Linux（2）

fork和exec

函数fork( )用来创建一个新的进程，该进程几乎是当前进程的一个完全拷贝；函数族exec( )用来启动另外的进程以取代当前运行的进程。Linux的进程控制和传统的Unix进程控制基本一致，只在一些细节的地方有些区别，例如在Linux系统中调用vfork和fork完全相同，而在有些版本的Unix系统中，vfork调用有不同的功能。由于这些差别几乎不影响我们大多数的编程，在这里我们不予考虑。

fork（）

　　fork在英文中是”分叉”的意思。为什么取这个名字呢？因为一个进程在运行中，如果使用了fork，就产生了另一个进程，于是进程就”分叉”了，所以这个名字取得很形象。下面就看看如何具体使用fork，这段程序演示了使用fork的基本框架：
　　

1void main()
 2{
   int i;
   if ( fork() == 0 ) 
   {
      /* 子进程程序 */
      for ( i = 1; i <1000; i ++ ) 
         printf("This is child process\n");
   }
   else 
   {
      /* 父进程程序*/
      for ( i = 1; i <1000; i ++ ) 
      printf("This is process process\n");
   }
16}

程序运行后，你就能看到屏幕上交替出现子进程与父进程各打印出的一千条信息了。如果程序还在运行中，你用ps命令就能看到系统中有两个它在运行了。

那么调用这个fork函数时发生了什么呢？fork函数启动一个新的进程，这个进程几乎是当前进程的一个拷贝：子进程和父进程使用相同的代码段；子进程复制父进程的堆栈段和数据段。这样，父进程的所有数据都可以留给子进程，但是，子进程一旦开始运行，虽然它继承了父进程的一切数据，但实际上数据却已经分开，相互之间不再有影响了，也就是说，它们之间不再共享任何数据了。它们再要交互信息时，只有通过进程间通信来实现，这将是我们下面的内容。既然它们如此相象，系统如何来区分它们呢？这是由函数的返回值来决定的。对于父进程， fork函数返回了子程序的进程号，而对于子程序，fork函数则返回零。在操作系统中，我们用ps函数就可以看到不同的进程号，对父进程而言，它的进程号是由比它更低层的系统调用赋予的，而对于子进程而言，它的进程号即是fork函数对父进程的返回值。在程序设计中，父进程和子进程都要调用函数fork（）下面的代码，而我们就是利用fork（）函数对父子进程的不同返回值用if…else…语句来实现让父子进程完成不同的功能，正如我们上面举的例子一样。我们看到，上面例子执行时两条信息是交互无规则的打印出来的，这是父子进程独立执行的结果，虽然我们的代码似乎和串行的代码没有什么区别。

读者也许会问，如果一个大程序在运行中，它的数据段和堆栈都很大，一次fork就要复制一次，那么fork的系统开销不是很大吗？其实UNIX自有其解决的办法，大家知道，一般CPU都是以”页”为单位来分配内存空间的，每一个页都是实际物理内存的一个映像，象INTEL的CPU，其一页在通常情况下是 4086字节大小，而无论是数据段还是堆栈段都是由许多”页”构成的，fork函数复制这两个段，只是”逻辑”上的，并非”物理”上的，也就是说，实际执行fork时，物理空间上两个进程的数据段和堆栈段都还是共享着的，当有一个进程写了某个数据时，这时两个进程之间的数据才有了区别，系统就将有区别的” 页”从物理上也分开。系统在空间上的开销就可以达到最小。

exec( )函数族

系统调用execve（）对当前进程进行替换，替换者为一个指定的程序，其参数包括文件名（filename）、参数列表（argv）以及环境变量（envp）。exec函数族当然不止一个，但它们大致相同，在 Linux中，它们分别是：execl，execlp，execle，execv，execve和execvp，下面我只以execlp为例，其它函数究竟与execlp有何区别，请通过manexec命令来了解它们的具体情况。

一个进程一旦调用exec类函数，它本身就”死亡”了，系统把代码段替换成新的程序的代码，废弃原有的数据段和堆栈段，并为新程序分配新的数据段与堆栈段。唯一留下的就是进程号，也就是说，对系统而言，还是同一个进程，不过已经是另一个程序了。（不过exec类函数中有的还允许继承环境变量之类的信息。）

那么如果我的程序想启动另一程序的执行但自己仍想继续运行的话，怎么办呢？那就是结合fork与exec的使用。下面一段代码显示如何启动运行其它程序：

