Subversion Repositories HelenOS

Rev

Rev 3138 | Rev 3880 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1072 palkovsky 1
/*
2071 jermar 2
 * Copyright (c) 2006 Ondrej Palkovsky
1072 palkovsky 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
 
1888 jermar 29
/** @addtogroup amd64debug
1702 cejka 30
 * @{
31
 */
32
/** @file
33
 */
34
 
1072 palkovsky 35
#include <arch/debugger.h>
36
#include <console/kconsole.h>
37
#include <console/cmd.h>
38
#include <symtab.h>
39
#include <print.h>
40
#include <panic.h>
41
#include <interrupt.h>
42
#include <arch/asm.h>
43
#include <arch/cpu.h>
44
#include <debug.h>
45
#include <func.h>
1077 palkovsky 46
#include <smp/ipi.h>
1072 palkovsky 47
 
48
typedef struct  {
1780 jermar 49
    uintptr_t address;      /**< Breakpoint address */
1072 palkovsky 50
    int flags;              /**< Flags regarding breakpoint */
51
    int counter;            /**< How many times the exception occured */
52
} bpinfo_t;
53
 
54
static bpinfo_t breakpoints[BKPOINTS_MAX];
55
SPINLOCK_INITIALIZE(bkpoint_lock);
56
 
3707 decky 57
#ifdef CONFIG_KCONSOLE
58
 
1072 palkovsky 59
static int cmd_print_breakpoints(cmd_arg_t *argv);
60
static cmd_info_t bkpts_info = {
61
    .name = "bkpts",
62
    .description = "Print breakpoint table.",
63
    .func = cmd_print_breakpoints,
64
    .argc = 0,
65
};
66
 
1077 palkovsky 67
#ifndef CONFIG_DEBUG_AS_WATCHPOINT
68
 
1072 palkovsky 69
static int cmd_del_breakpoint(cmd_arg_t *argv);
70
static cmd_arg_t del_argv = {
71
    .type = ARG_TYPE_INT
72
};
73
static cmd_info_t delbkpt_info = {
74
    .name = "delbkpt",
75
    .description = "delbkpt <number> - Delete breakpoint.",
76
    .func = cmd_del_breakpoint,
77
    .argc = 1,
78
    .argv = &del_argv
79
};
80
 
81
static int cmd_add_breakpoint(cmd_arg_t *argv);
82
static cmd_arg_t add_argv = {
83
    .type = ARG_TYPE_INT
84
};
85
static cmd_info_t addbkpt_info = {
86
    .name = "addbkpt",
87
    .description = "addbkpt <&symbol> - new breakpoint.",
88
    .func = cmd_add_breakpoint,
89
    .argc = 1,
90
    .argv = &add_argv
91
};
92
 
93
static cmd_arg_t addw_argv = {
94
    .type = ARG_TYPE_INT
95
};
96
static cmd_info_t addwatchp_info = {
97
    .name = "addwatchp",
98
    .description = "addbwatchp <&symbol> - new write watchpoint.",
99
    .func = cmd_add_breakpoint,
100
    .argc = 1,
101
    .argv = &addw_argv
102
};
103
 
3707 decky 104
#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
105
#endif /* CONFIG_KCONSOLE */
1072 palkovsky 106
 
