refactor: move directories around a bit

src/boot/limine/entry.zig

@@ -0,0 +1,93 @@
+const b = @import("base");
+const ksyms = @import("ksyms");
+const limine = @import("limine.zig");
+
+const pl = b.pl;
+const ke = b.ke;
+const ki = ke.private;
+
+pub const std_options = b.std_options;
+pub const panic = b.panic;
+
+const std = @import("std");
+
+var boot_info: pl.BootInfo = undefined;
+
+pub export var limine_base_revision: [3]u64 linksection(".limine_requests") = limine.base_revision(6);
+
+pub export var framebuffer_request: limine.FramebufferRequest linksection(".limine_requests") = .{
+    .id = limine.framebuffer_request_id,
+    .revision = 0,
+    .response = null,
+};
+
+pub export var limine_requests_start_marker: [4]u64 linksection(".limine_requests_start") = limine.requests_start_marker;
+pub export var limine_requests_end_marker: [2]u64 linksection(".limine_requests_end") = limine.requests_end_marker;
+
+pub export var memmap_request: limine.MemmapRequest linksection(".limine_requests") = .{
+    .id = limine.memmap_request_id,
+    .revision = 0,
+    .response = null,
+};
+
+pub export var rsdp_request: limine.RsdpRequest linksection(".limine_requests") = .{
+    .id = limine.rsdp_request_id,
+    .revision = 0,
+    .response = null,
+};
+
+pub export var cmdline_request: limine.CmdlineRequest linksection(".limine_requests") = .{
+    .id = limine.cmdline_request_id,
+    .revision = 0,
+    .response = null,
+};
+
+pub export var kernel_address_request: limine.ExecutableAddressRequest linksection(".limine_requests") = .{
+    .id = limine.executable_address_request_id,
+    .revision = 0,
+    .response = null,
+};
+
+fn build_memory_map() void {
+    const memmap_response = memmap_request.response orelse {
+        @panic("Limine memmap request failed");
+    };
+
+    boot_info.memory_map.entry_count = memmap_response.entry_count;
+    const entries = memmap_response.entries orelse {
+        @panic("Limine memmap response has no entries");
+    };
+
+    for (0..memmap_response.entry_count) |i| {
+        const entry = entries[i];
+        boot_info.memory_map.entries[i] = .{
+            .base = entry.base,
+            .size = entry.length,
+            .type = switch (entry.type) {
+                .Usable => pl.BootInfo.MemMap.Entry.Type.Free,
+                .AcpiReclaimable => pl.BootInfo.MemMap.Entry.Type.AcpiReclaimable,
+                .AcpiNvs => pl.BootInfo.MemMap.Entry.Type.AcpiNvs,
+                .BootloaderReclaimable => pl.BootInfo.MemMap.Entry.Type.LoaderReclaimable,
+                .KernelAndModules => pl.BootInfo.MemMap.Entry.Type.Kernel,
+                else => pl.BootInfo.MemMap.Entry.Type.Reserved,
+            },
+        };
+    }
+}
+
+export fn kmain() callconv(.c) void {
+    boot_info.cmdline = if (cmdline_request.response) |cmdline_response| std.mem.span(cmdline_response.cmdline) else null;
+
+    boot_info.rsdp = if (rsdp_request.response) |rsdp_response| @intFromPtr(rsdp_response.rsdp) else null;
+
+    boot_info.kernel_address = if (kernel_address_request.response) |ka_response| .{
+        .physical_base = ka_response.physical_base,
+        .virtual_base = ka_response.virtual_base,
+    } else .{ .physical_base = 0, .virtual_base = 0 };
+
+    build_memory_map();
+
+    ke.ncpus = 1;
+
+    ki.init(&boot_info);
+}

src/boot/limine/limine.zig

