file_utils.c File Reference

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

Include dependency graph for file_utils.c:

Go to the source code of this file.

Macros
#define	MINIMUM_VERSION_FOR_PG_WAL   100000

Functions
static void	walkdir (const char *path, int(*action)(const char *fname, bool isdir, const char *progname), bool process_symlinks, const char *progname)
void	fsync_pgdata (const char *pg_data, const char *progname, int serverVersion)
void	fsync_dir_recurse (const char *dir, const char *progname)
int	fsync_fname (const char *fname, bool isdir, const char *progname)
int	fsync_parent_path (const char *fname, const char *progname)
int	durable_rename (const char *oldfile, const char *newfile, const char *progname)

Macro Definition Documentation

#define MINIMUM_VERSION_FOR_PG_WAL   100000

Definition at line 35 of file file_utils.c.

Referenced by fsync_pgdata().

Function Documentation

int durable_rename	(	const char *	oldfile,
		const char *	newfile,
		const char *	progname
	)

Definition at line 348 of file file_utils.c.

References _, close, fd(), fsync, fsync_fname(), fsync_parent_path(), PG_BINARY, and strerror().

{
    int         fd;

    /*
     * First fsync the old and target path (if it exists), to ensure that they
     * are properly persistent on disk. Syncing the target file is not
     * strictly necessary, but it makes it easier to reason about crashes;
     * because it's then guaranteed that either source or target file exists
     * after a crash.
     */
    if (fsync_fname(oldfile, false, progname) != 0)
        return -1;

    fd = open(newfile, PG_BINARY | O_RDWR, 0);
    if (fd < 0)
    {
        if (errno != ENOENT)
        {
            fprintf(stderr, _("%s: could not open file \"%s\": %s\n"),
                    progname, newfile, strerror(errno));
            return -1;
        }
    }
    else
    {
        if (fsync(fd) != 0)
        {
            fprintf(stderr, _("%s: could not fsync file \"%s\": %s\n"),
                    progname, newfile, strerror(errno));
            close(fd);
            return -1;
        }
        close(fd);
    }

    /* Time to do the real deal... */
    if (rename(oldfile, newfile) != 0)
    {
        fprintf(stderr, _("%s: could not rename file \"%s\" to \"%s\": %s\n"),
                progname, oldfile, newfile, strerror(errno));
        return -1;
    }

    /*
     * To guarantee renaming the file is persistent, fsync the file with its
     * new name, and its containing directory.
     */
    if (fsync_fname(newfile, false, progname) != 0)
        return -1;

    if (fsync_parent_path(newfile, progname) != 0)
        return -1;

    return 0;
}

void fsync_dir_recurse	(	const char *	dir,
		const char *	progname
	)

Definition at line 124 of file file_utils.c.

References fsync_fname(), and walkdir().

Referenced by _CloseArchive().

{
    /*
     * If possible, hint to the kernel that we're soon going to fsync the data
     * directory and its contents.
     */
#ifdef PG_FLUSH_DATA_WORKS
    walkdir(dir, pre_sync_fname, false, progname);
#endif

    walkdir(dir, fsync_fname, false, progname);
}

int fsync_fname	(	const char *	fname,
		bool	isdir,
		const char *	progname
	)

Definition at line 263 of file file_utils.c.

References _, close, fd(), fsync, PG_BINARY, and strerror().

Referenced by durable_rename(), fsync_dir_recurse(), fsync_parent_path(), and fsync_pgdata().

{
    int         fd;
    int         flags;
    int         returncode;

    /*
     * Some OSs require directories to be opened read-only whereas other
     * systems don't allow us to fsync files opened read-only; so we need both
     * cases here.  Using O_RDWR will cause us to fail to fsync files that are
     * not writable by our userid, but we assume that's OK.
     */
    flags = PG_BINARY;
    if (!isdir)
        flags |= O_RDWR;
    else
        flags |= O_RDONLY;

    /*
     * Open the file, silently ignoring errors about unreadable files (or
     * unsupported operations, e.g. opening a directory under Windows), and
     * logging others.
     */
    fd = open(fname, flags);
    if (fd < 0)
    {
        if (errno == EACCES || (isdir && errno == EISDIR))
            return 0;
        fprintf(stderr, _("%s: could not open file \"%s\": %s\n"),
                progname, fname, strerror(errno));
        return -1;
    }

    returncode = fsync(fd);

    /*
     * Some OSes don't allow us to fsync directories at all, so we can ignore
     * those errors. Anything else needs to be reported.
     */
    if (returncode != 0 && !(isdir && errno == EBADF))
    {
        fprintf(stderr, _("%s: could not fsync file \"%s\": %s\n"),
                progname, fname, strerror(errno));
        (void) close(fd);
        return -1;
    }

    (void) close(fd);
    return 0;
}

int fsync_parent_path	(	const char *	fname,
		const char *	progname
	)

Definition at line 321 of file file_utils.c.

