From 48c6ae0611ec6fb4094a24610982ddefde16e20f Mon Sep 17 00:00:00 2001 From: Ayush Singh Date: Sun, 18 Dec 2022 09:54:54 +0530 Subject: Add Minimal Std implementation for UEFI Implemented modules: 1. alloc 2. os_str 3. env 4. math Tracking Issue: https://github.com/rust-lang/rust/issues/100499 API Change Proposal: https://github.com/rust-lang/libs-team/issues/87 This was originally part of https://github.com/rust-lang/rust/pull/100316. Since that PR was becoming too unwieldy and cluttered, and with suggestion from @dvdhrm, I have extracted a minimal std implementation to this PR. Signed-off-by: Ayush Singh --- src/doc/rustc/src/platform-support/unknown-uefi.md | 72 +++++++++++++++++++++- 1 file changed, 70 insertions(+), 2 deletions(-) (limited to 'src/doc/rustc') diff --git a/src/doc/rustc/src/platform-support/unknown-uefi.md b/src/doc/rustc/src/platform-support/unknown-uefi.md index 03fa284620e..8d4d60e12fb 100644 --- a/src/doc/rustc/src/platform-support/unknown-uefi.md +++ b/src/doc/rustc/src/platform-support/unknown-uefi.md @@ -19,8 +19,8 @@ Available targets: ## Requirements All UEFI targets can be used as `no-std` environments via cross-compilation. -Support for `std` is missing, but actively worked on. `alloc` is supported if -an allocator is provided by the user. No host tools are supported. +Support for `std` is present, but incomplete and extreamly new. `alloc` is supported if +an allocator is provided by the user or if using std. No host tools are supported. The UEFI environment resembles the environment for Microsoft Windows, with some minor differences. Therefore, cross-compiling for UEFI works with the same @@ -230,3 +230,71 @@ pub extern "C" fn main(_h: efi::Handle, st: *mut efi::SystemTable) -> efi::Statu efi::Status::SUCCESS } ``` + +## Rust std for UEFI +This section contains information on how to use std on UEFI. + +### Build std +The building std part is pretty much the same as the official [docs](https://rustc-dev-guide.rust-lang.org/getting-started.html). +The linker that should be used is `rust-lld`. Here is a sample `config.toml`: +```toml +[llvm] +download-ci-llvm = false +[rust] +lld = true +[target.x86_64-unknown-uefi] +linker = "rust-lld" +``` +Then just build using `x.py`: +```sh +./x.py build --target x86_64-unknown-uefi +``` + +### Std Requirements +The current std has a few basic requirements to function: +1. Memory Allocation Services (`EFI_BOOT_SERVICES.AllocatePool()` and + `EFI_BOOT_SERVICES.FreePool()`) are available. +If the above requirement is satisfied, the Rust code will reach `main`. +Now we will discuss what the different modules of std use in UEFI. + +### Implemented features +#### alloc +- Implemented using `EFI_BOOT_SERVICES.AllocatePool()` and `EFI_BOOT_SERVICES.FreePool()`. +- Passes all the tests. +- Some Quirks: + - Currently uses `EfiLoaderData` as the `EFI_ALLOCATE_POOL->PoolType`. +#### cmath +- Provided by compiler-builtins. +#### env +- Just some global consants. +#### locks +- Uses `unsupported/locks`. +- They should work for a platform without threads according to docs. +#### os_str +- Uses WTF-8 from windows. + +## Example: Hello World With std +The following code is a valid UEFI application showing stdio in UEFI. It also +uses `alloc` type `OsString` and `Vec`. + +This example can be compiled as binary crate via `cargo` using the toolchain +compiled from the above source (named custom): + +```sh +cargo +custom build --target x86_64-unknown-uefi +``` + +```rust,ignore (platform-specific) +use r_efi::efi; +use std::os::uefi::ffi::OsStrExt; +use std::{ffi::OsString, panic}; + +pub fn main() { + let st = std::os::uefi::env::system_table().as_ptr() as *mut efi::SystemTable; + let mut s: Vec = OsString::from("Hello World!\n").encode_wide().collect(); + s.push(0); + let r = + unsafe { ((*(*st).con_out).output_string)((*st).con_out, s.as_ptr() as *mut efi::Char16) }; + assert!(!r.is_error()) +} +``` -- cgit 1.4.1-3-g733a5 From 8e56b33d59593a99fdef6f73f0c1a09a012ca907 Mon Sep 17 00:00:00 2001 From: Ayush Singh Date: Sat, 28 Jan 2023 23:37:54 +0530 Subject: Fixes from PR Signed-off-by: Ayush Singh --- library/std/src/os/uefi/env.rs | 11 +- library/std/src/sys/uefi/alloc.rs | 12 +- library/std/src/sys/uefi/common.rs | 269 -------------------- library/std/src/sys/uefi/helpers.rs | 280 +++++++++++++++++++++ library/std/src/sys/uefi/mod.rs | 24 +- library/std/src/sys_common/mod.rs | 1 - src/doc/rustc/src/platform-support/unknown-uefi.md | 44 ++-- 7 files changed, 326 insertions(+), 315 deletions(-) delete mode 100644 library/std/src/sys/uefi/common.rs create mode 100644 library/std/src/sys/uefi/helpers.rs (limited to 'src/doc/rustc') diff --git a/library/std/src/os/uefi/env.rs b/library/std/src/os/uefi/env.rs index 479ff5f6975..71bf0ff8ff3 100644 --- a/library/std/src/os/uefi/env.rs +++ b/library/std/src/os/uefi/env.rs @@ -1,5 +1,7 @@ //! UEFI-specific extensions to the primitives in `std::env` module +#![unstable(feature = "uefi_std", issue = "100499")] + use crate::ffi::c_void; use crate::ptr::NonNull; use crate::sync::atomic::{AtomicPtr, Ordering}; @@ -22,21 +24,18 @@ static GLOBALS: OnceLock<(AtomicPtr, AtomicPtr)> = OnceLock::new /// standard library is loaded. /// /// This function must not be called more than once. -#[unstable(feature = "uefi_std", issue = "100499")] pub unsafe fn init_globals(handle: NonNull, system_table: NonNull) { GLOBALS.set((AtomicPtr::new(system_table.as_ptr()), AtomicPtr::new(handle.as_ptr()))).unwrap() } /// Get the SystemTable Pointer. -/// Note: This function panics if the System Table and Image Handle is Not initialized -#[unstable(feature = "uefi_std", issue = "100499")] +/// Note: This function panics if the System Table or Image Handle is not initialized pub fn system_table() -> NonNull { try_system_table().unwrap() } -/// Get the SystemHandle Pointer. -/// Note: This function panics if the System Table and Image Handle is Not initialized -#[unstable(feature = "uefi_std", issue = "100499")] +/// Get the ImageHandle Pointer. +/// Note: This function panics if the System Table or Image Handle is not initialized pub fn image_handle() -> NonNull { try_image_handle().unwrap() } diff --git a/library/std/src/sys/uefi/alloc.rs b/library/std/src/sys/uefi/alloc.rs index 6a14ee76e92..54d86d0c8a7 100644 --- a/library/std/src/sys/uefi/alloc.rs +++ b/library/std/src/sys/uefi/alloc.rs @@ -13,11 +13,8 @@ unsafe impl GlobalAlloc for System { Some(x) => x.as_ptr() as *mut _, }; - if layout.size() > 0 { - unsafe { r_efi_alloc::raw::alloc(system_table, layout, MEMORY_TYPE) } - } else { - layout.dangling().as_ptr() - } + // The caller must ensure non-0 layout + unsafe { r_efi_alloc::raw::alloc(system_table, layout, MEMORY_TYPE) } } unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { @@ -25,8 +22,7 @@ unsafe impl GlobalAlloc for System { None => handle_alloc_error(layout), Some(x) => x.as_ptr() as *mut _, }; - if layout.size() > 0 { - unsafe { r_efi_alloc::raw::dealloc(system_table, ptr, layout) } - } + // The caller must ensure non-0 layout + unsafe { r_efi_alloc::raw::dealloc(system_table, ptr, layout) } } } diff --git a/library/std/src/sys/uefi/common.rs b/library/std/src/sys/uefi/common.rs deleted file mode 100644 index 6316a74d367..00000000000 --- a/library/std/src/sys/uefi/common.rs +++ /dev/null @@ -1,269 +0,0 @@ -//! Contains most of the shared UEFI specific stuff. Some of this might be moved to `std::os::uefi` -//! if needed but no point in adding extra public API when there is not Std support for UEFI in the -//! first place - -use r_efi::efi::Guid; - -use crate::io::{self, const_io_error}; -use crate::mem::MaybeUninit; -use crate::os::uefi; -use crate::ptr::NonNull; - -// Locate handles with a particular protocol GUID -/// Implemented using `EFI_BOOT_SERVICES.LocateHandles()` -pub(crate) fn locate_handles(mut guid: Guid) -> io::Result>> { - fn inner( - guid: &mut Guid, - boot_services: NonNull, - buf_size: &mut usize, - buf: *mut r_efi::efi::Handle, - ) -> io::Result<()> { - let r = unsafe { - ((*boot_services.as_ptr()).locate_handle)( - r_efi::efi::BY_PROTOCOL, - guid, - crate::ptr::null_mut(), - buf_size, - buf, - ) - }; - - if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) } - } - - let boot_services = boot_services(); - let mut buf_len = 0usize; - - match inner(&mut guid, boot_services, &mut buf_len, crate::ptr::null_mut()) { - Ok(()) => unreachable!(), - Err(e) => match e.kind() { - io::ErrorKind::FileTooLarge => {} - _ => return Err(e), - }, - } - - // The returned buf_len is in bytes - let mut buf: Vec = - Vec::with_capacity(buf_len / crate::mem::size_of::()); - match inner(&mut guid, boot_services, &mut buf_len, buf.as_mut_ptr()) { - Ok(()) => { - // SAFETY: This is safe because the call will succeed only if buf_len >= required - // length. Also, on success, the `buf_len` is updated with the size of bufferv (in - // bytes) written - unsafe { buf.set_len(buf_len / crate::mem::size_of::()) }; - Ok(buf.iter().filter_map(|x| NonNull::new(*x)).collect()) - } - Err(e) => Err(e), - } -} - -/// Open Protocol on a handle -/// Implemented using `EFI_BOOT_SERVICES.OpenProtocol()` -pub(crate) fn open_protocol( - handle: NonNull, - mut protocol_guid: Guid, -) -> io::Result> { - let boot_services = boot_services(); - let system_handle = uefi::env::image_handle(); - let mut protocol: MaybeUninit<*mut T> = MaybeUninit::uninit(); - - let r = unsafe { - ((*boot_services.as_ptr()).open_protocol)( - handle.as_ptr(), - &mut protocol_guid, - protocol.as_mut_ptr().cast(), - system_handle.as_ptr(), - crate::ptr::null_mut(), - r_efi::system::OPEN_PROTOCOL_GET_PROTOCOL, - ) - }; - - if r.is_error() { - Err(status_to_io_error(r)) - } else { - NonNull::new(unsafe { protocol.assume_init() }) - .ok_or(const_io_error!(io::ErrorKind::Other, "null protocol")) - } -} - -pub(crate) fn status_to_io_error(s: r_efi::efi::Status) -> io::Error { - use io::ErrorKind; - 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, "The operation was aborted.") - } - Status::ACCESS_DENIED => { - const_io_error!(ErrorKind::PermissionDenied, "Access was denied.") - } - Status::ALREADY_STARTED => { - const_io_error!(ErrorKind::Other, "The protocol has already been started.") - } - Status::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, - "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, - "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, - "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, - "The receiving or transmission operation fails because this connection is refused." - ) - } - Status::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::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, "The end of the file was reached.") - } - Status::END_OF_MEDIA => { - const_io_error!(ErrorKind::Other, "Beginning or end of media was reached") - } - Status::HOST_UNREACHABLE => { - const_io_error!(ErrorKind::HostUnreachable, "The remote host is not reachable.") - } - Status::HTTP_ERROR => { - const_io_error!(ErrorKind::Other, "A HTTP error occurred during the network operation.") - } - Status::ICMP_ERROR => { - const_io_error!( - ErrorKind::Other, - "An ICMP error occurred during the network operation." - ) - } - Status::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, "The language specified was invalid.") - } - Status::INVALID_PARAMETER => { - const_io_error!(ErrorKind::InvalidInput, "A parameter was incorrect.") - } - Status::IP_ADDRESS_CONFLICT => { - const_io_error!(ErrorKind::AddrInUse, "There is an address conflict address allocation") - } - Status::LOAD_ERROR => { - const_io_error!(ErrorKind::Other, "The image failed to load.") - } - Status::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, - "The network containing the remote host is not reachable." - ) - } - Status::NO_MAPPING => { - const_io_error!(ErrorKind::Other, "A mapping to a device does not exist.") - } - Status::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, - "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::OUT_OF_RESOURCES => { - const_io_error!(ErrorKind::OutOfMemory, "A resource has run out.") - } - Status::PROTOCOL_ERROR => { - const_io_error!( - ErrorKind::Other, - "A protocol error occurred during the network operation." - ) - } - Status::PROTOCOL_UNREACHABLE => { - const_io_error!(ErrorKind::Other, "An ICMP protocol unreachable error is received.") - } - Status::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::TIMEOUT => const_io_error!(ErrorKind::TimedOut, "The timeout time expired."), - Status::UNSUPPORTED => { - const_io_error!(ErrorKind::Unsupported, "The operation is not supported.") - } - Status::VOLUME_FULL => { - const_io_error!(ErrorKind::StorageFull, "There is no more space on the file system.") - } - Status::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, "The device cannot be written to.") - } - _ => io::Error::new(ErrorKind::Uncategorized, format!("Status: {}", s.as_usize())), - } -} - -/// Get the BootServices Pointer. -pub(crate) fn boot_services() -> NonNull { - let system_table: NonNull = uefi::env::system_table().cast(); - let boot_services = unsafe { (*system_table.as_ptr()).boot_services }; - NonNull::new(boot_services).unwrap() -} -/// Get the BootServices Pointer. -/// This function is mostly intended for places where panic is not an option -pub(crate) fn try_boot_services() -> Option> { - let system_table: NonNull = uefi::env::try_system_table()?.cast(); - let boot_services = unsafe { (*system_table.as_ptr()).boot_services }; - NonNull::new(boot_services) -} diff --git a/library/std/src/sys/uefi/helpers.rs b/library/std/src/sys/uefi/helpers.rs new file mode 100644 index 00000000000..e83adabaf16 --- /dev/null +++ b/library/std/src/sys/uefi/helpers.rs @@ -0,0 +1,280 @@ +//! Contains most of the shared UEFI specific stuff. Some of this might be moved to `std::os::uefi` +//! if needed but no point in adding extra public API when there is not Std support for UEFI in the +//! first place +//! +//! Some Nomenclature +//! * Protocol: +//! - Protocols serve to enable communication between separately built modules, including drivers. +//! - Every protocol has a GUID associated with it. The GUID serves as the name for the protocol. +//! - Protocols are produced and consumed. +//! - 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::Guid; + +use crate::io::{self, const_io_error}; +use crate::mem::{size_of, MaybeUninit}; +use crate::os::uefi; +use crate::ptr::NonNull; + +/// Locate Handles with a particular Protocol GUID +/// Implemented using `EFI_BOOT_SERVICES.LocateHandles()` +/// +/// Returns an array of [Handles](r_efi::efi::Handle) that support a specified protocol. +pub(crate) fn locate_handles(mut guid: Guid) -> io::Result>> { + fn inner( + guid: &mut Guid, + boot_services: NonNull, + buf_size: &mut usize, + buf: *mut r_efi::efi::Handle, + ) -> io::Result<()> { + let r = unsafe { + ((*boot_services.as_ptr()).locate_handle)( + r_efi::efi::BY_PROTOCOL, + guid, + crate::ptr::null_mut(), + buf_size, + buf, + ) + }; + + if r.is_error() { Err(status_to_io_error(r)) } else { Ok(()) } + } + + let boot_services = boot_services(); + let mut buf_len = 0usize; + + // This should always fail since the size of buffer is 0. This call should update the buf_len + // variable with the required buffer length + match inner(&mut guid, boot_services, &mut buf_len, crate::ptr::null_mut()) { + Ok(()) => unreachable!(), + Err(e) => match e.kind() { + io::ErrorKind::FileTooLarge => {} + _ => return Err(e), + }, + } + + // The returned buf_len is in bytes + let mut buf: Vec = + Vec::with_capacity(buf_len / size_of::()); + match inner(&mut guid, boot_services, &mut buf_len, buf.as_mut_ptr()) { + Ok(()) => { + // This is safe because the call will succeed only if buf_len >= required length. + // Also, on success, the `buf_len` is updated with the size of bufferv (in bytes) written + unsafe { buf.set_len(buf_len / size_of::()) }; + Ok(buf.into_iter().filter_map(|x| NonNull::new(x)).collect()) + } + Err(e) => Err(e), + } +} + +/// Open Protocol on a handle. +/// Internally just a call to `EFI_BOOT_SERVICES.OpenProtocol()`. +/// +/// Queries a handle to determine if it supports a specified protocol. If the protocol is +/// supported by the handle, it opens the protocol on behalf of the calling agent. +pub(crate) fn open_protocol( + handle: NonNull, + mut protocol_guid: Guid, +) -> io::Result> { + let boot_services = boot_services(); + let system_handle = uefi::env::image_handle(); + let mut protocol: MaybeUninit<*mut T> = MaybeUninit::uninit(); + + let r = unsafe { + ((*boot_services.as_ptr()).open_protocol)( + handle.as_ptr(), + &mut protocol_guid, + protocol.as_mut_ptr().cast(), + system_handle.as_ptr(), + crate::ptr::null_mut(), + r_efi::system::OPEN_PROTOCOL_GET_PROTOCOL, + ) + }; + + if r.is_error() { + Err(status_to_io_error(r)) + } else { + NonNull::new(unsafe { protocol.assume_init() }) + .ok_or(const_io_error!(io::ErrorKind::Other, "null protocol")) + } +} + +pub(crate) fn status_to_io_error(s: r_efi::efi::Status) -> io::Error { + use io::ErrorKind; + 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, "The operation was aborted.") + } + Status::ACCESS_DENIED => { + const_io_error!(ErrorKind::PermissionDenied, "Access was denied.") + } + Status::ALREADY_STARTED => { + const_io_error!(ErrorKind::Other, "The protocol has already been started.") + } + Status::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, + "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, + "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, + "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, + "The receiving or transmission operation fails because this connection is refused." + ) + } + Status::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::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, "The end of the file was reached.") + } + Status::END_OF_MEDIA => { + const_io_error!(ErrorKind::Other, "Beginning or end of media was reached") + } + Status::HOST_UNREACHABLE => { + const_io_error!(ErrorKind::HostUnreachable, "The remote host is not reachable.") + } + Status::HTTP_ERROR => { + const_io_error!(ErrorKind::Other, "A HTTP error occurred during the network operation.") + } + Status::ICMP_ERROR => { + const_io_error!( + ErrorKind::Other, + "An ICMP error occurred during the network operation." + ) + } + Status::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, "The language specified was invalid.") + } + Status::INVALID_PARAMETER => { + const_io_error!(ErrorKind::InvalidInput, "A parameter was incorrect.") + } + Status::IP_ADDRESS_CONFLICT => { + const_io_error!(ErrorKind::AddrInUse, "There is an address conflict address allocation") + } + Status::LOAD_ERROR => { + const_io_error!(ErrorKind::Other, "The image failed to load.") + } + Status::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, + "The network containing the remote host is not reachable." + ) + } + Status::NO_MAPPING => { + const_io_error!(ErrorKind::Other, "A mapping to a device does not exist.") + } + Status::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, + "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::OUT_OF_RESOURCES => { + const_io_error!(ErrorKind::OutOfMemory, "A resource has run out.") + } + Status::PROTOCOL_ERROR => { + const_io_error!( + ErrorKind::Other, + "A protocol error occurred during the network operation." + ) + } + Status::PROTOCOL_UNREACHABLE => { + const_io_error!(ErrorKind::Other, "An ICMP protocol unreachable error is received.") + } + Status::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::TIMEOUT => const_io_error!(ErrorKind::TimedOut, "The timeout time expired."), + Status::UNSUPPORTED => { + const_io_error!(ErrorKind::Unsupported, "The operation is not supported.") + } + Status::VOLUME_FULL => { + const_io_error!(ErrorKind::StorageFull, "There is no more space on the file system.") + } + Status::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, "The device cannot be written to.") + } + _ => io::Error::new(ErrorKind::Uncategorized, format!("Status: {}", s.as_usize())), + } +} + +/// Get the BootServices Pointer. +pub(crate) fn boot_services() -> NonNull { + try_boot_services().unwrap() +} +/// Get the BootServices Pointer. +/// This function is mostly intended for places where panic is not an option +pub(crate) fn try_boot_services() -> Option> { + let system_table: NonNull = uefi::env::try_system_table()?.cast(); + let boot_services = unsafe { (*system_table.as_ptr()).boot_services }; + NonNull::new(boot_services) +} diff --git a/library/std/src/sys/uefi/mod.rs b/library/std/src/sys/uefi/mod.rs index 193d4ecc16f..fed44b4f49d 100644 --- a/library/std/src/sys/uefi/mod.rs +++ b/library/std/src/sys/uefi/mod.rs @@ -47,7 +47,7 @@ pub mod thread_local_key; #[path = "../unsupported/time.rs"] pub mod time; -pub(crate) mod common; +pub(crate) mod helpers; #[cfg(test)] mod tests; @@ -60,18 +60,20 @@ pub mod memchr { pub use core::slice::memchr::{memchr, memrchr}; } -// SAFETY: must be called only once during runtime initialization. -// SAFETY: argc must be 2. -// SAFETY: argv must be &[Handle, *mut SystemTable]. -pub unsafe fn init(argc: isize, argv: *const *const u8, _sigpipe: u8) { +/// # SAFETY +/// - must be called only once during runtime initialization. +/// - argc must be 2. +/// - argv must be &[Handle, *mut SystemTable]. +pub(crate) unsafe fn init(argc: isize, argv: *const *const u8, _sigpipe: u8) { assert_eq!(argc, 2); let image_handle = unsafe { NonNull::new(*argv as *mut crate::ffi::c_void).unwrap() }; let system_table = unsafe { NonNull::new(*argv.add(1) as *mut crate::ffi::c_void).unwrap() }; unsafe { crate::os::uefi::env::init_globals(image_handle, system_table) }; } -// SAFETY: must be called only once during runtime cleanup. -// NOTE: this is not guaranteed to run, for example when the program aborts. +/// # SAFETY +/// this is not guaranteed to run, for example when the program aborts. +/// - must be called only once during runtime cleanup. pub unsafe fn cleanup() {} #[inline] @@ -89,7 +91,7 @@ pub fn decode_error_kind(code: i32) -> crate::io::ErrorKind { use r_efi::efi::Status; if let Ok(code) = usize::try_from(code) { - common::status_to_io_error(Status::from_usize(code)).kind() + helpers::status_to_io_error(Status::from_usize(code)).kind() } else { ErrorKind::Uncategorized } @@ -97,7 +99,7 @@ pub fn decode_error_kind(code: i32) -> crate::io::ErrorKind { pub fn abort_internal() -> ! { if let (Some(boot_services), Some(handle)) = - (common::try_boot_services(), uefi::env::try_image_handle()) + (helpers::try_boot_services(), uefi::env::try_image_handle()) { let _ = unsafe { ((*boot_services.as_ptr()).exit)( @@ -130,9 +132,9 @@ fn get_random() -> Option<(u64, u64)> { use r_efi::protocols::rng; let mut buf = [0u8; 16]; - let handles = common::locate_handles(rng::PROTOCOL_GUID).ok()?; + let handles = helpers::locate_handles(rng::PROTOCOL_GUID).ok()?; for handle in handles { - if let Ok(protocol) = common::open_protocol::(handle, rng::PROTOCOL_GUID) { + if let Ok(protocol) = helpers::open_protocol::(handle, rng::PROTOCOL_GUID) { let r = unsafe { ((*protocol.as_ptr()).get_rng)( protocol.as_ptr(), diff --git a/library/std/src/sys_common/mod.rs b/library/std/src/sys_common/mod.rs index d65d68337d8..e18638f2a5f 100644 --- a/library/std/src/sys_common/mod.rs +++ b/library/std/src/sys_common/mod.rs @@ -44,7 +44,6 @@ cfg_if::cfg_if! { cfg_if::cfg_if! { if #[cfg(any(target_os = "l4re", - target_os = "hermit", target_os = "uefi", feature = "restricted-std", all(target_family = "wasm", not(target_os = "emscripten")), diff --git a/src/doc/rustc/src/platform-support/unknown-uefi.md b/src/doc/rustc/src/platform-support/unknown-uefi.md index 8d4d60e12fb..1a4cbc9f092 100644 --- a/src/doc/rustc/src/platform-support/unknown-uefi.md +++ b/src/doc/rustc/src/platform-support/unknown-uefi.md @@ -19,7 +19,7 @@ Available targets: ## Requirements All UEFI targets can be used as `no-std` environments via cross-compilation. -Support for `std` is present, but incomplete and extreamly new. `alloc` is supported if +Support for `std` is present, but incomplete and extremely new. `alloc` is supported if an allocator is provided by the user or if using std. No host tools are supported. The UEFI environment resembles the environment for Microsoft Windows, with some @@ -238,22 +238,22 @@ This section contains information on how to use std on UEFI. The building std part is pretty much the same as the official [docs](https://rustc-dev-guide.rust-lang.org/getting-started.html). The linker that should be used is `rust-lld`. Here is a sample `config.toml`: ```toml -[llvm] -download-ci-llvm = false [rust] lld = true -[target.x86_64-unknown-uefi] -linker = "rust-lld" ``` Then just build using `x.py`: ```sh -./x.py build --target x86_64-unknown-uefi +./x.py build --target x86_64-unknown-uefi --stage 1 +``` +Alternatively, it is possible to use the `build-std` feature. However, you must use a toolchain which has the UEFI std patches. +Then just build the project using the following command: +```sh +cargo build --target x86_64-unknown-uefi -Zbuild-std=std,panic_abort ``` ### Std Requirements The current std has a few basic requirements to function: -1. Memory Allocation Services (`EFI_BOOT_SERVICES.AllocatePool()` and - `EFI_BOOT_SERVICES.FreePool()`) are available. +1. Memory Allocation Services (`EFI_BOOT_SERVICES.AllocatePool()` and `EFI_BOOT_SERVICES.FreePool()`) are available. This should be true in in the Driver Execution Environment or later. If the above requirement is satisfied, the Rust code will reach `main`. Now we will discuss what the different modules of std use in UEFI. @@ -261,21 +261,19 @@ Now we will discuss what the different modules of std use in UEFI. #### alloc - Implemented using `EFI_BOOT_SERVICES.AllocatePool()` and `EFI_BOOT_SERVICES.FreePool()`. - Passes all the tests. -- Some Quirks: - - Currently uses `EfiLoaderData` as the `EFI_ALLOCATE_POOL->PoolType`. +- Currently uses `EfiLoaderData` as the `EFI_ALLOCATE_POOL->PoolType`. #### cmath - Provided by compiler-builtins. #### env -- Just some global consants. +- Just some global constants. #### locks -- Uses `unsupported/locks`. -- They should work for a platform without threads according to docs. +- The provided locks should work on all standard single-threaded UEFI implementations. #### os_str -- Uses WTF-8 from windows. +- While the strings in UEFI should be valid UCS-2, in practice, many implementations just do not care and use UTF-16 strings. +- Thus, the current implementation supports full UTF-16 strings. ## Example: Hello World With std -The following code is a valid UEFI application showing stdio in UEFI. It also -uses `alloc` type `OsString` and `Vec`. +The following code features a valid UEFI application, including stdio and `alloc` (`OsString` and `Vec`): This example can be compiled as binary crate via `cargo` using the toolchain compiled from the above source (named custom): @@ -286,15 +284,21 @@ cargo +custom build --target x86_64-unknown-uefi ```rust,ignore (platform-specific) use r_efi::efi; -use std::os::uefi::ffi::OsStrExt; -use std::{ffi::OsString, panic}; +use std::{ + ffi::OsString, + os::uefi::{env, ffi::OsStrExt} +}; pub fn main() { - let st = std::os::uefi::env::system_table().as_ptr() as *mut efi::SystemTable; + let st = env::system_table().as_ptr() as *mut efi::SystemTable; let mut s: Vec = OsString::from("Hello World!\n").encode_wide().collect(); s.push(0); let r = - unsafe { ((*(*st).con_out).output_string)((*st).con_out, s.as_ptr() as *mut efi::Char16) }; + unsafe { + let con_out: *mut simple_text_output::Protocol = (*st).con_out; + let output_string: extern "efiapi" fn(_: *mut simple_text_output::Protocol, *mut u16) = (*con_out).output_string; + output_string(con_out, s.as_ptr() as *mut efi::Char16) + }; assert!(!r.is_error()) } ``` -- cgit 1.4.1-3-g733a5 From 5df24d18b6cdb8abcede6b658cf066360a219c12 Mon Sep 17 00:00:00 2001 From: Ayush Singh Date: Mon, 27 Mar 2023 19:53:53 +0530 Subject: Add support for building `std::os::uefi` docs Signed-off-by: Ayush Singh --- library/std/src/os/mod.rs | 1 + library/std/src/os/uefi/env.rs | 32 ++++++++++++---------- library/std/src/os/uefi/mod.rs | 1 + library/std/src/sys/uefi/alloc.rs | 15 ++++------ library/std/src/sys/uefi/helpers.rs | 11 +++++--- library/std/src/sys/uefi/mod.rs | 1 + src/doc/rustc/src/platform-support/unknown-uefi.md | 11 ++++---- 7 files changed, 38 insertions(+), 34 deletions(-) (limited to 'src/doc/rustc') diff --git a/library/std/src/os/mod.rs b/library/std/src/os/mod.rs index 11ad21515fd..d1a73503899 100644 --- a/library/std/src/os/mod.rs +++ b/library/std/src/os/mod.rs @@ -143,6 +143,7 @@ pub mod solid; #[path = "ios/mod.rs"] pub(crate) mod tvos; #[cfg(target_os = "uefi")] +#[cfg(any(target_os = "uefi", doc))] pub mod uefi; #[cfg(target_os = "vita")] pub mod vita; diff --git a/library/std/src/os/uefi/env.rs b/library/std/src/os/uefi/env.rs index e62441596f3..41dc7ccdb6a 100644 --- a/library/std/src/os/uefi/env.rs +++ b/library/std/src/os/uefi/env.rs @@ -32,41 +32,45 @@ pub unsafe fn init_globals(handle: NonNull, system_table: NonNull NonNull { try_system_table().unwrap() } /// Get the ImageHandle Pointer. +/// /// Note: This function panics if the System Table or Image Handle is not initialized pub fn image_handle() -> NonNull { try_image_handle().unwrap() } -/// Get the SystemTable Pointer. -/// This function is mostly intended for places where panic is not an option -pub(crate) fn try_system_table() -> Option> { - GLOBALS.get().map(|x| x.0) -} - -/// Get the SystemHandle Pointer. -/// This function is mostly intended for places where panic is not an option -pub(crate) fn try_image_handle() -> Option> { - GLOBALS.get().map(|x| x.1) -} - /// Get the BootServices Pointer. /// This function also checks if `ExitBootServices` has already been called. -pub(crate) fn boot_services() -> Option> { +pub fn boot_services() -> Option> { if BOOT_SERVICES_FLAG.get() { let system_table: NonNull = try_system_table()?.cast(); let boot_services = unsafe { (*system_table.as_ptr()).boot_services }; - NonNull::new(boot_services) + NonNull::new(boot_services).map(|x| x.cast()) } else { None } } +/// Get the SystemTable Pointer. +/// This function is mostly intended for places where panic is not an option +pub(crate) fn try_system_table() -> Option> { + GLOBALS.get().map(|x| x.0) +} + +/// Get the SystemHandle Pointer. +/// This function is mostly intended for places where panic is not an option +pub(crate) fn try_image_handle() -> Option> { + GLOBALS.get().map(|x| x.1) +} + pub(crate) fn enable_boot_services() { BOOT_SERVICES_FLAG.set(true); } diff --git a/library/std/src/os/uefi/mod.rs b/library/std/src/os/uefi/mod.rs index fc0468f25fc..8ef05eee1f4 100644 --- a/library/std/src/os/uefi/mod.rs +++ b/library/std/src/os/uefi/mod.rs @@ -1,6 +1,7 @@ //! Platform-specific extensions to `std` for UEFI. #![unstable(feature = "uefi_std", issue = "100499")] +#![doc(cfg(target_os = "uefi"))] pub mod env; #[path = "../windows/ffi.rs"] diff --git a/library/std/src/sys/uefi/alloc.rs b/library/std/src/sys/uefi/alloc.rs index d6eb371033c..789e3cbd81a 100644 --- a/library/std/src/sys/uefi/alloc.rs +++ b/library/std/src/sys/uefi/alloc.rs @@ -1,7 +1,7 @@ //! Global Allocator for UEFI. //! Uses [r-efi-alloc](https://crates.io/crates/r-efi-alloc) -use crate::alloc::{handle_alloc_error, GlobalAlloc, Layout, System}; +use crate::alloc::{GlobalAlloc, Layout, System}; const MEMORY_TYPE: u32 = r_efi::efi::LOADER_DATA; @@ -13,11 +13,8 @@ unsafe impl GlobalAlloc for System { return crate::ptr::null_mut(); } - let system_table = match crate::os::uefi::env::try_system_table() { - None => return crate::ptr::null_mut(), - Some(x) => x.as_ptr() as *mut _, - }; - + // If boot services is valid then SystemTable is not null. + let system_table = crate::os::uefi::env::system_table().as_ptr().cast(); // The caller must ensure non-0 layout unsafe { r_efi_alloc::raw::alloc(system_table, layout, MEMORY_TYPE) } } @@ -28,10 +25,8 @@ unsafe impl GlobalAlloc for System { return; } - let system_table = match crate::os::uefi::env::try_system_table() { - None => handle_alloc_error(layout), - Some(x) => x.as_ptr() as *mut _, - }; + // If boot services is valid then SystemTable is not null. + let system_table = crate::os::uefi::env::system_table().as_ptr().cast(); // The caller must ensure non-0 layout unsafe { r_efi_alloc::raw::dealloc(system_table, ptr, layout) } } diff --git a/library/std/src/sys/uefi/helpers.rs b/library/std/src/sys/uefi/helpers.rs index 28a82394226..2108484a40c 100644 --- a/library/std/src/sys/uefi/helpers.rs +++ b/library/std/src/sys/uefi/helpers.rs @@ -46,7 +46,7 @@ pub(crate) fn locate_handles(mut guid: Guid) -> io::Result( handle: NonNull, mut protocol_guid: Guid, ) -> io::Result> { - let boot_services = boot_services().ok_or(BOOT_SERVICES_UNAVAILABLE)?; + let boot_services: NonNull = + boot_services().ok_or(BOOT_SERVICES_UNAVAILABLE)?.cast(); let system_handle = uefi::env::image_handle(); let mut protocol: MaybeUninit<*mut T> = MaybeUninit::uninit(); @@ -279,7 +280,8 @@ pub(crate) fn create_event( handler: Option, context: *mut crate::ffi::c_void, ) -> io::Result> { - let boot_services = boot_services().ok_or(BOOT_SERVICES_UNAVAILABLE)?; + let boot_services: NonNull = + boot_services().ok_or(BOOT_SERVICES_UNAVAILABLE)?.cast(); let mut exit_boot_service_event: r_efi::efi::Event = crate::ptr::null_mut(); let r = unsafe { let create_event = (*boot_services.as_ptr()).create_event; @@ -294,7 +296,8 @@ pub(crate) fn create_event( } pub(crate) fn close_event(evt: NonNull) -> io::Result<()> { - let boot_services = boot_services().ok_or(BOOT_SERVICES_UNAVAILABLE)?; + let boot_services: NonNull = + boot_services().ok_or(BOOT_SERVICES_UNAVAILABLE)?.cast(); let r = unsafe { let close_event = (*boot_services.as_ptr()).close_event; (close_event)(evt.as_ptr()) diff --git a/library/std/src/sys/uefi/mod.rs b/library/std/src/sys/uefi/mod.rs index fa33b681a19..6fd2c5f21cb 100644 --- a/library/std/src/sys/uefi/mod.rs +++ b/library/std/src/sys/uefi/mod.rs @@ -129,6 +129,7 @@ pub fn abort_internal() -> ! { if let (Some(boot_services), Some(handle)) = (uefi::env::boot_services(), uefi::env::try_image_handle()) { + let boot_services: NonNull = boot_services.cast(); let _ = unsafe { ((*boot_services.as_ptr()).exit)( handle.as_ptr(), diff --git a/src/doc/rustc/src/platform-support/unknown-uefi.md b/src/doc/rustc/src/platform-support/unknown-uefi.md index 1a4cbc9f092..e2c09d67bed 100644 --- a/src/doc/rustc/src/platform-support/unknown-uefi.md +++ b/src/doc/rustc/src/platform-support/unknown-uefi.md @@ -251,12 +251,6 @@ Then just build the project using the following command: cargo build --target x86_64-unknown-uefi -Zbuild-std=std,panic_abort ``` -### Std Requirements -The current std has a few basic requirements to function: -1. Memory Allocation Services (`EFI_BOOT_SERVICES.AllocatePool()` and `EFI_BOOT_SERVICES.FreePool()`) are available. This should be true in in the Driver Execution Environment or later. -If the above requirement is satisfied, the Rust code will reach `main`. -Now we will discuss what the different modules of std use in UEFI. - ### Implemented features #### alloc - Implemented using `EFI_BOOT_SERVICES.AllocatePool()` and `EFI_BOOT_SERVICES.FreePool()`. @@ -302,3 +296,8 @@ pub fn main() { assert!(!r.is_error()) } ``` + +### BootServices +The current implementation of std make `BootServices` unavailable once `ExitBootServices` is called. Refer to [Runtime Drivers](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/7_driver_entry_point/711_runtime_drivers) for more information regarding how to handle switching from using physical addresses to using virtual addresses. + +Note: It should be noted that it is upto the user to drop all allocated memory before `ExitBootServices` is called. -- cgit 1.4.1-3-g733a5 From 7a956441a15e6056448233d79f2d03581ce0ccfc Mon Sep 17 00:00:00 2001 From: Ayush Singh Date: Tue, 28 Mar 2023 20:14:33 +0530 Subject: Fixes from PR - Some comment fixes. - Make some functions unsafe. - Make helpers module private. - Rebase on master - Update r-efi to v4.2.0 Signed-off-by: Ayush Singh --- .nlsp-settings/rust_analyzer.json | 3 --- Cargo.lock | 4 ++-- library/std/Cargo.toml | 2 +- library/std/src/os/uefi/env.rs | 2 +- library/std/src/sys/uefi/helpers.rs | 4 +++- library/std/src/sys/uefi/mod.rs | 6 +++--- src/doc/rustc/src/platform-support/unknown-uefi.md | 2 +- 7 files changed, 11 insertions(+), 12 deletions(-) delete mode 100644 .nlsp-settings/rust_analyzer.json (limited to 'src/doc/rustc') diff --git a/.nlsp-settings/rust_analyzer.json b/.nlsp-settings/rust_analyzer.json deleted file mode 100644 index eddf84afb2a..00000000000 --- a/.nlsp-settings/rust_analyzer.json +++ /dev/null @@ -1,3 +0,0 @@ -{ - "rust-analyzer.cargo.target": "x86_64-unknown-uefi" -} diff --git a/Cargo.lock b/Cargo.lock index f84387f30be..a2025e58a8d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3008,9 +3008,9 @@ dependencies = [ [[package]] name = "r-efi" -version = "4.1.0" +version = "4.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e7345c622833c6745e7b027a28aa95618813dc1f3c3de396206410267dce6f3" +checksum = "575fc2d9b3da54adbdfaddf6eca48fec256d977c8630a1750b8991347d1ac911" dependencies = [ "compiler_builtins", "rustc-std-workspace-core", diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml index 1908dfaa33d..965132bdedb 100644 --- a/library/std/Cargo.toml +++ b/library/std/Cargo.toml @@ -49,7 +49,7 @@ hermit-abi = { version = "0.3.2", features = ['rustc-dep-of-std'], public = true wasi = { version = "0.11.0", features = ['rustc-dep-of-std'], default-features = false } [target.'cfg(target_os = "uefi")'.dependencies] -r-efi = { version = "4.1.0", features = ['rustc-dep-of-std', 'efiapi']} +r-efi = { version = "4.2.0", features = ['rustc-dep-of-std']} r-efi-alloc = { version = "1.0.0", features = ['rustc-dep-of-std']} [features] diff --git a/library/std/src/os/uefi/env.rs b/library/std/src/os/uefi/env.rs index 41dc7ccdb6a..4dd090e22c6 100644 --- a/library/std/src/os/uefi/env.rs +++ b/library/std/src/os/uefi/env.rs @@ -66,7 +66,7 @@ pub(crate) fn try_system_table() -> Option> { } /// Get the SystemHandle Pointer. -/// This function is mostly intended for places where panic is not an option +/// This function is mostly intended for places where panicking is not an option pub(crate) fn try_image_handle() -> Option> { GLOBALS.get().map(|x| x.1) } diff --git a/library/std/src/sys/uefi/helpers.rs b/library/std/src/sys/uefi/helpers.rs index 2108484a40c..ea1c68a90ef 100644 --- a/library/std/src/sys/uefi/helpers.rs +++ b/library/std/src/sys/uefi/helpers.rs @@ -295,7 +295,9 @@ pub(crate) fn create_event( } } -pub(crate) fn close_event(evt: NonNull) -> io::Result<()> { +/// # SAFETY +/// - The supplied event must be valid +pub(crate) unsafe fn close_event(evt: NonNull) -> io::Result<()> { let boot_services: NonNull = boot_services().ok_or(BOOT_SERVICES_UNAVAILABLE)?.cast(); let r = unsafe { diff --git a/library/std/src/sys/uefi/mod.rs b/library/std/src/sys/uefi/mod.rs index 6fd2c5f21cb..27f76f04c05 100644 --- a/library/std/src/sys/uefi/mod.rs +++ b/library/std/src/sys/uefi/mod.rs @@ -47,7 +47,7 @@ pub mod thread_local_key; #[path = "../unsupported/time.rs"] pub mod time; -pub(crate) mod helpers; +mod helpers; #[cfg(test)] mod tests; @@ -96,7 +96,7 @@ pub(crate) unsafe fn init(argc: isize, argv: *const *const u8, _sigpipe: u8) { /// - must be called only once during runtime cleanup. pub unsafe fn cleanup() { if let Some(exit_boot_service_event) = EXIT_BOOT_SERVICE_EVENT.take() { - let _ = helpers::close_event(exit_boot_service_event); + let _ = unsafe { helpers::close_event(exit_boot_service_event) }; } } @@ -123,7 +123,7 @@ pub fn decode_error_kind(code: i32) -> crate::io::ErrorKind { pub fn abort_internal() -> ! { if let Some(exit_boot_service_event) = EXIT_BOOT_SERVICE_EVENT.take() { - let _ = helpers::close_event(exit_boot_service_event); + let _ = unsafe { helpers::close_event(exit_boot_service_event) }; } if let (Some(boot_services), Some(handle)) = diff --git a/src/doc/rustc/src/platform-support/unknown-uefi.md b/src/doc/rustc/src/platform-support/unknown-uefi.md index e2c09d67bed..019f030eb1c 100644 --- a/src/doc/rustc/src/platform-support/unknown-uefi.md +++ b/src/doc/rustc/src/platform-support/unknown-uefi.md @@ -300,4 +300,4 @@ pub fn main() { ### BootServices The current implementation of std make `BootServices` unavailable once `ExitBootServices` is called. Refer to [Runtime Drivers](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/7_driver_entry_point/711_runtime_drivers) for more information regarding how to handle switching from using physical addresses to using virtual addresses. -Note: It should be noted that it is upto the user to drop all allocated memory before `ExitBootServices` is called. +Note: It should be noted that it is upto the user to drop all allocated memory before `ExitBootServices` is called. -- cgit 1.4.1-3-g733a5 From c7e5f3ca085c3adfd285a6d41080ff65a6299bc9 Mon Sep 17 00:00:00 2001 From: Ayush Singh Date: Sun, 21 May 2023 14:26:59 +0530 Subject: Rebase to master - Update Example - Add thread_parking to sys::uefi - Fix unsafe in unsafe errors - Improve docs - Improve os/exit - Some asserts - Switch back to atomics Signed-off-by: Ayush Singh --- compiler/rustc_codegen_ssa/src/base.rs | 13 ++---- library/panic_abort/src/lib.rs | 2 +- library/std/build.rs | 1 - library/std/src/lib.rs | 1 + library/std/src/os/mod.rs | 1 - library/std/src/os/uefi/env.rs | 54 +++++++++++++--------- library/std/src/sys/uefi/helpers.rs | 14 +++--- library/std/src/sys/uefi/mod.rs | 36 +++++++++++---- library/std/src/sys/uefi/os.rs | 42 +++++++++++++---- src/doc/rustc/src/platform-support/unknown-uefi.md | 10 ++-- 10 files changed, 111 insertions(+), 63 deletions(-) (limited to 'src/doc/rustc') diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs index 4753f125540..6c51dffedbf 100644 --- a/compiler/rustc_codegen_ssa/src/base.rs +++ b/compiler/rustc_codegen_ssa/src/base.rs @@ -421,7 +421,7 @@ pub fn maybe_create_entry_wrapper<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( entry_type: EntryFnType, ) -> Bx::Function { // The entry function is either `int main(void)` or `int main(int argc, char **argv)`, or - // `Status efi_main(Handle hd, SystemTable *st)` depending on the target. + // `usize efi_main(void *handle, void *system_table)` depending on the target. let llfty = if cx.sess().target.os.contains("uefi") { cx.type_func(&[cx.type_ptr(), cx.type_ptr()], cx.type_isize()) } else if cx.sess().target.main_needs_argc_argv { @@ -508,10 +508,9 @@ fn get_argc_argv<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>( let param_handle = bx.get_param(0); let param_system_table = bx.get_param(1); let arg_argc = bx.const_int(cx.type_isize(), 2); - let arg_argv = bx.alloca(cx.type_array(cx.type_i8p(), 2), Align::ONE); + let arg_argv = bx.alloca(cx.type_array(cx.type_ptr(), 2), Align::ONE); bx.store(param_handle, arg_argv, Align::ONE); - let arg_argv_el1 = - bx.gep(cx.type_ptr_to(cx.type_i8()), arg_argv, &[bx.const_int(cx.type_int(), 1)]); + let arg_argv_el1 = bx.gep(cx.type_ptr(), arg_argv, &[bx.const_int(cx.type_int(), 1)]); bx.store(param_system_table, arg_argv_el1, Align::ONE); (arg_argc, arg_argv) } else if cx.sess().target.main_needs_argc_argv { @@ -566,11 +565,7 @@ pub fn allocator_kind_for_codegen(tcx: TyCtxt<'_>) -> Option { use rustc_middle::middle::dependency_format::Linkage; list.iter().any(|&linkage| linkage == Linkage::Dynamic) }); - if any_dynamic_crate { - None - } else { - tcx.allocator_kind(()) - } + if any_dynamic_crate { None } else { tcx.allocator_kind(()) } } pub fn codegen_crate( diff --git a/library/panic_abort/src/lib.rs b/library/panic_abort/src/lib.rs index bc0d7287be5..6e097e2caf2 100644 --- a/library/panic_abort/src/lib.rs +++ b/library/panic_abort/src/lib.rs @@ -44,7 +44,7 @@ pub unsafe fn __rust_start_panic(_payload: &mut dyn PanicPayload) -> u32 { } } else if #[cfg(any(target_os = "hermit", all(target_vendor = "fortanix", target_env = "sgx"), - target_os = "xous" + target_os = "xous", target_os = "uefi", ))] { unsafe fn abort() -> ! { diff --git a/library/std/build.rs b/library/std/build.rs index 1c32b425650..36516978b7a 100644 --- a/library/std/build.rs +++ b/library/std/build.rs @@ -52,7 +52,6 @@ fn main() { // - mipsel-sony-psp // - nvptx64-nvidia-cuda // - arch=avr - // - tvos (aarch64-apple-tvos, x86_64-apple-tvos) // - JSON targets // - Any new targets that have not been explicitly added above. println!("cargo:rustc-cfg=feature=\"restricted-std\""); diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index b572347019c..5e3249655b8 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -263,6 +263,7 @@ #![cfg_attr(target_os = "xous", feature(slice_ptr_len))] // // Language features: +// tidy-alphabetical-start #![feature(alloc_error_handler)] #![feature(allocator_internals)] #![feature(allow_internal_unsafe)] diff --git a/library/std/src/os/mod.rs b/library/std/src/os/mod.rs index d1a73503899..41aa0472f52 100644 --- a/library/std/src/os/mod.rs +++ b/library/std/src/os/mod.rs @@ -142,7 +142,6 @@ pub mod solid; #[cfg(target_os = "tvos")] #[path = "ios/mod.rs"] pub(crate) mod tvos; -#[cfg(target_os = "uefi")] #[cfg(any(target_os = "uefi", doc))] pub mod uefi; #[cfg(target_os = "vita")] diff --git a/library/std/src/os/uefi/env.rs b/library/std/src/os/uefi/env.rs index 4dd090e22c6..5d082e7c113 100644 --- a/library/std/src/os/uefi/env.rs +++ b/library/std/src/os/uefi/env.rs @@ -2,23 +2,22 @@ #![unstable(feature = "uefi_std", issue = "100499")] -use crate::{cell::Cell, ffi::c_void, ptr::NonNull}; +use crate::sync::atomic::{AtomicBool, AtomicPtr, Ordering}; +use crate::{ffi::c_void, ptr::NonNull}; -// Since UEFI is single-threaded, making the global variables thread local should be safe. -thread_local! { - // Flag to check if BootServices are still valid. - // Start with assuming that they are not available - static BOOT_SERVICES_FLAG: Cell = Cell::new(false); - // Position 0 = SystemTable - // Position 1 = ImageHandle - static GLOBALS: Cell, NonNull)>> = Cell::new(None); -} +static SYSTEM_TABLE: AtomicPtr = AtomicPtr::new(crate::ptr::null_mut()); +static IMAGE_HANDLE: AtomicPtr = AtomicPtr::new(crate::ptr::null_mut()); +// Flag to check if BootServices are still valid. +// Start with assuming that they are not available +static BOOT_SERVICES_FLAG: AtomicBool = AtomicBool::new(false); /// Initializes the global System Table and Image Handle pointers. /// /// The standard library requires access to the UEFI System Table and the Application Image Handle /// to operate. Those are provided to UEFI Applications via their application entry point. By /// calling `init_globals()`, those pointers are retained by the standard library for future use. +/// Thus this function must be called before any of the standard library services are used. +/// /// The pointers are never exposed to any entity outside of this application and it is guaranteed /// that, once the application exited, these pointers are never dereferenced again. /// @@ -26,9 +25,26 @@ thread_local! { /// application. In particular, UEFI Boot Services must not be exited while an application with the /// standard library is loaded. /// -/// This function must not be called more than once. -pub unsafe fn init_globals(handle: NonNull, system_table: NonNull) { - GLOBALS.set(Some((system_table, handle))); +/// # SAFETY +/// Calling this function more than once will panic +pub(crate) unsafe fn init_globals(handle: NonNull, system_table: NonNull) { + IMAGE_HANDLE + .compare_exchange( + crate::ptr::null_mut(), + handle.as_ptr(), + Ordering::Release, + Ordering::Acquire, + ) + .unwrap(); + SYSTEM_TABLE + .compare_exchange( + crate::ptr::null_mut(), + system_table.as_ptr(), + Ordering::Release, + Ordering::Acquire, + ) + .unwrap(); + BOOT_SERVICES_FLAG.store(true, Ordering::Release) } /// Get the SystemTable Pointer. @@ -50,7 +66,7 @@ pub fn image_handle() -> NonNull { /// Get the BootServices Pointer. /// This function also checks if `ExitBootServices` has already been called. pub fn boot_services() -> Option> { - if BOOT_SERVICES_FLAG.get() { + if BOOT_SERVICES_FLAG.load(Ordering::Acquire) { let system_table: NonNull = try_system_table()?.cast(); let boot_services = unsafe { (*system_table.as_ptr()).boot_services }; NonNull::new(boot_services).map(|x| x.cast()) @@ -62,19 +78,15 @@ pub fn boot_services() -> Option> { /// Get the SystemTable Pointer. /// This function is mostly intended for places where panic is not an option pub(crate) fn try_system_table() -> Option> { - GLOBALS.get().map(|x| x.0) + NonNull::new(SYSTEM_TABLE.load(Ordering::Acquire)) } /// Get the SystemHandle Pointer. /// This function is mostly intended for places where panicking is not an option pub(crate) fn try_image_handle() -> Option> { - GLOBALS.get().map(|x| x.1) -} - -pub(crate) fn enable_boot_services() { - BOOT_SERVICES_FLAG.set(true); + NonNull::new(IMAGE_HANDLE.load(Ordering::Acquire)) } pub(crate) fn disable_boot_services() { - BOOT_SERVICES_FLAG.set(false); + BOOT_SERVICES_FLAG.store(false, Ordering::Release) } diff --git a/library/std/src/sys/uefi/helpers.rs b/library/std/src/sys/uefi/helpers.rs index 2e1bcb36944..126661bfc96 100644 --- a/library/std/src/sys/uefi/helpers.rs +++ b/library/std/src/sys/uefi/helpers.rs @@ -60,13 +60,14 @@ pub(crate) fn locate_handles(mut guid: Guid) -> io::Result = - Vec::with_capacity(buf_len / size_of::()); + assert_eq!(buf_len % size_of::(), 0); + let num_of_handles = buf_len / size_of::(); + let mut buf: Vec = Vec::with_capacity(num_of_handles); match inner(&mut guid, boot_services, &mut buf_len, buf.as_mut_ptr()) { Ok(()) => { // This is safe because the call will succeed only if buf_len >= required length. // Also, on success, the `buf_len` is updated with the size of bufferv (in bytes) written - unsafe { buf.set_len(buf_len / size_of::()) }; + unsafe { buf.set_len(num_of_handles) }; Ok(buf.into_iter().filter_map(|x| NonNull::new(x)).collect()) } Err(e) => Err(e), @@ -114,16 +115,15 @@ pub(crate) fn create_event( ) -> io::Result> { let boot_services: NonNull = boot_services().ok_or(BOOT_SERVICES_UNAVAILABLE)?.cast(); - let mut exit_boot_service_event: r_efi::efi::Event = crate::ptr::null_mut(); + let mut event: r_efi::efi::Event = crate::ptr::null_mut(); let r = unsafe { let create_event = (*boot_services.as_ptr()).create_event; - (create_event)(signal, tpl, handler, context, &mut exit_boot_service_event) + (create_event)(signal, tpl, handler, context, &mut event) }; if r.is_error() { Err(crate::io::Error::from_raw_os_error(r.as_usize())) } else { - NonNull::new(exit_boot_service_event) - .ok_or(const_io_error!(io::ErrorKind::Other, "null protocol")) + NonNull::new(event).ok_or(const_io_error!(io::ErrorKind::Other, "null protocol")) } } diff --git a/library/std/src/sys/uefi/mod.rs b/library/std/src/sys/uefi/mod.rs index 85d00caf149..9a10395af8e 100644 --- a/library/std/src/sys/uefi/mod.rs +++ b/library/std/src/sys/uefi/mod.rs @@ -12,7 +12,6 @@ //! [`OsStr`]: crate::ffi::OsStr //! [`OsString`]: crate::ffi::OsString -#![deny(unsafe_op_in_unsafe_fn)] pub mod alloc; #[path = "../unsupported/args.rs"] pub mod args; @@ -43,6 +42,8 @@ pub mod stdio; pub mod thread; #[path = "../unsupported/thread_local_key.rs"] pub mod thread_local_key; +#[path = "../unsupported/thread_parking.rs"] +pub mod thread_parking; #[path = "../unsupported/time.rs"] pub mod time; @@ -53,18 +54,17 @@ mod tests; pub type RawOsError = usize; -use crate::cell::Cell; use crate::io as std_io; use crate::os::uefi; use crate::ptr::NonNull; +use crate::sync::atomic::{AtomicPtr, Ordering}; pub mod memchr { pub use core::slice::memchr::{memchr, memrchr}; } -thread_local! { - static EXIT_BOOT_SERVICE_EVENT: Cell>> = Cell::new(None); -} +static EXIT_BOOT_SERVICE_EVENT: AtomicPtr = + AtomicPtr::new(crate::ptr::null_mut()); /// # SAFETY /// - must be called only once during runtime initialization. @@ -75,8 +75,6 @@ pub(crate) unsafe fn init(argc: isize, argv: *const *const u8, _sigpipe: u8) { let image_handle = unsafe { NonNull::new(*argv as *mut crate::ffi::c_void).unwrap() }; let system_table = unsafe { NonNull::new(*argv.add(1) as *mut crate::ffi::c_void).unwrap() }; unsafe { uefi::env::init_globals(image_handle, system_table) }; - // Enable boot services once GLOBALS are initialized - uefi::env::enable_boot_services(); // Register exit boot services handler match helpers::create_event( @@ -86,7 +84,17 @@ pub(crate) unsafe fn init(argc: isize, argv: *const *const u8, _sigpipe: u8) { crate::ptr::null_mut(), ) { Ok(x) => { - EXIT_BOOT_SERVICE_EVENT.set(Some(x)); + if EXIT_BOOT_SERVICE_EVENT + .compare_exchange( + crate::ptr::null_mut(), + x.as_ptr(), + Ordering::Release, + Ordering::Acquire, + ) + .is_err() + { + abort_internal(); + }; } Err(_) => abort_internal(), } @@ -96,7 +104,9 @@ pub(crate) unsafe fn init(argc: isize, argv: *const *const u8, _sigpipe: u8) { /// this is not guaranteed to run, for example when the program aborts. /// - must be called only once during runtime cleanup. pub unsafe fn cleanup() { - if let Some(exit_boot_service_event) = EXIT_BOOT_SERVICE_EVENT.take() { + if let Some(exit_boot_service_event) = + NonNull::new(EXIT_BOOT_SERVICE_EVENT.swap(crate::ptr::null_mut(), Ordering::Acquire)) + { let _ = unsafe { helpers::close_event(exit_boot_service_event) }; } } @@ -159,7 +169,9 @@ pub fn decode_error_kind(code: RawOsError) -> crate::io::ErrorKind { } pub fn abort_internal() -> ! { - if let Some(exit_boot_service_event) = EXIT_BOOT_SERVICE_EVENT.take() { + if let Some(exit_boot_service_event) = + NonNull::new(EXIT_BOOT_SERVICE_EVENT.load(Ordering::Acquire)) + { let _ = unsafe { helpers::close_event(exit_boot_service_event) }; } @@ -226,3 +238,7 @@ fn get_random() -> Option<(u64, u64)> { extern "efiapi" fn exit_boot_service_handler(_e: r_efi::efi::Event, _ctx: *mut crate::ffi::c_void) { uefi::env::disable_boot_services(); } + +pub fn is_interrupted(_code: RawOsError) -> bool { + false +} diff --git a/library/std/src/sys/uefi/os.rs b/library/std/src/sys/uefi/os.rs index cd489d8f7f9..e6693db68e6 100644 --- a/library/std/src/sys/uefi/os.rs +++ b/library/std/src/sys/uefi/os.rs @@ -4,15 +4,16 @@ use crate::ffi::{OsStr, OsString}; use crate::fmt; use crate::io; use crate::marker::PhantomData; +use crate::os::uefi; use crate::path::{self, PathBuf}; +use crate::ptr::NonNull; +use r_efi::efi::Status; pub fn errno() -> RawOsError { 0 } pub fn error_string(errno: RawOsError) -> String { - use r_efi::efi::Status; - // Keep the List in Alphabetical Order // The Messages are taken from UEFI Specification Appendix D - Status Codes match r_efi::efi::Status::from_usize(errno) { @@ -160,12 +161,7 @@ impl fmt::Display for JoinPathsError { } } -impl StdError for JoinPathsError { - #[allow(deprecated)] - fn description(&self) -> &str { - "not supported on this platform yet" - } -} +impl StdError for JoinPathsError {} pub fn current_exe() -> io::Result { unsupported() @@ -173,6 +169,14 @@ pub fn current_exe() -> io::Result { pub struct Env(!); +impl Env { + // FIXME(https://github.com/rust-lang/rust/issues/114583): Remove this when ::fmt matches ::fmt. + pub fn str_debug(&self) -> impl fmt::Debug + '_ { + let Self(inner) = self; + match *inner {} + } +} + impl Iterator for Env { type Item = (OsString, OsString); fn next(&mut self) -> Option<(OsString, OsString)> { @@ -180,6 +184,13 @@ impl Iterator for Env { } } +impl fmt::Debug for Env { + fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result { + let Self(inner) = self; + match *inner {} + } +} + pub fn env() -> Env { panic!("not supported on this platform") } @@ -204,7 +215,20 @@ pub fn home_dir() -> Option { None } -pub fn exit(_code: i32) -> ! { +pub fn exit(code: i32) -> ! { + if let (Some(boot_services), Some(handle)) = + (uefi::env::boot_services(), uefi::env::try_image_handle()) + { + let boot_services: NonNull = boot_services.cast(); + let _ = unsafe { + ((*boot_services.as_ptr()).exit)( + handle.as_ptr(), + Status::from_usize(code as usize), + 0, + crate::ptr::null_mut(), + ) + }; + } crate::intrinsics::abort() } diff --git a/src/doc/rustc/src/platform-support/unknown-uefi.md b/src/doc/rustc/src/platform-support/unknown-uefi.md index 019f030eb1c..68cd7fae319 100644 --- a/src/doc/rustc/src/platform-support/unknown-uefi.md +++ b/src/doc/rustc/src/platform-support/unknown-uefi.md @@ -277,7 +277,9 @@ cargo +custom build --target x86_64-unknown-uefi ``` ```rust,ignore (platform-specific) -use r_efi::efi; +#![feature(uefi_std)] + +use r_efi::{efi, protocols::simple_text_output}; use std::{ ffi::OsString, os::uefi::{env, ffi::OsStrExt} @@ -290,7 +292,7 @@ pub fn main() { let r = unsafe { let con_out: *mut simple_text_output::Protocol = (*st).con_out; - let output_string: extern "efiapi" fn(_: *mut simple_text_output::Protocol, *mut u16) = (*con_out).output_string; + let output_string: extern "efiapi" fn(_: *mut simple_text_output::Protocol, *mut u16) -> efi::Status = (*con_out).output_string; output_string(con_out, s.as_ptr() as *mut efi::Char16) }; assert!(!r.is_error()) @@ -298,6 +300,6 @@ pub fn main() { ``` ### BootServices -The current implementation of std make `BootServices` unavailable once `ExitBootServices` is called. Refer to [Runtime Drivers](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/7_driver_entry_point/711_runtime_drivers) for more information regarding how to handle switching from using physical addresses to using virtual addresses. +The current implementation of std makes `BootServices` unavailable once `ExitBootServices` is called. Refer to [Runtime Drivers](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/7_driver_entry_point/711_runtime_drivers) for more information regarding how to handle switching from using physical addresses to using virtual addresses. -Note: It should be noted that it is upto the user to drop all allocated memory before `ExitBootServices` is called. +Note: It should be noted that it is up to the user to drop all allocated memory before `ExitBootServices` is called. -- cgit 1.4.1-3-g733a5