diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 76a4827a5..ba6749377 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -7,7 +7,7 @@ description = "Core kernel for Xous, including task switching and memory managem [dependencies] bitflags = "1.2.1" -xous = { path = "../xous-rs", features = ["forget-memory-messages"] } +xous-kernel = { package = "xous", path = "../xous-rs", features = ["forget-memory-messages"] } stats_alloc = { version = "0.1.8", optional = true } sha3 = { default-features = false, version = "0.8.2" } diff --git a/kernel/src/arch/hosted.rs b/kernel/src/arch/hosted.rs index 9c7ab60e9..c129b3a8e 100644 --- a/kernel/src/arch/hosted.rs +++ b/kernel/src/arch/hosted.rs @@ -14,7 +14,7 @@ use std::thread_local; use crate::arch::process::Process; use crate::services::SystemServices; -use xous::{MemoryAddress, ProcessInit, ProcessKey, Result, SysCall, PID, TID}; +use xous_kernel::{MemoryAddress, ProcessInit, ProcessKey, Result, SysCall, PID, TID}; enum ThreadMessage { SysCall(PID, TID, SysCall), @@ -146,7 +146,7 @@ fn handle_connection( ServerMessage::Exit => break, ServerMessage::ServerPacket(pkt) => { let thread_id = pkt[0]; - let call = xous::SysCall::from_args( + let call = xous_kernel::SysCall::from_args( pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8], ); match call { @@ -164,7 +164,7 @@ fn handle_connection( } ServerMessage::ServerPacketWithData(pkt, data) => { let thread_id = pkt[0]; - let call = xous::SysCall::from_args( + let call = xous_kernel::SysCall::from_args( pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8], ); match call { @@ -182,9 +182,9 @@ fn handle_connection( // ); if let SysCall::SendMessage(ref _cid, ref mut envelope) = call { match envelope { - xous::Message::MutableBorrow(msg) - | xous::Message::Borrow(msg) - | xous::Message::Move(msg) => { + xous_kernel::Message::MutableBorrow(msg) + | xous_kernel::Message::Borrow(msg) + | xous_kernel::Message::Move(msg) => { // Update the address pointer. This will get turned back into a // usable pointer by casting it back into a &[T] on the other // side. This is just a pointer to the start of data @@ -209,7 +209,7 @@ fn handle_connection( _ => unreachable!(), }; } - xous::Message::Scalar(_) => (), + xous_kernel::Message::Scalar(_) => (), } } else { panic!("unsupported message type"); @@ -225,7 +225,7 @@ fn handle_connection( chn.send(ThreadMessage::SysCall( pid, 1, - xous::SysCall::TerminateProcess, + xous_kernel::SysCall::TerminateProcess, )) .unwrap(); } @@ -419,7 +419,7 @@ pub fn idle() -> bool { #[cfg(not(test))] { let address = address_receiver.recv().unwrap(); - xous::arch::set_xous_address(address); + xous_kernel::arch::set_xous_address(address); println!("KERNEL: Xous server listening on {}", address); println!("KERNEL: Starting initial processes:"); let mut args = std::env::args(); @@ -435,13 +435,13 @@ pub fn idle() -> bool { println!("-------+------------------"); for arg in args { let process_key = generate_pid_key(); - let init = xous::ProcessInit { + let init = xous_kernel::ProcessInit { key: ProcessKey::new(process_key), }; let new_pid = SystemServices::with_mut(|ss| ss.create_process(init)).unwrap(); println!(" {:^5} | {}", new_pid, arg); - let process_args = xous::ProcessArgs::new("program", arg); - xous::arch::create_process_post(process_args, init, new_pid).expect("couldn't spawn"); + let process_args = xous_kernel::ProcessArgs::new("program", arg); + xous_kernel::arch::create_process_post(process_args, init, new_pid).expect("couldn't spawn"); } } diff --git a/kernel/src/arch/hosted/irq.rs b/kernel/src/arch/hosted/irq.rs index 9744eda1c..b02181dc2 100644 --- a/kernel/src/arch/hosted/irq.rs +++ b/kernel/src/arch/hosted/irq.rs @@ -1,4 +1,4 @@ -use xous::{TID, PID}; +use xous_kernel::{TID, PID}; pub fn disable_all_irqs() { // There are no IRQs in a hosted environment, so there's nothing to do. @@ -12,8 +12,8 @@ pub fn enable_irq(_irq_no: usize) { unimplemented!(); } -pub fn disable_irq(_irq_no: usize) -> Result<(), xous::Error> { - Err(xous::Error::UnhandledSyscall) +pub fn disable_irq(_irq_no: usize) -> Result<(), xous_kernel::Error> { + Err(xous_kernel::Error::UnhandledSyscall) } pub unsafe fn take_isr_return_pair() -> Option<(PID, TID)> { diff --git a/kernel/src/arch/hosted/mem.rs b/kernel/src/arch/hosted/mem.rs index 2b84ece7a..749bb5f7d 100644 --- a/kernel/src/arch/hosted/mem.rs +++ b/kernel/src/arch/hosted/mem.rs @@ -1,6 +1,6 @@ pub const PAGE_SIZE: usize = 4096; use crate::mem::MemoryManager; -use xous::{Error, MemoryFlags, PID}; +use xous_kernel::{Error, MemoryFlags, PID}; pub const DEFAULT_HEAP_BASE: usize = 0x2000_0000; pub const DEFAULT_MESSAGE_BASE: usize = 0x4000_0000; @@ -32,7 +32,7 @@ impl MemoryMapping { /// kernel, which should be mapped into every possible address space. /// As such, this will only have an observable effect once code returns /// to userspace. - pub fn activate(self) -> Result<(), xous::Error> { + pub fn activate(self) -> Result<(), xous_kernel::Error> { // This is a no-op on hosted environments Ok(()) } @@ -59,7 +59,7 @@ pub fn map_page_inner( _virt: usize, _req_flags: MemoryFlags, _map_user: bool, -) -> Result<(), xous::Error> { +) -> Result<(), xous_kernel::Error> { unimplemented!() } diff --git a/kernel/src/arch/hosted/process.rs b/kernel/src/arch/hosted/process.rs index d8bbe42f7..324fa353f 100644 --- a/kernel/src/arch/hosted/process.rs +++ b/kernel/src/arch/hosted/process.rs @@ -4,7 +4,7 @@ use core::cell::RefCell; use std::io::Write; use std::net::TcpStream; use std::thread_local; -use xous::{ProcessInit, ProcessKey, ThreadInit, PID, TID}; +use xous_kernel::{ProcessInit, ProcessKey, ThreadInit, PID, TID}; pub const INITIAL_TID: usize = 1; pub const MAX_PROCESS_COUNT: usize = 32; @@ -87,7 +87,7 @@ pub fn set_current_pid(pid: PID) { }); } -pub fn register_connection_for_key(conn: TcpStream, key: ProcessKey) -> Result { +pub fn register_connection_for_key(conn: TcpStream, key: ProcessKey) -> Result { PROCESS_TABLE.with(|pt| { let mut process_table = pt.borrow_mut(); for (pid_minus_1, process) in process_table.table.iter_mut().enumerate() { @@ -98,7 +98,7 @@ pub fn register_connection_for_key(conn: TcpStream, key: ProcessKey) -> Result

