static int ipanic_current_task_info(void *data, unsigned char *buffer, size_t sz_buf) { struct stack_trace trace; int i, plen; struct task_struct *tsk; struct aee_process_info *cur_proc; struct pt_regs *regs = (struct pt_regs *)data; if (!virt_addr_valid(current_thread_info())) return -1; tsk = current_thread_info()->task; if (!virt_addr_valid(tsk)) return -1; cur_proc = (struct aee_process_info *)ipanic_task_info; memset(cur_proc, 0, sizeof(struct aee_process_info)); /* Grab kernel task stack trace */ trace.nr_entries = 0; trace.max_entries = MAX_STACK_TRACE_DEPTH; trace.entries = ipanic_stack_entries; trace.skip = 8; save_stack_trace_tsk(tsk, &trace); /* Skip the entries - ipanic_save_current_tsk_info/save_stack_trace_tsk */ for (i = 0; i < trace.nr_entries; i++) { int off = strlen(cur_proc->backtrace); int plen = AEE_BACKTRACE_LENGTH - off; if (plen > 16) { snprintf(cur_proc->backtrace + off, plen, "[<%p>] %pS\n", (void *)ipanic_stack_entries[i], (void *)ipanic_stack_entries[i]); } } if (regs) { cur_proc->ke_frame.pc = (__u64) regs->reg_pc; cur_proc->ke_frame.lr = (__u64) regs->reg_lr; } else { /* in case panic() is called without die */ /* Todo: a UT for this */ cur_proc->ke_frame.pc = ipanic_stack_entries[0]; cur_proc->ke_frame.lr = ipanic_stack_entries[1]; } snprintf(cur_proc->ke_frame.pc_symbol, AEE_SZ_SYMBOL_S, "[<%p>] %pS", (void *)(unsigned long) cur_proc->ke_frame.pc, (void *)(unsigned long) cur_proc->ke_frame.pc); snprintf(cur_proc->ke_frame.lr_symbol, AEE_SZ_SYMBOL_L, "[<%p>] %pS", (void *)(unsigned long) cur_proc->ke_frame.lr, (void *)(unsigned long) cur_proc->ke_frame.lr); /* Current panic user tasks */ plen = 0; while (tsk && (tsk->pid != 0) && (tsk->pid != 1)) { /* FIXME: Check overflow ? */ plen += snprintf(cur_proc->process_path + plen, AEE_PROCESS_NAME_LENGTH, "[%s, %d]", tsk->comm, tsk->pid); tsk = tsk->real_parent; } mrdump_mini_add_misc((unsigned long)cur_proc, sizeof(struct aee_process_info), 0, "PROC_CUR_TSK"); memcpy(buffer, cur_proc, sizeof(struct aee_process_info)); return sizeof(struct aee_process_info); }
static inline void store_stacktrace(struct task_struct *tsk, struct latency_record *lat) { struct stack_trace trace; memset(&trace, 0, sizeof(trace)); trace.max_entries = LT_BACKTRACEDEPTH; trace.entries = &lat->backtrace[0]; save_stack_trace_tsk(tsk, &trace); }
void save_stack_trace_tsk(struct task_struct *task, struct stack_trace *trace) { struct stack_trace_data trace_data = { .trace = trace, .skip = trace->skip, }; walk_stackframe(stack_pointer(task), stack_trace_cb, &trace_data); } EXPORT_SYMBOL_GPL(save_stack_trace_tsk); void save_stack_trace(struct stack_trace *trace) { save_stack_trace_tsk(current, trace); }
// IRQ off monitor void MT_trace_irq_off(void) { struct sched_stop_event *e; struct stack_trace *trace; e = & __raw_get_cpu_var(IRQ_disable_mon); e->cur_ts = sched_clock(); /*save timestap*/ __raw_get_cpu_var(TS_irq_off) = sched_clock(); trace = &__raw_get_cpu_var(MT_stack_trace); /*save backtraces*/ trace->nr_entries = 0; trace->max_entries = MAX_STACK_TRACE_DEPTH; //32 trace->skip = 0; save_stack_trace_tsk(current, trace); }
void aee_get_traces(char *msg) { struct stack_trace trace; int i; int offset; if (trace_entry_ptr == NULL) return; memset(trace_entry_ptr, 0, MAX_STACK_TRACE_DEPTH * 4); trace.entries = trace_entry_ptr; /*save backtraces */ trace.nr_entries = 0; trace.max_entries = 32; trace.skip = 0; save_stack_trace_tsk(current, &trace); for (i = 0; i < trace.nr_entries; i++) { offset = strlen(msg); snprintf(msg + offset, KERNEL_REPORT_LENGTH - offset, "[<%p>] %pS\n", (void *)trace.entries[i], (void *)trace.entries[i]); } }
/** * stack_trace_save - Save a stack trace into a storage array * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */ unsigned int stack_trace_save(unsigned long *store, unsigned int size, unsigned int skipnr) { struct stack_trace trace = { .entries = store, .max_entries = size, .skip = skipnr + 1, }; save_stack_trace(&trace); return trace.nr_entries; } EXPORT_SYMBOL_GPL(stack_trace_save); /** * stack_trace_save_tsk - Save a task stack trace into a storage array * @task: The task to examine * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */ unsigned int stack_trace_save_tsk(struct task_struct *task, unsigned long *store, unsigned int size, unsigned int skipnr) { struct stack_trace trace = { .entries = store, .max_entries = size, .skip = skipnr + 1, }; save_stack_trace_tsk(task, &trace); return trace.nr_entries; } /** * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array * @regs: Pointer to pt_regs to examine * @store: Pointer to storage array * @size: Size of the storage array * @skipnr: Number of entries to skip at the start of the stack trace * * Return: Number of trace entries stored */ unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store, unsigned int size, unsigned int skipnr) { struct stack_trace trace = { .entries = store, .max_entries = size, .skip = skipnr, }; save_stack_trace_regs(regs, &trace); return trace.nr_entries; } #ifdef CONFIG_HAVE_RELIABLE_STACKTRACE /** * stack_trace_save_tsk_reliable - Save task stack with verification * @tsk: Pointer to the task to examine * @store: Pointer to storage array * @size: Size of the storage array * * Return: An error if it detects any unreliable features of the * stack. Otherwise it guarantees that the stack trace is * reliable and returns the number of entries stored. * * If the task is not 'current', the caller *must* ensure the task is inactive. */ int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store, unsigned int size) { struct stack_trace trace = { .entries = store, .max_entries = size, }; int ret = save_stack_trace_tsk_reliable(tsk, &trace); return ret ? ret : trace.nr_entries; } #endif #ifdef CONFIG_USER_STACKTRACE_SUPPORT /** * stack_trace_save_user - Save a user space stack trace into a storage array * @store: Pointer to storage array * @size: Size of the storage array * * Return: Number of trace entries stored */ unsigned int stack_trace_save_user(unsigned long *store, unsigned int size) { struct stack_trace trace = { .entries = store, .max_entries = size, }; save_stack_trace_user(&trace); return trace.nr_entries; }
void save_stack_trace(struct stack_trace *trace) { save_stack_trace_tsk(current, trace); }
void save_stack_trace(struct stack_trace *trace) { save_stack_trace_tsk(NULL, trace); }