aya-{common,ebpf}: Add spin lock support

Add a new `aya-common` crate with a `SpinLock` struct, that wraps
`bpf_spin_lock` and allows to use it in BPF maps.

Add an extension trait `EbpfSpinLock` that provides a `lock` method,
which is a wrapper over `bpf_spin_lock` helper. It returns a
`SpinLockGuard` that calls `bpf_spin_unlock` helper once dropped.

Test that functionality with a simple XDP counter program.

Author: vadorovsky

.github/workflows/ci.yml

@@ -77,6 +77,7 @@ jobs:
         run: |
           set -euxo pipefail
           cargo +nightly hack miri test --all-targets --feature-powerset \
+            --exclude aya-common \
             --exclude aya-ebpf \
             --exclude aya-ebpf-bindings \
             --exclude aya-log-ebpf \
@@ -129,6 +130,7 @@ jobs:
         run: |
           set -euxo pipefail
           cargo hack build --all-targets --feature-powerset \
+            --exclude aya-common \
             --exclude aya-ebpf \
             --exclude aya-ebpf-bindings \
             --exclude aya-log-ebpf \
@@ -142,6 +144,7 @@ jobs:
         run: |
           set -euxo pipefail
           cargo hack test --all-targets \
+            --exclude aya-common \
             --exclude aya-ebpf \
             --exclude aya-ebpf-bindings \
             --exclude aya-log-ebpf \
@@ -155,6 +158,7 @@ jobs:
         run: |
           set -euxo pipefail
           cargo hack test --doc \
+            --exclude aya-common \
             --exclude aya-ebpf \
             --exclude aya-ebpf-bindings \
             --exclude aya-log-ebpf \

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "aya",
     "aya-build",
+    "aya-common",
     "aya-log",
     "aya-log-common",
     "aya-log-parser",

aya-common/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+description = "Library shared across eBPF and user-space"
+documentation = "https://docs.rs/aya-common"
+keywords = ["bpf", "ebpf", "common"]
+name = "aya-common"
+version = "0.1.0"
+
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+aya-ebpf-bindings = { version = "^0.1.2", path = "../ebpf/aya-ebpf-bindings" }
+
+[features]
+user = ["aya-ebpf-bindings/user"]

aya-common/src/lib.rs

@@ -0,0 +1,9 @@
+#![cfg_attr(
+    target_arch = "bpf",
+    expect(unused_crate_dependencies, reason = "compiler_builtins")
+)]
+#![no_std]
+
+mod spin_lock;
+
+pub use spin_lock::SpinLock;

aya-common/src/spin_lock.rs

@@ -0,0 +1,2 @@
+/// A spin lock that can be used to protect shared data in eBPF maps
+pub type SpinLock = aya_ebpf_bindings::bindings::bpf_spin_lock;

ebpf/aya-ebpf-bindings/Cargo.toml

@@ -13,7 +13,11 @@ repository.workspace = true
 workspace = true
 
 [dependencies]
+aya = { path = "../../aya", version = "^0.13.1", optional = true }
 aya-ebpf-cty = { version = "^0.2.3", path = "../aya-ebpf-cty" }
 
 [build-dependencies]
 aya-build = { version = "^0.1.3", path = "../../aya-build" }
+
+[features]
+user = ["dep:aya"]

ebpf/aya-ebpf-bindings/src/lib.rs

@@ -118,4 +118,7 @@ pub mod bindings {
         pub id: ::aya_ebpf_cty::c_uint,
         pub pinning: ::aya_ebpf_cty::c_uint,
     }
+
+    #[cfg(feature = "user")]
+    unsafe impl aya::Pod for bpf_spin_lock {}
 }

ebpf/aya-ebpf/Cargo.toml

@@ -14,6 +14,7 @@ rust-version.workspace = true
 workspace = true
 
 [dependencies]
+aya-common = { version = "^0.1.0", path = "../../aya-common" }
 aya-ebpf-bindings = { version = "^0.1.2", path = "../aya-ebpf-bindings" }
 aya-ebpf-cty = { version = "^0.2.3", path = "../aya-ebpf-cty" }
 aya-ebpf-macros = { version = "^0.1.2", path = "../../aya-ebpf-macros" }

ebpf/aya-ebpf/src/lib.rs

@@ -45,6 +45,7 @@ pub mod btf_maps;
 pub mod helpers;
 pub mod maps;
 pub mod programs;
+pub mod spin_lock;
 
 use core::{
     mem::MaybeUninit,

ebpf/aya-ebpf/src/spin_lock.rs

@@ -0,0 +1,56 @@
+pub use aya_common::SpinLock;
+
+use crate::helpers;
+
+/// An RAII implementation of a scope of a spin lock. When this structure is
+/// dropped (falls out of scope), the lock will be unlocked.
+#[must_use = "if unused the spin lock will immediately unlock"]
+pub struct SpinLockGuard<'a> {
+    spin_lock: &'a mut SpinLock,
+}
+
+impl Drop for SpinLockGuard<'_> {
+    fn drop(&mut self) {
+        // SAFETY: Call to an eBPF helper. `self.spin_lock` is always
+        // initialized.
+        unsafe {
+            helpers::bpf_spin_unlock(core::ptr::from_mut(self.spin_lock));
+        }
+    }
+}
+
+mod sealed {
+    use super::{SpinLock, SpinLockGuard, helpers};
+
+    pub trait EbpfSpinLock {
+        fn lock(&mut self) -> SpinLockGuard<'_>;
+    }
+
+    impl EbpfSpinLock for SpinLock {
+        fn lock(&mut self) -> SpinLockGuard<'_> {
+            // SAFETY: Call to an eBPF helper. `self` is always initialized.
+            unsafe {
+                helpers::bpf_spin_lock(core::ptr::from_mut(self));
+            }
+            SpinLockGuard { spin_lock: self }
+        }
+    }
+}
+
+/// Extension trait for [`SpinLock`] exposing eBPF-only helpers. These helpers
+/// are not available in user-space.
+pub trait EbpfSpinLockExt: sealed::EbpfSpinLock {
+    fn lock(&mut self) -> SpinLockGuard<'_>;
+}
+
+impl<T> EbpfSpinLockExt for T
+where
+    T: sealed::EbpfSpinLock,
+{
+    /// Acquires a spin lock and returns a [`SpinLockGuard`]. The lock is
+    /// acquired as long as the guard is alive.
+    #[inline]
+    fn lock(&mut self) -> SpinLockGuard<'_> {
+        sealed::EbpfSpinLock::lock(self)
+    }
+}