copy_file.h File Reference

#include "c.h"
#include "common/checksum_helper.h"
#include "common/file_utils.h"

Include dependency graph for copy_file.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef enum CopyMethod	CopyMethod

Enumerations
enum	CopyMethod { COPY_METHOD_CLONE , COPY_METHOD_COPY , COPY_METHOD_COPY_FILE_RANGE }

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

Typedef Documentation

CopyMethod

typedef enum CopyMethod CopyMethod

Enumeration Type Documentation

CopyMethod

enum CopyMethod

Enumerator
COPY_METHOD_CLONE
COPY_METHOD_COPY
COPY_METHOD_COPY_FILE_RANGE

Definition at line 21 of file copy_file.h.

{
    COPY_METHOD_CLONE,
    COPY_METHOD_COPY,
    COPY_METHOD_COPY_FILE_RANGE,
#ifdef WIN32
    COPY_METHOD_COPYFILE,
#endif
} CopyMethod;

Function Documentation

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.