LCOV - differential code coverage report
Current view: top level - src/backend/access/nbtree - nbtxlog.c (source / functions) Coverage Total Hit UBC CBC
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 94.3 % 505 476 29 476
Current Date: 2024-04-14 14:21:10 Functions: 94.1 % 17 16 1 16
Baseline: 16@8cea358b128 Branches: 64.2 % 243 156 87 156
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (240..) days: 94.3 % 505 476 29 476
Function coverage date bins:
(240..) days: 94.1 % 17 16 1 16
Branch coverage date bins:
(240..) days: 64.2 % 243 156 87 156

 Age         Owner                    Branch data    TLA  Line data    Source code
                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * nbtxlog.c
                                  4                 :                :  *    WAL replay logic for btrees.
                                  5                 :                :  *
                                  6                 :                :  *
                                  7                 :                :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
                                  8                 :                :  * Portions Copyright (c) 1994, Regents of the University of California
                                  9                 :                :  *
                                 10                 :                :  * IDENTIFICATION
                                 11                 :                :  *    src/backend/access/nbtree/nbtxlog.c
                                 12                 :                :  *
                                 13                 :                :  *-------------------------------------------------------------------------
                                 14                 :                :  */
                                 15                 :                : #include "postgres.h"
                                 16                 :                : 
                                 17                 :                : #include "access/bufmask.h"
                                 18                 :                : #include "access/nbtree.h"
                                 19                 :                : #include "access/nbtxlog.h"
                                 20                 :                : #include "access/transam.h"
                                 21                 :                : #include "access/xlogutils.h"
                                 22                 :                : #include "storage/standby.h"
                                 23                 :                : #include "utils/memutils.h"
                                 24                 :                : 
                                 25                 :                : static MemoryContext opCtx;     /* working memory for operations */
                                 26                 :                : 
                                 27                 :                : /*
                                 28                 :                :  * _bt_restore_page -- re-enter all the index tuples on a page
                                 29                 :                :  *
                                 30                 :                :  * The page is freshly init'd, and *from (length len) is a copy of what
                                 31                 :                :  * had been its upper part (pd_upper to pd_special).  We assume that the
                                 32                 :                :  * tuples had been added to the page in item-number order, and therefore
                                 33                 :                :  * the one with highest item number appears first (lowest on the page).
                                 34                 :                :  */
                                 35                 :                : static void
 7723 tgl@sss.pgh.pa.us          36                 :CBC        1537 : _bt_restore_page(Page page, char *from, int len)
                                 37                 :                : {
                                 38                 :                :     IndexTupleData itupdata;
                                 39                 :                :     Size        itemsz;
                                 40                 :           1537 :     char       *end = from + len;
                                 41                 :                :     Item        items[MaxIndexTuplesPerPage];
                                 42                 :                :     uint16      itemsizes[MaxIndexTuplesPerPage];
                                 43                 :                :     int         i;
                                 44                 :                :     int         nitems;
                                 45                 :                : 
                                 46                 :                :     /*
                                 47                 :                :      * To get the items back in the original order, we add them to the page in
                                 48                 :                :      * reverse.  To figure out where one tuple ends and another begins, we
                                 49                 :                :      * have to scan them in forward order first.
                                 50                 :                :      */
 3645 heikki.linnakangas@i       51                 :           1537 :     i = 0;
                                 52         [ +  + ]:          99499 :     while (from < end)
                                 53                 :                :     {
                                 54                 :                :         /*
                                 55                 :                :          * As we step through the items, 'from' won't always be properly
                                 56                 :                :          * aligned, so we need to use memcpy().  Further, we use Item (which
                                 57                 :                :          * is just a char*) here for our items array for the same reason;
                                 58                 :                :          * wouldn't want the compiler or anyone thinking that an item is
                                 59                 :                :          * aligned when it isn't.
                                 60                 :                :          */
 6654 tgl@sss.pgh.pa.us          61                 :          97962 :         memcpy(&itupdata, from, sizeof(IndexTupleData));
 2237                            62                 :          97962 :         itemsz = IndexTupleSize(&itupdata);
 7723                            63                 :          97962 :         itemsz = MAXALIGN(itemsz);
                                 64                 :                : 
 3645 heikki.linnakangas@i       65                 :          97962 :         items[i] = (Item) from;
                                 66                 :          97962 :         itemsizes[i] = itemsz;
                                 67                 :          97962 :         i++;
                                 68                 :                : 
                                 69                 :          97962 :         from += itemsz;
                                 70                 :                :     }
                                 71                 :           1537 :     nitems = i;
                                 72                 :                : 
                                 73         [ +  + ]:          99499 :     for (i = nitems - 1; i >= 0; i--)
                                 74                 :                :     {
                                 75         [ -  + ]:          97962 :         if (PageAddItem(page, items[i], itemsizes[i], nitems - i,
                                 76                 :                :                         false, false) == InvalidOffsetNumber)
 6282 bruce@momjian.us           77         [ #  # ]:UBC           0 :             elog(PANIC, "_bt_restore_page: cannot add item to page");
                                 78                 :                :     }
 7723 tgl@sss.pgh.pa.us          79                 :CBC        1537 : }
                                 80                 :                : 
                                 81                 :                : static void
 3433 heikki.linnakangas@i       82                 :            694 : _bt_restore_meta(XLogReaderState *record, uint8 block_id)
                                 83                 :                : {
                                 84                 :            694 :     XLogRecPtr  lsn = record->EndRecPtr;
                                 85                 :                :     Buffer      metabuf;
                                 86                 :                :     Page        metapg;
                                 87                 :                :     BTMetaPageData *md;
                                 88                 :                :     BTPageOpaque pageop;
                                 89                 :                :     xl_btree_metadata *xlrec;
                                 90                 :                :     char       *ptr;
                                 91                 :                :     Size        len;
                                 92                 :                : 
                                 93                 :            694 :     metabuf = XLogInitBufferForRedo(record, block_id);
                                 94                 :            694 :     ptr = XLogRecGetBlockData(record, block_id, &len);
                                 95                 :                : 
                                 96         [ -  + ]:            694 :     Assert(len == sizeof(xl_btree_metadata));
                                 97         [ -  + ]:            694 :     Assert(BufferGetBlockNumber(metabuf) == BTREE_METAPAGE);
                                 98                 :            694 :     xlrec = (xl_btree_metadata *) ptr;
 2916 kgrittn@postgresql.o       99                 :            694 :     metapg = BufferGetPage(metabuf);
                                100                 :                : 
 7723 tgl@sss.pgh.pa.us         101                 :            694 :     _bt_pageinit(metapg, BufferGetPageSize(metabuf));
                                102                 :                : 
                                103                 :            694 :     md = BTPageGetMeta(metapg);
 7256                           104                 :            694 :     md->btm_magic = BTREE_MAGIC;
 1852 pg@bowt.ie                105                 :            694 :     md->btm_version = xlrec->version;
 3433 heikki.linnakangas@i      106                 :            694 :     md->btm_root = xlrec->root;
                                107                 :            694 :     md->btm_level = xlrec->level;
                                108                 :            694 :     md->btm_fastroot = xlrec->fastroot;
                                109                 :            694 :     md->btm_fastlevel = xlrec->fastlevel;
                                110                 :                :     /* Cannot log BTREE_MIN_VERSION index metapage without upgrade */
 1732 pg@bowt.ie                111         [ -  + ]:            694 :     Assert(md->btm_version >= BTREE_NOVAC_VERSION);
 1145                           112                 :            694 :     md->btm_last_cleanup_num_delpages = xlrec->last_cleanup_num_delpages;
 1131                           113                 :            694 :     md->btm_last_cleanup_num_heap_tuples = -1.0;
 1509                           114                 :            694 :     md->btm_allequalimage = xlrec->allequalimage;
                                115                 :                : 
  744 michael@paquier.xyz       116                 :            694 :     pageop = BTPageGetOpaque(metapg);
 7723 tgl@sss.pgh.pa.us         117                 :            694 :     pageop->btpo_flags = BTP_META;
                                118                 :                : 
                                119                 :                :     /*
                                120                 :                :      * Set pd_lower just past the end of the metadata.  This is essential,
                                121                 :                :      * because without doing so, metadata will be lost if xlog.c compresses
                                122                 :                :      * the page.
                                123                 :                :      */
 6891                           124                 :            694 :     ((PageHeader) metapg)->pd_lower =
                                125                 :            694 :         ((char *) md + sizeof(BTMetaPageData)) - (char *) metapg;
                                126                 :                : 
 7723                           127                 :            694 :     PageSetLSN(metapg, lsn);
 6589                           128                 :            694 :     MarkBufferDirty(metabuf);
                                129                 :            694 :     UnlockReleaseBuffer(metabuf);
 7723                           130                 :            694 : }
                                131                 :                : 
                                132                 :                : /*
                                133                 :                :  * _bt_clear_incomplete_split -- clear INCOMPLETE_SPLIT flag on a page
                                134                 :                :  *
                                135                 :                :  * This is a common subroutine of the redo functions of all the WAL record
                                136                 :                :  * types that can insert a downlink: insert, split, and newroot.
                                137                 :                :  */
                                138                 :                : static void
 3433 heikki.linnakangas@i      139                 :           1487 : _bt_clear_incomplete_split(XLogReaderState *record, uint8 block_id)
                                140                 :                : {
                                141                 :           1487 :     XLogRecPtr  lsn = record->EndRecPtr;
                                142                 :                :     Buffer      buf;
                                143                 :                : 
                                144         [ +  - ]:           1487 :     if (XLogReadBufferForRedo(record, block_id, &buf) == BLK_NEEDS_REDO)
                                145                 :                :     {
 2916 kgrittn@postgresql.o      146                 :           1487 :         Page        page = (Page) BufferGetPage(buf);
  744 michael@paquier.xyz       147                 :           1487 :         BTPageOpaque pageop = BTPageGetOpaque(page);
                                148                 :                : 
 2400 tgl@sss.pgh.pa.us         149         [ -  + ]:           1487 :         Assert(P_INCOMPLETE_SPLIT(pageop));
 3532 heikki.linnakangas@i      150                 :           1487 :         pageop->btpo_flags &= ~BTP_INCOMPLETE_SPLIT;
                                151                 :                : 
                                152                 :           1487 :         PageSetLSN(page, lsn);
                                153                 :           1487 :         MarkBufferDirty(buf);
                                154                 :                :     }
                                155         [ +  - ]:           1487 :     if (BufferIsValid(buf))
                                156                 :           1487 :         UnlockReleaseBuffer(buf);
 3680                           157                 :           1487 : }
                                158                 :                : 
                                159                 :                : static void
 1509 pg@bowt.ie                160                 :         502487 : btree_xlog_insert(bool isleaf, bool ismeta, bool posting,
                                161                 :                :                   XLogReaderState *record)
                                162                 :                : {
 3433 heikki.linnakangas@i      163                 :         502487 :     XLogRecPtr  lsn = record->EndRecPtr;
 7723 tgl@sss.pgh.pa.us         164                 :         502487 :     xl_btree_insert *xlrec = (xl_btree_insert *) XLogRecGetData(record);
                                165                 :                :     Buffer      buffer;
                                166                 :                :     Page        page;
                                167                 :                : 
                                168                 :                :     /*
                                169                 :                :      * Insertion to an internal page finishes an incomplete split at the child
                                170                 :                :      * level.  Clear the incomplete-split flag in the child.  Note: during
                                171                 :                :      * normal operation, the child and parent pages are locked at the same
                                172                 :                :      * time (the locks are coupled), so that clearing the flag and inserting
                                173                 :                :      * the downlink appear atomic to other backends.  We don't bother with
                                174                 :                :      * that during replay, because readers don't care about the
                                175                 :                :      * incomplete-split flag and there cannot be updates happening.
                                176                 :                :      */
 3680 heikki.linnakangas@i      177         [ +  + ]:         502487 :     if (!isleaf)
 3433                           178                 :           1386 :         _bt_clear_incomplete_split(record, 1);
                                179         [ +  + ]:         502487 :     if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
                                180                 :                :     {
                                181                 :                :         Size        datalen;
                                182                 :         499593 :         char       *datapos = XLogRecGetBlockData(record, 0, &datalen);
                                183                 :                : 
 2916 kgrittn@postgresql.o      184                 :         499593 :         page = BufferGetPage(buffer);
                                185                 :                : 
 1509 pg@bowt.ie                186         [ +  + ]:         499593 :         if (!posting)
                                187                 :                :         {
                                188                 :                :             /* Simple retail insertion */
                                189         [ -  + ]:         495895 :             if (PageAddItem(page, (Item) datapos, datalen, xlrec->offnum,
                                190                 :                :                             false, false) == InvalidOffsetNumber)
 1509 pg@bowt.ie                191         [ #  # ]:UBC           0 :                 elog(PANIC, "failed to add new item");
                                192                 :                :         }
                                193                 :                :         else
                                194                 :                :         {
                                195                 :                :             ItemId      itemid;
                                196                 :                :             IndexTuple  oposting,
                                197                 :                :                         newitem,
                                198                 :                :                         nposting;
                                199                 :                :             uint16      postingoff;
                                200                 :                : 
                                201                 :                :             /*
                                202                 :                :              * A posting list split occurred during leaf page insertion.  WAL
                                203                 :                :              * record data will start with an offset number representing the
                                204                 :                :              * point in an existing posting list that a split occurs at.
                                205                 :                :              *
                                206                 :                :              * Use _bt_swap_posting() to repeat posting list split steps from
                                207                 :                :              * primary.  Note that newitem from WAL record is 'orignewitem',
                                208                 :                :              * not the final version of newitem that is actually inserted on
                                209                 :                :              * page.
                                210                 :                :              */
 1509 pg@bowt.ie                211                 :CBC        3698 :             postingoff = *((uint16 *) datapos);
                                212                 :           3698 :             datapos += sizeof(uint16);
                                213                 :           3698 :             datalen -= sizeof(uint16);
                                214                 :                : 
                                215                 :           3698 :             itemid = PageGetItemId(page, OffsetNumberPrev(xlrec->offnum));
                                216                 :           3698 :             oposting = (IndexTuple) PageGetItem(page, itemid);
                                217                 :                : 
                                218                 :                :             /* Use mutable, aligned newitem copy in _bt_swap_posting() */
                                219   [ +  -  -  + ]:           3698 :             Assert(isleaf && postingoff > 0);
                                220                 :           3698 :             newitem = CopyIndexTuple((IndexTuple) datapos);
                                221                 :           3698 :             nposting = _bt_swap_posting(newitem, oposting, postingoff);
                                222                 :                : 
                                223                 :                :             /* Replace existing posting list with post-split version */
                                224                 :           3698 :             memcpy(oposting, nposting, MAXALIGN(IndexTupleSize(nposting)));
                                225                 :                : 
                                226                 :                :             /* Insert "final" new item (not orignewitem from WAL stream) */
                                227         [ -  + ]:           3698 :             Assert(IndexTupleSize(newitem) == datalen);
                                228         [ -  + ]:           3698 :             if (PageAddItem(page, (Item) newitem, datalen, xlrec->offnum,
                                229                 :                :                             false, false) == InvalidOffsetNumber)
 1509 pg@bowt.ie                230         [ #  # ]:UBC           0 :                 elog(PANIC, "failed to add posting split new item");
                                231                 :                :         }
                                232                 :                : 
 3532 heikki.linnakangas@i      233                 :CBC      499593 :         PageSetLSN(page, lsn);
                                234                 :         499593 :         MarkBufferDirty(buffer);
                                235                 :                :     }
                                236         [ +  - ]:         502487 :     if (BufferIsValid(buffer))
                                237                 :         502487 :         UnlockReleaseBuffer(buffer);
                                238                 :                : 
                                239                 :                :     /*
                                240                 :                :      * Note: in normal operation, we'd update the metapage while still holding
                                241                 :                :      * lock on the page we inserted into.  But during replay it's not
                                242                 :                :      * necessary to hold that lock, since no other index updates can be
                                243                 :                :      * happening concurrently, and readers will cope fine with following an
                                244                 :                :      * obsolete link from the metapage.
                                245                 :                :      */
 6887 tgl@sss.pgh.pa.us         246         [ +  + ]:         502487 :     if (ismeta)
 3433 heikki.linnakangas@i      247                 :              4 :         _bt_restore_meta(record, 2);
 7723 tgl@sss.pgh.pa.us         248                 :         502487 : }
                                249                 :                : 
                                250                 :                : static void
 1462 pg@bowt.ie                251                 :           1487 : btree_xlog_split(bool newitemonleft, XLogReaderState *record)
                                252                 :                : {
 3433 heikki.linnakangas@i      253                 :           1487 :     XLogRecPtr  lsn = record->EndRecPtr;
 7723 tgl@sss.pgh.pa.us         254                 :           1487 :     xl_btree_split *xlrec = (xl_btree_split *) XLogRecGetData(record);
 3680 heikki.linnakangas@i      255                 :           1487 :     bool        isleaf = (xlrec->level == 0);
                                256                 :                :     Buffer      buf;
                                257                 :                :     Buffer      rbuf;
                                258                 :                :     Page        rpage;
                                259                 :                :     BTPageOpaque ropaque;
                                260                 :                :     char       *datapos;
                                261                 :                :     Size        datalen;
                                262                 :                :     BlockNumber origpagenumber;
                                263                 :                :     BlockNumber rightpagenumber;
                                264                 :                :     BlockNumber spagenumber;
                                265                 :                : 
 1346 pg@bowt.ie                266                 :           1487 :     XLogRecGetBlockTag(record, 0, NULL, NULL, &origpagenumber);
                                267                 :           1487 :     XLogRecGetBlockTag(record, 1, NULL, NULL, &rightpagenumber);
  734 tgl@sss.pgh.pa.us         268         [ +  + ]:           1487 :     if (!XLogRecGetBlockTagExtended(record, 2, NULL, NULL, &spagenumber, NULL))
 1346 pg@bowt.ie                269                 :            921 :         spagenumber = P_NONE;
                                270                 :                : 
                                271                 :                :     /*
                                272                 :                :      * Clear the incomplete split flag on the appropriate child page one level
                                273                 :                :      * down when origpage/buf is an internal page (there must have been
                                274                 :                :      * cascading page splits during original execution in the event of an
                                275                 :                :      * internal page split).  This is like the corresponding btree_xlog_insert
                                276                 :                :      * call for internal pages.  We're not clearing the incomplete split flag
                                277                 :                :      * for the current page split here (you can think of this as part of the
                                278                 :                :      * insert of newitem that the page split action needs to perform in
                                279                 :                :      * passing).
                                280                 :                :      *
                                281                 :                :      * Like in btree_xlog_insert, this can be done before locking other pages.
                                282                 :                :      * We never need to couple cross-level locks in REDO routines.
                                283                 :                :      */
 3680 heikki.linnakangas@i      284         [ +  + ]:           1487 :     if (!isleaf)
 3433                           285                 :             51 :         _bt_clear_incomplete_split(record, 3);
                                286                 :                : 
                                287                 :                :     /* Reconstruct right (new) sibling page from scratch */
                                288                 :           1487 :     rbuf = XLogInitBufferForRedo(record, 1);
                                289                 :           1487 :     datapos = XLogRecGetBlockData(record, 1, &datalen);
 2916 kgrittn@postgresql.o      290                 :           1487 :     rpage = (Page) BufferGetPage(rbuf);
                                291                 :                : 
 6275 bruce@momjian.us          292                 :           1487 :     _bt_pageinit(rpage, BufferGetPageSize(rbuf));
  744 michael@paquier.xyz       293                 :           1487 :     ropaque = BTPageGetOpaque(rpage);
                                294                 :                : 
 1346 pg@bowt.ie                295                 :           1487 :     ropaque->btpo_prev = origpagenumber;
                                296                 :           1487 :     ropaque->btpo_next = spagenumber;
 1145                           297                 :           1487 :     ropaque->btpo_level = xlrec->level;
 3680 heikki.linnakangas@i      298                 :           1487 :     ropaque->btpo_flags = isleaf ? BTP_LEAF : 0;
 6275 bruce@momjian.us          299                 :           1487 :     ropaque->btpo_cycleid = 0;
                                300                 :                : 
                                301                 :           1487 :     _bt_restore_page(rpage, datapos, datalen);
                                302                 :                : 
                                303                 :           1487 :     PageSetLSN(rpage, lsn);
                                304                 :           1487 :     MarkBufferDirty(rbuf);
                                305                 :                : 
                                306                 :                :     /* Now reconstruct original page (left half of split) */
 1346 pg@bowt.ie                307         [ +  + ]:           1487 :     if (XLogReadBufferForRedo(record, 0, &buf) == BLK_NEEDS_REDO)
                                308                 :                :     {
                                309                 :                :         /*
                                310                 :                :          * To retain the same physical order of the tuples that they had, we
                                311                 :                :          * initialize a temporary empty page for the left page and add all the
                                312                 :                :          * items to that in item number order.  This mirrors how _bt_split()
                                313                 :                :          * works.  Retaining the same physical order makes WAL consistency
                                314                 :                :          * checking possible.  See also _bt_restore_page(), which does the
                                315                 :                :          * same for the right page.
                                316                 :                :          */
                                317                 :           1466 :         Page        origpage = (Page) BufferGetPage(buf);
  744 michael@paquier.xyz       318                 :           1466 :         BTPageOpaque oopaque = BTPageGetOpaque(origpage);
                                319                 :                :         OffsetNumber off;
 1852 pg@bowt.ie                320                 :           1466 :         IndexTuple  newitem = NULL,
 1509                           321                 :           1466 :                     left_hikey = NULL,
                                322                 :           1466 :                     nposting = NULL;
 1852                           323                 :           1466 :         Size        newitemsz = 0,
                                324                 :           1466 :                     left_hikeysz = 0;
                                325                 :                :         Page        leftpage;
                                326                 :                :         OffsetNumber leftoff,
 1509                           327                 :           1466 :                     replacepostingoff = InvalidOffsetNumber;
                                328                 :                : 
 3433 heikki.linnakangas@i      329                 :           1466 :         datapos = XLogRecGetBlockData(record, 0, &datalen);
                                330                 :                : 
 1462 pg@bowt.ie                331   [ +  +  -  + ]:           1466 :         if (newitemonleft || xlrec->postingoff != 0)
                                332                 :                :         {
 2237 tgl@sss.pgh.pa.us         333                 :            167 :             newitem = (IndexTuple) datapos;
 3433 heikki.linnakangas@i      334                 :            167 :             newitemsz = MAXALIGN(IndexTupleSize(newitem));
                                335                 :            167 :             datapos += newitemsz;
                                336                 :            167 :             datalen -= newitemsz;
                                337                 :                : 
 1509 pg@bowt.ie                338         [ +  + ]:            167 :             if (xlrec->postingoff != 0)
                                339                 :                :             {
                                340                 :                :                 ItemId      itemid;
                                341                 :                :                 IndexTuple  oposting;
                                342                 :                : 
                                343                 :                :                 /* Posting list must be at offset number before new item's */
                                344                 :              6 :                 replacepostingoff = OffsetNumberPrev(xlrec->newitemoff);
                                345                 :                : 
                                346                 :                :                 /* Use mutable, aligned newitem copy in _bt_swap_posting() */
                                347                 :              6 :                 newitem = CopyIndexTuple(newitem);
 1346                           348                 :              6 :                 itemid = PageGetItemId(origpage, replacepostingoff);
                                349                 :              6 :                 oposting = (IndexTuple) PageGetItem(origpage, itemid);
 1509                           350                 :              6 :                 nposting = _bt_swap_posting(newitem, oposting,
                                351                 :              6 :                                             xlrec->postingoff);
                                352                 :                :             }
                                353                 :                :         }
                                354                 :                : 
                                355                 :                :         /*
                                356                 :                :          * Extract left hikey and its size.  We assume that 16-bit alignment
                                357                 :                :          * is enough to apply IndexTupleSize (since it's fetching from a
                                358                 :                :          * uint16 field).
                                359                 :                :          */
 1852                           360                 :           1466 :         left_hikey = (IndexTuple) datapos;
                                361                 :           1466 :         left_hikeysz = MAXALIGN(IndexTupleSize(left_hikey));
                                362                 :           1466 :         datapos += left_hikeysz;
                                363                 :           1466 :         datalen -= left_hikeysz;
                                364                 :                : 
 3433 heikki.linnakangas@i      365         [ -  + ]:           1466 :         Assert(datalen == 0);
                                366                 :                : 
 1346 pg@bowt.ie                367                 :           1466 :         leftpage = PageGetTempPageCopySpecial(origpage);
                                368                 :                : 
                                369                 :                :         /* Add high key tuple from WAL record to temp page */
 3532 heikki.linnakangas@i      370                 :           1466 :         leftoff = P_HIKEY;
 1346 pg@bowt.ie                371         [ -  + ]:           1466 :         if (PageAddItem(leftpage, (Item) left_hikey, left_hikeysz, P_HIKEY,
                                372                 :                :                         false, false) == InvalidOffsetNumber)
 1346 pg@bowt.ie                373         [ #  # ]:UBC           0 :             elog(ERROR, "failed to add high key to left page after split");
 3532 heikki.linnakangas@i      374                 :CBC        1466 :         leftoff = OffsetNumberNext(leftoff);
                                375                 :                : 
 1346 pg@bowt.ie                376   [ +  +  +  + ]:         328814 :         for (off = P_FIRSTDATAKEY(oopaque); off < xlrec->firstrightoff; off++)
                                377                 :                :         {
                                378                 :                :             ItemId      itemid;
                                379                 :                :             Size        itemsz;
                                380                 :                :             IndexTuple  item;
                                381                 :                : 
                                382                 :                :             /* Add replacement posting list when required */
 1509                           383         [ +  + ]:         327348 :             if (off == replacepostingoff)
                                384                 :                :             {
 1462                           385   [ -  +  -  - ]:              6 :                 Assert(newitemonleft ||
                                386                 :                :                        xlrec->firstrightoff == xlrec->newitemoff);
 1346                           387         [ -  + ]:              6 :                 if (PageAddItem(leftpage, (Item) nposting,
                                388                 :                :                                 MAXALIGN(IndexTupleSize(nposting)), leftoff,
                                389                 :                :                                 false, false) == InvalidOffsetNumber)
 1509 pg@bowt.ie                390         [ #  # ]:UBC           0 :                     elog(ERROR, "failed to add new posting list item to left page after split");
 1509 pg@bowt.ie                391                 :CBC           6 :                 leftoff = OffsetNumberNext(leftoff);
                                392                 :              6 :                 continue;       /* don't insert oposting */
                                393                 :                :             }
                                394                 :                : 
                                395                 :                :             /* add the new item if it was inserted on left page */
 1462                           396   [ +  +  +  + ]:         327342 :             else if (newitemonleft && off == xlrec->newitemoff)
                                397                 :                :             {
 1346                           398         [ -  + ]:            148 :                 if (PageAddItem(leftpage, (Item) newitem, newitemsz, leftoff,
                                399                 :                :                                 false, false) == InvalidOffsetNumber)
 3532 heikki.linnakangas@i      400         [ #  # ]:UBC           0 :                     elog(ERROR, "failed to add new item to left page after split");
 3645 heikki.linnakangas@i      401                 :CBC         148 :                 leftoff = OffsetNumberNext(leftoff);
                                402                 :                :             }
                                403                 :                : 
 1346 pg@bowt.ie                404                 :         327342 :             itemid = PageGetItemId(origpage, off);
 3532 heikki.linnakangas@i      405                 :         327342 :             itemsz = ItemIdGetLength(itemid);
 1346 pg@bowt.ie                406                 :         327342 :             item = (IndexTuple) PageGetItem(origpage, itemid);
                                407         [ -  + ]:         327342 :             if (PageAddItem(leftpage, (Item) item, itemsz, leftoff,
                                408                 :                :                             false, false) == InvalidOffsetNumber)
 3532 heikki.linnakangas@i      409         [ #  # ]:UBC           0 :                 elog(ERROR, "failed to add old item to left page after split");
 3532 heikki.linnakangas@i      410                 :CBC      327342 :             leftoff = OffsetNumberNext(leftoff);
                                411                 :                :         }
                                412                 :                : 
                                413                 :                :         /* cope with possibility that newitem goes at the end */
 1462 pg@bowt.ie                414   [ +  +  +  + ]:           1466 :         if (newitemonleft && off == xlrec->newitemoff)
                                415                 :                :         {
 1346                           416         [ -  + ]:             19 :             if (PageAddItem(leftpage, (Item) newitem, newitemsz, leftoff,
                                417                 :                :                             false, false) == InvalidOffsetNumber)
 3532 heikki.linnakangas@i      418         [ #  # ]:UBC           0 :                 elog(ERROR, "failed to add new item to left page after split");
 3532 heikki.linnakangas@i      419                 :CBC          19 :             leftoff = OffsetNumberNext(leftoff);
                                420                 :                :         }
                                421                 :                : 
 1346 pg@bowt.ie                422                 :           1466 :         PageRestoreTempPage(leftpage, origpage);
                                423                 :                : 
                                424                 :                :         /* Fix opaque fields */
                                425                 :           1466 :         oopaque->btpo_flags = BTP_INCOMPLETE_SPLIT;
 3532 heikki.linnakangas@i      426         [ +  + ]:           1466 :         if (isleaf)
 1346 pg@bowt.ie                427                 :           1415 :             oopaque->btpo_flags |= BTP_LEAF;
                                428                 :           1466 :         oopaque->btpo_next = rightpagenumber;
                                429                 :           1466 :         oopaque->btpo_cycleid = 0;
                                430                 :                : 
                                431                 :           1466 :         PageSetLSN(origpage, lsn);
                                432                 :           1466 :         MarkBufferDirty(buf);
                                433                 :                :     }
                                434                 :                : 
                                435                 :                :     /* Fix left-link of the page to the right of the new right sibling */
                                436         [ +  + ]:           1487 :     if (spagenumber != P_NONE)
                                437                 :                :     {
                                438                 :                :         Buffer      sbuf;
                                439                 :                : 
                                440         [ +  + ]:            566 :         if (XLogReadBufferForRedo(record, 2, &sbuf) == BLK_NEEDS_REDO)
                                441                 :                :         {
                                442                 :            519 :             Page        spage = (Page) BufferGetPage(sbuf);
  744 michael@paquier.xyz       443                 :            519 :             BTPageOpaque spageop = BTPageGetOpaque(spage);
                                444                 :                : 
 1346 pg@bowt.ie                445                 :            519 :             spageop->btpo_prev = rightpagenumber;
                                446                 :                : 
                                447                 :            519 :             PageSetLSN(spage, lsn);
                                448                 :            519 :             MarkBufferDirty(sbuf);
                                449                 :                :         }
                                450         [ +  - ]:            566 :         if (BufferIsValid(sbuf))
                                451                 :            566 :             UnlockReleaseBuffer(sbuf);
                                452                 :                :     }
                                453                 :                : 
                                454                 :                :     /*
                                455                 :                :      * Finally, release the remaining buffers.  sbuf, rbuf, and buf must be
                                456                 :                :      * released together, so that readers cannot observe inconsistencies.
                                457                 :                :      */
                                458                 :           1487 :     UnlockReleaseBuffer(rbuf);
                                459         [ +  - ]:           1487 :     if (BufferIsValid(buf))
                                460                 :           1487 :         UnlockReleaseBuffer(buf);
 7723 tgl@sss.pgh.pa.us         461                 :           1487 : }
                                462                 :                : 
                                463                 :                : static void
 1509 pg@bowt.ie                464                 :           2138 : btree_xlog_dedup(XLogReaderState *record)
                                465                 :                : {
                                466                 :           2138 :     XLogRecPtr  lsn = record->EndRecPtr;
                                467                 :           2138 :     xl_btree_dedup *xlrec = (xl_btree_dedup *) XLogRecGetData(record);
                                468                 :                :     Buffer      buf;
                                469                 :                : 
                                470         [ +  + ]:           2138 :     if (XLogReadBufferForRedo(record, 0, &buf) == BLK_NEEDS_REDO)
                                471                 :                :     {
                                472                 :           2133 :         char       *ptr = XLogRecGetBlockData(record, 0, NULL);
                                473                 :           2133 :         Page        page = (Page) BufferGetPage(buf);
  744 michael@paquier.xyz       474                 :           2133 :         BTPageOpaque opaque = BTPageGetOpaque(page);
                                475                 :                :         OffsetNumber offnum,
                                476                 :                :                     minoff,
                                477                 :                :                     maxoff;
                                478                 :                :         BTDedupState state;
                                479                 :                :         BTDedupInterval *intervals;
                                480                 :                :         Page        newpage;
                                481                 :                : 
 1509 pg@bowt.ie                482                 :           2133 :         state = (BTDedupState) palloc(sizeof(BTDedupStateData));
                                483                 :           2133 :         state->deduplicate = true;   /* unused */
 1395                           484                 :           2133 :         state->nmaxitems = 0;    /* unused */
                                485                 :                :         /* Conservatively use larger maxpostingsize than primary */
 1509                           486                 :           2133 :         state->maxpostingsize = BTMaxItemSize(page);
                                487                 :           2133 :         state->base = NULL;
                                488                 :           2133 :         state->baseoff = InvalidOffsetNumber;
                                489                 :           2133 :         state->basetupsize = 0;
                                490                 :           2133 :         state->htids = palloc(state->maxpostingsize);
                                491                 :           2133 :         state->nhtids = 0;
                                492                 :           2133 :         state->nitems = 0;
                                493                 :           2133 :         state->phystupsize = 0;
                                494                 :           2133 :         state->nintervals = 0;
                                495                 :                : 
                                496         [ +  + ]:           2133 :         minoff = P_FIRSTDATAKEY(opaque);
                                497                 :           2133 :         maxoff = PageGetMaxOffsetNumber(page);
                                498                 :           2133 :         newpage = PageGetTempPageCopySpecial(page);
                                499                 :                : 
                                500         [ +  + ]:           2133 :         if (!P_RIGHTMOST(opaque))
                                501                 :                :         {
                                502                 :           1834 :             ItemId      itemid = PageGetItemId(page, P_HIKEY);
                                503                 :           1834 :             Size        itemsz = ItemIdGetLength(itemid);
                                504                 :           1834 :             IndexTuple  item = (IndexTuple) PageGetItem(page, itemid);
                                505                 :                : 
                                506         [ -  + ]:           1834 :             if (PageAddItem(newpage, (Item) item, itemsz, P_HIKEY,
                                507                 :                :                             false, false) == InvalidOffsetNumber)
 1509 pg@bowt.ie                508         [ #  # ]:UBC           0 :                 elog(ERROR, "deduplication failed to add highkey");
                                509                 :                :         }
                                510                 :                : 
 1509 pg@bowt.ie                511                 :CBC        2133 :         intervals = (BTDedupInterval *) ptr;
                                512                 :           2133 :         for (offnum = minoff;
                                513         [ +  + ]:         490409 :              offnum <= maxoff;
                                514                 :         488276 :              offnum = OffsetNumberNext(offnum))
                                515                 :                :         {
                                516                 :         488276 :             ItemId      itemid = PageGetItemId(page, offnum);
                                517                 :         488276 :             IndexTuple  itup = (IndexTuple) PageGetItem(page, itemid);
                                518                 :                : 
                                519         [ +  + ]:         488276 :             if (offnum == minoff)
                                520                 :           2133 :                 _bt_dedup_start_pending(state, itup, offnum);
                                521         [ +  + ]:         486143 :             else if (state->nintervals < xlrec->nintervals &&
                                522         [ +  + ]:         363186 :                      state->baseoff == intervals[state->nintervals].baseoff &&
                                523         [ +  + ]:         127078 :                      state->nitems < intervals[state->nintervals].nitems)
                                524                 :                :             {
                                525         [ -  + ]:          84160 :                 if (!_bt_dedup_save_htid(state, itup))
 1509 pg@bowt.ie                526         [ #  # ]:UBC           0 :                     elog(ERROR, "deduplication failed to add heap tid to pending posting list");
                                527                 :                :             }
                                528                 :                :             else
                                529                 :                :             {
 1509 pg@bowt.ie                530                 :CBC      401983 :                 _bt_dedup_finish_pending(newpage, state);
                                531                 :         401983 :                 _bt_dedup_start_pending(state, itup, offnum);
                                532                 :                :             }
                                533                 :                :         }
                                534                 :                : 
                                535                 :           2133 :         _bt_dedup_finish_pending(newpage, state);
                                536         [ -  + ]:           2133 :         Assert(state->nintervals == xlrec->nintervals);
                                537         [ -  + ]:           2133 :         Assert(memcmp(state->intervals, intervals,
                                538                 :                :                       state->nintervals * sizeof(BTDedupInterval)) == 0);
                                539                 :                : 
                                540         [ -  + ]:           2133 :         if (P_HAS_GARBAGE(opaque))
                                541                 :                :         {
  744 michael@paquier.xyz       542                 :UBC           0 :             BTPageOpaque nopaque = BTPageGetOpaque(newpage);
                                543                 :                : 
 1509 pg@bowt.ie                544                 :              0 :             nopaque->btpo_flags &= ~BTP_HAS_GARBAGE;
                                545                 :                :         }
                                546                 :                : 
 1509 pg@bowt.ie                547                 :CBC        2133 :         PageRestoreTempPage(newpage, page);
                                548                 :           2133 :         PageSetLSN(page, lsn);
                                549                 :           2133 :         MarkBufferDirty(buf);
                                550                 :                :     }
                                551                 :                : 
                                552         [ +  - ]:           2138 :     if (BufferIsValid(buf))
                                553                 :           2138 :         UnlockReleaseBuffer(buf);
                                554                 :           2138 : }
                                555                 :                : 
                                556                 :                : static void
 1187                           557                 :            160 : btree_xlog_updates(Page page, OffsetNumber *updatedoffsets,
                                558                 :                :                    xl_btree_update *updates, int nupdated)
                                559                 :                : {
                                560                 :                :     BTVacuumPosting vacposting;
                                561                 :                :     IndexTuple  origtuple;
                                562                 :                :     ItemId      itemid;
                                563                 :                :     Size        itemsz;
                                564                 :                : 
                                565         [ +  + ]:           4255 :     for (int i = 0; i < nupdated; i++)
                                566                 :                :     {
                                567                 :           4095 :         itemid = PageGetItemId(page, updatedoffsets[i]);
                                568                 :           4095 :         origtuple = (IndexTuple) PageGetItem(page, itemid);
                                569                 :                : 
                                570                 :           4095 :         vacposting = palloc(offsetof(BTVacuumPostingData, deletetids) +
                                571                 :           4095 :                             updates->ndeletedtids * sizeof(uint16));
                                572                 :           4095 :         vacposting->updatedoffset = updatedoffsets[i];
                                573                 :           4095 :         vacposting->itup = origtuple;
                                574                 :           4095 :         vacposting->ndeletedtids = updates->ndeletedtids;
                                575                 :           4095 :         memcpy(vacposting->deletetids,
                                576                 :                :                (char *) updates + SizeOfBtreeUpdate,
                                577                 :           4095 :                updates->ndeletedtids * sizeof(uint16));
                                578                 :                : 
                                579                 :           4095 :         _bt_update_posting(vacposting);
                                580                 :                : 
                                581                 :                :         /* Overwrite updated version of tuple */
                                582                 :           4095 :         itemsz = MAXALIGN(IndexTupleSize(vacposting->itup));
                                583         [ -  + ]:           4095 :         if (!PageIndexTupleOverwrite(page, updatedoffsets[i],
                                584                 :           4095 :                                      (Item) vacposting->itup, itemsz))
 1187 pg@bowt.ie                585         [ #  # ]:UBC           0 :             elog(PANIC, "failed to update partially dead item");
                                586                 :                : 
 1187 pg@bowt.ie                587                 :CBC        4095 :         pfree(vacposting->itup);
                                588                 :           4095 :         pfree(vacposting);
                                589                 :                : 
                                590                 :                :         /* advance to next xl_btree_update from array */
                                591                 :           4095 :         updates = (xl_btree_update *)
                                592                 :           4095 :             ((char *) updates + SizeOfBtreeUpdate +
                                593                 :           4095 :              updates->ndeletedtids * sizeof(uint16));
                                594                 :                :     }
                                595                 :            160 : }
                                596                 :                : 
                                597                 :                : static void
 3433 heikki.linnakangas@i      598                 :           1352 : btree_xlog_vacuum(XLogReaderState *record)
                                599                 :                : {
                                600                 :           1352 :     XLogRecPtr  lsn = record->EndRecPtr;
 1578 pg@bowt.ie                601                 :           1352 :     xl_btree_vacuum *xlrec = (xl_btree_vacuum *) XLogRecGetData(record);
                                602                 :                :     Buffer      buffer;
                                603                 :                :     Page        page;
                                604                 :                :     BTPageOpaque opaque;
                                605                 :                : 
                                606                 :                :     /*
                                607                 :                :      * We need to take a cleanup lock here, just like btvacuumpage(). However,
                                608                 :                :      * it isn't necessary to exhaustively get a cleanup lock on every block in
                                609                 :                :      * the index during recovery (just getting a cleanup lock on pages with
                                610                 :                :      * items to kill suffices).  See nbtree/README for details.
                                611                 :                :      */
 3433 heikki.linnakangas@i      612         [ +  + ]:           1352 :     if (XLogReadBufferForRedoExtended(record, 0, RBM_NORMAL, true, &buffer)
                                613                 :                :         == BLK_NEEDS_REDO)
                                614                 :                :     {
 1578 pg@bowt.ie                615                 :            964 :         char       *ptr = XLogRecGetBlockData(record, 0, NULL);
                                616                 :                : 
 2916 kgrittn@postgresql.o      617                 :            964 :         page = (Page) BufferGetPage(buffer);
                                618                 :                : 
 1509 pg@bowt.ie                619         [ +  + ]:            964 :         if (xlrec->nupdated > 0)
                                620                 :                :         {
                                621                 :                :             OffsetNumber *updatedoffsets;
                                622                 :                :             xl_btree_update *updates;
                                623                 :                : 
                                624                 :             56 :             updatedoffsets = (OffsetNumber *)
                                625                 :             56 :                 (ptr + xlrec->ndeleted * sizeof(OffsetNumber));
                                626                 :             56 :             updates = (xl_btree_update *) ((char *) updatedoffsets +
                                627                 :             56 :                                            xlrec->nupdated *
                                628                 :                :                                            sizeof(OffsetNumber));
                                629                 :                : 
 1187                           630                 :             56 :             btree_xlog_updates(page, updatedoffsets, updates, xlrec->nupdated);
                                631                 :                :         }
                                632                 :                : 
 1509                           633         [ +  + ]:            964 :         if (xlrec->ndeleted > 0)
                                634                 :            956 :             PageIndexMultiDelete(page, (OffsetNumber *) ptr, xlrec->ndeleted);
                                635                 :                : 
                                636                 :                :         /*
                                637                 :                :          * Mark the page as not containing any LP_DEAD items --- see comments
                                638                 :                :          * in _bt_delitems_vacuum().
                                639                 :                :          */
  744 michael@paquier.xyz       640                 :            964 :         opaque = BTPageGetOpaque(page);
 3532 heikki.linnakangas@i      641                 :            964 :         opaque->btpo_flags &= ~BTP_HAS_GARBAGE;
                                642                 :                : 
                                643                 :            964 :         PageSetLSN(page, lsn);
                                644                 :            964 :         MarkBufferDirty(buffer);
                                645                 :                :     }
                                646         [ +  - ]:           1352 :     if (BufferIsValid(buffer))
                                647                 :           1352 :         UnlockReleaseBuffer(buffer);
 5230 simon@2ndQuadrant.co      648                 :           1352 : }
                                649                 :                : 
                                650                 :                : static void
 3433 heikki.linnakangas@i      651                 :            745 : btree_xlog_delete(XLogReaderState *record)
                                652                 :                : {
                                653                 :            745 :     XLogRecPtr  lsn = record->EndRecPtr;
 4171 tgl@sss.pgh.pa.us         654                 :            745 :     xl_btree_delete *xlrec = (xl_btree_delete *) XLogRecGetData(record);
                                655                 :                :     Buffer      buffer;
                                656                 :                :     Page        page;
                                657                 :                :     BTPageOpaque opaque;
                                658                 :                : 
                                659                 :                :     /*
                                660                 :                :      * If we have any conflict processing to do, it must happen before we
                                661                 :                :      * update the page
                                662                 :                :      */
                                663         [ +  + ]:            745 :     if (InHotStandby)
                                664                 :                :     {
                                665                 :                :         RelFileLocator rlocator;
                                666                 :                : 
  648 rhaas@postgresql.org      667                 :            743 :         XLogRecGetBlockTag(record, 0, &rlocator, NULL, NULL);
                                668                 :                : 
  514 pg@bowt.ie                669                 :            743 :         ResolveRecoveryConflictWithSnapshot(xlrec->snapshotConflictHorizon,
  373 andres@anarazel.de        670                 :            743 :                                             xlrec->isCatalogRel,
                                671                 :                :                                             rlocator);
                                672                 :                :     }
                                673                 :                : 
                                674                 :                :     /*
                                675                 :                :      * We don't need to take a cleanup lock to apply these changes. See
                                676                 :                :      * nbtree/README for details.
                                677                 :                :      */
 3433 heikki.linnakangas@i      678         [ +  + ]:            745 :     if (XLogReadBufferForRedo(record, 0, &buffer) == BLK_NEEDS_REDO)
                                679                 :                :     {
 1563 pg@bowt.ie                680                 :            744 :         char       *ptr = XLogRecGetBlockData(record, 0, NULL);
                                681                 :                : 
                                682                 :            744 :         page = (Page) BufferGetPage(buffer);
                                683                 :                : 
 1187                           684         [ +  + ]:            744 :         if (xlrec->nupdated > 0)
                                685                 :                :         {
                                686                 :                :             OffsetNumber *updatedoffsets;
                                687                 :                :             xl_btree_update *updates;
                                688                 :                : 
                                689                 :            104 :             updatedoffsets = (OffsetNumber *)
                                690                 :            104 :                 (ptr + xlrec->ndeleted * sizeof(OffsetNumber));
                                691                 :            104 :             updates = (xl_btree_update *) ((char *) updatedoffsets +
                                692                 :            104 :                                            xlrec->nupdated *
                                693                 :                :                                            sizeof(OffsetNumber));
                                694                 :                : 
                                695                 :            104 :             btree_xlog_updates(page, updatedoffsets, updates, xlrec->nupdated);
                                696                 :                :         }
                                697                 :                : 
                                698         [ +  + ]:            744 :         if (xlrec->ndeleted > 0)
                                699                 :            727 :             PageIndexMultiDelete(page, (OffsetNumber *) ptr, xlrec->ndeleted);
                                700                 :                : 
                                701                 :                :         /* Mark the page as not containing any LP_DEAD items */
  744 michael@paquier.xyz       702                 :            744 :         opaque = BTPageGetOpaque(page);
 3532 heikki.linnakangas@i      703                 :            744 :         opaque->btpo_flags &= ~BTP_HAS_GARBAGE;
                                704                 :                : 
                                705                 :            744 :         PageSetLSN(page, lsn);
                                706                 :            744 :         MarkBufferDirty(buffer);
                                707                 :                :     }
                                708         [ +  - ]:            745 :     if (BufferIsValid(buffer))
                                709                 :            745 :         UnlockReleaseBuffer(buffer);
 7723 tgl@sss.pgh.pa.us         710                 :            745 : }
                                711                 :                : 
                                712                 :                : static void
 3433 heikki.linnakangas@i      713                 :            644 : btree_xlog_mark_page_halfdead(uint8 info, XLogReaderState *record)
                                714                 :                : {
                                715                 :            644 :     XLogRecPtr  lsn = record->EndRecPtr;
 3684                           716                 :            644 :     xl_btree_mark_page_halfdead *xlrec = (xl_btree_mark_page_halfdead *) XLogRecGetData(record);
                                717                 :                :     Buffer      buffer;
                                718                 :                :     Page        page;
                                719                 :                :     BTPageOpaque pageop;
                                720                 :                :     IndexTupleData trunctuple;
                                721                 :                : 
                                722                 :                :     /*
                                723                 :                :      * In normal operation, we would lock all the pages this WAL record
                                724                 :                :      * touches before changing any of them.  In WAL replay, it should be okay
                                725                 :                :      * to lock just one page at a time, since no concurrent index updates can
                                726                 :                :      * be happening, and readers should not care whether they arrive at the
                                727                 :                :      * target page or not (since it's surely empty).
                                728                 :                :      */
                                729                 :                : 
                                730                 :                :     /* to-be-deleted subtree's parent page */
 3433                           731         [ +  - ]:            644 :     if (XLogReadBufferForRedo(record, 1, &buffer) == BLK_NEEDS_REDO)
                                732                 :                :     {
                                733                 :                :         OffsetNumber poffset;
                                734                 :                :         ItemId      itemid;
                                735                 :                :         IndexTuple  itup;
                                736                 :                :         OffsetNumber nextoffset;
                                737                 :                :         BlockNumber rightsib;
                                738                 :                : 
 2916 kgrittn@postgresql.o      739                 :            644 :         page = (Page) BufferGetPage(buffer);
  744 michael@paquier.xyz       740                 :            644 :         pageop = BTPageGetOpaque(page);
                                741                 :                : 
 3433 heikki.linnakangas@i      742                 :            644 :         poffset = xlrec->poffset;
                                743                 :                : 
 3532                           744                 :            644 :         nextoffset = OffsetNumberNext(poffset);
                                745                 :            644 :         itemid = PageGetItemId(page, nextoffset);
                                746                 :            644 :         itup = (IndexTuple) PageGetItem(page, itemid);
 1581 pg@bowt.ie                747                 :            644 :         rightsib = BTreeTupleGetDownLink(itup);
                                748                 :                : 
 3532 heikki.linnakangas@i      749                 :            644 :         itemid = PageGetItemId(page, poffset);
                                750                 :            644 :         itup = (IndexTuple) PageGetItem(page, itemid);
 1581 pg@bowt.ie                751                 :            644 :         BTreeTupleSetDownLink(itup, rightsib);
 3532 heikki.linnakangas@i      752                 :            644 :         nextoffset = OffsetNumberNext(poffset);
                                753                 :            644 :         PageIndexTupleDelete(page, nextoffset);
                                754                 :                : 
                                755                 :            644 :         PageSetLSN(page, lsn);
                                756                 :            644 :         MarkBufferDirty(buffer);
                                757                 :                :     }
                                758                 :                : 
                                759                 :                :     /*
                                760                 :                :      * Don't need to couple cross-level locks in REDO routines, so release
                                761                 :                :      * lock on internal page immediately
                                762                 :                :      */
                                763         [ +  - ]:            644 :     if (BufferIsValid(buffer))
                                764                 :            644 :         UnlockReleaseBuffer(buffer);
                                765                 :                : 
                                766                 :                :     /* Rewrite the leaf page as a halfdead page */
 3433                           767                 :            644 :     buffer = XLogInitBufferForRedo(record, 0);
 2916 kgrittn@postgresql.o      768                 :            644 :     page = (Page) BufferGetPage(buffer);
                                769                 :                : 
 3684 heikki.linnakangas@i      770                 :            644 :     _bt_pageinit(page, BufferGetPageSize(buffer));
  744 michael@paquier.xyz       771                 :            644 :     pageop = BTPageGetOpaque(page);
                                772                 :                : 
 3684 heikki.linnakangas@i      773                 :            644 :     pageop->btpo_prev = xlrec->leftblk;
                                774                 :            644 :     pageop->btpo_next = xlrec->rightblk;
 1145 pg@bowt.ie                775                 :            644 :     pageop->btpo_level = 0;
 3684 heikki.linnakangas@i      776                 :            644 :     pageop->btpo_flags = BTP_HALF_DEAD | BTP_LEAF;
                                777                 :            644 :     pageop->btpo_cycleid = 0;
                                778                 :                : 
                                779                 :                :     /*
                                780                 :                :      * Construct a dummy high key item that points to top parent page (value
                                781                 :                :      * is InvalidBlockNumber when the top parent page is the leaf page itself)
                                782                 :                :      */
                                783   [ -  +  -  -  :            644 :     MemSet(&trunctuple, 0, sizeof(IndexTupleData));
                                     -  -  -  -  -  
                                                 - ]
                                784                 :            644 :     trunctuple.t_info = sizeof(IndexTupleData);
 2183 teodor@sigaev.ru          785                 :            644 :     BTreeTupleSetTopParent(&trunctuple, xlrec->topparent);
                                786                 :                : 
 3684 heikki.linnakangas@i      787         [ -  + ]:            644 :     if (PageAddItem(page, (Item) &trunctuple, sizeof(IndexTupleData), P_HIKEY,
                                788                 :                :                     false, false) == InvalidOffsetNumber)
 3684 heikki.linnakangas@i      789         [ #  # ]:UBC           0 :         elog(ERROR, "could not add dummy high key to half-dead page");
                                790                 :                : 
 3684 heikki.linnakangas@i      791                 :CBC         644 :     PageSetLSN(page, lsn);
                                792                 :            644 :     MarkBufferDirty(buffer);
                                793                 :            644 :     UnlockReleaseBuffer(buffer);
                                794                 :            644 : }
                                795                 :                : 
                                796                 :                : 
                                797                 :                : static void
 3433                           798                 :            690 : btree_xlog_unlink_page(uint8 info, XLogReaderState *record)
                                799                 :                : {
                                800                 :            690 :     XLogRecPtr  lsn = record->EndRecPtr;
 3684                           801                 :            690 :     xl_btree_unlink_page *xlrec = (xl_btree_unlink_page *) XLogRecGetData(record);
                                802                 :                :     BlockNumber leftsib;
                                803                 :                :     BlockNumber rightsib;
                                804                 :                :     uint32      level;
                                805                 :                :     bool        isleaf;
                                806                 :                :     FullTransactionId safexid;
                                807                 :                :     Buffer      leftbuf;
                                808                 :                :     Buffer      target;
                                809                 :                :     Buffer      rightbuf;
                                810                 :                :     Page        page;
                                811                 :                :     BTPageOpaque pageop;
                                812                 :                : 
                                813                 :            690 :     leftsib = xlrec->leftsib;
                                814                 :            690 :     rightsib = xlrec->rightsib;
 1145 pg@bowt.ie                815                 :            690 :     level = xlrec->level;
                                816                 :            690 :     isleaf = (level == 0);
                                817                 :            690 :     safexid = xlrec->safexid;
                                818                 :                : 
                                819                 :                :     /* No leaftopparent for level 0 (leaf page) or level 1 target */
 1139                           820   [ +  +  -  + ]:            690 :     Assert(!BlockNumberIsValid(xlrec->leaftopparent) || level > 1);
                                821                 :                : 
                                822                 :                :     /*
                                823                 :                :      * In normal operation, we would lock all the pages this WAL record
                                824                 :                :      * touches before changing any of them.  In WAL replay, we at least lock
                                825                 :                :      * the pages in the same standard left-to-right order (leftsib, target,
                                826                 :                :      * rightsib), and don't release the sibling locks until the target is
                                827                 :                :      * marked deleted.
                                828                 :                :      */
                                829                 :                : 
                                830                 :                :     /* Fix right-link of left sibling, if any */
 3532 heikki.linnakangas@i      831         [ +  + ]:            690 :     if (leftsib != P_NONE)
                                832                 :                :     {
 1350 pg@bowt.ie                833         [ +  - ]:             82 :         if (XLogReadBufferForRedo(record, 1, &leftbuf) == BLK_NEEDS_REDO)
                                834                 :                :         {
                                835                 :             82 :             page = (Page) BufferGetPage(leftbuf);
  744 michael@paquier.xyz       836                 :             82 :             pageop = BTPageGetOpaque(page);
 3532 heikki.linnakangas@i      837                 :             82 :             pageop->btpo_next = rightsib;
                                838                 :                : 
                                839                 :             82 :             PageSetLSN(page, lsn);
 1350 pg@bowt.ie                840                 :             82 :             MarkBufferDirty(leftbuf);
                                841                 :                :         }
                                842                 :                :     }
                                843                 :                :     else
                                844                 :            608 :         leftbuf = InvalidBuffer;
                                845                 :                : 
                                846                 :                :     /* Rewrite target page as empty deleted page */
                                847                 :            690 :     target = XLogInitBufferForRedo(record, 0);
                                848                 :            690 :     page = (Page) BufferGetPage(target);
                                849                 :                : 
                                850                 :            690 :     _bt_pageinit(page, BufferGetPageSize(target));
  744 michael@paquier.xyz       851                 :            690 :     pageop = BTPageGetOpaque(page);
                                852                 :                : 
 6887 tgl@sss.pgh.pa.us         853                 :            690 :     pageop->btpo_prev = leftsib;
                                854                 :            690 :     pageop->btpo_next = rightsib;
 1145 pg@bowt.ie                855                 :            690 :     pageop->btpo_level = level;
                                856                 :            690 :     BTPageSetDeleted(page, safexid);
                                857         [ +  + ]:            690 :     if (isleaf)
 1256                           858                 :            643 :         pageop->btpo_flags |= BTP_LEAF;
 6551 tgl@sss.pgh.pa.us         859                 :            690 :     pageop->btpo_cycleid = 0;
                                860                 :                : 
 6887                           861                 :            690 :     PageSetLSN(page, lsn);
 1350 pg@bowt.ie                862                 :            690 :     MarkBufferDirty(target);
                                863                 :                : 
                                864                 :                :     /* Fix left-link of right sibling */
                                865         [ +  + ]:            690 :     if (XLogReadBufferForRedo(record, 2, &rightbuf) == BLK_NEEDS_REDO)
                                866                 :                :     {
                                867                 :            650 :         page = (Page) BufferGetPage(rightbuf);
  744 michael@paquier.xyz       868                 :            650 :         pageop = BTPageGetOpaque(page);
 1350 pg@bowt.ie                869                 :            650 :         pageop->btpo_prev = leftsib;
                                870                 :                : 
                                871                 :            650 :         PageSetLSN(page, lsn);
                                872                 :            650 :         MarkBufferDirty(rightbuf);
                                873                 :                :     }
                                874                 :                : 
                                875                 :                :     /* Release siblings */
                                876         [ +  + ]:            690 :     if (BufferIsValid(leftbuf))
                                877                 :             82 :         UnlockReleaseBuffer(leftbuf);
                                878         [ +  - ]:            690 :     if (BufferIsValid(rightbuf))
                                879                 :            690 :         UnlockReleaseBuffer(rightbuf);
                                880                 :                : 
                                881                 :                :     /* Release target */
                                882                 :            690 :     UnlockReleaseBuffer(target);
                                883                 :                : 
                                884                 :                :     /*
                                885                 :                :      * If we deleted a parent of the targeted leaf page, instead of the leaf
                                886                 :                :      * itself, update the leaf to point to the next remaining child in the
                                887                 :                :      * to-be-deleted subtree
                                888                 :                :      */
 3433 heikki.linnakangas@i      889   [ +  +  +  + ]:            690 :     if (XLogRecHasBlockRef(record, 3))
                                890                 :                :     {
                                891                 :                :         /*
                                892                 :                :          * There is no real data on the page, so we just re-create it from
                                893                 :                :          * scratch using the information from the WAL record.
                                894                 :                :          *
                                895                 :                :          * Note that we don't end up here when the target page is also the
                                896                 :                :          * leafbuf page.  There is no need to add a dummy hikey item with a
                                897                 :                :          * top parent link when deleting leafbuf because it's the last page
                                898                 :                :          * we'll delete in the subtree undergoing deletion.
                                899                 :                :          */
                                900                 :                :         Buffer      leafbuf;
                                901                 :                :         IndexTupleData trunctuple;
                                902                 :                : 
 1145 pg@bowt.ie                903         [ -  + ]:             47 :         Assert(!isleaf);
                                904                 :                : 
 1350                           905                 :             47 :         leafbuf = XLogInitBufferForRedo(record, 3);
                                906                 :             47 :         page = (Page) BufferGetPage(leafbuf);
                                907                 :                : 
                                908                 :             47 :         _bt_pageinit(page, BufferGetPageSize(leafbuf));
  744 michael@paquier.xyz       909                 :             47 :         pageop = BTPageGetOpaque(page);
                                910                 :                : 
 3684 heikki.linnakangas@i      911                 :             47 :         pageop->btpo_flags = BTP_HALF_DEAD | BTP_LEAF;
                                912                 :             47 :         pageop->btpo_prev = xlrec->leafleftsib;
                                913                 :             47 :         pageop->btpo_next = xlrec->leafrightsib;
 1145 pg@bowt.ie                914                 :             47 :         pageop->btpo_level = 0;
 3684 heikki.linnakangas@i      915                 :             47 :         pageop->btpo_cycleid = 0;
                                916                 :                : 
                                917                 :                :         /* Add a dummy hikey item */
                                918   [ +  -  +  -  :             94 :         MemSet(&trunctuple, 0, sizeof(IndexTupleData));
                                     +  -  +  -  +  
                                                 + ]
                                919                 :             47 :         trunctuple.t_info = sizeof(IndexTupleData);
 1145 pg@bowt.ie                920                 :             47 :         BTreeTupleSetTopParent(&trunctuple, xlrec->leaftopparent);
                                921                 :                : 
 3684 heikki.linnakangas@i      922         [ -  + ]:             47 :         if (PageAddItem(page, (Item) &trunctuple, sizeof(IndexTupleData), P_HIKEY,
                                923                 :                :                         false, false) == InvalidOffsetNumber)
 3684 heikki.linnakangas@i      924         [ #  # ]:UBC           0 :             elog(ERROR, "could not add dummy high key to half-dead page");
                                925                 :                : 
 3684 heikki.linnakangas@i      926                 :CBC          47 :         PageSetLSN(page, lsn);
 1350 pg@bowt.ie                927                 :             47 :         MarkBufferDirty(leafbuf);
                                928                 :             47 :         UnlockReleaseBuffer(leafbuf);
                                929                 :                :     }
                                930                 :                : 
                                931                 :                :     /* Update metapage if needed */
 3684 heikki.linnakangas@i      932         [ +  + ]:            690 :     if (info == XLOG_BTREE_UNLINK_PAGE_META)
 3433                           933                 :              8 :         _bt_restore_meta(record, 4);
 7721 tgl@sss.pgh.pa.us         934                 :            690 : }
                                935                 :                : 
                                936                 :                : static void
 3433 heikki.linnakangas@i      937                 :            668 : btree_xlog_newroot(XLogReaderState *record)
                                938                 :                : {
                                939                 :            668 :     XLogRecPtr  lsn = record->EndRecPtr;
 7723 tgl@sss.pgh.pa.us         940                 :            668 :     xl_btree_newroot *xlrec = (xl_btree_newroot *) XLogRecGetData(record);
                                941                 :                :     Buffer      buffer;
                                942                 :                :     Page        page;
                                943                 :                :     BTPageOpaque pageop;
                                944                 :                :     char       *ptr;
                                945                 :                :     Size        len;
                                946                 :                : 
 3433 heikki.linnakangas@i      947                 :            668 :     buffer = XLogInitBufferForRedo(record, 0);
 2916 kgrittn@postgresql.o      948                 :            668 :     page = (Page) BufferGetPage(buffer);
                                949                 :                : 
 7723 tgl@sss.pgh.pa.us         950                 :            668 :     _bt_pageinit(page, BufferGetPageSize(buffer));
  744 michael@paquier.xyz       951                 :            668 :     pageop = BTPageGetOpaque(page);
                                952                 :                : 
 7723 tgl@sss.pgh.pa.us         953                 :            668 :     pageop->btpo_flags = BTP_ROOT;
                                954                 :            668 :     pageop->btpo_prev = pageop->btpo_next = P_NONE;
 1145 pg@bowt.ie                955                 :            668 :     pageop->btpo_level = xlrec->level;
 7723 tgl@sss.pgh.pa.us         956         [ +  + ]:            668 :     if (xlrec->level == 0)
                                957                 :            618 :         pageop->btpo_flags |= BTP_LEAF;
 6551                           958                 :            668 :     pageop->btpo_cycleid = 0;
                                959                 :                : 
 3433 heikki.linnakangas@i      960         [ +  + ]:            668 :     if (xlrec->level > 0)
                                961                 :                :     {
                                962                 :             50 :         ptr = XLogRecGetBlockData(record, 0, &len);
                                963                 :             50 :         _bt_restore_page(page, ptr, len);
                                964                 :                : 
                                965                 :                :         /* Clear the incomplete-split flag in left child */
                                966                 :             50 :         _bt_clear_incomplete_split(record, 1);
                                967                 :                :     }
                                968                 :                : 
 7723 tgl@sss.pgh.pa.us         969                 :            668 :     PageSetLSN(page, lsn);
 6589                           970                 :            668 :     MarkBufferDirty(buffer);
                                971                 :            668 :     UnlockReleaseBuffer(buffer);
                                972                 :                : 
 3433 heikki.linnakangas@i      973                 :            668 :     _bt_restore_meta(record, 2);
 7723 tgl@sss.pgh.pa.us         974                 :            668 : }
                                975                 :                : 
                                976                 :                : /*
                                977                 :                :  * In general VACUUM must defer recycling as a way of avoiding certain race
                                978                 :                :  * conditions.  Deleted pages contain a safexid value that is used by VACUUM
                                979                 :                :  * to determine whether or not it's safe to place a page that was deleted by
                                980                 :                :  * VACUUM earlier into the FSM now.  See nbtree/README.
                                981                 :                :  *
                                982                 :                :  * As far as any backend operating during original execution is concerned, the
                                983                 :                :  * FSM is a cache of recycle-safe pages; the mere presence of the page in the
                                984                 :                :  * FSM indicates that the page must already be safe to recycle (actually,
                                985                 :                :  * _bt_getbuf() verifies it's safe using BTPageIsRecyclable(), but that's just
                                986                 :                :  * because it would be unwise to completely trust the FSM, given its current
                                987                 :                :  * limitations).
                                988                 :                :  *
                                989                 :                :  * This isn't sufficient to prevent similar concurrent recycling race
                                990                 :                :  * conditions during Hot Standby, though.  For that we need to log a
                                991                 :                :  * xl_btree_reuse_page record at the point that a page is actually recycled
                                992                 :                :  * and reused for an entirely unrelated page inside _bt_split().  These
                                993                 :                :  * records include the same safexid value from the original deleted page,
                                994                 :                :  * stored in the record's snapshotConflictHorizon field.
                                995                 :                :  *
                                996                 :                :  * The GlobalVisCheckRemovableFullXid() test in BTPageIsRecyclable() is used
                                997                 :                :  * to determine if it's safe to recycle a page.  This mirrors our own test:
                                998                 :                :  * the PGPROC->xmin > limitXmin test inside GetConflictingVirtualXIDs().
                                999                 :                :  * Consequently, one XID value achieves the same exclusion effect on primary
                               1000                 :                :  * and standby.
                               1001                 :                :  */
                               1002                 :                : static void
 3433 heikki.linnakangas@i     1003                 :             53 : btree_xlog_reuse_page(XLogReaderState *record)
                               1004                 :                : {
 4171 tgl@sss.pgh.pa.us        1005                 :             53 :     xl_btree_reuse_page *xlrec = (xl_btree_reuse_page *) XLogRecGetData(record);
                               1006                 :                : 
 5174 simon@2ndQuadrant.co     1007         [ +  - ]:             53 :     if (InHotStandby)
  514 pg@bowt.ie               1008                 :             53 :         ResolveRecoveryConflictWithSnapshotFullXid(xlrec->snapshotConflictHorizon,
  373 andres@anarazel.de       1009                 :             53 :                                                    xlrec->isCatalogRel,
                               1010                 :                :                                                    xlrec->locator);
 4171 tgl@sss.pgh.pa.us        1011                 :             53 : }
                               1012                 :                : 
                               1013                 :                : void
 3433 heikki.linnakangas@i     1014                 :         510278 : btree_redo(XLogReaderState *record)
                               1015                 :                : {
                               1016                 :         510278 :     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
                               1017                 :                :     MemoryContext oldCtx;
                               1018                 :                : 
 1509 pg@bowt.ie               1019                 :         510278 :     oldCtx = MemoryContextSwitchTo(opCtx);
 7723 tgl@sss.pgh.pa.us        1020   [ +  +  +  +  :         510278 :     switch (info)
                                     +  +  +  +  +  
                                     +  +  +  +  +  
                                                 - ]
                               1021                 :                :     {
                               1022                 :         497391 :         case XLOG_BTREE_INSERT_LEAF:
 1509 pg@bowt.ie               1023                 :         497391 :             btree_xlog_insert(true, false, false, record);
 7723 tgl@sss.pgh.pa.us        1024                 :         497391 :             break;
                               1025                 :           1382 :         case XLOG_BTREE_INSERT_UPPER:
 1509 pg@bowt.ie               1026                 :           1382 :             btree_xlog_insert(false, false, false, record);
 7723 tgl@sss.pgh.pa.us        1027                 :           1382 :             break;
                               1028                 :              4 :         case XLOG_BTREE_INSERT_META:
 1509 pg@bowt.ie               1029                 :              4 :             btree_xlog_insert(false, true, false, record);
 7723 tgl@sss.pgh.pa.us        1030                 :              4 :             break;
                               1031                 :            184 :         case XLOG_BTREE_SPLIT_L:
 1852 pg@bowt.ie               1032                 :            184 :             btree_xlog_split(true, record);
 7723 tgl@sss.pgh.pa.us        1033                 :            184 :             break;
                               1034                 :           1303 :         case XLOG_BTREE_SPLIT_R:
 1852 pg@bowt.ie               1035                 :           1303 :             btree_xlog_split(false, record);
 7723 tgl@sss.pgh.pa.us        1036                 :           1303 :             break;
 1509 pg@bowt.ie               1037                 :           3710 :         case XLOG_BTREE_INSERT_POST:
                               1038                 :           3710 :             btree_xlog_insert(true, false, true, record);
                               1039                 :           3710 :             break;
                               1040                 :           2138 :         case XLOG_BTREE_DEDUP:
                               1041                 :           2138 :             btree_xlog_dedup(record);
                               1042                 :           2138 :             break;
 5230 simon@2ndQuadrant.co     1043                 :           1352 :         case XLOG_BTREE_VACUUM:
 3433 heikki.linnakangas@i     1044                 :           1352 :             btree_xlog_vacuum(record);
 5230 simon@2ndQuadrant.co     1045                 :           1352 :             break;
 7723 tgl@sss.pgh.pa.us        1046                 :            745 :         case XLOG_BTREE_DELETE:
 3433 heikki.linnakangas@i     1047                 :            745 :             btree_xlog_delete(record);
 7723 tgl@sss.pgh.pa.us        1048                 :            745 :             break;
 3684 heikki.linnakangas@i     1049                 :            644 :         case XLOG_BTREE_MARK_PAGE_HALFDEAD:
 3433                          1050                 :            644 :             btree_xlog_mark_page_halfdead(info, record);
 3684                          1051                 :            644 :             break;
                               1052                 :            690 :         case XLOG_BTREE_UNLINK_PAGE:
                               1053                 :                :         case XLOG_BTREE_UNLINK_PAGE_META:
 3433                          1054                 :            690 :             btree_xlog_unlink_page(info, record);
 7723 tgl@sss.pgh.pa.us        1055                 :            690 :             break;
                               1056                 :            668 :         case XLOG_BTREE_NEWROOT:
 3433 heikki.linnakangas@i     1057                 :            668 :             btree_xlog_newroot(record);
 7723 tgl@sss.pgh.pa.us        1058                 :            668 :             break;
 5098 heikki.linnakangas@i     1059                 :             53 :         case XLOG_BTREE_REUSE_PAGE:
 3433                          1060                 :             53 :             btree_xlog_reuse_page(record);
 5098                          1061                 :             53 :             break;
 2202 teodor@sigaev.ru         1062                 :             14 :         case XLOG_BTREE_META_CLEANUP:
                               1063                 :             14 :             _bt_restore_meta(record, 0);
                               1064                 :             14 :             break;
 7723 tgl@sss.pgh.pa.us        1065                 :UBC           0 :         default:
                               1066         [ #  # ]:              0 :             elog(PANIC, "btree_redo: unknown op code %u", info);
                               1067                 :                :     }
 1509 pg@bowt.ie               1068                 :CBC      510278 :     MemoryContextSwitchTo(oldCtx);
                               1069                 :         510278 :     MemoryContextReset(opCtx);
                               1070                 :         510278 : }
                               1071                 :                : 
                               1072                 :                : void
                               1073                 :            232 : btree_xlog_startup(void)
                               1074                 :                : {
                               1075                 :            232 :     opCtx = AllocSetContextCreate(CurrentMemoryContext,
                               1076                 :                :                                   "Btree recovery temporary context",
                               1077                 :                :                                   ALLOCSET_DEFAULT_SIZES);
                               1078                 :            232 : }
                               1079                 :                : 
                               1080                 :                : void
                               1081                 :            140 : btree_xlog_cleanup(void)
                               1082                 :                : {
                               1083                 :            140 :     MemoryContextDelete(opCtx);
                               1084                 :            140 :     opCtx = NULL;
 7723 tgl@sss.pgh.pa.us        1085                 :            140 : }
                               1086                 :                : 
                               1087                 :                : /*
                               1088                 :                :  * Mask a btree page before performing consistency checks on it.
                               1089                 :                :  */
                               1090                 :                : void
 2622 rhaas@postgresql.org     1091                 :UBC           0 : btree_mask(char *pagedata, BlockNumber blkno)
                               1092                 :                : {
                               1093                 :              0 :     Page        page = (Page) pagedata;
                               1094                 :                :     BTPageOpaque maskopaq;
                               1095                 :                : 
 2396                          1096                 :              0 :     mask_page_lsn_and_checksum(page);
                               1097                 :                : 
 2622                          1098                 :              0 :     mask_page_hint_bits(page);
                               1099                 :              0 :     mask_unused_space(page);
                               1100                 :                : 
  744 michael@paquier.xyz      1101                 :              0 :     maskopaq = BTPageGetOpaque(page);
                               1102                 :                : 
 1348 akorotkov@postgresql     1103         [ #  # ]:              0 :     if (P_ISLEAF(maskopaq))
                               1104                 :                :     {
                               1105                 :                :         /*
                               1106                 :                :          * In btree leaf pages, it is possible to modify the LP_FLAGS without
                               1107                 :                :          * emitting any WAL record. Hence, mask the line pointer flags. See
                               1108                 :                :          * _bt_killitems(), _bt_check_unique() for details.
                               1109                 :                :          */
 2622 rhaas@postgresql.org     1110                 :              0 :         mask_lp_flags(page);
                               1111                 :                :     }
                               1112                 :                : 
                               1113                 :                :     /*
                               1114                 :                :      * BTP_HAS_GARBAGE is just an un-logged hint bit. So, mask it. See
                               1115                 :                :      * _bt_delete_or_dedup_one_page(), _bt_killitems(), and _bt_check_unique()
                               1116                 :                :      * for details.
                               1117                 :                :      */
                               1118                 :              0 :     maskopaq->btpo_flags &= ~BTP_HAS_GARBAGE;
                               1119                 :                : 
                               1120                 :                :     /*
                               1121                 :                :      * During replay of a btree page split, we don't set the BTP_SPLIT_END
                               1122                 :                :      * flag of the right sibling and initialize the cycle_id to 0 for the same
                               1123                 :                :      * page. See btree_xlog_split() for details.
                               1124                 :                :      */
                               1125                 :              0 :     maskopaq->btpo_flags &= ~BTP_SPLIT_END;
                               1126                 :              0 :     maskopaq->btpo_cycleid = 0;
                               1127                 :              0 : }
        

Generated by: LCOV version 2.1-beta2-3-g6141622