···

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

     

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

     

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

     

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

     

       
6
       
 
       
const flanterm = @import("flanterm");

     

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

     

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

     
···

       
233
       
 
       
            break :blk .{ .xapic = apic_base };

     

       
234
       
 
       
        },

     

       
235
       
 
       
    };

     

       
236
       
-
       
    // Set up the spurious vector and the TPR

     

       
0
       
 
       

     

       
237
       
 
       
    arch.interrupts.apic.init.initialSetup();

     

       
238
       
-
       


     

       
239
       
-
       
    // Calibrate the APIC timer

     

       
240
       
-
       
    arch.interrupts.apic.init.calibrateTimer();

     

       
241
       
 
       


     

       
242
       
 
       
    // Enable one-shot interrupts

     

       
243
       
 
       
    arch.interrupts.apic.init.enableOneshotInterrupt();

     

···

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

     

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

     

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

     

       
0
       
 
       

     

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

     

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

     

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

     
···

       
232
       
 
       
            break :blk .{ .xapic = apic_base };

     

       
233
       
 
       
        },

     

       
234
       
 
       
    };

     

       
235
       
+
       
    // Set up the spurious vector, TPR, and

     

       
236
       
+
       
    // calibrate the timer

     

       
237
       
 
       
    arch.interrupts.apic.init.initialSetup();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
238
       
 
       


     

       
239
       
 
       
    // Enable one-shot interrupts

     

       
240
       
 
       
    arch.interrupts.apic.init.enableOneshotInterrupt();

     

···

       
24
       
 
       
}

     

       
25
       
 
       


     

       
26
       
 
       
const FeaturesEcx = packed struct(u32) {

     

       
27
       
-
       
    _reserved0: u23,

     

       
28
       
 
       
    tsc_deadline: bool,

     

       
29
       
-
       
    _reserved1: u8,

     

       
30
       
 
       
};

     

       
31
       
 
       


     

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

     

···

       
24
       
 
       
}

     

       
25
       
 
       


     

       
26
       
 
       
const FeaturesEcx = packed struct(u32) {

     

       
27
       
+
       
    _reserved0: u24,

     

       
28
       
 
       
    tsc_deadline: bool,

     

       
29
       
+
       
    _reserved1: u7,

     

       
30
       
 
       
};

     

       
31
       
 
       


     

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

     

···

       
237
       
 
       
        // });

     

       
238
       
 
       
        arch.interrupts.idt.add_handler(.{ .interrupt = 0xFF }, spurious_interrupt_handler, 3, 0);

     

       
239
       
 
       
        arch.interrupts.idt.add_handler(.{ .interrupt = 48 }, periodic_handler, 3, 0);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
240
       
 
       
    }

     

       
241
       
 
       


     

       
242
       
-
       
    pub fn calibrateTimer() void {

     

       
243
       
 
       
        singleton.setDivideConfigurationRegister(.div2);

     

       
244
       
 
       
        singleton.setLVTTimerRegister(.{

     

       
245
       
 
       
            .idt_entry = 0x69,

     

···

       
237
       
 
       
        // });

     

       
238
       
 
       
        arch.interrupts.idt.add_handler(.{ .interrupt = 0xFF }, spurious_interrupt_handler, 3, 0);

     

       
239
       
 
       
        arch.interrupts.idt.add_handler(.{ .interrupt = 48 }, periodic_handler, 3, 0);

     

       
240
       
+
       


     

       
241
       
+
       
        calibrateTimer();

     

       
242
       
 
       
    }

     

       
243
       
 
       


     

       
244
       
+
       
    fn calibrateTimer() void {

     

       
245
       
 
       
        singleton.setDivideConfigurationRegister(.div2);

     

       
246
       
 
       
        singleton.setLVTTimerRegister(.{

     

       
247
       
 
       
            .idt_entry = 0x69,

     

···

       
12
       
 
       
    asm volatile ("cli");

     

       
13
       
 
       
}

     

       
14
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
15
       
 
       
pub fn unhandled_interrupt(frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       
16
       
 
       
    if (std.enums.tagName(idt.Exception, frame.int_num.exception)) |exception_name| {

     

       
17
       
 
       
        std.log.err("Unhandled interrupt (0x{x} : {s})!!!", .{ frame.int_num.interrupt, exception_name });

     

       
18
       
 
       
    } else {

     

       
19
       
 
       
        std.log.err("Unhandled interrupt (0x{x})!!!", .{frame.int_num.interrupt});

     

       
20
       
 
       
    }

     

       
21
       
-
       
    std.log.err("CR3: 0x{x:0>16}", .{frame.cr3});

     

       
22
       
-
       
    std.log.err("RAX: 0x{x:0>16}, RBX: 0x{x:0>16}, RCX: 0x{x:0>16}, RDX: 0x{x:0>16}", .{ frame.regs.rax, frame.regs.rbx, frame.regs.rcx, frame.regs.rdx });

     

       
23
       
-
       
    std.log.err("RSI: 0x{x:0>16}, RDI: 0x{x:0>16}, RBP: 0x{x:0>16}, RSP: 0x{x:0>16}", .{ frame.regs.rsi, frame.regs.rdi, frame.regs.rbp, frame.rsp });

     

       
24
       
-
       
    std.log.err("R8:  0x{x:0>16}, R9:  0x{x:0>16}, R10: 0x{x:0>16}, R11: 0x{x:0>16}", .{ frame.regs.r8, frame.regs.r9, frame.regs.r10, frame.regs.r11 });

     

       
25
       
-
       
    std.log.err("R12: 0x{x:0>16}, R13: 0x{x:0>16}, R14: 0x{x:0>16}, R15: 0x{x:0>16}", .{ frame.regs.r12, frame.regs.r13, frame.regs.r14, frame.regs.r15 });

     

       
26
       
-
       
    std.log.err("RFL: 0x{x:0>16}, RIP: 0x{x:0>16}, CS:  0x{x:0>16}, SS:  0x{x:0>16}", .{ frame.eflags, frame.rip, frame.cs, frame.ss });

     

       
27
       
 
       
    arch.interrupts.disable();

     

       
28
       
 
       
    arch.instructions.die();

     

       
29
       
 
       
}

     
···

       
34
       
 
       


     

       
35
       
 
       
pub fn double_fault(stack_frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       
36
       
 
       
    std.log.err("Double fault @ 0x{x}, dying!!!", .{stack_frame.rip});

     

       
0
       
 
       

     

       
0
       
 
       

     

       
37
       
 
       
    arch.instructions.die();

     

       
38
       
 
       
}

     

       
39
       
 
       


     
···

       
56
       
 
       
            std.log.warn("LDT selector: 0x{x}", .{ldt_sel});

     

       
57
       
 
       
        },

     

       
58
       
 
       
    }

     

       
0
       
 
       

     

       
59
       
 
       
    arch.instructions.die();

     

       
60
       
 
       
}

     

···

       
12
       
 
       
    asm volatile ("cli");

     

       
13
       
 
       
}

     

       
14
       
 
       


     

       
15
       
