fix(iovec): do not return error if some bytes were written

When reading from a volatile memory into a WriteVolatile we should let
the caller know if we managed to transfer some bytes. Currently, if the
write encounters any error after the first iovec an error is returned,
but some bytes are written. This causes issues in the caller, because it
thinks no bytes were written.

In particular, this caused a bug in the vsock code on 6.17 guest kernels
because these kernels started sending multiple iovecs. When sending 2
iovecs, it could happen that we'd get a WouldBlock error on the second,
but the vsock code thought no bytes were transferre, leading to a
spurious retransmission of the first iovec.

Fixes: #5475

Signed-off-by: Riccardo Mancini <mancio@amazon.com>

Author: Manciukic

src/vmm/src/devices/virtio/iovec.rs

@@ -192,23 +192,25 @@ impl IoVecBuffer {
                 slice = slice.subslice(0, len)?;
             }
 
-            let bytes_read = loop {
+            match loop {
                 match dst.write_volatile(&slice) {
                     Err(VolatileMemoryError::IOError(err))
-                        if err.kind() == ErrorKind::Interrupted =>
-                    {
-                        continue;
-                    }
-                    Ok(bytes_read) => break bytes_read,
-                    Err(volatile_memory_error) => return Err(volatile_memory_error),
+                        if err.kind() == ErrorKind::Interrupted => {}
+                    result => break result,
                 }
-            };
-            total_bytes_read += bytes_read;
+            } {
+                Ok(bytes_read) => {
+                    total_bytes_read += bytes_read;
 
-            if bytes_read < slice.len() {
-                break;
+                    if bytes_read < slice.len() {
+                        break;
+                    }
+                    len -= bytes_read;
+                }
+                // exit successfully if we previously managed to write some bytes
+                Err(_) if total_bytes_read > 0 => break,
+                Err(err) => return Err(err),
             }
-            len -= bytes_read;
         }
 
         Ok(total_bytes_read)