uefi: use new BootPolicy type

Author: phip1611

uefi-test-runner/src/bin/shell_launcher.rs

@@ -18,6 +18,7 @@ use uefi::prelude::*;
 use uefi::proto::device_path::build::{self, DevicePathBuilder};
 use uefi::proto::device_path::{DevicePath, DeviceSubType, DeviceType, LoadedImageDevicePath};
 use uefi::proto::loaded_image::LoadedImage;
+use uefi::proto::BootPolicy;
 
 /// Get the device path of the shell app. This is the same as the
 /// currently-loaded image's device path, but with the file path part changed.
@@ -53,7 +54,7 @@ fn efi_main() -> Status {
         boot::image_handle(),
         LoadImageSource::FromDevicePath {
             device_path: shell_image_path,
-            from_boot_manager: false,
+            bool_policy: BootPolicy::FALSE,
         },
     )
     .expect("failed to load shell app");

uefi-test-runner/src/boot/mod.rs

@@ -3,6 +3,7 @@ use uefi::fs::FileSystem;
 use uefi::proto::console::text::Output;
 use uefi::proto::device_path::media::FilePath;
 use uefi::proto::device_path::{DevicePath, LoadedImageDevicePath};
+use uefi::proto::BootPolicy;
 use uefi::table::boot::{BootServices, LoadImageSource, SearchType};
 use uefi::table::{Boot, SystemTable};
 use uefi::{boot, CString16, Identify};
