uClinux下用户程序的执行
之所以从用户程序谈起，是因为我们平常接触最多的还是应用程序。从应用程序引出到操作系统我觉得比较自然。下面就从一个简单例子介绍一个程序如何在操作系统中运行。
假如有个c程序：
int main(int argc, char **argv[])
{
printf("hello world!");
return 0;
}
这是一个最简单不过的程序了，一般一个C语言程序，都从main开始执行。那么，main函数是不是与其他函数有所区别，地位有些特殊呢？
不是的。main函数和其他函数地位一样。其实，我们完全可以做到让一个c程序从任何地方开始执行。比如linux，它就没有main函数，大家都知道，系统执行过启动的一段汇编后，就会跳转到位于init/main.c中的start_kernel中开始执行。
那么为什么用户程序都要从main函数执行呢？这就是用户C库的原因。一般用户用c语言开发时会调用一些库函数，编译成obj文件后，在链接过程中把库函数的二进制代码链接进入程序，最后形成二进制可执行文件。
链接过程中，链接器会在用户程序前插入一些初始化的代码。uClinux下是在crt0.s中(我移植的是uClibc库)。不管什么平台下什么形式的crt0.s，这个文件最后几行代码中肯定有一个jmp(或者call或br等转移指令) main(或__uClibc_main)。这就是为什么你的程序都从main开始执行。如果你把这个跳转标号改成任意一个标号，比如foo。而你的程序里面既有main，又有foo，则这种情况下，程序就先从foo开始执行。所以，main函数和其他函数一样，并没有特殊地位。
下面谈谈在uClinux中，main函数的argc,argv是参数怎样传递的。我们以flat格式可执行文件为例。uClinux下支持一种叫flat的可执行文件格式。这种文件格式比较简单，基本上是平铺的，所以叫flat很形象。现在好像uClinux-2.4.x内核的版本已经能够支持elf格式的文件执行了。不过为了举例简单，我还是用flat格式举例。这里暂不分析flat文件格式，我们把注意力放到参数传递上。uClinux开发用户程序，首先当然是编码，然后编译，编译生成的文件是elf格式的，所以要用工具elf2flt将elf文件转换成flat，假设这个工作已经完成。
我们在uclinux的shell下执行一个文件foo x y，foo是程序名，x, y是参数。学过C语言的都知道，x，y作为参数会传递给main，其中argc＝3，argv[0]="foo", argv[1]="x", argv[2]="y"。这些参数是如何传递进来的呢。
在你执行一个程序的时候，操作系统会调用进程中把库函数的二进制代码链接进入程序，最后形成二进制可执行文件。
在装入文件时，系统会根据不同的文件格式调用不同文件装入的handler，如果是flat格式，就会调用load_flat_binary()，在fs/binfmt_flat.c中。有关参数，会根据一路传递下来的argv,envp首先处理一遍计算出参数的个数argc,envc。然后在函数create_flat_tables里面建立好参数表。整个函数代码如下：
static unsigned long create_flat_tables(unsigned long pp, struct linux_binprm *bprm)
{
(1) unsigned long *argv,*envp;
(2) unsigned long * sp;
(3) char * p = (char*)pp;
(4) int argc = bprm->argc;
(5) int envc = bprm->envc;
(6) char dummy;
(7) sp = (unsigned long *) ((-(unsigned long)sizeof(char *))&(unsigned long) p);
(8) sp -= envc+1;
(9) envp = sp;
(10) sp -= argc+1;
(11) argv = sp;
(12) flat_stack_align(sp);
(13) if (flat_argvp_envp_on_stack()) {
(14) --sp; put_user((unsigned long) envp, sp);
(15) --sp; put_user((unsigned long) argv, sp);
(16) }
(17) put_user(argc,--sp);
(18) current->mm->arg_start = (unsigned long) p;
(19) while (argc-->0) {
(20) put_user((unsigned long) p, argv++);
(21) do {
(22) get_user(dummy, p); p++;
(23) } while (dummy);
(24) }
(25) put_user((unsigned long) NULL, argv);
(26) current->mm->arg_end = current->mm->env_start = (unsigned long) p;
(27) while (envc-->0) {
(28) put_user((unsigned long)p, envp); envp++;
(29) do {
(30) get_user(dummy, p); p++;
(31) } while (dummy);
(32) }
(33) put_user((unsigned long) NULL, envp);
(34) current->mm->env_end = (unsigned long) p;
(35) return (unsigned long)sp;
}
(1)-(6)行是变量声明。其中argc和envc分别记录前面已经计算出来的参数个数和环境变量参数个数。p=pp是参数和环境变量数组的指针，sp是你要执行程序的用户区堆栈，就是foo程序执行时，用户空间堆栈的起始地址。(8)-(11)是一个堆栈调整。首先sp移动envc+1个单位，这envc+1个用来存放一共envc个envp[0]->envc[envp-1]元素地址的，多余一个放0，表示envp数组结束。然后sp在移动argc+1各单位，留出argc+1单位空间，这argc+1个单位是用来存放argc个argv[0]->argv[argc-1]元素地址的，多余一个也放0，表示argv数组结束。经过堆栈调整，argv和envp各自指向自己在堆栈中的位置。如果开始堆栈初值记为init_sp，则现在envp=init_sp-(envc+1)，
argv=envp-(argc+1)。
(12)无关紧要，略去不提。(13)-(17)又是一次堆栈调整。(14)是sp再移动1个单位,然后将envp放入这个地址(此时envp=init_sp-(envc+1)),然后(15)又将sp移动一个单位,将argv写入. (17)是移动堆栈后将argc也写入里面.
(18)-(35)行是将argv[0]->argv[argc-1](在p所指向地方)依次写入argv所指堆栈区域中.然后再将envp[0]->edummy, p); p++;
(31) } while (dummy);
(32) }
(33) put_user((unsigned long) NULL, envp);
(34) current->mm->env_end = (unsigned long) p;
(35) return (unsigned long)sp;
}
下面举例和画图来说明过程.比如执行foo x y,此时argc=3,argv[0]="foo",
argv[1]="x", argv[2]="y", envc=1, envp[0]="path=/bin". 假设用户堆栈起始
空间堆栈地址是sp=0x1f0000,pp=0x1c0000.则处理过后在foo执行前,他的用户空
间堆栈frame如下:
--------------------------------
0x1f0000 | 0000 |
--------------------------------
0x1efffc | envp[0] = 0x1c0008 | ---->指向"path=/bin"
--------------------------------
0x1efff8 | 0000 |
--------------------------------
0x1efff4 | argv[2] = 0x1c0006 | ----->指向"y"
--------------------------------
0x1efff0 | argv[1] = 0x1c0004 | ----->指向"x"
--------------------------------
0x1effec | argv[0] = 0x1c0000 | ----->指向"foo"
--------------------------------
0x1effe8 | start addr of envp = 0x1efffc|
在写入同时,还要设置进程控制块相应的数据结构,如arg_start,env_start,env_end等.
到r2-r6里来传递。当然，如果超过5个，就要借助堆栈了。
既然main带了参数，那么在调用main之前，要把argc放到r2里面，argv放到r3里面，envp放到r4里面。刚才说了，sp是用户空间堆栈起始地址。所以在开始执行foo代码时候，r0=sp，在上文例子里r0等于0x1effe0.则如下伪汇编代码可以让参数装入正确寄存器。
load r2, (r0) /* r2 = argc */
load r3, (r0, 4) /* r3 = argv */
load r4, (r0, 8) /* r4 = envp */
call main /* 跳转到main函数 */
call _exit
我这个程序例子还没有完全讲完，比如后面printf怎么处理等，不过手都酸了，就
先讲到main函数的参数传递吧。刚学c语言那阵觉得main挺神秘，做过系统就知道，其实
main跟别的函数没有任何区别:)
printf和标准输出
上次写到main函数的参数传递.现在继续往下进行.最近忙实验室的事情,看了一周的文章,也没啥进展,周末写点技术贴,放松一下:-)
进入main函数后,就要调用printf("HelloWorld!");了.顺便将C语言参数传递提一下.字符串"Hello World!"编译器是当作字符串常量来处理的,虽然printf是在main内部调用,但"HelloWorld!"可不是放在main的栈中,字符串常量至少是放到.data段的,准确说是放在只读数据段.rodata,这个我在工作站上验证了一把.假如编辑的文件名是hello.c,首先编译生成elf格式二进制文件gcc hello.c -o hello然后用命令objdump -shello -s参数会将所有段信息dump出来.你会看到"HelloWorld!"位于.rodata段.
printf()是个标准C库函数.虽然功能简单,但实现起来却不容易.这是个和平台相关的函数.在pc上,printf输出是输出到终端屏幕,在嵌入式设备上,一般printf()是输出到串口.同是调用printf(),最终输出的设备却不同,从直觉的肯定是感觉printf()底层和平台是相关的.那么printf()是怎样实现的呢?
可以看一下C库程序的代码,这里以uClibc为例.
intprintf(const char * __restrict format, ...)
{
va_listarg;
intrv;
va_start(arg, format);
rv= vfprintf(stdout, format, arg);
va_end(arg);
return rv;
}
printf支持字符串格式化输出,具体参数处理这里不提.可以看到printf()调用了vfprintf(),vfprintf()第一个参数是stdout是标准输出设备.标准输出设备是个结构体,最重要的成员就是他的描述符,其值为1.
跟进vfprintf()函数看,里面是复杂的参数处理,因为printf()的参数形式很灵活,所以在vfprintf()里面要对传进来的参数进行解析处理,形成最终的输出格式.有兴趣的可以看一下,借助这个可以让你在一个没有操作系统的平台上实现你自己的printf()函数.这样你在裸机上调程序时输出调试信息就更方便些(实际上uClinux的printk就是这么干的).
vfprintf()在参数处理之后，就是输出了，输出调用的是putc()，进入putc()然后再跟进几层函数，发现调用了linux系统调用write()。呵呵，是的，输出就是借助操作系统代码完成的。在write之前所有的代码都是C库的代码，可以说是和平台无关的。而涉及到具体输出，就要调用操作系统提供给你的接口。系统调用的原理就是通过一定手段（一般是trap陷阱）进入操作系统的内核空间，调用操作系统代码来完成某些任务。
Linux系统调用针对不同平台有不同的实现方式。这个以后再讲。调用write()后，进入内核空间，首先来到的就是sys_write()，这个函数代码位于fs/read_write.c中。一进入sys_write()，就要根据传进来的fd描述符找到相应的file结构。对于标准输出，fd=1，每个进程的进程控制块都有一个打开文件的数组。file结构就是根据fd在这个数组中查找到相应的结构。找到结构后，就会调用file->write()来向外输出。具体输出到哪里，就要看file结构对应的设备驱动是什么。一般嵌入式系统可以从串口将信息输出，那么file->write()最底层就是调用的串口驱动的类似transmit_char的函数。
有关linux的设备驱动有很多书介绍,整个驱动的结构很复杂,我这里也没必要提了.至于终端设备怎样挂在驱动队列里面,怎么根据标准输出的描述符找到相应的驱动结构
有兴趣的请查阅相关资料.
--
手段（一般是trap陷阱）进入操作系统的内核空间，调用操作系统代码来完成某些任务。
Linux系统调用针对不同平台有不同的实现方式。这个以后再讲。调用write()后，进入内核空间，首先来到的就是sys_write()，这个函数代码位于fs/read_write.c中。一进入sys_write()，就要根据传进来的fd描述符找到相应的file结构。对于标准输出，fd=1，每个进程的进程控制块都有一个打开文件的数组。file结构就是根据fd在这个数组中查找到相应的结构。找到结构后，就会调用file->write()来向外输出。具体输出到哪里，就要看file结构对应的设备驱动是什么。一般嵌入式系统可以从串口将信息输出，那么file->write()最底层就是调用的串口驱动的类似transmit_char的函数。
有关linux的设备驱动有很多书介绍,整个驱动的结构很复杂,我这里也没必要提了.至于终端设备怎样挂在驱动队列里面,怎么根据标准输出的描述符找到相应的驱动结构有兴趣的请查阅相关资料.
----------------
| r7 |
----------------
| r6 |
----------------
| r5 |
----------------
| r4 |
----------------
| r3 |
----------------
| r2 |
----------------
0x1effC4 | r1 |
----------------
0x1f0000和0x1effc4分别是执行过(14)前后r0的值。这是个contexsave的操作。
注：lrw是立即数装入操作，addu是无符号加法，mfcr和mtcr是控制寄存器移动 操作，bclri是位清除操作，ldw是load word操作，addi是立即数加法操作。
(15)-(19)是做的栈指针保存操作。将当前进程用户栈和内核栈保存到进程控制块相应的数据结构中。linux下除了内核线程（只有内核栈）每个进程都有2个栈，一个在用户空间一个在内核空间。如果是内核线程，则不用关心它的用户堆栈，反正不会用到，是什么值都可以。如果用户进程，则在用户进程执行系统调用或者在用户进程执行时发生中断时，都需要从用户空间进入内核空间，在进入时，原先的用户空间栈指针就会暂时存放到ss1中。所以(17)-(18)两行就是从ss1中取出用户空间栈指针，存入task_struct中。(15)-(19)的操作可以总结为：
prev->thread.usp= ss1 保存用户栈指针
prev->thread.ksp= r0 保存内核栈指针
那么有人可能会问，ss1能够保证就是正确的当前用户栈指针么？当然可以。因为内核线程没有用户栈，所以这个值是什么无所谓。而对于用户进程，进入resume的唯一入口就是schedule，而这又都是操作系统内核代码。用户进程进入内核手段就有系统调用和中断，而在系统调用和中断处理一进来就保存了用户堆栈到ss1，所以在运行时，只要在内核里用的都是内核栈，用户栈指针不会变。
(20)-(23)执行的操作相当于_current_task = next。不再详细解释。
(24)-(28)执行的是装入新进程上下文的准备工作，也就是准备装入next了。(24)-(25)是装入next进程的内核和用户栈。因为进程的上下文都保存在该进程的内核栈里面，所以第一步就是装入该进程的栈指针。(27)-(28)是装入next进程在切换前的状态信息。(26)就是更新ss1,现在要装入新进程了，当然就要设置新的用户栈。
(29)是装入next进程的上下文。next进程在栈里有一个和上图一样的上下文，现在就要装入。
(30)是函数调用返回。如果这个进程是刚fork出来的子进程，则上下文里面r15=ref_from_fork（可以参看copy_thread函数），否则就是返回到switch_to里面第(6)句位置。
上面就是进程切换的部分。这部分是和平台相关的。以上是我实现的代码，感觉效率并不是非常高，但功能是正确的。可能有些地方我没有讲得很清楚，有什么问题欢迎提出。
http://blog.sina.com.cn/s/blog_4cb133e501000au3.html
4372
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
