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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
|
#include <lib.h>
#include <stddef.h>
#include <serial.h>
#include <backtrace.h>
#include "debugger.h"
struct dr6 {
uint64_t b0 : 1,
b1 : 1,
b2 : 1,
b3 : 1,
: 7,
bld : 1,
: 1,
bd : 1,
bs : 1,
bt : 1,
rtm : 1,
: 47;
};
struct dr7 {
uint64_t l0 : 1,
g0 : 1,
l1 : 1,
g1 : 1,
l2 : 1,
g2 : 1,
l3 : 1,
g3 : 1,
: 8,
rw0 : 2,
len0 : 2,
rw1 : 2,
len1 : 2,
rw2 : 2,
len2 : 2,
rw3 : 2,
len3 : 2,
: 32;
};
struct rflags {
uint64_t cf : 1,
: 1,
pf : 1,
: 1,
af : 1,
: 1,
zf : 1,
sf : 1,
tf : 1,
if_ : 1,
df : 1,
of : 1,
iopl : 2,
nt : 1,
md : 1,
rf : 1,
vm : 1,
ac : 1,
vif : 1,
vip : 1,
id : 1,
: 42;
};
struct breakpoint {
uint64_t addr;
uint8_t len;
uint8_t rw;
uint8_t used;
uint8_t enable;
};
static size_t dbg_steps = 0;
static int dbg_continue = 0;
static struct breakpoint bkps[4] = {{0}, {0}, {0}, {0}};
static void dbg_putc(char c) {
serial_out(c);
}
static void dbg_puts(char *msg) {
serial_out_str(msg);
}
static char dbg_getc() {
return serial_in();
}
static void debugger_msg(int cause, struct dr6 dr6) {
char buf[24];
switch (cause) {
case DEBUG_INT3:
dbg_puts("dbg: reached int3");
break;
case DEBUG_FAULT:
dbg_puts("dbg: a fault occured");
break;
case DEBUG_DBG:
if (dr6.bs)
dbg_puts("dbg: finished steps");
else if (dr6.b0)
dbg_puts("dbg: reached breakpoint 0");
else if (dr6.b1)
dbg_puts("dbg: reached breakpoint 1");
else if (dr6.b2)
dbg_puts("dbg: reached breakpoint 2");
else if (dr6.b3)
dbg_puts("dbg: reached breakpoint 3");
}
if (dbg_steps > 0) {
ultoa(dbg_steps, buf, 10);
dbg_puts(" (");
dbg_puts(buf);
dbg_puts(" steps left)");
}
if (dbg_continue > 0) {
dbg_puts(" (paused continue)");
}
dbg_puts("\n");
}
static void debugger_print_reg(char *name, uint64_t val) {
char buf[24];
char *end;
dbg_puts(name);
dbg_puts(": 0x");
end = ultoa(val, buf, 16);
for (int i = 0; i < 16 - (end - buf); i++) {
dbg_putc('0');
}
dbg_puts(buf);
dbg_puts(" (");
end = ultoa(val, buf, 10);
dbg_puts(buf);
dbg_puts(")\n");
}
static void debugger_print_regs(struct isr_regs *state) {
debugger_print_reg("rax", state->rax);
debugger_print_reg("rbx", state->rbx);
debugger_print_reg("rcx", state->rcx);
debugger_print_reg("rdx", state->rdx);
debugger_print_reg("rsi", state->rsi);
debugger_print_reg("rdi", state->rdi);
debugger_print_reg("rsp", state->rsp);
debugger_print_reg("rbp", state->rbp);
debugger_print_reg("r8 ", state->r8 );
debugger_print_reg("r9 ", state->r9 );
debugger_print_reg("r10", state->r10);
debugger_print_reg("r11", state->r11);
debugger_print_reg("r12", state->r12);
debugger_print_reg("r13", state->r13);
debugger_print_reg("r14", state->r14);
debugger_print_reg("r15", state->r15);
dbg_puts("---\n");
debugger_print_reg("rip", state->rip);
dbg_puts("---\n");
debugger_print_reg("rflags", state->rflags);
struct rflags *rflags = (struct rflags *)state->rflags;
dbg_puts("rflags: ");
if(rflags->cf) dbg_puts("CF ");
if(rflags->pf) dbg_puts("PF ");
if(rflags->af) dbg_puts("AF ");
if(rflags->zf) dbg_puts("ZF ");
if(rflags->sf) dbg_puts("SF ");
if(rflags->tf) dbg_puts("TF ");
if(rflags->if_) dbg_puts("IF ");
if(rflags->df) dbg_puts("DF ");
if(rflags->of) dbg_puts("OF ");
if(rflags->iopl) dbg_puts("IOPL ");
if(rflags->nt) dbg_puts("NT ");
if(rflags->md) dbg_puts("MD ");
if(rflags->rf) dbg_puts("RF ");
if(rflags->vm) dbg_puts("VM ");
if(rflags->ac) dbg_puts("AC ");
if(rflags->vif) dbg_puts("VIF ");
if(rflags->vip) dbg_puts("VIP ");
if(rflags->id) dbg_puts("ID ");
dbg_putc('\n');
}
#define PROMPT_LEN 60
static int debugger_handle_bkp_cmd(char *buf) {
if (buf[0] == 'l') {
// list breakpoints
char buf[20];
for (int i = 0; i < 4; i++) {
dbg_puts("breakpoint ");
dbg_putc('0' + i);
dbg_puts(": ");
struct breakpoint bkp = bkps[i];
if(!bkp.used) {
dbg_puts("unset\n");
continue;
}
dbg_puts(" 0x");
ultoa(bkp.addr, buf, 16);
dbg_puts(buf);
dbg_puts(" len=");
switch (bkp.len) {
case 0x0: dbg_putc('1'); break;
case 0x1: dbg_putc('2'); break;
case 0x2: dbg_putc('8'); break;
case 0x3: dbg_putc('4'); break;
}
dbg_puts(" trigger=");
switch (bkp.rw) {
case 0x0: dbg_puts("x "); break;
case 0x1: dbg_puts("w "); break;
case 0x2: dbg_puts("io"); break;
case 0x3: dbg_puts("rw"); break;
}
dbg_puts(bkp.enable ? " enabled" : " disabled");
}
return 1;
} else if (buf[0] == 'd') {
// disable breakpoints
bkps[0].enable = 0;
bkps[1].enable = 0;
bkps[2].enable = 0;
bkps[3].enable = 0;
return 1;
} else if (buf[0] == 'c') {
// clear breakpoints
bkps[0].used = 0;
bkps[1].used = 0;
bkps[2].used = 0;
bkps[3].used = 0;
return 1;
} else if (buf[0] <= '0' && buf[0] >= '3') {
dbg_puts("invalid breakpoint command\n");
return 1;
}
// TODO set breakpoints
return 1;
}
static void debugger_load_bkps() {
struct dr7 dr7;
__asm__ volatile ("mov %%dr7, %0" : "=r"(dr7));
dr7.g0 = bkps[0].enable & bkps[0].used;
dr7.g1 = bkps[1].enable & bkps[0].used;
dr7.g2 = bkps[2].enable & bkps[0].used;
dr7.g3 = bkps[3].enable & bkps[0].used;
dr7.l0 = 0;
dr7.l1 = 0;
dr7.l2 = 0;
dr7.l3 = 0;
dr7.rw0 = bkps[0].rw;
dr7.rw1 = bkps[1].rw;
dr7.rw2 = bkps[2].rw;
dr7.rw3 = bkps[3].rw;
dr7.len0 = bkps[0].len;
dr7.len1 = bkps[1].len;
dr7.len2 = bkps[2].len;
dr7.len3 = bkps[3].len;
__asm__ volatile ("mov %0, %%dr7" : : "r"(dr7));
}
static int debugger_prompt(struct isr_regs *state) {
char buf[PROMPT_LEN];
char *p = buf;
dbg_puts("dbg> ");
while ((*p = dbg_getc()) != '\r' && p < buf + PROMPT_LEN - 1) {
dbg_putc(*p++);
}
dbg_putc('\n');
for(; p < buf + PROMPT_LEN; p++) {
*p = 0;
}
struct rflags *rflags = (struct rflags *)&state->rflags;
switch (buf[0]) {
case '\0': // nothing entered
return 1;
case 'h': // help
dbg_puts("see debugger.c for help information\n");
return 1;
case 'q': // quit
return 0;
case 'c': // continue
rflags->tf = 1;
dbg_continue = 1;
return 0;
case 'r': // print registers
debugger_print_regs(state);
return 1;
case 'k': // backtrace
log_backtrace_ex((void *)state->rip, (void *)state->rbp);
return 1;
case 's': // step (n)
rflags->tf = 1;
dbg_steps = atol(buf + 1) - 1;
if (dbg_steps < 0) dbg_steps = 0;
return 0;
case 'b': // breakpoints
{
int res = debugger_handle_bkp_cmd(buf+1);
debugger_load_bkps();
return res;
}
default:
dbg_puts("unknown command\n");
return 1;
}
}
void debugger(struct isr_regs *state, int cause) {
struct dr6 dr6;
__asm__ volatile ("mov %%dr6, %0" : "=r"(dr6));
if (dr6.b0 || dr6.b1 || dr6.b2 || dr6.b3) {
} else {
if (dr6.bs && dbg_steps > 0) {
dbg_steps--;
return;
}
if (dr6.bs && dbg_continue) {
return;
}
}
debugger_msg(cause, dr6);
dbg_steps = 0;
dbg_continue = 0;
struct rflags *rflags = (struct rflags *)&state->rflags;
rflags->tf = 0;
while (debugger_prompt(state));
}
|
