void show_regs(struct pt_regs *fp) { #ifdef CONFIG_DEBUG_VERBOSE char buf [150]; struct irqaction *action; unsigned int i; unsigned long flags = 0; unsigned int cpu = smp_processor_id(); unsigned char in_atomic = (bfin_read_IPEND() & 0x10) || in_atomic(); verbose_printk(KERN_NOTICE "\n" KERN_NOTICE "SEQUENCER STATUS:\t\t%s\n", print_tainted()); verbose_printk(KERN_NOTICE " SEQSTAT: %08lx IPEND: %04lx SYSCFG: %04lx\n", (long)fp->seqstat, fp->ipend, fp->syscfg); if ((fp->seqstat & SEQSTAT_EXCAUSE) == VEC_HWERR) { verbose_printk(KERN_NOTICE " HWERRCAUSE: 0x%lx\n", (fp->seqstat & SEQSTAT_HWERRCAUSE) >> 14); #ifdef EBIU_ERRMST /* If the error was from the EBIU, print it out */ if (bfin_read_EBIU_ERRMST() & CORE_ERROR) { verbose_printk(KERN_NOTICE " EBIU Error Reason : 0x%04x\n", bfin_read_EBIU_ERRMST()); verbose_printk(KERN_NOTICE " EBIU Error Address : 0x%08x\n", bfin_read_EBIU_ERRADD()); } #endif }
void show_regs(struct pt_regs * regs) { unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L; printk("\n"); printk("Pid: %d, comm: %20s\n", current->pid, current->comm); printk("EIP: %04x:[<%08lx>] CPU: %d\n",0xffff & regs->xcs,regs->eip, smp_processor_id()); print_symbol("EIP is at %s\n", regs->eip); if (user_mode_vm(regs)) printk(" ESP: %04x:%08lx",0xffff & regs->xss,regs->esp); printk(" EFLAGS: %08lx %s (%s %.*s)\n", regs->eflags, print_tainted(), system_utsname.release, (int)strcspn(system_utsname.version, " "), system_utsname.version); printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n", regs->eax,regs->ebx,regs->ecx,regs->edx); printk("ESI: %08lx EDI: %08lx EBP: %08lx", regs->esi, regs->edi, regs->ebp); printk(" DS: %04x ES: %04x\n", 0xffff & regs->xds,0xffff & regs->xes); cr0 = read_cr0(); cr2 = read_cr2(); cr3 = read_cr3(); cr4 = read_cr4_safe(); printk("CR0: %08lx CR2: %08lx CR3: %08lx CR4: %08lx\n", cr0, cr2, cr3, cr4); show_trace(NULL, regs, ®s->esp); }
void show_regs(struct pt_regs *regs) { printk("PC is at %pS\n", (void *)instruction_pointer(regs)); printk("LP is at %pS\n", (void *)regs->lp); pr_info("pc : [<%08lx>] lp : [<%08lx>] %s\n" "sp : %08lx fp : %08lx gp : %08lx\n", instruction_pointer(regs), regs->lp, print_tainted(), regs->sp, regs->fp, regs->gp); pr_info("r25: %08lx r24: %08lx\n", regs->uregs[25], regs->uregs[24]); pr_info("r23: %08lx r22: %08lx r21: %08lx r20: %08lx\n", regs->uregs[23], regs->uregs[22], regs->uregs[21], regs->uregs[20]); pr_info("r19: %08lx r18: %08lx r17: %08lx r16: %08lx\n", regs->uregs[19], regs->uregs[18], regs->uregs[17], regs->uregs[16]); pr_info("r15: %08lx r14: %08lx r13: %08lx r12: %08lx\n", regs->uregs[15], regs->uregs[14], regs->uregs[13], regs->uregs[12]); pr_info("r11: %08lx r10: %08lx r9 : %08lx r8 : %08lx\n", regs->uregs[11], regs->uregs[10], regs->uregs[9], regs->uregs[8]); pr_info("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", regs->uregs[7], regs->uregs[6], regs->uregs[5], regs->uregs[4]); pr_info("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", regs->uregs[3], regs->uregs[2], regs->uregs[1], regs->uregs[0]); pr_info(" IRQs o%s Segment %s\n", interrupts_enabled(regs) ? "n" : "ff", segment_eq(get_fs(), get_ds())? "kernel" : "user"); }
static void spin_bug(spinlock_t *lock, const char *msg) { static long print_once = 1; struct task_struct *owner = NULL; if (xchg(&print_once, 0)) { if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT) owner = lock->owner; printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d (%s)\n", msg, raw_smp_processor_id(), current->comm, current->pid, print_tainted()); printk(KERN_EMERG " lock: %p, .magic: %08x, .owner: %s/%d, " ".owner_cpu: %d\n", lock, lock->magic, owner ? owner->comm : "<none>", owner ? owner->pid : -1, lock->owner_cpu); dump_stack(); #ifdef CONFIG_SMP /* * We cannot continue on SMP: */ if (nopanic) printk("bad locking\n"); else panic("bad locking"); #endif } }
void dik_show_regs(struct pt_regs *regs, unsigned long *r9_15) { printk("pc = [<%016lx>] ra = [<%016lx>] ps = %04lx %s\n", regs->pc, regs->r26, regs->ps, print_tainted()); print_symbol("pc is at %s\n", regs->pc); print_symbol("ra is at %s\n", regs->r26 ); printk("v0 = %016lx t0 = %016lx t1 = %016lx\n", regs->r0, regs->r1, regs->r2); printk("t2 = %016lx t3 = %016lx t4 = %016lx\n", regs->r3, regs->r4, regs->r5); printk("t5 = %016lx t6 = %016lx t7 = %016lx\n", regs->r6, regs->r7, regs->r8); if (r9_15) { printk("s0 = %016lx s1 = %016lx s2 = %016lx\n", r9_15[9], r9_15[10], r9_15[11]); printk("s3 = %016lx s4 = %016lx s5 = %016lx\n", r9_15[12], r9_15[13], r9_15[14]); printk("s6 = %016lx\n", r9_15[15]); } printk("a0 = %016lx a1 = %016lx a2 = %016lx\n", regs->r16, regs->r17, regs->r18); printk("a3 = %016lx a4 = %016lx a5 = %016lx\n", regs->r19, regs->r20, regs->r21); printk("t8 = %016lx t9 = %016lx t10= %016lx\n", regs->r22, regs->r23, regs->r24); printk("t11= %016lx pv = %016lx at = %016lx\n", regs->r25, regs->r27, regs->r28); printk("gp = %016lx sp = %p\n", regs->gp, regs+1); #if 0 __halt(); #endif }
void show_regs(struct pt_regs * regs) { unsigned long flags; flags = condition_codes(regs); printk("pc : [<%08lx>] lr : [<%08lx>] %s\n" "sp : %08lx ip : %08lx fp : %08lx\n", instruction_pointer(regs), regs->ARM_lr, print_tainted(), regs->ARM_sp, regs->ARM_ip, regs->ARM_fp); printk("r10: %08lx r9 : %08lx r8 : %08lx\n", regs->ARM_r10, regs->ARM_r9, regs->ARM_r8); printk("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", regs->ARM_r7, regs->ARM_r6, regs->ARM_r5, regs->ARM_r4); printk("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", regs->ARM_r3, regs->ARM_r2, regs->ARM_r1, regs->ARM_r0); printk("Flags: %c%c%c%c", flags & PSR_N_BIT ? 'N' : 'n', flags & PSR_Z_BIT ? 'Z' : 'z', flags & PSR_C_BIT ? 'C' : 'c', flags & PSR_V_BIT ? 'V' : 'v'); printk(" IRQs o%s FIQs o%s Mode %s Segment %s\n", interrupts_enabled(regs) ? "n" : "ff", fast_interrupts_enabled(regs) ? "n" : "ff", processor_modes[processor_mode(regs)], get_fs() == get_ds() ? "kernel" : "user"); }
void show_regs_common(void) { const char *vendor, *product, *board; vendor = dmi_get_system_info(DMI_SYS_VENDOR); if (!vendor) vendor = ""; product = dmi_get_system_info(DMI_PRODUCT_NAME); if (!product) product = ""; /* Board Name is optional */ board = dmi_get_system_info(DMI_BOARD_NAME); printk(KERN_CONT "\n"); printk(KERN_DEFAULT "Pid: %d, comm: %.20s %s %s %.*s", task_pid_nr(current), current->comm, print_tainted(), init_utsname()->release, (int)strcspn(init_utsname()->version, " "), init_utsname()->version); printk(KERN_CONT " %s %s", vendor, product); if (board) printk(KERN_CONT "/%s", board); printk(KERN_CONT "\n"); }
void __show_registers(struct pt_regs *regs, int all) { unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L; unsigned long d0, d1, d2, d3, d6, d7; unsigned long sp; unsigned short ss, gs; if (user_mode_vm(regs)) { sp = regs->sp; ss = regs->ss & 0xffff; savesegment(gs, gs); } else { sp = (unsigned long) (®s->sp); savesegment(ss, ss); savesegment(gs, gs); } printk("\n"); printk("Pid: %d, comm: %s %s (%s %.*s)\n", task_pid_nr(current), current->comm, print_tainted(), init_utsname()->release, (int)strcspn(init_utsname()->version, " "), init_utsname()->version); printk("EIP: %04x:[<%08lx>] EFLAGS: %08lx CPU: %d\n", (u16)regs->cs, regs->ip, regs->flags, smp_processor_id()); print_symbol("EIP is at %s\n", regs->ip); printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n", regs->ax, regs->bx, regs->cx, regs->dx); printk("ESI: %08lx EDI: %08lx EBP: %08lx ESP: %08lx\n", regs->si, regs->di, regs->bp, sp); printk(" DS: %04x ES: %04x FS: %04x GS: %04x SS: %04x\n", (u16)regs->ds, (u16)regs->es, (u16)regs->fs, gs, ss); if (!all) return; cr0 = read_cr0(); cr2 = read_cr2(); cr3 = read_cr3(); cr4 = read_cr4_safe(); printk("CR0: %08lx CR2: %08lx CR3: %08lx CR4: %08lx\n", cr0, cr2, cr3, cr4); get_debugreg(d0, 0); get_debugreg(d1, 1); get_debugreg(d2, 2); get_debugreg(d3, 3); printk("DR0: %08lx DR1: %08lx DR2: %08lx DR3: %08lx\n", d0, d1, d2, d3); get_debugreg(d6, 6); get_debugreg(d7, 7); printk("DR6: %08lx DR7: %08lx\n", d6, d7); }
void show_regs(struct pt_regs *fp) { char buf[150]; struct irqaction *action; unsigned int i; unsigned long flags = 0; unsigned int cpu = raw_smp_processor_id(); unsigned char in_atomic = (bfin_read_IPEND() & 0x10) || in_atomic(); pr_notice("\n"); if (CPUID != bfin_cpuid()) pr_notice("Compiled for cpu family 0x%04x (Rev %d), " "but running on:0x%04x (Rev %d)\n", CPUID, bfin_compiled_revid(), bfin_cpuid(), bfin_revid()); pr_notice("ADSP-%s-0.%d", CPU, bfin_compiled_revid()); if (bfin_compiled_revid() != bfin_revid()) pr_cont("(Detected 0.%d)", bfin_revid()); pr_cont(" %lu(MHz CCLK) %lu(MHz SCLK) (%s)\n", get_cclk()/1000000, get_sclk()/1000000, #ifdef CONFIG_MPU "mpu on" #else "mpu off" #endif ); if(board_rom_type()) pr_notice("%s", linux_banner_stockui); else pr_notice("%s", linux_banner); pr_notice("\nSEQUENCER STATUS:\t\t%s\n", print_tainted()); pr_notice(" SEQSTAT: %08lx IPEND: %04lx IMASK: %04lx SYSCFG: %04lx\n", (long)fp->seqstat, fp->ipend, cpu_pda[raw_smp_processor_id()].ex_imask, fp->syscfg); if (fp->ipend & EVT_IRPTEN) pr_notice(" Global Interrupts Disabled (IPEND[4])\n"); if (!(cpu_pda[raw_smp_processor_id()].ex_imask & (EVT_IVG13 | EVT_IVG12 | EVT_IVG11 | EVT_IVG10 | EVT_IVG9 | EVT_IVG8 | EVT_IVG7 | EVT_IVTMR))) pr_notice(" Peripheral interrupts masked off\n"); if (!(cpu_pda[raw_smp_processor_id()].ex_imask & (EVT_IVG15 | EVT_IVG14))) pr_notice(" Kernel interrupts masked off\n"); if ((fp->seqstat & SEQSTAT_EXCAUSE) == VEC_HWERR) { pr_notice(" HWERRCAUSE: 0x%lx\n", (fp->seqstat & SEQSTAT_HWERRCAUSE) >> 14); #ifdef EBIU_ERRMST if (bfin_read_EBIU_ERRMST() & CORE_ERROR) { pr_notice(" EBIU Error Reason : 0x%04x\n", bfin_read_EBIU_ERRMST()); pr_notice(" EBIU Error Address : 0x%08x\n", bfin_read_EBIU_ERRADD()); } #endif }
static void rwlock_bug(rwlock_t *lock, const char *msg) { if (!debug_locks_off()) return; printk(KERN_EMERG "BUG: rwlock %s on CPU#%d, %s/%d, %p (%s)\n", msg, raw_smp_processor_id(), current->comm, current->pid, lock, print_tainted()); dump_stack(); }
/* * The architecture-independent dump_stack generator */ void dump_stack(void) { unsigned long stack; printk("Pid: %d, comm: %.20s %s %s %.*s\n", current->pid, current->comm, print_tainted(), init_utsname()->release, (int)strcspn(init_utsname()->version, " "), init_utsname()->version); show_trace(NULL, NULL, &stack); }
void show_regs(struct pt_regs *regs) { int i; char buf[128], *p; char *level; unsigned long cr30; unsigned long cr31; level = user_mode(regs) ? KERN_DEBUG : KERN_CRIT; printk("%s\n", level); /* don't want to have that pretty register dump messed up */ printk("%s YZrvWESTHLNXBCVMcbcbcbcbOGFRQPDI\n", level); printbinary(buf, regs->gr[0], 32); printk("%sPSW: %s %s\n", level, buf, print_tainted()); for (i = 0; i < 32; i += 4) { int j; p = buf; p += sprintf(p, "%sr%02d-%02d ", level, i, i + 3); for (j = 0; j < 4; j++) { p += sprintf(p, " " RFMT, (i+j) == 0 ? 0 : regs->gr[i + j]); } printk("%s\n", buf); } for (i = 0; i < 8; i += 4) { int j; p = buf; p += sprintf(p, "%ssr%d-%d ", level, i, i + 3); for (j = 0; j < 4; j++) { p += sprintf(p, " " RFMT, regs->sr[i + j]); } printk("%s\n", buf); } #if RIDICULOUSLY_VERBOSE for (i = 0; i < 32; i += 2) printk("%sFR%02d : %016lx FR%2d : %016lx", level, i, regs->fr[i], i+1, regs->fr[i+1]); #endif cr30 = mfctl(30); cr31 = mfctl(31); printk("%s\n", level); printk("%sIASQ: " RFMT " " RFMT " IAOQ: " RFMT " " RFMT "\n", level, regs->iasq[0], regs->iasq[1], regs->iaoq[0], regs->iaoq[1]); printk("%s IIR: %08lx ISR: " RFMT " IOR: " RFMT "\n", level, regs->iir, regs->isr, regs->ior); printk("%s CPU: %8d CR30: " RFMT " CR31: " RFMT "\n", level, ((struct task_struct *)cr30)->processor, cr30, cr31); printk("%s ORIG_R28: " RFMT "\n", level, regs->orig_r28); }
/* XXX could/should be common code */ static void print_xen_info(void) { char taint_str[TAINT_STRING_MAX_LEN]; char debug = 'n'; #ifndef NDEBUG debug = 'y'; #endif printk("----[ Xen-%d.%d%s x86_64 debug=%c %s ]----\n", xen_major_version(), xen_minor_version(), xen_extra_version(), debug, print_tainted(taint_str)); }
/* * The architecture-independent dump_stack generator */ void dump_stack(void) { unsigned long bp; unsigned long stack; bp = stack_frame(current, NULL); printk("Pid: %d, comm: %.20s mm: {%p} %s %s %.*s\n", current->pid, current->comm,current->mm, print_tainted(), init_utsname()->release, (int)strcspn(init_utsname()->version, " "), init_utsname()->version); show_trace(NULL, NULL, &stack, bp); }
/* XXX could/should be common code */ static void print_xen_info(void) { char taint_str[TAINT_STRING_MAX_LEN]; printk("----[ Xen-%d.%d%s %s debug=%c %s ]----\n", xen_major_version(), xen_minor_version(), xen_extra_version(), #ifdef CONFIG_ARM_32 "arm32", #else "arm64", #endif debug_build() ? 'y' : 'n', print_tainted(taint_str)); }
void debug_rt_mutex_print_deadlock(struct rt_mutex_waiter *waiter) { struct task_struct *task; if (!waiter->deadlock_lock || !debug_locks) return; rcu_read_lock(); task = pid_task(waiter->deadlock_task_pid, PIDTYPE_PID); if (!task) { rcu_read_unlock(); return; } if (!debug_locks_off()) { rcu_read_unlock(); return; } pr_warn("\n"); pr_warn("============================================\n"); pr_warn("WARNING: circular locking deadlock detected!\n"); pr_warn("%s\n", print_tainted()); pr_warn("--------------------------------------------\n"); printk("%s/%d is deadlocking current task %s/%d\n\n", task->comm, task_pid_nr(task), current->comm, task_pid_nr(current)); printk("\n1) %s/%d is trying to acquire this lock:\n", current->comm, task_pid_nr(current)); printk_lock(waiter->lock, 1); printk("\n2) %s/%d is blocked on this lock:\n", task->comm, task_pid_nr(task)); printk_lock(waiter->deadlock_lock, 1); debug_show_held_locks(current); debug_show_held_locks(task); printk("\n%s/%d's [blocked] stackdump:\n\n", task->comm, task_pid_nr(task)); show_stack(task, NULL); printk("\n%s/%d's [current] stackdump:\n\n", current->comm, task_pid_nr(current)); dump_stack(); debug_show_all_locks(); rcu_read_unlock(); printk("[ turning off deadlock detection." "Please report this trace. ]\n\n"); }
void dump_stack(void) { unsigned long bp = 0; unsigned long stack; #ifdef CONFIG_FRAME_POINTER if (!bp) get_bp(bp); #endif printk("Pid: %d, comm: %.20s %s %s %.*s\n", current->pid, current->comm, print_tainted(), init_utsname()->release, (int)strcspn(init_utsname()->version, " "), init_utsname()->version); show_trace(NULL, NULL, &stack, bp); }
static void rwlock_bug(rwlock_t *lock, const char *msg) { static long print_once = 1; if (xchg(&print_once, 0)) { printk(KERN_EMERG "BUG: rwlock %s on CPU#%d, %s/%d, %p (%s)\n", msg, raw_smp_processor_id(), current->comm, current->pid, lock, print_tainted()); dump_stack(); #ifdef CONFIG_SMP /* * We cannot continue on SMP: */ panic("bad locking"); #endif } }
void show_regs(struct pt_regs * regs) { printk("PSR: %08lx PC: %08lx NPC: %08lx Y: %08lx %s\n", regs->psr, regs->pc, regs->npc, regs->y, print_tainted()); printk("g0: %08lx g1: %08lx g2: %08lx g3: %08lx ", regs->u_regs[0], regs->u_regs[1], regs->u_regs[2], regs->u_regs[3]); printk("g4: %08lx g5: %08lx g6: %08lx g7: %08lx\n", regs->u_regs[4], regs->u_regs[5], regs->u_regs[6], regs->u_regs[7]); printk("o0: %08lx o1: %08lx o2: %08lx o3: %08lx ", regs->u_regs[8], regs->u_regs[9], regs->u_regs[10], regs->u_regs[11]); printk("o4: %08lx o5: %08lx sp: %08lx o7: %08lx\n", regs->u_regs[12], regs->u_regs[13], regs->u_regs[14], regs->u_regs[15]); show_regwindow((struct reg_window *)regs->u_regs[14]); }
void show_regs(struct pt_regs * regs) { printk("\n"); printk("Pid: %d, comm: %20s\n", current->pid, current->comm); printk("EIP: %04x:[<%08lx>] CPU: %d\n",0xffff & regs->xcs,regs->eip, smp_processor_id()); print_symbol("EIP is at %s\n", regs->eip); if (regs->xcs & 2) printk(" ESP: %04x:%08lx",0xffff & regs->xss,regs->esp); printk(" EFLAGS: %08lx %s (%s)\n",regs->eflags, print_tainted(),UTS_RELEASE); printk("EAX: %08lx EBX: %08lx ECX: %08lx EDX: %08lx\n", regs->eax,regs->ebx,regs->ecx,regs->edx); printk("ESI: %08lx EDI: %08lx EBP: %08lx", regs->esi, regs->edi, regs->ebp); printk(" DS: %04x ES: %04x\n", 0xffff & regs->xds,0xffff & regs->xes); show_trace(NULL, ®s->esp); }
static void spin_bug(spinlock_t *lock, const char *msg) { struct task_struct *owner = NULL; if (!debug_locks_off()) return; if (lock->owner && lock->owner != SPINLOCK_OWNER_INIT) owner = lock->owner; printk(KERN_EMERG "BUG: spinlock %s on CPU#%d, %s/%d (%s)\n", msg, raw_smp_processor_id(), current->comm, current->pid, print_tainted()); printk(KERN_EMERG " lock: %p, .magic: %08x, .owner: %s/%d, " ".owner_cpu: %d\n", lock, lock->magic, owner ? owner->comm : "<none>", owner ? owner->pid : -1, lock->owner_cpu); dump_stack(); }
void show_regs(struct pt_regs *regs) { unsigned long sp = regs->sp; unsigned long lr = regs->lr; unsigned long mode = (regs->sr & MODE_MASK) >> MODE_SHIFT; if (!user_mode(regs)) sp = (unsigned long)regs + FRAME_SIZE_FULL; print_symbol("PC is at %s\n", instruction_pointer(regs)); print_symbol("LR is at %s\n", lr); printk("pc : [<%08lx>] lr : [<%08lx>] %s\n" "sp : %08lx r12: %08lx r11: %08lx\n", instruction_pointer(regs), lr, print_tainted(), sp, regs->r12, regs->r11); printk("r10: %08lx r9 : %08lx r8 : %08lx\n", regs->r10, regs->r9, regs->r8); printk("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", regs->r7, regs->r6, regs->r5, regs->r4); printk("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", regs->r3, regs->r2, regs->r1, regs->r0); printk("Flags: %c%c%c%c%c\n", regs->sr & SR_Q ? 'Q' : 'q', regs->sr & SR_V ? 'V' : 'v', regs->sr & SR_N ? 'N' : 'n', regs->sr & SR_Z ? 'Z' : 'z', regs->sr & SR_C ? 'C' : 'c'); printk("Mode bits: %c%c%c%c%c%c%c%c%c\n", regs->sr & SR_H ? 'H' : 'h', regs->sr & SR_R ? 'R' : 'r', regs->sr & SR_J ? 'J' : 'j', regs->sr & SR_EM ? 'E' : 'e', regs->sr & SR_I3M ? '3' : '.', regs->sr & SR_I2M ? '2' : '.', regs->sr & SR_I1M ? '1' : '.', regs->sr & SR_I0M ? '0' : '.', regs->sr & SR_GM ? 'G' : 'g'); printk("CPU Mode: %s\n", cpu_modes[mode]); show_trace(NULL, (unsigned long *)sp, regs); }
void __show_regs(struct pt_regs *regs) { printk("\n"); print_modules(); printk(KERN_INFO "Pid: %d, comm: %.20s %s %s\n", task_pid_nr(current), current->comm, print_tainted(), init_utsname()->release); printk(KERN_INFO "RIP: %04lx:[<%016lx>]\n", PT_REGS_CS(regs) & 0xffff, PT_REGS_IP(regs)); printk(KERN_INFO "RSP: %016lx EFLAGS: %08lx\n", PT_REGS_SP(regs), PT_REGS_EFLAGS(regs)); printk(KERN_INFO "RAX: %016lx RBX: %016lx RCX: %016lx\n", PT_REGS_AX(regs), PT_REGS_BX(regs), PT_REGS_CX(regs)); printk(KERN_INFO "RDX: %016lx RSI: %016lx RDI: %016lx\n", PT_REGS_DX(regs), PT_REGS_SI(regs), PT_REGS_DI(regs)); printk(KERN_INFO "RBP: %016lx R08: %016lx R09: %016lx\n", PT_REGS_BP(regs), PT_REGS_R8(regs), PT_REGS_R9(regs)); printk(KERN_INFO "R10: %016lx R11: %016lx R12: %016lx\n", PT_REGS_R10(regs), PT_REGS_R11(regs), PT_REGS_R12(regs)); printk(KERN_INFO "R13: %016lx R14: %016lx R15: %016lx\n", PT_REGS_R13(regs), PT_REGS_R14(regs), PT_REGS_R15(regs)); }
static void __spin_lock_debug(spinlock_t *lock) { int print_once = 1; u64 i; for (;;) { for (i = 0; i < loops_per_jiffy * HZ; i++) { if (__raw_spin_trylock(&lock->raw_lock)) return; } /* lockup suspected: */ if (print_once) { print_once = 0; printk(KERN_EMERG "BUG: spinlock lockup on CPU#%d, " "%s/%d, %p (%s)\n", raw_smp_processor_id(), current->comm, current->pid, lock, print_tainted()); dump_stack(); } } }
void show_regs(struct pt_regs *regs) { printk("r0 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", regs->regs[0], regs->regs[1], regs->regs[2], regs->regs[3], regs->regs[4], regs->regs[5], regs->regs[6], regs->regs[7]); printk("r8 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", regs->regs[8], regs->regs[9], regs->regs[10], regs->regs[11], regs->regs[12], regs->regs[13], regs->regs[14], regs->regs[15]); printk("r16: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", regs->regs[16], regs->regs[17], regs->regs[18], regs->regs[19], regs->regs[20], regs->regs[21], regs->regs[22], regs->regs[23]); printk("r24: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n", regs->regs[24], regs->regs[25], regs->regs[26], regs->regs[27], regs->regs[28], regs->regs[29], regs->regs[30], regs->regs[31]); printk("CEH : %08lx\n", regs->ceh); printk("CEL : %08lx\n", regs->cel); printk("EMA:%08lx, epc:%08lx %s\nPSR: %08lx\nECR:%08lx\nCondition : %08lx\n", regs->cp0_ema, regs->cp0_epc, print_tainted(), regs->cp0_psr, regs->cp0_ecr, regs->cp0_condition); }
void my_dump_stack(void) { unsigned int stack; unsigned int top; unsigned int addr; printk("Pid: %d, comm: %.20s %s %s %.*s\n", current->pid, current->comm, print_tainted(), init_utsname()->release, (int)strcspn(init_utsname()->version, " "), init_utsname()->version); printk("Call Trace:\n"); /* get stack point */ stack = (unsigned int)&stack; /* get stack top point */ top = (unsigned int)current_thread_info() + THREAD_SIZE; for (; stack < top; stack += 4) { addr = *(unsigned int *)stack; if (kernel_text_addressp(addr)) printk(" [<%p>] %pS\n", (void *)addr, (void *)addr); } }
void show_regs(struct pt_regs *fp) { char buf [150]; struct irqaction *action; unsigned int i; unsigned long flags; printk(KERN_NOTICE "\n" KERN_NOTICE "SEQUENCER STATUS:\t\t%s\n", print_tainted()); printk(KERN_NOTICE " SEQSTAT: %08lx IPEND: %04lx SYSCFG: %04lx\n", (long)fp->seqstat, fp->ipend, fp->syscfg); printk(KERN_NOTICE " HWERRCAUSE: 0x%lx\n", (fp->seqstat & SEQSTAT_HWERRCAUSE) >> 14); printk(KERN_NOTICE " EXCAUSE : 0x%lx\n", fp->seqstat & SEQSTAT_EXCAUSE); for (i = 6; i <= 15 ; i++) { if (fp->ipend & (1 << i)) { decode_address(buf, bfin_read32(EVT0 + 4*i)); printk(KERN_NOTICE " physical IVG%i asserted : %s\n", i, buf); } } /* if no interrupts are going off, don't print this out */ if (fp->ipend & ~0x3F) { for (i = 0; i < (NR_IRQS - 1); i++) { spin_lock_irqsave(&irq_desc[i].lock, flags); action = irq_desc[i].action; if (!action) goto unlock; decode_address(buf, (unsigned int)action->handler); printk(KERN_NOTICE " logical irq %3d mapped : %s", i, buf); for (action = action->next; action; action = action->next) { decode_address(buf, (unsigned int)action->handler); printk(", %s", buf); } printk("\n"); unlock: spin_unlock_irqrestore(&irq_desc[i].lock, flags); } } decode_address(buf, fp->rete); printk(KERN_NOTICE " RETE: %s\n", buf); decode_address(buf, fp->retn); printk(KERN_NOTICE " RETN: %s\n", buf); decode_address(buf, fp->retx); printk(KERN_NOTICE " RETX: %s\n", buf); decode_address(buf, fp->rets); printk(KERN_NOTICE " RETS: %s\n", buf); decode_address(buf, fp->pc); printk(KERN_NOTICE " PC : %s\n", buf); if (((long)fp->seqstat & SEQSTAT_EXCAUSE) && (((long)fp->seqstat & SEQSTAT_EXCAUSE) != VEC_HWERR)) { decode_address(buf, saved_dcplb_fault_addr); printk(KERN_NOTICE "DCPLB_FAULT_ADDR: %s\n", buf); decode_address(buf, saved_icplb_fault_addr); printk(KERN_NOTICE "ICPLB_FAULT_ADDR: %s\n", buf); } printk(KERN_NOTICE "\n" KERN_NOTICE "PROCESSOR STATE:\n"); printk(KERN_NOTICE " R0 : %08lx R1 : %08lx R2 : %08lx R3 : %08lx\n", fp->r0, fp->r1, fp->r2, fp->r3); printk(KERN_NOTICE " R4 : %08lx R5 : %08lx R6 : %08lx R7 : %08lx\n", fp->r4, fp->r5, fp->r6, fp->r7); printk(KERN_NOTICE " P0 : %08lx P1 : %08lx P2 : %08lx P3 : %08lx\n", fp->p0, fp->p1, fp->p2, fp->p3); printk(KERN_NOTICE " P4 : %08lx P5 : %08lx FP : %08lx SP : %08lx\n", fp->p4, fp->p5, fp->fp, (long)fp); printk(KERN_NOTICE " LB0: %08lx LT0: %08lx LC0: %08lx\n", fp->lb0, fp->lt0, fp->lc0); printk(KERN_NOTICE " LB1: %08lx LT1: %08lx LC1: %08lx\n", fp->lb1, fp->lt1, fp->lc1); printk(KERN_NOTICE " B0 : %08lx L0 : %08lx M0 : %08lx I0 : %08lx\n", fp->b0, fp->l0, fp->m0, fp->i0); printk(KERN_NOTICE " B1 : %08lx L1 : %08lx M1 : %08lx I1 : %08lx\n", fp->b1, fp->l1, fp->m1, fp->i1); printk(KERN_NOTICE " B2 : %08lx L2 : %08lx M2 : %08lx I2 : %08lx\n", fp->b2, fp->l2, fp->m2, fp->i2); printk(KERN_NOTICE " B3 : %08lx L3 : %08lx M3 : %08lx I3 : %08lx\n", fp->b3, fp->l3, fp->m3, fp->i3); printk(KERN_NOTICE "A0.w: %08lx A0.x: %08lx A1.w: %08lx A1.x: %08lx\n", fp->a0w, fp->a0x, fp->a1w, fp->a1x); printk(KERN_NOTICE "USP : %08lx ASTAT: %08lx\n", rdusp(), fp->astat); printk(KERN_NOTICE "\n"); }
void dg_currProcShowRegs(S_DG_REG *regs) { unsigned int cause = regs->cp0_cause; int i; printf("Cpu %lu\n", regs->cpu); /* * Saved main processor registers */ for (i = 0; i < 32; ) { if ((i % 4) == 0) printf("$%2d :", i); if (i == 0) printf(" %08lx", 0UL); else if (i == 26 || i == 27) printf(" %s", ""); else printf(" %08lx", regs->regs[i]); i++; if ((i % 4) == 0) printf("\n"); } printf("Hi : %08lx\n", regs->hi); printf("Lo : %08lx\n", regs->lo); /* * Saved cp0 registers */ printf("epc : %08lx ", regs->cp0_epc); printf(" %s\n", print_tainted(regs->tainted)); printf("ra : %08lx ", regs->regs[31]); printf("Status: %08lx ", regs->cp0_status); if (regs->cp0_status & ST0_KX) printf("KX "); if (regs->cp0_status & ST0_SX) printf("SX "); if (regs->cp0_status & ST0_UX) printf("UX "); switch (regs->cp0_status & ST0_KSU) { case KSU_USER: printf("USER "); break; case KSU_SUPERVISOR: printf("SUPERVISOR "); break; case KSU_KERNEL: printf("KERNEL "); break; default: printf("BAD_MODE "); break; } if (regs->cp0_status & ST0_ERL) printf("ERL "); if (regs->cp0_status & ST0_EXL) printf("EXL "); if (regs->cp0_status & ST0_IE) printf("IE "); printf("\n"); printf("Cause : %08x\n", cause); cause = (cause & CAUSEF_EXCCODE) >> CAUSEB_EXCCODE; if (1 <= cause && cause <= 5) printf("BadVA : %08lx\n", regs->cp0_badvaddr); printf("PrId : %08lx\n", regs->prid); }