Update

Author: nuta

kernel/src/boot.rs

@@ -25,6 +25,6 @@ pub struct BootInfo {
 pub fn boot(bootinfo: BootInfo) -> ! {
     crate::memory::init(&bootinfo);
     crate::cpuvar::init(0);
-    crate::loader::init(&bootinfo);
+    crate::server::init(&bootinfo);
     crate::scheduler::return_to_user();
 }

kernel/src/loader.rs

@@ -14,28 +14,22 @@ use ftl_utils::alignment::align_up;
 
 use crate::arch;
 use crate::arch::MIN_PAGE_SIZE;
-use crate::boot::BootInfo;
-use crate::initfs;
 use crate::memory::PAGE_ALLOCATOR;
 use crate::memory::PageType;
 
-const START_INFO: &StartInfo = &StartInfo {
-    sys_print: |bytes| {
-        println!("{}", core::str::from_utf8(bytes).unwrap());
-    },
-    sys_panic: || {
-        error!("server panicked");
-        crate::scheduler::return_to_user();
-    },
-};
-
-fn load_elf(elf_file: &[u8]) {
-    let elf = match Elf::parse(elf_file, ftl_elf::ET_DYN) {
-        Ok(elf) => elf,
-        Err(e) => {
-            panic!("failed to parse ELF file: {:?}", e);
-        }
-    };
+pub type EntryFn = extern "Rust" fn(start_info: *const StartInfo);
+
+#[derive(Debug)]
+pub enum Error {
+    ParseElf,
+    OutOfMemory,
+    BadRelocType,
+    BadRelocOffset,
+    BadRelocSize,
+}
+
+pub fn load_elf(elf_file: &[u8]) -> Result<(*const u8, usize, EntryFn), Error> {
+    let elf = Elf::parse(elf_file, ftl_elf::ET_DYN).map_err(|_| Error::ParseElf)?;
 
     // Find the end of the image to calculate the size of the memory it needs.
     let mut image_size = 0;
@@ -46,12 +40,9 @@ fn load_elf(elf_file: &[u8]) {
     }
 
     let image_size = align_up(image_size as usize, MIN_PAGE_SIZE);
-    let image_paddr = match PAGE_ALLOCATOR.alloc(image_size, PageType::Zeroed) {
-        Some(paddr) => paddr,
-        None => {
-            panic!("out of memory: {} bytes", image_size);
-        }
-    };
+    let image_paddr = PAGE_ALLOCATOR
+        .alloc(image_size, PageType::Zeroed)
+        .ok_or(Error::OutOfMemory)?;
 
     let image_ptr: *mut u8 = arch::paddr2vaddr(image_paddr).as_mut_ptr();
     let image = unsafe { slice::from_raw_parts_mut(image_ptr, image_size) };
@@ -107,7 +98,7 @@ fn load_elf(elf_file: &[u8]) {
     // Apply relocations.
     if rela_addr != 0 && rela_size > 0 {
         if rela_size % size_of::<Rela>() != 0 {
-            panic!("invalid relocation table size: {} bytes", rela_size);
+            return Err(Error::BadRelocSize);
         }
 
         let relocations = unsafe {
@@ -120,12 +111,12 @@ fn load_elf(elf_file: &[u8]) {
         for rela in relocations {
             let target_off = rela.r_offset as usize;
             if rela.r_sym() != 0 || rela.r_type() != R_X86_64_RELATIVE {
-                panic!("unexpected relocation type: {}", rela.r_type());
+                return Err(Error::BadRelocType);
             }
 
             let target_end = match target_off.checked_add(size_of::<u64>()) {
                 Some(end) if end <= image.len() => end,
-                _ => panic!("invalid relocation target offset: {}", target_off),
+                _ => return Err(Error::BadRelocOffset),
             };
 
             let base = image.as_ptr() as u64;
@@ -139,19 +130,5 @@ fn load_elf(elf_file: &[u8]) {
         core::mem::transmute::<*const u8, extern "Rust" fn(start_info: *const StartInfo)>(entry_ptr)
     };
 
-    trace!("Calling entry point: {:p}", entry_fn);
-    entry_fn(START_INFO);
-    trace!("Entry point returned");
-}
-
-pub fn init(bootinfo: &BootInfo) {
-    for module in &bootinfo.modules {
-        let initfs = initfs::InitFsLoader::new(module);
-        for file in initfs {
-            if file.name.starts_with(b"servers/") && file.name.ends_with(b".elf") {
-                trace!("loading {}...", core::str::from_utf8(file.name).unwrap());
-                load_elf(file.data);
-            }
-        }
-    }
+    Ok((image.as_ptr(), image_size, entry_fn))
 }

kernel/src/main.rs

@@ -21,6 +21,7 @@ mod loader;
 mod memory;
 mod panic;
 mod scheduler;
+mod server;
 mod shared_ref;
 mod spinlock;
 mod syscall;

kernel/src/server.rs

@@ -0,0 +1,53 @@
+use alloc::vec::Vec;
+
+use ftl_server::start::StartInfo;
+
+use crate::boot::BootInfo;
+use crate::initfs;
+use crate::spinlock::SpinLock;
+
+const START_INFO: &StartInfo = &StartInfo {
+    sys_print: |bytes| {
+        println!("{}", core::str::from_utf8(bytes).unwrap());
+    },
+    sys_panic: || {
+        error!("server panicked");
+        crate::scheduler::return_to_user();
+    },
+};
+
+static SERVERS: SpinLock<Vec<Server>> = SpinLock::new(Vec::new());
+
+pub struct Server {
+    image: *const u8,
+    image_size: usize,
+}
+
+impl Server {
+    fn load(elf_file: &[u8]) -> Result<Self, crate::loader::Error> {
+        let (image, image_size, entry_fn) = crate::loader::load_elf(elf_file)?;
+        entry_fn(START_INFO);
+        Ok(Self { image, image_size })
+    }
+}
+
+unsafe impl Send for Server {}
+
+pub fn init(bootinfo: &BootInfo) {
+    for module in &bootinfo.modules {
+        let initfs = initfs::InitFsLoader::new(module);
+        for file in initfs {
+            if file.name.starts_with(b"servers/") && file.name.ends_with(b".elf") {
+                trace!("loading {}...", core::str::from_utf8(file.name).unwrap());
+                match Server::load(file.data) {
+                    Ok(server) => {
+                        SERVERS.lock().push(server);
+                    }
+                    Err(e) => {
+                        error!("failed to load server: {:?}", e);
+                    }
+                }
+            }
+        }
+    }
+}

servers/lx/src/lib.rs

@@ -1,7 +1,5 @@
 #![cfg_attr(target_os = "none", no_std)]
 
-use ftl_server::info;
-
 struct Server {}
 
 impl Server {
@@ -18,7 +16,5 @@ impl ftl_server::Server for Server {
 
 #[unsafe(no_mangle)]
 pub fn init() {
-    info!("Hello from init!");
-    panic!("test panic");
     ftl_server::register(Server::new());
 }