The `from_bytes*` family of functions expect a slice of the exact same
size as the requested type. This can be sometimes cumbersome for callers
that deal with dynamic stream of data that needs to be manually cut
before each invocation of `from_bytes`.

To simplify such callers, introduce a new `from_bytes*_prefix` family of
methods, which split the input slice at the index required for the
equivalent `from_bytes` method to succeed, and return its result
alongside with the remainder of the slice.

This design is inspired by zerocopy's `try_*_from_prefix` family of
methods.

Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>
---
This patch was part of a minor Nova cleanup series [1], but since it
requires attention from the core Rust team and is buried under other
Nova patches, I am taking the freedom to send it separately for
visibility.

Since the originating series makes use of this, I hope to eventually
merge it together with it, through the drm-rust tree.

Thanks!

[1] https://lore.kernel.org/all/20251029-nova-vbios-frombytes-v1-0-ac441ebc1de3@nvidia.com/
---
 rust/kernel/transmute.rs | 63 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/rust/kernel/transmute.rs b/rust/kernel/transmute.rs
index cfc37d81adf2..cbea8ab10a2c 100644
--- a/rust/kernel/transmute.rs
+++ b/rust/kernel/transmute.rs
@@ -58,6 +58,27 @@ fn from_bytes(bytes: &[u8]) -> Option<&Self>
         }
     }
 
+    /// Converts the beginning of `bytes` to a reference to `Self`.
+    ///
+    /// This method is similar to [`Self::from_bytes`], with the difference that `bytes` does not
+    /// need to be the same size of `Self` - the appropriate portion is cut from the beginning of
+    /// `bytes`, and the remainder returned alongside the result.
+    fn from_bytes_prefix(bytes: &[u8]) -> Option<(&Self, &[u8])>
+    where
+        Self: Sized,
+    {
+        if bytes.len() < size_of::<Self>() {
+            None
+        } else {
+            // PANIC: We checked that `bytes.len() >= size_of::<Self>`, thus `split_at` cannot
+            // panic.
+            // TODO: replace with `split_at_checked` once the MSRV is >= 1.80.
+            let (prefix, remainder) = bytes.split_at(size_of::<Self>());
+
+            Self::from_bytes(prefix).map(|s| (s, remainder))
+        }
+    }
+
     /// Converts a mutable slice of bytes to a reference to `Self`.
     ///
     /// Succeeds if the reference is properly aligned, and the size of `bytes` is equal to that of
@@ -80,6 +101,27 @@ fn from_bytes_mut(bytes: &mut [u8]) -> Option<&mut Self>
         }
     }
 
+    /// Converts the beginning of `bytes` to a mutable reference to `Self`.
+    ///
+    /// This method is similar to [`Self::from_bytes_mut`], with the difference that `bytes` does
+    /// not need to be the same size of `Self` - the appropriate portion is cut from the beginning
+    /// of `bytes`, and the remainder returned alongside the result.
+    fn from_bytes_mut_prefix(bytes: &mut [u8]) -> Option<(&mut Self, &mut [u8])>
+    where
+        Self: AsBytes + Sized,
+    {
+        if bytes.len() < size_of::<Self>() {
+            None
+        } else {
+            // PANIC: We checked that `bytes.len() >= size_of::<Self>`, thus `split_at_mut` cannot
+            // panic.
+            // TODO: replace with `split_at_mut_checked` once the MSRV is >= 1.80.
+            let (prefix, remainder) = bytes.split_at_mut(size_of::<Self>());
+
+            Self::from_bytes_mut(prefix).map(|s| (s, remainder))
+        }
+    }
+
     /// Creates an owned instance of `Self` by copying `bytes`.
     ///
     /// Unlike [`FromBytes::from_bytes`], which requires aligned input, this method can be used on
@@ -97,6 +139,27 @@ fn from_bytes_copy(bytes: &[u8]) -> Option<Self>
             None
         }
     }
