html-to-markdown 2.27.2 → 2.27.3

data/rust-vendor/r-efi/NEWS.md

@@ -1,5 +1,21 @@
 # r-efi - UEFI Reference Specification Protocol Constants and Definitions
 
+## CHANGES WITH 6.0.0:
+
+        * Change all function prototypes to use `unsafe fn`. This is a major
+          change, but reflects what all downstream users have already assumed.
+
+        * Drop the obsolete `efiapi` and `examples` feature flags. The former
+          was unused, and the latter is an alias for `native`.
+
+        * The `eficall!{}` macro is now fully inline in all of r-efi. It is
+          still provided for external users, but will no longer be used by
+          r-efi. All users are recommended to use `extern "efiapi"` directly.
+
+        Contributions from: Alan Egerton, David Rheinsberg
+
+        - Dußlingen, 2026-02-03
+
 ## CHANGES WITH 5.3.0:
 
         * Remove the optional dependency on `compiler-builtins`, which was

data/rust-vendor/r-efi/src/base.rs

@@ -353,7 +353,7 @@ pub type VirtualAddress = u64;
 /// invocation, if invoked as an UEFI driver.
 /// In most cases it is perfectly fine to cast the pointer to a real rust reference. However, this
 /// should be an explicit decision by the caller.
-pub type ImageEntryPoint = eficall! {fn(Handle, *mut crate::system::SystemTable) -> Status};
+pub type ImageEntryPoint = unsafe extern "efiapi" fn(Handle, *mut crate::system::SystemTable) -> Status;
 
 /// Globally Unique Identifiers
 ///

data/rust-vendor/r-efi/src/lib.rs

@@ -71,22 +71,37 @@
 //!    pointers, we use `Option<fn ...>`.
 //!
 //!  * `prefer *mut over *const`: Whenever we transpose pointers from the
-//!    specification into Rust, we prefer `*mut` in almost all cases. `*const`
-//!    should only be used if the underlying value is known not to be accessible
-//!    via any other mutable pointer type. Since this is rarely the case in
-//!    UEFI, we avoid it.
-//!
-//!    The reasoning is that Rust allows coercing immutable types into `*const`
-//!    pointers, without any explicit casting required. However, immutable Rust
-//!    references require that no other mutable reference exists simultaneously.
-//!    This is not a guarantee of `const`-pointers in C / UEFI, hence this
-//!    coercion is usually ill-advised or even wrong.
-//!
-//!    Lastly, note that `*mut` and `*const` and be `as`-casted in both
+//!    specification into Rust, we default to `*mut`. So far, there is no
+//!    reason to use `*const`. We prefer `*mut T`, because:
+//!
+//!    * it is invariant over `T`, unlike `*const T`, which is covariant over
+//!      `T`. This variance is useful when treating the raw pointer like a
+//!      shared reference (which is also covariant over `T`). However, if the
+//!      raw pointer can be aliases by mutable pointers somewhere in the UEFI
+//!      stack, the variance might no longer apply. Using `*mut T` avoids this
+//!      default covariance, and requires callers to introduce manually if
+//!      desired.
+//!    * it cannot be automatically coerced from shared references. This
+//!      coercion is not necessarily correct, given that `const T *` pointers
+//!      in C do not share the immutability guarantee of Rust shared
+//!      references. By using `*mut T` an explicit pointer cast is required,
+//!      which we definitely want.
+//!    * it correctly conveys mutability to Miri Stacked Borrows. While Tree
+//!      Borrows do not distinguish raw pointers, Stacked Borrows do, and they
+//!      require a pointer to originate from a mutable reference if mutability
+//!      is desired.
+//!
+//!    Lastly, note that `*mut` and `*const` can be `as`-casted in both
 //!    directions without violating any Rust guarantees. Any UB concerns always
 //!    stem from the safety guarantees of the surrounding code, not of the
 //!    raw-pointer handling.
 //!
