[RFC PATCH] KGDB: various refactorings

Jan Kiszka
2008-01-27T18:45:50Z

[-- Attachment #1: Type: text/plain, Size: 30027 bytes --]

Jason,

this is a RFC about another round of refactoring for the KGDB version
in x86-git. It's a single patch so far, but I can break out individual
hunks on request.

Things I changed:
- Reduce EXPORT_SYMBOLs, switch the rest to EXPORT_SYMBOL_GPL
- Drop code that is (yet) unused
- Rename variables, refactor their types (personal taste, for sure)
- Remove "extern" for function prototypes
- Remove MODULE_LICENSE/DESCRIPTION from kgdb core

Just cherry-pick what you like.

Jan

Signed-off-by: Jan Kiszka <jan.kiszka@web.de>

---
arch/x86/kernel/kgdb.c | 10 +-
include/linux/kgdb.h | 109 ++++++++++++-----------
kernel/kgdb.c | 230 +++++++++++++++++++++----------------------------
3 files changed, 162 insertions(+), 187 deletions(-)

Index: b/include/linux/kgdb.h
===================================================================
--- a/include/linux/kgdb.h
+++ b/include/linux/kgdb.h
@@ -12,7 +12,6 @@
* version 2. This program is licensed "as is" without any warranty of any
* kind, whether express or implied.
*/
-#ifdef __KERNEL__
#ifndef _KGDB_H_
#define _KGDB_H_

@@ -34,10 +33,10 @@ struct task_struct;
struct uart_port;

/* To enter the debugger explicitly. */
-extern void breakpoint(void);
+void breakpoint(void);
+
extern int kgdb_connected;
extern int kgdb_may_fault;
-extern struct tasklet_struct kgdb_tasklet_breakpoint;

extern atomic_t kgdb_setting_breakpoint;
extern atomic_t cpu_doing_single_step;
@@ -45,19 +44,27 @@ extern int kgdb_softlock_skip[NR_CPUS];

extern struct task_struct *kgdb_usethread, *kgdb_contthread;

+enum kgdb_initstate {
+ KGDB_UNINITIALIZED = 0,
+ KGDB_SEMI_INITIALIZED,
+ KGDB_FULLY_INITIALIZED
+};
+
+extern enum kgdb_initstate kgdb_state;
+
enum kgdb_bptype {
- bp_breakpoint = '0',
- bp_hardware_breakpoint,
- bp_write_watchpoint,
- bp_read_watchpoint,
- bp_access_watchpoint
+ BP_BREAKPOINT = 0,
+ BP_HARDWARE_BREAKPOINT,
+ BP_WRITE_WATCHPOINT,
+ BP_READ_WATCHPOINT,
+ BP_ACCESS_WATCHPOINT
};

enum kgdb_bpstate {
- bp_none = 0,
- bp_removed,
- bp_set,
- bp_active
+ BP_UNDEFINED = 0,
+ BP_REMOVED,
+ BP_SET,
+ BP_ACTIVE
};

struct kgdb_bkpt {
@@ -68,10 +75,10 @@ struct kgdb_bkpt {
};

/* The maximum number of KGDB I/O modules that can be loaded */
-#define MAX_KGDB_IO_HANDLERS 3
+#define KGDB_MAX_IO_HANDLERS 3

-#ifndef MAX_BREAKPOINTS
-#define MAX_BREAKPOINTS 1000
+#ifndef KGDB_MAX_BREAKPOINTS
+#define KGDB_MAX_BREAKPOINTS 1000
#endif

#define KGDB_HW_BREAKPOINT 1
@@ -83,20 +90,20 @@ struct kgdb_bkpt {
* This function will handle the initalization of any architecture
* specific hooks.
*/
-extern int kgdb_arch_init(void);
+int kgdb_arch_init(void);

/**
- * regs_to_gdb_regs - Convert ptrace regs to GDB regs
+ * pt_regs_to_gdb_regs - Convert ptrace regs to GDB regs
* @gdb_regs: A pointer to hold the registers in the order GDB wants.
* @regs: The &struct pt_regs of the current process.
*
* Convert the pt_regs in @regs into the format for registers that
* GDB expects, stored in @gdb_regs.
*/
-extern void regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs);
+void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs);

/**
- * sleeping_regs_to_gdb_regs - Convert ptrace regs to GDB regs
+ * sleeping_thread_to_gdb_regs - Convert ptrace regs to GDB regs
* @gdb_regs: A pointer to hold the registers in the order GDB wants.
* @p: The &struct task_struct of the desired process.
*
@@ -107,18 +114,18 @@ extern void regs_to_gdb_regs(unsigned lo
* @gdb_regs with what has been saved in &struct thread_struct
* thread field during switch_to.
*/
-extern void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,
- struct task_struct *p);
+void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs,
+ struct task_struct *p);

