#include "postgres.h"
#include "access/bufmask.h"
#include "access/heapam_xlog.h"
#include "access/nbtree.h"
#include "access/nbtxlog.h"
#include "access/transam.h"
#include "access/xlog.h"
#include "access/xlogutils.h"
#include "storage/procarray.h"
#include "miscadmin.h"

Include dependency graph for nbtxlog.c:

Functions
static void	_bt_restore_page (Page page, char *from, int len)

static void	_bt_restore_meta (XLogReaderState *record, uint8 block_id)

static void	_bt_clear_incomplete_split (XLogReaderState *record, uint8 block_id)

static void	btree_xlog_insert (bool isleaf, bool ismeta, XLogReaderState *record)

static void	btree_xlog_split (bool onleft, XLogReaderState *record)

static void	btree_xlog_vacuum (XLogReaderState *record)

static TransactionId	btree_xlog_delete_get_latestRemovedXid (XLogReaderState *record)

static void	btree_xlog_delete (XLogReaderState *record)

static void	btree_xlog_mark_page_halfdead (uint8 info, XLogReaderState *record)

static void	btree_xlog_unlink_page (uint8 info, XLogReaderState *record)

static void	btree_xlog_newroot (XLogReaderState *record)

static void	btree_xlog_reuse_page (XLogReaderState *record)

void	btree_redo (XLogReaderState *record)

void	btree_mask (char *pagedata, BlockNumber blkno)

Function Documentation

static void _bt_clear_incomplete_split	(	XLogReaderState *	record,
		uint8	block_id
	)

static

Definition at line 128 of file nbtxlog.c.

References Assert, BLK_NEEDS_REDO, BTP_INCOMPLETE_SPLIT, BTPageOpaqueData::btpo_flags, buf, BufferGetPage, BufferIsValid, XLogReaderState::EndRecPtr, MarkBufferDirty(), P_INCOMPLETE_SPLIT, PageGetSpecialPointer, PageSetLSN, UnlockReleaseBuffer(), and XLogReadBufferForRedo().

Referenced by btree_xlog_insert(), btree_xlog_newroot(), and btree_xlog_split().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     Buffer      buf;
 
     if (XLogReadBufferForRedo(record, block_id, &buf) == BLK_NEEDS_REDO)
     {
         Page        page = (Page) BufferGetPage(buf);
         BTPageOpaque pageop = (BTPageOpaque) PageGetSpecialPointer(page);
 
         Assert(P_INCOMPLETE_SPLIT(pageop));
         pageop->btpo_flags &= ~BTP_INCOMPLETE_SPLIT;
 
         PageSetLSN(page, lsn);
         MarkBufferDirty(buf);
     }
     if (BufferIsValid(buf))
         UnlockReleaseBuffer(buf);
 }

static void _bt_restore_meta	(	XLogReaderState *	record,
		uint8	block_id
	)

static

Definition at line 77 of file nbtxlog.c.

References _bt_pageinit(), Assert, BTMetaPageData::btm_fastlevel, BTMetaPageData::btm_fastroot, BTMetaPageData::btm_level, BTMetaPageData::btm_magic, BTMetaPageData::btm_root, BTMetaPageData::btm_version, BTP_META, BTPageGetMeta, BTPageOpaqueData::btpo_flags, BTREE_MAGIC, BTREE_METAPAGE, BTREE_VERSION, BufferGetBlockNumber(), BufferGetPage, BufferGetPageSize, XLogReaderState::EndRecPtr, xl_btree_metadata::fastlevel, xl_btree_metadata::fastroot, xl_btree_metadata::level, MarkBufferDirty(), PageGetSpecialPointer, PageSetLSN, xl_btree_metadata::root, UnlockReleaseBuffer(), XLogInitBufferForRedo(), and XLogRecGetBlockData().

Referenced by btree_xlog_insert(), btree_xlog_newroot(), and btree_xlog_unlink_page().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     Buffer      metabuf;
     Page        metapg;
     BTMetaPageData *md;
     BTPageOpaque pageop;
     xl_btree_metadata *xlrec;
     char       *ptr;
     Size        len;
 
     metabuf = XLogInitBufferForRedo(record, block_id);
     ptr = XLogRecGetBlockData(record, block_id, &len);
 
     Assert(len == sizeof(xl_btree_metadata));
     Assert(BufferGetBlockNumber(metabuf) == BTREE_METAPAGE);
     xlrec = (xl_btree_metadata *) ptr;
     metapg = BufferGetPage(metabuf);
 
     _bt_pageinit(metapg, BufferGetPageSize(metabuf));
 
     md = BTPageGetMeta(metapg);
     md->btm_magic = BTREE_MAGIC;
     md->btm_version = BTREE_VERSION;
     md->btm_root = xlrec->root;
     md->btm_level = xlrec->level;
     md->btm_fastroot = xlrec->fastroot;
     md->btm_fastlevel = xlrec->fastlevel;
 
     pageop = (BTPageOpaque) PageGetSpecialPointer(metapg);
     pageop->btpo_flags = BTP_META;
 
     /*
      * Set pd_lower just past the end of the metadata.  This is not essential
      * but it makes the page look compressible to xlog.c.
      */
     ((PageHeader) metapg)->pd_lower =
         ((char *) md + sizeof(BTMetaPageData)) - (char *) metapg;
 
     PageSetLSN(metapg, lsn);
     MarkBufferDirty(metabuf);
     UnlockReleaseBuffer(metabuf);
 }

static void _bt_restore_page	(	Page	page,
		char *	from,
		int	len
	)

static

Definition at line 36 of file nbtxlog.c.

References elog, i, IndexTupleDSize, InvalidOffsetNumber, MAXALIGN, MaxIndexTuplesPerPage, PageAddItem, and PANIC.