@@ -0,0 +1,157 @@
+pub const common_magic: [2]u64 = .{
+    0xc7b1dd30df4c8b88,
+    0x0a82e883a194f07b,
+};
+
+pub const requests_start_marker: [4]u64 = .{
+    0xf6b8f4b39de7d1ae,
+    0xfab91a6940fcb9cf,
+    0x785c6ed015d3e316,
+    0x181e920a7852b9d9,
+};
+
+pub const requests_end_marker: [2]u64 = .{
+    0xadc0e0531bb10d03,
+    0x9572709f31764c62,
+};
+
+pub fn base_revision(rev: u64) [3]u64 {
+    return .{
+        0xf9562b2d5c95a6c8,
+        0x6a7b384944536bdc,
+        rev,
+    };
+}
+
+pub fn base_revision_supported(base_rev: *const [3]u64) bool {
+    return base_rev[2] == 0;
+}
+
+pub const memmap_request_id: [4]u64 = .{
+    common_magic[0],
+    common_magic[1],
+    0x67cf3d9d378a806f,
+    0xe304acdfc50c3c62,
+};
+
+pub const MemmapRequest = extern struct {
+    id: [4]u64,
+    revision: u64,
+    response: ?*MemmapResponse,
+};
+
+pub const MemmapResponse = extern struct {
+    revision: u64,
+    entry_count: u64,
+    entries: ?[*]*MemmapEntry,
+};
+
+pub const MemmapEntryType = enum(u64) {
+    Usable = 0,
+    Reserved = 1,
+    AcpiReclaimable = 2,
+    AcpiNvs = 3,
+    BadMemory = 4,
+    BootloaderReclaimable = 5,
+    KernelAndModules = 6,
+    Framebuffer = 7,
+    ReservedMapped = 8,
+};
+
+pub const MemmapEntry = extern struct {
+    base: u64,
+    length: u64,
+    type: MemmapEntryType,
+};
+
+pub const rsdp_request_id: [4]u64 = .{
+    common_magic[0],
+    common_magic[1],
+    0xc5e77b6b397e7b43,
+    0x27637845accdcf3c,
+};
+
+pub const RsdpRequest = extern struct {
+    id: [4]u64,
+    revision: u64,
+    response: ?*RsdpResponse,
+};
+
+pub const RsdpResponse = extern struct {
+    revision: u64,
+    rsdp: ?*anyopaque,
+};
+
+pub const cmdline_request_id: [4]u64 = .{
+    common_magic[0],
+    common_magic[1],
+    0x4b161536e598651e,
+    0xb390ad4a2f1f303a,
+};
+
+pub const CmdlineRequest = extern struct {
+    id: [4]u64,
+    revision: u64,
+    response: ?*CmdlineResponse,
+};
+
+pub const CmdlineResponse = extern struct {
+    revision: u64,
+    cmdline: ?[*:0]u8,
+};
+
+pub const executable_address_request_id: [4]u64 = .{
+    common_magic[0],
+    common_magic[1],
+    0x71ba76863cc55f63,
+    0xb2644a48c516a487,
+};
+
+pub const ExecutableAddressRequest = extern struct {
+    id: [4]u64,
+    revision: u64,
+    response: ?*ExecutableAddressResponse,
+};
+
+pub const ExecutableAddressResponse = extern struct {
+    revision: u64,
+    physical_base: u64,
+    virtual_base: u64,
+};
+
+pub const framebuffer_request_id: [4]u64 = .{
+    common_magic[0],
+    common_magic[1],
+    0x9d5827dcd881dd75,
+    0xa3148604f6fab11b,
+};
+
+pub const FramebufferRequest = extern struct {
+    id: [4]u64,
+    revision: u64,
+    response: ?*FramebufferResponse,
+};
+
+pub const FramebufferResponse = extern struct {
+    revision: u64,
+    framebuffer_count: u64,
+    framebuffers: ?[*]*Framebuffer,
+};
+
+pub const Framebuffer = extern struct {
+    address: ?*anyopaque,
+    width: u64,
+    height: u64,
+    pitch: u64,
+    bpp: u16,
+    memory_model: u8,
+    red_mask_size: u8,
+    red_mask_shift: u8,
+    green_mask_size: u8,
+    green_mask_shift: u8,
+    blue_mask_size: u8,
+    blue_mask_shift: u8,
+    unused: [7]u8,
+    edid_size: u64,
+    edid: ?*anyopaque,
+};