gdt: make add_entry const

This requires making the push method const as well, which means we need
the `const_panic` feature (not too much of a risk as this feature is
failly well along).

I also moved the pointer calculation (for GDT and IDT) into their own
(currently private) methods. Eventually these methods can be public, but
that's only useful if they can be const, which would require a breaking change.

The caclulation for the GDT pointer was also updated to use:
```rust
self.next_free * size_of::<u64>() - 1
```
instead of
```rust
self.table.len() * size_of::<u64>() - 1
```

Signed-off-by: Joe Richey <[email protected]>

Author: josephlr

src/lib.rs

@@ -3,6 +3,7 @@
 
 #![cfg_attr(not(test), no_std)]
 #![cfg_attr(feature = "const_fn", feature(const_fn))] // Needed for generic access to associated consts
+#![cfg_attr(feature = "const_fn", feature(const_panic))]
 #![cfg_attr(feature = "const_fn", feature(const_mut_refs))]
 #![cfg_attr(feature = "const_fn", feature(const_fn_fn_ptr_basics))]
 #![cfg_attr(feature = "const_fn", feature(const_in_array_repeat_expressions))]
@@ -22,16 +23,28 @@ pub use crate::addr::{align_down, align_up, PhysAddr, VirtAddr};
 macro_rules! const_fn {
     (
         $(#[$attr:meta])*
-        pub $($fn:tt)*
+        $sv:vis fn $($fn:tt)*
     ) => {
         $(#[$attr])*
         #[cfg(feature = "const_fn")]
-        pub const $($fn)*
+        $sv const fn $($fn)*
 
         $(#[$attr])*
         #[cfg(not(feature = "const_fn"))]
-        pub $($fn)*
-    }
+        $sv fn $($fn)*
+    };
+    (
+        $(#[$attr:meta])*
+        $sv:vis unsafe fn $($fn:tt)*
+    ) => {
+        $(#[$attr])*
+        #[cfg(feature = "const_fn")]
+        $sv const unsafe fn $($fn)*
+
+        $(#[$attr])*
+        #[cfg(not(feature = "const_fn"))]
+        $sv unsafe fn $($fn)*
+    };
 }
 
 #[cfg(all(feature = "instructions", feature = "external_asm"))]

src/structures/gdt.rs

@@ -1,6 +1,6 @@
 //! Types for the Global Descriptor Table and segment selectors.
 
-use crate::structures::tss::TaskStateSegment;
+use crate::structures::{tss::TaskStateSegment, DescriptorTablePointer};
 use crate::PrivilegeLevel;
 use bit_field::BitField;
 use bitflags::bitflags;
@@ -105,33 +105,35 @@ impl GlobalDescriptorTable {
         }
     }
 
-    /// Adds the given segment descriptor to the GDT, returning the segment selector.
-    ///
-    /// Panics if the GDT has no free entries left.
-    #[inline]
-    pub fn add_entry(&mut self, entry: Descriptor) -> SegmentSelector {
-        let index = match entry {
-            Descriptor::UserSegment(value) => self.push(value),
-            Descriptor::SystemSegment(value_low, value_high) => {
-                let index = self.push(value_low);
-                self.push(value_high);
-                index
-            }
-        };
-
-        let rpl = match entry {
-            Descriptor::UserSegment(value) => {
-                if DescriptorFlags::from_bits_truncate(value).contains(DescriptorFlags::DPL_RING_3)
-                {
-                    PrivilegeLevel::Ring3
-                } else {
-                    PrivilegeLevel::Ring0
+    const_fn! {
+        /// Adds the given segment descriptor to the GDT, returning the segment selector.
+        ///
+        /// Panics if the GDT has no free entries left.
+        #[inline]
+        pub fn add_entry(&mut self, entry: Descriptor) -> SegmentSelector {
+            let index = match entry {
+                Descriptor::UserSegment(value) => self.push(value),
+                Descriptor::SystemSegment(value_low, value_high) => {
+                    let index = self.push(value_low);
+                    self.push(value_high);
+                    index
                 }
-            }
-            Descriptor::SystemSegment(_, _) => PrivilegeLevel::Ring0,
-        };
+            };
+
+            let rpl = match entry {
+                Descriptor::UserSegment(value) => {
+                    if DescriptorFlags::from_bits_truncate(value).contains(DescriptorFlags::DPL_RING_3)
+                    {
+                        PrivilegeLevel::Ring3
+                    } else {
+                        PrivilegeLevel::Ring0
+                    }
+                }
+                Descriptor::SystemSegment(_, _) => PrivilegeLevel::Ring0,
+            };
 
-        SegmentSelector::new(index as u16, rpl)
+            SegmentSelector::new(index as u16, rpl)
+        }
     }
 
     /// Loads the GDT in the CPU using the `lgdt` instruction. This does **not** alter any of the
@@ -142,26 +144,33 @@ impl GlobalDescriptorTable {
     #[cfg(feature = "instructions")]
     #[inline]
     pub fn load(&'static self) {
-        use crate::instructions::tables::{lgdt, DescriptorTablePointer};
-        use core::mem::size_of;
-
-        let ptr = DescriptorTablePointer {
-            base: self.table.as_ptr() as u64,
-            limit: (self.table.len() * size_of::<u64>() - 1) as u16,
-        };
+        use crate::instructions::tables::lgdt;
+        // SAFETY: static lifetime ensures no modification after loading.
+        unsafe { lgdt(&self.pointer()) };
+    }
 
-        unsafe { lgdt(&ptr) };
+    const_fn! {
+        #[inline]
+        fn push(&mut self, value: u64) -> usize {
+            if self.next_free < self.table.len() {
+                let index = self.next_free;
+                self.table[index] = value;
+                self.next_free += 1;
+                index
+            } else {
+                panic!("GDT full");
+            }
+        }
     }
 
-    #[inline]
-    fn push(&mut self, value: u64) -> usize {
-        if self.next_free < self.table.len() {
-            let index = self.next_free;
-            self.table[index] = value;
-            self.next_free += 1;
-            index
-        } else {
-            panic!("GDT full");
+    /// Creates the descriptor pointer for this table. This pointer can only be
+    /// safely used if the table is never modified or destroyed while in use.
+    #[cfg(feature = "instructions")]
+    fn pointer(&self) -> DescriptorTablePointer {
+        use core::mem::size_of;
+        DescriptorTablePointer {
+            base: self.table.as_ptr() as u64,
+            limit: (self.next_free * size_of::<u64>() - 1) as u16,
         }
     }
 }

src/structures/idt.rs

@@ -9,7 +9,7 @@
 
 //! Provides types for the Interrupt Descriptor Table and its entries.
 
-use crate::{PrivilegeLevel, VirtAddr};
+use crate::{structures::DescriptorTablePointer, PrivilegeLevel, VirtAddr};
 use bit_field::BitField;
 use bitflags::bitflags;
 use core::fmt;
@@ -430,15 +430,19 @@ impl InterruptDescriptorTable {
     #[cfg(feature = "instructions")]
     #[inline]
     pub unsafe fn load_unsafe(&self) {
-        use crate::instructions::tables::{lidt, DescriptorTablePointer};
-        use core::mem::size_of;
+        use crate::instructions::tables::lidt;
+        lidt(&self.pointer());
+    }
 
-        let ptr = DescriptorTablePointer {
+    /// Creates the descriptor pointer for this table. This pointer can only be
+    /// safely used if the table is never modified or destroyed while in use.
+    #[cfg(feature = "instructions")]
+    fn pointer(&self) -> DescriptorTablePointer {
+        use core::mem::size_of;
+        DescriptorTablePointer {
             base: self as *const _ as u64,
             limit: (size_of::<Self>() - 1) as u16,
-        };
-
-        lidt(&ptr);
+        }
     }
 
     /// Returns a normalized and ranged check slice range from a RangeBounds trait object