Subversion Repositories HelenOS

Rev

Rev 615 | Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
614 palkovsky 1
/*
2
 * Copyright (C) 2005 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 <memstr.h>
31
#include <console/kconsole.h>
32
#include <console/cmd.h>
33
#include <symtab.h>
34
#include <print.h>
35
#include <panic.h>
36
#include <arch.h>
37
#include <arch/cp0.h>
38
#include <func.h>
39
 
40
bpinfo_t breakpoints[BKPOINTS_MAX];
41
spinlock_t bkpoint_lock;
42
 
43
static int cmd_print_breakpoints(cmd_arg_t *argv);
44
static cmd_info_t pbkpt_info = {
45
    .name = "pbkpt",
46
    .description = "Print breakpoint table.",
47
    .func = cmd_print_breakpoints,
48
    .argc = 0,
49
};
50
 
51
static int cmd_del_breakpoint(cmd_arg_t *argv);
52
static cmd_arg_t del_argv = {
53
    .type = ARG_TYPE_INT
54
};
55
static cmd_info_t delbkpt_info = {
56
    .name = "delbkpt",
57
    .description = "delbkpt <number> - Delete breakpoint.",
58
    .func = cmd_del_breakpoint,
59
    .argc = 1,
60
    .argv = &del_argv
61
};
62
 
63
static int cmd_add_breakpoint(cmd_arg_t *argv);
64
static cmd_arg_t add_argv = {
65
    .type = ARG_TYPE_INT
66
};
67
static cmd_info_t addbkpt_info = {
68
    .name = "addbkpt",
69
    .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch insts unsupported.",
70
    .func = cmd_add_breakpoint,
71
    .argc = 1,
72
    .argv = &add_argv
73
};
74
 
75
/** Add new breakpoint to table */
76
int cmd_add_breakpoint(cmd_arg_t *argv)
77
{
78
    bpinfo_t *cur = NULL;
79
    ipl_t ipl;
80
    int i;
81
 
82
    if (argv->intval & 0x3) {
83
        printf("Not aligned instruction, forgot to use &symbol?\n");
84
        return 1;
85
    }
86
    ipl = interrupts_disable();
87
    spinlock_lock(&bkpoint_lock);
88
 
89
    /* Check, that the breakpoints do not conflict */
90
    for (i=0; i<BKPOINTS_MAX; i++) {
91
        if (breakpoints[i].address == (__address)argv->intval) {
92
            printf("Duplicate breakpoint %d.\n", i);
93
            spinlock_unlock(&bkpoints_lock);
94
            return 0;
95
        } else if (breakpoints[i].address == (__address)argv->intval + sizeof(__native) || \
96
               breakpoints[i].address == (__address)argv->intval - sizeof(__native)) {
97
            printf("Adjacent breakpoints not supported, conflict with %d.\n", i);
98
            spinlock_unlock(&bkpoints_lock);
99
            return 0;
100
        }
101
 
102
    }
103
 
104
    for (i=0; i<BKPOINTS_MAX; i++)
105
        if (!breakpoints[i].address) {
106
            cur = &breakpoints[i];
107
            break;
108
        }
109
    if (!cur) {
110
        printf("Too many breakpoints.\n");
111
        spinlock_unlock(&bkpoint_lock);
112
        interrupts_restore(ipl);
113
        return 0;
114
    }
115
    cur->address = (__address) argv->intval;
116
    printf("Adding breakpoint on address: %p\n", argv->intval);
117
    cur->instruction = ((__native *)cur->address)[0];
118
    cur->nextinstruction = ((__native *)cur->address)[1];
119
    cur->executing = false;
120
 
121
    /* Set breakpoint */
122
    *((__native *)cur->address) = 0x0d;
123
 
124
    spinlock_unlock(&bkpoint_lock);
125
    interrupts_restore(ipl);
126
 
127
    return 1;
128
}
129
 
130
/** Remove breakpoint from table */
131
int cmd_del_breakpoint(cmd_arg_t *argv)
132
{
133
    bpinfo_t *cur;
134
    ipl_t ipl;
135
 
136
    if (argv->intval < 0 || argv->intval > BKPOINTS_MAX) {
137
        printf("Invalid breakpoint number.\n");
138
        return 0;
139
    }
140
    ipl = interrupts_disable();
141
    spinlock_lock(&bkpoint_lock);
142
 
143
    cur = &breakpoints[argv->intval];
144
    if (!cur->address) {
145
        printf("Breakpoint does not exist.\n");
146
        spinlock_unlock(&bkpoint_lock);
147
        interrupts_restore(ipl);
148
        return 0;
149
    }
150
 
151
    ((__u32 *)cur->address)[0] = cur->instruction;
152
    ((__u32 *)cur->address)[1] = cur->nextinstruction;
153
 
154
    cur->address = NULL;
155
 
156
    spinlock_unlock(&bkpoint_lock);
157
    interrupts_restore(ipl);
158
    return 1;
159
}
160
 