Result<(), xous::Error> { + pub fn activate(&mut self) -> Result<(), xous_kernel::Error> { // let mut pt = PROCESS_TABLE.lock().unwrap(); // assert!(pt.table[self.pid as usize - 1] == *self); // pt.current = self.pid as _; @@ -176,12 +176,12 @@ impl Process { process.threads[thread - 1].allocated = true; } - pub fn setup_process(pid: PID, setup: ThreadInit) -> Result<(), xous::Error> { + pub fn setup_process(pid: PID, setup: ThreadInit) -> Result<(), xous_kernel::Error> { let mut tmp = Process { pid }; tmp.setup_thread(INITIAL_TID, setup) } - pub fn setup_thread(&mut self, thread: TID, _setup: ThreadInit) -> Result<(), xous::Error> { + pub fn setup_thread(&mut self, thread: TID, _setup: ThreadInit) -> Result<(), xous_kernel::Error> { // println!( // "KERNEL({}): Setting up thread {} @ {:?}", // self.pid, @@ -212,7 +212,7 @@ impl Process { // } /// Set the current context number. - pub fn set_thread(&mut self, thread: TID) -> Result<(), xous::Error> { + pub fn set_thread(&mut self, thread: TID) -> Result<(), xous_kernel::Error> { assert!(thread > 0); PROCESS_TABLE.with(|pt| { let mut process_table = pt.borrow_mut(); @@ -243,7 +243,7 @@ impl Process { }) } - pub fn set_thread_result(&mut self, tid: TID, result: xous::Result) { + pub fn set_thread_result(&mut self, tid: TID, result: xous_kernel::Result) { assert!(tid > 0); PROCESS_TABLE.with(|pt| { let mut process_table = pt.borrow_mut(); @@ -313,7 +313,7 @@ impl Process { }) } - pub fn destroy(pid: PID) -> Result<(), xous::Error> { + pub fn destroy(pid: PID) -> Result<(), xous_kernel::Error> { PROCESS_TABLE.with(|pt| { let mut process_table = pt.borrow_mut(); let pid_idx = pid.get() as usize - 1; @@ -333,7 +333,7 @@ impl Process { }) } - pub fn send(&mut self, bytes: &[u8]) -> Result<(), xous::Error> { + pub fn send(&mut self, bytes: &[u8]) -> Result<(), xous_kernel::Error> { PROCESS_TABLE.with(|pt| { let mut process_table = pt.borrow_mut(); let current_pid_idx = process_table.current.get() as usize - 1; diff --git a/kernel/src/arch/riscv.rs b/kernel/src/arch/riscv.rs index b95885428..9ecce8508 100644 --- a/kernel/src/arch/riscv.rs +++ b/kernel/src/arch/riscv.rs @@ -1,5 +1,5 @@ use riscv::register::{satp, sie, sstatus}; -use xous::PID; +use xous_kernel::PID; pub mod exception; pub mod irq; diff --git a/kernel/src/arch/riscv/irq.rs b/kernel/src/arch/riscv/irq.rs index bfd3d211f..866bae001 100644 --- a/kernel/src/arch/riscv/irq.rs +++ b/kernel/src/arch/riscv/irq.rs @@ -5,10 +5,10 @@ use crate::arch::process::{Thread, RETURN_FROM_ISR}; use crate::mem::{MemoryManager, PAGE_SIZE}; use crate::services::SystemServices; use riscv::register::{scause, sepc, sie, sstatus, stval, vexriscv::sim, vexriscv::sip}; -use xous::{SysCall, PID, TID}; +use xous_kernel::{SysCall, PID, TID}; extern "Rust" { - fn _xous_syscall_return_result(result: &xous::Result, context: &Thread) -> !; + fn _xous_syscall_return_result(result: &xous_kernel::Result, context: &Thread) -> !; } extern "C" { @@ -31,7 +31,7 @@ pub fn enable_irq(irq_no: usize) { sim::write(sim::read() | (1 << irq_no)); } -pub fn disable_irq(irq_no: usize) -> Result<(), xous::Error> { +pub fn disable_irq(irq_no: usize) -> Result<(), xous_kernel::Error> { sim::write(sim::read() & !(1 << irq_no)); Ok(()) } @@ -89,14 +89,14 @@ pub extern "C" fn trap_handler( let call = SysCall::from_args(a0, a1, a2, a3, a4, a5, a6, a7).unwrap_or_else(|_| { ArchProcess::with_current_mut(|p| unsafe { _xous_syscall_return_result( - &xous::Result::Error(xous::Error::UnhandledSyscall), + &xous_kernel::Result::Error(xous_kernel::Error::UnhandledSyscall), p.current_thread(), ) }) }); let response = - crate::syscall::handle(pid, tid, call).unwrap_or_else(|e| xous::Result::Error(e)); + crate::syscall::handle(pid, tid, call).unwrap_or_else(|e| xous_kernel::Result::Error(e)); // println!("Syscall Result: {:?}", response); ArchProcess::with_current_mut(|p| { @@ -104,7 +104,7 @@ pub extern "C" fn trap_handler( // If we're resuming a process that was previously sleeping, restore the // context. Otherwise, keep the context the same but pass the return // values in 8 return registers. - if response == xous::Result::ResumeProcess { + if response == xous_kernel::Result::ResumeProcess { crate::arch::syscall::resume(current_pid().get() == 1, thread); } else { println!("Returning to address {:08x}", thread.sepc); diff --git a/kernel/src/arch/riscv/mem.rs b/kernel/src/arch/riscv/mem.rs index 59a2e6128..fee509403 100644 --- a/kernel/src/arch/riscv/mem.rs +++ b/kernel/src/arch/riscv/mem.rs @@ -1,7 +1,7 @@ use crate::mem::MemoryManager; use core::fmt; use riscv::register::satp; -use xous::{MemoryFlags, PID}; +use xous_kernel::{MemoryFlags, PID}; // pub const DEFAULT_STACK_TOP: usize = 0x8000_0000; pub const DEFAULT_HEAP_BASE: usize = 0x2000_0000; @@ -53,13 +53,13 @@ impl core::fmt::Debug for MemoryMapping { fn translate_flags(req_flags: MemoryFlags) -> MMUFlags { let mut flags = MMUFlags::NONE; - if req_flags & xous::MemoryFlags::R == xous::MemoryFlags::R { + if req_flags & xous_kernel::MemoryFlags::R == xous_kernel::MemoryFlags::R { flags |= MMUFlags::R; } - if req_flags & xous::MemoryFlags::W == xous::MemoryFlags::W { + if req_flags & xous_kernel::MemoryFlags::W == xous_kernel::MemoryFlags::W { flags |= MMUFlags::W; } - if req_flags & xous::MemoryFlags::X == xous::MemoryFlags::X { + if req_flags & xous_kernel::MemoryFlags::X == xous_kernel::MemoryFlags::X { flags |= MMUFlags::X; } flags @@ -67,15 +67,15 @@ fn translate_flags(req_flags: MemoryFlags) -> MMUFlags { fn untranslate_flags(req_flags: usize) -> MemoryFlags { let req_flags = MMUFlags::from_bits_truncate(req_flags); - let mut flags = xous::MemoryFlags::FREE; + let mut flags = xous_kernel::MemoryFlags::FREE; if req_flags & MMUFlags::R == MMUFlags::R { - flags |= xous::MemoryFlags::R; + flags |= xous_kernel::MemoryFlags::R; } if req_flags & MMUFlags::W == MMUFlags::W { - flags |= xous::MemoryFlags::W; + flags |= xous_kernel::MemoryFlags::W; } if req_flags & MMUFlags::X == MMUFlags::X { - flags |= xous::MemoryFlags::X; + flags |= xous_kernel::MemoryFlags::X; } flags } @@ -110,7 +110,7 @@ impl MemoryMapping { /// kernel, which should be mapped into every possible address space. /// As such, this will only have an observable effect once code returns /// to userspace. - pub fn activate(self) -> Result<(), xous::Error> { + pub fn activate(self) -> Result<(), xous_kernel::Error> { satp::write(self.satp); Ok(()) } @@ -162,7 +162,7 @@ impl MemoryMapping { mm: &mut MemoryManager, addr: usize, flags: MemoryFlags, - ) -> Result<(), xous::Error> { + ) -> Result<(), xous_kernel::Error> { let vpn1 = (addr >> 22) & ((1 << 10) - 1); let vpn0 = (addr >> 12) & ((1 << 10) - 1); @@ -256,7 +256,7 @@ impl fmt::Display for LeafPageTable { /// When we allocate pages, they are owned by the kernel so we can zero /// them out. After that is done, hand the page to the user. -pub fn hand_page_to_user(virt: *mut u8) -> Result<(), xous::Error> { +pub fn hand_page_to_user(virt: *mut u8) -> Result<(), xous_kernel::Error> { let virt = virt as usize; let vpn1 = (virt >> 22) & ((1 << 10) - 1); let vpn0 = (virt >> 12) & ((1 << 10) - 1); @@ -278,12 +278,12 @@ pub fn hand_page_to_user(virt: *mut u8) -> Result<(), xous::Error> { // If the level 1 pagetable doesn't exist, then this address isn't valid. if l1_pt[vpn1] & MMUFlags::VALID.bits() == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } // Ensure the entry hasn't already been mapped. if l0_pt.entries[vpn0] & 1 == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } // Add the USER flag to the entry @@ -306,7 +306,7 @@ pub fn map_page_inner( virt: usize, req_flags: MemoryFlags, map_user: bool, -) -> Result<(), xous::Error> { +) -> Result<(), xous_kernel::Error> { let ppn1 = (phys >> 22) & ((1 << 12) - 1); let ppn0 = (phys >> 12) & ((1 << 10) - 1); let ppo = (phys >> 0) & ((1 << 12) - 1); @@ -376,9 +376,9 @@ pub fn map_page_inner( } /// Get the pagetable entry for a given address, or `Err()` if the address is invalid -pub fn pagetable_entry(addr: usize) -> Result<&'static mut usize, xous::Error> { +pub fn pagetable_entry(addr: usize) -> Result<&'static mut usize, xous_kernel::Error> { if addr & 3 != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } let vpn1 = (addr >> 22) & ((1 << 10) - 1); let vpn0 = (addr >> 12) & ((1 << 10) - 1); @@ -388,7 +388,7 @@ pub fn pagetable_entry(addr: usize) -> Result<&'static mut usize, xous::Error> { let l1_pt = unsafe { &(*(PAGE_TABLE_ROOT_OFFSET as *mut RootPageTable)) }; let l1_pte = l1_pt.entries[vpn1]; if l1_pte & 1 == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } let l0_pt_virt = PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE; let entry = unsafe { &mut (*((l0_pt_virt + vpn0 * 4) as *mut usize)) }; @@ -405,12 +405,12 @@ pub fn pagetable_entry(addr: usize) -> Result<&'static mut usize, xous::Error> { /// # Errors /// /// * BadAddress - Address was not already mapped. -pub fn unmap_page_inner(_mm: &mut MemoryManager, virt: usize) -> Result { +pub fn unmap_page_inner(_mm: &mut MemoryManager, virt: usize) -> Result { let entry = pagetable_entry(virt)?; // Ensure the entry hasn't already been mapped. if *entry & 1 == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } let phys = (*entry >> 10) << 12; *entry = 0; @@ -427,10 +427,10 @@ pub fn move_page_inner( dest_pid: PID, dest_space: &MemoryMapping, dest_addr: *mut u8, -) -> Result<(), xous::Error> { +) -> Result<(), xous_kernel::Error> { let entry = pagetable_entry(src_addr as usize)?; if *entry & MMUFlags::VALID.bits() == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } let previous_entry = *entry; // Invalidate the old entry @@ -471,7 +471,7 @@ pub fn lend_page_inner( dest_space: &MemoryMapping, dest_addr: *mut u8, mutable: bool, -) -> Result { +) -> Result { let entry = pagetable_entry(src_addr as usize)?; let phys = (*entry >> 10) << 12; @@ -479,7 +479,7 @@ pub fn lend_page_inner( // If we try to share a page that's already mutable, that's a sharing // violation. if *entry & MMUFlags::S.bits() != 0 { - return Err(xous::Error::ShareViolation); + return Err(xous_kernel::Error::ShareViolation); } // If the page should be writable in the other process, ensure it's @@ -539,12 +539,12 @@ pub fn return_page_inner( _dest_pid: PID, dest_space: &MemoryMapping, dest_addr: *mut u8, -) -> Result { +) -> Result { let src_entry = pagetable_entry(src_addr as usize)?; let phys = (*src_entry >> 10) << 12; if *src_entry & MMUFlags::VALID.bits() == 0 { - return Err(xous::Error::ShareViolation); + return Err(xous_kernel::Error::ShareViolation); } *src_entry = 0; @@ -576,7 +576,7 @@ pub fn return_page_inner( Ok(phys) } -pub fn virt_to_phys(virt: usize) -> Result { +pub fn virt_to_phys(virt: usize) -> Result { let vpn1 = (virt >> 22) & ((1 << 10) - 1); let vpn0 = (virt >> 12) & ((1 << 10) - 1); @@ -592,12 +592,12 @@ pub fn virt_to_phys(virt: usize) -> Result { // If the level 1 pagetable doesn't exist, then this address is invalid if l1_pt[vpn1] & MMUFlags::VALID.bits() == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } // Ensure the entry hasn't already been mapped. if l0_pt.entries[vpn0] & 1 == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } Ok((l0_pt.entries[vpn0] >> 10) << 12) } diff --git a/kernel/src/arch/riscv/process.rs b/kernel/src/arch/riscv/process.rs index ecfeadbb1..dd83926a7 100644 --- a/kernel/src/arch/riscv/process.rs +++ b/kernel/src/arch/riscv/process.rs @@ -5,7 +5,7 @@ pub const INITIAL_TID: TID = 1; pub const IRQ_TID: TID = 0; use crate::arch::mem::PAGE_SIZE; use crate::services::ProcessInner; -use xous::{ProcessInit, ThreadInit, PID, TID}; +use xous_kernel::{ProcessInit, ThreadInit, PID, TID}; // use crate::args::KernelArguments; pub const DEFAULT_STACK_SIZE: usize = 131072; @@ -128,7 +128,7 @@ impl Process { } /// Mark this process as running on the current core - pub fn activate(&mut self) -> Result<(), xous::Error> { + pub fn activate(&mut self) -> Result<(), xous_kernel::Error> { Ok(()) } @@ -185,7 +185,7 @@ impl Process { } /// Set the current thread number. - pub fn set_thread(&mut self, thread: TID) -> Result<(), xous::Error> { + pub fn set_thread(&mut self, thread: TID) -> Result<(), xous_kernel::Error> { let mut process = unsafe { &mut *PROCESS }; // println!("KERNEL({}:{}): Switching to thread {}", self.pid, process.hardware_thread - 1, thread); assert!( @@ -227,7 +227,7 @@ impl Process { None } - pub fn set_thread_result(&mut self, thread_nr: TID, result: xous::Result) { + pub fn set_thread_result(&mut self, thread_nr: TID, result: xous_kernel::Result) { let vals = unsafe { mem::transmute::<_, [usize; 8]>(result) }; let thread = self.thread_mut(thread_nr); for (idx, reg) in vals.iter().enumerate() { @@ -308,14 +308,14 @@ impl Process { .reserve_range( init_sp as *mut u8, stack_size + 4096, - xous::MemoryFlags::R | xous::MemoryFlags::W, + xous_kernel::MemoryFlags::R | xous_kernel::MemoryFlags::W, ) .expect("couldn't reserve stack") }); } } - pub fn setup_thread(&mut self, new_tid: TID, setup: ThreadInit) -> Result<(), xous::Error> { + pub fn setup_thread(&mut self, new_tid: TID, setup: ThreadInit) -> Result<(), xous_kernel::Error> { let entrypoint = unsafe { core::mem::transmute::<_, usize>(setup.call) }; // Create the new context and set it to run in the new address space. let pid = self.pid.get(); @@ -376,7 +376,7 @@ impl Process { todo!(); } - pub fn destroy(_pid: PID) -> Result<(), xous::Error> { + pub fn destroy(_pid: PID) -> Result<(), xous_kernel::Error> { todo!(); // let mut process_table = unsafe { &mut *PROCESS }; // let pid_idx = pid.get() as usize - 1; diff --git a/kernel/src/irq.rs b/kernel/src/irq.rs index 12100ffc8..e350e410a 100644 --- a/kernel/src/irq.rs +++ b/kernel/src/irq.rs @@ -1,11 +1,11 @@ use crate::arch; use crate::services::SystemServices; -use xous::{MemoryAddress, PID}; +use xous_kernel::{MemoryAddress, PID}; static mut IRQ_HANDLERS: [Option<(PID, MemoryAddress, Option)>; 32] = [None; 32]; #[cfg(baremetal)] -pub fn handle(irqs_pending: usize) -> Result { +pub fn handle(irqs_pending: usize) -> Result { // Unsafe is required here because we're accessing a static // mutable value, and it could be modified from various threads. // However, this is fine because this is run from an IRQ context @@ -27,7 +27,7 @@ pub fn handle(irqs_pending: usize) -> Result { arg.map(|x| x.get() as *mut usize) .unwrap_or(core::ptr::null_mut::()), ) - .map(|_| xous::Result::ResumeProcess) + .map(|_| xous_kernel::Result::ResumeProcess) }); } else { // If there is no handler, mask this interrupt @@ -38,7 +38,7 @@ pub fn handle(irqs_pending: usize) -> Result { } } } - Ok(xous::Result::ResumeProcess) + Ok(xous_kernel::Result::ResumeProcess) } pub fn interrupt_claim( @@ -46,15 +46,15 @@ pub fn interrupt_claim( pid: PID, f: MemoryAddress, arg: Option, -) -> Result<(), xous::Error> { +) -> Result<(), xous_kernel::Error> { // Unsafe is required since we're accessing a static mut array. // However, we disable interrupts to prevent contention on this array. unsafe { arch::irq::enable_all_irqs(); let result = if irq > IRQ_HANDLERS.len() { - Err(xous::Error::InterruptNotFound) + Err(xous_kernel::Error::InterruptNotFound) } else if IRQ_HANDLERS[irq].is_some() { - Err(xous::Error::InterruptInUse) + Err(xous_kernel::Error::InterruptInUse) } else { IRQ_HANDLERS[irq] = Some((pid, f, arg)); arch::irq::enable_irq(irq); diff --git a/kernel/src/main.rs b/kernel/src/main.rs index a97402b99..17ff0257e 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -24,7 +24,7 @@ mod services; mod syscall; use services::SystemServices; -use xous::*; +use xous_kernel::*; #[cfg(baremetal)] use core::panic::PanicInfo; @@ -76,7 +76,7 @@ pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offs println!("KMAIN: Supervisor mode started..."); debug::SUPERVISOR_UART.enable_rx(); println!("Claiming IRQ 3 via syscall..."); - xous::claim_interrupt(3, debug::irq, 0 as *mut usize).expect("Couldn't claim interrupt 3"); + xous_kernel::claim_interrupt(3, debug::irq, 0 as *mut usize).expect("Couldn't claim interrupt 3"); print!("}} "); // Print the processed kernel arguments @@ -140,10 +140,12 @@ pub extern "C" fn kmain() { match pid { Some(pid) => { + #[cfg(feature = "debug-print")] println!("Attempting to switch to PID {}", pid); - xous::rsyscall(xous::SysCall::SwitchTo(pid, 0)).expect("couldn't switch to pid"); + xous_kernel::rsyscall(xous_kernel::SysCall::SwitchTo(pid, 0)).expect("couldn't switch to pid"); } None => { + #[cfg(feature = "debug-print")] println!("No runnable tasks found. Entering idle state..."); // Special case for testing: idle can return `false` to indicate exit if !arch::idle() { diff --git a/kernel/src/mem.rs b/kernel/src/mem.rs index b6a473c43..6dd11aaf2 100644 --- a/kernel/src/mem.rs +++ b/kernel/src/mem.rs @@ -5,7 +5,7 @@ use core::str; pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE}; use crate::arch::process::Process; -use xous::{MemoryFlags, MemoryRange, PID}; +use xous_kernel::{MemoryFlags, MemoryRange, PID}; #[derive(Debug)] enum ClaimOrRelease { @@ -113,7 +113,7 @@ impl MemoryManager { &mut self, base: *mut u32, args: &crate::args::KernelArguments, - ) -> Result<(), xous::Error> { + ) -> Result<(), xous_kernel::Error> { let mut args_iter = args.iter(); let xarg_def = args_iter.next().expect("mm: no kernel arguments found"); unsafe { @@ -217,7 +217,7 @@ impl MemoryManager { /// Allocate a single page to the given process. DOES NOT ZERO THE PAGE!!! /// This function CANNOT zero the page, as it hasn't been mapped yet. #[cfg(baremetal)] - pub fn alloc_page(&mut self, pid: PID) -> Result { + pub fn alloc_page(&mut self, pid: PID) -> Result { // Go through all RAM pages looking for a free page. // Optimization: start from the previous address. // println!("Allocating page for PID {}", pid); @@ -241,7 +241,7 @@ impl MemoryManager { } } } - Err(xous::Error::OutOfMemory) + Err(xous_kernel::Error::OutOfMemory) } /// Find a virtual address in the current process that is big enough @@ -250,8 +250,8 @@ impl MemoryManager { &mut self, virt_ptr: *mut u8, size: usize, - kind: xous::MemoryType, - ) -> Result<*mut u8, xous::Error> { + kind: xous_kernel::MemoryType, + ) -> Result<*mut u8, xous_kernel::Error> { // If we were supplied a perfectly good address, return that. if virt_ptr as usize != 0 { return Ok(virt_ptr); @@ -260,21 +260,21 @@ impl MemoryManager { // let process = Process::current(); Process::with_inner_mut(|process_inner| { let (start, end, initial) = match kind { - xous::MemoryType::Stack => return Err(xous::Error::BadAddress), - xous::MemoryType::Heap => { + xous_kernel::MemoryType::Stack => return Err(xous_kernel::Error::BadAddress), + xous_kernel::MemoryType::Heap => { let new_virt = process_inner.mem_heap_base + process_inner.mem_heap_size + PAGE_SIZE; if new_virt + size > process_inner.mem_heap_base + process_inner.mem_heap_max { - return Err(xous::Error::OutOfMemory); + return Err(xous_kernel::Error::OutOfMemory); } return Ok(new_virt as *mut u8); } - xous::MemoryType::Default => ( + xous_kernel::MemoryType::Default => ( process_inner.mem_default_base, process_inner.mem_default_base + 0x1000_0000, process_inner.mem_default_last, ), - xous::MemoryType::Messages => ( + xous_kernel::MemoryType::Messages => ( process_inner.mem_message_base, process_inner.mem_message_base + 0x1000_0000, process_inner.mem_message_last, @@ -293,10 +293,10 @@ impl MemoryManager { } if all_free { match kind { - xous::MemoryType::Default => { + xous_kernel::MemoryType::Default => { process_inner.mem_default_last = potential_start } - xous::MemoryType::Messages => { + xous_kernel::MemoryType::Messages => { process_inner.mem_message_last = potential_start } other => panic!("invalid kind: {:?}", other), @@ -316,10 +316,10 @@ impl MemoryManager { } if all_free { match kind { - xous::MemoryType::Default => { + xous_kernel::MemoryType::Default => { process_inner.mem_default_last = potential_start } - xous::MemoryType::Messages => { + xous_kernel::MemoryType::Messages => { process_inner.mem_message_last = potential_start } other => panic!("invalid kind: {:?}", other), @@ -327,7 +327,7 @@ impl MemoryManager { return Ok(potential_start as *mut u8); } } - Err(xous::Error::BadAddress) + Err(xous_kernel::Error::BadAddress) }) } @@ -339,17 +339,17 @@ impl MemoryManager { virt_ptr: *mut u8, size: usize, flags: MemoryFlags, - ) -> Result { + ) -> Result { // If no address was specified, pick the next address that fits // in the "default" range - let virt = self.find_virtual_address(virt_ptr, size, xous::MemoryType::Default)? as usize; + let virt = self.find_virtual_address(virt_ptr, size, xous_kernel::MemoryType::Default)? as usize; if virt & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } if size & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } let mut mm = MemoryMapping::current(); @@ -357,15 +357,15 @@ impl MemoryManager { // FIXME: Un-reserve addresses if we encounter an error here mm.reserve_address(self, virt, flags)?; } - Ok(xous::MemoryRange::new(virt_ptr as usize, size)?) + Ok(xous_kernel::MemoryRange::new(virt_ptr as usize, size)?) } /// Attempt to allocate a single page from the default section. /// Note that this will be backed by a real page. #[cfg(baremetal)] - pub fn map_zeroed_page(&mut self, pid: PID, is_user: bool) -> Result<*mut usize, xous::Error> { + pub fn map_zeroed_page(&mut self, pid: PID, is_user: bool) -> Result<*mut usize, xous_kernel::Error> { let virt = - self.find_virtual_address(core::ptr::null_mut(), PAGE_SIZE, xous::MemoryType::Default)? + self.find_virtual_address(core::ptr::null_mut(), PAGE_SIZE, xous_kernel::MemoryType::Default)? as usize; // Grab the next available page. This claims it for this process. @@ -377,7 +377,7 @@ impl MemoryManager { pid, phys as usize, virt as usize, - xous::MemoryFlags::R | xous::MemoryFlags::W, + xous_kernel::MemoryFlags::R | xous_kernel::MemoryFlags::W, false, ) { self.release_page(phys as *mut usize, pid).ok(); @@ -415,8 +415,8 @@ impl MemoryManager { size: usize, pid: PID, flags: MemoryFlags, - kind: xous::MemoryType, - ) -> Result { + kind: xous_kernel::MemoryType, + ) -> Result { let phys = phys_ptr as usize; let virt = self.find_virtual_address(virt_ptr, size, kind)?; @@ -464,7 +464,7 @@ impl MemoryManager { /// # Errors /// /// * MemoryInUse - The specified page is already mapped - pub fn unmap_page(&mut self, virt: *mut usize) -> Result { + pub fn unmap_page(&mut self, virt: *mut usize) -> Result { let pid = crate::arch::process::current_pid(); let phys = crate::arch::mem::virt_to_phys(virt as usize)?; self.release_page(phys as *mut usize, pid)?; @@ -480,7 +480,7 @@ impl MemoryManager { dest_pid: PID, dest_mapping: &MemoryMapping, dest_addr: *mut u8, - ) -> Result<(), xous::Error> { + ) -> Result<(), xous_kernel::Error> { crate::arch::mem::move_page_inner( self, &src_mapping, @@ -504,7 +504,7 @@ impl MemoryManager { dest_mapping: &MemoryMapping, dest_addr: *mut u8, mutable: bool, - ) -> Result { + ) -> Result { // If this page is to be writable, detach it from this process. // Otherwise, mark it as read-only to prevent a process from modifying // the page while it's borrowed. @@ -528,7 +528,7 @@ impl MemoryManager { dest_pid: PID, dest_mapping: &MemoryMapping, dest_addr: *mut u8, - ) -> Result { + ) -> Result { // If this page is to be writable, detach it from this process. // Otherwise, mark it as read-only to prevent a process from modifying // the page while it's borrowed. @@ -550,7 +550,7 @@ impl MemoryManager { _addr: *mut usize, _pid: PID, _action: ClaimOrRelease, - ) -> Result<(), xous::Error> { + ) -> Result<(), xous_kernel::Error> { Ok(()) } @@ -560,17 +560,17 @@ impl MemoryManager { addr: *mut usize, pid: PID, action: ClaimOrRelease, - ) -> Result<(), xous::Error> { + ) -> Result<(), xous_kernel::Error> { /// Modify the memory tracking table to note which process owns /// the specified address. fn action_inner( addr: &mut Option, pid: PID, action: ClaimOrRelease, - ) -> Result<(), xous::Error> { + ) -> Result<(), xous_kernel::Error> { if let Some(current_pid) = *addr { if current_pid != pid { - return Err(xous::Error::MemoryInUse); + return Err(xous_kernel::Error::MemoryInUse); } } match action { @@ -587,7 +587,7 @@ impl MemoryManager { // Ensure the address lies on a page boundary if addr & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } let mut offset = 0; @@ -615,16 +615,16 @@ impl MemoryManager { "mem: unable to claim or release physical address {:08x}", addr ); - Err(xous::Error::BadAddress) + Err(xous_kernel::Error::BadAddress) } /// Mark a given address as being owned by the specified process ID - fn claim_page(&mut self, addr: *mut usize, pid: PID) -> Result<(), xous::Error> { + fn claim_page(&mut self, addr: *mut usize, pid: PID) -> Result<(), xous_kernel::Error> { self.claim_or_release(addr, pid, ClaimOrRelease::Claim) } /// Mark a given address as no longer being owned by the specified process ID - fn release_page(&mut self, addr: *mut usize, pid: PID) -> Result<(), xous::Error> { + fn release_page(&mut self, addr: *mut usize, pid: PID) -> Result<(), xous_kernel::Error> { self.claim_or_release(addr, pid, ClaimOrRelease::Release) } } diff --git a/kernel/src/server.rs b/kernel/src/server.rs index b81214e0c..07c93c349 100644 --- a/kernel/src/server.rs +++ b/kernel/src/server.rs @@ -1,6 +1,6 @@ pub use crate::arch::process::Thread; use core::mem; -use xous::{TID, MemoryAddress, MemoryRange, MemorySize, Message, PID, SID}; +use xous_kernel::{TID, MemoryAddress, MemoryRange, MemorySize, Message, PID, SID}; pub struct SenderID { pub sidx: usize, @@ -8,7 +8,7 @@ pub struct SenderID { } impl SenderID { - pub fn from_usize(src: usize) -> Result { + pub fn from_usize(src: usize) -> Result { Ok(SenderID { sidx: src >> 16, tidx: src & 0xffff, @@ -169,9 +169,9 @@ impl Server { pid: PID, sid: SID, _backing: MemoryRange, - ) -> Result<(), xous::Error> { + ) -> Result<(), xous_kernel::Error> { if new != &None { - return Err(xous::Error::MemoryInUse); + return Err(xous_kernel::Error::MemoryInUse); } #[cfg(baremetal)] @@ -205,7 +205,7 @@ impl Server { } /// Take a current slot and replace it with `None`, clearing out the contents of the queue. - pub fn destroy(current: &mut Option) -> Result<(), xous::Error> { + pub fn destroy(current: &mut Option) -> Result<(), xous_kernel::Error> { if let Some(mut server) = current.take() { server.queue_head = 0; server.queue_tail = 0; @@ -278,9 +278,9 @@ impl Server { &mut self, idx: usize, buf: MemoryRange, - ) -> Result { + ) -> Result { if idx > self.queue.len() { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } let (pid, ctx, server_addr, client_addr, len, forget) = match self.queue[idx] { QueuedMessage::WaitingResponse(pid, ctx, server_addr, client_addr, len) => { @@ -292,7 +292,7 @@ impl Server { _ => return Ok(WaitingMessage::None), }; if server_addr != buf.as_ptr() as usize || len != buf.len() { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } self.queue[idx] = QueuedMessage::Empty; self.queue_tail += 1; @@ -338,7 +338,7 @@ impl Server { /// /// * **None**: There are no waiting messages /// ***Some(MessageEnvelope): This message is queued. - pub fn take_next_message(&mut self, server_idx: usize) -> Option { + pub fn take_next_message(&mut self, server_idx: usize) -> Option { // println!( // "queue_head: ((({}))) queue_tail: ((({}))): {:?}", // self.queue_head, self.queue_tail, self.queue[self.queue_tail] @@ -357,9 +357,9 @@ impl Server { offset, valid, ) => ( - xous::MessageEnvelope { + xous_kernel::MessageEnvelope { sender: self.queue_tail | (server_idx << 16), - message: xous::Message::Borrow(xous::MemoryMessage { + message: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), @@ -383,9 +383,9 @@ impl Server { offset, valid, ) => ( - xous::MessageEnvelope { + xous_kernel::MessageEnvelope { sender: self.queue_tail | (server_idx << 16), - message: xous::Message::MutableBorrow(xous::MemoryMessage { + message: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), @@ -409,9 +409,9 @@ impl Server { offset, valid, ) => ( - xous::MessageEnvelope { + xous_kernel::MessageEnvelope { sender: self.queue_tail | (server_idx << 16), - message: xous::Message::Borrow(xous::MemoryMessage { + message: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), @@ -435,9 +435,9 @@ impl Server { offset, valid, ) => ( - xous::MessageEnvelope { + xous_kernel::MessageEnvelope { sender: self.queue_tail | (server_idx << 16), - message: xous::Message::MutableBorrow(xous::MemoryMessage { + message: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), @@ -461,9 +461,9 @@ impl Server { offset, valid, ) => { - let msg = xous::MessageEnvelope { + let msg = xous_kernel::MessageEnvelope { sender: make_sender(pid, ctx), - message: xous::Message::Move(xous::MemoryMessage { + message: xous_kernel::Message::Move(xous_kernel::MemoryMessage { id, buf: MemoryRange::new(buf, buf_size).ok()?, offset: MemorySize::new(offset), @@ -480,9 +480,9 @@ impl Server { // Scalar messages have nothing to return, so they can go straight to the `Free` state QueuedMessage::ScalarMessage(pid, ctx, _reserved, id, arg1, arg2, arg3, arg4) => { - let msg = xous::MessageEnvelope { + let msg = xous_kernel::MessageEnvelope { sender: make_sender(pid, ctx), - message: xous::Message::Scalar(xous::ScalarMessage { + message: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { id, arg1, arg2, @@ -517,16 +517,16 @@ impl Server { &mut self, pid: PID, context: TID, - message: xous::Message, + message: xous_kernel::Message, original_address: Option, - ) -> core::result::Result { + ) -> core::result::Result { // println!("Queueing message: {:?} for pid: {} ctx: {}", message, pid.get(), context); if self.queue[self.queue_head] != QueuedMessage::Empty { - return Err(xous::Error::ServerQueueFull); + return Err(xous_kernel::Error::ServerQueueFull); } self.queue[self.queue_head] = match message { - xous::Message::Scalar(msg) => QueuedMessage::ScalarMessage( + xous_kernel::Message::Scalar(msg) => QueuedMessage::ScalarMessage( pid.get() as _, context as _, original_address.map(|x| x.get()).unwrap_or(0), @@ -536,7 +536,7 @@ impl Server { msg.arg3, msg.arg4, ), - xous::Message::Move(msg) => QueuedMessage::MemoryMessageSend( + xous_kernel::Message::Move(msg) => QueuedMessage::MemoryMessageSend( pid.get() as _, context as _, original_address.map(|x| x.get()).unwrap_or(0), @@ -546,7 +546,7 @@ impl Server { msg.offset.map(|x| x.get()).unwrap_or(0) as usize, msg.valid.map(|x| x.get()).unwrap_or(0) as usize, ), - xous::Message::MutableBorrow(msg) => QueuedMessage::MemoryMessageRWLend( + xous_kernel::Message::MutableBorrow(msg) => QueuedMessage::MemoryMessageRWLend( pid.get() as _, context as _, original_address.map(|x| x.get()).unwrap_or(0), @@ -556,7 +556,7 @@ impl Server { msg.offset.map(|x| x.get()).unwrap_or(0) as usize, msg.valid.map(|x| x.get()).unwrap_or(0) as usize, ), - xous::Message::Borrow(msg) => QueuedMessage::MemoryMessageROLend( + xous_kernel::Message::Borrow(msg) => QueuedMessage::MemoryMessageROLend( pid.get() as _, context as _, original_address.map(|x| x.get()).unwrap_or(0), @@ -582,14 +582,14 @@ impl Server { context: TID, message: &Message, client_address: Option, - ) -> core::result::Result { + ) -> core::result::Result { // println!("Queueing address message: {:?} (pid: {} ctx: {})", message, pid.get(), context); if self.queue[self.queue_head] != QueuedMessage::Empty { - return Err(xous::Error::ServerQueueFull); + return Err(xous_kernel::Error::ServerQueueFull); } let (server_address, len) = match message { - xous::Message::Scalar(_) | xous::Message::Move(_) => (0, 0), - xous::Message::MutableBorrow(msg) | xous::Message::Borrow(msg) => { + xous_kernel::Message::Scalar(_) | xous_kernel::Message::Move(_) => (0, 0), + xous_kernel::Message::MutableBorrow(msg) | xous_kernel::Message::Borrow(msg) => { (msg.buf.addr.get(), msg.buf.size.get()) } }; diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 195c12076..819e0ff97 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -3,12 +3,12 @@ use crate::arch::mem::MemoryMapping; pub use crate::arch::process::Process as ArchProcess; pub use crate::arch::process::Thread; use crate::mem::MemoryManager; -use xous::MemoryRange; +use xous_kernel::MemoryRange; use crate::filled_array; use crate::server::Server; // use core::mem; -use xous::{ +use xous_kernel::{ pid_from_usize, Error, MemoryAddress, Message, ProcessInit, ThreadInit, CID, PID, SID, TID, }; @@ -169,16 +169,16 @@ impl Process { } } - pub fn activate(&self) -> Result<(), xous::Error> { + pub fn activate(&self) -> Result<(), xous_kernel::Error> { crate::arch::process::set_current_pid(self.pid); self.mapping.activate()?; let mut current_process = crate::arch::process::Process::current(); current_process.activate() } - pub fn terminate(&mut self) -> Result<(), xous::Error> { + pub fn terminate(&mut self) -> Result<(), xous_kernel::Error> { if self.free() { - return Err(xous::Error::ProcessNotFound); + return Err(xous_kernel::Error::ProcessNotFound); } // TODO: Free all pages @@ -326,7 +326,7 @@ impl SystemServices { /// Add a new entry to the process table. This results in a new address space /// and a new PID, though the process is in the state `Setup()`. - pub fn create_process(&mut self, init_process: ProcessInit) -> Result { + pub fn create_process(&mut self, init_process: ProcessInit) -> Result { for (idx, mut entry) in self.processes.iter_mut().enumerate() { if entry.state != ProcessState::Free { continue; @@ -340,10 +340,10 @@ impl SystemServices { entry.pid = new_pid; return Ok(new_pid); } - Err(xous::Error::ProcessNotFound) + Err(xous_kernel::Error::ProcessNotFound) } - pub fn get_process(&self, pid: PID) -> Result<&Process, xous::Error> { + pub fn get_process(&self, pid: PID) -> Result<&Process, xous_kernel::Error> { // PID0 doesn't exist -- process IDs are offset by 1. let pid_idx = pid.get() as usize - 1; if cfg!(baremetal) && self.processes[pid_idx].mapping.get_pid() != pid { @@ -352,12 +352,12 @@ impl SystemServices { self.processes[pid_idx].mapping.get_pid(), pid ); - return Err(xous::Error::ProcessNotFound); + return Err(xous_kernel::Error::ProcessNotFound); } Ok(&self.processes[pid_idx]) } - pub fn get_process_mut(&mut self, pid: PID) -> Result<&mut Process, xous::Error> { + pub fn get_process_mut(&mut self, pid: PID) -> Result<&mut Process, xous_kernel::Error> { // PID0 doesn't exist -- process IDs are offset by 1. let pid_idx = pid.get() as usize - 1; @@ -367,7 +367,7 @@ impl SystemServices { // self.processes[pid_idx].mapping.get_pid(), // pid // ); - // return Err(xous::Error::ProcessNotFound); + // return Err(xous_kernel::Error::ProcessNotFound); // } Ok(&mut self.processes[pid_idx]) } @@ -398,7 +398,7 @@ impl SystemServices { /// 2. Save the process state, if it hasn't already been saved /// 3. Run the new process, returning to an illegal instruction #[cfg(baremetal)] - pub fn finish_callback_and_resume(&mut self, pid: PID, tid: TID) -> Result<(), xous::Error> { + pub fn finish_callback_and_resume(&mut self, pid: PID, tid: TID) -> Result<(), xous_kernel::Error> { // Get the current process (which was the interrupt handler) and mark it // as Ready. Note that the new PID may very well be the same PID. { @@ -448,8 +448,8 @@ impl SystemServices { _pc: *const usize, _irq_no: usize, _arg: *mut usize, - ) -> Result<(), xous::Error> { - Err(xous::Error::UnhandledSyscall) + ) -> Result<(), xous_kernel::Error> { + Err(xous_kernel::Error::UnhandledSyscall) } /// Create a stack frame in the specified process and jump to it. @@ -463,7 +463,7 @@ impl SystemServices { pc: *const usize, irq_no: usize, arg: *mut usize, - ) -> Result<(), xous::Error> { + ) -> Result<(), xous_kernel::Error> { // Get the current process (which was just interrupted) and mark it as // "ready to run". If this function is called when the current process // isn't running, that means the system has gotten into an invalid @@ -528,7 +528,7 @@ impl SystemServices { /// Mark the specified context as ready to run. If the thread is Sleeping, mark /// it as Ready. - pub fn ready_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous::Error> { + pub fn ready_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous_kernel::Error> { // assert!(tid == INITIAL_TID); let process = self.get_process_mut(pid)?; process.state = match process.state { @@ -557,7 +557,7 @@ impl SystemServices { /// # Panics /// /// If the current process is not running, or if it's "Running" but has no free contexts - pub fn switch_to_thread(&mut self, pid: PID, tid: Option) -> Result<(), xous::Error> { + pub fn switch_to_thread(&mut self, pid: PID, tid: Option) -> Result<(), xous_kernel::Error> { let process = self.get_process_mut(pid)?; // println!( // "switch_to_thread({}:{:?}): Old state was {:?}", @@ -566,9 +566,9 @@ impl SystemServices { // Determine which context number to switch to process.state = match process.state { - ProcessState::Free => return Err(xous::Error::ProcessNotFound), - ProcessState::Sleeping => return Err(xous::Error::ProcessNotFound), - ProcessState::Allocated => return Err(xous::Error::ProcessNotFound), + ProcessState::Free => return Err(xous_kernel::Error::ProcessNotFound), + ProcessState::Sleeping => return Err(xous_kernel::Error::ProcessNotFound), + ProcessState::Allocated => return Err(xous_kernel::Error::ProcessNotFound), ProcessState::Setup(setup) => { // Activate the process, which enables its memory mapping process.activate()?; @@ -608,7 +608,7 @@ impl SystemServices { Some(ctx) => { // Ensure the specified context is ready to run if x & (1 << ctx) == 0 { - return Err(xous::Error::InvalidThread); + return Err(xous_kernel::Error::InvalidThread); } ctx } @@ -652,7 +652,7 @@ impl SystemServices { if ready_threads & (1 << ctx) == 0 /*&& ctx != current_thread*/ { - return Err(xous::Error::InvalidThread); + return Err(xous_kernel::Error::InvalidThread); } ctx } @@ -682,7 +682,7 @@ impl SystemServices { /// # Panics /// /// If the current process is not running. - pub fn switch_from_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous::Error> { + pub fn switch_from_thread(&mut self, pid: PID, tid: TID) -> Result<(), xous_kernel::Error> { let process = self.get_process_mut(pid)?; // println!( // "switch_from_thread({}:{}): Old state was {:?}", @@ -744,8 +744,8 @@ impl SystemServices { &mut self, pid: PID, tid: TID, - result: xous::Result, - ) -> Result<(), xous::Error> { + result: xous_kernel::Result, + ) -> Result<(), xous_kernel::Error> { // Temporarily switch into the target process memory space // in order to pass the return value. let current_pid = self.current_pid(); @@ -772,7 +772,7 @@ impl SystemServices { new_pid: PID, mut new_tid: TID, can_resume: bool, - ) -> Result { + ) -> Result { // println!("Activating PID {}, context {}", new_pid, new_tid); let previous_pid = self.current_pid(); println!( @@ -789,7 +789,7 @@ impl SystemServices { match new.state { ProcessState::Free => { println!("PID {} was free", new_pid); - return Err(xous::Error::ProcessNotFound); + return Err(xous_kernel::Error::ProcessNotFound); } ProcessState::Setup(_) | ProcessState::Allocated => new_tid = INITIAL_TID, ProcessState::Running(x) | ProcessState::Ready(x) => { @@ -815,7 +815,7 @@ impl SystemServices { // // If we've looped around, return an error. // if new_tid == new.current_thread as usize { println!("Looked through all contexts and couldn't find one that was ready"); - return Err(xous::Error::ProcessNotFound); + return Err(xous_kernel::Error::ProcessNotFound); } } // println!(" -- picked context {}", new_context); @@ -824,12 +824,12 @@ impl SystemServices { "thread is {:?}, which is not valid for new thread {}", new.state, new_tid ); - return Err(xous::Error::ProcessNotFound); + return Err(xous_kernel::Error::ProcessNotFound); } } ProcessState::Sleeping => { println!("PID {} was sleeping", new_pid); - return Err(xous::Error::ProcessNotFound); + return Err(xous_kernel::Error::ProcessNotFound); } } @@ -908,7 +908,7 @@ impl SystemServices { let new = self.get_process_mut(new_pid)?; /* new.state = match new.state { ProcessState::Running(x) if (x & 1 << new_tid) == 0 => { - return Err(xous::Error::ProcessNotFound) + return Err(xous_kernel::Error::ProcessNotFound) } // ProcessState::Running(x) => { // if can_resume { @@ -979,18 +979,18 @@ impl SystemServices { dest_pid: PID, dest_virt: *mut u8, len: usize, - ) -> Result<*mut u8, xous::Error> { + ) -> Result<*mut u8, xous_kernel::Error> { if len == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } if len & 0xfff != 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } if src_virt as usize & 0xfff != 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } if dest_virt as usize & 0xfff != 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } let current_pid = self.current_pid(); @@ -1000,7 +1000,7 @@ impl SystemServices { // Locate an address to fit the new memory. dest_mapping.activate()?; let dest_virt = mm - .find_virtual_address(dest_virt, len, xous::MemoryType::Messages) + .find_virtual_address(dest_virt, len, xous_kernel::MemoryType::Messages) .or_else(|e| { src_mapping.activate().expect("couldn't undo mapping"); Err(e) @@ -1035,7 +1035,7 @@ impl SystemServices { _dest_pid: PID, _dest_virt: *mut u8, _len: usize, - ) -> Result<*mut u8, xous::Error> { + ) -> Result<*mut u8, xous_kernel::Error> { Ok(src_virt) } @@ -1072,18 +1072,18 @@ impl SystemServices { dest_virt: *mut u8, len: usize, mutable: bool, - ) -> Result<*mut u8, xous::Error> { + ) -> Result<*mut u8, xous_kernel::Error> { if len == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } if len & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } if src_virt as usize & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } if dest_virt as usize & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } let current_pid = self.current_pid(); @@ -1093,7 +1093,7 @@ impl SystemServices { // Locate an address to fit the new memory. dest_mapping.activate()?; let dest_virt = mm - .find_virtual_address(dest_virt, len, xous::MemoryType::Messages) + .find_virtual_address(dest_virt, len, xous_kernel::MemoryType::Messages) .or_else(|e| { src_mapping.activate().unwrap(); Err(e) @@ -1131,7 +1131,7 @@ impl SystemServices { _dest_virt: *mut u8, _len: usize, _mutable: bool, - ) -> Result<*mut u8, xous::Error> { + ) -> Result<*mut u8, xous_kernel::Error> { Ok(src_virt) } @@ -1153,18 +1153,18 @@ impl SystemServices { dest_pid: PID, dest_virt: *mut u8, len: usize, - ) -> Result<*mut u8, xous::Error> { + ) -> Result<*mut u8, xous_kernel::Error> { if len == 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } if len & 0xfff != 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } if src_virt as usize & 0xfff != 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } if dest_virt as usize & 0xfff != 0 { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); } let current_pid = self.current_pid(); @@ -1200,7 +1200,7 @@ impl SystemServices { dest_pid: PID, _dest_virt: *mut u8, len: usize, - ) -> Result<*mut u8, xous::Error> { + ) -> Result<*mut u8, xous_kernel::Error> { let buf = unsafe { core::slice::from_raw_parts(src_virt, len) }; let current_pid = self.current_pid(); { @@ -1226,14 +1226,14 @@ impl SystemServices { /// /// * **ThreadNotAvailable**: The process has used all of its context /// slots. - pub fn create_thread(&mut self, pid: PID, thread_init: ThreadInit) -> Result { + pub fn create_thread(&mut self, pid: PID, thread_init: ThreadInit) -> Result { let mut process = self.get_process_mut(pid)?; process.activate()?; let mut arch_process = crate::arch::process::Process::current(); let new_tid = arch_process .find_free_thread() - .ok_or(xous::Error::ThreadNotAvailable)?; + .ok_or(xous_kernel::Error::ThreadNotAvailable)?; arch_process.setup_thread(new_tid, thread_init)?; @@ -1265,7 +1265,7 @@ impl SystemServices { /// queue. /// * **ServerNotFound**: The server queue was full and a free slot could not /// be found. - pub fn create_server(&mut self, pid: PID, sid: SID) -> Result { + pub fn create_server(&mut self, pid: PID, sid: SID) -> Result { // println!( // "KERNEL({}): Looking through server list for free server", // self.pid.get() @@ -1300,12 +1300,12 @@ impl SystemServices { return Ok(sid); } } - Err(xous::Error::ServerNotFound) + Err(xous_kernel::Error::ServerNotFound) } /// Allocate a new server ID for this process and return the address. If the /// server table is full, return an error. - pub fn connect_to_server(&mut self, sid: SID) -> Result { + pub fn connect_to_server(&mut self, sid: SID) -> Result { // Check to see if we've already connected to this server. // While doing this, find a free slot in case we haven't // yet connected. @@ -1340,7 +1340,7 @@ impl SystemServices { } } } - Err(xous::Error::OutOfMemory) + Err(xous_kernel::Error::OutOfMemory) }) } @@ -1388,12 +1388,12 @@ impl SystemServices { context: TID, message: Message, original_address: Option, - ) -> Result { + ) -> Result { let current_pid = self.current_pid(); let result = { let server_pid = self .server_from_sidx(sidx) - .ok_or(xous::Error::ServerNotFound)? + .ok_or(xous_kernel::Error::ServerNotFound)? .pid; { let server_process = self.get_process(server_pid)?; @@ -1420,11 +1420,11 @@ impl SystemServices { context: TID, message: &Message, client_address: Option, - ) -> Result { + ) -> Result { // let current_pid = self.current_pid(); // let server_pid = self // .server_from_sidx(sidx) - // .ok_or(xous::Error::ServerNotFound)? + // .ok_or(xous_kernel::Error::ServerNotFound)? // .pid; // { // let server_process = self.get_process(server_pid)?; @@ -1449,7 +1449,7 @@ impl SystemServices { } /// Terminate the given process. Returns the process' parent PID. - pub fn terminate_process(&mut self, target_pid: PID) -> Result { + pub fn terminate_process(&mut self, target_pid: PID) -> Result { // To terminate a process, we must perform the following: // // 1. If we have any client connections, remove them. @@ -1501,7 +1501,7 @@ impl SystemServices { } /// Calls the provided function with the current inner process state. - pub fn shutdown(&mut self) -> Result<(), xous::Error> { + pub fn shutdown(&mut self) -> Result<(), xous_kernel::Error> { // Destroy all servers. This will cause all queued messages to be lost. for server in &mut self.servers { if server.is_some() { diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index ac3f360b8..29d4b44f2 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -5,14 +5,14 @@ use crate::mem::{MemoryManager, PAGE_SIZE}; use crate::server::{SenderID, WaitingMessage}; use crate::services::SystemServices; use core::mem; -use xous::*; +use xous_kernel::*; /// This is the context that called SwitchTo static mut SWITCHTO_CALLER: Option<(PID, TID)> = None; fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallResult { SystemServices::with_mut(|ss| { - let sidx = ss.sidx_from_cid(cid).ok_or(xous::Error::ServerNotFound)?; + let sidx = ss.sidx_from_cid(cid).ok_or(xous_kernel::Error::ServerNotFound)?; // ::debug_here::debug_here!(); let server_pid = ss @@ -133,25 +133,25 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes if blocking && cfg!(baremetal) { // println!("Activating Server context and switching away from Client"); ss.activate_process_thread(thread, server_pid, server_tid, !blocking) - .map(|_| Ok(xous::Result::Message(envelope))) - .unwrap_or(Err(xous::Error::ProcessNotFound)) + .map(|_| Ok(xous_kernel::Result::Message(envelope))) + .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) } else if blocking && !cfg!(baremetal) { // println!("Blocking client, since it sent a blocking message"); ss.switch_from_thread(pid, thread)?; ss.switch_to_thread(server_pid, Some(server_tid))?; - ss.set_thread_result(server_pid, server_tid, xous::Result::Message(envelope)) - .map(|_| xous::Result::BlockedProcess) + ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope)) + .map(|_| xous_kernel::Result::BlockedProcess) } else if cfg!(baremetal) { // println!("Setting the return value of the Server and returning to Client"); - ss.set_thread_result(server_pid, server_tid, xous::Result::Message(envelope)) - .map(|_| xous::Result::Ok) + ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope)) + .map(|_| xous_kernel::Result::Ok) } else { // println!("Setting the return value of the Server and returning to Client"); // "Switch to" the server PID when not running on bare metal. This ensures // that it's "Running". ss.switch_to_thread(server_pid, Some(server_tid))?; - ss.set_thread_result(server_pid, server_tid, xous::Result::Message(envelope)) - .map(|_| xous::Result::Ok) + ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope)) + .map(|_| xous_kernel::Result::Ok) } } else { // Add this message to the queue. If the queue is full, this @@ -167,15 +167,15 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes let ppid = process.ppid; unsafe { SWITCHTO_CALLER = None }; ss.activate_process_thread(thread, ppid, 0, !blocking) - .map(|_| Ok(xous::Result::ResumeProcess)) - .unwrap_or(Err(xous::Error::ProcessNotFound)) + .map(|_| Ok(xous_kernel::Result::ResumeProcess)) + .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) } else { ss.switch_from_thread(pid, thread)?; - Ok(xous::Result::BlockedProcess) + Ok(xous_kernel::Result::BlockedProcess) } } else { // println!("Returning to Client with Ok result"); - Ok(xous::Result::Ok) + Ok(xous_kernel::Result::Ok) } } }) @@ -187,9 +187,9 @@ fn return_memory(pid: PID, _tid: TID, sender: MessageSender, buf: MemoryRange) - let server = ss .server_from_sidx(sender.sidx) - .ok_or(xous::Error::ServerNotFound)?; + .ok_or(xous_kernel::Error::ServerNotFound)?; if server.pid != pid { - return Err(xous::Error::ServerNotFound); + return Err(xous_kernel::Error::ServerNotFound); } let result = server.take_waiting_message(sender.tidx, buf)?; let (client_pid, client_tid, server_addr, client_addr, len) = match result { @@ -201,15 +201,15 @@ fn return_memory(pid: PID, _tid: TID, sender: MessageSender, buf: MemoryRange) - len, ) => (client_pid, client_ctx, server_addr, client_addr, len), WaitingMessage::MovedMemory => { - return Ok(xous::Result::Ok); + return Ok(xous_kernel::Result::Ok); } WaitingMessage::ForgetMemory(range) => { return MemoryManager::with_mut(|mm| { - let mut result = Ok(xous::Result::Ok); + let mut result = Ok(xous_kernel::Result::Ok); let virt = range.addr.get(); let size = range.size.get(); if virt & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } for addr in (virt..(virt + size)).step_by(PAGE_SIZE) { if let Err(e) = mm.unmap_page(addr as *mut usize) { @@ -223,7 +223,7 @@ fn return_memory(pid: PID, _tid: TID, sender: MessageSender, buf: MemoryRange) - } WaitingMessage::None => { println!("WARNING: Tried to wait on a message that didn't exist"); - return Err(xous::Error::ProcessNotFound); + return Err(xous_kernel::Error::ProcessNotFound); } }; // println!( @@ -251,8 +251,8 @@ fn return_memory(pid: PID, _tid: TID, sender: MessageSender, buf: MemoryRange) - // ); ss.ready_thread(client_pid, client_tid)?; ss.switch_to_thread(client_pid, Some(client_tid))?; - ss.set_thread_result(client_pid, client_tid, xous::Result::Ok)?; - Ok(xous::Result::Ok) + ss.set_thread_result(client_pid, client_tid, xous_kernel::Result::Ok)?; + Ok(xous_kernel::Result::Ok) }) } @@ -263,21 +263,21 @@ fn receive_message(pid: PID, tid: TID, sid: SID) -> SysCallResult { "current thread is not running" ); // See if there is a pending message. If so, return immediately. - let sidx = ss.server_sidx(sid).ok_or(xous::Error::ServerNotFound)?; + let sidx = ss.server_sidx(sid).ok_or(xous_kernel::Error::ServerNotFound)?; let server = ss .server_from_sidx(sidx) - .ok_or(xous::Error::ServerNotFound)?; + .ok_or(xous_kernel::Error::ServerNotFound)?; // server.print_queue(); // Ensure the server is for this PID if server.pid != pid { - return Err(xous::Error::ServerNotFound); + return Err(xous_kernel::Error::ServerNotFound); } // If there is a pending message, return it immediately. if let Some(msg) = server.take_next_message(sidx) { // println!("PID {} had a message ready -- returning it", pid); - return Ok(xous::Result::Message(msg)); + return Ok(xous_kernel::Result::Message(msg)); } // There is no pending message, so return control to the parent @@ -296,21 +296,23 @@ fn receive_message(pid: PID, tid: TID, sid: SID) -> SysCallResult { let ppid = ss.get_process(pid).expect("Can't get current process").ppid; // TODO: Advance thread ss.activate_process_thread(tid, ppid, 0, false) - .map(|_| Ok(xous::Result::ResumeProcess)) - .unwrap_or(Err(xous::Error::ProcessNotFound)) + .map(|_| Ok(xous_kernel::Result::ResumeProcess)) + .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) } // For hosted targets, simply return `BlockedProcess` indicating we'll make // a callback to their socket at a later time. else { ss.switch_from_thread(pid, tid) - .map(|_| xous::Result::BlockedProcess) + .map(|_| xous_kernel::Result::BlockedProcess) } }) } pub fn handle(pid: PID, tid: TID, call: SysCall) -> SysCallResult { + #[cfg(feature = "debug-print")] print!("KERNEL({}:{}): Syscall {:?}", pid, tid, call); let result = handle_inner(pid, tid, call); + #[cfg(feature = "debug-print")] println!(" -> {:?}", result); result } @@ -334,12 +336,12 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { .map(|x| x.get() >= arch::mem::USER_AREA_END) .unwrap_or(false) { - return Err(xous::Error::BadAddress); + return Err(xous_kernel::Error::BadAddress); // Don't allow mapping non-page values } else if size.get() & (PAGE_SIZE - 1) != 0 { // println!("map: bad alignment of size {:08x}", size); - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } // println!( // "Mapping {:08x} -> {:08x} ({} bytes, flags: {:?})", @@ -380,15 +382,15 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { } } - Ok(xous::Result::MemoryRange(range)) + Ok(xous_kernel::Result::MemoryRange(range)) }) } SysCall::UnmapMemory(range) => MemoryManager::with_mut(|mm| { - let mut result = Ok(xous::Result::Ok); + let mut result = Ok(xous_kernel::Result::Ok); let virt = range.as_ptr() as usize; let size = range.len(); if virt & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } for addr in (virt..(virt + size)).step_by(PAGE_SIZE) { if let Err(e) = mm.unmap_page(addr as *mut usize) { @@ -401,12 +403,12 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { }), SysCall::IncreaseHeap(delta, flags) => { if delta & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } let start = { ArchProcess::with_inner_mut(|process_inner| { if process_inner.mem_heap_size + delta > process_inner.mem_heap_max { - return Err(xous::Error::OutOfMemory); + return Err(xous_kernel::Error::OutOfMemory); } let start = process_inner.mem_heap_base + process_inner.mem_heap_size; @@ -415,18 +417,18 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { })? }; MemoryManager::with_mut(|mm| { - Ok(xous::Result::MemoryRange( + Ok(xous_kernel::Result::MemoryRange( mm.reserve_range(start, delta, flags)?, )) }) } SysCall::DecreaseHeap(delta) => { if delta & 0xfff != 0 { - return Err(xous::Error::BadAlignment); + return Err(xous_kernel::Error::BadAlignment); } let start = ArchProcess::with_inner_mut(|process_inner| { if process_inner.mem_heap_size + delta > process_inner.mem_heap_max { - return Err(xous::Error::OutOfMemory); + return Err(xous_kernel::Error::OutOfMemory); } let start = process_inner.mem_heap_base + process_inner.mem_heap_size; @@ -439,7 +441,7 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { .expect("unable to unmap page"); } }); - Ok(xous::Result::Ok) + Ok(xous_kernel::Result::Ok) } SysCall::SwitchTo(new_pid, new_context) => { SystemServices::with_mut(|ss| { @@ -453,17 +455,17 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { ss.activate_process_thread(tid, new_pid, new_context, true) .map(|_ctx| { // println!("switchto ({}, {})", pid, _ctx); - xous::Result::ResumeProcess + xous_kernel::Result::ResumeProcess }) }) } SysCall::ClaimInterrupt(no, callback, arg) => { - interrupt_claim(no, pid as definitions::PID, callback, arg).map(|_| xous::Result::Ok) + interrupt_claim(no, pid as definitions::PID, callback, arg).map(|_| xous_kernel::Result::Ok) } SysCall::Yield => { // If we're not running on bare metal, treat this as a no-op. if !cfg!(baremetal) { - return Ok(xous::Result::Ok); + return Ok(xous_kernel::Result::Ok); } let (parent_pid, parent_ctx) = unsafe { @@ -474,8 +476,8 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { SystemServices::with_mut(|ss| { // TODO: Advance thread ss.activate_process_thread(tid, parent_pid, parent_ctx, true) - .map(|_| Ok(xous::Result::ResumeProcess)) - .unwrap_or(Err(xous::Error::ProcessNotFound)) + .map(|_| Ok(xous_kernel::Result::ResumeProcess)) + .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) }) } SysCall::ReturnToParentI(_pid, _cpuid) => { @@ -488,7 +490,7 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { .expect("ReturnToParentI called with no existing parent present"); crate::arch::irq::set_isr_return_pair(parent_pid, parent_ctx); }; - Ok(xous::Result::ResumeProcess) + Ok(xous_kernel::Result::ResumeProcess) } SysCall::ReceiveMessage(sid) => receive_message(pid, tid, sid), SysCall::WaitEvent => SystemServices::with_mut(|ss| { @@ -497,8 +499,8 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { unsafe { SWITCHTO_CALLER = None }; // TODO: Advance thread ss.activate_process_thread(tid, ppid, 0, false) - .map(|_| Ok(xous::Result::ResumeProcess)) - .unwrap_or(Err(xous::Error::ProcessNotFound)) + .map(|_| Ok(xous_kernel::Result::ResumeProcess)) + .unwrap_or(Err(xous_kernel::Error::ProcessNotFound)) }), SysCall::CreateThread(thread_init) => SystemServices::with_mut(|ss| { ss.create_thread(pid, thread_init).map(|new_tid| { @@ -506,18 +508,18 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { ss.switch_to_thread(pid, Some(new_tid)) .expect("couldn't activate new thread"); } - xous::Result::ThreadID(new_tid) + xous_kernel::Result::ThreadID(new_tid) }) }), SysCall::CreateProcess(process_init) => SystemServices::with_mut(|ss| { - ss.create_process(process_init).map(xous::Result::ProcessID) + ss.create_process(process_init).map(xous_kernel::Result::ProcessID) }), SysCall::CreateServer(name) => { - SystemServices::with_mut(|ss| ss.create_server(pid, name).map(xous::Result::ServerID)) + SystemServices::with_mut(|ss| ss.create_server(pid, name).map(xous_kernel::Result::ServerID)) } SysCall::Connect(sid) => { // ::debug_here::debug_here!(); - SystemServices::with_mut(|ss| ss.connect_to_server(sid).map(xous::Result::ConnectionID)) + SystemServices::with_mut(|ss| ss.connect_to_server(sid).map(xous_kernel::Result::ConnectionID)) } SysCall::ReturnMemory(sender, buf) => return_memory(pid, tid, sender, buf), SysCall::SendMessage(cid, message) => send_message(pid, tid, cid, message), @@ -526,12 +528,12 @@ pub fn handle_inner(pid: PID, tid: TID, call: SysCall) -> SysCallResult { let ppid = ss.terminate_process(pid)?; if cfg!(baremetal) { ss.switch_to_thread(ppid, None) - .map(|_| xous::Result::ResumeProcess) + .map(|_| xous_kernel::Result::ResumeProcess) } else { - Ok(xous::Result::Ok) + Ok(xous_kernel::Result::Ok) } }), - SysCall::Shutdown => SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous::Result::Ok)), - _ => Err(xous::Error::UnhandledSyscall), + SysCall::Shutdown => SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok)), + _ => Err(xous_kernel::Error::UnhandledSyscall), } } diff --git a/kernel/src/test.rs b/kernel/src/test.rs index 108714d5c..8c5266cf6 100644 --- a/kernel/src/test.rs +++ b/kernel/src/test.rs @@ -3,7 +3,7 @@ use std::thread::JoinHandle; use std::net::ToSocketAddrs; use std::sync::mpsc::channel; -use xous::{rsyscall, SysCall}; +use xous_kernel::{rsyscall, SysCall}; mod shutdown; @@ -31,7 +31,7 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> { for b in pid1_key.iter_mut() { *b = rng.gen(); } - xous::arch::set_process_key(&pid1_key); + xous_kernel::arch::set_process_key(&pid1_key); let server_addr = server_spec .to_socket_addrs() @@ -58,7 +58,7 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> { }) .expect("couldn't start kernel thread"); let server_addr = recv_addr.recv().unwrap(); - xous::arch::set_xous_address(server_addr); + xous_kernel::arch::set_xous_address(server_addr); // Connect to server. This first instance needs to make sure the kernel is listening. // let mut server_conn = None; @@ -78,8 +78,8 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> { fn shutdown_kernel() { // Any process ought to be able to shut down the system currently. - xous::wait_process_as_thread( - xous::create_process_as_thread(xous::ProcessArgsAsThread::new("shutdown", || { + xous_kernel::wait_process_as_thread( + xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new("shutdown", || { rsyscall(SysCall::Shutdown).expect("unable to shutdown server"); })) .expect("couldn't shut down the kernel"), @@ -95,10 +95,10 @@ fn shutdown_kernel() { // F: Send + 'static, // R: Send + 'static, // { -// let server_spec = xous::arch::xous_address(); +// let server_spec = xous_kernel::arch::xous_address(); // std::thread::spawn(move || { -// xous::arch::set_xous_address(server_spec); -// xous::arch::xous_connect(); +// xous_kernel::arch::set_xous_address(server_spec); +// xous_kernel::arch::xous_connect(); // f() // }) // } @@ -126,16 +126,16 @@ fn send_scalar_message() { // and receive the message. Note that we need to communicate to the // "Client" what our server ID is. Normally this would be done via // an external nameserver. - let xous_server = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_scalar_message server", move || { let sid = - xous::create_server(b"send_scalar_mesg").expect("couldn't create test server"); + xous_kernel::create_server(b"send_scalar_mesg").expect("couldn't create test server"); server_addr_send.send(sid).unwrap(); - let envelope = xous::receive_message(sid).expect("couldn't receive messages"); + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); assert_eq!( envelope.message, - xous::Message::Scalar(xous::ScalarMessage { + xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { id: 1, arg1: 2, arg2: 3, @@ -148,14 +148,14 @@ fn send_scalar_message() { .expect("couldn't spawn server process"); // Spawn the client "process" and wait for the server address. - let xous_client = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_scalar_message client", move || { let sid = server_addr_recv.recv().unwrap(); - let conn = xous::connect(sid).expect("couldn't connect to server"); - xous::send_message( + let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); + xous_kernel::send_message( conn, - xous::Message::Scalar(xous::ScalarMessage { + xous_kernel::Message::Scalar(xous_kernel::ScalarMessage { id: 1, arg1: 2, arg2: 3, @@ -185,19 +185,19 @@ fn send_move_message() { let (server_addr_send, server_addr_recv) = channel(); - let xous_server = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_move_message server", move || { // println!("SERVER: Creating server..."); let sid = - xous::create_server(b"send_move_messag").expect("couldn't create test server"); + xous_kernel::create_server(b"send_move_messag").expect("couldn't create test server"); // println!("SERVER: Sending server address of {:?} to client", sid); server_addr_send.send(sid).unwrap(); // println!("SERVER: Starting to receive messages..."); - let envelope = xous::receive_message(sid).expect("couldn't receive messages"); + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); // println!("SERVER: Received message from {}", envelope.sender); let message = envelope.message; - if let xous::Message::Move(m) = message { + if let xous_kernel::Message::Move(m) = message { let buf = m.buf; let bt = unsafe { Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) @@ -212,15 +212,15 @@ fn send_move_message() { )) .expect("couldn't start server"); - let xous_client = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_move_message client", move || { // println!("CLIENT: Waiting for server address..."); let sid = server_addr_recv.recv().unwrap(); // println!("CLIENT: Connecting to server {:?}", sid); - let conn = xous::connect(sid).expect("couldn't connect to server"); - let msg = xous::carton::Carton::from_bytes(test_bytes); - xous::send_message(conn, xous::Message::Move(msg.into_message(0))) + let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); + let msg = xous_kernel::carton::Carton::from_bytes(test_bytes); + xous_kernel::send_message(conn, xous_kernel::Message::Move(msg.into_message(0))) .expect("couldn't send a message"); // println!("CLIENT: Message sent"); }, @@ -244,18 +244,18 @@ fn send_borrow_message() { let test_str = "Hello, world!"; let test_bytes = test_str.as_bytes(); - let xous_server = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_borrow_message server", move || { // println!("SERVER: Creating server..."); let sid = - xous::create_server(b"send_borrow_mesg").expect("couldn't create test server"); + xous_kernel::create_server(b"send_borrow_mesg").expect("couldn't create test server"); server_addr_send.send(sid).unwrap(); // println!("SERVER: Receiving message..."); - let envelope = xous::receive_message(sid).expect("couldn't receive messages"); + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); // println!("SERVER: Received message from {}", envelope.sender); let message = envelope.message; - if let xous::Message::Borrow(m) = message { + if let xous_kernel::Message::Borrow(m) = message { let buf = m.buf; let bt = unsafe { Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) @@ -263,7 +263,7 @@ fn send_borrow_message() { assert_eq!(*test_bytes, *bt); // let s = String::from_utf8_lossy(&bt); // println!("SERVER: Got message: {:?} -> \"{}\"", bt, s); - xous::return_memory(envelope.sender, m.buf).unwrap(); + xous_kernel::return_memory(envelope.sender, m.buf).unwrap(); // println!("SERVER: Returned memory"); } else { panic!("unexpected message type"); @@ -272,7 +272,7 @@ fn send_borrow_message() { )) .expect("couldn't start server"); - let xous_client = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_borrow_message client", move || { // Get the server address (out of band) so we know what to connect to @@ -281,11 +281,11 @@ fn send_borrow_message() { // Perform a connection to the server // println!("CLIENT: Connecting to server..."); - let conn = xous::connect(sid).expect("couldn't connect to server"); + let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); // Convert the message into a "Carton" that can be shipped as a message // println!("CLIENT: Creating carton..."); - let carton = xous::carton::Carton::from_bytes(test_bytes); + let carton = xous_kernel::carton::Carton::from_bytes(test_bytes); // Send the message to the server // println!("CLIENT: Lending message..."); @@ -315,16 +315,16 @@ fn send_mutableborrow_message() { let test_str = "Hello, world!"; let test_bytes = test_str.as_bytes(); - let xous_server = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_mutableborrow_message server", move || { let sid = - xous::create_server(b"send_mutborrow_m").expect("couldn't create test server"); + xous_kernel::create_server(b"send_mutborrow_m").expect("couldn't create test server"); server_addr_send.send(sid).unwrap(); - let envelope = xous::receive_message(sid).expect("couldn't receive messages"); + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); // println!("Received message from {}", envelope.sender); let message = envelope.message; - if let xous::Message::MutableBorrow(m) = message { + if let xous_kernel::Message::MutableBorrow(m) = message { let buf = m.buf; let mut bt = unsafe { Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) @@ -332,7 +332,7 @@ fn send_mutableborrow_message() { for letter in bt.iter_mut() { *letter += 1; } - xous::return_memory(envelope.sender, m.buf).unwrap(); + xous_kernel::return_memory(envelope.sender, m.buf).unwrap(); } else { panic!("unexpected message type"); } @@ -340,17 +340,17 @@ fn send_mutableborrow_message() { )) .expect("couldn't start server"); - let xous_client = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_mutableborrow_message client", move || { // Get the server address (out of band) so we know what to connect to let sid = server_addr_recv.recv().unwrap(); // Perform a connection to the server - let conn = xous::connect(sid).expect("couldn't connect to server"); + let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); // Convert the message into a "Carton" that can be shipped as a message - let mut carton = xous::carton::Carton::from_bytes(&test_bytes); + let mut carton = xous_kernel::carton::Carton::from_bytes(&test_bytes); let mut check_bytes = test_bytes.to_vec(); for letter in check_bytes.iter_mut() { *letter += 1; @@ -386,17 +386,17 @@ fn send_mutableborrow_message_repeat() { let loops = 50; - let xous_server = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_mutableborrow_message_repeat server", move || { let sid = - xous::create_server(b"send_mutborrow_r").expect("couldn't create test server"); + xous_kernel::create_server(b"send_mutborrow_r").expect("couldn't create test server"); server_addr_send.send(sid).unwrap(); for iteration in 0..loops { - let envelope = xous::receive_message(sid).expect("couldn't receive messages"); + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); let message = envelope.message; - if let xous::Message::MutableBorrow(m) = message { + if let xous_kernel::Message::MutableBorrow(m) = message { let buf = m.buf; let mut bt = unsafe { Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) @@ -404,7 +404,7 @@ fn send_mutableborrow_message_repeat() { for letter in bt.iter_mut() { *letter = (*letter).wrapping_add((iteration & 0xff) as u8); } - xous::return_memory(envelope.sender, m.buf).unwrap(); + xous_kernel::return_memory(envelope.sender, m.buf).unwrap(); } else { panic!("unexpected message type"); } @@ -413,18 +413,18 @@ fn send_mutableborrow_message_repeat() { )) .expect("couldn't start server"); - let xous_client = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "send_mutableborrow_message_repeat client", move || { // Get the server address (out of band) so we know what to connect to let sid = server_addr_recv.recv().unwrap(); // Perform a connection to the server - let conn = xous::connect(sid).expect("couldn't connect to server"); + let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); // Convert the message into a "Carton" that can be shipped as a message for iteration in 0..loops { - let mut carton = xous::carton::Carton::from_bytes(&test_bytes); + let mut carton = xous_kernel::carton::Carton::from_bytes(&test_bytes); let mut check_bytes = test_bytes.to_vec(); for letter in check_bytes.iter_mut() { *letter = (*letter).wrapping_add((iteration & 0xff) as u8); @@ -486,12 +486,12 @@ fn server_client_same_process() { // Start the kernel in its own thread let main_thread = start_kernel(SERVER_SPEC); - let internal_server = xous::create_process_as_thread(xous::arch::ProcessArgsAsThread::new( + let internal_server = xous_kernel::create_process_as_thread(xous_kernel::arch::ProcessArgsAsThread::new( "server_client_same_process process", || { - let server = xous::create_server(b"s_c_same_process").expect("couldn't create server"); - let connection = xous::connect(server).expect("couldn't connect to our own server"); - let msg_contents = xous::ScalarMessage { + let server = xous_kernel::create_server(b"s_c_same_process").expect("couldn't create server"); + let connection = xous_kernel::connect(server).expect("couldn't connect to our own server"); + let msg_contents = xous_kernel::ScalarMessage { id: 1, arg1: 2, arg2: 3, @@ -499,17 +499,17 @@ fn server_client_same_process() { arg4: 5, }; - xous::send_message(connection, xous::Message::Scalar(msg_contents)) + xous_kernel::send_message(connection, xous_kernel::Message::Scalar(msg_contents)) .expect("couldn't send message"); - let msg = xous::receive_message(server).expect("couldn't receive message"); + let msg = xous_kernel::receive_message(server).expect("couldn't receive message"); - assert_eq!(msg.message, xous::Message::Scalar(msg_contents)); + assert_eq!(msg.message, xous_kernel::Message::Scalar(msg_contents)); }, )) .expect("couldn't start server"); - xous::wait_process_as_thread(internal_server).expect("couldn't join internal_server process"); + xous_kernel::wait_process_as_thread(internal_server).expect("couldn't join internal_server process"); // Any process ought to be able to shut down the system currently. rsyscall(SysCall::Shutdown).expect("unable to shutdown server"); @@ -524,12 +524,12 @@ fn multiple_contexts() { // Start the kernel in its own thread let main_thread = start_kernel(SERVER_SPEC); - let internal_server = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let internal_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "multiple_contexts process", move || { - let server = xous::create_server(b"multiple_context").expect("couldn't create server"); - let connection = xous::connect(server).expect("couldn't connect to our own server"); - let msg_contents = xous::ScalarMessage { + let server = xous_kernel::create_server(b"multiple_context").expect("couldn't create server"); + let connection = xous_kernel::connect(server).expect("couldn't connect to our own server"); + let msg_contents = xous_kernel::ScalarMessage { id: 1, arg1: 2, arg2: 3, @@ -540,26 +540,26 @@ fn multiple_contexts() { let mut server_threads = vec![]; for _ in 0..crate::arch::process::MAX_THREAD { server_threads.push( - xous::create_thread(move || { - let msg = xous::receive_message(server).expect("couldn't receive message"); - assert_eq!(msg.message, xous::Message::Scalar(msg_contents)); + xous_kernel::create_thread(move || { + let msg = xous_kernel::receive_message(server).expect("couldn't receive message"); + assert_eq!(msg.message, xous_kernel::Message::Scalar(msg_contents)); }) .expect("couldn't spawn client thread"), ); } for _ in &server_threads { - xous::send_message(connection, xous::Message::Scalar(msg_contents)) + xous_kernel::send_message(connection, xous_kernel::Message::Scalar(msg_contents)) .expect("couldn't send message"); } for server_thread in server_threads.into_iter() { - xous::wait_thread(server_thread).expect("couldn't wait for thread"); + xous_kernel::wait_thread(server_thread).expect("couldn't wait for thread"); } }, )) .expect("couldn't create internal server"); - xous::wait_process_as_thread(internal_server).expect("couldn't join internal_server process"); + xous_kernel::wait_process_as_thread(internal_server).expect("couldn't join internal_server process"); // Any process ought to be able to shut down the system currently. shutdown_kernel(); @@ -585,17 +585,17 @@ fn process_restart_server() { fn create_destroy_server(test_bytes: &'static [u8]) { let (server_addr_send, server_addr_recv) = channel(); - let xous_server = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "process_restart_server server", move || { let sid = - xous::create_server(b"test_recreate_se").expect("couldn't create test server"); + xous_kernel::create_server(b"test_recreate_se").expect("couldn't create test server"); server_addr_send.send(sid).unwrap(); - let thr = xous::create_thread(move || { - let envelope = xous::receive_message(sid).expect("couldn't receive messages"); + let thr = xous_kernel::create_thread(move || { + let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages"); // println!("Received message from {}", envelope.sender); let message = envelope.message; - if let xous::Message::Move(m) = message { + if let xous_kernel::Message::Move(m) = message { let buf = m.buf; let bt = unsafe { Box::from_raw(core::slice::from_raw_parts_mut( @@ -611,26 +611,26 @@ fn process_restart_server() { } }) .unwrap(); - xous::wait_thread(thr).unwrap(); + xous_kernel::wait_thread(thr).unwrap(); }, )) .expect("couldn't spawn server process"); // Wait for the server to start up - let xous_client = xous::create_process_as_thread(xous::ProcessArgsAsThread::new( + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( "process_restart_server client", move || { let sid = server_addr_recv.recv().unwrap(); - let conn = xous::connect(sid).expect("couldn't connect to server"); - let msg = xous::carton::Carton::from_bytes(test_bytes); - xous::send_message(conn, xous::Message::Move(msg.into_message(0))) + let conn = xous_kernel::connect(sid).expect("couldn't connect to server"); + let msg = xous_kernel::carton::Carton::from_bytes(test_bytes); + xous_kernel::send_message(conn, xous_kernel::Message::Move(msg.into_message(0))) .expect("couldn't send a message"); }, )) .expect("couldn't start client process"); - xous::wait_process_as_thread(xous_server).expect("couldn't join server process"); - xous::wait_process_as_thread(xous_client).expect("couldn't join client process"); + xous_kernel::wait_process_as_thread(xous_server).expect("couldn't join server process"); + xous_kernel::wait_process_as_thread(xous_client).expect("couldn't join client process"); } // create_destroy_server(test_bytes);