From bc8f4ef1c80b06c49bc7d25d41ea2d58bfcb42b8 Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Sun, 9 Apr 2023 12:14:01 +1000 Subject: [PATCH 1/7] integration-tests: rename relocations to btf_relocations In preparation of adding actual ELF relocation tests --- .../src/tests/{relocations.rs => btf_relocations.rs} | 0 test/integration-test/src/tests/mod.rs | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) rename test/integration-test/src/tests/{relocations.rs => btf_relocations.rs} (100%) diff --git a/test/integration-test/src/tests/relocations.rs b/test/integration-test/src/tests/btf_relocations.rs similarity index 100% rename from test/integration-test/src/tests/relocations.rs rename to test/integration-test/src/tests/btf_relocations.rs diff --git a/test/integration-test/src/tests/mod.rs b/test/integration-test/src/tests/mod.rs index ddb1b504..b7a171b1 100644 --- a/test/integration-test/src/tests/mod.rs +++ b/test/integration-test/src/tests/mod.rs @@ -4,10 +4,10 @@ use libc::{uname, utsname}; use regex::Regex; use std::{ffi::CStr, mem}; +pub mod btf_relocations; pub mod elf; pub mod load; pub mod rbpf; -pub mod relocations; pub mod smoke; pub use integration_test_macros::integration_test; From 5c4f1d69a60e0c5324512a7cfbc4467b7f5d0bca Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Sun, 9 Apr 2023 19:51:20 +1000 Subject: [PATCH 2/7] aya-obj: rework `maps` section parsing Avoid allocations and add comments explaining how things work. --- aya-obj/src/obj.rs | 105 +++++++++++++++++++++++++-------------------- 1 file changed, 59 insertions(+), 46 deletions(-) diff --git a/aya-obj/src/obj.rs b/aya-obj/src/obj.rs index 8491709b..7f040b24 100644 --- a/aya-obj/src/obj.rs +++ b/aya-obj/src/obj.rs @@ -762,37 +762,6 @@ impl Object { Ok(()) } - fn parse_map_section( - &mut self, - section: &Section, - symbols: Vec, - ) -> Result<(), ParseError> { - if symbols.is_empty() { - return Err(ParseError::NoSymbolsInMapSection {}); - } - for (i, sym) in symbols.iter().enumerate() { - let start = sym.address as usize; - let end = start + sym.size as usize; - let data = §ion.data[start..end]; - let name = sym - .name - .as_ref() - .ok_or(ParseError::MapSymbolNameNotFound { i })?; - let def = parse_map_def(name, data)?; - self.maps.insert( - name.to_string(), - Map::Legacy(LegacyMap { - section_index: section.index.0, - symbol_index: sym.index, - def, - data: Vec::new(), - kind: MapKind::Other, - }), - ); - } - Ok(()) - } - fn parse_btf_maps( &mut self, section: &Section, @@ -875,19 +844,24 @@ impl Object { self.parse_btf_maps(§ion, symbols)? } BpfSectionKind::Maps => { - let symbols: Vec = self - .symbols_by_index - .values() - .filter(|s| { - if let Some(idx) = s.section_index { - idx == section.index.0 - } else { - false - } - }) - .cloned() - .collect(); - self.parse_map_section(§ion, symbols)? + // take out self.maps so we can borrow the iterator below + // without cloning or collecting + let mut maps = mem::take(&mut self.maps); + + // extract the symbols for the .maps section, we'll need them + // during parsing + let symbols = self.symbols_by_index.values().filter(|s| { + s.section_index + .map(|idx| idx == section.index.0) + .unwrap_or(false) + }); + + let res = parse_maps_section(&mut maps, §ion, symbols); + + // put the maps back + self.maps = maps; + + res? } BpfSectionKind::Program => { let program = self.parse_program(§ion)?; @@ -911,6 +885,45 @@ impl Object { } } +// Parses multiple map definition contained in a single `maps` section (which is +// different from `.maps` which is used for BTF). We can tell where each map is +// based on the symbol table. +fn parse_maps_section<'a, I: Iterator>( + maps: &mut HashMap, + section: &Section, + symbols: I, +) -> Result<(), ParseError> { + let mut have_symbols = false; + + // each symbol in the section is a separate map + for (i, sym) in symbols.enumerate() { + let start = sym.address as usize; + let end = start + sym.size as usize; + let data = §ion.data[start..end]; + let name = sym + .name + .as_ref() + .ok_or(ParseError::MapSymbolNameNotFound { i })?; + let def = parse_map_def(name, data)?; + maps.insert( + name.to_string(), + Map::Legacy(LegacyMap { + section_index: section.index.0, + symbol_index: sym.index, + def, + data: Vec::new(), + kind: MapKind::Other, + }), + ); + have_symbols = true; + } + if !have_symbols { + return Err(ParseError::NoSymbolsForMapSection); + } + + Ok(()) +} + /// Errors caught during parsing the object file #[derive(Debug, Error)] #[allow(missing_docs)] @@ -974,8 +987,8 @@ pub enum ParseError { #[error("the map number {i} in the `maps` section doesn't have a symbol name")] MapSymbolNameNotFound { i: usize }, - #[error("no symbols found for the maps included in the maps section")] - NoSymbolsInMapSection {}, + #[error("no symbols for `maps` section, can't parse maps")] + NoSymbolsForMapsSection, /// No BTF parsed for object #[error("no BTF parsed for object")] From 401ea5e8482ece34b6c88de85ec474bdfc577fd4 Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Sun, 9 Apr 2023 22:14:28 +1000 Subject: [PATCH 3/7] aya, aya-obj: refactor map relocations Clearly split the code between `.maps`, `maps` and data maps (bss, data, rodata). Sprinkle comments. Remove MapKind which was effectively only needed since we used to have one variant - BpfSectionKind::Data - to represent all data maps. Instead add explicit BpfSectionKind::{Data, Rodata, Bss} variants and match on those when we initialize maps. --- aya-obj/src/maps.rs | 70 +++++++----------- aya-obj/src/obj.rs | 114 +++++++++++------------------- aya-obj/src/relocation.rs | 71 ++++++++++++------- aya/src/bpf.rs | 6 +- aya/src/maps/bloom_filter.rs | 13 ++-- aya/src/maps/hash_map/hash_map.rs | 13 ++-- aya/src/maps/lpm_trie.rs | 13 ++-- aya/src/maps/mod.rs | 6 +- 8 files changed, 133 insertions(+), 173 deletions(-) diff --git a/aya-obj/src/maps.rs b/aya-obj/src/maps.rs index a6c3c96c..22a88da9 100644 --- a/aya-obj/src/maps.rs +++ b/aya-obj/src/maps.rs @@ -2,7 +2,10 @@ use core::mem; -use crate::thiserror::{self, Error}; +use crate::{ + thiserror::{self, Error}, + BpfSectionKind, +}; use alloc::vec::Vec; /// Invalid map type encontered @@ -139,33 +142,6 @@ pub struct bpf_map_def { /// The first five __u32 of `bpf_map_def` must be defined. pub(crate) const MINIMUM_MAP_SIZE: usize = mem::size_of::() * 5; -/// Kinds of maps -#[derive(Debug, Copy, Clone, PartialEq, Eq)] -pub enum MapKind { - /// A map holding `.bss` section data - Bss, - /// A map holding `.data` section data - Data, - /// A map holding `.rodata` section data - Rodata, - /// Other maps - Other, -} - -impl From<&str> for MapKind { - fn from(s: &str) -> Self { - if s == ".bss" { - MapKind::Bss - } else if s.starts_with(".data") { - MapKind::Data - } else if s.starts_with(".rodata") { - MapKind::Rodata - } else { - MapKind::Other - } - } -} - /// Map data defined in `maps` or `.maps` sections #[derive(Debug, Clone)] pub enum Map { @@ -248,14 +224,6 @@ impl Map { } } - /// Returns the map kind - pub fn kind(&self) -> MapKind { - match self { - Map::Legacy(m) => m.kind, - Map::Btf(m) => m.kind, - } - } - /// Returns the section index pub fn section_index(&self) -> usize { match self { @@ -264,11 +232,22 @@ impl Map { } } - /// Returns the symbol index - pub fn symbol_index(&self) -> usize { + /// Returns the section kind. + pub fn section_kind(&self) -> BpfSectionKind { + match self { + Map::Legacy(m) => m.section_kind, + Map::Btf(_) => BpfSectionKind::BtfMaps, + } + } + + /// Returns the symbol index. + /// + /// This is `None` for data maps (.bss, .data and .rodata) since those don't + /// need symbols in order to be relocated. + pub fn symbol_index(&self) -> Option { match self { Map::Legacy(m) => m.symbol_index, - Map::Btf(m) => m.symbol_index, + Map::Btf(m) => Some(m.symbol_index), } } } @@ -283,12 +262,16 @@ pub struct LegacyMap { pub def: bpf_map_def, /// The section index pub section_index: usize, - /// The symbol index - pub symbol_index: usize, + /// The section kind + pub section_kind: BpfSectionKind, + /// The symbol index. + /// + /// This is None for data maps (.bss .data and .rodata). We don't need + /// symbols to relocate those since they don't contain multiple maps, but + /// are just a flat array of bytes. + pub symbol_index: Option, /// The map data pub data: Vec, - /// The map kind - pub kind: MapKind, } /// A BTF-defined map, most likely from a `.maps` section. @@ -298,6 +281,5 @@ pub struct BtfMap { pub def: BtfMapDef, pub(crate) section_index: usize, pub(crate) symbol_index: usize, - pub(crate) kind: MapKind, pub(crate) data: Vec, } diff --git a/aya-obj/src/obj.rs b/aya-obj/src/obj.rs index 7f040b24..0d110fff 100644 --- a/aya-obj/src/obj.rs +++ b/aya-obj/src/obj.rs @@ -15,7 +15,7 @@ use object::{ }; use crate::{ - maps::{BtfMap, LegacyMap, Map, MapKind, MINIMUM_MAP_SIZE}, + maps::{BtfMap, LegacyMap, Map, MINIMUM_MAP_SIZE}, relocation::*, thiserror::{self, Error}, util::HashMap, @@ -794,7 +794,6 @@ impl Object { def, section_index: section.index.0, symbol_index, - kind: MapKind::Other, data: Vec::new(), }), ); @@ -820,9 +819,9 @@ impl Object { self.section_sizes .insert(section.name.to_owned(), section.size); match section.kind { - BpfSectionKind::Data => { + BpfSectionKind::Data | BpfSectionKind::Rodata | BpfSectionKind::Bss => { self.maps - .insert(section.name.to_string(), parse_map(§ion, section.name)?); + .insert(section.name.to_string(), parse_data_map_section(§ion)?); } BpfSectionKind::Text => self.parse_text_section(section)?, BpfSectionKind::Btf => self.parse_btf(§ion)?, @@ -909,16 +908,16 @@ fn parse_maps_section<'a, I: Iterator>( name.to_string(), Map::Legacy(LegacyMap { section_index: section.index.0, - symbol_index: sym.index, + section_kind: section.kind, + symbol_index: Some(sym.index), def, data: Vec::new(), - kind: MapKind::Other, }), ); have_symbols = true; } if !have_symbols { - return Err(ParseError::NoSymbolsForMapSection); + return Err(ParseError::NoSymbolsForMapsSection); } Ok(()) @@ -995,17 +994,32 @@ pub enum ParseError { NoBTF, } -#[derive(Debug)] -enum BpfSectionKind { +/// The kind of an ELF section. +#[derive(Debug, Copy, Clone, Eq, PartialEq)] +pub enum BpfSectionKind { + /// Undefined Undefined, + /// `maps` Maps, + /// `.maps` BtfMaps, + /// A program section Program, + /// `.data` Data, + /// `.rodata` + Rodata, + /// `.bss` + Bss, + /// `.text` Text, + /// `.BTF` Btf, + /// `.BTF.ext` BtfExt, + /// `license` License, + /// `version` Version, } @@ -1172,10 +1186,11 @@ impl From for u32 { } } -fn parse_map(section: &Section, name: &str) -> Result { - let kind = MapKind::from(name); - let (def, data) = match kind { - MapKind::Bss | MapKind::Data | MapKind::Rodata => { +// Parsed '.bss' '.data' and '.rodata' sections. These sections are arrays of +// bytes and are relocated based on their section index. +fn parse_data_map_section(section: &Section) -> Result { + let (def, data) = match section.kind { + BpfSectionKind::Bss | BpfSectionKind::Data | BpfSectionKind::Rodata => { let def = bpf_map_def { map_type: BPF_MAP_TYPE_ARRAY as u32, key_size: mem::size_of::() as u32, @@ -1183,7 +1198,7 @@ fn parse_map(section: &Section, name: &str) -> Result { // .bss will always have data.len() == 0 value_size: section.size as u32, max_entries: 1, - map_flags: if kind == MapKind::Rodata { + map_flags: if section.kind == BpfSectionKind::Rodata { BPF_F_RDONLY_PROG } else { 0 @@ -1192,14 +1207,15 @@ fn parse_map(section: &Section, name: &str) -> Result { }; (def, section.data.to_vec()) } - MapKind::Other => (parse_map_def(name, section.data)?, Vec::new()), + _ => unreachable!(), }; Ok(Map::Legacy(LegacyMap { section_index: section.index.0, - symbol_index: 0, + section_kind: section.kind, + // Data maps don't require symbols to be relocated + symbol_index: None, def, data, - kind, })) } @@ -1319,8 +1335,6 @@ pub fn parse_map_info(info: bpf_map_info, pinned: PinningType) -> Map { section_index: 0, symbol_index: 0, data: Vec::new(), - // We should never be loading the .bss or .data or .rodata FDs - kind: MapKind::Other, }) } else { Map::Legacy(LegacyMap { @@ -1334,10 +1348,9 @@ pub fn parse_map_info(info: bpf_map_info, pinned: PinningType) -> Map { id: info.id, }, section_index: 0, - symbol_index: 0, + symbol_index: None, + section_kind: BpfSectionKind::Undefined, data: Vec::new(), - // We should never be loading the .bss or .data or .rodata FDs - kind: MapKind::Other, }) } } @@ -1523,65 +1536,21 @@ mod tests { assert_eq!(parse_map_def("foo", &buf).unwrap(), def); } - #[test] - fn test_parse_map_error() { - assert!(matches!( - parse_map(&fake_section(BpfSectionKind::Maps, "maps/foo", &[]), "foo",), - Err(ParseError::InvalidMapDefinition { .. }) - )); - } - - #[test] - fn test_parse_map() { - assert!(matches!( - parse_map( - &fake_section( - BpfSectionKind::Maps, - "maps/foo", - bytes_of(&bpf_map_def { - map_type: 1, - key_size: 2, - value_size: 3, - max_entries: 4, - map_flags: 5, - id: 0, - pinning: PinningType::None, - }) - ), - "foo" - ), - Ok(Map::Legacy(LegacyMap{ - section_index: 0, - def: bpf_map_def { - map_type: 1, - key_size: 2, - value_size: 3, - max_entries: 4, - map_flags: 5, - id: 0, - pinning: PinningType::None, - }, - data, - .. - })) if data.is_empty() - )) - } - #[test] fn test_parse_map_data() { let map_data = b"map data"; assert!(matches!( - parse_map( + parse_data_map_section( &fake_section( BpfSectionKind::Data, ".bss", map_data, ), - ".bss" ), Ok(Map::Legacy(LegacyMap { section_index: 0, - symbol_index: 0, + section_kind: BpfSectionKind::Data, + symbol_index: None, def: bpf_map_def { map_type: _map_type, key_size: 4, @@ -1592,8 +1561,7 @@ mod tests { pinning: PinningType::None, }, data, - kind - })) if data == map_data && value_size == map_data.len() as u32 && kind == MapKind::Bss + })) if data == map_data && value_size == map_data.len() as u32 )) } @@ -2240,9 +2208,9 @@ mod tests { pinning: PinningType::None, }, section_index: 1, - symbol_index: 1, + section_kind: BpfSectionKind::Rodata, + symbol_index: Some(1), data: vec![0, 0, 0], - kind: MapKind::Rodata, }), ); obj.symbols_by_index.insert( diff --git a/aya-obj/src/relocation.rs b/aya-obj/src/relocation.rs index 8b0b9170..6b41b9eb 100644 --- a/aya-obj/src/relocation.rs +++ b/aya-obj/src/relocation.rs @@ -15,6 +15,7 @@ use crate::{ obj::{Function, Object, Program}, thiserror::{self, Error}, util::HashMap, + BpfSectionKind, }; pub(crate) const INS_SIZE: usize = mem::size_of::(); @@ -109,7 +110,9 @@ impl Object { let mut maps_by_symbol = HashMap::new(); for (name, fd, map) in maps { maps_by_section.insert(map.section_index(), (name, fd, map)); - maps_by_symbol.insert(map.symbol_index(), (name, fd, map)); + if let Some(index) = map.symbol_index() { + maps_by_symbol.insert(index, (name, fd, map)); + } } let functions = self @@ -193,10 +196,9 @@ fn relocate_maps<'a, I: Iterator>( index: rel.symbol_index, })?; - let section_index = match sym.section_index { - Some(index) => index, + let Some(section_index) = sym.section_index else { // this is not a map relocation - None => continue, + continue; }; // calls and relocation to .text symbols are handled in a separate step @@ -204,23 +206,42 @@ fn relocate_maps<'a, I: Iterator>( continue; } - let (name, fd, map) = if maps_by_symbol.contains_key(&rel.symbol_index) { - maps_by_symbol - .get(&rel.symbol_index) - .ok_or(RelocationError::SectionNotFound { - symbol_index: rel.symbol_index, - symbol_name: sym.name.clone(), - section_index, - })? + let (name, fd, map) = if let Some(m) = maps_by_symbol.get(&rel.symbol_index) { + let map = &m.2; + debug!( + "relocating map by symbol index {}, kind {:?}", + map.section_index(), + map.section_kind() + ); + debug_assert_eq!(map.symbol_index().unwrap(), rel.symbol_index); + m } else { - maps_by_section - .get(§ion_index) - .ok_or(RelocationError::SectionNotFound { + let Some(m) = maps_by_section.get(§ion_index) else { + debug!( + "failed relocating map by section index {}", + section_index + ); + return Err(RelocationError::SectionNotFound { symbol_index: rel.symbol_index, symbol_name: sym.name.clone(), section_index, - })? + }); + }; + let map = &m.2; + debug!( + "relocating map by section index {}, kind {:?}", + map.section_index(), + map.section_kind() + ); + + debug_assert_eq!(map.symbol_index(), None); + debug_assert!(matches!( + map.section_kind(), + BpfSectionKind::Bss | BpfSectionKind::Data | BpfSectionKind::Rodata + ),); + m }; + debug_assert_eq!(map.section_index(), section_index); let map_fd = fd.ok_or_else(|| RelocationError::MapNotCreated { name: (*name).into(), @@ -476,7 +497,10 @@ fn insn_is_call(ins: &bpf_insn) -> bool { mod test { use alloc::{string::ToString, vec, vec::Vec}; - use crate::maps::{bpf_map_def, BtfMap, BtfMapDef, LegacyMap, Map, MapKind}; + use crate::{ + maps::{bpf_map_def, BtfMap, BtfMapDef, LegacyMap, Map}, + BpfSectionKind, + }; use super::*; @@ -498,25 +522,20 @@ mod test { fn fake_legacy_map(symbol_index: usize) -> Map { Map::Legacy(LegacyMap { - def: bpf_map_def { - ..Default::default() - }, + def: Default::default(), section_index: 0, - symbol_index, + section_kind: BpfSectionKind::Undefined, + symbol_index: Some(symbol_index), data: Vec::new(), - kind: MapKind::Other, }) } fn fake_btf_map(symbol_index: usize) -> Map { Map::Btf(BtfMap { - def: BtfMapDef { - ..Default::default() - }, + def: Default::default(), section_index: 0, symbol_index, data: Vec::new(), - kind: MapKind::Other, }) } diff --git a/aya/src/bpf.rs b/aya/src/bpf.rs index e94b2f6c..81d6051f 100644 --- a/aya/src/bpf.rs +++ b/aya/src/bpf.rs @@ -11,6 +11,7 @@ use aya_obj::{ btf::{BtfFeatures, BtfRelocationError}, generated::BPF_F_XDP_HAS_FRAGS, relocation::BpfRelocationError, + BpfSectionKind, }; use log::debug; use thiserror::Error; @@ -23,7 +24,6 @@ use crate::{ maps::{Map, MapData, MapError}, obj::{ btf::{Btf, BtfError}, - maps::MapKind, Object, ParseError, ProgramSection, }, programs::{ @@ -415,14 +415,14 @@ impl<'a> BpfLoader<'a> { } PinningType::None => map.create(&name)?, }; - if !map.obj.data().is_empty() && map.obj.kind() != MapKind::Bss { + if !map.obj.data().is_empty() && map.obj.section_kind() != BpfSectionKind::Bss { bpf_map_update_elem_ptr(fd, &0 as *const _, map.obj.data_mut().as_mut_ptr(), 0) .map_err(|(_, io_error)| MapError::SyscallError { call: "bpf_map_update_elem".to_owned(), io_error, })?; } - if map.obj.kind() == MapKind::Rodata { + if map.obj.section_kind() == BpfSectionKind::Rodata { bpf_map_freeze(fd).map_err(|(_, io_error)| MapError::SyscallError { call: "bpf_map_freeze".to_owned(), io_error, diff --git a/aya/src/maps/bloom_filter.rs b/aya/src/maps/bloom_filter.rs index 16eb1aa3..a58b9b44 100644 --- a/aya/src/maps/bloom_filter.rs +++ b/aya/src/maps/bloom_filter.rs @@ -84,10 +84,7 @@ mod tests { bpf_map_type::{BPF_MAP_TYPE_BLOOM_FILTER, BPF_MAP_TYPE_PERF_EVENT_ARRAY}, }, maps::{Map, MapData}, - obj::{ - self, - maps::{LegacyMap, MapKind}, - }, + obj::{self, maps::LegacyMap, BpfSectionKind}, sys::{override_syscall, SysResult, Syscall}, }; use libc::{EFAULT, ENOENT}; @@ -103,9 +100,9 @@ mod tests { ..Default::default() }, section_index: 0, - symbol_index: 0, + section_kind: BpfSectionKind::Maps, + symbol_index: None, data: Vec::new(), - kind: MapKind::Other, }) } @@ -142,9 +139,9 @@ mod tests { ..Default::default() }, section_index: 0, - symbol_index: 0, + section_kind: BpfSectionKind::Maps, + symbol_index: None, data: Vec::new(), - kind: MapKind::Other, }), fd: None, pinned: false, diff --git a/aya/src/maps/hash_map/hash_map.rs b/aya/src/maps/hash_map/hash_map.rs index a67cdead..14f5e73f 100644 --- a/aya/src/maps/hash_map/hash_map.rs +++ b/aya/src/maps/hash_map/hash_map.rs @@ -117,10 +117,7 @@ mod tests { bpf_map_type::{BPF_MAP_TYPE_HASH, BPF_MAP_TYPE_LRU_HASH}, }, maps::{Map, MapData}, - obj::{ - self, - maps::{LegacyMap, MapKind}, - }, + obj::{self, maps::LegacyMap, BpfSectionKind}, sys::{override_syscall, SysResult, Syscall}, }; @@ -136,9 +133,9 @@ mod tests { ..Default::default() }, section_index: 0, + section_kind: BpfSectionKind::Maps, data: Vec::new(), - kind: MapKind::Other, - symbol_index: 0, + symbol_index: None, }) } @@ -267,9 +264,9 @@ mod tests { ..Default::default() }, section_index: 0, - symbol_index: 0, + section_kind: BpfSectionKind::Maps, + symbol_index: None, data: Vec::new(), - kind: MapKind::Other, }), fd: Some(42), pinned: false, diff --git a/aya/src/maps/lpm_trie.rs b/aya/src/maps/lpm_trie.rs index 4a6cc94f..d8f3b66b 100644 --- a/aya/src/maps/lpm_trie.rs +++ b/aya/src/maps/lpm_trie.rs @@ -247,10 +247,7 @@ mod tests { bpf_map_type::{BPF_MAP_TYPE_LPM_TRIE, BPF_MAP_TYPE_PERF_EVENT_ARRAY}, }, maps::{Map, MapData}, - obj::{ - self, - maps::{LegacyMap, MapKind}, - }, + obj::{self, maps::LegacyMap, BpfSectionKind}, sys::{override_syscall, SysResult, Syscall}, }; use libc::{EFAULT, ENOENT}; @@ -266,9 +263,9 @@ mod tests { ..Default::default() }, section_index: 0, - symbol_index: 0, + section_kind: BpfSectionKind::Maps, + symbol_index: None, data: Vec::new(), - kind: MapKind::Other, }) } @@ -322,9 +319,9 @@ mod tests { ..Default::default() }, section_index: 0, - symbol_index: 0, + section_kind: BpfSectionKind::Maps, + symbol_index: None, data: Vec::new(), - kind: MapKind::Other, }), fd: None, btf_fd: None, diff --git a/aya/src/maps/mod.rs b/aya/src/maps/mod.rs index 505adafd..271cbab8 100644 --- a/aya/src/maps/mod.rs +++ b/aya/src/maps/mod.rs @@ -845,7 +845,7 @@ mod tests { bpf_map_def, generated::{bpf_cmd, bpf_map_type::BPF_MAP_TYPE_HASH}, maps::MapData, - obj::maps::{LegacyMap, MapKind}, + obj::{maps::LegacyMap, BpfSectionKind}, sys::{override_syscall, Syscall}, }; @@ -861,9 +861,9 @@ mod tests { ..Default::default() }, section_index: 0, - symbol_index: 0, + section_kind: BpfSectionKind::Maps, + symbol_index: Some(0), data: Vec::new(), - kind: MapKind::Other, }) } From b25a08981986cac4f511433d165560576a8c9856 Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Sun, 9 Apr 2023 23:01:55 +1000 Subject: [PATCH 4/7] aya-obj: change two drain() calls to into_iter() --- aya-obj/src/obj.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/aya-obj/src/obj.rs b/aya-obj/src/obj.rs index 0d110fff..b6b0a323 100644 --- a/aya-obj/src/obj.rs +++ b/aya-obj/src/obj.rs @@ -753,7 +753,7 @@ impl Object { section.index, section .relocations - .drain(..) + .into_iter() .map(|rel| (rel.offset, rel)) .collect(), ); @@ -871,7 +871,7 @@ impl Object { section.index, section .relocations - .drain(..) + .into_iter() .map(|rel| (rel.offset, rel)) .collect(), ); From b2b9bd2edff633c701b89cc64b1602adc18c61da Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Tue, 11 Apr 2023 22:59:38 +1000 Subject: [PATCH 5/7] integration tests: add relocation tests --- test/integration-ebpf/Cargo.toml | 4 ++ .../src/bpf/text_64_64_reloc.c | 28 ++++++++ test/integration-ebpf/src/relocations.rs | 45 ++++++++++++ test/integration-test/src/tests/mod.rs | 1 + .../integration-test/src/tests/relocations.rs | 70 +++++++++++++++++++ 5 files changed, 148 insertions(+) create mode 100644 test/integration-ebpf/src/bpf/text_64_64_reloc.c create mode 100644 test/integration-ebpf/src/relocations.rs create mode 100644 test/integration-test/src/tests/relocations.rs diff --git a/test/integration-ebpf/Cargo.toml b/test/integration-ebpf/Cargo.toml index 8668b91d..69c60316 100644 --- a/test/integration-ebpf/Cargo.toml +++ b/test/integration-ebpf/Cargo.toml @@ -22,3 +22,7 @@ path = "src/pass.rs" [[bin]] name = "test" path = "src/test.rs" + +[[bin]] +name = "relocations" +path = "src/relocations.rs" diff --git a/test/integration-ebpf/src/bpf/text_64_64_reloc.c b/test/integration-ebpf/src/bpf/text_64_64_reloc.c new file mode 100644 index 00000000..877c7628 --- /dev/null +++ b/test/integration-ebpf/src/bpf/text_64_64_reloc.c @@ -0,0 +1,28 @@ +#include +#include + +char _license[] SEC("license") = "GPL"; + +struct { + __uint(type, BPF_MAP_TYPE_ARRAY); + __type(key, __u32); + __type(value, __u64); + __uint(max_entries, 2); +} RESULTS SEC(".maps"); + +static __u64 +inc_cb(void *map, __u32 *key, void *val, + void *data) +{ + __u64 *value = val; + *value += 1; + return 0; +} + +SEC("uprobe/test_text_64_64_reloc") +int test_text_64_64_reloc(struct pt_regs *ctx) +{ + bpf_for_each_map_elem(&RESULTS, inc_cb, NULL, 0); + return 0; +} + diff --git a/test/integration-ebpf/src/relocations.rs b/test/integration-ebpf/src/relocations.rs new file mode 100644 index 00000000..ee8a21f6 --- /dev/null +++ b/test/integration-ebpf/src/relocations.rs @@ -0,0 +1,45 @@ +#![no_std] +#![no_main] + +use core::hint; + +use aya_bpf::{ + macros::{map, uprobe}, + maps::Array, + programs::ProbeContext, +}; + +#[map] +static mut RESULTS: Array = Array::with_max_entries(3, 0); + +#[uprobe] +pub fn test_64_32_call_relocs(_ctx: ProbeContext) { + // this will link set_result and do a forward call + set_result(0, hint::black_box(1)); + + // set_result is already linked, this will just do the forward call + set_result(1, hint::black_box(2)); + + // this will link set_result_backward after set_result. Then will do a + // backward call to set_result. + set_result_backward(2, hint::black_box(3)); +} + +#[inline(never)] +fn set_result(index: u32, value: u64) { + unsafe { + if let Some(v) = RESULTS.get_ptr_mut(index) { + *v = value; + } + } +} + +#[inline(never)] +fn set_result_backward(index: u32, value: u64) { + set_result(index, value); +} + +#[panic_handler] +fn panic(_info: &core::panic::PanicInfo) -> ! { + unsafe { core::hint::unreachable_unchecked() } +} diff --git a/test/integration-test/src/tests/mod.rs b/test/integration-test/src/tests/mod.rs index b7a171b1..127b037d 100644 --- a/test/integration-test/src/tests/mod.rs +++ b/test/integration-test/src/tests/mod.rs @@ -8,6 +8,7 @@ pub mod btf_relocations; pub mod elf; pub mod load; pub mod rbpf; +pub mod relocations; pub mod smoke; pub use integration_test_macros::integration_test; diff --git a/test/integration-test/src/tests/relocations.rs b/test/integration-test/src/tests/relocations.rs new file mode 100644 index 00000000..8a97a822 --- /dev/null +++ b/test/integration-test/src/tests/relocations.rs @@ -0,0 +1,70 @@ +use std::{process::exit, time::Duration}; + +use aya::{ + include_bytes_aligned, + programs::{ProgramError, UProbe}, + Bpf, +}; +use integration_test_macros::integration_test; + +#[integration_test] +fn relocations() { + let bpf = load_and_attach( + "test_64_32_call_relocs", + include_bytes_aligned!("../../../../target/bpfel-unknown-none/release/relocations"), + ); + + trigger_relocations_program(); + std::thread::sleep(Duration::from_millis(100)); + + let m = aya::maps::Array::<_, u64>::try_from(bpf.map("RESULTS").unwrap()).unwrap(); + assert_eq!(m.get(&0, 0).unwrap(), 1); + assert_eq!(m.get(&1, 0).unwrap(), 2); + assert_eq!(m.get(&2, 0).unwrap(), 3); +} + +#[integration_test] +fn text_64_64_reloc() { + let mut bpf = load_and_attach( + "test_text_64_64_reloc", + include_bytes_aligned!("../../../../target/bpfel-unknown-none/release/text_64_64_reloc.o"), + ); + + let mut m = aya::maps::Array::<_, u64>::try_from(bpf.map_mut("RESULTS").unwrap()).unwrap(); + m.set(0, 1, 0).unwrap(); + m.set(1, 2, 0).unwrap(); + + trigger_relocations_program(); + std::thread::sleep(Duration::from_millis(100)); + + assert_eq!(m.get(&0, 0).unwrap(), 2); + assert_eq!(m.get(&1, 0).unwrap(), 3); +} + +fn load_and_attach(name: &str, bytes: &[u8]) -> Bpf { + let mut bpf = Bpf::load(bytes).unwrap(); + + let prog: &mut UProbe = bpf.program_mut(name).unwrap().try_into().unwrap(); + if let Err(ProgramError::LoadError { + io_error, + verifier_log, + }) = prog.load() + { + println!("Failed to load program `{name}`: {io_error}. Verifier log:\n{verifier_log:#}"); + exit(1); + }; + + prog.attach( + Some("trigger_relocations_program"), + 0, + "/proc/self/exe", + None, + ) + .unwrap(); + + bpf +} + +#[no_mangle] +#[inline(never)] +pub extern "C" fn trigger_relocations_program() {} From 93ac3e94bcb47864670c124dfe00e16ed2ab6f5e Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Tue, 11 Apr 2023 23:24:55 +1000 Subject: [PATCH 6/7] aya: support relocations across multiple text sections + fixes Fix R_BPF_64_64 text relocations in sections other than .text (for instance .text.unlikely). Also fix misc bugs triggered by integration tests. --- aya-obj/src/btf/btf.rs | 4 +- aya-obj/src/lib.rs | 5 +- aya-obj/src/obj.rs | 33 ++-- aya-obj/src/relocation.rs | 196 ++++++++++++------------ aya/src/bpf.rs | 9 +- test/integration-test/src/tests/rbpf.rs | 8 +- 6 files changed, 136 insertions(+), 119 deletions(-) diff --git a/aya-obj/src/btf/btf.rs b/aya-obj/src/btf/btf.rs index f439ee1a..ac915bfd 100644 --- a/aya-obj/src/btf/btf.rs +++ b/aya-obj/src/btf/btf.rs @@ -1045,9 +1045,7 @@ mod tests { let name_offset = btf.add_string("&mut int".to_string()); let ptr_type_id = btf.add_type(BtfType::Ptr(Ptr::new(name_offset, int_type_id))); - let features = BtfFeatures { - ..Default::default() - }; + let features = Default::default(); btf.fixup_and_sanitize(&HashMap::new(), &HashMap::new(), &features) .unwrap(); diff --git a/aya-obj/src/lib.rs b/aya-obj/src/lib.rs index 438e38f2..3775295e 100644 --- a/aya-obj/src/lib.rs +++ b/aya-obj/src/lib.rs @@ -37,8 +37,9 @@ //! let bytes = std::fs::read("program.o").unwrap(); //! let mut object = Object::parse(&bytes).unwrap(); //! // Relocate the programs -//! object.relocate_calls().unwrap(); -//! object.relocate_maps(std::iter::empty()).unwrap(); +//! let text_sections = std::collections::HashSet::new(); +//! object.relocate_calls(&text_sections).unwrap(); +//! object.relocate_maps(std::iter::empty(), &text_sections).unwrap(); //! //! // Run with rbpf //! let instructions = &object.programs["prog_name"].function.instructions; diff --git a/aya-obj/src/obj.rs b/aya-obj/src/obj.rs index b6b0a323..1a376b58 100644 --- a/aya-obj/src/obj.rs +++ b/aya-obj/src/obj.rs @@ -52,14 +52,13 @@ pub struct Object { /// in [ProgramSection]s as keys. pub programs: HashMap, /// Functions - pub functions: HashMap, + pub functions: HashMap<(usize, u64), Function>, pub(crate) relocations: HashMap>, - pub(crate) symbols_by_index: HashMap, + pub(crate) symbol_table: HashMap, pub(crate) section_sizes: HashMap, // symbol_offset_by_name caches symbols that could be referenced from a // BTF VAR type so the offsets can be fixed up pub(crate) symbol_offset_by_name: HashMap, - pub(crate) text_section_index: Option, } /// An eBPF program @@ -522,7 +521,7 @@ impl Object { is_definition: symbol.is_definition(), kind: symbol.kind(), }; - bpf_obj.symbols_by_index.insert(symbol.index().0, sym); + bpf_obj.symbol_table.insert(symbol.index().0, sym); if symbol.is_global() || symbol.kind() == SymbolKind::Data { bpf_obj.symbol_offset_by_name.insert(name, symbol.address()); @@ -564,17 +563,16 @@ impl Object { programs: HashMap::new(), functions: HashMap::new(), relocations: HashMap::new(), - symbols_by_index: HashMap::new(), + symbol_table: HashMap::new(), section_sizes: HashMap::new(), symbol_offset_by_name: HashMap::new(), - text_section_index: None, } } /// Patches map data pub fn patch_map_data(&mut self, globals: HashMap<&str, &[u8]>) -> Result<(), ParseError> { let symbols: HashMap = self - .symbols_by_index + .symbol_table .iter() .filter(|(_, s)| s.name.is_some()) .map(|(_, s)| (s.name.as_ref().unwrap().clone(), s)) @@ -668,12 +666,10 @@ impl Object { }) } - fn parse_text_section(&mut self, mut section: Section) -> Result<(), ParseError> { - self.text_section_index = Some(section.index.0); - + fn parse_text_section(&mut self, section: Section) -> Result<(), ParseError> { let mut symbols_by_address = HashMap::new(); - for sym in self.symbols_by_index.values() { + for sym in self.symbol_table.values() { if sym.is_definition && sym.kind == SymbolKind::Text && sym.section_index == Some(section.index.0) @@ -729,7 +725,7 @@ impl Object { }; self.functions.insert( - sym.address, + (section.index.0, sym.address), Function { address, name: sym.name.clone().unwrap(), @@ -804,7 +800,7 @@ impl Object { Ok(()) } - fn parse_section(&mut self, mut section: Section) -> Result<(), ParseError> { + fn parse_section(&mut self, section: Section) -> Result<(), ParseError> { let mut parts = section.name.rsplitn(2, '/').collect::>(); parts.reverse(); @@ -828,7 +824,7 @@ impl Object { BpfSectionKind::BtfExt => self.parse_btf_ext(§ion)?, BpfSectionKind::BtfMaps => { let symbols: HashMap = self - .symbols_by_index + .symbol_table .values() .filter(|s| { if let Some(idx) = s.section_index { @@ -849,7 +845,7 @@ impl Object { // extract the symbols for the .maps section, we'll need them // during parsing - let symbols = self.symbols_by_index.values().filter(|s| { + let symbols = self.symbol_table.values().filter(|s| { s.section_index .map(|idx| idx == section.index.0) .unwrap_or(false) @@ -1097,6 +1093,7 @@ impl<'data, 'file, 'a> TryFrom<&'a ObjSection<'data, 'file>> for Section<'a> { _ => return Err(ParseError::UnsupportedRelocationTarget), }, offset, + size: r.size(), }) }) .collect::, _>>()?, @@ -1399,8 +1396,8 @@ mod tests { } fn fake_sym(obj: &mut Object, section_index: usize, address: u64, name: &str, size: u64) { - let idx = obj.symbols_by_index.len(); - obj.symbols_by_index.insert( + let idx = obj.symbol_table.len(); + obj.symbol_table.insert( idx + 1, Symbol { index: idx + 1, @@ -2213,7 +2210,7 @@ mod tests { data: vec![0, 0, 0], }), ); - obj.symbols_by_index.insert( + obj.symbol_table.insert( 1, Symbol { index: 1, diff --git a/aya-obj/src/relocation.rs b/aya-obj/src/relocation.rs index 6b41b9eb..c2f2096d 100644 --- a/aya-obj/src/relocation.rs +++ b/aya-obj/src/relocation.rs @@ -1,6 +1,7 @@ //! Program relocation handling. use core::mem; +use std::collections::HashSet; use alloc::{borrow::ToOwned, string::String}; use log::debug; @@ -85,6 +86,7 @@ pub enum RelocationError { pub(crate) struct Relocation { // byte offset of the instruction to be relocated pub(crate) offset: u64, + pub(crate) size: u8, // index of the symbol to relocate to pub(crate) symbol_index: usize, } @@ -105,6 +107,7 @@ impl Object { pub fn relocate_maps<'a, I: Iterator, &'a Map)>>( &mut self, maps: I, + text_sections: &HashSet, ) -> Result<(), BpfRelocationError> { let mut maps_by_section = HashMap::new(); let mut maps_by_symbol = HashMap::new(); @@ -128,8 +131,8 @@ impl Object { relocations.values(), &maps_by_section, &maps_by_symbol, - &self.symbols_by_index, - self.text_section_index, + &self.symbol_table, + text_sections, ) .map_err(|error| BpfRelocationError { function: function.name.clone(), @@ -142,13 +145,16 @@ impl Object { } /// Relocates function calls - pub fn relocate_calls(&mut self) -> Result<(), BpfRelocationError> { + pub fn relocate_calls( + &mut self, + text_sections: &HashSet, + ) -> Result<(), BpfRelocationError> { for (name, program) in self.programs.iter_mut() { let linker = FunctionLinker::new( - self.text_section_index, &self.functions, &self.relocations, - &self.symbols_by_index, + &self.symbol_table, + text_sections, ); linker.link(program).map_err(|error| BpfRelocationError { function: name.to_owned(), @@ -166,7 +172,7 @@ fn relocate_maps<'a, I: Iterator>( maps_by_section: &HashMap, &Map)>, maps_by_symbol: &HashMap, &Map)>, symbol_table: &HashMap, - text_section_index: Option, + text_sections: &HashSet, ) -> Result<(), RelocationError> { let section_offset = fun.section_offset; let instructions = &mut fun.instructions; @@ -202,16 +208,17 @@ fn relocate_maps<'a, I: Iterator>( }; // calls and relocation to .text symbols are handled in a separate step - if insn_is_call(&instructions[ins_index]) || sym.section_index == text_section_index { + if insn_is_call(&instructions[ins_index]) || text_sections.contains(§ion_index) { continue; } let (name, fd, map) = if let Some(m) = maps_by_symbol.get(&rel.symbol_index) { let map = &m.2; debug!( - "relocating map by symbol index {}, kind {:?}", - map.section_index(), - map.section_kind() + "relocating map by symbol index {:?}, kind {:?} at insn {ins_index} in section {}", + map.symbol_index(), + map.section_kind(), + fun.section_index.0 ); debug_assert_eq!(map.symbol_index().unwrap(), rel.symbol_index); m @@ -229,9 +236,10 @@ fn relocate_maps<'a, I: Iterator>( }; let map = &m.2; debug!( - "relocating map by section index {}, kind {:?}", + "relocating map by section index {}, kind {:?} at insn {ins_index} in section {}", map.section_index(), - map.section_kind() + map.section_kind(), + fun.section_index.0, ); debug_assert_eq!(map.symbol_index(), None); @@ -261,26 +269,26 @@ fn relocate_maps<'a, I: Iterator>( } struct FunctionLinker<'a> { - text_section_index: Option, - functions: &'a HashMap, + functions: &'a HashMap<(usize, u64), Function>, linked_functions: HashMap, relocations: &'a HashMap>, symbol_table: &'a HashMap, + text_sections: &'a HashSet, } impl<'a> FunctionLinker<'a> { fn new( - text_section_index: Option, - functions: &'a HashMap, + functions: &'a HashMap<(usize, u64), Function>, relocations: &'a HashMap>, symbol_table: &'a HashMap, + text_sections: &'a HashSet, ) -> FunctionLinker<'a> { FunctionLinker { - text_section_index, functions, linked_functions: HashMap::new(), relocations, symbol_table, + text_sections, } } @@ -310,6 +318,10 @@ impl<'a> FunctionLinker<'a> { // at `start_ins`. We'll use `start_ins` to do pc-relative calls. let start_ins = program.instructions.len(); program.instructions.extend(&fun.instructions); + debug!( + "linked function `{}` at instruction {}", + fun.name, start_ins + ); // link func and line info into the main program // the offset needs to be adjusted @@ -326,101 +338,110 @@ impl<'a> FunctionLinker<'a> { fn relocate(&mut self, program: &mut Function, fun: &Function) -> Result<(), RelocationError> { let relocations = self.relocations.get(&fun.section_index); - debug!("relocating program {} function {}", program.name, fun.name); - let n_instructions = fun.instructions.len(); let start_ins = program.instructions.len() - n_instructions; + debug!( + "relocating program `{}` function `{}` size {}", + program.name, fun.name, n_instructions + ); + // process all the instructions. We can't only loop over relocations since we need to // patch pc-relative calls too. for ins_index in start_ins..start_ins + n_instructions { let ins = program.instructions[ins_index]; let is_call = insn_is_call(&ins); - // only resolve relocations for calls or for instructions that - // reference symbols in the .text section (eg let callback = - // &some_fun) - let rel = if let Some(relocations) = relocations { - self.text_relocation_info( - relocations, - (fun.section_offset + (ins_index - start_ins) * INS_SIZE) as u64, - )? - // if not a call and not a .text reference, ignore the - // relocation (see relocate_maps()) - .and_then(|(_, sym)| { - if is_call { - return Some(sym.address); - } - - match sym.kind { - SymbolKind::Text => Some(sym.address), - SymbolKind::Section if sym.section_index == self.text_section_index => { - Some(sym.address + ins.imm as u64) - } - _ => None, - } + let rel = relocations + .and_then(|relocations| { + relocations + .get(&((fun.section_offset + (ins_index - start_ins) * INS_SIZE) as u64)) }) - } else { - None - }; + .and_then(|rel| { + // get the symbol for the relocation + self.symbol_table + .get(&rel.symbol_index) + .map(|sym| (rel, sym)) + }) + .filter(|(_rel, sym)| { + // only consider text relocations, data relocations are + // relocated in relocate_maps() + sym.kind == SymbolKind::Text + || sym + .section_index + .map(|section_index| self.text_sections.contains(§ion_index)) + .unwrap_or(false) + }); - // some_fun() or let x = &some_fun trigger linking, everything else - // can be ignored here + // not a call and not a text relocation, we don't need to do anything if !is_call && rel.is_none() { continue; } - let callee_address = if let Some(address) = rel { - // We have a relocation entry for the instruction at `ins_index`, the address of - // the callee is the address of the relocation's target symbol. - address + let (callee_section_index, callee_address) = if let Some((rel, sym)) = rel { + let address = match sym.kind { + SymbolKind::Text => sym.address, + // R_BPF_64_32 this is a call + SymbolKind::Section if rel.size == 32 => { + sym.address + (ins.imm + 1) as u64 * INS_SIZE as u64 + } + // R_BPF_64_64 this is a ld_imm64 text relocation + SymbolKind::Section if rel.size == 64 => sym.address + ins.imm as u64, + _ => todo!(), // FIXME: return an error here, + }; + (sym.section_index.unwrap(), address) } else { // The caller and the callee are in the same ELF section and this is a pc-relative // call. Resolve the pc-relative imm to an absolute address. let ins_size = INS_SIZE as i64; - (fun.section_offset as i64 - + ((ins_index - start_ins) as i64) * ins_size - + (ins.imm + 1) as i64 * ins_size) as u64 + ( + fun.section_index.0, + (fun.section_offset as i64 + + ((ins_index - start_ins) as i64) * ins_size + + (ins.imm + 1) as i64 * ins_size) as u64, + ) }; debug!( - "relocating {} to callee address {} ({})", + "relocating {} to callee address {:#x} in section {} ({}) at instruction {ins_index}", if is_call { "call" } else { "reference" }, callee_address, + callee_section_index, if rel.is_some() { "relocation" } else { - "relative" + "pc-relative" }, ); // lookup and link the callee if it hasn't been linked already. `callee_ins_index` will // contain the instruction index of the callee inside the program. - let callee = - self.functions - .get(&callee_address) - .ok_or(RelocationError::UnknownFunction { - address: callee_address, - caller_name: fun.name.clone(), - })?; + let callee = self + .functions + .get(&(callee_section_index, callee_address)) + .ok_or(RelocationError::UnknownFunction { + address: callee_address, + caller_name: fun.name.clone(), + })?; - debug!("callee is {}", callee.name); + debug!("callee is `{}`", callee.name); - let callee_ins_index = self.link_function(program, callee)?; + let callee_ins_index = self.link_function(program, callee)? as i32; let mut ins = &mut program.instructions[ins_index]; - ins.imm = if callee_ins_index < ins_index { - -((ins_index - callee_ins_index + 1) as i32) - } else { - (callee_ins_index - ins_index - 1) as i32 - }; + let ins_index = ins_index as i32; + ins.imm = callee_ins_index - ins_index - 1; + debug!( + "callee `{}` is at ins {callee_ins_index}, {} from current instruction {ins_index}", + callee.name, ins.imm + ); if !is_call { ins.set_src_reg(BPF_PSEUDO_FUNC as u8); } } debug!( - "finished relocating program {} function {}", + "finished relocating program `{}` function `{}`", program.name, fun.name ); @@ -459,25 +480,6 @@ impl<'a> FunctionLinker<'a> { } Ok(()) } - - fn text_relocation_info( - &self, - relocations: &HashMap, - offset: u64, - ) -> Result, RelocationError> { - if let Some(rel) = relocations.get(&offset) { - let sym = - self.symbol_table - .get(&rel.symbol_index) - .ok_or(RelocationError::UnknownSymbol { - index: rel.symbol_index, - })?; - - Ok(Some((*rel, sym.clone()))) - } else { - Ok(None) - } - } } fn insn_is_call(ins: &bpf_insn) -> bool { @@ -498,7 +500,7 @@ mod test { use alloc::{string::ToString, vec, vec::Vec}; use crate::{ - maps::{bpf_map_def, BtfMap, BtfMapDef, LegacyMap, Map}, + maps::{BtfMap, LegacyMap, Map}, BpfSectionKind, }; @@ -568,6 +570,7 @@ mod test { let relocations = vec![Relocation { offset: 0x0, symbol_index: 1, + size: 64, }]; let maps_by_section = HashMap::new(); @@ -580,7 +583,7 @@ mod test { &maps_by_section, &maps_by_symbol, &symbol_table, - None, + &HashSet::new(), ) .unwrap(); @@ -615,10 +618,12 @@ mod test { Relocation { offset: 0x0, symbol_index: 1, + size: 64, }, Relocation { offset: mem::size_of::() as u64, symbol_index: 2, + size: 64, }, ]; let maps_by_section = HashMap::new(); @@ -636,7 +641,7 @@ mod test { &maps_by_section, &maps_by_symbol, &symbol_table, - None, + &HashSet::new(), ) .unwrap(); @@ -665,6 +670,7 @@ mod test { let relocations = vec![Relocation { offset: 0x0, symbol_index: 1, + size: 64, }]; let maps_by_section = HashMap::new(); @@ -677,7 +683,7 @@ mod test { &maps_by_section, &maps_by_symbol, &symbol_table, - None, + &HashSet::new(), ) .unwrap(); @@ -712,10 +718,12 @@ mod test { Relocation { offset: 0x0, symbol_index: 1, + size: 64, }, Relocation { offset: mem::size_of::() as u64, symbol_index: 2, + size: 64, }, ]; let maps_by_section = HashMap::new(); @@ -733,7 +741,7 @@ mod test { &maps_by_section, &maps_by_symbol, &symbol_table, - None, + &HashSet::new(), ) .unwrap(); diff --git a/aya/src/bpf.rs b/aya/src/bpf.rs index 81d6051f..34d88277 100644 --- a/aya/src/bpf.rs +++ b/aya/src/bpf.rs @@ -431,11 +431,18 @@ impl<'a> BpfLoader<'a> { maps.insert(name, map); } + let text_sections = obj + .functions + .keys() + .map(|(section_index, _)| *section_index) + .collect(); + obj.relocate_maps( maps.iter() .map(|(s, data)| (s.as_str(), data.fd, &data.obj)), + &text_sections, )?; - obj.relocate_calls()?; + obj.relocate_calls(&text_sections)?; let programs = obj .programs diff --git a/test/integration-test/src/tests/rbpf.rs b/test/integration-test/src/tests/rbpf.rs index 8fa05f01..3cdcedfb 100644 --- a/test/integration-test/src/tests/rbpf.rs +++ b/test/integration-test/src/tests/rbpf.rs @@ -69,14 +69,20 @@ fn use_map_with_rbpf() { } } + let text_sections = object + .functions + .iter() + .map(|((section_index, _), _)| *section_index) + .collect(); object .relocate_maps( maps.iter() .map(|(s, (fd, map))| (s.as_ref() as &str, Some(*fd), map)), + &text_sections, ) .expect("Relocation failed"); // Actually there is no local function call involved. - object.relocate_calls().unwrap(); + object.relocate_calls(&text_sections).unwrap(); // Executes the program assert_eq!(object.programs.len(), 1); From 3a8380df26d266e9b8292e985319c33096d53c0d Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Wed, 12 Apr 2023 09:29:20 +1000 Subject: [PATCH 7/7] integration-test: expand full path for IntegrationTest --- test/integration-test-macros/src/lib.rs | 2 +- test/integration-test/src/tests/btf_relocations.rs | 2 +- test/integration-test/src/tests/elf.rs | 2 +- test/integration-test/src/tests/load.rs | 2 +- test/integration-test/src/tests/rbpf.rs | 2 +- test/integration-test/src/tests/smoke.rs | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/test/integration-test-macros/src/lib.rs b/test/integration-test-macros/src/lib.rs index 6f69b486..297159ed 100644 --- a/test/integration-test-macros/src/lib.rs +++ b/test/integration-test-macros/src/lib.rs @@ -10,7 +10,7 @@ pub fn integration_test(_attr: TokenStream, item: TokenStream) -> TokenStream { let expanded = quote! { #item - inventory::submit!(IntegrationTest { + inventory::submit!(crate::IntegrationTest { name: concat!(module_path!(), "::", #name_str), test_fn: #name, }); diff --git a/test/integration-test/src/tests/btf_relocations.rs b/test/integration-test/src/tests/btf_relocations.rs index 53de8b5d..85291ef4 100644 --- a/test/integration-test/src/tests/btf_relocations.rs +++ b/test/integration-test/src/tests/btf_relocations.rs @@ -4,7 +4,7 @@ use tempfile::TempDir; use aya::{maps::Array, programs::TracePoint, BpfLoader, Btf, Endianness}; -use super::{integration_test, IntegrationTest}; +use super::integration_test; // In the tests below we often use values like 0xAAAAAAAA or -0x7AAAAAAA. Those values have no // special meaning, they just have "nice" bit patterns that can be helpful while debugging. diff --git a/test/integration-test/src/tests/elf.rs b/test/integration-test/src/tests/elf.rs index 32684459..623c9362 100644 --- a/test/integration-test/src/tests/elf.rs +++ b/test/integration-test/src/tests/elf.rs @@ -1,4 +1,4 @@ -use super::{integration_test, IntegrationTest}; +use super::integration_test; use aya::include_bytes_aligned; use object::{Object, ObjectSymbol}; diff --git a/test/integration-test/src/tests/load.rs b/test/integration-test/src/tests/load.rs index 50a3a2b6..9aa21bb5 100644 --- a/test/integration-test/src/tests/load.rs +++ b/test/integration-test/src/tests/load.rs @@ -13,7 +13,7 @@ use log::warn; use crate::tests::kernel_version; -use super::{integration_test, IntegrationTest}; +use super::integration_test; const MAX_RETRIES: u32 = 100; const RETRY_DURATION_MS: u64 = 10; diff --git a/test/integration-test/src/tests/rbpf.rs b/test/integration-test/src/tests/rbpf.rs index 3cdcedfb..e896d262 100644 --- a/test/integration-test/src/tests/rbpf.rs +++ b/test/integration-test/src/tests/rbpf.rs @@ -4,7 +4,7 @@ use std::collections::HashMap; use aya::include_bytes_aligned; use aya_obj::{generated::bpf_insn, Object, ProgramSection}; -use super::{integration_test, IntegrationTest}; +use super::integration_test; #[integration_test] fn run_with_rbpf() { diff --git a/test/integration-test/src/tests/smoke.rs b/test/integration-test/src/tests/smoke.rs index f5867bfe..17abd79b 100644 --- a/test/integration-test/src/tests/smoke.rs +++ b/test/integration-test/src/tests/smoke.rs @@ -5,7 +5,7 @@ use aya::{ }; use log::info; -use super::{integration_test, kernel_version, IntegrationTest}; +use super::{integration_test, kernel_version}; #[integration_test] fn xdp() {