rust: sync: lock: Add Lock::get_mut()
Subsystems (3)
PATCH 1/1 rust: sync: lock: Add Lock::get_mut()
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.
--- rust/kernel/sync/lock.rs | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)
rust/kernel/sync/lock.rs +37 -0
@@ -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 { +// SAFETY: the UnsafeCell guarantee that the self.data is not null. +// The `&mut self` guarantees the exclusive access to the underlying data, therefore it's +// safe to reborrow the inner data. +unsafe { &mut *self.data.get () } + } }impl <B :Backend >Lock <(),B > {
Signature · 1 line
2.34.1
Alice Ryhl
maintainerQuoted 45 lines · Guilherme Giacomo Simoes
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 <[email protected]>Signed-off-by Guilherme Giacomo Simoes <[email protected]>--- rust/kernel/sync/lock.rs | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)rust/kernel/sync/lock.rs +22
-0@@ -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 }) +/// })
rust/kernel/sync/lock.rs pub fn new(t: T, name: &'static CStr, key: &'static LockClassKey) -> impl PinIni · line 174
Quoted 10 lines
rust/kernel/sync/lock.rs +10
-0+/// } +/// } +/// +/// 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
Alice Ryhl <[email protected]> wrotes:
Quoted 5 lines
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>.
Yes you is right, we should avoid unsafe code. But how the self: Pin<&mut Self help us here?
The unsafe code at the get_mut() call place, is because of get_unchecked_mut. You probably already know, but this is unsafe because you need guarantee that the value is not move in memory. The get_unchecked_mut return a &mut T, (in this case return a &mut Example), and we need a reference to Example for access d field.
since we have access for d , we can get get_mut() without pinned d.
We need a way for get Example.d without get_unchecked_mut.
Thanks,
Guilherme