~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/debug/debug_core.c

Version: ~ [ linux-5.2-rc1 ] ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <linux/pid_namespace.h>
 31 #include <linux/clocksource.h>
 32 #include <linux/interrupt.h>
 33 #include <linux/spinlock.h>
 34 #include <linux/console.h>
 35 #include <linux/threads.h>
 36 #include <linux/uaccess.h>
 37 #include <linux/kernel.h>
 38 #include <linux/module.h>
 39 #include <linux/ptrace.h>
 40 #include <linux/string.h>
 41 #include <linux/delay.h>
 42 #include <linux/sched.h>
 43 #include <linux/sysrq.h>
 44 #include <linux/init.h>
 45 #include <linux/kgdb.h>
 46 #include <linux/kdb.h>
 47 #include <linux/pid.h>
 48 #include <linux/smp.h>
 49 #include <linux/mm.h>
 50 #include <linux/rcupdate.h>
 51 
 52 #include <asm/cacheflush.h>
 53 #include <asm/byteorder.h>
 54 #include <asm/atomic.h>
 55 #include <asm/system.h>
 56 
 57 #include "debug_core.h"
 58 
 59 static int kgdb_break_asap;
 60 
 61 struct debuggerinfo_struct kgdb_info[NR_CPUS];
 62 
 63 /**
 64  * kgdb_connected - Is a host GDB connected to us?
 65  */
 66 int                             kgdb_connected;
 67 EXPORT_SYMBOL_GPL(kgdb_connected);
 68 
 69 /* All the KGDB handlers are installed */
 70 int                     kgdb_io_module_registered;
 71 
 72 /* Guard for recursive entry */
 73 static int                      exception_level;
 74 
 75 struct kgdb_io          *dbg_io_ops;
 76 static DEFINE_SPINLOCK(kgdb_registration_lock);
 77 
 78 /* kgdb console driver is loaded */
 79 static int kgdb_con_registered;
 80 /* determine if kgdb console output should be used */
 81 static int kgdb_use_con;
 82 /* Flag for alternate operations for early debugging */
 83 bool dbg_is_early = true;
 84 /* Next cpu to become the master debug core */
 85 int dbg_switch_cpu;
 86 
 87 /* Use kdb or gdbserver mode */
 88 int dbg_kdb_mode = 1;
 89 
 90 static int __init opt_kgdb_con(char *str)
 91 {
 92         kgdb_use_con = 1;
 93         return 0;
 94 }
 95 
 96 early_param("kgdbcon", opt_kgdb_con);
 97 
 98 module_param(kgdb_use_con, int, 0644);
 99 
