loader: rework kernel entry point

src/kern/init.zig

@@ -11,6 +11,9 @@ var thread0: ke.Thread = undefined;
 export fn kmain(boot_info: *r.BootInfo) callconv(.c) void {
     r.boot_info = boot_info;
 
+    // Immediately initialize the context of what will eventually become
+    // our idle thread. We keep running on the loader stack up until we switch
+    // into the thread.
     thread0.init(
         boot_info.kernel_stack,
         boot_info.kernel_stack_size,

src/kern/thread.zig

@@ -137,7 +137,12 @@ pub const Thread = struct {
         arg: ?*anyopaque,
     ) void {
         thread.* = .{
-            .context = .init(stack, stack_size, entry, arg),
+            .context = .init(
+                stack,
+                stack_size,
+                entry,
+                arg,
+            ),
             .lock = .init(),
             .nice = 0,
             .priority = prio,

src/loader/jump.s

@@ -1,5 +1,4 @@
 .globl jump_to_kernel
 jump_to_kernel:
-	mov %rsi, %rsp
-	push $0
-	jmp *%rdx					; rdi = loader_info
+	xorq %rbp, %rbp 			/* Call chain ends here */
+	jmp *%rsi					/* rdi = loader_info */

src/loader/main.zig

@@ -4,7 +4,7 @@ const std = @import("std");
 const Entry = r.BootInfo.MemMap.Entry;
 const stack_size = 1024 * 16; // should be enough
 
-extern fn jump_to_kernel(loader_info: usize, stack: usize, entry: usize) void;
+extern fn jump_to_kernel(loader_info: usize, entry: usize) void;
 
 fn load_kernel(kernel: *anyopaque) usize {
     const elf: *std.elf.Elf64.Ehdr = @ptrCast(@alignCast(kernel));
@@ -53,12 +53,8 @@ fn load_kernel(kernel: *anyopaque) usize {
                     // Copy the file data.
                     @memcpy(dest, source);
 
-                    if (filesz_rem == 0) {
-                        const zeroes = phdr.memsz - phdr.filesz;
-
-                        // Fill the rest of memsz with 0.
-                        @memset(va[0..zeroes], 0);
-                    }
+                    // Zero the rest.
+                    @memset(va[file_remaining..r.page_size], 0);
 
                     // Now update the page permissions to their true value.
                     r.mem.pagemap.map_page(addr, pa, .{
@@ -89,15 +85,23 @@ pub fn loader_main(kernel: *anyopaque) void {
     r.arch.init();
     r.mem.init();
     const entry = load_kernel(kernel);
-    const stack = r.mem.alloc(stack_size);
 
+    const stack = r.mem.alloc(stack_size);
     const memmap = &r.loader_info.memory_map;
 
     r.loader_info.kernel_stack = stack;
     r.loader_info.kernel_stack_size = stack_size;
 
     // Finally, sort the memory map once we're done allocating everything.
-    std.mem.sort(Entry, memmap.entries[0..memmap.entry_count], {}, cmp_entries);
+    std.mem.sort(
+        Entry,
+        memmap.entries[0..memmap.entry_count],
+        {},
+        cmp_entries,
+    );
 
-    jump_to_kernel(@intFromPtr(&r.loader_info), stack + stack_size, entry);
+    jump_to_kernel(
+        @intFromPtr(&r.loader_info),
+        entry,
+    );
 }