From de42b80c74883f512542875e7cfa96b8634a8991 Mon Sep 17 00:00:00 2001 From: Tamir Duberstein Date: Thu, 2 Oct 2025 23:32:48 -0400 Subject: [PATCH] aya,ebpf: add BPF_MAP_TYPE_SK_STORAGE This map type requires BTF, and we can finally do it! --- aya/src/bpf.rs | 1 + aya/src/maps/mod.rs | 10 +- aya/src/maps/sk_storage.rs | 65 ++++++++++++ ebpf/aya-ebpf/src/btf_maps/mod.rs | 2 + ebpf/aya-ebpf/src/btf_maps/sk_storage.rs | 87 ++++++++++++++++ test-distro/src/init.rs | 8 ++ test/integration-common/src/lib.rs | 23 +++++ test/integration-ebpf/Cargo.toml | 4 + test/integration-ebpf/src/sk_storage.rs | 78 +++++++++++++++ test/integration-test/src/lib.rs | 1 + test/integration-test/src/tests.rs | 1 + test/integration-test/src/tests/sk_storage.rs | 98 +++++++++++++++++++ test/integration-test/src/utils.rs | 98 ++++++++++++++++++- xtask/public-api/aya-ebpf.txt | 82 ++++++++++++++++ xtask/public-api/aya.txt | 93 ++++++++++++++++++ 15 files changed, 649 insertions(+), 2 deletions(-) create mode 100644 aya/src/maps/sk_storage.rs create mode 100644 ebpf/aya-ebpf/src/btf_maps/sk_storage.rs create mode 100644 test/integration-ebpf/src/sk_storage.rs create mode 100644 test/integration-test/src/tests/sk_storage.rs diff --git a/aya/src/bpf.rs b/aya/src/bpf.rs index f3a9409d..fa4b1348 100644 --- a/aya/src/bpf.rs +++ b/aya/src/bpf.rs @@ -728,6 +728,7 @@ fn parse_map( BPF_MAP_TYPE_DEVMAP => Map::DevMap(map), BPF_MAP_TYPE_DEVMAP_HASH => Map::DevMapHash(map), BPF_MAP_TYPE_XSKMAP => Map::XskMap(map), + BPF_MAP_TYPE_SK_STORAGE => Map::SkStorage(map), m_type => { if allow_unsupported_maps { Map::Unsupported(map) diff --git a/aya/src/maps/mod.rs b/aya/src/maps/mod.rs index 905681ff..46077ae9 100644 --- a/aya/src/maps/mod.rs +++ b/aya/src/maps/mod.rs @@ -82,6 +82,7 @@ pub mod lpm_trie; pub mod perf; pub mod queue; pub mod ring_buf; +pub mod sk_storage; pub mod sock; pub mod stack; pub mod stack_trace; @@ -95,6 +96,7 @@ pub use lpm_trie::LpmTrie; pub use perf::PerfEventArray; pub use queue::Queue; pub use ring_buf::RingBuf; +pub use sk_storage::SkStorage; pub use sock::{SockHash, SockMap}; pub use stack::Stack; pub use stack_trace::StackTraceMap; @@ -303,6 +305,8 @@ pub enum Map { SockHash(MapData), /// A [`SockMap`] map. SockMap(MapData), + /// A [`SkStorage`] map. + SkStorage(MapData), /// A [`Stack`] map. Stack(MapData), /// A [`StackTraceMap`] map. @@ -334,6 +338,7 @@ impl Map { Self::RingBuf(map) => map.obj.map_type(), Self::SockHash(map) => map.obj.map_type(), Self::SockMap(map) => map.obj.map_type(), + Self::SkStorage(map) => map.obj.map_type(), Self::Stack(map) => map.obj.map_type(), Self::StackTraceMap(map) => map.obj.map_type(), Self::Unsupported(map) => map.obj.map_type(), @@ -364,6 +369,7 @@ impl Map { Self::RingBuf(map) => map.pin(path), Self::SockHash(map) => map.pin(path), Self::SockMap(map) => map.pin(path), + Self::SkStorage(map) => map.pin(path), Self::Stack(map) => map.pin(path), Self::StackTraceMap(map) => map.pin(path), Self::Unsupported(map) => map.pin(path), @@ -409,7 +415,7 @@ impl Map { bpf_map_type::BPF_MAP_TYPE_HASH_OF_MAPS => Self::Unsupported(map_data), bpf_map_type::BPF_MAP_TYPE_CGROUP_STORAGE_DEPRECATED => Self::Unsupported(map_data), bpf_map_type::BPF_MAP_TYPE_REUSEPORT_SOCKARRAY => Self::Unsupported(map_data), - bpf_map_type::BPF_MAP_TYPE_SK_STORAGE => Self::Unsupported(map_data), + bpf_map_type::BPF_MAP_TYPE_SK_STORAGE => Self::SkStorage(map_data), bpf_map_type::BPF_MAP_TYPE_STRUCT_OPS => Self::Unsupported(map_data), bpf_map_type::BPF_MAP_TYPE_INODE_STORAGE => Self::Unsupported(map_data), bpf_map_type::BPF_MAP_TYPE_TASK_STORAGE => Self::Unsupported(map_data), @@ -468,6 +474,7 @@ impl_map_pin!((V) { SockHash, BloomFilter, Queue, + SkStorage, Stack, }); @@ -546,6 +553,7 @@ impl_try_from_map!((V) { PerCpuArray, Queue, SockHash, + SkStorage, Stack, }); diff --git a/aya/src/maps/sk_storage.rs b/aya/src/maps/sk_storage.rs new file mode 100644 index 00000000..18d2580c --- /dev/null +++ b/aya/src/maps/sk_storage.rs @@ -0,0 +1,65 @@ +//! A socket local storage map backed by `BPF_MAP_TYPE_SK_STORAGE`. + +use std::{ + borrow::{Borrow, BorrowMut}, + marker::PhantomData, + os::fd::AsRawFd, +}; + +use crate::{ + Pod, + maps::{MapData, MapError, check_kv_size, hash_map}, +}; + +/// A socket local storage map backed by `BPF_MAP_TYPE_SK_STORAGE`. +/// +/// This map type stores values that are owned by individual sockets. The map keys are socket file +/// descriptors and the values can be accessed both from eBPF using [`bpf_sk_storage_get`] and from +/// user space through the methods on this type. +/// +/// [`bpf_sk_storage_get`]: https://elixir.bootlin.com/linux/v6.12/source/include/uapi/linux/bpf.h#L4064-L4093 +#[doc(alias = "BPF_MAP_TYPE_SK_STORAGE")] +#[derive(Debug)] +pub struct SkStorage { + pub(crate) inner: T, + _v: PhantomData, +} + +impl, V: Pod> SkStorage { + pub(crate) fn new(map: T) -> Result { + let data = map.borrow(); + check_kv_size::(data)?; + + Ok(Self { + inner: map, + _v: PhantomData, + }) + } + + /// Returns the value associated with `socket`. + pub fn get(&self, socket: &impl AsRawFd, flags: u64) -> Result { + hash_map::get(self.inner.borrow(), &socket.as_raw_fd(), flags) + } +} + +impl, V: Pod> SkStorage { + /// Creates or updates the value associated with `socket`. + pub fn insert( + &mut self, + socket: &impl AsRawFd, + value: impl Borrow, + flags: u64, + ) -> Result<(), MapError> { + hash_map::insert( + self.inner.borrow_mut(), + &socket.as_raw_fd(), + value.borrow(), + flags, + ) + } + + /// Removes the storage associated with `socket`. + pub fn remove(&mut self, socket: &impl AsRawFd) -> Result<(), MapError> { + hash_map::remove(self.inner.borrow_mut(), &socket.as_raw_fd()) + } +} diff --git a/ebpf/aya-ebpf/src/btf_maps/mod.rs b/ebpf/aya-ebpf/src/btf_maps/mod.rs index c0079c72..a65a4a7e 100644 --- a/ebpf/aya-ebpf/src/btf_maps/mod.rs +++ b/ebpf/aya-ebpf/src/btf_maps/mod.rs @@ -1,8 +1,10 @@ use core::marker::PhantomData; pub mod array; +pub mod sk_storage; pub use array::Array; +pub use sk_storage::SkStorage; /// A marker used to remove names of annotated types in LLVM debug info and /// therefore also in BTF. diff --git a/ebpf/aya-ebpf/src/btf_maps/sk_storage.rs b/ebpf/aya-ebpf/src/btf_maps/sk_storage.rs new file mode 100644 index 00000000..935bf1b4 --- /dev/null +++ b/ebpf/aya-ebpf/src/btf_maps/sk_storage.rs @@ -0,0 +1,87 @@ +use core::{cell::UnsafeCell, ptr}; + +use aya_ebpf_bindings::bindings::{ + BPF_F_NO_PREALLOC, BPF_SK_STORAGE_GET_F_CREATE, bpf_map_type::BPF_MAP_TYPE_SK_STORAGE, bpf_sock, +}; +use aya_ebpf_cty::{c_long, c_void}; + +use crate::{ + btf_map_def, + helpers::generated::{bpf_sk_storage_delete, bpf_sk_storage_get}, + programs::sock_addr::SockAddrContext, +}; + +btf_map_def!(SkStorageDef, BPF_MAP_TYPE_SK_STORAGE); + +// TODO(https://github.com/rust-lang/rust/issues/76560): this should be: +// +// { F | BPF_F_NO_PREALLOC as usize }. +#[repr(transparent)] +pub struct SkStorage(UnsafeCell>); + +unsafe impl Sync for SkStorage {} + +impl SkStorage { + #[expect( + clippy::new_without_default, + reason = "BPF maps are always used as static variables, therefore this method has to be `const`. `Default::default` is not `const`." + )] + pub const fn new() -> Self { + Self(UnsafeCell::new(SkStorageDef::new())) + } + + #[inline(always)] + fn as_ptr(&self) -> *mut c_void { + let Self(inner) = self; + + inner.get().cast() + } + + #[inline(always)] + fn get_ptr(&self, ctx: &SockAddrContext, value: *mut T, flags: u64) -> *mut T { + let sock_addr = unsafe { &*ctx.sock_addr }; + let sk = unsafe { sock_addr.__bindgen_anon_1.sk }; + unsafe { bpf_sk_storage_get(self.as_ptr(), sk.cast(), value.cast(), flags) }.cast::() + } + + /// Gets a mutable reference to the value associated with `sk`. + /// + /// # Safety + /// + /// This function may dereference the pointer `sk`. + #[inline(always)] + pub unsafe fn get_ptr_mut(&self, ctx: &SockAddrContext) -> *mut T { + self.get_ptr(ctx, ptr::null_mut(), 0) + } + + /// Gets a mutable reference to the value associated with `sk`. + /// + /// If no value is associated with `sk`, `value` will be inserted.` + /// + /// # Safety + /// + /// This function may dereference the pointer `sk`. + #[inline(always)] + pub unsafe fn get_or_insert_ptr_mut( + &self, + ctx: &SockAddrContext, + value: Option<&mut T>, + ) -> *mut T { + self.get_ptr( + ctx, + value.map_or(ptr::null_mut(), ptr::from_mut), + BPF_SK_STORAGE_GET_F_CREATE.into(), + ) + } + + /// Deletes the value associated with `sk`. + /// + /// # Safety + /// + /// This function may dereference the pointer `sk`. + #[inline(always)] + pub unsafe fn delete(&self, sk: *mut bpf_sock) -> Result<(), c_long> { + let ret = unsafe { bpf_sk_storage_delete(self.as_ptr(), sk.cast()) }; + if ret == 0 { Ok(()) } else { Err(ret) } + } +} diff --git a/test-distro/src/init.rs b/test-distro/src/init.rs index e9030bc7..ccc8cdfc 100644 --- a/test-distro/src/init.rs +++ b/test-distro/src/init.rs @@ -89,6 +89,14 @@ fn run() -> anyhow::Result<()> { data: None, target_mode: None, }, + Mount { + source: "cgroup2", + target: "/sys/fs/cgroup", + fstype: "cgroup2", + flags: nix::mount::MsFlags::empty(), + data: None, + target_mode: None, + }, ] { match target_mode { None => { diff --git a/test/integration-common/src/lib.rs b/test/integration-common/src/lib.rs index 8932c15d..89179841 100644 --- a/test/integration-common/src/lib.rs +++ b/test/integration-common/src/lib.rs @@ -89,3 +89,26 @@ pub mod linear_data_structures { pub const PEEK_INDEX: u32 = 0; pub const POP_INDEX: u32 = 1; } + +pub mod sk_storage { + #[derive(Clone, Copy, Debug, Eq, PartialEq)] + #[repr(C)] + pub enum Ip { + V4(u32), + V6([u32; 4]), + } + + #[derive(Clone, Copy, Debug, Eq, PartialEq)] + #[repr(C)] + pub struct Value { + pub user_family: u32, + pub user_ip: Ip, + pub user_port: u32, + pub family: u32, + pub type_: u32, + pub protocol: u32, + } + + #[cfg(feature = "user")] + unsafe impl aya::Pod for Value {} +} diff --git a/test/integration-ebpf/Cargo.toml b/test/integration-ebpf/Cargo.toml index d4d6da59..cb52e728 100644 --- a/test/integration-ebpf/Cargo.toml +++ b/test/integration-ebpf/Cargo.toml @@ -72,6 +72,10 @@ path = "src/relocations.rs" name = "ring_buf" path = "src/ring_buf.rs" +[[bin]] +name = "sk_storage" +path = "src/sk_storage.rs" + [[bin]] name = "simple_prog" path = "src/simple_prog.rs" diff --git a/test/integration-ebpf/src/sk_storage.rs b/test/integration-ebpf/src/sk_storage.rs new file mode 100644 index 00000000..c6da2876 --- /dev/null +++ b/test/integration-ebpf/src/sk_storage.rs @@ -0,0 +1,78 @@ +#![no_std] +#![no_main] +#![expect(unused_crate_dependencies, reason = "used in other bins")] + +use aya_ebpf::{ + bindings::sk_action, + btf_maps::SkStorage, + macros::{btf_map, cgroup_sock_addr}, + programs::SockAddrContext, +}; +use integration_common::sk_storage::{Ip, Value}; +#[cfg(not(test))] +extern crate ebpf_panic; + +#[btf_map] +static SOCKET_STORAGE: SkStorage = SkStorage::new(); + +#[cgroup_sock_addr(connect4)] +pub(crate) fn sk_storage_connect4(ctx: SockAddrContext) -> i32 { + let sock_addr = unsafe { &*ctx.sock_addr }; + + let storage = unsafe { SOCKET_STORAGE.get_or_insert_ptr_mut(&ctx, None) }; + if !storage.is_null() { + unsafe { + *storage = Value { + user_family: sock_addr.user_family, + user_ip: Ip::V4(sock_addr.user_ip4), + user_port: sock_addr.user_port, + family: sock_addr.family, + type_: sock_addr.type_, + protocol: sock_addr.protocol, + } + } + } + + sk_action::SK_PASS as _ +} + +#[cgroup_sock_addr(connect6)] +pub(crate) fn sk_storage_connect6(ctx: SockAddrContext) -> i32 { + let sock_addr = unsafe { &*ctx.sock_addr }; + + let storage = unsafe { SOCKET_STORAGE.get_or_insert_ptr_mut(&ctx, None) }; + if !storage.is_null() { + let mut user_ip6 = [0u32; 4]; + unsafe { + // Verifier dislikes the naive thing: + // + // ; let sk = unsafe { sock_addr.__bindgen_anon_1.sk }; + // 0: (79) r2 = *(u64 *)(r1 +64) ; R1=ctx(off=0,imm=0) R2_w=sock(off=0,imm=0) + // ; user_family: sock_addr.user_family, + // 1: (61) r3 = *(u32 *)(r1 +0) ; R1=ctx(off=0,imm=0) R3_w=scalar(umax=4294967295,var_off=(0x0; 0xffffffff)) + // ; user_ip: Ip::V6(sock_addr.user_ip6), + // 2: (bf) r4 = r1 ; R1=ctx(off=0,imm=0) R4_w=ctx(off=0,imm=0) + // 3: (07) r4 += 8 ; R4_w=ctx(off=8,imm=0) + // ; let mut value = Value { + // 4: (bf) r5 = r10 ; R5_w=fp0 R10=fp0 + // 5: (07) r5 += -32 ; R5_w=fp-32 + // ; user_ip: Ip::V6(sock_addr.user_ip6), + // 6: (61) r0 = *(u32 *)(r4 +0) + // dereference of modified ctx ptr R4 off=8 disallowed + user_ip6[0] = sock_addr.user_ip6[0]; + user_ip6[1] = sock_addr.user_ip6[1]; + user_ip6[2] = sock_addr.user_ip6[2]; + user_ip6[3] = sock_addr.user_ip6[3]; + *storage = Value { + user_family: sock_addr.user_family, + user_ip: Ip::V6(user_ip6), + user_port: sock_addr.user_port, + family: sock_addr.family, + type_: sock_addr.type_, + protocol: sock_addr.protocol, + } + } + } + + sk_action::SK_PASS as _ +} diff --git a/test/integration-test/src/lib.rs b/test/integration-test/src/lib.rs index f7da1d9f..64f37d18 100644 --- a/test/integration-test/src/lib.rs +++ b/test/integration-test/src/lib.rs @@ -51,6 +51,7 @@ bpf_file!( RELOCATIONS => "relocations", RING_BUF => "ring_buf", SIMPLE_PROG => "simple_prog", + SK_STORAGE => "sk_storage", STRNCMP => "strncmp", TCX => "tcx", TEST => "test", diff --git a/test/integration-test/src/tests.rs b/test/integration-test/src/tests.rs index 0e376c5a..aafc4f36 100644 --- a/test/integration-test/src/tests.rs +++ b/test/integration-test/src/tests.rs @@ -13,6 +13,7 @@ mod raw_tracepoint; mod rbpf; mod relocations; mod ring_buf; +mod sk_storage; mod smoke; mod strncmp; mod tcx; diff --git a/test/integration-test/src/tests/sk_storage.rs b/test/integration-test/src/tests/sk_storage.rs new file mode 100644 index 00000000..ba37515d --- /dev/null +++ b/test/integration-test/src/tests/sk_storage.rs @@ -0,0 +1,98 @@ +use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, TcpListener, TcpStream}; + +use assert_matches::assert_matches; +use aya::{ + EbpfLoader, + maps::{MapError, SkStorage}, + programs::{CgroupAttachMode, CgroupSockAddr}, +}; +use integration_common::sk_storage::{Ip, Value}; +use libc::{self}; +use test_log::test; + +use crate::utils::{Cgroup, NetNsGuard}; + +#[test] +fn sk_storage_connect() { + let mut ebpf = EbpfLoader::new().load(crate::SK_STORAGE).unwrap(); + + let storage = ebpf.take_map("SOCKET_STORAGE").unwrap(); + let mut storage = SkStorage::<_, Value>::try_from(storage).unwrap(); + + let _netns = NetNsGuard::new(); + let root_cgroup = Cgroup::root(); + let cgroup = root_cgroup.create_child("aya-test-sk-storage"); + let cgroup_fd = cgroup.fd(); + + let guards = ebpf + .programs_mut() + .map(|(name, prog)| { + let prog: &mut CgroupSockAddr = prog.try_into().expect(name); + prog.load().expect(name); + let link_id = prog + .attach(cgroup_fd, CgroupAttachMode::Single) + .expect(name); + scopeguard::guard((), |()| { + prog.detach(link_id).expect(name); + }) + }) + .collect::>(); + + let cgroup = cgroup.into_cgroup(); + cgroup.write_pid(std::process::id()); + + let listener4 = TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).unwrap(); + let addr4 = listener4.local_addr().unwrap(); + let listener6 = TcpListener::bind((Ipv6Addr::LOCALHOST, 0)).unwrap(); + let addr6 = listener6.local_addr().unwrap(); + + { + let client4 = TcpStream::connect(addr4).unwrap(); + assert_matches!(storage.get(&client4, 0), Ok(value4) => { + assert_eq!(value4, expected_value(&addr4)); + }); + storage.remove(&client4).unwrap(); + assert_matches!(storage.get(&client4, 0), Err(MapError::KeyNotFound)); + + let client6 = TcpStream::connect(addr6).unwrap(); + assert_matches!(storage.get(&client6, 0), Ok(value6) => { + assert_eq!(value6, expected_value(&addr6)); + }); + storage.remove(&client6).unwrap(); + assert_matches!(storage.get(&client6, 0), Err(MapError::KeyNotFound)); + } + + // Detach. + drop(guards); + + { + let client4 = TcpStream::connect(addr4).unwrap(); + assert_matches!(storage.get(&client4, 0), Err(MapError::KeyNotFound)); + + let client6 = TcpStream::connect(addr6).unwrap(); + assert_matches!(storage.get(&client6, 0), Err(MapError::KeyNotFound)); + } +} + +fn expected_value(addr: &SocketAddr) -> Value { + match addr { + SocketAddr::V4(addr) => Value { + user_family: libc::AF_INET as u32, + user_ip: Ip::V4(u32::from_ne_bytes(addr.ip().octets())), + user_port: u32::from(addr.port().to_be()), + family: libc::AF_INET as u32, + type_: libc::SOCK_STREAM as u32, + protocol: libc::IPPROTO_TCP as u32, + }, + SocketAddr::V6(addr) => Value { + user_family: libc::AF_INET6 as u32, + user_ip: Ip::V6(unsafe { + core::mem::transmute::<[u8; 16], [u32; 4]>(addr.ip().octets()) + }), + user_port: u32::from(addr.port().to_be()), + family: libc::AF_INET6 as u32, + type_: libc::SOCK_STREAM as u32, + protocol: libc::IPPROTO_TCP as u32, + }, + } +} diff --git a/test/integration-test/src/utils.rs b/test/integration-test/src/utils.rs index bd1504d6..6a53775e 100644 --- a/test/integration-test/src/utils.rs +++ b/test/integration-test/src/utils.rs @@ -1,8 +1,13 @@ //! Utilities to run tests use std::{ + borrow::Cow, + cell::OnceCell, ffi::CString, - io, process, + fs, + io::{self, Write as _}, + path::Path, + process, sync::atomic::{AtomicU64, Ordering}, }; @@ -10,6 +15,97 @@ use aya::netlink_set_link_up; use libc::if_nametoindex; use netns_rs::{NetNs, get_from_current_thread}; +const CGROUP_ROOT: &str = "/sys/fs/cgroup"; +const CGROUP_PROCS: &str = "cgroup.procs"; + +pub(crate) struct ChildCgroup<'a> { + parent: &'a Cgroup<'a>, + path: Cow<'a, Path>, + fd: OnceCell, +} + +pub(crate) enum Cgroup<'a> { + Root, + Child(ChildCgroup<'a>), +} + +impl Cgroup<'static> { + pub(crate) fn root() -> Self { + Self::Root + } +} + +impl<'a> Cgroup<'a> { + fn path(&self) -> &Path { + match self { + Self::Root => Path::new(CGROUP_ROOT), + Self::Child(ChildCgroup { + parent: _, + path, + fd: _, + }) => path, + } + } + + pub(crate) fn create_child(&'a self, name: &str) -> ChildCgroup<'a> { + let path = self.path().join(name); + fs::create_dir(&path).unwrap(); + + ChildCgroup { + parent: self, + path: path.into(), + fd: OnceCell::new(), + } + } + + pub(crate) fn write_pid(&self, pid: u32) { + fs::write(self.path().join(CGROUP_PROCS), format!("{pid}\n")).unwrap(); + } +} + +impl<'a> ChildCgroup<'a> { + pub(crate) fn fd(&self) -> &fs::File { + let Self { + parent: _, + path, + fd, + } = self; + fd.get_or_init(|| { + fs::OpenOptions::new() + .read(true) + .open(path.as_ref()) + .unwrap() + }) + } + + pub(crate) fn into_cgroup(self) -> Cgroup<'a> { + Cgroup::Child(self) + } +} + +impl Drop for ChildCgroup<'_> { + fn drop(&mut self) { + let Self { + parent, + path, + fd: _, + } = self; + + let pids = fs::read_to_string(path.as_ref().join(CGROUP_PROCS)).unwrap(); + let mut dst = fs::OpenOptions::new() + .append(true) + .open(parent.path().join(CGROUP_PROCS)) + .unwrap(); + for pid in pids.split_inclusive('\n') { + dst.write_all(pid.as_bytes()).unwrap(); + } + + if let Err(e) = fs::remove_dir(&path) { + eprintln!("failed to remove {}: {e}", path.display()); + } + } +} + pub(crate) struct NetNsGuard { name: String, old_ns: NetNs, diff --git a/xtask/public-api/aya-ebpf.txt b/xtask/public-api/aya-ebpf.txt index b9cc7957..e43ff231 100644 --- a/xtask/public-api/aya-ebpf.txt +++ b/xtask/public-api/aya-ebpf.txt @@ -58,6 +58,60 @@ impl core::borrow::BorrowMut for aya_ebpf::btf_maps::array::ArrayDef::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya_ebpf::btf_maps::array::ArrayDef pub fn aya_ebpf::btf_maps::array::ArrayDef::from(t: T) -> T +pub mod aya_ebpf::btf_maps::sk_storage +#[repr(transparent)] pub struct aya_ebpf::btf_maps::sk_storage::SkStorage(_) +impl aya_ebpf::btf_maps::sk_storage::SkStorage +pub unsafe fn aya_ebpf::btf_maps::sk_storage::SkStorage::delete(&self, sk: *mut aya_ebpf_bindings::x86_64::bindings::bpf_sock) -> core::result::Result<(), aya_ebpf_cty::od::c_long> +pub unsafe fn aya_ebpf::btf_maps::sk_storage::SkStorage::get_or_insert_ptr_mut(&self, ctx: &aya_ebpf::programs::sock_addr::SockAddrContext, value: core::option::Option<&mut T>) -> *mut T +pub unsafe fn aya_ebpf::btf_maps::sk_storage::SkStorage::get_ptr_mut(&self, ctx: &aya_ebpf::programs::sock_addr::SockAddrContext) -> *mut T +pub const fn aya_ebpf::btf_maps::sk_storage::SkStorage::new() -> Self +impl core::marker::Sync for aya_ebpf::btf_maps::sk_storage::SkStorage +impl !core::marker::Freeze for aya_ebpf::btf_maps::sk_storage::SkStorage +impl !core::marker::Send for aya_ebpf::btf_maps::sk_storage::SkStorage +impl core::marker::Unpin for aya_ebpf::btf_maps::sk_storage::SkStorage +impl !core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorage +impl core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorage where T: core::panic::unwind_safe::RefUnwindSafe +impl core::convert::Into for aya_ebpf::btf_maps::sk_storage::SkStorage where U: core::convert::From +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::into(self) -> U +impl core::convert::TryFrom for aya_ebpf::btf_maps::sk_storage::SkStorage where U: core::convert::Into +pub type aya_ebpf::btf_maps::sk_storage::SkStorage::Error = core::convert::Infallible +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya_ebpf::btf_maps::sk_storage::SkStorage where U: core::convert::TryFrom +pub type aya_ebpf::btf_maps::sk_storage::SkStorage::Error = >::Error +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::try_into(self) -> core::result::Result>::Error> +impl core::any::Any for aya_ebpf::btf_maps::sk_storage::SkStorage where T: 'static + ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya_ebpf::btf_maps::sk_storage::SkStorage where T: ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya_ebpf::btf_maps::sk_storage::SkStorage where T: ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya_ebpf::btf_maps::sk_storage::SkStorage +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::from(t: T) -> T +pub struct aya_ebpf::btf_maps::sk_storage::SkStorageDef +impl aya_ebpf::btf_maps::sk_storage::SkStorageDef +pub const fn aya_ebpf::btf_maps::sk_storage::SkStorageDef::new() -> aya_ebpf::btf_maps::sk_storage::SkStorageDef +impl core::marker::Freeze for aya_ebpf::btf_maps::sk_storage::SkStorageDef +impl !core::marker::Send for aya_ebpf::btf_maps::sk_storage::SkStorageDef +impl !core::marker::Sync for aya_ebpf::btf_maps::sk_storage::SkStorageDef +impl core::marker::Unpin for aya_ebpf::btf_maps::sk_storage::SkStorageDef +impl core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorageDef where K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe +impl core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorageDef where K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe +impl core::convert::Into for aya_ebpf::btf_maps::sk_storage::SkStorageDef where U: core::convert::From +pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef::into(self) -> U +impl core::convert::TryFrom for aya_ebpf::btf_maps::sk_storage::SkStorageDef where U: core::convert::Into +pub type aya_ebpf::btf_maps::sk_storage::SkStorageDef::Error = core::convert::Infallible +pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya_ebpf::btf_maps::sk_storage::SkStorageDef where U: core::convert::TryFrom +pub type aya_ebpf::btf_maps::sk_storage::SkStorageDef::Error = >::Error +pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef::try_into(self) -> core::result::Result>::Error> +impl core::any::Any for aya_ebpf::btf_maps::sk_storage::SkStorageDef where T: 'static + ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya_ebpf::btf_maps::sk_storage::SkStorageDef where T: ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya_ebpf::btf_maps::sk_storage::SkStorageDef where T: ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya_ebpf::btf_maps::sk_storage::SkStorageDef +pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef::from(t: T) -> T #[repr(transparent)] pub struct aya_ebpf::btf_maps::Array(_) impl aya_ebpf::btf_maps::array::Array pub fn aya_ebpf::btf_maps::array::Array::get(&self, index: u32) -> core::option::Option<&T> @@ -87,6 +141,34 @@ impl core::borrow::BorrowMut for aya_ebpf::btf_maps::array::Array pub fn aya_ebpf::btf_maps::array::Array::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya_ebpf::btf_maps::array::Array pub fn aya_ebpf::btf_maps::array::Array::from(t: T) -> T +#[repr(transparent)] pub struct aya_ebpf::btf_maps::SkStorage(_) +impl aya_ebpf::btf_maps::sk_storage::SkStorage +pub unsafe fn aya_ebpf::btf_maps::sk_storage::SkStorage::delete(&self, sk: *mut aya_ebpf_bindings::x86_64::bindings::bpf_sock) -> core::result::Result<(), aya_ebpf_cty::od::c_long> +pub unsafe fn aya_ebpf::btf_maps::sk_storage::SkStorage::get_or_insert_ptr_mut(&self, ctx: &aya_ebpf::programs::sock_addr::SockAddrContext, value: core::option::Option<&mut T>) -> *mut T +pub unsafe fn aya_ebpf::btf_maps::sk_storage::SkStorage::get_ptr_mut(&self, ctx: &aya_ebpf::programs::sock_addr::SockAddrContext) -> *mut T +pub const fn aya_ebpf::btf_maps::sk_storage::SkStorage::new() -> Self +impl core::marker::Sync for aya_ebpf::btf_maps::sk_storage::SkStorage +impl !core::marker::Freeze for aya_ebpf::btf_maps::sk_storage::SkStorage +impl !core::marker::Send for aya_ebpf::btf_maps::sk_storage::SkStorage +impl core::marker::Unpin for aya_ebpf::btf_maps::sk_storage::SkStorage +impl !core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorage +impl core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorage where T: core::panic::unwind_safe::RefUnwindSafe +impl core::convert::Into for aya_ebpf::btf_maps::sk_storage::SkStorage where U: core::convert::From +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::into(self) -> U +impl core::convert::TryFrom for aya_ebpf::btf_maps::sk_storage::SkStorage where U: core::convert::Into +pub type aya_ebpf::btf_maps::sk_storage::SkStorage::Error = core::convert::Infallible +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya_ebpf::btf_maps::sk_storage::SkStorage where U: core::convert::TryFrom +pub type aya_ebpf::btf_maps::sk_storage::SkStorage::Error = >::Error +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::try_into(self) -> core::result::Result>::Error> +impl core::any::Any for aya_ebpf::btf_maps::sk_storage::SkStorage where T: 'static + ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya_ebpf::btf_maps::sk_storage::SkStorage where T: ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya_ebpf::btf_maps::sk_storage::SkStorage where T: ?core::marker::Sized +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya_ebpf::btf_maps::sk_storage::SkStorage +pub fn aya_ebpf::btf_maps::sk_storage::SkStorage::from(t: T) -> T pub mod aya_ebpf::helpers pub use aya_ebpf::helpers::generated pub macro aya_ebpf::helpers::bpf_printk! diff --git a/xtask/public-api/aya.txt b/xtask/public-api/aya.txt index 29238bc6..34006803 100644 --- a/xtask/public-api/aya.txt +++ b/xtask/public-api/aya.txt @@ -606,6 +606,48 @@ impl core::borrow::BorrowMut for aya::maps::ring_buf::RingBufItem<'a> wher pub fn aya::maps::ring_buf::RingBufItem<'a>::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::maps::ring_buf::RingBufItem<'a> pub fn aya::maps::ring_buf::RingBufItem<'a>::from(t: T) -> T +pub mod aya::maps::sk_storage +pub struct aya::maps::sk_storage::SkStorage +impl, V: aya::Pod> aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::get(&self, socket: &impl std::os::fd::raw::AsRawFd, flags: u64) -> core::result::Result +impl, V: aya::Pod> aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +impl, V: aya::Pod> aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::insert(&mut self, socket: &impl std::os::fd::raw::AsRawFd, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::sk_storage::SkStorage::remove(&mut self, socket: &impl std::os::fd::raw::AsRawFd) -> core::result::Result<(), aya::maps::MapError> +impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::sk_storage::SkStorage<&'a aya::maps::MapData, V> +pub type aya::maps::sk_storage::SkStorage<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage<&'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::sk_storage::SkStorage<&'a mut aya::maps::MapData, V> +pub type aya::maps::sk_storage::SkStorage<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result +impl core::fmt::Debug for aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::convert::TryFrom for aya::maps::sk_storage::SkStorage +pub type aya::maps::sk_storage::SkStorage::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage::try_from(map: aya::maps::Map) -> core::result::Result +impl core::marker::Freeze for aya::maps::sk_storage::SkStorage where T: core::marker::Freeze +impl core::marker::Send for aya::maps::sk_storage::SkStorage where T: core::marker::Send, V: core::marker::Send +impl core::marker::Sync for aya::maps::sk_storage::SkStorage where T: core::marker::Sync, V: core::marker::Sync +impl core::marker::Unpin for aya::maps::sk_storage::SkStorage where T: core::marker::Unpin, V: core::marker::Unpin +impl core::panic::unwind_safe::RefUnwindSafe for aya::maps::sk_storage::SkStorage where T: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe +impl core::panic::unwind_safe::UnwindSafe for aya::maps::sk_storage::SkStorage where T: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe +impl core::convert::Into for aya::maps::sk_storage::SkStorage where U: core::convert::From +pub fn aya::maps::sk_storage::SkStorage::into(self) -> U +impl core::convert::TryFrom for aya::maps::sk_storage::SkStorage where U: core::convert::Into +pub type aya::maps::sk_storage::SkStorage::Error = core::convert::Infallible +pub fn aya::maps::sk_storage::SkStorage::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya::maps::sk_storage::SkStorage where U: core::convert::TryFrom +pub type aya::maps::sk_storage::SkStorage::Error = >::Error +pub fn aya::maps::sk_storage::SkStorage::try_into(self) -> core::result::Result>::Error> +impl core::any::Any for aya::maps::sk_storage::SkStorage where T: 'static + ?core::marker::Sized +pub fn aya::maps::sk_storage::SkStorage::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya::maps::sk_storage::SkStorage where T: ?core::marker::Sized +pub fn aya::maps::sk_storage::SkStorage::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya::maps::sk_storage::SkStorage where T: ?core::marker::Sized +pub fn aya::maps::sk_storage::SkStorage::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::from(t: T) -> T pub mod aya::maps::sock pub struct aya::maps::sock::SockHash impl, K: aya::Pod> aya::maps::SockHash @@ -1074,6 +1116,7 @@ pub aya::maps::Map::PerfEventArray(aya::maps::MapData) pub aya::maps::Map::ProgramArray(aya::maps::MapData) pub aya::maps::Map::Queue(aya::maps::MapData) pub aya::maps::Map::RingBuf(aya::maps::MapData) +pub aya::maps::Map::SkStorage(aya::maps::MapData) pub aya::maps::Map::SockHash(aya::maps::MapData) pub aya::maps::Map::SockMap(aya::maps::MapData) pub aya::maps::Map::Stack(aya::maps::MapData) @@ -1145,6 +1188,9 @@ pub fn aya::maps::bloom_filter::BloomFilter<&'a aya::maps::MapData, V>::try_from 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 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::sk_storage::SkStorage<&'a aya::maps::MapData, V> +pub type aya::maps::sk_storage::SkStorage<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage<&'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 fn aya::maps::stack::Stack<&'a aya::maps::MapData, V>::try_from(map: &'a aya::maps::Map) -> core::result::Result @@ -1163,6 +1209,9 @@ pub fn aya::maps::bloom_filter::BloomFilter<&'a mut aya::maps::MapData, V>::try_ 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 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::sk_storage::SkStorage<&'a mut aya::maps::MapData, V> +pub type aya::maps::sk_storage::SkStorage<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage<&'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 fn aya::maps::stack::Stack<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result @@ -1244,6 +1293,9 @@ pub fn aya::maps::bloom_filter::BloomFilter::try_from(map impl core::convert::TryFrom for aya::maps::queue::Queue pub type aya::maps::queue::Queue::Error = aya::maps::MapError pub fn aya::maps::queue::Queue::try_from(map: aya::maps::Map) -> core::result::Result +impl core::convert::TryFrom for aya::maps::sk_storage::SkStorage +pub type aya::maps::sk_storage::SkStorage::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage::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 fn aya::maps::stack::Stack::try_from(map: aya::maps::Map) -> core::result::Result @@ -2145,6 +2197,47 @@ impl core::borrow::BorrowMut for aya::maps::ring_buf::RingBuf where T: pub fn aya::maps::ring_buf::RingBuf::borrow_mut(&mut self) -> &mut T impl core::convert::From for aya::maps::ring_buf::RingBuf pub fn aya::maps::ring_buf::RingBuf::from(t: T) -> T +pub struct aya::maps::SkStorage +impl, V: aya::Pod> aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::get(&self, socket: &impl std::os::fd::raw::AsRawFd, flags: u64) -> core::result::Result +impl, V: aya::Pod> aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::pin>(self, path: P) -> core::result::Result<(), aya::pin::PinError> +impl, V: aya::Pod> aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::insert(&mut self, socket: &impl std::os::fd::raw::AsRawFd, value: impl core::borrow::Borrow, flags: u64) -> core::result::Result<(), aya::maps::MapError> +pub fn aya::maps::sk_storage::SkStorage::remove(&mut self, socket: &impl std::os::fd::raw::AsRawFd) -> core::result::Result<(), aya::maps::MapError> +impl<'a, V: aya::Pod> core::convert::TryFrom<&'a aya::maps::Map> for aya::maps::sk_storage::SkStorage<&'a aya::maps::MapData, V> +pub type aya::maps::sk_storage::SkStorage<&'a aya::maps::MapData, V>::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage<&'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::sk_storage::SkStorage<&'a mut aya::maps::MapData, V> +pub type aya::maps::sk_storage::SkStorage<&'a mut aya::maps::MapData, V>::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage<&'a mut aya::maps::MapData, V>::try_from(map: &'a mut aya::maps::Map) -> core::result::Result +impl core::fmt::Debug for aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result +impl core::convert::TryFrom for aya::maps::sk_storage::SkStorage +pub type aya::maps::sk_storage::SkStorage::Error = aya::maps::MapError +pub fn aya::maps::sk_storage::SkStorage::try_from(map: aya::maps::Map) -> core::result::Result +impl core::marker::Freeze for aya::maps::sk_storage::SkStorage where T: core::marker::Freeze +impl core::marker::Send for aya::maps::sk_storage::SkStorage where T: core::marker::Send, V: core::marker::Send +impl core::marker::Sync for aya::maps::sk_storage::SkStorage where T: core::marker::Sync, V: core::marker::Sync +impl core::marker::Unpin for aya::maps::sk_storage::SkStorage where T: core::marker::Unpin, V: core::marker::Unpin +impl core::panic::unwind_safe::RefUnwindSafe for aya::maps::sk_storage::SkStorage where T: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe +impl core::panic::unwind_safe::UnwindSafe for aya::maps::sk_storage::SkStorage where T: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe +impl core::convert::Into for aya::maps::sk_storage::SkStorage where U: core::convert::From +pub fn aya::maps::sk_storage::SkStorage::into(self) -> U +impl core::convert::TryFrom for aya::maps::sk_storage::SkStorage where U: core::convert::Into +pub type aya::maps::sk_storage::SkStorage::Error = core::convert::Infallible +pub fn aya::maps::sk_storage::SkStorage::try_from(value: U) -> core::result::Result>::Error> +impl core::convert::TryInto for aya::maps::sk_storage::SkStorage where U: core::convert::TryFrom +pub type aya::maps::sk_storage::SkStorage::Error = >::Error +pub fn aya::maps::sk_storage::SkStorage::try_into(self) -> core::result::Result>::Error> +impl core::any::Any for aya::maps::sk_storage::SkStorage where T: 'static + ?core::marker::Sized +pub fn aya::maps::sk_storage::SkStorage::type_id(&self) -> core::any::TypeId +impl core::borrow::Borrow for aya::maps::sk_storage::SkStorage where T: ?core::marker::Sized +pub fn aya::maps::sk_storage::SkStorage::borrow(&self) -> &T +impl core::borrow::BorrowMut for aya::maps::sk_storage::SkStorage where T: ?core::marker::Sized +pub fn aya::maps::sk_storage::SkStorage::borrow_mut(&mut self) -> &mut T +impl core::convert::From for aya::maps::sk_storage::SkStorage +pub fn aya::maps::sk_storage::SkStorage::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