yanguangshaonian
/
aya
mirror of https://github.com/aya-rs/aya
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixing easy TODOs

Browse Source
reviewable/pr614/r4
Andrés Medina 2 years ago
parent a0cbb5428f
commit 9f5b205993
38 changed files with 243 additions and 315 deletions
Show Stats Download Patch File Download Diff File

27
aya/src/bpf.rs
Unescape Escape View File

@ -3,7 +3,11 @@ use std::{
collections::{HashMap, HashSet}, collections::{HashMap, HashSet},
ffi::CString, ffi::CString,
fs, io, fs, io,
os::{fd::AsRawFd, raw::c_int, unix::io::RawFd}, os::{
fd::{AsFd, AsRawFd},
raw::c_int,
unix::io::RawFd,
},
path::{Path, PathBuf}, path::{Path, PathBuf},
}; };
@ -421,23 +425,16 @@ impl<'a> BpfLoader<'a> {
PinningType::None => map.create(&name)?, PinningType::None => map.create(&name)?,
}; };
// OK: we just loaded the map // OK: we just loaded the map
let fd = map.fd.as_ref().unwrap(); let fd = map.fd.as_ref().unwrap().as_fd();
if !map.obj.data().is_empty() && map.obj.section_kind() != BpfSectionKind::Bss { if !map.obj.data().is_empty() && map.obj.section_kind() != BpfSectionKind::Bss {
// TODO (AM) bpf_map_update_elem_ptr(fd, &0 as *const _, map.obj.data_mut().as_mut_ptr(), 0)
bpf_map_update_elem_ptr( .map_err(|(_, io_error)| MapError::SyscallError {
fd.as_raw_fd(), call: "bpf_map_update_elem".to_owned(),
&0 as *const _, io_error,
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.section_kind() == BpfSectionKind::Rodata { if map.obj.section_kind() == BpfSectionKind::Rodata {
// TODO (AM) bpf_map_freeze(fd).map_err(|(_, io_error)| MapError::SyscallError {
bpf_map_freeze(fd.as_raw_fd()).map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_freeze".to_owned(), call: "bpf_map_freeze".to_owned(),
io_error, io_error,
})?; })?;

24
aya/src/maps/array/array.rs
Unescape Escape View File

@ -1,7 +1,6 @@
use std::{ use std::{
borrow::{Borrow, BorrowMut}, borrow::{Borrow, BorrowMut},
marker::PhantomData, marker::PhantomData,
os::fd::AsRawFd,
}; };
use crate::{ use crate::{
@ -66,14 +65,12 @@ impl<T: Borrow<MapData>, V: Pod> Array<T, V> {
check_bounds(data, *index)?; check_bounds(data, *index)?;
let fd = data.fd_or_err()?; let fd = data.fd_or_err()?;
// TODO (AM) let value = bpf_map_lookup_elem(fd, index, flags).map_err(|(_, io_error)| {
let value = MapError::SyscallError {
bpf_map_lookup_elem(fd.as_raw_fd(), index, flags).map_err(|(_, io_error)| { call: "bpf_map_lookup_elem".to_owned(),
MapError::SyscallError { io_error,
call: "bpf_map_lookup_elem".to_owned(), }
io_error, })?;
}
})?;
value.ok_or(MapError::KeyNotFound) value.ok_or(MapError::KeyNotFound)
} }
@ -95,13 +92,12 @@ impl<T: BorrowMut<MapData>, V: Pod> Array<T, V> {
let data = self.inner.borrow_mut(); let data = self.inner.borrow_mut();
check_bounds(data, index)?; check_bounds(data, index)?;
let fd = data.fd_or_err()?; let fd = data.fd_or_err()?;
// TODO (AM) bpf_map_update_elem(fd, Some(&index), value.borrow(), flags).map_err(|(_, io_error)| {
bpf_map_update_elem(fd.as_raw_fd(), Some(&index), value.borrow(), flags).map_err( MapError::SyscallError {
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(), call: "bpf_map_update_elem".to_owned(),
io_error, io_error,
}, }
)?; })?;
Ok(()) Ok(())
} }
} }

19
aya/src/maps/array/per_cpu_array.rs
Unescape Escape View File

@ -1,7 +1,6 @@
use std::{ use std::{
borrow::{Borrow, BorrowMut}, borrow::{Borrow, BorrowMut},
marker::PhantomData, marker::PhantomData,
os::fd::AsRawFd,
}; };
use crate::{ use crate::{
@ -85,13 +84,12 @@ impl<T: Borrow<MapData>, V: Pod> PerCpuArray<T, V> {
check_bounds(data, *index)?; check_bounds(data, *index)?;
let fd = data.fd_or_err()?; let fd = data.fd_or_err()?;
// TODO (AM) let value = bpf_map_lookup_elem_per_cpu(fd, index, flags).map_err(|(_, io_error)| {
let value = bpf_map_lookup_elem_per_cpu(fd.as_raw_fd(), index, flags).map_err( MapError::SyscallError {
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(), call: "bpf_map_lookup_elem".to_owned(),
io_error, io_error,
}, }
)?; })?;
value.ok_or(MapError::KeyNotFound) value.ok_or(MapError::KeyNotFound)
} }
@ -114,13 +112,12 @@ impl<T: BorrowMut<MapData>, V: Pod> PerCpuArray<T, V> {
check_bounds(data, index)?; check_bounds(data, index)?;
let fd = data.fd_or_err()?; let fd = data.fd_or_err()?;
// TODO (AM) bpf_map_update_elem_per_cpu(fd, &index, &values, flags).map_err(|(_, io_error)| {
bpf_map_update_elem_per_cpu(fd.as_raw_fd(), &index, &values, flags).map_err( MapError::SyscallError {
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(), call: "bpf_map_update_elem".to_owned(),
io_error, io_error,
}, }
)?; })?;
Ok(()) Ok(())
} }
} }

12
aya/src/maps/array/program_array.rs
Unescape Escape View File

