brin_revmap.c File Reference

#include "postgres.h"
#include "access/brin_page.h"
#include "access/brin_pageops.h"
#include "access/brin_revmap.h"
#include "access/brin_tuple.h"
#include "access/brin_xlog.h"
#include "access/rmgr.h"
#include "access/xloginsert.h"
#include "miscadmin.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
#include "utils/rel.h"

Include dependency graph for brin_revmap.c:

Go to the source code of this file.

Data Structures
struct	BrinRevmap

Macros
#define	HEAPBLK_TO_REVMAP_BLK(pagesPerRange, heapBlk)    ((heapBlk / pagesPerRange) / REVMAP_PAGE_MAXITEMS)
#define	HEAPBLK_TO_REVMAP_INDEX(pagesPerRange, heapBlk)    ((heapBlk / pagesPerRange) % REVMAP_PAGE_MAXITEMS)

Functions
static BlockNumber	revmap_get_blkno (BrinRevmap *revmap, BlockNumber heapBlk)
static Buffer	revmap_get_buffer (BrinRevmap *revmap, BlockNumber heapBlk)
static BlockNumber	revmap_extend_and_get_blkno (BrinRevmap *revmap, BlockNumber heapBlk)
static void	revmap_physical_extend (BrinRevmap *revmap)
BrinRevmap *	brinRevmapInitialize (Relation idxrel, BlockNumber *pagesPerRange)
void	brinRevmapTerminate (BrinRevmap *revmap)
void	brinRevmapExtend (BrinRevmap *revmap, BlockNumber heapBlk)
Buffer	brinLockRevmapPageForUpdate (BrinRevmap *revmap, BlockNumber heapBlk)
void	brinSetHeapBlockItemptr (Buffer buf, BlockNumber pagesPerRange, BlockNumber heapBlk, ItemPointerData tid)
BrinTuple *	brinGetTupleForHeapBlock (BrinRevmap *revmap, BlockNumber heapBlk, Buffer *buf, OffsetNumber *off, Size *size, int mode)
bool	brinRevmapDesummarizeRange (Relation idxrel, BlockNumber heapBlk)

Macro Definition Documentation

HEAPBLK_TO_REVMAP_BLK

#define HEAPBLK_TO_REVMAP_BLK	(		pagesPerRange,
			heapBlk
	)		((heapBlk / pagesPerRange) / REVMAP_PAGE_MAXITEMS)

Definition at line 41 of file brin_revmap.c.

HEAPBLK_TO_REVMAP_INDEX

#define HEAPBLK_TO_REVMAP_INDEX	(		pagesPerRange,
			heapBlk
	)		((heapBlk / pagesPerRange) % REVMAP_PAGE_MAXITEMS)

Definition at line 43 of file brin_revmap.c.

Function Documentation

brinGetTupleForHeapBlock()

BrinTuple* brinGetTupleForHeapBlock	(	BrinRevmap *	revmap,
		BlockNumber	heapBlk,
		Buffer *	buf,
		OffsetNumber *	off,
		Size *	size,
		int	mode
	)

Definition at line 195 of file brin_revmap.c.

