basebackup_server.c File Reference

#include "postgres.h"
#include "access/xact.h"
#include "backup/basebackup_sink.h"
#include "catalog/pg_authid.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "utils/acl.h"
#include "utils/wait_event.h"

Include dependency graph for basebackup_server.c:

Go to the source code of this file.

Data Structures
struct	bbsink_server

Typedefs
typedef struct bbsink_server	bbsink_server

Functions
static void	bbsink_server_begin_archive (bbsink *sink, const char *archive_name)
static void	bbsink_server_archive_contents (bbsink *sink, size_t len)
static void	bbsink_server_end_archive (bbsink *sink)
static void	bbsink_server_begin_manifest (bbsink *sink)
static void	bbsink_server_manifest_contents (bbsink *sink, size_t len)
static void	bbsink_server_end_manifest (bbsink *sink)
bbsink *	bbsink_server_new (bbsink *next, char *pathname)

Variables
static const bbsink_ops	bbsink_server_ops

Typedef Documentation

bbsink_server

typedef struct bbsink_server bbsink_server

Function Documentation

bbsink_server_archive_contents()

static void bbsink_server_archive_contents ( bbsink *  sink, size_t  len  )

static

Definition at line 160 of file basebackup_server.c.

{
    bbsink_server *mysink = (bbsink_server *) sink;
    int         nbytes;
 
    nbytes = FileWrite(mysink->file, mysink->base.bbs_buffer, len,
                       mysink->filepos, WAIT_EVENT_BASEBACKUP_WRITE);
 
    if (nbytes != len)
    {
        if (nbytes < 0)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not write file \"%s\": %m",
                            FilePathName(mysink->file)),
                     errhint("Check free disk space.")));
        /* short write: complain appropriately */
        ereport(ERROR,
                (errcode(ERRCODE_DISK_FULL),
                 errmsg("could not write file \"%s\": wrote only %d of %d bytes at offset %u",
                        FilePathName(mysink->file),
                        nbytes, (int) len, (unsigned) mysink->filepos),
                 errhint("Check free disk space.")));
    }
 
    mysink->filepos += nbytes;
 
    bbsink_forward_archive_contents(sink, len);
}

References bbsink_server::base, bbsink::bbs_buffer, bbsink_forward_archive_contents(), ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, bbsink_server::file, FilePathName(), bbsink_server::filepos, FileWrite(), and len.

bbsink_server_begin_archive()

static void bbsink_server_begin_archive ( bbsink *  sink, const char *  archive_name  )

static

Definition at line 134 of file basebackup_server.c.

{
    bbsink_server *mysink = (bbsink_server *) sink;
    char       *filename;
 
    Assert(mysink->file == 0);
    Assert(mysink->filepos == 0);
 
    filename = psprintf("%s/%s", mysink->pathname, archive_name);
 
    mysink->file = PathNameOpenFile(filename,
                                    O_CREAT | O_EXCL | O_WRONLY | PG_BINARY);
    if (mysink->file <= 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not create file \"%s\": %m", filename)));
 
    pfree(filename);
 
    bbsink_forward_begin_archive(sink, archive_name);
}

References Assert(), bbsink_forward_begin_archive(), ereport, errcode_for_file_access(), errmsg(), ERROR, bbsink_server::file, filename, bbsink_server::filepos, bbsink_server::pathname, PathNameOpenFile(), pfree(), PG_BINARY, and psprintf().

bbsink_server_begin_manifest()

static void bbsink_server_begin_manifest ( bbsink *  sink )

static

Definition at line 228 of file basebackup_server.c.

{
    bbsink_server *mysink = (bbsink_server *) sink;
    char       *tmp_filename;
 
    Assert(mysink->file == 0);
 
    tmp_filename = psprintf("%s/backup_manifest.tmp", mysink->pathname);
 
    mysink->file = PathNameOpenFile(tmp_filename,
                                    O_CREAT | O_EXCL | O_WRONLY | PG_BINARY);
    if (mysink->file <= 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not create file \"%s\": %m", tmp_filename)));
 
    pfree(tmp_filename);
 
    bbsink_forward_begin_manifest(sink);
}

References Assert(), bbsink_forward_begin_manifest(), ereport, errcode_for_file_access(), errmsg(), ERROR, bbsink_server::file, bbsink_server::pathname, PathNameOpenFile(), pfree(), PG_BINARY, and psprintf().

bbsink_server_end_archive()

static void bbsink_server_end_archive ( bbsink *  sink )

static

Definition at line 194 of file basebackup_server.c.

{
    bbsink_server *mysink = (bbsink_server *) sink;
 
    /*
     * We intentionally don't use data_sync_elevel here, because the server
     * shouldn't PANIC just because we can't guarantee that the backup has
     * been written down to disk. Running recovery won't fix anything in this
     * case anyway.
     */
    if (FileSync(mysink->file, WAIT_EVENT_BASEBACKUP_SYNC) < 0)
        ereport(ERROR,
                (errcode_for_file_access(),
                 errmsg("could not fsync file \"%s\": %m",
                        FilePathName(mysink->file))));
 
 
    /* We're done with this file now. */
    FileClose(mysink->file);
    mysink->file = 0;
    mysink->filepos = 0;
 
    bbsink_forward_end_archive(sink);
}

References bbsink_forward_end_archive(), ereport, errcode_for_file_access(), errmsg(), ERROR, bbsink_server::file, FileClose(), FilePathName(), bbsink_server::filepos, and FileSync().

bbsink_server_end_manifest()