@@ -117,7 +118,7 @@ fn test_load_image(bt: &BootServices) {
     {
         let load_source = LoadImageSource::FromDevicePath {
             device_path: image_device_path,
-            from_boot_manager: false,
+            bool_policy: BootPolicy::FALSE,
         };
         let _ = bt
             .load_image(bt.image_handle(), load_source)

uefi-test-runner/src/proto/load.rs

@@ -8,6 +8,7 @@ use core::ptr::addr_of;
 use uefi::prelude::BootServices;
 use uefi::proto::device_path::build::DevicePathBuilder;
 use uefi::proto::media::load_file::{LoadFile, LoadFile2};
+use uefi::proto::BootPolicy;
 use uefi::{Guid, Handle};
 use uefi_raw::protocol::device_path::DevicePathProtocol;
 use uefi_raw::protocol::media::{LoadFile2Protocol, LoadFileProtocol};
@@ -108,7 +109,9 @@ pub fn test(bt: &BootServices) {
     let dvp = dvp.finalize().unwrap();
 
     let mut opened_load_file_protocol = bt.open_protocol_exclusive::<LoadFile>(image).unwrap();
-    let loadfile_file = opened_load_file_protocol.load_file(dvp, true).unwrap();
+    let loadfile_file = opened_load_file_protocol
+        .load_file(dvp, BootPolicy::TRUE)
+        .unwrap();
     let loadfile_file_string = String::from_utf8(loadfile_file.to_vec()).unwrap();
 
     let mut opened_load_file2_protocol = bt.open_protocol_exclusive::<LoadFile2>(image).unwrap();

uefi/CHANGELOG.md

@@ -42,6 +42,8 @@
   > use uefi::mem::memory_map::{MemoryMap, MemoryMapMut, MemoryType};
   > use uefi::table::boot::BootServices;
   ```
+- **Breaking:** Added a new `BootPolicy` type which breaks existing usages
+  of `LoadImageSource`.
 
 
 # uefi - 0.30.0 (2024-08-02)

uefi/src/boot.rs

@@ -14,18 +14,18 @@ use core::{mem, slice};
 use uefi::{table, Char16, Error, Event, Guid, Handle, Result, Status, StatusExt};
 use uefi_raw::table::boot::InterfaceType;
 
+use crate::proto::BootPolicy;
+pub use crate::table::boot::{
+    AllocateType, EventNotifyFn, LoadImageSource, OpenProtocolAttributes, OpenProtocolParams,
+    SearchType, TimerTrigger,
+};
+pub use uefi_raw::table::boot::{EventType, MemoryType, Tpl};
 #[cfg(doc)]
 use {
     crate::proto::device_path::LoadedImageDevicePath, crate::proto::loaded_image::LoadedImage,
     crate::proto::media::fs::SimpleFileSystem,
 };
 
-pub use uefi::table::boot::{
-    AllocateType, EventNotifyFn, LoadImageSource, OpenProtocolAttributes, OpenProtocolParams,
-    SearchType, TimerTrigger,
-};
-pub use uefi_raw::table::boot::{EventType, MemoryType, Tpl};
-
 /// Global image handle. This is only set by [`set_image_handle`], and it is
 /// only read by [`image_handle`].
 static IMAGE_HANDLE: AtomicPtr<c_void> = AtomicPtr::new(ptr::null_mut());
@@ -681,17 +681,17 @@ pub fn load_image(parent_image_handle: Handle, source: LoadImageSource) -> Resul
     match source {
         LoadImageSource::FromBuffer { buffer, file_path } => {
             // Boot policy is ignored when loading from source buffer.
-            boot_policy = 0;
+            boot_policy = BootPolicy::FALSE;
 
             device_path = file_path.map(|p| p.as_ffi_ptr()).unwrap_or(ptr::null());
             source_buffer = buffer.as_ptr();
             source_size = buffer.len();
         }
         LoadImageSource::FromDevicePath {
             device_path: file_path,
-            from_boot_manager,
+            bool_policy,
         } => {
-            boot_policy = u8::from(from_boot_manager);
+            boot_policy = bool_policy;
             device_path = file_path.as_ffi_ptr();
             source_buffer = ptr::null();
             source_size = 0;
@@ -701,7 +701,7 @@ pub fn load_image(parent_image_handle: Handle, source: LoadImageSource) -> Resul
     let mut image_handle = ptr::null_mut();
     unsafe {
         (bt.load_image)(
-            boot_policy,
+            boot_policy.into(),
             parent_image_handle.as_ptr(),
             device_path.cast(),
             source_buffer,

uefi/src/proto/media/load_file.rs

@@ -8,6 +8,7 @@ use uefi_raw::protocol::media::{LoadFile2Protocol, LoadFileProtocol};
 use {
     crate::{mem::make_boxed, proto::device_path::DevicePath, Result, StatusExt},
     alloc::boxed::Box,
+    uefi::proto::BootPolicy,
 };
 
 /// Load File Protocol.
@@ -37,10 +38,7 @@ impl LoadFile {
     ///
     /// # Parameters
     /// - `file_path` The device specific path of the file to load.
-    /// - `boot_policy` If TRUE, indicates that the request originates from the
-    ///   boot manager, and that the boot manager is attempting to load FilePath
-    ///   as a boot selection. If FALSE, then FilePath must match an exact file
-    ///   to be loaded.
+    /// - `boot_policy` The [`BootPolicy`] to use.
     ///
     /// # Errors
     /// - `uefi::status::EFI_SUCCESS` The file was loaded.
@@ -60,12 +58,14 @@ impl LoadFile {
     ///   size needed to complete the request.
     /// - `uefi::status::EFI_WARN_FILE_SYSTEM` The resulting Buffer contains
     ///   UEFI-compliant file system.
+    ///
+    /// [`BootPolicy`]: uefi::proto::BootPolicy
     #[cfg(feature = "alloc")]
     #[allow(clippy::extra_unused_lifetimes)] // false positive, it is used
     pub fn load_file<'a>(
         &mut self,
         file_path: &DevicePath,
-        boot_policy: bool,
+        boot_policy: BootPolicy,
     ) -> Result<Box<[u8]>> {
         let this = core::ptr::addr_of_mut!(*self).cast();
 
@@ -75,7 +75,7 @@ impl LoadFile {
                 (self.0.load_file)(
                     this,
                     file_path.as_ffi_ptr().cast(),
-                    boot_policy,
+                    boot_policy.into(),
                     &mut size,
                     buf.as_mut_ptr().cast(),
                 )

uefi/src/proto/mod.rs

@@ -130,8 +130,8 @@ impl From<u8> for BootPolicy {
     fn from(value: u8) -> Self {
         match value {
             0 => Self::FALSE,
-            1 => Self::TRUE ,
-            _ => panic!("Invalid variant")
+            1 => Self::TRUE,
+            _ => panic!("Invalid variant"),
         }
     }
 }

uefi/src/table/boot.rs

@@ -10,7 +10,7 @@ use crate::mem::memory_map::*;
 use crate::proto::device_path::DevicePath;
 use crate::proto::loaded_image::LoadedImage;
 use crate::proto::media::fs::SimpleFileSystem;
-use crate::proto::{Protocol, ProtocolPointer};
+use crate::proto::{BootPolicy, Protocol, ProtocolPointer};
 use crate::util::opt_nonnull_to_ptr;
 use crate::{Char16, Error, Event, Guid, Handle, Result, Status, StatusExt};
 #[cfg(feature = "alloc")]
@@ -848,17 +848,17 @@ impl BootServices {
         match source {
             LoadImageSource::FromBuffer { buffer, file_path } => {
                 // Boot policy is ignored when loading from source buffer.
-                boot_policy = 0;
+                boot_policy = BootPolicy::FALSE;
 
                 device_path = file_path.map(|p| p.as_ffi_ptr()).unwrap_or(ptr::null());
                 source_buffer = buffer.as_ptr();
                 source_size = buffer.len();
             }
             LoadImageSource::FromDevicePath {
                 device_path: file_path,
-                from_boot_manager,
+                bool_policy,
             } => {
-                boot_policy = u8::from(from_boot_manager);
+                boot_policy = bool_policy;
                 device_path = file_path.as_ffi_ptr();
                 source_buffer = ptr::null();
                 source_size = 0;
@@ -868,7 +868,7 @@ impl BootServices {
         let mut image_handle = ptr::null_mut();
         unsafe {
             (self.0.load_image)(
-                boot_policy,
+                boot_policy.into(),
                 parent_image_handle.as_ptr(),
                 device_path.cast(),
                 source_buffer,
@@ -1403,9 +1403,12 @@ pub enum LoadImageSource<'a> {
 
     /// Load an image via the [`SimpleFileSystem`] protocol. If there is
     /// no instance of that protocol associated with the path then the
-    /// behavior depends on `from_boot_manager`. If `true`, attempt to
-    /// load via the `LoadFile` protocol. If `false`, attempt to load
-    /// via the `LoadFile2` protocol, then fall back to `LoadFile`.
+    /// behavior depends on [`BootPolicy`]. If [`BootPolicy::TRUE`], attempt to
+    /// load via the [`LoadFile`] protocol. If [`BootPolicy::FALSE`], attempt to
+    /// load via the [`LoadFile2`] protocol, then fall back to [`LoadFile`].
+    ///
+    /// [`LoadFile`]: crate::proto::media::load_file::LoadFile
+    /// [`LoadFile2`]: crate::proto::media::load_file::LoadFile2
     FromDevicePath {
         /// The full device path from which to load the image.
         ///
@@ -1416,12 +1419,8 @@ pub enum LoadImageSource<'a> {
         /// and not just `\\EFI\\BOOT\\BOOTX64.EFI`.
         device_path: &'a DevicePath,
 
-        /// If there is no instance of [`SimpleFileSystem`] protocol associated
-        /// with the given device path, then this function will attempt to use
-        /// `LoadFileProtocol` (`from_boot_manager` is `true`) or
-        /// `LoadFile2Protocol`, and then `LoadFileProtocol`
-        /// (`from_boot_manager` is `false`).
-        from_boot_manager: bool,
+        /// The [`BootPolicy`] to use.
+        bool_policy: BootPolicy,
     },
 }