APUE(Advanced Programming Unix Environment)

系统的口令文件存放在/etc/passwd下面，每行是一条记录。每条记录以:分隔包含7个字段

• username
• password
• uid(user id)
• gid(group id)
• comment
• home directory
• shell 但是现在所有的系统都将这些信息放在其他文件(which file).Linux默认是Bourne-again shell(bash).

早期的Unix系统把8个部分都集中在一本手册上面，现在趋势是将他们安排在不同的手册上面， 包括用户专门手册，程序员手册，系统管理员手册等。通常来说shell命令在第1节，系统调用 在第2节，库函数在第3节，而系统管理员手册在第7节。

目录的起点为根，名字是/.目录是包含多个目录项的文件，逻辑上来说目录包含文件名还包括文件 属性信息等，但是在现实系统实现时候属性信息是和文件关联起来的而不是由目录保存的。如果由 目录来保存文件属性信息的话，那么在制作硬链接的时候会存在问题，很难保持多个文件属性复本的同步。 创建目录的时候自动会创建.和..目录。

每个进程都存在工作目录(working directory),使得所有相对路径名都从这个工作目录开始解释。进程 允许使用chdir或者是fchdir来改变工作目录。需要注意的是工作目录仅仅和进程相关的，所以执行 一个程序在里面chdir,而退回到shell的话工作目录不变。一个用户登录时候的工作目录成为 起始目录(home directory),这个在口令文件中指定了。

目录中各项就是文件名。通常来说文件名不能够出现的字符只是/和null字符。尽管如此，一个好的习惯是 应该尽可能使用印刷字符的一个子集来作为文件名字符，这样在shell下面能够键入文件名。文件名 和目录放在一起形成了路径名(pathname).

文件属性包括文件类型，文件大小，文件所有者，文件权限，文件最后修改时间等。使用stat,fstat或者是 lstat函数可以返回某个文件的属性信息。

对于进程需要访问文件的话，系统调用提供的界面是文件描述符(file descriptor).一个fd是一个小的非负 整数，内核用它标识一个特定进程正在访问的文件。对于每一个应用程序，shell都会为这个应用程序打开 默认的3个fd,分别是stdin,stdout和stderr.这3个fd的值通常是0,1,2,但是为了程序的可移植性考虑的话， 最好使用

#include <unistd.h>
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2

IO分为不带缓冲IO和带缓冲IO.不带缓冲IO是指read/write这样的调用，而带缓冲IO是指标准IO比如printf/ getchar/fputs这样的调用。是否带缓冲的区别是是否在用户态是否有buffer来缓冲从内核态读出来的数据。

程序和进程的区别是逻辑上的区别。程序是静态的存储在磁盘的可执行文件，用户启动程序的话，那么 内核装载这个程序运行，那么就形成了进程。进程(process)就是程序运行之后的动态的一个对象。

为了控制进程，每个进程都会分配一个pid(process id).主要有3个用于控制进程的函数，分别是fork/exec/waitpid. 需要注意的是,fork在很多系统中有另外一个名字spawn.

进程是竞争操作系统的资源单位和调度单位，而线程是最小的调度单位。一个进程可能包含很多线程(thread)， 但是始终只有一个主线程(main thread).使用线程可以充分利用多处理器系统的并行性。在同一个进程里面， 线程之间是共享资源的，包括地址空间，文件描述符，栈，进程相关属性等，而不像进程之间一样默认资源是隔离 的(当然也可以共享).同时线程为了方便控制也有tid(thread id)，但是控制线程的函数另外有一套。

当Unix函数出错时，常常返回一个负值并且使用errno来表示这个错误号。

#include <errno.h>
//是否支持多线程
#ifdef SUPPORT_MULTI_THREADS
extern int errno;
#else
exrern int* __errno_locaiton(void);
#define errno (*__errno_locaiton())
#endif
//错误编号(!0)
#define EACCESS <???>
#define EPERM <???>

没有支持多线程之前，可以使用变量来表示。但是如果是支持多线程的话，那么errno将会是一个全局变量， 所以errno就需要后面一种方式表示。因为现在大部分操作系统都是支持多线程的，所以对于我们来说， 需要认识到errno其实是一个宏。

同时C标准定义了两个函数来帮助打印错误信息

const char* strerror(int errnum); //根据错误号返回一个错误信息字符串
void perror(const char* msg); //msg:<错误消息>打印到标准错误上

用户标识包括

• 用户id(uid,user id)
• 组id(gid,group id)

• 附加组id(sgid,supplementary group id)

  对于uid来说是系统为了简化区别用户的方式(不然使用字符串区别非常麻烦).uid在登录时候确定 并且不能够修改。uid=0的用户为根用户(root),这是一个超级用户对于系统都一切支配权。同理也是 gid和sgid存在的理由。gid就好比用户所属部门的一个编号，而sgid引入原因是有时候希望这个用户 属于多个其他部门，这些其他部门的gid就是sgid.

信号(signal)是通知进程已经发生某种情况的一种技术。通常用户接收到信息有三个选择：

• 忽略
• 默认方式(系统提供)
• 自定义处理 在终端下面有两种产生信号的方式，分别是中断键(interrupt key,C-c)和退出键(quit key,C-\). 另外我们可以调用kill函数或者是在shell下面使用kill命令来给进程发送信号。

长期以来，Unix系统使用两种不同的时间值。

一种是自1970-1-1 0:0:0以来所经过的秒数累计值，使用time_t来表示，可以用于比如保存文件最后一次 修改时间等。这是一个绝对时间。

一种是CPU时间，用于度量进程使用的中央处理机资源。CPU时间以时钟滴答计算，使用sysconf可以获得每秒 时钟滴答数。使用clock_t来表示。这是一个相对时间。度量一个进程的执行时间，Unix使用三个时间值：

• 时钟时间(wall clock time).
• 用户CPU时间(user cpu time).
• 系统CPU时间(sys cpu time).

#include <cstdio>
#include <cstdlib>
#include <cerrno>
#include <unistd.h>
#include <sys/times.h>

int main(){
    long clock_tck_per_sec=sysconf(_SC_CLK_TCK);
    if(clock_tck_per_sec==-1){
        perror("_SC_CLK_TCK not supported");
        exit(-1);
    }
    //operations.
    //...
    struct tms buf;
    if(times(&buf)==-1){
        perror("times failed");
        exit(-1);
    }
    printf("user time:%.3lfs\n"
           "sys time:%.3lfs\n"
           "cuser time:%.3lfs\n"
           "csys time:%.3lfs\n",
           buf.tms_utime*1.0/clock_tck_per_sec,
           buf.tms_stime*1.0/clock_tck_per_sec,
           buf.tms_cutime*1.0/clock_tck_per_sec,
           buf.tms_cstime*1.0/clock_tck_per_sec);
    return 0;
}

系统调用是内核态函数，而库函数是用户态函数。但是对于用户来说实际上是不关心的。 Reaserch Unix提供了50个系统调用，BSD4.4提供了110个，SVR4提供了120个，Linux提供了240-260个， 而FreeBSD大约提供了320个。通常来说在man 2里面有描述。而库函数在man 3里面有描述。系统调用和 库函数另外一个差别是，系统调用通常提供一个最小接口(但是现在趋势是尽可能将很多功能集中形成 一个系统调用，因为这样不用频繁地陷入内核态来提高性能),而库函数在上层进行一些复杂功能实现。

现有的Unix系统实现包括：

• SVR4(Unix System V Release 4).
• 4.4BSD(Berkeley Software Distribution).
• FreeBSD(4.4BSD后裔).
• NetBSD(4.4BSD后裔).
• OpenBSD(4.4BSD后裔).
• Linux
• Mac OS X(Darwin后裔,Mach内核和FreeBSD结合).
• Solaris(SVR4后裔).
• AIX(IBM Unix).
• HP-UX(HP Unix).
• IRIX(SGI Unix).
• Unix Ware(SCO Unix.SVR4后裔).

open打开文件返回文件描述符。允许指定读写方式，是否创建(O_CREAT)，如果文件存在并且创建是否会出错(O_EXCL,exclusive)， 是否追加，是否truncate,是否阻塞，权限等标记，同时还允许指定是否每次write需要等待物理IO操作完成。 对于open每次一定都是返回最小的未使用的文件描述符。而create可以理解为open的包装:).注意这里 O_CREAT也非常关键，语义是入如果不存在就创建，这样使得这个操作成为一个原子操作。

还有下面常用方式：

• O_RDONLY.只读
• O_WRONLY.只写
• O_RDWR.读写
• O_APPEND.追加
• O_NONBLOCK.非阻塞
• O_SYNC.等待内容完全写到底层时候才返回。
• O_ASYNC.信号驱动IO。
• O_DIRECT.direct io.注意direct io只是在64位下面才有效。

注意如果使用direct io的话，那么要求读写的起始地址，读写大小，以及用户buffer地址都必须是PAGE_SIZE的整数倍。 虽然在32位机器上可以打开_GNU_SOURCE这个宏来使用O_DIRECT编译但是却不能够运行。

close允许关闭文件描述符。关闭一个文件会释放该进程在文件上所有记录锁。程序退出的时候 自动关闭所有打开的文件描述符，利用这点很多程序在退出时候并不显示关闭文件描述符。

lseek允许显示设置文件当前偏移量。如果文件描述符是一个管道，FIFO或者是网络套接字的话，那么 会返回ESPIPE的错误。需要注意的是lseek仅仅是修改进程对于这个文件访问逻辑偏移，实际上不进行任何 物理IO操作。使用lseek允许造成文件空洞(通常见于core文件),空洞部分并不要求占用磁盘存储空间。

#include <fcntl.h>
#include <unistd.h>
#include <cstring>
int main(){
    int fd=open("hole",O_WRONLY | O_CREAT,0666);
    write(fd,"1G hole are coming",strlen("1G hole are coming"));
    lseek(fd,1024*1024*1024,SEEK_CUR);
    write(fd,"1G hole are ending",strlen("1G hole are ending"));
    close(fd);
    return 0;
}

创建1G的空洞，可以查看

[dirlt@localhost.localdomain]$ ll hole
-rw-r--r-- 1 dirlt dirlt 1073741860 05-17 08:11 hole

[dirlt@localhost.localdomain]$ du -h hole
20K     hole

关于占用多少真实磁盘大小是文件系统所关心的，Linux下面使用20K来保存空洞文件。 另外需要关心lseek问题就是文件大小的情况，我们可以使用_FILE_OFFSET_BITS来控制偏移量的范围， 这样就允许操作更大的文件了。如果

-D_FILE_OFFSET_BITS=64

的话，那么偏移量就允许在2^64.这种规模的文件是相当大的了。尽管可以支持64位文件偏移，但是是否 允许创建这么大的文件，还是最终取决于文件系统的能力。

read从文件当前偏移开始读出数据，并且修改当前文件偏移。read允许指定需要读取数据多少，但是并不一定 会返回这么多的数据回来，那么这个时候read返回值就是已经读取的字节数。基本上对于终端，网络， 管道，FIFO等文件，都需要多次读取才能够完成，比较例外的就是磁盘了。同时我们必须注意信号 终端情况，这个时候read会返回EINTR的错误，通常来说我们还需要继续读。

readahead可以异步地发起IO操作将所需要读入磁盘内容读入page cache,这样后续发起的read则不会从磁盘上 读取而是直接从page cache读取。但是使用场景应该是这样的，首先发起readahead，然后进行一些内存上面 操作或者是CPU计算，然后发起read这样可以将计算和存储并行起来节省时间。

write也是从当前偏移开始写数据的，然后修改当前文件偏移。如果设置了O_APPEND选项打开文件的话， 那么write每次写操作，都会首先移动到文件最末尾然后写数据。这个选项非常重要，可以让文件 追加写成为原子操作。如果write大小不超过PIPE_BUF的话保证是原子操作。

除非使用O_DIRECT否则write通常是先写page cache，然后系统将page cache刷到磁盘上面去。 系统将page cache写回到磁盘上的时机包括下面几个：

• 定时回写
• 脏页超过一定比例
• 空闲内存不足
• 用户调用sync

另外write可能会修改inode节点(这些inode节点也是保存在cached memory里面的).这些inode节点 写回磁盘的时机和page cache写回磁盘时机是一样的。

对于这些脏页的写回策略是：

• 首先判断脏页比例是否超过dirty_ratio.如果没有的话那么直接退出
• 然后开始将脏页刷到磁盘直到比率小于dirty_ratio.（此时write会阻塞）
• 判断脏页比例是否超过dirty_background_ratio或者是超过dirty_background_bytes.如果没有那么退出。
• 如果超过的话那么就会启动pdflush daemon后台进程刷新脏页。（此时write不会阻塞）

注意到这里可能启动pdflush daemon在后台刷新脏页。另外系统每隔dirty_writeback_centisecs时间会启动 pdflush daemon将脏页刷到磁盘上面。而pdflush daemon工作方式是这样的，检查脏页是否存在超过 dirty_expire_centisecs时间的，如果超过的话那么就会在后台刷新这些脏页。

如果写入量巨大，不能期待系统缓存的自动回刷机制，最好采用应用层调用fsync或者sync。如果写入量大，甚至超过了系统缓存自动刷回的速度，就有可能导致系统的脏页率超过/proc/sys/vm/dirty_ratio， 这个时候，系统就会阻塞后续的写操作，这个阻塞有可能有5分钟之久，是我们应用无法承受的。因此，一种建议的方式是在应用层，在合适的时机调用fsync。

http://blog.chinaunix.net/uid-27105712-id-3270102.html

下面是整个write过程

• glibc write是将app_buffer->libc_buffer->page_cache
• write是将app_buffer->page_cache
• mmap可以直接获取page_cache直写
• write+O_DIRECT的话将app_buffer写到io_queue里面
  • io_queue一方面将写邻近扇区的内容进行merge，另外一方面进行排序确保磁头和磁 盘旋转最少。
  • io_queue的工作也需要结合IO调度算法。不过这些仅仅对于physical disk有效。
  • 对于ssd而言的话，因为完全是随机写，基本没有调度算法。
• driver（filesystem module）通过DMA写入disk_cache之后(使用fsync就可以强制刷新)到disk上面了。
• 直接操作设备（RAW）方式直接写disk_cache.

O_DIRECT 和 RAW设备最根本的区别是O_DIRECT是基于文件系统的，也就是在应用层来看，其操作对象是文件句柄，内核和文件层来看，其操作是基于inode和数据块，这些概念都是和ext2/3的文件系统相关，写到磁盘上最终是ext3文件。而RAW设备写是没有文件系统概念，操作的是扇区号，操作对象是扇区，写出来的东西不一定是ext3文件（如果按照ext3规则写就是ext3文件）。一般基于O_DIRECT来设计优化自己的文件模块，是不满系统的cache和调度策略，自己在应用层实现这些，来制定自己特有的业务特色文件读写。但是写出来的东西是ext3文件，该磁盘卸下来，mount到其他任何linux系统上，都可以查看。而基于RAW设备的设计系统，一般是不满现有ext3的诸多缺陷，设计自己的文件系统。自己设计文件布局和索引方式。举个极端例子：把整个磁盘做一个文件来写，不要索引。这样没有inode限制，没有文件大小限制，磁盘有多大，文件就能多大。这样的磁盘卸下来，mount到其他linux系统上，是无法识别其数据的。两者都要通过驱动层读写；在系统引导启动，还处于实模式的时候，可以通过bios接口读写raw设备。

pread/pwrite相当于一个方便的lseek+read/write操作，并且有一个特点就是不修改当前文件偏移。

