(十一) 一起学 Unix 环境高级编程 (APUE) 之 高级 IO

 1 fd = open("/etc/service", O_RDONLY | O_NONBLOCK);
 2 /* if error */
 3 
 4 while (1) {
 5     size = read(fd, buf, BUFSIZE);
 6     if (size < 0) {
 7         if (EAGAIN == errno) {
 8             continue;
 9         }
10         perror("read()");
11         exit(1);
12     }
13 
14     // do sth...
15 
16 }

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <unistd.h>
  4 #include <sys/types.h>
  5 #include <sys/stat.h>
  6 #include <fcntl.h>
  7 #include <errno.h>
  8 
  9 #define BUFSIZE        1024
 10 #define TTY1        "/dev/tty11"
 11 #define TTY2        "/dev/tty12"
 12 
 13 /* 状态机的各种状态 */
 14 enum
 15 {
 16     STATE_R=1,
 17     STATE_W,
 18     STATE_Ex,
 19     STATE_T
 20 };
 21 
 22 /* 状态机，根据不同的需求设计不同的成员 */
 23 struct fsm_st
 24 {
 25     int state; // 状态机当前的状态
 26     int sfd; // 读取的来源文件描述符
 27     int dfd; // 写入的目标文件描述符
 28     char buf[BUFSIZE]; // 缓冲
 29     int len; // 一次读取到的实际数据量
 30     int pos; // buf 的偏移量，用于记录坚持写够 n 个字节时每次循环写到了哪里
 31     char *errstr; // 错误消息
 32 };
 33 
 34 /* 状态机驱动 */
 35 static void fsm_driver(struct fsm_st *fsm)
 36 {
 37     int ret;
 38 
 39     switch(fsm->state)
 40     {
 41         case STATE_R: // 读态
 42             fsm->len = read(fsm->sfd,fsm->buf,BUFSIZE);
 43             if(fsm->len == 0) // 读到了文件末尾，将状态机推向 T态
 44                 fsm->state = STATE_T;
 45             else if(fsm->len < 0) // 读取出现异常
 46             {
 47                 if(errno == EAGAIN) // 如果是假错就推到 读态，重新读一次
 48                     fsm->state = STATE_R;
 49                 else // 如果是真错就推到 异常态
 50                 {
 51                     fsm->errstr = "read()";
 52                     fsm->state = STATE_Ex;
 53                 }
 54             }
 55             else // 成功读取到了数据，将状态机推到 写态
 56             {
 57                 fsm->pos = 0;
 58                 fsm->state = STATE_W;
 59             }
 60             break;
 61 
 62         case STATE_W: // 写态
 63             ret = write(fsm->dfd,fsm->buf+fsm->pos,fsm->len);
 64             if(ret < 0) // 写入出现异常
 65             {
 66                 if(errno == EAGAIN) // 如果是假错就再次推到 写态，重新再写入一次
 67                     fsm->state = STATE_W;
 68                 else // 如果是真错就推到 异常态
 69                 {
 70                     fsm->errstr = "write()";
 71                     fsm->state = STATE_Ex;
 72                 }
 73             }
 74             else // 成功写入了数据
 75             {
 76                 fsm->pos += ret;
 77                 fsm->len -= ret;
 78                 if(fsm->len == 0) // 如果将读到的数据完全写出去了就将状态机推向 读态，开始下一轮读取
 79                     fsm->state = STATE_R;
 80                 else // 如果没有将读到的数据完全写出去，那么状态机依然推到 写态，下次继续写入没写完的数据，实现“坚持写够 n 个字节”
 81                     fsm->state = STATE_W;
 82             }
 83 
 84             break;
 85     
 86         case STATE_Ex: // 异常态，打印异常并将状态机推到 T态
 87             perror(fsm->errstr);
 88             fsm->state = STATE_T;
 89             break;
 90 
 91         case STATE_T: // 结束态，在这个例子中结束态没有什么需要做的事情，所以空着
 92             /*do sth */
 93             break;
 94         default: // 程序很可能发生了溢出等不可预料的情况，为了避免异常扩大直接自杀
 95             abort();
 96     }
 97 
 98 }
 99 
