rust: transmute: add `as_bytes(_mut)` methods for `AsBytes` trait

This is the sister patch of [1], providing an as_bytes method for AsBytes, and an as_bytes_mut accessor for types also implementing FromBytes.

It is going to be used in Nova, but should also be universally useful - if anything, it felt a bit strange that AsBytes did not provide this so far.

[1] https://lore.kernel.org/rust-for-linux/[email protected]/

---
Changes in v5:
- Add CAST: comments above cast operations. (thanks Benno!)
- Link to v4: https://lore.kernel.org/r/[email protected]

Changes in v4:
- Add the as_bytes_mut method for types also implementing FromBytes. (thanks Alice!)
- Link to v3: https://lore.kernel.org/r/[email protected]

Changes in v3:
- Use ptr::from_ref instead of as *const T.
- Link to v2: https://lore.kernel.org/r/[email protected]

Changes in v2:
- Use size_of_val to provide a default implementation for both Sized and non-Sized types, and remove AsBytesSized. (thanks Alice!)
- Link to v1: https://lore.kernel.org/r/[email protected]

---
Alexandre Courbot (2):
rust: transmute: add as_bytes method for AsBytes trait
rust: transmute: add as_bytes_mut method to AsBytes trait

 rust/kernel/transmute.rs | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

---
base-commit: 14ae91a81ec8fa0bc23170d4aa16dd2a20d54105
change-id: 20250725-as_bytes-6cbc11f2e8c3

Best regards,

Alexandre Courbot <[email protected]>

Every type that implements AsBytes should be able to provide its byte representation. Introduce the as_bytes method that returns the implementer as a stream of bytes, and provide a default implementation that should be suitable for any type that satisfies AsBytes's safety requirements.

---
 rust/kernel/transmute.rs | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

index 1c7d43771a37b90150de86699f114a2ffb84db91..08e6f0ff92a563e90895efa31f31f887aa05a0ae 100644
@@ -47,7 +47,17 @@ macro_rules! impl_frombytes {
 ///
 /// Values of this type may not contain any uninitialized bytes. This type must not have interior
 /// mutability.
-pub unsafe trait AsBytes {}
+pub unsafe trait AsBytes {
+    /// Returns `self` as a slice of bytes.
+    fn as_bytes(&self) -> &[u8] {
+        // CAST: `Self` implements `AsBytes` thus all bytes of `self` are initialized.
+        let data = core::ptr::from_ref(self).cast::<u8>();
+        let len = size_of_val(self);
+
+        // SAFETY: `data` is non-null and valid for reads of `len * sizeof::<u8>()` bytes.
+        unsafe { core::slice::from_raw_parts(data, len) }
+    }
+}
 
 macro_rules! impl_asbytes {
     ($($({$($generics:tt)*})? $t:ty, )*) => {

2.50.1

Types that implement both AsBytes and FromBytes can be safely modified as a slice of bytes. Add a as_bytes_mut method for that purpose.

---
 rust/kernel/transmute.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

index 08e6f0ff92a563e90895efa31f31f887aa05a0ae..5b2a53aa5df041e56be0c23993f684aa803551ae 100644
@@ -57,6 +57,21 @@ fn as_bytes(&self) -> &[u8] {
         // SAFETY: `data` is non-null and valid for reads of `len * sizeof::<u8>()` bytes.
         unsafe { core::slice::from_raw_parts(data, len) }
     }
+
+    /// Returns `self` as a mutable slice of bytes.
+    fn as_bytes_mut(&mut self) -> &mut [u8]
+    where
+        Self: FromBytes,
+    {
+        // CAST: `Self` implements both `AsBytes` and `FromBytes` thus making `Self`
+        // bi-directionally transmutable to `[u8; size_of_val(self)]`.
+        let data = core::ptr::from_mut(self).cast::<u8>();
+        let len = size_of_val(self);
+
+        // SAFETY: `data` is non-null and valid for read and writes of `len * sizeof::<u8>()`
+        // bytes.
+        unsafe { core::slice::from_raw_parts_mut(data, len) }
+    }
 }
 
 macro_rules! impl_asbytes {

2.50.1

---
Cheers,
Benno

Miguel, any concerns taking this through the nova tree?

If it is needed for something this same cycle in Nova, then please go ahead:

Thanks!

Cheers,
Miguel

Thanks Miguel! Yes, we are planning use it this cycle in Nova.

I'll push this into nova-next later today.