{
    Relation    idxRel = revmap->rm_irel;
    BlockNumber mapBlk;
    RevmapContents *contents;
    ItemPointerData *iptr;
    BlockNumber blk;
    Page        page;
    ItemId      lp;
    BrinTuple  *tup;
    ItemPointerData previptr;
 
    /* normalize the heap block number to be the first page in the range */
    heapBlk = (heapBlk / revmap->rm_pagesPerRange) * revmap->rm_pagesPerRange;
 
    /*
     * Compute the revmap page number we need.  If Invalid is returned (i.e.,
     * the revmap page hasn't been created yet), the requested page range is
     * not summarized.
     */
    mapBlk = revmap_get_blkno(revmap, heapBlk);
    if (mapBlk == InvalidBlockNumber)
    {
        *off = InvalidOffsetNumber;
        return NULL;
    }
 
    ItemPointerSetInvalid(&previptr);
    for (;;)
    {
        CHECK_FOR_INTERRUPTS();
 
        if (revmap->rm_currBuf == InvalidBuffer ||
            BufferGetBlockNumber(revmap->rm_currBuf) != mapBlk)
        {
            if (revmap->rm_currBuf != InvalidBuffer)
                ReleaseBuffer(revmap->rm_currBuf);
 
            Assert(mapBlk != InvalidBlockNumber);
            revmap->rm_currBuf = ReadBuffer(revmap->rm_irel, mapBlk);
        }
 
        LockBuffer(revmap->rm_currBuf, BUFFER_LOCK_SHARE);
 
        contents = (RevmapContents *)
            PageGetContents(BufferGetPage(revmap->rm_currBuf));
        iptr = contents->rm_tids;
        iptr += HEAPBLK_TO_REVMAP_INDEX(revmap->rm_pagesPerRange, heapBlk);
 
        if (!ItemPointerIsValid(iptr))
        {
            LockBuffer(revmap->rm_currBuf, BUFFER_LOCK_UNLOCK);
            return NULL;
        }
 
        /*
         * Check the TID we got in a previous iteration, if any, and save the
         * current TID we got from the revmap; if we loop, we can sanity-check
         * that the next one we get is different.  Otherwise we might be stuck
         * looping forever if the revmap is somehow badly broken.
         */
        if (ItemPointerIsValid(&previptr) && ItemPointerEquals(&previptr, iptr))
            ereport(ERROR,
                    (errcode(ERRCODE_INDEX_CORRUPTED),
                     errmsg_internal("corrupted BRIN index: inconsistent range map")));
        previptr = *iptr;
 
        blk = ItemPointerGetBlockNumber(iptr);
        *off = ItemPointerGetOffsetNumber(iptr);
 
        LockBuffer(revmap->rm_currBuf, BUFFER_LOCK_UNLOCK);
 
        /* Ok, got a pointer to where the BrinTuple should be. Fetch it. */
        if (!BufferIsValid(*buf) || BufferGetBlockNumber(*buf) != blk)
        {
            if (BufferIsValid(*buf))
                ReleaseBuffer(*buf);
            *buf = ReadBuffer(idxRel, blk);
        }
        LockBuffer(*buf, mode);
        page = BufferGetPage(*buf);
 
        /* If we land on a revmap page, start over */
        if (BRIN_IS_REGULAR_PAGE(page))
        {
            /*
             * If the offset number is greater than what's in the page, it's
             * possible that the range was desummarized concurrently. Just
             * return NULL to handle that case.
             */
            if (*off > PageGetMaxOffsetNumber(page))
            {
                LockBuffer(*buf, BUFFER_LOCK_UNLOCK);
                return NULL;
            }
 
            lp = PageGetItemId(page, *off);
            if (ItemIdIsUsed(lp))
            {
                tup = (BrinTuple *) PageGetItem(page, lp);
 
                if (tup->bt_blkno == heapBlk)
                {
                    if (size)
                        *size = ItemIdGetLength(lp);
                    /* found it! */
                    return tup;
                }
            }
        }
 
        /*
         * No luck. Assume that the revmap was updated concurrently.
         */
        LockBuffer(*buf, BUFFER_LOCK_UNLOCK);
    }
    /* not reached, but keep compiler quiet */
    return NULL;
}

References Assert(), BRIN_IS_REGULAR_PAGE, BrinTuple::bt_blkno, buf, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), CHECK_FOR_INTERRUPTS, ereport, errcode(), errmsg_internal(), ERROR, HEAPBLK_TO_REVMAP_INDEX, InvalidBlockNumber, InvalidBuffer, InvalidOffsetNumber, ItemIdGetLength, ItemIdIsUsed, ItemPointerEquals(), ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), ItemPointerSetInvalid(), LockBuffer(), mode, PageGetContents(), PageGetItem(), PageGetItemId(), PageGetMaxOffsetNumber(), ReadBuffer(), ReleaseBuffer(), revmap_get_blkno(), BrinRevmap::rm_currBuf, BrinRevmap::rm_irel, BrinRevmap::rm_pagesPerRange, and RevmapContents::rm_tids.

Referenced by bringetbitmap(), brininsert(), brinsummarize(), and summarize_range().

