file_ops.c File Reference

#include "postgres_fe.h"
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include "common/file_perm.h"
#include "common/file_utils.h"
#include "file_ops.h"
#include "filemap.h"
#include "pg_rewind.h"

Include dependency graph for file_ops.c:

Go to the source code of this file.

Functions
static void	create_target_dir (const char *path)
static void	remove_target_dir (const char *path)
static void	create_target_symlink (const char *path, const char *link)
static void	remove_target_symlink (const char *path)
static void	recurse_dir (const char *datadir, const char *parentpath, process_file_callback_t callback)
void	open_target_file (const char *path, bool trunc)
void	close_target_file (void)
void	write_target_range (char *buf, off_t begin, size_t size)
void	remove_target (file_entry_t *entry)
void	create_target (file_entry_t *entry)
void	remove_target_file (const char *path, bool missing_ok)
void	truncate_target_file (const char *path, off_t newsize)
void	sync_target_dir (void)
char *	slurpFile (const char *datadir, const char *path, size_t *filesize)
void	traverse_datadir (const char *datadir, process_file_callback_t callback)

Variables
static int	dstfd = -1
static char	dstpath [MAXPGPATH] = ""

Function Documentation

close_target_file()

void close_target_file

(

void

)

Definition at line 75 of file file_ops.c.

{
    if (dstfd == -1)
        return;
 
    if (close(dstfd) != 0)
        pg_fatal("could not close target file \"%s\": %m",
                 dstpath);
 
    dstfd = -1;
}

References close, dstfd, dstpath, and pg_fatal.

Referenced by createBackupLabel(), open_target_file(), and perform_rewind().

create_target()

void create_target

(

file_entry_t *

entry

)

Definition at line 156 of file file_ops.c.

{
    Assert(entry->action == FILE_ACTION_CREATE);
    Assert(!entry->target_exists);
 
    switch (entry->source_type)
    {
        case FILE_TYPE_DIRECTORY:
            create_target_dir(entry->path);
            break;
 
        case FILE_TYPE_SYMLINK:
            create_target_symlink(entry->path, entry->source_link_target);
            break;
 
        case FILE_TYPE_REGULAR:
            /* can't happen. Regular files are created with open_target_file. */
            pg_fatal("invalid action (CREATE) for regular file");
            break;
 
        case FILE_TYPE_UNDEFINED:
            pg_fatal("undefined file type for \"%s\"", entry->path);
            break;
    }
}

References file_entry_t::action, Assert(), create_target_dir(), create_target_symlink(), FILE_ACTION_CREATE, FILE_TYPE_DIRECTORY, FILE_TYPE_REGULAR, FILE_TYPE_SYMLINK, FILE_TYPE_UNDEFINED, file_entry_t::path, pg_fatal, file_entry_t::source_link_target, file_entry_t::source_type, and file_entry_t::target_exists.

Referenced by perform_rewind().

create_target_dir()

static void create_target_dir ( const char *  path )

static

Definition at line 229 of file file_ops.c.

{
    char        dstpath[MAXPGPATH];
 
    if (dry_run)
        return;
 
    snprintf(dstpath, sizeof(dstpath), "%s/%s", datadir_target, path);
    if (mkdir(dstpath, pg_dir_create_mode) != 0)
        pg_fatal("could not create directory \"%s\": %m",
                 dstpath);
}

References datadir_target, dry_run, dstpath, MAXPGPATH, mkdir, pg_dir_create_mode, pg_fatal, and snprintf.

Referenced by create_target().

create_target_symlink()

static void create_target_symlink ( const char *  path, const char *  link  )

static

Definition at line 257 of file file_ops.c.

{
    char        dstpath[MAXPGPATH];
 
    if (dry_run)
        return;
 
    snprintf(dstpath, sizeof(dstpath), "%s/%s", datadir_target, path);
    if (symlink(link, dstpath) != 0)
        pg_fatal("could not create symbolic link at \"%s\": %m",
                 dstpath);
}

References datadir_target, dry_run, dstpath, MAXPGPATH, pg_fatal, snprintf, and symlink.

Referenced by create_target().

open_target_file()

void open_target_file	(	const char *	path,
		bool	trunc
	)

Definition at line 47 of file file_ops.c.