/**
- * gdb_regs_to_regs - Convert GDB regs to ptrace regs.
+ * gdb_regs_to_pt_regs - Convert GDB regs to ptrace regs.
* @gdb_regs: A pointer to hold the registers we've received from GDB.
* @regs: A pointer to a &struct pt_regs to hold these values in.
*
* Convert the GDB regs in @gdb_regs into the pt_regs, and store them
* in @regs.
*/
-extern void gdb_regs_to_regs(unsigned long *gdb_regs, struct pt_regs *regs);
+void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs);

/**
* kgdb_arch_handle_exception - Handle architecture specific GDB packets.
@@ -136,10 +143,10 @@ extern void gdb_regs_to_regs(unsigned lo
* process more packets, and a %0 or %1 if it wants to exit from the
* kgdb hook.
*/
-extern int kgdb_arch_handle_exception(int vector, int signo, int err_code,
- char *remcom_in_buffer,
- char *remcom_out_buffer,
- struct pt_regs *regs);
+int kgdb_arch_handle_exception(int vector, int signo, int err_code,
+ char *remcom_in_buffer,
+ char *remcom_out_buffer,
+ struct pt_regs *regs);

/**
* kgdb_roundup_cpus - Get other CPUs into a holding pattern
@@ -157,7 +164,7 @@ extern int kgdb_arch_handle_exception(in
*
* On non-SMP systems, this is not called.
*/
-extern void kgdb_roundup_cpus(unsigned long flags);
+void kgdb_roundup_cpus(unsigned long flags);

#ifndef JMP_REGS_ALIGNMENT
#define JMP_REGS_ALIGNMENT
@@ -173,7 +180,7 @@ extern unsigned long kgdb_fault_jmp_regs
* cause a fault. When this happens, we trap it, restore state to
* this call, and let ourself know that something bad has happened.
*/
-extern asmlinkage int kgdb_fault_setjmp(unsigned long *curr_context);
+asmlinkage int kgdb_fault_setjmp(unsigned long *curr_context);

/**
* kgdb_fault_longjmp - Restore state when we have faulted.
@@ -183,12 +190,12 @@ extern asmlinkage int kgdb_fault_setjmp(
* restore the known good state, and set the return value to 1, so
* we know something bad happened.
*/
-extern asmlinkage void kgdb_fault_longjmp(unsigned long *curr_context);
+asmlinkage void kgdb_fault_longjmp(unsigned long *curr_context);

/* Optional functions. */
-extern int kgdb_validate_break_address(unsigned long addr);
-extern int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr);
-extern int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle);
+int kgdb_validate_break_address(unsigned long addr);
+int kgdb_arch_set_breakpoint(unsigned long addr, char *saved_instr);
+int kgdb_arch_remove_breakpoint(unsigned long addr, char *bundle);

/**
* struct kgdb_arch - Describe architecture specific values.
@@ -259,31 +266,31 @@ struct kgdb_io {

extern struct kgdb_io kgdb_io_ops;
extern struct kgdb_arch arch_kgdb_ops;
-extern int kgdb_initialized;

-extern int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops);
-extern void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops);
+int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops);
+void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops);

-extern void kgdb8250_add_port(int i, struct uart_port *serial_req);
-extern void __init kgdb8250_add_platform_port(int i,
+void kgdb8250_add_port(int i, struct uart_port *serial_req);
+void __init kgdb8250_add_platform_port(int i,
struct plat_serial8250_port *serial_req);

-extern int kgdb_hex2long(char **ptr, long *long_val);
-extern char *kgdb_mem2hex(char *mem, char *buf, int count);
-extern char *kgdb_hex2mem(char *buf, char *mem, int count);
-extern char *kgdb_get_mem(char *addr, unsigned char *buf, int count);
-extern char *kgdb_set_mem(char *addr, unsigned char *buf, int count);
+int kgdb_hex2long(char **ptr, long *long_val);
+char *kgdb_mem2hex(char *mem, char *buf, int count);
+char *kgdb_hex2mem(char *buf, char *mem, int count);
+char *kgdb_get_mem(char *addr, unsigned char *buf, int count);
+char *kgdb_set_mem(char *addr, unsigned char *buf, int count);

int kgdb_isremovedbreak(unsigned long addr);

-extern int kgdb_handle_exception(int ex_vector, int signo, int err_code,
- struct pt_regs *regs);
-extern int kgdb_nmihook(int cpu, void *regs);
+int kgdb_handle_exception(int ex_vector, int signo, int err_code,
+ struct pt_regs *regs);
+int kgdb_nmihook(int cpu, void *regs);
+
extern int debugger_step;
extern atomic_t debugger_active;
-#else
-/* Stubs for when KGDB is not set. */
+
+#else /* !CONFIG_KGDB */
static const atomic_t debugger_active = ATOMIC_INIT(0);
-#endif /* CONFIG_KGDB */
-#endif /* _KGDB_H_ */
-#endif /* __KERNEL__ */
+#endif /* !CONFIG_KGDB */
+
+#endif /* _KGDB_H_ */
Index: b/kernel/kgdb.c
===================================================================
--- a/kernel/kgdb.c
+++ b/kernel/kgdb.c
@@ -71,16 +71,11 @@ extern int pid_max;
} \
}

