From bb17038bfeff83558c5fcd2c88ebd57d6621257e Mon Sep 17 00:00:00 2001 From: Sean Cross Date: Mon, 17 Aug 2020 18:37:40 +0800 Subject: [PATCH] kernel: rename "xous" to "xous-kernel" in import Cargo appears to cache packages in the workspace when multiple packages use the same crate. Unfortunately, Xous uses different features depending on whether it's running in the kernel or in userspace. Pull the kernel version of "xous" in under a different namespace in order to force it to use a different build. Signed-off-by: Sean Cross --- kernel/Cargo.toml | 2 +- kernel/src/arch/hosted.rs | 24 ++--- kernel/src/arch/hosted/irq.rs | 6 +- kernel/src/arch/hosted/mem.rs | 6 +- kernel/src/arch/hosted/process.rs | 20 ++-- kernel/src/arch/riscv.rs | 2 +- kernel/src/arch/riscv/irq.rs | 12 +-- kernel/src/arch/riscv/mem.rs | 56 +++++------ kernel/src/arch/riscv/process.rs | 14 +-- kernel/src/irq.rs | 14 +-- kernel/src/main.rs | 8 +- kernel/src/mem.rs | 76 +++++++-------- kernel/src/server.rs | 64 ++++++------ kernel/src/services.rs | 126 ++++++++++++------------ kernel/src/syscall.rs | 114 +++++++++++----------- kernel/src/test.rs | 156 +++++++++++++++--------------- 16 files changed, 352 insertions(+), 348 deletions(-) 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);