std: xous: add support for args and env

Process arguments and environment variables are both passed by way of
Application Parameters. These are a TLV format that gets passed in as
the second process argument.
This patch combines both as they are very similar in their decode.
Signed-off-by: Sean Cross <sean@osdyne.com>

Author: xobs

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

@@ -0,0 +1,53 @@
+usecrate::ffi::OsString;
+usecrate::sys::pal::xous::os::get_application_parameters;
+usecrate::sys::pal::xous::os::params::ArgumentList;
+usecrate::{fmt, vec};
+
+pubstructArgs{
+parsed_args_list: vec::IntoIter<OsString>,
+}
+
+pubfnargs() -> Args{
+letSome(params) = get_application_parameters()else{
+returnArgs{parsed_args_list:vec![].into_iter()};
+};
+
+for param in params {
+ifletOk(args) = ArgumentList::try_from(&param){
+letmut parsed_args = vec![];
+for arg in args {
+ parsed_args.push(arg.into());
+}
+returnArgs{parsed_args_list: parsed_args.into_iter()};
+}
+}
+Args{parsed_args_list:vec![].into_iter()}
+}
+
+impl fmt::DebugforArgs{
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+self.parsed_args_list.as_slice().fmt(f)
+}
+}
+
+implIteratorforArgs{
+typeItem = OsString;
+fnnext(&mutself) -> Option<OsString>{
+self.parsed_args_list.next()
+}
+fnsize_hint(&self) -> (usize,Option<usize>){
+self.parsed_args_list.size_hint()
+}
+}
+
+implDoubleEndedIteratorforArgs{
+fnnext_back(&mutself) -> Option<OsString>{
+self.parsed_args_list.next_back()
+}
+}
+
+implExactSizeIteratorforArgs{
+fnlen(&self) -> usize{
+self.parsed_args_list.len()
+}
+}

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

@@ -1,6 +1,5 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-#[path = "../unsupported/args.rs"]
 pubmod args;
 #[path = "../unsupported/env.rs"]
 pubmod env;

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

@@ -1,29 +1,35 @@
 usesuper::unsupported;
+usecrate::collections::HashMap;
 usecrate::error::ErrorasStdError;
 usecrate::ffi::{OsStr,OsString};
 usecrate::marker::PhantomData;
 usecrate::os::xous::ffi::ErrorasXousError;
 usecrate::path::{self,PathBuf};
-usecrate::{fmt, io};
+usecrate::sync::atomic::{AtomicPtr,AtomicUsize,Ordering};
+usecrate::sync::{Mutex,Once};
+usecrate::{fmt, io, vec};
+
+pub(crate)mod params;
+
+staticPARAMS_ADDRESS:AtomicPtr<u8> = AtomicPtr::new(core::ptr::null_mut());
 
 #[cfg(not(test))]
 #[cfg(feature = "panic_unwind")]
 mod eh_unwinding {
-pub(crate)structEhFrameFinder(usize/* eh_frame */);
-pub(crate)staticmutEH_FRAME_SETTINGS:EhFrameFinder = EhFrameFinder(0);
-implEhFrameFinder{
-pub(crate)unsafefninit(&mutself,eh_frame:usize){
-unsafe{
-EH_FRAME_SETTINGS.0 = eh_frame;
-}
-}
-}
+pub(crate)structEhFrameFinder;
+pub(crate)staticmutEH_FRAME_ADDRESS:usize = 0;
+pub(crate)staticEH_FRAME_SETTINGS:EhFrameFinder = EhFrameFinder;
+
 unsafeimpl unwind::EhFrameFinderforEhFrameFinder{
 fnfind(&self,_pc:usize) -> Option<unwind::FrameInfo>{
-Some(unwind::FrameInfo{
-text_base:None,
-kind: unwind::FrameInfoKind::EhFrame(self.0),
-})
+ifunsafe{EH_FRAME_ADDRESS == 0}{
+None
+}else{
+Some(unwind::FrameInfo{
+text_base:None,
+kind: unwind::FrameInfoKind::EhFrame(unsafe{EH_FRAME_ADDRESS}),
+})
+}
 }
 }
 }
@@ -41,12 +47,21 @@ mod c_compat {
 }
 
 #[no_mangle]