100 /* 推动状态机 */
101 static void relay(int fd1,int fd2)
102 {
103     int fd1_save,fd2_save;    
104     // 因为是读 tty1 写 tty2；读 tty2 写 tty1，所以这里的两个状态机直接取名为 fsm12 和 fsm21
105     struct fsm_st fsm12,fsm21;
106 
107     fd1_save = fcntl(fd1,F_GETFL);
108     // 使用状态机操作 IO 一般都采用非阻塞的形式，避免状态机被阻塞
109     fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);
110     fd2_save = fcntl(fd2,F_GETFL);
111     fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);
112 
113     // 在启动状态机之前将状态机推向 读态
114     fsm12.state = STATE_R;
115     // 设置状态机中读写的来源和目标，这样状态机的读写接口就统一了。在状态机里面不用管到底是 读tty1 写tty2 还是 读tty2 写tty1 了，它只需要知道是 读src 写des 就可以了。
116     fsm12.sfd = fd1;
117     fsm12.dfd = fd2;
118 
119     // 同上
120     fsm21.state = STATE_R;
121     fsm21.sfd = fd2;
122     fsm21.dfd = fd1;
123 
124 
125     // 开始推状态机，只要不是 T态 就一直推
126     while(fsm12.state != STATE_T || fsm21.state != STATE_T)
127     {
128         // 调用状态机驱动函数，状态机开始工作
129         fsm_driver(&fsm12);
130         fsm_driver(&fsm21);
131     }
132 
133     fcntl(fd1,F_SETFL,fd1_save);
134     fcntl(fd2,F_SETFL,fd2_save);
135     
136 }
137 
138 int main()
139 {
140     int fd1,fd2;
141 
142     // 假设这里忘记将设备 tty1 以非阻塞的形式打开也没关系，因为推动状态机之前会重新设定文件描述符为非阻塞形式
143     fd1 = open(TTY1,O_RDWR);
144     if(fd1 < 0)
145     {
146         perror("open()");
147         exit(1);
148     }
149     write(fd1,"TTY1\n",5);
150     
151     fd2 = open(TTY2,O_RDWR|O_NONBLOCK);
152     if(fd2 < 0)
153     {
154         perror("open()");
155         exit(1);
156     }
157     write(fd2,"TTY2\n",5);
158 
159 
160     relay(fd1,fd2);
161 
162 
163     close(fd1);
164     close(fd2);
165 
166 
167     exit(0);
168 }

 1 select,  FD_CLR,  FD_ISSET, FD_SET, FD_ZERO - synchronous I/O multiplexing
 2 
 3 /* According to POSIX.1-2001 */
 4 #include <sys/select.h>
 5 
 6 /* According to earlier standards */
 7 #include <sys/time.h>
 8 #include <sys/types.h>
 9 #include <unistd.h>
10 
11 int select(int nfds, fd_set *readfds, fd_set *writefds,
12            fd_set *exceptfds, struct timeval *timeout);
13 
14 void FD_CLR(int fd, fd_set *set);
15 int  FD_ISSET(int fd, fd_set *set);
16 void FD_SET(int fd, fd_set *set);
17 void FD_ZERO(fd_set *set);

 1 enum
 2 {
 3     STATE_R=1,
 4     STATE_W,
 5 STATE_AUTO, // 添加这个值是为了起到分水岭的作用，小于这个值的时候才需要使用 select(2) 监视
 6     STATE_Ex,
 7     STATE_T
 8 };
 9 
