GKaszewski/k-os
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(adapter-riscv): fix VirtIO block driver — scan all MMIO slots, handle legacy mode, fix virtqueue layout

Browse Source 
VirtIO now properly scans 8 MMIO slots, detects legacy vs modern mode,
uses correct virtqueue page alignment for legacy, and reads sectors.
Fixed disk image script to force FAT16 (mformat was creating FAT32).
init.elf successfully loaded from FAT16 disk via VirtIO on QEMU.
This commit is contained in:
Gabriel Kaszewski
2026-10-18 04:42:13 +02:00
parent 7649cb0b18
commit 924baede9e
2 changed files with 158 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
crates/adapter-riscv/src/hw/virtio_blk.rs
View File

@@ -1,6 +1,8 @@
const VIRTIO_MMIO_BASE: usize = 0x10001000;
const VIRTIO_MAGIC: u32 = 0x74726976;
const VIRTIO_BLK_DEVICE_ID: u32 = 2;
const VIRTIO_MMIO_FIRST: usize = 0x10001000;
const VIRTIO_MMIO_STRIDE: usize = 0x1000;
const VIRTIO_MMIO_SLOTS: usize = 8;
const VIRTIO_STATUS_ACK: u32 = 1;
const VIRTIO_STATUS_DRIVER: u32 = 2;
@@ -9,8 +11,20 @@ const VIRTIO_STATUS_DRIVER_OK: u32 = 4;
const QUEUE_SIZE: usize = 8;
const SECTOR_SIZE: usize = 512;
const PAGE_SIZE: usize = 4096;
#[repr(C, align(16))]
// Legacy VirtIO layout: used ring must start at page boundary after avail ring.
// descs: 8 * 16 = 128 bytes, avail: 22 bytes → total 150 → pad to 4096.
#[repr(C, align(4096))]
struct VirtqMem {
descs: [VirtqDesc; QUEUE_SIZE],
avail: VirtqAvail,
_pad: [u8; 3946],
used: VirtqUsed,
}
#[repr(C)]
#[derive(Clone, Copy)]
struct VirtqDesc {
addr: u64,
len: u32,
@@ -18,14 +32,15 @@ struct VirtqDesc {
next: u16,
}
#[repr(C, align(2))]
#[repr(C)]
struct VirtqAvail {
flags: u16,
idx: u16,
ring: [u16; QUEUE_SIZE],
used_event: u16,
}
#[repr(C, align(4))]
#[repr(C)]
struct VirtqUsed {
flags: u16,
idx: u16,
@@ -33,6 +48,7 @@ struct VirtqUsed {
}
#[repr(C)]
#[derive(Clone, Copy)]
struct VirtqUsedElem {
id: u32,
len: u32,
@@ -45,16 +61,14 @@ struct VirtioBlkReqHeader {
sector: u64,
}
static mut DESCS: [VirtqDesc; QUEUE_SIZE] = [const {
VirtqDesc { addr: 0, len: 0, flags: 0, next: 0 }
}; QUEUE_SIZE];
static mut AVAIL: VirtqAvail = VirtqAvail {
flags: 0, idx: 0, ring: [0; QUEUE_SIZE],
};
static mut USED: VirtqUsed = VirtqUsed {
flags: 0, idx: 0, ring: [const { VirtqUsedElem { id: 0, len: 0 } }; QUEUE_SIZE],
static mut VQUEUE: VirtqMem = VirtqMem {
descs: [const { VirtqDesc { addr: 0, len: 0, flags: 0, next: 0 } }; QUEUE_SIZE],
avail: VirtqAvail { flags: 0, idx: 0, ring: [0; QUEUE_SIZE], used_event: 0 },
_pad: [0; 3946],
used: VirtqUsed {
flags: 0, idx: 0,
ring: [const { VirtqUsedElem { id: 0, len: 0 } }; QUEUE_SIZE],
},
};
static mut REQ_HEADER: VirtioBlkReqHeader = VirtioBlkReqHeader {
@@ -63,108 +77,137 @@ static mut REQ_HEADER: VirtioBlkReqHeader = VirtioBlkReqHeader {
static mut REQ_STATUS: u8 = 0xFF;
fn mmio_read(offset: usize) -> u32 {
unsafe { core::ptr::read_volatile((VIRTIO_MMIO_BASE + offset) as *const u32) }
fn mmio_read(base: usize, offset: usize) -> u32 {
unsafe { core::ptr::read_volatile((base + offset) as *const u32) }
}
fn mmio_write(offset: usize, val: u32) {
unsafe { core::ptr::write_volatile((VIRTIO_MMIO_BASE + offset) as *mut u32, val) }
fn mmio_write(base: usize, offset: usize, val: u32) {
unsafe { core::ptr::write_volatile((base + offset) as *mut u32, val) }
}
pub struct VirtioBlk {
initialized: bool,
base: usize,
legacy: bool,
}
impl VirtioBlk {
pub fn probe() -> Option<Self> {
let magic = mmio_read(0x000);
let device_id = mmio_read(0x008);
if magic != VIRTIO_MAGIC || device_id != VIRTIO_BLK_DEVICE_ID {
return None;
for slot in 0..VIRTIO_MMIO_SLOTS {
let base = VIRTIO_MMIO_FIRST + slot * VIRTIO_MMIO_STRIDE;
let magic = mmio_read(base, 0x000);
let device_id = mmio_read(base, 0x008);
if magic == VIRTIO_MAGIC && device_id == VIRTIO_BLK_DEVICE_ID {
return Self::init_at(base);
}
}
None
}
fn init_at(base: usize) -> Option<Self> {
let version = mmio_read(base, 0x004);
let legacy = version == 1;
// Reset
mmio_write(0x070, 0);
mmio_write(base, 0x070, 0);
while mmio_read(base, 0x070) != 0 {}
// Acknowledge
mmio_write(0x070, VIRTIO_STATUS_ACK);
mmio_write(0x070, VIRTIO_STATUS_ACK | VIRTIO_STATUS_DRIVER);
// Acknowledge + Driver
mmio_write(base, 0x070, VIRTIO_STATUS_ACK);
mmio_write(base, 0x070, mmio_read(base, 0x070) | VIRTIO_STATUS_DRIVER);
// No feature negotiation needed for basic read
mmio_write(0x024, 0); // DriverFeaturesSel = 0
mmio_write(0x020, 0); // DriverFeatures = 0
mmio_write(0x070, VIRTIO_STATUS_ACK | VIRTIO_STATUS_DRIVER | VIRTIO_STATUS_FEATURES_OK);
let status = mmio_read(0x070);
if status & VIRTIO_STATUS_FEATURES_OK == 0 {
return None;
if legacy {
// Legacy: set guest page size
mmio_write(base, 0x028, PAGE_SIZE as u32);
}
// Set up queue 0
mmio_write(0x030, 0); // QueueSel = 0
mmio_write(0x038, QUEUE_SIZE as u32); // QueueNum
// Feature negotiation
mmio_write(base, 0x014, 0);
let _features = mmio_read(base, 0x010);
mmio_write(base, 0x024, 0);
mmio_write(base, 0x020, 0);
if !legacy {
mmio_write(base, 0x070, mmio_read(base, 0x070) | VIRTIO_STATUS_FEATURES_OK);
if mmio_read(base, 0x070) & VIRTIO_STATUS_FEATURES_OK == 0 {
return None;
}
}
// Queue setup
mmio_write(base, 0x030, 0);
let queue_max = mmio_read(base, 0x034);
if queue_max == 0 { return None; }
let queue_num = (QUEUE_SIZE as u32).min(queue_max);
mmio_write(base, 0x038, queue_num);
unsafe {
let desc_addr = core::ptr::addr_of!(DESCS) as u64;
let avail_addr = core::ptr::addr_of!(AVAIL) as u64;
let used_addr = core::ptr::addr_of!(USED) as u64;
let vq_addr = core::ptr::addr_of!(VQUEUE) as usize;
mmio_write(0x080, desc_addr as u32);
mmio_write(0x084, (desc_addr >> 32) as u32);
mmio_write(0x090, avail_addr as u32);
mmio_write(0x094, (avail_addr >> 32) as u32);
mmio_write(0x0A0, used_addr as u32);
mmio_write(0x0A4, (used_addr >> 32) as u32);
if legacy {
mmio_write(base, 0x040, (vq_addr / PAGE_SIZE) as u32);
} else {
let desc_addr = vq_addr as u64;
let avail_addr = (vq_addr + core::mem::offset_of!(VirtqMem, avail)) as u64;
let used_addr = (vq_addr + core::mem::offset_of!(VirtqMem, used)) as u64;
mmio_write(base, 0x080, desc_addr as u32);
mmio_write(base, 0x084, (desc_addr >> 32) as u32);
mmio_write(base, 0x090, avail_addr as u32);
mmio_write(base, 0x094, (avail_addr >> 32) as u32);
mmio_write(base, 0x0A0, used_addr as u32);
mmio_write(base, 0x0A4, (used_addr >> 32) as u32);
mmio_write(base, 0x044, 1);
}
}
mmio_write(0x044, 1); // QueueReady
mmio_write(0x070, VIRTIO_STATUS_ACK | VIRTIO_STATUS_DRIVER | VIRTIO_STATUS_FEATURES_OK | VIRTIO_STATUS_DRIVER_OK);
mmio_write(base, 0x070, mmio_read(base, 0x070) | VIRTIO_STATUS_DRIVER_OK);
Some(Self { initialized: true })
Some(Self { base, legacy })
}
pub fn read_sector(&mut self, sector: u32, buf: &mut [u8; SECTOR_SIZE]) -> bool {
if !self.initialized { return false; }
unsafe {
REQ_HEADER.req_type = 0; // read
REQ_HEADER.req_type = 0;
REQ_HEADER.reserved = 0;
REQ_HEADER.sector = sector as u64;
REQ_STATUS = 0xFF;
// Descriptor 0: header (device reads)
DESCS[0].addr = core::ptr::addr_of!(REQ_HEADER) as u64;
DESCS[0].len = 16;
DESCS[0].flags = 1; // NEXT
DESCS[0].next = 1;
VQUEUE.descs[0] = VirtqDesc {
addr: core::ptr::addr_of!(REQ_HEADER) as u64,
len: 16,
flags: 1, // NEXT
next: 1,
};
VQUEUE.descs[1] = VirtqDesc {
addr: buf.as_ptr() as u64,
len: SECTOR_SIZE as u32,
flags: 2 | 1, // WRITE | NEXT
next: 2,
};
VQUEUE.descs[2] = VirtqDesc {
addr: core::ptr::addr_of!(REQ_STATUS) as u64,
len: 1,
flags: 2, // WRITE
next: 0,
};
// Descriptor 1: data buffer (device writes)
DESCS[1].addr = buf.as_ptr() as u64;
DESCS[1].len = SECTOR_SIZE as u32;
DESCS[1].flags = 2 | 1; // WRITE | NEXT
DESCS[1].next = 2;
// Descriptor 2: status (device writes)
DESCS[2].addr = core::ptr::addr_of!(REQ_STATUS) as u64;
DESCS[2].len = 1;
DESCS[2].flags = 2; // WRITE
DESCS[2].next = 0;
// Add to available ring
let avail_idx = AVAIL.idx;
AVAIL.ring[(avail_idx as usize) % QUEUE_SIZE] = 0;
let avail_idx = core::ptr::read_volatile(core::ptr::addr_of!(VQUEUE.avail.idx));
VQUEUE.avail.ring[(avail_idx as usize) % QUEUE_SIZE] = 0;
core::sync::atomic::fence(core::sync::atomic::Ordering::SeqCst);
AVAIL.idx = avail_idx.wrapping_add(1);
core::ptr::write_volatile(
core::ptr::addr_of_mut!(VQUEUE.avail.idx),
avail_idx.wrapping_add(1),
);
core::sync::atomic::fence(core::sync::atomic::Ordering::SeqCst);
// Notify device
mmio_write(0x050, 0);
mmio_write(self.base, 0x050, 0);
// Wait for completion
let expected = avail_idx.wrapping_add(1);
while core::ptr::read_volatile(core::ptr::addr_of!(USED.idx)) != expected {
let mut timeout = 10_000_000u32;
while core::ptr::read_volatile(core::ptr::addr_of!(VQUEUE.used.idx)) != expected {
core::hint::spin_loop();
timeout -= 1;
if timeout == 0 { return false; }
}
REQ_STATUS == 0