/*-------------------------------------------------------------------------

 *

 * ginxlog.c

 *    WAL replay logic for inverted index.

 *

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 * IDENTIFICATION

 *       src/backend/access/gin/ginxlog.c

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/bufmask.h"

#include "access/gin_private.h"

#include "access/ginxlog.h"

#include "access/xlogutils.h"

#include "utils/memutils.h"

static MemoryContext opCtx;   /* working memory for operations */

static void

ginRedoClearIncompleteSplit(XLogReaderState *record, uint8 block_id)

{

  XLogRecPtr  lsn = record->EndRecPtr;

  Buffer    buffer;

  Page    page;

  if (XLogReadBufferForRedo(record, block_id, &buffer) == BLK_NEEDS_REDO)

  {

    page = BufferGetPage(buffer);

    GinPageGetOpaque(page)->flags &= ~GIN_INCOMPLETE_SPLIT;

    PageSetLSN(page, lsn);

    MarkBufferDirty(buffer);

  }

  if (BufferIsValid(buffer))

    UnlockReleaseBuffer(buffer);

}

static void

ginRedoCreatePTree(XLogReaderState *record)

{

  XLogRecPtr  lsn = record->EndRecPtr;

  ginxlogCreatePostingTree *data = (ginxlogCreatePostingTree *) XLogRecGetData(record);

  char     *ptr;

  Buffer    buffer;

  Page    page;

  buffer = XLogInitBufferForRedo(record, 0);

  page = BufferGetPage(buffer);

  GinInitBuffer(buffer, GIN_DATA | GIN_LEAF | GIN_COMPRESSED);

  ptr = XLogRecGetData(record) + sizeof(ginxlogCreatePostingTree);

  /* Place page data */

  memcpy(GinDataLeafPageGetPostingList(page), ptr, data->size);

  GinDataPageSetDataSize(page, data->size);

  PageSetLSN(page, lsn);

  MarkBufferDirty(buffer);

  UnlockReleaseBuffer(buffer);

}

static void

ginRedoInsertEntry(Buffer buffer, bool isLeaf, BlockNumber rightblkno, void *rdata)

{

  Page    page = BufferGetPage(buffer);

  ginxlogInsertEntry *data = (ginxlogInsertEntry *) rdata;

  OffsetNumber offset = data->offset;

  IndexTuple  itup;

  if (rightblkno != InvalidBlockNumber)

  {

    /* update link to right page after split */

    Assert(!GinPageIsLeaf(page));

    Assert(offset >= FirstOffsetNumber && offset <= PageGetMaxOffsetNumber(page));

    itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offset));

    GinSetDownlink(itup, rightblkno);

  }

  if (data->isDelete)

  {

    Assert(GinPageIsLeaf(page));

    Assert(offset >= FirstOffsetNumber && offset <= PageGetMaxOffsetNumber(page));

    PageIndexTupleDelete(page, offset);

  }

  itup = &data->tuple;

  if (PageAddItem(page, itup, IndexTupleSize(itup), offset, false, false) == InvalidOffsetNumber)

  {

    RelFileLocator locator;

    ForkNumber  forknum;

    BlockNumber blknum;

    BufferGetTag(buffer, &locator, &forknum, &blknum);

    elog(ERROR, "failed to add item to index page in %u/%u/%u",

       locator.spcOid, locator.dbOid, locator.relNumber);

  }

}

/*

 * Redo recompression of posting list.  Doing all the changes in-place is not

 * always possible, because it might require more space than we've on the page.

 * Instead, once modification is required we copy unprocessed tail of the page

 * into separately allocated chunk of memory for further reading original

 * versions of segments.  Thanks to that we don't bother about moving page data

 * in-place.

 */

static void

ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)

