Why do #[repr(C)] structs require Unaligned for their fields when deriving IntoBytes?

[TheTollingBell]

According to the docs for the IntoBytes derive:

If the type is a struct, its fields must be IntoBytes. Additionally:

• if the type is repr(transparent) or repr(packed), it is IntoBytes if its fields are IntoBytes; else,
• if the type is repr(C) with at most one field, it is IntoBytes if its field is IntoBytes; else,
• if the type has no generic parameters, it is IntoBytes if the type is sized and has no padding bytes; else,
• if the type is repr(C), its fields must be Unaligned.

I don't really understand why there is a requirement that repr(C) must be Unaligned, since the alignment of [u8; _] is 1.

The types being derived on are generated with bindgen from the Linux kernel headers of FUSE. Here is an excerpt of a struct failing to compile:

#[doc = " struct fuse_supp_groups - Supplementary group extension\n @nr_groups: number of supplementary groups\n @groups: flexible array of group IDs"]
#[repr(C)]
#[derive(Debug, FromBytes, Immutable, IntoBytes)]
pub struct fuse_supp_groups<FAM: ?Sized = [u32; 0]> {
    pub nr_groups: u32,
    pub groups: FAM,
}

Error:

error[E0277]: the trait bound `u32: zerocopy::Unaligned` is not satisfied
 --> <PROJECT_DIR>/target/debug/build/linuxfuse_raw-f62653b9b13549cc/out/bindings.rs:1:85773
  |
1 | ...es , Immutable , IntoBytes)] pub struct fuse_supp_gro...
  |                     ^^^^^^^^^ the trait `zerocopy::Unaligned` is not implemented for `u32`
  |
  = note: Consider adding `#[derive(Unaligned)]` to `u32`
  = help: the following other types implement trait `zerocopy::Unaligned`:
            i8
            u8
  = help: see issue #48214
  = note: this error originates in the derive macro `IntoBytes` (in Nightly builds, run with -Z macro-backtrace for more info)

[joshlf]

This requirement is often a limitation of #[derive(IntoBytes)], not of IntoBytes itself. Can you provide the type you're trying to derive IntoBytes on?

[TheTollingBell]

Updated the question.

[joshlf]

The reason is that there will be some values of FAM for which fuse_supp_groups<FAM> has padding (e.g., consider FAM = u8). There's no way to express "this type of FAM will result in fuse_supp_groups<FAM> having padding", and so instead we conservatively require fuse_supp_groups<FAM>: Unaligned, which has the effect of guaranteeing that there's no padding (I can explain why this guarantees no padding if you're curious, but the TLDR is "alignment and padding math").

Is there an option to bindgen to remove the FAM parameter? Inlining would be fine too, i.e.:

#[repr(C)]
pub struct fuse_supp_groups {
    pub nr_groups: u32,
    pub groups: [u32; 0],
}

---

Unrelated: Fantastic profile picture. Huge SRV fan 🎸

[TheTollingBell]

Sadly, bindgen is pretty restrictive in how it generates types, so in order to modify types I have to parse it into a TokenStream and modify it from there. I didn't want to, but I'll probably swap all the primitive integers to use the Unaligned types, like U32.

[joshlf]

Be careful about updating the alignment – that may mean that your types no longer have the same ABI as the Linux types you're trying to mirror. If you're willing to go that route, you can just use #[repr(C, packed)] and it will make zerocopy happy – I didn't suggest it before because it changes the ABI (by making the entire struct have alignment 1).