#include <fcntl.h>
#include <unistd.h>
#include <cstring>
#include <cstdio>
int main(){
    int fd=open("main.cc",O_RDONLY);
    char buf[128];
    memset(buf,0,sizeof(buf));
    for(int i=0;i<10;i++){
        //每次读取到的都是相同的内容
        pread(fd,buf,sizeof(buf)-1,128);
        printf("%s\n",buf);
    }
    close(fd);
    return 0;
}

int dup(int fd);
int dup2(int src_fd,int dst_fd);

dup2允许指定将src_fd复制给某个dst_fd,而dup是将fd复制给最小未使用的fd. dup2相当于一个原子操作，首先关闭dst_fd然后再复制到dst_fd上面。

操作系统为了提高文件读写效率，在内核层提供了读写缓冲区。对于磁盘的写并不是立刻写入磁盘， 而是首先写入页面缓冲区然后定时刷到硬盘上。但是这种机制降低了文件更新速度，并且如果系统发生故障 的话，那么会造成部分数据丢失。这里的3个sync函数就是为了这个问题的。

• sync.是强制将所有页面缓冲区都更新到磁盘上。
• fsync.是强制将某个fd涉及到的页面缓存更新到磁盘上(包括文件属性等信息).
• fdatasync.是强制将某个fd涉及到的数据页面缓存更新到磁盘上。

全称是file control,可以改变已经打开文件的性质，共有下面5种功能：

• F_DUPFD.复制现有描述符。
• F_GETFD/F_SETFD.获得/设置现有文件描述符标记(现只有FD_CLOEXEC).
• F_SETFL/F_GETFL.获得/设置现有文件状态标记。
• F_GETOWN/F_SETOWN.获得/设置当前接受SIGIO和SIGURG信号的进程ID和进程组ID(设置异步IO所有权).
• F_GETLK/F_SETLK/F_SETLKW.获得/设置记录锁。

全称是io control.ioctl是IO操作杂物箱，终端IO是ioctl的最大使用方面。ioctl包含的头文件是

#include <unistd.h>
#include <sys/ioctl.h>
#include <stropts.h>

但是这仅仅是ioctl所需要包含的文件，不同设备还有专有的头文件：

使用open打开任何一个文件，相当于进行了dup操作一样进行了文件描述符复制。并且需要注意的是，比如 对于标准输入只允许读的话，那么如果open使用RDWR打开的话那么写依然是没有作用的。在shell下面如果 程序需要传入一个文件名从文件里面读入内容的话，我们提供/dev/fd/0的话，那么程序就可以从标准输入 中读取内容，这点非常方便。

这节主要说文件描述符是如何管理的，假设在一个系统中存在很多进程(process),每个进程里面有一个文件 描述符表，大致结构如下：

struct Process{
    //这是一个数组，文件描述符就是下标。
    vector<FileDescriptorEntry> entries;
};
struct FileDescriptorEntry{
    bool close_on_exec; //调用exec是否关闭
    bool other_flags; //其他标记
    OpenedFileTable* ft_ptr; //指向全局的打开文件表表项
};

然后系统维护一个打开表文件表表项，在每个进程的文件描述符里面有对应的表项指针。大致结构如下：

struct OpenedFileTable{
    int status; //状态标志，比如O_RDWR,O_APPEND,OSYNC等。
    off_t offset; //当前偏移
    vnode_t* vnode; //所指向的vnode
};

在进程复制一个文件描述符并没有增加一个新的表项，而是指向相同的表项。然后vnode_t就是 文件系统对应的内容了，包括位置大小属性等等信息。

首先我们可以将一块磁盘进行分区，这样每个区就可以在上面建立一个文件系统。 一个文件系统可以表示为下面这样的数据结构：

//Physical File System
strcut PFS{
    //这个部分内容可以直接载入内存来进行管理
    Block boot; //自举块
    Block super; //超级块
    Configuration config; //配置信息
    Bitmap inode_bitmap; //inode节点的bitmap
    Bitmap dblock_bitmap; //数据块的bitmap
    //下面这些内容不能够载入内存
    Inode inodes[]; //inode节点数组
    DataBlock dblocks[]; //数据块数组
};

可以看到为了管理一个文件系统，在内存中主要存放inode和数据块的bitmap,表示哪些inode和 数据块是空闲的。

然后对于Inode节点来说，里面存放的就是数据块的索引。这里为了概念上表示方便而使用数组 表示的，实际上Inode可能有简介索引，指向的并不一定就是直接可以的读取数据块，可能数据块 上面存放的是更多数据块的指针。

struct Inode{
    FileAttribute attr; //文件属性
    index_t datablock[]; //数据块的索引
};

但是可以确信一点的就是，一个文件在同一个文件系统中对应一个inode.文件属性对应的就是 struct stat这个结构。可以看到文件属性是存放在inode节点上而不是数据块上的。

对于一个目录项来说，结构大致如下：

//目录项
struct DirectoryEntry{
    char filename[]; //文件名
    index_t inode; //对应的inode索引
};

struct Directory{
    DirectoryEntry entries[]; //目录项数组
};

目录里面存放的就是文件名和对应的inode索引。

对于符号链接来说，在文件属性标记是否为符号链接，然后磁盘内容就是目的地文件系统路径。

[dirlt@localhost.localdomain]$ touch a
[dirlt@localhost.localdomain]$ ln -s ./a b
[dirlt@localhost.localdomain]$ ln -s /home/dirlt/cvs/opencode/zyspace/doc/a b2
[dirlt@localhost.localdomain]$ ll b b2
lrwxrwxrwx 1 dirlt dirlt  3 05-19 08:14 b -> ./a
lrwxrwxrwx 1 dirlt dirlt 38 05-19 08:15 b2 -> /home/dirlt/cvs/opencode/zyspace/doc/a
[dirlt@localhost.localdomain]$

可以看到b长度为3,正好等于"./a"长度，而b2长度为38也等于"/home/dirlt/cvs/opencode/zyspace/doc/a"长度。

对应的是st_mode这个字段。文件类型有下面这几类，系统也提供了特殊的宏来判断到底是 什么样的文件类型：

• 普通文件(S_ISREG)
• 目录文件(S_ISDIR)
• 字符特殊文件(S_ISCHR)
• 块特殊文件(S_ISBLK)
• FIFO文件(S_ISFIFO)
• 符号链接文件(S_ISLNK)
• 套接字文件(S_ISSOCK)

在Linux上面为了使用S_ISSOCK需要使用_GNU_SOURCE这个选项。然后需要注意的是，系统中 所有的设备要么是字符特殊文件，要么是块特殊文件。字符特殊文件针对设备是不带缓冲的 访问，每次访问长度可变，而块特殊设备对于访问提供缓冲并且以固定长度为单位进行。

#todo: 给出两个字符特殊文件和块特殊文件的例子，更加好区分两者差别。

对于一个进程来说，相关联的ID有下面几个：

关于保存的设置ID判断条件是_POSIX_SAVED_IDS/_SC_SAVED_IDS.

通常来说有效uid和gid等同于实际uid和gid.但是对于一些特殊程序比如需要修改passwd,那么 程序执行时必须以另外一种用户启动，所以区分了这两个概念。

[dirlt@localhost.localdomain]$ ll /usr/bin/passwd
-rwsr-xr-x 1 root root 25708 2007-09-26 /usr/bin/passwd

我们调用passwd修改密码，实际uid和gid是我们自己，而运行uid和gid则是root.为了查看文件 是否设置了这个功能，我们可以使用S_ISUID和S_ISGID查看st_mode相应位。

#include <sys/stat.h>
#include <cstdio>
int main(){
    struct stat buf;
    stat("/usr/bin/passwd",&buf);
    printf("is_uid:%d\n",(buf.st_mode && S_ISUID)!=0);
    printf("is_gid:%d\n",(buf.st_mode && S_ISGID)!=0);
    printf("owner uid:%d\n",buf.st_uid);
    printf("owner gid:%d\n",buf.st_gid);
    return 0;
}

is_uid:1
is_gid:1
owner uid:0
owner gid:0

文件访问权限也可以通过访问st_mode来获得，有下面9个权限位：

在谈论规则之前，有必要解释一下目录的执行权限。目录是一个特殊文件，可以将目录想象 成为里面都是文件的名称然后配上必要的索引信息。对于一个目录的读权限，就是可以获得 里面所有的文件名内容，而对于执行权限就是可以搜索其中特定的文件名。

文件访问权限有下面这些规则：

• 读写权限控制了我们是否可以读写文件。
• 打开任意类型文件，必须有效uid和文件owner uid匹配或者是gid匹配，或者是超级权限。
• 打开任意类型文件，必须有所有目录的执行权限。
• 在目录下面创建文件需要对这个目录有写和执行权限。
• 创建的文件的uid和gid分别是有效的uid和有效的gid.
• 删除文件必须有效uid和文件owner uid匹配，或者是gid匹配，或者是超级权限。
• 删除文件必须对目录有写和执行权限，但是不需要对文件有读写权限。
• 执行文件必须对文件有执行权限，并且文件还是一个普通文件。

其实对于创建文件来说，新文件的gid owner还可能是另外一种情况，那就是继承上级目录的gid owner. 对于Linux系统方式是这样的：如果上级目录设置了设置gid位的话，那么就继承上级的gid owner, 否则就使用创建者的有效gid.(个人觉得按照创建者的有效uid和gid比较好理解问题):).

文件长度对应st_size字段，而文件使用的块大小对应st_blksize字段，占用块数对应st_blocks字段。 大部分情况下面，st_size和st_blksize*st_blocks应该是很接近的，除非一种情况就是文件空洞。 一般对应于空洞文件来说，st_size可能很大，而实际占用磁盘空间却很少。

#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>
#include <cstdio>
int main(){
    //产生一个空洞文件
    int fd=open("hole",O_WRONLY | O_CREAT,0666);
    write(fd,"1G hole are coming",strlen("1G hole are coming"));
    lseek(fd,1024*1024*1024,SEEK_CUR);
    write(fd,"1G hole are ending",strlen("1G hole are ending"));
    close(fd);
    struct stat buf;
    stat("hole",&buf);
    printf("size:%lu,st_blksize:%lu,st_blocks:%lu\n",
           buf.st_size,buf.st_blksize,buf.st_blocks);
    return 0;
}

[dirlt@localhost.localdomain]$ ./main
size:1073741860,st_blksize:4096,st_blocks:40

int truncate(const char* filename,off_t length);
int ftruncate(int fd,off_t length);

如果length比原来文件短的话，那么文件在length偏移之后数据就不可以访问了。如果length比 原来文件长的话，那么会创造一个空洞出来

#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>
#include <cstdio>
int main(){
    int fd=open("hole",O_WRONLY | O_CREAT,0666);
    close(fd);
    truncate("hole",1024*1024*1024);
    struct stat buf;
    stat("hole",&buf);
    printf("size:%lu,st_blksize:%lu,st_blocks:%lu\n",
           buf.st_size,buf.st_blksize,buf.st_blocks);
    return 0;
}

[dirlt@localhost.localdomain]$ ./main
size:1073741824,st_blksize:4096,st_blocks:8

关于文件链接分为硬链接和软链接，软链接也称为符号链接在之前提到过。

创建一个硬链接效果就是，选择一个文件名然后选择一个已经使用的inode编号存放在目录下面。 一旦创建硬链接之后，那么被链接的文件的属性里面就会将链接数目+1.链接数目对应于struct stat 结构里面的st_nlink字段。

int link(const char* existingpath,const char* newpath);

可以看到硬链接是使用inode节点来操作的，所以硬链接是不可以跨越文件系统的。另外需要注意的是， 大多数操作系统仅限于超级用户进行目录的硬链接，因为这样做可能会造成文件系统中形成循环，而 大多数程序无法处理这种情况而且很容易搞乱文件系统。

符号链接也对应是一个文件，指向另外一个文件。所以在这里我们必须弄清楚，如果操作 符号链接的话，哪些是操作链接文件，哪些是操作真实文件：

创建符号链接和读取符号链接函数为symlink和readlink.

为了解除硬链接可以使用下面这个函数：

int unlink(const char* pathname);

因为文件链接数目如果为0的话，那么文件就会被删除，所以这个函数也可以用来删除文件。 解除硬链接必须包含对于目录的写和执行权限。如果文件设置了粘住位的话，除了具有写权限之外， 还必须有下面其中一个条件：

• 拥有该文件
• 拥有该目录
• 超级用户

关于文件删除也可以使用remove函数，效果和unlink一样。不过对于目录来说内部调用rmdir.

在删除文件是后需要注意的一个问题是这样的，就是即使st_nlink==0的话，如果系统中 还有进程在访问这个文件的话，那么磁盘空间仍然不会释放，知道进程关闭这个文件之后 才会释放磁盘空间。甚至来说，如果进程持有这个fd的话，这个文件依然是可写的。

#include <cstdio>
#include <fcntl.h>
#include <unistd.h>
int main(){
    int fd=open("hello",O_RDWR | O_TRUNC | O_CREAT,0666);
    unlink("hello");
    write(fd,"hello",6);
    lseek(fd,0,SEEK_SET);
    char buf[12];
    buf[0]=0;
    read(fd,buf,sizeof(buf));
    //尽管之前unlink了
    //依然可以读取到hello
    printf("%s\n",buf);
    close(fd);
}

重命名使用函数rename.关于重命名会涉及目录，所以这里看看行为：

• oldname是文件
  • newname不能够是目录
  • newname如果存在首先删除
  • 然后创建newname
• oldname是目录
  • newname不能够是文件
  • newname如果存在必须是空目录然后删除
  • 然后创建newname

文件时间分为：

• 最后访问时间(read)
• 最后修改时间(write)
• 最后更改时间(chmod,chown)

修改时间和更改时间差别是，修改时间是修改数据块内容时间，而更改时间是更改inode节点的时间， 差别就好比操作文件实际内容和文件属性。不同操作影响时间不同，而且还会影响所在父目录的时间。

创建目录函数是mkdir和rmdir.mkdir常犯错误是权限为0666和文件相同，通常来说目录是 需要可执行权限，不然我们不能够在下面创建目录。rmdir要求目录必须是空目录。 和删除文件一样，如果链接数为0并且没有进程打开之后才会释放空间。如果链接数==0时候， 有其他进程打开目录的话，那么会删除.和..,然后也不允许添加新的目录项，等到打开目录 进程退出之后，才会释放磁盘空间。

读取目录函数是：

• opendir
• readdir
• rewinddir
• closedir
• telldir
• seekdir

readdir访问到的文件顺序和目录实现相关

chdir,fchdir可以帮助切换当前工作目录，而getcwd可以获得当前工作目录是什么。 当前工作目录是一个进程的概念，所以如果A调用B的话，即使B调用chdir切换工作目录， B执行完成之后，A的工作目录不会发生变化。

st_dev是设备号，分为主次设备号：

major(buf.st_dev) //主设备号
minor(buf.st_dev) //次设备号

主设备号表示设备驱动程序，而次设备号表示特定的子设备。比如在同一个磁盘上面 不同的文件系统，设备驱动程序相当，但是次设备号不同。

st_rdev只有字符特殊文件和块特殊文件才有这个值，表示实际设备的设备编号。

#include <sys/types.h>
#include <sys/stat.h>
#include <cstdio>
int main(int argc,char * const* argv){
    for(int i=1;i<argc;i++){
        struct stat buf;
        stat(argv[i],&buf);
        printf("%s dev=%d/%d",argv[i],
               major(buf.st_dev),minor(buf.st_dev));
        if(S_ISCHR(buf.st_mode) || S_ISBLK(buf.st_mode)){
            if(S_ISCHR(buf.st_mode)){
                printf(" (character)");
            }else if(S_ISBLK(buf.st_mode)){
                printf(" (block)");
            }
            printf(" rdev=%d/%d",
                   major(buf.st_rdev),minor(buf.st_rdev));
        }
        printf("\n");
    }
    return 0;
}

