[RFC PATCH v5 4/6] rust: DmaFence: [RFC] Add Signaler

[Philipp Stanner <phasta@kernel.org>]

Depending on what the JobQueue locking design shall look like, it might
be necessary to be able to signal fences without having to access the
*locked* data structure the fences reside in.

Add a Signaler type to achieve that.

This type is not yet used in this patch series. The patch merely serves
showing the idea so that we have material to discuss.

Signed-off-by: Philipp Stanner <phasta@kernel.org>
---
 rust/kernel/dma_buf/dma_fence.rs | 49 ++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/rust/kernel/dma_buf/dma_fence.rs b/rust/kernel/dma_buf/dma_fence.rs
index b67121c7abd4..4e9b4a6a9471 100644
--- a/rust/kernel/dma_buf/dma_fence.rs
+++ b/rust/kernel/dma_buf/dma_fence.rs
@@ -590,6 +590,45 @@ unsafe fn dec_ref(ptr: NonNull<Self>) {
     }
 }
 
+/// An object that can signal an associated [`DriverFence`], independently of
+/// that one's lifetime.
+///
+/// Use with great caucion! Only the producer of a fence should ever be able to
+/// signal it.
+///
+/// This helper is necessary to signal DriverFences that are hidden behind locks
+/// which cannot be taken in certain situations.
+pub struct FenceSignaler {
+    fence: ARef<Fence>,
+}
+
+impl FenceSignaler {
+    /// Signal the associated [`DriverFence`].
+    pub fn signal(&self, res: Result) {
+        let fence = self.fence.lock();
+
+        // SAFETY: `fence` is valid because `self` is valid. The lock must be
+        // held, which we acquired directly above.
+        if !unsafe { bindings::dma_fence_test_signaled_flag(fence.as_raw()) } {
+            if let Err(err) = res {
+                // SAFETY: `fence` is valid because `self` is valid. The fence
+                // must not have been signaled yet, which we check directly above.
+                unsafe { bindings::dma_fence_set_error(fence.as_raw(), err.to_errno()) };
+            }
+            // SAFETY: `fence` is valid because `self` is valid. The lock must
+            // be held, which we acquired above.
+            unsafe { bindings::dma_fence_signal_locked(fence.as_raw()) };
+        }
+
+        // TODO: This should decrement the nr-of-unsignaled-fences tracker in fctx
+    }
+
+    /// Get the associated fence's sequence number.
+    pub fn seqno(&self) -> u64 {
+        self.fence.seqno()
+    }
+}
+
 // Necessary to guarantee that `inner` always comes first and can be freed by C.
 // Also useful for using casts instead of container_of().
 #[repr(C)]
@@ -805,6 +844,16 @@ pub fn as_fence(&self) -> &Fence {
         unsafe { Fence::from_raw(self.as_raw()) }
     }
 
+    /// Create a [`FenceSignaler`] associated with this `DriverFence`.
+    ///
+    /// Use with caution! Only the producer of a [`DriverFence`] should be able
+    /// to signal it.
+    pub fn new_signaler(&self) -> FenceSignaler {
+        FenceSignaler {
+            fence: ARef::from(self.as_fence()),
+        }
+    }
+
     /// Signal the fence. This will invoke all registered callbacks.
     pub fn signal(&self, res: Result) {
         let fence = self.as_fence().lock();
-- 
2.55.0