fmt (i always forget this...)

Author: Restioson

src/structures/gdt.rs

@@ -1,15 +1,14 @@
 //! Types for the Global Descriptor Table and segment selectors.
 
 pub use crate::registers::segmentation::SegmentSelector;
-use crate::structures::tss::TaskStateSegment;
+use crate::structures::tss::{InvalidIoMap, TaskStateSegment};
 use crate::PrivilegeLevel;
 use bit_field::BitField;
 use bitflags::bitflags;
 use core::{cmp, fmt, mem};
 // imports for intra-doc links
 #[cfg(doc)]
 use crate::registers::segmentation::{Segment, CS, SS};
-use crate::structures::tss::InvalidIoMap;
 
 #[cfg(all(feature = "instructions", target_arch = "x86_64"))]
 use core::sync::atomic::{AtomicU64 as EntryValue, Ordering};
@@ -450,23 +449,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,
             });
         }
 
@@ -481,10 +480,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: *const TaskStateSegment,
-        iomap_size: u16,
-    ) -> Descriptor {
+    unsafe fn tss_segment_raw(tss: *const TaskStateSegment, iomap_size: u16) -> Descriptor {
         use self::DescriptorFlags as Flags;
 
         let ptr = tss as u64;

src/structures/tss.rs

@@ -57,22 +57,13 @@ impl Default for 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 },
 }
 
 #[cfg(test)]