aya,ebpf: add BPF_MAP_TYPE_SK_STORAGE

This map type requires BTF, and we can finally do it!

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)

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,
 });
 

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<T, V: Pod> {
+    pub(crate) inner: T,
+    _v: PhantomData<V>,
+}
+
+impl<T: Borrow<MapData>, V: Pod> SkStorage<T, V> {
+    pub(crate) fn new(map: T) -> Result<Self, MapError> {
+        let data = map.borrow();
+        check_kv_size::<i32, V>(data)?;
+
+        Ok(Self {
+            inner: map,
+            _v: PhantomData,
+        })
+    }
+
+    /// Returns the value associated with `socket`.
+    pub fn get(&self, socket: &impl AsRawFd, flags: u64) -> Result<V, MapError> {
+        hash_map::get(self.inner.borrow(), &socket.as_raw_fd(), flags)
+    }
+}
+
+impl<T: BorrowMut<MapData>, V: Pod> SkStorage<T, V> {
+    /// Creates or updates the value associated with `socket`.
+    pub fn insert(
+        &mut self,
+        socket: &impl AsRawFd,
+        value: impl Borrow<V>,
+        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())
+    }
+}

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.

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<T>(UnsafeCell<SkStorageDef<i32, T, 0, { BPF_F_NO_PREALLOC as usize }>>);
+
+unsafe impl<T: Sync> Sync for SkStorage<T> {}
+
+impl<T> SkStorage<T> {
+    #[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::<T>()
+    }
+
+    /// 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) }
+    }
+}

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 => {

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 {}
+}

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"

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<Value> = 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 _
+}

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",

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;

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::<Vec<_>>();
+
+    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,
+        },
+    }
+}

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<fs::File>,
+}
+
+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,

xtask/public-api/aya-ebpf.txt

@@ -58,6 +58,60 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::array::ArrayDef<K, V,
 pub fn aya_ebpf::btf_maps::array::ArrayDef<K, V, M, F>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::btf_maps::array::ArrayDef<K, V, M, F>
 pub fn aya_ebpf::btf_maps::array::ArrayDef<K, V, M, F>::from(t: T) -> T
+pub mod aya_ebpf::btf_maps::sk_storage
+#[repr(transparent)] pub struct aya_ebpf::btf_maps::sk_storage::SkStorage<T>(_)
+impl<T> aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+pub unsafe fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::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<T>::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<T>::get_ptr_mut(&self, ctx: &aya_ebpf::programs::sock_addr::SockAddrContext) -> *mut T
+pub const fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::new() -> Self
+impl<T: core::marker::Sync> core::marker::Sync for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> !core::marker::Freeze for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> !core::marker::Send for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> core::marker::Unpin for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> !core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where U: core::convert::From<T>
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where U: core::convert::Into<T>
+pub type aya_ebpf::btf_maps::sk_storage::SkStorage<T>::Error = core::convert::Infallible
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::btf_maps::sk_storage::SkStorage<T>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::from(t: T) -> T
+pub struct aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, const M: usize, const F: usize>
+impl<K, V, const M: usize, const F: usize> aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>
+pub const fn aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::new() -> aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>
+impl<K, V, const M: usize, const F: usize> core::marker::Freeze for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>
+impl<K, V, const M: usize, const F: usize> !core::marker::Send for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>
+impl<K, V, const M: usize, const F: usize> !core::marker::Sync for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>
+impl<K, V, const M: usize, const F: usize> core::marker::Unpin for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>
+impl<K, V, const M: usize, const F: usize> core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F> where K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<K, V, const M: usize, const F: usize> core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F> where K: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F> where U: core::convert::From<T>
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F> where U: core::convert::Into<T>
+pub type aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::Error = core::convert::Infallible
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorageDef<K, V, M, F>::from(t: T) -> T
 #[repr(transparent)] pub struct aya_ebpf::btf_maps::Array<T, const M: usize, const F: usize>(_)
 impl<T, const M: usize, const F: usize> aya_ebpf::btf_maps::array::Array<T, M, F>
 pub fn aya_ebpf::btf_maps::array::Array<T, M, F>::get(&self, index: u32) -> core::option::Option<&T>
@@ -87,6 +141,34 @@ impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::array::Array<T, M, F>
 pub fn aya_ebpf::btf_maps::array::Array<T, M, F>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya_ebpf::btf_maps::array::Array<T, M, F>
 pub fn aya_ebpf::btf_maps::array::Array<T, M, F>::from(t: T) -> T
