patina 21.1.1

Common types and functionality used in UEFI development.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

//! Status Code Protocol
//!
//! Provides the protocol required to report a status code to the platform firmware.
//!
//! See <https://uefi.org/specs/PI/1.8A/V2_DXE_Runtime_Protocols.html#efi-status-code-protocol>
//!
//! ## License
//!
//! Copyright (c) Microsoft Corporation.
//!
//! SPDX-License-Identifier: Apache-2.0
//!
use core::{mem, ptr, slice};

use r_efi::efi;

use crate::pi::protocols::status_code::{
    self, EfiStatusCodeData, EfiStatusCodeType, EfiStatusCodeValue, ReportStatusCode,
};

use super::ProtocolInterface;

/// Rust definition of the UEFI Status Code Protocol.
///
/// <https://uefi.org/specs/PI/1.9/V2_DXE_Runtime_Protocols.html#status-code-runtime-protocol>
#[repr(transparent)]
pub struct StatusCodeRuntimeProtocol {
    protocol: status_code::Protocol,
}

// SAFETY: StatusCodeRuntimeProtocol implements the UEFI Status Code Runtime protocol interface.
// The PROTOCOL_GUID matches the PI specification. The repr(transparent) ensures that the
// structure layout matches the underlying r_efi protocol definition.
unsafe impl ProtocolInterface for StatusCodeRuntimeProtocol {
    const PROTOCOL_GUID: crate::BinaryGuid = status_code::PROTOCOL_GUID;
}

impl StatusCodeRuntimeProtocol {
    /// Creates a new instance of the Status Code Runtime Protocol with the given implementation.
    pub fn new(report_status_code: ReportStatusCode) -> Self {
        Self { protocol: status_code::Protocol { report_status_code } }
    }

    /// Reports a status code to the platform firmware with data.
    pub fn report_status_code_with_data<T>(
        &self,
        status_code_type: EfiStatusCodeType,
        status_code_value: EfiStatusCodeValue,
        instance: u32,
        caller_id: &efi::Guid,
        data_type: efi::Guid,
        data: T,
    ) -> Result<(), efi::Status>
    where
        T: Sized,
    {
        let header = EfiStatusCodeData {
            header_size: mem::size_of::<EfiStatusCodeData>() as u16,
            size: mem::size_of::<T>() as u16,
            r#type: data_type,
        };

        let mut data_buffer = [any_as_u8_slice(&header), any_as_u8_slice(&data)].concat();
        let data_ptr: *mut EfiStatusCodeData = data_buffer.as_mut_ptr() as *mut EfiStatusCodeData;

        let status =
            (self.protocol.report_status_code)(status_code_type, status_code_value, instance, caller_id, data_ptr);

        if status.is_error() { Err(status) } else { Ok(()) }
    }

    /// Reports a status code to the platform firmware without data.
    pub fn report_status_code(
        &self,
        status_code_type: EfiStatusCodeType,
        status_code_value: EfiStatusCodeValue,
        instance: u32,
        caller_id: &efi::Guid,
    ) -> Result<(), efi::Status> {
        let status = (self.protocol.report_status_code)(
            status_code_type,
            status_code_value,
            instance,
            caller_id,
            ptr::null_mut(),
        );
        if status.is_error() { Err(status) } else { Ok(()) }
    }
}

fn any_as_u8_slice<T: Sized>(p: &T) -> &[u8] {
    // SAFETY: P is a ref thus a valid pointer and since the type is sized, the memory boundary of this type is known.
    unsafe { slice::from_raw_parts((p as *const T) as *const u8, mem::size_of::<T>()) }
}