Referenced by btree_xlog_newroot(), and btree_xlog_split().

 {
     IndexTupleData itupdata;
     Size        itemsz;
     char       *end = from + len;
     Item        items[MaxIndexTuplesPerPage];
     uint16      itemsizes[MaxIndexTuplesPerPage];
     int         i;
     int         nitems;
 
     /*
      * To get the items back in the original order, we add them to the page in
      * reverse.  To figure out where one tuple ends and another begins, we
      * have to scan them in forward order first.
      */
     i = 0;
     while (from < end)
     {
         /* Need to copy tuple header due to alignment considerations */
         memcpy(&itupdata, from, sizeof(IndexTupleData));
         itemsz = IndexTupleDSize(itupdata);
         itemsz = MAXALIGN(itemsz);
 
         items[i] = (Item) from;
         itemsizes[i] = itemsz;
         i++;
 
         from += itemsz;
     }
     nitems = i;
 
     for (i = nitems - 1; i >= 0; i--)
     {
         if (PageAddItem(page, items[i], itemsizes[i], nitems - i,
                         false, false) == InvalidOffsetNumber)
             elog(PANIC, "_bt_restore_page: cannot add item to page");
         from += itemsz;
     }
 }

void btree_mask	(	char *	pagedata,
		BlockNumber	blkno
	)

Definition at line 1032 of file nbtxlog.c.

References BTP_HAS_GARBAGE, BTP_SPLIT_END, BTPageOpaqueData::btpo_cycleid, BTPageOpaqueData::btpo_flags, mask_lp_flags(), mask_page_content(), mask_page_hint_bits(), mask_page_lsn_and_checksum(), mask_unused_space(), P_ISDELETED, P_ISLEAF, and PageGetSpecialPointer.

 {
     Page        page = (Page) pagedata;
     BTPageOpaque maskopaq;
 
     mask_page_lsn_and_checksum(page);
 
     mask_page_hint_bits(page);
     mask_unused_space(page);
 
     maskopaq = (BTPageOpaque) PageGetSpecialPointer(page);
 
     if (P_ISDELETED(maskopaq))
     {
         /*
          * Mask page content on a DELETED page since it will be re-initialized
          * during replay. See btree_xlog_unlink_page() for details.
          */
         mask_page_content(page);
     }
     else if (P_ISLEAF(maskopaq))
     {
         /*
          * In btree leaf pages, it is possible to modify the LP_FLAGS without
          * emitting any WAL record. Hence, mask the line pointer flags. See
          * _bt_killitems(), _bt_check_unique() for details.
          */
         mask_lp_flags(page);
     }
 
     /*
      * BTP_HAS_GARBAGE is just an un-logged hint bit. So, mask it. See
      * _bt_killitems(), _bt_check_unique() for details.
      */
     maskopaq->btpo_flags &= ~BTP_HAS_GARBAGE;
 
     /*
      * During replay of a btree page split, we don't set the BTP_SPLIT_END
      * flag of the right sibling and initialize the cycle_id to 0 for the same
      * page. See btree_xlog_split() for details.
      */
     maskopaq->btpo_flags &= ~BTP_SPLIT_END;
     maskopaq->btpo_cycleid = 0;
 }

void btree_redo ( XLogReaderState * record )

Definition at line 983 of file nbtxlog.c.

References btree_xlog_delete(), btree_xlog_insert(), btree_xlog_mark_page_halfdead(), btree_xlog_newroot(), btree_xlog_reuse_page(), btree_xlog_split(), btree_xlog_unlink_page(), btree_xlog_vacuum(), elog, PANIC, XLOG_BTREE_DELETE, XLOG_BTREE_INSERT_LEAF, XLOG_BTREE_INSERT_META, XLOG_BTREE_INSERT_UPPER, XLOG_BTREE_MARK_PAGE_HALFDEAD, XLOG_BTREE_NEWROOT, XLOG_BTREE_REUSE_PAGE, XLOG_BTREE_SPLIT_L, XLOG_BTREE_SPLIT_R, XLOG_BTREE_UNLINK_PAGE, XLOG_BTREE_UNLINK_PAGE_META, XLOG_BTREE_VACUUM, XLogRecGetInfo, and XLR_INFO_MASK.

 {
     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
 
     switch (info)
     {
         case XLOG_BTREE_INSERT_LEAF:
             btree_xlog_insert(true, false, record);
             break;
         case XLOG_BTREE_INSERT_UPPER:
             btree_xlog_insert(false, false, record);
             break;
         case XLOG_BTREE_INSERT_META:
             btree_xlog_insert(false, true, record);
             break;
         case XLOG_BTREE_SPLIT_L:
             btree_xlog_split(true, record);
             break;
         case XLOG_BTREE_SPLIT_R:
             btree_xlog_split(false, record);
             break;
         case XLOG_BTREE_VACUUM:
             btree_xlog_vacuum(record);
             break;
         case XLOG_BTREE_DELETE:
             btree_xlog_delete(record);
             break;
         case XLOG_BTREE_MARK_PAGE_HALFDEAD:
             btree_xlog_mark_page_halfdead(info, record);
             break;
         case XLOG_BTREE_UNLINK_PAGE:
         case XLOG_BTREE_UNLINK_PAGE_META:
             btree_xlog_unlink_page(info, record);
             break;
         case XLOG_BTREE_NEWROOT:
             btree_xlog_newroot(record);
             break;
         case XLOG_BTREE_REUSE_PAGE:
             btree_xlog_reuse_page(record);
             break;
         default:
             elog(PANIC, "btree_redo: unknown op code %u", info);
     }
 }

static void btree_xlog_delete ( XLogReaderState * record )

static

Definition at line 663 of file nbtxlog.c.

References BLK_NEEDS_REDO, BTP_HAS_GARBAGE, BTPageOpaqueData::btpo_flags, btree_xlog_delete_get_latestRemovedXid(), buffer, BufferGetPage, BufferIsValid, XLogReaderState::EndRecPtr, InHotStandby, MarkBufferDirty(), xl_btree_delete::nitems, PageGetSpecialPointer, PageIndexMultiDelete(), PageSetLSN, ResolveRecoveryConflictWithSnapshot(), SizeOfBtreeDelete, UnlockReleaseBuffer(), XLogReadBufferForRedo(), XLogRecGetBlockTag(), XLogRecGetData, and XLogRecGetDataLen.

