xlogutils.c File Reference

#include "postgres.h"
#include <unistd.h>
#include "access/timeline.h"
#include "access/xlog.h"
#include "access/xlog_internal.h"
#include "access/xlogutils.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/smgr.h"
#include "utils/guc.h"
#include "utils/hsearch.h"
#include "utils/rel.h"

Include dependency graph for xlogutils.c:

Go to the source code of this file.

Data Structures
struct	xl_invalid_page_key
struct	xl_invalid_page
struct	FakeRelCacheEntryData

Typedefs
typedef struct xl_invalid_page_key	xl_invalid_page_key
typedef struct xl_invalid_page	xl_invalid_page
typedef FakeRelCacheEntryData *	FakeRelCacheEntry

Functions
static void	report_invalid_page (int elevel, RelFileNode node, ForkNumber forkno, BlockNumber blkno, bool present)
static void	log_invalid_page (RelFileNode node, ForkNumber forkno, BlockNumber blkno, bool present)
static void	forget_invalid_pages (RelFileNode node, ForkNumber forkno, BlockNumber minblkno)
static void	forget_invalid_pages_db (Oid dbid)
bool	XLogHaveInvalidPages (void)
void	XLogCheckInvalidPages (void)
XLogRedoAction	XLogReadBufferForRedo (XLogReaderState *record, uint8 block_id, Buffer *buf)
Buffer	XLogInitBufferForRedo (XLogReaderState *record, uint8 block_id)
XLogRedoAction	XLogReadBufferForRedoExtended (XLogReaderState *record, uint8 block_id, ReadBufferMode mode, bool get_cleanup_lock, Buffer *buf)
Buffer	XLogReadBufferExtended (RelFileNode rnode, ForkNumber forknum, BlockNumber blkno, ReadBufferMode mode)
Relation	CreateFakeRelcacheEntry (RelFileNode rnode)
void	FreeFakeRelcacheEntry (Relation fakerel)
void	XLogDropRelation (RelFileNode rnode, ForkNumber forknum)
void	XLogDropDatabase (Oid dbid)
void	XLogTruncateRelation (RelFileNode rnode, ForkNumber forkNum, BlockNumber nblocks)
static void	XLogRead (char *buf, int segsize, TimeLineID tli, XLogRecPtr startptr, Size count)
void	XLogReadDetermineTimeline (XLogReaderState *state, XLogRecPtr wantPage, uint32 wantLength)
int	read_local_xlog_page (XLogReaderState *state, XLogRecPtr targetPagePtr, int reqLen, XLogRecPtr targetRecPtr, char *cur_page, TimeLineID *pageTLI)

Variables
static HTAB *	invalid_page_tab = NULL

Typedef Documentation

FakeRelCacheEntry

typedef FakeRelCacheEntryData* FakeRelCacheEntry

Definition at line 535 of file xlogutils.c.

xl_invalid_page

typedef struct xl_invalid_page xl_invalid_page

xl_invalid_page_key

typedef struct xl_invalid_page_key xl_invalid_page_key

Function Documentation

CreateFakeRelcacheEntry()

Relation CreateFakeRelcacheEntry

(

RelFileNode

rnode

)

Definition at line 550 of file xlogutils.c.

References Assert, LockRelId::dbId, RelFileNode::dbNode, InRecovery, InvalidBackendId, LockInfoData::lockRelId, palloc0(), FakeRelCacheEntryData::pgc, RelationData::rd_backend, RelationData::rd_lockInfo, RelationData::rd_node, RelationData::rd_rel, RelationData::rd_smgr, RelationGetRelationName, LockRelId::relId, RelFileNode::relNode, and sprintf.

Referenced by heap_xlog_delete(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), heap_xlog_visible(), and smgr_redo().

{
    FakeRelCacheEntry fakeentry;
    Relation    rel;

    Assert(InRecovery);

    /* Allocate the Relation struct and all related space in one block. */
    fakeentry = palloc0(sizeof(FakeRelCacheEntryData));
    rel = (Relation) fakeentry;

    rel->rd_rel = &fakeentry->pgc;
    rel->rd_node = rnode;
    /* We will never be working with temp rels during recovery */
    rel->rd_backend = InvalidBackendId;

    /* It must be a permanent table if we're in recovery. */
    rel->rd_rel->relpersistence = RELPERSISTENCE_PERMANENT;

    /* We don't know the name of the relation; use relfilenode instead */
    sprintf(RelationGetRelationName(rel), "%u", rnode.relNode);

    /*
     * We set up the lockRelId in case anything tries to lock the dummy
     * relation.  Note that this is fairly bogus since relNode may be
     * different from the relation's OID.  It shouldn't really matter though,
     * since we are presumably running by ourselves and can't have any lock
     * conflicts ...
     */
    rel->rd_lockInfo.lockRelId.dbId = rnode.dbNode;
    rel->rd_lockInfo.lockRelId.relId = rnode.relNode;

    rel->rd_smgr = NULL;

    return rel;
}

