aya: use NonZeroU32 for perf event process scope

PerfEventScope::OneProcess can no longer represent pid 0, which
is the kernel sentinel for the calling process. This is a breaking
change to PerfEventScope; downstream callers that constructed
OneProcess { pid: 0 } should switch to CallingProcess.

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 and public API fixture.

Author: swananan

aya/src/programs/perf_event.rs

@@ -1,6 +1,6 @@
 //! Perf event programs.
 
-use std::os::fd::AsFd as _;
+use std::{num::NonZeroU32, os::fd::AsFd as _};
 
 use aya_obj::generated::{
     HW_BREAKPOINT_LEN_1, HW_BREAKPOINT_LEN_2, HW_BREAKPOINT_LEN_4, HW_BREAKPOINT_LEN_8,
@@ -372,7 +372,7 @@ pub enum PerfEventScope {
     /// one process
     OneProcess {
         /// process id
-        pid: u32,
+        pid: NonZeroU32,
         /// 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

@@ -1,6 +1,7 @@
 use std::{
     ffi::{CString, OsStr, c_long, c_uint},
     io, mem,
+    num::NonZeroU32,
     os::fd::{BorrowedFd, FromRawFd as _},
 };
 
@@ -125,7 +126,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),
     };
 
@@ -166,9 +169,10 @@ pub(crate) fn perf_event_open_trace_point(
     event_id: u64,
     pid: Option<u32>,
 ) -> io::Result<crate::MockableFd> {
-    let scope = match pid {
-        Some(pid) => PerfEventScope::OneProcess { pid, cpu: None },
+    let scope = match pid.map(NonZeroU32::new) {
         None => PerfEventScope::AllProcessesOneCpu { cpu: 0 },
+        Some(None) => PerfEventScope::CallingProcess { cpu: None },
+        Some(Some(pid)) => PerfEventScope::OneProcess { pid, cpu: None },
     };
     perf_event_open(
         PerfEventConfig::TracePoint { event_id },
@@ -253,3 +257,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

@@ -1,4 +1,10 @@
-use std::{collections::HashMap, fs, io::ErrorKind, num::ParseIntError, path::PathBuf};
+use std::{
+    collections::HashMap,
+    fs,
+    io::ErrorKind,
+    num::{NonZeroU32, ParseIntError},
+    path::PathBuf,
+};
 
 use assert_matches::assert_matches;
 use aya::{
@@ -114,7 +120,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 = NonZeroU32::new(std::process::id()).unwrap();
     for cpu in online_cpus().unwrap() {
         calling_process_scopes.push(PerfEventScope::CallingProcess { cpu: Some(cpu) });
         one_process_scopes.push(PerfEventScope::OneProcess {
@@ -171,6 +177,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: core::num::nonzero::NonZeroU32
 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