[dirlt@localhost.localdomain]$ mount
/dev/mapper/VolGroup00-LogVol00 on / type ext3 (rw)
proc on /proc type proc (rw)
sysfs on /sys type sysfs (rw)
devpts on /dev/pts type devpts (rw,gid=5,mode=620)
/dev/sda1 on /boot type ext3 (rw)
tmpfs on /dev/shm type tmpfs (rw)
none on /proc/sys/fs/binfmt_misc type binfmt_misc (rw)
sunrpc on /var/lib/nfs/rpc_pipefs type rpc_pipefs (rw)
[dirlt@localhost.localdomain]$ df
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/mapper/VolGroup00-LogVol00
                      19552940   2649028  15894660  15% /
/dev/sda1               194442     12450    171953   7% /boot
tmpfs                   127628         0    127628   0% /dev/shm
[dirlt@localhost.localdomain]$ ./main /boot/ /dev/shm /tmp /home /dev/cdrom /dev/tty0
/boot/ dev=8/1
/dev/shm dev=0/18
/tmp dev=253/0
/home dev=253/0
/dev/cdrom dev=0/16 (block) rdev=11/0
/dev/tty0 dev=0/16 (character) rdev=4/0

#todo: 其实对于设备号这个东西还不是非常地了解，认识有待加深。

http://www.ibm.com/developerworks/cn/linux/l-inotifynew/index.html

inotify可以用于监控文件以及目录的变化，下面是inotify提供的API

• #include <sys/inotify.h>
• int inotify_init(void); // inotify_init1(0);
• int inotify_init1(int flags);
  • IN_NONBLOCK // 在访问事件时候使用阻塞读取。
  • IN_CLOEXEC // 在exec时候关闭。
  • return a new file descriptor.
• int inotify_add_watch(int fd, const char *pathname, uint32_t mask);
  • pathname // 需要监控的文件或者是目录
  • mask // 监控标记
  • return a nonnegative watch descriptor.
• int inotify_rm_watch(int fd, int wd);

整个使用过程非常简单，首先通过init创建fd, 然后将需要监控的文件添加进来/或者是移除，之后在read时候读取监控事件。fd可以放在epoll里面进行监控。监控事件结构如下：

/* Structure describing an inotify event.  */
struct inotify_event
{
  int wd;       /* Watch descriptor.  */
  uint32_t mask;    /* Watch mask.  */
  uint32_t cookie;  /* Cookie to synchronize two events.  */
  uint32_t len;     /* Length (including NULs) of name.  */
  char name __flexarr;  /* Name.  */
};

对于__flexarr这个字段是一个悬挂指针表示文件名称，文件长度通过len表示，所以读取一个event之后的话，还需要向前移动len个字节才能够读取下一个事件。

有下面这些事件可以进行监控。下面是代码

/* Supported events suitable for MASK parameter of INOTIFY_ADD_WATCH.  */
#define IN_ACCESS    0x00000001 /* File was accessed.  */
#define IN_MODIFY    0x00000002 /* File was modified.  */
#define IN_ATTRIB    0x00000004 /* Metadata changed.  */
#define IN_CLOSE_WRITE   0x00000008 /* Writtable file was closed.  */
#define IN_CLOSE_NOWRITE 0x00000010 /* Unwrittable file closed.  */
#define IN_CLOSE     (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE) /* Close.  */
#define IN_OPEN      0x00000020 /* File was opened.  */
#define IN_MOVED_FROM    0x00000040 /* File was moved from X.  */
#define IN_MOVED_TO      0x00000080 /* File was moved to Y.  */
#define IN_MOVE      (IN_MOVED_FROM | IN_MOVED_TO) /* Moves.  */
#define IN_CREATE    0x00000100 /* Subfile was created.  */
#define IN_DELETE    0x00000200 /* Subfile was deleted.  */
#define IN_DELETE_SELF   0x00000400 /* Self was deleted.  */
#define IN_MOVE_SELF     0x00000800 /* Self was moved.  */

/* Events sent by the kernel.  */
#define IN_UNMOUNT   0x00002000 /* Backing fs was unmounted.  */
#define IN_Q_OVERFLOW    0x00004000 /* Event queued overflowed.  */
#define IN_IGNORED   0x00008000 /* File was ignored.  */

/* Helper events.  */
#define IN_CLOSE     (IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)    /* Close.  */
#define IN_MOVE      (IN_MOVED_FROM | IN_MOVED_TO)      /* Moves.  */

/* Special flags.  */
#define IN_ONLYDIR   0x01000000 /* Only watch the path if it is a
                       directory.  */
#define IN_DONT_FOLLOW   0x02000000 /* Do not follow a sym link.  */
#define IN_EXCL_UNLINK   0x04000000 /* Exclude events on unlinked
                       objects.  */
#define IN_MASK_ADD  0x20000000 /* Add to the mask of an already
                       existing watch.  */
#define IN_ISDIR     0x40000000 /* Event occurred against dir.  */
#define IN_ONESHOT   0x80000000 /* Only send event once.  */

/* All events which a program can wait on.  */
#define IN_ALL_EVENTS    (IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE  \
              | IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM        \
              | IN_MOVED_TO | IN_CREATE | IN_DELETE           \
              | IN_DELETE_SELF | IN_MOVE_SELF)

man里面对于每个事件有详细说明

inotify events
    The  inotify_add_watch(2) mask argument and the mask field of the inotify_event structure returned when read(2)ing an ino‐
    tify file descriptor are both bit masks identifying inotify events.  The following bits can  be  specified  in  mask  when
    calling inotify_add_watch(2) and may be returned in the mask field returned by read(2):

        IN_ACCESS         File was accessed (read) (*).
        IN_ATTRIB         Metadata  changed,  e.g.,  permissions,  timestamps,  extended  attributes,  link count (since Linux
                          2.6.25), UID, GID, etc. (*).
        IN_CLOSE_WRITE    File opened for writing was closed (*).
        IN_CLOSE_NOWRITE  File not opened for writing was closed (*).
        IN_CREATE         File/directory created in watched directory (*).
        IN_DELETE         File/directory deleted from watched directory (*).
        IN_DELETE_SELF    Watched file/directory was itself deleted.
        IN_MODIFY         File was modified (*).
        IN_MOVE_SELF      Watched file/directory was itself moved.
        IN_MOVED_FROM     File moved out of watched directory (*).
        IN_MOVED_TO       File moved into watched directory (*).
        IN_OPEN           File was opened (*).

    When monitoring a directory, the events marked with an asterisk (*) above can occur for files in the directory,  in  which
    case the name field in the returned inotify_event structure identifies the name of the file within the directory.

    The  IN_ALL_EVENTS macro is defined as a bit mask of all of the above events.  This macro can be used as the mask argument
    when calling inotify_add_watch(2).

    Two additional convenience macros are IN_MOVE, which equates to IN_MOVED_FROM|IN_MOVED_TO, and IN_CLOSE, which equates  to
    IN_CLOSE_WRITE|IN_CLOSE_NOWRITE.

    The following further bits can be specified in mask when calling inotify_add_watch(2):

        IN_DONT_FOLLOW (since Linux 2.6.15)
                          Don't dereference pathname if it is a symbolic link.
        IN_EXCL_UNLINK (since Linux 2.6.36)
                          By  default,  when watching events on the children of a directory, events are generated for children
                          even after they have been unlinked from the directory.  This can result in large numbers of uninter‐
                          esting  events for some applications (e.g., if watching /tmp, in which many applications create tem‐
                          porary files whose names are immediately unlinked).  Specifying IN_EXCL_UNLINK changes  the  default
                          behavior,  so  that  events  are  not  generated for children after they have been unlinked from the
                          watched directory.
        IN_MASK_ADD       Add (OR) events to watch mask for this pathname if it already exists (instead of replacing mask).
        IN_ONESHOT        Monitor pathname for one event, then remove from watch list.
        IN_ONLYDIR (since Linux 2.6.15)
                          Only watch pathname if it is a directory.

    The following bits may be set in the mask field returned by read(2):

        IN_IGNORED        Watch was removed explicitly (inotify_rm_watch(2)) or automatically (file was deleted, or file  sys‐
                          tem was unmounted).
        IN_ISDIR          Subject of this event is a directory.
        IN_Q_OVERFLOW     Event queue overflowed (wd is -1 for this event).
        IN_UNMOUNT        File system containing watched object was unmounted.

在man 7 inotify里面给出了涉及到的内核参数

/proc interfaces
    The following interfaces can be used to limit the amount of kernel memory consumed by inotify:

    /proc/sys/fs/inotify/max_queued_events
           The  value  in  this  file is used when an application calls inotify_init(2) to set an upper limit on the number of
           events that can be queued to the corresponding inotify instance.  Events in excess of this limit are  dropped,  but
           an IN_Q_OVERFLOW event is always generated.

    /proc/sys/fs/inotify/max_user_instances
           This specifies an upper limit on the number of inotify instances that can be created per real user ID.

    /proc/sys/fs/inotify/max_user_watches
           This specifies an upper limit on the number of watches that can be created per real user ID.

限制了创建的instance个数已经watch数目，以及event的数目。如果event出现溢出的话，那么会产生IN_Q_OVERFLOW事件。通常如果出现overflow事件的话， 以为着监控事件发生丢失，那么应用程序需要主动进行扫描。

对于文件IO来说，所有IO函数都是针对文件描述符展开的。而对于标准IO而言，所有函数 都只针对流展开的。管理的结构是FILE,通常是一个结构体，通常里面包含了：

• 文件fd
• 缓冲区指针
• 缓冲区长度
• 当前缓冲区读取长度
• 出错标志

然后大部分标准IO使用的都是FILE*结构体指针来操作的。

使用函数fileno可以得到fd.而对于其他字段的话，因为本身就是一个struct结构，只需要 阅读stdio.h里面的FILE结构就可以看到每个字段的意思并且可以得到它们。

