aya: use Pid for perf event scopes

Introduce a Pid newtype backed by NonZeroU32 so public APIs
communicate PID semantics while preventing pid 0 from being
represented as OneProcess.

PerfEventScope::OneProcess now takes Pid. pid 0 remains the
perf_event_open sentinel for the calling process, which is represented
by CallingProcess instead.

Route Some(0) to CallingProcess in perf_event_open_trace_point so
the pid=0 sentinel is preserved through the typed scope. None
continues to map to all-processes CPU 0.

Add syscall-level coverage for the pid/cpu mappings and update the
breakpoint integration test.

Author: swananan

aya/src/programs/mod.rs

@@ -77,6 +77,7 @@ use std::{
     borrow::Cow,
     ffi::CString,
     io,
+    num::NonZeroU32,
     os::fd::{AsFd, BorrowedFd},
     path::{Path, PathBuf},
     sync::Arc,
@@ -270,6 +271,32 @@ impl AsFd for ProgramFd {
     }
 }
 
+/// A non-zero process identifier.
+///
+/// This type represents a real process ID. Kernel sentinel values such as `0`
+/// are modeled separately by the APIs that accept them.
+#[derive(Debug, Clone, Copy)]
+pub struct Pid(NonZeroU32);
+
+impl Pid {
+    /// Creates a process identifier from a raw PID.
+    ///
+    /// Returns `None` if `pid` is zero.
+    pub fn new(pid: u32) -> Option<Self> {
+        NonZeroU32::new(pid).map(Self)
+    }
+
+    /// Returns the identifier of the current process.
+    pub fn current() -> Self {
+        Self(NonZeroU32::new(std::process::id()).unwrap())
+    }
+
+    /// Returns the raw PID value.
+    pub const fn get(self) -> u32 {
+        self.0.get()
+    }
+}
+
 /// A [`Program`] identifier.
 pub struct ProgramId(u32);
 

aya/src/programs/perf_event.rs

