fmt (i always forget this...)

Author: Restioson

src/structures/gdt.rs

@@ -1,11 +1,11 @@
 //! Types for the Global Descriptor Table and segment selectors.
 
+use crate::structures::tss::InvalidIoMap;
 use crate::structures::{tss::TaskStateSegment, DescriptorTablePointer};
 use crate::PrivilegeLevel;
 use bit_field::BitField;
 use bitflags::bitflags;
 use core::{cmp, fmt, mem};
-use crate::structures::tss::InvalidIoMap;
 
 /// Specifies which element to load into a segment from
 /// descriptor tables (i.e., is a index to LDT or GDT table
@@ -317,23 +317,23 @@ impl Descriptor {
         iomap: &'static [u8],
     ) -> Result<Descriptor, InvalidIoMap> {
         if iomap.len() > 8193 {
-            return Err(InvalidIoMap::TooLong { len: iomap.len() })
+            return Err(InvalidIoMap::TooLong { len: iomap.len() });
         }
 
         let base = iomap.as_ptr() as usize - tss as *const _ as usize;
         if base > 0xdfff {
-            return Err(InvalidIoMap::TooFarFromTss { distance: base })
+            return Err(InvalidIoMap::TooFarFromTss { distance: base });
         }
 
         let last_byte = *iomap.last().unwrap_or(&0xff);
         if last_byte != 0xff {
-            return Err(InvalidIoMap::InvalidTerminatingByte { byte: last_byte })
+            return Err(InvalidIoMap::InvalidTerminatingByte { byte: last_byte });
         }
 
         if tss.iomap_base != base as u16 {
             return Err(InvalidIoMap::InvalidBase {
                 expected: base as u16,
-                got: tss.iomap_base
+                got: tss.iomap_base,
             });
         }
 
@@ -348,10 +348,7 @@ impl Descriptor {
     /// There must be a valid IO map at `(tss as *const u8).offset(tss.iomap_base)`
     /// of length `iomap_size`, with the terminating `0xFF` byte. Additionally, `iomap_base` must
     /// not exceed `0xDFFF`.
-    unsafe fn tss_segment_raw(
-        tss: &'static TaskStateSegment,
-        iomap_size: u16,
-    ) -> Descriptor {
+    unsafe fn tss_segment_raw(tss: &'static TaskStateSegment, iomap_size: u16) -> Descriptor {
         use self::DescriptorFlags as Flags;
 
         let ptr = tss as *const _ as u64;

src/structures/tss.rs

@@ -44,20 +44,11 @@ impl TaskStateSegment {
 pub enum InvalidIoMap {
     /// The IO permissions bitmap is too far from the TSS. It must be within `0xdfff` bytes of the
     /// start of the TSS.
-    TooFarFromTss {
-        distance: usize,
-    },
+    TooFarFromTss { distance: usize },
     /// The final byte of the IO permissions bitmap was not 0xff
-    InvalidTerminatingByte {
-        byte: u8,
-    },
+    InvalidTerminatingByte { byte: u8 },
     /// The IO permissions bitmap exceeds the maximum length (8193).
-    TooLong {
-        len: usize
-    },
+    TooLong { len: usize },
     /// The `iomap_base` in the `TaskStateSegment` struct was not what was expected.
-    InvalidBase {
-        expected: u16,
-        got: u16,
-    }
+    InvalidBase { expected: u16, got: u16 },
 }