10 static int max(int a,int b)
11 {
12     if(a < b)
13         return b;
14     return a;
15 }
16 
17 static void relay(int fd1,int fd2)
18 {
19     int fd1_save,fd2_save;    
20     struct fsm_st fsm12,fsm21;
21     fd_set rset,wset; // 读写文件描述符集合
22 
23     fd1_save = fcntl(fd1,F_GETFL);
24     fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);
25     fd2_save = fcntl(fd2,F_GETFL);
26     fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);
27 
28     fsm12.state = STATE_R;
29     fsm12.sfd = fd1;
30     fsm12.dfd = fd2;
31 
32     fsm21.state = STATE_R;
33     fsm21.sfd = fd2;
34     fsm21.dfd = fd1;
35 
36 
37     while(fsm12.state != STATE_T || fsm21.state != STATE_T)
38     {
39         //布置监视任务
40         FD_ZERO(&rset);
41         FD_ZERO(&wset);
42 
43         // 读态监视输入文件描述符；写态监视输出文件描述符
44         if(fsm12.state == STATE_R)
45             FD_SET(fsm12.sfd,&rset);
46         if(fsm12.state == STATE_W)
47             FD_SET(fsm12.dfd,&wset);
48         if(fsm21.state == STATE_R)
49             FD_SET(fsm21.sfd,&rset);
50         if(fsm21.state == STATE_W)
51             FD_SET(fsm21.dfd,&wset);
52 
53         if(fsm12.state < STATE_AUTO || fsm21.state < STATE_AUTO)
54         {
55             // 以阻塞形式监视
56             if(select(max(fd1,fd2)+1,&rset,&wset,NULL,NULL) < 0)
57             {
58                 if(errno == EINTR)
59                     continue;
60                 perror("select()");
61                 exit(1);
62             }
63         }
64 
65         //查看监视结果
66         if( FD_ISSET(fd1,&rset) || FD_ISSET(fd2,&wset) || fsm12.state > STATE_AUTO)
67             fsm_driver(&fsm12);
68         if( FD_ISSET(fd2,&rset) || FD_ISSET(fd1,&wset) || fsm21.state > STATE_AUTO)
69             fsm_driver(&fsm21);
70     }
71 
72     fcntl(fd1,F_SETFL,fd1_save);
73     fcntl(fd2,F_SETFL,fd2_save);
74     
75 }

 1 poll - wait for some event on a file descriptor
 2 
 3 #include <poll.h>
 4 
 5 int poll(struct pollfd *fds, nfds_t nfds, int timeout);
 6 
 7 struct pollfd {
 8     int   fd;         /* 需要监视的文件描述符 */
 9     short events;     /* 要监视的事件 */
10     short revents;    /* 该文件描述符发生了的事件 */
11 };

 1 static void relay(int fd1,int fd2)
 2 {
 3     int fd1_save,fd2_save;    
 4     struct fsm_st fsm12,fsm21;
 5     struct pollfd pfd[2]; // 一共监视两个文件描述符
 6 
 7 
 8     fd1_save = fcntl(fd1,F_GETFL);
 9     fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);
10     fd2_save = fcntl(fd2,F_GETFL);
11     fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);
12 
13     fsm12.state = STATE_R;
14     fsm12.sfd = fd1;
15     fsm12.dfd = fd2;
16 
17     fsm21.state = STATE_R;
18     fsm21.sfd = fd2;
19     fsm21.dfd = fd1;
20 
21     pfd[0].fd = fd1;
22     pfd[1].fd = fd2;
23 
24     while(fsm12.state != STATE_T || fsm21.state != STATE_T)
25     {
26         // 布置监视任务
27         pfd[0].events = 0;
28         if(fsm12.state == STATE_R)
29             pfd[0].events |= POLLIN; // 第一个文件描述符可读
30         if(fsm21.state == STATE_W)    
31             pfd[0].events |= POLLOUT; // 第一个文件描述符可写
32 
33         pfd[1].events = 0;
34         if(fsm12.state == STATE_W)
35             pfd[1].events |= POLLOUT; // 第二个文件描述符可读
36         if(fsm21.state == STATE_R)
37             pfd[1].events |= POLLIN; // 第二个文件描述符可写
38 
39         // 只要是可读写状态就进行监视
40         if(fsm12.state < STATE_AUTO || fsm21.state < STATE_AUTO)
41         {
42             // 阻塞监视
43             while(poll(pfd,2,-1) < 0)
44             {
45                 if(errno == EINTR)
46                     continue;
47                 perror("poll()");
48                 exit(1);
49             }
50         }
51 
52         // 查看监视结果
53         if( pfd[0].revents & POLLIN || 54             pfd[1].revents & POLLOUT || 55             fsm12.state > STATE_AUTO)
56             fsm_driver(&fsm12); // 推状态机
57         if( pfd[1].revents & POLLIN || 58             pfd[0].revents & POLLOUT || 59             fsm21.state > STATE_AUTO)
60             fsm_driver(&fsm21); // 推状态机
61     }
62 
63     fcntl(fd1,F_SETFL,fd1_save);
64     fcntl(fd2,F_SETFL,fd2_save);
65     
66 }

1 epoll_create - open an epoll file descriptor
2 
3 #include <sys/epoll.h>
4 
5 int epoll_create(int size);

 1 epoll_ctl - control interface for an epoll descriptor
 2 
 3 #include <sys/epoll.h>
 4 
 5 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
 6 
 7 
 8 struct epoll_event {
 9        uint32_t events; /* Epoll 监视的事件，这些事件与 poll(2) 能监视的事件差不多，只是宏名前面加了个E */
10        epoll_data_t data; /* 用户数据，除了能保存文件描述符以外，还能让你保存一些其它有关数据，比如你这个文件描述符是嵌在一棵树上的，你在使用它的时候不知道它是树的哪个节点，则可以在布置监视任务的时候将相关的位置都保存下来。这个联合体成员就是 epoll 设计的精髓。 */
11 };

