Fixes from PR

1. Make Errors constant
2. Fix UCS-2 conversions: char is UTF-32, and not UTF-8. Thus converting UCS-2
   to and from char can be done using basic u32 to conversions.
3. Use String and str intenally in `os_str`

Signed-off-by: Ayush Singh <ayushsingh1325@gmail.com>

library/std/src/io/mod.rs

@@ -287,7 +287,7 @@ pub(crate) use error::const_io_error;
 mod buffered;
 pub(crate) mod copy;
 mod cursor;
-mod error;
+pub(crate) mod error;
 mod impls;
 pub mod prelude;
 mod readbuf;
@@ -2406,11 +2406,7 @@ impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
     }
 
     fn consume(&mut self, amt: usize) {
-        if !self.done_first {
-            self.first.consume(amt)
-        } else {
-            self.second.consume(amt)
-        }
+        if !self.done_first { self.first.consume(amt) } else { self.second.consume(amt) }
     }
 }
 

library/std/src/os/uefi/env.rs

@@ -6,7 +6,7 @@ use crate::io;
 use crate::mem::MaybeUninit;
 use crate::ptr::NonNull;
 use crate::sync::atomic::{AtomicPtr, Ordering};
-use r_efi::efi::{Guid, Handle, Status};
+use r_efi::efi::{Guid, Handle};
 use r_efi::system;
 
 static GLOBAL_SYSTEM_TABLE: AtomicPtr<SystemTable> = AtomicPtr::new(crate::ptr::null_mut());
@@ -48,35 +48,14 @@ pub fn get_runtime_services() -> Option<NonNull<RuntimeServices>> {
     NonNull::new(runtime_services)
 }
 
-/// Get the Protocol for current system handle.
-/// Note: Some protocols need to be manually freed. It is the callers responsibility to do so.
-pub(crate) fn get_current_handle_protocol<T>(protocol_guid: &mut Guid) -> Option<NonNull<T>> {
-    let system_handle = get_system_handle()?;
-    get_handle_protocol(system_handle, protocol_guid)
-}
-
-pub(crate) fn get_handle_protocol<T>(
-    handle: NonNull<c_void>,
-    protocol_guid: &mut Guid,
-) -> Option<NonNull<T>> {
-    let boot_services = get_boot_services()?;
-    let mut protocol: *mut c_void = crate::ptr::null_mut();
-
-    let r = unsafe {
-        ((*boot_services.as_ptr()).handle_protocol)(handle.as_ptr(), protocol_guid, &mut protocol)
-    };
-
-    if r.is_error() { None } else { NonNull::new(protocol.cast()) }
-}
-
 pub(crate) fn open_protocol<T>(
     handle: NonNull<c_void>,
     mut protocol_guid: Guid,
 ) -> io::Result<NonNull<T>> {
     let boot_services = get_boot_services()
-        .ok_or(io::Error::new(io::ErrorKind::Other, "Failed to get BootServices"))?;
+        .ok_or(io::error::const_io_error!(io::ErrorKind::Other, "Failed to get BootServices"))?;
     let system_handle = get_system_handle()
-        .ok_or(io::Error::new(io::ErrorKind::Other, "Failed to get System Handle"))?;
+        .ok_or(io::error::const_io_error!(io::ErrorKind::Other, "Failed to get System Handle"))?;
     let mut protocol: MaybeUninit<*mut T> = MaybeUninit::uninit();
 
     let r = unsafe {
@@ -91,27 +70,10 @@ pub(crate) fn open_protocol<T>(
     };
 
     if r.is_error() {
-        match r {
-            Status::INVALID_PARAMETER => {
-                Err(io::Error::new(io::ErrorKind::InvalidInput, "EFI_INVALID_PARAMETER"))
-            }
-            Status::UNSUPPORTED => {
-                Err(io::Error::new(io::ErrorKind::Unsupported, "Handle does not support Protocol"))
-            }
-            Status::ACCESS_DENIED => {
-                Err(io::Error::new(io::ErrorKind::PermissionDenied, "EFI_ACCESS_DENIED"))
-            }
-            Status::ALREADY_STARTED => {
-                Err(io::Error::new(io::ErrorKind::Other, "EFI_ALREADY_STARTED"))
-            }
-            _ => Err(io::Error::new(
-                io::ErrorKind::Uncategorized,
-                format!("Status: {}", r.as_usize()),
-            )),
-        }
+        Err(super::io::status_to_io_error(r))
     } else {
         NonNull::new(unsafe { protocol.assume_init() })
-            .ok_or(io::Error::new(io::ErrorKind::Other, "Null Protocol"))
+            .ok_or(io::error::const_io_error!(io::ErrorKind::Other, "Null Protocol"))
     }
 }
 
@@ -132,30 +94,13 @@ pub(crate) fn locate_handles(mut guid: Guid) -> io::Result<Vec<NonNull<c_void>>>
             )
         };
 
