libbpf-cargo: Add support for custom .data/.bss/.rodata sections

This change adds support for handling of custom .data/.bss/.rodata
sections, declared via SEC(".data.xxxx") in the BPF C code. It makes
sure that we generate the corresponding Rust types as well as the proper
maps getters.

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

Author: d-e-s-o

libbpf-cargo/CHANGELOG.md

@@ -3,6 +3,7 @@ Unreleased
 - Removed `novendor` feature in favor of having disableable default
   feature
 - Added support for `struct_ops` shadow objects for generated skeletons
+- Added support for handling custom data sections in generated skeletons
 - Adjusted `SkeletonBuilder::clang_args` to accept an iterator of
   arguments instead of a string
 - Added `--clang-args` argument to `make` and `build` sub-commands

libbpf-cargo/src/gen/btf.rs

@@ -772,6 +772,7 @@ impl struct_ops {{
             Some(s) => s.into_owned(),
         };
         sec_name.remove(0);
+        let sec_name = sec_name.replace('.', "_");
 
         writeln!(def, r#"#[derive(Debug, Copy, Clone)]"#)?;
         writeln!(def, r#"#[repr(C)]"#)?;

libbpf-cargo/src/gen/mod.rs

@@ -6,6 +6,9 @@ use std::collections::HashSet;
 use std::ffi::c_void;
 use std::ffi::CStr;
 use std::ffi::CString;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::fmt::Result as FmtResult;
 use std::fmt::Write as fmt_write;
 use std::fs::File;
 use std::io::stdout;
@@ -34,23 +37,28 @@ use crate::metadata::UnprocessedObj;
 use self::btf::GenBtf;
 
 #[derive(Debug, PartialEq)]
-pub(crate) enum InternalMapType {
+pub(crate) enum InternalMapType<'name> {
     Data,
+    CustomData(&'name str),
     Rodata,
+    CustomRodata(&'name str),
     Bss,
+    CustomBss(&'name str),
     Kconfig,
     StructOps,
 }
 
-impl AsRef<str> for InternalMapType {
-    #[inline]
-    fn as_ref(&self) -> &'static str {
+impl Display for InternalMapType<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         match self {
-            Self::Data => "data",
-            Self::Rodata => "rodata",
-            Self::Bss => "bss",
-            Self::Kconfig => "kconfig",
-            Self::StructOps => "struct_ops",
+            Self::Data => write!(f, "data"),
+            Self::CustomData(name) => write!(f, "data_{}", name),
+            Self::Rodata => write!(f, "rodata"),
+            Self::CustomRodata(name) => write!(f, "rodata_{}", name),
+            Self::Bss => write!(f, "bss"),
+            Self::CustomBss(name) => write!(f, "bss_{}", name),
+            Self::Kconfig => write!(f, "kconfig"),
+            Self::StructOps => write!(f, "struct_ops"),
         }
     }
 }
@@ -193,7 +201,7 @@ fn get_raw_map_name(map: *const libbpf_sys::bpf_map) -> Result<String> {
     Ok(unsafe { CStr::from_ptr(name_ptr) }.to_str()?.to_string())
 }
 
-pub(crate) fn canonicalize_internal_map_name(s: &str) -> Option<InternalMapType> {
+pub(crate) fn canonicalize_internal_map_name(s: &str) -> Option<InternalMapType<'_>> {
     if s.ends_with(".data") {
         Some(InternalMapType::Data)
     } else if s.ends_with(".rodata") {
@@ -208,6 +216,18 @@ pub(crate) fn canonicalize_internal_map_name(s: &str) -> Option<InternalMapType>
         // The `*.link` extension really only sets an additional flag in lower
         // layers. For our intents and purposes both can be treated similarly.
         Some(InternalMapType::StructOps)
+    // Custom data sections don't prepend bpf_object name, so we can match from
+    // start of name.
+    // See https://github.com/libbpf/libbpf/blob/20ea95b4505c477af3b6ff6ce9d19cee868ddc5d/src/libbpf.c#L1789-L1794
+    } else if s.starts_with(".data.") {
+        let name = s.get(".data.".len()..).unwrap();
+        Some(InternalMapType::CustomData(name))
+    } else if s.starts_with(".rodata.") {
+        let name = s.get(".rodata.".len()..).unwrap();
+        Some(InternalMapType::CustomRodata(name))
+    } else if s.starts_with(".bss.") {
+        let name = s.get(".bss.".len()..).unwrap();
+        Some(InternalMapType::CustomBss(name))
     } else {
         eprintln!("Warning: unrecognized map: {s}");
         None
@@ -221,7 +241,7 @@ fn get_map_name(map: *const libbpf_sys::bpf_map) -> Result<Option<String>> {
     if unsafe { !libbpf_sys::bpf_map__is_internal(map) } {
         Ok(Some(name))
     } else {
-        Ok(canonicalize_internal_map_name(&name).map(|map| map.as_ref().to_string()))
+        Ok(canonicalize_internal_map_name(&name).map(|map| map.to_string()))
     }
 }
 

libbpf-cargo/src/test.rs

@@ -648,6 +648,9 @@ fn test_skeleton_datasec() {
 
         int myglobal = 0;
         void * const myconst = 0;
+        int mycustomdata SEC(".data.custom");
+        int mycustombss SEC(".bss.custom");
+        const int mycustomrodata SEC(".rodata.custom") = 43;
 
         SEC("kprobe/foo")
         int this_is_my_prog(u64 *ctx)
@@ -715,12 +718,19 @@ fn test_skeleton_datasec() {
             // We can always set bss vars
             open_skel.bss_mut().myglobal = 42;
 
+            open_skel.data_custom_mut().mycustomdata = 1337;
+            open_skel.bss_custom_mut().mycustombss = 12;
+            assert_eq!(open_skel.rodata_custom().mycustomrodata, 43);
+
             let mut skel = open_skel
                 .load()
                 .expect("failed to load skel");
 
             // We can always set bss vars
             skel.bss_mut().myglobal = 24;
+            skel.data_custom_mut().mycustomdata += 1;
+            skel.bss_custom_mut().mycustombss += 1;
+            assert_eq!(skel.rodata_custom().mycustomrodata, 43);
 
             // Read only for rodata after load
             let _rodata: &prog_types::rodata = skel.rodata();
@@ -2039,6 +2049,52 @@ pub struct rodata {
     assert_definition(&btf, &rodata, rodata_output);
 }
 
+#[test]
+fn test_btf_dump_definition_datasec_custom() {
+    let prog_text = r#"
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+
+int bss_array[1] SEC(".bss.custom");
+int data_array[1] SEC(".data.custom");
+const int rodata_array[1] SEC(".rodata.custom");
+"#;
+
+    let bss_custom_output = r#"
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct bss_custom {
+    pub bss_array: [i32; 1],
+}
+"#;
+
+    let data_custom_output = r#"
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct data_custom {
+    pub data_array: [i32; 1],
+}
+"#;
+
+    let rodata_custom_output = r#"
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct rodata_custom {
+    pub rodata_array: [i32; 1],
+}
+"#;
+
+    let mmap = build_btf_mmap(prog_text);
+    let btf = btf_from_mmap(&mmap);
+    let bss_custom = find_type_in_btf!(btf, types::DataSec<'_>, ".bss.custom", false);
+    let data_custom = find_type_in_btf!(btf, types::DataSec<'_>, ".data.custom", false);
+    let rodata_custom = find_type_in_btf!(btf, types::DataSec<'_>, ".rodata.custom", false);
+
+    assert_definition(&btf, &bss_custom, bss_custom_output);
+    assert_definition(&btf, &data_custom, data_custom_output);
+    assert_definition(&btf, &rodata_custom, rodata_custom_output);
+}
+
 #[test]
 fn test_btf_dump_definition_datasec_long_array() {
     let prog_text = r#"