Scalar5 support

kernel/src/syscall.rs

@@ -538,6 +538,84 @@ fn return_scalar2(
     })
 }
 
+fn return_scalar5(
+    server_pid: PID,
+    server_tid: TID,
+    in_irq: bool,
+    sender: MessageSender,
+    arg1: usize,
+    arg2: usize,
+    arg3: usize,
+    arg4: usize,
+    arg5: usize,
+) -> SysCallResult {
+    SystemServices::with_mut(|ss| {
+        let sender = SenderID::from(sender);
+
+        let server = ss
+            .server_from_sidx_mut(sender.sidx)
+            .ok_or(xous_kernel::Error::ServerNotFound)?;
+        // .expect("Couldn't get server from SIDX");
+        if server.pid != server_pid {
+            return Err(xous_kernel::Error::ServerNotFound);
+        }
+        let result = server.take_waiting_message(sender.idx, None)?;
+        let (client_pid, client_tid) = match result {
+            WaitingMessage::ScalarMessage(pid, tid) => (pid, tid),
+            WaitingMessage::ForgetMemory(_) => {
+                println!("WARNING: Tried to wait on a scalar message that was actually forgetting memory");
+                return Err(xous_kernel::Error::ProcessNotFound);
+            }
+            WaitingMessage::BorrowedMemory(_, _, _, _, _) => {
+                println!(
+                    "WARNING: Tried to wait on a scalar message that was actually borrowed memory"
+                );
+                return Err(xous_kernel::Error::ProcessNotFound);
+            }
+            WaitingMessage::MovedMemory => {
+                println!(
+                    "WARNING: Tried to wait on a scalar message that was actually moved memory"
+                );
+                return Err(xous_kernel::Error::ProcessNotFound);
+            }
+            WaitingMessage::None => {
+                println!("WARNING: Tried to wait on a message that didn't exist");
+                return Err(xous_kernel::Error::ProcessNotFound);
+            }
+        };
+
+        let client_is_runnable = ss.runnable(client_pid, Some(client_tid))?;
+
+        if !cfg!(baremetal) || in_irq || !client_is_runnable {
+            // In a hosted environment, `switch_to_thread()` doesn't continue
+            // execution from the new thread. Instead it continues in the old
+            // thread. Therefore, we need to instruct the client to resume, and
+            // return to the server.
+            // In a baremetal environment, the opposite is true -- we instruct
+            // the server to resume and return to the client.
+            ss.set_thread_result(
+                client_pid,
+                client_tid,
+                xous_kernel::Result::Scalar5(arg1, arg2, arg3, arg4, arg5),
+            )?;
+            if cfg!(baremetal) {
+                ss.ready_thread(client_pid, client_tid)?;
+            }
+            Ok(xous_kernel::Result::Ok)
+        } else {
+            // Switch away from the server, but leave it as Runnable
+            ss.unschedule_thread(server_pid, server_tid)?;
+            ss.ready_thread(server_pid, server_tid)?;
+            ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Ok)?;
+
+            // Switch to the client
+            ss.ready_thread(client_pid, client_tid)?;
+            ss.switch_to_thread(client_pid, Some(client_tid))?;
+            Ok(xous_kernel::Result::Scalar5(arg1, arg2, arg3, arg4, arg5))
+        }
+    })
+}
+
 fn receive_message(pid: PID, tid: TID, sid: SID, blocking: ExecutionType) -> SysCallResult {
     SystemServices::with_mut(|ss| {
         assert!(
@@ -855,6 +933,9 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
         SysCall::ReturnScalar2(sender, arg1, arg2) => {
             return_scalar2(pid, tid, in_irq, sender, arg1, arg2)
         }
+        SysCall::ReturnScalar5(sender, arg1, arg2, arg3, arg4, arg5) => {
+            return_scalar5(pid, tid, in_irq, sender, arg1, arg2, arg3, arg4, arg5)
+        }
         SysCall::TrySendMessage(cid, message) => send_message(pid, tid, cid, message),
         SysCall::TerminateProcess(_ret) => SystemServices::with_mut(|ss| {
             ss.unschedule_thread(pid, tid)?;
@@ -936,7 +1017,7 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
             }),
             _ => Err(xous_kernel::Error::InvalidLimit),
         },
-        #[cfg(feature="v2p")]
+        #[cfg(feature = "v2p")]
         SysCall::VirtToPhys(vaddr) => {
             let phys_addr = crate::arch::mem::virt_to_phys(vaddr as usize);
             match phys_addr {

xous-rs/src/definitions.rs

@@ -460,6 +460,9 @@ pub enum Result {
     /// the caller.
     NewProcess(ProcessStartup),
 
+    /// 20: A scalar with five values
+    Scalar5(usize, usize, usize, usize, usize),
+
     UnknownResult(usize, usize, usize, usize, usize, usize, usize),
 }
 
@@ -523,6 +526,7 @@ impl Result {
                 0,
             ],
             Result::NewProcess(p) => Self::add_opcode(19, p.into()),
+            Result::Scalar5(a, b, c, d, e) => [15, *a, *b, *c, *d, *e, 0, 0],
             Result::UnknownResult(arg1, arg2, arg3, arg4, arg5, arg6, arg7) => {
                 [usize::MAX, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6, *arg7]
             }
@@ -600,6 +604,7 @@ impl Result {
             17 => Result::None,
             18 => Result::MemoryReturned(MemorySize::new(src[1]), MemorySize::new(src[2])),
             19 => Result::NewProcess(src.into()),
+            20 => Result::Scalar5(src[1], src[2], src[3], src[4], src[5]),
             _ => Result::UnknownResult(src[0], src[1], src[2], src[3], src[4], src[5], src[6]),
         }
     }

xous-rs/src/syscall.rs

@@ -327,6 +327,7 @@ pub enum SysCall {
     /// * **Ok**: The Scalar / Send message was successfully sent, or the Borrow has finished
     /// * **Scalar1**: The Server returned a `Scalar1` value
     /// * **Scalar2**: The Server returned a `Scalar2` value
+    /// * **Scalar5**: The Server returned a `Scalar5` value
     /// * **BlockedProcess**: In Hosted mode, the target process is now blocked
     ///
     /// # Errors
@@ -342,6 +343,7 @@ pub enum SysCall {
     /// * **Ok**: The Scalar / Send message was successfully sent, or the Borrow has finished
     /// * **Scalar1**: The Server returned a `Scalar1` value
     /// * **Scalar2**: The Server returned a `Scalar2` value
+    /// * **Scalar5**: The Server returned a `Scalar5` value
     /// * **BlockedProcess**: In Hosted mode, the target process is now blocked
     ///
     /// # Errors
@@ -467,10 +469,11 @@ pub enum SysCall {
     ///
     /// ## Errors
     ///     * **BadAddress**: The mapping does not exist
-    #[cfg(feature="v2p")]
-    VirtToPhys(
-        usize, /* virtual address */
-    ),
+    #[cfg(feature = "v2p")]
+    VirtToPhys(usize /* virtual address */),
+
+    /// Return five scalars to the sender
+    ReturnScalar5(MessageSender, usize, usize, usize, usize, usize),
 
     /// This syscall does not exist. It captures all possible
     /// arguments so detailed analysis can be performed.
@@ -516,8 +519,9 @@ pub enum SysCallNumber {
     JoinThread = 36,
     SetExceptionHandler = 37,
     AdjustProcessLimit = 38,
-    #[cfg(feature="v2p")]
+    #[cfg(feature = "v2p")]
     VirtToPhys = 39,
+    ReturnScalar5 = 40,
     Invalid,
 }
 
@@ -562,8 +566,9 @@ impl SysCallNumber {
             36 => JoinThread,
             37 => SetExceptionHandler,
             38 => AdjustProcessLimit,
-            #[cfg(feature="v2p")]
+            #[cfg(feature = "v2p")]
             39 => VirtToPhys,
+            40 => ReturnScalar5,
             _ => Invalid,
         }
     }
@@ -928,15 +933,18 @@ impl SysCall {
                 0,
                 0,
             ],
-            #[cfg(feature="v2p")]
-            SysCall::VirtToPhys(vaddr) => [
-                SysCallNumber::VirtToPhys as usize,
-                *vaddr,
-                0,
-                0,
-                0,
-                0,
-                0,
+            #[cfg(feature = "v2p")]
+            SysCall::VirtToPhys(vaddr) => {
+                [SysCallNumber::VirtToPhys as usize, *vaddr, 0, 0, 0, 0, 0, 0]
+            }
+            SysCall::ReturnScalar5(sender, arg1, arg2, arg3, arg4, arg5) => [
+                SysCallNumber::ReturnScalar5 as usize,
+                sender.to_usize(),
+                *arg1,
+                *arg2,
+                *arg3,
+                *arg4,
+                *arg5,
                 0,
             ],
             SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => [
@@ -1103,8 +1111,11 @@ impl SysCall {
             SysCallNumber::JoinThread => SysCall::JoinThread(a1 as _),
             SysCallNumber::SetExceptionHandler => SysCall::SetExceptionHandler(a1 as _, a2 as _),
             SysCallNumber::AdjustProcessLimit => SysCall::AdjustProcessLimit(a1, a2, a3),
-            #[cfg(feature="v2p")]
+            #[cfg(feature = "v2p")]
             SysCallNumber::VirtToPhys => SysCall::VirtToPhys(a1 as _),
+            SysCallNumber::ReturnScalar5 => {
+                SysCall::ReturnScalar5(MessageSender::from_usize(a1), a2, a3, a4, a5, a6)
+            }
             SysCallNumber::Invalid => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
         })
     }
@@ -1201,6 +1212,7 @@ impl SysCall {
             SysCall::TryConnect(_)
                 | SysCall::TryReceiveMessage(_)
                 | SysCall::ReturnToParent(_, _)
+                | SysCall::ReturnScalar5(_, _, _, _, _, _)
                 | SysCall::ReturnScalar2(_, _, _)
                 | SysCall::ReturnScalar1(_, _)
                 | SysCall::ReturnMemory(_, _, _, _)
@@ -1343,6 +1355,25 @@ pub fn return_scalar2(
     }
 }
 
+/// Return 5 scalars to the provided message.
+pub fn return_scalar5(
+    sender: MessageSender,
+    val1: usize,
+    val2: usize,
+    val3: usize,
+    val4: usize,
+    val5: usize,
+) -> core::result::Result<(), Error> {
+    let result = rsyscall(SysCall::ReturnScalar5(sender, val1, val2, val3, val4, val5))?;
+    if let crate::Result::Ok = result {
+        Ok(())
+    } else if let Result::Error(e) = result {
+        Err(e)
+    } else {
+        Err(Error::InternalError)
+    }
+}
+
 /// Claim a hardware interrupt for this process.
 pub fn claim_interrupt(
     irq_no: usize,
@@ -1530,6 +1561,7 @@ pub fn try_send_message(connection: CID, message: Message) -> core::result::Resu
         Ok(Result::Ok) => Ok(Result::Ok),
         Ok(Result::Scalar1(a)) => Ok(Result::Scalar1(a)),
         Ok(Result::Scalar2(a, b)) => Ok(Result::Scalar2(a, b)),
+        Ok(Result::Scalar5(a, b, c, d, e)) => Ok(Result::Scalar5(a, b, c, d, e)),
         Ok(Result::MemoryReturned(offset, valid)) => Ok(Result::MemoryReturned(offset, valid)),
         Err(e) => Err(e),
         v => panic!("Unexpected return value: {:?}", v),
@@ -1572,6 +1604,7 @@ pub fn send_message(connection: CID, message: Message) -> core::result::Result<R
         Ok(Result::Ok) => Ok(Result::Ok),
         Ok(Result::Scalar1(a)) => Ok(Result::Scalar1(a)),
         Ok(Result::Scalar2(a, b)) => Ok(Result::Scalar2(a, b)),
+        Ok(Result::Scalar5(a, b, c, d, e)) => Ok(Result::Scalar5(a, b, c, d, e)),
         Ok(Result::MemoryReturned(offset, valid)) => Ok(Result::MemoryReturned(offset, valid)),
         Err(e) => Err(e),
         v => panic!("Unexpected return value: {:?}", v),
@@ -1872,7 +1905,7 @@ pub fn set_exception_handler(
 */
 
 /// Translate a virtual address to a physical address
-#[cfg(feature="v2p")]
+#[cfg(feature = "v2p")]
 pub fn virt_to_phys(va: usize) -> core::result::Result<usize, Error> {
     rsyscall(SysCall::VirtToPhys(va)).and_then(|result| {
         if let Result::Scalar1(pa) = result {