References fsync_fname(), get_parent_directory(), MAXPGPATH, and strlcpy().

Referenced by durable_rename().

{
    char        parentpath[MAXPGPATH];

    strlcpy(parentpath, fname, MAXPGPATH);
    get_parent_directory(parentpath);

    /*
     * get_parent_directory() returns an empty string if the input argument is
     * just a file name (see comments in path.c), so handle that as being the
     * current directory.
     */
    if (strlen(parentpath) == 0)
        strlcpy(parentpath, ".", MAXPGPATH);

    if (fsync_fname(parentpath, true, progname) != 0)
        return -1;

    return 0;
}

void fsync_pgdata	(	const char *	pg_data,
		const char *	progname,
		int	serverVersion
	)

Definition at line 58 of file file_utils.c.

References _, fsync_fname(), lstat, MAXPGPATH, MINIMUM_VERSION_FOR_PG_WAL, snprintf(), strerror(), and walkdir().

Referenced by BaseBackup(), and main().

{
    bool        xlog_is_symlink;
    char        pg_wal[MAXPGPATH];
    char        pg_tblspc[MAXPGPATH];

    /* handle renaming of pg_xlog to pg_wal in post-10 clusters */
    snprintf(pg_wal, MAXPGPATH, "%s/%s", pg_data,
             serverVersion < MINIMUM_VERSION_FOR_PG_WAL ? "pg_xlog" : "pg_wal");
    snprintf(pg_tblspc, MAXPGPATH, "%s/pg_tblspc", pg_data);

    /*
     * If pg_wal is a symlink, we'll need to recurse into it separately,
     * because the first walkdir below will ignore it.
     */
    xlog_is_symlink = false;

#ifndef WIN32
    {
        struct stat st;

        if (lstat(pg_wal, &st) < 0)
            fprintf(stderr, _("%s: could not stat file \"%s\": %s\n"),
                    progname, pg_wal, strerror(errno));
        else if (S_ISLNK(st.st_mode))
            xlog_is_symlink = true;
    }
#else
    if (pgwin32_is_junction(pg_wal))
        xlog_is_symlink = true;
#endif

    /*
     * If possible, hint to the kernel that we're soon going to fsync the data
     * directory and its contents.
     */
#ifdef PG_FLUSH_DATA_WORKS
    walkdir(pg_data, pre_sync_fname, false, progname);
    if (xlog_is_symlink)
        walkdir(pg_wal, pre_sync_fname, false, progname);
    walkdir(pg_tblspc, pre_sync_fname, true, progname);
#endif

    /*
     * Now we do the fsync()s in the same order.
     *
     * The main call ignores symlinks, so in addition to specially processing
     * pg_wal if it's a symlink, pg_tblspc has to be visited separately with
     * process_symlinks = true.  Note that if there are any plain directories
     * in pg_tblspc, they'll get fsync'd twice.  That's not an expected case
     * so we don't worry about optimizing it.
     */
    walkdir(pg_data, fsync_fname, false, progname);
    if (xlog_is_symlink)
        walkdir(pg_wal, fsync_fname, false, progname);
    walkdir(pg_tblspc, fsync_fname, true, progname);
}

static void walkdir ( const char *  path, int(*)(const char *fname, bool isdir, const char *progname)  action, bool  process_symlinks, const char *  progname  )

static

Definition at line 152 of file file_utils.c.

References _, closedir(), dirent::d_name, lstat, MAXPGPATH, NULL, opendir(), progname, readdir(), snprintf(), strerror(), and subpath().

Referenced by fsync_dir_recurse(), and fsync_pgdata().

{
    DIR        *dir;
    struct dirent *de;

    dir = opendir(path);
    if (dir == NULL)
    {
        fprintf(stderr, _("%s: could not open directory \"%s\": %s\n"),
                progname, path, strerror(errno));
        return;
    }

    while (errno = 0, (de = readdir(dir)) != NULL)
    {
        char        subpath[MAXPGPATH * 2];
        struct stat fst;
        int         sret;

        if (strcmp(de->d_name, ".") == 0 ||
            strcmp(de->d_name, "..") == 0)
            continue;

        snprintf(subpath, sizeof(subpath), "%s/%s", path, de->d_name);

        if (process_symlinks)
            sret = stat(subpath, &fst);
        else
            sret = lstat(subpath, &fst);

        if (sret < 0)
        {
            fprintf(stderr, _("%s: could not stat file \"%s\": %s\n"),
                    progname, subpath, strerror(errno));
            continue;
        }

        if (S_ISREG(fst.st_mode))
            (*action) (subpath, false, progname);
        else if (S_ISDIR(fst.st_mode))
            walkdir(subpath, action, false, progname);
    }

    if (errno)
        fprintf(stderr, _("%s: could not read directory \"%s\": %s\n"),
                progname, path, strerror(errno));

    (void) closedir(dir);

    /*
     * 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 an issue for ext3 and other filesystems in the past.
     */
    (*action) (path, true, progname);
}