dbcommands_xlog.h File Reference

#include "access/xlogreader.h"
#include "lib/stringinfo.h"

Include dependency graph for dbcommands_xlog.h:

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

Go to the source code of this file.

Data Structures
struct	xl_dbase_create_file_copy_rec
struct	xl_dbase_create_wal_log_rec
struct	xl_dbase_drop_rec

Macros
#define	XLOG_DBASE_CREATE_FILE_COPY   0x00
#define	XLOG_DBASE_CREATE_WAL_LOG   0x10
#define	XLOG_DBASE_DROP   0x20
#define	MinSizeOfDbaseDropRec   offsetof(xl_dbase_drop_rec, tablespace_ids)

Typedefs
typedef struct xl_dbase_create_file_copy_rec	xl_dbase_create_file_copy_rec
typedef struct xl_dbase_create_wal_log_rec	xl_dbase_create_wal_log_rec
typedef struct xl_dbase_drop_rec	xl_dbase_drop_rec

Functions
void	dbase_redo (XLogReaderState *record)
void	dbase_desc (StringInfo buf, XLogReaderState *record)
const char *	dbase_identify (uint8 info)

Macro Definition Documentation

MinSizeOfDbaseDropRec

#define MinSizeOfDbaseDropRec   offsetof(xl_dbase_drop_rec, tablespace_ids)

Definition at line 54 of file dbcommands_xlog.h.

XLOG_DBASE_CREATE_FILE_COPY

#define XLOG_DBASE_CREATE_FILE_COPY   0x00

Definition at line 21 of file dbcommands_xlog.h.

XLOG_DBASE_CREATE_WAL_LOG

#define XLOG_DBASE_CREATE_WAL_LOG   0x10

Definition at line 22 of file dbcommands_xlog.h.

XLOG_DBASE_DROP

#define XLOG_DBASE_DROP   0x20

Definition at line 23 of file dbcommands_xlog.h.

Typedef Documentation

xl_dbase_create_file_copy_rec

typedef struct xl_dbase_create_file_copy_rec xl_dbase_create_file_copy_rec

xl_dbase_create_wal_log_rec

typedef struct xl_dbase_create_wal_log_rec xl_dbase_create_wal_log_rec

xl_dbase_drop_rec

typedef struct xl_dbase_drop_rec xl_dbase_drop_rec

Function Documentation

dbase_desc()

void dbase_desc ( StringInfo  buf, XLogReaderState *  record  )

extern

Definition at line 22 of file dbasedesc.c.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    if (info == XLOG_DBASE_CREATE_FILE_COPY)
    {
        xl_dbase_create_file_copy_rec *xlrec =
            (xl_dbase_create_file_copy_rec *) rec;
 
        appendStringInfo(buf, "copy dir %u/%u to %u/%u",
                         xlrec->src_tablespace_id, xlrec->src_db_id,
                         xlrec->tablespace_id, xlrec->db_id);
    }
    else if (info == XLOG_DBASE_CREATE_WAL_LOG)
    {
        xl_dbase_create_wal_log_rec *xlrec =
            (xl_dbase_create_wal_log_rec *) rec;
 
        appendStringInfo(buf, "create dir %u/%u",
                         xlrec->tablespace_id, xlrec->db_id);
    }
    else if (info == XLOG_DBASE_DROP)
    {
        xl_dbase_drop_rec *xlrec = (xl_dbase_drop_rec *) rec;
        int         i;
 
        appendStringInfoString(buf, "dir");
        for (i = 0; i < xlrec->ntablespaces; i++)
            appendStringInfo(buf, " %u/%u",
                             xlrec->tablespace_ids[i], xlrec->db_id);
    }
}

References appendStringInfo(), appendStringInfoString(), buf, fb(), i, XLOG_DBASE_CREATE_FILE_COPY, XLOG_DBASE_CREATE_WAL_LOG, XLOG_DBASE_DROP, XLogRecGetData, and XLogRecGetInfo.