forget_invalid_pages()

static void forget_invalid_pages ( RelFileNode  node, ForkNumber  forkno, BlockNumber  minblkno  )

static

Definition at line 142 of file xlogutils.c.

References xl_invalid_page_key::blkno, client_min_messages, DEBUG2, elog, ERROR, xl_invalid_page_key::forkno, HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), xl_invalid_page::key, log_min_messages, xl_invalid_page_key::node, pfree(), RelFileNodeEquals, relpathperm, and status().

Referenced by XLogDropRelation(), and XLogTruncateRelation().

{
    HASH_SEQ_STATUS status;
    xl_invalid_page *hentry;

    if (invalid_page_tab == NULL)
        return;                 /* nothing to do */

    hash_seq_init(&status, invalid_page_tab);

    while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) != NULL)
    {
        if (RelFileNodeEquals(hentry->key.node, node) &&
            hentry->key.forkno == forkno &&
            hentry->key.blkno >= minblkno)
        {
            if (log_min_messages <= DEBUG2 || client_min_messages <= DEBUG2)
            {
                char       *path = relpathperm(hentry->key.node, forkno);

                elog(DEBUG2, "page %u of relation %s has been dropped",
                     hentry->key.blkno, path);
                pfree(path);
            }

            if (hash_search(invalid_page_tab,
                            (void *) &hentry->key,
                            HASH_REMOVE, NULL) == NULL)
                elog(ERROR, "hash table corrupted");
        }
    }
}

forget_invalid_pages_db()

static void forget_invalid_pages_db ( Oid  dbid )

static

Definition at line 177 of file xlogutils.c.

References xl_invalid_page_key::blkno, client_min_messages, RelFileNode::dbNode, DEBUG2, elog, ERROR, xl_invalid_page_key::forkno, HASH_REMOVE, hash_search(), hash_seq_init(), hash_seq_search(), xl_invalid_page::key, log_min_messages, xl_invalid_page_key::node, pfree(), relpathperm, and status().

Referenced by XLogDropDatabase().

{
    HASH_SEQ_STATUS status;
    xl_invalid_page *hentry;

    if (invalid_page_tab == NULL)
        return;                 /* nothing to do */

    hash_seq_init(&status, invalid_page_tab);

    while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) != NULL)
    {
        if (hentry->key.node.dbNode == dbid)
        {
            if (log_min_messages <= DEBUG2 || client_min_messages <= DEBUG2)
            {
                char       *path = relpathperm(hentry->key.node, hentry->key.forkno);

                elog(DEBUG2, "page %u of relation %s has been dropped",
                     hentry->key.blkno, path);
                pfree(path);
            }

            if (hash_search(invalid_page_tab,
                            (void *) &hentry->key,
                            HASH_REMOVE, NULL) == NULL)
                elog(ERROR, "hash table corrupted");
        }
    }
}

FreeFakeRelcacheEntry()

void FreeFakeRelcacheEntry

(

Relation

fakerel

)

Definition at line 591 of file xlogutils.c.

References pfree(), RelationData::rd_smgr, and smgrclearowner().

Referenced by heap_xlog_delete(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), heap_xlog_visible(), and smgr_redo().

{
    /* make sure the fakerel is not referenced by the SmgrRelation anymore */
    if (fakerel->rd_smgr != NULL)
        smgrclearowner(&fakerel->rd_smgr, fakerel->rd_smgr);
    pfree(fakerel);
}

log_invalid_page()

static void log_invalid_page ( RelFileNode  node, ForkNumber  forkno, BlockNumber  blkno, bool  present  )

static

Definition at line 78 of file xlogutils.c.

References xl_invalid_page_key::blkno, client_min_messages, DEBUG1, elog, HASHCTL::entrysize, xl_invalid_page_key::forkno, HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), sort-test::key, HASHCTL::keysize, log_min_messages, xl_invalid_page_key::node, PANIC, xl_invalid_page::present, reachedConsistency, report_invalid_page(), and WARNING.

Referenced by XLogReadBufferExtended().

