handle ErrorKind::Interrupted when doing file IOs

According to rust doc for Read::read():
If this function encounters any form of I/O or other error, an error
variant will be returned. If an error is returned then it must be
guaranteed that no bytes were read.

An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the
read operation should be retried if there is nothing else to do.

So we should silently ignore [`ErrorKind::Interrupted`] and retry,
otherwise it will false alarms/wrong results.

Signed-off-by: Liu Jiang <[email protected]>

Author: jiangliu

coverage_config.json

@@ -1,5 +1,5 @@
 {
-  "coverage_score": 85.7,
+  "coverage_score": 84.9,
   "exclude_path": "mmap_windows.rs",
   "crate_features": "backend-mmap,backend-atomic"
 }

src/guest_memory.rs

@@ -743,15 +743,27 @@ impl<T: GuestMemory> Bytes<GuestAddress> for T {
                 // This is safe cause `start` and `len` are within the `region`.
                 let start = caddr.raw_value() as usize;
                 let end = start + len;
-                let bytes_read = src.read(&mut dst[start..end]).map_err(Error::IOError)?;
-                Ok(bytes_read)
+                loop {
+                    match src.read(&mut dst[start..end]) {
+                        Ok(n) => break Ok(n),
+                        Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
+                        Err(e) => break Err(Error::IOError(e)),
+                    }
+                }
             } else {
                 let len = std::cmp::min(len, MAX_ACCESS_CHUNK);
                 let mut buf = vec![0u8; len].into_boxed_slice();
-                let bytes_read = src.read(&mut buf[..]).map_err(Error::IOError)?;
-                let bytes_written = region.write(&buf[0..bytes_read], caddr)?;
-                assert_eq!(bytes_written, bytes_read);
-                Ok(bytes_read)
+                loop {
+                    match src.read(&mut buf[..]) {
+                        Ok(bytes_read) => {
+                            let bytes_written = region.write(&buf[0..bytes_read], caddr)?;
+                            assert_eq!(bytes_written, bytes_read);
+                            break Ok(bytes_read);
+                        }
+                        Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
+                        Err(e) => break Err(Error::IOError(e)),
+                    }
+                }
             }
         })
     }
@@ -809,12 +821,17 @@ impl<T: GuestMemory> Bytes<GuestAddress> for T {
                 // This is safe cause `start` and `len` are within the `region`.
                 let start = caddr.raw_value() as usize;
                 let end = start + len;
-                // It is safe to read from volatile memory. Accessing the guest
-                // memory as a slice should be OK as long as nothing assumes another
-                // thread won't change what is loaded; however, we may want to introduce
-                // VolatileRead and VolatileWrite traits in the future.
-                let bytes_written = dst.write(&src[start..end]).map_err(Error::IOError)?;
-                Ok(bytes_written)
+                loop {
+                    // It is safe to read from volatile memory. Accessing the guest
+                    // memory as a slice should be OK as long as nothing assumes another
+                    // thread won't change what is loaded; however, we may want to introduce
+                    // VolatileRead and VolatileWrite traits in the future.
+                    match dst.write(&src[start..end]) {
+                        Ok(n) => break Ok(n),
+                        Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
+                        Err(e) => break Err(Error::IOError(e)),
+                    }
+                }
             } else {
                 let len = std::cmp::min(len, MAX_ACCESS_CHUNK);
                 let mut buf = vec![0u8; len].into_boxed_slice();

src/volatile_memory.rs

@@ -592,7 +592,13 @@ impl Bytes<usize> for VolatileSlice<'_> {
             // memory as a mutable slice is OK because nothing assumes another
             // thread won't change what is loaded.
             let dst = &mut self.as_mut_slice()[addr..end];
-            src.read(dst).map_err(Error::IOError)
+            loop {
+                match src.read(dst) {
+                    Ok(n) => break Ok(n),
+                    Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
+                    Err(e) => break Err(Error::IOError(e)),
+                }
+            }
         }
     }
 
@@ -656,7 +662,13 @@ impl Bytes<usize> for VolatileSlice<'_> {
             // memory as a slice is OK because nothing assumes another thread
             // won't change what is loaded.
             let src = &self.as_mut_slice()[addr..end];
-            dst.write(src).map_err(Error::IOError)
+            loop {
+                match dst.write(src) {
+                    Ok(n) => break Ok(n),
+                    Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
+                    Err(e) => break Err(Error::IOError(e)),
+                }
+            }
         }
     }