aya/maps: pin for (async)perf_event_array

Implement pinning for perf_event_array and async_perf_event_array.
Additionally make the core MapData.pin method operate on a reference
rather than a mutable reference.

Signed-off-by: astoycos <[email protected]>

aya/src/maps/mod.rs

@@ -48,7 +48,7 @@
 //! versa. Because of that, all map values must be plain old data and therefore
 //! implement the [Pod] trait.
 use std::{
-    borrow::BorrowMut,
+    borrow::Borrow,
     ffi::{c_long, CString},
     fmt, io,
     marker::PhantomData,
@@ -332,7 +332,7 @@ impl Map {
     ///
     /// When a map is pinned it will remain loaded until the corresponding file
     /// is deleted. All parent directories in the given `path` must already exist.
-    pub fn pin<P: AsRef<Path>>(&mut self, path: P) -> Result<(), PinError> {
+    pub fn pin<P: AsRef<Path>>(&self, path: P) -> Result<(), PinError> {
         match self {
             Self::Array(map) => map.pin(path),
             Self::BloomFilter(map) => map.pin(path),
@@ -360,7 +360,6 @@ impl Map {
 }
 
 // Implements map pinning for different map implementations
-// TODO add support for PerfEventArrays and AsyncPerfEventArrays
 macro_rules! impl_map_pin {
     ($ty_param:tt {
         $($ty:ident),+ $(,)?
@@ -371,14 +370,14 @@ macro_rules! impl_map_pin {
       <($($ty_param:ident),*)>
       $ty:ident
     ) => {
-            impl<T: BorrowMut<MapData>, $($ty_param: Pod),*> $ty<T, $($ty_param),*>
+            impl<T: Borrow<MapData>, $($ty_param: Pod),*> $ty<T, $($ty_param),*>
             {
                     /// 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<P: AsRef<Path>>(&mut self, path: P) -> Result<(), PinError> {
-                        let data = self.inner.borrow_mut();
+                    pub fn pin<P: AsRef<Path>>(self, path: P) -> Result<(), PinError> {
+                        let data = self.inner.borrow();
                         data.pin(path)
                     }
             }
@@ -591,7 +590,7 @@ impl MapData {
                 Ok(Self { obj, fd })
             }
             Err(_) => {
-                let mut map = Self::create(obj, name, btf_fd)?;
+                let map = Self::create(obj, name, btf_fd)?;
                 map.pin(&path).map_err(|error| MapError::PinError {
                     name: Some(name.into()),
                     error,
@@ -687,7 +686,7 @@ impl MapData {
     ///
     /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
-    pub fn pin<P: AsRef<Path>>(&mut self, path: P) -> Result<(), PinError> {
+    pub fn pin<P: AsRef<Path>>(&self, path: P) -> Result<(), PinError> {
         use std::os::unix::ffi::OsStrExt as _;
 
         let Self { fd, obj: _ } = self;

aya/src/maps/perf/async_perf_event_array.rs

@@ -1,4 +1,7 @@
-use std::borrow::{Borrow, BorrowMut};
+use std::{
+    borrow::{Borrow, BorrowMut},
+    path::Path,
+};
 
 // See https://doc.rust-lang.org/cargo/reference/features.html#mutually-exclusive-features.
 //
@@ -12,7 +15,7 @@ use tokio::io::unix::AsyncFd;
 
 use crate::maps::{
     perf::{Events, PerfBufferError, PerfEventArray, PerfEventArrayBuffer},
-    MapData, MapError,
+    MapData, MapError, PinError,
 };
 
 /// A `Future` based map that can be used to receive events from eBPF programs using the linux
@@ -105,6 +108,14 @@ impl<T: BorrowMut<MapData>> AsyncPerfEventArray<T> {
         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<P: AsRef<Path>>(&self, path: P) -> Result<(), PinError> {
+        self.perf_map.pin(path)
+    }
 }
 
 impl<T: Borrow<MapData>> AsyncPerfEventArray<T> {

aya/src/maps/perf/perf_event_array.rs

@@ -5,6 +5,7 @@ use std::{
     borrow::{Borrow, BorrowMut},
     ops::Deref,
     os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd},
+    path::Path,
     sync::Arc,
 };
 
@@ -13,7 +14,7 @@ use bytes::BytesMut;
 use crate::{
     maps::{
         perf::{Events, PerfBuffer, PerfBufferError},
-        MapData, MapError,
+        MapData, MapError, PinError,
     },
     sys::bpf_map_update_elem,
     util::page_size,
@@ -173,6 +174,15 @@ impl<T: Borrow<MapData>> PerfEventArray<T> {
             page_size: page_size(),
         })
     }
+
+    /// 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<P: AsRef<Path>>(&self, path: P) -> Result<(), PinError> {
+        let data: &MapData = self.map.deref().borrow();
+        data.pin(path)
+    }
 }
 
 impl<T: BorrowMut<MapData>> PerfEventArray<T> {

test/integration-test/src/tests/load.rs

@@ -91,9 +91,9 @@ fn pin_lifecycle_multiple_btf_maps() {
         remove_file(map_pin_path).unwrap();
     }
 
-    let mut map_1: Array<_, u64> = bpf.take_map("map_1").unwrap().try_into().unwrap();
-    let mut map_2: Array<_, u64> = bpf.take_map("map_2").unwrap().try_into().unwrap();
-    let mut map_pin_by_name: Array<_, u64> =
+    let map_1: Array<_, u64> = bpf.take_map("map_1").unwrap().try_into().unwrap();
+    let map_2: Array<_, u64> = bpf.take_map("map_2").unwrap().try_into().unwrap();
+    let map_pin_by_name: Array<_, u64> =
         bpf.take_map("map_pin_by_name").unwrap().try_into().unwrap();
 
     let prog: &mut UProbe = bpf.program_mut("bpf_prog").unwrap().try_into().unwrap();