| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20260203081403.68733-6-phasta@kernel.org>
Date: Tue, 3 Feb 2026 09:14:03 +0100
From: Philipp Stanner <phasta@...nel.org>
To: David Airlie <airlied@...il.com>,
Simona Vetter <simona@...ll.ch>,
Danilo Krummrich <dakr@...nel.org>,
Alice Ryhl <aliceryhl@...gle.com>,
Gary Guo <gary@...yguo.net>,
Benno Lossin <lossin@...nel.org>,
Christian König <christian.koenig@....com>,
Boris Brezillon <boris.brezillon@...labora.com>,
Daniel Almeida <daniel.almeida@...labora.com>,
Joel Fernandes <joelagnelf@...dia.com>
Cc: linux-kernel@...r.kernel.org,
dri-devel@...ts.freedesktop.org,
rust-for-linux@...r.kernel.org,
Philipp Stanner <phasta@...nel.org>
Subject: [RFC PATCH 4/4] samples: rust: Add jobqueue tester
The DRM Jobqueue is a new piece of (highly asynchronous) infrastructure
for submitting jobs to graphics processing units (GPUs).
It is difficult to test such a mechanism purely with unit tests. Thus,
provide this driver solely for testing drm::Jobqueue.
Signed-off-by: Philipp Stanner <phasta@...nel.org>
---
samples/rust/Kconfig | 11 ++
samples/rust/Makefile | 1 +
samples/rust/rust_jobqueue_tester.rs | 180 +++++++++++++++++++++++++++
3 files changed, 192 insertions(+)
create mode 100644 samples/rust/rust_jobqueue_tester.rs
diff --git a/samples/rust/Kconfig b/samples/rust/Kconfig
index c376eb899b7a..a9a3a671bb0b 100644
--- a/samples/rust/Kconfig
+++ b/samples/rust/Kconfig
@@ -145,4 +145,15 @@ config SAMPLE_RUST_HOSTPROGS
If unsure, say N.
+config SAMPLE_RUST_JOBQUEUE_TESTER
+ tristate "Jobqueue Tester"
+ select JOBQUEUE_TESTER
+ help
+ This option builds the Rust Jobqueue Tester.
+
+ To compile this as a module, choose M here:
+ the module will be called rust_jobqueue_tester.
+
+ If unsure, say N.
+
endif # SAMPLES_RUST
diff --git a/samples/rust/Makefile b/samples/rust/Makefile
index cf8422f8f219..9cc1f021dc39 100644
--- a/samples/rust/Makefile
+++ b/samples/rust/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_SAMPLE_RUST_DRIVER_USB) += rust_driver_usb.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_FAUX) += rust_driver_faux.o
obj-$(CONFIG_SAMPLE_RUST_DRIVER_AUXILIARY) += rust_driver_auxiliary.o
obj-$(CONFIG_SAMPLE_RUST_CONFIGFS) += rust_configfs.o
+obj-$(CONFIG_SAMPLE_RUST_JOBQUEUE_TESTER) += rust_jobqueue_tester.o
rust_print-y := rust_print_main.o rust_print_events.o
diff --git a/samples/rust/rust_jobqueue_tester.rs b/samples/rust/rust_jobqueue_tester.rs
new file mode 100644
index 000000000000..c2590a1b4f8a
--- /dev/null
+++ b/samples/rust/rust_jobqueue_tester.rs
@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Small example demonstrating how to use [`drm::Jobqueue`].
+
+use kernel::prelude::*;
+use kernel::sync::{DmaFenceCtx, DmaFence, Arc};
+use kernel::drm::jq::{Job, Jobqueue};
+use kernel::types::{ARef};
+use kernel::time::{delay::fsleep, Delta};
+use kernel::workqueue::{self, impl_has_work, new_work, Work, WorkItem};
+
+module! {
+ type: RustJobqueueTester,
+ name: "rust_jobqueue_tester",
+ authors: ["Philipp Stanner"],
+ description: "Rust minimal sample",
+ license: "GPL",
+}
+
+#[pin_data]
+struct GPUWorker {
+ hw_fence: ARef<DmaFence<i32>>,
+ #[pin]
+ work: Work<GPUWorker>,
+}
+
+impl GPUWorker {
+ fn new(
+ hw_fence: ARef<DmaFence<i32>>,
+ ) -> Result<Arc<Self>> {
+ Arc::pin_init(
+ pin_init!(Self {hw_fence, work <- new_work!("Jobqueue::GPUWorker")}),
+ GFP_KERNEL,
+ )
+ }
+}
+
+impl_has_work! {
+ impl HasWork<Self> for GPUWorker { self.work }
+}
+
+impl WorkItem for GPUWorker {
+ type Pointer = Arc<GPUWorker>;
+
+ fn run(this: Arc<GPUWorker>) {
+ fsleep(Delta::from_secs(1));
+ this.hw_fence.signal().unwrap();
+ }
+}
+
+fn run_job(job: &Pin<&mut Job<Arc<DmaFenceCtx>>>) -> ARef<DmaFence<i32>> {
+ let fence = job.data.as_arc_borrow().new_fence(42 as i32).unwrap();
+
+ let gpu_worker = GPUWorker::new(fence.clone()).unwrap();
+ let _ = workqueue::system().enqueue(gpu_worker);
+
+ fence
+}
+
+struct RustJobqueueTester { }
+
+impl kernel::Module for RustJobqueueTester {
+ fn init(_module: &'static ThisModule) -> Result<Self> {
+ pr_info!("Rust Jobqueue Tester (init)\n");
+ pr_info!("Am I built-in? {}\n", !cfg!(MODULE));
+
+ let dep_fctx = DmaFenceCtx::new()?;
+ let hw_fctx = DmaFenceCtx::new()?;
+ let jq = Jobqueue::new(1_000_000, run_job)?;
+
+
+ pr_info!("Test 1: Test submitting two jobs without dependencies.\n");
+ let job1 = Job::new(1, hw_fctx.clone())?;
+ let job2 = Job::new(1, hw_fctx.clone())?;
+
+ let fence1 = jq.submit_job(job1)?;
+ let fence2 = jq.submit_job(job2)?;
+
+ while !fence1.is_signaled() || !fence2.is_signaled() {
+ fsleep(Delta::from_secs(2));
+ }
+ pr_info!("Test 1 succeeded.\n");
+
+
+ pr_info!("Test 2: Test submitting a job with already-fullfilled dependency.\n");
+ let mut job3 = Job::new(1, hw_fctx.clone())?;
+ job3.add_dependency(fence1)?;
+
+ let fence3 = jq.submit_job(job3)?;
+ fsleep(Delta::from_secs(2));
+ if !fence3.is_signaled() {
+ pr_info!("Test 2 failed.\n");
+ return Err(EAGAIN);
+ }
+ pr_info!("Test 2 succeeded.\n");
+
+
+ pr_info!("Test 3: Test that a job with unfullfilled dependency gets never run.\n");
+ let unsignaled_fence = dep_fctx.as_arc_borrow().new_fence(9001 as i32)?;
+
+ let mut job4 = Job::new(1, hw_fctx.clone())?;
+ job4.add_dependency(unsignaled_fence.clone())?;
+
+ let blocked_job_fence = jq.submit_job(job4)?;
+ fsleep(Delta::from_secs(2));
+ if blocked_job_fence.is_signaled() {
+ pr_info!("Test 3 failed.\n");
+ return Err(EAGAIN);
+ }
+ pr_info!("Test 3 succeeded.\n");
+
+
+ pr_info!("Test 4: Test whether Test 3's blocked job can be unblocked.\n");
+ unsignaled_fence.signal()?;
+ while !blocked_job_fence.is_signaled() {
+ fsleep(Delta::from_secs(2));
+ }
+ pr_info!("Test 4 succeeded.\n");
+
+
+ pr_info!("Test 5: Submit a bunch of unblocked jobs, then a blocked one, then an unblocked one.\n");
+ let job1 = Job::new(1, hw_fctx.clone())?;
+ let job2 = Job::new(1, hw_fctx.clone())?;
+ let mut job3 = Job::new(1, hw_fctx.clone())?;
+ let job4 = Job::new(1, hw_fctx.clone())?;
+ let job5 = Job::new(1, hw_fctx.clone())?;
+
+ let unsignaled_fence1 = dep_fctx.as_arc_borrow().new_fence(9001 as i32)?;
+ let unsignaled_fence2 = dep_fctx.as_arc_borrow().new_fence(9001 as i32)?;
+ let unsignaled_fence3 = dep_fctx.as_arc_borrow().new_fence(9001 as i32)?;
+ job3.add_dependency(unsignaled_fence1.clone())?;
+ job3.add_dependency(unsignaled_fence2.clone())?;
+ job3.add_dependency(unsignaled_fence3.clone())?;
+
+ let fence1 = jq.submit_job(job1)?;
+ let fence2 = jq.submit_job(job2)?;
+ let fence3 = jq.submit_job(job3)?;
+
+ fsleep(Delta::from_secs(2));
+ if fence3.is_signaled() || !fence1.is_signaled() || !fence2.is_signaled() {
+ pr_info!("Test 5 failed.\n");
+ return Err(EAGAIN);
+ }
+
+ unsignaled_fence1.signal()?;
+ unsignaled_fence3.signal()?;
+ fsleep(Delta::from_secs(2));
+ if fence3.is_signaled() {
+ pr_info!("Test 5 failed.\n");
+ return Err(EAGAIN);
+ }
+
+ unsignaled_fence2.signal()?;
+ fsleep(Delta::from_secs(2));
+ if !fence3.is_signaled() {
+ pr_info!("Test 5 failed.\n");
+ return Err(EAGAIN);
+ }
+
+ let fence4 = jq.submit_job(job4)?;
+ let fence5 = jq.submit_job(job5)?;
+
+ fsleep(Delta::from_secs(2));
+
+ if !fence4.is_signaled() || !fence5.is_signaled() {
+ pr_info!("Test 5 failed.\n");
+ return Err(EAGAIN);
+ }
+ pr_info!("Test 5 succeeded.\n");
+
+
+ Ok(RustJobqueueTester { })
+ }
+}
+
+impl Drop for RustJobqueueTester {
+ fn drop(&mut self) {
+ pr_info!("Rust Jobqueue Tester (exit)\n");
+ }
+}
--
2.49.0
Powered by blists - more mailing lists