[major] Add Initial Patina UEFI Services [Rebase & FF]

Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["components/*", "core/*", "sdk/*", "patina_dxe_core"]
 
 [workspace.package]
-version = "23.1.0"
+version = "23.1.1"
 license = "Apache-2.0"
 edition = "2024"
 rust-version = "1.90"
@@ -34,21 +34,21 @@ linkme = { version = "0.3.36" }
 log = { version = "0.4", default-features = false }
 memoffset = {version = "0.9.1" }
 num-traits = { version = "0.2", default-features = false }
-patina = { version = "23.1.0", path = "sdk/patina" }
-patina_debugger = { version = "23.1.0", path = "core/patina_debugger" }
-patina_ffs = { version = "23.1.0", path = "sdk/patina_ffs" }
-patina_ffs_extractors = { version = "23.1.0", path = "sdk/patina_ffs_extractors" }
-patina_internal_core = { version = "23.1.0", path = "core/patina_internal_core", default-features = false }
-patina_internal_cpu = { version = "23.1.0", path = "core/patina_internal_cpu" }
+patina = { version = "23.1.1", path = "sdk/patina" }
+patina_debugger = { version = "23.1.1", path = "core/patina_debugger" }
+patina_ffs = { version = "23.1.1", path = "sdk/patina_ffs" }
+patina_ffs_extractors = { version = "23.1.1", path = "sdk/patina_ffs_extractors" }
+patina_internal_core = { version = "23.1.1", path = "core/patina_internal_core", default-features = false }
+patina_internal_cpu = { version = "23.1.1", path = "core/patina_internal_cpu" }
 lzma-rust2 = { version = "0.16", default-features = false }
-patina_macro = { version = "23.1.0", path = "sdk/patina_macro" }
-patina_mm = { version = "23.1.0", path = "components/patina_mm" }
+patina_macro = { version = "23.1.1", path = "sdk/patina_macro" }
+patina_mm = { version = "23.1.1", path = "components/patina_mm" }
 patina_mtrr = { version = "1.1.9" }
 patina_paging = { version = "11.0.4" }
-patina_performance = { version = "23.1.0", path = "components/patina_performance" }
-patina_smbios = { version = "23.1.0", path = "components/patina_smbios" }
-patina_stacktrace = { version = "23.1.0", path = "core/patina_stacktrace" }
-patina_test = { version = "23.1.0", path = "components/patina_test" }
+patina_performance = { version = "23.1.1", path = "components/patina_performance" }
+patina_smbios = { version = "23.1.1", path = "components/patina_smbios" }
+patina_stacktrace = { version = "23.1.1", path = "core/patina_stacktrace" }
+patina_test = { version = "23.1.1", path = "components/patina_test" }
 proc-macro2 = { version = "1" }
 quote = { version = "1" }
 scroll = { version = "0.13", default-features = false, features = ["derive"]}

patina_dxe_core/Cargo.toml

@@ -15,7 +15,6 @@ workspace = true
 [dependencies]
 bitfield-struct = { workspace = true }
 cfg-if = { workspace = true }
-crc32fast = { workspace = true }
 goblin = { workspace = true, features = ["pe32", "pe64", "te"] }
 linked_list_allocator = { workspace = true }
 log = { workspace = true }

patina_dxe_core/src/dxe_services.rs

@@ -12,6 +12,7 @@ use core::{
     mem,
     slice::{self, from_raw_parts},
 };
+use patina::crc32;
 use patina::error::EfiError;
 use patina_ffs::volume::VolumeRef;
 
