Linux内核源码阅读系列(8)-内核的构成 之 二

进程管理

进程

进程是正在运行的程序的实体。它们是Linux用以完成各种应用程序的核心。”链接“系列文章中说明了一个应用程序如何从源代码变成可执行文件,以及如何将这个可执行文件加载进入内存从而使程序运行的过程。可执行的目标文件被加载后就行成了进程的基本组成部分。操作系统本身还会为每一个进程添加一些附加的信息用以对进程进行调度管理和创建/消灭等过程。另一方面,为了方便用户的使用,Linux向用户应用程序提供了一些系统调用帮助用户应用程序进行进程的管理。进程有自己的生命周期,它可以被创建,消灭,使其进入活动状态等等,这些状态之间可以通过系统调用或者进程调度的机制进行转换。下面的图展示了从交互式shell中启动’yes’这个应用程序的过程。

从shell运行yes

从shell运行yes

bash在使用fork()系统调用之后,只是在虚拟内存空间上复制一个和自己完全相同的拷贝,那么这时我们就可以得到两个bash,其中早先的那个bash进程通常被称作父进程,而其后被创建的那个进程被称作子进程;因为现在用户需要运行的是yes这个程序,其中原来的bash需要使用wait()进入等待状态以便腾出CPU占用时间来运行’yes’。在接下来的过程中,刚刚被创建的那个新的bash的副本,会使用exec()系统调用将yes这个应用程序的可执行文件映射并拷贝到内存中,通过这个方式,操作系统可以创建一个信的进程。yes这个程序比较特殊,他的作用事实上就是不断的输出’yes’这个字符串,但事实上任何应用程序都可能退出,比如我们这个时候按一下Ctrl-C,其后的动作是通过系统系统调用exit()结束进程。父进程bash在接收到子进程结束的消息后,可能又进入活动状态。

线程

进程管理部分的代码,着重可以看看进程的创建,消灭以及其他状态之间的转换是怎样实现的,此外,还有“线程”需要注意。线程在Linux中的实现和进程非常相似,可以说他是一种特殊的进程。线程的特殊之处在于多个线程之间共享相同的“进程空间”——这一点其实逻辑上很容易想清楚,就是多线程通常用来相应高并发的任务,而这些线程事实上完成的功能是一致的,他们之间不需要有区别。从“调度器”的角度来看,线程和进程是一致的。

信号

进程管理的另外一个重要内容是所谓的“信号”(signal),它是一个简单的向进程传递非同期时间的功能。收到信号的进程可以选择通过指定的signal handler做一个动作,或者忽略这个信号,等等。收到信号的进程的行为于收到中断的内核非常相似。:)说了等于没说……

内存管理

关于内存管理的内容的文章简直可以说在互联网上泛滥成灾。写文章的人从不同的角度对应该怎样管理内存的问题做了很多讨论。内存管理的策略也是多如牛毛,比如C++标准模板库中用free list实现的内存池等等。所以,看内存管理的话,很多大仙可以拍拍胸脯满怀信心的就把书翻过去了。但是,Linux作为一个经过实战考验的开源操作系统——事实上开源创造了更加安全可靠的操作系统,研究发现Linux2.6版本共5.7million行的源代码中,仅仅存在985个Bug;而如果将总代码量于工业界的平均水平相比,Linux中存在114,000~171,000个Bug都可以被评价为“质量不错”——它的内存管理实现可以被认为在很多地方都具有参考和借鉴的意义。就凭这一点,内存管理简直可以说是内核代码中最值得关注的部分。

Linux内存管理可以被分为两大块。第一是实内存管理,另外一个是虚拟内存的管理方法。

实内存管理

实际的内存分配策略往往区分大块内存划分和小块内存划分以提高内存分配算法的效率。Linux的实内存分配测律也不例外,她采用了以Page为单位的Buddy方法来划分大块内存区域的同时,对于小内存区块却采用了一个叫做Slab的小内存划分方法。这两者的实现都非常精巧,值得仔细研究。

虚拟内存管理

虚拟内存(Virtual Memory)技术可以说是现代计算机系统中非常重要的组成部分。它不但关系到硬件的设计,而且还关系到很多重要的软件技术的实现,比如以前文章中提到的共享库和动态链接技术。MMU(Memory Management Unit)是在计算机体系结构发展这中产生的,这个硬件组件是现代虚拟内存技术的硬件基础。Linux中采用了多重虚拟地址的虚拟内存空间,所以,它让操作系统本身获得了更加强大的能力。所以,虚拟内存管理的部分应该硬件结合软件一起来看才能看个通通透透。虚拟内存同时和内核的其他部分,比如,进程管理有很多关联的地方——比如前文提到的程序的内存映像的生成等,所以,在讨论进程的过程中也不能忘记虚拟内存。