{
    xl_invalid_page_key key;
    xl_invalid_page *hentry;
    bool        found;

    /*
     * Once recovery has reached a consistent state, the invalid-page table
     * should be empty and remain so. If a reference to an invalid page is
     * found after consistency is reached, PANIC immediately. This might seem
     * aggressive, but it's better than letting the invalid reference linger
     * in the hash table until the end of recovery and PANIC there, which
     * might come only much later if this is a standby server.
     */
    if (reachedConsistency)
    {
        report_invalid_page(WARNING, node, forkno, blkno, present);
        elog(PANIC, "WAL contains references to invalid pages");
    }

    /*
     * Log references to invalid pages at DEBUG1 level.  This allows some
     * tracing of the cause (note the elog context mechanism will tell us
     * something about the XLOG record that generated the reference).
     */
    if (log_min_messages <= DEBUG1 || client_min_messages <= DEBUG1)
        report_invalid_page(DEBUG1, node, forkno, blkno, present);

    if (invalid_page_tab == NULL)
    {
        /* create hash table when first needed */
        HASHCTL     ctl;

        memset(&ctl, 0, sizeof(ctl));
        ctl.keysize = sizeof(xl_invalid_page_key);
        ctl.entrysize = sizeof(xl_invalid_page);

        invalid_page_tab = hash_create("XLOG invalid-page table",
                                       100,
                                       &ctl,
                                       HASH_ELEM | HASH_BLOBS);
    }

    /* we currently assume xl_invalid_page_key contains no padding */
    key.node = node;
    key.forkno = forkno;
    key.blkno = blkno;
    hentry = (xl_invalid_page *)
        hash_search(invalid_page_tab, (void *) &key, HASH_ENTER, &found);

    if (!found)
    {
        /* hash_search already filled in the key */
        hentry->present = present;
    }
    else
    {
        /* repeat reference ... leave "present" as it was */
    }
}

read_local_xlog_page()

int read_local_xlog_page	(	XLogReaderState *	state,
		XLogRecPtr	targetPagePtr,
		int	reqLen,
		XLogRecPtr	targetRecPtr,
		char *	cur_page,
		TimeLineID *	pageTLI
	)

Definition at line 911 of file xlogutils.c.

References CHECK_FOR_INTERRUPTS, XLogReaderState::currTLI, XLogReaderState::currTLIValidUntil, GetFlushRecPtr(), GetXLogReplayRecPtr(), pg_usleep(), RecoveryInProgress(), ThisTimeLineID, XLogReaderState::wal_segment_size, XLogRead(), and XLogReadDetermineTimeline().

Referenced by logical_read_local_xlog_page(), and XlogReadTwoPhaseData().

{
    XLogRecPtr  read_upto,
                loc;
    int         count;

    loc = targetPagePtr + reqLen;

    /* Loop waiting for xlog to be available if necessary */
    while (1)
    {
        /*
         * Determine the limit of xlog we can currently read to, and what the
         * most recent timeline is.
         *
         * RecoveryInProgress() will update ThisTimeLineID when it first
         * notices recovery finishes, so we only have to maintain it for the
         * local process until recovery ends.
         */
        if (!RecoveryInProgress())
            read_upto = GetFlushRecPtr();
        else
            read_upto = GetXLogReplayRecPtr(&ThisTimeLineID);

        *pageTLI = ThisTimeLineID;

        /*
         * Check which timeline to get the record from.
         *
         * We have to do it each time through the loop because if we're in
         * recovery as a cascading standby, the current timeline might've
         * become historical. We can't rely on RecoveryInProgress() because in
         * a standby configuration like
         *
         * A => B => C
         *
         * if we're a logical decoding session on C, and B gets promoted, our
         * timeline will change while we remain in recovery.
         *
         * We can't just keep reading from the old timeline as the last WAL
         * archive in the timeline will get renamed to .partial by
         * StartupXLOG().
         *
         * If that happens after our caller updated ThisTimeLineID but before
         * we actually read the xlog page, we might still try to read from the
         * old (now renamed) segment and fail. There's not much we can do
         * about this, but it can only happen when we're a leaf of a cascading
         * standby whose master gets promoted while we're decoding, so a
         * one-off ERROR isn't too bad.
         */
        XLogReadDetermineTimeline(state, targetPagePtr, reqLen);

        if (state->currTLI == ThisTimeLineID)
        {

            if (loc <= read_upto)
                break;

            CHECK_FOR_INTERRUPTS();
            pg_usleep(1000L);
        }
        else
        {
            /*
             * We're on a historical timeline, so limit reading to the switch
             * point where we moved to the next timeline.
             *
             * We don't need to GetFlushRecPtr or GetXLogReplayRecPtr. We know
             * about the new timeline, so we must've received past the end of
             * it.
             */
            read_upto = state->currTLIValidUntil;

            /*
             * Setting pageTLI to our wanted record's TLI is slightly wrong;
             * the page might begin on an older timeline if it contains a
             * timeline switch, since its xlog segment will have been copied
             * from the prior timeline. This is pretty harmless though, as
             * nothing cares so long as the timeline doesn't go backwards.  We
             * should read the page header instead; FIXME someday.
             */
            *pageTLI = state->currTLI;

            /* No need to wait on a historical timeline */
            break;
        }
    }

    if (targetPagePtr + XLOG_BLCKSZ <= read_upto)
    {
        /*
         * more than one block available; read only that block, have caller
         * come back if they need more.
         */
        count = XLOG_BLCKSZ;
    }
    else if (targetPagePtr + reqLen > read_upto)
    {
        /* not enough data there */
        return -1;
    }
    else
    {
        /* enough bytes available to satisfy the request */
        count = read_upto - targetPagePtr;
    }

    /*
     * Even though we just determined how much of the page can be validly read
     * as 'count', read the whole page anyway. It's guaranteed to be
     * zero-padded up to the page boundary if it's incomplete.
     */
    XLogRead(cur_page, state->wal_segment_size, *pageTLI, targetPagePtr,
             XLOG_BLCKSZ);

    /* number of valid bytes in the buffer */
    return count;
}