流的定向(stream's orientation)决定了所读写的字符是单字节还是多字节的。一个流最初创建 的时候并没有定向，直到第一次使用的时候才被确定。有两个函数可以修改流的定向：

• freopen.这个函数清除了流的定向。
• fwide(FILE* fp,int mode).这个函数修改流的定向。

#todo: 为什么需要使用宽字符。是否使用宽字符的话，那么很多编码方面的问题就可以在标准IO层面操作而不需要上层操作呢？

对于文件IO使用了0,1,2分别表示标准输入，输出和错误，对应的标准IO也提供了预定义的三个 流来，分别是stdin,stdout和stderr.

标准IO相对于文件IO最便利的地方就是提供了缓冲。缓冲的话大部分情况能够改善程序的性能， 虽然大部分使用标准IO需要提供一次额外的copy,但是相对于频繁进行系统调用来说还是值得的。

标准IO提供了下面三种缓冲：

• 全缓冲
• 行缓冲
• 不带缓冲

全缓冲是指填满IO缓冲区之后在进行实际的IO操作，通常来说对于驻留在磁盘上的文件使用 全缓冲。在流上第一次实行IO操作的时候，标准IO就会通过malloc分配一块缓冲区。如果使用 全缓冲需要强制进行实际操作的话，可以调用fflush来冲刷。对于flush有两层意思，对于 标准IO而言，flush是将缓冲区的内容进行实际IO操作，而对于设备驱动程序而言，就是 丢弃缓冲区里面的内容。

#include <cstdio>
#include <unistd.h>
int main(){
    //退出后输出
    char buffer[1024];
    setvbuf(stdout,buffer,_IOFBF,sizeof(buffer));
    printf("helloworld");
    sleep(2);
    return 0;
}

行缓冲是指输入和输出遇到换行符之后，标准IO库才执行IO操作。当然如果缓冲区已经满了 的话，那么也是会进行的。并且任何时候如果标准IO库从一个不带缓冲的流，或者是从内核 得到数据的带行缓冲流中获得数据的话，会造成冲洗所有行缓冲输出流。(what fucking is that?). 通常来说对于终端设备比如标准输入和输出的时候，使用行缓冲。

#include <cstdio>
#include <unistd.h>
int main(){
    //退出后输出
    char buffer[128];
    setvbuf(stdout,buffer,_IOLBF,sizeof(buffer));
    printf("helloworld");
    sleep(2);
    return 0;
}

#include <cstdio>
#include <unistd.h>
int main(){
    //立刻输出
    char buffer[128];
    setvbuf(stdout,buffer,_IOLBF,sizeof(buffer));
    printf("helloworld\n");
    sleep(2);
    return 0;
}

#include <cstdio>
#include <unistd.h>
int main(){
    //立刻输出
    //可以看到并不是说缓冲区足够的情况下不输出
    //内置有另外一套算法，对于128那么就并没有输出
    //而对于64立刻输出，但是其实都没有填满
    char buffer[64];
    setvbuf(stdout,buffer,_IOLBF,sizeof(buffer));
    printf("helloworld");
    sleep(2);
    return 0;
}

关于行缓冲这个部分确实很迷惑人:(.

不带缓冲是指不对字符进行任何缓冲。通常对于标准错误来说，希望信息尽可能地快地显示 出来，所以不带缓冲。

对于Linux平台来说：

• 标准错误是不带缓冲的。
• 终端设备是行缓冲的。
• 其他都是全缓冲的。

也提供了API来设置缓冲模式：

//打开和关闭缓冲模式
//如果buf!=NULL,buf必须是BUFSIZE大小缓冲区，那么选择合适的缓冲模式
//如果buf==NULL,那么表示不带缓冲
void setbuf(FILE* restrict fp,char* restrict buf);

//mode可以执行什么缓冲模式
//如果不带缓冲，那么忽略buf和isze
//如果带缓冲，那么使用buf和size.如果buf==NULL,那么size=BUFSIZE
int setvbuf(FILE* restrict fp,char* restrict buf,int mode,size_t size);

关于fflush也之前也提过了，如果fflush传入参数为NULL的话，那么会刷出所有的输出流。

可以看到，标准IO提供了很多一次刷新所有输出流(fflush)和一次刷新所有行输出流，并且 如果程序退出之前没有关闭流的话，那么标准IO会自动帮助我们关闭。那么基本上可以了解， 在实现层面上，我们打开一个流对象，在标准IO都会进行簿记的。

打开流提供了下面这些函数：

//打开pathname
FILE* fopen(const char* restrict pathname,const char* restrict type);
//关闭fp,然后打开pathname,和fp进行关联
FILE* freopen(const char* restrict pathname,const char* restrict type,FILE* restrict fp);
//将打开的fd映射成为流
FILE* fdopen(int fd,const char* type);

通常来说freopen的用途是，将fp设置成为stdin,stdout或者是stderr,这样原来操作fprintf函数的话， 就可以直接关联到文件上面了，而不需要修改很多代码即可完成。

关于type有下面这几种枚举值

对于fdopen的type比较特殊，type不能够指定创建还是截断，并且关于读写模式必须和fd的属性相同。

因为标准IO内部只是维护一个缓冲区，如果读写交替的话，那么实际上会打乱内部buffer内容。 所以如果使用+打开的话，在交替输出和输入的时候，需要进行flush操作，可以使用下面这些函数：

• fseek
• fseeko
• fsetpos
• rewind
• fflush

关于流使用fclose函数，在文件关闭之前会冲洗缓冲区的输出数据，并且丢弃缓冲区的任何输入数据。 并且如果IO库已经分配一个缓冲区的话，那么需要显示地释放这块缓冲区。

包括下面这些：

long ftell(FILE* fp);
off_t ftello(FILE* fp);

//whence包括
//SEEK_SET 从头
//SEEK_CUR 当前
//SEEK_END 末尾
int fseek(FILE* fp,long offset,int whence);
int fseeko(FILE* fp,off_t offset,int whence);

//回到头部
void rewind(FILE* fp);

//如果移植到非UNIX平台建议使用
int fgetpos(FILE* restrict fp,fpos_t* restrict pos);
int fsetpos(FILE* fp,const fpos_t* pos);

其中ftello/ftell和fseeko/fseek之间的差别，就是类型不同，分别是off_t和long.

创建临时文件的接口有：

char* tmpnam(char* ptr);
FILE* tmpfile(void);
char* tempnam(const char* directory,const char* prefix);
int mkstemp(char* template);

tmpnam的ptr传入一个L_tmpnam长度的buf,然后会返回一个临时文件的名称，最多调用TMP_MAX次。

#include <cstdio>
int main(){
    char name[L_tmpnam];
    printf("%d\n",TMP_MAX);
    for(int i=0;i<10;i++){
        name[0]=0;
        tmpnam(name);
        printf("%s\n",name);
    }
    return 0;
}

临时文件目录都是在/tmp目录下面的

[dirlt@localhost.localdomain]$ ./main
238328
/tmp/fileroni3c
/tmp/filehspHQc
/tmp/file5Us9Dc
/tmp/file4gKJrc
/tmp/fileKgUsfc
/tmp/file3wqf3b
/tmp/fileTDb5Qb
/tmp/fileGCrXEb
/tmp/filexBfVsb
/tmp/filepoJVgb

tmpfile可以返回一个"wb+"打开临时文件流。基本上可以认为tmpfile是这样操作的：

• tmpname产生一个文件名
• 然后fopen(…,"wb+")打开
• 然后unlink这个文件

但是因为这种间存在一定的时间空隙，tmpfile保证原子操作行。并且注意到最后unlink了， 所以不需要用来自己删除文件:).

tempnam相对于tmpnam来说功能更强大，但是至于是否好用就不好说了。对于tempnam可以在 不同目录下面生成临时文件(顺序比较诡异):

• 如果有环境变量TMPDIR,那么在directory为TMPDIR.
• 如果directory不为NULL的话，那么使用directory.
• <cstdio>定义的P_tmpdir.

而prefix是最多包含5个字符的字符串。然后内部使用malloc来构造，所以最终需要自己释放。

#include <cstdio>
#include <cstdlib>
#include <unistd.h>
int main(){
    printf("%s\n",P_tmpdir);
    //只取前面5个字符
    char* p=tempnam("/var/tmp","helloworld");
    printf("%s\n",p);
    free(p);
    p=tempnam(NULL,"helloworld");
    printf("%s\n",p);
    free(p);
    return 0;
}

[dirlt@localhost.localdomain]$ ./main
/tmp
/var/tmp/hello7wVj3K
/tmp/helloqNEpql
[dirlt@localhost.localdomain]$ TMPDIR=/home/ ./main
/tmp
/home/hellopg7ANi
/home/hello1xmviW

mkstemp要求template是一个路径名称，最后面是6个XXXXXX,然后会修改这6个字符。然后 一旦创建成功之后返回文件描述符就可以使用。但是需要注意的是，mkstemp相对于tmpfile 并不会自动进行unlink,所以需要用户自己进行unlink.

口令文件存储于/ect/passwd下面，每一行是一个记录按照:进行分隔：

root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/spool/mail:/sbin/nologin
news:x:9:13:news:/etc/news:
uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
games:x:12:100:games:/usr/games:/sbin/nologin
gopher:x:13:30:gopher:/var/gopher:/sbin/nologin
ftp:x:14:50:FTP User:/:/sbin/nologin
nobody:x:99:99:Nobody:/:/sbin/nologin
dbus:x:81:81:System message bus:/:/sbin/nologin

之前提到过每个字段含义。可以看到密码都是使用x表示。如果不希望用户登录的话，那么提供 一个不存在的shell比如/sbin/noshell或者是/sbin/nologin.

所涉及到的结构和接口包括：

#include <pwd.h>
struct passwd {
    char    *pw_name;      /* user name */
    char    *pw_passwd;    /* user password */
    uid_t   pw_uid;        /* user id */
    gid_t   pw_gid;        /* group id */
    char    *pw_gecos;     /* real name */
    char    *pw_dir;       /* home directory */
    char    *pw_shell;     /* shell program */
};
//按照uid和name来进行查找
//内部实现可以理解为使用下面例程来完成的
struct passwd* getpwuid(uid_t uid);
struct passwd* getpwnam(const char* name);

//得到下一个entry.如果没有打开文件会自动打开
//不是线程安全的
struct passwd* getpwent(void);
//从头开始entry
void setpwent(void);
//关闭entry访问接口
void endpwent(void);

#include <pwd.h>
#include <cstdio>
int main(){
    setpwent();
    struct passwd* pw=getpwent();
    while(pw){
        printf("%s:%s:%d:%d:%s:%s:%s\n",
               pw->pw_name,pw->pw_passwd,pw->pw_uid,pw->pw_gid,
               pw->pw_gecos,pw->pw_dir,pw->pw_shell);
        pw=getpwent();
    }
    endpwent();
    return 0;
}

虽然密码是进行单向加密算法加密的，但是如果攻击者如果进行密码碰撞检测的话，并且配合 工程学的知识来破解的话，相对来说比较容易破解。所以之后Unix系统将单向加密值放在/etc/shadow 文件下面，这个文件只有root可以阅读。格式和/etc/shadow一样：

root:$1$s4hs87U1$ti.Gd2Nh/JiQ6L.SuSg7L1:14927:0:99999:7:::
dirlt:$1$BRt79uEo$PtCKwZNuUB7x5zyOKVRi00:14927:0:99999:7:::

访问结构和接口有下面这些：

#include <shadow.h>
struct spwd {
    char          *sp_namp; /* user login name */
    char          *sp_pwdp; /* encrypted password */
    long int      sp_lstchg; /* last password change */
    long int      sp_min; /* days until change allowed. */
    long int      sp_max; /* days before change required */
    long int      sp_warn; /* days warning for expiration */
    long int      sp_inact; /* days before account inactive */
    long int      sp_expire; /* date when account expires */
    unsigned long int  sp_flag; /* reserved for future use */
};
//使用name查找，底层还是调用下面拿几个函数
struct spwd* getspnam(const char* name);
struct spwd* getspent();
void setspent();
vodi endspent();

格式和/etc/passwd一样，最后一个字段按照,分开：

root:x:0:root
bin:x:1:root,bin,daemon
daemon:x:2:root,bin,daemon
sys:x:3:root,bin,adm
adm:x:4:root,adm,daemon
tty:x:5:
dirlt:x:500

结构和接口有下面这些：

#include <grp.h>
struct group {
    char   *gr_name;       /* group name */
    char   *gr_passwd;     /* group password */
    gid_t   gr_gid;        /* group ID */
    char  **gr_mem;        /* group members */
};
//按照gid和group name来检索
struct group* getgrgid(gid_t gid);
struct group* getgrnam(const char* name);
//遍历接口
struct group* getgrent();
void setgrent();
void endgrent();

#include <grp.h>
#include <cstdio>
int main(){
    setgrent();
    struct group *gp=getgrent();
    while(gp){
        printf("%s:%s:%d:",gp->gr_name,gp->gr_passwd,gp->gr_gid);
        if(*(gp->gr_mem)){
            while(*(gp->gr_mem+1)){
                printf("%s,",*(gp->gr_mem));
                gp->gr_mem++;
            }
            printf("%s",*(gp->gr_mem));
        }
        printf("\n");
        gp=getgrent();
    }
    endgrent();
    return 0;
}

其他数据文件所提供的接口和上面很相似，包括遍历接口和查找接口。

Unix提供了下面这两个数据文件utmp和wtmp.其中utmp记录当前登录进入系统的各个用户， 而wtmp是跟踪各个登录和注销事件，内部都是相同的二进制记录。在Linux系统上，两个 文件的存放位置分别是/var/run/utmp和/var/log/wtmp,查看man utmp可以查看二进制的 格式：

struct exit_status {
    short int e_termination;    /* process termination status */
    short int e_exit;           /* process exit status */
};

struct utmp {
    short ut_type;              /* type of login */
    pid_t ut_pid;               /* PID of login process */
    char ut_line[UT_LINESIZE];  /* device name of tty - "/dev/" */
    char ut_id[4];              /* init id or abbrev. ttyname */
    char ut_user[UT_NAMESIZE];  /* user name */
    char ut_host[UT_HOSTSIZE];  /* hostname for remote login */
    struct exit_status ut_exit; /* The exit status of a process
                                   marked as DEAD_PROCESS */

    /* The ut_session and ut_tv fields must be the same size when
       compiled 32- and 64-bit.  This allows data files and shared
       memory to be shared between 32- and 64-bit applications */
#if __WORDSIZE == 64 && defined __WORDSIZE_COMPAT32
    int32_t ut_session;         /* Session ID, used for windowing */
    struct {
        int32_t tv_sec;         /* Seconds */
        int32_t tv_usec;        /* Microseconds */
    } ut_tv;                    /* Time entry was made */
#else
    long int ut_session;        /* Session ID, used for windowing */
    struct timeval ut_tv;       /* Time entry was made */
#endif

    int32_t ut_addr_v6[4];       /* IP address of remote host */
    char __unused[20];           /* Reserved for future use */
};

登录时，login进程填写此结构，写入utmp和wtmp文件中，注销时init进程将utmp 文件中对应记录擦除并且增加一条新记录到wtmp文件中。并且在系统重启，修改系统 时间和日期之后，都会在wtmp文件中追加一条记录。

utmp和wtmp虽然都是二进制文件，但是Linux系统了系统命令可以用来查看这两个 文件，分别是who和last.:).

uname函数可以返回和当前主机和操作系统相关信息：

#include <sys/utsname.h>
int uname(struct utsname *buf);
struct utsname {
    char sysname[];
    char nodename[];
    char release[];
    char version[];
    char machine[];
#ifdef _GNU_SOURCE
    char domainname[];
#endif
};

需要注意的是nodename不能够用于引用网络通信主机，仅仅适用于引用UUCP网络上的主机。 如果需要返回TCP网络主机的话，可以使用gethostname这个函数：

#include <unistd.h>
int gethostname(char* name,int namelen);

#include <sys/utsname.h>
#include <unistd.h>
#include <cstdio>
int main(){
    struct utsname buf;
    uname(&buf);
    printf("sysname:%s\n"
           "nodename:%s\n"
           "release:%s\n"
           "version:%s\n"
           "machine:%s\n"
           "domainname:%s\n",
           buf.sysname,buf.nodename,
           buf.release,buf.version,
           buf.machine,buf.domainname);
    char host[128];
    gethostname(host,sizeof(host));
    printf("hostname:%s\n",host);
    return 0;
}

[dirlt@localhost.localdomain]$ ./main
sysname:Linux
nodename:localhost.localdomain
release:2.6.23.1-42.fc8
version:#1 SMP Tue Oct 30 13:55:12 EDT 2007
machine:i686
domainname:(none)
hostname:localhost.localdomain

Unix所提供的时间和日期是存放在一个量值里面的，就是time_t.表示从国际标准时间1970年 1月1日00:00:00至今的秒数，使用调用time可以获得。当然Unix也提供了一系列的函数来进行转换和本地化操作， 包括夏时制转换以及转换成为本地时区的时间。当然Unix也提供了更加精确到微妙的调用gettimeofday。

struct timeval{
    time_t tv_sec; //这个分量还是表示秒
    long tv_usec; //微秒
};

time_t是一个秒的概念，Unix还提供了下面结构可以表达日期时间概念：

struct tm {
    int tm_sec;         /* seconds */ //[0,60]60表示闰秒
    int tm_min;         /* minutes */
    int tm_hour;        /* hours */
    int tm_mday;        /* day of the month */
    int tm_mon;         /* month */
    int tm_year;        /* year */ //since 1900
    int tm_wday;        /* day of the week */
    int tm_yday;        /* day in the year */
    int tm_isdst;       /* daylight saving time */ //>0夏时制生效
};

当然得到这个结构用户还必须自己制作字符串，所以还有字符串表达方式(const char*)。

受TZ影响的意思是受环境变量TZ的影响，TZ可以用来定义我们系统所处的时区。

对于一个C程序来说，在调用main之前首先调用一个特殊例程，链接器在链接成为可执行程序的时候， 就将这个特殊例程设置成为程序起始地址。启动例程从内核中得到命令行参数和环境变量，然后调用main 函数。

有下面8中终止方式，其中5种为正常方式：

• main返回。好比调用exit(main(argc,argv))
• exit.
• _exit/_Exit
• 最后一个线程从启动例程返回。
• 最后一个线程调用pthread_exit.

异常终止有下面三种：

• abort.
• 接收到信号并且终止。
• 最后一个线程对取消请求作出响应。

exit和_exit/_Exit的差别在于，exit首先执行一段程序然后进入内核，而_exit/_Exit就直接立刻进入内核。 exit所作的事情包括执行atexit注册函数，冲刷标准IO流，关闭标准IO流等事情(但是文件描述符关闭放在内核完成). 参数是退出状态，然后进入内核之后退出状态结合进程自身结果，组合成为终止状态，返回给外部。关于 退出状态和终止状态会在下一章说明。_exit/_Exit之间没有差别，只不过_exit是POSIX定义的，而 _Exit是ISO C所定义的。

我们可以使用atexit来注册退出清理函数，个数是有上限的，而且允许重复设置。退出时候执行 顺序和设置时候顺序相反。

从历史上讲，C程序一直有下面这几个部分组成：

• 正文段(text).程序代码
• 初始化数据段(data).有初始化值的全局和静态变量
• 非初始化数据段(bss,block started by symbol).没有初始化值的全局和静态变量，初始化值为0。
• 栈(stack).
• 堆(heap).

典型的逻辑布局是：

| .text | .data | .bss | .heap(->) | zero block | (<-).stack | argv & environ |

其中.text被安排在低地址，而argv & environ被安排在高地址。堆栈按照不同的方向进行增长， 中间有一个非常大的zero block是没有被使用的虚拟内存，所有的mmap都是在这方面开辟的。

对于一个ELF文件来说，还有若干其他类型的短，比如包含符号表的段，调试信息的段和包含 动态共享库链接表的段，而这些端并不装载到进程执行的程序映像中。反过来说，对于 程序映像中，只有.text和.data段内容是在二进制文件里面保存的，而.bss是不保存的。 也没有必要，因为程序只需要知道这个段大小然后初始化为0即可。

使用size命令可以查看各个段大小：

[dirlt@localhost.localdomain]$ size /usr/bin/gcc /usr/libexec/gcc/i386-redhat-linux/4.1.2/cc1plus /bin/bash
   text    data     bss     dec     hex filename
 196215    4124       0  200339   30e93 /usr/bin/gcc
5893175   16584  544620 6454379  627c6b /usr/libexec/gcc/i386-redhat-linux/4.1.2/cc1plus
 707639   19416   19444  746499   b6403 /bin/bash

关于存储器的分配，包括两个区域存储分配，一个是heap一个是stack.对于heap来说， ISO C提供了下面这些函数来分配heap上空间：

• malloc
• calloc
• realloc

这些里面会调用sbrk或者是mmap系统调用，得到内存之后在用户态进行管理。对于sbrk 得到内存free不会释放回去，而调用mmap得到的内存会mumap回去。

