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

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

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

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

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

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

@ -1,7 +1,6 @@
use std::{
borrow::{Borrow, BorrowMut},
marker::PhantomData,
os::fd::AsRawFd,
};
use crate::{
@ -85,13 +84,12 @@ impl<T: Borrow<MapData>, V: Pod> PerCpuArray<T, V> {
check_bounds(data, *index)?;
let fd = data.fd_or_err()?;
// TODO (AM)
let value = bpf_map_lookup_elem_per_cpu(fd.as_raw_fd(), index, flags).map_err(
|(_, io_error)| MapError::SyscallError {
let value = bpf_map_lookup_elem_per_cpu(fd, index, flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(),
io_error,
},
)?;
}
})?;
value.ok_or(MapError::KeyNotFound)
}
@ -114,13 +112,12 @@ impl<T: BorrowMut<MapData>, V: Pod> PerCpuArray<T, V> {
check_bounds(data, index)?;
let fd = data.fd_or_err()?;
// TODO (AM)
bpf_map_update_elem_per_cpu(fd.as_raw_fd(), &index, &values, flags).map_err(
|(_, io_error)| MapError::SyscallError {
bpf_map_update_elem_per_cpu(fd, &index, &values, flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(),
io_error,
},
)?;
}
})?;
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 prog_fd = program.as_raw_fd();
// TODO (AM)
bpf_map_update_elem(fd.as_raw_fd(), Some(&index), &prog_fd, flags).map_err(
|(_, io_error)| MapError::SyscallError {
bpf_map_update_elem(fd, Some(&index), &prog_fd, flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(),
io_error,
},
)?;
}
})?;
Ok(())
}
@ -98,8 +97,7 @@ impl<T: BorrowMut<MapData>> ProgramArray<T> {
check_bounds(data, *index)?;
let fd = self.inner.borrow_mut().fd_or_err()?;
// TODO (AM)
bpf_map_delete_elem(fd.as_raw_fd(), index)
bpf_map_delete_elem(fd, index)
.map(|_| ())
.map_err(|(_, io_error)| MapError::SyscallError {
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.
use std::{borrow::Borrow, marker::PhantomData, os::fd::AsRawFd};
use std::{borrow::Borrow, marker::PhantomData};
use crate::{
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> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
bpf_map_lookup_elem_ptr::<u32, _>(fd.as_raw_fd(), None, &mut value, flags)
bpf_map_lookup_elem_ptr::<u32, _>(fd, None, &mut value, flags)
.map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(),
io_error,
@ -65,8 +64,7 @@ impl<T: Borrow<MapData>, V: Pod> BloomFilter<T, V> {
/// Inserts a value into the map.
pub fn insert(&self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
bpf_map_push_elem(fd.as_raw_fd(), value.borrow(), flags).map_err(|(_, io_error)| {
bpf_map_push_elem(fd, value.borrow(), flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_push_elem".to_owned(),
io_error,

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

@ -1,7 +1,6 @@
use std::{
borrow::{Borrow, BorrowMut},
marker::PhantomData,
os::fd::AsRawFd,
};
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.
pub fn get(&self, key: &K, flags: u64) -> Result<V, MapError> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(),
io_error,

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

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

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

@ -2,7 +2,6 @@
use std::{
borrow::{Borrow, BorrowMut},
marker::PhantomData,
os::fd::AsRawFd,
};
use crate::{
@ -65,9 +64,7 @@ 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.
pub fn get(&self, key: &K, flags: u64) -> Result<PerCpuValues<V>, MapError> {
let fd = self.inner.borrow().fd_or_err()?;
let values =
// TODO (AM)
bpf_map_lookup_elem_per_cpu(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
let values = bpf_map_lookup_elem_per_cpu(fd, key, flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(),
io_error,
@ -125,8 +122,7 @@ impl<T: BorrowMut<MapData>, K: Pod, V: Pod> PerCpuHashMap<T, K, V> {
flags: u64,
) -> Result<(), MapError> {
let fd = self.inner.borrow_mut().fd_or_err()?;
// TODO (AM)
bpf_map_update_elem_per_cpu(fd.as_raw_fd(), key.borrow(), &values, flags).map_err(
bpf_map_update_elem_per_cpu(fd, key.borrow(), &values, flags).map_err(
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(),
io_error,

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

@ -2,7 +2,6 @@
use std::{
borrow::{Borrow, BorrowMut},
marker::PhantomData,
os::fd::AsRawFd,
};
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.
pub fn get(&self, key: &Key<K>, flags: u64) -> Result<V, MapError> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(),
io_error,
@ -161,13 +159,12 @@ impl<T: BorrowMut<MapData>, K: Pod, V: Pod> LpmTrie<T, K, V> {
flags: u64,
) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
bpf_map_update_elem(fd.as_raw_fd(), Some(key), value.borrow(), flags).map_err(
|(_, io_error)| MapError::SyscallError {
bpf_map_update_elem(fd, Some(key), value.borrow(), flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(),
io_error,
},
)?;
}
})?;
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.
pub fn remove(&mut self, key: &Key<K>) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
bpf_map_delete_elem(fd.as_raw_fd(), key)
bpf_map_delete_elem(fd, key)
.map(|_| ())
.map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_delete_elem".to_owned(),

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

@ -549,9 +549,8 @@ impl MapData {
io_error,
})?;
// TODO (AM)
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(),
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.
/// For example, you received an FD over Unix Domain Socket.
pub fn from_fd(fd: OwnedFd) -> Result<MapData, MapError> {
// TODO (AM)
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(),
io_error,
})?;
@ -597,7 +595,7 @@ impl MapData {
return Err(PinError::AlreadyPinned { name: name.into() });
}
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(),
})?;
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(),
}
})?;
// TODO (AM): switch to BorrowedFd
bpf_pin_object(fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| {
PinError::SyscallError {
bpf_pin_object(fd, &path_string).map_err(|(_, io_error)| PinError::SyscallError {
name: "BPF_OBJ_PIN".to_string(),
io_error,
}
})?;
self.pinned = true;
Ok(())
@ -690,8 +685,7 @@ impl<K: Pod> Iterator for MapKeys<'_, K> {
}
};
// TODO (AM)
match bpf_map_get_next_key(fd.as_raw_fd(), self.key.as_ref()) {
match bpf_map_get_next_key(fd, self.key.as_ref()) {
Ok(Some(key)) => {
self.key = Some(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_fd = map_data.fd_or_err().unwrap();
let buf = PerfBuffer::open(index, self.page_size, page_count.unwrap_or(2))?;
// TODO (AM)
bpf_map_update_elem(map_fd.as_raw_fd(), Some(&index), &buf.as_raw_fd(), 0)
bpf_map_update_elem(map_fd, Some(&index), &buf.as_raw_fd(), 0)
.map_err(|(_, io_error)| io_error)?;
Ok(PerfEventArrayBuffer {

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

@ -2,7 +2,6 @@
use std::{
borrow::{Borrow, BorrowMut},
marker::PhantomData,
os::fd::AsRawFd,
};
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> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd.as_raw_fd(), None, flags).map_err(
let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd, None, flags).map_err(
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_and_delete_elem".to_owned(),
io_error,
@ -82,8 +80,7 @@ impl<T: BorrowMut<MapData>, V: Pod> Queue<T, V> {
/// [`MapError::SyscallError`] if `bpf_map_update_elem` fails.
pub fn push(&mut self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
bpf_map_push_elem(fd.as_raw_fd(), value.borrow(), flags).map_err(|(_, io_error)| {
bpf_map_push_elem(fd, value.borrow(), flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_push_elem".to_owned(),
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.
pub fn get(&self, key: &K, flags: u64) -> Result<RawFd, MapError> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(),
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 fd = data.fd_or_err()?;
check_bounds(data, index)?;
// TODO (AM)
bpf_map_update_elem(fd.as_raw_fd(), Some(&index), &socket.as_raw_fd(), flags).map_err(
bpf_map_update_elem(fd, Some(&index), &socket.as_raw_fd(), flags).map_err(
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(),
io_error,
@ -91,8 +90,7 @@ impl<T: BorrowMut<MapData>> SockMap<T> {
let data = self.inner.borrow_mut();
let fd = data.fd_or_err()?;
check_bounds(data, *index)?;
// TODO (AM)
bpf_map_delete_elem(fd.as_raw_fd(), index)
bpf_map_delete_elem(fd, index)
.map(|_| ())
.map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_delete_elem".to_owned(),

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

@ -2,7 +2,6 @@
use std::{
borrow::{Borrow, BorrowMut},
marker::PhantomData,
os::fd::AsRawFd,
};
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> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd.as_raw_fd(), None, flags).map_err(
let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd, None, flags).map_err(
|(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_and_delete_elem".to_owned(),
io_error,
@ -82,13 +80,12 @@ impl<T: BorrowMut<MapData>, V: Pod> Stack<T, V> {
/// [`MapError::SyscallError`] if `bpf_map_update_elem` fails.
pub fn push(&mut self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
let fd = self.inner.borrow().fd_or_err()?;
// TODO (AM)
bpf_map_update_elem(fd.as_raw_fd(), None::<&u32>, value.borrow(), flags).map_err(
|(_, io_error)| MapError::SyscallError {
bpf_map_update_elem(fd, None::<&u32>, value.borrow(), flags).map_err(|(_, io_error)| {
MapError::SyscallError {
call: "bpf_map_update_elem".to_owned(),
io_error,
},
)?;
}
})?;
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.
//!
//! See [`StackTraceMap`] for documentation and examples.
use std::{
borrow::Borrow, collections::BTreeMap, fs, io, mem, os::fd::AsRawFd, path::Path, str::FromStr,
};
use std::{borrow::Borrow, collections::BTreeMap, fs, io, mem, path::Path, str::FromStr};
use crate::{
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 mut frames = vec![0; self.max_stack_depth];
// TODO (AM)
bpf_map_lookup_elem_ptr(fd.as_raw_fd(), Some(stack_id), frames.as_mut_ptr(), flags)
bpf_map_lookup_elem_ptr(fd, Some(stack_id), frames.as_mut_ptr(), flags)
.map_err(|(_, io_error)| MapError::SyscallError {
call: "bpf_map_lookup_elem".to_owned(),
io_error,

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

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

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

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

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

@ -92,14 +92,7 @@ impl Extension {
let target_fd = self.data.attach_prog_fd.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
// TODO (AM)
let link_fd = bpf_link_create(
prog_fd.as_raw_fd(),
target_fd,
BPF_CGROUP_INET_INGRESS,
Some(btf_id),
0,
)
let link_fd = bpf_link_create(prog_fd, target_fd, BPF_CGROUP_INET_INGRESS, Some(btf_id), 0)
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(),
io_error,
@ -129,14 +122,7 @@ impl Extension {
let (_, btf_id) = get_btf_info(target_fd, func_name)?;
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
// TODO (AM)
let link_fd = bpf_link_create(
prog_fd.as_raw_fd(),
target_fd,
BPF_CGROUP_INET_INGRESS,
Some(btf_id),
0,
)
let link_fd = bpf_link_create(prog_fd, target_fd, BPF_CGROUP_INET_INGRESS, Some(btf_id), 0)
.map_err(|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(),
io_error,

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

@ -6,7 +6,7 @@ use std::{
collections::{hash_map::Entry, HashMap},
ffi::CString,
io,
os::fd::{AsRawFd, OwnedFd, RawFd},
os::fd::{AsFd, AsRawFd, OwnedFd, RawFd},
path::{Path, PathBuf},
};
@ -128,8 +128,7 @@ impl FdLink {
error: e.to_string(),
}
})?;
// TODO (AM)
bpf_pin_object(self.fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| {
bpf_pin_object(self.fd.as_fd(), &path_string).map_err(|(_, io_error)| {
PinError::SyscallError {
name: "BPF_OBJ_PIN".to_string(),
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 lircdev_fd = lircdev.as_raw_fd();
// TODO (AM)
bpf_prog_attach(prog_fd.as_raw_fd(), lircdev_fd, BPF_LIRC_MODE2).map_err(
|(_, io_error)| ProgramError::SyscallError {
bpf_prog_attach(prog_fd, lircdev_fd, BPF_LIRC_MODE2).map_err(|(_, io_error)| {
ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(),
io_error,
},
)?;
}
})?;
// TODO (AM)
self.data

5
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(),
}
})?;
// TODO (AM)
bpf_pin_object(fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| {
PinError::SyscallError {
bpf_pin_object(fd, &path_string).map_err(|(_, io_error)| PinError::SyscallError {
name: "BPF_OBJ_PIN".to_string(),
io_error,
}
})?;
Ok(())
}

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

@ -1,6 +1,9 @@
//! Perf attach links.
use libc::close;
use std::os::unix::io::RawFd;
use std::os::{
fd::{AsRawFd, BorrowedFd},
unix::io::RawFd,
};
use crate::{
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() {
let link_fd =
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(
prog_fd: RawFd,
prog_fd: BorrowedFd<'_>,
fd: RawFd,
probe_kind: ProbeKind,
event_alias: String,
@ -97,17 +103,17 @@ pub(crate) fn perf_attach_debugfs(
}
fn perf_attach_either(
prog_fd: RawFd,
prog_fd: BorrowedFd<'_>,
fd: RawFd,
probe_kind: Option<ProbeKind>,
event_alias: Option<String>,
) -> Result<PerfLinkInner, ProgramError> {
perf_event_ioctl(fd, PERF_EVENT_IOC_SET_BPF, prog_fd).map_err(|(_, io_error)| {
ProgramError::SyscallError {
perf_event_ioctl(fd, PERF_EVENT_IOC_SET_BPF, prog_fd.as_raw_fd()).map_err(
|(_, io_error)| ProgramError::SyscallError {
call: "PERF_EVENT_IOC_SET_BPF".to_owned(),
io_error,
}
})?;
},
)?;
perf_event_ioctl(fd, PERF_EVENT_IOC_ENABLE, 0).map_err(|(_, io_error)| {
ProgramError::SyscallError {
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.
use std::os::fd::AsRawFd;
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,
};
@ -171,8 +169,7 @@ impl PerfEvent {
io_error,
})? as i32;
// TODO (AM)
let link = perf_attach(self.data.fd_or_err()?.as_raw_fd(), fd)?;
let link = perf_attach(self.data.fd_or_err()?, fd)?;
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::{
fs::{self, OpenOptions},
io::{self, Write},
os::fd::AsRawFd,
path::Path,
process,
sync::atomic::{AtomicUsize, Ordering},
@ -54,8 +53,7 @@ pub(crate) fn attach<T: Link + From<PerfLinkInner>>(
if k_ver < (4, 17, 0) {
let (fd, event_alias) = create_as_trace_point(kind, fn_name, offset, pid)?;
let link = T::from(perf_attach_debugfs(
// TODO (AM)
program_data.fd_or_err()?.as_raw_fd(),
program_data.fd_or_err()?,
fd,
kind,
event_alias,
@ -64,8 +62,7 @@ pub(crate) fn attach<T: Link + From<PerfLinkInner>>(
};
let fd = create_as_probe(kind, fn_name, offset, pid)?;
// TODO (AM)
let link = T::from(perf_attach(program_data.fd_or_err()?.as_raw_fd(), fd)?);
let link = T::from(perf_attach(program_data.fd_or_err()?, fd)?);
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 netns_fd = netns.as_raw_fd();
// TODO (AM)
let link_fd = bpf_link_create(prog_fd.as_raw_fd(), netns_fd, BPF_SK_LOOKUP, None, 0)
.map_err(|(_, io_error)| ProgramError::SyscallError {
let link_fd = bpf_link_create(prog_fd, netns_fd, BPF_SK_LOOKUP, None, 0).map_err(
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(),
io_error,
})?;
},
)?;
self.data
.links
.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 map_fd = map.as_raw_fd();
// TODO (AM)
bpf_prog_attach(prog_fd.as_raw_fd(), map_fd, BPF_SK_MSG_VERDICT).map_err(
|(_, io_error)| ProgramError::SyscallError {
bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT).map_err(|(_, io_error)| {
ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(),
io_error,
},
)?;
}
})?;
self.data.links.insert(SkMsgLink::new(ProgAttachLink::new(
// TODO (AM)
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::StreamVerdict => BPF_SK_SKB_STREAM_VERDICT,
};
// TODO (AM)
bpf_prog_attach(prog_fd.as_raw_fd(), map_fd, attach_type).map_err(|(_, io_error)| {
bpf_prog_attach(prog_fd, map_fd, attach_type).map_err(|(_, io_error)| {
ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(),
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 cgroup_fd = cgroup.as_raw_fd();
// TODO (AM)
bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_SOCK_OPS).map_err(
|(_, io_error)| ProgramError::SyscallError {
bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SOCK_OPS).map_err(|(_, io_error)| {
ProgramError::SyscallError {
call: "bpf_prog_attach".to_owned(),
io_error,
},
)?;
}
})?;
// TODO (AM)
self.data.links.insert(SockOpsLink::new(ProgAttachLink::new(
prog_fd.as_raw_fd(),

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

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

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

@ -1,5 +1,5 @@
//! 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::{
programs::{FdLink, Link, ProgramData, ProgramError},
@ -13,9 +13,7 @@ pub(crate) fn attach_raw_tracepoint<T: Link + From<FdLink>>(
) -> Result<T::Id, ProgramError> {
let prog_fd = program_data.fd_or_err()?;
// TODO (AM)
let pfd =
bpf_raw_tracepoint_open(tp_name, prog_fd.as_raw_fd()).map_err(|(_code, io_error)| {
let pfd = bpf_raw_tracepoint_open(tp_name, prog_fd).map_err(|(_code, io_error)| {
ProgramError::SyscallError {
call: "bpf_raw_tracepoint_open".to_owned(),
io_error,

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

@ -6,7 +6,10 @@ use std::{
ffi::CString,
hash::Hash,
io,
os::{fd::AsRawFd, unix::io::RawFd},
os::{
fd::{AsFd, AsRawFd},
unix::io::RawFd,
},
};
use thiserror::Error;
@ -134,13 +137,12 @@ impl Xdp {
let k_ver = kernel_version().unwrap();
if k_ver >= (5, 9, 0) {
// TODO (AM)
let link_fd =
bpf_link_create(prog_fd.as_raw_fd(), if_index, BPF_XDP, None, flags.bits())
.map_err(|(_, io_error)| ProgramError::SyscallError {
let link_fd = bpf_link_create(prog_fd, if_index, BPF_XDP, None, flags.bits()).map_err(
|(_, io_error)| ProgramError::SyscallError {
call: "bpf_link_create".to_owned(),
io_error,
})?;
},
)?;
self.data
.links
.insert(XdpLink::new(XdpLinkInner::FdLink(FdLink::new(link_fd))))
@ -298,12 +300,12 @@ impl TryFrom<FdLink> for XdpLink {
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.
let info =
// TODO (AM)
bpf_link_get_info_by_fd(fd_link.fd.as_raw_fd()).map_err(|io_error| LinkError::SyscallError {
let info = bpf_link_get_info_by_fd(fd_link.fd.as_fd()).map_err(|io_error| {
LinkError::SyscallError {
call: "BPF_OBJ_GET_INFO_BY_FD".to_string(),
code: 0,
io_error,
}
})?;
if info.type_ == (bpf_link_type::BPF_LINK_TYPE_XDP as u32) {
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,
mem::{self, MaybeUninit},
os::{
fd::{AsRawFd, FromRawFd, OwnedFd},
fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, OwnedFd},
unix::io::RawFd,
},
slice,
@ -100,10 +100,10 @@ pub(crate) fn bpf_create_map(
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 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;
sys_bpf(bpf_cmd::BPF_OBJ_PIN, &attr)
}
@ -204,7 +204,7 @@ pub(crate) fn bpf_load_program(
}
fn lookup<K: Pod, V: Pod>(
fd: RawFd,
fd: BorrowedFd<'_>,
key: Option<&K>,
flags: u64,
cmd: bpf_cmd,
@ -213,7 +213,7 @@ fn lookup<K: Pod, V: Pod>(
let mut value = MaybeUninit::zeroed();
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 {
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>(
fd: RawFd,
fd: BorrowedFd<'_>,
key: &K,
flags: u64,
) -> 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>(
fd: RawFd,
fd: BorrowedFd<'_>,
key: Option<&K>,
flags: u64,
) -> 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>(
fd: RawFd,
fd: BorrowedFd<'_>,
key: &K,
flags: u64,
) -> 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>(
fd: RawFd,
fd: BorrowedFd<'_>,
key: Option<&K>,
value: *mut V,
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 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 {
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>(
fd: RawFd,
fd: BorrowedFd<'_>,
key: Option<&K>,
value: &V,
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 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 {
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)
}
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 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.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>(
fd: RawFd,
fd: BorrowedFd<'_>,
key: *const K,
value: *mut V,
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 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.__bindgen_anon_1.value = value as u64;
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>(
fd: RawFd,
fd: BorrowedFd<'_>,
key: &K,
values: &PerCpuValues<V>,
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)
}
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 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;
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 next_key = MaybeUninit::uninit();
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 {
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
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 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)
}
// since kernel 5.7
pub(crate) fn bpf_link_create(
prog_fd: RawFd,
prog_fd: BorrowedFd<'_>,
target_fd: RawFd,
attach_type: bpf_attach_type,
btf_id: Option<u32>,
@ -382,7 +385,7 @@ pub(crate) fn bpf_link_create(
) -> Result<OwnedFd> {
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.attach_type = attach_type as u32;
attr.link_create.flags = flags;
@ -417,13 +420,13 @@ pub(crate) fn bpf_link_update(
}
pub(crate) fn bpf_prog_attach(
prog_fd: RawFd,
prog_fd: BorrowedFd<'_>,
target_fd: RawFd,
attach_type: bpf_attach_type,
) -> SysResult {
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.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>() };
// info gets entirely populated by the kernel
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_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>() };
// info gets entirely populated by the kernel
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_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>() };
attr.raw_tracepoint.name = match name {
Some(n) => n.as_ptr() as u64,
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;
// 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;
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)) =
// 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.
let res = e.raw_os_error() == Some(libc::EBADF);
unsafe { libc::close(fd as i32) };
return res;
return e.raw_os_error() == Some(libc::EBADF);
}
}
false

Write Preview
Loading…
Cancel
Save