From 5233d23ce8e26b432e5cb4e379f05afedbd91a99 Mon Sep 17 00:00:00 2001 From: Tomas Vondra Date: Tue, 19 Mar 2024 15:16:29 +0100 Subject: [PATCH v20240401 3/7] use clone/copy_file_range to copy whole files Use clone/copy_file_range when copying whole files. --- doc/src/sgml/ref/pg_combinebackup.sgml | 46 ++++++ src/bin/pg_combinebackup/copy_file.c | 170 ++++++++++++++++---- src/bin/pg_combinebackup/copy_file.h | 18 ++- src/bin/pg_combinebackup/pg_combinebackup.c | 18 ++- src/bin/pg_combinebackup/reconstruct.c | 5 +- src/bin/pg_combinebackup/reconstruct.h | 3 +- 6 files changed, 219 insertions(+), 41 deletions(-) diff --git a/doc/src/sgml/ref/pg_combinebackup.sgml b/doc/src/sgml/ref/pg_combinebackup.sgml index 6f90dba281f..70310c31985 100644 --- a/doc/src/sgml/ref/pg_combinebackup.sgml +++ b/doc/src/sgml/ref/pg_combinebackup.sgml @@ -185,6 +185,52 @@ PostgreSQL documentation + + + + + Use efficient file cloning (also known as reflinks on + some systems) instead of copying files to the new data directory, + which can result in near-instantaneous copying of the data files. + + + + File cloning may be used only when the checksums match in the backup + manifests. If a backup manifest is not available or does not contain + checksum of the right type, the file will be copied block-by-block + as if the option was not specified. + + + + File cloning is only supported on some operating systems and file + systems. If it is selected but not supported, the + pg_combinebackup run will error. At present, + it is supported on Linux (kernel 4.5 or later) with Btrfs and XFS (on + file systems created with reflink support), and on macOS with APFS. + + + + + + + + + Use the copy_file_range system call for efficient + copying. On some file systems this gives results similar to + , sharing physical disk blocks, while on others + it may still copy blocks, but do so via an optimized path. At present, + it is supported on Linux and FreeBSD. + + + + copy_file_range may be used only when the + checksums match in the backup manifests. If a backup manifest is not + available or does not contain checksum of the right type, the file will + be copied block-by-block as if the option was not specified. + + + + diff --git a/src/bin/pg_combinebackup/copy_file.c b/src/bin/pg_combinebackup/copy_file.c index e6d2423278a..be8336f7120 100644 --- a/src/bin/pg_combinebackup/copy_file.c +++ b/src/bin/pg_combinebackup/copy_file.c @@ -14,6 +14,7 @@ #include #endif #include +#include #include #include @@ -24,6 +25,10 @@ static void copy_file_blocks(const char *src, const char *dst, pg_checksum_context *checksum_ctx); +static void copy_file_clone(const char *src, const char *dst); + +static void copy_file_by_range(const char *src, const char *dst); + #ifdef WIN32 static void copy_file_copyfile(const char *src, const char *dst); #endif @@ -35,8 +40,12 @@ static void copy_file_copyfile(const char *src, const char *dst); */ void copy_file(const char *src, const char *dst, - pg_checksum_context *checksum_ctx, bool dry_run) + pg_checksum_context *checksum_ctx, bool dry_run, + CopyMethod copy_method) { + char *strategy_name = NULL; + void (*strategy_implementation) (const char *, const char *) = NULL; + /* * In dry-run mode, we don't actually copy anything, nor do we read any * data from the source file, but we do verify that we can open it. @@ -52,57 +61,80 @@ copy_file(const char *src, const char *dst, } /* + * If we need to compute a checksum, but the user perhaps requested + * a special copy method that does not support this, fallback to the + * default block-by-block copy. We don't want to fail if just one of + * many files requires checksum, etc. + * * If we don't need to compute a checksum, then we can use any special * operating system primitives that we know about to copy the file; this - * may be quicker than a naive block copy. + * may be quicker than a naive block copy. We only do this for WIN32. + * On other operating systems the user has to explicitly specify one of + * the available primitives - there may be multiple, we don't know which + * are reliable/preferred. */ - if (checksum_ctx->type == CHECKSUM_TYPE_NONE) + if (checksum_ctx->type != CHECKSUM_TYPE_NONE) { - char *strategy_name = NULL; - void (*strategy_implementation) (const char *, const char *) = NULL; - + /* fallback to block-by-block copy */ + copy_method = COPY_METHOD_COPY; + } #ifdef WIN32 - strategy_name = "CopyFile"; - strategy_implementation = copy_file_copyfile; + else + { + copy_method = COPY_METHOD_COPYFILE; + } #endif - if (strategy_name != NULL) - { - if (dry_run) - pg_log_debug("would copy \"%s\" to \"%s\" using strategy %s", - src, dst, strategy_name); - else - { - pg_log_debug("copying \"%s\" to \"%s\" using strategy %s", - src, dst, strategy_name); - (*strategy_implementation) (src, dst); - } - return; - } + /* Determine the name of the copy strategy for use in log messages. */ + switch (copy_method) + { + case COPY_METHOD_CLONE: + strategy_name = "clone"; + strategy_implementation = copy_file_clone; + break; + case COPY_METHOD_COPY: + /* leave NULL for simple block-by-block copy */ + break; + case COPY_METHOD_COPY_FILE_RANGE: + strategy_name = "copy_file_range"; + strategy_implementation = copy_file_by_range; + break; +#ifdef WIN32 + case COPY_METHOD_COPYFILE: + strategy_name = "CopyFile"; + strategy_implementation = copy_file_copyfile; + break; +#endif } - /* - * Fall back to the simple approach of reading and writing all the blocks, - * feeding them into the checksum context as we go. - */ if (dry_run) { - if (checksum_ctx->type == CHECKSUM_TYPE_NONE) + if (strategy_name) + pg_log_debug("would copy \"%s\" to \"%s\" using strategy %s", + src, dst, strategy_name); + else pg_log_debug("would copy \"%s\" to \"%s\"", src, dst); - else - pg_log_debug("would copy \"%s\" to \"%s\" and checksum with %s", - src, dst, pg_checksum_type_name(checksum_ctx->type)); } else { - if (checksum_ctx->type == CHECKSUM_TYPE_NONE) - pg_log_debug("copying \"%s\" to \"%s\"", - src, dst); + if (strategy_name) + { + pg_log_debug("copying \"%s\" to \"%s\" using strategy %s", + src, dst, strategy_name); + strategy_implementation(src, dst); + } else - pg_log_debug("copying \"%s\" to \"%s\" and checksumming with %s", - src, dst, pg_checksum_type_name(checksum_ctx->type)); - copy_file_blocks(src, dst, checksum_ctx); + { + if (checksum_ctx->type == CHECKSUM_TYPE_NONE) + pg_log_debug("copying \"%s\" to \"%s\"", + src, dst); + else + pg_log_debug("copying \"%s\" to \"%s\" and checksumming with %s", + src, dst, pg_checksum_type_name(checksum_ctx->type)); + + copy_file_blocks(src, dst, checksum_ctx); + } } } @@ -156,6 +188,74 @@ copy_file_blocks(const char *src, const char *dst, close(dest_fd); } +/* + * copy_file_clone + * Clones/reflinks a file from src to dest. + */ +static void +copy_file_clone(const char *src, const char *dest) +{ +#if defined(HAVE_COPYFILE) && defined(COPYFILE_CLONE_FORCE) + if (copyfile(src, dest, NULL, COPYFILE_CLONE_FORCE) < 0) + pg_fatal("error while cloning file \"%s\" to \"%s\": %m", src, dest); +#elif defined(__linux__) && defined(FICLONE) + { + if ((src_fd = open(src, O_RDONLY | PG_BINARY, 0)) < 0) + pg_fatal("could not open file \"%s\": %m", src); + + if ((dest_fd = open(dest, O_RDWR | O_CREAT | O_EXCL | PG_BINARY, + pg_file_create_mode)) < 0) + pg_fatal("could not create file \"%s\": %m", dest); + + if (ioctl(dest_fd, FICLONE, src_fd) < 0) + { + int save_errno = errno; + + unlink(dest); + + pg_fatal("error while cloning file \"%s\" to \"%s\": %s", + src, dest); + } + } +#else + pg_fatal("file cloning not supported on this platform"); +#endif +} + +/* + * copy_file_by_range + * Copies a file from src to dest using copy_file_range system call. + */ +static void +copy_file_by_range(const char *src, const char *dest) +{ +#if defined(HAVE_COPY_FILE_RANGE) + int src_fd; + int dest_fd; + ssize_t nbytes; + + if ((src_fd = open(src, O_RDONLY | PG_BINARY, 0)) < 0) + pg_fatal("could not open file \"%s\": %m", src); + + if ((dest_fd = open(dest, O_RDWR | O_CREAT | O_EXCL | PG_BINARY, + pg_file_create_mode)) < 0) + pg_fatal("could not create file \"%s\": %m", dest); + + do + { + nbytes = copy_file_range(src_fd, NULL, dest_fd, NULL, SSIZE_MAX, 0); + if (nbytes < 0) + pg_fatal("error while copying file range from \"%s\" to \"%s\": %m", + src, dest); + } while (nbytes > 0); + + close(src_fd); + close(dest_fd); +#else + pg_fatal("copy_file_range not supported on this platform"); +#endif +} + #ifdef WIN32 static void copy_file_copyfile(const char *src, const char *dst) diff --git a/src/bin/pg_combinebackup/copy_file.h b/src/bin/pg_combinebackup/copy_file.h index 0f6bc09403f..9615595d887 100644 --- a/src/bin/pg_combinebackup/copy_file.h +++ b/src/bin/pg_combinebackup/copy_file.h @@ -11,9 +11,25 @@ #ifndef COPY_FILE_H #define COPY_FILE_H +#include "c.h" #include "common/checksum_helper.h" +#include "common/file_utils.h" + +/* + * Enumeration to denote copy modes + */ +typedef enum CopyMethod +{ + COPY_METHOD_CLONE, + COPY_METHOD_COPY, + COPY_METHOD_COPY_FILE_RANGE, +#ifdef WIN32 + COPY_METHOD_COPYFILE, +#endif +} CopyMethod; extern void copy_file(const char *src, const char *dst, - pg_checksum_context *checksum_ctx, bool dry_run); + pg_checksum_context *checksum_ctx, bool dry_run, + CopyMethod copy_method); #endif /* COPY_FILE_H */ diff --git a/src/bin/pg_combinebackup/pg_combinebackup.c b/src/bin/pg_combinebackup/pg_combinebackup.c index 74f8be9eeac..76a63d826a7 100644 --- a/src/bin/pg_combinebackup/pg_combinebackup.c +++ b/src/bin/pg_combinebackup/pg_combinebackup.c @@ -69,6 +69,7 @@ typedef struct cb_options pg_checksum_type manifest_checksums; bool no_manifest; DataDirSyncMethod sync_method; + CopyMethod copy_method; } cb_options; /* @@ -129,6 +130,8 @@ main(int argc, char *argv[]) {"manifest-checksums", required_argument, NULL, 1}, {"no-manifest", no_argument, NULL, 2}, {"sync-method", required_argument, NULL, 3}, + {"clone", no_argument, NULL, 4}, + {"copy-file-range", no_argument, NULL, 5}, {NULL, 0, NULL, 0} }; @@ -156,6 +159,7 @@ main(int argc, char *argv[]) memset(&opt, 0, sizeof(opt)); opt.manifest_checksums = CHECKSUM_TYPE_CRC32C; opt.sync_method = DATA_DIR_SYNC_METHOD_FSYNC; + opt.copy_method = COPY_METHOD_COPY; /* process command-line options */ while ((c = getopt_long(argc, argv, "dnNPo:T:", @@ -192,6 +196,12 @@ main(int argc, char *argv[]) if (!parse_sync_method(optarg, &opt.sync_method)) exit(1); break; + case 4: + opt.copy_method = COPY_METHOD_CLONE; + break; + case 5: + opt.copy_method = COPY_METHOD_COPY_FILE_RANGE; + break; default: /* getopt_long already emitted a complaint */ pg_log_error_hint("Try \"%s --help\" for more information.", progname); @@ -696,6 +706,8 @@ help(const char *progname) " use algorithm for manifest checksums\n")); printf(_(" --no-manifest suppress generation of backup manifest\n")); printf(_(" --sync-method=METHOD set method for syncing files to disk\n")); + printf(_(" --clone clone (reflink) instead of copying files\n")); + printf(_(" --copy-file-range copy using copy_file_range() syscall\n")); printf(_(" -?, --help show this help, then exit\n")); printf(_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT); @@ -937,7 +949,8 @@ process_directory_recursively(Oid tsoid, &checksum_length, &checksum_payload, opt->debug, - opt->dry_run); + opt->dry_run, + opt->copy_method); } else { @@ -993,7 +1006,8 @@ process_directory_recursively(Oid tsoid, /* Actually copy the file. */ snprintf(ofullpath, MAXPGPATH, "%s/%s", ofulldir, de->d_name); - copy_file(ifullpath, ofullpath, &checksum_ctx, opt->dry_run); + copy_file(ifullpath, ofullpath, &checksum_ctx, opt->dry_run, + opt->copy_method); /* * If copy_file() performed a checksum calculation for us, then diff --git a/src/bin/pg_combinebackup/reconstruct.c b/src/bin/pg_combinebackup/reconstruct.c index 2a8482c5083..f2c6101c6de 100644 --- a/src/bin/pg_combinebackup/reconstruct.c +++ b/src/bin/pg_combinebackup/reconstruct.c @@ -90,7 +90,8 @@ reconstruct_from_incremental_file(char *input_filename, int *checksum_length, uint8 **checksum_payload, bool debug, - bool dry_run) + bool dry_run, + CopyMethod copy_method) { rfile **source; rfile *latest_source = NULL; @@ -319,7 +320,7 @@ reconstruct_from_incremental_file(char *input_filename, */ if (copy_source != NULL) copy_file(copy_source->filename, output_filename, - &checksum_ctx, dry_run); + &checksum_ctx, dry_run, copy_method); else { write_reconstructed_file(input_filename, output_filename, diff --git a/src/bin/pg_combinebackup/reconstruct.h b/src/bin/pg_combinebackup/reconstruct.h index 8e33a8a95a0..532cd81052d 100644 --- a/src/bin/pg_combinebackup/reconstruct.h +++ b/src/bin/pg_combinebackup/reconstruct.h @@ -28,6 +28,7 @@ extern void reconstruct_from_incremental_file(char *input_filename, int *checksum_length, uint8 **checksum_payload, bool debug, - bool dry_run); + bool dry_run, + CopyMethod copy_method); #endif -- 2.44.0