mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
Merge remote-tracking branch 'betrusted/master' into hardware
This commit is contained in:
commit
95719852b3
20 changed files with 688 additions and 201 deletions
|
|
@ -28,13 +28,13 @@ _TBD_
|
|||
|
||||
## Contribution Guidelines
|
||||
|
||||
[](CODE_OF_CONDUCT.md)
|
||||
[](../CODE_OF_CONDUCT.md)
|
||||
|
||||
Please see [CONTRIBUTING](CONTRIBUTING.md) for details on
|
||||
Please see [CONTRIBUTING](../CONTRIBUTING.md) for details on
|
||||
how to make a contribution.
|
||||
|
||||
Please note that this project is released with a
|
||||
[Contributor Code of Conduct](CODE_OF_CONDUCT.md).
|
||||
[Contributor Code of Conduct](../CODE_OF_CONDUCT.md).
|
||||
By participating in this project you agree to abide its terms.
|
||||
|
||||
## License
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
pub mod irq;
|
||||
pub mod mem;
|
||||
pub mod process;
|
||||
pub mod rand;
|
||||
pub mod syscall;
|
||||
|
||||
use std::cell::RefCell;
|
||||
|
|
@ -59,7 +60,7 @@ pub fn set_send_addr(send_addr: Sender<SocketAddr>) {
|
|||
|
||||
#[cfg(not(test))]
|
||||
fn generate_pid_key() -> [u8; 16] {
|
||||
use rand::{thread_rng, Rng};
|
||||
use ::rand::{thread_rng, Rng};
|
||||
let mut process_key = [0u8; 16];
|
||||
let mut rng = thread_rng();
|
||||
for b in process_key.iter_mut() {
|
||||
|
|
@ -236,7 +237,7 @@ fn handle_connection(
|
|||
| xous_kernel::Message::BlockingScalar(_) => (),
|
||||
}
|
||||
}
|
||||
SysCall::ReturnMemory(_sender, ref mut buf) => {
|
||||
SysCall::ReturnMemory(ref _sender, ref mut buf) => {
|
||||
let sliced_data = data.into_boxed_slice();
|
||||
assert_eq!(
|
||||
sliced_data.len(),
|
||||
|
|
@ -548,14 +549,15 @@ pub fn idle() -> bool {
|
|||
"Unable to send response to process: {:?} -- terminating",
|
||||
_e
|
||||
);
|
||||
crate::syscall::handle(pid, thread_id, false, SysCall::TerminateProcess).ok();
|
||||
crate::syscall::handle(pid, thread_id, false, SysCall::TerminateProcess)
|
||||
.ok();
|
||||
});
|
||||
// println!("KERNEL: Done sending");
|
||||
}
|
||||
|
||||
// Handle the syscall within the Xous kernel
|
||||
let response =
|
||||
crate::syscall::handle(pid, thread_id, false, call).unwrap_or_else(Result::Error);
|
||||
let response = crate::syscall::handle(pid, thread_id, false, call)
|
||||
.unwrap_or_else(Result::Error);
|
||||
|
||||
// println!("KERNEL({}): Syscall response {:?}", pid, response);
|
||||
// There's a response if it wasn't a blocked process and we're not terminating.
|
||||
|
|
@ -584,7 +586,8 @@ pub fn idle() -> bool {
|
|||
"KERNEL({}): Unable to send response to process: {:?} -- terminating",
|
||||
pid, _e
|
||||
);
|
||||
crate::syscall::handle(pid, thread_id, false, SysCall::TerminateProcess).ok();
|
||||
crate::syscall::handle(pid, thread_id, false, SysCall::TerminateProcess)
|
||||
.ok();
|
||||
});
|
||||
crate::arch::process::set_current_pid(existing_pid);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -300,18 +300,18 @@ impl Process {
|
|||
if result.memory().is_some() {
|
||||
panic!("Result has memory and we're also returning memory!");
|
||||
}
|
||||
klog!("adding {} additional bytes from memory being returned", buf.len());
|
||||
klog!(
|
||||
"adding {} additional bytes from memory being returned",
|
||||
buf.len()
|
||||
);
|
||||
klog!("data: {:?}", buf);
|
||||
response.extend_from_slice(&buf);
|
||||
}
|
||||
|
||||
klog!("setting thread return value to {} bytes", response.len());
|
||||
process
|
||||
.conn
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.write_all(&response)
|
||||
.expect("Disconnection");
|
||||
let conn = process.conn.as_mut().unwrap();
|
||||
conn.write_all(&response).expect("Disconnection");
|
||||
conn.flush().expect("Disconnection");
|
||||
});
|
||||
}
|
||||
|
||||
|
|
@ -380,7 +380,9 @@ impl Process {
|
|||
let mut process_table = pt.borrow_mut();
|
||||
let current_pid_idx = process_table.current.get() as usize - 1;
|
||||
let process = &mut process_table.table[current_pid_idx].as_mut().unwrap();
|
||||
process.conn.as_mut().unwrap().write_all(bytes).unwrap();
|
||||
let conn = process.conn.as_mut().unwrap();
|
||||
conn.write_all(bytes).unwrap();
|
||||
conn.flush().unwrap();
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
|
|
|||
3
kernel/src/arch/hosted/rand.rs
Normal file
3
kernel/src/arch/hosted/rand.rs
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
pub fn get_u32() -> u32 {
|
||||
::rand::random()
|
||||
}
|
||||
|
|
@ -5,6 +5,7 @@ pub mod exception;
|
|||
pub mod irq;
|
||||
pub mod mem;
|
||||
pub mod process;
|
||||
pub mod rand;
|
||||
pub mod syscall;
|
||||
|
||||
pub use process::Thread;
|
||||
|
|
|
|||
16
kernel/src/arch/riscv/rand.rs
Normal file
16
kernel/src/arch/riscv/rand.rs
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
static mut LFSR: u32 = 0xace1u32;
|
||||
|
||||
fn move_lfsr(mut lfsr: u32) -> u32 {
|
||||
lfsr ^= lfsr >> 7;
|
||||
lfsr ^= lfsr << 9;
|
||||
lfsr ^= lfsr >> 13;
|
||||
lfsr
|
||||
}
|
||||
|
||||
pub fn get_u32() -> u32 {
|
||||
// The kernel is currently single-threaded, so this is a valid operation.
|
||||
unsafe {
|
||||
LFSR = move_lfsr(LFSR);
|
||||
LFSR
|
||||
}
|
||||
}
|
||||
|
|
@ -1,26 +1,49 @@
|
|||
pub use crate::arch::process::Thread;
|
||||
use core::mem;
|
||||
use xous_kernel::{MemoryAddress, MemoryRange, MemorySize, Message, PID, SID, TID};
|
||||
use xous_kernel::{MemoryAddress, MemoryRange, MemorySize, Message, MessageSender, PID, SID, TID};
|
||||
|
||||
pub struct SenderID {
|
||||
/// The index of the server within the SystemServices table
|
||||
pub sidx: usize,
|
||||
/// The index into the queue array
|
||||
pub idx: usize,
|
||||
/// The process ID that sent this message
|
||||
pid: Option<PID>,
|
||||
}
|
||||
|
||||
impl SenderID {
|
||||
pub fn new(sidx: usize, idx: usize, pid: Option<PID>) -> Self {
|
||||
SenderID { sidx, idx, pid }
|
||||
}
|
||||
}
|
||||
|
||||
impl From<usize> for SenderID {
|
||||
fn from(item: usize) -> SenderID {
|
||||
SenderID {
|
||||
sidx: item >> 16,
|
||||
sidx: (item >> 16) & 0xff,
|
||||
idx: item & 0xffff,
|
||||
pid: PID::new((item >> 24) as u8),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Into<usize> for SenderID {
|
||||
fn into(self) -> usize {
|
||||
(self.sidx << 16) | (self.idx & 0xffff)
|
||||
(self.pid.map(|x| x.get() as usize).unwrap_or(0) << 24)
|
||||
| ((self.sidx << 16) & 0x00ff0000)
|
||||
| (self.idx & 0xffff)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<MessageSender> for SenderID {
|
||||
fn from(item: MessageSender) -> SenderID {
|
||||
SenderID::from(item.to_usize())
|
||||
}
|
||||
}
|
||||
|
||||
impl Into<MessageSender> for SenderID {
|
||||
fn into(self) -> MessageSender {
|
||||
MessageSender::from_usize(self.into())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -333,12 +356,12 @@ impl Server {
|
|||
idx: usize,
|
||||
buf: Option<&MemoryRange>,
|
||||
) -> Result<WaitingMessage, xous_kernel::Error> {
|
||||
if idx > self.queue.len() {
|
||||
// println!("KERNEL: index exceeds queue length");
|
||||
return Err(xous_kernel::Error::BadAddress);
|
||||
}
|
||||
klog!("memory in queue[{}]: {:?}", idx, self.queue[idx]);
|
||||
let (pid, tid, server_addr, client_addr, len, forget, is_memory) = match self.queue[idx] {
|
||||
let current_val = self
|
||||
.queue
|
||||
.get_mut(idx)
|
||||
.ok_or(xous_kernel::Error::BadAddress)?;
|
||||
klog!("memory in queue[{}]: {:?}", idx, val);
|
||||
let (pid, tid, server_addr, client_addr, len, forget, is_memory) = match *current_val {
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, server_addr, client_addr, len) => {
|
||||
(pid, tid, server_addr, client_addr, len, false, true)
|
||||
}
|
||||
|
|
@ -357,17 +380,21 @@ impl Server {
|
|||
let buf = buf.expect("memory message expected but no buffer passed!");
|
||||
if server_addr != buf.as_ptr() as usize || len != buf.len() {
|
||||
// println!("KERNEL: Memory is attached but the returned buffer doesn't match (len: {} vs {}), buf addr: {:08x} vs {:08x}", len, buf.len(), server_addr, buf.as_ptr() as usize);
|
||||
return Err(xous_kernel::Error::BadAddress);
|
||||
Err(xous_kernel::Error::BadAddress)?;
|
||||
}
|
||||
}
|
||||
self.queue[idx] = QueuedMessage::Empty;
|
||||
*current_val = QueuedMessage::Empty;
|
||||
self.queue_tail += 1;
|
||||
if self.queue_tail >= self.queue.len() {
|
||||
self.queue_tail = 0;
|
||||
}
|
||||
|
||||
// Destructure the PID and context ID from the `pid_tid` field
|
||||
klog!("taking waiting message and returning to pid: {} tid: {}", pid, tid);
|
||||
klog!(
|
||||
"taking waiting message and returning to pid: {} tid: {}",
|
||||
pid,
|
||||
tid
|
||||
);
|
||||
|
||||
if !is_memory {
|
||||
return Ok(WaitingMessage::ScalarMessage(
|
||||
|
|
@ -414,12 +441,10 @@ impl Server {
|
|||
pub fn take_next_message(&mut self, sidx: usize) -> Option<xous_kernel::MessageEnvelope> {
|
||||
// println!(
|
||||
// "queue_head: ((({}))) queue_tail: ((({}))): {:?} CID: ((({})))",
|
||||
// self.queue_head, self.queue_tail, self.queue[self.queue_tail], cid
|
||||
// self.queue_head, self.queue_tail, self.queue[self.queue_tail], sidx
|
||||
// );
|
||||
let sender = SenderID {
|
||||
idx: self.queue_tail,
|
||||
sidx,
|
||||
}.into();
|
||||
use core::convert::TryInto;
|
||||
let mut sender = SenderID::new(sidx, self.queue_tail, None);
|
||||
let (result, response) = match self.queue[self.queue_tail] {
|
||||
QueuedMessage::Empty => return None,
|
||||
QueuedMessage::WaitingReturnMemory(_, _, _, _, _) => return None,
|
||||
|
|
@ -434,18 +459,21 @@ impl Server {
|
|||
buf_size,
|
||||
offset,
|
||||
valid,
|
||||
) => (
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender,
|
||||
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||
),
|
||||
) => {
|
||||
sender.pid = PID::new(pid.try_into().unwrap());
|
||||
(
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender: sender.into(),
|
||||
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||
)
|
||||
}
|
||||
QueuedMessage::MemoryMessageRWLend(
|
||||
pid,
|
||||
tid,
|
||||
|
|
@ -455,18 +483,21 @@ impl Server {
|
|||
buf_size,
|
||||
offset,
|
||||
valid,
|
||||
) => (
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender,
|
||||
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||
),
|
||||
) => {
|
||||
sender.pid = PID::new(pid.try_into().unwrap());
|
||||
(
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender: sender.into(),
|
||||
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||
)
|
||||
}
|
||||
QueuedMessage::MemoryMessageROLendTerminated(
|
||||
pid,
|
||||
tid,
|
||||
|
|
@ -476,18 +507,21 @@ impl Server {
|
|||
buf_size,
|
||||
offset,
|
||||
valid,
|
||||
) => (
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender,
|
||||
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||
),
|
||||
) => {
|
||||
sender.pid = PID::new(pid.try_into().unwrap());
|
||||
(
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender: sender.into(),
|
||||
body: xous_kernel::Message::Borrow(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||
)
|
||||
}
|
||||
QueuedMessage::MemoryMessageRWLendTerminated(
|
||||
pid,
|
||||
tid,
|
||||
|
|
@ -497,18 +531,21 @@ impl Server {
|
|||
buf_size,
|
||||
offset,
|
||||
valid,
|
||||
) => (
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender,
|
||||
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||
),
|
||||
) => {
|
||||
sender.pid = PID::new(pid.try_into().unwrap());
|
||||
(
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender: sender.into(),
|
||||
body: xous_kernel::Message::MutableBorrow(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
offset: MemorySize::new(offset),
|
||||
valid: MemorySize::new(valid),
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnMemory(pid, tid, buf, client_addr, buf_size),
|
||||
)
|
||||
}
|
||||
|
||||
QueuedMessage::BlockingScalarMessage(
|
||||
pid,
|
||||
|
|
@ -519,21 +556,24 @@ impl Server {
|
|||
arg2,
|
||||
arg3,
|
||||
arg4,
|
||||
) => (
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender,
|
||||
body: xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage {
|
||||
id,
|
||||
arg1,
|
||||
arg2,
|
||||
arg3,
|
||||
arg4,
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnScalar(pid, tid, client_addr),
|
||||
),
|
||||
) => {
|
||||
sender.pid = PID::new(pid.try_into().unwrap());
|
||||
(
|
||||
xous_kernel::MessageEnvelope {
|
||||
sender: sender.into(),
|
||||
body: xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage {
|
||||
id,
|
||||
arg1,
|
||||
arg2,
|
||||
arg3,
|
||||
arg4,
|
||||
}),
|
||||
},
|
||||
QueuedMessage::WaitingReturnScalar(pid, tid, client_addr),
|
||||
)
|
||||
}
|
||||
QueuedMessage::MemoryMessageSend(
|
||||
_pid,
|
||||
pid,
|
||||
_tid,
|
||||
_reserved,
|
||||
id,
|
||||
|
|
@ -542,8 +582,9 @@ impl Server {
|
|||
offset,
|
||||
valid,
|
||||
) => {
|
||||
sender.pid = PID::new(pid.try_into().unwrap());
|
||||
let msg = xous_kernel::MessageEnvelope {
|
||||
sender,
|
||||
sender: sender.into(),
|
||||
body: xous_kernel::Message::Move(xous_kernel::MemoryMessage {
|
||||
id,
|
||||
buf: MemoryRange::new(buf, buf_size).ok()?,
|
||||
|
|
@ -560,9 +601,10 @@ impl Server {
|
|||
}
|
||||
|
||||
// Scalar messages have nothing to return, so they can go straight to the `Free` state
|
||||
QueuedMessage::ScalarMessage(_pid, _tid, _reserved, id, arg1, arg2, arg3, arg4) => {
|
||||
QueuedMessage::ScalarMessage(pid, _tid, _reserved, id, arg1, arg2, arg3, arg4) => {
|
||||
sender.pid = PID::new(pid.try_into().unwrap());
|
||||
let msg = xous_kernel::MessageEnvelope {
|
||||
sender,
|
||||
sender: sender.into(),
|
||||
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
|
||||
id,
|
||||
arg1,
|
||||
|
|
@ -579,7 +621,7 @@ impl Server {
|
|||
return Some(msg);
|
||||
}
|
||||
QueuedMessage::BlockingScalarTerminated(
|
||||
_pid,
|
||||
pid,
|
||||
_tid,
|
||||
_reserved,
|
||||
id,
|
||||
|
|
@ -588,8 +630,9 @@ impl Server {
|
|||
arg3,
|
||||
arg4,
|
||||
) => {
|
||||
sender.pid = PID::new(pid.try_into().unwrap());
|
||||
let msg = xous_kernel::MessageEnvelope {
|
||||
sender,
|
||||
sender: sender.into(),
|
||||
body: xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
|
||||
id,
|
||||
arg1,
|
||||
|
|
|
|||
|
|
@ -323,7 +323,8 @@ impl SystemServices {
|
|||
// Set up our handle with a bogus sp and pc. These will get updated
|
||||
// once a context switch _away_ from the kernel occurs, however we need
|
||||
// to make sure other fields such as "thread number" are all valid.
|
||||
ArchProcess::setup_process(PID::new(1).unwrap(), ThreadInit::default()).expect("couldn't setup process");
|
||||
ArchProcess::setup_process(PID::new(1).unwrap(), ThreadInit::default())
|
||||
.expect("couldn't setup process");
|
||||
}
|
||||
|
||||
/// Add a new entry to the process table. This results in a new address space
|
||||
|
|
@ -865,7 +866,7 @@ impl SystemServices {
|
|||
ProcessState::Allocated => {
|
||||
ArchProcess::with_inner_mut(|process_inner| process_inner.pid = new_pid);
|
||||
ProcessState::Running(0)
|
||||
},
|
||||
}
|
||||
ProcessState::Free => panic!("process was suddenly Free"),
|
||||
ProcessState::Ready(x) | ProcessState::Running(x) => {
|
||||
ProcessState::Running(x & !(1 << new_tid))
|
||||
|
|
@ -941,7 +942,7 @@ impl SystemServices {
|
|||
previous_pid, new.state
|
||||
) /*,
|
||||
}*/
|
||||
;
|
||||
;
|
||||
// if advance_thread {
|
||||
// new.current_thread += 1;
|
||||
// if new.current_thread as TID > arch::process::MAX_CONTEXT {
|
||||
|
|
@ -1277,7 +1278,7 @@ impl SystemServices {
|
|||
ProcessState::Allocated => {
|
||||
ArchProcess::with_inner_mut(|process_inner| process_inner.pid = pid);
|
||||
ProcessState::Ready(1 << new_tid)
|
||||
},
|
||||
}
|
||||
|
||||
other => panic!(
|
||||
"error spawning thread: process was in an invalid state {:?}",
|
||||
|
|
@ -1298,7 +1299,11 @@ impl SystemServices {
|
|||
/// queue.
|
||||
/// * **ServerNotFound**: The server queue was full and a free slot could not
|
||||
/// be found.
|
||||
pub fn create_server(&mut self, pid: PID, sid: SID) -> Result<(SID, CID), xous_kernel::Error> {
|
||||
pub fn create_server_with_address(
|
||||
&mut self,
|
||||
pid: PID,
|
||||
sid: SID,
|
||||
) -> Result<(SID, CID), xous_kernel::Error> {
|
||||
// println!(
|
||||
// "KERNEL({}): Looking through server list for free server",
|
||||
// self.pid.get()
|
||||
|
|
@ -1343,6 +1348,39 @@ impl SystemServices {
|
|||
Err(xous_kernel::Error::ServerNotFound)
|
||||
}
|
||||
|
||||
/// Generate a new server ID for this process and then create a new server.
|
||||
/// If the
|
||||
/// server table is full, or if there is not enough memory to map the server queue,
|
||||
/// return an error.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// * **OutOfMemory**: A new page could not be assigned to store the server
|
||||
/// queue.
|
||||
/// * **ServerNotFound**: The server queue was full and a free slot could not
|
||||
/// be found.
|
||||
pub fn create_server(
|
||||
&mut self,
|
||||
pid: PID,
|
||||
) -> Result<(SID, CID), xous_kernel::Error> {
|
||||
let sid = SID::from_u32(arch::rand::get_u32(), arch::rand::get_u32(), arch::rand::get_u32(), arch::rand::get_u32());
|
||||
self.create_server_with_address(pid, sid)
|
||||
}
|
||||
|
||||
/// Connect to a server on behalf of another process.
|
||||
pub fn connect_process_to_server(&mut self, target_pid: PID, sid: SID) -> Result<CID, xous_kernel::Error>{
|
||||
let original_pid = crate::arch::process::current_pid();
|
||||
|
||||
let process = self.get_process_mut(target_pid)?;
|
||||
process.activate()?;
|
||||
|
||||
let result = self.connect_to_server(sid);
|
||||
|
||||
let process = self.get_process_mut(original_pid)?;
|
||||
process.activate().unwrap();
|
||||
|
||||
result
|
||||
}
|
||||
/// Allocate a new server ID for this process and return the address. If the
|
||||
/// server table is full, return an error.
|
||||
pub fn connect_to_server(&mut self, sid: SID) -> Result<CID, xous_kernel::Error> {
|
||||
|
|
@ -1508,28 +1546,6 @@ impl SystemServices {
|
|||
result
|
||||
}
|
||||
|
||||
// /// Obtain the connection ID of the server from within the server process.
|
||||
// pub fn server_cid(&mut self, sidx: usize) -> Result<CID, xous_kernel::Error> {
|
||||
// let current_pid = self.current_pid();
|
||||
// let result = {
|
||||
// let server = self
|
||||
// .server_from_sidx(sidx)
|
||||
// .ok_or(xous_kernel::Error::ServerNotFound)?;
|
||||
// let server_pid = server.pid;
|
||||
// let sid = server.sid;
|
||||
// {
|
||||
// let server_process = self.get_process(server_pid)?;
|
||||
// server_process.mapping.activate().unwrap();
|
||||
// }
|
||||
// self.connect_to_server(sid)
|
||||
// };
|
||||
// let current_process = self
|
||||
// .get_process(current_pid)
|
||||
// .expect("couldn't restore previous process");
|
||||
// current_process.mapping.activate()?;
|
||||
// result
|
||||
// }
|
||||
|
||||
/// Switch to the server's address space and add a "remember this address"
|
||||
/// entry to its server queue, then switch back to the original address space.
|
||||
pub fn remember_server_message(
|
||||
|
|
@ -1552,8 +1568,13 @@ impl SystemServices {
|
|||
.server_from_sidx_mut(sidx)
|
||||
.expect("couldn't re-discover server index");
|
||||
let result = server.queue_response(current_pid, current_thread, message, client_address);
|
||||
let current_process = self.get_process(current_pid).expect("couldn't find old process");
|
||||
current_process.mapping.activate().expect("couldn't switch back to previous address space");
|
||||
let current_process = self
|
||||
.get_process(current_pid)
|
||||
.expect("couldn't find old process");
|
||||
current_process
|
||||
.mapping
|
||||
.activate()
|
||||
.expect("couldn't switch back to previous address space");
|
||||
result
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -147,10 +147,7 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
|
|||
} else {
|
||||
0
|
||||
};
|
||||
let sender = SenderID {
|
||||
sidx,
|
||||
idx: sender_idx,
|
||||
};
|
||||
let sender = SenderID::new(sidx, sender_idx, Some(pid));
|
||||
klog!(
|
||||
"server connection data: sidx: {}, idx: {}, server pid: {}",
|
||||
sidx,
|
||||
|
|
@ -747,8 +744,12 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
|
|||
ss.create_process(process_init)
|
||||
.map(xous_kernel::Result::ProcessID)
|
||||
}),
|
||||
SysCall::CreateServer(name) => SystemServices::with_mut(|ss| {
|
||||
ss.create_server(pid, name)
|
||||
SysCall::CreateServerWithAddress(name) => SystemServices::with_mut(|ss| {
|
||||
ss.create_server_with_address(pid, name)
|
||||
.map(|(sid, cid)| xous_kernel::Result::NewServerID(sid, cid))
|
||||
}),
|
||||
SysCall::CreateServer => SystemServices::with_mut(|ss| {
|
||||
ss.create_server(pid)
|
||||
.map(|(sid, cid)| xous_kernel::Result::NewServerID(sid, cid))
|
||||
}),
|
||||
SysCall::TryConnect(sid) => SystemServices::with_mut(|ss| {
|
||||
|
|
@ -786,6 +787,17 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
|
|||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
SysCall::ConnectForProcess(pid, sid) => {
|
||||
let result = SystemServices::with_mut(|ss| {
|
||||
ss.connect_process_to_server(pid, sid)
|
||||
.map(xous_kernel::Result::ConnectionID)
|
||||
});
|
||||
match result {
|
||||
Ok(o) => Ok(o),
|
||||
Err(xous_kernel::Error::ServerNotFound) => retry_syscall(pid, tid),
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
SysCall::SendMessage(cid, message) => {
|
||||
let result = send_message(pid, tid, cid, message);
|
||||
match result {
|
||||
|
|
|
|||
|
|
@ -118,6 +118,155 @@ fn shutdown() {
|
|||
main_thread.join().expect("couldn't join main thread");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connect_for_process() {
|
||||
use xous_kernel::SID;
|
||||
// Start the server in another thread
|
||||
let main_thread = start_kernel(SERVER_SPEC);
|
||||
let nameserver_addr_bytes = b"nameserver-12345";
|
||||
let nameserver_addr = SID::from_bytes(nameserver_addr_bytes).unwrap();
|
||||
|
||||
let (server_addr_send, server_addr_recv) = channel();
|
||||
let (nameserver_send, nameserver_recv) = channel();
|
||||
|
||||
// Spawn the client "process" and wait for the server address.
|
||||
let nameserver_process = xous_kernel::create_process_as_thread(
|
||||
xous_kernel::ProcessArgsAsThread::new("nameserver_process", move || {
|
||||
let sid = xous_kernel::create_server_with_address(&nameserver_addr_bytes)
|
||||
.expect("couldn't create test server");
|
||||
// Indicate that the nameserver is running
|
||||
nameserver_send.send(()).unwrap();
|
||||
|
||||
// Receive the first message, which is the SID to register
|
||||
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages");
|
||||
let (msg, other_sid) = if let xous_kernel::Message::Scalar(msg) = envelope.body {
|
||||
(
|
||||
msg.id,
|
||||
SID::from_u32(msg.arg1 as _, msg.arg2 as _, msg.arg3 as _, msg.arg4 as _),
|
||||
)
|
||||
} else {
|
||||
panic!("unexpected message")
|
||||
};
|
||||
|
||||
assert!(msg == 1, "unexpected message id");
|
||||
|
||||
// Receive the second message, which is the "name" to "resolve"
|
||||
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages");
|
||||
let msg = if let xous_kernel::Message::BlockingScalar(msg) = envelope.body {
|
||||
msg.id
|
||||
} else {
|
||||
panic!("unexpected message")
|
||||
};
|
||||
assert!(msg == 10, "unexpected message id");
|
||||
|
||||
let new_cid_result =
|
||||
xous_kernel::connect_for_process(envelope.sender.pid().unwrap(), other_sid)
|
||||
.expect("couldn't connect for other process");
|
||||
let new_cid = if let xous_kernel::Result::ConnectionID(c) = new_cid_result {
|
||||
c
|
||||
} else {
|
||||
panic!("Unexpected return value");
|
||||
};
|
||||
xous_kernel::return_scalar(envelope.sender, new_cid).expect("couldn't return scalar");
|
||||
}),
|
||||
)
|
||||
.expect("couldn't spawn client process");
|
||||
|
||||
// Spawn the server "process" (which just lives in a separate thread)
|
||||
// and receive the message. Note that we need to communicate to the
|
||||
// "Client" what our server ID is. Normally this would be done via
|
||||
// an external nameserver.
|
||||
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message server",
|
||||
move || {
|
||||
let sid = xous_kernel::create_server().expect("couldn't create test server");
|
||||
// Wait for nameserver to start
|
||||
nameserver_recv.recv().unwrap();
|
||||
|
||||
let conn =
|
||||
xous_kernel::try_connect(nameserver_addr).expect("couldn't connect to server");
|
||||
// Register our SID with the nameserver
|
||||
let sid_u32 = sid.to_u32();
|
||||
xous_kernel::send_message(
|
||||
conn,
|
||||
xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
|
||||
id: 1,
|
||||
arg1: sid_u32.0 as _,
|
||||
arg2: sid_u32.1 as _,
|
||||
arg3: sid_u32.2 as _,
|
||||
arg4: sid_u32.3 as _,
|
||||
}),
|
||||
)
|
||||
.expect("couldn't send message");
|
||||
|
||||
server_addr_send.send(()).unwrap();
|
||||
|
||||
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages");
|
||||
assert_eq!(
|
||||
envelope.body,
|
||||
xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
|
||||
id: 15,
|
||||
arg1: 21,
|
||||
arg2: 31,
|
||||
arg3: 41,
|
||||
arg4: 51
|
||||
})
|
||||
);
|
||||
},
|
||||
))
|
||||
.expect("couldn't spawn server process");
|
||||
|
||||
// Spawn the client "process" and wait for the server address.
|
||||
let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message client",
|
||||
move || {
|
||||
server_addr_recv.recv().unwrap();
|
||||
let conn =
|
||||
xous_kernel::try_connect(nameserver_addr).expect("couldn't connect to server");
|
||||
|
||||
// Attempt to resolve this address.
|
||||
let other_conn_result = xous_kernel::try_send_message(
|
||||
conn,
|
||||
xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage {
|
||||
id: 10,
|
||||
arg1: 52,
|
||||
arg2: 53,
|
||||
arg3: 54,
|
||||
arg4: 55,
|
||||
}),
|
||||
)
|
||||
.expect("couldn't send message");
|
||||
let other_conn = if let xous_kernel::Result::Scalar1(r) = other_conn_result {
|
||||
r
|
||||
} else {
|
||||
panic!("unexpected return value");
|
||||
};
|
||||
|
||||
// Send a message to the server we were just connected to.
|
||||
xous_kernel::try_send_message(
|
||||
other_conn,
|
||||
xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
|
||||
id: 15,
|
||||
arg1: 21,
|
||||
arg2: 31,
|
||||
arg3: 41,
|
||||
arg4: 51,
|
||||
}),
|
||||
)
|
||||
.expect("couldn't send message");
|
||||
},
|
||||
))
|
||||
.expect("couldn't spawn client process");
|
||||
|
||||
// Wait for both processes to finish
|
||||
crate::wait_process_as_thread(xous_server).expect("couldn't join server process");
|
||||
crate::wait_process_as_thread(xous_client).expect("couldn't join client process");
|
||||
crate::wait_process_as_thread(nameserver_process).expect("couldn't join nameserver process");
|
||||
shutdown_kernel();
|
||||
|
||||
main_thread.join().expect("couldn't join kernel process");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_scalar_message() {
|
||||
// Start the server in another thread
|
||||
|
|
@ -132,8 +281,7 @@ fn send_scalar_message() {
|
|||
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message server",
|
||||
move || {
|
||||
let sid = xous_kernel::create_server(b"send_scalar_mesg")
|
||||
.expect("couldn't create test server");
|
||||
let sid = xous_kernel::create_server().expect("couldn't create test server");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages");
|
||||
assert_eq!(
|
||||
|
|
@ -194,13 +342,14 @@ fn try_receive_message() {
|
|||
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message server",
|
||||
move || {
|
||||
let sid = xous_kernel::create_server(b"send_scalar_mesg")
|
||||
.expect("couldn't create test server");
|
||||
let maybe_envelope = xous_kernel::try_receive_message(sid).expect("couldn't receive messages");
|
||||
let sid = xous_kernel::create_server().expect("couldn't create test server");
|
||||
let maybe_envelope =
|
||||
xous_kernel::try_receive_message(sid).expect("couldn't receive messages");
|
||||
assert!(maybe_envelope.is_none(), "some message came back");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
client_sent_recv.recv().unwrap();
|
||||
let maybe_envelope = xous_kernel::try_receive_message(sid).expect("couldn't receive messages");
|
||||
let maybe_envelope =
|
||||
xous_kernel::try_receive_message(sid).expect("couldn't receive messages");
|
||||
let envelope = maybe_envelope.expect("got None as an envelope");
|
||||
assert_eq!(
|
||||
envelope.body,
|
||||
|
|
@ -233,7 +382,9 @@ fn try_receive_message() {
|
|||
}),
|
||||
)
|
||||
.expect("couldn't send message");
|
||||
client_sent_send.send(()).expect("couldn't notify them we sent a message");
|
||||
client_sent_send
|
||||
.send(())
|
||||
.expect("couldn't notify them we sent a message");
|
||||
},
|
||||
))
|
||||
.expect("couldn't spawn client process");
|
||||
|
|
@ -260,7 +411,7 @@ fn send_blocking_scalar_message() {
|
|||
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message server",
|
||||
move || {
|
||||
let sid = xous_kernel::create_server(b"send_scalar_mesg")
|
||||
let sid = xous_kernel::create_server_with_address(b"send_scalar_mesg")
|
||||
.expect("couldn't create test server");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages");
|
||||
|
|
@ -335,6 +486,123 @@ fn send_blocking_scalar_message() {
|
|||
main_thread.join().expect("couldn't join kernel process");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn message_ordering() {
|
||||
// Start the server in another thread
|
||||
let main_thread = start_kernel(SERVER_SPEC);
|
||||
|
||||
let (server_addr_send, server_addr_recv) = channel();
|
||||
let (server_can_start_send, server_can_start_recv) = channel();
|
||||
let (client_total_send, client_total_recv) = channel();
|
||||
let (server_total_send, server_total_recv) = channel();
|
||||
|
||||
// Spawn the server "process" (which just lives in a separate thread)
|
||||
// and receive the message. Note that we need to communicate to the
|
||||
// "Client" what our server ID is. Normally this would be done via
|
||||
// an external nameserver.
|
||||
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message server",
|
||||
move || {
|
||||
let sid = xous_kernel::create_server_with_address(b"send_scalar_mesg")
|
||||
.expect("couldn't create test server");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
// Sync point waiting to start receiving.
|
||||
server_can_start_recv.recv().unwrap();
|
||||
|
||||
let mut queue_length = 1;
|
||||
// Keep receiving messages until we get a BlockingScalar message
|
||||
loop {
|
||||
let envelope =
|
||||
xous_kernel::receive_message(sid).expect("couldn't receive messages");
|
||||
match envelope.body {
|
||||
xous_kernel::Message::Scalar(sm) => {
|
||||
assert_eq!(sm.id, queue_length, "messages were not ordered");
|
||||
queue_length += 1;
|
||||
}
|
||||
xous_kernel::Message::BlockingScalar(sm) => {
|
||||
assert_eq!(sm.id, queue_length, "blocking message were not ordered");
|
||||
// The BlockingScalar has exceeded the queue length, so subtract
|
||||
// 1 from the running total.
|
||||
queue_length -= 1;
|
||||
xous_kernel::return_scalar(envelope.sender, queue_length)
|
||||
.expect("couldn't return scalar");
|
||||
break;
|
||||
}
|
||||
_ => panic!("unexpected message received"),
|
||||
}
|
||||
}
|
||||
|
||||
// Return the total number of messages we've seen to the parent
|
||||
server_total_send.send(queue_length).unwrap();
|
||||
},
|
||||
))
|
||||
.expect("couldn't spawn server process");
|
||||
|
||||
// Spawn the client "process" and wait for the server address.
|
||||
let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message client",
|
||||
move || {
|
||||
let sid = server_addr_recv.recv().unwrap();
|
||||
let conn = xous_kernel::try_connect(sid).expect("couldn't connect to server");
|
||||
|
||||
// Determine the length of the kernel queue.
|
||||
let mut queue_length = 0;
|
||||
for i in 1.. {
|
||||
if xous_kernel::try_send_message(
|
||||
conn,
|
||||
xous_kernel::Message::Scalar(xous_kernel::ScalarMessage {
|
||||
id: i,
|
||||
arg1: 0,
|
||||
arg2: 0,
|
||||
arg3: 0,
|
||||
arg4: 0,
|
||||
}),
|
||||
)
|
||||
.is_err()
|
||||
{
|
||||
break;
|
||||
}
|
||||
queue_length += 1;
|
||||
}
|
||||
|
||||
// Let the server process messages
|
||||
server_can_start_send.send(()).ok();
|
||||
|
||||
// Send one more message, but make it blocking. This acts as a sentinal
|
||||
// value to let the kernel know things are done.
|
||||
xous_kernel::send_message(
|
||||
conn,
|
||||
xous_kernel::Message::BlockingScalar(xous_kernel::ScalarMessage {
|
||||
id: queue_length + 1,
|
||||
arg1: 0,
|
||||
arg2: 0,
|
||||
arg3: 0,
|
||||
arg4: 0,
|
||||
}),
|
||||
)
|
||||
.expect("couldn't send message");
|
||||
|
||||
// Report the number of messages to the main thread.
|
||||
client_total_send.send(queue_length).unwrap();
|
||||
},
|
||||
))
|
||||
.expect("couldn't spawn client process");
|
||||
|
||||
let server_total = server_total_recv.recv().unwrap();
|
||||
let client_total = client_total_recv.recv().unwrap();
|
||||
|
||||
// Wait for both processes to finish
|
||||
crate::wait_process_as_thread(xous_server).expect("couldn't join server process");
|
||||
crate::wait_process_as_thread(xous_client).expect("couldn't join client process");
|
||||
shutdown_kernel();
|
||||
assert_eq!(
|
||||
client_total, server_total,
|
||||
"client and server processed a different number of messages"
|
||||
);
|
||||
|
||||
main_thread.join().expect("couldn't join kernel process");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn send_interleved_blocking_scalar_message() {
|
||||
// Start the server in another thread
|
||||
|
|
@ -349,7 +617,7 @@ fn send_interleved_blocking_scalar_message() {
|
|||
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message server",
|
||||
move || {
|
||||
let sid = xous_kernel::create_server(b"send_scalar_mesg")
|
||||
let sid = xous_kernel::create_server_with_address(b"send_scalar_mesg")
|
||||
.expect("couldn't create test server");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
|
||||
|
|
@ -376,9 +644,8 @@ fn send_interleved_blocking_scalar_message() {
|
|||
|
||||
// Spawn the client "process" and wait for the server address. This one will have
|
||||
// 1 added to the `id` field.
|
||||
let xous_client_1 = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message client 1",
|
||||
move || {
|
||||
let xous_client_1 = xous_kernel::create_process_as_thread(
|
||||
xous_kernel::ProcessArgsAsThread::new("send_scalar_message client 1", move || {
|
||||
let conn = xous_kernel::try_connect(sid_client_1).expect("couldn't connect to server");
|
||||
let result = xous_kernel::try_send_message(
|
||||
conn,
|
||||
|
|
@ -392,15 +659,14 @@ fn send_interleved_blocking_scalar_message() {
|
|||
)
|
||||
.expect("couldn't send message");
|
||||
assert_eq!(result, xous_kernel::Result::Scalar1(2));
|
||||
},
|
||||
))
|
||||
}),
|
||||
)
|
||||
.expect("couldn't spawn client 1 process");
|
||||
|
||||
// Spawn the client "process" and wait for the server address. This one
|
||||
// will have `10` added to the value when it is returned.
|
||||
let xous_client_2 = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_scalar_message client 2",
|
||||
move || {
|
||||
let xous_client_2 = xous_kernel::create_process_as_thread(
|
||||
xous_kernel::ProcessArgsAsThread::new("send_scalar_message client 2", move || {
|
||||
let conn = xous_kernel::try_connect(sid_client_2).expect("couldn't connect to server");
|
||||
let result = xous_kernel::try_send_message(
|
||||
conn,
|
||||
|
|
@ -414,8 +680,8 @@ fn send_interleved_blocking_scalar_message() {
|
|||
)
|
||||
.expect("couldn't send message");
|
||||
assert_eq!(result, xous_kernel::Result::Scalar1(20));
|
||||
},
|
||||
))
|
||||
}),
|
||||
)
|
||||
.expect("couldn't spawn client 2 process");
|
||||
|
||||
// Wait for both processes to finish
|
||||
|
|
@ -440,7 +706,7 @@ fn send_move_message() {
|
|||
"send_move_message server",
|
||||
move || {
|
||||
// println!("SERVER: Creating server...");
|
||||
let sid = xous_kernel::create_server(b"send_move_messag")
|
||||
let sid = xous_kernel::create_server_with_address(b"send_move_messag")
|
||||
.expect("couldn't create test server");
|
||||
// println!("SERVER: Sending server address of {:?} to client", sid);
|
||||
server_addr_send.send(sid).unwrap();
|
||||
|
|
@ -498,7 +764,7 @@ fn send_borrow_message() {
|
|||
move || {
|
||||
{
|
||||
// println!("SERVER: Creating server...");
|
||||
let sid = xous_kernel::create_server(b"send_borrow_mesg")
|
||||
let sid = xous_kernel::create_server_with_address(b"send_borrow_mesg")
|
||||
.expect("couldn't create test server");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
// println!("SERVER: Receiving message...");
|
||||
|
|
@ -575,14 +841,15 @@ fn send_mutableborrow_message() {
|
|||
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_mutableborrow_message server",
|
||||
move || {
|
||||
let sid = xous_kernel::create_server(b"send_mutborrow_m")
|
||||
let sid = xous_kernel::create_server_with_address(b"send_mutborrow_m")
|
||||
.expect("couldn't create test server");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
let envelope = xous_kernel::receive_message(sid).expect("couldn't receive messages");
|
||||
// println!("Received message from {}", envelope.sender);
|
||||
let message = envelope.body;
|
||||
if let xous_kernel::Message::MutableBorrow(m) = message {
|
||||
let bt = unsafe { core::slice::from_raw_parts_mut(m.buf.as_mut_ptr(), m.buf.len()) };
|
||||
let bt =
|
||||
unsafe { core::slice::from_raw_parts_mut(m.buf.as_mut_ptr(), m.buf.len()) };
|
||||
// eprintln!("SERVER: UPDATING VALUES");
|
||||
for letter in bt.iter_mut() {
|
||||
*letter += 1;
|
||||
|
|
@ -645,7 +912,7 @@ fn send_repeat_mutableborrow_message() {
|
|||
let xous_server = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new(
|
||||
"send_mutableborrow_message_repeat server",
|
||||
move || {
|
||||
let sid = xous_kernel::create_server(b"send_mutborrow_r")
|
||||
let sid = xous_kernel::create_server_with_address(b"send_mutborrow_r")
|
||||
.expect("couldn't create test server");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
|
||||
|
|
@ -744,8 +1011,7 @@ fn server_client_same_process() {
|
|||
|
||||
let internal_server = xous_kernel::create_process_as_thread(
|
||||
xous_kernel::arch::ProcessArgsAsThread::new("server_client_same_process process", || {
|
||||
let server =
|
||||
xous_kernel::create_server(b"s_c_same_process").expect("couldn't create server");
|
||||
let server = xous_kernel::create_server().expect("couldn't create server");
|
||||
let connection =
|
||||
xous_kernel::try_connect(server).expect("couldn't connect to our own server");
|
||||
let msg_contents = xous_kernel::ScalarMessage {
|
||||
|
|
@ -784,8 +1050,7 @@ fn multiple_contexts() {
|
|||
|
||||
let internal_server = xous_kernel::create_process_as_thread(
|
||||
xous_kernel::ProcessArgsAsThread::new("multiple_contexts process", move || {
|
||||
let server =
|
||||
xous_kernel::create_server(b"multiple_context").expect("couldn't create server");
|
||||
let server = xous_kernel::create_server().expect("couldn't create server");
|
||||
let connection =
|
||||
xous_kernel::try_connect(server).expect("couldn't connect to our own server");
|
||||
let msg_contents = xous_kernel::ScalarMessage {
|
||||
|
|
@ -851,7 +1116,7 @@ fn process_restart_server() {
|
|||
|
||||
let xous_server = xous_kernel::create_process_as_thread(
|
||||
xous_kernel::ProcessArgsAsThread::new("process_restart_server server", move || {
|
||||
let sid = xous_kernel::create_server(b"test_recreate_se")
|
||||
let sid = xous_kernel::create_server_with_address(b"test_recreate_se")
|
||||
.expect("couldn't create test server");
|
||||
server_addr_send.send(sid).unwrap();
|
||||
let thr = xous_kernel::create_thread(move || {
|
||||
|
|
|
|||
|
|
@ -91,13 +91,13 @@ test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
|
|||
## Contribution Guidelines
|
||||
|
||||
[](CODE_OF_CONDUCT.md)
|
||||
Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](../CODE_OF_CONDUCT.md)
|
||||
|
||||
Please see [CONTRIBUTING](CONTRIBUTING.md) for details on how to make a
|
||||
Please see [CONTRIBUTING](../CONTRIBUTING.md) for details on how to make a
|
||||
contribution.
|
||||
|
||||
Please note that this project is released with a [Contributor Code of
|
||||
Conduct](CODE_OF_CONDUCT.md). By participating in this project you agree
|
||||
Conduct](../CODE_OF_CONDUCT.md). By participating in this project you agree
|
||||
to abide its terms.
|
||||
|
||||
## License
|
||||
|
|
|
|||
|
|
@ -217,7 +217,7 @@ fn xmain() -> ! {
|
|||
log_server::init_wait().unwrap();
|
||||
|
||||
let com_server =
|
||||
xous::create_server(b"com ").expect("Couldn't create COM server");
|
||||
xous::create_server_with_address(b"com ").expect("Couldn't create COM server");
|
||||
|
||||
let shell_id = xous::SID::from_bytes(b"shell ").unwrap();
|
||||
let shell_conn = xous::connect(shell_id).unwrap();
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ fn xmain() -> ! {
|
|||
|
||||
display.redraw();
|
||||
|
||||
let sid = xous::create_server(b"graphics-server ").unwrap();
|
||||
let sid = xous::create_server_with_address(b"graphics-server ").unwrap();
|
||||
// info!("GFX: Server listening on address {:?}", sid);
|
||||
// ::debug_here::debug_here!();
|
||||
loop {
|
||||
|
|
|
|||
|
|
@ -216,7 +216,7 @@ fn reader_thread(mut output: implementation::OutputWriter) {
|
|||
writeln!(output, "LOG: Xous Logging Server starting up...").unwrap();
|
||||
|
||||
writeln!(output, "LOG: Starting log server...").unwrap();
|
||||
let server_addr = xous::create_server(b"xous-log-server ").unwrap();
|
||||
let server_addr = xous::create_server_with_address(b"xous-log-server ").unwrap();
|
||||
writeln!(output, "LOG: Server listening on address {:?}", server_addr).unwrap();
|
||||
|
||||
let mut counter: usize = 0;
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ static BATT_STATS_REMAINING: AtomicU16 = AtomicU16::new(750);
|
|||
|
||||
fn com_thread(_arg: Option<u32>) {
|
||||
let shell_server =
|
||||
xous::create_server(b"shell ").expect("Couldn't create Shell server");
|
||||
xous::create_server_with_address(b"shell ").expect("Couldn't create Shell server");
|
||||
info!("SHELL|com_thread: starting COM response handler thread");
|
||||
loop {
|
||||
let envelope =
|
||||
|
|
|
|||
|
|
@ -271,7 +271,7 @@ fn xmain() -> ! {
|
|||
let mut sleep_heap: BinaryHeap<SleepResponse, U32, Min> = BinaryHeap::new();
|
||||
|
||||
let ticktimer_server =
|
||||
xous::create_server(b"ticktimer-server").expect("Couldn't create Ticktimer server");
|
||||
xous::create_server_with_address(b"ticktimer-server").expect("Couldn't create Ticktimer server");
|
||||
|
||||
// Connect to our own server so we can send the "Recalculate" message
|
||||
let ticktimer_client = xous::connect(xous::SID::from_bytes(b"ticktimer-server").unwrap())
|
||||
|
|
|
|||
|
|
@ -76,13 +76,13 @@ _TBD_
|
|||
|
||||
## Contribution Guidelines
|
||||
|
||||
[](CODE_OF_CONDUCT.md)
|
||||
[](../CODE_OF_CONDUCT.md)
|
||||
|
||||
Please see [CONTRIBUTING](CONTRIBUTING.md) for details on
|
||||
Please see [CONTRIBUTING](../CONTRIBUTING.md) for details on
|
||||
how to make a contribution.
|
||||
|
||||
Please note that this project is released with a
|
||||
[Contributor Code of Conduct](CODE_OF_CONDUCT.md).
|
||||
[Contributor Code of Conduct](../CODE_OF_CONDUCT.md).
|
||||
By participating in this project you agree to abide its terms.
|
||||
|
||||
## License
|
||||
|
|
|
|||
|
|
@ -396,6 +396,7 @@ fn xous_connect_impl(
|
|||
match TcpStream::connect(addr) {
|
||||
Ok(mut conn) => {
|
||||
conn.write_all(&key.0).unwrap(); // Send key to authenticate us as PID 1
|
||||
conn.flush().unwrap();
|
||||
Ok(ServerConnection {
|
||||
send: Arc::new(Mutex::new(conn.try_clone().unwrap())),
|
||||
recv: Arc::new(Mutex::new(conn)),
|
||||
|
|
@ -678,4 +679,5 @@ fn _xous_syscall_to(
|
|||
eprintln!("Server shut down: {}", e);
|
||||
std::process::exit(0);
|
||||
}
|
||||
xsc.flush().unwrap();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,9 +7,40 @@ pub type StackPointer = usize;
|
|||
pub type MessageId = usize;
|
||||
|
||||
pub type PID = NonZeroU8;
|
||||
pub type MessageSender = usize;
|
||||
pub type Connection = usize;
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Ord, PartialOrd, Copy, Clone)]
|
||||
pub struct MessageSender {
|
||||
data: usize,
|
||||
}
|
||||
|
||||
impl MessageSender {
|
||||
pub fn to_usize(&self) -> usize {
|
||||
self.data
|
||||
}
|
||||
|
||||
pub fn from_usize(data: usize) -> Self {
|
||||
MessageSender { data }
|
||||
}
|
||||
|
||||
pub fn pid(&self) -> Option<PID> {
|
||||
let pid_u8 = ((self.data >> 24) & 0xff) as u8;
|
||||
PID::new(pid_u8)
|
||||
}
|
||||
}
|
||||
|
||||
impl core::default::Default for MessageSender {
|
||||
fn default() -> Self {
|
||||
MessageSender { data: 0 }
|
||||
}
|
||||
}
|
||||
|
||||
impl core::fmt::Display for MessageSender {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
||||
write!(f, "data: {}", self.data)
|
||||
}
|
||||
}
|
||||
|
||||
/// Server ID
|
||||
#[derive(Debug, Copy, Clone, PartialEq)]
|
||||
pub struct SID((u32, u32, u32, u32));
|
||||
|
|
@ -343,7 +374,7 @@ impl MessageEnvelope {
|
|||
Message::BlockingScalar(m) => (4, m.to_usize()),
|
||||
};
|
||||
[
|
||||
self.sender,
|
||||
self.sender.to_usize(),
|
||||
ret.0,
|
||||
ret.1[0],
|
||||
ret.1[1],
|
||||
|
|
@ -574,7 +605,7 @@ impl Result {
|
|||
_ => return Result::Error(Error::InternalError),
|
||||
};
|
||||
Result::Message(MessageEnvelope {
|
||||
sender,
|
||||
sender: MessageSender::from_usize(sender),
|
||||
body: message,
|
||||
})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -210,24 +210,23 @@ pub enum SysCall {
|
|||
/// Get a list of contexts that can be run in the given PID.
|
||||
ReadyThreads(PID),
|
||||
|
||||
/// Create a new Server
|
||||
/// Create a new Server with a specified address
|
||||
///
|
||||
/// This will return a 128-bit Server ID that can be used to send messages
|
||||
/// to this server. This ID will be unique per process. You may specify an
|
||||
/// additional `usize` value to make the ID unique. This value will be
|
||||
/// mixed in with the random value.
|
||||
/// to this server, as well as a connection ID. This connection ID will be
|
||||
/// unique per process, while the server ID is available globally.
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// The ServerId can be assembled to form a 128-bit server ID in native byte
|
||||
/// order.
|
||||
/// The specified SID, along with the connection ID for this process to talk
|
||||
/// to the server.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// * **OutOfMemory**: The server table was full and a new server couldn't
|
||||
/// be created.
|
||||
/// * **ServerExists**: The server hash is already in use.
|
||||
CreateServer(SID /* server hash */),
|
||||
CreateServerWithAddress(SID /* server hash */),
|
||||
|
||||
/// Connect to a server. This turns a 128-bit Serever ID into a 32-bit
|
||||
/// Connection ID. Blocks until the server is available.
|
||||
|
|
@ -273,6 +272,27 @@ pub enum SysCall {
|
|||
/// Shut down the entire system
|
||||
Shutdown,
|
||||
|
||||
/// Create a new Server
|
||||
///
|
||||
/// This will return a 128-bit Server ID that can be used to send messages
|
||||
/// to this server. The returned Derver ID is random.
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// The SID, along with a Connection ID that can be used to immediately
|
||||
/// communicate with this process.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// * **OutOfMemory**: The server table was full and a new server couldn't
|
||||
/// be created.
|
||||
CreateServer,
|
||||
|
||||
/// Establish a connection in the given process to the given server. This
|
||||
/// call can be used by a nameserver to make server connections without
|
||||
/// disclosing SIDs.
|
||||
ConnectForProcess(PID, SID),
|
||||
|
||||
/// This syscall does not exist. It captures all possible
|
||||
/// arguments so detailed analysis can be performed.
|
||||
Invalid(usize, usize, usize, usize, usize, usize, usize),
|
||||
|
|
@ -292,7 +312,7 @@ pub enum SysCallNumber {
|
|||
DecreaseHeap = 11,
|
||||
UpdateMemoryFlags = 12,
|
||||
SetMemRegion = 13,
|
||||
CreateServer = 14,
|
||||
CreateServerWithAddress = 14,
|
||||
ReceiveMessage = 15,
|
||||
SendMessage = 16,
|
||||
Connect = 17,
|
||||
|
|
@ -307,6 +327,8 @@ pub enum SysCallNumber {
|
|||
ReturnScalar1 = 26,
|
||||
ReturnScalar2 = 27,
|
||||
TryReceiveMessage = 28,
|
||||
CreateServer = 29,
|
||||
ConnectForProcess = 30,
|
||||
Invalid,
|
||||
}
|
||||
|
||||
|
|
@ -326,7 +348,7 @@ impl SysCallNumber {
|
|||
11 => DecreaseHeap,
|
||||
12 => UpdateMemoryFlags,
|
||||
13 => SetMemRegion,
|
||||
14 => CreateServer,
|
||||
14 => CreateServerWithAddress,
|
||||
15 => ReceiveMessage,
|
||||
16 => SendMessage,
|
||||
17 => Connect,
|
||||
|
|
@ -341,6 +363,8 @@ impl SysCallNumber {
|
|||
26 => ReturnScalar1,
|
||||
27 => ReturnScalar2,
|
||||
28 => TryReceiveMessage,
|
||||
29 => CreateServer,
|
||||
30 => ConnectForProcess,
|
||||
_ => Invalid,
|
||||
}
|
||||
}
|
||||
|
|
@ -406,6 +430,19 @@ impl SysCall {
|
|||
0,
|
||||
]
|
||||
}
|
||||
SysCall::ConnectForProcess(pid, sid) => {
|
||||
let s = sid.to_u32();
|
||||
[
|
||||
SysCallNumber::ConnectForProcess as usize,
|
||||
pid.get() as _,
|
||||
s.0 as _,
|
||||
s.1 as _,
|
||||
s.2 as _,
|
||||
s.3 as _,
|
||||
0,
|
||||
0,
|
||||
]
|
||||
}
|
||||
SysCall::ReturnToParent(a1, a2) => [
|
||||
SysCallNumber::ReturnToParent as usize,
|
||||
a1.get() as usize,
|
||||
|
|
@ -490,10 +527,10 @@ impl SysCall {
|
|||
0,
|
||||
],
|
||||
|
||||
SysCall::CreateServer(sid) => {
|
||||
SysCall::CreateServerWithAddress(sid) => {
|
||||
let s = sid.to_u32();
|
||||
[
|
||||
SysCallNumber::CreateServer as usize,
|
||||
SysCallNumber::CreateServerWithAddress as usize,
|
||||
s.0 as _,
|
||||
s.1 as _,
|
||||
s.2 as _,
|
||||
|
|
@ -503,6 +540,7 @@ impl SysCall {
|
|||
0,
|
||||
]
|
||||
}
|
||||
SysCall::CreateServer => [SysCallNumber::CreateServer as usize, 0, 0, 0, 0, 0, 0, 0],
|
||||
SysCall::Connect(sid) => {
|
||||
let s = sid.to_u32();
|
||||
[
|
||||
|
|
@ -540,7 +578,7 @@ impl SysCall {
|
|||
},
|
||||
SysCall::ReturnMemory(sender, buf) => [
|
||||
SysCallNumber::ReturnMemory as usize,
|
||||
*sender,
|
||||
sender.to_usize(),
|
||||
buf.as_ptr() as usize,
|
||||
buf.len(),
|
||||
0,
|
||||
|
|
@ -602,7 +640,7 @@ impl SysCall {
|
|||
},
|
||||
SysCall::ReturnScalar1(sender, arg1) => [
|
||||
SysCallNumber::ReturnScalar1 as usize,
|
||||
*sender,
|
||||
sender.to_usize(),
|
||||
*arg1,
|
||||
0,
|
||||
0,
|
||||
|
|
@ -612,7 +650,7 @@ impl SysCall {
|
|||
],
|
||||
SysCall::ReturnScalar2(sender, arg1, arg2) => [
|
||||
SysCallNumber::ReturnScalar2 as usize,
|
||||
*sender,
|
||||
sender.to_usize(),
|
||||
*arg1,
|
||||
*arg2,
|
||||
0,
|
||||
|
|
@ -687,9 +725,10 @@ impl SysCall {
|
|||
MemoryAddress::new(a3).ok_or(Error::InvalidSyscall)?,
|
||||
a4,
|
||||
),
|
||||
SysCallNumber::CreateServer => {
|
||||
SysCall::CreateServer(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
|
||||
SysCallNumber::CreateServerWithAddress => {
|
||||
SysCall::CreateServerWithAddress(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
|
||||
}
|
||||
SysCallNumber::CreateServer => SysCall::CreateServer,
|
||||
SysCallNumber::Connect => {
|
||||
SysCall::Connect(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
|
||||
}
|
||||
|
|
@ -743,7 +782,9 @@ impl SysCall {
|
|||
),
|
||||
_ => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
|
||||
},
|
||||
SysCallNumber::ReturnMemory => SysCall::ReturnMemory(a1, MemoryRange::new(a2, a3)?),
|
||||
SysCallNumber::ReturnMemory => {
|
||||
SysCall::ReturnMemory(MessageSender::from_usize(a1), MemoryRange::new(a2, a3)?)
|
||||
}
|
||||
SysCallNumber::CreateThread => {
|
||||
SysCall::CreateThread(crate::arch::args_to_thread(a1, a2, a3, a4, a5, a6, a7)?)
|
||||
}
|
||||
|
|
@ -805,8 +846,16 @@ impl SysCall {
|
|||
),
|
||||
_ => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
|
||||
},
|
||||
SysCallNumber::ReturnScalar1 => SysCall::ReturnScalar1(a1, a2),
|
||||
SysCallNumber::ReturnScalar2 => SysCall::ReturnScalar2(a1, a2, a3),
|
||||
SysCallNumber::ReturnScalar1 => {
|
||||
SysCall::ReturnScalar1(MessageSender::from_usize(a1), a2)
|
||||
}
|
||||
SysCallNumber::ReturnScalar2 => {
|
||||
SysCall::ReturnScalar2(MessageSender::from_usize(a1), a2, a3)
|
||||
}
|
||||
SysCallNumber::ConnectForProcess => SysCall::ConnectForProcess(
|
||||
PID::new(a1 as _).ok_or(Error::InvalidSyscall)?,
|
||||
SID::from_u32(a2 as _, a3 as _, a4 as _, a5 as _),
|
||||
),
|
||||
SysCallNumber::Invalid => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
|
||||
})
|
||||
}
|
||||
|
|
@ -1020,12 +1069,32 @@ pub fn claim_interrupt(
|
|||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// * **OutOfMemory**: No more servers may be created
|
||||
/// * **ServerExists**: A server has already registered with that name
|
||||
/// * **InvalidString**: The name was not a valid UTF-8 string
|
||||
pub fn create_server(name_bytes: &[u8; 16]) -> core::result::Result<SID, Error> {
|
||||
pub fn create_server_with_address(name_bytes: &[u8; 16]) -> core::result::Result<SID, Error> {
|
||||
let sid = SID::from_bytes(name_bytes).ok_or(Error::InvalidString)?;
|
||||
|
||||
let result = rsyscall(SysCall::CreateServer(sid))?;
|
||||
let result = rsyscall(SysCall::CreateServerWithAddress(sid))?;
|
||||
if let Result::NewServerID(sid, _cid) = result {
|
||||
Ok(sid)
|
||||
} else if let Result::Error(e) = result {
|
||||
Err(e)
|
||||
} else {
|
||||
Err(Error::InternalError)
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new server with a random name. This enables other processes to
|
||||
/// connect to this server to send messages. A random server ID is generated
|
||||
/// by the kernel and returned to the caller. This address can then be registered
|
||||
/// to a namserver.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// * **OutOfMemory**: No more servers may be created
|
||||
pub fn create_server() -> core::result::Result<SID, Error> {
|
||||
let result = rsyscall(SysCall::CreateServer)?;
|
||||
if let Result::NewServerID(sid, _cid) = result {
|
||||
Ok(sid)
|
||||
} else if let Result::Error(e) = result {
|
||||
|
|
@ -1081,7 +1150,8 @@ pub fn receive_message(server: SID) -> core::result::Result<MessageEnvelope, Err
|
|||
/// # Errors
|
||||
///
|
||||
pub fn try_receive_message(server: SID) -> core::result::Result<Option<MessageEnvelope>, Error> {
|
||||
let result = rsyscall(SysCall::TryReceiveMessage(server)).expect("Couldn't call ReceiveMessage");
|
||||
let result =
|
||||
rsyscall(SysCall::TryReceiveMessage(server)).expect("Couldn't call ReceiveMessage");
|
||||
if let Result::Message(envelope) = result {
|
||||
Ok(Some(envelope))
|
||||
} else if result == Result::None {
|
||||
|
|
@ -1115,6 +1185,24 @@ pub fn try_send_message(connection: CID, message: Message) -> core::result::Resu
|
|||
}
|
||||
}
|
||||
|
||||
/// Connect to a server on behalf of another process. This can be used by a name
|
||||
/// resolution server to securely create connections without disclosing a SID.
|
||||
///
|
||||
/// # Errors
|
||||
///
|
||||
/// * **ServerNotFound**: The server does not exist so the connection is now invalid
|
||||
/// * **BadAddress**: The client tried to pass a Memory message using an address it doesn't own
|
||||
/// * **ServerQueueFull**: The queue in the server is full, and this call would block
|
||||
/// * **Timeout**: The timeout limit has been reached
|
||||
pub fn connect_for_process(pid: PID, sid: SID) -> core::result::Result<Result, Error> {
|
||||
let result = rsyscall(SysCall::ConnectForProcess(pid, sid));
|
||||
match result {
|
||||
Ok(Result::ConnectionID(cid)) => Ok(Result::ConnectionID(cid)),
|
||||
Err(e) => Err(e),
|
||||
v => panic!("Unexpected return value: {:?}", v),
|
||||
}
|
||||
}
|
||||
|
||||
/// Send a message to a server. Depending on the mesage type (move or borrow), it
|
||||
/// will either block (borrow) or return immediately (move).
|
||||
/// If the message type is `borrow`, then the memory addresses pointed to will be
|
||||
|
|
|
|||
Loading…
Reference in a new issue