Merge branch 'master' into next

Author: phil-opp

Changelog.md

@@ -17,6 +17,11 @@
 - **Breaking:** Remove `PortReadWrite` trait, which is no longer needed ([#217](https://github.com/rust-osdev/x86_64/pull/217))
 - Relaxe `Sized` requirement for `FrameAllocator` in `Mapper::map_to` ([204](https://github.com/rust-osdev/x86_64/pull/204))
 
+# 0.12.4 – 2020-12-28
+
+- Fix bad conversion from llvm_asm! to asm! ([#218](https://github.com/rust-osdev/x86_64/pull/218))
+- GDT: Add `load_unchecked`, `from_raw_slice`, and `as_raw_slice` ([#210](https://github.com/rust-osdev/x86_64/pull/210))
+
 # 0.12.3 – 2020-10-31
 
 - Use `asm!` instead of perma-unstable `llvm_asm!` macro ([#165](https://github.com/rust-osdev/x86_64/pull/165))

src/instructions/mod.rs

@@ -50,7 +50,7 @@ pub fn nop() {
 #[inline]
 pub fn bochs_breakpoint() {
     unsafe {
-        asm!("xchgw bx, bx", options(nomem, nostack));
+        asm!("xchg bx, bx", options(nomem, nostack));
     }
 }
 

src/structures/gdt.rs

@@ -108,6 +108,40 @@ impl GlobalDescriptorTable {
         }
     }
 
+    /// Forms a GDT from a slice of `u64`.
+    ///
+    /// # Safety
+    ///
+    /// * The user must make sure that the entries are well formed
+    /// * The provided slice **must not be larger than 8 items** (only up to the first 8 will be observed.)
+    #[inline]
+    #[cfg(feature = "const_fn")]
+    pub const unsafe fn from_raw_slice(slice: &[u64]) -> GlobalDescriptorTable {
+        assert!(
+            slice.len() <= 8,
+            "initializing a GDT from a slice requires it to be **at most** 8 elements."
+        );
+        let next_free = slice.len();
+
+        let mut table = [0; 8];
+        let mut idx = 0;
+
+        while idx != next_free {
+            table[idx] = slice[idx];
+            idx += 1;
+        }
+
+        GlobalDescriptorTable { table, next_free }
+    }
+
+    /// Get a reference to the internal table.
+    ///
+    /// The resulting slice may contain system descriptors, which span two `u64`s.
+    #[inline]
+    pub fn as_raw_slice(&self) -> &[u64] {
+        &self.table[..self.next_free]
+    }
+
     const_fn! {
         /// Adds the given segment descriptor to the GDT, returning the segment selector.
         ///
@@ -147,9 +181,27 @@ impl GlobalDescriptorTable {
     #[cfg(feature = "instructions")]
     #[inline]
     pub fn load(&'static self) {
-        use crate::instructions::tables::lgdt;
         // SAFETY: static lifetime ensures no modification after loading.
-        unsafe { lgdt(&self.pointer()) };
+        unsafe { self.load_unsafe() };
+    }
+
+    /// Loads the GDT in the CPU using the `lgdt` instruction. This does **not** alter any of the
+    /// segment registers; you **must** (re)load them yourself using [the appropriate
+    /// functions](crate::instructions::segmentation):
+    /// [load_ss](crate::instructions::segmentation::load_ss),
+    /// [set_cs](crate::instructions::segmentation::set_cs).
+    ///
+    /// # Safety
+    ///
+    /// Unlike `load` this function will not impose a static lifetime constraint
+    /// this means its up to the user to ensure that there will be no modifications
+    /// after loading and that the GDT will live for as long as it's loaded.
+    ///
+    #[cfg(feature = "instructions")]
+    #[inline]
+    pub unsafe fn load_unsafe(&self) {
+        use crate::instructions::tables::lgdt;
+        lgdt(&self.pointer());
     }
 
     const_fn! {