[v6] rust: add `ww_mutex` support

[PATCH v6 7/7] add KUnit coverage on ww_mutex/exec implementation

Posted by Onur Özkan 4 weeks, 1 day ago

Adds coverage for `ww_mutex/exec.rs` implementation.

Signed-off-by: Onur Özkan <work@onurozkan.dev>
---
 rust/kernel/sync/lock/ww_mutex/exec.rs | 148 +++++++++++++++++++++++++
 1 file changed, 148 insertions(+)

diff --git a/rust/kernel/sync/lock/ww_mutex/exec.rs b/rust/kernel/sync/lock/ww_mutex/exec.rs
index 2f1fc540f0b8..543c5218232a 100644
--- a/rust/kernel/sync/lock/ww_mutex/exec.rs
+++ b/rust/kernel/sync/lock/ww_mutex/exec.rs
@@ -174,3 +174,151 @@ fn cleanup_on_deadlock(&mut self) -> Result {
         Ok(())
     }
 }
+
+#[kunit_tests(rust_kernel_ww_exec)]
+mod tests {
+    use crate::c_str;
+    use crate::prelude::*;
+    use crate::sync::Arc;
+    use pin_init::stack_pin_init;
+
+    use super::*;
+
+    #[test]
+    fn test_exec_context_basic_lock_unlock() -> Result {
+        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("exec_ctx_basic")));
+
+        let mutex = Arc::pin_init(WwMutex::new(10, &class), GFP_KERNEL)?;
+        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
+
+        ctx.lock(&mutex)?;
+        ctx.with_locked(&mutex, |v| {
+            assert_eq!(*v, 10);
+        })?;
+
+        ctx.release_all_locks();
+        assert!(!mutex.is_locked());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_exec_context_with_locked_mutates_data() -> Result {
+        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("exec_ctx_with_locked")));
+
+        let mutex = Arc::pin_init(WwMutex::new(5, &class), GFP_KERNEL)?;
+        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
+
+        ctx.lock(&mutex)?;
+
+        ctx.with_locked(&mutex, |v| {
+            assert_eq!(*v, 5);
+            // Increment the value.
+            *v += 7;
+        })?;
+
+        ctx.with_locked(&mutex, |v| {
+            // Check that mutation took effect.
+            assert_eq!(*v, 12);
+        })?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_lock_all_success() -> Result {
+        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("lock_all_ok")));
+
+        let mutex1 = Arc::pin_init(WwMutex::new(1, &class), GFP_KERNEL)?;
+        let mutex2 = Arc::pin_init(WwMutex::new(2, &class), GFP_KERNEL)?;
+        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
+
+        let res = ctx.lock_all(
+            |ctx| {
+                let _ = ctx.lock(&mutex1)?;
+                let _ = ctx.lock(&mutex2)?;
+                Ok(())
+            },
+            |ctx| {
+                ctx.with_locked(&mutex1, |v| *v += 10)?;
+                ctx.with_locked(&mutex2, |v| *v += 20)?;
+                Ok((
+                    ctx.with_locked(&mutex1, |v| *v)?,
+                    ctx.with_locked(&mutex2, |v| *v)?,
+                ))
+            },
+        )?;
+
+        assert_eq!(res, (11, 22));
+        assert!(!mutex1.is_locked());
+        assert!(!mutex2.is_locked());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_with_different_input_type() -> Result {
+        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("lock_all_ok")));
+
+        let mutex1 = Arc::pin_init(WwMutex::new(1, &class), GFP_KERNEL)?;
+        let mutex2 = Arc::pin_init(WwMutex::new("hello", &class), GFP_KERNEL)?;
+        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
+
+        ctx.lock_all(
+            |ctx| {
+                ctx.lock(&mutex1)?;
+                ctx.lock(&mutex2)?;
+                Ok(())
+            },
+            |ctx| {
+                ctx.with_locked(&mutex1, |v| assert_eq!(*v, 1))?;
+                ctx.with_locked(&mutex2, |v| assert_eq!(*v, "hello"))?;
+                Ok(())
+            },
+        )?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_lock_all_retries_on_deadlock() -> Result {
+        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("lock_all_retry")));
+
+        let mutex = Arc::pin_init(WwMutex::new(99, &class), GFP_KERNEL)?;
+        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
+        let mut first_try = true;
+
+        let res = ctx.lock_all(
+            |ctx| {
+                if first_try {
+                    first_try = false;
+                    // Simulate deadlock on first attempt.
+                    return Err(EDEADLK);
+                }
+                ctx.lock(&mutex)
+            },
+            |ctx| {
+                ctx.with_locked(&mutex, |v| {
+                    *v += 1;
+                    *v
+                })
+            },
+        )?;
+
+        assert_eq!(res, 100);
+        Ok(())
+    }
+
+    #[test]
+    fn test_with_locked_on_unlocked_mutex() -> Result {
+        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("with_unlocked_mutex")));
+
+        let mutex = Arc::pin_init(WwMutex::new(5, &class), GFP_KERNEL)?;
+        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
+
+        let ecode = ctx.with_locked(&mutex, |_v| {}).unwrap_err();
+        assert_eq!(EINVAL, ecode);
+
+        Ok(())
+    }
+}
--
2.50.0

