/*-------------------------------------------------------------------------
 *
 * ginxlog.c
 *   WAL replay logic for inverted index.
 *
 *
 * Portions Copyright (c) 1996-2025, 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 = (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 = (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, (Item) 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;
 Pointer  segmentend;
 char    *walbuf;
 int   totalsize;
 Pointer  tailCopy = NULL;
 Pointer  writePtr;
 Pointer  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 = (Pointer) oldseg;
 segmentend = (Pointer) 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, (Pointer) 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 = (Pointer) 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 = (Pointer) 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 = (Pointer) oldseg;
 if (segptr != segmentend && tailCopy)
 {
  int   restSize = segmentend - segptr;

  Assert(writePtr + restSize <= PageGetSpecialPointer(page));
  memcpy(writePtr, segptr, restSize);
  writePtr += restSize;
 }

 totalsize = writePtr - (Pointer) 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);
  payload += sizeof(BlockIdData);

  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, (Item) 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, (Item) 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);
}