161
/** Print table of active breakpoints */
162
int cmd_print_breakpoints(cmd_arg_t *argv)
163
{
164
    int i;
165
    char *symbol;
166
 
167
    printf("Breakpoint table.\n");
168
    for (i=0; i < BKPOINTS_MAX; i++)
169
        if (breakpoints[i].address) {
170
            symbol = get_symtab_entry(breakpoints[i].address);
171
            printf("%d. 0x%p in %s\n",i,
172
                   breakpoints[i].address, symbol);
173
        }
174
    return 1;
175
}
176
 
177
/** Initialize debugger */
178
void debugger_init()
179
{
180
    int i;
181
 
182
    for (i=0; i<BKPOINTS_MAX; i++)
183
        breakpoints[i].address = NULL;
184
    spinlock_initialize(&bkpoint_lock, "breakpoint_lock");
185
 
186
    cmd_initialize(&pbkpt_info);
187
    if (!cmd_register(&pbkpt_info))
188
        panic("could not register command %s\n", pbkpt_info.name);
189
 
190
    cmd_initialize(&delbkpt_info);
191
    if (!cmd_register(&delbkpt_info))
192
        panic("could not register command %s\n", delbkpt_info.name);
193
 
194
    cmd_initialize(&addbkpt_info);
195
    if (!cmd_register(&addbkpt_info))
196
        panic("could not register command %s\n", addbkpt_info.name);
197
}
198
 
199
/** Handle breakpoint
200
 *
201
 * Find breakpoint in breakpoint table.
202
 * If found, call kconsole, set break on next instruction and reexecute.
203
 * If we are on "next instruction", set it back on the first and reexecute.
204
 * If breakpoint not found in breakpoint table, call kconsole and start
205
 * next instruction.
206
 */
207
void debugger_bpoint(struct exception_regdump *pstate)
208
{
209
    char *symbol;
210
    bpinfo_t *cur = NULL;
211
    int i;
212
 
213
    symbol = get_symtab_entry(pstate->epc);
214
 
215
 
216
    /* test branch delay slot */
217
    if (cp0_cause_read() & 0x80000000)
218
        panic("Breakpoint in branch delay slot not supported.\n");
219
 
220
    spinlock_lock(&bkpoint_lock);
221
    for (i=0; i<BKPOINTS_MAX; i++) {
222
        if (pstate->epc == breakpoints[i].address || \
223
            (pstate->epc == breakpoints[i].address+sizeof(__native) &&\
224
             breakpoints[i].executing))
225
            cur = &breakpoints[i];
226
        break;
227
 
228
    }
229
    if (cur) {
230
        if ((cur->executing && pstate->epc==cur->address) ||
231
            (!cur->executing && pstate->epc==cur->address+sizeof(__native)))
232
            panic("Weird breakpoint state.\n");
233
        if (!cur->executing) {
234
            printf("***Breakpoint %d: %p in %s.\n", i,
235
                   pstate->epc,symbol);
236
            /* Return first instruction back */
237
            ((__u32 *)cur->address)[0] = cur->instruction;
238
            /* Set Breakpoint on second */
239
            ((__u32 *)cur->address)[1] = 0x0d;
240
            cur->executing = true;
241
        } else {
242
            /* Set breakpoint on first instruction */
243
            ((__u32 *)cur->address)[0] = 0x0d;
244
            /* Return back the second */
245
            ((__u32 *)cur->address)[1] = cur->nextinstruction;
246
            cur->executing = false;
247
            spinlock_unlock(&bkpoint_lock);
248
            return;
249
        }
250
    } else {
251
        printf("***Breakpoint %p in %s.\n", pstate->epc, symbol);
252
        /* Move on to next instruction */
253
        pstate->epc += 4;
254
    }
255
    spinlock_unlock(&bkpoint_lock);
256
 
257
 
258
    printf("***Type 'exit' to exit kconsole.\n");
259
    /* Umm..we should rather set some 'debugstate' here */
260
    haltstate = 1;
261
    kconsole("debug");
262
    haltstate = 0;
263
}