brinLockRevmapPageForUpdate()

Buffer brinLockRevmapPageForUpdate	(	BrinRevmap *	revmap,
		BlockNumber	heapBlk
	)

Definition at line 135 of file brin_revmap.c.

{
    Buffer      rmBuf;
 
    rmBuf = revmap_get_buffer(revmap, heapBlk);
    LockBuffer(rmBuf, BUFFER_LOCK_EXCLUSIVE);
 
    return rmBuf;
}

References BUFFER_LOCK_EXCLUSIVE, LockBuffer(), and revmap_get_buffer().

Referenced by brin_doinsert(), brin_doupdate(), and brinRevmapDesummarizeRange().

brinRevmapDesummarizeRange()

bool brinRevmapDesummarizeRange	(	Relation	idxrel,
		BlockNumber	heapBlk
	)

Definition at line 324 of file brin_revmap.c.

{
    BrinRevmap *revmap;
    BlockNumber pagesPerRange;
    RevmapContents *contents;
    ItemPointerData *iptr;
    ItemPointerData invalidIptr;
    BlockNumber revmapBlk;
    Buffer      revmapBuf;
    Buffer      regBuf;
    Page        revmapPg;
    Page        regPg;
    OffsetNumber revmapOffset;
    OffsetNumber regOffset;
    ItemId      lp;
 
    revmap = brinRevmapInitialize(idxrel, &pagesPerRange);
 
    revmapBlk = revmap_get_blkno(revmap, heapBlk);
    if (!BlockNumberIsValid(revmapBlk))
    {
        /* revmap page doesn't exist: range not summarized, we're done */
        brinRevmapTerminate(revmap);
        return true;
    }
 
    /* Lock the revmap page, obtain the index tuple pointer from it */
    revmapBuf = brinLockRevmapPageForUpdate(revmap, heapBlk);
    revmapPg = BufferGetPage(revmapBuf);
    revmapOffset = HEAPBLK_TO_REVMAP_INDEX(revmap->rm_pagesPerRange, heapBlk);
 
    contents = (RevmapContents *) PageGetContents(revmapPg);
    iptr = contents->rm_tids;
    iptr += revmapOffset;
 
    if (!ItemPointerIsValid(iptr))
    {
        /* no index tuple: range not summarized, we're done */
        LockBuffer(revmapBuf, BUFFER_LOCK_UNLOCK);
        brinRevmapTerminate(revmap);
        return true;
    }
 
    regBuf = ReadBuffer(idxrel, ItemPointerGetBlockNumber(iptr));
    LockBuffer(regBuf, BUFFER_LOCK_EXCLUSIVE);
    regPg = BufferGetPage(regBuf);
 
    /* if this is no longer a regular page, tell caller to start over */
    if (!BRIN_IS_REGULAR_PAGE(regPg))
    {
        LockBuffer(revmapBuf, BUFFER_LOCK_UNLOCK);
        LockBuffer(regBuf, BUFFER_LOCK_UNLOCK);
        brinRevmapTerminate(revmap);
        return false;
    }
 
    regOffset = ItemPointerGetOffsetNumber(iptr);
    if (regOffset > PageGetMaxOffsetNumber(regPg))
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("corrupted BRIN index: inconsistent range map")));
 
    lp = PageGetItemId(regPg, regOffset);
    if (!ItemIdIsUsed(lp))
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("corrupted BRIN index: inconsistent range map")));
 
    /*
     * Placeholder tuples only appear during unfinished summarization, and we
     * hold ShareUpdateExclusiveLock, so this function cannot run concurrently
     * with that.  So any placeholder tuples that exist are leftovers from a
     * crashed or aborted summarization; remove them silently.
     */
 
    START_CRIT_SECTION();
 
    ItemPointerSetInvalid(&invalidIptr);
    brinSetHeapBlockItemptr(revmapBuf, revmap->rm_pagesPerRange, heapBlk,
                            invalidIptr);
    PageIndexTupleDeleteNoCompact(regPg, regOffset);
    /* XXX record free space in FSM? */
 
    MarkBufferDirty(regBuf);
    MarkBufferDirty(revmapBuf);
 
    if (RelationNeedsWAL(idxrel))
    {
        xl_brin_desummarize xlrec;
        XLogRecPtr  recptr;
 
        xlrec.pagesPerRange = revmap->rm_pagesPerRange;
        xlrec.heapBlk = heapBlk;
        xlrec.regOffset = regOffset;
 
        XLogBeginInsert();
        XLogRegisterData((char *) &xlrec, SizeOfBrinDesummarize);
        XLogRegisterBuffer(0, revmapBuf, 0);
        XLogRegisterBuffer(1, regBuf, REGBUF_STANDARD);
        recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_DESUMMARIZE);
        PageSetLSN(revmapPg, recptr);
        PageSetLSN(regPg, recptr);
    }
 
    END_CRIT_SECTION();
 
    UnlockReleaseBuffer(regBuf);
    LockBuffer(revmapBuf, BUFFER_LOCK_UNLOCK);
    brinRevmapTerminate(revmap);
 
    return true;
}