+
       
fn print_regs(frame: *idt.InterruptFrame(u64)) void {

     

       
16
       
+
       
    std.log.err("CR3: 0x{x:0>16}", .{frame.cr3});

     

       
17
       
+
       
    std.log.err("RAX: 0x{x:0>16}, RBX: 0x{x:0>16}, RCX: 0x{x:0>16}, RDX: 0x{x:0>16}", .{ frame.regs.rax, frame.regs.rbx, frame.regs.rcx, frame.regs.rdx });

     

       
18
       
+
       
    std.log.err("RSI: 0x{x:0>16}, RDI: 0x{x:0>16}, RBP: 0x{x:0>16}, RSP: 0x{x:0>16}", .{ frame.regs.rsi, frame.regs.rdi, frame.regs.rbp, frame.rsp });

     

       
19
       
+
       
    std.log.err("R8:  0x{x:0>16}, R9:  0x{x:0>16}, R10: 0x{x:0>16}, R11: 0x{x:0>16}", .{ frame.regs.r8, frame.regs.r9, frame.regs.r10, frame.regs.r11 });

     

       
20
       
+
       
    std.log.err("R12: 0x{x:0>16}, R13: 0x{x:0>16}, R14: 0x{x:0>16}, R15: 0x{x:0>16}", .{ frame.regs.r12, frame.regs.r13, frame.regs.r14, frame.regs.r15 });

     

       
21
       
+
       
    std.log.err("RFL: 0x{x:0>16}, RIP: 0x{x:0>16}, CS:  0x{x:0>16}, SS:  0x{x:0>16}", .{ frame.eflags, frame.rip, frame.cs, frame.ss });

     

       
22
       
+
       
}

     

       
23
       
+
       


     

       
24
       
 
       
pub fn unhandled_interrupt(frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       
25
       
 
       
    if (std.enums.tagName(idt.Exception, frame.int_num.exception)) |exception_name| {

     

       
26
       
 
       
        std.log.err("Unhandled interrupt (0x{x} : {s})!!!", .{ frame.int_num.interrupt, exception_name });

     

       
27
       
 
       
    } else {

     

       
28
       
 
       
        std.log.err("Unhandled interrupt (0x{x})!!!", .{frame.int_num.interrupt});

     

       
29
       
 
       
    }

     

       
30
       
+
       


     

       
31
       
+
       
    print_regs(frame);

     

       
32
       
+
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
33
       
 
       
    arch.interrupts.disable();

     

       
34
       
 
       
    arch.instructions.die();

     

       
35
       
 
       
}

     
···

       
40
       
 
       


     

       
41
       
 
       
pub fn double_fault(stack_frame: *idt.InterruptFrame(u64)) callconv(.{ .x86_64_sysv = .{} }) void {

     

       
42
       
 
       
    std.log.err("Double fault @ 0x{x}, dying!!!", .{stack_frame.rip});

     

       
43
       
+
       
    print_regs(stack_frame);

     

       
44
       
+
       
    arch.interrupts.disable();

     

       
45
       
 
       
    arch.instructions.die();

     

       
46
       
 
       
}

     

       
47
       
 
       


     
···

       
64
       
 
       
            std.log.warn("LDT selector: 0x{x}", .{ldt_sel});

     

       
65
       
 
       
        },

     

       
66
       
 
       
    }

     

       
67
       
+
       
    print_regs(@ptrCast(stack_frame));

     

       
68
       
 
       
    arch.instructions.die();

     

       
69
       
 
       
}