refactor: deconsolidate redox.patch into individual patches

The 556MB monolithic redox.patch was impossible to manage, unreviewable, blocked GitHub pushes, and could only grow. This commit: - Moves all 64 absorbed patches from absorbed/ to active use in base/ - Removes the absorbed/ directory (consolidation history is now PATCH-HISTORY.md) - Removes the redox.patch symlink from recipes/core/base/ - Fixes all recipe symlinks to point to active patches (not absorbed/) - Patches are now individually wired, reviewable, and independently rebasable The redox.patch mega-file is no longer needed — individual patches are applied directly from the recipe.toml patches list.
2026-05-03 08:35:26 +01:00
parent 1140f0f9b3
commit c0587f9a2d
107 changed files with 244 additions and 17208 deletions
@@ -0,0 +1,655 @@
+diff --git a/daemon/src/lib.rs b/daemon/src/lib.rs
+index 9f507221..a0ba9d88 100644
+--- a/daemon/src/lib.rs
+++ b/daemon/src/lib.rs
+@@ -11,12 +11,23 @@ use redox_scheme::Socket;
+ use redox_scheme::scheme::{SchemeAsync, SchemeSync};
+ 
+ unsafe fn get_fd(var: &str) -> RawFd {
+-    let fd: RawFd = std::env::var(var).unwrap().parse().unwrap();
+    let fd: RawFd = match std::env::var(var)
+        .map_err(|e| eprintln!("daemon: env var {var} not set: {e}"))
+        .ok()
+        .and_then(|val| {
+            val.parse()
+                .map_err(|e| eprintln!("daemon: failed to parse {var} as fd: {e}"))
+                .ok()
+        }) {
+        Some(fd) => fd,
+        None => return -1,
+    };
+     if unsafe { libc::fcntl(fd, libc::F_SETFD, libc::FD_CLOEXEC) } == -1 {
+-        panic!(
+        eprintln!(
+             "daemon: failed to set CLOEXEC flag for {var} fd: {}",
+             io::Error::last_os_error()
+         );
+        return -1;
+     }
+     fd
+ }
+@@ -51,31 +62,40 @@ impl Daemon {
+ 
+     /// Notify the process that the daemon is ready to accept requests.
+     pub fn ready(mut self) {
+-        self.write_pipe.write_all(&[0]).unwrap();
+        if let Err(err) = self.write_pipe.write_all(&[0]) {
+            if err.kind() != io::ErrorKind::BrokenPipe {
+                eprintln!("daemon::ready write failed: {err}");
+            }
+        }
+     }
+ 
+     /// Executes `Command` as a child process.
+     // FIXME remove once the service spawning of hwd and pcid-spawner is moved to init
+     #[deprecated]
+-    pub fn spawn(mut cmd: Command) {
+-        let (mut read_pipe, write_pipe) = io::pipe().unwrap();
+    pub fn spawn(mut cmd: Command) -> io::Result<()> {
+        let (mut read_pipe, write_pipe) = io::pipe().map_err(|err| {
+            io::Error::new(err.kind(), format!("daemon: failed to create readiness pipe: {err}"))
+        })?;
+ 
+         unsafe { pass_fd(&mut cmd, "INIT_NOTIFY", write_pipe.into()) };
+ 
+-        if let Err(err) = cmd.spawn() {
+-            eprintln!("daemon: failed to execute {cmd:?}: {err}");
+-            return;
+-        }
+        cmd.spawn().map_err(|err| {
+            io::Error::new(err.kind(), format!("failed to execute {cmd:?}: {err}"))
+        })?;
+ 
+         let mut data = [0];
+         match read_pipe.read_exact(&mut data) {
+-            Ok(()) => {}
+            Ok(()) => Ok(()),
+             Err(err) if err.kind() == io::ErrorKind::UnexpectedEof => {
+-                eprintln!("daemon: {cmd:?} exited without notifying readiness");
+-            }
+-            Err(err) => {
+-                eprintln!("daemon: failed to wait for {cmd:?}: {err}");
+                Err(io::Error::new(
+                    io::ErrorKind::UnexpectedEof,
+                    format!("{cmd:?} exited without notifying readiness"),
+                ))
+             }
+            Err(err) => Err(io::Error::new(
+                err.kind(),
+                format!("failed to wait for {cmd:?}: {err}"),
+            )),
+         }
+     }
+ }
+diff --git a/drivers/audio/ac97d/src/main.rs b/drivers/audio/ac97d/src/main.rs
+index ffa8a94b..4e381e48 100644
+--- a/drivers/audio/ac97d/src/main.rs
+++ b/drivers/audio/ac97d/src/main.rs
+@@ -3,6 +3,7 @@ use std::os::unix::io::AsRawFd;
+ use std::usize;
+ 
+ use event::{user_data, EventQueue};
+use log::error;
+ use pcid_interface::PciFunctionHandle;
+ use redox_scheme::scheme::register_sync_scheme;
+ use redox_scheme::Socket;
+@@ -22,13 +23,35 @@ fn daemon(daemon: daemon::Daemon, pcid_handle: PciFunctionHandle) -> ! {
+     let mut name = pci_config.func.name();
+     name.push_str("_ac97");
+ 
+-    let bar0 = pci_config.func.bars[0].expect_port();
+-    let bar1 = pci_config.func.bars[1].expect_port();
+    let bar0 = match pci_config.func.bars[0].try_port() {
+        Ok(port) => port,
+        Err(err) => {
+            error!("ac97d: invalid BAR0");
+            std::process::exit(1);
+        }
+    };
+    let bar1 = match pci_config.func.bars[1].try_port() {
+        Ok(port) => port,
+        Err(err) => {
+            error!("ac97d: invalid BAR1");
+            std::process::exit(1);
+        }
+    };
+    let bar1 = match pci_config.func.bars[1].try_port() {
+        Ok(port) => port,
+        Err(err) => {
+            error!("ac97d: invalid BAR1");
+            std::process::exit(1);
+        }
+    };
+ 
+     let irq = pci_config
+         .func
+         .legacy_interrupt_line
+-        .expect("ac97d: no legacy interrupts supported");
+        .unwrap_or_else(|| {
+            error!("ac97d: no legacy interrupts supported");
+            std::process::exit(1);
+        });
+ 
+     println!(" + ac97 {}", pci_config.func.display());
+ 
+@@ -40,13 +63,35 @@ fn daemon(daemon: daemon::Daemon, pcid_handle: PciFunctionHandle) -> ! {
+         common::file_level(),
+     );
+ 
+-    common::acquire_port_io_rights().expect("ac97d: failed to set I/O privilege level to Ring 3");
+    if let Err(err) = common::acquire_port_io_rights() {
+        error!("ac97d: failed to set I/O privilege level to Ring 3: {err}");
+        std::process::exit(1);
+    }
+ 
+-    let mut irq_file = irq.irq_handle("ac97d");
+    let mut irq_file = match irq.try_irq_handle("ac97d") {
+        Ok(file) => file,
+        Err(err) => {
+            error!("ac97d: failed to open IRQ handle");
+            std::process::exit(1);
+        }
+    };
+ 
+-    let socket = Socket::nonblock().expect("ac97d: failed to create socket");
+-    let mut device =
+-        unsafe { device::Ac97::new(bar0, bar1).expect("ac97d: failed to allocate device") };
+    let socket = match Socket::nonblock() {
+        Ok(socket) => socket,
+        Err(err) => {
+            error!("ac97d: failed to create socket: {err}");
+            std::process::exit(1);
+        }
+    };
+    let mut device = unsafe {
+        match device::Ac97::new(bar0, bar1) {
+            Ok(device) => device,
+            Err(err) => {
+                error!("ac97d: failed to allocate device: {err}");
+                std::process::exit(1);
+            }
+        }
+    };
+     let mut readiness_based = ReadinessBased::new(&socket, 16);
+ 
+     user_data! {
+@@ -56,49 +101,81 @@ fn daemon(daemon: daemon::Daemon, pcid_handle: PciFunctionHandle) -> ! {
+         }
+     }
+ 
+-    let event_queue = EventQueue::<Source>::new().expect("ac97d: Could not create event queue.");
+    let event_queue = match EventQueue::<Source>::new() {
+        Ok(queue) => queue,
+        Err(err) => {
+            error!("ac97d: could not create event queue: {err}");
+            std::process::exit(1);
+        }
+    };
+     event_queue
+         .subscribe(
+             irq_file.as_raw_fd() as usize,
+             Source::Irq,
+             event::EventFlags::READ,
+         )
+-        .unwrap();
+        .unwrap_or_else(|err| {
+            error!("ac97d: failed to subscribe IRQ fd: {err}");
+            std::process::exit(1);
+        });
+     event_queue
+         .subscribe(
+             socket.inner().raw(),
+             Source::Scheme,
+             event::EventFlags::READ,
+         )
+-        .unwrap();
+-
+-    register_sync_scheme(&socket, "audiohw", &mut device)
+-        .expect("ac97d: failed to register audiohw scheme to namespace");
+        .unwrap_or_else(|err| {
+            error!("ac97d: failed to subscribe scheme fd: {err}");
+            std::process::exit(1);
+        });
+
+        register_sync_scheme(&socket, "audiohw", &mut device).unwrap_or_else(|err| {
+            error!("ac97d: failed to register audiohw scheme to namespace: {err}");
+            std::process::exit(1);
+        });
+     daemon.ready();
+ 
+-    libredox::call::setrens(0, 0).expect("ac97d: failed to enter null namespace");
+    if let Err(err) = libredox::call::setrens(0, 0) {
+        error!("ac97d: failed to enter null namespace: {err}");
+        std::process::exit(1);
+    }
+ 
+     let all = [Source::Irq, Source::Scheme];
+-    for event in all
+-        .into_iter()
+-        .chain(event_queue.map(|e| e.expect("ac97d: failed to get next event").user_data))
+-    {
+    for event in all.into_iter().chain(event_queue.map(|e| match e {
+        Ok(event) => event.user_data,
+        Err(err) => {
+            error!("ac97d: failed to get next event: {err}");
+            std::process::exit(1);
+        }
+    })) {
+         match event {
+             Source::Irq => {
+                 let mut irq = [0; 8];
+-                irq_file.read(&mut irq).unwrap();
+                if let Err(err) = irq_file.read(&mut irq) {
+                    error!("ac97d: failed to read IRQ file: {err}");
+                    std::process::exit(1);
+                }
+ 
+                 if !device.irq() {
+                     continue;
+                 }
+-                irq_file.write(&mut irq).unwrap();
+                if let Err(err) = irq_file.write(&mut irq) {
+                    error!("ac97d: failed to acknowledge IRQ: {err}");
+                    std::process::exit(1);
+                }
+ 
+                 readiness_based
+                     .poll_all_requests(&mut device)
+-                    .expect("ac97d: failed to poll requests");
+                    .unwrap_or_else(|err| {
+                        error!("ac97d: failed to poll requests: {err}");
+                        std::process::exit(1);
+                    });
+                 readiness_based
+                     .write_responses()
+-                    .expect("ac97d: failed to write to socket");
+                    .unwrap_or_else(|err| {
+                        error!("ac97d: failed to write to socket: {err}");
+                        std::process::exit(1);
+                    });
+ 
+                 /*
+                 let next_read = device_irq.next_read();
+@@ -110,10 +187,16 @@ fn daemon(daemon: daemon::Daemon, pcid_handle: PciFunctionHandle) -> ! {
+             Source::Scheme => {
+                 readiness_based
+                     .read_and_process_requests(&mut device)
+-                    .expect("ac97d: failed to read from socket");
+                    .unwrap_or_else(|err| {
+                        error!("ac97d: failed to read from socket: {err}");
+                        std::process::exit(1);
+                    });
+                 readiness_based
+                     .write_responses()
+-                    .expect("ac97d: failed to write to socket");
+                    .unwrap_or_else(|err| {
+                        error!("ac97d: failed to write to socket: {err}");
+                        std::process::exit(1);
+                    });
+ 
+                 /*
+                 let next_read = device.borrow().next_read();
+@@ -125,7 +208,7 @@ fn daemon(daemon: daemon::Daemon, pcid_handle: PciFunctionHandle) -> ! {
+         }
+     }
+ 
+-    std::process::exit(0);
+    std::process::exit(1);
+ }
+ 
+ #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+diff --git a/drivers/audio/ihdad/src/main.rs b/drivers/audio/ihdad/src/main.rs
+index 31a2add7..4e455066 100755
+--- a/drivers/audio/ihdad/src/main.rs
+++ b/drivers/audio/ihdad/src/main.rs
+@@ -6,7 +6,7 @@ use std::os::unix::io::AsRawFd;
+ use std::usize;
+ 
+ use event::{user_data, EventQueue};
+-use pcid_interface::irq_helpers::pci_allocate_interrupt_vector;
+use pcid_interface::irq_helpers::try_pci_allocate_interrupt_vector;
+ use pcid_interface::PciFunctionHandle;
+ 
+ pub mod hda;
+@@ -38,9 +38,19 @@ fn daemon(daemon: daemon::Daemon, mut pcid_handle: PciFunctionHandle) -> ! {
+ 
+     log::info!("IHDA {}", pci_config.func.display());
+ 
+    if let Err(err) = pci_config.func.bars[0].try_mem() {
+        log::error!("ihdad: invalid BAR0");
+        std::process::exit(1);
+    }
+     let address = unsafe { pcid_handle.map_bar(0) }.ptr.as_ptr() as usize;
+ 
+-    let irq_file = pci_allocate_interrupt_vector(&mut pcid_handle, "ihdad");
+    let irq_file = match try_pci_allocate_interrupt_vector(&mut pcid_handle, "ihdad") {
+        Ok(irq) => irq,
+        Err(err) => {
+            log::error!("ihdad: failed to allocate interrupt vector");
+            std::process::exit(1);
+        }
+    };
+ 
+     {
+         let vend_prod: u32 = ((pci_config.func.full_device_id.vendor_id as u32) << 16)
+@@ -53,11 +63,28 @@ fn daemon(daemon: daemon::Daemon, mut pcid_handle: PciFunctionHandle) -> ! {
+             }
+         }
+ 
+-        let event_queue =
+-            EventQueue::<Source>::new().expect("ihdad: Could not create event queue.");
+-        let socket = Socket::nonblock().expect("ihdad: failed to create socket");
+        let event_queue = match EventQueue::<Source>::new() {
+            Ok(queue) => queue,
+            Err(err) => {
+                log::error!("ihdad: could not create event queue: {err}");
+                std::process::exit(1);
+            }
+        };
+        let socket = match Socket::nonblock() {
+            Ok(socket) => socket,
+            Err(err) => {
+                log::error!("ihdad: failed to create socket: {err}");
+                std::process::exit(1);
+            }
+        };
+         let mut device = unsafe {
+-            hda::IntelHDA::new(address, vend_prod).expect("ihdad: failed to allocate device")
+            match hda::IntelHDA::new(address, vend_prod) {
+                Ok(device) => device,
+                Err(err) => {
+                    log::error!("ihdad: failed to allocate device: {err}");
+                    std::process::exit(1);
+                }
+            }
+         };
+         let mut readiness_based = ReadinessBased::new(&socket, 16);
+ 
+diff --git a/drivers/graphics/ihdgd/src/main.rs b/drivers/graphics/ihdgd/src/main.rs
+index a8b6cc60..d855d108 100644
+--- a/drivers/graphics/ihdgd/src/main.rs
+++ b/drivers/graphics/ihdgd/src/main.rs
+@@ -1,6 +1,6 @@
+ use driver_graphics::GraphicsScheme;
+ use event::{user_data, EventQueue};
+-use pcid_interface::{irq_helpers::pci_allocate_interrupt_vector, PciFunctionHandle};
+use pcid_interface::{irq_helpers::try_pci_allocate_interrupt_vector, PciFunctionHandle};
+ use std::{
+     io::{Read, Write},
+     os::fd::AsRawFd,
+@@ -29,16 +29,32 @@ fn daemon(daemon: daemon::Daemon, mut pcid_handle: PciFunctionHandle) -> ! {
+ 
+     log::info!("IHDG {}", pci_config.func.display());
+ 
+-    let device = Device::new(&mut pcid_handle, &pci_config.func)
+-        .expect("ihdgd: failed to initialize device");
+    let device = match Device::new(&mut pcid_handle, &pci_config.func) {
+        Ok(device) => device,
+        Err(err) => {
+            log::error!("ihdgd: failed to initialize device: {err}");
+            std::process::exit(1);
+        }
+    };
+ 
+-    let irq_file = pci_allocate_interrupt_vector(&mut pcid_handle, "ihdgd");
+    let irq_file = match try_pci_allocate_interrupt_vector(&mut pcid_handle, "ihdgd") {
+        Ok(irq) => irq,
+        Err(err) => {
+            log::error!("ihdgd: failed to allocate interrupt vector");
+            std::process::exit(1);
+        }
+    };
+ 
+     // Needs to be before GraphicsScheme::new to avoid a deadlock due to initnsmgr blocking on
+     // /scheme/event as it is already blocked on opening /scheme/display.ihdg.*.
+     // FIXME change the initnsmgr to not block on openat for the target scheme.
+-    let event_queue: EventQueue<Source> =
+-        EventQueue::new().expect("ihdgd: failed to create event queue");
+    let event_queue: EventQueue<Source> = match EventQueue::new() {
+        Ok(eq) => eq,
+        Err(err) => {
+            log::error!("ihdgd: failed to create event queue: {err}");
+            std::process::exit(1);
+        }
+    };
+ 
+     let mut scheme = GraphicsScheme::new(device, format!("display.ihdg.{}", name), false);
+ 
+@@ -50,53 +66,69 @@ fn daemon(daemon: daemon::Daemon, mut pcid_handle: PciFunctionHandle) -> ! {
+         }
+     }
+ 
+-    event_queue
+-        .subscribe(
+-            scheme.inputd_event_handle().as_raw_fd() as usize,
+-            Source::Input,
+-            event::EventFlags::READ,
+-        )
+-        .unwrap();
+-    event_queue
+-        .subscribe(
+-            irq_file.irq_handle().as_raw_fd() as usize,
+-            Source::Irq,
+-            event::EventFlags::READ,
+-        )
+-        .unwrap();
+-    event_queue
+-        .subscribe(
+-            scheme.event_handle().raw(),
+-            Source::Scheme,
+-            event::EventFlags::READ,
+-        )
+-        .unwrap();
+-
+-    libredox::call::setrens(0, 0).expect("ihdgd: failed to enter null namespace");
+    if let Err(err) = event_queue.subscribe(
+        scheme.inputd_event_handle().as_raw_fd() as usize,
+        Source::Input,
+        event::EventFlags::READ,
+    ) {
+        log::error!("ihdgd: failed to subscribe to input events: {err}");
+    }
+    if let Err(err) = event_queue.subscribe(
+        irq_file.irq_handle().as_raw_fd() as usize,
+        Source::Irq,
+        event::EventFlags::READ,
+    ) {
+        log::error!("ihdgd: failed to subscribe to IRQ events: {err}");
+    }
+    if let Err(err) = event_queue.subscribe(
+        scheme.event_handle().raw(),
+        Source::Scheme,
+        event::EventFlags::READ,
+    ) {
+        log::error!("ihdgd: failed to subscribe to scheme events: {err}");
+    }
+
+    if let Err(err) = libredox::call::setrens(0, 0) {
+        log::error!("ihdgd: failed to enter null namespace: {err}");
+        std::process::exit(1);
+    }
+ 
+     daemon.ready();
+ 
+     let all = [Source::Input, Source::Irq, Source::Scheme];
+-    for event in all
+-        .into_iter()
+-        .chain(event_queue.map(|e| e.expect("ihdgd: failed to get next event").user_data))
+-    {
+    for event in all.into_iter().chain(
+        event_queue.filter_map(|e| match e {
+            Ok(event) => Some(event.user_data),
+            Err(err) => {
+                log::error!("ihdgd: failed to get next event: {err}");
+                None
+            }
+        }),
+    ) {
+         match event {
+             Source::Input => scheme.handle_vt_events(),
+             Source::Irq => {
+                 let mut irq = [0; 8];
+-                irq_file.irq_handle().read(&mut irq).unwrap();
+                if irq_file.irq_handle().read(&mut irq).is_err() {
+                    log::error!("ihdgd: failed to read IRQ");
+                    continue;
+                }
+                 if scheme.adapter_mut().handle_irq() {
+-                    irq_file.irq_handle().write(&mut irq).unwrap();
+                    if let Err(err) = irq_file.irq_handle().write(&mut irq) {
+                        log::error!("ihdgd: failed to write IRQ: {err}");
+                        continue;
+                    }
+ 
+                     scheme.adapter_mut().handle_events();
+-                    scheme.tick().unwrap();
+                    if let Err(err) = scheme.tick() {
+                        log::error!("ihdgd: failed to handle display events after IRQ: {err}");
+                    }
+                 }
+             }
+             Source::Scheme => {
+-                scheme
+-                    .tick()
+-                    .expect("ihdgd: failed to handle scheme events");
+                if let Err(err) = scheme.tick() {
+                    log::error!("ihdgd: failed to handle scheme events: {err}");
+                }
+             }
+         }
+     }
+diff --git a/drivers/pcid/src/driver_interface/bar.rs b/drivers/pcid/src/driver_interface/bar.rs
+index b2c1d35b..d333cd53 100644
+--- a/drivers/pcid/src/driver_interface/bar.rs
+++ b/drivers/pcid/src/driver_interface/bar.rs
+@@ -1,4 +1,5 @@
+ use std::convert::TryInto;
+use std::fmt;
+ 
+ use serde::{Deserialize, Serialize};
+ 
+@@ -12,6 +13,21 @@ pub enum PciBar {
+     Port(u16),
+ }
+ 
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub enum PciBarError {
+    WrongType,
+    Missing,
+}
+
+impl fmt::Display for PciBarError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            PciBarError::WrongType => write!(f, "wrong BAR type"),
+            PciBarError::Missing => write!(f, "BAR not present"),
+        }
+    }
+}
+
+ impl PciBar {
+     pub fn display(&self) -> String {
+         match self {
+@@ -29,27 +45,33 @@ impl PciBar {
+         }
+     }
+ 
+-    pub fn expect_port(&self) -> u16 {
+    pub fn try_port(&self) -> Result<u16, PciBarError> {
+         match *self {
+-            PciBar::Port(port) => port,
+-            PciBar::Memory32 { .. } | PciBar::Memory64 { .. } => {
+-                panic!("expected port BAR, found memory BAR");
+-            }
+-            PciBar::None => panic!("expected BAR to exist"),
+            PciBar::Port(port) => Ok(port),
+            PciBar::Memory32 { .. } | PciBar::Memory64 { .. } => Err(PciBarError::WrongType),
+            PciBar::None => Err(PciBarError::Missing),
+         }
+     }
+ 
+-    pub fn expect_mem(&self) -> (usize, usize) {
+    pub fn try_mem(&self) -> Result<(usize, usize), PciBarError> {
+         match *self {
+-            PciBar::Memory32 { addr, size } => (addr as usize, size as usize),
+-            PciBar::Memory64 { addr, size } => (
+            PciBar::Memory32 { addr, size } => Ok((addr as usize, size as usize)),
+            PciBar::Memory64 { addr, size } => Ok((
+                 addr.try_into()
+                     .expect("conversion from 64bit BAR to usize failed"),
+                 size.try_into()
+                     .expect("conversion from 64bit BAR size to usize failed"),
+-            ),
+-            PciBar::Port(_) => panic!("expected memory BAR, found port BAR"),
+-            PciBar::None => panic!("expected BAR to exist"),
+            )),
+            PciBar::Port(_) => Err(PciBarError::WrongType),
+            PciBar::None => Err(PciBarError::Missing),
+         }
+     }
+
+    pub fn expect_port(&self) -> u16 {
+        self.try_port().expect("expected port BAR")
+    }
+
+    pub fn expect_mem(&self) -> (usize, usize) {
+        self.try_mem().expect("expected memory BAR")
+    }
+ }
+diff --git a/drivers/pcid/src/driver_interface/irq_helpers.rs b/drivers/pcid/src/driver_interface/irq_helpers.rs
+index 28ca077a..d0c7042e 100644
+--- a/drivers/pcid/src/driver_interface/irq_helpers.rs
+++ b/drivers/pcid/src/driver_interface/irq_helpers.rs
+@@ -61,6 +61,14 @@ pub fn cpu_ids() -> io::Result<impl Iterator<Item = io::Result<usize>> + 'static
+     )
+ }
+ 
+/// Allocate a single interrupt vector. Returns the InterruptVector on success.
+pub fn try_pci_allocate_interrupt_vector(
+    pcid_handle: &mut crate::driver_interface::PciFunctionHandle,
+    driver: &str,
+) -> Result<InterruptVector, ()> {
+    Ok(pci_allocate_interrupt_vector(pcid_handle, driver))
+}
+
+ /// Allocate multiple interrupt vectors, from the IDT of the specified processor, returning the
+ /// start vector and the IRQ handles.
+ ///
+diff --git a/drivers/pcid/src/driver_interface/mod.rs b/drivers/pcid/src/driver_interface/mod.rs
+index bbc7304e..a77d79ec 100644
+--- a/drivers/pcid/src/driver_interface/mod.rs
+++ b/drivers/pcid/src/driver_interface/mod.rs
+@@ -29,6 +29,10 @@ pub struct LegacyInterruptLine {
+ }
+ 
+ impl LegacyInterruptLine {
+    /// Get an IRQ handle for this interrupt line.
+    pub fn try_irq_handle(self, driver: &str) -> Result<File, ()> {
+        Ok(self.irq_handle(driver))
+    }
+     /// Get an IRQ handle for this interrupt line.
+     pub fn irq_handle(self, driver: &str) -> File {
+         if let Some((phandle, addr, cells)) = self.phandled {
+@@ -452,6 +456,9 @@ impl PciFunctionHandle {
+             }
+         }
+     }
+    pub unsafe fn try_map_bar(&mut self, bir: u8) -> Result<&MappedBar, ()> {
+        Ok(self.map_bar(bir))
+    }
+     pub unsafe fn map_bar(&mut self, bir: u8) -> &MappedBar {
+         let mapped_bar = &mut self.mapped_bars[bir as usize];
+         if let Some(mapped_bar) = mapped_bar {
+diff --git a/drivers/virtio-core/src/transport.rs b/drivers/virtio-core/src/transport.rs
+index d3445d2d..2a316557 100644
+--- a/drivers/virtio-core/src/transport.rs
+++ b/drivers/virtio-core/src/transport.rs
+@@ -19,6 +19,8 @@ pub enum Error {
+     SyscallError(#[from] libredox::error::Error),
+     #[error("the device is incapable of {0:?}")]
+     InCapable(CfgType),
+    #[error("probe: {0}")]
+    Probe(&'static str),
+ }
+ 
+ /// Returns the queue part sizes in bytes.