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_rec
struct	xl_dbase_drop_rec

Macros
#define	XLOG_DBASE_CREATE   0x00
#define	XLOG_DBASE_DROP   0x10
#define	MinSizeOfDbaseDropRec   offsetof(xl_dbase_drop_rec, tablespace_ids)

Typedefs
typedef struct xl_dbase_create_rec	xl_dbase_create_rec
typedef struct xl_dbase_drop_rec	xl_dbase_drop_rec

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

Macro Definition Documentation

MinSizeOfDbaseDropRec

#define MinSizeOfDbaseDropRec   offsetof(xl_dbase_drop_rec, tablespace_ids)

Definition at line 39 of file dbcommands_xlog.h.

Referenced by remove_dbtablespaces().

XLOG_DBASE_CREATE

#define XLOG_DBASE_CREATE   0x00

Definition at line 21 of file dbcommands_xlog.h.

Referenced by createdb(), dbase_desc(), dbase_identify(), dbase_redo(), extractPageInfo(), and movedb().

XLOG_DBASE_DROP

#define XLOG_DBASE_DROP   0x10

Definition at line 22 of file dbcommands_xlog.h.

Referenced by dbase_desc(), dbase_identify(), dbase_redo(), extractPageInfo(), movedb(), and remove_dbtablespaces().

Typedef Documentation

xl_dbase_create_rec

typedef struct xl_dbase_create_rec xl_dbase_create_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 *	rptr
	)

Definition at line 22 of file dbasedesc.c.

References appendStringInfo(), xl_dbase_create_rec::db_id, xl_dbase_drop_rec::db_id, i, xl_dbase_drop_rec::ntablespaces, xl_dbase_create_rec::src_db_id, xl_dbase_create_rec::src_tablespace_id, xl_dbase_create_rec::tablespace_id, xl_dbase_drop_rec::tablespace_ids, XLOG_DBASE_CREATE, XLOG_DBASE_DROP, XLogRecGetData, XLogRecGetInfo, and XLR_INFO_MASK.

{
    char       *rec = XLogRecGetData(record);
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

    if (info == XLOG_DBASE_CREATE)
    {
        xl_dbase_create_rec *xlrec = (xl_dbase_create_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_DROP)
    {
        xl_dbase_drop_rec *xlrec = (xl_dbase_drop_rec *) rec;
        int     i;

        appendStringInfo(buf, "dir");
        for (i = 0; i < xlrec->ntablespaces; i++)
            appendStringInfo(buf, " %u/%u",
                             xlrec->tablespace_ids[i], xlrec->db_id);
    }
}

dbase_identify()

const char* dbase_identify

(

uint8

info

)

Definition at line 48 of file dbasedesc.c.

References XLOG_DBASE_CREATE, XLOG_DBASE_DROP, and XLR_INFO_MASK.

{
    const char *id = NULL;

    switch (info & ~XLR_INFO_MASK)
    {
        case XLOG_DBASE_CREATE:
            id = "CREATE";
            break;
        case XLOG_DBASE_DROP:
            id = "DROP";
            break;
    }

    return id;
}

dbase_redo()

void dbase_redo

(

XLogReaderState *

rptr

)

Definition at line 2176 of file dbcommands.c.

References AccessExclusiveLock, Assert, copydir(), xl_dbase_create_rec::db_id, xl_dbase_drop_rec::db_id, DropDatabaseBuffers(), elog, ereport, errmsg(), FlushDatabaseBuffers(), ForgetDatabaseSyncRequests(), GetDatabasePath(), i, InHotStandby, LockSharedObjectForSession(), xl_dbase_drop_rec::ntablespaces, PANIC, pfree(), ReplicationSlotsDropDBSlots(), ResolveRecoveryConflictWithDatabase(), rmtree(), S_ISDIR, xl_dbase_create_rec::src_db_id, xl_dbase_create_rec::src_tablespace_id, stat, xl_dbase_create_rec::tablespace_id, xl_dbase_drop_rec::tablespace_ids, UnlockSharedObjectForSession(), WARNING, XLOG_DBASE_CREATE, XLOG_DBASE_DROP, XLogDropDatabase(), XLogRecGetData, XLogRecGetInfo, XLogRecHasAnyBlockRefs, and XLR_INFO_MASK.

{
    uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

    /* Backup blocks are not used in dbase records */
    Assert(!XLogRecHasAnyBlockRefs(record));

    if (info == XLOG_DBASE_CREATE)
    {
        xl_dbase_create_rec *xlrec = (xl_dbase_create_rec *) XLogRecGetData(record);
        char       *src_path;
        char       *dst_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)));
        }

        /*
         * Force dirty buffers out to disk, to ensure source database is
         * up-to-date for the copy.
         */
        FlushDatabaseBuffers(xlrec->src_db_id);

        /*
         * Copy this subdirectory to the new location
         *
         * We don't need to copy subdirectories
         */
        copydir(src_path, dst_path, false);
    }
    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);

        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);
}