···

       
2
       
2
       
 
       
//AMD64 Kernel

     

       
3
       
3
       
 
       
  protocol: limine

     

       
4
       
4
       
 
       
  path: boot():/kernel-amd64.elf

     

       
5
       
5
       
-
       
  module_path: boot():/init-amd64.elf

     

       
5
       
5
       
+
       
  module_path: boot():/root-69.elf

     

       
6
       
6
       
+
       
  module_path: boot():/root-420.elf

     

       
6
       
7
       
 
       
//aarch64 Kernel

     

       
7
       
8
       
 
       
  protocol: limine

     

       
8
       
9
       
 
       
  path: boot():/kernel-aarch64.elf

     

···

       
9
       
9
       
 
       
    });

     

       
10
       
10
       
 
       
    const ukernel_artifact = ukernel_dep.artifact("ukernel");

     

       
11
       
11
       
 
       
    const ukernel_inst = b.addInstallFile(ukernel_artifact.getEmittedBin(), arch.kernelExeName());

     

       
12
       
12
       
-
       
    b.default_step.dependOn(&ukernel_inst.step);

     

       
12
       
12
       
+
       
    b.getInstallStep().dependOn(&ukernel_inst.step);

     

       
13
       
13
       
 
       


     

       
14
       
14
       
-
       
    const root_dep = b.dependency("root_server", .{

     

       
14
       
14
       
+
       
    const root_69 = b.dependency("root_server", .{

     

       
15
       
15
       
+
       
        .arch = arch,

     

       
16
       
16
       
+
       
        .number = 0x69,

     

       
17
       
17
       
+
       
    }).artifact("root_server");

     

       
18
       
18
       
+
       
    const root_69_inst = b.addInstallFile(root_69.getEmittedBin(), "root-69.elf");

     

       
19
       
19
       
+
       
    b.getInstallStep().dependOn(&root_69_inst.step);

     

       
20
       
20
       
+
       


     

       
21
       
21
       
+
       
    const root_420 = b.dependency("root_server", .{

     

       
15
       
22
       
 
       
        .arch = arch,

     

       
16
       
16
       
-
       
    });

     

       
17
       
17
       
-
       
    const root_artifact = root_dep.artifact("root_server");

     

       
18
       
18
       
-
       
    const root_inst = b.addInstallFile(root_artifact.getEmittedBin(), arch.rootTaskName());

     

       
19
       
19
       
-
       
    b.default_step.dependOn(&root_inst.step);

     

       
23
       
23
       
+
       
        .number = 0x420,

     

       
24
       
24
       
+
       
    }).artifact("root_server");

     

       
25
       
25
       
+
       
    const root_420_inst = b.addInstallFile(root_420.getEmittedBin(), "root-420.elf");

     

       
26
       
26
       
+
       
    b.getInstallStep().dependOn(&root_420_inst.step);

     

       
20
       
27
       
 
       


     

       
21
       
28
       
 
       
    // Run in QEMU

     

       
22
       
29
       
 
       
    run_blk: {

     
···

       
34
       
41
       
 
       
            break :blk limine_dep.path("BOOTX64.EFI");

     

       
35
       
42
       
 
       
        };

     

       
36
       
43
       
 
       


     

       
44
       
44
       
+
       
        // Install Required dependencies

     

       
37
       
45
       
 
       
        const code_install = b.addInstallFile(ovmf_code, "OVMF_CODE_X64.fd");

     

       
38
       
46
       
 
       
        const vars_install = b.addInstallFile(ovmf_vars, "OVMF_VARS_X64.fd");

     

       
39
       
47
       
 
       
        const loader_install = b.addInstallFileWithDir(loader_path, .{ .custom = "EFI/BOOT" }, "BOOTX64.EFI");

     

       
40
       
48
       
 
       
        const config_install = b.addInstallFileWithDir(b.path("assets/limine.conf"), .{ .custom = "limine" }, "limine.conf");

     

       
41
       
49
       
 
       


     

       
42
       
42
       
-
       
        const qemu_prepare_step = b.step("qemu_prepare", "Prepare for QEMU run");

     

       
43
       
43
       
-
       
        qemu_prepare_step.dependOn(&code_install.step);

     

       
44
       
44
       
-
       
        qemu_prepare_step.dependOn(&vars_install.step);

     

       
45
       
45
       
-
       
        qemu_prepare_step.dependOn(&loader_install.step);

     

       
46
       
46
       
-
       
        qemu_prepare_step.dependOn(&config_install.step);

     

       
50
       
50
       
+
       
        const qemu_cmd = b.addSystemCommand(&.{ "qemu-system-x86_64", "-smp", "4", "-m", "4G", "-monitor", "stdio", "-drive", "format=raw,file=fat:rw:zig-out", "-drive", "if=pflash,format=raw,readonly=on,file=zig-out/OVMF_CODE_X64.fd", "-drive", "if=pflash,format=raw,file=zig-out/OVMF_VARS_X64.fd" });

     

       
51
       
51
       
+
       


     

       
52
       
52
       
+
       
        // Depend on the install step (ukernel and root task)

     

       
53
       
53
       
+
       
        qemu_cmd.step.dependOn(b.getInstallStep());

     

       
54
       
54
       
+
       
        // Depend on OVMF code+vars, Limine bootloader, and Limine cfg

     

       
55
       
55
       
+
       
        qemu_cmd.step.dependOn(&code_install.step);

     

       
56
       
56
       
+
       
        qemu_cmd.step.dependOn(&vars_install.step);

     

       
57
       
57
       
+
       
        qemu_cmd.step.dependOn(&loader_install.step);

     

       
58
       
58
       
+
       
        qemu_cmd.step.dependOn(&config_install.step);

     

       
47
       
59
       
 
       


     

       
48
       
48
       
-
       
        const qemu_cmd = b.addSystemCommand(&.{ "qemu-system-x86_64", "-smp", "4", "-m", "4G", "-monitor", "stdio", "-drive", "format=raw,file=fat:rw:zig-out", "-drive", "if=pflash,format=raw,readonly=on,file=zig-out/OVMF_CODE_X64.fd", "-drive", "if=pflash,format=raw,file=zig-out/OVMF_VARS_X64.fd" });

     

       
60
       
60
       
+
       
        // Create the actual public callable step and depend on our command

     

       
49
       
61
       
 
       
        const qemu_step = b.step("qemu", "Run in QEMU");

     

       
50
       
50
       
-
       
        qemu_step.dependOn(b.default_step);

     

       
51
       
51
       
-
       
        qemu_step.dependOn(qemu_prepare_step);

     

       
52
       
62
       
 
       
        qemu_step.dependOn(&qemu_cmd.step);

     

       
53
       
63
       
 
       
    }

     

       
54
       
64
       
 
       
}

     

···

       
14
       
14
       
 
       
            .path = "components/build_helpers",

     

       
15
       
15
       
 
       
        },

     

       
16
       
16
       
 
       
        .limine_binary = .{

     

       
17
       
17
       
-
       
            .url = "git+https://codeberg.org/Limine/Limine?ref=v9.x-binary#acf1e35c4685dba7ef271013db375a727c340ff7",

     

       
18
       
18
       
-
       
            .hash = "N-V-__8AAOkzSACT_9p6kmSSly1l008erzXuG39Z6r54B_y0",

     

       
19
       
19
       
-
       
            // Codeberg is always down so better to leave it not lazy

     

       
20
       
20
       
-
       
            // .lazy = true,

     

       
17
       
17
       
+
       
            .url = "git+https://codeberg.org/Limine/Limine?ref=v10.x-binary#648e33afd153bdbf780ba123e45997428796395d",

     

       
18
       
18
       
+
       
            .hash = "N-V-__8AAJ8bSADxAGaebgaAbkAR2kqOBy52rXAL0oCumn0t",

     

       
19
       
19
       
+
       
            .lazy = true,

     

       
21
       
20
       
 
       
        },

     

       
22
       
