refactor(aya-ebpf): make InnerMap a sealed trait

Seal the InnerMap trait to prevent external implementations.
This ensures only aya-ebpf map types can be used as inner maps
in map-of-maps structures.

Author: Brskt

ebpf/aya-ebpf/src/maps/array.rs

@@ -15,9 +15,9 @@ pub struct Array<T> {
 }
 
 unsafe impl<T: Sync> Sync for Array<T> {}
+impl<T> super::private::Sealed for Array<T> {}
 unsafe impl<T> InnerMap for Array<T> {}
 
-
 impl<T> Array<T> {
     map_constructors!(u32, T, BPF_MAP_TYPE_ARRAY, phantom _t);
 

ebpf/aya-ebpf/src/maps/bloom_filter.rs

@@ -12,6 +12,7 @@ pub struct BloomFilter<T> {
     _t: PhantomData<T>,
 }
 
+impl<T> super::private::Sealed for BloomFilter<T> {}
 unsafe impl<T> InnerMap for BloomFilter<T> {}
 
 impl<T> BloomFilter<T> {

ebpf/aya-ebpf/src/maps/hash_map.rs

@@ -20,6 +20,7 @@ macro_rules! define_hash_map {
             _kv: PhantomData<(K, V)>,
         }
 
+        impl<K: Sync, V: Sync> super::private::Sealed for $name<K, V> {}
         unsafe impl<K: Sync, V: Sync> InnerMap for $name<K, V> {}
 
         impl<K, V> $name<K, V> {

ebpf/aya-ebpf/src/maps/lpm_trie.rs

@@ -17,6 +17,7 @@ pub struct LpmTrie<K, V> {
 }
 
 unsafe impl<K: Sync, V: Sync> Sync for LpmTrie<K, V> {}
+impl<K, V> super::private::Sealed for LpmTrie<K, V> {}
 unsafe impl<K, V> InnerMap for LpmTrie<K, V> {}
 
 #[repr(C, packed)]

ebpf/aya-ebpf/src/maps/mod.rs

@@ -109,9 +109,16 @@ pub use stack::Stack;
 pub use stack_trace::StackTrace;
 pub use xdp::{CpuMap, DevMap, DevMapHash, XskMap};
 
+mod private {
+    pub trait Sealed {}
+}
+
 /// Marker trait for all eBPF maps that can be used in a map of maps.
 ///
+/// This trait is sealed and cannot be implemented outside this crate.
+///
 /// # Safety
 ///
-/// Only implement this trait for map types that can be safely used as inner maps.
-pub unsafe trait InnerMap {}
+/// This trait must only be implemented for map types that the kernel accepts
+/// as inner maps in a map-of-maps structure.
+pub unsafe trait InnerMap: private::Sealed {}

ebpf/aya-ebpf/src/maps/per_cpu_array.rs

@@ -13,6 +13,7 @@ pub struct PerCpuArray<T> {
 }
 
 unsafe impl<T> Sync for PerCpuArray<T> {}
+impl<T> super::private::Sealed for PerCpuArray<T> {}
 unsafe impl<T> InnerMap for PerCpuArray<T> {}
 
 impl<T> PerCpuArray<T> {

ebpf/aya-ebpf/src/maps/queue.rs

@@ -13,6 +13,7 @@ pub struct Queue<T> {
 }
 
 unsafe impl<T: Sync> Sync for Queue<T> {}
+impl<T> super::private::Sealed for Queue<T> {}
 unsafe impl<T> InnerMap for Queue<T> {}
 
 impl<T> Queue<T> {

ebpf/aya-ebpf/src/maps/ring_buf.rs

@@ -23,6 +23,7 @@ pub struct RingBuf {
 }
 
 unsafe impl Sync for RingBuf {}
+impl super::private::Sealed for RingBuf {}
 unsafe impl InnerMap for RingBuf {}
 
 /// A ring buffer entry, returned from [`RingBuf::reserve_bytes`].

ebpf/aya-ebpf/src/maps/sock_hash.rs

@@ -23,6 +23,7 @@ pub struct SockHash<K> {
 }
 
 unsafe impl<K: Sync> Sync for SockHash<K> {}
+impl<K> super::private::Sealed for SockHash<K> {}
 unsafe impl<K> InnerMap for SockHash<K> {}
 
 impl<K> SockHash<K> {

ebpf/aya-ebpf/src/maps/sock_map.rs

@@ -16,6 +16,7 @@ pub struct SockMap {
 }
 
 unsafe impl Sync for SockMap {}
+impl super::private::Sealed for SockMap {}
 unsafe impl InnerMap for SockMap {}
 
 impl SockMap {