report_invalid_page()

static void report_invalid_page ( int  elevel, RelFileNode  node, ForkNumber  forkno, BlockNumber  blkno, bool  present  )

static

Definition at line 62 of file xlogutils.c.

References elog, pfree(), and relpathperm.

Referenced by log_invalid_page(), and XLogCheckInvalidPages().

{
    char       *path = relpathperm(node, forkno);

    if (present)
        elog(elevel, "page %u of relation %s is uninitialized",
             blkno, path);
    else
        elog(elevel, "page %u of relation %s does not exist",
             blkno, path);
    pfree(path);
}

XLogCheckInvalidPages()

void XLogCheckInvalidPages

(

void

)

Definition at line 220 of file xlogutils.c.

References xl_invalid_page_key::blkno, elog, xl_invalid_page_key::forkno, hash_destroy(), hash_seq_init(), hash_seq_search(), xl_invalid_page::key, xl_invalid_page_key::node, PANIC, xl_invalid_page::present, report_invalid_page(), status(), and WARNING.

Referenced by CheckRecoveryConsistency().

{
    HASH_SEQ_STATUS status;
    xl_invalid_page *hentry;
    bool        foundone = false;

    if (invalid_page_tab == NULL)
        return;                 /* nothing to do */

    hash_seq_init(&status, invalid_page_tab);

    /*
     * Our strategy is to emit WARNING messages for all remaining entries and
     * only PANIC after we've dumped all the available info.
     */
    while ((hentry = (xl_invalid_page *) hash_seq_search(&status)) != NULL)
    {
        report_invalid_page(WARNING, hentry->key.node, hentry->key.forkno,
                            hentry->key.blkno, hentry->present);
        foundone = true;
    }

    if (foundone)
        elog(PANIC, "WAL contains references to invalid pages");

    hash_destroy(invalid_page_tab);
    invalid_page_tab = NULL;
}

XLogDropDatabase()

void XLogDropDatabase

(

Oid

dbid

)

Definition at line 617 of file xlogutils.c.

References forget_invalid_pages_db(), and smgrcloseall().

Referenced by dbase_redo().

{
    /*
     * This is unnecessarily heavy-handed, as it will close SMgrRelation
     * objects for other databases as well. DROP DATABASE occurs seldom enough
     * that it's not worth introducing a variant of smgrclose for just this
     * purpose. XXX: Or should we rather leave the smgr entries dangling?
     */
    smgrcloseall();

    forget_invalid_pages_db(dbid);
}

XLogDropRelation()

void XLogDropRelation	(	RelFileNode	rnode,
		ForkNumber	forknum
	)

Definition at line 606 of file xlogutils.c.

References forget_invalid_pages().

Referenced by DropRelationFiles().

{
    forget_invalid_pages(rnode, forknum, 0);
}

XLogHaveInvalidPages()

bool XLogHaveInvalidPages

(

void

)

Definition at line 210 of file xlogutils.c.

References hash_get_num_entries().

Referenced by RecoveryRestartPoint().

{
    if (invalid_page_tab != NULL &&
        hash_get_num_entries(invalid_page_tab) > 0)
        return true;
    return false;
}

XLogInitBufferForRedo()

Buffer XLogInitBufferForRedo	(	XLogReaderState *	record,
		uint8	block_id
	)

Definition at line 301 of file xlogutils.c.

References buf, RBM_ZERO_AND_LOCK, and XLogReadBufferForRedoExtended().

Referenced by _bt_restore_meta(), brin_xlog_createidx(), brin_xlog_insert_update(), brin_xlog_revmap_extend(), btree_xlog_mark_page_halfdead(), btree_xlog_newroot(), btree_xlog_split(), btree_xlog_unlink_page(), ginRedoCreatePTree(), ginRedoDeleteListPages(), ginRedoInsertListPage(), ginRedoUpdateMetapage(), gistRedoPageSplitRecord(), hash_xlog_add_ovfl_page(), hash_xlog_init_bitmap_page(), hash_xlog_init_meta_page(), hash_xlog_split_allocate_page(), heap_xlog_insert(), heap_xlog_multi_insert(), heap_xlog_update(), seq_redo(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), and spgRedoSplitTuple().