{

  int     actionno;

  int     segno;

  GinPostingList *oldseg;

  char     *segmentend;

  char     *walbuf;

  int     totalsize;

  void     *tailCopy = NULL;

  char     *writePtr;

  char     *segptr;

  /*

   * If the page is in pre-9.4 format, convert to new format first.

   */

  if (!GinPageIsCompressed(page))

  {

    ItemPointer uncompressed = (ItemPointer) GinDataPageGetData(page);

    int     nuncompressed = GinPageGetOpaque(page)->maxoff;

    int     npacked;

    /*

     * Empty leaf pages are deleted as part of vacuum, but leftmost and

     * rightmost pages are never deleted.  So, pg_upgrade'd from pre-9.4

     * instances might contain empty leaf pages, and we need to handle

     * them correctly.

     */

    if (nuncompressed > 0)

    {

      GinPostingList *plist;

      plist = ginCompressPostingList(uncompressed, nuncompressed,

                       BLCKSZ, &npacked);

      totalsize = SizeOfGinPostingList(plist);

      Assert(npacked == nuncompressed);

      memcpy(GinDataLeafPageGetPostingList(page), plist, totalsize);

    }

    else

    {

      totalsize = 0;

    }

    GinDataPageSetDataSize(page, totalsize);

    GinPageSetCompressed(page);

    GinPageGetOpaque(page)->maxoff = InvalidOffsetNumber;

  }

  oldseg = GinDataLeafPageGetPostingList(page);

  writePtr = (char *) oldseg;

  segmentend = (char *) oldseg + GinDataLeafPageGetPostingListSize(page);

  segno = 0;

  walbuf = ((char *) data) + sizeof(ginxlogRecompressDataLeaf);

  for (actionno = 0; actionno < data->nactions; actionno++)

  {

    uint8   a_segno = *((uint8 *) (walbuf++));

    uint8   a_action = *((uint8 *) (walbuf++));

    GinPostingList *newseg = NULL;

    int     newsegsize = 0;

    ItemPointerData *items = NULL;

    uint16    nitems = 0;

    ItemPointerData *olditems;

    int     nolditems;

    ItemPointerData *newitems;

    int     nnewitems;

    int     segsize;

    /* Extract all the information we need from the WAL record */

    if (a_action == GIN_SEGMENT_INSERT ||

      a_action == GIN_SEGMENT_REPLACE)

    {

      newseg = (GinPostingList *) walbuf;

      newsegsize = SizeOfGinPostingList(newseg);

      walbuf += SHORTALIGN(newsegsize);

    }

    if (a_action == GIN_SEGMENT_ADDITEMS)

    {

      memcpy(&nitems, walbuf, sizeof(uint16));

      walbuf += sizeof(uint16);

      items = (ItemPointerData *) walbuf;

      walbuf += nitems * sizeof(ItemPointerData);

    }

    /* Skip to the segment that this action concerns */

    Assert(segno <= a_segno);

    while (segno < a_segno)

    {

      /*

       * Once modification is started and page tail is copied, we've to

       * copy unmodified segments.

       */

      segsize = SizeOfGinPostingList(oldseg);

      if (tailCopy)

      {

        Assert(writePtr + segsize < PageGetSpecialPointer(page));

        memcpy(writePtr, oldseg, segsize);

      }

      writePtr += segsize;

      oldseg = GinNextPostingListSegment(oldseg);

      segno++;

    }

    /*

     * ADDITEMS action is handled like REPLACE, but the new segment to

     * replace the old one is reconstructed using the old segment from

     * disk and the new items from the WAL record.

     */

    if (a_action == GIN_SEGMENT_ADDITEMS)

    {

      int     npacked;

      olditems = ginPostingListDecode(oldseg, &nolditems);

      newitems = ginMergeItemPointers(items, nitems,

                      olditems, nolditems,

                      &nnewitems);

      Assert(nnewitems == nolditems + nitems);

      newseg = ginCompressPostingList(newitems, nnewitems,

                      BLCKSZ, &npacked);

      Assert(npacked == nnewitems);

      newsegsize = SizeOfGinPostingList(newseg);

      a_action = GIN_SEGMENT_REPLACE;

    }

    segptr = (char *) oldseg;

    if (segptr != segmentend)

      segsize = SizeOfGinPostingList(oldseg);

    else

    {

      /*

       * Positioned after the last existing segment. Only INSERTs

       * expected here.

       */

      Assert(a_action == GIN_SEGMENT_INSERT);

      segsize = 0;

    }

    /*

     * We're about to start modification of the page.  So, copy tail of

     * the page if it's not done already.

     */

    if (!tailCopy && segptr != segmentend)

    {

      int     tailSize = segmentend - segptr;

      tailCopy = palloc(tailSize);

      memcpy(tailCopy, segptr, tailSize);

      segptr = tailCopy;

      oldseg = (GinPostingList *) segptr;

      segmentend = segptr + tailSize;

    }

    switch (a_action)

    {

      case GIN_SEGMENT_DELETE:

        segptr += segsize;

        segno++;

        break;

      case GIN_SEGMENT_INSERT:

        /* copy the new segment in place */

        Assert(writePtr + newsegsize <= PageGetSpecialPointer(page));

        memcpy(writePtr, newseg, newsegsize);

        writePtr += newsegsize;

        break;

      case GIN_SEGMENT_REPLACE:

        /* copy the new version of segment in place */

        Assert(writePtr + newsegsize <= PageGetSpecialPointer(page));

        memcpy(writePtr, newseg, newsegsize);

        writePtr += newsegsize;

        segptr += segsize;

        segno++;

        break;

      default:

        elog(ERROR, "unexpected GIN leaf action: %u", a_action);

    }

    oldseg = (GinPostingList *) segptr;

  }

  /* Copy the rest of unmodified segments if any. */

  segptr = (char *) oldseg;

  if (segptr != segmentend && tailCopy)

  {

    int     restSize = segmentend - segptr;

    Assert(writePtr + restSize <= PageGetSpecialPointer(page));

    memcpy(writePtr, segptr, restSize);

    writePtr += restSize;

  }

  totalsize = writePtr - (char *) GinDataLeafPageGetPostingList(page);

  GinDataPageSetDataSize(page, totalsize);

}