References BlockNumberIsValid(), BRIN_IS_REGULAR_PAGE, brinLockRevmapPageForUpdate(), brinRevmapInitialize(), brinRevmapTerminate(), brinSetHeapBlockItemptr(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetPage(), END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, xl_brin_desummarize::heapBlk, HEAPBLK_TO_REVMAP_INDEX, ItemIdIsUsed, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), ItemPointerSetInvalid(), LockBuffer(), MarkBufferDirty(), PageGetContents(), PageGetItemId(), PageGetMaxOffsetNumber(), PageIndexTupleDeleteNoCompact(), PageSetLSN(), xl_brin_desummarize::pagesPerRange, ReadBuffer(), REGBUF_STANDARD, xl_brin_desummarize::regOffset, RelationNeedsWAL, revmap_get_blkno(), BrinRevmap::rm_pagesPerRange, RevmapContents::rm_tids, SizeOfBrinDesummarize, START_CRIT_SECTION, UnlockReleaseBuffer(), XLOG_BRIN_DESUMMARIZE, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by brin_desummarize_range().

brinRevmapExtend()

void brinRevmapExtend	(	BrinRevmap *	revmap,
		BlockNumber	heapBlk
	)

Definition at line 113 of file brin_revmap.c.

{
    BlockNumber mapBlk PG_USED_FOR_ASSERTS_ONLY;
 
    mapBlk = revmap_extend_and_get_blkno(revmap, heapBlk);
 
    /* Ensure the buffer we got is in the expected range */
    Assert(mapBlk != InvalidBlockNumber &&
           mapBlk != BRIN_METAPAGE_BLKNO &&
           mapBlk <= revmap->rm_lastRevmapPage);
}

References Assert(), BRIN_METAPAGE_BLKNO, InvalidBlockNumber, PG_USED_FOR_ASSERTS_ONLY, and revmap_extend_and_get_blkno().

Referenced by brin_doinsert(), and brin_doupdate().

brinRevmapInitialize()

BrinRevmap* brinRevmapInitialize	(	Relation	idxrel,
		BlockNumber *	pagesPerRange
	)

Definition at line 71 of file brin_revmap.c.

{
    BrinRevmap *revmap;
    Buffer      meta;
    BrinMetaPageData *metadata;
    Page        page;
 
    meta = ReadBuffer(idxrel, BRIN_METAPAGE_BLKNO);
    LockBuffer(meta, BUFFER_LOCK_SHARE);
    page = BufferGetPage(meta);
    metadata = (BrinMetaPageData *) PageGetContents(page);
 
    revmap = palloc(sizeof(BrinRevmap));
    revmap->rm_irel = idxrel;
    revmap->rm_pagesPerRange = metadata->pagesPerRange;
    revmap->rm_lastRevmapPage = metadata->lastRevmapPage;
    revmap->rm_metaBuf = meta;
    revmap->rm_currBuf = InvalidBuffer;
 
    *pagesPerRange = metadata->pagesPerRange;
 
    LockBuffer(meta, BUFFER_LOCK_UNLOCK);
 
    return revmap;
}

