/* Action for the reboot notifier, a global allow kdb to change it */ staticint kgdbreboot; /* kgdb console driver is loaded */ staticint kgdb_con_registered; /* determine if kgdb console output should be used */ staticint kgdb_use_con; /* Flag for alternate operations for early debugging */ bool dbg_is_early = true; /* Next cpu to become the master debug core */ int dbg_switch_cpu;
/* Use kdb or gdbserver mode */ int dbg_kdb_mode = 1;
/* * Holds information about breakpoints in a kernel. These breakpoints are * added and removed by gdb.
*/ staticstruct kgdb_bkpt kgdb_break[KGDB_MAX_BREAKPOINTS] = {
[0 ... KGDB_MAX_BREAKPOINTS-1] = { .state = BP_UNDEFINED }
};
/* * The CPU# of the active CPU, or -1 if none:
*/
atomic_t kgdb_active = ATOMIC_INIT(-1);
EXPORT_SYMBOL_GPL(kgdb_active); static DEFINE_RAW_SPINLOCK(dbg_master_lock); static DEFINE_RAW_SPINLOCK(dbg_slave_lock);
/* * We use NR_CPUs not PERCPU, in case kgdb is used to debug early * bootup code (which might not have percpu set up yet):
*/ static atomic_t masters_in_kgdb; static atomic_t slaves_in_kgdb;
atomic_t kgdb_setting_breakpoint;
int kgdb_single_step; static pid_t kgdb_sstep_pid;
/* to keep track of the CPU which is doing the single stepping*/
atomic_t kgdb_cpu_doing_single_step = ATOMIC_INIT(-1);
/* * If you are debugging a problem where roundup (the collection of * all other CPUs) is a problem [this should be extremely rare], * then use the nokgdbroundup option to avoid roundup. In that case * the other CPUs might interfere with your debugging context, so * use this with care:
*/ staticint kgdb_do_roundup = 1;
/* * Weak aliases for breakpoint management, * can be overridden by architectures when needed:
*/ int __weak kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt)
{ int err;
int __weak kgdb_validate_break_address(unsignedlong addr)
{ struct kgdb_bkpt tmp; int err;
if (kgdb_within_blocklist(addr)) return -EINVAL;
/* Validate setting the breakpoint and then removing it. If the * remove fails, the kernel needs to emit a bad message because we * are deep trouble not being able to put things back the way we * found them.
*/
tmp.bpt_addr = addr;
err = kgdb_arch_set_breakpoint(&tmp); if (err) return err;
err = kgdb_arch_remove_breakpoint(&tmp); if (err)
pr_err("Critical breakpoint error, kernel memory destroyed at: %lx\n",
addr); return err;
}
/* * Default (weak) implementation for kgdb_roundup_cpus
*/
void __weak kgdb_call_nmi_hook(void *ignored)
{ /* * NOTE: get_irq_regs() is supposed to get the registers from * before the IPI interrupt happened and so is supposed to * show where the processor was. In some situations it's * possible we might be called without an IPI, so it might be * safer to figure out how to make kgdb_breakpoint() work * properly here.
*/
kgdb_nmicallback(raw_smp_processor_id(), get_irq_regs());
}
NOKPROBE_SYMBOL(kgdb_call_nmi_hook);
void __weak kgdb_roundup_cpus(void)
{
call_single_data_t *csd; int this_cpu = raw_smp_processor_id(); int cpu; int ret;
for_each_online_cpu(cpu) { /* No need to roundup ourselves */ if (cpu == this_cpu) continue;
csd = &per_cpu(kgdb_roundup_csd, cpu);
/* * If it didn't round up last time, don't try again * since smp_call_function_single_async() will block. * * If rounding_up is false then we know that the * previous call must have at least started and that * means smp_call_function_single_async() won't block.
*/ if (kgdb_info[cpu].rounding_up) continue;
kgdb_info[cpu].rounding_up = true;
ret = smp_call_function_single_async(cpu, csd); if (ret)
kgdb_info[cpu].rounding_up = false;
}
}
NOKPROBE_SYMBOL(kgdb_roundup_cpus);
#endif
/* * Some architectures need cache flushes when we set/clear a * breakpoint:
*/ staticvoid kgdb_flush_swbreak_addr(unsignedlong addr)
{ if (!CACHE_FLUSH_IS_SAFE) return;
/* Force flush instruction cache if it was outside the mm */
flush_icache_range(addr, addr + BREAK_INSTR_SIZE);
}
NOKPROBE_SYMBOL(kgdb_flush_swbreak_addr);
/* * SW breakpoint management:
*/ int dbg_activate_sw_breakpoints(void)
{ int error; int ret = 0; int i;
for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) { if (kgdb_break[i].state != BP_SET) continue;
error = kgdb_arch_set_breakpoint(&kgdb_break[i]); if (error) {
ret = error;
pr_info("BP install failed: %lx\n",
kgdb_break[i].bpt_addr); continue;
}
int dbg_deactivate_sw_breakpoints(void)
{ int error; int ret = 0; int i;
for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) { if (kgdb_break[i].state != BP_ACTIVE) continue;
error = kgdb_arch_remove_breakpoint(&kgdb_break[i]); if (error) {
pr_info("BP remove failed: %lx\n",
kgdb_break[i].bpt_addr);
ret = error;
}
if (!(kgdb_info[cpu].exception_state & DCPU_IS_SLAVE)) {
kdb_printf("ERROR: Task on cpu %d didn't stop in the debugger\n",
cpu); return;
}
/* * In general, architectures don't support dumping the stack of a * "running" process that's not the current one. From the point of * view of the Linux, kernel processes that are looping in the kgdb * slave loop are still "running". There's also no API (that actually * works across all architectures) that can do a stack crawl based * on registers passed as a parameter. * * Solve this conundrum by asking slave CPUs to do the backtrace * themselves.
*/
kgdb_info[cpu].exception_state |= DCPU_WANT_BT; while (kgdb_info[cpu].exception_state & DCPU_WANT_BT)
cpu_relax();
} #endif
/* * Return true if there is a valid kgdb I/O module. Also if no * debugger is attached a message can be printed to the console about * waiting for the debugger to attach. * * The print_wait argument is only to be true when called from inside * the core kgdb_handle_exception, because it will wait for the * debugger to attach.
*/ staticint kgdb_io_ready(int print_wait)
{ if (!dbg_io_ops) return 0; if (kgdb_connected) return 1; if (atomic_read(&kgdb_setting_breakpoint)) return 1; if (print_wait) { #ifdef CONFIG_KGDB_KDB if (!dbg_kdb_mode)
pr_crit("waiting... or $3#33 for KDB\n"); #else
pr_crit("Waiting for remote debugger\n"); #endif
} return 1;
}
NOKPROBE_SYMBOL(kgdb_io_ready);
/* * If the break point removed ok at the place exception * occurred, try to recover and print a warning to the end * user because the user planted a breakpoint in a place that * KGDB needs in order to function.
*/ if (dbg_remove_sw_break(addr) == 0) {
exception_level = 0;
kgdb_skipexception(ks->ex_vector, ks->linux_regs);
dbg_activate_sw_breakpoints();
pr_crit("re-enter error: breakpoint removed %lx\n", addr);
WARN_ON_ONCE(1);
staticint kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs, int exception_state)
{ unsignedlong flags; int sstep_tries = 100; int error; int cpu; int trace_on = 0; int online_cpus = num_online_cpus();
u64 time_left;
/* Make sure the above info reaches the primary CPU */
smp_mb();
if (exception_level == 1) { if (raw_spin_trylock(&dbg_master_lock))
atomic_xchg(&kgdb_active, cpu); goto cpu_master_loop;
}
/* * CPU will loop if it is a slave or request to become a kgdb * master cpu and acquire the kgdb_active lock:
*/ while (1) {
cpu_loop: if (kgdb_info[cpu].exception_state & DCPU_NEXT_MASTER) {
kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER; goto cpu_master_loop;
} elseif (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) { if (raw_spin_trylock(&dbg_master_lock)) {
atomic_xchg(&kgdb_active, cpu); break;
}
} elseif (kgdb_info[cpu].exception_state & DCPU_WANT_BT) {
dump_stack();
kgdb_info[cpu].exception_state &= ~DCPU_WANT_BT;
} elseif (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) { if (!raw_spin_is_locked(&dbg_slave_lock)) goto return_normal;
} else {
return_normal: /* Return to normal operation by executing any * hw breakpoint fixup.
*/ if (arch_kgdb_ops.correct_hw_break)
arch_kgdb_ops.correct_hw_break(); if (trace_on)
tracing_on();
kgdb_info[cpu].debuggerinfo = NULL;
kgdb_info[cpu].task = NULL;
kgdb_info[cpu].exception_state &=
~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
kgdb_info[cpu].enter_kgdb--;
smp_mb__before_atomic();
atomic_dec(&slaves_in_kgdb);
dbg_touch_watchdogs();
local_irq_restore(flags);
rcu_read_unlock(); return 0;
}
cpu_relax();
}
/* * For single stepping, try to only enter on the processor * that was single stepping. To guard against a deadlock, the * kernel will only try for the value of sstep_tries before * giving up and continuing on.
*/ if (atomic_read(&kgdb_cpu_doing_single_step) != -1 &&
(kgdb_info[cpu].task &&
kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
atomic_set(&kgdb_active, -1);
raw_spin_unlock(&dbg_master_lock);
dbg_touch_watchdogs();
local_irq_restore(flags);
rcu_read_unlock();
goto acquirelock;
}
if (!kgdb_io_ready(1)) {
kgdb_info[cpu].ret_state = 1; goto kgdb_restore; /* No I/O connection, resume the system */
}
/* * Don't enter if we have hit a removed breakpoint.
*/ if (kgdb_skipexception(ks->ex_vector, ks->linux_regs)) goto kgdb_restore;
atomic_inc(&ignore_console_lock_warning);
/* Call the I/O driver's pre_exception routine */ if (dbg_io_ops->pre_exception)
dbg_io_ops->pre_exception();
/* * Get the passive CPU lock which will hold all the non-primary * CPU in a spin state while the debugger is active
*/ if (!kgdb_single_step)
raw_spin_lock(&dbg_slave_lock);
#ifdef CONFIG_SMP /* If send_ready set, slaves are already waiting */ if (ks->send_ready)
atomic_set(ks->send_ready, 1);
/* Signal the other CPUs to enter kgdb_wait() */ elseif ((!kgdb_single_step) && kgdb_do_roundup)
kgdb_roundup_cpus(); #endif
/* * Wait for the other CPUs to be notified and be waiting for us:
*/
time_left = MSEC_PER_SEC; while (kgdb_do_roundup && --time_left &&
(atomic_read(&masters_in_kgdb) + atomic_read(&slaves_in_kgdb)) !=
online_cpus)
udelay(1000); if (!time_left)
pr_crit("Timed out waiting for secondary CPUs.\n");
/* * At this point the primary processor is completely * in the debugger and all secondary CPUs are quiescent
*/
dbg_deactivate_sw_breakpoints();
kgdb_single_step = 0;
kgdb_contthread = current;
exception_level = 0;
trace_on = tracing_is_on(); if (trace_on)
tracing_off();
while (1) {
cpu_master_loop: if (dbg_kdb_mode) {
kgdb_connected = 1;
error = kdb_stub(ks); if (error == -1) continue;
kgdb_connected = 0;
} else { /* * This is a brutal way to interfere with the debugger * and prevent gdb being used to poke at kernel memory. * This could cause trouble if lockdown is applied when * there is already an active gdb session. For now the * answer is simply "don't do that". Typically lockdown * *will* be applied before the debug core gets started * so only developers using kgdb for fairly advanced * early kernel debug can be biten by this. Hopefully * they are sophisticated enough to take care of * themselves, especially with help from the lockdown * message printed on the console!
*/ if (security_locked_down(LOCKDOWN_DBG_WRITE_KERNEL)) { if (IS_ENABLED(CONFIG_KGDB_KDB)) { /* Switch back to kdb if possible... */
dbg_kdb_mode = 1; continue;
} else { /* ... otherwise just bail */ break;
}
}
error = gdb_serial_stub(ks);
}
/* Call the I/O driver's post_exception routine */ if (dbg_io_ops->post_exception)
dbg_io_ops->post_exception();
atomic_dec(&ignore_console_lock_warning);
if (!kgdb_single_step) {
raw_spin_unlock(&dbg_slave_lock); /* Wait till all the CPUs have quit from the debugger. */ while (kgdb_do_roundup && atomic_read(&slaves_in_kgdb))
cpu_relax();
}
kgdb_restore: if (atomic_read(&kgdb_cpu_doing_single_step) != -1) { int sstep_cpu = atomic_read(&kgdb_cpu_doing_single_step); if (kgdb_info[sstep_cpu].task)
kgdb_sstep_pid = kgdb_info[sstep_cpu].task->pid; else
kgdb_sstep_pid = 0;
} if (arch_kgdb_ops.correct_hw_break)
arch_kgdb_ops.correct_hw_break(); if (trace_on)
tracing_on();
/* * kgdb_handle_exception() - main entry point from a kernel exception * * Locking hierarchy: * interface locks, if any (begin_session) * kgdb lock (kgdb_active)
*/ int
kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
{ struct kgdb_state kgdb_var; struct kgdb_state *ks = &kgdb_var; /* * Avoid entering the debugger if we were triggered due to an oops * but panic_timeout indicates the system should automatically * reboot on panic. We don't want to get stuck waiting for input * on such systems, especially if its "just" an oops.
*/ if (signo != SIGTRAP && panic_timeout) return 1;
int kgdb_nmicallin(int cpu, int trapnr, void *regs, int err_code,
atomic_t *send_ready)
{ #ifdef CONFIG_SMP if (!kgdb_io_ready(0) || !send_ready) return 1;
/* If we're debugging, or KGDB has not connected, don't try
* and print. */ if (!kgdb_connected || atomic_read(&kgdb_active) != -1 || dbg_kdb_mode) return;
void kgdb_panic(constchar *msg)
{ if (!kgdb_io_module_registered) return;
/* * We don't want to get stuck waiting for input from user if * "panic_timeout" indicates the system should automatically * reboot on panic.
*/ if (panic_timeout) return;
if (kgdb_io_module_registered && kgdb_break_asap)
kgdb_initial_breakpoint();
}
staticint
dbg_notify_reboot(struct notifier_block *this, unsignedlong code, void *x)
{ /* * Take the following action on reboot notify depending on value: * 1 == Enter debugger * 0 == [the default] detach debug client * -1 == Do nothing... and use this until the board resets
*/ switch (kgdbreboot) { case 1:
kgdb_breakpoint(); goto done; case -1: goto done;
} if (!dbg_kdb_mode)
gdbstub_exit(code);
done: return NOTIFY_DONE;
}
staticvoid kgdb_unregister_callbacks(void)
{ /* * When this routine is called KGDB should unregister from * handlers and clean up, making sure it is not handling any * break exceptions at the time.
*/ if (kgdb_io_module_registered) {
kgdb_io_module_registered = 0;
unregister_reboot_notifier(&dbg_reboot_notifier);
unregister_module_notifier(&dbg_module_load_nb);
kgdb_arch_exit(); #ifdef CONFIG_MAGIC_SYSRQ
unregister_sysrq_key('g', &sysrq_dbg_op); #endif if (kgdb_con_registered) {
unregister_console(&kgdbcons);
kgdb_con_registered = 0;
}
}
}
/** * kgdb_register_io_module - register KGDB IO module * @new_dbg_io_ops: the io ops vector * * Register it with the KGDB core.
*/ int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops)
{ struct kgdb_io *old_dbg_io_ops; int err;
spin_lock(&kgdb_registration_lock);
old_dbg_io_ops = dbg_io_ops; if (old_dbg_io_ops) { if (!old_dbg_io_ops->deinit) {
spin_unlock(&kgdb_registration_lock);
int dbg_io_get_char(void)
{ int ret = dbg_io_ops->read_char(); if (ret == NO_POLL_CHAR) return -1; if (!dbg_kdb_mode) return ret; if (ret == 127) return 8; return ret;
}
/** * kgdb_breakpoint - generate breakpoint exception * * This function will generate a breakpoint exception. It is used at the * beginning of a program to sync up with a debugger and can be used * otherwise as a quick means to stop program execution and "break" into * the debugger.
*/
noinline void kgdb_breakpoint(void)
{
atomic_inc(&kgdb_setting_breakpoint);
wmb(); /* Sync point before breakpoint */
arch_kgdb_breakpoint();
wmb(); /* Sync point after breakpoint */
atomic_dec(&kgdb_setting_breakpoint);
}
EXPORT_SYMBOL_GPL(kgdb_breakpoint);
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