char command[256];
void main()
{
  int rtn; /*子进程的返回数值*/
  while(1) {
      /* 从终端读取要执行的命令 */
      printf( ">" );
      fgets( command, 256, stdin );
      command[strlen(command)-1] = 0;
      if ( fork() == 0 ) {/* 子进程执行此命令 */
         execlp( command, NULL );
         /* 如果exec函数返回，表明没有正常执行命令，打印错误信息*/
         perror( command );
         exit( errno );
      }
      else {/* 父进程， 等待子进程结束，并打印子进程的返回值 */
         wait ( &rtn );
         printf( " child process return %d\n", rtn );
      }
  }
}

Linux下的5种I/O模型

为了OS的安全性等的考虑，进程是无法直接操作I/O设备的，其必须通过系统调用请求内核来协助完成I/O动作，而内核会为每个I/O设备维护一个buffer。
整个请求过程为： 用户进程发起请求，内核从I/O设备中获取数据到buffer中，再将buffer中的数据copy到用户进程的地址空间，该用户进程获取到数据后再响应客户端。
在整个请求过程中，数据输入至buffer需要时间，而从buffer复制数据至进程也需要时间。因此根据在这两段时间内等待方式的不同，I/O动作可以分为以下五种模式：

1. 阻塞I/O (Blocking I/O)
2. 非阻塞I/O (Non-Blocking I/O)
3. I/O复用（I/O Multiplexing)
4. 信号驱动的I/O (Signal Driven I/O)
5. 异步I/O (Asynchrnous I/O)

阻塞I/O模型

最流行的I/O模型是阻塞I/O模型，缺省时，所有sockt都是阻塞的,这意味着当一个sockt调用不能立即完成时，进程进入睡眠状态，等待操作完成。

进程调用recvfrom,此调用直到数据报到达且拷贝到应用缓冲区或是出错才返回。最常见的错误是系统调用被信号中断，我们所说进程阻塞的整段时间是指从调用recvfrom开始到它返回的这段时间，当进程返回成功指示时，应用进程开始处理数据报。

非阻塞I/O模型

前3次调用recvfrom时仍无数据返回，因此内核立即返回一个EWOULDBLOCK错误。第4次调用recvfrom时，数据报已经准备好了，被拷贝到应用缓冲区，recvfrom返回成功指示，接着就是我们处理数据报。
当一个应用进程像这样对一个非阻塞sockt循环调用recvfrom时，我们称此过程为轮询（polling）.应用进程连续不断的查询内核，看看某操作是否准备好,这对CPU是极大的浪费，但这种模型只是偶尔才遇到。

I/O复用模型

I/O复用能让一个或多个I/O条件满足（例如，输入已经准备好被读，或者描述字可以承接更多的输出）时，我们就被通知到。I/O复用由select和poll支持。

我们阻塞于select调用，等待数据报socket可读,当select返回socket可读条件时，我们调用recvfrom将数据报拷贝到应用缓存区中。
将图3与图1比较，似乎没有显示什么优越性，实际上使用了select,要求两次系统调用而不是一次，但是select的好处在于我们可以等待多个描述字准备好。

信号驱动I/O模型

信号驱动I/O模型能在描述字准备好时用信号SIGIO通知我们。

首先我们允许socket进行信号驱动 I/O，并通过系统调用sigaction安装一个信号处理程序。此系统调用立即返回，进程继续工作，它是非阻塞的。
当数据报准备好被读时，就为该进程生成个SIGIO信号。我们随即可以在信号处理程序中调用recvfrom来读取数据报，并通知主循环数据已准备好被处理，也可以通知主循环，让它来处理数据报。
无论我们如何处理SIGIO信号，这种模型的好处是当等待数据报到达时，可以不阻塞。主循环可以继续执行，只是等待信号处理程序的通知：或者数据报已准备好被处理，或者数据报已准备好被读取。

异步I/O模型

异步I/O模型让内核启动操作，并在整个操作完成后（包括将数据报从内核拷贝到我们自己的缓冲区）通知我们。
这种模型与信号驱动模型的主要区别在于：信号驱动I/O是有内核通知我们何时可以启动一个I/O操作，而异步I/O模型是由内核通知我们I/O操作何时完成。

