remove programfd in favor of ownedfd

This commit removes the ProgramFd wrapper of RawFd and deduplicates some
code. Specifically it adds a new constructor for ProgramInfo which
allows it to be generated from an OwnedFd.

Signed-off-by: Andrew Stoycos <astoycos@redhat.com>

aya/src/maps/array/program_array.rs

@@ -2,12 +2,11 @@
 
 use std::{
     borrow::{Borrow, BorrowMut},
-    os::fd::{AsRawFd, RawFd},
+    os::fd::{AsRawFd, OwnedFd, RawFd},
 };
 
 use crate::{
     maps::{check_bounds, check_kv_size, MapData, MapError, MapKeys},
-    programs::ProgramFd,
     sys::{bpf_map_delete_elem, bpf_map_update_elem},
 };
 
@@ -73,7 +72,7 @@ impl<T: BorrowMut<MapData>> ProgramArray<T> {
     ///
     /// When an eBPF program calls `bpf_tail_call(ctx, prog_array, index)`, control
     /// flow will jump to `program`.
-    pub fn set(&mut self, index: u32, program: ProgramFd, flags: u64) -> Result<(), MapError> {
+    pub fn set(&mut self, index: u32, program: OwnedFd, flags: u64) -> Result<(), MapError> {
         let data = self.inner.borrow_mut();
         check_bounds(data, index)?;
         let fd = data.fd_or_err()?;

aya/src/programs/extension.rs

@@ -1,5 +1,5 @@
 //! Extension programs.
-use std::os::fd::{AsRawFd, RawFd};
+use std::os::fd::{AsRawFd, OwnedFd, RawFd};
 use thiserror::Error;
 
 use object::Endianness;
@@ -7,9 +7,7 @@ use object::Endianness;
 use crate::{
     generated::{bpf_attach_type::BPF_CGROUP_INET_INGRESS, bpf_prog_type::BPF_PROG_TYPE_EXT},
     obj::btf::BtfKind,
-    programs::{
-        define_link_wrapper, load_program, FdLink, FdLinkId, ProgramData, ProgramError, ProgramFd,
-    },
+    programs::{define_link_wrapper, load_program, FdLink, FdLinkId, ProgramData, ProgramError},
     sys::{self, bpf_link_create},
     Btf,
 };
@@ -68,7 +66,7 @@ impl Extension {
     /// The extension code will be loaded but inactive until it's attached.
     /// There are no restrictions on what functions may be replaced, so you could replace
     /// the main entry point of your program with an extension.
-    pub fn load(&mut self, program: ProgramFd, func_name: &str) -> Result<(), ProgramError> {
+    pub fn load(&mut self, program: OwnedFd, func_name: &str) -> Result<(), ProgramError> {
         let target_prog_fd = program.as_raw_fd();
         let (btf_fd, btf_id) = get_btf_info(target_prog_fd, func_name)?;
 
@@ -113,7 +111,7 @@ impl Extension {
     /// original function, see [Extension::detach].
     pub fn attach_to_program(
         &mut self,
-        program: ProgramFd,
+        program: OwnedFd,
         func_name: &str,
     ) -> Result<ExtensionLinkId, ProgramError> {
         let target_fd = program.as_raw_fd();

aya/src/programs/lirc_mode2.rs

@@ -1,10 +1,10 @@
 //! Lirc programs.
-use std::os::fd::{AsRawFd, IntoRawFd as _, RawFd};
+use std::os::fd::{AsRawFd, FromRawFd as _, IntoRawFd as _, OwnedFd, RawFd};
 
 use crate::{
     generated::{bpf_attach_type::BPF_LIRC_MODE2, bpf_prog_type::BPF_PROG_TYPE_LIRC_MODE2},
     programs::{load_program, query, Link, ProgramData, ProgramError, ProgramInfo},
-    sys::{bpf_prog_attach, bpf_prog_detach, bpf_prog_get_fd_by_id, bpf_prog_get_info_by_fd},
+    sys::{bpf_prog_attach, bpf_prog_detach, bpf_prog_get_fd_by_id},
 };
 
 use libc::{close, dup};
@@ -132,13 +132,7 @@ impl LircLink {
 
     /// Get ProgramInfo from this link
     pub fn info(&self) -> Result<ProgramInfo, ProgramError> {
-        match bpf_prog_get_info_by_fd(self.prog_fd, &[]) {
-            Ok(info) => Ok(ProgramInfo(info)),
-            Err(io_error) => Err(ProgramError::SyscallError {
-                call: "bpf_prog_get_info_by_fd",
-                io_error,
-            }),
-        }
+        ProgramInfo::new_from_fd(unsafe { OwnedFd::from_raw_fd(self.prog_fd) })
     }
 }
 

aya/src/programs/mod.rs

@@ -69,7 +69,7 @@ use libc::ENOSPC;
 use std::{
     ffi::CString,
     io,
-    os::fd::{AsFd, AsRawFd, OwnedFd, RawFd},
+    os::fd::{AsFd, AsRawFd, FromRawFd as _, OwnedFd, RawFd},
     path::{Path, PathBuf},
     time::{Duration, SystemTime},
 };
@@ -216,16 +216,6 @@ pub enum ProgramError {
     IOError(#[from] io::Error),
 }
 
-/// A [`Program`] file descriptor.
-#[derive(Copy, Clone)]
-pub struct ProgramFd(RawFd);
-
-impl AsRawFd for ProgramFd {
-    fn as_raw_fd(&self) -> RawFd {
-        self.0
-    }
-}
-
 /// eBPF program type.
 #[derive(Debug)]
 pub enum Program {
@@ -375,7 +365,7 @@ impl Program {
     ///
     /// Can be used to add a program to a [`crate::maps::ProgramArray`] or attach an [`Extension`] program.
     /// Can be converted to [`RawFd`] using [`AsRawFd`].
-    pub fn fd(&self) -> Option<ProgramFd> {
+    pub fn fd(&self) -> Option<OwnedFd> {
         match self {
             Program::KProbe(p) => p.fd(),
             Program::UProbe(p) => p.fd(),
@@ -496,14 +486,11 @@ impl<T: Link> ProgramData<T> {
                 io_error,
             })? as RawFd;
 
-        let info =
-            bpf_prog_get_info_by_fd(fd, &[]).map_err(|io_error| ProgramError::SyscallError {
-                call: "bpf_prog_get_info_by_fd",
-                io_error,
-            })?;
+        let info = ProgramInfo::new_from_fd(unsafe { OwnedFd::from_raw_fd(fd) })?;
+        let name = info.name_as_str().map(|s| s.to_string());
 
-        let name = ProgramInfo(info).name_as_str().map(|s| s.to_string());
-        ProgramData::from_bpf_prog_info(name, fd, path.as_ref(), info, verifier_log_level)
+        let ProgramInfo(bpf_prog_info) = info;
+        ProgramData::from_bpf_prog_info(name, fd, path.as_ref(), bpf_prog_info, verifier_log_level)
     }
 }
 
@@ -736,8 +723,8 @@ macro_rules! impl_fd {
         $(
             impl $struct_name {
                 /// Returns the file descriptor of this Program.
-                pub fn fd(&self) -> Option<ProgramFd> {
-                    self.data.fd.map(|fd| ProgramFd(fd))
+                pub fn fd(&self) -> Option<OwnedFd> {
+                    self.data.fd.map(|fd| unsafe{ OwnedFd::from_raw_fd(fd) })
                 }
             }
         )+
@@ -931,13 +918,7 @@ macro_rules! impl_program_info {
                 /// Returns the file descriptor of this Program.
                 pub fn program_info(&self) -> Result<ProgramInfo, ProgramError> {
                     let fd = self.fd().ok_or(ProgramError::NotLoaded)?;
-
-                    bpf_prog_get_info_by_fd(fd.as_raw_fd(), &[])
-                        .map_err(|io_error| ProgramError::SyscallError {
-                            call: "bpf_prog_get_info_by_fd",
-                            io_error,
-                        })
-                        .map(ProgramInfo)
+                    ProgramInfo::new_from_fd(fd)
                 }
             }
         )+
@@ -976,6 +957,15 @@ impl_program_info!(
 pub struct ProgramInfo(bpf_prog_info);
 
 impl ProgramInfo {
+    fn new_from_fd(fd: OwnedFd) -> Result<Self, ProgramError> {
+        bpf_prog_get_info_by_fd(fd.as_raw_fd(), &[])
+            .map_err(|io_error| ProgramError::SyscallError {
+                call: "bpf_prog_get_info_by_fd",
+                io_error,
+            })
+            .map(ProgramInfo)
+    }
+
     /// The name of the program as was provided when it was load. This is limited to 16 bytes
     pub fn name(&self) -> &[u8] {
         let length = self
@@ -1088,15 +1078,7 @@ impl ProgramInfo {
                 io_error,
             })? as RawFd;
 
-        let info =
-            bpf_prog_get_info_by_fd(fd, &[]).map_err(|io_error| ProgramError::SyscallError {
-                call: "bpf_prog_get_info_by_fd",
-                io_error,
-            })?;
-        unsafe {
-            libc::close(fd);
-        }
-        Ok(ProgramInfo(info))
+        ProgramInfo::new_from_fd(unsafe { OwnedFd::from_raw_fd(fd) })
     }
 }
 
@@ -1124,14 +1106,7 @@ impl Iterator for ProgramsIter {
                             call: "bpf_prog_get_fd_by_id",
                             io_error,
                         })
-                        .and_then(|fd| {
-                            bpf_prog_get_info_by_fd(fd.as_raw_fd(), &[])
-                                .map_err(|io_error| ProgramError::SyscallError {
-                                    call: "bpf_prog_get_info_by_fd",
-                                    io_error,
-                                })
-                                .map(ProgramInfo)
-                        }),
+                        .and_then(ProgramInfo::new_from_fd),
                 )
             }
             Ok(None) => None,