这个部分的关键词有:Demand paging,Swapping, Page fault等等。

Linux内核源码阅读系列(7)-链接4

可执行目标文件

静态连接的目标输出是“可执行的目标文件”,它的基本形式当然也是ELF。只是,“可执行目标文件”与“可重定位目标文件”一些重要的区别。产生这种区别的原因在于这两种文件的目的不同。“可重定位目标文件”的目的是提供给链接器(静态链接的ld或者动态链接的ld.so)链接信息以便帮助可执行文件。而“可执行目标文件”的目的在于提供一种形式将程序的代码方便的加载到内存中以便执行。所以,“可执行的目标文件”中增加了一个叫做“段头表”(segment header table)的部分,这个表中描述了文件内容到主存的映射方法,在程序运行时,加载器(loader)将根据这个表的信息把“可执行目标文件”中的代码拷贝到主存中去。

内存布局

下面的图展示了一个典型的可执行目标文件的构成,以及在取其相应的内存“镜像”之间的简单关系(并不严格)。

 +----------------------+
 |    ELF header        |
 +----------------------+     +--------------------+ 0x00000000
 | segment header table |     |       NO USAGE     |
 +----------------------+     +--------------------+ 0x08048000
 |       .init          | - > |  read-only segment |
 +----------------------+     |                    |
 |       .text          | - > |  (size <= 4kb*n)   |
 +----------------------+     |                    |
 |       .rodata        | - > |  ......            |
 +----------------------+     +--------------------+
 |       .data          | - > | read-write segment |
 +----------------------+     |  (size <= 4kb*m)   |
 |        .bss          | - > |  .....             |
 x----------------------x     +--------------------+
 /        .symtab       /     |       heap         |
 x----------------------x     +--------------------+
 /      .rel.text       /     |        ↓           |
 x----------------------x     |                    |
 /      .rel.data       /     +--------------------+ 0x40000000
 x----------------------x     |   shared library   |
 /       .debug         /     | memory map area    |
 x----------------------x     +--------------------+
 /       .line          /     |        ↓           |
 x----------------------x     |        ↑           |
 /       .strtab        /     +--------------------+
 x----------------------x     |      stack         |
 / section header table /     +--------------------+ 0xbfffffff
 x----------------------x     |      kernel        |
                              +--------------------+

在IA32结构上,Linux采用虚拟内存(virtual memory)技术,所以,每个程序在内存布局的时候都好像已经拿到了所有的内存一样,而程序代码最开始的地方总是在虚拟地址0x08048000处。加载器从这里开始拷贝ELF中定义的只读代码,这些只读代码通常被包含在.init.text.rodate段;所谓段和节事实上同样的,只是在链接的时候,它被称为“节”,而加载时却被成为“段”。.init段是链接器给每个“可执行目标文件”添加的,在其中包含了程序的初始化代码的一部分;链接器在其中写入了一个叫做_init的函数,这个细节需要注意。只读代码要求4kb对齐,所以虽然它实际的大小为往往小于4kb*n,但是其后紧跟的读/写段却需要从4kb*n的虚拟内存处开始。同样,读/写段也需要4kb对齐(想想why?)。读写段之后紧跟的是堆(heap)的内存区域,众所周知,这个区域是为了malloc函数群动态分配的内存准备的;此外,这个区域将根据需要向上(向高地址区域)增长。ELF文件中的.symtab.debug等内容并不会被加载进入内存,上图中用斜线表示了。操作系统还会为这个程序在内存的0x40000000处准备了动态加载的共享库代码区域;0xbfffffff处准备了另一个重要的运行时数据结构“栈”,这个区域主要用于程序中的过程调用,并且区域大小向下增长。用于应用程序的空间到这里结束了,紧跟在运行时栈的栈底后面的区域,也就是从0xc0000000开始就是内核代码了。

加载器(loader)通常是shell呼出的,但是任何应用程序都可以通过系统调用execve()调用加载器。

内存访问越界的时候通常你会被警告很奇怪的消息”segment fault”,并且程序终了。相信这个会帮助你,让你对“段”的记忆更加深刻些了,哈哈哈。这是一句很笼统的提示,但他说的就是你的指针在乱跳,可能对只读内存区域进行了写操作。

启动代码