-/*
- * kgdb_initialized with a value of 1 indicates that kgdb is setup and is
- * all ready to serve breakpoints and other kernel exceptions. A value of
- * -1 indicates that we have tried to initialize early, and need to try
- * again later.
- */
-int kgdb_initialized;
+enum kgdb_initstate kgdb_state;
+
/* Is a host GDB connected to us? */
int kgdb_connected;
-EXPORT_SYMBOL(kgdb_connected);
+EXPORT_SYMBOL_GPL(kgdb_connected);

/* Could we be about to try and access a bad memory location?
* If so we also need to flag this has happened. */
@@ -91,8 +86,6 @@ int kgdb_from_module_registered;
/* Guard for recursive entry */
static int exception_level;

-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Common architecture KGDB stub");
#ifdef CONFIG_KGDB_ATTACH_WAIT
static int attachwait = 1;
#else
@@ -101,35 +94,32 @@ static int attachwait;
module_param(attachwait, int, 0644);
MODULE_PARM_DESC(attachwait, "Wait for remote debugger"
" after an exception");
-MODULE_LICENSE("GPL");

/* We provide a kgdb_io_ops structure that may be overriden. */
struct kgdb_io __attribute__((weak)) kgdb_io_ops;
-EXPORT_SYMBOL(kgdb_io_ops);
+EXPORT_SYMBOL_GPL(kgdb_io_ops);

-static struct kgdb_io kgdb_io_ops_prev[MAX_KGDB_IO_HANDLERS];
+static struct kgdb_io kgdb_io_ops_prev[KGDB_MAX_IO_HANDLERS];
static int kgdb_io_handler_cnt;

/*
* Holds information about breakpoints in a kernel. These breakpoints are
* added and removed by gdb.
*/
-struct kgdb_bkpt kgdb_break[MAX_BREAKPOINTS];
+struct kgdb_bkpt kgdb_break[KGDB_MAX_BREAKPOINTS];

struct kgdb_arch *kgdb_ops = &arch_kgdb_ops;

static const char hexchars[] = "0123456789abcdef";

-static spinlock_t slavecpulocks[NR_CPUS];
-static atomic_t procindebug[NR_CPUS];
+static spinlock_t slave_cpu_locks[NR_CPUS];
+static atomic_t cpu_in_debugger[NR_CPUS];
atomic_t kgdb_setting_breakpoint;
-EXPORT_SYMBOL(kgdb_setting_breakpoint);
struct task_struct *kgdb_usethread, *kgdb_contthread;

int debugger_step;
static atomic_t kgdb_sync = ATOMIC_INIT(-1);
atomic_t debugger_active;
-EXPORT_SYMBOL(debugger_active);

