Merge remote-tracking branch 'betrusted/master' into hardware

This commit is contained in:
bunnie 2020-12-12 12:58:06 +08:00
commit 95719852b3
20 changed files with 688 additions and 201 deletions

View file

@ -28,13 +28,13 @@ _TBD_
## Contribution Guidelines
[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](CODE_OF_CONDUCT.md)
[![Contributor 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
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

View file

@ -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);
}

View file

@ -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(())
}

View file

@ -0,0 +1,3 @@
pub fn get_u32() -> u32 {
::rand::random()
}

View file

@ -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;

View 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
}
}

View file

@ -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,

View file

@ -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
}

View file

@ -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 {

View file

@ -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 || {

View file

@ -91,13 +91,13 @@ test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
## Contribution Guidelines
[![Contributor
Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](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

View file

@ -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();

View file

@ -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 {

View file

@ -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;

View file

@ -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 =

View file

@ -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())

View file

@ -76,13 +76,13 @@ _TBD_
## Contribution Guidelines
[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](CODE_OF_CONDUCT.md)
[![Contributor 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
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

View file

@ -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();
}

View file

@ -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,
})
}

View file

@ -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