{
    int         mode;
 
    if (dry_run)
        return;
 
    if (dstfd != -1 && !trunc &&
        strcmp(path, &dstpath[strlen(datadir_target) + 1]) == 0)
        return;                 /* already open */
 
    close_target_file();
 
    snprintf(dstpath, sizeof(dstpath), "%s/%s", datadir_target, path);
 
    mode = O_WRONLY | O_CREAT | PG_BINARY;
    if (trunc)
        mode |= O_TRUNC;
    dstfd = open(dstpath, mode, pg_file_create_mode);
    if (dstfd < 0)
        pg_fatal("could not open target file \"%s\": %m",
                 dstpath);
}

References close_target_file(), datadir_target, dry_run, dstfd, dstpath, mode, PG_BINARY, pg_fatal, pg_file_create_mode, and snprintf.

Referenced by createBackupLabel(), libpq_queue_fetch_file(), local_queue_fetch_file(), local_queue_fetch_range(), and process_queued_fetch_requests().

recurse_dir()

static void recurse_dir ( const char *  datadir, const char *  parentpath, process_file_callback_t  callback  )

static

Definition at line 374 of file file_ops.c.

{
    DIR        *xldir;
    struct dirent *xlde;
    char        fullparentpath[MAXPGPATH];
 
    if (parentpath)
        snprintf(fullparentpath, MAXPGPATH, "%s/%s", datadir, parentpath);
    else
        snprintf(fullparentpath, MAXPGPATH, "%s", datadir);
 
    xldir = opendir(fullparentpath);
    if (xldir == NULL)
        pg_fatal("could not open directory \"%s\": %m",
                 fullparentpath);
 
    while (errno = 0, (xlde = readdir(xldir)) != NULL)
    {
        struct stat fst;
        char        fullpath[MAXPGPATH * 2];
        char        path[MAXPGPATH * 2];
 
        if (strcmp(xlde->d_name, ".") == 0 ||
            strcmp(xlde->d_name, "..") == 0)
            continue;
 
        snprintf(fullpath, sizeof(fullpath), "%s/%s", fullparentpath, xlde->d_name);
 
        if (lstat(fullpath, &fst) < 0)
        {
            if (errno == ENOENT)
            {
                /*
                 * File doesn't exist anymore. This is ok, if the new primary
                 * is running and the file was just removed. If it was a data
                 * file, there should be a WAL record of the removal. If it
                 * was something else, it couldn't have been anyway.
                 *
                 * TODO: But complain if we're processing the target dir!
                 */
            }
            else
                pg_fatal("could not stat file \"%s\": %m",
                         fullpath);
        }
 
        if (parentpath)
            snprintf(path, sizeof(path), "%s/%s", parentpath, xlde->d_name);
        else
            snprintf(path, sizeof(path), "%s", xlde->d_name);
 
        if (S_ISREG(fst.st_mode))
            callback(path, FILE_TYPE_REGULAR, fst.st_size, NULL);
        else if (S_ISDIR(fst.st_mode))
        {
            callback(path, FILE_TYPE_DIRECTORY, 0, NULL);
            /* recurse to handle subdirectories */
            recurse_dir(datadir, path, callback);
        }
        else if (S_ISLNK(fst.st_mode))
        {
            char        link_target[MAXPGPATH];
            int         len;
 
            len = readlink(fullpath, link_target, sizeof(link_target));
            if (len < 0)
                pg_fatal("could not read symbolic link \"%s\": %m",
                         fullpath);
            if (len >= sizeof(link_target))
                pg_fatal("symbolic link \"%s\" target is too long",
                         fullpath);
            link_target[len] = '\0';
 
            callback(path, FILE_TYPE_SYMLINK, 0, link_target);
 
            /*
             * If it's a symlink within pg_tblspc, we need to recurse into it,
             * to process all the tablespaces.  We also follow a symlink if
             * it's for pg_wal.  Symlinks elsewhere are ignored.
             */
            if ((parentpath && strcmp(parentpath, PG_TBLSPC_DIR) == 0) ||
                strcmp(path, "pg_wal") == 0)
                recurse_dir(datadir, path, callback);
        }
    }
 
    if (errno)
        pg_fatal("could not read directory \"%s\": %m",
                 fullparentpath);
 
    if (closedir(xldir))
        pg_fatal("could not close directory \"%s\": %m",
                 fullparentpath);
}

