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

style: cargo fmt kernel crates

Browse Source
This commit is contained in:
Gabriel Kaszewski
2026-10-26 19:07:54 +01:00
parent 818eaecadd
commit 1c04ddf909
50 changed files with 995 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
crates/adapter-riscv/src/boot/caps.rs
View File

@@ -22,37 +22,85 @@ pub fn grant_all(
.with(types::permission::Permission::Read)
.with(types::permission::Permission::Execute);
let storage_ep = kern().create_endpoint()
let storage_ep = kern()
.create_endpoint()
.unwrap_or_else(|_| crate::halt(uart, "storage endpoint failed"));
kern().grant_capability(init_pid, domain::resource::Resource::Process(storage_pid), all_perms)
kern()
.grant_capability(
init_pid,
domain::resource::Resource::Process(storage_pid),
all_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
kern().grant_capability(init_pid, domain::resource::Resource::Endpoint(storage_ep), all_perms)
kern()
.grant_capability(
init_pid,
domain::resource::Resource::Endpoint(storage_ep),
all_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
kern().grant_capability(storage_pid, domain::resource::Resource::Endpoint(storage_ep), ipc_perms)
kern()
.grant_capability(
storage_pid,
domain::resource::Resource::Endpoint(storage_ep),
ipc_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
let display_ep = kern().create_endpoint()
let display_ep = kern()
.create_endpoint()
.unwrap_or_else(|_| crate::halt(uart, "display endpoint failed"));
kern().grant_capability(display_pid, domain::resource::Resource::Endpoint(display_ep), ipc_perms)
kern()
.grant_capability(
display_pid,
domain::resource::Resource::Endpoint(display_ep),
ipc_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
kern().grant_capability(init_pid, domain::resource::Resource::Endpoint(display_ep), all_perms)
kern()
.grant_capability(
init_pid,
domain::resource::Resource::Endpoint(display_ep),
all_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
kern().grant_capability(init_pid, domain::resource::Resource::Process(display_pid), all_perms)
kern()
.grant_capability(
init_pid,
domain::resource::Resource::Process(display_pid),
all_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
let input_ep = kern().create_endpoint()
let input_ep = kern()
.create_endpoint()
.unwrap_or_else(|_| crate::halt(uart, "input endpoint failed"));
kern().grant_capability(input_pid, domain::resource::Resource::Endpoint(input_ep), ipc_perms)
kern()
.grant_capability(
input_pid,
domain::resource::Resource::Endpoint(input_ep),
ipc_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
kern().grant_capability(init_pid, domain::resource::Resource::Endpoint(input_ep), all_perms)
kern()
.grant_capability(
init_pid,
domain::resource::Resource::Endpoint(input_ep),
all_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
kern().grant_capability(init_pid, domain::resource::Resource::Process(input_pid), all_perms)
kern()
.grant_capability(
init_pid,
domain::resource::Resource::Process(input_pid),
all_perms,
)
.unwrap_or_else(|_| crate::halt(uart, "grant failed"));
uart.write_str("k-os: capabilities granted\n");

2
crates/adapter-riscv/src/boot/hardware.rs
View File

@@ -1,6 +1,6 @@
use crate::hw::uart::Uart;
use crate::hw::virtio_blk::VirtioBlk;
use crate::{board, kernel_cell::KernelCell, mmu, platform, trap, KERNEL};
use crate::{KERNEL, board, kernel_cell::KernelCell, mmu, platform, trap};
unsafe extern "C" {
static _bss_start: u8;

61
crates/adapter-riscv/src/boot/loader.rs
View File

@@ -21,11 +21,16 @@ pub fn load_init(
kernel_pt: &mmu::PageTable,
) -> (LoadedProcess, ThreadId) {
let (pid, tid) = kern()
.boot(types::bounded::Priority::DEFAULT, types::time::TimeSlice::DEFAULT)
.boot(
types::bounded::Priority::DEFAULT,
types::time::TimeSlice::DEFAULT,
)
.unwrap_or_else(|_| crate::halt(uart, "boot failed"));
let entry = load_elf(blk, kernel_pt, pid, b"init.elf");
if entry == 0 { crate::halt(uart, "init.elf not found"); }
if entry == 0 {
crate::halt(uart, "init.elf not found");
}
setup_thread(tid, entry);
uart.write_str("k-os: init loaded\n");
@@ -39,11 +44,15 @@ pub fn load_server(
filename: &[u8],
label: &str,
) -> LoadedProcess {
let pid = kern().create_process_internal()
let pid = kern()
.create_process_internal()
.unwrap_or_else(|| crate::halt(uart, "process create failed"));
let entry = load_elf(blk, kernel_pt, pid, filename);
if entry == 0 { crate::halt(uart, "elf not found"); }
let tid = kern().spawn_thread_internal(pid)
if entry == 0 {
crate::halt(uart, "elf not found");
}
let tid = kern()
.spawn_thread_internal(pid)
.unwrap_or_else(|| crate::halt(uart, "thread spawn failed"));
setup_thread(tid, entry);
uart.write_str("k-os: ");
@@ -103,7 +112,9 @@ fn load_elf(
let buf = unsafe { core::slice::from_raw_parts_mut(buf_base as *mut u8, MAX_FILE_SIZE) };
let file_size = boot_fs::read_file_from_disk(blk, filename, buf).unwrap_or(0);
if file_size == 0 { return 0; }
if file_size == 0 {
return 0;
}
let elf_info = match elf::parse(&buf[..file_size]) {
Ok(info) => info,
@@ -130,7 +141,9 @@ fn load_elf(
let dest_off = if p == 0 { offset_in_page } else { 0 };
let copy_len = if seg_file_start < segment.file_size {
(segment.file_size - seg_file_start).min(4096 - dest_off)
} else { 0 };
} else {
0
};
if copy_len > 0 {
let src = segment.file_offset + seg_file_start;
@@ -152,25 +165,33 @@ fn load_elf(
} else {
mmu::Sv39Flags::user_rx()
};
mmu::map(user_pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(page_va),
pa: types::address::PhysicalAddress::from_raw(page),
pages: 1,
flags,
});
mmu::map(
user_pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(page_va),
pa: types::address::PhysicalAddress::from_raw(page),
pages: 1,
flags,
},
);
}
}
for i in 0..16usize {
let sp = mmu::allocator::alloc_zeroed_page();
mmu::map(user_pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(USER_VA_BASE - (16 - i) * 4096),
pa: types::address::PhysicalAddress::from_raw(sp),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
});
mmu::map(
user_pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(USER_VA_BASE - (16 - i) * 4096),
pa: types::address::PhysicalAddress::from_raw(sp),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
},
);
}
kern().platform_mut().set_page_table(pid, user_pt as *const mmu::PageTable as usize);
kern()
.platform_mut()
.set_page_table(pid, user_pt as *const mmu::PageTable as usize);
elf_info.entry_point
}

50
crates/adapter-riscv/src/boot_fs.rs
View File

@@ -19,7 +19,9 @@ impl BootFat16 {
}
let bytes_per_sector = u16::from_le_bytes([boot_sector[11], boot_sector[12]]);
if bytes_per_sector != SECTOR_SIZE as u16 { return None; }
if bytes_per_sector != SECTOR_SIZE as u16 {
return None;
}
let sectors_per_cluster = boot_sector[13];
let reserved_sectors = u16::from_le_bytes([boot_sector[14], boot_sector[15]]);
@@ -50,7 +52,9 @@ impl BootFat16 {
fn to_fat_name(name: &[u8]) -> [u8; 11] {
let mut fat = [b' '; 11];
let dot_pos = name.iter().position(|&b| b == b'.').unwrap_or(name.len());
for i in 0..dot_pos.min(8) { fat[i] = name[i].to_ascii_uppercase(); }
for i in 0..dot_pos.min(8) {
fat[i] = name[i].to_ascii_uppercase();
}
if dot_pos < name.len() {
for i in 0..(name.len() - dot_pos - 1).min(3) {
fat[8 + i] = name[dot_pos + 1 + i].to_ascii_uppercase();
@@ -67,7 +71,9 @@ pub fn read_file_from_disk(
let mut sector_buf = [0u8; SECTOR_SIZE];
// Read boot sector
if !blk.read_sector(0, &mut sector_buf) { return None; }
if !blk.read_sector(0, &mut sector_buf) {
return None;
}
let fs = BootFat16::parse(&sector_buf)?;
let fat_name = to_fat_name(filename);
@@ -78,25 +84,37 @@ pub fn read_file_from_disk(
let mut found = false;
for s in 0..fs.root_dir_sectors {
if !blk.read_sector((fs.root_dir_start + s) as u32, &mut sector_buf) { continue; }
if !blk.read_sector((fs.root_dir_start + s) as u32, &mut sector_buf) {
continue;
}
for i in 0..(SECTOR_SIZE / 32) {
let off = i * 32;
if sector_buf[off] == 0x00 { break; }
if sector_buf[off] == 0xE5 { continue; }
if sector_buf[off] == 0x00 {
break;
}
if sector_buf[off] == 0xE5 {
continue;
}
if sector_buf[off..off + 11] == fat_name {
first_cluster = u16::from_le_bytes([sector_buf[off + 26], sector_buf[off + 27]]);
file_size = u32::from_le_bytes([
sector_buf[off + 28], sector_buf[off + 29],
sector_buf[off + 30], sector_buf[off + 31],
sector_buf[off + 28],
sector_buf[off + 29],
sector_buf[off + 30],
sector_buf[off + 31],
]);
found = true;
break;
}
}
if found { break; }
if found {
break;
}
}
if !found { return None; }
if !found {
return None;
}
let size = (file_size as usize).min(out_buf.len());
let mut read = 0;
@@ -105,9 +123,13 @@ pub fn read_file_from_disk(
while read < size && cluster >= 2 && cluster < 0xFFF8 {
for s in 0..sectors_per_cluster {
if read >= size { break; }
if read >= size {
break;
}
let sector = fs.cluster_to_sector(cluster) + s;
if !blk.read_sector(sector, &mut sector_buf) { return Some(read); }
if !blk.read_sector(sector, &mut sector_buf) {
return Some(read);
}
let chunk = (size - read).min(SECTOR_SIZE);
out_buf[read..read + chunk].copy_from_slice(&sector_buf[..chunk]);
read += chunk;
@@ -117,7 +139,9 @@ pub fn read_file_from_disk(
let fat_offset = (cluster as u32) * 2;
let fat_sector = fs.reserved_sectors as u32 + fat_offset / SECTOR_SIZE as u32;
let fat_byte = (fat_offset % SECTOR_SIZE as u32) as usize;
if !blk.read_sector(fat_sector, &mut sector_buf) { break; }
if !blk.read_sector(fat_sector, &mut sector_buf) {
break;
}
cluster = u16::from_le_bytes([sector_buf[fat_byte], sector_buf[fat_byte + 1]]);
}

20
crates/adapter-riscv/src/devices/gpu_setup.rs
View File

@@ -38,9 +38,8 @@ pub fn configure(uart: &Uart, display_pid: ProcessId) {
gpu.init_device(vq_phys);
let queue = hw_virtio::queue::VirtioQueue::new(
hw_virtio::queue::QueueAddrs::from_base(vq_phys),
);
let queue =
hw_virtio::queue::VirtioQueue::new(hw_virtio::queue::QueueAddrs::from_base(vq_phys));
let dma = hw_virtio::gpu::GpuDmaAddrs {
cmd_pa: types::address::PhysicalAddress::from_raw(cmd_phys),
cmd_va: types::address::VirtualAddress::from_raw(cmd_phys),
@@ -86,12 +85,15 @@ pub fn configure(uart: &Uart, display_pid: ProcessId) {
}
fn map_page(pt: &mut mmu::PageTable, va: usize, pa: usize) {
mmu::map(pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(va),
pa: types::address::PhysicalAddress::from_raw(pa),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
});
mmu::map(
pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(va),
pa: types::address::PhysicalAddress::from_raw(pa),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
},
);
}
fn map_range(pt: &mut mmu::PageTable, va_base: usize, pa_base: usize, count: usize) {

15
crates/adapter-riscv/src/devices/input_setup.rs
View File

@@ -45,12 +45,15 @@ pub fn configure(uart: &Uart, input_pid: ProcessId) {
}
fn map_page(pt: &mut mmu::PageTable, va: usize, pa: usize) {
mmu::map(pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(va),
pa: types::address::PhysicalAddress::from_raw(pa),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
});
mmu::map(
pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(va),
pa: types::address::PhysicalAddress::from_raw(pa),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
},
);
}
fn map_range(pt: &mut mmu::PageTable, va_base: usize, pa_base: usize, count: usize) {

82
crates/adapter-riscv/src/devices/storage_setup.rs
View File

@@ -13,12 +13,7 @@ const PHYSINFO_VA: usize = 0x24000;
const SHARED_BUF_VA: usize = 0x30000;
const SHARED_BUF_PAGES: usize = 16;
pub fn configure(
uart: &Uart,
init_pid: ProcessId,
storage_pid: ProcessId,
virtio_base: usize,
) {
pub fn configure(uart: &Uart, init_pid: ProcessId, storage_pid: ProcessId, virtio_base: usize) {
let storage_pt = get_pt(storage_pid);
let init_pt = get_pt(init_pid);
@@ -39,47 +34,59 @@ fn get_pt(pid: ProcessId) -> &'static mut mmu::PageTable {
}
fn map_virtio_mmio(pt: &mut mmu::PageTable, virtio_base: usize) {
mmu::map(pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(VIRTIO_VA),
pa: types::address::PhysicalAddress::from_raw(virtio_base),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
});
mmu::map(
pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(VIRTIO_VA),
pa: types::address::PhysicalAddress::from_raw(virtio_base),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
},
);
}
fn alloc_and_map_virtqueue(pt: &mut mmu::PageTable) -> usize {
let phys = mmu::allocator::alloc_zeroed_page();
mmu::allocator::alloc_zeroed_page();
for i in 0..2usize {
mmu::map(pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(VQUEUE_VA + i * 4096),
pa: types::address::PhysicalAddress::from_raw(phys + i * 4096),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
});
mmu::map(
pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(VQUEUE_VA + i * 4096),
pa: types::address::PhysicalAddress::from_raw(phys + i * 4096),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
},
);
}
phys
}
fn alloc_and_map_reqhdr(pt: &mut mmu::PageTable) -> usize {
let phys = mmu::allocator::alloc_zeroed_page();
mmu::map(pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(REQHDR_VA),
pa: types::address::PhysicalAddress::from_raw(phys),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
});
mmu::map(
pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(REQHDR_VA),
pa: types::address::PhysicalAddress::from_raw(phys),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
},
);
phys
}
fn write_phys_info(pt: &mut mmu::PageTable, reqhdr_phys: usize) {
let phys = mmu::allocator::alloc_zeroed_page();
mmu::map(pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(PHYSINFO_VA),
pa: types::address::PhysicalAddress::from_raw(phys),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
});
mmu::map(
pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(PHYSINFO_VA),
pa: types::address::PhysicalAddress::from_raw(phys),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
},
);
unsafe {
let info = phys as *mut u64;
core::ptr::write_volatile(info, reqhdr_phys as u64);
@@ -104,11 +111,14 @@ fn map_shared_buffer(init_pt: &mut mmu::PageTable, storage_pt: &mut mmu::PageTab
flags: mmu::Sv39Flags::user_rw(),
};
mmu::map(init_pt, mapping);
mmu::map(storage_pt, mmu::Mapping {
va: types::address::VirtualAddress::from_raw(va),
pa: types::address::PhysicalAddress::from_raw(page),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
});
mmu::map(
storage_pt,
mmu::Mapping {
va: types::address::VirtualAddress::from_raw(va),
pa: types::address::PhysicalAddress::from_raw(page),
pages: 1,
flags: mmu::Sv39Flags::user_rw(),
},
);
}
}

10
crates/adapter-riscv/src/hw/uart.rs
View File

@@ -6,7 +6,9 @@ pub struct Uart {
impl Uart {
pub fn new() -> Self {
Self { base: board::UART_BASE }
Self {
base: board::UART_BASE,
}
}
pub fn put_char(&self, byte: u8) {
@@ -30,7 +32,11 @@ impl Uart {
let mut i = 0;
while value > 0 {
let digit = (value & 0xF) as u8;
buf[i] = if digit < 10 { b'0' + digit } else { b'a' + digit - 10 };
buf[i] = if digit < 10 {
b'0' + digit
} else {
b'a' + digit - 10
};
value >>= 4;
i += 1;
}

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

@@ -1,6 +1,6 @@
use hw_virtio::mmio::{self, DirectMmio};
use hw_virtio::queue::{QueueAddrs, VirtioQueue, QUEUE_SIZE};
use hw_virtio::block::{self, DmaAddrs};
use hw_virtio::mmio::{self, DirectMmio};
use hw_virtio::queue::{QUEUE_SIZE, QueueAddrs, VirtioQueue};
use types::address::{PhysicalAddress, VirtualAddress};
const SECTOR_SIZE: usize = 512;
@@ -11,7 +11,11 @@ struct VirtqMem {
}
static mut VQUEUE: VirtqMem = VirtqMem { _data: [0; 8192] };
static mut REQ_HEADER: block::BlockReqHeader = block::BlockReqHeader { req_type: 0, reserved: 0, sector: 0 };
static mut REQ_HEADER: block::BlockReqHeader = block::BlockReqHeader {
req_type: 0,
reserved: 0,
sector: 0,
};
static mut REQ_STATUS: u8 = 0xFF;
static mut SECTOR_BUF: [u8; SECTOR_SIZE] = [0; SECTOR_SIZE];

22
crates/adapter-riscv/src/hw/virtio_gpu.rs
View File

@@ -1,6 +1,6 @@
use hw_virtio::mmio::{self, DirectMmio};
use hw_virtio::queue::{QueueAddrs, VirtioQueue, QUEUE_SIZE};
use hw_virtio::gpu::{self, GpuDmaAddrs};
use hw_virtio::mmio::{self, DirectMmio};
use hw_virtio::queue::{QUEUE_SIZE, QueueAddrs, VirtioQueue};
use types::address::{PhysicalAddress, VirtualAddress};
use types::display::Dimension;
@@ -26,7 +26,14 @@ impl VirtioGpu {
mmio::init_legacy_device(&self.mmio, vqueue_phys, QUEUE_SIZE as u32);
}
pub fn setup_framebuffer(&self, cmd_phys: usize, vq_phys: usize, fb_phys: usize, width: Dimension, height: Dimension) -> bool {
pub fn setup_framebuffer(
&self,
cmd_phys: usize,
vq_phys: usize,
fb_phys: usize,
width: Dimension,
height: Dimension,
) -> bool {
let queue = VirtioQueue::new(QueueAddrs::from_base(vq_phys));
let dma = GpuDmaAddrs {
cmd_pa: PhysicalAddress::from_raw(cmd_phys),
@@ -34,7 +41,14 @@ impl VirtioGpu {
resp_pa: PhysicalAddress::from_raw(cmd_phys + 512),
};
let ok1 = gpu::create_2d(&self.mmio, &queue, &dma, 1, width, height);
let ok2 = gpu::attach_backing(&self.mmio, &queue, &dma, 1, PhysicalAddress::from_raw(fb_phys), width.raw() as u32 * height.raw() as u32 * 4);
let ok2 = gpu::attach_backing(
&self.mmio,
&queue,
&dma,
1,
PhysicalAddress::from_raw(fb_phys),
width.raw() as u32 * height.raw() as u32 * 4,
);
let ok3 = gpu::set_scanout(&self.mmio, &queue, &dma, 0, 1, width, height);
ok1 && ok2 && ok3
}

12
crates/adapter-riscv/src/main.rs
View File

@@ -42,8 +42,8 @@ extern "C" fn kmain() -> ! {
uart.write_str("k-os: booted on RISC-V\n");
let kernel_pt = boot::hardware::init(&uart);
let mut blk = boot::hardware::probe_block_device(&uart)
.unwrap_or_else(|| halt(&uart, "no block device"));
let mut blk =
boot::hardware::probe_block_device(&uart).unwrap_or_else(|| halt(&uart, "no block device"));
let (init, _) = boot::loader::load_init(&uart, &mut blk, kernel_pt);
let storage = boot::loader::load_server(&uart, &mut blk, kernel_pt, b"storage.elf", "storage");
@@ -65,7 +65,9 @@ pub fn halt(uart: &Uart, msg: &str) -> ! {
uart.write_str("k-os: FATAL — ");
uart.write_str(msg);
uart.put_char(b'\n');
loop { unsafe { core::arch::asm!("wfi") }; }
loop {
unsafe { core::arch::asm!("wfi") };
}
}
#[panic_handler]
@@ -78,5 +80,7 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
uart.write_dec(location.line() as usize);
}
uart.put_char(b'\n');
loop { unsafe { core::arch::asm!("wfi") }; }
loop {
unsafe { core::arch::asm!("wfi") };
}
}

6
crates/adapter-riscv/src/mmu/allocator.rs
View File

@@ -1,11 +1,13 @@
use super::page_table::{PageTable, PAGE_SIZE};
use super::page_table::{PAGE_SIZE, PageTable};
// Boot-time bump allocator for page tables.
// Only used during init before the scheduler starts.
static mut NEXT_FREE: usize = 0;
pub fn init_allocator(start: usize) {
unsafe { NEXT_FREE = start; }
unsafe {
NEXT_FREE = start;
}
}
pub fn alloc_zeroed_page() -> usize {

5
crates/adapter-riscv/src/mmu/mod.rs
View File

@@ -2,4 +2,7 @@ pub mod allocator;
pub mod page_table;
pub use allocator::init_allocator;
pub use page_table::{activate, init_kernel_page_table, create_user_page_table, map, translate, Sv39Flags, Mapping, PageTable, PAGE_SIZE};
pub use page_table::{
Mapping, PAGE_SIZE, PageTable, Sv39Flags, activate, create_user_page_table,
init_kernel_page_table, map, translate,
};

106
crates/adapter-riscv/src/mmu/page_table.rs
View File

@@ -1,5 +1,5 @@
use crate::board;
use super::allocator::alloc_page_table;
use crate::board;
use types::address::{PhysicalAddress, VirtualAddress};
pub use types::mapping::Mapping;
@@ -21,26 +21,40 @@ pub struct Sv39Flags {
impl Sv39Flags {
pub fn kernel_rwx() -> Self {
Self { bits: PTE_R | PTE_W | PTE_X | PTE_G }
Self {
bits: PTE_R | PTE_W | PTE_X | PTE_G,
}
}
pub fn kernel_rw() -> Self {
Self { bits: PTE_R | PTE_W | PTE_G }
Self {
bits: PTE_R | PTE_W | PTE_G,
}
}
pub fn user_rx() -> Self {
Self { bits: PTE_R | PTE_X | PTE_U }
Self {
bits: PTE_R | PTE_X | PTE_U,
}
}
pub fn user_rw() -> Self {
Self { bits: PTE_R | PTE_W | PTE_U }
Self {
bits: PTE_R | PTE_W | PTE_U,
}
}
pub fn user(read: bool, write: bool, exec: bool) -> Self {
let mut bits = PTE_U;
if read { bits |= PTE_R; }
if write { bits |= PTE_W; }
if exec { bits |= PTE_X; }
if read {
bits |= PTE_R;
}
if write {
bits |= PTE_W;
}
if exec {
bits |= PTE_X;
}
Self { bits }
}
@@ -94,15 +108,21 @@ fn vpn(va: usize, level: usize) -> usize {
pub fn translate(root: &PageTable, va: usize) -> Option<usize> {
let vpn2 = vpn(va, 2);
if !root.entries[vpn2].is_valid() { return None; }
if !root.entries[vpn2].is_valid() {
return None;
}
let l1 = unsafe { &*((root.entries[vpn2].ppn() << 12) as *const PageTable) };
let vpn1 = vpn(va, 1);
if !l1.entries[vpn1].is_valid() { return None; }
if !l1.entries[vpn1].is_valid() {
return None;
}
let l0 = unsafe { &*((l1.entries[vpn1].ppn() << 12) as *const PageTable) };
let vpn0 = vpn(va, 0);
if !l0.entries[vpn0].is_valid() { return None; }
if !l0.entries[vpn0].is_valid() {
return None;
}
let pa = (l0.entries[vpn0].ppn() << 12) as usize | (va & 0xFFF);
Some(pa)
}
@@ -137,29 +157,79 @@ fn map_page(root: &mut PageTable, va: usize, pa: usize, flags: Sv39Flags) {
pub fn map(root: &mut PageTable, mapping: Mapping<Sv39Flags>) {
for i in 0..mapping.pages {
let offset = i * PAGE_SIZE;
map_page(root, mapping.va.raw() + offset, mapping.pa.raw() + offset, mapping.flags);
map_page(
root,
mapping.va.raw() + offset,
mapping.pa.raw() + offset,
mapping.flags,
);
}
}
pub fn init_kernel_page_table() -> &'static mut PageTable {
let root = alloc_page_table();
let identity = |addr: usize| (VirtualAddress::from_raw(addr), PhysicalAddress::from_raw(addr));
let identity = |addr: usize| {
(
VirtualAddress::from_raw(addr),
PhysicalAddress::from_raw(addr),
)
};
let (va, pa) = identity(board::RAM_BASE);
map(root, Mapping { va, pa, pages: board::RAM_SIZE / PAGE_SIZE, flags: Sv39Flags::kernel_rwx() });
map(
root,
Mapping {
va,
pa,
pages: board::RAM_SIZE / PAGE_SIZE,
flags: Sv39Flags::kernel_rwx(),
},
);
let (va, pa) = identity(board::UART_BASE);
map(root, Mapping { va, pa, pages: 1, flags: Sv39Flags::kernel_rw() });
map(
root,
Mapping {
va,
pa,
pages: 1,
flags: Sv39Flags::kernel_rw(),
},
);
let (va, pa) = identity(board::PLIC_BASE);
map(root, Mapping { va, pa, pages: 0x400000 / PAGE_SIZE, flags: Sv39Flags::kernel_rw() });
map(
root,
Mapping {
va,
pa,
pages: 0x400000 / PAGE_SIZE,
flags: Sv39Flags::kernel_rw(),
},
);
let (va, pa) = identity(board::CLINT_BASE);
map(root, Mapping { va, pa, pages: 0x10000 / PAGE_SIZE, flags: Sv39Flags::kernel_rw() });
map(
root,
Mapping {
va,
pa,
pages: 0x10000 / PAGE_SIZE,
flags: Sv39Flags::kernel_rw(),
},
);
let (va, pa) = identity(board::VIRTIO_BASE);
map(root, Mapping { va, pa, pages: board::VIRTIO_SIZE / PAGE_SIZE, flags: Sv39Flags::kernel_rw() });
map(
root,
Mapping {
va,
pa,
pages: board::VIRTIO_SIZE / PAGE_SIZE,
flags: Sv39Flags::kernel_rw(),
},
);
root
}

70
crates/adapter-riscv/src/platform.rs
View File

@@ -57,12 +57,15 @@ impl Platform for RiscVPlatform {
fn configure_protection(&mut self, process: ProcessId, regions: &[MemoryRegion]) {
let pt = self.ensure_page_table(process);
for region in regions {
mmu::map(pt, mmu::Mapping {
va: VirtualAddress::from_raw(region.base().raw()),
pa: region.base(),
pages: region.size().value() as usize,
flags: mmu::Sv39Flags::user(true, true, true),
});
mmu::map(
pt,
mmu::Mapping {
va: VirtualAddress::from_raw(region.base().raw()),
pa: region.base(),
pages: region.size().value() as usize,
flags: mmu::Sv39Flags::user(true, true, true),
},
);
}
}
@@ -122,16 +125,19 @@ impl Platform for RiscVPlatform {
permissions: PermissionSet,
) {
let pt = self.ensure_page_table(process);
mmu::map(pt, mmu::Mapping {
va: VirtualAddress::from_raw(base.raw()),
pa: base,
pages: size.value() as usize,
flags: mmu::Sv39Flags::user(
permissions.allows(Permission::Read),
permissions.allows(Permission::Write),
permissions.allows(Permission::Execute),
),
});
mmu::map(
pt,
mmu::Mapping {
va: VirtualAddress::from_raw(base.raw()),
pa: base,
pages: size.value() as usize,
flags: mmu::Sv39Flags::user(
permissions.allows(Permission::Read),
permissions.allows(Permission::Write),
permissions.allows(Permission::Execute),
),
},
);
}
fn debug_putchar(&self, byte: u8) {
@@ -140,20 +146,32 @@ impl Platform for RiscVPlatform {
fn translate_va(&self, process: ProcessId, va: VirtualAddress) -> Option<PhysicalAddress> {
let pt_addr = self.page_tables[process.raw() as usize];
if pt_addr == 0 { return None; }
if pt_addr == 0 {
return None;
}
let pt = unsafe { &*(pt_addr as *const mmu::PageTable) };
mmu::translate(pt, va.raw()).map(PhysicalAddress::from_raw)
}
fn map_user_page(&mut self, process: ProcessId, va: VirtualAddress, pa: PhysicalAddress, writable: bool, executable: bool) {
fn map_user_page(
&mut self,
process: ProcessId,
va: VirtualAddress,
pa: PhysicalAddress,
writable: bool,
executable: bool,
) {
let pt = self.ensure_page_table(process);
let flags = mmu::Sv39Flags::user(true, writable, executable);
mmu::map(pt, mmu::Mapping {
va,
pa,
pages: 1,
flags,
});
mmu::map(
pt,
mmu::Mapping {
va,
pa,
pages: 1,
flags,
},
);
}
fn halt(&self) -> ! {
@@ -166,6 +184,8 @@ impl Platform for RiscVPlatform {
in("a6") 0usize,
);
}
loop { unsafe { core::arch::asm!("wfi") }; }
loop {
unsafe { core::arch::asm!("wfi") };
}
}
}

62
crates/adapter-riscv/src/trap/mod.rs
View File

@@ -17,7 +17,8 @@ impl TrapFrame {
}
}
global_asm!(r#"
global_asm!(
r#"
.align 4
.globl trap_vector
trap_vector:
@@ -120,7 +121,8 @@ _restore_smode:
csrrw sp, sscratch, sp
_sret_smode:
sret
"#);
"#
);
const CAUSE_INTERRUPT_BIT: usize = 1 << 63;
const CAUSE_S_TIMER: usize = 5;
@@ -169,7 +171,10 @@ fn decode_syscall(frame: &TrapFrame) -> Option<domain::syscall::Syscall> {
SYS_SEND => {
let slot = types::bounded::CapSlot::new(a0 as u8)?;
let msg = Message::from_words([a1, a2, a3, a4]);
Some(Syscall::Send { endpoint: slot, message: msg })
Some(Syscall::Send {
endpoint: slot,
message: msg,
})
}
SYS_RECEIVE => {
let slot = types::bounded::CapSlot::new(a0 as u8)?;
@@ -179,7 +184,11 @@ fn decode_syscall(frame: &TrapFrame) -> Option<domain::syscall::Syscall> {
let slot = types::bounded::CapSlot::new(a0 as u8)?;
let to = types::bounded::CapSlot::new(a1 as u8)?;
let perms = types::permission::PermissionSet::from_bits(a2 as u8);
Some(Syscall::Delegate { slot, to_endpoint: to, permissions: perms })
Some(Syscall::Delegate {
slot,
to_endpoint: to,
permissions: perms,
})
}
SYS_WAIT_FOR_INTERRUPT => {
let slot = types::bounded::CapSlot::new(a0 as u8)?;
@@ -190,14 +199,27 @@ fn decode_syscall(frame: &TrapFrame) -> Option<domain::syscall::Syscall> {
Some(Syscall::AcknowledgeInterrupt { irq: slot })
}
SYS_WAIT_ANY => {
let ep0 = if a0 != usize::MAX { types::bounded::CapSlot::new(a0 as u8) } else { None };
let ep1 = if a1 != usize::MAX { types::bounded::CapSlot::new(a1 as u8) } else { None };
let ep2 = if a2 != usize::MAX { types::bounded::CapSlot::new(a2 as u8) } else { None };
let ep3 = if a3 != usize::MAX { types::bounded::CapSlot::new(a3 as u8) } else { None };
let sources = WaitSet::new(
[ep0, ep1, ep2, ep3],
[None, None, None, None],
);
let ep0 = if a0 != usize::MAX {
types::bounded::CapSlot::new(a0 as u8)
} else {
None
};
let ep1 = if a1 != usize::MAX {
types::bounded::CapSlot::new(a1 as u8)
} else {
None
};
let ep2 = if a2 != usize::MAX {
types::bounded::CapSlot::new(a2 as u8)
} else {
None
};
let ep3 = if a3 != usize::MAX {
types::bounded::CapSlot::new(a3 as u8)
} else {
None
};
let sources = WaitSet::new([ep0, ep1, ep2, ep3], [None, None, None, None]);
Some(Syscall::WaitAny { sources })
}
SYS_CREATE_PROCESS => {
@@ -288,7 +310,7 @@ fn load_context_to_frame(ctx: &domain::thread::SavedContext, frame: &mut TrapFra
frame.sstatus = ctx.status();
// ensure returning to U-mode
frame.sstatus &= !(1 << 8); // clear SPP
frame.sstatus |= 1 << 5; // set SPIE
frame.sstatus |= 1 << 5; // set SPIE
}
fn apply_pending_result(frame: &mut TrapFrame, tid: types::id::ThreadId) {
@@ -315,7 +337,11 @@ fn write_result_direct(frame: &mut TrapFrame, result: &kernel::SyscallResult) {
}
}
fn switch_to_thread(frame: &mut TrapFrame, current_tid: types::id::ThreadId, next_tid: types::id::ThreadId) {
fn switch_to_thread(
frame: &mut TrapFrame,
current_tid: types::id::ThreadId,
next_tid: types::id::ThreadId,
) {
let kern = unsafe { &mut *crate::kernel_ptr() };
if let Some(ctx) = kern.thread_context_mut(current_tid) {
@@ -372,7 +398,9 @@ fn switch_to_next(frame: &mut TrapFrame, current_tid: types::id::ThreadId) {
}
}
} else {
loop { unsafe { core::arch::asm!("wfi") }; }
loop {
unsafe { core::arch::asm!("wfi") };
}
}
}
@@ -471,7 +499,9 @@ fn handle_exception(frame: &mut TrapFrame, scause: usize) {
kern.handle_fault(current_tid, fault, frame.sepc);
switch_to_next(frame, current_tid);
} else {
loop { unsafe { core::arch::asm!("wfi") }; }
loop {
unsafe { core::arch::asm!("wfi") };
}
}
}
}