dbase_identify()

const char * dbase_identify ( uint8  info )

extern

Definition at line 57 of file dbasedesc.c.

{
    const char *id = NULL;
 
    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_DBASE_CREATE_FILE_COPY:
            id = "CREATE_FILE_COPY";
            break;
        case XLOG_DBASE_CREATE_WAL_LOG:
            id = "CREATE_WAL_LOG";
            break;
        case XLOG_DBASE_DROP:
            id = "DROP";
            break;
    }
 
    return id;
}

References fb(), XLOG_DBASE_CREATE_FILE_COPY, XLOG_DBASE_CREATE_WAL_LOG, XLOG_DBASE_DROP, and XLR_INFO_MASK.

dbase_redo()

void dbase_redo ( XLogReaderState *  record )

extern

Definition at line 3287 of file dbcommands.c.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
    /* Backup blocks are not used in dbase records */
    Assert(!XLogRecHasAnyBlockRefs(record));
 
    if (info == XLOG_DBASE_CREATE_FILE_COPY)
    {
        xl_dbase_create_file_copy_rec *xlrec =
            (xl_dbase_create_file_copy_rec *) XLogRecGetData(record);
        char       *src_path;
        char       *dst_path;
        char       *parent_path;
        struct stat st;
 
        src_path = GetDatabasePath(xlrec->src_db_id, xlrec->src_tablespace_id);
        dst_path = GetDatabasePath(xlrec->db_id, xlrec->tablespace_id);
 
        /*
         * Our theory for replaying a CREATE is to forcibly drop the target
         * subdirectory if present, then re-copy the source data. This may be
         * more work than needed, but it is simple to implement.
         */
        if (stat(dst_path, &st) == 0 && S_ISDIR(st.st_mode))
        {
            if (!rmtree(dst_path, true))
                /* If this failed, copydir() below is going to error. */
                ereport(WARNING,
                        (errmsg("some useless files may be left behind in old database directory \"%s\"",
                                dst_path)));
        }
 
        /*
         * If the parent of the target path doesn't exist, create it now. This
         * enables us to create the target underneath later.
         */
        parent_path = pstrdup(dst_path);
        get_parent_directory(parent_path);
        if (stat(parent_path, &st) < 0)
        {
            if (errno != ENOENT)
                ereport(FATAL,
                        errmsg("could not stat directory \"%s\": %m",
                               dst_path));
 
            /* create the parent directory if needed and valid */
            recovery_create_dbdir(parent_path, true);
        }
        pfree(parent_path);
 
        /*
         * There's a case where the copy source directory is missing for the
         * same reason above.  Create the empty source directory so that
         * copydir below doesn't fail.  The directory will be dropped soon by
         * recovery.
         */
        if (stat(src_path, &st) < 0 && errno == ENOENT)
            recovery_create_dbdir(src_path, false);
 
        /*
         * Force dirty buffers out to disk, to ensure source database is
         * up-to-date for the copy.
         */
        FlushDatabaseBuffers(xlrec->src_db_id);
 
        /* Close all smgr fds in all backends. */
        WaitForProcSignalBarrier(EmitProcSignalBarrier(PROCSIGNAL_BARRIER_SMGRRELEASE));
 
        /*
         * Copy this subdirectory to the new location
         *
         * We don't need to copy subdirectories
         */
        copydir(src_path, dst_path, false);
 
        pfree(src_path);
        pfree(dst_path);
    }
    else if (info == XLOG_DBASE_CREATE_WAL_LOG)
    {
        xl_dbase_create_wal_log_rec *xlrec =
            (xl_dbase_create_wal_log_rec *) XLogRecGetData(record);
        char       *dbpath;
        char       *parent_path;
 
        dbpath = GetDatabasePath(xlrec->db_id, xlrec->tablespace_id);
 
        /* create the parent directory if needed and valid */
        parent_path = pstrdup(dbpath);
        get_parent_directory(parent_path);
        recovery_create_dbdir(parent_path, true);
        pfree(parent_path);
 
        /* Create the database directory with the version file. */
        CreateDirAndVersionFile(dbpath, xlrec->db_id, xlrec->tablespace_id,
                                true);
        pfree(dbpath);
    }
    else if (info == XLOG_DBASE_DROP)
    {
        xl_dbase_drop_rec *xlrec = (xl_dbase_drop_rec *) XLogRecGetData(record);
        char       *dst_path;
        int         i;
 
        if (InHotStandby)
        {
            /*
             * Lock database while we resolve conflicts to ensure that
             * InitPostgres() cannot fully re-execute concurrently. This
             * avoids backends re-connecting automatically to same database,
             * which can happen in some cases.
             *
             * This will lock out walsenders trying to connect to db-specific
             * slots for logical decoding too, so it's safe for us to drop
             * slots.
             */
            LockSharedObjectForSession(DatabaseRelationId, xlrec->db_id, 0, AccessExclusiveLock);
            ResolveRecoveryConflictWithDatabase(xlrec->db_id);
        }
 
        /* Drop any database-specific replication slots */
        ReplicationSlotsDropDBSlots(xlrec->db_id);
 
        /* Drop pages for this database that are in the shared buffer cache */
        DropDatabaseBuffers(xlrec->db_id);
 
        /* Also, clean out any fsync requests that might be pending in md.c */
        ForgetDatabaseSyncRequests(xlrec->db_id);
 
        /* Clean out the xlog relcache too */
        XLogDropDatabase(xlrec->db_id);
 
        /* Close all smgr fds in all backends. */
        WaitForProcSignalBarrier(EmitProcSignalBarrier(PROCSIGNAL_BARRIER_SMGRRELEASE));
 
        for (i = 0; i < xlrec->ntablespaces; i++)
        {
            dst_path = GetDatabasePath(xlrec->db_id, xlrec->tablespace_ids[i]);
 
            /* And remove the physical files */
            if (!rmtree(dst_path, true))
                ereport(WARNING,
                        (errmsg("some useless files may be left behind in old database directory \"%s\"",
                                dst_path)));
            pfree(dst_path);
        }
 
        if (InHotStandby)
        {
            /*
             * Release locks prior to commit. XXX There is a race condition
             * here that may allow backends to reconnect, but the window for
             * this is small because the gap between here and commit is mostly
             * fairly small and it is unlikely that people will be dropping
             * databases that we are trying to connect to anyway.
             */
            UnlockSharedObjectForSession(DatabaseRelationId, xlrec->db_id, 0, AccessExclusiveLock);
        }
    }
    else
        elog(PANIC, "dbase_redo: unknown op code %u", info);
}

References AccessExclusiveLock, Assert, copydir(), CreateDirAndVersionFile(), DropDatabaseBuffers(), elog, EmitProcSignalBarrier(), ereport, errmsg(), FATAL, fb(), FlushDatabaseBuffers(), ForgetDatabaseSyncRequests(), get_parent_directory(), GetDatabasePath(), i, InHotStandby, LockSharedObjectForSession(), PANIC, pfree(), PROCSIGNAL_BARRIER_SMGRRELEASE, pstrdup(), recovery_create_dbdir(), ReplicationSlotsDropDBSlots(), ResolveRecoveryConflictWithDatabase(), rmtree(), S_ISDIR, stat::st_mode, stat, UnlockSharedObjectForSession(), WaitForProcSignalBarrier(), WARNING, XLOG_DBASE_CREATE_FILE_COPY, XLOG_DBASE_CREATE_WAL_LOG, XLOG_DBASE_DROP, XLogDropDatabase(), XLogRecGetData, XLogRecGetInfo, and XLogRecHasAnyBlockRefs.