+#[repr(transparent)] pub struct aya_ebpf::btf_maps::SkStorage<T>(_)
+impl<T> aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+pub unsafe fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::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<T>::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<T>::get_ptr_mut(&self, ctx: &aya_ebpf::programs::sock_addr::SockAddrContext) -> *mut T
+pub const fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::new() -> Self
+impl<T: core::marker::Sync> core::marker::Sync for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> !core::marker::Freeze for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> !core::marker::Send for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> core::marker::Unpin for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> !core::panic::unwind_safe::RefUnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+impl<T> core::panic::unwind_safe::UnwindSafe for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where T: core::panic::unwind_safe::RefUnwindSafe
+impl<T, U> core::convert::Into<U> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where U: core::convert::From<T>
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where U: core::convert::Into<T>
+pub type aya_ebpf::btf_maps::sk_storage::SkStorage<T>::Error = core::convert::Infallible
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where U: core::convert::TryFrom<T>
+pub type aya_ebpf::btf_maps::sk_storage::SkStorage<T>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where T: 'static + ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya_ebpf::btf_maps::sk_storage::SkStorage<T> where T: ?core::marker::Sized
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya_ebpf::btf_maps::sk_storage::SkStorage<T>
+pub fn aya_ebpf::btf_maps::sk_storage::SkStorage<T>::from(t: T) -> T
 pub mod aya_ebpf::helpers
 pub use aya_ebpf::helpers::generated
 pub macro aya_ebpf::helpers::bpf_printk!

xtask/public-api/aya.txt

@@ -606,6 +606,48 @@ impl<T> core::borrow::BorrowMut<T> for aya::maps::ring_buf::RingBufItem<'a> wher
 pub fn aya::maps::ring_buf::RingBufItem<'a>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> 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<T, V: aya::Pod>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::get(&self, socket: &impl std::os::fd::raw::AsRawFd, flags: u64) -> core::result::Result<V, aya::maps::MapError>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
+impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::insert(&mut self, socket: &impl std::os::fd::raw::AsRawFd, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::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<Self, Self::Error>
+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<Self, Self::Error>
+impl<T: core::fmt::Debug, V: core::fmt::Debug + aya::Pod> core::fmt::Debug for aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V: aya::Pod> core::convert::TryFrom<aya::maps::Map> for aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>
+pub type aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<T, V> core::marker::Freeze for aya::maps::sk_storage::SkStorage<T, V> where T: core::marker::Freeze
+impl<T, V> core::marker::Send for aya::maps::sk_storage::SkStorage<T, V> where T: core::marker::Send, V: core::marker::Send
+impl<T, V> core::marker::Sync for aya::maps::sk_storage::SkStorage<T, V> where T: core::marker::Sync, V: core::marker::Sync
+impl<T, V> core::marker::Unpin for aya::maps::sk_storage::SkStorage<T, V> where T: core::marker::Unpin, V: core::marker::Unpin
+impl<T, V> core::panic::unwind_safe::RefUnwindSafe for aya::maps::sk_storage::SkStorage<T, V> where T: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, V> core::panic::unwind_safe::UnwindSafe for aya::maps::sk_storage::SkStorage<T, V> where T: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya::maps::sk_storage::SkStorage<T, V> where U: core::convert::From<T>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya::maps::sk_storage::SkStorage<T, V> where U: core::convert::Into<T>
+pub type aya::maps::sk_storage::SkStorage<T, V>::Error = core::convert::Infallible
+pub fn aya::maps::sk_storage::SkStorage<T, V>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya::maps::sk_storage::SkStorage<T, V> where U: core::convert::TryFrom<T>
+pub type aya::maps::sk_storage::SkStorage<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya::maps::sk_storage::SkStorage<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya::maps::sk_storage::SkStorage<T, V> where T: 'static + ?core::marker::Sized
+pub fn aya::maps::sk_storage::SkStorage<T, V>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya::maps::sk_storage::SkStorage<T, V> where T: ?core::marker::Sized
+pub fn aya::maps::sk_storage::SkStorage<T, V>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya::maps::sk_storage::SkStorage<T, V> where T: ?core::marker::Sized
+pub fn aya::maps::sk_storage::SkStorage<T, V>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::from(t: T) -> T
 pub mod aya::maps::sock
 pub struct aya::maps::sock::SockHash<T, K>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod> aya::maps::SockHash<T, K>
@@ -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<Self, Self::Error>
+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<Self, Self::Error>
 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<Self, Self::Error>
@@ -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<Self, Self::Error>
+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<Self, Self::Error>
 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<Self, Self::Error>
@@ -1244,6 +1293,9 @@ pub fn aya::maps::bloom_filter::BloomFilter<aya::maps::MapData, V>::try_from(map
 impl<V: aya::Pod> core::convert::TryFrom<aya::maps::Map> for aya::maps::queue::Queue<aya::maps::MapData, V>
 pub type aya::maps::queue::Queue<aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::queue::Queue<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<V: aya::Pod> core::convert::TryFrom<aya::maps::Map> for aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>
+pub type aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
 impl<V: aya::Pod> core::convert::TryFrom<aya::maps::Map> for aya::maps::stack::Stack<aya::maps::MapData, V>
 pub type aya::maps::stack::Stack<aya::maps::MapData, V>::Error = aya::maps::MapError
 pub fn aya::maps::stack::Stack<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
@@ -2145,6 +2197,47 @@ impl<T> core::borrow::BorrowMut<T> for aya::maps::ring_buf::RingBuf<T> where T:
 pub fn aya::maps::ring_buf::RingBuf<T>::borrow_mut(&mut self) -> &mut T
 impl<T> core::convert::From<T> for aya::maps::ring_buf::RingBuf<T>
 pub fn aya::maps::ring_buf::RingBuf<T>::from(t: T) -> T
+pub struct aya::maps::SkStorage<T, V: aya::Pod>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::get(&self, socket: &impl std::os::fd::raw::AsRawFd, flags: u64) -> core::result::Result<V, aya::maps::MapError>
+impl<T: core::borrow::Borrow<aya::maps::MapData>, V: aya::Pod> aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::pin<P: core::convert::AsRef<std::path::Path>>(self, path: P) -> core::result::Result<(), aya::pin::PinError>
+impl<T: core::borrow::BorrowMut<aya::maps::MapData>, V: aya::Pod> aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::insert(&mut self, socket: &impl std::os::fd::raw::AsRawFd, value: impl core::borrow::Borrow<V>, flags: u64) -> core::result::Result<(), aya::maps::MapError>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::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<Self, Self::Error>
+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<Self, Self::Error>
+impl<T: core::fmt::Debug, V: core::fmt::Debug + aya::Pod> core::fmt::Debug for aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl<V: aya::Pod> core::convert::TryFrom<aya::maps::Map> for aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>
+pub type aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>::Error = aya::maps::MapError
+pub fn aya::maps::sk_storage::SkStorage<aya::maps::MapData, V>::try_from(map: aya::maps::Map) -> core::result::Result<Self, Self::Error>
+impl<T, V> core::marker::Freeze for aya::maps::sk_storage::SkStorage<T, V> where T: core::marker::Freeze
+impl<T, V> core::marker::Send for aya::maps::sk_storage::SkStorage<T, V> where T: core::marker::Send, V: core::marker::Send
+impl<T, V> core::marker::Sync for aya::maps::sk_storage::SkStorage<T, V> where T: core::marker::Sync, V: core::marker::Sync
+impl<T, V> core::marker::Unpin for aya::maps::sk_storage::SkStorage<T, V> where T: core::marker::Unpin, V: core::marker::Unpin
+impl<T, V> core::panic::unwind_safe::RefUnwindSafe for aya::maps::sk_storage::SkStorage<T, V> where T: core::panic::unwind_safe::RefUnwindSafe, V: core::panic::unwind_safe::RefUnwindSafe
+impl<T, V> core::panic::unwind_safe::UnwindSafe for aya::maps::sk_storage::SkStorage<T, V> where T: core::panic::unwind_safe::UnwindSafe, V: core::panic::unwind_safe::UnwindSafe
+impl<T, U> core::convert::Into<U> for aya::maps::sk_storage::SkStorage<T, V> where U: core::convert::From<T>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::into(self) -> U
+impl<T, U> core::convert::TryFrom<U> for aya::maps::sk_storage::SkStorage<T, V> where U: core::convert::Into<T>
+pub type aya::maps::sk_storage::SkStorage<T, V>::Error = core::convert::Infallible
+pub fn aya::maps::sk_storage::SkStorage<T, V>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
+impl<T, U> core::convert::TryInto<U> for aya::maps::sk_storage::SkStorage<T, V> where U: core::convert::TryFrom<T>
+pub type aya::maps::sk_storage::SkStorage<T, V>::Error = <U as core::convert::TryFrom<T>>::Error
+pub fn aya::maps::sk_storage::SkStorage<T, V>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
+impl<T> core::any::Any for aya::maps::sk_storage::SkStorage<T, V> where T: 'static + ?core::marker::Sized
+pub fn aya::maps::sk_storage::SkStorage<T, V>::type_id(&self) -> core::any::TypeId
+impl<T> core::borrow::Borrow<T> for aya::maps::sk_storage::SkStorage<T, V> where T: ?core::marker::Sized
+pub fn aya::maps::sk_storage::SkStorage<T, V>::borrow(&self) -> &T
+impl<T> core::borrow::BorrowMut<T> for aya::maps::sk_storage::SkStorage<T, V> where T: ?core::marker::Sized
+pub fn aya::maps::sk_storage::SkStorage<T, V>::borrow_mut(&mut self) -> &mut T
+impl<T> core::convert::From<T> for aya::maps::sk_storage::SkStorage<T, V>
+pub fn aya::maps::sk_storage::SkStorage<T, V>::from(t: T) -> T
 pub struct aya::maps::SockHash<T, K>
 impl<T: core::borrow::Borrow<aya::maps::MapData>, K: aya::Pod> aya::maps::SockHash<T, K>
 pub fn aya::maps::SockHash<T, K>::fd(&self) -> &aya::maps::sock::SockMapFd