1 epoll_wait  -  wait  for  an  I/O  event on an epoll file descriptor
2 
3 #include <sys/epoll.h>
4 
5 int epoll_wait(int epfd, struct epoll_event *events,
6                int maxevents, int timeout);

 1 static void relay(int fd1,int fd2)
 2 {
 3     int fd1_save,fd2_save;    
 4     struct fsm_st fsm12,fsm21;
 5     int epfd;
 6     struct epoll_event ev;
 7 
 8     epfd = epoll_create(10);
 9     if(epfd < 0)
10     {
11         perror("epfd()");
12         exit(1);
13     }
14 
15     fd1_save = fcntl(fd1,F_GETFL);
16     fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);
17     fd2_save = fcntl(fd2,F_GETFL);
18     fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);
19 
20     fsm12.state = STATE_R;
21     fsm12.sfd = fd1;
22     fsm12.dfd = fd2;
23 
24     fsm21.state = STATE_R;
25     fsm21.sfd = fd2;
26     fsm21.dfd = fd1;
27 
28     ev.events = 0;
29     ev.data.fd = fd1;
30     epoll_ctl(epfd,EPOLL_CTL_ADD,fd1,&ev);
31     
32     ev.events = 0;
33         ev.data.fd = fd2;
34         epoll_ctl(epfd,EPOLL_CTL_ADD,fd2,&ev);
35 
36 
37     while(fsm12.state != STATE_T || fsm21.state != STATE_T)
38     {
39         // 布置监视任务
40 
41         ev.events = 0;
42         ev.data.fd = fd1;
43         if(fsm12.state == STATE_R)
44             ev.events |= EPOLLIN;
45         if(fsm21.state == STATE_W)    
46             ev.events |= EPOLLOUT;
47         epoll_ctl(epfd,EPOLL_CTL_MOD,fd1,&ev);
48 
49         ev.events = 0;
50         ev.data.fd = fd2;
51         if(fsm12.state == STATE_W)
52             ev.events |= EPOLLOUT;
53         if(fsm21.state == STATE_R)
54             ev.events |= EPOLLIN;
55         epoll_ctl(epfd,EPOLL_CTL_MOD,fd2,&ev);
56 
57         // 监视
58         if(fsm12.state < STATE_AUTO || fsm21.state < STATE_AUTO)
59         {
60             while(epoll_wait(epfd,&ev,1,-1) < 0)
61             {
62                 if(errno == EINTR)
63                     continue;
64                 perror("epoll_wait()");
65                 exit(1);
66             }
67         }
68 
69         // 查看监视结果
70         if( ev.data.fd == fd1 && ev.events & EPOLLIN || 71             ev.data.fd == fd2 && ev.events & EPOLLOUT || 72             fsm12.state > STATE_AUTO)
73             fsm_driver(&fsm12);
74         if( ev.data.fd == fd2 && ev.events & EPOLLIN || 75             ev.data.fd == fd1 && ev.events & EPOLLOUT  || 76             fsm21.state > STATE_AUTO)
77             fsm_driver(&fsm21);
78     }
79 
80     fcntl(fd1,F_SETFL,fd1_save);
81     fcntl(fd2,F_SETFL,fd2_save);
82     
83     close(epfd);
84 
85 }

 1 readv,  writev  -  read  or write data into multiple buffers
 2 
 3 #include <sys/uio.h>
 4 
 5 ssize_t readv(int fd, const struct iovec *iov, int iovcnt);
 6 
 7 ssize_t writev(int fd, const struct iovec *iov, int iovcnt);
 8 
 9 struct iovec {
10         void  *iov_base;    /* 起始地址 */
11         size_t iov_len;     /* Number of bytes to transfer */
12 };

 1 mmap, munmap - map or unmap files or devices into memory
 2 
 3 #include <sys/mman.h>
 4 
 5 void *mmap(void *addr, size_t length, int prot, int flags,
 6            int fd, off_t offset);
 7 int munmap(void *addr, size_t length);

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <sys/mman.h>
 4 #include <sys/types.h>
 5 #include <sys/stat.h>
 6 #include <unistd.h>
 7 #include <fcntl.h>
 8 
 9 
