+2008-03-03 Jay Lan <jlan@sgi.com>
+
+ * kdb-v4.4-2.6.25-rc3-ia64-1.
+
+2008-02-26 Jay Lan <jlan@sgi.com>
+
+ * kdb-v4.4-2.6.25-rc2-ia64-1.
+
+2008-02-19 Jay Lan <jlan@sgi.com>
+
+ * kdb-v4.4-2.6.25-rc1-ia64-1.
+
2008-02-01 Jay Lan <jlan@sgi.com>
* Backed out USB UHCI support since it caused dropped characters and
Add a simple leak tracer to the IOMMU code. This is useful when you
are debugging a buggy device driver that leaks IOMMU mappings.
-config KDB
- bool "Built-in Kernel Debugger support"
- depends on DEBUG_KERNEL
- select KALLSYMS
- select KALLSYMS_ALL
- help
- This option provides a built-in kernel debugger. The built-in
- kernel debugger contains commands which allow memory to be examined,
- instructions to be disassembled and breakpoints to be set. For details,
- see Documentation/kdb/kdb.mm and the manual pages kdb_bt, kdb_ss, etc.
- Kdb can also be used via the serial port. Set up the system to
- have a serial console (see Documentation/serial-console.txt).
- The key sequence <escape>KDB on the serial port will cause the
- kernel debugger to be entered with input from the serial port and
- output to the serial console. If unsure, say N.
-
-config KDB_MODULES
- tristate "KDB modules"
- depends on KDB
- help
- KDB can be extended by adding your own modules, in directory
- kdb/modules. This option selects the way that these modules should
- be compiled, as free standing modules (select M) or built into the
- kernel (select Y). If unsure say M.
-
-config KDB_OFF
- bool "KDB off by default"
- depends on KDB
- help
- Normally kdb is activated by default, as long as CONFIG_KDB is set.
- If you want to ship a kernel with kdb support but only have kdb
- turned on when the user requests it then select this option. When
- compiled with CONFIG_KDB_OFF, kdb ignores all events unless you boot
- with kdb=on or you echo "1" > /proc/sys/kernel/kdb. This option also
- works in reverse, if kdb is normally activated, you can boot with
- kdb=off or echo "0" > /proc/sys/kernel/kdb to deactivate kdb. If
- unsure, say N.
-
-config KDB_CONTINUE_CATASTROPHIC
- int "KDB continues after catastrophic errors"
- depends on KDB
- default "0"
- help
- This integer controls the behaviour of kdb when the kernel gets a
- catastrophic error, i.e. for a panic, oops, NMI or other watchdog
- tripping. CONFIG_KDB_CONTINUE_CATASTROPHIC interacts with
- /proc/sys/kernel/kdb and CONFIG_LKCD_DUMP (if your kernel has the
- LKCD patch).
- When KDB is active (/proc/sys/kernel/kdb == 1) and a catastrophic
- error occurs, nothing extra happens until you type 'go'.
- CONFIG_KDB_CONTINUE_CATASTROPHIC == 0 (default). The first time
- you type 'go', kdb warns you. The second time you type 'go', KDB
- tries to continue - no guarantees that the kernel is still usable.
- CONFIG_KDB_CONTINUE_CATASTROPHIC == 1. KDB tries to continue - no
- guarantees that the kernel is still usable.
- CONFIG_KDB_CONTINUE_CATASTROPHIC == 2. If your kernel has the LKCD
- patch and LKCD is configured to take a dump then KDB forces a dump.
- Whether or not a dump is taken, KDB forces a reboot.
- When KDB is not active (/proc/sys/kernel/kdb == 0) and a catastrophic
- error occurs, the following steps are automatic, no human
- intervention is required.
- CONFIG_KDB_CONTINUE_CATASTROPHIC == 0 (default) or 1. KDB attempts
- to continue - no guarantees that the kernel is still usable.
- CONFIG_KDB_CONTINUE_CATASTROPHIC == 2. If your kernel has the LKCD
- patch and LKCD is configured to take a dump then KDB automatically
- forces a dump. Whether or not a dump is taken, KDB forces a
- reboot.
- If you are not sure, say 0. Read Documentation/kdb/dump.txt before
- setting to 2.
-
-config KDB_USB
- bool "Support for USB Keyboard in KDB (OHCI and/or EHCI only)"
- depends on KDB && (USB_OHCI_HCD || USB_EHCI_HCD)
- help
- If you want to use kdb from USB keyboards then say Y here. If you
- say N then kdb can only be used from a PC (AT) keyboard or a serial
- console.
-
#
# IO delay types:
#
help
Do change_page_attr() self-tests every 30 seconds.
+config KDB
+ bool "Built-in Kernel Debugger support"
+ depends on DEBUG_KERNEL
+ select KALLSYMS
+ select KALLSYMS_ALL
+ help
+ This option provides a built-in kernel debugger. The built-in
+ kernel debugger contains commands which allow memory to be examined,
+ instructions to be disassembled and breakpoints to be set. For details,
+ see Documentation/kdb/kdb.mm and the manual pages kdb_bt, kdb_ss, etc.
+ Kdb can also be used via the serial port. Set up the system to
+ have a serial console (see Documentation/serial-console.txt).
+ The key sequence <escape>KDB on the serial port will cause the
+ kernel debugger to be entered with input from the serial port and
+ output to the serial console. If unsure, say N.
+
+config KDB_MODULES
+ tristate "KDB modules"
+ depends on KDB
+ help
+ KDB can be extended by adding your own modules, in directory
+ kdb/modules. This option selects the way that these modules should
+ be compiled, as free standing modules (select M) or built into the
+ kernel (select Y). If unsure say M.
+
+config KDB_OFF
+ bool "KDB off by default"
+ depends on KDB
+ help
+ Normally kdb is activated by default, as long as CONFIG_KDB is set.
+ If you want to ship a kernel with kdb support but only have kdb
+ turned on when the user requests it then select this option. When
+ compiled with CONFIG_KDB_OFF, kdb ignores all events unless you boot
+ with kdb=on or you echo "1" > /proc/sys/kernel/kdb. This option also
+ works in reverse, if kdb is normally activated, you can boot with
+ kdb=off or echo "0" > /proc/sys/kernel/kdb to deactivate kdb. If
+ unsure, say N.
+
+config KDB_CONTINUE_CATASTROPHIC
+ int "KDB continues after catastrophic errors"
+ depends on KDB
+ default "0"
+ help
+ This integer controls the behaviour of kdb when the kernel gets a
+ catastrophic error, i.e. for a panic, oops, NMI or other watchdog
+ tripping. CONFIG_KDB_CONTINUE_CATASTROPHIC interacts with
+ /proc/sys/kernel/kdb and CONFIG_LKCD_DUMP (if your kernel has the
+ LKCD patch).
+ When KDB is active (/proc/sys/kernel/kdb == 1) and a catastrophic
+ error occurs, nothing extra happens until you type 'go'.
+ CONFIG_KDB_CONTINUE_CATASTROPHIC == 0 (default). The first time
+ you type 'go', kdb warns you. The second time you type 'go', KDB
+ tries to continue - no guarantees that the kernel is still usable.
+ CONFIG_KDB_CONTINUE_CATASTROPHIC == 1. KDB tries to continue - no
+ guarantees that the kernel is still usable.
+ CONFIG_KDB_CONTINUE_CATASTROPHIC == 2. If your kernel has the LKCD
+ patch and LKCD is configured to take a dump then KDB forces a dump.
+ Whether or not a dump is taken, KDB forces a reboot.
+ When KDB is not active (/proc/sys/kernel/kdb == 0) and a catastrophic
+ error occurs, the following steps are automatic, no human
+ intervention is required.
+ CONFIG_KDB_CONTINUE_CATASTROPHIC == 0 (default) or 1. KDB attempts
+ to continue - no guarantees that the kernel is still usable.
+ CONFIG_KDB_CONTINUE_CATASTROPHIC == 2. If your kernel has the LKCD
+ patch and LKCD is configured to take a dump then KDB automatically
+ forces a dump. Whether or not a dump is taken, KDB forces a
+ reboot.
+ If you are not sure, say 0. Read Documentation/kdb/dump.txt before
+ setting to 2.
+
+config KDB_USB
+ bool "Support for USB Keyboard in KDB (OHCI and/or EHCI only)"
+ depends on KDB && (USB_OHCI_HCD || USB_EHCI_HCD)
+ help
+ If you want to use kdb from USB keyboards then say Y here. If you
+ say N then kdb can only be used from a PC (AT) keyboard or a serial
+ console.
+
endmenu
ifeq ($(CONFIG_X86_32),y)
drivers-$(CONFIG_FB) += arch/x86/video/
endif
-drivers-$(CONFIG_KDB) += arch/x86/kdb/
+
+# KDB support
+drivers-$(CONFIG_KDB) += arch/x86/kdb/
####
# boot loader support. Several targets are kept for legacy purposes
+2008-03-03 Jay Lan <jlan@sgi.com>
+
+ * kdb-v4.4-2.6.25-rc3-x86-1.
+
+2008-02-26 Jay Lan <jlan@sgi.com>
+
+ * remove 'fastcall' from kdb code.
+ * Known problem: backtrace for i386 is broken since 2.6.25-rc1.
+ * kdb-v4.4-2.6.25-rc2-x86-1.
+
+2008-02-19 Jay Lan <jlan@sgi.com>
+
+ * Known problem: backtrace for i386 is broken.
+ * kdb-v4.4-2.6.25-rc1-x86-1.
+
2008-02-01 Jay Lan <jlan@sgi.com>
* Backed out USB UHCI support since it caused dropped characters and
* breakpoint (bc). This code recognises a breakpoint even when
* disabled but not when it has been cleared.
*
- * WARNING: This routine resets the eip. It should be called
+ * WARNING: This routine resets the ip. It should be called
* once per breakpoint and the result cached.
*/
* Determine which breakpoint was encountered.
*/
if (KDB_DEBUG(BP))
- kdb_printf("kdba_bp_trap: eip=0x%lx (not adjusted) "
- "eflags=0x%lx regs=0x%p esp=0x%lx\n",
+ kdb_printf("kdba_bp_trap: ip=0x%lx (not adjusted) "
+ "flags=0x%lx regs=0x%p sp=0x%lx\n",
regs->ip, regs->flags, regs, regs->sp);
rv = KDB_DB_NOBPT; /* Cause kdb() to return */
kdb_printf("kdba_installbp\n");
kdba_installbp(regs, bp);
if (!KDB_STATE(DOING_SS)) {
- regs->flags &= ~EF_TF;
+ regs->flags &= ~X86_EFLAGS_TF;
return(KDB_DB_SSBPT);
}
break;
kdb_printf("kdb: Unable to find delayed breakpoint\n");
}
if (!KDB_STATE(DOING_SS)) {
- regs->flags &= ~EF_TF;
+ regs->flags &= ~X86_EFLAGS_TF;
return(KDB_DB_NOBPT);
}
/* FALLTHROUGH */
}
if (rv != KDB_DB_SSB)
- regs->flags &= ~EF_TF;
+ regs->flags &= ~X86_EFLAGS_TF;
}
if (dr6 & DR6_B0) {
/*
* Set Resume Flag
*/
- regs->flags |= EF_RF;
+ regs->flags |= X86_EFLAGS_RF;
/*
* Determine which breakpoint was encountered.
}
unknown:
- regs->flags |= EF_RF; /* Supress further faults */
+ regs->flags |= X86_EFLAGS_RF; /* Supress further faults */
rv = KDB_DB_NOBPT; /* Cause kdb() to return */
handled:
* breakpoint (bc). This code recognises a breakpoint even when
* disabled but not when it has been cleared.
*
- * WARNING: This routine resets the rip. It should be called
+ * WARNING: This routine resets the ip. It should be called
* once per breakpoint and the result cached.
*/
* Determine which breakpoint was encountered.
*/
if (KDB_DEBUG(BP))
- kdb_printf("kdba_bp_trap: rip=0x%lx (not adjusted) "
- "eflags=0x%lx ef=0x%p rsp=0x%lx\n",
+ kdb_printf("kdba_bp_trap: ip=0x%lx (not adjusted) "
+ "flags=0x%lx ef=0x%p sp=0x%lx\n",
regs->ip, regs->flags, regs, regs->sp);
rv = KDB_DB_NOBPT; /* Cause kdb() to return */
dst->reg &&
bb_is_int_reg(dst->base_rc) &&
full_register_dst) {
-#ifndef CONFIG_X86_64
+#ifdef CONFIG_X86_32
/* mov from TSS_sysenter_sp0+offset to esp to fix up the
* sysenter stack, it leaves esp well defined. mov
- * TSS_sysenter_esp0+offset(%esp),%esp is followed by up to 5
+ * TSS_ysenter_sp0+offset(%esp),%esp is followed by up to 5
* push instructions to mimic the hardware stack push. If
- * TSS_sysenter_esp0 is offset then only 3 words will be
+ * TSS_sysenter_sp0 is offset then only 3 words will be
* pushed.
*/
if (dst->base_rc == BBRG_RSP &&
"\n");
return BBOU_NOP;
}
-#endif /* !CONFIG_X86_64 */
+#endif /* CONFIG_X86_32 */
bb_read_operand(src);
bb_reg_set_memory(dst->base_rc, src->base_rc, src->disp);
return BBOU_NOP;
* None.
* Remarks:
* If kdb was entered via an interrupt from the kernel itself then
- * ss and esp are *not* on the stack.
+ * ss and sp are *not* on the stack.
*/
static struct kdbregs {
char *reg_name;
size_t reg_offset;
} kdbreglist[] = {
- { "eax", offsetof(struct pt_regs, ax) },
- { "ebx", offsetof(struct pt_regs, bx) },
- { "ecx", offsetof(struct pt_regs, cx) },
- { "edx", offsetof(struct pt_regs, dx) },
+ { "ax", offsetof(struct pt_regs, ax) },
+ { "bx", offsetof(struct pt_regs, bx) },
+ { "cx", offsetof(struct pt_regs, cx) },
+ { "dx", offsetof(struct pt_regs, dx) },
- { "esi", offsetof(struct pt_regs, si) },
- { "edi", offsetof(struct pt_regs, di) },
- { "esp", offsetof(struct pt_regs, sp) },
- { "eip", offsetof(struct pt_regs, ip) },
+ { "si", offsetof(struct pt_regs, si) },
+ { "di", offsetof(struct pt_regs, di) },
+ { "sp", offsetof(struct pt_regs, sp) },
+ { "ip", offsetof(struct pt_regs, ip) },
- { "ebp", offsetof(struct pt_regs, bp) },
- { "xss", offsetof(struct pt_regs, ss) },
- { "xcs", offsetof(struct pt_regs, cs) },
- { "eflags", offsetof(struct pt_regs, flags) },
+ { "bp", offsetof(struct pt_regs, bp) },
+ { "ss", offsetof(struct pt_regs, ss) },
+ { "cs", offsetof(struct pt_regs, cs) },
+ { "flags", offsetof(struct pt_regs, flags) },
- { "xds", offsetof(struct pt_regs, ds) },
- { "xes", offsetof(struct pt_regs, es) },
- { "origeax", offsetof(struct pt_regs, orig_ax) },
+ { "ds", offsetof(struct pt_regs, ds) },
+ { "es", offsetof(struct pt_regs, es) },
+ { "origax", offsetof(struct pt_regs, orig_ax) },
};
if (strcmp(regname, "kesp") == 0) {
*contents = (unsigned long)regs + sizeof(struct pt_regs);
if ((regs->cs & 0xffff) == __KERNEL_CS) {
- /* esp and ss are not on stack */
+ /* sp and ss are not on stack */
*contents -= 2*4;
}
return 0;
if ((i < nkdbreglist)
&& (strlen(kdbreglist[i].reg_name) == strlen(regname))) {
if ((regs->cs & 0xffff) == __KERNEL_CS) {
- /* No cpl switch, esp and ss are not on stack */
- if (strcmp(kdbreglist[i].reg_name, "esp") == 0) {
+ /* No cpl switch, sp and ss are not on stack */
+ if (strcmp(kdbreglist[i].reg_name, "sp") == 0) {
*contents = (kdb_machreg_t)regs +
sizeof(struct pt_regs) - 2*4;
return(0);
* 0 KDB was invoked for an event which it wasn't responsible
* 1 KDB handled the event for which it was invoked.
* Outputs:
- * Sets eip and esp in current->thread.
+ * Sets ip and sp in current->thread.
* Locking:
* None.
* Remarks:
p = (struct pt_regs *) addr;
kdb_printf("struct pt_regs 0x%p-0x%p\n", p, (unsigned char *)p + sizeof(*p) - 1);
- kdb_print_nameval("ebx", p->bx);
- kdb_print_nameval("ecx", p->cx);
- kdb_print_nameval("edx", p->dx);
- kdb_print_nameval("esi", p->si);
- kdb_print_nameval("edi", p->di);
- kdb_print_nameval("ebp", p->bp);
- kdb_print_nameval("eax", p->ax);
- kdb_printf(fmt, "xds", p->ds);
- kdb_printf(fmt, "xes", p->es);
- kdb_print_nameval("orig_eax", p->orig_ax);
- kdb_print_nameval("eip", p->ip);
- kdb_printf(fmt, "xcs", p->cs);
- kdb_printf(fmt, "eflags", p->flags);
- kdb_printf(fmt, "esp", p->sp);
- kdb_printf(fmt, "xss", p->ss);
+ kdb_print_nameval("bx", p->bx);
+ kdb_print_nameval("cx", p->cx);
+ kdb_print_nameval("dx", p->dx);
+ kdb_print_nameval("si", p->si);
+ kdb_print_nameval("di", p->di);
+ kdb_print_nameval("bp", p->bp);
+ kdb_print_nameval("ax", p->ax);
+ kdb_printf(fmt, "ds", p->ds);
+ kdb_printf(fmt, "es", p->es);
+ kdb_print_nameval("orig_ax", p->orig_ax);
+ kdb_print_nameval("ip", p->ip);
+ kdb_printf(fmt, "cs", p->cs);
+ kdb_printf(fmt, "flags", p->flags);
+ kdb_printf(fmt, "sp", p->sp);
+ kdb_printf(fmt, "ss", p->ss);
return 0;
}
*/
static void
-kdba_stackdepth1(struct task_struct *p, unsigned long esp)
+kdba_stackdepth1(struct task_struct *p, unsigned long sp)
{
struct thread_info *tinfo;
int used;
const char *type;
kdb_ps1(p);
do {
- tinfo = (struct thread_info *)(esp & -THREAD_SIZE);
- used = sizeof(*tinfo) + THREAD_SIZE - (esp & (THREAD_SIZE-1));
+ tinfo = (struct thread_info *)(sp & -THREAD_SIZE);
+ used = sizeof(*tinfo) + THREAD_SIZE - (sp & (THREAD_SIZE-1));
type = NULL;
if (kdb_task_has_cpu(p)) {
struct kdb_activation_record ar;
memset(&ar, 0, sizeof(ar));
- kdba_get_stack_info_alternate(esp, -1, &ar);
+ kdba_get_stack_info_alternate(sp, -1, &ar);
type = ar.stack.id;
}
if (!type)
type = "process";
- kdb_printf(" %s stack %p esp %lx used %d\n", type, tinfo, esp, used);
- esp = tinfo->previous_esp;
- } while (esp);
+ kdb_printf(" %s stack %p sp %lx used %d\n", type, tinfo, sp, used);
+ sp = tinfo->previous_esp;
+ } while (sp);
}
static int
* ®s - Prints address of exception frame
* krsp - Prints kernel stack pointer at time of fault
* crsp - Prints current kernel stack pointer, inside kdb
- * cflags - Prints current flags, inside kdb
+ * ceflags - Prints current flags, inside kdb
* %<regname> - Uses the value of the registers at the
* last time the user process entered kernel
* mode, instead of the registers at the time
* None.
* Remarks:
* If kdb was entered via an interrupt from the kernel itself then
- * ss and rsp are *not* on the stack.
+ * ss and sp are *not* on the stack.
*/
static struct kdbregs {
{ "r14", offsetof(struct pt_regs, r14) },
{ "r13", offsetof(struct pt_regs, r13) },
{ "r12", offsetof(struct pt_regs, r12) },
- { "bp", offsetof(struct pt_regs, bp) },
- { "rbx", offsetof(struct pt_regs, bx) },
+ { "bp", offsetof(struct pt_regs, bp) },
+ { "bx", offsetof(struct pt_regs, bx) },
{ "r11", offsetof(struct pt_regs, r11) },
{ "r10", offsetof(struct pt_regs, r10) },
{ "r9", offsetof(struct pt_regs, r9) },
{ "r8", offsetof(struct pt_regs, r8) },
- { "rax", offsetof(struct pt_regs, ax) },
- { "rcx", offsetof(struct pt_regs, cx) },
- { "rdx", offsetof(struct pt_regs, dx) },
- { "rsi", offsetof(struct pt_regs, si) },
- { "rdi", offsetof(struct pt_regs, di) },
- { "orig_rax", offsetof(struct pt_regs, orig_ax) },
- { "rip", offsetof(struct pt_regs, ip) },
+ { "ax", offsetof(struct pt_regs, ax) },
+ { "cx", offsetof(struct pt_regs, cx) },
+ { "dx", offsetof(struct pt_regs, dx) },
+ { "si", offsetof(struct pt_regs, si) },
+ { "di", offsetof(struct pt_regs, di) },
+ { "orig_ax", offsetof(struct pt_regs, orig_ax) },
+ { "ip", offsetof(struct pt_regs, ip) },
{ "cs", offsetof(struct pt_regs, cs) },
{ "flags", offsetof(struct pt_regs, flags) },
- { "rsp", offsetof(struct pt_regs, sp) },
+ { "sp", offsetof(struct pt_regs, sp) },
{ "ss", offsetof(struct pt_regs, ss) },
};
if (strcmp(regname, "krsp") == 0) {
*contents = (unsigned long)regs + sizeof(struct pt_regs);
if ((regs->cs & 0xffff) == __KERNEL_CS) {
- /* rsp and ss are not on stack */
+ /* sp and ss are not on stack */
*contents -= 2*4;
}
return 0;
return 0;
}
- if (strcmp(regname, "cflags") == 0) {
+ if (strcmp(regname, "ceflags") == 0) {
unsigned long flags;
local_save_flags(flags);
*contents = flags;
if ((i < nkdbreglist)
&& (strlen(kdbreglist[i].reg_name) == strlen(regname))) {
if ((regs->cs & 0xffff) == __KERNEL_CS) {
- /* No cpl switch, rsp is not on stack */
- if (strcmp(kdbreglist[i].reg_name, "rsp") == 0) {
+ /* No cpl switch, sp is not on stack */
+ if (strcmp(kdbreglist[i].reg_name, "sp") == 0) {
*contents = (kdb_machreg_t)regs +
sizeof(struct pt_regs) - 2*8;
return(0);
* 0 KDB was invoked for an event which it wasn't responsible
* 1 KDB handled the event for which it was invoked.
* Outputs:
- * Sets rip and rsp in current->thread.
+ * Sets ip and sp in current->thread.
* Locking:
* None.
* Remarks:
int ret;
if (regs)
- kdba_getregcontents("rsp", regs, &(current->thread.sp));
+ kdba_getregcontents("sp", regs, &(current->thread.sp));
ret = kdb_save_running(regs, reason, reason2, error, db_result);
kdb_unsave_running(regs);
return ret;
{
if (KDB_NULL_REGS(regs))
return;
- if (regs->flags & EF_IE)
+ if (regs->flags & X86_EFLAGS_IF)
KDB_STATE_SET(A_IF);
else
KDB_STATE_CLEAR(A_IF);
- regs->flags = (regs->flags | EF_TF) & ~EF_IE;
+ regs->flags = (regs->flags | X86_EFLAGS_TF) & ~X86_EFLAGS_IF;
}
void
if (KDB_NULL_REGS(regs))
return;
if (KDB_STATE(A_IF))
- regs->flags |= EF_IE;
+ regs->flags |= X86_EFLAGS_IF;
else
- regs->flags &= ~EF_IE;
+ regs->flags &= ~X86_EFLAGS_IF;
}
int asmlinkage
#else /* !CONFIG_FRAME_POINTER */
__asm__ __volatile__
("movq %%rbx, (0*8)(%%rdi);"
- "movq %%bp, (1*8)(%%rdi);"
+ "movq %%rbp, (1*8)(%%rdi);"
"movq %%r12, (2*8)(%%rdi);"
"movq %%r13, (3*8)(%%rdi);"
"movq %%r14, (4*8)(%%rdi);"
if (first_time) {
first_time = 0;
kdb_printf("\n+++ Warning: x86_64 pt_regs are not always "
- "completely defined, r15-rbx may be invalid\n\n");
+ "completely defined, r15-bx may be invalid\n\n");
}
kdb_printf("struct pt_regs 0x%p-0x%p\n", p, (unsigned char *)p + sizeof(*p) - 1);
kdb_print_nameval("r15", p->r15);
kdb_print_nameval("r13", p->r13);
kdb_print_nameval("r12", p->r12);
kdb_print_nameval("bp", p->bp);
- kdb_print_nameval("rbx", p->bx);
+ kdb_print_nameval("bx", p->bx);
kdb_print_nameval("r11", p->r11);
kdb_print_nameval("r10", p->r10);
kdb_print_nameval("r9", p->r9);
kdb_print_nameval("r8", p->r8);
- kdb_print_nameval("rax", p->ax);
- kdb_print_nameval("rcx", p->cx);
- kdb_print_nameval("rdx", p->dx);
- kdb_print_nameval("rsi", p->si);
- kdb_print_nameval("rdi", p->di);
- kdb_print_nameval("orig_rax", p->orig_ax);
- kdb_print_nameval("rip", p->ip);
+ kdb_print_nameval("ax", p->ax);
+ kdb_print_nameval("cx", p->cx);
+ kdb_print_nameval("dx", p->dx);
+ kdb_print_nameval("si", p->si);
+ kdb_print_nameval("di", p->di);
+ kdb_print_nameval("orig_ax", p->orig_ax);
+ kdb_print_nameval("ip", p->ip);
kdb_printf(fmt, "cs", p->cs);
kdb_printf(fmt, "flags", p->flags);
- kdb_printf(fmt, "rsp", p->sp);
+ kdb_printf(fmt, "sp", p->sp);
kdb_printf(fmt, "ss", p->ss);
return 0;
}
-#ifdef CONFIG_KDB
-#include <linux/kdb.h>
-#endif /* CONFIG_KDB */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/reboot.h>
#include <linux/init.h>
#include <linux/pm.h>
#include <linux/efi.h>
+#ifdef CONFIG_KDB
+#include <linux/kdb.h>
+#endif /* CONFIG_KDB */
#include <acpi/reboot.h>
#include <asm/io.h>
#include <asm/apic.h>
/* Make certain I only run on the appropriate processor */
set_cpus_allowed(current, cpumask_of_cpu(reboot_cpu_id));
- /* O.K Now that I'm on the appropriate processor,
- * stop all of the others.
- */
-#ifdef CONFIG_KDB
+#if defined(CONFIG_X86_32) && defined(CONFIG_KDB)
/*
* If this restart is occuring while kdb is running (e.g. reboot
* command), the other CPU's are already stopped. Don't try to
* stop them yet again.
*/
if (!KDB_IS_RUNNING())
-#endif /* CONFIG_KDB */
+#endif /* defined(CONFIG_X86_32) && defined(CONFIG_KDB) */
+ /* O.K Now that I'm on the appropriate processor,
+ * stop all of the others.
+ */
smp_send_stop();
#endif
}
DO_VM86_ERROR_INFO( 0, SIGFPE, "divide error", divide_error, FPE_INTDIV, regs->ip)
-#if !defined(CONFIG_KPROBES) && !defined(CONFIG_KDB)
+#if !defined(CONFIG_KPROBES) && !defined(CONFIG_KDB)
DO_VM86_ERROR( 3, SIGTRAP, "int3", int3)
#endif
DO_VM86_ERROR( 4, SIGSEGV, "overflow", overflow)
}
EXPORT_SYMBOL_GPL (usb_hc_died);
-#ifdef CONFIG_KDB_USB
-void *
-usb_hcd_get_kdb_poll_func(struct usb_device *udev)
-{
- struct usb_hcd *hcd = bus_to_hcd(udev->bus);
-
- if (hcd && hcd->driver)
- return (void *)(hcd->driver->kdb_poll_char);
-
- return NULL;
-}
-EXPORT_SYMBOL_GPL (usb_hcd_get_kdb_poll_func);
-#endif /* CONFIG_KDB_USB */
-
/*-------------------------------------------------------------------------*/
/**
}
EXPORT_SYMBOL_GPL(usb_hcd_platform_shutdown);
+#ifdef CONFIG_KDB_USB
+void *
+usb_hcd_get_kdb_poll_func(struct usb_device *udev)
+{
+ struct usb_hcd *hcd = bus_to_hcd(udev->bus);
+
+ if (hcd && hcd->driver)
+ return (void *)(hcd->driver->kdb_poll_char);
+
+ return NULL;
+}
+EXPORT_SYMBOL_GPL (usb_hcd_get_kdb_poll_func);
+#endif /* CONFIG_KDB_USB */
+
/*-------------------------------------------------------------------------*/
#if defined(CONFIG_USB_MON)
void (*relinquish_port)(struct usb_hcd *, int);
#ifdef CONFIG_KDB_USB
/* KDB poll function for this HC */
- int (*kdb_poll_char)(struct urb *urb);
+ int (*kdb_poll_char)(struct urb *urb);
#endif /* CONFIG_KDB_USB */
};
/* this struct defines the way the registers are stored on the
stack during a system call. */
+enum EFLAGS {
+ EF_CF = 0x00000001,
+ EF_PF = 0x00000004,
+ EF_AF = 0x00000010,
+ EF_ZF = 0x00000040,
+ EF_SF = 0x00000080,
+ EF_TF = 0x00000100,
+ EF_IE = 0x00000200,
+ EF_DF = 0x00000400,
+ EF_OF = 0x00000800,
+ EF_IOPL = 0x00003000,
+ EF_IOPL_RING0 = 0x00000000,
+ EF_IOPL_RING1 = 0x00001000,
+ EF_IOPL_RING2 = 0x00002000,
+ EF_NT = 0x00004000, /* nested task */
+ EF_RF = 0x00010000, /* resume */
+ EF_VM = 0x00020000, /* virtual mode */
+ EF_AC = 0x00040000, /* alignment */
+ EF_VIF = 0x00080000, /* virtual interrupt */
+ EF_VIP = 0x00100000, /* virtual interrupt pending */
+ EF_ID = 0x00200000, /* id */
+};
+
#ifndef __KERNEL__
struct pt_regs {
#endif /* __KERNEL__ */
#endif /* !__i386__ */
-enum EFLAGS {
- EF_CF = 0x00000001,
- EF_PF = 0x00000004,
- EF_AF = 0x00000010,
- EF_ZF = 0x00000040,
- EF_SF = 0x00000080,
- EF_TF = 0x00000100,
- EF_IE = 0x00000200,
- EF_DF = 0x00000400,
- EF_OF = 0x00000800,
- EF_IOPL = 0x00003000,
- EF_IOPL_RING0 = 0x00000000,
- EF_IOPL_RING1 = 0x00001000,
- EF_IOPL_RING2 = 0x00002000,
- EF_NT = 0x00004000, /* nested task */
- EF_RF = 0x00010000, /* resume */
- EF_VM = 0x00020000, /* virtual mode */
- EF_AC = 0x00040000, /* alignment */
- EF_VIF = 0x00080000, /* virtual interrupt */
- EF_VIP = 0x00100000, /* virtual interrupt pending */
- EF_ID = 0x00200000, /* id */
-};
-
#ifdef __KERNEL__
/* the DS BTS struct is used for ptrace as well */
+2008-03-03 Jay Lan <jlan@sgi.com>
+
+ * kdb-v4.4-2.6.25-rc3-common-1.
+
+2008-02-26 Jay Lan <jlan@sgi.com>
+
+ * remove 'fastcall' from kdb code.
+ * kdb-v4.4-2.6.25-rc2-common-1.
+
+2008-02-19 Jay Lan <jlan@sgi.com>
+
+ * kdb-v4.4-2.6.25-rc1-common-1.
+
2008-02-06 Jay Lan <jlan@sgi.com>
* Backed out USB UHCI support since it caused dropped characters and
/* Standard Linux page stuff */
-#ifndef CONFIG_DISCONTIGMEM
+#if !defined(CONFIG_DISCONTIGMEM) && !defined(CONFIG_NUMA)
/* From include/linux/page-flags.h */
static char *pg_flag_vals[] = {
"PG_locked", "PG_error", "PG_referenced", "PG_uptodate",
"Uptodate", "Dirty", "Lock", "Req",
"Uptodate_Lock", "Mapped", "New", "Async_read",
"Async_write", "Delay", "Boundary", "Write_EIO",
- "Ordered", "Eopnotsupp", "Unwritten", "Private",
+ "Ordered", "Eopnotsupp", "Unwritten", "Priavate",
NULL };
/* From include/linux/bio.h */
return 0;
}
-#ifndef CONFIG_DISCONTIGMEM
+#if !defined(CONFIG_DISCONTIGMEM) && !defined(CONFIG_NUMA)
static char *page_flags(unsigned long flags)
{
return(map_flags(flags, pg_flag_vals));
static int
kdbm_page(int argc, const char **argv)
{
-#ifndef CONFIG_NEED_MULTIPLE_NODES
struct page page;
unsigned long addr;
long offset = 0;
kdb_printf(" buffers 0x%p\n", page_buffers(&page));
else
kdb_printf(" private 0x%lx\n", page_private(&page));
-#endif
- kdb_printf("Unimplemented with CONFIG_NEED_MULTIPLE_NODES enabled\n");
+
return 0;
}
-#endif /* CONFIG_DISCONTIGMEM */
+#endif /* !CONFIG_DISCONTIGMEM && !NUMA */
static unsigned long
print_request(unsigned long addr)
}
-
-#if defined(CONFIG_X86) && !defined(CONFIG_X86_64)
+#if !defined(CONFIG_DISCONTIGMEM) && !defined(CONFIG_NUMA)
/* According to Steve Lord, this code is ix86 specific. Patches to extend it to
* other architectures will be greatefully accepted.
*/
static int
kdbm_memmap(int argc, const char **argv)
{
-#ifndef CONFIG_NEED_MULTIPLE_NODES
struct page page;
int i, page_count;
int slab_count = 0;
i, page_counts[i]);
}
kdb_printf(" high page count: %6d\n", page_counts[8]);
-#else
- kdb_printf("Unimplemented with CONFIG_NEED_MULTIPLE_NODES enabled\n");
-#endif
-
return 0;
}
-#endif /* CONFIG_X86 && !CONFIG_X86_64 */
+#endif /* !CONFIG_DISCONTIGMEM && !NUMA */
static int __init kdbm_pg_init(void)
{
-#ifndef CONFIG_DISCONTIGMEM
+#if !defined(CONFIG_DISCONTIGMEM) && !defined(CONFIG_NUMA)
kdb_register("page", kdbm_page, "<vaddr>", "Display page", 0);
#endif
kdb_register("inode", kdbm_inode, "<vaddr>", "Display inode", 0);
kdb_register("inode_pages", kdbm_inode_pages, "<inode *>", "Display pages in an inode", 0);
kdb_register("req", kdbm_request, "<vaddr>", "dump request struct", 0);
kdb_register("rqueue", kdbm_rqueue, "<vaddr>", "dump request queue", 0);
-#if defined(CONFIG_X86) && !defined(CONFIG_X86_64)
+#if !defined(CONFIG_DISCONTIGMEM) && !defined(CONFIG_NUMA)
kdb_register("memmap", kdbm_memmap, "", "page table summary", 0);
#endif
static void __exit kdbm_pg_exit(void)
{
-#ifndef CONFIG_DISCONTIGMEM
+#if !defined(CONFIG_DISCONTIGMEM) && !defined(CONFIG_NUMA)
kdb_unregister("page");
#endif
kdb_unregister("inode");
kdb_unregister("inode_pages");
kdb_unregister("req");
kdb_unregister("rqueue");
-#if defined(CONFIG_X86) && !defined(CONFIG_X86_64)
+#if !defined(CONFIG_DISCONTIGMEM) && !defined(CONFIG_NUMA)
kdb_unregister("memmap");
#endif
}
kdb_printf("\n");
}
+ if (k.name != kobject_name((struct kobject *)addr))
+ kdb_printf(" name '%." __stringify(KOBJ_NAME_LEN) "s'\n", k.name);
+
kdb_printf(" kref.refcount %d'\n", atomic_read(&k.kref.refcount));
kdb_printf(" entry.next = 0x%p entry.prev = 0x%p\n",
sd->siblings.next, sd->siblings.prev, sd->host);
kdb_printf("device_busy = %d current_cmnd 0x%p\n",
sd->device_busy, sd->current_cmnd);
- kdb_printf("id/lun/chan = [%d/%d/%d] device_blocked = %d\n",
- sd->id, sd->lun, sd->channel, sd->device_blocked);
+ kdb_printf("id/lun/chan = [%d/%d/%d] single_lun = %d device_blocked = %d\n",
+ sd->id, sd->lun, sd->channel, sd->sdev_target->single_lun, sd->device_blocked);
kdb_printf("queue_depth = %d current_tag = %d scsi_level = %d\n",
sd->queue_depth, sd->current_tag, sd->scsi_level);
kdb_printf("%8.8s %16.16s %4.4s\n", sd->vendor, sd->model, sd->rev);
sc->cmnd[0], sc->cmnd[1], sc->cmnd[2], sc->cmnd[3], sc->cmnd[4],
sc->cmnd[5], sc->cmnd[6], sc->cmnd[7], sc->cmnd[8], sc->cmnd[9],
sc->cmnd[10], sc->cmnd[11]);
-#if 0
kdb_printf("request_buffer = 0x%p request_bufflen = %d\n",
- sc->request_buffer, sc->request_bufflen);
- kdb_printf("use_sg = %d\n", sc->use_sg);
-#endif
+ scsi_sglist(sc), scsi_bufflen(sc));
+ kdb_printf("use_sg = %d\n", scsi_sg_count(sc));
kdb_printf("underflow = %d transfersize = %d\n",
sc->underflow, sc->transfersize);
kdb_printf("tag = %d\n", sc->tag);
{
#ifdef CONFIG_X86_64
int i;
- kdb_printf(" rsp0 = 0x%016Lx, rsp1 = 0x%016Lx\n",
+ kdb_printf(" sp0 = 0x%016Lx, sp1 = 0x%016Lx\n",
t->x86_tss.sp0, t->x86_tss.sp1);
- kdb_printf(" rsp2 = 0x%016Lx\n", t->x86_tss.sp2);
+ kdb_printf(" sp2 = 0x%016Lx\n", t->x86_tss.sp2);
for (i = 0; i < ARRAY_SIZE(t->x86_tss.ist); ++i)
kdb_printf(" ist[%d] = 0x%016Lx\n",
i, t->x86_tss.ist[i]);
kdb_printf(" iomap = 0x%04x\n", t->x86_tss.io_bitmap_base);
#else /* !CONFIG_X86_64 */
- kdb_printf(" cs = %04x, eip = " kdb_machreg_fmt0 "\n",
+ kdb_printf(" cs = %04x, ip = " kdb_machreg_fmt0 "\n",
t->x86_tss.es, t->x86_tss.ip);
- kdb_printf(" ss = %04x, esp = " kdb_machreg_fmt0 "\n",
+ kdb_printf(" ss = %04x, sp = " kdb_machreg_fmt0 "\n",
t->x86_tss.ss, t->x86_tss.sp);
- kdb_printf(" ss0 = %04x, esp0 = " kdb_machreg_fmt0 "\n",
+ kdb_printf(" ss0 = %04x, sp0 = " kdb_machreg_fmt0 "\n",
t->x86_tss.ss0, t->x86_tss.sp0);
- kdb_printf(" ss1 = %04x, esp1 = " kdb_machreg_fmt0 "\n",
+ kdb_printf(" ss1 = %04x, sp1 = " kdb_machreg_fmt0 "\n",
t->x86_tss.ss1, t->x86_tss.sp1);
- kdb_printf(" ss2 = %04x, esp2 = " kdb_machreg_fmt0 "\n",
+ kdb_printf(" ss2 = %04x, sp2 = " kdb_machreg_fmt0 "\n",
t->x86_tss.ss2, t->x86_tss.sp2);
kdb_printf(" ldt = %04x, cr3 = " kdb_machreg_fmt0 "\n",
t->x86_tss.ldt, t->x86_tss.__cr3);
kdb_printf(" ds = %04x, es = %04x fs = %04x gs = %04x\n",
t->x86_tss.ds, t->x86_tss.es, t->x86_tss.fs, t->x86_tss.gs);
- kdb_printf(" eax = " kdb_machreg_fmt0 ", ebx = " kdb_machreg_fmt0
- " ecx = " kdb_machreg_fmt0 " edx = " kdb_machreg_fmt0 "\n",
+ kdb_printf(" ax = " kdb_machreg_fmt0 ", bx = " kdb_machreg_fmt0
+ " cx = " kdb_machreg_fmt0 " dx = " kdb_machreg_fmt0 "\n",
t->x86_tss.ax, t->x86_tss.bx, t->x86_tss.cx, t->x86_tss.dx);
- kdb_printf(" esi = " kdb_machreg_fmt0 ", edi = " kdb_machreg_fmt0
- " ebp = " kdb_machreg_fmt0 "\n",
+ kdb_printf(" si = " kdb_machreg_fmt0 ", di = " kdb_machreg_fmt0
+ " bp = " kdb_machreg_fmt0 "\n",
t->x86_tss.si, t->x86_tss.di, t->x86_tss.bp);
kdb_printf(" trace = %d, iomap = 0x%04x\n", t->x86_tss.trace, t->x86_tss.io_bitmap_base);
#endif /* CONFIG_X86_64 */
projects / linux-flexiantxendom0-3.2.10.git / commitdiff