21
       
 
       
        .edk2_binary = .{

     

       
23
       
22
       
 
       
            .url = "git+https://github.com/retrage/edk2-nightly#23068f498687bf64f2b8f80fbcf11e82d987fd9b",

     

···

       
3
       
3
       
 
       


     

       
4
       
4
       
 
       
pub fn build(b: *std.Build) void {

     

       
5
       
5
       
 
       
    const arch = b.option(build_helpers.Architecture, "arch", "The target root_server architecture") orelse .amd64;

     

       
6
       
6
       
+
       
    const number = b.option(usize, "number", "The syscall number to use") orelse 0x69;

     

       
6
       
7
       
 
       


     

       
7
       
8
       
 
       
    // set CPU features based on the architecture

     

       
8
       
9
       
 
       
    const target = b.resolveTargetQuery(.{

     
···

       
20
       
21
       
 
       


     

       
21
       
22
       
 
       
    const config = b.addOptions();

     

       
22
       
23
       
 
       
    config.addOption(build_helpers.Architecture, "arch", arch);

     

       
24
       
24
       
+
       
    config.addOption(usize, "number", number);

     

       
23
       
25
       
 
       


     

       
24
       
26
       
 
       
    const build_helpers_dep = b.dependency("build_helpers", .{});

     

       
25
       
27
       
 
       


     

···

       
1
       
1
       
 
       
const std = @import("std");

     

       
2
       
2
       
 
       
const os = @import("os.zig");

     

       
3
       
3
       
+
       
const config = @import("config");

     

       
3
       
4
       
 
       


     

       
4
       
5
       
 
       
export fn _start() callconv(.c) noreturn {

     

       
5
       
6
       
 
       
    _ = os.syscall1(SYS_poke, 0xB16B00B5BADBABE);

     

       
6
       
6
       
-
       
    _ = os.syscall1(SYS_exit, 0);

     

       
7
       
7
       
-
       
    unreachable;

     

       
7
       
7
       
+
       
    _ = os.syscall1(SYS_exit, 0x69696969);

     

       
8
       
8
       
+
       
    asm volatile ("int3");

     

       
9
       
9
       
+
       
    asm volatile (

     

       
10
       
10
       
+
       
        \\ mov %[number], %%rdi

     

       
11
       
11
       
+
       
        \\ xor %%rsi, %%rsi

     

       
12
       
12
       
+
       
        \\ xor %%rbx, %%rbx

     

       
13
       
13
       
+
       
        \\ mainloop:

     

       
14
       
14
       
+
       
        \\ xor %%rax, %%rax

     

       
15
       
15
       
+
       
        \\ delayloop:

     

       
16
       
16
       
+
       
        \\ inc %%rax

     

       
17
       
17
       
+
       
        \\ cmp $0x1000000, %%rax

     

       
18
       
18
       
+
       
        \\ jnz delayloop

     

       
19
       
19
       
+
       
        \\ inc %%rbx

     

       
20
       
20
       
+
       
        \\ mov %%rsp, %%rsi

     

       
21
       
21
       
+
       
        \\ syscall

     

       
22
       
22
       
+
       
        \\ jmp mainloop

     

       
23
       
23
       
+
       
        :

     

       
24
       
24
       
+
       
        : [number] "r" (config.number),

     

       
25
       
25
       
+
       
    );

     

       
26
       
26
       
+
       


     

       
27
       
27
       
+
       
    die();

     

       
8
       
28
       
 
       
}

     

       
9
       
9
       
-
       
pub const SYS_exit = 69;

     

       
10
       
10
       
-
       
pub const SYS_poke = 420;

     

       
29
       
29
       
+
       


     

       
30
       
30
       
+
       
pub inline fn die() noreturn {

     

       
31
       
31
       
+
       
    while (true) {}

     

       
32
       
32
       
+
       
}

     

       
33
       
33
       
+
       


     

       
34
       
34
       
+
       
pub const SYS_exit = 0x420;

     

       
35
       
35
       
+
       
pub const SYS_poke = 0x69;

     

···

       
21
       
21
       
 
       
    pub fn syscall1(number: usize, arg1: usize) usize {

     

       
22
       
22
       
 
       
        return asm volatile ("syscall"

     

       
23
       
23
       
 
       
            : [ret] "={rax}" (-> usize),

     

       
24
       
24
       
-
       
            : [number] "{rax}" (number),

     

       
25
       
25
       
-
       
              [arg1] "{rdi}" (arg1),

     

       
24
       
24
       
+
       
            : [number] "{rdi}" (number),

     

       
25
       
25
       
+
       
              [arg1] "{rsi}" (arg1),

     

       
26
       
26
       
 
       
            : .{ .rcx = true, .r11 = true });

     

       
27
       
27
       
 
       
    }

     

       
28
       
28
       
 
       
};

     

···

       
2
       
2
       
 
       
const std = @import("std");

     

       
3
       
3
       
 
       
const arch = @import("root.zig");

     

       
4
       
4
       
 
       
const common = @import("common");

     

       
5
       
5
       
-
       
const console = @import("console");

     

       
6
       
5
       
 
       
const log = std.log.scoped(.aarch64_init);

     

       
7
       
6
       
 
       


     

       
8
       
7
       
 
       
pub const limine_requests = struct {

     
···

       
22
       
21
       
 
       
pub fn bsp_init() callconv(.c) noreturn {

     

       
23
       
22
       
 
       
    if (limine_requests.framebuffer.response) |fb_response| {

     

       
24
       
23
       
 
       
        if (fb_response.framebuffer_count > 0) {

     

       
25
       
25
       
-
       
            const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       
24
       
24
       
+
       
            const fb = common.aux.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       
26
       
25
       
 
       
            common.init_data.framebuffer = fb;

     

       
27
       
26
       
 
       
            @memset(fb.address[0..64], 0xFF);

     

       
28
       
27
       
 
       
        }

     
···

       
68
       
67
       
 
       
            const mod_addr: [*]align(4096) u8 = @ptrCast(mod.address);

     

       
69
       
68
       
 
       
            const mod_size = mod.size;

     

       
70
       
69
       
 
       
            log.info("Loading root task with {s} @ {*}", .{ mod.path, mod.address });

     

       
71
       
71
       
-
       
            common.init_data.root_task = mod_addr[0..mod_size];

     

       
70
       
70
       
+
       
            common.init_data.root_task_elf = mod_addr[0..mod_size];

     

       
72
       
71
       
 
       
        }

     

       
73
       
72
       
 
       
    } else {

     

       
74
       
73
       
 
       
        @branchHint(.unlikely);

     
···

       
83
       
82
       
 
       
fn initConsole() void {

     

       
84
       
83
       
 
       
    if (limine_requests.framebuffer.response) |fb_response| {

     

       
85
       
84
       
 
       
        if (fb_response.framebuffer_count > 0) {

     

       
86
       
86
       
-
       
            const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       
85
       
85
       
+
       
            const fb = common.aux.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       
87
       
86
       
 
       
            common.init_data.framebuffer = fb;

     

       
88
       
87
       
 
       
            // At this point, log becomes usable

     

       
89
       
88
       
 
       
            common.init_data.console = console.Console.from_font(fb, console.DefaultFont);

     

···

       
4
       
4
       
 
       
const common = @import("common");

     

       
5
       
5
       
 
       
const console = @import("console");

     

       
6
       
6
       
 
       
const log = std.log.scoped(.amd64_init);

     

       
7
       
7
       
-
       
const Idt = arch.structures.Idt;

     

       
8
       
7
       
 
       
const StandardGdt = arch.structures.gdt.StandardGdt;

     

       
9
       
8
       
 
       
const Tss = arch.structures.tss.Tss;

     

       
10
       
10
       
-
       


     

       
11
       
11
       
-
       
var per_cpu_init_data: PerCpuInitData = .{};

     

       
12
       
9
       
 
       


     

       
13
       
10
       
 
       
pub const limine_requests = struct {

     

       
14
       
11
       
 
       
    export var start_marker: limine.RequestsStartMarker linksection(".limine_reqs_start") = .{};

     
···

       
24
       
21
       
 
       
    pub export var mp: limine.SmpMpFeature.MpRequest linksection(".limine_reqs") = .{ .flags = .{ .x2apic = true } };

     

       
25
       
22
       
 
       
};

     

       
26
       
23
       
 
       


     

       
27
       
27
       
-
       
pub fn bsp_init() callconv(.c) noreturn {

     

       
24
       
24
       
+
       
pub fn early_init() void {

     

       
28
       
25
       
 
       
    // Don't optimize away the limine requests

     

       
29
       
26
       
 
       
    inline for (@typeInfo(limine_requests).@"struct".decls) |decl| {

     

       
30
       
27
       
 
       
        std.mem.doNotOptimizeAway(&@field(limine_requests, decl.name));

     

       
28
       
28
       
+
       
    }

     

       
29
       
29
       
+
       


     

       
30
       
30
       
+
       
    // If the base revision isn't supported, we can't boot

     

       
31
       
31
       
+
       
    if (!limine_requests.base_revision.isSupported()) {

     

       
32
       
32
       
+
       
        @branchHint(.cold);

     

       
33
       
33
       
+
       
        arch.instructions.die();

     

       
31
       
34
       
 
       
    }

     

       
32
       
35
       
 
       


     

       
33
       
36
       
 
       
    // If the base revision isn't supported, we can't boot

     
···

       
49
       
52
       
 
       
    const hhdm_offset = limine_requests.hhdm.response.?.offset;

     

       
50
       
53
       
 
       
    common.init_data.hhdm_slide = hhdm_offset;

     

       
51
       
54
       
 
       


     

       
52
       
52
       
-
       
    // Add in a framebuffer if found

     

       
53
       
53
       
-
       
    initConsole();

     

       
55
       
55
       
+
       
    // Get CPUID info

     

       
56
       
56
       
+
       
    arch.instructions.cpuid.init();

     

       
57
       
57
       
+
       


     

       
58
       
58
       
+
       
    // Set up the kernel paging context

     

       
59
       
59
       
+
       
    common.init_data.kernel_paging_ctx = arch.mm.paging.Context.get_current();

     

       
60
       
60
       
+
       
}

     

       
61
       
61
       
+
       


     

       
62
       
62
       
+
       
pub fn bsp_init() void {

     

       
63
       
63
       
+
       
    // Set up per-cpu data

     

       
64
       
64
       
+
       
    arch.per_cpu_init_data.init(limine_requests.mp.response.?.cpu_count);

     

       
65
       
65
       
+
       


     

       
66
       
66
       
+
       
    // Set up our own GDT and TSS

     

       
67
       
67
       
+
       
    const gdt = &arch.per_cpu_init_data.gdt_buf[0];

     

       
68
       
68
       
+
       
    gdt.* = .{};

     

       
69
       
69
       
+
       
    const tss = &arch.per_cpu_init_data.tss_buf[0];

     

       
70
       
70
       
+
       
    // TODO: create a fixed mapping for the pages maybe?

     

       
71
       
71
       
+
       
    tss.* = .{

     

       
72
       
72
       
+
       
        .rsp0 = common.init_data.hhdm_slide + arch.per_cpu_init_data.getStackPhys(0),

     

       
73
       
73
       
+
       
    };

     

       
74
       
74
       
+
       


     

       
75
       
75
       
+
       
    gdt.tss_desc.set_tss_addr(tss);

     

       
76
       
76
       
+
       
    gdt.load();

     

       
77
       
77
       
+
       


     

       
78
       
78
       
+
       
    // Add in the framebuffer

     

       
79
       
79
       
+
       
    if (limine_requests.framebuffer.response) |fb_response| {

     

       
80
       
80
       
+
       
        if (fb_response.framebuffer_count > 0) {

     

       
81
       
81
       
+
       
            const fb = fb_response.getFramebuffers()[0];

     

       
82
       
82
       
+
       
            common.init_data.framebuffer = .{

     

       
83
       
83
       
+
       
                .address = @ptrCast(@alignCast(fb.address)),

     

       
84
       
84
       
+
       
                .width = fb.width,

     

       
85
       
85
       
+
       
                .height = fb.height,

     

       
86
       
86
       
+
       
                .pitch = fb.pitch,

     

       
87
       
87
       
+
       
                .red_mask_size = fb.red_mask_size,

     

       
88
       
88
       
+
       
                .red_mask_shift = fb.red_mask_shift,

     

       
89
       
89
       
+
       
                .green_mask_size = fb.green_mask_size,

     

       
90
       
90
       
+
       
                .green_mask_shift = fb.green_mask_shift,

     

       
91
       
91
       
+
       
                .blue_mask_size = fb.blue_mask_size,

     

       
92
       
92
       
+
       
                .blue_mask_shift = fb.blue_mask_shift,

     

       
93
       
93
       
+
       
                .bypp = fb.bpp / 8,

     

       
94
       
94
       
+
       
            };

     

       
95
       
95
       
+
       
        }

     

       
96
       
96
       
+
       
    }

     

       
54
       
97
       
 
       


     

       
55
       
98
       
 
       
    // Add in ACPI/dtb if found, prefer ACPI

     

       
56
       
99
       
 
       
    initHwDesc();

     

       
57
       
100
       
 
       


     

       
58
       
58
       
-
       
    // Set up the temporary Physical Memory Allocator

     

       
59
       
59
       
-
       
    common.mm.bootmem.init();

     

       
60
       
60
       
-
       


     

       
61
       
101
       
 
       
    // Attach the root task

     

       
62
       
102
       
 
       
    if (limine_requests.modules.response) |module_response| {

     

       
63
       
103
       
 
       
        if (module_response.module_count > 0) {

     
···

       
65
       
105
       
 
       
            const mod_addr: [*]align(4096) u8 = @ptrCast(mod.address);

     

       
66
       
106
       
 
       
            const mod_size = mod.size;

     

       
67
       
107
       
 
       
            log.info("Loading root task with {s} @ {*}", .{ mod.path, mod.address });

     

       
68
       
68
       
-
       
            common.init_data.root_task = mod_addr[0..mod_size];

     

       
108
       
108
       
+
       
            common.init_data.root_task_elf = mod_addr[0..mod_size];

     

       
69
       
109
       
 
       
        }

     

       
70
       
110
       
 
       
    } else {

     

       
71
       
111
       
 
       
        @branchHint(.unlikely);

     

       
72
       
112
       
 
       
        @panic("No root task found!");

     

       
73
       
113
       
 
       
    }

     

       
74
       
114
       
 
       


     

       
75
       
75
       
-
       
    // Initialize per-cpu data (GDT and TSS)

     

       
76
       
76
       
-
       
    per_cpu_init_data.init();

     

       
77
       
77
       
-
       


     

       
78
       
78
       
-
       
    // Install the IDT

     

       
79
       
79
       
-
       
    initIdt();

     

       
80
       
80
       
-
       


     

       
81
       
81
       
-
       
    // AP bootstrap

     

       
82
       
115
       
 
       
    bootstrapAPs();

     

       
83
       
83
       
-
       


     

       
84
       
84
       
-
       
    // Set up our own GDT and TSS

     

       
85
       
85
       
-
       
    const gdt = &per_cpu_init_data.gdt_buf[0];

     

       
86
       
86
       
-
       
    gdt.* = .{};

     

       
87
       
87
       
-
       
    const tss = &per_cpu_init_data.tss_buf[0];

     

       
88
       
88
       
-
       
    // TSS rsp 0x3800

     

       
89
       
89
       
-
       
    tss.* = .{

     

       
90
       
90
       
-
       
        .rsp0 = 0x3800,

     

       
91
       
91
       
-
       
        .rsp1 = 0x3800,

     

       
92
       
92
       
-
       
        .rsp2 = 0x3800,

     

       
93
       
93
       
-
       
    };

     

       
94
       
94
       
-
       


     

       
95
       
95
       
-
       
    gdt.tss_desc.set_tss_addr(tss);

     

       
96
       
96
       
-
       
    gdt.load();

     

       
97
       
97
       
-
       
    log.info("BSP successfully setup GDT+TSS!", .{});

     

       
98
       
98
       
-
       


     

       
99
       
99
       
-
       
    log.info("Allocating code for userspace...", .{});

     

       
100
       
100
       
-
       


     

       
101
       
101
       
-
       
    const user_code = common.init_data.bootmem.allocPhys(0x1000) catch @panic("alloc bruh");

     

       
102
       
102
       
-
       
    const user_stack = common.init_data.bootmem.allocPhys(0x1000) catch @panic("alloc bruh2");

     

       
103
       
103
       
-
       


     

       
104
       
104
       
-
       
    // TODO: load the actual root task ELF for fucks sake

     

       
105
       
105
       
-
       
    // instead of the current glorified shellcode

     

       
106
       
106
       
-
       


     

       
107
       
107
       
-
       
    // Map our executable page to 0x1000

     

       
108
       
108
       
-
       
    common.mm.paging.mapPhys(.{

     

       
109
       
109
       
-
       
        .vaddr = 0x8000,

     

       
110
       
110
       
-
       
        .paddr = user_code,

     

       
111
       
111
       
-
       
        .size = 0x1000,

     

       
112
       
112
       
-
       
        .memory_type = .MemoryWriteBack,

     

       
113
       
113
       
-
       
        .perms = .{

     

       
114
       
114
       
-
       
            .executable = true,

     

       
115
       
115
       
-
       
            .writable = false,

     

       
116
       
116
       
-
       
            .userspace_accessible = true,

     

       
117
       
117
       
-
       
        },

     

       
118
       
118
       
-
       
    }) catch {

     

       
119
       
119
       
-
       
        @panic("Mapping failed!!!!!");

     

       
120
       
120
       
-
       
    };

     

       
121
       
121
       
-
       


     

       
122
       
122
       
-
       
    // Map our stack page to 0x3000 (starts at 0x4000)

     

       
123
       
123
       
-
       
    common.mm.paging.mapPhys(.{

     

       
124
       
124
       
-
       
        .vaddr = 0x3000,

     

       
125
       
125
       
-
       
        .paddr = user_stack,

     

       
126
       
126
       
-
       
        .size = 0x1000,

     

       
127
       
127
       
-
       
        .memory_type = .MemoryWriteBack,

     

       
128
       
128
       
-
       
        .perms = .{

     

       
129
       
129
       
-
       
            .executable = false,

     

       
130
       
130
       
-
       
            .writable = true,

     

       
131
       
131
       
-
       
            .userspace_accessible = true,

     

       
132
       
132
       
-
       
        },

     

       
133
       
133
       
-
       
    }) catch {

     

       
134
       
134
       
-
       
        @panic("Mapping failed!!!!!");

     

       
135
       
135
       
-
       
    };

     

       
136
       
136
       
-
       


     

       
137
       
137
       
-
       
    // Place shellcode there (does a couple syscalls then jmp $ infinite loop)

     

       
138
       
138
       
-
       
    const memory: [*]u8 = common.mm.physToHHDM([*]u8, user_code);

     

       
139
       
139
       
-
       
    const shellcode = [_]u8{ 0x48, 0xBF, 0xE1, 0xAB, 0xDB, 0xBA, 0xB5, 0x00, 0x6B, 0xB1, 0x48, 0xBE, 0x06, 0x42, 0x69, 0x20, 0x94, 0x06, 0x42, 0x69, 0x0F, 0x05, 0xBF, 0x11, 0xCA, 0x00, 0x00, 0xBE, 0x69, 0x69, 0x69, 0x69, 0x0F, 0x05, 0xEB, 0xFE };

     

       
140
       
140
       
-
       
    @memcpy(memory[0..@sizeOf(@TypeOf(shellcode))], shellcode[0..]);

     

       
141
       
141
       
-
       


     

       
142
       
142
       
-
       
    // Set up MSRs to enable syscalls

     

       
143
       
143
       
-
       
    init_syscalls();

     

       
144
       
144
       
-
       


     

       
145
       
145
       
-
       
    // Finally, iretq ourselves into this bitch

     

       
146
       
146
       
-
       
    enter_userspace(0x8000, 0x69, 0x3800);

     

       
147
       
116
       
 
       
}

     

       
148
       
117
       
 
       


     

       
149
       
149
       
-
       
// Get ready for system calls (set MSRs)

     

       
150
       
150
       
-
       
fn init_syscalls() void {

     

       
151
       
151
       
-
       
    // Set up the STAR MSR with the segment descriptors

     

       
152
       
152
       
-
       
    const IA32_STAR = arch.registers.MSR(u64, 0xC0000081);

     

       
153
       
153
       
-
       
    const star_value: u64 = 0 | @as(u64, arch.structures.gdt.StandardGdt.selectors.kernel_code) << 32 | (@as(u64, arch.structures.gdt.StandardGdt.selectors.tss_desc + 8) | 3) << 48;

     

       
154
       
154
       
-
       
    IA32_STAR.write(star_value);

     

       
155
       
155
       
-
       
    log.debug("Wrote 0x{x:0>16} to IA32_STAR", .{star_value});

     

       
118
       
118
       
+
       
pub fn loadTasks() void {

     

       
119
       
119
       
+
       
    const tasks_buf: [*]arch.structures.Task = @ptrFromInt(common.init_data.bootmem.allocMem(std.heap.pageSize()) catch {

     

       
120
       
120
       
+
       
        std.log.err("Couldn't allocate tasks!", .{});

     

       
121
       
121
       
+
       
        @panic("allocPhys");

     

       
122
       
122
       
+
       
    });

     

       
123
       
123
       
+
       
    const tasks_scratch: []arch.structures.Task = tasks_buf[0 .. std.heap.pageSize() / @sizeOf(arch.structures.Task)];

     

       
156
       
124
       
 
       


     

       
157
       
157
       
-
       
    // Set up the EFER MSR with SCE (System Call Enable)

     

       
158
       
158
       
-
       
    const IA32_EFER = arch.registers.MSR(u64, 0xC0000080);

     

       
159
       
159
       
-
       
    const efer_val = IA32_EFER.read() | 0b1;

     

       
160
       
160
       
-
       
    IA32_EFER.write(efer_val);

     

       
161
       
161
       
-
       
    log.debug("Wrote 0x{x:0>16} to IA32_EFER", .{efer_val});

     

       
162
       
162
       
-
       


     

       
163
       
163
       
-
       
    // Set up LSTAR with the syscall handler and FMASK to clear interrupts

     

       
164
       
164
       
-
       
    const IA32_LSTAR = arch.registers.MSR(u64, 0xC0000082);

     

       
165
       
165
       
-
       
    IA32_LSTAR.write(@intFromPtr(syscall_entry));

     

       
166
       
166
       
-
       


     

       
167
       
167
       
-
       
    log.debug("Wrote 0x{x:0>16} to IA32_LSTAR", .{@intFromPtr(syscall_entry)});

     

       
168
       
168
       
-
       


     

       
169
       
169
       
-
       
    const IA32_FMASK = arch.registers.MSR(u64, 0xC0000084);

     

       
170
       
170
       
-
       
    IA32_FMASK.write(1 << 9);

     

       
171
       
171
       
-
       
    log.debug("Wrote 0x{x:0>16} to IA32_FMASK", .{1 << 9});

     

       
172
       
172
       
-
       
}

     

       
173
       
173
       
-
       


     

       
174
       
174
       
-
       
const syscall_entry = @extern(*anyopaque, .{

     

       
175
       
175
       
-
       
    .name = "syscall_entry",

     

       
176
       
176
       
-
       
});

     

       
177
       
177
       
-
       
export fn syscall_handler(rdi: usize, rsi: usize) callconv(.c) void {

     

       
178
       
178
       
-
       
    std.log.info("Got a syscall! rdi=0x{x}, rsi=0x{x}", .{ rdi, rsi });

     

       
179
       
179
       
-
       
}

     

       
180
       
180
       
-
       


     

       
181
       
181
       
-
       
fn enter_userspace(entry: u64, arg: u64, stack: u64) noreturn {

     

       
182
       
182
       
-
       
    log.info("usercode64 GDT 0x{x}, userdata64 GDT 0x{x}", .{ arch.structures.gdt.StandardGdt.selectors.user_code, arch.structures.gdt.StandardGdt.selectors.user_data });

     

       
183
       
183
       
-
       
    const cr3 = arch.registers.ControlRegisters.Cr3.read();

     

       
184
       
184
       
-
       
    arch.registers.ControlRegisters.Cr3.write(cr3);

     

       
185
       
185
       
-
       
    asm volatile (

     

       
186
       
186
       
-
       
        \\ push %[userdata64]

     

       
187
       
187
       
-
       
        \\ push %[stack]

     

       
188
       
188
       
-
       
        \\ push $0x2

     

       
189
       
189
       
-
       
        \\ push %[usercode64]

     

       
190
       
190
       
-
       
        \\ push %[entry]

     

       
191
       
191
       
-
       
        \\

     

       
192
       
192
       
-
       
        \\ mov %[userdata64], %%rax

     

       
193
       
193
       
-
       
        \\ mov %%rax, %%es

     

       
194
       
194
       
-
       
        \\ mov %%rax, %%ds

     

       
195
       
195
       
-
       
        \\

     

       
196
       
196
       
-
       
        \\ xor %%rsi, %%rsi

     

       
197
       
197
       
-
       
        \\ xor %%rax, %%rax

     

       
198
       
198
       
-
       
        \\ xor %%rdx, %%rdx

     

       
199
       
199
       
-
       
        \\ xor %%rcx, %%rcx

     

       
200
       
200
       
-
       
        \\ xor %%rbp, %%rbp

     

       
201
       
201
       
-
       
        \\ xor %%rbx, %%rbx

     

       
202
       
202
       
-
       
        \\

     

       
203
       
203
       
-
       
        \\ xor %%r8, %%r8

     

       
204
       
204
       
-
       
        \\ xor %%r9, %%r9

     

       
205
       
205
       
-
       
        \\ xor %%r10, %%r10

     

       
206
       
206
       
-
       
        \\ xor %%r11, %%r11

     

       
207
       
207
       
-
       
        \\ xor %%r12, %%r12

     

       
208
       
208
       
-
       
        \\ xor %%r13, %%r13

     

       
209
       
209
       
-
       
        \\ xor %%r14, %%r14

     

       
210
       
210
       
-
       
        \\ xor %%r15, %%r15

     

       
211
       
211
       
-
       
        \\

     

       
212
       
212
       
-
       
        \\ iretq

     

       
213
       
213
       
-
       
        \\

     

       
214
       
214
       
-
       
        :

     

       
215
       
215
       
-
       
        : [arg] "{rdi}" (arg),

     

       
216
       
216
       
-
       
          [stack] "r" (stack),

     

       
217
       
217
       
-
       
          [entry] "r" (entry),

     

       
218
       
218
       
-
       
          [userdata64] "i" (arch.structures.gdt.StandardGdt.selectors.user_data),

     

       
219
       
219
       
-
       
          [usercode64] "i" (arch.structures.gdt.StandardGdt.selectors.user_code),

     

       
220
       
220
       
-
       
    );

     

       
221
       
221
       
-
       
    unreachable;

     

       
222
       
222
       
-
       
}

     

       
223
       
223
       
-
       


     

       
224
       
224
       
-
       
fn initConsole() void {

     

       
225
       
225
       
-
       
    if (limine_requests.framebuffer.response) |fb_response| {

     

       
226
       
226
       
-
       
        if (fb_response.framebuffer_count > 0) {

     

       
227
       
227
       
-
       
            const fb = console.Framebuffer.from_limine(fb_response.getFramebuffers()[0]);

     

       
228
       
228
       
-
       
            common.init_data.framebuffer = fb;

     

       
229
       
229
       
-
       
            // At this point, log becomes usable

     

       
230
       
230
       
-
       
            common.init_data.console = console.Console.from_font(fb, console.DefaultFont);

     

       
231
       
231
       
-
       
            common.init_data.console.?.setColor(0x3bcf1d, 0);

     

       
125
       
125
       
+
       
    if (limine_requests.modules.response) |module_response| {

     

       
126
       
126
       
+
       
        if (module_response.module_count > 0) {

     

       
127
       
127
       
+
       
            for (module_response.modules.?[0..module_response.module_count], 0..) |mod, i| {

     

       
128
       
128
       
+
       
                const mod_addr: [*]align(4096) u8 = @ptrCast(mod.address);

     

       
129
       
129
       
+
       
                const mod_size = mod.size;

     

       
130
       
130
       
+
       
                common.loadTask(&tasks_scratch[i], mod_addr[0..mod_size]);

     

       
131
       
131
       
+
       
            }

     

       
232
       
132
       
 
       
        }

     

       
233
       
133
       
 
       
    }

     

       
234
       
134
       
 
       
}

     
···

       
242
       
142
       
 
       
    }

     

       
243
       
143
       
 
       
}

     

       
244
       
144
       
 
       


     

       
245
       
245
       
-
       
pub fn initIdt() void {

     

       
246
       
246
       
-
       
    const idt_addr: usize = @intFromPtr(per_cpu_init_data.idt);

     

       
247
       
247
       
-
       


     

       
248
       
248
       
-
       
    // Install the known exception handlers

     

       
249
       
249
       
-
       
    per_cpu_init_data.idt.breakpoint.installHandler(breakpoint_handler);

     

       
250
       
250
       
-
       
    per_cpu_init_data.idt.double_fault.installHandler(double_fault);

     

       
251
       
251
       
-
       
    per_cpu_init_data.idt.general_protection_fault.installHandler(gpf);

     

       
252
       
252
       
-
       
    per_cpu_init_data.idt.page_fault.installHandler(page_fault);

     

       
253
       
253
       
-
       


     

       
254
       
254
       
-
       
    // Load the Idt Register

     

       
255
       
255
       
-
       
    const reg: Idt.Idtr = .{ .addr = idt_addr, .limit = @sizeOf(Idt) - 1 };

     

       
256
       
256
       
-
       
    reg.load();

     

       
257
       
257
       
-
       
}

     

       
258
       
258
       
-
       


     

       
259
       
259
       
-
       
// TODO: update the type reflection thing to make a custom

     

       
260
       
260
       
-
       
// function type for the ISR

     

       
261
       
261
       
-
       
pub const PageFaultErrorCode = packed struct {

     

       
262
       
262
       
-
       
    present: bool,

     

       
263
       
263
       
-
       
    write: bool,

     

       
264
       
264
       
-
       
    user: bool,

     

       
265
       
265
       
-
       
    reserved_write: bool,

     

       
266
       
266
       
-
       
    instruction_fetch: bool,

     

       
267
       
267
       
-
       
    protection_key: bool,

     

       
268
       
268
       
-
       
    shadow_stack: bool,

     

       
269
       
269
       
-
       
    _reserved: u8,

     

       
270
       
270
       
-
       
    sgx: bool,

     

       
271
       
271
       
-
       
    _reserved2: u48,

     

       
272
       
272
       
-
       


     

       
273
       
273
       
-
       
    pub fn val(self: *const PageFaultErrorCode) u64 {

     

       
274
       
274
       
-
       
        return @bitCast(self.*);

     

       
275
       
275
       
-
       
    }

     

       
276
       
276
       
-
       
};

     

       
277
       
277
       
-
       
pub fn page_fault(stack_frame: *arch.structures.Idt.InterruptStackFrame, err_code_u64: u64) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       
278
       
278
       
-
       
    const err_code: PageFaultErrorCode = @bitCast(err_code_u64);

     

       
279
       
279
       
-
       
    log.err("PAGE FAULT @ 0x{x:0>16}, code 0x{x}!!!!!!!!!!!", .{ stack_frame.instruction_pointer, err_code.val() });

     

       
280
       
280
       
-
       
    const cr2 = arch.registers.ControlRegisters.Cr2.read();

     

       
281
       
281
       
-
       
    switch (err_code.write) {

     

       
282
       
282
       
-
       
        true => log.err("Tried to write to vaddr 0x{x:0>16}", .{cr2}),

     

       
283
       
283
       
-
       
        false => log.err("Tried to read from vaddr 0x{x:0>16}", .{cr2}),

     

       
284
       
284
       
-
       
    }

     

       
285
       
285
       
-
       
    log.err("dying...", .{});

     

       
286
       
286
       
-
       
    arch.instructions.die();

     

       
287
       
287
       
-
       
}

     

       
288
       
288
       
-
       


     

       
289
       
289
       
-
       
pub fn breakpoint_handler(stack_frame: *Idt.InterruptStackFrame) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       
290
       
290
       
-
       
    log.warn("Breakpoint @ 0x{x:0>16}, returning execution...", .{stack_frame.instruction_pointer});

     

       
291
       
291
       
-
       
}

     

       
292
       
292
       
-
       


     

       
293
       
293
       
-
       
pub fn gpf(stack_frame: *Idt.InterruptStackFrame, err_code: u64) callconv(.{ .x86_64_interrupt = .{} }) void {

     

       
294
       
294
       
-
       
    log.warn("gpf @ 0x{x:0>16} ERR CODE {}, returning execution...", .{ stack_frame.instruction_pointer, err_code });

     

       
295
       
295
       
-
       
    arch.instructions.die();

     

       
296
       
296
       
-
       
}

     

       
297
       
297
       
-
       


     

       
298
       
298
       
-
       
pub fn double_fault(stack_frame: *Idt.InterruptStackFrame, err_code: u64) callconv(.{ .x86_64_interrupt = .{} }) noreturn {

     

       
299
       
299
       
-
       
    common.init_data.console.?.setColor(0xf40d17, 0);

     

       
300
       
300
       
-
       
    log.err("FATAL DOUBLE FAULT @ 0x{x:0>16}, code 0x{x}!!!!!!!!!!!", .{ stack_frame.instruction_pointer, err_code });

     

       
301
       
301
       
-
       
    log.err("dying...", .{});

     

       
302
       
302
       
-
       
    arch.instructions.die();

     

       
303
       
303
       
-
       
}

     

       
304
       
304
       
-
       


     

       
305
       
145
       
 
       
fn bootstrapAPs() void {

     

       
306
       
146
       
 
       
    log.info("Bootstrapping APs...", .{});

     

       
307
       
147
       
 
       
    const cpus = limine_requests.mp.response.?.getCpus();

     
···

       
312
       
152
       
 
       


     

       
313
       
153
       
 
       
fn ap_init(mp_info: *limine.SmpMpFeature.MpInfo) callconv(.c) noreturn {

     

       
314
       
154
       
 
       
    // Set up the IDT

     

       
315
       
315
       
-
       
    const idt_addr: usize = @intFromPtr(per_cpu_init_data.idt);

     

       
316
       
316
       
-
       
    const reg: Idt.Idtr = .{ .addr = idt_addr, .limit = @sizeOf(Idt) - 1 };

     

       
317
       
317
       
-
       
    reg.load();

     

       
155
       
155
       
+
       
    arch.interrupts.idt.load();

     

       
318
       
156
       
 
       


     

       
319
       
157
       
 
       
    // Set up our GDT and TSS

     

       
320
       
320
       
-
       
    const gdt = &per_cpu_init_data.gdt_buf[mp_info.processor_id];

     

       
158
       
158
       
+
       
    const gdt = &arch.per_cpu_init_data.gdt_buf[mp_info.processor_id];

     

       
321
       
159
       
 
       
    gdt.* = .{};

     

       
322
       
322
       
-
       
    const tss = &per_cpu_init_data.tss_buf[mp_info.processor_id];

     

       
160
       
160
       
+
       
    const tss = &arch.per_cpu_init_data.tss_buf[mp_info.processor_id];

     

       
323
       
161
       
 
       
    tss.* = .{};

     

       
324
       
162
       
 
       


     

       
325
       
163
       
 
       
    gdt.tss_desc.set_tss_addr(tss);

     
···

       
329
       
167
       
 
       


     

       
330
       
168
       
 
       
    arch.instructions.die();

     

       
331
       
169
       
 
       
}

     

       
332
       
332
       
-
       


     

       
333
       
333
       
-
       
const PerCpuInitData = struct {

     

       
334
       
334
       
-
       
    gdt_buf: []StandardGdt = undefined,

     

       
335
       
335
       
-
       
    tss_buf: []Tss = undefined,

     

       
336
       
336
       
-
       
    idt: *Idt = undefined,

     

       
337
       
337
       
-
       


     

       
338
       
338
       
-
       
    const Self = @This();

     

       
339
       
339
       
-
       
    pub fn init(self: *Self) void {

     

       
340
       
340
       
-
       
        // 1. Allocate an IDT

     

       
341
       
341
       
-
       
        const idt_addr = common.init_data.bootmem.allocMem(@sizeOf(Idt)) catch |err| {

     

       
342
       
342
       
-
       
            std.log.err("init PerCpuInitData: IDT alloc failed: {}", .{err});

     

       
343
       
343
       
-
       
            @panic("rip bozo");

     

       
344
       
344
       
-
       
        };

     

       
345
       
345
       
-
       
        self.idt = @ptrFromInt(idt_addr);

     

       
346
       
346
       
-
       


     

       
347
       
347
       
-
       
        // 2. Allocate space for GDT and TSS data

     

       
348
       
348
       
-
       
        const cpu_count = limine_requests.mp.response.?.cpu_count;

     

       
349
       
349
       
-
       
        const gdt_size = @sizeOf(StandardGdt);

     

       
350
       
350
       
-
       
        const tss_size = @sizeOf(Tss);

     

       
351
       
351
       
-
       


     

       
352
       
352
       
-
       
        const total_required_size = gdt_size * cpu_count + tss_size * cpu_count;

     

       
353
       
353
       
-
       
        const buf: [*]u8 = @ptrFromInt(common.init_data.bootmem.allocMem(total_required_size) catch |err| {

     

       
354
       
354
       
-
       
            std.log.err("init PerCpuInitData: GDT/TSS alloc failed: {}", .{err});

     

       
355
       
355
       
-
       
            @panic("rip bozo");

     

       
356
       
356
       
-
       
        });

     

       
357
       
357
       
-
       


     

       
358
       
358
       
-
       
        // 3. Transmute and fill out the structure

     

       
359
       
359
       
-
       
        const gdt_buf: [*]StandardGdt = @ptrCast(@alignCast(buf[0 .. gdt_size * cpu_count]));

     

       
360
       
360
       
-
       
        const tss_buf: [*]Tss = @ptrCast(@alignCast(buf[gdt_size * cpu_count ..][0 .. tss_size * cpu_count]));

     

       
361
       
361
       
-
       
        self.gdt_buf = gdt_buf[0..cpu_count];

     

       
362
       
362
       
-
       
        self.tss_buf = tss_buf[0..cpu_count];

     

       
363
       
363
       
-
       
    }

     

       
364
       
364
       
-
       
};

     

···

       
1
       
1
       
+
       
// Do all the needed CPUID calls here, and store the info for later use

     

       
2
       
2
       
+
       
const std = @import("std");

     

       
3
       
3
       
+
       
const arch = @import("../root.zig");

     

       
4
       
4
       
+
       


     

       
5
       
5
       
+
       
pub const captured = struct {

     

       
6
       
6
       
+
       
    pub var vendor_str: [12]u8 = undefined;

     

       
7
       
7
       
+
       
};

     

       
8
       
8
       
+
       
pub fn init() void {

     

       
9
       
9
       
+
       
    capture_vendor_str();

     

       
10
       
10
       
+
       
    capture_cpu_features();

     

       
11
       
11
       
+
       
}

     

       
12
       
12
       
+
       


     

       
13
       
13
       
+
       
fn capture_vendor_str() void {

     

       
14
       
14
       
+
       
    const res = cpuid(0, 0);

     

       
15
       
15
       
+
       
    @memcpy(captured.vendor_str[0..4], std.mem.asBytes(&res.ebx));

     

       
16
       
16
       
+
       
    @memcpy(captured.vendor_str[4..8], std.mem.asBytes(&res.edx));

     

       
17
       
17
       
+
       
    @memcpy(captured.vendor_str[8..12], std.mem.asBytes(&res.ecx));

     

       
18
       
18
       
+
       
}

     

       
19
       
19
       
+
       


     

       
20
       
20
       
+
       
fn capture_cpu_features() void {

     

       
21
       
21
       
+
       
    const res = cpuid(1, 0);

     

       
22
       
22
       
+
       
    const feat_ecx: FeaturesEcx = @bitCast(res.ecx);

     

       
23
       
23
       
+
       
    arch.interrupts.apic.tsc_deadline_available = feat_ecx.tsc_deadline;

     

       
24
       
24
       
+
       
    arch.interrupts.apic.has_x2apic = feat_ecx.x2apic;

     

       
25
       
25
       
+
       
}

     

       
26
       
26
       
+
       


     

       
27
       
27
       
+
       
const FeaturesEcx = packed struct(u32) {

     

       
28
       
28
       
+
       
    sse3: bool,

     

       
29
       
29
       
+
       
    pclmulqdq: bool,

     

       
30
       
30
       
+
       
    dtes64: bool,

     

       
31
       
31
       
+
       
    monitor: bool,

     

       
32
       
32
       
+
       
    ds_cpl: bool,

     

       
33
       
33
       
+
       
    vmx: bool,

     

       
34
       
34
       
+
       
    smx: bool,

     

       
35
       
35
       
+
       
    est: bool,

     

       
36
       
36
       
+
       
    tm2: bool,

     

       
37
       
37
       
+
       
    ssse3: bool,

     

       
38
       
38
       
+
       
    cnxt_id: bool,

     

       
39
       
39
       
+
       
    sdbg: bool,

     

       
40
       
40
       
+
       
    fma: bool,

     

       
41
       
41
       
+
       
    cx16: bool,

     

       
42
       
42
       
+
       
    xtpr: bool,

     

       
43
       
43
       
+
       
    pdcm: bool,

     

       
44
       
44
       
+
       
    _reserved0: bool,

     

       
45
       
45
       
+
       
    pcid: bool,

     

       
46
       
46
       
+
       
    dca: bool,

     

       
47
       
47
       
+
       
    sse4_1: bool,

     

       
48
       
48
       
+
       
    sse4_2: bool,

     

       
49
       
49
       
+
       
    x2apic: bool,

     

       
50
       
50
       
+
       
    movbe: bool,

     

       
51
       
51
       
+
       
    popcnt: bool,

     

       
52
       
52
       
+
       
    tsc_deadline: bool,

     

       
53
       
53
       
+
       
    aesni: bool,

     

       
54
       
54
       
+
       
    xsave: bool,

     

       
55
       
55
       
+
       
    osxsave: bool,

     

       
56
       
56
       
+
       
    avx: bool,

     

       
57
       
57
       
+
       
    f16c: bool,

     

       
58
       
58
       
+
       
    rdrand: bool,

     

       
59
       
59
       
+
       
    hypervisor: bool,

     

       
60
       
60
       
+
       
};

     

       
61
       
61
       
+
       


     

       
62
       
62
       
+
       
pub inline fn cpuid(leaf: u32, sub: u32) DefaultResults {

     

       
63
       
63
       
+
       
    var eax: u32 = undefined;

     

       
64
       
64
       
+
       
    var ebx: u32 = undefined;

     

       
65
       
65
       
+
       
    var edx: u32 = undefined;

     

       
66
       
66
       
+
       
    var ecx: u32 = undefined;

     

       
67
       
67
       
+
       


     

       
68
       
68
       
+
       
    asm volatile (

     

       
69
       
69
       
+
       
        \\cpuid

     

       
70
       
70
       
+
       
        : [eax] "={eax}" (eax),

     

       
71
       
71
       
+
       
          [ebx] "={ebx}" (ebx),

     

       
72
       
72
       
+
       
          [edx] "={edx}" (edx),

     

       
73
       
73
       
+
       
          [ecx] "={ecx}" (ecx),

     

       
74
       
74
       
+
       
        : [leaf] "{eax}" (leaf),

     

       
75
       
75
       
+
       
          [sub] "{ecx}" (sub),

     

       
76
       
76
       
+
       
    );

     

       
77
       
77
       
+
       


     

       
78
       
78
       
+
       
    return .{

     

       
79
       
79
       
+
       
        .eax = eax,

     

       
80
       
80
       
+
       
        .ebx = ebx,

     

       
81
       
81
       
+
       
        .ecx = ecx,

     

       
82
       
82
       
+
       
        .edx = edx,

     

       
83
       
83
       
+
       
    };

     

       
84
       
84
       
+
       
}

     

       
85
       
85
       
+
       


     

       
86
       
86
       
+
       
pub const DefaultResults = struct {

     

       
87
       
87
       
+
       
    eax: u32 = 0,

     

       
88
       
88
       
+
       
    ebx: u32 = 0,

     

       
89
       
89
       
+
       
    edx: u32 = 0,

     

       
90
       
90
       
+
       
    ecx: u32 = 0,

     

       
91
       
91
       
+
       
};

     

···

       
1
       
1
       
+
       
pub const cpuid = @import("cpuid.zig");

     

       
2
       
2
       
+
       


     

       
3
       
3
       
+
       
pub inline fn die() noreturn {

     

       
4
       
4
       
+
       
    asm volatile (

     

       
5
       
5
       
+
       
        \\ mov $0xDEADDEADDEADDEAD, %%rax

     

       
6
       
6
       
+
       
        \\ 1: hlt

     

       
7
       
7
       
+
       
        \\ jmp 1b

     

       
8
       
8
       
+
       
    );

     

       
9
       
9
       
+
       
    unreachable;

     

       
10
       
10
       
+
       
}

     

···

       
1
       
1
       
-
       
pub inline fn die() noreturn {

     

       
2
       
2
       
-
       
    while (true) {

     

       
3
       
3
       
-
       
        asm volatile ("hlt");

     

       
4
       
4
       
-
       
    }

     

       
5
       
5
       
-
       
}

     

···

       
1
       
1
       
+
       
const std = @import("std");

     

       
2
       
2
       
+
       
const arch = @import("../root.zig");

     

       
3
       
3
       
+
       
const idt = arch.interrupts.idt;

     

       
4
       
4
       
+
       
const log = std.log.scoped(.apic);

     

       
5
       
5
       
+
       
const common = @import("common");

     

       
6
       
6
       
+
       


     

       
7
       
7
       
+
       
pub var lapic_timer_khz: usize = 0;

     

       
8
       
8
       
+
       
pub var tsc_deadline_available = false;

     

       
9
       
9
       
+
       
pub var has_x2apic: bool = false;

     

       
10
       
10
       
+
       


     

       
11
       
11
       
+
       
// tbh every cpu will be either x2apic or not, and if xapic it will

     

       
12
       
12
       
+
       
// have the exact same base address anyways so this is fine

     

       
13
       
13
       
+
       
pub var singleton: LAPIC = undefined;

     

       
14
       
14
       
+
       


     

       
15
       
15
       
+
       
// Must instantiate this!

     

       
16
       
16
       
+
       
pub const LAPIC = union(enum) {

     

       
17
       
17
       
+
       
    xapic: [*]volatile u8,

     

       
18
       
18
       
+
       
    x2apic,

     

       
19
       
19
       
+
       


     

       
20
       
20
       
+
       
    const Self = @This();

     

       
21
       
21
       
+
       


     

       
22
       
22
       
+
       
    // ID Register

     

       
23
       
23
       
+
       


     

       
24
       
24
       
+
       
    pub const IdRegister = packed struct(u32) {

     

       
25
       
25
       
+
       
        _reserved0: u24 = 0,

     

       
26
       
26
       
+
       
        id: u8,

     

       
27
       
27
       
+
       
    };

     

       
28
       
28
       
+
       


     

       
29
       
29
       
+
       
    pub fn getIdRegister(lapic: Self) IdRegister {

     

       
30
       
30
       
+
       
        return @bitCast(lapic.getRegister(.lapic_id));

     

       
31
       
31
       
+
       
    }

     

       
32
       
32
       
+
       


     

       
33
       
33
       
+
       
    // Version Register

     

       
34
       
34
       
+
       
    pub const VersionRegister = packed struct(u32) {

     

       
35
       
35
       
+
       
        version: u8,

     

       
36
       
36
       
+
       
        _reserved0: u8 = 0,

     

       
37
       
37
       
+
       
        max_lvt_entry: u8,

     

       
38
       
38
       
+
       
        support_for_eoi_broadcast_suppression: bool,

     

       
39
       
39
       
+
       
        _reserved1: u7 = 0,

     

       
40
       
40
       
+
       
    };

     

       
41
       
41
       
+
       


     

       
42
       
42
       
+
       
    pub fn getVersionRegister(lapic: Self) VersionRegister {

     

       
43
       
43
       
+
       
        return @bitCast(lapic.getRegister(.version));

     

       
44
       
44
       
+
       
    }

     

       
45
       
45
       
+
       


     

       
46
       
46
       
+
       
    // Spurious Interrupt

     

       
47
       
47
       
+
       
    pub const SpuriousInterruptRegister = packed struct(u32) {

     

       
48
       
48
       
+
       
        idt_entry: u8,

     

       
49
       
49
       
+
       
        apic_soft_enable: bool,

     

       
50
       
50
       
+
       
        focus_processor_checking: bool = false,

     

       
51
       
51
       
+
       
        _reserved0: u2 = 0,

     

       
52
       
52
       
+
       
        eoi_broadcast_suppression: bool = false,

     

       
53
       
53
       
+
       
        _reserved1: u19 = 0,

     

       
54
       
54
       
+
       
    };

     

       
55
       
55
       
+
       


     

       
56
       
56
       
+
       
    pub fn getSpuriousInterruptRegister(lapic: Self) SpuriousInterruptRegister {

     

       
57
       
57
       
+
       
        return @bitCast(lapic.getRegister(.spurious_vector));

     

       
58
       
58
       
+
       
    }

     

       
59
       
59
       
+
       


     

       
60
       
60
       
+
       
    pub fn setSpuriousInterruptRegister(lapic: Self, val: SpuriousInterruptRegister) void {

     

       
61
       
61
       
+
       
        lapic.setRegister(.spurious_vector, @bitCast(val));

     

       
62
       
62
       
+
       
    }

     

       
63
       
63
       
+
       


     

       
64
       
64
       
+
       
    // Task Priority

     

       
65
       
65
       
+
       
    pub const TaskPriorityRegister = packed struct(u32) {

     

       
66
       
66
       
+
       
        priority_sub_class: u4,

     

       
67
       
67
       
+
       
        priority_class: u4,

     

       
68
       
68
       
+
       
        _reserved0: u24 = 0,

     

       
69
       
69
       
+
       
    };

     

       
70
       
70
       
+
       


     

       
71
       
71
       
+
       
    pub fn getTaskPriorityRegister(lapic: Self) TaskPriorityRegister {

     

       
72
       
72
       
+
       
        return @bitCast(lapic.getRegister(.task_priority));

     

       
73
       
73
       
+
       
    }

     

       
74
       
74
       
+
       


     

       
75
       
75
       
+
       
    pub fn setTaskPriorityRegister(lapic: Self, val: TaskPriorityRegister) void {

     

       
76
       
76
       
+
       
        lapic.setRegister(.task_priority, @bitCast(val));

     

       
77
       
77
       
+
       
    }

     

       
78
       
78
       
+
       


     

       
79
       
79
       
+
       
    // Initial Count

     

       
80
       
80
       
+
       
    pub fn setInitialCountRegister(lapic: Self, count: u32) void {

     

       
81
       
81
       
+
       
        lapic.setRegister(.initial_count, count);

     

       
82
       
82
       
+
       
    }

     

       
83
       
83
       
+
       


     

       
84
       
84
       
+
       
    // Current Count

     

       
85
       
85
       
+
       
    pub fn getCurrentCountRegister(lapic: Self) u32 {

     

       
86
       
86
       
+
       
        return lapic.getRegister(.current_count);

     

       
87
       
87
       
+
       
    }

     

       
88
       
88
       
+
       


     

       
89
       
89
       
+
       
    // Divide Configuration

     

       
90
       
90
       
+
       
    pub const DivideConfigurationRegister = enum(u32) {

     

       
91
       
91
       
+
       
        div2 = 0,

     

       
92
       
92
       
+
       
        div4 = 1,

     

       
93
       
93
       
+
       
        div8 = 2,

     

       
94
       
94
       
+
       
        div16 = 3,

     

       
95
       
95
       
+
       
        div32 = 8,

     

       
96
       
96
       
+
       
        div64 = 9,

     

       
97
       
97
       
+
       
        div128 = 10,

     

       
98
       
98
       
+
       
        div1 = 11,

     

       
99
       
99
       
+
       
    };

     

       
100
       
100
       
+
       


     

       
101
       
101
       
+
       
    pub fn getDivideConfigurationRegister(lapic: LAPIC) DivideConfigurationRegister {

     

       
102
       
102
       
+
       
        return @enumFromInt(lapic.getRegister(.divide_configuration));

     

       
103
       
103
       
+
       
    }

     

       
104
       
104
       
+
       


     

       
105
       
105
       
+
       
    pub fn setDivideConfigurationRegister(lapic: LAPIC, register: DivideConfigurationRegister) void {

     

       
106
       
106
       
+
       
        lapic.setRegister(.divide_configuration, @intFromEnum(register));

     

       
107
       
107
       
+
       
    }

     

       
108
       
108
       
+
       


     

       
109
       
109
       
+
       
    // LVT Timer Register

     

       
110
       
110
       
+
       
    pub const LVTTimerRegister = packed struct(u32) {

     

       
111
       
111
       
+
       
        idt_entry: u8,

     

       
112
       
112
       
+
       
        _reserved0: u4 = 0,

     

       
113
       
113
       
+
       
        status: DeliveryStatus = .idle,

     

       
114
       
114
       
+
       
        _reserved1: u3 = 0,

     

       
115
       
115
       
+
       
        masked: bool,

     

       
116
       
116
       
+
       
        mode: Mode,

     

       
117
       
117
       
+
       
        _reserved2: u13 = 0,

     

       
118
       
118
       
+
       


     

       
119
       
119
       
+
       
        pub const DeliveryStatus = enum(u1) {

     

       
120
       
120
       
+
       
            idle = 0,

     

       
121
       
121
       
+
       
            send_pending = 1,

     

       
122
       
122
       
+
       
        };

     

       
123
       
123
       
+
       


     

       
124
       
124
       
+
       
        pub const Mode = enum(u2) {

     

       
125
       
125
       
+
       
            oneshot = 0,

     

       
126
       
126
       
+
       
            periodic = 1,

     

       
127
       
127
       
+
       
            tsc_deadline = 2,

     

       
128
       
128
       
+
       
        };

     

       
129
       
129
       
+
       
    };

     

       
130
       
130
       
+
       


     

       
131
       
131
       
+
       
    pub fn getLVTTimerRegister(lapic: LAPIC) LVTTimerRegister {

     

       
132
       
132
       
+
       
        return @enumFromInt(lapic.getRegister(.lvt_timer));

     

       
133
       
133
       
+
       
    }

     

       
134
       
134
       
+
       


     

       
135
       
135
       
+
       
    pub fn setLVTTimerRegister(lapic: LAPIC, register: LVTTimerRegister) void {

     

       
136
       
136
       
+
       
        lapic.setRegister(.lvt_timer, @bitCast(register));

     

       
137
       
137
       
+
       
    }

     

       
138
       
138
       
+
       


     

       
139
       
139
       
+
       
    pub fn getRegister(lapic: Self, reg: Register) u32 {

     

       
140
       
140
       
+
       
        switch (lapic) {

     

       
141
       
141
       
+
       
            .xapic => |base| {

     

       
142
       
142
       
+
       
                const ptr: *align(0x10) volatile u32 = @ptrCast(@alignCast(base + reg.xapic()));

     

       
143
       
143
       
+
       
                return ptr.*;

     

       
144
       
144
       
+
       
            },

     

       
145
       
145
       
+
       
            .x2apic => {

     

       
146
       
146
       
+
       
                return arch.registers.readMSR(u32, reg.x2apic());

     

       
147
       
147
       
+
       
            },

     

       
148
       
148
       
+
       
        }

     

       
149
       
149
       
+
       
    }

     

       
150
       
150
       
+
       


     

       
151
       
151
       
+
       
    pub fn setRegister(lapic: Self, reg: Register, value: u32) void {

     

       
152
       
152
       
+
       
        switch (lapic) {

     

       
153
       
153
       
+
       
            .xapic => |base| {

     

       
154
       
154
       
+
       
                const ptr: *align(0x10) volatile u32 = @ptrCast(@alignCast(base + reg.xapic()));

     

       
155
       
155
       
+
       
                ptr.* = value;

     

       
156
       
156
       
+
       
            },

     

       
157
       
157
       
+
       
            .x2apic => {

     

       
158
       
158
       
+
       
                arch.registers.writeMSR(u32, reg.x2apic(), value);

     

       
159
       
159
       
+
       
            },

     

       
160
       
160
       
+
       
        }

     

       
161
       
161
       
+
       
    }

     

       
162
       
162
       
+
       


     

       
163
       
163
       
+
       
    pub const Register = enum(u32) {

     

       
164
       
164
       
+
       
        // From Intel® 64 and IA-32 Architectures Software Developer’s Manual Volume 3

     

       
165
       
165
       
+
       
        lapic_id = 0x2,

     

       
166
       
166
       
+
       
        version = 0x3,

     

       
167
       
167
       
+
       
        task_priority = 0x8,

     

       
168
       
168
       
+
       
        process_priority = 0xa,

     

       
169
       
169
       
+
       
        eoi = 0xb,

     

       
170
       
170
       
+
       
        logical_destination = 0xd,

     

       
171
       
171
       
+
       
        spurious_vector = 0xf,

     

       
172
       
172
       
+
       


     

       
173
       
173
       
+
       
        in_service_0_31 = 0x10,

     

       
174
       
174
       
+
       
        in_service_63_32 = 0x11,

     

       
175
       
175
       
+
       
        in_service_95_64 = 0x12,

     

       
176
       
176
       
+
       
        in_service_127_96 = 0x13,

     

       
177
       
177
       
+
       
        in_service_159_128 = 0x14,

     

       
178
       
178
       
+
       
        in_service_191_160 = 0x15,

     

       
179
       
179
       
+
       
        in_service_223_192 = 0x16,

     

       
180
       
180
       
+
       
        in_service_255_224 = 0x17,

     

       
181
       
181
       
+
       


     

       
182
       
182
       
+
       
        trigger_mode_0_31 = 0x18,

     

       
183
       
183
       
+
       
        trigger_mode_63_32 = 0x19,

     

       
184
       
184
       
+
       
        trigger_mode_95_64 = 0x1a,

     

       
185
       
185
       
+
       
        trigger_mode_127_96 = 0x1b,

     

       
186
       
186
       
+
       
        trigger_mode_159_128 = 0x1c,

     

       
187
       
187
       
+
       
        trigger_mode_191_160 = 0x1d,

     

       
188
       
188
       
+
       
        trigger_mode_223_192 = 0x1e,

     

       
189
       
189
       
+
       
        trigger_mode_255_224 = 0x1f,

     

       
190
       
190
       
+
       


     

       
191
       
191
       
+
       
        interrupt_request_0_31 = 0x20,

     

       
192
       
192
       
+
       
        interrupt_request_63_32 = 0x21,

     

       
193
       
193
       
+
       
        interrupt_request_95_64 = 0x22,

     

       
194
       
194
       
+
       
        interrupt_request_127_96 = 0x23,

     

       
195
       
195
       
+
       
        interrupt_request_159_128 = 0x24,

     

       
196
       
196
       
+
       
        interrupt_request_191_160 = 0x25,

     

       
197
       
197
       
+
       
        interrupt_request_223_192 = 0x26,

     

       
198
       
198
       
+
       
        interrupt_request_255_224 = 0x27,

     

       
199
       
199
       
+
       


     

       
200
       
200
       
+
       
        error_status = 0x28,

     

       
201
       
201
       
+
       
        lvt_cmi = 0x2f,

     

       
202
       
202
       
+
       


     

       
203
       
203
       
+
       
        interrupt_command_0_31 = 0x30,

     

       
204
       
204
       
+
       
        interrupt_command_32_63 = 0x31,

     

       
205
       
205
       
+
       
        lvt_timer = 0x32,

     

       
206
       
206
       
+
       
        lvt_thermal_sensor = 0x33,

     

       
207
       
207
       
+
       
        lvt_performance_monitoring = 0x34,

     

       
208
       
208
       
+
       
        lvt_lint0 = 0x35,

     

       
209
       
209
       
+
       
        lvt_lint1 = 0x36,

     

       
210
       
210
       
+
       
        lvt_error = 0x37,

     

       
211
       
211
       
+
       
        initial_count = 0x38,

     

       
212
       
212
       
+
       
        current_count = 0x39,

     

       
213
       
213
       
+
       
        divide_configuration = 0x3e,

     

       
214
       
214
       
+
       
        self_ipi = 0x3f,

     

       
215
       
215
       
+
       


     

       
216
       
216
       
+
       
        const Self = @This();

     

       
217
       
217
       
+
       


     

       
218
       
218
       
+
       
        // Get an offset to apply to the xAPIC base

     

       
219
       
219
       
+
       
        pub fn xapic(reg: Register) usize {

     

       
220
       
220
       
+
       
            return @intFromEnum(reg) * 0x10;

     

       
221
       
221
       
+
       
        }

     

       
222
       
222
       
+
       


     

       
223
       
223
       
+
       
        // Get an MSR number to write to

     

       
224
       
224
       
+
       
        pub fn x2apic(reg: Register) u32 {

     

       
225
       
225
       
+
       
            return 0x800 | @intFromEnum(reg);

     

       
226
       
226
       
+
       
        }

     

       
227
       
227
       
+
       
    };

     

       
228
       
228
       
+
       
};

     

       
229
       
229
       
+
       


     

       
230
       
230
       
+
       
pub const init = struct {

     

       
231
       
231
       
+
       
    pub fn initialSetup() void {

     

       
232
       
232
       
+
       
        // First, make the APIC accessible

     

       
233
       
233
       
+
       
        initSingleton() catch |err| {

     

       
234
       
234
       
+
       
            log.err("Failed to map APIC! {}", .{err});

     

       
235
       
235
       
+
       
            @panic("initSingleton");

     

       
236
       
236
       
+
       
        };

     

       
237
       
237
       
+
       
        // Set up the interrupt handlers

     

       
238
       
238
       
+
       
        singleton.setSpuriousInterruptRegister(.{

     

       
239
       
239
       
+
       
            .apic_soft_enable = true,

     

       
240
       
240
       
+
       
            .idt_entry = 0xFF,

     

       
241
       
241
       
+
       
        });

     

       
242
       
242
       
+
       
        // lapic.setTaskPriorityRegister(.{

     

       
243
       
243
       
+
       
        //     .priority_class = 0,

     

       
244
       
244
       
+
       
        //     .priority_sub_class = 0,

     

       
245
       
245
       
+
       
        // });

     

       
246
       
246
       
+
       
        arch.interrupts.idt.add_handler(.{ .interrupt = 0xFF }, u64, spurious_interrupt_handler, 0, 0);

     

       
247
       
247
       
+
       
        arch.interrupts.idt.add_handler(.{ .interrupt = 48 }, u64, timer_handler, 0, 0);

     

       
248
       
248
       
+
       


     

       
249
       
249
       
+
       
        // Calibrate against the TSC

     

       
250
       
250
       
+
       
        calibrateTimer();

     

       
251
       
251
       
+
       
        // Set up the LVT Timer Register

     

       
252
       
252
       
+
       
        enableOneshotInterrupt();

     

       
253
       
253
       
+
       
    }

     

       
254
       
254
       
+
       


     

       
255
       
255
       
+
       
    fn initSingleton() !void {

     

       
256
       
256
       
+
       
        arch.interrupts.apic.singleton = switch (has_x2apic) {

     

       
257
       
257
       
+
       
            true => .x2apic,

     

       
258
       
258
       
+
       
            false => blk: {

     

       
259
       
259
       
+
       
                // Map the APIC first!

     

       
260
       
260
       
+
       
                const apic_base = common.mm.physToHHDM([*]volatile u8, 0xFEE0_0000);

     

       
261
       
261
       
+
       
                try common.mm.paging.mapPhys(.{

     

       
262
       
262
       
+
       
                    .vaddr = @intFromPtr(apic_base),

     

       
263
       
263
       
+
       
                    .paddr = 0xFEE0_0000,

     

       
264
       
264
       
+
       
                    .size = 0x1000,

     

       
265
       
265
       
+
       
                    .memory_type = .DeviceUncacheable,

     

       
266
       
266
       
+
       
                    .perms = .{

     

       
267
       
267
       
+
       
                        .x = false,

     

       
268
       
268
       
+
       
                        .u = false,

     

       
269
       
269
       
+
       
                        .w = true,

     

       
270
       
270
       
+
       
                    },

     

       
271
       
271
       
+
       
                });

     

       
272
       
272
       
+
       
                break :blk .{ .xapic = apic_base };

     

       
273
       
273
       
+
       
            },

     

       
274
       
274
       
+
       
        };

     

       
275
       
275
       
+
       
    }

     

       
276
       
276
       
+
       


     

       
277
       
277
       
+
       
    fn calibrateTimer() void {

     

       
278
       
278
       
+
       
        singleton.setDivideConfigurationRegister(.div2);

     

       
279
       
279
       
+
       
        singleton.setLVTTimerRegister(.{

     

       
280
       
280
       
+
       
            .idt_entry = 0x69,

     

       
281
       
281
       
+
       
            .mode = .oneshot,

     

       
282
       
282
       
+
       
            .masked = true,

     

       
283
       
283
       
+
       
        });

     

       
284
       
284
       
+
       


     

       
285
       
285
       
+
       
        var warmup_clk_count: u64 = 0;

     

       
286
       
286
       
+
       
        for (0..5) |_| {

     

       
287
       
287
       
+
       
            singleton.setInitialCountRegister(0xFFFF_FFFF);

     

       
288
       
288
       
+
       
            arch.tsc.delay_poll(1);

     

       
289
       
289
       
+
       
            const count = singleton.getCurrentCountRegister();

     

       
290
       
290
       
+
       
            singleton.setInitialCountRegister(0);

     

       
291
       
291
       
+
       


     

       
292
       
292
       
+
       
            warmup_clk_count += 0xFFFF_FFFF - count;

     

       
293
       
293
       
+
       
        }

     

       
294
       
294
       
+
       


     

       
295
       
295
       
+
       
        std.mem.doNotOptimizeAway(&warmup_clk_count);

     

       
296
       
296
       
+
       


     

       
297
       
297
       
+
       
        // Now, do it again

     

       
298
       
298
       
+
       
        var tick_count: u64 = 0;

     

       
299
       
299
       
+
       
        for (0..5) |_| {

     

       
300
       
300
       
+
       
            singleton.setInitialCountRegister(0xFFFF_FFFF);

     

       
301
       
301
       
+
       
            arch.tsc.delay_poll(5);

     

       
302
       
302
       
+
       
            const count = singleton.getCurrentCountRegister();

     

       
303
       
303
       
+
       
            singleton.setInitialCountRegister(0);

     

       
304
       
304
       
+
       


     

       
305
       
305
       
+
       
            tick_count += 0xFFFF_FFFF - count;

     

       
306
       
306
       
+
       
        }

     

       
307
       
307
       
+
       


     

       
308
       
308
       
+
       
        // This would be the number of ticks per 5ms interval

     

       
309
       
309
       
+
       
        const norm = tick_count / 5;

     

       
310
       
310
       
+
       


     

       
311
       
311
       
+
       
        lapic_timer_khz = norm / 5;

     

       
312
       
312
       
+
       


     

       
313
       
313
       
+
       
        log.debug("timer: {} kHz", .{lapic_timer_khz});

     

       
314
       
314
       
+
       
    }

     

       
315
       
315
       
+
       


     

       
316
       
316
       
+
       
    fn enableOneshotInterrupt() void {

     

       
317
       
317
       
+
       
        const mode: LAPIC.LVTTimerRegister.Mode = switch (tsc_deadline_available) {

     

       
318
       
318
       
+
       
            true => .tsc_deadline,

     

       
319
       
319
       
+
       
            false => blk: {

     

       
320
       
320
       
+
       
                singleton.setInitialCountRegister(0);

     

       
321
       
321
       
+
       
                singleton.setDivideConfigurationRegister(.div2);

     

       
322
       
322
       
+
       
                break :blk .oneshot;

     

       
323
       
323
       
+
       
            },

     

       
324
       
324
       
+
       
        };

     

       
325
       
325
       
+
       


     

       
326
       
326
       
+
       
        // TODO: detect and support tsc_deadline, ditto @ armTimer

     

       
327
       
327
       
+
       
        singleton.setLVTTimerRegister(.{

     

       
328
       
328
       
+
       
            .idt_entry = 48,

     

       
329
       
329
       
+
       
            .mode = mode,

     

       
330
       
330
       
+
       
            .masked = false,

     

       
331
       
331
       
+
       
        });

     

       
332
       
332
       
+
       
    }

     

       
333
       
333
       
+
       
};

     

       
334
       
334
       
+
       


     

       
335
       
335
       
+
       
pub fn armTimer(ms: usize) void {

     

       
336
       
336
       
+
       
    if (tsc_deadline_available) {

     

       
337
       
337
       
+
       
        const IA32_TSC_DEADLINE = arch.registers.MSR(u64, 0x6E0);

     

       
338
       
338
       
+
       
        const delta = arch.tsc.tsc_khz * ms;

     

       
339
       
339
       
+
       
        const target = arch.tsc.rdtsc() + delta;

     

       
340
       
340
       
+
       


     

       
341
       
341
       
+
       
        IA32_TSC_DEADLINE.write(target);

     

       
342
       
342
       
+
       
    } else {

     

       
343
       
343
       
+
       
        const ticks: u32 = @truncate(lapic_timer_khz * ms);

     

       
344
       
344
       
+
       
        singleton.setInitialCountRegister(ticks);

     

       
345
       
345
       
+
       
    }

     

       
346
       
346
       
+
       
}

     

       
347
       
347
       
+
       


     

       
348
       
348
       
+
       
pub fn spurious_interrupt_handler(_: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       
349
       
349
       
+
       
    log.warn("Got a spurious interrupt!", .{});

     

       
350
       
350
       
+
       
}

     

       
351
       
351
       
+
       


     

       
352
       
352
       
+
       
pub fn timer_handler(stack_trace: *idt.InterruptFrame(u64)) callconv(idt.CallConv) void {

     

       
353
       
353
       
+
       
    defer {

     

       
354
       
354
       
+
       
        singleton.setRegister(.eoi, 0);

     

       
355
       
355
       
+
       
        armTimer(20);

     

       
356
       
356
       
+
       
    }

     

       
357
       
357
       
+
       
    // 1. Get the next task. If there is no next task, just keep scheduling.

     

       
358
       
358
       
+
       
    const task = common.scheduler.getNextTask() orelse return;

     

       
359
       
359
       
+
       
    // 2. Swap the next task state with the current interrupt trace

     

       
360
       
360
       
+
       
    std.mem.swap(arch.interrupts.idt.SavedRegisters, &task.regs, &stack_trace.regs);

     

       
361
       
361
       
+
       
    std.mem.swap(u64, &task.rip, &stack_trace.rip);

     

       
362
       
362
       
+
       
    std.mem.swap(u64, &task.rsp, &stack_trace.rsp);

     

       
363
       
363
       
+
       
    // If task has a new cr3, swap current CR3 and task cr3 too

     

       
364
       
364
       
+
       
    if (task.cr3_val != stack_trace.cr3) {

     

       
365
       
365
       
+
       
        arch.registers.ControlRegisters.Cr3.write(task.cr3_val);

     

       
366
       
366
       
+
       
        task.cr3_val = stack_trace.cr3;

     

       
367
       
367
       
+
       
    }

     

       
368
       
368
       
+
       
    // 3. Now, `task` has our current state, so enqueue it.

     

       
369
       
369
       
+
       
    common.scheduler.pushTask(task);

     

       
370
       
370
       
+
       
}

     

···

       
1
       
1
       
+
       
const arch = @import("../root.zig");

     

       
2
       
2
       
+
       
const std = @import("std");

     

       
3
       
3
       
+
       
const interrupts = arch.interrupts;

     

       
4
       
4
       
+
       
const StandardGdt = arch.structures.gdt.StandardGdt;

     

       
5
       
5
       
+
       


     

       
6
       
6
       
+
       
// The actual IDT memory

     

       
7
       
7
       
+
       
const entry_count = 256;

     

       
8
       
8
       
+
       
export var interrupt_descriptor_table: [entry_count]Entry = undefined;

     

       
9
       
9
       
+
       


     

       
10
       
10
       
+
       
// Pointers to the actual ISRs which the global interrupt handler call

     

       
11
       
11
       
+
       
// Each IDT entry pushes the interrupt number then calls the global

     

       
12
       
12
       
+
       
// handler, which pushes more information then calls the user

     

       
13
       
13
       
+
       
// defined handler. Use common sense and don't return from an exception

     

       
14
       
14
       
+
       
// which shouldn't be returned from.

     

       
15
       
15
       
+
       
pub const CallConv: std.builtin.CallingConvention = .{ .x86_64_sysv = .{} };

     

       
16
       
16
       
+
       
pub fn InterruptHandler(comptime E: type) type {

     

       
17
       
17
       
+
       
    return *const fn (*InterruptFrame(E)) callconv(CallConv) void;

     

       
18
       
18
       
+
       
}

     

       
19
       
19
       
+
       
pub export var defined_handlers: [entry_count]InterruptHandler(u64) = undefined;

     

       
20
       
20
       
+
       


     

       
21
       
21
       
+
       
// The actual handlers with addresses in the IDT.

     

       
22
       
22
       
+
       
const ActualHandler = *const fn () callconv(.naked) void;

     

       
23
       
23
       
+
       
const actual_handlers: [entry_count]ActualHandler = blk: {

     

       
24
       
24
       
+
       
    @setEvalBranchQuota(100000000);

     

       
25
       
25
       
+
       
    var ret: [entry_count]ActualHandler = undefined;

     

       
26
       
26
       
+
       
    for (0..256) |i| {

     

       
27
       
27
       
+
       
        ret[i] = make_actual_handler(.{ .interrupt = i });

     

       
28
       
28
       
+
       
    }

     

       
29
       
29
       
+
       
    break :blk ret;

     

       
30
       
30
       
+
       
};

     

       
31
       
31
       
+
       


     

       
32
       
32
       
+
       
fn make_actual_handler(comptime interrupt: Interrupt) ActualHandler {

     

       
33
       
33
       
+
       
    var asm_code: []const u8 = "";

     

       
34
       
34
       
+
       
    // Make the stack consistent

     

       
35
       
35
       
+
       
    if (!interrupt.has_error_code()) {

     

       
36
       
36
       
+
       
        asm_code = asm_code ++ "pushq $0\n";

     

       
37
       
37
       
+
       
    }

     

       
38
       
38
       
+
       
    // Push the interrupt number

     

       
39
       
39
       
+
       
    asm_code = asm_code ++ std.fmt.comptimePrint("pushq ${}\n", .{interrupt.interrupt});

     

       
40
       
40
       
+
       
    // Jump to the common interrupt handler code

     

       
41
       
41
       
+
       
    asm_code = asm_code ++ "jmp _int_handler_common";

     

       
42
       
42
       
+
       
    const code = asm_code;

     

       
43
       
43
       
+
       


     

       
44
       
44
       
+
       
    const tmp_struct = struct {

     

       
45
       
45
       
+
       
        fn actual_handler() callconv(.naked) void {

     

       
46
       
46
       
+
       
            asm volatile (code);

     

       
47
       
47
       
+
       
        }

     

       
48
       
48
       
+
       
    };

     

       
49
       
49
       
+
       
    return tmp_struct.actual_handler;

     

       
50
       
50
       
+
       
}

     

       
51
       
51
       
+
       


     

       
52
       
52
       
+
       
// The global assembly for the common interrupt handler

     

       
53
       
53
       
+
       
comptime {

     

       
54
       
54
       
+
       
    // Construct the push and pop instructions from SavedRegisters

     

       
55
       
55
       
+
       
    var push_instrs: []const u8 = "\n";

     

       
56
       
56
       
+
       
    var pop_instrs: []const u8 = "\n";

     

       
57
       
57
       
+
       


     

       
58
       
58
       
+
       
    const saved_regs = @typeInfo(SavedRegisters).@"struct".fields;

     

       
59
       
59
       
+
       
    for (saved_regs) |saved_reg| {

     

       
60
       
60
       
+
       
        // We must prepend to push because pushes are basically

     

       
61
       
61
       
+
       
        // building the struct in reverse order, so reverse the effects

     

       
62
       
62
       
+
       
        push_instrs = "\n pushq %" ++ saved_reg.name ++ push_instrs;

     

       
63
       
63
       
+
       
        // Of course, pop in the opposite order as push

     

       
64
       
64
       
+
       
        pop_instrs = pop_instrs ++ "popq %" ++ saved_reg.name ++ "\n";

     

       
65
       
65
       
+
       
    }

     

       
66
       
66
       
+
       


     

       
67
       
67
       
+
       
    asm (

     

       
68
       
68
       
+
       
        \\ .global _int_handler_common

     

       
69
       
69
       
+
       
        \\ .type _int_handler_common, @function

     

       
70
       
70
       
+
       
        \\ _int_handler_common:

     

       
71
       
71
       
+
       


     

       
72
       
72
       
+
       
        // Push the general purpose registers and then CR3

     

       
73
       
73
       
+
       
    ++ push_instrs ++

     

       
74
       
74
       
+
       
        \\     mov %cr3, %rax

     

       
75
       
75
       
+
       
        \\     pushq %rax

     

       
76
       
76
       
+
       


     

       
77
       
77
       
+
       
        // Now, rsp points to the start of InterruptFrame. Read int_num and call into an offset of

     

       
78
       
78
       
+
       
        // the defined handlers list after setting the first arg to the created structure.

     

       
79
       
79
       
+
       
    ++ std.fmt.comptimePrint("\nmov {}(%rsp), %rcx\n", .{@offsetOf(InterruptFrame(u64), "int_num")}) ++

     

       
80
       
80
       
+
       
        \\     mov      %rsp, %rdi

     

       
81
       
81
       
+
       
        \\     callq    *defined_handlers(, %rcx, 8)

     

       
82
       
82
       
+
       


     

       
83
       
83
       
+
       
        // Skip the stack all the way down to the general purpose

     

       
84
       
84
       
+
       
        // registers, then pop all of them

     

       
85
       
85
       
+
       
        // TODO: restore CR3??

     

       
86
       
86
       
+
       
    ++ std.fmt.comptimePrint("\nadd ${}, %rsp\n", .{@offsetOf(InterruptFrame(u64), "regs")}) ++ pop_instrs ++

     

       
87
       
87
       
+
       
        // Skip the interrupt number and error code and iretq

     

       
88
       
88
       
+
       
        \\     add $16, %rsp

     

       
89
       
89
       
+
       
        \\     iretq

     

       
90
       
90
       
+
       
    );

     

       
91
       
91
       
+
       
}

     

       
92
       
92
       
+
       


     

       
93
       
93
       
+
       
/// IDT Register

     

       
94
       
94
       
+
       
const Idtr = packed struct(u80) {

     

       
95
       
95
       
+
       
    limit: u16,

     

       
96
       
96
       
+
       
    addr: u64,

     

       
97
       
97
       
+
       


     

       
98
       
98
       
+
       
    /// Load the IDT Register

     

       
99
       
99
       
+
       
    pub fn load(self: *const Idtr) void {

     

       
100
       
100
       
+
       
        asm volatile ("lidt (%[idtr_addr])"

     

       
101
       
101
       
+
       
            :

     

       
102
       
102
       
+
       
            : [idtr_addr] "r" (self),

     

       
103
       
103
       
+
       
        );

     

       
104
       
104
       
+
       
    }

     

       
105
       
105
       
+
       
};

     

       
106
       
106
       
+
       


     

       
107
       
107
       
+
       
// A raw IDT entry

     

       
108
       
108
       
+
       
const Entry = extern struct {

     

       
109
       
109
       
+
       
    func_low: u16,

     

       
110
       
110
       
+
       
    gdt_selector: u16,

     

       
111
       
111
       
+
       
    options: Options,

     

       
112
       
112
       
+
       
    func_mid: u16,

     

       
113
       
113
       
+
       
    func_high: u32,

     

       
114
       
114
       
+
       
    _reserved0: u32 = 0,

     

       
115
       
115
       
+
       


     

       
116
       
116
       
+
       
    pub const Options = packed struct(u16) {

     

       
117
       
117
       
+
       
        ist_index: u3,

     

       
118
       
118
       
+
       
        _reserved0: u5 = 0,

     

       
119
       
119
       
+
       
        disable_interrupts: bool = true,

     

       
120
       
120
       
+
       
        // type: Type,

     

       
121
       
121
       
+
       
        must_be_one: u3 = 0b111,

     

       
122
       
122
       
+
       
        must_be_zero: u1 = 0,

     

       
123
       
123
       
+
       
        dpl: u2,

     

       
124
       
124
       
+
       
        present: bool,

     

       
125
       
125
       
+
       
    };

     

       
126
       
126
       
+
       


     

       
127
       
127
       
+
       
    pub const Owner = enum {

     

       
128
       
128
       
+
       
        kernel,

     

       
129
       
129
       
+
       
        user,

     

       
130
       
130
       
+
       
    };

     

       
131
       
131
       
+
       


     

       
132
       
132
       
+
       
    const Self = @This();

     

       
133
       
133
       
+
       
    pub fn init(func_ptr: usize, dpl: u2, ist: u3) Entry {

     

       
134
       
134
       
+
       
        // _ = typ;

     

       
135
       
135
       
+
       
        return .{

     

       
136
       
136
       
+
       
            .func_low = @truncate(func_ptr),

     

       
137
       
137
       
+
       
            .gdt_selector = StandardGdt.selectors.kernel_code,

     

       
138
       
138
       
+
       
            .options = .{

     

       
139
       
139
       
+
       
                .ist_index = ist,

     

       
140
       
140
       
+
       
                .dpl = dpl,

     

       
141
       
141
       
+
       
                .present = true,

     

       
142
       
142
       
+
       
            },

     

       
143
       
143
       
+
       
            .func_mid = @truncate(func_ptr >> 16),

     

       
144
       
144
       
+
       
            .func_high = @truncate(func_ptr >> 32),

     

       
145
       
145
       
+
       
        };

     

       
146
       
146
       
+
       
    }

     

       
147
       
147
       
+
       


     

       
148
       
148
       
+
       
    // Changes the address without changing anything else

     

       
149
       
149
       
+
       
    pub fn set_func(self: *Self, ptr: usize) void {

     

       
150
       
150
       
+
       
        self.func_low = @truncate(ptr);

     

       
151
       
151
       
+
       
        self.func_mid = @truncate(ptr >> 16);

     

       
152
       
152
       
+
       
        self.func_high = @truncate(ptr >> 32);

     

       
153
       
153
       
+
       
    }

     

       
154
       
154
       
+
       
};

     

       
155
       
155
       
+
       


     

       
156
       
156
       
+
       
/// A selector error code indexing into the GDT, IDT, or LDT.

     

       
157
       
157
       
+
       
/// Used in a general protection fault for example.

     

       
158
       
158
       
+
       
pub const SelectorErrorCode = packed struct(u64) {

     

       
159
       
159
       
+
       
    external: bool,

     

       
160
       
160
       
+
       
    interrupt: bool,

     

       
161
       
161
       
+
       
    // Only valid if not interrupt

     

       
162
       
162
       
+
       
    type: enum(u1) {

     

       
163
       
163
       
+
       
        gdt = 0,

     

       
164
       
164
       
+
       
        ldt = 1,

     

       
165
       
165
       
+
       
    },

     

       
166
       
166
       
+
       
    idx: u13,

     

       
167
       
167
       
+
       
    _reserved0: u48 = 0,

     

       
168
       
168
       
+
       


     

       
169
       
169
       
+
       
    pub const Target = union(enum) {

     

       
170
       
170
       
+
       
        interrupt: Interrupt,

     

       
171
       
171
       
+
       
        gdt_sel: u16,

     

       
172
       
172
       
+
       
        ldt_sel: u13,

     

       
173
       
173
       
+
       
    };

     

       
174
       
174
       
+
       


     

       
175
       
175
       
+
       
    const Self = @This();

     

       
176
       
176
       
+
       
    pub fn parse(self: Self) Target {

     

       
177
       
177
       
+
       
        return switch (self.interrupt) {

     

       
178
       
178
       
+
       
            true => .{ .interrupt = .{ .interrupt = @truncate(self.idx) } },

     

       
179
       
179
       
+
       
            false => switch (self.type) {

     

       
180
       
180
       
+
       
                .gdt => .{ .gdt_sel = self.idx },

     

       
181
       
181
       
+
       
                .ldt => .{ .ldt_sel = self.idx },

     

       
182
       
182
       
+
       
            },

     

       
183
       
183
       
+
       
        };

     

       
184
       
184
       
+
       
    }

     

       
185
       
185
       
+
       
};

     

       
186
       
186
       
+
       


     

       
187
       
187
       
+
       
/// List of the general built in exceptions

     

       
188
       
188
       
+
       
pub const Exception = enum(u8) {

     

       
189
       
189
       
+
       
    divide_error = 0x00,

     

       
190
       
190
       
+
       
    debug_exeption = 0x01,

     

       
191
       
191
       
+
       
    non_maskable_interrupt = 0x02,

     

       
192
       
192
       
+
       
    breakpoint = 0x03,

     

       
193
       
193
       
+
       
    overflow = 0x04,

     

       
194
       
194
       
+
       
    bound_range_exceeded = 0x05,

     

       
195
       
195
       
+
       
    invalid_opcode = 0x06,

     

       
196
       
196
       
+
       
    device_not_available = 0x07,

     

       
197
       
197
       
+
       
    double_fault = 0x08,

     

       
198
       
198
       
+
       
    // _coprocessor_segment_overrun = 0x09,

     

       
199
       
199
       
+
       
    invalid_tss = 0x0a,

     

       
200
       
200
       
+
       
    segment_not_present = 0x0b,

     

       
201
       
201
       
+
       
    stack_segment_fault = 0x0c,

     

       
202
       
202
       
+
       
    general_protection_fault = 0x0d,

     

       
203
       
203
       
+
       
    page_fault = 0x0e,

     

       
204
       
204
       
+
       
    // _reserved0 = 0x0f,

     

       
205
       
205
       
+
       
    x87_floating_point = 0x10,

     

       
206
       
206
       
+
       
    alignment_check = 0x11,

     

       
207
       
207
       
+
       
    machine_check = 0x12,

     

       
208
       
208
       
+
       
    simd_floating_point = 0x13,

     

       
209
       
209
       
+
       
    virtualization = 0x14,

     

       
210
       
210
       
+
       
    control_protection = 0x15,

     

       
211
       
211
       
+
       
    hypervisor = 0x1c,

     

       
212
       
212
       
+
       
    vmm = 0x1d,

     

       
213
       
213
       
+
       
    security_fault = 0x1e,

     

       
214
       
214
       
+
       
    _,

     

       
215
       
215
       
+
       


     

       
216
       
216
       
+
       
    fn has_error_code(self: Exception) bool {

     

       
217
       
217
       
+
       
        return switch (self) {

     

       
218
       
218
       
+
       
            .double_fault, .invalid_tss, .segment_not_present, .general_protection_fault, .page_fault, .security_fault => true,

     

       
219
       
219
       
+
       
            else => false,

     

       
220
       
220
       
+
       
        };

     

       
221
       
221
       
+
       
    }

     

       
222
       
222
       
+
       
};

     

       
223
       
223
       
+
       


     

       
224
       
224
       
+
       
pub const Interrupt = packed union {

     

       
225
       
225
       
+
       
    exception: Exception,

     

       
226
       
226
       
+
       
    interrupt: u8,

     

       
227
       
227
       
+
       


     

       
228
       
228
       
+
       
    pub fn has_error_code(self: Interrupt) bool {

     

       
229
       
229
       
+
       
        return self.exception.has_error_code();

     

       
230
       
230
       
+
       
    }

     

       
231
       
231
       
+
       
};

     

       
232
       
232
       
+
       


     

       
233
       
233
       
+
       
/// Basically all the general purpose registers except rsp,

     

       
234
       
234
       
+
       
/// because RSP is already in the InterruptFrame. Ordered

     

       
235
       
235
       
+
       
/// in the order of the X.Reg from the instruction encoding lol

     

       
236
       
236
       
+
       
pub const SavedRegisters = extern struct {

     

       
237
       
237
       
+
       
    rax: u64,

     

       
238
       
238
       
+
       
    rcx: u64,

     

       
239
       
239
       
+
       
    rdx: u64,

     

       
240
       
240
       
+
       
    rbx: u64,

     

       
241
       
241
       
+
       
    // rsp: u64,

     

       
242
       
242
       
+
       
    rbp: u64,

     

       
243
       
243
       
+
       
    rsi: u64,

     

       
244
       
244
       
+
       
    rdi: u64,

     

       
245
       
245
       
+
       
    r8: u64,

     

       
246
       
246
       
+
       
    r9: u64,

     

       
247
       
247
       
+
       
    r10: u64,

     

       
248
       
248
       
+
       
    r11: u64,

     

       
249
       
249
       
+
       
    r12: u64,

     

       
250
       
250
       
+
       
    r13: u64,

     

       
251
       
251
       
+
       
    r14: u64,

     

       
252
       
252
       
+
       
    r15: u64,

     

       
253
       
253
       
+
       


     

       
254
       
254
       
+
       
    pub const default = std.mem.zeroes(SavedRegisters);

     

       
255
       
255
       
+
       
};

     

       
256
       
256
       
+
       


     

       
257
       
257
       
+
       
/// The Interrupt frame which we help generate

     

       
258
       
258
       
+
       
pub fn InterruptFrame(comptime ErrorCode: type) type {

     

       
259
       
259
       
+
       
    if (@bitSizeOf(ErrorCode) != 64) {

     

       
260
       
260
       
+
       
        @compileError("ErrorCode for InterruptFrame must be exactly 64 bits!");

     

       
261
       
261
       
+
       
    }

     

       
262
       
262
       
+
       
    return extern struct {

     

       
263
       
263
       
+
       
        // CR3

     

       
264
       
264
       
+
       
        cr3: u64,

     

       
265
       
265
       
+
       
        // All the general purpose registers

     

       
266
       
266
       
+
       
        regs: SavedRegisters align(8),

     

       
267
       
267
       
+
       
        // The interrupt number

     

       
268
       
268
       
+
       
        int_num: Interrupt align(8),

     

       
269
       
269
       
+
       
        // Pushed by the CPU (error_code may be pushed by us)

     

       
270
       
270
       
+
       
        error_code: ErrorCode,

     

       
271
       
271
       
+
       
        rip: u64,

     

       
272
       
272
       
+
       
        cs: u16 align(8),

     

       
273
       
273
       
+
       
        eflags: u64,

     

       
274
       
274
       
+
       
        rsp: u64,

     

       
275
       
275
       
+
       
        ss: u16 align(8),

     

       
276
       
276
       
+
       


     

       
277
       
277
       
+
       
        pub fn normalize(self: *InterruptFrame(ErrorCode)) *InterruptFrame(u64) {

     

       
278
       
278
       
+
       
            return @ptrCast(self);

     

       
279
       
279
       
+
       
        }

     

       
280
       
280
       
+
       
    };

     

       
281
       
281
       
+
       
}

     

       
282
       
282
       
+
       


     

       
283
       
283
       
+
       
// Initialize the IDT with the default unhandled exception

     

       
284
       
284
       
+
       
pub fn init() void {

     

       
285
       
285
       
+
       
    // Set every IDT entry to the corresponding ActualHandler

     

       
286
       
286
       
+
       
    for (0..entry_count) |i| {

     

       
287
       
287
       
+
       
        const actual_handler = @intFromPtr(actual_handlers[i]);

     

       
288
       
288
       
+
       
        interrupt_descriptor_table[i] = Entry.init(actual_handler, 0, 0);

     

       
289
       
289
       
+
       
    }

     

       
290
       
290
       
+
       
    // Now, set every defined handler to the default one

     

       
291
       
291
       
+
       
    @memset(&defined_handlers, arch.interrupts.unhandled_interrupt);

     

       
292
       
292
       
+
       


     

       
293
       
293
       
+
       
    // Finally, load the idt

     

       
294
       
294
       
+
       
    load();

     

       
295
       
295
       
+
       
}

     

       
296
       
296
       
+
       


     

       
297
       
297
       
+
       
pub fn load() void {

     

       
298
       
298
       
+
       
    const idtr: Idtr = .{

     

       
299
       
299
       
+
       
        .addr = @intFromPtr(&interrupt_descriptor_table),

     

       
300
       
300
       
+
       
        .limit = 0xFFF,

     

       
301
       
301
       
+
       
    };

     

       
302
       
302
       
+
       
    idtr.load();

     

       
303
       
303
       
+
       
}

     

       
304
       
304
       
+
       


     

       
305
       
305
       
+
       
pub fn add_handler(interrupt: Interrupt, comptime E: type, handler: InterruptHandler(E), dpl: u2, ist: u3) void {

     

       
306
       
306
       
+
       
    // Modify the type, dpl, and ist in place

     

       
307
       
307
       
+
       
    var tmp = interrupt_descriptor_table[interrupt.interrupt];

     

       
308
       
308
       
+
       
    tmp.options.dpl = dpl;

     

       
309
       
309
       
+
       
    tmp.options.ist_index = ist;

     

       
310
       
310
       
+
       
    interrupt_descriptor_table[interrupt.interrupt] = tmp;

     

       
311
       
311
       
+
       


     

       
312
       
312
       
+
       
    // Add the InterruptHandler

     

       
313
       
313
       
+
       
    defined_handlers[interrupt.interrupt] = @ptrCast(handler);

     

       
314
       
314
       
+
       
}