"is_regular_file" for file trait + integration test

Author: phip1611

CHANGELOG.md

@@ -11,6 +11,8 @@
 - Implemented `core::fmt::Write` for the `Serial` protocol.
 - Added the `MemoryProtection` protocol.
 - Added `BootServices::get_handle_for_protocol`.
+- the `File` trait now knows the methods `is_regular_file()` and `is_directory`.
+  Developers profit from this on the struct `FileHandle`, for example.
 
 ### Changed
 
@@ -27,7 +29,7 @@
   version to make sure it's 2.0 or higher before calling the associated
   function pointers. This prevents potential invalid pointer access.
 - The table `Header` struct's `Debug` impl now prints the correct signature.
-  
+
 ### Removed
 
 - Removed the `exts::allocate_buffer` function. This function could

src/proto/media/file/dir.rs

@@ -67,4 +67,12 @@ impl File for Directory {
     fn handle(&mut self) -> &mut FileHandle {
         self.0.handle()
     }
+
+    fn is_regular_file(&self) -> bool {
+        false
+    }
+
+    fn is_directory(&self) -> bool {
+        true
+    }
 }

src/proto/media/file/mod.rs

@@ -214,6 +214,16 @@ pub trait File: Sized {
         // global allocator.
         unsafe { Ok(Box::from_raw(info)) }
     }
+
+    /// Returns true if the file is a regular file.
+    ///
+    /// UEFI file system protocol only knows "regular files" and "directories".
+    fn is_regular_file(&self) -> bool;
+
+    /// Returns if the file is a directory.
+    ///
+    /// UEFI file system protocol only knows "regular files" and "directories".
+    fn is_directory(&self) -> bool;
 }
 
 // Internal File helper methods to access the funciton pointer table.
@@ -242,15 +252,13 @@ impl FileHandle {
 
     /// Converts `File` into a more specific subtype based on if it is a
     /// directory or not. It does this via a call to `get_position`.
-    pub fn into_type(mut self) -> Result<FileType> {
+    pub fn into_type(self) -> Result<FileType> {
         use FileType::*;
 
-        // get_position fails with EFI_UNSUPPORTED on directories
-        let mut pos = 0;
-        match (self.imp().get_position)(self.imp(), &mut pos) {
-            Status::SUCCESS => unsafe { Ok(Regular(RegularFile::new(self))) },
-            Status::UNSUPPORTED => unsafe { Ok(Dir(Directory::new(self))) },
-            s => Err(s.into()),
+        if self.is_regular_file() {
+            unsafe { Ok(Regular(RegularFile::new(self))) }
+        } else {
+            unsafe { Ok(Dir(Directory::new(self))) }
         }
     }
 
@@ -280,6 +288,22 @@ impl File for FileHandle {
     fn handle(&mut self) -> &mut FileHandle {
         self
     }
+
+    fn is_regular_file(&self) -> bool {
+        let this = unsafe { self.0.as_mut().unwrap() };
+
+        // get_position fails with EFI_UNSUPPORTED on directories
+        let mut pos = 0;
+        match (this.get_position)(this, &mut pos) {
+            Status::SUCCESS => true,
+            Status::UNSUPPORTED => false,
+            _ => panic!("unexpected response"),
+        }
+    }
+
+    fn is_directory(&self) -> bool {
+        !self.is_regular_file()
+    }
 }
 
 impl Drop for FileHandle {

src/proto/media/file/regular.rs

@@ -104,4 +104,12 @@ impl File for RegularFile {
     fn handle(&mut self) -> &mut FileHandle {
         &mut self.0
     }
+
+    fn is_regular_file(&self) -> bool {
+        true
+    }
+
+    fn is_directory(&self) -> bool {
+        false
+    }
 }

uefi-test-runner/src/proto/media/mod.rs

@@ -1,10 +1,13 @@
 mod known_disk;
 
 use uefi::prelude::*;
-use uefi::proto::media::file::{Directory, File, FileSystemInfo, FileSystemVolumeLabel};
+use uefi::proto::media::file::{
+    Directory, File, FileAttribute, FileMode, FileSystemInfo, FileSystemVolumeLabel, FileType,
+};
 use uefi::proto::media::fs::SimpleFileSystem;
 use uefi::proto::media::partition::PartitionInfo;
 use uefi::table::boot::{OpenProtocolAttributes, OpenProtocolParams};
+use uefi::CString16;
 
 /// Test `FileSystemInfo` and `FileSystemVolumeLabel`.
 fn test_file_system_info(directory: &mut Directory) {
@@ -24,8 +27,8 @@ fn test_file_system_info(directory: &mut Directory) {
     assert_eq!(fs_info.volume_label(), fs_vol.volume_label());
 }
 
-pub fn test(image: Handle, bt: &BootServices) {
-    info!("Testing Media Access protocols");
+pub fn test_simple_file_system_protocol(image: Handle, bt: &BootServices) {
+    info!("Testing Simple File System Protocol");
 
     if let Ok(handle) = bt.get_handle_for_protocol::<SimpleFileSystem>() {
         let mut sfs = bt
@@ -39,10 +42,10 @@ pub fn test(image: Handle, bt: &BootServices) {
             )
             .expect("failed to open SimpleFileSystem protocol");
 
-        let mut directory = sfs.open_volume().unwrap();
+        let mut root_directory = sfs.open_volume().unwrap();
         let mut buffer = vec![0; 128];
         loop {
-            let file_info = match directory.read_entry(&mut buffer) {
+            let file_info = match root_directory.read_entry(&mut buffer) {
                 Ok(info) => {
                     if let Some(info) = info {
                         info
@@ -60,12 +63,35 @@ pub fn test(image: Handle, bt: &BootServices) {
             };
             info!("Root directory entry: {:?}", file_info);
         }
-        directory.reset_entry_readout().unwrap();
+        root_directory.reset_entry_readout().unwrap();
 
-        test_file_system_info(&mut directory);
+        test_file_system_info(&mut root_directory);
+
+        assert!(root_directory.is_directory());
+        assert!(!root_directory.is_regular_file());
+
+        info!("creating file in root volume");
+        let created_file = root_directory
+            .open(
+                CString16::try_from("foo").unwrap().as_ref(),
+                FileMode::CreateReadWrite,
+                FileAttribute::empty(),
+            )
+            .unwrap();
+        assert!(created_file.is_regular_file());
+        let created_file = match created_file.into_type().unwrap() {
+            FileType::Regular(file) => file,
+            _ => panic!("unsupported value"),
+        };
+        assert!(created_file.is_regular_file());
+        assert!(!created_file.is_directory());
     } else {
         warn!("`SimpleFileSystem` protocol is not available");
     }
+}
+
+pub fn test_partition_info_protocol(image: Handle, bt: &BootServices) {
+    info!("Testing Partition Info protocols");
 
     let handles = bt
         .find_handles::<PartitionInfo>()

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

@@ -15,7 +15,8 @@ pub fn test(image: Handle, st: &mut SystemTable<Boot>) {
     debug::test(image, bt);
     device_path::test(image, bt);
     loaded_image::test(image, bt);
-    media::test(image, bt);
+    media::test_simple_file_system_protocol(image, bt);
+    media::test_partition_info_protocol(image, bt);
     network::test(image, bt);
     pi::test(image, bt);
     rng::test(image, bt);