diff --git a/pvmfw/src/instance.rs b/pvmfw/src/instance.rs
index b96ae1e..56468b2 100644
--- a/pvmfw/src/instance.rs
+++ b/pvmfw/src/instance.rs
@@ -29,9 +29,9 @@
 use diced_open_dice::Hidden;
 use log::trace;
 use uuid::Uuid;
-use virtio_drivers::transport::pci::bus::PciRoot;
+use virtio_drivers::transport::{pci::bus::PciRoot, DeviceType, Transport};
 use vmbase::util::ceiling_div;
-use vmbase::virtio::pci::VirtIOBlkIterator;
+use vmbase::virtio::pci::{PciTransportIterator, VirtIOBlk};
 use zerocopy::AsBytes;
 use zerocopy::FromBytes;
 
@@ -60,6 +60,8 @@
     RecordedDiceModeMismatch,
     /// Size of the instance.img entry being read or written is not supported.
     UnsupportedEntrySize(usize),
+    /// Failed to create VirtIO Block device.
+    VirtIOBlkCreationFailed(virtio_drivers::Error),
 }
 
 impl fmt::Display for Error {
@@ -89,6 +91,9 @@
             Self::RecordedCodeHashMismatch => write!(f, "Recorded code hash doesn't match"),
             Self::RecordedDiceModeMismatch => write!(f, "Recorded DICE mode doesn't match"),
             Self::UnsupportedEntrySize(sz) => write!(f, "Invalid entry size: {sz}"),
+            Self::VirtIOBlkCreationFailed(e) => {
+                write!(f, "Failed to create VirtIO Block device: {e}")
+            }
         }
     }
 }
@@ -178,7 +183,10 @@
 }
 
 fn find_instance_img(pci_root: &mut PciRoot) -> Result<Partition> {
-    for device in VirtIOBlkIterator::new(pci_root) {
+    for transport in
+        PciTransportIterator::new(pci_root).filter(|t| DeviceType::Block == t.device_type())
+    {
+        let device = VirtIOBlk::new(transport).map_err(Error::VirtIOBlkCreationFailed)?;
         match Partition::get_by_name(device, "vm-instance") {
             Ok(Some(p)) => return Ok(p),
             Ok(None) => {}
diff --git a/vmbase/src/virtio/pci.rs b/vmbase/src/virtio/pci.rs
index b54f7d1..cbb4d26 100644
--- a/vmbase/src/virtio/pci.rs
+++ b/vmbase/src/virtio/pci.rs
@@ -23,12 +23,9 @@
 use once_cell::race::OnceBox;
 use virtio_drivers::{
     device::blk,
-    transport::{
-        pci::{
-            bus::{BusDeviceIterator, PciRoot},
-            virtio_device_type, PciTransport,
-        },
-        DeviceType, Transport,
+    transport::pci::{
+        bus::{BusDeviceIterator, PciRoot},
+        virtio_device_type, PciTransport,
     },
 };
 
@@ -81,13 +78,13 @@
 /// Virtio Block device.
 pub type VirtIOBlk = blk::VirtIOBlk<HalImpl, PciTransport>;
 
-/// Virtio Block device iterator.
-pub struct VirtIOBlkIterator<'a> {
+/// An iterator that iterates over the PCI transport for each device.
+pub struct PciTransportIterator<'a> {
     pci_root: &'a mut PciRoot,
     bus: BusDeviceIterator,
 }
 
-impl<'a> VirtIOBlkIterator<'a> {
+impl<'a> PciTransportIterator<'a> {
     /// Creates a new iterator.
     pub fn new(pci_root: &'a mut PciRoot) -> Self {
         let bus = pci_root.enumerate_bus(0);
@@ -95,8 +92,8 @@
     }
 }
 
-impl<'a> Iterator for VirtIOBlkIterator<'a> {
-    type Item = VirtIOBlk;
+impl<'a> Iterator for PciTransportIterator<'a> {
+    type Item = PciTransport;
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
@@ -112,17 +109,7 @@
             };
             debug!("  VirtIO {:?}", virtio_type);
 
-            let mut transport =
-                PciTransport::new::<HalImpl>(self.pci_root, device_function).unwrap();
-            debug!(
-                "Detected virtio PCI device with device type {:?}, features {:#018x}",
-                transport.device_type(),
-                transport.read_device_features(),
-            );
-
-            if virtio_type == DeviceType::Block {
-                return Some(Self::Item::new(transport).expect("failed to create blk driver"));
-            }
+            return PciTransport::new::<HalImpl>(self.pci_root, device_function).ok();
         }
     }
 }