zerocopy

The zerocopy crate (from Fuchsia) provides traits and macros for safely converting between byte sequences and other types.

  1. use zerocopy::{Immutable, IntoBytes};
  3. #[repr(u32)]
  4. #[derive(Debug, Default, Immutable, IntoBytes)]
  5. enum RequestType {
  6.     #[default]
  7.     In = 0,
  8.     Out = 1,
  9.     Flush = 4,
  10. }
  12. #[repr(C)]
  13. #[derive(Debug, Default, Immutable, IntoBytes)]
  14. struct VirtioBlockRequest {
  15.     request_type: RequestType,
  16.     reserved: u32,
  17.     sector: u64,
  18. }
  20. fn main() {
  21.     let request = VirtioBlockRequest {
  22.         request_type: RequestType::Flush,
  23.         sector: 42,
  24.         ..Default::default()
  25.     };
  27.     assert_eq!(
  28.         request.as_bytes(),
  29.         &[4, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0]
  30.     );
  31. }

This is not suitable for MMIO (as it doesn’t use volatile reads and writes), but can be useful for working with structures shared with hardware e.g. by DMA, or sent over some external interface.

  • FromBytes can be implemented for types for which any byte pattern is valid, and so can safely be converted from an untrusted sequence of bytes.
  • Attempting to derive FromBytes for these types would fail, because RequestType doesn’t use all possible u32 values as discriminants, so not all byte patterns are valid.
  • zerocopy::byteorder has types for byte-order aware numeric primitives.
  • Run the example with cargo run under src/bare-metal/useful-crates/zerocopy-example/. (It won’t run in the Playground because of the crate dependency.)