References callback(), closedir(), dirent::d_name, datadir, FILE_TYPE_DIRECTORY, FILE_TYPE_REGULAR, FILE_TYPE_SYMLINK, len, lstat, MAXPGPATH, opendir(), pg_fatal, PG_TBLSPC_DIR, readdir(), readlink, recurse_dir(), S_ISDIR, S_ISLNK, S_ISREG, snprintf, stat::st_mode, and stat::st_size.

Referenced by recurse_dir(), and traverse_datadir().

remove_target()

void remove_target

(

file_entry_t *

entry

)

Definition at line 130 of file file_ops.c.

{
    Assert(entry->action == FILE_ACTION_REMOVE);
    Assert(entry->target_exists);
 
    switch (entry->target_type)
    {
        case FILE_TYPE_DIRECTORY:
            remove_target_dir(entry->path);
            break;
 
        case FILE_TYPE_REGULAR:
            remove_target_file(entry->path, false);
            break;
 
        case FILE_TYPE_SYMLINK:
            remove_target_symlink(entry->path);
            break;
 
        case FILE_TYPE_UNDEFINED:
            pg_fatal("undefined file type for \"%s\"", entry->path);
            break;
    }
}

References file_entry_t::action, Assert(), FILE_ACTION_REMOVE, FILE_TYPE_DIRECTORY, FILE_TYPE_REGULAR, FILE_TYPE_SYMLINK, FILE_TYPE_UNDEFINED, file_entry_t::path, pg_fatal, remove_target_dir(), remove_target_file(), remove_target_symlink(), file_entry_t::target_exists, and file_entry_t::target_type.

Referenced by perform_rewind().

remove_target_dir()

static void remove_target_dir ( const char *  path )

static

Definition at line 243 of file file_ops.c.

{
    char        dstpath[MAXPGPATH];
 
    if (dry_run)
        return;
 
    snprintf(dstpath, sizeof(dstpath), "%s/%s", datadir_target, path);
    if (rmdir(dstpath) != 0)
        pg_fatal("could not remove directory \"%s\": %m",
                 dstpath);
}

References datadir_target, dry_run, dstpath, MAXPGPATH, pg_fatal, and snprintf.

Referenced by remove_target().

remove_target_file()

void remove_target_file	(	const char *	path,
		bool	missing_ok
	)

Definition at line 187 of file file_ops.c.

{
    char        dstpath[MAXPGPATH];
 
    if (dry_run)
        return;
 
    snprintf(dstpath, sizeof(dstpath), "%s/%s", datadir_target, path);
    if (unlink(dstpath) != 0)
    {
        if (errno == ENOENT && missing_ok)
            return;
 
        pg_fatal("could not remove file \"%s\": %m",
                 dstpath);
    }
}

References datadir_target, dry_run, dstpath, MAXPGPATH, pg_fatal, and snprintf.

Referenced by process_queued_fetch_requests(), and remove_target().

remove_target_symlink()

static void remove_target_symlink ( const char *  path )

static

Definition at line 271 of file file_ops.c.

{
    char        dstpath[MAXPGPATH];
 
    if (dry_run)
        return;
 
    snprintf(dstpath, sizeof(dstpath), "%s/%s", datadir_target, path);
    if (unlink(dstpath) != 0)
        pg_fatal("could not remove symbolic link \"%s\": %m",
                 dstpath);
}

References datadir_target, dry_run, dstpath, MAXPGPATH, pg_fatal, and snprintf.

Referenced by remove_target().

slurpFile()

char * slurpFile	(	const char *	datadir,
		const char *	path,
		size_t *	filesize
	)

Definition at line 314 of file file_ops.c.

{
    int         fd;
    char       *buffer;
    struct stat statbuf;
    char        fullpath[MAXPGPATH];
    int         len;
    int         r;
 
    snprintf(fullpath, sizeof(fullpath), "%s/%s", datadir, path);
 
    if ((fd = open(fullpath, O_RDONLY | PG_BINARY, 0)) == -1)
        pg_fatal("could not open file \"%s\" for reading: %m",
                 fullpath);
 
    if (fstat(fd, &statbuf) < 0)
        pg_fatal("could not open file \"%s\" for reading: %m",
                 fullpath);
 
    len = statbuf.st_size;
 
    buffer = pg_malloc(len + 1);
 
    r = read(fd, buffer, len);
    if (r != len)
    {
        if (r < 0)
            pg_fatal("could not read file \"%s\": %m",
                     fullpath);
        else
            pg_fatal("could not read file \"%s\": read %d of %zu",
                     fullpath, r, (Size) len);
    }
    close(fd);
 
    /* Zero-terminate the buffer. */
    buffer[len] = '\0';
 
    if (filesize)
        *filesize = len;
    return buffer;
}

