Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
1072 palkovsky 1
/*
2
 * Copyright (C) 2006 Ondrej 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
 
29
#include <arch/debugger.h>
30
#include <console/kconsole.h>
31
#include <console/cmd.h>
32
#include <symtab.h>
33
#include <print.h>
34
#include <panic.h>
35
#include <interrupt.h>
36
#include <arch/asm.h>
37
#include <arch/cpu.h>
38
#include <debug.h>
39
#include <func.h>
40
 
41
typedef struct  {
42
    __address address;      /**< Breakpoint address */
43
    int flags;              /**< Flags regarding breakpoint */
44
    int counter;            /**< How many times the exception occured */
45
} bpinfo_t;
46
 
47
static bpinfo_t breakpoints[BKPOINTS_MAX];
48
SPINLOCK_INITIALIZE(bkpoint_lock);
49
 
50
static int cmd_print_breakpoints(cmd_arg_t *argv);
51
static cmd_info_t bkpts_info = {
52
    .name = "bkpts",
53
    .description = "Print breakpoint table.",
54
    .func = cmd_print_breakpoints,
55
    .argc = 0,
56
};
57
 
58
static int cmd_del_breakpoint(cmd_arg_t *argv);
59
static cmd_arg_t del_argv = {
60
    .type = ARG_TYPE_INT
61
};
62
static cmd_info_t delbkpt_info = {
63
    .name = "delbkpt",
64
    .description = "delbkpt <number> - Delete breakpoint.",
65
    .func = cmd_del_breakpoint,
66
    .argc = 1,
67
    .argv = &del_argv
68
};
69
 
70
static int cmd_add_breakpoint(cmd_arg_t *argv);
71
static cmd_arg_t add_argv = {
72
    .type = ARG_TYPE_INT
73
};
74
static cmd_info_t addbkpt_info = {
75
    .name = "addbkpt",
76
    .description = "addbkpt <&symbol> - new breakpoint.",
77
    .func = cmd_add_breakpoint,
78
    .argc = 1,
79
    .argv = &add_argv
80
};
81
 
82
static cmd_arg_t addw_argv = {
83
    .type = ARG_TYPE_INT
84
};
85
static cmd_info_t addwatchp_info = {
86
    .name = "addwatchp",
87
    .description = "addbwatchp <&symbol> - new write watchpoint.",
88
    .func = cmd_add_breakpoint,
89
    .argc = 1,
90
    .argv = &addw_argv
91
};
92
 
93
 
94
/** Print table of active breakpoints */
95
int cmd_print_breakpoints(cmd_arg_t *argv)
96
{
97
    int i;
98
    char *symbol;
99
 
100
    printf("Breakpoint table.\n");
101
    for (i=0; i < BKPOINTS_MAX; i++)
102
        if (breakpoints[i].address) {
103
            symbol = get_symtab_entry(breakpoints[i].address);
104
            printf("%d. 0x%p in %s\n",i,
105
                   breakpoints[i].address, symbol);
106
            printf("     Count(%d) ", breakpoints[i].counter);
107
            printf("\n");
108
        }
109
    return 1;
110
}
111
 
112
/** Enable hardware breakpoint
113
 *
114
 *
115
 * @param where Address of HW breakpoint
116
 * @param flags Type of breakpoint (EXECUTE, WRITE)
117
 * @return Debug slot on success, -1 - no available HW breakpoint
118
 */
119
int breakpoint_add(void * where, int flags)
120
{
121
    bpinfo_t *cur = NULL;
122
    int curidx;
123
    ipl_t ipl;
124
    int i;
125
    __native dr7;
126
 
127
    ASSERT( flags & (BKPOINT_INSTR | BKPOINT_WRITE | BKPOINT_READ_WRITE));
128
 
129
    ipl = interrupts_disable();
130
    spinlock_lock(&bkpoint_lock);
131
 
132
    /* Find free space in slots */
133
    for (i=0; i<BKPOINTS_MAX; i++)
134
        if (!breakpoints[i].address) {
135
            cur = &breakpoints[i];
136
            curidx = i;
137
            break;
138
        }
139
    if (!cur) {
140
        /* Too many breakpoints */
141
        spinlock_unlock(&bkpoint_lock);
142
        interrupts_restore(ipl);
143
        return -1;
144
    }
145
    cur->address = (__address) where;
146
    cur->flags = flags;
147
    cur->counter = 0;
148
 
149
    /* Set breakpoint to debug registers */
150
    switch (curidx) {
151
    case 0:
152
        write_dr0(cur->address);
153
        break;
154
    case 1:
155
        write_dr1(cur->address);
156
        break;
157
    case 2:
158
        write_dr2(cur->address);
159
        break;
160
    case 3:
161
        write_dr3(cur->address);
162
        break;
163
    }
164
    dr7 = read_dr7();
165
    /* Set type to requested breakpoint & length*/
166
    dr7 &= ~ (0x3 << (16 + 4*curidx));
167
    dr7 &= ~ (0x3 << (18 + 4*curidx));
168
    if ((flags & BKPOINT_INSTR)) {
169
        printf("Instr breakpoint\n");
170
        ;
171
    } else {
172
        if (sizeof(int) == 4)
173
            dr7 |= 0x3 << (18 + 4*curidx);
174
        else /* 8 */
175
            dr7 |= 0x2 << (18 + 4*curidx);
176
 
177
        if ((flags & BKPOINT_WRITE))
178
            dr7 |= 0x1 << (16 + 4*curidx);
179
        else if ((flags & BKPOINT_READ_WRITE))
180
            dr7 |= 0x3 << (16 + 4*curidx);
181
    }
182
 
183
    /* Enable global breakpoint */
184
    dr7 |= 0x2 << (curidx*2);
185
 
186
    write_dr7(dr7);
187
 
188
    spinlock_unlock(&bkpoint_lock);
189
    interrupts_restore(ipl);
190
 
191
    return curidx;
192
}
193
 
