1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
#include "def.h"
#include "halt.h"
#include "font.h"
#include "heap.h"
extern u64 idt_entries[256]; // isr.asm
typedef struct {
u64 which;
u64 error_code;
// automatically pushed
u64 rip;
u64 cs;
u64 rflags;
u64 rsp;
u64 ss;
} interrupt_frame;
static const char *exception[32] = {
"Division Error",
"Debug",
"Non-maskable Interrupt",
"Breakpoint",
"Overflow",
"Bound Range Exceeded",
"Invalid Opcode",
"Device Not Available",
"Double Fault",
"Coprocessor Segment Overrun",
"Invalid TSS",
"Segment Not Present",
"Stack-Segment Fault",
"General Protection Fault",
"Page Fault",
nil,
"x87 Floating-Point Exception",
"Alignment Check",
"Machine Check",
"SIMD Floating-Point Exception",
"Virtualization Exception",
"Control Protection Exception",
nil, nil, nil, nil, nil, nil,
"Hypervisor Injection Exception",
"VMM Communication Exception",
"Security Exception",
nil,
};
static void dump_frame(interrupt_frame *frame)
{
print("rip = "); print_num(frame->rip, 16, 0); print("\n");
print("cs = "); print_num(frame->cs, 16, 0); print("\n");
print("rflags = "); print_num(frame->rflags, 16, 0); print("\n");
print("rsp = "); print_num(frame->rsp, 16, 0); print("\n");
print("ss = "); print_num(frame->ss, 16, 0); print("\n");
}
void interrupt_handler(interrupt_frame *frame)
{
if (frame->which < 32) {
if (exception[frame->which] == nil) {
print("Unknown Exception ");
print_num(frame->which, 10, 0);
} else {
print(exception[frame->which]);
}
print("\n");
if (frame->which == 13) {
const char *bits[8] = {
"present",
"write",
"user",
"reserved_write",
"instruction_fetch",
"protection_key",
"shadow_stack",
"software_guard_extensions",
};
u8 err = frame->error_code;
for (int i = 0; i < 8; i++) {
print(bits[i]); print(" = "); print((err & 1) ? "true\n" : "false\n");
err >>= 1;
}
} else {
print("error_code = "); print_num(frame->error_code, 10, 0); print("\n");
}
dump_frame(frame);
halt();
} else {
print("Spurious Interrupt "); print_num(frame->which, 10, 0); print("\n");
dump_frame(frame);
}
}
void init_interrupts()
{
typedef struct {
u16 offset_1;
u16 selector;
u8 ist;
u8 type_attrs;
u16 offset_2;
u32 offset_3;
u32 zero;
} __attribute__((packed)) interrupt_descriptor;
interrupt_descriptor *idt = malloc(256 * sizeof *idt);
for (int i = 0; i < 255; i++) {
union {
struct {
u16 offset_1;
u16 offset_2;
u32 offset_3;
} __attribute__((packed)) off;
u64 addr;
} __attribute__((packed)) isr = {
.addr = idt_entries[i],
};
idt[i] = (interrupt_descriptor) {
.offset_1 = isr.off.offset_1,
.selector = 0x8,
.ist = 0,
.type_attrs = 0x8E,
.offset_2 = isr.off.offset_2,
.offset_3 = isr.off.offset_3,
.zero = 0,
};
}
typedef struct {
u16 size;
u64 addr;
} __attribute__((packed)) idt_descriptor;
idt_descriptor idtr = {
.size = 256 * sizeof *idt - 1,
.addr = (u64) &idt[0],
};
asm("lidt %0" : : "m"(idtr));
}
|