{
    Buffer      buf;

    XLogReadBufferForRedoExtended(record, block_id, RBM_ZERO_AND_LOCK, false,
                                  &buf);
    return buf;
}

XLogRead()

static void XLogRead ( char *  buf, int  segsize, TimeLineID  tli, XLogRecPtr  startptr, Size  count  )

static

Definition at line 656 of file xlogutils.c.

References Assert, BasicOpenFile(), buf, close, ereport, errcode_for_file_access(), errmsg(), ERROR, MAXPGPATH, PG_BINARY, pgstat_report_wait_end(), pgstat_report_wait_start(), read, sendFile, sendOff, sendSegNo, startptr, WAIT_EVENT_WAL_READ, wal_segment_size, XLByteInSeg, XLByteToSeg, XLogFilePath, and XLogSegmentOffset.

Referenced by read_local_xlog_page().

{
    char       *p;
    XLogRecPtr  recptr;
    Size        nbytes;

    /* state maintained across calls */
    static int  sendFile = -1;
    static XLogSegNo sendSegNo = 0;
    static TimeLineID sendTLI = 0;
    static uint32 sendOff = 0;

    Assert(segsize == wal_segment_size);

    p = buf;
    recptr = startptr;
    nbytes = count;

    while (nbytes > 0)
    {
        uint32      startoff;
        int         segbytes;
        int         readbytes;

        startoff = XLogSegmentOffset(recptr, segsize);

        /* Do we need to switch to a different xlog segment? */
        if (sendFile < 0 || !XLByteInSeg(recptr, sendSegNo, segsize) ||
            sendTLI != tli)
        {
            char        path[MAXPGPATH];

            if (sendFile >= 0)
                close(sendFile);

            XLByteToSeg(recptr, sendSegNo, segsize);

            XLogFilePath(path, tli, sendSegNo, segsize);

            sendFile = BasicOpenFile(path, O_RDONLY | PG_BINARY);

            if (sendFile < 0)
            {
                if (errno == ENOENT)
                    ereport(ERROR,
                            (errcode_for_file_access(),
                             errmsg("requested WAL segment %s has already been removed",
                                    path)));
                else
                    ereport(ERROR,
                            (errcode_for_file_access(),
                             errmsg("could not open file \"%s\": %m",
                                    path)));
            }
            sendOff = 0;
            sendTLI = tli;
        }

        /* Need to seek in the file? */
        if (sendOff != startoff)
        {
            if (lseek(sendFile, (off_t) startoff, SEEK_SET) < 0)
            {
                char        path[MAXPGPATH];
                int         save_errno = errno;

                XLogFilePath(path, tli, sendSegNo, segsize);
                errno = save_errno;
                ereport(ERROR,
                        (errcode_for_file_access(),
                         errmsg("could not seek in log segment %s to offset %u: %m",
                                path, startoff)));
            }
            sendOff = startoff;
        }

        /* How many bytes are within this segment? */
        if (nbytes > (segsize - startoff))
            segbytes = segsize - startoff;
        else
            segbytes = nbytes;

        pgstat_report_wait_start(WAIT_EVENT_WAL_READ);
        readbytes = read(sendFile, p, segbytes);
        pgstat_report_wait_end();
        if (readbytes <= 0)
        {
            char        path[MAXPGPATH];
            int         save_errno = errno;

            XLogFilePath(path, tli, sendSegNo, segsize);
            errno = save_errno;
            ereport(ERROR,
                    (errcode_for_file_access(),
                     errmsg("could not read from log segment %s, offset %u, length %lu: %m",
                            path, sendOff, (unsigned long) segbytes)));
        }

        /* Update state for read */
        recptr += readbytes;

        sendOff += readbytes;
        nbytes -= readbytes;
        p += readbytes;
    }
}

XLogReadBufferExtended()

Buffer XLogReadBufferExtended	(	RelFileNode	rnode,
		ForkNumber	forknum,
		BlockNumber	blkno,
		ReadBufferMode	mode
	)

Definition at line 437 of file xlogutils.c.

References Assert, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage, InRecovery, InvalidBackendId, InvalidBuffer, LockBuffer(), log_invalid_page(), P_NEW, PageIsNew, RBM_NORMAL, RBM_NORMAL_NO_LOG, RBM_ZERO_AND_CLEANUP_LOCK, RBM_ZERO_AND_LOCK, ReadBufferWithoutRelcache(), ReleaseBuffer(), smgrcreate(), smgrnblocks(), and smgropen().

