feat: proper IPC-based boot — init loads servers from storage via IPC, VirtIO GPU driver
Complete microkernel boot pipeline: adapter loads only init + storage + display from disk. Init bootstraps all other servers by reading binaries from the storage server via IPC, parsing ELF, creating processes, mapping pages, and spawning threads. New syscalls: - CreateEndpoint: userspace endpoint creation with full capability grant - DebugPutchar: debug output to UART from userspace - MapPage: cross-process page mapping (init loads binaries into children) - SpawnThreadIn: spawn thread in another process via capability Key fixes: - Per-process L1 page tables for VPN[2]=0 (prevents cross-process corruption) - Separate kernel_pt from page_tables[0] (init pid=0 overwrote kernel PT ref) - Thread Running state set in switch_to_next (syscalls rejected without it) - Pending IPC results applied during context switch - SIE disabled during boot (timer can't preempt into unready processes) - User heap VA starts at 0x40000 (avoids shared buffer at 0x30000) - RequestPages maps at user VAs via per-process heap allocator VirtIO GPU: - Adapter probes for GPU device, initializes resource/scanout/backing - Display server writes to mapped framebuffer, flushes via GPU virtqueue - 640x480 BGRA framebuffer with transfer-to-host and resource-flush Storage server: - Userspace VirtIO block driver using pre-mapped MMIO and DMA pages - FAT16 filesystem reader serving file-read requests via IPC - Shared buffer protocol: init writes filename, storage writes file data Echo app for IPC testing (adapter-loaded echo proved the pipeline end-to-end).
This commit is contained in:
@@ -1,34 +1,123 @@
|
||||
use crate::framebuffer::Framebuffer;
|
||||
|
||||
const VIRTIO_GPU_BASE: usize = 0x10008000;
|
||||
const FB_WIDTH: u16 = 640;
|
||||
const FB_HEIGHT: u16 = 480;
|
||||
const GPU_MMIO_VA: usize = 0x20000;
|
||||
const VQUEUE_VA: usize = 0x21000;
|
||||
const CMDBUF_VA: usize = 0x23000;
|
||||
const PHYSINFO_VA: usize = 0x24000;
|
||||
const FB_VA: usize = 0x100000;
|
||||
const FB_BPP: usize = 4;
|
||||
const QUEUE_SIZE: usize = 8;
|
||||
|
||||
struct PhysInfo {
|
||||
cmd_pa: u64,
|
||||
resp_pa: u64,
|
||||
fb_pa: u64,
|
||||
width: u64,
|
||||
height: u64,
|
||||
}
|
||||
|
||||
fn read_phys_info() -> PhysInfo {
|
||||
unsafe {
|
||||
let p = PHYSINFO_VA as *const u64;
|
||||
PhysInfo {
|
||||
cmd_pa: core::ptr::read_volatile(p),
|
||||
resp_pa: core::ptr::read_volatile(p.add(1)),
|
||||
fb_pa: core::ptr::read_volatile(p.add(2)),
|
||||
width: core::ptr::read_volatile(p.add(3)),
|
||||
height: core::ptr::read_volatile(p.add(4)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn mmio_write(offset: usize, val: u32) {
|
||||
unsafe { core::ptr::write_volatile((GPU_MMIO_VA + offset) as *mut u32, val) }
|
||||
}
|
||||
|
||||
pub struct VirtioFramebuffer {
|
||||
buffer: &'static mut [u8],
|
||||
width: u16,
|
||||
height: u16,
|
||||
stride: usize,
|
||||
phys: PhysInfo,
|
||||
}
|
||||
|
||||
impl VirtioFramebuffer {
|
||||
pub fn new(buffer_addr: usize) -> Self {
|
||||
let stride = FB_WIDTH as usize * FB_BPP;
|
||||
let size = stride * FB_HEIGHT as usize;
|
||||
let buffer = unsafe { core::slice::from_raw_parts_mut(buffer_addr as *mut u8, size) };
|
||||
pub fn new(_buffer_addr: usize) -> Self {
|
||||
let phys = read_phys_info();
|
||||
let width = phys.width as u16;
|
||||
let height = phys.height as u16;
|
||||
let stride = width as usize * FB_BPP;
|
||||
|
||||
for byte in buffer.iter_mut() {
|
||||
*byte = 0;
|
||||
}
|
||||
Self { width, height, stride, phys }
|
||||
}
|
||||
|
||||
Self {
|
||||
buffer,
|
||||
width: FB_WIDTH,
|
||||
height: FB_HEIGHT,
|
||||
stride,
|
||||
fn send_gpu_cmd(&self, cmd_len: u32, resp_len: u32) {
|
||||
unsafe {
|
||||
let desc0 = VQUEUE_VA as *mut u8;
|
||||
core::ptr::write_volatile(desc0 as *mut u64, self.phys.cmd_pa);
|
||||
core::ptr::write_volatile(desc0.add(8) as *mut u32, cmd_len);
|
||||
core::ptr::write_volatile(desc0.add(12) as *mut u16, 1); // NEXT
|
||||
core::ptr::write_volatile(desc0.add(14) as *mut u16, 1);
|
||||
|
||||
let desc1 = desc0.add(16);
|
||||
core::ptr::write_volatile(desc1 as *mut u64, self.phys.resp_pa);
|
||||
core::ptr::write_volatile(desc1.add(8) as *mut u32, resp_len);
|
||||
core::ptr::write_volatile(desc1.add(12) as *mut u16, 2); // WRITE
|
||||
core::ptr::write_volatile(desc1.add(14) as *mut u16, 0);
|
||||
|
||||
let avail = VQUEUE_VA + QUEUE_SIZE * 16;
|
||||
let avail_idx = core::ptr::read_volatile((avail + 2) as *const u16);
|
||||
core::ptr::write_volatile(
|
||||
(avail + 4 + (avail_idx as usize % QUEUE_SIZE) * 2) as *mut u16,
|
||||
0,
|
||||
);
|
||||
core::sync::atomic::fence(core::sync::atomic::Ordering::SeqCst);
|
||||
core::ptr::write_volatile((avail + 2) as *mut u16, avail_idx.wrapping_add(1));
|
||||
core::sync::atomic::fence(core::sync::atomic::Ordering::SeqCst);
|
||||
|
||||
mmio_write(0x050, 0);
|
||||
|
||||
let used = VQUEUE_VA + 4096;
|
||||
let expected = avail_idx.wrapping_add(1);
|
||||
let mut timeout = 10_000_000u32;
|
||||
while core::ptr::read_volatile((used + 2) as *const u16) != expected {
|
||||
core::hint::spin_loop();
|
||||
timeout -= 1;
|
||||
if timeout == 0 { return; }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn transfer_and_flush(&self, x: u32, y: u32, w: u32, h: u32) {
|
||||
// TRANSFER_TO_HOST_2D
|
||||
unsafe {
|
||||
let p = CMDBUF_VA as *mut u8;
|
||||
core::ptr::write_bytes(p, 0, 512);
|
||||
core::ptr::write_volatile(p as *mut u32, 0x0105); // TRANSFER_TO_HOST_2D
|
||||
// rect at offset 24
|
||||
core::ptr::write_volatile(p.add(24) as *mut u32, x);
|
||||
core::ptr::write_volatile(p.add(28) as *mut u32, y);
|
||||
core::ptr::write_volatile(p.add(32) as *mut u32, w);
|
||||
core::ptr::write_volatile(p.add(36) as *mut u32, h);
|
||||
// offset at 40
|
||||
core::ptr::write_volatile(p.add(40) as *mut u64, 0);
|
||||
// resource_id at 48
|
||||
core::ptr::write_volatile(p.add(48) as *mut u32, 1);
|
||||
}
|
||||
self.send_gpu_cmd(56, 24);
|
||||
|
||||
// RESOURCE_FLUSH
|
||||
unsafe {
|
||||
let p = CMDBUF_VA as *mut u8;
|
||||
core::ptr::write_bytes(p, 0, 512);
|
||||
core::ptr::write_volatile(p as *mut u32, 0x0106); // RESOURCE_FLUSH
|
||||
core::ptr::write_volatile(p.add(24) as *mut u32, x);
|
||||
core::ptr::write_volatile(p.add(28) as *mut u32, y);
|
||||
core::ptr::write_volatile(p.add(32) as *mut u32, w);
|
||||
core::ptr::write_volatile(p.add(36) as *mut u32, h);
|
||||
core::ptr::write_volatile(p.add(40) as *mut u32, 1); // resource_id
|
||||
}
|
||||
self.send_gpu_cmd(48, 24);
|
||||
}
|
||||
}
|
||||
|
||||
impl Framebuffer for VirtioFramebuffer {
|
||||
@@ -41,15 +130,12 @@ impl Framebuffer for VirtioFramebuffer {
|
||||
}
|
||||
|
||||
fn write_pixel(&mut self, x: u16, y: u16, color: u32) {
|
||||
if x >= self.width || y >= self.height {
|
||||
return;
|
||||
}
|
||||
if x >= self.width || y >= self.height { return; }
|
||||
let offset = (y as usize) * self.stride + (x as usize) * FB_BPP;
|
||||
let bytes = color.to_le_bytes();
|
||||
self.buffer[offset] = bytes[0];
|
||||
self.buffer[offset + 1] = bytes[1];
|
||||
self.buffer[offset + 2] = bytes[2];
|
||||
self.buffer[offset + 3] = bytes[3];
|
||||
let buf = FB_VA + offset;
|
||||
unsafe {
|
||||
core::ptr::write_volatile(buf as *mut u32, color);
|
||||
}
|
||||
}
|
||||
|
||||
fn fill_rect(&mut self, x: u16, y: u16, w: u16, h: u16, color: u32) {
|
||||
@@ -61,21 +147,14 @@ impl Framebuffer for VirtioFramebuffer {
|
||||
}
|
||||
|
||||
fn clear(&mut self, color: u32) {
|
||||
let bytes = color.to_le_bytes();
|
||||
for y in 0..self.height as usize {
|
||||
for x in 0..self.width as usize {
|
||||
let offset = y * self.stride + x * FB_BPP;
|
||||
self.buffer[offset] = bytes[0];
|
||||
self.buffer[offset + 1] = bytes[1];
|
||||
self.buffer[offset + 2] = bytes[2];
|
||||
self.buffer[offset + 3] = bytes[3];
|
||||
}
|
||||
let total = self.width as usize * self.height as usize;
|
||||
let buf = FB_VA as *mut u32;
|
||||
for i in 0..total {
|
||||
unsafe { core::ptr::write_volatile(buf.add(i), color); }
|
||||
}
|
||||
}
|
||||
|
||||
fn flush(&mut self) {
|
||||
// VirtIO GPU flush would send TRANSFER_TO_HOST_2D + RESOURCE_FLUSH
|
||||
// For now, the buffer is memory-mapped — no explicit flush needed
|
||||
// when using ramfb or a simple scanout
|
||||
self.transfer_and_flush(0, 0, self.width as u32, self.height as u32);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,2 +1,3 @@
|
||||
pub mod mock_block;
|
||||
pub mod mock_fs;
|
||||
pub mod virtio_blk;
|
||||
|
||||
183
crates/servers/storage-server/src/adapters/virtio_blk.rs
Normal file
183
crates/servers/storage-server/src/adapters/virtio_blk.rs
Normal file
@@ -0,0 +1,183 @@
|
||||
use crate::block_device::{BlockDevice, SectorId};
|
||||
|
||||
const QUEUE_SIZE: usize = 8;
|
||||
const SECTOR_SIZE: usize = 512;
|
||||
|
||||
const MMIO_BASE: usize = 0x20000;
|
||||
const VQUEUE_VA: usize = 0x21000;
|
||||
const REQ_HDR_VA: usize = 0x23000;
|
||||
|
||||
// Physical addresses are written to a known location by the adapter at boot
|
||||
// Layout at 0x24000: [req_hdr_pa: u64, status_pa: u64, sector_buf_pa: u64]
|
||||
const PHYS_INFO_VA: usize = 0x24000;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy)]
|
||||
struct VirtqDesc {
|
||||
addr: u64,
|
||||
len: u32,
|
||||
flags: u16,
|
||||
next: u16,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct VirtqAvail {
|
||||
flags: u16,
|
||||
idx: u16,
|
||||
ring: [u16; QUEUE_SIZE],
|
||||
used_event: u16,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy)]
|
||||
struct VirtqUsedElem {
|
||||
id: u32,
|
||||
len: u32,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct VirtqUsed {
|
||||
flags: u16,
|
||||
idx: u16,
|
||||
ring: [VirtqUsedElem; QUEUE_SIZE],
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
struct VirtioBlkReqHeader {
|
||||
req_type: u32,
|
||||
reserved: u32,
|
||||
sector: u64,
|
||||
}
|
||||
|
||||
fn mmio_read(offset: usize) -> u32 {
|
||||
unsafe { core::ptr::read_volatile((MMIO_BASE + offset) as *const u32) }
|
||||
}
|
||||
|
||||
fn mmio_write(offset: usize, val: u32) {
|
||||
unsafe { core::ptr::write_volatile((MMIO_BASE + offset) as *mut u32, val) }
|
||||
}
|
||||
|
||||
fn descs() -> *mut VirtqDesc {
|
||||
VQUEUE_VA as *mut VirtqDesc
|
||||
}
|
||||
|
||||
fn avail() -> *mut VirtqAvail {
|
||||
(VQUEUE_VA + QUEUE_SIZE * 16) as *mut VirtqAvail
|
||||
}
|
||||
|
||||
fn used() -> *mut VirtqUsed {
|
||||
(VQUEUE_VA + 0x1000) as *mut VirtqUsed
|
||||
}
|
||||
|
||||
fn req_header() -> *mut VirtioBlkReqHeader {
|
||||
REQ_HDR_VA as *mut VirtioBlkReqHeader
|
||||
}
|
||||
|
||||
fn req_status() -> *mut u8 {
|
||||
(REQ_HDR_VA + 16) as *mut u8
|
||||
}
|
||||
|
||||
struct PhysAddrs {
|
||||
req_hdr: u64,
|
||||
status: u64,
|
||||
sector_buf: u64,
|
||||
}
|
||||
|
||||
fn read_phys_addrs() -> PhysAddrs {
|
||||
unsafe {
|
||||
let base = PHYS_INFO_VA as *const u64;
|
||||
PhysAddrs {
|
||||
req_hdr: core::ptr::read_volatile(base),
|
||||
status: core::ptr::read_volatile(base.add(1)),
|
||||
sector_buf: core::ptr::read_volatile(base.add(2)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct VirtioBlockDevice {
|
||||
phys: PhysAddrs,
|
||||
}
|
||||
|
||||
impl VirtioBlockDevice {
|
||||
pub fn new() -> Self {
|
||||
Self { phys: read_phys_addrs() }
|
||||
}
|
||||
}
|
||||
|
||||
impl BlockDevice for VirtioBlockDevice {
|
||||
fn sector_size(&self) -> usize {
|
||||
SECTOR_SIZE
|
||||
}
|
||||
|
||||
fn sector_count(&self) -> usize {
|
||||
0xFFFF
|
||||
}
|
||||
|
||||
fn read_sector(&mut self, sector: SectorId, buf: &mut [u8]) -> bool {
|
||||
if buf.len() < SECTOR_SIZE { return false; }
|
||||
|
||||
// Write to the local VA — device reads via physical address
|
||||
unsafe {
|
||||
let hdr = req_header();
|
||||
(*hdr).req_type = 0;
|
||||
(*hdr).reserved = 0;
|
||||
(*hdr).sector = sector.raw() as u64;
|
||||
|
||||
core::ptr::write_volatile(req_status(), 0xFF);
|
||||
|
||||
// Sector buffer: use a fixed area at REQ_HDR_VA + 32
|
||||
let sector_buf_va = (REQ_HDR_VA + 32) as *mut u8;
|
||||
|
||||
let d = descs();
|
||||
(*d.add(0)) = VirtqDesc {
|
||||
addr: self.phys.req_hdr,
|
||||
len: 16,
|
||||
flags: 1,
|
||||
next: 1,
|
||||
};
|
||||
(*d.add(1)) = VirtqDesc {
|
||||
addr: self.phys.sector_buf,
|
||||
len: SECTOR_SIZE as u32,
|
||||
flags: 2 | 1,
|
||||
next: 2,
|
||||
};
|
||||
(*d.add(2)) = VirtqDesc {
|
||||
addr: self.phys.status,
|
||||
len: 1,
|
||||
flags: 2,
|
||||
next: 0,
|
||||
};
|
||||
|
||||
let a = avail();
|
||||
let avail_idx = core::ptr::read_volatile(&(*a).idx);
|
||||
(*a).ring[(avail_idx as usize) % QUEUE_SIZE] = 0;
|
||||
core::sync::atomic::fence(core::sync::atomic::Ordering::SeqCst);
|
||||
core::ptr::write_volatile(&mut (*a).idx, avail_idx.wrapping_add(1));
|
||||
core::sync::atomic::fence(core::sync::atomic::Ordering::SeqCst);
|
||||
|
||||
mmio_write(0x050, 0);
|
||||
|
||||
let expected = avail_idx.wrapping_add(1);
|
||||
let u = used();
|
||||
let mut timeout = 10_000_000u32;
|
||||
while core::ptr::read_volatile(&(*u).idx) != expected {
|
||||
core::hint::spin_loop();
|
||||
timeout -= 1;
|
||||
if timeout == 0 { return false; }
|
||||
}
|
||||
|
||||
if core::ptr::read_volatile(req_status()) != 0 {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Copy from sector buffer VA to caller's buffer
|
||||
core::ptr::copy_nonoverlapping(sector_buf_va, buf.as_mut_ptr(), SECTOR_SIZE);
|
||||
}
|
||||
|
||||
true
|
||||
}
|
||||
|
||||
fn write_sector(&mut self, _sector: SectorId, _buf: &[u8]) -> bool {
|
||||
false
|
||||
}
|
||||
}
|
||||
@@ -11,16 +11,81 @@ pub mod server;
|
||||
#[path = "tests/mod.rs"]
|
||||
mod tests;
|
||||
|
||||
use userspace::syscall;
|
||||
|
||||
const CMD_READ_FILE: usize = 1;
|
||||
const SHARED_BUF_VA: usize = 0x30000;
|
||||
const SHARED_BUF_SIZE: usize = 64 * 1024;
|
||||
|
||||
fn shared_buf() -> &'static mut [u8] {
|
||||
unsafe { core::slice::from_raw_parts_mut(SHARED_BUF_VA as *mut u8, SHARED_BUF_SIZE) }
|
||||
}
|
||||
|
||||
fn debug_print(s: &[u8]) {
|
||||
for &b in s {
|
||||
syscall::debug_putchar(b);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run() -> ! {
|
||||
#[cfg(feature = "qemu-virt")]
|
||||
{
|
||||
let device = adapters::mock_block::MockBlockDevice::new(64);
|
||||
let filesystem = fs::fat16::Fat16::mount(device);
|
||||
if let Some(mut fs) = filesystem {
|
||||
let mut srv = server::StorageServer::new(fs);
|
||||
server_framework::serve(&mut srv, 0);
|
||||
debug_print(b"storage: started\n");
|
||||
|
||||
let device = adapters::virtio_blk::VirtioBlockDevice::new();
|
||||
let fat16 = fs::fat16::Fat16::mount(device);
|
||||
if fat16.is_none() {
|
||||
debug_print(b"storage: FAT16 mount failed\n");
|
||||
loop { syscall::yield_now(); }
|
||||
}
|
||||
let mut fat16 = fat16.unwrap();
|
||||
debug_print(b"storage: FAT16 mounted\n");
|
||||
|
||||
let ep: usize = 0;
|
||||
|
||||
loop {
|
||||
let (w0, w1, _w2, _w3) = syscall::receive(ep);
|
||||
|
||||
match w0 {
|
||||
CMD_READ_FILE => {
|
||||
let filename_len = w1;
|
||||
let buf = shared_buf();
|
||||
let filename_len = filename_len.min(buf.len());
|
||||
|
||||
let mut name_buf = [0u8; 32];
|
||||
let name_len = filename_len.min(32);
|
||||
name_buf[..name_len].copy_from_slice(&buf[..name_len]);
|
||||
|
||||
debug_print(b"storage: read ");
|
||||
debug_print(&name_buf[..name_len]);
|
||||
debug_print(b"...");
|
||||
|
||||
let file_size = read_entire_file(&mut fat16, &name_buf[..name_len], buf);
|
||||
|
||||
debug_print(if file_size > 0 { b"ok\n" } else { b"NOT FOUND\n" });
|
||||
|
||||
syscall::send(ep, file_size, 0, 0, 0);
|
||||
}
|
||||
_ => {
|
||||
syscall::send(ep, 0, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
loop { userspace::syscall::yield_now(); }
|
||||
}
|
||||
|
||||
fn read_entire_file<B: block_device::BlockDevice>(
|
||||
fat: &mut fs::fat16::Fat16<B>,
|
||||
filename: &[u8],
|
||||
out: &mut [u8],
|
||||
) -> usize {
|
||||
use filesystem::FileSystem;
|
||||
|
||||
let handle = match fat.open(filename) {
|
||||
Some(h) => h,
|
||||
None => return 0,
|
||||
};
|
||||
|
||||
let size = fat.file_size(handle).unwrap_or(0);
|
||||
let to_read = size.min(out.len());
|
||||
let read = fat.read(handle, &mut out[..to_read]).unwrap_or(0);
|
||||
fat.close(handle);
|
||||
read
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user