Referenced by btree_redo().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     xl_btree_delete *xlrec = (xl_btree_delete *) XLogRecGetData(record);
     Buffer      buffer;
     Page        page;
     BTPageOpaque opaque;
 
     /*
      * If we have any conflict processing to do, it must happen before we
      * update the page.
      *
      * Btree delete records can conflict with standby queries.  You might
      * think that vacuum records would conflict as well, but we've handled
      * that already.  XLOG_HEAP2_CLEANUP_INFO records provide the highest xid
      * cleaned by the vacuum of the heap and so we can resolve any conflicts
      * just once when that arrives.  After that we know that no conflicts
      * exist from individual btree vacuum records on that index.
      */
     if (InHotStandby)
     {
         TransactionId latestRemovedXid = btree_xlog_delete_get_latestRemovedXid(record);
         RelFileNode rnode;
 
         XLogRecGetBlockTag(record, 0, &rnode, NULL, NULL);
 
         ResolveRecoveryConflictWithSnapshot(latestRemovedXid, rnode);
     }
 
     /*
      * We don't need to take a cleanup lock to apply these changes. See
      * nbtree/README for details.
      */
     if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
     {
         page = (Page) BufferGetPage(buffer);
 
         if (XLogRecGetDataLen(record) > SizeOfBtreeDelete)
         {
             OffsetNumber *unused;
 
             unused = (OffsetNumber *) ((char *) xlrec + SizeOfBtreeDelete);
 
             PageIndexMultiDelete(page, unused, xlrec->nitems);
         }
 
         /*
          * Mark the page as not containing any LP_DEAD items --- see comments
          * in _bt_delitems_delete().
          */
         opaque = (BTPageOpaque) PageGetSpecialPointer(page);
         opaque->btpo_flags &= ~BTP_HAS_GARBAGE;
 
         PageSetLSN(page, lsn);
         MarkBufferDirty(buffer);
     }
     if (BufferIsValid(buffer))
         UnlockReleaseBuffer(buffer);
 }

static TransactionId btree_xlog_delete_get_latestRemovedXid ( XLogReaderState * record )

static

Definition at line 521 of file nbtxlog.c.

References Assert, BT_READ, BufferGetPage, BufferIsValid, CHECK_FOR_INTERRUPTS, CountDBBackends(), elog, HeapTupleHeaderAdvanceLatestRemovedXid(), xl_btree_delete::hnode, i, InvalidOid, InvalidTransactionId, ItemIdGetRedirect, ItemIdHasStorage, ItemIdIsDead, ItemIdIsRedirected, ItemIdIsUsed, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, LockBuffer(), MAIN_FORKNUM, xl_btree_delete::nitems, PageGetItem, PageGetItemId, PANIC, RBM_NORMAL, reachedConsistency, SizeOfBtreeDelete, IndexTupleData::t_tid, UnlockReleaseBuffer(), XLogReadBufferExtended(), XLogRecGetBlockTag(), and XLogRecGetData.

Referenced by btree_xlog_delete().

 {
     xl_btree_delete *xlrec = (xl_btree_delete *) XLogRecGetData(record);
     OffsetNumber *unused;
     Buffer      ibuffer,
                 hbuffer;
     Page        ipage,
                 hpage;
     RelFileNode rnode;
     BlockNumber blkno;
     ItemId      iitemid,
                 hitemid;
     IndexTuple  itup;
     HeapTupleHeader htuphdr;
     BlockNumber hblkno;
     OffsetNumber hoffnum;
     TransactionId latestRemovedXid = InvalidTransactionId;
     int         i;
 
     /*
      * If there's nothing running on the standby we don't need to derive a
      * full latestRemovedXid value, so use a fast path out of here.  This
      * returns InvalidTransactionId, and so will conflict with all HS
      * transactions; but since we just worked out that that's zero people,
      * it's OK.
      *
      * XXX There is a race condition here, which is that a new backend might
      * start just after we look.  If so, it cannot need to conflict, but this
      * coding will result in throwing a conflict anyway.
      */
     if (CountDBBackends(InvalidOid) == 0)
         return latestRemovedXid;
 
     /*
      * In what follows, we have to examine the previous state of the index
      * page, as well as the heap page(s) it points to.  This is only valid if
      * WAL replay has reached a consistent database state; which means that
      * the preceding check is not just an optimization, but is *necessary*. We
      * won't have let in any user sessions before we reach consistency.
      */
     if (!reachedConsistency)
         elog(PANIC, "btree_xlog_delete_get_latestRemovedXid: cannot operate with inconsistent data");
 
     /*
      * Get index page.  If the DB is consistent, this should not fail, nor
      * should any of the heap page fetches below.  If one does, we return
      * InvalidTransactionId to cancel all HS transactions.  That's probably
      * overkill, but it's safe, and certainly better than panicking here.
      */
     XLogRecGetBlockTag(record, 0, &rnode, NULL, &blkno);
     ibuffer = XLogReadBufferExtended(rnode, MAIN_FORKNUM, blkno, RBM_NORMAL);
     if (!BufferIsValid(ibuffer))
         return InvalidTransactionId;
     LockBuffer(ibuffer, BT_READ);
     ipage = (Page) BufferGetPage(ibuffer);
 
     /*
      * Loop through the deleted index items to obtain the TransactionId from
      * the heap items they point to.
      */
     unused = (OffsetNumber *) ((char *) xlrec + SizeOfBtreeDelete);
 
     for (i = 0; i < xlrec->nitems; i++)
     {
         /*
          * Identify the index tuple about to be deleted
          */
         iitemid = PageGetItemId(ipage, unused[i]);
         itup = (IndexTuple) PageGetItem(ipage, iitemid);
 
         /*
          * Locate the heap page that the index tuple points at
          */
         hblkno = ItemPointerGetBlockNumber(&(itup->t_tid));
         hbuffer = XLogReadBufferExtended(xlrec->hnode, MAIN_FORKNUM, hblkno, RBM_NORMAL);
         if (!BufferIsValid(hbuffer))
         {
             UnlockReleaseBuffer(ibuffer);
             return InvalidTransactionId;
         }
         LockBuffer(hbuffer, BT_READ);
         hpage = (Page) BufferGetPage(hbuffer);
 
         /*
          * Look up the heap tuple header that the index tuple points at by
          * using the heap node supplied with the xlrec. We can't use
          * heap_fetch, since it uses ReadBuffer rather than XLogReadBuffer.
          * Note that we are not looking at tuple data here, just headers.
          */
         hoffnum = ItemPointerGetOffsetNumber(&(itup->t_tid));
         hitemid = PageGetItemId(hpage, hoffnum);
 
         /*
          * Follow any redirections until we find something useful.
          */
         while (ItemIdIsRedirected(hitemid))
         {
             hoffnum = ItemIdGetRedirect(hitemid);
             hitemid = PageGetItemId(hpage, hoffnum);
             CHECK_FOR_INTERRUPTS();
         }
 
         /*
          * If the heap item has storage, then read the header and use that to
          * set latestRemovedXid.
          *
          * Some LP_DEAD items may not be accessible, so we ignore them.
          */
         if (ItemIdHasStorage(hitemid))
         {
             htuphdr = (HeapTupleHeader) PageGetItem(hpage, hitemid);
 
             HeapTupleHeaderAdvanceLatestRemovedXid(htuphdr, &latestRemovedXid);
         }
         else if (ItemIdIsDead(hitemid))
         {
             /*
              * Conjecture: if hitemid is dead then it had xids before the xids
              * marked on LP_NORMAL items. So we just ignore this item and move
              * onto the next, for the purposes of calculating
              * latestRemovedxids.
              */
         }
         else
             Assert(!ItemIdIsUsed(hitemid));
 
         UnlockReleaseBuffer(hbuffer);
     }
 
     UnlockReleaseBuffer(ibuffer);
 
     /*
      * If all heap tuples were LP_DEAD then we will be returning
      * InvalidTransactionId here, which avoids conflicts. This matches
      * existing logic which assumes that LP_DEAD tuples must already be older
      * than the latestRemovedXid on the cleanup record that set them as
      * LP_DEAD, hence must already have generated a conflict.
      */
     return latestRemovedXid;
 }