对于stack来说，提供了两种方式，一种是函数一种是编译器的语法。函数是alloca而 语法就是varied length array(VLA)(只有gcc支持，g++不支持).

#include <alloca.h>
#include <string.h>
#include <stdio.h>

int main(){
    //alloca
    char* p=(char*)alloca(100);
    strcpy(p,"hello,world");
    printf("%s\n",p);

    //VLA
    int len=100;
    char p2[len];
    strcpy(p2,"hello,world");
    printf("%s\n",p2);
    return 0;
}

对于标准main函数界面应该是这样的：

int main(int argc,char* argv[],char* envp[]);

通常来说也可以不写第三个参数，而直接使用全局变量引用也可以extern char** environ.其中环境表 每个项的内容都是一个字符串，格式为"name=value",如果用户需要使用的话需要自己进行解析，或者是 使用getenv这样的接口来使用。

关于环境表操作有必要说说。环境表的接口有下面这些：

• char* getenv(const char* name);
• int putenv(const char* str);
• int setenv(const char* name,const char* value,int rewrite);
• int unsetenv(const char* name);

关于putenv和setenv的差别可以看到，因为环境表存放的是name=value这样的表示，而setenv提供的是 k,v单量，所以setenv内部是需要分配一个内存来合并name和value的。

在上一节看到了程序启动时候，参数和环境变量都是安排在内存空间高端的。这就造成一个问题，那就是 如果putenv和setenv需要添加环境表的内容怎么办？事实上这个问题也很好办，原则就是尽可能复用内存：

• 如果改写
  • 如果name=value长度更短，那么覆盖原空间。
  • 如果name=value长度更长，那么开辟新空间替换指针。
• 如果追加
  • 如果环境表项足够，那么开辟name=value并且填写指针。
  • 如果环境表项不够，那么重开一个环境表，然后开辟name=value并且填写指针。

局部跳转是指在一个函数内的跳转，可以使用goto.非局部跳转就是指函数之间的跳转了。使用的 函数是：

#include <setjmp.h>
int setjmp(jmp_buf env);
void longjmp(jmp_buf env,int val);

使用方式是，在一个地方setjmp得到当前jmp_buf内容并且返回0,表示第一次调用。如果使用 longjmp并且val!=0的话，那么调回这个位置时候，说明是非局部跳转。

#include <setjmp.h>
#include <stdio.h>
jmp_buf env;
void foo(){
    printf("ins 1\n");
    longjmp(env,1);
    printf("ins 2\n");
}
int main(){
    int ret=setjmp(env);
    if(ret==0){
        foo();
    }else if(ret==1){
        printf("jmp from foo\n");
    }
    return 0;
}

[dirlt@localhost.localdomain]$ ./main
ins 1
jmp from foo

对于非局部跳转的实现，仅仅是保存寄存器的内容。也就是说，如果变量被安排在寄存器上的话， 那么跳回去的时候，值是会回滚的。如果不希望回滚的话，那么就要声明变量是volatile的。 同时也可以看到，因为仅仅保存的是寄存器，所以如果跳转到函数的话，必须保证栈上内容没有被 修改

#include <setjmp.h>
#include <stdio.h>
#include <string.h>
jmp_buf main_env;
jmp_buf foo_env;
void foo(){
    char stack[16];
    strcpy(stack,"hello,world");
    if(setjmp(foo_env)==0){
        printf("%p,%x\n",stack,(unsigned char)stack[0]);
    }else{
        printf("%p,%x\n",stack,(unsigned char)stack[0]);
        longjmp(main_env,1);
    }
}
void foo2(){
    char stack[16];
    strcpy(stack,"hello,dirlt");
    printf("%s\n",stack);
}
int main(){
    if(setjmp(main_env)==0){
        foo();
        foo2();
        printf("jmp to foo again\n");
        longjmp(foo_env,1);
    }else{
        printf("jmp from foo\n");
    }
    return 0;
}

[dirlt@localhost.localdomain]$ ./main
0xbffc0d28,68
hello,dirlt
jmp to foo again
0xbffc0d28,b0
jmp from foo

可以看到调用foo2之后企图重新进入foo的话，结果是stack变量修改了。

每个进程都有一组资源限制，可以设置和查看这些资源限制。

#include <sys/resource.h>
int getrlimit(int resource,struct rlimit* limit);
int setrlimit(int resource,const struct rlimit* limit);
struct rlimit{
    rlim_t rlim_cur; //soft limit,current limit.
    rlim_t rlim_max; //hard limit,maximum value for rlim_cur.
};

对于资源限制分为硬限制和软限制，遵循下面三个规则：

• 任何进程都可以将软限制调整<=硬限制。
• 任何进程可以降低硬限制，但是必须>=软限制。
• 只有超级用户可以提高硬限制。

常量RLIM_INFINITY可以指定无限量限制。

关于resoruce有下面这几个常量：

对于RLIMIT_CPU来说，超过soft limit每秒发送SIGXCPU信号，如果超过hard limit发送SIGKILL。

[dirlt@localhost.localdomain]$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 4096
max locked memory       (kbytes, -l) 32
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 10240
cpu time               (seconds, -t) unlimited
max user processes              (-u) 4096
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

每个进程都有一个表示非负整数的唯一进程ID，但是这个ID是可以重复使用的。 Unix提供采用延迟重用算法，但是如果创建进程频繁的话，那么ID很快就会被重复使用。

在系统中有一些专用的进程。ID==0的进程通常是调度进程(swapper)是内核一部分， 并不执行任何磁盘上的程序，ID==1的进程是init进程，在自举过程结束时由内核调用， 负责在自举内核后启动一个Unix系统，早期版本是/etc/init较新版本是/sbin/init. 会读取/etc/rc*和/etc/inittab以及/etc/init.d中的文件，然后将系统引入一个状态。 ID==2是页守护进程(page daemon),负责支持虚拟存储系统的分页操作。

进程标识符接口有下面这些：

• getpid //pid
• getppid //parent pid
• getuid //实际用户id
• geteuid //有效用户id
• getgid //实际组id
• getegid //有效组id

我们使用fork/vfork可以开辟子进程：

#include <unistd.h>
//返回值==0表示子进程，>0表示父进程(表示子进程pid)
pid_t fork();
pid_t vfork();

fork之后，子进程和父进程各自执行自己的逻辑。刚分开的时候，两者的内存映像是相同的。 系统在实现的时候，并没有完全进行复制，而是使用COW(copy on write)的技术来解决的。 如果父子进程任意一个试图修改这些内存的话，那么会对修改页创建一个副本。对于POSIX 线程来说，fork的子进程之后包含了该fork出来的线程，而不是拥有所有线程的副本。

fork失败的原因通常有下面两种：

• 系统中已经存在太多的进程。
• 实际用户ID的进程总数已经超过了系统限制，CHILD_MAX.

fork出的子进程继承了父进程下面这些属性：

• uid,gid,euid,egid
• 附加组id,进程组id,会话id
• 设置用户id标记和设置组id标记
• 控制终端
• 当前工作目录/根目录
• 文件模式创建mask
• 文件描述符的文件标志(close-on-exec)
• 信号屏蔽和安排
• 存储映射
• 资源限制

下面是不同的部分：

• pid不同
• 进程时间被清空
• 文件锁没有继承
• 未处理信号被清空

fork通常一种使用方法就是之后执行exec程序，因为大部分时候做一个COW内存映像也是没有必要的。 vfork相对于fork就是这样一个差别，vfork子进程和父进程占用同一个内存映像，在子进程修改会影响父进程。 同时只有在子进程执行exec/exit之后才会运行父进程。

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(){
    int env=0;
    pid_t pid=vfork();
    if(pid==0){
        env=1;
        sleep(2);
        exit(0);
    }else{ //parent
        printf("parent are waiting...\n");
        printf("%d\n",env);
        return 0;
    }
}

[dirlt@localhost.localdomain]$ ./main
parent are waiting...
1

实际上子进程占用的栈空间就是父进程的栈空间，所以需要非常小心。如果vfork的子进程并没有 exec或者是exit的话，那么子进程就会执行父进程直到程序退出之后，父进程才开始执行。而这个 时候父进程的内存已经完全被写坏：

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(){
    int env=0;
    pid_t pid=vfork();
    if(pid==0){
        env=1;
        return 0;
    }else{ //parent
        printf("parent are waiting...\n");
        printf("%d\n",env);
        return 0;
    }
}

[dirlt@localhost.localdomain]$ ./main
parent are waiting...
6616584
Segmentation fault

库函数调用exit最终调用_exit函数时候，会关闭所有打开的文件描述符，并且释放它所使用 的存储器。_exit函数参数是退出状态，然后内核会转换成为终止状态交给父进程来进行处理。

如果父进程在子进程之前结束的话，那么内核如何将终止状态传回给父进程呢？这个时候子进程 已经没有父进程成为了孤儿进程。对于孤儿进程，内核会修改这个进程的父进程为init进程，操作 过程大致如下：每当一个进程终止时，内核会逐个检查所有活动进程，以判断它是否需要是正要 终止进程的子进程，如果是的话，那么修改ppid=1.

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(){
    int env=0;
    pid_t pid=fork();
    if(pid==0){
        sleep(2);
        printf("%d\n",getppid());
    }else{ //parent
    }
    return 0;
}

[dirlt@localhost.localdomain]$ ./main
[dirlt@localhost.localdomain]$ 1

另外一个情况是，如果子进程在父进程之前结束，父进程如何来获得子进程的终止状态呢？ 内核为每个终止子进程保存了一定的信息，父进程调用wait/waitpid就可以获得这些信息，包括进程 ID,终止状态以及占用CPU时间。对于一个终止但是父进程尚未进行处理的子进程，成为僵死 进程(zombie).而如果子进程变成孤儿进程由init托管后，是不会发生僵死进程的，因为init内部 会通过wait来处理。

+#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(){
    //创建僵死进程10个
    int i=0;
    for(i=0;i<10;i++){
        if(fork()==0){
            //child exit
            exit(0);
        }else{
            continue;
        }
    }
    //在这个时候挂起使用ps aux查看
    getchar();
    return 0;
}

dirlt     9472  0.0  0.1   1604   300 pts/0    T    17:04   0:00 ./main
dirlt     9473  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9474  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9475  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9476  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9477  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9478  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9479  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9480  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9481  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>
dirlt     9482  0.0  0.0      0     0 pts/0    Z    17:04   0:00 [main] <defunct>

当一个进程正常或者是异常终止的时候，内核就会向父进程发送一个SIGCHLD信号，父进程可以对 这个信号进行处理或者是忽略，默认情况下面是忽略。如果父进程需要处理的话，那么就可以调用 wait/waitpid来得到子进程终止状态。

两个函数接口是：

#include <sys/wait.h>
pid_t wait(int* statloc);
pid_t waitpid(pid_t pid,int* statloc,int options);

行为是这样的：

• 如果没有任何子进程结束，那么默认阻塞。
• 如果任一子进程终止的话，那么父状态得到这个子进程终止状态返回，而子进程资源可以回收。
• 如果没有任何子进程的话，那么出错返回。

对于waitpid是wait的升级版本，可以选择非阻塞返回，并且可以等待一个特定的子进程返回， 而不是只是等待第一个结束的子进程返回。

对于pid来说：

• ==-1.任意子进程
• >0.pid和pid相等的子进程
• ==0.组id和调用进程组id相同的任一子进程
• <0.组id等于pid的任一子进程

这个关系到进程组的概念，后面会提到。

对于statloc如果不为NULL的话，那么可以获得子进程终止状态，通过宏来处理这个值：

这里关系到作业控制概念，后面会提到。

对于options有下面几个值：

• WCONTINUED.
• WUNTRACED.
• WNOHANG.非阻塞的等待子进程结束。

之前提到了对于子进程结束的话，内核是会维护子进程的一些资源使用和终止状态的。对于wait/waitpid来说，只是 得到了终止状态信息，如果需要得到资源使用的饿话，那么可以使用wait3/wait4函数。这两个函数都是wait/waitpid 的升级版本。

pid_t wait3(int* statloc,int options,struct rusage* rusage);
pid_t wait4(pid_t pid,int* statloc,int options,struct rusage* rusage);

exec函数并不创建任何新进程，所以前后进程关系是没有发生任何改变的。exec所做的事情就是替换当前 正文段，数据，堆和栈。exec族函数包括：

int execl(const char* pathname,const char* arg0,...); //end with NULL
int execv(const char* pathname,char* const argv[]); //end with NULL
int execle(const char* pathname,const char* arg0,...);//end with NULL and char* const envp[]
int execve(const char* pathname,char* const argv[],char* const envp);
int execlp(const char* filename,const char* arg0,...); //end with NULL
int execvp(const char* filename,char* const argv[]); //end with NULL

对于exec来说，如果传入的是filename的话，那么：

• 如果包含/的话，那么认为这是一个路径名pathname
• 否则在PATH环境变量里面查找到第一个可执行文件
• 如果可执行文件不是链接器产生的话，那么认为是一个shell文件，使用/bin/sh执行

执行exec函数，下面属性是不发生变化的：

• 进程ID和父进程ID
• 实际用户ID和实际组ID
• 附加组ID
• 会话ID
• 控制终端
• 闹钟余留时间
• 当前工作目录
• 根目录
• umask
• 文件锁
• 进程信号屏蔽
• 未处理信号
• 资源限制
• 进程时间

而下面属性是发生变化的：

• 文件描述符如果存在close-on-exec标记的话，那么会关闭。
• 如果可执行程序存在设置用户ID和组ID位的话，那么有效用户ID和组ID会发生变化。

所涉及的函数包括下面几个：

#include <unistd.h>
int setuid(uid_t uid);
int setgid(gid_t gid);
//r for real,e for effective
int setreuid(uid_t ruid,uid_t euid);
int setregid(gid_t rgid,gid_t egid);
int seteuid(uid_t uid);
int setegid(gid_t gid);

组id和用户id在处理逻辑上面是等价的，所以这里只是说说对于uid的处理。

这里有必要说说保存设置用户ID的作用。保存设置用户ID判断是否存在是用过_SC_SAVED_IDS这个 选项来判断的。假设我们编写一个程序aaa,用户是dirlt,然后aaa的owner是root并且设置了设置uid位。 当我们exec这个aaa程序的话，我们ruid=dirlt,euid=root.因为ruid=dirlt,euid=root，那么如果进行 下面这样的操作的话seteuid修改有效用户id为dirlt是允许的，因为ruid就是dirlt. 这样ruid=dirlt,euid=dirlt.这样就造成了一个问题，如果我们想设置回来root系统如何验证呢？ 系统不可能再去读取一次文件系统，所以要求内核本身就保存一个设置用户id.可以看到设置用户id 通常保存的内容就是第一次exec文件使用的euid.

对于setuid(uid)行为是这样的：

• 如果是超级用户进程的话，那么ruid=uid,euid=uid,saved_id=uid.
• 如果不是超级用户进程的话，如果uid==实际用户id或者是保存设置id的话，那么euid=uid.
• 出错那么返回-1并且errno=EPERM.

对于setreuid不是很了解，对于seteuid来说和setuid差别不大，只不过超级用户也只是修改euid.

system函数使用起来非常方便，但是需要了解其中细节才可能用好。system本身实现大致就是

• fork/exec
• 使用命令/bin/sh -c来执行cmdstring
• 父进程使用waitpid得到结果

对于system的返回值有下面三种：

• 如果fork或者是waitpid返回除EINTR之外的错误，那么返回-1并且设置errno
• 如果exec失败的话，那么/bin/sh返回值相当执行exit(127).
• 如果都成功的话，那么返回命令的终止状态。

