diff --git a/kernel/README.md b/kernel/README.md index 2a28196f3..b7a81b677 100644 --- a/kernel/README.md +++ b/kernel/README.md @@ -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 diff --git a/kernel/src/arch/hosted.rs b/kernel/src/arch/hosted.rs index f12efd24d..e6a46be1e 100644 --- a/kernel/src/arch/hosted.rs +++ b/kernel/src/arch/hosted.rs @@ -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) { #[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); } diff --git a/kernel/src/arch/hosted/process.rs b/kernel/src/arch/hosted/process.rs index d622b42f5..5dd50793f 100644 --- a/kernel/src/arch/hosted/process.rs +++ b/kernel/src/arch/hosted/process.rs @@ -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(()) } diff --git a/kernel/src/arch/hosted/rand.rs b/kernel/src/arch/hosted/rand.rs new file mode 100644 index 000000000..b5cdd3c46 --- /dev/null +++ b/kernel/src/arch/hosted/rand.rs @@ -0,0 +1,3 @@ +pub fn get_u32() -> u32 { + ::rand::random() +} diff --git a/kernel/src/arch/riscv.rs b/kernel/src/arch/riscv.rs index 9ecce8508..ebbcdc08e 100644 --- a/kernel/src/arch/riscv.rs +++ b/kernel/src/arch/riscv.rs @@ -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; diff --git a/kernel/src/arch/riscv/rand.rs b/kernel/src/arch/riscv/rand.rs new file mode 100644 index 000000000..17be78d44 --- /dev/null +++ b/kernel/src/arch/riscv/rand.rs @@ -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 + } +} diff --git a/kernel/src/server.rs b/kernel/src/server.rs index a10b63fa3..3d64924ce 100644 --- a/kernel/src/server.rs +++ b/kernel/src/server.rs @@ -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, +} + +impl SenderID { + pub fn new(sidx: usize, idx: usize, pid: Option) -> Self { + SenderID { sidx, idx, pid } + } } impl From 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 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 for SenderID { + fn from(item: MessageSender) -> SenderID { + SenderID::from(item.to_usize()) + } +} + +impl Into for SenderID { + fn into(self) -> MessageSender { + MessageSender::from_usize(self.into()) } } @@ -333,12 +356,12 @@ impl Server { idx: usize, buf: Option<&MemoryRange>, ) -> Result { - 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 { // 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, diff --git a/kernel/src/services.rs b/kernel/src/services.rs index 300a6c3a1..9c74f3daa 100644 --- a/kernel/src/services.rs +++ b/kernel/src/services.rs @@ -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{ + 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 { @@ -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 { - // 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 } diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index 3d7a36ae8..dca955cb0 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -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 { diff --git a/kernel/src/test.rs b/kernel/src/test.rs index cac764ba4..4fe4d8685 100644 --- a/kernel/src/test.rs +++ b/kernel/src/test.rs @@ -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 || { diff --git a/loader/README.md b/loader/README.md index 2f9372341..c17137e17 100644 --- a/loader/README.md +++ b/loader/README.md @@ -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 diff --git a/services/com/src/main.rs b/services/com/src/main.rs index 52d30aaaf..c0649c279 100644 --- a/services/com/src/main.rs +++ b/services/com/src/main.rs @@ -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(); diff --git a/services/graphics-server/src/main.rs b/services/graphics-server/src/main.rs index f9df4d911..e51318f25 100644 --- a/services/graphics-server/src/main.rs +++ b/services/graphics-server/src/main.rs @@ -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 { diff --git a/services/log-server/src/main.rs b/services/log-server/src/main.rs index 81ff23fb1..563920453 100644 --- a/services/log-server/src/main.rs +++ b/services/log-server/src/main.rs @@ -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; diff --git a/services/shell/src/main.rs b/services/shell/src/main.rs index ffcd04efd..d3a2b303b 100644 --- a/services/shell/src/main.rs +++ b/services/shell/src/main.rs @@ -106,7 +106,7 @@ static BATT_STATS_REMAINING: AtomicU16 = AtomicU16::new(750); fn com_thread(_arg: Option) { 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 = diff --git a/services/ticktimer-server/src/main.rs b/services/ticktimer-server/src/main.rs index 469fbd673..54302e4f9 100644 --- a/services/ticktimer-server/src/main.rs +++ b/services/ticktimer-server/src/main.rs @@ -271,7 +271,7 @@ fn xmain() -> ! { let mut sleep_heap: BinaryHeap = 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()) diff --git a/tools/README.md b/tools/README.md index 2697765a0..475d7a3a4 100644 --- a/tools/README.md +++ b/tools/README.md @@ -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 diff --git a/xous-rs/src/arch/hosted.rs b/xous-rs/src/arch/hosted.rs index 88530efef..cfd70a7e0 100644 --- a/xous-rs/src/arch/hosted.rs +++ b/xous-rs/src/arch/hosted.rs @@ -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(); } diff --git a/xous-rs/src/definitions.rs b/xous-rs/src/definitions.rs index d3796c65b..9beab6503 100644 --- a/xous-rs/src/definitions.rs +++ b/xous-rs/src/definitions.rs @@ -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 { + 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, }) } diff --git a/xous-rs/src/syscall.rs b/xous-rs/src/syscall.rs index 1c5787e90..f59ccbb24 100644 --- a/xous-rs/src/syscall.rs +++ b/xous-rs/src/syscall.rs @@ -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 { +pub fn create_server_with_address(name_bytes: &[u8; 16]) -> core::result::Result { 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 { + 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 core::result::Result, 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 { + 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