aya: skip map creation and relocation for maps that should be ignored

aya-obj/src/lib.rs

@@ -39,10 +39,14 @@
 //! // Relocate the programs
 //! #[cfg(feature = "std")]
 //! let text_sections = std::collections::HashSet::new();
+//! #[cfg(feature = "std")]
+//! let ignore_maps = std::collections::HashMap::new();
 //! #[cfg(not(feature = "std"))]
 //! let text_sections = hashbrown::HashSet::new();
+//! #[cfg(not(feature = "std"))]
+//! let ignore_maps = hashbrown::HashMap::new();
 //! object.relocate_calls(&text_sections).unwrap();
-//! object.relocate_maps(std::iter::empty(), &text_sections).unwrap();
+//! object.relocate_maps(std::iter::empty(), &text_sections, &ignore_maps).unwrap();
 //!
 //! // Run with rbpf
 //! let function = object.functions.get(&object.programs["prog_name"].function_key()).unwrap();

aya-obj/src/relocation.rs

@@ -108,9 +108,20 @@ impl Object {
  &mut self,
  maps: I,
  text_sections: &HashSet<usize>,
+ ignored_maps: &HashMap<String, Map>,
  ) -> Result<(), EbpfRelocationError> {
  let mut maps_by_section = HashMap::new();
  let mut maps_by_symbol = HashMap::new();
+ let mut ignored_by_section = HashSet::new();
+ let mut ignored_by_symbol = HashSet::new();
+
+ for map in ignored_maps.values() {
+ ignored_by_section.insert(map.section_index());
+ if let Some(index) = map.symbol_index() {
+ ignored_by_symbol.insert(index);
+ }
+ }
+
  for (name, fd, map) in maps {
  maps_by_section.insert(map.section_index(), (name, fd, map));
  if let Some(index) = map.symbol_index() {
@@ -127,6 +138,8 @@ impl Object {
  &maps_by_symbol,
  &self.symbol_table,
  text_sections,
+ &ignored_by_section,
+ &ignored_by_symbol,
  )
  .map_err(|error| EbpfRelocationError {
  function: function.name.clone(),
@@ -176,13 +189,16 @@ impl Object {
  }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn relocate_maps<'a, I: Iterator<Item = &'a Relocation>>(
  fun: &mut Function,
  relocations: I,
  maps_by_section: &HashMap<usize, (&str, std::os::fd::RawFd, &Map)>,
  maps_by_symbol: &HashMap<usize, (&str, std::os::fd::RawFd, &Map)>,
  symbol_table: &HashMap<usize, Symbol>,
  text_sections: &HashSet<usize>,
+ ignored_by_section: &HashSet<usize>,
+ ignored_by_symbol: &HashSet<usize>,
 ) -> Result<(), RelocationError> {
  let section_offset = fun.section_offset;
  let instructions = &mut fun.instructions;
@@ -222,7 +238,9 @@ fn relocate_maps<'a, I: Iterator<Item = &'a Relocation>>(
  continue;
  }
 
- let (_name, fd, map) = if let Some(m) = maps_by_symbol.get(&rel.symbol_index) {
+ let (_name, fd, map) = if ignored_by_symbol.contains(&rel.symbol_index) {
+ continue;
+ } else if let Some(m) = maps_by_symbol.get(&rel.symbol_index) {
  let map = &m.2;
  debug!(
  "relocating map by symbol index {:?}, kind {:?} at insn {ins_index} in section {}",
@@ -232,6 +250,8 @@ fn relocate_maps<'a, I: Iterator<Item = &'a Relocation>>(
  );
  debug_assert_eq!(map.symbol_index().unwrap(), rel.symbol_index);
  m
+ } else if ignored_by_section.contains(&section_index) {
+ continue;
  } else {
  let Some(m) = maps_by_section.get(&section_index) else {
  debug!("failed relocating map by section index {}", section_index);
@@ -580,6 +600,8 @@ mod test {
  &maps_by_symbol,
  &symbol_table,
  &HashSet::new(),
+ &HashSet::new(),
+ &HashSet::new(),
  )
  .unwrap();
 
@@ -636,6 +658,8 @@ mod test {
  &maps_by_symbol,
  &symbol_table,
  &HashSet::new(),
+ &HashSet::new(),
+ &HashSet::new(),
  )
  .unwrap();
 
@@ -675,6 +699,8 @@ mod test {
  &maps_by_symbol,
  &symbol_table,
  &HashSet::new(),
+ &HashSet::new(),
+ &HashSet::new(),
  )
  .unwrap();
 
@@ -731,6 +757,8 @@ mod test {
  &maps_by_symbol,
  &symbol_table,
  &HashSet::new(),
+ &HashSet::new(),
+ &HashSet::new(),
  )
  .unwrap();
 

aya/src/bpf.rs

@@ -21,8 +21,8 @@ use thiserror::Error;
 
 use crate::{
  generated::{
- bpf_map_type, bpf_map_type::*, AYA_PERF_EVENT_IOC_DISABLE, AYA_PERF_EVENT_IOC_ENABLE,
- AYA_PERF_EVENT_IOC_SET_BPF,
+ bpf_map_type::{self, *},
+ AYA_PERF_EVENT_IOC_DISABLE, AYA_PERF_EVENT_IOC_ENABLE, AYA_PERF_EVENT_IOC_SET_BPF,
  },
  maps::{Map, MapData, MapError},
  obj::{
@@ -137,6 +137,7 @@ pub struct EbpfLoader<'a> {
  extensions: HashSet<&'a str>,
  verifier_log_level: VerifierLogLevel,
  allow_unsupported_maps: bool,
+ ignore_maps_by_name: &'a [&'a str],
 }
 
 /// Builder style API for advanced loading of eBPF programs.
@@ -175,6 +176,7 @@ impl<'a> EbpfLoader<'a> {
  extensions: HashSet::new(),
  verifier_log_level: VerifierLogLevel::default(),
  allow_unsupported_maps: false,
+ ignore_maps_by_name: &[],
  }
  }
 
@@ -224,6 +226,32 @@ impl<'a> EbpfLoader<'a> {
  self
  }
 
+ /// Allows programs containing unsupported maps for the current kernel to be loaded
+ /// by skipping map creation and relocation before loading.
+ ///
+ /// This is useful when you have a single ebpf program containing e.g. a `RingBuf`
+ /// and a `PerfEventArray` and you decide which one to use before loading the bytecode.
+ ///
+ /// Must be used with [`EbpfLoader::set_global`] to signal if the map is supported in the ebpf program.
+ ///
+ /// # Example
+ ///
+ /// ```no_run
+ /// use aya::EbpfLoader;
+ ///
+ /// let ringbuf_supported = 0;
+ /// let ebpf = EbpfLoader::new()
+ /// .ignore_maps_by_name(&["RINGBUF"])
+ /// .set_global("RINGBUF_SUPPORTED", &ringbuf_supported, true)
+ /// .load_file("file.o")?;
+ /// # Ok::<(), aya::EbpfError>(())
+ /// ```
+ ///
+ pub fn ignore_maps_by_name(&mut self, name: &'a [&'a str]) -> &mut Self {
+ self.ignore_maps_by_name = name;
+ self
+ }
+
  /// Sets the base directory path for pinned maps.
  ///
  /// Pinned maps will be loaded from `path/MAP_NAME`.
@@ -394,6 +422,7 @@ impl<'a> EbpfLoader<'a> {
  extensions,
  verifier_log_level,
  allow_unsupported_maps,
+ ignore_maps_by_name,
  } = self;
  let mut obj = Object::parse(data)?;
  obj.patch_map_data(globals.clone())?;
@@ -459,12 +488,22 @@ impl<'a> EbpfLoader<'a> {
  obj.relocate_btf(btf)?;
  }
  let mut maps = HashMap::new();
+ let mut ignored_maps = HashMap::new();
+
  for (name, mut obj) in obj.maps.drain() {
  if let (false, EbpfSectionKind::Bss | EbpfSectionKind::Data | EbpfSectionKind::Rodata) =
  (FEATURES.bpf_global_data(), obj.section_kind())
  {
  continue;
  }
+
+ if ignore_maps_by_name.contains(&name.as_str()) {
+ ignored_maps.insert(name, obj);
+ // ignore map creation. The map is saved in `ignored_maps` and filtered out
+ // in `relocate_maps()` later on
+ continue;
+ }
+
  let num_cpus = || -> Result<u32, EbpfError> {
  Ok(possible_cpus()
  .map_err(|error| EbpfError::FileError {
@@ -508,7 +547,6 @@ impl<'a> EbpfLoader<'a> {
  map.finalize()?;
  maps.insert(name, map);
  }
-
  let text_sections = obj
  .functions
  .keys()
@@ -519,6 +557,7 @@ impl<'a> EbpfLoader<'a> {
  maps.iter()
  .map(|(s, data)| (s.as_str(), data.fd().as_fd().as_raw_fd(), data.obj())),
  &text_sections,
+ &ignored_maps,
  )?;
  obj.relocate_calls(&text_sections)?;
  obj.sanitize_functions(&FEATURES);

test/integration-ebpf/Cargo.toml

@@ -61,6 +61,10 @@ path = "src/xdp_sec.rs"
 name = "ring_buf"
 path = "src/ring_buf.rs"
 
+[[bin]]
+name = "ignore_map"
+path = "src/ignore_map.rs"
+
 [[bin]]
 name = "memmove_test"
 path = "src/memmove_test.rs"

test/integration-ebpf/src/ignore_map.rs

@@ -0,0 +1,32 @@
+#![no_std]
+#![no_main]
+
+use aya_ebpf::{
+ macros::{map, uprobe},
+ maps::{PerfEventArray, RingBuf},
+ programs::ProbeContext,
+};
+
+#[no_mangle]
+pub static RINGBUF_SUPPORTED: i32 = 0;
+
+#[map]
+static mut RINGBUF: RingBuf = RingBuf::with_byte_size(0, 0);
+
+#[map]
+static mut PERFBUF: PerfEventArray<u64> = PerfEventArray::with_max_entries(1, 0);
+
+#[uprobe]
+pub fn test_ignored_map_relocation(ctx: ProbeContext) {
+ if unsafe { core::ptr::read_volatile(&RINGBUF_SUPPORTED) == 1 } {
+ let _ = unsafe { RINGBUF.output(&1, 0).map_err(|_| 1u32) };
+ } else {
+ unsafe { PERFBUF.output(&ctx, &1, 0) };
+ }
+}
+
+#[cfg(not(test))]
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+ loop {}
+}

test/integration-test/src/lib.rs

@@ -22,6 +22,7 @@ pub const BPF_PROBE_READ: &[u8] =
 pub const REDIRECT: &[u8] = include_bytes_aligned!(concat!(env!("OUT_DIR"), "/redirect"));
 pub const XDP_SEC: &[u8] = include_bytes_aligned!(concat!(env!("OUT_DIR"), "/xdp_sec"));
 pub const RING_BUF: &[u8] = include_bytes_aligned!(concat!(env!("OUT_DIR"), "/ring_buf"));
+pub const IGNORE_MAP: &[u8] = include_bytes_aligned!(concat!(env!("OUT_DIR"), "/ignore_map"));
 pub const MEMMOVE_TEST: &[u8] = include_bytes_aligned!(concat!(env!("OUT_DIR"), "/memmove_test"));
 
 #[cfg(test)]

test/integration-test/src/tests/rbpf.rs

@@ -81,11 +81,13 @@ fn use_map_with_rbpf() {
  .iter()
  .map(|((section_index, _), _)| *section_index)
  .collect();
+ let disable_maps = HashMap::new();
  object
  .relocate_maps(
  maps.iter()
  .map(|(s, (fd, map))| (s.as_ref() as &str, *fd, map)),
  &text_sections,
+ &disable_maps,
  )
  .expect("Relocation failed");
  // Actually there is no local function call involved.

test/integration-test/src/tests/relocations.rs

@@ -1,6 +1,19 @@
-use aya::{programs::UProbe, util::KernelVersion, Ebpf};
+use aya::{programs::UProbe, util::KernelVersion, Ebpf, EbpfLoader};
 use test_log::test;
 
+#[test]
+fn ignored_map_relocation_by_name() {
+ let mut ebpf =
+ relocation_load_and_attach("test_ignored_map_relocation", crate::IGNORE_MAP, "RINGBUF");
+
+ let perf = ebpf.take_map("PERFBUF");
+
+ let ring = ebpf.take_map("RINGBUF");
+
+ assert!(perf.is_some());
+ assert!(ring.is_none());
+}
+
 #[test]
 fn relocations() {
  let bpf = load_and_attach("test_64_32_call_relocs", crate::RELOCATIONS);
@@ -33,6 +46,27 @@ fn text_64_64_reloc() {
  assert_eq!(m.get(&1, 0).unwrap(), 3);
 }
 
+fn relocation_load_and_attach(name: &str, bytes: &[u8], disable_map_name: &str) -> Ebpf {
+ let mut ebpf = EbpfLoader::new()
+ .ignore_maps_by_name(&[disable_map_name])
+ .set_global("RINGBUF_SUPPORTED", &0, true)
+ .load(bytes)
+ .unwrap();
+
+ let prog: &mut UProbe = ebpf.program_mut(name).unwrap().try_into().unwrap();
+ prog.load().unwrap();
+
+ prog.attach(
+ Some("trigger_relocations_program"),
+ 0,
+ "/proc/self/exe",
+ None,
+ )
+ .unwrap();
+
+ ebpf
+}
+
 fn load_and_attach(name: &str, bytes: &[u8]) -> Ebpf {
  let mut bpf = Ebpf::load(bytes).unwrap();