Improve copydir() code for the case that fsync is off.

We should avoid calling sync_file_range or posix_fadvise in this case,
since (a) we don't really care if the data gets synced, and might as
well save the kernel calls; (b) at least on Linux we know that the
kernel might block us until it's scheduled the write.

Also, avoid making a useless second traversal of the directory tree
if we're not actually going to call fsync(2) after all.

diff --git a/src/backend/storage/file/copydir.c b/src/backend/storage/file/copydir.c
index dc89442041a1e2968c7c1626e5faa4264c9d8a28..cf47708a7976d58e4c7da553062ca3f5dbb9ce20 100644 (file)
--- a/src/backend/storage/file/copydir.c
+++ b/src/backend/storage/file/copydir.c
@@ -98,7 +98,11 @@ copydir(char *fromdir, char *todir, bool recurse)
 
        /*
         * Be paranoid here and fsync all files to ensure the copy is really done.
+        * But if fsync is disabled, we're done.
         */
+       if (!enableFsync)
+               return;
+
        xldir = AllocateDir(todir);
        if (xldir == NULL)
                ereport(ERROR,
@@ -200,9 +204,9 @@ copy_file(char *fromfile, char *tofile)
                /*
                 * We fsync the files later but first flush them to avoid spamming the
                 * cache and hopefully get the kernel to start writing them out before
-                * the fsync comes.
+                * the fsync comes.  Ignore any error, since it's only a hint.
                 */
-               pg_flush_data(dstfd, offset, nbytes);
+               (void) pg_flush_data(dstfd, offset, nbytes);
        }
 
        if (close(dstfd))

diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c
index 9724f481dc0aa1b04110aa4aeb4d75dcd769e8eb..1e54715056c89ea65c47a5e7c543e8930f930be7 100644 (file)
--- a/src/backend/storage/file/fd.c
+++ b/src/backend/storage/file/fd.c
@@ -337,18 +337,22 @@ pg_fdatasync(int fd)
  * pg_flush_data --- advise OS that the data described won't be needed soon
  *
  * Not all platforms have sync_file_range or posix_fadvise; treat as no-op
- * if not available.
+ * if not available.  Also, treat as no-op if enableFsync is off; this is
+ * because the call isn't free, and some platforms such as Linux will actually
+ * block the requestor until the write is scheduled.
  */
 int
 pg_flush_data(int fd, off_t offset, off_t amount)
 {
+       if (enableFsync)
+       {
 #if defined(HAVE_SYNC_FILE_RANGE)
-       return sync_file_range(fd, offset, amount, SYNC_FILE_RANGE_WRITE);
+               return sync_file_range(fd, offset, amount, SYNC_FILE_RANGE_WRITE);
 #elif defined(USE_POSIX_FADVISE) && defined(POSIX_FADV_DONTNEED)
-       return posix_fadvise(fd, offset, amount, POSIX_FADV_DONTNEED);
-#else
-       return 0;
+               return posix_fadvise(fd, offset, amount, POSIX_FADV_DONTNEED);
 #endif
+       }
+       return 0;
 }