libbpf-cargo: Make all XXX_data skeleton members optional

As discussed in libbpf#1151, libbpf may not provide direct memory map access
to any of the BPF map members if the kernel does not support
memory-mapped global variable maps.
To that end, make them all optional.

Closes: libbpf#1151

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

Author: d-e-s-o

examples/capable/src/main.rs

@@ -174,16 +174,16 @@ fn main() -> Result<()> {
     }
 
     let mut open_object = MaybeUninit::uninit();
-    let open_skel = skel_builder.open(&mut open_object)?;
-    //Pass configuration to BPF
-    open_skel.maps.rodata_data.tool_config.tgid = opts.pid; //tgid in kernel is pid in userland
-    open_skel
+    let mut open_skel = skel_builder.open(&mut open_object)?;
+    let rodata = open_skel
         .maps
         .rodata_data
-        .tool_config
-        .verbose
-        .write(opts.verbose);
-    open_skel.maps.rodata_data.tool_config.unique_type = opts.unique_type;
+        .as_deref_mut()
+        .expect("`rodata` is not memory mapped");
+    //Pass configuration to BPF
+    rodata.tool_config.tgid = opts.pid; //tgid in kernel is pid in userland
+    rodata.tool_config.verbose.write(opts.verbose);
+    rodata.tool_config.unique_type = opts.unique_type;
 
     let mut skel = open_skel.load()?;
     skel.attach()?;

examples/ringbuf_multi/src/main.rs