static void btree_xlog_insert	(	bool	isleaf,
		bool	ismeta,
		XLogReaderState *	record
	)

static

Definition at line 149 of file nbtxlog.c.

References _bt_clear_incomplete_split(), _bt_restore_meta(), BLK_NEEDS_REDO, buffer, BufferGetPage, BufferIsValid, elog, XLogReaderState::EndRecPtr, InvalidOffsetNumber, MarkBufferDirty(), xl_btree_insert::offnum, PageAddItem, PageSetLSN, PANIC, UnlockReleaseBuffer(), XLogReadBufferForRedo(), XLogRecGetBlockData(), and XLogRecGetData.

Referenced by btree_redo().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     xl_btree_insert *xlrec = (xl_btree_insert *) XLogRecGetData(record);
     Buffer      buffer;
     Page        page;
 
     /*
      * Insertion to an internal page finishes an incomplete split at the child
      * level.  Clear the incomplete-split flag in the child.  Note: during
      * normal operation, the child and parent pages are locked at the same
      * time, so that clearing the flag and inserting the downlink appear
      * atomic to other backends.  We don't bother with that during replay,
      * because readers don't care about the incomplete-split flag and there
      * cannot be updates happening.
      */
     if (!isleaf)
         _bt_clear_incomplete_split(record, 1);
     if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
     {
         Size        datalen;
         char       *datapos = XLogRecGetBlockData(record, 0, &datalen);
 
         page = BufferGetPage(buffer);
 
         if (PageAddItem(page, (Item) datapos, datalen, xlrec->offnum,
                         false, false) == InvalidOffsetNumber)
             elog(PANIC, "btree_insert_redo: failed to add item");
 
         PageSetLSN(page, lsn);
         MarkBufferDirty(buffer);
     }
     if (BufferIsValid(buffer))
         UnlockReleaseBuffer(buffer);
 
     /*
      * Note: in normal operation, we'd update the metapage while still holding
      * lock on the page we inserted into.  But during replay it's not
      * necessary to hold that lock, since no other index updates can be
      * happening concurrently, and readers will cope fine with following an
      * obsolete link from the metapage.
      */
     if (ismeta)
         _bt_restore_meta(record, 2);
 }

static void btree_xlog_mark_page_halfdead	(	uint8	info,
		XLogReaderState *	record
	)

static

Definition at line 724 of file nbtxlog.c.

References _bt_pageinit(), BLK_NEEDS_REDO, BTP_HALF_DEAD, BTP_LEAF, BTPageOpaqueData::btpo, BTPageOpaqueData::btpo_cycleid, BTPageOpaqueData::btpo_flags, BTPageOpaqueData::btpo_next, BTPageOpaqueData::btpo_prev, buffer, BufferGetPage, BufferGetPageSize, BufferIsValid, elog, XLogReaderState::EndRecPtr, ERROR, InvalidBlockNumber, InvalidOffsetNumber, ItemPointerGetBlockNumber, ItemPointerSet, ItemPointerSetInvalid, xl_btree_mark_page_halfdead::leftblk, BTPageOpaqueData::level, MarkBufferDirty(), MemSet, OffsetNumberNext, P_HIKEY, PageAddItem, PageGetItem, PageGetItemId, PageGetSpecialPointer, PageIndexTupleDelete(), PageSetLSN, xl_btree_mark_page_halfdead::poffset, xl_btree_mark_page_halfdead::rightblk, IndexTupleData::t_info, IndexTupleData::t_tid, xl_btree_mark_page_halfdead::topparent, UnlockReleaseBuffer(), XLogInitBufferForRedo(), XLogReadBufferForRedo(), and XLogRecGetData.

