Migrate mu_plus from mu_uefi_boot_services crate to patina crate (#881)

## Description

- `mu_uefi_boot_services` is not maintained and its functionality is
moved into patina.
- The [mu_uefi_boot_services's
crates.io](https://crates.io/crates/mu_uefi_boot_services) point to
non-existent repo.
- This cleanup is needed to move mu_plus's r-efi dependency to 6.0

Next, Once Patina is updated to r-efi 6.0 we can migrate mu_plus to
patina vnext and r-efi to 6.0

- [ ] Impacts functionality?
- [ ] Impacts security?
- [ ] Breaking change?
- [ ] Includes tests?
- [ ] Includes documentation?

## How This Was Tested

`cargo make all` worked. Will be tested in internal repos once r-efi 6.0
migration is done.

## Integration Instructions

NA

Signed-off-by: Vineel Kovvuri[MSFT] <vineelko@microsoft.com>

Author: vineelko

AdvLoggerPkg/Crates/RustAdvancedLoggerDxe/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "RustAdvancedLoggerDxe"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
@@ -10,7 +10,7 @@ path = "src/lib.rs"
 
 [dependencies]
 r-efi = { workspace = true }
-mu_uefi_boot_services = { workspace = true }
+patina = { workspace = true }
 
 [dev-dependencies]
-mu_uefi_boot_services = { workspace = true, features = ["mockall"] }
+patina = { workspace = true, features = ["mockall"] }

AdvLoggerPkg/Crates/RustAdvancedLoggerDxe/src/lib.rs

@@ -39,10 +39,10 @@ use core::{
     ptr,
     sync::atomic::{AtomicPtr, Ordering},
 };
+use patina::BinaryGuid;
+use patina::{boot_services, uefi_protocol::ProtocolInterface};
 use r_efi::efi;
 
-use boot_services::{self, protocol_handler::Protocol};
-
 //Global static logger instance - this is a singleton.
 static LOGGER: AdvancedLogger = AdvancedLogger::new();
 
@@ -58,34 +58,25 @@ pub const DEBUG_VERBOSE: usize = 0x00400000;
 pub const DEBUG_ERROR: usize = 0x80000000;
 
 // AdvancedLogger protocol definition. Mirrors C definition in AdvLoggerPkg/Include/Protocol/AdvancedLogger.h
-const ADVANCED_LOGGER_PROTOCOL_GUID: efi::Guid =
-    efi::Guid::from_fields(0x434f695c, 0xef26, 0x4a12, 0x9e, 0xba, &[0xdd, 0xef, 0x00, 0x97, 0x49, 0x7c]);
-
+const ADVANCED_LOGGER_PROTOCOL_GUID: BinaryGuid = BinaryGuid::from_string("434f695c-ef26-4a12-9eba-ddef0097497c");
 type AdvancedLoggerWriteProtocol = extern "efiapi" fn(*const AdvancedLoggerProtocolInterface, usize, *const u8, usize);
 
-const ADVANCED_LOGGER_PROTOCOL: AdvancedLoggerProtocol = AdvancedLoggerProtocol {};
-
 #[repr(C)]
 struct AdvancedLoggerProtocolInterface {
     signature: u32,
     version: u32,
     write_log: AdvancedLoggerWriteProtocol,
 }
 
-struct AdvancedLoggerProtocol;
-
-unsafe impl Protocol for AdvancedLoggerProtocol {
-    type Interface = AdvancedLoggerProtocolInterface;
-    fn protocol_guid(&self) -> &'static efi::Guid {
-        &ADVANCED_LOGGER_PROTOCOL_GUID
-    }
+unsafe impl ProtocolInterface for AdvancedLoggerProtocolInterface {
+    const PROTOCOL_GUID: BinaryGuid = ADVANCED_LOGGER_PROTOCOL_GUID;
 }
 
-impl Deref for AdvancedLoggerProtocol {
+impl Deref for AdvancedLoggerProtocolInterface {
     type Target = efi::Guid;
 
     fn deref(&self) -> &Self::Target {
-        self.protocol_guid()
+        &ADVANCED_LOGGER_PROTOCOL_GUID
     }
 }
 
@@ -103,7 +94,8 @@ impl AdvancedLogger {
 
     // initialize the AdvancedLogger by acquiring a pointer to the AdvancedLogger protocol.
     fn init(&self, boot_services_impl: &impl boot_services::BootServices) {
-        let protocol_ptr = match unsafe { boot_services_impl.locate_protocol(&ADVANCED_LOGGER_PROTOCOL, None) } {
+        let protocol_ptr = match unsafe { boot_services_impl.locate_protocol::<AdvancedLoggerProtocolInterface>(None) }
+        {
             Ok(interface) => interface as *mut AdvancedLoggerProtocolInterface,
             Err(_status) => ptr::null_mut(),
         };
@@ -143,7 +135,7 @@ impl fmt::Write for LogTransactor<'_> {
 /// # Safety
 /// Parameter `efi_boot_services` should be a valid pointer of [`efi::BootServices`] with a static lifetime.
 pub unsafe fn init_debug(efi_boot_services: *mut efi::BootServices) {
-    let standard_boot_services = unsafe { boot_services::StandardBootServices::new(&*efi_boot_services) };
+    let standard_boot_services = boot_services::StandardBootServices::new(efi_boot_services);
     LOGGER.init(&standard_boot_services);
 }
 
@@ -252,12 +244,12 @@ macro_rules! debugln {
 mod tests {
     extern crate std;
     use crate::{
-        debug, AdvancedLogger, AdvancedLoggerProtocol, AdvancedLoggerProtocolInterface, DEBUG_ERROR, DEBUG_INFO,
-        DEBUG_INIT, DEBUG_VERBOSE, DEBUG_WARN, LOGGER,
+        AdvancedLogger, AdvancedLoggerProtocolInterface, DEBUG_ERROR, DEBUG_INFO, DEBUG_INIT, DEBUG_VERBOSE,
+        DEBUG_WARN, LOGGER, debug,
     };
     use core::{slice::from_raw_parts, sync::atomic::Ordering};
+    use patina::boot_services::MockBootServices;
     use std::{println, str};
-
     static ADVANCED_LOGGER_INSTANCE: AdvancedLoggerProtocolInterface =
         AdvancedLoggerProtocolInterface { signature: 0, version: 0, write_log: mock_advanced_logger_write };
 
@@ -287,8 +279,8 @@ mod tests {
 
     #[test]
     fn init_should_initialize_logger() {
-        let mut mock_boot_services = boot_services::MockBootServices::new();
-        mock_boot_services.expect_locate_protocol().returning(|_: &AdvancedLoggerProtocol, registration| unsafe {
+        let mut mock_boot_services = MockBootServices::new();
+        mock_boot_services.expect_locate_protocol().returning(|registration| unsafe {
             assert_eq!(registration, None);
             Ok((&ADVANCED_LOGGER_INSTANCE as *const AdvancedLoggerProtocolInterface
                 as *mut AdvancedLoggerProtocolInterface)
@@ -305,8 +297,8 @@ mod tests {
 
     #[test]
     fn debug_macro_should_log_things() {
-        let mut mock_boot_services = boot_services::MockBootServices::new();
-        mock_boot_services.expect_locate_protocol().returning(|_: &AdvancedLoggerProtocol, registration| unsafe {
+        let mut mock_boot_services = MockBootServices::new();
+        mock_boot_services.expect_locate_protocol().returning(|registration| unsafe {
             assert_eq!(registration, None);
             Ok((&ADVANCED_LOGGER_INSTANCE as *const AdvancedLoggerProtocolInterface
                 as *mut AdvancedLoggerProtocolInterface)

Cargo.toml

@@ -20,7 +20,7 @@ mu_rust_helpers = { version = "3" }
 MuTelemetryHelperLib = { path = "MsWheaPkg/Crates/MuTelemetryHelperLib" }
 RustAdvancedLoggerDxe = { path = "AdvLoggerPkg/Crates/RustAdvancedLoggerDxe" }
 RustBootServicesAllocatorDxe = { path = "MsCorePkg/Crates/RustBootServicesAllocatorDxe" }
-mu_uefi_boot_services = { version = "2" }
+patina = { version = "21" }
 mockall = {version = "0.14.0"}
 
 memoffset = "0.9.0"

MsWheaPkg/Crates/MuTelemetryHelperLib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "MuTelemetryHelperLib"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [lib]
 name = "mu_telemetry_helper_lib"
@@ -11,11 +11,11 @@ path = "src/lib.rs"
 mu_pi = { workspace = true }
 mu_rust_helpers = { workspace = true }
 r-efi = { workspace = true }
-mu_uefi_boot_services = { workspace = true }
+patina = { workspace = true }
 
 [dev-dependencies]
 mockall = { workspace = true }
-mu_uefi_boot_services = { workspace = true, features = ["mockall"] }
+patina = { workspace = true, features = ["mockall"] }
 
 [lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }

MsWheaPkg/Crates/MuTelemetryHelperLib/src/lib.rs

@@ -14,7 +14,7 @@
 //!
 //!    //Initialize Boot Services
 //!    unsafe {
-//!        init_telemetry((*system_table).boot_services.as_ref().unwrap());
+//!        init_telemetry((*system_table).boot_services);
 //!    }
 //!
 //!    //if (some_failure) {
@@ -34,16 +34,14 @@
 //!
 #![cfg_attr(target_os = "uefi", no_std)]
 
-mod status_code_runtime;
-
-use boot_services::{BootServices, StandardBootServices};
 use mu_pi::{
     protocols::status_code::{EfiStatusCodeType, EfiStatusCodeValue},
     status_code::{EFI_ERROR_CODE, EFI_ERROR_MAJOR, EFI_ERROR_MINOR},
 };
 use mu_rust_helpers::{guid, guid::guid};
+use patina::boot_services::{BootServices, StandardBootServices};
+use patina::uefi_protocol::status_code::StatusCodeRuntimeProtocol;
 use r_efi::efi;
-use status_code_runtime::{ReportStatusCode, StatusCodeRuntimeProtocol};
 
 static BOOT_SERVICES: StandardBootServices = StandardBootServices::new_uninit();
 
@@ -139,37 +137,38 @@ fn log_telemetry_internal<B: BootServices>(
         additional_info2: extra_data2,
     };
 
-    StatusCodeRuntimeProtocol::report_status_code(
-        boot_services,
+    let protocol = unsafe { boot_services.locate_protocol::<StatusCodeRuntimeProtocol>(None)? };
+
+    let caller_id = component_id.unwrap_or(&guid::CALLER_ID);
+
+    protocol.report_status_code_with_data(
         status_code_type,
         class_id,
         0,
-        component_id,
+        caller_id,
         MS_WHEA_RSC_DATA_TYPE_GUID,
         error_data,
     )
 }
 
 #[cfg(not(tarpaulin_include))]
-pub fn init_telemetry(efi_boot_services: &efi::BootServices) {
-    BOOT_SERVICES.initialize(efi_boot_services)
+pub fn init_telemetry(efi_boot_services: *mut efi::BootServices) {
+    BOOT_SERVICES.init(efi_boot_services)
 }
 
 #[cfg(test)]
 mod test {
-    use boot_services::MockBootServices;
     use mu_pi::protocols::{
         status_code,
         status_code::{EfiStatusCodeData, EfiStatusCodeType, EfiStatusCodeValue},
     };
     use mu_rust_helpers::guid::guid;
+    use patina::boot_services::MockBootServices;
     use r_efi::efi;
 
-    use crate::{
-        log_telemetry_internal, status_code_runtime::StatusCodeRuntimeProtocol, MsWheaRscInternalErrorData,
-        MS_WHEA_ERROR_STATUS_TYPE_FATAL,
-    };
+    use crate::{MS_WHEA_ERROR_STATUS_TYPE_FATAL, MsWheaRscInternalErrorData, log_telemetry_internal};
     use core::mem::size_of;
+    use patina::uefi_protocol::status_code::StatusCodeRuntimeProtocol;
 
     const DATA_SIZE: usize = size_of::<EfiStatusCodeData>() + size_of::<MsWheaRscInternalErrorData>();
     const MOCK_CALLER_ID: efi::Guid = guid!("d0d1d2d3-d4d5-d6d7-d8d9-dadbdcdddedf");
@@ -185,33 +184,28 @@ mod test {
         assert_eq!(value, MOCK_STATUS_CODE_VALUE);
         assert_eq!(instance, 0);
         assert_eq!(unsafe { *caller_id }, MOCK_CALLER_ID);
-        if r#type == MS_WHEA_ERROR_STATUS_TYPE_FATAL {
-            efi::Status::SUCCESS
-        } else {
-            efi::Status::INVALID_PARAMETER
-        }
+        if r#type == MS_WHEA_ERROR_STATUS_TYPE_FATAL { efi::Status::SUCCESS } else { efi::Status::INVALID_PARAMETER }
     }
 
-    static MOCK_STATUS_CODE_RUNTIME_INTERFACE: status_code::Protocol =
-        status_code::Protocol { report_status_code: mock_report_status_code };
+    static MOCK_STATUS_CODE_RUNTIME_INTERFACE: status_code::Protocol = {
+        let f: status_code::ReportStatusCode = mock_report_status_code;
+        status_code::Protocol { report_status_code: f }
+    };
 
     #[test]
     fn try_log_telemetry() {
         let mut mock_boot_services: MockBootServices = MockBootServices::new();
 
-        mock_boot_services.expect_locate_protocol().returning(|_: &StatusCodeRuntimeProtocol, registration| unsafe {
+        mock_boot_services.expect_locate_protocol().returning(|registration| unsafe {
             assert_eq!(registration, None);
-            Ok((&MOCK_STATUS_CODE_RUNTIME_INTERFACE as *const status_code::Protocol as *mut status_code::Protocol)
+            Ok((&MOCK_STATUS_CODE_RUNTIME_INTERFACE as *const status_code::Protocol as *mut StatusCodeRuntimeProtocol)
                 .as_mut()
                 .unwrap())
         });
 
         // Test sizes of "repr(C)" structs
         assert_eq!(size_of::<MsWheaRscInternalErrorData>(), 48);
         assert_eq!(size_of::<[u8; 68]>(), DATA_SIZE);
-
-        // Test Deref trait
-        assert_eq!(*StatusCodeRuntimeProtocol, status_code::PROTOCOL_GUID);
         assert_eq!(
             Ok(()),
             log_telemetry_internal(
@@ -244,7 +238,7 @@ mod test {
     fn test_protocol_not_found() {
         let mut mock_boot_services: MockBootServices = MockBootServices::new();
 
-        mock_boot_services.expect_locate_protocol().returning(|_: &StatusCodeRuntimeProtocol, registration| {
+        mock_boot_services.expect_locate_protocol::<StatusCodeRuntimeProtocol>().returning(|registration| {
             assert_eq!(registration, None);
             //Simulate "marker protocol" without an Interface
             Err(efi::Status::NOT_FOUND)