libbpf-cargo: Relative anonymous type naming for struct fields

Previously, anonymous types were named as __anon_{id} with id as a global counter. This approach caused cascading renaming of all subsequent anonymous definitions after any C anonymous struct order/amount change. This was a major design problem not for only development but even portability, since here may be the case when something was changed in vmlinux.h leading to compilation errors.

This commit addresses the issue by localizing cascading effects to the local struct layer rather than the global layer. While the solution is not fully ideal - cascading still occurs within individual structs - it eliminates the need for wide Rust code modifications when the order of anonymous struct definitions changes.

Note, that the commit does not fully eliminates __anon_{id}, but the most important part of it.

The commit is breaking and should be included in major version update.

Author: Waujito

libbpf-cargo/src/gen/btf.rs

@@ -10,6 +10,7 @@ use std::fmt::Write;
 use std::mem::size_of;
 use std::num::NonZeroUsize;
 use std::ops::Deref;
+use std::rc::Rc;
 
 use anyhow::anyhow;
 use anyhow::bail;
@@ -367,6 +368,13 @@ 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>>,
+}
+
 #[derive(Debug, Default)]
 pub(crate) struct TypeMap {
     /// A mapping from type to number, allowing us to assign numbers to
@@ -377,16 +385,74 @@ pub(crate) struct TypeMap {
     /// Mapping from type name to the number of times we have seen this
     /// name already.
     names_count: RefCell<HashMap<String, u8>>,
+
+    dependencies: 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();
+        if let Some(_) = deps.get(&ty.type_id()) {
+            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 let Some(_) = ty.name() {
+                dep.child_counter = Rc::new(RefCell::new(0));
+            }
+
+            let parent_counter = pdep.child_counter.clone();
+            *parent_counter.borrow_mut() += 1;
+            dep.dep_id = *parent_counter.borrow();
+
+            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 let Some(n) = parent.name() {
+                dep.name = Some(n.to_string_lossy().to_string());
+            }
+            if let Some(_) = ty.name() {
+                dep.child_counter = Rc::new(RefCell::new(0));
+            }
+            dep.dep_id = 1;
+            deps.insert(ty.type_id(), dep);
+        }
+    }
+
+    pub fn lookup_parent<'s>(&self, ty: &BtfType<'s>) -> Option<BtfDependency> {
+        self.dependencies
+            .borrow()
+            .get(&ty.type_id())
+            .map(|x| x.clone())
+    }
+
     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);
-                format!("{ANON_PREFIX}{anon_id}").into()
+
+                if let Some(parent) = self.lookup_parent(ty) {
+                    if let Some(name) = parent.name {
+                        if name.len() != 0 {
+                            return format!("{ANON_PREFIX}{}_{}", name, parent.dep_id).into();
+                        }
+                    }
+                }
+                return format!("{ANON_PREFIX}{anon_id}").into();
             }
             Some(n) => match self.names.borrow_mut().entry(ty.type_id()) {
                 Entry::Occupied(entry) => Cow::Owned(entry.get().clone()),
@@ -726,6 +792,7 @@ impl<'s> GenBtf<'s> {
             }
 
             if let Some(next_ty_id) = next_type(field_ty)? {
+                self.type_map.derive_parent(&next_ty_id, &t);
                 dependent_types.push(next_ty_id);
             }
             let field_name = if let Some(name) = member.name {