我们调用aio_red(Posix异步I/O函数以aio_或lio_开头)，给内核传递描述字、缓冲区指针、缓冲区大小（与red相同的3个参数）、文件偏移（与lseek类似），并告诉内核当整个操作完成时如何通知我们。此系统调用立即返回，我们的进程不阻塞于等待I/O操作的完成。在此例子中，我们假设要求内核在操作完成时产生一个信号，此信号直到数据已拷贝到应用程序缓冲区才产生，这一点是与信号驱动I/O模型不同的。

5种I/O模型的比较

前4种模型的区别都在第1阶段，因为前4种模型的第2阶段基本相同：在数据从内核拷贝到调用者的缓冲区时，进程阻塞于recvfrom调用。然而异步I/O处理的两个阶段都不同于前4个模型。

阻塞I/O：同步阻塞
非阻塞I/O：同步非阻塞（轮询）
I/O复用：同步阻塞（select，poll）
信号驱动I/O：同步非阻塞（信号）

同步和异步I/O

同步I/O：在I/O操作未完成前，请求进程会被阻塞
异步I/O：在I/O操作未完成前，请求进程不被阻塞

根据上述定义，我们的前四个I/O模型都是同步I/O模型，因为真正的I/O操作（recvfrom）阻塞进程，只有异步I/O模型属于异步I/O。

直接I/O

上述的几种I/O都属于缓存I/O。缓存 I/O 又被称作标准 I/O，大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中，操作系统会将 I/O 的数据缓存在文件系统的页缓存( page cache )中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。
在缓存 I/O 机制中，DMA 方式可以将数据直接从磁盘读到页缓存中，或者将数据从页缓存直接写回到磁盘上，而不能直接在应用程序地址空间和磁盘之间进行数据传输，这样的话，数据在传输过程中需要在应用程序地址空间和页缓存之间进行多次数据拷贝操作，这些数据拷贝操作所带来的 CPU 以及内存开销是非常大的。
凡是通过直接 I/O 方式进行数据传输，数据均直接在用户地址空间的缓冲区和磁盘之间直接进行传输，完全不需要页缓存的支持。操作系统层提供的缓存往往会使应用程序在读写数据的时候获得更好的性能，但是对于某些特殊的应用程序，比如说数据库管理系统这类应用，他们更倾向于选择他们自己的缓存机制，因为数据库管理系统往往比操作系统更了解数据库中存放的数据，数据库管理系统可以提供一种更加有效的缓存机制来提高数据库中数据的存取性能。

在块设备或者网络设备中执行直接 I/O 完全不用担心实现直接 I/O 的问题，Linux 2.6 操作系统内核中高层代码已经设置和使用了直接 I/O，驱动程序级别的代码甚至不需要知道已经执行了直接 I/O;但是对于字符设备来说，执行直接 I/O 是不可行的，Linux 2.6 提供了函数 get_user_pages() 用于实现直接 I/O。

内核为块设备执行直接 I/O 提供的支持

要在块设备中执行直接 I/O，进程必须在打开文件的时候设置对文件的访问模式为 O_DIRECT，这样就等于告诉操作系统进程在接下来使用 read() 或者 write() 系统调用去读写文件的时候使用的是直接 I/O 方式，所传输的数据均不经过操作系统内核缓存空间。
使用直接 I/O 读写数据必须要注意缓冲区对齐( buffer alignment )以及缓冲区的大小的问题，即对应 read() 以及 write() 系统调用的第二个和第三个参数。这里边说的对齐指的是文件系统块大小的对齐，缓冲区的大小也必须是该块大小的整数倍。

直接 I/O 的优点

直接 I/O 最主要的优点就是通过减少操作系统内核缓冲区和应用程序地址空间的数据拷贝次数，降低了对文件读取和写入时所带来的 CPU 的使用以及内存带宽的占用。这对于某些特殊的应用程序，比如自缓存应用程序来说，不失为一种好的选择。如果要传输的数据量很大，使用直接 I/O 的方式进行数据传输，而不需要操作系统内核地址空间拷贝数据操作的参与，这将会大大提高性能。

直接 I/O 潜在可能存在的问题

直接 I/O 并不一定总能提供令人满意的性能上的飞跃。设置直接 I/O 的开销非常大，而直接 I/O 又不能提供缓存 I/O 的优势。缓存 I/O 的读操作可以从高速缓冲存储器中获取数据，而直接 I/O 的读数据操作会造成磁盘的同步读，这会带来性能上的差异 , 并且导致进程需要较长的时间才能执行完;对于写数据操作来说，使用直接 I/O 需要 write() 系统调用同步执行，否则应用程序将会不知道什么时候才能够再次使用它的 I/O 缓冲区。与直接 I/O 读操作类似的是，直接 I/O 写操作也会导致应用程序关闭缓慢。所以，应用程序使用直接 I/O 进行数据传输的时候通常会和使用异步 I/O 结合使用。

