Reduce duplication in `{nr,possible}_cpus`

aya-log/src/lib.rs

@@ -161,7 +161,7 @@ impl EbpfLogger {
         let mut logs: AsyncPerfEventArray<_> = map.try_into()?;
 
         let logger = Arc::new(logger);
-        for cpu_id in online_cpus().map_err(Error::InvalidOnlineCpu)? {
+        for cpu_id in online_cpus().map_err(|(_, error)| Error::InvalidOnlineCpu(error))? {
             let mut buf = logs.open(cpu_id, None)?;
 
             let log = logger.clone();

aya/src/bpf.rs

@@ -43,7 +43,7 @@ use crate::{
         is_info_map_ids_supported, is_perf_link_supported, is_probe_read_kernel_supported,
         is_prog_id_supported, is_prog_name_supported, retry_with_verifier_logs,
     },
-    util::{bytes_of, bytes_of_slice, page_size, possible_cpus, POSSIBLE_CPUS},
+    util::{bytes_of, bytes_of_slice, nr_cpus, page_size},
 };
 
 pub(crate) const BPF_OBJ_NAME_LEN: usize = 16;
@@ -465,13 +465,11 @@ impl<'a> EbpfLoader<'a> {
             {
                 continue;
             }
-            let num_cpus = || -> Result<u32, EbpfError> {
-                Ok(possible_cpus()
-                    .map_err(|error| EbpfError::FileError {
-                        path: PathBuf::from(POSSIBLE_CPUS),
-                        error,
-                    })?
-                    .len() as u32)
+            let num_cpus = || {
+                Ok(nr_cpus().map_err(|(path, error)| EbpfError::FileError {
+                    path: PathBuf::from(path),
+                    error,
+                })? as u32)
             };
             let map_type: bpf_map_type = obj.map_type().try_into().map_err(MapError::from)?;
             if let Some(max_entries) = max_entries_override(

aya/src/maps/mod.rs

@@ -569,9 +569,9 @@ impl MapData {
         //
         // Otherwise, when the value is `0` or too large, we set it to the number of CPUs.
         if obj.map_type() == bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY as u32 {
-            let ncpus = nr_cpus().map_err(MapError::IoError)? as u32;
-            if obj.max_entries() == 0 || obj.max_entries() > ncpus {
-                obj.set_max_entries(ncpus);
+            let nr_cpus = nr_cpus().map_err(|(_, error)| MapError::IoError(error))? as u32;
+            if obj.max_entries() == 0 || obj.max_entries() > nr_cpus {
+                obj.set_max_entries(nr_cpus);
             }
         };
 
@@ -891,7 +891,7 @@ impl<T: Pod> TryFrom<Vec<T>> for PerCpuValues<T> {
     type Error = io::Error;
 
     fn try_from(values: Vec<T>) -> Result<Self, Self::Error> {
-        let nr_cpus = nr_cpus()?;
+        let nr_cpus = nr_cpus().map_err(|(_, error)| error)?;
         if values.len() != nr_cpus {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
@@ -907,8 +907,9 @@ impl<T: Pod> TryFrom<Vec<T>> for PerCpuValues<T> {
 impl<T: Pod> PerCpuValues<T> {
     pub(crate) fn alloc_kernel_mem() -> Result<PerCpuKernelMem, io::Error> {
         let value_size = (mem::size_of::<T>() + 7) & !7;
+        let nr_cpus = nr_cpus().map_err(|(_, error)| error)?;
         Ok(PerCpuKernelMem {
-            bytes: vec![0u8; nr_cpus()? * value_size],
+            bytes: vec![0u8; nr_cpus * value_size],
         })
     }
 
@@ -1086,9 +1087,9 @@ mod tests {
             _ => Err((-1, io::Error::from_raw_os_error(EFAULT))),
         });
 
-        let ncpus = nr_cpus().unwrap();
+        let nr_cpus = nr_cpus().unwrap();
 
-        // Create with max_entries > ncpus is clamped to ncpus
+        // Create with max_entries > nr_cpus is clamped to nr_cpus
         assert_matches!(
             MapData::create(test_utils::new_obj_map_with_max_entries::<u32>(
                 crate::generated::bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,
@@ -1099,11 +1100,11 @@ mod tests {
                 fd,
             }) => {
                 assert_eq!(fd.as_fd().as_raw_fd(), crate::MockableFd::mock_signed_fd());
-                assert_eq!(obj.max_entries(), ncpus as u32)
+                assert_eq!(obj.max_entries(), nr_cpus as u32)
             }
         );
 
-        // Create with max_entries = 0 is set to ncpus
+        // Create with max_entries = 0 is set to nr_cpus
         assert_matches!(
             MapData::create(test_utils::new_obj_map_with_max_entries::<u32>(
                 crate::generated::bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,
@@ -1114,11 +1115,11 @@ mod tests {
                 fd,
             }) => {
                 assert_eq!(fd.as_fd().as_raw_fd(), crate::MockableFd::mock_signed_fd());
-                assert_eq!(obj.max_entries(), ncpus as u32)
+                assert_eq!(obj.max_entries(), nr_cpus as u32)
             }
         );
 
-        // Create with max_entries < ncpus is unchanged
+        // Create with max_entries < nr_cpus is unchanged
         assert_matches!(
             MapData::create(test_utils::new_obj_map_with_max_entries::<u32>(
                 crate::generated::bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,

aya/src/util.rs

@@ -185,40 +185,29 @@ impl Display for KernelVersion {
 }
 
 const ONLINE_CPUS: &str = "/sys/devices/system/cpu/online";
-pub(crate) const POSSIBLE_CPUS: &str = "/sys/devices/system/cpu/possible";
+const POSSIBLE_CPUS: &str = "/sys/devices/system/cpu/possible";
 
 /// Returns the numeric IDs of the CPUs currently online.
-pub fn online_cpus() -> Result<Vec<u32>, io::Error> {
-    let data = fs::read_to_string(ONLINE_CPUS)?;
-    parse_cpu_ranges(data.trim()).map_err(|_| {
-        io::Error::new(
-            io::ErrorKind::Other,
-            format!("unexpected {ONLINE_CPUS} format"),
-        )
-    })
+pub fn online_cpus() -> Result<Vec<u32>, (&'static str, io::Error)> {
+    read_cpu_ranges(ONLINE_CPUS)
 }
 
 /// Get the number of possible cpus.
 ///
 /// See `/sys/devices/system/cpu/possible`.
-pub fn nr_cpus() -> Result<usize, io::Error> {
-    Ok(possible_cpus()?.len())
+pub fn nr_cpus() -> Result<usize, (&'static str, io::Error)> {
+    read_cpu_ranges(POSSIBLE_CPUS).map(|cpus| cpus.len())
 }
 
-/// Get the list of possible cpus.
-///
-/// See `/sys/devices/system/cpu/possible`.
-pub(crate) fn possible_cpus() -> Result<Vec<u32>, io::Error> {
-    let data = fs::read_to_string(POSSIBLE_CPUS)?;
-    parse_cpu_ranges(data.trim()).map_err(|_| {
-        io::Error::new(
-            io::ErrorKind::Other,
-            format!("unexpected {POSSIBLE_CPUS} format"),
-        )
-    })
+fn read_cpu_ranges(path: &'static str) -> Result<Vec<u32>, (&'static str, io::Error)> {
+    (|| {
+        let data = fs::read_to_string(path)?;
+        parse_cpu_ranges(&data).map_err(|range| io::Error::new(io::ErrorKind::InvalidData, range))
+    })()
+    .map_err(|error| (path, error))
 }
 
-fn parse_cpu_ranges(data: &str) -> Result<Vec<u32>, ()> {
+fn parse_cpu_ranges(data: &str) -> Result<Vec<u32>, &str> {
     let mut cpus = Vec::new();
     for range in data.split(',') {
         cpus.extend({
@@ -226,10 +215,10 @@ fn parse_cpu_ranges(data: &str) -> Result<Vec<u32>, ()> {
                 .splitn(2, '-')
                 .map(u32::from_str)
                 .collect::<Result<Vec<_>, _>>()
-                .map_err(|_| ())?
+                .map_err(|ParseIntError { .. }| range)?
                 .as_slice()
             {
-                &[] | &[_, _, _, ..] => return Err(()),
+                &[] | &[_, _, _, ..] => return Err(range),
                 &[start] => start..=start,
                 &[start, end] => start..=end,
             }

xtask/public-api/aya.txt

@@ -9026,8 +9026,8 @@ pub unsafe fn aya::util::KernelVersion::clone_to_uninit(&self, dst: *mut T)
 impl<T> core::convert::From<T> for aya::util::KernelVersion
 pub fn aya::util::KernelVersion::from(t: T) -> T
 pub fn aya::util::kernel_symbols() -> core::result::Result<alloc::collections::btree::map::BTreeMap<u64, alloc::string::String>, std::io::error::Error>
-pub fn aya::util::nr_cpus() -> core::result::Result<usize, std::io::error::Error>
-pub fn aya::util::online_cpus() -> core::result::Result<alloc::vec::Vec<u32>, std::io::error::Error>
+pub fn aya::util::nr_cpus() -> core::result::Result<usize, (&'static str, std::io::error::Error)>
+pub fn aya::util::online_cpus() -> core::result::Result<alloc::vec::Vec<u32>, (&'static str, std::io::error::Error)>
 pub fn aya::util::syscall_prefix() -> core::result::Result<&'static str, std::io::error::Error>
 pub macro aya::include_bytes_aligned!
 pub enum aya::EbpfError