Provide helper for retrying partial vectored I/O.

compute_remaining_iovec() is a re-usable routine for retrying after
pg_readv() or pg_writev() reports a short transfer.  This will gain new
users in a later commit, but can already replace the open-coded
equivalent code in the existing pg_pwritev_with_retry() function.

Reviewed-by: Heikki Linnakangas <hlinnaka@iki.fi>
Discussion: https://postgr.es/m/CA+hUKGJkOiOCa+mag4BF+zHo7qo=o9CFheB8=g6uT5TUm2gkvA@mail.gmail.com

diff --git a/src/common/file_utils.c b/src/common/file_utils.c
index abe5129412db5c65075fb5db849bd4442e17804d..5380299f35f7cf16fb313592c8e7d67cc939f9e4 100644 (file)
--- a/src/common/file_utils.c
+++ b/src/common/file_utils.c
@@ -581,6 +581,52 @@ get_dirent_type(const char *path,
    return result;
 }
 
+/*
+ * Compute what remains to be done after a possibly partial vectored read or
+ * write.  The part of 'source' beginning after 'transferred' bytes is copied
+ * to 'destination', and its length is returned.  'source' and 'destination'
+ * may point to the same array, for in-place adjustment.  A return value of
+ * zero indicates completion (for callers without a cheaper way to know that).
+ */
+int
+compute_remaining_iovec(struct iovec *destination,
+                       const struct iovec *source,
+                       int iovcnt,
+                       size_t transferred)
+{
+   Assert(iovcnt > 0);
+
+   /* Skip wholly transferred iovecs. */
+   while (source->iov_len <= transferred)
+   {
+       transferred -= source->iov_len;
+       source++;
+       iovcnt--;
+
+       /* All iovecs transferred? */
+       if (iovcnt == 0)
+       {
+           /*
+            * We don't expect the kernel to transfer more than we asked it
+            * to, or something is out of sync.
+            */
+           Assert(transferred == 0);
+           return 0;
+       }
+   }
+
+   /* Copy the remaining iovecs to the front of the array. */
+   if (source != destination)
+       memmove(destination, source, sizeof(*source) * iovcnt);
+
+   /* Adjust leading iovec, which may have been partially transferred. */
+   Assert(destination->iov_len > transferred);
+   destination->iov_base = (char *) destination->iov_base + transferred;
+   destination->iov_len -= transferred;
+
+   return iovcnt;
+}
+
 /*
  * pg_pwritev_with_retry
  *
@@ -601,7 +647,7 @@ pg_pwritev_with_retry(int fd, const struct iovec *iov, int iovcnt, off_t offset)
        return -1;
    }
 
-   for (;;)
+   do
    {
        /* Write as much as we can. */
        part = pg_pwritev(fd, iov, iovcnt, offset);
@@ -616,33 +662,14 @@ pg_pwritev_with_retry(int fd, const struct iovec *iov, int iovcnt, off_t offset)
        sum += part;
        offset += part;
 
-       /* Step over iovecs that are done. */
-       while (iovcnt > 0 && iov->iov_len <= part)
-       {
-           part -= iov->iov_len;
-           ++iov;
-           --iovcnt;
-       }
-
-       /* Are they all done? */
-       if (iovcnt == 0)
-       {
-           /* We don't expect the kernel to write more than requested. */
-           Assert(part == 0);
-           break;
-       }
-
        /*
-        * Move whatever's left to the front of our mutable copy and adjust
-        * the leading iovec.
+        * See what is left.  On the first loop we used the caller's array,
+        * but in later loops we'll use our local copy that we are allowed to
+        * mutate.
         */
-       Assert(iovcnt > 0);
-       memmove(iov_copy, iov, sizeof(*iov) * iovcnt);
-       Assert(iov->iov_len > part);
-       iov_copy[0].iov_base = (char *) iov_copy[0].iov_base + part;
-       iov_copy[0].iov_len -= part;
+       iovcnt = compute_remaining_iovec(iov_copy, iov, iovcnt, part);
        iov = iov_copy;
-   }
+   } while (iovcnt > 0);
 
    return sum;
 }

diff --git a/src/include/common/file_utils.h b/src/include/common/file_utils.h
index 3bb20170cbd5ce93d0f39ec18e317e1eaa145ab9..02a940e31029421cdb5dfe493ea20b1c9cca6c89 100644 (file)
--- a/src/include/common/file_utils.h
+++ b/src/include/common/file_utils.h
@@ -46,6 +46,11 @@ extern PGFileType get_dirent_type(const char *path,
                                  bool look_through_symlinks,
                                  int elevel);
 
+extern int compute_remaining_iovec(struct iovec *destination,
+                                   const struct iovec *source,
+                                   int iovcnt,
+                                   size_t transferred);
+
 extern ssize_t pg_pwritev_with_retry(int fd,
                                     const struct iovec *iov,
                                     int iovcnt,