100 /*
101  * Holds information about breakpoints in a kernel. These breakpoints are
102  * added and removed by gdb.
103  */
104 static struct kgdb_bkpt         kgdb_break[KGDB_MAX_BREAKPOINTS] = {
105         [0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
106 };
107 
108 /*
109  * The CPU# of the active CPU, or -1 if none:
110  */
111 atomic_t                        kgdb_active = ATOMIC_INIT(-1);
112 EXPORT_SYMBOL_GPL(kgdb_active);
113 static DEFINE_RAW_SPINLOCK(dbg_master_lock);
114 static DEFINE_RAW_SPINLOCK(dbg_slave_lock);
115 
116 /*
117  * We use NR_CPUs not PERCPU, in case kgdb is used to debug early
118  * bootup code (which might not have percpu set up yet):
119  */
120 static atomic_t                 masters_in_kgdb;
121 static atomic_t                 slaves_in_kgdb;
122 static atomic_t                 kgdb_break_tasklet_var;
123 atomic_t                        kgdb_setting_breakpoint;
124 
125 struct task_struct              *kgdb_usethread;
126 struct task_struct              *kgdb_contthread;
127 
128 int                             kgdb_single_step;
129 static pid_t                    kgdb_sstep_pid;
130 
131 /* to keep track of the CPU which is doing the single stepping*/
132 atomic_t                        kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
133 
134 /*
135  * If you are debugging a problem where roundup (the collection of
136  * all other CPUs) is a problem [this should be extremely rare],
137  * then use the nokgdbroundup option to avoid roundup. In that case
138  * the other CPUs might interfere with your debugging context, so
139  * use this with care:
140  */
141 static int kgdb_do_roundup = 1;
142 
143 static int __init opt_nokgdbroundup(char *str)
144 {
145         kgdb_do_roundup = 0;
146 
147         return 0;
148 }
149 
150 early_param("nokgdbroundup", opt_nokgdbroundup);
151 
152 /*
153  * Finally, some KGDB code :-)
154  */
155 
156 /*
157  * Weak aliases for breakpoint management,
158  * can be overriden by architectures when needed:
159  */
160 int __weak kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr)
161 {
162         int err;
163 
164         err = probe_kernel_read(saved_instr, (char *)addr, BREAK_INSTR_SIZE);
165         if (err)
166                 return err;
167 
168         return probe_kernel_write((char *)addr, arch_kgdb_ops.gdb_bpt_instr,
169                                   BREAK_INSTR_SIZE);
170 }
171 
172 int __weak kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle)
173 {
174         return probe_kernel_write((char *)addr,
175                                   (char *)bundle, BREAK_INSTR_SIZE);
176 }
177 
178 int __weak kgdb_validate_break_address(unsigned long addr)
179 {
180         char tmp_variable[BREAK_INSTR_SIZE];
181         int err;
182         /* Validate setting the breakpoint and then removing it.  In the
183          * remove fails, the kernel needs to emit a bad message because we
184          * are deep trouble not being able to put things back the way we
185          * found them.
186          */
187         err = kgdb_arch_set_breakpoint(addr, tmp_variable);
188         if (err)
189                 return err;
190         err = kgdb_arch_remove_breakpoint(addr, tmp_variable);
191         if (err)
192                 printk(KERN_ERR "KGDB: Critical breakpoint error, kernel "
193                    "memory destroyed at: %lx", addr);
194         return err;
195 }
196 
197 unsigned long __weak kgdb_arch_pc(int exception, struct pt_regs *regs)
198 {
199         return instruction_pointer(regs);
200 }
201 
202 int __weak kgdb_arch_init(void)
203 {
204         return 0;
205 }
206 
207 int __weak kgdb_skipexception(int exception, struct pt_regs *regs)
208 {
209         return 0;
210 }
211 
212 /*
213  * Some architectures need cache flushes when we set/clear a
214  * breakpoint:
215  */
216 static void kgdb_flush_swbreak_addr(unsigned long addr)
217 {
218         if (!CACHE_FLUSH_IS_SAFE)
219                 return;
220 
221         if (current->mm && current->mm->mmap_cache) {
222                 flush_cache_range(current->mm->mmap_cache,
223                                   addr, addr + BREAK_INSTR_SIZE);
224         }
225         /* Force flush instruction cache if it was outside the mm */
226         flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
227 }
228 
229 /*
230  * SW breakpoint management:
231  */
232 int dbg_activate_sw_breakpoints(void)
233 {
234         unsigned long addr;
235         int error;
236         int ret = 0;
237         int i;
238 
239         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
240                 if (kgdb_break[i].state != BP_SET)
241                         continue;
242 
243                 addr = kgdb_break[i].bpt_addr;
244                 error = kgdb_arch_set_breakpoint(addr,
245                                 kgdb_break[i].saved_instr);
246                 if (error) {
247                         ret = error;
248                         printk(KERN_INFO "KGDB: BP install failed: %lx", addr);
249                         continue;
250                 }
251 
252                 kgdb_flush_swbreak_addr(addr);
253                 kgdb_break[i].state = BP_ACTIVE;
254         }
255         return ret;
256 }
257 
258 int dbg_set_sw_break(unsigned long addr)
259 {
260         int err = kgdb_validate_break_address(addr);
261         int breakno = -1;
262         int i;
263 
264         if (err)
265                 return err;
266 
267         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
268                 if ((kgdb_break[i].state == BP_SET) &&
269                                         (kgdb_break[i].bpt_addr == addr))
270                         return -EEXIST;
271         }
272         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
273                 if (kgdb_break[i].state == BP_REMOVED &&
274                                         kgdb_break[i].bpt_addr == addr) {
275                         breakno = i;
276                         break;
277                 }
278         }
279 
280         if (breakno == -1) {
281                 for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
282                         if (kgdb_break[i].state == BP_UNDEFINED) {
283                                 breakno = i;
284                                 break;
285                         }
286                 }
287         }
288 
289         if (breakno == -1)
290                 return -E2BIG;
291 
292         kgdb_break[breakno].state = BP_SET;
293         kgdb_break[breakno].type = BP_BREAKPOINT;
294         kgdb_break[breakno].bpt_addr = addr;
295 
296         return 0;
297 }
298 
299 int dbg_deactivate_sw_breakpoints(void)
300 {
301         unsigned long addr;
302         int error;
303         int ret = 0;
304         int i;
305 
306         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
307                 if (kgdb_break[i].state != BP_ACTIVE)
308                         continue;
309                 addr = kgdb_break[i].bpt_addr;
310                 error = kgdb_arch_remove_breakpoint(addr,
311                                         kgdb_break[i].saved_instr);
312                 if (error) {
313                         printk(KERN_INFO "KGDB: BP remove failed: %lx\n", addr);
314                         ret = error;
315                 }
316 
317                 kgdb_flush_swbreak_addr(addr);
318                 kgdb_break[i].state = BP_SET;
319         }
320         return ret;
321 }
322 
323 int dbg_remove_sw_break(unsigned long addr)
324 {
325         int i;
326 
327         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
328                 if ((kgdb_break[i].state == BP_SET) &&
329                                 (kgdb_break[i].bpt_addr == addr)) {
330                         kgdb_break[i].state = BP_REMOVED;
331                         return 0;
332                 }
333         }
334         return -ENOENT;
335 }
336 
337 int kgdb_isremovedbreak(unsigned long addr)
338 {
339         int i;
340 
341         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
342                 if ((kgdb_break[i].state == BP_REMOVED) &&
343                                         (kgdb_break[i].bpt_addr == addr))
344                         return 1;
345         }
346         return 0;
347 }
348 
349 int dbg_remove_all_break(void)
350 {
351         unsigned long addr;
352         int error;
353         int i;
354 
355         /* Clear memory breakpoints. */
356         for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
357                 if (kgdb_break[i].state != BP_ACTIVE)
358                         goto setundefined;
359                 addr = kgdb_break[i].bpt_addr;
360                 error = kgdb_arch_remove_breakpoint(addr,
361                                 kgdb_break[i].saved_instr);
362                 if (error)
363                         printk(KERN_ERR "KGDB: breakpoint remove failed: %lx\n",
364                            addr);
365 setundefined:
366                 kgdb_break[i].state = BP_UNDEFINED;
367         }
368 
369         /* Clear hardware breakpoints. */
370         if (arch_kgdb_ops.remove_all_hw_break)
371                 arch_kgdb_ops.remove_all_hw_break();
372 
373         return 0;
374 }
375 
376 /*
377  * Return true if there is a valid kgdb I/O module.  Also if no
378  * debugger is attached a message can be printed to the console about
379  * waiting for the debugger to attach.
380  *
381  * The print_wait argument is only to be true when called from inside
382  * the core kgdb_handle_exception, because it will wait for the
383  * debugger to attach.
384  */
385 static int kgdb_io_ready(int print_wait)
386 {
387         if (!dbg_io_ops)
388                 return 0;
389         if (kgdb_connected)
390                 return 1;
391         if (atomic_read(&kgdb_setting_breakpoint))
392                 return 1;
393         if (print_wait) {
394 #ifdef CONFIG_KGDB_KDB
395                 if (!dbg_kdb_mode)
396                         printk(KERN_CRIT "KGDB: waiting... or $3#33 for KDB\n");
397 #else
398                 printk(KERN_CRIT "KGDB: Waiting for remote debugger\n");
399 #endif
400         }
401         return 1;
402 }
403 
404 static int kgdb_reenter_check(struct kgdb_state *ks)
405 {
406         unsigned long addr;
407 
408         if (atomic_read(&kgdb_active) != raw_smp_processor_id())
409                 return 0;
410 
411         /* Panic on recursive debugger calls: */
412         exception_level++;
413         addr = kgdb_arch_pc(ks->ex_vector, ks->linux_regs);
414         dbg_deactivate_sw_breakpoints();
415 
416         /*
417          * If the break point removed ok at the place exception
418          * occurred, try to recover and print a warning to the end
419          * user because the user planted a breakpoint in a place that
420          * KGDB needs in order to function.
421          */
422         if (dbg_remove_sw_break(addr) == 0) {
423                 exception_level = 0;
424                 kgdb_skipexception(ks->ex_vector, ks->linux_regs);
425                 dbg_activate_sw_breakpoints();
426                 printk(KERN_CRIT "KGDB: re-enter error: breakpoint removed %lx\n",
427                         addr);
428                 WARN_ON_ONCE(1);
429 
430                 return 1;
431         }
432         dbg_remove_all_break();
433         kgdb_skipexception(ks->ex_vector, ks->linux_regs);
434 
435         if (exception_level > 1) {
436                 dump_stack();
437                 panic("Recursive entry to debugger");
438         }
439 
440         printk(KERN_CRIT "KGDB: re-enter exception: ALL breakpoints killed\n");
441 #ifdef CONFIG_KGDB_KDB
442         /* Allow kdb to debug itself one level */
443         return 0;
444 #endif
445         dump_stack();
446         panic("Recursive entry to debugger");
447 
448         return 1;
449 }
450 
451 static void dbg_touch_watchdogs(void)
452 {
453         touch_softlockup_watchdog_sync();
454         clocksource_touch_watchdog();
455         rcu_cpu_stall_reset();
456 }
457 
458 static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,
459                 int exception_state)
460 {
461         unsigned long flags;
462         int sstep_tries = 100;
463         int error;
464         int cpu;
465         int trace_on = 0;
466         int online_cpus = num_online_cpus();
467 
468         kgdb_info[ks->cpu].enter_kgdb++;
469         kgdb_info[ks->cpu].exception_state |= exception_state;
470 
471         if (exception_state == DCPU_WANT_MASTER)
472                 atomic_inc(&masters_in_kgdb);
473         else
474                 atomic_inc(&slaves_in_kgdb);
475 
476         if (arch_kgdb_ops.disable_hw_break)
477                 arch_kgdb_ops.disable_hw_break(regs);
478 
479 acquirelock:
480         /*
481          * Interrupts will be restored by the 'trap return' code, except when
482          * single stepping.
483          */
484         local_irq_save(flags);
485 
486         cpu = ks->cpu;
487         kgdb_info[cpu].debuggerinfo = regs;
488         kgdb_info[cpu].task = current;
489         kgdb_info[cpu].ret_state = 0;
490         kgdb_info[cpu].irq_depth = hardirq_count() >> HARDIRQ_SHIFT;
491 
492         /* Make sure the above info reaches the primary CPU */
493         smp_mb();
494 
495         if (exception_level == 1) {
496                 if (raw_spin_trylock(&dbg_master_lock))
497                         atomic_xchg(&kgdb_active, cpu);
498                 goto cpu_master_loop;
499         }
500 
501         /*
502          * CPU will loop if it is a slave or request to become a kgdb
503          * master cpu and acquire the kgdb_active lock:
504          */
505         while (1) {
506 cpu_loop:
507                 if (kgdb_info[cpu].exception_state & DCPU_NEXT_MASTER) {
508                         kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER;
509                         goto cpu_master_loop;
510                 } else if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
511                         if (raw_spin_trylock(&dbg_master_lock)) {
512                                 atomic_xchg(&kgdb_active, cpu);
513                                 break;
514                         }
515                 } else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
516                         if (!raw_spin_is_locked(&dbg_slave_lock))
517                                 goto return_normal;
518                 } else {
519 return_normal:
520                         /* Return to normal operation by executing any
521                          * hw breakpoint fixup.
522                          */
523                         if (arch_kgdb_ops.correct_hw_break)
524                                 arch_kgdb_ops.correct_hw_break();
525                         if (trace_on)
526                                 tracing_on();
527                         kgdb_info[cpu].exception_state &=
528                                 ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
529                         kgdb_info[cpu].enter_kgdb--;
530                         smp_mb__before_atomic_dec();
531                         atomic_dec(&slaves_in_kgdb);
532                         dbg_touch_watchdogs();
533                         local_irq_restore(flags);
534                         return 0;
535                 }
536                 cpu_relax();
537         }
538 
539         /*
540          * For single stepping, try to only enter on the processor
541          * that was single stepping.  To guard against a deadlock, the
542          * kernel will only try for the value of sstep_tries before
543          * giving up and continuing on.
544          */
545         if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
546             (kgdb_info[cpu].task &&
547              kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
548                 atomic_set(&kgdb_active, -1);
549                 raw_spin_unlock(&dbg_master_lock);
550                 dbg_touch_watchdogs();
551                 local_irq_restore(flags);
552 
553                 goto acquirelock;
554         }
555 
556         if (!kgdb_io_ready(1)) {
557                 kgdb_info[cpu].ret_state = 1;
558                 goto kgdb_restore; /* No I/O connection, resume the system */
559         }
560 
561         /*
562          * Don't enter if we have hit a removed breakpoint.
563          */
564         if (kgdb_skipexception(ks->ex_vector, ks->linux_regs))
565                 goto kgdb_restore;
566 
567         /* Call the I/O driver's pre_exception routine */
568         if (dbg_io_ops->pre_exception)
569                 dbg_io_ops->pre_exception();
570 
571         /*
572          * Get the passive CPU lock which will hold all the non-primary
573          * CPU in a spin state while the debugger is active
574          */
575         if (!kgdb_single_step)
576                 raw_spin_lock(&dbg_slave_lock);
577 
578 #ifdef CONFIG_SMP
579         /* Signal the other CPUs to enter kgdb_wait() */
580         if ((!kgdb_single_step) && kgdb_do_roundup)
581                 kgdb_roundup_cpus(flags);
582 #endif
583 
584         /*
585          * Wait for the other CPUs to be notified and be waiting for us:
586          */
587         while (kgdb_do_roundup && (atomic_read(&masters_in_kgdb) +
588                                 atomic_read(&slaves_in_kgdb)) != online_cpus)
589                 cpu_relax();
590 
591         /*
592          * At this point the primary processor is completely
593          * in the debugger and all secondary CPUs are quiescent
594          */
595         dbg_deactivate_sw_breakpoints();
596         kgdb_single_step = 0;
597         kgdb_contthread = current;
598         exception_level = 0;
599         trace_on = tracing_is_on();
600         if (trace_on)
601                 tracing_off();
602 
603         while (1) {
604 cpu_master_loop:
605                 if (dbg_kdb_mode) {
606                         kgdb_connected = 1;
607                         error = kdb_stub(ks);
608                         if (error == -1)
609                                 continue;
610                         kgdb_connected = 0;
611                 } else {
612                         error = gdb_serial_stub(ks);
613                 }
614 
615                 if (error == DBG_PASS_EVENT) {
616                         dbg_kdb_mode = !dbg_kdb_mode;
617                 } else if (error == DBG_SWITCH_CPU_EVENT) {
618                         kgdb_info[dbg_switch_cpu].exception_state |=
619                                 DCPU_NEXT_MASTER;
620                         goto cpu_loop;
621                 } else {
622                         kgdb_info[cpu].ret_state = error;
623                         break;
624                 }
625         }
626 
627         /* Call the I/O driver's post_exception routine */
628         if (dbg_io_ops->post_exception)
629                 dbg_io_ops->post_exception();
630 
631         if (!kgdb_single_step) {
632                 raw_spin_unlock(&dbg_slave_lock);
633                 /* Wait till all the CPUs have quit from the debugger. */
634                 while (kgdb_do_roundup && atomic_read(&slaves_in_kgdb))
635                         cpu_relax();
636         }
637 
638 kgdb_restore:
639         if (atomic_read(&kgdb_cpu_doing_single_step) != -1) {
640                 int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step);
641                 if (kgdb_info[sstep_cpu].task)
642                         kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid;
643                 else
644                         kgdb_sstep_pid = 0;
645         }
646         if (arch_kgdb_ops.correct_hw_break)
647                 arch_kgdb_ops.correct_hw_break();
648         if (trace_on)
649                 tracing_on();
650 
651         kgdb_info[cpu].exception_state &=
652                 ~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
653         kgdb_info[cpu].enter_kgdb--;
654         smp_mb__before_atomic_dec();
655         atomic_dec(&masters_in_kgdb);
656         /* Free kgdb_active */
657         atomic_set(&kgdb_active, -1);
658         raw_spin_unlock(&dbg_master_lock);
659         dbg_touch_watchdogs();
660         local_irq_restore(flags);
661 
662         return kgdb_info[cpu].ret_state;
663 }
664 
665 /*
666  * kgdb_handle_exception() - main entry point from a kernel exception
667  *
668  * Locking hierarchy:
669  *      interface locks, if any (begin_session)
670  *      kgdb lock (kgdb_active)
671  */
672 int
673 kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
674 {
675         struct kgdb_state kgdb_var;
676         struct kgdb_state *ks = &kgdb_var;
677 
678         ks->cpu                 = raw_smp_processor_id();
679         ks->ex_vector           = evector;
680         ks->signo               = signo;
681         ks->err_code            = ecode;
682         ks->kgdb_usethreadid    = 0;
683         ks->linux_regs          = regs;
684 
685         if (kgdb_reenter_check(ks))
686                 return 0; /* Ouch, double exception ! */
687         if (kgdb_info[ks->cpu].enter_kgdb != 0)
688                 return 0;
689 
690         return kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
691 }
692 
693 int kgdb_nmicallback(int cpu, void *regs)
694 {
695 #ifdef CONFIG_SMP
696         struct kgdb_state kgdb_var;
697         struct kgdb_state *ks = &kgdb_var;
698 
699         memset(ks, 0, sizeof(struct kgdb_state));
700         ks->cpu                 = cpu;
701         ks->linux_regs          = regs;
702 
703         if (kgdb_info[ks->cpu].enter_kgdb == 0 &&
704                         raw_spin_is_locked(&dbg_master_lock)) {
705                 kgdb_cpu_enter(ks, regs, DCPU_IS_SLAVE);
706                 return 0;
707         }
708 #endif
709         return 1;
710 }
711 
712 static void kgdb_console_write(struct console *co, const char *s,
713    unsigned count)
714 {
715         unsigned long flags;
716 
717         /* If we're debugging, or KGDB has not connected, don't try
718          * and print. */
719         if (!kgdb_connected || atomic_read(&kgdb_active) != -1 || dbg_kdb_mode)
720                 return;
721 
722         local_irq_save(flags);
723         gdbstub_msg_write(s, count);
724         local_irq_restore(flags);
725 }
726 
727 static struct console kgdbcons = {
728         .name           = "kgdb",
729         .write          = kgdb_console_write,
730         .flags          = CON_PRINTBUFFER | CON_ENABLED,
731         .index          = -1,
732 };
733 
734 #ifdef CONFIG_MAGIC_SYSRQ
735 static void sysrq_handle_dbg(int key)
736 {
737         if (!dbg_io_ops) {
738                 printk(KERN_CRIT "ERROR: No KGDB I/O module available\n");
739                 return;
740         }
741         if (!kgdb_connected) {
742 #ifdef CONFIG_KGDB_KDB
743                 if (!dbg_kdb_mode)
744                         printk(KERN_CRIT "KGDB or $3#33 for KDB\n");
745 #else
746                 printk(KERN_CRIT "Entering KGDB\n");
747 #endif
748         }
749 
750         kgdb_breakpoint();
751 }
752 
753 static struct sysrq_key_op sysrq_dbg_op = {
754         .handler        = sysrq_handle_dbg,
755         .help_msg       = "debug(G)",
756         .action_msg     = "DEBUG",
757 };
758 #endif
759 
760 static int kgdb_panic_event(struct notifier_block *self,
761                             unsigned long val,
762                             void *data)
763 {
764         if (dbg_kdb_mode)
765                 kdb_printf("PANIC: %s\n", (char *)data);
766         kgdb_breakpoint();
767         return NOTIFY_DONE;
768 }
769 
770 static struct notifier_block kgdb_panic_event_nb = {
771        .notifier_call   = kgdb_panic_event,
772        .priority        = INT_MAX,
773 };
774 
775 void __weak kgdb_arch_late(void)
776 {
777 }
778 
779 void __init dbg_late_init(void)
780 {
781         dbg_is_early = false;
782         if (kgdb_io_module_registered)
783                 kgdb_arch_late();
784         kdb_init(KDB_INIT_FULL);
785 }
786 
787 static void kgdb_register_callbacks(void)
788 {
789         if (!kgdb_io_module_registered) {
790                 kgdb_io_module_registered = 1;
791                 kgdb_arch_init();
792                 if (!dbg_is_early)
793                         kgdb_arch_late();
794                 atomic_notifier_chain_register(&panic_notifier_list,
795                                                &kgdb_panic_event_nb);
796 #ifdef CONFIG_MAGIC_SYSRQ
797                 register_sysrq_key('g', &sysrq_dbg_op);
798 #endif
799                 if (kgdb_use_con && !kgdb_con_registered) {
800                         register_console(&kgdbcons);
801                         kgdb_con_registered = 1;
802                 }
803         }
804 }
805 
806 static void kgdb_unregister_callbacks(void)
807 {
808         /*
809          * When this routine is called KGDB should unregister from the
810          * panic handler and clean up, making sure it is not handling any
811          * break exceptions at the time.
812          */
813         if (kgdb_io_module_registered) {
814                 kgdb_io_module_registered = 0;
815                 atomic_notifier_chain_unregister(&panic_notifier_list,
816                                                &kgdb_panic_event_nb);
817                 kgdb_arch_exit();
818 #ifdef CONFIG_MAGIC_SYSRQ
819                 unregister_sysrq_key('g', &sysrq_dbg_op);
820 #endif
821                 if (kgdb_con_registered) {
822                         unregister_console(&kgdbcons);
823                         kgdb_con_registered = 0;
824                 }
825         }
826 }
827 
828 /*
829  * There are times a tasklet needs to be used vs a compiled in
830  * break point so as to cause an exception outside a kgdb I/O module,
831  * such as is the case with kgdboe, where calling a breakpoint in the
832  * I/O driver itself would be fatal.
833  */
834 static void kgdb_tasklet_bpt(unsigned long ing)
835 {
836         kgdb_breakpoint();
837         atomic_set(&kgdb_break_tasklet_var, 0);
838 }
839 
840 static DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0);
841 
842 void kgdb_schedule_breakpoint(void)
843 {
844         if (atomic_read(&kgdb_break_tasklet_var) ||
845                 atomic_read(&kgdb_active) != -1 ||
846                 atomic_read(&kgdb_setting_breakpoint))
847                 return;
848         atomic_inc(&kgdb_break_tasklet_var);
849         tasklet_schedule(&kgdb_tasklet_breakpoint);
850 }
851 EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint);
852 
853 static void kgdb_initial_breakpoint(void)
854 {
855         kgdb_break_asap = 0;
856 
857         printk(KERN_CRIT "kgdb: Waiting for connection from remote gdb...\n");
858         kgdb_breakpoint();
859 }
860 
861 /**
862  *      kgdb_register_io_module - register KGDB IO module
863  *      @new_dbg_io_ops: the io ops vector
864  *
865  *      Register it with the KGDB core.
866  */
867 int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
868 {
869         int err;
870 
871         spin_lock(&kgdb_registration_lock);
872 
873         if (dbg_io_ops) {
874                 spin_unlock(&kgdb_registration_lock);
875 
876                 printk(KERN_ERR "kgdb: Another I/O driver is already "
877                                 "registered with KGDB.\n");
878                 return -EBUSY;
879         }
880 
881         if (new_dbg_io_ops->init) {
882                 err = new_dbg_io_ops->init();
883                 if (err) {
884                         spin_unlock(&kgdb_registration_lock);
885                         return err;
886                 }
887         }
888 
889         dbg_io_ops = new_dbg_io_ops;
890 
891         spin_unlock(&kgdb_registration_lock);
892 
893         printk(KERN_INFO "kgdb: Registered I/O driver %s.\n",
894                new_dbg_io_ops->name);
895 
896         /* Arm KGDB now. */
897         kgdb_register_callbacks();
898 
899         if (kgdb_break_asap)
900                 kgdb_initial_breakpoint();
901 
902         return 0;
903 }
904 EXPORT_SYMBOL_GPL(kgdb_register_io_module);
905 
906 /**
907  *      kkgdb_unregister_io_module - unregister KGDB IO module
908  *      @old_dbg_io_ops: the io ops vector
909  *
910  *      Unregister it with the KGDB core.
911  */
912 void kgdb_unregister_io_module(struct kgdb_io *old_dbg_io_ops)
913 {
914         BUG_ON(kgdb_connected);
915 
916         /*
917          * KGDB is no longer able to communicate out, so
918          * unregister our callbacks and reset state.
919          */
920         kgdb_unregister_callbacks();
921 
922         spin_lock(&kgdb_registration_lock);
923 
924         WARN_ON_ONCE(dbg_io_ops != old_dbg_io_ops);
925         dbg_io_ops = NULL;
926 
927         spin_unlock(&kgdb_registration_lock);
928 
929         printk(KERN_INFO
930                 "kgdb: Unregistered I/O driver %s, debugger disabled.\n",
931                 old_dbg_io_ops->name);
932 }
933 EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);
934 
935 int dbg_io_get_char(void)
936 {
937         int ret = dbg_io_ops->read_char();
938         if (ret == NO_POLL_CHAR)
939                 return -1;
940         if (!dbg_kdb_mode)
941                 return ret;
942         if (ret == 127)
943                 return 8;
944         return ret;
945 }
946 
947 /**
948  * kgdb_breakpoint - generate breakpoint exception
949  *
950  * This function will generate a breakpoint exception.  It is used at the
951  * beginning of a program to sync up with a debugger and can be used
952  * otherwise as a quick means to stop program execution and "break" into
953  * the debugger.
954  */
955 void kgdb_breakpoint(void)
956 {
957         atomic_inc(&kgdb_setting_breakpoint);
958         wmb(); /* Sync point before breakpoint */
959         arch_kgdb_breakpoint();
960         wmb(); /* Sync point after breakpoint */
961         atomic_dec(&kgdb_setting_breakpoint);
962 }
963 EXPORT_SYMBOL_GPL(kgdb_breakpoint);
964 
965 static int __init opt_kgdb_wait(char *str)
966 {
967         kgdb_break_asap = 1;
968 
969         kdb_init(KDB_INIT_EARLY);
970         if (kgdb_io_module_registered)
971                 kgdb_initial_breakpoint();
972 
973         return 0;
974 }
975 
976 early_param("kgdbwait", opt_kgdb_wait);
977 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp