libbpf-cargo: Relative anonymous type naming

Author: Waujito

libbpf-cargo/src/gen/btf.rs

@@ -369,10 +369,17 @@ fn escape_reserved_keyword(identifier: Cow<'_, str>) -> Cow<'_, str> {
 }
 
 #[derive(Debug, Clone)]
-pub struct BtfDependency {
-    pub name: Option<String>,
-    pub dep_id: i32,
-    pub child_counter: Rc<RefCell<i32>>,
+struct BtfDependency {
+    /// Name of the dependency parent
+    parent_name: Option<String>,
+
+    /// Dependency id relative to the parent's `child_counter`
+    dep_id: i32,
+
+    /// The `child_counter` for the dependency if it is intended to be
+    /// a parent itself.
+    /// For an anonymous unit this should be a pointer to the parent's `child_counter`
+    child_counter: Rc<RefCell<i32>>,
 }
 
 #[derive(Debug, Default)]
@@ -386,69 +393,74 @@ pub(crate) struct TypeMap {
     /// name already.
     names_count: RefCell<HashMap<String, u8>>,
 
-    dependencies: RefCell<HashMap<TypeId, BtfDependency>>,
+    /// Mapping from type to it's parent. Used in anonymous members naming
+    dependency_tree: RefCell<HashMap<TypeId, BtfDependency>>,
 }
 
 impl TypeMap {
-    pub fn derive_parent<'s>(&self, ty: &BtfType<'s>, parent: &BtfType<'s>) {
-        let mut deps = self.dependencies.borrow_mut();
+    fn register_parent<'s>(&self, ty: &BtfType<'s>, parent: &BtfType<'s>) {
+        let mut deps = self.dependency_tree.borrow_mut();
         if deps.get(&ty.type_id()).is_some() {
             return;
         }
 
-        let parent_dep = deps.get(&parent.type_id());
-        if let Some(pdep) = parent_dep {
-            let mut dep = pdep.clone();
-
-            if let Some(n) = parent.name() {
-                dep.name = Some(n.to_string_lossy().to_string());
-            }
-            if ty.name().is_some() {
-                dep.child_counter = Rc::new(RefCell::new(0));
-            }
+        let pdep = deps.entry(parent.type_id()).or_insert(BtfDependency {
+            parent_name: None,
+            dep_id: 0,
+            child_counter: Rc::new(RefCell::new(0)),
+        });
 
-            let parent_counter = Rc::<RefCell<i32>>::clone(&pdep.child_counter);
-            *parent_counter.borrow_mut() += 1;
-            dep.dep_id = *parent_counter.borrow();
+        let mut dep = pdep.clone();
 
-            deps.insert(ty.type_id(), dep);
-        } else {
-            let mut dep = BtfDependency {
-                name: None,
-                dep_id: 0,
-                child_counter: Rc::new(RefCell::new(1)),
-            };
-            deps.insert(parent.type_id(), dep.clone());
+        // If parent is named, derive it.
+        // Otherwise derive parent's parent
+        if let Some(n) = parent.name() {
+            dep.parent_name = Some(n.to_string_lossy().to_string());
+        }
 
-            if let Some(n) = parent.name() {
-                dep.name = Some(n.to_string_lossy().to_string());
-            }
-            if ty.name().is_some() {
-                dep.child_counter = Rc::new(RefCell::new(0));
-            }
-            dep.dep_id = 1;
-            deps.insert(ty.type_id(), dep);
+        // If the current unit is named, self-assign the child_counter.
+        // Otherwise derive a parent's one
+        if ty.name().is_some() {
+            dep.child_counter = Rc::new(RefCell::new(0));
         }
+
+        // Increment parent's `child_counter` and assign the new value to dep_id
+        let parent_counter = Rc::clone(&pdep.child_counter);
+        *parent_counter.borrow_mut() += 1;
+        dep.dep_id = *parent_counter.borrow();
+
+        deps.insert(ty.type_id(), dep);
     }
 
-    pub fn lookup_parent<'s>(&self, ty: &BtfType<'s>) -> Option<BtfDependency> {
-        self.dependencies.borrow().get(&ty.type_id()).cloned()
+    fn lookup_parent<'s>(&self, ty: &BtfType<'s>) -> Option<BtfDependency> {
+        self.dependency_tree.borrow().get(&ty.type_id()).cloned()
     }
 
     pub fn type_name_or_anon<'s>(&self, ty: &BtfType<'s>) -> Cow<'s, str> {
         match ty.name() {
             None => {
                 let mut anon_table = self.types.borrow_mut();
                 let len = anon_table.len() + 1; // use 1 index anon ids for backwards compat
-                let anon_id = anon_table.entry(ty.type_id()).or_insert(len);
 
-                if let Some(parent) = self.lookup_parent(ty) {
-                    if let Some(name) = parent.name {
-                        if !name.is_empty() {
-                            return format!("{ANON_PREFIX}{}_{}", name, parent.dep_id).into();
+                let anon_id = match anon_table.entry(ty.type_id()) {
+                    Entry::Occupied(anon_id) => {
+                        let anon_id = anon_id.get();
+                        *anon_id
+                    }
+                    Entry::Vacant(anon_id) => {
+                        if let Some(dep) = self.lookup_parent(ty) {
+                            if let Some(name) = dep.parent_name {
+                                if !name.is_empty() {
+                                    return format!("{ANON_PREFIX}{}_{}", name, dep.dep_id).into();
+                                }
+                            }
                         }
+
+                        let anon_id = anon_id.insert(len);
+                        *anon_id
                     }
-                }
+                };
+
                 format!("{ANON_PREFIX}{anon_id}").into()
             }
             Some(n) => match self.names.borrow_mut().entry(ty.type_id()) {
@@ -789,7 +801,7 @@ impl<'s> GenBtf<'s> {
             }
 
             if let Some(next_ty_id) = next_type(field_ty)? {
-                self.type_map.derive_parent(&next_ty_id, &t);
+                self.type_map.register_parent(&next_ty_id, &t);
                 dependent_types.push(next_ty_id);
             }
             let field_name = if let Some(name) = member.name {

libbpf-cargo/src/test.rs

@@ -2792,6 +2792,134 @@ impl Default for __anon_Foo_1 {
     assert_definition(&btf, &struct_foo, expected_output);
 }
 
+#[test]
+fn test_btf_dump_anon_member_tree() {
+    let prog_text = r#"
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+
+struct Foo {
+    union {
+        struct {
+            char *name;
+            void *tp;
+        };
+        struct Bar {
+            union {
+                struct {
+                    char *name;
+                    void *trp;
+                };
+                struct Baz {
+                    char *name;
+                    void *trp;
+                } baz;
+            };
+        } bar;
+    };
+};
+
+struct Foo foo = {0};
+"#;
+
+    let expected_output = r#"
+#[derive(Debug, Default, Copy, Clone)]
+#[repr(C)]
+pub struct Foo {
+    pub __anon_Foo_1: __anon_Foo_1,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union __anon_Foo_1 {
+    pub __anon_Foo_2: __anon_Foo_2,
+    pub bar: Bar,
+}
+impl std::fmt::Debug for __anon_Foo_1 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "(???)")
+    }
+}
+impl Default for __anon_Foo_1 {
+    fn default() -> Self {
+        Self {
+            __anon_Foo_2: __anon_Foo_2::default(),
+        }
+    }
+}
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct __anon_Foo_2 {
+    pub name: *mut i8,
+    pub tp: *mut std::ffi::c_void,
+}
+impl Default for __anon_Foo_2 {
+    fn default() -> Self {
+        Self {
+            name: std::ptr::null_mut(),
+            tp: std::ptr::null_mut(),
+        }
+    }
+}
+#[derive(Debug, Default, Copy, Clone)]
+#[repr(C)]
+pub struct Bar {
+    pub __anon_Bar_1: __anon_Bar_1,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union __anon_Bar_1 {
+    pub __anon_Bar_2: __anon_Bar_2,
+    pub baz: Baz,
+}
+impl std::fmt::Debug for __anon_Bar_1 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "(???)")
+    }
+}
+impl Default for __anon_Bar_1 {
+    fn default() -> Self {
+        Self {
+            __anon_Bar_2: __anon_Bar_2::default(),
+        }
+    }
+}
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct __anon_Bar_2 {
+    pub name: *mut i8,
+    pub trp: *mut std::ffi::c_void,
+}
+impl Default for __anon_Bar_2 {
+    fn default() -> Self {
+        Self {
+            name: std::ptr::null_mut(),
+            trp: std::ptr::null_mut(),
+        }
+    }
+}
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct Baz {
+    pub name: *mut i8,
+    pub trp: *mut std::ffi::c_void,
+}
+impl Default for Baz {
+    fn default() -> Self {
+        Self {
+            name: std::ptr::null_mut(),
+            trp: std::ptr::null_mut(),
+        }
+    }
+}
+"#;
+
+    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_definition_anon_enum() {
     let prog_text = r#"