/* Our I/O buffers. */
static char remcom_in_buffer[BUFMAX];
@@ -152,7 +142,7 @@ struct kgdb_state {
int ex_vector;
int signo;
int err_code;
- int processor;
+ int cpu;
int pass_exception;
long threadid;
long kgdb_usethreadid;
@@ -658,44 +648,43 @@ static struct task_struct *getthread(str
static void kgdb_wait(struct pt_regs *regs)
{
unsigned long flags;
- int processor;
+ int cpu;

local_irq_save(flags);
- processor = raw_smp_processor_id();
- kgdb_info[processor].debuggerinfo = regs;
- kgdb_info[processor].task = current;
- atomic_set(&procindebug[processor], 1);
+ cpu = raw_smp_processor_id();
+ kgdb_info[cpu].debuggerinfo = regs;
+ kgdb_info[cpu].task = current;
+ atomic_set(&cpu_in_debugger[cpu], 1);

- /* The master processor must be active to enter here, but this is
- * gaurd in case the master processor had not been selected if
+ /* The master CPU must be active to enter here, but this is
+ * gaurd in case the master CPU had not been selected if
* this was an entry via nmi.
*/
while (!atomic_read(&debugger_active))
cpu_relax();

- /* Wait till master processor goes completely into the debugger.
- */
- while (!atomic_read(&procindebug[atomic_read(&debugger_active) - 1])) {
+ /* Wait till master CPU goes completely into the debugger. */
+ while (!atomic_read(&cpu_in_debugger[atomic_read(&debugger_active) - 1])) {
int i = 10; /* an arbitrary number */

while (--i)
cpu_relax();
}

- /* Wait till master processor is done with debugging */
- spin_lock(&slavecpulocks[processor]);
+ /* Wait till master CPU is done with debugging */
+ spin_lock(&slave_cpu_locks[cpu]);

- kgdb_info[processor].debuggerinfo = NULL;
- kgdb_info[processor].task = NULL;
+ kgdb_info[cpu].debuggerinfo = NULL;
+ kgdb_info[cpu].task = NULL;

/* fix up hardware debug registers on local cpu */
if (kgdb_ops->correct_hw_break)
kgdb_ops->correct_hw_break();
- /* Signal the master processor that we are done */
- atomic_set(&procindebug[processor], 0);
- spin_unlock(&slavecpulocks[processor]);
+ /* Signal the master CPU that we are done */
+ atomic_set(&cpu_in_debugger[cpu], 0);
+ spin_unlock(&slave_cpu_locks[cpu]);
clocksource_touch_watchdog();
- kgdb_softlock_skip[processor] = 1;
+ kgdb_softlock_skip[cpu] = 1;
local_irq_restore(flags);
}
#endif
@@ -742,8 +731,8 @@ int kgdb_activate_sw_breakpoints(void)
int i;
int error = 0;
unsigned long addr;
- for (i = 0; i < MAX_BREAKPOINTS; i++) {
- if (kgdb_break[i].state != bp_set)
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+ if (kgdb_break[i].state != BP_SET)
continue;
addr = kgdb_break[i].bpt_addr;
error = kgdb_arch_set_breakpoint(addr,
@@ -760,7 +749,7 @@ int kgdb_activate_sw_breakpoints(void)
BREAK_INSTR_SIZE);
}

- kgdb_break[i].state = bp_active;
+ kgdb_break[i].state = BP_ACTIVE;
}
return 0;
}
@@ -772,13 +761,13 @@ static int kgdb_set_sw_break(unsigned lo
int error = kgdb_validate_break_address(addr);
if (error < 0)
return error;
- for (i = 0; i < MAX_BREAKPOINTS; i++) {
- if ((kgdb_break[i].state == bp_set) &&
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+ if ((kgdb_break[i].state == BP_SET) &&
(kgdb_break[i].bpt_addr == addr))
return -EEXIST;
}
- for (i = 0; i < MAX_BREAKPOINTS; i++) {
- if (kgdb_break[i].state == bp_removed &&
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+ if (kgdb_break[i].state == BP_REMOVED &&
kgdb_break[i].bpt_addr == addr) {
breakno = i;
break;
@@ -786,8 +775,8 @@ static int kgdb_set_sw_break(unsigned lo
}

if (breakno == -1) {
- for (i = 0; i < MAX_BREAKPOINTS; i++) {
- if (kgdb_break[i].state == bp_none) {
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+ if (kgdb_break[i].state == BP_UNDEFINED) {
breakno = i;
break;
}
@@ -796,8 +785,8 @@ static int kgdb_set_sw_break(unsigned lo
if (breakno == -1)
return -E2BIG;

- kgdb_break[breakno].state = bp_set;
- kgdb_break[breakno].type = bp_breakpoint;
+ kgdb_break[breakno].state = BP_SET;
+ kgdb_break[breakno].type = BP_BREAKPOINT;
kgdb_break[breakno].bpt_addr = addr;

return 0;
@@ -808,8 +797,8 @@ int kgdb_deactivate_sw_breakpoints(void)
int i;
int error = 0;
unsigned long addr;
- for (i = 0; i < MAX_BREAKPOINTS; i++) {
- if (kgdb_break[i].state != bp_active)
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+ if (kgdb_break[i].state != BP_ACTIVE)
continue;
addr = kgdb_break[i].bpt_addr;
error = kgdb_arch_remove_breakpoint(addr,
@@ -824,7 +813,7 @@ int kgdb_deactivate_sw_breakpoints(void)
else if (CACHE_FLUSH_IS_SAFE)
flush_icache_range(addr,
addr + BREAK_INSTR_SIZE);
- kgdb_break[i].state = bp_set;
+ kgdb_break[i].state = BP_SET;
}
return 0;
}
@@ -833,10 +822,10 @@ static int kgdb_remove_sw_break(unsigned
{
int i;

- for (i = 0; i < MAX_BREAKPOINTS; i++) {
- if ((kgdb_break[i].state == bp_set) &&
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+ if ((kgdb_break[i].state == BP_SET) &&
(kgdb_break[i].bpt_addr == addr)) {
- kgdb_break[i].state = bp_removed;
+ kgdb_break[i].state = BP_REMOVED;
return 0;
}
}
@@ -846,8 +835,8 @@ static int kgdb_remove_sw_break(unsigned
int kgdb_isremovedbreak(unsigned long addr)
{
int i;
- for (i = 0; i < MAX_BREAKPOINTS; i++) {
- if ((kgdb_break[i].state == bp_removed) &&
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+ if ((kgdb_break[i].state == BP_REMOVED) &&
(kgdb_break[i].bpt_addr == addr))
return 1;
}
@@ -861,15 +850,15 @@ int remove_all_break(void)
unsigned long addr;

/* Clear memory breakpoints. */
- for (i = 0; i < MAX_BREAKPOINTS; i++) {
- if (kgdb_break[i].state != bp_set)
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+ if (kgdb_break[i].state != BP_SET)
continue;
addr = kgdb_break[i].bpt_addr;
error = kgdb_arch_remove_breakpoint(addr,
kgdb_break[i].saved_instr);
if (error)
return error;
- kgdb_break[i].state = bp_removed;
+ kgdb_break[i].state = BP_REMOVED;
}

/* Clear hardware breakpoints. */
@@ -977,9 +966,9 @@ static void gdb_cmd_getregs(struct kgdb_

thread = kgdb_usethread;
if (!thread) {
- thread = kgdb_info[ks->processor].task;
+ thread = kgdb_info[ks->cpu].task;
local_debuggerinfo =
- kgdb_info[ks->processor].debuggerinfo;
+ kgdb_info[ks->cpu].debuggerinfo;
} else {
local_debuggerinfo = NULL;
for (i = 0; i < NR_CPUS; i++) {
@@ -1008,9 +997,9 @@ static void gdb_cmd_getregs(struct kgdb_
-EINVAL);
return;
}
- regs_to_gdb_regs(gdb_regs, shadowregs);
+ pt_regs_to_gdb_regs(gdb_regs, shadowregs);
} else if (local_debuggerinfo)
- regs_to_gdb_regs(gdb_regs, local_debuggerinfo);
+ pt_regs_to_gdb_regs(gdb_regs, local_debuggerinfo);
else {
/* Pull stuff saved during
* switch_to; nothing else is
@@ -1031,7 +1020,7 @@ static void gdb_cmd_setregs(struct kgdb_
if (kgdb_usethread && kgdb_usethread != current)
error_packet(remcom_out_buffer, -EINVAL);
else {
- gdb_regs_to_regs(gdb_regs, ks->linux_regs);
+ gdb_regs_to_pt_regs(gdb_regs, ks->linux_regs);
strcpy(remcom_out_buffer, "OK");
}
}
@@ -1387,8 +1376,8 @@ static int gdb_serial_stub(struct kgdb_s
put_packet(remcom_out_buffer);
}

- kgdb_usethread = kgdb_info[ks->processor].task;
- ks->kgdb_usethreadid = shadow_pid(kgdb_info[ks->processor].task->pid);
+ kgdb_usethread = kgdb_info[ks->cpu].task;
+ ks->kgdb_usethreadid = shadow_pid(kgdb_info[ks->cpu].task->pid);
ks->pass_exception = 0;

while (kgdb_io_ops.read_char) {
@@ -1541,12 +1530,12 @@ int kgdb_handle_exception(int evector, i
{
unsigned long flags;
unsigned i;
- unsigned procid;
+ int cpu;
int error = 0;
struct kgdb_state kgdb_var;
struct kgdb_state *ks = &kgdb_var;

- ks->processor = raw_smp_processor_id();
+ ks->cpu = raw_smp_processor_id();
ks->all_cpus_synced = 0;
ks->ex_vector = evector;
ks->signo = signo;
@@ -1566,7 +1555,7 @@ int kgdb_handle_exception(int evector, i
*/
local_irq_save(flags);

- procid = raw_smp_processor_id();
+ cpu = raw_smp_processor_id();

/* Being the process of declaring a master debug processor, the
* goal is to have only one single processor set debugger_active
@@ -1577,7 +1566,7 @@ int kgdb_handle_exception(int evector, i
int i = 25; /* an arbitrary number */
if (atomic_read(&kgdb_sync) < 0 &&
atomic_inc_and_test(&kgdb_sync)) {
- atomic_set(&debugger_active, procid + 1);
+ atomic_set(&debugger_active, cpu + 1);
break;
}

@@ -1585,7 +1574,7 @@ int kgdb_handle_exception(int evector, i
cpu_relax();

if (atomic_read(&cpu_doing_single_step) != -1 &&
- atomic_read(&cpu_doing_single_step) != procid)
+ atomic_read(&cpu_doing_single_step) != cpu)
udelay(1);
}

@@ -1595,11 +1584,11 @@ int kgdb_handle_exception(int evector, i
* debugger on a different CPU via a single step
*/
if (atomic_read(&cpu_doing_single_step) != -1 &&
- atomic_read(&cpu_doing_single_step) != procid) {
+ atomic_read(&cpu_doing_single_step) != cpu) {
atomic_set(&debugger_active, 0);
atomic_set(&kgdb_sync, -1);
clocksource_touch_watchdog();
- kgdb_softlock_skip[procid] = 1;
+ kgdb_softlock_skip[cpu] = 1;
local_irq_restore(flags);
goto acquirelock;
}
@@ -1619,17 +1608,17 @@ int kgdb_handle_exception(int evector, i
if (kgdb_io_ops.pre_exception)
kgdb_io_ops.pre_exception();

- kgdb_info[ks->processor].debuggerinfo = ks->linux_regs;
- kgdb_info[ks->processor].task = current;
+ kgdb_info[ks->cpu].debuggerinfo = ks->linux_regs;
+ kgdb_info[ks->cpu].task = current;

kgdb_disable_hw_debug(ks->linux_regs);

/* Get the slave CPU lock which will hold all the non-master
- * processors in a spin state while the debugger is active
+ * CPU in a spin state while the debugger is active
*/
if (!debugger_step || !kgdb_contthread)
for (i = 0; i < NR_CPUS; i++)
- spin_lock(&slavecpulocks[i]);
+ spin_lock(&slave_cpu_locks[i]);

#ifdef CONFIG_SMP
/* Signal the other CPUs to enter kgdb_wait() */
@@ -1639,16 +1628,16 @@ int kgdb_handle_exception(int evector, i

/* spin_lock code is good enough as a barrier so we don't
* need one here */
- atomic_set(&procindebug[ks->processor], 1);
+ atomic_set(&cpu_in_debugger[ks->cpu], 1);

/* Wait a reasonable time for the other CPUs to be notified and
* be waiting for us. Very early on this could be imperfect
* as num_online_cpus() could be 0.*/
for (i = 0; i < ROUNDUP_WAIT; i++) {
- int cpu;
+ int n;
int num = 0;
- for (cpu = 0; cpu < NR_CPUS; cpu++) {
- if (atomic_read(&procindebug[cpu]))
+ for (n = 0; n < NR_CPUS; n++) {
+ if (atomic_read(&cpu_in_debugger[n]))
num++;
}
if (num >= num_online_cpus()) {
@@ -1671,17 +1660,17 @@ int kgdb_handle_exception(int evector, i
if (kgdb_io_ops.post_exception)
kgdb_io_ops.post_exception();

- kgdb_info[ks->processor].debuggerinfo = NULL;
- kgdb_info[ks->processor].task = NULL;
- atomic_set(&procindebug[ks->processor], 0);
+ kgdb_info[ks->cpu].debuggerinfo = NULL;
+ kgdb_info[ks->cpu].task = NULL;
+ atomic_set(&cpu_in_debugger[ks->cpu], 0);

if (!debugger_step || !kgdb_contthread) {
for (i = 0; i < NR_CPUS; i++)
- spin_unlock(&slavecpulocks[i]);
- /* Wait till all the processors have quit
+ spin_unlock(&slave_cpu_locks[i]);
+ /* Wait till all the CPUs have quit
* from the debugger. */
for (i = 0; i < NR_CPUS; i++) {
- while (atomic_read(&procindebug[i])) {
+ while (atomic_read(&cpu_in_debugger[i])) {
int j = 10; /* an arbitrary number */

while (--j)
@@ -1693,13 +1682,12 @@ int kgdb_handle_exception(int evector, i
#ifdef CONFIG_SMP
/* This delay has a real purpose. The problem is that if you
* are single-stepping, you are sending an NMI to all the
- * other processors to stop them. Interrupts come in, but
- * don't get handled. Then you let them go just long enough
- * to get into their interrupt routines and use up some stack.
- * You stop them again, and then do the same thing. After a
- * while you blow the stack on the other processors. This
- * delay gives some time for interrupts to be cleared out on
- * the other processors.
+ * other CPUs to stop them. Interrupts come in, but don't get
+ * handled. Then you let them go just long enough to get into
+ * their interrupt routines and use up some stack. You stop them
+ * again, and then do the same thing. After a while you blow
+ * the stack on the other CPUs. This delay gives some time for
+ * interrupts to be cleared out on the other CPUs.
*/
if (debugger_step)
mdelay(2);
@@ -1709,7 +1697,7 @@ int kgdb_handle_exception(int evector, i
atomic_set(&debugger_active, 0);
atomic_set(&kgdb_sync, -1);
clocksource_touch_watchdog();
- kgdb_softlock_skip[ks->processor] = 1;
+ kgdb_softlock_skip[ks->cpu] = 1;
local_irq_restore(flags);

return error;
@@ -1733,7 +1721,7 @@ static struct notifier_block kgdb_module
int kgdb_nmihook(int cpu, void *regs)
{
#ifdef CONFIG_SMP
- if (!atomic_read(&procindebug[cpu]) &&
+ if (!atomic_read(&cpu_in_debugger[cpu]) &&
atomic_read(&debugger_active) != (cpu + 1)) {
kgdb_wait((struct pt_regs *)regs);
return 0;
@@ -1796,10 +1784,10 @@ static void __init kgdb_internal_init(vo

/* Initialize our spinlocks. */
for (i = 0; i < NR_CPUS; i++)
- spin_lock_init(&slavecpulocks[i]);
+ spin_lock_init(&slave_cpu_locks[i]);

- for (i = 0; i < MAX_BREAKPOINTS; i++)
- kgdb_break[i].state = bp_none;
+ for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++)
+ kgdb_break[i].state = BP_UNDEFINED;

/* Initialize the I/O handles */
memset(&kgdb_io_ops_prev, 0, sizeof(kgdb_io_ops_prev));
@@ -1811,7 +1799,7 @@ static void __init kgdb_internal_init(vo
register_console(&kgdbcons);
#endif

- kgdb_initialized = 1;
+ kgdb_state = KGDB_FULLY_INITIALIZED;
}

static void kgdb_register_for_panic(void)
@@ -1852,7 +1840,7 @@ int kgdb_register_io_module(struct kgdb_
}

/* Save the old values so they can be restored */
- if (kgdb_io_handler_cnt >= MAX_KGDB_IO_HANDLERS) {
+ if (kgdb_io_handler_cnt >= KGDB_MAX_IO_HANDLERS) {
printk(KERN_ERR "kgdb: No more I/O handles available.\n");
return -EINVAL;
}
@@ -1876,7 +1864,7 @@ int kgdb_register_io_module(struct kgdb_

return 0;
}
-EXPORT_SYMBOL(kgdb_register_io_module);
+EXPORT_SYMBOL_GPL(kgdb_register_io_module);

void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops)
{
@@ -1935,23 +1923,7 @@ void kgdb_unregister_io_module(struct kg
memset(&kgdb_io_ops, 0, sizeof(struct kgdb_io));
}
}
-EXPORT_SYMBOL(kgdb_unregister_io_module);
-
-/*
- * There are times we need to call a tasklet to cause a breakpoint
- * as calling breakpoint() at that point might be fatal. We have to
- * check that the exception stack is setup, as tasklets may be scheduled
- * prior to this. When that happens, it is up to the architecture to
- * schedule this when it is safe to run.
- */
-static void kgdb_tasklet_bpt(unsigned long ing)
-{
- if (CHECK_EXCEPTION_STACK())
- breakpoint();
-}
-EXPORT_SYMBOL(kgdb_tasklet_breakpoint);
-
-DECLARE_TASKLET(kgdb_tasklet_breakpoint, kgdb_tasklet_bpt, 0);
+EXPORT_SYMBOL_GPL(kgdb_unregister_io_module);

/*
* This function can be called very early, either via early_param() or
@@ -1969,7 +1941,7 @@ static void __init kgdb_early_entry(void
*/

if (!CHECK_EXCEPTION_STACK()) {
- kgdb_initialized = -1;
+ kgdb_state = KGDB_SEMI_INITIALIZED;
/* any kind of break point is deferred to late_init */
return;
}
@@ -1978,7 +1950,7 @@ static void __init kgdb_early_entry(void
/* For early entry kgdb_io_ops.init must be defined */
if (!kgdb_io_ops.init || kgdb_io_ops.init()) {
/* Try again later. */
- kgdb_initialized = -1;
+ kgdb_state = KGDB_SEMI_INITIALIZED;
return;
}

@@ -2002,20 +1974,16 @@ static void __init kgdb_early_entry(void
*/
static int __init kgdb_late_entry(void)
{
- int need_break = 0;
-
- /* If kgdb_initialized is -1 then we were passed kgdbwait. */
- if (kgdb_initialized == -1)
- need_break = 1;
+ int need_break = (kgdb_state == KGDB_SEMI_INITIALIZED);

/*
* If we haven't tried to initialize KGDB yet, we need to call
* kgdb_arch_init before moving onto the I/O.
*/
- if (!kgdb_initialized)
+ if (kgdb_state == KGDB_UNINITIALIZED)
kgdb_arch_init();

- if (kgdb_initialized != 1) {
+ if (kgdb_state != KGDB_FULLY_INITIALIZED) {
if (kgdb_io_ops.init && kgdb_io_ops.init()) {
/* When KGDB allows I/O via modules and the core
* I/O init fails KGDB must default to defering the
@@ -2072,7 +2040,7 @@ void breakpoint(void)
wmb(); /* Sync point after breakpoint */
atomic_set(&kgdb_setting_breakpoint, 0);
}
-EXPORT_SYMBOL(breakpoint);
+EXPORT_SYMBOL_GPL(breakpoint);

#ifdef CONFIG_MAGIC_SYSRQ
static void sysrq_handle_gdb(int key, struct tty_struct *tty)
@@ -2128,12 +2096,12 @@ static int __init opt_kgdb_attachwait(ch
static int __init opt_kgdb_enter(char *str)
{
/* We've already done this by an explicit breakpoint() call. */
- if (kgdb_initialized)
+ if (kgdb_state != KGDB_UNINITIALIZED)
return 0;

kgdb_early_entry();
attachwait = 1;
- if (kgdb_initialized == 1)
+ if (kgdb_state == KGDB_FULLY_INITIALIZED)
printk(KERN_CRIT "Waiting for connection from remote "
"gdb...\n");
else {
Index: b/arch/x86/kernel/kgdb.c
===================================================================
--- a/arch/x86/kernel/kgdb.c
+++ b/arch/x86/kernel/kgdb.c
@@ -57,7 +57,7 @@ static int gdb_x86errcode;
number through the usual means, and that's not very specific). */
static int gdb_x86vector = -1;

-void regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
+void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
{
gdb_regs[_AX] = regs->ax;
gdb_regs[_BX] = regs->bx;
@@ -122,7 +122,7 @@ void sleeping_thread_to_gdb_regs(unsigne
gdb_regs[_SP] = p->thread.sp;
}

-void gdb_regs_to_regs(unsigned long *gdb_regs, struct pt_regs *regs)
+void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
{
regs->ax = gdb_regs[_AX];
regs->bx = gdb_regs[_BX];
@@ -241,14 +241,14 @@ static int kgdb_set_hw_break(unsigned lo
return -1;

switch (bptype) {
- case bp_hardware_breakpoint:
+ case BP_HARDWARE_BREAKPOINT:
type = 0;
len = 1;
break;
- case bp_write_watchpoint:
+ case BP_WRITE_WATCHPOINT:
type = 1;
break;
- case bp_access_watchpoint:
+ case BP_ACCESS_WATCHPOINT:
type = 3;
break;
default:

[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 254 bytes --]