EINTR and non-blocking calls

Question

As is known, some blocking calls like read and write would return -1 and set errno to EINTR , and we need handle this.

My question is: Does this apply for non-blocking calls, eg, set socket to O_NONBLOCK ?

Since some articles and sources I have read said non-blocking calls don't need bother with this, but I have found no authoritative reference about it. If so, does it apply cross different implementations?

Answer 1

I cannot give you a definitive answer to this question, and the answer may further vary from system to system, but I would expect a non-blocking socket to never fail with EINTR . If you take a look at the man pages of various systems for the following socket functions bind() , connect() , send() , and receive() , or look those up in the POSIX standard, you'll notice something interesting: All these functions except one may return -1 and set errno to EINTR . The one function that is not documented to ever fail with EINTR is bind() . And bind() is also the only function of that list that will never block by default. So it seems that only blocking functions may fail because of EINTR , including read() and write() , yet if these functions never block, they also will never fail with EINTR and if you use O_NONBLOCK , those functions will never block.

It would also make no sense from a logical perspective. Eg consider you are using blocking I/O and you call read() and this call has to block, but while it was blocking, a signal is sent to your process and thus the read request is unblocked. How should the system handle this situation? Claiming that read() did succeed? That would be a lie, it did not succeed because no data was read. Claiming it did succeed, but zero bytes data were read? This wouldn't be correct either, since a "zero read result" is used to indicate end-of-stream (or end-of-file), so your process would to assume that no data was read, because the end of a file has been reached (or a socket/pipe has been closed at other end), which simply isn't the case. The end-of-file (or end-of-stream) has not been reached, if you call read() again, it will be able to return more data. So that would also be a lie. You expectation is that this read call either succeeds and reads data or fails with an error. Thus the read call has to fail and return -1 in that case, but what errno value shall the system set? All the other error values indicate a critical error with the file descriptor, yet there was no critical error and indicating such an error would also be a lie. That's why errno is set to EINTR , which means: "There was nothing wrong with the stream. Your read call just failed, because it was interrupted by a signal. If it wasn't interrupted, it may still have succeeded, so if you still care for the data, please try again."

If you now switch to non-blocking I/O, the situation of above never arises. The read call will never block and if it cannot read data immediately, it will fail with an error EAGAIN (POSIX) or EWOULDBLOCK (unofficial, on Linux both are the same error, just alternative names for it), which means: "There is no data available right now and thus your read call would have to block and wait for data arriving, but blocking is not allowed, so it failed instead." So there is an error for every situation that may arise.

Of course, even with non-blocking I/O, the read call may have temporarily interrupted by a signal but why would the system have to indicate that? Every function call, whether this is a system function or one written by the user, may be temporarily interrupted by a signal, really every single one, no exception. If the system would have to inform the user whenever that happens, all system functions could possibly fail because of EINTR . However, even if there was a signal interruption, the functions usually perform their task all the way to the end, that's why this interruption is irrelevant. The error EINTR is used to tell the caller that the action he has requested was not performed because of a signal interruption, but in case of non-blocking I/O, there is no reason why the function should not perform the read or the write request, unless it cannot be performed right now, but then this can be indicated by an appropriate error.

To confirm my theory, I took a look at the kernel of MacOS (10.8), which is still largely based on the FreeBSD kernel and it seems to confirm the suspicion. If a read call is currently not possible, as no data are available, the kernel checks for the O_NONBLOCK flag in the file descriptor flags. If this flag is set, it fails immediately with EAGAIN . If it is not set, it puts the current thread to sleep by calling a function named msleep() . The function is documented here (as I said, OS X uses plenty of FreeBSD code in its kernel). This function causes the current thread to sleep until it is explicitly woken up (which is the case if data becomes ready for reading) or a timeout has been hit (eg you can set a receive timeout on sockets). Yet the thread is also woken up, if a signal is delivered, in which case msleep() itself returns EINTR and the next higher layer just passes this error through. So it is msleep() that produces the EINTR error, but if the O_NONBLOCK flag is set, msleep() is never called in the first place, hence this error cannot be returned.

Of course that was MacOS/FreeBSD, other systems may be different, but since most systems try to keep at least a certain level of consistency among these APIs, if a system breaks the assumption, that non-blocking I/O calls can never fail because of EINTR , this is probably not by intention and may even get fixed if your report it.

Answer 2

@Mecki Great explanation. To add to the accepted answer, the book "Unix Network Programming - Volume 1, Third Edition" (Stevens) makes a distinction between slow system call and others in chapter/section 5.9 - "Handling Interrupted System Calls". I am quoting from the book -

We used the term "slow system call" to describe accept , and we use this term for any system call that can block forever. That is, the system call need never return.

In the next para of the same section -

The basic rule that applies here is that when a process is blocked in a slow system call and the process catches a signal and the signal handler returns, the system call can return an error of EINTR .

Going by this explanation, a read / write on a non-blocking socket is not a slow system call and hence should not return an error of EINTR .

Answer 3

Just to add some evidence to @Mecki's answer, I found this discussion about fixing a bug in Linux where a patch caused non-blocking recvmsg to return EINTR. It was stated:

EINTR always means that you asked for a blocking operation, and a signal arrived meanwhile.

Once you invert the "blocking" part of that set of conditions, EINTR becomes an impossible event.

Also:

Look at what we do for AF_INET. We handle this the proper way.

If we are 'interrupted' by a signal while sleeping in lock_sock(), recvmsg() on a non blocking socket, we return -EAGAIN properly, not -EINTR.

Fact that we potentially sleep to get the socket lock is hidden for the user, its an implementation detail of the kernel.

We never return -EINTR, as stated in manpage for non blocking sockets.

Source here: https://patchwork.ozlabs.org/project/netdev/patch/1395798147.12610.196.camel@edumazet-glaptop2.roam.corp.google.com/#741015