[Fixed] nits and only readonly hook called.

Author: sky5454

uefi-raw/CHANGELOG.md

@@ -1,7 +1,7 @@
 # uefi-raw - [Unreleased]
 
 ## Added
-- Added `ResetNotification`.
+- Added `ResetNotificationProtocol`.
 
 ## Added
 - Added `TimestampProtocol`.

uefi-raw/src/protocol/misc.rs

@@ -1,5 +1,5 @@
-use crate::{guid, Guid, Status};
 use crate::table::runtime;
+use crate::{guid, Guid, Status};
 
 #[derive(Debug)]
 #[repr(C)]
@@ -28,15 +28,20 @@ pub struct TimestampProperties {
 #[derive(Debug)]
 #[repr(C)]
 pub struct ResetNotificationProtocol {
-    pub register_reset_notify: unsafe extern "efiapi" fn(this: *const Self, reset_function: Option<ResetSystemFn>) -> Status,
-    pub unregister_reset_notify: unsafe extern "efiapi" fn(this: *const Self, reset_function: Option<ResetSystemFn>) -> Status,
+    pub register_reset_notify: unsafe extern "efiapi" fn(
+        this: *const Self,
+        reset_function: Option<ResetSystemFn>,
+    ) -> Status,
+    pub unregister_reset_notify: unsafe extern "efiapi" fn(
+        this: *const Self,
+        reset_function: Option<ResetSystemFn>,
+    ) -> Status,
 }
 
 impl ResetNotificationProtocol {
     pub const GUID: Guid = guid!("9da34ae0-eaf9-4bbf-8ec3-fd60226c44be");
 }
 
-
 /// Raw reset notification function, to be called if you register it when a RestSystem() is executed.
 // copy from uefi-raw/src/table/runtime.rs:53  at commit@6093205c3eb27b2e78be4c003c04d46679bff420
 pub type ResetSystemFn = unsafe extern "efiapi" fn(

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

@@ -3,55 +3,66 @@ use uefi::proto::misc::{ResetNotification, Timestamp};
 use uefi::table::runtime;
 
 ///
-/// you may see those log, it's nothing just for your computer firmware does not support the new UEFI feature.
+/// you may see those log, it's nothing just for your computer firmware does not support the new UEFI feature of Timestamp Protocol.
 ///
 /// ```sh
-/// [ INFO]: uefi-test-runner\src\proto\misc.rs@012: Running loaded Timestamp Protocol test
-/// [ WARN]: uefi-test-runner\src\proto\misc.rs@026: Failed to open Timestamp Protocol: Error { status: UNSUPPORTED, data: () }
-/// [ INFO]: uefi-test-runner\src\proto\misc.rs@033: Running loaded ResetNotification protocol test
-/// [ WARN]: uefi-test-runner\src\proto\misc.rs@068: Failed to open ResetNotification Protocol: Error { status: UNSUPPORTED, data: () }
+/// [ INFO]: uefi-test-runner\src\proto\misc.rs@020: Running loaded Timestamp Protocol test
+/// [ WARN]: uefi-test-runner\src\proto\misc.rs@037: Failed to found Timestamp Protocol: Error { status: NOT_FOUND, data: () }
+/// [ INFO]: uefi-test-runner\src\proto\misc.rs@043: Running loaded ResetNotification protocol test
+/// [ INFO]: uefi-test-runner\src\proto\misc.rs@053: ResetNotification Protocol register null test: Err(Error { status: INVALID_PARAMETER, data: () })
+/// [ INFO]: uefi-test-runner\src\proto\misc.rs@059: ResetNotification Protocol unregister null test: Err(Error { status: INVALID_PARAMETER, data: () })
+/// [ INFO]: uefi-test-runner\src\proto\misc.rs@078: ResetNotification Protocol register efi_reset_fn test: Ok(())
+/// [ INFO]: uefi-test-runner\src\proto\misc.rs@084: ResetNotification Protocol unregister efi_reset_fn test: Ok(())
 /// ```
-pub fn test(image: Handle, bt: &BootServices) {
-    test_timestamp(image, bt);
-    test_reset_notification(image, bt);
+pub fn test(bt: &BootServices) {
+    test_timestamp(bt);
+    test_reset_notification(bt);
 }
 
-pub fn test_timestamp(image: Handle, bt: &BootServices) {
+pub fn test_timestamp(bt: &BootServices) {
     info!("Running loaded Timestamp Protocol test");
 
-    let result = bt
-        .open_protocol_exclusive::<Timestamp>(image);
+    let handle = bt.get_handle_for_protocol::<Timestamp>();
+
+    match handle {
+        Ok(handle) => {
+            let timestamp_proto = bt
+                .open_protocol_exclusive::<Timestamp>(handle)
+                .expect("Founded Timestamp Protocol but open failed");
 
-    match result {
-        Ok(timestamp_proto) => {
             let timestamp = timestamp_proto.get_timestamp();
             info!("Timestamp Protocol's timestamp: {:?}", timestamp);
 
             let properties = timestamp_proto.get_properties();
             info!("Timestamp Protocol's properties: {:?}", properties);
         }
         Err(err) => {
-            warn!("Failed to open Timestamp Protocol: {:?}", err);
+            warn!("Failed to found Timestamp Protocol: {:?}", err);
         }
     }
 }
 
-
-pub fn test_reset_notification(image: Handle, bt: &BootServices) {
+pub fn test_reset_notification(bt: &BootServices) {
     info!("Running loaded ResetNotification protocol test");
 
-    let result = bt
-        .open_protocol_exclusive::<ResetNotification>(image);
+    let handle = bt.get_handle_for_protocol::<ResetNotification>();
 
-    match result {
-        Ok(mut reset_notif_proto) => {
+    match handle {
+        Ok(handle) => {
+            let mut reset_notif_proto = bt
+                .open_protocol_exclusive::<ResetNotification>(handle)
+                .expect("Founded ResetNotification Protocol but open failed");
             let result = reset_notif_proto.register_reset_notify(None);
-            info!("ResetNotification Protocol register null test: {:?}", result);
+            info!(
+                "ResetNotification Protocol register null test: {:?}",
+                result
+            );
 
             let result = reset_notif_proto.unregister_reset_notify(None);
-            info!("ResetNotification Protocol unregister null test: {:?}", result);
-
-
+            info!(
+                "ResetNotification Protocol unregister null test: {:?}",
+                result
+            );
 
             // value efi_reset_fn is the type of ResetSystemFn, a function pointer
             unsafe extern "efiapi" fn efi_reset_fn(
@@ -67,14 +78,19 @@ pub fn test_reset_notification(image: Handle, bt: &BootServices) {
             }
 
             let result = reset_notif_proto.register_reset_notify(Some(efi_reset_fn));
-            info!("ResetNotification Protocol register efi_reset_fn test: {:?}", result);
+            info!(
+                "ResetNotification Protocol register efi_reset_fn test: {:?}",
+                result
+            );
 
             let result = reset_notif_proto.unregister_reset_notify(Some(efi_reset_fn));
-            info!("ResetNotification Protocol unregister efi_reset_fn test: {:?}", result);
+            info!(
+                "ResetNotification Protocol unregister efi_reset_fn test: {:?}",
+                result
+            );
         }
         Err(err) => {
-            warn!("Failed to open ResetNotification Protocol: {:?}", err);
+            warn!("Failed to found ResetNotification Protocol: {:?}", err);
         }
     }
 }
-

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

@@ -1,6 +1,6 @@
-use uefi::{Identify, proto};
 use uefi::prelude::*;
 use uefi::proto::loaded_image::LoadedImage;
+use uefi::{proto, Identify};
 
 pub fn test(image: Handle, st: &mut SystemTable<Boot>) {
     info!("Testing various protocols");
@@ -21,13 +21,13 @@ pub fn test(image: Handle, st: &mut SystemTable<Boot>) {
     rng::test(bt);
     shell_params::test(bt);
     string::test(bt);
-    misc::test(image, bt);
+    misc::test(bt);
 
     #[cfg(any(
-    target_arch = "x86",
-    target_arch = "x86_64",
-    target_arch = "arm",
-    target_arch = "aarch64"
+        target_arch = "x86",
+        target_arch = "x86_64",
+        target_arch = "arm",
+        target_arch = "aarch64"
     ))]
     shim::test(bt);
     tcg::test(bt);
@@ -61,17 +61,17 @@ mod device_path;
 mod driver;
 mod loaded_image;
 mod media;
+mod misc;
 mod network;
 mod pi;
 mod rng;
 mod shell_params;
 #[cfg(any(
-target_arch = "x86",
-target_arch = "x86_64",
-target_arch = "arm",
-target_arch = "aarch64"
+    target_arch = "x86",
+    target_arch = "x86_64",
+    target_arch = "arm",
+    target_arch = "aarch64"
 ))]
 mod shim;
 mod string;
 mod tcg;
-mod misc;

uefi/src/proto/misc.rs

@@ -1,9 +1,11 @@
 //! Miscellaneous protocols.
 
-use uefi_raw::protocol::misc::{ResetNotificationProtocol, ResetSystemFn, TimestampProperties, TimestampProtocol};
+use uefi_raw::protocol::misc::{
+    ResetNotificationProtocol, ResetSystemFn, TimestampProperties, TimestampProtocol,
+};
 
-use crate::{Result, StatusExt};
 use crate::proto::unsafe_protocol;
+use crate::{Result, StatusExt};
 
 /// Protocol for retrieving a high-resolution timestamp counter.
 #[derive(Debug)]
@@ -65,21 +67,16 @@ impl ResetNotification {
     ///     }
     /// ```
     pub fn register_reset_notify(&mut self, reset_function: Option<ResetSystemFn>) -> Result {
-        unsafe {
-            (self.0.register_reset_notify)(&mut self.0, reset_function)
-        }.to_result()
+        unsafe { (self.0.register_reset_notify)(&mut self.0, reset_function) }.to_result()
     }
 
     /// Removes a reset notification function that has been previously registered with RegisterResetNotify().
     /// Tips: RegisterResetNotify() has named as `register_reset_notify()` in uefi-rs.
     pub fn unregister_reset_notify(&mut self, reset_function: Option<ResetSystemFn>) -> Result {
-        unsafe {
-            (self.0.unregister_reset_notify)(&mut self.0, reset_function)
-        }.to_result()
+        unsafe { (self.0.unregister_reset_notify)(&mut self.0, reset_function) }.to_result()
     }
 }
 
-
 // !TODO: make a safe FFI for raw function 'ResetSystemFn'
 // copy and edit from uefi-raw/src/table/runtime.rs:84 at commit@6093205c3eb27b2e78be4c003c04d46679bff420
 // pub fn new(&self, rt: ResetType, status: Status, data: Option<&[u8]>) ->  Option<ResetSystemFn>