chore(safa-os): update safa-api

Author: safiworks

library/std/src/sys/pal/safaos/common.rs

@@ -28,10 +28,9 @@ pub fn decode_error_kind(code: i32) -> crate::io::ErrorKind {
  return crate::io::ErrorKind::Uncategorized;
  }
 
- match SysResult::try_from(code as u16) {
- Ok(SysResult::Success) => unreachable!(),
- Ok(SysResult::Error(err)) => crate::os::safaos::into_io_error_kind(err),
- Err(_) => crate::io::ErrorKind::Uncategorized,
+ match SysResult::from_isize(code as isize).into_result() {
+ Ok(_) => unreachable!(),
+ Err(err) => crate::os::safaos::into_io_error_kind(err),
  }
 }
 

library/std/src/sys/pal/safaos/futex.rs

@@ -14,17 +14,22 @@ pub type SmallPrimitive = u32;
 pub fn futex_wait(futex: &Atomic<u32>, expected: u32, timeout: Option<Duration>) -> bool {
  // FIXME: Infinite timeout is just the max for now
  let timeout_duration = timeout.unwrap_or(Duration::MAX);
- let results = safa_api::syscalls::futex::futex_wait(futex, expected, timeout_duration)
- .expect("FATAL System error while waiting for Futex");
- results
+ let results = safa_api::syscalls::futex::futex_wait(futex, expected, timeout_duration);
+ let timedout = results == Err(safa_api::errors::ErrorStatus::Timeout);
+ if let Err(err) = results {
+ panic!("FATAL System error while waiting for Futex: {}", err.as_str());
+ }
+ !timedout
 }
 
 #[inline]
 pub fn futex_wake(futex: &Atomic<u32>) -> bool {
- let results = safa_api::syscalls::futex::futex_wake(futex, 1)
- .expect("FATAL System error while waking 1 Futex")
- > 0;
- results
+ let results = safa_api::syscalls::futex::futex_wake(futex, 1);
+ let timedout = results == Err(safa_api::errors::ErrorStatus::Timeout);
+ if let Err(err) = results {
+ panic!("FATAL System error while waking Futex: {}", err.as_str());
+ }
+ !timedout
 }
 
 #[inline]

library/std/src/sys/pal/safaos/resources.rs

@@ -16,7 +16,7 @@ pub(crate) use path_to_str;
 
 #[stable(feature = "rust1", since = "1.0.0")]
 /// Reprsents an ID over a resource
-pub type ResourceID = usize;
+pub type ResourceID = u32;
 const _: () = assert!(size_of::<ResourceID>() == size_of::<safa_api::syscalls::types::Ri>());
 
 #[derive(Debug, PartialEq, Eq)]
@@ -121,19 +121,19 @@ impl FileDesc {
 
  /// converts a raw resource id into a FileDesc
  /// this is unsafe because the resource id is not checked for validity
- pub unsafe fn from_raw(ri: usize) -> Self {
+ pub unsafe fn from_raw(ri: ResourceID) -> Self {
  Self { fd: FileResource(ri), seek_at: UnsafeCell::new(0) }
  }
 
  /// duplicates a raw resource id into a FileDesc
  /// this is unsafe because the resource id is not checked for validity
  /// the returned FileDesc is a duplicate of the original with a different resource id and therefore doesn't take ownership of the resource
- pub unsafe fn from_raw_dup(ri: usize) -> Self {
+ pub unsafe fn from_raw_dup(ri: ResourceID) -> Self {
  let fd = unsafe { ManuallyDrop::new(Self::from_raw(ri)) };
  ManuallyDrop::into_inner(fd.clone())
  }
 
- pub(crate) fn fd(&self) -> usize {
+ pub(crate) fn fd(&self) -> ResourceID {
  self.fd.0
  }
 

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

@@ -2,6 +2,7 @@ use super::env::{CommandEnv, CommandEnvs};
 pub use crate::ffi::OsString as EnvKey;
 use crate::ffi::{OsStr, OsString};
 use crate::num::NonZero;
+use crate::os::safaos::ResourceID;
 use crate::os::safaos::api::errors::ErrorStatus;
 use crate::os::safaos::api::syscalls;
 use crate::path::Path;
@@ -51,7 +52,7 @@ pub enum Stdio {
 
 impl Stdio {
  // `&self` because Self::InheritFile has to live as long as the results
- fn into_raw(&self) -> Option<usize> {
+ fn into_raw(&self) -> Option<ResourceID> {
  match self {
  Stdio::Inherit => None,
  Stdio::InheritStdout => Some(sysget_stdout()),
@@ -292,14 +293,13 @@ impl fmt::Debug for Command {
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug, Default)]
 #[non_exhaustive]
-pub struct ExitStatus(u32);
+pub struct ExitStatus(isize);
 
 impl ExitStatus {
  pub fn exit_ok(&self) -> Result<(), ExitStatusError> {
- match SysResult::try_from(self.0 as u16) {
- Ok(SysResult::Success) => Ok(()),
- Ok(SysResult::Error(e)) => Err(ExitStatusError::ErrorStatus(e)),
- Err(_) => Err(ExitStatusError::Unknown(self.0 as u32)),
+ match SysResult::from_isize(self.0).into_result() {
+ Ok(_) => Ok(()),
+ Err(e) => Err(ExitStatusError(e)),
  }
  }
 
@@ -311,24 +311,19 @@ impl ExitStatus {
 impl fmt::Display for ExitStatus {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  match self.exit_ok() {
- Ok(()) => write!(f, "{}", "Success"),
+ Ok(()) => write!(f, "Success"),
  Err(err) => write!(f, "{}", err),
  }
  }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ExitStatusError {
- ErrorStatus(ErrorStatus),
- Unknown(u32),
-}
+#[repr(transparent)]
+pub struct ExitStatusError(ErrorStatus);
 
 impl core::fmt::Display for ExitStatusError {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- match self {
- Self::ErrorStatus(err) => write!(f, "{}", err.as_str()),
- Self::Unknown(code) => write!(f, "<unknown exit status {}>", code),
- }
+ write!(f, "{}", self.0.as_str())
  }
 }
 
@@ -341,10 +336,7 @@ impl ExitStatusError {
 
 impl Into<ExitStatus> for ExitStatusError {
  fn into(self) -> ExitStatus {
- match self {
- Self::ErrorStatus(err) => ExitStatus(err as u32),
- Self::Unknown(code) => ExitStatus(code),
- }
+ ExitStatus(-(self.0 as isize))
  }
 }
 
@@ -385,12 +377,12 @@ impl Process {
 
  pub fn wait(&mut self) -> io::Result<ExitStatus> {
  let exit_code = syscalls::process::wait(self.0)?;
- Ok(ExitStatus(exit_code as u32))
+ Ok(ExitStatus(exit_code as isize))
  }
 
  pub fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {
  let exit_code = syscalls::process::try_cleanup(self.0)?;
- Ok(exit_code.map(|code| ExitStatus(code as u32)))
+ Ok(exit_code.map(|code| ExitStatus(code as isize)))
  }
 }