rust: init: add `Zeroable` trait and `init::zeroed` function
Subsystems (2)
PATCH v3 9/13 rust: init: add `Zeroable` trait and `init::zeroed` function
From: Benno Lossin <[email protected]>
Add the Zeroable trait which marks types that can be initialized by writing 0x00 to every byte of the type. Also add the init::zeroed function that creates an initializer for a Zeroable type that writes 0x00 to every byte.
--- rust/kernel/init.rs | 65 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+)
rust/kernel/init.rs +65 -0
@@ -1254,3 +1254,68 @@ pub unsafe trait PinnedDrop: __internal::HasPinData {/// automatically. fn drop (self:Pin <&mut Self >, only_call_from_drop: __internal::OnlyCallFromDrop ); } + +/// Marker trait for types that can be initialized by writing just zeroes. +/// +/// # Safety +/// +/// The bit pattern consisting of only zeroes is a valid bit pattern for this type. In other words, +/// this is not UB: +/// +/// ```rust,ignore +/// let val: Self = unsafe { core::mem::zeroed() }; +/// ``` +pub unsafe trait Zeroable {} + +/// Create a new zeroed T. +/// +/// The returned initializer will write `0x00` to every byte of the given `slot`. +#[inline] +pub fn zeroed <T :Zeroable +Unpin >() ->impl Init <T > { +// SAFETY: Because `T: Zeroable`, all bytes zero is a valid bit pattern for `T` +// and because we write all zeroes, the memory is initialized. +unsafe { +init_from_closure (|slot: *mut T | { + slot.write_bytes (0 ,1 ); +Ok (()) + }) + } +} + +macro_rules! impl_zeroable { + ($($t:ty, )*) => { + $(unsafe impl Zeroable for $t {})* + }; +} + +impl_zeroable! { +// SAFETY: All primitives that are allowed to be zero. +bool , +char , +u8 ,u16 ,u32 ,u64 ,u128 ,usize , +i8 ,i16 ,i32 ,i64 ,i128 ,isize , +f32 ,f64 , +// SAFETY: There is nothing to zero. + core::marker::PhantomPinned ,Infallible , (), +} + +// SAFETY: We are allowed to zero padding bytes. +unsafe impl <const N :usize ,T :Zeroable >Zeroable for [T ;N ] {} + +// SAFETY: There is nothing to zero. +unsafe impl <T : ?Sized >Zeroable for PhantomData <T > {} + +// SAFETY: `null` pointer is valid. +unsafe impl <T : ?Sized >Zeroable for *mut T {} +unsafe impl <T : ?Sized >Zeroable for *const T {} + +macro_rules! impl_tuple_zeroable { + ($(,)?) => {}; + ($first:ident, $($t:ident),* $(,)?) => { +// SAFETY: All elements are zeroable and padding can be zero. +unsafe impl <$first:Zeroable , $($t:Zeroable ),*>Zeroable for ($first, $($t),*) {} +impl_tuple_zeroable! ($($t),* ,); + } +} + +impl_tuple_zeroable! (A ,B ,C ,D ,E ,F ,G ,H ,I ,J );
--
2.39.2
Quoted 8 lines · On Wed, 29 Mar 2023 22:33:35 +0000 [email protected] wrote:
From: Benno Lossin <[email protected]>
Add the
Zeroabletrait which marks types that can be initialized by writing0x00to every byte of the type. Also add theinit::zeroedfunction that creates an initializer for aZeroabletype that writes0x00to every byte.Signed-off-by Benno Lossin <[email protected]>
Quoted 81 lines
--- rust/kernel/init.rs | 65 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+)rust/kernel/init.rs +65
-1@@ -1254,3 +1254,68 @@ pub unsafe trait PinnedDrop: __internal::HasPinData {/// automatically. fn drop (self:Pin <&mut Self >, only_call_from_drop: __internal::OnlyCallFromDrop ); } + +/// Marker trait for types that can be initialized by writing just zeroes. +/// +/// # Safety +/// +/// The bit pattern consisting of only zeroes is a valid bit pattern for this type. In other words, +/// this is not UB: +/// +/// ```rust,ignore +/// let val: Self = unsafe { core::mem::zeroed() }; +/// ``` +pub unsafe trait Zeroable {} + +/// Create a new zeroed T. +/// +/// The returned initializer will write `0x00` to every byte of the given `slot`. +#[inline] +pub fn zeroed <T :Zeroable +Unpin >() ->impl Init <T > { +// SAFETY: Because `T: Zeroable`, all bytes zero is a valid bit pattern for `T` +// and because we write all zeroes, the memory is initialized. +unsafe { +init_from_closure (|slot: *mut T | { + slot.write_bytes (0 ,1 ); +Ok (()) + }) + } +} + +macro_rules! impl_zeroable { + ($($t:ty, )*) => { + $(unsafe impl Zeroable for $t {})* + }; +} + +impl_zeroable! { +// SAFETY: All primitives that are allowed to be zero. +bool , +char , +u8 ,u16 ,u32 ,u64 ,u128 ,usize , +i8 ,i16 ,i32 ,i64 ,i128 ,isize , +f32 ,f64 , +// SAFETY: There is nothing to zero. + core::marker::PhantomPinned ,Infallible , (), +} + +// SAFETY: We are allowed to zero padding bytes. +unsafe impl <const N :usize ,T :Zeroable >Zeroable for [T ;N ] {} + +// SAFETY: There is nothing to zero. +unsafe impl <T : ?Sized >Zeroable for PhantomData <T > {} + +// SAFETY: `null` pointer is valid. +unsafe impl <T : ?Sized >Zeroable for *mut T {} +unsafe impl <T : ?Sized >Zeroable for *const T {} + +macro_rules! impl_tuple_zeroable { + ($(,)?) => {}; + ($first:ident, $($t:ident),* $(,)?) => { +// SAFETY: All elements are zeroable and padding can be zero. +unsafe impl <$first:Zeroable , $($t:Zeroable ),*>Zeroable for ($first, $($t),*) {} +impl_tuple_zeroable! ($($t),* ,); + } +} + +impl_tuple_zeroable! (A ,B ,C ,D ,E ,F ,G ,H ,I ,J ); --2.39.2
Quoted 8 lines · On 3/30/23 00:33, [email protected] wrote:
From: Benno Lossin <[email protected]>
Add the
Zeroabletrait which marks types that can be initialized by writing0x00to every byte of the type. Also add theinit::zeroedfunction that creates an initializer for aZeroabletype that writes0x00to every byte.Signed-off-by Benno Lossin <[email protected]>
rust/kernel/init.rs pub unsafe trait PinnedDrop: __internal::HasPinData { · line 1300
Quoted 10 lines
rust/kernel/init.rs +10
-0+impl_zeroable! { +// SAFETY: All primitives that are allowed to be zero. +bool , +char , +u8 ,u16 ,u32 ,u64 ,u128 ,usize , +i8 ,i16 ,i32 ,i64 ,i128 ,isize , +f32 ,f64 , +// SAFETY: There is nothing to zero. + core::marker::PhantomPinned ,Infallible , (), +}
Here are some other types it might make sense to add:
* Option<NonNull<T>>
* Option<Box<T>>
* Option<NonZeroU32>
* PhantomData<T>
* MaybeUninit<T>
rust/kernel/init.rs pub unsafe trait PinnedDrop: __internal::HasPinData { · line 1303
Quoted 3 lines
rust/kernel/init.rs +3
-0+ +// SAFETY: We are allowed to zero padding bytes. +unsafe impl <const N :usize ,T :Zeroable >Zeroable for [T ;N ] {}
There are no padding bytes in [T; N].
rust/kernel/init.rs pub unsafe trait PinnedDrop: __internal::HasPinData { · line 1310
Quoted 12 lines · On 3/30/23 00:33, [email protected] wrote:
From: Benno Lossin <[email protected]>
Add the
Zeroabletrait which marks types that can be initialized by writing0x00to every byte of the type. Also add theinit::zeroedfunction that creates an initializer for aZeroabletype that writes0x00to every byte.Signed-off-by Benno Lossin <[email protected]>---
rust/kernel/init.rs +3
-0+// SAFETY: `null` pointer is valid. +unsafe impl <T : ?Sized >Zeroable for *mut T {} +unsafe impl <T : ?Sized >Zeroable for *const T {}
Actually, I just realized that this is not ok for unsized types. When T is unsized, the raw pointer is a fat pointer with a vtable, and the vtable part is not necessarily zeroable.
However, it would be ok to do it for *const [T] since the fat part of the pointer is just the length in this case, and a length of zero is fine.
See more here:
https://github.com/Lokathor/bytemuck/blob/8391afa876ba2e99dffb0c991cc7fa775287d106/src/zeroable.rs#L56-L65
Gary Guo
maintainerQuoted 18 lines · On Fri, 31 Mar 2023 00:40:34 +0200 Alice Ryhl <[email protected]> wrote:
rust/kernel/init.rs pub unsafe trait PinnedDrop: __internal::HasPinData { · line 1310
Quoted 12 lines · On 3/30/23 00:33, [email protected] wrote:
From: Benno Lossin <[email protected]>
Add the
Zeroabletrait which marks types that can be initialized by writing0x00to every byte of the type. Also add theinit::zeroedfunction that creates an initializer for aZeroabletype that writes0x00to every byte.Signed-off-by Benno Lossin <[email protected]>---
rust/kernel/init.rs +3
-0+// SAFETY: `null` pointer is valid. +unsafe impl <T : ?Sized >Zeroable for *mut T {} +unsafe impl <T : ?Sized >Zeroable for *const T {}Actually, I just realized that this is not ok for unsized types. When T is unsized, the raw pointer is a fat pointer with a vtable, and the vtable part is not necessarily zeroable.
Quoted 5 lines
However, it would be ok to do it for
*const [T]since the fat part of the pointer is just the length in this case, and a length of zero is fine.See more here:
https://github.com/Lokathor/bytemuck/blob/8391afa876ba2e99dffb0c991cc7fa775287d106/src/zeroable.rs#L56-L65
Good catch. vtable completely slipped my mind when I am reviewing this code.
Vtable is not *not necessary zeroable*, but actually never zeroable. Although currently not yet formally specified, the compiler has always assumed vtable part of fat pointers to be non-null, well aligned and dereferenceable.
Best,
Gary
Quoted 18 lines · Alice Ryhl
rust/kernel/init.rs pub unsafe trait PinnedDrop: __internal::HasPinData { · line 1310
Quoted 12 lines · On 3/30/23 00:33, [email protected] wrote:
From: Benno Lossin <[email protected]>
Add the
Zeroabletrait which marks types that can be initialized by writing0x00to every byte of the type. Also add theinit::zeroedfunction that creates an initializer for aZeroabletype that writes0x00to every byte.Signed-off-by Benno Lossin <[email protected]>---
rust/kernel/init.rs +3
-0+// SAFETY: `null` pointer is valid. +unsafe impl <T : ?Sized >Zeroable for *mut T {} +unsafe impl <T : ?Sized >Zeroable for *const T {}Actually, I just realized that this is not ok for unsized types. When T is unsized, the raw pointer is a fat pointer with a vtable, and the vtable part is not necessarily zeroable.
Quoted 5 lines
However, it would be ok to do it for
*const [T]since the fat part of the pointer is just the length in this case, and a length of zero is fine.See more here:
https://github.com/Lokathor/bytemuck/blob/8391afa876ba2e99dffb0c991cc7fa775287d106/src/zeroable.rs#L56-L65
Wow I forgot about fat pointers completely! Good catch!
--
Cheers,
Benno