文件系统

文件存储结构

Linux正统的文件系统(如ext2、ext3)一个文件由目录项、inode和数据块组成。

目录项:包括文件名和inode节点号。
Inode：又称文件索引节点，是文件基本信息的存放地和数据块指针存放地。
数据块：文件的具体内容存放地。

Linux正统的文件系统(如ext2、3等)将硬盘分区时会划分出目录块、inode Table区块和data block数据区域。一个文件由一个目录项、inode和数据区域块组成。Inode包含文件的属性(如读写属性、owner等，以及指向数据块的指针)，数据区域块则是文件内容。当查看某个文件时，会先从inode table中查出文件属性及数据存放点，再从数据块中读取数据。

软（符号）连接和硬连接

Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接，也叫软连接。默认情况下，ln命令产生硬链接。

硬连接

硬连接指通过Inode来进行连接。在Linux的文件系统中，多个文件名指向同一Inode是存在的。一般这种连接就是硬连接。硬连接的作用是允许一个文件拥有多个有效路径名，这样用户就可以建立硬连接到重要文件，以防止“误删”的功能。
具体来说，如果一个Inode有一个以上的连接，那么只删除一个连接并不影响Inode本身和其它的连接。只有当最后一个连接被删除后，文件的数据块及目录的连接才会被释放。也就是说，文件真正删除的条件是与之相关的所有硬连接文件均被删除。

个人理解，类似于智能指针，只有引用计数减为0了，文件才真正被删除。

软连接

软链接文件类似于Windows的快捷方式，它实际上是一个特殊的文本文件，保存了其代表的文件的绝对路径。

个人理解，软连接只是对原文件的绝对路径的记录，相当于一个引用，原文件一旦被删除，软连接就直接失效了。

内存管理

伙伴系统

每个内存管理器都使用了一种基于堆的分配策略。在这种方法中，大块内存（称为 堆）用来为用户定义的目的提供内存。当用户需要一块内存时，就请求给自己分配一定大小的内存。堆管理器会查看可用内存的情况（使用特定算法）并返回一块内存。搜索过程中使用的一些算法有 first-fit（在堆中搜索到的第一个满足请求的内存块）和 best-fit（使用堆中满足请求的最合适的内存块）。当用户使用完内存后，就将内存返回给堆。

这种基于堆的分配策略的根本问题是碎片（fragmentation）。当内存块被分配后，它们会以不同的顺序在不同的时间返回。这样会在堆中留下一些洞，需要花一些时间才能有效地管理空闲内存。这种算法通常具有较高的内存使用效率（分配需要的内存），但是却需要花费更多时间来对堆进行管理。

于是引入伙伴系统。

伙伴系统的概念

伙伴系统是一种经典的内存管理方法。Linux伙伴系统的引入为内核提供了一种用于分配一组连续的页而建立的一种高效的分配策略，并有效的解决了外碎片问题。

Linux中的内存管理的“页”大小为4KB。把所有的空闲页分组为11个块链表，每个块链表分别包含大小为1，2，4，8，16，32，64，128，256，512和1024个连续页框的页块。最大可以申请1024个连续页，对应4MB大小的连续内存。每个页块的第一个页的物理地址是该块大小的整数倍。

结构如图所示：第i个块链表中，num表示大小为(2^i)页块的数目，address表示大小为(2^i)页块的首地址。

伙伴系统的内存分配及释放

当向内核请求分配(2^(i-1)，2^i]数目的页块时，按照2^i页块请求处理。如果对应的块链表中没有空闲页块，则在更大的页块链表中找。当分配的页块中有多余的页时，伙伴系统根据多余的页框大小插入到对应的空闲页块链表中。

当释放单页的内存时，内核将其置于CPU高速缓存中，对很可能出现在cache的页，则放到“快表”的列表中。在此过程中，内核先判断CPU高速缓存中的页数是否超过一定“阈值”，如果是，则将一批内存页还给伙伴系统，然后将该页添加到CPU高速缓存中。