因为cmdstring是通过/bin/sh来执行的话，那么允许里面包含glob符号和重定向等shell字符。

值得一提的是，在waitpid出来之前，system使用wait函数来等待子进程返回，方式大概如下：

while((lastpid=wait(&status))!=pid && lastpid!=-1);

那么如果在system之前执行了一个子进程S，然后system启动。这在system的cmdstring之前 子进程S返回的话，那么相当于这个状态是丢弃的了。当system执行完毕之后，父进程 在外面wait子进程S的话，就会阻塞住，因为子进程S已经处理并且丢弃了。所以需要使用waitpid 这种有选择的等待子进程结束的方式。

还有需要注意的是，如果执行system的进程有效用户ID是0(root)的话，执行一个X没有设置设置uid 和gid位的话，因为system没有调用setuid和setgid接口，会导致X的有效用户ID是0(root)，因此在 使用system的时候需要特别小心。原理是：

//main.cc
#include <cstdio>
#include <cstdlib>
int main(int argc,char* const argv[]){
    system(argv[1]);
    return 0;
}

//echo.cc
#include <unistd.h>
#include <cstdio>
int main(){
    printf("ruid=%d,euid=%d\n",getuid(),geteuid());
    return 0;
}

[dirlt@localhost.localdomain]$ su root
口令：
[root@localhost doc]# chown root:root main
[root@localhost doc]# chmod +s ./main
[root@localhost doc]# ll
总计 536
-rw-r--r-- 1 dirlt dirlt  38697 05-24 06:52 Announce.org
-rw-r--r-- 1 dirlt dirlt 129914 05-24 15:48 APUE.html
-rw-r--r-- 1 dirlt dirlt  85116 05-26 09:33 APUE.org
-rw-r--r-- 1 dirlt dirlt  32766 04-19 16:36 BuildSystem.org
-rw-r--r-- 1 dirlt dirlt  12362 12-27 12:48 DesignPattern.org
-rwxr-xr-x 1 dirlt dirlt   5467 05-26 09:30 echo
-rw-r--r-- 1 dirlt dirlt    396 05-26 09:29 echo.cc
-rw-r--r-- 1 dirlt dirlt   4849 04-19 16:43 Encoding.org
-rw-r--r-- 1 dirlt dirlt   5370 04-20 19:22 GCCAssembly.org
-rw-r--r-- 1 dirlt dirlt   2343 04-25 11:07 GDB.org
-rw-r--r-- 1 dirlt dirlt  13423 03-09 08:47 HTML.org
-rw-r--r-- 1 dirlt dirlt   9021 04-26 11:58 Investment.org
-rwsr-sr-x 1 root  root    5254 05-26 09:33 main
-rw-r--r-- 1 dirlt dirlt    391 05-26 09:28 main.cc
-rw-r--r-- 1 dirlt dirlt    602 04-25 11:07 MultiThread.org
-rw-r--r-- 1 dirlt dirlt   9110 05-19 09:23 OProfile.org
-rw-r--r-- 1 dirlt dirlt   8310 04-25 11:07 PrinciplesOfEconomics.org
-rw-r--r-- 1 dirlt dirlt   9534 04-26 12:02 PurchaseHouse.org
-rw-r--r-- 1 dirlt dirlt   6617 05-17 07:30 RentHouse.org
-rw-r--r-- 1 dirlt dirlt  24906 04-16 18:29 SIMD.org
[root@localhost doc]# exit
exit
[dirlt@localhost.localdomain]$ ./main  ./echo
ruid=500,euid=500 //实际上这里并没有改变。如果按照上面阐述的话，应该euid=0
[dirlt@localhost.localdomain]$

对于bash2以上版本修复了这个问题。回想一下system调用的是/bin/sh这个命令，如果 /bin/sh发现有效用户和实际用户不匹配的话，会将有效用户设置成为实际用户。

为了验证另外一种情况

//main.cc
#include <cstdio>
#include <cstdlib>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main(int argc,char* const argv[]){
    pid_t pid=fork();
    if(pid==0){
        execlp(argv[1],argv[1],NULL);
    }else{
        waitpid(pid,NULL,0);
    }
    return 0;
}

[dirlt@localhost.localdomain]$ su root
口令：
[root@localhost doc]# chown root:root main
[root@localhost doc]# chmod +s main
[root@localhost doc]# exit
exit
[dirlt@localhost.localdomain]$ ./main ./echo
ruid=500,euid=0 //这个时候就修改成功了
[dirlt@localhost.localdomain]$

解释器文件是以#!开头的文件，格式是

#!pathname [optional-arguments]

假设文件是X,我们正准备执行./X arg0 arg1.那么shell会做如下处理：

• 识别出是解释器文件X
• 直接调用pathname [optional-arguments] X arg0 arg1

#include <cstdio>
int main(int argc,char* const argv[]){
    for(int i=0;i<argc;i++){
        printf("%s\n",argv[i]);
    }
    return 0;
}

#!./main hello world

[dirlt@localhost.localdomain]$ ./shell arg0 arg1
./main
hello world
./shell
arg0
arg1

使用解释器文件有下面这些好处。首先是隐藏内部细节。如果文件是python编写的话， 但是执行起来并没有调用python.对于用户来说就是一个可执行文件。其次和效率相关， 假设对于下面这个例子的两种写法：

#!/usr/bin/env python
print("hello,world")

/usr/bin/env python -c 'print("hello,world")'

前面一种是解释器写法，后面一种是非解释器写法。对于非解释器文件来说，如果使用./X 来执行的话，那么经过下面这几个步骤：

• shell尝试执行./X.(execlp)但是失败，发现这个是一个shell脚本文件。
• 那么会尝试启动/bin/sh来将这个文件作为输入，执行文件内容。

