impl Fanotify {
  pub fn read_events_with_info_records(
          &self,
  ) -> Result<Vec<(FanotifyEvent, Vec<FanotifyInfoRecord>)>> {
          ...
          Ok(events)
      }
}

#[derive(Debug, Eq, Hash, PartialEq)]
#[allow(missing_copy_implementations)]
pub enum FanotifyInfoRecord {
    /// A [`libc::fanotify_event_info_fid`] event was recieved, usually as
    /// a result of passing [`InitFlags::FAN_REPORT_FID`] or [`InitFlags::FAN_REPORT_DIR_FID`]
    /// into [`Fanotify::init`]. The containing struct includes a `file_handle` for
    /// use with `open_by_handle_at(2)`.
    Fid(FanotifyFidRecord),

    /// A [`libc::fanotify_event_info_error`] event was recieved.
    /// This occurs when a FAN_FS_ERROR occurs, indicating an error with
    /// the watch filesystem object. (such as a bad file or bad link lookup)
    Error(FanotifyErrorRecord),

    /// A [`libc::fanotify_event_info_pidfd`] event was recieved, usually as
    /// a result of passing [`InitFlags::FAN_REPORT_PIDFD`] into [`Fanotify::init`].
    /// The containing struct includes a `pidfd` for reliably determining
    /// whether the process responsible for generating an event has been recycled or terminated
    Pidfd(FanotifyPidfdRecord),
}

pub struct FanotifyFidRecord(libc::fanotify_event_info_fid);

impl FanotifyFidRecord {

    pub fn filesystem_id(&self) -> libc::__kernel_fsid_t {
        self.0.fsid
    }

    pub fn handle(&self) -> [u8; 0] {
        self.0.handle
    }
}

pub struct FanotifyErrorRecord(libc::fanotify_event_info_error);

impl FanotifyErrorRecord {
    pub fn err(&self) -> Errno {
        Errno::from_raw(self.0.error)
    }

    pub fn err_count(&self) -> u32 {
        self.0.error_count
    }
}

pub struct FanotifyPidfdRecord(libc::fanotify_event_info_pidfd);

impl FanotifyPidfdRecord {
    pub fn pidfd(&self) -> Option<BorrowedFd> {
        if self.0.pidfd == libc::FAN_NOPIDFD || self.0.pidfd == libc::FAN_EPIDFD
        {
            None
        } else {
            Some(unsafe { BorrowedFd::borrow_raw(self.0.pidfd) })
        }
    }
}

impl Drop for FanotifyPidfdRecord {
    fn drop(&mut self) {
        if self.0.pidfd == libc::FAN_NOFD {
            return;
        }
        let e = close(self.0.pidfd);
        if !std::thread::panicking() && e == Err(Errno::EBADF) {
            panic!("Closing an invalid file descriptor!");
        };
    }
}