loader: initial loader code

src/mm/amd64/impl.zig

@@ -117,11 +117,5 @@ pub fn is_leaf_level_enabled(level: usize) bool {
 }
 
 pub fn init_kernel() void {
-    mi.kernel_space.pmap.root_pa = mi.phys.early_alloc();
-    const table_ptr: [*]Pte = @ptrFromInt(mm.p2v(mi.kernel_space.pmap.root_pa));
-    @memset(table_ptr[0..512], Pte.zero());
-
-    for (256..512) |i| {
-        table_ptr[i] = make_table_pte(mi.phys.early_alloc());
-    }
+    mi.kernel_space.pmap.root_pa = amd64.read_cr(3);
 }

src/mm/init.zig

@@ -4,106 +4,8 @@ const mm = r.mm;
 const mi = mm.private;
 const config = @import("config");
 
-extern var text_start_addr: u8;
-extern var text_end_addr: u8;
-extern var rodata_start_addr: u8;
-extern var rodata_end_addr: u8;
-extern var data_start_addr: u8;
-extern var data_end_addr: u8;
-
-fn map_kernel(boot_info: *pl.BootInfo) void {
-    const kaddr = boot_info.kernel_address;
-
-    const text_start = @intFromPtr(&text_start_addr);
-    const text_end = @intFromPtr(&text_end_addr);
-    const rodata_start = @intFromPtr(&rodata_start_addr);
-    const rodata_end = @intFromPtr(&rodata_end_addr);
-    const data_start = @intFromPtr(&data_start_addr);
-    const data_end = @intFromPtr(&data_end_addr);
-
-    const text_size = text_end - text_start;
-    const rodata_size = rodata_end - rodata_start;
-    const data_size = data_end - data_start;
-
-    const start_phys = kaddr.physical_base;
-    const start_virt = kaddr.virtual_base;
-    const until_size = text_start - start_virt;
-
-    mi.kernel_space.pmap.map_contiguous_range(start_virt, start_phys, until_size, .{
-        .read = true,
-        .write = true,
-        .global = true,
-    }, .Boot);
-
-    mi.kernel_space.pmap.map_contiguous_range(text_start, kaddr.physical_base + (text_start - kaddr.virtual_base), text_size, .{
-        .read = true,
-        .execute = true,
-        .global = true,
-    }, .Boot);
-
-    mi.kernel_space.pmap.map_contiguous_range(rodata_start, kaddr.physical_base + (rodata_start - kaddr.virtual_base), rodata_size, .{
-        .read = true,
-        .global = true,
-    }, .Boot);
-
-    mi.kernel_space.pmap.map_contiguous_range(data_start, kaddr.physical_base + (data_start - kaddr.virtual_base), data_size, .{
-        .read = true,
-        .write = true,
-        .global = true,
-    }, .Boot);
-
-    mi.kernel_space.pmap.map_contiguous_range(
-        mm.p2v(0),
-        0,
-        mi.impl.hhdm_minimum_max_address,
-        .{
-            .read = true,
-            .write = true,
-            .global = true,
-        },
-        .Boot,
-    );
-
-    // Now go through every usable entry and map to the HHDM every part that isnt covered by [0, hhdm_minimum_max_address).
-    // We can't blindly map until the maximum usable physical address because on some CPUs this might cause MCEs.
-    // See https://github.com/torvalds/linux/commit/66520ebc2df3fe52eb4792f8101fac573b766baf
-    for (0..boot_info.memory_map.entry_count) |i| {
-        const entry = boot_info.memory_map.entries[i];
-
-        if ((entry.type != .Free and entry.type != .LoaderReclaimable) or entry.size < mm.page_size) {
-            continue;
-        }
-
-        if (entry.base + entry.size <= mi.impl.hhdm_minimum_max_address) {
-            continue;
-        }
-
-        var entry_start = entry.base;
-        var entry_size = entry.size;
-
-        if (entry.base < mi.impl.hhdm_minimum_max_address) {
-            const adjust = mi.impl.hhdm_minimum_max_address - entry.base;
-            entry_start += adjust;
-            entry_size -= adjust;
-        }
-
-        mi.kernel_space.pmap.map_contiguous_range(
-            mm.p2v(entry_start),
-            entry_start,
-            entry_size,
-            .{
-                .read = true,
-                .write = true,
-                .global = true,
-            },
-            .Boot,
-        );
-    }
-}
-
-pub fn init(boot_info: *pl.BootInfo) linksection(r.init) void {
+pub fn init(boot_info: *r.BootInfo) linksection(r.init) void {
     mi.phys.init(boot_info);
-    map_kernel(boot_info);
     mi.kernel_space.pmap.activate();
     mi.phys.init_pfndb();
     mi.zone.early_init();

src/mm/phys.zig

@@ -20,7 +20,7 @@ pub var high_memory_threshold: usize = 0;
 
 var bootstrapped = false;
 var early_alloc_entry_idx: usize = 0;
-var memory_map: *pl.BootInfo.MemMap = undefined;
+var memory_map: *r.BootInfo.MemMap = undefined;
 var early_allocs: usize = 0;
 var list_lock: ke.SpinLock = .init();
 var free_list: rtl.List = undefined;
@@ -162,7 +162,7 @@ pub fn free_batch(head: *mm.Page, tail: *mm.Page, count: usize) void {
     list_lock.release(ipl);
 }
 
-pub fn init(boot_info: *pl.BootInfo) linksection(r.init) void {
+pub fn init(boot_info: *r.BootInfo) linksection(r.init) void {
     memory_map = &boot_info.memory_map;
     free_list.init();
     free_page_event.init(.Notification);

src/mm/zone.zig

@@ -416,7 +416,7 @@ inline fn wma_mix(old: usize, new: usize) usize {
     return (3 * old + new * wma_unit) / 4;
 }
 
-fn alloc_cpus() []rtl.CachePadded(Cpu) {
+fn cpus_alloc() []rtl.CachePadded(Cpu) {
     const ptr = cpu_zone.alloc(.{}) catch @panic("failed to allocate zone CPU state");
     const raw: [*]rtl.CachePadded(Cpu) = @ptrCast(@alignCast(ptr));
     return raw[0..ke.ncpus];
@@ -526,7 +526,7 @@ pub const Zone = struct {
             return;
         }
 
-        self.cpus = alloc_cpus();
+        self.cpus = cpus_alloc();
 
         for (0..ke.ncpus) |i| {
             self.cpus[i].value.lock = .init();
@@ -1284,7 +1284,7 @@ pub fn late_init() linksection(r.init) void {
 
     while (zone) |z| {
         if (z.use_magazines) {
-            z.cpus = alloc_cpus();
+            z.cpus = cpus_alloc();
 
             for (0..ke.ncpus) |i| {
                 z.cpus[i] = .init(.{