References BRIN_METAPAGE_BLKNO, BUFFER_LOCK_SHARE, BUFFER_LOCK_UNLOCK, BufferGetPage(), InvalidBuffer, BrinMetaPageData::lastRevmapPage, LockBuffer(), PageGetContents(), BrinMetaPageData::pagesPerRange, palloc(), ReadBuffer(), BrinRevmap::rm_currBuf, BrinRevmap::rm_irel, BrinRevmap::rm_lastRevmapPage, BrinRevmap::rm_metaBuf, and BrinRevmap::rm_pagesPerRange.

Referenced by brinbeginscan(), brinbuild(), brininsert(), brinRevmapDesummarizeRange(), and brinsummarize().

brinRevmapTerminate()

void brinRevmapTerminate

(

BrinRevmap *

revmap

)

Definition at line 101 of file brin_revmap.c.

{
    ReleaseBuffer(revmap->rm_metaBuf);
    if (revmap->rm_currBuf != InvalidBuffer)
        ReleaseBuffer(revmap->rm_currBuf);
    pfree(revmap);
}

References InvalidBuffer, pfree(), ReleaseBuffer(), BrinRevmap::rm_currBuf, and BrinRevmap::rm_metaBuf.

Referenced by brinbuild(), brinendscan(), brininsert(), brinRevmapDesummarizeRange(), and brinsummarize().

brinSetHeapBlockItemptr()

void brinSetHeapBlockItemptr	(	Buffer	buf,
		BlockNumber	pagesPerRange,
		BlockNumber	heapBlk,
		ItemPointerData	tid
	)

Definition at line 156 of file brin_revmap.c.

{
    RevmapContents *contents;
    ItemPointerData *iptr;
    Page        page;
 
    /* The correct page should already be pinned and locked */
    page = BufferGetPage(buf);
    contents = (RevmapContents *) PageGetContents(page);
    iptr = (ItemPointerData *) contents->rm_tids;
    iptr += HEAPBLK_TO_REVMAP_INDEX(pagesPerRange, heapBlk);
 
    if (ItemPointerIsValid(&tid))
        ItemPointerSet(iptr,
                       ItemPointerGetBlockNumber(&tid),
                       ItemPointerGetOffsetNumber(&tid));
    else
        ItemPointerSetInvalid(iptr);
}

References buf, BufferGetPage(), HEAPBLK_TO_REVMAP_INDEX, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), ItemPointerIsValid(), ItemPointerSet(), ItemPointerSetInvalid(), PageGetContents(), and RevmapContents::rm_tids.

Referenced by brin_doinsert(), brin_doupdate(), brin_xlog_desummarize_page(), brin_xlog_insert_update(), and brinRevmapDesummarizeRange().

revmap_extend_and_get_blkno()

static BlockNumber revmap_extend_and_get_blkno ( BrinRevmap *  revmap, BlockNumber  heapBlk  )

static

Definition at line 501 of file brin_revmap.c.

{
    BlockNumber targetblk;
 
    /* obtain revmap block number, skip 1 for metapage block */
    targetblk = HEAPBLK_TO_REVMAP_BLK(revmap->rm_pagesPerRange, heapBlk) + 1;
 
    /* Extend the revmap, if necessary */
    while (targetblk > revmap->rm_lastRevmapPage)
    {
        CHECK_FOR_INTERRUPTS();
        revmap_physical_extend(revmap);
    }
 
    return targetblk;
}

References CHECK_FOR_INTERRUPTS, HEAPBLK_TO_REVMAP_BLK, revmap_physical_extend(), BrinRevmap::rm_lastRevmapPage, and BrinRevmap::rm_pagesPerRange.

Referenced by brinRevmapExtend().

revmap_get_blkno()

static BlockNumber revmap_get_blkno ( BrinRevmap *  revmap, BlockNumber  heapBlk  )

static

Definition at line 443 of file brin_revmap.c.

{
    BlockNumber targetblk;
 
    /* obtain revmap block number, skip 1 for metapage block */
    targetblk = HEAPBLK_TO_REVMAP_BLK(revmap->rm_pagesPerRange, heapBlk) + 1;
 
    /* Normal case: the revmap page is already allocated */
    if (targetblk <= revmap->rm_lastRevmapPage)
        return targetblk;
 
    return InvalidBlockNumber;
}

