Fixes from PR

1. Make Event *mut c_void.
2. Better error messages.
3. Use OnceLock instead of OnceCell in tcp4
4. Fix File::create_new
5. Performance improvements in `sys::args` and `sys::time::Instant`
6. Only use 2 events in tcp4 now.
7. Fix incorrect uses of `size_of_val`.
8. Fix UEFI CI

Signed-off-by: Ayush Singh <[email protected]>

Author: Ayush1325

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

@@ -5,6 +5,7 @@ use crate::env::current_exe;
 use crate::ffi::OsString;
 use crate::fmt;
 use crate::path::PathBuf;
+use crate::sync::OnceLock;
 use crate::sys_common::args::{parse_lp_cmd_line, WStrUnits};
 use crate::vec;
 use r_efi::efi::protocols::loaded_image;
@@ -16,19 +17,22 @@ pub struct Args {
 // Get the Supplied arguments for loaded image.
 // Uses EFI_LOADED_IMAGE_PROTOCOL
 pub fn args() -> Args {
-    match common::get_current_handle_protocol::<loaded_image::Protocol>(loaded_image::PROTOCOL_GUID)
-    {
-        Some(x) => {
-            let lp_cmd_line = unsafe { (*x.as_ptr()).load_options as *const u16 };
-            let parsed_args_list =
+    static ARGUMENTS: OnceLock<Vec<OsString>> = OnceLock::new();
+    // Caching the arguments the first time they are parsed.
+    let vec_args = ARGUMENTS.get_or_init(|| {
+        match common::get_current_handle_protocol::<loaded_image::Protocol>(
+            loaded_image::PROTOCOL_GUID,
+        ) {
+            Some(x) => {
+                let lp_cmd_line = unsafe { (*x.as_ptr()).load_options as *const u16 };
                 parse_lp_cmd_line(unsafe { WStrUnits::new(lp_cmd_line) }, || {
                     current_exe().map(PathBuf::into_os_string).unwrap_or_else(|_| OsString::new())
-                });
-
-            Args { parsed_args_list: parsed_args_list.into_iter() }
+                })
+            }
+            None => Vec::new(),
         }
-        None => Args { parsed_args_list: Vec::new().into_iter() },
-    }
+    });
+    Args { parsed_args_list: vec_args.clone().into_iter() }
 }
 
 impl fmt::Debug for Args {

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

@@ -17,20 +17,10 @@ pub(crate) fn get_current_handle_protocol<T>(protocol_guid: Guid) -> Option<NonN
 
 #[repr(transparent)]
 pub(crate) struct Event {
-    inner: NonNull<crate::ffi::c_void>,
+    inner: r_efi::efi::Event,
 }
 
 impl Event {
-    #[inline]
-    fn new(inner: NonNull<crate::ffi::c_void>) -> Self {
-        Self { inner }
-    }
-
-    #[inline]
-    fn from_raw_event(ptr: r_efi::efi::Event) -> Option<Self> {
-        Some(Self::new(NonNull::new(ptr)?))
-    }
-
     pub(crate) fn create(
         event_type: u32,
         event_tpl: Tpl,
@@ -55,12 +45,7 @@ impl Event {
             )
         };
 
-        if r.is_error() {
-            Err(status_to_io_error(r))
-        } else {
-            Self::from_raw_event(event)
-                .ok_or(const_io_error!(io::ErrorKind::Other, "event is null"))
-        }
+        if r.is_error() { Err(status_to_io_error(r)) } else { Ok(Self { inner: event }) }
     }
 
     pub(crate) fn create_timer() -> io::Result<Event> {
@@ -117,17 +102,17 @@ impl Event {
 
     #[inline]
     pub(crate) fn as_raw_event(&self) -> r_efi::efi::Event {
-        self.inner.as_ptr()
+        self.inner
     }
 }
 
-extern "efiapi" fn empty_notify(_: r_efi::efi::Event, _: *mut crate::ffi::c_void) {}
+pub(crate) extern "efiapi" fn empty_notify(_: r_efi::efi::Event, _: *mut crate::ffi::c_void) {}
 
 impl Drop for Event {
     fn drop(&mut self) {
         let boot_services = boot_services();
         // Always returns EFI_SUCCESS
-        let _ = unsafe { ((*boot_services.as_ptr()).close_event)(self.inner.as_ptr()) };
+        let _ = unsafe { ((*boot_services.as_ptr()).close_event)(self.inner) };
     }
 }
 
@@ -296,109 +281,164 @@ pub(crate) fn status_to_io_error(s: r_efi::efi::Status) -> io::Error {
     use r_efi::efi::Status;
 
     // Keep the List in Alphabetical Order
+    // The Messages are taken from UEFI Specification Appendix D - Status Codes
     match s {
         Status::ABORTED => {
-            const_io_error!(ErrorKind::ConnectionAborted, "EFI_ABORTED")
+            const_io_error!(ErrorKind::ConnectionAborted, "The operation was aborted.")
         }
         Status::ACCESS_DENIED => {
-            const_io_error!(ErrorKind::PermissionDenied, "EFI_ACCESS_DENIED")
+            const_io_error!(ErrorKind::PermissionDenied, "Access was denied.")
         }
         Status::ALREADY_STARTED => {
-            const_io_error!(ErrorKind::Other, "EFI_ALREADY_STARTED")
+            const_io_error!(ErrorKind::Other, "The protocol has already been started.")
         }
         Status::BAD_BUFFER_SIZE => {
-            const_io_error!(ErrorKind::InvalidData, "EFI_BAD_BUFFER_SIZE")
+            const_io_error!(
+                ErrorKind::InvalidData,
+                "The buffer was not the proper size for the request."
+            )
         }
         Status::BUFFER_TOO_SMALL => {
-            const_io_error!(ErrorKind::FileTooLarge, "EFI_BUFFER_TOO_SMALL")
+            const_io_error!(
+                ErrorKind::FileTooLarge,
+                "The buffer is not large enough to hold the requested data. The required buffer size is returned in the appropriate parameter when this error occurs."
+            )
         }
         Status::COMPROMISED_DATA => {
-            const_io_error!(ErrorKind::Other, "EFI_COMPRIMISED_DATA")
+            const_io_error!(
+                ErrorKind::Other,
+                "The security status of the data is unknown or compromised and the data must be updated or replaced to restore a valid security status."
+            )
         }
         Status::CONNECTION_FIN => {
-            const_io_error!(ErrorKind::Other, "EFI_CONNECTION_FIN")
+            const_io_error!(
+                ErrorKind::Other,
+                "The receiving operation fails because the communication peer has closed the connection and there is no more data in the receive buffer of the instance."
+            )
         }
         Status::CONNECTION_REFUSED => {
-            const_io_error!(ErrorKind::ConnectionRefused, "EFI_CONNECTION_REFUSED")
+            const_io_error!(
+                ErrorKind::ConnectionRefused,
+                "The receiving or transmission operation fails because this connection is refused."
+            )
         }
         Status::CONNECTION_RESET => {
-            const_io_error!(ErrorKind::ConnectionReset, "EFI_CONNECTION_RESET")
+            const_io_error!(
+                ErrorKind::ConnectionReset,
+                "The connect fails because the connection is reset either by instance itself or the communication peer."
+            )
         }
-        Status::CRC_ERROR => const_io_error!(ErrorKind::InvalidData, "EFI_CRC_ERROR"),
-        Status::DEVICE_ERROR => const_io_error!(ErrorKind::Other, "EFI_DEVICE_ERROR"),
+        Status::CRC_ERROR => const_io_error!(ErrorKind::Other, "A CRC error was detected."),
+        Status::DEVICE_ERROR => const_io_error!(
+            ErrorKind::Other,
+            "The physical device reported an error while attempting the operation."
+        ),
         Status::END_OF_FILE => {
-            const_io_error!(ErrorKind::UnexpectedEof, "EFI_END_OF_FILE")
+            const_io_error!(ErrorKind::UnexpectedEof, "The end of the file was reached.")
         }
         Status::END_OF_MEDIA => {
-            const_io_error!(ErrorKind::UnexpectedEof, "EFI_END_OF_MEDIA")
+            const_io_error!(ErrorKind::Other, "Beginning or end of media was reached")
         }
         Status::HOST_UNREACHABLE => {
-            const_io_error!(ErrorKind::HostUnreachable, "EFI_HOST_UNREACHABLE")
+            const_io_error!(ErrorKind::HostUnreachable, "The remote host is not reachable.")
         }
         Status::HTTP_ERROR => {
-            const_io_error!(ErrorKind::NetworkUnreachable, "EFI_HTTP_ERROR")
+            const_io_error!(ErrorKind::Other, "A HTTP error occurred during the network operation.")
         }
         Status::ICMP_ERROR => {
-            const_io_error!(ErrorKind::Other, "EFI_ICMP_ERROR")
+            const_io_error!(
+                ErrorKind::Other,
+                "An ICMP error occurred during the network operation."
+            )
         }
         Status::INCOMPATIBLE_VERSION => {
-            const_io_error!(ErrorKind::Other, "EFI_INCOMPATIBLE_VERSION")
+            const_io_error!(
+                ErrorKind::Other,
+                "The function encountered an internal version that was incompatible with a version requested by the caller."
+            )
         }
         Status::INVALID_LANGUAGE => {
-            const_io_error!(ErrorKind::InvalidData, "EFI_INVALID_LANGUAGE")
+            const_io_error!(ErrorKind::InvalidData, "The language specified was invalid.")
         }
         Status::INVALID_PARAMETER => {
-            const_io_error!(ErrorKind::InvalidInput, "EFI_INVALID_PARAMETER")
+            const_io_error!(ErrorKind::InvalidInput, "A parameter was incorrect.")
         }
         Status::IP_ADDRESS_CONFLICT => {
-            const_io_error!(ErrorKind::AddrInUse, "EFI_IP_ADDRESS_CONFLICT")
+            const_io_error!(ErrorKind::AddrInUse, "There is an address conflict address allocation")
         }
         Status::LOAD_ERROR => {
-            const_io_error!(ErrorKind::Other, "EFI_LOAD_ERROR")
+            const_io_error!(ErrorKind::Other, "The image failed to load.")
         }
         Status::MEDIA_CHANGED => {
-            const_io_error!(ErrorKind::StaleNetworkFileHandle, "EFI_MEDIA_CHANGED")
+            const_io_error!(
+                ErrorKind::Other,
+                "The medium in the device has changed since the last access."
+            )
         }
         Status::NETWORK_UNREACHABLE => {
-            const_io_error!(ErrorKind::NetworkUnreachable, "EFI_NETWORK_UNREACHABLE")
+            const_io_error!(
+                ErrorKind::NetworkUnreachable,
+                "The network containing the remote host is not reachable."
+            )
         }
         Status::NO_MAPPING => {
-            const_io_error!(ErrorKind::Other, "EFI_NO_MAPPING")
+            const_io_error!(ErrorKind::Other, "A mapping to a device does not exist.")
         }
         Status::NO_MEDIA => {
-            const_io_error!(ErrorKind::Other, "EFI_NO_MEDIA")
+            const_io_error!(
+                ErrorKind::Other,
+                "The device does not contain any medium to perform the operation."
+            )
         }
         Status::NO_RESPONSE => {
-            const_io_error!(ErrorKind::HostUnreachable, "EFI_NO_RESPONSE")
+            const_io_error!(
+                ErrorKind::HostUnreachable,
+                "The server was not found or did not respond to the request."
+            )
+        }
+        Status::NOT_FOUND => const_io_error!(ErrorKind::NotFound, "The item was not found."),
+        Status::NOT_READY => {
+            const_io_error!(ErrorKind::ResourceBusy, "There is no data pending upon return.")
+        }
+        Status::NOT_STARTED => {
+            const_io_error!(ErrorKind::Other, "The protocol has not been started.")
         }
-        Status::NOT_FOUND => const_io_error!(ErrorKind::NotFound, "EFI_NOT_FOUND"),
-        Status::NOT_READY => const_io_error!(ErrorKind::ResourceBusy, "EFI_NOT_READY"),
-        Status::NOT_STARTED => const_io_error!(ErrorKind::Other, "EFI_NOT_STARTED"),
         Status::OUT_OF_RESOURCES => {
-            const_io_error!(ErrorKind::OutOfMemory, "EFI_OUT_OF_RESOURCES")
+            const_io_error!(ErrorKind::OutOfMemory, "A resource has run out.")
         }
         Status::PROTOCOL_ERROR => {
-            const_io_error!(ErrorKind::Other, "EFI_PROTOCOL_ERROR")
+            const_io_error!(
+                ErrorKind::Other,
+                "A protocol error occurred during the network operation."
+            )
         }
         Status::PROTOCOL_UNREACHABLE => {
-            const_io_error!(ErrorKind::Other, "EFI_PROTOCOL_UNREACHABLE")
+            const_io_error!(ErrorKind::Other, "An ICMP protocol unreachable error is received.")
         }
         Status::SECURITY_VIOLATION => {
-            const_io_error!(ErrorKind::PermissionDenied, "EFI_SECURITY_VIOLATION")
+            const_io_error!(
+                ErrorKind::PermissionDenied,
+                "The function was not performed due to a security violation."
+            )
+        }
+        Status::TFTP_ERROR => {
+            const_io_error!(ErrorKind::Other, "A TFTP error occurred during the network operation.")
         }
-        Status::TFTP_ERROR => const_io_error!(ErrorKind::Other, "EFI_TFTP_ERROR"),
-        Status::TIMEOUT => const_io_error!(ErrorKind::TimedOut, "EFI_TIMEOUT"),
+        Status::TIMEOUT => const_io_error!(ErrorKind::TimedOut, "The timeout time expired."),
         Status::UNSUPPORTED => {
-            const_io_error!(ErrorKind::Unsupported, "EFI_UNSUPPORTED")
+            const_io_error!(ErrorKind::Unsupported, "The operation is not supported.")
         }
         Status::VOLUME_FULL => {
-            const_io_error!(ErrorKind::StorageFull, "EFI_VOLUME_FULL")
+            const_io_error!(ErrorKind::StorageFull, "There is no more space on the file system.")
         }
         Status::VOLUME_CORRUPTED => {
-            const_io_error!(ErrorKind::Other, "EFI_VOLUME_CORRUPTED")
+            const_io_error!(
+                ErrorKind::Other,
+                "An inconstancy was detected on the file system causing the operating to fail."
+            )
         }
         Status::WRITE_PROTECTED => {
-            const_io_error!(ErrorKind::ReadOnlyFilesystem, "EFI_WRITE_PROTECTED")
+            const_io_error!(ErrorKind::ReadOnlyFilesystem, "The device cannot be written to.")
         }
         _ => io::Error::new(ErrorKind::Uncategorized, format!("Status: {}", s.as_usize())),
     }

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

@@ -256,16 +256,12 @@ impl OpenOptions {
 
 impl File {
     pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
+        if opts.create_new && uefi_fs::FileProtocol::file_exists(path)? {
+            return Err(io::const_io_error!(io::ErrorKind::AlreadyExists, "File already exists"));
+        }
         let file_opened = uefi_fs::FileProtocol::from_path(path, opts.open_mode, opts.attr)?;
         let file = File { ptr: file_opened };
-        if opts.create_new {
-            if file.file_attr()?.size != 0 {
-                return Err(io::const_io_error!(
-                    io::ErrorKind::AlreadyExists,
-                    "File already exists"
-                ));
-            }
-        } else if opts.truncate {
+        if opts.truncate {
             file.truncate(0)?;
         } else if opts.append {
             // If you truncate a file, no need to seek to end
@@ -843,8 +839,8 @@ mod uefi_fs {
 
             let file_name = common::to_ffi_string(file_name);
             let old_info = self.get_file_info()?;
-            let new_size =
-                crate::mem::size_of::<file::Info>() + crate::mem::size_of_val(&file_name);
+            let new_size = crate::mem::size_of::<file::Info>()
+                + file_name.len() * crate::mem::size_of::<u16>();
             let layout = unsafe {
                 crate::alloc::Layout::from_size_align_unchecked(new_size, POOL_ALIGNMENT)
             };
@@ -916,6 +912,19 @@ mod uefi_fs {
             }
         }
 
+        pub(crate) fn file_exists(path: &Path) -> io::Result<bool> {
+            match FileProtocol::from_path(path, file::MODE_READ, 0) {
+                Ok(_) => Ok(true),
+                Err(e) => {
+                    if e.kind() == io::ErrorKind::NotFound {
+                        Ok(false)
+                    } else {
+                        Err(e)
+                    }
+                }
+            }
+        }
+
         // Delete a file.
         pub(crate) fn delete(self) -> io::Result<()> {
             // Deleting the file makes the pointer invalid. Thus calling drop on it later will

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

@@ -134,22 +134,23 @@ unsafe fn get_random() -> Option<u64> {
     None
 }
 
-extern "C" {
-    fn main(argc: isize, argv: *const *const u8) -> isize;
-}
-
 // FIXME: Do not generate this in case of `no_main`
 #[no_mangle]
 pub unsafe extern "efiapi" fn efi_main(
     handle: r_efi::efi::Handle,
     st: *mut r_efi::efi::SystemTable,
 ) -> r_efi::efi::Status {
-    let system_table = NonNull::new(st).unwrap();
-    let image_handle = NonNull::new(handle).unwrap();
+    extern "C" {
+        fn main(argc: isize, argv: *const *const u8) -> isize;
+    }
+
+    let (system_table, image_handle) = match (NonNull::new(st), NonNull::new(handle)) {
+        (Some(x), Some(y)) => (x, y),
+        _ => return r_efi::efi::Status::ABORTED,
+    };
     unsafe { uefi::env::init_globals(image_handle, system_table.cast()) };
 
     let res = unsafe { main(0, crate::ptr::null()) };
-
     match usize::try_from(res) {
         Ok(x) => r_efi::efi::Status::from_usize(x),
         Err(_) => r_efi::efi::Status::ABORTED,