static void

ginRedoInsertData(Buffer buffer, bool isLeaf, BlockNumber rightblkno, void *rdata)

{

  Page    page = BufferGetPage(buffer);

  if (isLeaf)

  {

    ginxlogRecompressDataLeaf *data = (ginxlogRecompressDataLeaf *) rdata;

    Assert(GinPageIsLeaf(page));

    ginRedoRecompress(page, data);

  }

  else

  {

    ginxlogInsertDataInternal *data = (ginxlogInsertDataInternal *) rdata;

    PostingItem *oldpitem;

    Assert(!GinPageIsLeaf(page));

    /* update link to right page after split */

    oldpitem = GinDataPageGetPostingItem(page, data->offset);

    PostingItemSetBlockNumber(oldpitem, rightblkno);

    GinDataPageAddPostingItem(page, &data->newitem, data->offset);

  }

}

static void

ginRedoInsert(XLogReaderState *record)

{

  XLogRecPtr  lsn = record->EndRecPtr;

  ginxlogInsert *data = (ginxlogInsert *) XLogRecGetData(record);

  Buffer    buffer;

#ifdef NOT_USED

  BlockNumber leftChildBlkno = InvalidBlockNumber;

#endif

  BlockNumber rightChildBlkno = InvalidBlockNumber;

  bool    isLeaf = (data->flags & GIN_INSERT_ISLEAF) != 0;

  /*

   * First clear incomplete-split flag on child page if this finishes a

   * split.

   */

  if (!isLeaf)

  {

    char     *payload = XLogRecGetData(record) + sizeof(ginxlogInsert);

#ifdef NOT_USED

    leftChildBlkno = BlockIdGetBlockNumber((BlockId) payload);

#endif

    payload += sizeof(BlockIdData);

    rightChildBlkno = BlockIdGetBlockNumber((BlockId) payload);

    ginRedoClearIncompleteSplit(record, 1);

  }

  if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)

  {

    Page    page = BufferGetPage(buffer);

    Size    len;

    char     *payload = XLogRecGetBlockData(record, 0, &len);

    /* How to insert the payload is tree-type specific */

    if (data->flags & GIN_INSERT_ISDATA)

    {

      Assert(GinPageIsData(page));

      ginRedoInsertData(buffer, isLeaf, rightChildBlkno, payload);

    }

    else

    {

      Assert(!GinPageIsData(page));

      ginRedoInsertEntry(buffer, isLeaf, rightChildBlkno, payload);

    }

    PageSetLSN(page, lsn);

    MarkBufferDirty(buffer);

  }

  if (BufferIsValid(buffer))

    UnlockReleaseBuffer(buffer);

}

static void

ginRedoSplit(XLogReaderState *record)