@@ -45,10 +45,15 @@ fn main() -> Result<()> {
     let mut open_object = MaybeUninit::uninit();
     let open_skel = skel_builder.open(&mut open_object)?;
     let mut skel = open_skel.load()?;
+    let bss = skel
+        .maps
+        .bss_data
+        .as_deref_mut()
+        .expect("`bss` is not memory mapped");
 
     // Only trigger BPF program for current process.
     let pid = unsafe { libc::getpid() };
-    skel.maps.bss_data.pid = pid;
+    bss.pid = pid;
 
     let mut builder = libbpf_rs::RingBufferBuilder::new();
     builder
@@ -60,19 +65,24 @@ fn main() -> Result<()> {
     let ringbuf = builder.build().unwrap();
 
     let () = skel.attach()?;
+    let bss = skel
+        .maps
+        .bss_data
+        .as_deref_mut()
+        .expect("`bss` is not memory mapped");
 
     // trigger few samples, some will be skipped
-    skel.maps.bss_data.target_ring = 0;
-    skel.maps.bss_data.value = 333;
+    bss.target_ring = 0;
+    bss.value = 333;
     let _pgid = unsafe { libc::getpgid(pid) };
 
     // skipped, no ringbuf in slot 1
-    skel.maps.bss_data.target_ring = 1;
-    skel.maps.bss_data.value = 555;
+    bss.target_ring = 1;
+    bss.value = 555;
     let _pgid = unsafe { libc::getpgid(pid) };
 
-    skel.maps.bss_data.target_ring = 2;
-    skel.maps.bss_data.value = 777;
+    bss.target_ring = 2;
+    bss.value = 777;
     let _pgid = unsafe { libc::getpgid(pid) };
 
     // poll for samples, should get 2 ringbufs back

examples/runqslower/src/main.rs

@@ -78,12 +78,17 @@ fn main() -> Result<()> {
     }
 
     let mut open_object = MaybeUninit::uninit();
-    let open_skel = skel_builder.open(&mut open_object)?;
+    let mut open_skel = skel_builder.open(&mut open_object)?;
+    let rodata = open_skel
+        .maps
+        .rodata_data
+        .as_deref_mut()
+        .expect("`rodata` is not memory mapped");
 
     // Write arguments into prog
-    open_skel.maps.rodata_data.min_us = opts.latency;
-    open_skel.maps.rodata_data.targ_pid = opts.pid;
-    open_skel.maps.rodata_data.targ_tgid = opts.tid;
+    rodata.min_us = opts.latency;
+    rodata.targ_pid = opts.pid;
+    rodata.targ_tgid = opts.tid;
 
     // Begin tracing
     let mut skel = open_skel.load()?;

examples/tcp_ca/src/main.rs

@@ -163,19 +163,24 @@ fn test(name_to_register: Option<&OsStr>, name_to_use: &OsStr, verbose: bool) ->
     // NB: At this point `/proc/sys/net/ipv4/tcp_available_congestion_control`
     //     would list the registered congestion algorithm.
 
-    assert_eq!(skel.maps.bss_data.ca_cnt, 0);
-    assert!(!skel.maps.bss_data.cong_control);
+    let bss = skel
+        .maps
+        .bss_data
+        .as_deref_mut()
+        .expect("`bss` is not memory mapped");
+    assert_eq!(bss.ca_cnt, 0);
+    assert!(!bss.cong_control);
 
     // Use our registered TCP congestion algorithm while sending a bunch of data
     // over the loopback device.
     let () = send_recv(name_to_use)?;
     println!("Done.");
 
-    let saved_ca_cnt = skel.maps.bss_data.ca_cnt;
+    let saved_ca_cnt = bss.ca_cnt;
     assert_ne!(saved_ca_cnt, 0);
     // With `ca_update_cong_control2` active, we should have seen the
     // `cong_control` value changed as well.
-    assert!(skel.maps.bss_data.cong_control);
+    assert!(bss.cong_control);
     Ok(())
 }
 

examples/tcp_option/src/main.rs

@@ -86,12 +86,17 @@ fn main() -> Result<()> {
         builder.obj_builder.debug(true);
     }
     let mut open_object = MaybeUninit::uninit();
-    let open = builder.open(&mut open_object)?;
+    let mut open_skel = builder.open(&mut open_object)?;
+    let rodata = open_skel
+        .maps
+        .rodata_data
+        .as_deref_mut()
+        .expect("`rodata` is not memory mapped");
 
-    open.maps.rodata_data.targ_ip = u32::from_be_bytes(ip.octets()).to_be();
-    open.maps.rodata_data.data_such_as_trace_id = opts.trace_id;
+    rodata.targ_ip = u32::from_be_bytes(ip.octets()).to_be();
+    rodata.data_such_as_trace_id = opts.trace_id;
 
-    let skel = open.load()?;
+    let skel = open_skel.load()?;
 
     let cgroup_fd = OpenOptions::new()
         .read(true)

examples/tproxy/src/main.rs

@@ -68,10 +68,15 @@ fn main() -> Result<()> {
 
     // Set constants
     let mut open_object = MaybeUninit::uninit();
-    let open_skel = skel_builder.open(&mut open_object)?;
-    open_skel.maps.rodata_data.target_port = opts.port.to_be();
-    open_skel.maps.rodata_data.proxy_addr = proxy_addr.to_be();
-    open_skel.maps.rodata_data.proxy_port = opts.proxy_port.to_be();
+    let mut open_skel = skel_builder.open(&mut open_object)?;
+    let rodata = open_skel
+        .maps
+        .rodata_data
+        .as_deref_mut()
+        .expect("`rodata` is not memory mapped");
+    rodata.target_port = opts.port.to_be();
+    rodata.proxy_addr = proxy_addr.to_be();
+    rodata.proxy_port = opts.proxy_port.to_be();
 
     // Load into kernel
     let skel = open_skel.load()?;

libbpf-cargo/CHANGELOG.md

@@ -1,5 +1,6 @@
 Unreleased
 ----------
+- Adjusted all `<xxx>_data` BPF map skeleton members to be `Option`s
 - Removed `SkeletonBuilder::skip_clang_version_check` and
   `SkeletonBuilder::debug`
 - Removed `--skip-clang-version-checks` option of `libbpf build`

libbpf-cargo/src/gen/mod.rs

@@ -405,7 +405,7 @@ fn gen_skel_map_defs(
             write!(
                 skel,
                 "\
-                    pub {name}_data: &'obj{ref_mut} types::{name},
+                    pub {name}_data: Option<&'obj{ref_mut} types::{name}>,
                 ",
                 name = map.name,
             )?;
@@ -499,7 +499,6 @@ fn gen_skel_map_defs(
                                     .expect(\"BPF map `{name}` does not have mmap pointer\")
                                     .cast::<types::{name}>()
                                     .as_{ref_conv}()
-                                    .expect(\"BPF map `{name}` mmap pointer is NULL\")
                             }},
                 ",
                 name = map.name,

libbpf-cargo/src/test.rs

@@ -578,30 +578,28 @@ fn test_skeleton_datasec() {
         fn main() {
             let builder = ProgSkelBuilder::default();
             let mut open_object = MaybeUninit::uninit();
-            let open_skel = builder
+            let mut open_skel = builder
                 .open(&mut open_object)
                 .expect("failed to open skel");
-
             // Check that we set rodata vars before load
-            open_skel.maps.rodata_data.myconst = std::ptr::null_mut();
+            open_skel.maps.rodata_data.as_deref_mut().unwrap().myconst = std::ptr::null_mut();
 
             // We can always set bss vars
-            open_skel.maps.bss_data.myglobal = 42;
+            open_skel.maps.bss_data.as_deref_mut().unwrap().myglobal = 42;
+            open_skel.maps.data_custom_data.as_deref_mut().unwrap().mycustomdata = 1337;
+            open_skel.maps.bss_custom_data.as_deref_mut().unwrap().mycustombss = 12;
+            assert_eq!(open_skel.maps.rodata_custom_1_data.as_deref_mut().unwrap().mycustomrodata, 43);
 
-            open_skel.maps.data_custom_data.mycustomdata = 1337;
-            open_skel.maps.bss_custom_data.mycustombss = 12;
-            assert_eq!(open_skel.maps.rodata_custom_1_data.mycustomrodata, 43);
-
-            let skel = open_skel.load().expect("failed to load skel");
+            let mut skel = open_skel.load().expect("failed to load skel");
 
             // We can always set bss vars
-            skel.maps.bss_data.myglobal = 24;
-            skel.maps.data_custom_data.mycustomdata += 1;
-            skel.maps.bss_custom_data.mycustombss += 1;
-            assert_eq!(skel.maps.rodata_custom_1_data.mycustomrodata, 43);
+            skel.maps.bss_data.as_deref_mut().unwrap().myglobal = 24;
+            skel.maps.data_custom_data.as_deref_mut().unwrap().mycustomdata += 1;
+            skel.maps.bss_custom_data.as_deref_mut().unwrap().mycustombss += 1;
+            assert_eq!(skel.maps.rodata_custom_1_data.as_deref().unwrap().mycustomrodata, 43);
 
             // Read only for rodata after load
-            let _rodata: &types::rodata = skel.maps.rodata_data;
+            let _rodata: &types::rodata = skel.maps.rodata_data.as_deref().unwrap();
         }
     "#
     .to_string();
@@ -819,12 +817,13 @@ fn test_skeleton_builder_arrays_ptrs() {
             let open_skel = builder
                 .open(&mut open_object)
                 .expect("failed to open skel");
+            let rodata = open_skel.maps.rodata_data.as_deref().unwrap();
 
             // That everything exists and compiled okay
-            let _ = open_skel.maps.rodata_data.my_array[0].x;
-            let _ = open_skel.maps.rodata_data.my_array[0].y[1].b;
-            let _ = open_skel.maps.rodata_data.my_array[0].z[0].a;
-            let _ = open_skel.maps.rodata_data.my_ptr;
+            let _ = rodata.my_array[0].x;
+            let _ = rodata.my_array[0].y[1].b;
+            let _ = rodata.my_array[0].z[0].a;
+            let _ = rodata.my_ptr;
         }
     "#
     .to_string();