Handle EINTR.

When building with sccache locally, I'm seeing a bunch of errors to acquire the
jobserver token which are caused by interrupts at bad times.

I think it was a kernel update what caused this, fwiw, but not 100% sure.

Both can happen according to the man pages, and we're not handling them
sensibly.

I think retrying the read / poll when the error is EINTR is a sensible thing to
do.

src/lib.rs

@@ -591,7 +591,11 @@ mod imp {
                 loop {
                     fd.revents = 0;
                     if libc::poll(&mut fd, 1, -1) == -1 {
-                        return Err(io::Error::last_os_error());
+                        let e = io::Error::last_os_error();
+                        match e.kind() {
+                            io::ErrorKind::Interrupted => continue,
+                            _ => return Err(e),
+                        }
                     }
                     if fd.revents == 0 {
                         continue;
@@ -605,8 +609,10 @@ mod imp {
                                 "early EOF on jobserver pipe",
                             ))
                         }
-                        Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
-                        Err(e) => return Err(e),
+                        Err(e) => match e.kind() {
+                            io::ErrorKind::WouldBlock | io::ErrorKind::Interrupted => continue,
+                            _ => return Err(e),
+                        },
                     }
                 }
             }