Reformat and fix CI

Author: GabrielMajeri

src/proto/console/gop.rs

@@ -23,20 +23,23 @@
 //! In theory, a buffer with a width of 640 should have (640 * 4) bytes per row,
 //! but in practice there might be some extra padding used for efficiency.
 
+use crate::{Completion, Result, Status};
 use core::marker::PhantomData;
 use core::mem;
 use core::ptr;
-use crate::{Completion, Result, Status};
 
 /// Provides access to the video hardware's frame buffer.
 ///
 /// The GOP can be used to set the properties of the frame buffer,
 /// and also allows the app to access the in-memory buffer.
 #[repr(C)]
 pub struct GraphicsOutput<'boot> {
-    query_mode:
-        extern "win64" fn(&GraphicsOutput, mode: u32, info_sz: &mut usize, &mut *const ModeInfo)
-            -> Status,
+    query_mode: extern "win64" fn(
+        &GraphicsOutput,
+        mode: u32,
+        info_sz: &mut usize,
+        &mut *const ModeInfo,
+    ) -> Status,
     set_mode: extern "win64" fn(&mut GraphicsOutput, mode: u32) -> Status,
     // Clippy correctly complains that this is too complicated, but we can't change the spec.
     #[allow(clippy::type_complexity)]

src/proto/console/pointer/mod.rs

@@ -1,7 +1,7 @@
 //! Pointer device access.
 
-use core::mem;
 use crate::{Event, Result, Status};
+use core::mem;
 
 /// Provides information about a pointer device.
 #[repr(C)]

src/proto/console/serial.rs

@@ -1,7 +1,7 @@
 //! Abstraction over byte stream devices, also known as serial I/O devices.
 
-use bitflags::bitflags;
 use crate::{Completion, Result, Status};
+use bitflags::bitflags;
 
 /// Provides access to a serial I/O device.
 ///

src/proto/console/text/input.rs

@@ -1,5 +1,5 @@
-use core::mem;
 use crate::{Char16, Event, Result, Status};
+use core::mem;
 
 /// Interface for text-based input devices.
 #[repr(C)]

src/proto/console/text/output.rs

@@ -1,6 +1,6 @@
-use core::fmt;
 use crate::prelude::*;
 use crate::{CStr16, Char16, Completion, Result, Status};
+use core::fmt;
 
 /// Interface for text-based output devices.
 ///
@@ -11,8 +11,12 @@ pub struct Output<'boot> {
     reset: extern "win64" fn(this: &Output, extended: bool) -> Status,
     output_string: extern "win64" fn(this: &Output, string: *const Char16) -> Status,
     test_string: extern "win64" fn(this: &Output, string: *const Char16) -> Status,
-    query_mode: extern "win64" fn(this: &Output, mode: i32, columns: &mut usize, rows: &mut usize)
-        -> Status,
+    query_mode: extern "win64" fn(
+        this: &Output,
+        mode: i32,
+        columns: &mut usize,
+        rows: &mut usize,
+    ) -> Status,
     set_mode: extern "win64" fn(this: &mut Output, mode: i32) -> Status,
     set_attribute: extern "win64" fn(this: &mut Output, attribute: usize) -> Status,
     clear_screen: extern "win64" fn(this: &mut Output) -> Status,

src/proto/media/file.rs

@@ -5,11 +5,11 @@
 //! `/` on that volume, and with that file it is possible to enumerate and open
 //! all the other files on that volume.
 
+use crate::prelude::*;
+use crate::{CStr16, Char16, Result, Status};
 use bitflags::bitflags;
 use core::mem;
 use core::ptr;
-use crate::prelude::*;
-use crate::{CStr16, Char16, Result, Status};
 use ucs2;
 
 /// A file represents an abstraction of some contiguous block of data residing