1077 palkovsky 107
/* Setup DR register according to table */
108
static void setup_dr(int curidx)
109
{
1780 jermar 110
    unative_t dr7;
1077 palkovsky 111
    bpinfo_t *cur = &breakpoints[curidx];
112
    int flags = breakpoints[curidx].flags;
113
 
114
    /* Disable breakpoint in DR7 */
115
    dr7 = read_dr7();
116
    dr7 &= ~(0x2 << (curidx*2));
117
 
118
    if (cur->address) { /* Setup DR register */
119
        /* Set breakpoint to debug registers */
120
        switch (curidx) {
121
        case 0:
122
            write_dr0(cur->address);
123
            break;
124
        case 1:
125
            write_dr1(cur->address);
126
            break;
127
        case 2:
128
            write_dr2(cur->address);
129
            break;
130
        case 3:
131
            write_dr3(cur->address);
132
            break;
133
        }
134
        /* Set type to requested breakpoint & length*/
135
        dr7 &= ~ (0x3 << (16 + 4*curidx));
136
        dr7 &= ~ (0x3 << (18 + 4*curidx));
137
        if ((flags & BKPOINT_INSTR)) {
138
            ;
139
        } else {
3071 decky 140
 
141
#ifdef __32_BITS__
142
            dr7 |= ((unative_t) 0x3) << (18 + 4 * curidx);
143
#endif
144
 
145
#ifdef __64_BITS__
146
            dr7 |= ((unative_t) 0x2) << (18 + 4 * curidx);
147
#endif
1077 palkovsky 148
 
149
            if ((flags & BKPOINT_WRITE))
3071 decky 150
                dr7 |= ((unative_t) 0x1) << (16 + 4 * curidx);
1077 palkovsky 151
            else if ((flags & BKPOINT_READ_WRITE))
3071 decky 152
                dr7 |= ((unative_t) 0x3) << (16 + 4 * curidx);
1077 palkovsky 153
        }
154
 
155
        /* Enable global breakpoint */
3138 jermar 156
        dr7 |= 0x2 << (curidx * 2);
1077 palkovsky 157
 
158
        write_dr7(dr7);
159
 
160
    }
161
}
162
 
1072 palkovsky 163
/** Enable hardware breakpoint
164
 *
165
 * @param where Address of HW breakpoint
166
 * @param flags Type of breakpoint (EXECUTE, WRITE)
167
 * @return Debug slot on success, -1 - no available HW breakpoint
168
 */
2441 decky 169
int breakpoint_add(const void *where, const int flags, int curidx)
1072 palkovsky 170
{
171
    ipl_t ipl;
172
    int i;
1077 palkovsky 173
    bpinfo_t *cur;
1072 palkovsky 174
 
2441 decky 175
    ASSERT(flags & (BKPOINT_INSTR | BKPOINT_WRITE | BKPOINT_READ_WRITE));
1072 palkovsky 176
 
177
    ipl = interrupts_disable();
178
    spinlock_lock(&bkpoint_lock);
179
 
1077 palkovsky 180
    if (curidx == -1) {
181
        /* Find free space in slots */
2441 decky 182
        for (i = 0; i < BKPOINTS_MAX; i++)
1077 palkovsky 183
            if (!breakpoints[i].address) {
184
                curidx = i;
185
                break;
186
            }
187
        if (curidx == -1) {
188
            /* Too many breakpoints */
189
            spinlock_unlock(&bkpoint_lock);
190
            interrupts_restore(ipl);
191
            return -1;
1072 palkovsky 192
        }
193
    }
1077 palkovsky 194
    cur = &breakpoints[curidx];
195
 
1780 jermar 196
    cur->address = (uintptr_t) where;
1072 palkovsky 197
    cur->flags = flags;
198
    cur->counter = 0;
199
 
1077 palkovsky 200
    setup_dr(curidx);
1072 palkovsky 201
 
202
    spinlock_unlock(&bkpoint_lock);
203
    interrupts_restore(ipl);
204
 
1077 palkovsky 205
    /* Send IPI */
206
#ifdef CONFIG_SMP
207
//  ipi_broadcast(VECTOR_DEBUG_IPI);    
208
#endif  
209
 
1072 palkovsky 210
    return curidx;
211
}
212
 
1074 palkovsky 213
#ifdef amd64
2441 decky 214
#   define getip(x) ((x)->rip)
1074 palkovsky 215
#else
2441 decky 216
#   define getip(x) ((x)->eip)
1074 palkovsky 217
#endif
218
 
