libbpf-cargo: Make all XXX_data skeleton members optional

As discussed in #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: #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,13 @@ 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,20 @@ 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,11 @@ 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/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,