内核为每个线程分配8K的栈空间, 在每个堆栈的顶部放着struct thread_info 结构体，用来保存线程相关信息.
其中有几个重要变量：
Preempt_count :
此变量分为四部分
0-7bit ：当前进程是否能抢占的标志
8-15bit:softirq 使能标志
16-23bit :hardirq 使能标志
24bit:PREEMPT_ACTIVE标志位(原子上下文标志位？？)
Task: 进程相关的结构,包含更加丰富的信息
Cpu_context :cpu 寄存器值，这个应该是当前进程被切换时，保留下来的线程执行场景.
struct thread_info {
unsignedlong flags; /* low level flags */
int preempt_count; /* 0 => preemptable, <0 => bug */
mm_segment_t addr_limit; /* address limit */
structtask_struct *task; /* main task structure */
__u32 cpu; /*cpu */
structcpu_context_save cpu_context; /* cpu context */
……………………….
}
只需要获得当前sp指针,然后进行8k字节对齐即可找到thread_info结构
register unsignedlong sp asm ("sp");
return (structthread_info *)(sp & ~(THREAD_SIZE - 1));
static inline struct thread_info*current_thread_info(void)
以及current宏用于获取当前进程结构体.
static inline unsigned longarch_local_cpsr_save(void)
{
unsignedlong flags ;
asmvolatile( " mrs %0, cpsr @ arch_local_irq_save\n"
:: "r" (flags): "memory", "cc");
returnflags;
}
每一个进程都有自己的栈。考虑进程执行时发生函数调用的场景，母函数和子函数使用的是同一个栈，在通常的情况下，并不需要区分母函数和子函数分别使用了栈的哪个部分。但是，当需要在执行过程中对函数调用进行backtrace的时候，这一信息就很重要了。
简单的说，stack frame就是一个函数所使用的stack的一部分，所有函数的stack frame串起来就组成了一个完整的栈。stack frame的两个边界分别由FP和SP来限定。
在程序执行过程中（通常是发生了某种意外情况而需要进行调试），通过SP和FP所限定的 stackframe，就可以得到母函数的SP和FP，从而得到母函数的stack frame（PC，LR，SP，FP会在函数调用的第一时间压栈），以此追溯，即可得到所有函数的调用顺序。
要内核支持FP指针必须打开CONFIG_FRAME_POINTER配置
voidsave_stack_trace(struct stack_trace *trace)
{
save_stack_trace_tsk(current, trace);
}
接着分析：
voidsave_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
{
struct stack_trace_data data;
struct stackframe frame;
data.trace = trace;
data.skip = trace->skip;//设置需要忽视的调用级数,一般设置为0
if (tsk != current) {
#ifdefCONFIG_SMP
/*
* What guarantees do we have here that ‘tsk‘is not
* running on another CPU? For now, ignore it as we
* can‘t guarantee we won‘t explode.
*/
//如果不是保存当前cpu上的当前进程,那么是很难确定tsk进程寄存器的值的，
也许时刻都在变化.
if (trace->nr_entries <trace->max_entries)
trace->entries[trace->nr_entries++]= ULONG_MAX;
return;
#else //在单cpu时，tsk进程已经被切换，可以追溯backtrace
data.no_sched_functions = 1;
frame.fp = thread_saved_fp(tsk);
frame.sp = thread_saved_sp(tsk);
frame.lr = 0; /* recovered from the stack */
frame.pc = thread_saved_pc(tsk);
#endif
} else {
register unsigned long current_sp asm("sp");//通过sp获取当前堆栈指针
//__builtin_frame_address(0)返回当前函数的FP指针
//__builtin_return_address(0)返回当前函数的返回地址(LR)
data.no_sched_functions = 0;
frame.fp = (unsignedlong)__builtin_frame_address(0);
frame.sp = current_sp;
frame.lr = (unsignedlong)__builtin_return_address(0);
frame.pc = (unsignedlong)save_stack_trace_tsk;//通过函数名获取到当前pc
}
walk_stackframe(&frame, save_trace,&data);//进行堆栈遍历
if (trace->nr_entries <trace->max_entries)
trace->entries[trace->nr_entries++]= ULONG_MAX;
}
其中save_trace主要保存当前pc到数组中.
staticint save_trace(struct stackframe *frame, void *d)
{
struct stack_trace_data *data = d;
struct stack_trace *trace = data->trace;
unsigned long addr = frame->pc;
if (data->no_sched_functions &&in_sched_functions(addr))
return 0;
if (data->skip) {//如果有设置skip,则会跳过当前调用
data->skip--;
return 0;
}
trace->entries[trace->nr_entries++] =addr;//保存当前pc
return trace->nr_entries >=trace->max_entries;
}
接着分析walk_stackframe函数
void notrace walk_stackframe(struct stackframe *frame,
int (*fn)(struct stackframe *, void *), void *data)
{
while (1) {
int ret;
if (fn(frame, data))//调用save_trace保存当前pc
break;
ret = unwind_frame(frame);//把FP指针移到上一个函数
if (ret < 0)
break;
}
}
intnotrace unwind_frame(struct stackframe *frame)
{
unsigned long high, low;
unsigned long fp = frame->fp;
/* only go to a higher address on the stack */
low = frame->sp;//当前堆栈末端
high = ALIGN(low, THREAD_SIZE);//当前堆栈顶端
/* check current frame pointer is within bounds*/
if (fp < low + 12 || fp > high - 4)
return -EINVAL;
/* restore the registers from the stack frame*/
由上面的堆栈图可知,这几个指针在堆栈上的存放顺序为
Pc,lr,sp,fp
frame->fp = *(unsigned long *)(fp - 12);
frame->sp = *(unsigned long *)(fp - 8);
frame->pc = *(unsigned long *)(fp - 4);
return 0;
}
voidaee_get_traces(char *msg)
{
structstack_trace trace;
inti;
intoffset;
if(trace_entry_ptr == NULL)
return;
memset(trace_entry_ptr,0, MAX_STACK_TRACE_DEPTH * 4);
trace.entries= trace_entry_ptr;
/*savebacktraces */
trace.nr_entries= 0;
trace.max_entries= 32;//32级调用
trace.skip= 0;
save_stack_trace_tsk(current,&trace);
for(i = 0; i < trace.nr_entries; i++) {//current
offset= strlen(msg);
//根据pc,通过%pf ， %pf就可以打印出函数名
snprintf(msg+ offset, KERNEL_REPORT_LENGTH - offset, "[<%p>]%pS\n",
(void *)trace.entries[i], (void*)trace.entries[i]);
}
}
原文地址：http://blog.csdn.net/bin_linux96/article/details/41908097