Referenced by btree_xlog_vacuum(), checkXLogConsistency(), XLogReadBufferForRedoExtended(), and XLogRecordPageWithFreeSpace().

{
    BlockNumber lastblock;
    Buffer      buffer;
    SMgrRelation smgr;

    Assert(blkno != P_NEW);

    /* Open the relation at smgr level */
    smgr = smgropen(rnode, InvalidBackendId);

    /*
     * Create the target file if it doesn't already exist.  This lets us cope
     * if the replay sequence contains writes to a relation that is later
     * deleted.  (The original coding of this routine would instead suppress
     * the writes, but that seems like it risks losing valuable data if the
     * filesystem loses an inode during a crash.  Better to write the data
     * until we are actually told to delete the file.)
     */
    smgrcreate(smgr, forknum, true);

    lastblock = smgrnblocks(smgr, forknum);

    if (blkno < lastblock)
    {
        /* page exists in file */
        buffer = ReadBufferWithoutRelcache(rnode, forknum, blkno,
                                           mode, NULL);
    }
    else
    {
        /* hm, page doesn't exist in file */
        if (mode == RBM_NORMAL)
        {
            log_invalid_page(rnode, forknum, blkno, false);
            return InvalidBuffer;
        }
        if (mode == RBM_NORMAL_NO_LOG)
            return InvalidBuffer;
        /* OK to extend the file */
        /* we do this in recovery only - no rel-extension lock needed */
        Assert(InRecovery);
        buffer = InvalidBuffer;
        do
        {
            if (buffer != InvalidBuffer)
            {
                if (mode == RBM_ZERO_AND_LOCK || mode == RBM_ZERO_AND_CLEANUP_LOCK)
                    LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
                ReleaseBuffer(buffer);
            }
            buffer = ReadBufferWithoutRelcache(rnode, forknum,
                                               P_NEW, mode, NULL);
        }
        while (BufferGetBlockNumber(buffer) < blkno);
        /* Handle the corner case that P_NEW returns non-consecutive pages */
        if (BufferGetBlockNumber(buffer) != blkno)
        {
            if (mode == RBM_ZERO_AND_LOCK || mode == RBM_ZERO_AND_CLEANUP_LOCK)
                LockBuffer(buffer, BUFFER_LOCK_UNLOCK);
            ReleaseBuffer(buffer);
            buffer = ReadBufferWithoutRelcache(rnode, forknum, blkno,
                                               mode, NULL);
        }
    }

    if (mode == RBM_NORMAL)
    {
        /* check that page has been initialized */
        Page        page = (Page) BufferGetPage(buffer);

        /*
         * We assume that PageIsNew is safe without a lock. During recovery,
         * there should be no other backends that could modify the buffer at
         * the same time.
         */
        if (PageIsNew(page))
        {
            ReleaseBuffer(buffer);
            log_invalid_page(rnode, forknum, blkno, true);
            return InvalidBuffer;
        }
    }

    return buffer;
}

XLogReadBufferForRedo()

XLogRedoAction XLogReadBufferForRedo	(	XLogReaderState *	record,
		uint8	block_id,
		Buffer *	buf
	)

Definition at line 289 of file xlogutils.c.

References RBM_NORMAL, and XLogReadBufferForRedoExtended().

Referenced by _bt_clear_incomplete_split(), brin_xlog_desummarize_page(), brin_xlog_insert_update(), brin_xlog_revmap_extend(), brin_xlog_samepage_update(), brin_xlog_update(), btree_xlog_delete(), btree_xlog_insert(), btree_xlog_mark_page_halfdead(), btree_xlog_split(), btree_xlog_unlink_page(), generic_redo(), ginRedoClearIncompleteSplit(), ginRedoDeletePage(), ginRedoInsert(), ginRedoSplit(), ginRedoUpdateMetapage(), ginRedoVacuumDataLeafPage(), ginRedoVacuumPage(), gistRedoClearFollowRight(), gistRedoDeleteRecord(), gistRedoPageDelete(), gistRedoPageUpdateRecord(), hash_xlog_add_ovfl_page(), hash_xlog_delete(), hash_xlog_init_bitmap_page(), hash_xlog_insert(), hash_xlog_move_page_contents(), hash_xlog_split_allocate_page(), hash_xlog_split_cleanup(), hash_xlog_split_complete(), hash_xlog_split_page(), hash_xlog_squeeze_page(), hash_xlog_update_meta_page(), hash_xlog_vacuum_one_page(), heap_xlog_confirm(), heap_xlog_delete(), heap_xlog_freeze_page(), heap_xlog_inplace(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), heap_xlog_visible(), spgRedoAddLeaf(), spgRedoAddNode(), spgRedoMoveLeafs(), spgRedoPickSplit(), spgRedoSplitTuple(), spgRedoVacuumLeaf(), spgRedoVacuumRedirect(), spgRedoVacuumRoot(), and xlog_redo().

