Merge branch 'main' into next

Author: phil-opp

Cargo.lock

@@ -2,7 +2,7 @@ cargo-features = ["profile-rustflags"]
 
 [package]
 name = "bootloader"
-version = "0.11.0-alpha.0"
+version = "0.10.13"
 authors = ["Philipp Oppermann <dev@phil-opp.com>"]
 license = "MIT/Apache-2.0"
 description = "An experimental x86_64 bootloader that works on both BIOS and UEFI systems."
@@ -96,7 +96,7 @@ llvm-tools = "0.1.1"
 default-target = "x86_64-unknown-linux-gnu"
 
 [package.metadata.release]
-no-dev-version = true
+dev-version = false
 pre-release-replacements = [
     { file = "Changelog.md", search = "# Unreleased", replace = "# Unreleased\n\n# {{version}} – {{date}}", exactly = 1 },
 ]

Cargo.toml

@@ -1,5 +1,14 @@
 # Unreleased
 
+# 0.10.13 – 2022-09-25
+
+- Add dynamic range configuration ([#229](https://github.com/rust-osdev/bootloader/pull/229))
+- Fix boot for machines that report memory regions at high physical addresses (see [#259](https://github.com/rust-osdev/bootloader/issues/259))
+  - Limit BIOS bootloader's `max_phys_addr` to 4 GiB ([#260](https://github.com/rust-osdev/bootloader/pull/260))
+  - fix `get_free_address` for large sizes (0.10) ([#263](https://github.com/rust-osdev/bootloader/pull/263))
+  - Only perform a single TLB flush after identity mapping ([#265](https://github.com/rust-osdev/bootloader/pull/265))
+- Correct typos in `src/binary/level_4_entries.rs` ([#228](https://github.com/rust-osdev/bootloader/pull/228))
+
 # 0.10.12 – 2022-02-06
 
 - Add support for position independent executables ([#206](https://github.com/rust-osdev/bootloader/pull/206))

Changelog.md

@@ -8,14 +8,16 @@ use bootloader_x86_64_common::{
     legacy_memory_region::LegacyFrameAllocator, load_and_switch_to_kernel, Kernel, PageTables,
     SystemInfo,
 };
-use core::slice;
+use core::{cmp, slice};
 use usize_conversions::usize_from;
 use x86_64::structures::paging::{FrameAllocator, OffsetPageTable};
 use x86_64::structures::paging::{
     Mapper, PageTable, PageTableFlags, PhysFrame, Size2MiB, Size4KiB,
 };
 use x86_64::{PhysAddr, VirtAddr};
 
+const GIGABYTE: u64 = 4096 * 512 * 512;
+
 mod memory_descriptor;
 
 #[no_mangle]
@@ -34,14 +36,20 @@ pub extern "C" fn _start(info: &mut BiosInfo) -> ! {
 
     memory_map.sort_unstable_by_key(|e| e.start_addr);
 
-    let max_phys_addr = memory_map
-        .iter()
-        .map(|r| {
-            log::info!("start: {:#x}, len: {:#x}", r.start_addr, r.len);
-            r.start_addr + r.len
-        })
-        .max()
-        .expect("no physical memory regions found");
+    let max_phys_addr = {
+        let max = memory_map
+            .iter()
+            .map(|r| {
+                log::info!("start: {:#x}, len: {:#x}", r.start_addr, r.len);
+                r.start_addr + r.len
+            })
+            .max()
+            .expect("no physical memory regions found");
+        // Don't consider addresses > 4GiB when determining the maximum physical
+        // address for the bootloader, as we are in protected mode and cannot
+        // address more than 4 GiB of memory anyway.
+        cmp::min(max, 4 * GIGABYTE)
+    };
 
     let kernel_start = {
         assert!(info.kernel.start != 0, "kernel start address must be set");
@@ -68,22 +76,31 @@ pub extern "C" fn _start(info: &mut BiosInfo) -> ! {
     // identity-map remaining physical memory (first 10 gigabytes are already identity-mapped)
     {
         let start_frame: PhysFrame<Size2MiB> =
-            PhysFrame::containing_address(PhysAddr::new(4096 * 512 * 512 * 10));
+            PhysFrame::containing_address(PhysAddr::new(GIGABYTE * 10));
         let end_frame = PhysFrame::containing_address(PhysAddr::new(max_phys_addr - 1));
         for frame in PhysFrame::range_inclusive(start_frame, end_frame) {
-            unsafe {
+            let flusher = unsafe {
                 bootloader_page_table
                     .identity_map(
                         frame,
                         PageTableFlags::PRESENT | PageTableFlags::WRITABLE,
                         &mut frame_allocator,
                     )
                     .unwrap()
-                    .flush()
             };
+            // skip flushing the entry from the TLB for now, as we will
+            // flush the entire TLB at the end of the loop.
+            flusher.ignore();
         }
     }
 
+    // once all the physical memory is mapped, flush the TLB by reloading the
+    // CR3 register.
+    //
+    // we perform a single flush here rather than flushing each individual entry as
+    // it's mapped using `invlpg`, for efficiency.
+    x86_64::instructions::tlb::flush_all();
+
     log::info!("BIOS boot");
 
     let page_tables = create_page_tables(&mut frame_allocator);

bios/stage-4/src/main.rs

@@ -134,19 +134,18 @@ impl UsedLevel4Entries {
         }
     }
 
-    /// Returns an unused level 4 entry and marks it as used. If `CONFIG.aslr` is
-    /// enabled, this will return a random available entry.
+    /// Returns the first index of a `num` contiguous unused level 4 entries and marks them as
+    /// used. If `CONFIG.aslr` is enabled, this will return random contiguous available entries.
     ///
     /// Since this method marks each returned index as used, it can be used multiple times
     /// to determine multiple unused virtual memory regions.
-    pub fn get_free_entry(&mut self) -> PageTableIndex {
-        // Create an iterator over all available p4 indices.
+    pub fn get_free_entries(&mut self, num: u64) -> PageTableIndex {
+        // Create an iterator over all available p4 indices with `num` contiguous free entries.
         let mut free_entries = self
             .entry_state
-            .iter()
-            .copied()
+            .windows(num.into_usize())
             .enumerate()
-            .filter(|(_, used)| !used)
+            .filter(|(_, entries)| entries.iter().all(|used| !used))
             .map(|(idx, _)| idx);
 
         // Choose the free entry index.
@@ -157,30 +156,36 @@ impl UsedLevel4Entries {
             // Choose the first index.
             free_entries.next()
         };
-        let idx = idx_opt.expect("no usable level 4 entry found");
+        let idx = idx_opt.expect("no usable level 4 entries found");
 
-        // Mark the entry as used.
-        self.entry_state[idx] = true;
+        // Mark the entries as used.
+        for i in 0..num.into_usize() {
+            self.entry_state[idx + i] = true;
+        }
 
         PageTableIndex::new(idx.try_into().unwrap())
     }
 
-    /// Returns a virtual address in an unused level 4 entry and marks it as used.
+    /// Returns a virtual address in one or more unused level 4 entries and marks them as used.
     ///
-    /// This function calls [`get_free_entry`] internally, so all of its docs applies here
+    /// This function calls [`get_free_entries`] internally, so all of its docs applies here
     /// too.
     pub fn get_free_address(&mut self, size: u64, alignment: u64) -> VirtAddr {
         assert!(alignment.is_power_of_two());
 
-        let base =
-            Page::from_page_table_indices_1gib(self.get_free_entry(), PageTableIndex::new(0))
-                .start_address();
+        const LEVEL_4_SIZE: u64 = 4096 * 512 * 512 * 512;
+
+        let level_4_entries = (size + (LEVEL_4_SIZE - 1)) / LEVEL_4_SIZE;
+        let base = Page::from_page_table_indices_1gib(
+            self.get_free_entries(level_4_entries),
+            PageTableIndex::new(0),
+        )
+        .start_address();
 
         let offset = if let Some(rng) = self.rng.as_mut() {
             // Choose a random offset.
-            const LEVEL_4_SIZE: u64 = 4096 * 512 * 512 * 512;
-            let end = LEVEL_4_SIZE - size;
-            let uniform_range = Uniform::from(0..end / alignment);
+            let max_offset = LEVEL_4_SIZE - (size % LEVEL_4_SIZE);
+            let uniform_range = Uniform::from(0..max_offset / alignment);
             uniform_range.sample(rng) * alignment
         } else {
             0

common/src/level_4_entries.rs

@@ -281,7 +281,7 @@ where
     let recursive_index = if let Some(mapping) = config.mappings.page_table_recursive {
         log::info!("Map page table recursively");
         let index = match mapping {
-            Mapping::Dynamic => used_entries.get_free_entry(),
+            Mapping::Dynamic => used_entries.get_free_entries(1),
             Mapping::FixedAddress(offset) => {
                 let offset = VirtAddr::new(offset);
                 let table_level = PageTableLevel::Four;