user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

std: switch to moto-rt v0.16.0

Browse source
This commit is contained in:
U. Lasiotus 2025-12-18 21:41:41 -08:00
parent 806c2a35dc
commit fb6dd1700a
8 changed files with 58 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

4
library/Cargo.lock
View file

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

2
library/std/Cargo.toml
View file

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

4
library/std/src/os/motor/mod.rs
View file

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

23
library/std/src/sys/net/connection/motor.rs
View file

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

54
library/std/src/sys/pal/motor/mod.rs
View file

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

15
library/std/src/sys/pal/motor/os.rs
View file

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

7
library/std/src/sys/process/motor.rs
View file

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

2
library/std/src/sys/thread/motor.rs
View file

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