{
    return XLogReadBufferForRedoExtended(record, block_id, RBM_NORMAL,
                                         false, buf);
}

XLogReadBufferForRedoExtended()

XLogRedoAction XLogReadBufferForRedoExtended	(	XLogReaderState *	record,
		uint8	block_id,
		ReadBufferMode	mode,
		bool	get_cleanup_lock,
		Buffer *	buf
	)

Definition at line 326 of file xlogutils.c.

References Assert, BKPBLOCK_WILL_INIT, BLK_DONE, BLK_NEEDS_REDO, BLK_NOTFOUND, BLK_RESTORED, xl_invalid_page_key::blkno, XLogReaderState::blocks, BUFFER_LOCK_EXCLUSIVE, BufferGetPage, BufferIsValid, elog, XLogReaderState::EndRecPtr, ERROR, DecodedBkpBlock::flags, FlushOneBuffer(), INIT_FORKNUM, LockBuffer(), LockBufferForCleanup(), MarkBufferDirty(), PageGetLSN, PageIsNew, PageSetLSN, PANIC, RBM_ZERO_AND_CLEANUP_LOCK, RBM_ZERO_AND_LOCK, RestoreBlockImage(), XLogReadBufferExtended(), XLogRecBlockImageApply, XLogRecGetBlockTag(), and XLogRecHasBlockImage.

Referenced by btree_xlog_vacuum(), hash_xlog_delete(), hash_xlog_move_page_contents(), hash_xlog_split_allocate_page(), hash_xlog_squeeze_page(), hash_xlog_vacuum_one_page(), heap_xlog_clean(), heap_xlog_visible(), XLogInitBufferForRedo(), and XLogReadBufferForRedo().

{
    XLogRecPtr  lsn = record->EndRecPtr;
    RelFileNode rnode;
    ForkNumber  forknum;
    BlockNumber blkno;
    Page        page;
    bool        zeromode;
    bool        willinit;

    if (!XLogRecGetBlockTag(record, block_id, &rnode, &forknum, &blkno))
    {
        /* Caller specified a bogus block_id */
        elog(PANIC, "failed to locate backup block with ID %d", block_id);
    }

    /*
     * Make sure that if the block is marked with WILL_INIT, the caller is
     * going to initialize it. And vice versa.
     */
    zeromode = (mode == RBM_ZERO_AND_LOCK || mode == RBM_ZERO_AND_CLEANUP_LOCK);
    willinit = (record->blocks[block_id].flags & BKPBLOCK_WILL_INIT) != 0;
    if (willinit && !zeromode)
        elog(PANIC, "block with WILL_INIT flag in WAL record must be zeroed by redo routine");
    if (!willinit && zeromode)
        elog(PANIC, "block to be initialized in redo routine must be marked with WILL_INIT flag in the WAL record");

    /* If it has a full-page image and it should be restored, do it. */
    if (XLogRecBlockImageApply(record, block_id))
    {
        Assert(XLogRecHasBlockImage(record, block_id));
        *buf = XLogReadBufferExtended(rnode, forknum, blkno,
                                      get_cleanup_lock ? RBM_ZERO_AND_CLEANUP_LOCK : RBM_ZERO_AND_LOCK);
        page = BufferGetPage(*buf);
        if (!RestoreBlockImage(record, block_id, page))
            elog(ERROR, "failed to restore block image");

        /*
         * The page may be uninitialized. If so, we can't set the LSN because
         * that would corrupt the page.
         */
        if (!PageIsNew(page))
        {
            PageSetLSN(page, lsn);
        }

        MarkBufferDirty(*buf);

        /*
         * At the end of crash recovery the init forks of unlogged relations
         * are copied, without going through shared buffers. So we need to
         * force the on-disk state of init forks to always be in sync with the
         * state in shared buffers.
         */
        if (forknum == INIT_FORKNUM)
            FlushOneBuffer(*buf);

        return BLK_RESTORED;
    }
    else
    {
        *buf = XLogReadBufferExtended(rnode, forknum, blkno, mode);
        if (BufferIsValid(*buf))
        {
            if (mode != RBM_ZERO_AND_LOCK && mode != RBM_ZERO_AND_CLEANUP_LOCK)
            {
                if (get_cleanup_lock)
                    LockBufferForCleanup(*buf);
                else
                    LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE);
            }
            if (lsn <= PageGetLSN(BufferGetPage(*buf)))
                return BLK_DONE;
            else
                return BLK_NEEDS_REDO;
        }
        else
            return BLK_NOTFOUND;
    }
}

XLogReadDetermineTimeline()

