The socket process handles interrupted system calls and the Accept function returns EINTR error handling

Transfer from Http://blog.csdn.net/keshacookie/article/details/40717059?utm_source=tuicool

We use slow system calls to describe system calls (function calls) that may be blocked forever, such as Accept,read. A system call that is never blocked means that a call may never be returned, and most network support functions fall into this category. For example, if no customer is connected to the server, the server does not return a guarantee for the call to accept. Similarly, if a customer never sends a line of text that requires the server to be shot back, the server's call to read will never return. Other examples of slow system calls are the reading and writing of pipelines and end devices. One exception is disk IO, which he generally returns to the caller.

When a process jams and a slow system call captures a signal, the system call may return a EINTR error when the signal handler returns. Some cores automatically reboot some of the interrupted system calls. For portability, when we write a program that captures signals (most concurrent servers capture SIGCHLD), we must be prepared to return EINTR for slow system calls.

In order to handle an interrupted accept, we take care of the call to accept, and other slow system call functions can also be processed as follows:

The first method: use continue to enter for the next loop, thereby restarting the interrupted system call;

2. for (;;)
4. {
6. Clilen = sizeof (CLIADDR);
8. if (connfd = Accept (LISTENFD, (SA *) &cliaddr, &clilen)) < 0) {
10. if (errno = = eintr)
12. continue;
14. Else
16. Err_sys ("Accept error");
18. }
20. }

or use Goto to achieve the same function, but also let the interrupted system call restart;

2. Again:
4. for (;;)
6. {
8. Clilen = sizeof (CLIADDR);
10. if (connfd = Accept (LISTENFD, (SA *) &cliaddr, &clilen)) < 0) {
12. if (errno = = eintr)
14. Goto Again;
16. Else
18. Err_sys ("Accept error");
20. }
22. }

It is also stated that:

The basic rule for slow system calls is that when a process blocking a slow system call captures a signal, the system call may return a EINTR error when the corresponding signal processing function is returned, and some system cores will automatically reboot some of the interrupted system calls;

In this code, all we do is reboot the interrupted system call, which is appropriate for the accept and other functions such as read,write,select and open, but there is a function we cannot restart by ourselves: Connect. If this function returns Inter, we can no longer call him or return an error. When the connet is interrupted by a captured signal and does not restart automatically, we must call Select to wait for the connection to complete.

Finally, when we write the final version of the TCP server that handles the Accept return EINTR error, there are a couple of questions to note first:

>>> When you fork a child process, you must capture the SIGCHLD signal (theSIGCHLD signal is the signal sent to the kernel when the child process ends)

>>> the interrupted system call must be processed when the signal is captured

>>> SIGCHLD Signal processing function (SIG_CHLD) must be correctly written, should use the Waitpid function to kill the zombie process;

The following is the final version of the TCP server program that handles the Accept function return EINTR error:

2. #include <unp.h>
6. Int
8. Main (int argc, char **argv)
10. {
12. int LISTENFD, CONNFD;
14. pid_t Child_pid;
16. Socklen_t Clilen;
18. struct sockaddr_in cliaddr, servaddr;
20. void sig_chld (int);
24. LISTENFD = Socket (af_inet, sock_stream, 0);
26. Bzero (&servaddr, sizeof (SERVADDR));
28. servaddr.sin_family = af_inet;
30. SERVADDR.SIN_ADDR.S_ADDR = htonl (Inaddr_any);
32. Servaddr.sin_port = htons (Serv_port);
36. Bind (LISTENFD, (SA *) &servaddr, sizeof (SERVADDR));
38. Listen (LISTENFD, Listenq);
40. Signal (SIGCHLD, SIG_CHLD);
44. for (;;) {  
46. Clilen = sizeof (CLIADDR);
48. if (connfd = Accept (LISTENFD, (SA *) &cliaddr, &clilen)) < 0) {
50. if (errno = = eintr)
52. continue;
54. Else
56. Err_sys ("Accept error");
58. }
60. if ((Child_pid = Fork ()) = = 0) {
62. Close (LISTENFD);
64. STR_CLI (CONNFD);
66. Exit (0);
68. }
70. Close (CONNFD);
72. }
74. }

The socket process handles interrupted system calls and the Accept function returns eintr error handling (RPM)