From cb72b70312ddb3f68fd8bd11b1e8d7ae784c6d73 Mon Sep 17 00:00:00 2001 From: Dave Tucker Date: Fri, 18 Oct 2024 14:16:24 +0100 Subject: [PATCH] wip errors Signed-off-by: Dave Tucker --- aya-log/src/lib.rs | 7 +- aya-obj/src/btf/btf.rs | 11 +- aya/src/bpf.rs | 117 +- aya/src/errors.rs | 535 +++ aya/src/lib.rs | 2 +- aya/src/maps/array/array.rs | 18 +- aya/src/maps/array/per_cpu_array.rs | 23 +- aya/src/maps/array/program_array.rs | 20 +- aya/src/maps/bloom_filter.rs | 90 +- aya/src/maps/hash_map/hash_map.rs | 298 +- aya/src/maps/hash_map/mod.rs | 20 +- aya/src/maps/hash_map/per_cpu_hash_map.rs | 21 +- aya/src/maps/info.rs | 14 +- aya/src/maps/lpm_trie.rs | 133 +- aya/src/maps/mod.rs | 315 +- aya/src/maps/perf/async_perf_event_array.rs | 11 +- aya/src/maps/perf/perf_buffer.rs | 63 +- aya/src/maps/perf/perf_event_array.rs | 10 +- aya/src/maps/queue.rs | 14 +- aya/src/maps/ring_buf.rs | 17 +- aya/src/maps/sock/sock_hash.rs | 11 +- aya/src/maps/sock/sock_map.rs | 20 +- aya/src/maps/stack.rs | 16 +- aya/src/maps/stack_trace.rs | 29 +- aya/src/maps/xdp/cpu_map.rs | 21 +- aya/src/maps/xdp/dev_map.rs | 26 +- aya/src/maps/xdp/dev_map_hash.rs | 19 +- aya/src/maps/xdp/mod.rs | 15 - aya/src/maps/xdp/xsk_map.rs | 9 +- aya/src/pin.rs | 29 - aya/src/programs/cgroup_device.rs | 19 +- aya/src/programs/cgroup_skb.rs | 19 +- aya/src/programs/cgroup_sock.rs | 19 +- aya/src/programs/cgroup_sock_addr.rs | 19 +- aya/src/programs/cgroup_sockopt.rs | 19 +- aya/src/programs/cgroup_sysctl.rs | 19 +- aya/src/programs/extension.rs | 51 +- aya/src/programs/fentry.rs | 9 +- aya/src/programs/fexit.rs | 9 +- aya/src/programs/info.rs | 18 +- aya/src/programs/kprobe.rs | 32 +- aya/src/programs/links.rs | 73 +- aya/src/programs/lirc_mode2.rs | 9 +- aya/src/programs/lsm.rs | 7 +- aya/src/programs/mod.rs | 172 +- aya/src/programs/perf_attach.rs | 35 +- aya/src/programs/perf_event.rs | 21 +- aya/src/programs/probe.rs | 68 +- aya/src/programs/raw_trace_point.rs | 7 +- aya/src/programs/sk_lookup.rs | 15 +- aya/src/programs/sk_msg.rs | 7 +- aya/src/programs/sk_skb.rs | 7 +- aya/src/programs/sock_ops.rs | 17 +- aya/src/programs/socket_filter.rs | 24 +- aya/src/programs/tc.rs | 86 +- aya/src/programs/tp_btf.rs | 7 +- aya/src/programs/trace_point.rs | 50 +- aya/src/programs/uprobe.rs | 93 +- aya/src/programs/utils.rs | 13 +- aya/src/programs/xdp.rs | 56 +- aya/src/sys/bpf.rs | 250 +- aya/src/sys/fake.rs | 12 +- aya/src/sys/mod.rs | 169 +- aya/src/sys/perf_event.rs | 19 +- test/integration-test/src/tests/info.rs | 21 +- xtask/libbpf | 2 +- xtask/public-api/aya-log.txt | 22 +- xtask/public-api/aya-obj.txt | 19 +- xtask/public-api/aya.txt | 3630 ++++++++----------- 69 files changed, 3230 insertions(+), 3848 deletions(-) create mode 100644 aya/src/errors.rs delete mode 100644 aya/src/pin.rs diff --git a/aya-log/src/lib.rs b/aya-log/src/lib.rs index 610d37b64..bcb5cf1f7 100644 --- a/aya-log/src/lib.rs +++ b/aya-log/src/lib.rs @@ -60,11 +60,12 @@ use std::{ const MAP_NAME: &str = "AYA_LOGS"; use aya::{ + errors::{MapError, PerfBufferError, ProgramError}, maps::{ - perf::{AsyncPerfEventArray, Events, PerfBufferError}, - Map, MapData, MapError, MapInfo, + perf::{AsyncPerfEventArray, Events}, + Map, MapData, MapInfo, }, - programs::{loaded_programs, ProgramError}, + programs::loaded_programs, util::online_cpus, Ebpf, Pod, }; diff --git a/aya-obj/src/btf/btf.rs b/aya-obj/src/btf/btf.rs index 0d160a7d8..d8e8de7c0 100644 --- a/aya-obj/src/btf/btf.rs +++ b/aya-obj/src/btf/btf.rs @@ -1,5 +1,6 @@ use alloc::{ borrow::{Cow, ToOwned as _}, + boxed::Box, format, string::String, vec, @@ -157,6 +158,10 @@ pub enum BtfError { /// unable to get symbol name #[error("Unable to get symbol name")] InvalidSymbolName, + + /// an irrecoverable error occurred + #[error(transparent)] + Other(#[from] Box), } /// Available BTF features @@ -889,7 +894,7 @@ impl BtfExt { ); Ok((name, info)) }) - .collect::, _>>()?, + .collect::, BtfError>>()?, ); let line_info_rec_size = ext.line_info_rec_size; @@ -910,7 +915,7 @@ impl BtfExt { ); Ok((name, info)) }) - .collect::, _>>()?, + .collect::, BtfError>>()?, ); let rec_size = ext.core_relo_rec_size; @@ -925,7 +930,7 @@ impl BtfExt { .collect::, _>>()?; Ok((sec.name_offset, relos)) }) - .collect::, _>>()?, + .collect::, BtfError>>()?, ); Ok(ext) diff --git a/aya/src/bpf.rs b/aya/src/bpf.rs index bbe064b15..a008c7a37 100644 --- a/aya/src/bpf.rs +++ b/aya/src/bpf.rs @@ -1,7 +1,7 @@ use std::{ borrow::Cow, collections::{HashMap, HashSet}, - fs, io, + fs, os::{ fd::{AsFd as _, AsRawFd as _}, raw::c_int, @@ -11,29 +11,28 @@ use std::{ }; use aya_obj::{ - btf::{BtfFeatures, BtfRelocationError}, + btf::BtfFeatures, generated::{BPF_F_SLEEPABLE, BPF_F_XDP_HAS_FRAGS}, - relocation::EbpfRelocationError, EbpfSectionKind, Features, }; use log::{debug, warn}; -use thiserror::Error; use crate::{ + errors::{EbpfError, InternalMapError, MapError, SysError}, generated::{ bpf_map_type::{self, *}, AYA_PERF_EVENT_IOC_DISABLE, AYA_PERF_EVENT_IOC_ENABLE, AYA_PERF_EVENT_IOC_SET_BPF, }, - maps::{Map, MapData, MapError}, + maps::{Map, MapData}, obj::{ btf::{Btf, BtfError}, - Object, ParseError, ProgramSection, + Object, ProgramSection, }, programs::{ BtfTracePoint, CgroupDevice, CgroupSkb, CgroupSkbAttachType, CgroupSock, CgroupSockAddr, CgroupSockopt, CgroupSysctl, Extension, FEntry, FExit, KProbe, LircMode2, Lsm, PerfEvent, - ProbeKind, Program, ProgramData, ProgramError, RawTracePoint, SchedClassifier, SkLookup, - SkMsg, SkSkb, SkSkbKind, SockOps, SocketFilter, TracePoint, UProbe, Xdp, + ProbeKind, Program, ProgramData, RawTracePoint, SchedClassifier, SkLookup, SkMsg, SkSkb, + SkSkbKind, SockOps, SocketFilter, TracePoint, UProbe, Xdp, }, sys::{ bpf_load_btf, is_bpf_cookie_supported, is_bpf_global_data_supported, @@ -395,11 +394,15 @@ impl<'a> EbpfLoader<'a> { verifier_log_level, allow_unsupported_maps, } = self; - let mut obj = Object::parse(data)?; - obj.patch_map_data(globals.clone())?; + let mut obj = Object::parse(data).map_err(|e| EbpfError::Other(e.into()))?; + obj.patch_map_data(globals.clone()) + .map_err(|e| EbpfError::Other(e.into()))?; let btf_fd = if let Some(features) = &FEATURES.btf() { - if let Some(btf) = obj.fixup_and_sanitize_btf(features)? { + if let Some(btf) = obj + .fixup_and_sanitize_btf(features) + .map_err(|e| EbpfError::Other(e.into()))? + { match load_btf(btf.to_bytes(), *verifier_log_level) { Ok(btf_fd) => Some(Arc::new(btf_fd)), // Only report an error here if the BTF is truly needed, otherwise proceed without. @@ -411,7 +414,7 @@ impl<'a> EbpfLoader<'a> { | ProgramSection::FExit { sleepable: _ } | ProgramSection::Lsm { sleepable: _ } | ProgramSection::BtfTracePoint => { - return Err(EbpfError::BtfError(err)) + return Err(EbpfError::Other(err.into())); } ProgramSection::KRetProbe | ProgramSection::KProbe @@ -456,7 +459,8 @@ impl<'a> EbpfLoader<'a> { }; if let Some(btf) = &btf { - obj.relocate_btf(btf)?; + obj.relocate_btf(btf) + .map_err(|e| EbpfError::Other(e.into()))?; } let mut maps = HashMap::new(); for (name, mut obj) in obj.maps.drain() { @@ -471,7 +475,10 @@ impl<'a> EbpfLoader<'a> { error, })? as u32) }; - let map_type: bpf_map_type = obj.map_type().try_into().map_err(MapError::from)?; + let map_type: bpf_map_type = obj + .map_type() + .try_into() + .map_err(|e| EbpfError::MapError(MapError::from(e)))?; if let Some(max_entries) = max_entries_override( map_type, max_entries.get(name.as_str()).copied(), @@ -492,7 +499,9 @@ impl<'a> EbpfLoader<'a> { } let btf_fd = btf_fd.as_deref().map(|fd| fd.as_fd()); let mut map = match obj.pinning() { - PinningType::None => MapData::create(obj, &name, btf_fd)?, + PinningType::None => { + MapData::create(obj, &name, btf_fd).map_err(|e| EbpfError::Other(e.into()))? + } PinningType::ByName => { // pin maps in /sys/fs/bpf by default to align with libbpf // behavior https://github.com/libbpf/libbpf/blob/v1.2.2/src/libbpf.c#L2161. @@ -517,8 +526,10 @@ impl<'a> EbpfLoader<'a> { maps.iter() .map(|(s, data)| (s.as_str(), data.fd().as_fd().as_raw_fd(), data.obj())), &text_sections, - )?; - obj.relocate_calls(&text_sections)?; + ) + .map_err(|e| EbpfError::Other(e.into()))?; + obj.relocate_calls(&text_sections) + .map_err(|e| EbpfError::Other(e.into()))?; obj.sanitize_functions(&FEATURES); let programs = obj @@ -699,10 +710,10 @@ impl<'a> EbpfLoader<'a> { .collect::, EbpfError>>()?; if !*allow_unsupported_maps { - maps.iter().try_for_each(|(_, x)| match x { - Map::Unsupported(map) => Err(EbpfError::MapError(MapError::Unsupported { - map_type: map.obj().map_type(), - })), + maps.iter().try_for_each(|(name, x)| match x { + Map::Unsupported(_) => Err(EbpfError::Other(Box::new( + InternalMapError::Unsupported(name.clone()), + ))), _ => Ok(()), })?; }; @@ -713,7 +724,8 @@ impl<'a> EbpfLoader<'a> { fn parse_map(data: (String, MapData)) -> Result<(String, Map), EbpfError> { let (name, map) = data; - let map_type = bpf_map_type::try_from(map.obj().map_type()).map_err(MapError::from)?; + let map_type = bpf_map_type::try_from(map.obj().map_type()) + .map_err(|e| EbpfError::Other(Box::new(MapError::from(e))))?; let map = match map_type { BPF_MAP_TYPE_ARRAY => Map::Array(map), BPF_MAP_TYPE_PERCPU_ARRAY => Map::PerCpuArray(map), @@ -1068,55 +1080,6 @@ impl Ebpf { } } -/// The error type returned by [`Ebpf::load_file`] and [`Ebpf::load`]. -#[derive(Debug, Error)] -pub enum EbpfError { - /// Error loading file - #[error("error loading {path}")] - FileError { - /// The file path - path: PathBuf, - #[source] - /// The original io::Error - error: io::Error, - }, - - /// Unexpected pinning type - #[error("unexpected pinning type {name}")] - UnexpectedPinningType { - /// The value encountered - name: u32, - }, - - /// Error parsing BPF object - #[error("error parsing BPF object: {0}")] - ParseError(#[from] ParseError), - - /// Error parsing BTF object - #[error("BTF error: {0}")] - BtfError(#[from] BtfError), - - /// Error performing relocations - #[error("error relocating function")] - RelocationError(#[from] EbpfRelocationError), - - /// Error performing relocations - #[error("error relocating section")] - BtfRelocationError(#[from] BtfRelocationError), - - /// No BTF parsed for object - #[error("no BTF parsed for object")] - NoBTF, - - #[error("map error: {0}")] - /// A map error - MapError(#[from] MapError), - - #[error("program error: {0}")] - /// A program error - ProgramError(#[from] ProgramError), -} - /// The error type returned by [`Bpf::load_file`] and [`Bpf::load`]. #[deprecated(since = "0.13.0", note = "use `EbpfError` instead")] pub type BpfError = EbpfError; @@ -1128,10 +1091,14 @@ fn load_btf( let (ret, verifier_log) = retry_with_verifier_logs(10, |logger| { bpf_load_btf(raw_btf.as_slice(), logger, verifier_log_level) }); - ret.map_err(|(_, io_error)| BtfError::LoadError { - io_error, - verifier_log, - }) + match ret { + Ok(fd) => Ok(fd), + Err((_, SysError::Syscall { call: _, io_error })) => Err(BtfError::LoadError { + io_error, + verifier_log, + }), + Err((_, e)) => Err(BtfError::Other(Box::new(e))), + } } /// Global data that can be exported to eBPF programs before they are loaded. diff --git a/aya/src/errors.rs b/aya/src/errors.rs new file mode 100644 index 000000000..1f4578a07 --- /dev/null +++ b/aya/src/errors.rs @@ -0,0 +1,535 @@ +//! Aya Error types. + +use std::{error::Error, ffi::NulError, io, path::PathBuf}; + +use aya_obj::{ + btf::{BtfError, BtfRelocationError}, + relocation::EbpfRelocationError, + InvalidTypeBinding, ParseError, VerifierLog, +}; +use thiserror::Error; + +/// The error type returned by [`Ebpf::load_file`] and [`Ebpf::load`]. +#[derive(Debug, Error)] +#[cfg_attr(not(test), non_exhaustive)] +pub enum EbpfError { + /// Error loading file. + #[error("error loading {path}")] + FileError { + /// The file path. + path: PathBuf, + #[source] + /// The original [`io::Error`]. + error: io::Error, + }, + + #[error("map error: {0}")] + /// A map error. + MapError(#[from] MapError), + + #[error("program error: {0}")] + /// A program error. + ProgramError(#[from] ProgramError), + + /// An irrecoverable error occurred. + #[error(transparent)] + Other(#[from] Box), +} + +#[derive(Debug, Error)] +pub(crate) enum EbpfInternalError { + #[error("error parsing BPF object: {0}")] + ParseError(#[from] ParseError), + + #[error("BTF error: {0}")] + BtfError(#[from] BtfError), + + #[error("error relocating function")] + RelocationError(#[from] EbpfRelocationError), + + #[error("error relocating section")] + BtfRelocationError(#[from] BtfRelocationError), + + #[error("no BTF parsed for object")] + NoBTF, +} + +/// Error type returned when working with programs. +#[derive(Debug, Error)] +pub enum ProgramError { + /// The program is already loaded. + #[error("the program is already loaded")] + AlreadyLoaded, + + /// The program is not loaded. + #[error("the program is not loaded")] + NotLoaded, + + /// Loading the program failed. + #[error("the BPF_PROG_LOAD syscall failed. Verifier output: {verifier_log}")] + LoadError { + /// The [`SysError`] returned by the `BPF_PROG_LOAD` syscall. + #[source] + source: SysError, + /// The error log produced by the kernel verifier. + verifier_log: VerifierLog, + }, + + /// The program is not of the expected type. + #[error("unexpected program type")] + UnexpectedProgramType, + + /// A syscall failed. + #[error("syscall failed")] + Syscall(#[from] SysError), + + /// An irrecoverable error occurred. + #[error(transparent)] + Other(#[from] Box), +} + +impl From for ProgramError { + fn from(e: EbpfInternalError) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From<(i64, SysError)> for ProgramError { + fn from((_, error): (i64, SysError)) -> Self { + error.into() + } +} + +impl From for ProgramError { + fn from(e: io::Error) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for ProgramError { + fn from(e: BtfError) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for ProgramError { + fn from(e: LinkError) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for ProgramError { + fn from(e: NulError) -> Self { + Self::Other(Box::new(e)) + } +} + +/// An error ocurred working with a pinned BPF object. +#[derive(Error, Debug)] +pub(crate) enum PinError { + /// The path for the BPF object is not valid. + #[error("invalid pin path `{}`", path.display())] + InvalidPinPath { + /// The path. + path: std::path::PathBuf, + + #[source] + /// The source error. + error: std::ffi::NulError, + }, + /// An irrecoverable error occurred. + #[error(transparent)] + Other(#[from] Box), +} + +impl From for MapError { + fn from(e: InternalMapError) -> Self { + Self::Other(Box::new(e)) + } +} + +/// Errors from operations on maps. +#[derive(Error, Debug)] +pub enum MapError { + /// Key not found + #[error("key not found")] + KeyNotFound, + + /// Element not found + #[error("element not found")] + ElementNotFound, + + /// Index is out of bounds + #[error("the index is {index} but `max_entries` is {max_entries}")] + OutOfBounds { + /// Index accessed + index: u32, + /// Map size + max_entries: u32, + }, + + /// Chained programs are not supported. + #[error("chained programs are not supported by the current kernel")] + ChainedProgramNotSupported, + + /// Invalid map type encontered + #[error("invalid map type {map_type}")] + InvalidMapType { + /// The map type + map_type: u32, + }, + + /// A syscall failed. + #[error(transparent)] + Syscall(#[from] SysError), + + /// An internal and irrecoverable error occurred. + #[error(transparent)] + Other(#[from] Box), +} + +impl From<(i64, SysError)> for MapError { + fn from((_, error): (i64, SysError)) -> Self { + error.into() + } +} + +impl From for MapError { + fn from(e: io::Error) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for MapError { + fn from(e: NulError) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for MapError { + fn from(e: PinError) -> Self { + Self::Other(Box::new(e)) + } +} + +#[derive(Error, Debug)] +/// Errors occuring from working with Maps +pub(crate) enum InternalMapError { + /// Invalid map name encountered + #[error("invalid map name `{name}`")] + InvalidName { + /// The map name + name: String, + }, + + /// Failed to create map + #[error("failed to create map `{name}` with code {code}")] + CreateError { + /// Map name + name: String, + /// Error code + code: i64, + #[source] + /// Original io::Error + source: SysError, + }, + + /// Invalid key size + #[error("invalid key size {size}, expected {expected}")] + InvalidKeySize { + /// Size encountered + size: usize, + /// Size expected + expected: usize, + }, + + /// Invalid value size + #[error("invalid value size {size}, expected {expected}")] + InvalidValueSize { + /// Size encountered + size: usize, + /// Size expected + expected: usize, + }, + + /// An IO error occurred + #[error(transparent)] + IoError(#[from] io::Error), + + /// Syscall failed + #[error(transparent)] + SysError(#[from] SysError), + + /// Map type not supported + #[error("map {0}: type is not supported")] + Unsupported(String), +} + +impl From> for MapError { + fn from(e: InvalidTypeBinding) -> Self { + let InvalidTypeBinding { value } = e; + Self::InvalidMapType { map_type: value } + } +} + +/// Perf buffer error. +#[derive(Error, Debug)] +pub enum PerfBufferError { + /// the page count value passed to [`PerfEventArray::open`](crate::maps::PerfEventArray::open) is invalid. + #[error("invalid page count {page_count}, the value must be a power of two")] + InvalidPageCount { + /// the page count + page_count: usize, + }, + + /// `perf_event_open` failed. + #[error("perf_event_open failed: {io_error}")] + OpenError { + /// the source of this error + #[source] + io_error: io::Error, + }, + + /// `mmap`-ping the buffer failed. + #[error("mmap failed: {io_error}")] + MMapError { + /// the source of this error + #[source] + io_error: io::Error, + }, + + /// The `PERF_EVENT_IOC_ENABLE` ioctl failed + #[error("PERF_EVENT_IOC_ENABLE failed: {io_error}")] + PerfEventEnableError { + #[source] + /// the source of this error + io_error: io::Error, + }, + + /// `read_events()` was called with no output buffers. + #[error("read_events() was called with no output buffers")] + NoBuffers, + + /// `read_events()` was called with a buffer that is not large enough to + /// contain the next event in the perf buffer. + #[deprecated( + since = "0.10.8", + note = "read_events() now calls BytesMut::reserve() internally, so this error is never returned" + )] + #[error("the buffer needs to be of at least {size} bytes")] + MoreSpaceNeeded { + /// expected size + size: usize, + }, + + /// An IO error occurred. + #[error(transparent)] + IOError(#[from] io::Error), + + /// An irrecoverable error occurred. + #[error(transparent)] + Other(#[from] Box), +} + +impl From for PerfBufferError { + fn from(e: SysError) -> Self { + match e { + SysError::Syscall { call: _, io_error } => Self::Other(Box::new(io_error)), + SysError::Mmap { io_error } => Self::MMapError { io_error }, + _ => Self::Other(Box::new(e)), + } + } +} + +impl From<(i64, SysError)> for PerfBufferError { + fn from((_, error): (i64, SysError)) -> Self { + error.into() + } +} + +#[derive(Error, Debug)] +/// Errors from operations on links. +pub enum LinkError { + /// Invalid link. + #[error("Invalid link")] + InvalidLink, + + /// The program is not attached. + #[error("the program is not attached")] + NotAttached, + + /// The program is already attached. + #[error("the program is already attached")] + AlreadyAttached, + + /// A file error. + #[error("file error: {path}")] + FileError { + /// The file path. + path: PathBuf, + /// The original [`io::Error`]. + #[source] + error: io::Error, + }, + + /// An irrecoverable error occurred. + #[error(transparent)] + Other(#[from] Box), +} + +impl From<(PathBuf, io::Error)> for LinkError { + fn from((path, error): (PathBuf, io::Error)) -> Self { + Self::FileError { path, error } + } +} + +impl From for LinkError { + fn from(e: SysError) -> Self { + match e { + SysError::Syscall { call: _, io_error } => Self::Other(Box::new(io_error)), + _ => Self::Other(Box::new(e)), + } + } +} + +impl From<(i64, SysError)> for LinkError { + fn from((_, error): (i64, SysError)) -> Self { + error.into() + } +} + +impl From for LinkError { + fn from(e: ProgramError) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for LinkError { + fn from(e: io::Error) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for LinkError { + fn from(e: NulError) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for LinkError { + fn from(e: std::num::ParseIntError) -> Self { + Self::Other(Box::new(e)) + } +} + +impl From for LinkError { + fn from(e: ResolveSymbolError) -> Self { + Self::Other(Box::new(e)) + } +} + +#[derive(Error, Debug)] +pub(crate) enum InternalLinkError { + #[error("the target program is not loaded")] + TargetProgramNotLoaded, + + #[error("target program does not have BTF")] + TargetNoBtf, + + #[error("error reading ld.so.cache file")] + LdSoCache { + #[source] + io_error: &'static io::Error, + }, + + #[error("could not resolve uprobe target `{path}`")] + InvalidTarget { + /// path to target + path: PathBuf, + }, + + /// netlink error while attaching XDP program + #[error("Netlink error")] + NetlinkError { + /// the [`io::Error`] from the netlink call + #[source] + io_error: io::Error, + }, + + /// operation not supported for programs loaded via tcx + #[error("operation not supported for programs loaded via tcx")] + InvalidLinkOperation, + + /// tcx links can only be attached to ingress or egress, custom attachment is not supported + #[error("tcx links can only be attached to ingress or egress, custom attachment: {0} is not supported")] + InvalidTcxAttach(u32), + + /// The network interface does not exist. + #[error("unknown network interface {name}")] + UnknownInterface { + /// interface name + name: String, + }, + + /// Setting the `SO_ATTACH_BPF` socket option failed. + #[error("setsockopt SO_ATTACH_BPF failed")] + SoAttachEbpf { + /// original [`io::Error`] + #[source] + io_error: io::Error, + }, +} + +impl From for LinkError { + fn from(e: InternalLinkError) -> Self { + Self::Other(Box::new(e)) + } +} + +#[derive(Error, Debug)] +pub(crate) enum ResolveSymbolError { + #[error(transparent)] + Io(#[from] io::Error), + + #[error("error parsing ELF")] + Object(#[from] object::Error), + + #[error("unknown symbol `{0}`")] + Unknown(String), + + #[error("symbol `{0}` does not appear in section")] + NotInSection(String), + + #[error("symbol `{0}` in section `{1:?}` which has no offset")] + SectionFileRangeNone(String, Result), + + #[error("failed to access debuglink file `{0}`: `{1}`")] + DebuglinkAccessError(String, io::Error), + + #[error("symbol `{0}` not found, mismatched build IDs in main and debug files")] + BuildIdMismatch(String), +} + +/// Errors from Syscalls. +#[derive(Debug, Error)] +pub enum SysError { + /// A syscall failed. + #[error("{call} failed")] + Syscall { + /// The name of the syscall which failed. + call: String, + /// The [`io::Error`] returned by the syscall. + #[source] + io_error: io::Error, + }, + /// A mmap operation failed. + #[error("mmap failed")] + Mmap { + /// The [`io::Error`] returned by the mmap operation. + #[source] + io_error: io::Error, + }, + /// An irecoverable error occurred. + #[error(transparent)] + Other(#[from] Box), +} diff --git a/aya/src/lib.rs b/aya/src/lib.rs index 3278d3dcd..3041dc33a 100644 --- a/aya/src/lib.rs +++ b/aya/src/lib.rs @@ -78,8 +78,8 @@ )] mod bpf; +pub mod errors; pub mod maps; -pub mod pin; pub mod programs; pub mod sys; pub mod util; diff --git a/aya/src/maps/array/array.rs b/aya/src/maps/array/array.rs index 8ca907f54..04b005fa8 100644 --- a/aya/src/maps/array/array.rs +++ b/aya/src/maps/array/array.rs @@ -5,8 +5,9 @@ use std::{ }; use crate::{ - maps::{check_bounds, check_kv_size, IterableMap, MapData, MapError}, - sys::{bpf_map_lookup_elem, bpf_map_update_elem, SyscallError}, + errors::MapError, + maps::{check_bounds, check_kv_size, IterableMap, MapData}, + sys::{bpf_map_lookup_elem, bpf_map_update_elem}, Pod, }; @@ -64,11 +65,7 @@ impl, V: Pod> Array { check_bounds(data, *index)?; let fd = data.fd().as_fd(); - let value = - bpf_map_lookup_elem(fd, index, flags).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })?; + let value = bpf_map_lookup_elem(fd, index, flags)?; value.ok_or(MapError::KeyNotFound) } @@ -90,12 +87,7 @@ impl, V: Pod> Array { let data = self.inner.borrow_mut(); check_bounds(data, index)?; let fd = data.fd().as_fd(); - bpf_map_update_elem(fd, Some(&index), value.borrow(), flags).map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_update_elem", - io_error, - } - })?; + bpf_map_update_elem(fd, Some(&index), value.borrow(), flags)?; Ok(()) } } diff --git a/aya/src/maps/array/per_cpu_array.rs b/aya/src/maps/array/per_cpu_array.rs index 66e7f4313..d64ec8cc7 100644 --- a/aya/src/maps/array/per_cpu_array.rs +++ b/aya/src/maps/array/per_cpu_array.rs @@ -5,8 +5,9 @@ use std::{ }; use crate::{ - maps::{check_bounds, check_kv_size, IterableMap, MapData, MapError, PerCpuValues}, - sys::{bpf_map_lookup_elem_per_cpu, bpf_map_update_elem_per_cpu, SyscallError}, + errors::MapError, + maps::{check_bounds, check_kv_size, IterableMap, MapData, PerCpuValues}, + sys::{bpf_map_lookup_elem_per_cpu, bpf_map_update_elem_per_cpu}, Pod, }; @@ -83,12 +84,7 @@ impl, V: Pod> PerCpuArray { check_bounds(data, *index)?; let fd = data.fd().as_fd(); - let value = bpf_map_lookup_elem_per_cpu(fd, index, flags).map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_lookup_elem", - io_error, - } - })?; + let value = bpf_map_lookup_elem_per_cpu(fd, index, flags)?; value.ok_or(MapError::KeyNotFound) } @@ -104,19 +100,14 @@ impl, V: Pod> PerCpuArray { /// /// # Errors /// - /// Returns [`MapError::OutOfBounds`] if `index` is out of bounds, [`MapError::SyscallError`] - /// if `bpf_map_update_elem` fails. + /// Returns [`MapError::OutOfBounds`] if `index` is out of bounds, [`MapError::Other`] + /// if `bpf_map_update_elem` fails for any other reason. pub fn set(&mut self, index: u32, values: PerCpuValues, flags: u64) -> Result<(), MapError> { let data = self.inner.borrow_mut(); check_bounds(data, index)?; let fd = data.fd().as_fd(); - bpf_map_update_elem_per_cpu(fd, &index, &values, flags).map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_update_elem", - io_error, - } - })?; + bpf_map_update_elem_per_cpu(fd, &index, &values, flags)?; Ok(()) } } diff --git a/aya/src/maps/array/program_array.rs b/aya/src/maps/array/program_array.rs index ca6beb8e2..4eb836d1f 100644 --- a/aya/src/maps/array/program_array.rs +++ b/aya/src/maps/array/program_array.rs @@ -6,9 +6,10 @@ use std::{ }; use crate::{ - maps::{check_bounds, check_kv_size, MapData, MapError, MapKeys}, + errors::MapError, + maps::{check_bounds, check_kv_size, MapData, MapKeys}, programs::ProgramFd, - sys::{bpf_map_delete_elem, bpf_map_update_elem, SyscallError}, + sys::{bpf_map_delete_elem, bpf_map_update_elem}, }; /// An array of eBPF program file descriptors used as a jump table. @@ -78,12 +79,7 @@ impl> ProgramArray { let prog_fd = program.as_fd(); let prog_fd = prog_fd.as_raw_fd(); - bpf_map_update_elem(fd, Some(&index), &prog_fd, flags).map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_update_elem", - io_error, - } - })?; + bpf_map_update_elem(fd, Some(&index), &prog_fd, flags)?; Ok(()) } @@ -98,12 +94,6 @@ impl> ProgramArray { bpf_map_delete_elem(fd, index) .map(|_| ()) - .map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_delete_elem", - io_error, - } - .into() - }) + .map_err(Into::into) } } diff --git a/aya/src/maps/bloom_filter.rs b/aya/src/maps/bloom_filter.rs index 8e6e521e1..0a7849d9f 100644 --- a/aya/src/maps/bloom_filter.rs +++ b/aya/src/maps/bloom_filter.rs @@ -6,8 +6,9 @@ use std::{ }; use crate::{ - maps::{check_v_size, MapData, MapError}, - sys::{bpf_map_lookup_elem_ptr, bpf_map_push_elem, SyscallError}, + errors::MapError, + maps::{check_v_size, MapData}, + sys::{bpf_map_lookup_elem_ptr, bpf_map_push_elem}, Pod, }; @@ -54,11 +55,7 @@ impl, V: Pod> BloomFilter { pub fn contains(&self, mut value: &V, flags: u64) -> Result<(), MapError> { let fd = self.inner.borrow().fd().as_fd(); - bpf_map_lookup_elem_ptr::(fd, None, &mut value, flags) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })? + bpf_map_lookup_elem_ptr::(fd, None, &mut value, flags)? .ok_or(MapError::ElementNotFound)?; Ok(()) } @@ -68,10 +65,7 @@ impl, V: Pod> BloomFilter { /// Inserts a value into the map. pub fn insert(&mut self, value: impl Borrow, flags: u64) -> Result<(), MapError> { let fd = self.inner.borrow_mut().fd().as_fd(); - bpf_map_push_elem(fd, value.borrow(), flags).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_push_elem", - io_error, - })?; + bpf_map_push_elem(fd, value.borrow(), flags)?; Ok(()) } } @@ -81,40 +75,60 @@ mod tests { use std::io; use assert_matches::assert_matches; - use libc::{EFAULT, ENOENT}; + use libc::{EFAULT, EINVAL, ENOENT}; use super::*; use crate::{ - generated::{ - bpf_cmd, - bpf_map_type::{BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_BLOOM_FILTER}, - }, + errors::{InternalMapError, SysError}, + generated::bpf_map_type::{BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_BLOOM_FILTER}, maps::{ test_utils::{self, new_map}, Map, }, obj, - sys::{override_syscall, SysResult, Syscall}, + sys::{override_syscall, BpfCmd, SysResult, Syscall}, }; fn new_obj_map() -> obj::Map { test_utils::new_obj_map::(BPF_MAP_TYPE_BLOOM_FILTER) } - fn sys_error(value: i32) -> SysResult { - Err((-1, io::Error::from_raw_os_error(value))) + fn sys_error(call: Syscall<'_>, value: i32) -> SysResult { + match call { + Syscall::Ebpf { .. } => Err(( + -1, + SysError::Syscall { + call: format!("{:?}", call), + io_error: io::Error::from_raw_os_error(value), + }, + )), + _ => Err(( + -1, + SysError::Syscall { + call: "UNEXPECTED!!!".to_string(), + io_error: io::Error::from_raw_os_error(EINVAL), + }, + )), + } } #[test] fn test_wrong_value_size() { let map = new_map(new_obj_map()); - assert_matches!( - BloomFilter::<_, u16>::new(&map), - Err(MapError::InvalidValueSize { - size: 2, - expected: 4 - }) - ); + let res = BloomFilter::<_, u16>::new(&map); + assert!(res.is_err()); + let res = res.unwrap_err(); + if let MapError::Other(map_err) = res { + assert_matches!( + map_err.downcast_ref::().unwrap(), + InternalMapError::InvalidKeySize { + size: 2, + expected: 4 + } + ); + } else { + panic!("unexpected error: {:?}", res); + } } #[test] @@ -149,12 +163,9 @@ mod tests { let mut map = new_map(new_obj_map()); let mut bloom_filter = BloomFilter::<_, u32>::new(&mut map).unwrap(); - override_syscall(|_| sys_error(EFAULT)); + override_syscall(|c| sys_error(c, EFAULT)); - assert_matches!( - bloom_filter.insert(1, 0), - Err(MapError::SyscallError(SyscallError { call: "bpf_map_push_elem", io_error })) if io_error.raw_os_error() == Some(EFAULT) - ); + assert!(bloom_filter.insert(1, 0).is_err()); } #[test] @@ -164,10 +175,10 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_UPDATE_ELEM, + cmd: BpfCmd::MapUpdateElem, .. } => Ok(1), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); assert!(bloom_filter.insert(0, 42).is_ok()); @@ -178,12 +189,9 @@ mod tests { let map = new_map(new_obj_map()); let bloom_filter = BloomFilter::<_, u32>::new(&map).unwrap(); - override_syscall(|_| sys_error(EFAULT)); + override_syscall(|c| sys_error(c, EFAULT)); - assert_matches!( - bloom_filter.contains(&1, 0), - Err(MapError::SyscallError(SyscallError { call: "bpf_map_lookup_elem", io_error })) if io_error.raw_os_error() == Some(EFAULT) - ); + assert!(bloom_filter.contains(&1, 0).is_err()); } #[test] @@ -193,10 +201,10 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM, + cmd: BpfCmd::MapUpdateElem, .. - } => sys_error(ENOENT), - _ => sys_error(EFAULT), + } => sys_error(call, ENOENT), + c => sys_error(c, EFAULT), }); assert_matches!(bloom_filter.contains(&1, 0), Err(MapError::ElementNotFound)); diff --git a/aya/src/maps/hash_map/hash_map.rs b/aya/src/maps/hash_map/hash_map.rs index becac6c4b..49720d026 100644 --- a/aya/src/maps/hash_map/hash_map.rs +++ b/aya/src/maps/hash_map/hash_map.rs @@ -5,8 +5,9 @@ use std::{ }; use crate::{ - maps::{check_kv_size, hash_map, IterableMap, MapData, MapError, MapIter, MapKeys}, - sys::{bpf_map_lookup_elem, SyscallError}, + errors::MapError, + maps::{check_kv_size, hash_map, IterableMap, MapData, MapIter, MapKeys}, + sys::bpf_map_lookup_elem, Pod, }; @@ -54,10 +55,7 @@ impl, K: Pod, V: Pod> HashMap { /// Returns a copy of the value associated with the key. pub fn get(&self, key: &K, flags: u64) -> Result { let fd = self.inner.borrow().fd().as_fd(); - let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })?; + let value = bpf_map_lookup_elem(fd, key, flags)?; value.ok_or(MapError::KeyNotFound) } @@ -106,12 +104,13 @@ mod tests { use std::io; use assert_matches::assert_matches; - use libc::{EFAULT, ENOENT}; + use libc::{EFAULT, EINVAL, ENOENT}; use super::*; use crate::{ + errors::{InternalMapError, SysError}, generated::{ - bpf_attr, bpf_cmd, + bpf_attr, bpf_map_type::{BPF_MAP_TYPE_HASH, BPF_MAP_TYPE_LRU_HASH}, }, maps::{ @@ -119,39 +118,68 @@ mod tests { Map, }, obj, - sys::{override_syscall, SysResult, Syscall}, + sys::{override_syscall, BpfCmd, SysResult, Syscall}, }; fn new_obj_map() -> obj::Map { test_utils::new_obj_map::(BPF_MAP_TYPE_HASH) } - fn sys_error(value: i32) -> SysResult { - Err((-1, io::Error::from_raw_os_error(value))) + fn sys_error(call: Syscall<'_>, value: i32) -> SysResult { + match call { + Syscall::Ebpf { .. } => Err(( + -1, + SysError::Syscall { + call: format!("{:?}", call), + io_error: io::Error::from_raw_os_error(value), + }, + )), + _ => Err(( + -1, + SysError::Syscall { + call: "UNEXPECTED!!!".to_string(), + io_error: io::Error::from_raw_os_error(EINVAL), + }, + )), + } } #[test] fn test_wrong_key_size() { let map = new_map(new_obj_map()); - assert_matches!( - HashMap::<_, u8, u32>::new(&map), - Err(MapError::InvalidKeySize { - size: 1, - expected: 4 - }) - ); + let res = HashMap::<_, u8, u32>::new(&map); + assert!(res.is_err()); + let res = res.unwrap_err(); + if let MapError::Other(map_err) = res { + assert_matches!( + map_err.downcast_ref::().unwrap(), + InternalMapError::InvalidKeySize { + size: 1, + expected: 4 + } + ); + } else { + panic!("unexpected error: {:?}", res); + } } #[test] fn test_wrong_value_size() { let map = new_map(new_obj_map()); - assert_matches!( - HashMap::<_, u32, u16>::new(&map), - Err(MapError::InvalidValueSize { - size: 2, - expected: 4 - }) - ); + let res = HashMap::<_, u32, u16>::new(&map); + assert!(res.is_err()); + let res = res.unwrap_err(); + if let MapError::Other(map_err) = res { + assert_matches!( + map_err.downcast_ref::().unwrap(), + InternalMapError::InvalidValueSize { + size: 2, + expected: 4 + } + ); + } else { + panic!("unexpected error: {:?}", res); + } } #[test] @@ -160,7 +188,7 @@ mod tests { let map = Map::Array(map); assert_matches!( HashMap::<_, u8, u32>::try_from(&map), - Err(MapError::InvalidMapType { .. }) + Err(MapError::Other(_)) ); } @@ -170,10 +198,7 @@ mod tests { let map = Map::HashMap(map); assert_matches!( HashMap::<_, u32, u16>::try_from(&map), - Err(MapError::InvalidValueSize { - size: 2, - expected: 4 - }) + Err(MapError::Other(_)) ); } @@ -204,12 +229,9 @@ mod tests { let mut map = new_map(new_obj_map()); let mut hm = HashMap::<_, u32, u32>::new(&mut map).unwrap(); - override_syscall(|_| sys_error(EFAULT)); + override_syscall(|c| sys_error(c, EFAULT)); - assert_matches!( - hm.insert(1, 42, 0), - Err(MapError::SyscallError(SyscallError { call: "bpf_map_update_elem", io_error })) if io_error.raw_os_error() == Some(EFAULT) - ); + assert!(hm.insert(1, 42, 0).is_err()); } #[test] @@ -219,10 +241,10 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_UPDATE_ELEM, + cmd: BpfCmd::MapUpdateElem, .. } => Ok(1), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); assert!(hm.insert(1, 42, 0).is_ok()); @@ -235,10 +257,10 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_UPDATE_ELEM, + cmd: BpfCmd::MapUpdateElem, .. } => Ok(1), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); assert!(hm.insert(Box::new(1), Box::new(42), 0).is_ok()); @@ -249,12 +271,9 @@ mod tests { let mut map = new_map(new_obj_map()); let mut hm = HashMap::<_, u32, u32>::new(&mut map).unwrap(); - override_syscall(|_| sys_error(EFAULT)); + override_syscall(|c| sys_error(c, EFAULT)); - assert_matches!( - hm.remove(&1), - Err(MapError::SyscallError(SyscallError { call: "bpf_map_delete_elem", io_error })) if io_error.raw_os_error() == Some(EFAULT) - ); + assert!(hm.remove(&1).is_err()); } #[test] @@ -264,10 +283,10 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_DELETE_ELEM, + cmd: BpfCmd::MapDeleteElem, .. } => Ok(1), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); assert!(hm.remove(&1).is_ok()); @@ -276,13 +295,19 @@ mod tests { #[test] fn test_get_syscall_error() { let map = new_map(new_obj_map()); - override_syscall(|_| sys_error(EFAULT)); + override_syscall(|c| sys_error(c, EFAULT)); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); - - assert_matches!( - hm.get(&1, 0), - Err(MapError::SyscallError(SyscallError { call: "bpf_map_lookup_elem", io_error })) if io_error.raw_os_error() == Some(EFAULT) - ); + let res = hm.get(&1, 0); + assert!(res.is_err()); + let res = res.unwrap_err(); + if let MapError::Other(map_err) = res { + assert_matches!( + map_err.downcast_ref::().unwrap(), + SysError::Syscall { call, io_error } if call == "bpf_map_lookup_elem" && io_error.raw_os_error() == Some(EFAULT) + ); + } else { + panic!("unexpected error: {:?}", res); + } } #[test] @@ -290,10 +315,10 @@ mod tests { let map = new_map(new_obj_map()); override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM, + cmd: BpfCmd::MapLookupElem, .. - } => sys_error(ENOENT), - _ => sys_error(EFAULT), + } => sys_error(call, ENOENT), + c => sys_error(c, EFAULT), }); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); @@ -322,13 +347,13 @@ mod tests { let map = new_map(new_obj_map()); override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_NEXT_KEY, + cmd: BpfCmd::MapGetNextKey, .. - } => sys_error(ENOENT), - _ => sys_error(EFAULT), + } => sys_error(call, ENOENT), + c => sys_error(c, EFAULT), }); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); - let keys = hm.keys().collect::, _>>(); + let keys = hm.keys().collect::, MapError>>(); assert_matches!(keys, Ok(ks) if ks.is_empty()) } @@ -337,8 +362,24 @@ mod tests { None => set_next_key(attr, 10), Some(10) => set_next_key(attr, 20), Some(20) => set_next_key(attr, 30), - Some(30) => return sys_error(ENOENT), - Some(_) => return sys_error(EFAULT), + Some(30) => { + return sys_error( + Syscall::Ebpf { + cmd: BpfCmd::MapGetNextKey, + attr: &mut attr.clone(), + }, + ENOENT, + ) + } + Some(_) => { + return sys_error( + Syscall::Ebpf { + cmd: BpfCmd::MapGetNextKey, + attr: &mut attr.clone(), + }, + EFAULT, + ) + } }; Ok(1) @@ -349,8 +390,24 @@ mod tests { Some(10) => set_ret(attr, 100), Some(20) => set_ret(attr, 200), Some(30) => set_ret(attr, 300), - Some(_) => return sys_error(ENOENT), - None => return sys_error(EFAULT), + Some(_) => { + return sys_error( + Syscall::Ebpf { + cmd: BpfCmd::MapLookupElem, + attr: &mut attr.clone(), + }, + ENOENT, + ) + } + None => { + return sys_error( + Syscall::Ebpf { + cmd: BpfCmd::MapLookupElem, + attr: &mut attr.clone(), + }, + EFAULT, + ) + } }; Ok(1) @@ -362,15 +419,15 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_NEXT_KEY, + cmd: BpfCmd::MapGetNextKey, attr, } => get_next_key(attr), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); - let keys = hm.keys().collect::, _>>().unwrap(); + let keys = hm.keys().collect::, MapError>>().unwrap(); assert_eq!(&keys, &[10, 20, 30]) } @@ -379,31 +436,33 @@ mod tests { let map = new_map(new_obj_map()); override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_NEXT_KEY, + cmd: BpfCmd::MapGetNextKey, attr, } => { match bpf_key(attr) { None => set_next_key(attr, 10), Some(10) => set_next_key(attr, 20), - Some(_) => return sys_error(EFAULT), + Some(_) => { + return sys_error( + Syscall::Ebpf { + cmd: BpfCmd::MapGetNextKey, + attr: &mut attr.clone(), + }, + EFAULT, + ) + } }; Ok(1) } - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); let mut keys = hm.keys(); assert_matches!(keys.next(), Some(Ok(10))); assert_matches!(keys.next(), Some(Ok(20))); - assert_matches!( - keys.next(), - Some(Err(MapError::SyscallError(SyscallError { - call: "bpf_map_get_next_key", - io_error: _ - }))) - ); + assert_matches!(keys.next(), Some(Err(MapError::Other(_)))); assert_matches!(keys.next(), None); } @@ -412,17 +471,20 @@ mod tests { let map = new_map(new_obj_map()); override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_NEXT_KEY, + cmd: BpfCmd::MapGetNextKey, attr, } => get_next_key(attr), Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM, + cmd: BpfCmd::MapLookupElem, attr, } => lookup_elem(attr), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); - let items = hm.iter().collect::, _>>().unwrap(); + let items = hm + .iter() + .collect::, MapError>>() + .unwrap(); assert_eq!(&items, &[(10, 100), (20, 200), (30, 300)]) } @@ -431,28 +493,36 @@ mod tests { let map = new_map(new_obj_map()); override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_NEXT_KEY, + cmd: BpfCmd::MapGetNextKey, attr, } => get_next_key(attr), Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM, + cmd: BpfCmd::MapLookupElem, attr, } => { + let call = { + Syscall::Ebpf { + cmd: BpfCmd::MapLookupElem, + attr: &mut attr.clone(), + } + }; match bpf_key(attr) { Some(10) => set_ret(attr, 100), - Some(20) => return sys_error(ENOENT), + Some(20) => return sys_error(call, ENOENT), Some(30) => set_ret(attr, 300), - Some(_) => return sys_error(ENOENT), - None => return sys_error(EFAULT), - }; - + Some(_) => return sys_error(call, ENOENT), + None => return sys_error(call, EFAULT), + } Ok(1) } - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); - let items = hm.iter().collect::, _>>().unwrap(); + let items = hm + .iter() + .collect::, MapError>>() + .unwrap(); assert_eq!(&items, &[(10, 100), (30, 300)]) } @@ -461,37 +531,37 @@ mod tests { let map = new_map(new_obj_map()); override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_NEXT_KEY, + cmd: BpfCmd::MapGetNextKey, attr, } => { + let call = { + Syscall::Ebpf { + cmd: BpfCmd::MapGetNextKey, + attr: &mut attr.clone(), + } + }; match bpf_key(attr) { None => set_next_key(attr, 10), Some(10) => set_next_key(attr, 20), - Some(20) => return sys_error(EFAULT), - Some(30) => return sys_error(ENOENT), + Some(20) => return sys_error(call, EFAULT), + Some(30) => return sys_error(call, ENOENT), Some(i) => panic!("invalid key {}", i), }; Ok(1) } Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM, + cmd: BpfCmd::MapLookupElem, attr, } => lookup_elem(attr), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); let mut iter = hm.iter(); assert_matches!(iter.next(), Some(Ok((10, 100)))); assert_matches!(iter.next(), Some(Ok((20, 200)))); - assert_matches!( - iter.next(), - Some(Err(MapError::SyscallError(SyscallError { - call: "bpf_map_get_next_key", - io_error: _ - }))) - ); + assert_matches!(iter.next(), Some(Err(MapError::Other(_)))); assert_matches!(iter.next(), None); } @@ -500,36 +570,36 @@ mod tests { let map = new_map(new_obj_map()); override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_NEXT_KEY, + cmd: BpfCmd::MapGetNextKey, attr, } => get_next_key(attr), Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM, + cmd: BpfCmd::MapLookupElem, attr, } => { + let call = { + Syscall::Ebpf { + cmd: BpfCmd::MapLookupElem, + attr: &mut attr.clone(), + } + }; match bpf_key(attr) { Some(10) => set_ret(attr, 100), - Some(20) => return sys_error(EFAULT), + Some(20) => return sys_error(call, EFAULT), Some(30) => set_ret(attr, 300), - Some(_) => return sys_error(ENOENT), - None => return sys_error(EFAULT), + Some(_) => return sys_error(call, ENOENT), + None => return sys_error(call, EFAULT), }; Ok(1) } - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); let hm = HashMap::<_, u32, u32>::new(&map).unwrap(); let mut iter = hm.iter(); assert_matches!(iter.next(), Some(Ok((10, 100)))); - assert_matches!( - iter.next(), - Some(Err(MapError::SyscallError(SyscallError { - call: "bpf_map_lookup_elem", - io_error: _ - }))) - ); + assert_matches!(iter.next(), Some(Err(MapError::Other(_)))); assert_matches!(iter.next(), Some(Ok((30, 300)))); assert_matches!(iter.next(), None); } diff --git a/aya/src/maps/hash_map/mod.rs b/aya/src/maps/hash_map/mod.rs index 33f5292b1..4f337f7a7 100644 --- a/aya/src/maps/hash_map/mod.rs +++ b/aya/src/maps/hash_map/mod.rs @@ -2,8 +2,8 @@ use std::os::fd::AsFd as _; use crate::{ - maps::MapError, - sys::{bpf_map_delete_elem, bpf_map_update_elem, SyscallError}, + errors::MapError, + sys::{bpf_map_delete_elem, bpf_map_update_elem}, Pod, }; @@ -23,23 +23,11 @@ pub(crate) fn insert( flags: u64, ) -> Result<(), MapError> { let fd = map.fd().as_fd(); - bpf_map_update_elem(fd, Some(key), value, flags).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_update_elem", - io_error, - })?; - + bpf_map_update_elem(fd, Some(key), value, flags)?; Ok(()) } pub(crate) fn remove(map: &MapData, key: &K) -> Result<(), MapError> { let fd = map.fd().as_fd(); - bpf_map_delete_elem(fd, key) - .map(|_| ()) - .map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_delete_elem", - io_error, - } - .into() - }) + bpf_map_delete_elem(fd, key).map(|_| ()).map_err(Into::into) } diff --git a/aya/src/maps/hash_map/per_cpu_hash_map.rs b/aya/src/maps/hash_map/per_cpu_hash_map.rs index 54cbe1186..dfa369d88 100644 --- a/aya/src/maps/hash_map/per_cpu_hash_map.rs +++ b/aya/src/maps/hash_map/per_cpu_hash_map.rs @@ -6,10 +6,9 @@ use std::{ }; use crate::{ - maps::{ - check_kv_size, hash_map, IterableMap, MapData, MapError, MapIter, MapKeys, PerCpuValues, - }, - sys::{bpf_map_lookup_elem_per_cpu, bpf_map_update_elem_per_cpu, SyscallError}, + errors::MapError, + maps::{check_kv_size, hash_map, IterableMap, MapData, MapIter, MapKeys, PerCpuValues}, + sys::{bpf_map_lookup_elem_per_cpu, bpf_map_update_elem_per_cpu}, Pod, }; @@ -63,11 +62,7 @@ impl, K: Pod, V: Pod> PerCpuHashMap { /// Returns a slice of values - one for each CPU - associated with the key. pub fn get(&self, key: &K, flags: u64) -> Result, MapError> { let fd = self.inner.borrow().fd().as_fd(); - let values = - bpf_map_lookup_elem_per_cpu(fd, key, flags).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })?; + let values = bpf_map_lookup_elem_per_cpu(fd, key, flags)?; values.ok_or(MapError::KeyNotFound) } @@ -121,13 +116,7 @@ impl, K: Pod, V: Pod> PerCpuHashMap { flags: u64, ) -> Result<(), MapError> { let fd = self.inner.borrow_mut().fd().as_fd(); - bpf_map_update_elem_per_cpu(fd, key.borrow(), &values, flags).map_err( - |(_, io_error)| SyscallError { - call: "bpf_map_update_elem", - io_error, - }, - )?; - + bpf_map_update_elem_per_cpu(fd, key.borrow(), &values, flags)?; Ok(()) } diff --git a/aya/src/maps/info.rs b/aya/src/maps/info.rs index 2d36c2a19..5deaba4c7 100644 --- a/aya/src/maps/info.rs +++ b/aya/src/maps/info.rs @@ -8,11 +8,10 @@ use std::{ use aya_obj::generated::{bpf_map_info, bpf_map_type}; -use super::{MapError, MapFd}; +use super::MapFd; use crate::{ - sys::{ - bpf_get_object, bpf_map_get_fd_by_id, bpf_map_get_info_by_fd, iter_map_ids, SyscallError, - }, + errors::MapError, + sys::{bpf_get_object, bpf_map_get_fd_by_id, bpf_map_get_info_by_fd, iter_map_ids}, util::bytes_of_bpf_name, FEATURES, }; @@ -35,7 +34,7 @@ impl MapInfo { /// Uses kernel v4.13 features. pub fn from_id(id: u32) -> Result { bpf_map_get_fd_by_id(id) - .map_err(MapError::from) + .map_err(|e| e.into()) .and_then(|fd| Self::new_from_fd(fd.as_fd())) } @@ -121,10 +120,7 @@ impl MapInfo { // TODO: avoid this unwrap by adding a new error variant. let path_string = CString::new(path.as_ref().as_os_str().as_bytes()).unwrap(); - let fd = bpf_get_object(&path_string).map_err(|(_, io_error)| SyscallError { - call: "BPF_OBJ_GET", - io_error, - })?; + let fd = bpf_get_object(&path_string)?; Self::new_from_fd(fd.as_fd()) } diff --git a/aya/src/maps/lpm_trie.rs b/aya/src/maps/lpm_trie.rs index f7efd87fa..a6e89559e 100644 --- a/aya/src/maps/lpm_trie.rs +++ b/aya/src/maps/lpm_trie.rs @@ -6,8 +6,9 @@ use std::{ }; use crate::{ - maps::{check_kv_size, IterableMap, MapData, MapError, MapIter, MapKeys}, - sys::{bpf_map_delete_elem, bpf_map_lookup_elem, bpf_map_update_elem, SyscallError}, + errors::MapError, + maps::{check_kv_size, IterableMap, MapData, MapIter, MapKeys}, + sys::{bpf_map_delete_elem, bpf_map_lookup_elem, bpf_map_update_elem}, Pod, }; @@ -127,10 +128,7 @@ impl, K: Pod, V: Pod> LpmTrie { /// Returns a copy of the value associated with the longest prefix matching key in the LpmTrie. pub fn get(&self, key: &Key, flags: u64) -> Result { let fd = self.inner.borrow().fd().as_fd(); - let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })?; + let value = bpf_map_lookup_elem(fd, key, flags)?; value.ok_or(MapError::KeyNotFound) } @@ -156,12 +154,7 @@ impl, K: Pod, V: Pod> LpmTrie { flags: u64, ) -> Result<(), MapError> { let fd = self.inner.borrow().fd().as_fd(); - bpf_map_update_elem(fd, Some(key), value.borrow(), flags).map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_update_elem", - io_error, - } - })?; + bpf_map_update_elem(fd, Some(key), value.borrow(), flags)?; Ok(()) } @@ -171,15 +164,7 @@ impl, K: Pod, V: Pod> LpmTrie { /// Both the prefix and data must match exactly - this method does not do a longest prefix match. pub fn remove(&mut self, key: &Key) -> Result<(), MapError> { let fd = self.inner.borrow().fd().as_fd(); - bpf_map_delete_elem(fd, key) - .map(|_| ()) - .map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_delete_elem", - io_error, - } - .into() - }) + bpf_map_delete_elem(fd, key).map(|_| ()).map_err(Into::into) } } @@ -198,52 +183,79 @@ mod tests { use std::{io, net::Ipv4Addr}; use assert_matches::assert_matches; - use libc::{EFAULT, ENOENT}; + use libc::{EFAULT, EINVAL, ENOENT}; use super::*; use crate::{ - generated::{ - bpf_cmd, - bpf_map_type::{BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_LPM_TRIE}, - }, + errors::{InternalMapError, SysError}, + generated::bpf_map_type::{BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_LPM_TRIE}, maps::{ test_utils::{self, new_map}, Map, }, obj, - sys::{override_syscall, SysResult, Syscall}, + sys::{override_syscall, BpfCmd, SysResult, Syscall}, }; fn new_obj_map() -> obj::Map { test_utils::new_obj_map::>(BPF_MAP_TYPE_LPM_TRIE) } - fn sys_error(value: i32) -> SysResult { - Err((-1, io::Error::from_raw_os_error(value))) + fn sys_error(call: Syscall<'_>, value: i32) -> SysResult { + match call { + Syscall::Ebpf { .. } => Err(( + -1, + SysError::Syscall { + call: format!("{:?}", call), + io_error: io::Error::from_raw_os_error(value), + }, + )), + _ => Err(( + -1, + SysError::Syscall { + call: "UNEXPECTED!!!".to_string(), + io_error: io::Error::from_raw_os_error(EINVAL), + }, + )), + } } #[test] fn test_wrong_key_size() { let map = new_map(new_obj_map()); - assert_matches!( - LpmTrie::<_, u16, u32>::new(&map), - Err(MapError::InvalidKeySize { - size: 6, - expected: 8 // four bytes for prefixlen and four bytes for data. - }) - ); + let res = LpmTrie::<_, u16, u32>::new(&map); + assert!(res.is_err()); + let res = res.err().unwrap(); + if let MapError::Other(map_err) = res { + assert_matches!( + map_err.downcast_ref::().unwrap(), + InternalMapError::InvalidKeySize { + size: 2, + expected: 8 + } + ); + } else { + panic!("unexpected error: {:?}", res); + } } #[test] fn test_wrong_value_size() { let map = new_map(new_obj_map()); - assert_matches!( - LpmTrie::<_, u32, u16>::new(&map), - Err(MapError::InvalidValueSize { - size: 2, - expected: 4 - }) - ); + let res = LpmTrie::<_, u32, u16>::new(&map); + assert!(res.is_err()); + let res = res.err().unwrap(); + if let MapError::Other(map_err) = res { + assert_matches!( + map_err.downcast_ref::().unwrap(), + InternalMapError::InvalidValueSize { + size: 2, + expected: 4 + } + ); + } else { + panic!("unexpected error: {:?}", res); + } } #[test] @@ -280,12 +292,9 @@ mod tests { let ipaddr = Ipv4Addr::new(8, 8, 8, 8); let key = Key::new(16, u32::from(ipaddr).to_be()); - override_syscall(|_| sys_error(EFAULT)); + override_syscall(|c| sys_error(c, EFAULT)); - assert_matches!( - trie.insert(&key, 1, 0), - Err(MapError::SyscallError(SyscallError { call: "bpf_map_update_elem", io_error })) if io_error.raw_os_error() == Some(EFAULT) - ); + assert!(trie.insert(&key, 1, 0).is_err()); } #[test] @@ -297,10 +306,10 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_UPDATE_ELEM, + cmd: BpfCmd::MapUpdateElem, .. } => Ok(1), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); assert!(trie.insert(&key, 1, 0).is_ok()); @@ -313,12 +322,9 @@ mod tests { let ipaddr = Ipv4Addr::new(8, 8, 8, 8); let key = Key::new(16, u32::from(ipaddr).to_be()); - override_syscall(|_| sys_error(EFAULT)); + override_syscall(|c| sys_error(c, EFAULT)); - assert_matches!( - trie.remove(&key), - Err(MapError::SyscallError(SyscallError { call: "bpf_map_delete_elem", io_error })) if io_error.raw_os_error() == Some(EFAULT) - ); + assert!(trie.remove(&key).is_err()); } #[test] @@ -330,10 +336,10 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_DELETE_ELEM, + cmd: BpfCmd::MapDeleteElem, .. } => Ok(1), - _ => sys_error(EFAULT), + c => sys_error(c, EFAULT), }); assert!(trie.remove(&key).is_ok()); @@ -346,12 +352,9 @@ mod tests { let ipaddr = Ipv4Addr::new(8, 8, 8, 8); let key = Key::new(16, u32::from(ipaddr).to_be()); - override_syscall(|_| sys_error(EFAULT)); + override_syscall(|c| sys_error(c, EFAULT)); - assert_matches!( - trie.get(&key, 0), - Err(MapError::SyscallError(SyscallError { call: "bpf_map_lookup_elem", io_error })) if io_error.raw_os_error() == Some(EFAULT) - ); + assert!(trie.get(&key, 0).is_err()); } #[test] @@ -363,10 +366,10 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_LOOKUP_ELEM, + cmd: BpfCmd::MapLookupElem, .. - } => sys_error(ENOENT), - _ => sys_error(EFAULT), + } => sys_error(call, ENOENT), + c => sys_error(c, EFAULT), }); assert_matches!(trie.get(&key, 0), Err(MapError::KeyNotFound)); diff --git a/aya/src/maps/mod.rs b/aya/src/maps/mod.rs index 6f36b6b35..76093c475 100644 --- a/aya/src/maps/mod.rs +++ b/aya/src/maps/mod.rs @@ -59,17 +59,16 @@ use std::{ ptr, }; -use aya_obj::{generated::bpf_map_type, InvalidTypeBinding}; +use aya_obj::generated::bpf_map_type; use libc::{getrlimit, rlim_t, rlimit, RLIMIT_MEMLOCK, RLIM_INFINITY}; use log::warn; -use thiserror::Error; use crate::{ + errors::{InternalMapError, MapError, PinError}, obj::{self, parse_map_info, EbpfSectionKind}, - pin::PinError, sys::{ bpf_create_map, bpf_get_object, bpf_map_freeze, bpf_map_get_fd_by_id, bpf_map_get_next_key, - bpf_map_update_elem_ptr, bpf_pin_object, SyscallError, + bpf_map_update_elem_ptr, bpf_pin_object, }, util::{nr_cpus, KernelVersion}, PinningType, Pod, @@ -104,111 +103,6 @@ pub use stack::Stack; pub use stack_trace::StackTraceMap; pub use xdp::{CpuMap, DevMap, DevMapHash, XskMap}; -#[derive(Error, Debug)] -/// Errors occuring from working with Maps -pub enum MapError { - /// Invalid map type encontered - #[error("invalid map type {map_type}")] - InvalidMapType { - /// The map type - map_type: u32, - }, - - /// Invalid map name encountered - #[error("invalid map name `{name}`")] - InvalidName { - /// The map name - name: String, - }, - - /// Failed to create map - #[error("failed to create map `{name}` with code {code}")] - CreateError { - /// Map name - name: String, - /// Error code - code: i64, - #[source] - /// Original io::Error - io_error: io::Error, - }, - - /// Invalid key size - #[error("invalid key size {size}, expected {expected}")] - InvalidKeySize { - /// Size encountered - size: usize, - /// Size expected - expected: usize, - }, - - /// Invalid value size - #[error("invalid value size {size}, expected {expected}")] - InvalidValueSize { - /// Size encountered - size: usize, - /// Size expected - expected: usize, - }, - - /// Index is out of bounds - #[error("the index is {index} but `max_entries` is {max_entries}")] - OutOfBounds { - /// Index accessed - index: u32, - /// Map size - max_entries: u32, - }, - - /// Key not found - #[error("key not found")] - KeyNotFound, - - /// Element not found - #[error("element not found")] - ElementNotFound, - - /// Progam Not Loaded - #[error("the program is not loaded")] - ProgramNotLoaded, - - /// An IO error occurred - #[error(transparent)] - IoError(#[from] io::Error), - - /// Syscall failed - #[error(transparent)] - SyscallError(#[from] SyscallError), - - /// Could not pin map - #[error("map `{name:?}` requested pinning. pinning failed")] - PinError { - /// The map name - name: Option, - /// The reason for the failure - #[source] - error: PinError, - }, - - /// Program IDs are not supported - #[error("program ids are not supported by the current kernel")] - ProgIdNotSupported, - - /// Unsupported Map type - #[error("Unsupported map type found {map_type}")] - Unsupported { - /// The map type - map_type: u32, - }, -} - -impl From> for MapError { - fn from(e: InvalidTypeBinding) -> Self { - let InvalidTypeBinding { value } = e; - Self::InvalidMapType { map_type: value } - } -} - /// A map file descriptor. #[derive(Debug)] pub struct MapFd { @@ -347,7 +241,7 @@ impl Map { /// /// When a map is pinned it will remain loaded until the corresponding file /// is deleted. All parent directories in the given `path` must already exist. - pub fn pin>(&self, path: P) -> Result<(), PinError> { + pub fn pin>(&self, path: P) -> Result<(), MapError> { match self { Self::Array(map) => map.pin(path), Self::BloomFilter(map) => map.pin(path), @@ -391,7 +285,7 @@ macro_rules! impl_map_pin { /// /// When a map is pinned it will remain loaded until the corresponding file /// is deleted. All parent directories in the given `path` must already exist. - pub fn pin>(self, path: P) -> Result<(), PinError> { + pub fn pin>(self, path: P) -> Result<(), MapError> { let data = self.inner.borrow(); data.pin(path) } @@ -516,25 +410,25 @@ pub(crate) fn check_bounds(map: &MapData, index: u32) -> Result<(), MapError> { } } -pub(crate) fn check_kv_size(map: &MapData) -> Result<(), MapError> { +pub(crate) fn check_kv_size(map: &MapData) -> Result<(), InternalMapError> { let size = mem::size_of::(); let expected = map.obj.key_size() as usize; if size != expected { - return Err(MapError::InvalidKeySize { size, expected }); + return Err(InternalMapError::InvalidKeySize { size, expected }); } let size = mem::size_of::(); let expected = map.obj.value_size() as usize; if size != expected { - return Err(MapError::InvalidValueSize { size, expected }); + return Err(InternalMapError::InvalidValueSize { size, expected }); }; Ok(()) } -pub(crate) fn check_v_size(map: &MapData) -> Result<(), MapError> { +pub(crate) fn check_v_size(map: &MapData) -> Result<(), InternalMapError> { let size = mem::size_of::(); let expected = map.obj.value_size() as usize; if size != expected { - return Err(MapError::InvalidValueSize { size, expected }); + return Err(InternalMapError::InvalidValueSize { size, expected }); }; Ok(()) } @@ -555,7 +449,8 @@ impl MapData { name: &str, btf_fd: Option>, ) -> Result { - let c_name = CString::new(name).map_err(|_| MapError::InvalidName { name: name.into() })?; + let c_name = + CString::new(name).map_err(|_| InternalMapError::InvalidName { name: name.into() })?; // BPF_MAP_TYPE_PERF_EVENT_ARRAY's max_entries should not exceed the number of // CPUs. @@ -569,7 +464,7 @@ impl MapData { // // Otherwise, when the value is `0` or too large, we set it to the number of CPUs. if obj.map_type() == bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY as u32 { - let nr_cpus = nr_cpus().map_err(|(_, error)| MapError::IoError(error))? as u32; + let nr_cpus = nr_cpus().map_err(|(_, error)| InternalMapError::IoError(error))? as u32; if obj.max_entries() == 0 || obj.max_entries() > nr_cpus { obj.set_max_entries(nr_cpus); } @@ -580,15 +475,14 @@ impl MapData { #[cfg(test)] let kernel_version = KernelVersion::new(0xff, 0xff, 0xff); let fd = - bpf_create_map(&c_name, &obj, btf_fd, kernel_version).map_err(|(code, io_error)| { + bpf_create_map(&c_name, &obj, btf_fd, kernel_version).map_err(|(code, source)| { if kernel_version < KernelVersion::new(5, 11, 0) { maybe_warn_rlimit(); } - - MapError::CreateError { + InternalMapError::CreateError { name: name.into(), code, - io_error, + source, } })?; Ok(Self { @@ -610,26 +504,17 @@ impl MapData { let path_string = match CString::new(path.as_os_str().as_bytes()) { Ok(path) => path, Err(error) => { - return Err(MapError::PinError { - name: Some(name.into()), - error: PinError::InvalidPinPath { path, error }, - }); + return Err(PinError::InvalidPinPath { path, error }.into()); } }; - match bpf_get_object(&path_string).map_err(|(_, io_error)| SyscallError { - call: "BPF_OBJ_GET", - io_error, - }) { + match bpf_get_object(&path_string) { Ok(fd) => Ok(Self { obj, fd: MapFd::from_fd(fd), }), Err(_) => { let map = Self::create(obj, name, btf_fd)?; - map.pin(&path).map_err(|error| MapError::PinError { - name: Some(name.into()), - error, - })?; + map.pin(&path)?; Ok(map) } } @@ -638,20 +523,10 @@ impl MapData { pub(crate) fn finalize(&mut self) -> Result<(), MapError> { let Self { obj, fd } = self; if !obj.data().is_empty() && obj.section_kind() != EbpfSectionKind::Bss { - bpf_map_update_elem_ptr(fd.as_fd(), &0 as *const _, obj.data_mut().as_mut_ptr(), 0) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_map_update_elem", - io_error, - }) - .map_err(MapError::from)?; + bpf_map_update_elem_ptr(fd.as_fd(), &0 as *const _, obj.data_mut().as_mut_ptr(), 0)?; } if obj.section_kind() == EbpfSectionKind::Rodata { - bpf_map_freeze(fd.as_fd()) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_map_freeze", - io_error, - }) - .map_err(MapError::from)?; + bpf_map_freeze(fd.as_fd())?; } Ok(()) } @@ -661,19 +536,8 @@ impl MapData { use std::os::unix::ffi::OsStrExt as _; let path = path.as_ref(); - let path_string = - CString::new(path.as_os_str().as_bytes()).map_err(|error| MapError::PinError { - name: None, - error: PinError::InvalidPinPath { - path: path.into(), - error, - }, - })?; - - let fd = bpf_get_object(&path_string).map_err(|(_, io_error)| SyscallError { - call: "BPF_OBJ_GET", - io_error, - })?; + let path_string = CString::new(path.as_os_str().as_bytes())?; + let fd = bpf_get_object(&path_string)?; Self::from_fd_inner(fd) } @@ -726,21 +590,13 @@ impl MapData { /// /// # Ok::<(), Box>(()) /// ``` - pub fn pin>(&self, path: P) -> Result<(), PinError> { + pub fn pin>(&self, path: P) -> Result<(), MapError> { use std::os::unix::ffi::OsStrExt as _; let Self { fd, obj: _ } = self; let path = path.as_ref(); - let path_string = CString::new(path.as_os_str().as_bytes()).map_err(|error| { - PinError::InvalidPinPath { - path: path.to_path_buf(), - error, - } - })?; - bpf_pin_object(fd.as_fd(), &path_string).map_err(|(_, io_error)| SyscallError { - call: "BPF_OBJ_PIN", - io_error, - })?; + let path_string = CString::new(path.as_os_str().as_bytes())?; + bpf_pin_object(fd.as_fd(), &path_string)?; Ok(()) } @@ -796,11 +652,7 @@ impl Iterator for MapKeys<'_, K> { } let fd = self.map.fd().as_fd(); - let key = - bpf_map_get_next_key(fd, self.key.as_ref()).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_get_next_key", - io_error, - }); + let key = bpf_map_get_next_key(fd, self.key.as_ref()); match key { Err(err) => { self.err = true; @@ -953,16 +805,16 @@ impl Deref for PerCpuValues { mod test_utils { use crate::{ bpf_map_def, - generated::{bpf_cmd, bpf_map_type}, + generated::bpf_map_type, maps::MapData, obj::{self, maps::LegacyMap, EbpfSectionKind}, - sys::{override_syscall, Syscall}, + sys::{override_syscall, BpfCmd, Syscall}, }; pub(super) fn new_map(obj: obj::Map) -> MapData { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_CREATE, + cmd: BpfCmd::MapCreate, .. } => Ok(crate::MockableFd::mock_signed_fd().into()), call => panic!("unexpected syscall {:?}", call), @@ -1019,15 +871,15 @@ mod tests { use super::*; use crate::{ - generated::bpf_cmd, - sys::{override_syscall, Syscall}, + errors::SysError, + sys::{override_syscall, BpfCmd, Syscall}, }; #[test] fn test_from_map_id() { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_FD_BY_ID, + cmd: BpfCmd::MapGetFdById, attr, } => { assert_eq!( @@ -1037,7 +889,7 @@ mod tests { Ok(crate::MockableFd::mock_signed_fd().into()) } Syscall::Ebpf { - cmd: bpf_cmd::BPF_OBJ_GET_INFO_BY_FD, + cmd: BpfCmd::ObjGetInfoByFd, attr, } => { assert_eq!( @@ -1046,7 +898,13 @@ mod tests { ); Ok(0) } - _ => Err((-1, io::Error::from_raw_os_error(EFAULT))), + _ => Err(( + -1, + SysError::Syscall { + call: "unexpected".to_string(), + io_error: io::Error::from_raw_os_error(EFAULT), + }, + )), }); assert_matches!( @@ -1062,10 +920,16 @@ mod tests { fn test_create() { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_CREATE, + cmd: BpfCmd::MapCreate, .. } => Ok(crate::MockableFd::mock_signed_fd().into()), - _ => Err((-1, io::Error::from_raw_os_error(EFAULT))), + _ => Err(( + -1, + SysError::Syscall { + call: "unexpected".to_string(), + io_error: io::Error::from_raw_os_error(EFAULT), + }, + )), }); assert_matches!( @@ -1082,10 +946,16 @@ mod tests { fn test_create_perf_event_array() { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_CREATE, + cmd: BpfCmd::MapCreate, .. } => Ok(crate::MockableFd::mock_signed_fd().into()), - _ => Err((-1, io::Error::from_raw_os_error(EFAULT))), + _ => Err(( + -1, + SysError::Syscall { + call: "unexpected".to_string(), + io_error: io::Error::from_raw_os_error(EFAULT), + }, + )), }); let nr_cpus = nr_cpus().unwrap(); @@ -1148,11 +1018,11 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_CREATE, + cmd: BpfCmd::MapCreate, .. } => Ok(crate::MockableFd::mock_signed_fd().into()), Syscall::Ebpf { - cmd: bpf_cmd::BPF_OBJ_GET_INFO_BY_FD, + cmd: BpfCmd::ObjGetInfoByFd, attr, } => { assert_eq!( @@ -1165,7 +1035,13 @@ mod tests { }); Ok(0) } - _ => Err((-1, io::Error::from_raw_os_error(EFAULT))), + _ => Err(( + -1, + SysError::Syscall { + call: "unexpected".to_string(), + io_error: io::Error::from_raw_os_error(EFAULT), + }, + )), }); let map_data = MapData::create(new_obj_map(), TEST_NAME, None).unwrap(); @@ -1182,7 +1058,7 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_NEXT_ID, + cmd: BpfCmd::MapGetNextId, attr, } => unsafe { let id = attr.__bindgen_anon_6.__bindgen_anon_1.start_id; @@ -1190,17 +1066,23 @@ mod tests { attr.__bindgen_anon_6.next_id = id + 1; Ok(0) } else { - Err((-1, io::Error::from_raw_os_error(libc::ENOENT))) + Err(( + -1, + SysError::Syscall { + call: "unexpected".to_string(), + io_error: io::Error::from_raw_os_error(EFAULT), + }, + )) } }, Syscall::Ebpf { - cmd: bpf_cmd::BPF_MAP_GET_FD_BY_ID, + cmd: BpfCmd::MapGetFdById, attr, } => Ok((unsafe { attr.__bindgen_anon_6.__bindgen_anon_1.map_id } + crate::MockableFd::mock_unsigned_fd()) .into()), Syscall::Ebpf { - cmd: bpf_cmd::BPF_OBJ_GET_INFO_BY_FD, + cmd: BpfCmd::ObjGetInfoByFd, attr, } => { let map_info = unsafe { &mut *(attr.info.info as *mut bpf_map_info) }; @@ -1211,7 +1093,13 @@ mod tests { map_info.max_entries = 99; Ok(0) } - _ => Err((-1, io::Error::from_raw_os_error(EFAULT))), + _ => Err(( + -1, + SysError::Syscall { + call: "unexpected".to_string(), + io_error: io::Error::from_raw_os_error(EFAULT), + }, + )), }); assert_eq!( @@ -1243,15 +1131,34 @@ mod tests { #[test] fn test_create_failed() { - override_syscall(|_| Err((-42, io::Error::from_raw_os_error(EFAULT)))); + override_syscall(|_| { + Err(( + -42, + SysError::Syscall { + call: "unexpected".to_string(), + io_error: io::Error::from_raw_os_error(EFAULT), + }, + )) + }); - assert_matches!( - MapData::create(new_obj_map(), "foo", None), - Err(MapError::CreateError { name, code, io_error }) => { - assert_eq!(name, "foo"); - assert_eq!(code, -42); - assert_eq!(io_error.raw_os_error(), Some(EFAULT)); - } - ); + let res = MapData::create(new_obj_map(), "foo", None); + assert!(res.is_err()); + let res = res.unwrap_err(); + if let MapError::Other(e) = res { + assert_matches!( + e.downcast_ref::().unwrap(), + InternalMapError::CreateError { name, code, source} => { + assert_eq!(name, "foo"); + assert_eq!(*code, -42); + if let SysError::Syscall { call: _, io_error } = source { + assert_eq!(io_error.raw_os_error(), Some(EFAULT)); + } else { + panic!("unexpected source: {:?}", source); + } + } + ); + } else { + panic!("unexpected error: {:?}", res); + } } } diff --git a/aya/src/maps/perf/async_perf_event_array.rs b/aya/src/maps/perf/async_perf_event_array.rs index 6fcfcdf25..f5b5cdc66 100644 --- a/aya/src/maps/perf/async_perf_event_array.rs +++ b/aya/src/maps/perf/async_perf_event_array.rs @@ -13,9 +13,12 @@ use bytes::BytesMut; #[cfg(feature = "async_tokio")] use tokio::io::unix::AsyncFd; -use crate::maps::{ - perf::{Events, PerfBufferError, PerfEventArray, PerfEventArrayBuffer}, - MapData, MapError, PinError, +use crate::{ + errors::{MapError, PerfBufferError}, + maps::{ + perf::{Events, PerfEventArray, PerfEventArrayBuffer}, + MapData, + }, }; /// A `Future` based map that can be used to receive events from eBPF programs using the linux @@ -113,7 +116,7 @@ impl> AsyncPerfEventArray { /// /// When a map is pinned it will remain loaded until the corresponding file /// is deleted. All parent directories in the given `path` must already exist. - pub fn pin>(&self, path: P) -> Result<(), PinError> { + pub fn pin>(&self, path: P) -> Result<(), MapError> { self.perf_map.pin(path) } } diff --git a/aya/src/maps/perf/perf_buffer.rs b/aya/src/maps/perf/perf_buffer.rs index 79b799ee4..b69aaa2fb 100644 --- a/aya/src/maps/perf/perf_buffer.rs +++ b/aya/src/maps/perf/perf_buffer.rs @@ -8,9 +8,9 @@ use std::{ use bytes::BytesMut; use libc::{munmap, MAP_FAILED, MAP_SHARED, PROT_READ, PROT_WRITE}; -use thiserror::Error; use crate::{ + errors::PerfBufferError, generated::{ perf_event_header, perf_event_mmap_page, perf_event_type::{PERF_RECORD_LOST, PERF_RECORD_SAMPLE}, @@ -19,61 +19,6 @@ use crate::{ PERF_EVENT_IOC_DISABLE, PERF_EVENT_IOC_ENABLE, }; -/// Perf buffer error. -#[derive(Error, Debug)] -pub enum PerfBufferError { - /// the page count value passed to [`PerfEventArray::open`](crate::maps::PerfEventArray::open) is invalid. - #[error("invalid page count {page_count}, the value must be a power of two")] - InvalidPageCount { - /// the page count - page_count: usize, - }, - - /// `perf_event_open` failed. - #[error("perf_event_open failed: {io_error}")] - OpenError { - /// the source of this error - #[source] - io_error: io::Error, - }, - - /// `mmap`-ping the buffer failed. - #[error("mmap failed: {io_error}")] - MMapError { - /// the source of this error - #[source] - io_error: io::Error, - }, - - /// The `PERF_EVENT_IOC_ENABLE` ioctl failed - #[error("PERF_EVENT_IOC_ENABLE failed: {io_error}")] - PerfEventEnableError { - #[source] - /// the source of this error - io_error: io::Error, - }, - - /// `read_events()` was called with no output buffers. - #[error("read_events() was called with no output buffers")] - NoBuffers, - - /// `read_events()` was called with a buffer that is not large enough to - /// contain the next event in the perf buffer. - #[deprecated( - since = "0.10.8", - note = "read_events() now calls BytesMut::reserve() internally, so this error is never returned" - )] - #[error("the buffer needs to be of at least {size} bytes")] - MoreSpaceNeeded { - /// expected size - size: usize, - }, - - /// An IO error occurred. - #[error(transparent)] - IOError(#[from] io::Error), -} - /// Return type of `read_events()`. #[derive(Debug, PartialEq, Eq)] pub struct Events { @@ -101,8 +46,7 @@ impl PerfBuffer { return Err(PerfBufferError::InvalidPageCount { page_count }); } - let fd = perf_event_open_bpf(cpu_id as i32) - .map_err(|(_, io_error)| PerfBufferError::OpenError { io_error })?; + let fd = perf_event_open_bpf(cpu_id as i32)?; let size = page_size * page_count; let buf = unsafe { mmap( @@ -127,8 +71,7 @@ impl PerfBuffer { fd, }; - perf_event_ioctl(perf_buf.fd.as_fd(), PERF_EVENT_IOC_ENABLE, 0) - .map_err(|(_, io_error)| PerfBufferError::PerfEventEnableError { io_error })?; + perf_event_ioctl(perf_buf.fd.as_fd(), PERF_EVENT_IOC_ENABLE, 0)?; Ok(perf_buf) } diff --git a/aya/src/maps/perf/perf_event_array.rs b/aya/src/maps/perf/perf_event_array.rs index 47e37e95f..d3e1bed87 100644 --- a/aya/src/maps/perf/perf_event_array.rs +++ b/aya/src/maps/perf/perf_event_array.rs @@ -12,9 +12,10 @@ use std::{ use bytes::BytesMut; use crate::{ + errors::{MapError, PerfBufferError}, maps::{ - perf::{Events, PerfBuffer, PerfBufferError}, - MapData, MapError, PinError, + perf::{Events, PerfBuffer}, + MapData, }, sys::bpf_map_update_elem, util::page_size, @@ -179,7 +180,7 @@ impl> PerfEventArray { /// /// When a map is pinned it will remain loaded until the corresponding file /// is deleted. All parent directories in the given `path` must already exist. - pub fn pin>(&self, path: P) -> Result<(), PinError> { + pub fn pin>(&self, path: P) -> Result<(), MapError> { let data: &MapData = self.map.deref().borrow(); data.pin(path) } @@ -199,8 +200,7 @@ impl> PerfEventArray { let map_data: &MapData = self.map.deref().borrow(); let map_fd = map_data.fd().as_fd(); let buf = PerfBuffer::open(index, self.page_size, page_count.unwrap_or(2))?; - bpf_map_update_elem(map_fd, Some(&index), &buf.as_fd().as_raw_fd(), 0) - .map_err(|(_, io_error)| io_error)?; + bpf_map_update_elem(map_fd, Some(&index), &buf.as_fd().as_raw_fd(), 0)?; Ok(PerfEventArrayBuffer { buf, diff --git a/aya/src/maps/queue.rs b/aya/src/maps/queue.rs index 9c3425255..59d50d818 100644 --- a/aya/src/maps/queue.rs +++ b/aya/src/maps/queue.rs @@ -7,7 +7,7 @@ use std::{ use crate::{ maps::{check_kv_size, MapData, MapError}, - sys::{bpf_map_lookup_and_delete_elem, bpf_map_push_elem, SyscallError}, + sys::{bpf_map_lookup_and_delete_elem, bpf_map_push_elem}, Pod, }; @@ -63,12 +63,7 @@ impl, V: Pod> Queue { pub fn pop(&mut self, flags: u64) -> Result { let fd = self.inner.borrow().fd().as_fd(); - let value = bpf_map_lookup_and_delete_elem::(fd, None, flags).map_err( - |(_, io_error)| SyscallError { - call: "bpf_map_lookup_and_delete_elem", - io_error, - }, - )?; + let value = bpf_map_lookup_and_delete_elem::(fd, None, flags)?; value.ok_or(MapError::ElementNotFound) } @@ -79,10 +74,7 @@ impl, V: Pod> Queue { /// [`MapError::SyscallError`] if `bpf_map_update_elem` fails. pub fn push(&mut self, value: impl Borrow, flags: u64) -> Result<(), MapError> { let fd = self.inner.borrow().fd().as_fd(); - bpf_map_push_elem(fd, value.borrow(), flags).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_push_elem", - io_error, - })?; + bpf_map_push_elem(fd, value.borrow(), flags)?; Ok(()) } } diff --git a/aya/src/maps/ring_buf.rs b/aya/src/maps/ring_buf.rs index f6fc93774..26668cf87 100644 --- a/aya/src/maps/ring_buf.rs +++ b/aya/src/maps/ring_buf.rs @@ -20,9 +20,10 @@ use std::{ use libc::{munmap, off_t, MAP_FAILED, MAP_SHARED, PROT_READ, PROT_WRITE}; use crate::{ + errors::SysError, generated::{BPF_RINGBUF_BUSY_BIT, BPF_RINGBUF_DISCARD_BIT, BPF_RINGBUF_HDR_SZ}, maps::{MapData, MapError}, - sys::{mmap, SyscallError}, + sys::mmap, util::page_size, }; @@ -426,21 +427,21 @@ impl MMap { offset: off_t, ) -> Result { match unsafe { mmap(ptr::null_mut(), len, prot, flags, fd, offset) } { - MAP_FAILED => Err(MapError::SyscallError(SyscallError { - call: "mmap", + MAP_FAILED => Err(SysError::Mmap { io_error: io::Error::last_os_error(), - })), + } + .into()), ptr => Ok(Self { - ptr: NonNull::new(ptr).ok_or( + ptr: NonNull::new(ptr).ok_or::( // This should never happen, but to be paranoid, and so we never need to talk // about a null pointer, we check it anyway. - MapError::SyscallError(SyscallError { - call: "mmap", + SysError::Mmap { io_error: io::Error::new( io::ErrorKind::Other, "mmap returned null pointer", ), - }), + } + .into(), )?, len, }), diff --git a/aya/src/maps/sock/sock_hash.rs b/aya/src/maps/sock/sock_hash.rs index 9be05ee4b..9e5793d6f 100644 --- a/aya/src/maps/sock/sock_hash.rs +++ b/aya/src/maps/sock/sock_hash.rs @@ -5,11 +5,11 @@ use std::{ }; use crate::{ + errors::MapError, maps::{ - check_kv_size, hash_map, sock::SockMapFd, IterableMap, MapData, MapError, MapFd, MapIter, - MapKeys, + check_kv_size, hash_map, sock::SockMapFd, IterableMap, MapData, MapFd, MapIter, MapKeys, }, - sys::{bpf_map_lookup_elem, SyscallError}, + sys::bpf_map_lookup_elem, Pod, }; @@ -83,10 +83,7 @@ impl, K: Pod> SockHash { /// Returns the fd of the socket stored at the given key. pub fn get(&self, key: &K, flags: u64) -> Result { let fd = self.inner.borrow().fd().as_fd(); - let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })?; + let value = bpf_map_lookup_elem(fd, key, flags)?; value.ok_or(MapError::KeyNotFound) } diff --git a/aya/src/maps/sock/sock_map.rs b/aya/src/maps/sock/sock_map.rs index f0590467e..a6810ea30 100644 --- a/aya/src/maps/sock/sock_map.rs +++ b/aya/src/maps/sock/sock_map.rs @@ -6,8 +6,9 @@ use std::{ }; use crate::{ - maps::{check_bounds, check_kv_size, sock::SockMapFd, MapData, MapError, MapFd, MapKeys}, - sys::{bpf_map_delete_elem, bpf_map_update_elem, SyscallError}, + errors::MapError, + maps::{check_bounds, check_kv_size, sock::SockMapFd, MapData, MapFd, MapKeys}, + sys::{bpf_map_delete_elem, bpf_map_update_elem}, }; /// An array of TCP or UDP sockets. @@ -87,12 +88,7 @@ impl> SockMap { let data = self.inner.borrow_mut(); let fd = data.fd().as_fd(); check_bounds(data, index)?; - bpf_map_update_elem(fd, Some(&index), &socket.as_raw_fd(), flags).map_err( - |(_, io_error)| SyscallError { - call: "bpf_map_update_elem", - io_error, - }, - )?; + bpf_map_update_elem(fd, Some(&index), &socket.as_raw_fd(), flags)?; Ok(()) } @@ -103,12 +99,6 @@ impl> SockMap { check_bounds(data, *index)?; bpf_map_delete_elem(fd, index) .map(|_| ()) - .map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_delete_elem", - io_error, - } - .into() - }) + .map_err(Into::into) } } diff --git a/aya/src/maps/stack.rs b/aya/src/maps/stack.rs index 8a7b94bd9..61496fa96 100644 --- a/aya/src/maps/stack.rs +++ b/aya/src/maps/stack.rs @@ -7,7 +7,7 @@ use std::{ use crate::{ maps::{check_kv_size, MapData, MapError}, - sys::{bpf_map_lookup_and_delete_elem, bpf_map_update_elem, SyscallError}, + sys::{bpf_map_lookup_and_delete_elem, bpf_map_update_elem}, Pod, }; @@ -63,12 +63,7 @@ impl, V: Pod> Stack { pub fn pop(&mut self, flags: u64) -> Result { let fd = self.inner.borrow().fd().as_fd(); - let value = bpf_map_lookup_and_delete_elem::(fd, None, flags).map_err( - |(_, io_error)| SyscallError { - call: "bpf_map_lookup_and_delete_elem", - io_error, - }, - )?; + let value = bpf_map_lookup_and_delete_elem::(fd, None, flags)?; value.ok_or(MapError::ElementNotFound) } @@ -79,12 +74,7 @@ impl, V: Pod> Stack { /// [`MapError::SyscallError`] if `bpf_map_update_elem` fails. pub fn push(&mut self, value: impl Borrow, flags: u64) -> Result<(), MapError> { let fd = self.inner.borrow().fd().as_fd(); - bpf_map_update_elem(fd, None::<&u32>, value.borrow(), flags).map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_update_elem", - io_error, - } - })?; + bpf_map_update_elem(fd, None::<&u32>, value.borrow(), flags)?; Ok(()) } } diff --git a/aya/src/maps/stack_trace.rs b/aya/src/maps/stack_trace.rs index 74b85b660..48bfc2d2f 100644 --- a/aya/src/maps/stack_trace.rs +++ b/aya/src/maps/stack_trace.rs @@ -10,8 +10,9 @@ use std::{ }; use crate::{ - maps::{IterableMap, MapData, MapError, MapIter, MapKeys}, - sys::{bpf_map_delete_elem, bpf_map_lookup_elem_ptr, SyscallError}, + errors::{InternalMapError, MapError}, + maps::{IterableMap, MapData, MapIter, MapKeys}, + sys::{bpf_map_delete_elem, bpf_map_lookup_elem_ptr}, }; /// A hash map of kernel or user space stack traces. @@ -83,17 +84,13 @@ impl> StackTraceMap { let expected = mem::size_of::(); let size = data.obj.key_size() as usize; if size != expected { - return Err(MapError::InvalidKeySize { size, expected }); + return Err(InternalMapError::InvalidKeySize { size, expected }.into()); } - let max_stack_depth = - sysctl::("kernel/perf_event_max_stack").map_err(|io_error| SyscallError { - call: "sysctl", - io_error, - })?; + let max_stack_depth = sysctl::("kernel/perf_event_max_stack")?; let size = data.obj.value_size() as usize; if size > max_stack_depth * mem::size_of::() { - return Err(MapError::InvalidValueSize { size, expected }); + return Err(InternalMapError::InvalidValueSize { size, expected }.into()); } Ok(Self { @@ -112,11 +109,7 @@ impl> StackTraceMap { let fd = self.inner.borrow().fd().as_fd(); let mut frames = vec![0; self.max_stack_depth]; - bpf_map_lookup_elem_ptr(fd, Some(stack_id), frames.as_mut_ptr(), flags) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })? + bpf_map_lookup_elem_ptr(fd, Some(stack_id), frames.as_mut_ptr(), flags)? .ok_or(MapError::KeyNotFound)?; let frames = frames @@ -169,13 +162,7 @@ impl> StackTraceMap { let fd = self.inner.borrow().fd().as_fd(); bpf_map_delete_elem(fd, stack_id) .map(|_| ()) - .map_err(|(_, io_error)| { - SyscallError { - call: "bpf_map_delete_elem", - io_error, - } - .into() - }) + .map_err(Into::into) } } diff --git a/aya/src/maps/xdp/cpu_map.rs b/aya/src/maps/xdp/cpu_map.rs index 7777fc229..f52d6c09b 100644 --- a/aya/src/maps/xdp/cpu_map.rs +++ b/aya/src/maps/xdp/cpu_map.rs @@ -8,11 +8,10 @@ use std::{ use aya_obj::generated::bpf_cpumap_val; -use super::XdpMapError; use crate::{ maps::{check_bounds, check_kv_size, IterableMap, MapData, MapError}, programs::ProgramFd, - sys::{bpf_map_lookup_elem, bpf_map_update_elem, SyscallError}, + sys::{bpf_map_lookup_elem, bpf_map_update_elem}, Pod, FEATURES, }; @@ -102,12 +101,7 @@ impl> CpuMap { }) }) }; - value - .map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })? - .ok_or(MapError::KeyNotFound) + value?.ok_or(MapError::KeyNotFound) } /// An iterator over the elements of the map. @@ -142,7 +136,7 @@ impl> CpuMap { queue_size: u32, program: Option<&ProgramFd>, flags: u64, - ) -> Result<(), XdpMapError> { + ) -> Result<(), MapError> { let data = self.inner.borrow_mut(); check_bounds(data, cpu_index)?; let fd = data.fd().as_fd(); @@ -158,17 +152,12 @@ impl> CpuMap { bpf_map_update_elem(fd, Some(&cpu_index), &value, flags) } else { if program.is_some() { - return Err(XdpMapError::ChainedProgramNotSupported); + return Err(MapError::ChainedProgramNotSupported); } bpf_map_update_elem(fd, Some(&cpu_index), &queue_size, flags) }; - res.map_err(|(_, io_error)| { - MapError::from(SyscallError { - call: "bpf_map_update_elem", - io_error, - }) - })?; + res?; Ok(()) } } diff --git a/aya/src/maps/xdp/dev_map.rs b/aya/src/maps/xdp/dev_map.rs index 44062df55..bf5fe41ba 100644 --- a/aya/src/maps/xdp/dev_map.rs +++ b/aya/src/maps/xdp/dev_map.rs @@ -8,11 +8,11 @@ use std::{ use aya_obj::generated::bpf_devmap_val; -use super::XdpMapError; use crate::{ - maps::{check_bounds, check_kv_size, IterableMap, MapData, MapError}, + errors::MapError, + maps::{check_bounds, check_kv_size, IterableMap, MapData}, programs::ProgramFd, - sys::{bpf_map_lookup_elem, bpf_map_update_elem, SyscallError}, + sys::{bpf_map_lookup_elem, bpf_map_update_elem}, Pod, FEATURES, }; @@ -93,12 +93,7 @@ impl> DevMap { }) }) }; - value - .map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })? - .ok_or(MapError::KeyNotFound) + value?.ok_or(MapError::KeyNotFound) } /// An iterator over the elements of the array. @@ -124,7 +119,7 @@ impl> DevMap { /// # Errors /// /// Returns [`MapError::OutOfBounds`] if `index` is out of bounds, [`MapError::SyscallError`] - /// if `bpf_map_update_elem` fails, [`MapError::ProgIdNotSupported`] if the kernel does not + /// if `bpf_map_update_elem` fails, [`MapError::ChainedProgramsNotSupported`] if the kernel does not /// support chained programs and one is provided. pub fn set( &mut self, @@ -132,7 +127,7 @@ impl> DevMap { target_if_index: u32, program: Option<&ProgramFd>, flags: u64, - ) -> Result<(), XdpMapError> { + ) -> Result<(), MapError> { let data = self.inner.borrow_mut(); check_bounds(data, index)?; let fd = data.fd().as_fd(); @@ -149,17 +144,12 @@ impl> DevMap { bpf_map_update_elem(fd, Some(&index), &value, flags) } else { if program.is_some() { - return Err(XdpMapError::ChainedProgramNotSupported); + return Err(MapError::ChainedProgramNotSupported); } bpf_map_update_elem(fd, Some(&index), &target_if_index, flags) }; - res.map_err(|(_, io_error)| { - MapError::from(SyscallError { - call: "bpf_map_update_elem", - io_error, - }) - })?; + res?; Ok(()) } } diff --git a/aya/src/maps/xdp/dev_map_hash.rs b/aya/src/maps/xdp/dev_map_hash.rs index 1b941bc4d..a5cc3206b 100644 --- a/aya/src/maps/xdp/dev_map_hash.rs +++ b/aya/src/maps/xdp/dev_map_hash.rs @@ -8,11 +8,13 @@ use std::{ use aya_obj::generated::bpf_devmap_val; -use super::{dev_map::DevMapValue, XdpMapError}; use crate::{ - maps::{check_kv_size, hash_map, IterableMap, MapData, MapError, MapIter, MapKeys}, + errors::MapError, + maps::{ + check_kv_size, hash_map, xdp::dev_map::DevMapValue, IterableMap, MapData, MapIter, MapKeys, + }, programs::ProgramFd, - sys::{bpf_map_lookup_elem, SyscallError}, + sys::bpf_map_lookup_elem, FEATURES, }; @@ -83,12 +85,7 @@ impl> DevMapHash { }) }) }; - value - .map_err(|(_, io_error)| SyscallError { - call: "bpf_map_lookup_elem", - io_error, - })? - .ok_or(MapError::KeyNotFound) + value?.ok_or(MapError::KeyNotFound) } /// An iterator over the elements of the devmap in arbitrary order. @@ -126,7 +123,7 @@ impl> DevMapHash { target_if_index: u32, program: Option<&ProgramFd>, flags: u64, - ) -> Result<(), XdpMapError> { + ) -> Result<(), MapError> { if FEATURES.devmap_prog_id() { let mut value = unsafe { std::mem::zeroed::() }; value.ifindex = target_if_index; @@ -139,7 +136,7 @@ impl> DevMapHash { hash_map::insert(self.inner.borrow_mut(), &key, &value, flags)?; } else { if program.is_some() { - return Err(XdpMapError::ChainedProgramNotSupported); + return Err(MapError::ChainedProgramNotSupported); } hash_map::insert(self.inner.borrow_mut(), &key, &target_if_index, flags)?; } diff --git a/aya/src/maps/xdp/mod.rs b/aya/src/maps/xdp/mod.rs index 2f00492c5..6120dc909 100644 --- a/aya/src/maps/xdp/mod.rs +++ b/aya/src/maps/xdp/mod.rs @@ -7,19 +7,4 @@ mod xsk_map; pub use cpu_map::CpuMap; pub use dev_map::DevMap; pub use dev_map_hash::DevMapHash; -use thiserror::Error; pub use xsk_map::XskMap; - -use super::MapError; - -#[derive(Error, Debug)] -/// Errors occuring from working with XDP maps. -pub enum XdpMapError { - /// Chained programs are not supported. - #[error("chained programs are not supported by the current kernel")] - ChainedProgramNotSupported, - - /// Map operation failed. - #[error(transparent)] - MapError(#[from] MapError), -} diff --git a/aya/src/maps/xdp/xsk_map.rs b/aya/src/maps/xdp/xsk_map.rs index 95c593cc3..60e75228b 100644 --- a/aya/src/maps/xdp/xsk_map.rs +++ b/aya/src/maps/xdp/xsk_map.rs @@ -7,7 +7,7 @@ use std::{ use crate::{ maps::{check_bounds, check_kv_size, MapData, MapError}, - sys::{bpf_map_update_elem, SyscallError}, + sys::bpf_map_update_elem, }; /// An array of AF_XDP sockets. @@ -70,12 +70,7 @@ impl> XskMap { let data = self.inner.borrow_mut(); check_bounds(data, index)?; let fd = data.fd().as_fd(); - bpf_map_update_elem(fd, Some(&index), &socket_fd.as_raw_fd(), flags).map_err( - |(_, io_error)| SyscallError { - call: "bpf_map_update_elem", - io_error, - }, - )?; + bpf_map_update_elem(fd, Some(&index), &socket_fd.as_raw_fd(), flags)?; Ok(()) } } diff --git a/aya/src/pin.rs b/aya/src/pin.rs deleted file mode 100644 index 28ff03c47..000000000 --- a/aya/src/pin.rs +++ /dev/null @@ -1,29 +0,0 @@ -//! Pinning BPF objects to the BPF filesystem. - -use thiserror::Error; - -use crate::sys::SyscallError; - -/// An error ocurred working with a pinned BPF object. -#[derive(Error, Debug)] -pub enum PinError { - /// The object FD is not known by Aya. - #[error("the BPF object `{name}`'s FD is not known")] - NoFd { - /// Object name. - name: String, - }, - /// The path for the BPF object is not valid. - #[error("invalid pin path `{}`", path.display())] - InvalidPinPath { - /// The path. - path: std::path::PathBuf, - - #[source] - /// The source error. - error: std::ffi::NulError, - }, - /// An error ocurred making a syscall. - #[error(transparent)] - SyscallError(#[from] SyscallError), -} diff --git a/aya/src/programs/cgroup_device.rs b/aya/src/programs/cgroup_device.rs index 87c5d4a26..7d7aa1ded 100644 --- a/aya/src/programs/cgroup_device.rs +++ b/aya/src/programs/cgroup_device.rs @@ -3,12 +3,13 @@ use std::os::fd::AsFd; use crate::{ + errors::{LinkError, ProgramError}, generated::{bpf_attach_type::BPF_CGROUP_DEVICE, bpf_prog_type::BPF_PROG_TYPE_CGROUP_DEVICE}, programs::{ bpf_prog_get_fd_by_id, define_link_wrapper, load_program, query, CgroupAttachMode, FdLink, - Link, ProgAttachLink, ProgramData, ProgramError, ProgramFd, + Link, ProgAttachLink, ProgramData, ProgramFd, }, - sys::{bpf_link_create, LinkTarget, ProgQueryTarget, SyscallError}, + sys::{bpf_link_create, LinkTarget, ProgQueryTarget}, util::KernelVersion, }; @@ -65,7 +66,7 @@ impl CgroupDevice { &mut self, cgroup: T, mode: CgroupAttachMode, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let cgroup_fd = cgroup.as_fd(); @@ -78,11 +79,7 @@ impl CgroupDevice { None, mode.into(), None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(CgroupDeviceLink::new(CgroupDeviceLinkInner::Fd( @@ -106,14 +103,14 @@ impl CgroupDevice { pub fn take_link( &mut self, link_id: CgroupDeviceLinkId, - ) -> Result { + ) -> Result { self.data.take_link(link_id) } /// Detaches the program /// /// See [CgroupDevice::attach]. - pub fn detach(&mut self, link_id: CgroupDeviceLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: CgroupDeviceLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -164,7 +161,7 @@ impl Link for CgroupDeviceLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::Fd(fd) => fd.detach(), Self::ProgAttach(p) => p.detach(), diff --git a/aya/src/programs/cgroup_skb.rs b/aya/src/programs/cgroup_skb.rs index 637e897ae..87701346b 100644 --- a/aya/src/programs/cgroup_skb.rs +++ b/aya/src/programs/cgroup_skb.rs @@ -3,15 +3,16 @@ use std::{hash::Hash, os::fd::AsFd, path::Path}; use crate::{ + errors::{LinkError, ProgramError}, generated::{ bpf_attach_type::{BPF_CGROUP_INET_EGRESS, BPF_CGROUP_INET_INGRESS}, bpf_prog_type::BPF_PROG_TYPE_CGROUP_SKB, }, programs::{ define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink, - ProgramData, ProgramError, + ProgramData, }, - sys::{bpf_link_create, LinkTarget, SyscallError}, + sys::{bpf_link_create, LinkTarget}, util::KernelVersion, VerifierLogLevel, }; @@ -89,7 +90,7 @@ impl CgroupSkb { cgroup: T, attach_type: CgroupSkbAttachType, mode: CgroupAttachMode, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let cgroup_fd = cgroup.as_fd(); @@ -106,11 +107,7 @@ impl CgroupSkb { None, mode.into(), None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(CgroupSkbLink::new(CgroupSkbLinkInner::Fd(FdLink::new( @@ -129,14 +126,14 @@ impl CgroupSkb { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: CgroupSkbLinkId) -> Result { + pub fn take_link(&mut self, link_id: CgroupSkbLinkId) -> Result { self.data.take_link(link_id) } /// Detaches the program. /// /// See [CgroupSkb::attach]. - pub fn detach(&mut self, link_id: CgroupSkbLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: CgroupSkbLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -180,7 +177,7 @@ impl Link for CgroupSkbLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::Fd(fd) => fd.detach(), Self::ProgAttach(p) => p.detach(), diff --git a/aya/src/programs/cgroup_sock.rs b/aya/src/programs/cgroup_sock.rs index cc5db22fe..ca000cc70 100644 --- a/aya/src/programs/cgroup_sock.rs +++ b/aya/src/programs/cgroup_sock.rs @@ -5,12 +5,13 @@ use std::{hash::Hash, os::fd::AsFd, path::Path}; pub use aya_obj::programs::CgroupSockAttachType; use crate::{ + errors::{LinkError, ProgramError}, generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCK, programs::{ define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink, - ProgramData, ProgramError, + ProgramData, }, - sys::{bpf_link_create, LinkTarget, SyscallError}, + sys::{bpf_link_create, LinkTarget}, util::KernelVersion, VerifierLogLevel, }; @@ -71,7 +72,7 @@ impl CgroupSock { &mut self, cgroup: T, mode: CgroupAttachMode, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let cgroup_fd = cgroup.as_fd(); @@ -84,11 +85,7 @@ impl CgroupSock { None, mode.into(), None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(CgroupSockLink::new(CgroupSockLinkInner::Fd(FdLink::new( @@ -107,14 +104,14 @@ impl CgroupSock { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: CgroupSockLinkId) -> Result { + pub fn take_link(&mut self, link_id: CgroupSockLinkId) -> Result { self.data.take_link(link_id) } /// Detaches the program. /// /// See [CgroupSock::attach]. - pub fn detach(&mut self, link_id: CgroupSockLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: CgroupSockLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -155,7 +152,7 @@ impl Link for CgroupSockLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::Fd(fd) => fd.detach(), Self::ProgAttach(p) => p.detach(), diff --git a/aya/src/programs/cgroup_sock_addr.rs b/aya/src/programs/cgroup_sock_addr.rs index a31d8cfde..3c55e213d 100644 --- a/aya/src/programs/cgroup_sock_addr.rs +++ b/aya/src/programs/cgroup_sock_addr.rs @@ -5,12 +5,13 @@ use std::{hash::Hash, os::fd::AsFd, path::Path}; pub use aya_obj::programs::CgroupSockAddrAttachType; use crate::{ + errors::{LinkError, ProgramError}, generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCK_ADDR, programs::{ define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink, - ProgramData, ProgramError, + ProgramData, }, - sys::{bpf_link_create, LinkTarget, SyscallError}, + sys::{bpf_link_create, LinkTarget}, util::KernelVersion, VerifierLogLevel, }; @@ -72,7 +73,7 @@ impl CgroupSockAddr { &mut self, cgroup: T, mode: CgroupAttachMode, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let cgroup_fd = cgroup.as_fd(); @@ -85,11 +86,7 @@ impl CgroupSockAddr { None, mode.into(), None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(CgroupSockAddrLink::new(CgroupSockAddrLinkInner::Fd( @@ -111,14 +108,14 @@ impl CgroupSockAddr { pub fn take_link( &mut self, link_id: CgroupSockAddrLinkId, - ) -> Result { + ) -> Result { self.data.take_link(link_id) } /// Detaches the program. /// /// See [CgroupSockAddr::attach]. - pub fn detach(&mut self, link_id: CgroupSockAddrLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: CgroupSockAddrLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -159,7 +156,7 @@ impl Link for CgroupSockAddrLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::Fd(fd) => fd.detach(), Self::ProgAttach(p) => p.detach(), diff --git a/aya/src/programs/cgroup_sockopt.rs b/aya/src/programs/cgroup_sockopt.rs index ee9d40b23..ca7c45f12 100644 --- a/aya/src/programs/cgroup_sockopt.rs +++ b/aya/src/programs/cgroup_sockopt.rs @@ -5,12 +5,13 @@ use std::{hash::Hash, os::fd::AsFd, path::Path}; pub use aya_obj::programs::CgroupSockoptAttachType; use crate::{ + errors::{LinkError, ProgramError}, generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCKOPT, programs::{ define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink, - ProgramData, ProgramError, + ProgramData, }, - sys::{bpf_link_create, LinkTarget, SyscallError}, + sys::{bpf_link_create, LinkTarget}, util::KernelVersion, VerifierLogLevel, }; @@ -69,7 +70,7 @@ impl CgroupSockopt { &mut self, cgroup: T, mode: CgroupAttachMode, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let cgroup_fd = cgroup.as_fd(); @@ -82,11 +83,7 @@ impl CgroupSockopt { None, mode.into(), None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(CgroupSockoptLink::new(CgroupSockoptLinkInner::Fd( @@ -110,14 +107,14 @@ impl CgroupSockopt { pub fn take_link( &mut self, link_id: CgroupSockoptLinkId, - ) -> Result { + ) -> Result { self.data.take_link(link_id) } /// Detaches the program. /// /// See [CgroupSockopt::attach]. - pub fn detach(&mut self, link_id: CgroupSockoptLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: CgroupSockoptLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -158,7 +155,7 @@ impl Link for CgroupSockoptLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::Fd(fd) => fd.detach(), Self::ProgAttach(p) => p.detach(), diff --git a/aya/src/programs/cgroup_sysctl.rs b/aya/src/programs/cgroup_sysctl.rs index fd997aa13..2427b9c54 100644 --- a/aya/src/programs/cgroup_sysctl.rs +++ b/aya/src/programs/cgroup_sysctl.rs @@ -3,12 +3,13 @@ use std::{hash::Hash, os::fd::AsFd}; use crate::{ + errors::{LinkError, ProgramError}, generated::{bpf_attach_type::BPF_CGROUP_SYSCTL, bpf_prog_type::BPF_PROG_TYPE_CGROUP_SYSCTL}, programs::{ define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink, - ProgramData, ProgramError, + ProgramData, }, - sys::{bpf_link_create, LinkTarget, SyscallError}, + sys::{bpf_link_create, LinkTarget}, util::KernelVersion, }; @@ -64,7 +65,7 @@ impl CgroupSysctl { &mut self, cgroup: T, mode: CgroupAttachMode, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let cgroup_fd = cgroup.as_fd(); @@ -77,11 +78,7 @@ impl CgroupSysctl { None, mode.into(), None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(CgroupSysctlLink::new(CgroupSysctlLinkInner::Fd( @@ -105,14 +102,14 @@ impl CgroupSysctl { pub fn take_link( &mut self, link_id: CgroupSysctlLinkId, - ) -> Result { + ) -> Result { self.data.take_link(link_id) } /// Detaches the program. /// /// See [CgroupSysctl::attach]. - pub fn detach(&mut self, link_id: CgroupSysctlLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: CgroupSysctlLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } } @@ -139,7 +136,7 @@ impl Link for CgroupSysctlLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::Fd(fd) => fd.detach(), Self::ProgAttach(p) => p.detach(), diff --git a/aya/src/programs/extension.rs b/aya/src/programs/extension.rs index 68d77f380..dca94faac 100644 --- a/aya/src/programs/extension.rs +++ b/aya/src/programs/extension.rs @@ -3,26 +3,16 @@ use std::os::fd::{AsFd as _, BorrowedFd}; use object::Endianness; -use thiserror::Error; use crate::{ + errors::{EbpfInternalError, InternalLinkError, LinkError, ProgramError}, generated::{bpf_attach_type::BPF_CGROUP_INET_INGRESS, bpf_prog_type::BPF_PROG_TYPE_EXT}, obj::btf::BtfKind, - programs::{ - define_link_wrapper, load_program, FdLink, FdLinkId, ProgramData, ProgramError, ProgramFd, - }, - sys::{self, bpf_link_create, LinkTarget, SyscallError}, + programs::{define_link_wrapper, load_program, FdLink, FdLinkId, ProgramData, ProgramFd}, + sys::{self, bpf_link_create, LinkTarget}, Btf, }; -/// The type returned when loading or attaching an [`Extension`] fails. -#[derive(Debug, Error)] -pub enum ExtensionError { - /// Target BPF program does not have BTF loaded to the kernel. - #[error("target BPF program does not have BTF loaded to the kernel")] - NoBTF, -} - /// A program used to extend existing BPF programs. /// /// [`Extension`] programs can be loaded to replace a global @@ -86,16 +76,19 @@ impl Extension { /// /// The returned value can be used to detach the extension and restore the /// original function, see [Extension::detach]. - pub fn attach(&mut self) -> Result { + pub fn attach(&mut self) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let target_fd = self .data .attach_prog_fd .as_ref() - .ok_or(ProgramError::NotLoaded)?; + .ok_or(InternalLinkError::TargetProgramNotLoaded)?; let target_fd = target_fd.as_fd(); - let btf_id = self.data.attach_btf_id.ok_or(ProgramError::NotLoaded)?; + let btf_id = self + .data + .attach_btf_id + .ok_or(InternalLinkError::TargetNoBtf)?; // the attach type must be set as 0, which is bpf_attach_type::BPF_CGROUP_INET_INGRESS let link_fd = bpf_link_create( prog_fd, @@ -104,11 +97,7 @@ impl Extension { Some(btf_id), 0, None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(ExtensionLink::new(FdLink::new(link_fd))) @@ -129,7 +118,7 @@ impl Extension { &mut self, program: &ProgramFd, func_name: &str, - ) -> Result { + ) -> Result { let target_fd = program.as_fd(); let (_, btf_id) = get_btf_info(target_fd, func_name)?; let prog_fd = self.fd()?; @@ -142,11 +131,7 @@ impl Extension { Some(btf_id), 0, None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(ExtensionLink::new(FdLink::new(link_fd))) @@ -156,7 +141,7 @@ impl Extension { /// /// Detaching restores the original code overridden by the extension program. /// See [Extension::attach]. - pub fn detach(&mut self, link_id: ExtensionLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: ExtensionLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -164,7 +149,7 @@ impl Extension { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: ExtensionLinkId) -> Result { + pub fn take_link(&mut self, link_id: ExtensionLinkId) -> Result { self.data.take_link(link_id) } } @@ -180,7 +165,7 @@ fn get_btf_info( // btf_id refers to the ID of the program btf that was loaded with bpf(BPF_BTF_LOAD) if info.btf_id == 0 { - return Err(ProgramError::ExtensionError(ExtensionError::NoBTF)); + return Err(EbpfInternalError::NoBTF.into()); } // the bpf fd of the BTF object @@ -200,11 +185,9 @@ fn get_btf_info( break; } - let btf = Btf::parse(&buf, Endianness::default()).map_err(ProgramError::Btf)?; + let btf = Btf::parse(&buf, Endianness::default())?; - let btf_id = btf - .id_by_type_name_kind(func_name, BtfKind::Func) - .map_err(ProgramError::Btf)?; + let btf_id = btf.id_by_type_name_kind(func_name, BtfKind::Func)?; Ok((btf_fd, btf_id)) } diff --git a/aya/src/programs/fentry.rs b/aya/src/programs/fentry.rs index 0a1d082fb..830c14a58 100644 --- a/aya/src/programs/fentry.rs +++ b/aya/src/programs/fentry.rs @@ -1,11 +1,12 @@ //! Fentry programs. use crate::{ + errors::{LinkError, ProgramError}, generated::{bpf_attach_type::BPF_TRACE_FENTRY, bpf_prog_type::BPF_PROG_TYPE_TRACING}, obj::btf::{Btf, BtfKind}, programs::{ define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId, - ProgramData, ProgramError, + ProgramData, }, }; @@ -64,14 +65,14 @@ impl FEntry { /// Attaches the program. /// /// The returned value can be used to detach, see [FEntry::detach]. - pub fn attach(&mut self) -> Result { + pub fn attach(&mut self) -> Result { attach_raw_tracepoint(&mut self.data, None) } /// Detaches the program. /// /// See [FEntry::attach]. - pub fn detach(&mut self, link_id: FEntryLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: FEntryLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -79,7 +80,7 @@ impl FEntry { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: FEntryLinkId) -> Result { + pub fn take_link(&mut self, link_id: FEntryLinkId) -> Result { self.data.take_link(link_id) } } diff --git a/aya/src/programs/fexit.rs b/aya/src/programs/fexit.rs index 5efca2853..34d1b43e9 100644 --- a/aya/src/programs/fexit.rs +++ b/aya/src/programs/fexit.rs @@ -1,11 +1,12 @@ //! Fexit programs. use crate::{ + errors::{LinkError, ProgramError}, generated::{bpf_attach_type::BPF_TRACE_FEXIT, bpf_prog_type::BPF_PROG_TYPE_TRACING}, obj::btf::{Btf, BtfKind}, programs::{ define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId, - ProgramData, ProgramError, + ProgramData, }, }; @@ -64,14 +65,14 @@ impl FExit { /// Attaches the program. /// /// The returned value can be used to detach, see [FExit::detach]. - pub fn attach(&mut self) -> Result { + pub fn attach(&mut self) -> Result { attach_raw_tracepoint(&mut self.data, None) } /// Detaches the program. /// /// See [FExit::attach]. - pub fn detach(&mut self, link_id: FExitLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: FExitLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -79,7 +80,7 @@ impl FExit { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: FExitLinkId) -> Result { + pub fn take_link(&mut self, link_id: FExitLinkId) -> Result { self.data.take_link(link_id) } } diff --git a/aya/src/programs/info.rs b/aya/src/programs/info.rs index 3bfa89f39..22d66e146 100644 --- a/aya/src/programs/info.rs +++ b/aya/src/programs/info.rs @@ -9,14 +9,13 @@ use std::{ use aya_obj::generated::{bpf_prog_info, bpf_prog_type}; -use super::{ - utils::{boot_time, get_fdinfo}, - ProgramError, ProgramFd, -}; use crate::{ - sys::{ - bpf_get_object, bpf_prog_get_fd_by_id, bpf_prog_get_info_by_fd, iter_prog_ids, SyscallError, + errors::ProgramError, + programs::{ + utils::{boot_time, get_fdinfo}, + ProgramFd, }, + sys::{bpf_get_object, bpf_prog_get_fd_by_id, bpf_prog_get_info_by_fd, iter_prog_ids}, util::bytes_of_bpf_name, FEATURES, }; @@ -214,10 +213,7 @@ impl ProgramInfo { // TODO: avoid this unwrap by adding a new error variant. let path_string = CString::new(path.as_ref().as_os_str().as_bytes()).unwrap(); - let fd = bpf_get_object(&path_string).map_err(|(_, io_error)| SyscallError { - call: "BPF_OBJ_GET", - io_error, - })?; + let fd = bpf_get_object(&path_string)?; Self::new_from_fd(fd.as_fd()) } @@ -235,7 +231,7 @@ macro_rules! impl_info { /// Returns metadata information of this program. /// /// Uses kernel v4.13 features. - pub fn info(&self) -> Result { + pub fn info(&self) -> Result { let ProgramFd(fd) = self.fd()?; ProgramInfo::new_from_fd(fd.as_fd()) } diff --git a/aya/src/programs/kprobe.rs b/aya/src/programs/kprobe.rs index 81e830e98..f17a07fdb 100644 --- a/aya/src/programs/kprobe.rs +++ b/aya/src/programs/kprobe.rs @@ -1,20 +1,14 @@ //! Kernel space probes. -use std::{ - ffi::OsStr, - io, - os::fd::AsFd as _, - path::{Path, PathBuf}, -}; - -use thiserror::Error; +use std::{ffi::OsStr, os::fd::AsFd as _, path::Path}; use crate::{ + errors::LinkError, generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_KPROBE}, programs::{ define_link_wrapper, load_program, perf_attach::{PerfLinkIdInner, PerfLinkInner}, probe::{attach, ProbeKind}, - FdLink, LinkError, ProgramData, ProgramError, + FdLink, ProgramData, ProgramError, }, sys::bpf_link_get_info_by_fd, VerifierLogLevel, @@ -77,14 +71,14 @@ impl KProbe { &mut self, fn_name: T, offset: u64, - ) -> Result { + ) -> Result { attach(&mut self.data, self.kind, fn_name.as_ref(), offset, None) } /// Detaches the program. /// /// See [KProbe::attach]. - pub fn detach(&mut self, link_id: KProbeLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: KProbeLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -92,7 +86,7 @@ impl KProbe { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: KProbeLinkId) -> Result { + pub fn take_link(&mut self, link_id: KProbeLinkId) -> Result { self.data.take_link(link_id) } @@ -117,20 +111,6 @@ define_link_wrapper!( PerfLinkIdInner ); -/// The type returned when attaching a [`KProbe`] fails. -#[derive(Debug, Error)] -pub enum KProbeError { - /// Error detaching from debugfs - #[error("`{filename}`")] - FileError { - /// The file name - filename: PathBuf, - /// The [`io::Error`] returned from the file operation - #[source] - io_error: io::Error, - }, -} - impl TryFrom for FdLink { type Error = LinkError; diff --git a/aya/src/programs/links.rs b/aya/src/programs/links.rs index 9e8ac1c0e..0ace091a5 100644 --- a/aya/src/programs/links.rs +++ b/aya/src/programs/links.rs @@ -7,16 +7,14 @@ use std::{ path::{Path, PathBuf}, }; -use thiserror::Error; - use crate::{ + errors::LinkError, generated::{ bpf_attach_type, BPF_F_AFTER, BPF_F_ALLOW_MULTI, BPF_F_ALLOW_OVERRIDE, BPF_F_BEFORE, BPF_F_ID, BPF_F_LINK, BPF_F_REPLACE, }, - pin::PinError, programs::{MultiProgLink, MultiProgram, ProgramError, ProgramFd, ProgramId}, - sys::{bpf_get_object, bpf_pin_object, bpf_prog_attach, bpf_prog_detach, SyscallError}, + sys::{bpf_get_object, bpf_pin_object, bpf_prog_attach, bpf_prog_detach}, }; /// A Link. @@ -28,7 +26,7 @@ pub trait Link: std::fmt::Debug + 'static { fn id(&self) -> Self::Id; /// Detaches the LinkOwnedLink is gone... but this doesn't work :( - fn detach(self) -> Result<(), ProgramError>; + fn detach(self) -> Result<(), LinkError>; } /// Program attachment mode. @@ -67,33 +65,33 @@ impl LinkMap { } } - pub(crate) fn insert(&mut self, link: T) -> Result { + pub(crate) fn insert(&mut self, link: T) -> Result { let id = link.id(); match self.links.entry(link.id()) { - Entry::Occupied(_) => return Err(ProgramError::AlreadyAttached), + Entry::Occupied(_) => return Err(LinkError::AlreadyAttached), Entry::Vacant(e) => e.insert(link), }; Ok(id) } - pub(crate) fn remove(&mut self, link_id: T::Id) -> Result<(), ProgramError> { + pub(crate) fn remove(&mut self, link_id: T::Id) -> Result<(), LinkError> { self.links .remove(&link_id) - .ok_or(ProgramError::NotAttached)? + .ok_or(LinkError::NotAttached)? .detach() } - pub(crate) fn remove_all(&mut self) -> Result<(), ProgramError> { + pub(crate) fn remove_all(&mut self) -> Result<(), LinkError> { for (_, link) in self.links.drain() { link.detach()?; } Ok(()) } - pub(crate) fn forget(&mut self, link_id: T::Id) -> Result { - self.links.remove(&link_id).ok_or(ProgramError::NotAttached) + pub(crate) fn forget(&mut self, link_id: T::Id) -> Result { + self.links.remove(&link_id).ok_or(LinkError::NotAttached) } } @@ -159,8 +157,6 @@ impl FdLink { /// # #[error(transparent)] /// # Ebpf(#[from] aya::EbpfError), /// # #[error(transparent)] - /// # Pin(#[from] aya::pin::PinError), - /// # #[error(transparent)] /// # Program(#[from] aya::programs::ProgramError) /// # } /// # let mut bpf = aya::Ebpf::load(&[])?; @@ -171,20 +167,12 @@ impl FdLink { /// let pinned_link = fd_link.pin("/sys/fs/bpf/example")?; /// # Ok::<(), Error>(()) /// ``` - pub fn pin>(self, path: P) -> Result { + pub fn pin>(self, path: P) -> Result { use std::os::unix::ffi::OsStrExt as _; let path = path.as_ref(); - let path_string = CString::new(path.as_os_str().as_bytes()).map_err(|error| { - PinError::InvalidPinPath { - path: path.into(), - error, - } - })?; - bpf_pin_object(self.fd.as_fd(), &path_string).map_err(|(_, io_error)| SyscallError { - call: "BPF_OBJ_PIN", - io_error, - })?; + let path_string = CString::new(path.as_os_str().as_bytes())?; + bpf_pin_object(self.fd.as_fd(), &path_string)?; Ok(PinnedLink::new(path.into(), self)) } } @@ -196,7 +184,7 @@ impl Link for FdLink { FdLinkId(self.fd.as_raw_fd()) } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { // detach is a noop since it consumes self. once self is consumed, drop will be triggered // and the link will be detached. // @@ -234,12 +222,7 @@ impl PinnedLink { // TODO: avoid this unwrap by adding a new error variant. let path_string = CString::new(path.as_ref().as_os_str().as_bytes()).unwrap(); - let fd = bpf_get_object(&path_string).map_err(|(_, io_error)| { - LinkError::SyscallError(SyscallError { - call: "BPF_OBJ_GET", - io_error, - }) - })?; + let fd = bpf_get_object(&path_string)?; Ok(Self::new(path.as_ref().to_path_buf(), FdLink::new(fd))) } @@ -280,7 +263,7 @@ impl ProgAttachLink { target_fd: BorrowedFd<'_>, attach_type: bpf_attach_type, mode: CgroupAttachMode, - ) -> Result { + ) -> Result { // The link is going to own this new file descriptor so we are // going to need a duplicate whose lifetime we manage. Let's // duplicate it prior to attaching it so the new file @@ -311,7 +294,7 @@ impl Link for ProgAttachLink { ) } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { bpf_prog_detach( self.prog_fd.as_fd(), self.target_fd.as_fd(), @@ -365,7 +348,7 @@ macro_rules! define_link_wrapper { $wrapper_id(self.0.as_ref().unwrap().id()) } - fn detach(mut self) -> Result<(), ProgramError> { + fn detach(mut self) -> Result<(), crate::errors::LinkError> { self.0.take().unwrap().detach() } } @@ -386,17 +369,6 @@ macro_rules! define_link_wrapper { pub(crate) use define_link_wrapper; -#[derive(Error, Debug)] -/// Errors from operations on links. -pub enum LinkError { - /// Invalid link. - #[error("Invalid link")] - InvalidLink, - /// Syscall failed. - #[error(transparent)] - SyscallError(#[from] SyscallError), -} - #[derive(Debug)] pub(crate) enum LinkRef { Id(u32), @@ -525,8 +497,9 @@ mod tests { use super::{FdLink, Link, LinkMap}; use crate::{ + errors::LinkError, generated::{BPF_F_ALLOW_MULTI, BPF_F_ALLOW_OVERRIDE}, - programs::{CgroupAttachMode, ProgramError}, + programs::CgroupAttachMode, sys::override_syscall, }; @@ -555,7 +528,7 @@ mod tests { TestLinkId(self.id.0, self.id.1) } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { *self.detached.borrow_mut() += 1; Ok(()) } @@ -591,7 +564,7 @@ mod tests { links.insert(TestLink::new(1, 2)).unwrap(); assert_matches!( links.insert(TestLink::new(1, 2)), - Err(ProgramError::AlreadyAttached) + Err(LinkError::AlreadyAttached) ); } @@ -604,7 +577,7 @@ mod tests { let l1_id2 = l1.id(); links.insert(TestLink::new(1, 2)).unwrap(); links.remove(l1_id1).unwrap(); - assert_matches!(links.remove(l1_id2), Err(ProgramError::NotAttached)); + assert_matches!(links.remove(l1_id2), Err(LinkError::NotAttached)); } #[test] diff --git a/aya/src/programs/lirc_mode2.rs b/aya/src/programs/lirc_mode2.rs index fecd261d1..15eca3f5d 100644 --- a/aya/src/programs/lirc_mode2.rs +++ b/aya/src/programs/lirc_mode2.rs @@ -2,6 +2,7 @@ use std::os::fd::{AsFd, AsRawFd as _, RawFd}; use crate::{ + errors::LinkError, generated::{bpf_attach_type::BPF_LIRC_MODE2, bpf_prog_type::BPF_PROG_TYPE_LIRC_MODE2}, programs::{ load_program, query, CgroupAttachMode, Link, ProgramData, ProgramError, ProgramFd, @@ -61,7 +62,7 @@ impl LircMode2 { /// Attaches the program to the given lirc device. /// /// The returned value can be used to detach, see [LircMode2::detach]. - pub fn attach(&mut self, lircdev: T) -> Result { + pub fn attach(&mut self, lircdev: T) -> Result { let prog_fd = self.fd()?; // The link is going to own this new file descriptor so we are @@ -85,7 +86,7 @@ impl LircMode2 { /// Detaches the program. /// /// See [LircMode2::attach]. - pub fn detach(&mut self, link_id: LircLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: LircLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -93,7 +94,7 @@ impl LircMode2 { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: LircLinkId) -> Result { + pub fn take_link(&mut self, link_id: LircLinkId) -> Result { self.data.take_link(link_id) } @@ -148,7 +149,7 @@ impl Link for LircLink { LircLinkId(self.prog_fd.as_fd().as_raw_fd(), self.target_fd.as_raw_fd()) } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { bpf_prog_detach(self.prog_fd.as_fd(), self.target_fd.as_fd(), BPF_LIRC_MODE2) .map_err(Into::into) } diff --git a/aya/src/programs/lsm.rs b/aya/src/programs/lsm.rs index 7c1d9ddf8..a287dc24b 100644 --- a/aya/src/programs/lsm.rs +++ b/aya/src/programs/lsm.rs @@ -1,6 +1,7 @@ //! LSM probes. use crate::{ + errors::LinkError, generated::{bpf_attach_type::BPF_LSM_MAC, bpf_prog_type::BPF_PROG_TYPE_LSM}, obj::btf::{Btf, BtfKind}, programs::{ @@ -70,14 +71,14 @@ impl Lsm { /// Attaches the program. /// /// The returned value can be used to detach, see [Lsm::detach]. - pub fn attach(&mut self) -> Result { + pub fn attach(&mut self) -> Result { attach_raw_tracepoint(&mut self.data, None) } /// Detaches the program. /// /// See [Lsm::attach]. - pub fn detach(&mut self, link_id: LsmLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: LsmLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -85,7 +86,7 @@ impl Lsm { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: LsmLinkId) -> Result { + pub fn take_link(&mut self, link_id: LsmLinkId) -> Result { self.data.take_link(link_id) } } diff --git a/aya/src/programs/mod.rs b/aya/src/programs/mod.rs index 00d61b01d..1dd61c76a 100644 --- a/aya/src/programs/mod.rs +++ b/aya/src/programs/mod.rs @@ -81,7 +81,6 @@ use info::impl_info; pub use info::{loaded_programs, ProgramInfo, ProgramType}; use libc::ENOSPC; use tc::SchedClassifierLink; -use thiserror::Error; // re-export the main items needed to load and attach pub use crate::programs::{ @@ -91,10 +90,10 @@ pub use crate::programs::{ cgroup_sock_addr::{CgroupSockAddr, CgroupSockAddrAttachType}, cgroup_sockopt::{CgroupSockopt, CgroupSockoptAttachType}, cgroup_sysctl::CgroupSysctl, - extension::{Extension, ExtensionError}, + extension::Extension, fentry::FEntry, fexit::FExit, - kprobe::{KProbe, KProbeError}, + kprobe::KProbe, links::{CgroupAttachMode, Link, LinkOrder}, lirc_mode2::LircMode2, lsm::Lsm, @@ -105,120 +104,27 @@ pub use crate::programs::{ sk_msg::SkMsg, sk_skb::{SkSkb, SkSkbKind}, sock_ops::SockOps, - socket_filter::{SocketFilter, SocketFilterError}, - tc::{SchedClassifier, TcAttachType, TcError}, + socket_filter::SocketFilter, + tc::{SchedClassifier, TcAttachType}, tp_btf::BtfTracePoint, - trace_point::{TracePoint, TracePointError}, - uprobe::{UProbe, UProbeError}, - xdp::{Xdp, XdpError, XdpFlags}, + trace_point::TracePoint, + uprobe::UProbe, + xdp::{Xdp, XdpFlags}, }; use crate::{ + errors::{LinkError, ProgramError, SysError}, generated::{bpf_attach_type, bpf_link_info, bpf_prog_info, bpf_prog_type}, - maps::MapError, - obj::{self, btf::BtfError, VerifierLog}, - pin::PinError, + obj::{self}, programs::{links::*, perf_attach::*}, sys::{ bpf_btf_get_fd_by_id, bpf_get_object, bpf_link_get_fd_by_id, bpf_link_get_info_by_fd, bpf_load_program, bpf_pin_object, bpf_prog_get_fd_by_id, bpf_prog_query, iter_link_ids, - retry_with_verifier_logs, EbpfLoadProgramAttrs, ProgQueryTarget, SyscallError, + retry_with_verifier_logs, EbpfLoadProgramAttrs, ProgQueryTarget, }, util::KernelVersion, VerifierLogLevel, }; -/// Error type returned when working with programs. -#[derive(Debug, Error)] -pub enum ProgramError { - /// The program is already loaded. - #[error("the program is already loaded")] - AlreadyLoaded, - - /// The program is not loaded. - #[error("the program is not loaded")] - NotLoaded, - - /// The program is already attached. - #[error("the program was already attached")] - AlreadyAttached, - - /// The program is not attached. - #[error("the program is not attached")] - NotAttached, - - /// Loading the program failed. - #[error("the BPF_PROG_LOAD syscall failed. Verifier output: {verifier_log}")] - LoadError { - /// The [`io::Error`] returned by the `BPF_PROG_LOAD` syscall. - #[source] - io_error: io::Error, - /// The error log produced by the kernel verifier. - verifier_log: VerifierLog, - }, - - /// A syscall failed. - #[error(transparent)] - SyscallError(#[from] SyscallError), - - /// The network interface does not exist. - #[error("unknown network interface {name}")] - UnknownInterface { - /// interface name - name: String, - }, - - /// The program is not of the expected type. - #[error("unexpected program type")] - UnexpectedProgramType, - - /// A map error occurred while loading or attaching a program. - #[error(transparent)] - MapError(#[from] MapError), - - /// An error occurred while working with a [`KProbe`]. - #[error(transparent)] - KProbeError(#[from] KProbeError), - - /// An error occurred while working with an [`UProbe`]. - #[error(transparent)] - UProbeError(#[from] UProbeError), - - /// An error occurred while working with a [`TracePoint`]. - #[error(transparent)] - TracePointError(#[from] TracePointError), - - /// An error occurred while working with a [`SocketFilter`]. - #[error(transparent)] - SocketFilterError(#[from] SocketFilterError), - - /// An error occurred while working with an [`Xdp`] program. - #[error(transparent)] - XdpError(#[from] XdpError), - - /// An error occurred while working with a TC program. - #[error(transparent)] - TcError(#[from] TcError), - - /// An error occurred while working with an [`Extension`] program. - #[error(transparent)] - ExtensionError(#[from] ExtensionError), - - /// An error occurred while working with BTF. - #[error(transparent)] - Btf(#[from] BtfError), - - /// The program is not attached. - #[error("the program name `{name}` is invalid")] - InvalidName { - /// program name - name: String, - }, - - /// An error occurred while working with IO. - #[error(transparent)] - IOError(#[from] io::Error), -} - /// A [`Program`] file descriptor. #[derive(Debug)] pub struct ProgramFd(crate::MockableFd); @@ -334,7 +240,7 @@ impl Program { } /// Pin the program to the provided path - pub fn pin>(&mut self, path: P) -> Result<(), PinError> { + pub fn pin>(&mut self, path: P) -> Result<(), ProgramError> { match self { Self::KProbe(p) => p.pin(path), Self::UProbe(p) => p.pin(path), @@ -538,10 +444,7 @@ impl ProgramData { // TODO: avoid this unwrap by adding a new error variant. let path_string = CString::new(path.as_ref().as_os_str().as_bytes()).unwrap(); - let fd = bpf_get_object(&path_string).map_err(|(_, io_error)| SyscallError { - call: "bpf_obj_get", - io_error, - })?; + let fd = bpf_get_object(&path_string)?; let info = ProgramInfo::new_from_fd(fd.as_fd())?; let name = info.name_as_str().map(|s| s.to_string()); @@ -554,7 +457,7 @@ impl ProgramData { self.fd.as_ref().ok_or(ProgramError::NotLoaded) } - pub(crate) fn take_link(&mut self, link_id: T::Id) -> Result { + pub(crate) fn take_link(&mut self, link_id: T::Id) -> Result { self.links.forget(link_id) } } @@ -567,26 +470,16 @@ fn unload_program(data: &mut ProgramData) -> Result<(), ProgramError .map(|ProgramFd { .. }| ()) } -fn pin_program>(data: &ProgramData, path: P) -> Result<(), PinError> { +fn pin_program>( + data: &ProgramData, + path: P, +) -> Result<(), ProgramError> { use std::os::unix::ffi::OsStrExt as _; - let fd = data.fd.as_ref().ok_or(PinError::NoFd { - name: data - .name - .as_deref() - .unwrap_or("") - .to_string(), - })?; + let fd = data.fd.as_ref().ok_or(ProgramError::NotLoaded)?; let path = path.as_ref(); - let path_string = - CString::new(path.as_os_str().as_bytes()).map_err(|error| PinError::InvalidPinPath { - path: path.into(), - error, - })?; - bpf_pin_object(fd.as_fd(), &path_string).map_err(|(_, io_error)| SyscallError { - call: "BPF_OBJ_PIN", - io_error, - })?; + let path_string = CString::new(path.as_os_str().as_bytes())?; + bpf_pin_object(fd.as_fd(), &path_string)?; Ok(()) } @@ -640,8 +533,7 @@ fn load_program( if name.len() > 15 { name.truncate(15); } - let prog_name = CString::new(name.clone()) - .map_err(|_| ProgramError::InvalidName { name: name.clone() })?; + let prog_name = CString::new(name.clone())?; Some(prog_name) } else { None @@ -674,8 +566,8 @@ fn load_program( *fd = Some(ProgramFd(prog_fd)); Ok(()) } - Err((_, io_error)) => Err(ProgramError::LoadError { - io_error, + Err((_, source)) => Err(ProgramError::LoadError { + source, verifier_log, }), } @@ -707,16 +599,14 @@ pub(crate) fn query( prog_ids.resize(prog_cnt as usize, 0); return Ok((revision, prog_ids)); } - Err((_, io_error)) => { - if retries == 0 && io_error.raw_os_error() == Some(ENOSPC) { - prog_ids.resize(prog_cnt as usize, 0); - retries += 1; - } else { - return Err(SyscallError { - call: "bpf_prog_query", - io_error, + Err((_, e)) => { + if let SysError::Syscall { call: _, io_error } = e { + if retries == 0 && io_error.raw_os_error() == Some(ENOSPC) { + prog_ids.resize(prog_cnt as usize, 0); + retries += 1; } - .into()); + } else { + return Err(e.into()); } } } @@ -874,7 +764,7 @@ macro_rules! impl_program_pin{ /// Aya has unloaded the program. /// To remove the program, the file on the BPF filesystem must be removed. /// Any directories in the the path provided should have been created by the caller. - pub fn pin>(&mut self, path: P) -> Result<(), PinError> { + pub fn pin>(&mut self, path: P) -> Result<(), ProgramError> { self.data.path = Some(path.as_ref().to_path_buf()); pin_program(&self.data, path) } diff --git a/aya/src/programs/perf_attach.rs b/aya/src/programs/perf_attach.rs index 89f68ace4..e3bd0683e 100644 --- a/aya/src/programs/perf_attach.rs +++ b/aya/src/programs/perf_attach.rs @@ -2,12 +2,13 @@ use std::os::fd::{AsFd as _, AsRawFd as _, BorrowedFd, RawFd}; use crate::{ + errors::LinkError, generated::bpf_attach_type::BPF_PERF_EVENT, programs::{ probe::{detach_debug_fs, ProbeEvent}, - FdLink, Link, ProgramError, + FdLink, Link, }, - sys::{bpf_link_create, perf_event_ioctl, LinkTarget, SysResult, SyscallError}, + sys::{bpf_link_create, perf_event_ioctl, LinkTarget, SysResult}, FEATURES, PERF_EVENT_IOC_DISABLE, PERF_EVENT_IOC_ENABLE, PERF_EVENT_IOC_SET_BPF, }; @@ -33,7 +34,7 @@ impl Link for PerfLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::FdLink(link) => link.detach(), Self::PerfLink(link) => link.detach(), @@ -59,7 +60,7 @@ impl Link for PerfLink { PerfLinkId(self.perf_fd.as_raw_fd()) } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { let Self { perf_fd, event } = self; let _: SysResult<_> = perf_event_ioctl(perf_fd.as_fd(), PERF_EVENT_IOC_DISABLE, 0); if let Some(event) = event { @@ -73,7 +74,7 @@ impl Link for PerfLink { pub(crate) fn perf_attach( prog_fd: BorrowedFd<'_>, fd: crate::MockableFd, -) -> Result { +) -> Result { if FEATURES.bpf_perf_link() { let link_fd = bpf_link_create( prog_fd, @@ -82,11 +83,7 @@ pub(crate) fn perf_attach( None, 0, None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; Ok(PerfLinkInner::FdLink(FdLink::new(link_fd))) } else { perf_attach_either(prog_fd, fd, None) @@ -97,7 +94,7 @@ pub(crate) fn perf_attach_debugfs( prog_fd: BorrowedFd<'_>, fd: crate::MockableFd, event: ProbeEvent, -) -> Result { +) -> Result { perf_attach_either(prog_fd, fd, Some(event)) } @@ -105,19 +102,9 @@ fn perf_attach_either( prog_fd: BorrowedFd<'_>, fd: crate::MockableFd, event: Option, -) -> Result { - perf_event_ioctl(fd.as_fd(), PERF_EVENT_IOC_SET_BPF, prog_fd.as_raw_fd()).map_err( - |(_, io_error)| SyscallError { - call: "PERF_EVENT_IOC_SET_BPF", - io_error, - }, - )?; - perf_event_ioctl(fd.as_fd(), PERF_EVENT_IOC_ENABLE, 0).map_err(|(_, io_error)| { - SyscallError { - call: "PERF_EVENT_IOC_ENABLE", - io_error, - } - })?; +) -> Result { + perf_event_ioctl(fd.as_fd(), PERF_EVENT_IOC_SET_BPF, prog_fd.as_raw_fd())?; + perf_event_ioctl(fd.as_fd(), PERF_EVENT_IOC_ENABLE, 0)?; Ok(PerfLinkInner::PerfLink(PerfLink { perf_fd: fd, event })) } diff --git a/aya/src/programs/perf_event.rs b/aya/src/programs/perf_event.rs index 587d6499b..5e6354588 100644 --- a/aya/src/programs/perf_event.rs +++ b/aya/src/programs/perf_event.rs @@ -6,6 +6,7 @@ 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, }; use crate::{ + errors::LinkError, generated::{ bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_PERF_EVENT, @@ -16,11 +17,11 @@ use crate::{ }, programs::{ links::define_link_wrapper, - load_program, perf_attach, - perf_attach::{PerfLinkIdInner, PerfLinkInner}, - FdLink, LinkError, ProgramData, ProgramError, + load_program, + perf_attach::{perf_attach, PerfLinkIdInner, PerfLinkInner}, + FdLink, ProgramData, ProgramError, }, - sys::{bpf_link_get_info_by_fd, perf_event_open, SyscallError}, + sys::{bpf_link_get_info_by_fd, perf_event_open}, }; /// The type of perf event @@ -150,7 +151,7 @@ impl PerfEvent { scope: PerfEventScope, sample_policy: SamplePolicy, inherit: bool, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let (sample_period, sample_frequency) = match sample_policy { @@ -174,11 +175,7 @@ impl PerfEvent { false, inherit, 0, - ) - .map_err(|(_code, io_error)| SyscallError { - call: "perf_event_open", - io_error, - })?; + )?; let link = perf_attach(prog_fd, fd)?; self.data.links.insert(PerfEventLink::new(link)) @@ -187,7 +184,7 @@ impl PerfEvent { /// Detaches the program. /// /// See [PerfEvent::attach]. - pub fn detach(&mut self, link_id: PerfEventLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: PerfEventLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -195,7 +192,7 @@ impl PerfEvent { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: PerfEventLinkId) -> Result { + pub fn take_link(&mut self, link_id: PerfEventLinkId) -> Result { self.data.take_link(link_id) } } diff --git a/aya/src/programs/probe.rs b/aya/src/programs/probe.rs index 4d737e346..b1dc4be37 100644 --- a/aya/src/programs/probe.rs +++ b/aya/src/programs/probe.rs @@ -12,12 +12,15 @@ use std::{ use libc::pid_t; use crate::{ + errors::LinkError, programs::{ - kprobe::KProbeError, perf_attach, perf_attach::PerfLinkInner, perf_attach_debugfs, - trace_point::read_sys_fs_trace_point_id, uprobe::UProbeError, utils::find_tracefs_path, - Link, ProgramData, ProgramError, + perf_attach::{perf_attach, PerfLinkInner}, + perf_attach_debugfs, + trace_point::read_sys_fs_trace_point_id, + utils::find_tracefs_path, + Link, ProgramData, }, - sys::{perf_event_open_probe, perf_event_open_trace_point, SyscallError}, + sys::{perf_event_open_probe, perf_event_open_trace_point}, util::KernelVersion, }; @@ -112,7 +115,7 @@ pub(crate) fn attach>( fn_name: &OsStr, offset: u64, pid: Option, -) -> Result { +) -> Result { // https://github.com/torvalds/linux/commit/e12f03d7031a977356e3d7b75a68c2185ff8d155 // Use debugfs to create probe let prog_fd = program_data.fd()?; @@ -127,22 +130,10 @@ pub(crate) fn attach>( program_data.links.insert(T::from(link)) } -pub(crate) fn detach_debug_fs(event: ProbeEvent) -> Result<(), ProgramError> { - use ProbeKind::*; - +pub(crate) fn detach_debug_fs(event: ProbeEvent) -> Result<(), LinkError> { let tracefs = find_tracefs_path()?; - let ProbeEvent { - kind, - event_alias: _, - } = &event; - let kind = *kind; - let result = delete_probe_event(tracefs, event); - - result.map_err(|(filename, io_error)| match kind { - KProbe | KRetProbe => KProbeError::FileError { filename, io_error }.into(), - UProbe | URetProbe => UProbeError::FileError { filename, io_error }.into(), - }) + delete_probe_event(tracefs, event).map_err(Into::into) } fn create_as_probe( @@ -150,35 +141,21 @@ fn create_as_probe( fn_name: &OsStr, offset: u64, pid: Option, -) -> Result { +) -> Result { use ProbeKind::*; let perf_ty = match kind { - KProbe | KRetProbe => read_sys_fs_perf_type(kind.pmu()) - .map_err(|(filename, io_error)| KProbeError::FileError { filename, io_error })?, - UProbe | URetProbe => read_sys_fs_perf_type(kind.pmu()) - .map_err(|(filename, io_error)| UProbeError::FileError { filename, io_error })?, + KProbe | KRetProbe => read_sys_fs_perf_type(kind.pmu())?, + UProbe | URetProbe => read_sys_fs_perf_type(kind.pmu())?, }; let ret_bit = match kind { - KRetProbe => Some( - read_sys_fs_perf_ret_probe(kind.pmu()) - .map_err(|(filename, io_error)| KProbeError::FileError { filename, io_error })?, - ), - URetProbe => Some( - read_sys_fs_perf_ret_probe(kind.pmu()) - .map_err(|(filename, io_error)| UProbeError::FileError { filename, io_error })?, - ), + KRetProbe => Some(read_sys_fs_perf_ret_probe(kind.pmu())?), + URetProbe => Some(read_sys_fs_perf_ret_probe(kind.pmu())?), _ => None, }; - perf_event_open_probe(perf_ty, ret_bit, fn_name, offset, pid).map_err(|(_code, io_error)| { - SyscallError { - call: "perf_event_open", - io_error, - } - .into() - }) + perf_event_open_probe(perf_ty, ret_bit, fn_name, offset, pid).map_err(Into::into) } fn create_as_trace_point( @@ -186,24 +163,19 @@ fn create_as_trace_point( name: &OsStr, offset: u64, pid: Option, -) -> Result<(crate::MockableFd, OsString), ProgramError> { +) -> Result<(crate::MockableFd, OsString), LinkError> { use ProbeKind::*; let tracefs = find_tracefs_path()?; let event_alias = match kind { - KProbe | KRetProbe => create_probe_event(tracefs, kind, name, offset) - .map_err(|(filename, io_error)| KProbeError::FileError { filename, io_error })?, - UProbe | URetProbe => create_probe_event(tracefs, kind, name, offset) - .map_err(|(filename, io_error)| UProbeError::FileError { filename, io_error })?, + KProbe | KRetProbe => create_probe_event(tracefs, kind, name, offset)?, + UProbe | URetProbe => create_probe_event(tracefs, kind, name, offset)?, }; let category = format!("{}s", kind.pmu()); let tpid = read_sys_fs_trace_point_id(tracefs, &category, event_alias.as_ref())?; - let fd = perf_event_open_trace_point(tpid, pid).map_err(|(_code, io_error)| SyscallError { - call: "perf_event_open", - io_error, - })?; + let fd = perf_event_open_trace_point(tpid, pid)?; Ok((fd, event_alias)) } diff --git a/aya/src/programs/raw_trace_point.rs b/aya/src/programs/raw_trace_point.rs index 617ebc810..245a07713 100644 --- a/aya/src/programs/raw_trace_point.rs +++ b/aya/src/programs/raw_trace_point.rs @@ -2,6 +2,7 @@ use std::ffi::CString; use crate::{ + errors::LinkError, generated::bpf_prog_type::BPF_PROG_TYPE_RAW_TRACEPOINT, programs::{ define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId, @@ -48,7 +49,7 @@ impl RawTracePoint { /// Attaches the program to the given tracepoint. /// /// The returned value can be used to detach, see [RawTracePoint::detach]. - pub fn attach(&mut self, tp_name: &str) -> Result { + pub fn attach(&mut self, tp_name: &str) -> Result { let tp_name_c = CString::new(tp_name).unwrap(); attach_raw_tracepoint(&mut self.data, Some(&tp_name_c)) } @@ -56,7 +57,7 @@ impl RawTracePoint { /// Detaches from a tracepoint. /// /// See [RawTracePoint::attach]. - pub fn detach(&mut self, link_id: RawTracePointLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: RawTracePointLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -67,7 +68,7 @@ impl RawTracePoint { pub fn take_link( &mut self, link_id: RawTracePointLinkId, - ) -> Result { + ) -> Result { self.data.take_link(link_id) } } diff --git a/aya/src/programs/sk_lookup.rs b/aya/src/programs/sk_lookup.rs index 065001ce0..3c8d87d31 100644 --- a/aya/src/programs/sk_lookup.rs +++ b/aya/src/programs/sk_lookup.rs @@ -3,9 +3,10 @@ use std::os::fd::AsFd; use super::links::FdLink; use crate::{ + errors::LinkError, generated::{bpf_attach_type::BPF_SK_LOOKUP, bpf_prog_type::BPF_PROG_TYPE_SK_LOOKUP}, programs::{define_link_wrapper, load_program, FdLinkId, ProgramData, ProgramError}, - sys::{bpf_link_create, LinkTarget, SyscallError}, + sys::{bpf_link_create, LinkTarget}, }; /// A program used to redirect incoming packets to a local socket. @@ -60,7 +61,7 @@ impl SkLookup { /// Attaches the program to the given network namespace. /// /// The returned value can be used to detach, see [SkLookup::detach]. - pub fn attach(&mut self, netns: T) -> Result { + pub fn attach(&mut self, netns: T) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let netns_fd = netns.as_fd(); @@ -72,11 +73,7 @@ impl SkLookup { None, 0, None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(SkLookupLink::new(FdLink::new(link_fd))) @@ -86,14 +83,14 @@ impl SkLookup { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: SkLookupLinkId) -> Result { + pub fn take_link(&mut self, link_id: SkLookupLinkId) -> Result { self.data.take_link(link_id) } /// Detaches the program. /// /// See [SkLookup::attach]. - pub fn detach(&mut self, link_id: SkLookupLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: SkLookupLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } } diff --git a/aya/src/programs/sk_msg.rs b/aya/src/programs/sk_msg.rs index 95510cf2c..7622c089c 100644 --- a/aya/src/programs/sk_msg.rs +++ b/aya/src/programs/sk_msg.rs @@ -3,6 +3,7 @@ use std::os::fd::AsFd as _; use crate::{ + errors::LinkError, generated::{bpf_attach_type::BPF_SK_MSG_VERDICT, bpf_prog_type::BPF_PROG_TYPE_SK_MSG}, maps::sock::SockMapFd, programs::{ @@ -77,7 +78,7 @@ impl SkMsg { /// Attaches the program to the given sockmap. /// /// The returned value can be used to detach, see [SkMsg::detach]. - pub fn attach(&mut self, map: &SockMapFd) -> Result { + pub fn attach(&mut self, map: &SockMapFd) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let link = ProgAttachLink::attach( @@ -93,7 +94,7 @@ impl SkMsg { /// Detaches the program from a sockmap. /// /// See [SkMsg::attach]. - pub fn detach(&mut self, link_id: SkMsgLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: SkMsgLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -101,7 +102,7 @@ impl SkMsg { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: SkMsgLinkId) -> Result { + pub fn take_link(&mut self, link_id: SkMsgLinkId) -> Result { self.data.take_link(link_id) } } diff --git a/aya/src/programs/sk_skb.rs b/aya/src/programs/sk_skb.rs index eabce5938..3def6fa35 100644 --- a/aya/src/programs/sk_skb.rs +++ b/aya/src/programs/sk_skb.rs @@ -3,6 +3,7 @@ use std::{os::fd::AsFd as _, path::Path}; use crate::{ + errors::LinkError, generated::{ bpf_attach_type::{BPF_SK_SKB_STREAM_PARSER, BPF_SK_SKB_STREAM_VERDICT}, bpf_prog_type::BPF_PROG_TYPE_SK_SKB, @@ -81,7 +82,7 @@ impl SkSkb { /// Attaches the program to the given socket map. /// /// The returned value can be used to detach, see [SkSkb::detach]. - pub fn attach(&mut self, map: &SockMapFd) -> Result { + pub fn attach(&mut self, map: &SockMapFd) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); @@ -99,7 +100,7 @@ impl SkSkb { /// Detaches the program. /// /// See [SkSkb::attach]. - pub fn detach(&mut self, link_id: SkSkbLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: SkSkbLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -107,7 +108,7 @@ impl SkSkb { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: SkSkbLinkId) -> Result { + pub fn take_link(&mut self, link_id: SkSkbLinkId) -> Result { self.data.take_link(link_id) } diff --git a/aya/src/programs/sock_ops.rs b/aya/src/programs/sock_ops.rs index 62573215c..dc97f119e 100644 --- a/aya/src/programs/sock_ops.rs +++ b/aya/src/programs/sock_ops.rs @@ -2,12 +2,13 @@ use std::os::fd::AsFd; use crate::{ + errors::LinkError, generated::{bpf_attach_type::BPF_CGROUP_SOCK_OPS, bpf_prog_type::BPF_PROG_TYPE_SOCK_OPS}, programs::{ define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink, ProgramData, ProgramError, }, - sys::{bpf_link_create, LinkTarget, SyscallError}, + sys::{bpf_link_create, LinkTarget}, util::KernelVersion, }; @@ -63,7 +64,7 @@ impl SockOps { &mut self, cgroup: T, mode: CgroupAttachMode, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let cgroup_fd = cgroup.as_fd(); @@ -76,11 +77,7 @@ impl SockOps { None, mode.into(), None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(SockOpsLink::new(SockOpsLinkInner::Fd(FdLink::new(link_fd)))) @@ -96,7 +93,7 @@ impl SockOps { /// Detaches the program. /// /// See [SockOps::attach]. - pub fn detach(&mut self, link_id: SockOpsLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: SockOpsLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -104,7 +101,7 @@ impl SockOps { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: SockOpsLinkId) -> Result { + pub fn take_link(&mut self, link_id: SockOpsLinkId) -> Result { self.data.take_link(link_id) } } @@ -131,7 +128,7 @@ impl Link for SockOpsLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::Fd(fd) => fd.detach(), Self::ProgAttach(p) => p.detach(), diff --git a/aya/src/programs/socket_filter.rs b/aya/src/programs/socket_filter.rs index 02be9e054..8f5e8fc0a 100644 --- a/aya/src/programs/socket_filter.rs +++ b/aya/src/programs/socket_filter.rs @@ -5,25 +5,13 @@ use std::{ }; use libc::{setsockopt, SOL_SOCKET}; -use thiserror::Error; use crate::{ + errors::{InternalLinkError, LinkError}, generated::{bpf_prog_type::BPF_PROG_TYPE_SOCKET_FILTER, SO_ATTACH_BPF, SO_DETACH_BPF}, programs::{load_program, Link, ProgramData, ProgramError}, }; -/// The type returned when attaching a [`SocketFilter`] fails. -#[derive(Debug, Error)] -pub enum SocketFilterError { - /// Setting the `SO_ATTACH_BPF` socket option failed. - #[error("setsockopt SO_ATTACH_BPF failed")] - SoAttachEbpfError { - /// original [`io::Error`] - #[source] - io_error: io::Error, - }, -} - /// A program used to inspect and filter incoming packets on a socket. /// /// [`SocketFilter`] programs are attached on sockets and can be used to inspect @@ -72,7 +60,7 @@ impl SocketFilter { /// Attaches the filter on the given socket. /// /// The returned value can be used to detach from the socket, see [SocketFilter::detach]. - pub fn attach(&mut self, socket: T) -> Result { + pub fn attach(&mut self, socket: T) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let prog_fd = prog_fd.as_raw_fd(); @@ -89,7 +77,7 @@ impl SocketFilter { ) }; if ret < 0 { - return Err(SocketFilterError::SoAttachEbpfError { + return Err(InternalLinkError::SoAttachEbpf { io_error: io::Error::last_os_error(), } .into()); @@ -101,7 +89,7 @@ impl SocketFilter { /// Detaches the program. /// /// See [SocketFilter::attach]. - pub fn detach(&mut self, link_id: SocketFilterLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: SocketFilterLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -112,7 +100,7 @@ impl SocketFilter { pub fn take_link( &mut self, link_id: SocketFilterLinkId, - ) -> Result { + ) -> Result { self.data.take_link(link_id) } } @@ -135,7 +123,7 @@ impl Link for SocketFilterLink { SocketFilterLinkId(self.socket, self.prog_fd) } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { unsafe { setsockopt( self.socket, diff --git a/aya/src/programs/tc.rs b/aya/src/programs/tc.rs index 9f55fe92b..f51a113ae 100644 --- a/aya/src/programs/tc.rs +++ b/aya/src/programs/tc.rs @@ -6,10 +6,9 @@ use std::{ path::Path, }; -use thiserror::Error; - use super::{FdLink, ProgramInfo}; use crate::{ + errors::{InternalLinkError, LinkError}, generated::{ bpf_attach_type::{self, BPF_TCX_EGRESS, BPF_TCX_INGRESS}, bpf_link_type, @@ -17,13 +16,12 @@ use crate::{ TC_H_CLSACT, TC_H_MIN_EGRESS, TC_H_MIN_INGRESS, }, programs::{ - define_link_wrapper, load_program, query, Link, LinkError, LinkOrder, ProgramData, - ProgramError, + define_link_wrapper, load_program, query, Link, LinkOrder, ProgramData, ProgramError, }, sys::{ bpf_link_create, bpf_link_get_info_by_fd, bpf_link_update, bpf_prog_get_fd_by_id, netlink_find_filter_with_name, netlink_qdisc_add_clsact, netlink_qdisc_attach, - netlink_qdisc_detach, LinkTarget, ProgQueryTarget, SyscallError, + netlink_qdisc_detach, LinkTarget, ProgQueryTarget, }, util::{ifindex_from_ifname, tc_handler_make, KernelVersion}, VerifierLogLevel, @@ -84,27 +82,6 @@ pub struct SchedClassifier { pub(crate) data: ProgramData, } -/// Errors from TC programs -#[derive(Debug, Error)] -pub enum TcError { - /// netlink error while attaching ebpf program - #[error("netlink error while attaching ebpf program to tc")] - NetlinkError { - /// the [`io::Error`] from the netlink call - #[source] - io_error: io::Error, - }, - /// the clsact qdisc is already attached - #[error("the clsact qdisc is already attached")] - AlreadyAttached, - /// tcx links can only be attached to ingress or egress, custom attachment is not supported - #[error("tcx links can only be attached to ingress or egress, custom attachment: {0} is not supported")] - InvalidTcxAttach(u32), - /// operation not supported for programs loaded via tcx - #[error("operation not supported for programs loaded via tcx")] - InvalidLinkOperation, -} - impl TcAttachType { pub(crate) fn tc_parent(&self) -> u32 { match self { @@ -114,11 +91,13 @@ impl TcAttachType { } } - pub(crate) fn tcx_attach_type(&self) -> Result { + pub(crate) fn tcx_attach_type(&self) -> Result { match self { Self::Ingress => Ok(BPF_TCX_INGRESS), Self::Egress => Ok(BPF_TCX_EGRESS), - Self::Custom(tcx_attach_type) => Err(TcError::InvalidTcxAttach(*tcx_attach_type)), + Self::Custom(tcx_attach_type) => { + Err(InternalLinkError::InvalidTcxAttach(*tcx_attach_type)) + } } } } @@ -175,7 +154,7 @@ impl SchedClassifier { &mut self, interface: &str, attach_type: TcAttachType, - ) -> Result { + ) -> Result { if !matches!(attach_type, TcAttachType::Custom(_)) && KernelVersion::current().unwrap() >= KernelVersion::new(6, 6, 0) { @@ -208,9 +187,9 @@ impl SchedClassifier { interface: &str, attach_type: TcAttachType, options: TcAttachOptions, - ) -> Result { + ) -> Result { let if_index = ifindex_from_ifname(interface) - .map_err(|io_error| TcError::NetlinkError { io_error })?; + .map_err(|io_error| InternalLinkError::NetlinkError { io_error })?; self.do_attach(if_index, attach_type, options, true) } @@ -220,7 +199,7 @@ impl SchedClassifier { pub fn attach_to_link( &mut self, link: SchedClassifierLink, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); match link.into_inner() { @@ -228,12 +207,7 @@ impl SchedClassifier { let fd = link.fd; let link_fd = fd.as_fd(); - bpf_link_update(link_fd.as_fd(), prog_fd, None, 0).map_err(|(_, io_error)| { - SyscallError { - call: "bpf_link_update", - io_error, - } - })?; + bpf_link_update(link_fd.as_fd(), prog_fd, None, 0).map_err(|(_, e)| e)?; self.data .links @@ -261,7 +235,7 @@ impl SchedClassifier { attach_type: TcAttachType, options: TcAttachOptions, create: bool, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); @@ -281,7 +255,7 @@ impl SchedClassifier { create, ) } - .map_err(|io_error| TcError::NetlinkError { io_error })?; + .map_err(|io_error| InternalLinkError::NetlinkError { io_error })?; self.data .links @@ -300,11 +274,7 @@ impl SchedClassifier { None, options.flags.bits(), Some(&options.link_ref), - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_mprog_attach", - io_error, - })?; + )?; self.data .links @@ -318,7 +288,7 @@ impl SchedClassifier { /// Detaches the program. /// /// See [SchedClassifier::attach]. - pub fn detach(&mut self, link_id: SchedClassifierLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: SchedClassifierLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -329,7 +299,7 @@ impl SchedClassifier { pub fn take_link( &mut self, link_id: SchedClassifierLinkId, - ) -> Result { + ) -> Result { self.data.take_link(link_id) } @@ -361,9 +331,9 @@ impl SchedClassifier { pub fn query_tcx( interface: &str, attach_type: TcAttachType, - ) -> Result<(u64, Vec), ProgramError> { + ) -> Result<(u64, Vec), LinkError> { let if_index = ifindex_from_ifname(interface) - .map_err(|io_error| TcError::NetlinkError { io_error })?; + .map_err(|io_error| InternalLinkError::NetlinkError { io_error })?; let (revision, prog_ids) = query( ProgQueryTarget::IfIndex(if_index), @@ -403,7 +373,7 @@ impl Link for NlLink { NlLinkId(self.if_index, self.attach_type, self.priority, self.handle) } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { unsafe { netlink_qdisc_detach( self.if_index as i32, @@ -412,7 +382,7 @@ impl Link for NlLink { self.handle, ) } - .map_err(|io_error| TcError::NetlinkError { io_error })?; + .map_err(|io_error| InternalLinkError::NetlinkError { io_error })?; Ok(()) } } @@ -439,7 +409,7 @@ impl Link for TcLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::FdLink(link) => link.detach(), Self::NlLink(link) => link.detach(), @@ -540,29 +510,29 @@ impl SchedClassifierLink { } /// Returns the attach type. - pub fn attach_type(&self) -> Result { + pub fn attach_type(&self) -> Result { if let TcLinkInner::NlLink(n) = self.inner() { Ok(n.attach_type) } else { - Err(TcError::InvalidLinkOperation.into()) + Err(InternalLinkError::InvalidLinkOperation.into()) } } /// Returns the allocated priority. If none was provided at attach time, this was allocated for you. - pub fn priority(&self) -> Result { + pub fn priority(&self) -> Result { if let TcLinkInner::NlLink(n) = self.inner() { Ok(n.priority) } else { - Err(TcError::InvalidLinkOperation.into()) + Err(InternalLinkError::InvalidLinkOperation.into()) } } /// Returns the assigned handle. If none was provided at attach time, this was allocated for you. - pub fn handle(&self) -> Result { + pub fn handle(&self) -> Result { if let TcLinkInner::NlLink(n) = self.inner() { Ok(n.handle) } else { - Err(TcError::InvalidLinkOperation.into()) + Err(InternalLinkError::InvalidLinkOperation.into()) } } } diff --git a/aya/src/programs/tp_btf.rs b/aya/src/programs/tp_btf.rs index 8c235d43f..c345410a5 100644 --- a/aya/src/programs/tp_btf.rs +++ b/aya/src/programs/tp_btf.rs @@ -1,6 +1,7 @@ //! BTF-enabled raw tracepoints. use crate::{ + errors::LinkError, generated::{bpf_attach_type::BPF_TRACE_RAW_TP, bpf_prog_type::BPF_PROG_TYPE_TRACING}, obj::btf::{Btf, BtfKind}, programs::{ @@ -68,14 +69,14 @@ impl BtfTracePoint { /// Attaches the program. /// /// The returned value can be used to detach, see [BtfTracePoint::detach]. - pub fn attach(&mut self) -> Result { + pub fn attach(&mut self) -> Result { attach_raw_tracepoint(&mut self.data, None) } /// Detaches the program. /// /// See [BtfTracePoint::attach]. - pub fn detach(&mut self, link_id: BtfTracePointLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: BtfTracePointLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -86,7 +87,7 @@ impl BtfTracePoint { pub fn take_link( &mut self, link_id: BtfTracePointLinkId, - ) -> Result { + ) -> Result { self.data.take_link(link_id) } } diff --git a/aya/src/programs/trace_point.rs b/aya/src/programs/trace_point.rs index 4ce0be9a6..1c5825b83 100644 --- a/aya/src/programs/trace_point.rs +++ b/aya/src/programs/trace_point.rs @@ -1,33 +1,18 @@ //! Tracepoint programs. -use std::{fs, io, os::fd::AsFd as _, path::Path}; - -use thiserror::Error; +use std::{fs, os::fd::AsFd as _, path::Path}; use crate::{ + errors::LinkError, generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_TRACEPOINT}, programs::{ define_link_wrapper, load_program, perf_attach::{perf_attach, PerfLinkIdInner, PerfLinkInner}, utils::find_tracefs_path, - FdLink, LinkError, ProgramData, ProgramError, + FdLink, ProgramData, ProgramError, }, - sys::{bpf_link_get_info_by_fd, perf_event_open_trace_point, SyscallError}, + sys::{bpf_link_get_info_by_fd, perf_event_open_trace_point}, }; -/// The type returned when attaching a [`TracePoint`] fails. -#[derive(Debug, Error)] -pub enum TracePointError { - /// Error detaching from debugfs - #[error("`{filename}`")] - FileError { - /// The file name - filename: String, - /// The [`io::Error`] returned from the file operation - #[source] - io_error: io::Error, - }, -} - /// A program that can be attached at a pre-defined kernel trace point. /// /// The kernel provides a set of pre-defined trace points that eBPF programs can @@ -67,16 +52,12 @@ impl TracePoint { /// `/sys/kernel/debug/tracing/events`. /// /// The returned value can be used to detach, see [TracePoint::detach]. - pub fn attach(&mut self, category: &str, name: &str) -> Result { + pub fn attach(&mut self, category: &str, name: &str) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); let tracefs = find_tracefs_path()?; let id = read_sys_fs_trace_point_id(tracefs, category, name.as_ref())?; - let fd = - perf_event_open_trace_point(id, None).map_err(|(_code, io_error)| SyscallError { - call: "perf_event_open_trace_point", - io_error, - })?; + let fd = perf_event_open_trace_point(id, None)?; let link = perf_attach(prog_fd, fd)?; self.data.links.insert(TracePointLink::new(link)) @@ -85,7 +66,7 @@ impl TracePoint { /// Detaches from a trace point. /// /// See [TracePoint::attach]. - pub fn detach(&mut self, link_id: TracePointLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: TracePointLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -93,7 +74,7 @@ impl TracePoint { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: TracePointLinkId) -> Result { + pub fn take_link(&mut self, link_id: TracePointLinkId) -> Result { self.data.take_link(link_id) } } @@ -135,20 +116,11 @@ pub(crate) fn read_sys_fs_trace_point_id( tracefs: &Path, category: &str, name: &Path, -) -> Result { +) -> Result { let file = tracefs.join("events").join(category).join(name).join("id"); - let id = fs::read_to_string(&file).map_err(|io_error| TracePointError::FileError { - filename: file.display().to_string(), - io_error, - })?; - let id = id - .trim() - .parse::() - .map_err(|error| TracePointError::FileError { - filename: file.display().to_string(), - io_error: io::Error::new(io::ErrorKind::Other, error), - })?; + let id = fs::read_to_string(&file)?; + let id = id.trim().parse::()?; Ok(id) } diff --git a/aya/src/programs/uprobe.rs b/aya/src/programs/uprobe.rs index 737166ba0..8660106e1 100644 --- a/aya/src/programs/uprobe.rs +++ b/aya/src/programs/uprobe.rs @@ -1,7 +1,6 @@ //! User space probes. use std::{ borrow::Cow, - error::Error, ffi::{CStr, OsStr, OsString}, fs, io::{self, BufRead, Cursor, Read}, @@ -13,15 +12,15 @@ use std::{ use libc::pid_t; use object::{Object, ObjectSection, ObjectSymbol, Symbol}; -use thiserror::Error; use crate::{ + errors::{InternalLinkError, LinkError, ResolveSymbolError}, generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_KPROBE}, programs::{ define_link_wrapper, load_program, perf_attach::{PerfLinkIdInner, PerfLinkInner}, probe::{attach, OsStringExt as _, ProbeKind}, - FdLink, LinkError, ProgramData, ProgramError, + FdLink, ProgramData, ProgramError, }, sys::bpf_link_get_info_by_fd, VerifierLogLevel, @@ -81,14 +80,11 @@ impl UProbe { offset: u64, target: T, pid: Option, - ) -> Result { + ) -> Result { let path = resolve_attach_path(target.as_ref(), pid)?; let sym_offset = if let Some(fn_name) = fn_name { - resolve_symbol(&path, fn_name).map_err(|error| UProbeError::SymbolError { - symbol: fn_name.to_string(), - error: Box::new(error), - })? + resolve_symbol(&path, fn_name)? } else { 0 }; @@ -100,7 +96,7 @@ impl UProbe { /// Detaches the program. /// /// See [UProbe::attach]. - pub fn detach(&mut self, link_id: UProbeLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: UProbeLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -108,7 +104,7 @@ impl UProbe { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: UProbeLinkId) -> Result { + pub fn take_link(&mut self, link_id: UProbeLinkId) -> Result { self.data.take_link(link_id) } @@ -124,15 +120,12 @@ impl UProbe { } } -fn resolve_attach_path(target: &Path, pid: Option) -> Result, UProbeError> { +fn resolve_attach_path(target: &Path, pid: Option) -> Result, LinkError> { // Look up the path for the target. If it there is a pid, and the target is a library name // that is in the process's memory map, use the path of that library. Otherwise, use the target as-is. pid.and_then(|pid| { find_lib_in_proc_maps(pid, target) - .map_err(|io_error| UProbeError::FileError { - filename: Path::new("/proc").join(pid.to_string()).join("maps"), - io_error, - }) + .map_err(Into::into) .map(|v| v.map(Cow::Owned)) .transpose() }) @@ -140,14 +133,15 @@ fn resolve_attach_path(target: &Path, pid: Option) -> Result for UProbeLink { } } -/// The type returned when attaching an [`UProbe`] fails. -#[derive(Debug, Error)] -pub enum UProbeError { - /// There was an error parsing `/etc/ld.so.cache`. - #[error("error reading `{}` file", LD_SO_CACHE_FILE)] - InvalidLdSoCache { - /// the original [`io::Error`] - #[source] - io_error: &'static io::Error, - }, - - /// The target program could not be found. - #[error("could not resolve uprobe target `{path}`")] - InvalidTarget { - /// path to target - path: PathBuf, - }, - - /// There was an error resolving the target symbol. - #[error("error resolving symbol")] - SymbolError { - /// symbol name - symbol: String, - /// the original error - #[source] - error: Box, - }, - - /// There was an error accessing `filename`. - #[error("`{filename}`")] - FileError { - /// The file name - filename: PathBuf, - /// The [`io::Error`] returned from the file operation - #[source] - io_error: io::Error, - }, -} - fn proc_maps_libs(pid: pid_t) -> Result, io::Error> { use std::os::unix::ffi::OsStrExt as _; @@ -412,30 +367,6 @@ impl LdSoCache { } } -#[derive(Error, Debug)] -enum ResolveSymbolError { - #[error(transparent)] - Io(#[from] io::Error), - - #[error("error parsing ELF")] - Object(#[from] object::Error), - - #[error("unknown symbol `{0}`")] - Unknown(String), - - #[error("symbol `{0}` does not appear in section")] - NotInSection(String), - - #[error("symbol `{0}` in section `{1:?}` which has no offset")] - SectionFileRangeNone(String, Result), - - #[error("failed to access debuglink file `{0}`: `{1}`")] - DebuglinkAccessError(String, io::Error), - - #[error("symbol `{0}` not found, mismatched build IDs in main and debug files")] - BuildIdMismatch(String), -} - fn construct_debuglink_path( filename: &[u8], main_path: &Path, diff --git a/aya/src/programs/utils.rs b/aya/src/programs/utils.rs index 9eabbd81e..1a6946eb8 100644 --- a/aya/src/programs/utils.rs +++ b/aya/src/programs/utils.rs @@ -10,28 +10,25 @@ use std::{ }; use crate::{ + errors::LinkError, programs::{FdLink, Link, ProgramData, ProgramError}, - sys::{bpf_raw_tracepoint_open, SyscallError}, + sys::bpf_raw_tracepoint_open, }; /// Attaches the program to a raw tracepoint. pub(crate) fn attach_raw_tracepoint>( program_data: &mut ProgramData, tp_name: Option<&CStr>, -) -> Result { +) -> Result { let prog_fd = program_data.fd()?; let prog_fd = prog_fd.as_fd(); - let pfd = - bpf_raw_tracepoint_open(tp_name, prog_fd).map_err(|(_code, io_error)| SyscallError { - call: "bpf_raw_tracepoint_open", - io_error, - })?; + let pfd = bpf_raw_tracepoint_open(tp_name, prog_fd)?; program_data.links.insert(FdLink::new(pfd).into()) } /// Find tracefs filesystem path. -pub(crate) fn find_tracefs_path() -> Result<&'static Path, ProgramError> { +pub(crate) fn find_tracefs_path() -> Result<&'static Path, LinkError> { static TRACE_FS: LazyLock> = LazyLock::new(|| { [ Path::new("/sys/kernel/tracing"), diff --git a/aya/src/programs/xdp.rs b/aya/src/programs/xdp.rs index 66b32b324..3edb283a6 100644 --- a/aya/src/programs/xdp.rs +++ b/aya/src/programs/xdp.rs @@ -3,43 +3,27 @@ use std::{ ffi::CString, hash::Hash, - io, os::fd::{AsFd as _, AsRawFd as _, BorrowedFd, RawFd}, path::Path, }; use libc::if_nametoindex; -use thiserror::Error; use crate::{ + errors::{InternalLinkError, LinkError}, generated::{ bpf_link_type, bpf_prog_type, XDP_FLAGS_DRV_MODE, XDP_FLAGS_HW_MODE, XDP_FLAGS_REPLACE, XDP_FLAGS_SKB_MODE, XDP_FLAGS_UPDATE_IF_NOEXIST, }, obj::programs::XdpAttachType, - programs::{ - define_link_wrapper, load_program, FdLink, Link, LinkError, ProgramData, ProgramError, - }, + programs::{define_link_wrapper, load_program, FdLink, Link, ProgramData, ProgramError}, sys::{ bpf_link_create, bpf_link_get_info_by_fd, bpf_link_update, netlink_set_xdp_fd, LinkTarget, - SyscallError, }, util::KernelVersion, VerifierLogLevel, }; -/// The type returned when attaching an [`Xdp`] program fails on kernels `< 5.9`. -#[derive(Debug, Error)] -pub enum XdpError { - /// netlink error while attaching XDP program - #[error("netlink error while attaching XDP program")] - NetlinkError { - /// the [`io::Error`] from the netlink call - #[source] - io_error: io::Error, - }, -} - bitflags::bitflags! { /// Flags passed to [`Xdp::attach()`]. #[derive(Clone, Copy, Debug, Default)] @@ -105,14 +89,15 @@ impl Xdp { /// kernels `>= 5.9.0`, and instead /// [`XdpError::NetlinkError`] is returned for older /// kernels. - pub fn attach(&mut self, interface: &str, flags: XdpFlags) -> Result { + pub fn attach(&mut self, interface: &str, flags: XdpFlags) -> Result { // TODO: avoid this unwrap by adding a new error variant. let c_interface = CString::new(interface).unwrap(); let if_index = unsafe { if_nametoindex(c_interface.as_ptr()) }; if if_index == 0 { - return Err(ProgramError::UnknownInterface { + return Err(InternalLinkError::UnknownInterface { name: interface.to_string(), - }); + } + .into()); } self.attach_to_if_index(if_index, flags) } @@ -131,7 +116,7 @@ impl Xdp { &mut self, if_index: u32, flags: XdpFlags, - ) -> Result { + ) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); @@ -151,18 +136,14 @@ impl Xdp { None, flags.bits(), None, - ) - .map_err(|(_, io_error)| SyscallError { - call: "bpf_link_create", - io_error, - })?; + )?; self.data .links .insert(XdpLink::new(XdpLinkInner::FdLink(FdLink::new(link_fd)))) } else { let if_index = if_index as i32; unsafe { netlink_set_xdp_fd(if_index, Some(prog_fd), None, flags.bits()) } - .map_err(|io_error| XdpError::NetlinkError { io_error })?; + .map_err(|io_error| InternalLinkError::NetlinkError { io_error })?; let prog_fd = prog_fd.as_raw_fd(); self.data @@ -193,7 +174,7 @@ impl Xdp { /// Detaches the program. /// /// See [Xdp::attach]. - pub fn detach(&mut self, link_id: XdpLinkId) -> Result<(), ProgramError> { + pub fn detach(&mut self, link_id: XdpLinkId) -> Result<(), LinkError> { self.data.links.remove(link_id) } @@ -201,25 +182,20 @@ impl Xdp { /// /// The link will be detached on `Drop` and the caller is now responsible /// for managing its lifetime. - pub fn take_link(&mut self, link_id: XdpLinkId) -> Result { + pub fn take_link(&mut self, link_id: XdpLinkId) -> Result { self.data.take_link(link_id) } /// Atomically replaces the program referenced by the provided link. /// /// Ownership of the link will transfer to this program. - pub fn attach_to_link(&mut self, link: XdpLink) -> Result { + pub fn attach_to_link(&mut self, link: XdpLink) -> Result { let prog_fd = self.fd()?; let prog_fd = prog_fd.as_fd(); match link.into_inner() { XdpLinkInner::FdLink(fd_link) => { let link_fd = fd_link.fd; - bpf_link_update(link_fd.as_fd(), prog_fd, None, 0).map_err(|(_, io_error)| { - SyscallError { - call: "bpf_link_update", - io_error, - } - })?; + bpf_link_update(link_fd.as_fd(), prog_fd, None, 0)?; self.data .links @@ -239,7 +215,7 @@ impl Xdp { Some(old_prog_fd), replace_flags.bits(), ) - .map_err(|io_error| XdpError::NetlinkError { io_error })?; + .map_err(|io_error| InternalLinkError::NetlinkError { io_error })?; } let prog_fd = prog_fd.as_raw_fd(); @@ -269,7 +245,7 @@ impl Link for NlLink { (self.if_index, self.prog_fd) } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { let flags = if KernelVersion::current().unwrap() >= KernelVersion::new(5, 7, 0) { self.flags.bits() | XDP_FLAGS_REPLACE } else { @@ -304,7 +280,7 @@ impl Link for XdpLinkInner { } } - fn detach(self) -> Result<(), ProgramError> { + fn detach(self) -> Result<(), LinkError> { match self { Self::FdLink(link) => link.detach(), Self::NlLink(link) => link.detach(), diff --git a/aya/src/sys/bpf.rs b/aya/src/sys/bpf.rs index a405b3bee..94ee4a9b8 100644 --- a/aya/src/sys/bpf.rs +++ b/aya/src/sys/bpf.rs @@ -16,9 +16,11 @@ use obj::{ EbpfSectionKind, VerifierLog, }; +use super::BpfCmd; use crate::{ + errors::SysError, generated::{ - bpf_attach_type, bpf_attr, bpf_btf_info, bpf_cmd, bpf_insn, bpf_link_info, bpf_map_info, + bpf_attach_type, bpf_attr, bpf_btf_info, bpf_insn, bpf_link_info, bpf_map_info, bpf_map_type, bpf_prog_info, bpf_prog_type, BPF_F_REPLACE, }, maps::{MapData, PerCpuValues}, @@ -31,7 +33,7 @@ use crate::{ copy_instructions, }, programs::links::LinkRef, - sys::{syscall, SysResult, Syscall, SyscallError}, + sys::{syscall, SysResult, Syscall}, util::KernelVersion, Btf, Pod, VerifierLogLevel, BPF_OBJ_NAME_LEN, FEATURES, }; @@ -95,7 +97,7 @@ pub(crate) fn bpf_create_map( } // SAFETY: BPF_MAP_CREATE returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_MAP_CREATE, &mut attr) } + unsafe { fd_sys_bpf(BpfCmd::MapCreate, &mut attr) } } pub(crate) fn bpf_pin_object(fd: BorrowedFd<'_>, path: &CStr) -> SysResult { @@ -103,7 +105,7 @@ pub(crate) fn bpf_pin_object(fd: BorrowedFd<'_>, path: &CStr) -> SysResult let u = unsafe { &mut attr.__bindgen_anon_4 }; u.bpf_fd = fd.as_raw_fd() as u32; u.pathname = path.as_ptr() as u64; - sys_bpf(bpf_cmd::BPF_OBJ_PIN, &mut attr) + sys_bpf(BpfCmd::ObjPin, &mut attr) } /// Introduced in kernel v4.4. @@ -112,7 +114,7 @@ pub(crate) fn bpf_get_object(path: &CStr) -> SysResult { let u = unsafe { &mut attr.__bindgen_anon_4 }; u.pathname = path.as_ptr() as u64; // SAFETY: BPF_OBJ_GET returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_OBJ_GET, &mut attr) } + unsafe { fd_sys_bpf(BpfCmd::ObjGet, &mut attr) } } pub(crate) struct EbpfLoadProgramAttrs<'a> { @@ -202,7 +204,7 @@ fn lookup( fd: BorrowedFd<'_>, key: Option<&K>, flags: u64, - cmd: bpf_cmd, + cmd: BpfCmd, ) -> SysResult> { let mut attr = unsafe { mem::zeroed::() }; let mut value = MaybeUninit::zeroed(); @@ -217,7 +219,9 @@ fn lookup( match sys_bpf(cmd, &mut attr) { Ok(_) => Ok(Some(unsafe { value.assume_init() })), - Err((_, io_error)) if io_error.raw_os_error() == Some(ENOENT) => Ok(None), + Err((_, SysError::Syscall { io_error, .. })) if io_error.raw_os_error() == Some(ENOENT) => { + Ok(None) + } Err(e) => Err(e), } } @@ -227,7 +231,7 @@ pub(crate) fn bpf_map_lookup_elem( key: &K, flags: u64, ) -> SysResult> { - lookup(fd, Some(key), flags, bpf_cmd::BPF_MAP_LOOKUP_ELEM) + lookup(fd, Some(key), flags, BpfCmd::MapLookupElem) } pub(crate) fn bpf_map_lookup_and_delete_elem( @@ -235,7 +239,7 @@ pub(crate) fn bpf_map_lookup_and_delete_elem( key: Option<&K>, flags: u64, ) -> SysResult> { - lookup(fd, key, flags, bpf_cmd::BPF_MAP_LOOKUP_AND_DELETE_ELEM) + lookup(fd, key, flags, BpfCmd::MapLookupAndDeleteElem) } pub(crate) fn bpf_map_lookup_elem_per_cpu( @@ -243,10 +247,13 @@ pub(crate) fn bpf_map_lookup_elem_per_cpu( key: &K, flags: u64, ) -> SysResult>> { - let mut mem = PerCpuValues::::alloc_kernel_mem().map_err(|io_error| (-1, io_error))?; + let mut mem = PerCpuValues::::alloc_kernel_mem() + .map_err(|io_error| (-1, SysError::Other(Box::new(io_error))))?; match bpf_map_lookup_elem_ptr(fd, Some(key), mem.as_mut_ptr(), flags) { Ok(_) => Ok(Some(unsafe { PerCpuValues::from_kernel_mem(mem) })), - Err((_, io_error)) if io_error.raw_os_error() == Some(ENOENT) => Ok(None), + Err((_, SysError::Syscall { io_error, .. })) if io_error.raw_os_error() == Some(ENOENT) => { + Ok(None) + } Err(e) => Err(e), } } @@ -267,9 +274,11 @@ pub(crate) fn bpf_map_lookup_elem_ptr( u.__bindgen_anon_1.value = value as u64; u.flags = flags; - match sys_bpf(bpf_cmd::BPF_MAP_LOOKUP_ELEM, &mut attr) { + match sys_bpf(BpfCmd::MapLookupElem, &mut attr) { Ok(_) => Ok(Some(())), - Err((_, io_error)) if io_error.raw_os_error() == Some(ENOENT) => Ok(None), + Err((_, SysError::Syscall { io_error, .. })) if io_error.raw_os_error() == Some(ENOENT) => { + Ok(None) + } Err(e) => Err(e), } } @@ -290,7 +299,7 @@ pub(crate) fn bpf_map_update_elem( u.__bindgen_anon_1.value = value as *const _ as u64; u.flags = flags; - sys_bpf(bpf_cmd::BPF_MAP_UPDATE_ELEM, &mut attr) + sys_bpf(BpfCmd::MapUpdateElem, &mut attr) } pub(crate) fn bpf_map_push_elem( @@ -305,7 +314,7 @@ pub(crate) fn bpf_map_push_elem( u.__bindgen_anon_1.value = value as *const _ as u64; u.flags = flags; - sys_bpf(bpf_cmd::BPF_MAP_UPDATE_ELEM, &mut attr) + sys_bpf(BpfCmd::MapUpdateElem, &mut attr) } pub(crate) fn bpf_map_update_elem_ptr( @@ -322,7 +331,7 @@ pub(crate) fn bpf_map_update_elem_ptr( u.__bindgen_anon_1.value = value as u64; u.flags = flags; - sys_bpf(bpf_cmd::BPF_MAP_UPDATE_ELEM, &mut attr) + sys_bpf(BpfCmd::MapUpdateElem, &mut attr) } pub(crate) fn bpf_map_update_elem_per_cpu( @@ -331,7 +340,9 @@ pub(crate) fn bpf_map_update_elem_per_cpu( values: &PerCpuValues, flags: u64, ) -> SysResult { - let mut mem = values.build_kernel_mem().map_err(|e| (-1, e))?; + let mut mem = values + .build_kernel_mem() + .map_err(|e| (-1, SysError::Other(Box::new(e))))?; bpf_map_update_elem_ptr(fd, key, mem.as_mut_ptr(), flags) } @@ -342,7 +353,7 @@ pub(crate) fn bpf_map_delete_elem(fd: BorrowedFd<'_>, key: &K) -> SysRes u.map_fd = fd.as_raw_fd() as u32; u.key = key as *const _ as u64; - sys_bpf(bpf_cmd::BPF_MAP_DELETE_ELEM, &mut attr) + sys_bpf(BpfCmd::MapDeleteElem, &mut attr) } pub(crate) fn bpf_map_get_next_key( @@ -359,9 +370,11 @@ pub(crate) fn bpf_map_get_next_key( } u.__bindgen_anon_1.next_key = &mut next_key as *mut _ as u64; - match sys_bpf(bpf_cmd::BPF_MAP_GET_NEXT_KEY, &mut attr) { + match sys_bpf(BpfCmd::MapGetNextKey, &mut attr) { Ok(_) => Ok(Some(unsafe { next_key.assume_init() })), - Err((_, io_error)) if io_error.raw_os_error() == Some(ENOENT) => Ok(None), + Err((_, SysError::Syscall { io_error, .. })) if io_error.raw_os_error() == Some(ENOENT) => { + Ok(None) + } Err(e) => Err(e), } } @@ -371,7 +384,7 @@ pub(crate) fn bpf_map_freeze(fd: BorrowedFd<'_>) -> SysResult { let mut attr = unsafe { mem::zeroed::() }; let u = unsafe { &mut attr.__bindgen_anon_2 }; u.map_fd = fd.as_raw_fd() as u32; - sys_bpf(bpf_cmd::BPF_MAP_FREEZE, &mut attr) + sys_bpf(BpfCmd::MapFreeze, &mut attr) } pub(crate) enum LinkTarget<'f> { @@ -428,7 +441,7 @@ pub(crate) fn bpf_link_create( }; // SAFETY: BPF_LINK_CREATE returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_LINK_CREATE, &mut attr) } + unsafe { fd_sys_bpf(BpfCmd::LinkCreate, &mut attr) } } // since kernel 5.7 @@ -449,7 +462,7 @@ pub(crate) fn bpf_link_update( attr.link_update.flags = flags; } - sys_bpf(bpf_cmd::BPF_LINK_UPDATE, &mut attr) + sys_bpf(BpfCmd::LinkUpdate, &mut attr) } pub(crate) fn bpf_prog_attach( @@ -457,7 +470,7 @@ pub(crate) fn bpf_prog_attach( target_fd: BorrowedFd<'_>, attach_type: bpf_attach_type, flags: u32, -) -> Result<(), SyscallError> { +) -> Result<(), SysError> { let mut attr = unsafe { mem::zeroed::() }; attr.__bindgen_anon_5.attach_bpf_fd = prog_fd.as_raw_fd() as u32; @@ -465,12 +478,9 @@ pub(crate) fn bpf_prog_attach( attr.__bindgen_anon_5.attach_type = attach_type as u32; attr.__bindgen_anon_5.attach_flags = flags; - let ret = sys_bpf(bpf_cmd::BPF_PROG_ATTACH, &mut attr).map_err(|(code, io_error)| { + let ret = sys_bpf(BpfCmd::ProgAttach, &mut attr).map_err(|(code, error)| { assert_eq!(code, -1); - SyscallError { - call: "bpf_prog_attach", - io_error, - } + error })?; assert_eq!(ret, 0); Ok(()) @@ -480,19 +490,16 @@ pub(crate) fn bpf_prog_detach( prog_fd: BorrowedFd<'_>, target_fd: BorrowedFd<'_>, attach_type: bpf_attach_type, -) -> Result<(), SyscallError> { +) -> Result<(), SysError> { let mut attr = unsafe { mem::zeroed::() }; attr.__bindgen_anon_5.attach_bpf_fd = prog_fd.as_raw_fd() as u32; attr.__bindgen_anon_5.__bindgen_anon_1.target_fd = target_fd.as_raw_fd() as u32; attr.__bindgen_anon_5.attach_type = attach_type as u32; - let ret = sys_bpf(bpf_cmd::BPF_PROG_DETACH, &mut attr).map_err(|(code, io_error)| { + let ret = sys_bpf(BpfCmd::ProgDetach, &mut attr).map_err(|(code, e)| { assert_eq!(code, -1); - SyscallError { - call: "bpf_prog_detach", - io_error, - } + e })?; assert_eq!(ret, 0); Ok(()) @@ -527,7 +534,7 @@ pub(crate) fn bpf_prog_query( attr.query.query_flags = query_flags; attr.query.__bindgen_anon_2.prog_cnt = prog_ids.len() as u32; attr.query.prog_ids = prog_ids.as_mut_ptr() as u64; - let ret = sys_bpf(bpf_cmd::BPF_PROG_QUERY, &mut attr); + let ret = sys_bpf(BpfCmd::ProgQuery, &mut attr); *prog_cnt = unsafe { attr.query.__bindgen_anon_2.prog_cnt }; *revision = unsafe { attr.query.revision }; @@ -540,17 +547,14 @@ pub(crate) fn bpf_prog_query( } /// Introduced in kernel v4.13. -pub(crate) fn bpf_prog_get_fd_by_id(prog_id: u32) -> Result { +pub(crate) fn bpf_prog_get_fd_by_id(prog_id: u32) -> Result { let mut attr = unsafe { mem::zeroed::() }; attr.__bindgen_anon_6.__bindgen_anon_1.prog_id = prog_id; // SAFETY: BPF_PROG_GET_FD_BY_ID returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_PROG_GET_FD_BY_ID, &mut attr) }.map_err(|(code, io_error)| { + unsafe { fd_sys_bpf(BpfCmd::ProgGetFdById, &mut attr) }.map_err(|(code, e)| { assert_eq!(code, -1); - SyscallError { - call: "bpf_prog_get_fd_by_id", - io_error, - } + e }) } @@ -558,7 +562,7 @@ pub(crate) fn bpf_prog_get_fd_by_id(prog_id: u32) -> Result( fd: BorrowedFd<'_>, init: F, -) -> Result { +) -> Result { let mut attr = unsafe { mem::zeroed::() }; let mut info = unsafe { mem::zeroed() }; @@ -568,17 +572,14 @@ fn bpf_obj_get_info_by_fd( attr.info.info = &info as *const _ as u64; attr.info.info_len = mem::size_of_val(&info) as u32; - match sys_bpf(bpf_cmd::BPF_OBJ_GET_INFO_BY_FD, &mut attr) { + match sys_bpf(BpfCmd::ObjGetInfoByFd, &mut attr) { Ok(code) => { assert_eq!(code, 0); Ok(info) } - Err((code, io_error)) => { + Err((code, e)) => { assert_eq!(code, -1); - Err(SyscallError { - call: "bpf_obj_get_info_by_fd", - io_error, - }) + Err(e) } } } @@ -587,7 +588,7 @@ fn bpf_obj_get_info_by_fd( pub(crate) fn bpf_prog_get_info_by_fd( fd: BorrowedFd<'_>, map_ids: &mut [u32], -) -> Result { +) -> Result { // An `E2BIG` error can occur on kernels below v4.15 when handing over a large struct where the // extra space is not all-zero bytes. bpf_obj_get_info_by_fd(fd, |info: &mut bpf_prog_info| { @@ -599,47 +600,41 @@ pub(crate) fn bpf_prog_get_info_by_fd( } /// Introduced in kernel v4.13. -pub(crate) fn bpf_map_get_fd_by_id(map_id: u32) -> Result { +pub(crate) fn bpf_map_get_fd_by_id(map_id: u32) -> Result { let mut attr = unsafe { mem::zeroed::() }; attr.__bindgen_anon_6.__bindgen_anon_1.map_id = map_id; // SAFETY: BPF_MAP_GET_FD_BY_ID returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_MAP_GET_FD_BY_ID, &mut attr) }.map_err(|(code, io_error)| { + unsafe { fd_sys_bpf(BpfCmd::MapGetFdById, &mut attr) }.map_err(|(code, e)| { assert_eq!(code, -1); - SyscallError { - call: "bpf_map_get_fd_by_id", - io_error, - } + e }) } -pub(crate) fn bpf_map_get_info_by_fd(fd: BorrowedFd<'_>) -> Result { +pub(crate) fn bpf_map_get_info_by_fd(fd: BorrowedFd<'_>) -> Result { bpf_obj_get_info_by_fd(fd, |_| {}) } -pub(crate) fn bpf_link_get_fd_by_id(link_id: u32) -> Result { +pub(crate) fn bpf_link_get_fd_by_id(link_id: u32) -> Result { let mut attr = unsafe { mem::zeroed::() }; attr.__bindgen_anon_6.__bindgen_anon_1.link_id = link_id; // SAFETY: BPF_LINK_GET_FD_BY_ID returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_LINK_GET_FD_BY_ID, &mut attr) }.map_err(|(code, io_error)| { + unsafe { fd_sys_bpf(BpfCmd::LinkGetFdById, &mut attr) }.map_err(|(code, e)| { assert_eq!(code, -1); - SyscallError { - call: "bpf_link_get_fd_by_id", - io_error, - } + e }) } -pub(crate) fn bpf_link_get_info_by_fd(fd: BorrowedFd<'_>) -> Result { +pub(crate) fn bpf_link_get_info_by_fd(fd: BorrowedFd<'_>) -> Result { bpf_obj_get_info_by_fd(fd, |_| {}) } pub(crate) fn btf_obj_get_info_by_fd( fd: BorrowedFd<'_>, buf: &mut [u8], -) -> Result { +) -> Result { bpf_obj_get_info_by_fd(fd, |info: &mut bpf_btf_info| { info.btf = buf.as_mut_ptr() as _; info.btf_size = buf.len() as _; @@ -659,7 +654,7 @@ pub(crate) fn bpf_raw_tracepoint_open( attr.raw_tracepoint.prog_fd = prog_fd.as_raw_fd() as u32; // SAFETY: BPF_RAW_TRACEPOINT_OPEN returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_RAW_TRACEPOINT_OPEN, &mut attr) } + unsafe { fd_sys_bpf(BpfCmd::RawTracepointOpen, &mut attr) } } pub(crate) fn bpf_load_btf( @@ -677,35 +672,32 @@ pub(crate) fn bpf_load_btf( u.btf_log_size = log_buf.len() as u32; } // SAFETY: `BPF_BTF_LOAD` returns a newly created fd. - unsafe { fd_sys_bpf(bpf_cmd::BPF_BTF_LOAD, &mut attr) } + unsafe { fd_sys_bpf(BpfCmd::BtfLoad, &mut attr) } } // SAFETY: only use for bpf_cmd that return a new file descriptor on success. -unsafe fn fd_sys_bpf(cmd: bpf_cmd, attr: &mut bpf_attr) -> SysResult { +unsafe fn fd_sys_bpf(cmd: BpfCmd, attr: &mut bpf_attr) -> SysResult { let fd = sys_bpf(cmd, attr)?; let fd = fd.try_into().map_err(|_| { ( fd, - io::Error::new( + SysError::Other(Box::new(io::Error::new( io::ErrorKind::InvalidData, format!("{cmd:?}: invalid fd returned: {fd}"), - ), + ))), ) })?; Ok(crate::MockableFd::from_raw_fd(fd)) } -pub(crate) fn bpf_btf_get_fd_by_id(id: u32) -> Result { +pub(crate) fn bpf_btf_get_fd_by_id(id: u32) -> Result { let mut attr = unsafe { mem::zeroed::() }; attr.__bindgen_anon_6.__bindgen_anon_1.btf_id = id; // SAFETY: BPF_BTF_GET_FD_BY_ID returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_BTF_GET_FD_BY_ID, &mut attr) }.map_err(|(code, io_error)| { + unsafe { fd_sys_bpf(BpfCmd::BtfGetNextId, &mut attr) }.map_err(|(code, e)| { assert_eq!(code, -1); - SyscallError { - call: "bpf_btf_get_fd_by_id", - io_error, - } + e }) } @@ -865,7 +857,7 @@ pub(crate) fn is_perf_link_supported() -> bool { // Uses an invalid target FD so we get EBADF if supported. bpf_link_create(fd, LinkTarget::IfIndex(u32::MAX), bpf_attach_type::BPF_PERF_EVENT, None, 0, None), // Returns EINVAL if unsupported. EBADF if supported. - Err((_, e)) if e.raw_os_error() == Some(libc::EBADF), + Err((_, SysError::Syscall{ call: _, io_error })) if io_error.raw_os_error() == Some(libc::EBADF), ) } else { false @@ -983,7 +975,7 @@ pub(crate) fn is_prog_id_supported(map_type: bpf_map_type) -> bool { u.map_flags = 0; // SAFETY: BPF_MAP_CREATE returns a new file descriptor. - let fd = unsafe { fd_sys_bpf(bpf_cmd::BPF_MAP_CREATE, &mut attr) }; + let fd = unsafe { fd_sys_bpf(BpfCmd::MapCreate, &mut attr) }; fd.is_ok() } @@ -1145,18 +1137,14 @@ pub(crate) fn is_btf_type_tag_supported() -> bool { fn bpf_prog_load(attr: &mut bpf_attr) -> SysResult { // SAFETY: BPF_PROG_LOAD returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_PROG_LOAD, attr) } + unsafe { fd_sys_bpf(BpfCmd::ProgLoad, attr) } } -fn sys_bpf(cmd: bpf_cmd, attr: &mut bpf_attr) -> SysResult { +fn sys_bpf(cmd: BpfCmd, attr: &mut bpf_attr) -> SysResult { syscall(Syscall::Ebpf { cmd, attr }) } -fn bpf_obj_get_next_id( - id: u32, - cmd: bpf_cmd, - name: &'static str, -) -> Result, SyscallError> { +fn bpf_obj_get_next_id(id: u32, cmd: BpfCmd) -> Result, SysError> { let mut attr = unsafe { mem::zeroed::() }; let u = unsafe { &mut attr.__bindgen_anon_6 }; u.__bindgen_anon_1.start_id = id; @@ -1165,66 +1153,54 @@ fn bpf_obj_get_next_id( assert_eq!(code, 0); Ok(Some(unsafe { attr.__bindgen_anon_6.next_id })) } - Err((code, io_error)) => { + Err((code, SysError::Syscall { call, io_error })) => { assert_eq!(code, -1); if io_error.raw_os_error() == Some(ENOENT) { Ok(None) } else { - Err(SyscallError { - call: name, - io_error, - }) + Err(SysError::Syscall { call, io_error }) } } + Err((_, e)) => Err(SysError::Other(Box::new(e))), } } -fn iter_obj_ids( - cmd: bpf_cmd, - name: &'static str, -) -> impl Iterator> { +fn iter_obj_ids(cmd: BpfCmd) -> impl Iterator> { let mut current_id = Some(0); iter::from_fn(move || { let next_id = { let current_id = current_id?; - bpf_obj_get_next_id(current_id, cmd, name).transpose() + bpf_obj_get_next_id(current_id, cmd).transpose() }; current_id = next_id.as_ref().and_then(|next_id| match next_id { Ok(next_id) => Some(*next_id), - Err(SyscallError { .. }) => None, + Err(_) => None, }); next_id }) } /// Introduced in kernel v4.13. -pub(crate) fn iter_prog_ids() -> impl Iterator> { - iter_obj_ids(bpf_cmd::BPF_PROG_GET_NEXT_ID, "bpf_prog_get_next_id") +pub(crate) fn iter_prog_ids() -> impl Iterator> { + iter_obj_ids(BpfCmd::ProgGetNextId) } -pub(crate) fn iter_link_ids() -> impl Iterator> { - iter_obj_ids(bpf_cmd::BPF_LINK_GET_NEXT_ID, "bpf_link_get_next_id") +pub(crate) fn iter_link_ids() -> impl Iterator> { + iter_obj_ids(BpfCmd::LinkGetNextId) } /// Introduced in kernel v4.13. -pub(crate) fn iter_map_ids() -> impl Iterator> { - iter_obj_ids(bpf_cmd::BPF_MAP_GET_NEXT_ID, "bpf_map_get_next_id") +pub(crate) fn iter_map_ids() -> impl Iterator> { + iter_obj_ids(BpfCmd::MapGetNextId) } /// Introduced in kernel v5.8. -pub(crate) fn bpf_enable_stats( - stats_type: bpf_stats_type, -) -> Result { +pub(crate) fn bpf_enable_stats(stats_type: bpf_stats_type) -> Result { let mut attr = unsafe { mem::zeroed::() }; attr.enable_stats.type_ = stats_type as u32; // SAFETY: BPF_ENABLE_STATS returns a new file descriptor. - unsafe { fd_sys_bpf(bpf_cmd::BPF_ENABLE_STATS, &mut attr) }.map_err(|(_, io_error)| { - SyscallError { - call: "bpf_enable_stats", - io_error, - } - }) + unsafe { fd_sys_bpf(BpfCmd::EnableStats, &mut attr) }.map_err(|(_, e)| e) } pub(crate) fn retry_with_verifier_logs( @@ -1239,7 +1215,7 @@ pub(crate) fn retry_with_verifier_logs( loop { let ret = f(log_buf.as_mut_slice()); if retries != max_retries { - if let Err((_, io_error)) = &ret { + if let Err((_, SysError::Syscall { call: _, io_error })) = &ret { if retries == 0 || io_error.raw_os_error() == Some(ENOSPC) { let len = (log_buf.capacity() * 10).clamp(MIN_LOG_BUF_SIZE, MAX_LOG_BUF_SIZE); log_buf.resize(len, 0); @@ -1275,13 +1251,19 @@ mod tests { // Test attach flags propagated to system call. override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_PROG_ATTACH, + cmd: BpfCmd::ProgAttach, attr, } => { assert_eq!(unsafe { attr.__bindgen_anon_5.attach_flags }, FAKE_FLAGS); Ok(0) } - _ => Err((-1, io::Error::from_raw_os_error(EINVAL))), + _ => Err(( + -1, + SysError::Syscall { + call: format!("{:?}", BpfCmd::ProgAttach), + io_error: io::Error::from_raw_os_error(EINVAL), + }, + )), }); let prog_fd = unsafe { BorrowedFd::borrow_raw(FAKE_FD) }; @@ -1297,13 +1279,19 @@ mod tests { // Test with no flags. override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_PROG_ATTACH, + cmd: BpfCmd::ProgAttach, attr, } => { assert_eq!(unsafe { attr.__bindgen_anon_5.attach_flags }, 0); Ok(0) } - _ => Err((-1, io::Error::from_raw_os_error(EINVAL))), + _ => Err(( + -1, + SysError::Syscall { + call: format!("{:?}", BpfCmd::ProgAttach), + io_error: io::Error::from_raw_os_error(EINVAL), + }, + )), }); result = bpf_prog_attach(prog_fd, tgt_fd, bpf_attach_type::BPF_CGROUP_SOCK_OPS, 0); @@ -1314,9 +1302,15 @@ mod tests { fn test_perf_link_supported() { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_LINK_CREATE, + cmd: BpfCmd::LinkCreate, .. - } => Err((-1, io::Error::from_raw_os_error(EBADF))), + } => Err(( + -1, + SysError::Syscall { + call: format!("{:?}", BpfCmd::LinkCreate), + io_error: io::Error::from_raw_os_error(EBADF), + }, + )), _ => Ok(crate::MockableFd::mock_signed_fd().into()), }); let supported = is_perf_link_supported(); @@ -1324,9 +1318,15 @@ mod tests { override_syscall(|call| match call { Syscall::Ebpf { - cmd: bpf_cmd::BPF_LINK_CREATE, + cmd: BpfCmd::LinkCreate, .. - } => Err((-1, io::Error::from_raw_os_error(EINVAL))), + } => Err(( + -1, + SysError::Syscall { + call: format!("{:?}", BpfCmd::LinkCreate), + io_error: io::Error::from_raw_os_error(EINVAL), + }, + )), _ => Ok(crate::MockableFd::mock_signed_fd().into()), }); let supported = is_perf_link_supported(); @@ -1345,7 +1345,15 @@ mod tests { let supported = is_prog_id_supported(bpf_map_type::BPF_MAP_TYPE_DEVMAP_HASH); assert!(supported); - override_syscall(|_call| Err((-1, io::Error::from_raw_os_error(EINVAL)))); + override_syscall(|_call| { + Err(( + -1, + SysError::Syscall { + call: format!("{:?}", BpfCmd::MapCreate), + io_error: io::Error::from_raw_os_error(EINVAL), + }, + )) + }); let supported = is_prog_id_supported(bpf_map_type::BPF_MAP_TYPE_CPUMAP); assert!(!supported); } diff --git a/aya/src/sys/fake.rs b/aya/src/sys/fake.rs index 0e0cd3fe2..5adba9110 100644 --- a/aya/src/sys/fake.rs +++ b/aya/src/sys/fake.rs @@ -11,8 +11,16 @@ thread_local! { } #[cfg(test)] -unsafe fn test_syscall(_call: Syscall<'_>) -> SysResult { - Err((-1, io::Error::from_raw_os_error(libc::EINVAL))) +unsafe fn test_syscall(call: Syscall<'_>) -> SysResult { + use crate::errors::SysError; + + Err(( + -1, + SysError::Syscall { + call: format!("{:?}", call), + io_error: io::Error::from_raw_os_error(libc::EINVAL), + }, + )) } #[cfg(test)] diff --git a/aya/src/sys/mod.rs b/aya/src/sys/mod.rs index 05f8b4dd7..7b4d7ce05 100644 --- a/aya/src/sys/mod.rs +++ b/aya/src/sys/mod.rs @@ -21,15 +21,17 @@ use libc::{pid_t, SYS_bpf, SYS_perf_event_open}; pub use netlink::netlink_set_link_up; pub(crate) use netlink::*; pub(crate) use perf_event::*; -use thiserror::Error; -use crate::generated::{bpf_attr, bpf_cmd, perf_event_attr}; +use crate::{ + errors::SysError, + generated::{bpf_attr, bpf_cmd, perf_event_attr}, +}; -pub(crate) type SysResult = Result; +pub(crate) type SysResult = Result; pub(crate) enum Syscall<'a> { Ebpf { - cmd: bpf_cmd, + cmd: BpfCmd, attr: &'a mut bpf_attr, }, PerfEventOpen { @@ -46,15 +48,137 @@ pub(crate) enum Syscall<'a> { }, } -/// A system call error. -#[derive(Debug, Error)] -#[error("`{call}` failed")] -pub struct SyscallError { - /// The name of the syscall which failed. - pub call: &'static str, - /// The [`io::Error`] returned by the syscall. - #[source] - pub io_error: io::Error, +#[derive(Copy, Clone)] +pub(crate) enum BpfCmd { + MapCreate, + MapLookupElem, + MapUpdateElem, + MapDeleteElem, + MapGetNextKey, + ProgLoad, + ObjPin, + ObjGet, + ProgAttach, + ProgDetach, + ProgTestRun, + ProgGetNextId, + MapGetNextId, + ProgGetFdById, + MapGetFdById, + ObjGetInfoByFd, + ProgQuery, + RawTracepointOpen, + BtfLoad, + BtfGetFdById, + TaskFdQuery, + MapLookupAndDeleteElem, + MapFreeze, + BtfGetNextId, + MapLookupBatch, + MapLookupAndDeleteBatch, + MapUpdateBatch, + MapDeleteBatch, + LinkCreate, + LinkUpdate, + LinkGetFdById, + LinkGetNextId, + EnableStats, + IterCreate, + LinkDetach, + ProgBindMap, + TokenCreate, + Max, +} + +impl From for BpfCmd { + fn from(value: bpf_cmd) -> Self { + use bpf_cmd::*; + match value { + BPF_MAP_CREATE => Self::MapCreate, + BPF_MAP_LOOKUP_ELEM => Self::MapLookupElem, + BPF_MAP_UPDATE_ELEM => Self::MapUpdateElem, + BPF_MAP_DELETE_ELEM => Self::MapDeleteElem, + BPF_MAP_GET_NEXT_KEY => Self::MapGetNextKey, + BPF_PROG_LOAD => Self::ProgLoad, + BPF_OBJ_PIN => Self::ObjPin, + BPF_OBJ_GET => Self::ObjGet, + BPF_PROG_ATTACH => Self::ProgAttach, + BPF_PROG_DETACH => Self::ProgDetach, + BPF_PROG_TEST_RUN => Self::ProgTestRun, + BPF_PROG_GET_NEXT_ID => Self::ProgGetNextId, + BPF_MAP_GET_NEXT_ID => Self::MapGetNextId, + BPF_PROG_GET_FD_BY_ID => Self::ProgGetFdById, + BPF_MAP_GET_FD_BY_ID => Self::MapGetFdById, + BPF_OBJ_GET_INFO_BY_FD => Self::ObjGetInfoByFd, + BPF_PROG_QUERY => Self::ProgQuery, + BPF_RAW_TRACEPOINT_OPEN => Self::RawTracepointOpen, + BPF_BTF_LOAD => Self::BtfLoad, + BPF_BTF_GET_FD_BY_ID => Self::BtfGetFdById, + BPF_TASK_FD_QUERY => Self::TaskFdQuery, + BPF_MAP_LOOKUP_AND_DELETE_ELEM => Self::MapLookupAndDeleteElem, + BPF_MAP_FREEZE => Self::MapFreeze, + BPF_BTF_GET_NEXT_ID => Self::BtfGetNextId, + BPF_MAP_LOOKUP_BATCH => Self::MapLookupBatch, + BPF_MAP_LOOKUP_AND_DELETE_BATCH => Self::MapLookupAndDeleteBatch, + BPF_MAP_UPDATE_BATCH => Self::MapUpdateBatch, + BPF_MAP_DELETE_BATCH => Self::MapDeleteBatch, + BPF_LINK_CREATE => Self::LinkCreate, + BPF_LINK_UPDATE => Self::LinkUpdate, + BPF_LINK_GET_FD_BY_ID => Self::LinkGetFdById, + BPF_LINK_GET_NEXT_ID => Self::LinkGetNextId, + BPF_ENABLE_STATS => Self::EnableStats, + BPF_ITER_CREATE => Self::IterCreate, + BPF_LINK_DETACH => Self::LinkDetach, + BPF_PROG_BIND_MAP => Self::ProgBindMap, + BPF_TOKEN_CREATE => Self::TokenCreate, + __MAX_BPF_CMD => Self::Max, + } + } +} + +impl std::fmt::Debug for BpfCmd { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::MapCreate => f.write_str("bpf_map_create"), + Self::MapLookupElem => f.write_str("bpf_map_lookup_elem"), + Self::MapUpdateElem => f.write_str("bpf_map_update_elem"), + Self::MapDeleteElem => f.write_str("bpf_map_delete_elem"), + Self::MapGetNextKey => f.write_str("bpf_map_get_next_key"), + Self::ProgLoad => f.write_str("bpf_prog_load"), + Self::ObjPin => f.write_str("bpf_obj_pin"), + Self::ObjGet => f.write_str("bpf_obj_get"), + Self::ProgAttach => f.write_str("bpf_prog_attach"), + Self::ProgDetach => f.write_str("bpf_prog_detach"), + Self::ProgTestRun => f.write_str("bpf_prog_test_run"), + Self::ProgGetNextId => f.write_str("bpf_prog_get_next_id"), + Self::MapGetNextId => f.write_str("bpf_map_get_next_id"), + Self::ProgGetFdById => f.write_str("bpf_prog_get_fd_by_id"), + Self::MapGetFdById => f.write_str("bpf_map_get_fd_by_id"), + Self::ObjGetInfoByFd => f.write_str("bpf_obj_get_info_by_fd"), + Self::ProgQuery => f.write_str("bpf_prog_query"), + Self::RawTracepointOpen => f.write_str("bpf_raw_tracepoint_open"), + Self::BtfLoad => f.write_str("bpf_btf_load"), + Self::BtfGetFdById => f.write_str("bpf_btf_get_fd_by_id"), + Self::TaskFdQuery => f.write_str("bpf_task_fd_query"), + Self::MapLookupAndDeleteElem => f.write_str("bpf_map_lookup_and_delete_elem"), + Self::MapFreeze => f.write_str("bpf_map_freeze"), + Self::BtfGetNextId => f.write_str("bpf_btf_get_next_id"), + Self::MapLookupBatch => f.write_str("bpf_map_lookup_batch"), + Self::MapLookupAndDeleteBatch => f.write_str("bpf_map_lookup_and_delete_batch"), + Self::MapUpdateBatch => f.write_str("bpf_map_update_batch"), + Self::MapDeleteBatch => f.write_str("bpf_map_delete_batch"), + Self::LinkCreate => f.write_str("bpf_link_create"), + Self::LinkUpdate => f.write_str("bpf_link_update"), + Self::LinkGetFdById => f.write_str("bpf_link_get_fd_by_id"), + Self::LinkGetNextId => f.write_str("bpf_link_get_next_id"), + Self::EnableStats => f.write_str("bpf_enable_stats"), + Self::IterCreate => f.write_str("bpf_iter_create"), + Self::LinkDetach => f.write_str("bpf_link_detach"), + Self::ProgBindMap => f.write_str("bpf_prog_bind_map"), + Self::TokenCreate => f.write_str("bpf_token_create"), + Self::Max => f.write_str("MAX"), + } + } } impl std::fmt::Debug for Syscall<'_> { @@ -95,6 +219,7 @@ fn syscall(call: Syscall<'_>) -> SysResult { #[cfg_attr(test, allow(unreachable_code))] { + let call_name = format!("{:?}", call); let ret = unsafe { match call { Syscall::Ebpf { cmd, attr } => { @@ -120,7 +245,13 @@ fn syscall(call: Syscall<'_>) -> SysResult { #[allow(clippy::useless_conversion)] match ret.into() { ret @ 0.. => Ok(ret), - ret => Err((ret, io::Error::last_os_error())), + ret => Err(( + ret, + SysError::Syscall { + call: call_name, + io_error: io::Error::last_os_error(), + }, + )), } } } @@ -181,13 +312,15 @@ impl From for crate::generated::bpf_stats_type { /// # Examples /// /// ```no_run -/// # use aya::sys::{SyscallError}; +/// # use aya::errors::{SysError}; /// use aya::sys::{enable_stats, Stats}; /// /// let _fd = enable_stats(Stats::RunTime)?; -/// # Ok::<(), SyscallError>(()) +/// # Ok::<(), SysError>(()) /// ``` #[doc(alias = "BPF_ENABLE_STATS")] -pub fn enable_stats(stats_type: Stats) -> Result { - bpf_enable_stats(stats_type.into()).map(|fd| fd.into_inner()) +pub fn enable_stats(stats_type: Stats) -> Result> { + Ok(bpf_enable_stats(stats_type.into()) + .map(|fd| fd.into_inner()) + .map_err(Box::new)?) } diff --git a/aya/src/sys/perf_event.rs b/aya/src/sys/perf_event.rs index ec8b14207..0b3806f63 100644 --- a/aya/src/sys/perf_event.rs +++ b/aya/src/sys/perf_event.rs @@ -7,12 +7,15 @@ use std::{ use libc::pid_t; use super::{syscall, SysResult, Syscall}; -use crate::generated::{ - perf_event_attr, - perf_event_sample_format::PERF_SAMPLE_RAW, - perf_sw_ids::PERF_COUNT_SW_BPF_OUTPUT, - perf_type_id::{PERF_TYPE_SOFTWARE, PERF_TYPE_TRACEPOINT}, - PERF_FLAG_FD_CLOEXEC, +use crate::{ + errors::SysError, + generated::{ + perf_event_attr, + perf_event_sample_format::PERF_SAMPLE_RAW, + perf_sw_ids::PERF_COUNT_SW_BPF_OUTPUT, + perf_type_id::{PERF_TYPE_SOFTWARE, PERF_TYPE_TRACEPOINT}, + PERF_FLAG_FD_CLOEXEC, + }, }; #[allow(clippy::too_many_arguments)] @@ -130,10 +133,10 @@ fn perf_event_sys( let fd = fd.try_into().map_err(|_| { ( fd, - io::Error::new( + SysError::Other(Box::new(io::Error::new( io::ErrorKind::InvalidData, format!("perf_event_open: invalid fd returned: {fd}"), - ), + ))), ) })?; diff --git a/test/integration-test/src/tests/info.rs b/test/integration-test/src/tests/info.rs index 6a84100d4..8125b81cd 100644 --- a/test/integration-test/src/tests/info.rs +++ b/test/integration-test/src/tests/info.rs @@ -8,8 +8,9 @@ use std::{fs, panic, path::Path, time::SystemTime}; use aya::{ - maps::{loaded_maps, Array, HashMap, IterableMap as _, MapError, MapType}, - programs::{loaded_programs, ProgramError, ProgramType, SocketFilter, TracePoint}, + errors::{MapError, ProgramError, SysError}, + maps::{loaded_maps, Array, HashMap, IterableMap as _, MapType}, + programs::{loaded_programs, ProgramType, SocketFilter, TracePoint}, sys::enable_stats, util::KernelVersion, Ebpf, @@ -33,13 +34,9 @@ fn test_loaded_programs() { // Ensure loaded program doesn't panic let mut programs = loaded_programs().peekable(); if let Err(err) = programs.peek().unwrap() { - if let ProgramError::SyscallError(err) = &err { + if let ProgramError::Syscall(SysError::Syscall { call: _, io_error }) = &err { // Skip entire test since feature not available - if err - .io_error - .raw_os_error() - .is_some_and(|errno| errno == EINVAL) - { + if io_error.raw_os_error().is_some_and(|errno| errno == EINVAL) { eprintln!( "ignoring test completely as `loaded_programs()` is not available on the host" ); @@ -234,12 +231,8 @@ fn list_loaded_maps() { // Ensure the loaded_maps() api doesn't panic let mut maps = loaded_maps().peekable(); if let Err(err) = maps.peek().unwrap() { - if let MapError::SyscallError(err) = &err { - if err - .io_error - .raw_os_error() - .is_some_and(|errno| errno == EINVAL) - { + if let MapError::Syscall(SysError::Syscall { call: _, io_error }) = &err { + if io_error.raw_os_error().is_some_and(|errno| errno == EINVAL) { eprintln!( "ignoring test completely as `loaded_maps()` is not available on the host" ); diff --git a/xtask/libbpf b/xtask/libbpf index 20ea95b45..a2258003f 160000 --- a/xtask/libbpf +++ b/xtask/libbpf @@ -1 +1 @@ -Subproject commit 20ea95b4505c477af3b6ff6ce9d19cee868ddc5d +Subproject commit a2258003f21d9d52afd48aa64787b65ef80bd355 diff --git a/xtask/public-api/aya-log.txt b/xtask/public-api/aya-log.txt index 3e5bdf8c4..afe22a692 100644 --- a/xtask/public-api/aya-log.txt +++ b/xtask/public-api/aya-log.txt @@ -1,17 +1,17 @@ pub mod aya_log pub enum aya_log::Error pub aya_log::Error::InvalidOnlineCpu(std::io::error::Error) -pub aya_log::Error::MapError(aya::maps::MapError) +pub aya_log::Error::MapError(aya::errors::MapError) pub aya_log::Error::MapNotFound -pub aya_log::Error::PerfBufferError(aya::maps::perf::perf_buffer::PerfBufferError) -pub aya_log::Error::ProgramError(aya::programs::ProgramError) +pub aya_log::Error::PerfBufferError(aya::errors::PerfBufferError) +pub aya_log::Error::ProgramError(aya::errors::ProgramError) pub aya_log::Error::ProgramNotFound -impl core::convert::From for aya_log::Error -pub fn aya_log::Error::from(source: aya::maps::MapError) -> Self -impl core::convert::From for aya_log::Error -pub fn aya_log::Error::from(source: aya::maps::perf::perf_buffer::PerfBufferError) -> Self -impl core::convert::From for aya_log::Error -pub fn aya_log::Error::from(source: aya::programs::ProgramError) -> Self +impl core::convert::From for aya_log::Error +pub fn aya_log::Error::from(source: aya::errors::MapError) -> Self +impl core::convert::From for aya_log::Error +pub fn aya_log::Error::from(source: aya::errors::PerfBufferError) -> Self +impl core::convert::From for aya_log::Error +pub fn aya_log::Error::from(source: aya::errors::ProgramError) -> Self impl core::error::Error for aya_log::Error pub fn aya_log::Error::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> impl core::fmt::Debug for aya_log::Error @@ -19,8 +19,8 @@ pub fn aya_log::Error::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt impl core::fmt::Display for aya_log::Error pub fn aya_log::Error::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::marker::Freeze for aya_log::Error -impl core::marker::Send for aya_log::Error -impl core::marker::Sync for aya_log::Error +impl !core::marker::Send for aya_log::Error +impl !core::marker::Sync for aya_log::Error impl core::marker::Unpin for aya_log::Error impl !core::panic::unwind_safe::RefUnwindSafe for aya_log::Error impl !core::panic::unwind_safe::UnwindSafe for aya_log::Error diff --git a/xtask/public-api/aya-obj.txt b/xtask/public-api/aya-obj.txt index f46d106f2..e03a9e533 100644 --- a/xtask/public-api/aya-obj.txt +++ b/xtask/public-api/aya-obj.txt @@ -28,6 +28,7 @@ pub aya_obj::btf::BtfError::LoadError::io_error: std::io::error::Error pub aya_obj::btf::BtfError::LoadError::verifier_log: aya_obj::VerifierLog pub aya_obj::btf::BtfError::MaximumTypeDepthReached pub aya_obj::btf::BtfError::MaximumTypeDepthReached::type_id: u32 +pub aya_obj::btf::BtfError::Other(alloc::boxed::Box) pub aya_obj::btf::BtfError::SymbolOffsetNotFound pub aya_obj::btf::BtfError::SymbolOffsetNotFound::symbol_name: alloc::string::String pub aya_obj::btf::BtfError::UnexpectedBtfType @@ -38,6 +39,8 @@ pub aya_obj::btf::BtfError::UnknownBtfTypeName pub aya_obj::btf::BtfError::UnknownBtfTypeName::type_name: alloc::string::String pub aya_obj::btf::BtfError::UnknownSectionSize pub aya_obj::btf::BtfError::UnknownSectionSize::section_name: alloc::string::String +impl core::convert::From> for aya_obj::btf::BtfError +pub fn aya_obj::btf::BtfError::from(source: alloc::boxed::Box) -> Self impl core::convert::From for aya_obj::ParseError pub fn aya_obj::ParseError::from(source: aya_obj::btf::BtfError) -> Self impl core::error::Error for aya_obj::btf::BtfError @@ -47,8 +50,8 @@ pub fn aya_obj::btf::BtfError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> c impl core::fmt::Display for aya_obj::btf::BtfError pub fn aya_obj::btf::BtfError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::marker::Freeze for aya_obj::btf::BtfError -impl core::marker::Send for aya_obj::btf::BtfError -impl core::marker::Sync for aya_obj::btf::BtfError +impl !core::marker::Send for aya_obj::btf::BtfError +impl !core::marker::Sync for aya_obj::btf::BtfError impl core::marker::Unpin for aya_obj::btf::BtfError impl !core::panic::unwind_safe::RefUnwindSafe for aya_obj::btf::BtfError impl !core::panic::unwind_safe::UnwindSafe for aya_obj::btf::BtfError @@ -582,8 +585,8 @@ pub fn aya_obj::btf::BtfRelocationError::fmt(&self, f: &mut core::fmt::Formatter impl core::fmt::Display for aya_obj::btf::BtfRelocationError pub fn aya_obj::btf::BtfRelocationError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::marker::Freeze for aya_obj::btf::BtfRelocationError -impl core::marker::Send for aya_obj::btf::BtfRelocationError -impl core::marker::Sync for aya_obj::btf::BtfRelocationError +impl !core::marker::Send for aya_obj::btf::BtfRelocationError +impl !core::marker::Sync for aya_obj::btf::BtfRelocationError impl core::marker::Unpin for aya_obj::btf::BtfRelocationError impl !core::panic::unwind_safe::RefUnwindSafe for aya_obj::btf::BtfRelocationError impl !core::panic::unwind_safe::UnwindSafe for aya_obj::btf::BtfRelocationError @@ -7001,8 +7004,8 @@ pub fn aya_obj::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core impl core::fmt::Display for aya_obj::ParseError pub fn aya_obj::ParseError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::marker::Freeze for aya_obj::ParseError -impl core::marker::Send for aya_obj::ParseError -impl core::marker::Sync for aya_obj::ParseError +impl !core::marker::Send for aya_obj::ParseError +impl !core::marker::Sync for aya_obj::ParseError impl core::marker::Unpin for aya_obj::ParseError impl !core::panic::unwind_safe::RefUnwindSafe for aya_obj::ParseError impl !core::panic::unwind_safe::UnwindSafe for aya_obj::ParseError @@ -7861,8 +7864,8 @@ pub fn aya_obj::ParseError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core impl core::fmt::Display for aya_obj::ParseError pub fn aya_obj::ParseError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::marker::Freeze for aya_obj::ParseError -impl core::marker::Send for aya_obj::ParseError -impl core::marker::Sync for aya_obj::ParseError +impl !core::marker::Send for aya_obj::ParseError +impl !core::marker::Sync for aya_obj::ParseError impl core::marker::Unpin for aya_obj::ParseError impl !core::panic::unwind_safe::RefUnwindSafe for aya_obj::ParseError impl !core::panic::unwind_safe::UnwindSafe for aya_obj::ParseError diff --git a/xtask/public-api/aya.txt b/xtask/public-api/aya.txt index 3d5c5874a..e937dbb5a 100644 --- a/xtask/public-api/aya.txt +++ b/xtask/public-api/aya.txt @@ -4,28 +4,306 @@ pub use aya::BtfError pub use aya::Endianness pub use aya::PinningType pub use aya::bpf_map_def +pub mod aya::errors +#[non_exhaustive] pub enum aya::errors::EbpfError +pub aya::errors::EbpfError::FileError +pub aya::errors::EbpfError::FileError::error: std::io::error::Error +pub aya::errors::EbpfError::FileError::path: std::path::PathBuf +pub aya::errors::EbpfError::MapError(aya::errors::MapError) +pub aya::errors::EbpfError::Other(alloc::boxed::Box) +pub aya::errors::EbpfError::ProgramError(aya::errors::ProgramError) +impl core::convert::From> for aya::errors::EbpfError +pub fn aya::errors::EbpfError::from(source: alloc::boxed::Box) -> Self +impl core::convert::From for aya::errors::EbpfError +pub fn aya::errors::EbpfError::from(source: aya::errors::MapError) -> Self +impl core::convert::From for aya::errors::EbpfError +pub fn aya::errors::EbpfError::from(source: aya::errors::ProgramError) -> Self +impl core::error::Error for aya::errors::EbpfError +pub fn aya::errors::EbpfError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> +impl core::fmt::Debug for aya::errors::EbpfError +pub fn aya::errors::EbpfError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::fmt::Display for aya::errors::EbpfError +pub fn aya::errors::EbpfError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::marker::Freeze for aya::errors::EbpfError +impl !core::marker::Send for aya::errors::EbpfError +impl !core::marker::Sync for aya::errors::EbpfError +impl core::marker::Unpin for aya::errors::EbpfError +impl !core::panic::unwind_safe::RefUnwindSafe for aya::errors::EbpfError +impl !core::panic::unwind_safe::UnwindSafe for aya::errors::EbpfError +impl core::convert::Into for aya::errors::EbpfError where U: core::convert::From +pub fn aya::errors::EbpfError::into(self) -> U +impl core::convert::TryFrom for aya::errors::EbpfError where U: core::convert::Into +pub type aya::errors::EbpfError::Error = core::convert::Infallible +pub fn aya::errors::EbpfError::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya::errors::EbpfError where U: core::convert::TryFrom +pub type aya::errors::EbpfError::Error = >::Error +pub fn aya::errors::EbpfError::try_into(self) -> core::result::Result>::Error> +impl alloc::string::ToString for aya::errors::EbpfError where T: core::fmt::Display + core::marker::Sized +pub fn aya::errors::EbpfError::to_string(&self) -> alloc::string::String +impl core::any::Any for aya::errors::EbpfError where T: 'static + core::marker::Sized +pub fn aya::errors::EbpfError::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya::errors::EbpfError where T: core::marker::Sized +pub fn aya::errors::EbpfError::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya::errors::EbpfError where T: core::marker::Sized +pub fn aya::errors::EbpfError::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya::errors::EbpfError +pub fn aya::errors::EbpfError::from(t: T) -> T +pub enum aya::errors::LinkError +pub aya::errors::LinkError::AlreadyAttached +pub aya::errors::LinkError::InvalidLink +pub aya::errors::LinkError::NotAttached +pub aya::errors::LinkError::Other(alloc::boxed::Box) +impl core::convert::From<(i64, aya::errors::SysError)> for aya::errors::LinkError +pub fn aya::errors::LinkError::from((_, error): (i64, aya::errors::SysError)) -> Self +impl core::convert::From> for aya::errors::LinkError +pub fn aya::errors::LinkError::from(source: alloc::boxed::Box) -> Self +impl core::convert::From for aya::errors::LinkError +pub fn aya::errors::LinkError::from(e: aya::errors::ProgramError) -> Self +impl core::convert::From for aya::errors::LinkError +pub fn aya::errors::LinkError::from(e: aya::errors::SysError) -> Self +impl core::error::Error for aya::errors::LinkError +pub fn aya::errors::LinkError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> +impl core::fmt::Debug for aya::errors::LinkError +pub fn aya::errors::LinkError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::fmt::Display for aya::errors::LinkError +pub fn aya::errors::LinkError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::marker::Freeze for aya::errors::LinkError +impl !core::marker::Send for aya::errors::LinkError +impl !core::marker::Sync for aya::errors::LinkError +impl core::marker::Unpin for aya::errors::LinkError +impl !core::panic::unwind_safe::RefUnwindSafe for aya::errors::LinkError +impl !core::panic::unwind_safe::UnwindSafe for aya::errors::LinkError +impl core::convert::Into for aya::errors::LinkError where U: core::convert::From +pub fn aya::errors::LinkError::into(self) -> U +impl core::convert::TryFrom for aya::errors::LinkError where U: core::convert::Into +pub type aya::errors::LinkError::Error = core::convert::Infallible +pub fn aya::errors::LinkError::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya::errors::LinkError where U: core::convert::TryFrom +pub type aya::errors::LinkError::Error = >::Error +pub fn aya::errors::LinkError::try_into(self) -> core::result::Result>::Error> +impl alloc::string::ToString for aya::errors::LinkError where T: core::fmt::Display + core::marker::Sized +pub fn aya::errors::LinkError::to_string(&self) -> alloc::string::String +impl core::any::Any for aya::errors::LinkError where T: 'static + core::marker::Sized +pub fn aya::errors::LinkError::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya::errors::LinkError where T: core::marker::Sized +pub fn aya::errors::LinkError::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya::errors::LinkError where T: core::marker::Sized +pub fn aya::errors::LinkError::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya::errors::LinkError +pub fn aya::errors::LinkError::from(t: T) -> T +pub enum aya::errors::MapError +pub aya::errors::MapError::ChainedProgramNotSupported +pub aya::errors::MapError::ElementNotFound +pub aya::errors::MapError::InvalidMapType +pub aya::errors::MapError::InvalidMapType::map_type: u32 +pub aya::errors::MapError::KeyNotFound +pub aya::errors::MapError::Other(alloc::boxed::Box) +pub aya::errors::MapError::OutOfBounds +pub aya::errors::MapError::OutOfBounds::index: u32 +pub aya::errors::MapError::OutOfBounds::max_entries: u32 +pub aya::errors::MapError::Syscall(aya::errors::SysError) +impl core::convert::From> for aya::errors::MapError +pub fn aya::errors::MapError::from(source: alloc::boxed::Box) -> Self +impl core::convert::From for aya::errors::EbpfError +pub fn aya::errors::EbpfError::from(source: aya::errors::MapError) -> Self +impl core::convert::From for aya::errors::MapError +pub fn aya::errors::MapError::from(source: aya::errors::SysError) -> Self +impl core::convert::From> for aya::errors::MapError +pub fn aya::errors::MapError::from(e: aya_obj::obj::InvalidTypeBinding) -> Self +impl core::error::Error for aya::errors::MapError +pub fn aya::errors::MapError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> +impl core::fmt::Debug for aya::errors::MapError +pub fn aya::errors::MapError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::fmt::Display for aya::errors::MapError +pub fn aya::errors::MapError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::marker::Freeze for aya::errors::MapError +impl !core::marker::Send for aya::errors::MapError +impl !core::marker::Sync for aya::errors::MapError +impl core::marker::Unpin for aya::errors::MapError +impl !core::panic::unwind_safe::RefUnwindSafe for aya::errors::MapError +impl !core::panic::unwind_safe::UnwindSafe for aya::errors::MapError +impl core::convert::Into for aya::errors::MapError where U: core::convert::From +pub fn aya::errors::MapError::into(self) -> U +impl core::convert::TryFrom for aya::errors::MapError where U: core::convert::Into +pub type aya::errors::MapError::Error = core::convert::Infallible +pub fn aya::errors::MapError::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya::errors::MapError where U: core::convert::TryFrom +pub type aya::errors::MapError::Error = >::Error +pub fn aya::errors::MapError::try_into(self) -> core::result::Result>::Error> +impl alloc::string::ToString for aya::errors::MapError where T: core::fmt::Display + core::marker::Sized +pub fn aya::errors::MapError::to_string(&self) -> alloc::string::String +impl core::any::Any for aya::errors::MapError where T: 'static + core::marker::Sized +pub fn aya::errors::MapError::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya::errors::MapError where T: core::marker::Sized +pub fn aya::errors::MapError::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya::errors::MapError where T: core::marker::Sized +pub fn aya::errors::MapError::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya::errors::MapError +pub fn aya::errors::MapError::from(t: T) -> T +pub enum aya::errors::PerfBufferError +pub aya::errors::PerfBufferError::IOError(std::io::error::Error) +pub aya::errors::PerfBufferError::InvalidPageCount +pub aya::errors::PerfBufferError::InvalidPageCount::page_count: usize +pub aya::errors::PerfBufferError::MMapError +pub aya::errors::PerfBufferError::MMapError::io_error: std::io::error::Error +pub aya::errors::PerfBufferError::MoreSpaceNeeded +pub aya::errors::PerfBufferError::MoreSpaceNeeded::size: usize +pub aya::errors::PerfBufferError::NoBuffers +pub aya::errors::PerfBufferError::OpenError +pub aya::errors::PerfBufferError::OpenError::io_error: std::io::error::Error +pub aya::errors::PerfBufferError::Other(alloc::boxed::Box) +pub aya::errors::PerfBufferError::PerfEventEnableError +pub aya::errors::PerfBufferError::PerfEventEnableError::io_error: std::io::error::Error +impl core::convert::From> for aya::errors::PerfBufferError +pub fn aya::errors::PerfBufferError::from(source: alloc::boxed::Box) -> Self +impl core::convert::From for aya::errors::PerfBufferError +pub fn aya::errors::PerfBufferError::from(source: std::io::error::Error) -> Self +impl core::error::Error for aya::errors::PerfBufferError +pub fn aya::errors::PerfBufferError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> +impl core::fmt::Debug for aya::errors::PerfBufferError +pub fn aya::errors::PerfBufferError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::fmt::Display for aya::errors::PerfBufferError +pub fn aya::errors::PerfBufferError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::marker::Freeze for aya::errors::PerfBufferError +impl !core::marker::Send for aya::errors::PerfBufferError +impl !core::marker::Sync for aya::errors::PerfBufferError +impl core::marker::Unpin for aya::errors::PerfBufferError +impl !core::panic::unwind_safe::RefUnwindSafe for aya::errors::PerfBufferError +impl !core::panic::unwind_safe::UnwindSafe for aya::errors::PerfBufferError +impl core::convert::Into for aya::errors::PerfBufferError where U: core::convert::From +pub fn aya::errors::PerfBufferError::into(self) -> U +impl core::convert::TryFrom for aya::errors::PerfBufferError where U: core::convert::Into +pub type aya::errors::PerfBufferError::Error = core::convert::Infallible +pub fn aya::errors::PerfBufferError::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya::errors::PerfBufferError where U: core::convert::TryFrom +pub type aya::errors::PerfBufferError::Error = >::Error +pub fn aya::errors::PerfBufferError::try_into(self) -> core::result::Result>::Error> +impl alloc::string::ToString for aya::errors::PerfBufferError where T: core::fmt::Display + core::marker::Sized +pub fn aya::errors::PerfBufferError::to_string(&self) -> alloc::string::String +impl core::any::Any for aya::errors::PerfBufferError where T: 'static + core::marker::Sized +pub fn aya::errors::PerfBufferError::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya::errors::PerfBufferError where T: core::marker::Sized +pub fn aya::errors::PerfBufferError::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya::errors::PerfBufferError where T: core::marker::Sized +pub fn aya::errors::PerfBufferError::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya::errors::PerfBufferError +pub fn aya::errors::PerfBufferError::from(t: T) -> T +pub enum aya::errors::ProgramError +pub aya::errors::ProgramError::AlreadyLoaded +pub aya::errors::ProgramError::LoadError +pub aya::errors::ProgramError::LoadError::source: aya::errors::SysError +pub aya::errors::ProgramError::LoadError::verifier_log: aya_obj::VerifierLog +pub aya::errors::ProgramError::NotLoaded +pub aya::errors::ProgramError::Other(alloc::boxed::Box) +pub aya::errors::ProgramError::Syscall(aya::errors::SysError) +pub aya::errors::ProgramError::UnexpectedProgramType +impl core::convert::From<(i64, aya::errors::SysError)> for aya::errors::ProgramError +pub fn aya::errors::ProgramError::from((_, error): (i64, aya::errors::SysError)) -> Self +impl core::convert::From> for aya::errors::ProgramError +pub fn aya::errors::ProgramError::from(source: alloc::boxed::Box) -> Self +impl core::convert::From for aya::errors::EbpfError +pub fn aya::errors::EbpfError::from(source: aya::errors::ProgramError) -> Self +impl core::convert::From for aya::errors::LinkError +pub fn aya::errors::LinkError::from(e: aya::errors::ProgramError) -> Self +impl core::convert::From for aya::errors::ProgramError +pub fn aya::errors::ProgramError::from(source: aya::errors::SysError) -> Self +impl core::error::Error for aya::errors::ProgramError +pub fn aya::errors::ProgramError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> +impl core::fmt::Debug for aya::errors::ProgramError +pub fn aya::errors::ProgramError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::fmt::Display for aya::errors::ProgramError +pub fn aya::errors::ProgramError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::marker::Freeze for aya::errors::ProgramError +impl !core::marker::Send for aya::errors::ProgramError +impl !core::marker::Sync for aya::errors::ProgramError +impl core::marker::Unpin for aya::errors::ProgramError +impl !core::panic::unwind_safe::RefUnwindSafe for aya::errors::ProgramError +impl !core::panic::unwind_safe::UnwindSafe for aya::errors::ProgramError +impl core::convert::Into for aya::errors::ProgramError where U: core::convert::From +pub fn aya::errors::ProgramError::into(self) -> U +impl core::convert::TryFrom for aya::errors::ProgramError where U: core::convert::Into +pub type aya::errors::ProgramError::Error = core::convert::Infallible +pub fn aya::errors::ProgramError::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya::errors::ProgramError where U: core::convert::TryFrom +pub type aya::errors::ProgramError::Error = >::Error +pub fn aya::errors::ProgramError::try_into(self) -> core::result::Result>::Error> +impl alloc::string::ToString for aya::errors::ProgramError where T: core::fmt::Display + core::marker::Sized +pub fn aya::errors::ProgramError::to_string(&self) -> alloc::string::String +impl core::any::Any for aya::errors::ProgramError where T: 'static + core::marker::Sized +pub fn aya::errors::ProgramError::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya::errors::ProgramError where T: core::marker::Sized +pub fn aya::errors::ProgramError::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya::errors::ProgramError where T: core::marker::Sized +pub fn aya::errors::ProgramError::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya::errors::ProgramError +pub fn aya::errors::ProgramError::from(t: T) -> T +pub enum aya::errors::SysError +pub aya::errors::SysError::Mmap +pub aya::errors::SysError::Mmap::io_error: std::io::error::Error +pub aya::errors::SysError::Other(alloc::boxed::Box) +pub aya::errors::SysError::Syscall +pub aya::errors::SysError::Syscall::call: alloc::string::String +pub aya::errors::SysError::Syscall::io_error: std::io::error::Error +impl core::convert::From> for aya::errors::SysError +pub fn aya::errors::SysError::from(source: alloc::boxed::Box) -> Self +impl core::convert::From for aya::errors::LinkError +pub fn aya::errors::LinkError::from(e: aya::errors::SysError) -> Self +impl core::convert::From for aya::errors::MapError +pub fn aya::errors::MapError::from(source: aya::errors::SysError) -> Self +impl core::convert::From for aya::errors::ProgramError +pub fn aya::errors::ProgramError::from(source: aya::errors::SysError) -> Self +impl core::error::Error for aya::errors::SysError +pub fn aya::errors::SysError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> +impl core::fmt::Debug for aya::errors::SysError +pub fn aya::errors::SysError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::fmt::Display for aya::errors::SysError +pub fn aya::errors::SysError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::marker::Freeze for aya::errors::SysError +impl !core::marker::Send for aya::errors::SysError +impl !core::marker::Sync for aya::errors::SysError +impl core::marker::Unpin for aya::errors::SysError +impl !core::panic::unwind_safe::RefUnwindSafe for aya::errors::SysError +impl !core::panic::unwind_safe::UnwindSafe for aya::errors::SysError +impl core::convert::Into for aya::errors::SysError where U: core::convert::From +pub fn aya::errors::SysError::into(self) -> U +impl core::convert::TryFrom for aya::errors::SysError where U: core::convert::Into +pub type aya::errors::SysError::Error = core::convert::Infallible +pub fn aya::errors::SysError::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya::errors::SysError where U: core::convert::TryFrom +pub type aya::errors::SysError::Error = >::Error +pub fn aya::errors::SysError::try_into(self) -> core::result::Result>::Error> +impl alloc::string::ToString for aya::errors::SysError where T: core::fmt::Display + core::marker::Sized +pub fn aya::errors::SysError::to_string(&self) -> alloc::string::String +impl core::any::Any for aya::errors::SysError where T: 'static + core::marker::Sized +pub fn aya::errors::SysError::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya::errors::SysError where T: core::marker::Sized +pub fn aya::errors::SysError::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya::errors::SysError where T: core::marker::Sized +pub fn aya::errors::SysError::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya::errors::SysError +pub fn aya::errors::SysError::from(t: T) -> T pub mod aya::maps pub mod aya::maps::array pub struct aya::maps::array::Array impl, V: aya::Pod> aya::maps::array::Array -pub fn aya::maps::array::Array::get(&self, index: &u32, flags: u64) -> core::result::Result -pub fn aya::maps::array::Array::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ +pub fn aya::maps::array::Array::get(&self, index: &u32, flags: u64) -> core::result::Result +pub fn aya::maps::array::Array::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ pub fn aya::maps::array::Array::len(&self) -> u32 impl, V: aya::Pod> aya::maps::array::Array -pub fn aya::maps::array::Array::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::array::Array::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::array::Array -pub fn aya::maps::array::Array::set(&mut self, index: u32, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::array::Array::set(&mut self, index: u32, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::array::Array<&'a aya::maps::MapData, V> -pub type aya::maps::array::Array<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::array::Array<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::array::Array<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::array::Array<&'a mut aya::maps::MapData, V> -pub type aya::maps::array::Array<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::array::Array<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::array::Array<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl, V: aya::Pod> aya::maps::IterableMap for aya::maps::array::Array -pub fn aya::maps::array::Array::get(&self, index: &u32) -> core::result::Result +pub fn aya::maps::array::Array::get(&self, index: &u32) -> core::result::Result pub fn aya::maps::array::Array::map(&self) -> &aya::maps::MapData impl core::convert::TryFrom for aya::maps::array::Array -pub type aya::maps::array::Array::Error = aya::maps::MapError +pub type aya::maps::array::Array::Error = aya::errors::MapError pub fn aya::maps::array::Array::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::array::Array where T: core::marker::Freeze impl core::marker::Send for aya::maps::array::Array where T: core::marker::Send, V: core::marker::Send @@ -51,24 +329,24 @@ impl core::convert::From for aya::maps::array::Array pub fn aya::maps::array::Array::from(t: T) -> T pub struct aya::maps::array::PerCpuArray impl, V: aya::Pod> aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::get(&self, index: &u32, flags: u64) -> core::result::Result, aya::maps::MapError> -pub fn aya::maps::PerCpuArray::iter(&self) -> impl core::iter::traits::iterator::Iterator, aya::maps::MapError>> + '_ +pub fn aya::maps::PerCpuArray::get(&self, index: &u32, flags: u64) -> core::result::Result, aya::errors::MapError> +pub fn aya::maps::PerCpuArray::iter(&self) -> impl core::iter::traits::iterator::Iterator, aya::errors::MapError>> + '_ pub fn aya::maps::PerCpuArray::len(&self) -> u32 impl, V: aya::Pod> aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::PerCpuArray::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::set(&mut self, index: u32, values: aya::maps::PerCpuValues, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::PerCpuArray::set(&mut self, index: u32, values: aya::maps::PerCpuValues, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::PerCpuArray<&'a aya::maps::MapData, V> -pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V> -pub type aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl, V: aya::Pod> aya::maps::IterableMap> for aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::get(&self, index: &u32) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::PerCpuArray::get(&self, index: &u32) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::PerCpuArray::map(&self) -> &aya::maps::MapData impl core::convert::TryFrom for aya::maps::PerCpuArray -pub type aya::maps::PerCpuArray::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::PerCpuArray where T: core::marker::Freeze impl core::marker::Send for aya::maps::PerCpuArray where T: core::marker::Send, V: core::marker::Send @@ -96,18 +374,18 @@ pub struct aya::maps::array::ProgramArray impl> aya::maps::ProgramArray pub fn aya::maps::ProgramArray::indices(&self) -> aya::maps::MapKeys<'_, u32> impl> aya::maps::ProgramArray -pub fn aya::maps::ProgramArray::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::ProgramArray::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::ProgramArray -pub fn aya::maps::ProgramArray::clear_index(&mut self, index: &u32) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::ProgramArray::set(&mut self, index: u32, program: &aya::programs::ProgramFd, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::ProgramArray::clear_index(&mut self, index: &u32) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::ProgramArray::set(&mut self, index: u32, program: &aya::programs::ProgramFd, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::ProgramArray -pub type aya::maps::ProgramArray::Error = aya::maps::MapError +pub type aya::maps::ProgramArray::Error = aya::errors::MapError pub fn aya::maps::ProgramArray::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ProgramArray<&'a aya::maps::MapData> -pub type aya::maps::ProgramArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ProgramArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ProgramArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ProgramArray<&'a mut aya::maps::MapData> -pub type aya::maps::ProgramArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ProgramArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ProgramArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::ProgramArray where T: core::marker::Freeze impl core::marker::Send for aya::maps::ProgramArray where T: core::marker::Send @@ -134,21 +412,21 @@ pub fn aya::maps::ProgramArray::from(t: T) -> T pub mod aya::maps::bloom_filter pub struct aya::maps::bloom_filter::BloomFilter impl, V: aya::Pod> aya::maps::bloom_filter::BloomFilter -pub fn aya::maps::bloom_filter::BloomFilter::contains(&self, value: &V, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::bloom_filter::BloomFilter::contains(&self, value: &V, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::bloom_filter::BloomFilter -pub fn aya::maps::bloom_filter::BloomFilter::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::bloom_filter::BloomFilter::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::bloom_filter::BloomFilter -pub fn aya::maps::bloom_filter::BloomFilter::insert(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::bloom_filter::BloomFilter::insert(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V> -pub type aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V> -pub type aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::fmt::Debug for aya::maps::bloom_filter::BloomFilter pub fn aya::maps::bloom_filter::BloomFilter::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::convert::TryFrom for aya::maps::bloom_filter::BloomFilter -pub type aya::maps::bloom_filter::BloomFilter::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::bloom_filter::BloomFilter where T: core::marker::Freeze impl core::marker::Send for aya::maps::bloom_filter::BloomFilter where T: core::marker::Send, V: core::marker::Send @@ -175,25 +453,25 @@ pub fn aya::maps::bloom_filter::BloomFilter::from(t: T) -> T pub mod aya::maps::hash_map pub struct aya::maps::hash_map::HashMap impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::get(&self, key: &K, flags: u64) -> core::result::Result +pub fn aya::maps::hash_map::HashMap::get(&self, key: &K, flags: u64) -> core::result::Result pub fn aya::maps::hash_map::HashMap::iter(&self) -> aya::maps::MapIter<'_, K, V, Self> pub fn aya::maps::hash_map::HashMap::keys(&self) -> aya::maps::MapKeys<'_, K> impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::hash_map::HashMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::insert(&mut self, key: impl core::borrow::Borrow, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::hash_map::HashMap::remove(&mut self, key: &K) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::hash_map::HashMap::insert(&mut self, key: impl core::borrow::Borrow, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::hash_map::HashMap::remove(&mut self, key: &K) -> core::result::Result<(), aya::errors::MapError> impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V> -pub type aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::hash_map::HashMap -pub type aya::maps::hash_map::HashMap::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap::try_from(map: aya::maps::Map) -> core::result::Result impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap for aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::get(&self, key: &K) -> core::result::Result +pub fn aya::maps::hash_map::HashMap::get(&self, key: &K) -> core::result::Result pub fn aya::maps::hash_map::HashMap::map(&self) -> &aya::maps::MapData impl core::fmt::Debug for aya::maps::hash_map::HashMap pub fn aya::maps::hash_map::HashMap::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -221,25 +499,25 @@ impl core::convert::From for aya::maps::hash_map::HashMap pub fn aya::maps::hash_map::HashMap::from(t: T) -> T pub struct aya::maps::hash_map::PerCpuHashMap impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K, flags: u64) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K, flags: u64) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::hash_map::PerCpuHashMap::iter(&self) -> aya::maps::MapIter<'_, K, aya::maps::PerCpuValues, Self> pub fn aya::maps::hash_map::PerCpuHashMap::keys(&self) -> aya::maps::MapKeys<'_, K> impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::hash_map::PerCpuHashMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::insert(&mut self, key: impl core::borrow::Borrow, values: aya::maps::PerCpuValues, flags: u64) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::hash_map::PerCpuHashMap::remove(&mut self, key: &K) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::insert(&mut self, key: impl core::borrow::Borrow, values: aya::maps::PerCpuValues, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::remove(&mut self, key: &K) -> core::result::Result<(), aya::errors::MapError> impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V> -pub type aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::hash_map::PerCpuHashMap -pub type aya::maps::hash_map::PerCpuHashMap::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap::try_from(map: aya::maps::Map) -> core::result::Result impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap> for aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::hash_map::PerCpuHashMap::map(&self) -> &aya::maps::MapData impl core::marker::Freeze for aya::maps::hash_map::PerCpuHashMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::hash_map::PerCpuHashMap where T: core::marker::Send, K: core::marker::Send, V: core::marker::Send @@ -274,7 +552,7 @@ impl core::clone::Clone for aya::maps::lpm_trie::Key pub fn aya::maps::lpm_trie::Key::clone(&self) -> Self impl core::marker::Copy for aya::maps::lpm_trie::Key impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap, V> for aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key) -> core::result::Result +pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key) -> core::result::Result pub fn aya::maps::lpm_trie::LpmTrie::map(&self) -> &aya::maps::MapData impl core::marker::Freeze for aya::maps::lpm_trie::Key where K: core::marker::Freeze impl core::marker::Send for aya::maps::lpm_trie::Key where K: core::marker::Send @@ -306,25 +584,25 @@ impl core::convert::From for aya::maps::lpm_trie::Key pub fn aya::maps::lpm_trie::Key::from(t: T) -> T pub struct aya::maps::lpm_trie::LpmTrie impl, K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key, flags: u64) -> core::result::Result +pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key, flags: u64) -> core::result::Result pub fn aya::maps::lpm_trie::LpmTrie::iter(&self) -> aya::maps::MapIter<'_, aya::maps::lpm_trie::Key, V, Self> pub fn aya::maps::lpm_trie::LpmTrie::keys(&self) -> aya::maps::MapKeys<'_, aya::maps::lpm_trie::Key> impl, K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::lpm_trie::LpmTrie::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::insert(&mut self, key: &aya::maps::lpm_trie::Key, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::lpm_trie::LpmTrie::remove(&mut self, key: &aya::maps::lpm_trie::Key) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::lpm_trie::LpmTrie::insert(&mut self, key: &aya::maps::lpm_trie::Key, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::lpm_trie::LpmTrie::remove(&mut self, key: &aya::maps::lpm_trie::Key) -> core::result::Result<(), aya::errors::MapError> impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V> -pub type aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::lpm_trie::LpmTrie -pub type aya::maps::lpm_trie::LpmTrie::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie::try_from(map: aya::maps::Map) -> core::result::Result impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap, V> for aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key) -> core::result::Result +pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key) -> core::result::Result pub fn aya::maps::lpm_trie::LpmTrie::map(&self) -> &aya::maps::MapData impl core::fmt::Debug for aya::maps::lpm_trie::LpmTrie pub fn aya::maps::lpm_trie::LpmTrie::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -351,63 +629,18 @@ pub fn aya::maps::lpm_trie::LpmTrie::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::maps::lpm_trie::LpmTrie pub fn aya::maps::lpm_trie::LpmTrie::from(t: T) -> T pub mod aya::maps::perf -pub enum aya::maps::perf::PerfBufferError -pub aya::maps::perf::PerfBufferError::IOError(std::io::error::Error) -pub aya::maps::perf::PerfBufferError::InvalidPageCount -pub aya::maps::perf::PerfBufferError::InvalidPageCount::page_count: usize -pub aya::maps::perf::PerfBufferError::MMapError -pub aya::maps::perf::PerfBufferError::MMapError::io_error: std::io::error::Error -pub aya::maps::perf::PerfBufferError::MoreSpaceNeeded -pub aya::maps::perf::PerfBufferError::MoreSpaceNeeded::size: usize -pub aya::maps::perf::PerfBufferError::NoBuffers -pub aya::maps::perf::PerfBufferError::OpenError -pub aya::maps::perf::PerfBufferError::OpenError::io_error: std::io::error::Error -pub aya::maps::perf::PerfBufferError::PerfEventEnableError -pub aya::maps::perf::PerfBufferError::PerfEventEnableError::io_error: std::io::error::Error -impl core::convert::From for aya::maps::perf::PerfBufferError -pub fn aya::maps::perf::PerfBufferError::from(source: std::io::error::Error) -> Self -impl core::error::Error for aya::maps::perf::PerfBufferError -pub fn aya::maps::perf::PerfBufferError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::maps::perf::PerfBufferError -pub fn aya::maps::perf::PerfBufferError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::maps::perf::PerfBufferError -pub fn aya::maps::perf::PerfBufferError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::maps::perf::PerfBufferError -impl core::marker::Send for aya::maps::perf::PerfBufferError -impl core::marker::Sync for aya::maps::perf::PerfBufferError -impl core::marker::Unpin for aya::maps::perf::PerfBufferError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::maps::perf::PerfBufferError -impl !core::panic::unwind_safe::UnwindSafe for aya::maps::perf::PerfBufferError -impl core::convert::Into for aya::maps::perf::PerfBufferError where U: core::convert::From -pub fn aya::maps::perf::PerfBufferError::into(self) -> U -impl core::convert::TryFrom for aya::maps::perf::PerfBufferError where U: core::convert::Into -pub type aya::maps::perf::PerfBufferError::Error = core::convert::Infallible -pub fn aya::maps::perf::PerfBufferError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::maps::perf::PerfBufferError where U: core::convert::TryFrom -pub type aya::maps::perf::PerfBufferError::Error = >::Error -pub fn aya::maps::perf::PerfBufferError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::maps::perf::PerfBufferError where T: core::fmt::Display + core::marker::Sized -pub fn aya::maps::perf::PerfBufferError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::maps::perf::PerfBufferError where T: 'static + core::marker::Sized -pub fn aya::maps::perf::PerfBufferError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::maps::perf::PerfBufferError where T: core::marker::Sized -pub fn aya::maps::perf::PerfBufferError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::maps::perf::PerfBufferError where T: core::marker::Sized -pub fn aya::maps::perf::PerfBufferError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::maps::perf::PerfBufferError -pub fn aya::maps::perf::PerfBufferError::from(t: T) -> T pub struct aya::maps::perf::AsyncPerfEventArray impl> aya::maps::perf::AsyncPerfEventArray -pub fn aya::maps::perf::AsyncPerfEventArray::open(&mut self, index: u32, page_count: core::option::Option) -> core::result::Result, aya::maps::perf::PerfBufferError> -pub fn aya::maps::perf::AsyncPerfEventArray::pin>(&self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::perf::AsyncPerfEventArray::open(&mut self, index: u32, page_count: core::option::Option) -> core::result::Result, aya::errors::PerfBufferError> +pub fn aya::maps::perf::AsyncPerfEventArray::pin>(&self, path: P) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::perf::AsyncPerfEventArray -pub type aya::maps::perf::AsyncPerfEventArray::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData> -pub type aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData> -pub type aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::perf::AsyncPerfEventArray impl core::marker::Send for aya::maps::perf::AsyncPerfEventArray where T: core::marker::Sync + core::marker::Send @@ -433,7 +666,7 @@ impl core::convert::From for aya::maps::perf::AsyncPerfEventArray pub fn aya::maps::perf::AsyncPerfEventArray::from(t: T) -> T pub struct aya::maps::perf::AsyncPerfEventArrayBuffer> impl> aya::maps::perf::AsyncPerfEventArrayBuffer -pub async fn aya::maps::perf::AsyncPerfEventArrayBuffer::read_events(&mut self, buffers: &mut [bytes::bytes_mut::BytesMut]) -> core::result::Result +pub async fn aya::maps::perf::AsyncPerfEventArrayBuffer::read_events(&mut self, buffers: &mut [bytes::bytes_mut::BytesMut]) -> core::result::Result impl !core::marker::Freeze for aya::maps::perf::AsyncPerfEventArrayBuffer impl core::marker::Send for aya::maps::perf::AsyncPerfEventArrayBuffer where T: core::marker::Sync + core::marker::Send impl core::marker::Sync for aya::maps::perf::AsyncPerfEventArrayBuffer where T: core::marker::Sync + core::marker::Send @@ -491,17 +724,17 @@ impl core::convert::From for aya::maps::perf::Events pub fn aya::maps::perf::Events::from(t: T) -> T pub struct aya::maps::perf::PerfEventArray impl> aya::maps::perf::PerfEventArray -pub fn aya::maps::perf::PerfEventArray::pin>(&self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::perf::PerfEventArray::pin>(&self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::perf::PerfEventArray -pub fn aya::maps::perf::PerfEventArray::open(&mut self, index: u32, page_count: core::option::Option) -> core::result::Result, aya::maps::perf::PerfBufferError> +pub fn aya::maps::perf::PerfEventArray::open(&mut self, index: u32, page_count: core::option::Option) -> core::result::Result, aya::errors::PerfBufferError> impl core::convert::TryFrom for aya::maps::perf::PerfEventArray -pub type aya::maps::perf::PerfEventArray::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::perf::PerfEventArray<&'a aya::maps::MapData> -pub type aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData> -pub type aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::perf::PerfEventArray impl core::marker::Send for aya::maps::perf::PerfEventArray where T: core::marker::Sync + core::marker::Send @@ -527,7 +760,7 @@ impl core::convert::From for aya::maps::perf::PerfEventArray pub fn aya::maps::perf::PerfEventArray::from(t: T) -> T pub struct aya::maps::perf::PerfEventArrayBuffer impl> aya::maps::perf::PerfEventArrayBuffer -pub fn aya::maps::perf::PerfEventArrayBuffer::read_events(&mut self, out_bufs: &mut [bytes::bytes_mut::BytesMut]) -> core::result::Result +pub fn aya::maps::perf::PerfEventArrayBuffer::read_events(&mut self, out_bufs: &mut [bytes::bytes_mut::BytesMut]) -> core::result::Result pub fn aya::maps::perf::PerfEventArrayBuffer::readable(&self) -> bool impl> std::os::fd::owned::AsFd for aya::maps::perf::PerfEventArrayBuffer pub fn aya::maps::perf::PerfEventArrayBuffer::as_fd(&self) -> std::os::fd::owned::BorrowedFd<'_> @@ -560,18 +793,18 @@ pub struct aya::maps::queue::Queue impl, V: aya::Pod> aya::maps::queue::Queue pub fn aya::maps::queue::Queue::capacity(&self) -> u32 impl, V: aya::Pod> aya::maps::queue::Queue -pub fn aya::maps::queue::Queue::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::queue::Queue::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::queue::Queue -pub fn aya::maps::queue::Queue::pop(&mut self, flags: u64) -> core::result::Result -pub fn aya::maps::queue::Queue::push(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::queue::Queue::pop(&mut self, flags: u64) -> core::result::Result +pub fn aya::maps::queue::Queue::push(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::queue::Queue<&'a aya::maps::MapData, V> -pub type aya::maps::queue::Queue<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::queue::Queue<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::queue::Queue<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::queue::Queue<&'a mut aya::maps::MapData, V> -pub type aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::queue::Queue -pub type aya::maps::queue::Queue::Error = aya::maps::MapError +pub type aya::maps::queue::Queue::Error = aya::errors::MapError pub fn aya::maps::queue::Queue::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::queue::Queue where T: core::marker::Freeze impl core::marker::Send for aya::maps::queue::Queue where T: core::marker::Send, V: core::marker::Send @@ -600,13 +833,13 @@ pub struct aya::maps::ring_buf::RingBuf impl aya::maps::ring_buf::RingBuf pub fn aya::maps::ring_buf::RingBuf::next(&mut self) -> core::option::Option> impl core::convert::TryFrom for aya::maps::ring_buf::RingBuf -pub type aya::maps::ring_buf::RingBuf::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData> -pub type aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData> -pub type aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl> std::os::fd::raw::AsRawFd for aya::maps::ring_buf::RingBuf pub fn aya::maps::ring_buf::RingBuf::as_raw_fd(&self) -> std::os::fd::raw::RawFd @@ -666,25 +899,25 @@ pub mod aya::maps::sock pub struct aya::maps::sock::SockHash impl, K: aya::Pod> aya::maps::SockHash pub fn aya::maps::SockHash::fd(&self) -> &aya::maps::sock::SockMapFd -pub fn aya::maps::SockHash::get(&self, key: &K, flags: u64) -> core::result::Result +pub fn aya::maps::SockHash::get(&self, key: &K, flags: u64) -> core::result::Result pub fn aya::maps::SockHash::iter(&self) -> aya::maps::MapIter<'_, K, std::os::fd::raw::RawFd, Self> pub fn aya::maps::SockHash::keys(&self) -> aya::maps::MapKeys<'_, K> impl, V: aya::Pod> aya::maps::SockHash -pub fn aya::maps::SockHash::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::SockHash::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, K: aya::Pod> aya::maps::SockHash -pub fn aya::maps::SockHash::insert(&mut self, key: impl core::borrow::Borrow, value: I, flags: u64) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::SockHash::remove(&mut self, key: &K) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::SockHash::insert(&mut self, key: impl core::borrow::Borrow, value: I, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::SockHash::remove(&mut self, key: &K) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::SockHash<&'a aya::maps::MapData, V> -pub type aya::maps::SockHash<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::SockHash<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::SockHash<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::SockHash<&'a mut aya::maps::MapData, V> -pub type aya::maps::SockHash<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::SockHash<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::SockHash<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl, K: aya::Pod> aya::maps::IterableMap for aya::maps::SockHash -pub fn aya::maps::SockHash::get(&self, key: &K) -> core::result::Result +pub fn aya::maps::SockHash::get(&self, key: &K) -> core::result::Result pub fn aya::maps::SockHash::map(&self) -> &aya::maps::MapData impl core::convert::TryFrom for aya::maps::SockHash -pub type aya::maps::SockHash::Error = aya::maps::MapError +pub type aya::maps::SockHash::Error = aya::errors::MapError pub fn aya::maps::SockHash::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::SockHash where T: core::marker::Freeze impl core::marker::Send for aya::maps::SockHash where T: core::marker::Send, K: core::marker::Send @@ -713,18 +946,18 @@ impl> aya::maps::SockMap pub fn aya::maps::SockMap::fd(&self) -> &aya::maps::sock::SockMapFd pub fn aya::maps::SockMap::indices(&self) -> aya::maps::MapKeys<'_, u32> impl> aya::maps::SockMap -pub fn aya::maps::SockMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::SockMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::SockMap -pub fn aya::maps::SockMap::clear_index(&mut self, index: &u32) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::SockMap::set(&mut self, index: u32, socket: &I, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::SockMap::clear_index(&mut self, index: &u32) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::SockMap::set(&mut self, index: u32, socket: &I, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::SockMap -pub type aya::maps::SockMap::Error = aya::maps::MapError +pub type aya::maps::SockMap::Error = aya::errors::MapError pub fn aya::maps::SockMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::SockMap<&'a aya::maps::MapData> -pub type aya::maps::SockMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::SockMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::SockMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::SockMap<&'a mut aya::maps::MapData> -pub type aya::maps::SockMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::SockMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::SockMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::SockMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::SockMap where T: core::marker::Send @@ -780,18 +1013,18 @@ pub struct aya::maps::stack::Stack impl, V: aya::Pod> aya::maps::stack::Stack pub fn aya::maps::stack::Stack::capacity(&self) -> u32 impl, V: aya::Pod> aya::maps::stack::Stack -pub fn aya::maps::stack::Stack::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::stack::Stack::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::stack::Stack -pub fn aya::maps::stack::Stack::pop(&mut self, flags: u64) -> core::result::Result -pub fn aya::maps::stack::Stack::push(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::stack::Stack::pop(&mut self, flags: u64) -> core::result::Result +pub fn aya::maps::stack::Stack::push(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::stack::Stack<&'a aya::maps::MapData, V> -pub type aya::maps::stack::Stack<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::stack::Stack<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::stack::Stack<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::stack::Stack<&'a mut aya::maps::MapData, V> -pub type aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::stack::Stack -pub type aya::maps::stack::Stack::Error = aya::maps::MapError +pub type aya::maps::stack::Stack::Error = aya::errors::MapError pub fn aya::maps::stack::Stack::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::stack::Stack where T: core::marker::Freeze impl core::marker::Send for aya::maps::stack::Stack where T: core::marker::Send, V: core::marker::Send @@ -845,7 +1078,7 @@ pub aya::maps::stack_trace::StackTrace::id: u32 impl aya::maps::stack_trace::StackTrace pub fn aya::maps::stack_trace::StackTrace::frames(&self) -> &[aya::maps::stack_trace::StackFrame] impl> aya::maps::IterableMap for aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::get(&self, index: &u32) -> core::result::Result +pub fn aya::maps::stack_trace::StackTraceMap::get(&self, index: &u32) -> core::result::Result pub fn aya::maps::stack_trace::StackTraceMap::map(&self) -> &aya::maps::MapData impl core::marker::Freeze for aya::maps::stack_trace::StackTrace impl core::marker::Send for aya::maps::stack_trace::StackTrace @@ -871,28 +1104,28 @@ impl core::convert::From for aya::maps::stack_trace::StackTrace pub fn aya::maps::stack_trace::StackTrace::from(t: T) -> T pub struct aya::maps::stack_trace::StackTraceMap impl> aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::get(&self, stack_id: &u32, flags: u64) -> core::result::Result +pub fn aya::maps::stack_trace::StackTraceMap::get(&self, stack_id: &u32, flags: u64) -> core::result::Result pub fn aya::maps::stack_trace::StackTraceMap::iter(&self) -> aya::maps::MapIter<'_, u32, aya::maps::stack_trace::StackTrace, Self> pub fn aya::maps::stack_trace::StackTraceMap::stack_ids(&self) -> aya::maps::MapKeys<'_, u32> impl> aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::stack_trace::StackTraceMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::remove(&mut self, stack_id: &u32) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::stack_trace::StackTraceMap::remove(&mut self, stack_id: &u32) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::stack_trace::StackTraceMap -pub type aya::maps::stack_trace::StackTraceMap::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a, T: core::borrow::Borrow> core::iter::traits::collect::IntoIterator for &'a aya::maps::stack_trace::StackTraceMap pub type &'a aya::maps::stack_trace::StackTraceMap::IntoIter = aya::maps::MapIter<'a, u32, aya::maps::stack_trace::StackTrace, aya::maps::stack_trace::StackTraceMap> -pub type &'a aya::maps::stack_trace::StackTraceMap::Item = core::result::Result<(u32, aya::maps::stack_trace::StackTrace), aya::maps::MapError> +pub type &'a aya::maps::stack_trace::StackTraceMap::Item = core::result::Result<(u32, aya::maps::stack_trace::StackTrace), aya::errors::MapError> pub fn &'a aya::maps::stack_trace::StackTraceMap::into_iter(self) -> Self::IntoIter impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData> -pub type aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData> -pub type aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl> aya::maps::IterableMap for aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::get(&self, index: &u32) -> core::result::Result +pub fn aya::maps::stack_trace::StackTraceMap::get(&self, index: &u32) -> core::result::Result pub fn aya::maps::stack_trace::StackTraceMap::map(&self) -> &aya::maps::MapData impl core::fmt::Debug for aya::maps::stack_trace::StackTraceMap pub fn aya::maps::stack_trace::StackTraceMap::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -919,58 +1152,23 @@ pub fn aya::maps::stack_trace::StackTraceMap::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::maps::stack_trace::StackTraceMap pub fn aya::maps::stack_trace::StackTraceMap::from(t: T) -> T pub mod aya::maps::xdp -pub enum aya::maps::xdp::XdpMapError -pub aya::maps::xdp::XdpMapError::ChainedProgramNotSupported -pub aya::maps::xdp::XdpMapError::MapError(aya::maps::MapError) -impl core::convert::From for aya::maps::xdp::XdpMapError -pub fn aya::maps::xdp::XdpMapError::from(source: aya::maps::MapError) -> Self -impl core::error::Error for aya::maps::xdp::XdpMapError -pub fn aya::maps::xdp::XdpMapError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::maps::xdp::XdpMapError -pub fn aya::maps::xdp::XdpMapError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::maps::xdp::XdpMapError -pub fn aya::maps::xdp::XdpMapError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::maps::xdp::XdpMapError -impl core::marker::Send for aya::maps::xdp::XdpMapError -impl core::marker::Sync for aya::maps::xdp::XdpMapError -impl core::marker::Unpin for aya::maps::xdp::XdpMapError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::maps::xdp::XdpMapError -impl !core::panic::unwind_safe::UnwindSafe for aya::maps::xdp::XdpMapError -impl core::convert::Into for aya::maps::xdp::XdpMapError where U: core::convert::From -pub fn aya::maps::xdp::XdpMapError::into(self) -> U -impl core::convert::TryFrom for aya::maps::xdp::XdpMapError where U: core::convert::Into -pub type aya::maps::xdp::XdpMapError::Error = core::convert::Infallible -pub fn aya::maps::xdp::XdpMapError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::maps::xdp::XdpMapError where U: core::convert::TryFrom -pub type aya::maps::xdp::XdpMapError::Error = >::Error -pub fn aya::maps::xdp::XdpMapError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::maps::xdp::XdpMapError where T: core::fmt::Display + core::marker::Sized -pub fn aya::maps::xdp::XdpMapError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::maps::xdp::XdpMapError where T: 'static + core::marker::Sized -pub fn aya::maps::xdp::XdpMapError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::maps::xdp::XdpMapError where T: core::marker::Sized -pub fn aya::maps::xdp::XdpMapError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::maps::xdp::XdpMapError where T: core::marker::Sized -pub fn aya::maps::xdp::XdpMapError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::maps::xdp::XdpMapError -pub fn aya::maps::xdp::XdpMapError::from(t: T) -> T pub struct aya::maps::xdp::CpuMap impl> aya::maps::CpuMap -pub fn aya::maps::CpuMap::get(&self, cpu_index: u32, flags: u64) -> core::result::Result -pub fn aya::maps::CpuMap::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ +pub fn aya::maps::CpuMap::get(&self, cpu_index: u32, flags: u64) -> core::result::Result +pub fn aya::maps::CpuMap::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ pub fn aya::maps::CpuMap::len(&self) -> u32 impl> aya::maps::CpuMap -pub fn aya::maps::CpuMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::CpuMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::CpuMap -pub fn aya::maps::CpuMap::set(&mut self, cpu_index: u32, queue_size: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::maps::xdp::XdpMapError> +pub fn aya::maps::CpuMap::set(&mut self, cpu_index: u32, queue_size: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::CpuMap -pub type aya::maps::CpuMap::Error = aya::maps::MapError +pub type aya::maps::CpuMap::Error = aya::errors::MapError pub fn aya::maps::CpuMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::CpuMap<&'a aya::maps::MapData> -pub type aya::maps::CpuMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::CpuMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::CpuMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::CpuMap<&'a mut aya::maps::MapData> -pub type aya::maps::CpuMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::CpuMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::CpuMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::CpuMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::CpuMap where T: core::marker::Send @@ -996,21 +1194,21 @@ impl core::convert::From for aya::maps::CpuMap pub fn aya::maps::CpuMap::from(t: T) -> T pub struct aya::maps::xdp::DevMap impl> aya::maps::DevMap -pub fn aya::maps::DevMap::get(&self, index: u32, flags: u64) -> core::result::Result -pub fn aya::maps::DevMap::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ +pub fn aya::maps::DevMap::get(&self, index: u32, flags: u64) -> core::result::Result +pub fn aya::maps::DevMap::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ pub fn aya::maps::DevMap::len(&self) -> u32 impl> aya::maps::DevMap -pub fn aya::maps::DevMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::DevMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::DevMap -pub fn aya::maps::DevMap::set(&mut self, index: u32, target_if_index: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::maps::xdp::XdpMapError> +pub fn aya::maps::DevMap::set(&mut self, index: u32, target_if_index: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::DevMap -pub type aya::maps::DevMap::Error = aya::maps::MapError +pub type aya::maps::DevMap::Error = aya::errors::MapError pub fn aya::maps::DevMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::DevMap<&'a aya::maps::MapData> -pub type aya::maps::DevMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::DevMap<&'a mut aya::maps::MapData> -pub type aya::maps::DevMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::DevMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::DevMap where T: core::marker::Send @@ -1036,22 +1234,22 @@ impl core::convert::From for aya::maps::DevMap pub fn aya::maps::DevMap::from(t: T) -> T pub struct aya::maps::xdp::DevMapHash impl> aya::maps::DevMapHash -pub fn aya::maps::DevMapHash::get(&self, key: u32, flags: u64) -> core::result::Result +pub fn aya::maps::DevMapHash::get(&self, key: u32, flags: u64) -> core::result::Result pub fn aya::maps::DevMapHash::iter(&self) -> aya::maps::MapIter<'_, u32, DevMapValue, Self> pub fn aya::maps::DevMapHash::keys(&self) -> aya::maps::MapKeys<'_, u32> impl> aya::maps::DevMapHash -pub fn aya::maps::DevMapHash::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::DevMapHash::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::DevMapHash -pub fn aya::maps::DevMapHash::insert(&mut self, key: u32, target_if_index: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::maps::xdp::XdpMapError> -pub fn aya::maps::DevMapHash::remove(&mut self, key: u32) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::DevMapHash::insert(&mut self, key: u32, target_if_index: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::DevMapHash::remove(&mut self, key: u32) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::DevMapHash -pub type aya::maps::DevMapHash::Error = aya::maps::MapError +pub type aya::maps::DevMapHash::Error = aya::errors::MapError pub fn aya::maps::DevMapHash::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::DevMapHash<&'a aya::maps::MapData> -pub type aya::maps::DevMapHash<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMapHash<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMapHash<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::DevMapHash<&'a mut aya::maps::MapData> -pub type aya::maps::DevMapHash<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMapHash<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMapHash<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::DevMapHash where T: core::marker::Freeze impl core::marker::Send for aya::maps::DevMapHash where T: core::marker::Send @@ -1079,17 +1277,17 @@ pub struct aya::maps::xdp::XskMap impl> aya::maps::XskMap pub fn aya::maps::XskMap::len(&self) -> u32 impl> aya::maps::XskMap -pub fn aya::maps::XskMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::XskMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::XskMap -pub fn aya::maps::XskMap::set(&mut self, index: u32, socket_fd: impl std::os::fd::raw::AsRawFd, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::XskMap::set(&mut self, index: u32, socket_fd: impl std::os::fd::raw::AsRawFd, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::XskMap -pub type aya::maps::XskMap::Error = aya::maps::MapError +pub type aya::maps::XskMap::Error = aya::errors::MapError pub fn aya::maps::XskMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::XskMap<&'a aya::maps::MapData> -pub type aya::maps::XskMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::XskMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::XskMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::XskMap<&'a mut aya::maps::MapData> -pub type aya::maps::XskMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::XskMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::XskMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::XskMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::XskMap where T: core::marker::Send @@ -1136,179 +1334,179 @@ pub aya::maps::Map::StackTraceMap(aya::maps::MapData) pub aya::maps::Map::Unsupported(aya::maps::MapData) pub aya::maps::Map::XskMap(aya::maps::MapData) impl aya::maps::Map -pub fn aya::maps::Map::pin>(&self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::Map::pin>(&self, path: P) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::CpuMap -pub type aya::maps::CpuMap::Error = aya::maps::MapError +pub type aya::maps::CpuMap::Error = aya::errors::MapError pub fn aya::maps::CpuMap::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::DevMap -pub type aya::maps::DevMap::Error = aya::maps::MapError +pub type aya::maps::DevMap::Error = aya::errors::MapError pub fn aya::maps::DevMap::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::DevMapHash -pub type aya::maps::DevMapHash::Error = aya::maps::MapError +pub type aya::maps::DevMapHash::Error = aya::errors::MapError pub fn aya::maps::DevMapHash::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::ProgramArray -pub type aya::maps::ProgramArray::Error = aya::maps::MapError +pub type aya::maps::ProgramArray::Error = aya::errors::MapError pub fn aya::maps::ProgramArray::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::SockMap -pub type aya::maps::SockMap::Error = aya::maps::MapError +pub type aya::maps::SockMap::Error = aya::errors::MapError pub fn aya::maps::SockMap::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::XskMap -pub type aya::maps::XskMap::Error = aya::maps::MapError +pub type aya::maps::XskMap::Error = aya::errors::MapError pub fn aya::maps::XskMap::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::perf::AsyncPerfEventArray -pub type aya::maps::perf::AsyncPerfEventArray::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::perf::PerfEventArray -pub type aya::maps::perf::PerfEventArray::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::ring_buf::RingBuf -pub type aya::maps::ring_buf::RingBuf::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::stack_trace::StackTraceMap -pub type aya::maps::stack_trace::StackTraceMap::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap::try_from(map: aya::maps::Map) -> core::result::Result impl core::fmt::Debug for aya::maps::Map pub fn aya::maps::Map::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V> -pub type aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V> -pub type aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V> -pub type aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::PerCpuArray<&'a aya::maps::MapData, V> -pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::SockHash<&'a aya::maps::MapData, V> -pub type aya::maps::SockHash<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::SockHash<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::SockHash<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::array::Array<&'a aya::maps::MapData, V> -pub type aya::maps::array::Array<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::array::Array<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::array::Array<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V> -pub type aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::queue::Queue<&'a aya::maps::MapData, V> -pub type aya::maps::queue::Queue<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::queue::Queue<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::queue::Queue<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::stack::Stack<&'a aya::maps::MapData, V> -pub type aya::maps::stack::Stack<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::stack::Stack<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::stack::Stack<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V> -pub type aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::SockHash<&'a mut aya::maps::MapData, V> -pub type aya::maps::SockHash<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::SockHash<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::SockHash<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::array::Array<&'a mut aya::maps::MapData, V> -pub type aya::maps::array::Array<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::array::Array<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::array::Array<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V> -pub type aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::queue::Queue<&'a mut aya::maps::MapData, V> -pub type aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::stack::Stack<&'a mut aya::maps::MapData, V> -pub type aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::CpuMap<&'a aya::maps::MapData> -pub type aya::maps::CpuMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::CpuMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::CpuMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::DevMap<&'a aya::maps::MapData> -pub type aya::maps::DevMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::DevMapHash<&'a aya::maps::MapData> -pub type aya::maps::DevMapHash<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMapHash<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMapHash<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ProgramArray<&'a aya::maps::MapData> -pub type aya::maps::ProgramArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ProgramArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ProgramArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::SockMap<&'a aya::maps::MapData> -pub type aya::maps::SockMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::SockMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::SockMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::XskMap<&'a aya::maps::MapData> -pub type aya::maps::XskMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::XskMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::XskMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData> -pub type aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::perf::PerfEventArray<&'a aya::maps::MapData> -pub type aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData> -pub type aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData> -pub type aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::CpuMap<&'a mut aya::maps::MapData> -pub type aya::maps::CpuMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::CpuMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::CpuMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::DevMap<&'a mut aya::maps::MapData> -pub type aya::maps::DevMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::DevMapHash<&'a mut aya::maps::MapData> -pub type aya::maps::DevMapHash<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMapHash<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMapHash<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ProgramArray<&'a mut aya::maps::MapData> -pub type aya::maps::ProgramArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ProgramArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ProgramArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::SockMap<&'a mut aya::maps::MapData> -pub type aya::maps::SockMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::SockMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::SockMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::XskMap<&'a mut aya::maps::MapData> -pub type aya::maps::XskMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::XskMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::XskMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData> -pub type aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData> -pub type aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData> -pub type aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData> -pub type aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::hash_map::HashMap -pub type aya::maps::hash_map::HashMap::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::hash_map::PerCpuHashMap -pub type aya::maps::hash_map::PerCpuHashMap::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::lpm_trie::LpmTrie -pub type aya::maps::lpm_trie::LpmTrie::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::PerCpuArray -pub type aya::maps::PerCpuArray::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::SockHash -pub type aya::maps::SockHash::Error = aya::maps::MapError +pub type aya::maps::SockHash::Error = aya::errors::MapError pub fn aya::maps::SockHash::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::array::Array -pub type aya::maps::array::Array::Error = aya::maps::MapError +pub type aya::maps::array::Array::Error = aya::errors::MapError pub fn aya::maps::array::Array::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::bloom_filter::BloomFilter -pub type aya::maps::bloom_filter::BloomFilter::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::queue::Queue -pub type aya::maps::queue::Queue::Error = aya::maps::MapError +pub type aya::maps::queue::Queue::Error = aya::errors::MapError pub fn aya::maps::queue::Queue::try_from(map: aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::stack::Stack -pub type aya::maps::stack::Stack::Error = aya::maps::MapError +pub type aya::maps::stack::Stack::Error = aya::errors::MapError pub fn aya::maps::stack::Stack::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::Map impl core::marker::Send for aya::maps::Map @@ -1332,77 +1530,6 @@ impl core::borrow::BorrowMut for aya::maps::Map where T: core::marker::Siz pub fn aya::maps::Map::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::maps::Map pub fn aya::maps::Map::from(t: T) -> T -pub enum aya::maps::MapError -pub aya::maps::MapError::CreateError -pub aya::maps::MapError::CreateError::code: i64 -pub aya::maps::MapError::CreateError::io_error: std::io::error::Error -pub aya::maps::MapError::CreateError::name: alloc::string::String -pub aya::maps::MapError::ElementNotFound -pub aya::maps::MapError::InvalidKeySize -pub aya::maps::MapError::InvalidKeySize::expected: usize -pub aya::maps::MapError::InvalidKeySize::size: usize -pub aya::maps::MapError::InvalidMapType -pub aya::maps::MapError::InvalidMapType::map_type: u32 -pub aya::maps::MapError::InvalidName -pub aya::maps::MapError::InvalidName::name: alloc::string::String -pub aya::maps::MapError::InvalidValueSize -pub aya::maps::MapError::InvalidValueSize::expected: usize -pub aya::maps::MapError::InvalidValueSize::size: usize -pub aya::maps::MapError::IoError(std::io::error::Error) -pub aya::maps::MapError::KeyNotFound -pub aya::maps::MapError::OutOfBounds -pub aya::maps::MapError::OutOfBounds::index: u32 -pub aya::maps::MapError::OutOfBounds::max_entries: u32 -pub aya::maps::MapError::PinError -pub aya::maps::MapError::PinError::error: aya::pin::PinError -pub aya::maps::MapError::PinError::name: core::option::Option -pub aya::maps::MapError::ProgIdNotSupported -pub aya::maps::MapError::ProgramNotLoaded -pub aya::maps::MapError::SyscallError(aya::sys::SyscallError) -pub aya::maps::MapError::Unsupported -pub aya::maps::MapError::Unsupported::map_type: u32 -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(source: aya::maps::MapError) -> Self -impl core::convert::From for aya::maps::xdp::XdpMapError -pub fn aya::maps::xdp::XdpMapError::from(source: aya::maps::MapError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::maps::MapError) -> Self -impl core::convert::From for aya::maps::MapError -pub fn aya::maps::MapError::from(source: aya::sys::SyscallError) -> Self -impl core::convert::From> for aya::maps::MapError -pub fn aya::maps::MapError::from(e: aya_obj::obj::InvalidTypeBinding) -> Self -impl core::convert::From for aya::maps::MapError -pub fn aya::maps::MapError::from(source: std::io::error::Error) -> Self -impl core::error::Error for aya::maps::MapError -pub fn aya::maps::MapError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::maps::MapError -pub fn aya::maps::MapError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::maps::MapError -pub fn aya::maps::MapError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::maps::MapError -impl core::marker::Send for aya::maps::MapError -impl core::marker::Sync for aya::maps::MapError -impl core::marker::Unpin for aya::maps::MapError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::maps::MapError -impl !core::panic::unwind_safe::UnwindSafe for aya::maps::MapError -impl core::convert::Into for aya::maps::MapError where U: core::convert::From -pub fn aya::maps::MapError::into(self) -> U -impl core::convert::TryFrom for aya::maps::MapError where U: core::convert::Into -pub type aya::maps::MapError::Error = core::convert::Infallible -pub fn aya::maps::MapError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::maps::MapError where U: core::convert::TryFrom -pub type aya::maps::MapError::Error = >::Error -pub fn aya::maps::MapError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::maps::MapError where T: core::fmt::Display + core::marker::Sized -pub fn aya::maps::MapError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::maps::MapError where T: 'static + core::marker::Sized -pub fn aya::maps::MapError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::maps::MapError where T: core::marker::Sized -pub fn aya::maps::MapError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::maps::MapError where T: core::marker::Sized -pub fn aya::maps::MapError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::maps::MapError -pub fn aya::maps::MapError::from(t: T) -> T #[non_exhaustive] pub enum aya::maps::MapType pub aya::maps::MapType::Arena = 33 pub aya::maps::MapType::Array = 2 @@ -1443,7 +1570,7 @@ pub fn aya::maps::MapType::clone(&self) -> aya::maps::MapType impl core::cmp::PartialEq for aya::maps::MapType pub fn aya::maps::MapType::eq(&self, other: &aya::maps::MapType) -> bool impl core::convert::TryFrom for aya::maps::MapType -pub type aya::maps::MapType::Error = aya::maps::MapError +pub type aya::maps::MapType::Error = aya::errors::MapError pub fn aya::maps::MapType::try_from(map_type: aya_obj::generated::linux_bindings_x86_64::bpf_map_type) -> core::result::Result impl core::fmt::Debug for aya::maps::MapType pub fn aya::maps::MapType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -1479,24 +1606,24 @@ impl core::convert::From for aya::maps::MapType pub fn aya::maps::MapType::from(t: T) -> T pub struct aya::maps::Array impl, V: aya::Pod> aya::maps::array::Array -pub fn aya::maps::array::Array::get(&self, index: &u32, flags: u64) -> core::result::Result -pub fn aya::maps::array::Array::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ +pub fn aya::maps::array::Array::get(&self, index: &u32, flags: u64) -> core::result::Result +pub fn aya::maps::array::Array::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ pub fn aya::maps::array::Array::len(&self) -> u32 impl, V: aya::Pod> aya::maps::array::Array -pub fn aya::maps::array::Array::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::array::Array::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::array::Array -pub fn aya::maps::array::Array::set(&mut self, index: u32, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::array::Array::set(&mut self, index: u32, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::array::Array<&'a aya::maps::MapData, V> -pub type aya::maps::array::Array<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::array::Array<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::array::Array<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::array::Array<&'a mut aya::maps::MapData, V> -pub type aya::maps::array::Array<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::array::Array<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::array::Array<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl, V: aya::Pod> aya::maps::IterableMap for aya::maps::array::Array -pub fn aya::maps::array::Array::get(&self, index: &u32) -> core::result::Result +pub fn aya::maps::array::Array::get(&self, index: &u32) -> core::result::Result pub fn aya::maps::array::Array::map(&self) -> &aya::maps::MapData impl core::convert::TryFrom for aya::maps::array::Array -pub type aya::maps::array::Array::Error = aya::maps::MapError +pub type aya::maps::array::Array::Error = aya::errors::MapError pub fn aya::maps::array::Array::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::array::Array where T: core::marker::Freeze impl core::marker::Send for aya::maps::array::Array where T: core::marker::Send, V: core::marker::Send @@ -1522,16 +1649,16 @@ impl core::convert::From for aya::maps::array::Array pub fn aya::maps::array::Array::from(t: T) -> T pub struct aya::maps::AsyncPerfEventArray impl> aya::maps::perf::AsyncPerfEventArray -pub fn aya::maps::perf::AsyncPerfEventArray::open(&mut self, index: u32, page_count: core::option::Option) -> core::result::Result, aya::maps::perf::PerfBufferError> -pub fn aya::maps::perf::AsyncPerfEventArray::pin>(&self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::perf::AsyncPerfEventArray::open(&mut self, index: u32, page_count: core::option::Option) -> core::result::Result, aya::errors::PerfBufferError> +pub fn aya::maps::perf::AsyncPerfEventArray::pin>(&self, path: P) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::perf::AsyncPerfEventArray -pub type aya::maps::perf::AsyncPerfEventArray::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData> -pub type aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData> -pub type aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::AsyncPerfEventArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::perf::AsyncPerfEventArray impl core::marker::Send for aya::maps::perf::AsyncPerfEventArray where T: core::marker::Sync + core::marker::Send @@ -1557,21 +1684,21 @@ impl core::convert::From for aya::maps::perf::AsyncPerfEventArray pub fn aya::maps::perf::AsyncPerfEventArray::from(t: T) -> T pub struct aya::maps::BloomFilter impl, V: aya::Pod> aya::maps::bloom_filter::BloomFilter -pub fn aya::maps::bloom_filter::BloomFilter::contains(&self, value: &V, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::bloom_filter::BloomFilter::contains(&self, value: &V, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::bloom_filter::BloomFilter -pub fn aya::maps::bloom_filter::BloomFilter::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::bloom_filter::BloomFilter::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::bloom_filter::BloomFilter -pub fn aya::maps::bloom_filter::BloomFilter::insert(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::bloom_filter::BloomFilter::insert(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V> -pub type aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V> -pub type aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::fmt::Debug for aya::maps::bloom_filter::BloomFilter pub fn aya::maps::bloom_filter::BloomFilter::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::convert::TryFrom for aya::maps::bloom_filter::BloomFilter -pub type aya::maps::bloom_filter::BloomFilter::Error = aya::maps::MapError +pub type aya::maps::bloom_filter::BloomFilter::Error = aya::errors::MapError pub fn aya::maps::bloom_filter::BloomFilter::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::bloom_filter::BloomFilter where T: core::marker::Freeze impl core::marker::Send for aya::maps::bloom_filter::BloomFilter where T: core::marker::Send, V: core::marker::Send @@ -1597,21 +1724,21 @@ impl core::convert::From for aya::maps::bloom_filter::BloomFilter pub fn aya::maps::bloom_filter::BloomFilter::from(t: T) -> T pub struct aya::maps::CpuMap impl> aya::maps::CpuMap -pub fn aya::maps::CpuMap::get(&self, cpu_index: u32, flags: u64) -> core::result::Result -pub fn aya::maps::CpuMap::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ +pub fn aya::maps::CpuMap::get(&self, cpu_index: u32, flags: u64) -> core::result::Result +pub fn aya::maps::CpuMap::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ pub fn aya::maps::CpuMap::len(&self) -> u32 impl> aya::maps::CpuMap -pub fn aya::maps::CpuMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::CpuMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::CpuMap -pub fn aya::maps::CpuMap::set(&mut self, cpu_index: u32, queue_size: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::maps::xdp::XdpMapError> +pub fn aya::maps::CpuMap::set(&mut self, cpu_index: u32, queue_size: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::CpuMap -pub type aya::maps::CpuMap::Error = aya::maps::MapError +pub type aya::maps::CpuMap::Error = aya::errors::MapError pub fn aya::maps::CpuMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::CpuMap<&'a aya::maps::MapData> -pub type aya::maps::CpuMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::CpuMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::CpuMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::CpuMap<&'a mut aya::maps::MapData> -pub type aya::maps::CpuMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::CpuMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::CpuMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::CpuMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::CpuMap where T: core::marker::Send @@ -1637,21 +1764,21 @@ impl core::convert::From for aya::maps::CpuMap pub fn aya::maps::CpuMap::from(t: T) -> T pub struct aya::maps::DevMap impl> aya::maps::DevMap -pub fn aya::maps::DevMap::get(&self, index: u32, flags: u64) -> core::result::Result -pub fn aya::maps::DevMap::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ +pub fn aya::maps::DevMap::get(&self, index: u32, flags: u64) -> core::result::Result +pub fn aya::maps::DevMap::iter(&self) -> impl core::iter::traits::iterator::Iterator> + '_ pub fn aya::maps::DevMap::len(&self) -> u32 impl> aya::maps::DevMap -pub fn aya::maps::DevMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::DevMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::DevMap -pub fn aya::maps::DevMap::set(&mut self, index: u32, target_if_index: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::maps::xdp::XdpMapError> +pub fn aya::maps::DevMap::set(&mut self, index: u32, target_if_index: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::DevMap -pub type aya::maps::DevMap::Error = aya::maps::MapError +pub type aya::maps::DevMap::Error = aya::errors::MapError pub fn aya::maps::DevMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::DevMap<&'a aya::maps::MapData> -pub type aya::maps::DevMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::DevMap<&'a mut aya::maps::MapData> -pub type aya::maps::DevMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::DevMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::DevMap where T: core::marker::Send @@ -1677,22 +1804,22 @@ impl core::convert::From for aya::maps::DevMap pub fn aya::maps::DevMap::from(t: T) -> T pub struct aya::maps::DevMapHash impl> aya::maps::DevMapHash -pub fn aya::maps::DevMapHash::get(&self, key: u32, flags: u64) -> core::result::Result +pub fn aya::maps::DevMapHash::get(&self, key: u32, flags: u64) -> core::result::Result pub fn aya::maps::DevMapHash::iter(&self) -> aya::maps::MapIter<'_, u32, DevMapValue, Self> pub fn aya::maps::DevMapHash::keys(&self) -> aya::maps::MapKeys<'_, u32> impl> aya::maps::DevMapHash -pub fn aya::maps::DevMapHash::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::DevMapHash::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::DevMapHash -pub fn aya::maps::DevMapHash::insert(&mut self, key: u32, target_if_index: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::maps::xdp::XdpMapError> -pub fn aya::maps::DevMapHash::remove(&mut self, key: u32) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::DevMapHash::insert(&mut self, key: u32, target_if_index: u32, program: core::option::Option<&aya::programs::ProgramFd>, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::DevMapHash::remove(&mut self, key: u32) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::DevMapHash -pub type aya::maps::DevMapHash::Error = aya::maps::MapError +pub type aya::maps::DevMapHash::Error = aya::errors::MapError pub fn aya::maps::DevMapHash::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::DevMapHash<&'a aya::maps::MapData> -pub type aya::maps::DevMapHash<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMapHash<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMapHash<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::DevMapHash<&'a mut aya::maps::MapData> -pub type aya::maps::DevMapHash<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::DevMapHash<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::DevMapHash<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::DevMapHash where T: core::marker::Freeze impl core::marker::Send for aya::maps::DevMapHash where T: core::marker::Send @@ -1718,25 +1845,25 @@ impl core::convert::From for aya::maps::DevMapHash pub fn aya::maps::DevMapHash::from(t: T) -> T pub struct aya::maps::HashMap impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::get(&self, key: &K, flags: u64) -> core::result::Result +pub fn aya::maps::hash_map::HashMap::get(&self, key: &K, flags: u64) -> core::result::Result pub fn aya::maps::hash_map::HashMap::iter(&self) -> aya::maps::MapIter<'_, K, V, Self> pub fn aya::maps::hash_map::HashMap::keys(&self) -> aya::maps::MapKeys<'_, K> impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::hash_map::HashMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::insert(&mut self, key: impl core::borrow::Borrow, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::hash_map::HashMap::remove(&mut self, key: &K) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::hash_map::HashMap::insert(&mut self, key: impl core::borrow::Borrow, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::hash_map::HashMap::remove(&mut self, key: &K) -> core::result::Result<(), aya::errors::MapError> impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V> -pub type aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::hash_map::HashMap -pub type aya::maps::hash_map::HashMap::Error = aya::maps::MapError +pub type aya::maps::hash_map::HashMap::Error = aya::errors::MapError pub fn aya::maps::hash_map::HashMap::try_from(map: aya::maps::Map) -> core::result::Result impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap for aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::get(&self, key: &K) -> core::result::Result +pub fn aya::maps::hash_map::HashMap::get(&self, key: &K) -> core::result::Result pub fn aya::maps::hash_map::HashMap::map(&self) -> &aya::maps::MapData impl core::fmt::Debug for aya::maps::hash_map::HashMap pub fn aya::maps::hash_map::HashMap::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -1764,25 +1891,25 @@ impl core::convert::From for aya::maps::hash_map::HashMap pub fn aya::maps::hash_map::HashMap::from(t: T) -> T pub struct aya::maps::LpmTrie impl, K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key, flags: u64) -> core::result::Result +pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key, flags: u64) -> core::result::Result pub fn aya::maps::lpm_trie::LpmTrie::iter(&self) -> aya::maps::MapIter<'_, aya::maps::lpm_trie::Key, V, Self> pub fn aya::maps::lpm_trie::LpmTrie::keys(&self) -> aya::maps::MapKeys<'_, aya::maps::lpm_trie::Key> impl, K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::lpm_trie::LpmTrie::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, K: aya::Pod, V: aya::Pod> aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::insert(&mut self, key: &aya::maps::lpm_trie::Key, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::lpm_trie::LpmTrie::remove(&mut self, key: &aya::maps::lpm_trie::Key) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::lpm_trie::LpmTrie::insert(&mut self, key: &aya::maps::lpm_trie::Key, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::lpm_trie::LpmTrie::remove(&mut self, key: &aya::maps::lpm_trie::Key) -> core::result::Result<(), aya::errors::MapError> impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V> -pub type aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::lpm_trie::LpmTrie -pub type aya::maps::lpm_trie::LpmTrie::Error = aya::maps::MapError +pub type aya::maps::lpm_trie::LpmTrie::Error = aya::errors::MapError pub fn aya::maps::lpm_trie::LpmTrie::try_from(map: aya::maps::Map) -> core::result::Result impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap, V> for aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key) -> core::result::Result +pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key) -> core::result::Result pub fn aya::maps::lpm_trie::LpmTrie::map(&self) -> &aya::maps::MapData impl core::fmt::Debug for aya::maps::lpm_trie::LpmTrie pub fn aya::maps::lpm_trie::LpmTrie::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -1810,13 +1937,13 @@ impl core::convert::From for aya::maps::lpm_trie::LpmTrie pub fn aya::maps::lpm_trie::LpmTrie::from(t: T) -> T pub struct aya::maps::MapData impl aya::maps::MapData -pub fn aya::maps::MapData::create(obj: aya_obj::maps::Map, name: &str, btf_fd: core::option::Option>) -> core::result::Result +pub fn aya::maps::MapData::create(obj: aya_obj::maps::Map, name: &str, btf_fd: core::option::Option>) -> core::result::Result pub fn aya::maps::MapData::fd(&self) -> &aya::maps::MapFd -pub fn aya::maps::MapData::from_fd(fd: std::os::fd::owned::OwnedFd) -> core::result::Result -pub fn aya::maps::MapData::from_id(id: u32) -> core::result::Result -pub fn aya::maps::MapData::from_pin>(path: P) -> core::result::Result -pub fn aya::maps::MapData::info(&self) -> core::result::Result -pub fn aya::maps::MapData::pin>(&self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::MapData::from_fd(fd: std::os::fd::owned::OwnedFd) -> core::result::Result +pub fn aya::maps::MapData::from_id(id: u32) -> core::result::Result +pub fn aya::maps::MapData::from_pin>(path: P) -> core::result::Result +pub fn aya::maps::MapData::info(&self) -> core::result::Result +pub fn aya::maps::MapData::pin>(&self, path: P) -> core::result::Result<(), aya::errors::MapError> impl core::fmt::Debug for aya::maps::MapData pub fn aya::maps::MapData::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::marker::Freeze for aya::maps::MapData @@ -1870,13 +1997,13 @@ impl core::convert::From for aya::maps::MapFd pub fn aya::maps::MapFd::from(t: T) -> T pub struct aya::maps::MapInfo(_) impl aya::maps::MapInfo -pub fn aya::maps::MapInfo::fd(&self) -> core::result::Result -pub fn aya::maps::MapInfo::from_id(id: u32) -> core::result::Result -pub fn aya::maps::MapInfo::from_pin>(path: P) -> core::result::Result +pub fn aya::maps::MapInfo::fd(&self) -> core::result::Result +pub fn aya::maps::MapInfo::from_id(id: u32) -> core::result::Result +pub fn aya::maps::MapInfo::from_pin>(path: P) -> core::result::Result pub fn aya::maps::MapInfo::id(&self) -> u32 pub fn aya::maps::MapInfo::key_size(&self) -> u32 pub fn aya::maps::MapInfo::map_flags(&self) -> u32 -pub fn aya::maps::MapInfo::map_type(&self) -> core::result::Result +pub fn aya::maps::MapInfo::map_type(&self) -> core::result::Result pub fn aya::maps::MapInfo::max_entries(&self) -> u32 pub fn aya::maps::MapInfo::name(&self) -> &[u8] pub fn aya::maps::MapInfo::name_as_str(&self) -> core::option::Option<&str> @@ -1907,7 +2034,7 @@ impl core::convert::From for aya::maps::MapInfo pub fn aya::maps::MapInfo::from(t: T) -> T pub struct aya::maps::MapIter<'coll, K: aya::Pod, V, I: aya::maps::IterableMap> impl> core::iter::traits::iterator::Iterator for aya::maps::MapIter<'_, K, V, I> -pub type aya::maps::MapIter<'_, K, V, I>::Item = core::result::Result<(K, V), aya::maps::MapError> +pub type aya::maps::MapIter<'_, K, V, I>::Item = core::result::Result<(K, V), aya::errors::MapError> pub fn aya::maps::MapIter<'_, K, V, I>::next(&mut self) -> core::option::Option impl<'coll, K, V, I> core::marker::Freeze for aya::maps::MapIter<'coll, K, V, I> where K: core::marker::Freeze impl<'coll, K, V, I> core::marker::Send for aya::maps::MapIter<'coll, K, V, I> where I: core::marker::Sync, V: core::marker::Send, K: core::marker::Send @@ -1937,8 +2064,8 @@ impl core::convert::From for aya::maps::MapIter<'coll, K, V, I> pub fn aya::maps::MapIter<'coll, K, V, I>::from(t: T) -> T pub struct aya::maps::MapKeys<'coll, K: aya::Pod> impl core::iter::traits::iterator::Iterator for aya::maps::MapKeys<'_, K> -pub type aya::maps::MapKeys<'_, K>::Item = core::result::Result -pub fn aya::maps::MapKeys<'_, K>::next(&mut self) -> core::option::Option> +pub type aya::maps::MapKeys<'_, K>::Item = core::result::Result +pub fn aya::maps::MapKeys<'_, K>::next(&mut self) -> core::option::Option> impl<'coll, K> core::marker::Freeze for aya::maps::MapKeys<'coll, K> where K: core::marker::Freeze impl<'coll, K> core::marker::Send for aya::maps::MapKeys<'coll, K> where K: core::marker::Send impl<'coll, K> core::marker::Sync for aya::maps::MapKeys<'coll, K> where K: core::marker::Sync @@ -1967,24 +2094,24 @@ impl core::convert::From for aya::maps::MapKeys<'coll, K> pub fn aya::maps::MapKeys<'coll, K>::from(t: T) -> T pub struct aya::maps::PerCpuArray impl, V: aya::Pod> aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::get(&self, index: &u32, flags: u64) -> core::result::Result, aya::maps::MapError> -pub fn aya::maps::PerCpuArray::iter(&self) -> impl core::iter::traits::iterator::Iterator, aya::maps::MapError>> + '_ +pub fn aya::maps::PerCpuArray::get(&self, index: &u32, flags: u64) -> core::result::Result, aya::errors::MapError> +pub fn aya::maps::PerCpuArray::iter(&self) -> impl core::iter::traits::iterator::Iterator, aya::errors::MapError>> + '_ pub fn aya::maps::PerCpuArray::len(&self) -> u32 impl, V: aya::Pod> aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::PerCpuArray::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::set(&mut self, index: u32, values: aya::maps::PerCpuValues, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::PerCpuArray::set(&mut self, index: u32, values: aya::maps::PerCpuValues, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::PerCpuArray<&'a aya::maps::MapData, V> -pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V> -pub type aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl, V: aya::Pod> aya::maps::IterableMap> for aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::get(&self, index: &u32) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::PerCpuArray::get(&self, index: &u32) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::PerCpuArray::map(&self) -> &aya::maps::MapData impl core::convert::TryFrom for aya::maps::PerCpuArray -pub type aya::maps::PerCpuArray::Error = aya::maps::MapError +pub type aya::maps::PerCpuArray::Error = aya::errors::MapError pub fn aya::maps::PerCpuArray::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::PerCpuArray where T: core::marker::Freeze impl core::marker::Send for aya::maps::PerCpuArray where T: core::marker::Send, V: core::marker::Send @@ -2010,25 +2137,25 @@ impl core::convert::From for aya::maps::PerCpuArray pub fn aya::maps::PerCpuArray::from(t: T) -> T pub struct aya::maps::PerCpuHashMap impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K, flags: u64) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K, flags: u64) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::hash_map::PerCpuHashMap::iter(&self) -> aya::maps::MapIter<'_, K, aya::maps::PerCpuValues, Self> pub fn aya::maps::hash_map::PerCpuHashMap::keys(&self) -> aya::maps::MapKeys<'_, K> impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::hash_map::PerCpuHashMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, K: aya::Pod, V: aya::Pod> aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::insert(&mut self, key: impl core::borrow::Borrow, values: aya::maps::PerCpuValues, flags: u64) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::hash_map::PerCpuHashMap::remove(&mut self, key: &K) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::insert(&mut self, key: impl core::borrow::Borrow, values: aya::maps::PerCpuValues, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::remove(&mut self, key: &K) -> core::result::Result<(), aya::errors::MapError> impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V> -pub type aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap<&'a aya::maps::MapData, K, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, K: aya::Pod, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V> -pub type aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap<&'a mut aya::maps::MapData, K, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::hash_map::PerCpuHashMap -pub type aya::maps::hash_map::PerCpuHashMap::Error = aya::maps::MapError +pub type aya::maps::hash_map::PerCpuHashMap::Error = aya::errors::MapError pub fn aya::maps::hash_map::PerCpuHashMap::try_from(map: aya::maps::Map) -> core::result::Result impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap> for aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::hash_map::PerCpuHashMap::map(&self) -> &aya::maps::MapData impl core::marker::Freeze for aya::maps::hash_map::PerCpuHashMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::hash_map::PerCpuHashMap where T: core::marker::Send, K: core::marker::Send, V: core::marker::Send @@ -2060,10 +2187,10 @@ impl core::ops::deref::Deref for aya::maps::PerCpuValues pub type aya::maps::PerCpuValues::Target = alloc::boxed::Box<[T]> pub fn aya::maps::PerCpuValues::deref(&self) -> &Self::Target impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap> for aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::hash_map::PerCpuHashMap::map(&self) -> &aya::maps::MapData impl, V: aya::Pod> aya::maps::IterableMap> for aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::get(&self, index: &u32) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::PerCpuArray::get(&self, index: &u32) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::PerCpuArray::map(&self) -> &aya::maps::MapData impl core::fmt::Debug for aya::maps::PerCpuValues pub fn aya::maps::PerCpuValues::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -2091,17 +2218,17 @@ impl core::convert::From for aya::maps::PerCpuValues pub fn aya::maps::PerCpuValues::from(t: T) -> T pub struct aya::maps::PerfEventArray impl> aya::maps::perf::PerfEventArray -pub fn aya::maps::perf::PerfEventArray::pin>(&self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::perf::PerfEventArray::pin>(&self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::perf::PerfEventArray -pub fn aya::maps::perf::PerfEventArray::open(&mut self, index: u32, page_count: core::option::Option) -> core::result::Result, aya::maps::perf::PerfBufferError> +pub fn aya::maps::perf::PerfEventArray::open(&mut self, index: u32, page_count: core::option::Option) -> core::result::Result, aya::errors::PerfBufferError> impl core::convert::TryFrom for aya::maps::perf::PerfEventArray -pub type aya::maps::perf::PerfEventArray::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::perf::PerfEventArray<&'a aya::maps::MapData> -pub type aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData> -pub type aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::perf::PerfEventArray impl core::marker::Send for aya::maps::perf::PerfEventArray where T: core::marker::Sync + core::marker::Send @@ -2129,18 +2256,18 @@ pub struct aya::maps::ProgramArray impl> aya::maps::ProgramArray pub fn aya::maps::ProgramArray::indices(&self) -> aya::maps::MapKeys<'_, u32> impl> aya::maps::ProgramArray -pub fn aya::maps::ProgramArray::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::ProgramArray::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::ProgramArray -pub fn aya::maps::ProgramArray::clear_index(&mut self, index: &u32) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::ProgramArray::set(&mut self, index: u32, program: &aya::programs::ProgramFd, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::ProgramArray::clear_index(&mut self, index: &u32) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::ProgramArray::set(&mut self, index: u32, program: &aya::programs::ProgramFd, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::ProgramArray -pub type aya::maps::ProgramArray::Error = aya::maps::MapError +pub type aya::maps::ProgramArray::Error = aya::errors::MapError pub fn aya::maps::ProgramArray::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ProgramArray<&'a aya::maps::MapData> -pub type aya::maps::ProgramArray<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ProgramArray<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ProgramArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ProgramArray<&'a mut aya::maps::MapData> -pub type aya::maps::ProgramArray<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ProgramArray<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ProgramArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::ProgramArray where T: core::marker::Freeze impl core::marker::Send for aya::maps::ProgramArray where T: core::marker::Send @@ -2168,18 +2295,18 @@ pub struct aya::maps::Queue impl, V: aya::Pod> aya::maps::queue::Queue pub fn aya::maps::queue::Queue::capacity(&self) -> u32 impl, V: aya::Pod> aya::maps::queue::Queue -pub fn aya::maps::queue::Queue::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::queue::Queue::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::queue::Queue -pub fn aya::maps::queue::Queue::pop(&mut self, flags: u64) -> core::result::Result -pub fn aya::maps::queue::Queue::push(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::queue::Queue::pop(&mut self, flags: u64) -> core::result::Result +pub fn aya::maps::queue::Queue::push(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::queue::Queue<&'a aya::maps::MapData, V> -pub type aya::maps::queue::Queue<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::queue::Queue<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::queue::Queue<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::queue::Queue<&'a mut aya::maps::MapData, V> -pub type aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::queue::Queue<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::queue::Queue -pub type aya::maps::queue::Queue::Error = aya::maps::MapError +pub type aya::maps::queue::Queue::Error = aya::errors::MapError pub fn aya::maps::queue::Queue::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::queue::Queue where T: core::marker::Freeze impl core::marker::Send for aya::maps::queue::Queue where T: core::marker::Send, V: core::marker::Send @@ -2207,13 +2334,13 @@ pub struct aya::maps::RingBuf impl aya::maps::ring_buf::RingBuf pub fn aya::maps::ring_buf::RingBuf::next(&mut self) -> core::option::Option> impl core::convert::TryFrom for aya::maps::ring_buf::RingBuf -pub type aya::maps::ring_buf::RingBuf::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData> -pub type aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData> -pub type aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::ring_buf::RingBuf<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl> std::os::fd::raw::AsRawFd for aya::maps::ring_buf::RingBuf pub fn aya::maps::ring_buf::RingBuf::as_raw_fd(&self) -> std::os::fd::raw::RawFd @@ -2242,25 +2369,25 @@ pub fn aya::maps::ring_buf::RingBuf::from(t: T) -> T pub struct aya::maps::SockHash impl, K: aya::Pod> aya::maps::SockHash pub fn aya::maps::SockHash::fd(&self) -> &aya::maps::sock::SockMapFd -pub fn aya::maps::SockHash::get(&self, key: &K, flags: u64) -> core::result::Result +pub fn aya::maps::SockHash::get(&self, key: &K, flags: u64) -> core::result::Result pub fn aya::maps::SockHash::iter(&self) -> aya::maps::MapIter<'_, K, std::os::fd::raw::RawFd, Self> pub fn aya::maps::SockHash::keys(&self) -> aya::maps::MapKeys<'_, K> impl, V: aya::Pod> aya::maps::SockHash -pub fn aya::maps::SockHash::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::SockHash::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, K: aya::Pod> aya::maps::SockHash -pub fn aya::maps::SockHash::insert(&mut self, key: impl core::borrow::Borrow, value: I, flags: u64) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::SockHash::remove(&mut self, key: &K) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::SockHash::insert(&mut self, key: impl core::borrow::Borrow, value: I, flags: u64) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::SockHash::remove(&mut self, key: &K) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::SockHash<&'a aya::maps::MapData, V> -pub type aya::maps::SockHash<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::SockHash<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::SockHash<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::SockHash<&'a mut aya::maps::MapData, V> -pub type aya::maps::SockHash<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::SockHash<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::SockHash<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl, K: aya::Pod> aya::maps::IterableMap for aya::maps::SockHash -pub fn aya::maps::SockHash::get(&self, key: &K) -> core::result::Result +pub fn aya::maps::SockHash::get(&self, key: &K) -> core::result::Result pub fn aya::maps::SockHash::map(&self) -> &aya::maps::MapData impl core::convert::TryFrom for aya::maps::SockHash -pub type aya::maps::SockHash::Error = aya::maps::MapError +pub type aya::maps::SockHash::Error = aya::errors::MapError pub fn aya::maps::SockHash::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::SockHash where T: core::marker::Freeze impl core::marker::Send for aya::maps::SockHash where T: core::marker::Send, K: core::marker::Send @@ -2289,18 +2416,18 @@ impl> aya::maps::SockMap pub fn aya::maps::SockMap::fd(&self) -> &aya::maps::sock::SockMapFd pub fn aya::maps::SockMap::indices(&self) -> aya::maps::MapKeys<'_, u32> impl> aya::maps::SockMap -pub fn aya::maps::SockMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::SockMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::SockMap -pub fn aya::maps::SockMap::clear_index(&mut self, index: &u32) -> core::result::Result<(), aya::maps::MapError> -pub fn aya::maps::SockMap::set(&mut self, index: u32, socket: &I, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::SockMap::clear_index(&mut self, index: &u32) -> core::result::Result<(), aya::errors::MapError> +pub fn aya::maps::SockMap::set(&mut self, index: u32, socket: &I, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::SockMap -pub type aya::maps::SockMap::Error = aya::maps::MapError +pub type aya::maps::SockMap::Error = aya::errors::MapError pub fn aya::maps::SockMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::SockMap<&'a aya::maps::MapData> -pub type aya::maps::SockMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::SockMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::SockMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::SockMap<&'a mut aya::maps::MapData> -pub type aya::maps::SockMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::SockMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::SockMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::SockMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::SockMap where T: core::marker::Send @@ -2328,18 +2455,18 @@ pub struct aya::maps::Stack impl, V: aya::Pod> aya::maps::stack::Stack pub fn aya::maps::stack::Stack::capacity(&self) -> u32 impl, V: aya::Pod> aya::maps::stack::Stack -pub fn aya::maps::stack::Stack::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::stack::Stack::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl, V: aya::Pod> aya::maps::stack::Stack -pub fn aya::maps::stack::Stack::pop(&mut self, flags: u64) -> core::result::Result -pub fn aya::maps::stack::Stack::push(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::stack::Stack::pop(&mut self, flags: u64) -> core::result::Result +pub fn aya::maps::stack::Stack::push(&mut self, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::stack::Stack<&'a aya::maps::MapData, V> -pub type aya::maps::stack::Stack<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::stack::Stack<&'a aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::stack::Stack<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a, V: aya::Pod> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::stack::Stack<&'a mut aya::maps::MapData, V> -pub type aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub type aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::Error = aya::errors::MapError pub fn aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::convert::TryFrom for aya::maps::stack::Stack -pub type aya::maps::stack::Stack::Error = aya::maps::MapError +pub type aya::maps::stack::Stack::Error = aya::errors::MapError pub fn aya::maps::stack::Stack::try_from(map: aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::stack::Stack where T: core::marker::Freeze impl core::marker::Send for aya::maps::stack::Stack where T: core::marker::Send, V: core::marker::Send @@ -2365,28 +2492,28 @@ impl core::convert::From for aya::maps::stack::Stack pub fn aya::maps::stack::Stack::from(t: T) -> T pub struct aya::maps::StackTraceMap impl> aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::get(&self, stack_id: &u32, flags: u64) -> core::result::Result +pub fn aya::maps::stack_trace::StackTraceMap::get(&self, stack_id: &u32, flags: u64) -> core::result::Result pub fn aya::maps::stack_trace::StackTraceMap::iter(&self) -> aya::maps::MapIter<'_, u32, aya::maps::stack_trace::StackTrace, Self> pub fn aya::maps::stack_trace::StackTraceMap::stack_ids(&self) -> aya::maps::MapKeys<'_, u32> impl> aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::stack_trace::StackTraceMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::remove(&mut self, stack_id: &u32) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::stack_trace::StackTraceMap::remove(&mut self, stack_id: &u32) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::stack_trace::StackTraceMap -pub type aya::maps::stack_trace::StackTraceMap::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a, T: core::borrow::Borrow> core::iter::traits::collect::IntoIterator for &'a aya::maps::stack_trace::StackTraceMap pub type &'a aya::maps::stack_trace::StackTraceMap::IntoIter = aya::maps::MapIter<'a, u32, aya::maps::stack_trace::StackTrace, aya::maps::stack_trace::StackTraceMap> -pub type &'a aya::maps::stack_trace::StackTraceMap::Item = core::result::Result<(u32, aya::maps::stack_trace::StackTrace), aya::maps::MapError> +pub type &'a aya::maps::stack_trace::StackTraceMap::Item = core::result::Result<(u32, aya::maps::stack_trace::StackTrace), aya::errors::MapError> pub fn &'a aya::maps::stack_trace::StackTraceMap::into_iter(self) -> Self::IntoIter impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData> -pub type aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData> -pub type aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::stack_trace::StackTraceMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl> aya::maps::IterableMap for aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::get(&self, index: &u32) -> core::result::Result +pub fn aya::maps::stack_trace::StackTraceMap::get(&self, index: &u32) -> core::result::Result pub fn aya::maps::stack_trace::StackTraceMap::map(&self) -> &aya::maps::MapData impl core::fmt::Debug for aya::maps::stack_trace::StackTraceMap pub fn aya::maps::stack_trace::StackTraceMap::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -2416,17 +2543,17 @@ pub struct aya::maps::XskMap impl> aya::maps::XskMap pub fn aya::maps::XskMap::len(&self) -> u32 impl> aya::maps::XskMap -pub fn aya::maps::XskMap::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::maps::XskMap::pin>(self, path: P) -> core::result::Result<(), aya::errors::MapError> impl> aya::maps::XskMap -pub fn aya::maps::XskMap::set(&mut self, index: u32, socket_fd: impl std::os::fd::raw::AsRawFd, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::XskMap::set(&mut self, index: u32, socket_fd: impl std::os::fd::raw::AsRawFd, flags: u64) -> core::result::Result<(), aya::errors::MapError> impl core::convert::TryFrom for aya::maps::XskMap -pub type aya::maps::XskMap::Error = aya::maps::MapError +pub type aya::maps::XskMap::Error = aya::errors::MapError pub fn aya::maps::XskMap::try_from(map: aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::XskMap<&'a aya::maps::MapData> -pub type aya::maps::XskMap<&'a aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::XskMap<&'a aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::XskMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result impl<'a> core::convert::TryFrom<&'a mut aya::maps::Map> for aya::maps::XskMap<&'a mut aya::maps::MapData> -pub type aya::maps::XskMap<&'a mut aya::maps::MapData>::Error = aya::maps::MapError +pub type aya::maps::XskMap<&'a mut aya::maps::MapData>::Error = aya::errors::MapError pub fn aya::maps::XskMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result impl core::marker::Freeze for aya::maps::XskMap where T: core::marker::Freeze impl core::marker::Send for aya::maps::XskMap where T: core::marker::Send @@ -2451,70 +2578,30 @@ pub fn aya::maps::XskMap::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::maps::XskMap pub fn aya::maps::XskMap::from(t: T) -> T pub trait aya::maps::IterableMap -pub fn aya::maps::IterableMap::get(&self, key: &K) -> core::result::Result +pub fn aya::maps::IterableMap::get(&self, key: &K) -> core::result::Result pub fn aya::maps::IterableMap::map(&self) -> &aya::maps::MapData impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap for aya::maps::hash_map::HashMap -pub fn aya::maps::hash_map::HashMap::get(&self, key: &K) -> core::result::Result +pub fn aya::maps::hash_map::HashMap::get(&self, key: &K) -> core::result::Result pub fn aya::maps::hash_map::HashMap::map(&self) -> &aya::maps::MapData impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap> for aya::maps::hash_map::PerCpuHashMap -pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::hash_map::PerCpuHashMap::get(&self, key: &K) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::hash_map::PerCpuHashMap::map(&self) -> &aya::maps::MapData impl, K: aya::Pod, V: aya::Pod> aya::maps::IterableMap, V> for aya::maps::lpm_trie::LpmTrie -pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key) -> core::result::Result +pub fn aya::maps::lpm_trie::LpmTrie::get(&self, key: &aya::maps::lpm_trie::Key) -> core::result::Result pub fn aya::maps::lpm_trie::LpmTrie::map(&self) -> &aya::maps::MapData impl, K: aya::Pod> aya::maps::IterableMap for aya::maps::SockHash -pub fn aya::maps::SockHash::get(&self, key: &K) -> core::result::Result +pub fn aya::maps::SockHash::get(&self, key: &K) -> core::result::Result pub fn aya::maps::SockHash::map(&self) -> &aya::maps::MapData impl, V: aya::Pod> aya::maps::IterableMap for aya::maps::array::Array -pub fn aya::maps::array::Array::get(&self, index: &u32) -> core::result::Result +pub fn aya::maps::array::Array::get(&self, index: &u32) -> core::result::Result pub fn aya::maps::array::Array::map(&self) -> &aya::maps::MapData impl, V: aya::Pod> aya::maps::IterableMap> for aya::maps::PerCpuArray -pub fn aya::maps::PerCpuArray::get(&self, index: &u32) -> core::result::Result, aya::maps::MapError> +pub fn aya::maps::PerCpuArray::get(&self, index: &u32) -> core::result::Result, aya::errors::MapError> pub fn aya::maps::PerCpuArray::map(&self) -> &aya::maps::MapData impl> aya::maps::IterableMap for aya::maps::stack_trace::StackTraceMap -pub fn aya::maps::stack_trace::StackTraceMap::get(&self, index: &u32) -> core::result::Result +pub fn aya::maps::stack_trace::StackTraceMap::get(&self, index: &u32) -> core::result::Result pub fn aya::maps::stack_trace::StackTraceMap::map(&self) -> &aya::maps::MapData -pub fn aya::maps::loaded_maps() -> impl core::iter::traits::iterator::Iterator> -pub mod aya::pin -pub enum aya::pin::PinError -pub aya::pin::PinError::InvalidPinPath -pub aya::pin::PinError::InvalidPinPath::error: alloc::ffi::c_str::NulError -pub aya::pin::PinError::InvalidPinPath::path: std::path::PathBuf -pub aya::pin::PinError::NoFd -pub aya::pin::PinError::NoFd::name: alloc::string::String -pub aya::pin::PinError::SyscallError(aya::sys::SyscallError) -impl core::convert::From for aya::pin::PinError -pub fn aya::pin::PinError::from(source: aya::sys::SyscallError) -> Self -impl core::error::Error for aya::pin::PinError -pub fn aya::pin::PinError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::pin::PinError -pub fn aya::pin::PinError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::pin::PinError -pub fn aya::pin::PinError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::pin::PinError -impl core::marker::Send for aya::pin::PinError -impl core::marker::Sync for aya::pin::PinError -impl core::marker::Unpin for aya::pin::PinError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::pin::PinError -impl !core::panic::unwind_safe::UnwindSafe for aya::pin::PinError -impl core::convert::Into for aya::pin::PinError where U: core::convert::From -pub fn aya::pin::PinError::into(self) -> U -impl core::convert::TryFrom for aya::pin::PinError where U: core::convert::Into -pub type aya::pin::PinError::Error = core::convert::Infallible -pub fn aya::pin::PinError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::pin::PinError where U: core::convert::TryFrom -pub type aya::pin::PinError::Error = >::Error -pub fn aya::pin::PinError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::pin::PinError where T: core::fmt::Display + core::marker::Sized -pub fn aya::pin::PinError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::pin::PinError where T: 'static + core::marker::Sized -pub fn aya::pin::PinError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::pin::PinError where T: core::marker::Sized -pub fn aya::pin::PinError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::pin::PinError where T: core::marker::Sized -pub fn aya::pin::PinError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::pin::PinError -pub fn aya::pin::PinError::from(t: T) -> T +pub fn aya::maps::loaded_maps() -> impl core::iter::traits::iterator::Iterator> pub mod aya::programs pub use aya::programs::CgroupSockAddrAttachType pub use aya::programs::CgroupSockAttachType @@ -2522,32 +2609,32 @@ pub use aya::programs::CgroupSockoptAttachType pub mod aya::programs::cgroup_device pub struct aya::programs::cgroup_device::CgroupDevice impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_device::CgroupDevice::detach(&mut self, link_id: aya::programs::cgroup_device::CgroupDeviceLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_device::CgroupDevice::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_device::CgroupDevice::query(target_fd: T) -> core::result::Result, aya::programs::ProgramError> -pub fn aya::programs::cgroup_device::CgroupDevice::take_link(&mut self, link_id: aya::programs::cgroup_device::CgroupDeviceLinkId) -> core::result::Result +pub fn aya::programs::cgroup_device::CgroupDevice::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_device::CgroupDevice::detach(&mut self, link_id: aya::programs::cgroup_device::CgroupDeviceLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_device::CgroupDevice::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDevice::query(target_fd: T) -> core::result::Result, aya::errors::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDevice::take_link(&mut self, link_id: aya::programs::cgroup_device::CgroupDeviceLinkId) -> core::result::Result impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDevice::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::cgroup_device::CgroupDevice::from_pin>(path: P) -> core::result::Result impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_device::CgroupDevice::info(&self) -> core::result::Result impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_device::CgroupDevice::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_device::CgroupDevice::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDevice::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_device::CgroupDevice pub fn aya::programs::cgroup_device::CgroupDevice::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_device::CgroupDevice pub fn aya::programs::cgroup_device::CgroupDevice::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_device::CgroupDevice -pub type &'a aya::programs::cgroup_device::CgroupDevice::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_device::CgroupDevice, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_device::CgroupDevice::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_device::CgroupDevice, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_device::CgroupDevice -pub type &'a mut aya::programs::cgroup_device::CgroupDevice::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_device::CgroupDevice, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_device::CgroupDevice::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_device::CgroupDevice, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_device::CgroupDevice impl core::marker::Send for aya::programs::cgroup_device::CgroupDevice impl core::marker::Sync for aya::programs::cgroup_device::CgroupDevice @@ -2573,7 +2660,7 @@ pub fn aya::programs::cgroup_device::CgroupDevice::from(t: T) -> T pub struct aya::programs::cgroup_device::CgroupDeviceLink(_) impl aya::programs::links::Link for aya::programs::cgroup_device::CgroupDeviceLink pub type aya::programs::cgroup_device::CgroupDeviceLink::Id = aya::programs::cgroup_device::CgroupDeviceLinkId -pub fn aya::programs::cgroup_device::CgroupDeviceLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDeviceLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_device::CgroupDeviceLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::cgroup_device::CgroupDeviceLink pub fn aya::programs::cgroup_device::CgroupDeviceLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -2673,31 +2760,31 @@ impl core::convert::From for aya::programs::cgroup_skb::CgroupSkbAttachTyp pub fn aya::programs::cgroup_skb::CgroupSkbAttachType::from(t: T) -> T pub struct aya::programs::cgroup_skb::CgroupSkb impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::attach(&mut self, cgroup: T, attach_type: aya::programs::cgroup_skb::CgroupSkbAttachType, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_skb::CgroupSkb::detach(&mut self, link_id: aya::programs::cgroup_skb::CgroupSkbLinkId) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkb::attach(&mut self, cgroup: T, attach_type: aya::programs::cgroup_skb::CgroupSkbAttachType, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_skb::CgroupSkb::detach(&mut self, link_id: aya::programs::cgroup_skb::CgroupSkbLinkId) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_skb::CgroupSkb::expected_attach_type(&self) -> &core::option::Option -pub fn aya::programs::cgroup_skb::CgroupSkb::from_pin>(path: P, expected_attach_type: aya::programs::cgroup_skb::CgroupSkbAttachType) -> core::result::Result -pub fn aya::programs::cgroup_skb::CgroupSkb::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_skb::CgroupSkb::take_link(&mut self, link_id: aya::programs::cgroup_skb::CgroupSkbLinkId) -> core::result::Result +pub fn aya::programs::cgroup_skb::CgroupSkb::from_pin>(path: P, expected_attach_type: aya::programs::cgroup_skb::CgroupSkbAttachType) -> core::result::Result +pub fn aya::programs::cgroup_skb::CgroupSkb::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkb::take_link(&mut self, link_id: aya::programs::cgroup_skb::CgroupSkbLinkId) -> core::result::Result impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkb::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_skb::CgroupSkb::info(&self) -> core::result::Result impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_skb::CgroupSkb::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_skb::CgroupSkb::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkb::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_skb::CgroupSkb pub fn aya::programs::cgroup_skb::CgroupSkb::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_skb::CgroupSkb pub fn aya::programs::cgroup_skb::CgroupSkb::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_skb::CgroupSkb -pub type &'a aya::programs::cgroup_skb::CgroupSkb::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_skb::CgroupSkb, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_skb::CgroupSkb::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_skb::CgroupSkb, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_skb::CgroupSkb -pub type &'a mut aya::programs::cgroup_skb::CgroupSkb::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_skb::CgroupSkb, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_skb::CgroupSkb::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_skb::CgroupSkb, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_skb::CgroupSkb impl core::marker::Send for aya::programs::cgroup_skb::CgroupSkb impl core::marker::Sync for aya::programs::cgroup_skb::CgroupSkb @@ -2723,7 +2810,7 @@ pub fn aya::programs::cgroup_skb::CgroupSkb::from(t: T) -> T pub struct aya::programs::cgroup_skb::CgroupSkbLink(_) impl aya::programs::links::Link for aya::programs::cgroup_skb::CgroupSkbLink pub type aya::programs::cgroup_skb::CgroupSkbLink::Id = aya::programs::cgroup_skb::CgroupSkbLinkId -pub fn aya::programs::cgroup_skb::CgroupSkbLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkbLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_skb::CgroupSkbLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::cgroup_skb::CgroupSkbLink pub fn aya::programs::cgroup_skb::CgroupSkbLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -2788,30 +2875,30 @@ pub mod aya::programs::cgroup_sock pub use aya::programs::cgroup_sock::CgroupSockAttachType pub struct aya::programs::cgroup_sock::CgroupSock impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_sock::CgroupSock::detach(&mut self, link_id: aya::programs::cgroup_sock::CgroupSockLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sock::CgroupSock::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sock::CgroupSockAttachType) -> core::result::Result -pub fn aya::programs::cgroup_sock::CgroupSock::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sock::CgroupSock::take_link(&mut self, link_id: aya::programs::cgroup_sock::CgroupSockLinkId) -> core::result::Result +pub fn aya::programs::cgroup_sock::CgroupSock::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_sock::CgroupSock::detach(&mut self, link_id: aya::programs::cgroup_sock::CgroupSockLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_sock::CgroupSock::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sock::CgroupSockAttachType) -> core::result::Result +pub fn aya::programs::cgroup_sock::CgroupSock::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSock::take_link(&mut self, link_id: aya::programs::cgroup_sock::CgroupSockLinkId) -> core::result::Result impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSock::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_sock::CgroupSock::info(&self) -> core::result::Result impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_sock::CgroupSock::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_sock::CgroupSock::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSock::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_sock::CgroupSock pub fn aya::programs::cgroup_sock::CgroupSock::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_sock::CgroupSock pub fn aya::programs::cgroup_sock::CgroupSock::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sock::CgroupSock -pub type &'a aya::programs::cgroup_sock::CgroupSock::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock::CgroupSock, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sock::CgroupSock::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock::CgroupSock, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sock::CgroupSock -pub type &'a mut aya::programs::cgroup_sock::CgroupSock::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock::CgroupSock, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sock::CgroupSock::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock::CgroupSock, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_sock::CgroupSock impl core::marker::Send for aya::programs::cgroup_sock::CgroupSock impl core::marker::Sync for aya::programs::cgroup_sock::CgroupSock @@ -2837,7 +2924,7 @@ pub fn aya::programs::cgroup_sock::CgroupSock::from(t: T) -> T pub struct aya::programs::cgroup_sock::CgroupSockLink(_) impl aya::programs::links::Link for aya::programs::cgroup_sock::CgroupSockLink pub type aya::programs::cgroup_sock::CgroupSockLink::Id = aya::programs::cgroup_sock::CgroupSockLinkId -pub fn aya::programs::cgroup_sock::CgroupSockLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSockLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sock::CgroupSockLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::cgroup_sock::CgroupSockLink pub fn aya::programs::cgroup_sock::CgroupSockLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -2902,30 +2989,30 @@ pub mod aya::programs::cgroup_sock_addr pub use aya::programs::cgroup_sock_addr::CgroupSockAddrAttachType pub struct aya::programs::cgroup_sock_addr::CgroupSockAddr impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::detach(&mut self, link_id: aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sock_addr::CgroupSockAddrAttachType) -> core::result::Result -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::take_link(&mut self, link_id: aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId) -> core::result::Result +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::detach(&mut self, link_id: aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sock_addr::CgroupSockAddrAttachType) -> core::result::Result +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::take_link(&mut self, link_id: aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId) -> core::result::Result impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::info(&self) -> core::result::Result impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_sock_addr::CgroupSockAddr pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_sock_addr::CgroupSockAddr pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sock_addr::CgroupSockAddr -pub type &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr -pub type &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_sock_addr::CgroupSockAddr impl core::marker::Send for aya::programs::cgroup_sock_addr::CgroupSockAddr impl core::marker::Sync for aya::programs::cgroup_sock_addr::CgroupSockAddr @@ -2951,7 +3038,7 @@ pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::from(t: T) -> T pub struct aya::programs::cgroup_sock_addr::CgroupSockAddrLink(_) impl aya::programs::links::Link for aya::programs::cgroup_sock_addr::CgroupSockAddrLink pub type aya::programs::cgroup_sock_addr::CgroupSockAddrLink::Id = aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::cgroup_sock_addr::CgroupSockAddrLink pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -3016,30 +3103,30 @@ pub mod aya::programs::cgroup_sockopt pub use aya::programs::cgroup_sockopt::CgroupSockoptAttachType pub struct aya::programs::cgroup_sockopt::CgroupSockopt impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::detach(&mut self, link_id: aya::programs::cgroup_sockopt::CgroupSockoptLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sockopt::CgroupSockoptAttachType) -> core::result::Result -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::take_link(&mut self, link_id: aya::programs::cgroup_sockopt::CgroupSockoptLinkId) -> core::result::Result +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::detach(&mut self, link_id: aya::programs::cgroup_sockopt::CgroupSockoptLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sockopt::CgroupSockoptAttachType) -> core::result::Result +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::take_link(&mut self, link_id: aya::programs::cgroup_sockopt::CgroupSockoptLinkId) -> core::result::Result impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::info(&self) -> core::result::Result impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_sockopt::CgroupSockopt::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_sockopt::CgroupSockopt pub fn aya::programs::cgroup_sockopt::CgroupSockopt::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_sockopt::CgroupSockopt pub fn aya::programs::cgroup_sockopt::CgroupSockopt::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sockopt::CgroupSockopt -pub type &'a aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sockopt::CgroupSockopt, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sockopt::CgroupSockopt, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sockopt::CgroupSockopt -pub type &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sockopt::CgroupSockopt, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sockopt::CgroupSockopt, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_sockopt::CgroupSockopt impl core::marker::Send for aya::programs::cgroup_sockopt::CgroupSockopt impl core::marker::Sync for aya::programs::cgroup_sockopt::CgroupSockopt @@ -3065,7 +3152,7 @@ pub fn aya::programs::cgroup_sockopt::CgroupSockopt::from(t: T) -> T pub struct aya::programs::cgroup_sockopt::CgroupSockoptLink(_) impl aya::programs::links::Link for aya::programs::cgroup_sockopt::CgroupSockoptLink pub type aya::programs::cgroup_sockopt::CgroupSockoptLink::Id = aya::programs::cgroup_sockopt::CgroupSockoptLinkId -pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::cgroup_sockopt::CgroupSockoptLink pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -3129,31 +3216,31 @@ pub fn aya::programs::cgroup_sockopt::CgroupSockoptLinkId::from(t: T) -> T pub mod aya::programs::cgroup_sysctl pub struct aya::programs::cgroup_sysctl::CgroupSysctl impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::detach(&mut self, link_id: aya::programs::cgroup_sysctl::CgroupSysctlLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::take_link(&mut self, link_id: aya::programs::cgroup_sysctl::CgroupSysctlLinkId) -> core::result::Result +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::detach(&mut self, link_id: aya::programs::cgroup_sysctl::CgroupSysctlLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::take_link(&mut self, link_id: aya::programs::cgroup_sysctl::CgroupSysctlLinkId) -> core::result::Result impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::from_pin>(path: P) -> core::result::Result impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::info(&self) -> core::result::Result impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_sysctl::CgroupSysctl::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_sysctl::CgroupSysctl pub fn aya::programs::cgroup_sysctl::CgroupSysctl::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_sysctl::CgroupSysctl pub fn aya::programs::cgroup_sysctl::CgroupSysctl::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sysctl::CgroupSysctl -pub type &'a aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sysctl::CgroupSysctl, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sysctl::CgroupSysctl, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sysctl::CgroupSysctl -pub type &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sysctl::CgroupSysctl, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sysctl::CgroupSysctl, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_sysctl::CgroupSysctl impl core::marker::Send for aya::programs::cgroup_sysctl::CgroupSysctl impl core::marker::Sync for aya::programs::cgroup_sysctl::CgroupSysctl @@ -3179,7 +3266,7 @@ pub fn aya::programs::cgroup_sysctl::CgroupSysctl::from(t: T) -> T pub struct aya::programs::cgroup_sysctl::CgroupSysctlLink(_) impl aya::programs::links::Link for aya::programs::cgroup_sysctl::CgroupSysctlLink pub type aya::programs::cgroup_sysctl::CgroupSysctlLink::Id = aya::programs::cgroup_sysctl::CgroupSysctlLinkId -pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::cgroup_sysctl::CgroupSysctlLink pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -3241,67 +3328,34 @@ pub fn aya::programs::cgroup_sysctl::CgroupSysctlLinkId::borrow_mut(&mut self) - impl core::convert::From for aya::programs::cgroup_sysctl::CgroupSysctlLinkId pub fn aya::programs::cgroup_sysctl::CgroupSysctlLinkId::from(t: T) -> T pub mod aya::programs::extension -pub enum aya::programs::extension::ExtensionError -pub aya::programs::extension::ExtensionError::NoBTF -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::extension::ExtensionError) -> Self -impl core::error::Error for aya::programs::extension::ExtensionError -impl core::fmt::Debug for aya::programs::extension::ExtensionError -pub fn aya::programs::extension::ExtensionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::extension::ExtensionError -pub fn aya::programs::extension::ExtensionError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::extension::ExtensionError -impl core::marker::Send for aya::programs::extension::ExtensionError -impl core::marker::Sync for aya::programs::extension::ExtensionError -impl core::marker::Unpin for aya::programs::extension::ExtensionError -impl core::panic::unwind_safe::RefUnwindSafe for aya::programs::extension::ExtensionError -impl core::panic::unwind_safe::UnwindSafe for aya::programs::extension::ExtensionError -impl core::convert::Into for aya::programs::extension::ExtensionError where U: core::convert::From -pub fn aya::programs::extension::ExtensionError::into(self) -> U -impl core::convert::TryFrom for aya::programs::extension::ExtensionError where U: core::convert::Into -pub type aya::programs::extension::ExtensionError::Error = core::convert::Infallible -pub fn aya::programs::extension::ExtensionError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::extension::ExtensionError where U: core::convert::TryFrom -pub type aya::programs::extension::ExtensionError::Error = >::Error -pub fn aya::programs::extension::ExtensionError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::extension::ExtensionError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::extension::ExtensionError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::extension::ExtensionError where T: 'static + core::marker::Sized -pub fn aya::programs::extension::ExtensionError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::extension::ExtensionError where T: core::marker::Sized -pub fn aya::programs::extension::ExtensionError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::extension::ExtensionError where T: core::marker::Sized -pub fn aya::programs::extension::ExtensionError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::extension::ExtensionError -pub fn aya::programs::extension::ExtensionError::from(t: T) -> T pub struct aya::programs::extension::Extension impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::attach(&mut self) -> core::result::Result -pub fn aya::programs::extension::Extension::attach_to_program(&mut self, program: &aya::programs::ProgramFd, func_name: &str) -> core::result::Result -pub fn aya::programs::extension::Extension::detach(&mut self, link_id: aya::programs::extension::ExtensionLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::extension::Extension::load(&mut self, program: aya::programs::ProgramFd, func_name: &str) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::extension::Extension::take_link(&mut self, link_id: aya::programs::extension::ExtensionLinkId) -> core::result::Result +pub fn aya::programs::extension::Extension::attach(&mut self) -> core::result::Result +pub fn aya::programs::extension::Extension::attach_to_program(&mut self, program: &aya::programs::ProgramFd, func_name: &str) -> core::result::Result +pub fn aya::programs::extension::Extension::detach(&mut self, link_id: aya::programs::extension::ExtensionLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::extension::Extension::load(&mut self, program: aya::programs::ProgramFd, func_name: &str) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::extension::Extension::take_link(&mut self, link_id: aya::programs::extension::ExtensionLinkId) -> core::result::Result impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::extension::Extension::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::extension::Extension::from_pin>(path: P) -> core::result::Result impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::info(&self) -> core::result::Result +pub fn aya::programs::extension::Extension::info(&self) -> core::result::Result impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::extension::Extension::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::extension::Extension::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::extension::Extension::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::extension::Extension pub fn aya::programs::extension::Extension::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::extension::Extension pub fn aya::programs::extension::Extension::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::extension::Extension -pub type &'a aya::programs::extension::Extension::Error = aya::programs::ProgramError -pub fn &'a aya::programs::extension::Extension::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::extension::Extension, aya::programs::ProgramError> +pub type &'a aya::programs::extension::Extension::Error = aya::errors::ProgramError +pub fn &'a aya::programs::extension::Extension::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::extension::Extension, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::extension::Extension -pub type &'a mut aya::programs::extension::Extension::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::extension::Extension::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::extension::Extension, aya::programs::ProgramError> +pub type &'a mut aya::programs::extension::Extension::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::extension::Extension::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::extension::Extension, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::extension::Extension impl core::marker::Send for aya::programs::extension::Extension impl core::marker::Sync for aya::programs::extension::Extension @@ -3327,7 +3381,7 @@ pub fn aya::programs::extension::Extension::from(t: T) -> T pub struct aya::programs::extension::ExtensionLink(_) impl aya::programs::links::Link for aya::programs::extension::ExtensionLink pub type aya::programs::extension::ExtensionLink::Id = aya::programs::extension::ExtensionLinkId -pub fn aya::programs::extension::ExtensionLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::extension::ExtensionLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::extension::ExtensionLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::links::FdLink pub fn aya::programs::links::FdLink::from(w: aya::programs::extension::ExtensionLink) -> aya::programs::links::FdLink @@ -3395,31 +3449,31 @@ pub fn aya::programs::extension::ExtensionLinkId::from(t: T) -> T pub mod aya::programs::fentry pub struct aya::programs::fentry::FEntry impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::attach(&mut self) -> core::result::Result -pub fn aya::programs::fentry::FEntry::detach(&mut self, link_id: aya::programs::fentry::FEntryLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::fentry::FEntry::load(&mut self, fn_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::fentry::FEntry::take_link(&mut self, link_id: aya::programs::fentry::FEntryLinkId) -> core::result::Result +pub fn aya::programs::fentry::FEntry::attach(&mut self) -> core::result::Result +pub fn aya::programs::fentry::FEntry::detach(&mut self, link_id: aya::programs::fentry::FEntryLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::fentry::FEntry::load(&mut self, fn_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::fentry::FEntry::take_link(&mut self, link_id: aya::programs::fentry::FEntryLinkId) -> core::result::Result impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::fentry::FEntry::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::fentry::FEntry::from_pin>(path: P) -> core::result::Result impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::info(&self) -> core::result::Result +pub fn aya::programs::fentry::FEntry::info(&self) -> core::result::Result impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::fentry::FEntry::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::fentry::FEntry::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fentry::FEntry::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::fentry::FEntry pub fn aya::programs::fentry::FEntry::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::fentry::FEntry pub fn aya::programs::fentry::FEntry::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::fentry::FEntry -pub type &'a aya::programs::fentry::FEntry::Error = aya::programs::ProgramError -pub fn &'a aya::programs::fentry::FEntry::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fentry::FEntry, aya::programs::ProgramError> +pub type &'a aya::programs::fentry::FEntry::Error = aya::errors::ProgramError +pub fn &'a aya::programs::fentry::FEntry::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fentry::FEntry, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::fentry::FEntry -pub type &'a mut aya::programs::fentry::FEntry::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::fentry::FEntry::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fentry::FEntry, aya::programs::ProgramError> +pub type &'a mut aya::programs::fentry::FEntry::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::fentry::FEntry::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fentry::FEntry, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::fentry::FEntry impl core::marker::Send for aya::programs::fentry::FEntry impl core::marker::Sync for aya::programs::fentry::FEntry @@ -3445,7 +3499,7 @@ pub fn aya::programs::fentry::FEntry::from(t: T) -> T pub struct aya::programs::fentry::FEntryLink(_) impl aya::programs::links::Link for aya::programs::fentry::FEntryLink pub type aya::programs::fentry::FEntryLink::Id = aya::programs::fentry::FEntryLinkId -pub fn aya::programs::fentry::FEntryLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fentry::FEntryLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::fentry::FEntryLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::links::FdLink pub fn aya::programs::links::FdLink::from(w: aya::programs::fentry::FEntryLink) -> aya::programs::links::FdLink @@ -3513,31 +3567,31 @@ pub fn aya::programs::fentry::FEntryLinkId::from(t: T) -> T pub mod aya::programs::fexit pub struct aya::programs::fexit::FExit impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::attach(&mut self) -> core::result::Result -pub fn aya::programs::fexit::FExit::detach(&mut self, link_id: aya::programs::fexit::FExitLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::fexit::FExit::load(&mut self, fn_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::fexit::FExit::take_link(&mut self, link_id: aya::programs::fexit::FExitLinkId) -> core::result::Result +pub fn aya::programs::fexit::FExit::attach(&mut self) -> core::result::Result +pub fn aya::programs::fexit::FExit::detach(&mut self, link_id: aya::programs::fexit::FExitLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::fexit::FExit::load(&mut self, fn_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::fexit::FExit::take_link(&mut self, link_id: aya::programs::fexit::FExitLinkId) -> core::result::Result impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::fexit::FExit::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::fexit::FExit::from_pin>(path: P) -> core::result::Result impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::info(&self) -> core::result::Result +pub fn aya::programs::fexit::FExit::info(&self) -> core::result::Result impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::fexit::FExit::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::fexit::FExit::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fexit::FExit::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::fexit::FExit pub fn aya::programs::fexit::FExit::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::fexit::FExit pub fn aya::programs::fexit::FExit::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::fexit::FExit -pub type &'a aya::programs::fexit::FExit::Error = aya::programs::ProgramError -pub fn &'a aya::programs::fexit::FExit::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fexit::FExit, aya::programs::ProgramError> +pub type &'a aya::programs::fexit::FExit::Error = aya::errors::ProgramError +pub fn &'a aya::programs::fexit::FExit::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fexit::FExit, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::fexit::FExit -pub type &'a mut aya::programs::fexit::FExit::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::fexit::FExit::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fexit::FExit, aya::programs::ProgramError> +pub type &'a mut aya::programs::fexit::FExit::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::fexit::FExit::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fexit::FExit, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::fexit::FExit impl core::marker::Send for aya::programs::fexit::FExit impl core::marker::Sync for aya::programs::fexit::FExit @@ -3563,7 +3617,7 @@ pub fn aya::programs::fexit::FExit::from(t: T) -> T pub struct aya::programs::fexit::FExitLink(_) impl aya::programs::links::Link for aya::programs::fexit::FExitLink pub type aya::programs::fexit::FExitLink::Id = aya::programs::fexit::FExitLinkId -pub fn aya::programs::fexit::FExitLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fexit::FExitLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::fexit::FExitLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::links::FdLink pub fn aya::programs::links::FdLink::from(w: aya::programs::fexit::FExitLink) -> aya::programs::links::FdLink @@ -3629,69 +3683,33 @@ pub fn aya::programs::fexit::FExitLinkId::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::programs::fexit::FExitLinkId pub fn aya::programs::fexit::FExitLinkId::from(t: T) -> T pub mod aya::programs::kprobe -pub enum aya::programs::kprobe::KProbeError -pub aya::programs::kprobe::KProbeError::FileError -pub aya::programs::kprobe::KProbeError::FileError::filename: std::path::PathBuf -pub aya::programs::kprobe::KProbeError::FileError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::kprobe::KProbeError) -> Self -impl core::error::Error for aya::programs::kprobe::KProbeError -pub fn aya::programs::kprobe::KProbeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::kprobe::KProbeError -pub fn aya::programs::kprobe::KProbeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::kprobe::KProbeError -pub fn aya::programs::kprobe::KProbeError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::kprobe::KProbeError -impl core::marker::Send for aya::programs::kprobe::KProbeError -impl core::marker::Sync for aya::programs::kprobe::KProbeError -impl core::marker::Unpin for aya::programs::kprobe::KProbeError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::kprobe::KProbeError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::kprobe::KProbeError -impl core::convert::Into for aya::programs::kprobe::KProbeError where U: core::convert::From -pub fn aya::programs::kprobe::KProbeError::into(self) -> U -impl core::convert::TryFrom for aya::programs::kprobe::KProbeError where U: core::convert::Into -pub type aya::programs::kprobe::KProbeError::Error = core::convert::Infallible -pub fn aya::programs::kprobe::KProbeError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::kprobe::KProbeError where U: core::convert::TryFrom -pub type aya::programs::kprobe::KProbeError::Error = >::Error -pub fn aya::programs::kprobe::KProbeError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::kprobe::KProbeError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::kprobe::KProbeError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::kprobe::KProbeError where T: 'static + core::marker::Sized -pub fn aya::programs::kprobe::KProbeError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::kprobe::KProbeError where T: core::marker::Sized -pub fn aya::programs::kprobe::KProbeError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::kprobe::KProbeError where T: core::marker::Sized -pub fn aya::programs::kprobe::KProbeError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::kprobe::KProbeError -pub fn aya::programs::kprobe::KProbeError::from(t: T) -> T pub struct aya::programs::kprobe::KProbe impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::attach>(&mut self, fn_name: T, offset: u64) -> core::result::Result -pub fn aya::programs::kprobe::KProbe::detach(&mut self, link_id: aya::programs::kprobe::KProbeLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::kprobe::KProbe::from_pin>(path: P, kind: aya::programs::ProbeKind) -> core::result::Result +pub fn aya::programs::kprobe::KProbe::attach>(&mut self, fn_name: T, offset: u64) -> core::result::Result +pub fn aya::programs::kprobe::KProbe::detach(&mut self, link_id: aya::programs::kprobe::KProbeLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::kprobe::KProbe::from_pin>(path: P, kind: aya::programs::ProbeKind) -> core::result::Result pub fn aya::programs::kprobe::KProbe::kind(&self) -> aya::programs::ProbeKind -pub fn aya::programs::kprobe::KProbe::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::kprobe::KProbe::take_link(&mut self, link_id: aya::programs::kprobe::KProbeLinkId) -> core::result::Result +pub fn aya::programs::kprobe::KProbe::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::kprobe::KProbe::take_link(&mut self, link_id: aya::programs::kprobe::KProbeLinkId) -> core::result::Result impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::kprobe::KProbe::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::info(&self) -> core::result::Result +pub fn aya::programs::kprobe::KProbe::info(&self) -> core::result::Result impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::kprobe::KProbe::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::kprobe::KProbe::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::kprobe::KProbe::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::kprobe::KProbe pub fn aya::programs::kprobe::KProbe::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::kprobe::KProbe pub fn aya::programs::kprobe::KProbe::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::kprobe::KProbe -pub type &'a aya::programs::kprobe::KProbe::Error = aya::programs::ProgramError -pub fn &'a aya::programs::kprobe::KProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::kprobe::KProbe, aya::programs::ProgramError> +pub type &'a aya::programs::kprobe::KProbe::Error = aya::errors::ProgramError +pub fn &'a aya::programs::kprobe::KProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::kprobe::KProbe, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::kprobe::KProbe -pub type &'a mut aya::programs::kprobe::KProbe::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::kprobe::KProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::kprobe::KProbe, aya::programs::ProgramError> +pub type &'a mut aya::programs::kprobe::KProbe::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::kprobe::KProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::kprobe::KProbe, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::kprobe::KProbe impl core::marker::Send for aya::programs::kprobe::KProbe impl core::marker::Sync for aya::programs::kprobe::KProbe @@ -3717,13 +3735,13 @@ pub fn aya::programs::kprobe::KProbe::from(t: T) -> T pub struct aya::programs::kprobe::KProbeLink(_) impl aya::programs::links::Link for aya::programs::kprobe::KProbeLink pub type aya::programs::kprobe::KProbeLink::Id = aya::programs::kprobe::KProbeLinkId -pub fn aya::programs::kprobe::KProbeLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::kprobe::KProbeLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::kprobe::KProbeLink::id(&self) -> Self::Id impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::kprobe::KProbeLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::kprobe::KProbeLink -pub type aya::programs::kprobe::KProbeLink::Error = aya::programs::links::LinkError +pub type aya::programs::kprobe::KProbeLink::Error = aya::errors::LinkError pub fn aya::programs::kprobe::KProbeLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::fmt::Debug for aya::programs::kprobe::KProbeLink pub fn aya::programs::kprobe::KProbeLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -3826,47 +3844,12 @@ impl core::clone::CloneToUninit for aya::programs::links::CgroupAttachMode wh pub unsafe fn aya::programs::links::CgroupAttachMode::clone_to_uninit(&self, dst: *mut T) impl core::convert::From for aya::programs::links::CgroupAttachMode pub fn aya::programs::links::CgroupAttachMode::from(t: T) -> T -pub enum aya::programs::links::LinkError -pub aya::programs::links::LinkError::InvalidLink -pub aya::programs::links::LinkError::SyscallError(aya::sys::SyscallError) -impl core::convert::From for aya::programs::links::LinkError -pub fn aya::programs::links::LinkError::from(source: aya::sys::SyscallError) -> Self -impl core::error::Error for aya::programs::links::LinkError -pub fn aya::programs::links::LinkError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::links::LinkError -pub fn aya::programs::links::LinkError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::links::LinkError -pub fn aya::programs::links::LinkError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::links::LinkError -impl core::marker::Send for aya::programs::links::LinkError -impl core::marker::Sync for aya::programs::links::LinkError -impl core::marker::Unpin for aya::programs::links::LinkError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::links::LinkError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::links::LinkError -impl core::convert::Into for aya::programs::links::LinkError where U: core::convert::From -pub fn aya::programs::links::LinkError::into(self) -> U -impl core::convert::TryFrom for aya::programs::links::LinkError where U: core::convert::Into -pub type aya::programs::links::LinkError::Error = core::convert::Infallible -pub fn aya::programs::links::LinkError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::links::LinkError where U: core::convert::TryFrom -pub type aya::programs::links::LinkError::Error = >::Error -pub fn aya::programs::links::LinkError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::links::LinkError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::links::LinkError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::links::LinkError where T: 'static + core::marker::Sized -pub fn aya::programs::links::LinkError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::links::LinkError where T: core::marker::Sized -pub fn aya::programs::links::LinkError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::links::LinkError where T: core::marker::Sized -pub fn aya::programs::links::LinkError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::links::LinkError -pub fn aya::programs::links::LinkError::from(t: T) -> T pub struct aya::programs::links::FdLink impl aya::programs::links::FdLink -pub fn aya::programs::links::FdLink::pin>(self, path: P) -> core::result::Result +pub fn aya::programs::links::FdLink::pin>(self, path: P) -> core::result::Result impl aya::programs::links::Link for aya::programs::links::FdLink pub type aya::programs::links::FdLink::Id = aya::programs::links::FdLinkId -pub fn aya::programs::links::FdLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::links::FdLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::links::FdLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::links::FdLink pub fn aya::programs::links::FdLink::from(w: aya::programs::extension::ExtensionLink) -> aya::programs::links::FdLink @@ -3899,45 +3882,45 @@ pub fn aya::programs::links::FdLink::from(w: aya::programs::sk_lookup::SkLookupL impl core::convert::From for aya::programs::links::FdLink pub fn aya::programs::links::FdLink::from(w: aya::programs::tp_btf::BtfTracePointLink) -> aya::programs::links::FdLink impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::kprobe::KProbeLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::kprobe::KProbeLink -pub type aya::programs::kprobe::KProbeLink::Error = aya::programs::links::LinkError +pub type aya::programs::kprobe::KProbeLink::Error = aya::errors::LinkError pub fn aya::programs::kprobe::KProbeLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::perf_event::PerfEventLink -pub type aya::programs::perf_event::PerfEventLink::Error = aya::programs::links::LinkError +pub type aya::programs::perf_event::PerfEventLink::Error = aya::errors::LinkError pub fn aya::programs::perf_event::PerfEventLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::tc::SchedClassifierLink -pub type aya::programs::tc::SchedClassifierLink::Error = aya::programs::links::LinkError +pub type aya::programs::tc::SchedClassifierLink::Error = aya::errors::LinkError pub fn aya::programs::tc::SchedClassifierLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::trace_point::TracePointLink -pub type aya::programs::trace_point::TracePointLink::Error = aya::programs::links::LinkError +pub type aya::programs::trace_point::TracePointLink::Error = aya::errors::LinkError pub fn aya::programs::trace_point::TracePointLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::uprobe::UProbeLink -pub type aya::programs::uprobe::UProbeLink::Error = aya::programs::links::LinkError +pub type aya::programs::uprobe::UProbeLink::Error = aya::errors::LinkError pub fn aya::programs::uprobe::UProbeLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::xdp::XdpLink -pub type aya::programs::xdp::XdpLink::Error = aya::programs::links::LinkError +pub type aya::programs::xdp::XdpLink::Error = aya::errors::LinkError pub fn aya::programs::xdp::XdpLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::perf_event::PerfEventLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::tc::SchedClassifierLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::trace_point::TracePointLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::uprobe::UProbeLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::xdp::XdpLink) -> core::result::Result impl core::fmt::Debug for aya::programs::links::FdLink pub fn aya::programs::links::FdLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl<'a> core::convert::TryFrom<&'a aya::programs::tc::SchedClassifierLink> for &'a aya::programs::links::FdLink -pub type &'a aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type &'a aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn &'a aya::programs::links::FdLink::try_from(value: &'a aya::programs::tc::SchedClassifierLink) -> core::result::Result impl core::marker::Freeze for aya::programs::links::FdLink impl core::marker::Send for aya::programs::links::FdLink @@ -3996,11 +3979,11 @@ impl core::convert::From for aya::programs::links::FdLinkId pub fn aya::programs::links::FdLinkId::from(t: T) -> T pub struct aya::programs::links::LinkOrder impl aya::programs::links::LinkOrder -pub fn aya::programs::links::LinkOrder::after_link(link: &L) -> core::result::Result -pub fn aya::programs::links::LinkOrder::after_program(program: &P) -> core::result::Result +pub fn aya::programs::links::LinkOrder::after_link(link: &L) -> core::result::Result +pub fn aya::programs::links::LinkOrder::after_program(program: &P) -> core::result::Result pub fn aya::programs::links::LinkOrder::after_program_id(id: aya::programs::ProgramId) -> Self -pub fn aya::programs::links::LinkOrder::before_link(link: &L) -> core::result::Result -pub fn aya::programs::links::LinkOrder::before_program(program: &P) -> core::result::Result +pub fn aya::programs::links::LinkOrder::before_link(link: &L) -> core::result::Result +pub fn aya::programs::links::LinkOrder::before_program(program: &P) -> core::result::Result pub fn aya::programs::links::LinkOrder::before_program_id(id: aya::programs::ProgramId) -> Self pub fn aya::programs::links::LinkOrder::first() -> Self pub fn aya::programs::links::LinkOrder::last() -> Self @@ -4032,7 +4015,7 @@ impl core::convert::From for aya::programs::links::LinkOrder pub fn aya::programs::links::LinkOrder::from(t: T) -> T pub struct aya::programs::links::PinnedLink impl aya::programs::links::PinnedLink -pub fn aya::programs::links::PinnedLink::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::links::PinnedLink::from_pin>(path: P) -> core::result::Result pub fn aya::programs::links::PinnedLink::unpin(self) -> core::result::Result impl core::convert::From for aya::programs::links::FdLink pub fn aya::programs::links::FdLink::from(p: aya::programs::links::PinnedLink) -> Self @@ -4063,7 +4046,7 @@ pub fn aya::programs::links::PinnedLink::from(t: T) -> T pub struct aya::programs::links::ProgAttachLink impl aya::programs::links::Link for aya::programs::links::ProgAttachLink pub type aya::programs::links::ProgAttachLink::Id = aya::programs::links::ProgAttachLinkId -pub fn aya::programs::links::ProgAttachLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::links::ProgAttachLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::links::ProgAttachLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::sk_msg::SkMsgLink pub fn aya::programs::sk_msg::SkMsgLink::from(b: aya::programs::links::ProgAttachLink) -> aya::programs::sk_msg::SkMsgLink @@ -4132,123 +4115,123 @@ impl core::convert::From for aya::programs::links::ProgAttachLinkId pub fn aya::programs::links::ProgAttachLinkId::from(t: T) -> T pub trait aya::programs::links::Link: core::fmt::Debug + 'static pub type aya::programs::links::Link::Id: core::fmt::Debug + core::hash::Hash + core::cmp::Eq + core::cmp::PartialEq -pub fn aya::programs::links::Link::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::links::Link::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::links::Link::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_device::CgroupDeviceLink pub type aya::programs::cgroup_device::CgroupDeviceLink::Id = aya::programs::cgroup_device::CgroupDeviceLinkId -pub fn aya::programs::cgroup_device::CgroupDeviceLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDeviceLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_device::CgroupDeviceLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_skb::CgroupSkbLink pub type aya::programs::cgroup_skb::CgroupSkbLink::Id = aya::programs::cgroup_skb::CgroupSkbLinkId -pub fn aya::programs::cgroup_skb::CgroupSkbLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkbLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_skb::CgroupSkbLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_sock::CgroupSockLink pub type aya::programs::cgroup_sock::CgroupSockLink::Id = aya::programs::cgroup_sock::CgroupSockLinkId -pub fn aya::programs::cgroup_sock::CgroupSockLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSockLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sock::CgroupSockLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_sock_addr::CgroupSockAddrLink pub type aya::programs::cgroup_sock_addr::CgroupSockAddrLink::Id = aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_sockopt::CgroupSockoptLink pub type aya::programs::cgroup_sockopt::CgroupSockoptLink::Id = aya::programs::cgroup_sockopt::CgroupSockoptLinkId -pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_sysctl::CgroupSysctlLink pub type aya::programs::cgroup_sysctl::CgroupSysctlLink::Id = aya::programs::cgroup_sysctl::CgroupSysctlLinkId -pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::extension::ExtensionLink pub type aya::programs::extension::ExtensionLink::Id = aya::programs::extension::ExtensionLinkId -pub fn aya::programs::extension::ExtensionLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::extension::ExtensionLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::extension::ExtensionLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::fentry::FEntryLink pub type aya::programs::fentry::FEntryLink::Id = aya::programs::fentry::FEntryLinkId -pub fn aya::programs::fentry::FEntryLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fentry::FEntryLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::fentry::FEntryLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::fexit::FExitLink pub type aya::programs::fexit::FExitLink::Id = aya::programs::fexit::FExitLinkId -pub fn aya::programs::fexit::FExitLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fexit::FExitLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::fexit::FExitLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::kprobe::KProbeLink pub type aya::programs::kprobe::KProbeLink::Id = aya::programs::kprobe::KProbeLinkId -pub fn aya::programs::kprobe::KProbeLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::kprobe::KProbeLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::kprobe::KProbeLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::links::FdLink pub type aya::programs::links::FdLink::Id = aya::programs::links::FdLinkId -pub fn aya::programs::links::FdLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::links::FdLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::links::FdLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::links::ProgAttachLink pub type aya::programs::links::ProgAttachLink::Id = aya::programs::links::ProgAttachLinkId -pub fn aya::programs::links::ProgAttachLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::links::ProgAttachLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::links::ProgAttachLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::lirc_mode2::LircLink pub type aya::programs::lirc_mode2::LircLink::Id = aya::programs::lirc_mode2::LircLinkId -pub fn aya::programs::lirc_mode2::LircLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lirc_mode2::LircLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::lirc_mode2::LircLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::lsm::LsmLink pub type aya::programs::lsm::LsmLink::Id = aya::programs::lsm::LsmLinkId -pub fn aya::programs::lsm::LsmLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lsm::LsmLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::lsm::LsmLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::perf_attach::PerfLink pub type aya::programs::perf_attach::PerfLink::Id = aya::programs::perf_attach::PerfLinkId -pub fn aya::programs::perf_attach::PerfLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::perf_attach::PerfLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::perf_attach::PerfLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::perf_event::PerfEventLink pub type aya::programs::perf_event::PerfEventLink::Id = aya::programs::perf_event::PerfEventLinkId -pub fn aya::programs::perf_event::PerfEventLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::perf_event::PerfEventLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::perf_event::PerfEventLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::raw_trace_point::RawTracePointLink pub type aya::programs::raw_trace_point::RawTracePointLink::Id = aya::programs::raw_trace_point::RawTracePointLinkId -pub fn aya::programs::raw_trace_point::RawTracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::raw_trace_point::RawTracePointLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::sk_lookup::SkLookupLink pub type aya::programs::sk_lookup::SkLookupLink::Id = aya::programs::sk_lookup::SkLookupLinkId -pub fn aya::programs::sk_lookup::SkLookupLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_lookup::SkLookupLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_lookup::SkLookupLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::sk_msg::SkMsgLink pub type aya::programs::sk_msg::SkMsgLink::Id = aya::programs::sk_msg::SkMsgLinkId -pub fn aya::programs::sk_msg::SkMsgLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_msg::SkMsgLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_msg::SkMsgLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::sk_skb::SkSkbLink pub type aya::programs::sk_skb::SkSkbLink::Id = aya::programs::sk_skb::SkSkbLinkId -pub fn aya::programs::sk_skb::SkSkbLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_skb::SkSkbLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_skb::SkSkbLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::sock_ops::SockOpsLink pub type aya::programs::sock_ops::SockOpsLink::Id = aya::programs::sock_ops::SockOpsLinkId -pub fn aya::programs::sock_ops::SockOpsLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sock_ops::SockOpsLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sock_ops::SockOpsLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::socket_filter::SocketFilterLink pub type aya::programs::socket_filter::SocketFilterLink::Id = aya::programs::socket_filter::SocketFilterLinkId -pub fn aya::programs::socket_filter::SocketFilterLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::socket_filter::SocketFilterLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::socket_filter::SocketFilterLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::tc::SchedClassifierLink pub type aya::programs::tc::SchedClassifierLink::Id = aya::programs::tc::SchedClassifierLinkId -pub fn aya::programs::tc::SchedClassifierLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifierLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::tc::SchedClassifierLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::tp_btf::BtfTracePointLink pub type aya::programs::tp_btf::BtfTracePointLink::Id = aya::programs::tp_btf::BtfTracePointLinkId -pub fn aya::programs::tp_btf::BtfTracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::tp_btf::BtfTracePointLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::trace_point::TracePointLink pub type aya::programs::trace_point::TracePointLink::Id = aya::programs::trace_point::TracePointLinkId -pub fn aya::programs::trace_point::TracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::trace_point::TracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::trace_point::TracePointLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::uprobe::UProbeLink pub type aya::programs::uprobe::UProbeLink::Id = aya::programs::uprobe::UProbeLinkId -pub fn aya::programs::uprobe::UProbeLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::uprobe::UProbeLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::uprobe::UProbeLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::xdp::XdpLink pub type aya::programs::xdp::XdpLink::Id = aya::programs::xdp::XdpLinkId -pub fn aya::programs::xdp::XdpLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::xdp::XdpLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::xdp::XdpLink::id(&self) -> Self::Id pub mod aya::programs::lirc_mode2 pub struct aya::programs::lirc_mode2::LircLink impl aya::programs::lirc_mode2::LircLink -pub fn aya::programs::lirc_mode2::LircLink::info(&self) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircLink::info(&self) -> core::result::Result impl aya::programs::links::Link for aya::programs::lirc_mode2::LircLink pub type aya::programs::lirc_mode2::LircLink::Id = aya::programs::lirc_mode2::LircLinkId -pub fn aya::programs::lirc_mode2::LircLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lirc_mode2::LircLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::lirc_mode2::LircLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::lirc_mode2::LircLink pub fn aya::programs::lirc_mode2::LircLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -4309,32 +4292,32 @@ impl core::convert::From for aya::programs::lirc_mode2::LircLinkId pub fn aya::programs::lirc_mode2::LircLinkId::from(t: T) -> T pub struct aya::programs::lirc_mode2::LircMode2 impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::attach(&mut self, lircdev: T) -> core::result::Result -pub fn aya::programs::lirc_mode2::LircMode2::detach(&mut self, link_id: aya::programs::lirc_mode2::LircLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::lirc_mode2::LircMode2::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::lirc_mode2::LircMode2::query(target_fd: T) -> core::result::Result, aya::programs::ProgramError> -pub fn aya::programs::lirc_mode2::LircMode2::take_link(&mut self, link_id: aya::programs::lirc_mode2::LircLinkId) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircMode2::attach(&mut self, lircdev: T) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircMode2::detach(&mut self, link_id: aya::programs::lirc_mode2::LircLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::lirc_mode2::LircMode2::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::lirc_mode2::LircMode2::query(target_fd: T) -> core::result::Result, aya::errors::ProgramError> +pub fn aya::programs::lirc_mode2::LircMode2::take_link(&mut self, link_id: aya::programs::lirc_mode2::LircLinkId) -> core::result::Result impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::lirc_mode2::LircMode2::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircMode2::from_pin>(path: P) -> core::result::Result impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::info(&self) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircMode2::info(&self) -> core::result::Result impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::lirc_mode2::LircMode2::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::lirc_mode2::LircMode2::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lirc_mode2::LircMode2::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::lirc_mode2::LircMode2 pub fn aya::programs::lirc_mode2::LircMode2::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::lirc_mode2::LircMode2 pub fn aya::programs::lirc_mode2::LircMode2::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::lirc_mode2::LircMode2 -pub type &'a aya::programs::lirc_mode2::LircMode2::Error = aya::programs::ProgramError -pub fn &'a aya::programs::lirc_mode2::LircMode2::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lirc_mode2::LircMode2, aya::programs::ProgramError> +pub type &'a aya::programs::lirc_mode2::LircMode2::Error = aya::errors::ProgramError +pub fn &'a aya::programs::lirc_mode2::LircMode2::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lirc_mode2::LircMode2, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::lirc_mode2::LircMode2 -pub type &'a mut aya::programs::lirc_mode2::LircMode2::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::lirc_mode2::LircMode2::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lirc_mode2::LircMode2, aya::programs::ProgramError> +pub type &'a mut aya::programs::lirc_mode2::LircMode2::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::lirc_mode2::LircMode2::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lirc_mode2::LircMode2, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::lirc_mode2::LircMode2 impl core::marker::Send for aya::programs::lirc_mode2::LircMode2 impl core::marker::Sync for aya::programs::lirc_mode2::LircMode2 @@ -4360,31 +4343,31 @@ pub fn aya::programs::lirc_mode2::LircMode2::from(t: T) -> T pub mod aya::programs::lsm pub struct aya::programs::lsm::Lsm impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::attach(&mut self) -> core::result::Result -pub fn aya::programs::lsm::Lsm::detach(&mut self, link_id: aya::programs::lsm::LsmLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::lsm::Lsm::load(&mut self, lsm_hook_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::lsm::Lsm::take_link(&mut self, link_id: aya::programs::lsm::LsmLinkId) -> core::result::Result +pub fn aya::programs::lsm::Lsm::attach(&mut self) -> core::result::Result +pub fn aya::programs::lsm::Lsm::detach(&mut self, link_id: aya::programs::lsm::LsmLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::lsm::Lsm::load(&mut self, lsm_hook_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::lsm::Lsm::take_link(&mut self, link_id: aya::programs::lsm::LsmLinkId) -> core::result::Result impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::lsm::Lsm::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::lsm::Lsm::from_pin>(path: P) -> core::result::Result impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::info(&self) -> core::result::Result +pub fn aya::programs::lsm::Lsm::info(&self) -> core::result::Result impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::lsm::Lsm::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::lsm::Lsm::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lsm::Lsm::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::lsm::Lsm pub fn aya::programs::lsm::Lsm::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::lsm::Lsm pub fn aya::programs::lsm::Lsm::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::lsm::Lsm -pub type &'a aya::programs::lsm::Lsm::Error = aya::programs::ProgramError -pub fn &'a aya::programs::lsm::Lsm::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lsm::Lsm, aya::programs::ProgramError> +pub type &'a aya::programs::lsm::Lsm::Error = aya::errors::ProgramError +pub fn &'a aya::programs::lsm::Lsm::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lsm::Lsm, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::lsm::Lsm -pub type &'a mut aya::programs::lsm::Lsm::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::lsm::Lsm::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lsm::Lsm, aya::programs::ProgramError> +pub type &'a mut aya::programs::lsm::Lsm::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::lsm::Lsm::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lsm::Lsm, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::lsm::Lsm impl core::marker::Send for aya::programs::lsm::Lsm impl core::marker::Sync for aya::programs::lsm::Lsm @@ -4410,7 +4393,7 @@ pub fn aya::programs::lsm::Lsm::from(t: T) -> T pub struct aya::programs::lsm::LsmLink(_) impl aya::programs::links::Link for aya::programs::lsm::LsmLink pub type aya::programs::lsm::LsmLink::Id = aya::programs::lsm::LsmLinkId -pub fn aya::programs::lsm::LsmLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lsm::LsmLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::lsm::LsmLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::lsm::LsmLink pub fn aya::programs::lsm::LsmLink::from(b: aya::programs::links::FdLink) -> aya::programs::lsm::LsmLink @@ -4479,7 +4462,7 @@ pub mod aya::programs::perf_attach pub struct aya::programs::perf_attach::PerfLink impl aya::programs::links::Link for aya::programs::perf_attach::PerfLink pub type aya::programs::perf_attach::PerfLink::Id = aya::programs::perf_attach::PerfLinkId -pub fn aya::programs::perf_attach::PerfLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::perf_attach::PerfLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::perf_attach::PerfLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::perf_attach::PerfLink pub fn aya::programs::perf_attach::PerfLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -4663,31 +4646,31 @@ impl core::convert::From for aya::programs::perf_event::SamplePolicy pub fn aya::programs::perf_event::SamplePolicy::from(t: T) -> T pub struct aya::programs::perf_event::PerfEvent impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::attach(&mut self, perf_type: aya::programs::perf_event::PerfTypeId, config: u64, scope: aya::programs::perf_event::PerfEventScope, sample_policy: aya::programs::perf_event::SamplePolicy, inherit: bool) -> core::result::Result -pub fn aya::programs::perf_event::PerfEvent::detach(&mut self, link_id: aya::programs::perf_event::PerfEventLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::perf_event::PerfEvent::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::perf_event::PerfEvent::take_link(&mut self, link_id: aya::programs::perf_event::PerfEventLinkId) -> core::result::Result +pub fn aya::programs::perf_event::PerfEvent::attach(&mut self, perf_type: aya::programs::perf_event::PerfTypeId, config: u64, scope: aya::programs::perf_event::PerfEventScope, sample_policy: aya::programs::perf_event::SamplePolicy, inherit: bool) -> core::result::Result +pub fn aya::programs::perf_event::PerfEvent::detach(&mut self, link_id: aya::programs::perf_event::PerfEventLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::perf_event::PerfEvent::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::perf_event::PerfEvent::take_link(&mut self, link_id: aya::programs::perf_event::PerfEventLinkId) -> core::result::Result impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::perf_event::PerfEvent::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::perf_event::PerfEvent::from_pin>(path: P) -> core::result::Result impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::info(&self) -> core::result::Result +pub fn aya::programs::perf_event::PerfEvent::info(&self) -> core::result::Result impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::perf_event::PerfEvent::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::perf_event::PerfEvent::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::perf_event::PerfEvent::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::perf_event::PerfEvent pub fn aya::programs::perf_event::PerfEvent::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::perf_event::PerfEvent pub fn aya::programs::perf_event::PerfEvent::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::perf_event::PerfEvent -pub type &'a aya::programs::perf_event::PerfEvent::Error = aya::programs::ProgramError -pub fn &'a aya::programs::perf_event::PerfEvent::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::perf_event::PerfEvent, aya::programs::ProgramError> +pub type &'a aya::programs::perf_event::PerfEvent::Error = aya::errors::ProgramError +pub fn &'a aya::programs::perf_event::PerfEvent::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::perf_event::PerfEvent, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::perf_event::PerfEvent -pub type &'a mut aya::programs::perf_event::PerfEvent::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::perf_event::PerfEvent::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::perf_event::PerfEvent, aya::programs::ProgramError> +pub type &'a mut aya::programs::perf_event::PerfEvent::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::perf_event::PerfEvent::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::perf_event::PerfEvent, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::perf_event::PerfEvent impl core::marker::Send for aya::programs::perf_event::PerfEvent impl core::marker::Sync for aya::programs::perf_event::PerfEvent @@ -4713,13 +4696,13 @@ pub fn aya::programs::perf_event::PerfEvent::from(t: T) -> T pub struct aya::programs::perf_event::PerfEventLink(_) impl aya::programs::links::Link for aya::programs::perf_event::PerfEventLink pub type aya::programs::perf_event::PerfEventLink::Id = aya::programs::perf_event::PerfEventLinkId -pub fn aya::programs::perf_event::PerfEventLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::perf_event::PerfEventLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::perf_event::PerfEventLink::id(&self) -> Self::Id impl core::convert::TryFrom for aya::programs::perf_event::PerfEventLink -pub type aya::programs::perf_event::PerfEventLink::Error = aya::programs::links::LinkError +pub type aya::programs::perf_event::PerfEventLink::Error = aya::errors::LinkError pub fn aya::programs::perf_event::PerfEventLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::perf_event::PerfEventLink) -> core::result::Result impl core::fmt::Debug for aya::programs::perf_event::PerfEventLink pub fn aya::programs::perf_event::PerfEventLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -4783,31 +4766,31 @@ pub fn aya::programs::perf_event::PerfEventLinkId::from(t: T) -> T pub mod aya::programs::raw_trace_point pub struct aya::programs::raw_trace_point::RawTracePoint impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::attach(&mut self, tp_name: &str) -> core::result::Result -pub fn aya::programs::raw_trace_point::RawTracePoint::detach(&mut self, link_id: aya::programs::raw_trace_point::RawTracePointLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::raw_trace_point::RawTracePoint::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::raw_trace_point::RawTracePoint::take_link(&mut self, link_id: aya::programs::raw_trace_point::RawTracePointLinkId) -> core::result::Result +pub fn aya::programs::raw_trace_point::RawTracePoint::attach(&mut self, tp_name: &str) -> core::result::Result +pub fn aya::programs::raw_trace_point::RawTracePoint::detach(&mut self, link_id: aya::programs::raw_trace_point::RawTracePointLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::raw_trace_point::RawTracePoint::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePoint::take_link(&mut self, link_id: aya::programs::raw_trace_point::RawTracePointLinkId) -> core::result::Result impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::raw_trace_point::RawTracePoint::from_pin>(path: P) -> core::result::Result impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::info(&self) -> core::result::Result +pub fn aya::programs::raw_trace_point::RawTracePoint::info(&self) -> core::result::Result impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::raw_trace_point::RawTracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::raw_trace_point::RawTracePoint::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePoint::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::raw_trace_point::RawTracePoint pub fn aya::programs::raw_trace_point::RawTracePoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::raw_trace_point::RawTracePoint pub fn aya::programs::raw_trace_point::RawTracePoint::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::raw_trace_point::RawTracePoint -pub type &'a aya::programs::raw_trace_point::RawTracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::raw_trace_point::RawTracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::raw_trace_point::RawTracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::raw_trace_point::RawTracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::raw_trace_point::RawTracePoint -pub type &'a mut aya::programs::raw_trace_point::RawTracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::raw_trace_point::RawTracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::raw_trace_point::RawTracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::raw_trace_point::RawTracePoint, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::raw_trace_point::RawTracePoint impl core::marker::Send for aya::programs::raw_trace_point::RawTracePoint impl core::marker::Sync for aya::programs::raw_trace_point::RawTracePoint @@ -4833,7 +4816,7 @@ pub fn aya::programs::raw_trace_point::RawTracePoint::from(t: T) -> T pub struct aya::programs::raw_trace_point::RawTracePointLink(_) impl aya::programs::links::Link for aya::programs::raw_trace_point::RawTracePointLink pub type aya::programs::raw_trace_point::RawTracePointLink::Id = aya::programs::raw_trace_point::RawTracePointLinkId -pub fn aya::programs::raw_trace_point::RawTracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::raw_trace_point::RawTracePointLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::raw_trace_point::RawTracePointLink pub fn aya::programs::raw_trace_point::RawTracePointLink::from(b: aya::programs::links::FdLink) -> aya::programs::raw_trace_point::RawTracePointLink @@ -4901,31 +4884,31 @@ pub fn aya::programs::raw_trace_point::RawTracePointLinkId::from(t: T) -> T pub mod aya::programs::sk_lookup pub struct aya::programs::sk_lookup::SkLookup impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::attach(&mut self, netns: T) -> core::result::Result -pub fn aya::programs::sk_lookup::SkLookup::detach(&mut self, link_id: aya::programs::sk_lookup::SkLookupLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_lookup::SkLookup::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_lookup::SkLookup::take_link(&mut self, link_id: aya::programs::sk_lookup::SkLookupLinkId) -> core::result::Result +pub fn aya::programs::sk_lookup::SkLookup::attach(&mut self, netns: T) -> core::result::Result +pub fn aya::programs::sk_lookup::SkLookup::detach(&mut self, link_id: aya::programs::sk_lookup::SkLookupLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::sk_lookup::SkLookup::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::sk_lookup::SkLookup::take_link(&mut self, link_id: aya::programs::sk_lookup::SkLookupLinkId) -> core::result::Result impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::sk_lookup::SkLookup::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::sk_lookup::SkLookup::from_pin>(path: P) -> core::result::Result impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::info(&self) -> core::result::Result +pub fn aya::programs::sk_lookup::SkLookup::info(&self) -> core::result::Result impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::sk_lookup::SkLookup::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::sk_lookup::SkLookup::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_lookup::SkLookup::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::sk_lookup::SkLookup pub fn aya::programs::sk_lookup::SkLookup::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::sk_lookup::SkLookup pub fn aya::programs::sk_lookup::SkLookup::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_lookup::SkLookup -pub type &'a aya::programs::sk_lookup::SkLookup::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_lookup::SkLookup::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_lookup::SkLookup, aya::programs::ProgramError> +pub type &'a aya::programs::sk_lookup::SkLookup::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_lookup::SkLookup::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_lookup::SkLookup, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_lookup::SkLookup -pub type &'a mut aya::programs::sk_lookup::SkLookup::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_lookup::SkLookup::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_lookup::SkLookup, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_lookup::SkLookup::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_lookup::SkLookup::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_lookup::SkLookup, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::sk_lookup::SkLookup impl core::marker::Send for aya::programs::sk_lookup::SkLookup impl core::marker::Sync for aya::programs::sk_lookup::SkLookup @@ -4951,7 +4934,7 @@ pub fn aya::programs::sk_lookup::SkLookup::from(t: T) -> T pub struct aya::programs::sk_lookup::SkLookupLink(_) impl aya::programs::links::Link for aya::programs::sk_lookup::SkLookupLink pub type aya::programs::sk_lookup::SkLookupLink::Id = aya::programs::sk_lookup::SkLookupLinkId -pub fn aya::programs::sk_lookup::SkLookupLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_lookup::SkLookupLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_lookup::SkLookupLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::sk_lookup::SkLookupLink pub fn aya::programs::sk_lookup::SkLookupLink::from(b: aya::programs::links::FdLink) -> aya::programs::sk_lookup::SkLookupLink @@ -5019,31 +5002,31 @@ pub fn aya::programs::sk_lookup::SkLookupLinkId::from(t: T) -> T pub mod aya::programs::sk_msg pub struct aya::programs::sk_msg::SkMsg impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::attach(&mut self, map: &aya::maps::sock::SockMapFd) -> core::result::Result -pub fn aya::programs::sk_msg::SkMsg::detach(&mut self, link_id: aya::programs::sk_msg::SkMsgLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_msg::SkMsg::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_msg::SkMsg::take_link(&mut self, link_id: aya::programs::sk_msg::SkMsgLinkId) -> core::result::Result +pub fn aya::programs::sk_msg::SkMsg::attach(&mut self, map: &aya::maps::sock::SockMapFd) -> core::result::Result +pub fn aya::programs::sk_msg::SkMsg::detach(&mut self, link_id: aya::programs::sk_msg::SkMsgLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::sk_msg::SkMsg::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::sk_msg::SkMsg::take_link(&mut self, link_id: aya::programs::sk_msg::SkMsgLinkId) -> core::result::Result impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::sk_msg::SkMsg::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::sk_msg::SkMsg::from_pin>(path: P) -> core::result::Result impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::info(&self) -> core::result::Result +pub fn aya::programs::sk_msg::SkMsg::info(&self) -> core::result::Result impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::sk_msg::SkMsg::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::sk_msg::SkMsg::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_msg::SkMsg::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::sk_msg::SkMsg pub fn aya::programs::sk_msg::SkMsg::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::sk_msg::SkMsg pub fn aya::programs::sk_msg::SkMsg::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_msg::SkMsg -pub type &'a aya::programs::sk_msg::SkMsg::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_msg::SkMsg::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_msg::SkMsg, aya::programs::ProgramError> +pub type &'a aya::programs::sk_msg::SkMsg::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_msg::SkMsg::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_msg::SkMsg, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_msg::SkMsg -pub type &'a mut aya::programs::sk_msg::SkMsg::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_msg::SkMsg::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_msg::SkMsg, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_msg::SkMsg::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_msg::SkMsg::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_msg::SkMsg, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::sk_msg::SkMsg impl core::marker::Send for aya::programs::sk_msg::SkMsg impl core::marker::Sync for aya::programs::sk_msg::SkMsg @@ -5069,7 +5052,7 @@ pub fn aya::programs::sk_msg::SkMsg::from(t: T) -> T pub struct aya::programs::sk_msg::SkMsgLink(_) impl aya::programs::links::Link for aya::programs::sk_msg::SkMsgLink pub type aya::programs::sk_msg::SkMsgLink::Id = aya::programs::sk_msg::SkMsgLinkId -pub fn aya::programs::sk_msg::SkMsgLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_msg::SkMsgLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_msg::SkMsgLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::sk_msg::SkMsgLink pub fn aya::programs::sk_msg::SkMsgLink::from(b: aya::programs::links::ProgAttachLink) -> aya::programs::sk_msg::SkMsgLink @@ -5173,30 +5156,30 @@ impl core::convert::From for aya::programs::sk_skb::SkSkbKind pub fn aya::programs::sk_skb::SkSkbKind::from(t: T) -> T pub struct aya::programs::sk_skb::SkSkb impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::attach(&mut self, map: &aya::maps::sock::SockMapFd) -> core::result::Result -pub fn aya::programs::sk_skb::SkSkb::detach(&mut self, link_id: aya::programs::sk_skb::SkSkbLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_skb::SkSkb::from_pin>(path: P, kind: aya::programs::sk_skb::SkSkbKind) -> core::result::Result -pub fn aya::programs::sk_skb::SkSkb::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_skb::SkSkb::take_link(&mut self, link_id: aya::programs::sk_skb::SkSkbLinkId) -> core::result::Result +pub fn aya::programs::sk_skb::SkSkb::attach(&mut self, map: &aya::maps::sock::SockMapFd) -> core::result::Result +pub fn aya::programs::sk_skb::SkSkb::detach(&mut self, link_id: aya::programs::sk_skb::SkSkbLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::sk_skb::SkSkb::from_pin>(path: P, kind: aya::programs::sk_skb::SkSkbKind) -> core::result::Result +pub fn aya::programs::sk_skb::SkSkb::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::sk_skb::SkSkb::take_link(&mut self, link_id: aya::programs::sk_skb::SkSkbLinkId) -> core::result::Result impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::sk_skb::SkSkb::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::info(&self) -> core::result::Result +pub fn aya::programs::sk_skb::SkSkb::info(&self) -> core::result::Result impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::sk_skb::SkSkb::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::sk_skb::SkSkb::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_skb::SkSkb::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::sk_skb::SkSkb pub fn aya::programs::sk_skb::SkSkb::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::sk_skb::SkSkb pub fn aya::programs::sk_skb::SkSkb::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_skb::SkSkb -pub type &'a aya::programs::sk_skb::SkSkb::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_skb::SkSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_skb::SkSkb, aya::programs::ProgramError> +pub type &'a aya::programs::sk_skb::SkSkb::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_skb::SkSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_skb::SkSkb, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_skb::SkSkb -pub type &'a mut aya::programs::sk_skb::SkSkb::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_skb::SkSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_skb::SkSkb, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_skb::SkSkb::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_skb::SkSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_skb::SkSkb, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::sk_skb::SkSkb impl core::marker::Send for aya::programs::sk_skb::SkSkb impl core::marker::Sync for aya::programs::sk_skb::SkSkb @@ -5222,7 +5205,7 @@ pub fn aya::programs::sk_skb::SkSkb::from(t: T) -> T pub struct aya::programs::sk_skb::SkSkbLink(_) impl aya::programs::links::Link for aya::programs::sk_skb::SkSkbLink pub type aya::programs::sk_skb::SkSkbLink::Id = aya::programs::sk_skb::SkSkbLinkId -pub fn aya::programs::sk_skb::SkSkbLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_skb::SkSkbLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_skb::SkSkbLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::sk_skb::SkSkbLink pub fn aya::programs::sk_skb::SkSkbLink::from(b: aya::programs::links::ProgAttachLink) -> aya::programs::sk_skb::SkSkbLink @@ -5290,31 +5273,31 @@ pub fn aya::programs::sk_skb::SkSkbLinkId::from(t: T) -> T pub mod aya::programs::sock_ops pub struct aya::programs::sock_ops::SockOps impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::sock_ops::SockOps::detach(&mut self, link_id: aya::programs::sock_ops::SockOpsLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sock_ops::SockOps::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sock_ops::SockOps::take_link(&mut self, link_id: aya::programs::sock_ops::SockOpsLinkId) -> core::result::Result +pub fn aya::programs::sock_ops::SockOps::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::sock_ops::SockOps::detach(&mut self, link_id: aya::programs::sock_ops::SockOpsLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::sock_ops::SockOps::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::sock_ops::SockOps::take_link(&mut self, link_id: aya::programs::sock_ops::SockOpsLinkId) -> core::result::Result impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::sock_ops::SockOps::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::sock_ops::SockOps::from_pin>(path: P) -> core::result::Result impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::info(&self) -> core::result::Result +pub fn aya::programs::sock_ops::SockOps::info(&self) -> core::result::Result impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::sock_ops::SockOps::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::sock_ops::SockOps::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sock_ops::SockOps::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::sock_ops::SockOps pub fn aya::programs::sock_ops::SockOps::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::sock_ops::SockOps pub fn aya::programs::sock_ops::SockOps::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sock_ops::SockOps -pub type &'a aya::programs::sock_ops::SockOps::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sock_ops::SockOps::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sock_ops::SockOps, aya::programs::ProgramError> +pub type &'a aya::programs::sock_ops::SockOps::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sock_ops::SockOps::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sock_ops::SockOps, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sock_ops::SockOps -pub type &'a mut aya::programs::sock_ops::SockOps::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sock_ops::SockOps::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sock_ops::SockOps, aya::programs::ProgramError> +pub type &'a mut aya::programs::sock_ops::SockOps::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sock_ops::SockOps::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sock_ops::SockOps, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::sock_ops::SockOps impl core::marker::Send for aya::programs::sock_ops::SockOps impl core::marker::Sync for aya::programs::sock_ops::SockOps @@ -5340,7 +5323,7 @@ pub fn aya::programs::sock_ops::SockOps::from(t: T) -> T pub struct aya::programs::sock_ops::SockOpsLink(_) impl aya::programs::links::Link for aya::programs::sock_ops::SockOpsLink pub type aya::programs::sock_ops::SockOpsLink::Id = aya::programs::sock_ops::SockOpsLinkId -pub fn aya::programs::sock_ops::SockOpsLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sock_ops::SockOpsLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sock_ops::SockOpsLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::sock_ops::SockOpsLink pub fn aya::programs::sock_ops::SockOpsLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -5402,68 +5385,33 @@ pub fn aya::programs::sock_ops::SockOpsLinkId::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::programs::sock_ops::SockOpsLinkId pub fn aya::programs::sock_ops::SockOpsLinkId::from(t: T) -> T pub mod aya::programs::socket_filter -pub enum aya::programs::socket_filter::SocketFilterError -pub aya::programs::socket_filter::SocketFilterError::SoAttachEbpfError -pub aya::programs::socket_filter::SocketFilterError::SoAttachEbpfError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::socket_filter::SocketFilterError) -> Self -impl core::error::Error for aya::programs::socket_filter::SocketFilterError -pub fn aya::programs::socket_filter::SocketFilterError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::socket_filter::SocketFilterError -pub fn aya::programs::socket_filter::SocketFilterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::socket_filter::SocketFilterError -pub fn aya::programs::socket_filter::SocketFilterError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::socket_filter::SocketFilterError -impl core::marker::Send for aya::programs::socket_filter::SocketFilterError -impl core::marker::Sync for aya::programs::socket_filter::SocketFilterError -impl core::marker::Unpin for aya::programs::socket_filter::SocketFilterError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::socket_filter::SocketFilterError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::socket_filter::SocketFilterError -impl core::convert::Into for aya::programs::socket_filter::SocketFilterError where U: core::convert::From -pub fn aya::programs::socket_filter::SocketFilterError::into(self) -> U -impl core::convert::TryFrom for aya::programs::socket_filter::SocketFilterError where U: core::convert::Into -pub type aya::programs::socket_filter::SocketFilterError::Error = core::convert::Infallible -pub fn aya::programs::socket_filter::SocketFilterError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::socket_filter::SocketFilterError where U: core::convert::TryFrom -pub type aya::programs::socket_filter::SocketFilterError::Error = >::Error -pub fn aya::programs::socket_filter::SocketFilterError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::socket_filter::SocketFilterError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::socket_filter::SocketFilterError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::socket_filter::SocketFilterError where T: 'static + core::marker::Sized -pub fn aya::programs::socket_filter::SocketFilterError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::socket_filter::SocketFilterError where T: core::marker::Sized -pub fn aya::programs::socket_filter::SocketFilterError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::socket_filter::SocketFilterError where T: core::marker::Sized -pub fn aya::programs::socket_filter::SocketFilterError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::socket_filter::SocketFilterError -pub fn aya::programs::socket_filter::SocketFilterError::from(t: T) -> T pub struct aya::programs::socket_filter::SocketFilter impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::attach(&mut self, socket: T) -> core::result::Result -pub fn aya::programs::socket_filter::SocketFilter::detach(&mut self, link_id: aya::programs::socket_filter::SocketFilterLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::socket_filter::SocketFilter::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::socket_filter::SocketFilter::take_link(&mut self, link_id: aya::programs::socket_filter::SocketFilterLinkId) -> core::result::Result +pub fn aya::programs::socket_filter::SocketFilter::attach(&mut self, socket: T) -> core::result::Result +pub fn aya::programs::socket_filter::SocketFilter::detach(&mut self, link_id: aya::programs::socket_filter::SocketFilterLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::socket_filter::SocketFilter::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::socket_filter::SocketFilter::take_link(&mut self, link_id: aya::programs::socket_filter::SocketFilterLinkId) -> core::result::Result impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::socket_filter::SocketFilter::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::socket_filter::SocketFilter::from_pin>(path: P) -> core::result::Result impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::info(&self) -> core::result::Result +pub fn aya::programs::socket_filter::SocketFilter::info(&self) -> core::result::Result impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::socket_filter::SocketFilter::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::socket_filter::SocketFilter::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::socket_filter::SocketFilter::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::socket_filter::SocketFilter pub fn aya::programs::socket_filter::SocketFilter::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::socket_filter::SocketFilter pub fn aya::programs::socket_filter::SocketFilter::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::socket_filter::SocketFilter -pub type &'a aya::programs::socket_filter::SocketFilter::Error = aya::programs::ProgramError -pub fn &'a aya::programs::socket_filter::SocketFilter::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::socket_filter::SocketFilter, aya::programs::ProgramError> +pub type &'a aya::programs::socket_filter::SocketFilter::Error = aya::errors::ProgramError +pub fn &'a aya::programs::socket_filter::SocketFilter::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::socket_filter::SocketFilter, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::socket_filter::SocketFilter -pub type &'a mut aya::programs::socket_filter::SocketFilter::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::socket_filter::SocketFilter::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::socket_filter::SocketFilter, aya::programs::ProgramError> +pub type &'a mut aya::programs::socket_filter::SocketFilter::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::socket_filter::SocketFilter::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::socket_filter::SocketFilter, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::socket_filter::SocketFilter impl core::marker::Send for aya::programs::socket_filter::SocketFilter impl core::marker::Sync for aya::programs::socket_filter::SocketFilter @@ -5489,7 +5437,7 @@ pub fn aya::programs::socket_filter::SocketFilter::from(t: T) -> T pub struct aya::programs::socket_filter::SocketFilterLink impl aya::programs::links::Link for aya::programs::socket_filter::SocketFilterLink pub type aya::programs::socket_filter::SocketFilterLink::Id = aya::programs::socket_filter::SocketFilterLinkId -pub fn aya::programs::socket_filter::SocketFilterLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::socket_filter::SocketFilterLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::socket_filter::SocketFilterLink::id(&self) -> Self::Id impl core::fmt::Debug for aya::programs::socket_filter::SocketFilterLink pub fn aya::programs::socket_filter::SocketFilterLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -5621,44 +5569,6 @@ impl core::clone::CloneToUninit for aya::programs::tc::TcAttachType where T: pub unsafe fn aya::programs::tc::TcAttachType::clone_to_uninit(&self, dst: *mut T) impl core::convert::From for aya::programs::tc::TcAttachType pub fn aya::programs::tc::TcAttachType::from(t: T) -> T -pub enum aya::programs::tc::TcError -pub aya::programs::tc::TcError::AlreadyAttached -pub aya::programs::tc::TcError::InvalidLinkOperation -pub aya::programs::tc::TcError::InvalidTcxAttach(u32) -pub aya::programs::tc::TcError::NetlinkError -pub aya::programs::tc::TcError::NetlinkError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::tc::TcError) -> Self -impl core::error::Error for aya::programs::tc::TcError -pub fn aya::programs::tc::TcError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::tc::TcError -pub fn aya::programs::tc::TcError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::tc::TcError -pub fn aya::programs::tc::TcError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::tc::TcError -impl core::marker::Send for aya::programs::tc::TcError -impl core::marker::Sync for aya::programs::tc::TcError -impl core::marker::Unpin for aya::programs::tc::TcError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::tc::TcError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::tc::TcError -impl core::convert::Into for aya::programs::tc::TcError where U: core::convert::From -pub fn aya::programs::tc::TcError::into(self) -> U -impl core::convert::TryFrom for aya::programs::tc::TcError where U: core::convert::Into -pub type aya::programs::tc::TcError::Error = core::convert::Infallible -pub fn aya::programs::tc::TcError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::tc::TcError where U: core::convert::TryFrom -pub type aya::programs::tc::TcError::Error = >::Error -pub fn aya::programs::tc::TcError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::tc::TcError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::tc::TcError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::tc::TcError where T: 'static + core::marker::Sized -pub fn aya::programs::tc::TcError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::tc::TcError where T: core::marker::Sized -pub fn aya::programs::tc::TcError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::tc::TcError where T: core::marker::Sized -pub fn aya::programs::tc::TcError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::tc::TcError -pub fn aya::programs::tc::TcError::from(t: T) -> T pub struct aya::programs::tc::NlOptions pub aya::programs::tc::NlOptions::handle: u32 pub aya::programs::tc::NlOptions::priority: u16 @@ -5698,35 +5608,35 @@ impl core::convert::From for aya::programs::tc::NlOptions pub fn aya::programs::tc::NlOptions::from(t: T) -> T pub struct aya::programs::tc::SchedClassifier impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::attach(&mut self, interface: &str, attach_type: aya::programs::tc::TcAttachType) -> core::result::Result -pub fn aya::programs::tc::SchedClassifier::attach_to_link(&mut self, link: aya::programs::tc::SchedClassifierLink) -> core::result::Result -pub fn aya::programs::tc::SchedClassifier::attach_with_options(&mut self, interface: &str, attach_type: aya::programs::tc::TcAttachType, options: aya::programs::tc::TcAttachOptions) -> core::result::Result -pub fn aya::programs::tc::SchedClassifier::detach(&mut self, link_id: aya::programs::tc::SchedClassifierLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::tc::SchedClassifier::from_pin>(path: P) -> core::result::Result -pub fn aya::programs::tc::SchedClassifier::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::tc::SchedClassifier::query_tcx(interface: &str, attach_type: aya::programs::tc::TcAttachType) -> core::result::Result<(u64, alloc::vec::Vec), aya::programs::ProgramError> -pub fn aya::programs::tc::SchedClassifier::take_link(&mut self, link_id: aya::programs::tc::SchedClassifierLinkId) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::attach(&mut self, interface: &str, attach_type: aya::programs::tc::TcAttachType) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::attach_to_link(&mut self, link: aya::programs::tc::SchedClassifierLink) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::attach_with_options(&mut self, interface: &str, attach_type: aya::programs::tc::TcAttachType, options: aya::programs::tc::TcAttachOptions) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::detach(&mut self, link_id: aya::programs::tc::SchedClassifierLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::tc::SchedClassifier::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::tc::SchedClassifier::query_tcx(interface: &str, attach_type: aya::programs::tc::TcAttachType) -> core::result::Result<(u64, alloc::vec::Vec), aya::errors::LinkError> +pub fn aya::programs::tc::SchedClassifier::take_link(&mut self, link_id: aya::programs::tc::SchedClassifierLinkId) -> core::result::Result impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::info(&self) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::info(&self) -> core::result::Result impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::tc::SchedClassifier::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::tc::SchedClassifier::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifier::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl aya::programs::MultiProgram for aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result, aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result, aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::tc::SchedClassifier pub fn aya::programs::tc::SchedClassifier::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::tc::SchedClassifier pub fn aya::programs::tc::SchedClassifier::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::tc::SchedClassifier -pub type &'a aya::programs::tc::SchedClassifier::Error = aya::programs::ProgramError -pub fn &'a aya::programs::tc::SchedClassifier::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tc::SchedClassifier, aya::programs::ProgramError> +pub type &'a aya::programs::tc::SchedClassifier::Error = aya::errors::ProgramError +pub fn &'a aya::programs::tc::SchedClassifier::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tc::SchedClassifier, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::tc::SchedClassifier -pub type &'a mut aya::programs::tc::SchedClassifier::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::tc::SchedClassifier::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tc::SchedClassifier, aya::programs::ProgramError> +pub type &'a mut aya::programs::tc::SchedClassifier::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::tc::SchedClassifier::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tc::SchedClassifier, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::tc::SchedClassifier impl core::marker::Send for aya::programs::tc::SchedClassifier impl core::marker::Sync for aya::programs::tc::SchedClassifier @@ -5751,28 +5661,28 @@ impl core::convert::From for aya::programs::tc::SchedClassifier pub fn aya::programs::tc::SchedClassifier::from(t: T) -> T pub struct aya::programs::tc::SchedClassifierLink(_) impl aya::programs::tc::SchedClassifierLink -pub fn aya::programs::tc::SchedClassifierLink::attach_type(&self) -> core::result::Result +pub fn aya::programs::tc::SchedClassifierLink::attach_type(&self) -> core::result::Result pub fn aya::programs::tc::SchedClassifierLink::attached(if_name: &str, attach_type: aya::programs::tc::TcAttachType, priority: u16, handle: u32) -> core::result::Result -pub fn aya::programs::tc::SchedClassifierLink::handle(&self) -> core::result::Result -pub fn aya::programs::tc::SchedClassifierLink::priority(&self) -> core::result::Result +pub fn aya::programs::tc::SchedClassifierLink::handle(&self) -> core::result::Result +pub fn aya::programs::tc::SchedClassifierLink::priority(&self) -> core::result::Result impl aya::programs::MultiProgLink for aya::programs::tc::SchedClassifierLink -pub fn aya::programs::tc::SchedClassifierLink::fd(&self) -> core::result::Result, aya::programs::links::LinkError> +pub fn aya::programs::tc::SchedClassifierLink::fd(&self) -> core::result::Result, aya::errors::LinkError> impl aya::programs::links::Link for aya::programs::tc::SchedClassifierLink pub type aya::programs::tc::SchedClassifierLink::Id = aya::programs::tc::SchedClassifierLinkId -pub fn aya::programs::tc::SchedClassifierLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifierLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::tc::SchedClassifierLink::id(&self) -> Self::Id impl core::convert::TryFrom for aya::programs::tc::SchedClassifierLink -pub type aya::programs::tc::SchedClassifierLink::Error = aya::programs::links::LinkError +pub type aya::programs::tc::SchedClassifierLink::Error = aya::errors::LinkError pub fn aya::programs::tc::SchedClassifierLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::tc::SchedClassifierLink) -> core::result::Result impl core::fmt::Debug for aya::programs::tc::SchedClassifierLink pub fn aya::programs::tc::SchedClassifierLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::tc::SchedClassifierLink pub fn aya::programs::tc::SchedClassifierLink::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::tc::SchedClassifierLink> for &'a aya::programs::links::FdLink -pub type &'a aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type &'a aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn &'a aya::programs::links::FdLink::try_from(value: &'a aya::programs::tc::SchedClassifierLink) -> core::result::Result impl core::marker::Freeze for aya::programs::tc::SchedClassifierLink impl core::marker::Send for aya::programs::tc::SchedClassifierLink @@ -5834,31 +5744,31 @@ pub fn aya::programs::tc::qdisc_detach_program(if_name: &str, attach_type: aya:: pub mod aya::programs::tp_btf pub struct aya::programs::tp_btf::BtfTracePoint impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::attach(&mut self) -> core::result::Result -pub fn aya::programs::tp_btf::BtfTracePoint::detach(&mut self, link_id: aya::programs::tp_btf::BtfTracePointLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::tp_btf::BtfTracePoint::load(&mut self, tracepoint: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::tp_btf::BtfTracePoint::take_link(&mut self, link_id: aya::programs::tp_btf::BtfTracePointLinkId) -> core::result::Result +pub fn aya::programs::tp_btf::BtfTracePoint::attach(&mut self) -> core::result::Result +pub fn aya::programs::tp_btf::BtfTracePoint::detach(&mut self, link_id: aya::programs::tp_btf::BtfTracePointLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::tp_btf::BtfTracePoint::load(&mut self, tracepoint: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePoint::take_link(&mut self, link_id: aya::programs::tp_btf::BtfTracePointLinkId) -> core::result::Result impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::tp_btf::BtfTracePoint::from_pin>(path: P) -> core::result::Result impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::info(&self) -> core::result::Result +pub fn aya::programs::tp_btf::BtfTracePoint::info(&self) -> core::result::Result impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::tp_btf::BtfTracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::tp_btf::BtfTracePoint::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePoint::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::tp_btf::BtfTracePoint pub fn aya::programs::tp_btf::BtfTracePoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::tp_btf::BtfTracePoint pub fn aya::programs::tp_btf::BtfTracePoint::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::tp_btf::BtfTracePoint -pub type &'a aya::programs::tp_btf::BtfTracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tp_btf::BtfTracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::tp_btf::BtfTracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tp_btf::BtfTracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::tp_btf::BtfTracePoint -pub type &'a mut aya::programs::tp_btf::BtfTracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tp_btf::BtfTracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::tp_btf::BtfTracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tp_btf::BtfTracePoint, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::tp_btf::BtfTracePoint impl core::marker::Send for aya::programs::tp_btf::BtfTracePoint impl core::marker::Sync for aya::programs::tp_btf::BtfTracePoint @@ -5884,7 +5794,7 @@ pub fn aya::programs::tp_btf::BtfTracePoint::from(t: T) -> T pub struct aya::programs::tp_btf::BtfTracePointLink(_) impl aya::programs::links::Link for aya::programs::tp_btf::BtfTracePointLink pub type aya::programs::tp_btf::BtfTracePointLink::Id = aya::programs::tp_btf::BtfTracePointLinkId -pub fn aya::programs::tp_btf::BtfTracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::tp_btf::BtfTracePointLink::id(&self) -> Self::Id impl core::convert::From for aya::programs::tp_btf::BtfTracePointLink pub fn aya::programs::tp_btf::BtfTracePointLink::from(b: aya::programs::links::FdLink) -> aya::programs::tp_btf::BtfTracePointLink @@ -5950,69 +5860,33 @@ pub fn aya::programs::tp_btf::BtfTracePointLinkId::borrow_mut(&mut self) -> &mut impl core::convert::From for aya::programs::tp_btf::BtfTracePointLinkId pub fn aya::programs::tp_btf::BtfTracePointLinkId::from(t: T) -> T pub mod aya::programs::trace_point -pub enum aya::programs::trace_point::TracePointError -pub aya::programs::trace_point::TracePointError::FileError -pub aya::programs::trace_point::TracePointError::FileError::filename: alloc::string::String -pub aya::programs::trace_point::TracePointError::FileError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::trace_point::TracePointError) -> Self -impl core::error::Error for aya::programs::trace_point::TracePointError -pub fn aya::programs::trace_point::TracePointError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::trace_point::TracePointError -pub fn aya::programs::trace_point::TracePointError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::trace_point::TracePointError -pub fn aya::programs::trace_point::TracePointError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::trace_point::TracePointError -impl core::marker::Send for aya::programs::trace_point::TracePointError -impl core::marker::Sync for aya::programs::trace_point::TracePointError -impl core::marker::Unpin for aya::programs::trace_point::TracePointError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::trace_point::TracePointError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::trace_point::TracePointError -impl core::convert::Into for aya::programs::trace_point::TracePointError where U: core::convert::From -pub fn aya::programs::trace_point::TracePointError::into(self) -> U -impl core::convert::TryFrom for aya::programs::trace_point::TracePointError where U: core::convert::Into -pub type aya::programs::trace_point::TracePointError::Error = core::convert::Infallible -pub fn aya::programs::trace_point::TracePointError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::trace_point::TracePointError where U: core::convert::TryFrom -pub type aya::programs::trace_point::TracePointError::Error = >::Error -pub fn aya::programs::trace_point::TracePointError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::trace_point::TracePointError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::trace_point::TracePointError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::trace_point::TracePointError where T: 'static + core::marker::Sized -pub fn aya::programs::trace_point::TracePointError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::trace_point::TracePointError where T: core::marker::Sized -pub fn aya::programs::trace_point::TracePointError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::trace_point::TracePointError where T: core::marker::Sized -pub fn aya::programs::trace_point::TracePointError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::trace_point::TracePointError -pub fn aya::programs::trace_point::TracePointError::from(t: T) -> T pub struct aya::programs::trace_point::TracePoint impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::attach(&mut self, category: &str, name: &str) -> core::result::Result -pub fn aya::programs::trace_point::TracePoint::detach(&mut self, link_id: aya::programs::trace_point::TracePointLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::trace_point::TracePoint::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::trace_point::TracePoint::take_link(&mut self, link_id: aya::programs::trace_point::TracePointLinkId) -> core::result::Result +pub fn aya::programs::trace_point::TracePoint::attach(&mut self, category: &str, name: &str) -> core::result::Result +pub fn aya::programs::trace_point::TracePoint::detach(&mut self, link_id: aya::programs::trace_point::TracePointLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::trace_point::TracePoint::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::trace_point::TracePoint::take_link(&mut self, link_id: aya::programs::trace_point::TracePointLinkId) -> core::result::Result impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::trace_point::TracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::trace_point::TracePoint::from_pin>(path: P) -> core::result::Result impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::info(&self) -> core::result::Result +pub fn aya::programs::trace_point::TracePoint::info(&self) -> core::result::Result impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::trace_point::TracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::trace_point::TracePoint::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::trace_point::TracePoint::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::trace_point::TracePoint pub fn aya::programs::trace_point::TracePoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::trace_point::TracePoint pub fn aya::programs::trace_point::TracePoint::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::trace_point::TracePoint -pub type &'a aya::programs::trace_point::TracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::trace_point::TracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::trace_point::TracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::trace_point::TracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::trace_point::TracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::trace_point::TracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::trace_point::TracePoint -pub type &'a mut aya::programs::trace_point::TracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::trace_point::TracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::trace_point::TracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::trace_point::TracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::trace_point::TracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::trace_point::TracePoint, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::trace_point::TracePoint impl core::marker::Send for aya::programs::trace_point::TracePoint impl core::marker::Sync for aya::programs::trace_point::TracePoint @@ -6038,13 +5912,13 @@ pub fn aya::programs::trace_point::TracePoint::from(t: T) -> T pub struct aya::programs::trace_point::TracePointLink(_) impl aya::programs::links::Link for aya::programs::trace_point::TracePointLink pub type aya::programs::trace_point::TracePointLink::Id = aya::programs::trace_point::TracePointLinkId -pub fn aya::programs::trace_point::TracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::trace_point::TracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::trace_point::TracePointLink::id(&self) -> Self::Id impl core::convert::TryFrom for aya::programs::trace_point::TracePointLink -pub type aya::programs::trace_point::TracePointLink::Error = aya::programs::links::LinkError +pub type aya::programs::trace_point::TracePointLink::Error = aya::errors::LinkError pub fn aya::programs::trace_point::TracePointLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::trace_point::TracePointLink) -> core::result::Result impl core::fmt::Debug for aya::programs::trace_point::TracePointLink pub fn aya::programs::trace_point::TracePointLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -6106,76 +5980,33 @@ pub fn aya::programs::trace_point::TracePointLinkId::borrow_mut(&mut self) -> &m impl core::convert::From for aya::programs::trace_point::TracePointLinkId pub fn aya::programs::trace_point::TracePointLinkId::from(t: T) -> T pub mod aya::programs::uprobe -pub enum aya::programs::uprobe::UProbeError -pub aya::programs::uprobe::UProbeError::FileError -pub aya::programs::uprobe::UProbeError::FileError::filename: std::path::PathBuf -pub aya::programs::uprobe::UProbeError::FileError::io_error: std::io::error::Error -pub aya::programs::uprobe::UProbeError::InvalidLdSoCache -pub aya::programs::uprobe::UProbeError::InvalidLdSoCache::io_error: &'static std::io::error::Error -pub aya::programs::uprobe::UProbeError::InvalidTarget -pub aya::programs::uprobe::UProbeError::InvalidTarget::path: std::path::PathBuf -pub aya::programs::uprobe::UProbeError::SymbolError -pub aya::programs::uprobe::UProbeError::SymbolError::error: alloc::boxed::Box<(dyn core::error::Error + core::marker::Send + core::marker::Sync)> -pub aya::programs::uprobe::UProbeError::SymbolError::symbol: alloc::string::String -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::uprobe::UProbeError) -> Self -impl core::error::Error for aya::programs::uprobe::UProbeError -pub fn aya::programs::uprobe::UProbeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::uprobe::UProbeError -pub fn aya::programs::uprobe::UProbeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::uprobe::UProbeError -pub fn aya::programs::uprobe::UProbeError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::uprobe::UProbeError -impl core::marker::Send for aya::programs::uprobe::UProbeError -impl core::marker::Sync for aya::programs::uprobe::UProbeError -impl core::marker::Unpin for aya::programs::uprobe::UProbeError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::uprobe::UProbeError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::uprobe::UProbeError -impl core::convert::Into for aya::programs::uprobe::UProbeError where U: core::convert::From -pub fn aya::programs::uprobe::UProbeError::into(self) -> U -impl core::convert::TryFrom for aya::programs::uprobe::UProbeError where U: core::convert::Into -pub type aya::programs::uprobe::UProbeError::Error = core::convert::Infallible -pub fn aya::programs::uprobe::UProbeError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::uprobe::UProbeError where U: core::convert::TryFrom -pub type aya::programs::uprobe::UProbeError::Error = >::Error -pub fn aya::programs::uprobe::UProbeError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::uprobe::UProbeError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::uprobe::UProbeError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::uprobe::UProbeError where T: 'static + core::marker::Sized -pub fn aya::programs::uprobe::UProbeError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::uprobe::UProbeError where T: core::marker::Sized -pub fn aya::programs::uprobe::UProbeError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::uprobe::UProbeError where T: core::marker::Sized -pub fn aya::programs::uprobe::UProbeError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::uprobe::UProbeError -pub fn aya::programs::uprobe::UProbeError::from(t: T) -> T pub struct aya::programs::uprobe::UProbe impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::attach>(&mut self, fn_name: core::option::Option<&str>, offset: u64, target: T, pid: core::option::Option) -> core::result::Result -pub fn aya::programs::uprobe::UProbe::detach(&mut self, link_id: aya::programs::uprobe::UProbeLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::uprobe::UProbe::from_pin>(path: P, kind: aya::programs::ProbeKind) -> core::result::Result +pub fn aya::programs::uprobe::UProbe::attach>(&mut self, fn_name: core::option::Option<&str>, offset: u64, target: T, pid: core::option::Option) -> core::result::Result +pub fn aya::programs::uprobe::UProbe::detach(&mut self, link_id: aya::programs::uprobe::UProbeLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::uprobe::UProbe::from_pin>(path: P, kind: aya::programs::ProbeKind) -> core::result::Result pub fn aya::programs::uprobe::UProbe::kind(&self) -> aya::programs::ProbeKind -pub fn aya::programs::uprobe::UProbe::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::uprobe::UProbe::take_link(&mut self, link_id: aya::programs::uprobe::UProbeLinkId) -> core::result::Result +pub fn aya::programs::uprobe::UProbe::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::uprobe::UProbe::take_link(&mut self, link_id: aya::programs::uprobe::UProbeLinkId) -> core::result::Result impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::uprobe::UProbe::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::info(&self) -> core::result::Result +pub fn aya::programs::uprobe::UProbe::info(&self) -> core::result::Result impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::uprobe::UProbe::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::uprobe::UProbe::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::uprobe::UProbe::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::uprobe::UProbe pub fn aya::programs::uprobe::UProbe::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::uprobe::UProbe pub fn aya::programs::uprobe::UProbe::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::uprobe::UProbe -pub type &'a aya::programs::uprobe::UProbe::Error = aya::programs::ProgramError -pub fn &'a aya::programs::uprobe::UProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::uprobe::UProbe, aya::programs::ProgramError> +pub type &'a aya::programs::uprobe::UProbe::Error = aya::errors::ProgramError +pub fn &'a aya::programs::uprobe::UProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::uprobe::UProbe, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::uprobe::UProbe -pub type &'a mut aya::programs::uprobe::UProbe::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::uprobe::UProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::uprobe::UProbe, aya::programs::ProgramError> +pub type &'a mut aya::programs::uprobe::UProbe::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::uprobe::UProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::uprobe::UProbe, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::uprobe::UProbe impl core::marker::Send for aya::programs::uprobe::UProbe impl core::marker::Sync for aya::programs::uprobe::UProbe @@ -6201,13 +6032,13 @@ pub fn aya::programs::uprobe::UProbe::from(t: T) -> T pub struct aya::programs::uprobe::UProbeLink(_) impl aya::programs::links::Link for aya::programs::uprobe::UProbeLink pub type aya::programs::uprobe::UProbeLink::Id = aya::programs::uprobe::UProbeLinkId -pub fn aya::programs::uprobe::UProbeLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::uprobe::UProbeLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::uprobe::UProbeLink::id(&self) -> Self::Id impl core::convert::TryFrom for aya::programs::uprobe::UProbeLink -pub type aya::programs::uprobe::UProbeLink::Error = aya::programs::links::LinkError +pub type aya::programs::uprobe::UProbeLink::Error = aya::errors::LinkError pub fn aya::programs::uprobe::UProbeLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::uprobe::UProbeLink) -> core::result::Result impl core::fmt::Debug for aya::programs::uprobe::UProbeLink pub fn aya::programs::uprobe::UProbeLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -6269,69 +6100,34 @@ pub fn aya::programs::uprobe::UProbeLinkId::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::programs::uprobe::UProbeLinkId pub fn aya::programs::uprobe::UProbeLinkId::from(t: T) -> T pub mod aya::programs::xdp -pub enum aya::programs::xdp::XdpError -pub aya::programs::xdp::XdpError::NetlinkError -pub aya::programs::xdp::XdpError::NetlinkError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::xdp::XdpError) -> Self -impl core::error::Error for aya::programs::xdp::XdpError -pub fn aya::programs::xdp::XdpError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::xdp::XdpError -pub fn aya::programs::xdp::XdpError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::xdp::XdpError -pub fn aya::programs::xdp::XdpError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::xdp::XdpError -impl core::marker::Send for aya::programs::xdp::XdpError -impl core::marker::Sync for aya::programs::xdp::XdpError -impl core::marker::Unpin for aya::programs::xdp::XdpError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::xdp::XdpError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::xdp::XdpError -impl core::convert::Into for aya::programs::xdp::XdpError where U: core::convert::From -pub fn aya::programs::xdp::XdpError::into(self) -> U -impl core::convert::TryFrom for aya::programs::xdp::XdpError where U: core::convert::Into -pub type aya::programs::xdp::XdpError::Error = core::convert::Infallible -pub fn aya::programs::xdp::XdpError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::xdp::XdpError where U: core::convert::TryFrom -pub type aya::programs::xdp::XdpError::Error = >::Error -pub fn aya::programs::xdp::XdpError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::xdp::XdpError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::xdp::XdpError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::xdp::XdpError where T: 'static + core::marker::Sized -pub fn aya::programs::xdp::XdpError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::xdp::XdpError where T: core::marker::Sized -pub fn aya::programs::xdp::XdpError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::xdp::XdpError where T: core::marker::Sized -pub fn aya::programs::xdp::XdpError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::xdp::XdpError -pub fn aya::programs::xdp::XdpError::from(t: T) -> T pub struct aya::programs::xdp::Xdp impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::attach(&mut self, interface: &str, flags: aya::programs::xdp::XdpFlags) -> core::result::Result -pub fn aya::programs::xdp::Xdp::attach_to_if_index(&mut self, if_index: u32, flags: aya::programs::xdp::XdpFlags) -> core::result::Result -pub fn aya::programs::xdp::Xdp::attach_to_link(&mut self, link: aya::programs::xdp::XdpLink) -> core::result::Result -pub fn aya::programs::xdp::Xdp::detach(&mut self, link_id: aya::programs::xdp::XdpLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::xdp::Xdp::from_pin>(path: P, attach_type: aya_obj::programs::xdp::XdpAttachType) -> core::result::Result -pub fn aya::programs::xdp::Xdp::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::xdp::Xdp::take_link(&mut self, link_id: aya::programs::xdp::XdpLinkId) -> core::result::Result +pub fn aya::programs::xdp::Xdp::attach(&mut self, interface: &str, flags: aya::programs::xdp::XdpFlags) -> core::result::Result +pub fn aya::programs::xdp::Xdp::attach_to_if_index(&mut self, if_index: u32, flags: aya::programs::xdp::XdpFlags) -> core::result::Result +pub fn aya::programs::xdp::Xdp::attach_to_link(&mut self, link: aya::programs::xdp::XdpLink) -> core::result::Result +pub fn aya::programs::xdp::Xdp::detach(&mut self, link_id: aya::programs::xdp::XdpLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::xdp::Xdp::from_pin>(path: P, attach_type: aya_obj::programs::xdp::XdpAttachType) -> core::result::Result +pub fn aya::programs::xdp::Xdp::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::xdp::Xdp::take_link(&mut self, link_id: aya::programs::xdp::XdpLinkId) -> core::result::Result impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::xdp::Xdp::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::info(&self) -> core::result::Result +pub fn aya::programs::xdp::Xdp::info(&self) -> core::result::Result impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::xdp::Xdp::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::xdp::Xdp::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::xdp::Xdp::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::xdp::Xdp pub fn aya::programs::xdp::Xdp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::xdp::Xdp pub fn aya::programs::xdp::Xdp::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::xdp::Xdp -pub type &'a aya::programs::xdp::Xdp::Error = aya::programs::ProgramError -pub fn &'a aya::programs::xdp::Xdp::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::xdp::Xdp, aya::programs::ProgramError> +pub type &'a aya::programs::xdp::Xdp::Error = aya::errors::ProgramError +pub fn &'a aya::programs::xdp::Xdp::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::xdp::Xdp, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::xdp::Xdp -pub type &'a mut aya::programs::xdp::Xdp::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::xdp::Xdp::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::xdp::Xdp, aya::programs::ProgramError> +pub type &'a mut aya::programs::xdp::Xdp::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::xdp::Xdp::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::xdp::Xdp, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::xdp::Xdp impl core::marker::Send for aya::programs::xdp::Xdp impl core::marker::Sync for aya::programs::xdp::Xdp @@ -6470,13 +6266,13 @@ pub fn aya::programs::xdp::XdpFlags::from(t: T) -> T pub struct aya::programs::xdp::XdpLink(_) impl aya::programs::links::Link for aya::programs::xdp::XdpLink pub type aya::programs::xdp::XdpLink::Id = aya::programs::xdp::XdpLinkId -pub fn aya::programs::xdp::XdpLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::xdp::XdpLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::xdp::XdpLink::id(&self) -> Self::Id impl core::convert::TryFrom for aya::programs::xdp::XdpLink -pub type aya::programs::xdp::XdpLink::Error = aya::programs::links::LinkError +pub type aya::programs::xdp::XdpLink::Error = aya::errors::LinkError pub fn aya::programs::xdp::XdpLink::try_from(fd_link: aya::programs::links::FdLink) -> core::result::Result impl core::convert::TryFrom for aya::programs::links::FdLink -pub type aya::programs::links::FdLink::Error = aya::programs::links::LinkError +pub type aya::programs::links::FdLink::Error = aya::errors::LinkError pub fn aya::programs::links::FdLink::try_from(value: aya::programs::xdp::XdpLink) -> core::result::Result impl core::fmt::Debug for aya::programs::xdp::XdpLink pub fn aya::programs::xdp::XdpLink::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -6614,75 +6410,6 @@ impl core::clone::CloneToUninit for aya::programs::cgroup_skb::CgroupSkbAttac pub unsafe fn aya::programs::cgroup_skb::CgroupSkbAttachType::clone_to_uninit(&self, dst: *mut T) impl core::convert::From for aya::programs::cgroup_skb::CgroupSkbAttachType pub fn aya::programs::cgroup_skb::CgroupSkbAttachType::from(t: T) -> T -pub enum aya::programs::ExtensionError -pub aya::programs::ExtensionError::NoBTF -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::extension::ExtensionError) -> Self -impl core::error::Error for aya::programs::extension::ExtensionError -impl core::fmt::Debug for aya::programs::extension::ExtensionError -pub fn aya::programs::extension::ExtensionError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::extension::ExtensionError -pub fn aya::programs::extension::ExtensionError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::extension::ExtensionError -impl core::marker::Send for aya::programs::extension::ExtensionError -impl core::marker::Sync for aya::programs::extension::ExtensionError -impl core::marker::Unpin for aya::programs::extension::ExtensionError -impl core::panic::unwind_safe::RefUnwindSafe for aya::programs::extension::ExtensionError -impl core::panic::unwind_safe::UnwindSafe for aya::programs::extension::ExtensionError -impl core::convert::Into for aya::programs::extension::ExtensionError where U: core::convert::From -pub fn aya::programs::extension::ExtensionError::into(self) -> U -impl core::convert::TryFrom for aya::programs::extension::ExtensionError where U: core::convert::Into -pub type aya::programs::extension::ExtensionError::Error = core::convert::Infallible -pub fn aya::programs::extension::ExtensionError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::extension::ExtensionError where U: core::convert::TryFrom -pub type aya::programs::extension::ExtensionError::Error = >::Error -pub fn aya::programs::extension::ExtensionError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::extension::ExtensionError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::extension::ExtensionError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::extension::ExtensionError where T: 'static + core::marker::Sized -pub fn aya::programs::extension::ExtensionError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::extension::ExtensionError where T: core::marker::Sized -pub fn aya::programs::extension::ExtensionError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::extension::ExtensionError where T: core::marker::Sized -pub fn aya::programs::extension::ExtensionError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::extension::ExtensionError -pub fn aya::programs::extension::ExtensionError::from(t: T) -> T -pub enum aya::programs::KProbeError -pub aya::programs::KProbeError::FileError -pub aya::programs::KProbeError::FileError::filename: std::path::PathBuf -pub aya::programs::KProbeError::FileError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::kprobe::KProbeError) -> Self -impl core::error::Error for aya::programs::kprobe::KProbeError -pub fn aya::programs::kprobe::KProbeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::kprobe::KProbeError -pub fn aya::programs::kprobe::KProbeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::kprobe::KProbeError -pub fn aya::programs::kprobe::KProbeError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::kprobe::KProbeError -impl core::marker::Send for aya::programs::kprobe::KProbeError -impl core::marker::Sync for aya::programs::kprobe::KProbeError -impl core::marker::Unpin for aya::programs::kprobe::KProbeError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::kprobe::KProbeError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::kprobe::KProbeError -impl core::convert::Into for aya::programs::kprobe::KProbeError where U: core::convert::From -pub fn aya::programs::kprobe::KProbeError::into(self) -> U -impl core::convert::TryFrom for aya::programs::kprobe::KProbeError where U: core::convert::Into -pub type aya::programs::kprobe::KProbeError::Error = core::convert::Infallible -pub fn aya::programs::kprobe::KProbeError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::kprobe::KProbeError where U: core::convert::TryFrom -pub type aya::programs::kprobe::KProbeError::Error = >::Error -pub fn aya::programs::kprobe::KProbeError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::kprobe::KProbeError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::kprobe::KProbeError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::kprobe::KProbeError where T: 'static + core::marker::Sized -pub fn aya::programs::kprobe::KProbeError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::kprobe::KProbeError where T: core::marker::Sized -pub fn aya::programs::kprobe::KProbeError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::kprobe::KProbeError where T: core::marker::Sized -pub fn aya::programs::kprobe::KProbeError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::kprobe::KProbeError -pub fn aya::programs::kprobe::KProbeError::from(t: T) -> T pub enum aya::programs::PerfEventScope pub aya::programs::PerfEventScope::AllProcessesOneCpu pub aya::programs::PerfEventScope::AllProcessesOneCpu::cpu: u32 @@ -6829,157 +6556,157 @@ pub aya::programs::Program::TracePoint(aya::programs::trace_point::TracePoint) pub aya::programs::Program::UProbe(aya::programs::uprobe::UProbe) pub aya::programs::Program::Xdp(aya::programs::xdp::Xdp) impl aya::programs::Program -pub fn aya::programs::Program::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> -pub fn aya::programs::Program::info(&self) -> core::result::Result -pub fn aya::programs::Program::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::Program::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> +pub fn aya::programs::Program::info(&self) -> core::result::Result +pub fn aya::programs::Program::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::Program::prog_type(&self) -> aya::programs::ProgramType -pub fn aya::programs::Program::unload(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::Program::unload(self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::Program pub fn aya::programs::Program::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_device::CgroupDevice -pub type &'a aya::programs::cgroup_device::CgroupDevice::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_device::CgroupDevice, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_device::CgroupDevice::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_device::CgroupDevice, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_skb::CgroupSkb -pub type &'a aya::programs::cgroup_skb::CgroupSkb::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_skb::CgroupSkb, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_skb::CgroupSkb::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_skb::CgroupSkb, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sock::CgroupSock -pub type &'a aya::programs::cgroup_sock::CgroupSock::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock::CgroupSock, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sock::CgroupSock::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock::CgroupSock, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sock_addr::CgroupSockAddr -pub type &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sockopt::CgroupSockopt -pub type &'a aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sockopt::CgroupSockopt, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sockopt::CgroupSockopt, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sysctl::CgroupSysctl -pub type &'a aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sysctl::CgroupSysctl, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sysctl::CgroupSysctl, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::extension::Extension -pub type &'a aya::programs::extension::Extension::Error = aya::programs::ProgramError -pub fn &'a aya::programs::extension::Extension::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::extension::Extension, aya::programs::ProgramError> +pub type &'a aya::programs::extension::Extension::Error = aya::errors::ProgramError +pub fn &'a aya::programs::extension::Extension::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::extension::Extension, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::fentry::FEntry -pub type &'a aya::programs::fentry::FEntry::Error = aya::programs::ProgramError -pub fn &'a aya::programs::fentry::FEntry::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fentry::FEntry, aya::programs::ProgramError> +pub type &'a aya::programs::fentry::FEntry::Error = aya::errors::ProgramError +pub fn &'a aya::programs::fentry::FEntry::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fentry::FEntry, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::fexit::FExit -pub type &'a aya::programs::fexit::FExit::Error = aya::programs::ProgramError -pub fn &'a aya::programs::fexit::FExit::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fexit::FExit, aya::programs::ProgramError> +pub type &'a aya::programs::fexit::FExit::Error = aya::errors::ProgramError +pub fn &'a aya::programs::fexit::FExit::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fexit::FExit, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::kprobe::KProbe -pub type &'a aya::programs::kprobe::KProbe::Error = aya::programs::ProgramError -pub fn &'a aya::programs::kprobe::KProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::kprobe::KProbe, aya::programs::ProgramError> +pub type &'a aya::programs::kprobe::KProbe::Error = aya::errors::ProgramError +pub fn &'a aya::programs::kprobe::KProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::kprobe::KProbe, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::lirc_mode2::LircMode2 -pub type &'a aya::programs::lirc_mode2::LircMode2::Error = aya::programs::ProgramError -pub fn &'a aya::programs::lirc_mode2::LircMode2::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lirc_mode2::LircMode2, aya::programs::ProgramError> +pub type &'a aya::programs::lirc_mode2::LircMode2::Error = aya::errors::ProgramError +pub fn &'a aya::programs::lirc_mode2::LircMode2::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lirc_mode2::LircMode2, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::lsm::Lsm -pub type &'a aya::programs::lsm::Lsm::Error = aya::programs::ProgramError -pub fn &'a aya::programs::lsm::Lsm::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lsm::Lsm, aya::programs::ProgramError> +pub type &'a aya::programs::lsm::Lsm::Error = aya::errors::ProgramError +pub fn &'a aya::programs::lsm::Lsm::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lsm::Lsm, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::perf_event::PerfEvent -pub type &'a aya::programs::perf_event::PerfEvent::Error = aya::programs::ProgramError -pub fn &'a aya::programs::perf_event::PerfEvent::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::perf_event::PerfEvent, aya::programs::ProgramError> +pub type &'a aya::programs::perf_event::PerfEvent::Error = aya::errors::ProgramError +pub fn &'a aya::programs::perf_event::PerfEvent::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::perf_event::PerfEvent, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::raw_trace_point::RawTracePoint -pub type &'a aya::programs::raw_trace_point::RawTracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::raw_trace_point::RawTracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::raw_trace_point::RawTracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::raw_trace_point::RawTracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_lookup::SkLookup -pub type &'a aya::programs::sk_lookup::SkLookup::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_lookup::SkLookup::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_lookup::SkLookup, aya::programs::ProgramError> +pub type &'a aya::programs::sk_lookup::SkLookup::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_lookup::SkLookup::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_lookup::SkLookup, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_msg::SkMsg -pub type &'a aya::programs::sk_msg::SkMsg::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_msg::SkMsg::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_msg::SkMsg, aya::programs::ProgramError> +pub type &'a aya::programs::sk_msg::SkMsg::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_msg::SkMsg::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_msg::SkMsg, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_skb::SkSkb -pub type &'a aya::programs::sk_skb::SkSkb::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_skb::SkSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_skb::SkSkb, aya::programs::ProgramError> +pub type &'a aya::programs::sk_skb::SkSkb::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_skb::SkSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_skb::SkSkb, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sock_ops::SockOps -pub type &'a aya::programs::sock_ops::SockOps::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sock_ops::SockOps::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sock_ops::SockOps, aya::programs::ProgramError> +pub type &'a aya::programs::sock_ops::SockOps::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sock_ops::SockOps::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sock_ops::SockOps, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::socket_filter::SocketFilter -pub type &'a aya::programs::socket_filter::SocketFilter::Error = aya::programs::ProgramError -pub fn &'a aya::programs::socket_filter::SocketFilter::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::socket_filter::SocketFilter, aya::programs::ProgramError> +pub type &'a aya::programs::socket_filter::SocketFilter::Error = aya::errors::ProgramError +pub fn &'a aya::programs::socket_filter::SocketFilter::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::socket_filter::SocketFilter, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::tc::SchedClassifier -pub type &'a aya::programs::tc::SchedClassifier::Error = aya::programs::ProgramError -pub fn &'a aya::programs::tc::SchedClassifier::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tc::SchedClassifier, aya::programs::ProgramError> +pub type &'a aya::programs::tc::SchedClassifier::Error = aya::errors::ProgramError +pub fn &'a aya::programs::tc::SchedClassifier::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tc::SchedClassifier, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::tp_btf::BtfTracePoint -pub type &'a aya::programs::tp_btf::BtfTracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tp_btf::BtfTracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::tp_btf::BtfTracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tp_btf::BtfTracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::trace_point::TracePoint -pub type &'a aya::programs::trace_point::TracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::trace_point::TracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::trace_point::TracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::trace_point::TracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::trace_point::TracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::trace_point::TracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::uprobe::UProbe -pub type &'a aya::programs::uprobe::UProbe::Error = aya::programs::ProgramError -pub fn &'a aya::programs::uprobe::UProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::uprobe::UProbe, aya::programs::ProgramError> +pub type &'a aya::programs::uprobe::UProbe::Error = aya::errors::ProgramError +pub fn &'a aya::programs::uprobe::UProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::uprobe::UProbe, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::xdp::Xdp -pub type &'a aya::programs::xdp::Xdp::Error = aya::programs::ProgramError -pub fn &'a aya::programs::xdp::Xdp::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::xdp::Xdp, aya::programs::ProgramError> +pub type &'a aya::programs::xdp::Xdp::Error = aya::errors::ProgramError +pub fn &'a aya::programs::xdp::Xdp::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::xdp::Xdp, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_device::CgroupDevice -pub type &'a mut aya::programs::cgroup_device::CgroupDevice::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_device::CgroupDevice, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_device::CgroupDevice::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_device::CgroupDevice, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_skb::CgroupSkb -pub type &'a mut aya::programs::cgroup_skb::CgroupSkb::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_skb::CgroupSkb, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_skb::CgroupSkb::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_skb::CgroupSkb, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sock::CgroupSock -pub type &'a mut aya::programs::cgroup_sock::CgroupSock::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock::CgroupSock, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sock::CgroupSock::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock::CgroupSock, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr -pub type &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sockopt::CgroupSockopt -pub type &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sockopt::CgroupSockopt, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sockopt::CgroupSockopt, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sysctl::CgroupSysctl -pub type &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sysctl::CgroupSysctl, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sysctl::CgroupSysctl, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::extension::Extension -pub type &'a mut aya::programs::extension::Extension::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::extension::Extension::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::extension::Extension, aya::programs::ProgramError> +pub type &'a mut aya::programs::extension::Extension::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::extension::Extension::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::extension::Extension, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::fentry::FEntry -pub type &'a mut aya::programs::fentry::FEntry::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::fentry::FEntry::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fentry::FEntry, aya::programs::ProgramError> +pub type &'a mut aya::programs::fentry::FEntry::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::fentry::FEntry::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fentry::FEntry, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::fexit::FExit -pub type &'a mut aya::programs::fexit::FExit::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::fexit::FExit::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fexit::FExit, aya::programs::ProgramError> +pub type &'a mut aya::programs::fexit::FExit::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::fexit::FExit::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fexit::FExit, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::kprobe::KProbe -pub type &'a mut aya::programs::kprobe::KProbe::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::kprobe::KProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::kprobe::KProbe, aya::programs::ProgramError> +pub type &'a mut aya::programs::kprobe::KProbe::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::kprobe::KProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::kprobe::KProbe, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::lirc_mode2::LircMode2 -pub type &'a mut aya::programs::lirc_mode2::LircMode2::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::lirc_mode2::LircMode2::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lirc_mode2::LircMode2, aya::programs::ProgramError> +pub type &'a mut aya::programs::lirc_mode2::LircMode2::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::lirc_mode2::LircMode2::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lirc_mode2::LircMode2, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::lsm::Lsm -pub type &'a mut aya::programs::lsm::Lsm::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::lsm::Lsm::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lsm::Lsm, aya::programs::ProgramError> +pub type &'a mut aya::programs::lsm::Lsm::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::lsm::Lsm::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lsm::Lsm, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::perf_event::PerfEvent -pub type &'a mut aya::programs::perf_event::PerfEvent::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::perf_event::PerfEvent::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::perf_event::PerfEvent, aya::programs::ProgramError> +pub type &'a mut aya::programs::perf_event::PerfEvent::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::perf_event::PerfEvent::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::perf_event::PerfEvent, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::raw_trace_point::RawTracePoint -pub type &'a mut aya::programs::raw_trace_point::RawTracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::raw_trace_point::RawTracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::raw_trace_point::RawTracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::raw_trace_point::RawTracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_lookup::SkLookup -pub type &'a mut aya::programs::sk_lookup::SkLookup::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_lookup::SkLookup::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_lookup::SkLookup, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_lookup::SkLookup::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_lookup::SkLookup::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_lookup::SkLookup, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_msg::SkMsg -pub type &'a mut aya::programs::sk_msg::SkMsg::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_msg::SkMsg::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_msg::SkMsg, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_msg::SkMsg::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_msg::SkMsg::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_msg::SkMsg, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_skb::SkSkb -pub type &'a mut aya::programs::sk_skb::SkSkb::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_skb::SkSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_skb::SkSkb, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_skb::SkSkb::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_skb::SkSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_skb::SkSkb, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sock_ops::SockOps -pub type &'a mut aya::programs::sock_ops::SockOps::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sock_ops::SockOps::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sock_ops::SockOps, aya::programs::ProgramError> +pub type &'a mut aya::programs::sock_ops::SockOps::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sock_ops::SockOps::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sock_ops::SockOps, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::socket_filter::SocketFilter -pub type &'a mut aya::programs::socket_filter::SocketFilter::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::socket_filter::SocketFilter::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::socket_filter::SocketFilter, aya::programs::ProgramError> +pub type &'a mut aya::programs::socket_filter::SocketFilter::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::socket_filter::SocketFilter::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::socket_filter::SocketFilter, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::tc::SchedClassifier -pub type &'a mut aya::programs::tc::SchedClassifier::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::tc::SchedClassifier::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tc::SchedClassifier, aya::programs::ProgramError> +pub type &'a mut aya::programs::tc::SchedClassifier::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::tc::SchedClassifier::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tc::SchedClassifier, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::tp_btf::BtfTracePoint -pub type &'a mut aya::programs::tp_btf::BtfTracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tp_btf::BtfTracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::tp_btf::BtfTracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tp_btf::BtfTracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::trace_point::TracePoint -pub type &'a mut aya::programs::trace_point::TracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::trace_point::TracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::trace_point::TracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::trace_point::TracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::trace_point::TracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::trace_point::TracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::uprobe::UProbe -pub type &'a mut aya::programs::uprobe::UProbe::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::uprobe::UProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::uprobe::UProbe, aya::programs::ProgramError> +pub type &'a mut aya::programs::uprobe::UProbe::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::uprobe::UProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::uprobe::UProbe, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::xdp::Xdp -pub type &'a mut aya::programs::xdp::Xdp::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::xdp::Xdp::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::xdp::Xdp, aya::programs::ProgramError> +pub type &'a mut aya::programs::xdp::Xdp::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::xdp::Xdp::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::xdp::Xdp, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::Program impl core::marker::Send for aya::programs::Program impl core::marker::Sync for aya::programs::Program @@ -7002,84 +6729,6 @@ impl core::borrow::BorrowMut for aya::programs::Program where T: core::mar pub fn aya::programs::Program::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::programs::Program pub fn aya::programs::Program::from(t: T) -> T -pub enum aya::programs::ProgramError -pub aya::programs::ProgramError::AlreadyAttached -pub aya::programs::ProgramError::AlreadyLoaded -pub aya::programs::ProgramError::Btf(aya_obj::btf::btf::BtfError) -pub aya::programs::ProgramError::ExtensionError(aya::programs::extension::ExtensionError) -pub aya::programs::ProgramError::IOError(std::io::error::Error) -pub aya::programs::ProgramError::InvalidName -pub aya::programs::ProgramError::InvalidName::name: alloc::string::String -pub aya::programs::ProgramError::KProbeError(aya::programs::kprobe::KProbeError) -pub aya::programs::ProgramError::LoadError -pub aya::programs::ProgramError::LoadError::io_error: std::io::error::Error -pub aya::programs::ProgramError::LoadError::verifier_log: aya_obj::VerifierLog -pub aya::programs::ProgramError::MapError(aya::maps::MapError) -pub aya::programs::ProgramError::NotAttached -pub aya::programs::ProgramError::NotLoaded -pub aya::programs::ProgramError::SocketFilterError(aya::programs::socket_filter::SocketFilterError) -pub aya::programs::ProgramError::SyscallError(aya::sys::SyscallError) -pub aya::programs::ProgramError::TcError(aya::programs::tc::TcError) -pub aya::programs::ProgramError::TracePointError(aya::programs::trace_point::TracePointError) -pub aya::programs::ProgramError::UProbeError(aya::programs::uprobe::UProbeError) -pub aya::programs::ProgramError::UnexpectedProgramType -pub aya::programs::ProgramError::UnknownInterface -pub aya::programs::ProgramError::UnknownInterface::name: alloc::string::String -pub aya::programs::ProgramError::XdpError(aya::programs::xdp::XdpError) -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::maps::MapError) -> Self -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(source: aya::programs::ProgramError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::extension::ExtensionError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::kprobe::KProbeError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::socket_filter::SocketFilterError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::tc::TcError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::trace_point::TracePointError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::uprobe::UProbeError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::xdp::XdpError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::sys::SyscallError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya_obj::btf::btf::BtfError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: std::io::error::Error) -> Self -impl core::error::Error for aya::programs::ProgramError -pub fn aya::programs::ProgramError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::ProgramError -pub fn aya::programs::ProgramError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::ProgramError -pub fn aya::programs::ProgramError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::ProgramError -impl core::marker::Send for aya::programs::ProgramError -impl core::marker::Sync for aya::programs::ProgramError -impl core::marker::Unpin for aya::programs::ProgramError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::ProgramError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::ProgramError -impl core::convert::Into for aya::programs::ProgramError where U: core::convert::From -pub fn aya::programs::ProgramError::into(self) -> U -impl core::convert::TryFrom for aya::programs::ProgramError where U: core::convert::Into -pub type aya::programs::ProgramError::Error = core::convert::Infallible -pub fn aya::programs::ProgramError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::ProgramError where U: core::convert::TryFrom -pub type aya::programs::ProgramError::Error = >::Error -pub fn aya::programs::ProgramError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::ProgramError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::ProgramError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::ProgramError where T: 'static + core::marker::Sized -pub fn aya::programs::ProgramError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::ProgramError where T: core::marker::Sized -pub fn aya::programs::ProgramError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::ProgramError where T: core::marker::Sized -pub fn aya::programs::ProgramError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(t: T) -> T #[non_exhaustive] pub enum aya::programs::ProgramType pub aya::programs::ProgramType::CgroupDevice = 15 pub aya::programs::ProgramType::CgroupSkb = 8 @@ -7119,7 +6768,7 @@ pub fn aya::programs::ProgramType::clone(&self) -> aya::programs::ProgramType impl core::cmp::PartialEq for aya::programs::ProgramType pub fn aya::programs::ProgramType::eq(&self, other: &aya::programs::ProgramType) -> bool impl core::convert::TryFrom for aya::programs::ProgramType -pub type aya::programs::ProgramType::Error = aya::programs::ProgramError +pub type aya::programs::ProgramType::Error = aya::errors::ProgramError pub fn aya::programs::ProgramType::try_from(prog_type: aya_obj::generated::linux_bindings_x86_64::bpf_prog_type) -> core::result::Result impl core::fmt::Debug for aya::programs::ProgramType pub fn aya::programs::ProgramType::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result @@ -7224,41 +6873,6 @@ impl core::clone::CloneToUninit for aya::programs::sk_skb::SkSkbKind where T: pub unsafe fn aya::programs::sk_skb::SkSkbKind::clone_to_uninit(&self, dst: *mut T) impl core::convert::From for aya::programs::sk_skb::SkSkbKind pub fn aya::programs::sk_skb::SkSkbKind::from(t: T) -> T -pub enum aya::programs::SocketFilterError -pub aya::programs::SocketFilterError::SoAttachEbpfError -pub aya::programs::SocketFilterError::SoAttachEbpfError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::socket_filter::SocketFilterError) -> Self -impl core::error::Error for aya::programs::socket_filter::SocketFilterError -pub fn aya::programs::socket_filter::SocketFilterError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::socket_filter::SocketFilterError -pub fn aya::programs::socket_filter::SocketFilterError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::socket_filter::SocketFilterError -pub fn aya::programs::socket_filter::SocketFilterError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::socket_filter::SocketFilterError -impl core::marker::Send for aya::programs::socket_filter::SocketFilterError -impl core::marker::Sync for aya::programs::socket_filter::SocketFilterError -impl core::marker::Unpin for aya::programs::socket_filter::SocketFilterError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::socket_filter::SocketFilterError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::socket_filter::SocketFilterError -impl core::convert::Into for aya::programs::socket_filter::SocketFilterError where U: core::convert::From -pub fn aya::programs::socket_filter::SocketFilterError::into(self) -> U -impl core::convert::TryFrom for aya::programs::socket_filter::SocketFilterError where U: core::convert::Into -pub type aya::programs::socket_filter::SocketFilterError::Error = core::convert::Infallible -pub fn aya::programs::socket_filter::SocketFilterError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::socket_filter::SocketFilterError where U: core::convert::TryFrom -pub type aya::programs::socket_filter::SocketFilterError::Error = >::Error -pub fn aya::programs::socket_filter::SocketFilterError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::socket_filter::SocketFilterError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::socket_filter::SocketFilterError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::socket_filter::SocketFilterError where T: 'static + core::marker::Sized -pub fn aya::programs::socket_filter::SocketFilterError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::socket_filter::SocketFilterError where T: core::marker::Sized -pub fn aya::programs::socket_filter::SocketFilterError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::socket_filter::SocketFilterError where T: core::marker::Sized -pub fn aya::programs::socket_filter::SocketFilterError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::socket_filter::SocketFilterError -pub fn aya::programs::socket_filter::SocketFilterError::from(t: T) -> T pub enum aya::programs::TcAttachType pub aya::programs::TcAttachType::Custom(u32) pub aya::programs::TcAttachType::Egress @@ -7304,185 +6918,33 @@ impl core::clone::CloneToUninit for aya::programs::tc::TcAttachType where T: pub unsafe fn aya::programs::tc::TcAttachType::clone_to_uninit(&self, dst: *mut T) impl core::convert::From for aya::programs::tc::TcAttachType pub fn aya::programs::tc::TcAttachType::from(t: T) -> T -pub enum aya::programs::TcError -pub aya::programs::TcError::AlreadyAttached -pub aya::programs::TcError::InvalidLinkOperation -pub aya::programs::TcError::InvalidTcxAttach(u32) -pub aya::programs::TcError::NetlinkError -pub aya::programs::TcError::NetlinkError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::tc::TcError) -> Self -impl core::error::Error for aya::programs::tc::TcError -pub fn aya::programs::tc::TcError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::tc::TcError -pub fn aya::programs::tc::TcError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::tc::TcError -pub fn aya::programs::tc::TcError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::tc::TcError -impl core::marker::Send for aya::programs::tc::TcError -impl core::marker::Sync for aya::programs::tc::TcError -impl core::marker::Unpin for aya::programs::tc::TcError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::tc::TcError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::tc::TcError -impl core::convert::Into for aya::programs::tc::TcError where U: core::convert::From -pub fn aya::programs::tc::TcError::into(self) -> U -impl core::convert::TryFrom for aya::programs::tc::TcError where U: core::convert::Into -pub type aya::programs::tc::TcError::Error = core::convert::Infallible -pub fn aya::programs::tc::TcError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::tc::TcError where U: core::convert::TryFrom -pub type aya::programs::tc::TcError::Error = >::Error -pub fn aya::programs::tc::TcError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::tc::TcError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::tc::TcError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::tc::TcError where T: 'static + core::marker::Sized -pub fn aya::programs::tc::TcError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::tc::TcError where T: core::marker::Sized -pub fn aya::programs::tc::TcError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::tc::TcError where T: core::marker::Sized -pub fn aya::programs::tc::TcError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::tc::TcError -pub fn aya::programs::tc::TcError::from(t: T) -> T -pub enum aya::programs::TracePointError -pub aya::programs::TracePointError::FileError -pub aya::programs::TracePointError::FileError::filename: alloc::string::String -pub aya::programs::TracePointError::FileError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::trace_point::TracePointError) -> Self -impl core::error::Error for aya::programs::trace_point::TracePointError -pub fn aya::programs::trace_point::TracePointError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::trace_point::TracePointError -pub fn aya::programs::trace_point::TracePointError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::trace_point::TracePointError -pub fn aya::programs::trace_point::TracePointError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::trace_point::TracePointError -impl core::marker::Send for aya::programs::trace_point::TracePointError -impl core::marker::Sync for aya::programs::trace_point::TracePointError -impl core::marker::Unpin for aya::programs::trace_point::TracePointError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::trace_point::TracePointError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::trace_point::TracePointError -impl core::convert::Into for aya::programs::trace_point::TracePointError where U: core::convert::From -pub fn aya::programs::trace_point::TracePointError::into(self) -> U -impl core::convert::TryFrom for aya::programs::trace_point::TracePointError where U: core::convert::Into -pub type aya::programs::trace_point::TracePointError::Error = core::convert::Infallible -pub fn aya::programs::trace_point::TracePointError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::trace_point::TracePointError where U: core::convert::TryFrom -pub type aya::programs::trace_point::TracePointError::Error = >::Error -pub fn aya::programs::trace_point::TracePointError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::trace_point::TracePointError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::trace_point::TracePointError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::trace_point::TracePointError where T: 'static + core::marker::Sized -pub fn aya::programs::trace_point::TracePointError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::trace_point::TracePointError where T: core::marker::Sized -pub fn aya::programs::trace_point::TracePointError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::trace_point::TracePointError where T: core::marker::Sized -pub fn aya::programs::trace_point::TracePointError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::trace_point::TracePointError -pub fn aya::programs::trace_point::TracePointError::from(t: T) -> T -pub enum aya::programs::UProbeError -pub aya::programs::UProbeError::FileError -pub aya::programs::UProbeError::FileError::filename: std::path::PathBuf -pub aya::programs::UProbeError::FileError::io_error: std::io::error::Error -pub aya::programs::UProbeError::InvalidLdSoCache -pub aya::programs::UProbeError::InvalidLdSoCache::io_error: &'static std::io::error::Error -pub aya::programs::UProbeError::InvalidTarget -pub aya::programs::UProbeError::InvalidTarget::path: std::path::PathBuf -pub aya::programs::UProbeError::SymbolError -pub aya::programs::UProbeError::SymbolError::error: alloc::boxed::Box<(dyn core::error::Error + core::marker::Send + core::marker::Sync)> -pub aya::programs::UProbeError::SymbolError::symbol: alloc::string::String -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::uprobe::UProbeError) -> Self -impl core::error::Error for aya::programs::uprobe::UProbeError -pub fn aya::programs::uprobe::UProbeError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::uprobe::UProbeError -pub fn aya::programs::uprobe::UProbeError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::uprobe::UProbeError -pub fn aya::programs::uprobe::UProbeError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::uprobe::UProbeError -impl core::marker::Send for aya::programs::uprobe::UProbeError -impl core::marker::Sync for aya::programs::uprobe::UProbeError -impl core::marker::Unpin for aya::programs::uprobe::UProbeError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::uprobe::UProbeError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::uprobe::UProbeError -impl core::convert::Into for aya::programs::uprobe::UProbeError where U: core::convert::From -pub fn aya::programs::uprobe::UProbeError::into(self) -> U -impl core::convert::TryFrom for aya::programs::uprobe::UProbeError where U: core::convert::Into -pub type aya::programs::uprobe::UProbeError::Error = core::convert::Infallible -pub fn aya::programs::uprobe::UProbeError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::uprobe::UProbeError where U: core::convert::TryFrom -pub type aya::programs::uprobe::UProbeError::Error = >::Error -pub fn aya::programs::uprobe::UProbeError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::uprobe::UProbeError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::uprobe::UProbeError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::uprobe::UProbeError where T: 'static + core::marker::Sized -pub fn aya::programs::uprobe::UProbeError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::uprobe::UProbeError where T: core::marker::Sized -pub fn aya::programs::uprobe::UProbeError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::uprobe::UProbeError where T: core::marker::Sized -pub fn aya::programs::uprobe::UProbeError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::uprobe::UProbeError -pub fn aya::programs::uprobe::UProbeError::from(t: T) -> T -pub enum aya::programs::XdpError -pub aya::programs::XdpError::NetlinkError -pub aya::programs::XdpError::NetlinkError::io_error: std::io::error::Error -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::programs::xdp::XdpError) -> Self -impl core::error::Error for aya::programs::xdp::XdpError -pub fn aya::programs::xdp::XdpError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::programs::xdp::XdpError -pub fn aya::programs::xdp::XdpError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::programs::xdp::XdpError -pub fn aya::programs::xdp::XdpError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::programs::xdp::XdpError -impl core::marker::Send for aya::programs::xdp::XdpError -impl core::marker::Sync for aya::programs::xdp::XdpError -impl core::marker::Unpin for aya::programs::xdp::XdpError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::programs::xdp::XdpError -impl !core::panic::unwind_safe::UnwindSafe for aya::programs::xdp::XdpError -impl core::convert::Into for aya::programs::xdp::XdpError where U: core::convert::From -pub fn aya::programs::xdp::XdpError::into(self) -> U -impl core::convert::TryFrom for aya::programs::xdp::XdpError where U: core::convert::Into -pub type aya::programs::xdp::XdpError::Error = core::convert::Infallible -pub fn aya::programs::xdp::XdpError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::programs::xdp::XdpError where U: core::convert::TryFrom -pub type aya::programs::xdp::XdpError::Error = >::Error -pub fn aya::programs::xdp::XdpError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::programs::xdp::XdpError where T: core::fmt::Display + core::marker::Sized -pub fn aya::programs::xdp::XdpError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::programs::xdp::XdpError where T: 'static + core::marker::Sized -pub fn aya::programs::xdp::XdpError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::programs::xdp::XdpError where T: core::marker::Sized -pub fn aya::programs::xdp::XdpError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::programs::xdp::XdpError where T: core::marker::Sized -pub fn aya::programs::xdp::XdpError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::programs::xdp::XdpError -pub fn aya::programs::xdp::XdpError::from(t: T) -> T pub struct aya::programs::BtfTracePoint impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::attach(&mut self) -> core::result::Result -pub fn aya::programs::tp_btf::BtfTracePoint::detach(&mut self, link_id: aya::programs::tp_btf::BtfTracePointLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::tp_btf::BtfTracePoint::load(&mut self, tracepoint: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::tp_btf::BtfTracePoint::take_link(&mut self, link_id: aya::programs::tp_btf::BtfTracePointLinkId) -> core::result::Result +pub fn aya::programs::tp_btf::BtfTracePoint::attach(&mut self) -> core::result::Result +pub fn aya::programs::tp_btf::BtfTracePoint::detach(&mut self, link_id: aya::programs::tp_btf::BtfTracePointLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::tp_btf::BtfTracePoint::load(&mut self, tracepoint: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePoint::take_link(&mut self, link_id: aya::programs::tp_btf::BtfTracePointLinkId) -> core::result::Result impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::tp_btf::BtfTracePoint::from_pin>(path: P) -> core::result::Result impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::info(&self) -> core::result::Result +pub fn aya::programs::tp_btf::BtfTracePoint::info(&self) -> core::result::Result impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::tp_btf::BtfTracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::tp_btf::BtfTracePoint::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::tp_btf::BtfTracePoint -pub fn aya::programs::tp_btf::BtfTracePoint::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePoint::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::tp_btf::BtfTracePoint pub fn aya::programs::tp_btf::BtfTracePoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::tp_btf::BtfTracePoint pub fn aya::programs::tp_btf::BtfTracePoint::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::tp_btf::BtfTracePoint -pub type &'a aya::programs::tp_btf::BtfTracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tp_btf::BtfTracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::tp_btf::BtfTracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tp_btf::BtfTracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::tp_btf::BtfTracePoint -pub type &'a mut aya::programs::tp_btf::BtfTracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tp_btf::BtfTracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::tp_btf::BtfTracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::tp_btf::BtfTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tp_btf::BtfTracePoint, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::tp_btf::BtfTracePoint impl core::marker::Send for aya::programs::tp_btf::BtfTracePoint impl core::marker::Sync for aya::programs::tp_btf::BtfTracePoint @@ -7507,32 +6969,32 @@ impl core::convert::From for aya::programs::tp_btf::BtfTracePoint pub fn aya::programs::tp_btf::BtfTracePoint::from(t: T) -> T pub struct aya::programs::CgroupDevice impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_device::CgroupDevice::detach(&mut self, link_id: aya::programs::cgroup_device::CgroupDeviceLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_device::CgroupDevice::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_device::CgroupDevice::query(target_fd: T) -> core::result::Result, aya::programs::ProgramError> -pub fn aya::programs::cgroup_device::CgroupDevice::take_link(&mut self, link_id: aya::programs::cgroup_device::CgroupDeviceLinkId) -> core::result::Result +pub fn aya::programs::cgroup_device::CgroupDevice::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_device::CgroupDevice::detach(&mut self, link_id: aya::programs::cgroup_device::CgroupDeviceLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_device::CgroupDevice::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDevice::query(target_fd: T) -> core::result::Result, aya::errors::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDevice::take_link(&mut self, link_id: aya::programs::cgroup_device::CgroupDeviceLinkId) -> core::result::Result impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDevice::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::cgroup_device::CgroupDevice::from_pin>(path: P) -> core::result::Result impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_device::CgroupDevice::info(&self) -> core::result::Result impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_device::CgroupDevice::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_device::CgroupDevice::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_device::CgroupDevice -pub fn aya::programs::cgroup_device::CgroupDevice::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDevice::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_device::CgroupDevice pub fn aya::programs::cgroup_device::CgroupDevice::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_device::CgroupDevice pub fn aya::programs::cgroup_device::CgroupDevice::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_device::CgroupDevice -pub type &'a aya::programs::cgroup_device::CgroupDevice::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_device::CgroupDevice, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_device::CgroupDevice::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_device::CgroupDevice, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_device::CgroupDevice -pub type &'a mut aya::programs::cgroup_device::CgroupDevice::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_device::CgroupDevice, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_device::CgroupDevice::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_device::CgroupDevice::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_device::CgroupDevice, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_device::CgroupDevice impl core::marker::Send for aya::programs::cgroup_device::CgroupDevice impl core::marker::Sync for aya::programs::cgroup_device::CgroupDevice @@ -7557,31 +7019,31 @@ impl core::convert::From for aya::programs::cgroup_device::CgroupDevice pub fn aya::programs::cgroup_device::CgroupDevice::from(t: T) -> T pub struct aya::programs::CgroupSkb impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::attach(&mut self, cgroup: T, attach_type: aya::programs::cgroup_skb::CgroupSkbAttachType, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_skb::CgroupSkb::detach(&mut self, link_id: aya::programs::cgroup_skb::CgroupSkbLinkId) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkb::attach(&mut self, cgroup: T, attach_type: aya::programs::cgroup_skb::CgroupSkbAttachType, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_skb::CgroupSkb::detach(&mut self, link_id: aya::programs::cgroup_skb::CgroupSkbLinkId) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_skb::CgroupSkb::expected_attach_type(&self) -> &core::option::Option -pub fn aya::programs::cgroup_skb::CgroupSkb::from_pin>(path: P, expected_attach_type: aya::programs::cgroup_skb::CgroupSkbAttachType) -> core::result::Result -pub fn aya::programs::cgroup_skb::CgroupSkb::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_skb::CgroupSkb::take_link(&mut self, link_id: aya::programs::cgroup_skb::CgroupSkbLinkId) -> core::result::Result +pub fn aya::programs::cgroup_skb::CgroupSkb::from_pin>(path: P, expected_attach_type: aya::programs::cgroup_skb::CgroupSkbAttachType) -> core::result::Result +pub fn aya::programs::cgroup_skb::CgroupSkb::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkb::take_link(&mut self, link_id: aya::programs::cgroup_skb::CgroupSkbLinkId) -> core::result::Result impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkb::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_skb::CgroupSkb::info(&self) -> core::result::Result impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_skb::CgroupSkb::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_skb::CgroupSkb::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_skb::CgroupSkb -pub fn aya::programs::cgroup_skb::CgroupSkb::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkb::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_skb::CgroupSkb pub fn aya::programs::cgroup_skb::CgroupSkb::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_skb::CgroupSkb pub fn aya::programs::cgroup_skb::CgroupSkb::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_skb::CgroupSkb -pub type &'a aya::programs::cgroup_skb::CgroupSkb::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_skb::CgroupSkb, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_skb::CgroupSkb::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_skb::CgroupSkb, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_skb::CgroupSkb -pub type &'a mut aya::programs::cgroup_skb::CgroupSkb::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_skb::CgroupSkb, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_skb::CgroupSkb::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_skb::CgroupSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_skb::CgroupSkb, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_skb::CgroupSkb impl core::marker::Send for aya::programs::cgroup_skb::CgroupSkb impl core::marker::Sync for aya::programs::cgroup_skb::CgroupSkb @@ -7606,30 +7068,30 @@ impl core::convert::From for aya::programs::cgroup_skb::CgroupSkb pub fn aya::programs::cgroup_skb::CgroupSkb::from(t: T) -> T pub struct aya::programs::CgroupSock impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_sock::CgroupSock::detach(&mut self, link_id: aya::programs::cgroup_sock::CgroupSockLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sock::CgroupSock::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sock::CgroupSockAttachType) -> core::result::Result -pub fn aya::programs::cgroup_sock::CgroupSock::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sock::CgroupSock::take_link(&mut self, link_id: aya::programs::cgroup_sock::CgroupSockLinkId) -> core::result::Result +pub fn aya::programs::cgroup_sock::CgroupSock::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_sock::CgroupSock::detach(&mut self, link_id: aya::programs::cgroup_sock::CgroupSockLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_sock::CgroupSock::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sock::CgroupSockAttachType) -> core::result::Result +pub fn aya::programs::cgroup_sock::CgroupSock::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSock::take_link(&mut self, link_id: aya::programs::cgroup_sock::CgroupSockLinkId) -> core::result::Result impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSock::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_sock::CgroupSock::info(&self) -> core::result::Result impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_sock::CgroupSock::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_sock::CgroupSock::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_sock::CgroupSock -pub fn aya::programs::cgroup_sock::CgroupSock::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSock::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_sock::CgroupSock pub fn aya::programs::cgroup_sock::CgroupSock::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_sock::CgroupSock pub fn aya::programs::cgroup_sock::CgroupSock::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sock::CgroupSock -pub type &'a aya::programs::cgroup_sock::CgroupSock::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock::CgroupSock, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sock::CgroupSock::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock::CgroupSock, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sock::CgroupSock -pub type &'a mut aya::programs::cgroup_sock::CgroupSock::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock::CgroupSock, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sock::CgroupSock::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sock::CgroupSock::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock::CgroupSock, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_sock::CgroupSock impl core::marker::Send for aya::programs::cgroup_sock::CgroupSock impl core::marker::Sync for aya::programs::cgroup_sock::CgroupSock @@ -7654,30 +7116,30 @@ impl core::convert::From for aya::programs::cgroup_sock::CgroupSock pub fn aya::programs::cgroup_sock::CgroupSock::from(t: T) -> T pub struct aya::programs::CgroupSockAddr impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::detach(&mut self, link_id: aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sock_addr::CgroupSockAddrAttachType) -> core::result::Result -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::take_link(&mut self, link_id: aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId) -> core::result::Result +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::detach(&mut self, link_id: aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sock_addr::CgroupSockAddrAttachType) -> core::result::Result +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::take_link(&mut self, link_id: aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId) -> core::result::Result impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::info(&self) -> core::result::Result impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_sock_addr::CgroupSockAddr -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_sock_addr::CgroupSockAddr pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_sock_addr::CgroupSockAddr pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sock_addr::CgroupSockAddr -pub type &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr -pub type &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sock_addr::CgroupSockAddr, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_sock_addr::CgroupSockAddr impl core::marker::Send for aya::programs::cgroup_sock_addr::CgroupSockAddr impl core::marker::Sync for aya::programs::cgroup_sock_addr::CgroupSockAddr @@ -7702,30 +7164,30 @@ impl core::convert::From for aya::programs::cgroup_sock_addr::CgroupSockAd pub fn aya::programs::cgroup_sock_addr::CgroupSockAddr::from(t: T) -> T pub struct aya::programs::CgroupSockopt impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::detach(&mut self, link_id: aya::programs::cgroup_sockopt::CgroupSockoptLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sockopt::CgroupSockoptAttachType) -> core::result::Result -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::take_link(&mut self, link_id: aya::programs::cgroup_sockopt::CgroupSockoptLinkId) -> core::result::Result +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::detach(&mut self, link_id: aya::programs::cgroup_sockopt::CgroupSockoptLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::from_pin>(path: P, attach_type: aya_obj::programs::cgroup_sockopt::CgroupSockoptAttachType) -> core::result::Result +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::take_link(&mut self, link_id: aya::programs::cgroup_sockopt::CgroupSockoptLinkId) -> core::result::Result impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::info(&self) -> core::result::Result impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_sockopt::CgroupSockopt::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_sockopt::CgroupSockopt -pub fn aya::programs::cgroup_sockopt::CgroupSockopt::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockopt::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_sockopt::CgroupSockopt pub fn aya::programs::cgroup_sockopt::CgroupSockopt::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_sockopt::CgroupSockopt pub fn aya::programs::cgroup_sockopt::CgroupSockopt::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sockopt::CgroupSockopt -pub type &'a aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sockopt::CgroupSockopt, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sockopt::CgroupSockopt, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sockopt::CgroupSockopt -pub type &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sockopt::CgroupSockopt, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sockopt::CgroupSockopt::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sockopt::CgroupSockopt, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_sockopt::CgroupSockopt impl core::marker::Send for aya::programs::cgroup_sockopt::CgroupSockopt impl core::marker::Sync for aya::programs::cgroup_sockopt::CgroupSockopt @@ -7750,31 +7212,31 @@ impl core::convert::From for aya::programs::cgroup_sockopt::CgroupSockopt pub fn aya::programs::cgroup_sockopt::CgroupSockopt::from(t: T) -> T pub struct aya::programs::CgroupSysctl impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::detach(&mut self, link_id: aya::programs::cgroup_sysctl::CgroupSysctlLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::take_link(&mut self, link_id: aya::programs::cgroup_sysctl::CgroupSysctlLinkId) -> core::result::Result +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::detach(&mut self, link_id: aya::programs::cgroup_sysctl::CgroupSysctlLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::take_link(&mut self, link_id: aya::programs::cgroup_sysctl::CgroupSysctlLinkId) -> core::result::Result impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::from_pin>(path: P) -> core::result::Result impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::info(&self) -> core::result::Result +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::info(&self) -> core::result::Result impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::cgroup_sysctl::CgroupSysctl::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::cgroup_sysctl::CgroupSysctl -pub fn aya::programs::cgroup_sysctl::CgroupSysctl::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctl::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::cgroup_sysctl::CgroupSysctl pub fn aya::programs::cgroup_sysctl::CgroupSysctl::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::cgroup_sysctl::CgroupSysctl pub fn aya::programs::cgroup_sysctl::CgroupSysctl::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::cgroup_sysctl::CgroupSysctl -pub type &'a aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::programs::ProgramError -pub fn &'a aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sysctl::CgroupSysctl, aya::programs::ProgramError> +pub type &'a aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::errors::ProgramError +pub fn &'a aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::cgroup_sysctl::CgroupSysctl, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::cgroup_sysctl::CgroupSysctl -pub type &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sysctl::CgroupSysctl, aya::programs::ProgramError> +pub type &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::cgroup_sysctl::CgroupSysctl::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::cgroup_sysctl::CgroupSysctl, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::cgroup_sysctl::CgroupSysctl impl core::marker::Send for aya::programs::cgroup_sysctl::CgroupSysctl impl core::marker::Sync for aya::programs::cgroup_sysctl::CgroupSysctl @@ -7799,32 +7261,32 @@ impl core::convert::From for aya::programs::cgroup_sysctl::CgroupSysctl pub fn aya::programs::cgroup_sysctl::CgroupSysctl::from(t: T) -> T pub struct aya::programs::Extension impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::attach(&mut self) -> core::result::Result -pub fn aya::programs::extension::Extension::attach_to_program(&mut self, program: &aya::programs::ProgramFd, func_name: &str) -> core::result::Result -pub fn aya::programs::extension::Extension::detach(&mut self, link_id: aya::programs::extension::ExtensionLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::extension::Extension::load(&mut self, program: aya::programs::ProgramFd, func_name: &str) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::extension::Extension::take_link(&mut self, link_id: aya::programs::extension::ExtensionLinkId) -> core::result::Result +pub fn aya::programs::extension::Extension::attach(&mut self) -> core::result::Result +pub fn aya::programs::extension::Extension::attach_to_program(&mut self, program: &aya::programs::ProgramFd, func_name: &str) -> core::result::Result +pub fn aya::programs::extension::Extension::detach(&mut self, link_id: aya::programs::extension::ExtensionLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::extension::Extension::load(&mut self, program: aya::programs::ProgramFd, func_name: &str) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::extension::Extension::take_link(&mut self, link_id: aya::programs::extension::ExtensionLinkId) -> core::result::Result impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::extension::Extension::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::extension::Extension::from_pin>(path: P) -> core::result::Result impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::info(&self) -> core::result::Result +pub fn aya::programs::extension::Extension::info(&self) -> core::result::Result impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::extension::Extension::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::extension::Extension::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::extension::Extension -pub fn aya::programs::extension::Extension::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::extension::Extension::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::extension::Extension pub fn aya::programs::extension::Extension::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::extension::Extension pub fn aya::programs::extension::Extension::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::extension::Extension -pub type &'a aya::programs::extension::Extension::Error = aya::programs::ProgramError -pub fn &'a aya::programs::extension::Extension::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::extension::Extension, aya::programs::ProgramError> +pub type &'a aya::programs::extension::Extension::Error = aya::errors::ProgramError +pub fn &'a aya::programs::extension::Extension::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::extension::Extension, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::extension::Extension -pub type &'a mut aya::programs::extension::Extension::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::extension::Extension::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::extension::Extension, aya::programs::ProgramError> +pub type &'a mut aya::programs::extension::Extension::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::extension::Extension::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::extension::Extension, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::extension::Extension impl core::marker::Send for aya::programs::extension::Extension impl core::marker::Sync for aya::programs::extension::Extension @@ -7849,31 +7311,31 @@ impl core::convert::From for aya::programs::extension::Extension pub fn aya::programs::extension::Extension::from(t: T) -> T pub struct aya::programs::FEntry impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::attach(&mut self) -> core::result::Result -pub fn aya::programs::fentry::FEntry::detach(&mut self, link_id: aya::programs::fentry::FEntryLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::fentry::FEntry::load(&mut self, fn_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::fentry::FEntry::take_link(&mut self, link_id: aya::programs::fentry::FEntryLinkId) -> core::result::Result +pub fn aya::programs::fentry::FEntry::attach(&mut self) -> core::result::Result +pub fn aya::programs::fentry::FEntry::detach(&mut self, link_id: aya::programs::fentry::FEntryLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::fentry::FEntry::load(&mut self, fn_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::fentry::FEntry::take_link(&mut self, link_id: aya::programs::fentry::FEntryLinkId) -> core::result::Result impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::fentry::FEntry::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::fentry::FEntry::from_pin>(path: P) -> core::result::Result impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::info(&self) -> core::result::Result +pub fn aya::programs::fentry::FEntry::info(&self) -> core::result::Result impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::fentry::FEntry::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::fentry::FEntry::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::fentry::FEntry -pub fn aya::programs::fentry::FEntry::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fentry::FEntry::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::fentry::FEntry pub fn aya::programs::fentry::FEntry::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::fentry::FEntry pub fn aya::programs::fentry::FEntry::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::fentry::FEntry -pub type &'a aya::programs::fentry::FEntry::Error = aya::programs::ProgramError -pub fn &'a aya::programs::fentry::FEntry::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fentry::FEntry, aya::programs::ProgramError> +pub type &'a aya::programs::fentry::FEntry::Error = aya::errors::ProgramError +pub fn &'a aya::programs::fentry::FEntry::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fentry::FEntry, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::fentry::FEntry -pub type &'a mut aya::programs::fentry::FEntry::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::fentry::FEntry::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fentry::FEntry, aya::programs::ProgramError> +pub type &'a mut aya::programs::fentry::FEntry::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::fentry::FEntry::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fentry::FEntry, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::fentry::FEntry impl core::marker::Send for aya::programs::fentry::FEntry impl core::marker::Sync for aya::programs::fentry::FEntry @@ -7898,31 +7360,31 @@ impl core::convert::From for aya::programs::fentry::FEntry pub fn aya::programs::fentry::FEntry::from(t: T) -> T pub struct aya::programs::FExit impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::attach(&mut self) -> core::result::Result -pub fn aya::programs::fexit::FExit::detach(&mut self, link_id: aya::programs::fexit::FExitLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::fexit::FExit::load(&mut self, fn_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::fexit::FExit::take_link(&mut self, link_id: aya::programs::fexit::FExitLinkId) -> core::result::Result +pub fn aya::programs::fexit::FExit::attach(&mut self) -> core::result::Result +pub fn aya::programs::fexit::FExit::detach(&mut self, link_id: aya::programs::fexit::FExitLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::fexit::FExit::load(&mut self, fn_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::fexit::FExit::take_link(&mut self, link_id: aya::programs::fexit::FExitLinkId) -> core::result::Result impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::fexit::FExit::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::fexit::FExit::from_pin>(path: P) -> core::result::Result impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::info(&self) -> core::result::Result +pub fn aya::programs::fexit::FExit::info(&self) -> core::result::Result impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::fexit::FExit::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::fexit::FExit::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::fexit::FExit -pub fn aya::programs::fexit::FExit::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fexit::FExit::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::fexit::FExit pub fn aya::programs::fexit::FExit::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::fexit::FExit pub fn aya::programs::fexit::FExit::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::fexit::FExit -pub type &'a aya::programs::fexit::FExit::Error = aya::programs::ProgramError -pub fn &'a aya::programs::fexit::FExit::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fexit::FExit, aya::programs::ProgramError> +pub type &'a aya::programs::fexit::FExit::Error = aya::errors::ProgramError +pub fn &'a aya::programs::fexit::FExit::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::fexit::FExit, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::fexit::FExit -pub type &'a mut aya::programs::fexit::FExit::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::fexit::FExit::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fexit::FExit, aya::programs::ProgramError> +pub type &'a mut aya::programs::fexit::FExit::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::fexit::FExit::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::fexit::FExit, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::fexit::FExit impl core::marker::Send for aya::programs::fexit::FExit impl core::marker::Sync for aya::programs::fexit::FExit @@ -7947,31 +7409,31 @@ impl core::convert::From for aya::programs::fexit::FExit pub fn aya::programs::fexit::FExit::from(t: T) -> T pub struct aya::programs::KProbe impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::attach>(&mut self, fn_name: T, offset: u64) -> core::result::Result -pub fn aya::programs::kprobe::KProbe::detach(&mut self, link_id: aya::programs::kprobe::KProbeLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::kprobe::KProbe::from_pin>(path: P, kind: aya::programs::ProbeKind) -> core::result::Result +pub fn aya::programs::kprobe::KProbe::attach>(&mut self, fn_name: T, offset: u64) -> core::result::Result +pub fn aya::programs::kprobe::KProbe::detach(&mut self, link_id: aya::programs::kprobe::KProbeLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::kprobe::KProbe::from_pin>(path: P, kind: aya::programs::ProbeKind) -> core::result::Result pub fn aya::programs::kprobe::KProbe::kind(&self) -> aya::programs::ProbeKind -pub fn aya::programs::kprobe::KProbe::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::kprobe::KProbe::take_link(&mut self, link_id: aya::programs::kprobe::KProbeLinkId) -> core::result::Result +pub fn aya::programs::kprobe::KProbe::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::kprobe::KProbe::take_link(&mut self, link_id: aya::programs::kprobe::KProbeLinkId) -> core::result::Result impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::kprobe::KProbe::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::info(&self) -> core::result::Result +pub fn aya::programs::kprobe::KProbe::info(&self) -> core::result::Result impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::kprobe::KProbe::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::kprobe::KProbe::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::kprobe::KProbe -pub fn aya::programs::kprobe::KProbe::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::kprobe::KProbe::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::kprobe::KProbe pub fn aya::programs::kprobe::KProbe::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::kprobe::KProbe pub fn aya::programs::kprobe::KProbe::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::kprobe::KProbe -pub type &'a aya::programs::kprobe::KProbe::Error = aya::programs::ProgramError -pub fn &'a aya::programs::kprobe::KProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::kprobe::KProbe, aya::programs::ProgramError> +pub type &'a aya::programs::kprobe::KProbe::Error = aya::errors::ProgramError +pub fn &'a aya::programs::kprobe::KProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::kprobe::KProbe, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::kprobe::KProbe -pub type &'a mut aya::programs::kprobe::KProbe::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::kprobe::KProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::kprobe::KProbe, aya::programs::ProgramError> +pub type &'a mut aya::programs::kprobe::KProbe::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::kprobe::KProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::kprobe::KProbe, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::kprobe::KProbe impl core::marker::Send for aya::programs::kprobe::KProbe impl core::marker::Sync for aya::programs::kprobe::KProbe @@ -7996,11 +7458,11 @@ impl core::convert::From for aya::programs::kprobe::KProbe pub fn aya::programs::kprobe::KProbe::from(t: T) -> T pub struct aya::programs::LinkOrder impl aya::programs::links::LinkOrder -pub fn aya::programs::links::LinkOrder::after_link(link: &L) -> core::result::Result -pub fn aya::programs::links::LinkOrder::after_program(program: &P) -> core::result::Result +pub fn aya::programs::links::LinkOrder::after_link(link: &L) -> core::result::Result +pub fn aya::programs::links::LinkOrder::after_program(program: &P) -> core::result::Result pub fn aya::programs::links::LinkOrder::after_program_id(id: aya::programs::ProgramId) -> Self -pub fn aya::programs::links::LinkOrder::before_link(link: &L) -> core::result::Result -pub fn aya::programs::links::LinkOrder::before_program(program: &P) -> core::result::Result +pub fn aya::programs::links::LinkOrder::before_link(link: &L) -> core::result::Result +pub fn aya::programs::links::LinkOrder::before_program(program: &P) -> core::result::Result pub fn aya::programs::links::LinkOrder::before_program_id(id: aya::programs::ProgramId) -> Self pub fn aya::programs::links::LinkOrder::first() -> Self pub fn aya::programs::links::LinkOrder::last() -> Self @@ -8032,32 +7494,32 @@ impl core::convert::From for aya::programs::links::LinkOrder pub fn aya::programs::links::LinkOrder::from(t: T) -> T pub struct aya::programs::LircMode2 impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::attach(&mut self, lircdev: T) -> core::result::Result -pub fn aya::programs::lirc_mode2::LircMode2::detach(&mut self, link_id: aya::programs::lirc_mode2::LircLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::lirc_mode2::LircMode2::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::lirc_mode2::LircMode2::query(target_fd: T) -> core::result::Result, aya::programs::ProgramError> -pub fn aya::programs::lirc_mode2::LircMode2::take_link(&mut self, link_id: aya::programs::lirc_mode2::LircLinkId) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircMode2::attach(&mut self, lircdev: T) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircMode2::detach(&mut self, link_id: aya::programs::lirc_mode2::LircLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::lirc_mode2::LircMode2::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::lirc_mode2::LircMode2::query(target_fd: T) -> core::result::Result, aya::errors::ProgramError> +pub fn aya::programs::lirc_mode2::LircMode2::take_link(&mut self, link_id: aya::programs::lirc_mode2::LircLinkId) -> core::result::Result impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::lirc_mode2::LircMode2::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircMode2::from_pin>(path: P) -> core::result::Result impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::info(&self) -> core::result::Result +pub fn aya::programs::lirc_mode2::LircMode2::info(&self) -> core::result::Result impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::lirc_mode2::LircMode2::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::lirc_mode2::LircMode2::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::lirc_mode2::LircMode2 -pub fn aya::programs::lirc_mode2::LircMode2::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lirc_mode2::LircMode2::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::lirc_mode2::LircMode2 pub fn aya::programs::lirc_mode2::LircMode2::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::lirc_mode2::LircMode2 pub fn aya::programs::lirc_mode2::LircMode2::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::lirc_mode2::LircMode2 -pub type &'a aya::programs::lirc_mode2::LircMode2::Error = aya::programs::ProgramError -pub fn &'a aya::programs::lirc_mode2::LircMode2::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lirc_mode2::LircMode2, aya::programs::ProgramError> +pub type &'a aya::programs::lirc_mode2::LircMode2::Error = aya::errors::ProgramError +pub fn &'a aya::programs::lirc_mode2::LircMode2::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lirc_mode2::LircMode2, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::lirc_mode2::LircMode2 -pub type &'a mut aya::programs::lirc_mode2::LircMode2::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::lirc_mode2::LircMode2::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lirc_mode2::LircMode2, aya::programs::ProgramError> +pub type &'a mut aya::programs::lirc_mode2::LircMode2::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::lirc_mode2::LircMode2::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lirc_mode2::LircMode2, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::lirc_mode2::LircMode2 impl core::marker::Send for aya::programs::lirc_mode2::LircMode2 impl core::marker::Sync for aya::programs::lirc_mode2::LircMode2 @@ -8082,31 +7544,31 @@ impl core::convert::From for aya::programs::lirc_mode2::LircMode2 pub fn aya::programs::lirc_mode2::LircMode2::from(t: T) -> T pub struct aya::programs::Lsm impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::attach(&mut self) -> core::result::Result -pub fn aya::programs::lsm::Lsm::detach(&mut self, link_id: aya::programs::lsm::LsmLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::lsm::Lsm::load(&mut self, lsm_hook_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::lsm::Lsm::take_link(&mut self, link_id: aya::programs::lsm::LsmLinkId) -> core::result::Result +pub fn aya::programs::lsm::Lsm::attach(&mut self) -> core::result::Result +pub fn aya::programs::lsm::Lsm::detach(&mut self, link_id: aya::programs::lsm::LsmLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::lsm::Lsm::load(&mut self, lsm_hook_name: &str, btf: &aya_obj::btf::btf::Btf) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::lsm::Lsm::take_link(&mut self, link_id: aya::programs::lsm::LsmLinkId) -> core::result::Result impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::lsm::Lsm::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::lsm::Lsm::from_pin>(path: P) -> core::result::Result impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::info(&self) -> core::result::Result +pub fn aya::programs::lsm::Lsm::info(&self) -> core::result::Result impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::lsm::Lsm::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::lsm::Lsm::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::lsm::Lsm -pub fn aya::programs::lsm::Lsm::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lsm::Lsm::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::lsm::Lsm pub fn aya::programs::lsm::Lsm::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::lsm::Lsm pub fn aya::programs::lsm::Lsm::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::lsm::Lsm -pub type &'a aya::programs::lsm::Lsm::Error = aya::programs::ProgramError -pub fn &'a aya::programs::lsm::Lsm::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lsm::Lsm, aya::programs::ProgramError> +pub type &'a aya::programs::lsm::Lsm::Error = aya::errors::ProgramError +pub fn &'a aya::programs::lsm::Lsm::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::lsm::Lsm, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::lsm::Lsm -pub type &'a mut aya::programs::lsm::Lsm::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::lsm::Lsm::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lsm::Lsm, aya::programs::ProgramError> +pub type &'a mut aya::programs::lsm::Lsm::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::lsm::Lsm::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::lsm::Lsm, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::lsm::Lsm impl core::marker::Send for aya::programs::lsm::Lsm impl core::marker::Sync for aya::programs::lsm::Lsm @@ -8131,31 +7593,31 @@ impl core::convert::From for aya::programs::lsm::Lsm pub fn aya::programs::lsm::Lsm::from(t: T) -> T pub struct aya::programs::PerfEvent impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::attach(&mut self, perf_type: aya::programs::perf_event::PerfTypeId, config: u64, scope: aya::programs::perf_event::PerfEventScope, sample_policy: aya::programs::perf_event::SamplePolicy, inherit: bool) -> core::result::Result -pub fn aya::programs::perf_event::PerfEvent::detach(&mut self, link_id: aya::programs::perf_event::PerfEventLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::perf_event::PerfEvent::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::perf_event::PerfEvent::take_link(&mut self, link_id: aya::programs::perf_event::PerfEventLinkId) -> core::result::Result +pub fn aya::programs::perf_event::PerfEvent::attach(&mut self, perf_type: aya::programs::perf_event::PerfTypeId, config: u64, scope: aya::programs::perf_event::PerfEventScope, sample_policy: aya::programs::perf_event::SamplePolicy, inherit: bool) -> core::result::Result +pub fn aya::programs::perf_event::PerfEvent::detach(&mut self, link_id: aya::programs::perf_event::PerfEventLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::perf_event::PerfEvent::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::perf_event::PerfEvent::take_link(&mut self, link_id: aya::programs::perf_event::PerfEventLinkId) -> core::result::Result impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::perf_event::PerfEvent::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::perf_event::PerfEvent::from_pin>(path: P) -> core::result::Result impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::info(&self) -> core::result::Result +pub fn aya::programs::perf_event::PerfEvent::info(&self) -> core::result::Result impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::perf_event::PerfEvent::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::perf_event::PerfEvent::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::perf_event::PerfEvent -pub fn aya::programs::perf_event::PerfEvent::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::perf_event::PerfEvent::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::perf_event::PerfEvent pub fn aya::programs::perf_event::PerfEvent::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::perf_event::PerfEvent pub fn aya::programs::perf_event::PerfEvent::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::perf_event::PerfEvent -pub type &'a aya::programs::perf_event::PerfEvent::Error = aya::programs::ProgramError -pub fn &'a aya::programs::perf_event::PerfEvent::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::perf_event::PerfEvent, aya::programs::ProgramError> +pub type &'a aya::programs::perf_event::PerfEvent::Error = aya::errors::ProgramError +pub fn &'a aya::programs::perf_event::PerfEvent::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::perf_event::PerfEvent, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::perf_event::PerfEvent -pub type &'a mut aya::programs::perf_event::PerfEvent::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::perf_event::PerfEvent::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::perf_event::PerfEvent, aya::programs::ProgramError> +pub type &'a mut aya::programs::perf_event::PerfEvent::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::perf_event::PerfEvent::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::perf_event::PerfEvent, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::perf_event::PerfEvent impl core::marker::Send for aya::programs::perf_event::PerfEvent impl core::marker::Sync for aya::programs::perf_event::PerfEvent @@ -8236,16 +7698,16 @@ pub struct aya::programs::ProgramInfo(_) impl aya::programs::ProgramInfo pub fn aya::programs::ProgramInfo::btf_id(&self) -> core::option::Option pub fn aya::programs::ProgramInfo::created_by_uid(&self) -> core::option::Option -pub fn aya::programs::ProgramInfo::fd(&self) -> core::result::Result -pub fn aya::programs::ProgramInfo::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::ProgramInfo::fd(&self) -> core::result::Result +pub fn aya::programs::ProgramInfo::from_pin>(path: P) -> core::result::Result pub fn aya::programs::ProgramInfo::gpl_compatible(&self) -> core::option::Option pub fn aya::programs::ProgramInfo::id(&self) -> u32 pub fn aya::programs::ProgramInfo::loaded_at(&self) -> core::option::Option -pub fn aya::programs::ProgramInfo::map_ids(&self) -> core::result::Result>, aya::programs::ProgramError> -pub fn aya::programs::ProgramInfo::memory_locked(&self) -> core::result::Result +pub fn aya::programs::ProgramInfo::map_ids(&self) -> core::result::Result>, aya::errors::ProgramError> +pub fn aya::programs::ProgramInfo::memory_locked(&self) -> core::result::Result pub fn aya::programs::ProgramInfo::name(&self) -> &[u8] pub fn aya::programs::ProgramInfo::name_as_str(&self) -> core::option::Option<&str> -pub fn aya::programs::ProgramInfo::program_type(&self) -> core::result::Result +pub fn aya::programs::ProgramInfo::program_type(&self) -> core::result::Result pub fn aya::programs::ProgramInfo::run_count(&self) -> u64 pub fn aya::programs::ProgramInfo::run_time(&self) -> core::time::Duration pub fn aya::programs::ProgramInfo::size_jitted(&self) -> u32 @@ -8278,31 +7740,31 @@ impl core::convert::From for aya::programs::ProgramInfo pub fn aya::programs::ProgramInfo::from(t: T) -> T pub struct aya::programs::RawTracePoint impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::attach(&mut self, tp_name: &str) -> core::result::Result -pub fn aya::programs::raw_trace_point::RawTracePoint::detach(&mut self, link_id: aya::programs::raw_trace_point::RawTracePointLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::raw_trace_point::RawTracePoint::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::raw_trace_point::RawTracePoint::take_link(&mut self, link_id: aya::programs::raw_trace_point::RawTracePointLinkId) -> core::result::Result +pub fn aya::programs::raw_trace_point::RawTracePoint::attach(&mut self, tp_name: &str) -> core::result::Result +pub fn aya::programs::raw_trace_point::RawTracePoint::detach(&mut self, link_id: aya::programs::raw_trace_point::RawTracePointLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::raw_trace_point::RawTracePoint::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePoint::take_link(&mut self, link_id: aya::programs::raw_trace_point::RawTracePointLinkId) -> core::result::Result impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::raw_trace_point::RawTracePoint::from_pin>(path: P) -> core::result::Result impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::info(&self) -> core::result::Result +pub fn aya::programs::raw_trace_point::RawTracePoint::info(&self) -> core::result::Result impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::raw_trace_point::RawTracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::raw_trace_point::RawTracePoint::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::raw_trace_point::RawTracePoint -pub fn aya::programs::raw_trace_point::RawTracePoint::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePoint::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::raw_trace_point::RawTracePoint pub fn aya::programs::raw_trace_point::RawTracePoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::raw_trace_point::RawTracePoint pub fn aya::programs::raw_trace_point::RawTracePoint::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::raw_trace_point::RawTracePoint -pub type &'a aya::programs::raw_trace_point::RawTracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::raw_trace_point::RawTracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::raw_trace_point::RawTracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::raw_trace_point::RawTracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::raw_trace_point::RawTracePoint -pub type &'a mut aya::programs::raw_trace_point::RawTracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::raw_trace_point::RawTracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::raw_trace_point::RawTracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::raw_trace_point::RawTracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::raw_trace_point::RawTracePoint, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::raw_trace_point::RawTracePoint impl core::marker::Send for aya::programs::raw_trace_point::RawTracePoint impl core::marker::Sync for aya::programs::raw_trace_point::RawTracePoint @@ -8327,35 +7789,35 @@ impl core::convert::From for aya::programs::raw_trace_point::RawTracePoint pub fn aya::programs::raw_trace_point::RawTracePoint::from(t: T) -> T pub struct aya::programs::SchedClassifier impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::attach(&mut self, interface: &str, attach_type: aya::programs::tc::TcAttachType) -> core::result::Result -pub fn aya::programs::tc::SchedClassifier::attach_to_link(&mut self, link: aya::programs::tc::SchedClassifierLink) -> core::result::Result -pub fn aya::programs::tc::SchedClassifier::attach_with_options(&mut self, interface: &str, attach_type: aya::programs::tc::TcAttachType, options: aya::programs::tc::TcAttachOptions) -> core::result::Result -pub fn aya::programs::tc::SchedClassifier::detach(&mut self, link_id: aya::programs::tc::SchedClassifierLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::tc::SchedClassifier::from_pin>(path: P) -> core::result::Result -pub fn aya::programs::tc::SchedClassifier::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::tc::SchedClassifier::query_tcx(interface: &str, attach_type: aya::programs::tc::TcAttachType) -> core::result::Result<(u64, alloc::vec::Vec), aya::programs::ProgramError> -pub fn aya::programs::tc::SchedClassifier::take_link(&mut self, link_id: aya::programs::tc::SchedClassifierLinkId) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::attach(&mut self, interface: &str, attach_type: aya::programs::tc::TcAttachType) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::attach_to_link(&mut self, link: aya::programs::tc::SchedClassifierLink) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::attach_with_options(&mut self, interface: &str, attach_type: aya::programs::tc::TcAttachType, options: aya::programs::tc::TcAttachOptions) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::detach(&mut self, link_id: aya::programs::tc::SchedClassifierLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::tc::SchedClassifier::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::tc::SchedClassifier::query_tcx(interface: &str, attach_type: aya::programs::tc::TcAttachType) -> core::result::Result<(u64, alloc::vec::Vec), aya::errors::LinkError> +pub fn aya::programs::tc::SchedClassifier::take_link(&mut self, link_id: aya::programs::tc::SchedClassifierLinkId) -> core::result::Result impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::info(&self) -> core::result::Result +pub fn aya::programs::tc::SchedClassifier::info(&self) -> core::result::Result impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::tc::SchedClassifier::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::tc::SchedClassifier::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifier::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl aya::programs::MultiProgram for aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result, aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result, aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::tc::SchedClassifier pub fn aya::programs::tc::SchedClassifier::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::tc::SchedClassifier pub fn aya::programs::tc::SchedClassifier::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::tc::SchedClassifier -pub type &'a aya::programs::tc::SchedClassifier::Error = aya::programs::ProgramError -pub fn &'a aya::programs::tc::SchedClassifier::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tc::SchedClassifier, aya::programs::ProgramError> +pub type &'a aya::programs::tc::SchedClassifier::Error = aya::errors::ProgramError +pub fn &'a aya::programs::tc::SchedClassifier::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::tc::SchedClassifier, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::tc::SchedClassifier -pub type &'a mut aya::programs::tc::SchedClassifier::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::tc::SchedClassifier::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tc::SchedClassifier, aya::programs::ProgramError> +pub type &'a mut aya::programs::tc::SchedClassifier::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::tc::SchedClassifier::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::tc::SchedClassifier, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::tc::SchedClassifier impl core::marker::Send for aya::programs::tc::SchedClassifier impl core::marker::Sync for aya::programs::tc::SchedClassifier @@ -8380,31 +7842,31 @@ impl core::convert::From for aya::programs::tc::SchedClassifier pub fn aya::programs::tc::SchedClassifier::from(t: T) -> T pub struct aya::programs::SkLookup impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::attach(&mut self, netns: T) -> core::result::Result -pub fn aya::programs::sk_lookup::SkLookup::detach(&mut self, link_id: aya::programs::sk_lookup::SkLookupLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_lookup::SkLookup::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_lookup::SkLookup::take_link(&mut self, link_id: aya::programs::sk_lookup::SkLookupLinkId) -> core::result::Result +pub fn aya::programs::sk_lookup::SkLookup::attach(&mut self, netns: T) -> core::result::Result +pub fn aya::programs::sk_lookup::SkLookup::detach(&mut self, link_id: aya::programs::sk_lookup::SkLookupLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::sk_lookup::SkLookup::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::sk_lookup::SkLookup::take_link(&mut self, link_id: aya::programs::sk_lookup::SkLookupLinkId) -> core::result::Result impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::sk_lookup::SkLookup::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::sk_lookup::SkLookup::from_pin>(path: P) -> core::result::Result impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::info(&self) -> core::result::Result +pub fn aya::programs::sk_lookup::SkLookup::info(&self) -> core::result::Result impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::sk_lookup::SkLookup::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::sk_lookup::SkLookup::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::sk_lookup::SkLookup -pub fn aya::programs::sk_lookup::SkLookup::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_lookup::SkLookup::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::sk_lookup::SkLookup pub fn aya::programs::sk_lookup::SkLookup::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::sk_lookup::SkLookup pub fn aya::programs::sk_lookup::SkLookup::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_lookup::SkLookup -pub type &'a aya::programs::sk_lookup::SkLookup::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_lookup::SkLookup::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_lookup::SkLookup, aya::programs::ProgramError> +pub type &'a aya::programs::sk_lookup::SkLookup::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_lookup::SkLookup::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_lookup::SkLookup, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_lookup::SkLookup -pub type &'a mut aya::programs::sk_lookup::SkLookup::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_lookup::SkLookup::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_lookup::SkLookup, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_lookup::SkLookup::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_lookup::SkLookup::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_lookup::SkLookup, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::sk_lookup::SkLookup impl core::marker::Send for aya::programs::sk_lookup::SkLookup impl core::marker::Sync for aya::programs::sk_lookup::SkLookup @@ -8429,31 +7891,31 @@ impl core::convert::From for aya::programs::sk_lookup::SkLookup pub fn aya::programs::sk_lookup::SkLookup::from(t: T) -> T pub struct aya::programs::SkMsg impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::attach(&mut self, map: &aya::maps::sock::SockMapFd) -> core::result::Result -pub fn aya::programs::sk_msg::SkMsg::detach(&mut self, link_id: aya::programs::sk_msg::SkMsgLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_msg::SkMsg::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_msg::SkMsg::take_link(&mut self, link_id: aya::programs::sk_msg::SkMsgLinkId) -> core::result::Result +pub fn aya::programs::sk_msg::SkMsg::attach(&mut self, map: &aya::maps::sock::SockMapFd) -> core::result::Result +pub fn aya::programs::sk_msg::SkMsg::detach(&mut self, link_id: aya::programs::sk_msg::SkMsgLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::sk_msg::SkMsg::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::sk_msg::SkMsg::take_link(&mut self, link_id: aya::programs::sk_msg::SkMsgLinkId) -> core::result::Result impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::sk_msg::SkMsg::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::sk_msg::SkMsg::from_pin>(path: P) -> core::result::Result impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::info(&self) -> core::result::Result +pub fn aya::programs::sk_msg::SkMsg::info(&self) -> core::result::Result impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::sk_msg::SkMsg::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::sk_msg::SkMsg::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::sk_msg::SkMsg -pub fn aya::programs::sk_msg::SkMsg::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_msg::SkMsg::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::sk_msg::SkMsg pub fn aya::programs::sk_msg::SkMsg::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::sk_msg::SkMsg pub fn aya::programs::sk_msg::SkMsg::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_msg::SkMsg -pub type &'a aya::programs::sk_msg::SkMsg::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_msg::SkMsg::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_msg::SkMsg, aya::programs::ProgramError> +pub type &'a aya::programs::sk_msg::SkMsg::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_msg::SkMsg::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_msg::SkMsg, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_msg::SkMsg -pub type &'a mut aya::programs::sk_msg::SkMsg::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_msg::SkMsg::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_msg::SkMsg, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_msg::SkMsg::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_msg::SkMsg::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_msg::SkMsg, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::sk_msg::SkMsg impl core::marker::Send for aya::programs::sk_msg::SkMsg impl core::marker::Sync for aya::programs::sk_msg::SkMsg @@ -8478,30 +7940,30 @@ impl core::convert::From for aya::programs::sk_msg::SkMsg pub fn aya::programs::sk_msg::SkMsg::from(t: T) -> T pub struct aya::programs::SkSkb impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::attach(&mut self, map: &aya::maps::sock::SockMapFd) -> core::result::Result -pub fn aya::programs::sk_skb::SkSkb::detach(&mut self, link_id: aya::programs::sk_skb::SkSkbLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_skb::SkSkb::from_pin>(path: P, kind: aya::programs::sk_skb::SkSkbKind) -> core::result::Result -pub fn aya::programs::sk_skb::SkSkb::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sk_skb::SkSkb::take_link(&mut self, link_id: aya::programs::sk_skb::SkSkbLinkId) -> core::result::Result +pub fn aya::programs::sk_skb::SkSkb::attach(&mut self, map: &aya::maps::sock::SockMapFd) -> core::result::Result +pub fn aya::programs::sk_skb::SkSkb::detach(&mut self, link_id: aya::programs::sk_skb::SkSkbLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::sk_skb::SkSkb::from_pin>(path: P, kind: aya::programs::sk_skb::SkSkbKind) -> core::result::Result +pub fn aya::programs::sk_skb::SkSkb::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::sk_skb::SkSkb::take_link(&mut self, link_id: aya::programs::sk_skb::SkSkbLinkId) -> core::result::Result impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::sk_skb::SkSkb::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::info(&self) -> core::result::Result +pub fn aya::programs::sk_skb::SkSkb::info(&self) -> core::result::Result impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::sk_skb::SkSkb::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::sk_skb::SkSkb::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::sk_skb::SkSkb -pub fn aya::programs::sk_skb::SkSkb::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_skb::SkSkb::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::sk_skb::SkSkb pub fn aya::programs::sk_skb::SkSkb::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::sk_skb::SkSkb pub fn aya::programs::sk_skb::SkSkb::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sk_skb::SkSkb -pub type &'a aya::programs::sk_skb::SkSkb::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sk_skb::SkSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_skb::SkSkb, aya::programs::ProgramError> +pub type &'a aya::programs::sk_skb::SkSkb::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sk_skb::SkSkb::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sk_skb::SkSkb, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sk_skb::SkSkb -pub type &'a mut aya::programs::sk_skb::SkSkb::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sk_skb::SkSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_skb::SkSkb, aya::programs::ProgramError> +pub type &'a mut aya::programs::sk_skb::SkSkb::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sk_skb::SkSkb::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sk_skb::SkSkb, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::sk_skb::SkSkb impl core::marker::Send for aya::programs::sk_skb::SkSkb impl core::marker::Sync for aya::programs::sk_skb::SkSkb @@ -8526,31 +7988,31 @@ impl core::convert::From for aya::programs::sk_skb::SkSkb pub fn aya::programs::sk_skb::SkSkb::from(t: T) -> T pub struct aya::programs::SockOps impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result -pub fn aya::programs::sock_ops::SockOps::detach(&mut self, link_id: aya::programs::sock_ops::SockOpsLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sock_ops::SockOps::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::sock_ops::SockOps::take_link(&mut self, link_id: aya::programs::sock_ops::SockOpsLinkId) -> core::result::Result +pub fn aya::programs::sock_ops::SockOps::attach(&mut self, cgroup: T, mode: aya::programs::links::CgroupAttachMode) -> core::result::Result +pub fn aya::programs::sock_ops::SockOps::detach(&mut self, link_id: aya::programs::sock_ops::SockOpsLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::sock_ops::SockOps::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::sock_ops::SockOps::take_link(&mut self, link_id: aya::programs::sock_ops::SockOpsLinkId) -> core::result::Result impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::sock_ops::SockOps::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::sock_ops::SockOps::from_pin>(path: P) -> core::result::Result impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::info(&self) -> core::result::Result +pub fn aya::programs::sock_ops::SockOps::info(&self) -> core::result::Result impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::sock_ops::SockOps::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::sock_ops::SockOps::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::sock_ops::SockOps -pub fn aya::programs::sock_ops::SockOps::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sock_ops::SockOps::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::sock_ops::SockOps pub fn aya::programs::sock_ops::SockOps::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::sock_ops::SockOps pub fn aya::programs::sock_ops::SockOps::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::sock_ops::SockOps -pub type &'a aya::programs::sock_ops::SockOps::Error = aya::programs::ProgramError -pub fn &'a aya::programs::sock_ops::SockOps::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sock_ops::SockOps, aya::programs::ProgramError> +pub type &'a aya::programs::sock_ops::SockOps::Error = aya::errors::ProgramError +pub fn &'a aya::programs::sock_ops::SockOps::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::sock_ops::SockOps, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::sock_ops::SockOps -pub type &'a mut aya::programs::sock_ops::SockOps::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::sock_ops::SockOps::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sock_ops::SockOps, aya::programs::ProgramError> +pub type &'a mut aya::programs::sock_ops::SockOps::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::sock_ops::SockOps::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::sock_ops::SockOps, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::sock_ops::SockOps impl core::marker::Send for aya::programs::sock_ops::SockOps impl core::marker::Sync for aya::programs::sock_ops::SockOps @@ -8575,31 +8037,31 @@ impl core::convert::From for aya::programs::sock_ops::SockOps pub fn aya::programs::sock_ops::SockOps::from(t: T) -> T pub struct aya::programs::SocketFilter impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::attach(&mut self, socket: T) -> core::result::Result -pub fn aya::programs::socket_filter::SocketFilter::detach(&mut self, link_id: aya::programs::socket_filter::SocketFilterLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::socket_filter::SocketFilter::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::socket_filter::SocketFilter::take_link(&mut self, link_id: aya::programs::socket_filter::SocketFilterLinkId) -> core::result::Result +pub fn aya::programs::socket_filter::SocketFilter::attach(&mut self, socket: T) -> core::result::Result +pub fn aya::programs::socket_filter::SocketFilter::detach(&mut self, link_id: aya::programs::socket_filter::SocketFilterLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::socket_filter::SocketFilter::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::socket_filter::SocketFilter::take_link(&mut self, link_id: aya::programs::socket_filter::SocketFilterLinkId) -> core::result::Result impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::socket_filter::SocketFilter::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::socket_filter::SocketFilter::from_pin>(path: P) -> core::result::Result impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::info(&self) -> core::result::Result +pub fn aya::programs::socket_filter::SocketFilter::info(&self) -> core::result::Result impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::socket_filter::SocketFilter::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::socket_filter::SocketFilter::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::socket_filter::SocketFilter -pub fn aya::programs::socket_filter::SocketFilter::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::socket_filter::SocketFilter::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::socket_filter::SocketFilter pub fn aya::programs::socket_filter::SocketFilter::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::socket_filter::SocketFilter pub fn aya::programs::socket_filter::SocketFilter::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::socket_filter::SocketFilter -pub type &'a aya::programs::socket_filter::SocketFilter::Error = aya::programs::ProgramError -pub fn &'a aya::programs::socket_filter::SocketFilter::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::socket_filter::SocketFilter, aya::programs::ProgramError> +pub type &'a aya::programs::socket_filter::SocketFilter::Error = aya::errors::ProgramError +pub fn &'a aya::programs::socket_filter::SocketFilter::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::socket_filter::SocketFilter, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::socket_filter::SocketFilter -pub type &'a mut aya::programs::socket_filter::SocketFilter::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::socket_filter::SocketFilter::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::socket_filter::SocketFilter, aya::programs::ProgramError> +pub type &'a mut aya::programs::socket_filter::SocketFilter::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::socket_filter::SocketFilter::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::socket_filter::SocketFilter, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::socket_filter::SocketFilter impl core::marker::Send for aya::programs::socket_filter::SocketFilter impl core::marker::Sync for aya::programs::socket_filter::SocketFilter @@ -8624,31 +8086,31 @@ impl core::convert::From for aya::programs::socket_filter::SocketFilter pub fn aya::programs::socket_filter::SocketFilter::from(t: T) -> T pub struct aya::programs::TracePoint impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::attach(&mut self, category: &str, name: &str) -> core::result::Result -pub fn aya::programs::trace_point::TracePoint::detach(&mut self, link_id: aya::programs::trace_point::TracePointLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::trace_point::TracePoint::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::trace_point::TracePoint::take_link(&mut self, link_id: aya::programs::trace_point::TracePointLinkId) -> core::result::Result +pub fn aya::programs::trace_point::TracePoint::attach(&mut self, category: &str, name: &str) -> core::result::Result +pub fn aya::programs::trace_point::TracePoint::detach(&mut self, link_id: aya::programs::trace_point::TracePointLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::trace_point::TracePoint::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::trace_point::TracePoint::take_link(&mut self, link_id: aya::programs::trace_point::TracePointLinkId) -> core::result::Result impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::trace_point::TracePoint::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::from_pin>(path: P) -> core::result::Result +pub fn aya::programs::trace_point::TracePoint::from_pin>(path: P) -> core::result::Result impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::info(&self) -> core::result::Result +pub fn aya::programs::trace_point::TracePoint::info(&self) -> core::result::Result impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::trace_point::TracePoint::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::trace_point::TracePoint::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::trace_point::TracePoint -pub fn aya::programs::trace_point::TracePoint::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::trace_point::TracePoint::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::trace_point::TracePoint pub fn aya::programs::trace_point::TracePoint::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::trace_point::TracePoint pub fn aya::programs::trace_point::TracePoint::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::trace_point::TracePoint -pub type &'a aya::programs::trace_point::TracePoint::Error = aya::programs::ProgramError -pub fn &'a aya::programs::trace_point::TracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::trace_point::TracePoint, aya::programs::ProgramError> +pub type &'a aya::programs::trace_point::TracePoint::Error = aya::errors::ProgramError +pub fn &'a aya::programs::trace_point::TracePoint::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::trace_point::TracePoint, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::trace_point::TracePoint -pub type &'a mut aya::programs::trace_point::TracePoint::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::trace_point::TracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::trace_point::TracePoint, aya::programs::ProgramError> +pub type &'a mut aya::programs::trace_point::TracePoint::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::trace_point::TracePoint::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::trace_point::TracePoint, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::trace_point::TracePoint impl core::marker::Send for aya::programs::trace_point::TracePoint impl core::marker::Sync for aya::programs::trace_point::TracePoint @@ -8673,31 +8135,31 @@ impl core::convert::From for aya::programs::trace_point::TracePoint pub fn aya::programs::trace_point::TracePoint::from(t: T) -> T pub struct aya::programs::UProbe impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::attach>(&mut self, fn_name: core::option::Option<&str>, offset: u64, target: T, pid: core::option::Option) -> core::result::Result -pub fn aya::programs::uprobe::UProbe::detach(&mut self, link_id: aya::programs::uprobe::UProbeLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::uprobe::UProbe::from_pin>(path: P, kind: aya::programs::ProbeKind) -> core::result::Result +pub fn aya::programs::uprobe::UProbe::attach>(&mut self, fn_name: core::option::Option<&str>, offset: u64, target: T, pid: core::option::Option) -> core::result::Result +pub fn aya::programs::uprobe::UProbe::detach(&mut self, link_id: aya::programs::uprobe::UProbeLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::uprobe::UProbe::from_pin>(path: P, kind: aya::programs::ProbeKind) -> core::result::Result pub fn aya::programs::uprobe::UProbe::kind(&self) -> aya::programs::ProbeKind -pub fn aya::programs::uprobe::UProbe::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::uprobe::UProbe::take_link(&mut self, link_id: aya::programs::uprobe::UProbeLinkId) -> core::result::Result +pub fn aya::programs::uprobe::UProbe::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::uprobe::UProbe::take_link(&mut self, link_id: aya::programs::uprobe::UProbeLinkId) -> core::result::Result impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::uprobe::UProbe::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::info(&self) -> core::result::Result +pub fn aya::programs::uprobe::UProbe::info(&self) -> core::result::Result impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::uprobe::UProbe::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::uprobe::UProbe::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::uprobe::UProbe -pub fn aya::programs::uprobe::UProbe::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::uprobe::UProbe::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::uprobe::UProbe pub fn aya::programs::uprobe::UProbe::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::uprobe::UProbe pub fn aya::programs::uprobe::UProbe::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::uprobe::UProbe -pub type &'a aya::programs::uprobe::UProbe::Error = aya::programs::ProgramError -pub fn &'a aya::programs::uprobe::UProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::uprobe::UProbe, aya::programs::ProgramError> +pub type &'a aya::programs::uprobe::UProbe::Error = aya::errors::ProgramError +pub fn &'a aya::programs::uprobe::UProbe::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::uprobe::UProbe, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::uprobe::UProbe -pub type &'a mut aya::programs::uprobe::UProbe::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::uprobe::UProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::uprobe::UProbe, aya::programs::ProgramError> +pub type &'a mut aya::programs::uprobe::UProbe::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::uprobe::UProbe::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::uprobe::UProbe, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::uprobe::UProbe impl core::marker::Send for aya::programs::uprobe::UProbe impl core::marker::Sync for aya::programs::uprobe::UProbe @@ -8722,32 +8184,32 @@ impl core::convert::From for aya::programs::uprobe::UProbe pub fn aya::programs::uprobe::UProbe::from(t: T) -> T pub struct aya::programs::Xdp impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::attach(&mut self, interface: &str, flags: aya::programs::xdp::XdpFlags) -> core::result::Result -pub fn aya::programs::xdp::Xdp::attach_to_if_index(&mut self, if_index: u32, flags: aya::programs::xdp::XdpFlags) -> core::result::Result -pub fn aya::programs::xdp::Xdp::attach_to_link(&mut self, link: aya::programs::xdp::XdpLink) -> core::result::Result -pub fn aya::programs::xdp::Xdp::detach(&mut self, link_id: aya::programs::xdp::XdpLinkId) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::xdp::Xdp::from_pin>(path: P, attach_type: aya_obj::programs::xdp::XdpAttachType) -> core::result::Result -pub fn aya::programs::xdp::Xdp::load(&mut self) -> core::result::Result<(), aya::programs::ProgramError> -pub fn aya::programs::xdp::Xdp::take_link(&mut self, link_id: aya::programs::xdp::XdpLinkId) -> core::result::Result +pub fn aya::programs::xdp::Xdp::attach(&mut self, interface: &str, flags: aya::programs::xdp::XdpFlags) -> core::result::Result +pub fn aya::programs::xdp::Xdp::attach_to_if_index(&mut self, if_index: u32, flags: aya::programs::xdp::XdpFlags) -> core::result::Result +pub fn aya::programs::xdp::Xdp::attach_to_link(&mut self, link: aya::programs::xdp::XdpLink) -> core::result::Result +pub fn aya::programs::xdp::Xdp::detach(&mut self, link_id: aya::programs::xdp::XdpLinkId) -> core::result::Result<(), aya::errors::LinkError> +pub fn aya::programs::xdp::Xdp::from_pin>(path: P, attach_type: aya_obj::programs::xdp::XdpAttachType) -> core::result::Result +pub fn aya::programs::xdp::Xdp::load(&mut self) -> core::result::Result<(), aya::errors::ProgramError> +pub fn aya::programs::xdp::Xdp::take_link(&mut self, link_id: aya::programs::xdp::XdpLinkId) -> core::result::Result impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::programs::ProgramError> +pub fn aya::programs::xdp::Xdp::fd(&self) -> core::result::Result<&aya::programs::ProgramFd, aya::errors::ProgramError> impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::info(&self) -> core::result::Result +pub fn aya::programs::xdp::Xdp::info(&self) -> core::result::Result impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::pin>(&mut self, path: P) -> core::result::Result<(), aya::pin::PinError> +pub fn aya::programs::xdp::Xdp::pin>(&mut self, path: P) -> core::result::Result<(), aya::errors::ProgramError> pub fn aya::programs::xdp::Xdp::unpin(self) -> core::result::Result<(), std::io::error::Error> impl aya::programs::xdp::Xdp -pub fn aya::programs::xdp::Xdp::unload(&mut self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::xdp::Xdp::unload(&mut self) -> core::result::Result<(), aya::errors::ProgramError> impl core::fmt::Debug for aya::programs::xdp::Xdp pub fn aya::programs::xdp::Xdp::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result impl core::ops::drop::Drop for aya::programs::xdp::Xdp pub fn aya::programs::xdp::Xdp::drop(&mut self) impl<'a> core::convert::TryFrom<&'a aya::programs::Program> for &'a aya::programs::xdp::Xdp -pub type &'a aya::programs::xdp::Xdp::Error = aya::programs::ProgramError -pub fn &'a aya::programs::xdp::Xdp::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::xdp::Xdp, aya::programs::ProgramError> +pub type &'a aya::programs::xdp::Xdp::Error = aya::errors::ProgramError +pub fn &'a aya::programs::xdp::Xdp::try_from(program: &'a aya::programs::Program) -> core::result::Result<&'a aya::programs::xdp::Xdp, aya::errors::ProgramError> impl<'a> core::convert::TryFrom<&'a mut aya::programs::Program> for &'a mut aya::programs::xdp::Xdp -pub type &'a mut aya::programs::xdp::Xdp::Error = aya::programs::ProgramError -pub fn &'a mut aya::programs::xdp::Xdp::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::xdp::Xdp, aya::programs::ProgramError> +pub type &'a mut aya::programs::xdp::Xdp::Error = aya::errors::ProgramError +pub fn &'a mut aya::programs::xdp::Xdp::try_from(program: &'a mut aya::programs::Program) -> core::result::Result<&'a mut aya::programs::xdp::Xdp, aya::errors::ProgramError> impl core::marker::Freeze for aya::programs::xdp::Xdp impl core::marker::Send for aya::programs::xdp::Xdp impl core::marker::Sync for aya::programs::xdp::Xdp @@ -8885,125 +8347,125 @@ impl core::convert::From for aya::programs::xdp::XdpFlags pub fn aya::programs::xdp::XdpFlags::from(t: T) -> T pub trait aya::programs::Link: core::fmt::Debug + 'static pub type aya::programs::Link::Id: core::fmt::Debug + core::hash::Hash + core::cmp::Eq + core::cmp::PartialEq -pub fn aya::programs::Link::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::Link::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::Link::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_device::CgroupDeviceLink pub type aya::programs::cgroup_device::CgroupDeviceLink::Id = aya::programs::cgroup_device::CgroupDeviceLinkId -pub fn aya::programs::cgroup_device::CgroupDeviceLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_device::CgroupDeviceLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_device::CgroupDeviceLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_skb::CgroupSkbLink pub type aya::programs::cgroup_skb::CgroupSkbLink::Id = aya::programs::cgroup_skb::CgroupSkbLinkId -pub fn aya::programs::cgroup_skb::CgroupSkbLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_skb::CgroupSkbLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_skb::CgroupSkbLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_sock::CgroupSockLink pub type aya::programs::cgroup_sock::CgroupSockLink::Id = aya::programs::cgroup_sock::CgroupSockLinkId -pub fn aya::programs::cgroup_sock::CgroupSockLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock::CgroupSockLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sock::CgroupSockLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_sock_addr::CgroupSockAddrLink pub type aya::programs::cgroup_sock_addr::CgroupSockAddrLink::Id = aya::programs::cgroup_sock_addr::CgroupSockAddrLinkId -pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sock_addr::CgroupSockAddrLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_sockopt::CgroupSockoptLink pub type aya::programs::cgroup_sockopt::CgroupSockoptLink::Id = aya::programs::cgroup_sockopt::CgroupSockoptLinkId -pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sockopt::CgroupSockoptLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::cgroup_sysctl::CgroupSysctlLink pub type aya::programs::cgroup_sysctl::CgroupSysctlLink::Id = aya::programs::cgroup_sysctl::CgroupSysctlLinkId -pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::cgroup_sysctl::CgroupSysctlLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::extension::ExtensionLink pub type aya::programs::extension::ExtensionLink::Id = aya::programs::extension::ExtensionLinkId -pub fn aya::programs::extension::ExtensionLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::extension::ExtensionLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::extension::ExtensionLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::fentry::FEntryLink pub type aya::programs::fentry::FEntryLink::Id = aya::programs::fentry::FEntryLinkId -pub fn aya::programs::fentry::FEntryLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fentry::FEntryLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::fentry::FEntryLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::fexit::FExitLink pub type aya::programs::fexit::FExitLink::Id = aya::programs::fexit::FExitLinkId -pub fn aya::programs::fexit::FExitLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::fexit::FExitLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::fexit::FExitLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::kprobe::KProbeLink pub type aya::programs::kprobe::KProbeLink::Id = aya::programs::kprobe::KProbeLinkId -pub fn aya::programs::kprobe::KProbeLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::kprobe::KProbeLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::kprobe::KProbeLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::links::FdLink pub type aya::programs::links::FdLink::Id = aya::programs::links::FdLinkId -pub fn aya::programs::links::FdLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::links::FdLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::links::FdLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::links::ProgAttachLink pub type aya::programs::links::ProgAttachLink::Id = aya::programs::links::ProgAttachLinkId -pub fn aya::programs::links::ProgAttachLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::links::ProgAttachLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::links::ProgAttachLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::lirc_mode2::LircLink pub type aya::programs::lirc_mode2::LircLink::Id = aya::programs::lirc_mode2::LircLinkId -pub fn aya::programs::lirc_mode2::LircLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lirc_mode2::LircLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::lirc_mode2::LircLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::lsm::LsmLink pub type aya::programs::lsm::LsmLink::Id = aya::programs::lsm::LsmLinkId -pub fn aya::programs::lsm::LsmLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::lsm::LsmLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::lsm::LsmLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::perf_attach::PerfLink pub type aya::programs::perf_attach::PerfLink::Id = aya::programs::perf_attach::PerfLinkId -pub fn aya::programs::perf_attach::PerfLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::perf_attach::PerfLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::perf_attach::PerfLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::perf_event::PerfEventLink pub type aya::programs::perf_event::PerfEventLink::Id = aya::programs::perf_event::PerfEventLinkId -pub fn aya::programs::perf_event::PerfEventLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::perf_event::PerfEventLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::perf_event::PerfEventLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::raw_trace_point::RawTracePointLink pub type aya::programs::raw_trace_point::RawTracePointLink::Id = aya::programs::raw_trace_point::RawTracePointLinkId -pub fn aya::programs::raw_trace_point::RawTracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::raw_trace_point::RawTracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::raw_trace_point::RawTracePointLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::sk_lookup::SkLookupLink pub type aya::programs::sk_lookup::SkLookupLink::Id = aya::programs::sk_lookup::SkLookupLinkId -pub fn aya::programs::sk_lookup::SkLookupLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_lookup::SkLookupLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_lookup::SkLookupLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::sk_msg::SkMsgLink pub type aya::programs::sk_msg::SkMsgLink::Id = aya::programs::sk_msg::SkMsgLinkId -pub fn aya::programs::sk_msg::SkMsgLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_msg::SkMsgLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_msg::SkMsgLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::sk_skb::SkSkbLink pub type aya::programs::sk_skb::SkSkbLink::Id = aya::programs::sk_skb::SkSkbLinkId -pub fn aya::programs::sk_skb::SkSkbLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sk_skb::SkSkbLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sk_skb::SkSkbLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::sock_ops::SockOpsLink pub type aya::programs::sock_ops::SockOpsLink::Id = aya::programs::sock_ops::SockOpsLinkId -pub fn aya::programs::sock_ops::SockOpsLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::sock_ops::SockOpsLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::sock_ops::SockOpsLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::socket_filter::SocketFilterLink pub type aya::programs::socket_filter::SocketFilterLink::Id = aya::programs::socket_filter::SocketFilterLinkId -pub fn aya::programs::socket_filter::SocketFilterLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::socket_filter::SocketFilterLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::socket_filter::SocketFilterLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::tc::SchedClassifierLink pub type aya::programs::tc::SchedClassifierLink::Id = aya::programs::tc::SchedClassifierLinkId -pub fn aya::programs::tc::SchedClassifierLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tc::SchedClassifierLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::tc::SchedClassifierLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::tp_btf::BtfTracePointLink pub type aya::programs::tp_btf::BtfTracePointLink::Id = aya::programs::tp_btf::BtfTracePointLinkId -pub fn aya::programs::tp_btf::BtfTracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::tp_btf::BtfTracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::tp_btf::BtfTracePointLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::trace_point::TracePointLink pub type aya::programs::trace_point::TracePointLink::Id = aya::programs::trace_point::TracePointLinkId -pub fn aya::programs::trace_point::TracePointLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::trace_point::TracePointLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::trace_point::TracePointLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::uprobe::UProbeLink pub type aya::programs::uprobe::UProbeLink::Id = aya::programs::uprobe::UProbeLinkId -pub fn aya::programs::uprobe::UProbeLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::uprobe::UProbeLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::uprobe::UProbeLink::id(&self) -> Self::Id impl aya::programs::links::Link for aya::programs::xdp::XdpLink pub type aya::programs::xdp::XdpLink::Id = aya::programs::xdp::XdpLinkId -pub fn aya::programs::xdp::XdpLink::detach(self) -> core::result::Result<(), aya::programs::ProgramError> +pub fn aya::programs::xdp::XdpLink::detach(self) -> core::result::Result<(), aya::errors::LinkError> pub fn aya::programs::xdp::XdpLink::id(&self) -> Self::Id pub trait aya::programs::MultiProgLink -pub fn aya::programs::MultiProgLink::fd(&self) -> core::result::Result, aya::programs::links::LinkError> +pub fn aya::programs::MultiProgLink::fd(&self) -> core::result::Result, aya::errors::LinkError> impl aya::programs::MultiProgLink for aya::programs::tc::SchedClassifierLink -pub fn aya::programs::tc::SchedClassifierLink::fd(&self) -> core::result::Result, aya::programs::links::LinkError> +pub fn aya::programs::tc::SchedClassifierLink::fd(&self) -> core::result::Result, aya::errors::LinkError> pub trait aya::programs::MultiProgram -pub fn aya::programs::MultiProgram::fd(&self) -> core::result::Result, aya::programs::ProgramError> +pub fn aya::programs::MultiProgram::fd(&self) -> core::result::Result, aya::errors::ProgramError> impl aya::programs::MultiProgram for aya::programs::tc::SchedClassifier -pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result, aya::programs::ProgramError> -pub fn aya::programs::loaded_programs() -> impl core::iter::traits::iterator::Iterator> +pub fn aya::programs::tc::SchedClassifier::fd(&self) -> core::result::Result, aya::errors::ProgramError> +pub fn aya::programs::loaded_programs() -> impl core::iter::traits::iterator::Iterator> pub mod aya::sys #[non_exhaustive] pub enum aya::sys::Stats pub aya::sys::Stats::RunTime @@ -9042,48 +8504,7 @@ impl core::clone::CloneToUninit for aya::sys::Stats where T: core::clone::Clo pub unsafe fn aya::sys::Stats::clone_to_uninit(&self, dst: *mut T) impl core::convert::From for aya::sys::Stats pub fn aya::sys::Stats::from(t: T) -> T -pub struct aya::sys::SyscallError -pub aya::sys::SyscallError::call: &'static str -pub aya::sys::SyscallError::io_error: std::io::error::Error -impl core::convert::From for aya::maps::MapError -pub fn aya::maps::MapError::from(source: aya::sys::SyscallError) -> Self -impl core::convert::From for aya::pin::PinError -pub fn aya::pin::PinError::from(source: aya::sys::SyscallError) -> Self -impl core::convert::From for aya::programs::ProgramError -pub fn aya::programs::ProgramError::from(source: aya::sys::SyscallError) -> Self -impl core::convert::From for aya::programs::links::LinkError -pub fn aya::programs::links::LinkError::from(source: aya::sys::SyscallError) -> Self -impl core::error::Error for aya::sys::SyscallError -pub fn aya::sys::SyscallError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::sys::SyscallError -pub fn aya::sys::SyscallError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::sys::SyscallError -pub fn aya::sys::SyscallError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::sys::SyscallError -impl core::marker::Send for aya::sys::SyscallError -impl core::marker::Sync for aya::sys::SyscallError -impl core::marker::Unpin for aya::sys::SyscallError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::sys::SyscallError -impl !core::panic::unwind_safe::UnwindSafe for aya::sys::SyscallError -impl core::convert::Into for aya::sys::SyscallError where U: core::convert::From -pub fn aya::sys::SyscallError::into(self) -> U -impl core::convert::TryFrom for aya::sys::SyscallError where U: core::convert::Into -pub type aya::sys::SyscallError::Error = core::convert::Infallible -pub fn aya::sys::SyscallError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::sys::SyscallError where U: core::convert::TryFrom -pub type aya::sys::SyscallError::Error = >::Error -pub fn aya::sys::SyscallError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::sys::SyscallError where T: core::fmt::Display + core::marker::Sized -pub fn aya::sys::SyscallError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::sys::SyscallError where T: 'static + core::marker::Sized -pub fn aya::sys::SyscallError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::sys::SyscallError where T: core::marker::Sized -pub fn aya::sys::SyscallError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::sys::SyscallError where T: core::marker::Sized -pub fn aya::sys::SyscallError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::sys::SyscallError -pub fn aya::sys::SyscallError::from(t: T) -> T -pub fn aya::sys::enable_stats(stats_type: aya::sys::Stats) -> core::result::Result +pub fn aya::sys::enable_stats(stats_type: aya::sys::Stats) -> core::result::Result> pub mod aya::util pub struct aya::util::KernelVersion impl aya::util::KernelVersion @@ -9140,65 +8561,10 @@ pub fn aya::util::nr_cpus() -> core::result::Result core::result::Result, (&'static str, std::io::error::Error)> pub fn aya::util::syscall_prefix() -> core::result::Result<&'static str, std::io::error::Error> pub macro aya::include_bytes_aligned! -pub enum aya::EbpfError -pub aya::EbpfError::BtfError(aya_obj::btf::btf::BtfError) -pub aya::EbpfError::BtfRelocationError(aya_obj::btf::relocation::BtfRelocationError) -pub aya::EbpfError::FileError -pub aya::EbpfError::FileError::error: std::io::error::Error -pub aya::EbpfError::FileError::path: std::path::PathBuf -pub aya::EbpfError::MapError(aya::maps::MapError) -pub aya::EbpfError::NoBTF -pub aya::EbpfError::ParseError(aya_obj::obj::ParseError) -pub aya::EbpfError::ProgramError(aya::programs::ProgramError) -pub aya::EbpfError::RelocationError(aya_obj::relocation::EbpfRelocationError) -pub aya::EbpfError::UnexpectedPinningType -pub aya::EbpfError::UnexpectedPinningType::name: u32 -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(source: aya::maps::MapError) -> Self -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(source: aya::programs::ProgramError) -> Self -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(source: aya_obj::btf::btf::BtfError) -> Self -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(source: aya_obj::btf::relocation::BtfRelocationError) -> Self -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(source: aya_obj::obj::ParseError) -> Self -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(source: aya_obj::relocation::EbpfRelocationError) -> Self -impl core::error::Error for aya::EbpfError -pub fn aya::EbpfError::source(&self) -> core::option::Option<&(dyn core::error::Error + 'static)> -impl core::fmt::Debug for aya::EbpfError -pub fn aya::EbpfError::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::fmt::Display for aya::EbpfError -pub fn aya::EbpfError::fmt(&self, __formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result -impl core::marker::Freeze for aya::EbpfError -impl core::marker::Send for aya::EbpfError -impl core::marker::Sync for aya::EbpfError -impl core::marker::Unpin for aya::EbpfError -impl !core::panic::unwind_safe::RefUnwindSafe for aya::EbpfError -impl !core::panic::unwind_safe::UnwindSafe for aya::EbpfError -impl core::convert::Into for aya::EbpfError where U: core::convert::From -pub fn aya::EbpfError::into(self) -> U -impl core::convert::TryFrom for aya::EbpfError where U: core::convert::Into -pub type aya::EbpfError::Error = core::convert::Infallible -pub fn aya::EbpfError::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::EbpfError where U: core::convert::TryFrom -pub type aya::EbpfError::Error = >::Error -pub fn aya::EbpfError::try_into(self) -> core::result::Result>::Error> -impl alloc::string::ToString for aya::EbpfError where T: core::fmt::Display + core::marker::Sized -pub fn aya::EbpfError::to_string(&self) -> alloc::string::String -impl core::any::Any for aya::EbpfError where T: 'static + core::marker::Sized -pub fn aya::EbpfError::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::EbpfError where T: core::marker::Sized -pub fn aya::EbpfError::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::EbpfError where T: core::marker::Sized -pub fn aya::EbpfError::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::EbpfError -pub fn aya::EbpfError::from(t: T) -> T pub struct aya::Ebpf impl aya::Ebpf -pub fn aya::Ebpf::load(data: &[u8]) -> core::result::Result -pub fn aya::Ebpf::load_file>(path: P) -> core::result::Result +pub fn aya::Ebpf::load(data: &[u8]) -> core::result::Result +pub fn aya::Ebpf::load_file>(path: P) -> core::result::Result pub fn aya::Ebpf::map(&self, name: &str) -> core::option::Option<&aya::maps::Map> pub fn aya::Ebpf::map_mut(&mut self, name: &str) -> core::option::Option<&mut aya::maps::Map> pub fn aya::Ebpf::maps(&self) -> impl core::iter::traits::iterator::Iterator @@ -9237,8 +8603,8 @@ impl<'a> aya::EbpfLoader<'a> pub fn aya::EbpfLoader<'a>::allow_unsupported_maps(&mut self) -> &mut Self pub fn aya::EbpfLoader<'a>::btf(&mut self, btf: core::option::Option<&'a aya_obj::btf::btf::Btf>) -> &mut Self pub fn aya::EbpfLoader<'a>::extension(&mut self, name: &'a str) -> &mut Self -pub fn aya::EbpfLoader<'a>::load(&mut self, data: &[u8]) -> core::result::Result -pub fn aya::EbpfLoader<'a>::load_file>(&mut self, path: P) -> core::result::Result +pub fn aya::EbpfLoader<'a>::load(&mut self, data: &[u8]) -> core::result::Result +pub fn aya::EbpfLoader<'a>::load_file>(&mut self, path: P) -> core::result::Result pub fn aya::EbpfLoader<'a>::map_pin_path>(&mut self, path: P) -> &mut Self pub fn aya::EbpfLoader<'a>::new() -> Self pub fn aya::EbpfLoader<'a>::set_global>>(&mut self, name: &'a str, value: T, must_exist: bool) -> &mut Self @@ -9426,5 +8792,5 @@ impl aya::Pod for aya::maps::lpm_trie::Key impl aya::Pod for [T; N] pub fn aya::features() -> &'static aya_obj::obj::Features pub type aya::Bpf = aya::Ebpf -pub type aya::BpfError = aya::EbpfError +pub type aya::BpfError = aya::errors::EbpfError pub type aya::BpfLoader<'a> = aya::EbpfLoader<'a>