Referenced by btree_redo().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     xl_btree_mark_page_halfdead *xlrec = (xl_btree_mark_page_halfdead *) XLogRecGetData(record);
     Buffer      buffer;
     Page        page;
     BTPageOpaque pageop;
     IndexTupleData trunctuple;
 
     /*
      * In normal operation, we would lock all the pages this WAL record
      * touches before changing any of them.  In WAL replay, it should be okay
      * to lock just one page at a time, since no concurrent index updates can
      * be happening, and readers should not care whether they arrive at the
      * target page or not (since it's surely empty).
      */
 
     /* parent page */
     if (XLogReadBufferForRedo(record, 1, &buffer) == BLK_NEEDS_REDO)
     {
         OffsetNumber poffset;
         ItemId      itemid;
         IndexTuple  itup;
         OffsetNumber nextoffset;
         BlockNumber rightsib;
 
         page = (Page) BufferGetPage(buffer);
         pageop = (BTPageOpaque) PageGetSpecialPointer(page);
 
         poffset = xlrec->poffset;
 
         nextoffset = OffsetNumberNext(poffset);
         itemid = PageGetItemId(page, nextoffset);
         itup = (IndexTuple) PageGetItem(page, itemid);
         rightsib = ItemPointerGetBlockNumber(&itup->t_tid);
 
         itemid = PageGetItemId(page, poffset);
         itup = (IndexTuple) PageGetItem(page, itemid);
         ItemPointerSet(&(itup->t_tid), rightsib, P_HIKEY);
         nextoffset = OffsetNumberNext(poffset);
         PageIndexTupleDelete(page, nextoffset);
 
         PageSetLSN(page, lsn);
         MarkBufferDirty(buffer);
     }
     if (BufferIsValid(buffer))
         UnlockReleaseBuffer(buffer);
 
     /* Rewrite the leaf page as a halfdead page */
     buffer = XLogInitBufferForRedo(record, 0);
     page = (Page) BufferGetPage(buffer);
 
     _bt_pageinit(page, BufferGetPageSize(buffer));
     pageop = (BTPageOpaque) PageGetSpecialPointer(page);
 
     pageop->btpo_prev = xlrec->leftblk;
     pageop->btpo_next = xlrec->rightblk;
     pageop->btpo.level = 0;
     pageop->btpo_flags = BTP_HALF_DEAD | BTP_LEAF;
     pageop->btpo_cycleid = 0;
 
     /*
      * Construct a dummy hikey item that points to the next parent to be
      * deleted (if any).
      */
     MemSet(&trunctuple, 0, sizeof(IndexTupleData));
     trunctuple.t_info = sizeof(IndexTupleData);
     if (xlrec->topparent != InvalidBlockNumber)
         ItemPointerSet(&trunctuple.t_tid, xlrec->topparent, P_HIKEY);
     else
         ItemPointerSetInvalid(&trunctuple.t_tid);
     if (PageAddItem(page, (Item) &trunctuple, sizeof(IndexTupleData), P_HIKEY,
                     false, false) == InvalidOffsetNumber)
         elog(ERROR, "could not add dummy high key to half-dead page");
 
     PageSetLSN(page, lsn);
     MarkBufferDirty(buffer);
     UnlockReleaseBuffer(buffer);
 }

static void btree_xlog_newroot ( XLogReaderState * record )

static

Definition at line 920 of file nbtxlog.c.

References _bt_clear_incomplete_split(), _bt_pageinit(), _bt_restore_meta(), _bt_restore_page(), BTP_LEAF, BTP_ROOT, BTPageOpaqueData::btpo, BTPageOpaqueData::btpo_cycleid, BTPageOpaqueData::btpo_flags, BTPageOpaqueData::btpo_next, BTPageOpaqueData::btpo_prev, buffer, BufferGetPage, BufferGetPageSize, XLogReaderState::EndRecPtr, BTPageOpaqueData::level, xl_btree_newroot::level, MarkBufferDirty(), P_NONE, PageGetSpecialPointer, PageSetLSN, UnlockReleaseBuffer(), XLogInitBufferForRedo(), XLogRecGetBlockData(), and XLogRecGetData.

Referenced by btree_redo().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     xl_btree_newroot *xlrec = (xl_btree_newroot *) XLogRecGetData(record);
     Buffer      buffer;
     Page        page;
     BTPageOpaque pageop;
     char       *ptr;
     Size        len;
 
     buffer = XLogInitBufferForRedo(record, 0);
     page = (Page) BufferGetPage(buffer);
 
     _bt_pageinit(page, BufferGetPageSize(buffer));
     pageop = (BTPageOpaque) PageGetSpecialPointer(page);
 
     pageop->btpo_flags = BTP_ROOT;
     pageop->btpo_prev = pageop->btpo_next = P_NONE;
     pageop->btpo.level = xlrec->level;
     if (xlrec->level == 0)
         pageop->btpo_flags |= BTP_LEAF;
     pageop->btpo_cycleid = 0;
 
     if (xlrec->level > 0)
     {
         ptr = XLogRecGetBlockData(record, 0, &len);
         _bt_restore_page(page, ptr, len);
 
         /* Clear the incomplete-split flag in left child */
         _bt_clear_incomplete_split(record, 1);
     }
 
     PageSetLSN(page, lsn);
     MarkBufferDirty(buffer);
     UnlockReleaseBuffer(buffer);
 
     _bt_restore_meta(record, 2);
 }

static void btree_xlog_reuse_page ( XLogReaderState * record )

static

Definition at line 960 of file nbtxlog.c.

References InHotStandby, xl_btree_reuse_page::latestRemovedXid, xl_btree_reuse_page::node, ResolveRecoveryConflictWithSnapshot(), and XLogRecGetData.

Referenced by btree_redo().

 {
     xl_btree_reuse_page *xlrec = (xl_btree_reuse_page *) XLogRecGetData(record);
 
     /*
      * Btree reuse_page records exist to provide a conflict point when we
      * reuse pages in the index via the FSM.  That's all they do though.
      *
      * latestRemovedXid was the page's btpo.xact.  The btpo.xact <
      * RecentGlobalXmin test in _bt_page_recyclable() conceptually mirrors the
      * pgxact->xmin > limitXmin test in GetConflictingVirtualXIDs().
      * Consequently, one XID value achieves the same exclusion effect on
      * master and standby.
      */
     if (InHotStandby)
     {
         ResolveRecoveryConflictWithSnapshot(xlrec->latestRemovedXid,
                                             xlrec->node);
     }
 }

static void btree_xlog_split	(	bool	onleft,
		XLogReaderState *	record
	)

static

Definition at line 196 of file nbtxlog.c.

References _bt_clear_incomplete_split(), _bt_pageinit(), _bt_restore_page(), Assert, BLK_NEEDS_REDO, BTP_INCOMPLETE_SPLIT, BTP_LEAF, BTPageOpaqueData::btpo, BTPageOpaqueData::btpo_cycleid, BTPageOpaqueData::btpo_flags, BTPageOpaqueData::btpo_next, BTPageOpaqueData::btpo_prev, buffer, BufferGetPage, BufferGetPageSize, BufferIsValid, elog, XLogReaderState::EndRecPtr, ERROR, xl_btree_split::firstright, IndexTupleSize, InvalidOffsetNumber, ItemIdGetLength, BTPageOpaqueData::level, xl_btree_split::level, MarkBufferDirty(), MAXALIGN, xl_btree_split::newitemoff, OffsetNumberNext, P_FIRSTDATAKEY, P_HIKEY, P_NONE, PageAddItem, PageGetItem, PageGetItemId, PageGetSpecialPointer, PageGetTempPageCopySpecial(), PageRestoreTempPage(), PageSetLSN, PANIC, UnlockReleaseBuffer(), XLogInitBufferForRedo(), XLogReadBufferForRedo(), XLogRecGetBlockData(), XLogRecGetBlockTag(), and XLogRecGetData.