-        if r.is_error() {
-            match r {
-                Status::NOT_FOUND => {
-                    Err(io::Error::new(io::ErrorKind::NotFound, "No handles match the search"))
-                }
-                Status::BUFFER_TOO_SMALL => Err(io::Error::new(
-                    io::ErrorKind::InvalidData,
-                    "The BufferSize is too small for the result",
-                )),
-                Status::INVALID_PARAMETER => {
-                    Err(io::Error::new(io::ErrorKind::InvalidInput, "EFI_INVALID_PARAMETER"))
-                }
-                _ => Err(io::Error::new(
-                    io::ErrorKind::Uncategorized,
-                    format!("Status: {}", r.as_usize()),
-                )),
-            }
-        } else {
-            Ok(())
-        }
+        if r.is_error() { Err(super::io::status_to_io_error(r)) } else { Ok(()) }
     }
 
-    let boot_services = get_boot_services()
-        .ok_or(io::Error::new(io::ErrorKind::Other, "Unable to acquire boot services"))?;
+    let boot_services = get_boot_services().ok_or(io::error::const_io_error!(
+        io::ErrorKind::Other,
+        "Unable to acquire boot services"
+    ))?;
     let mut buf_len = 0usize;
 
     match inner(&mut guid, boot_services, &mut buf_len, crate::ptr::null_mut()) {

library/std/src/os/uefi/io.rs

@@ -0,0 +1,55 @@
+use r_efi::efi::Status;
+
+use crate::io::{self, ErrorKind};
+
+pub(crate) fn status_to_io_error(s: r_efi::efi::Status) -> io::Error {
+    match s {
+        Status::INVALID_PARAMETER => {
+            io::error::const_io_error!(ErrorKind::InvalidInput, "EFI_INVALID_PARAMETER")
+        }
+        Status::UNSUPPORTED => {
+            io::error::const_io_error!(ErrorKind::Unsupported, "EFI_UNSUPPORTED")
+        }
+        Status::BAD_BUFFER_SIZE => {
+            io::error::const_io_error!(ErrorKind::InvalidData, "EFI_BAD_BUFFER_SIZE")
+        }
+        Status::INVALID_LANGUAGE => {
+            io::error::const_io_error!(ErrorKind::InvalidData, "EFI_INVALID_LANGUAGE")
+        }
+        Status::CRC_ERROR => io::error::const_io_error!(ErrorKind::InvalidData, "EFI_CRC_ERROR"),
+        Status::BUFFER_TOO_SMALL => {
+            io::error::const_io_error!(ErrorKind::FileTooLarge, "EFI_BUFFER_TOO_SMALL")
+        }
+        Status::NOT_READY => io::error::const_io_error!(ErrorKind::ResourceBusy, "EFI_NOT_READY"),
+        Status::WRITE_PROTECTED => {
+            io::error::const_io_error!(ErrorKind::ReadOnlyFilesystem, "EFI_WRITE_PROTECTED")
+        }
+        Status::VOLUME_FULL => {
+            io::error::const_io_error!(ErrorKind::StorageFull, "EFI_VOLUME_FULL")
+        }
+        Status::MEDIA_CHANGED => {
+            io::error::const_io_error!(ErrorKind::StaleNetworkFileHandle, "EFI_MEDIA_CHANGED")
+        }
+        Status::NOT_FOUND => io::error::const_io_error!(ErrorKind::NotFound, "EFI_NOT_FOUND"),
+        Status::ACCESS_DENIED => {
+            io::error::const_io_error!(ErrorKind::PermissionDenied, "EFI_ACCESS_DENIED")
+        }
+        Status::SECURITY_VIOLATION => {
+            io::error::const_io_error!(ErrorKind::PermissionDenied, "EFI_SECURITY_VIOLATION")
+        }
+        Status::NO_RESPONSE => {
+            io::error::const_io_error!(ErrorKind::HostUnreachable, "EFI_NO_RESPONSE")
+        }
+        Status::TIMEOUT => io::error::const_io_error!(ErrorKind::TimedOut, "EFI_TIMEOUT"),
+        Status::END_OF_FILE => {
+            io::error::const_io_error!(ErrorKind::UnexpectedEof, "EFI_END_OF_FILE")
+        }
+        Status::IP_ADDRESS_CONFLICT => {
+            io::error::const_io_error!(ErrorKind::AddrInUse, "EFI_IP_ADDRESS_CONFLICT")
+        }
+        Status::HTTP_ERROR => {
+            io::error::const_io_error!(ErrorKind::NetworkUnreachable, "EFI_HTTP_ERROR")
+        }
+        _ => io::Error::new(ErrorKind::Uncategorized, format!("Status: {}", s.as_usize())),
+    }
+}

library/std/src/os/uefi/mod.rs

@@ -4,7 +4,7 @@
 
 pub mod env;
 pub mod ffi;
+pub mod io;
 pub mod net;
 pub mod path;
 pub mod raw;
-pub mod thread;

library/std/src/os/uefi/path.rs

@@ -44,7 +44,10 @@ impl TryFrom<NonNull<device_path::Protocol>> for PathBuf {
             let mut path = String::new();
             for c in ucs2_iter {
                 let ch = char::from(ucs2::Ucs2Char::from_u16(u16::from(c)).ok_or(
-                    io::Error::new(io::ErrorKind::InvalidData, "Invalid Device Path Text"),
+                    io::error::const_io_error!(
+                        io::ErrorKind::InvalidData,
+                        "Invalid Device Path Text"
+                    ),
                 )?);
                 path.push(ch);
                 len += 1;
@@ -58,7 +61,7 @@ impl TryFrom<NonNull<device_path::Protocol>> for PathBuf {
             }
             return Ok(PathBuf::from(path));
         }
-        Err(crate::io::Error::new(
+        Err(crate::io::error::const_io_error!(
             crate::io::ErrorKind::InvalidData,
             "Failed to Convert to text representation",
         ))
@@ -92,7 +95,7 @@ impl TryFrom<&OsStr> for DevicePath {
             };
             let device_path = match NonNull::new(device_path) {
                 None => {
-                    return Err(io::Error::new(
+                    return Err(io::error::const_io_error!(
                         io::ErrorKind::Uncategorized,
                         "Null DevicePath Returned",
                     ));
@@ -105,7 +108,7 @@ impl TryFrom<&OsStr> for DevicePath {
                     .unwrap();
             return Ok(DevicePath::new(device_path, layout));
         }
-        Err(crate::io::Error::new(
+        Err(crate::io::error::const_io_error!(
             crate::io::ErrorKind::InvalidData,
             "Failed to Convert to text representation",
         ))

library/std/src/os/uefi/raw.rs

@@ -21,11 +21,17 @@ impl<T> VariableSizeType<T> {
     }
 
     pub(crate) fn from_size(size: usize) -> io::Result<Self> {
-        let layout = Layout::from_size_align(size, Self::ALIGNMENT)
-            .map_err(|_| io::Error::new(io::ErrorKind::Uncategorized, "Invalid buffer size"))?;
+        let layout = Layout::from_size_align(size, Self::ALIGNMENT).map_err(|_| {
+            io::error::const_io_error!(io::ErrorKind::Uncategorized, "Invalid buffer size")
+        })?;
         let inner: NonNull<T> = Global
             .allocate(layout)
-            .map_err(|_| io::Error::new(io::ErrorKind::Uncategorized, "Failed to allocate Buffer"))?
+            .map_err(|_| {
+                io::error::const_io_error!(
+                    io::ErrorKind::Uncategorized,
+                    "Failed to allocate Buffer"
+                )
+            })?
             .cast();
         Ok(Self::new(inner, layout))
     }

library/std/src/sys/uefi/args.rs

@@ -1,7 +1,8 @@
+use super::common;
 use crate::ffi::OsString;
 use crate::fmt;
 use crate::num::NonZeroU16;
-use crate::os::uefi::{self, ffi::OsStringExt};
+use crate::os::uefi::ffi::OsStringExt;
 use crate::sys_common::ucs2::Ucs2Units;
 use crate::vec;
 use core::iter;
@@ -14,7 +15,7 @@ pub fn args() -> Args {
     use r_efi::efi::protocols::loaded_image;
 
     let mut protocol_guid = loaded_image::PROTOCOL_GUID;
-    match uefi::env::get_current_handle_protocol::<loaded_image::Protocol>(&mut protocol_guid) {
+    match common::get_current_handle_protocol::<loaded_image::Protocol>(&mut protocol_guid) {
         Some(x) => {
             let lp_cmd_line = unsafe { (*x.as_ptr()).load_options as *const u16 };
             let parsed_args_list =