-pubextern"C"fn_start(eh_frame:usize){
+pubextern"C"fn_start(eh_frame:usize,params_address:usize){
 #[cfg(feature = "panic_unwind")]
-unsafe{
-super::eh_unwinding::EH_FRAME_SETTINGS.init(eh_frame);
+{
+unsafe{super::eh_unwinding::EH_FRAME_ADDRESS = eh_frame};
  unwind::set_custom_eh_frame_finder(&super::eh_unwinding::EH_FRAME_SETTINGS).ok();
 }
+
+if params_address != 0{
+let params_address = crate::ptr::with_exposed_provenance_mut::<u8>(params_address);
+ifunsafe{
+super::params::ApplicationParameters::new_from_ptr(params_address).is_some()
+}{
+super::PARAMS_ADDRESS.store(params_address, core::sync::atomic::Ordering::Relaxed);
+}
+}
 exit(unsafe{main()});
 }
 
@@ -116,44 +131,103 @@ pub fn current_exe() -> io::Result<PathBuf> {
 unsupported()
 }
 
-pubstructEnv(!);
+pub(crate)fnget_application_parameters() -> Option<params::ApplicationParameters>{
+let params_address = PARAMS_ADDRESS.load(Ordering::Relaxed);
+unsafe{ params::ApplicationParameters::new_from_ptr(params_address)}
+}
+
+// ---------- Environment handling ---------- //
+staticENV:AtomicUsize = AtomicUsize::new(0);
+staticENV_INIT:Once = Once::new();
+typeEnvStore = Mutex<HashMap<OsString,OsString>>;
+
+fnget_env_store() -> &'staticEnvStore{
+ENV_INIT.call_once(|| {
+let env_store = EnvStore::default();
+ifletSome(params) = get_application_parameters(){
+for param in params {
+ifletOk(envs) = params::EnvironmentBlock::try_from(&param){
+letmut env_store = env_store.lock().unwrap();
+for env in envs {
+ env_store.insert(env.key.into(), env.value.into());
+}
+break;
+}
+}
+}
+ENV.store(Box::into_raw(Box::new(env_store))as_,Ordering::Relaxed)
+});
+unsafe{&*core::ptr::with_exposed_provenance::<EnvStore>(ENV.load(Ordering::Relaxed))}
+}
+
+pubstructEnv{
+iter: vec::IntoIter<(OsString,OsString)>,
+}
+
+// FIXME(https://github.com/rust-lang/rust/issues/114583): Remove this when <OsStr as Debug>::fmt matches <str as Debug>::fmt.
+pubstructEnvStrDebug<'a>{
+slice:&'a[(OsString,OsString)],
+}
+
+impl fmt::DebugforEnvStrDebug<'_>{
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+letSelf{ slice } = self;
+ f.debug_list()
+.entries(slice.iter().map(|(a, b)| (a.to_str().unwrap(), b.to_str().unwrap())))
+.finish()
+}
+}
 
 implEnv{
 // FIXME(https://github.com/rust-lang/rust/issues/114583): Remove this when <OsStr as Debug>::fmt matches <str as Debug>::fmt.
 pubfnstr_debug(&self) -> impl fmt::Debug + '_{
-letSelf(inner) = self;
-match*inner {}
+letSelf{ iter } = self;
+EnvStrDebug{slice: iter.as_slice()}
 }
 }
 
 impl fmt::DebugforEnv{
-fnfmt(&self,_:&mut fmt::Formatter<'_>) -> fmt::Result{
-letSelf(inner) = self;
-match*inner {}
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+letSelf{ iter } = self;
+f.debug_list().entries(iter.as_slice()).finish()
 }
 }
 
+impl !SendforEnv{}
+impl !SyncforEnv{}
+
 implIteratorforEnv{
 typeItem = (OsString,OsString);
 fnnext(&mutself) -> Option<(OsString,OsString)>{
-self.0
+self.iter.next()
+}
+fnsize_hint(&self) -> (usize,Option<usize>){
+self.iter.size_hint()
 }
 }
 
 pubfnenv() -> Env{
-panic!("not supported on this platform")
+let clone_to_vec = |map:&HashMap<OsString,OsString>| -> Vec<_>{
+ map.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
+};
+
+let iter = clone_to_vec(&*get_env_store().lock().unwrap()).into_iter();
+Env{ iter }
 }
 
-pubfngetenv(_:&OsStr) -> Option<OsString>{
-None
+pubfngetenv(k:&OsStr) -> Option<OsString>{
+get_env_store().lock().unwrap().get(k).cloned()
 }
 
-pubunsafefnsetenv(_:&OsStr, _:&OsStr) -> io::Result<()>{
-Err(io::const_io_error!(io::ErrorKind::Unsupported,"cannot set env vars on this platform"))
+pubunsafefnsetenv(k:&OsStr,v:&OsStr) -> io::Result<()>{
+let(k, v) = (k.to_owned(), v.to_owned());
+get_env_store().lock().unwrap().insert(k, v);
+Ok(())
 }
 
-pubunsafefnunsetenv(_:&OsStr) -> io::Result<()>{
-Err(io::const_io_error!(io::ErrorKind::Unsupported,"cannot unset env vars on this platform"))
+pubunsafefnunsetenv(k:&OsStr) -> io::Result<()>{
+get_env_store().lock().unwrap().remove(k);
+Ok(())
 }
 
 pubfntemp_dir() -> PathBuf{