From 35332f2288b0bbb8981233ae464715ea9217b081 Mon Sep 17 00:00:00 2001 From: Tamir Duberstein Date: Sun, 6 Jul 2025 18:57:41 -0400 Subject: [PATCH] aya: remove `AsyncPerfEventArray{,Buffer}` Rather than support N async runtimes, push this to the user. The relevant types (`PerfEventArrayBuffer` and `RingBuffer`) implement `As{,Raw}Fd` which is sufficient with integration with tokio, smol, and other async runtimes. --- Cargo.toml | 1 - aya/CHANGELOG.md | 8 + aya/Cargo.toml | 7 - aya/src/lib.rs | 4 - aya/src/maps/info.rs | 4 +- aya/src/maps/mod.rs | 6 - aya/src/maps/perf/async_perf_event_array.rs | 185 -------------------- aya/src/maps/perf/mod.rs | 8 +- aya/src/maps/perf/perf_event_array.rs | 7 - aya/src/maps/ring_buf.rs | 8 +- xtask/public-api/aya.txt | 104 ----------- 11 files changed, 16 insertions(+), 326 deletions(-) delete mode 100644 aya/src/maps/perf/async_perf_event_array.rs diff --git a/Cargo.toml b/Cargo.toml index 044cd9f6..78ec5c1f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -63,7 +63,6 @@ rust-version = "1.85.0" [workspace.dependencies] anyhow = { version = "1", default-features = false } assert_matches = { version = "1.5.0", default-features = false } -async-io = { version = "2.0", default-features = false } base64 = { version = "0.22.1", default-features = false } bindgen = { version = "0.72", default-features = false } bitflags = { version = "2.2.1", default-features = false } diff --git a/aya/CHANGELOG.md b/aya/CHANGELOG.md index beacdef0..99db6548 100644 --- a/aya/CHANGELOG.md +++ b/aya/CHANGELOG.md @@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [Unreleased] + +### Breaking Changes + + - Remove `AsyncPerfEventArray` and `AsyncPerfEventArrayBuffer` These types have been removed to + avoid maintaining support for multiple async runtimes. Use `PerfEventArrayBuffer`, which + implements `As{,Raw}Fd` for integration with async executors. + ## 0.13.1 (2024-11-01) ### Chore diff --git a/aya/Cargo.toml b/aya/Cargo.toml index 3d0618da..ad431440 100644 --- a/aya/Cargo.toml +++ b/aya/Cargo.toml @@ -18,7 +18,6 @@ workspace = true [dependencies] assert_matches = { workspace = true } -async-io = { workspace = true, optional = true } aya-obj = { path = "../aya-obj", version = "^0.2.1", features = ["std"] } bitflags = { workspace = true } bytes = { workspace = true } @@ -28,16 +27,10 @@ log = { workspace = true } object = { workspace = true, features = ["elf", "read_core", "std", "write"] } once_cell = { workspace = true } thiserror = { workspace = true } -tokio = { workspace = true, features = ["rt"], optional = true } [dev-dependencies] tempfile = { workspace = true } -[features] -async_std = ["dep:async-io"] -async_tokio = ["tokio/net"] -default = [] - [package.metadata.docs.rs] all-features = true rustdoc-args = ["--cfg", "docsrs", "-D", "warnings"] diff --git a/aya/src/lib.rs b/aya/src/lib.rs index 8f37fd78..ba57bfd3 100644 --- a/aya/src/lib.rs +++ b/aya/src/lib.rs @@ -67,10 +67,6 @@ //unused_qualifications, https://github.com/rust-lang/rust/commit/9ccc7b7 added size_of to the prelude, but we need to continue to qualify it so that we build on older compilers. //unused_results, )] -#![cfg_attr( - all(feature = "async_tokio", feature = "async_std"), - expect(unused_crate_dependencies) -)] mod bpf; pub mod maps; diff --git a/aya/src/maps/info.rs b/aya/src/maps/info.rs index 81ab1498..5c2dac9b 100644 --- a/aya/src/maps/info.rs +++ b/aya/src/maps/info.rs @@ -185,8 +185,8 @@ pub enum MapType { /// Introduced in kernel v4.2. #[doc(alias = "BPF_MAP_TYPE_PROG_ARRAY")] ProgramArray = bpf_map_type::BPF_MAP_TYPE_PROG_ARRAY as isize, - /// A Perf Event Array map type. See [`PerfEventArray`](super::perf::PerfEventArray) and - /// [`AsyncPerfEventArray`](super::perf::AsyncPerfEventArray) for the map implementations. + /// A Perf Event Array map type. See [`PerfEventArray`](super::perf::PerfEventArray) for the map + /// implementation. /// /// Introduced in kernel v4.3. #[doc(alias = "BPF_MAP_TYPE_PERF_EVENT_ARRAY")] diff --git a/aya/src/maps/mod.rs b/aya/src/maps/mod.rs index 21bb2b4c..0d3e0ebf 100644 --- a/aya/src/maps/mod.rs +++ b/aya/src/maps/mod.rs @@ -92,9 +92,6 @@ pub use bloom_filter::BloomFilter; pub use hash_map::{HashMap, PerCpuHashMap}; pub use info::{MapInfo, MapType, loaded_maps}; pub use lpm_trie::LpmTrie; -#[cfg(any(feature = "async_tokio", feature = "async_std"))] -#[cfg_attr(docsrs, doc(cfg(any(feature = "async_tokio", feature = "async_std"))))] -pub use perf::AsyncPerfEventArray; pub use perf::PerfEventArray; pub use queue::Queue; pub use ring_buf::RingBuf; @@ -487,9 +484,6 @@ impl_try_from_map!(() { SockMap, StackTraceMap, XskMap, - #[cfg(any(feature = "async_tokio", feature = "async_std"))] - #[cfg_attr(docsrs, doc(cfg(any(feature = "async_tokio", feature = "async_std"))))] - AsyncPerfEventArray from PerfEventArray, }); impl_try_from_map!((V) { diff --git a/aya/src/maps/perf/async_perf_event_array.rs b/aya/src/maps/perf/async_perf_event_array.rs deleted file mode 100644 index ecc7babb..00000000 --- a/aya/src/maps/perf/async_perf_event_array.rs +++ /dev/null @@ -1,185 +0,0 @@ -use std::{ - borrow::{Borrow, BorrowMut}, - path::Path, -}; - -// See https://doc.rust-lang.org/cargo/reference/features.html#mutually-exclusive-features. -// -// We should eventually split async functionality out into separate crates "aya-async-tokio" and -// "async-async-std". Presently we arbitrarily choose tokio over async-std when both are requested. -#[cfg(all(not(feature = "async_tokio"), feature = "async_std"))] -use async_io::Async; -use bytes::BytesMut; -#[cfg(feature = "async_tokio")] -use tokio::io::unix::AsyncFd; - -use crate::maps::{ - MapData, MapError, PinError, - perf::{Events, PerfBufferError, PerfEventArray, PerfEventArrayBuffer}, -}; - -/// A `Future` based map that can be used to receive events from eBPF programs using the linux -/// [`perf`](https://perf.wiki.kernel.org/index.php/Main_Page) API. -/// -/// This is the async version of [`PerfEventArray`], which provides integration -/// with [tokio](https://docs.rs/tokio) and [async-std](https:/docs.rs/async-std) and a nice `Future` based API. -/// -/// To receive events you need to: -/// * call [`AsyncPerfEventArray::open`] -/// * call [`AsyncPerfEventArrayBuffer::read_events`] to read the events -/// -/// # Minimum kernel version -/// -/// The minimum kernel version required to use this feature is 4.3. -/// -/// # Examples -/// -/// ```no_run -/// # #[derive(thiserror::Error, Debug)] -/// # enum Error { -/// # #[error(transparent)] -/// # IO(#[from] std::io::Error), -/// # #[error(transparent)] -/// # Map(#[from] aya::maps::MapError), -/// # #[error(transparent)] -/// # Ebpf(#[from] aya::EbpfError), -/// # #[error(transparent)] -/// # PerfBuf(#[from] aya::maps::perf::PerfBufferError), -/// # } -/// # #[cfg(feature = "async_tokio")] -/// # async fn try_main() -> Result<(), Error> { -/// # let mut bpf = aya::Ebpf::load(&[])?; -/// use aya::maps::perf::{AsyncPerfEventArray, PerfBufferError}; -/// use aya::util::online_cpus; -/// use bytes::BytesMut; -/// use tokio::task; // or async_std::task -/// -/// // try to convert the PERF_ARRAY map to an AsyncPerfEventArray -/// let mut perf_array = AsyncPerfEventArray::try_from(bpf.take_map("PERF_ARRAY").unwrap())?; -/// -/// for cpu_id in online_cpus().map_err(|(_, error)| error)? { -/// // open a separate perf buffer for each cpu -/// let mut buf = perf_array.open(cpu_id, None)?; -/// -/// // process each perf buffer in a separate task -/// task::spawn(async move { -/// let mut buffers = std::iter::repeat_n(BytesMut::with_capacity(1024), 10) -/// .collect::>(); -/// -/// loop { -/// // wait for events -/// let events = buf.read_events(&mut buffers).await?; -/// -/// // events.read contains the number of events that have been read, -/// // and is always <= buffers.len() -/// for i in 0..events.read { -/// let buf = &mut buffers[i]; -/// // process buf -/// } -/// } -/// -/// Ok::<_, PerfBufferError>(()) -/// }); -/// } -/// -/// # Ok(()) -/// # } -/// ``` -#[doc(alias = "BPF_MAP_TYPE_PERF_EVENT_ARRAY")] -pub struct AsyncPerfEventArray { - perf_map: PerfEventArray, -} - -impl> AsyncPerfEventArray { - /// Opens the perf buffer at the given index. - /// - /// The returned buffer will receive all the events eBPF programs send at the given index. - pub fn open( - &mut self, - index: u32, - page_count: Option, - ) -> Result, PerfBufferError> { - let Self { perf_map } = self; - let buf = perf_map.open(index, page_count)?; - #[cfg(feature = "async_tokio")] - let buf = AsyncFd::new(buf)?; - #[cfg(all(not(feature = "async_tokio"), feature = "async_std"))] - let buf = Async::new(buf)?; - Ok(AsyncPerfEventArrayBuffer { buf }) - } - - /// Pins the map to a BPF filesystem. - /// - /// 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> { - self.perf_map.pin(path) - } -} - -impl> AsyncPerfEventArray { - pub(crate) fn new(map: T) -> Result { - Ok(Self { - perf_map: PerfEventArray::new(map)?, - }) - } -} - -/// A `Future` based ring buffer that can receive events from eBPF programs. -/// -/// [`AsyncPerfEventArrayBuffer`] is a ring buffer that can receive events from eBPF programs that -/// use `bpf_perf_event_output()`. It's returned by [`AsyncPerfEventArray::open`]. -/// -/// See the [`AsyncPerfEventArray` documentation](AsyncPerfEventArray) for an overview of how to -/// use perf buffers. -pub struct AsyncPerfEventArrayBuffer> { - #[cfg(not(any(feature = "async_tokio", feature = "async_std")))] - buf: PerfEventArrayBuffer, - - #[cfg(feature = "async_tokio")] - buf: AsyncFd>, - - #[cfg(all(not(feature = "async_tokio"), feature = "async_std"))] - buf: Async>, -} - -impl> AsyncPerfEventArrayBuffer { - /// Reads events from the buffer. - /// - /// This method reads events into the provided slice of buffers, filling - /// each buffer in order stopping when there are no more events to read or - /// all the buffers have been filled. - /// - /// Returns the number of events read and the number of events lost. Events - /// are lost when user space doesn't read events fast enough and the ring - /// buffer fills up. - pub async fn read_events( - &mut self, - buffers: &mut [BytesMut], - ) -> Result { - let Self { buf } = self; - loop { - #[cfg(feature = "async_tokio")] - let mut guard = buf.readable_mut().await?; - #[cfg(feature = "async_tokio")] - let buf = guard.get_inner_mut(); - - #[cfg(all(not(feature = "async_tokio"), feature = "async_std"))] - let buf = { - if !buf.get_ref().readable() { - buf.readable().await?; - } - unsafe { buf.get_mut() } - }; - - let events = buf.read_events(buffers)?; - const EMPTY: Events = Events { read: 0, lost: 0 }; - if events != EMPTY { - break Ok(events); - } - - #[cfg(feature = "async_tokio")] - guard.clear_ready(); - } - } -} diff --git a/aya/src/maps/perf/mod.rs b/aya/src/maps/perf/mod.rs index 765b052d..61151c6f 100644 --- a/aya/src/maps/perf/mod.rs +++ b/aya/src/maps/perf/mod.rs @@ -1,15 +1,9 @@ //! Ring buffer types used to receive events from eBPF programs using the linux //! `perf` API. //! -//! See [`PerfEventArray`] and [`AsyncPerfEventArray`]. -#[cfg(any(feature = "async_tokio", feature = "async_std"))] -#[cfg_attr(docsrs, doc(cfg(any(feature = "async_tokio", feature = "async_std"))))] -mod async_perf_event_array; +//! See [`PerfEventArray`]. mod perf_buffer; mod perf_event_array; -#[cfg(any(feature = "async_tokio", feature = "async_std"))] -#[cfg_attr(docsrs, doc(cfg(any(feature = "async_tokio", feature = "async_std"))))] -pub use async_perf_event_array::*; pub use perf_buffer::*; pub use perf_event_array::*; diff --git a/aya/src/maps/perf/perf_event_array.rs b/aya/src/maps/perf/perf_event_array.rs index c825178a..91618fe4 100644 --- a/aya/src/maps/perf/perf_event_array.rs +++ b/aya/src/maps/perf/perf_event_array.rs @@ -151,16 +151,9 @@ impl> AsRawFd for PerfEventArrayBuffer { /// amounts of data, in order not to lose events you might want to process each /// [`PerfEventArrayBuffer`] on a different thread. /// -/// # Async -/// -/// If you are using [tokio] or [async-std], you should use `AsyncPerfEventArray` which -/// efficiently integrates with those and provides a nicer `Future` based API. -/// /// [`perf`]: https://perf.wiki.kernel.org/index.php/Main_Page /// [epoll]: https://docs.rs/epoll /// [mio]: https://docs.rs/mio -/// [tokio]: https://docs.rs/tokio -/// [async-std]: https://docs.rs/async-std #[doc(alias = "BPF_MAP_TYPE_PERF_EVENT_ARRAY")] pub struct PerfEventArray { map: Arc, diff --git a/aya/src/maps/ring_buf.rs b/aya/src/maps/ring_buf.rs index 79bf8f1c..c6642411 100644 --- a/aya/src/maps/ring_buf.rs +++ b/aya/src/maps/ring_buf.rs @@ -83,9 +83,11 @@ use crate::{ /// # Polling /// /// In the example above the implementations of poll(), poll.readable(), guard.inner_mut(), and -/// guard.clear_ready() are not given. RingBuf implements the AsRawFd trait, so you can implement -/// polling using any crate that can poll file descriptors, like epoll, mio etc. The above example -/// API is motivated by that of [`tokio::io::unix::AsyncFd`]. +/// guard.clear_ready() are not given. RingBuf implements [`AsRawFd`], so you can implement polling +/// using any crate that can poll file descriptors, like epoll, mio etc. The above example API is +/// motivated by that of [`tokio::io::unix::AsyncFd`]. +/// +/// [`tokio::io::unix::AsyncFd`]: https://docs.rs/tokio/latest/tokio/io/unix/struct.AsyncFd.html #[doc(alias = "BPF_MAP_TYPE_RINGBUF")] pub struct RingBuf { map: T, diff --git a/xtask/public-api/aya.txt b/xtask/public-api/aya.txt index 9fad0a43..a0d9277f 100644 --- a/xtask/public-api/aya.txt +++ b/xtask/public-api/aya.txt @@ -396,66 +396,6 @@ impl core::borrow::BorrowMut for aya::maps::perf::PerfBufferError where T: 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> -impl core::convert::TryFrom for aya::maps::perf::AsyncPerfEventArray -pub type aya::maps::perf::AsyncPerfEventArray::Error = aya::maps::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 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 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 -impl core::marker::Sync for aya::maps::perf::AsyncPerfEventArray where T: core::marker::Sync + core::marker::Send -impl core::marker::Unpin for aya::maps::perf::AsyncPerfEventArray -impl core::panic::unwind_safe::RefUnwindSafe for aya::maps::perf::AsyncPerfEventArray where T: core::panic::unwind_safe::RefUnwindSafe -impl core::panic::unwind_safe::UnwindSafe for aya::maps::perf::AsyncPerfEventArray where T: core::panic::unwind_safe::RefUnwindSafe -impl core::convert::Into for aya::maps::perf::AsyncPerfEventArray where U: core::convert::From -pub fn aya::maps::perf::AsyncPerfEventArray::into(self) -> U -impl core::convert::TryFrom for aya::maps::perf::AsyncPerfEventArray where U: core::convert::Into -pub type aya::maps::perf::AsyncPerfEventArray::Error = core::convert::Infallible -pub fn aya::maps::perf::AsyncPerfEventArray::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::maps::perf::AsyncPerfEventArray where U: core::convert::TryFrom -pub type aya::maps::perf::AsyncPerfEventArray::Error = >::Error -pub fn aya::maps::perf::AsyncPerfEventArray::try_into(self) -> core::result::Result>::Error> -impl core::any::Any for aya::maps::perf::AsyncPerfEventArray where T: 'static + ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArray::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::maps::perf::AsyncPerfEventArray where T: ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArray::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::maps::perf::AsyncPerfEventArray where T: ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArray::borrow_mut(&mut self) -> &mut T -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 -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 -impl core::marker::Unpin for aya::maps::perf::AsyncPerfEventArrayBuffer -impl !core::panic::unwind_safe::RefUnwindSafe for aya::maps::perf::AsyncPerfEventArrayBuffer -impl !core::panic::unwind_safe::UnwindSafe for aya::maps::perf::AsyncPerfEventArrayBuffer -impl core::convert::Into for aya::maps::perf::AsyncPerfEventArrayBuffer where U: core::convert::From -pub fn aya::maps::perf::AsyncPerfEventArrayBuffer::into(self) -> U -impl core::convert::TryFrom for aya::maps::perf::AsyncPerfEventArrayBuffer where U: core::convert::Into -pub type aya::maps::perf::AsyncPerfEventArrayBuffer::Error = core::convert::Infallible -pub fn aya::maps::perf::AsyncPerfEventArrayBuffer::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::maps::perf::AsyncPerfEventArrayBuffer where U: core::convert::TryFrom -pub type aya::maps::perf::AsyncPerfEventArrayBuffer::Error = >::Error -pub fn aya::maps::perf::AsyncPerfEventArrayBuffer::try_into(self) -> core::result::Result>::Error> -impl core::any::Any for aya::maps::perf::AsyncPerfEventArrayBuffer where T: 'static + ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArrayBuffer::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::maps::perf::AsyncPerfEventArrayBuffer where T: ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArrayBuffer::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::maps::perf::AsyncPerfEventArrayBuffer where T: ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArrayBuffer::borrow_mut(&mut self) -> &mut T -impl core::convert::From for aya::maps::perf::AsyncPerfEventArrayBuffer -pub fn aya::maps::perf::AsyncPerfEventArrayBuffer::from(t: T) -> T pub struct aya::maps::perf::Events pub aya::maps::perf::Events::lost: usize pub aya::maps::perf::Events::read: usize @@ -1160,9 +1100,6 @@ pub fn aya::maps::SockMap::try_from(map: aya::maps::Map) -> impl core::convert::TryFrom for aya::maps::XskMap pub type aya::maps::XskMap::Error = aya::maps::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 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 fn aya::maps::perf::PerfEventArray::try_from(map: aya::maps::Map) -> core::result::Result @@ -1246,9 +1183,6 @@ pub fn aya::maps::SockMap<&'a aya::maps::MapData>::try_from(map: &'a aya::maps:: 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 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 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 fn aya::maps::perf::PerfEventArray<&'a aya::maps::MapData>::try_from(map: &'a aya::maps::Map) -> core::result::Result @@ -1276,9 +1210,6 @@ pub fn aya::maps::SockMap<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya 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 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 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 fn aya::maps::perf::PerfEventArray<&'a mut aya::maps::MapData>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result @@ -1525,41 +1456,6 @@ impl core::borrow::BorrowMut for aya::maps::array::Array where T: ?c pub fn aya::maps::array::Array::borrow_mut(&mut self) -> &mut T 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> -impl core::convert::TryFrom for aya::maps::perf::AsyncPerfEventArray -pub type aya::maps::perf::AsyncPerfEventArray::Error = aya::maps::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 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 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 -impl core::marker::Sync for aya::maps::perf::AsyncPerfEventArray where T: core::marker::Sync + core::marker::Send -impl core::marker::Unpin for aya::maps::perf::AsyncPerfEventArray -impl core::panic::unwind_safe::RefUnwindSafe for aya::maps::perf::AsyncPerfEventArray where T: core::panic::unwind_safe::RefUnwindSafe -impl core::panic::unwind_safe::UnwindSafe for aya::maps::perf::AsyncPerfEventArray where T: core::panic::unwind_safe::RefUnwindSafe -impl core::convert::Into for aya::maps::perf::AsyncPerfEventArray where U: core::convert::From -pub fn aya::maps::perf::AsyncPerfEventArray::into(self) -> U -impl core::convert::TryFrom for aya::maps::perf::AsyncPerfEventArray where U: core::convert::Into -pub type aya::maps::perf::AsyncPerfEventArray::Error = core::convert::Infallible -pub fn aya::maps::perf::AsyncPerfEventArray::try_from(value: U) -> core::result::Result>::Error> -impl core::convert::TryInto for aya::maps::perf::AsyncPerfEventArray where U: core::convert::TryFrom -pub type aya::maps::perf::AsyncPerfEventArray::Error = >::Error -pub fn aya::maps::perf::AsyncPerfEventArray::try_into(self) -> core::result::Result>::Error> -impl core::any::Any for aya::maps::perf::AsyncPerfEventArray where T: 'static + ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArray::type_id(&self) -> core::any::TypeId -impl core::borrow::Borrow for aya::maps::perf::AsyncPerfEventArray where T: ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArray::borrow(&self) -> &T -impl core::borrow::BorrowMut for aya::maps::perf::AsyncPerfEventArray where T: ?core::marker::Sized -pub fn aya::maps::perf::AsyncPerfEventArray::borrow_mut(&mut self) -> &mut T -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>