copydir.h File Reference

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

Go to the source code of this file.

Typedefs
typedef enum FileCopyMethod	FileCopyMethod

Enumerations
enum	FileCopyMethod { FILE_COPY_METHOD_COPY , FILE_COPY_METHOD_CLONE }

Functions
void	copydir (const char *fromdir, const char *todir, bool recurse)
void	copy_file (const char *fromfile, const char *tofile)

Variables
PGDLLIMPORT int	file_copy_method

Typedef Documentation

FileCopyMethod

typedef enum FileCopyMethod FileCopyMethod

Enumeration Type Documentation

FileCopyMethod

enum FileCopyMethod

Enumerator
FILE_COPY_METHOD_COPY
FILE_COPY_METHOD_CLONE

Definition at line 16 of file copydir.h.

{
    FILE_COPY_METHOD_COPY,
    FILE_COPY_METHOD_CLONE,
} FileCopyMethod;

Function Documentation

copy_file()

void copy_file	(	const char *	fromfile,
		const char *	tofile
	)

Definition at line 133 of file copydir.c.

{
    char       *buffer;
    int         srcfd;
    int         dstfd;
    int         nbytes;
    off_t       offset;
    off_t       flush_offset;
 
    /* Size of copy buffer (read and write requests) */
#define COPY_BUF_SIZE (8 * BLCKSZ)
 
    /*
     * Size of data flush requests.  It seems beneficial on most platforms to
     * do this every 1MB or so.  But macOS, at least with early releases of
     * APFS, is really unfriendly to small mmap/msync requests, so there do it
     * only every 32MB.
     */
#if defined(__darwin__)
#define FLUSH_DISTANCE (32 * 1024 * 1024)
#else
#define FLUSH_DISTANCE (1024 * 1024)
#endif
 
    /* Use palloc to ensure we get a maxaligned buffer */
    buffer = palloc(COPY_BUF_SIZE);
 
    /*
     * Open the files
     */
    srcfd = OpenTransientFile(fromfile, O_RDONLY | PG_BINARY);
    if (srcfd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not open file \"%s\": %m", fromfile)));
 
    dstfd = OpenTransientFile(tofile, O_RDWR | O_CREAT | O_EXCL | PG_BINARY);
    if (dstfd < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not create file \"%s\": %m", tofile)));
 
    /*
     * Do the data copying.
     */
    flush_offset = 0;
    for (offset = 0;; offset += nbytes)
    {
        /* If we got a cancel signal during the copy of the file, quit */
        CHECK_FOR_INTERRUPTS();
 
        /*
         * We fsync the files later, but during the copy, flush them every so
         * often to avoid spamming the cache and hopefully get the kernel to
         * start writing them out before the fsync comes.
         */
        if (offset - flush_offset >= FLUSH_DISTANCE)
        {
            pg_flush_data(dstfd, flush_offset, offset - flush_offset);
            flush_offset = offset;
        }
 
        pgstat_report_wait_start(WAIT_EVENT_COPY_FILE_READ);
        nbytes = read(srcfd, buffer, COPY_BUF_SIZE);
        pgstat_report_wait_end();
        if (nbytes < 0)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not read file \"%s\": %m", fromfile)));
        if (nbytes == 0)
            break;
        errno = 0;
        pgstat_report_wait_start(WAIT_EVENT_COPY_FILE_WRITE);
        if ((int) write(dstfd, buffer, nbytes) != nbytes)
        {
            /* if write didn't set errno, assume problem is no disk space */
            if (errno == 0)
                errno = ENOSPC;
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not write to file \"%s\": %m", tofile)));
        }
        pgstat_report_wait_end();
    }
 
    if (offset > flush_offset)
        pg_flush_data(dstfd, flush_offset, offset - flush_offset);
 
    if (CloseTransientFile(dstfd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m", tofile)));
 
    if (CloseTransientFile(srcfd) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not close file \"%s\": %m", fromfile)));
 
    pfree(buffer);
}