{

  ginxlogSplit *data = (ginxlogSplit *) XLogRecGetData(record);

  Buffer    lbuffer,

        rbuffer,

        rootbuf;

  bool    isLeaf = (data->flags & GIN_INSERT_ISLEAF) != 0;

  bool    isRoot = (data->flags & GIN_SPLIT_ROOT) != 0;

  /*

   * First clear incomplete-split flag on child page if this finishes a

   * split

   */

  if (!isLeaf)

    ginRedoClearIncompleteSplit(record, 3);

  if (XLogReadBufferForRedo(record, 0, &lbuffer) != BLK_RESTORED)

    elog(ERROR, "GIN split record did not contain a full-page image of left page");

  if (XLogReadBufferForRedo(record, 1, &rbuffer) != BLK_RESTORED)

    elog(ERROR, "GIN split record did not contain a full-page image of right page");

  if (isRoot)

  {

    if (XLogReadBufferForRedo(record, 2, &rootbuf) != BLK_RESTORED)

      elog(ERROR, "GIN split record did not contain a full-page image of root page");

    UnlockReleaseBuffer(rootbuf);

  }

  UnlockReleaseBuffer(rbuffer);

  UnlockReleaseBuffer(lbuffer);

}

/*

 * VACUUM_PAGE record contains simply a full image of the page, similar to

 * an XLOG_FPI record.

 */

static void

ginRedoVacuumPage(XLogReaderState *record)

{

  Buffer    buffer;

  if (XLogReadBufferForRedo(record, 0, &buffer) != BLK_RESTORED)

  {

    elog(ERROR, "replay of gin entry tree page vacuum did not restore the page");

  }

  UnlockReleaseBuffer(buffer);

}

static void

ginRedoVacuumDataLeafPage(XLogReaderState *record)

{

  XLogRecPtr  lsn = record->EndRecPtr;

  Buffer    buffer;

  if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)

  {

    Page    page = BufferGetPage(buffer);

    Size    len;

    ginxlogVacuumDataLeafPage *xlrec;

    xlrec = (ginxlogVacuumDataLeafPage *) XLogRecGetBlockData(record, 0, &len);

    Assert(GinPageIsLeaf(page));

    Assert(GinPageIsData(page));

    ginRedoRecompress(page, &xlrec->data);

    PageSetLSN(page, lsn);

    MarkBufferDirty(buffer);

  }

  if (BufferIsValid(buffer))

    UnlockReleaseBuffer(buffer);

}

static void

ginRedoDeletePage(XLogReaderState *record)

{

  XLogRecPtr  lsn = record->EndRecPtr;

  ginxlogDeletePage *data = (ginxlogDeletePage *) XLogRecGetData(record);

  Buffer    dbuffer;

  Buffer    pbuffer;

  Buffer    lbuffer;

  Page    page;

  /*

   * Lock left page first in order to prevent possible deadlock with

   * ginStepRight().

   */

  if (XLogReadBufferForRedo(record, 2, &lbuffer) == BLK_NEEDS_REDO)

  {

    page = BufferGetPage(lbuffer);

    Assert(GinPageIsData(page));

    GinPageGetOpaque(page)->rightlink = data->rightLink;

    PageSetLSN(page, lsn);

    MarkBufferDirty(lbuffer);

  }

  if (XLogReadBufferForRedo(record, 0, &dbuffer) == BLK_NEEDS_REDO)

  {

    page = BufferGetPage(dbuffer);

    Assert(GinPageIsData(page));

    GinPageSetDeleted(page);

    GinPageSetDeleteXid(page, data->deleteXid);

    PageSetLSN(page, lsn);

    MarkBufferDirty(dbuffer);

  }

  if (XLogReadBufferForRedo(record, 1, &pbuffer) == BLK_NEEDS_REDO)

  {

    page = BufferGetPage(pbuffer);

    Assert(GinPageIsData(page));

    Assert(!GinPageIsLeaf(page));

    GinPageDeletePostingItem(page, data->parentOffset);

    PageSetLSN(page, lsn);

    MarkBufferDirty(pbuffer);

  }

  if (BufferIsValid(lbuffer))

    UnlockReleaseBuffer(lbuffer);

  if (BufferIsValid(pbuffer))

    UnlockReleaseBuffer(pbuffer);

  if (BufferIsValid(dbuffer))

    UnlockReleaseBuffer(dbuffer);

}

static void

ginRedoUpdateMetapage(XLogReaderState *record)

