Address Clippy lints and re-run rustfmt

Author: GabrielMajeri

src/proto/console/text/output.rs

@@ -136,8 +136,7 @@ impl fmt::Write for Output {
             buf[*i] = 0;
             *i = 0;
 
-            self.output_string(buf.as_ptr())
-                .map_err(|_| fmt::Error)
+            self.output_string(buf.as_ptr()).map_err(|_| fmt::Error)
         };
 
         // This closure converts a character to UCS-2 and adds it to the buffer,

src/table/boot.rs

@@ -292,13 +292,20 @@ impl BootServices {
     ///
     /// If provided, the watchdog data must be a null-terminated string
     /// optionally followed by other binary data.
-    pub fn set_watchdog_timer(&self, timeout: usize, watchdog_code: u64, data: Option<&mut [u16]>) -> Result<()> {
-        let (data_len, data) =
-            data.map(|d| {
-                         assert!(d.contains(&0), "Watchdog data must contain a null-terminated string");
-                         (d.len(), d.as_mut_ptr())
-                     })
-                .unwrap_or((0, ptr::null_mut()));
+    pub fn set_watchdog_timer(
+        &self,
+        timeout: usize,
+        watchdog_code: u64,
+        data: Option<&mut [u16]>,
+    ) -> Result<()> {
+        let (data_len, data) = data
+            .map(|d| {
+                assert!(
+                    d.contains(&0),
+                    "Watchdog data must contain a null-terminated string"
+                );
+                (d.len(), d.as_mut_ptr())
+            }).unwrap_or((0, ptr::null_mut()));
 
         (self.set_watchdog_timer)(timeout, watchdog_code, data_len, data).into()
     }

uefi-exts/src/boot.rs

@@ -49,10 +49,8 @@ impl BootServicesExt for BootServices {
             // We have to retrieve them all and find one that works.
             .iter()
             .map(|&handle| self.handle_protocol::<P>(handle))
-            // Only choose a handle which implements the protocol.
-            .filter(Option::is_some)
-            // Pick the first one that works.
-            .next()
+            // Find a handle which implements the protocol.
+            .find(Option::is_some)
             // Filter itself returns an option, we need to lift it out.
             .unwrap_or(None)
     }

uefi-logger/src/lib.rs

@@ -45,9 +45,7 @@ impl log::Log for Logger {
 
     fn log(&self, record: &log::Record) {
         let writer = unsafe { &mut *self.writer.get() };
-        DecoratedLog::write(writer,
-                            record.level(),
-                            record.args()).unwrap();
+        DecoratedLog::write(writer, record.level(), record.args()).unwrap();
     }
 
     fn flush(&self) {
@@ -59,7 +57,6 @@ impl log::Log for Logger {
 unsafe impl Sync for Logger {}
 unsafe impl Send for Logger {}
 
-
 /// Writer wrapper which prints a log level in front of every line of text
 ///
 /// This is less easy than it sounds because...
@@ -71,18 +68,15 @@ unsafe impl Send for Logger {}
 ///
 /// Therefore, we need to inject ourselves in the middle of the fmt::Write
 /// machinery and intercept the strings that it sends to the Writer.
-///.
 struct DecoratedLog<'a, W: fmt::Write> {
     backend: &'a mut W,
     log_level: log::Level,
     at_line_start: bool,
 }
-//
+
 impl<'a, W: fmt::Write> DecoratedLog<'a, W> {
     // Call this method to print a level-annotated log
-    fn write(writer: &'a mut W,
-             level: log::Level,
-             args: &fmt::Arguments) -> fmt::Result {
+    fn write(writer: &'a mut W, level: log::Level, args: &fmt::Arguments) -> fmt::Result {
         let mut decorated_writer = Self {
             backend: writer,
             log_level: level,
@@ -91,7 +85,7 @@ impl<'a, W: fmt::Write> DecoratedLog<'a, W> {
         writeln!(decorated_writer, "{}", *args)
     }
 }
-//
+
 impl<'a, W: fmt::Write> fmt::Write for DecoratedLog<'a, W> {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         // Split the input string into lines
@@ -122,4 +116,4 @@ impl<'a, W: fmt::Write> fmt::Write for DecoratedLog<'a, W> {
         }
         Ok(())
     }
-}
+}

uefi-services/src/lib.rs

@@ -10,9 +10,10 @@
 //! through the reference provided by `system_table`.
 
 #![no_std]
+#![feature(alloc_error_handler)]
+#![feature(asm)]
 #![feature(lang_items)]
 #![feature(panic_info_message)]
-#![feature(alloc_error_handler)]
 
 // These crates are required.
 extern crate rlibc;
@@ -139,11 +140,19 @@ fn panic_handler(info: &core::panic::PanicInfo) -> ! {
 
     // If we don't have any shutdown mechanism handy, the best we can do is loop
     error!("Could not shut down, please power off the system manually...");
-    loop {}
+
+    loop {
+        unsafe {
+            // Try to at least keep CPU from running at 100%
+            asm!("hlt" :::: "volatile");
+        }
+    }
 }
 
 #[alloc_error_handler]
-fn out_of_memory(_: ::core::alloc::Layout) -> ! {
-    // TODO: handle out-of-memory conditions
-    loop {}
+fn out_of_memory(layout: ::core::alloc::Layout) -> ! {
+    panic!(
+        "Ran out of free memory while trying to allocate {:#?}",
+        layout
+    );
 }

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

@@ -51,12 +51,16 @@ fn memmove(bt: &BootServices) {
     let mut dest = [0u8; 4];
 
     // Fill the buffer with a value
-    unsafe { bt.memset(dest.as_mut_ptr(), dest.len(), 1); }
+    unsafe {
+        bt.memset(dest.as_mut_ptr(), dest.len(), 1);
+    }
 
     assert_eq!(dest, [1; 4], "Failed to set memory");
 
     // Copy other values on it
-    unsafe { bt.memmove(dest.as_mut_ptr(), src.as_ptr(), dest.len()); }
+    unsafe {
+        bt.memmove(dest.as_mut_ptr(), src.as_ptr(), dest.len());
+    }
 
     assert_eq!(dest, src, "Failed to copy memory");
 }

uefi-test-runner/src/proto/console/serial.rs

@@ -6,8 +6,9 @@ pub fn test(bt: &BootServices) {
     if let Some(mut serial) = bt.find_protocol::<Serial>() {
         let serial = unsafe { serial.as_mut() };
 
-        let old_ctrl_bits = serial.get_control_bits()
-                                  .expect("Failed to get device control bits");
+        let old_ctrl_bits = serial
+            .get_control_bits()
+            .expect("Failed to get device control bits");
         let mut ctrl_bits = ControlBits::empty();
 
         // For the purposes of testing, we're _not_ going to implement
@@ -40,8 +41,9 @@ pub fn test(bt: &BootServices) {
 
         // Clean up after ourselves
         serial.reset().expect("Could not reset the serial device");
-        serial.set_control_bits(old_ctrl_bits & ControlBits::SETTABLE)
-              .expect("Could not restore the serial device state");
+        serial
+            .set_control_bits(old_ctrl_bits & ControlBits::SETTABLE)
+            .expect("Could not restore the serial device state");
     } else {
         warn!("No serial device found");
     }