libbpf-cargo: Generate Default impl on overly large padding

When we pad structs to ensure proper alignment, we may end up generating
padding arrays of more than 32 byte when alignment is large. In such
cases, Rust would not be able to derive a Default and we'd need to make
sure to generate one ourselves, or a compilation error will ensue.
With this change we make sure to switch over to generating a Default
impl ourselves in those cases.

Signed-off-by: Daniel Müller <[email protected]>

Author: d-e-s-o

libbpf-cargo/CHANGELOG.md

@@ -1,3 +1,8 @@
+Unreleased
+----------
+- Fixed generation of `Default` impl in presence of large padding arrays
+
+
 0.23.1
 ------
 - Added "import injection" escape hatch to generated skeletons

libbpf-cargo/src/gen/btf.rs

@@ -575,6 +575,10 @@ impl struct_ops {{
                     impl_default.push(format!(
                         r#"            __pad_{offset}: [u8::default(); {padding}]"#,
                     ));
+
+                    if padding > 32 {
+                        gen_impl_default = true;
+                    }
                 }
 
                 if let Some(ft) = self.type_by_id::<types::Array<'_>>(field_ty.type_id()) {
@@ -634,6 +638,10 @@ impl struct_ops {{
                 impl_default.push(format!(
                     r#"            __pad_{offset}: [u8::default(); {padding}]"#,
                 ));
+
+                if padding > 32 {
+                    gen_impl_default = true;
+                }
             }
         }
 

libbpf-cargo/src/test.rs

@@ -1467,6 +1467,43 @@ pub struct Foo {
     assert_definition(&btf, &struct_foo, expected_output);
 }
 
+#[test]
+fn test_btf_dump_insane_align() {
+    let prog_text = r#"
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+
+struct Foo {
+    int x;
+} __attribute__((aligned(64)));
+
+struct Foo foo = {1};
+"#;
+
+    let expected_output = r#"
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct Foo {
+    pub x: i32,
+    pub __pad_4: [u8; 60],
+}
+impl Default for Foo {
+    fn default() -> Self {
+        Foo {
+            x: i32::default(),
+            __pad_4: [u8::default(); 60],
+        }
+    }
+}
+"#;
+
+    let mmap = build_btf_mmap(prog_text);
+    let btf = btf_from_mmap(&mmap);
+    let struct_foo = find_type_in_btf!(btf, types::Struct<'_>, "Foo");
+
+    assert_definition(&btf, &struct_foo, expected_output);
+}
+
 #[test]
 fn test_btf_dump_basic_long_array() {
     let prog_text = r#"