@@ -397,7 +398,7 @@ impl<P: PlatformInfo> Core<P> {
         let dxe_services_system_table_ptr = &raw const dxe_services_system_table;
         // SAFETY: dxe_services_system_table is a local value, its byte representation is valid for hashing.
         let crc32 = unsafe {
-            crc32fast::hash(from_raw_parts(
+            crc32::calculate_crc32(from_raw_parts(
                 dxe_services_system_table_ptr as *const u8,
                 mem::size_of::<dxe_services::DxeServicesTable>(),
             ))
@@ -2318,7 +2319,7 @@ mod tests {
             let mut copy = unsafe { core::ptr::read(dxe_tbl) };
             copy.header.crc32 = 0;
             // SAFETY: copy is a local value. Creating a slice from its pointer and size is valid.
-            let crc = crc32fast::hash(unsafe {
+            let crc = patina::crc32::calculate_crc32(unsafe {
                 core::slice::from_raw_parts(
                     (&raw const copy) as *const u8,
                     core::mem::size_of::<dxe_services::DxeServicesTable>(),

patina_dxe_core/src/gcd/spin_locked_gcd.rs

@@ -9,7 +9,7 @@
 use crate::pecoff::UefiPeInfo;
 use alloc::{boxed::Box, slice, vec, vec::Vec};
 use core::{fmt::Display, ptr};
-use patina::{DEFAULT_CACHE_ATTR, error::EfiError, log_debug_assert};
+use patina::{DEFAULT_CACHE_ATTR, crc32, error::EfiError, log_debug_assert};
 
 use patina::standard::efi;
 use patina::{
@@ -2972,7 +2972,7 @@ impl SpinLockedGcd {
     ///
     /// * `memory_map_bytes` - The byte slice representing the EFI memory map
     pub fn set_last_efi_memory_map_key(&self, memory_map_bytes: &[u8]) {
-        let key = crc32fast::hash(memory_map_bytes) as usize;
+        let key = crc32::calculate_crc32(memory_map_bytes) as usize;
         *self.last_efi_memory_map_key.lock() = Some(key);
     }
 }

patina_dxe_core/src/misc_boot_services.rs

@@ -10,6 +10,7 @@ use core::{ffi::c_void, slice::from_raw_parts, sync::atomic::Ordering};
 use patina::arch as interrupts;
 use patina::standard::efi;
 use patina::{
+    crc32,
     guid as base_guids, log_debug_assert,
     pi::{protocol, status_code},
     uefi::event::EXIT_BOOT_SERVICES_FAILED_EVENT_GROUP_GUID,
@@ -78,7 +79,7 @@ unsafe extern "efiapi" fn calculate_crc32(data: *mut c_void, data_size: usize, c
     // SAFETY: caller must ensure that data and crc_32 are valid pointers. They are null-checked above.
     unsafe {
         let buffer = from_raw_parts(data as *mut u8, data_size);
-        crc_32.write_unaligned(crc32fast::hash(buffer));
+        crc_32.write_unaligned(crc32::calculate_crc32(buffer));
     }
 
     efi::Status::SUCCESS
@@ -366,7 +367,7 @@ mod tests {
             };
             // Verify the function succeeded and CRC32 was calculated correctly for zero buffer
             if status == efi::Status::SUCCESS {
-                let expected_crc = crc32fast::hash(&BUFFER);
+                let expected_crc = crc32::calculate_crc32(&BUFFER);
                 if data_crc == expected_crc {
                     log::debug!("CRC32 calculation successful: {data_crc:#x}");
                 } else {

patina_dxe_core/src/pi_dispatcher.rs

@@ -25,6 +25,7 @@ use patina::standard::efi;
 use patina::{
     BinaryGuid, Char16Str, OwnedGuid,
     component::service::Service,
+    crc32,
     error::EfiError,
     pi::{
         fw_fs::ffs,
@@ -241,8 +242,10 @@ impl<P: PlatformInfo> PiDispatcher<P> {
                 },
             );
 
-            let crc32 =
-                crc32fast::hash(alloc::slice::from_raw_parts(ptr as *const u8, size_of::<efi::SystemTablePointer>()));
+            let crc32 = crc32::calculate_crc32(alloc::slice::from_raw_parts(
+                ptr as *const u8,
+                size_of::<efi::SystemTablePointer>(),
+            ));
 
             core::ptr::write_volatile(&raw mut (*ptr).crc32, crc32);
         }

patina_dxe_core/src/systemtables.rs

@@ -12,7 +12,7 @@ use core::{ffi::c_void, mem::size_of, slice::from_raw_parts};
 
 use alloc::boxed::Box;
 use patina::standard::efi;
-use patina::{component::component, pi::error_codes::EFI_NOT_AVAILABLE_YET, uefi::boot_services::BootServices};
+use patina::{component::component, crc32, pi::error_codes::EFI_NOT_AVAILABLE_YET, uefi::boot_services::BootServices};
 
 use crate::{allocator::EFI_RUNTIME_SERVICES_DATA_ALLOCATOR, tpl_mutex};
 
@@ -50,7 +50,7 @@ impl EfiRuntimeServicesTable {
         // SAFETY: table_copy is a valid, initialized RuntimeServices value on the stack.
         let tbl_slice =
             unsafe { from_raw_parts(&raw const table_copy as *const u8, size_of::<efi::RuntimeServices>()) };
-        table_copy.hdr.crc32 = crc32fast::hash(tbl_slice);
+        table_copy.hdr.crc32 = crc32::calculate_crc32(tbl_slice);
 
         // SAFETY: structure construction ensures pointer is valid.
         unsafe { self.runtime_services.write(table_copy) }
@@ -250,7 +250,7 @@ impl EfiBootServicesTable {
 
         // SAFETY: table_copy is a valid, initialized BootServices value on the stack.
         let tbl_slice = unsafe { from_raw_parts(&raw const table_copy as *const u8, size_of::<efi::BootServices>()) };
-        table_copy.hdr.crc32 = crc32fast::hash(tbl_slice);
+        table_copy.hdr.crc32 = crc32::calculate_crc32(tbl_slice);
 
         // SAFETY: structure construction ensures pointer is valid.
         unsafe { self.boot_services.write(table_copy) }
@@ -740,7 +740,7 @@ impl EfiSystemTable {
 
         // SAFETY: table_copy is a valid, initialized SystemTable value on the stack.
         let st_slice = unsafe { from_raw_parts(&raw const table_copy as *const u8, size_of::<efi::SystemTable>()) };
-        table_copy.hdr.crc32 = crc32fast::hash(st_slice);
+        table_copy.hdr.crc32 = crc32::calculate_crc32(st_slice);
 
         // SAFETY: structure construction ensures pointer is valid.
         unsafe { self.system_table.write(table_copy) }

sdk/patina/Cargo.toml

@@ -51,6 +51,7 @@ fixedbitset = { workspace = true, optional = true }
 bitvec = { workspace = true }
 cfg-if = { workspace = true }
 compile-time = { workspace = true }
+crc32fast = { workspace = true }
 goblin = { workspace = true, features = ["pe32", "pe64", "te", "alloc"], optional = true }
 log = { workspace = true }
 r-efi = { version = "7.1", default-features = false }

sdk/patina/src/base.rs

@@ -12,6 +12,7 @@ use crate::base::error::EfiError;
 use crate::standard::efi;
 
 pub mod c_ptr;
+pub mod crc32;
 pub mod error;
 pub mod guid;
 pub mod hash;

sdk/patina/src/base/crc32.rs

@@ -0,0 +1,46 @@
+//! CRC-32 checksum calculation for Patina.
+//!
+//! Provides a general-purpose CRC-32 checksum function for use across Patina.
+//!
+//! ## License
+//!
+//! Copyright (c) Microsoft Corporation.
+//!
+//! SPDX-License-Identifier: Apache-2.0
+
+/// Computes the CRC-32 of `data`, matching the UEFI `CalculateCrc32` boot service.
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use patina::crc32::calculate_crc32;
+///
+/// let checksum = calculate_crc32(b"hello");
+/// log::info!("crc32 = {checksum:#x}");
+/// ```
+pub fn calculate_crc32(data: &[u8]) -> u32 {
+    crc32fast::hash(data)
+}
+
+#[cfg(test)]
+#[cfg_attr(coverage, coverage(off))]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_calculate_crc32_empty_slice() {
+        assert_eq!(calculate_crc32(&[]), crc32fast::hash(&[]));
+    }
+
+    #[test]
+    fn test_calculate_crc32_known_vector() {
+        // "123456789" is the standard CRC-32 check-value test vector.
+        let data = b"123456789";
+        assert_eq!(calculate_crc32(data), crc32fast::hash(data));
+    }
+
+    #[test]
+    fn test_calculate_crc32_different_inputs_produce_different_hashes() {
+        assert_ne!(calculate_crc32(b"abc"), calculate_crc32(b"abd"));
+    }
+}

sdk/patina/src/base/string.rs

@@ -215,7 +215,9 @@ macro_rules! char16 {
     ($s:literal) => {{
         static CHAR16_LITERAL: $crate::string::Char16Array<{ $crate::string::ucs2_capacity($s) }> =
             $crate::string::Char16Array::from_str($s);
-        CHAR16_LITERAL.as_char16_str()
+        // SAFETY: `ucs2_capacity($s)` is exactly the encoded length plus one for the NUL terminator, so
+        // the array has no padding and its only NUL is the final element.
+        unsafe { $crate::string::Char16Str::from_units_with_nul_unchecked(CHAR16_LITERAL.as_array()) }
     }};
 }
 
@@ -238,7 +240,9 @@ macro_rules! char8 {
     ($s:literal) => {{
         static CHAR8_LITERAL: $crate::string::Char8Array<{ $crate::string::latin1_capacity($s) }> =
             $crate::string::Char8Array::from_str($s);
-        CHAR8_LITERAL.as_char8_str()
+        // SAFETY: `latin1_capacity($s)` is exactly the encoded length plus one for the NUL terminator, so
+        // the array has no padding and its only NUL is the final element.
+        unsafe { $crate::string::Char8Str::from_bytes_with_nul_unchecked(CHAR8_LITERAL.as_array()) }
     }};
 }
 

sdk/patina/src/component/service.rs

@@ -128,6 +128,7 @@ pub mod dxe_dispatch;
 pub mod memory;
 pub mod perf_timer;
 pub mod performance;
+pub mod uefi_services;
 
 pub use patina_macro::IntoService;
 

sdk/patina/src/component/service/uefi_services.rs

@@ -0,0 +1,53 @@
+//! UEFI Services for Patina components.
+//!
+//! This module defines a set of service traits that expose UEFI Boot Services (and,
+//! over time, Runtime Services) to Patina components as Rust APIs.
+//!
+//! These services are the recommended way for components to consume UEFI functionality.
+//! Unlike the raw [`crate::uefi::boot_services`] abstractions, which wrap the C
+//! `EFI_BOOT_SERVICES` function-pointer table, these services are implemented by the
+//! Patina DXE Core directly against its internal Rust APIs. Components therefore do not
+//! interact with C-style constructs such as the boot services table or raw pointers until
+//! they go down an unavoidable path into C code, such as calling a protocol function
+//! pointer when the protocol is produced by a C driver.
+//!
+//! # Design
+//!
+//! Each service group is defined as a trait in this module and implemented by the core.
+//! Components declare a dependency on a service by adding a [`Service<dyn Trait>`] parameter
+//! to their entry point. The trait is only made available once the core registers its
+//! implementation, so a component depending on a service is guaranteed the service is ready.
+//! Some services may be deferred until underlying dependencies such as an architectural protocol
+//! or other platform-dependent service is available.
+//!
+//! Services are split into cohesive functional groups so that a component can declare a more
+//! granular dependency on the functionality it needs:
+//!
+//! - [`config_table::ConfigurationTableServices`] - Configuration table installation and lookup.
+//! - [`driver::DriverServices`] - Connecting and disconnecting drivers to controllers.
+//! - [`event::EventServices`] - Events, using Rust closures for notifications.
+//! - [`image::ImageServices`] - Loading, starting, and unloading UEFI images.
+//! - [`protocol::ProtocolServices`] - Typed protocol installation and discovery.
+//! - [`timer_event::TimerEventServices`] - Timer events, available once the Timer Architectural
+//!   Protocol is installed.
+//! - [`timing::TimingServices`] - Delays and the Watchdog timer.
+//! - [`tpl::TplServices`] - Raising and restoring the Task Priority Level (TPL).
+//!
+//! [`Service<dyn Trait>`]: crate::component::service::Service
+//!
+//! ## License
+//!
+//! Copyright (c) Microsoft Corporation.
+//!
+//! SPDX-License-Identifier: Apache-2.0
+//!
+
+pub mod config_table;
+pub mod driver;
+pub mod event;
+pub mod handle;
+pub mod image;
+pub mod protocol;
+pub mod timer_event;
+pub mod timing;
+pub mod tpl;