1072 palkovsky 219
static void handle_exception(int slot, istate_t *istate)
220
{
221
    ASSERT(breakpoints[slot].address);
222
 
223
    /* Handle zero checker */
224
    if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
225
        if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
1780 jermar 226
            if (*((unative_t *) breakpoints[slot].address) != 0)
1072 palkovsky 227
                return;
3138 jermar 228
            printf("*** Found ZERO on address %lx (slot %d) ***\n",
229
                breakpoints[slot].address, slot);
1072 palkovsky 230
        } else {
2441 decky 231
            printf("Data watchpoint - new data: %lx\n",
3138 jermar 232
                *((unative_t *) breakpoints[slot].address));
1072 palkovsky 233
        }
234
    }
2441 decky 235
    printf("Reached breakpoint %d:%lx(%s)\n", slot, getip(istate),
3138 jermar 236
        get_symtab_entry(getip(istate)));
3707 decky 237
 
238
#ifdef CONFIG_KCONSOLE
239
    atomic_set(&haltstate, 1);
240
    kconsole("debug", "Debug console ready (type 'exit' to continue)\n", false);
241
    atomic_set(&haltstate, 0);
242
#endif
1072 palkovsky 243
}
244
 
245
void breakpoint_del(int slot)
246
{
247
    bpinfo_t *cur;
248
    ipl_t ipl;
249
 
250
    ipl = interrupts_disable();
251
    spinlock_lock(&bkpoint_lock);
252
 
253
    cur = &breakpoints[slot];
254
    if (!cur->address) {
255
        spinlock_unlock(&bkpoint_lock);
256
        interrupts_restore(ipl);
257
        return;
258
    }
259
 
260
    cur->address = NULL;
261
 
1077 palkovsky 262
    setup_dr(slot);
1072 palkovsky 263
 
264
    spinlock_unlock(&bkpoint_lock);
265
    interrupts_restore(ipl);
1077 palkovsky 266
#ifdef CONFIG_SMP
267
//  ipi_broadcast(VECTOR_DEBUG_IPI);    
268
#endif
1072 palkovsky 269
}
270
 
1077 palkovsky 271
 
1072 palkovsky 272
 
2441 decky 273
static void debug_exception(int n __attribute__((unused)), istate_t *istate)
1077 palkovsky 274
{
1780 jermar 275
    unative_t dr6;
1077 palkovsky 276
    int i;
277
 
278
    /* Set RF to restart the instruction  */
279
#ifdef amd64       
280
    istate->rflags |= RFLAGS_RF;
281
#else
282
    istate->eflags |= EFLAGS_RF;
283
#endif
284
 
285
    dr6 = read_dr6();
286
    for (i=0; i < BKPOINTS_MAX; i++) {
287
        if (dr6 & (1 << i)) {
288
            dr6 &= ~ (1 << i);
289
            write_dr6(dr6);
290
 
291
            handle_exception(i, istate);
292
        }
293
    }
294
}
295
 
296
#ifdef CONFIG_SMP
3138 jermar 297
static void
298
debug_ipi(int n __attribute__((unused)),
299
    istate_t *istate __attribute__((unused)))
1077 palkovsky 300
{
301
    int i;
302
 
303
    spinlock_lock(&bkpoint_lock);
2441 decky 304
    for (i = 0; i < BKPOINTS_MAX; i++)
1077 palkovsky 305
        setup_dr(i);
306
    spinlock_unlock(&bkpoint_lock);
307
}
308
#endif
309
 