Re: [PATCH v6 7/7] add KUnit coverage on ww_mutex/exec implementation

Posted by Elle Rhumsaa 3 weeks, 6 days ago

On Wed, Sep 03, 2025 at 04:13:13PM +0300, Onur Özkan wrote:
> Adds coverage for `ww_mutex/exec.rs` implementation.
> 
> Signed-off-by: Onur Özkan <work@onurozkan.dev>
> ---
>  rust/kernel/sync/lock/ww_mutex/exec.rs | 148 +++++++++++++++++++++++++
>  1 file changed, 148 insertions(+)
> 
> diff --git a/rust/kernel/sync/lock/ww_mutex/exec.rs b/rust/kernel/sync/lock/ww_mutex/exec.rs
> index 2f1fc540f0b8..543c5218232a 100644
> --- a/rust/kernel/sync/lock/ww_mutex/exec.rs
> +++ b/rust/kernel/sync/lock/ww_mutex/exec.rs
> @@ -174,3 +174,151 @@ fn cleanup_on_deadlock(&mut self) -> Result {
>          Ok(())
>      }
>  }
> +
> +#[kunit_tests(rust_kernel_ww_exec)]
> +mod tests {
> +    use crate::c_str;
> +    use crate::prelude::*;
> +    use crate::sync::Arc;
> +    use pin_init::stack_pin_init;
> +
> +    use super::*;
> +
> +    #[test]
> +    fn test_exec_context_basic_lock_unlock() -> Result {
> +        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("exec_ctx_basic")));
> +
> +        let mutex = Arc::pin_init(WwMutex::new(10, &class), GFP_KERNEL)?;
> +        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
> +
> +        ctx.lock(&mutex)?;
> +        ctx.with_locked(&mutex, |v| {
> +            assert_eq!(*v, 10);
> +        })?;
> +
> +        ctx.release_all_locks();
> +        assert!(!mutex.is_locked());
> +
> +        Ok(())
> +    }
> +
> +    #[test]
> +    fn test_exec_context_with_locked_mutates_data() -> Result {
> +        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("exec_ctx_with_locked")));
> +
> +        let mutex = Arc::pin_init(WwMutex::new(5, &class), GFP_KERNEL)?;
> +        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
> +
> +        ctx.lock(&mutex)?;
> +
> +        ctx.with_locked(&mutex, |v| {
> +            assert_eq!(*v, 5);
> +            // Increment the value.
> +            *v += 7;
> +        })?;
> +
> +        ctx.with_locked(&mutex, |v| {
> +            // Check that mutation took effect.
> +            assert_eq!(*v, 12);
> +        })?;
> +
> +        Ok(())
> +    }
> +
> +    #[test]
> +    fn test_lock_all_success() -> Result {
> +        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("lock_all_ok")));
> +
> +        let mutex1 = Arc::pin_init(WwMutex::new(1, &class), GFP_KERNEL)?;
> +        let mutex2 = Arc::pin_init(WwMutex::new(2, &class), GFP_KERNEL)?;
> +        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
> +
> +        let res = ctx.lock_all(
> +            |ctx| {
> +                let _ = ctx.lock(&mutex1)?;
> +                let _ = ctx.lock(&mutex2)?;
> +                Ok(())
> +            },
> +            |ctx| {
> +                ctx.with_locked(&mutex1, |v| *v += 10)?;
> +                ctx.with_locked(&mutex2, |v| *v += 20)?;
> +                Ok((
> +                    ctx.with_locked(&mutex1, |v| *v)?,
> +                    ctx.with_locked(&mutex2, |v| *v)?,
> +                ))
> +            },
> +        )?;
> +
> +        assert_eq!(res, (11, 22));
> +        assert!(!mutex1.is_locked());
> +        assert!(!mutex2.is_locked());
> +
> +        Ok(())
> +    }
> +
> +    #[test]
> +    fn test_with_different_input_type() -> Result {
> +        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("lock_all_ok")));
> +
> +        let mutex1 = Arc::pin_init(WwMutex::new(1, &class), GFP_KERNEL)?;
> +        let mutex2 = Arc::pin_init(WwMutex::new("hello", &class), GFP_KERNEL)?;
> +        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
> +
> +        ctx.lock_all(
> +            |ctx| {
> +                ctx.lock(&mutex1)?;
> +                ctx.lock(&mutex2)?;
> +                Ok(())
> +            },
> +            |ctx| {
> +                ctx.with_locked(&mutex1, |v| assert_eq!(*v, 1))?;
> +                ctx.with_locked(&mutex2, |v| assert_eq!(*v, "hello"))?;
> +                Ok(())
> +            },
> +        )?;
> +
> +        Ok(())
> +    }
> +
> +    #[test]
> +    fn test_lock_all_retries_on_deadlock() -> Result {
> +        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("lock_all_retry")));
> +
> +        let mutex = Arc::pin_init(WwMutex::new(99, &class), GFP_KERNEL)?;
> +        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
> +        let mut first_try = true;
> +
> +        let res = ctx.lock_all(
> +            |ctx| {
> +                if first_try {
> +                    first_try = false;
> +                    // Simulate deadlock on first attempt.
> +                    return Err(EDEADLK);
> +                }
> +                ctx.lock(&mutex)
> +            },
> +            |ctx| {
> +                ctx.with_locked(&mutex, |v| {
> +                    *v += 1;
> +                    *v
> +                })
> +            },
> +        )?;
> +
> +        assert_eq!(res, 100);
> +        Ok(())
> +    }
> +
> +    #[test]
> +    fn test_with_locked_on_unlocked_mutex() -> Result {
> +        stack_pin_init!(let class = WwClass::new_wound_wait(c_str!("with_unlocked_mutex")));
> +
> +        let mutex = Arc::pin_init(WwMutex::new(5, &class), GFP_KERNEL)?;
> +        let mut ctx = KBox::pin_init(ExecContext::new(&class)?, GFP_KERNEL)?;
> +
> +        let ecode = ctx.with_locked(&mutex, |_v| {}).unwrap_err();
> +        assert_eq!(EINVAL, ecode);
> +
> +        Ok(())
> +    }
> +}
> --
> 2.50.0
> 
> 

Thanks for adding these tests!

Reviewed-by: Elle Rhumsaa <elle@weathered-steel.dev>

[PATCH v6 1/7] rust: add C wrappers for ww_mutex inline functions
[PATCH v6 2/7] rust: implement `WwClass` for ww_mutex support
[PATCH v6 3/7] rust: implement `WwMutex`, `WwAcquireCtx` and `WwMutexGuard`
[PATCH v6 4/7] add KUnit coverage on Rust ww_mutex implementation
[PATCH v6 5/7] rust: ww_mutex: add context-free locking functions
[PATCH v6 6/7] rust: ww_mutex/exec: add high-level API
[PATCH v6 7/7] add KUnit coverage on ww_mutex/exec implementation