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

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Message-Id: <DAOESYD6F287.3U3M64X0S1WN5@nvidia.com>
Date: Tue, 17 Jun 2025 10:15:37 +0900
From: "Alexandre Courbot" <acourbot@...dia.com>
To: "Christian" <christiansantoslima21@...il.com>
Cc: "Miguel Ojeda" <ojeda@...nel.org>, "Alex Gaynor"
 <alex.gaynor@...il.com>, "Boqun Feng" <boqun.feng@...il.com>, "Gary Guo"
 <gary@...yguo.net>, Björn Roy Baron
 <bjorn3_gh@...tonmail.com>, "Benno Lossin" <benno.lossin@...ton.me>,
 "Andreas Hindborg" <a.hindborg@...nel.org>, "Alice Ryhl"
 <aliceryhl@...gle.com>, "Trevor Gross" <tmgross@...ch.edu>, "Danilo
 Krummrich" <dakr@...nel.org>, <rust-for-linux@...r.kernel.org>,
 <linux-kernel@...r.kernel.org>, <~lkcamp/patches@...ts.sr.ht>,
 <richard120310@...il.com>
Subject: Re: [PATCH v7] rust: transmute: Add methods for FromBytes trait

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`?