加载器运行时,首先构造一个上面提到的那样的内存映像,然后根据“段头表”的指引,将程序代码拷贝到内存中。接着,他会跳转到程序的入口开始执行程序。提到c语言的程序入口,那可不就是大名鼎鼎的main函数么?这个说法没错,但是也不全对。真正的程序入口是一个叫做_start的函数,这个函数被包含在crtl.o文件中。这个目标文件是C语言运行时环境的一部分。它的大致的示意代码如下所示:

0x080480c0 <_start>        /*  .text段的入口点                 */
  call _libc_init_first     /* 启动.text节的代码通常是初始化c的库  */
  call _init               /* 启动_init代码,也就是在_init段中   */
  call atexit              /* 注册一些在程序结束时需要作的动作     */
  call main                /* 应用程序的入口点                  */
  call _exit               /* 结束应用程序,将控制权返还给操作系统  */

很明显,c语言的main函数是约定好的,如果没有这个函数程序将不能被执行。关于ctrl.o这个事情,让我想起面试国内某家公司的时候,曾被面试官问到这个问题;他问c程序在调用main之前需要做哪些动作,当时刚刚毕业,我的回答是现编的……,当然是错的很离谱,恩,往事不堪回首。如果你经常看到编译时或者运行时提示找不到crtl.o文件,恭喜你,你可以记住它了。嘿嘿。

动态链接和PIC代码

顾名思义,动态链接就是将链接过程从编译时挪到了运行时。这个内容写起来会有如“懒婆娘的裹脚”,各位看官可以参照IBM developerWorks的文章。但是动态链接对于立志做个好程序员的有痔青年是非常重要的内容,所以,如果有时间还是要认真研究的。简单的过程应该是像这样的

生成.so


gcc -shared -fPIC -o libvector.so x.c y.c z.c

这个过程就是将源代码文件编译成为目标文件,然后在用PIC指定它进行特殊的链接重定位定位信息,其中比较重要的就是添加PLT(procedure linkage table)和GOT(global offset table)。PLT被添加到.text节,而GOT被添加到.data节。PIC代码有个缺陷,就是因为对GOT的存储器引用造成的,具有大量寄存器堆的机器上没有太大问题,但是,寄存器不足的机器上却会造成严重缺陷。比如,MIPS结构的GOT问题就由来已久。对于外部过程的调用,PIC代码中采用一种叫做“延迟绑定”(lazy binding)技术,这个也是需要好好学习一下的。

链接共享库


gcc -o prog main.c libvector.so

这个链接过程不像静态链接过程,链接器并不真正的拷贝共享库中的.text.data节到可执行文件之中。相反,链接器会拷贝一些重定位和符号表信息,以便运行时可以解析对共享库代码和数据的引用。如你说知道的,这个过程就是在那个著名的$LD_LIBRARY_PATH之中去寻找共享库文件。

动态加载动态链接共享库


gcc -rdynamic -o prog main.c -ldl

通过dlopen()等函数可以在程序中动态地加载和链接共享库,在编译该程序时,只要连接libdl就可以了。而运行时,这个动态的加载和链接过程需要在被称为动态链接器的ld.so帮助下完成。这种方法特别灵活,因此被在各种各样的系统中广泛得应用,比如Java中的JNI(Java Native Interface),通过它可以让Java程序调用本地的C或者C++函数库。

这篇文章的目的在于说明一个程序是怎样形成,怎样加载,最终怎样在Linux中执行的,目的已经达到了,我就不再罗嗦了。

Linux内核源码阅读系列(6)-链接3

上一篇举例的时候那个例子并不是很恰当,因为用局部变量的生存周期来解释的话,也是行的通的。那个例子只能说是又添加了一种新的解释而已。要找一个比较妖的还挺难,就直接抄书了:

/* foo5.c */
#include <stdio.h>
void f(void);

int x = 15213;
int y = 15212;

int main()
{
	f();
	printf("x = 0x%x y = 0x%x n",
		x, y);
	return 0;
}
/* bar5.c */
double x;

void f()
{
	x = -0.0;
	^^^---链接器在处理这个符号x的时候,选择了,foo5.c文件中定义的
	      “强符号”int型的x,也就是解释为foo5.c中的x的内存位置写入
	      在这里定义的double型的值。
}

在IA32/Linux机器上,double型是8个字节,而int型是4字节;因此,这里将用double型的”-0.0″覆盖foo5.c中的x和y的内存位置,于是理所当然的程序出了一个意想不到的意外,而且这类错误是不容易被发现。

静态链接库

静态链接库就是把一堆相关的.o文件使用ar工具打包。最著名的静态连接库恐怕就是libc.a了。这是C语言标准库的静态链接版本。程序跟静态连接库链接的时候一般采用如下形式的命令:

