Rev 631 | Rev 673 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 631 | Rev 635 | ||
---|---|---|---|
1 | /* |
1 | /* |
2 | * Copyright (C) 2005 Ondrej Palkovsky |
2 | * Copyright (C) 2005 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 | #include <arch/debugger.h> |
29 | #include <arch/debugger.h> |
30 | #include <memstr.h> |
30 | #include <memstr.h> |
31 | #include <console/kconsole.h> |
31 | #include <console/kconsole.h> |
32 | #include <console/cmd.h> |
32 | #include <console/cmd.h> |
33 | #include <symtab.h> |
33 | #include <symtab.h> |
34 | #include <print.h> |
34 | #include <print.h> |
35 | #include <panic.h> |
35 | #include <panic.h> |
36 | #include <arch.h> |
36 | #include <arch.h> |
37 | #include <arch/cp0.h> |
37 | #include <arch/cp0.h> |
38 | #include <func.h> |
38 | #include <func.h> |
39 | 39 | ||
40 | bpinfo_t breakpoints[BKPOINTS_MAX]; |
40 | bpinfo_t breakpoints[BKPOINTS_MAX]; |
41 | SPINLOCK_INITIALIZE(bkpoint_lock); |
41 | SPINLOCK_INITIALIZE(bkpoint_lock); |
42 | 42 | ||
43 | static int cmd_print_breakpoints(cmd_arg_t *argv); |
43 | static int cmd_print_breakpoints(cmd_arg_t *argv); |
44 | static cmd_info_t pbkpt_info = { |
44 | static cmd_info_t pbkpt_info = { |
45 | .name = "pbkpt", |
45 | .name = "pbkpt", |
46 | .description = "Print breakpoint table.", |
46 | .description = "Print breakpoint table.", |
47 | .func = cmd_print_breakpoints, |
47 | .func = cmd_print_breakpoints, |
48 | .argc = 0, |
48 | .argc = 0, |
49 | }; |
49 | }; |
50 | 50 | ||
51 | static int cmd_del_breakpoint(cmd_arg_t *argv); |
51 | static int cmd_del_breakpoint(cmd_arg_t *argv); |
52 | static cmd_arg_t del_argv = { |
52 | static cmd_arg_t del_argv = { |
53 | .type = ARG_TYPE_INT |
53 | .type = ARG_TYPE_INT |
54 | }; |
54 | }; |
55 | static cmd_info_t delbkpt_info = { |
55 | static cmd_info_t delbkpt_info = { |
56 | .name = "delbkpt", |
56 | .name = "delbkpt", |
57 | .description = "delbkpt <number> - Delete breakpoint.", |
57 | .description = "delbkpt <number> - Delete breakpoint.", |
58 | .func = cmd_del_breakpoint, |
58 | .func = cmd_del_breakpoint, |
59 | .argc = 1, |
59 | .argc = 1, |
60 | .argv = &del_argv |
60 | .argv = &del_argv |
61 | }; |
61 | }; |
62 | 62 | ||
63 | static int cmd_add_breakpoint(cmd_arg_t *argv); |
63 | static int cmd_add_breakpoint(cmd_arg_t *argv); |
64 | static cmd_arg_t add_argv = { |
64 | static cmd_arg_t add_argv = { |
65 | .type = ARG_TYPE_INT |
65 | .type = ARG_TYPE_INT |
66 | }; |
66 | }; |
67 | static cmd_info_t addbkpt_info = { |
67 | static cmd_info_t addbkpt_info = { |
68 | .name = "addbkpt", |
68 | .name = "addbkpt", |
69 | .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch insts unsupported.", |
69 | .description = "addbkpt <&symbol> - new bkpoint. Break on J/Branch insts unsupported.", |
70 | .func = cmd_add_breakpoint, |
70 | .func = cmd_add_breakpoint, |
71 | .argc = 1, |
71 | .argc = 1, |
72 | .argv = &add_argv |
72 | .argv = &add_argv |
73 | }; |
73 | }; |
74 | 74 | ||
- | 75 | static cmd_arg_t adde_argv[] = { |
|
- | 76 | { .type = ARG_TYPE_INT }, |
|
- | 77 | { .type = ARG_TYPE_INT } |
|
- | 78 | }; |
|
- | 79 | static cmd_info_t addbkpte_info = { |
|
- | 80 | .name = "addbkpte", |
|
- | 81 | .description = "addebkpte <&symbol> <&func> - new bkpoint. Call func(or Nothing if 0).", |
|
- | 82 | .func = cmd_add_breakpoint, |
|
- | 83 | .argc = 2, |
|
- | 84 | .argv = adde_argv |
|
- | 85 | }; |
|
- | 86 | ||
- | 87 | static struct { |
|
- | 88 | __u32 andmask; |
|
- | 89 | __u32 value; |
|
- | 90 | }jmpinstr[] = { |
|
- | 91 | {0xf3ff0000, 0x41000000}, /* BCzF */ |
|
- | 92 | {0xf3ff0000, 0x41020000}, /* BCzFL */ |
|
- | 93 | {0xf3ff0000, 0x41010000}, /* BCzT */ |
|
- | 94 | {0xf3ff0000, 0x41030000}, /* BCzTL */ |
|
- | 95 | {0xfc000000, 0x10000000}, /* BEQ */ |
|
- | 96 | {0xfc000000, 0x50000000}, /* BEQL */ |
|
- | 97 | {0xfc1f0000, 0x04010000}, /* BEQL */ |
|
- | 98 | {0xfc1f0000, 0x04110000}, /* BGEZAL */ |
|
- | 99 | {0xfc1f0000, 0x04130000}, /* BGEZALL */ |
|
- | 100 | {0xfc1f0000, 0x04030000}, /* BGEZL */ |
|
- | 101 | {0xfc1f0000, 0x1c000000}, /* BGTZ */ |
|
- | 102 | {0xfc1f0000, 0x5c000000}, /* BGTZL */ |
|
- | 103 | {0xfc1f0000, 0x18000000}, /* BLEZ */ |
|
- | 104 | {0xfc1f0000, 0x58000000}, /* BLEZL */ |
|
- | 105 | {0xfc1f0000, 0x04000000}, /* BLTZ */ |
|
- | 106 | {0xfc1f0000, 0x04100000}, /* BLTZAL */ |
|
- | 107 | {0xfc1f0000, 0x04120000}, /* BLTZALL */ |
|
- | 108 | {0xfc1f0000, 0x04020000}, /* BLTZL */ |
|
- | 109 | {0xfc000000, 0x14000000}, /* BNE */ |
|
- | 110 | {0xfc000000, 0x54000000}, /* BNEL */ |
|
- | 111 | {0xfc000000, 0x08000000}, /* J */ |
|
- | 112 | {0xfc000000, 0x0c000000}, /* JAL */ |
|
- | 113 | {0xfc1f07ff, 0x00000009}, /* JALR */ |
|
- | 114 | {0,0} /* EndOfTable */ |
|
- | 115 | }; |
|
- | 116 | ||
- | 117 | /** Test, if the given instruction is a jump or branch instruction |
|
- | 118 | * |
|
- | 119 | * @param instr Instruction code |
|
- | 120 | * @return true - it is jump instruction, false otherwise |
|
- | 121 | */ |
|
- | 122 | static bool is_jump(__native instr) |
|
- | 123 | { |
|
- | 124 | int i; |
|
- | 125 | ||
- | 126 | for (i=0;jmpinstr[i].andmask;i++) { |
|
- | 127 | if ((instr & jmpinstr[i].andmask) == jmpinstr[i].value) |
|
- | 128 | return true; |
|
- | 129 | } |
|
- | 130 | ||
- | 131 | return false; |
|
- | 132 | } |
|
- | 133 | ||
75 | /** Add new breakpoint to table */ |
134 | /** Add new breakpoint to table */ |
76 | int cmd_add_breakpoint(cmd_arg_t *argv) |
135 | int cmd_add_breakpoint(cmd_arg_t *argv) |
77 | { |
136 | { |
78 | bpinfo_t *cur = NULL; |
137 | bpinfo_t *cur = NULL; |
79 | ipl_t ipl; |
138 | ipl_t ipl; |
80 | int i; |
139 | int i; |
81 | 140 | ||
82 | if (argv->intval & 0x3) { |
141 | if (argv->intval & 0x3) { |
83 | printf("Not aligned instruction, forgot to use &symbol?\n"); |
142 | printf("Not aligned instruction, forgot to use &symbol?\n"); |
84 | return 1; |
143 | return 1; |
85 | } |
144 | } |
86 | ipl = interrupts_disable(); |
145 | ipl = interrupts_disable(); |
87 | spinlock_lock(&bkpoint_lock); |
146 | spinlock_lock(&bkpoint_lock); |
88 | 147 | ||
89 | /* Check, that the breakpoints do not conflict */ |
148 | /* Check, that the breakpoints do not conflict */ |
90 | for (i=0; i<BKPOINTS_MAX; i++) { |
149 | for (i=0; i<BKPOINTS_MAX; i++) { |
91 | if (breakpoints[i].address == (__address)argv->intval) { |
150 | if (breakpoints[i].address == (__address)argv->intval) { |
92 | printf("Duplicate breakpoint %d.\n", i); |
151 | printf("Duplicate breakpoint %d.\n", i); |
93 | spinlock_unlock(&bkpoints_lock); |
152 | spinlock_unlock(&bkpoints_lock); |
94 | return 0; |
153 | return 0; |
95 | } else if (breakpoints[i].address == (__address)argv->intval + sizeof(__native) || \ |
154 | } else if (breakpoints[i].address == (__address)argv->intval + sizeof(__native) || \ |
96 | breakpoints[i].address == (__address)argv->intval - sizeof(__native)) { |
155 | breakpoints[i].address == (__address)argv->intval - sizeof(__native)) { |
97 | printf("Adjacent breakpoints not supported, conflict with %d.\n", i); |
156 | printf("Adjacent breakpoints not supported, conflict with %d.\n", i); |
98 | spinlock_unlock(&bkpoints_lock); |
157 | spinlock_unlock(&bkpoints_lock); |
99 | return 0; |
158 | return 0; |
100 | } |
159 | } |
101 | 160 | ||
102 | } |
161 | } |
103 | 162 | ||
104 | for (i=0; i<BKPOINTS_MAX; i++) |
163 | for (i=0; i<BKPOINTS_MAX; i++) |
105 | if (!breakpoints[i].address) { |
164 | if (!breakpoints[i].address) { |
106 | cur = &breakpoints[i]; |
165 | cur = &breakpoints[i]; |
107 | break; |
166 | break; |
108 | } |
167 | } |
109 | if (!cur) { |
168 | if (!cur) { |
110 | printf("Too many breakpoints.\n"); |
169 | printf("Too many breakpoints.\n"); |
111 | spinlock_unlock(&bkpoint_lock); |
170 | spinlock_unlock(&bkpoint_lock); |
112 | interrupts_restore(ipl); |
171 | interrupts_restore(ipl); |
113 | return 0; |
172 | return 0; |
114 | } |
173 | } |
115 | cur->address = (__address) argv->intval; |
174 | cur->address = (__address) argv->intval; |
116 | printf("Adding breakpoint on address: %p\n", argv->intval); |
175 | printf("Adding breakpoint on address: %p\n", argv->intval); |
117 | cur->instruction = ((__native *)cur->address)[0]; |
176 | cur->instruction = ((__native *)cur->address)[0]; |
118 | cur->nextinstruction = ((__native *)cur->address)[1]; |
177 | cur->nextinstruction = ((__native *)cur->address)[1]; |
- | 178 | if (argv == &add_argv) { |
|
- | 179 | cur->flags = 0; |
|
- | 180 | } else { /* We are add extended */ |
|
- | 181 | cur->flags = BKPOINT_FUNCCALL; |
|
- | 182 | cur->bkfunc = (void (*)(void *, struct exception_regdump *)) argv[1].intval; |
|
- | 183 | } |
|
- | 184 | if (is_jump(cur->instruction)) |
|
- | 185 | cur->flags |= BKPOINT_ONESHOT; |
|
119 | cur->executing = false; |
186 | cur->counter = 0; |
120 | 187 | ||
121 | /* Set breakpoint */ |
188 | /* Set breakpoint */ |
122 | *((__native *)cur->address) = 0x0d; |
189 | *((__native *)cur->address) = 0x0d; |
123 | 190 | ||
124 | spinlock_unlock(&bkpoint_lock); |
191 | spinlock_unlock(&bkpoint_lock); |
125 | interrupts_restore(ipl); |
192 | interrupts_restore(ipl); |
126 | 193 | ||
127 | return 1; |
194 | return 1; |
128 | } |
195 | } |
129 | 196 | ||
- | 197 | ||
- | 198 | ||
130 | /** Remove breakpoint from table */ |
199 | /** Remove breakpoint from table */ |
131 | int cmd_del_breakpoint(cmd_arg_t *argv) |
200 | int cmd_del_breakpoint(cmd_arg_t *argv) |
132 | { |
201 | { |
133 | bpinfo_t *cur; |
202 | bpinfo_t *cur; |
134 | ipl_t ipl; |
203 | ipl_t ipl; |
135 | 204 | ||
136 | if (argv->intval < 0 || argv->intval > BKPOINTS_MAX) { |
205 | if (argv->intval < 0 || argv->intval > BKPOINTS_MAX) { |
137 | printf("Invalid breakpoint number.\n"); |
206 | printf("Invalid breakpoint number.\n"); |
138 | return 0; |
207 | return 0; |
139 | } |
208 | } |
140 | ipl = interrupts_disable(); |
209 | ipl = interrupts_disable(); |
141 | spinlock_lock(&bkpoint_lock); |
210 | spinlock_lock(&bkpoint_lock); |
142 | 211 | ||
143 | cur = &breakpoints[argv->intval]; |
212 | cur = &breakpoints[argv->intval]; |
144 | if (!cur->address) { |
213 | if (!cur->address) { |
145 | printf("Breakpoint does not exist.\n"); |
214 | printf("Breakpoint does not exist.\n"); |
146 | spinlock_unlock(&bkpoint_lock); |
215 | spinlock_unlock(&bkpoint_lock); |
147 | interrupts_restore(ipl); |
216 | interrupts_restore(ipl); |
148 | return 0; |
217 | return 0; |
149 | } |
218 | } |
- | 219 | if ((cur->flags & BKPOINT_INPROG) && (cur->flags & BKPOINT_ONESHOT)) { |
|
- | 220 | printf("Cannot remove one-shot breakpoint in-progress\n"); |
|
- | 221 | spinlock_unlock(&bkpoint_lock); |
|
- | 222 | interrupts_restore(ipl); |
|
- | 223 | return 0; |
|
150 | 224 | } |
|
151 | ((__u32 *)cur->address)[0] = cur->instruction; |
225 | ((__u32 *)cur->address)[0] = cur->instruction; |
152 | ((__u32 *)cur->address)[1] = cur->nextinstruction; |
226 | ((__u32 *)cur->address)[1] = cur->nextinstruction; |
153 | 227 | ||
154 | cur->address = NULL; |
228 | cur->address = NULL; |
155 | 229 | ||
156 | spinlock_unlock(&bkpoint_lock); |
230 | spinlock_unlock(&bkpoint_lock); |
157 | interrupts_restore(ipl); |
231 | interrupts_restore(ipl); |
158 | return 1; |
232 | return 1; |
159 | } |
233 | } |
160 | 234 | ||
161 | /** Print table of active breakpoints */ |
235 | /** Print table of active breakpoints */ |
162 | int cmd_print_breakpoints(cmd_arg_t *argv) |
236 | int cmd_print_breakpoints(cmd_arg_t *argv) |
163 | { |
237 | { |
164 | int i; |
238 | int i; |
165 | char *symbol; |
239 | char *symbol; |
166 | 240 | ||
167 | printf("Breakpoint table.\n"); |
241 | printf("Breakpoint table.\n"); |
168 | for (i=0; i < BKPOINTS_MAX; i++) |
242 | for (i=0; i < BKPOINTS_MAX; i++) |
169 | if (breakpoints[i].address) { |
243 | if (breakpoints[i].address) { |
170 | symbol = get_symtab_entry(breakpoints[i].address); |
244 | symbol = get_symtab_entry(breakpoints[i].address); |
171 | printf("%d. 0x%p in %s\n",i, |
245 | printf("%d. 0x%p in %s\n",i, |
172 | breakpoints[i].address, symbol); |
246 | breakpoints[i].address, symbol); |
- | 247 | printf(" Count(%d) ", breakpoints[i].counter); |
|
- | 248 | if (breakpoints[i].flags & BKPOINT_INPROG) |
|
- | 249 | printf("INPROG "); |
|
- | 250 | if (breakpoints[i].flags & BKPOINT_ONESHOT) |
|
- | 251 | printf("ONESHOT "); |
|
- | 252 | if (breakpoints[i].flags & BKPOINT_FUNCCALL) |
|
- | 253 | printf("FUNCCALL "); |
|
- | 254 | printf("\n"); |
|
173 | } |
255 | } |
174 | return 1; |
256 | return 1; |
175 | } |
257 | } |
176 | 258 | ||
177 | /** Initialize debugger */ |
259 | /** Initialize debugger */ |
178 | void debugger_init() |
260 | void debugger_init() |
179 | { |
261 | { |
180 | int i; |
262 | int i; |
181 | 263 | ||
182 | for (i=0; i<BKPOINTS_MAX; i++) |
264 | for (i=0; i<BKPOINTS_MAX; i++) |
183 | breakpoints[i].address = NULL; |
265 | breakpoints[i].address = NULL; |
184 | 266 | ||
185 | cmd_initialize(&pbkpt_info); |
267 | cmd_initialize(&pbkpt_info); |
186 | if (!cmd_register(&pbkpt_info)) |
268 | if (!cmd_register(&pbkpt_info)) |
187 | panic("could not register command %s\n", pbkpt_info.name); |
269 | panic("could not register command %s\n", pbkpt_info.name); |
188 | 270 | ||
189 | cmd_initialize(&delbkpt_info); |
271 | cmd_initialize(&delbkpt_info); |
190 | if (!cmd_register(&delbkpt_info)) |
272 | if (!cmd_register(&delbkpt_info)) |
191 | panic("could not register command %s\n", delbkpt_info.name); |
273 | panic("could not register command %s\n", delbkpt_info.name); |
192 | 274 | ||
193 | cmd_initialize(&addbkpt_info); |
275 | cmd_initialize(&addbkpt_info); |
194 | if (!cmd_register(&addbkpt_info)) |
276 | if (!cmd_register(&addbkpt_info)) |
195 | panic("could not register command %s\n", addbkpt_info.name); |
277 | panic("could not register command %s\n", addbkpt_info.name); |
- | 278 | ||
- | 279 | cmd_initialize(&addbkpte_info); |
|
- | 280 | if (!cmd_register(&addbkpte_info)) |
|
- | 281 | panic("could not register command %s\n", addbkpte_info.name); |
|
196 | } |
282 | } |
197 | 283 | ||
198 | /** Handle breakpoint |
284 | /** Handle breakpoint |
199 | * |
285 | * |
200 | * Find breakpoint in breakpoint table. |
286 | * Find breakpoint in breakpoint table. |
201 | * If found, call kconsole, set break on next instruction and reexecute. |
287 | * If found, call kconsole, set break on next instruction and reexecute. |
202 | * If we are on "next instruction", set it back on the first and reexecute. |
288 | * If we are on "next instruction", set it back on the first and reexecute. |
203 | * If breakpoint not found in breakpoint table, call kconsole and start |
289 | * If breakpoint not found in breakpoint table, call kconsole and start |
204 | * next instruction. |
290 | * next instruction. |
205 | */ |
291 | */ |
206 | void debugger_bpoint(struct exception_regdump *pstate) |
292 | void debugger_bpoint(struct exception_regdump *pstate) |
207 | { |
293 | { |
208 | char *symbol; |
- | |
209 | bpinfo_t *cur = NULL; |
294 | bpinfo_t *cur = NULL; |
- | 295 | __address fireaddr = pstate->epc; |
|
210 | int i; |
296 | int i; |
211 | 297 | ||
212 | symbol = get_symtab_entry(pstate->epc); |
- | |
213 | - | ||
214 | - | ||
215 | /* test branch delay slot */ |
298 | /* test branch delay slot */ |
216 | if (cp0_cause_read() & 0x80000000) |
299 | if (cp0_cause_read() & 0x80000000) |
217 | panic("Breakpoint in branch delay slot not supported.\n"); |
300 | panic("Breakpoint in branch delay slot not supported.\n"); |
218 | 301 | ||
219 | spinlock_lock(&bkpoint_lock); |
302 | spinlock_lock(&bkpoint_lock); |
220 | for (i=0; i<BKPOINTS_MAX; i++) { |
303 | for (i=0; i<BKPOINTS_MAX; i++) { |
221 | if (pstate->epc == breakpoints[i].address || \ |
304 | /* Normal breakpoint */ |
222 | (pstate->epc == breakpoints[i].address+sizeof(__native) &&\ |
305 | if (fireaddr == breakpoints[i].address \ |
223 | breakpoints[i].executing)) |
306 | && !(breakpoints[i].flags & BKPOINT_REINST)) { |
224 | cur = &breakpoints[i]; |
307 | cur = &breakpoints[i]; |
225 | break; |
308 | break; |
- | 309 | } |
|
- | 310 | /* Reinst only breakpoint */ |
|
- | 311 | if ((breakpoints[i].flags & BKPOINT_REINST) \ |
|
- | 312 | && (fireaddr ==breakpoints[i].address+sizeof(__native))) { |
|
- | 313 | cur = &breakpoints[i]; |
|
- | 314 | break; |
|
226 | 315 | } |
|
227 | } |
316 | } |
228 | if (cur) { |
317 | if (cur) { |
229 | if ((cur->executing && pstate->epc==cur->address) || |
- | |
230 | (!cur->executing && pstate->epc==cur->address+sizeof(__native))) |
- | |
231 | panic("Weird breakpoint state.\n"); |
- | |
232 | if (!cur->executing) { |
318 | if (cur->flags & BKPOINT_REINST) { |
233 | printf("***Breakpoint %d: 0x%p in %s.\n", i, |
- | |
234 | pstate->epc,symbol); |
- | |
235 | /* Return first instruction back */ |
- | |
236 | ((__u32 *)cur->address)[0] = cur->instruction; |
- | |
237 | /* Set Breakpoint on second */ |
- | |
238 | ((__u32 *)cur->address)[1] = 0x0d; |
- | |
239 | cur->executing = true; |
- | |
240 | } else { |
- | |
241 | /* Set breakpoint on first instruction */ |
319 | /* Set breakpoint on first instruction */ |
242 | ((__u32 *)cur->address)[0] = 0x0d; |
320 | ((__u32 *)cur->address)[0] = 0x0d; |
243 | /* Return back the second */ |
321 | /* Return back the second */ |
244 | ((__u32 *)cur->address)[1] = cur->nextinstruction; |
322 | ((__u32 *)cur->address)[1] = cur->nextinstruction; |
245 | cur->executing = false; |
323 | cur->flags &= ~BKPOINT_REINST; |
246 | spinlock_unlock(&bkpoint_lock); |
324 | spinlock_unlock(&bkpoint_lock); |
247 | return; |
325 | return; |
248 | } |
326 | } |
- | 327 | if (cur->flags & BKPOINT_INPROG) |
|
- | 328 | printf("Warning: breakpoint recursion\n"); |
|
- | 329 | ||
- | 330 | if (!(cur->flags & BKPOINT_FUNCCALL)) |
|
- | 331 | printf("***Breakpoint %d: 0x%p in %s.\n", i, |
|
- | 332 | fireaddr, get_symtab_entry(pstate->epc)); |
|
- | 333 | ||
- | 334 | /* Return first instruction back */ |
|
- | 335 | ((__u32 *)cur->address)[0] = cur->instruction; |
|
- | 336 | ||
- | 337 | if (! (cur->flags & BKPOINT_ONESHOT)) { |
|
- | 338 | /* Set Breakpoint on next instruction */ |
|
- | 339 | ((__u32 *)cur->address)[1] = 0x0d; |
|
- | 340 | cur->flags |= BKPOINT_REINST; |
|
- | 341 | } |
|
- | 342 | cur->flags |= BKPOINT_INPROG; |
|
249 | } else { |
343 | } else { |
250 | printf("***Breakpoint 0x%p in %s.\n", pstate->epc, symbol); |
344 | printf("***Breakpoint 0x%p in %s.\n", fireaddr, |
- | 345 | get_symtab_entry(fireaddr)); |
|
251 | /* Move on to next instruction */ |
346 | /* Move on to next instruction */ |
252 | pstate->epc += 4; |
347 | pstate->epc += 4; |
253 | } |
348 | } |
- | 349 | ||
- | 350 | cur->counter++; |
|
- | 351 | if (cur && (cur->flags & BKPOINT_FUNCCALL)) { |
|
- | 352 | /* Allow zero bkfunc, just for counting */ |
|
- | 353 | if (cur->bkfunc) |
|
- | 354 | cur->bkfunc(cur, pstate); |
|
- | 355 | } else { |
|
- | 356 | printf("***Type 'exit' to exit kconsole.\n"); |
|
- | 357 | /* This disables all other processors - we are not SMP, |
|
- | 358 | * actually this gets us to cpu_halt, if scheduler() is run |
|
- | 359 | * - we generally do not want scheduler to be run from debug, |
|
- | 360 | * so this is a good idea |
|
- | 361 | */ |
|
- | 362 | atomic_set(&haltstate,1); |
|
254 | spinlock_unlock(&bkpoint_lock); |
363 | spinlock_unlock(&bkpoint_lock); |
255 | 364 | ||
- | 365 | kconsole("debug"); |
|
- | 366 | ||
- | 367 | spinlock_lock(&bkpoint_lock); |
|
- | 368 | atomic_set(&haltstate,0); |
|
256 | 369 | } |
|
- | 370 | ||
257 | printf("***Type 'exit' to exit kconsole.\n"); |
371 | if (cur && cur->address == fireaddr && (cur->flags & BKPOINT_INPROG)) { |
258 | /* Umm..we should rather set some 'debugstate' here */ |
372 | /* Remove one-shot breakpoint */ |
- | 373 | if ((cur->flags & BKPOINT_ONESHOT)) |
|
259 | atomic_set(&haltstate,1); |
374 | cur->address = NULL; |
260 | kconsole("debug"); |
375 | /* Remove in-progress flag */ |
- | 376 | cur->flags &= ~BKPOINT_INPROG; |
|
- | 377 | } |
|
261 | atomic_set(&haltstate,0); |
378 | spinlock_unlock(&bkpoint_lock); |
262 | } |
379 | } |
263 | 380 |