Format sources

kernel/src/arch/aarch64/boot/mod.rs

@@ -4,7 +4,7 @@
 fn __aa64_bsp_main() {
     debugln!("Test");
     use crate::arch::machine;
-    use crate::dev::{Device, timer::TimestampSource, serial::SerialDevice};
+    use crate::dev::{serial::SerialDevice, timer::TimestampSource, Device};
 
     unsafe {
         machine::console().lock().enable().unwrap();

kernel/src/arch/aarch64/mach_qemu/mod.rs

@@ -1,8 +1,8 @@
 //! QEMU virt machine
 
+use crate::arch::aarch64::timer::GenericTimer;
 use crate::dev::serial::{pl011::Pl011, SerialDevice};
 use crate::dev::timer::TimestampSource;
-use crate::arch::aarch64::timer::GenericTimer;
 use crate::sync::Spin;
 
 const UART0_BASE: usize = 0x09000000;

kernel/src/arch/mod.rs

@@ -19,8 +19,8 @@ cfg_if! {
 }
 
 // TODO move to mod io
-use core::ops::Deref;
 use core::marker::PhantomData;
+use core::ops::Deref;
 
 /// Wrapper for setting up memory-mapped registers and IO
 pub struct MemoryIo<T> {
@@ -37,7 +37,7 @@ impl<T> MemoryIo<T> {
     pub const unsafe fn new(base: usize) -> Self {
         Self {
             base,
-            _pd: PhantomData
+            _pd: PhantomData,
         }
     }
 }

kernel/src/debug.rs

@@ -41,5 +41,9 @@ pub fn _debug(args: fmt::Arguments) {
     use crate::arch::machine;
     use fmt::Write;
 
-    SerialOutput { inner: machine::console() }.write_fmt(args).ok();
+    SerialOutput {
+        inner: machine::console(),
+    }
+    .write_fmt(args)
+    .ok();
 }

kernel/src/main.rs

@@ -9,7 +9,6 @@
 )]
 #![no_std]
 #![no_main]
-
 #![deny(missing_docs)]
 
 #[macro_use]

kernel/src/sync.rs

@@ -1,7 +1,7 @@
 //! Synchronization facilities module
 
-use core::ops::{Deref, DerefMut};
 use core::cell::UnsafeCell;
+use core::ops::{Deref, DerefMut};
 
 /// Dummy lock implementation, does not do any locking.
 ///
@@ -9,26 +9,30 @@ use core::cell::UnsafeCell;
 /// interrupts are enabled.
 #[repr(transparent)]
 pub struct NullLock<T: ?Sized> {
-    value: UnsafeCell<T>
+    value: UnsafeCell<T>,
 }
 
 /// Dummy lock guard for [NullLock].
 #[repr(transparent)]
 pub struct NullLockGuard<'a, T: ?Sized> {
-    value: &'a mut T
+    value: &'a mut T,
 }
 
 impl<T> NullLock<T> {
     /// Constructs a new instance of the lock, wrapping `value`
     #[inline(always)]
     pub const fn new(value: T) -> Self {
-        Self { value: UnsafeCell::new(value) }
+        Self {
+            value: UnsafeCell::new(value),
+        }
     }
 
     /// Returns [NullLockGuard] for this lock
     #[inline(always)]
     pub fn lock(&self) -> NullLockGuard<T> {
-        NullLockGuard { value: unsafe { &mut *self.value.get() } }
+        NullLockGuard {
+            value: unsafe { &mut *self.value.get() },
+        }
     }
 }