10 #define FNAME        "/etc/services"
11 
12 int main(void)
13 {
14     int fd,i;
15     char *str;
16     struct stat statres;
17     int count = 0;
18 
19     fd = open(FNAME,O_RDONLY);    
20     if(fd < 0)
21     {
22         perror("open()");
23         exit(1);
24     }
25 
26     // 通过 stat(2) 获得文件大小
27     if(fstat(fd,&statres) < 0)
28     {
29         perror("fstat()");
30         exit(1);
31     }
32 
33     str = mmap(NULL,statres.st_size,PROT_READ,MAP_SHARED,fd,0);
34     if(str == MAP_FAILED)
35     {
36         perror("mmap()");
37         exit(1);
38     }
39 
40     // 将文件映射到内存之后文件描述符就可以关闭了，直接访问映射的内存就相当于访问文件了。
41     close(fd);
42 
43     for(i = 0 ; i < statres.st_size; i++) {
44         // 因为访问的是文本文件，所以可以把映射的内存看作是一个大字符串处理
45         if(str[i] == ‘a‘) {
46             count++;
47         }
48     }
49     
50     printf("count = %d\n",count);
51 
52     // 用完了别忘了解除映射，不然会造成内存泄漏！
53     munmap(str,statres.st_size);
54 
55     exit(0);
56 }

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <sys/mman.h>
 4 #include <sys/types.h>
 5 #include <sys/stat.h>
 6 #include <unistd.h>
 7 #include <fcntl.h>
 8 #include <string.h>
 9 #include <wait.h>
10 
11 #define MEMSIZE        1024
12 
13 int main(void)
14 {
15     char *str;
16     pid_t pid;
17 
18     // 这里在 flags 中添加 MAP_ANONYMOUS，为制作共享内存做准备
19     str = mmap(NULL,MEMSIZE,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0);
20     if(str == MAP_FAILED)
21     {
22         perror("mmap()");
23         exit(1);
24     }
25 
26     // 创建子进程，父子进程使用共享内存进行通信
27     pid = fork();
28     if(pid < 0)
29     {
30         perror("fork()");
31         exit(1);
32     }
33     if(pid == 0) // 子进程向共享内存中写入数据
34     {
35         strcpy(str,"Hello!");
36         munmap(str,MEMSIZE); // 注意，虽然共享内存是在 fork(2) 之前创建的，但是 fork(2) 的时候子进程也拷贝了一份，所以子进程使用完毕之后也要解除映射
37         exit(0);
38     }
39     else // 父进程从共享内存中读取子进程写入的数据
40     {
41         wait(NULL); // 保障子进程先运行起来，因为就算父进程先运行了也会在这里阻塞等待
42         puts(str); // 把从共享内存中读取出来的数据打印出来
43         munmap(str,MEMSIZE); // 不要忘记解除映射
44         exit(0);
45     }
46 
47 
48     exit(0);
49 }

 1 lockf - apply, test or remove a POSIX lock on an open file
 2 
 3 #include <unistd.h>
 4 
 5 int lockf(int fd, int cmd, off_t len);
 6 
 7 flock - apply or remove an advisory lock on an open file
 8 
 9 #include <sys/file.h>
10 
11 int flock(int fd, int operation);

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <string.h>
 4 #include <unistd.h>
 5 #include <wait.h>
 6 #include <sys/types.h>
 7 
 8 
 9 #define PROCNUM        20    
10 #define FNAME        "/tmp/out"
11 #define BUFSIZE        1024
12 
13 
14 static void func_add()
15 {
16     FILE *fp;
17     int fd;
18     char buf[BUFSIZE];
19     
20     fp = fopen(FNAME,"r+");    
21     if(fp == NULL)
22     {
23         perror("fopen()");
24         exit(1);
25     }
26 
27     fd = fileno(fp);
28     if(fd < 0)
29     {
30         perror("fd");
31         exit(1);
32     }
33 
34     // 使用之前先锁定
35     lockf(fd,F_LOCK,0);
36 
37     fgets(buf,BUFSIZE,fp);
38     rewind(fp); // 把文件位置指针定位到文件首
39     sleep(1); // 放大竞争
40     fprintf(fp,"%d\n",atoi(buf)+1);
41     fflush(fp);
42 
43     // 使用之后释放锁
44     lockf(fd,F_ULOCK,0);
45 
46     fclose(fp);
47 
48     return ;
49 }
50 
51 int main(void)
52 {
53     int i;
54     pid_t pid;
55     
56     for(i = 0 ; i < PROCNUM ; i++)
57     {
58         pid = fork();        
59         if(pid < 0)
60         {
61             perror("fork()");
62             exit(1);
63         }
64         if(pid == 0)    // child
65         {
66             func_add();
67             exit(0);
68         }
69     }
70 
71     for(i = 0 ; i < PROCNUM ; i++)
72         wait(NULL);
73 
74 
75     exit(0);
76 }