rust: locks: Add `get_mut` method to `Lock`
Subsystems (3)
PATCH v2 1/1 rust: locks: Add `get_mut` method to `Lock`
Having a mutable reference guarantees that no other threads have access to the lock, so we can take advantage of that to grant callers access to the protected data without the the cost of acquiring and releasing the locks. Since the lifetime of the data is tied to the mutable reference, the borrow checker guarantees that the usage is safe.
---
Changes in v2:
- Improved doc comment.
- Link to v1: https://lore.kernel.org/r/[email protected]
--- rust/kernel/sync/lock.rs | 7 +++++++ 1 file changed, 7 insertions(+)
rust/kernel/sync/lock.rs +7 -0
@@ -121,6 +121,13 @@ pub fn lock(&self) -> Guard<'_, T, B> {// SAFETY: The lock was just acquired. unsafe {Guard ::new (self, state) } } + +/// Gets the data contained in the lock +/// Having a mutable reference to the lock guarantees that no other threads have access to the lock. +/// Making it safe to get a mutable reference to the lock content. +pub fn get_mut (&mut self) -> &mut T { + self.data.get_mut () + } }/// A lock guard.
---
base-commit: 711cbfc717650532624ca9f56fbaf191bed56e67
change-id: 20240118-rust-locks-get-mut-c42072101d7a
Best regards,
Signature · 1 line
Mathys-Gasnier <[email protected]>
Alice Ryhl
maintainerrust/kernel/sync/lock.rs pub fn lock(&self) -> Guard<'_, T, B> { · line 130
Quoted 6 lines · On Mon, Feb 12, 2024 at 3:13 PM Mathys-Gasnier via B4 Relay…
rust/kernel/sync/lock.rs +6
-0+/// Gets the data contained in the lock +/// Having a mutable reference to the lock guarantees that no other threads have access to the lock. +/// Making it safe to get a mutable reference to the lock content. +pub fn get_mut (&mut self) -> &mut T { + self.data.get_mut () + }
It's impossible to call this method. You can never have a mutable reference to a Linux mutex because we pin our locks. At most, you can have a Pin<&mut Self>.
Alice
Quoted 10 lines · Alice Ryhl
rust/kernel/sync/lock.rs pub fn lock(&self) -> Guard<'_, T, B> { · line 130
Quoted 6 lines · On Mon, Feb 12, 2024 at 3:13 PM Mathys-Gasnier via B4 Relay…
rust/kernel/sync/lock.rs +6
-0+/// Gets the data contained in the lock +/// Having a mutable reference to the lock guarantees that no other threads have access to the lock. +/// Making it safe to get a mutable reference to the lock content. +pub fn get_mut (&mut self) -> &mut T { + self.data.get_mut () + }
Quoted 3 lines
It's impossible to call this method. You can never have a mutable reference to a Linux mutex because we pin our locks. At most, you can have a Pin<&mut Self>.
Perhaps you meant to say that it's impossible to call this method without unsafe blocks? From a Pin<&mut T>, we can call get_unchecked_mut to get an &mut T.
This is addressing issue 924 opened by Björn some time back. The idea here is that if there's a path where avoiding the lock/unlock calls (which are expensive because of the memory barriers) is performance critical, we can do it as long as we use an unsafe block.
Quoted 11 lines · Wedson Almeida Filho
Quoted 10 lines · Alice Ryhl
Quoted 6 lines · On Mon, Feb 12, 2024 at 3:13 PM Mathys-Gasnier via B4 Relay…
rust/kernel/sync/lock.rs +6
-0+/// Gets the data contained in the lock +/// Having a mutable reference to the lock guarantees that no other threads have access to the lock. +/// Making it safe to get a mutable reference to the lock content. +pub fn get_mut (&mut self) -> &mut T { + self.data.get_mut () + }
Quoted 7 lines
Quoted 3 lines
It's impossible to call this method. You can never have a mutable reference to a Linux mutex because we pin our locks. At most, you can have a Pin<&mut Self>.
Perhaps you meant to say that it's impossible to call this method without unsafe blocks? From a
Pin<&mut T>, we can callget_unchecked_mutto get an&mut T.
That is the wrong way to design this, since it forces an extra unsafe call. Instead this function's receiver type should be self: Pin<&mut Self>.
Signature · 2 lines
Cheers, Benno
Quoted 11 lines · On Mon, 12 Feb 2024 at 11:13, Mathys-Gasnier via B4 Relay…
From: Mathys-Gasnier <[email protected]>
Having a mutable reference guarantees that no other threads have access to the lock, so we can take advantage of that to grant callers access to the protected data without the the cost of acquiring and releasing the locks. Since the lifetime of the data is tied to the mutable reference, the borrow checker guarantees that the usage is safe.
Reviewed-by Martin Rodriguez Reboredo <[email protected]>Signed-off-by Mathys-Gasnier <[email protected]>