{

  XLogRecPtr  lsn = record->EndRecPtr;

  ginxlogUpdateMeta *data = (ginxlogUpdateMeta *) XLogRecGetData(record);

  Buffer    metabuffer;

  Page    metapage;

  Buffer    buffer;

  /*

   * Restore the metapage. This is essentially the same as a full-page

   * image, so restore the metapage unconditionally without looking at the

   * LSN, to avoid torn page hazards.

   */

  metabuffer = XLogInitBufferForRedo(record, 0);

  Assert(BufferGetBlockNumber(metabuffer) == GIN_METAPAGE_BLKNO);

  metapage = BufferGetPage(metabuffer);

  GinInitMetabuffer(metabuffer);

  memcpy(GinPageGetMeta(metapage), &data->metadata, sizeof(GinMetaPageData));

  PageSetLSN(metapage, lsn);

  MarkBufferDirty(metabuffer);

  if (data->ntuples > 0)

  {

    /*

     * insert into tail page

     */

    if (XLogReadBufferForRedo(record, 1, &buffer) == BLK_NEEDS_REDO)

    {

      Page    page = BufferGetPage(buffer);

      OffsetNumber off;

      int     i;

      Size    tupsize;

      char     *payload;

      IndexTuple  tuples;

      Size    totaltupsize;

      payload = XLogRecGetBlockData(record, 1, &totaltupsize);

      tuples = (IndexTuple) payload;

      if (PageIsEmpty(page))

        off = FirstOffsetNumber;

      else

        off = OffsetNumberNext(PageGetMaxOffsetNumber(page));

      for (i = 0; i < data->ntuples; i++)

      {

        tupsize = IndexTupleSize(tuples);

        if (PageAddItem(page, tuples, tupsize, off, false, false) == InvalidOffsetNumber)

          elog(ERROR, "failed to add item to index page");

        tuples = (IndexTuple) (((char *) tuples) + tupsize);

        off++;

      }

      Assert(payload + totaltupsize == (char *) tuples);

      /*

       * Increase counter of heap tuples

       */

      GinPageGetOpaque(page)->maxoff++;

      PageSetLSN(page, lsn);

      MarkBufferDirty(buffer);

    }

    if (BufferIsValid(buffer))

      UnlockReleaseBuffer(buffer);

  }

  else if (data->prevTail != InvalidBlockNumber)

  {

    /*

     * New tail

     */

    if (XLogReadBufferForRedo(record, 1, &buffer) == BLK_NEEDS_REDO)

    {

      Page    page = BufferGetPage(buffer);

      GinPageGetOpaque(page)->rightlink = data->newRightlink;

      PageSetLSN(page, lsn);

      MarkBufferDirty(buffer);

    }

    if (BufferIsValid(buffer))

      UnlockReleaseBuffer(buffer);

  }

  UnlockReleaseBuffer(metabuffer);

}

static void

ginRedoInsertListPage(XLogReaderState *record)

{

  XLogRecPtr  lsn = record->EndRecPtr;

  ginxlogInsertListPage *data = (ginxlogInsertListPage *) XLogRecGetData(record);

  Buffer    buffer;

  Page    page;

  OffsetNumber l,

        off = FirstOffsetNumber;

  int     i,

        tupsize;

  char     *payload;

  IndexTuple  tuples;

  Size    totaltupsize;

  /* We always re-initialize the page. */

  buffer = XLogInitBufferForRedo(record, 0);

  page = BufferGetPage(buffer);

  GinInitBuffer(buffer, GIN_LIST);

  GinPageGetOpaque(page)->rightlink = data->rightlink;

  if (data->rightlink == InvalidBlockNumber)

  {

    /* tail of sublist */

    GinPageSetFullRow(page);

    GinPageGetOpaque(page)->maxoff = 1;

  }

  else

  {

    GinPageGetOpaque(page)->maxoff = 0;

  }

  payload = XLogRecGetBlockData(record, 0, &totaltupsize);

  tuples = (IndexTuple) payload;

  for (i = 0; i < data->ntuples; i++)

  {

    tupsize = IndexTupleSize(tuples);

    l = PageAddItem(page, tuples, tupsize, off, false, false);

    if (l == InvalidOffsetNumber)

      elog(ERROR, "failed to add item to index page");

    tuples = (IndexTuple) (((char *) tuples) + tupsize);

    off++;

  }

  Assert((char *) tuples == payload + totaltupsize);

  PageSetLSN(page, lsn);

  MarkBufferDirty(buffer);

  UnlockReleaseBuffer(buffer);

}

static void

ginRedoDeleteListPages(XLogReaderState *record)