1072 palkovsky 310
/** Initialize debugger */
311
void debugger_init()
312
{
313
    int i;
314
 
3138 jermar 315
    for (i = 0; i < BKPOINTS_MAX; i++)
1072 palkovsky 316
        breakpoints[i].address = NULL;
3707 decky 317
 
318
#ifdef CONFIG_KCONSOLE
1072 palkovsky 319
    cmd_initialize(&bkpts_info);
320
    if (!cmd_register(&bkpts_info))
3707 decky 321
        printf("Cannot register command %s\n", bkpts_info.name);
1072 palkovsky 322
 
1077 palkovsky 323
#ifndef CONFIG_DEBUG_AS_WATCHPOINT
1072 palkovsky 324
    cmd_initialize(&delbkpt_info);
325
    if (!cmd_register(&delbkpt_info))
3707 decky 326
        printf("Cannot register command %s\n", delbkpt_info.name);
1072 palkovsky 327
 
328
    cmd_initialize(&addbkpt_info);
329
    if (!cmd_register(&addbkpt_info))
3707 decky 330
        printf("Cannot register command %s\n", addbkpt_info.name);
1072 palkovsky 331
 
332
    cmd_initialize(&addwatchp_info);
333
    if (!cmd_register(&addwatchp_info))
3707 decky 334
        printf("Cannot register command %s\n", addwatchp_info.name);
335
#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
336
#endif /* CONFIG_KCONSOLE */
1072 palkovsky 337
 
3138 jermar 338
    exc_register(VECTOR_DEBUG, "debugger", debug_exception);
1077 palkovsky 339
#ifdef CONFIG_SMP
3138 jermar 340
    exc_register(VECTOR_DEBUG_IPI, "debugger_smp", debug_ipi);
1077 palkovsky 341
#endif
1072 palkovsky 342
}
1702 cejka 343
 
3707 decky 344
#ifdef CONFIG_KCONSOLE
345
/** Print table of active breakpoints */
346
int cmd_print_breakpoints(cmd_arg_t *argv __attribute__((unused)))
347
{
348
    unsigned int i;
349
    char *symbol;
350
 
351
#ifdef __32_BITS__  
352
    printf("#  Count Address    In symbol\n");
353
    printf("-- ----- ---------- ---------\n");
354
#endif
355
 
356
#ifdef __64_BITS__
357
    printf("#  Count Address            In symbol\n");
358
    printf("-- ----- ------------------ ---------\n");
359
#endif
360
 
361
    for (i = 0; i < BKPOINTS_MAX; i++)
362
        if (breakpoints[i].address) {
363
            symbol = get_symtab_entry(breakpoints[i].address);
364
 
365
#ifdef __32_BITS__
366
            printf("%-2u %-5d %#10zx %s\n", i,
367
                breakpoints[i].counter, breakpoints[i].address,
368
                symbol);
369
#endif
370
 
371
#ifdef __64_BITS__
372
            printf("%-2u %-5d %#18zx %s\n", i,
373
                breakpoints[i].counter, breakpoints[i].address,
374
                symbol);
375
#endif
376
 
377
        }
378
    return 1;
379
}
380
 
381
#ifndef CONFIG_DEBUG_AS_WATCHPOINT
382
 
383
/** Remove breakpoint from table */
384
int cmd_del_breakpoint(cmd_arg_t *argv)
385
{
386
    unative_t bpno = argv->intval;
387
    if (bpno > BKPOINTS_MAX) {
388
        printf("Invalid breakpoint number.\n");
389
        return 0;
390
    }
391
    breakpoint_del(argv->intval);
392
    return 1;
393
}
394
 
395
/** Add new breakpoint to table */
396
static int cmd_add_breakpoint(cmd_arg_t *argv)
397
{
398
    int flags;
399
    int id;
400
 
401
    if (argv == &add_argv) {
402
        flags = BKPOINT_INSTR;
403
    } else { /* addwatchp */
404
        flags = BKPOINT_WRITE;
405
    }
406
    printf("Adding breakpoint on address: %p\n", argv->intval);
407
    id = breakpoint_add((void *)argv->intval, flags, -1);
408
    if (id < 0)
409
        printf("Add breakpoint failed.\n");
410
    else
411
        printf("Added breakpoint %d.\n", id);
412
 
413
    return 1;
414
}
415
#endif /* CONFIG_DEBUG_AS_WATCHPOINT */
416
#endif /* CONFIG_KCONSOLE */
417
 
1888 jermar 418
/** @}
1702 cejka 419
 */