@@ -11,7 +11,7 @@ use aya_obj::generated::{
 
 use crate::{
     programs::{
-        ProgramData, ProgramError, ProgramType, impl_try_from_fdlink, impl_try_into_fdlink,
+        Pid, ProgramData, ProgramError, ProgramType, impl_try_from_fdlink, impl_try_into_fdlink,
         links::define_link_wrapper,
         load_program_without_attach_type,
         perf_attach::{PerfLinkIdInner, PerfLinkInner, perf_attach},
@@ -372,7 +372,7 @@ pub enum PerfEventScope {
     /// one process
     OneProcess {
         /// process id
-        pid: u32,
+        pid: Pid,
         /// cpu id or any cpu if None
         cpu: Option<u32>,
     },

aya/src/sys/fake.rs

@@ -2,20 +2,20 @@ use std::{cell::RefCell, ffi::c_void, io, ptr};
 
 use super::{SysResult, Syscall};
 
-type SyscallFn = unsafe fn(Syscall<'_>) -> SysResult;
+type SyscallFn = dyn for<'a> Fn(Syscall<'a>) -> SysResult;
 
 #[cfg(test)]
 thread_local! {
-    pub(crate) static TEST_SYSCALL: RefCell<SyscallFn> = RefCell::new(test_syscall);
+    pub(crate) static TEST_SYSCALL: RefCell<Box<SyscallFn>> = RefCell::new(Box::new(test_syscall));
     pub(crate) static TEST_MMAP_RET: RefCell<*mut c_void> = const { RefCell::new(ptr::null_mut()) };
 }
 
 #[cfg(test)]
-unsafe fn test_syscall(_call: Syscall<'_>) -> SysResult {
+fn test_syscall(_call: Syscall<'_>) -> SysResult {
     Err((-1, io::Error::from_raw_os_error(libc::EINVAL)))
 }
 
 #[cfg(test)]
-pub(crate) fn override_syscall(call: unsafe fn(Syscall<'_>) -> SysResult) {
-    TEST_SYSCALL.with(|test_impl| *test_impl.borrow_mut() = call);
+pub(crate) fn override_syscall(call: impl for<'a> Fn(Syscall<'a>) -> SysResult + 'static) {
+    TEST_SYSCALL.with(|test_impl| *test_impl.borrow_mut() = Box::new(call));
 }

aya/src/sys/mod.rs

@@ -35,7 +35,6 @@ pub(crate) enum PerfEventIoctlRequest<'a> {
     SetBpf(BorrowedFd<'a>),
 }
 
-#[cfg_attr(test, expect(dead_code, reason = "test stubs cut above this"))]
 pub(crate) enum Syscall<'a> {
     Ebpf {
         cmd: bpf_cmd,
@@ -99,7 +98,7 @@ impl std::fmt::Debug for Syscall<'_> {
 fn syscall(call: Syscall<'_>) -> SysResult {
     #[cfg(test)]
     {
-        TEST_SYSCALL.with(|test_impl| unsafe { test_impl.borrow()(call) })
+        TEST_SYSCALL.with(|test_impl| test_impl.borrow()(call))
     }
 
     #[cfg(not(test))]

aya/src/sys/perf_event.rs

@@ -16,9 +16,12 @@ use aya_obj::generated::{
 use libc::pid_t;
 
 use super::{PerfEventIoctlRequest, Syscall, syscall};
-use crate::programs::perf_event::{
-    BreakpointConfig, PerfEventConfig, PerfEventScope, SamplePolicy, WakeupPolicy,
-    perf_type_id_to_u32,
+use crate::programs::{
+    Pid,
+    perf_event::{
+        BreakpointConfig, PerfEventConfig, PerfEventScope, SamplePolicy, WakeupPolicy,
+        perf_type_id_to_u32,
+    },
 };
 
 pub(crate) fn perf_event_open(
@@ -125,7 +128,9 @@ pub(crate) fn perf_event_open(
 
     let (pid, cpu) = match scope {
         PerfEventScope::CallingProcess { cpu } => (0, cpu.map_or(-1, |cpu| cpu as i32)),
-        PerfEventScope::OneProcess { pid, cpu } => (pid as i32, cpu.map_or(-1, |cpu| cpu as i32)),
+        PerfEventScope::OneProcess { pid, cpu } => {
+            (pid.get() as i32, cpu.map_or(-1, |cpu| cpu as i32))
+        }
         PerfEventScope::AllProcessesOneCpu { cpu } => (-1, cpu as i32),
     };
 
@@ -167,8 +172,12 @@ pub(crate) fn perf_event_open_trace_point(
     pid: Option<u32>,
 ) -> io::Result<crate::MockableFd> {
     let scope = match pid {
-        Some(pid) => PerfEventScope::OneProcess { pid, cpu: None },
         None => PerfEventScope::AllProcessesOneCpu { cpu: 0 },
+        Some(0) => PerfEventScope::CallingProcess { cpu: None },
+        Some(pid) => PerfEventScope::OneProcess {
+            pid: Pid::new(pid).unwrap(),
+            cpu: None,
+        },
     };
     perf_event_open(
         PerfEventConfig::TracePoint { event_id },
@@ -253,3 +262,47 @@ impl TryFrom<u32> for perf_event_type {
     }
 }
 */
+
+#[cfg(test)]
+mod tests {
+    use std::os::fd::AsRawFd as _;
+
+    use libc::pid_t;
+    use test_case::test_case;
+
+    use super::{PERF_FLAG_FD_CLOEXEC, perf_event_open_trace_point};
+    use crate::sys::{Syscall, override_syscall};
+
+    const EVENT_ID: u64 = 123;
+
+    #[test_case(None, -1, 0; "all_processes")]
+    #[test_case(Some(0), 0, -1; "calling_process")]
+    #[test_case(Some(42), 42, -1; "one_process")]
+    fn perf_event_open_trace_point_maps_pid_scope(
+        pid: Option<u32>,
+        expected_pid: pid_t,
+        expected_cpu: i32,
+    ) {
+        override_syscall(move |call| match call {
+            Syscall::PerfEventOpen {
+                attr,
+                pid: actual_pid,
+                cpu: actual_cpu,
+                group,
+                flags,
+            } => {
+                assert_eq!(attr.config, EVENT_ID);
+                assert_eq!(unsafe { attr.__bindgen_anon_1.sample_period }, 0);
+                assert_eq!(actual_pid, expected_pid);
+                assert_eq!(actual_cpu, expected_cpu);
+                assert_eq!(group, -1);
+                assert_eq!(flags, PERF_FLAG_FD_CLOEXEC);
+                Ok(crate::MockableFd::mock_signed_fd().into())
+            }
+            call => panic!("unexpected syscall: {call:?}"),
+        });
+
+        let fd = perf_event_open_trace_point(EVENT_ID, pid).unwrap();
+        assert_eq!(fd.as_raw_fd(), crate::MockableFd::mock_signed_fd());
+    }
+}

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

@@ -4,7 +4,7 @@ use assert_matches::assert_matches;
 use aya::{
     Ebpf, maps,
     programs::{
-        ProgramError,
+        Pid, ProgramError,
         perf_event::{
             BreakpointConfig, PerfBreakpointLength, PerfBreakpointType, PerfEventConfig,
             PerfEventScope, SamplePolicy,
@@ -114,7 +114,7 @@ where
     let mut one_process_scopes = Vec::new();
     let mut all_processes_one_cpu_scopes = Vec::new();
 
-    let pid = std::process::id();
+    let pid = Pid::current();
     for cpu in online_cpus().unwrap() {
         calling_process_scopes.push(PerfEventScope::CallingProcess { cpu: Some(cpu) });
         one_process_scopes.push(PerfEventScope::OneProcess {
@@ -171,6 +171,7 @@ where
 
         trigger();
 
+        let pid = pid.get();
         let lookup = map.get(&pid, 0);
         if attached {
             let recorded =

xtask/public-api/aya.txt

@@ -3625,7 +3625,7 @@ pub aya::programs::perf_event::PerfEventScope::CallingProcess
 pub aya::programs::perf_event::PerfEventScope::CallingProcess::cpu: core::option::Option<u32>
 pub aya::programs::perf_event::PerfEventScope::OneProcess
 pub aya::programs::perf_event::PerfEventScope::OneProcess::cpu: core::option::Option<u32>
-pub aya::programs::perf_event::PerfEventScope::OneProcess::pid: u32
+pub aya::programs::perf_event::PerfEventScope::OneProcess::pid: aya::programs::Pid
 impl core::clone::Clone for aya::programs::perf_event::PerfEventScope
 pub fn aya::programs::perf_event::PerfEventScope::clone(&self) -> aya::programs::perf_event::PerfEventScope
 impl core::fmt::Debug for aya::programs::perf_event::PerfEventScope
@@ -6299,6 +6299,23 @@ impl core::marker::Unpin for aya::programs::perf_event::PerfEvent
 impl core::marker::UnsafeUnpin for aya::programs::perf_event::PerfEvent
 impl core::panic::unwind_safe::RefUnwindSafe for aya::programs::perf_event::PerfEvent
 impl core::panic::unwind_safe::UnwindSafe for aya::programs::perf_event::PerfEvent
+pub struct aya::programs::Pid(_)
+impl aya::programs::Pid
+pub fn aya::programs::Pid::current() -> Self
+pub const fn aya::programs::Pid::get(self) -> u32
+pub fn aya::programs::Pid::new(pid: u32) -> core::option::Option<Self>
+impl core::clone::Clone for aya::programs::Pid
+pub fn aya::programs::Pid::clone(&self) -> aya::programs::Pid
+impl core::fmt::Debug for aya::programs::Pid
+pub fn aya::programs::Pid::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
+impl core::marker::Copy for aya::programs::Pid
+impl core::marker::Freeze for aya::programs::Pid
+impl core::marker::Send for aya::programs::Pid
+impl core::marker::Sync for aya::programs::Pid
+impl core::marker::Unpin for aya::programs::Pid
+impl core::marker::UnsafeUnpin for aya::programs::Pid
+impl core::panic::unwind_safe::RefUnwindSafe for aya::programs::Pid
+impl core::panic::unwind_safe::UnwindSafe for aya::programs::Pid
 pub struct aya::programs::ProgramFd(_)
 impl aya::programs::ProgramFd
 pub fn aya::programs::ProgramFd::try_clone(&self) -> std::io::error::Result<Self>