@@ -185,8 +185,11 @@ pub(super) struct FileImpl {
     delete: extern "win64" fn(this: &mut FileImpl) -> Status,
     read:
         extern "win64" fn(this: &mut FileImpl, buffer_size: &mut usize, buffer: *mut u8) -> Status,
-    write: extern "win64" fn(this: &mut FileImpl, buffer_size: &mut usize, buffer: *const u8)
-        -> Status,
+    write: extern "win64" fn(
+        this: &mut FileImpl,
+        buffer_size: &mut usize,
+        buffer: *const u8,
+    ) -> Status,
     get_position: extern "win64" fn(this: &mut FileImpl, position: &mut u64) -> Status,
     set_position: extern "win64" fn(this: &mut FileImpl, position: u64) -> Status,
     get_info: usize,

src/proto/media/fs.rs

@@ -1,8 +1,8 @@
 //! File system support protocols.
 
 use super::file::{File, FileImpl};
-use core::ptr;
 use crate::{Result, Status};
+use core::ptr;
 
 /// Allows access to a FAT-12/16/32 file system.
 ///

src/table/boot.rs

@@ -1,12 +1,12 @@
 //! UEFI services available during boot.
 
 use super::Header;
+use crate::proto::Protocol;
+use crate::{Event, Guid, Handle, Result, Status};
 use bitflags::bitflags;
 use core::cell::UnsafeCell;
 use core::ffi::c_void;
 use core::{mem, ptr, result};
-use crate::proto::Protocol;
-use crate::{Event, Guid, Handle, Result, Status};
 
 /// Contains pointers to all of the boot services.
 #[repr(C)]
@@ -18,9 +18,12 @@ pub struct BootServices {
     restore_tpl: extern "win64" fn(old_tpl: Tpl),
 
     // Memory allocation functions
-    allocate_pages:
-        extern "win64" fn(alloc_ty: u32, mem_ty: MemoryType, count: usize, addr: &mut u64)
-            -> Status,
+    allocate_pages: extern "win64" fn(
+        alloc_ty: u32,
+        mem_ty: MemoryType,
+        count: usize,
+        addr: &mut u64,
+    ) -> Status,
     free_pages: extern "win64" fn(addr: u64, pages: usize) -> Status,
     memory_map: extern "win64" fn(
         size: &mut usize,
@@ -42,9 +45,11 @@ pub struct BootServices {
         event: *mut Event,
     ) -> Status,
     set_timer: usize,
-    wait_for_event:
-        extern "win64" fn(number_of_events: usize, events: *mut Event, out_index: &mut usize)
-            -> Status,
+    wait_for_event: extern "win64" fn(
+        number_of_events: usize,
+        events: *mut Event,
+        out_index: &mut usize,
+    ) -> Status,
     signal_event: usize,
     close_event: usize,
     check_event: usize,
@@ -53,9 +58,11 @@ pub struct BootServices {
     install_protocol_interface: usize,
     reinstall_protocol_interface: usize,
     uninstall_protocol_interface: usize,
-    handle_protocol:
-        extern "win64" fn(handle: Handle, proto: *const Guid, out_proto: &mut *mut c_void)
-            -> Status,
+    handle_protocol: extern "win64" fn(
+        handle: Handle,
+        proto: *const Guid,
+        out_proto: &mut *mut c_void,
+    ) -> Status,
     _reserved: usize,
     register_protocol_notify: usize,
     locate_handle: extern "win64" fn(

src/table/cfg.rs

@@ -9,9 +9,9 @@
 
 #![allow(clippy::unreadable_literal)]
 
+use crate::Guid;
 use bitflags::bitflags;
 use core::ffi::c_void;
-use crate::Guid;
 
 /// Contains a set of GUID / pointer for a vendor-specific table.
 ///

src/table/runtime.rs

@@ -1,8 +1,8 @@
 //! UEFI services available at runtime, even after the OS boots.
 
 use super::Header;
-use core::ptr;
 use crate::Status;
+use core::ptr;
 
 /// Contains pointers to all of the runtime services.
 ///

src/table/system.rs

@@ -1,10 +1,10 @@
 use super::boot::{BootServices, MemoryMapIter};
 use super::runtime::RuntimeServices;
 use super::{cfg, Header, Revision};
-use core::marker::PhantomData;
-use core::slice;
 use crate::proto::console::text;
 use crate::{CStr16, Char16, Handle, Result, Status};
+use core::marker::PhantomData;
+use core::slice;
 
 /// Marker trait used to provide different views of the UEFI System Table
 pub trait SystemTableView {}

uefi-logger/src/lib.rs

@@ -110,22 +110,22 @@ impl<'a, W: fmt::Write> fmt::Write for DecoratedLog<'a, W> {
         // beginning of a line of output.
         let first = lines.next().unwrap_or("");
         if self.at_line_start {
-            write!(self.backend, "{}: ", self.log_level);
+            write!(self.backend, "{}: ", self.log_level)?;
             self.at_line_start = false;
         }
         write!(self.backend, "{}", first)?;
 
         // For the remainder of the line iterator (if any), we know that we are
         // truly at the beginning of lines of output.
         for line in lines {
-            write!(self.backend, "\n{}: {}", self.log_level, line);
+            write!(self.backend, "\n{}: {}", self.log_level, line)?;
         }
 
         // If the string ends with a newline character, we must 1/propagate it
         // to the output (it was swallowed by the iteration) and 2/prepare to
         // write the log level of the beginning of the next line (if any).
         if let Some('\n') = s.chars().next_back() {
-            writeln!(self.backend);
+            writeln!(self.backend)?;
             self.at_line_start = true;
         }
         Ok(())

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

@@ -1,8 +1,8 @@
 use uefi::prelude::*;
 use uefi::table::boot::{AllocateType, BootServices, MemoryDescriptor, MemoryType};
 
-use core::mem;
 use crate::alloc::vec::Vec;
+use core::mem;
 
 pub fn test(bt: &BootServices) {
     info!("Testing memory functions");