Unix编程常见问题解答(FAQ / Frequently Asked Questions)(v1.37)(中文版 v0.1.0)

关于这篇“常见问题解答”
************************

这篇“常见问题解答” 由Patrick Horgan自一九九六年五月开始起草；因其历经
数月未复更新，我从而接手编辑。我已经将其内容稍做重新安排并加入一些新的内
容；我仍然认为它仍处于“有待开发建设”中。

请将批评，建议，增补，更正或其它意见发给维护者，电子邮件地址：
[email protected]

这篇文档的超文本版(英文)在WEB上可以获得。主站点设在
“ http://www.erlenstar.demon.co.uk/unix/faq_toc.html”。
美国镜像站点设在“ http://www.whitefang.com/unix/faq_toc.html”。

这篇文档可以用FTP的方式自主机rtfm.mit.edu和其众多镜像站点的news.answers 归
档中找到(译者注：URL是 ftp://rtfm.mit.edu/pub/faqs/unix-faq/programmer/faq)。
它的官方归档名是“unix-faq/programmer/faq”。其他将网络新闻组*.answers归档的
服务器也会在目录“comp.unix.programmer”下存放这篇文档。

其他信息资源未于此一一列出。读者可在新闻组comp.unix.programmer每周定期发
布的[READ ME FIRST]中找到其他“常见问题”，书籍，原代码等资源的的连接。
关于管理新闻组的小问题等等也能在其中找到；而我只想在将这篇文档中特别讨
论问题和回答。

所有提供的资料已经经过维护者编辑，所有错误或疏忽是我的责任，跟提供者无
关。

这篇“常见问题解答”现在以Texinfo资源格式维护；我使用“makeinfo”程序将其
转换成供新闻组阅读的原始字符文件格式，并使用“texi2html”程序将其转换成
HTML格式。

版权所有：1997，1998， 1999， 2000 Andrew Gierth. 这篇文档允许通过新闻组或
电子邮件方式的分发，也允许在news.answers 归档的镜像FTP或WWW站点归档存
放，并保证提供所有维持该文档更新应付出的努力。(本许可能够以个人为单位取
消)未经维护者许可，不允许将该文档以其他任何方式发表，无论是书面，WWW，
光盘，或在其他任何媒体。

内容提供者名单，无先后次序：

Andrew Gierth     < [email protected]>
Patrick J. Horgan   withheld
Stephen Baynes     < [email protected]>
James Raynard     withheld
Michael F. Quigley withheld
Ken Pizzini       withheld
Thamer Al-Herbish   withheld
Nick Kew         < [email protected]>
Dan Abarbanel     withheld
Billy Chambless   < [email protected]>
Walter Briscoe     < [email protected]>
Jim Buchanan     < [email protected]>
Dave Plonka       < [email protected]>
Daniel Stenberg   withheld
Ralph Corderoy     < [email protected]>
Stuart Kemp       withheld
Sergei Chernev     < [email protected]>
Bjorn Reese       withheld
Joe Halpin       < [email protected]>
Aaron Crane       < [email protected]>
Geoff Clare       < [email protected]>


问题目录
********

(译者：这里我有意保留原文以便于查询)

1. Process Control 进程控制
1.1 Creating new processes: fork() 创建新进程：fork函数
  1.1.1 What does fork() do? fork函数干什么？
  1.1.2 What's the difference between fork() and vfork()? fork函数 与 vfork函数的区别在哪里？
  1.1.3 Why use _exit rather than exit in the child branch of a fork? 为何在一个fork的子进程分支中使用_exit函数而不使用exit函数？
1.2 Environment variables 环境变量
  1.2.1 How can I get/set an environment variable from a program? 我怎样在程序中获得/设置环境变量？
  1.2.2 How can I read the whole environment? 我怎样读取整个环境变量表？
1.3 How can I sleep for less than a second? 我怎样睡眠小于一秒？
1.4 How can I get a finer-grained version of alarm()? 我怎样得到一个更细分时间单位的alarm函数版本(译者注：希望alarm的时间小于一秒)？
1.5 How can a parent and child process communicate? 父子进程如何通信？
1.6 How do I get rid of zombie processes? 我怎样去除僵死进程？
  1.6.1 What is a zombie? 何为僵死进程？
  1.6.2 How do I prevent them from occuring? 我怎样避免它们的出现？
1.7 How do I get my program to act like a daemon? 我怎样使我的程序作为守护程序运行？
1.8 How can I look at process in the system like ps does? 我怎样象ps程序一样审视系统的进程？
1.9 Given a pid, how can I tell if it's a running program? 给定一个进程号(译者注：pid: process ID)，我怎样知道它是个正在运行的程序？
1.10 What's the return value of system/pclose/waitpid? system函数，pclose函数，waitpid函数 的返回值是什么？
1.11 How do I find out about a process' memory usage? 我怎样找出一个进程的存储器使用情况？
1.12 Why do processes never decrease in size? 为什么进程的大小不缩减？
1.13 How do I change the name of my program (as seen by `ps')? 我怎样改变我程序的名字(即“ps”看到的名字)？
1.14 How can I find a process' executable file? 我怎样找到进程的相应可执行文件？
  1.14.1 So where do I put my configuration files then? 那么，我把配置文件放在哪里呢？
1.15 Why doesn't my process get SIGHUP when its parent dies? 为何父进程死时，我的进程未得到SIGHUP信号？
1.16 How can I kill all descendents of a process? 我怎样杀死一个进程的所有派生进程？

2. General File handling (including pipes and sockets) 一般文件操作(包括管道和套接字)
2.1 How to manage multiple connections? 怎样管理多个连接？
  2.1.1 How do I use select()? 我怎样使用select()？
  2.1.2 How do I use poll()? 我怎样使用poll() ？
  2.1.3 Can I use SysV IPC at the same time as select or poll? 我是否可以将SysV 进程间通信 (译者注：IPC: Interprocess Communications) 与select或poll同
时使用？
2.2 How can I tell when the other end of a connection shuts down? 我怎么知道连接的另一端已关闭？
2.3 Best way to read directories? 读目录的最好方法？
2.4 How can I find out if someone else has a file open? 我怎么知道其他人已经打开一个文件？
2.5 How do I `lock' a file? 我怎样锁定一个文件？
2.6 How do I find out if a file has been updated by another process? 我怎么知道一个文件是否已被其他进程更新？
2.7 How does the `du' utility work? “du”工具程序是怎么工作的？
2.8 How do I find the size of a file? 我怎么知道一个文件的大小？
2.9 How do I expand `~' in a filename like the shell does? 我怎样象shell程序一样将一个文件名中含有的“~”展开？
2.10 What can I do with named pipes (FIFOs)? 我能用有名管道(FIFOs)(译者注：FIFO: First In First Oout)干什么？
  2.10.1 What is a named pipe? 什么是有名管道？
  2.10.2 How do I create a named pipe? 我怎样创建一个有名管道？
  2.10.3 How do I use a named pipe? 我怎样使用一个有名管道？
  2.10.4 Can I use a named pipe across NFS? 我能基于网络文件系统(译者注：NFS：Network File System)使用有名管道吗？
  2.10.5 Can multiple processes write to the pipe simultaneously? 多个进程能否同时向这个管道写执行写操作？
  2.10.6 Using named pipes in applications 在应用程序中使用有名管道。

3. Terminal I/O 终端输入/输出(I/O：input/output)
3.1 How can I make my program not echo input? 我怎样使我的程序不回射输入？
3.2 How can I read single characters from the terminal? 我怎样从终端读取单个字符？
3.3 How can I check and see if a key was pressed? 我怎样检查是否一个键被摁下？
3.4 How can I move the cursor around the screen? 我怎样将光标在屏幕里移动？
3.5 What are pttys? pttys(pttys：Pseudo-teletypes)是什么？
3.6 How to handle a serial port or modem? 怎样控制一个串行口和调制解调器(译者注：modem: modulate-demodulate)
  3.6.1 Serial device names and types 串行设备和类型
  3.6.2 Setting up termios flags 设置termios的标志位
    3.6.2.1 c_iflag
    3.6.2.2 c_oflag
    3.6.2.3 c_cflag
    3.6.2.4 c_lflag
    3.6.2.5 c_cc

4. System Information 系统信息
4.1 How can I tell how much memory my system has? 我怎样知道我的系统有多少存储器容量？
4.2 How do I check a user's password? 我怎样检查一个用户的口令？
  4.2.1 How do I get a user's password? 我怎样得到一个用户的口令？
  4.2.2 How do I get shadow passwords by uid? 我怎样通过用户号(译者注：uid: User ID)得到阴影口令文件中的口令？
  4.2.3 How do I verify a user's password? 我怎样核对一个用户的口令？

5. Miscellaneous programming 编程杂技
5.1 How do I compare strings using wildcards? 我怎样使用通配字符比较字符串？
  5.1.1 How do I compare strings using filename patterns? 我怎样使用文件名通配模式比较字符串？
  5.1.2 How do I compare strings using regular expressions? 我怎样使用正则表达式比较字符串？
5.2 What's the best way to send mail from a program? 什么是在程序中发送电子邮件的最好方法？
  5.2.1 The simple method: /bin/mail 简单方法：/bin/mail
  5.2.2 Invoking the MTA directly: /usr/lib/sendmail 直接启动邮件传输代理(译者注：MTA: mail transfer agent)：/usr/bin/sendmail
    5.2.2.1 Supplying the envelope explicitly 显式提供收件人信息
    5.2.2.2 Allowing sendmail to deduce the recipients 允许sendmail程序根据邮件内容分析出收件人

6. Use of tools 工具的使用
6.1 How can I debug the children after a fork? 我怎样调试fork函数产生的子进程？
6.2 How to build library from other libraries? 怎样通过其他库文件建立新的库文件？
6.3 How to create shared libraries / dlls? 怎样创建动态连接库/dlls？
6.4 Can I replace objects in a shared library? 我能更改一个动态连接库里的目标吗？
6.5 How can I generate a stack dump from within a running program? 我能在一个运行着的程序中生成堆栈映象吗？


1. 进程控制
***********

1.1 创建新进程：fork函数
========================

1.1.1 fork函数干什么？
----------------------

  #include <sys/types.h>
  #include <unistd.h>

  pid_t fork(void);

‘fork()’函数用于从已存在进程中创建一个新进程。新进程称为子进程，而原进程称为
父进程。你可以通过检查‘fork()’函数的返回值知道哪个是父进程，哪个是子进程。父
进程得到的返回值是子进程的进程号，而子进程则返回0。以下这个范例程序说明它的基本
功能：[ DISCUZ_CODE_150 ]当然，有人可以用‘if() ... else ...’语句取代‘switch()’语句，但是上面的形式是
一个有用的惯用方法。

知道子进程自父进程继承什么或未继承什么将有助于我们。下面这个名单会因为
不同Unix的实现而发生变化，所以或许准确性有了水份。请注意子进程得到的是
这些东西的 *拷贝*，不是它们本身。

由子进程自父进程继承到：

  * 进程的资格(真实(real)/有效(effective)/已保存(saved) 用户号(UIDs)和组号(GIDs))

  * 环境(environment)

  * 堆栈

  * 内存

  * 打开文件的描述符(注意对应的文件的位置由父子进程共享，这会引起含糊情况)

  * 执行时关闭(close-on-exec) 标志 (译者注：close-on-exec标志可通过fnctl()对文件描
  述符设置，POSIX.1要求所有目录流都必须在exec函数调用时关闭。更详细说明，
  参见<<UNIX环境高级编程>> W. R. Stevens, 1993, 尤晋元等译(以下简称<<高级编
  程>>), 3.13节和8.9节)

  * 信号(signal)控制设定

  * nice值 (译者注：nice值由nice函数设定，该值表示进程的优先级，数值越小，优
  先级越高)

  * 进程调度类别(scheduler class) (译者注：进程调度类别指进程在系统中被调度时所
  属的类别，不同类别有不同优先级，根据进程调度类别和nice值，进程调度程序可计
  算出每个进程的全局优先级(Global process prority)，优先级高的进程优先执行)

  * 进程组号

  * 对话期ID(Session ID) (译者注：译文取自<<高级编程>>，指：进程所属的对话期
  (session)ID， 一个对话期包括一个或多个进程组， 更详细说明参见<<高级编程>>
  9.5节)

  * 当前工作目录

  * 根目录 (译者注：根目录不一定是“/”，它可由chroot函数改变)

  * 文件方式创建屏蔽字(file mode creation mask (umask)) (译者注：译文取自<<高级编
  程>>，指：创建新文件的缺省屏蔽字)

  * 资源限制

  * 控制终端

子进程所独有：

  * 进程号

  * 不同的父进程号(译者注：即子进程的父进程号与父进程的父进程号不同，父进
  程号可由getppid函数得到)

  * 自己的文件描述符和目录流的拷贝(译者注：目录流由opendir函数创建，因其为
  顺序读取，顾称“目录流”)

  * 子进程不继承父进程的进程，正文(text)，数据和其它锁定内存(memory locks)
  (译者注：锁定内存指被锁定的虚拟内存页，锁定后，不允许内核将其在必要时
  换出(page out)，详细说明参见<<The GNU C Library Reference Manual>> 2.2版，
  1999, 3.4.2节)

  * 在tms结构中的系统时间(译者注：tms结构可由times函数获得，它保存四个数据
  用于记录进程使用中央处理器(CPU：Central Processing Unit)的时间，包括：用户时
  间，系统时间，用户各子进程合计时间，系统各子进程合计时间)

  * 资源使用(resource utilizations)设定为0

  * 阻塞信号集初始化为空集(译者注：原文此处不明确，译文根据fork函数手册页
  稍做修改)

  * 不继承由timer_create函数创建的计时器

  * 不继承异步输入和输出

1.1.2 fork函数 与 vfork函数的区别在哪里里？
-------------------------------------------

有些系统有一个系统调用‘vfork()’，它最初被设计成‘fork()’的较少额外支出
(lower-overhead)版本。因为‘fork()’包括拷贝整个进程的地址空间，所以非常
“昂贵”，这个‘vfork()’函数因此被引入。(在3.0BSD中)(译者注：BSD：
Berkeley Software Distribution)

*但是*，自从‘vfork()’被引入，‘fork()’的实现方法得到了很大改善，最值得
注意的是“写操作时拷贝”(copy-on-write)的引入，它是通过允许父子进程可访问
相同物理内存从而伪装(fake)了对进程地址空间的真实拷贝，直到有进程改变内
存中数据时才拷贝。这个提高很大程度上抹杀了需要‘vfork()’的理由；事实上，
一大部份系统完全丧失了‘vfork()’的原始功能。但为了兼容，它们仍然提供
‘vfork()’函数调用，但它只是简单地调用‘fork()’，而不试图模拟所有‘vfork()’
的语义(semantics， 译文取自<<高级编程>>，指定义的内容和做法)。

结论是，试图使用任何‘fork()’和‘vfork()’的不同点是*很*不明智的。事实上，
可能使用‘vfork()’根本就是不明智的，除非你确切知道你想*干什么*。

两者的基本区别在于当使用‘vfork()’创建新进程时，父进程将被暂时阻塞，而
子进程则可以借用父进程的地址空间。这个奇特状态将持续直到子进程要么退
出，要么调用‘execve()’，至此父进程才继续执行。

这意味着一个由‘vfork()’创建的子进程必须小心以免出乎意料地改变父进程的
变量。特别的，子进程必须不从包含‘vfork()’调用的函数返回，而且必须不调
用‘exit()’(如果它需要退出，它需要使用‘_exit()’；事实上，对于使用正常
‘fork()’创建的子进程这也是正确的)(译者注：参见1.1.3)

1.1.3 为何在一个fork的子进程分支中使用_exit函数而不使用exit函数？
-----------------------------------------------------------------

‘exit()’与‘_exit()’有不少区别在使用‘fork()’，特别是‘vfork()’时变得很
突出。

‘exit()’与‘_exit()’的基本区别在于前一个调用实施与调用库里用户状态结构
(user-mode constructs)有关的清除工作(clean-up)，而且调用用户自定义的清除程序
(译者注：自定义清除程序由atexit函数定义，可定义多次，并以倒序执行)，相对
应，后一个函数只为进程实施内核清除工作。

在由‘fork()’创建的子进程分支里，正常情况下使用‘exit()’是不正确的，这是
因为使用它会导致标准输入输出(译者注：stdio: Standard Input Output)的缓冲区被
清空两次，而且临时文件被出乎意料的删除(译者注：临时文件由tmpfile函数创建
在系统临时目录下，文件名由系统随机生成)。在C++程序中情况会更糟，因为静
态目标(static objects)的析构函数(destructors)可以被错误地执行。(还有一些特殊情
况，比如守护程序，它们的*父进程*需要调用‘_exit()’而不是子进程；适用于绝
大多数情况的基本规则是，‘exit()’在每一次进入‘main’函数后只调用一次。)

在由‘vfork()’创建的子进程分支里，‘exit()’的使用将更加危险，因为它将影响
*父*进程的状态。

1.2 环境变量
============

1.2.1 如何从程序中获得/设置环境变量？
--------------------------------------
获得一个环境变量可以通过调用‘getenv()’函数完成。

  #include <stdlib.h>

  char *getenv(const char *name);

设置一个环境变量可以通过调用‘putenv()’函数完成。

  #include <stdlib.h>

  int putenv(char *string);

变量string应该遵守"name=value"的格式。已经传递给putenv函数的字符串*不*能够被
释放或变成无效，因为一个指向它的指针将由‘putenv()’保存。这意味着它必须是
在静态数据区中或是从堆(heap)分配的。如果这个环境变量被另一个‘putenv()’的
调用重新定义或删除，上述字符串可以被释放。

/* 译者增加：

因为putenv()有这样的局限，在使用中经常会导致一些错
误，GNU libc 中还包括了两个BSD风格的函数:

#include <stdlib.h>
int setenv(const char *name, const char *value, int replace);
void unsetenv(const char *name);

setenv()/unsetenv()函数可以完成所有putenv()能做的事。setenv() 可以不受指针
限制地向环境变量中添加新值，但传入参数不能为空（NULL）。当replace为0时，如
果环境变量中已经有了name项，函数什么也不做（保留原项），否则原项被覆盖。
unsetenv()是用来把name项从环境变量中删除。注意：这两个函数只存在在BSD和GNU
库中，其他如SunOS系统中不包括它们，因此将会带来一些兼容问题。我们可以用
getenv()/putenv()来实现：

int setenv(const char *name, const char *value, int replace)
{
  char *envstr;

  if (name == NULL || value == NULL)
    return 1;
  if (getenv(name) !=NULL)
  {
    envstr = (char *) malloc(strlen(name) + strlen(value) + 2);
    sprintf (envstr, "%s=%s", name, value);
    if (putenv(envstr));
      return 1;
  }
  return 0;
}
*/

记住环境变量是被继承的；每一个进程有一个不同的环境变量表拷贝（译者注：
从core文件中我们可以看出这一点）。结果是，你不能从一个其他进程改变当前
进程的环境变量，比如shell进程。

假设你想得到环境变量‘TERM’的值，你需要使用下面的程序：

  char *envvar;

  envvar=getenv("TERM");

  printf("The value for the environment variable TERM is ");
  if(envvar)
  {
      printf("%s ",envvar);
  }
  else
  {
      printf("not set. ");
  }

现在假设你想创建一个新的环境变量，变量名为‘MYVAR’，值为‘MYVAL’。
以下是你将怎样做：

  static char envbuf[256];

  sprintf(envbuf,"MYVAR=%s","MYVAL");

  if(putenv(envbuf))
  {
      printf("Sorry, putenv() couldn't find the memory for %s ",envbuf);
      /* Might exit() or something here if you can't live without it */
  }

1.2.2 我怎样读取整个环境变量表？
--------------------------------

如果你不知道确切你想要的环境变量的名字，那么‘getenv()’函数不是很有用。
在这种情况下，你必须更深入了解环境变量表的存储方式。

全局变量，‘char **envrion’，包含指向环境字符串指针数组的指针，每一个字
符串的形式为‘“NAME=value”’(译者注：和putenv()中的“string”的格式相同)。
这个数组以一个‘空’(NULL)指针标记结束。这里是一个打印当前环境变量列表
的小程序(类似‘printenv’)。

  #include <stdio.h>

  extern char **environ;

  int main()
  {
      char **ep = environ;
      char *p;
      while ((p = *ep++))
        printf("%s ", p);
      return 0;
  }

一般情况下，‘envrion’变量作为可选的第三个参数传递给‘main()’；就是说，
上面的程序可以写成：

  #include <stdio.h>

  int main(int argc, char **argv, char **envp)
  {
      char *p;
      while ((p = *envp++))
        printf("%s ", p);
      return 0;
  }

虽然这种方法被广泛的操纵系统所支持(译者注：包括DOS)，这种方法事实上并
没有被POSIX(译者注：POSIX: Portable Operating System Interace)标准所定义。(一
般的，它也比较没用)

1.3 我怎样睡眠小于一秒？
========================

在所有Unix中都有的‘sleep()’函数只允许以秒计算的时间间隔。如果你想要更
细化，那么你需要寻找替换方法：

  * 许多系统有一个‘usleep()’函数

  * 你可以使用‘select()’或‘poll()’，并设置成无文件描述符并试验；一个普
  遍技巧是基于其中一个函数写一个‘usleep()’函数。(参见comp.unix.questions
  FAQ 的一些例子)

  * 如果你的系统有itimers(很多是有的)(译者注：setitimer和getitimer是两个操作
  itimers的函数，使用“man setitimer”确认你的系统支持)，你可以用它们自己撺一
  个‘usleep()’。(参见BSD源程序的‘usleep()’以便知道怎样做)

  * 如果你有POSIX实时(realtime)支持，那会有一个‘nanosleep()’函数。

众观以上方法，‘select()’可能是移植性最好的(直截了当说，它经常比
‘usleep()’或基于itimer的方法更有效)。但是，在睡眠中捕获信号的做法会有
所不同；基于不同应用，这可以成为或不成为一个问题。

无论你选择哪条路，意识到你将受到系统计时器分辨率的限制是很重要的(一
些系统允许设置非常短的时间间隔，而其他的系统有一个分辨率，比如说10毫
秒，而且总是将所有设置时间取整到那个值)。而且，关于‘sleep()’，你设置
的延迟只是最小值(译者注：实际延迟的最小值)；经过这段时间的延迟，会有
一个中间时间间隔直到你的进程重新被调度到。

1.4 我怎样得到一个更细分时间单位的alarm函数版本？
==================================================

当今Unix系统倾向于使用‘setitimer()’函数实现闹钟，它比简单的‘alarm()’函
数具有更高的分辨率和更多的选择项。一个使用者一般需要首先假设‘alarm()’
和‘setitimer(ITIMER_REAL)’可能是相同的底层计时器，而且假设同时使用两
种方法会造成混乱。

Itimers可被用于实现一次性或重复信号；而且一般有3种不同的计时器可以用：

`ITIMER_REAL'
    计数真实(挂钟)时间，然后发送‘SIGALRM’信号

`ITIMER_VIRTUAL'
    计数进程虚拟(用户中央处理器)时间，然后发送‘SIGVTALRM’信号

`ITIMER_PROF'
  计数用户和系统中央处理器时间，然后发送‘SIGPROF’信号；它供解释器
  用来进行梗概处理(profiling)

然而itimers不是许多标准的一部份，尽管它自从4.2BSD就被提供。POSIX实时标
准的扩充定义了类似但不同的函数。

1.5 父子进程如何通信？
======================

一对父子进程可以通过正常的进程间通信的办法(管道，套接字，消息队列，共
享内存)进行通信，但也可以通过利用它们作为父子进程的相互关系而具有的一
些特殊方法。

一个最显然的方法是父进程可以得到子进程的退出状态。

因为子进程从它的父进程继承文件描述符，所以父进程可以打开一个管道的两端，
然后fork，然后父进程关闭管道这一端，子进程关闭管道另一端。这正是你从你的
进程调用‘popen()’函数运行另一个程序所发生的情况，也就是说你可以向
‘popen()’返回的文件描述符进行写操作而子进程将其当作自己的标准输入，或
者你可以读取这个文件描述符来看子进程向标准输出写了什么。(‘popen()’函数
的mode参数定义你的意图(译者注：mode=“r”为读，mode=“w”为写)；如果你
想读写都做，那么你可以并不困难地用管道自己做到)

而且，子进程继承由父进程用mmap函数映射的匿名共享内存段(或者通过映射特
殊文件‘/dev/zero’)；这些共享内存段不能从无关的进程访问。

1.6 我怎样去除僵死进程？
========================

1.6.1 何为僵死进程？
--------------------

当一个程序创建的子进程比父进程提前结束，内核仍然保存一些它的信息以便父
进程会需要它 - 比如，父进程可能需要检查子进程的退出状态。为了得到这些信
息，父进程调用‘wait()’；当这个调用发生，内核可以丢弃这些信息。

在子进程终止后到父进程调用‘wait()’前的时间里，子进程被称为‘僵死进程’
(‘zombie’)。(如果你用‘ps’，这个子进程会有一个‘Z’出现在它的状态区
里指出这点。)即使它没有在执行，它仍然占据进程表里一个位置。(它不消耗其
它资源，但是有些工具程序会显示错误的数字，比如中央处理器的使用；这是
因为为节约空间进程表的某些部份与会计数据(accounting info)是共用(overlaid)的。)

这并不好，因为进程表对于进程数有固定的上限，系统会用光它们。即使系统没
有用光 ，每一个用户可以同时执行的进程数有限制，它总是小于系统的限制。
顺便说一下，这也正是你需要总是 检查‘fork()’是否失败的一个原因。

如果父进程未调用wait函数而终止，子进程将被‘init’进程收管，它将控制子进
程退出后必须的清除工作。(‘init’是一个特殊的系统程序，进程号为1 - 它实际
上是系统启动后运行的第一个程序)，

1.6.2 我怎样避免它们的出现？
----------------------------

你需要却认父进程为每个子进程的终止调用‘wait()’(或者‘waitpid()’，
‘wait3()’，等等)； 或者，在某些系统上，你可以指令系统你对子进程的退出状
态没有兴趣。(译者注：在SysV系统上，可以调用signal函数，设置SIGCLD信号为
SIG_IGN，系统将不产生僵死进程， 详细说明参见<<高级编程>>10.7节)

另一种方法是*两次*‘fork()’，而且使紧跟的子进程直接退出，这样造成孙子进
程变成孤儿进程(orphaned)，从而init进程将负责清除它。欲获得做这个的程序，参
看范例章节的函数‘fork2()’。

为了忽略子进程状态，你需要做下面的步骤(查询你的系统手册页以知道这是否正
常工作)：

      struct sigaction sa;
      sa.sa_handler = SIG_IGN;
  #ifdef SA_NOCLDWAIT
      sa.sa_flags = SA_NOCLDWAIT;
  #else
      sa.sa_flags = 0;
  #endif
      sigemptyset(&sa.sa_mask);
      sigaction(SIGCHLD, &sa, NULL);

如果这是成功的，那么‘wait()’函数集将不再正常工作；如果它们中任何一个被
调用，它们将等待直到*所有*子进程已经退出，然后返回失败，并且
‘errno==ECHILD’。

另一个技巧是捕获SIGCHLD信号，然后使信号处理程序调用‘waitpid()’或
‘wait3()’。参见范例章节的完整程序。

1.7 我怎样使我的程序作为守护程序运行？
======================================

一个“守护程序”进程通常被定义为一个后台进程，而且它不属于任何一个终端
会话，(terminal session)。许多系统服务由守护程序实施；如网络服务，打印等。

简单地在后台启动一个程序并非足够是这些长时间运行的程序；那种方法没有正
确地将进程从启动它的终端脱离(detach)。而且，启动守护程序的普遍接受的的方
法是简单地手工执行或从rc脚本程序执行(译者注：rc：runcom)；并希望这个守护
程序将其*自身*安置到后台。

这里是成为守护程序的步骤：

1. 调用‘fork()’以便父进程可以退出，这样就将控制权归还给运行你程序的
  命令行或shell程序。需要这一步以便保证新进程不是一个进程组头领进程(process
  group leader)。下一步，‘setsid()’，会因为你是进程组头领进程而失败。

2. 调用‘setsid()’ 以便成为一个进程组和会话组的头领进程。由于一个控制终端
  与一个会话相关联，而且这个新会话还没有获得一个控制终端，我们的进程没
  有控制终端，这对于守护程序来说是一件好事。

3. 再次调用‘fork()’所以父进程(会话组头领进程)可以退出。这意味着我们，一
  个非会话组头领进程永远不能重新获得控制终端。

4. 调用‘chdir("/")’确认我们的进程不保持任何目录于使用状态。不做这个会导
  致系统管理员不能卸装(umount)一个文件系统，因为它是我们的当前工作目录。

  [类似的，我们可以改变当前目录至对于守护程序运行重要的文件所在目录]

5. 调用‘umask(0)’以便我们拥有对于我们写的任何东西的完全控制。我们不知
  道我们继承了什么样的umask。

  [这一步是可选的](译者注：这里指步骤5，因为守护程序不一定需要写文件)

6. 调用‘close()’关闭文件描述符0,1和2。这样我们释放了从父进程继承的标
  准输入，标准输出，和标准错误输出。我们没办法知道这些文描述符符可能
  已经被重定向去哪里。注意到许多守护程序使用‘sysconf()’来确认
  ‘_SC_OPEN_MAX’的限制。‘_SC_OPEN_MAX’告诉你每个进程能够打
  开的最多文件数。然后使用一个循环，守护程序可以关闭所有可能的文件描
  述符。你必须决定你需要做这个或不做。如果你认为有可能有打开的文件描
  述符，你需要关闭它们，因为系统有一个同时打开文件数的限制。

7. 为标准输入，标准输出和标准错误输出建立新的文件描述符。即使你不打算
  使用它们，打开着它们不失为一个好主意。准确操作这些描述符是基于各自
  爱好；比如说，如果你有一个日志文件，你可能希望把它作为标准输出和标
  准错误输出打开，而把‘/dev/null’作为标准输入打开；作为替代方法，你可
  以将‘/dev/console’作为标准错误输出和/或标准输出打开，而‘/dev/null’作
  为标准输入，或者任何其它对你的守护程序有意义的结合方法。(译者注：一
  般使用dup2函数原子化关闭和复制文件描述符，参见<<高级编程>>3.12节)

如果你的守护程序是被‘inetd’启动的，几乎所有这些步骤都不需要(或不建议
采用)。在那种情况下，标准输入，标准输出和标准错误输出都为你指定为网络
连接，而且‘fork()’的调用和会话的操纵不应做(以免使‘inetd’造成混乱)。只
有‘chdir()’和‘umask()’这两步保持有用。

1.8 我怎样象ps程序一样审视系统的进程？
=======================================

你真的不该想做这个。

到目前为止，移植性最好的是调用‘popen(pscmd,"r")’并处理它的输出。(pscmd
应当是类似SysV系统上的‘“ps -ef”’，BSD系统有很多可能的显示选项：选
择一个。)

在范例章节有这个问题的两个完整解决方法；一个适用于SunOS 4，它需要root权
限执行并使用‘kvm_*’例程从内核数据结果读取信息；另一种适用于SVR4系统
(包括Sun OS 5)，它使用‘/proc’文件系统。

在具有SVR4.2风格‘/proc’的系统上更简单；只要对于每一个感兴趣的进程号从
文件‘/proc/进程号/psinfo’读取一个psinfo_t结构。但是，这种可能是最清晰的方
法也许又是最不得到很好支持的方法。(在FreeBSD的‘/proc’上，你从
‘/proc/进程号/status’读取一个半未提供文档说明(semi-undocumented)的可打印字
符串；Linux有一些与其类似的东西)

1.9 给定一个进程号，我怎样知道它是个正在运行的程序？
=====================================================

使用‘kill()’函数，而已0作为信号代码(signal number)。

从这个函数返回有四种可能的结果：

  * ‘kill()’返回0

    - 这意味着一个给定此进程号的进程退出，系统允许你向它发送信号。该进
      程是否可以是僵死进程与不同系统有关。

  * ‘kill()’返回-1，‘errno == ESRCH’

    - 要么不存在给定进程号的进程，要么增强的安全机制导致系统否认它的存
      在。(在一些系统上，这个进程有可能是僵死进程。)

  * ‘kill()’返回-1，‘errno == EPERM’

    - 系统不允许你杀死(kill)这个特定进程。这意味着要么进程存在(它又可能是
      僵死进程)，要么严格的增强安全机制起作用(比如你的进程不允许发送信号
      给*任何人*)。

  * ‘kill()’返回-1，伴以其它‘errno’值

    - 你有麻烦了！

用的最多的技巧是认为调用“成功”或伴以‘EPERM’的“失败”意味着进程存
在，而其它错误意味着它不存在。

如果你特别为提供‘/proc’文件系统的系统(或所有类似系统)写程序，一个替换
方法存在：检查‘proc/进程号’是否存在是可行的。

1.10 system函数，pclose函数，waitpid函数 的返回值是什么？
==========================================================

  ‘system()’，‘pclose()’或者‘waitpid()’的返回值不象是我进程的退出值(exit
    value)(译者注：退出值指调用exit() 或_exit()时给的参数)... 或者退出值左移了8
    位...这是怎么搞的？

手册页是对的，你也是对的! 如果查阅手册页的‘waitpid()’你会发现进程的返回
值被编码了。正常情况下，进程的返回值在高16位，而余下的位用来作其它事。
如果你希望可移植，你就不能凭借这个，而建议是你该使用提供的宏。这些宏总
是在‘wait()’或‘wstat’的文档中说明了。

为了不同目的定义的宏(在‘<sys/wait.h>’)包括(stat是‘waitpid()’返回的值)：

`WIFEXITED(stat)'
  如果子进程正常退出则返回非0

`WEXITSTATUS(stat)'
  子进程返回的退出码

`WIFSIGNALED(stat)'
  如果子进程由与信号而 终止则返回非0

`WTERMSIG(stat)'
  终止子进程的信号代码

`WIFSTOPPED(stat)'
  如果子进程暂停(stopped)则返回非0

`WSTOPSIG(stat)'
  使子进程暂停的信号代码

`WIFCONTINUED(stat)'
  如果状态是表示子进程继续执行则返回非0

`WCOREDUMP(stat)'
  如果‘WIFSIGNALED(stat)’为非0，而如果这个进程产生一个内存映射文件
  (core dump)则返回非0

1.11 我怎样找出一个进程的存储器使用情况？
=========================================

如果提供的话，参看‘getrusage()’手册页

1.12 为什么进程的大小不缩减？
=============================

当你使用‘free()’函数释放内存给堆时，几乎所有的系统都*不*减少你程序的
对内存的使用。被‘free()’释放的内存仍然属于进程地址空间的一部份，并将
被将来的‘malloc()’请求所重复使用。

如果你真的需要释放内存给系统，参看使用‘mmap()’分配私有匿名内存映射
(private anonymous mappings)。当这些内存映射被取消映射时，内存真的将其释放给
系统。某些‘malloc()’的实现方法(比如在GNU C库中)在允许时自动使用‘mmap()’
实施大容量分配；这些内存块(blocks)随着‘free()’被释放回系统。

当然，如果你的程序的大小增加而你认为它不应该这样，你可能有一个‘内存泄
露’(‘memory leak’)- 即在你的的程序中有缺陷(bug)导致未用的内存没释放。

1.13 我怎样改变我程序的名字(即“ps”看到的名字)？
=================================================

在BSD风格的系统中，‘ps’程序实际上审视运行进程的地址空间从而找到当前
的‘argv[]’，并显示它。这使得程序可以通过简单的修改‘argv[]’以改变它的
名字。

在SysV风格的系统中，命令的名字和参数的一般头80字节是存放在进程的u-区(
u-area)， 所以不能被直接修改。可能有一个系统调用用来修改它(不象是这样)，
但是其它的话，只有一个方法就是实施一个‘exec()’，或者些内核内存(危险，
而且只有root才有可能)。

一些系统(值得注意的是Solaris)可以有‘ps’的两种不同版本，一种是在
‘/usr/bin/ps’拥有SysV的行为，而另一种在‘/usr/ucb/ps’拥有BSD的行为。在
这些系统中，如果你改变‘argv[]’，那么BSD版的‘ps’将反映这个变化，而
SysV版将不会。

检查你的系统是否有一个函数‘setproctitle()’。

1.14 我怎样找到进程的相应可执行文件？
=====================================

这个问题可以作为‘常见未回答问题’(‘Frequently Unanswered Questions’)的一
个好候选，因为事实上提出这个问题经常意味着程序的设计有缺陷。:)

你能作的‘最佳猜测’(‘best guess’)是通过审视‘argv[0]’的值而获得。如果
它包括一个‘/’，那么它可能是可执行程序的绝对或相对(对于在程序开始时的
当前目录而言)路径。如果不包括，那么你可以仿效shell对于‘PATH’变量的查
询来查找这个程序。但是，不能保证成功，因为有可能执行程序时‘argv[0]’是
一些任意值，也不排除这个可执行文件在执行后可能已经被更名或删除的情况。

如果所有你想做的只是能打印一个和错误消息一起出现的合适的名字，那么最好
的方法在‘main()’函数中将‘argv[0]’的值保存在全局变量中以供整个程序使
用。虽然没有保证说‘argv[0]’的值总是有意义，但在大多数情况下它是最好的
选择。

人们询问这个问题的最普通原因是意图定位他们程序的配置文件。这被认为是
不好的形式；包含可执行文件的目录应当*只*包含可执行文件，而且基于管理的
要求经常试图将配置文件放置在和可执行文件不同的文件系统。

试图做这个的一个比较不普通但更正规的理由是允许程序调用‘exec()’执行它
自己；这是一种用来完全重新初始化进程(比如被用于一些‘sendmail’的版本)的
办法(比如当一个守护程序捕获一个‘SIGHUP’信号)。

1.14.1 So where do I put my configuration files then?
-----------------------------------------------------
1.14.1 那么，我把配置文件放在哪里里呢？

为配置文件安排正确的目录总是取决于你使用的Unix系统的特点；
‘/var/opt/PACKAGE’，‘/usr/local/lib’，‘/usr/local/etc’，或者任何其它一
些可能的地方。用户自定义的配置文件通常是在‘$HOME’下的以“.”开始的隐藏文件(
比如‘$HOME/.exrc’)。

从一个在不同系统上都能使用的软件包(package)的角度看，它通常意味着任何站
点范围(sitewide)的配置文件的位置有个已设定的缺省值，可能情况是使用一个在
配置脚本程序里的‘--prefix’选项(Autoconf 脚本程序集做这个工作)。你会希望允
许这个缺省值在程序执行时被一个环境变量重载。(如果你没使用配置脚本程序，
那么在编译时，将这个位置缺省值作为‘-D’选项放入项目文件(Makefile)，或者
将其放入一个‘config.h’头文件，或做其它类似的工作)

--

用户自定义配置需要放置于一个在‘$HOME’下的文件名“.”打头的文件，或者
在需要多个配置文件时，建立文件名“.”打头的子目录。(在列目录时，文件名以
“.”打头的文件或目录缺省情况下被忽略。)避免在‘$HOME’建立多个文件，因
为这会造成非常杂乱的情况。当然，你也应该允许用户通过一个环境变量重载这个
位置。即使不能找到某个用户的配置文件，程序仍应当以适宜的方式执行。

1.15 为何父进程死时，我的进程未得到SIGHUP信号？
===============================================

因为本来就没有设想是这样做的。

‘SIGHUP’是一个信号，它按照惯例意味着“终端线路被挂断”。它与父进程
无关，而且通常由tty驱动程序产生(并传递给前台的进程组)。

但是，作为会话管理系统(session management system)的一部份，确切说有两种情况
下‘SIGHUP’会在一个进程死时发送出：

  * 当一个终端设备与一个会话相关联，而这个会话的会话首领进程死时，
  ‘SIGHUP’被发送至这个终端设备的所有前台进程组。

  * 当一个进程死去导致一个进程组变成孤儿，而且该进程组里一个或多个进程
  处于*暂停*状态时，那么‘SIGHUP’和‘SIGCONT’被发送至这个孤儿进程
  组的所有成员进程。(一个孤儿进程组是指在该进程组中没有一个成员进程的
  父进程属于和该进程组相同的会话的其它进程组。)

1.16 我怎样杀死一个进程的所有派生进程？
=======================================

没有一个完全普遍的方法来做这个。虽然你可以通过处理‘ps’的输出确定进
程间的相互关系，但因为它只表示系统的一瞬间的状态(snapshot)所以并不可靠。

但是，如果你启动一个子进程，而它可能生成它自己的子进程，而你意图一次杀
死整个生成的事务(job)，解决方法是将最先启动的子进程置于一个新的进程组，
当你需要时杀死整个进程组。

建议为创建进程组而使用的函数是‘setpgid()’。在可能情况下，使用这个函数
而不使用‘setpgrp()’，因为后一个在不同系统中有所不同(在一些系统上‘setgrp()；’
等同于‘setpgid(0,0)；’，在其它系统上，‘setpgrp()’和‘setpgid()’相同)。

参见范例章节的事务-控制范例程序。

放置一个子进程于其自身的进程组有一些影响。特别的，除非你显式地将该进程
组放置于前台，它将被认为是一个后台事务并具有以下结果：

  * 试图从终端读取的进程将被‘SIGTTIN’信号暂停。

  * 如果设置终端模式‘tostop’，那么试图向终端写的进程将被‘SIGTTOU’
  信号暂停。(试图改变终端模式也导致这个结果，且不管当前‘tostop’是否
  设置)

  * 子进程将不会收到从终端发出的键盘信号(比如‘SIGINT’或‘SIGQUIT’)

在很多应用程序中输入和输出总会被重定向，所以最显著的影响将是丧失键盘
信号。父进程需要安排程序起码捕获‘SIGINIT’和‘SIGQUIT’(可能情况下，
还有‘SIGTERM’)，并在需要情况下清除后台事务。


2. 一般文件操作(包括管道和套接字)
*********************************

请同时参考套接字FAQ，在
http://www.lcg.org/sock-faq/

2.1 如何管理多个连接？
======================
  “我想同时监控一个以上的文件描述符(fd)/连接(connection)/流(stream)，
应该怎么办？”

使用 select() 或 poll() 函数。

注意：select() 在BSD中被引入，而poll()是SysV STREAM流控制的产物。因此，
这里就有了平台移植上的考虑：纯粹的BSD系统可能仍然缺少poll()，而早一些
的SVR3系统中可能没有select()，尽管在SVR4中将其加入。目前两者都是POSIX.
1g标准，（译者注：因此在Linux上两者都存在）

select()和poll()本质上来讲做的是同一件事，只是完成的方法不一样。两者都
通过检验一组文件描述符来检测是否有特定的时间将在上面发生并在一定的时间
内等待其发生。

[重要事项：无论select()还是poll()都不对普通文件起很大效用，它们着重用
于套接口(socket)、管道(pipe)、伪终端(pty)、终端设备(tty)和其他一些字符
设备，但是这些操作都是系统相关(system-dependent)的。]

2.2.1 我如何使用select()函数？
------------------------------
select()函数的接口主要是建立在一种叫'fd_set'类型的基础上。它('fd_set')
是一组文件描述符(fd)的集合。由于fd_set类型的长度在不同平台上不同，因此
应该用一组标准的宏定义来处理此类变量：

  fd_set set;
  FD_ZERO(&set);     /* 将set清零 */
  FD_SET(fd, &set);   /* 将fd加入set */
  FD_CLR(fd, &set);   /* 将fd从set中清除 */
  FD_ISSET(fd, &set); /* 如果fd在set中则真　*/

在过去，一个fd_set通常只能包含少于等于32个文件描述符，因为fd_set其实只
用了一个int的比特矢量来实现，在大多数情况下，检查fd_set能包括任意值的
文件描述符是系统的责任，但确定你的fd_set到底能放多少有时你应该检查/修
改宏FD_SETSIZE的值。*这个值是系统相关的*，同时检查你的系统中的select()
的man手册。有一些系统对多于1024个文件描述符的支持有问题。[译者注：
Linux就是这样的系统！你会发现sizeof(fd_set)的结果是128(*8 =
FD_SETSIZE=1024)　尽管很少你会遇到这种情况。]

select的基本接口十分简单：

  int select(int nfds, fd_set *readset, fd_set *writeset,
          fd_set *exceptset, struct timeval *timeout);
其中：
nfds :     需要检查的文件描述符个数，数值应该比是三组fd_set中最大数
        更大，而不是实际文件描述符的总数。
readset:   用来检查可读性的一组文件描述符。
writeset:   用来检查可写性的一组文件描述符。
exceptset: 用来检查意外状态的文件描述符。(注：错误并不是意外状态)
timeout:   NULL指针代表无限等待，否则是指向timeval结构的指针，代表最
        长等待时间。(如果其中tv_sec和tv_usec都等于0, 则文件描述符
        的状态不被影响，但函数并不挂起)

函数将返回响应操作的对应操作文件描述符的总数，且三组数据均在恰当位置被
修改，只有响应操作的那一些没有修改。接着应该用FD_ISSET宏来查找返回的文
件描述符组。

这里是一个简单的测试单个文件描述符可读性的例子：[ DISCUZ_CODE_151 ]当然如果我们把NULL指针作为fd_set传入的话，这就表示我们对这种操作的发生
不感兴趣，但select() 还是会等待直到其发生或者超过等待时间。

[译者注：在Linux中，timeout指的是程序在非sleep状态中度过的时间，而不是
实际上过去的时间，这就会引起和非Linux平台移植上的时间不等问题。移植问
题还包括在System V风格中select()在函数退出前会把timeout设为未定义的
NULL状态，而在BSD中则不是这样，Linux在这点上遵从System V，因此在重复利
用timeout指针问题上也应该注意。]