linux 内核打印调用栈,Linux内核堆栈调用实现分析

1 内核线程

内核为每个线程分配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宏用于获取当前进程结构体.

c 语言中获取cpsr寄存器

static inline unsigned longarch_local_cpsr_save(void)

{

unsignedlong flags ;

asmvolatile( "   mrs %0, cpsr   @ arch_local_irq_save\n"

:: "r" (flags): "memory", "cc");

returnflags;

}

2 函数调用时stack frame

每一个进程都有自己的栈。考虑进程执行时发生函数调用的场景，母函数和子函数使用的是同一个栈，在通常的情况下，并不需要区分母函数和子函数分别使用了栈的哪个部分。但是，当需要在执行过程中对函数调用进行backtrace的时候，这一信息就很重要了。

简单的说，stack frame就是一个函数所使用的stack的一部分，所有函数的stack frame串起来就组成了一个完整的栈。stack frame的两个边界分别由FP和SP来限定。

通过FP指针就可以找出所有的backtrace过程

在程序执行过程中(通常是发生了某种意外情况而需要进行调试)，通过SP和FP所限定的 stackframe，就可以得到母函数的SP和FP，从而得到母函数的stack frame(PC，LR，SP，FP会在函数调用的第一时间压栈)，以此追溯，即可得到所有函数的调用顺序。

要内核支持FP指针必须打开CONFIG_FRAME_POINTER配置

3内核save_stack_trace分析

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 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 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;

}

3.1 获取stack实例

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, "[]%pS\n",

(void *)trace.entries[i], (void*)trace.entries[i]);

}

}

原文：http://blog.csdn.net/bin_linux96/article/details/41908097