@ -79,13 +79,12 @@ impl<T: BorrowMut<MapData>> ProgramArray<T> {
let fd = data.fd_or_err()?; let fd = data.fd_or_err()?;
let prog_fd = program.as_raw_fd(); let prog_fd = program.as_raw_fd();
// TODO (AM) bpf_map_update_elem(fd, Some(&index), &prog_fd, flags).map_err(|(_, io_error)| {
bpf_map_update_elem(fd.as_raw_fd(), Some(&index), &prog_fd, flags).map_err( MapError::SyscallError {
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(), call: "bpf_map_update_elem".to_owned(),
io_error, io_error,
}, }
)?; })?;
Ok(()) Ok(())
} }
@ -98,8 +97,7 @@ impl<T: BorrowMut<MapData>> ProgramArray<T> {
check_bounds(data, *index)?; check_bounds(data, *index)?;
let fd = self.inner.borrow_mut().fd_or_err()?; let fd = self.inner.borrow_mut().fd_or_err()?;
// TODO (AM) bpf_map_delete_elem(fd, index)
bpf_map_delete_elem(fd.as_raw_fd(), index)
.map(|_| ()) .map(|_| ())
.map_err(|(_, io_error)| MapError::SyscallError { .map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_delete_elem".to_owned(), call: "bpf_map_delete_elem".to_owned(),

8
aya/src/maps/bloom_filter.rs
Unescape Escape View File

@ -1,5 +1,5 @@
//! A Bloom Filter. //! A Bloom Filter.
use std::{borrow::Borrow, marker::PhantomData, os::fd::AsRawFd}; use std::{borrow::Borrow, marker::PhantomData};
use crate::{ use crate::{
maps::{check_v_size, MapData, MapError}, maps::{check_v_size, MapData, MapError},
@ -52,8 +52,7 @@ impl<T: Borrow<MapData>, V: Pod> BloomFilter<T, V> {
pub fn contains(&self, mut value: &V, flags: u64) -> Result<(), MapError> { pub fn contains(&self, mut value: &V, flags: u64) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) bpf_map_lookup_elem_ptr::<u32, _>(fd, None, &mut value, flags)
bpf_map_lookup_elem_ptr::<u32, _>(fd.as_raw_fd(), None, &mut value, flags)
.map_err(|(_, io_error)| MapError::SyscallError { .map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(), call: "bpf_map_lookup_elem".to_owned(),
io_error, io_error,
@ -65,8 +64,7 @@ impl<T: Borrow<MapData>, V: Pod> BloomFilter<T, V> {
/// Inserts a value into the map. /// Inserts a value into the map.
pub fn insert(&self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> { pub fn insert(&self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) bpf_map_push_elem(fd, value.borrow(), flags).map_err(|(_, io_error)| {
bpf_map_push_elem(fd.as_raw_fd(), value.borrow(), flags).map_err(|(_, io_error)| {
MapError::SyscallError { MapError::SyscallError {
call: "bpf_map_push_elem".to_owned(), call: "bpf_map_push_elem".to_owned(),
io_error, io_error,

4
aya/src/maps/hash_map/hash_map.rs
Unescape Escape View File

@ -1,7 +1,6 @@
use std::{ use std::{
borrow::{Borrow, BorrowMut}, borrow::{Borrow, BorrowMut},
marker::PhantomData, marker::PhantomData,
os::fd::AsRawFd,
}; };
use crate::{ use crate::{
@ -55,8 +54,7 @@ impl<T: Borrow<MapData>, K: Pod, V: Pod> HashMap<T, K, V> {
/// Returns a copy of the value associated with the key. /// Returns a copy of the value associated with the key.
pub fn get(&self, key: &K, flags: u64) -> Result<V, MapError> { pub fn get(&self, key: &K, flags: u64) -> Result<V, MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
MapError::SyscallError { MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(), call: "bpf_map_lookup_elem".to_owned(),
io_error, io_error,

8
aya/src/maps/hash_map/mod.rs
Unescape Escape View File

@ -1,6 +1,4 @@
//! Hash map types. //! Hash map types.
use std::os::fd::AsRawFd;
use crate::{ use crate::{
maps::MapError, maps::MapError,
sys::{bpf_map_delete_elem, bpf_map_update_elem}, sys::{bpf_map_delete_elem, bpf_map_update_elem},
@ -23,8 +21,7 @@ pub(crate) fn insert<K: Pod, V: Pod>(
flags: u64, flags: u64,
) -> Result<(), MapError> { ) -> Result<(), MapError> {
let fd = map.fd_or_err()?; let fd = map.fd_or_err()?;
// TODO (AM) bpf_map_update_elem(fd, Some(key), value, flags).map_err(|(_, io_error)| {
bpf_map_update_elem(fd.as_raw_fd(), Some(key), value, flags).map_err(|(_, io_error)| {
MapError::SyscallError { MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(), call: "bpf_map_update_elem".to_owned(),
io_error, io_error,
@ -36,8 +33,7 @@ pub(crate) fn insert<K: Pod, V: Pod>(
pub(crate) fn remove<K: Pod>(map: &mut MapData, key: &K) -> Result<(), MapError> { pub(crate) fn remove<K: Pod>(map: &mut MapData, key: &K) -> Result<(), MapError> {
let fd = map.fd_or_err()?; let fd = map.fd_or_err()?;
// TODO (AM) bpf_map_delete_elem(fd, key)
bpf_map_delete_elem(fd.as_raw_fd(), key)
.map(|_| ()) .map(|_| ())
.map_err(|(_, io_error)| MapError::SyscallError { .map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_delete_elem".to_owned(), call: "bpf_map_delete_elem".to_owned(),

18
aya/src/maps/hash_map/per_cpu_hash_map.rs
Unescape Escape View File

@ -2,7 +2,6 @@
use std::{ use std::{
borrow::{Borrow, BorrowMut}, borrow::{Borrow, BorrowMut},
marker::PhantomData, marker::PhantomData,
os::fd::AsRawFd,
}; };
use crate::{ use crate::{
@ -65,14 +64,12 @@ impl<T: Borrow<MapData>, K: Pod, V: Pod> PerCpuHashMap<T, K, V> {
/// Returns a slice of values - one for each CPU - associated with the key. /// Returns a slice of values - one for each CPU - associated with the key.
pub fn get(&self, key: &K, flags: u64) -> Result<PerCpuValues<V>, MapError> { pub fn get(&self, key: &K, flags: u64) -> Result<PerCpuValues<V>, MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
let values = let values = bpf_map_lookup_elem_per_cpu(fd, key, flags).map_err(|(_, io_error)| {
// TODO (AM) MapError::SyscallError {
bpf_map_lookup_elem_per_cpu(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| { call: "bpf_map_lookup_elem".to_owned(),
MapError::SyscallError { io_error,
call: "bpf_map_lookup_elem".to_owned(), }
io_error, })?;
}
})?;
values.ok_or(MapError::KeyNotFound) values.ok_or(MapError::KeyNotFound)
} }
@ -125,8 +122,7 @@ impl<T: BorrowMut<MapData>, K: Pod, V: Pod> PerCpuHashMap<T, K, V> {
flags: u64, flags: u64,
) -> Result<(), MapError> { ) -> Result<(), MapError> {
let fd = self.inner.borrow_mut().fd_or_err()?; let fd = self.inner.borrow_mut().fd_or_err()?;
// TODO (AM) bpf_map_update_elem_per_cpu(fd, key.borrow(), &values, flags).map_err(
bpf_map_update_elem_per_cpu(fd.as_raw_fd(), key.borrow(), &values, flags).map_err(
|(_, io_error)| MapError::SyscallError { |(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(), call: "bpf_map_update_elem".to_owned(),
io_error, io_error,

16
aya/src/maps/lpm_trie.rs
Unescape Escape View File

@ -2,7 +2,6 @@
use std::{ use std::{
borrow::{Borrow, BorrowMut}, borrow::{Borrow, BorrowMut},
marker::PhantomData, marker::PhantomData,
os::fd::AsRawFd,
}; };
use crate::{ use crate::{
@ -129,8 +128,7 @@ impl<T: Borrow<MapData>, K: Pod, V: Pod> LpmTrie<T, K, V> {
/// Returns a copy of the value associated with the longest prefix matching key in the LpmTrie. /// Returns a copy of the value associated with the longest prefix matching key in the LpmTrie.
pub fn get(&self, key: &Key<K>, flags: u64) -> Result<V, MapError> { pub fn get(&self, key: &Key<K>, flags: u64) -> Result<V, MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
MapError::SyscallError { MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(), call: "bpf_map_lookup_elem".to_owned(),
io_error, io_error,
@ -161,13 +159,12 @@ impl<T: BorrowMut<MapData>, K: Pod, V: Pod> LpmTrie<T, K, V> {
flags: u64, flags: u64,
) -> Result<(), MapError> { ) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) bpf_map_update_elem(fd, Some(key), value.borrow(), flags).map_err(|(_, io_error)| {
bpf_map_update_elem(fd.as_raw_fd(), Some(key), value.borrow(), flags).map_err( MapError::SyscallError {
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(), call: "bpf_map_update_elem".to_owned(),
io_error, io_error,
}, }
)?; })?;
Ok(()) Ok(())
} }
@ -177,8 +174,7 @@ impl<T: BorrowMut<MapData>, K: Pod, V: Pod> LpmTrie<T, K, V> {
/// Both the prefix and data must match exactly - this method does not do a longest prefix match. /// Both the prefix and data must match exactly - this method does not do a longest prefix match.
pub fn remove(&mut self, key: &Key<K>) -> Result<(), MapError> { pub fn remove(&mut self, key: &Key<K>) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) bpf_map_delete_elem(fd, key)
bpf_map_delete_elem(fd.as_raw_fd(), key)
.map(|_| ()) .map(|_| ())
.map_err(|(_, io_error)| MapError::SyscallError { .map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_delete_elem".to_owned(), call: "bpf_map_delete_elem".to_owned(),

20
aya/src/maps/mod.rs
Unescape Escape View File

@ -549,9 +549,8 @@ impl MapData {
io_error, io_error,
})?; })?;
// TODO (AM)
let info = let info =
bpf_map_get_info_by_fd(fd.as_raw_fd()).map_err(|io_error| MapError::SyscallError { bpf_map_get_info_by_fd(fd.as_fd()).map_err(|io_error| MapError::SyscallError {
call: "BPF_MAP_GET_INFO_BY_FD".to_owned(), call: "BPF_MAP_GET_INFO_BY_FD".to_owned(),
io_error, io_error,
})?; })?;
@ -570,9 +569,8 @@ impl MapData {
/// This API is intended for cases where you have received a valid BPF FD from some other means. /// This API is intended for cases where you have received a valid BPF FD from some other means.
/// For example, you received an FD over Unix Domain Socket. /// For example, you received an FD over Unix Domain Socket.
pub fn from_fd(fd: OwnedFd) -> Result<MapData, MapError> { pub fn from_fd(fd: OwnedFd) -> Result<MapData, MapError> {
// TODO (AM)
let info = let info =
bpf_map_get_info_by_fd(fd.as_raw_fd()).map_err(|io_error| MapError::SyscallError { bpf_map_get_info_by_fd(fd.as_fd()).map_err(|io_error| MapError::SyscallError {
call: "BPF_OBJ_GET".to_owned(), call: "BPF_OBJ_GET".to_owned(),
io_error, io_error,
})?; })?;
@ -597,7 +595,7 @@ impl MapData {
return Err(PinError::AlreadyPinned { name: name.into() }); return Err(PinError::AlreadyPinned { name: name.into() });
} }
let map_path = path.as_ref().join(name); let map_path = path.as_ref().join(name);
let fd = self.fd.as_ref().ok_or(PinError::NoFd { let fd = self.fd.as_ref().map(|f| f.as_fd()).ok_or(PinError::NoFd {
name: name.to_string(), name: name.to_string(),
})?; })?;
let path_string = CString::new(map_path.to_string_lossy().into_owned()).map_err(|e| { let path_string = CString::new(map_path.to_string_lossy().into_owned()).map_err(|e| {
@ -605,12 +603,9 @@ impl MapData {
error: e.to_string(), error: e.to_string(),
} }
})?; })?;
// TODO (AM): switch to BorrowedFd bpf_pin_object(fd, &path_string).map_err(|(_, io_error)| PinError::SyscallError {
bpf_pin_object(fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| { name: "BPF_OBJ_PIN".to_string(),
PinError::SyscallError { io_error,
name: "BPF_OBJ_PIN".to_string(),
io_error,
}
})?; })?;
self.pinned = true; self.pinned = true;
Ok(()) Ok(())
@ -690,8 +685,7 @@ impl<K: Pod> Iterator for MapKeys<'_, K> {
} }
}; };
// TODO (AM) match bpf_map_get_next_key(fd, self.key.as_ref()) {
match bpf_map_get_next_key(fd.as_raw_fd(), self.key.as_ref()) {
Ok(Some(key)) => { Ok(Some(key)) => {
self.key = Some(key); self.key = Some(key);
Some(Ok(key)) Some(Ok(key))

3
aya/src/maps/perf/perf_event_array.rs
Unescape Escape View File

@ -186,8 +186,7 @@ impl<T: BorrowMut<MapData> + Borrow<MapData>> PerfEventArray<T> {
let map_data: &MapData = self.map.deref().borrow(); let map_data: &MapData = self.map.deref().borrow();
let map_fd = map_data.fd_or_err().unwrap(); let map_fd = map_data.fd_or_err().unwrap();
let buf = PerfBuffer::open(index, self.page_size, page_count.unwrap_or(2))?; let buf = PerfBuffer::open(index, self.page_size, page_count.unwrap_or(2))?;
// TODO (AM) bpf_map_update_elem(map_fd, Some(&index), &buf.as_raw_fd(), 0)
bpf_map_update_elem(map_fd.as_raw_fd(), Some(&index), &buf.as_raw_fd(), 0)
.map_err(|(_, io_error)| io_error)?; .map_err(|(_, io_error)| io_error)?;
Ok(PerfEventArrayBuffer { Ok(PerfEventArrayBuffer {

7
aya/src/maps/queue.rs
Unescape Escape View File

@ -2,7 +2,6 @@
use std::{ use std::{
borrow::{Borrow, BorrowMut}, borrow::{Borrow, BorrowMut},
marker::PhantomData, marker::PhantomData,
os::fd::AsRawFd,
}; };
use crate::{ use crate::{
@ -65,8 +64,7 @@ impl<T: BorrowMut<MapData>, V: Pod> Queue<T, V> {
pub fn pop(&mut self, flags: u64) -> Result<V, MapError> { pub fn pop(&mut self, flags: u64) -> Result<V, MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd, None, flags).map_err(
let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd.as_raw_fd(), None, flags).map_err(
|(_, io_error)| MapError::SyscallError { |(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_and_delete_elem".to_owned(), call: "bpf_map_lookup_and_delete_elem".to_owned(),
io_error, io_error,
@ -82,8 +80,7 @@ impl<T: BorrowMut<MapData>, V: Pod> Queue<T, V> {
/// [`MapError::SyscallError`] if `bpf_map_update_elem` fails. /// [`MapError::SyscallError`] if `bpf_map_update_elem` fails.
pub fn push(&mut self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> { pub fn push(&mut self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) bpf_map_push_elem(fd, value.borrow(), flags).map_err(|(_, io_error)| {
bpf_map_push_elem(fd.as_raw_fd(), value.borrow(), flags).map_err(|(_, io_error)| {
MapError::SyscallError { MapError::SyscallError {
call: "bpf_map_push_elem".to_owned(), call: "bpf_map_push_elem".to_owned(),
io_error, io_error,

3
aya/src/maps/sock/sock_hash.rs
Unescape Escape View File

@ -83,8 +83,7 @@ impl<T: Borrow<MapData>, K: Pod> SockHash<T, K> {
/// Returns the fd of the socket stored at the given key. /// Returns the fd of the socket stored at the given key.
pub fn get(&self, key: &K, flags: u64) -> Result<RawFd, MapError> { pub fn get(&self, key: &K, flags: u64) -> Result<RawFd, MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
MapError::SyscallError { MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(), call: "bpf_map_lookup_elem".to_owned(),
io_error, io_error,

6
aya/src/maps/sock/sock_map.rs
Unescape Escape View File

@ -76,8 +76,7 @@ impl<T: BorrowMut<MapData>> SockMap<T> {
let data = self.inner.borrow_mut(); let data = self.inner.borrow_mut();
let fd = data.fd_or_err()?; let fd = data.fd_or_err()?;
check_bounds(data, index)?; check_bounds(data, index)?;
// TODO (AM) bpf_map_update_elem(fd, Some(&index), &socket.as_raw_fd(), flags).map_err(
bpf_map_update_elem(fd.as_raw_fd(), Some(&index), &socket.as_raw_fd(), flags).map_err(
|(_, io_error)| MapError::SyscallError { |(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(), call: "bpf_map_update_elem".to_owned(),
io_error, io_error,
@ -91,8 +90,7 @@ impl<T: BorrowMut<MapData>> SockMap<T> {
let data = self.inner.borrow_mut(); let data = self.inner.borrow_mut();
let fd = data.fd_or_err()?; let fd = data.fd_or_err()?;
check_bounds(data, *index)?; check_bounds(data, *index)?;
// TODO (AM) bpf_map_delete_elem(fd, index)
bpf_map_delete_elem(fd.as_raw_fd(), index)
.map(|_| ()) .map(|_| ())
.map_err(|(_, io_error)| MapError::SyscallError { .map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_delete_elem".to_owned(), call: "bpf_map_delete_elem".to_owned(),

13
aya/src/maps/stack.rs
Unescape Escape View File

@ -2,7 +2,6 @@
use std::{ use std::{
borrow::{Borrow, BorrowMut}, borrow::{Borrow, BorrowMut},
marker::PhantomData, marker::PhantomData,
os::fd::AsRawFd,
}; };
use crate::{ use crate::{
@ -65,8 +64,7 @@ impl<T: BorrowMut<MapData>, V: Pod> Stack<T, V> {
pub fn pop(&mut self, flags: u64) -> Result<V, MapError> { pub fn pop(&mut self, flags: u64) -> Result<V, MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd, None, flags).map_err(
let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd.as_raw_fd(), None, flags).map_err(
|(_, io_error)| MapError::SyscallError { |(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_and_delete_elem".to_owned(), call: "bpf_map_lookup_and_delete_elem".to_owned(),
io_error, io_error,
@ -82,13 +80,12 @@ impl<T: BorrowMut<MapData>, V: Pod> Stack<T, V> {
/// [`MapError::SyscallError`] if `bpf_map_update_elem` fails. /// [`MapError::SyscallError`] if `bpf_map_update_elem` fails.
pub fn push(&mut self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> { pub fn push(&mut self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM) bpf_map_update_elem(fd, None::<&u32>, value.borrow(), flags).map_err(|(_, io_error)| {
bpf_map_update_elem(fd.as_raw_fd(), None::<&u32>, value.borrow(), flags).map_err( MapError::SyscallError {
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(), call: "bpf_map_update_elem".to_owned(),
io_error, io_error,
}, }
)?; })?;
Ok(()) Ok(())
} }
} }

7
aya/src/maps/stack_trace.rs
Unescape Escape View File

@ -1,9 +1,7 @@
//! A hash map of kernel or user space stack traces. //! A hash map of kernel or user space stack traces.
//! //!
//! See [`StackTraceMap`] for documentation and examples. //! See [`StackTraceMap`] for documentation and examples.
use std::{ use std::{borrow::Borrow, collections::BTreeMap, fs, io, mem, path::Path, str::FromStr};
borrow::Borrow, collections::BTreeMap, fs, io, mem, os::fd::AsRawFd, path::Path, str::FromStr,
};
use crate::{ use crate::{
maps::{IterableMap, MapData, MapError, MapIter, MapKeys}, maps::{IterableMap, MapData, MapError, MapIter, MapKeys},
@ -107,8 +105,7 @@ impl<T: Borrow<MapData>> StackTraceMap<T> {
let fd = self.inner.borrow().fd_or_err()?; let fd = self.inner.borrow().fd_or_err()?;
let mut frames = vec![0; self.max_stack_depth]; let mut frames = vec![0; self.max_stack_depth];
// TODO (AM) bpf_map_lookup_elem_ptr(fd, Some(stack_id), frames.as_mut_ptr(), flags)
bpf_map_lookup_elem_ptr(fd.as_raw_fd(), Some(stack_id), frames.as_mut_ptr(), flags)
.map_err(|(_, io_error)| MapError::SyscallError { .map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(), call: "bpf_map_lookup_elem".to_owned(),
io_error, io_error,

22
aya/src/programs/cgroup_device.rs
Unescape Escape View File

@ -64,26 +64,24 @@ impl CgroupDevice {
let k_ver = kernel_version().unwrap(); let k_ver = kernel_version().unwrap();
if k_ver >= (5, 7, 0) { if k_ver >= (5, 7, 0) {
// TODO (AM) let link_fd = bpf_link_create(prog_fd, cgroup_fd, BPF_CGROUP_DEVICE, None, 0).map_err(
let link_fd = |(_, io_error)| ProgramError::SyscallError {
bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_DEVICE, None, 0) call: "bpf_link_create".to_owned(),
.map_err(|(_, io_error)| ProgramError::SyscallError { io_error,
call: "bpf_link_create".to_owned(), },
io_error, )?;
})?;
self.data self.data
.links .links
.insert(CgroupDeviceLink::new(CgroupDeviceLinkInner::Fd( .insert(CgroupDeviceLink::new(CgroupDeviceLinkInner::Fd(
FdLink::new(link_fd), FdLink::new(link_fd),
))) )))
} else { } else {
// TODO (AM) bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_DEVICE).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_DEVICE).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
self.data self.data
.links .links
.insert(CgroupDeviceLink::new(CgroupDeviceLinkInner::ProgAttach( .insert(CgroupDeviceLink::new(CgroupDeviceLinkInner::ProgAttach(

17
aya/src/programs/cgroup_skb.rs
Unescape Escape View File

@ -94,25 +94,24 @@ impl CgroupSkb {
}; };
let k_ver = kernel_version().unwrap(); let k_ver = kernel_version().unwrap();
if k_ver >= (5, 7, 0) { if k_ver >= (5, 7, 0) {
// TODO (AM) let link_fd = bpf_link_create(prog_fd, cgroup_fd, attach_type, None, 0).map_err(
let link_fd = bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, attach_type, None, 0) |(_, io_error)| ProgramError::SyscallError {
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(), call: "bpf_link_create".to_owned(),
io_error, io_error,
})?; },
)?;
self.data self.data
.links .links
.insert(CgroupSkbLink::new(CgroupSkbLinkInner::Fd(FdLink::new( .insert(CgroupSkbLink::new(CgroupSkbLinkInner::Fd(FdLink::new(
link_fd, link_fd,
)))) ))))
} else { } else {
// TODO (AM) bpf_prog_attach(prog_fd, cgroup_fd, attach_type).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, attach_type).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
self.data self.data
.links .links

17
aya/src/programs/cgroup_sock.rs
Unescape Escape View File

@ -69,25 +69,24 @@ impl CgroupSock {
let attach_type = self.data.expected_attach_type.unwrap(); let attach_type = self.data.expected_attach_type.unwrap();
let k_ver = kernel_version().unwrap(); let k_ver = kernel_version().unwrap();
if k_ver >= (5, 7, 0) { if k_ver >= (5, 7, 0) {
// TODO (AM) let link_fd = bpf_link_create(prog_fd, cgroup_fd, attach_type, None, 0).map_err(
let link_fd = bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, attach_type, None, 0) |(_, io_error)| ProgramError::SyscallError {
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(), call: "bpf_link_create".to_owned(),
io_error, io_error,
})?; },
)?;
self.data self.data
.links .links
.insert(CgroupSockLink::new(CgroupSockLinkInner::Fd(FdLink::new( .insert(CgroupSockLink::new(CgroupSockLinkInner::Fd(FdLink::new(
link_fd, link_fd,
)))) ))))
} else { } else {
// TODO (AM) bpf_prog_attach(prog_fd, cgroup_fd, attach_type).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, attach_type).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
self.data self.data
.links .links

17
aya/src/programs/cgroup_sock_addr.rs
Unescape Escape View File

@ -70,25 +70,24 @@ impl CgroupSockAddr {
let attach_type = self.data.expected_attach_type.unwrap(); let attach_type = self.data.expected_attach_type.unwrap();
let k_ver = kernel_version().unwrap(); let k_ver = kernel_version().unwrap();
if k_ver >= (5, 7, 0) { if k_ver >= (5, 7, 0) {
// TODO (AM) let link_fd = bpf_link_create(prog_fd, cgroup_fd, attach_type, None, 0).map_err(
let link_fd = bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, attach_type, None, 0) |(_, io_error)| ProgramError::SyscallError {
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(), call: "bpf_link_create".to_owned(),
io_error, io_error,
})?; },
)?;
self.data self.data
.links .links
.insert(CgroupSockAddrLink::new(CgroupSockAddrLinkInner::Fd( .insert(CgroupSockAddrLink::new(CgroupSockAddrLinkInner::Fd(
FdLink::new(link_fd), FdLink::new(link_fd),
))) )))
} else { } else {
// TODO (AM) bpf_prog_attach(prog_fd, cgroup_fd, attach_type).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, attach_type).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
self.data.links.insert(CgroupSockAddrLink::new( self.data.links.insert(CgroupSockAddrLink::new(
CgroupSockAddrLinkInner::ProgAttach(ProgAttachLink::new( CgroupSockAddrLinkInner::ProgAttach(ProgAttachLink::new(

17
aya/src/programs/cgroup_sockopt.rs
Unescape Escape View File

@ -67,25 +67,24 @@ impl CgroupSockopt {
let attach_type = self.data.expected_attach_type.unwrap(); let attach_type = self.data.expected_attach_type.unwrap();
let k_ver = kernel_version().unwrap(); let k_ver = kernel_version().unwrap();
if k_ver >= (5, 7, 0) { if k_ver >= (5, 7, 0) {
// TODO (AM) let link_fd = bpf_link_create(prog_fd, cgroup_fd, attach_type, None, 0).map_err(
let link_fd = bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, attach_type, None, 0) |(_, io_error)| ProgramError::SyscallError {
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(), call: "bpf_link_create".to_owned(),
io_error, io_error,
})?; },
)?;
self.data self.data
.links .links
.insert(CgroupSockoptLink::new(CgroupSockoptLinkInner::Fd( .insert(CgroupSockoptLink::new(CgroupSockoptLinkInner::Fd(
FdLink::new(link_fd), FdLink::new(link_fd),
))) )))
} else { } else {
// TODO (AM) bpf_prog_attach(prog_fd, cgroup_fd, attach_type).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, attach_type).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
self.data self.data
.links .links

22
aya/src/programs/cgroup_sysctl.rs
Unescape Escape View File

@ -63,26 +63,24 @@ impl CgroupSysctl {
let k_ver = kernel_version().unwrap(); let k_ver = kernel_version().unwrap();
if k_ver >= (5, 7, 0) { if k_ver >= (5, 7, 0) {
// TODO (AM) let link_fd = bpf_link_create(prog_fd, cgroup_fd, BPF_CGROUP_SYSCTL, None, 0).map_err(
let link_fd = |(_, io_error)| ProgramError::SyscallError {
bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_SYSCTL, None, 0) call: "bpf_link_create".to_owned(),
.map_err(|(_, io_error)| ProgramError::SyscallError { io_error,
call: "bpf_link_create".to_owned(), },
io_error, )?;
})?;
self.data self.data
.links .links
.insert(CgroupSysctlLink::new(CgroupSysctlLinkInner::Fd( .insert(CgroupSysctlLink::new(CgroupSysctlLinkInner::Fd(
FdLink::new(link_fd), FdLink::new(link_fd),
))) )))
} else { } else {
// TODO (AM) bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SYSCTL).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_SYSCTL).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
self.data self.data
.links .links

34
aya/src/programs/extension.rs
Unescape Escape View File

@ -92,18 +92,11 @@ impl Extension {
let target_fd = self.data.attach_prog_fd.ok_or(ProgramError::NotLoaded)?; let target_fd = self.data.attach_prog_fd.ok_or(ProgramError::NotLoaded)?;
let btf_id = self.data.attach_btf_id.ok_or(ProgramError::NotLoaded)?; let btf_id = self.data.attach_btf_id.ok_or(ProgramError::NotLoaded)?;
// the attach type must be set as 0, which is bpf_attach_type::BPF_CGROUP_INET_INGRESS // the attach type must be set as 0, which is bpf_attach_type::BPF_CGROUP_INET_INGRESS
// TODO (AM) let link_fd = bpf_link_create(prog_fd, target_fd, BPF_CGROUP_INET_INGRESS, Some(btf_id), 0)
let link_fd = bpf_link_create( .map_err(|(_, io_error)| ProgramError::SyscallError {
prog_fd.as_raw_fd(), call: "bpf_link_create".to_owned(),
target_fd, io_error,
BPF_CGROUP_INET_INGRESS, })?;
Some(btf_id),
0,
)
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(),
io_error,
})?;
self.data self.data
.links .links
.insert(ExtensionLink::new(FdLink::new(link_fd))) .insert(ExtensionLink::new(FdLink::new(link_fd)))
@ -129,18 +122,11 @@ impl Extension {
let (_, btf_id) = get_btf_info(target_fd, func_name)?; let (_, btf_id) = get_btf_info(target_fd, func_name)?;
let prog_fd = self.data.fd_or_err()?; let prog_fd = self.data.fd_or_err()?;
// the attach type must be set as 0, which is bpf_attach_type::BPF_CGROUP_INET_INGRESS // the attach type must be set as 0, which is bpf_attach_type::BPF_CGROUP_INET_INGRESS
// TODO (AM) let link_fd = bpf_link_create(prog_fd, target_fd, BPF_CGROUP_INET_INGRESS, Some(btf_id), 0)
let link_fd = bpf_link_create( .map_err(|(_, io_error)| ProgramError::SyscallError {
prog_fd.as_raw_fd(), call: "bpf_link_create".to_owned(),
target_fd, io_error,
BPF_CGROUP_INET_INGRESS, })?;
Some(btf_id),
0,
)
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(),
io_error,
})?;
self.data self.data
.links .links
.insert(ExtensionLink::new(FdLink::new(link_fd))) .insert(ExtensionLink::new(FdLink::new(link_fd)))

5
aya/src/programs/links.rs
Unescape Escape View File

@ -6,7 +6,7 @@ use std::{
collections::{hash_map::Entry, HashMap}, collections::{hash_map::Entry, HashMap},
ffi::CString, ffi::CString,
io, io,
os::fd::{AsRawFd, OwnedFd, RawFd}, os::fd::{AsFd, AsRawFd, OwnedFd, RawFd},
path::{Path, PathBuf}, path::{Path, PathBuf},
}; };
@ -128,8 +128,7 @@ impl FdLink {
error: e.to_string(), error: e.to_string(),
} }
})?; })?;
// TODO (AM) bpf_pin_object(self.fd.as_fd(), &path_string).map_err(|(_, io_error)| {
bpf_pin_object(self.fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| {
PinError::SyscallError { PinError::SyscallError {
name: "BPF_OBJ_PIN".to_string(), name: "BPF_OBJ_PIN".to_string(),
io_error, io_error,

9
aya/src/programs/lirc_mode2.rs
Unescape Escape View File

@ -64,13 +64,12 @@ impl LircMode2 {
let prog_fd = self.data.fd_or_err()?; let prog_fd = self.data.fd_or_err()?;
let lircdev_fd = lircdev.as_raw_fd(); let lircdev_fd = lircdev.as_raw_fd();
// TODO (AM) bpf_prog_attach(prog_fd, lircdev_fd, BPF_LIRC_MODE2).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), lircdev_fd, BPF_LIRC_MODE2).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
// TODO (AM) // TODO (AM)
self.data self.data

9
aya/src/programs/mod.rs
Unescape Escape View File

@ -549,12 +549,9 @@ fn pin_program<T: Link, P: AsRef<Path>>(
error: e.to_string(), error: e.to_string(),
} }
})?; })?;
// TODO (AM) bpf_pin_object(fd, &path_string).map_err(|(_, io_error)| PinError::SyscallError {
bpf_pin_object(fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| { name: "BPF_OBJ_PIN".to_string(),
PinError::SyscallError { io_error,
name: "BPF_OBJ_PIN".to_string(),
io_error,
}
})?; })?;
Ok(()) Ok(())
} }

22
aya/src/programs/perf_attach.rs
Unescape Escape View File

@ -1,6 +1,9 @@
//! Perf attach links. //! Perf attach links.
use libc::close; use libc::close;
use std::os::unix::io::RawFd; use std::os::{
fd::{AsRawFd, BorrowedFd},
unix::io::RawFd,
};
use crate::{ use crate::{
generated::bpf_attach_type::BPF_PERF_EVENT, generated::bpf_attach_type::BPF_PERF_EVENT,
@ -72,7 +75,10 @@ impl Link for PerfLink {
} }
} }
pub(crate) fn perf_attach(prog_fd: RawFd, fd: RawFd) -> Result<PerfLinkInner, ProgramError> { pub(crate) fn perf_attach(
prog_fd: BorrowedFd<'_>,
fd: RawFd,
) -> Result<PerfLinkInner, ProgramError> {
if FEATURES.bpf_perf_link() { if FEATURES.bpf_perf_link() {
let link_fd = let link_fd =
bpf_link_create(prog_fd, fd, BPF_PERF_EVENT, None, 0).map_err(|(_, io_error)| { bpf_link_create(prog_fd, fd, BPF_PERF_EVENT, None, 0).map_err(|(_, io_error)| {
@ -88,7 +94,7 @@ pub(crate) fn perf_attach(prog_fd: RawFd, fd: RawFd) -> Result<PerfLinkInner, Pr
} }
pub(crate) fn perf_attach_debugfs( pub(crate) fn perf_attach_debugfs(
prog_fd: RawFd, prog_fd: BorrowedFd<'_>,
fd: RawFd, fd: RawFd,
probe_kind: ProbeKind, probe_kind: ProbeKind,
event_alias: String, event_alias: String,
@ -97,17 +103,17 @@ pub(crate) fn perf_attach_debugfs(
} }
fn perf_attach_either( fn perf_attach_either(
prog_fd: RawFd, prog_fd: BorrowedFd<'_>,
fd: RawFd, fd: RawFd,
probe_kind: Option<ProbeKind>, probe_kind: Option<ProbeKind>,
event_alias: Option<String>, event_alias: Option<String>,
) -> Result<PerfLinkInner, ProgramError> { ) -> Result<PerfLinkInner, ProgramError> {
perf_event_ioctl(fd, PERF_EVENT_IOC_SET_BPF, prog_fd).map_err(|(_, io_error)| { perf_event_ioctl(fd, PERF_EVENT_IOC_SET_BPF, prog_fd.as_raw_fd()).map_err(
ProgramError::SyscallError { |(_, io_error)| ProgramError::SyscallError {
call: "PERF_EVENT_IOC_SET_BPF".to_owned(), call: "PERF_EVENT_IOC_SET_BPF".to_owned(),
io_error, io_error,
} },
})?; )?;
perf_event_ioctl(fd, PERF_EVENT_IOC_ENABLE, 0).map_err(|(_, io_error)| { perf_event_ioctl(fd, PERF_EVENT_IOC_ENABLE, 0).map_err(|(_, io_error)| {
ProgramError::SyscallError { ProgramError::SyscallError {
call: "PERF_EVENT_IOC_ENABLE".to_owned(), call: "PERF_EVENT_IOC_ENABLE".to_owned(),

5
aya/src/programs/perf_event.rs
Unescape Escape View File

@ -1,7 +1,5 @@
//! Perf event programs. //! Perf event programs.
use std::os::fd::AsRawFd;
pub use crate::generated::{ pub use crate::generated::{
perf_hw_cache_id, perf_hw_cache_op_id, perf_hw_cache_op_result_id, perf_hw_id, perf_sw_ids, perf_hw_cache_id, perf_hw_cache_op_id, perf_hw_cache_op_result_id, perf_hw_id, perf_sw_ids,
}; };
@ -171,8 +169,7 @@ impl PerfEvent {
io_error, io_error,
})? as i32; })? as i32;
// TODO (AM) let link = perf_attach(self.data.fd_or_err()?, fd)?;
let link = perf_attach(self.data.fd_or_err()?.as_raw_fd(), fd)?;
self.data.links.insert(PerfEventLink::new(link)) self.data.links.insert(PerfEventLink::new(link))
} }

7
aya/src/programs/probe.rs
Unescape Escape View File

@ -2,7 +2,6 @@ use libc::pid_t;
use std::{ use std::{
fs::{self, OpenOptions}, fs::{self, OpenOptions},
io::{self, Write}, io::{self, Write},
os::fd::AsRawFd,
path::Path, path::Path,
process, process,
sync::atomic::{AtomicUsize, Ordering}, sync::atomic::{AtomicUsize, Ordering},
@ -54,8 +53,7 @@ pub(crate) fn attach<T: Link + From<PerfLinkInner>>(
if k_ver < (4, 17, 0) { if k_ver < (4, 17, 0) {
let (fd, event_alias) = create_as_trace_point(kind, fn_name, offset, pid)?; let (fd, event_alias) = create_as_trace_point(kind, fn_name, offset, pid)?;
let link = T::from(perf_attach_debugfs( let link = T::from(perf_attach_debugfs(
// TODO (AM) program_data.fd_or_err()?,
program_data.fd_or_err()?.as_raw_fd(),
fd, fd,
kind, kind,
event_alias, event_alias,
@ -64,8 +62,7 @@ pub(crate) fn attach<T: Link + From<PerfLinkInner>>(
}; };
let fd = create_as_probe(kind, fn_name, offset, pid)?; let fd = create_as_probe(kind, fn_name, offset, pid)?;
// TODO (AM) let link = T::from(perf_attach(program_data.fd_or_err()?, fd)?);
let link = T::from(perf_attach(program_data.fd_or_err()?.as_raw_fd(), fd)?);
program_data.links.insert(link) program_data.links.insert(link)
} }

8
aya/src/programs/sk_lookup.rs
Unescape Escape View File

@ -64,12 +64,12 @@ impl SkLookup {
let prog_fd = self.data.fd_or_err()?; let prog_fd = self.data.fd_or_err()?;
let netns_fd = netns.as_raw_fd(); let netns_fd = netns.as_raw_fd();
// TODO (AM) let link_fd = bpf_link_create(prog_fd, netns_fd, BPF_SK_LOOKUP, None, 0).map_err(
let link_fd = bpf_link_create(prog_fd.as_raw_fd(), netns_fd, BPF_SK_LOOKUP, None, 0) |(_, io_error)| ProgramError::SyscallError {
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(), call: "bpf_link_create".to_owned(),
io_error, io_error,
})?; },
)?;
self.data self.data
.links .links
.insert(SkLookupLink::new(FdLink::new(link_fd))) .insert(SkLookupLink::new(FdLink::new(link_fd)))

9
aya/src/programs/sk_msg.rs
Unescape Escape View File

@ -82,13 +82,12 @@ impl SkMsg {
let prog_fd = self.data.fd_or_err()?; let prog_fd = self.data.fd_or_err()?;
let map_fd = map.as_raw_fd(); let map_fd = map.as_raw_fd();
// TODO (AM) bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), map_fd, BPF_SK_MSG_VERDICT).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
self.data.links.insert(SkMsgLink::new(ProgAttachLink::new( self.data.links.insert(SkMsgLink::new(ProgAttachLink::new(
// TODO (AM) // TODO (AM)
prog_fd.as_raw_fd(), prog_fd.as_raw_fd(),

3
aya/src/programs/sk_skb.rs
Unescape Escape View File

@ -78,8 +78,7 @@ impl SkSkb {
SkSkbKind::StreamParser => BPF_SK_SKB_STREAM_PARSER, SkSkbKind::StreamParser => BPF_SK_SKB_STREAM_PARSER,
SkSkbKind::StreamVerdict => BPF_SK_SKB_STREAM_VERDICT, SkSkbKind::StreamVerdict => BPF_SK_SKB_STREAM_VERDICT,
}; };
// TODO (AM) bpf_prog_attach(prog_fd, map_fd, attach_type).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), map_fd, attach_type).map_err(|(_, io_error)| {
ProgramError::SyscallError { ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,

9
aya/src/programs/sock_ops.rs
Unescape Escape View File

@ -62,13 +62,12 @@ impl SockOps {
let prog_fd = self.data.fd_or_err()?; let prog_fd = self.data.fd_or_err()?;
let cgroup_fd = cgroup.as_raw_fd(); let cgroup_fd = cgroup.as_raw_fd();
// TODO (AM) bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SOCK_OPS).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_SOCK_OPS).map_err( ProgramError::SyscallError {
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(), call: "bpf_prog_attach".to_owned(),
io_error, io_error,
}, }
)?; })?;
// TODO (AM) // TODO (AM)
self.data.links.insert(SockOpsLink::new(ProgAttachLink::new( self.data.links.insert(SockOpsLink::new(ProgAttachLink::new(
prog_fd.as_raw_fd(), prog_fd.as_raw_fd(),

5
aya/src/programs/trace_point.rs
Unescape Escape View File

@ -1,5 +1,5 @@
//! Tracepoint programs. //! Tracepoint programs.
use std::{fs, io, os::fd::AsRawFd, path::Path}; use std::{fs, io, path::Path};
use thiserror::Error; use thiserror::Error;
use crate::{ use crate::{
@ -87,8 +87,7 @@ impl TracePoint {
} }
})? as i32; })? as i32;
// TODO (AM) let link = perf_attach(self.data.fd_or_err()?, fd)?;
let link = perf_attach(self.data.fd_or_err()?.as_raw_fd(), fd)?;
self.data.links.insert(TracePointLink::new(link)) self.data.links.insert(TracePointLink::new(link))
} }

16
aya/src/programs/utils.rs
Unescape Escape View File

@ -1,5 +1,5 @@
//! Common functions shared between multiple eBPF program types. //! Common functions shared between multiple eBPF program types.
use std::{ffi::CStr, io, os::fd::AsRawFd, path::Path}; use std::{ffi::CStr, io, path::Path};
use crate::{ use crate::{
programs::{FdLink, Link, ProgramData, ProgramError}, programs::{FdLink, Link, ProgramData, ProgramError},
@ -13,14 +13,12 @@ pub(crate) fn attach_raw_tracepoint<T: Link + From<FdLink>>(
) -> Result<T::Id, ProgramError> { ) -> Result<T::Id, ProgramError> {
let prog_fd = program_data.fd_or_err()?; let prog_fd = program_data.fd_or_err()?;
// TODO (AM) let pfd = bpf_raw_tracepoint_open(tp_name, prog_fd).map_err(|(_code, io_error)| {
let pfd = ProgramError::SyscallError {
bpf_raw_tracepoint_open(tp_name, prog_fd.as_raw_fd()).map_err(|(_code, io_error)| { call: "bpf_raw_tracepoint_open".to_owned(),
ProgramError::SyscallError { io_error,
call: "bpf_raw_tracepoint_open".to_owned(), }
io_error, })?;
}
})?;
program_data.links.insert(FdLink::new(pfd).into()) program_data.links.insert(FdLink::new(pfd).into())
} }

26
aya/src/programs/xdp.rs
Unescape Escape View File

@ -6,7 +6,10 @@ use std::{
ffi::CString, ffi::CString,
hash::Hash, hash::Hash,
io, io,
os::{fd::AsRawFd, unix::io::RawFd}, os::{
fd::{AsFd, AsRawFd},
unix::io::RawFd,
},
}; };
use thiserror::Error; use thiserror::Error;
@ -134,13 +137,12 @@ impl Xdp {
let k_ver = kernel_version().unwrap(); let k_ver = kernel_version().unwrap();
if k_ver >= (5, 9, 0) { if k_ver >= (5, 9, 0) {
// TODO (AM) let link_fd = bpf_link_create(prog_fd, if_index, BPF_XDP, None, flags.bits()).map_err(
let link_fd = |(_, io_error)| ProgramError::SyscallError {
bpf_link_create(prog_fd.as_raw_fd(), if_index, BPF_XDP, None, flags.bits()) call: "bpf_link_create".to_owned(),
.map_err(|(_, io_error)| ProgramError::SyscallError { io_error,
call: "bpf_link_create".to_owned(), },
io_error, )?;
})?;
self.data self.data
.links .links
.insert(XdpLink::new(XdpLinkInner::FdLink(FdLink::new(link_fd)))) .insert(XdpLink::new(XdpLinkInner::FdLink(FdLink::new(link_fd))))
@ -298,13 +300,13 @@ impl TryFrom<FdLink> for XdpLink {
fn try_from(fd_link: FdLink) -> Result<Self, Self::Error> { fn try_from(fd_link: FdLink) -> Result<Self, Self::Error> {
// unwrap of fd_link.fd will not panic since it's only None when being dropped. // unwrap of fd_link.fd will not panic since it's only None when being dropped.
let info = let info = bpf_link_get_info_by_fd(fd_link.fd.as_fd()).map_err(|io_error| {
// TODO (AM) LinkError::SyscallError {
bpf_link_get_info_by_fd(fd_link.fd.as_raw_fd()).map_err(|io_error| LinkError::SyscallError {
call: "BPF_OBJ_GET_INFO_BY_FD".to_string(), call: "BPF_OBJ_GET_INFO_BY_FD".to_string(),
code: 0, code: 0,
io_error, io_error,
})?; }
})?;
if info.type_ == (bpf_link_type::BPF_LINK_TYPE_XDP as u32) { if info.type_ == (bpf_link_type::BPF_LINK_TYPE_XDP as u32) {
return Ok(XdpLink::new(XdpLinkInner::FdLink(fd_link))); return Ok(XdpLink::new(XdpLinkInner::FdLink(fd_link)));
} }

80
aya/src/sys/bpf.rs
Unescape Escape View File

@ -4,7 +4,7 @@ use std::{
io, io,
mem::{self, MaybeUninit}, mem::{self, MaybeUninit},
os::{ os::{
fd::{AsRawFd, FromRawFd, OwnedFd}, fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, OwnedFd},
unix::io::RawFd, unix::io::RawFd,
}, },
slice, slice,
@ -100,10 +100,10 @@ pub(crate) fn bpf_create_map(
Ok(unsafe { OwnedFd::from_raw_fd(fd) }) Ok(unsafe { OwnedFd::from_raw_fd(fd) })
} }
pub(crate) fn bpf_pin_object(fd: RawFd, path: &CStr) -> SysResult { pub(crate) fn bpf_pin_object(fd: BorrowedFd<'_>, path: &CStr) -> SysResult {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
let u = unsafe { &mut attr.__bindgen_anon_4 }; let u = unsafe { &mut attr.__bindgen_anon_4 };
u.bpf_fd = fd as u32; u.bpf_fd = fd.as_raw_fd() as u32;
u.pathname = path.as_ptr() as u64; u.pathname = path.as_ptr() as u64;
sys_bpf(bpf_cmd::BPF_OBJ_PIN, &attr) sys_bpf(bpf_cmd::BPF_OBJ_PIN, &attr)
} }
@ -204,7 +204,7 @@ pub(crate) fn bpf_load_program(
} }
fn lookup<K: Pod, V: Pod>( fn lookup<K: Pod, V: Pod>(
fd: RawFd, fd: BorrowedFd<'_>,
key: Option<&K>, key: Option<&K>,
flags: u64, flags: u64,
cmd: bpf_cmd, cmd: bpf_cmd,
@ -213,7 +213,7 @@ fn lookup<K: Pod, V: Pod>(
let mut value = MaybeUninit::zeroed(); let mut value = MaybeUninit::zeroed();
let u = unsafe { &mut attr.__bindgen_anon_2 }; let u = unsafe { &mut attr.__bindgen_anon_2 };
u.map_fd = fd as u32; u.map_fd = fd.as_raw_fd() as u32;
if let Some(key) = key { if let Some(key) = key {
u.key = key as *const _ as u64; u.key = key as *const _ as u64;
} }
@ -228,7 +228,7 @@ fn lookup<K: Pod, V: Pod>(
} }
pub(crate) fn bpf_map_lookup_elem<K: Pod, V: Pod>( pub(crate) fn bpf_map_lookup_elem<K: Pod, V: Pod>(
fd: RawFd, fd: BorrowedFd<'_>,
key: &K, key: &K,
flags: u64, flags: u64,
) -> Result<Option<V>> { ) -> Result<Option<V>> {
@ -236,7 +236,7 @@ pub(crate) fn bpf_map_lookup_elem<K: Pod, V: Pod>(
} }
pub(crate) fn bpf_map_lookup_and_delete_elem<K: Pod, V: Pod>( pub(crate) fn bpf_map_lookup_and_delete_elem<K: Pod, V: Pod>(
fd: RawFd, fd: BorrowedFd<'_>,
key: Option<&K>, key: Option<&K>,
flags: u64, flags: u64,
) -> Result<Option<V>> { ) -> Result<Option<V>> {
@ -244,7 +244,7 @@ pub(crate) fn bpf_map_lookup_and_delete_elem<K: Pod, V: Pod>(
} }
pub(crate) fn bpf_map_lookup_elem_per_cpu<K: Pod, V: Pod>( pub(crate) fn bpf_map_lookup_elem_per_cpu<K: Pod, V: Pod>(
fd: RawFd, fd: BorrowedFd<'_>,
key: &K, key: &K,
flags: u64, flags: u64,
) -> Result<Option<PerCpuValues<V>>> { ) -> Result<Option<PerCpuValues<V>>> {
@ -257,7 +257,7 @@ pub(crate) fn bpf_map_lookup_elem_per_cpu<K: Pod, V: Pod>(
} }
pub(crate) fn bpf_map_lookup_elem_ptr<K: Pod, V>( pub(crate) fn bpf_map_lookup_elem_ptr<K: Pod, V>(
fd: RawFd, fd: BorrowedFd<'_>,
key: Option<&K>, key: Option<&K>,
value: *mut V, value: *mut V,
flags: u64, flags: u64,
@ -265,7 +265,7 @@ pub(crate) fn bpf_map_lookup_elem_ptr<K: Pod, V>(
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
let u = unsafe { &mut attr.__bindgen_anon_2 }; let u = unsafe { &mut attr.__bindgen_anon_2 };
u.map_fd = fd as u32; u.map_fd = fd.as_raw_fd() as u32;
if let Some(key) = key { if let Some(key) = key {
u.key = key as *const _ as u64; u.key = key as *const _ as u64;
} }
@ -280,7 +280,7 @@ pub(crate) fn bpf_map_lookup_elem_ptr<K: Pod, V>(
} }
pub(crate) fn bpf_map_update_elem<K: Pod, V: Pod>( pub(crate) fn bpf_map_update_elem<K: Pod, V: Pod>(
fd: RawFd, fd: BorrowedFd<'_>,
key: Option<&K>, key: Option<&K>,
value: &V, value: &V,
flags: u64, flags: u64,
@ -288,7 +288,7 @@ pub(crate) fn bpf_map_update_elem<K: Pod, V: Pod>(
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
let u = unsafe { &mut attr.__bindgen_anon_2 }; let u = unsafe { &mut attr.__bindgen_anon_2 };
u.map_fd = fd as u32; u.map_fd = fd.as_raw_fd() as u32;
if let Some(key) = key { if let Some(key) = key {
u.key = key as *const _ as u64; u.key = key as *const _ as u64;
} }
@ -298,11 +298,11 @@ pub(crate) fn bpf_map_update_elem<K: Pod, V: Pod>(
sys_bpf(bpf_cmd::BPF_MAP_UPDATE_ELEM, &attr) sys_bpf(bpf_cmd::BPF_MAP_UPDATE_ELEM, &attr)
} }
pub(crate) fn bpf_map_push_elem<V: Pod>(fd: RawFd, value: &V, flags: u64) -> SysResult { pub(crate) fn bpf_map_push_elem<V: Pod>(fd: BorrowedFd<'_>, value: &V, flags: u64) -> SysResult {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
let u = unsafe { &mut attr.__bindgen_anon_2 }; let u = unsafe { &mut attr.__bindgen_anon_2 };
u.map_fd = fd as u32; u.map_fd = fd.as_raw_fd() as u32;
u.__bindgen_anon_1.value = value as *const _ as u64; u.__bindgen_anon_1.value = value as *const _ as u64;
u.flags = flags; u.flags = flags;
@ -310,7 +310,7 @@ pub(crate) fn bpf_map_push_elem<V: Pod>(fd: RawFd, value: &V, flags: u64) -> Sys
} }
pub(crate) fn bpf_map_update_elem_ptr<K, V>( pub(crate) fn bpf_map_update_elem_ptr<K, V>(
fd: RawFd, fd: BorrowedFd<'_>,
key: *const K, key: *const K,
value: *mut V, value: *mut V,
flags: u64, flags: u64,
@ -318,7 +318,7 @@ pub(crate) fn bpf_map_update_elem_ptr<K, V>(
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
let u = unsafe { &mut attr.__bindgen_anon_2 }; let u = unsafe { &mut attr.__bindgen_anon_2 };
u.map_fd = fd as u32; u.map_fd = fd.as_raw_fd() as u32;
u.key = key as u64; u.key = key as u64;
u.__bindgen_anon_1.value = value as u64; u.__bindgen_anon_1.value = value as u64;
u.flags = flags; u.flags = flags;
@ -327,7 +327,7 @@ pub(crate) fn bpf_map_update_elem_ptr<K, V>(
} }
pub(crate) fn bpf_map_update_elem_per_cpu<K: Pod, V: Pod>( pub(crate) fn bpf_map_update_elem_per_cpu<K: Pod, V: Pod>(
fd: RawFd, fd: BorrowedFd<'_>,
key: &K, key: &K,
values: &PerCpuValues<V>, values: &PerCpuValues<V>,
flags: u64, flags: u64,
@ -336,22 +336,25 @@ pub(crate) fn bpf_map_update_elem_per_cpu<K: Pod, V: Pod>(
bpf_map_update_elem_ptr(fd, key, mem.as_mut_ptr(), flags) bpf_map_update_elem_ptr(fd, key, mem.as_mut_ptr(), flags)
} }
pub(crate) fn bpf_map_delete_elem<K: Pod>(fd: RawFd, key: &K) -> SysResult { pub(crate) fn bpf_map_delete_elem<K: Pod>(fd: BorrowedFd<'_>, key: &K) -> SysResult {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
let u = unsafe { &mut attr.__bindgen_anon_2 }; let u = unsafe { &mut attr.__bindgen_anon_2 };
u.map_fd = fd as u32; u.map_fd = fd.as_raw_fd() as u32;
u.key = key as *const _ as u64; u.key = key as *const _ as u64;
sys_bpf(bpf_cmd::BPF_MAP_DELETE_ELEM, &attr) sys_bpf(bpf_cmd::BPF_MAP_DELETE_ELEM, &attr)
} }
pub(crate) fn bpf_map_get_next_key<K: Pod>(fd: RawFd, key: Option<&K>) -> Result<Option<K>> { pub(crate) fn bpf_map_get_next_key<K: Pod>(
fd: BorrowedFd<'_>,
key: Option<&K>,
) -> Result<Option<K>> {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
let mut next_key = MaybeUninit::uninit(); let mut next_key = MaybeUninit::uninit();
let u = unsafe { &mut attr.__bindgen_anon_2 }; let u = unsafe { &mut attr.__bindgen_anon_2 };
u.map_fd = fd as u32; u.map_fd = fd.as_raw_fd() as u32;
if let Some(key) = key { if let Some(key) = key {
u.key = key as *const _ as u64; u.key = key as *const _ as u64;
} }
@ -365,16 +368,16 @@ pub(crate) fn bpf_map_get_next_key<K: Pod>(fd: RawFd, key: Option<&K>) -> Result
} }
// since kernel 5.2 // since kernel 5.2
pub(crate) fn bpf_map_freeze(fd: RawFd) -> SysResult { pub(crate) fn bpf_map_freeze(fd: BorrowedFd<'_>) -> SysResult {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
let u = unsafe { &mut attr.__bindgen_anon_2 }; let u = unsafe { &mut attr.__bindgen_anon_2 };
u.map_fd = fd as u32; u.map_fd = fd.as_raw_fd() as u32;
sys_bpf(bpf_cmd::BPF_MAP_FREEZE, &attr) sys_bpf(bpf_cmd::BPF_MAP_FREEZE, &attr)
} }
// since kernel 5.7 // since kernel 5.7
pub(crate) fn bpf_link_create( pub(crate) fn bpf_link_create(
prog_fd: RawFd, prog_fd: BorrowedFd<'_>,
target_fd: RawFd, target_fd: RawFd,
attach_type: bpf_attach_type, attach_type: bpf_attach_type,
btf_id: Option<u32>, btf_id: Option<u32>,
@ -382,7 +385,7 @@ pub(crate) fn bpf_link_create(
) -> Result<OwnedFd> { ) -> Result<OwnedFd> {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
attr.link_create.__bindgen_anon_1.prog_fd = prog_fd as u32; attr.link_create.__bindgen_anon_1.prog_fd = prog_fd.as_raw_fd() as u32;
attr.link_create.__bindgen_anon_2.target_fd = target_fd as u32; attr.link_create.__bindgen_anon_2.target_fd = target_fd as u32;
attr.link_create.attach_type = attach_type as u32; attr.link_create.attach_type = attach_type as u32;
attr.link_create.flags = flags; attr.link_create.flags = flags;
@ -417,13 +420,13 @@ pub(crate) fn bpf_link_update(
} }
pub(crate) fn bpf_prog_attach( pub(crate) fn bpf_prog_attach(
prog_fd: RawFd, prog_fd: BorrowedFd<'_>,
target_fd: RawFd, target_fd: RawFd,
attach_type: bpf_attach_type, attach_type: bpf_attach_type,
) -> SysResult { ) -> SysResult {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
attr.__bindgen_anon_5.attach_bpf_fd = prog_fd as u32; attr.__bindgen_anon_5.attach_bpf_fd = prog_fd.as_raw_fd() as u32;
attr.__bindgen_anon_5.target_fd = target_fd as u32; attr.__bindgen_anon_5.target_fd = target_fd as u32;
attr.__bindgen_anon_5.attach_type = attach_type as u32; attr.__bindgen_anon_5.attach_type = attach_type as u32;
@ -497,12 +500,12 @@ pub(crate) fn bpf_prog_get_info_by_fd(prog_fd: RawFd) -> io::Result<bpf_prog_inf
} }
} }
pub(crate) fn bpf_map_get_info_by_fd(prog_fd: RawFd) -> io::Result<bpf_map_info> { pub(crate) fn bpf_map_get_info_by_fd(prog_fd: BorrowedFd<'_>) -> io::Result<bpf_map_info> {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
// info gets entirely populated by the kernel // info gets entirely populated by the kernel
let info = MaybeUninit::zeroed(); let info = MaybeUninit::zeroed();
attr.info.bpf_fd = prog_fd as u32; attr.info.bpf_fd = prog_fd.as_raw_fd() as u32;
attr.info.info = info.as_ptr() as *const _ as u64; attr.info.info = info.as_ptr() as *const _ as u64;
attr.info.info_len = mem::size_of::<bpf_map_info>() as u32; attr.info.info_len = mem::size_of::<bpf_map_info>() as u32;
@ -512,12 +515,12 @@ pub(crate) fn bpf_map_get_info_by_fd(prog_fd: RawFd) -> io::Result<bpf_map_info>
} }
} }
pub(crate) fn bpf_link_get_info_by_fd(link_fd: RawFd) -> io::Result<bpf_link_info> { pub(crate) fn bpf_link_get_info_by_fd(link_fd: BorrowedFd<'_>) -> io::Result<bpf_link_info> {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
// info gets entirely populated by the kernel // info gets entirely populated by the kernel
let info = unsafe { MaybeUninit::zeroed().assume_init() }; let info = unsafe { MaybeUninit::zeroed().assume_init() };
attr.info.bpf_fd = link_fd as u32; attr.info.bpf_fd = link_fd.as_raw_fd() as u32;
attr.info.info = &info as *const _ as u64; attr.info.info = &info as *const _ as u64;
attr.info.info_len = mem::size_of::<bpf_link_info>() as u32; attr.info.info_len = mem::size_of::<bpf_link_info>() as u32;
@ -543,14 +546,17 @@ pub(crate) fn btf_obj_get_info_by_fd(prog_fd: RawFd, buf: &mut [u8]) -> io::Resu
} }
} }
pub(crate) fn bpf_raw_tracepoint_open(name: Option<&CStr>, prog_fd: RawFd) -> Result<OwnedFd> { pub(crate) fn bpf_raw_tracepoint_open(
name: Option<&CStr>,
prog_fd: BorrowedFd<'_>,
) -> Result<OwnedFd> {
let mut attr = unsafe { mem::zeroed::<bpf_attr>() }; let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
attr.raw_tracepoint.name = match name { attr.raw_tracepoint.name = match name {
Some(n) => n.as_ptr() as u64, Some(n) => n.as_ptr() as u64,
None => 0, None => 0,
}; };
attr.raw_tracepoint.prog_fd = prog_fd as u32; attr.raw_tracepoint.prog_fd = prog_fd.as_raw_fd() as u32;
let fd = sys_bpf(bpf_cmd::BPF_RAW_TRACEPOINT_OPEN, &attr)? as RawFd; let fd = sys_bpf(bpf_cmd::BPF_RAW_TRACEPOINT_OPEN, &attr)? as RawFd;
// Safety: BPF_RAW_TRACEPOINT_OPEN returns a new fd // Safety: BPF_RAW_TRACEPOINT_OPEN returns a new fd
@ -665,14 +671,14 @@ pub(crate) fn is_perf_link_supported() -> bool {
u.prog_type = bpf_prog_type::BPF_PROG_TYPE_TRACEPOINT as u32; u.prog_type = bpf_prog_type::BPF_PROG_TYPE_TRACEPOINT as u32;
if let Ok(fd) = sys_bpf(bpf_cmd::BPF_PROG_LOAD, &attr) { if let Ok(fd) = sys_bpf(bpf_cmd::BPF_PROG_LOAD, &attr) {
// SAFETY: BPF_PROG_LOAD creates a new fd
let fd = unsafe { OwnedFd::from_raw_fd(fd as RawFd) };
if let Err((_, e)) = if let Err((_, e)) =
// Uses an invalid target FD so we get EBADF if supported. // Uses an invalid target FD so we get EBADF if supported.
bpf_link_create(fd as i32, -1, bpf_attach_type::BPF_PERF_EVENT, None, 0) bpf_link_create(fd.as_fd(), -1, bpf_attach_type::BPF_PERF_EVENT, None, 0)
{ {
// Returns EINVAL if unsupported. EBADF if supported. // Returns EINVAL if unsupported. EBADF if supported.
let res = e.raw_os_error() == Some(libc::EBADF); return e.raw_os_error() == Some(libc::EBADF);
unsafe { libc::close(fd as i32) };
return res;
} }
} }
false false

4
test/integration-ebpf/src/bpf_probe_read.rs
Unescape Escape View File

@ -14,8 +14,8 @@ macro_rules! read_str_bytes {
($fun:ident, $ptr:expr, $len:expr $(,)?) => { ($fun:ident, $ptr:expr, $len:expr $(,)?) => {
let r = unsafe { let r = unsafe {
let Some(ptr) = RESULT.get_ptr_mut(0) else { let Some(ptr) = RESULT.get_ptr_mut(0) else {
return; return;
}; };
&mut *ptr &mut *ptr
}; };

Write Preview
Loading…
Cancel
Save