source: mainline/kernel/arch/amd64/src/debugger.c@ e16e0d59

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since e16e0d59 was e16e0d59, checked in by Jiri Svoboda <jirik.svoboda@…>, 16 years ago

Make optionality of symbol information less intrusive per Jakub's request. Also, improve symtab function names and update their semantics.
  • Property mode set to 100644
File size: 9.4 KB
RevLine 
[4e49572]1/*
[df4ed85]2 * Copyright (c) 2006 Ondrej Palkovsky
[4e49572]3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
[06e1e95]29/** @addtogroup amd64debug
[b45c443]30 * @{
31 */
32/** @file
33 */
34
[4e49572]35#include <arch/debugger.h>
36#include <console/kconsole.h>
37#include <console/cmd.h>
38#include <print.h>
39#include <panic.h>
40#include <interrupt.h>
41#include <arch/asm.h>
42#include <arch/cpu.h>
43#include <debug.h>
44#include <func.h>
[6c6a19e6]45#include <smp/ipi.h>
[e2b762ec]46#include <symtab.h>
47
[4e49572]48typedef struct {
[7f1c620]49 uintptr_t address; /**< Breakpoint address */
[4e49572]50 int flags; /**< Flags regarding breakpoint */
51 int counter; /**< How many times the exception occured */
52} bpinfo_t;
53
54static bpinfo_t breakpoints[BKPOINTS_MAX];
55SPINLOCK_INITIALIZE(bkpoint_lock);
56
[76fca31]57#ifdef CONFIG_KCONSOLE
58
[4e49572]59static int cmd_print_breakpoints(cmd_arg_t *argv);
60static cmd_info_t bkpts_info = {
61 .name = "bkpts",
62 .description = "Print breakpoint table.",
63 .func = cmd_print_breakpoints,
64 .argc = 0,
65};
66
67static int cmd_del_breakpoint(cmd_arg_t *argv);
68static cmd_arg_t del_argv = {
69 .type = ARG_TYPE_INT
70};
71static cmd_info_t delbkpt_info = {
72 .name = "delbkpt",
73 .description = "delbkpt <number> - Delete breakpoint.",
74 .func = cmd_del_breakpoint,
75 .argc = 1,
76 .argv = &del_argv
77};
78
79static int cmd_add_breakpoint(cmd_arg_t *argv);
80static cmd_arg_t add_argv = {
81 .type = ARG_TYPE_INT
82};
83static cmd_info_t addbkpt_info = {
84 .name = "addbkpt",
85 .description = "addbkpt <&symbol> - new breakpoint.",
86 .func = cmd_add_breakpoint,
87 .argc = 1,
88 .argv = &add_argv
89};
90
91static cmd_arg_t addw_argv = {
92 .type = ARG_TYPE_INT
93};
94static cmd_info_t addwatchp_info = {
95 .name = "addwatchp",
96 .description = "addbwatchp <&symbol> - new write watchpoint.",
97 .func = cmd_add_breakpoint,
98 .argc = 1,
99 .argv = &addw_argv
100};
101
[76fca31]102#endif /* CONFIG_KCONSOLE */
[4e49572]103
[6c6a19e6]104/* Setup DR register according to table */
105static void setup_dr(int curidx)
106{
[7f1c620]107 unative_t dr7;
[6c6a19e6]108 bpinfo_t *cur = &breakpoints[curidx];
109 int flags = breakpoints[curidx].flags;
110
111 /* Disable breakpoint in DR7 */
112 dr7 = read_dr7();
113 dr7 &= ~(0x2 << (curidx*2));
114
115 if (cur->address) { /* Setup DR register */
116 /* Set breakpoint to debug registers */
117 switch (curidx) {
118 case 0:
119 write_dr0(cur->address);
120 break;
121 case 1:
122 write_dr1(cur->address);
123 break;
124 case 2:
125 write_dr2(cur->address);
126 break;
127 case 3:
128 write_dr3(cur->address);
129 break;
130 }
131 /* Set type to requested breakpoint & length*/
132 dr7 &= ~ (0x3 << (16 + 4*curidx));
133 dr7 &= ~ (0x3 << (18 + 4*curidx));
134 if ((flags & BKPOINT_INSTR)) {
135 ;
136 } else {
[f4c2b6a]137
138#ifdef __32_BITS__
139 dr7 |= ((unative_t) 0x3) << (18 + 4 * curidx);
140#endif
141
142#ifdef __64_BITS__
143 dr7 |= ((unative_t) 0x2) << (18 + 4 * curidx);
144#endif
[6c6a19e6]145
146 if ((flags & BKPOINT_WRITE))
[f4c2b6a]147 dr7 |= ((unative_t) 0x1) << (16 + 4 * curidx);
[6c6a19e6]148 else if ((flags & BKPOINT_READ_WRITE))
[f4c2b6a]149 dr7 |= ((unative_t) 0x3) << (16 + 4 * curidx);
[6c6a19e6]150 }
151
152 /* Enable global breakpoint */
[d7c9fcb]153 dr7 |= 0x2 << (curidx * 2);
[6c6a19e6]154
155 write_dr7(dr7);
156
157 }
158}
159
[4e49572]160/** Enable hardware breakpoint
161 *
162 * @param where Address of HW breakpoint
163 * @param flags Type of breakpoint (EXECUTE, WRITE)
164 * @return Debug slot on success, -1 - no available HW breakpoint
165 */
[7f043c0]166int breakpoint_add(const void *where, const int flags, int curidx)
[4e49572]167{
168 ipl_t ipl;
169 int i;
[6c6a19e6]170 bpinfo_t *cur;
[4e49572]171
[7f043c0]172 ASSERT(flags & (BKPOINT_INSTR | BKPOINT_WRITE | BKPOINT_READ_WRITE));
[4e49572]173
174 ipl = interrupts_disable();
175 spinlock_lock(&bkpoint_lock);
176
[6c6a19e6]177 if (curidx == -1) {
178 /* Find free space in slots */
[7f043c0]179 for (i = 0; i < BKPOINTS_MAX; i++)
[6c6a19e6]180 if (!breakpoints[i].address) {
181 curidx = i;
182 break;
183 }
184 if (curidx == -1) {
185 /* Too many breakpoints */
186 spinlock_unlock(&bkpoint_lock);
187 interrupts_restore(ipl);
188 return -1;
[4e49572]189 }
190 }
[6c6a19e6]191 cur = &breakpoints[curidx];
192
[7f1c620]193 cur->address = (uintptr_t) where;
[4e49572]194 cur->flags = flags;
195 cur->counter = 0;
196
[6c6a19e6]197 setup_dr(curidx);
[4e49572]198
199 spinlock_unlock(&bkpoint_lock);
200 interrupts_restore(ipl);
201
[6c6a19e6]202 /* Send IPI */
203#ifdef CONFIG_SMP
[6da1013f]204// ipi_broadcast(VECTOR_DEBUG_IPI);
[6c6a19e6]205#endif
206
[4e49572]207 return curidx;
208}
209
[6da1013f]210#ifdef __64_BITS__
211 #define getip(x) ((x)->rip)
[23d22eb]212#else
[6da1013f]213 #define getip(x) ((x)->eip)
[23d22eb]214#endif
215
[4e49572]216static void handle_exception(int slot, istate_t *istate)
217{
218 ASSERT(breakpoints[slot].address);
219
220 /* Handle zero checker */
221 if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
222 if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
[7f1c620]223 if (*((unative_t *) breakpoints[slot].address) != 0)
[4e49572]224 return;
[d7c9fcb]225 printf("*** Found ZERO on address %lx (slot %d) ***\n",
226 breakpoints[slot].address, slot);
[4e49572]227 } else {
[7f043c0]228 printf("Data watchpoint - new data: %lx\n",
[d7c9fcb]229 *((unative_t *) breakpoints[slot].address));
[4e49572]230 }
231 }
[e2b762ec]232
[e16e0d59]233 printf("Reached breakpoint %d:%lx (%s)\n", slot, getip(istate),
234 symtab_fmt_name_lookup(getip(istate)));
[76fca31]235
236#ifdef CONFIG_KCONSOLE
237 atomic_set(&haltstate, 1);
[0b6eba5]238 kconsole("debug", "Debug console ready.\n", false);
[76fca31]239 atomic_set(&haltstate, 0);
240#endif
[4e49572]241}
242
243void breakpoint_del(int slot)
244{
245 bpinfo_t *cur;
246 ipl_t ipl;
247
248 ipl = interrupts_disable();
249 spinlock_lock(&bkpoint_lock);
250
251 cur = &breakpoints[slot];
252 if (!cur->address) {
253 spinlock_unlock(&bkpoint_lock);
254 interrupts_restore(ipl);
255 return;
256 }
257
258 cur->address = NULL;
259
[6c6a19e6]260 setup_dr(slot);
[4e49572]261
262 spinlock_unlock(&bkpoint_lock);
263 interrupts_restore(ipl);
[6c6a19e6]264#ifdef CONFIG_SMP
265// ipi_broadcast(VECTOR_DEBUG_IPI);
266#endif
[4e49572]267}
268
[6c6a19e6]269
270
[7f043c0]271static void debug_exception(int n __attribute__((unused)), istate_t *istate)
[6c6a19e6]272{
[7f1c620]273 unative_t dr6;
[6c6a19e6]274 int i;
275
276 /* Set RF to restart the instruction */
[6da1013f]277#ifdef __64_BITS__
[6c6a19e6]278 istate->rflags |= RFLAGS_RF;
279#else
280 istate->eflags |= EFLAGS_RF;
281#endif
282
283 dr6 = read_dr6();
284 for (i=0; i < BKPOINTS_MAX; i++) {
285 if (dr6 & (1 << i)) {
286 dr6 &= ~ (1 << i);
287 write_dr6(dr6);
288
289 handle_exception(i, istate);
290 }
291 }
292}
293
294#ifdef CONFIG_SMP
[d7c9fcb]295static void
296debug_ipi(int n __attribute__((unused)),
297 istate_t *istate __attribute__((unused)))
[6c6a19e6]298{
299 int i;
300
301 spinlock_lock(&bkpoint_lock);
[7f043c0]302 for (i = 0; i < BKPOINTS_MAX; i++)
[6c6a19e6]303 setup_dr(i);
304 spinlock_unlock(&bkpoint_lock);
305}
306#endif
[4e49572]307
308/** Initialize debugger */
309void debugger_init()
310{
311 int i;
312
[d7c9fcb]313 for (i = 0; i < BKPOINTS_MAX; i++)
[4e49572]314 breakpoints[i].address = NULL;
[76fca31]315
316#ifdef CONFIG_KCONSOLE
[4e49572]317 cmd_initialize(&bkpts_info);
318 if (!cmd_register(&bkpts_info))
[76fca31]319 printf("Cannot register command %s\n", bkpts_info.name);
[4e49572]320
321 cmd_initialize(&delbkpt_info);
322 if (!cmd_register(&delbkpt_info))
[76fca31]323 printf("Cannot register command %s\n", delbkpt_info.name);
[4e49572]324
325 cmd_initialize(&addbkpt_info);
326 if (!cmd_register(&addbkpt_info))
[76fca31]327 printf("Cannot register command %s\n", addbkpt_info.name);
[4e49572]328
329 cmd_initialize(&addwatchp_info);
330 if (!cmd_register(&addwatchp_info))
[76fca31]331 printf("Cannot register command %s\n", addwatchp_info.name);
332#endif /* CONFIG_KCONSOLE */
[4e49572]333
[d7c9fcb]334 exc_register(VECTOR_DEBUG, "debugger", debug_exception);
[6c6a19e6]335#ifdef CONFIG_SMP
[d7c9fcb]336 exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);
[6c6a19e6]337#endif
[4e49572]338}
[b45c443]339
[76fca31]340#ifdef CONFIG_KCONSOLE
341/** Print table of active breakpoints */
342int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
343{
344 unsigned int i;
345 char *symbol;
346
[6da1013f]347#ifdef __32_BITS__
[76fca31]348 printf("# Count Address In symbol\n");
349 printf("-- ----- ---------- ---------\n");
350#endif
351
352#ifdef __64_BITS__
353 printf("# Count Address In symbol\n");
354 printf("-- ----- ------------------ ---------\n");
355#endif
356
357 for (i = 0; i < BKPOINTS_MAX; i++)
358 if (breakpoints[i].address) {
[e16e0d59]359 symbol = symtab_fmt_name_lookup(
360 breakpoints[i].address);
[76fca31]361
362#ifdef __32_BITS__
363 printf("%-2u %-5d %#10zx %s\n", i,
364 breakpoints[i].counter, breakpoints[i].address,
365 symbol);
366#endif
367
368#ifdef __64_BITS__
369 printf("%-2u %-5d %#18zx %s\n", i,
370 breakpoints[i].counter, breakpoints[i].address,
371 symbol);
372#endif
373
374 }
375 return 1;
376}
377
378/** Remove breakpoint from table */
379int cmd_del_breakpoint(cmd_arg_t *argv)
380{
381 unative_t bpno = argv->intval;
382 if (bpno > BKPOINTS_MAX) {
383 printf("Invalid breakpoint number.\n");
384 return 0;
385 }
386 breakpoint_del(argv->intval);
387 return 1;
388}
389
390/** Add new breakpoint to table */
391static int cmd_add_breakpoint(cmd_arg_t *argv)
392{
393 int flags;
394 int id;
395
396 if (argv == &add_argv) {
397 flags = BKPOINT_INSTR;
398 } else { /* addwatchp */
399 flags = BKPOINT_WRITE;
400 }
401 printf("Adding breakpoint on address: %p\n", argv->intval);
402 id = breakpoint_add((void *)argv->intval, flags, -1);
403 if (id < 0)
404 printf("Add breakpoint failed.\n");
405 else
406 printf("Added breakpoint %d.\n", id);
407
408 return 1;
409}
410#endif /* CONFIG_KCONSOLE */
411
[06e1e95]412/** @}
[b45c443]413 */
Note: See TracBrowser for help on using the repository browser.