[library/std pal::safaos]: update safa-api to 0.2.6, change how arguments are handled to use api implementition and add environment variables

Author: safiworks

library/Cargo.lock

@@ -315,9 +315,9 @@ dependencies = [
 
 [[package]]
 name = "safa-abi"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d9dc36026b330e211bedd31644d5f7cdbb04988de00b9e622cc1a5a228a8d27"
+checksum = "904cf96582683a0faecdaf07b75f1b12388f893722be8e3ffa81a4f671364bf1"
 dependencies = [
  "compiler_builtins",
  "rustc-std-workspace-alloc",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "safa-api"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d039d8b6139419447bd9578f34edbcabdcfa150dc2f8a298f78696f101bfafb6"
+checksum = "4f38596091b6f623631d7a960e7753c94bd51e21c4541c53fdcceb4e1abb1b55"
 dependencies = [
  "compiler_builtins",
  "rustc-std-workspace-alloc",

library/std/Cargo.toml

@@ -77,7 +77,7 @@ hermit-abi = { version = "0.4.0", features = [
 ], public = true }
 
 [target.'cfg(target_os = "safaos")'.dependencies]
-safa-api = { version = "0.2.5", features = ['rustc-dep-of-std'], public = true }
+safa-api = { version = "0.2.6", features = ['rustc-dep-of-std'], public = true }
 
 [target.'cfg(target_os = "wasi")'.dependencies]
 wasi = { version = "0.11.0", features = [

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

@@ -1,40 +1,10 @@
-use core::cell::SyncUnsafeCell;
-use core::ptr::NonNull;
-
 use crate::ffi::OsString;
 use crate::fmt;
-use crate::mem::MaybeUninit;
-
-#[derive(Debug, Clone, Copy)]
-pub(super) struct RawArgs {
-    pub(super) args: NonNull<[(NonNull<u8>, usize)]>,
-}
 
-impl RawArgs {
-    fn len(&self) -> usize {
-        unsafe { (*self.args.as_ptr()).len() }
-    }
-
-    fn get(&self, index: usize) -> Option<&'static str> {
-        unsafe {
-            let args = &*self.args.as_ptr();
-            let (ptr, len) = args.get(index)?;
-            Some(core::str::from_utf8_unchecked(core::slice::from_raw_parts(ptr.as_ptr(), *len)))
-        }
-    }
-}
-
-unsafe impl Sync for RawArgs {}
-
-pub(super) static RAW_ARGS: SyncUnsafeCell<MaybeUninit<Option<RawArgs>>> =
-    SyncUnsafeCell::new(MaybeUninit::uninit());
-pub struct Args {
-    raw_args: Option<RawArgs>,
-    index: usize,
-}
+pub struct Args(safa_api::process::ArgsIter);
 
 pub fn args() -> Args {
-    Args { raw_args: unsafe { (*RAW_ARGS.get()).assume_init() }, index: 0 }
+    Args(safa_api::process::ArgsIter::get())
 }
 
 impl fmt::Debug for Args {
@@ -43,8 +13,8 @@ impl fmt::Debug for Args {
         let len = self.len();
         for i in 0..len {
             // safe because index is always in len and raw_args is initialized (otherwise len is going to be 0)
-            let arg = unsafe { self.raw_args.unwrap_unchecked().get(i).unwrap_unchecked() };
-            list.entry(&arg);
+            let arg = unsafe { self.0.get_index(i).unwrap_unchecked() };
+            list.entry(&unsafe { arg.into_slice_mut() });
         }
         list.finish()
     }
@@ -53,30 +23,19 @@ impl fmt::Debug for Args {
 impl Iterator for Args {
     type Item = OsString;
     fn next(&mut self) -> Option<OsString> {
-        if self.index >= self.len() {
-            return None;
-        }
-        // it is gruanted that the raw_args is initialized if len > 0
-        let raw_args = unsafe { self.raw_args.unwrap_unchecked() };
-        let results = raw_args.get(self.index).map(|arg| OsString::from(arg));
-        self.index += 1;
-        results
+        self.0.next().map(|arg| unsafe {
+            OsString::from_encoded_bytes_unchecked(arg.into_slice_mut().to_vec())
+        })
     }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.len();
 
-        if len == 0 {
-            (0, Some(0))
-        } else {
-            let left = len - self.index;
-            (left, Some(left))
-        }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.0.len(), Some(self.0.len()))
     }
 }
 
 impl ExactSizeIterator for Args {
     fn len(&self) -> usize {
-        self.raw_args.map(|s| s.len()).unwrap_or(0)
+        self.0.len()
     }
 }
 

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

@@ -1,6 +1,6 @@
 pub mod os {
-    pub const FAMILY: &str = "";
-    pub const OS: &str = "";
+    pub const FAMILY: &str = "safa";
+    pub const OS: &str = "SafaOS";
     pub const DLL_PREFIX: &str = "";
     pub const DLL_SUFFIX: &str = "";
     pub const DLL_EXTENSION: &str = "";

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

@@ -80,45 +80,61 @@ pub fn current_exe() -> io::Result<PathBuf> {
     unsupported()
 }
 
-pub struct Env(!);
+pub struct Env {
+    inner: Vec<(OsString, OsString)>,
+    index: usize,
+}
 
 impl Env {
     // FIXME(https://github.com/rust-lang/rust/issues/114583): Remove this when <OsStr as Debug>::fmt matches <str as Debug>::fmt.
     pub fn str_debug(&self) -> impl fmt::Debug + '_ {
-        let Self(inner) = self;
-        match *inner {}
+        self
     }
 }
 
 impl fmt::Debug for Env {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self(inner) = self;
-        match *inner {}
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_list().entries(self.inner.iter()).finish()
     }
 }
 
 impl Iterator for Env {
     type Item = (OsString, OsString);
     fn next(&mut self) -> Option<(OsString, OsString)> {
-        let Self(inner) = self;
-        match *inner {}
+        if self.index >= self.inner.len() {
+            return None;
+        }
+        let (key, value) = self.inner[self.index].clone();
+        self.index += 1;
+        Some((key, value))
     }
 }
 
 pub fn env() -> Env {
-    panic!("not supported on this platform")
+    let all = safa_api::process::env_get_all();
+    let mut results = Vec::with_capacity(all.len());
+    for (key, value) in all {
+        results.push((unsafe { OsString::from_encoded_bytes_unchecked(key.to_vec()) }, unsafe {
+            OsString::from_encoded_bytes_unchecked(value.to_bytes().to_vec())
+        }));
+    }
+
+    Env { inner: results, index: 0 }
 }
 
-pub fn getenv(_: &OsStr) -> Option<OsString> {
-    None
+pub fn getenv(key: &OsStr) -> Option<OsString> {
+    safa_api::process::env_get(key.as_encoded_bytes())
+        .map(|s| unsafe { OsString::from_encoded_bytes_unchecked(s.to_vec()) })
 }
 
-pub unsafe fn setenv(_: &OsStr, _: &OsStr) -> io::Result<()> {
-    Err(io::const_error!(io::ErrorKind::Unsupported, "cannot set env vars on this platform"))
+pub unsafe fn setenv(key: &OsStr, value: &OsStr) -> io::Result<()> {
+    safa_api::process::env_set(key.as_encoded_bytes(), value.as_encoded_bytes());
+    Ok(())
 }
 
-pub unsafe fn unsetenv(_: &OsStr) -> io::Result<()> {
-    Err(io::const_error!(io::ErrorKind::Unsupported, "cannot unset env vars on this platform"))
+pub unsafe fn unsetenv(key: &OsStr) -> io::Result<()> {
+    safa_api::process::env_remove(key.as_encoded_bytes());
+    Ok(())
 }
 
 pub fn temp_dir() -> PathBuf {

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

@@ -1,35 +1,34 @@
-use core::ptr::NonNull;
-
-use super::args::RAW_ARGS;
-use super::args::RawArgs;
-use super::os::exit;
-use crate::mem::MaybeUninit;
+use safa_api::raw::{NonNullSlice, RawSliceMut};
+use safa_api::syscalls::exit;
 
 extern "C" {
     fn main() -> u16;
 }
 
-unsafe fn _start_inner(argc: usize, argv: *mut (NonNull<u8>, usize)) -> ! {
+unsafe fn _start_inner(
+    argc: usize,
+    argv: *mut NonNullSlice<u8>,
+    envc: usize,
+    envp: *mut NonNullSlice<u8>,
+) -> ! {
     unsafe {
-        let raw_args = match argc == 0 || argv.is_null() {
-            true => None,
-            false => {
-                let args_slice = core::slice::from_raw_parts_mut(argv, argc);
-                let args = NonNull::new_unchecked(args_slice as *mut _);
-                Some(RawArgs { args })
-            }
-        };
-
-        RAW_ARGS.get().write(MaybeUninit::new(raw_args));
+        let args = RawSliceMut::from_raw_parts(argv, argc);
+        let env = RawSliceMut::from_raw_parts(envp, envc);
+        safa_api::process::sysapi_init(args, env);
         let results = main();
 
-        exit(results as i32)
+        exit(results as usize);
     }
 }
 
 #[no_mangle]
 #[allow(unused)]
-pub extern "C" fn _start(argc: usize, argv: *mut (NonNull<u8>, usize)) {
+pub extern "C" fn _start(
+    argc: usize,
+    argv: *mut NonNullSlice<u8>,
+    envc: usize,
+    envp: *mut NonNullSlice<u8>,
+) {
     unsafe {
         core::arch::asm!(
             "
@@ -39,6 +38,6 @@ pub extern "C" fn _start(argc: usize, argv: *mut (NonNull<u8>, usize)) {
         ",
             options(nostack)
         );
-        _start_inner(argc, argv);
+        _start_inner(argc, argv, envc, envp);
     };
 }