copy_file.c File Reference

#include "postgres_fe.h"
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>
#include <unistd.h>
#include "common/file_perm.h"
#include "common/logging.h"
#include "copy_file.h"

Include dependency graph for copy_file.c:

Go to the source code of this file.

Functions
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, pg_checksum_context *checksum_ctx)
static void	copy_file_by_range (const char *src, const char *dst, pg_checksum_context *checksum_ctx)
void	copy_file (const char *src, const char *dst, pg_checksum_context *checksum_ctx, CopyMethod copy_method, bool dry_run)
static void	checksum_file (const char *src, pg_checksum_context *checksum_ctx)

Function Documentation

checksum_file()

static void checksum_file ( const char *  src, pg_checksum_context *  checksum_ctx  )

static

Definition at line 123 of file copy_file.c.

{
    int         src_fd;
    uint8      *buffer;
    const int   buffer_size = 50 * BLCKSZ;
    ssize_t     rb;
 
    /* bail out if no checksum needed */
    if (checksum_ctx->type == CHECKSUM_TYPE_NONE)
        return;
 
    if ((src_fd = open(src, O_RDONLY | PG_BINARY, 0)) < 0)
        pg_fatal("could not open file \"%s\": %m", src);
 
    buffer = pg_malloc(buffer_size);
 
    while ((rb = read(src_fd, buffer, buffer_size)) > 0)
    {
        if (pg_checksum_update(checksum_ctx, buffer, rb) < 0)
            pg_fatal("could not update checksum of file \"%s\"", src);
    }
 
    if (rb < 0)
        pg_fatal("could not read file \"%s\": %m", src);
 
    pg_free(buffer);
    close(src_fd);
}

References CHECKSUM_TYPE_NONE, close, PG_BINARY, pg_checksum_update(), pg_fatal, pg_free(), pg_malloc(), read, and pg_checksum_context::type.

Referenced by copy_file_by_range(), and copy_file_clone().

copy_file()

void copy_file	(	const char *	src,
		const char *	dst,
		pg_checksum_context *	checksum_ctx,
		CopyMethod	copy_method,
		bool	dry_run
	)

Definition at line 45 of file copy_file.c.

{
    char       *strategy_name = NULL;
    void        (*strategy_implementation) (const char *, const char *,
                                            pg_checksum_context *checksum_ctx) = 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.
     */
    if (dry_run)
    {
        int         fd;
 
        if ((fd = open(src, O_RDONLY | PG_BINARY, 0)) < 0)
            pg_fatal("could not open \"%s\": %m", src);
        if (close(fd) < 0)
            pg_fatal("could not close \"%s\": %m", src);
    }
 
#ifdef WIN32
    copy_method = COPY_METHOD_COPYFILE;
#endif
 
    /* 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 */
            strategy_implementation = copy_file_blocks;
            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
    }
 
    if (dry_run)
    {
        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
    {
        if (strategy_name)
            pg_log_debug("copying \"%s\" to \"%s\" using strategy %s",
                         src, dst, strategy_name);
        else 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));
 
        strategy_implementation(src, dst, checksum_ctx);
    }
}

References CHECKSUM_TYPE_NONE, close, copy_file_blocks(), copy_file_by_range(), copy_file_clone(), COPY_METHOD_CLONE, COPY_METHOD_COPY, COPY_METHOD_COPY_FILE_RANGE, dry_run, fd(), PG_BINARY, pg_checksum_type_name(), pg_fatal, pg_log_debug, and pg_checksum_context::type.

copy_file_blocks()

static void copy_file_blocks ( const char *  src, const char *  dst, pg_checksum_context *  checksum_ctx  )

static

Definition at line 156 of file copy_file.c.

{
    int         src_fd;
    int         dest_fd;
    uint8      *buffer;
    const int   buffer_size = 50 * BLCKSZ;
    ssize_t     rb;
    unsigned    offset = 0;
 
    if ((src_fd = open(src, O_RDONLY | PG_BINARY, 0)) < 0)
        pg_fatal("could not open file \"%s\": %m", src);
 
    if ((dest_fd = open(dst, O_WRONLY | O_CREAT | O_EXCL | PG_BINARY,
                        pg_file_create_mode)) < 0)
        pg_fatal("could not open file \"%s\": %m", dst);
 
    buffer = pg_malloc(buffer_size);
 
    while ((rb = read(src_fd, buffer, buffer_size)) > 0)
    {
        ssize_t     wb;
 
        if ((wb = write(dest_fd, buffer, rb)) != rb)
        {
            if (wb < 0)
                pg_fatal("could not write file \"%s\": %m", dst);
            else
                pg_fatal("could not write file \"%s\": wrote only %d of %d bytes at offset %u",
                         dst, (int) wb, (int) rb, offset);
        }
 
        if (pg_checksum_update(checksum_ctx, buffer, rb) < 0)
            pg_fatal("could not update checksum of file \"%s\"", dst);
 
        offset += rb;
    }
 
    if (rb < 0)
        pg_fatal("could not read file \"%s\": %m", dst);
 
    pg_free(buffer);
    close(src_fd);
    close(dest_fd);
}

References close, PG_BINARY, pg_checksum_update(), pg_fatal, pg_file_create_mode, pg_free(), pg_malloc(), read, and write.

Referenced by copy_file().

copy_file_by_range()

static void copy_file_by_range ( const char *  src, const char *  dst, pg_checksum_context *  checksum_ctx  )

static

Definition at line 249 of file copy_file.c.

{
#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
 
    /* if needed, calculate checksum of the file */
    checksum_file(src, checksum_ctx);
}

References checksum_file(), close, generate_unaccent_rules::dest, PG_BINARY, pg_fatal, and pg_file_create_mode.

Referenced by copy_file().

copy_file_clone()

static void copy_file_clone ( const char *  src, const char *  dst, pg_checksum_context *  checksum_ctx  )

static

Definition at line 209 of file copy_file.c.

{
#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
 
    /* if needed, calculate checksum of the file */
    checksum_file(src, checksum_ctx);
}

References checksum_file(), generate_unaccent_rules::dest, PG_BINARY, pg_fatal, and pg_file_create_mode.

Referenced by copy_file().