多进程共享epoll fd

1. #include <stdlib.h>
   
2. #include <strings.h>
   
3. #include <sys/epoll.h>
   
4. #include <fcntl.h>
   
5. #include <unistd.h>
   
6. #include <sys/socket.h>
   
7. #include <arpa/inet.h>
   
8. #include <errno.h>
   
9. 
   
10. void setnonblocking(int fd)
    
11. {
    
12.     int val;
    
13. 
    
14.     if ((val = fcntl(fd, F_GETFL)) < 0)
    
15.     {
    
16.         perror("GETFL");
    
17.         exit(1);
    
18.     }
    
19. 
    
20.     val |= O_NONBLOCK;
    
21. 
    
22.     if (fcntl(fd, F_SETFL, val) < 0)
    
23.     {
    
24.         perror("SETFL");
    
25.         exit(1);
    
26.     }
    
27. }
    
28. 
    
29. int main()
    
30. {
    
31.     int fd, listener, clifd, epfd, i, ret, size;
    
32.     struct epoll_event ev, events[16];
    
33.     char buf[1024];
    
34.     int parent = 1;
    
35.     int status;
    
36.     int pid;
    
37.     
    
38.     if ((listener = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    
39.     {
    
40.         perror("socket");
    
41.         exit(1);
    
42.     }
    
43. 
    
44.     setnonblocking(listener);
    
45. 
    
46.     epfd = epoll_create(256);
    
47.     if (epfd < 0)
    
48.     {
    
49.         perror("epoll_create");
    
50.         exit(1);
    
51.     }
    
52. 
    
53.     ev.data.fd = listener;
    
54.     ev.events = EPOLLIN | EPOLLET;
    
55. 
    
56.     if (epoll_ctl(epfd, EPOLL_CTL_ADD, listener, &ev) < 0)
    
57.     {
    
58.         perror("epoll_ctl");
    
59.         exit(1);
    
60.     }
    
61.     
    
62.     struct sockaddr_in servaddr, cliaddr;
    
63.     bzero(&servaddr, sizeof(servaddr));
    
64.     servaddr.sin_family = AF_INET;
    
65.     servaddr.sin_addr.s_addr = INADDR_ANY;
    
66.     servaddr.sin_port = htons(5432);
    
67. 
    
68.     if (bind(listener, &servaddr, sizeof(servaddr)) < 0)
    
69.     {
    
70.         perror("bind");
    
71.         exit(1);
    
72.     }
    
73. 
    
74.     if (listen(listener, 16) < 0)
    
75.     {
    
76.         perror("listen");
    
77.         exit(1);
    
78.     }
    
79. 
    
80.     for (i = 0; i < 3 && parent; i++)
    
81.     {
    
82.         switch (fork())
    
83.         {
    
84.             case -1:
    
85.                 perror("fork");
    
86.                 exit(1);
    
87.             case 0:
    
88.                 parent = 0;
    
89.                 pid = getpid();
    
90.                 break;
    
91.             default:
    
92.                 break;
    
93.         }
    
94.     }
    
95. 
    
96.     if (parent)
    
97.     {
    
98.         while ((ret = waitpid(-1, &status, 0)))
    
99.         {
    
100.             if (ret > 0)
     
101.                 printf("child %d has quit with %d...\n", ret, status);
     
102.         }
     
103.     }
     
104. 
     
105.     socklen_t len;
     
106.     while (1)
     
107.     {
     
108.         if ((ret = epoll_wait(epfd, events, 1, 600000)) < 0)
     
109.         {
     
110.             perror("epoll_wait");
     
111.             exit(1);
     
112.         }
     
113.         else if (ret == 0)
     
114.         {
     
115.             printf("[%d]600s elapsed...\n", pid);
     
116.         }
     
117.         else
     
118.         {
     
119.             printf("\n[%d]%d events checkin\n", pid, ret);
     
120.         }
     
121. 
     
122.         for (i = 0; i < ret; i++)
     
123.         {
     
124.             if ((fd = events[i].data.fd) < 0)
     
125.             {
     
126.                 printf("Invalid fd!\n");
     
127.                 exit(1);
     
128.             }
     
129.             
     
130.             if (fd == listener)
     
131.             {
     
132.                 len = sizeof(cliaddr);
     
133.                 clifd = accept(fd, &cliaddr, &len);
     
134.                 if (clifd < 0)
     
135.                 {
     
136.                     perror("accept");
     
137.                     continue;
     
138.                 }
     
139. 
     
140.                 printf("[%d]New connection from %s:%d,fd=%d\n",pid, inet_ntoa(cliaddr.sin_addr), 
     
141.                     ntohs(cliaddr.sin_port), clifd);
     
142. 
     
143.                 setnonblocking(clifd);
     
144.                 ev.data.fd = clifd;
     
145.                 ev.events = EPOLLIN | EPOLLET;
     
146. 
     
147.                 if (epoll_ctl(epfd, EPOLL_CTL_ADD, clifd, &ev) < 0)
     
148.                 {
     
149.                     perror("epoll_ctl");
     
150.                     exit(1);
     
151.                 }
     
152.             }
     
153.             else if (events[i].events & EPOLLIN)
     
154.             {
     
155.                 while ((size = recv(fd, buf, sizeof(buf), 0)) > 0)
     
156.                 {
     
157.                     buf[size] = 0;
     
158.                     printf("[%d]%d bytes recved from fd %d:%s\n", pid, size, fd, buf);
     
159.                 }
     
160. 
     
161.                 printf("[%d]size=%d,fd=%d:%s\n", pid, size, fd, strerror(errno));
     
162.                 if (size == 0)
     
163.                 {
     
164.                     close(fd);
     
165.                 }
     
166.             }
     
167.         }
     
168.     }
     
169. 
     
170.     return 0;
     
171. }

把 epoll_create这段(46-60)放到子进程里面就没问题了。