static void show_trace(long *sp) { int i; long addr; sp = sp ? sp : (long *) &sp; printk(KERN_NOTICE "Call Trace: "); i = 1; while ((long) sp & (PAGE_SIZE - 1)) { if (__get_user(addr, sp++)) { if (i && ((i % 6) == 0)) printk(KERN_NOTICE "\n"); printk(KERN_NOTICE " (Bad stack address)\n"); break; } if (kernel_text_address(addr)) { if (i && ((i % 6) == 0)) printk(KERN_NOTICE "\n"); if (i > 40) { printk(KERN_NOTICE " ..."); break; } printk(KERN_NOTICE " [<%08lx>]", addr); i++; } } printk(KERN_NOTICE "\n"); }
void show_trace(struct task_struct *task, unsigned long *stack) { unsigned long addr; if (!stack) stack = (unsigned long *)&stack; printk(KERN_NOTICE "Call Trace: "); #ifdef CONFIG_KALLSYMS printk(KERN_NOTICE "\n"); #endif while (!kstack_end(stack)) { addr = *stack++; /* * If the address is either in the text segment of the * kernel, or in the region which contains vmalloc'ed * memory, it *may* be the address of a calling * routine; if so, print it so that someone tracing * down the cause of the crash will be able to figure * out the call path that was taken. */ if (kernel_text_address(addr)) print_ip_sym(addr); } printk(KERN_NOTICE "\n"); if (!task) task = current; debug_show_held_locks(task); }
static void show_trace(struct task_struct *tsk, unsigned long *sp) { unsigned long addr; printk("\nCall Trace:"); #ifdef CONFIG_KALLSYMS printk("\n"); #endif while (!kstack_end(sp)) { addr = *sp++; /* * If the address is either in the text segment of the * kernel, or in the region which contains vmalloc'ed * memory, it *may* be the address of a calling * routine; if so, print it so that someone tracing * down the cause of the crash will be able to figure * out the call path that was taken. */ if (kernel_text_address(addr)) print_ip_sym(addr); } printk("\n"); }
static void perf_callchain_kernel(struct pt_regs *regs, struct perf_callchain_entry *entry) { unsigned long sp, next_sp; unsigned long next_ip; unsigned long lr; long level = 0; unsigned long *fp; lr = regs->link; sp = regs->gpr[1]; callchain_store(entry, PERF_CONTEXT_KERNEL); callchain_store(entry, regs->nip); if (!validate_sp(sp, current, STACK_FRAME_OVERHEAD)) return; for (;;) { fp = (unsigned long *) sp; next_sp = fp[0]; if (next_sp == sp + STACK_INT_FRAME_SIZE && fp[STACK_FRAME_MARKER] == STACK_FRAME_REGS_MARKER) { /* * This looks like an interrupt frame for an * interrupt that occurred in the kernel */ regs = (struct pt_regs *)(sp + STACK_FRAME_OVERHEAD); next_ip = regs->nip; lr = regs->link; level = 0; callchain_store(entry, PERF_CONTEXT_KERNEL); } else { if (level == 0) next_ip = lr; else next_ip = fp[STACK_FRAME_LR_SAVE]; /* * We can't tell which of the first two addresses * we get are valid, but we can filter out the * obviously bogus ones here. We replace them * with 0 rather than removing them entirely so * that userspace can tell which is which. */ if ((level == 1 && next_ip == lr) || (level <= 1 && !kernel_text_address(next_ip))) next_ip = 0; ++level; } callchain_store(entry, next_ip); if (!valid_next_sp(next_sp, sp)) return; sp = next_sp; } }
static void __jump_label_update(struct static_key *key, struct jump_entry *entry, struct jump_entry *stop, int enable) { for (; (entry < stop) && (entry->key == (jump_label_t)(unsigned long)key); entry++) { if (entry->code && kernel_text_address(entry->code)) arch_jump_label_transform(entry, enable); } }
static void __jump_label_update(struct jump_label_key *key, struct jump_entry *entry, int enable) { for (; entry->key == (jump_label_t)(unsigned long)key; entry++) { /* * entry->code set to 0 invalidates module init text sections * kernel_text_address() verifies we are not in core kernel * init code, see jump_label_invalidate_module_init(). */ if (entry->code && kernel_text_address(entry->code)) arch_jump_label_transform(entry, enable); } }
static int return_address_cb(struct stackframe *frame, void *data) { struct return_addr_data *r = data; if (r->skip) { --r->skip; return 0; } if (!kernel_text_address(frame->pc)) return 0; r->addr = frame->pc; return 1; }
static void __jump_label_update(struct static_key *key, struct jump_entry *entry, struct jump_entry *stop) { for (; (entry < stop) && (jump_entry_key(entry) == key); entry++) { /* * entry->code set to 0 invalidates module init text sections * kernel_text_address() verifies we are not in core kernel * init code, see jump_label_invalidate_module_init(). */ if (entry->code && kernel_text_address(entry->code)) arch_jump_label_transform(entry, jump_label_type(entry)); } }
static int stack_trace_cb(struct stackframe *frame, void *data) { struct stack_trace_data *trace_data = data; struct stack_trace *trace = trace_data->trace; if (trace_data->skip) { --trace_data->skip; return 0; } if (!kernel_text_address(frame->pc)) return 0; trace->entries[trace->nr_entries++] = frame->pc; return trace->nr_entries >= trace->max_entries; }
/* * Check if the target PC is within an alternative block. */ static bool branch_insn_requires_update(struct alt_instr *alt, unsigned long pc) { unsigned long replptr; if (kernel_text_address(pc)) return 1; replptr = (unsigned long)ALT_REPL_PTR(alt); if (pc >= replptr && pc <= (replptr + alt->alt_len)) return 0; /* * Branching into *another* alternate sequence is doomed, and * we're not even trying to fix it up. */ BUG(); }
void show_trace(unsigned long * stack) { unsigned long *startstack; unsigned long addr; int i; startstack = (unsigned long *)((unsigned long)stack & ~(THREAD_SIZE - 1)); i = 1; printk("Kernel addresses on the stack:\n"); while (stack >= startstack) { addr = *stack--; if (kernel_text_address(addr)) { printk(" [<" RFMT ">] ", addr); if ((i & 0x03) == 0) printk("\n"); i++; } } printk("\n"); }
void show_trace(unsigned long * stack) { int i; unsigned long addr; if (!stack) stack = (unsigned long*) &stack; printk("Call Trace: "); i = 1; while (((long) stack & (THREAD_SIZE-1)) != 0) { addr = *stack++; if (kernel_text_address(addr)) { if (i && ((i % 6) == 0)) printk("\n "); printk("[<%08lx>] ", addr); i++; } } printk("\n"); }
void nommu_dump_state(struct pt_regs *regs, unsigned long ea, unsigned long vector) { int i; unsigned long addr, stack = regs->sp; printk("\n\r[nommu_dump_state] :: ea %lx, vector %lx\n\r", ea, vector); printk("CPU #: %d\n" " PC: %08lx SR: %08lx SP: %08lx\n", 0, regs->pc, regs->sr, regs->sp); printk("GPR00: %08lx GPR01: %08lx GPR02: %08lx GPR03: %08lx\n", 0L, regs->gpr[1], regs->gpr[2], regs->gpr[3]); printk("GPR04: %08lx GPR05: %08lx GPR06: %08lx GPR07: %08lx\n", regs->gpr[4], regs->gpr[5], regs->gpr[6], regs->gpr[7]); printk("GPR08: %08lx GPR09: %08lx GPR10: %08lx GPR11: %08lx\n", regs->gpr[8], regs->gpr[9], regs->gpr[10], regs->gpr[11]); printk("GPR12: %08lx GPR13: %08lx GPR14: %08lx GPR15: %08lx\n", regs->gpr[12], regs->gpr[13], regs->gpr[14], regs->gpr[15]); printk("GPR16: %08lx GPR17: %08lx GPR18: %08lx GPR19: %08lx\n", regs->gpr[16], regs->gpr[17], regs->gpr[18], regs->gpr[19]); printk("GPR20: %08lx GPR21: %08lx GPR22: %08lx GPR23: %08lx\n", regs->gpr[20], regs->gpr[21], regs->gpr[22], regs->gpr[23]); printk("GPR24: %08lx GPR25: %08lx GPR26: %08lx GPR27: %08lx\n", regs->gpr[24], regs->gpr[25], regs->gpr[26], regs->gpr[27]); printk("GPR28: %08lx GPR29: %08lx GPR30: %08lx GPR31: %08lx\n", regs->gpr[28], regs->gpr[29], regs->gpr[30], regs->gpr[31]); printk(" RES: %08lx oGPR11: %08lx\n", regs->gpr[11], regs->orig_gpr11); printk("Process %s (pid: %d, stackpage=%08lx)\n", ((struct task_struct *)(__pa(current)))->comm, ((struct task_struct *)(__pa(current)))->pid, (unsigned long)current); printk("\nStack: "); printk("Stack dump [0x%08lx]:\n", (unsigned long)stack); for (i = 0; i < kstack_depth_to_print; i++) { if (((long)stack & (THREAD_SIZE - 1)) == 0) break; stack++; printk("%lx :: sp + %02d: 0x%08lx\n", stack, i * 4, *((unsigned long *)(__pa(stack)))); } printk("\n"); printk("Call Trace: "); i = 1; while (((long)stack & (THREAD_SIZE - 1)) != 0) { addr = *((unsigned long *)__pa(stack)); stack++; if (kernel_text_address(addr)) { if (i && ((i % 6) == 0)) printk("\n "); printk(" [<%08lx>]", addr); i++; } } printk("\n"); printk("\nCode: "); for (i = -24; i < 24; i++) { unsigned char c; c = ((unsigned char *)(__pa(regs->pc)))[i]; if (i == 0) printk("(%02x) ", c); else printk("%02x ", c); } printk("\n"); }