1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <errno.h>  
4. #include <string.h>  
5. #include <sys/types.h>  
6. #include <netinet/in.h>  
7. #include <sys/socket.h>  
8. #include <sys/wait.h>  
9. #include <unistd.h>  
10. #include <arpa/inet.h>  
11. #include <openssl/ssl.h>  
12. #include <openssl/err.h>  
13. #include <fcntl.h>  
14. #include <sys/epoll.h>  
15. #include <sys/time.h>  
16. #include <sys/resource.h>  

1. #define MAXBUF 1024  
2. #define MAXEPOLLSIZE 10000  

1. /* 
2. setnonblocking - 设置句柄为非阻塞方式 
3. */  
4. int setnonblocking(int sockfd)  
5. {  
6.     if (fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFD, 0)|O_NONBLOCK) == -1)  
7.  {  
8.         return -1;  
9.     }  
10.     return 0;  
11. }  

1. /* 
2. handle_message - 处理每个 socket 上的消息收发 
3. */  
4. int handle_message(int new_fd)  
5. {  
6.     char buf[MAXBUF + 1];  
7.     int len;  
8.       
9.  /* 开始处理每个新连接上的数据收发 */  
10.     bzero(buf, MAXBUF + 1);  
11.      
12.  /* 接收客户端的消息 */  
13.     len = recv(new_fd, buf, MAXBUF, 0);  
14.     if (len > 0)  
15.  {  
16.         printf  
17.             ("%d接收消息成功:'%s'，共%d个字节的数据/n",  
18.              new_fd, buf, len);  
19.  }  
20.     else  
21.  {  
22.         if (len < 0)  
23.      printf  
24.                 ("消息接收失败！错误代码是%d，错误信息是'%s'/n",  
25.                  errno, strerror(errno));  
26.         close(new_fd);  
27.         return -1;  
28.     }  
29.     /* 处理每个新连接上的数据收发结束 */  
30.     return len;  
31. }  
32. /************关于本文档******************************************** 
33. *filename: epoll-server.c 
34. *purpose: 演示epoll处理海量socket连接的方法 
35. *wrote by: zhoulifa(<a href="mailto:zhoulifa@163.com"& gt;zhoulifa@163.com</a>) 周立发(<a href="http: //zhoulifa.bokee.com">http://zhoulifa.bokee.com</a>) 
36. Linux爱好者 Linux知识传播者 SOHO族 开发者 最擅长C语言 
37. *date time:2007-01-31 21:00 
38. *Note: 任何人可以任意复制代码并运用这些文档，当然包括你的商业用途 
39. * 但请遵循GPL 
40. *Thanks to:Google 
41. *Hope:希望越来越多的人贡献自己的力量，为科学技术发展出力 
42. * 科技站在巨人的肩膀上进步更快！感谢有开源前辈的贡献！ 
43. *********************************************************************/  
44. int main(int argc, char **argv)  
45. {  
46.     int listener, new_fd, kdpfd, nfds, n, ret, curfds;  
47.     socklen_t len;  
48.     struct sockaddr_in my_addr, their_addr;  
49.     unsigned int myport, lisnum;  
50.     struct epoll_event ev;  
51.     struct epoll_event events[MAXEPOLLSIZE];  
52.     struct rlimit rt;  
53.  myport = 5000;  
54.  lisnum = 2;   
55.       
56.  /* 设置每个进程允许打开的最大文件数 */  
57.     rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE;  
58.     if (setrlimit(RLIMIT_NOFILE, &rt) == -1)   
59.  {  
60.         perror("setrlimit");  
61.         exit(1);  
62.     }  
63.     else   
64.     {  
65.         printf("设置系统资源参数成功！/n");  
66.     }  

1.     /* 开启 socket 监听 */  
2.     if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1)  
3.     {  
4.         perror("socket");  
5.         exit(1);  
6.     }  
7.     else  
8.     {  
9.         printf("socket 创建成功！/n");  
10.  }  
11.    
12.     setnonblocking(listener);  

1.     bzero(&my_addr, sizeof(my_addr));  
2.     my_addr.sin_family = PF_INET;  
3.     my_addr.sin_port = htons(myport);  
4.     my_addr.sin_addr.s_addr = INADDR_ANY;  

