misc(kernel): bump bitflags to 2.4.2

Signed-off-by: Anhad Singh <[email protected]>

Author: Andy-Python-Programmer

src/Cargo.lock

@@ -26,7 +26,7 @@ spin = { version = "0.9.8", default-features = false, features = [
     "rwlock",
     "once",
 ] }
-bitflags = "1.2.1"
+bitflags = "2.4.2"
 bit_field = "0.10.2"
 log = "0.4.20"
 xmas-elf = "0.9.1"

src/aero_kernel/Cargo.toml

@@ -184,6 +184,7 @@ bitflags::bitflags! {
 }
 
 bitflags::bitflags! {
+    #[derive(Debug)]
     pub struct MxCsr: u32 {
         const INVALID_OPERATION = 1 << 0;
         const DENORMAL = 1 << 1;

src/aero_kernel/src/arch/x86_64/controlregs.rs

@@ -30,32 +30,24 @@ use core::ptr::addr_of;
 
 use alloc::alloc::alloc_zeroed;
 
-bitflags::bitflags! {
-    /// Specifies which element to load into a segment from
-    /// descriptor tables (i.e., is a index to LDT or GDT table
-    /// with some additional flags).
-    pub struct SegmentSelector: u16 {
-        const RPL_0 = 0b00;
-        const RPL_1 = 0b01;
-        const RPL_2 = 0b10;
-        const RPL_3 = 0b11;
-        const TI_GDT = 0 << 2;
-        const TI_LDT = 1 << 2;
-    }
-}
-
 bitflags::bitflags! {
     struct GdtEntryFlags: u8 {
-        const NULL = 0;
         const PROTECTED_MODE = 1 << 6;
         const LONG_MODE = 1 << 5;
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Ring {
-    Ring0 = 0b00,
-    Ring3 = 0b11,
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[repr(u8)]
+pub enum PrivilegeLevel {
+    Ring0 = 0,
+    Ring3 = 3,
+}
+
+impl PrivilegeLevel {
+    pub fn is_user(&self) -> bool {
+        matches!(self, Self::Ring3)
+    }
 }
 
 const BOOT_GDT_ENTRY_COUNT: usize = 4;
@@ -155,7 +147,7 @@ static GDT: [GdtEntry; GDT_ENTRY_COUNT] = [
     // GDT TSS descriptor.
     GdtEntry::new(
         GdtAccessFlags::PRESENT | GdtAccessFlags::RING_3 | GdtAccessFlags::TSS_AVAIL,
-        GdtEntryFlags::NULL,
+        GdtEntryFlags::empty(),
     ),
     // GDT null descriptor as the TSS should be 16 bytes long
     // and twice the normal size.
@@ -175,10 +167,10 @@ impl GdtAccessFlags {
     const TSS_AVAIL: u8 = 9;
 }
 
-pub struct GdtEntryType;
+pub struct GdtEntryIndex;
 
 #[rustfmt::skip]
-impl GdtEntryType {
+impl GdtEntryIndex {
     pub const KERNEL_CODE: u16 = 1;
     pub const KERNEL_DATA: u16 = 2;
     pub const KERNEL_TLS: u16 = 3;
@@ -188,10 +180,32 @@ impl GdtEntryType {
     pub const TSS_HI: u16 = 9;
 }
 
+#[derive(Debug, Copy, Clone)]
+#[repr(transparent)]
+pub struct SegmentSelector(u16);
+
 impl SegmentSelector {
-    const fn new(index: u16, rpl: Ring) -> Self {
-        Self {
-            bits: index << 3 | (rpl as u16),
+    pub const fn empty() -> Self {
+        Self(0)
+    }
+
+    pub const fn new(index: u16, privilege_level: PrivilegeLevel) -> Self {
+        Self(index << 3 | (privilege_level as u16))
+    }
+
+    pub const fn bits(&self) -> u16 {
+        self.0
+    }
+
+    pub const fn from_bits(value: u16) -> Self {
+        Self(value)
+    }
+
+    pub const fn privilege_level(&self) -> PrivilegeLevel {
+        match self.bits() & 0b11 {
+            0 => PrivilegeLevel::Ring0,
+            3 => PrivilegeLevel::Ring3,
+            _ => unreachable!(),
         }
     }
 }
@@ -230,7 +244,7 @@ pub(super) struct GdtEntry {
 }
 
 impl GdtEntry {
-    const NULL: Self = Self::new(GdtAccessFlags::NULL, GdtEntryFlags::NULL);
+    const NULL: Self = Self::new(GdtAccessFlags::NULL, GdtEntryFlags::empty());
 
     const fn new(access_flags: u8, entry_flags: GdtEntryFlags) -> Self {
         Self {
@@ -311,19 +325,45 @@ pub fn init_boot() {
 
     // Load the GDT segments.
     unsafe {
-        load_cs(SegmentSelector::new(GdtEntryType::KERNEL_CODE, Ring::Ring0));
-        load_ds(SegmentSelector::new(GdtEntryType::KERNEL_DATA, Ring::Ring0));
-        load_es(SegmentSelector::new(GdtEntryType::KERNEL_DATA, Ring::Ring0));
-        load_fs(SegmentSelector::new(GdtEntryType::KERNEL_DATA, Ring::Ring0));
-        load_gs(SegmentSelector::new(GdtEntryType::KERNEL_TLS, Ring::Ring0));
-        load_ss(SegmentSelector::new(GdtEntryType::KERNEL_DATA, Ring::Ring0));
+        load_cs(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_CODE,
+            PrivilegeLevel::Ring0,
+        ));
+
+        load_ds(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_DATA,
+            PrivilegeLevel::Ring0,
+        ));
+
+        load_es(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_DATA,
+            PrivilegeLevel::Ring0,
+        ));
+
+        load_fs(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_DATA,
+            PrivilegeLevel::Ring0,
+        ));
+
+        load_gs(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_TLS,
+            PrivilegeLevel::Ring0,
+        ));
+
+        load_ss(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_DATA,
+            PrivilegeLevel::Ring0,
+        ));
     }
 }
 
 static STK: [u8; 4096 * 16] = [0; 4096 * 16];
 
-pub const USER_SS: SegmentSelector = SegmentSelector::new(GdtEntryType::USER_DATA, Ring::Ring3);
-pub const USER_CS: SegmentSelector = SegmentSelector::new(GdtEntryType::USER_CODE, Ring::Ring3);
+pub const USER_SS: SegmentSelector =
+    SegmentSelector::new(GdtEntryIndex::USER_DATA, PrivilegeLevel::Ring3);
+
+pub const USER_CS: SegmentSelector =
+    SegmentSelector::new(GdtEntryIndex::USER_CODE, PrivilegeLevel::Ring3);
 
 /// Initialize the *actual* GDT stored in TLS.
 ///
@@ -347,9 +387,9 @@ pub fn init() {
     unsafe {
         let tss_ptr = TSS.addr().as_mut_ptr::<Tss>();
 
-        gdt[GdtEntryType::TSS as usize].set_offset(tss_ptr as u32);
-        gdt[GdtEntryType::TSS as usize].set_limit(mem::size_of::<Tss>() as u32);
-        gdt[GdtEntryType::TSS_HI as usize].set_raw((tss_ptr as u64) >> 32);
+        gdt[GdtEntryIndex::TSS as usize].set_offset(tss_ptr as u32);
+        gdt[GdtEntryIndex::TSS as usize].set_limit(mem::size_of::<Tss>() as u32);
+        gdt[GdtEntryIndex::TSS_HI as usize].set_raw((tss_ptr as u64) >> 32);
 
         TSS.rsp[0] = STK.as_ptr().offset(4096 * 16) as u64;
 
@@ -361,13 +401,28 @@ pub fn init() {
         load_gdt(&gdt_descriptor);
 
         // Reload the GDT segments.
-        load_cs(SegmentSelector::new(GdtEntryType::KERNEL_CODE, Ring::Ring0));
-        load_ds(SegmentSelector::new(GdtEntryType::KERNEL_DATA, Ring::Ring0));
-        load_es(SegmentSelector::new(GdtEntryType::KERNEL_DATA, Ring::Ring0));
-        load_ss(SegmentSelector::new(GdtEntryType::KERNEL_DATA, Ring::Ring0));
+        load_cs(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_CODE,
+            PrivilegeLevel::Ring0,
+        ));
+        load_ds(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_DATA,
+            PrivilegeLevel::Ring0,
+        ));
+        load_es(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_DATA,
+            PrivilegeLevel::Ring0,
+        ));
+        load_ss(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_DATA,
+            PrivilegeLevel::Ring0,
+        ));
 
         // Load the Task State Segment.
-        load_tss(SegmentSelector::new(GdtEntryType::TSS, Ring::Ring0));
+        load_tss(SegmentSelector::new(
+            GdtEntryIndex::TSS,
+            PrivilegeLevel::Ring0,
+        ));
     }
 
     // // Now we update the per-cpu storage to store a reference

src/aero_kernel/src/arch/x86_64/gdt.rs

@@ -21,26 +21,15 @@
 
 const IDT_ENTRIES: usize = 256;
 
-pub(super) static mut IDT: [IdtEntry; IDT_ENTRIES] = [IdtEntry::NULL; IDT_ENTRIES];
+pub(super) static mut IDT: [IdtEntry; IDT_ENTRIES] = [IdtEntry::EMPTY; IDT_ENTRIES];
 
 use core::mem::size_of;
 use core::ptr::addr_of;
 
-use crate::arch::gdt::SegmentSelector;
-use crate::utils::sync::Mutex;
+use bit_field::BitField;
 
-bitflags::bitflags! {
-    pub struct IDTFlags: u8 {
-        const PRESENT = 1 << 7;
-        const RING_0 = 0 << 5;
-        const RING_1 = 1 << 5;
-        const RING_2 = 2 << 5;
-        const RING_3 = 3 << 5;
-        const SS = 1 << 4;
-        const INTERRUPT = 0xE;
-        const TRAP = 0xF;
-    }
-}
+use crate::arch::gdt::{GdtEntryIndex, PrivilegeLevel, SegmentSelector};
+use crate::utils::sync::Mutex;
 
 #[repr(C, packed)]
 struct IdtDescriptor {
@@ -56,47 +45,72 @@ impl IdtDescriptor {
     }
 }
 
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+struct EntryOptions {
+    cs: SegmentSelector,
+    bits: u16,
+}
+
+impl EntryOptions {
+    #[inline]
+    const fn default() -> Self {
+        Self {
+            cs: SegmentSelector::empty(),
+            // bits 11:8 specify the gate-descriptor type, default to 64-bit interrupt gate (0xe).
+            bits: 0b1110_0000_0000,
+        }
+    }
+
+    #[inline]
+    fn set_privilege_level(&mut self, dpl: PrivilegeLevel) {
+        self.bits.set_bits(13..15, dpl as u16);
+    }
+
+    #[inline]
+    fn set_code_segment(&mut self, cs: SegmentSelector) {
+        self.cs = cs;
+    }
+
+    #[inline]
+    fn set_present(&mut self, present: bool) {
+        self.bits.set_bit(15, present);
+    }
+}
+
 #[derive(Copy, Clone)]
-#[repr(C, packed)]
+#[repr(C)]
 pub(super) struct IdtEntry {
-    offset_low: u16,
-    selector: u16,
-    ist: u8,
-    type_attr: u8,
-    offset_middle: u16,
-    offset_hi: u32,
+    ptr_low: u16,
+    options: EntryOptions,
+    ptr_middle: u16,
+    ptr_high: u32,
     ignore: u32,
 }
 
 impl IdtEntry {
-    /// IDT entry with all values defaulted to 0, ie `null`.
-    const NULL: Self = Self {
-        offset_low: 0x00,
-        selector: 0x00,
-        ist: 0x00,
-        type_attr: 0x00,
-        offset_middle: 0x00,
-        offset_hi: 0x00,
-        ignore: 0x00,
+    const EMPTY: Self = Self {
+        ptr_low: 0,
+        options: EntryOptions::default(),
+        ptr_middle: 0,
+        ptr_high: 0,
+        ignore: 0,
     };
 
-    /// Set the IDT entry flags.
-    fn set_flags(&mut self, flags: IDTFlags) {
-        self.type_attr = flags.bits;
-    }
+    pub(crate) fn set_function(&mut self, ptr: *const u8) {
+        self.options.set_privilege_level(PrivilegeLevel::Ring0);
+        self.options.set_code_segment(SegmentSelector::new(
+            GdtEntryIndex::KERNEL_CODE,
+            PrivilegeLevel::Ring0,
+        ));
 
-    /// Set the IDT entry offset.
-    fn set_offset(&mut self, selector: u16, base: usize) {
-        self.selector = selector;
-        self.offset_low = base as u16;
-        self.offset_middle = (base >> 16) as u16;
-        self.offset_hi = (base >> 32) as u32;
-    }
+        let addr = ptr.addr();
+
+        self.ptr_low = addr as u16;
+        self.ptr_middle = (addr >> 16) as u16;
+        self.ptr_high = (addr >> 32) as u32;
 
-    /// Set the handler function of the IDT entry.
-    pub(crate) fn set_function(&mut self, handler: *const u8) {
-        self.set_flags(IDTFlags::PRESENT | IDTFlags::RING_0 | IDTFlags::INTERRUPT);
-        self.set_offset(8, handler as usize);
+        self.options.set_present(true);
     }
 }
 
@@ -137,7 +151,8 @@ pub struct IretRegisters {
 
 impl IretRegisters {
     pub fn is_user(&self) -> bool {
-        SegmentSelector::from_bits_truncate(self.cs as u16).contains(SegmentSelector::RPL_3)
+        let selector = SegmentSelector::from_bits(self.cs as u16);
+        selector.privilege_level().is_user()
     }
 }