建立自己的函数调用帧

本文从最简单的打印“hello world!”的C程序开始，写出其汇编程序（在汇编中使用C库函数），讲解怎样建立自己的函数调用帧，接着使用jmp指令替代call完成函数的调转与返回。在linux内核中这种技巧被大量使用，最后举出内核中使用到的两个实例。

首先，下面的C程序完成的功能，相信大家学大多数语言，都是用来讲解的第一个示例：

//helloworld1.c

#include <stdio.h>

int main()
{
        printf("hello world!\n");
        return 0;
}

我们使用gcc进行编译生成可执行文件，结果如下所示：

[guohl@guohl]$ gcc -o helloworld1 helloworld1.c
[guohl@guohl]$ ./helloworld1
hello world!

 

将上述C语言函数改成汇编程序，当然printf与exit函数还是使用C库自带的函数，这样就是汇编与C的混合编程，修改后程序如下：

#helloworld2.s

.section .data
output:
        .asciz "hello world!\n"

.section .text
.globl _start
_start:
        pushl $output	#通过栈传递参数
        call printf	#调用C库的printf函数
        addl $4, %esp	#恢复栈指针
        pushl $0	#以下两行为exit(0)
        call exit

在这里开始调用printf与exit函数所使用到的栈帧是我们自己建立的，因为这两个函数的参数均是通过栈传递的，因此将参数入栈。从函数返回时，再恢复调用之前的栈帧。

使用as与ld分别进行汇编和链接，运行结果如下：

[guohl@guohl]$ as -o helloworld2.o helloworld2.s
[guohl@guohl]$ ld -dynamic-linker /lib/ld-linux.so.2 -o helloworld2 -lc helloworld2.o[guohl@guohl]$ ./helloworld2
hello world!

在此程序中call指令实际完成了两件事——将下一条指令的地址压栈和将当前程序指针指向调用函数的入口。这样接下来就开始执行调用函数的程序，当从函数中返回时，ret指令恢复将之前压栈的下一条指令恢复到程序指针寄存器。

下面我们将call指令完成的工作重写一遍，得到：

#helloworld3.s

.section .data
output:
        .asciz "hello world!\n"

.section .text
.globl _start
_start:
        pushl $output
        pushl $1f	#将标签为1处的地址压栈
        jmp printf	#jmp到printf函数入口处，不是call
1:
        addl $4, %esp
        pushl $0
        call exit

在这里由于使用的是jmp指令而不是call指令，因此如果没有第11行的压栈指令，当程序从printf函数返回时，ret会将栈顶的值弹出到程序指针寄存器（即ip）中，对于本实验就跳转到数据段output那里了，这样就会出现段错误。因此，我们需要人为将函数返回时应该跳转的地址压栈，对于本程序即标号为1的地址。

与前一个实验一样编译链接并执行，得到结果如下：

[guohl@guohl]$ as -o helloworld3.o helloworld3.s
[guohl@guohl]$ ld -dynamic-linker /lib/ld-linux.so.2 -o helloworld3 -lc helloworld3.o
[guohl@guohl]$ ./helloworld3
hello world!

 

也许你就疑惑了，明明我用一个call就可以搞定的事，你为什么要用push和jmp两条指令完成呢？试想一下，如果我们不希望函数返回时执行到call的下一条指令，而是执行我们指定的一段程序，那么怎么实现呢？这时，将那段程序的地址先压栈，再通过jmp而不是call到调用函数，这样从函数返回的时候，就能执行到我们指定的程序段了。

下面举出内核中一个例子，使用的就是这种技巧：

#define switch_to(prev, next, last)					\
do {									\
	/*								\
	 * Context-switching clobbers all registers, so we clobber	\
	 * them explicitly, via unused output variables.		\
	 * (EAX and EBP is not listed because EBP is saved/restored	\
	 * explicitly for wchan access and EAX is the return value of	\
	 * __switch_to())						\
	 */								\
	unsigned long ebx, ecx, edx, esi, edi;				\
									\
	asm volatile("pushfl\n\t"		/* save    flags */	\
		     "pushl %%ebp\n\t"		/* save    EBP   */	\
		     "movl %%esp,%[prev_sp]\n\t"	/* save    ESP   */ \
		     "movl %[next_sp],%%esp\n\t"	/* restore ESP   */ \
		     "movl $1f,%[prev_ip]\n\t"	/* save    EIP   */	\
		     "pushl %[next_ip]\n\t"	/* restore EIP   */	\
		     __switch_canary					\
		     "jmp __switch_to\n"	/* regparm call  */	\
		     "1:\t"						\
		     "popl %%ebp\n\t"		/* restore EBP   */	\
		     "popfl\n"			/* restore flags */	\
									\
		     /* output parameters */				\
		     : [prev_sp] "=m" (prev->thread.sp),		\
		       [prev_ip] "=m" (prev->thread.ip),		\
		       "=a" (last),					\
									\
		       /* clobbered output registers: */		\
		       "=b" (ebx), "=c" (ecx), "=d" (edx),		\
		       "=S" (esi), "=D" (edi)				\
		       							\
		       __switch_canary_oparam				\
									\
		       /* input parameters: */				\
		     : [next_sp]  "m" (next->thread.sp),		\
		       [next_ip]  "m" (next->thread.ip),		\
		       							\
		       /* regparm parameters for __switch_to(): */	\
		       [prev]     "a" (prev),				\
		       [next]     "d" (next)				\
									\
		       __switch_canary_iparam				\
									\
		     : /* reloaded segment registers */			\
			"memory");					\
} while (0)

这时进程切换的核心代码，切换的具体过程就不赘述，可以参考我的一个PPT，下载地址http://wenku.baidu.com/view/f9a17542b307e87101f6968d.html?st=1。重点看第17行和19行，第17行将希望即将切换进来的进程next的执行的ip压栈（而此ip是在next被切换出去之前执行siwtch_to在第16行所保存的，即标号为1的地址），在第19行调转到__switch_to函数，待到从__switch_to函数返回时，此时就可以恢复执行next进程从上一次切换出去的地方（即标号为1）继续执行。如果按照此情景，完全可以将17和19行换成一句“call __switch_to”语句；关键地方在于，如果是fork新建的一个进程，第一次调度，它之前并未执行switch_to的语句，因此切换到它的时候，并不能让它从标号为1的地方开始执行，而是应该让进程从sys_fork系统调用中返回，该地址在sys_fork->do_fork->copy_process->copy_thread 函数中进行赋值：

p->thread.ip = (unsigned long) ret_from_fork;

这样对于切换到新进程第17行压栈的将不是标号为1的地址，而是ret_from_fork的地址。可以看出，在这里，设计的非常巧妙！而且还是必须的！