可以看到相比较解释器文件的话，首先execlp会尝试判断是否为shell脚本，这个部分会试错， 同时试错之后还要启动一个/bin/sh来执行shell脚本。另外一点可以看到，实际上我们 是最终拿/bin/sh来执行shell脚本的，问题是如果我们shell脚本中使用了一些其他shell 脚本特性的话，那么就会fail:(.

如果多个用户对应同样一个uid的话，那么我们这个时候就没有办法区分用户了。Unix系统 提供下面这个函数来得到登陆用户。如果调用此函数的进程没有连接到用户登录所使用 的终端的话，那么本函数会失败。通常来说这些进程就是守护进程daemon.

#include <unistd.h>
char* getlogin();

使用下面函数可以获得进程执行时间：

#include <unistd.h>
struct tms {
    clock_t tms_utime;  /* user time */
    clock_t tms_stime;  /* system time */
    clock_t tms_cutime; /* user time of children */
    clock_t tms_cstime; /* system time of children */
};
clock_t times(struct tms* buf); //返回wall clock time.但是需要通过差值来反映

为了转换成为秒数，需要使用sysconf(_SC_CLK_TCK)得到每秒钟多少个滴答数。

#note: 对于终端不是很了解，所以这里没有区分是从终端登录还是网络登录，只是统一说明为登录过程。但是介绍的时候，还是区分两种登录方式的。

首先看看终端登录过程，这个过程是BSD的，但是Linux基本相同：

• 管理员创建/etc/ttys文件，每个终端设备有一行表明设备名和getty启动参数。
• 系统自举创建init进程，init进程读取/etc/ttys文件，对每个终端fork并且exec gettty.
• getty打开终端设备，这样就映射到了文件描述符0,1,2.然后初始化环境，exec login.
• login基本功能就是读取用户密码，然后验证。如果失败的话，那么直接退出。
• 失败的话，那么init会接收到失败的信号，然后重新fork一个getty出来。

如果login成功的话，那么会执行下面这些动作：

• 更改目录为当前用户home目录
• chown终端权限所有权，使登录用户为所有者
• 将终端设备访问权限修改称为用户读写
• 调用setgid和initgroups设置进程的组id
• 设置环境变量，然后exec shell

bash启动之后会读取.bash_profile.这样用户最终的话，通过终端连接到终端设备驱动程序， 而终端设备的读写被映射成为0,1,2文件描述符被shell使用。用户操作终端的话，会被终端设备驱动程序接收到， 而对于shell来说，这些操作就是直接从0,1,2读取和写入数据。对于Linux来说，唯一不同的就是，对于 gettty启动过程参数不是在文件/etc/ttys而是在/etc/inittab里面描述的。

| shell | 终端设备驱动程序 | 用户 |

网络登录基本上和终端登录相同。不过init进程并不一开始就开辟多个getty进程，因为通过网络进程没有办法 估计有多少个用户登录，同时需要处理网络传输。init进程启动的是inted这个进程，inted监听某些登录端口， 假设用户通过telnet登录，inetd监听23端口。如果用户请求到达的话，那么会启动一个telnetd这个服务，好比getty, 只不过telnetd连接的是一个伪终端设备驱动程序，但是文件描述符依然是0,1,2.但是telnetd并不会直接exec login. 因为如果login执行失败的话，那么没有办法重新启动telnetd(注意现在login失败的话，那么父进程是init而不是telnetd). 所以telnetd通过fork一次，子进程exec login.如果子进程失败的话，那么父进程可以感知到。如果成功的话，那么和终端登录一样。

| shell | 伪终端设备驱动程序 | 用户 |

进程组是一个或者是多个进程的集合，通常和一个作业相关联，可以接受来自同一终端的各种信号。每个进程组有一个唯一的进程组ID, 也有一个组长进程，组长进程标识是组长进程id==进程组id.或者进程组id可以通过

pid_t getpgrp();
pid_t getpgid(pid_t pid); //如果pid==0,那么就是调用进程进程组id

进程组的存在和进程组长是否终止没有关系，进程组的生命周期是最后一个进程消亡或者是离开了进程组。

也可以使用

int setpgid(pid_t pid,pid_t pgid);

将pid的进程组id设置为pgid.pid==0的话，那么使用调用进程的pid,如果pgid==0的话，那么将pid设置为pgid.

会话是一个或者是多个进程组集合。进程可以通过调用

pid_t setsid();

来建立一个新会话。如果调用此函数的进程不是进程组长的话，那么就会创建一个新的会话。那么此时会：

• 该进程称为会话首进程(session leader).
• 该进程称为进程组组长.
• 该进程没有控制终端，即使之前有控制终端那么这种联系也会断掉。

我们使用第三个特性来创建daemon进程。调用getsid可以获得会话首进程进程组pid,也就是会话首进程进程id.

会话和进程组有一些其他特性，包括下面这些：

• 一个会话持有一个控制终端(controlling terminal)，可以是终端设备也可以是伪终端
• 建立与控制终端连接的会话首进程被称为控制进程(controlling process).
• 一个会话有多个进程组，允许存在多个后台进程组(backgroup process group)和一个前台进程组(foregroup process group).
• 键入终端的中断键(Ctrl+C)会发送中断信号给前台进程组所有进程。
• 键入终端的退出键(Ctrl+\)会发送退出信号给前台进程组所有进程。
• 终端或者是网络断开的话，那么会将挂断信号发送给会话首进程。

通常来说我们不必关心控制终端，因为在登录shell时候已经自动建立控制终端了。

查看当前shell使用的控制终端可以

[zhangyan@tc-cm-et18.tc.baidu.com]$ ps
  PID TTY          TIME CMD
23449 pts/18   00:00:00 bash
13311 pts/18   00:00:12 emacs
25278 pts/18   00:00:00 ps

通过控制终端可以设置前台进程组和获取前台进程组信息，以及获取会话首进程。设置了前台进程组的话， 这样终端设备驱动程序就可以知道终端输入和输出信号送到何处了。

pid_t tcgetpgrp(int fd);
int tcsetpgrp(int fd,pid_t pgrpid);
pid_t tcgetsid(int fd);

通常我们并不调用这些函数，作业控制通常交给shell来控制。这里fd必须引用的是控制终端。 通常来说在程序启动时候，0,1,2就引用了。

作业控制是在BSD后期版本加入的，允许一个终端上启动多个作业(进程组),控制哪一个作业可以访问该终端， 以及哪些作业是在后台运行的。作业控制我们大体接触到这些信号：

• SIGTSTP(Ctrl+Z)
• SIGINT(Ctrl+C)
• SIGQUIT(Ctrl+\)
• SIGHUP(终端断开或者是网络断开)
• SIGCONT(fg,将后台进程组切换到前台进程组)
• SIGTTIN
• SIGTTOUT

这几种信号之间会有交互作用，比如对一个进程产生四种停止信号(SIGTSTP,SIGSTOP,SIGTTIN,SIGTTOUT)那么就会 取消SIGCONT信号，而产生SIGCONT信号的话也会丢弃停止信号。

这里主要说说SIGTTIN和SIGTTOUT信号。如果一个后台进程组尝试读取控制终端的话，那么会产生一个SIGTTIN信号。 后台作业会停止，shell检测到后台作业状态发生变化的话，那么通知我们作业停止。同样如果准备写控制终端的话， 会产生SIGTTOUT信号，后台作业也会停止我们被通知到。不过大部分情况是，作业会直接写到终端上， 而之后shell会显示后台作业运行完毕。我们可以稍微调整一下控制终端行为，就可以看到这样的结果：

[zhangyan@tc-cm-et18.tc.baidu.com]$ cat >tmp.txt &
[2] 30493 //挂起
[zhangyan@tc-cm-et18.tc.baidu.com]$

[2]+  Stopped                 cat >tmp.txt //显示停止
[zhangyan@tc-cm-et18.tc.baidu.com]$

[zhangyan@tc-cm-et18.tc.baidu.com]$ cat tmp.txt &
[2] 30617
[zhangyan@tc-cm-et18.tc.baidu.com]$ hello,world

[2]-  Done                    cat tmp.txt
[zhangyan@tc-cm-et18.tc.baidu.com]$ stty tostop
[zhangyan@tc-cm-et18.tc.baidu.com]$ cat tmp.txt &
[2] 30643
[zhangyan@tc-cm-et18.tc.baidu.com]$

[2]+  Stopped                 cat tmp.txt
[zhangyan@tc-cm-et18.tc.baidu.com]$ fg
cat tmp.txt
hello,world
[zhangyan@tc-cm-et18.tc.baidu.com]$

如果我们使用设置前台进程组函数的话，那么一样可以看到这样的情况

#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <cstdio>
#include <cstdlib>

int main(){
    tcsetpgrp(STDIN_FILENO,getppid());
    char ch;
    read(STDIN_FILENO,&ch,sizeof(ch));
    return 0;
}

因为getppid()为shell的pid,当设置为前台进程的话我们继续从stdin读取的话，那么就会产生SIGTTIN信号， 然后stop掉，通知到父进程shell.然后shell告诉我们子进程停止了

[dirlt@localhost.localdomain]$ ./a.out

[2]+  Stopped                 ./a.out
[dirlt@localhost.localdomain]$ fg
./a.out
x
[dirlt@localhost.localdomain]

孤儿进程组定义为：该组中每个成员的父进程要么是该组的一个成员，要么不是该组所属会话的成员。 如果某个进程终止，使得某个进程组成为孤儿进程组的话，系统会向孤儿进程组里面每个处于停止状态进程发送一个SIGHUP信号， 然后发送SIGCONT信号。

#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <cstdio>
#include <cstdlib>

static void sig_hup(int signo){
    printf("SIGHUP received,pid=%d\n",getpid());
}
static void pr_ids(const char* name){
    printf("%s:pid=%d,ppid=%d,pgrp=%d,tpgrp=%d\n",
           name,getpid(),getppid(),getpgrp(),tcgetpgrp(STDIN_FILENO));
}
int main(){
    pr_ids("parent");
    pid_t pid;
    if((pid=fork())==0){//child
        pr_ids("child");
        signal(SIGHUP,sig_hup);
        //sleep(5);
        kill(getpid(),SIGTSTP);
        pr_ids("child");
        char c;
        if(read(STDIN_FILENO,&c,sizeof(c))==-1){
            printf("read from tty error,errno=%m\n");
        }
        exit(0);
    }else{
        //wait the child to install signal handler and send signal
        sleep(3);
        exit(0);
        printf("parent exit\n");
    }
}

[zhangyan@tc-cm-et18.tc.baidu.com]$ ./a.out
parent:pid=26510,ppid=23449,pgrp=26510,tpgrp=26510
child:pid=26511,ppid=26510,pgrp=26510,tpgrp=26510
SIGHUP received,pid=26511 //确实接收到了
child:pid=26511,ppid=1,pgrp=26510,tpgrp=26510 //但是SIGCONT被换到了前台进程了,所以tpgrp还是26510并且可读

如果我们这里不kill而是sleep,那么不会接收到SIGHUP信号。然后父进程作为进程组完成之后，前台进程切换到shell了， 这样造成read会存在错误。

[zhangyan@tc-cm-et18.tc.baidu.com]$ ./a.out
parent:pid=27218,ppid=23449,pgrp=27218,tpgrp=27218
child:pid=27219,ppid=27218,pgrp=27218,tpgrp=27218
[zhangyan@tc-cm-et18.tc.baidu.com]$ child:pid=27219,ppid=1,pgrp=27218,tpgrp=23449 //tpgrp为23449是shell的pid
read from tty error,errno=Input/output error

[zhangyan@tc-cm-et18.tc.baidu.com]$

信号定义在头文件<signal.h>里面并且都是正整数，没有为0的信号。但是kill对于信号0有着特殊应用。信号出现 情况有下面这些：

• 用户在控制终端按键
• 硬件异常产生信号
• kill
• 某种条件发生，比如SIGPIPE

信号是一个异步事件，我们不能够再某个点判断信号是否发生，而只能够告诉系统信号发生了我们应该怎么做：

• 忽略信号。但是SIGKILL和SIGSTOP是不可以忽略的，它们向超级用户提供了进程终止和停止的可靠方法。
• 捕捉系统。可以提供自定义函数来处理信号发生动作，但是不能够捕捉SIGKILL和SIGSTOP这两个信号。
• 执行系统默认动作，大多数系统默认动作是终止进程。

下面这些条件是不产生core文件的：

• 进程是设置用户ID或者是设置组ID的，但是程序文件的owner并不是当前用户。
• 用户没有写当前目录权限。
• core文件已经存在并且用户对文件有写权限。
• core文件过大超过允许core出大小。

对于SIGCHLD信号来说，如果忽略的话那么不会产生僵尸进程。子进程返回直接丢弃退出状态。 而父进程如果调用wait的话，那么会等待到最后一个子进程结束，然后返回-1并且errno=ECHILD.

int main(){
    //如果加上的话，那么ps aux看不出有任何僵死进程
    //如果不加上的话，那么存在僵尸进程
    signal(SIGCHLD,SIG_IGN);
    pid_t pid=fork();
    if(pid==0){//child
        exit(0);
    }else{
        for(;;){
            sleep(5);
        }
    }
    return 0;
}

对于SIGHUP信号来说，如果终端断开会传递给会话首进程。如果会话首进程终止，也会发送给前台进程组每一个进程。 对于守护进程来说，因为守护进程没有不关系到任何控制终端，所以可以利用这个信号来通知守护进程配置文件发生变化， 需要重新读取等自定义操作。

早期的Unix版本提供的信号机制是不可靠的。首先信号可能会丢失。也就是说信号发生但是进程却可能不知道这点。 signal设置信号处理之后，每次都会复位。那么在调用处理函数和安装这段时间内，信号是按照默认方式处理的。

void sig_handler(int signo){
    //这个时间片内，SIGUSR1是按照默认程序处理的
    //而默认处理方式是终止
    signal(SIGUSR1,sig_handler);
}

int main(){
    signal(SIGUSR1,sig_handler);
    return 0;
}

其次对于信号控制能力差，只是提供阻塞和忽略。如果我们想先阻塞完成之后查看有哪些pending的信号，这是满足不了的。

int flag;
void sig_handler(int signo){
    signal(SIGUSR1,sig_handler);
    flag=1;
}

int main(){
    signal(SIGUSR1,sig_handler);
    flag=0;
    //我们这里想仅当触发了SIGUSR1才退出
    while(flag==0){
        //但是在这个时间片内，触发了SIGUSR1但是却没有被pause处理
        pause();
    }
    return 0;
}

早期Unix特征是如果进程在执行一个低速的系统调用的时候，如果捕捉到了一个信号的话，那么会返回错误， errno=EINTR.理由是，一旦信号发生的话意味系统发生某些事情，那么是唤醒阻塞的系统调用好机会。

低速的系统调用，主要是针对那种很可能永久阻塞的系统调用，包括：

• 读写和打开某些类型文件(管道，终端和网络设备等)
• pause,wait以及某些ioctl操作

需要注意的是，磁盘文件并不属于低速系统调用范围。

对于存在中断的系统调用来说，我们必须显示处理中断情况写起来就相当恶心：

again:
    if((n=read(fd,buf,BUFFSIZE))<0){
        if(errno==EINTR){
            goto again;
        }
        //handle error
    }

为此4.2BSD引入了自动重启系统调用这个概念，不必处理被中断的系统调用。因为自动重启也可能带来问题， 所以4.3BSD允许进程基于每个信号来禁用自动重启功能。Linux系统默认也是自动重启，也支持基于信号来禁用自动重启。

假设我们正在执行函数A,而正在这个时候出发了信号处理函数，里面也调用了A.我们必须确保两次调用A的结果都完全正确。 如果保证调用完全正确的话，那么这个函数就是可重入函数。很明显可重入函数，对应着就是没有使用全局变量的函数。

这里我们需要区分可重入函数和线程安全函数。如果某个函数使用了全局变量，但是在全局变量访问部分保证串行访问的话， 那么这个函数就是线程安全函数。可重入函数必然是线程安全函数，而线程安全函数不一定是可重入函数。

我们首先看看可靠信号下面存在哪些术语：

• 产生(generation).当系统认为某个时间时候，那么向进程通知这个信号发生。
• 递送(delivery).当信号处理函数被调用时候，那么说向进程递送了这个信号。
• 未决(pending).信号产生和信号递送这段时间，信号是未决的。
• 阻塞(blocking).进程屏蔽某个信号，并且处理方式不是忽略的话，那么信号会一直保持未决状态。直到更改为忽略处理方式，或者是不屏蔽。
• 排队(queue).阻塞时候如果对应信号发生多次的话，那么信号会累加。不过大部分系统而言Unix并不排队，而只是保存一次。
• 递送顺序(delivery order).系统并没有规定如果多个信号发生，那么哪个信号会首先被递送。但是通常来说是关系到当前进程状态信号被处理，比如SIGSEGV.
• 信号屏蔽字(signal mask)和信号集(sigset).保存多个信号集合。

信号集是一堆信号的集合，POSIX.1定义了信号集上一系列操作。因为信号集的数量可能扩展，所以必须定义一个新的结构表示。 但是使用的应该是比较节省的方式，按照bit进行标记。

//sigset_t as the set of signals
int sigemptyset(sigset_t* set); //清空
int sigfillset(sigset_t* set); //填充
int sigaddset(sigset_t* set,int signo) //添加信号
int sigdelset(sigset_t* set,int signo) //删除信号
int sigismember(const sigset_t* set,int signo) //检查是否存在

线程使用线程id来标识自己，thread_t这个数据结构。我们不能够使用一种可移植的方式来打印该数据类型的值。

pthread_t pthread_sekf(); //获得自身的线程标识
int pthread_equal(pthread_t tid1,pthread_t tid2); //比较两个线程号是否相同

但是这个pthread_t仅仅是一个逻辑的标识而不是系统标识，为了获得系统标识的话可以调用gettid这个函数。gettid是一个内核调用。 如果我们阅读pthread代码的话可以发现一种不通过系统调用得到tid的方法。

默认情况下面我们可以使用gettid这个系统调用得到thread id.但是我们可以通过汇编来得到thread id 而不调用系统调用。这个内容在fs寄存器指向的段144个字节上，占用4个字节。至于为什么是在144字节上的话， 可以阅读nptl/descr.h里面pthread结构体代码，每个线程的fs寄存器指向内容就是这个结构体。

/* Thread descriptor data structure.  */
struct pthread
{
  union
  {
#if !TLS_DTV_AT_TP
    /* This overlaps the TCB as used for TLS without threads (see tls.h).  */
    tcbhead_t header;
#else
    struct
    {
      int multiple_threads;
    } header;
#endif

    /* This extra padding has no special purpose, and this structure layout
       is private and subject to change without affecting the official ABI.
       We just have it here in case it might be convenient for some
       implementation-specific instrumentation hack or suchlike.  */
    void *__padding[16];
  }; // 128字节

  /* This descriptor's link on the `stack_used' or `__stack_user' list.  */
  list_t list; // 2个指针，16个字节

  /* Thread ID - which is also a 'is this thread descriptor (and
     therefore stack) used' flag.  */
  pid_t tid; // 在这个地方

  /* Process ID - thread group ID in kernel speak.  */
  pid_t pid;

  // 省略后面字段
} __attribute ((aligned (TCB_ALIGNMENT)));

#include <linux/unistd.h>
_syscall0(pid_t,gettid)

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

pid_t user_gettid(){
    pid_t pid=0;
    __asm__ __volatile__(
        "movl %%fs:%c1,%0\n\t"
        :"=r"(pid)
        :"i"(144));
    return pid;
}
int main(){
    printf("%d\n",user_gettid());
    printf("%d\n",gettid());
}

创建接口为

//1.tidp表示创建的线程号
//2.attr表示线程属性
//3.线程入口
//4.线程入口的参数
int pthread_create(pthread_t* restrict tidp,const pthread_attr_t* restrict attr,void* (*start)(void*),void* restrict arg);

线程创建并不保证那个线程会首先运行，是新创建的线程还是调用线程。新创建的线程可以访问进程的地址空间， 并且集成了线程的浮点环境和信号屏蔽字，但是对于未决的信号都会进行丢弃。

如果希望多个线程里面某些部分只是执行一次的话，可以使用下面这个接口：

pthread_once_t initflag=PTHREAD_ONCE_INIT;
int pthread_once(pthread_once_t* initflag,void (*initfn)(void));

然后再每个线程里面调用pthread_once.下面是一个例子：

#include <unistd.h>
#include <pthread.h>
#include <cstdio>
#include <cmath>
#include <cstdlib>

pthread_once_t initflag=PTHREAD_ONCE_INIT;
void run_once(){
    printf("just run once\n");
}
void* foo(void* arg){
    pthread_once(&initflag,run_once);
}
int main(){
    pthread_t tid[10];
    for(int i=0;i<10;i++){
        pthread_create(tid+i,NULL,foo,(void*)(long)i);
    }
    for(int i=0;i<10;i++){
        pthread_join(tid[i],NULL);
    }
    return 0;
}

如果进程中任意线程调用了_exit,Exit,exit的话，或者是任意线程接收到了信号而处理动作是终止的话，那么整个进程就会终止。 对于单个线程只有以下面三种方式退出的话，才可能在不终止整个进程情况下面停止它的控制流：

• 线程只是从启动例程中返回，返回值是线程的退出码。
• 线程可以被同一进程中的其他线程取消。
• 线程调用pthread_exit.

void pthread_exit(void* ret_ptr); //返回ret_ptr
int pthread_join(pthread_t tid,void** ret_ptr); //得到ret_ptr内容
int pthread_cancel(pthread_t tid); //好比调用了pthread_exit(PTHREAD_CANCELED),只是通知线程而并不等待取消，是一个异步过程。
int pthread_detach(pthread_t tid);

对于pthread_join来说，直到指定的tid线程返回那么才返回。如果tid是取消的话，那么ret_ptr是PTHREAD_CANCELED. pthread_join好比wait调用。如果线程是一个detach状态的话，那么pthread_join马上就会失败返回EINVAL.

和进程使用atexit一样，线程也允许存在这种清理函数：

void pthread_cleanup_push(void (*func)(void*),void* arg);
void pthread_cleanup_pop(int execute); //非0表示立即执行,0表示不立即执行

通常来说这两个函数需要配对使用，因为很可能实现为宏。push包含{,而pop包含}.当线程返回的时候，那么就会触发push的函数：

void foo(void* arg){
    printf("%s\n",(char*)arg);
}
void* pthread_func(void* arg){
    pthread_cleanup_push(foo,(void*)"push1");
    pthread_cleanup_push(foo,(void*)"push2");
    for(;;){
        sleep(5);
    }
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    return NULL;
}

int main(){
    pthread_t tid;
    int ret=0;
    pthread_create(&tid,NULL,pthread_func,0);
    ret=pthread_detach(tid);
    if(ret){
        printf("pthread_detach:%s\n",strerror(ret));
    }
    ret=pthread_join(tid,NULL); //detach之后返回join返回EINVAL错误
    if(ret){
        printf("pthread_join:%s\n",strerror(ret));
    }
    pthread_cancel(tid);
    return 0;
}

[dirlt@localhost.localdomain]$ ./a.out
pthread_join:Invalid argument
push2
push1

关于线程同步，pthread提供了三种最基本的机制，分别是：

• 互斥锁
• 读写锁
• 条件变量

线程限制有下面这些方面：

关于第一个参数后面可以看到为什引入的。键使用来定位线程私有数据的。每个线程都是在特定的可用栈上进行的。

在创建线程的时候我们可以指定线程属性，接口是：

int pthread_attr_init(pthread_attr_t* attr);
int pthread_attr_destroy(pthread_attr_t* attr);

对于我们来说，pthread_attr_t接口并不是透明的。所以我们设置属性的话是通过其他API来完成的。POSIX.1定义的 线程属性包括下面这些：

可重入这个话题在信号处理已经讨论过了，可重入函数一定是线程安全函数，但是线程安全不一定是可重入的。如果 一个函数可在同一时刻被多个线程安全调用的话，那么这个函数就是线程安全的。对于一些线程不安全函数的，如果 操作系统需要支持线程安全性的话，那么会定义_POSIX_THREAD_SAFE_FUNCTIONS/_SC_THREAD_SAFE_FUNCTIONS，同时对于 一些线程不安全函数，提供一个线程安全的版本，通常以_r结尾。

标准IO提供了函数来保证操作标准IO是线程安全的：

int ftrylockfile(FILE* fp);
void flockfile(FILE* fp);
void funlockfile(FILE* fp);

但是实际上我们操作标准IO而言的话是不需要使用这些函数的，因为标准IO内部保证线程安全的。如果我们进行信号处理 多次fprintf的话不会hang住，所以内部实现应该是递归锁，在同一个线程内多次调用没有任何问题。标准IO默认提供递归锁 又引入了一个问题，那就是如果我们操作字符的时候，如果每次操作字符都要加锁那么代价是非常大的，所以标准IO还提供了另外 一个接口是允许不加锁的操作字符

#include <cstdio>
int getchar_unlocked();
int getc_unlocked(FILE* fp);
int putchar_unlocked();
int putc_unlocked(FILE* fp);

引入线程之后，我们就有必须重新考虑变量作用域的问题。在引入线程之前，我们有全局变量和局部变量。但是在多个线程情况下， 如果我们将线程当做一个单独实体的话，那么多出了一个作用域，就是相对于线程来说的全局变量。这种变量我们称为线程 私有数据。每个线程私有数据对应一个键，通过这个键来获取对线程私有数据的访问权。考虑如果没有这个线程私有数据的话， 那么我们线程里面每个函数都必须将这个对象作为参数传入，何其繁琐。

int pthread_key_create(pthread_key_t* keyp,void (*destructor)(void*));
int pthread_key_delete(pthread_key_t* key);
void* pthread_getspecific(pthread_key_t key);
int pthread_setspecific(pthread_key_t key,const void* value);

创建的键存放在keyp指向的内存单元，这个键可以被所有线程使用，但是不同线程将这个键关联到不同的线程私有数据上。 每个创建的键都设置了一个析构函数，如果为NULL的话那么析构函数不调用。当线程调用pthread_exit或者是线程执行返回的时候， 析构函数才会调用。key_delete只是释放key这个内存，并不会调用析构函数。

线程对于创建的键的数量是存在限制的，可以通过PTHREAD_KEYS_MAX来获得。线程退出时会尝试调用一次析构函数，如果所有键 绑定的值都已经释放为null的话，那么正常，否则还会尝试调用一次析构函数，直到尝试次数为PTHREAD_DESTRUCTOR_ITERATIONS次数。

线程分为是否可以取消，以及如果允许取消的话是延迟还是异步取消。设置线程取消可以通过：

//1.PTHREAD_CANCEL_ENABLE
//2.PTHREAD_CANCEL_DISABLE
int pthread_setcancelstate(int state,int* oldstate);

默认启动的时候线程是可以取消的。如果线程是不可以取消的话那么pthread_cancel不会杀死线程，只是进行标记。 直到线程变成ENABLE状态之后，在下一个取消点才会进行取消。

这里有一个术语就是取消点，取消点是线程检查是否被取消并且按照请求进行动作的一个位置。我们没有必要记住 所有的取消点，因为pthread本身就提供了一个取消点pthread_testcancel.如果线程允许取消的话，调用这个函数 会判断是否存在取消标记，如果有取消标记的话，那么就会停止线程。

取消时机也分延迟取消还是异步取消，延迟取消就是我们所看到的到达某个同步点才取消，而异步取消的话线程可以在 任意时间取消，而不是遇到取消点才取消。设置取消时机的接口是

//1.PTHREAD_CANCEL_DEFERRED
//2.PTHREAD_CANCEL_ASYNCHRONOUS
int pthread_setcanceltype(int type,int* oldtype);

每个线程有自己的信号屏蔽字，但是信号的处理是所有线程共享的。进程中的单个信号是递送到单个线程的，如果信号 与硬件故障或者是计时器相关的话，那么信号就会发送到引起该事件的线程中去，而其他的信号则被发送到任意一个线程中。 POSIX.1的线程模型中，异步信号被发送到进程以后，进程中当前没有阻塞该信号的某个线程来处理该信号。

每个线程有自己的信号屏蔽字，如果我们使用sigprocmask的话对于多线程是没有定义的。为此pthread提供了pthread_sigmask 来为每个线程提供线程的信号屏蔽字。此外线程还可以通过调用sigwait来等待一个或者是多个信号发生。语义和sigsuspend一样， 但是可以获得等待到的信号编号。sigwait会首先清除未决的信号，然后打开需要截获的信号，这也意味这在sigwait之前需要屏蔽 需要关心的信号，然后调用sigwait.

#include <signal.h>
int pthread_sigmask(int how,const sigset_t* restrict set,sigset_t* restrict oset);
int sigwait(const sigset_t* restrict set,int* restrict signop);

使用sigwait可以简化信号处理，允许把异步的信号用同步的方式处理。我们可以将正常线程屏蔽信号，然后只让某一个线程处理信号。 这样能够按照同步方式来处理信号，非常方便。

#include <unistd.h>
#include <signal.h>
#include <pthread.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
int quit_flag=0;
//此线程专门处理信号
void* signal_handler_thread(void* arg){
    sigset_t set;
    sigfillset(&set);
    pthread_sigmask(SIG_BLOCK,&set,NULL);
    sigemptyset(&set);
    sigaddset(&set,SIGINT);
    sigaddset(&set,SIGUSR1);
    sigaddset(&set,SIGUSR2);
    for(;;){
        int signo;
        sigwait(&set,&signo);
        //in a synchronous way.
        printf("%s received\n",strsignal(signo));
        if(signo==SIGINT){
            quit_flag=1;
            return NULL;
        }
    }
}
//main主线程非常轻松，屏蔽了所有的信号，
//而在专门的线程里面以一种同步的方式来处理信号
int main(){
    sigset_t set;
    sigfillset(&set);
    pthread_sigmask(SIG_BLOCK,&set,NULL);
    pthread_t tid;
    pthread_create(&tid,NULL,signal_handler_thread,NULL);
    for(;;){
        sleep(1);
        if(quit_flag==1){
            pthread_join(tid,NULL);
            return 0;
        }
    }
    return 0;
}

进程之间发送信号也是可以的。我们也可以传递信号0来判断线程是否存在。

#include <signal.h>
int pthread_kill(pthread_t thread,int signo);

注意闹钟定时器是进程资源，并且所有的线程共享相同的alarm.所以进程中的多个线程不可能互不干扰地使用闹钟定时器。

#note: 个人觉得相当无用而且异常繁琐。为了保证锁和条件变量的状态，使用到了pthread_atfork.

多线程IO下面读写文件的话，底层能够保证一次read/write的串行化，可以认为是一个原子操作。 但是需要考虑的是，线程需要lseek来定位的话，那么这就是一个非原子操作。因为在lseek和read/write之间的话， 位置可能已经发生了变化。我们可以通过系统调用pread/pwrite来满足我们的需求，这是两个原子操作。

我们只是打算对于pthread的API做一个简单的回顾，这样我们至少可以知道pthread到底可以做什么事情。 我们打算对于API分为下面这几个部分进行介绍。https://computing.llnl.gov/tutorials/pthreads/ 通读这些API之后，对realtime threads这个部分的很多内容不是很理解，包括clock_id,mutex下面protocol等。

产生一个daemon程序需要一系列的操作，步骤如下：

• umask(0).因为我们从shell创建的话，那么继承了shell的umask.这样导致守护进程创建文件会屏蔽某些权限。
• fork然后使得父进程退出。一方面shell认为父进程执行完毕，另外一方面子进程获得新的pid肯定不为进程组组长，这是setsid前提。
• setsid来创建新的会话。这时候进程称为会话首进程，称为第一个进程组组长进程同时失去了控制终端。
• 最好在这里再次fork。这样子进程不是会话首进程，那么永远没有机会获得控制终端。如果这里不fork的话那么会话首进程依然可能打开控制终端。
• 将当前工作目录更改为根目录。父进程继承过来的当前目录可能mount在一个文件系统上。如果不切换到根目录，那么这个文件系统不允许unmount.
• 关闭不需要的文件描述符。可以通过_SC_OPEN_MAX来判断最高文件描述符(不是很必须).
• 然后打开/dev/null复制到0,1,2(不是很必须).

void print_ids(const char* name){
    printf("%s:pid=%d,ppid=%d,pgid=%d,sid=%d\n",
           name,getpid(),getppid(),getpgid(0),getsid(0));
    //printf("%s\n",name);
}

void daemonize(){
    umask(0);
    pid_t pid=fork();
    if(pid!=0){
        exit(0);
    }
    sleep(1);
    print_ids("after fork()");
    setsid();
    print_ids("after setsid()");
    pid=fork();
    if(pid!=0){
        exit(0);
    }
    print_ids("after fork()");
    chdir("/");
    long v=sysconf(_SC_OPEN_MAX);
    for(long i=0;i<v;i++){
        close(i);
    }
    open("/dev/null",O_RDWR);
    dup(0);
    dup(0);
}

实验之后发现其实控制终端依然还是存在的并且依然可写(不过在关闭之后定位到/dev/null不可写了)。但是如果本次链接断开之后下次重新链接的话， 那么就会失去这个控制终端。其实似乎建立一个这样的东西完全没有必要这么麻烦，甚至最后面setsid和第二次fork都不需要，因为第一个子进程 已经成为一孤儿进程组，shell会话是不会影响到它的。

void daemonize(){
    umask(0);
    pid_t pid=fork();
    if(pid!=0){
        exit(0);
    }
    chdir("/");
    long v=sysconf(_SC_OPEN_MAX);
    for(long i=0;i<v;i++){
        close(i);
    }
    open("/dev/null",O_RDWR);
    dup(0);
    dup(0);
}

我们假设daemon不会将错误信息输出到终端上。如果我们只是写到一个单独的文件，那么非常难以管理。所以有必要有 一个集中设施来管理出错记录。BSD的syslog就是这个集中设施。设施大体分布是这样的：

• syslogd守护进程专门接受记录，然后决定写文件，本地或者发送到远程主机。配置文件是/etc/syslog.conf
• 用户进程通过syslog传递到syslogd,通信机制是unix domain socket,文件是/dev/log.
• TCP/IP可以通过访问UDP 514端口和syslogd通信提交日志。
• 内核例程通过log函数传递到syslogd,通信机制也是unix domain socket,文件是/dev/klog.

syslog的设施接口是下面这样的：

#include <syslog.h>
//facility通常为LOG_USER
void openlog(const char* ident,int option,int facility);
void syslog(int priority,const char* format,...); //priority是facility和level的组合
void closelog();
int setlogmask(int maskpri); //屏蔽的priority

如果我们直接使用syslog也是可以，但是这样会损失很多功能，所以还是很推荐使用openlog首先打开，然后再syslog这种方式。

看完这个之后我们看看一份syslog.conf的样例配置

# Log all kernel messages to the console.
# Logging much else clutters up the screen.
#kern.*							/dev/console
kern.*                                                  /var/log/kernel
# Log anything (except mail) of level info or higher.
# Don't log private authentication messages!
*.info;mail.none;authpriv.none;cron.none		/var/log/messages

# The authpriv file has restricted access.
authpriv.*						/var/log/secure

# Log all the mail messages in one place.
mail.*							-/var/log/maillog


# Log cron stuff
cron.*							/var/log/cron

# Everybody gets emergency messages
*.emerg							*

# Save news errors of level crit and higher in a special file.
uucp,news.crit						/var/log/spooler

# Save boot messages also to boot.log
local7.*						/var/log/boot.log
*.*             @tc-sys00.tc.baidu.com

可以看到每个项分两个部分，第一个是priority,第二个就是写的位置。如果*那么都会收到这个message.

#include <syslog.h>
int main(){
    openlog("FuckYourAss",0,LOG_EMERG);
    syslog(0,"%s\n","Fuck Your Ass!!!!");
    closelog();
}

守护进程通常单实例运行的，为了保证是单例运行的话，我们可以通过文件标记或者是文件锁来完成。 在Unix下面守护进程通常有下面这些惯例：

• 守护进程的锁文件，通常存放在/var/run/<name>.pid
• 如果守护进程有配置文件的话，那么文件存放在/etc/<name>.conf
• 守护进程可以使用命令行启动，但是通常是在系统初始化脚本之一存放在/etc/init.d/*下面。
• 守护进程终止的话我们通常希望重启。而守护进程的父进程通常为init.在/etc/inittab里面为守护进程包含_respawn选项的话，那么守护进程终止的话init会自动重启。
• 因为守护进程和终端不连接，所以永远接收不到SIGHUP信号。我们可以使用SIGHUP信号来通知守护进程重新载入配置文件。守护进程必须支持这个功能。

首先必须明确为什么需要引入非阻塞IO这个概念。因为系统调用存在低速系统调用，可能使进程永久阻塞住。 通常包括下面这些进程：

• 某些文件类型比如管道，终端设备和网络设备数据并不存在。
• 数据不能够被文件立即接受，比如管道无空间或者是网络流控制等。
• 打开某些类型文件比如调制解调器等等待应答。
• 对于文件加上了强制锁进行的读写。
• 某些ioctl操作。
• 某些进程间通信函数。

但是我们必须区分磁盘IO相关的系统调用，这些并不是低速系统调用。对于非阻塞IO操作的话，如果没有成功的话， 那么不会阻塞而是立即返回一个错误表示EAGAIN.

对于一个给定的描述符设置非阻塞IO属性的话，要不可以通过在open时候指定，要不通过fcntl来修改为O_NONBLOCK状态。

建议锁和强制锁之间的差别，建议锁更强调协作方面的特性只是一个软规定，而对于强制锁来说， 如果我们加上强制锁的话那么以阻塞方式来读写的话那么就一定会阻塞，是一个硬性规定。强制锁和建议锁底层都是记录锁。

#note: 我们这里不谈强制锁，似乎没有太大的作用。

记录锁(record locking)的功能是当一个进程正在读或者是修改文件的某一个部分的话，它可以阻塞其他进程修改 同一个文件区域。对于文件区域来说，是一个范围，可以锁几个字节也可以尝试锁一个文件。记录锁有下面这些属性：

• 进程终止时，进程建立的锁全部释放。
• 关闭任何一个描述符时，那么这个描述符可以引用的任何所都会被释放。
• fork出来的子进程继承文件描述符但是却不继承记录锁。
• exec之后会继承文件描述符和锁。但是如果文件标识设置了close-on-exec的话，那么会自动关闭。

这里可以看到，记录锁是和文件描述符以及进程相关联的。在具体实现可以看到为什么是这样的。

如果我们希望可以监视多个IO操作的话，那么会遇到一个问题。对于阻塞IO的话，我们必须安排一定的顺序来读取， 对于非阻塞IO的话我们必须耗费大量时间在轮询上。另外一种方式就是使用异步信号IO,但是它通常只是告诉我们 有文件描述符准备好了但是在信号处理部分我们还是要轮询一次。IO多路转接(IO multiplexing)就是用来解决这个问题的， 效果相当于构造一个文件描述符表，然后如果可读可写或者是发生异常的话就会返回一个准备好的fd集合。

异步IO是通过信号同时来实现的，并且异步IO对应的只有有限的几个信号。这样在信号处理函数中我们还必须仔细 判断哪些文件描述符是可读，可写或者是异常的。对于BSD派生出来的系统，使用的信号是SIGIO和SIGURG(猜想linux和bsd应该走得很近). SIGIO是通用异步信号，而SIGURG是用药通知进程在网络连接上有带外数据。为了使用SIGIO的话，需要执行下面三个步骤：

• 调用signal为SIGIO建立处理函数
• 使用F_SETOWN为fd设置进程和进程组。因为一旦fd触发信号的话，系统是要决定信号投递到哪个进程和进程组的。
• 使用F_SETFL来设置O_ASYNC文件状态标志。对于BSD来说仅仅用于终端或者是网络的描述符。

对于SIGURG只需要设置前面两个步骤，信号仅仅是用于支持带外数据的网络连接描述符产生的。

#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
#include <cstdio>
#include <cstring>

static int id=0;
void sig_handler(int signo){
    printf("%s received(%d)\n",strsignal(signo),id);
    id++;
}

int main(){
    signal(SIGIO,sig_handler);
    fcntl(0,F_SETOWN,getpid());
    fcntl(0,F_SETFL,fcntl(0,F_GETFL) | O_ASYNC);
    pause();
    return 0;
}

//发送多次SIGIO信号之后才被pause所捕获到
[dirlt@localhost.localdomain]$ ./a.out
1I/O possible received(0)
I/O possible received(1)
I/O possible received(2)
I/O possible received(3)
I/O possible received(4)
I/O possible received(5)
I/O possible received(6)
I/O possible received(7)
I/O possible received(8)
I/O possible received(9)
I/O possible received(10)
I/O possible received(11)
I/O possible received(12)
I/O possible received(13)
I/O possible received(14)