Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb
* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jwessel/linux-2.6-kgdb: kdb,debug_core: adjust master cpu switch logic against new debug_core locking debug_core: refactor locking for master/slave cpus x86,kgdb: remove unnecessary call to kgdb_correct_hw_break() debug_core: disable hw_breakpoints on all cores in kgdb_cpu_enter() kdb,kgdb: fix sparse fixups kdb: Fix oops in kdb_unregister kdb,ftdump: Remove reference to internal kdb include kdb: Allow kernel loadable modules to add kdb shell functions debug_core: stop rcu warnings on kernel resume debug_core: move all watch dog syncs to a single function x86,kgdb: fix debugger hw breakpoint test regression in 2.6.35
This commit is contained in:
commit
8814011679
|
@ -477,8 +477,6 @@ int kgdb_arch_handle_exception(int e_vector, int signo, int err_code,
|
|||
raw_smp_processor_id());
|
||||
}
|
||||
|
||||
kgdb_correct_hw_break();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -621,7 +619,12 @@ int kgdb_arch_init(void)
|
|||
static void kgdb_hw_overflow_handler(struct perf_event *event, int nmi,
|
||||
struct perf_sample_data *data, struct pt_regs *regs)
|
||||
{
|
||||
kgdb_ll_trap(DIE_DEBUG, "debug", regs, 0, 0, SIGTRAP);
|
||||
struct task_struct *tsk = current;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
if (breakinfo[i].enabled)
|
||||
tsk->thread.debugreg6 |= (DR_TRAP0 << i);
|
||||
}
|
||||
|
||||
void kgdb_arch_late(void)
|
||||
|
@ -644,7 +647,7 @@ void kgdb_arch_late(void)
|
|||
if (breakinfo[i].pev)
|
||||
continue;
|
||||
breakinfo[i].pev = register_wide_hw_breakpoint(&attr, NULL);
|
||||
if (IS_ERR(breakinfo[i].pev)) {
|
||||
if (IS_ERR((void * __force)breakinfo[i].pev)) {
|
||||
printk(KERN_ERR "kgdb: Could not allocate hw"
|
||||
"breakpoints\nDisabling the kernel debugger\n");
|
||||
breakinfo[i].pev = NULL;
|
||||
|
|
|
@ -243,7 +243,7 @@ static struct kgdb_io kgdboc_io_ops = {
|
|||
|
||||
#ifdef CONFIG_KGDB_SERIAL_CONSOLE
|
||||
/* This is only available if kgdboc is a built in for early debugging */
|
||||
int __init kgdboc_early_init(char *opt)
|
||||
static int __init kgdboc_early_init(char *opt)
|
||||
{
|
||||
/* save the first character of the config string because the
|
||||
* init routine can destroy it.
|
||||
|
|
|
@ -28,6 +28,41 @@ extern int kdb_poll_idx;
|
|||
extern int kdb_initial_cpu;
|
||||
extern atomic_t kdb_event;
|
||||
|
||||
/* Types and messages used for dynamically added kdb shell commands */
|
||||
|
||||
#define KDB_MAXARGS 16 /* Maximum number of arguments to a function */
|
||||
|
||||
typedef enum {
|
||||
KDB_REPEAT_NONE = 0, /* Do not repeat this command */
|
||||
KDB_REPEAT_NO_ARGS, /* Repeat the command without arguments */
|
||||
KDB_REPEAT_WITH_ARGS, /* Repeat the command including its arguments */
|
||||
} kdb_repeat_t;
|
||||
|
||||
typedef int (*kdb_func_t)(int, const char **);
|
||||
|
||||
/* KDB return codes from a command or internal kdb function */
|
||||
#define KDB_NOTFOUND (-1)
|
||||
#define KDB_ARGCOUNT (-2)
|
||||
#define KDB_BADWIDTH (-3)
|
||||
#define KDB_BADRADIX (-4)
|
||||
#define KDB_NOTENV (-5)
|
||||
#define KDB_NOENVVALUE (-6)
|
||||
#define KDB_NOTIMP (-7)
|
||||
#define KDB_ENVFULL (-8)
|
||||
#define KDB_ENVBUFFULL (-9)
|
||||
#define KDB_TOOMANYBPT (-10)
|
||||
#define KDB_TOOMANYDBREGS (-11)
|
||||
#define KDB_DUPBPT (-12)
|
||||
#define KDB_BPTNOTFOUND (-13)
|
||||
#define KDB_BADMODE (-14)
|
||||
#define KDB_BADINT (-15)
|
||||
#define KDB_INVADDRFMT (-16)
|
||||
#define KDB_BADREG (-17)
|
||||
#define KDB_BADCPUNUM (-18)
|
||||
#define KDB_BADLENGTH (-19)
|
||||
#define KDB_NOBP (-20)
|
||||
#define KDB_BADADDR (-21)
|
||||
|
||||
/*
|
||||
* kdb_diemsg
|
||||
*
|
||||
|
@ -104,10 +139,26 @@ int kdb_process_cpu(const struct task_struct *p)
|
|||
|
||||
/* kdb access to register set for stack dumping */
|
||||
extern struct pt_regs *kdb_current_regs;
|
||||
#ifdef CONFIG_KALLSYMS
|
||||
extern const char *kdb_walk_kallsyms(loff_t *pos);
|
||||
#else /* ! CONFIG_KALLSYMS */
|
||||
static inline const char *kdb_walk_kallsyms(loff_t *pos)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
#endif /* ! CONFIG_KALLSYMS */
|
||||
|
||||
/* Dynamic kdb shell command registration */
|
||||
extern int kdb_register(char *, kdb_func_t, char *, char *, short);
|
||||
extern int kdb_register_repeat(char *, kdb_func_t, char *, char *,
|
||||
short, kdb_repeat_t);
|
||||
extern int kdb_unregister(char *);
|
||||
#else /* ! CONFIG_KGDB_KDB */
|
||||
#define kdb_printf(...)
|
||||
#define kdb_init(x)
|
||||
#define kdb_register(...)
|
||||
#define kdb_register_repeat(...)
|
||||
#define kdb_uregister(x)
|
||||
#endif /* CONFIG_KGDB_KDB */
|
||||
enum {
|
||||
KDB_NOT_INITIALIZED,
|
||||
|
|
|
@ -47,6 +47,7 @@
|
|||
#include <linux/pid.h>
|
||||
#include <linux/smp.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/rcupdate.h>
|
||||
|
||||
#include <asm/cacheflush.h>
|
||||
#include <asm/byteorder.h>
|
||||
|
@ -109,13 +110,15 @@ static struct kgdb_bkpt kgdb_break[KGDB_MAX_BREAKPOINTS] = {
|
|||
*/
|
||||
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 passive_cpu_wait[NR_CPUS];
|
||||
static atomic_t cpu_in_kgdb[NR_CPUS];
|
||||
static atomic_t masters_in_kgdb;
|
||||
static atomic_t slaves_in_kgdb;
|
||||
static atomic_t kgdb_break_tasklet_var;
|
||||
atomic_t kgdb_setting_breakpoint;
|
||||
|
||||
|
@ -457,26 +460,32 @@ static int kgdb_reenter_check(struct kgdb_state *ks)
|
|||
return 1;
|
||||
}
|
||||
|
||||
static void dbg_cpu_switch(int cpu, int next_cpu)
|
||||
static void dbg_touch_watchdogs(void)
|
||||
{
|
||||
/* Mark the cpu we are switching away from as a slave when it
|
||||
* holds the kgdb_active token. This must be done so that the
|
||||
* that all the cpus wait in for the debug core will not enter
|
||||
* again as the master. */
|
||||
if (cpu == atomic_read(&kgdb_active)) {
|
||||
kgdb_info[cpu].exception_state |= DCPU_IS_SLAVE;
|
||||
kgdb_info[cpu].exception_state &= ~DCPU_WANT_MASTER;
|
||||
}
|
||||
kgdb_info[next_cpu].exception_state |= DCPU_NEXT_MASTER;
|
||||
touch_softlockup_watchdog_sync();
|
||||
clocksource_touch_watchdog();
|
||||
rcu_cpu_stall_reset();
|
||||
}
|
||||
|
||||
static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs)
|
||||
static int kgdb_cpu_enter(struct kgdb_state *ks, struct pt_regs *regs,
|
||||
int exception_state)
|
||||
{
|
||||
unsigned long flags;
|
||||
int sstep_tries = 100;
|
||||
int error;
|
||||
int i, cpu;
|
||||
int cpu;
|
||||
int trace_on = 0;
|
||||
int online_cpus = num_online_cpus();
|
||||
|
||||
kgdb_info[ks->cpu].enter_kgdb++;
|
||||
kgdb_info[ks->cpu].exception_state |= exception_state;
|
||||
|
||||
if (exception_state == DCPU_WANT_MASTER)
|
||||
atomic_inc(&masters_in_kgdb);
|
||||
else
|
||||
atomic_inc(&slaves_in_kgdb);
|
||||
kgdb_disable_hw_debug(ks->linux_regs);
|
||||
|
||||
acquirelock:
|
||||
/*
|
||||
* Interrupts will be restored by the 'trap return' code, except when
|
||||
|
@ -489,14 +498,15 @@ acquirelock:
|
|||
kgdb_info[cpu].task = current;
|
||||
kgdb_info[cpu].ret_state = 0;
|
||||
kgdb_info[cpu].irq_depth = hardirq_count() >> HARDIRQ_SHIFT;
|
||||
/*
|
||||
* Make sure the above info reaches the primary CPU before
|
||||
* our cpu_in_kgdb[] flag setting does:
|
||||
*/
|
||||
atomic_inc(&cpu_in_kgdb[cpu]);
|
||||
|
||||
if (exception_level == 1)
|
||||
/* 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
|
||||
|
@ -508,10 +518,12 @@ cpu_loop:
|
|||
kgdb_info[cpu].exception_state &= ~DCPU_NEXT_MASTER;
|
||||
goto cpu_master_loop;
|
||||
} else if (kgdb_info[cpu].exception_state & DCPU_WANT_MASTER) {
|
||||
if (atomic_cmpxchg(&kgdb_active, -1, cpu) == cpu)
|
||||
if (raw_spin_trylock(&dbg_master_lock)) {
|
||||
atomic_xchg(&kgdb_active, cpu);
|
||||
break;
|
||||
}
|
||||
} else if (kgdb_info[cpu].exception_state & DCPU_IS_SLAVE) {
|
||||
if (!atomic_read(&passive_cpu_wait[cpu]))
|
||||
if (!raw_spin_is_locked(&dbg_slave_lock))
|
||||
goto return_normal;
|
||||
} else {
|
||||
return_normal:
|
||||
|
@ -522,9 +534,12 @@ return_normal:
|
|||
arch_kgdb_ops.correct_hw_break();
|
||||
if (trace_on)
|
||||
tracing_on();
|
||||
atomic_dec(&cpu_in_kgdb[cpu]);
|
||||
touch_softlockup_watchdog_sync();
|
||||
clocksource_touch_watchdog();
|
||||
kgdb_info[cpu].exception_state &=
|
||||
~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
|
||||
kgdb_info[cpu].enter_kgdb--;
|
||||
smp_mb__before_atomic_dec();
|
||||
atomic_dec(&slaves_in_kgdb);
|
||||
dbg_touch_watchdogs();
|
||||
local_irq_restore(flags);
|
||||
return 0;
|
||||
}
|
||||
|
@ -541,8 +556,8 @@ return_normal:
|
|||
(kgdb_info[cpu].task &&
|
||||
kgdb_info[cpu].task->pid != kgdb_sstep_pid) && --sstep_tries) {
|
||||
atomic_set(&kgdb_active, -1);
|
||||
touch_softlockup_watchdog_sync();
|
||||
clocksource_touch_watchdog();
|
||||
raw_spin_unlock(&dbg_master_lock);
|
||||
dbg_touch_watchdogs();
|
||||
local_irq_restore(flags);
|
||||
|
||||
goto acquirelock;
|
||||
|
@ -563,16 +578,12 @@ return_normal:
|
|||
if (dbg_io_ops->pre_exception)
|
||||
dbg_io_ops->pre_exception();
|
||||
|
||||
kgdb_disable_hw_debug(ks->linux_regs);
|
||||
|
||||
/*
|
||||
* 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) {
|
||||
for (i = 0; i < NR_CPUS; i++)
|
||||
atomic_inc(&passive_cpu_wait[i]);
|
||||
}
|
||||
if (!kgdb_single_step)
|
||||
raw_spin_lock(&dbg_slave_lock);
|
||||
|
||||
#ifdef CONFIG_SMP
|
||||
/* Signal the other CPUs to enter kgdb_wait() */
|
||||
|
@ -583,10 +594,9 @@ return_normal:
|
|||
/*
|
||||
* Wait for the other CPUs to be notified and be waiting for us:
|
||||
*/
|
||||
for_each_online_cpu(i) {
|
||||
while (kgdb_do_roundup && !atomic_read(&cpu_in_kgdb[i]))
|
||||
cpu_relax();
|
||||
}
|
||||
while (kgdb_do_roundup && (atomic_read(&masters_in_kgdb) +
|
||||
atomic_read(&slaves_in_kgdb)) != online_cpus)
|
||||
cpu_relax();
|
||||
|
||||
/*
|
||||
* At this point the primary processor is completely
|
||||
|
@ -615,7 +625,8 @@ cpu_master_loop:
|
|||
if (error == DBG_PASS_EVENT) {
|
||||
dbg_kdb_mode = !dbg_kdb_mode;
|
||||
} else if (error == DBG_SWITCH_CPU_EVENT) {
|
||||
dbg_cpu_switch(cpu, dbg_switch_cpu);
|
||||
kgdb_info[dbg_switch_cpu].exception_state |=
|
||||
DCPU_NEXT_MASTER;
|
||||
goto cpu_loop;
|
||||
} else {
|
||||
kgdb_info[cpu].ret_state = error;
|
||||
|
@ -627,24 +638,11 @@ cpu_master_loop:
|
|||
if (dbg_io_ops->post_exception)
|
||||
dbg_io_ops->post_exception();
|
||||
|
||||
atomic_dec(&cpu_in_kgdb[ks->cpu]);
|
||||
|
||||
if (!kgdb_single_step) {
|
||||
for (i = NR_CPUS-1; i >= 0; i--)
|
||||
atomic_dec(&passive_cpu_wait[i]);
|
||||
/*
|
||||
* Wait till all the CPUs have quit from the debugger,
|
||||
* but allow a CPU that hit an exception and is
|
||||
* waiting to become the master to remain in the debug
|
||||
* core.
|
||||
*/
|
||||
for_each_online_cpu(i) {
|
||||
while (kgdb_do_roundup &&
|
||||
atomic_read(&cpu_in_kgdb[i]) &&
|
||||
!(kgdb_info[i].exception_state &
|
||||
DCPU_WANT_MASTER))
|
||||
cpu_relax();
|
||||
}
|
||||
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:
|
||||
|
@ -655,12 +653,20 @@ kgdb_restore:
|
|||
else
|
||||
kgdb_sstep_pid = 0;
|
||||
}
|
||||
if (arch_kgdb_ops.correct_hw_break)
|
||||
arch_kgdb_ops.correct_hw_break();
|
||||
if (trace_on)
|
||||
tracing_on();
|
||||
|
||||
kgdb_info[cpu].exception_state &=
|
||||
~(DCPU_WANT_MASTER | DCPU_IS_SLAVE);
|
||||
kgdb_info[cpu].enter_kgdb--;
|
||||
smp_mb__before_atomic_dec();
|
||||
atomic_dec(&masters_in_kgdb);
|
||||
/* Free kgdb_active */
|
||||
atomic_set(&kgdb_active, -1);
|
||||
touch_softlockup_watchdog_sync();
|
||||
clocksource_touch_watchdog();
|
||||
raw_spin_unlock(&dbg_master_lock);
|
||||
dbg_touch_watchdogs();
|
||||
local_irq_restore(flags);
|
||||
|
||||
return kgdb_info[cpu].ret_state;
|
||||
|
@ -678,7 +684,6 @@ kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
|
|||
{
|
||||
struct kgdb_state kgdb_var;
|
||||
struct kgdb_state *ks = &kgdb_var;
|
||||
int ret;
|
||||
|
||||
ks->cpu = raw_smp_processor_id();
|
||||
ks->ex_vector = evector;
|
||||
|
@ -689,11 +694,10 @@ kgdb_handle_exception(int evector, int signo, int ecode, struct pt_regs *regs)
|
|||
|
||||
if (kgdb_reenter_check(ks))
|
||||
return 0; /* Ouch, double exception ! */
|
||||
kgdb_info[ks->cpu].exception_state |= DCPU_WANT_MASTER;
|
||||
ret = kgdb_cpu_enter(ks, regs);
|
||||
kgdb_info[ks->cpu].exception_state &= ~(DCPU_WANT_MASTER |
|
||||
DCPU_IS_SLAVE);
|
||||
return ret;
|
||||
if (kgdb_info[ks->cpu].enter_kgdb != 0)
|
||||
return 0;
|
||||
|
||||
return kgdb_cpu_enter(ks, regs, DCPU_WANT_MASTER);
|
||||
}
|
||||
|
||||
int kgdb_nmicallback(int cpu, void *regs)
|
||||
|
@ -706,12 +710,9 @@ int kgdb_nmicallback(int cpu, void *regs)
|
|||
ks->cpu = cpu;
|
||||
ks->linux_regs = regs;
|
||||
|
||||
if (!atomic_read(&cpu_in_kgdb[cpu]) &&
|
||||
atomic_read(&kgdb_active) != -1 &&
|
||||
atomic_read(&kgdb_active) != cpu) {
|
||||
kgdb_info[cpu].exception_state |= DCPU_IS_SLAVE;
|
||||
kgdb_cpu_enter(ks, regs);
|
||||
kgdb_info[cpu].exception_state &= ~DCPU_IS_SLAVE;
|
||||
if (kgdb_info[ks->cpu].enter_kgdb == 0 &&
|
||||
raw_spin_is_locked(&dbg_master_lock)) {
|
||||
kgdb_cpu_enter(ks, regs, DCPU_IS_SLAVE);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -40,6 +40,7 @@ struct debuggerinfo_struct {
|
|||
int exception_state;
|
||||
int ret_state;
|
||||
int irq_depth;
|
||||
int enter_kgdb;
|
||||
};
|
||||
|
||||
extern struct debuggerinfo_struct kgdb_info[];
|
||||
|
|
|
@ -86,7 +86,7 @@ int kdb_stub(struct kgdb_state *ks)
|
|||
}
|
||||
/* Set initial kdb state variables */
|
||||
KDB_STATE_CLEAR(KGDB_TRANS);
|
||||
kdb_initial_cpu = ks->cpu;
|
||||
kdb_initial_cpu = atomic_read(&kgdb_active);
|
||||
kdb_current_task = kgdb_info[ks->cpu].task;
|
||||
kdb_current_regs = kgdb_info[ks->cpu].debuggerinfo;
|
||||
/* Remove any breakpoints as needed by kdb and clear single step */
|
||||
|
@ -105,7 +105,6 @@ int kdb_stub(struct kgdb_state *ks)
|
|||
ks->pass_exception = 1;
|
||||
KDB_FLAG_SET(CATASTROPHIC);
|
||||
}
|
||||
kdb_initial_cpu = ks->cpu;
|
||||
if (KDB_STATE(SSBPT) && reason == KDB_REASON_SSTEP) {
|
||||
KDB_STATE_CLEAR(SSBPT);
|
||||
KDB_STATE_CLEAR(DOING_SS);
|
||||
|
|
|
@ -823,4 +823,4 @@ int kdb_printf(const char *fmt, ...)
|
|||
|
||||
return r;
|
||||
}
|
||||
|
||||
EXPORT_SYMBOL_GPL(kdb_printf);
|
||||
|
|
|
@ -1749,13 +1749,13 @@ static int kdb_go(int argc, const char **argv)
|
|||
int nextarg;
|
||||
long offset;
|
||||
|
||||
if (raw_smp_processor_id() != kdb_initial_cpu) {
|
||||
kdb_printf("go must execute on the entry cpu, "
|
||||
"please use \"cpu %d\" and then execute go\n",
|
||||
kdb_initial_cpu);
|
||||
return KDB_BADCPUNUM;
|
||||
}
|
||||
if (argc == 1) {
|
||||
if (raw_smp_processor_id() != kdb_initial_cpu) {
|
||||
kdb_printf("go <address> must be issued from the "
|
||||
"initial cpu, do cpu %d first\n",
|
||||
kdb_initial_cpu);
|
||||
return KDB_ARGCOUNT;
|
||||
}
|
||||
nextarg = 1;
|
||||
diag = kdbgetaddrarg(argc, argv, &nextarg,
|
||||
&addr, &offset, NULL);
|
||||
|
@ -2783,6 +2783,8 @@ int kdb_register_repeat(char *cmd,
|
|||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(kdb_register_repeat);
|
||||
|
||||
|
||||
/*
|
||||
* kdb_register - Compatibility register function for commands that do
|
||||
|
@ -2805,6 +2807,7 @@ int kdb_register(char *cmd,
|
|||
return kdb_register_repeat(cmd, func, usage, help, minlen,
|
||||
KDB_REPEAT_NONE);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(kdb_register);
|
||||
|
||||
/*
|
||||
* kdb_unregister - This function is used to unregister a kernel
|
||||
|
@ -2823,7 +2826,7 @@ int kdb_unregister(char *cmd)
|
|||
/*
|
||||
* find the command.
|
||||
*/
|
||||
for (i = 0, kp = kdb_commands; i < kdb_max_commands; i++, kp++) {
|
||||
for_each_kdbcmd(kp, i) {
|
||||
if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
|
||||
kp->cmd_name = NULL;
|
||||
return 0;
|
||||
|
@ -2833,6 +2836,7 @@ int kdb_unregister(char *cmd)
|
|||
/* Couldn't find it. */
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(kdb_unregister);
|
||||
|
||||
/* Initialize the kdb command table. */
|
||||
static void __init kdb_inittab(void)
|
||||
|
|
|
@ -15,29 +15,6 @@
|
|||
#include <linux/kgdb.h>
|
||||
#include "../debug_core.h"
|
||||
|
||||
/* Kernel Debugger Error codes. Must not overlap with command codes. */
|
||||
#define KDB_NOTFOUND (-1)
|
||||
#define KDB_ARGCOUNT (-2)
|
||||
#define KDB_BADWIDTH (-3)
|
||||
#define KDB_BADRADIX (-4)
|
||||
#define KDB_NOTENV (-5)
|
||||
#define KDB_NOENVVALUE (-6)
|
||||
#define KDB_NOTIMP (-7)
|
||||
#define KDB_ENVFULL (-8)
|
||||
#define KDB_ENVBUFFULL (-9)
|
||||
#define KDB_TOOMANYBPT (-10)
|
||||
#define KDB_TOOMANYDBREGS (-11)
|
||||
#define KDB_DUPBPT (-12)
|
||||
#define KDB_BPTNOTFOUND (-13)
|
||||
#define KDB_BADMODE (-14)
|
||||
#define KDB_BADINT (-15)
|
||||
#define KDB_INVADDRFMT (-16)
|
||||
#define KDB_BADREG (-17)
|
||||
#define KDB_BADCPUNUM (-18)
|
||||
#define KDB_BADLENGTH (-19)
|
||||
#define KDB_NOBP (-20)
|
||||
#define KDB_BADADDR (-21)
|
||||
|
||||
/* Kernel Debugger Command codes. Must not overlap with error codes. */
|
||||
#define KDB_CMD_GO (-1001)
|
||||
#define KDB_CMD_CPU (-1002)
|
||||
|
@ -93,17 +70,6 @@
|
|||
*/
|
||||
#define KDB_MAXBPT 16
|
||||
|
||||
/* Maximum number of arguments to a function */
|
||||
#define KDB_MAXARGS 16
|
||||
|
||||
typedef enum {
|
||||
KDB_REPEAT_NONE = 0, /* Do not repeat this command */
|
||||
KDB_REPEAT_NO_ARGS, /* Repeat the command without arguments */
|
||||
KDB_REPEAT_WITH_ARGS, /* Repeat the command including its arguments */
|
||||
} kdb_repeat_t;
|
||||
|
||||
typedef int (*kdb_func_t)(int, const char **);
|
||||
|
||||
/* Symbol table format returned by kallsyms. */
|
||||
typedef struct __ksymtab {
|
||||
unsigned long value; /* Address of symbol */
|
||||
|
@ -123,11 +89,6 @@ extern int kallsyms_symbol_next(char *prefix_name, int flag);
|
|||
extern int kallsyms_symbol_complete(char *prefix_name, int max_len);
|
||||
|
||||
/* Exported Symbols for kernel loadable modules to use. */
|
||||
extern int kdb_register(char *, kdb_func_t, char *, char *, short);
|
||||
extern int kdb_register_repeat(char *, kdb_func_t, char *, char *,
|
||||
short, kdb_repeat_t);
|
||||
extern int kdb_unregister(char *);
|
||||
|
||||
extern int kdb_getarea_size(void *, unsigned long, size_t);
|
||||
extern int kdb_putarea_size(unsigned long, void *, size_t);
|
||||
|
||||
|
@ -144,6 +105,7 @@ extern int kdb_getword(unsigned long *, unsigned long, size_t);
|
|||
extern int kdb_putword(unsigned long, unsigned long, size_t);
|
||||
|
||||
extern int kdbgetularg(const char *, unsigned long *);
|
||||
extern int kdbgetu64arg(const char *, u64 *);
|
||||
extern char *kdbgetenv(const char *);
|
||||
extern int kdbgetaddrarg(int, const char **, int*, unsigned long *,
|
||||
long *, char **);
|
||||
|
@ -255,14 +217,6 @@ extern void kdb_ps1(const struct task_struct *p);
|
|||
extern void kdb_print_nameval(const char *name, unsigned long val);
|
||||
extern void kdb_send_sig_info(struct task_struct *p, struct siginfo *info);
|
||||
extern void kdb_meminfo_proc_show(void);
|
||||
#ifdef CONFIG_KALLSYMS
|
||||
extern const char *kdb_walk_kallsyms(loff_t *pos);
|
||||
#else /* ! CONFIG_KALLSYMS */
|
||||
static inline const char *kdb_walk_kallsyms(loff_t *pos)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
#endif /* ! CONFIG_KALLSYMS */
|
||||
extern char *kdb_getstr(char *, size_t, char *);
|
||||
|
||||
/* Defines for kdb_symbol_print */
|
||||
|
|
|
@ -13,7 +13,6 @@
|
|||
#include <linux/kdb.h>
|
||||
#include <linux/ftrace.h>
|
||||
|
||||
#include "../debug/kdb/kdb_private.h"
|
||||
#include "trace.h"
|
||||
#include "trace_output.h"
|
||||
|
||||
|
|
Loading…
Reference in New Issue