1.     if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1)   
2.     {  
3.         perror("bind");  
4.         exit(1);  
5.     }   
6.     else  
7.     {  
8.         printf("IP 地址和端口绑定成功/n");  
9.  }  
10.     if (listen(listener, lisnum) == -1)   
11.     {  
12.         perror("listen");  
13.         exit(1);  
14.     }  
15.     else  
16.     {  
17.         printf("开启服务成功！/n");  
18.  }  
19.       
20.  /* 创建 epoll 句柄，把监听 socket 加入到 epoll 集合里 */  
21.     kdpfd = epoll_create(MAXEPOLLSIZE);  
22.     len = sizeof(struct sockaddr_in);  
23.     ev.events = EPOLLIN | EPOLLET;  
24.     ev.data.fd = listener;  
25.     if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0)   
26.  {  
27.         fprintf(stderr, "epoll set insertion error: fd=%d/n", listener);  
28.         return -1;  
29.     }  
30.  else  
31.     {  
32.   printf("监听 socket 加入 epoll 成功！/n");  
33.  }  
34.     curfds = 1;  
35.     while (1)   
36.  {  
37.         /* 等待有事件发生 */  
38.         nfds = epoll_wait(kdpfd, events, curfds, -1);  
39.         if (nfds == -1)  
40.   {  
41.             perror("epoll_wait");  
42.             break;  
43.         }  
44.         /* 处理所有事件 */  
45.         for (n = 0; n < nfds; ++n)  
46.   {  
47.             if (events[n].data.fd == listener)   
48.    {  
49.                 new_fd = accept(listener, (struct sockaddr *) &their_addr,&len);  
50.                 if (new_fd < 0)   
51.     {  
52.                     perror("accept");  
53.                     continue;  
54.                 }   
55.     else  
56.     {  
57.      printf("有连接来自于： %d:%d， 分配的 socket 为:%d/n",  
58.                              inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd);  
59.     }  
60.                 setnonblocking(new_fd);  
61.                 ev.events = EPOLLIN | EPOLLET;  
62.                 ev.data.fd = new_fd;  
63.                 if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0)  
64.     {  
65.                     fprintf(stderr, "把 socket '%d' 加入 epoll 失败！%s/n",  
66.                             new_fd, strerror(errno));  
67.                     return -1;  
68.                 }  
69.                 curfds++;  
70.             }   
71.    else  
72.    {  
73.                 ret = handle_message(events[n].data.fd);  
74.                 if (ret < 1 && errno != 11)  
75.     {  
76.                     epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,&ev);  
77.                     curfds--;  
78.                 }  
79.             }  
80.         }  
81.     }  
82.     close(listener);  
83.     return 0;  
84. }  

 epoll_wait 运行的原理是 等侍注册在epfd上的socket fd的事件的发生，如果发生则将发生的sokct fd和事件类型放入到events数组中。 并且将注册在epfd上的socket fd的事件类型给清空，所以如果下一个循环你还要关注这个socket fd的话，则需要用epoll_ctl(epfd,EPOLL_CTL_MOD,listenfd,&ev)来重新设置socket fd的事件类型。这时不用EPOLL_CTL_ADD,因为socket fd并未清空，只是事件类型清空。这一步非常重要。 

转：

今天被朋友问及“Linux下可以替换运行中的程序么？”，以前依稀记得Linux下是可以的（而Windows就不让），于是随口答道“OK”。结果朋友发来一个执行结果：（test正在运行中）

# cp test2 test
cp: cannot create regular file `test': Text file busy

看起来是程序被占用，无法覆盖。于是自己又再做了几个实验：

（1）先rm删除正在运行的test，然后cp test2 test就没有错误了。
（2）先mv改名正在运行的test，然后cp test2 test也没有问题。

查了查资料并动手分析了一下，找到了比较满意的解释。cp并不改变目标文件的inode，事实上它的实现是这样的：

# strace cp test2 test  2>&1 | grep open.*test
open("test2", O_RDONLY|O_LARGEFILE)     = 3
open("test", O_WRONLY|O_TRUNC|O_LARGEFILE) = 4

我原以为cp的实现是“rm + open(O_CREAT)”，不过现在想想上面的实现方式才是最可靠的（保证了时序安全和目标文件的属性）。这也可以解释为什么cp的目标文件会继承被覆盖文件的属性而非源文件。

Linux 由于Demand Paging机制的关系，必须确保正在运行中的程序镜像（注意，并非文件本身）不被意外修改，因此内核在启动程序后会锁定这个程序镜像的inode。这就 是为什么cp在用“O_WRONLY|O_TRUNC”模式open目标文件时会失败。而先rm再cp的话，新文件的inode其实已经改变了，原 inode并没有被真正删除，直到内核释放对它的引用。同理，mv只是改变了文件名，其inode不变，新文件使用了新的inode。

问题到这里已经水落石出，不过刨根究底的个性驱使我再做了以下一组实验，没想到结果完全出乎我意料之外！

写了一个简单的测试程序：

#include <stdio.h>

int main(int argc, char * argv[])
{
    foo();  // An export function by libtest.so.
    sleep(1000);
    return 0;
}

foo()是另一个测试动态库libtest.so的导出接口，只打印一行提示就返回。接下来我把上面对执行文件的测试用例对动态库又做了一遍：

（1）cp libtest2.so libtest.so可以直接覆盖已加载的动态库。
（2）先rm删除已加载的libtest.so，然后cp libtest2.so libtest.so成功。
（3）先mv改名已加载的libtest.so，然后cp libtest2.so libtest.so成功。

除了第一个用例外，结果相同。这样看来，动态库被加载时难道ld并没有锁定inode？不过想想也可以宽恕，毕竟ld也是用户态程序，没有权利去锁定inode，也不应与内核的文件系统底层实现耦合。

到这里都还算在情理之中，看起来Linux也都处理的很好。不过还剩下一个问题：动态库被以cp的方式覆盖后难道不会和Demand Paging机制产生冲突？

在思考这个问题的过程中，我意识到前面这个测试程序的一个致命漏洞，稍作修改如下：

#include <stdio.h>

int main(int argc, char * argv[])
{
loop:
    foo();  // An export function by libtest.so.
    sleep(1);
    goto loop;
    return 0;
}

这 次，再执行上面的三个用例后发现，“cp libtest2.so libtest.so”虽然仍可直接覆盖已加载的动态库，但是测试程序马上出现了“Segmentation fault”。而后两个用例结果不变。由此可见，想要安全的替换已加载的动态库，还是用“笨拙”的“rm + cp”吧，看似捷径的“cp覆盖”会直接葬送掉你的程序……

看来，我再一次低估了Linux的健壮性，看似符合逻辑的流程也可能会带来灾 难性的后果；“rm & cp”与“cp覆盖”背后所隐藏的底层差异却可以成为你的救星。Linux用得越久越是让人觉得这是一块充满了荆棘和陷阱的原始丛林，只有步步为营实踏前 行才能走的更远。

注：以上实验基于SuSE Linux Enterprise Server 9 SP1（Linux 2.6.5 & glibc 2.3.3）。