From b2b9bd2edff633c701b89cc64b1602adc18c61da Mon Sep 17 00:00:00 2001 From: Alessandro Decina Date: Tue, 11 Apr 2023 22:59:38 +1000 Subject: [PATCH] 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() {}