Re: [Qemu-devel] [PATCH] suppress 'warn_unused_result' warning

[Jamie Lokier <jamie@shareable.org>]

Stuart Brady wrote:
> On Sun, May 10, 2009 at 07:53:35PM -0600, M. Warner Losh wrote:
> > When a signal is received and you are waiting for data, you get
> > EINTR.  If there's data available, then I believe the behavior is to
> > return that data and not EINTR.  That's the way Unix works.
> 
> So if I do a read() from a file over NFS, and there's an awful lot of
> latency (and perhaps even connection problems), and the process gets a
> signal -- does that mean that the signal will only be delivered once
> data is returned?

With NFS, if it's mounted "hard" it behaves like reading from a local
disk and returns exactly the number of bytes requested (unless it
reaches the end of file), and never returns EINTR.

If it's mounted "soft", it can return EINTR and does not have to wait
for data to be received.  But if it _already_ has some data when the
signal happens, it will return the amount of data it has already.

EINTR is not rare if you do a blocknig read from a pipe or socket, and
then receive a signal.  It returns EINTR every time :-)

> If not, then I would really start to wonder whether /all/ code dealing
> with read(), write(), etc. should be written to cope with EINTR (and 
> also partial reads/writes?) regardless of whatever is done with threads
> and signal masks, as doing otherwise seems only to be asking for trouble
> at some point.  (I'd be especially concerned about signals intended for
> libraries that are not under the developer's control...)

In some cases it's easier to set SA_RESTART when setting the signal
handler.  See "man 7 signal" and restarting signals - it has a good
explanation of when EINTR is received, when you can disable it, and
which systems calls you can't disable it for.

Of course signal handlers set by library code might not set that flag,
which is why it's usually not a good idea to rely on it.n

To be more thorough, do all I/O in thread swhich never receives
signals (except stop/kill).  This is achieved by pthread_sigmask() to
block all signals on those threads.  Make sure no libraries unmask them!

-- Jamie