$ gcc -O2 -c main.c
$ gcc -static -o swap_sample main.o libswap.a

程序在跟静态库链接的时候,首先链接器会按照命令行输入的从前往后的方向对可重定位文件进行符号解析,找出在模块内部未定义的符号,并将在其后找到包含这个符号定义的那个模块的代码和数据拷贝进入将生成的可执行目标文件,并对其中的符号进行重定位,如果这些未定义的符号全部解决,则链接成功并输出可执行文件,否则链接器会报错。

重定位

重定位就是确定一个对象(包括代码和数据)在存储器中的位置的过程。关于每个需要重定位的符号,链接器有两个方面事情要做,1. 对模块中的符号的定义(definition)进行定位,这个工作主要是合并各个输入模块的代码和数据节,并给每个节和每个符号定义赋以新的存储器地址; 2. 将模块中的引用(reference)指向正确的符号定义位置,这个工作主要依靠“重定位表目”完成,也就是上一篇中提到的实例中的rel.textrel.data节的总览中提到的”R_386_PC32“和”R_386_32“等附带有重定位类型的表目。

重定位表目可以用下面的包括下面代码展示的内容:

typedef struct {
	int offset;	/* 需要被重定位的“引用”在所在节中的偏移量 */
	int symbol:24,	/* 这个引用应该指向的符号 */
	    type:8;	/* 重定位类型 */
}

最重要的两类重定位类型就是”R_386_PC32″和”R_386_32″。

R_386_PC32: 这个类型的重定位信息主要控制的是程序在执行是的跳转。重定位一个使用32位PC(program counter)相关的地址引用。当CPU执行使用PC相关寻址的指令时,它就将在代码中编码的32位值加上PC当前运行时的值,得到有效地址,而PC值通常默认是存储器中的下一条指令的地址。

R_386_32:重定位一个使用32位绝对地址的引用。通过绝对寻址,CPU直接使用在指令中编码的32值作为有效地址。————《深入理解计算机系统》

重定位符号应用的算法伪代码如下:

foreach section s {
	foreach relocation entry r {
		refptr = s + r.offset; /* 指向需要被重定位的引用的指针 */

	/* relocate a PC-relative reference */
	if (r.type = R_386_PC32) {
		refaddr = ADDR(s) + r.offset; /* 引用的运行时地址 */
		*refptr = (unsigned) ((ADDR(r.symbol) + *refptr - refaddr);
	}

	/* relocate an absolute reference */
	if (r.type == R_386_32)
		*refptr = (unsigned) (ADDR(r.symbol) + *refptr);
	}
}

R_386_PC32

在没有跳转的情况下,众所周知程序是按照从上到下的顺序顺序执行的,而这个事实在机器语言级别的直接反应就是PC的值默认情况下都会指向(经过call指令的计算后)当前执行指令的邻近下一条指令的地址。IA32结构中,一条指令的大小是4字节,所以,call指令的默认参数总是”-4″(0xfffffc),以便操作数于PC值相加时,跳转到临近的下一条指令。也就是说上面伪代码中的refptr在PC相关的地址引用中,初始值是”-4″。那么,如果程序发生非顺序执行的跳转,其重点因素就是要给call等类似的指令一个正确的操作数。这个操作数与PC中的值进行计算之后可以跳转到相应的对象(代码)保证程序的正确执行。”R_386_PC32″这种类型的重定位过程就是给call或者类似指令计算一个正确的操作数的过程。上面展示的伪代码中的refptr就是这个操作数。因为在给符号定义(definition)定位的过程中,ADDR(r.symbol)是确定的,所以,refptr就是可以计算的。

R_386_32

这种情况就简单些,计算方法只是将可重定位引用所在节的首地址和其偏移量相加,这样就能确定符号在虚存中的位置。

未完待续。

——写完后偷偷修改的分割线——-
这两天些的东西非常tmd的艰深难懂,但是硬骨头还是要啃的。市面上有很多SourceReview的书,但是读完之后总是觉得只见树木不见森林。我想要一个从上到下看到通通投投的Linux内核“解析体验”,哈哈哈。理论是比较枯燥,细节是比较烦人,但是所有奇妙的计算效果就是用这些东西为基础的,没有办法。很多时候也许真的需要不求甚解,但是,我是个偏执狂,如果遇到自己感兴趣却没有弄通的东西总觉得如鲠在喉。最终结果是写这样的文章难为自己,看这个样的文章吓走朋友,哈哈哈