References HEAPBLK_TO_REVMAP_BLK, InvalidBlockNumber, and BrinRevmap::rm_pagesPerRange.

Referenced by brinGetTupleForHeapBlock(), brinRevmapDesummarizeRange(), and revmap_get_buffer().

revmap_get_buffer()

static Buffer revmap_get_buffer ( BrinRevmap *  revmap, BlockNumber  heapBlk  )

static

Definition at line 464 of file brin_revmap.c.

{
    BlockNumber mapBlk;
 
    /* Translate the heap block number to physical index location. */
    mapBlk = revmap_get_blkno(revmap, heapBlk);
 
    if (mapBlk == InvalidBlockNumber)
        elog(ERROR, "revmap does not cover heap block %u", heapBlk);
 
    /* Ensure the buffer we got is in the expected range */
    Assert(mapBlk != BRIN_METAPAGE_BLKNO &&
           mapBlk <= revmap->rm_lastRevmapPage);
 
    /*
     * Obtain the buffer from which we need to read.  If we already have the
     * correct buffer in our access struct, use that; otherwise, release that,
     * (if valid) and read the one we need.
     */
    if (revmap->rm_currBuf == InvalidBuffer ||
        mapBlk != BufferGetBlockNumber(revmap->rm_currBuf))
    {
        if (revmap->rm_currBuf != InvalidBuffer)
            ReleaseBuffer(revmap->rm_currBuf);
 
        revmap->rm_currBuf = ReadBuffer(revmap->rm_irel, mapBlk);
    }
 
    return revmap->rm_currBuf;
}

References Assert(), BRIN_METAPAGE_BLKNO, BufferGetBlockNumber(), elog(), ERROR, InvalidBlockNumber, InvalidBuffer, ReadBuffer(), ReleaseBuffer(), revmap_get_blkno(), BrinRevmap::rm_currBuf, and BrinRevmap::rm_irel.

Referenced by brinLockRevmapPageForUpdate().

revmap_physical_extend()

static void revmap_physical_extend ( BrinRevmap *  revmap )

static

Definition at line 523 of file brin_revmap.c.

