diff --git a/kernel/bin/riscv32i-unknown-none-elf.a b/kernel/bin/riscv32i-unknown-none-elf.a index bd6218967..97fefeff0 100644 Binary files a/kernel/bin/riscv32i-unknown-none-elf.a and b/kernel/bin/riscv32i-unknown-none-elf.a differ diff --git a/kernel/bin/riscv32imac-unknown-none-elf.a b/kernel/bin/riscv32imac-unknown-none-elf.a index fd897a658..f134e50ef 100644 Binary files a/kernel/bin/riscv32imac-unknown-none-elf.a and b/kernel/bin/riscv32imac-unknown-none-elf.a differ diff --git a/kernel/bin/riscv32imc-unknown-none-elf.a b/kernel/bin/riscv32imc-unknown-none-elf.a index fd897a658..f134e50ef 100644 Binary files a/kernel/bin/riscv32imc-unknown-none-elf.a and b/kernel/bin/riscv32imc-unknown-none-elf.a differ diff --git a/kernel/bin/riscv64gc-unknown-none-elf.a b/kernel/bin/riscv64gc-unknown-none-elf.a index fd72b4731..c26f36718 100644 Binary files a/kernel/bin/riscv64gc-unknown-none-elf.a and b/kernel/bin/riscv64gc-unknown-none-elf.a differ diff --git a/kernel/bin/riscv64imac-unknown-none-elf.a b/kernel/bin/riscv64imac-unknown-none-elf.a index fd72b4731..c26f36718 100644 Binary files a/kernel/bin/riscv64imac-unknown-none-elf.a and b/kernel/bin/riscv64imac-unknown-none-elf.a differ diff --git a/kernel/src/asm.S b/kernel/src/asm.S index 4d47efb55..1974ef615 100644 --- a/kernel/src/asm.S +++ b/kernel/src/asm.S @@ -33,9 +33,9 @@ _start: // have already been set up by the loader. jal x1, init - // Call the main function. This function diverges, so + // Call the kmain function. This function diverges, so // shouldn't ever return. - j main + j kmain /* diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 28a09fe3f..e56ea8b64 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -43,17 +43,17 @@ fn handle_panic(_arg: &PanicInfo) -> ! { pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offset: *mut u32) { unsafe { args::KernelArguments::init(arg_offset) }; let args = args::KernelArguments::get(); + // Everything needs memory, so the first thing we should do is initialize the memory manager. { use mem::MemoryManagerHandle; let mut memory_manager = MemoryManagerHandle::get(); memory_manager - .init(rpt_offset, &args) + .init_from_memory(rpt_offset, &args) .expect("couldn't initialize memory manager"); } - // Everything needs memory, so the first thing we should do is initialize the memory manager. { let mut system_services = SystemServicesHandle::get(); - system_services.init(init_offset, &args); + system_services.init_from_memory(init_offset, &args); } // Now that the memory manager is set up, perform any arch-specific initializations. @@ -90,9 +90,8 @@ fn next_pid_to_run(last_pid: Option) -> Option { None } -#[cfg_attr(baremetal, no_mangle)] -fn main() { - println!("Hello, world!"); +#[no_mangle] +pub extern "C" fn kmain() { // Either map memory using a syscall, or if we're debugging the syscall // handler then directly map it. #[cfg(all(feature = "debug-print", baremetal))] @@ -148,3 +147,10 @@ fn main() { } } } + +/// The main entrypoint when run in hosted mode. When running in embedded mode, +/// this function does not exist. +#[cfg(not(baremetal))] +fn main() { + kmain(); +} diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index b60c52022..2986bceda 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -116,7 +116,7 @@ impl DerefMut for MemoryManagerHandle<'_> { /// and place it at the usual offset. The MMU will not be enabled yet, /// as the process entry has not yet been created. impl MemoryManager { - pub fn init(&mut self, base: *mut u32, args: &KernelArguments) -> Result<(), xous::Error> { + pub fn init_from_memory(&mut self, base: *mut u32, args: &KernelArguments) -> Result<(), xous::Error> { let mut args_iter = args.iter(); let xarg_def = args_iter.next().expect("mm: no kernel arguments found"); assert!( diff --git a/kernel/src/server.rs b/kernel/src/server.rs index 004fae31b..6e4123517 100644 --- a/kernel/src/server.rs +++ b/kernel/src/server.rs @@ -130,15 +130,15 @@ impl Server { Ok(()) } - pub fn print_queue(&self) { - println!(" Q Queue Head: {}", self.queue_head); - println!(" Q Queue Tail: {}", self.queue_tail); - for (_idx, _entry) in self.queue.iter().enumerate() { - if _entry != &QueuedMessage::Empty { - println!(" Q entry[{}]: {:?}", _idx, _entry); - } - } - } + // pub fn print_queue(&self) { + // println!(" Q Queue Head: {}", self.queue_head); + // println!(" Q Queue Tail: {}", self.queue_tail); + // for (_idx, _entry) in self.queue.iter().enumerate() { + // if _entry != &QueuedMessage::Empty { + // println!(" Q entry[{}]: {:?}", _idx, _entry); + // } + // } + // } /// Convert a `QueuedMesage::WaitingResponse` into `QueuedMessage::Empty` /// and return the pair. Advance the tail. Note that the `idx` could be diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 995ea14e2..22c281226 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -201,7 +201,7 @@ impl SystemServices { /// Create a new "System Services" object based on the arguments from the /// kernel. These arguments decide where the memory spaces are located, as /// well as where the stack and program counter should initially go. - pub fn init(&mut self, base: *const u32, args: &KernelArguments) { + pub fn init_from_memory(&mut self, base: *const u32, args: &KernelArguments) { // Look through the kernel arguments and create a new process for each. let init_offsets = { let mut init_count = 1; diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 9d2a592a1..b1e46796c 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -166,9 +166,9 @@ pub fn handle(call: SysCall) -> core::result::Result .unwrap_or(Err(xous::Error::ProcessNotFound)) } SysCall::ReturnToParentI(_pid, _cpuid) => { - let mut ss = SystemServicesHandle::get(); + let _ss = SystemServicesHandle::get(); unsafe { - let (current_pid, current_ctx) = crate::arch::irq::take_isr_return_pair() + let (_current_pid, _current_ctx) = crate::arch::irq::take_isr_return_pair() .expect("couldn't get the isr return pair"); // ss.ready_context(current_pid, current_ctx).unwrap(); let (parent_pid, parent_ctx) = SWITCHTO_CALLER