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