fs: add high-level file system abstraction

Author: phip1611

Cargo.lock

@@ -0,0 +1,54 @@
+//! Tests functionality from the `uefi::fs` module. See function [`test`].
+
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use uefi::fs::{FileSystem, FileSystemError};
+use uefi::proto::media::fs::SimpleFileSystem;
+use uefi::table::boot::ScopedProtocol;
+
+/// Tests functionality from the `uefi::fs` module. This test relies on a
+/// working File System Protocol, which is tested at a dedicated place.
+pub fn test(sfs: ScopedProtocol<SimpleFileSystem>) {
+    let mut fs = FileSystem::new(sfs);
+
+    fs.create_dir("test_file_system_abs").unwrap();
+
+    // slash is transparently transformed to backslash
+    fs.write("test_file_system_abs/foo", "hello").unwrap();
+    // absolute or relative paths are supported; ./ is ignored
+    fs.copy("\\test_file_system_abs/foo", "\\test_file_system_abs/./bar")
+        .unwrap();
+    let read = fs.read("\\test_file_system_abs\\bar").unwrap();
+    let read = String::from_utf8(read).unwrap();
+    assert_eq!(read, "hello");
+
+    assert_eq!(
+        fs.try_exists("test_file_system_abs\\barfoo"),
+        Err(FileSystemError::OpenError(
+            "\\test_file_system_abs\\barfoo".to_string()
+        ))
+    );
+    fs.rename("test_file_system_abs\\bar", "test_file_system_abs\\barfoo")
+        .unwrap();
+    assert!(fs.try_exists("test_file_system_abs\\barfoo").is_ok());
+
+    let entries = fs
+        .read_dir("test_file_system_abs")
+        .unwrap()
+        .map(|e| e.unwrap().file_name().to_string())
+        .collect::<Vec<_>>();
+    assert_eq!(&[".", "..", "foo", "barfoo"], entries.as_slice());
+
+    /*fs.create_dir("/deeply_nested_test").unwrap();
+    fs.create_dir("/deeply_nested_test/1").unwrap();
+    fs.create_dir("/deeply_nested_test/1/2").unwrap();
+    fs.create_dir("/deeply_nested_test/1/2/3").unwrap();
+    fs.create_dir("/deeply_nested_test/1/2/3/4").unwrap();*/
+    fs.create_dir_all("/deeply_nested_test/1/2/3/4/5/6/7")
+        .unwrap();
+    fs.try_exists("/deeply_nested_test/1/2/3/4/5/6/7").unwrap();
+    //fs.remove_dir_all("/deeply_nested_test/1/2/3/4/5/6/7").unwrap();
+    fs.remove_dir("/deeply_nested_test/1/2/3/4/5/6/7").unwrap();
+    let x = fs.try_exists("/deeply_nested_test/1/2/3/4/5/6/7");
+    assert!(x.is_err());
+}

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

@@ -13,6 +13,7 @@ use uefi::Result;
 use uefi_services::{print, println};
 
 mod boot;
+mod fs;
 mod proto;
 mod runtime;
 

uefi-test-runner/src/main.rs

@@ -433,8 +433,12 @@ pub fn test(bt: &BootServices) {
         test_partition_info(bt, handle);
     }
 
-    // Close the `SimpleFileSystem` protocol so that the raw disk tests work.
-    drop(sfs);
+    // Invoke the fs test after the basic low-level file system protocol
+    // tests succeeded.
+
+    // This will also drop the `SimpleFileSystem` protocol so that the raw disk
+    // tests work.
+    crate::fs::test(sfs);
 
     test_raw_disk_io(handle, bt);
     test_raw_disk_io2(handle, bt);

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

@@ -25,6 +25,7 @@ unstable = []
 
 [dependencies]
 bitflags = "1.3.1"
+derive_more = { version = "0.99.17", features = ["display"] }
 log = { version = "0.4.5", default-features = false }
 ptr_meta = { version = "0.2.0", default-features = false }
 ucs2 = "0.3.2"

uefi/Cargo.toml

@@ -0,0 +1,31 @@
+//! Module for directory iteration. See [`UefiDirectoryIter`].
+
+use super::*;
+use alloc::boxed::Box;
+use uefi::Result;
+
+/// Iterates over the entries of an UEFI directory. It returns boxed values of
+/// type [`UefiFileInfo`].
+#[derive(Debug)]
+pub struct UefiDirectoryIter(UefiDirectoryHandle);
+
+impl UefiDirectoryIter {
+    /// Constructor.
+    pub fn new(handle: UefiDirectoryHandle) -> Self {
+        Self(handle)
+    }
+}
+
+impl Iterator for UefiDirectoryIter {
+    type Item = Result<Box<UefiFileInfo>, ()>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let e = self.0.read_entry_boxed();
+        match e {
+            // no more entries
+            Ok(None) => None,
+            Ok(Some(e)) => Some(Ok(e)),
+            Err(e) => Some(Err(e)),
+        }
+    }
+}