rust: workqueue: remove HasWork::OFFSET
Subsystems (4)
cover rust: workqueue: remove HasWork::OFFSET
The bulk of this change occurs in the latter commit, please see its message for details. The first commit was developed in another series not yet shared with the list but was picked into this series to allow HasWork::work_container_of to return container_of! without the need to cast from *const Self to *mut Self.
---
Tamir Duberstein (2):
rust: retain pointer mut-ness in container_of!
rust: workqueue: remove HasWork::OFFSET
rust/kernel/lib.rs | 5 ++--- rust/kernel/pci.rs | 2 +- rust/kernel/platform.rs | 2 +- rust/kernel/rbtree.rs | 23 ++++++++++------------- rust/kernel/workqueue.rs | 45 ++++++++++++--------------------------------- 5 files changed, 26 insertions(+), 51 deletions(-)
---
base-commit: ff64846bee0e7e3e7bc9363ebad3bab42dd27e24
change-id: 20250307-no-offset-e463667a72fb
Best regards,
Signature · 1 line
Tamir Duberstein <[email protected]>
PATCH 1/2 rust: retain pointer mut-ness in `container_of!`
Avoid casting the input pointer to *const _, allowing the output pointer to be *mut if the input is *mut. This allows a number of *const to *mut conversions to be removed at the cost of slightly worse ergonomics when the macro is used with a reference rather than a pointer; the only example of this was in the macro's own doctest.
--- rust/kernel/lib.rs | 5 ++--- rust/kernel/pci.rs | 2 +- rust/kernel/platform.rs | 2 +- rust/kernel/rbtree.rs | 23 ++++++++++------------- 4 files changed, 14 insertions(+), 18 deletions(-)
rust/kernel/lib.rs +2 -3
@@ -187,7 +187,7 @@ fn panic(info: &core::panic::PanicInfo<'_>) -> ! {/// } /// /// let test = Test { a: 10, b: 20 }; -/// let b_ptr = &test.b; +/// let b_ptr: *const _ = &test.b; /// // SAFETY: The pointer points at the `b` field of a `Test`, so the resulting pointer will be /// // in-bounds of the same allocation as `b_ptr`. /// let test_alias = unsafe { container_of!(b_ptr, Test, b) };
@@ -196,9 +196,8 @@ fn panic(info: &core::panic::PanicInfo<'_>) -> ! {#[macro_export] macro_rules! container_of { ($ptr:expr, $type:ty, $($f:tt)*) => {{ -let ptr = $ptras *const _ as *const u8 ;let offset:usize = ::core::mem::offset_of!($type , $($f)*); - ptr.sub (offset)as *const $type + $ptr.byte_sub (offset).cast ::<$type>() }} }
rust/kernel/pci.rs +1 -1
@@ -364,7 +364,7 @@ pub unsafe fn from_dev(dev: ARef<device::Device>) -> Self {fn as_raw (&self) -> *mut bindings::pci_dev {// SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device` // embedded in `struct pci_dev`. -unsafe {container_of! (self.0 .as_raw (), bindings::pci_dev, dev)as _ } +unsafe {container_of! (self.0 .as_raw (), bindings::pci_dev, dev) } }/// Returns the PCI vendor ID.
rust/kernel/platform.rs +1 -1
@@ -189,7 +189,7 @@ unsafe fn from_dev(dev: ARef<device::Device>) -> Self {fn as_raw (&self) -> *mut bindings::platform_device {// SAFETY: By the type invariant `self.0.as_raw` is a pointer to the `struct device` // embedded in `struct platform_device`. -unsafe {container_of! (self.0 .as_raw (), bindings::platform_device, dev) }.cast_mut () +unsafe {container_of! (self.0 .as_raw (), bindings::platform_device, dev) } } }
rust/kernel/rbtree.rs +10 -13
@@ -424,7 +424,7 @@ pub fn cursor_lower_bound(&mut self, key: &K) -> Option<Cursor<'_, K, V>>while !node.is_null () {// SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node<K, V>` objects. -let this =unsafe {container_of! (node,Node <K ,V >, links) }.cast_mut (); +let this =unsafe {container_of! (node,Node <K ,V >, links) };// SAFETY: `this` is a non-null node so it is valid by the type invariants. let this_key =unsafe { &(*this).key };// SAFETY: `node` is a non-null node so it is valid by the type invariants.
@@ -496,7 +496,7 @@ fn drop(&mut self) {// but it is not observable. The loop invariant is still maintained. // SAFETY: `this` is valid per the loop invariant. -unsafe {drop (KBox ::from_raw (this.cast_mut ())) }; +unsafe {drop (KBox ::from_raw (this)) }; } } }
@@ -761,7 +761,7 @@ pub fn remove_current(self) -> (Option<Self>, RBTreeNode<K, V>) {let next = self.get_neighbor_raw (Direction ::Next );// SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node<K, V>` objects. -let this =unsafe {container_of! (self.current.as_ptr (),Node <K ,V >, links) }.cast_mut (); +let this =unsafe {container_of! (self.current.as_ptr (),Node <K ,V >, links) };// SAFETY: `this` is valid by the type invariants as described above. let node =unsafe {KBox ::from_raw (this) };let node =RBTreeNode { node };
@@ -806,7 +806,7 @@ fn remove_neighbor(&mut self, direction: Direction) -> Option<RBTreeNode<K, V>>unsafe { bindings::rb_erase (neighbor,addr_of_mut! (self.tree.root)) };// SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node<K, V>` objects. -let this =unsafe {container_of! (neighbor,Node <K ,V >, links) }.cast_mut (); +let this =unsafe {container_of! (neighbor,Node <K ,V >, links) };// SAFETY: `this` is valid by the type invariants as described above. let node =unsafe {KBox ::from_raw (this) };return Some (RBTreeNode { node });
@@ -912,7 +912,7 @@ unsafe fn to_key_value_mut<'b>(node: NonNull<bindings::rb_node>) -> (&'b K, &'bunsafe fn to_key_value_raw <'b>(node:NonNull <bindings::rb_node >) -> (&'bK , *mut V ) {// SAFETY: By the type invariant of `Self`, all non-null `rb_node` pointers stored in `self` // point to the links field of `Node<K, V>` objects. -let this =unsafe {container_of! (node.as_ptr (),Node <K ,V >, links) }.cast_mut (); +let this =unsafe {container_of! (node.as_ptr (),Node <K ,V >, links) };// SAFETY: The passed `node` is the current node or a non-null neighbor, // thus `this` is valid by the type invariants. let k =unsafe { &(*this).key };
@@ -1021,7 +1021,7 @@ fn next(&mut self) -> Option<Self::Item> {// SAFETY: By the type invariant of `IterRaw`, `self.next` is a valid node in an `RBTree`, // and by the type invariant of `RBTree`, all nodes point to the links field of `Node<K, V>` objects. -let cur =unsafe {container_of! (self.next,Node <K ,V >, links) }.cast_mut (); +let cur =unsafe {container_of! (self.next,Node <K ,V >, links) };// SAFETY: `self.next` is a valid tree node by the type invariants. self.next =unsafe { bindings::rb_next (self.next) };
@@ -1216,7 +1216,7 @@ pub fn get_mut(&mut self) -> &mut V {// SAFETY: // - `self.node_links` is a valid pointer to a node in the tree. // - We have exclusive access to the underlying tree, and can thus give out a mutable reference. -unsafe { &mut (*(container_of! (self.node_links,Node <K ,V >, links).cast_mut ())).value } +unsafe { &mut (*(container_of! (self.node_links,Node <K ,V >, links))).value } }/// Converts the entry into a mutable reference to its value.
@@ -1226,7 +1226,7 @@ pub fn into_mut(self) -> &'a mut V {// SAFETY: // - `self.node_links` is a valid pointer to a node in the tree. // - This consumes the `&'a mut RBTree<K, V>`, therefore it can give out a mutable reference that lives for `'a`. -unsafe { &mut (*(container_of! (self.node_links,Node <K ,V >, links).cast_mut ())).value } +unsafe { &mut (*(container_of! (self.node_links,Node <K ,V >, links))).value } }/// Remove this entry from the [`RBTree`].
@@ -1239,9 +1239,7 @@ pub fn remove_node(self) -> RBTreeNode<K, V> {RBTreeNode {// SAFETY: The node was a node in the tree, but we removed it, so we can convert it // back into a box. - node:unsafe { -KBox ::from_raw (container_of! (self.node_links,Node <K ,V >, links).cast_mut ()) - }, + node:unsafe {KBox ::from_raw (container_of! (self.node_links,Node <K ,V >, links)) }, } }
@@ -1272,8 +1270,7 @@ fn replace(self, node: RBTreeNode<K, V>) -> RBTreeNode<K, V> {// SAFETY: // - `self.node_ptr` produces a valid pointer to a node in the tree. // - Now that we removed this entry from the tree, we can convert the node to a box. -let old_node = -unsafe {KBox ::from_raw (container_of! (self.node_links,Node <K ,V >, links).cast_mut ()) }; +let old_node =unsafe {KBox ::from_raw (container_of! (self.node_links,Node <K ,V >, links)) };RBTreeNode { node: old_node } }
Signature · 1 line
2.48.1
Re: [PATCH 1/2] rust: retain pointer mut-ness in `container_of!`
Quoted 7 lines · Tamir Duberstein
Avoid casting the input pointer to
*const _, allowing the output pointer to be*mutif the input is*mut. This allows a number of*constto*mutconversions to be removed at the cost of slightly worse ergonomics when the macro is used with a reference rather than a pointer; the only example of this was in the macro's own doctest.Signed-off-by Tamir Duberstein <[email protected]>
---
Cheers,
Benno
Quoted 6 lines
--- rust/kernel/lib.rs | 5 ++--- rust/kernel/pci.rs | 2 +- rust/kernel/platform.rs | 2 +- rust/kernel/rbtree.rs | 23 ++++++++++------------- 4 files changed, 14 insertions(+), 18 deletions(-)
Re: [PATCH 1/2] rust: retain pointer mut-ness in `container_of!`
In reply to Tamir DubersteinQuoted 7 lines · Tamir Duberstein
Avoid casting the input pointer to
*const _, allowing the output pointer to be*mutif the input is*mut. This allows a number of*constto*mutconversions to be removed at the cost of slightly worse ergonomics when the macro is used with a reference rather than a pointer; the only example of this was in the macro's own doctest.Signed-off-by Tamir Duberstein <[email protected]>
PATCH 2/2 rust: workqueue: remove HasWork::OFFSET
In reply to Tamir DubersteinImplement HasWork::work_container_of in impl_has_work!, narrowing the interface of HasWork and replacing pointer arithmetic with container_of!. Remove the provided implementation of HasWork::get_work_offset without replacement; an implementation is already generated in impl_has_work!. Remove the Self: Sized bound on HasWork::work_container_of which was apparently necessary to access OFFSET as OFFSET no longer exists.
A similar API change was discussed on the hrtimer series[1].
--- rust/kernel/workqueue.rs | 45 ++++++++++++--------------------------------- 1 file changed, 12 insertions(+), 33 deletions(-)
rust/kernel/workqueue.rs +12 -33
@@ -429,51 +429,23 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct {/// /// # Safety /// -/// The [`OFFSET`] constant must be the offset of a field in `Self` of type [`Work<T, ID>`]. The -/// methods on this trait must have exactly the behavior that the definitions given below have. +/// The methods on this trait must have exactly the behavior that the definitions given below have. /// /// [`impl_has_work!`]: crate::impl_has_work -/// [`OFFSET`]: HasWork::OFFSET pub unsafe trait HasWork <T ,const ID :u64 =0 > { -/// The offset of the [`Work<T, ID>`] field. -const OFFSET :usize ; - -/// Returns the offset of the [`Work<T, ID>`] field. -/// -/// This method exists because the [`OFFSET`] constant cannot be accessed if the type is not -/// [`Sized`]. -/// -/// [`OFFSET`]: HasWork::OFFSET -#[inline] -fn get_work_offset (&self) ->usize { -Self ::OFFSET - } -/// Returns a pointer to the [`Work<T, ID>`] field. /// /// # Safety /// /// The provided pointer must point at a valid struct of type `Self`. -#[inline] -unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID > { -// SAFETY: The caller promises that the pointer is valid. -unsafe { (ptras *mut u8 ).add (Self ::OFFSET )as *mut Work <T ,ID > } - } +unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID >;/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`. -#[inline] -unsafe fn work_container_of (ptr: *mut Work <T ,ID >) -> *mut Self -where -Self :Sized , - { -// SAFETY: The caller promises that the pointer points at a field of the right type in the -// right kind of struct. -unsafe { (ptras *mut u8 ).sub (Self ::OFFSET )as *mut Self } - } +unsafe fn work_container_of (ptr: *mut Work <T ,ID >) -> *mut Self ; }/// Used to safely implement the [`HasWork<T, ID>`] trait.
@@ -504,8 +476,6 @@ macro_rules! impl_has_work {// SAFETY: The implementation of `raw_get_work` only compiles if the field has the right // type. unsafe impl$(<$($generics)+>)? $crate::workqueue::HasWork<$work_type $(, $id)?> for $self { - const OFFSET: usize = ::core::mem::offset_of!(Self, $field) as usize; - #[inline] unsafe fn raw_get_work(ptr: *mut Self) -> *mut $crate::workqueue::Work<$work_type $(, $id)?> { // SAFETY: The caller promises that the pointer is not dangling.
@@ -513,6 +483,15 @@ unsafe fn raw_get_work(ptr: *mut Self) -> *mut $crate::workqueue::Work<$work_typ ::core::ptr::addr_of_mut!((*ptr).$field) } } + +#[inline] +unsafe fn work_container_of ( + ptr: *mut $crate::workqueue::Work<$work_type $(, $id)?>, + ) -> *mut Self { +// SAFETY: The caller promises that the pointer points at a field of the right type +// in the right kind of struct. +unsafe { $crate::container_of!(ptr,Self , $field) } + } } )*}; }
Signature · 1 line
2.48.1
Quoted 8 lines · Tamir Duberstein
Implement
HasWork::work_container_ofinimpl_has_work!, narrowing the interface ofHasWorkand replacing pointer arithmetic withcontainer_of!. Remove the provided implementation ofHasWork::get_work_offsetwithout replacement; an implementation is already generated inimpl_has_work!. Remove theSelf: Sizedbound onHasWork::work_container_ofwhich was apparently necessary to accessOFFSETasOFFSETno longer exists.
Quoted 7 lines
A similar API change was discussed on the hrtimer series[1].
Signed-off-by Tamir Duberstein <[email protected]>--- rust/kernel/workqueue.rs | 45 ++++++++++++--------------------------------- 1 file changed, 12 insertions(+), 33 deletions(-)
What is the motivation of this change? I didn't follow the discussion, so if you explained it there, it would be nice if you could also add it to this commit message.
Quoted 40 lines
rust/kernel/workqueue.rs +2
-22@@ -429,51 +429,23 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct {/// /// # Safety /// -/// The [`OFFSET`] constant must be the offset of a field in `Self` of type [`Work<T, ID>`]. The -/// methods on this trait must have exactly the behavior that the definitions given below have. +/// The methods on this trait must have exactly the behavior that the definitions given below have. /// /// [`impl_has_work!`]: crate::impl_has_work -/// [`OFFSET`]: HasWork::OFFSET pub unsafe trait HasWork <T ,const ID :u64 =0 > { -/// The offset of the [`Work<T, ID>`] field. -const OFFSET :usize ; - -/// Returns the offset of the [`Work<T, ID>`] field. -/// -/// This method exists because the [`OFFSET`] constant cannot be accessed if the type is not -/// [`Sized`]. -/// -/// [`OFFSET`]: HasWork::OFFSET -#[inline] -fn get_work_offset (&self) ->usize { -Self ::OFFSET - } -/// Returns a pointer to the [`Work<T, ID>`] field. /// /// # Safety /// /// The provided pointer must point at a valid struct of type `Self`. -#[inline] -unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID > { -// SAFETY: The caller promises that the pointer is valid. -unsafe { (ptras *mut u8 ).add (Self ::OFFSET )as *mut Work <T ,ID > } - } +unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID >;
rust/kernel/workqueue.rs pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { · line 471
Quoted 10 lines
rust/kernel/workqueue.rs +0
-4/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`. -#[inline] -unsafe fn work_container_of (ptr: *mut Work <T ,ID >) -> *mut Self -where -Self :Sized ,
This bound is required in order to allow the usage of dyn HasWork (ie object safety), so it should stay.
Maybe add a comment explaining why it's there.
---
Cheers,
Benno
Quoted 34 lines
rust/kernel/workqueue.rs +10
-7- { -// SAFETY: The caller promises that the pointer points at a field of the right type in the -// right kind of struct. -unsafe { (ptras *mut u8 ).sub (Self ::OFFSET )as *mut Self } - } +unsafe fn work_container_of (ptr: *mut Work <T ,ID >) -> *mut Self ; }/// Used to safely implement the [`HasWork<T, ID>`] trait. @@ -504,8 +476,6 @@ macro_rules! impl_has_work {// SAFETY: The implementation of `raw_get_work` only compiles if the field has the right // type. unsafe impl$(<$($generics)+>)? $crate::workqueue::HasWork<$work_type $(, $id)?> for $self { - const OFFSET: usize = ::core::mem::offset_of!(Self, $field) as usize; - #[inline] unsafe fn raw_get_work(ptr: *mut Self) -> *mut $crate::workqueue::Work<$work_type $(, $id)?> { // SAFETY: The caller promises that the pointer is not dangling.@@ -513,6 +483,15 @@ unsafe fn raw_get_work(ptr: *mut Self) -> *mut $crate::workqueue::Work<$work_typ ::core::ptr::addr_of_mut!((*ptr).$field) } } + +#[inline] +unsafe fn work_container_of ( + ptr: *mut $crate::workqueue::Work<$work_type $(, $id)?>, + ) -> *mut Self { +// SAFETY: The caller promises that the pointer points at a field of the right type +// in the right kind of struct. +unsafe { $crate::container_of!(ptr,Self , $field) } + } } )*}; }
Quoted 18 lines · Benno Lossin
Quoted 8 lines · Tamir Duberstein
Implement
HasWork::work_container_ofinimpl_has_work!, narrowing the interface ofHasWorkand replacing pointer arithmetic withcontainer_of!. Remove the provided implementation ofHasWork::get_work_offsetwithout replacement; an implementation is already generated inimpl_has_work!. Remove theSelf: Sizedbound onHasWork::work_container_ofwhich was apparently necessary to accessOFFSETasOFFSETno longer exists.Quoted 7 lines
A similar API change was discussed on the hrtimer series[1].
Signed-off-by Tamir Duberstein <[email protected]>--- rust/kernel/workqueue.rs | 45 ++++++++++++--------------------------------- 1 file changed, 12 insertions(+), 33 deletions(-)
Quoted 3 lines
What is the motivation of this change? I didn't follow the discussion, so if you explained it there, it would be nice if you could also add it to this commit message.
The motivation is right at the top: it narrows the interface and replaces pointer arithmetic with an existing macro, and then deletes unnecessary code.
Quoted 54 lines
Quoted 40 lines
rust/kernel/workqueue.rs +2
-22@@ -429,51 +429,23 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct {/// /// # Safety /// -/// The [`OFFSET`] constant must be the offset of a field in `Self` of type [`Work<T, ID>`]. The -/// methods on this trait must have exactly the behavior that the definitions given below have. +/// The methods on this trait must have exactly the behavior that the definitions given below have. /// /// [`impl_has_work!`]: crate::impl_has_work -/// [`OFFSET`]: HasWork::OFFSET pub unsafe trait HasWork <T ,const ID :u64 =0 > { -/// The offset of the [`Work<T, ID>`] field. -const OFFSET :usize ; - -/// Returns the offset of the [`Work<T, ID>`] field. -/// -/// This method exists because the [`OFFSET`] constant cannot be accessed if the type is not -/// [`Sized`]. -/// -/// [`OFFSET`]: HasWork::OFFSET -#[inline] -fn get_work_offset (&self) ->usize { -Self ::OFFSET - } -/// Returns a pointer to the [`Work<T, ID>`] field. /// /// # Safety /// /// The provided pointer must point at a valid struct of type `Self`. -#[inline] -unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID > { -// SAFETY: The caller promises that the pointer is valid. -unsafe { (ptras *mut u8 ).add (Self ::OFFSET )as *mut Work <T ,ID > } - } +unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID >;rust/kernel/workqueue.rs pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { · line 471
Quoted 10 lines
rust/kernel/workqueue.rs +0
-4/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`. -#[inline] -unsafe fn work_container_of (ptr: *mut Work <T ,ID >) -> *mut Self -where -Self :Sized ,This bound is required in order to allow the usage of
dyn HasWork(ie object safety), so it should stay.
Quoted 1 line
Maybe add a comment explaining why it's there.
I guess a doctest would be better, but I still don't understand why the bound is needed. Sorry, can you cite something or explain in more detail please?
Quoted 81 lines · Tamir Duberstein
Quoted 18 lines · Benno Lossin
Quoted 8 lines · Tamir Duberstein
Implement
HasWork::work_container_ofinimpl_has_work!, narrowing the interface ofHasWorkand replacing pointer arithmetic withcontainer_of!. Remove the provided implementation ofHasWork::get_work_offsetwithout replacement; an implementation is already generated inimpl_has_work!. Remove theSelf: Sizedbound onHasWork::work_container_ofwhich was apparently necessary to accessOFFSETasOFFSETno longer exists.Quoted 7 lines
A similar API change was discussed on the hrtimer series[1].
Signed-off-by Tamir Duberstein <[email protected]>--- rust/kernel/workqueue.rs | 45 ++++++++++++--------------------------------- 1 file changed, 12 insertions(+), 33 deletions(-)Quoted 3 lines
What is the motivation of this change? I didn't follow the discussion, so if you explained it there, it would be nice if you could also add it to this commit message.
The motivation is right at the top: it narrows the interface and replaces pointer arithmetic with an existing macro, and then deletes unnecessary code.
Quoted 54 lines
Quoted 40 lines
rust/kernel/workqueue.rs +2
-22@@ -429,51 +429,23 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct {/// /// # Safety /// -/// The [`OFFSET`] constant must be the offset of a field in `Self` of type [`Work<T, ID>`]. The -/// methods on this trait must have exactly the behavior that the definitions given below have. +/// The methods on this trait must have exactly the behavior that the definitions given below have. /// /// [`impl_has_work!`]: crate::impl_has_work -/// [`OFFSET`]: HasWork::OFFSET pub unsafe trait HasWork <T ,const ID :u64 =0 > { -/// The offset of the [`Work<T, ID>`] field. -const OFFSET :usize ; - -/// Returns the offset of the [`Work<T, ID>`] field. -/// -/// This method exists because the [`OFFSET`] constant cannot be accessed if the type is not -/// [`Sized`]. -/// -/// [`OFFSET`]: HasWork::OFFSET -#[inline] -fn get_work_offset (&self) ->usize { -Self ::OFFSET - } -/// Returns a pointer to the [`Work<T, ID>`] field. /// /// # Safety /// /// The provided pointer must point at a valid struct of type `Self`. -#[inline] -unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID > { -// SAFETY: The caller promises that the pointer is valid. -unsafe { (ptras *mut u8 ).add (Self ::OFFSET )as *mut Work <T ,ID > } - } +unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID >;rust/kernel/workqueue.rs pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { · line 471
Quoted 10 lines
rust/kernel/workqueue.rs +0
-4/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`. -#[inline] -unsafe fn work_container_of (ptr: *mut Work <T ,ID >) -> *mut Self -where -Self :Sized ,This bound is required in order to allow the usage of
dyn HasWork(ie object safety), so it should stay.
Quoted 5 lines
Quoted 1 line
Maybe add a comment explaining why it's there.
I guess a doctest would be better, but I still don't understand why the bound is needed. Sorry, can you cite something or explain in more detail please?
Here is a link: https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility
But I realized that the trait wasn't object safe to begin with due to the OFFSET associated constant. So I'm not sure we need this. Alice, do you need dyn HasWork?
---
Cheers,
Benno
Quoted 89 lines · Benno Lossin
Quoted 81 lines · Tamir Duberstein
Quoted 18 lines · Benno Lossin
Quoted 8 lines · Tamir Duberstein
Implement
HasWork::work_container_ofinimpl_has_work!, narrowing the interface ofHasWorkand replacing pointer arithmetic withcontainer_of!. Remove the provided implementation ofHasWork::get_work_offsetwithout replacement; an implementation is already generated inimpl_has_work!. Remove theSelf: Sizedbound onHasWork::work_container_ofwhich was apparently necessary to accessOFFSETasOFFSETno longer exists.Quoted 7 lines
A similar API change was discussed on the hrtimer series[1].
Signed-off-by Tamir Duberstein <[email protected]>--- rust/kernel/workqueue.rs | 45 ++++++++++++--------------------------------- 1 file changed, 12 insertions(+), 33 deletions(-)Quoted 3 lines
What is the motivation of this change? I didn't follow the discussion, so if you explained it there, it would be nice if you could also add it to this commit message.
The motivation is right at the top: it narrows the interface and replaces pointer arithmetic with an existing macro, and then deletes unnecessary code.
Quoted 54 lines
Quoted 40 lines
rust/kernel/workqueue.rs +2
-22@@ -429,51 +429,23 @@ pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct {/// /// # Safety /// -/// The [`OFFSET`] constant must be the offset of a field in `Self` of type [`Work<T, ID>`]. The -/// methods on this trait must have exactly the behavior that the definitions given below have. +/// The methods on this trait must have exactly the behavior that the definitions given below have. /// /// [`impl_has_work!`]: crate::impl_has_work -/// [`OFFSET`]: HasWork::OFFSET pub unsafe trait HasWork <T ,const ID :u64 =0 > { -/// The offset of the [`Work<T, ID>`] field. -const OFFSET :usize ; - -/// Returns the offset of the [`Work<T, ID>`] field. -/// -/// This method exists because the [`OFFSET`] constant cannot be accessed if the type is not -/// [`Sized`]. -/// -/// [`OFFSET`]: HasWork::OFFSET -#[inline] -fn get_work_offset (&self) ->usize { -Self ::OFFSET - } -/// Returns a pointer to the [`Work<T, ID>`] field. /// /// # Safety /// /// The provided pointer must point at a valid struct of type `Self`. -#[inline] -unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID > { -// SAFETY: The caller promises that the pointer is valid. -unsafe { (ptras *mut u8 ).add (Self ::OFFSET )as *mut Work <T ,ID > } - } +unsafe fn raw_get_work (ptr: *mut Self ) -> *mut Work <T ,ID >;rust/kernel/workqueue.rs pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { · line 471
Quoted 10 lines
rust/kernel/workqueue.rs +0
-4/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`. -#[inline] -unsafe fn work_container_of (ptr: *mut Work <T ,ID >) -> *mut Self -where -Self :Sized ,This bound is required in order to allow the usage of
dyn HasWork(ie object safety), so it should stay.Quoted 5 lines
Quoted 1 line
Maybe add a comment explaining why it's there.
I guess a doctest would be better, but I still don't understand why the bound is needed. Sorry, can you cite something or explain in more detail please?
Quoted 5 lines
Here is a link: https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility
But I realized that the trait wasn't object safe to begin with due to the
OFFSETassociated constant. So I'm not sure we need this. Alice, do you needdyn HasWork?
I wrote a simple test:
rust/kernel/workqueue.rs +5 -0
@@ -448,6 +448,11 @@ pub unsafe trait HasWork<T, const ID: u64 = 0> {unsafe fn work_container_of (ptr: *mut Work <T ,ID >) -> *mut Self ; } +fn has_work_object_safe <T :HasWork <T >>(has_work:T ) { +fn _assert_object_safe (_: &dyn HasWork <()>) {} +_assert_object_safe (&has_work); +} +/// Used to safely implement the [`HasWork<T, ID>`] trait. /// /// # Examples
HasWork is not object-safe even before this patch:
Quoted 29 lines
error[E0038]: the trait
workqueue::HasWorkcannot be made into an object
-->../rust/kernel/workqueue.rs:481:25| 481 | _assert_object_safe(&has_work); | ^^^^^^^^^ `workqueue::HasWork` cannot be made into an object | note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety> --> ../rust/kernel/workqueue.rs:439:11 | 437 | pub unsafe trait HasWork<T, const ID: u64 = 0> { | ------- this trait cannot be made into an object... 438 | /// The offset of the [`Work<T, ID>`] field. 439 | const OFFSET: usize; | ^^^^^^ ...because it contains this associated `const`...
458 | unsafe fnraw_get_work(ptr: *mut Self)-> *mut Work<T, ID> {
| ^^^^^^^^^^^^ ...because associated functionraw_get_workhas noselfparameter
= help: consider movingOFFSETto another trait
= help: only typeworkqueue::ClosureWork<T>is seen to implement the trait in this crate, consider using it directly instead
= note:workqueue::HasWorkcan be implemented in other crates; if you want to support your users passing their own types here, you can't refer to a specific type
help: consider turningraw_get_workinto a method by giving it a&selfargument| 458 | unsafe fn raw_get_work(&self, ptr: *mut Self) -> *mut Work<T, ID> { | ++++++ help: alternatively, consider constraining `raw_get_work` so it does not apply to trait objects | 458 | unsafe fn raw_get_work(ptr: *mut Self) -> *mut Work<T, ID> where Self: Sized { | +++++++++++++++++
Quoted 1 line
error: aborting due to 3 previous errors
so I don't think adding the Sized bound makes sense - we'd end up adding it on every item in the trait.
Quoted 32 lines · Tamir Duberstein
Quoted 24 lines · Benno Lossin
Quoted 13 lines · Tamir Duberstein
Quoted 12 lines · Benno Lossin
Quoted 9 lines · Tamir Duberstein
/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`.(quoted diff) +0
-4- #[inline] - unsafe fn work_container_of(ptr: *mut Work<T, ID>) -> *mut Self - where - Self: Sized,Quoted 8 lines
Quoted 4 lines
This bound is required in order to allow the usage of
dyn HasWork(ie object safety), so it should stay.Maybe add a comment explaining why it's there.
I guess a doctest would be better, but I still don't understand why the bound is needed. Sorry, can you cite something or explain in more detail please?
Quoted 5 lines
Here is a link: https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility
But I realized that the trait wasn't object safe to begin with due to the
OFFSETassociated constant. So I'm not sure we need this. Alice, do you needdyn HasWork?I wrote a simple test:
[...]
Quoted 2 lines
so I don't think adding the Sized bound makes sense - we'd end up adding it on every item in the trait.
Yeah the Sized bound was probably to make the cast work, so let's remove it.
---
Cheers,
Benno
Quoted 35 lines · Benno Lossin
Quoted 25 lines · Tamir Duberstein
Quoted 24 lines · Benno Lossin
Quoted 21 lines · Tamir Duberstein
Quoted 12 lines · Benno Lossin
Review
Quoted 9 lines · Tamir Duberstein
/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`.(quoted diff) +0
-4- #[inline] - unsafe fn work_container_of(ptr: *mut Work<T, ID>) -> *mut Self - where - Self: Sized,Quoted 4 lines
This bound is required in order to allow the usage of
dyn HasWork(ie object safety), so it should stay.Maybe add a comment explaining why it's there.
I guess a doctest would be better, but I still don't understand why the bound is needed. Sorry, can you cite something or explain in more detail please?
Quoted 7 lines
Quoted 5 lines
Here is a link: https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility
But I realized that the trait wasn't object safe to begin with due to the
OFFSETassociated constant. So I'm not sure we need this. Alice, do you needdyn HasWork?I wrote a simple test:
Quoted 7 lines
[...]
Quoted 2 lines
so I don't think adding the Sized bound makes sense - we'd end up adding it on every item in the trait.
Yeah the
Sizedbound was probably to make the cast work, so let's remove it.
It's already removed, right?
Quoted 39 lines · Tamir Duberstein
Quoted 37 lines · Benno Lossin
Quoted 32 lines · Tamir Duberstein
Quoted 24 lines · Benno Lossin
Quoted 13 lines · Tamir Duberstein
Quoted 12 lines · Benno Lossin
Quoted 9 lines · Tamir Duberstein
/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`.(quoted diff) +0
-4- #[inline] - unsafe fn work_container_of(ptr: *mut Work<T, ID>) -> *mut Self - where - Self: Sized,Quoted 8 lines
Quoted 4 lines
This bound is required in order to allow the usage of
dyn HasWork(ie object safety), so it should stay.Maybe add a comment explaining why it's there.
I guess a doctest would be better, but I still don't understand why the bound is needed. Sorry, can you cite something or explain in more detail please?
Quoted 5 lines
Here is a link: https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility
But I realized that the trait wasn't object safe to begin with due to the
OFFSETassociated constant. So I'm not sure we need this. Alice, do you needdyn HasWork?I wrote a simple test:
[...]
Quoted 7 lines
Quoted 5 lines
Quoted 2 lines
so I don't think adding the Sized bound makes sense - we'd end up adding it on every item in the trait.
Yeah the
Sizedbound was probably to make the cast work, so let's remove it.It's already removed, right?
Ping. Can you help me understand what change, if any, you think is required?
Quoted 43 lines · Tamir Duberstein
Quoted 42 lines · Tamir Duberstein
Quoted 40 lines · Benno Lossin
Quoted 32 lines · Tamir Duberstein
Quoted 24 lines · Benno Lossin
Quoted 13 lines · Tamir Duberstein
Quoted 12 lines · Benno Lossin
Quoted 9 lines · Tamir Duberstein
/// Returns a pointer to the struct containing the [`Work<T, ID>`] field. /// /// # Safety /// /// The pointer must point at a [`Work<T, ID>`] field in a struct of type `Self`.(quoted diff) +0
-4- #[inline] - unsafe fn work_container_of(ptr: *mut Work<T, ID>) -> *mut Self - where - Self: Sized,Quoted 8 lines
Quoted 4 lines
This bound is required in order to allow the usage of
dyn HasWork(ie object safety), so it should stay.Maybe add a comment explaining why it's there.
I guess a doctest would be better, but I still don't understand why the bound is needed. Sorry, can you cite something or explain in more detail please?
Quoted 5 lines
Here is a link: https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility
But I realized that the trait wasn't object safe to begin with due to the
OFFSETassociated constant. So I'm not sure we need this. Alice, do you needdyn HasWork?I wrote a simple test:
[...]
Quoted 2 lines
so I don't think adding the Sized bound makes sense - we'd end up adding it on every item in the trait.
Quoted 6 lines
Quoted 4 lines
Quoted 2 lines
Yeah the
Sizedbound was probably to make the cast work, so let's remove it.It's already removed, right?
Ping. Can you help me understand what change, if any, you think is required?
No change required, with my reply above I intended to take my complaint away :)
---
Cheers,
Benno
Quoted 3 lines · Benno Lossin
No change required, with my reply above I intended to take my complaint away :)
Cool :) is there something else to be done to earn your RB, or do you mean to defer to Alice?
Benno Lossin
Reviewed-byQuoted 7 lines · Tamir Duberstein
Quoted 3 lines · Benno Lossin
No change required, with my reply above I intended to take my complaint away :)
Cool :) is there something else to be done to earn your RB, or do you mean to defer to Alice?
Ah sorry, I didn't end up adding it (:
It would be good if Alice could also take a look.
---
Cheers,
Benno
Quoted 8 lines · Tamir Duberstein
Implement
HasWork::work_container_ofinimpl_has_work!, narrowing the interface ofHasWorkand replacing pointer arithmetic withcontainer_of!. Remove the provided implementation ofHasWork::get_work_offsetwithout replacement; an implementation is already generated inimpl_has_work!. Remove theSelf: Sizedbound onHasWork::work_container_ofwhich was apparently necessary to accessOFFSETasOFFSETno longer exists.
Quoted 4 lines
A similar API change was discussed on the hrtimer series[1].
Signed-off-by Tamir Duberstein <[email protected]>
Overall looks good to me, but please CC the WORKQUEUE maintainers on the next version.
Rust Binder still builds with this change:
rust/kernel/workqueue.rs pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { · line 471
Quoted 2 lines
rust/kernel/workqueue.rs +0
-2- where - Self: Sized,
I did have trait object support in mind when I wrote these abstractions, but I don't actually need it and I don't think I actually got it working with trait objects.
Alice
Quoted 24 lines · Alice Ryhl
Quoted 8 lines · Tamir Duberstein
Implement
HasWork::work_container_ofinimpl_has_work!, narrowing the interface ofHasWorkand replacing pointer arithmetic withcontainer_of!. Remove the provided implementation ofHasWork::get_work_offsetwithout replacement; an implementation is already generated inimpl_has_work!. Remove theSelf: Sizedbound onHasWork::work_container_ofwhich was apparently necessary to accessOFFSETasOFFSETno longer exists.Quoted 4 lines
A similar API change was discussed on the hrtimer series[1].
Signed-off-by Tamir Duberstein <[email protected]>Overall looks good to me, but please CC the WORKQUEUE maintainers on the next version.
Reviewed-by Alice Ryhl <[email protected]>Rust Binder still builds with this change:
Tested-by Alice Ryhl <[email protected]>
Quoted 8 lines
rust/kernel/workqueue.rs pub unsafe fn raw_get(ptr: *const Self) -> *mut bindings::work_struct { · line 471
Quoted 2 lines
rust/kernel/workqueue.rs +0
-2- where - Self: Sized,I did have trait object support in mind when I wrote these abstractions, but I don't actually need it and I don't think I actually got it working with trait objects.
Alice
Thanks! Does there need to be another version? No changes have been requested.
Alice Ryhl
reviewerQuoted 6 lines · Tamir Duberstein
Quoted 3 lines · Alice Ryhl
Overall looks good to me, but please CC the WORKQUEUE maintainers on the next version.
Thanks! Does there need to be another version? No changes have been requested.
Yes, it needs a new version to fix conflicts with commit 7b948a2af6b5 ("rust: pci: fix unrestricted &mut pci::Device") that landed in the merge window just now. More generally, a new version is also recommended if maintainers are missing in the CC list.
As an FYI, I'm looking to do some additional work on the workqueue abstractions to support delayed work items for use by GPU drivers. Since I agree with this change, I'll base my work on top of your series.
Alice
Gentle ping on this.