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

feat: proper IPC-based boot — init loads servers from storage via IPC, VirtIO GPU driver

Browse Source 
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:
Gabriel Kaszewski
2026-10-18 13:02:30 +02:00
parent ffde4065ba
commit 38f20cc3c4
41 changed files with 1676 additions and 808 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
crates/kernel/src/syscall/ipc.rs
View File

@@ -4,6 +4,31 @@ use super::{SyscallOutcome, SyscallResult};
use crate::Kernel;
impl<P: Platform> Kernel<P> {
pub(crate) fn handle_create_endpoint(
&mut self,
caller_pid: types::id::ProcessId,
) -> SyscallOutcome {
let ep_id = match self.create_endpoint() {
Ok(id) => id,
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
let all_perms = types::permission::PermissionSet::empty()
.with(types::permission::Permission::Read)
.with(types::permission::Permission::Write)
.with(types::permission::Permission::Execute)
.with(types::permission::Permission::Delegate);
match self.grant_cap(
caller_pid,
domain::resource::Resource::Endpoint(ep_id),
all_perms,
) {
Ok(slot) => SyscallOutcome::Complete(SyscallResult::Slot(slot)),
Err(e) => SyscallOutcome::Complete(SyscallResult::Error(e)),
}
}
pub(crate) fn handle_send(
&mut self,
caller_tid: types::id::ThreadId,

47
crates/kernel/src/syscall/lifecycle.rs
View File

@@ -70,6 +70,53 @@ impl<P: Platform> Kernel<P> {
SyscallOutcome::Complete(SyscallResult::Slot(slot))
}
pub(crate) fn handle_spawn_thread_in(
&mut self,
caller_pid: types::id::ProcessId,
process_cap: types::bounded::CapSlot,
entry: types::address::EntryPoint,
stack: types::address::StackPointer,
) -> SyscallOutcome {
use domain::scheduler::Scheduler;
use domain::thread::SavedContext;
let target_pid = match self.check_cap(
caller_pid,
process_cap,
types::permission::Permission::Execute,
) {
Ok(cap) => match cap.resource() {
domain::resource::Resource::Process(pid) => *pid,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: process_cap,
needed: types::permission::Permission::Execute,
},
)),
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
let priority = types::bounded::Priority::new(16)
.unwrap_or_else(|| unreachable!());
let time_slice = types::time::TimeSlice::new(100);
let context = SavedContext::with_entry_and_stack(entry, stack);
let tid = match self.threads.spawn_with_context(target_pid, priority, time_slice, None, context) {
Ok(t) => t,
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
if let Err(e) = self.processes.get_mut(target_pid).and_then(|p| p.add_thread(tid)) {
let _ = self.threads.destroy(tid);
return SyscallOutcome::Complete(SyscallResult::Error(e));
}
let core = self.platform.core_id();
self.scheduler.add(tid, priority, core);
SyscallOutcome::Complete(SyscallResult::Value(tid.raw() as usize))
}
pub(crate) fn handle_kill(
&mut self,
caller_pid: types::id::ProcessId,

92
crates/kernel/src/syscall/memory.rs
View File

@@ -1,4 +1,5 @@
use platform::Platform;
use types::address::{PhysicalAddress, VirtualAddress};
use super::{SyscallOutcome, SyscallResult};
use crate::Kernel;
@@ -11,19 +12,22 @@ impl<P: Platform> Kernel<P> {
) -> SyscallOutcome {
let pages = count.value() as usize;
if let Some(pm) = &mut self.process_memory[pid.raw() as usize] {
if pm.grant(pages).is_err() {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
));
}
} else {
return SyscallOutcome::Complete(SyscallResult::Error(
let pm = match &mut self.process_memory[pid.raw() as usize] {
Some(pm) => pm,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::InvalidProcess(pid),
)),
};
if pm.grant(pages).is_err() {
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
));
}
let addr = match self.page_pool.allocate(pages) {
let user_va = pm.alloc_user_va(pages);
let phys_addr = match self.page_pool.allocate(pages) {
Some(a) => a,
None => {
if let Some(pm) = &mut self.process_memory[pid.raw() as usize] {
@@ -35,48 +39,60 @@ impl<P: Platform> Kernel<P> {
}
};
let region = domain::memory::MemoryRegion::new(
types::id::RegionId::from_raw(0),
pid,
addr,
count,
types::generation::Generation::initial(),
);
let region_id = match self.regions.insert(region) {
Some(id) => id,
None => {
self.page_pool.free(addr, pages);
if let Some(pm) = &mut self.process_memory[pid.raw() as usize] {
let _ = pm.release(pages);
}
return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
));
}
};
for i in 0..pages {
let page_va = VirtualAddress::from_raw(user_va.raw() + i * 4096);
let page_pa = PhysicalAddress::from_raw(phys_addr.raw() + i * 4096);
self.platform.map_user_page(pid, page_va, page_pa, true, false);
}
let slot = match self.grant_cap(
pid,
domain::resource::Resource::Memory(region_id),
types::permission::PermissionSet::empty()
.with(types::permission::Permission::Read)
.with(types::permission::Permission::Write),
SyscallOutcome::Complete(SyscallResult::Value(user_va.raw()))
}
pub(crate) fn handle_map_page(
&mut self,
caller_pid: types::id::ProcessId,
process_cap: types::bounded::CapSlot,
src_va: VirtualAddress,
dst_va: VirtualAddress,
executable: bool,
) -> SyscallOutcome {
let target_pid = match self.check_cap(
caller_pid,
process_cap,
types::permission::Permission::Execute,
) {
Ok(s) => s,
Ok(cap) => match cap.resource() {
domain::resource::Resource::Process(pid) => *pid,
_ => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::PermissionDenied {
slot: process_cap,
needed: types::permission::Permission::Execute,
},
)),
},
Err(e) => return SyscallOutcome::Complete(SyscallResult::Error(e)),
};
SyscallOutcome::Complete(SyscallResult::Slot(slot))
let pa = match self.platform.translate_va(caller_pid, src_va) {
Some(pa) => pa,
None => return SyscallOutcome::Complete(SyscallResult::Error(
domain::error::KernelError::OutOfMemory,
)),
};
self.platform.map_user_page(target_pid, dst_va, pa, !executable, executable);
SyscallOutcome::Complete(SyscallResult::Ok)
}
pub(crate) fn handle_release_pages(
&mut self,
pid: types::id::ProcessId,
addr: types::address::VirtualAddress,
addr: VirtualAddress,
count: types::bounded::PageCount,
) -> SyscallOutcome {
let pages = count.value() as usize;
let phys = types::address::PhysicalAddress::from_raw(addr.raw());
let phys = PhysicalAddress::from_raw(addr.raw());
let region_id = match self.regions.find_by_base(pid, phys) {
Some((rid, _)) => rid,

8
crates/kernel/src/syscall/mod.rs
View File

@@ -55,6 +55,14 @@ impl<P: Platform> Kernel<P> {
Syscall::AcknowledgeInterrupt { irq } => self.handle_ack_interrupt(pid, irq),
Syscall::WaitAny { sources } => self.handle_wait_any(tid, pid, sources),
Syscall::Halt => self.handle_halt(pid),
Syscall::CreateEndpoint => self.handle_create_endpoint(pid),
Syscall::DebugPutchar { byte } => self.handle_debug_putchar(byte),
Syscall::MapPage { process, src_va, dst_va, executable } => {
self.handle_map_page(pid, process, src_va, dst_va, executable)
}
Syscall::SpawnThreadIn { process, entry, stack } => {
self.handle_spawn_thread_in(pid, process, entry, stack)
}
}
}
}

5
crates/kernel/src/syscall/simple.rs
View File

@@ -93,6 +93,11 @@ impl<P: Platform> Kernel<P> {
SyscallOutcome::TerminateCaller
}
pub(crate) fn handle_debug_putchar(&self, byte: u8) -> SyscallOutcome {
self.platform.debug_putchar(byte);
SyscallOutcome::Complete(SyscallResult::Ok)
}
pub(crate) fn handle_halt(
&mut self,
pid: types::id::ProcessId,