Referenced by btree_redo().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     xl_btree_split *xlrec = (xl_btree_split *) XLogRecGetData(record);
     bool        isleaf = (xlrec->level == 0);
     Buffer      lbuf;
     Buffer      rbuf;
     Page        rpage;
     BTPageOpaque ropaque;
     char       *datapos;
     Size        datalen;
     Item        left_hikey = NULL;
     Size        left_hikeysz = 0;
     BlockNumber leftsib;
     BlockNumber rightsib;
     BlockNumber rnext;
 
     XLogRecGetBlockTag(record, 0, NULL, NULL, &leftsib);
     XLogRecGetBlockTag(record, 1, NULL, NULL, &rightsib);
     if (!XLogRecGetBlockTag(record, 2, NULL, NULL, &rnext))
         rnext = P_NONE;
 
     /*
      * Clear the incomplete split flag on the left sibling of the child page
      * this is a downlink for.  (Like in btree_xlog_insert, this can be done
      * before locking the other pages)
      */
     if (!isleaf)
         _bt_clear_incomplete_split(record, 3);
 
     /* Reconstruct right (new) sibling page from scratch */
     rbuf = XLogInitBufferForRedo(record, 1);
     datapos = XLogRecGetBlockData(record, 1, &datalen);
     rpage = (Page) BufferGetPage(rbuf);
 
     _bt_pageinit(rpage, BufferGetPageSize(rbuf));
     ropaque = (BTPageOpaque) PageGetSpecialPointer(rpage);
 
     ropaque->btpo_prev = leftsib;
     ropaque->btpo_next = rnext;
     ropaque->btpo.level = xlrec->level;
     ropaque->btpo_flags = isleaf ? BTP_LEAF : 0;
     ropaque->btpo_cycleid = 0;
 
     _bt_restore_page(rpage, datapos, datalen);
 
     /*
      * On leaf level, the high key of the left page is equal to the first key
      * on the right page.
      */
     if (isleaf)
     {
         ItemId      hiItemId = PageGetItemId(rpage, P_FIRSTDATAKEY(ropaque));
 
         left_hikey = PageGetItem(rpage, hiItemId);
         left_hikeysz = ItemIdGetLength(hiItemId);
     }
 
     PageSetLSN(rpage, lsn);
     MarkBufferDirty(rbuf);
 
     /* don't release the buffer yet; we touch right page's first item below */
 
     /* Now reconstruct left (original) sibling page */
     if (XLogReadBufferForRedo(record, 0, &lbuf) == BLK_NEEDS_REDO)
     {
         /*
          * To retain the same physical order of the tuples that they had, we
          * initialize a temporary empty page for the left page and add all the
          * items to that in item number order.  This mirrors how _bt_split()
          * works.  It's not strictly required to retain the same physical
          * order, as long as the items are in the correct item number order,
          * but it helps debugging.  See also _bt_restore_page(), which does
          * the same for the right page.
          */
         Page        lpage = (Page) BufferGetPage(lbuf);
         BTPageOpaque lopaque = (BTPageOpaque) PageGetSpecialPointer(lpage);
         OffsetNumber off;
         Item        newitem = NULL;
         Size        newitemsz = 0;
         Page        newlpage;
         OffsetNumber leftoff;
 
         datapos = XLogRecGetBlockData(record, 0, &datalen);
 
         if (onleft)
         {
             newitem = (Item) datapos;
             newitemsz = MAXALIGN(IndexTupleSize(newitem));
             datapos += newitemsz;
             datalen -= newitemsz;
         }
 
         /* Extract left hikey and its size (assuming 16-bit alignment) */
         if (!isleaf)
         {
             left_hikey = (Item) datapos;
             left_hikeysz = MAXALIGN(IndexTupleSize(left_hikey));
             datapos += left_hikeysz;
             datalen -= left_hikeysz;
         }
         Assert(datalen == 0);
 
         newlpage = PageGetTempPageCopySpecial(lpage);
 
         /* Set high key */
         leftoff = P_HIKEY;
         if (PageAddItem(newlpage, left_hikey, left_hikeysz,
                         P_HIKEY, false, false) == InvalidOffsetNumber)
             elog(PANIC, "failed to add high key to left page after split");
         leftoff = OffsetNumberNext(leftoff);
 
         for (off = P_FIRSTDATAKEY(lopaque); off < xlrec->firstright; off++)
         {
             ItemId      itemid;
             Size        itemsz;
             Item        item;
 
             /* add the new item if it was inserted on left page */
             if (onleft && off == xlrec->newitemoff)
             {
                 if (PageAddItem(newlpage, newitem, newitemsz, leftoff,
                                 false, false) == InvalidOffsetNumber)
                     elog(ERROR, "failed to add new item to left page after split");
                 leftoff = OffsetNumberNext(leftoff);
             }
 
             itemid = PageGetItemId(lpage, off);
             itemsz = ItemIdGetLength(itemid);
             item = PageGetItem(lpage, itemid);
             if (PageAddItem(newlpage, item, itemsz, leftoff,
                             false, false) == InvalidOffsetNumber)
                 elog(ERROR, "failed to add old item to left page after split");
             leftoff = OffsetNumberNext(leftoff);
         }
 
         /* cope with possibility that newitem goes at the end */
         if (onleft && off == xlrec->newitemoff)
         {
             if (PageAddItem(newlpage, newitem, newitemsz, leftoff,
                             false, false) == InvalidOffsetNumber)
                 elog(ERROR, "failed to add new item to left page after split");
             leftoff = OffsetNumberNext(leftoff);
         }
 
         PageRestoreTempPage(newlpage, lpage);
 
         /* Fix opaque fields */
         lopaque->btpo_flags = BTP_INCOMPLETE_SPLIT;
         if (isleaf)
             lopaque->btpo_flags |= BTP_LEAF;
         lopaque->btpo_next = rightsib;
         lopaque->btpo_cycleid = 0;
 
         PageSetLSN(lpage, lsn);
         MarkBufferDirty(lbuf);
     }
 
     /* We no longer need the buffers */
     if (BufferIsValid(lbuf))
         UnlockReleaseBuffer(lbuf);
     UnlockReleaseBuffer(rbuf);
 
     /*
      * Fix left-link of the page to the right of the new right sibling.
      *
      * Note: in normal operation, we do this while still holding lock on the
      * two split pages.  However, that's not necessary for correctness in WAL
      * replay, because no other index update can be in progress, and readers
      * will cope properly when following an obsolete left-link.
      */
     if (rnext != P_NONE)
     {
         Buffer      buffer;
 
         if (XLogReadBufferForRedo(record, 2, &buffer) == BLK_NEEDS_REDO)
         {
             Page        page = (Page) BufferGetPage(buffer);
             BTPageOpaque pageop = (BTPageOpaque) PageGetSpecialPointer(page);
 
             pageop->btpo_prev = rightsib;
 
             PageSetLSN(page, lsn);
             MarkBufferDirty(buffer);
         }
         if (BufferIsValid(buffer))
             UnlockReleaseBuffer(buffer);
     }
 }

