Re: [PATCH v7] rust: transmute: Add methods for FromBytes trait

["Alexandre Courbot" <acourbot@nvidia.com>]

On Tue Jun 17, 2025 at 4:57 AM JST, Christian wrote:
>> We can, however, use a proxy trait that provides an implementation of
>> `FromBytes` for any type that is `Sized`:
>>
>>     pub unsafe trait FromBytesSized: Sized {}
>>
>>     unsafe impl<T> FromBytes for T
>>     where
>>         T: FromBytesSized,
>>     {
>>         fn from_bytes(bytes: &[u8]) -> Option<&Self> {
>>             if bytes.len() == core::mem::size_of::<Self>()
>>                 && (bytes.as_ptr() as usize) % core::mem::align_of::<Self>() == 0
>>             {
>>                 let slice_ptr = bytes.as_ptr().cast::<Self>();
>>                 unsafe { Some(&*slice_ptr) }
>>             } else {
>>                 None
>>             }
>>         }
>>
>>         fn from_mut_bytes(bytes: &mut [u8]) -> Option<&mut Self>
>>         where
>>             Self: AsBytes,
>>         {
>>             if bytes.len() == core::mem::size_of::<Self>()
>>                 && (bytes.as_mut_ptr() as usize) % core::mem::align_of::<Self>() == 0
>>             {
>>                 let slice_ptr = bytes.as_mut_ptr().cast::<Self>();
>>                 unsafe { Some(&mut *slice_ptr) }
>>             } else {
>>                 None
>>             }
>>         }
>>     }
>>
>> You can then implement `FromBytesSized` for all the types given to
>> `impl_frombytes!`.
>>
>> The main benefit over the `impl_frombytes!` macro is that `FromBytesSized` is
>> public, and external users can just implement it on their types without having
>> to provide implementations for `from_bytes` and `from_mut_bytes` which would in
>> all likelihood be identical to the ones of `impl_frombytes!` anyway. And if
>> they need something different, they can always implement `FromBytes` directly.
>>
>> For instance, the failing tests in `dma.rs` that I mentioned above can be fixed
>> by making them implement `FromBytesSized` instead of `FromBytes`.
>
> Hmm... I can change the implementation for this, but I think the idea
> behind `FromBytes` and `AsBytes` is that they are the default
> implementation and other parts adapt to them. Also, in the case of
> Slices, since we'll use only `Sized` types, do we just abort the
> conversion for them? If the maintainers are ok, I don't mind tho.

No, for slices you just keep the implementation you currently have,
which works just fine. The idea of `FromBytesSized` is to provide a
sensible default implementation for most users who just want to morph a
stream of bytes into a given struct type.

Or if that is still unclear, consider the following doctest in `dma.rs`
that fails with this patch:

    struct MyStruct { field: u32, }

    // SAFETY: All bit patterns are acceptable values for `MyStruct`.
    unsafe impl kernel::transmute::FromBytes for MyStruct{};
    // SAFETY: Instances of `MyStruct` have no uninitialized portions.
    unsafe impl kernel::transmute::AsBytes for MyStruct{};

It fails because the `FromBytes` implementation for `MyStruct` does not provide
a definition for `from_bytes` and `from_mut_bytes`. Fixing this is just a
matter of changing the `impl FromBytes` into `impl FromBytesSized`. But without
the latter, how do you make this example build without providing a definition
of `from_bytes` and `from_bytes_mut`?