{
    Buffer      buf;
    Page        page;
    Page        metapage;
    BrinMetaPageData *metadata;
    BlockNumber mapBlk;
    BlockNumber nblocks;
    Relation    irel = revmap->rm_irel;
 
    /*
     * Lock the metapage. This locks out concurrent extensions of the revmap,
     * but note that we still need to grab the relation extension lock because
     * another backend can extend the index with regular BRIN pages.
     */
    LockBuffer(revmap->rm_metaBuf, BUFFER_LOCK_EXCLUSIVE);
    metapage = BufferGetPage(revmap->rm_metaBuf);
    metadata = (BrinMetaPageData *) PageGetContents(metapage);
 
    /*
     * Check that our cached lastRevmapPage value was up-to-date; if it
     * wasn't, update the cached copy and have caller start over.
     */
    if (metadata->lastRevmapPage != revmap->rm_lastRevmapPage)
    {
        revmap->rm_lastRevmapPage = metadata->lastRevmapPage;
        LockBuffer(revmap->rm_metaBuf, BUFFER_LOCK_UNLOCK);
        return;
    }
    mapBlk = metadata->lastRevmapPage + 1;
 
    nblocks = RelationGetNumberOfBlocks(irel);
    if (mapBlk < nblocks)
    {
        buf = ReadBuffer(irel, mapBlk);
        LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
        page = BufferGetPage(buf);
    }
    else
    {
        buf = ExtendBufferedRel(BMR_REL(irel), MAIN_FORKNUM, NULL,
                                EB_LOCK_FIRST);
        if (BufferGetBlockNumber(buf) != mapBlk)
        {
            /*
             * Very rare corner case: somebody extended the relation
             * concurrently after we read its length.  If this happens, give
             * up and have caller start over.  We will have to evacuate that
             * page from under whoever is using it.
             */
            LockBuffer(revmap->rm_metaBuf, BUFFER_LOCK_UNLOCK);
            UnlockReleaseBuffer(buf);
            return;
        }
        page = BufferGetPage(buf);
    }
 
    /* Check that it's a regular block (or an empty page) */
    if (!PageIsNew(page) && !BRIN_IS_REGULAR_PAGE(page))
        ereport(ERROR,
                (errcode(ERRCODE_INDEX_CORRUPTED),
                 errmsg("unexpected page type 0x%04X in BRIN index \"%s\" block %u",
                        BrinPageType(page),
                        RelationGetRelationName(irel),
                        BufferGetBlockNumber(buf))));
 
    /* If the page is in use, evacuate it and restart */
    if (brin_start_evacuating_page(irel, buf))
    {
        LockBuffer(revmap->rm_metaBuf, BUFFER_LOCK_UNLOCK);
        brin_evacuate_page(irel, revmap->rm_pagesPerRange, revmap, buf);
 
        /* have caller start over */
        return;
    }
 
    /*
     * Ok, we have now locked the metapage and the target block. Re-initialize
     * the target block as a revmap page, and update the metapage.
     */
    START_CRIT_SECTION();
 
    /* the rm_tids array is initialized to all invalid by PageInit */
    brin_page_init(page, BRIN_PAGETYPE_REVMAP);
    MarkBufferDirty(buf);
 
    metadata->lastRevmapPage = mapBlk;
 
    /*
     * Set pd_lower just past the end of the metadata.  This is essential,
     * because without doing so, metadata will be lost if xlog.c compresses
     * the page.  (We must do this here because pre-v11 versions of PG did not
     * set the metapage's pd_lower correctly, so a pg_upgraded index might
     * contain the wrong value.)
     */
    ((PageHeader) metapage)->pd_lower =
        ((char *) metadata + sizeof(BrinMetaPageData)) - (char *) metapage;
 
    MarkBufferDirty(revmap->rm_metaBuf);
 
    if (RelationNeedsWAL(revmap->rm_irel))
    {
        xl_brin_revmap_extend xlrec;
        XLogRecPtr  recptr;
 
        xlrec.targetBlk = mapBlk;
 
        XLogBeginInsert();
        XLogRegisterData((char *) &xlrec, SizeOfBrinRevmapExtend);
        XLogRegisterBuffer(0, revmap->rm_metaBuf, REGBUF_STANDARD);
 
        XLogRegisterBuffer(1, buf, REGBUF_WILL_INIT);
 
        recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_REVMAP_EXTEND);
        PageSetLSN(metapage, recptr);
        PageSetLSN(page, recptr);
    }
 
    END_CRIT_SECTION();
 
    LockBuffer(revmap->rm_metaBuf, BUFFER_LOCK_UNLOCK);
 
    UnlockReleaseBuffer(buf);
}

References BMR_REL, brin_evacuate_page(), BRIN_IS_REGULAR_PAGE, brin_page_init(), BRIN_PAGETYPE_REVMAP, brin_start_evacuating_page(), BrinPageType, buf, BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), EB_LOCK_FIRST, END_CRIT_SECTION, ereport, errcode(), errmsg(), ERROR, ExtendBufferedRel(), BrinMetaPageData::lastRevmapPage, LockBuffer(), MAIN_FORKNUM, MarkBufferDirty(), PageGetContents(), PageIsNew(), PageSetLSN(), ReadBuffer(), REGBUF_STANDARD, REGBUF_WILL_INIT, RelationGetNumberOfBlocks, RelationGetRelationName, RelationNeedsWAL, BrinRevmap::rm_irel, BrinRevmap::rm_lastRevmapPage, BrinRevmap::rm_metaBuf, BrinRevmap::rm_pagesPerRange, SizeOfBrinRevmapExtend, START_CRIT_SECTION, xl_brin_revmap_extend::targetBlk, UnlockReleaseBuffer(), XLOG_BRIN_REVMAP_EXTEND, XLogBeginInsert(), XLogInsert(), XLogRegisterBuffer(), and XLogRegisterData().

Referenced by revmap_extend_and_get_blkno().