+//!  * `default to unsafe fn`: Always use `unsafe fn` for function prototypes.
+//!    UEFI makes no guarantees about global state, as such any implementation
+//!    of any UEFI prototype might introduce unsafety. Use `unsafe fn`
+//!    unconditionally, so the prototypes can be used for externally provided
+//!    code.
+//!
 //! # Specification Details
 //!
 //! This section lists errata of, and general comments on, the UEFI

data/rust-vendor/r-efi/src/protocols/absolute_pointer.rs

@@ -50,15 +50,15 @@ pub struct State {
     pub active_buttons: u32,
 }
 
-pub type Reset = eficall! {fn(
+pub type Reset = unsafe extern "efiapi" fn(
     this: *mut Protocol,
     extended_verification: bool,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type GetState = eficall! {fn(
+pub type GetState = unsafe extern "efiapi" fn(
     this: *mut Protocol,
     state: *mut State,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/block_io.rs

@@ -34,30 +34,30 @@ pub struct Media {
     pub optimal_transfer_length_granularity: u32,
 }
 
-pub type ProtocolReset = eficall! {fn(
+pub type ProtocolReset = unsafe extern "efiapi" fn(
     *mut Protocol,
     crate::base::Boolean,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolReadBlocks = eficall! {fn(
+pub type ProtocolReadBlocks = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     crate::base::Lba,
     usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolWriteBlocks = eficall! {fn(
+pub type ProtocolWriteBlocks = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     crate::base::Lba,
     usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolFlushBlocks = eficall! {fn(
+pub type ProtocolFlushBlocks = unsafe extern "efiapi" fn(
     *mut Protocol,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/bus_specific_driver_override.rs

@@ -21,10 +21,10 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
     &[0x4d, 0x7d, 0x13, 0xfb, 0x32, 0x65],
 );
 
-pub type ProtocolGetDriver = eficall! {fn(
+pub type ProtocolGetDriver = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut crate::base::Handle,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/debug_support.rs

@@ -796,34 +796,34 @@ pub const EXCEPT_RISCV_MACHINE_TIMER_INT: ExceptionType = 7;
 pub const EXCEPT_RISCV_SUPERVISOR_EXTERNAL_INT: ExceptionType = 9;
 pub const EXCEPT_RISCV_MACHINE_EXTERNAL_INT: ExceptionType = 11;
 
-pub type GetMaximumProcessorIndex = eficall! {fn(
+pub type GetMaximumProcessorIndex = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut usize,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type PeriodicCallback = eficall! {fn(SystemContext)};
+pub type PeriodicCallback = unsafe extern "efiapi" fn(SystemContext);
 
-pub type RegisterPeriodicCallback = eficall! {fn(
+pub type RegisterPeriodicCallback = unsafe extern "efiapi" fn(
     *mut Protocol,
     usize,
     Option<PeriodicCallback>,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ExceptionCallback = eficall! {fn(ExceptionType, SystemContext)};
+pub type ExceptionCallback = unsafe extern "efiapi" fn(ExceptionType, SystemContext);
 
-pub type RegisterExceptionCallback = eficall! {fn(
+pub type RegisterExceptionCallback = unsafe extern "efiapi" fn(
     *mut Protocol,
     usize,
     Option<ExceptionCallback>,
     ExceptionType,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type InvalidateInstructionCache = eficall! {fn(
+pub type InvalidateInstructionCache = unsafe extern "efiapi" fn(
     *mut Protocol,
     usize,
     *mut core::ffi::c_void,
     u64,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/debugport.rs

@@ -11,27 +11,27 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
     &[0x26, 0x47, 0xba, 0x96, 0x60, 0xd0],
 );
 
-pub type Reset = eficall! {fn(
+pub type Reset = unsafe extern "efiapi" fn(
     *mut Protocol,
-) -> *mut crate::base::Status};
+) -> *mut crate::base::Status;
 
-pub type Write = eficall! {fn(
+pub type Write = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     *mut usize,
     *mut core::ffi::c_void
-) -> *mut crate::base::Status};
+) -> *mut crate::base::Status;
 
-pub type Read = eficall! {fn(
+pub type Read = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     *mut usize,
     *mut core::ffi::c_void
-) -> *mut crate::base::Status};
+) -> *mut crate::base::Status;
 
-pub type Poll = eficall! {fn(
+pub type Poll = unsafe extern "efiapi" fn(
     *mut Protocol,
-) -> *mut crate::base::Status};
+) -> *mut crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/decompress.rs

@@ -12,15 +12,15 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
     &[0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d],
 );
 
-pub type ProtocolGetInfo = eficall! {fn(
+pub type ProtocolGetInfo = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut core::ffi::c_void,
     u32,
     *mut u32,
     *mut u32,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolDecompress = eficall! {fn(
+pub type ProtocolDecompress = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut core::ffi::c_void,
     u32,
@@ -28,7 +28,7 @@ pub type ProtocolDecompress = eficall! {fn(
     u32,
     *mut core::ffi::c_void,
     u32,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/device_path_from_text.rs

@@ -11,13 +11,13 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
     &[0x35, 0xdf, 0x33, 0x43, 0xf5, 0x1e],
 );
 
-pub type DevicePathFromTextNode = eficall! {fn(
+pub type DevicePathFromTextNode = unsafe extern "efiapi" fn(
     *const crate::base::Char16,
-) -> *mut crate::protocols::device_path::Protocol};
+) -> *mut crate::protocols::device_path::Protocol;
 
-pub type DevicePathFromTextPath = eficall! {fn(
+pub type DevicePathFromTextPath = unsafe extern "efiapi" fn(
     *const crate::base::Char16,
-) -> *mut crate::protocols::device_path::Protocol};
+) -> *mut crate::protocols::device_path::Protocol;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/device_path_to_text.rs

@@ -11,17 +11,17 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
     &[0x55, 0x1a, 0x4e, 0x4a, 0x7f, 0x1c],
 );
 
-pub type DevicePathToTextNode = eficall! {fn(
+pub type DevicePathToTextNode = unsafe extern "efiapi" fn(
     *mut crate::protocols::device_path::Protocol,
     crate::base::Boolean,
     crate::base::Boolean,
-) -> *mut crate::base::Char16};
+) -> *mut crate::base::Char16;
 
-pub type DevicePathToTextPath = eficall! {fn(
+pub type DevicePathToTextPath = unsafe extern "efiapi" fn(
     *mut crate::protocols::device_path::Protocol,
     crate::base::Boolean,
     crate::base::Boolean,
-) -> *mut crate::base::Char16};
+) -> *mut crate::base::Char16;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/device_path_utilities.rs

@@ -12,43 +12,43 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
     &[0xed, 0xb8, 0x2f, 0xb7, 0x72, 0xa4],
 );
 
-pub type ProtocolGetDevicePathSize = eficall! {fn(
+pub type ProtocolGetDevicePathSize = unsafe extern "efiapi" fn(
     *const crate::protocols::device_path::Protocol,
-) -> usize};
+) -> usize;
 
-pub type ProtocolDuplicateDevicePath = eficall! {fn(
+pub type ProtocolDuplicateDevicePath = unsafe extern "efiapi" fn(
     *const crate::protocols::device_path::Protocol,
-) -> *mut crate::protocols::device_path::Protocol};
+) -> *mut crate::protocols::device_path::Protocol;
 
-pub type ProtocolAppendDevicePath = eficall! {fn(
+pub type ProtocolAppendDevicePath = unsafe extern "efiapi" fn(
     *const crate::protocols::device_path::Protocol,
     *const crate::protocols::device_path::Protocol,
-) -> *mut crate::protocols::device_path::Protocol};
+) -> *mut crate::protocols::device_path::Protocol;
 
-pub type ProtocolAppendDeviceNode = eficall! {fn(
+pub type ProtocolAppendDeviceNode = unsafe extern "efiapi" fn(
     *const crate::protocols::device_path::Protocol,
     *const crate::protocols::device_path::Protocol,
-) -> *mut crate::protocols::device_path::Protocol};
+) -> *mut crate::protocols::device_path::Protocol;
 
-pub type ProtocolAppendDevicePathInstance = eficall! {fn(
+pub type ProtocolAppendDevicePathInstance = unsafe extern "efiapi" fn(
     *const crate::protocols::device_path::Protocol,
     *const crate::protocols::device_path::Protocol,
-) -> *mut crate::protocols::device_path::Protocol};
+) -> *mut crate::protocols::device_path::Protocol;
 
-pub type ProtocolGetNextDevicePathInstance = eficall! {fn(
+pub type ProtocolGetNextDevicePathInstance = unsafe extern "efiapi" fn(
     *mut *mut crate::protocols::device_path::Protocol,
     *mut usize,
-) -> *mut crate::protocols::device_path::Protocol};
+) -> *mut crate::protocols::device_path::Protocol;
 
-pub type ProtocolIsDevicePathMultiInstance = eficall! {fn(
+pub type ProtocolIsDevicePathMultiInstance = unsafe extern "efiapi" fn(
     *const crate::protocols::device_path::Protocol,
-) -> crate::base::Boolean};
+) -> crate::base::Boolean;
 
-pub type ProtocolCreateDeviceNode = eficall! {fn(
+pub type ProtocolCreateDeviceNode = unsafe extern "efiapi" fn(
     u8,
     u8,
     u16,
-) -> *mut crate::protocols::device_path::Protocol};
+) -> *mut crate::protocols::device_path::Protocol;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/disk_io.rs

@@ -16,21 +16,21 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
 
 pub const REVISION: u64 = 0x0000000000010000u64;
 
-pub type ProtocolReadDisk = eficall! {fn(
+pub type ProtocolReadDisk = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     u64,
     usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolWriteDisk = eficall! {fn(
+pub type ProtocolWriteDisk = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     u64,
     usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/disk_io2.rs

@@ -21,32 +21,32 @@ pub struct Token {
     transaction_status: crate::base::Status,
 }
 
-pub type ProtocolCancel = eficall! {fn(
+pub type ProtocolCancel = unsafe extern "efiapi" fn(
     *mut Protocol,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolReadDiskEx = eficall! {fn(
+pub type ProtocolReadDiskEx = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     u64,
     *mut Token,
     usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolWriteDiskEx = eficall! {fn(
+pub type ProtocolWriteDiskEx = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     u64,
     *mut Token,
     usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolFlushDiskEx = eficall! {fn(
+pub type ProtocolFlushDiskEx = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut Token,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/driver_binding.rs

@@ -12,24 +12,24 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
     &[0x0c, 0x09, 0x26, 0x1e, 0x9f, 0x71],
 );
 
-pub type ProtocolSupported = eficall! {fn(
+pub type ProtocolSupported = unsafe extern "efiapi" fn(
     *mut Protocol,
     crate::base::Handle,
     *mut crate::protocols::device_path::Protocol,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolStart = eficall! {fn(
+pub type ProtocolStart = unsafe extern "efiapi" fn(
     *mut Protocol,
     crate::base::Handle,
     *mut crate::protocols::device_path::Protocol,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolStop = eficall! {fn(
+pub type ProtocolStop = unsafe extern "efiapi" fn(
     *mut Protocol,
     crate::base::Handle,
     usize,
     *mut crate::base::Handle,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/driver_diagnostics2.rs

@@ -20,7 +20,7 @@ pub const TYPE_MANUFACTURING: Type = 2;
 pub const TYPE_CANCEL: Type = 3;
 pub const TYPE_MAXIMUM: Type = 4;
 
-pub type RunDiagnostics = eficall! {fn(
+pub type RunDiagnostics = unsafe extern "efiapi" fn(
     *mut Protocol,
     crate::base::Handle,
     crate::base::Handle,
@@ -29,7 +29,7 @@ pub type RunDiagnostics = eficall! {fn(
     *mut *mut crate::base::Guid,
     *mut usize,
     *mut *mut crate::base::Char16,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/driver_family_override.rs

@@ -13,9 +13,9 @@ pub const PROTOCOL_GUID: crate::base::Guid = crate::base::Guid::from_fields(
     &[0x04, 0xa4, 0x92, 0x37, 0x66, 0xa7],
 );
 
-pub type ProtocolGetVersion = eficall! {fn(
+pub type ProtocolGetVersion = unsafe extern "efiapi" fn(
     *mut Protocol,
-) -> u32};
+) -> u32;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/file.rs

@@ -83,85 +83,85 @@ pub struct SystemVolumeLabel<const N: usize = 0> {
     pub volume_label: [crate::base::Char16; N],
 }
 
-pub type ProtocolOpen = eficall! {fn(
+pub type ProtocolOpen = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut *mut Protocol,
     *mut crate::base::Char16,
     u64,
     u64,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolClose = eficall! {fn(
+pub type ProtocolClose = unsafe extern "efiapi" fn(
     *mut Protocol,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolDelete = eficall! {fn(
+pub type ProtocolDelete = unsafe extern "efiapi" fn(
     *mut Protocol,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolRead = eficall! {fn(
+pub type ProtocolRead = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolWrite = eficall! {fn(
+pub type ProtocolWrite = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolGetPosition = eficall! {fn(
+pub type ProtocolGetPosition = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut u64,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolSetPosition = eficall! {fn(
+pub type ProtocolSetPosition = unsafe extern "efiapi" fn(
     *mut Protocol,
     u64,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolGetInfo = eficall! {fn(
+pub type ProtocolGetInfo = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut crate::base::Guid,
     *mut usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolSetInfo = eficall! {fn(
+pub type ProtocolSetInfo = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut crate::base::Guid,
     usize,
     *mut core::ffi::c_void,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolFlush = eficall! {fn(
+pub type ProtocolFlush = unsafe extern "efiapi" fn(
     *mut Protocol,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolOpenEx = eficall! {fn(
+pub type ProtocolOpenEx = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut *mut Protocol,
     *mut crate::base::Char16,
     u64,
     u64,
     *mut IoToken,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolReadEx = eficall! {fn(
+pub type ProtocolReadEx = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut IoToken,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolWriteEx = eficall! {fn(
+pub type ProtocolWriteEx = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut IoToken,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolFlushEx = eficall! {fn(
+pub type ProtocolFlushEx = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut IoToken,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {

data/rust-vendor/r-efi/src/protocols/graphics_output.rs

@@ -69,19 +69,19 @@ pub const BLT_BUFFER_TO_VIDEO: BltOperation = 0x00000002;
 pub const BLT_VIDEO_TO_VIDEO: BltOperation = 0x00000003;
 pub const BLT_OPERATION_MAX: BltOperation = 0x00000004;
 
-pub type ProtocolQueryMode = eficall! {fn(
+pub type ProtocolQueryMode = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
     *mut usize,
     *mut *mut ModeInformation,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolSetMode = eficall! {fn(
+pub type ProtocolSetMode = unsafe extern "efiapi" fn(
     *mut Protocol,
     u32,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
-pub type ProtocolBlt = eficall! {fn(
+pub type ProtocolBlt = unsafe extern "efiapi" fn(
     *mut Protocol,
     *mut BltPixel,
     BltOperation,
@@ -92,7 +92,7 @@ pub type ProtocolBlt = eficall! {fn(
     usize,
     usize,
     usize,
-) -> crate::base::Status};
+) -> crate::base::Status;
 
 #[repr(C)]
 pub struct Protocol {