void XLogReadDetermineTimeline	(	XLogReaderState *	state,
		XLogRecPtr	wantPage,
		uint32	wantLength
	)

Definition at line 803 of file xlogutils.c.

References Assert, XLogReaderState::currTLI, XLogReaderState::currTLIValidUntil, DEBUG3, elog, InvalidXLogRecPtr, list_free_deep(), Min, XLogReaderState::nextTLI, XLogReaderState::readLen, XLogReaderState::readOff, XLogReaderState::readSegNo, readTimeLineHistory(), ThisTimeLineID, tliOfPointInHistory(), tliSwitchPoint(), and XLogReaderState::wal_segment_size.

Referenced by logical_read_xlog_page(), and read_local_xlog_page().

{
    const XLogRecPtr lastReadPage = state->readSegNo *
    state->wal_segment_size + state->readOff;

    Assert(wantPage != InvalidXLogRecPtr && wantPage % XLOG_BLCKSZ == 0);
    Assert(wantLength <= XLOG_BLCKSZ);
    Assert(state->readLen == 0 || state->readLen <= XLOG_BLCKSZ);

    /*
     * If the desired page is currently read in and valid, we have nothing to
     * do.
     *
     * The caller should've ensured that it didn't previously advance readOff
     * past the valid limit of this timeline, so it doesn't matter if the
     * current TLI has since become historical.
     */
    if (lastReadPage == wantPage &&
        state->readLen != 0 &&
        lastReadPage + state->readLen >= wantPage + Min(wantLength, XLOG_BLCKSZ - 1))
        return;

    /*
     * If we're reading from the current timeline, it hasn't become historical
     * and the page we're reading is after the last page read, we can again
     * just carry on. (Seeking backwards requires a check to make sure the
     * older page isn't on a prior timeline).
     *
     * ThisTimeLineID might've become historical since we last looked, but the
     * caller is required not to read past the flush limit it saw at the time
     * it looked up the timeline. There's nothing we can do about it if
     * StartupXLOG() renames it to .partial concurrently.
     */
    if (state->currTLI == ThisTimeLineID && wantPage >= lastReadPage)
    {
        Assert(state->currTLIValidUntil == InvalidXLogRecPtr);
        return;
    }

    /*
     * If we're just reading pages from a previously validated historical
     * timeline and the timeline we're reading from is valid until the end of
     * the current segment we can just keep reading.
     */
    if (state->currTLIValidUntil != InvalidXLogRecPtr &&
        state->currTLI != ThisTimeLineID &&
        state->currTLI != 0 &&
        ((wantPage + wantLength) / state->wal_segment_size) <
        (state->currTLIValidUntil / state->wal_segment_size))
        return;

    /*
     * If we reach this point we're either looking up a page for random
     * access, the current timeline just became historical, or we're reading
     * from a new segment containing a timeline switch. In all cases we need
     * to determine the newest timeline on the segment.
     *
     * If it's the current timeline we can just keep reading from here unless
     * we detect a timeline switch that makes the current timeline historical.
     * If it's a historical timeline we can read all the segment on the newest
     * timeline because it contains all the old timelines' data too. So only
     * one switch check is required.
     */
    {
        /*
         * We need to re-read the timeline history in case it's been changed
         * by a promotion or replay from a cascaded replica.
         */
        List       *timelineHistory = readTimeLineHistory(ThisTimeLineID);

        XLogRecPtr  endOfSegment = (((wantPage / state->wal_segment_size) + 1)
                                    * state->wal_segment_size) - 1;

        Assert(wantPage / state->wal_segment_size ==
               endOfSegment / state->wal_segment_size);

        /*
         * Find the timeline of the last LSN on the segment containing
         * wantPage.
         */
        state->currTLI = tliOfPointInHistory(endOfSegment, timelineHistory);
        state->currTLIValidUntil = tliSwitchPoint(state->currTLI, timelineHistory,
                                                  &state->nextTLI);

        Assert(state->currTLIValidUntil == InvalidXLogRecPtr ||
               wantPage + wantLength < state->currTLIValidUntil);

        list_free_deep(timelineHistory);

        elog(DEBUG3, "switched to timeline %u valid until %X/%X",
             state->currTLI,
             (uint32) (state->currTLIValidUntil >> 32),
             (uint32) (state->currTLIValidUntil));
    }
}

XLogTruncateRelation()

void XLogTruncateRelation	(	RelFileNode	rnode,
		ForkNumber	forkNum,
		BlockNumber	nblocks
	)

Definition at line 636 of file xlogutils.c.

References forget_invalid_pages().

Referenced by smgr_redo().

{
    forget_invalid_pages(rnode, forkNum, nblocks);
}

Variable Documentation

invalid_page_tab

HTAB* invalid_page_tab = NULL

static

Definition at line 57 of file xlogutils.c.