block/virtio_blk: Add new driver

marv7000 · marv7000 · commit dd30b80d57f4 · 2026-07-31T00:30:02.000+02:00
diff --git a/drivers/block/virtio_blk/Cargo.toml b/drivers/block/virtio_blk/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "virtio_blk"
+version = "0.1.0"
+edition = "2024"
+build = "../../build.rs"
+
+[lib]
+crate-type = ["dylib"]
+
+[dependencies]
+zinnia = { workspace = true }
+virtio = { path = "../../common/virtio" }
diff --git a/drivers/block/virtio_blk/src/device.rs b/drivers/block/virtio_blk/src/device.rs
@@ -0,0 +1,180 @@
+use crate::{error::BlkError, queue::RequestQueue, spec};
+use virtio::VirtioDevice;
+use zinnia::{
+    alloc::sync::Arc,
+    arch,
+    device::{
+        Device,
+        block::{BioRequest, BlockDevice, BlockLimits, BlockOp},
+    },
+    log,
+    memory::Register,
+    posix::errno::{EResult, Errno},
+    vfs::file::{FileOps, OpenFlags},
+    warn,
+};
+
+const VIRTIO_BLK_MAJOR: u32 = 254;
+const MAX_TRANSFER_BYTES: usize = 1024 * 1024;
+
+pub struct Geometry {
+    lba_size: usize,
+    lba_count: u64,
+    sectors_per_lba: u64,
+    max_lbas: usize,
+    max_segments: usize,
+    read_only: bool,
+}
+
+impl Geometry {
+    pub fn read(virtio: &VirtioDevice, features: u32, queue_size: u16) -> Result<Self, BlkError> {
+        let read = |reg: Register<u32>| {
+            virtio
+                .read_config32(reg)
+                .map_err(|_| BlkError::UnsupportedLayout)
+        };
+
+        let capacity = (read(spec::config::CAPACITY_HI)? as u64) << 32
+            | read(spec::config::CAPACITY_LO)? as u64;
+
+        let lba_size = if features & spec::VIRTIO_BLK_F_BLK_SIZE != 0 {
+            let blk_size = read(spec::config::BLK_SIZE)? as usize;
+            if blk_size.is_power_of_two()
+                && blk_size >= spec::SECTOR_SIZE
+                && blk_size <= arch::virt::get_page_size()
+            {
+                blk_size
+            } else {
+                warn!("Ignoring unusable block size {blk_size}");
+                spec::SECTOR_SIZE
+            }
+        } else {
+            spec::SECTOR_SIZE
+        };
+
+        let sectors_per_lba = (lba_size / spec::SECTOR_SIZE) as u64;
+        let lba_count = capacity / sectors_per_lba;
+        if lba_count == 0 {
+            return Err(BlkError::UnsupportedLayout);
+        }
+
+        let hardware_segments = (queue_size as usize).saturating_sub(2).max(1);
+        let max_segments = if features & spec::VIRTIO_BLK_F_SEG_MAX != 0 {
+            (read(spec::config::SEG_MAX)? as usize).clamp(1, hardware_segments)
+        } else {
+            hardware_segments
+        };
+
+        let max_bytes = if features & spec::VIRTIO_BLK_F_SIZE_MAX != 0 {
+            match read(spec::config::SIZE_MAX)? as usize {
+                0 => MAX_TRANSFER_BYTES,
+                size_max => size_max.min(MAX_TRANSFER_BYTES),
+            }
+        } else {
+            MAX_TRANSFER_BYTES
+        };
+
+        Ok(Self {
+            lba_size,
+            lba_count,
+            sectors_per_lba,
+            max_lbas: (max_bytes / lba_size).max(1),
+            max_segments,
+            read_only: features & spec::VIRTIO_BLK_F_RO != 0,
+        })
+    }
+}
+
+pub struct VirtioBlkDevice {
+    queue: Arc<RequestQueue>,
+    geometry: Geometry,
+    minor: u32,
+}
+
+impl VirtioBlkDevice {
+    pub fn new(queue: Arc<RequestQueue>, geometry: Geometry, minor: u32) -> Self {
+        log!(
+            "New block device: {} byte blocks, {} MBs total, {}",
+            geometry.lba_size,
+            (geometry.lba_count * geometry.lba_size as u64) / 1024 / 1024,
+            if geometry.read_only {
+                "read-only"
+            } else {
+                "read-write"
+            }
+        );
+        Self {
+            queue,
+            geometry,
+            minor,
+        }
+    }
+}
+
+impl BlockDevice for VirtioBlkDevice {
+    fn get_lba_size(&self) -> usize {
+        self.geometry.lba_size
+    }
+
+    fn lba_count(&self) -> u64 {
+        self.geometry.lba_count
+    }
+
+    fn limits(&self) -> BlockLimits {
+        BlockLimits {
+            max_lbas: self.geometry.max_lbas,
+            max_segments: self.geometry.max_segments,
+        }
+    }
+
+    fn submit_bio(&self, bio: &Arc<BioRequest>) -> EResult<()> {
+        if self.geometry.read_only && bio.op() == BlockOp::Write {
+            bio.complete(Err(Errno::EROFS));
+            return Ok(());
+        }
+
+        let Some(end_lba) = bio.lba().checked_add(bio.num_lbas() as u64) else {
+            bio.complete(Err(Errno::EOVERFLOW));
+            return Ok(());
+        };
+        if end_lba > self.geometry.lba_count {
+            bio.complete(match bio.op() {
+                BlockOp::Read => Ok(0),
+                BlockOp::Write => Err(Errno::ENOSPC),
+            });
+            return Ok(());
+        }
+
+        let Some(sector) = bio.lba().checked_mul(self.geometry.sectors_per_lba) else {
+            bio.complete(Err(Errno::EOVERFLOW));
+            return Ok(());
+        };
+
+        let kind = match bio.op() {
+            BlockOp::Read => spec::req_type::IN,
+            BlockOp::Write => spec::req_type::OUT,
+        };
+
+        if let Err(error) = self.queue.submit(bio, kind, sector) {
+            bio.complete(Err(error.into()));
+            return Ok(());
+        }
+
+        self.queue.wait_if_polling(bio);
+        Ok(())
+    }
+}
+
+impl Device for VirtioBlkDevice {
+    fn open(self: Arc<Self>, _flags: OpenFlags) -> EResult<Arc<dyn FileOps>> {
+        Ok(self.clone())
+    }
+
+    fn major(&self) -> u32 {
+        VIRTIO_BLK_MAJOR
+    }
+
+    fn minor(&self) -> u32 {
+        self.minor
+    }
+}
diff --git a/drivers/block/virtio_blk/src/error.rs b/drivers/block/virtio_blk/src/error.rs
@@ -0,0 +1,37 @@
+use core::fmt::Display;
+use zinnia::posix::errno::Errno;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BlkError {
+    AllocationFailed,
+    EncodingFailed,
+    QueueFull,
+    NotifyFailed,
+    Timeout,
+    UnsupportedLayout,
+}
+
+impl From<BlkError> for Errno {
+    fn from(value: BlkError) -> Self {
+        match value {
+            BlkError::AllocationFailed => Errno::ENOMEM,
+            BlkError::QueueFull => Errno::EBUSY,
+            BlkError::Timeout => Errno::ETIMEDOUT,
+            BlkError::UnsupportedLayout => Errno::ENOTSUP,
+            _ => Errno::EIO,
+        }
+    }
+}
+
+impl Display for BlkError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            BlkError::AllocationFailed => f.write_str("Failed to allocate DMA memory"),
+            BlkError::EncodingFailed => f.write_str("A request header did not fit into its slot"),
+            BlkError::QueueFull => f.write_str("The request does not fit into the virtqueue"),
+            BlkError::NotifyFailed => f.write_str("Failed to notify the device"),
+            BlkError::Timeout => f.write_str("Timed out waiting for the device"),
+            BlkError::UnsupportedLayout => f.write_str("The device reported an unusable geometry"),
+        }
+    }
+}
diff --git a/drivers/block/virtio_blk/src/lib.rs b/drivers/block/virtio_blk/src/lib.rs
@@ -0,0 +1,128 @@
+#![no_std]
+
+use crate::{
+    device::{Geometry, VirtioBlkDevice},
+    queue::RequestQueue,
+};
+use core::sync::atomic::{AtomicUsize, Ordering};
+use virtio::VirtioDevice;
+use zinnia::{
+    alloc::{boxed::Box, format, sync::Arc},
+    device::pci::{DeviceView, Driver, PciVariant},
+    error,
+    irq::{IrqHandler, Status},
+    log,
+    posix::errno::{EResult, Errno},
+};
+
+mod device;
+mod error;
+mod queue;
+mod spec;
+
+const MSIX_VECTOR: u16 = 0;
+const MIN_QUEUE_SIZE: u16 = 4;
+
+static BLK_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+struct VirtioBlkIrqHandler {
+    queue: Arc<RequestQueue>,
+}
+
+impl IrqHandler for VirtioBlkIrqHandler {
+    fn raise(&mut self) -> Status {
+        self.queue.drain();
+        Status::Handled
+    }
+}
+
+fn enable_bus_mastering(view: &mut DeviceView<'static>) {
+    let command = view.access().read32(view.address(), 0x04) as u16;
+    let updated = command | (1 << 1) | (1 << 2);
+    view.access().write32(view.address(), 0x04, updated as u32);
+}
+
+fn bind_interrupts(virtio: &mut VirtioDevice) -> EResult<bool> {
+    if virtio.set_queue_msix_vector(spec::REQUEST_QUEUE, MSIX_VECTOR)? != MSIX_VECTOR {
+        return Ok(false);
+    }
+    virtio.set_config_msix_vector(0xFFFF)?;
+    Ok(true)
+}
+
+fn probe(_: &PciVariant, mut view: DeviceView<'static>) -> EResult<()> {
+    log!("Probing VirtIO block device on {}", view.address());
+
+    enable_bus_mastering(&mut view);
+    let irq_line = view.setup_irq().ok();
+
+    let mut virtio = VirtioDevice::new_pci(view)?;
+
+    let device_lo = virtio.get_device_features(0)?;
+    let device_hi = virtio.get_device_features(1)?;
+    if device_hi & spec::VIRTIO_F_VERSION_1_LO == 0 {
+        error!("VirtIO block device does not implement the 1.0 interface");
+        return Err(Errno::ENOTSUP);
+    }
+
+    let driver_lo = device_lo & spec::SUPPORTED_FEATURES;
+    virtio.set_driver_features(0, driver_lo)?;
+    virtio.set_driver_features(1, spec::VIRTIO_F_VERSION_1_LO)?;
+    virtio.finalize_features()?;
+    log!("Negotiated features: {driver_lo:#010x}");
+
+    if virtio.num_queues()? == 0 {
+        error!("VirtIO block device exposes no request queue");
+        return Err(Errno::ENODEV);
+    }
+
+    let queue = virtio.setup_queue(spec::REQUEST_QUEUE)?;
+    let queue_size = queue.queue_size();
+    if queue_size < MIN_QUEUE_SIZE {
+        error!("Request queue is too small ({queue_size} descriptors)");
+        return Err(Errno::ENODEV);
+    }
+
+    let geometry = Geometry::read(&virtio, driver_lo, queue_size)?;
+
+    let irq_line = match irq_line {
+        Some(line) => bind_interrupts(&mut virtio)?.then_some(line),
+        None => None,
+    };
+    if irq_line.is_none() {
+        log!("Falling back to polled completions");
+    }
+
+    virtio.set_driver_ok()?;
+
+    let requests = Arc::new(RequestQueue::new(virtio, queue, irq_line.is_none())?);
+
+    if let Some(line) = irq_line.as_ref() {
+        line.attach(Box::new(VirtioBlkIrqHandler {
+            queue: requests.clone(),
+        }));
+        line.unmask();
+    }
+
+    let index = BLK_COUNTER.fetch_add(1, Ordering::SeqCst);
+    let blk = Arc::new(VirtioBlkDevice::new(requests, geometry, index as u32));
+
+    zinnia::device::block::register_block_device(&format!("virtblk{index}"), blk)
+}
+
+const BASE_VARIANT: PciVariant = PciVariant::new().vendor(0x1AF4);
+
+static DRIVER: Driver = Driver {
+    name: "virtio_blk",
+    probe,
+    variants: &[BASE_VARIANT.device(0x1001), BASE_VARIANT.device(0x1042)],
+};
+
+zinnia::module!("VirtIO block driver", "Marvin Friedrich", main);
+
+pub fn main(_cmdline: &str) {
+    match DRIVER.register() {
+        Ok(_) => (),
+        Err(e) => error!("Unable to load VirtIO block driver: {:?}", e),
+    }
+}
diff --git a/drivers/block/virtio_blk/src/queue.rs b/drivers/block/virtio_blk/src/queue.rs
diff --git a/drivers/block/virtio_blk/src/spec.rs b/drivers/block/virtio_blk/src/spec.rs
