Subversion Repositories HelenOS

Rev

Rev 4377 | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

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