关于linux进程编程的一些笔记整理
关于linux进程编程的一些笔记整理。
涉及到通过系统调用对进程的创建控制以及进程间通讯的实现。
Linux 系统调用 --fork 函数详解
功能描述：
建立一个子进程。所建立的子进程 PID 和 PPID 不同于其父进程，同时资源使用被设置为 0 ，文件锁和挂起的信号不被继承。
Linux 内部， fork 的执行使用 copy-on-write 页面，所以耗费的资源只是拷贝父进程页表，建立唯一子进程 task 结构体的时间和内存。
用法：
#include
#include
pid_t fork(void);
返回说明：
成功执行时，在父进程的线程执行中返回子进程 PID ，在子进程的线程执行中返回 0 。失败时在父进程的语境中返回 -1 ， errno 被设为以下的某个值
EAGAIN ：
1. 不能为拷贝父进程的页表和子进程的 task 结构分配足够的内存
2. 不可能再建立新的子进程，因为调用者已达到 RLIMIT_NPROC 的资源限制，除了调用进程有 CAP_SYS_ADMIN 或 CAP_SYS_RESOURCE 的权限
ENOMEM ：内核内存不足，无法分配必须的数据结构
例子：
#include
#include
#include
int main(void)
{
pid_t pid;
printf("Before fork .../n");
switch(pid = fork()) {
case -1:
printf("Fock call fail/n");
exit(1);
case 0:
printf("The pid of child is: %d/n", getpid());
printf("The pid of child's parent is: %d/n", getppid());
printf("Child exiting.../n");
exit(0);
default:
printf("The pid of parent is: %d/n", getpid());
printf("the pid of parent's child is: %d/n", pid);
}
printf("After fork, program exiting.../n");
exit(0);
}
unix/linux 管道通信相关函数
程序中有如下 Linux 系统调用 : (1) fork( ): 创建一个进程。 返回值： -1 ：创建子进程失败。 0 ：子进程得到的返回值。 >0 ：父进程得到的返回值，表示子进程号（ pid) 。 创建子进程后，父、子进程执行同一个程序段，但有不同的数据区，子进程继 承父进程的资源。 (2) exit( ): 撤消进程。 若父进程因 wait() 而睡眠，则唤醒父进程。 exit() 撤消子进程时必须通知父 进程。 (3) pipe(fd): 创建一个管道 . fd[0] 为管道的读端 ,fd[1] 为管道的写端。管道用来实现父进程与其子孙进程 之间的通信 , 以 FIFO 方式传送消息。 (4) wait(): 父进程等待子进程撤销。 若子进程尚未撤销 , 父进程睡眠等待 , 子进程撤销时 , 将其唤醒，若子进程已撤 销，父进程不睡眠等待。 ) (5) Sleep(n): 进程睡眠等待 n 秒，交出处理机控制权。
/*----------------------------------------------------*/
下面我引一篇在网上找到的文章，对理清概念很有帮助，并且里面提到几个很重要点的。
我将用红色注明。
/*----------------------------------------------------*/
进程管理相关的系统调用
本文介绍了 Linux 下的进程概念，并着重讲解了与 Linux 进程管理相关的 4 个重要系统调用 getpid,fork,exit 和 _exit ，辅助一些例程说明了它们的特点和使用方法。
关于进程的一些必要知识
先看一下进程在大学课本里的标准定义：“进程是可并发执行的程序在一个数据集合上的运行过程。”这个定义非常严谨，而且难懂，如果你没有一下子理解这句话，就不妨看看笔者自己的并不严谨的解释。我们大家都知道，硬盘上的一个可执行文件经常被称作程序，在 Linux 系统中，当一个程序开始执行后，在开始执行到执行完毕退出这段时间里，它在内存中的部分就被称作一个进程。
当然，这个解释并不完善，但好处是容易理解，在以下的文章中，我们将会对进程作一些更全面的认识。
Linux 进程简介
Linux 是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单 CPU 计算机实际上在一个时间片断内只能执行一条指令，那么 Linux 是如何实现多进程同时执行的呢？原来 Linux 使用了一种称为“进程调度（ process scheduling ）”的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停， Linux 就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。
在 Linux 中，每个进程在创建时都会被分配一个数据结构，称为进程控制块（ Process Control Block ，简称 PCB ）。 PCB 中包含了很多重要的信息，供系统调度和进程本身执行使用，其中最重要的莫过于进程 ID （ process ID ）了，进程 ID 也被称作进程标识符，是一个非负的整数，在 Linux 操作系统中唯一地标志一个进程，在我们最常使用的 I386 架构（即 PC 使用的架构）上，一个非负的整数的变化范围是 0-32767 ，这也是我们所有可能取到的进程 ID 。其实从进程 ID 的名字就可以看出，它就是进程的身份证号码，每个人的身份证号码都不会相同，每个进程的进程 ID 也不会相同。
一个或多个进程可以合起来构成一个进程组（ process group ），一个或多个进程组可以合起来构成一个会话（ session ）。这样我们就有了对进程进行批量操作的能力，比如通过向某个进程组发送信号来实现向该组中的每个进程发送信号。
最后，让我们通过 ps 命令亲眼看一看自己的系统中目前有多少进程在运行：
$ps -aux （以下是在我的计算机上的运行结果，你的结果很可能与这不同。） USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND root 1 0.1 0.4 1412 520 ? S May15 0:04 init [3] root 2 0.0 0.0 0 0 ? SW May15 0:00 [keventd] root 3 0.0 0.0 0 0 ? SW May15 0:00 [kapm-idled] root 4 0.0 0.0 0 0 ? SWN May15 0:00 [ksoftirqd_CPU0] root 5 0.0 0.0 0 0 ? SW May15 0:00 [kswapd] root 6 0.0 0.0 0 0 ? SW May15 0:00 [kreclaimd] root 7 0.0 0.0 0 0 ? SW May15 0:00 [bdflush] root 8 0.0 0.0 0 0 ? SW May15 0:00 [kupdated] root 9 0.0 0.0 0 0 ? SW< May15 0:00 [mdrecoveryd] root 13 0.0 0.0 0 0 ? SW May15 0:00 [kjournald] root 132 0.0 0.0 0 0 ? SW May15 0:00 [kjournald] root 673 0.0 0.4 1472 592 ? S May15 0:00 syslogd -m 0 root 678 0.0 0.8 2084 1116 ? S May15 0:00 klogd -2 rpc 698 0.0 0.4 1552 588 ? S May15 0:00 portmap rpcuser 726 0.0 0.6 1596 764 ? S May15 0:00 rpc.statd root 839 0.0 0.4 1396 524 ? S May15 0:00 /usr/sbin/apmd -p root 908 0.0 0.7 2264 1000 ? S May15 0:00 xinetd -stayalive root 948 0.0 1.5 5296 1984 ? S May15 0:00 sendmail: accepti root 967 0.0 0.3 1440 484 ? S May15 0:00 gpm -t ps/2 -m /d wnn 987 0.0 2.7 4732 3440 ? S May15 0:00 /usr/bin/cserver root 1005 0.0 0.5 1584 660 ? S May15 0:00 crond wnn 1025 0.0 1.9 3720 2488 ? S May15 0:00 /usr/bin/tserver xfs 1079 0.0 2.5 4592 3216 ? S May15 0:00 xfs -droppriv -da daemon 1115 0.0 0.4 1444 568 ? S May15 0:00 /usr/sbin/atd root 1130 0.0 0.3 1384 448 tty1 S May15 0:00 /sbin/mingetty tt root 1131 0.0 0.3 1384 448 tty2 S May15 0:00 /sbin/mingetty tt root 1132 0.0 0.3 1384 448 tty3 S May15 0:00 /sbin/mingetty tt root 1133 0.0 0.3 1384 448 tty4 S May15 0:00 /sbin/mingetty tt root 1134 0.0 0.3 1384 448 tty5 S May15 0:00 /sbin/mingetty tt root 1135 0.0 0.3 1384 448 tty6 S May15 0:00 /sbin/mingetty tt root 8769 0.0 0.6 1744 812 ? S 00:08 0:00 in.telnetd: 192.1 root 8770 0.0 0.9 2336 1184 pts/0 S 00:08 0:00 login -- lei lei 8771 0.1 0.9 2432 1264 pts/0 S 00:08 0:00 -bash lei 8809 0.0 0.6 2764 808 pts/0 R 00:09 0:00 ps -aux
以上除标题外，每一行都代表一个进程。在各列中， PID 一列代表了各进程的进程 ID ， COMMAND 一列代表了进程的名称或在 Shell 中调用的命令行，对其他列的具体含义，我就不再作解释，有兴趣的读者可以去参考相关书籍。
getpid
在 2.4.4 版内核中， getpid 是第 20 号系统调用，其在 Linux 函数库中的原型是：
#include /* 提供类型 pid_t 的定义 */
#include /* 提供函数的定义 */
pid_t getpid(void);
getpid 的作用很简单，就是返回当前进程的进程 ID ，请大家看以下的例子：
/* getpid_test.c *
/#include
main()
{
printf("The current process ID is %d/n",getpid());
}
细心的读者可能注意到了，这个程序的定义里并没有包含头文件 sys/types.h ，这是因为我们在程序中没有用到 pid_t 类型， pid_t 类型即为进程 ID 的类型。事实上，在 i386 架构上（就是我们一般 PC 计算机的架构）， pid_t 类型是和 int 类型完全兼容的，我们可以用处理整形数的方法去处理 pid_t 类型的数据，比如，用 "%d" 把它打印出来。
编译并运行程序 getpid_test.c ：
$gcc getpid_test.c -o getpid_test
$./getpid_test
The current process ID is 1980 （你自己的运行结果很可能与这个数字不一样，这是很正常的。）
再运行一遍：
$./getpid_test
The current process ID is 1981
正如我们所见，尽管是同一个应用程序，每一次运行的时候，所分配的进程标识符都不相同。
fork
在 2.4.4 版内核中， fork 是第 2 号系统调用，其在 Linux 函数库中的原型是：
#include /* 提供类型 pid_t 的定义 */
#include /* 提供函数的定义 */
pid_t fork(void);
只看 fork 的名字，可能难得有几个人可以猜到它是做什么用的。 fork 系统调用的作用是复制一个进程。当一个进程调用它，完成后就出现两个几乎一模一样的进程，我们也由此得到了一个新进程。据说 fork 的名字就是来源于这个与叉子的形状颇有几分相似的工作流程。
在 Linux 中，创造新进程的方法只有一个，就是我们正在介绍的 fork 。其他一些库函数，如 system() ，看起来似乎它们也能创建新的进程，如果能看一下它们的源码就会明白，它们实际上也在内部调用了 fork 。包括我们在命令行下运行应用程序，新的进程也是由 shell 调用 fork 制造出来的。 fork 有一些很有意思的特征，下面就让我们通过一个小程序来对它有更多的了解。
/* fork_test.c */
#include
#inlcude
main()
{
pid_t pid; /* 此时仅有一个进程 */
pid=fork(); /* 此时已经有两个进程在同时运行 */
if(pid<0)
printf("error in fork!");
else if(pid==0)
printf("I am the child process, my process ID is %d/n",getpid());
else printf("I am the parent process, my process ID is %d/n",getpid());
}
编译并运行：
$gcc fork_test.c -o fork_test
$./fork_test
I am the parent process, my process ID is 1991
I am the child process, my process ID is 1992
看这个程序的时候，头脑中必须首先了解一个概念：在语句 pid=fork() 之前，只有一个进程在执行这段代码，但在这条语句之后，就变成两个进程在执行了，这两个进程的代码部分完全相同，将要执行的下一条语句都是 if(pid==0) ……。
两个进程中，原先就存在的那个被称作“父进程”，新出现的那个被称作“子进程”。父子进程的区别除了进程标志符（ process ID ）不同外，变量 pid 的值也不相同， pid 存放的是 fork 的返回值。 fork 调用的一个奇妙之处就是它仅仅被调用一次，却能够返回两次，它可能有三种不同的返回值：
在父进程中， fork 返回新创建子进程的进程 ID ；
在子进程中， fork 返回 0 ；
如果出现错误， fork 返回一个负值；
fork 出错可能有两种原因：
（ 1 ）当前的进程数已经达到了系统规定的上限，这时 errno 的值被设置为 EAGAIN 。
（ 2 ）系统内存不足，这时 errno 的值被设置为 ENOMEM 。（关于 errno 的意义，请参考本系列的第一篇文章。）
fork 系统调用出错的可能性很小，而且如果出错，一般都为第一种错误。如果出现第二种错误，说明系统已经没有可分配的内存，正处于崩溃的边缘，这种情况对 Linux 来说是很罕见的。
说到这里，聪明的读者可能已经完全看懂剩下的代码了，如果 pid 小于 0 ，说明出现了错误； pid==0 ，就说明 fork 返回了 0 ，也就说明当前进程是子进程，就去执行 printf("I am the child!") ，否则（ else ），当前进程就是父进程，执行 printf("I am the parent!") 。完美主义者会觉得这很冗余，因为两个进程里都各有一条它们永远执行不到的语句。不必过于为此耿耿于怀，毕竟很多年以前， UNIX 的鼻祖们在当时内存小得无法想象的计算机上就是这样写程序的，以我们如今的“海量”内存，完全可以把这几个字节的顾虑抛到九霄云外。
说到这里，可能有些读者还有疑问：如果 fork 后子进程和父进程几乎完全一样，而系统中产生新进程唯一的方法就是 fork ，那岂不是系统中所有的进程都要一模一样吗？那我们要执行新的应用程序时候怎么办呢？从对 Linux 系统的经验中，我们知道这种问题并不存在。至于采用了什么方法，我们把这个问题留到后面具体讨论。
exit
在 2.4.4 版内核中， exit 是第 1 号调用，其在 Linux 函数库中的原型是：
#include
void exit(int status);
不像 fork 那么难理解，从 exit 的名字就能看出，这个系统调用是用来终止一个进程的。无论在程序中的什么位置，只要执行到 exit 系统调用，进程就会停止剩下的所有操作，清除包括 PCB 在内的各种数据结构，并终止本进程的运行。请看下面的程序：
/* exit_test1.c */
#include
main()
{
printf("this process will exit!/n");
exit(0);
printf("never be displayed!/n");
}
编译后运行：
$gcc exit_test1.c -o exit_test1$./exit_test1this process will exit!
我们可以看到，程序并没有打印后面的 "never be displayed!/n" ，因为在此之前，在执行到 exit(0) 时，进程就已经终止了。
exit 系统调用带有一个整数类型的参数 status ，我们可以利用这个参数传递进程结束时的状态，比如说，该进程是正常结束的，还是出现某种意外而结束的，一般来说， 0 表示没有意外的正常结束；其他的数值表示出现了错误，进程非正常结束。我们在实际编程时，可以用 wait 系统调用接收子进程的返回值，从而针对不同的情况进行不同的处理。关于 wait 的详细情况，我们将在以后的篇幅中进行介绍。
exit 和 _exit
作为系统调用而言， _exit 和 exit 是一对孪生兄弟，它们究竟相似到什么程度，我们可以从 Linux 的源码中找到答案：
#define __NR__exit __NR_exit /* 摘自文件 include/asm-i386/unistd.h 第 334 行 */
“ __NR_ ”是在 Linux 的源码中为每个系统调用加上的前缀，请注意第一个 exit 前有 2 条下划线，第二个 exit 前只有 1 条下划线。
这时随便一个懂得 C 语言并且头脑清醒的人都会说， _exit 和 exit 没有任何区别，但我们还要讲一下这两者之间的区别，这种区别主要体现在它们在函数库中的定义。 _exit 在 Linux 函数库中的原型是：
#include
void _exit(int status);
和 exit 比较一下， exit() 函数定义在 stdlib.h 中，而 _exit() 定义在 unistd.h 中，从名字上看， stdlib.h 似乎比 unistd.h 高级一点，那么，它们之间到底有什么区别呢？让我们先来看流程图，通过下图，我们会对这两个系统调用的执行过程产生一个较为直观的认识。
_exit() 函数的作用最为简单：直接使进程停止运行，清除其使用的内存空间，并销毁其在内核中的各种数据结构； exit() 函数则在这些基础上作了一些包装，在执行退出之前加了若干道工序，也是因为这个原因，有些人认为 exit 已经不能算是纯粹的系统调用。
exit() 函数与 _exit() 函数最大的区别就在于 exit() 函数在调用 exit 系统调用之前要检查文件的打开情况，把文件缓冲区中的内容写回文件，就是图中的“清理 I/O 缓冲”一项。
在 Linux 的标准函数库中，有一套称作“高级 I/O ”的函数，我们熟知的 printf() 、 fopen() 、 fread() 、 fwrite() 都在此列，它们也被称作“缓冲 I/O （ buffered I/O ）”，其特征是对应每一个打开的文件，在内存中都有一片缓冲区，每次读文件时，会多读出若干条记录，这样下次读文件时就可以直接从内存的缓冲区中读取，每次写文件的时候，也仅仅是写入内存中的缓冲区，等满足了一定的条件（达到一定数量，或遇到特定字符，如换行符 /n 和文件结束符 EOF ），再将缓冲区中的内容一次性写入文件，这样就大大增加了文件读写的速度，但也为我们编程带来了一点点麻烦。如果有一些数据，我们认为已经写入了文件，实际上因为没有满足特定的条件，它们还只是保存在缓冲区内，这时我们用 _exit() 函数直接将进程关闭，缓冲区中的数据就会丢失，反之，如果想保证数据的完整性，就一定要使用 exit() 函数。
请看以下例程：
/* exit2.c */
#include
main()
{
printf("output begin/n");
printf("content in buffer");
exit(0);
}
编译并运行：
$gcc exit2.c -o exit2
$./exit2
output begin
content in buffer
/* _exit1.c *
/#include
main()
{
printf("output begin/n");
printf("content in buffer");
_exit(0);
}
编译并运行：
$gcc _exit1.c -o _exit1$./_exit1output begin
在 Linux 中，标准输入和标准输出都是作为文件处理的，虽然是一类特殊的文件，但从程序员的角度来看，它们和硬盘上存储数据的普通文件并没有任何区别。与所有其他文件一样，它们在打开后也有自己的缓冲区。
请读者结合前面的叙述，思考一下为什么这两个程序会得出不同的结果。相信如果您理解了我前面所讲的内容，会很容易的得出结论。
1.7 背景
在前面的文章中，我们已经了解了父进程和子进程的概念，并已经掌握了系统调用 exit 的用法，但可能很少有人意识到，在一个进程调用了 exit 之后，该进程并非马上就消失掉，而是留下一个称为僵尸进程（ Zombie ）的数据结构。在 Linux 进程的 5 种状态中，僵尸进程是非常特殊的一种，它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置，记载该进程的退出状态等信息供其他进程收集，除此之外，僵尸进程不再占有任何内存空间。从这点来看，僵尸进程虽然有一个很酷的名字，但它的影响力远远抵不上那些真正的僵尸兄弟，真正的僵尸总能令人感到恐怖，而僵尸进程却除了留下一些供人凭吊的信息，对系统毫无作用。
也许读者们还对这个新概念比较好奇，那就让我们来看一眼 Linux 里的僵尸进程究竟长什么样子。
当一个进程已退出，但其父进程还没有调用系统调用 wait （稍后介绍）对其进行收集之前的这段时间里，它会一直保持僵尸状态，利用这个特点，我们来写一个简单的小程序：
|
/* zombie.c */ #include |
sleep 的作用是让进程休眠指定的秒数，在这 60 秒内，子进程已经退出，而父进程正忙着睡觉，不可能对它进行收集，这样，我们就能保持子进程 60 秒的僵尸状态。
编译这个程序：
|
$ cc zombie.c -o zombie
|
后台运行程序，以使我们能够执行下一条命令
|
$ ./zombie & [1] 1577
|
列一下系统内的进程
|
$ ps -ax ... ... 1177 pts/0 S 0:00 -bash 1577 pts/0 S 0:00 ./zombie 1578 pts/0 Z 0:00 [zombie |
看到中间的 "Z" 了吗？那就是僵尸进程的标志，它表示 1578 号进程现在就是一个僵尸进程。
我们已经学习了系统调用 exit ，它的作用是使进程退出，但也仅仅限于将一个正常的进程变成一个僵尸进程，并不能将其完全销毁。僵尸进程虽然对其他进程几乎没有什么影响，不占用 CPU 时间，消耗的内存也几乎可以忽略不计，但有它在那里呆着，还是让人觉得心里很不舒服。而且 Linux 系统中进程数目是有限制的，在一些特殊的情况下，如果存在太多的僵尸进程，也会影响到新进程的产生。那么，我们该如何来消灭这些僵尸进程呢？
先来了解一下僵尸进程的来由，我们知道， Linux 和 UNIX 总有着剪不断理还乱的亲缘关系，僵尸进程的概念也是从 UNIX 上继承来的，而 UNIX 的先驱们设计这个东西并非是因为闲来无聊想烦烦其他的程序员。僵尸进程中保存着很多对程序员和系统管理员非常重要的信息，首先，这个进程是怎么死亡的？是正常退出呢，还是出现了错误，还是被其它进程强迫退出的？其次，这个进程占用的总系统 CPU 时间和总用户 CPU 时间分别是多少？发生页错误的数目和收到信号的数目。这些信息都被存储在僵尸进程中，试想如果没有僵尸进程，进程一退出，所有与之相关的信息都立刻归于无形，而此时程序员或系统管理员需要用到，就只好干瞪眼了。
那么，我们如何收集这些信息，并终结这些僵尸进程呢？就要靠我们下面要讲到的 waitpid 调用和 wait 调用。这两者的作用都是收集僵尸进程留下的信息，同时使这个进程彻底消失。下面就对这两个调用分别作详细介绍。
1.8 wait
1.8.1 简介
wait 的函数原型是：
|
#include |
进程一旦调用了 wait ，就立即阻塞自己，由 wait 自动分析是否当前进程的某个子进程已经退出，如果让它找到了这样一个已经变成僵尸的子进程， wait 就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程， wait 就会一直阻塞在这里，直到有一个出现为止。
参数 status 用来保存被收集进程退出时的一些状态，它是一个指向 int 类型的指针。但如果我们对这个子进程是如何死掉的毫不在意，只想把这个僵尸进程消灭掉，（事实上绝大多数情况下，我们都会这样想），我们就可以设定这个参数为 NULL ，就象下面这样：
|
pid = wait(NULL);
|
如果成功， wait 会返回被收集的子进程的进程 ID ，如果调用进程没有子进程，调用就会失败，此时 wait 返回 -1 ，同时 errno 被置为 ECHILD 。
1.8.2 实战
下面就让我们用一个例子来实战应用一下 wait 调用，程序中用到了系统调用 fork ，如果你对此不大熟悉或已经忘记了，请参考上一篇文章《进程管理相关的系统调用（一）》。
|
/* wait1.c */ #include |
编译并运行 :
|
$ cc wait1.c -o wait1 $ ./wait1 This is child process with pid of 1508 I catched a child process with pid of 1508
|
可以明显注意到，在第 2 行结果打印出来前有 10 秒钟的等待时间，这就是我们设定的让子进程睡眠的时间，只有子进程从睡眠中苏醒过来，它才能正常退出，也就才能被父进程捕捉到。其实这里我们不管设定子进程睡眠的时间有多长，父进程都会一直等待下去，读者如果有兴趣的话，可以试着自己修改一下这个数值，看看会出现怎样的结果。
1.8.3 参数 status
如果参数 status 的值不是 NULL ， wait 就会把子进程退出时的状态取出并存入其中，这是一个整数值（ int ），指出了子进程是正常退出还是被非正常结束的（一个进程也可以被其他进程用信号结束，我们将在以后的文章中介绍），以及正常结束时的返回值，或被哪一个信号结束的等信息。由于这些信息被存放在一个整数的不同二进制位中，所以用常规的方法读取会非常麻烦，人们就设计了一套专门的宏（ macro ）来完成这项工作，下面我们来学习一下其中最常用的两个：
1 ， WIFEXITED(status) 这个宏用来指出子进程是否为正常退出的，如果是，它会返回一个非零值。
（请注意，虽然名字一样，这里的参数 status 并不同于 wait 唯一的参数 -- 指向整数的指针 status ，而是那个指针所指向的整数，切记不要搞混了。）
2 ， WEXITSTATUS(status) 当 WIFEXITED 返回非零值时，我们可以用这个宏来提取子进程的返回值，如果子进程调用 exit(5) 退出， WEXITSTATUS(status) 就会返回 5 ；如果子进程调用 exit(7) ， WEXITSTATUS(status) 就会返回 7 。请注意，如果进程不是正常退出的，也就是说， WIFEXITED 返回 0 ，这个值就毫无意义。
下面通过例子来实战一下我们刚刚学到的内容：
|
/* wait2.c */ #include |
编译并运行 :
|
$ cc wait2.c -o wait2 $ ./wait2 This is child process with pid of 1538. the child process 1538 exit normally. the return code is 3.
|
父进程准确捕捉到了子进程的返回值 3 ，并把它打印了出来。
当然，处理进程退出状态的宏并不止这两个，但它们当中的绝大部分在平时的编程中很少用到，就也不在这里浪费篇幅介绍了，有兴趣的读者可以自己参阅 Linux man pages 去了解它们的用法。
1.8.4 进程同步
有时候，父进程要求子进程的运算结果进行下一步的运算，或者子进程的功能是为父进程提供了下一步执行的先决条件（如：子进程建立文件，而父进程写入数据），此时父进程就必须在某一个位置停下来，等待子进程运行结束，而如果父进程不等待而直接执行下去的话，可以想见，会出现极大的混乱。这种情况称为进程之间的同步，更准确地说，这是进程同步的一种特例。进程同步就是要协调好 2 个以上的进程，使之以安排好地次序依次执行。解决进程同步问题有更通用的方法，我们将在以后介绍，但对于我们假设的这种情况，则完全可以用 wait 系统调用简单的予以解决。请看下面这段程序：
|
#include |
这段程序只是个例子，不能真正拿来执行，但它却说明了一些问题，首先，当 fork 调用成功后，父子进程各做各的事情，但当父进程的工作告一段落，需要用到子进程的结果时，它就停下来调用 wait ，一直等到子进程运行结束，然后利用子进程的结果继续执行，这样就圆满地解决了我们提出的进程同步问题。
1.9 waitpid
1.9.1 简介
waitpid 系统调用在 Linux 函数库中的原型是：
|
#include |
从本质上讲，系统调用 waitpid 和 wait 的作用是完全相同的，但 waitpid 多出了两个可由用户控制的参数 pid 和 options ，从而为我们编程提供了另一种更灵活的方式。下面我们就来详细介绍一下这两个参数：
pid
从参数的名字 pid 和类型 pid_t 中就可以看出，这里需要的是一个进程 ID 。但当 pid 取不同的值时，在这里有不同的意义。
1. pid>0 时，只等待进程 ID 等于 pid 的子进程，不管其它已经有多少子进程运行结束退出了，只要指定的子进程还没有结束， waitpid 就会一直等下去。
2. pid=-1 时，等待任何一个子进程退出，没有任何限制，此时 waitpid 和 wait 的作用一模一样。
3. pid=0 时，等待同一个进程组中的任何子进程，如果子进程已经加入了别的进程组， waitpid 不会对它做任何理睬。
4. pid<-1 时，等待一个指定进程组中的任何子进程，这个进程组的 ID 等于 pid 的绝对值。
options
options 提供了一些额外的选项来控制 waitpid ，目前在 Linux 中只支持 WNOHANG 和 WUNTRACED 两个选项，这是两个常数，可以用 "|" 运算符把它们连接起来使用，比如：
|
ret=waitpid(-1,NULL,WNOHANG | WUNTRACED);
|
如果我们不想使用它们，也可以把 options 设为 0 ，如：
|
ret=waitpid(-1,NULL,0);
|
如果使用了 WNOHANG 参数调用 waitpid ，即使没有子进程退出，它也会立即返回，不会像 wait 那样永远等下去。
而 WUNTRACED 参数，由于涉及到一些跟踪调试方面的知识，加之极少用到，这里就不多费笔墨了，有兴趣的读者可以自行查阅相关材料。
看到这里，聪明的读者可能已经看出端倪了 --wait 不就是经过包装的 waitpid 吗？没错，察看 < 内核源码目录 >/include/unistd.h 文件 349-352 行就会发现以下程序段：
|
static inline pid_t wait(int * wait_stat) { return waitpid(-1,wait_stat,0); }
|
1.9.2 返回值和错误
waitpid 的返回值比 wait 稍微复杂一些，一共有 3 种情况：
1. 当正常返回的时候， waitpid 返回收集到的子进程的进程 ID ；
2. 如果设置了选项 WNOHANG ，而调用中 waitpid 发现没有已退出的子进程可收集，则返回 0 ；
3. 如果调用中出错，则返回 -1 ，这时 errno 会被设置成相应的值以指示错误所在；
当 pid 所指示的子进程不存在，或此进程存在，但不是调用进程的子进程， waitpid 就会出错返回，这时 errno 被设置为 ECHILD ；
|
/* waitpid.c */ #include |
编译并运行：
|
$ cc waitpid.c -o waitpid $ ./waitpid No child exited No child exited No child exited No child exited No child exited No child exited No child exited No child exited No child exited No child exited successfully get child 1526
|
父进程经过 10 次失败的尝试之后，终于收集到了退出的子进程。
因为这只是一个例子程序，不便写得太复杂，所以我们就让父进程和子进程分别睡眠了 10 秒钟和 1 秒钟，代表它们分别作了 10 秒钟和 1 秒钟的工作。父子进程都有工作要做，父进程利用工作的简短间歇察看子进程的是否退出，如退出就收集它。
1.10 exec
也许有不少读者从本系列文章一推出就开始读，一直到这里还有一个很大的疑惑：既然所有新进程都是由 fork 产生的，而且由 fork 产生的子进程和父进程几乎完全一样，那岂不是意味着系统中所有的进程都应该一模一样了吗？而且，就我们的常识来说，当我们执行一个程序的时候，新产生的进程的内容应就是程序的内容才对。是我们理解错了吗？显然不是，要解决这些疑惑，就必须提到我们下面要介绍的 exec 系统调用。
1.10.1 简介
说是 exec 系统调用，实际上在 Linux 中，并不存在一个 exec() 的函数形式， exec 指的是一组函数，一共有 6 个，分别是：
|
#include |
其中只有 execve 是真正意义上的系统调用，其它都是在此基础上经过包装的库函数。
exec 函数族的作用是根据指定的文件名找到可执行文件，并用它来取代调用进程的内容，换句话说，就是在调用进程内部执行一个可执行文件。这里的可执行文件既可以是二进制文件，也可以是任何 Linux 下可执行的脚本文件。
与一般情况不同， exec 函数族的函数执行成功后不会返回，因为调用进程的实体，包括代码段，数据段和堆栈等都已经被新的内容取代，只留下进程 ID 等一些表面上的信息仍保持原样，颇有些神似 " 三十六计 " 中的 " 金蝉脱壳 " 。看上去还是旧的躯壳，却已经注入了新的灵魂。只有调用失败了，它们才会返回一个 -1 ，从原程序的调用点接着往下执行。
现在我们应该明白了， Linux 下是如何执行新程序的，每当有进程认为自己不能为系统和拥护做出任何贡献了，他就可以发挥最后一点余热，调用任何一个 exec ，让自己以新的面貌重生；或者，更普遍的情况是，如果一个进程想执行另一个程序，它就可以 fork 出一个新进程，然后调用任何一个 exec ，这样看起来就好像通过执行应用程序而产生了一个新进程一样。
事实上第二种情况被应用得如此普遍，以至于 Linux 专门为其作了优化，我们已经知道， fork 会将调用进程的所有内容原封不动的拷贝到新产生的子进程中去，这些拷贝的动作很消耗时间，而如果 fork 完之后我们马上就调用 exec ，这些辛辛苦苦拷贝来的东西又会被立刻抹掉，这看起来非常不划算，于是人们设计了一种 " 写时拷贝（ copy-on-write ） " 技术，使得 fork 结束后并不立刻复制父进程的内容，而是到了真正实用的时候才复制，这样如果下一条语句是 exec ，它就不会白白作无用功了，也就提高了效率。
1.10.2 稍稍深入
上面 6 条函数看起来似乎很复杂，但实际上无论是作用还是用法都非常相似，只有很微小的差别。在学习它们之前，先来了解一下我们习以为常的 main 函数。
下面这个 main 函数的形式可能有些出乎我们的意料：
|
int main(int argc, char *argv[], char *envp[])
|
它可能与绝大多数教科书上描述的都不一样，但实际上，这才是 main 函数真正完整的形式。
参数 argc 指出了运行该程序时命令行参数的个数，数组 argv 存放了所有的命令行参数，数组 envp 存放了所有的环境变量。环境变量指的是一组值，从用户登录后就一直存在，很多应用程序需要依靠它来确定系统的一些细节，我们最常见的环境变量是 PATH ，它指出了应到哪里去搜索应用程序，如 /bin ； HOME 也是比较常见的环境变量，它指出了我们在系统中的个人目录。环境变量一般以字符串 "XXX=xxx" 的形式存在， XXX 表示变量名， xxx 表示变量的值。
值得一提的是， argv 数组和 envp 数组存放的都是指向字符串的指针，这两个数组都以一个 NULL 元素表示数组的结尾。
我们可以通过以下这个程序来观看传到 argc 、 argv 和 envp 里的都是什么东西：
|
/* main.c */ int main(int argc, char *argv[], char *envp[]) { printf("/n### ARGC ###/n%d/n", argc); printf("/n### ARGV ###/n"); while(*argv) printf("%s/n", *(argv++)); printf("/n### ENVP ###/n"); while(*envp) printf("%s/n", *(envp++)); return 0; }
|
编译它：
|
$ cc main.c -o main
|
运行时，我们故意加几个没有任何作用的命令行参数：
|
$ ./main -xx 000 ### ARGC ### 3 ### ARGV ### ./main -xx 000 ### ENVP ### PWD=/home/lei REMOTEHOST=dt.laser.com HOSTNAME=localhost.localdomain QTDIR=/usr/lib/qt-2.3.1 LESSOPEN=|/usr/bin/lesspipe.sh %s KDEDIR=/usr USER=lei LS_COLORS= MACHTYPE=i386-redhat-linux-gnu MAIL=/var/spool/mail/lei INPUTRC=/etc/inputrc LANG=en_US LOGNAME=lei SHLVL=1 SHELL=/bin/bash HOSTTYPE=i386 OSTYPE=linux-gnu HISTSIZE=1000 TERM=ansi HOME=/home/lei PATH=/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/home/lei/bin _=./main
|
我们看到，程序将 "./main" 作为第 1 个命令行参数，所以我们一共有 3 个命令行参数。这可能与大家平时习惯的说法有些不同，小心不要搞错了。
现在回过头来看一下 exec 函数族，先把注意力集中在 execve 上：
|
int execve(const char *path, char *const argv[], char *const envp[]);
|
对比一下 main 函数的完整形式，看出问题了吗？是的，这两个函数里的 argv 和 envp 是完全一一对应的关系。 execve 第 1 个参数 path 是被执行应用程序的完整路径，第 2 个参数 argv 就是传给被执行应用程序的命令行参数，第 3 个参数 envp 是传给被执行应用程序的环境变量。
留心看一下这 6 个函数还可以发现，前 3 个函数都是以 execl 开头的，后 3 个都是以 execv 开头的，它们的区别在于， execv 开头的函数是以 "char *argv[]" 这样的形式传递命令行参数，而 execl 开头的函数采用了我们更容易习惯的方式，把参数一个一个列出来，然后以一个 NULL 表示结束。这里的 NULL 的作用和 argv 数组里的 NULL 作用是一样的。
在全部 6 个函数中，只有 execle 和 execve 使用了 char *envp[] 传递环境变量，其它的 4 个函数都没有这个参数，这并不意味着它们不传递环境变量，这 4 个函数将把默认的环境变量不做任何修改地传给被执行的应用程序。而 execle 和 execve 会用指定的环境变量去替代默认的那些。
还有 2 个以 p 结尾的函数 execlp 和 execvp ，咋看起来，它们和 execl 与 execv 的差别很小，事实也确是如此，除 execlp 和 execvp 之外的 4 个函数都要求，它们的第 1 个参数 path 必须是一个完整的路径，如 "/bin/ls" ；而 execlp 和 execvp 的第 1 个参数 file 可以简单到仅仅是一个文件名，如 "ls" ，这两个函数可以自动到环境变量 PATH 制定的目录里去寻找。
1.10.3 实战
知识介绍得差不多了，接下来我们看看实际的应用：
|
/* exec.c */ #include |
程序里调用了 2 个 Linux 常用的系统命令， echo 和 env 。 echo 会把后面跟的命令行参数原封不动的打印出来， env 用来列出所有环境变量。
由于各个子进程执行的顺序无法控制，所以有可能出现一个比较混乱的输出 -- 各子进程打印的结果交杂在一起，而不是严格按照程序中列出的次序。
编译并运行：
|
$ cc exec.c -o exec $ ./exec executed by execl PATH=/tmp USER=lei STATUS=testing executed by execlp excuted by execv executed by execvp PATH=/tmp USER=lei STATUS=testing
|
果然不出所料， execle 输出的结果跑到了 execlp 前面。
大家在平时的编程中，如果用到了 exec 函数族，一定记得要加错误判断语句。因为与其他系统调用比起来， exec 很容易受伤，被执行文件的位置，权限等很多因素都能导致该调用的失败。最常见的错误是：
1. 找不到文件或路径，此时 errno 被设置为 ENOENT ；
2. 数组 argv 和 envp 忘记用 NULL 结束，此时 errno 被设置为 EFAULT ；
3. 没有对要执行文件的运行权限，此时 errno 被设置为 EACCES 。
1.11 进程的一生
下面就让我用一些形象的比喻，来对进程短暂的一生作一个小小的总结：
随着一句 fork ，一个新进程呱呱落地，但它这时只是老进程的一个克隆。
然后随着 exec ，新进程脱胎换骨，离家独立，开始了为人民服务的职业生涯。
人有生老病死，进程也一样，它可以是自然死亡，即运行到 main 函数的最后一个 "}" ，从容地离我们而去；也可以是自杀，自杀有 2 种方式，一种是调用 exit 函数，一种是在 main 函数内使用 return ，无论哪一种方式，它都可以留下遗书，放在返回值里保留下来；它还甚至能可被谋杀，被其它进程通过另外一些方式结束他的生命。
进程死掉以后，会留下一具僵尸， wait 和 waitpid 充当了殓尸工，把僵尸推去火化，使其最终归于无形。
这就是进程完整的一生。
1.12 小结
本文重点介绍了系统调用 wait 、 waitpid 和 exec 函数族，对与进程管理相关的系统调用的介绍就在这里告一段落，在下一篇文章，也是与进程管理相关的系统调用的最后一篇文章中，我们会通过两个很酷的实际例子，来重温一下最近学过的知识。
1.13 Shell
对 Linux 不是太陌生的读者都应该对 Shell 有一定的了解，就是这个程序在我们登陆后自动执行，打印出一个 $ 符号，然后等待我们输入命令。 Linux 下最常用的 Shell 应用程序是 Bash ，绝大部分 Linux 发行版默认安装的都是它。下面我们也来亲手编写一个 Shell 程序，这个 Shell 远远不如 Bash 复杂，但也能满足我们一般的使用，下面，我们就开始。
首先，给这个 Shell 取一个名字，不妨就叫做 Mini Shell 。
Linux 系统的命令分为内部命令和外部命令两种，内部命令由 Shell 程序实现，如 cd 、 echo 等， Linux 的内部命令数量有限，而且绝大部分都很少用到。而每一个 Linux 外部命令都是一个单独的应用程序，我们非常熟悉的 ls 、 cp 等绝大多数命令都是外部命令，这些命令都以可执行文件的形式存在，绝大部分放在目录 /bin 和 /sbin 中。这样一来，我们编程的难度就可以大大下降了，我们只需要实现很有限的内部命令，对于其它的输入，统统当作应用程序来执行即可。
为了简单明了起见， Mini Shell 只实现了 2 个内部命令： 1 、 cd 用于切换目录，和我们熟悉的命令 cd 类似，除了没有那么多的附加功能。 2 、 quit 用于退出 Mini Shell 。
下面是程序清单：
|
1: /* mshell.c */ 2: #include |
这个程序稍稍有点长，我们来对它作一下详细的解释：
函数 main ：
14 行：定义字符串 cmd ，用于接收用户输入的命令行。 15 行：定义指针数组 cmd_arg ，它的形式和作用都与我们熟悉的 char *argv[] 一样。
从以上 2 个定义可以看出 Mini Shell 对命令输入的 2 个限制：首先，用户输入的命令行必须在 255 个字符之内（除去字符串结束标志 '/0' ）；其次，命令行的参数个数不得超过 10 个（包括命令本身在内）。
18 行：进入一个 do-while 循环，这个循环是本程序的主体部分，基本思想是 " 等待输入命令 -- 处理已输入命令 -- 等待输入命令 " 。
22 行：打印输入提示信息。在 Mini Shell 中，你可以随意定自己喜欢的命令输入提示信息，本程序中使用了 "-=Mini Shell=-*| " ，是不是有点像一个 CS 高手？如果不喜欢，你可以用任意的字符替换它。
23 行：接收用户输入。
25-27 行： fgets 接受输入时，会将输入字符串时末尾的换行符（ "/n" ）一起接受，这是我们不需要的，所以要把它去掉。本程序中简单的用字符串结束标志 '/0' 覆盖了字符串 cmd 的最后一个字符来实现这个目的。
30 行：初始化指针数组 cmd_arg 。
32-42 行：对输入进行分析，将 cmd 中参数间的空格用 '/0' 填充，并把各参数的起始地址分别赋与 cmd_arg 数组。这样就把 cmd 分解成了 cmd_arg ，但分解后的各命令参数仍然使用着 cmd 的内存空间，所以在命令执行结束前不宜对 cmd 另外赋值。
45 行：如果还未分析到输入字符串的末尾（ i ），而分析出的参数已经达到或超过了 10 个（ j>=10 ），就认为输入的命令行超出了 10 个参数的限制，打印错误并重新接收命令。
51-52 行：内部命令 quit ：字符串 cmd_arg[0] 就是命令本身，如果命令是 quit ，则退出循环，也就等于退出该程序。
55-58 行：内部命令 cd ：调用函数 do_cd() 完成 cd 命令的动作。
61 行：对于其它的外部命令和应用程序，调用函数 execute_new() 执行。
函数 do_cd ：
68 行：仅仅考虑紧跟在命令后面的参数 argv[1] ，而不再考虑其它的参数。如果这个参数存在，就把它作为要转换的目录。
69 行：调用系统调用 chdir 切换当前目录，参见附录 1 。
70-82 行：对 chdir 可能出现的错误进行处理。
函数 execute_new ：
92 行：调用系统调用 fork 产生新的子进程。
93 行：如果返回负值，说明 fork 调用出现错误。
96 行：如果返回 0 ，说明当前进程是子进程。
97 行：调用 execvp 执行新的应用程序，并检测调用是否出错（返回负值）。这里使用 execvp 的原因是它可以自动在各默认目录里寻找目标应用程序的位置，而不必我们自己编程实现。
98-107 行：对 execvp 可能出现的错误进程处理。
108 行：如果 execvp 的执行出现错误，子进程在这里终止。表面上看起来，这个 exit 是接着 97 行的错误判断的下一行语句，而非 if 语句的一部分，似乎无论调用 execvp 成功与否都会接着执行 exit 。但事实上，如果 execvp 调用成功的话，这个进程将会被新的程序代码填充，因而根本不可能执行到这一行。反之，如果执行到了这一行，说明前面的 execvp 调用一定出现了错误。这样的效果和 exit 被包含在 if 语句中的效果是完全一样的。
109 行：如果 fork 返回其它值，说明当前进程是父进程。
110 行：调用系统调用 wait 。 wait 在这里有两个作用：
1. 使父进程在此暂停，等待子进程执行完毕。这样，就可以等子进程的所有信息全部输出完毕后才打印命令提示符，等待下一条命令的输入，从而避免了命令提示符和应用程序输出混杂在一起的现象。
2. 收集子进程退出后留下的僵尸进程。可能有读者一直对这个问题存有疑问 --" 我们编程生成的子进程由我们自己设计的父进程负责收集，但我们手动执行的这个父进程由谁收集呢？ " 现在大家应该明白了，我们从命令行执行的所有进程最后都是由 shell 收集的。
关于 Mini Shell 的编译和运行，这里就不再敷述了，有兴趣的读者可以自行动手实验，或者对这个程序进行改进，使之更接近甚至超过我们正使用的 Bash 。
1.14 daemon 进程
1.14.1 了解 daemon 进程
这又是一个有趣的概念， daemon 在英语中是 " 精灵 " 的意思，就像我们经常在迪斯尼动画里见到的那些，有些会飞，有些不会，经常围着动画片的主人公转来转去，啰里啰唆地提一些忠告，时不时倒霉地撞在柱子上，有时候还会想出一些小小的花招，把主人公从敌人手中救出来，正因如此， daemon 有时也被译作 " 守护神 " 。所以， daemon 进程在国内也有两种译法，有些人译作 " 精灵进程 " ，有些人译作 " 守护进程 " ，这两种称呼的出现频率都很高。
与真正的 daemon 相似， daemon 进程也习惯于把自己隐藏在人们的视线之外，默默为系统做出贡献，有时人们也把它们称作 " 后台服务进程 " 。 daemon 进程的寿命很长，一般来说，从它们一被执行开始，直到整个系统关闭，它们才会退出。几乎所有的服务器程序，包括我们熟知的 Apache 和 wu -FTP ，都用 daemon 进程的形式实现。很多 Linux 下常见的命令如 inetd 和 ftpd ，末尾的字母 d 就是指 daemon 。
为什么一定要使用 daemon 进程呢？ Linux 中每一个系统与用户进行交流的界面称为终端（ terminal ），每一个从此终端开始运行的进程都会依附于这个终端，这个终端就称为这些进程的控制终端（ Controlling terminal ），当控制终端被关闭时，相应的进程都会被自动关闭。关于这点，读者可以用 X-Window 中的 XTerm 试验一下，（每一个 XTerm 就是一个打开的终端，）我们可以通过键入命令启动应用程序，比如：
$netscape
然后我们关闭 XTerm 窗口，刚刚启动的 netscape 窗口也会随之一同突然蒸发。但是 daemon 进程却能够突破这种限制，即使对应的终端关闭，它也能在系统中长久地存在下去，如果我们想让某个进程长命百岁，不因为用户或终端或其他的变化而受到影响，就必须把这个进程变成一个 daemon 进程。
1.14.2 daemon 进程的编程规则
如果想把自己的进程变成 daemon 进程，我们必须严格按照以下步骤进行：
1. 调用 fork 产生一个子进程，同时父进程退出。我们所有后续工作都在子进程中完成。这样做我们可以：
1. 如果我们是从命令行执行的该程序，这可以造成程序执行完毕的假象， shell 会回去等待下一条命令；
2. 刚刚通过 fork 产生的新进程一定不会是一个进程组的组长，这为第 2 步的执行提供了前提保障。
这样做还会出现一种很有趣的现象：由于父进程已经先于子进程退出，会造成子进程没有父进程，变成一个孤儿进程（ orphan ）。每当系统发现一个孤儿进程，就会自动由 1 号进程收养它，这样，原先的子进程就会变成 1 号进程的子进程。
2. 调用 setsid 系统调用。这是整个过程中最重要的一步。 setsid 的介绍见附录 2 ，它的作用是创建一个新的会话（ session ），并自任该会话的组长（ session leader ）。如果调用进程是一个进程组的组长，调用就会失败，但这已经在第 1 步得到了保证。调用 setsid 有 3 个作用：
1. 让进程摆脱原会话的控制；
2. 让进程摆脱原进程组的控制；
3. 让进程摆脱原控制终端的控制；
总之，就是让调用进程完全独立出来，脱离所有其他进程的控制。
3. 把当前工作目录切换到根目录。如果我们是在一个临时加载的文件系统上执行这个进程的，比如： /mnt/floppy/ ，该进程的当前工作目录就会是 /mnt/floppy/ 。在整个进程运行期间该文件系统都无法被卸下（ umount ），而无论我们是否在使用这个文件系统，这会给我们带来很多不便。解决的方法是使用 chdir 系统调用把当前工作目录变为根目录，应该不会有人想把根目录卸下吧。关于 chdir 的用法，参见附录 1 。 当然，在这一步里，如果有特殊的需要，我们也可以把当前工作目录换成其他的路径，比如 /tmp 。
4. 将文件权限掩码设为 0 。这需要调用系统调用 umask ，参见附录 3 。每个进程都会从父进程那里继承一个文件权限掩码，当创建新文件时，这个掩码被用于设定文件的默认访问权限，屏蔽掉某些权限，如一般用户的写权限。当另一个进程用 exec 调用我们编写的 daemon 程序时，由于我们不知道那个进程的文件权限掩码是什么，这样在我们创建新文件时，就会带来一些麻烦。所以，我们应该重新设置文件权限掩码，我们可以设成任何我们想要的值，但一般情况下，大家都把它设为 0 ，这样，它就不会屏蔽用户的任何操作。 如果你的应用程序根本就不涉及创建新文件或是文件访问权限的设定，你也完全可以把文件权限掩码一脚踢开，跳过这一步。
5. 关闭所有不需要的文件。同文件权限掩码一样，我们的新进程会从父进程那里继承一些已经打开了的文件。这些被打开的文件可能永远不被我们的 daemon 进程读或写，但它们一样消耗系统资源，而且可能导致所在的文件系统无法卸下。需要指出的是，文件描述符为 0 、 1 和 2 的三个文件（文件描述符的概念将在下一章介绍），也就是我们常说的输入、输出和报错这三个文件也需要被关闭。很可能不少读者会对此感到奇怪，难道我们不需要输入输出吗？但事实是，在上面的第 2 步后，我们的 daemon 进程已经与所属的控制终端失去了联系，我们从终端输入的字符不可能达到 daemon 进程， daemon 进程用常规的方法（如 printf ）输出的字符也不可能在我们的终端上显示出来。所以这三个文件已经失去了存在的价值，也应该被关闭。
下面，就然我们亲眼看一个 daemon 进程的诞生：
1.14.3 一个 daemon 程序
|
/* daemon.c */ #include |
编译和运行的任务就交给读者们自己完成。 daemon 进程不像其他进程一样有很抢眼的运行结果，基本上它只是毫不声张地做自己的事。你不可能看到任何东西，但可以用 "ps -ajx" 命令观察一下你的 daemon 进程的状态和一些参数。
1.15 附录
1.15.1 系统调用 chdir
|
#include |
chdir 的作用是改变当前工作目录。进程的当前工作目录一般是应用程序启动时的目录，一旦进程开始运行后，当前工作目录就会保持不变，除非调用 chdir 。 chdir 只有 1 个字符串参数，就是要转去的路径。例如：
|
chdir("/");
|
进程的当前路径就会变为根目录。
1.15.2 系统调用 setsid
|
#include |
一个会话（ session ）开始于用户登陆，终止于用户退出，在此期间该用户运行的所有进程都属于这个会话，除非进程调用 setsid 系统调用。
系统调用 setsid 不带任何参数，调用之后，调用进程就会成立一个新的会话，并自任该会话的组长。
1.15.3 系统调用 umask
|
#include |
系统调用 umask 可以设定一个文件权限掩码，用户可以用它来屏蔽某些权限，以防止误操作导致给予某些用户过高的权限。