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 <sean@xobs.io>
This commit is contained in:
Sean Cross 2020-08-17 18:37:40 +08:00
parent f469bfcffc
commit bb17038bfe
16 changed files with 352 additions and 348 deletions

View file

@ -7,7 +7,7 @@ description = "Core kernel for Xous, including task switching and memory managem
[dependencies] [dependencies]
bitflags = "1.2.1" 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 } stats_alloc = { version = "0.1.8", optional = true }
sha3 = { default-features = false, version = "0.8.2" } sha3 = { default-features = false, version = "0.8.2" }

View file

@ -14,7 +14,7 @@ use std::thread_local;
use crate::arch::process::Process; use crate::arch::process::Process;
use crate::services::SystemServices; 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 { enum ThreadMessage {
SysCall(PID, TID, SysCall), SysCall(PID, TID, SysCall),
@ -146,7 +146,7 @@ fn handle_connection(
ServerMessage::Exit => break, ServerMessage::Exit => break,
ServerMessage::ServerPacket(pkt) => { ServerMessage::ServerPacket(pkt) => {
let thread_id = pkt[0]; 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], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8],
); );
match call { match call {
@ -164,7 +164,7 @@ fn handle_connection(
} }
ServerMessage::ServerPacketWithData(pkt, data) => { ServerMessage::ServerPacketWithData(pkt, data) => {
let thread_id = pkt[0]; 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], pkt[1], pkt[2], pkt[3], pkt[4], pkt[5], pkt[6], pkt[7], pkt[8],
); );
match call { match call {
@ -182,9 +182,9 @@ fn handle_connection(
// ); // );
if let SysCall::SendMessage(ref _cid, ref mut envelope) = call { if let SysCall::SendMessage(ref _cid, ref mut envelope) = call {
match envelope { match envelope {
xous::Message::MutableBorrow(msg) xous_kernel::Message::MutableBorrow(msg)
| xous::Message::Borrow(msg) | xous_kernel::Message::Borrow(msg)
| xous::Message::Move(msg) => { | xous_kernel::Message::Move(msg) => {
// Update the address pointer. This will get turned back into a // Update the address pointer. This will get turned back into a
// usable pointer by casting it back into a &[T] on the other // usable pointer by casting it back into a &[T] on the other
// side. This is just a pointer to the start of data // side. This is just a pointer to the start of data
@ -209,7 +209,7 @@ fn handle_connection(
_ => unreachable!(), _ => unreachable!(),
}; };
} }
xous::Message::Scalar(_) => (), xous_kernel::Message::Scalar(_) => (),
} }
} else { } else {
panic!("unsupported message type"); panic!("unsupported message type");
@ -225,7 +225,7 @@ fn handle_connection(
chn.send(ThreadMessage::SysCall( chn.send(ThreadMessage::SysCall(
pid, pid,
1, 1,
xous::SysCall::TerminateProcess, xous_kernel::SysCall::TerminateProcess,
)) ))
.unwrap(); .unwrap();
} }
@ -419,7 +419,7 @@ pub fn idle() -> bool {
#[cfg(not(test))] #[cfg(not(test))]
{ {
let address = address_receiver.recv().unwrap(); 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: Xous server listening on {}", address);
println!("KERNEL: Starting initial processes:"); println!("KERNEL: Starting initial processes:");
let mut args = std::env::args(); let mut args = std::env::args();
@ -435,13 +435,13 @@ pub fn idle() -> bool {
println!("-------+------------------"); println!("-------+------------------");
for arg in args { for arg in args {
let process_key = generate_pid_key(); let process_key = generate_pid_key();
let init = xous::ProcessInit { let init = xous_kernel::ProcessInit {
key: ProcessKey::new(process_key), key: ProcessKey::new(process_key),
}; };
let new_pid = SystemServices::with_mut(|ss| ss.create_process(init)).unwrap(); let new_pid = SystemServices::with_mut(|ss| ss.create_process(init)).unwrap();
println!(" {:^5} | {}", new_pid, arg); println!(" {:^5} | {}", new_pid, arg);
let process_args = xous::ProcessArgs::new("program", arg); let process_args = xous_kernel::ProcessArgs::new("program", arg);
xous::arch::create_process_post(process_args, init, new_pid).expect("couldn't spawn"); xous_kernel::arch::create_process_post(process_args, init, new_pid).expect("couldn't spawn");
} }
} }

View file

@ -1,4 +1,4 @@
use xous::{TID, PID}; use xous_kernel::{TID, PID};
pub fn disable_all_irqs() { pub fn disable_all_irqs() {
// There are no IRQs in a hosted environment, so there's nothing to do. // 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!(); unimplemented!();
} }
pub fn disable_irq(_irq_no: usize) -> Result<(), xous::Error> { pub fn disable_irq(_irq_no: usize) -> Result<(), xous_kernel::Error> {
Err(xous::Error::UnhandledSyscall) Err(xous_kernel::Error::UnhandledSyscall)
} }
pub unsafe fn take_isr_return_pair() -> Option<(PID, TID)> { pub unsafe fn take_isr_return_pair() -> Option<(PID, TID)> {

View file

@ -1,6 +1,6 @@
pub const PAGE_SIZE: usize = 4096; pub const PAGE_SIZE: usize = 4096;
use crate::mem::MemoryManager; 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_HEAP_BASE: usize = 0x2000_0000;
pub const DEFAULT_MESSAGE_BASE: usize = 0x4000_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. /// kernel, which should be mapped into every possible address space.
/// As such, this will only have an observable effect once code returns /// As such, this will only have an observable effect once code returns
/// to userspace. /// 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 // This is a no-op on hosted environments
Ok(()) Ok(())
} }
@ -59,7 +59,7 @@ pub fn map_page_inner(
_virt: usize, _virt: usize,
_req_flags: MemoryFlags, _req_flags: MemoryFlags,
_map_user: bool, _map_user: bool,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
unimplemented!() unimplemented!()
} }

View file

@ -4,7 +4,7 @@ use core::cell::RefCell;
use std::io::Write; use std::io::Write;
use std::net::TcpStream; use std::net::TcpStream;
use std::thread_local; 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 INITIAL_TID: usize = 1;
pub const MAX_PROCESS_COUNT: usize = 32; 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<PID, xous::Error> { pub fn register_connection_for_key(conn: TcpStream, key: ProcessKey) -> Result<PID, xous_kernel::Error> {
PROCESS_TABLE.with(|pt| { PROCESS_TABLE.with(|pt| {
let mut process_table = pt.borrow_mut(); let mut process_table = pt.borrow_mut();
for (pid_minus_1, process) in process_table.table.iter_mut().enumerate() { 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<P
} }
} }
} }
Err(xous::Error::ProcessNotFound) Err(xous_kernel::Error::ProcessNotFound)
}) })
} }
@ -135,7 +135,7 @@ impl Process {
} }
/// Mark this process as running (on the current core?!) /// 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> {
// let mut pt = PROCESS_TABLE.lock().unwrap(); // let mut pt = PROCESS_TABLE.lock().unwrap();
// assert!(pt.table[self.pid as usize - 1] == *self); // assert!(pt.table[self.pid as usize - 1] == *self);
// pt.current = self.pid as _; // pt.current = self.pid as _;
@ -176,12 +176,12 @@ impl Process {
process.threads[thread - 1].allocated = true; 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 }; let mut tmp = Process { pid };
tmp.setup_thread(INITIAL_TID, setup) 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!( // println!(
// "KERNEL({}): Setting up thread {} @ {:?}", // "KERNEL({}): Setting up thread {} @ {:?}",
// self.pid, // self.pid,
@ -212,7 +212,7 @@ impl Process {
// } // }
/// Set the current context number. /// 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); assert!(thread > 0);
PROCESS_TABLE.with(|pt| { PROCESS_TABLE.with(|pt| {
let mut process_table = pt.borrow_mut(); 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); assert!(tid > 0);
PROCESS_TABLE.with(|pt| { PROCESS_TABLE.with(|pt| {
let mut process_table = pt.borrow_mut(); 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| { PROCESS_TABLE.with(|pt| {
let mut process_table = pt.borrow_mut(); let mut process_table = pt.borrow_mut();
let pid_idx = pid.get() as usize - 1; 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| { PROCESS_TABLE.with(|pt| {
let mut process_table = pt.borrow_mut(); let mut process_table = pt.borrow_mut();
let current_pid_idx = process_table.current.get() as usize - 1; let current_pid_idx = process_table.current.get() as usize - 1;

View file

@ -1,5 +1,5 @@
use riscv::register::{satp, sie, sstatus}; use riscv::register::{satp, sie, sstatus};
use xous::PID; use xous_kernel::PID;
pub mod exception; pub mod exception;
pub mod irq; pub mod irq;

View file

@ -5,10 +5,10 @@ use crate::arch::process::{Thread, RETURN_FROM_ISR};
use crate::mem::{MemoryManager, PAGE_SIZE}; use crate::mem::{MemoryManager, PAGE_SIZE};
use crate::services::SystemServices; use crate::services::SystemServices;
use riscv::register::{scause, sepc, sie, sstatus, stval, vexriscv::sim, vexriscv::sip}; 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" { 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" { extern "C" {
@ -31,7 +31,7 @@ pub fn enable_irq(irq_no: usize) {
sim::write(sim::read() | (1 << irq_no)); 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)); sim::write(sim::read() & !(1 << irq_no));
Ok(()) 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(|_| { let call = SysCall::from_args(a0, a1, a2, a3, a4, a5, a6, a7).unwrap_or_else(|_| {
ArchProcess::with_current_mut(|p| unsafe { ArchProcess::with_current_mut(|p| unsafe {
_xous_syscall_return_result( _xous_syscall_return_result(
&xous::Result::Error(xous::Error::UnhandledSyscall), &xous_kernel::Result::Error(xous_kernel::Error::UnhandledSyscall),
p.current_thread(), p.current_thread(),
) )
}) })
}); });
let response = 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); // println!("Syscall Result: {:?}", response);
ArchProcess::with_current_mut(|p| { 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 // If we're resuming a process that was previously sleeping, restore the
// context. Otherwise, keep the context the same but pass the return // context. Otherwise, keep the context the same but pass the return
// values in 8 return registers. // 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); crate::arch::syscall::resume(current_pid().get() == 1, thread);
} else { } else {
println!("Returning to address {:08x}", thread.sepc); println!("Returning to address {:08x}", thread.sepc);

View file

@ -1,7 +1,7 @@
use crate::mem::MemoryManager; use crate::mem::MemoryManager;
use core::fmt; use core::fmt;
use riscv::register::satp; use riscv::register::satp;
use xous::{MemoryFlags, PID}; use xous_kernel::{MemoryFlags, PID};
// pub const DEFAULT_STACK_TOP: usize = 0x8000_0000; // pub const DEFAULT_STACK_TOP: usize = 0x8000_0000;
pub const DEFAULT_HEAP_BASE: usize = 0x2000_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 { fn translate_flags(req_flags: MemoryFlags) -> MMUFlags {
let mut flags = MMUFlags::NONE; 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; 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; 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 |= MMUFlags::X;
} }
flags flags
@ -67,15 +67,15 @@ fn translate_flags(req_flags: MemoryFlags) -> MMUFlags {
fn untranslate_flags(req_flags: usize) -> MemoryFlags { fn untranslate_flags(req_flags: usize) -> MemoryFlags {
let req_flags = MMUFlags::from_bits_truncate(req_flags); 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 { if req_flags & MMUFlags::R == MMUFlags::R {
flags |= xous::MemoryFlags::R; flags |= xous_kernel::MemoryFlags::R;
} }
if req_flags & MMUFlags::W == MMUFlags::W { if req_flags & MMUFlags::W == MMUFlags::W {
flags |= xous::MemoryFlags::W; flags |= xous_kernel::MemoryFlags::W;
} }
if req_flags & MMUFlags::X == MMUFlags::X { if req_flags & MMUFlags::X == MMUFlags::X {
flags |= xous::MemoryFlags::X; flags |= xous_kernel::MemoryFlags::X;
} }
flags flags
} }
@ -110,7 +110,7 @@ impl MemoryMapping {
/// kernel, which should be mapped into every possible address space. /// kernel, which should be mapped into every possible address space.
/// As such, this will only have an observable effect once code returns /// As such, this will only have an observable effect once code returns
/// to userspace. /// to userspace.
pub fn activate(self) -> Result<(), xous::Error> { pub fn activate(self) -> Result<(), xous_kernel::Error> {
satp::write(self.satp); satp::write(self.satp);
Ok(()) Ok(())
} }
@ -162,7 +162,7 @@ impl MemoryMapping {
mm: &mut MemoryManager, mm: &mut MemoryManager,
addr: usize, addr: usize,
flags: MemoryFlags, flags: MemoryFlags,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
let vpn1 = (addr >> 22) & ((1 << 10) - 1); let vpn1 = (addr >> 22) & ((1 << 10) - 1);
let vpn0 = (addr >> 12) & ((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 /// 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. /// 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 virt = virt as usize;
let vpn1 = (virt >> 22) & ((1 << 10) - 1); let vpn1 = (virt >> 22) & ((1 << 10) - 1);
let vpn0 = (virt >> 12) & ((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 the level 1 pagetable doesn't exist, then this address isn't valid.
if l1_pt[vpn1] & MMUFlags::VALID.bits() == 0 { 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. // Ensure the entry hasn't already been mapped.
if l0_pt.entries[vpn0] & 1 == 0 { 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 // Add the USER flag to the entry
@ -306,7 +306,7 @@ pub fn map_page_inner(
virt: usize, virt: usize,
req_flags: MemoryFlags, req_flags: MemoryFlags,
map_user: bool, map_user: bool,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
let ppn1 = (phys >> 22) & ((1 << 12) - 1); let ppn1 = (phys >> 22) & ((1 << 12) - 1);
let ppn0 = (phys >> 12) & ((1 << 10) - 1); let ppn0 = (phys >> 12) & ((1 << 10) - 1);
let ppo = (phys >> 0) & ((1 << 12) - 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 /// 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 { if addr & 3 != 0 {
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
let vpn1 = (addr >> 22) & ((1 << 10) - 1); let vpn1 = (addr >> 22) & ((1 << 10) - 1);
let vpn0 = (addr >> 12) & ((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_pt = unsafe { &(*(PAGE_TABLE_ROOT_OFFSET as *mut RootPageTable)) };
let l1_pte = l1_pt.entries[vpn1]; let l1_pte = l1_pt.entries[vpn1];
if l1_pte & 1 == 0 { 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 l0_pt_virt = PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE;
let entry = unsafe { &mut (*((l0_pt_virt + vpn0 * 4) as *mut usize)) }; 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 /// # Errors
/// ///
/// * BadAddress - Address was not already mapped. /// * BadAddress - Address was not already mapped.
pub fn unmap_page_inner(_mm: &mut MemoryManager, virt: usize) -> Result<usize, xous::Error> { pub fn unmap_page_inner(_mm: &mut MemoryManager, virt: usize) -> Result<usize, xous_kernel::Error> {
let entry = pagetable_entry(virt)?; let entry = pagetable_entry(virt)?;
// Ensure the entry hasn't already been mapped. // Ensure the entry hasn't already been mapped.
if *entry & 1 == 0 { if *entry & 1 == 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
let phys = (*entry >> 10) << 12; let phys = (*entry >> 10) << 12;
*entry = 0; *entry = 0;
@ -427,10 +427,10 @@ pub fn move_page_inner(
dest_pid: PID, dest_pid: PID,
dest_space: &MemoryMapping, dest_space: &MemoryMapping,
dest_addr: *mut u8, dest_addr: *mut u8,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
let entry = pagetable_entry(src_addr as usize)?; let entry = pagetable_entry(src_addr as usize)?;
if *entry & MMUFlags::VALID.bits() == 0 { if *entry & MMUFlags::VALID.bits() == 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
let previous_entry = *entry; let previous_entry = *entry;
// Invalidate the old entry // Invalidate the old entry
@ -471,7 +471,7 @@ pub fn lend_page_inner(
dest_space: &MemoryMapping, dest_space: &MemoryMapping,
dest_addr: *mut u8, dest_addr: *mut u8,
mutable: bool, mutable: bool,
) -> Result<usize, xous::Error> { ) -> Result<usize, xous_kernel::Error> {
let entry = pagetable_entry(src_addr as usize)?; let entry = pagetable_entry(src_addr as usize)?;
let phys = (*entry >> 10) << 12; 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 // If we try to share a page that's already mutable, that's a sharing
// violation. // violation.
if *entry & MMUFlags::S.bits() != 0 { 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 // 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_pid: PID,
dest_space: &MemoryMapping, dest_space: &MemoryMapping,
dest_addr: *mut u8, dest_addr: *mut u8,
) -> Result<usize, xous::Error> { ) -> Result<usize, xous_kernel::Error> {
let src_entry = pagetable_entry(src_addr as usize)?; let src_entry = pagetable_entry(src_addr as usize)?;
let phys = (*src_entry >> 10) << 12; let phys = (*src_entry >> 10) << 12;
if *src_entry & MMUFlags::VALID.bits() == 0 { if *src_entry & MMUFlags::VALID.bits() == 0 {
return Err(xous::Error::ShareViolation); return Err(xous_kernel::Error::ShareViolation);
} }
*src_entry = 0; *src_entry = 0;
@ -576,7 +576,7 @@ pub fn return_page_inner(
Ok(phys) Ok(phys)
} }
pub fn virt_to_phys(virt: usize) -> Result<usize, xous::Error> { pub fn virt_to_phys(virt: usize) -> Result<usize, xous_kernel::Error> {
let vpn1 = (virt >> 22) & ((1 << 10) - 1); let vpn1 = (virt >> 22) & ((1 << 10) - 1);
let vpn0 = (virt >> 12) & ((1 << 10) - 1); let vpn0 = (virt >> 12) & ((1 << 10) - 1);
@ -592,12 +592,12 @@ pub fn virt_to_phys(virt: usize) -> Result<usize, xous::Error> {
// If the level 1 pagetable doesn't exist, then this address is invalid // If the level 1 pagetable doesn't exist, then this address is invalid
if l1_pt[vpn1] & MMUFlags::VALID.bits() == 0 { 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. // Ensure the entry hasn't already been mapped.
if l0_pt.entries[vpn0] & 1 == 0 { 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) Ok((l0_pt.entries[vpn0] >> 10) << 12)
} }

View file

@ -5,7 +5,7 @@ pub const INITIAL_TID: TID = 1;
pub const IRQ_TID: TID = 0; pub const IRQ_TID: TID = 0;
use crate::arch::mem::PAGE_SIZE; use crate::arch::mem::PAGE_SIZE;
use crate::services::ProcessInner; use crate::services::ProcessInner;
use xous::{ProcessInit, ThreadInit, PID, TID}; use xous_kernel::{ProcessInit, ThreadInit, PID, TID};
// use crate::args::KernelArguments; // use crate::args::KernelArguments;
pub const DEFAULT_STACK_SIZE: usize = 131072; pub const DEFAULT_STACK_SIZE: usize = 131072;
@ -128,7 +128,7 @@ impl Process {
} }
/// Mark this process as running on the current core /// 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(()) Ok(())
} }
@ -185,7 +185,7 @@ impl Process {
} }
/// Set the current thread number. /// 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 }; let mut process = unsafe { &mut *PROCESS };
// println!("KERNEL({}:{}): Switching to thread {}", self.pid, process.hardware_thread - 1, thread); // println!("KERNEL({}:{}): Switching to thread {}", self.pid, process.hardware_thread - 1, thread);
assert!( assert!(
@ -227,7 +227,7 @@ impl Process {
None 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 vals = unsafe { mem::transmute::<_, [usize; 8]>(result) };
let thread = self.thread_mut(thread_nr); let thread = self.thread_mut(thread_nr);
for (idx, reg) in vals.iter().enumerate() { for (idx, reg) in vals.iter().enumerate() {
@ -308,14 +308,14 @@ impl Process {
.reserve_range( .reserve_range(
init_sp as *mut u8, init_sp as *mut u8,
stack_size + 4096, stack_size + 4096,
xous::MemoryFlags::R | xous::MemoryFlags::W, xous_kernel::MemoryFlags::R | xous_kernel::MemoryFlags::W,
) )
.expect("couldn't reserve stack") .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) }; let entrypoint = unsafe { core::mem::transmute::<_, usize>(setup.call) };
// Create the new context and set it to run in the new address space. // Create the new context and set it to run in the new address space.
let pid = self.pid.get(); let pid = self.pid.get();
@ -376,7 +376,7 @@ impl Process {
todo!(); todo!();
} }
pub fn destroy(_pid: PID) -> Result<(), xous::Error> { pub fn destroy(_pid: PID) -> Result<(), xous_kernel::Error> {
todo!(); todo!();
// let mut process_table = unsafe { &mut *PROCESS }; // let mut process_table = unsafe { &mut *PROCESS };
// let pid_idx = pid.get() as usize - 1; // let pid_idx = pid.get() as usize - 1;

View file

@ -1,11 +1,11 @@
use crate::arch; use crate::arch;
use crate::services::SystemServices; use crate::services::SystemServices;
use xous::{MemoryAddress, PID}; use xous_kernel::{MemoryAddress, PID};
static mut IRQ_HANDLERS: [Option<(PID, MemoryAddress, Option<MemoryAddress>)>; 32] = [None; 32]; static mut IRQ_HANDLERS: [Option<(PID, MemoryAddress, Option<MemoryAddress>)>; 32] = [None; 32];
#[cfg(baremetal)] #[cfg(baremetal)]
pub fn handle(irqs_pending: usize) -> Result<xous::Result, xous::Error> { pub fn handle(irqs_pending: usize) -> Result<xous_kernel::Result, xous_kernel::Error> {
// Unsafe is required here because we're accessing a static // Unsafe is required here because we're accessing a static
// mutable value, and it could be modified from various threads. // mutable value, and it could be modified from various threads.
// However, this is fine because this is run from an IRQ context // However, this is fine because this is run from an IRQ context
@ -27,7 +27,7 @@ pub fn handle(irqs_pending: usize) -> Result<xous::Result, xous::Error> {
arg.map(|x| x.get() as *mut usize) arg.map(|x| x.get() as *mut usize)
.unwrap_or(core::ptr::null_mut::<usize>()), .unwrap_or(core::ptr::null_mut::<usize>()),
) )
.map(|_| xous::Result::ResumeProcess) .map(|_| xous_kernel::Result::ResumeProcess)
}); });
} else { } else {
// If there is no handler, mask this interrupt // If there is no handler, mask this interrupt
@ -38,7 +38,7 @@ pub fn handle(irqs_pending: usize) -> Result<xous::Result, xous::Error> {
} }
} }
} }
Ok(xous::Result::ResumeProcess) Ok(xous_kernel::Result::ResumeProcess)
} }
pub fn interrupt_claim( pub fn interrupt_claim(
@ -46,15 +46,15 @@ pub fn interrupt_claim(
pid: PID, pid: PID,
f: MemoryAddress, f: MemoryAddress,
arg: Option<MemoryAddress>, arg: Option<MemoryAddress>,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
// Unsafe is required since we're accessing a static mut array. // Unsafe is required since we're accessing a static mut array.
// However, we disable interrupts to prevent contention on this array. // However, we disable interrupts to prevent contention on this array.
unsafe { unsafe {
arch::irq::enable_all_irqs(); arch::irq::enable_all_irqs();
let result = if irq > IRQ_HANDLERS.len() { let result = if irq > IRQ_HANDLERS.len() {
Err(xous::Error::InterruptNotFound) Err(xous_kernel::Error::InterruptNotFound)
} else if IRQ_HANDLERS[irq].is_some() { } else if IRQ_HANDLERS[irq].is_some() {
Err(xous::Error::InterruptInUse) Err(xous_kernel::Error::InterruptInUse)
} else { } else {
IRQ_HANDLERS[irq] = Some((pid, f, arg)); IRQ_HANDLERS[irq] = Some((pid, f, arg));
arch::irq::enable_irq(irq); arch::irq::enable_irq(irq);

View file

@ -24,7 +24,7 @@ mod services;
mod syscall; mod syscall;
use services::SystemServices; use services::SystemServices;
use xous::*; use xous_kernel::*;
#[cfg(baremetal)] #[cfg(baremetal)]
use core::panic::PanicInfo; 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..."); println!("KMAIN: Supervisor mode started...");
debug::SUPERVISOR_UART.enable_rx(); debug::SUPERVISOR_UART.enable_rx();
println!("Claiming IRQ 3 via syscall..."); 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!("}} ");
// Print the processed kernel arguments // Print the processed kernel arguments
@ -140,10 +140,12 @@ pub extern "C" fn kmain() {
match pid { match pid {
Some(pid) => { Some(pid) => {
#[cfg(feature = "debug-print")]
println!("Attempting to switch to PID {}", pid); 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 => { None => {
#[cfg(feature = "debug-print")]
println!("No runnable tasks found. Entering idle state..."); println!("No runnable tasks found. Entering idle state...");
// Special case for testing: idle can return `false` to indicate exit // Special case for testing: idle can return `false` to indicate exit
if !arch::idle() { if !arch::idle() {

View file

@ -5,7 +5,7 @@ use core::str;
pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE}; pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE};
use crate::arch::process::Process; use crate::arch::process::Process;
use xous::{MemoryFlags, MemoryRange, PID}; use xous_kernel::{MemoryFlags, MemoryRange, PID};
#[derive(Debug)] #[derive(Debug)]
enum ClaimOrRelease { enum ClaimOrRelease {
@ -113,7 +113,7 @@ impl MemoryManager {
&mut self, &mut self,
base: *mut u32, base: *mut u32,
args: &crate::args::KernelArguments, args: &crate::args::KernelArguments,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
let mut args_iter = args.iter(); let mut args_iter = args.iter();
let xarg_def = args_iter.next().expect("mm: no kernel arguments found"); let xarg_def = args_iter.next().expect("mm: no kernel arguments found");
unsafe { unsafe {
@ -217,7 +217,7 @@ impl MemoryManager {
/// Allocate a single page to the given process. DOES NOT ZERO THE PAGE!!! /// 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. /// This function CANNOT zero the page, as it hasn't been mapped yet.
#[cfg(baremetal)] #[cfg(baremetal)]
pub fn alloc_page(&mut self, pid: PID) -> Result<usize, xous::Error> { pub fn alloc_page(&mut self, pid: PID) -> Result<usize, xous_kernel::Error> {
// Go through all RAM pages looking for a free page. // Go through all RAM pages looking for a free page.
// Optimization: start from the previous address. // Optimization: start from the previous address.
// println!("Allocating page for PID {}", pid); // 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 /// Find a virtual address in the current process that is big enough
@ -250,8 +250,8 @@ impl MemoryManager {
&mut self, &mut self,
virt_ptr: *mut u8, virt_ptr: *mut u8,
size: usize, size: usize,
kind: xous::MemoryType, kind: xous_kernel::MemoryType,
) -> Result<*mut u8, xous::Error> { ) -> Result<*mut u8, xous_kernel::Error> {
// If we were supplied a perfectly good address, return that. // If we were supplied a perfectly good address, return that.
if virt_ptr as usize != 0 { if virt_ptr as usize != 0 {
return Ok(virt_ptr); return Ok(virt_ptr);
@ -260,21 +260,21 @@ impl MemoryManager {
// let process = Process::current(); // let process = Process::current();
Process::with_inner_mut(|process_inner| { Process::with_inner_mut(|process_inner| {
let (start, end, initial) = match kind { let (start, end, initial) = match kind {
xous::MemoryType::Stack => return Err(xous::Error::BadAddress), xous_kernel::MemoryType::Stack => return Err(xous_kernel::Error::BadAddress),
xous::MemoryType::Heap => { xous_kernel::MemoryType::Heap => {
let new_virt = let new_virt =
process_inner.mem_heap_base + process_inner.mem_heap_size + PAGE_SIZE; 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 { 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); return Ok(new_virt as *mut u8);
} }
xous::MemoryType::Default => ( xous_kernel::MemoryType::Default => (
process_inner.mem_default_base, process_inner.mem_default_base,
process_inner.mem_default_base + 0x1000_0000, process_inner.mem_default_base + 0x1000_0000,
process_inner.mem_default_last, process_inner.mem_default_last,
), ),
xous::MemoryType::Messages => ( xous_kernel::MemoryType::Messages => (
process_inner.mem_message_base, process_inner.mem_message_base,
process_inner.mem_message_base + 0x1000_0000, process_inner.mem_message_base + 0x1000_0000,
process_inner.mem_message_last, process_inner.mem_message_last,
@ -293,10 +293,10 @@ impl MemoryManager {
} }
if all_free { if all_free {
match kind { match kind {
xous::MemoryType::Default => { xous_kernel::MemoryType::Default => {
process_inner.mem_default_last = potential_start process_inner.mem_default_last = potential_start
} }
xous::MemoryType::Messages => { xous_kernel::MemoryType::Messages => {
process_inner.mem_message_last = potential_start process_inner.mem_message_last = potential_start
} }
other => panic!("invalid kind: {:?}", other), other => panic!("invalid kind: {:?}", other),
@ -316,10 +316,10 @@ impl MemoryManager {
} }
if all_free { if all_free {
match kind { match kind {
xous::MemoryType::Default => { xous_kernel::MemoryType::Default => {
process_inner.mem_default_last = potential_start process_inner.mem_default_last = potential_start
} }
xous::MemoryType::Messages => { xous_kernel::MemoryType::Messages => {
process_inner.mem_message_last = potential_start process_inner.mem_message_last = potential_start
} }
other => panic!("invalid kind: {:?}", other), other => panic!("invalid kind: {:?}", other),
@ -327,7 +327,7 @@ impl MemoryManager {
return Ok(potential_start as *mut u8); 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, virt_ptr: *mut u8,
size: usize, size: usize,
flags: MemoryFlags, flags: MemoryFlags,
) -> Result<xous::MemoryRange, xous::Error> { ) -> Result<xous_kernel::MemoryRange, xous_kernel::Error> {
// If no address was specified, pick the next address that fits // If no address was specified, pick the next address that fits
// in the "default" range // 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 { if virt & 0xfff != 0 {
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
if size & 0xfff != 0 { if size & 0xfff != 0 {
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
let mut mm = MemoryMapping::current(); let mut mm = MemoryMapping::current();
@ -357,15 +357,15 @@ impl MemoryManager {
// FIXME: Un-reserve addresses if we encounter an error here // FIXME: Un-reserve addresses if we encounter an error here
mm.reserve_address(self, virt, flags)?; 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. /// Attempt to allocate a single page from the default section.
/// Note that this will be backed by a real page. /// Note that this will be backed by a real page.
#[cfg(baremetal)] #[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 = 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; as usize;
// Grab the next available page. This claims it for this process. // Grab the next available page. This claims it for this process.
@ -377,7 +377,7 @@ impl MemoryManager {
pid, pid,
phys as usize, phys as usize,
virt as usize, virt as usize,
xous::MemoryFlags::R | xous::MemoryFlags::W, xous_kernel::MemoryFlags::R | xous_kernel::MemoryFlags::W,
false, false,
) { ) {
self.release_page(phys as *mut usize, pid).ok(); self.release_page(phys as *mut usize, pid).ok();
@ -415,8 +415,8 @@ impl MemoryManager {
size: usize, size: usize,
pid: PID, pid: PID,
flags: MemoryFlags, flags: MemoryFlags,
kind: xous::MemoryType, kind: xous_kernel::MemoryType,
) -> Result<xous::MemoryRange, xous::Error> { ) -> Result<xous_kernel::MemoryRange, xous_kernel::Error> {
let phys = phys_ptr as usize; let phys = phys_ptr as usize;
let virt = self.find_virtual_address(virt_ptr, size, kind)?; let virt = self.find_virtual_address(virt_ptr, size, kind)?;
@ -464,7 +464,7 @@ impl MemoryManager {
/// # Errors /// # Errors
/// ///
/// * MemoryInUse - The specified page is already mapped /// * MemoryInUse - The specified page is already mapped
pub fn unmap_page(&mut self, virt: *mut usize) -> Result<usize, xous::Error> { pub fn unmap_page(&mut self, virt: *mut usize) -> Result<usize, xous_kernel::Error> {
let pid = crate::arch::process::current_pid(); let pid = crate::arch::process::current_pid();
let phys = crate::arch::mem::virt_to_phys(virt as usize)?; let phys = crate::arch::mem::virt_to_phys(virt as usize)?;
self.release_page(phys as *mut usize, pid)?; self.release_page(phys as *mut usize, pid)?;
@ -480,7 +480,7 @@ impl MemoryManager {
dest_pid: PID, dest_pid: PID,
dest_mapping: &MemoryMapping, dest_mapping: &MemoryMapping,
dest_addr: *mut u8, dest_addr: *mut u8,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
crate::arch::mem::move_page_inner( crate::arch::mem::move_page_inner(
self, self,
&src_mapping, &src_mapping,
@ -504,7 +504,7 @@ impl MemoryManager {
dest_mapping: &MemoryMapping, dest_mapping: &MemoryMapping,
dest_addr: *mut u8, dest_addr: *mut u8,
mutable: bool, mutable: bool,
) -> Result<usize, xous::Error> { ) -> Result<usize, xous_kernel::Error> {
// If this page is to be writable, detach it from this process. // If this page is to be writable, detach it from this process.
// Otherwise, mark it as read-only to prevent a process from modifying // Otherwise, mark it as read-only to prevent a process from modifying
// the page while it's borrowed. // the page while it's borrowed.
@ -528,7 +528,7 @@ impl MemoryManager {
dest_pid: PID, dest_pid: PID,
dest_mapping: &MemoryMapping, dest_mapping: &MemoryMapping,
dest_addr: *mut u8, dest_addr: *mut u8,
) -> Result<usize, xous::Error> { ) -> Result<usize, xous_kernel::Error> {
// If this page is to be writable, detach it from this process. // If this page is to be writable, detach it from this process.
// Otherwise, mark it as read-only to prevent a process from modifying // Otherwise, mark it as read-only to prevent a process from modifying
// the page while it's borrowed. // the page while it's borrowed.
@ -550,7 +550,7 @@ impl MemoryManager {
_addr: *mut usize, _addr: *mut usize,
_pid: PID, _pid: PID,
_action: ClaimOrRelease, _action: ClaimOrRelease,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
Ok(()) Ok(())
} }
@ -560,17 +560,17 @@ impl MemoryManager {
addr: *mut usize, addr: *mut usize,
pid: PID, pid: PID,
action: ClaimOrRelease, action: ClaimOrRelease,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
/// Modify the memory tracking table to note which process owns /// Modify the memory tracking table to note which process owns
/// the specified address. /// the specified address.
fn action_inner( fn action_inner(
addr: &mut Option<PID>, addr: &mut Option<PID>,
pid: PID, pid: PID,
action: ClaimOrRelease, action: ClaimOrRelease,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
if let Some(current_pid) = *addr { if let Some(current_pid) = *addr {
if current_pid != pid { if current_pid != pid {
return Err(xous::Error::MemoryInUse); return Err(xous_kernel::Error::MemoryInUse);
} }
} }
match action { match action {
@ -587,7 +587,7 @@ impl MemoryManager {
// Ensure the address lies on a page boundary // Ensure the address lies on a page boundary
if addr & 0xfff != 0 { if addr & 0xfff != 0 {
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
let mut offset = 0; let mut offset = 0;
@ -615,16 +615,16 @@ impl MemoryManager {
"mem: unable to claim or release physical address {:08x}", "mem: unable to claim or release physical address {:08x}",
addr addr
); );
Err(xous::Error::BadAddress) Err(xous_kernel::Error::BadAddress)
} }
/// Mark a given address as being owned by the specified process ID /// 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) self.claim_or_release(addr, pid, ClaimOrRelease::Claim)
} }
/// Mark a given address as no longer being owned by the specified process ID /// 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) self.claim_or_release(addr, pid, ClaimOrRelease::Release)
} }
} }

View file

@ -1,6 +1,6 @@
pub use crate::arch::process::Thread; pub use crate::arch::process::Thread;
use core::mem; 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 struct SenderID {
pub sidx: usize, pub sidx: usize,
@ -8,7 +8,7 @@ pub struct SenderID {
} }
impl SenderID { impl SenderID {
pub fn from_usize(src: usize) -> Result<SenderID, xous::Error> { pub fn from_usize(src: usize) -> Result<SenderID, xous_kernel::Error> {
Ok(SenderID { Ok(SenderID {
sidx: src >> 16, sidx: src >> 16,
tidx: src & 0xffff, tidx: src & 0xffff,
@ -169,9 +169,9 @@ impl Server {
pid: PID, pid: PID,
sid: SID, sid: SID,
_backing: MemoryRange, _backing: MemoryRange,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
if new != &None { if new != &None {
return Err(xous::Error::MemoryInUse); return Err(xous_kernel::Error::MemoryInUse);
} }
#[cfg(baremetal)] #[cfg(baremetal)]
@ -205,7 +205,7 @@ impl Server {
} }
/// Take a current slot and replace it with `None`, clearing out the contents of the queue. /// Take a current slot and replace it with `None`, clearing out the contents of the queue.
pub fn destroy(current: &mut Option<Server>) -> Result<(), xous::Error> { pub fn destroy(current: &mut Option<Server>) -> Result<(), xous_kernel::Error> {
if let Some(mut server) = current.take() { if let Some(mut server) = current.take() {
server.queue_head = 0; server.queue_head = 0;
server.queue_tail = 0; server.queue_tail = 0;
@ -278,9 +278,9 @@ impl Server {
&mut self, &mut self,
idx: usize, idx: usize,
buf: MemoryRange, buf: MemoryRange,
) -> Result<WaitingMessage, xous::Error> { ) -> Result<WaitingMessage, xous_kernel::Error> {
if idx > self.queue.len() { 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] { let (pid, ctx, server_addr, client_addr, len, forget) = match self.queue[idx] {
QueuedMessage::WaitingResponse(pid, ctx, server_addr, client_addr, len) => { QueuedMessage::WaitingResponse(pid, ctx, server_addr, client_addr, len) => {
@ -292,7 +292,7 @@ impl Server {
_ => return Ok(WaitingMessage::None), _ => return Ok(WaitingMessage::None),
}; };
if server_addr != buf.as_ptr() as usize || len != buf.len() { 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[idx] = QueuedMessage::Empty;
self.queue_tail += 1; self.queue_tail += 1;
@ -338,7 +338,7 @@ impl Server {
/// ///
/// * **None**: There are no waiting messages /// * **None**: There are no waiting messages
/// ***Some(MessageEnvelope): This message is queued. /// ***Some(MessageEnvelope): This message is queued.
pub fn take_next_message(&mut self, server_idx: usize) -> Option<xous::MessageEnvelope> { pub fn take_next_message(&mut self, server_idx: usize) -> Option<xous_kernel::MessageEnvelope> {
// println!( // println!(
// "queue_head: ((({}))) queue_tail: ((({}))): {:?}", // "queue_head: ((({}))) queue_tail: ((({}))): {:?}",
// self.queue_head, self.queue_tail, self.queue[self.queue_tail] // self.queue_head, self.queue_tail, self.queue[self.queue_tail]
@ -357,9 +357,9 @@ impl Server {
offset, offset,
valid, valid,
) => ( ) => (
xous::MessageEnvelope { xous_kernel::MessageEnvelope {
sender: self.queue_tail | (server_idx << 16), sender: self.queue_tail | (server_idx << 16),
message: xous::Message::Borrow(xous::MemoryMessage { message: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
id, id,
buf: MemoryRange::new(buf, buf_size).ok()?, buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset), offset: MemorySize::new(offset),
@ -383,9 +383,9 @@ impl Server {
offset, offset,
valid, valid,
) => ( ) => (
xous::MessageEnvelope { xous_kernel::MessageEnvelope {
sender: self.queue_tail | (server_idx << 16), sender: self.queue_tail | (server_idx << 16),
message: xous::Message::MutableBorrow(xous::MemoryMessage { message: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
id, id,
buf: MemoryRange::new(buf, buf_size).ok()?, buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset), offset: MemorySize::new(offset),
@ -409,9 +409,9 @@ impl Server {
offset, offset,
valid, valid,
) => ( ) => (
xous::MessageEnvelope { xous_kernel::MessageEnvelope {
sender: self.queue_tail | (server_idx << 16), sender: self.queue_tail | (server_idx << 16),
message: xous::Message::Borrow(xous::MemoryMessage { message: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
id, id,
buf: MemoryRange::new(buf, buf_size).ok()?, buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset), offset: MemorySize::new(offset),
@ -435,9 +435,9 @@ impl Server {
offset, offset,
valid, valid,
) => ( ) => (
xous::MessageEnvelope { xous_kernel::MessageEnvelope {
sender: self.queue_tail | (server_idx << 16), sender: self.queue_tail | (server_idx << 16),
message: xous::Message::MutableBorrow(xous::MemoryMessage { message: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
id, id,
buf: MemoryRange::new(buf, buf_size).ok()?, buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset), offset: MemorySize::new(offset),
@ -461,9 +461,9 @@ impl Server {
offset, offset,
valid, valid,
) => { ) => {
let msg = xous::MessageEnvelope { let msg = xous_kernel::MessageEnvelope {
sender: make_sender(pid, ctx), sender: make_sender(pid, ctx),
message: xous::Message::Move(xous::MemoryMessage { message: xous_kernel::Message::Move(xous_kernel::MemoryMessage {
id, id,
buf: MemoryRange::new(buf, buf_size).ok()?, buf: MemoryRange::new(buf, buf_size).ok()?,
offset: MemorySize::new(offset), 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 // 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) => { QueuedMessage::ScalarMessage(pid, ctx, _reserved, id, arg1, arg2, arg3, arg4) => {
let msg = xous::MessageEnvelope { let msg = xous_kernel::MessageEnvelope {
sender: make_sender(pid, ctx), sender: make_sender(pid, ctx),
message: xous::Message::Scalar(xous::ScalarMessage { message: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id, id,
arg1, arg1,
arg2, arg2,
@ -517,16 +517,16 @@ impl Server {
&mut self, &mut self,
pid: PID, pid: PID,
context: TID, context: TID,
message: xous::Message, message: xous_kernel::Message,
original_address: Option<MemoryAddress>, original_address: Option<MemoryAddress>,
) -> core::result::Result<usize, xous::Error> { ) -> core::result::Result<usize, xous_kernel::Error> {
// println!("Queueing message: {:?} for pid: {} ctx: {}", message, pid.get(), context); // println!("Queueing message: {:?} for pid: {} ctx: {}", message, pid.get(), context);
if self.queue[self.queue_head] != QueuedMessage::Empty { 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 { self.queue[self.queue_head] = match message {
xous::Message::Scalar(msg) => QueuedMessage::ScalarMessage( xous_kernel::Message::Scalar(msg) => QueuedMessage::ScalarMessage(
pid.get() as _, pid.get() as _,
context as _, context as _,
original_address.map(|x| x.get()).unwrap_or(0), original_address.map(|x| x.get()).unwrap_or(0),
@ -536,7 +536,7 @@ impl Server {
msg.arg3, msg.arg3,
msg.arg4, msg.arg4,
), ),
xous::Message::Move(msg) => QueuedMessage::MemoryMessageSend( xous_kernel::Message::Move(msg) => QueuedMessage::MemoryMessageSend(
pid.get() as _, pid.get() as _,
context as _, context as _,
original_address.map(|x| x.get()).unwrap_or(0), 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.offset.map(|x| x.get()).unwrap_or(0) as usize,
msg.valid.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 _, pid.get() as _,
context as _, context as _,
original_address.map(|x| x.get()).unwrap_or(0), 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.offset.map(|x| x.get()).unwrap_or(0) as usize,
msg.valid.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 _, pid.get() as _,
context as _, context as _,
original_address.map(|x| x.get()).unwrap_or(0), original_address.map(|x| x.get()).unwrap_or(0),
@ -582,14 +582,14 @@ impl Server {
context: TID, context: TID,
message: &Message, message: &Message,
client_address: Option<MemoryAddress>, client_address: Option<MemoryAddress>,
) -> core::result::Result<usize, xous::Error> { ) -> core::result::Result<usize, xous_kernel::Error> {
// println!("Queueing address message: {:?} (pid: {} ctx: {})", message, pid.get(), context); // println!("Queueing address message: {:?} (pid: {} ctx: {})", message, pid.get(), context);
if self.queue[self.queue_head] != QueuedMessage::Empty { 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 { let (server_address, len) = match message {
xous::Message::Scalar(_) | xous::Message::Move(_) => (0, 0), xous_kernel::Message::Scalar(_) | xous_kernel::Message::Move(_) => (0, 0),
xous::Message::MutableBorrow(msg) | xous::Message::Borrow(msg) => { xous_kernel::Message::MutableBorrow(msg) | xous_kernel::Message::Borrow(msg) => {
(msg.buf.addr.get(), msg.buf.size.get()) (msg.buf.addr.get(), msg.buf.size.get())
} }
}; };

View file

@ -3,12 +3,12 @@ use crate::arch::mem::MemoryMapping;
pub use crate::arch::process::Process as ArchProcess; pub use crate::arch::process::Process as ArchProcess;
pub use crate::arch::process::Thread; pub use crate::arch::process::Thread;
use crate::mem::MemoryManager; use crate::mem::MemoryManager;
use xous::MemoryRange; use xous_kernel::MemoryRange;
use crate::filled_array; use crate::filled_array;
use crate::server::Server; use crate::server::Server;
// use core::mem; // use core::mem;
use xous::{ use xous_kernel::{
pid_from_usize, Error, MemoryAddress, Message, ProcessInit, ThreadInit, CID, PID, SID, TID, 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); crate::arch::process::set_current_pid(self.pid);
self.mapping.activate()?; self.mapping.activate()?;
let mut current_process = crate::arch::process::Process::current(); let mut current_process = crate::arch::process::Process::current();
current_process.activate() current_process.activate()
} }
pub fn terminate(&mut self) -> Result<(), xous::Error> { pub fn terminate(&mut self) -> Result<(), xous_kernel::Error> {
if self.free() { if self.free() {
return Err(xous::Error::ProcessNotFound); return Err(xous_kernel::Error::ProcessNotFound);
} }
// TODO: Free all pages // 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 /// 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()`. /// and a new PID, though the process is in the state `Setup()`.
pub fn create_process(&mut self, init_process: ProcessInit) -> Result<PID, xous::Error> { pub fn create_process(&mut self, init_process: ProcessInit) -> Result<PID, xous_kernel::Error> {
for (idx, mut entry) in self.processes.iter_mut().enumerate() { for (idx, mut entry) in self.processes.iter_mut().enumerate() {
if entry.state != ProcessState::Free { if entry.state != ProcessState::Free {
continue; continue;
@ -340,10 +340,10 @@ impl SystemServices {
entry.pid = new_pid; entry.pid = new_pid;
return Ok(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. // PID0 doesn't exist -- process IDs are offset by 1.
let pid_idx = pid.get() as usize - 1; let pid_idx = pid.get() as usize - 1;
if cfg!(baremetal) && self.processes[pid_idx].mapping.get_pid() != pid { if cfg!(baremetal) && self.processes[pid_idx].mapping.get_pid() != pid {
@ -352,12 +352,12 @@ impl SystemServices {
self.processes[pid_idx].mapping.get_pid(), self.processes[pid_idx].mapping.get_pid(),
pid pid
); );
return Err(xous::Error::ProcessNotFound); return Err(xous_kernel::Error::ProcessNotFound);
} }
Ok(&self.processes[pid_idx]) 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. // PID0 doesn't exist -- process IDs are offset by 1.
let pid_idx = pid.get() as usize - 1; let pid_idx = pid.get() as usize - 1;
@ -367,7 +367,7 @@ impl SystemServices {
// self.processes[pid_idx].mapping.get_pid(), // self.processes[pid_idx].mapping.get_pid(),
// pid // pid
// ); // );
// return Err(xous::Error::ProcessNotFound); // return Err(xous_kernel::Error::ProcessNotFound);
// } // }
Ok(&mut self.processes[pid_idx]) Ok(&mut self.processes[pid_idx])
} }
@ -398,7 +398,7 @@ impl SystemServices {
/// 2. Save the process state, if it hasn't already been saved /// 2. Save the process state, if it hasn't already been saved
/// 3. Run the new process, returning to an illegal instruction /// 3. Run the new process, returning to an illegal instruction
#[cfg(baremetal)] #[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 // 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. // as Ready. Note that the new PID may very well be the same PID.
{ {
@ -448,8 +448,8 @@ impl SystemServices {
_pc: *const usize, _pc: *const usize,
_irq_no: usize, _irq_no: usize,
_arg: *mut usize, _arg: *mut usize,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
Err(xous::Error::UnhandledSyscall) Err(xous_kernel::Error::UnhandledSyscall)
} }
/// Create a stack frame in the specified process and jump to it. /// Create a stack frame in the specified process and jump to it.
@ -463,7 +463,7 @@ impl SystemServices {
pc: *const usize, pc: *const usize,
irq_no: usize, irq_no: usize,
arg: *mut usize, arg: *mut usize,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
// Get the current process (which was just interrupted) and mark it as // Get the current process (which was just interrupted) and mark it as
// "ready to run". If this function is called when the current process // "ready to run". If this function is called when the current process
// isn't running, that means the system has gotten into an invalid // 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 /// Mark the specified context as ready to run. If the thread is Sleeping, mark
/// it as Ready. /// 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); // assert!(tid == INITIAL_TID);
let process = self.get_process_mut(pid)?; let process = self.get_process_mut(pid)?;
process.state = match process.state { process.state = match process.state {
@ -557,7 +557,7 @@ impl SystemServices {
/// # Panics /// # Panics
/// ///
/// If the current process is not running, or if it's "Running" but has no free contexts /// 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<TID>) -> Result<(), xous::Error> { pub fn switch_to_thread(&mut self, pid: PID, tid: Option<TID>) -> Result<(), xous_kernel::Error> {
let process = self.get_process_mut(pid)?; let process = self.get_process_mut(pid)?;
// println!( // println!(
// "switch_to_thread({}:{:?}): Old state was {:?}", // "switch_to_thread({}:{:?}): Old state was {:?}",
@ -566,9 +566,9 @@ impl SystemServices {
// Determine which context number to switch to // Determine which context number to switch to
process.state = match process.state { process.state = match process.state {
ProcessState::Free => return Err(xous::Error::ProcessNotFound), ProcessState::Free => return Err(xous_kernel::Error::ProcessNotFound),
ProcessState::Sleeping => return Err(xous::Error::ProcessNotFound), ProcessState::Sleeping => return Err(xous_kernel::Error::ProcessNotFound),
ProcessState::Allocated => return Err(xous::Error::ProcessNotFound), ProcessState::Allocated => return Err(xous_kernel::Error::ProcessNotFound),
ProcessState::Setup(setup) => { ProcessState::Setup(setup) => {
// Activate the process, which enables its memory mapping // Activate the process, which enables its memory mapping
process.activate()?; process.activate()?;
@ -608,7 +608,7 @@ impl SystemServices {
Some(ctx) => { Some(ctx) => {
// Ensure the specified context is ready to run // Ensure the specified context is ready to run
if x & (1 << ctx) == 0 { if x & (1 << ctx) == 0 {
return Err(xous::Error::InvalidThread); return Err(xous_kernel::Error::InvalidThread);
} }
ctx ctx
} }
@ -652,7 +652,7 @@ impl SystemServices {
if ready_threads & (1 << ctx) == 0 if ready_threads & (1 << ctx) == 0
/*&& ctx != current_thread*/ /*&& ctx != current_thread*/
{ {
return Err(xous::Error::InvalidThread); return Err(xous_kernel::Error::InvalidThread);
} }
ctx ctx
} }
@ -682,7 +682,7 @@ impl SystemServices {
/// # Panics /// # Panics
/// ///
/// If the current process is not running. /// 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)?; let process = self.get_process_mut(pid)?;
// println!( // println!(
// "switch_from_thread({}:{}): Old state was {:?}", // "switch_from_thread({}:{}): Old state was {:?}",
@ -744,8 +744,8 @@ impl SystemServices {
&mut self, &mut self,
pid: PID, pid: PID,
tid: TID, tid: TID,
result: xous::Result, result: xous_kernel::Result,
) -> Result<(), xous::Error> { ) -> Result<(), xous_kernel::Error> {
// Temporarily switch into the target process memory space // Temporarily switch into the target process memory space
// in order to pass the return value. // in order to pass the return value.
let current_pid = self.current_pid(); let current_pid = self.current_pid();
@ -772,7 +772,7 @@ impl SystemServices {
new_pid: PID, new_pid: PID,
mut new_tid: TID, mut new_tid: TID,
can_resume: bool, can_resume: bool,
) -> Result<TID, xous::Error> { ) -> Result<TID, xous_kernel::Error> {
// println!("Activating PID {}, context {}", new_pid, new_tid); // println!("Activating PID {}, context {}", new_pid, new_tid);
let previous_pid = self.current_pid(); let previous_pid = self.current_pid();
println!( println!(
@ -789,7 +789,7 @@ impl SystemServices {
match new.state { match new.state {
ProcessState::Free => { ProcessState::Free => {
println!("PID {} was free", new_pid); 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::Setup(_) | ProcessState::Allocated => new_tid = INITIAL_TID,
ProcessState::Running(x) | ProcessState::Ready(x) => { ProcessState::Running(x) | ProcessState::Ready(x) => {
@ -815,7 +815,7 @@ impl SystemServices {
// // If we've looped around, return an error. // // If we've looped around, return an error.
// if new_tid == new.current_thread as usize { // if new_tid == new.current_thread as usize {
println!("Looked through all contexts and couldn't find one that was ready"); 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); // println!(" -- picked context {}", new_context);
@ -824,12 +824,12 @@ impl SystemServices {
"thread is {:?}, which is not valid for new thread {}", "thread is {:?}, which is not valid for new thread {}",
new.state, new_tid new.state, new_tid
); );
return Err(xous::Error::ProcessNotFound); return Err(xous_kernel::Error::ProcessNotFound);
} }
} }
ProcessState::Sleeping => { ProcessState::Sleeping => {
println!("PID {} was sleeping", new_pid); 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)?; /* let new = self.get_process_mut(new_pid)?; /*
new.state = match new.state { new.state = match new.state {
ProcessState::Running(x) if (x & 1 << new_tid) == 0 => { ProcessState::Running(x) if (x & 1 << new_tid) == 0 => {
return Err(xous::Error::ProcessNotFound) return Err(xous_kernel::Error::ProcessNotFound)
} }
// ProcessState::Running(x) => { // ProcessState::Running(x) => {
// if can_resume { // if can_resume {
@ -979,18 +979,18 @@ impl SystemServices {
dest_pid: PID, dest_pid: PID,
dest_virt: *mut u8, dest_virt: *mut u8,
len: usize, len: usize,
) -> Result<*mut u8, xous::Error> { ) -> Result<*mut u8, xous_kernel::Error> {
if len == 0 { if len == 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
if len & 0xfff != 0 { if len & 0xfff != 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
if src_virt as usize & 0xfff != 0 { 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 { if dest_virt as usize & 0xfff != 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
let current_pid = self.current_pid(); let current_pid = self.current_pid();
@ -1000,7 +1000,7 @@ impl SystemServices {
// Locate an address to fit the new memory. // Locate an address to fit the new memory.
dest_mapping.activate()?; dest_mapping.activate()?;
let dest_virt = mm 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| { .or_else(|e| {
src_mapping.activate().expect("couldn't undo mapping"); src_mapping.activate().expect("couldn't undo mapping");
Err(e) Err(e)
@ -1035,7 +1035,7 @@ impl SystemServices {
_dest_pid: PID, _dest_pid: PID,
_dest_virt: *mut u8, _dest_virt: *mut u8,
_len: usize, _len: usize,
) -> Result<*mut u8, xous::Error> { ) -> Result<*mut u8, xous_kernel::Error> {
Ok(src_virt) Ok(src_virt)
} }
@ -1072,18 +1072,18 @@ impl SystemServices {
dest_virt: *mut u8, dest_virt: *mut u8,
len: usize, len: usize,
mutable: bool, mutable: bool,
) -> Result<*mut u8, xous::Error> { ) -> Result<*mut u8, xous_kernel::Error> {
if len == 0 { if len == 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
if len & 0xfff != 0 { if len & 0xfff != 0 {
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
if src_virt as usize & 0xfff != 0 { 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 { if dest_virt as usize & 0xfff != 0 {
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
let current_pid = self.current_pid(); let current_pid = self.current_pid();
@ -1093,7 +1093,7 @@ impl SystemServices {
// Locate an address to fit the new memory. // Locate an address to fit the new memory.
dest_mapping.activate()?; dest_mapping.activate()?;
let dest_virt = mm 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| { .or_else(|e| {
src_mapping.activate().unwrap(); src_mapping.activate().unwrap();
Err(e) Err(e)
@ -1131,7 +1131,7 @@ impl SystemServices {
_dest_virt: *mut u8, _dest_virt: *mut u8,
_len: usize, _len: usize,
_mutable: bool, _mutable: bool,
) -> Result<*mut u8, xous::Error> { ) -> Result<*mut u8, xous_kernel::Error> {
Ok(src_virt) Ok(src_virt)
} }
@ -1153,18 +1153,18 @@ impl SystemServices {
dest_pid: PID, dest_pid: PID,
dest_virt: *mut u8, dest_virt: *mut u8,
len: usize, len: usize,
) -> Result<*mut u8, xous::Error> { ) -> Result<*mut u8, xous_kernel::Error> {
if len == 0 { if len == 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
if len & 0xfff != 0 { if len & 0xfff != 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
if src_virt as usize & 0xfff != 0 { 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 { if dest_virt as usize & 0xfff != 0 {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
} }
let current_pid = self.current_pid(); let current_pid = self.current_pid();
@ -1200,7 +1200,7 @@ impl SystemServices {
dest_pid: PID, dest_pid: PID,
_dest_virt: *mut u8, _dest_virt: *mut u8,
len: usize, 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 buf = unsafe { core::slice::from_raw_parts(src_virt, len) };
let current_pid = self.current_pid(); let current_pid = self.current_pid();
{ {
@ -1226,14 +1226,14 @@ impl SystemServices {
/// ///
/// * **ThreadNotAvailable**: The process has used all of its context /// * **ThreadNotAvailable**: The process has used all of its context
/// slots. /// slots.
pub fn create_thread(&mut self, pid: PID, thread_init: ThreadInit) -> Result<TID, xous::Error> { pub fn create_thread(&mut self, pid: PID, thread_init: ThreadInit) -> Result<TID, xous_kernel::Error> {
let mut process = self.get_process_mut(pid)?; let mut process = self.get_process_mut(pid)?;
process.activate()?; process.activate()?;
let mut arch_process = crate::arch::process::Process::current(); let mut arch_process = crate::arch::process::Process::current();
let new_tid = arch_process let new_tid = arch_process
.find_free_thread() .find_free_thread()
.ok_or(xous::Error::ThreadNotAvailable)?; .ok_or(xous_kernel::Error::ThreadNotAvailable)?;
arch_process.setup_thread(new_tid, thread_init)?; arch_process.setup_thread(new_tid, thread_init)?;
@ -1265,7 +1265,7 @@ impl SystemServices {
/// queue. /// queue.
/// * **ServerNotFound**: The server queue was full and a free slot could not /// * **ServerNotFound**: The server queue was full and a free slot could not
/// be found. /// be found.
pub fn create_server(&mut self, pid: PID, sid: SID) -> Result<SID, xous::Error> { pub fn create_server(&mut self, pid: PID, sid: SID) -> Result<SID, xous_kernel::Error> {
// println!( // println!(
// "KERNEL({}): Looking through server list for free server", // "KERNEL({}): Looking through server list for free server",
// self.pid.get() // self.pid.get()
@ -1300,12 +1300,12 @@ impl SystemServices {
return Ok(sid); 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 /// Allocate a new server ID for this process and return the address. If the
/// server table is full, return an error. /// server table is full, return an error.
pub fn connect_to_server(&mut self, sid: SID) -> Result<CID, xous::Error> { pub fn connect_to_server(&mut self, sid: SID) -> Result<CID, xous_kernel::Error> {
// Check to see if we've already connected to this server. // Check to see if we've already connected to this server.
// While doing this, find a free slot in case we haven't // While doing this, find a free slot in case we haven't
// yet connected. // 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, context: TID,
message: Message, message: Message,
original_address: Option<MemoryAddress>, original_address: Option<MemoryAddress>,
) -> Result<usize, xous::Error> { ) -> Result<usize, xous_kernel::Error> {
let current_pid = self.current_pid(); let current_pid = self.current_pid();
let result = { let result = {
let server_pid = self let server_pid = self
.server_from_sidx(sidx) .server_from_sidx(sidx)
.ok_or(xous::Error::ServerNotFound)? .ok_or(xous_kernel::Error::ServerNotFound)?
.pid; .pid;
{ {
let server_process = self.get_process(server_pid)?; let server_process = self.get_process(server_pid)?;
@ -1420,11 +1420,11 @@ impl SystemServices {
context: TID, context: TID,
message: &Message, message: &Message,
client_address: Option<MemoryAddress>, client_address: Option<MemoryAddress>,
) -> Result<usize, xous::Error> { ) -> Result<usize, xous_kernel::Error> {
// let current_pid = self.current_pid(); // let current_pid = self.current_pid();
// let server_pid = self // let server_pid = self
// .server_from_sidx(sidx) // .server_from_sidx(sidx)
// .ok_or(xous::Error::ServerNotFound)? // .ok_or(xous_kernel::Error::ServerNotFound)?
// .pid; // .pid;
// { // {
// let server_process = self.get_process(server_pid)?; // let server_process = self.get_process(server_pid)?;
@ -1449,7 +1449,7 @@ impl SystemServices {
} }
/// Terminate the given process. Returns the process' parent PID. /// Terminate the given process. Returns the process' parent PID.
pub fn terminate_process(&mut self, target_pid: PID) -> Result<PID, xous::Error> { pub fn terminate_process(&mut self, target_pid: PID) -> Result<PID, xous_kernel::Error> {
// To terminate a process, we must perform the following: // To terminate a process, we must perform the following:
// //
// 1. If we have any client connections, remove them. // 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. /// 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. // Destroy all servers. This will cause all queued messages to be lost.
for server in &mut self.servers { for server in &mut self.servers {
if server.is_some() { if server.is_some() {

View file

@ -5,14 +5,14 @@ use crate::mem::{MemoryManager, PAGE_SIZE};
use crate::server::{SenderID, WaitingMessage}; use crate::server::{SenderID, WaitingMessage};
use crate::services::SystemServices; use crate::services::SystemServices;
use core::mem; use core::mem;
use xous::*; use xous_kernel::*;
/// This is the context that called SwitchTo /// This is the context that called SwitchTo
static mut SWITCHTO_CALLER: Option<(PID, TID)> = None; static mut SWITCHTO_CALLER: Option<(PID, TID)> = None;
fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallResult { fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallResult {
SystemServices::with_mut(|ss| { 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!(); // ::debug_here::debug_here!();
let server_pid = ss let server_pid = ss
@ -133,25 +133,25 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
if blocking && cfg!(baremetal) { if blocking && cfg!(baremetal) {
// println!("Activating Server context and switching away from Client"); // println!("Activating Server context and switching away from Client");
ss.activate_process_thread(thread, server_pid, server_tid, !blocking) ss.activate_process_thread(thread, server_pid, server_tid, !blocking)
.map(|_| Ok(xous::Result::Message(envelope))) .map(|_| Ok(xous_kernel::Result::Message(envelope)))
.unwrap_or(Err(xous::Error::ProcessNotFound)) .unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
} else if blocking && !cfg!(baremetal) { } else if blocking && !cfg!(baremetal) {
// println!("Blocking client, since it sent a blocking message"); // println!("Blocking client, since it sent a blocking message");
ss.switch_from_thread(pid, thread)?; ss.switch_from_thread(pid, thread)?;
ss.switch_to_thread(server_pid, Some(server_tid))?; ss.switch_to_thread(server_pid, Some(server_tid))?;
ss.set_thread_result(server_pid, server_tid, xous::Result::Message(envelope)) ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope))
.map(|_| xous::Result::BlockedProcess) .map(|_| xous_kernel::Result::BlockedProcess)
} else if cfg!(baremetal) { } else if cfg!(baremetal) {
// println!("Setting the return value of the Server and returning to Client"); // println!("Setting the return value of the Server and returning to Client");
ss.set_thread_result(server_pid, server_tid, xous::Result::Message(envelope)) ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope))
.map(|_| xous::Result::Ok) .map(|_| xous_kernel::Result::Ok)
} else { } else {
// println!("Setting the return value of the Server and returning to Client"); // 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 // "Switch to" the server PID when not running on bare metal. This ensures
// that it's "Running". // that it's "Running".
ss.switch_to_thread(server_pid, Some(server_tid))?; ss.switch_to_thread(server_pid, Some(server_tid))?;
ss.set_thread_result(server_pid, server_tid, xous::Result::Message(envelope)) ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Message(envelope))
.map(|_| xous::Result::Ok) .map(|_| xous_kernel::Result::Ok)
} }
} else { } else {
// Add this message to the queue. If the queue is full, this // 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; let ppid = process.ppid;
unsafe { SWITCHTO_CALLER = None }; unsafe { SWITCHTO_CALLER = None };
ss.activate_process_thread(thread, ppid, 0, !blocking) ss.activate_process_thread(thread, ppid, 0, !blocking)
.map(|_| Ok(xous::Result::ResumeProcess)) .map(|_| Ok(xous_kernel::Result::ResumeProcess))
.unwrap_or(Err(xous::Error::ProcessNotFound)) .unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
} else { } else {
ss.switch_from_thread(pid, thread)?; ss.switch_from_thread(pid, thread)?;
Ok(xous::Result::BlockedProcess) Ok(xous_kernel::Result::BlockedProcess)
} }
} else { } else {
// println!("Returning to Client with Ok result"); // 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 let server = ss
.server_from_sidx(sender.sidx) .server_from_sidx(sender.sidx)
.ok_or(xous::Error::ServerNotFound)?; .ok_or(xous_kernel::Error::ServerNotFound)?;
if server.pid != pid { 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 result = server.take_waiting_message(sender.tidx, buf)?;
let (client_pid, client_tid, server_addr, client_addr, len) = match result { 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, len,
) => (client_pid, client_ctx, server_addr, client_addr, len), ) => (client_pid, client_ctx, server_addr, client_addr, len),
WaitingMessage::MovedMemory => { WaitingMessage::MovedMemory => {
return Ok(xous::Result::Ok); return Ok(xous_kernel::Result::Ok);
} }
WaitingMessage::ForgetMemory(range) => { WaitingMessage::ForgetMemory(range) => {
return MemoryManager::with_mut(|mm| { 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 virt = range.addr.get();
let size = range.size.get(); let size = range.size.get();
if virt & 0xfff != 0 { 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) { for addr in (virt..(virt + size)).step_by(PAGE_SIZE) {
if let Err(e) = mm.unmap_page(addr as *mut usize) { 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 => { WaitingMessage::None => {
println!("WARNING: Tried to wait on a message that didn't exist"); println!("WARNING: Tried to wait on a message that didn't exist");
return Err(xous::Error::ProcessNotFound); return Err(xous_kernel::Error::ProcessNotFound);
} }
}; };
// println!( // println!(
@ -251,8 +251,8 @@ fn return_memory(pid: PID, _tid: TID, sender: MessageSender, buf: MemoryRange) -
// ); // );
ss.ready_thread(client_pid, client_tid)?; ss.ready_thread(client_pid, client_tid)?;
ss.switch_to_thread(client_pid, Some(client_tid))?; ss.switch_to_thread(client_pid, Some(client_tid))?;
ss.set_thread_result(client_pid, client_tid, xous::Result::Ok)?; ss.set_thread_result(client_pid, client_tid, xous_kernel::Result::Ok)?;
Ok(xous::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" "current thread is not running"
); );
// See if there is a pending message. If so, return immediately. // 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 let server = ss
.server_from_sidx(sidx) .server_from_sidx(sidx)
.ok_or(xous::Error::ServerNotFound)?; .ok_or(xous_kernel::Error::ServerNotFound)?;
// server.print_queue(); // server.print_queue();
// Ensure the server is for this PID // Ensure the server is for this PID
if server.pid != 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 there is a pending message, return it immediately.
if let Some(msg) = server.take_next_message(sidx) { if let Some(msg) = server.take_next_message(sidx) {
// println!("PID {} had a message ready -- returning it", pid); // 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 // 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; let ppid = ss.get_process(pid).expect("Can't get current process").ppid;
// TODO: Advance thread // TODO: Advance thread
ss.activate_process_thread(tid, ppid, 0, false) ss.activate_process_thread(tid, ppid, 0, false)
.map(|_| Ok(xous::Result::ResumeProcess)) .map(|_| Ok(xous_kernel::Result::ResumeProcess))
.unwrap_or(Err(xous::Error::ProcessNotFound)) .unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
} }
// For hosted targets, simply return `BlockedProcess` indicating we'll make // For hosted targets, simply return `BlockedProcess` indicating we'll make
// a callback to their socket at a later time. // a callback to their socket at a later time.
else { else {
ss.switch_from_thread(pid, tid) 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 { pub fn handle(pid: PID, tid: TID, call: SysCall) -> SysCallResult {
#[cfg(feature = "debug-print")]
print!("KERNEL({}:{}): Syscall {:?}", pid, tid, call); print!("KERNEL({}:{}): Syscall {:?}", pid, tid, call);
let result = handle_inner(pid, tid, call); let result = handle_inner(pid, tid, call);
#[cfg(feature = "debug-print")]
println!(" -> {:?}", result); println!(" -> {:?}", result);
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) .map(|x| x.get() >= arch::mem::USER_AREA_END)
.unwrap_or(false) .unwrap_or(false)
{ {
return Err(xous::Error::BadAddress); return Err(xous_kernel::Error::BadAddress);
// Don't allow mapping non-page values // Don't allow mapping non-page values
} else if size.get() & (PAGE_SIZE - 1) != 0 { } else if size.get() & (PAGE_SIZE - 1) != 0 {
// println!("map: bad alignment of size {:08x}", size); // println!("map: bad alignment of size {:08x}", size);
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
// println!( // println!(
// "Mapping {:08x} -> {:08x} ({} bytes, flags: {:?})", // "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| { 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 virt = range.as_ptr() as usize;
let size = range.len(); let size = range.len();
if virt & 0xfff != 0 { 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) { for addr in (virt..(virt + size)).step_by(PAGE_SIZE) {
if let Err(e) = mm.unmap_page(addr as *mut usize) { 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) => { SysCall::IncreaseHeap(delta, flags) => {
if delta & 0xfff != 0 { if delta & 0xfff != 0 {
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
let start = { let start = {
ArchProcess::with_inner_mut(|process_inner| { ArchProcess::with_inner_mut(|process_inner| {
if process_inner.mem_heap_size + delta > process_inner.mem_heap_max { 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; 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| { MemoryManager::with_mut(|mm| {
Ok(xous::Result::MemoryRange( Ok(xous_kernel::Result::MemoryRange(
mm.reserve_range(start, delta, flags)?, mm.reserve_range(start, delta, flags)?,
)) ))
}) })
} }
SysCall::DecreaseHeap(delta) => { SysCall::DecreaseHeap(delta) => {
if delta & 0xfff != 0 { if delta & 0xfff != 0 {
return Err(xous::Error::BadAlignment); return Err(xous_kernel::Error::BadAlignment);
} }
let start = ArchProcess::with_inner_mut(|process_inner| { let start = ArchProcess::with_inner_mut(|process_inner| {
if process_inner.mem_heap_size + delta > process_inner.mem_heap_max { 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; 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"); .expect("unable to unmap page");
} }
}); });
Ok(xous::Result::Ok) Ok(xous_kernel::Result::Ok)
} }
SysCall::SwitchTo(new_pid, new_context) => { SysCall::SwitchTo(new_pid, new_context) => {
SystemServices::with_mut(|ss| { 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) ss.activate_process_thread(tid, new_pid, new_context, true)
.map(|_ctx| { .map(|_ctx| {
// println!("switchto ({}, {})", pid, _ctx); // println!("switchto ({}, {})", pid, _ctx);
xous::Result::ResumeProcess xous_kernel::Result::ResumeProcess
}) })
}) })
} }
SysCall::ClaimInterrupt(no, callback, arg) => { 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 => { SysCall::Yield => {
// If we're not running on bare metal, treat this as a no-op. // If we're not running on bare metal, treat this as a no-op.
if !cfg!(baremetal) { if !cfg!(baremetal) {
return Ok(xous::Result::Ok); return Ok(xous_kernel::Result::Ok);
} }
let (parent_pid, parent_ctx) = unsafe { 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| { SystemServices::with_mut(|ss| {
// TODO: Advance thread // TODO: Advance thread
ss.activate_process_thread(tid, parent_pid, parent_ctx, true) ss.activate_process_thread(tid, parent_pid, parent_ctx, true)
.map(|_| Ok(xous::Result::ResumeProcess)) .map(|_| Ok(xous_kernel::Result::ResumeProcess))
.unwrap_or(Err(xous::Error::ProcessNotFound)) .unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
}) })
} }
SysCall::ReturnToParentI(_pid, _cpuid) => { 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"); .expect("ReturnToParentI called with no existing parent present");
crate::arch::irq::set_isr_return_pair(parent_pid, parent_ctx); 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::ReceiveMessage(sid) => receive_message(pid, tid, sid),
SysCall::WaitEvent => SystemServices::with_mut(|ss| { 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 }; unsafe { SWITCHTO_CALLER = None };
// TODO: Advance thread // TODO: Advance thread
ss.activate_process_thread(tid, ppid, 0, false) ss.activate_process_thread(tid, ppid, 0, false)
.map(|_| Ok(xous::Result::ResumeProcess)) .map(|_| Ok(xous_kernel::Result::ResumeProcess))
.unwrap_or(Err(xous::Error::ProcessNotFound)) .unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
}), }),
SysCall::CreateThread(thread_init) => SystemServices::with_mut(|ss| { SysCall::CreateThread(thread_init) => SystemServices::with_mut(|ss| {
ss.create_thread(pid, thread_init).map(|new_tid| { 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)) ss.switch_to_thread(pid, Some(new_tid))
.expect("couldn't activate new thread"); .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| { 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) => { 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) => { SysCall::Connect(sid) => {
// ::debug_here::debug_here!(); // ::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::ReturnMemory(sender, buf) => return_memory(pid, tid, sender, buf),
SysCall::SendMessage(cid, message) => send_message(pid, tid, cid, message), 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)?; let ppid = ss.terminate_process(pid)?;
if cfg!(baremetal) { if cfg!(baremetal) {
ss.switch_to_thread(ppid, None) ss.switch_to_thread(ppid, None)
.map(|_| xous::Result::ResumeProcess) .map(|_| xous_kernel::Result::ResumeProcess)
} else { } else {
Ok(xous::Result::Ok) Ok(xous_kernel::Result::Ok)
} }
}), }),
SysCall::Shutdown => SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous::Result::Ok)), SysCall::Shutdown => SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok)),
_ => Err(xous::Error::UnhandledSyscall), _ => Err(xous_kernel::Error::UnhandledSyscall),
} }
} }

View file

@ -3,7 +3,7 @@ use std::thread::JoinHandle;
use std::net::ToSocketAddrs; use std::net::ToSocketAddrs;
use std::sync::mpsc::channel; use std::sync::mpsc::channel;
use xous::{rsyscall, SysCall}; use xous_kernel::{rsyscall, SysCall};
mod shutdown; mod shutdown;
@ -31,7 +31,7 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> {
for b in pid1_key.iter_mut() { for b in pid1_key.iter_mut() {
*b = rng.gen(); *b = rng.gen();
} }
xous::arch::set_process_key(&pid1_key); xous_kernel::arch::set_process_key(&pid1_key);
let server_addr = server_spec let server_addr = server_spec
.to_socket_addrs() .to_socket_addrs()
@ -58,7 +58,7 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> {
}) })
.expect("couldn't start kernel thread"); .expect("couldn't start kernel thread");
let server_addr = recv_addr.recv().unwrap(); 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. // Connect to server. This first instance needs to make sure the kernel is listening.
// let mut server_conn = None; // let mut server_conn = None;
@ -78,8 +78,8 @@ fn start_kernel(server_spec: &str) -> JoinHandle<()> {
fn shutdown_kernel() { fn shutdown_kernel() {
// Any process ought to be able to shut down the system currently. // Any process ought to be able to shut down the system currently.
xous::wait_process_as_thread( xous_kernel::wait_process_as_thread(
xous::create_process_as_thread(xous::ProcessArgsAsThread::new("shutdown", || { xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new("shutdown", || {
rsyscall(SysCall::Shutdown).expect("unable to shutdown server"); rsyscall(SysCall::Shutdown).expect("unable to shutdown server");
})) }))
.expect("couldn't shut down the kernel"), .expect("couldn't shut down the kernel"),
@ -95,10 +95,10 @@ fn shutdown_kernel() {
// F: Send + 'static, // F: Send + 'static,
// R: Send + 'static, // R: Send + 'static,
// { // {
// let server_spec = xous::arch::xous_address(); // let server_spec = xous_kernel::arch::xous_address();
// std::thread::spawn(move || { // std::thread::spawn(move || {
// xous::arch::set_xous_address(server_spec); // xous_kernel::arch::set_xous_address(server_spec);
// xous::arch::xous_connect(); // xous_kernel::arch::xous_connect();
// f() // f()
// }) // })
// } // }
@ -126,16 +126,16 @@ fn send_scalar_message() {
// and receive the message. Note that we need to communicate to the // and receive the message. Note that we need to communicate to the
// "Client" what our server ID is. Normally this would be done via // "Client" what our server ID is. Normally this would be done via
// an external nameserver. // 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", "send_scalar_message server",
move || { move || {
let sid = 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(); 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!( assert_eq!(
envelope.message, envelope.message,
xous::Message::Scalar(xous::ScalarMessage { xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id: 1, id: 1,
arg1: 2, arg1: 2,
arg2: 3, arg2: 3,
@ -148,14 +148,14 @@ fn send_scalar_message() {
.expect("couldn't spawn server process"); .expect("couldn't spawn server process");
// Spawn the client "process" and wait for the server address. // 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", "send_scalar_message client",
move || { move || {
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
let conn = xous::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::connect(sid).expect("couldn't connect to server");
xous::send_message( xous_kernel::send_message(
conn, conn,
xous::Message::Scalar(xous::ScalarMessage { xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
id: 1, id: 1,
arg1: 2, arg1: 2,
arg2: 3, arg2: 3,
@ -185,19 +185,19 @@ fn send_move_message() {
let (server_addr_send, server_addr_recv) = channel(); 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", "send_move_message server",
move || { move || {
// println!("SERVER: Creating server..."); // println!("SERVER: Creating server...");
let sid = 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); // println!("SERVER: Sending server address of {:?} to client", sid);
server_addr_send.send(sid).unwrap(); server_addr_send.send(sid).unwrap();
// println!("SERVER: Starting to receive messages..."); // 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); // println!("SERVER: Received message from {}", envelope.sender);
let message = envelope.message; let message = envelope.message;
if let xous::Message::Move(m) = message { if let xous_kernel::Message::Move(m) = message {
let buf = m.buf; let buf = m.buf;
let bt = unsafe { let bt = unsafe {
Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) 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"); .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", "send_move_message client",
move || { move || {
// println!("CLIENT: Waiting for server address..."); // println!("CLIENT: Waiting for server address...");
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
// println!("CLIENT: Connecting to server {:?}", sid); // println!("CLIENT: Connecting to server {:?}", sid);
let conn = xous::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::connect(sid).expect("couldn't connect to server");
let msg = xous::carton::Carton::from_bytes(test_bytes); let msg = xous_kernel::carton::Carton::from_bytes(test_bytes);
xous::send_message(conn, xous::Message::Move(msg.into_message(0))) xous_kernel::send_message(conn, xous_kernel::Message::Move(msg.into_message(0)))
.expect("couldn't send a message"); .expect("couldn't send a message");
// println!("CLIENT: Message sent"); // println!("CLIENT: Message sent");
}, },
@ -244,18 +244,18 @@ fn send_borrow_message() {
let test_str = "Hello, world!"; let test_str = "Hello, world!";
let test_bytes = test_str.as_bytes(); 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", "send_borrow_message server",
move || { move || {
// println!("SERVER: Creating server..."); // println!("SERVER: Creating server...");
let sid = 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(); server_addr_send.send(sid).unwrap();
// println!("SERVER: Receiving message..."); // 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); // println!("SERVER: Received message from {}", envelope.sender);
let message = envelope.message; let message = envelope.message;
if let xous::Message::Borrow(m) = message { if let xous_kernel::Message::Borrow(m) = message {
let buf = m.buf; let buf = m.buf;
let bt = unsafe { let bt = unsafe {
Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) 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); assert_eq!(*test_bytes, *bt);
// let s = String::from_utf8_lossy(&bt); // let s = String::from_utf8_lossy(&bt);
// println!("SERVER: Got message: {:?} -> \"{}\"", bt, s); // 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"); // println!("SERVER: Returned memory");
} else { } else {
panic!("unexpected message type"); panic!("unexpected message type");
@ -272,7 +272,7 @@ fn send_borrow_message() {
)) ))
.expect("couldn't start server"); .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", "send_borrow_message client",
move || { move || {
// Get the server address (out of band) so we know what to connect to // 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 // Perform a connection to the server
// println!("CLIENT: Connecting to 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 // Convert the message into a "Carton" that can be shipped as a message
// println!("CLIENT: Creating carton..."); // 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 // Send the message to the server
// println!("CLIENT: Lending message..."); // println!("CLIENT: Lending message...");
@ -315,16 +315,16 @@ fn send_mutableborrow_message() {
let test_str = "Hello, world!"; let test_str = "Hello, world!";
let test_bytes = test_str.as_bytes(); 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", "send_mutableborrow_message server",
move || { move || {
let sid = 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(); 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); // println!("Received message from {}", envelope.sender);
let message = envelope.message; let message = envelope.message;
if let xous::Message::MutableBorrow(m) = message { if let xous_kernel::Message::MutableBorrow(m) = message {
let buf = m.buf; let buf = m.buf;
let mut bt = unsafe { let mut bt = unsafe {
Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) 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() { for letter in bt.iter_mut() {
*letter += 1; *letter += 1;
} }
xous::return_memory(envelope.sender, m.buf).unwrap(); xous_kernel::return_memory(envelope.sender, m.buf).unwrap();
} else { } else {
panic!("unexpected message type"); panic!("unexpected message type");
} }
@ -340,17 +340,17 @@ fn send_mutableborrow_message() {
)) ))
.expect("couldn't start server"); .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", "send_mutableborrow_message client",
move || { move || {
// Get the server address (out of band) so we know what to connect to // Get the server address (out of band) so we know what to connect to
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
// Perform a connection to the server // 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 // 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(); let mut check_bytes = test_bytes.to_vec();
for letter in check_bytes.iter_mut() { for letter in check_bytes.iter_mut() {
*letter += 1; *letter += 1;
@ -386,17 +386,17 @@ fn send_mutableborrow_message_repeat() {
let loops = 50; 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", "send_mutableborrow_message_repeat server",
move || { move || {
let sid = 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(); server_addr_send.send(sid).unwrap();
for iteration in 0..loops { 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; let message = envelope.message;
if let xous::Message::MutableBorrow(m) = message { if let xous_kernel::Message::MutableBorrow(m) = message {
let buf = m.buf; let buf = m.buf;
let mut bt = unsafe { let mut bt = unsafe {
Box::from_raw(core::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len())) 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() { for letter in bt.iter_mut() {
*letter = (*letter).wrapping_add((iteration & 0xff) as u8); *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 { } else {
panic!("unexpected message type"); panic!("unexpected message type");
} }
@ -413,18 +413,18 @@ fn send_mutableborrow_message_repeat() {
)) ))
.expect("couldn't start server"); .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", "send_mutableborrow_message_repeat client",
move || { move || {
// Get the server address (out of band) so we know what to connect to // Get the server address (out of band) so we know what to connect to
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
// Perform a connection to the server // 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 // Convert the message into a "Carton" that can be shipped as a message
for iteration in 0..loops { 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(); let mut check_bytes = test_bytes.to_vec();
for letter in check_bytes.iter_mut() { for letter in check_bytes.iter_mut() {
*letter = (*letter).wrapping_add((iteration & 0xff) as u8); *letter = (*letter).wrapping_add((iteration & 0xff) as u8);
@ -486,12 +486,12 @@ fn server_client_same_process() {
// Start the kernel in its own thread // Start the kernel in its own thread
let main_thread = start_kernel(SERVER_SPEC); 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", "server_client_same_process process",
|| { || {
let server = xous::create_server(b"s_c_same_process").expect("couldn't create server"); let server = xous_kernel::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 connection = xous_kernel::connect(server).expect("couldn't connect to our own server");
let msg_contents = xous::ScalarMessage { let msg_contents = xous_kernel::ScalarMessage {
id: 1, id: 1,
arg1: 2, arg1: 2,
arg2: 3, arg2: 3,
@ -499,17 +499,17 @@ fn server_client_same_process() {
arg4: 5, 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"); .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"); .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. // Any process ought to be able to shut down the system currently.
rsyscall(SysCall::Shutdown).expect("unable to shutdown server"); rsyscall(SysCall::Shutdown).expect("unable to shutdown server");
@ -524,12 +524,12 @@ fn multiple_contexts() {
// Start the kernel in its own thread // Start the kernel in its own thread
let main_thread = start_kernel(SERVER_SPEC); 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", "multiple_contexts process",
move || { move || {
let server = xous::create_server(b"multiple_context").expect("couldn't create server"); let server = xous_kernel::create_server(b"multiple_context").expect("couldn't create server");
let connection = xous::connect(server).expect("couldn't connect to our own server"); let connection = xous_kernel::connect(server).expect("couldn't connect to our own server");
let msg_contents = xous::ScalarMessage { let msg_contents = xous_kernel::ScalarMessage {
id: 1, id: 1,
arg1: 2, arg1: 2,
arg2: 3, arg2: 3,
@ -540,26 +540,26 @@ fn multiple_contexts() {
let mut server_threads = vec![]; let mut server_threads = vec![];
for _ in 0..crate::arch::process::MAX_THREAD { for _ in 0..crate::arch::process::MAX_THREAD {
server_threads.push( server_threads.push(
xous::create_thread(move || { xous_kernel::create_thread(move || {
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 spawn client thread"), .expect("couldn't spawn client thread"),
); );
} }
for _ in &server_threads { 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"); .expect("couldn't send message");
} }
for server_thread in server_threads.into_iter() { 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"); .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. // Any process ought to be able to shut down the system currently.
shutdown_kernel(); shutdown_kernel();
@ -585,17 +585,17 @@ fn process_restart_server() {
fn create_destroy_server(test_bytes: &'static [u8]) { fn create_destroy_server(test_bytes: &'static [u8]) {
let (server_addr_send, server_addr_recv) = channel(); 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", "process_restart_server server",
move || { move || {
let sid = 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(); server_addr_send.send(sid).unwrap();
let thr = xous::create_thread(move || { let thr = xous_kernel::create_thread(move || {
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); // println!("Received message from {}", envelope.sender);
let message = envelope.message; let message = envelope.message;
if let xous::Message::Move(m) = message { if let xous_kernel::Message::Move(m) = message {
let buf = m.buf; let buf = m.buf;
let bt = unsafe { let bt = unsafe {
Box::from_raw(core::slice::from_raw_parts_mut( Box::from_raw(core::slice::from_raw_parts_mut(
@ -611,26 +611,26 @@ fn process_restart_server() {
} }
}) })
.unwrap(); .unwrap();
xous::wait_thread(thr).unwrap(); xous_kernel::wait_thread(thr).unwrap();
}, },
)) ))
.expect("couldn't spawn server process"); .expect("couldn't spawn server process");
// Wait for the server to start up // 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", "process_restart_server client",
move || { move || {
let sid = server_addr_recv.recv().unwrap(); let sid = server_addr_recv.recv().unwrap();
let conn = xous::connect(sid).expect("couldn't connect to server"); let conn = xous_kernel::connect(sid).expect("couldn't connect to server");
let msg = xous::carton::Carton::from_bytes(test_bytes); let msg = xous_kernel::carton::Carton::from_bytes(test_bytes);
xous::send_message(conn, xous::Message::Move(msg.into_message(0))) xous_kernel::send_message(conn, xous_kernel::Message::Move(msg.into_message(0)))
.expect("couldn't send a message"); .expect("couldn't send a message");
}, },
)) ))
.expect("couldn't start client process"); .expect("couldn't start client process");
xous::wait_process_as_thread(xous_server).expect("couldn't join server process"); xous_kernel::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_client).expect("couldn't join client process");
} }
// create_destroy_server(test_bytes); // create_destroy_server(test_bytes);