References CHECK_FOR_INTERRUPTS, CloseTransientFile(), COPY_BUF_SIZE, dstfd, ereport, errcode_for_file_access(), errmsg(), ERROR, FLUSH_DISTANCE, OpenTransientFile(), palloc(), pfree(), PG_BINARY, pg_flush_data(), pgstat_report_wait_end(), pgstat_report_wait_start(), read, and write.

Referenced by basic_archive_file(), copydir(), process_directory_recursively(), reconstruct_from_incremental_file(), and ResetUnloggedRelationsInDbspaceDir().

copydir()

void copydir	(	const char *	fromdir,
		const char *	todir,
		bool	recurse
	)

Definition at line 48 of file copydir.c.

{
    DIR        *xldir;
    struct dirent *xlde;
    char        fromfile[MAXPGPATH * 2];
    char        tofile[MAXPGPATH * 2];
 
    if (MakePGDirectory(todir) != 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not create directory \"%s\": %m", todir)));
 
    xldir = AllocateDir(fromdir);
 
    while ((xlde = ReadDir(xldir, fromdir)) != NULL)
    {
        PGFileType  xlde_type;
 
        /* If we got a cancel signal during the copy of the directory, quit */
        CHECK_FOR_INTERRUPTS();
 
        if (strcmp(xlde->d_name, ".") == 0 ||
            strcmp(xlde->d_name, "..") == 0)
            continue;
 
        snprintf(fromfile, sizeof(fromfile), "%s/%s", fromdir, xlde->d_name);
        snprintf(tofile, sizeof(tofile), "%s/%s", todir, xlde->d_name);
 
        xlde_type = get_dirent_type(fromfile, xlde, false, ERROR);
 
        if (xlde_type == PGFILETYPE_DIR)
        {
            /* recurse to handle subdirectories */
            if (recurse)
                copydir(fromfile, tofile, true);
        }
        else if (xlde_type == PGFILETYPE_REG)
        {
            if (file_copy_method == FILE_COPY_METHOD_CLONE)
                clone_file(fromfile, tofile);
            else
                copy_file(fromfile, tofile);
        }
    }
    FreeDir(xldir);
 
    /*
     * 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);
 
    while ((xlde = ReadDir(xldir, todir)) != NULL)
    {
        if (strcmp(xlde->d_name, ".") == 0 ||
            strcmp(xlde->d_name, "..") == 0)
            continue;
 
        snprintf(tofile, sizeof(tofile), "%s/%s", todir, xlde->d_name);
 
        /*
         * We don't need to sync subdirectories here since the recursive
         * copydir will do it before it returns
         */
        if (get_dirent_type(tofile, xlde, false, ERROR) == PGFILETYPE_REG)
            fsync_fname(tofile, false);
    }
    FreeDir(xldir);
 
    /*
     * It's important to fsync the destination directory itself as individual
     * file fsyncs don't guarantee that the directory entry for the file is
     * synced. Recent versions of ext4 have made the window much wider but
     * it's been true for ext3 and other filesystems in the past.
     */
    fsync_fname(todir, true);
}

References AllocateDir(), CHECK_FOR_INTERRUPTS, clone_file(), copy_file(), copydir(), dirent::d_name, enableFsync, ereport, errcode_for_file_access(), errmsg(), ERROR, file_copy_method, FILE_COPY_METHOD_CLONE, FreeDir(), fsync_fname(), get_dirent_type(), MakePGDirectory(), MAXPGPATH, PGFILETYPE_DIR, PGFILETYPE_REG, ReadDir(), and snprintf.

Referenced by copydir(), CreateDatabaseUsingFileCopy(), dbase_redo(), and movedb().

Variable Documentation

file_copy_method

PGDLLIMPORT int file_copy_method

extern

Definition at line 34 of file copydir.c.

Referenced by copydir().