当释放多页的块时，内核首先计算出该内存块的伙伴的地址。内核将满足以下条件的2个块称为伙伴：(1)两个块具有相同的大小，记作b。(2)它们的物理地址是连续的。(3)第一块的第一个页的物理地址是2*(2^b)的倍数。如果找到了该内存块的伙伴，确保该伙伴的所有页都是空闲的，以便进行合并。内存继续检查合并后页块的“伙伴”并检查是否可以合并，依次类推。

slab缓存

linux kernel 通过把整个物理内存划分成以一个个page（4kB）进行管理，管理器就是伙伴系统，它的最小分配单元就是page。但是对于小于page的内存分配，如果直接分配一个page，是一个很大的浪费。linux kernel 通过slab来实现对小于page大小的内存分配。slab把page按2的m次幂进行划分一个个字节块，当kmalloc申请内存时，通过slab管理器返回需要满足申请大小的最小空闲内存块。

上图是slab 结构的高层组织结构。在最高层是 cache_chain，这是一个 slab 缓存的链接列表。这对于 best-fit 算法非常有用，可以用来查找最适合所需要的分配大小的缓存（遍历列表）。cache_chain 的每个元素都是一个 kmem_cache结构（称为一个 cache）。它定义了一个要管理的给定大小的对象池。

每个缓存都包含了一个 slabs 列表，这是一段连续的内存块（通常都是页面）。存在 3 种 slab：
slabs_full：完全分配的 slab
slabs_partial：部分分配的 slab
slabs_empty：空 slab，或者没有对象被分配

slab 列表中的每个 slab 都是一个连续的内存块（一个或多个连续页），它们被划分成一个个对象。这些对象是从特定缓存中进行分配和释放的基本元素。注意 slab 是 slab 分配器进行操作的最小分配单位，因此如果需要对 slab 进行扩展，这也就是所扩展的最小值。通常来说，每个 slab 被分配为多个对象。
由于对象是从 slab 中进行分配和释放的，因此单个 slab 可以在 slab 列表之间进行移动。例如，当一个 slab 中的所有对象都被使用完时，就从 slabs_partial 列表中移动到 slabs_full 列表中。当一个 slab 完全被分配并且有对象被释放后，就从 slabs_full 列表中移动到 slabs_partial 列表中。当所有对象都被释放之后，就从 slabs_partial 列表移动到 slabs_empty 列表中。

虚拟地址-线性地址-物理地址

分段机制

在 Intel 平台下，逻辑地址(logical address)是 selector:offset 这种形式，selector 是 CS 寄存器的值，offset 是 EIP 寄存器的值。如果用 selector 去 GDT( 全局描述符表 ) 里拿到 segment base address(段基址) 然后加上 offset(段内偏移)，这就得到了 linear address。我们把这个过程称作段式内存管理。
（段描述符->）段基址 + 段内偏移 = 线性地址

linux中的段

由于绝大部分硬件不支持分段，只支持分页，所以linux为了更好的移植性，把段基址设为0，段的界限设为4GB，这样虚拟地址就和线性地址相同了。IA32F规定为代码段和数据段创建不同的段。这就意味着linux必须创建4个段描述符－－特权0和3的代码段和数据段。

分页机制

线性地址是一个32位无符号整数，可以用来表示高达4GB的地址。如果启用了分页机制，那么线性地址可以再经过变换以产生一个物理地址。当采用4KB分页大小的时候，线性地址的高10位为页目录项在页目录表中的编号，中间十位为页表中的页号，其低12位则为偏移地址。

1、分页单元中，页目录是唯一的，它的地址放在CPU的cr3寄存器中，是进行地址转换的开始点。万里长征就从此长始了。
2、每一个活动的进程，因为都有其独立的对应的虚似内存（页目录也是唯一的），那么它也对应了一个独立的页目录地址。——运行一个进程，需要将它的页目录地址放到cr3寄存器中，将别个的保存下来。
3、每一个32位的线性地址被划分为三部份，页目录索引(10位)：页表索引(10位)：偏移(12位)依据以下步骤进行转换：
1、从cr3中取出进程的页目录地址（操作系统负责在调度进程的时候，把这个地址装入对应寄存器）；
2、根据线性地址前十位，在数组中，找到对应的页目录索引项，因为引入了二级管理模式，页目录中的项，不再是页的地址，而是一个页表的地址。（又引入了一个数组），页的地址被放到页表中去了。
3、根据线性地址的中间十位，在页表（也是数组）中找到页的起始地址；4、将页的起始地址与线性地址中最后12位相加，得到最终我们想要的物理地址。