static void btree_xlog_unlink_page	(	uint8	info,
		XLogReaderState *	record
	)

static

Definition at line 806 of file nbtxlog.c.

References _bt_pageinit(), _bt_restore_meta(), BLK_NEEDS_REDO, BTP_DELETED, BTP_HALF_DEAD, BTP_LEAF, BTPageOpaqueData::btpo, BTPageOpaqueData::btpo_cycleid, BTPageOpaqueData::btpo_flags, BTPageOpaqueData::btpo_next, BTPageOpaqueData::btpo_prev, xl_btree_unlink_page::btpo_xact, buffer, BufferGetPage, BufferGetPageSize, BufferIsValid, elog, XLogReaderState::EndRecPtr, ERROR, InvalidBlockNumber, InvalidOffsetNumber, ItemPointerSet, ItemPointerSetInvalid, xl_btree_unlink_page::leafleftsib, xl_btree_unlink_page::leafrightsib, xl_btree_unlink_page::leftsib, BTPageOpaqueData::level, MarkBufferDirty(), MemSet, P_HIKEY, P_NONE, PageAddItem, PageGetSpecialPointer, PageSetLSN, xl_btree_unlink_page::rightsib, IndexTupleData::t_info, IndexTupleData::t_tid, xl_btree_unlink_page::topparent, UnlockReleaseBuffer(), BTPageOpaqueData::xact, XLOG_BTREE_UNLINK_PAGE_META, XLogInitBufferForRedo(), XLogReadBufferForRedo(), XLogRecGetData, and XLogRecHasBlockRef.

Referenced by btree_redo().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     xl_btree_unlink_page *xlrec = (xl_btree_unlink_page *) XLogRecGetData(record);
     BlockNumber leftsib;
     BlockNumber rightsib;
     Buffer      buffer;
     Page        page;
     BTPageOpaque pageop;
 
     leftsib = xlrec->leftsib;
     rightsib = xlrec->rightsib;
 
     /*
      * In normal operation, we would lock all the pages this WAL record
      * touches before changing any of them.  In WAL replay, it should be okay
      * to lock just one page at a time, since no concurrent index updates can
      * be happening, and readers should not care whether they arrive at the
      * target page or not (since it's surely empty).
      */
 
     /* Fix left-link of right sibling */
     if (XLogReadBufferForRedo(record, 2, &buffer) == BLK_NEEDS_REDO)
     {
         page = (Page) BufferGetPage(buffer);
         pageop = (BTPageOpaque) PageGetSpecialPointer(page);
         pageop->btpo_prev = leftsib;
 
         PageSetLSN(page, lsn);
         MarkBufferDirty(buffer);
     }
     if (BufferIsValid(buffer))
         UnlockReleaseBuffer(buffer);
 
     /* Fix right-link of left sibling, if any */
     if (leftsib != P_NONE)
     {
         if (XLogReadBufferForRedo(record, 1, &buffer) == BLK_NEEDS_REDO)
         {
             page = (Page) BufferGetPage(buffer);
             pageop = (BTPageOpaque) PageGetSpecialPointer(page);
             pageop->btpo_next = rightsib;
 
             PageSetLSN(page, lsn);
             MarkBufferDirty(buffer);
         }
         if (BufferIsValid(buffer))
             UnlockReleaseBuffer(buffer);
     }
 
     /* Rewrite target page as empty deleted page */
     buffer = XLogInitBufferForRedo(record, 0);
     page = (Page) BufferGetPage(buffer);
 
     _bt_pageinit(page, BufferGetPageSize(buffer));
     pageop = (BTPageOpaque) PageGetSpecialPointer(page);
 
     pageop->btpo_prev = leftsib;
     pageop->btpo_next = rightsib;
     pageop->btpo.xact = xlrec->btpo_xact;
     pageop->btpo_flags = BTP_DELETED;
     pageop->btpo_cycleid = 0;
 
     PageSetLSN(page, lsn);
     MarkBufferDirty(buffer);
     UnlockReleaseBuffer(buffer);
 
     /*
      * If we deleted a parent of the targeted leaf page, instead of the leaf
      * itself, update the leaf to point to the next remaining child in the
      * branch.
      */
     if (XLogRecHasBlockRef(record, 3))
     {
         /*
          * There is no real data on the page, so we just re-create it from
          * scratch using the information from the WAL record.
          */
         IndexTupleData trunctuple;
 
         buffer = XLogInitBufferForRedo(record, 3);
         page = (Page) BufferGetPage(buffer);
 
         _bt_pageinit(page, BufferGetPageSize(buffer));
         pageop = (BTPageOpaque) PageGetSpecialPointer(page);
 
         pageop->btpo_flags = BTP_HALF_DEAD | BTP_LEAF;
         pageop->btpo_prev = xlrec->leafleftsib;
         pageop->btpo_next = xlrec->leafrightsib;
         pageop->btpo.level = 0;
         pageop->btpo_cycleid = 0;
 
         /* Add a dummy hikey item */
         MemSet(&trunctuple, 0, sizeof(IndexTupleData));
         trunctuple.t_info = sizeof(IndexTupleData);
         if (xlrec->topparent != InvalidBlockNumber)
             ItemPointerSet(&trunctuple.t_tid, xlrec->topparent, P_HIKEY);
         else
             ItemPointerSetInvalid(&trunctuple.t_tid);
         if (PageAddItem(page, (Item) &trunctuple, sizeof(IndexTupleData), P_HIKEY,
                         false, false) == InvalidOffsetNumber)
             elog(ERROR, "could not add dummy high key to half-dead page");
 
         PageSetLSN(page, lsn);
         MarkBufferDirty(buffer);
         UnlockReleaseBuffer(buffer);
     }
 
     /* Update metapage if needed */
     if (info == XLOG_BTREE_UNLINK_PAGE_META)
         _bt_restore_meta(record, 4);
 }

