Rollup merge of #127462 - Ayush1325:uefi-env, r=joboet

std: uefi: Add basic Env variables
- Implement environment variable functions
- Using EFI Shell protocol.

Author: matthiaskrgr

library/std/src/sys/pal/uefi/helpers.rs

@@ -10,7 +10,7 @@
 //! - More information about protocols can be found [here](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/3_foundation/36_protocols_and_handles)
 
 use r_efi::efi::{self,Guid};
-use r_efi::protocols::{device_path, device_path_to_text};
+use r_efi::protocols::{device_path, device_path_to_text, shell};
 
 usecrate::ffi::{OsStr,OsString};
 usecrate::io::{self, const_io_error};
@@ -424,3 +424,24 @@ pub(crate) fn os_string_to_raw(s: &OsStr) -> Option<Box<[r_efi::efi::Char16]>> {
 let temp = s.encode_wide().chain(Some(0)).collect::<Box<[r_efi::efi::Char16]>>();
 if temp[..temp.len() - 1].contains(&0){None}else{Some(temp)}
 }
+
+pub(crate)fnopen_shell() -> Option<NonNull<shell::Protocol>>{
+staticLAST_VALID_HANDLE:AtomicPtr<crate::ffi::c_void> =
+AtomicPtr::new(crate::ptr::null_mut());
+
+ifletSome(handle) = NonNull::new(LAST_VALID_HANDLE.load(Ordering::Acquire)){
+ifletOk(protocol) = open_protocol::<shell::Protocol>(handle, shell::PROTOCOL_GUID){
+returnSome(protocol);
+}
+}
+
+let handles = locate_handles(shell::PROTOCOL_GUID).ok()?;
+for handle in handles {
+ifletOk(protocol) = open_protocol::<shell::Protocol>(handle, shell::PROTOCOL_GUID){
+LAST_VALID_HANDLE.store(handle.as_ptr(),Ordering::Release);
+returnSome(protocol);
+}
+}
+
+None
+}

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

