x86_64: switch to the limine boot protocol

* The stivale2 protocol is deperacated so, now we are using the new
next-gen limine protocol. :)

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

.vscode/launch.json

@@ -9,7 +9,7 @@
                 "platform select remote-gdb-server"
             ],
             "targetCreateCommands": [
-                "target create ${workspaceFolder}/src/target/x86_64-aero_os/release/aero_kernel"
+                "target create ${workspaceFolder}/build/iso_root/aero.elf"
             ],
             "processCreateCommands": [
                 "gdb-remote 127.0.0.1:1234" // Connect to the GDB Server

aero.py

@@ -59,15 +59,16 @@
 VERBOSE=yes
 
 :aero
-PROTOCOL=stivale2
+PROTOCOL=limine
+KASLR=no
 KERNEL_PATH=boot:///aero.elf
 CMDLINE=term-background=background theme-background=0x50000000
 
 MODULE_PATH=boot:///term_background.bmp
-MODULE_STRING=background
+MODULE_CMDLINE=background
 
 MODULE_PATH=boot:///initramfs.cpio
-MODULE_STRING=initramfs
+MODULE_CMDLINE=initramfs
 """
 
 

src/.cargo/kernel.ld

@@ -1,80 +1,54 @@
-ENTRY(x86_64_aero_main)
-OUTPUT_FORMAT(elf64-x86-64) 
+/* Tell the linker that we want an x86_64 ELF64 output file */
+OUTPUT_FORMAT(elf64-x86-64)
+OUTPUT_ARCH(i386:x86-64)
 
-/* We want to be placed in the higher half, 2MiB above 0x00 in physical memory */
-KERNEL_OFFSET = 0xFFFFFFFF80200000;
+/* We want the symbol `x86_64_aero_main` to be our entry point */
+ENTRY(x86_64_aero_main)
 
-SECTIONS 
+/* Define the program headers we want so the bootloader gives us the right */
+/* MMU permissions */
+PHDRS
 {
-    . = KERNEL_OFFSET;
-
-    __kernel_start = .;
+    null    PT_NULL    FLAGS(0) ;                   /* Null segment */
+    text    PT_LOAD    FLAGS((1 << 0) | (1 << 2)) ; /* Execute + Read */
+    rodata  PT_LOAD    FLAGS((1 << 2)) ;            /* Read only */
+    data    PT_LOAD    FLAGS((1 << 1) | (1 << 2)) ; /* Write + Read */
+}
 
-    .stivale2hdr : ALIGN(4K) {
-        KEEP(*(.stivale2hdr))
-    }
+SECTIONS
+{
+    /* We wanna be placed in the topmost 2GiB of the address space, for optimisations */
+    /* and because that is what the Limine spec mandates. */
+    /* Any address in this region will do, but often 0xffffffff80000000 is chosen as */
+    /* that is the beginning of the region. */
+    . = 0xffffffff80000000;
 
-    /* Then place all of the other traditional executable sections afterwards... */
-    . = ALIGN(4K);
     .text : {
-        __text_start = .;
         *(.text .text.*)
-        . = ALIGN(4096);
-        __text_end = .;
-    }
+    } :text
+
+    /* Move to the next memory page for .rodata */
+    . += CONSTANT(MAXPAGESIZE);
 
-    . = ALIGN(4K);
     .rodata : {
-        __rodata_start = .;
-        *(.rodata*)
-        . = ALIGN(4096);
-        __rodata_end = .;
-    }
+        *(.rodata .rodata.*)
+    } :rodata
 
-    /* The kernel makes use of the tdata section for CPU-local variables... */
-    . = ALIGN(4K);
-    .tdata : {
-        __tdata_start = .;
-        KEEP(*(.tdata*))
-        KEEP(*(.tbss*))
-        __tdata_end = ALIGN(8);
-    }
+    /* Move to the next memory page for .data */
+    . += CONSTANT(MAXPAGESIZE);
 
-    . = ALIGN(4K);
     .data : {
-        __data_start = .;
         *(.data .data.*)
-        . = ALIGN(4096);
-        __data_end = .;
-    }
+    } :data
 
-    . = ALIGN(4K);
     .kernel_modules : {
         __kernel_modules_start = .;
         KEEP(*(.kernel_modules.init))
         __kernel_modules_end = .;
     }
 
-    . = ALIGN(4K);
     .bss : {
-        __bss_start = .;
+        *(COMMON)
         *(.bss .bss.*)
-        . = ALIGN(4096);
-        __bss_end = .;
-    }
-    
-    __kernel_end = .;
-
-    /* 
-     * Discard all of the useless sections for us. Note that Aero does do stack unwinding on panic, instead
-     * of aborting, but it does not use the eh frame. See the `aero_kernel/src/unwind.rs` file for more
-     * information.
-     */
-    /DISCARD/ : {
-        *(.comment*)
-        *(.eh_frame*)
-        *(.gcc_except_table*)
-        *(.note*)
-        *(.rel.eh_frame*)
-    }
-}
+    } :data
+}

src/Cargo.lock

@@ -23,22 +23,27 @@ syslog = []
 default = ["round-robin"]
 
 [dependencies]
-spin = "0.9.2"
+spin = { version = "0.9.4", default-features = false, features = [
+    "spin_mutex",
+    "rwlock",
+    "once",
+] }
 bitflags = "1.2.1"
 bit_field = "0.10.1"
 log = "0.4.14"
 raw-cpuid = "10.0.0"
 xmas-elf = "0.8.0"
-hashbrown = "0.11.2"
+hashbrown = { version = "0.12.3" }
 rustc-demangle = "0.1.20"
-stivale-boot = "0.2.6"
 intrusive-collections = "0.9.2"
 serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
 lai = { git = "https://github.com/aero-os/lai-rs" }
 uapi = { path = "../uapi" }
 cpio_reader = { git = "https://github.com/Andy-Python-Programmer/cpio_reader" }
 static_assertions = "1.1.0"
 
+limine = { path = "../../../limine-rs" }
+
 [dependencies.vte]
 git = "https://github.com/Andy-Python-Programmer/vte"
 features = ["no_std"]

src/aero_kernel/Cargo.toml

@@ -60,6 +60,7 @@ pub struct Madt {
 
 impl Madt {
     pub(super) fn init(&'static self) {
+        return;
         log::debug!("storing AP trampoline at 0x1000");
 
         let page_index = unsafe { smp_prepare_trampoline() };

src/aero_kernel/src/acpi/madt.rs

@@ -25,7 +25,7 @@
 use spin::Once;
 
 use crate::{
-    mem::paging::{PhysAddr, VirtAddr},
+    mem::paging::VirtAddr,
     utils::sync::{Mutex, MutexGuard},
 };
 
@@ -104,8 +104,7 @@ pub fn get_acpi_table() -> MutexGuard<'static, AcpiTable> {
 }
 
 /// Initialize the ACPI tables.
-pub fn init(rsdp_address: PhysAddr) {
-    let rsdp_address = rsdp_address.as_hhdm_virt();
+pub fn init(rsdp_address: VirtAddr) {
     let acpi_table = AcpiTable::new(rsdp_address);
 
     ACPI_TABLE.call_once(|| Mutex::new(acpi_table));

src/aero_kernel/src/acpi/mod.rs

@@ -31,8 +31,6 @@ use core::mem;
 
 use alloc::alloc::alloc_zeroed;
 
-use crate::mem::paging::VirtAddr;
-
 use crate::arch::tls::PerCpuData;
 
 use super::tls;
@@ -329,11 +327,13 @@ pub fn get_kpcr() -> &'static mut Kpcr {
     unsafe { &mut *(io::rdmsr(io::IA32_GS_BASE) as *mut Kpcr) }
 }
 
+static STK: [u8; 4096 * 16] = [0; 4096 * 16];
+
 /// Initialize the *actual* GDT stored in TLS.
 ///
 /// ## Saftey
 /// The heap must be initialized before this function is called.
-pub fn init(stack_top: VirtAddr) {
+pub fn init() {
     let gdt = unsafe {
         let gdt_ent_size = core::mem::size_of::<GdtEntry>();
         let gdt_ent_align = core::mem::align_of::<GdtEntry>();
@@ -356,7 +356,7 @@ pub fn init(stack_top: VirtAddr) {
         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);
 
-        tss_ref.rsp[0] = stack_top.as_u64();
+        tss_ref.rsp[0] = STK.as_ptr().offset(4096 * 16) as u64;
 
         let gdt_descriptor = GdtDescriptor::new(
             (mem::size_of::<[GdtEntry; GDT_ENTRY_COUNT]>() - 1) as u16,