static void btree_xlog_vacuum ( XLogReaderState * record )

static

Definition at line 387 of file nbtxlog.c.

References BLK_NEEDS_REDO, BlockNumberIsValid, BTP_HAS_GARBAGE, BTPageOpaqueData::btpo_flags, buffer, BufferGetPage, BufferIsValid, XLogReaderState::EndRecPtr, HotStandbyActiveInReplay(), xl_btree_vacuum::lastBlockVacuumed, LockBufferForCleanup(), MAIN_FORKNUM, MarkBufferDirty(), PageGetSpecialPointer, PageIndexMultiDelete(), PageSetLSN, RBM_NORMAL, RBM_NORMAL_NO_LOG, UnlockReleaseBuffer(), XLogReadBufferExtended(), XLogReadBufferForRedoExtended(), XLogRecGetBlockData(), XLogRecGetBlockTag(), and XLogRecGetData.

Referenced by btree_redo().

 {
     XLogRecPtr  lsn = record->EndRecPtr;
     Buffer      buffer;
     Page        page;
     BTPageOpaque opaque;
 #ifdef UNUSED
     xl_btree_vacuum *xlrec = (xl_btree_vacuum *) XLogRecGetData(record);
 
     /*
      * This section of code is thought to be no longer needed, after analysis
      * of the calling paths. It is retained to allow the code to be reinstated
      * if a flaw is revealed in that thinking.
      *
      * If we are running non-MVCC scans using this index we need to do some
      * additional work to ensure correctness, which is known as a "pin scan"
      * described in more detail in next paragraphs. We used to do the extra
      * work in all cases, whereas we now avoid that work in most cases. If
      * lastBlockVacuumed is set to InvalidBlockNumber then we skip the
      * additional work required for the pin scan.
      *
      * Avoiding this extra work is important since it requires us to touch
      * every page in the index, so is an O(N) operation. Worse, it is an
      * operation performed in the foreground during redo, so it delays
      * replication directly.
      *
      * If queries might be active then we need to ensure every leaf page is
      * unpinned between the lastBlockVacuumed and the current block, if there
      * are any.  This prevents replay of the VACUUM from reaching the stage of
      * removing heap tuples while there could still be indexscans "in flight"
      * to those particular tuples for those scans which could be confused by
      * finding new tuples at the old TID locations (see nbtree/README).
      *
      * It might be worth checking if there are actually any backends running;
      * if not, we could just skip this.
      *
      * Since VACUUM can visit leaf pages out-of-order, it might issue records
      * with lastBlockVacuumed >= block; that's not an error, it just means
      * nothing to do now.
      *
      * Note: since we touch all pages in the range, we will lock non-leaf
      * pages, and also any empty (all-zero) pages that may be in the index. It
      * doesn't seem worth the complexity to avoid that.  But it's important
      * that HotStandbyActiveInReplay() will not return true if the database
      * isn't yet consistent; so we need not fear reading still-corrupt blocks
      * here during crash recovery.
      */
     if (HotStandbyActiveInReplay() && BlockNumberIsValid(xlrec->lastBlockVacuumed))
     {
         RelFileNode thisrnode;
         BlockNumber thisblkno;
         BlockNumber blkno;
 
         XLogRecGetBlockTag(record, 0, &thisrnode, NULL, &thisblkno);
 
         for (blkno = xlrec->lastBlockVacuumed + 1; blkno < thisblkno; blkno++)
         {
             /*
              * We use RBM_NORMAL_NO_LOG mode because it's not an error
              * condition to see all-zero pages.  The original btvacuumpage
              * scan would have skipped over all-zero pages, noting them in FSM
              * but not bothering to initialize them just yet; so we mustn't
              * throw an error here.  (We could skip acquiring the cleanup lock
              * if PageIsNew, but it's probably not worth the cycles to test.)
              *
              * XXX we don't actually need to read the block, we just need to
              * confirm it is unpinned. If we had a special call into the
              * buffer manager we could optimise this so that if the block is
              * not in shared_buffers we confirm it as unpinned. Optimizing
              * this is now moot, since in most cases we avoid the scan.
              */
             buffer = XLogReadBufferExtended(thisrnode, MAIN_FORKNUM, blkno,
                                             RBM_NORMAL_NO_LOG);
             if (BufferIsValid(buffer))
             {
                 LockBufferForCleanup(buffer);
                 UnlockReleaseBuffer(buffer);
             }
         }
     }
 #endif
 
     /*
      * Like in btvacuumpage(), we need to take a cleanup lock on every leaf
      * page. See nbtree/README for details.
      */
     if (XLogReadBufferForRedoExtended(record, 0, RBM_NORMAL, true, &buffer)
         == BLK_NEEDS_REDO)
     {
         char       *ptr;
         Size        len;
 
         ptr = XLogRecGetBlockData(record, 0, &len);
 
         page = (Page) BufferGetPage(buffer);
 
         if (len > 0)
         {
             OffsetNumber *unused;
             OffsetNumber *unend;
 
             unused = (OffsetNumber *) ptr;
             unend = (OffsetNumber *) ((char *) ptr + len);
 
             if ((unend - unused) > 0)
                 PageIndexMultiDelete(page, unused, unend - unused);
         }
 
         /*
          * Mark the page as not containing any LP_DEAD items --- see comments
          * in _bt_delitems_vacuum().
          */
         opaque = (BTPageOpaque) PageGetSpecialPointer(page);
         opaque->btpo_flags &= ~BTP_HAS_GARBAGE;
 
         PageSetLSN(page, lsn);
         MarkBufferDirty(buffer);
     }
     if (BufferIsValid(buffer))
         UnlockReleaseBuffer(buffer);
 }

Functions

Function Documentation