feat(userspace): log server sole console holder; init boots from manifest; adapter loads only init+storage

crates/init/src/load.rs

@@ -0,0 +1,106 @@
+//! Reading program files from storage and loading them into new processes.
+
+use libkos::fs::Storage;
+use libkos::syscall;
+use types::address::{EntryPoint, VirtualAddress};
+use types::bounded::{CapSlot, PageCount};
+use types::budget::Limits;
+
+const PAGE_SIZE: usize = 4096;
+const USER_CODE_BASE: usize = 0x10000;
+const USER_STACK_PAGES: usize = 4;
+const CREATE_CAP: CapSlot = CapSlot::const_new(0);
+/// Where a program file is read to before it is loaded (16 pages: the
+/// largest program init will load).
+const SCRATCH_VA: usize = 0x30000;
+const SCRATCH_PAGES: u16 = 16;
+
+pub(crate) struct LoadedProcess {
+    pub(crate) process_cap: CapSlot,
+    pub(crate) entry_point: EntryPoint,
+}
+
+/// Reads all of `filename` into `scratch`; its size, or `None` if it is
+/// missing, unreadable or larger than `scratch`.
+fn read_file(storage: &mut Storage, scratch: &mut [u8], filename: &[u8]) -> Option<usize> {
+    let handle = storage.open(filename).ok()?;
+    let size = storage.file_size(handle).ok().filter(|s| *s <= scratch.len());
+    let read = size.and_then(|s| storage.read(handle, &mut scratch[..s]).ok());
+    let _ = storage.close(handle);
+    read.filter(|r| Some(*r) == size)
+}
+
+pub(crate) fn load_binary(
+    storage: &mut Storage,
+    scratch: &mut [u8],
+    filename: &[u8],
+    limits: Limits,
+) -> Option<LoadedProcess> {
+    let file_size = read_file(storage, scratch, filename)?;
+    let elf_data = &scratch[..file_size];
+    let elf_info = match elf::parse(elf_data) {
+        Ok(info) => info,
+        Err(_) => return None,
+    };
+
+    let process_cap = syscall::create_process(CREATE_CAP, limits)?;
+
+    for segment in elf_info.segments() {
+        let page_start = segment.vaddr & !0xFFF;
+        let offset_in_page = segment.vaddr & 0xFFF;
+        let total_size = offset_in_page + segment.mem_size;
+        let seg_pages = (total_size + PAGE_SIZE - 1) / PAGE_SIZE;
+
+        let page_count = PageCount::new(seg_pages as u16)?;
+        let local_va = syscall::request_pages(page_count)?;
+
+        let local_ptr = local_va.raw() as *mut u8;
+        unsafe {
+            core::ptr::write_bytes(local_ptr, 0, seg_pages * PAGE_SIZE);
+        }
+
+        let copy_len = segment.file_size.min(segment.mem_size);
+        let src = segment
+            .file_offset
+            .checked_add(copy_len)
+            .and_then(|end| elf_data.get(segment.file_offset..end));
+        if let Some(src) = src.filter(|_| copy_len > 0) {
+            // SAFETY: the pages just requested hold seg_pages * PAGE_SIZE
+            // bytes, which covers offset_in_page + copy_len.
+            unsafe {
+                core::ptr::copy_nonoverlapping(src.as_ptr(), local_ptr.add(offset_in_page), copy_len);
+            }
+        }
+
+        for p in 0..seg_pages {
+            let src_page = VirtualAddress::from_raw(local_va.raw() + p * PAGE_SIZE);
+            let dst_page = VirtualAddress::from_raw(page_start + p * PAGE_SIZE);
+            syscall::map_page(process_cap, src_page, dst_page, segment.flags.execute);
+        }
+    }
+
+    for i in 0..USER_STACK_PAGES {
+        let page_count = PageCount::new(1)?;
+        let stack_va = syscall::request_pages(page_count)?;
+        let dst = VirtualAddress::from_raw(USER_CODE_BASE - (USER_STACK_PAGES - i) * PAGE_SIZE);
+        syscall::map_page(process_cap, stack_va, dst, false);
+    }
+
+    Some(LoadedProcess {
+        process_cap,
+        entry_point: EntryPoint::from_raw(elf_info.entry_point),
+    })
+}
+
+/// A region of init's own to read program files into.
+pub(crate) fn scratch() -> Option<&'static mut [u8]> {
+    let region = syscall::create_region(PageCount::new(SCRATCH_PAGES)?).ok()?;
+    syscall::map_region(
+        region,
+        VirtualAddress::from_raw(SCRATCH_VA),
+        types::mapping::PagePerms::ReadWrite,
+    )
+    .ok()?;
+    // SAFETY: the region is mapped read-write at SCRATCH_VA for good.
+    Some(unsafe { core::slice::from_raw_parts_mut(SCRATCH_VA as *mut u8, SCRATCH_PAGES as usize * PAGE_SIZE) })
+}