Add ability to add iomap to TSS (take 2)

src/structures/gdt.rs

@@ -1,10 +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::fmt;
+use core::{cmp, fmt, mem};
 
 /// Specifies which element to load into a segment from
 /// descriptor tables (i.e., is a index to LDT or GDT table
@@ -306,17 +307,69 @@ impl Descriptor {
     /// Creates a TSS system descriptor for the given TSS.
     #[inline]
     pub fn tss_segment(tss: &'static TaskStateSegment) -> Descriptor {
+        // SAFETY: if iomap_size is zero, there are no requirements to uphold.
+        unsafe { Self::tss_segment_raw(tss, 0) }
+    }
+
+    /// Creates a TSS system descriptor for the given TSS, setting up the IO permissions bitmap.
+    pub fn tss_segment_with_iomap(
+        tss: &'static TaskStateSegment,
+        iomap: &'static [u8],
+    ) -> Result<Descriptor, InvalidIoMap> {
+        if iomap.len() > 8193 {
+            return Err(InvalidIoMap::TooLong { len: iomap.len() });
+        }
+
+        let iomap_addr = iomap.as_ptr() as usize;
+        let tss_addr = tss as *const _ as usize;
+
+        if tss_addr > iomap_addr {
+            return Err(InvalidIoMap::IoMapBeforeTss);
+        }
+
+        let base = iomap_addr - tss_addr;
+        if base > 0xdfff {
+            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 });
+        }
+
+        if tss.iomap_base != base as u16 {
+            return Err(InvalidIoMap::InvalidBase {
+                expected: base as u16,
+                got: tss.iomap_base,
+            });
+        }
+
+        // SAFETY: all invariants checked above
+        Ok(unsafe { Self::tss_segment_raw(tss, iomap.len() as u16) })
+    }
+
+    /// Creates a TSS system descriptor for the given TSS, setting up the IO permissions bitmap.
+    ///
+    /// # Safety
+    ///
+    /// 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 {
         use self::DescriptorFlags as Flags;
-        use core::mem::size_of;
 
         let ptr = tss as *const _ as u64;
 
         let mut low = Flags::PRESENT.bits();
         // base
         low.set_bits(16..40, ptr.get_bits(0..24));
         low.set_bits(56..64, ptr.get_bits(24..32));
-        // limit (the `-1` in needed since the bound is inclusive)
-        low.set_bits(0..16, (size_of::<TaskStateSegment>() - 1) as u64);
+        // limit (the `-1` is needed since the bound is inclusive)
+        let iomap_limit = tss.iomap_base as u64 + iomap_size as u64;
+        low.set_bits(
+            0..16,
+            cmp::max(mem::size_of::<TaskStateSegment>() as u64, iomap_limit) - 1,
+        );
         // type (0b1001 = available 64-bit tss)
         low.set_bits(40..44, 0b1001);
 

src/structures/tss.rs

@@ -17,7 +17,8 @@ pub struct TaskStateSegment {
     pub interrupt_stack_table: [VirtAddr; 7],
     reserved_3: u64,
     reserved_4: u16,
-    /// The 16-bit offset to the I/O permission bit map from the 64-bit TSS base.
+    /// The 16-bit offset to the I/O permission bit map from the 64-bit TSS base. It must not
+    /// exceed `0xDFFF`.
     pub iomap_base: u16,
 }
 
@@ -37,3 +38,34 @@ impl TaskStateSegment {
         }
     }
 }
+
+/// The given IO permissions bitmap is invalid.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum InvalidIoMap {
+    /// The IO permissions bitmap is before the TSS. It must be located after the TSS.
+    IoMapBeforeTss,
+    /// The IO permissions bitmap is too far from the TSS. It must be within `0xdfff` bytes of the
+    /// start of the TSS. Note that if the IO permissions bitmap is located before the TSS, then
+    /// `IoMapBeforeTss` will be returned instead.
+    TooFarFromTss {
+        /// The distance of the IO permissions bitmap from the beginning of the TSS.
+        distance: usize,
+    },
+    /// The final byte of the IO permissions bitmap was not 0xff
+    InvalidTerminatingByte {
+        /// The byte found at the end of the IO permissions bitmap.
+        byte: u8,
+    },
+    /// The IO permissions bitmap exceeds the maximum length (8193).
+    TooLong {
+        /// The length of the IO permissions bitmap.
+        len: usize,
+    },
+    /// The `iomap_base` in the `TaskStateSegment` struct was not what was expected.
+    InvalidBase {
+        /// The expected `iomap_base` to be set in the `TaskStateSegment` struct.
+        expected: u16,
+        /// The actual `iomap_base` set in the `TaskStateSegment` struct.
+        got: u16,
+    },
+}