std: Motor OS: switch to moto-rt v0.16.0

library/Cargo.lock

@@ -175,9 +175,9 @@ dependencies = [
 
 [[package]]
 name = "moto-rt"
-version = "0.15.2"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bf4bc387d3b3502cb92c09ec980cca909b94978e144c61da8319ecf4bc8d031"
+checksum = "29aea9f7dfeb258e030a84e0ec38a9c2ec2063d4f45eb2db31445cfc40b3dba1"
 dependencies = [
  "rustc-std-workspace-alloc",
  "rustc-std-workspace-core",

library/std/Cargo.toml

@@ -71,7 +71,7 @@ fortanix-sgx-abi = { version = "0.6.1", features = [
 ], public = true }
 
 [target.'cfg(target_os = "motor")'.dependencies]
-moto-rt = { version = "0.15", features = ['rustc-dep-of-std'], public = true }
+moto-rt = { version = "0.16", features = ['rustc-dep-of-std'], public = true }
 
 [target.'cfg(target_os = "hermit")'.dependencies]
 hermit-abi = { version = "0.5.0", features = [

library/std/src/os/motor/mod.rs

@@ -2,3 +2,7 @@
 
 pub mod ffi;
 pub mod process;
+
+pub fn rt_version() -> u64 {
+    moto_rt::RT_VERSION
+}

library/std/src/sys/net/connection/motor.rs

@@ -144,8 +144,9 @@ impl TcpStream {
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let e = moto_rt::net::take_error(self.inner.as_raw_fd()).map_err(map_motor_error)?;
-        if e == moto_rt::E_OK { Ok(None) } else { Ok(Some(map_motor_error(e))) }
+        moto_rt::net::take_error(self.inner.as_raw_fd())
+            .map(|e| e.map(map_motor_error))
+            .map_err(map_motor_error)
     }
 
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
@@ -212,8 +213,9 @@ impl TcpListener {
     }
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
-        let e = moto_rt::net::take_error(self.inner.as_raw_fd()).map_err(map_motor_error)?;
-        if e == moto_rt::E_OK { Ok(None) } else { Ok(Some(map_motor_error(e))) }
+        moto_rt::net::take_error(self.inner.as_raw_fd())
+            .map(|e| e.map(map_motor_error))
+            .map_err(map_motor_error)
     }
 
     pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
@@ -363,10 +365,7 @@ impl UdpSocket {
 
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         moto_rt::net::take_error(self.inner.as_raw_fd())
-            .map(|e| match e {
-                moto_rt::E_OK => None,
-                e => Some(map_motor_error(e)),
-            })
+            .map(|e| e.map(map_motor_error))
             .map_err(map_motor_error)
     }
 
@@ -414,10 +413,12 @@ impl TryFrom<&str> for LookupHost {
     fn try_from(host_port: &str) -> io::Result<LookupHost> {
         let (host, port_str) = host_port
             .rsplit_once(':')
-            .ok_or(moto_rt::E_INVALID_ARGUMENT)
+            .ok_or(moto_rt::Error::InvalidArgument)
+            .map_err(map_motor_error)?;
+        let port: u16 = port_str
+            .parse()
+            .map_err(|_| moto_rt::Error::InvalidArgument)
             .map_err(map_motor_error)?;
-        let port: u16 =
-            port_str.parse().map_err(|_| moto_rt::E_INVALID_ARGUMENT).map_err(map_motor_error)?;
         (host, port).try_into()
     }
 }

library/std/src/sys/pal/motor/mod.rs

@@ -6,10 +6,11 @@ pub mod time;
 pub use moto_rt::futex;
 
 use crate::io as std_io;
-use crate::sys::RawOsError;
+use crate::sys::io::RawOsError;
 
-pub(crate) fn map_motor_error(err: moto_rt::ErrorCode) -> crate::io::Error {
-    crate::io::Error::from_raw_os_error(err.into())
+pub(crate) fn map_motor_error(err: moto_rt::Error) -> crate::io::Error {
+    let error_code: moto_rt::ErrorCode = err.into();
+    crate::io::Error::from_raw_os_error(error_code.into())
 }
 
 #[cfg(not(test))]
@@ -49,35 +50,36 @@ pub fn is_interrupted(_code: RawOsError) -> bool {
 }
 
 pub fn decode_error_kind(code: RawOsError) -> crate::io::ErrorKind {
-    use moto_rt::error::*;
     use std_io::ErrorKind;
 
     if code < 0 || code > u16::MAX.into() {
         return std_io::ErrorKind::Uncategorized;
     }
 
-    match code as moto_rt::ErrorCode /* u16 */ {
-        E_UNSPECIFIED => ErrorKind::Uncategorized,
-        E_UNKNOWN => ErrorKind::Uncategorized,
-        E_NOT_READY => ErrorKind::WouldBlock,
-        E_NOT_IMPLEMENTED => ErrorKind::Unsupported,
-        E_VERSION_TOO_HIGH => ErrorKind::Unsupported,
-        E_VERSION_TOO_LOW => ErrorKind::Unsupported,
-        E_INVALID_ARGUMENT => ErrorKind::InvalidInput,
-        E_OUT_OF_MEMORY => ErrorKind::OutOfMemory,
-        E_NOT_ALLOWED => ErrorKind::PermissionDenied,
-        E_NOT_FOUND => ErrorKind::NotFound,
-        E_INTERNAL_ERROR => ErrorKind::Other,
-        E_TIMED_OUT => ErrorKind::TimedOut,
-        E_ALREADY_IN_USE => ErrorKind::AlreadyExists,
-        E_UNEXPECTED_EOF => ErrorKind::UnexpectedEof,
-        E_INVALID_FILENAME => ErrorKind::InvalidFilename,
-        E_NOT_A_DIRECTORY => ErrorKind::NotADirectory,
-        E_BAD_HANDLE => ErrorKind::InvalidInput,
-        E_FILE_TOO_LARGE => ErrorKind::FileTooLarge,
-        E_NOT_CONNECTED => ErrorKind::NotConnected,
-        E_STORAGE_FULL => ErrorKind::StorageFull,
-        E_INVALID_DATA => ErrorKind::InvalidData,
+    let error = moto_rt::Error::from(code as moto_rt::ErrorCode);
+
+    match error {
+        moto_rt::Error::Unspecified => ErrorKind::Uncategorized,
+        moto_rt::Error::Unknown => ErrorKind::Uncategorized,
+        moto_rt::Error::NotReady => ErrorKind::WouldBlock,
+        moto_rt::Error::NotImplemented => ErrorKind::Unsupported,
+        moto_rt::Error::VersionTooHigh => ErrorKind::Unsupported,
+        moto_rt::Error::VersionTooLow => ErrorKind::Unsupported,
+        moto_rt::Error::InvalidArgument => ErrorKind::InvalidInput,
+        moto_rt::Error::OutOfMemory => ErrorKind::OutOfMemory,
+        moto_rt::Error::NotAllowed => ErrorKind::PermissionDenied,
+        moto_rt::Error::NotFound => ErrorKind::NotFound,
+        moto_rt::Error::InternalError => ErrorKind::Other,
+        moto_rt::Error::TimedOut => ErrorKind::TimedOut,
+        moto_rt::Error::AlreadyInUse => ErrorKind::AlreadyExists,
+        moto_rt::Error::UnexpectedEof => ErrorKind::UnexpectedEof,
+        moto_rt::Error::InvalidFilename => ErrorKind::InvalidFilename,
+        moto_rt::Error::NotADirectory => ErrorKind::NotADirectory,
+        moto_rt::Error::BadHandle => ErrorKind::InvalidInput,
+        moto_rt::Error::FileTooLarge => ErrorKind::FileTooLarge,
+        moto_rt::Error::NotConnected => ErrorKind::NotConnected,
+        moto_rt::Error::StorageFull => ErrorKind::StorageFull,
+        moto_rt::Error::InvalidData => ErrorKind::InvalidData,
         _ => crate::io::ErrorKind::Uncategorized,
     }
 }

library/std/src/sys/pal/motor/os.rs

@@ -4,7 +4,7 @@ use crate::ffi::{OsStr, OsString};
 use crate::marker::PhantomData;
 use crate::os::motor::ffi::OsStrExt;
 use crate::path::{self, PathBuf};
-use crate::sys::RawOsError;
+use crate::sys::io::RawOsError;
 use crate::{fmt, io};
 
 pub fn errno() -> RawOsError {
@@ -22,16 +22,17 @@ pub fn errno() -> RawOsError {
     // separate runtime background/I/O thread, so it is really hard
     // to define what "last system error in the current thread"
     // actually means.
-    moto_rt::E_UNKNOWN.into()
+    let error_code: moto_rt::ErrorCode = moto_rt::Error::Unknown.into();
+    error_code.into()
 }
 
 pub fn error_string(errno: RawOsError) -> String {
-    let error_code: moto_rt::ErrorCode = match errno {
-        x if x < 0 => moto_rt::E_UNKNOWN,
-        x if x > u16::MAX.into() => moto_rt::E_UNKNOWN,
-        x => x as moto_rt::ErrorCode, /* u16 */
+    let error: moto_rt::Error = match errno {
+        x if x < 0 => moto_rt::Error::Unknown,
+        x if x > u16::MAX.into() => moto_rt::Error::Unknown,
+        x => (x as moto_rt::ErrorCode).into(), /* u16 */
     };
-    format!("{}", moto_rt::Error::from(error_code))
+    format!("{}", error)
 }
 
 pub fn getcwd() -> io::Result<PathBuf> {

library/std/src/sys/process/motor.rs

@@ -265,10 +265,7 @@ impl Process {
     }
 
     pub fn kill(&mut self) -> io::Result<()> {
-        match moto_rt::process::kill(self.handle) {
-            moto_rt::E_OK => Ok(()),
-            err => Err(map_motor_error(err)),
-        }
+        moto_rt::process::kill(self.handle).map_err(map_motor_error)
     }
 
     pub fn wait(&mut self) -> io::Result<ExitStatus> {
@@ -279,7 +276,7 @@ impl Process {
         match moto_rt::process::try_wait(self.handle) {
             Ok(s) => Ok(Some(ExitStatus(s))),
             Err(err) => match err {
-                moto_rt::E_NOT_READY => Ok(None),
+                moto_rt::Error::NotReady => Ok(None),
                 err => Err(map_motor_error(err)),
             },
         }

library/std/src/sys/thread/motor.rs

@@ -36,7 +36,7 @@ impl Thread {
     }
 
     pub fn join(self) {
-        assert!(moto_rt::thread::join(self.sys_thread) == moto_rt::E_OK)
+        assert!(moto_rt::thread::join(self.sys_thread).is_ok())
     }
 }