Revert "libbpf-cargo: Don't provide kconfig data access after "open""

Commit 27dfe16 "libbpf-cargo: Don't provide kconfig data access after "open""
worked around the fact that the kconfig data member may not be present
whenever. As it turns out, there is no guarantee that any of the data
members are available as memory mapped data: on older kernels that "do
not support memory-mapped global variable maps, libbpf will just avoid
doing mmap" [0].
Revert this special sauce work around, as that means it's basically
unnecessary now and we have to come up with a generic solution instead.

This reverts commit 27dfe16.

[0]: #1151 (comment)

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

Author: d-e-s-o

libbpf-cargo/src/gen/mod.rs

@@ -47,14 +47,6 @@ use crate::metadata::UnprocessedObj;
 pub(crate) use self::btf::GenBtf;
 pub(crate) use self::btf::GenStructOps;
 
-
-/// Name of the `.kconfig` map.
-///
-/// It requires special treatment because `libbpf` doesn't set the
-/// corresponding mmap pointer during "open", only as part of "load".
-const MAP_NAME_KCONFIG: &str = "kconfig";
-
-
 /// Escape certain characters in a "raw" name of a section, for example.
 fn escape_raw_name(name: &str) -> String {
     name.replace('.', "_")
@@ -91,20 +83,15 @@ impl Display for InternalMapType<'_> {
 /// Meta-data about a BPF map.
 enum MapMeta {
     NonDatasec,
-    Datasec {
-        mmap_idx: usize,
-        read_only: bool,
-        not_openable: bool,
-    },
+    Datasec { mmap_idx: usize, read_only: bool },
 }
 
 impl MapMeta {
-    fn new(name: &str, idx: usize, map: &Map<'_>) -> Self {
+    fn new(idx: usize, map: &Map<'_>) -> Self {
         if map_is_datasec(map) {
             Self::Datasec {
                 mmap_idx: idx,
                 read_only: map_is_readonly(map),
-                not_openable: name == MAP_NAME_KCONFIG,
             }
         } else {
             Self::NonDatasec
@@ -138,8 +125,8 @@ impl MapData {
 
         let slf = Self {
             raw_name,
-            meta: MapMeta::new(&name, idx, map),
             name,
+            meta: MapMeta::new(idx, map),
         };
         Ok(Some(slf))
     }
@@ -411,24 +398,17 @@ fn gen_skel_map_defs(
             name = map.name
         )?;
 
-        if let MapMeta::Datasec {
-            read_only,
-            not_openable,
-            ..
-        } = map.meta
-        {
-            if !(open && not_openable) {
-                // After "open" all maps are writable. That's the point,
-                // they can be modified.
-                let ref_mut = if open || !read_only { " mut" } else { "" };
-                write!(
-                    skel,
-                    "\
-                        pub {name}_data: &'obj{ref_mut} types::{name},
-                    ",
-                    name = map.name,
-                )?;
-            }
+        if let MapMeta::Datasec { read_only, .. } = map.meta {
+            // After "open" all maps are writable. That's the point,
+            // they can be modified.
+            let ref_mut = if open || !read_only { " mut" } else { "" };
+            write!(
+                skel,
+                "\
+                    pub {name}_data: &'obj{ref_mut} types::{name},
+                ",
+                name = map.name,
+            )?;
         }
     }
 
@@ -507,26 +487,23 @@ fn gen_skel_map_defs(
         if let MapMeta::Datasec {
             mmap_idx,
             read_only,
-            not_openable,
         } = map.meta
         {
-            if !(open && not_openable) {
-                let ref_conv = if open || !read_only { "mut" } else { "ref" };
-                write!(
-                    skel,
-                    "\
-                                {name}_data: unsafe {{
-                                    config
-                                        .map_mmap_ptr({mmap_idx})
-                                        .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,
-                )?;
-            }
+            let ref_conv = if open || !read_only { "mut" } else { "ref" };
+            write!(
+                skel,
+                "\
+                            {name}_data: unsafe {{
+                                config
+                                    .map_mmap_ptr({mmap_idx})
+                                    .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,
+            )?;
         }
     }