1074 palkovsky 194
#ifdef amd64
195
# define getip(x)  ((x)->rip)
196
#else
197
# define getip(x)  ((x)->eip)
198
#endif
199
 
1072 palkovsky 200
static void handle_exception(int slot, istate_t *istate)
201
{
202
    ASSERT(breakpoints[slot].address);
203
 
204
    /* Handle zero checker */
205
    if (! (breakpoints[slot].flags & BKPOINT_INSTR)) {
206
        if ((breakpoints[slot].flags & BKPOINT_CHECK_ZERO)) {
207
            if (*((__native *) breakpoints[slot].address) != 0)
208
                return;
209
            printf("**** Found ZERO on address %P ****\n",
210
                   slot, breakpoints[slot].address);
211
        } else {
212
            printf("Data watchpoint - new data: %P\n",
213
                   *((__native *) breakpoints[slot].address));
214
        }
215
    }
1074 palkovsky 216
    printf("Reached breakpoint %d:%P(%s)\n", slot, getip(istate),
217
           get_symtab_entry(getip(istate)));
1072 palkovsky 218
    printf("***Type 'exit' to exit kconsole.\n");
219
    atomic_set(&haltstate,1);
220
    kconsole("debug");
221
    atomic_set(&haltstate,0);
222
}
223
 
224
static void debug_exception(int n, istate_t *istate)
225
{
226
    __native dr6;
227
    int i;
228
 
229
    /* Set RF to restart the instruction  */
1074 palkovsky 230
#ifdef amd64       
1072 palkovsky 231
    istate->rflags |= RFLAGS_RF;
1074 palkovsky 232
#else
233
    istate->eflags |= EFLAGS_RF;
234
#endif
1072 palkovsky 235
 
236
    dr6 = read_dr6();
237
    for (i=0; i < BKPOINTS_MAX; i++) {
238
        if (dr6 & (1 << i)) {
239
            dr6 &= ~ (1 << i);
240
            write_dr6(dr6);
241
 
242
            handle_exception(i, istate);
243
        }
244
    }
245
}
246
 
247
void breakpoint_del(int slot)
248
{
249
    bpinfo_t *cur;
250
    ipl_t ipl;
251
    __native dr7;
252
 
253
    ipl = interrupts_disable();
254
    spinlock_lock(&bkpoint_lock);
255
 
256
    cur = &breakpoints[slot];
257
    if (!cur->address) {
258
        spinlock_unlock(&bkpoint_lock);
259
        interrupts_restore(ipl);
260
        return;
261
    }
262
 
263
    cur->address = NULL;
264
 
265
    /* Disable breakpoint in DR7 */
266
    dr7 = read_dr7();
267
    dr7 &= ~(0x2 << (slot*2));
268
    write_dr7(dr7);
269
 
270
    spinlock_unlock(&bkpoint_lock);
271
    interrupts_restore(ipl);
272
}
273
 
274
/** Remove breakpoint from table */
275
int cmd_del_breakpoint(cmd_arg_t *argv)
276
{
277
    if (argv->intval < 0 || argv->intval > BKPOINTS_MAX) {
278
        printf("Invalid breakpoint number.\n");
279
        return 0;
280
    }
281
    breakpoint_del(argv->intval);
282
    return 1;
283
}
284
 
285
/** Add new breakpoint to table */
286
static int cmd_add_breakpoint(cmd_arg_t *argv)
287
{
288
    int flags;
289
 
290
    if (argv == &add_argv) {
291
        flags = BKPOINT_INSTR;
292
    } else { /* addwatchp */
293
        flags = BKPOINT_WRITE;
294
    }
295
    printf("Adding breakpoint on address: %p\n", argv->intval);
296
    if (breakpoint_add((void *)argv->intval, flags))
297
        printf("Add breakpoint failed.\n");
298
 
299
    return 1;
300
}
301
 
302
/** Initialize debugger */
303
void debugger_init()
304
{
305
    int i;
306
 
307
    for (i=0; i<BKPOINTS_MAX; i++)
308
        breakpoints[i].address = NULL;
309
 
310
    cmd_initialize(&bkpts_info);
311
    if (!cmd_register(&bkpts_info))
312
        panic("could not register command %s\n", bkpts_info.name);
313
 
314
    cmd_initialize(&delbkpt_info);
315
    if (!cmd_register(&delbkpt_info))
316
        panic("could not register command %s\n", delbkpt_info.name);
317
 
318
    cmd_initialize(&addbkpt_info);
319
    if (!cmd_register(&addbkpt_info))
320
        panic("could not register command %s\n", addbkpt_info.name);
321
 
322
    cmd_initialize(&addwatchp_info);
323
    if (!cmd_register(&addwatchp_info))
324
        panic("could not register command %s\n", addwatchp_info.name);
325
 
326
    exc_register(VECTOR_DEBUG, "debugger",
327
             debug_exception);
328
}