+
+    /// Creates an owned instance of `Self` from the beginning of `bytes`.
+    ///
+    /// This method is similar to [`Self::from_bytes_copy`], with the difference that `bytes` does
+    /// not need to be the same size of `Self` - the appropriate portion is cut from the beginning
+    /// of `bytes`, and the remainder returned alongside the result.
+    fn from_bytes_copy_prefix(bytes: &[u8]) -> Option<(Self, &[u8])>
+    where
+        Self: Sized,
+    {
+        if bytes.len() < size_of::<Self>() {
+            None
+        } else {
+            // PANIC: We checked that `bytes.len() >= size_of::<Self>`, thus `split_at` cannot
+            // panic.
+            // TODO: replace with `split_at_checked` once the MSRV is >= 1.80.
+            let (prefix, remainder) = bytes.split_at(size_of::<Self>());
+
+            Self::from_bytes_copy(prefix).map(|s| (s, remainder))
+        }
+    }
 }
 
 macro_rules! impl_frombytes {

---
base-commit: 9a3c2f8a4f84960a48c056d0da88de3d09e6d622
change-id: 20251101-b4-frombytes-prefix-6bb9984cda4e

Best regards,
-- 
Alexandre Courbot <acourbot@nvidia.com>

On Sat Nov 1, 2025 at 10:41 PM JST, Alexandre Courbot wrote:
> The `from_bytes*` family of functions expect a slice of the exact same
> size as the requested type. This can be sometimes cumbersome for callers
> that deal with dynamic stream of data that needs to be manually cut
> before each invocation of `from_bytes`.
>
> To simplify such callers, introduce a new `from_bytes*_prefix` family of
> methods, which split the input slice at the index required for the
> equivalent `from_bytes` method to succeed, and return its result
> alongside with the remainder of the slice.
>
> This design is inspired by zerocopy's `try_*_from_prefix` family of
> methods.
>
> Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>
> ---
> This patch was part of a minor Nova cleanup series [1], but since it
> requires attention from the core Rust team and is buried under other
> Nova patches, I am taking the freedom to send it separately for
> visibility.
>
> Since the originating series makes use of this, I hope to eventually
> merge it together with it, through the drm-rust tree.
>
> Thanks!
>
> [1] https://lore.kernel.org/all/20251029-nova-vbios-frombytes-v1-0-ac441ebc1de3@nvidia.com/

Pushed along with the rest of the VBIOS series to drm-rust-next, thanks!

On Sat, Nov 01, 2025 at 10:41:21PM +0900, Alexandre Courbot wrote:
> The `from_bytes*` family of functions expect a slice of the exact same
> size as the requested type. This can be sometimes cumbersome for callers
> that deal with dynamic stream of data that needs to be manually cut
> before each invocation of `from_bytes`.
> 
> To simplify such callers, introduce a new `from_bytes*_prefix` family of
> methods, which split the input slice at the index required for the
> equivalent `from_bytes` method to succeed, and return its result
> alongside with the remainder of the slice.
> 
> This design is inspired by zerocopy's `try_*_from_prefix` family of
> methods.
> 
> Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>

Reviewed-by: Alice Ryhl <aliceryhl@google.com>

On Sat Nov 1, 2025 at 10:41 PM JST, Alexandre Courbot wrote:
> The `from_bytes*` family of functions expect a slice of the exact same
> size as the requested type. This can be sometimes cumbersome for callers
> that deal with dynamic stream of data that needs to be manually cut
> before each invocation of `from_bytes`.
>
> To simplify such callers, introduce a new `from_bytes*_prefix` family of
> methods, which split the input slice at the index required for the
> equivalent `from_bytes` method to succeed, and return its result
> alongside with the remainder of the slice.
>
> This design is inspired by zerocopy's `try_*_from_prefix` family of
> methods.
>
> Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>
> ---
> This patch was part of a minor Nova cleanup series [1], but since it
> requires attention from the core Rust team and is buried under other
> Nova patches, I am taking the freedom to send it separately for
> visibility.
>
> Since the originating series makes use of this, I hope to eventually
> merge it together with it, through the drm-rust tree.
>
> Thanks!
>
> [1] https://lore.kernel.org/all/20251029-nova-vbios-frombytes-v1-0-ac441ebc1de3@nvidia.com/

Rust core folks: if this looks ok to you, could I get an Acked-by to
take this through the drm-rust tree along with the rest of the series?

On Tue, Nov 4, 2025 at 5:56 AM Alexandre Courbot <acourbot@nvidia.com> wrote:
>
> Rust core folks: if this looks ok to you, could I get an Acked-by to
> take this through the drm-rust tree along with the rest of the series?

Acked-by: Miguel Ojeda <ojeda@kernel.org>

Thanks!

Cheers,
Miguel

On 11/4/25 5:55 AM, Alexandre Courbot wrote:
> Rust core folks: if this looks ok to you, could I get an Acked-by to
> take this through the drm-rust tree along with the rest of the series?

For drm-rust:

Acked-by: Danilo Krummrich <dakr@kernel.org>

On Sat Nov 1, 2025 at 2:41 PM CET, Alexandre Courbot wrote:
> The `from_bytes*` family of functions expect a slice of the exact same
> size as the requested type. This can be sometimes cumbersome for callers
> that deal with dynamic stream of data that needs to be manually cut
> before each invocation of `from_bytes`.
>
> To simplify such callers, introduce a new `from_bytes*_prefix` family of
> methods, which split the input slice at the index required for the
> equivalent `from_bytes` method to succeed, and return its result
> alongside with the remainder of the slice.
>
> This design is inspired by zerocopy's `try_*_from_prefix` family of
> methods.
>
> Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>

Reviewed-by: Danilo Krummrich <dakr@kernel.org>

One nit below:

> +    /// Converts the beginning of `bytes` to a reference to `Self`.
> +    ///
> +    /// This method is similar to [`Self::from_bytes`], with the difference that `bytes` does not
> +    /// need to be the same size of `Self` - the appropriate portion is cut from the beginning of
> +    /// `bytes`, and the remainder returned alongside the result.

Maybe "alongside `&Self`"? "alongside the result" sounds a bit like the method
would return `Result<&Self>, &[u8]`.

On Sat Nov 1, 2025 at 10:52 PM JST, Danilo Krummrich wrote:
> On Sat Nov 1, 2025 at 2:41 PM CET, Alexandre Courbot wrote:
>> The `from_bytes*` family of functions expect a slice of the exact same
>> size as the requested type. This can be sometimes cumbersome for callers
>> that deal with dynamic stream of data that needs to be manually cut
>> before each invocation of `from_bytes`.
>>
>> To simplify such callers, introduce a new `from_bytes*_prefix` family of
>> methods, which split the input slice at the index required for the
>> equivalent `from_bytes` method to succeed, and return its result
>> alongside with the remainder of the slice.
>>
>> This design is inspired by zerocopy's `try_*_from_prefix` family of
>> methods.
>>
>> Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>
>
> Reviewed-by: Danilo Krummrich <dakr@kernel.org>
>
> One nit below:
>
>> +    /// Converts the beginning of `bytes` to a reference to `Self`.
>> +    ///
>> +    /// This method is similar to [`Self::from_bytes`], with the difference that `bytes` does not
>> +    /// need to be the same size of `Self` - the appropriate portion is cut from the beginning of
>> +    /// `bytes`, and the remainder returned alongside the result.
>
> Maybe "alongside `&Self`"? "alongside the result" sounds a bit like the method
> would return `Result<&Self>, &[u8]`.

Thanks, that remove the ambiguity indeed!