Merge pull request #191 from josephlr/gdt-push

gdt: make add_entry const

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