@@ -125,7 +125,7 @@ pub fn error_string(errno: RawOsError) -> String {
 }
 
 pubfngetcwd() -> io::Result<PathBuf>{
-matchuefi_shell::open_shell(){
+matchhelpers::open_shell(){
 Some(shell) => {
 // SAFETY: path_ptr is managed by UEFI shell and should not be deallocated
 let path_ptr = unsafe{((*shell.as_ptr()).get_cur_dir)(crate::ptr::null_mut())};
@@ -144,7 +144,7 @@ pub fn getcwd() -> io::Result<PathBuf> {
 }
 
 pubfnchdir(p:&path::Path) -> io::Result<()>{
-let shell = uefi_shell::open_shell().ok_or(unsupported_err())?;
+let shell = helpers::open_shell().ok_or(unsupported_err())?;
 
 letmut p = helpers::os_string_to_raw(p.as_os_str())
 .ok_or(io::const_io_error!(io::ErrorKind::InvalidData,"Invalid path"))?;
@@ -192,44 +192,58 @@ pub fn current_exe() -> io::Result<PathBuf> {
  helpers::device_path_to_text(protocol).map(PathBuf::from)
 }
 
-pubstructEnv(!);
+pubstructEnvStrDebug<'a>{
+iter:&'a[(OsString,OsString)],
+}
+
+impl fmt::DebugforEnvStrDebug<'_>{
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+letmut list = f.debug_list();
+for(a, b)inself.iter{
+ list.entry(&(a.to_str().unwrap(), b.to_str().unwrap()));
+}
+ list.finish()
+}
+}
+
+pubstructEnv(crate::vec::IntoIter<(OsString,OsString)>);
 
 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 {}
+EnvStrDebug{iter:self.0.as_slice()}
 }
 }
 
 implIteratorforEnv{
 typeItem = (OsString,OsString);
+
 fnnext(&mutself) -> Option<(OsString,OsString)>{
-self.0
+self.0.next()
 }
 }
 
 impl fmt::DebugforEnv{
-fnfmt(&self, _:&mut fmt::Formatter<'_>) -> fmt::Result{
-letSelf(inner) = self;
-match*inner {}
+fnfmt(&self,f:&mut fmt::Formatter<'_>) -> fmt::Result{
+self.0.fmt(f)
 }
 }
 
 pubfnenv() -> Env{
-panic!("not supported on this platform")
+let env = uefi_env::get_all().expect("not supported on this platform");
+Env(env.into_iter())
 }
 
-pubfngetenv(_:&OsStr) -> Option<OsString>{
-None
+pubfngetenv(key:&OsStr) -> Option<OsString>{
+uefi_env::get(key)
 }
 
-pubunsafefnsetenv(_:&OsStr,_:&OsStr) -> io::Result<()>{
-Err(io::const_io_error!(io::ErrorKind::Unsupported,"cannot set env vars on this platform"))
+pubunsafefnsetenv(key:&OsStr,val:&OsStr) -> io::Result<()>{
+uefi_env::set(key, val)
 }
 
-pubunsafefnunsetenv(_:&OsStr) -> io::Result<()>{
-Err(io::const_io_error!(io::ErrorKind::Unsupported,"cannot unset env vars on this platform"))
+pubunsafefnunsetenv(key:&OsStr) -> io::Result<()>{
+uefi_env::unset(key)
 }
 
 pubfntemp_dir() -> PathBuf{
@@ -261,36 +275,84 @@ pub fn getpid() -> u32 {
 panic!("no pids on this platform")
 }
 
-moduefi_shell{
-user_efi::protocols::shell;
-
-usesuper::super::helpers;
+moduefi_env{
+usecrate::ffi::{OsStr,OsString};
+usecrate::io;
+usecrate::os::uefi::ffi::OsStringExt;
 usecrate::ptr::NonNull;
-usecrate::sync::atomic::{AtomicPtr,Ordering};
-
-pubfnopen_shell() -> Option<NonNull<shell::Protocol>>{
-staticLAST_VALID_HANDLE:AtomicPtr<crate::ffi::c_void> =
-AtomicPtr::new(crate::ptr::null_mut());
-
-ifletSome(handle) = NonNull::new(LAST_VALID_HANDLE.load(Ordering::Acquire)){
-ifletOk(protocol) = helpers::open_protocol::<shell::Protocol>(
- handle,
- r_efi::protocols::shell::PROTOCOL_GUID,
-){
-returnSome(protocol);
-}
+usecrate::sys::{helpers, unsupported_err};
+
+pub(crate)fnget(key:&OsStr) -> Option<OsString>{
+let shell = helpers::open_shell()?;
+letmut key_ptr = helpers::os_string_to_raw(key)?;
+unsafe{get_raw(shell, key_ptr.as_mut_ptr())}
+}
+
+pub(crate)fnset(key:&OsStr,val:&OsStr) -> io::Result<()>{
+letmut key_ptr = helpers::os_string_to_raw(key)
+.ok_or(io::const_io_error!(io::ErrorKind::InvalidInput,"Invalid Key"))?;
+letmut val_ptr = helpers::os_string_to_raw(val)
+.ok_or(io::const_io_error!(io::ErrorKind::InvalidInput,"Invalid Value"))?;
+unsafe{set_raw(key_ptr.as_mut_ptr(), val_ptr.as_mut_ptr())}
+}
+
+pub(crate)fnunset(key:&OsStr) -> io::Result<()>{
+letmut key_ptr = helpers::os_string_to_raw(key)
+.ok_or(io::const_io_error!(io::ErrorKind::InvalidInput,"Invalid Key"))?;
+unsafe{set_raw(key_ptr.as_mut_ptr(),crate::ptr::null_mut())}
+}
+
+pub(crate)fnget_all() -> io::Result<Vec<(OsString,OsString)>>{
+let shell = helpers::open_shell().ok_or(unsupported_err())?;
+
+letmut vars = Vec::new();
+let val = unsafe{((*shell.as_ptr()).get_env)(crate::ptr::null_mut())};
+
+if val.is_null(){
+returnOk(vars);
 }
 
-let handles = helpers::locate_handles(shell::PROTOCOL_GUID).ok()?;
-for handle in handles {
-ifletOk(protocol) =
- helpers::open_protocol::<shell::Protocol>(handle, shell::PROTOCOL_GUID)
-{
-LAST_VALID_HANDLE.store(handle.as_ptr(),Ordering::Release);
-returnSome(protocol);
+letmut start = 0;
+
+// UEFI Shell returns all keys seperated by NULL.
+// End of string is denoted by two NULLs
+for i in0.. {
+ifunsafe{*val.add(i)} == 0{
+// Two NULL signal end of string
+if i == start {
+break;
+}
+
+let key = OsString::from_wide(unsafe{
+crate::slice::from_raw_parts(val.add(start), i - start)
+});
+// SAFETY: val.add(start) is always NULL terminated
+let val = unsafe{get_raw(shell, val.add(start))}
+.ok_or(io::const_io_error!(io::ErrorKind::InvalidInput,"Invalid Value"))?;
+
+ vars.push((key, val));
+ start = i + 1;
 }
 }
 
-None
+Ok(vars)
+}
+
+unsafefnget_raw(
+shell:NonNull<r_efi::efi::protocols::shell::Protocol>,
+key_ptr:*mut r_efi::efi::Char16,
+) -> Option<OsString>{
+let val = unsafe{((*shell.as_ptr()).get_env)(key_ptr)};
+ helpers::os_string_from_raw(val)
+}
+
+unsafefnset_raw(
+key_ptr:*mut r_efi::efi::Char16,
+val_ptr:*mut r_efi::efi::Char16,
+) -> io::Result<()>{
+let shell = helpers::open_shell().ok_or(unsupported_err())?;
+let r =
+unsafe{((*shell.as_ptr()).set_env)(key_ptr, val_ptr, r_efi::efi::Boolean::FALSE)};
+if r.is_error(){Err(io::Error::from_raw_os_error(r.as_usize()))}else{Ok(())}
 }
 }