Branch data Line data Source code
1 : : /*
2 : : * Kernel Debug Core
3 : : *
4 : : * Maintainer: Jason Wessel <jason.wessel@windriver.com>
5 : : *
6 : : * Copyright (C) 2000-2001 VERITAS Software Corporation.
7 : : * Copyright (C) 2002-2004 Timesys Corporation
8 : : * Copyright (C) 2003-2004 Amit S. Kale <amitkale@linsyssoft.com>
9 : : * Copyright (C) 2004 Pavel Machek <pavel@ucw.cz>
10 : : * Copyright (C) 2004-2006 Tom Rini <trini@kernel.crashing.org>
11 : : * Copyright (C) 2004-2006 LinSysSoft Technologies Pvt. Ltd.
12 : : * Copyright (C) 2005-2009 Wind River Systems, Inc.
13 : : * Copyright (C) 2007 MontaVista Software, Inc.
14 : : * Copyright (C) 2008 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
15 : : *
16 : : * Contributors at various stages not listed above:
17 : : * Jason Wessel ( jason.wessel@windriver.com )
18 : : * George Anzinger <george@mvista.com>
19 : : * Anurekh Saxena (anurekh.saxena@timesys.com)
20 : : * Lake Stevens Instrument Division (Glenn Engel)
21 : : * Jim Kingdon, Cygnus Support.
22 : : *
23 : : * Original KGDB stub: David Grothe <dave@gcom.com>,
24 : : * Tigran Aivazian <tigran@sco.com>
25 : : *
26 : : * This file is licensed under the terms of the GNU General Public License
27 : : * version 2. This program is licensed "as is" without any warranty of any
28 : : * kind, whether express or implied.
29 : : */
30 : :
31 : : #define pr_fmt(fmt) "KGDB: " fmt
32 : :
33 : : #include <linux/pid_namespace.h>
34 : : #include <linux/clocksource.h>
35 : : #include <linux/serial_core.h>
36 : : #include <linux/interrupt.h>
37 : : #include <linux/spinlock.h>
38 : : #include <linux/console.h>
39 : : #include <linux/threads.h>
40 : : #include <linux/uaccess.h>
41 : : #include <linux/kernel.h>
42 : : #include <linux/module.h>
43 : : #include <linux/ptrace.h>
44 : : #include <linux/string.h>
45 : : #include <linux/delay.h>
46 : : #include <linux/sched.h>
47 : : #include <linux/sysrq.h>
48 : : #include <linux/reboot.h>
49 : : #include <linux/init.h>
50 : : #include <linux/kgdb.h>
51 : : #include <linux/kdb.h>
52 : : #include <linux/nmi.h>
53 : : #include <linux/pid.h>
54 : : #include <linux/smp.h>
55 : : #include <linux/mm.h>
56 : : #include <linux/vmacache.h>
57 : : #include <linux/rcupdate.h>
58 : : #include <linux/irq.h>
59 : :
60 : : #include <asm/cacheflush.h>
61 : : #include <asm/byteorder.h>
62 : : #include <linux/atomic.h>
63 : :
64 : : #include "debug_core.h"
65 : :
66 : : static int kgdb_break_asap;
67 : :
68 : : struct debuggerinfo_struct kgdb_info[NR_CPUS];
69 : :
70 : : /**
71 : : * kgdb_connected - Is a host GDB connected to us?
72 : : */
73 : : int kgdb_connected;
74 : : EXPORT_SYMBOL_GPL(kgdb_connected);
75 : :
76 : : /* All the KGDB handlers are installed */
77 : : int kgdb_io_module_registered;
78 : :
79 : : /* Guard for recursive entry */
80 : : static int exception_level;
81 : :
82 : : struct kgdb_io *dbg_io_ops;
83 : : static DEFINE_SPINLOCK(kgdb_registration_lock);
84 : :
85 : : /* Action for the reboot notifiter, a global allow kdb to change it */
86 : : static int kgdbreboot;
87 : : /* kgdb console driver is loaded */
88 : : static int kgdb_con_registered;
89 : : /* determine if kgdb console output should be used */
90 : : static int kgdb_use_con;
91 : : /* Flag for alternate operations for early debugging */
92 : : bool dbg_is_early = true;
93 : : /* Next cpu to become the master debug core */
94 : : int dbg_switch_cpu;
95 : :
96 : : /* Use kdb or gdbserver mode */
97 : : int dbg_kdb_mode = 1;
98 : :
99 : 0 : static int __init opt_kgdb_con(char *str)
100 : : {
101 : 0 : kgdb_use_con = 1;
102 : 0 : return 0;
103 : : }
104 : :
105 : : early_param("kgdbcon", opt_kgdb_con);
106 : :
107 : : module_param(kgdb_use_con, int, 0644);
108 : : module_param(kgdbreboot, int, 0644);
109 : :
110 : : /*
111 : : * Holds information about breakpoints in a kernel. These breakpoints are
112 : : * added and removed by gdb.
113 : : */
114 : : static struct kgdb_bkpt kgdb_break[KGDB_MAX_BREAKPOINTS] = {
115 : : [0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
116 : : };
117 : :
118 : : /*
119 : : * The CPU# of the active CPU, or -1 if none:
120 : : */
121 : : atomic_t kgdb_active = ATOMIC_INIT(-1);
122 : : EXPORT_SYMBOL_GPL(kgdb_active);
123 : : static DEFINE_RAW_SPINLOCK(dbg_master_lock);
124 : : static DEFINE_RAW_SPINLOCK(dbg_slave_lock);
125 : :
126 : : /*
127 : : * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
128 : : * bootup code (which might not have percpu set up yet):
129 : : */
130 : : static atomic_t masters_in_kgdb;
131 : : static atomic_t slaves_in_kgdb;
132 : : static atomic_t kgdb_break_tasklet_var;
133 : : atomic_t kgdb_setting_breakpoint;
134 : :
135 : : struct task_struct *kgdb_usethread;
136 : : struct task_struct *kgdb_contthread;
137 : :
138 : : int kgdb_single_step;
139 : : static pid_t kgdb_sstep_pid;
140 : :
141 : : /* to keep track of the CPU which is doing the single stepping*/
142 : : atomic_t kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
143 : :
144 : : /*
145 : : * If you are debugging a problem where roundup (the collection of
146 : : * all other CPUs) is a problem [this should be extremely rare],
147 : : * then use the nokgdbroundup option to avoid roundup. In that case
148 : : * the other CPUs might interfere with your debugging context, so
149 : : * use this with care:
150 : : */
151 : : static int kgdb_do_roundup = 1;
152 : :
153 : 0 : static int __init opt_nokgdbroundup(char *str)
154 : : {
155 : 0 : kgdb_do_roundup = 0;
156 : :
157 : 0 : return 0;
158 : : }
159 : :
160 : : early_param("nokgdbroundup", opt_nokgdbroundup);
161 : :
162 : : /*
163 : : * Finally, some KGDB code :-)
164 : : */
165 : :
166 : : /*
167 : : * Weak aliases for breakpoint management,
168 : : * can be overriden by architectures when needed:
169 : : */
170 : 0 : int __weak kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
171 : : {
172 : : int err;
173 : :
174 : 0 : err = probe_kernel_read(bpt->saved_instr, (char *)bpt->bpt_addr,
175 : : BREAK_INSTR_SIZE);
176 : 0 : if (err)
177 : : return err;
178 : 0 : err = probe_kernel_write((char *)bpt->bpt_addr,
179 : : arch_kgdb_ops.gdb_bpt_instr, BREAK_INSTR_SIZE);
180 : 0 : return err;
181 : : }
182 : :
183 : 0 : int __weak kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt)
184 : : {
185 : 0 : return probe_kernel_write((char *)bpt->bpt_addr,
186 : 0 : (char *)bpt->saved_instr, BREAK_INSTR_SIZE);
187 : : }
188 : :
189 : 0 : int __weak kgdb_validate_break_address(unsigned long addr)
190 : : {
191 : : struct kgdb_bkpt tmp;
192 : : int err;
193 : : /* Validate setting the breakpoint and then removing it. If the
194 : : * remove fails, the kernel needs to emit a bad message because we
195 : : * are deep trouble not being able to put things back the way we
196 : : * found them.
197 : : */
198 : 0 : tmp.bpt_addr = addr;
199 : 0 : err = kgdb_arch_set_breakpoint(&tmp);
200 : 0 : if (err)
201 : : return err;
202 : 0 : err = kgdb_arch_remove_breakpoint(&tmp);
203 : 0 : if (err)
204 : 0 : pr_err("Critical breakpoint error, kernel memory destroyed at: %lx\n",
205 : : addr);
206 : 0 : return err;
207 : : }
208 : :
209 : 0 : unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
210 : : {
211 : 0 : return instruction_pointer(regs);
212 : : }
213 : :
214 : 0 : int __weak kgdb_arch_init(void)
215 : : {
216 : 0 : return 0;
217 : : }
218 : :
219 : 0 : int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
220 : : {
221 : 0 : return 0;
222 : : }
223 : :
224 : : #ifdef CONFIG_SMP
225 : :
226 : : /*
227 : : * Default (weak) implementation for kgdb_roundup_cpus
228 : : */
229 : :
230 : : static DEFINE_PER_CPU(call_single_data_t, kgdb_roundup_csd);
231 : :
232 : 0 : void __weak kgdb_call_nmi_hook(void *ignored)
233 : : {
234 : : /*
235 : : * NOTE: get_irq_regs() is supposed to get the registers from
236 : : * before the IPI interrupt happened and so is supposed to
237 : : * show where the processor was. In some situations it's
238 : : * possible we might be called without an IPI, so it might be
239 : : * safer to figure out how to make kgdb_breakpoint() work
240 : : * properly here.
241 : : */
242 : 0 : kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
243 : 0 : }
244 : :
245 : 0 : void __weak kgdb_roundup_cpus(void)
246 : : {
247 : : call_single_data_t *csd;
248 : 0 : int this_cpu = raw_smp_processor_id();
249 : : int cpu;
250 : : int ret;
251 : :
252 : 0 : for_each_online_cpu(cpu) {
253 : : /* No need to roundup ourselves */
254 : 0 : if (cpu == this_cpu)
255 : 0 : continue;
256 : :
257 : 0 : csd = &per_cpu(kgdb_roundup_csd, cpu);
258 : :
259 : : /*
260 : : * If it didn't round up last time, don't try again
261 : : * since smp_call_function_single_async() will block.
262 : : *
263 : : * If rounding_up is false then we know that the
264 : : * previous call must have at least started and that
265 : : * means smp_call_function_single_async() won't block.
266 : : */
267 : 0 : if (kgdb_info[cpu].rounding_up)
268 : 0 : continue;
269 : 0 : kgdb_info[cpu].rounding_up = true;
270 : :
271 : 0 : csd->func = kgdb_call_nmi_hook;
272 : 0 : ret = smp_call_function_single_async(cpu, csd);
273 : 0 : if (ret)
274 : 0 : kgdb_info[cpu].rounding_up = false;
275 : : }
276 : 0 : }
277 : :
278 : : #endif
279 : :
280 : : /*
281 : : * Some architectures need cache flushes when we set/clear a
282 : : * breakpoint:
283 : : */
284 : 0 : static void kgdb_flush_swbreak_addr(unsigned long addr)
285 : : {
286 : : if (!CACHE_FLUSH_IS_SAFE)
287 : 0 : return;
288 : :
289 : 0 : if (current->mm) {
290 : : int i;
291 : :
292 : 0 : for (i = 0; i < VMACACHE_SIZE; i++) {
293 : 0 : if (!current->vmacache.vmas[i])
294 : 0 : continue;
295 : 0 : flush_cache_range(current->vmacache.vmas[i],
296 : : addr, addr + BREAK_INSTR_SIZE);
297 : : }
298 : : }
299 : :
300 : : /* Force flush instruction cache if it was outside the mm */
301 : 0 : flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
302 : : }
303 : :
304 : : /*
305 : : * SW breakpoint management:
306 : : */
307 : 0 : int dbg_activate_sw_breakpoints(void)
308 : : {
309 : : int error;
310 : : int ret = 0;
311 : : int i;
312 : :
313 : 0 : for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
314 : 0 : if (kgdb_break[i].state != BP_SET)
315 : 0 : continue;
316 : :
317 : 0 : error = kgdb_arch_set_breakpoint(&kgdb_break[i]);
318 : 0 : if (error) {
319 : : ret = error;
320 : 0 : pr_info("BP install failed: %lx\n",
321 : : kgdb_break[i].bpt_addr);
322 : 0 : continue;
323 : : }
324 : :
325 : 0 : kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
326 : 0 : kgdb_break[i].state = BP_ACTIVE;
327 : : }
328 : 0 : return ret;
329 : : }
330 : :
331 : 0 : int dbg_set_sw_break(unsigned long addr)
332 : : {
333 : 0 : int err = kgdb_validate_break_address(addr);
334 : : int breakno = -1;
335 : : int i;
336 : :
337 : 0 : if (err)
338 : : return err;
339 : :
340 : 0 : for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
341 : 0 : if ((kgdb_break[i].state == BP_SET) &&
342 : 0 : (kgdb_break[i].bpt_addr == addr))
343 : : return -EEXIST;
344 : : }
345 : 0 : for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
346 : 0 : if (kgdb_break[i].state == BP_REMOVED &&
347 : 0 : kgdb_break[i].bpt_addr == addr) {
348 : 0 : breakno = i;
349 : 0 : break;
350 : : }
351 : : }
352 : :
353 : 0 : if (breakno == -1) {
354 : 0 : for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
355 : 0 : if (kgdb_break[i].state == BP_UNDEFINED) {
356 : 0 : breakno = i;
357 : 0 : break;
358 : : }
359 : : }
360 : : }
361 : :
362 : 0 : if (breakno == -1)
363 : : return -E2BIG;
364 : :
365 : 0 : kgdb_break[breakno].state = BP_SET;
366 : 0 : kgdb_break[breakno].type = BP_BREAKPOINT;
367 : 0 : kgdb_break[breakno].bpt_addr = addr;
368 : :
369 : 0 : return 0;
370 : : }
371 : :
372 : 0 : int dbg_deactivate_sw_breakpoints(void)
373 : : {
374 : : int error;
375 : : int ret = 0;
376 : : int i;
377 : :
378 : 0 : for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
379 : 0 : if (kgdb_break[i].state != BP_ACTIVE)
380 : 0 : continue;
381 : 0 : error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
382 : 0 : if (error) {
383 : 0 : pr_info("BP remove failed: %lx\n",
384 : : kgdb_break[i].bpt_addr);
385 : : ret = error;
386 : : }
387 : :
388 : 0 : kgdb_flush_swbreak_addr(kgdb_break[i].bpt_addr);
389 : 0 : kgdb_break[i].state = BP_SET;
390 : : }
391 : 0 : return ret;
392 : : }
393 : :
394 : 0 : int dbg_remove_sw_break(unsigned long addr)
395 : : {
396 : : int i;
397 : :
398 : 0 : for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
399 : 0 : if ((kgdb_break[i].state == BP_SET) &&
400 : 0 : (kgdb_break[i].bpt_addr == addr)) {
401 : 0 : kgdb_break[i].state = BP_REMOVED;
402 : 0 : return 0;
403 : : }
404 : : }
405 : : return -ENOENT;
406 : : }
407 : :
408 : 0 : int kgdb_isremovedbreak(unsigned long addr)
409 : : {
410 : : int i;
411 : :
412 : 0 : for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
413 : 0 : if ((kgdb_break[i].state == BP_REMOVED) &&
414 : 0 : (kgdb_break[i].bpt_addr == addr))
415 : : return 1;
416 : : }
417 : : return 0;
418 : : }
419 : :
420 : 0 : int dbg_remove_all_break(void)
421 : : {
422 : : int error;
423 : : int i;
424 : :
425 : : /* Clear memory breakpoints. */
426 : 0 : for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
427 : 0 : if (kgdb_break[i].state != BP_ACTIVE)
428 : : goto setundefined;
429 : 0 : error = kgdb_arch_remove_breakpoint(&kgdb_break[i]);
430 : 0 : if (error)
431 : 0 : pr_err("breakpoint remove failed: %lx\n",
432 : : kgdb_break[i].bpt_addr);
433 : : setundefined:
434 : 0 : kgdb_break[i].state = BP_UNDEFINED;
435 : : }
436 : :
437 : : /* Clear hardware breakpoints. */
438 : 0 : if (arch_kgdb_ops.remove_all_hw_break)
439 : 0 : arch_kgdb_ops.remove_all_hw_break();
440 : :
441 : 0 : return 0;
442 : : }
443 : :
444 : : /*
445 : : * Return true if there is a valid kgdb I/O module. Also if no
446 : : * debugger is attached a message can be printed to the console about
447 : : * waiting for the debugger to attach.
448 : : *
449 : : * The print_wait argument is only to be true when called from inside
450 : : * the core kgdb_handle_exception, because it will wait for the
451 : : * debugger to attach.
452 : : */
453 : 0 : static int kgdb_io_ready(int print_wait)
454 : : {
455 : 0 : if (!dbg_io_ops)
456 : : return 0;
457 : 0 : if (kgdb_connected)
458 : : return 1;
459 : 0 : if (atomic_read(&kgdb_setting_breakpoint))
460 : : return 1;
461 : 0 : if (print_wait) {
462 : : #ifdef CONFIG_KGDB_KDB
463 : 0 : if (!dbg_kdb_mode)
464 : 0 : pr_crit("waiting... or $3#33 for KDB\n");
465 : : #else
466 : : pr_crit("Waiting for remote debugger\n");
467 : : #endif
468 : : }
469 : : return 1;
470 : : }
471 : :
472 : 0 : static int kgdb_reenter_check(struct kgdb_state *ks)
473 : : {
474 : : unsigned long addr;
475 : :
476 : 0 : if (atomic_read(&kgdb_active) != raw_smp_processor_id())
477 : : return 0;
478 : :
479 : : /* Panic on recursive debugger calls: */
480 : 0 : exception_level++;
481 : 0 : addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
482 : 0 : dbg_deactivate_sw_breakpoints();
483 : :
484 : : /*
485 : : * If the break point removed ok at the place exception
486 : : * occurred, try to recover and print a warning to the end
487 : : * user because the user planted a breakpoint in a place that
488 : : * KGDB needs in order to function.
489 : : */
490 : 0 : if (dbg_remove_sw_break(addr) == 0) {
491 : 0 : exception_level = 0;
492 : 0 : kgdb_skipexception(ks->ex_vector, ks->linux_regs);
493 : 0 : dbg_activate_sw_breakpoints();
494 : 0 : pr_crit("re-enter error: breakpoint removed %lx\n", addr);
495 : 0 : WARN_ON_ONCE(1);
496 : :
497 : : return 1;
498 : : }
499 : 0 : dbg_remove_all_break();
500 : 0 : kgdb_skipexception(ks->ex_vector, ks->linux_regs);
501 : :
502 : 0 : if (exception_level > 1) {
503 : 0 : dump_stack();
504 : 0 : kgdb_io_module_registered = false;
505 : 0 : panic("Recursive entry to debugger");
506 : : }
507 : :
508 : 0 : pr_crit("re-enter exception: ALL breakpoints killed\n");
509 : : #ifdef CONFIG_KGDB_KDB
510 : : /* Allow kdb to debug itself one level */
511 : 0 : return 0;
512 : : #endif
513 : : dump_stack();
514 : : panic("Recursive entry to debugger");
515 : :
516 : : return 1;
517 : : }
518 : :
519 : : static void dbg_touch_watchdogs(void)
520 : : {
521 : : touch_softlockup_watchdog_sync();
522 : 0 : clocksource_touch_watchdog();
523 : 0 : rcu_cpu_stall_reset();
524 : : }
525 : :
526 : 0 : static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,
527 : : int exception_state)
528 : : {
529 : : unsigned long flags;
530 : : int sstep_tries = 100;
531 : : int error;
532 : : int cpu;
533 : : int trace_on = 0;
534 : 0 : int online_cpus = num_online_cpus();
535 : : u64 time_left;
536 : :
537 : 0 : kgdb_info[ks->cpu].enter_kgdb++;
538 : 0 : kgdb_info[ks->cpu].exception_state |= exception_state;
539 : :
540 : 0 : if (exception_state == DCPU_WANT_MASTER)
541 : : atomic_inc(&masters_in_kgdb);
542 : : else
543 : : atomic_inc(&slaves_in_kgdb);
544 : :
545 : 0 : if (arch_kgdb_ops.disable_hw_break)
546 : 0 : arch_kgdb_ops.disable_hw_break(regs);
547 : :
548 : : acquirelock:
549 : : rcu_read_lock();
550 : : /*
551 : : * Interrupts will be restored by the 'trap return' code, except when
552 : : * single stepping.
553 : : */
554 : 0 : local_irq_save(flags);
555 : :
556 : 0 : cpu = ks->cpu;
557 : 0 : kgdb_info[cpu].debuggerinfo = regs;
558 : 0 : kgdb_info[cpu].task = current;
559 : 0 : kgdb_info[cpu].ret_state = 0;
560 : 0 : kgdb_info[cpu].irq_depth = hardirq_count() >> HARDIRQ_SHIFT;
561 : :
562 : : /* Make sure the above info reaches the primary CPU */
563 : 0 : smp_mb();
564 : :
565 : 0 : if (exception_level == 1) {
566 : 0 : if (raw_spin_trylock(&dbg_master_lock))
567 : 0 : atomic_xchg(&kgdb_active, cpu);
568 : : goto cpu_master_loop;
569 : : }
570 : :
571 : : /*
572 : : * CPU will loop if it is a slave or request to become a kgdb
573 : : * master cpu and acquire the kgdb_active lock:
574 : : */
575 : : while (1) {
576 : : cpu_loop:
577 : 0 : if (kgdb_info[cpu].exception_state & DCPU_NEXT_MASTER) {
578 : 0 : kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER;
579 : 0 : goto cpu_master_loop;
580 : 0 : } else if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
581 : 0 : if (raw_spin_trylock(&dbg_master_lock)) {
582 : 0 : atomic_xchg(&kgdb_active, cpu);
583 : : break;
584 : : }
585 : 0 : } else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
586 : 0 : if (!raw_spin_is_locked(&dbg_slave_lock))
587 : : goto return_normal;
588 : : } else {
589 : : return_normal:
590 : : /* Return to normal operation by executing any
591 : : * hw breakpoint fixup.
592 : : */
593 : 0 : if (arch_kgdb_ops.correct_hw_break)
594 : 0 : arch_kgdb_ops.correct_hw_break();
595 : 0 : if (trace_on)
596 : 0 : tracing_on();
597 : 0 : kgdb_info[cpu].debuggerinfo = NULL;
598 : 0 : kgdb_info[cpu].task = NULL;
599 : 0 : kgdb_info[cpu].exception_state &=
600 : : ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
601 : 0 : kgdb_info[cpu].enter_kgdb--;
602 : 0 : smp_mb__before_atomic();
603 : : atomic_dec(&slaves_in_kgdb);
604 : : dbg_touch_watchdogs();
605 : 0 : local_irq_restore(flags);
606 : : rcu_read_unlock();
607 : 0 : return 0;
608 : : }
609 : 0 : cpu_relax();
610 : 0 : }
611 : :
612 : : /*
613 : : * For single stepping, try to only enter on the processor
614 : : * that was single stepping. To guard against a deadlock, the
615 : : * kernel will only try for the value of sstep_tries before
616 : : * giving up and continuing on.
617 : : */
618 : 0 : if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
619 : 0 : (kgdb_info[cpu].task &&
620 : 0 : kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
621 : : atomic_set(&kgdb_active, -1);
622 : : raw_spin_unlock(&dbg_master_lock);
623 : : dbg_touch_watchdogs();
624 : 0 : local_irq_restore(flags);
625 : : rcu_read_unlock();
626 : :
627 : : goto acquirelock;
628 : : }
629 : :
630 : 0 : if (!kgdb_io_ready(1)) {
631 : 0 : kgdb_info[cpu].ret_state = 1;
632 : 0 : goto kgdb_restore; /* No I/O connection, resume the system */
633 : : }
634 : :
635 : : /*
636 : : * Don't enter if we have hit a removed breakpoint.
637 : : */
638 : 0 : if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
639 : : goto kgdb_restore;
640 : :
641 : : atomic_inc(&ignore_console_lock_warning);
642 : :
643 : : /* Call the I/O driver's pre_exception routine */
644 : 0 : if (dbg_io_ops->pre_exception)
645 : 0 : dbg_io_ops->pre_exception();
646 : :
647 : : /*
648 : : * Get the passive CPU lock which will hold all the non-primary
649 : : * CPU in a spin state while the debugger is active
650 : : */
651 : 0 : if (!kgdb_single_step)
652 : 0 : raw_spin_lock(&dbg_slave_lock);
653 : :
654 : : #ifdef CONFIG_SMP
655 : : /* If send_ready set, slaves are already waiting */
656 : 0 : if (ks->send_ready)
657 : : atomic_set(ks->send_ready, 1);
658 : :
659 : : /* Signal the other CPUs to enter kgdb_wait() */
660 : 0 : else if ((!kgdb_single_step) && kgdb_do_roundup)
661 : 0 : kgdb_roundup_cpus();
662 : : #endif
663 : :
664 : : /*
665 : : * Wait for the other CPUs to be notified and be waiting for us:
666 : : */
667 : : time_left = MSEC_PER_SEC;
668 : 0 : while (kgdb_do_roundup && --time_left &&
669 : 0 : (atomic_read(&masters_in_kgdb) + atomic_read(&slaves_in_kgdb)) !=
670 : : online_cpus)
671 : 0 : udelay(1000);
672 : 0 : if (!time_left)
673 : 0 : pr_crit("Timed out waiting for secondary CPUs.\n");
674 : :
675 : : /*
676 : : * At this point the primary processor is completely
677 : : * in the debugger and all secondary CPUs are quiescent
678 : : */
679 : 0 : dbg_deactivate_sw_breakpoints();
680 : 0 : kgdb_single_step = 0;
681 : 0 : kgdb_contthread = current;
682 : 0 : exception_level = 0;
683 : 0 : trace_on = tracing_is_on();
684 : 0 : if (trace_on)
685 : 0 : tracing_off();
686 : :
687 : : while (1) {
688 : : cpu_master_loop:
689 : 0 : if (dbg_kdb_mode) {
690 : 0 : kgdb_connected = 1;
691 : 0 : error = kdb_stub(ks);
692 : 0 : if (error == -1)
693 : 0 : continue;
694 : 0 : kgdb_connected = 0;
695 : : } else {
696 : 0 : error = gdb_serial_stub(ks);
697 : : }
698 : :
699 : 0 : if (error == DBG_PASS_EVENT) {
700 : 0 : dbg_kdb_mode = !dbg_kdb_mode;
701 : 0 : } else if (error == DBG_SWITCH_CPU_EVENT) {
702 : 0 : kgdb_info[dbg_switch_cpu].exception_state |=
703 : : DCPU_NEXT_MASTER;
704 : 0 : goto cpu_loop;
705 : : } else {
706 : 0 : kgdb_info[cpu].ret_state = error;
707 : : break;
708 : : }
709 : : }
710 : :
711 : : /* Call the I/O driver's post_exception routine */
712 : 0 : if (dbg_io_ops->post_exception)
713 : 0 : dbg_io_ops->post_exception();
714 : :
715 : : atomic_dec(&ignore_console_lock_warning);
716 : :
717 : 0 : if (!kgdb_single_step) {
718 : : raw_spin_unlock(&dbg_slave_lock);
719 : : /* Wait till all the CPUs have quit from the debugger. */
720 : 0 : while (kgdb_do_roundup && atomic_read(&slaves_in_kgdb))
721 : 0 : cpu_relax();
722 : : }
723 : :
724 : : kgdb_restore:
725 : 0 : if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
726 : 0 : int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
727 : 0 : if (kgdb_info[sstep_cpu].task)
728 : 0 : kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
729 : : else
730 : 0 : kgdb_sstep_pid = 0;
731 : : }
732 : 0 : if (arch_kgdb_ops.correct_hw_break)
733 : 0 : arch_kgdb_ops.correct_hw_break();
734 : 0 : if (trace_on)
735 : 0 : tracing_on();
736 : :
737 : 0 : kgdb_info[cpu].debuggerinfo = NULL;
738 : 0 : kgdb_info[cpu].task = NULL;
739 : 0 : kgdb_info[cpu].exception_state &=
740 : : ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
741 : 0 : kgdb_info[cpu].enter_kgdb--;
742 : 0 : smp_mb__before_atomic();
743 : : atomic_dec(&masters_in_kgdb);
744 : : /* Free kgdb_active */
745 : : atomic_set(&kgdb_active, -1);
746 : : raw_spin_unlock(&dbg_master_lock);
747 : : dbg_touch_watchdogs();
748 : 0 : local_irq_restore(flags);
749 : : rcu_read_unlock();
750 : :
751 : 0 : return kgdb_info[cpu].ret_state;
752 : : }
753 : :
754 : : /*
755 : : * kgdb_handle_exception() - main entry point from a kernel exception
756 : : *
757 : : * Locking hierarchy:
758 : : * interface locks, if any (begin_session)
759 : : * kgdb lock (kgdb_active)
760 : : */
761 : : int
762 : 0 : kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
763 : : {
764 : : struct kgdb_state kgdb_var;
765 : : struct kgdb_state *ks = &kgdb_var;
766 : : int ret = 0;
767 : :
768 : 0 : if (arch_kgdb_ops.enable_nmi)
769 : 0 : arch_kgdb_ops.enable_nmi(0);
770 : : /*
771 : : * Avoid entering the debugger if we were triggered due to an oops
772 : : * but panic_timeout indicates the system should automatically
773 : : * reboot on panic. We don't want to get stuck waiting for input
774 : : * on such systems, especially if its "just" an oops.
775 : : */
776 : 0 : if (signo != SIGTRAP && panic_timeout)
777 : : return 1;
778 : :
779 : 0 : memset(ks, 0, sizeof(struct kgdb_state));
780 : 0 : ks->cpu = raw_smp_processor_id();
781 : 0 : ks->ex_vector = evector;
782 : 0 : ks->signo = signo;
783 : 0 : ks->err_code = ecode;
784 : 0 : ks->linux_regs = regs;
785 : :
786 : 0 : if (kgdb_reenter_check(ks))
787 : : goto out; /* Ouch, double exception ! */
788 : 0 : if (kgdb_info[ks->cpu].enter_kgdb != 0)
789 : : goto out;
790 : :
791 : 0 : ret = kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
792 : : out:
793 : 0 : if (arch_kgdb_ops.enable_nmi)
794 : 0 : arch_kgdb_ops.enable_nmi(1);
795 : 0 : return ret;
796 : : }
797 : :
798 : : /*
799 : : * GDB places a breakpoint at this function to know dynamically loaded objects.
800 : : */
801 : 0 : static int module_event(struct notifier_block *self, unsigned long val,
802 : : void *data)
803 : : {
804 : 0 : return 0;
805 : : }
806 : :
807 : : static struct notifier_block dbg_module_load_nb = {
808 : : .notifier_call = module_event,
809 : : };
810 : :
811 : 0 : int kgdb_nmicallback(int cpu, void *regs)
812 : : {
813 : : #ifdef CONFIG_SMP
814 : : struct kgdb_state kgdb_var;
815 : : struct kgdb_state *ks = &kgdb_var;
816 : :
817 : 0 : kgdb_info[cpu].rounding_up = false;
818 : :
819 : 0 : memset(ks, 0, sizeof(struct kgdb_state));
820 : 0 : ks->cpu = cpu;
821 : 0 : ks->linux_regs = regs;
822 : :
823 : 0 : if (kgdb_info[ks->cpu].enter_kgdb == 0 &&
824 : : raw_spin_is_locked(&dbg_master_lock)) {
825 : 0 : kgdb_cpu_enter(ks, regs, DCPU_IS_SLAVE);
826 : 0 : return 0;
827 : : }
828 : : #endif
829 : : return 1;
830 : : }
831 : :
832 : 0 : int kgdb_nmicallin(int cpu, int trapnr, void *regs, int err_code,
833 : : atomic_t *send_ready)
834 : : {
835 : : #ifdef CONFIG_SMP
836 : 0 : if (!kgdb_io_ready(0) || !send_ready)
837 : : return 1;
838 : :
839 : 0 : if (kgdb_info[cpu].enter_kgdb == 0) {
840 : : struct kgdb_state kgdb_var;
841 : : struct kgdb_state *ks = &kgdb_var;
842 : :
843 : 0 : memset(ks, 0, sizeof(struct kgdb_state));
844 : 0 : ks->cpu = cpu;
845 : 0 : ks->ex_vector = trapnr;
846 : 0 : ks->signo = SIGTRAP;
847 : 0 : ks->err_code = err_code;
848 : 0 : ks->linux_regs = regs;
849 : 0 : ks->send_ready = send_ready;
850 : 0 : kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
851 : : return 0;
852 : : }
853 : : #endif
854 : : return 1;
855 : : }
856 : :
857 : 0 : static void kgdb_console_write(struct console *co, const char *s,
858 : : unsigned count)
859 : : {
860 : : unsigned long flags;
861 : :
862 : : /* If we're debugging, or KGDB has not connected, don't try
863 : : * and print. */
864 : 0 : if (!kgdb_connected || atomic_read(&kgdb_active) != -1 || dbg_kdb_mode)
865 : 0 : return;
866 : :
867 : 0 : local_irq_save(flags);
868 : 0 : gdbstub_msg_write(s, count);
869 : 0 : local_irq_restore(flags);
870 : : }
871 : :
872 : : static struct console kgdbcons = {
873 : : .name = "kgdb",
874 : : .write = kgdb_console_write,
875 : : .flags = CON_PRINTBUFFER | CON_ENABLED,
876 : : .index = -1,
877 : : };
878 : :
879 : : #ifdef CONFIG_MAGIC_SYSRQ
880 : 0 : static void sysrq_handle_dbg(int key)
881 : : {
882 : 0 : if (!dbg_io_ops) {
883 : 0 : pr_crit("ERROR: No KGDB I/O module available\n");
884 : 0 : return;
885 : : }
886 : 0 : if (!kgdb_connected) {
887 : : #ifdef CONFIG_KGDB_KDB
888 : 0 : if (!dbg_kdb_mode)
889 : 0 : pr_crit("KGDB or $3#33 for KDB\n");
890 : : #else
891 : : pr_crit("Entering KGDB\n");
892 : : #endif
893 : : }
894 : :
895 : 0 : kgdb_breakpoint();
896 : : }
897 : :
898 : : static struct sysrq_key_op sysrq_dbg_op = {
899 : : .handler = sysrq_handle_dbg,
900 : : .help_msg = "debug(g)",
901 : : .action_msg = "DEBUG",
902 : : };
903 : : #endif
904 : :
905 : 0 : void kgdb_panic(const char *msg)
906 : : {
907 : 0 : if (!kgdb_io_module_registered)
908 : : return;
909 : :
910 : : /*
911 : : * We don't want to get stuck waiting for input from user if
912 : : * "panic_timeout" indicates the system should automatically
913 : : * reboot on panic.
914 : : */
915 : 0 : if (panic_timeout)
916 : : return;
917 : :
918 : 0 : if (dbg_kdb_mode)
919 : 0 : kdb_printf("PANIC: %s\n", msg);
920 : :
921 : 0 : kgdb_breakpoint();
922 : : }
923 : :
924 : 0 : void __weak kgdb_arch_late(void)
925 : : {
926 : 0 : }
927 : :
928 : 3 : void __init dbg_late_init(void)
929 : : {
930 : 3 : dbg_is_early = false;
931 : 3 : if (kgdb_io_module_registered)
932 : 0 : kgdb_arch_late();
933 : 3 : kdb_init(KDB_INIT_FULL);
934 : 3 : }
935 : :
936 : : static int
937 : 0 : dbg_notify_reboot(struct notifier_block *this, unsigned long code, void *x)
938 : : {
939 : : /*
940 : : * Take the following action on reboot notify depending on value:
941 : : * 1 == Enter debugger
942 : : * 0 == [the default] detatch debug client
943 : : * -1 == Do nothing... and use this until the board resets
944 : : */
945 : 0 : switch (kgdbreboot) {
946 : : case 1:
947 : 0 : kgdb_breakpoint();
948 : : case -1:
949 : : goto done;
950 : : }
951 : 0 : if (!dbg_kdb_mode)
952 : 0 : gdbstub_exit(code);
953 : : done:
954 : 0 : return NOTIFY_DONE;
955 : : }
956 : :
957 : : static struct notifier_block dbg_reboot_notifier = {
958 : : .notifier_call = dbg_notify_reboot,
959 : : .next = NULL,
960 : : .priority = INT_MAX,
961 : : };
962 : :
963 : 0 : static void kgdb_register_callbacks(void)
964 : : {
965 : 0 : if (!kgdb_io_module_registered) {
966 : 0 : kgdb_io_module_registered = 1;
967 : 0 : kgdb_arch_init();
968 : 0 : if (!dbg_is_early)
969 : 0 : kgdb_arch_late();
970 : 0 : register_module_notifier(&dbg_module_load_nb);
971 : 0 : register_reboot_notifier(&dbg_reboot_notifier);
972 : : #ifdef CONFIG_MAGIC_SYSRQ
973 : 0 : register_sysrq_key('g', &sysrq_dbg_op);
974 : : #endif
975 : 0 : if (kgdb_use_con && !kgdb_con_registered) {
976 : 0 : register_console(&kgdbcons);
977 : 0 : kgdb_con_registered = 1;
978 : : }
979 : : }
980 : 0 : }
981 : :
982 : 0 : static void kgdb_unregister_callbacks(void)
983 : : {
984 : : /*
985 : : * When this routine is called KGDB should unregister from
986 : : * handlers and clean up, making sure it is not handling any
987 : : * break exceptions at the time.
988 : : */
989 : 0 : if (kgdb_io_module_registered) {
990 : 0 : kgdb_io_module_registered = 0;
991 : 0 : unregister_reboot_notifier(&dbg_reboot_notifier);
992 : 0 : unregister_module_notifier(&dbg_module_load_nb);
993 : 0 : kgdb_arch_exit();
994 : : #ifdef CONFIG_MAGIC_SYSRQ
995 : 0 : unregister_sysrq_key('g', &sysrq_dbg_op);
996 : : #endif
997 : 0 : if (kgdb_con_registered) {
998 : 0 : unregister_console(&kgdbcons);
999 : 0 : kgdb_con_registered = 0;
1000 : : }
1001 : : }
1002 : 0 : }
1003 : :
1004 : : /*
1005 : : * There are times a tasklet needs to be used vs a compiled in
1006 : : * break point so as to cause an exception outside a kgdb I/O module,
1007 : : * such as is the case with kgdboe, where calling a breakpoint in the
1008 : : * I/O driver itself would be fatal.
1009 : : */
1010 : 0 : static void kgdb_tasklet_bpt(unsigned long ing)
1011 : : {
1012 : 0 : kgdb_breakpoint();
1013 : : atomic_set(&kgdb_break_tasklet_var, 0);
1014 : 0 : }
1015 : :
1016 : : static DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0);
1017 : :
1018 : 0 : void kgdb_schedule_breakpoint(void)
1019 : : {
1020 : 0 : if (atomic_read(&kgdb_break_tasklet_var) ||
1021 : 0 : atomic_read(&kgdb_active) != -1 ||
1022 : 0 : atomic_read(&kgdb_setting_breakpoint))
1023 : 0 : return;
1024 : : atomic_inc(&kgdb_break_tasklet_var);
1025 : 0 : tasklet_schedule(&kgdb_tasklet_breakpoint);
1026 : : }
1027 : : EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint);
1028 : :
1029 : : static void kgdb_initial_breakpoint(void)
1030 : : {
1031 : 0 : kgdb_break_asap = 0;
1032 : :
1033 : 0 : pr_crit("Waiting for connection from remote gdb...\n");
1034 : 0 : kgdb_breakpoint();
1035 : : }
1036 : :
1037 : : /**
1038 : : * kgdb_register_io_module - register KGDB IO module
1039 : : * @new_dbg_io_ops: the io ops vector
1040 : : *
1041 : : * Register it with the KGDB core.
1042 : : */
1043 : 0 : int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
1044 : : {
1045 : : int err;
1046 : :
1047 : : spin_lock(&kgdb_registration_lock);
1048 : :
1049 : 0 : if (dbg_io_ops) {
1050 : : spin_unlock(&kgdb_registration_lock);
1051 : :
1052 : 0 : pr_err("Another I/O driver is already registered with KGDB\n");
1053 : 0 : return -EBUSY;
1054 : : }
1055 : :
1056 : 0 : if (new_dbg_io_ops->init) {
1057 : 0 : err = new_dbg_io_ops->init();
1058 : 0 : if (err) {
1059 : : spin_unlock(&kgdb_registration_lock);
1060 : 0 : return err;
1061 : : }
1062 : : }
1063 : :
1064 : 0 : dbg_io_ops = new_dbg_io_ops;
1065 : :
1066 : : spin_unlock(&kgdb_registration_lock);
1067 : :
1068 : 0 : pr_info("Registered I/O driver %s\n", new_dbg_io_ops->name);
1069 : :
1070 : : /* Arm KGDB now. */
1071 : 0 : kgdb_register_callbacks();
1072 : :
1073 : 0 : if (kgdb_break_asap)
1074 : : kgdb_initial_breakpoint();
1075 : :
1076 : : return 0;
1077 : : }
1078 : : EXPORT_SYMBOL_GPL(kgdb_register_io_module);
1079 : :
1080 : : /**
1081 : : * kkgdb_unregister_io_module - unregister KGDB IO module
1082 : : * @old_dbg_io_ops: the io ops vector
1083 : : *
1084 : : * Unregister it with the KGDB core.
1085 : : */
1086 : 0 : void kgdb_unregister_io_module(struct kgdb_io *old_dbg_io_ops)
1087 : : {
1088 : 0 : BUG_ON(kgdb_connected);
1089 : :
1090 : : /*
1091 : : * KGDB is no longer able to communicate out, so
1092 : : * unregister our callbacks and reset state.
1093 : : */
1094 : 0 : kgdb_unregister_callbacks();
1095 : :
1096 : : spin_lock(&kgdb_registration_lock);
1097 : :
1098 : 0 : WARN_ON_ONCE(dbg_io_ops != old_dbg_io_ops);
1099 : 0 : dbg_io_ops = NULL;
1100 : :
1101 : : spin_unlock(&kgdb_registration_lock);
1102 : :
1103 : 0 : pr_info("Unregistered I/O driver %s, debugger disabled\n",
1104 : : old_dbg_io_ops->name);
1105 : 0 : }
1106 : : EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
1107 : :
1108 : 0 : int dbg_io_get_char(void)
1109 : : {
1110 : 0 : int ret = dbg_io_ops->read_char();
1111 : 0 : if (ret == NO_POLL_CHAR)
1112 : : return -1;
1113 : 0 : if (!dbg_kdb_mode)
1114 : : return ret;
1115 : 0 : if (ret == 127)
1116 : : return 8;
1117 : 0 : return ret;
1118 : : }
1119 : :
1120 : : /**
1121 : : * kgdb_breakpoint - generate breakpoint exception
1122 : : *
1123 : : * This function will generate a breakpoint exception. It is used at the
1124 : : * beginning of a program to sync up with a debugger and can be used
1125 : : * otherwise as a quick means to stop program execution and "break" into
1126 : : * the debugger.
1127 : : */
1128 : 0 : noinline void kgdb_breakpoint(void)
1129 : : {
1130 : : atomic_inc(&kgdb_setting_breakpoint);
1131 : 0 : wmb(); /* Sync point before breakpoint */
1132 : : arch_kgdb_breakpoint();
1133 : 0 : wmb(); /* Sync point after breakpoint */
1134 : : atomic_dec(&kgdb_setting_breakpoint);
1135 : 0 : }
1136 : : EXPORT_SYMBOL_GPL(kgdb_breakpoint);
1137 : :
1138 : 0 : static int __init opt_kgdb_wait(char *str)
1139 : : {
1140 : 0 : kgdb_break_asap = 1;
1141 : :
1142 : 0 : kdb_init(KDB_INIT_EARLY);
1143 : 0 : if (kgdb_io_module_registered)
1144 : : kgdb_initial_breakpoint();
1145 : :
1146 : 0 : return 0;
1147 : : }
1148 : :
1149 : : early_param("kgdbwait", opt_kgdb_wait);
|