References close, datadir, fd(), fstat, len, MAXPGPATH, PG_BINARY, pg_fatal, pg_malloc(), read, snprintf, and stat::st_size.

Referenced by getTimelineHistory(), local_fetch_file(), and main().

sync_target_dir()

void sync_target_dir

(

void

)

Definition at line 294 of file file_ops.c.

{
    if (!do_sync || dry_run)
        return;
 
    sync_pgdata(datadir_target, PG_VERSION_NUM, sync_method, true);
}

References datadir_target, do_sync, dry_run, and sync_method.

Referenced by main().

traverse_datadir()

void traverse_datadir	(	const char *	datadir,
		process_file_callback_t	callback
	)

Definition at line 362 of file file_ops.c.

{
    recurse_dir(datadir, NULL, callback);
}

References callback(), datadir, and recurse_dir().

Referenced by local_traverse_files(), and main().

truncate_target_file()

void truncate_target_file	(	const char *	path,
		off_t	newsize
	)

Definition at line 206 of file file_ops.c.

{
    char        dstpath[MAXPGPATH];
    int         fd;
 
    if (dry_run)
        return;
 
    snprintf(dstpath, sizeof(dstpath), "%s/%s", datadir_target, path);
 
    fd = open(dstpath, O_WRONLY, pg_file_create_mode);
    if (fd < 0)
        pg_fatal("could not open file \"%s\" for truncation: %m",
                 dstpath);
 
    if (ftruncate(fd, newsize) != 0)
        pg_fatal("could not truncate file \"%s\" to %u: %m",
                 dstpath, (unsigned int) newsize);
 
    close(fd);
}

References close, datadir_target, dry_run, dstpath, fd(), MAXPGPATH, pg_fatal, pg_file_create_mode, and snprintf.

Referenced by perform_rewind().

write_target_range()

void write_target_range	(	char *	buf,
		off_t	begin,
		size_t	size
	)

Definition at line 88 of file file_ops.c.

{
    size_t      writeleft;
    char       *p;
 
    /* update progress report */
    fetch_done += size;
    progress_report(false);
 
    if (dry_run)
        return;
 
    if (lseek(dstfd, begin, SEEK_SET) == -1)
        pg_fatal("could not seek in target file \"%s\": %m",
                 dstpath);
 
    writeleft = size;
    p = buf;
    while (writeleft > 0)
    {
        ssize_t     writelen;
 
        errno = 0;
        writelen = write(dstfd, p, writeleft);
        if (writelen < 0)
        {
            /* if write didn't set errno, assume problem is no disk space */
            if (errno == 0)
                errno = ENOSPC;
            pg_fatal("could not write file \"%s\": %m",
                     dstpath);
        }
 
        p += writelen;
        writeleft -= writelen;
    }
 
    /* keep the file open, in case we need to copy more blocks in it */
}

References buf, dry_run, dstfd, dstpath, fetch_done, pg_fatal, progress_report(), and write.

Referenced by createBackupLabel(), local_queue_fetch_file(), local_queue_fetch_range(), and process_queued_fetch_requests().

Variable Documentation

dstfd

int dstfd = -1

static

Definition at line 31 of file file_ops.c.

Referenced by clone_file(), close_target_file(), copy_file(), open_target_file(), and write_target_range().

dstpath

char dstpath[MAXPGPATH] = ""

static

Definition at line 32 of file file_ops.c.

Referenced by check_db_file_conflict(), close_target_file(), create_target_dir(), create_target_symlink(), CreateDatabaseUsingFileCopy(), CreateDatabaseUsingWalLog(), movedb_failure_callback(), open_target_file(), remove_dbtablespaces(), remove_target_dir(), remove_target_file(), remove_target_symlink(), ResetUnloggedRelationsInDbspaceDir(), truncate_target_file(), and write_target_range().