static void bbsink_server_end_manifest ( bbsink *  sink )

static

Definition at line 287 of file basebackup_server.c.

{
    bbsink_server *mysink = (bbsink_server *) sink;
    char       *tmp_filename;
    char       *filename;
 
    /* We're done with this file now. */
    FileClose(mysink->file);
    mysink->file = 0;
 
    /*
     * Rename it into place. This also fsyncs the temporary file, so we don't
     * need to do that here. We don't use data_sync_elevel here for the same
     * reasons as in bbsink_server_end_archive.
     */
    tmp_filename = psprintf("%s/backup_manifest.tmp", mysink->pathname);
    filename = psprintf("%s/backup_manifest", mysink->pathname);
    durable_rename(tmp_filename, filename, ERROR);
    pfree(filename);
    pfree(tmp_filename);
 
    bbsink_forward_end_manifest(sink);
}

References bbsink_forward_end_manifest(), durable_rename(), ERROR, bbsink_server::file, FileClose(), filename, bbsink_server::pathname, pfree(), and psprintf().

bbsink_server_manifest_contents()

static void bbsink_server_manifest_contents ( bbsink *  sink, size_t  len  )

static

Definition at line 253 of file basebackup_server.c.

{
    bbsink_server *mysink = (bbsink_server *) sink;
    int         nbytes;
 
    nbytes = FileWrite(mysink->file, mysink->base.bbs_buffer, len,
                       mysink->filepos, WAIT_EVENT_BASEBACKUP_WRITE);
 
    if (nbytes != len)
    {
        if (nbytes < 0)
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not write file \"%s\": %m",
                            FilePathName(mysink->file)),
                     errhint("Check free disk space.")));
        /* short write: complain appropriately */
        ereport(ERROR,
                (errcode(ERRCODE_DISK_FULL),
                 errmsg("could not write file \"%s\": wrote only %d of %d bytes at offset %u",
                        FilePathName(mysink->file),
                        nbytes, (int) len, (unsigned) mysink->filepos),
                 errhint("Check free disk space.")));
    }
 
    mysink->filepos += nbytes;
 
    bbsink_forward_manifest_contents(sink, len);
}

References bbsink_server::base, bbsink::bbs_buffer, bbsink_forward_manifest_contents(), ereport, errcode(), errcode_for_file_access(), errhint(), errmsg(), ERROR, bbsink_server::file, FilePathName(), bbsink_server::filepos, FileWrite(), and len.

bbsink_server_new()

bbsink * bbsink_server_new	(	bbsink *	next,
		char *	pathname
	)

Definition at line 60 of file basebackup_server.c.

{
    bbsink_server *sink = palloc0(sizeof(bbsink_server));
 
    *((const bbsink_ops **) &sink->base.bbs_ops) = &bbsink_server_ops;
    sink->pathname = pathname;
    sink->base.bbs_next = next;
 
    /* Replication permission is not sufficient in this case. */
    StartTransactionCommand();
    if (!has_privs_of_role(GetUserId(), ROLE_PG_WRITE_SERVER_FILES))
        ereport(ERROR,
                (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
                 errmsg("permission denied to create backup stored on server"),
                 errdetail("Only roles with privileges of the \"%s\" role may create a backup stored on the server.",
                           "pg_write_server_files")));
    CommitTransactionCommand();
 
    /*
     * It's not a good idea to store your backups in the same directory that
     * you're backing up. If we allowed a relative path here, that could
     * easily happen accidentally, so we don't. The user could still
     * accomplish the same thing by including the absolute path to $PGDATA in
     * the pathname, but that's likely an intentional bad decision rather than
     * an accident.
     */
    if (!is_absolute_path(pathname))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("relative path not allowed for backup stored on server")));
 
    switch (pg_check_dir(pathname))
    {
        case 0:
 
            /*
             * Does not exist, so create it using the same permissions we'd
             * use for a new subdirectory of the data directory itself.
             */
            if (MakePGDirectory(pathname) < 0)
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not create directory \"%s\": %m", pathname)));
            break;
 
        case 1:
            /* Exists, empty. */
            break;
 
        case 2:
        case 3:
        case 4:
            /* Exists, not empty. */
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_FILE),
                     errmsg("directory \"%s\" exists but is not empty",
                            pathname)));
            break;
 
        default:
            /* Access problem. */
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not access directory \"%s\": %m",
                            pathname)));
    }
 
    return &sink->base;
}

References bbsink_server::base, bbsink::bbs_next, bbsink::bbs_ops, bbsink_server_ops, CommitTransactionCommand(), ereport, errcode(), errcode_for_file_access(), errdetail(), errmsg(), ERROR, GetUserId(), has_privs_of_role(), is_absolute_path, MakePGDirectory(), next, palloc0(), bbsink_server::pathname, pg_check_dir(), and StartTransactionCommand().

Referenced by server_get_sink().

Variable Documentation

bbsink_server_ops

const bbsink_ops bbsink_server_ops

static

Initial value:

= {
    .begin_backup = bbsink_forward_begin_backup,
    .begin_archive = bbsink_server_begin_archive,
    .archive_contents = bbsink_server_archive_contents,
    .end_archive = bbsink_server_end_archive,
    .begin_manifest = bbsink_server_begin_manifest,
    .manifest_contents = bbsink_server_manifest_contents,
    .end_manifest = bbsink_server_end_manifest,
    .end_backup = bbsink_forward_end_backup,
    .cleanup = bbsink_forward_cleanup
}

Definition at line 44 of file basebackup_server.c.

Referenced by bbsink_server_new().