uefi: Revising function calls, names, and return types to better match standard convention

Author: RenTrieu

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

@@ -3,30 +3,29 @@
 use uefi::boot::ScopedProtocol;
 use uefi::proto::shell::Shell;
 use uefi::{boot, cstr16};
-use uefi_raw::Status;
 
-/// Test `get_cur_dir()` and `set_cur_dir()`
-pub fn test_cur_dir(shell: &ScopedProtocol<Shell>) {
+/// Test `current_dir()` and `set_current_dir()`
+pub fn test_current_dir(shell: &ScopedProtocol<Shell>) {
     /* Test setting and getting current file system and current directory */
     let fs_var = cstr16!("fs0:");
     let dir_var = cstr16!("/");
-    let status = shell.set_cur_dir(Some(fs_var), Some(dir_var));
-    assert_eq!(status, Status::SUCCESS);
+    let status = shell.set_current_dir(Some(fs_var), Some(dir_var));
+    assert!(status.is_ok());
 
     let cur_fs_str = shell
-        .get_cur_dir(Some(fs_var))
+        .current_dir(Some(fs_var))
         .expect("Could not get the current file system mapping");
     let expected_fs_str = cstr16!("FS0:\\");
     assert_eq!(cur_fs_str, expected_fs_str);
 
     // Changing current file system
     let fs_var = cstr16!("fs1:");
     let dir_var = cstr16!("/");
-    let status = shell.set_cur_dir(Some(fs_var), Some(dir_var));
-    assert_eq!(status, Status::SUCCESS);
+    let status = shell.set_current_dir(Some(fs_var), Some(dir_var));
+    assert!(status.is_ok());
 
     let cur_fs_str = shell
-        .get_cur_dir(Some(fs_var))
+        .current_dir(Some(fs_var))
         .expect("Could not get the current file system mapping");
     assert_ne!(cur_fs_str, expected_fs_str);
     let expected_fs_str = cstr16!("FS1:\\");
@@ -35,11 +34,11 @@ pub fn test_cur_dir(shell: &ScopedProtocol<Shell>) {
     // Changing current file system and current directory
     let fs_var = cstr16!("fs0:");
     let dir_var = cstr16!("efi/");
-    let status = shell.set_cur_dir(Some(fs_var), Some(dir_var));
-    assert_eq!(status, Status::SUCCESS);
+    let status = shell.set_current_dir(Some(fs_var), Some(dir_var));
+    assert!(status.is_ok());
 
     let cur_fs_str = shell
-        .get_cur_dir(Some(fs_var))
+        .current_dir(Some(fs_var))
         .expect("Could not get the current file system mapping");
     assert_ne!(cur_fs_str, expected_fs_str);
     let expected_fs_str = cstr16!("FS0:\\efi");
@@ -49,50 +48,50 @@ pub fn test_cur_dir(shell: &ScopedProtocol<Shell>) {
 
     // At this point, the current working file system has not been set
     // So we expect a NULL output
-    assert!(shell.get_cur_dir(None).is_none());
+    assert!(shell.current_dir(None).is_none());
 
     // Setting the current working file system and current working directory
     let dir_var = cstr16!("fs0:/");
-    let status = shell.set_cur_dir(None, Some(dir_var));
-    assert_eq!(status, Status::SUCCESS);
+    let status = shell.set_current_dir(None, Some(dir_var));
+    assert!(status.is_ok());
     let cur_fs_str = shell
-        .get_cur_dir(Some(fs_var))
+        .current_dir(Some(fs_var))
         .expect("Could not get the current file system mapping");
     let expected_fs_str = cstr16!("FS0:");
     assert_eq!(cur_fs_str, expected_fs_str);
 
     let cur_fs_str = shell
-        .get_cur_dir(None)
+        .current_dir(None)
         .expect("Could not get the current file system mapping");
     assert_eq!(cur_fs_str, expected_fs_str);
 
     // Changing current working directory
     let dir_var = cstr16!("/efi");
-    let status = shell.set_cur_dir(None, Some(dir_var));
-    assert_eq!(status, Status::SUCCESS);
+    let status = shell.set_current_dir(None, Some(dir_var));
+    assert!(status.is_ok());
     let cur_fs_str = shell
-        .get_cur_dir(Some(fs_var))
+        .current_dir(Some(fs_var))
         .expect("Could not get the current file system mapping");
     let expected_fs_str = cstr16!("FS0:\\efi");
     assert_eq!(cur_fs_str, expected_fs_str);
     let cur_fs_str = shell
-        .get_cur_dir(None)
+        .current_dir(None)
         .expect("Could not get the current file system mapping");
     assert_eq!(cur_fs_str, expected_fs_str);
 
     // Changing current directory in a non-current working file system
     let fs_var = cstr16!("fs0:");
     let dir_var = cstr16!("efi/tools");
-    let status = shell.set_cur_dir(Some(fs_var), Some(dir_var));
-    assert_eq!(status, Status::SUCCESS);
+    let status = shell.set_current_dir(Some(fs_var), Some(dir_var));
+    assert!(status.is_ok());
     let cur_fs_str = shell
-        .get_cur_dir(None)
+        .current_dir(None)
         .expect("Could not get the current file system mapping");
     assert_ne!(cur_fs_str, expected_fs_str);
 
     let expected_fs_str = cstr16!("FS0:\\efi\\tools");
     let cur_fs_str = shell
-        .get_cur_dir(Some(fs_var))
+        .current_dir(Some(fs_var))
         .expect("Could not get the current file system mapping");
     assert_eq!(cur_fs_str, expected_fs_str);
 }
@@ -105,5 +104,5 @@ pub fn test() {
     let shell =
         boot::open_protocol_exclusive::<Shell>(handle).expect("Failed to open Shell protocol");
 
-    test_cur_dir(&shell);
+    test_current_dir(&shell);
 }

uefi/src/proto/shell/mod.rs

@@ -3,20 +3,18 @@
 //! EFI Shell Protocol v2.2
 
 use uefi_macros::unsafe_protocol;
-use uefi_raw::Status;
 
 use core::ptr;
 
 use uefi_raw::protocol::shell::ShellProtocol;
 
-use crate::{CStr16, Char16};
+use crate::{CStr16, Char16, Result, StatusExt};
 
 /// Shell Protocol
 #[derive(Debug)]
 #[repr(transparent)]
 #[unsafe_protocol(ShellProtocol::GUID)]
 pub struct Shell(ShellProtocol);
-
 impl Shell {
     /// Returns the current directory on the specified device
     ///
@@ -30,8 +28,8 @@ impl Shell {
     /// * `Some(cwd)` - CStr16 containing the current working directory
     /// * `None` - Could not retrieve current directory
     #[must_use]
-    pub fn get_cur_dir(&self, file_system_mapping: Option<&CStr16>) -> Option<&CStr16> {
-        let mapping_ptr: *const Char16 = file_system_mapping.map_or(ptr::null(), |x| (x.as_ptr()));
+    pub fn current_dir(&self, file_system_mapping: Option<&CStr16>) -> Option<&CStr16> {
+        let mapping_ptr: *const Char16 = file_system_mapping.map_or(ptr::null(), CStr16::as_ptr);
         let cur_dir = unsafe { (self.0.get_cur_dir)(mapping_ptr.cast()) };
         if cur_dir.is_null() {
             None
@@ -55,9 +53,13 @@ impl Shell {
     /// # Errors
     ///
     /// * `Status::EFI_NOT_FOUND` - The directory does not exist
-    pub fn set_cur_dir(&self, file_system: Option<&CStr16>, directory: Option<&CStr16>) -> Status {
-        let fs_ptr: *const Char16 = file_system.map_or(ptr::null(), |x| (x.as_ptr()));
-        let dir_ptr: *const Char16 = directory.map_or(ptr::null(), |x| (x.as_ptr()));
-        unsafe { (self.0.set_cur_dir)(fs_ptr.cast(), dir_ptr.cast()) }
+    pub fn set_current_dir(
+        &self,
+        file_system: Option<&CStr16>,
+        directory: Option<&CStr16>,
+    ) -> Result {
+        let fs_ptr: *const Char16 = file_system.map_or(ptr::null(), |x| x.as_ptr());
+        let dir_ptr: *const Char16 = directory.map_or(ptr::null(), |x| x.as_ptr());
+        unsafe { (self.0.set_cur_dir)(fs_ptr.cast(), dir_ptr.cast()) }.to_result()
     }
 }