Re: [PATCH] rust: sync: lock: Add Lock::get_mut()

[Alice Ryhl]

On Fri, Jan 31, 2025 at 4:59 PM Guilherme Giacomo Simoes
<trintaeoitogc@xxxxxxxxx> wrote:
>
> At initialization where we can guarantee that we do not have multiple
> threads accessing the protected resource, blocking the resource in
> addition to being redundant, can cause unnecessary overhead.
> Add the Lock::get_mut() function for access the data without lock.
> Receive a mutable instance of Lock, and return a mutable reference to
> data because if the instance is mutable, the rust compiler guarantee the
> access control.
>
> Suggested-by: Björn Roy Baron <bjorn3_gh@xxxxxxxxxxxxxx>
> Signed-off-by: Guilherme Giacomo Simoes <trintaeoitogc@xxxxxxxxx>
> ---
>  rust/kernel/sync/lock.rs | 37 +++++++++++++++++++++++++++++++++++++
>  1 file changed, 37 insertions(+)
>
> diff --git a/rust/kernel/sync/lock.rs b/rust/kernel/sync/lock.rs
> index eb80048e0110..f1e29820ce99 100644
> --- a/rust/kernel/sync/lock.rs
> +++ b/rust/kernel/sync/lock.rs
> @@ -140,6 +140,43 @@ pub fn new(t: T, name: &'static CStr, key: &'static LockClassKey) -> impl PinIni
>              }),
>          })
>      }
> +
> +    /// Get a mutable reference to data
> +    ///
> +    /// ```
> +    /// use kernel::sync::{new_mutex, Mutex};
> +    ///
> +    /// struct Inner {
> +    ///     a: u32,
> +    /// }
> +    ///
> +    /// #[pin_data]
> +    /// struct Example {
> +    ///     #[pin]
> +    ///     d: Mutex<Inner>,
> +    /// }
> +    ///
> +    /// impl Example {
> +    ///     fn new() -> impl PinInit<Self> {
> +    ///         pin_init!(Self {
> +    ///             // This new_mutex! can be anothers locks like new_spinlock!()
> +    ///             d <- new_mutex!(Inner { a: 20 })
> +    ///         })
> +    ///     }
> +    /// }
> +    ///
> +    /// let mut pin = KBox::pin_init(Example::new(), GFP_KERNEL)?;
> +    /// let mut_pin = pin.as_mut();
> +    ///
> +    /// let data = unsafe { Pin::get_unchecked_mut(mut_pin).d.get_mut() };
> +    /// assert_eq!(data.a, 20);
> +    /// ```
> +    pub fn get_mut(&mut self) -> &mut T {

I maintain my objection that this function cannot be correctly called.
Yes, if you use dubious unsafe code, you can call it, but we shouldn't
do that.

At best, you could change this method to take `self: Pin<&mut Self>`.

Alice