{

  XLogRecPtr  lsn = record->EndRecPtr;

  ginxlogDeleteListPages *data = (ginxlogDeleteListPages *) XLogRecGetData(record);

  Buffer    metabuffer;

  Page    metapage;

  int     i;

  metabuffer = XLogInitBufferForRedo(record, 0);

  Assert(BufferGetBlockNumber(metabuffer) == GIN_METAPAGE_BLKNO);

  metapage = BufferGetPage(metabuffer);

  GinInitMetabuffer(metabuffer);

  memcpy(GinPageGetMeta(metapage), &data->metadata, sizeof(GinMetaPageData));

  PageSetLSN(metapage, lsn);

  MarkBufferDirty(metabuffer);

  /*

   * In normal operation, shiftList() takes exclusive lock on all the

   * pages-to-be-deleted simultaneously.  During replay, however, it should

   * be all right to lock them one at a time.  This is dependent on the fact

   * that we are deleting pages from the head of the list, and that readers

   * share-lock the next page before releasing the one they are on. So we

   * cannot get past a reader that is on, or due to visit, any page we are

   * going to delete.  New incoming readers will block behind our metapage

   * lock and then see a fully updated page list.

   *

   * No full-page images are taken of the deleted pages. Instead, they are

   * re-initialized as empty, deleted pages. Their right-links don't need to

   * be preserved, because no new readers can see the pages, as explained

   * above.

   */

  for (i = 0; i < data->ndeleted; i++)

  {

    Buffer    buffer;

    Page    page;

    buffer = XLogInitBufferForRedo(record, i + 1);

    page = BufferGetPage(buffer);

    GinInitBuffer(buffer, GIN_DELETED);

    PageSetLSN(page, lsn);

    MarkBufferDirty(buffer);

    UnlockReleaseBuffer(buffer);

  }

  UnlockReleaseBuffer(metabuffer);

}

void

gin_redo(XLogReaderState *record)

{

  uint8   info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;

  MemoryContext oldCtx;

  /*

   * GIN indexes do not require any conflict processing. NB: If we ever

   * implement a similar optimization as we have in b-tree, and remove

   * killed tuples outside VACUUM, we'll need to handle that here.

   */

  oldCtx = MemoryContextSwitchTo(opCtx);

  switch (info)

  {

    case XLOG_GIN_CREATE_PTREE:

      ginRedoCreatePTree(record);

      break;

    case XLOG_GIN_INSERT:

      ginRedoInsert(record);

      break;

    case XLOG_GIN_SPLIT:

      ginRedoSplit(record);

      break;

    case XLOG_GIN_VACUUM_PAGE:

      ginRedoVacuumPage(record);

      break;

    case XLOG_GIN_VACUUM_DATA_LEAF_PAGE:

      ginRedoVacuumDataLeafPage(record);

      break;

    case XLOG_GIN_DELETE_PAGE:

      ginRedoDeletePage(record);

      break;

    case XLOG_GIN_UPDATE_META_PAGE:

      ginRedoUpdateMetapage(record);

      break;

    case XLOG_GIN_INSERT_LISTPAGE:

      ginRedoInsertListPage(record);

      break;

    case XLOG_GIN_DELETE_LISTPAGE:

      ginRedoDeleteListPages(record);

      break;

    default:

      elog(PANIC, "gin_redo: unknown op code %u", info);

  }

  MemoryContextSwitchTo(oldCtx);

  MemoryContextReset(opCtx);

}

void

gin_xlog_startup(void)

{

  opCtx = AllocSetContextCreate(CurrentMemoryContext,

                  "GIN recovery temporary context",

                  ALLOCSET_DEFAULT_SIZES);

}

void

gin_xlog_cleanup(void)

{

  MemoryContextDelete(opCtx);

  opCtx = NULL;

}

/*

 * Mask a GIN page before running consistency checks on it.

 */

void

gin_mask(char *pagedata, BlockNumber blkno)

{

  Page    page = (Page) pagedata;

  PageHeader  pagehdr = (PageHeader) page;

  GinPageOpaque opaque;

  mask_page_lsn_and_checksum(page);

  opaque = GinPageGetOpaque(page);

  mask_page_hint_bits(page);

  /*

   * For a GIN_DELETED page, the page is initialized to empty.  Hence, mask

   * the whole page content.  For other pages, mask the hole if pd_lower

   * appears to have been set correctly.

   */

  if (opaque->flags & GIN_DELETED)

    mask_page_content(page);

  else if (pagehdr->pd_lower > SizeOfPageHeaderData)

    mask_unused_space(page);

}