LCOV - code coverage report
Current view: top level - src/backend/catalog - storage.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 308 316 97.5 %
Date: 2023-12-02 14:10:25 Functions: 19 19 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * storage.c
       4             :  *    code to create and destroy physical storage for relations
       5             :  *
       6             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
       7             :  * Portions Copyright (c) 1994, Regents of the University of California
       8             :  *
       9             :  *
      10             :  * IDENTIFICATION
      11             :  *    src/backend/catalog/storage.c
      12             :  *
      13             :  * NOTES
      14             :  *    Some of this code used to be in storage/smgr/smgr.c, and the
      15             :  *    function names still reflect that.
      16             :  *
      17             :  *-------------------------------------------------------------------------
      18             :  */
      19             : 
      20             : #include "postgres.h"
      21             : 
      22             : #include "access/parallel.h"
      23             : #include "access/visibilitymap.h"
      24             : #include "access/xact.h"
      25             : #include "access/xlog.h"
      26             : #include "access/xloginsert.h"
      27             : #include "access/xlogutils.h"
      28             : #include "catalog/storage.h"
      29             : #include "catalog/storage_xlog.h"
      30             : #include "miscadmin.h"
      31             : #include "storage/freespace.h"
      32             : #include "storage/smgr.h"
      33             : #include "utils/hsearch.h"
      34             : #include "utils/memutils.h"
      35             : #include "utils/rel.h"
      36             : 
      37             : /* GUC variables */
      38             : int         wal_skip_threshold = 2048;  /* in kilobytes */
      39             : 
      40             : /*
      41             :  * We keep a list of all relations (represented as RelFileLocator values)
      42             :  * that have been created or deleted in the current transaction.  When
      43             :  * a relation is created, we create the physical file immediately, but
      44             :  * remember it so that we can delete the file again if the current
      45             :  * transaction is aborted.  Conversely, a deletion request is NOT
      46             :  * executed immediately, but is just entered in the list.  When and if
      47             :  * the transaction commits, we can delete the physical file.
      48             :  *
      49             :  * To handle subtransactions, every entry is marked with its transaction
      50             :  * nesting level.  At subtransaction commit, we reassign the subtransaction's
      51             :  * entries to the parent nesting level.  At subtransaction abort, we can
      52             :  * immediately execute the abort-time actions for all entries of the current
      53             :  * nesting level.
      54             :  *
      55             :  * NOTE: the list is kept in TopMemoryContext to be sure it won't disappear
      56             :  * unbetimes.  It'd probably be OK to keep it in TopTransactionContext,
      57             :  * but I'm being paranoid.
      58             :  */
      59             : 
      60             : typedef struct PendingRelDelete
      61             : {
      62             :     RelFileLocator rlocator;    /* relation that may need to be deleted */
      63             :     BackendId   backend;        /* InvalidBackendId if not a temp rel */
      64             :     bool        atCommit;       /* T=delete at commit; F=delete at abort */
      65             :     int         nestLevel;      /* xact nesting level of request */
      66             :     struct PendingRelDelete *next;  /* linked-list link */
      67             : } PendingRelDelete;
      68             : 
      69             : typedef struct PendingRelSync
      70             : {
      71             :     RelFileLocator rlocator;
      72             :     bool        is_truncated;   /* Has the file experienced truncation? */
      73             : } PendingRelSync;
      74             : 
      75             : static PendingRelDelete *pendingDeletes = NULL; /* head of linked list */
      76             : static HTAB *pendingSyncHash = NULL;
      77             : 
      78             : 
      79             : /*
      80             :  * AddPendingSync
      81             :  *      Queue an at-commit fsync.
      82             :  */
      83             : static void
      84       64598 : AddPendingSync(const RelFileLocator *rlocator)
      85             : {
      86             :     PendingRelSync *pending;
      87             :     bool        found;
      88             : 
      89             :     /* create the hash if not yet */
      90       64598 :     if (!pendingSyncHash)
      91             :     {
      92             :         HASHCTL     ctl;
      93             : 
      94       11944 :         ctl.keysize = sizeof(RelFileLocator);
      95       11944 :         ctl.entrysize = sizeof(PendingRelSync);
      96       11944 :         ctl.hcxt = TopTransactionContext;
      97       11944 :         pendingSyncHash = hash_create("pending sync hash", 16, &ctl,
      98             :                                       HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
      99             :     }
     100             : 
     101       64598 :     pending = hash_search(pendingSyncHash, rlocator, HASH_ENTER, &found);
     102             :     Assert(!found);
     103       64598 :     pending->is_truncated = false;
     104       64598 : }
     105             : 
     106             : /*
     107             :  * RelationCreateStorage
     108             :  *      Create physical storage for a relation.
     109             :  *
     110             :  * Create the underlying disk file storage for the relation. This only
     111             :  * creates the main fork; additional forks are created lazily by the
     112             :  * modules that need them.
     113             :  *
     114             :  * This function is transactional. The creation is WAL-logged, and if the
     115             :  * transaction aborts later on, the storage will be destroyed.  A caller
     116             :  * that does not want the storage to be destroyed in case of an abort may
     117             :  * pass register_delete = false.
     118             :  */
     119             : SMgrRelation
     120      185568 : RelationCreateStorage(RelFileLocator rlocator, char relpersistence,
     121             :                       bool register_delete)
     122             : {
     123             :     SMgrRelation srel;
     124             :     BackendId   backend;
     125             :     bool        needs_wal;
     126             : 
     127             :     Assert(!IsInParallelMode());    /* couldn't update pendingSyncHash */
     128             : 
     129      185568 :     switch (relpersistence)
     130             :     {
     131        5656 :         case RELPERSISTENCE_TEMP:
     132        5656 :             backend = BackendIdForTempRelations();
     133        5656 :             needs_wal = false;
     134        5656 :             break;
     135         440 :         case RELPERSISTENCE_UNLOGGED:
     136         440 :             backend = InvalidBackendId;
     137         440 :             needs_wal = false;
     138         440 :             break;
     139      179472 :         case RELPERSISTENCE_PERMANENT:
     140      179472 :             backend = InvalidBackendId;
     141      179472 :             needs_wal = true;
     142      179472 :             break;
     143           0 :         default:
     144           0 :             elog(ERROR, "invalid relpersistence: %c", relpersistence);
     145             :             return NULL;        /* placate compiler */
     146             :     }
     147             : 
     148      185568 :     srel = smgropen(rlocator, backend);
     149      185568 :     smgrcreate(srel, MAIN_FORKNUM, false);
     150             : 
     151      185568 :     if (needs_wal)
     152      179472 :         log_smgrcreate(&srel->smgr_rlocator.locator, MAIN_FORKNUM);
     153             : 
     154             :     /*
     155             :      * Add the relation to the list of stuff to delete at abort, if we are
     156             :      * asked to do so.
     157             :      */
     158      185568 :     if (register_delete)
     159             :     {
     160             :         PendingRelDelete *pending;
     161             : 
     162             :         pending = (PendingRelDelete *)
     163       95854 :             MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete));
     164       95854 :         pending->rlocator = rlocator;
     165       95854 :         pending->backend = backend;
     166       95854 :         pending->atCommit = false;   /* delete if abort */
     167       95854 :         pending->nestLevel = GetCurrentTransactionNestLevel();
     168       95854 :         pending->next = pendingDeletes;
     169       95854 :         pendingDeletes = pending;
     170             :     }
     171             : 
     172      185568 :     if (relpersistence == RELPERSISTENCE_PERMANENT && !XLogIsNeeded())
     173             :     {
     174             :         Assert(backend == InvalidBackendId);
     175       61014 :         AddPendingSync(&rlocator);
     176             :     }
     177             : 
     178      185568 :     return srel;
     179             : }
     180             : 
     181             : /*
     182             :  * Perform XLogInsert of an XLOG_SMGR_CREATE record to WAL.
     183             :  */
     184             : void
     185      209820 : log_smgrcreate(const RelFileLocator *rlocator, ForkNumber forkNum)
     186             : {
     187             :     xl_smgr_create xlrec;
     188             : 
     189             :     /*
     190             :      * Make an XLOG entry reporting the file creation.
     191             :      */
     192      209820 :     xlrec.rlocator = *rlocator;
     193      209820 :     xlrec.forkNum = forkNum;
     194             : 
     195      209820 :     XLogBeginInsert();
     196      209820 :     XLogRegisterData((char *) &xlrec, sizeof(xlrec));
     197      209820 :     XLogInsert(RM_SMGR_ID, XLOG_SMGR_CREATE | XLR_SPECIAL_REL_UPDATE);
     198      209820 : }
     199             : 
     200             : /*
     201             :  * RelationDropStorage
     202             :  *      Schedule unlinking of physical storage at transaction commit.
     203             :  */
     204             : void
     205       61210 : RelationDropStorage(Relation rel)
     206             : {
     207             :     PendingRelDelete *pending;
     208             : 
     209             :     /* Add the relation to the list of stuff to delete at commit */
     210             :     pending = (PendingRelDelete *)
     211       61210 :         MemoryContextAlloc(TopMemoryContext, sizeof(PendingRelDelete));
     212       61210 :     pending->rlocator = rel->rd_locator;
     213       61210 :     pending->backend = rel->rd_backend;
     214       61210 :     pending->atCommit = true;    /* delete if commit */
     215       61210 :     pending->nestLevel = GetCurrentTransactionNestLevel();
     216       61210 :     pending->next = pendingDeletes;
     217       61210 :     pendingDeletes = pending;
     218             : 
     219             :     /*
     220             :      * NOTE: if the relation was created in this transaction, it will now be
     221             :      * present in the pending-delete list twice, once with atCommit true and
     222             :      * once with atCommit false.  Hence, it will be physically deleted at end
     223             :      * of xact in either case (and the other entry will be ignored by
     224             :      * smgrDoPendingDeletes, so no error will occur).  We could instead remove
     225             :      * the existing list entry and delete the physical file immediately, but
     226             :      * for now I'll keep the logic simple.
     227             :      */
     228             : 
     229       61210 :     RelationCloseSmgr(rel);
     230       61210 : }
     231             : 
     232             : /*
     233             :  * RelationPreserveStorage
     234             :  *      Mark a relation as not to be deleted after all.
     235             :  *
     236             :  * We need this function because relation mapping changes are committed
     237             :  * separately from commit of the whole transaction, so it's still possible
     238             :  * for the transaction to abort after the mapping update is done.
     239             :  * When a new physical relation is installed in the map, it would be
     240             :  * scheduled for delete-on-abort, so we'd delete it, and be in trouble.
     241             :  * The relation mapper fixes this by telling us to not delete such relations
     242             :  * after all as part of its commit.
     243             :  *
     244             :  * We also use this to reuse an old build of an index during ALTER TABLE, this
     245             :  * time removing the delete-at-commit entry.
     246             :  *
     247             :  * No-op if the relation is not among those scheduled for deletion.
     248             :  */
     249             : void
     250        6292 : RelationPreserveStorage(RelFileLocator rlocator, bool atCommit)
     251             : {
     252             :     PendingRelDelete *pending;
     253             :     PendingRelDelete *prev;
     254             :     PendingRelDelete *next;
     255             : 
     256        6292 :     prev = NULL;
     257       40470 :     for (pending = pendingDeletes; pending != NULL; pending = next)
     258             :     {
     259       34178 :         next = pending->next;
     260       34178 :         if (RelFileLocatorEquals(rlocator, pending->rlocator)
     261         636 :             && pending->atCommit == atCommit)
     262             :         {
     263             :             /* unlink and delete list entry */
     264         630 :             if (prev)
     265         496 :                 prev->next = next;
     266             :             else
     267         134 :                 pendingDeletes = next;
     268         630 :             pfree(pending);
     269             :             /* prev does not change */
     270             :         }
     271             :         else
     272             :         {
     273             :             /* unrelated entry, don't touch it */
     274       33548 :             prev = pending;
     275             :         }
     276             :     }
     277        6292 : }
     278             : 
     279             : /*
     280             :  * RelationTruncate
     281             :  *      Physically truncate a relation to the specified number of blocks.
     282             :  *
     283             :  * This includes getting rid of any buffers for the blocks that are to be
     284             :  * dropped.
     285             :  */
     286             : void
     287        1052 : RelationTruncate(Relation rel, BlockNumber nblocks)
     288             : {
     289             :     bool        fsm;
     290             :     bool        vm;
     291        1052 :     bool        need_fsm_vacuum = false;
     292             :     ForkNumber  forks[MAX_FORKNUM];
     293             :     BlockNumber blocks[MAX_FORKNUM];
     294        1052 :     int         nforks = 0;
     295             :     SMgrRelation reln;
     296             : 
     297             :     /*
     298             :      * Make sure smgr_targblock etc aren't pointing somewhere past new end.
     299             :      * (Note: don't rely on this reln pointer below this loop.)
     300             :      */
     301        1052 :     reln = RelationGetSmgr(rel);
     302        1052 :     reln->smgr_targblock = InvalidBlockNumber;
     303        5260 :     for (int i = 0; i <= MAX_FORKNUM; ++i)
     304        4208 :         reln->smgr_cached_nblocks[i] = InvalidBlockNumber;
     305             : 
     306             :     /* Prepare for truncation of MAIN fork of the relation */
     307        1052 :     forks[nforks] = MAIN_FORKNUM;
     308        1052 :     blocks[nforks] = nblocks;
     309        1052 :     nforks++;
     310             : 
     311             :     /* Prepare for truncation of the FSM if it exists */
     312        1052 :     fsm = smgrexists(RelationGetSmgr(rel), FSM_FORKNUM);
     313        1052 :     if (fsm)
     314             :     {
     315         270 :         blocks[nforks] = FreeSpaceMapPrepareTruncateRel(rel, nblocks);
     316         270 :         if (BlockNumberIsValid(blocks[nforks]))
     317             :         {
     318         270 :             forks[nforks] = FSM_FORKNUM;
     319         270 :             nforks++;
     320         270 :             need_fsm_vacuum = true;
     321             :         }
     322             :     }
     323             : 
     324             :     /* Prepare for truncation of the visibility map too if it exists */
     325        1052 :     vm = smgrexists(RelationGetSmgr(rel), VISIBILITYMAP_FORKNUM);
     326        1052 :     if (vm)
     327             :     {
     328         268 :         blocks[nforks] = visibilitymap_prepare_truncate(rel, nblocks);
     329         268 :         if (BlockNumberIsValid(blocks[nforks]))
     330             :         {
     331          92 :             forks[nforks] = VISIBILITYMAP_FORKNUM;
     332          92 :             nforks++;
     333             :         }
     334             :     }
     335             : 
     336        1052 :     RelationPreTruncate(rel);
     337             : 
     338             :     /*
     339             :      * Make sure that a concurrent checkpoint can't complete while truncation
     340             :      * is in progress.
     341             :      *
     342             :      * The truncation operation might drop buffers that the checkpoint
     343             :      * otherwise would have flushed. If it does, then it's essential that the
     344             :      * files actually get truncated on disk before the checkpoint record is
     345             :      * written. Otherwise, if reply begins from that checkpoint, the
     346             :      * to-be-truncated blocks might still exist on disk but have older
     347             :      * contents than expected, which can cause replay to fail. It's OK for the
     348             :      * blocks to not exist on disk at all, but not for them to have the wrong
     349             :      * contents.
     350             :      */
     351             :     Assert((MyProc->delayChkptFlags & DELAY_CHKPT_COMPLETE) == 0);
     352        1052 :     MyProc->delayChkptFlags |= DELAY_CHKPT_COMPLETE;
     353             : 
     354             :     /*
     355             :      * We WAL-log the truncation before actually truncating, which means
     356             :      * trouble if the truncation fails. If we then crash, the WAL replay
     357             :      * likely isn't going to succeed in the truncation either, and cause a
     358             :      * PANIC. It's tempting to put a critical section here, but that cure
     359             :      * would be worse than the disease. It would turn a usually harmless
     360             :      * failure to truncate, that might spell trouble at WAL replay, into a
     361             :      * certain PANIC.
     362             :      */
     363        1052 :     if (RelationNeedsWAL(rel))
     364             :     {
     365             :         /*
     366             :          * Make an XLOG entry reporting the file truncation.
     367             :          */
     368             :         XLogRecPtr  lsn;
     369             :         xl_smgr_truncate xlrec;
     370             : 
     371         388 :         xlrec.blkno = nblocks;
     372         388 :         xlrec.rlocator = rel->rd_locator;
     373         388 :         xlrec.flags = SMGR_TRUNCATE_ALL;
     374             : 
     375         388 :         XLogBeginInsert();
     376         388 :         XLogRegisterData((char *) &xlrec, sizeof(xlrec));
     377             : 
     378         388 :         lsn = XLogInsert(RM_SMGR_ID,
     379             :                          XLOG_SMGR_TRUNCATE | XLR_SPECIAL_REL_UPDATE);
     380             : 
     381             :         /*
     382             :          * Flush, because otherwise the truncation of the main relation might
     383             :          * hit the disk before the WAL record, and the truncation of the FSM
     384             :          * or visibility map. If we crashed during that window, we'd be left
     385             :          * with a truncated heap, but the FSM or visibility map would still
     386             :          * contain entries for the non-existent heap pages.
     387             :          */
     388         388 :         if (fsm || vm)
     389         250 :             XLogFlush(lsn);
     390             :     }
     391             : 
     392             :     /*
     393             :      * This will first remove any buffers from the buffer pool that should no
     394             :      * longer exist after truncation is complete, and then truncate the
     395             :      * corresponding files on disk.
     396             :      */
     397        1052 :     smgrtruncate(RelationGetSmgr(rel), forks, nforks, blocks);
     398             : 
     399             :     /* We've done all the critical work, so checkpoints are OK now. */
     400        1052 :     MyProc->delayChkptFlags &= ~DELAY_CHKPT_COMPLETE;
     401             : 
     402             :     /*
     403             :      * Update upper-level FSM pages to account for the truncation. This is
     404             :      * important because the just-truncated pages were likely marked as
     405             :      * all-free, and would be preferentially selected.
     406             :      *
     407             :      * NB: There's no point in delaying checkpoints until this is done.
     408             :      * Because the FSM is not WAL-logged, we have to be prepared for the
     409             :      * possibility of corruption after a crash anyway.
     410             :      */
     411        1052 :     if (need_fsm_vacuum)
     412         270 :         FreeSpaceMapVacuumRange(rel, nblocks, InvalidBlockNumber);
     413        1052 : }
     414             : 
     415             : /*
     416             :  * RelationPreTruncate
     417             :  *      Perform AM-independent work before a physical truncation.
     418             :  *
     419             :  * If an access method's relation_nontransactional_truncate does not call
     420             :  * RelationTruncate(), it must call this before decreasing the table size.
     421             :  */
     422             : void
     423        1052 : RelationPreTruncate(Relation rel)
     424             : {
     425             :     PendingRelSync *pending;
     426             : 
     427        1052 :     if (!pendingSyncHash)
     428        1046 :         return;
     429             : 
     430           6 :     pending = hash_search(pendingSyncHash,
     431           6 :                           &(RelationGetSmgr(rel)->smgr_rlocator.locator),
     432             :                           HASH_FIND, NULL);
     433           6 :     if (pending)
     434           6 :         pending->is_truncated = true;
     435             : }
     436             : 
     437             : /*
     438             :  * Copy a fork's data, block by block.
     439             :  *
     440             :  * Note that this requires that there is no dirty data in shared buffers. If
     441             :  * it's possible that there are, callers need to flush those using
     442             :  * e.g. FlushRelationBuffers(rel).
     443             :  *
     444             :  * Also note that this is frequently called via locutions such as
     445             :  *      RelationCopyStorage(RelationGetSmgr(rel), ...);
     446             :  * That's safe only because we perform only smgr and WAL operations here.
     447             :  * If we invoked anything else, a relcache flush could cause our SMgrRelation
     448             :  * argument to become a dangling pointer.
     449             :  */
     450             : void
     451         178 : RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
     452             :                     ForkNumber forkNum, char relpersistence)
     453             : {
     454             :     PGIOAlignedBlock buf;
     455             :     Page        page;
     456             :     bool        use_wal;
     457             :     bool        copying_initfork;
     458             :     BlockNumber nblocks;
     459             :     BlockNumber blkno;
     460             : 
     461         178 :     page = (Page) buf.data;
     462             : 
     463             :     /*
     464             :      * The init fork for an unlogged relation in many respects has to be
     465             :      * treated the same as normal relation, changes need to be WAL logged and
     466             :      * it needs to be synced to disk.
     467             :      */
     468         178 :     copying_initfork = relpersistence == RELPERSISTENCE_UNLOGGED &&
     469             :         forkNum == INIT_FORKNUM;
     470             : 
     471             :     /*
     472             :      * We need to log the copied data in WAL iff WAL archiving/streaming is
     473             :      * enabled AND it's a permanent relation.  This gives the same answer as
     474             :      * "RelationNeedsWAL(rel) || copying_initfork", because we know the
     475             :      * current operation created new relation storage.
     476             :      */
     477         194 :     use_wal = XLogIsNeeded() &&
     478          16 :         (relpersistence == RELPERSISTENCE_PERMANENT || copying_initfork);
     479             : 
     480         178 :     nblocks = smgrnblocks(src, forkNum);
     481             : 
     482        1372 :     for (blkno = 0; blkno < nblocks; blkno++)
     483             :     {
     484             :         /* If we got a cancel signal during the copy of the data, quit */
     485        1194 :         CHECK_FOR_INTERRUPTS();
     486             : 
     487        1194 :         smgrread(src, forkNum, blkno, buf.data);
     488             : 
     489        1194 :         if (!PageIsVerifiedExtended(page, blkno,
     490             :                                     PIV_LOG_WARNING | PIV_REPORT_STAT))
     491             :         {
     492             :             /*
     493             :              * For paranoia's sake, capture the file path before invoking the
     494             :              * ereport machinery.  This guards against the possibility of a
     495             :              * relcache flush caused by, e.g., an errcontext callback.
     496             :              * (errcontext callbacks shouldn't be risking any such thing, but
     497             :              * people have been known to forget that rule.)
     498             :              */
     499           0 :             char       *relpath = relpathbackend(src->smgr_rlocator.locator,
     500             :                                                  src->smgr_rlocator.backend,
     501             :                                                  forkNum);
     502             : 
     503           0 :             ereport(ERROR,
     504             :                     (errcode(ERRCODE_DATA_CORRUPTED),
     505             :                      errmsg("invalid page in block %u of relation %s",
     506             :                             blkno, relpath)));
     507             :         }
     508             : 
     509             :         /*
     510             :          * WAL-log the copied page. Unfortunately we don't know what kind of a
     511             :          * page this is, so we have to log the full page including any unused
     512             :          * space.
     513             :          */
     514        1194 :         if (use_wal)
     515         106 :             log_newpage(&dst->smgr_rlocator.locator, forkNum, blkno, page, false);
     516             : 
     517        1194 :         PageSetChecksumInplace(page, blkno);
     518             : 
     519             :         /*
     520             :          * Now write the page.  We say skipFsync = true because there's no
     521             :          * need for smgr to schedule an fsync for this write; we'll do it
     522             :          * ourselves below.
     523             :          */
     524        1194 :         smgrextend(dst, forkNum, blkno, buf.data, true);
     525             :     }
     526             : 
     527             :     /*
     528             :      * When we WAL-logged rel pages, we must nonetheless fsync them.  The
     529             :      * reason is that since we're copying outside shared buffers, a CHECKPOINT
     530             :      * occurring during the copy has no way to flush the previously written
     531             :      * data to disk (indeed it won't know the new rel even exists).  A crash
     532             :      * later on would replay WAL from the checkpoint, therefore it wouldn't
     533             :      * replay our earlier WAL entries. If we do not fsync those pages here,
     534             :      * they might still not be on disk when the crash occurs.
     535             :      */
     536         178 :     if (use_wal || copying_initfork)
     537         100 :         smgrimmedsync(dst, forkNum);
     538         178 : }
     539             : 
     540             : /*
     541             :  * RelFileLocatorSkippingWAL
     542             :  *      Check if a BM_PERMANENT relfilelocator is using WAL.
     543             :  *
     544             :  * Changes to certain relations must not write WAL; see "Skipping WAL for
     545             :  * New RelFileLocator" in src/backend/access/transam/README.  Though it is
     546             :  * known from Relation efficiently, this function is intended for the code
     547             :  * paths not having access to Relation.
     548             :  */
     549             : bool
     550      102012 : RelFileLocatorSkippingWAL(RelFileLocator rlocator)
     551             : {
     552      105304 :     if (!pendingSyncHash ||
     553        3292 :         hash_search(pendingSyncHash, &rlocator, HASH_FIND, NULL) == NULL)
     554      101712 :         return false;
     555             : 
     556         300 :     return true;
     557             : }
     558             : 
     559             : /*
     560             :  * EstimatePendingSyncsSpace
     561             :  *      Estimate space needed to pass syncs to parallel workers.
     562             :  */
     563             : Size
     564         804 : EstimatePendingSyncsSpace(void)
     565             : {
     566             :     long        entries;
     567             : 
     568         804 :     entries = pendingSyncHash ? hash_get_num_entries(pendingSyncHash) : 0;
     569         804 :     return mul_size(1 + entries, sizeof(RelFileLocator));
     570             : }
     571             : 
     572             : /*
     573             :  * SerializePendingSyncs
     574             :  *      Serialize syncs for parallel workers.
     575             :  */
     576             : void
     577         804 : SerializePendingSyncs(Size maxSize, char *startAddress)
     578             : {
     579             :     HTAB       *tmphash;
     580             :     HASHCTL     ctl;
     581             :     HASH_SEQ_STATUS scan;
     582             :     PendingRelSync *sync;
     583             :     PendingRelDelete *delete;
     584             :     RelFileLocator *src;
     585         804 :     RelFileLocator *dest = (RelFileLocator *) startAddress;
     586             : 
     587         804 :     if (!pendingSyncHash)
     588         620 :         goto terminate;
     589             : 
     590             :     /* Create temporary hash to collect active relfilelocators */
     591         184 :     ctl.keysize = sizeof(RelFileLocator);
     592         184 :     ctl.entrysize = sizeof(RelFileLocator);
     593         184 :     ctl.hcxt = CurrentMemoryContext;
     594         184 :     tmphash = hash_create("tmp relfilelocators",
     595             :                           hash_get_num_entries(pendingSyncHash), &ctl,
     596             :                           HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
     597             : 
     598             :     /* collect all rlocator from pending syncs */
     599         184 :     hash_seq_init(&scan, pendingSyncHash);
     600        1622 :     while ((sync = (PendingRelSync *) hash_seq_search(&scan)))
     601        1438 :         (void) hash_search(tmphash, &sync->rlocator, HASH_ENTER, NULL);
     602             : 
     603             :     /* remove deleted rnodes */
     604        1944 :     for (delete = pendingDeletes; delete != NULL; delete = delete->next)
     605        1760 :         if (delete->atCommit)
     606         312 :             (void) hash_search(tmphash, &delete->rlocator,
     607             :                                HASH_REMOVE, NULL);
     608             : 
     609         184 :     hash_seq_init(&scan, tmphash);
     610        1318 :     while ((src = (RelFileLocator *) hash_seq_search(&scan)))
     611        1134 :         *dest++ = *src;
     612             : 
     613         184 :     hash_destroy(tmphash);
     614             : 
     615         804 : terminate:
     616         804 :     MemSet(dest, 0, sizeof(RelFileLocator));
     617         804 : }
     618             : 
     619             : /*
     620             :  * RestorePendingSyncs
     621             :  *      Restore syncs within a parallel worker.
     622             :  *
     623             :  * RelationNeedsWAL() and RelFileLocatorSkippingWAL() must offer the correct
     624             :  * answer to parallel workers.  Only smgrDoPendingSyncs() reads the
     625             :  * is_truncated field, at end of transaction.  Hence, don't restore it.
     626             :  */
     627             : void
     628        2590 : RestorePendingSyncs(char *startAddress)
     629             : {
     630             :     RelFileLocator *rlocator;
     631             : 
     632             :     Assert(pendingSyncHash == NULL);
     633        6174 :     for (rlocator = (RelFileLocator *) startAddress; rlocator->relNumber != 0;
     634        3584 :          rlocator++)
     635        3584 :         AddPendingSync(rlocator);
     636        2590 : }
     637             : 
     638             : /*
     639             :  *  smgrDoPendingDeletes() -- Take care of relation deletes at end of xact.
     640             :  *
     641             :  * This also runs when aborting a subxact; we want to clean up a failed
     642             :  * subxact immediately.
     643             :  *
     644             :  * Note: It's possible that we're being asked to remove a relation that has
     645             :  * no physical storage in any fork. In particular, it's possible that we're
     646             :  * cleaning up an old temporary relation for which RemovePgTempFiles has
     647             :  * already recovered the physical storage.
     648             :  */
     649             : void
     650      521874 : smgrDoPendingDeletes(bool isCommit)
     651             : {
     652      521874 :     int         nestLevel = GetCurrentTransactionNestLevel();
     653             :     PendingRelDelete *pending;
     654             :     PendingRelDelete *prev;
     655             :     PendingRelDelete *next;
     656      521874 :     int         nrels = 0,
     657      521874 :                 maxrels = 0;
     658      521874 :     SMgrRelation *srels = NULL;
     659             : 
     660      521874 :     prev = NULL;
     661      686216 :     for (pending = pendingDeletes; pending != NULL; pending = next)
     662             :     {
     663      164342 :         next = pending->next;
     664      164342 :         if (pending->nestLevel < nestLevel)
     665             :         {
     666             :             /* outer-level entries should not be processed yet */
     667        8038 :             prev = pending;
     668             :         }
     669             :         else
     670             :         {
     671             :             /* unlink list entry first, so we don't retry on failure */
     672      156304 :             if (prev)
     673           0 :                 prev->next = next;
     674             :             else
     675      156304 :                 pendingDeletes = next;
     676             :             /* do deletion if called for */
     677      156304 :             if (pending->atCommit == isCommit)
     678             :             {
     679             :                 SMgrRelation srel;
     680             : 
     681       63142 :                 srel = smgropen(pending->rlocator, pending->backend);
     682             : 
     683             :                 /* allocate the initial array, or extend it, if needed */
     684       63142 :                 if (maxrels == 0)
     685             :                 {
     686       17956 :                     maxrels = 8;
     687       17956 :                     srels = palloc(sizeof(SMgrRelation) * maxrels);
     688             :                 }
     689       45186 :                 else if (maxrels <= nrels)
     690             :                 {
     691        1604 :                     maxrels *= 2;
     692        1604 :                     srels = repalloc(srels, sizeof(SMgrRelation) * maxrels);
     693             :                 }
     694             : 
     695       63142 :                 srels[nrels++] = srel;
     696             :             }
     697             :             /* must explicitly free the list entry */
     698      156304 :             pfree(pending);
     699             :             /* prev does not change */
     700             :         }
     701             :     }
     702             : 
     703      521874 :     if (nrels > 0)
     704             :     {
     705       17956 :         smgrdounlinkall(srels, nrels, false);
     706             : 
     707       81098 :         for (int i = 0; i < nrels; i++)
     708       63142 :             smgrclose(srels[i]);
     709             : 
     710       17956 :         pfree(srels);
     711             :     }
     712      521874 : }
     713             : 
     714             : /*
     715             :  *  smgrDoPendingSyncs() -- Take care of relation syncs at end of xact.
     716             :  */
     717             : void
     718      513938 : smgrDoPendingSyncs(bool isCommit, bool isParallelWorker)
     719             : {
     720             :     PendingRelDelete *pending;
     721      513938 :     int         nrels = 0,
     722      513938 :                 maxrels = 0;
     723      513938 :     SMgrRelation *srels = NULL;
     724             :     HASH_SEQ_STATUS scan;
     725             :     PendingRelSync *pendingsync;
     726             : 
     727             :     Assert(GetCurrentTransactionNestLevel() == 1);
     728             : 
     729      513938 :     if (!pendingSyncHash)
     730      502812 :         return;                 /* no relation needs sync */
     731             : 
     732             :     /* Abort -- just throw away all pending syncs */
     733       11944 :     if (!isCommit)
     734             :     {
     735         424 :         pendingSyncHash = NULL;
     736         424 :         return;
     737             :     }
     738             : 
     739             :     AssertPendingSyncs_RelationCache();
     740             : 
     741             :     /* Parallel worker -- just throw away all pending syncs */
     742       11520 :     if (isParallelWorker)
     743             :     {
     744         394 :         pendingSyncHash = NULL;
     745         394 :         return;
     746             :     }
     747             : 
     748             :     /* Skip syncing nodes that smgrDoPendingDeletes() will delete. */
     749       36790 :     for (pending = pendingDeletes; pending != NULL; pending = pending->next)
     750       25664 :         if (pending->atCommit)
     751        4546 :             (void) hash_search(pendingSyncHash, &pending->rlocator,
     752             :                                HASH_REMOVE, NULL);
     753             : 
     754       11126 :     hash_seq_init(&scan, pendingSyncHash);
     755       71152 :     while ((pendingsync = (PendingRelSync *) hash_seq_search(&scan)))
     756             :     {
     757             :         ForkNumber  fork;
     758             :         BlockNumber nblocks[MAX_FORKNUM + 1];
     759       60026 :         BlockNumber total_blocks = 0;
     760             :         SMgrRelation srel;
     761             : 
     762       60026 :         srel = smgropen(pendingsync->rlocator, InvalidBackendId);
     763             : 
     764             :         /*
     765             :          * We emit newpage WAL records for smaller relations.
     766             :          *
     767             :          * Small WAL records have a chance to be flushed along with other
     768             :          * backends' WAL records.  We emit WAL records instead of syncing for
     769             :          * files that are smaller than a certain threshold, expecting faster
     770             :          * commit.  The threshold is defined by the GUC wal_skip_threshold.
     771             :          */
     772       60026 :         if (!pendingsync->is_truncated)
     773             :         {
     774      300130 :             for (fork = 0; fork <= MAX_FORKNUM; fork++)
     775             :             {
     776      240104 :                 if (smgrexists(srel, fork))
     777             :                 {
     778       73260 :                     BlockNumber n = smgrnblocks(srel, fork);
     779             : 
     780             :                     /* we shouldn't come here for unlogged relations */
     781             :                     Assert(fork != INIT_FORKNUM);
     782       73260 :                     nblocks[fork] = n;
     783       73260 :                     total_blocks += n;
     784             :                 }
     785             :                 else
     786      166844 :                     nblocks[fork] = InvalidBlockNumber;
     787             :             }
     788             :         }
     789             : 
     790             :         /*
     791             :          * Sync file or emit WAL records for its contents.
     792             :          *
     793             :          * Although we emit WAL record if the file is small enough, do file
     794             :          * sync regardless of the size if the file has experienced a
     795             :          * truncation. It is because the file would be followed by trailing
     796             :          * garbage blocks after a crash recovery if, while a past longer file
     797             :          * had been flushed out, we omitted syncing-out of the file and
     798             :          * emitted WAL instead.  You might think that we could choose WAL if
     799             :          * the current main fork is longer than ever, but there's a case where
     800             :          * main fork is longer than ever but FSM fork gets shorter.
     801             :          */
     802       60026 :         if (pendingsync->is_truncated ||
     803       60026 :             total_blocks * BLCKSZ / 1024 >= wal_skip_threshold)
     804             :         {
     805             :             /* allocate the initial array, or extend it, if needed */
     806          34 :             if (maxrels == 0)
     807             :             {
     808          22 :                 maxrels = 8;
     809          22 :                 srels = palloc(sizeof(SMgrRelation) * maxrels);
     810             :             }
     811          12 :             else if (maxrels <= nrels)
     812             :             {
     813           0 :                 maxrels *= 2;
     814           0 :                 srels = repalloc(srels, sizeof(SMgrRelation) * maxrels);
     815             :             }
     816             : 
     817          34 :             srels[nrels++] = srel;
     818             :         }
     819             :         else
     820             :         {
     821             :             /* Emit WAL records for all blocks.  The file is small enough. */
     822      299960 :             for (fork = 0; fork <= MAX_FORKNUM; fork++)
     823             :             {
     824      239968 :                 int         n = nblocks[fork];
     825             :                 Relation    rel;
     826             : 
     827      239968 :                 if (!BlockNumberIsValid(n))
     828      166746 :                     continue;
     829             : 
     830             :                 /*
     831             :                  * Emit WAL for the whole file.  Unfortunately we don't know
     832             :                  * what kind of a page this is, so we have to log the full
     833             :                  * page including any unused space.  ReadBufferExtended()
     834             :                  * counts some pgstat events; unfortunately, we discard them.
     835             :                  */
     836       73222 :                 rel = CreateFakeRelcacheEntry(srel->smgr_rlocator.locator);
     837       73222 :                 log_newpage_range(rel, fork, 0, n, false);
     838       73222 :                 FreeFakeRelcacheEntry(rel);
     839             :             }
     840             :         }
     841             :     }
     842             : 
     843       11126 :     pendingSyncHash = NULL;
     844             : 
     845       11126 :     if (nrels > 0)
     846             :     {
     847          22 :         smgrdosyncall(srels, nrels);
     848          22 :         pfree(srels);
     849             :     }
     850             : }
     851             : 
     852             : /*
     853             :  * smgrGetPendingDeletes() -- Get a list of non-temp relations to be deleted.
     854             :  *
     855             :  * The return value is the number of relations scheduled for termination.
     856             :  * *ptr is set to point to a freshly-palloc'd array of RelFileLocators.
     857             :  * If there are no relations to be deleted, *ptr is set to NULL.
     858             :  *
     859             :  * Only non-temporary relations are included in the returned list.  This is OK
     860             :  * because the list is used only in contexts where temporary relations don't
     861             :  * matter: we're either writing to the two-phase state file (and transactions
     862             :  * that have touched temp tables can't be prepared) or we're writing to xlog
     863             :  * (and all temporary files will be zapped if we restart anyway, so no need
     864             :  * for redo to do it also).
     865             :  *
     866             :  * Note that the list does not include anything scheduled for termination
     867             :  * by upper-level transactions.
     868             :  */
     869             : int
     870      480274 : smgrGetPendingDeletes(bool forCommit, RelFileLocator **ptr)
     871             : {
     872      480274 :     int         nestLevel = GetCurrentTransactionNestLevel();
     873             :     int         nrels;
     874             :     RelFileLocator *rptr;
     875             :     PendingRelDelete *pending;
     876             : 
     877      480274 :     nrels = 0;
     878      641988 :     for (pending = pendingDeletes; pending != NULL; pending = pending->next)
     879             :     {
     880      161714 :         if (pending->nestLevel >= nestLevel && pending->atCommit == forCommit
     881       63272 :             && pending->backend == InvalidBackendId)
     882       57616 :             nrels++;
     883             :     }
     884      480274 :     if (nrels == 0)
     885             :     {
     886      463692 :         *ptr = NULL;
     887      463692 :         return 0;
     888             :     }
     889       16582 :     rptr = (RelFileLocator *) palloc(nrels * sizeof(RelFileLocator));
     890       16582 :     *ptr = rptr;
     891       85972 :     for (pending = pendingDeletes; pending != NULL; pending = pending->next)
     892             :     {
     893       69390 :         if (pending->nestLevel >= nestLevel && pending->atCommit == forCommit
     894       57734 :             && pending->backend == InvalidBackendId)
     895             :         {
     896       57616 :             *rptr = pending->rlocator;
     897       57616 :             rptr++;
     898             :         }
     899             :     }
     900       16582 :     return nrels;
     901             : }
     902             : 
     903             : /*
     904             :  *  PostPrepare_smgr -- Clean up after a successful PREPARE
     905             :  *
     906             :  * What we have to do here is throw away the in-memory state about pending
     907             :  * relation deletes.  It's all been recorded in the 2PC state file and
     908             :  * it's no longer smgr's job to worry about it.
     909             :  */
     910             : void
     911         752 : PostPrepare_smgr(void)
     912             : {
     913             :     PendingRelDelete *pending;
     914             :     PendingRelDelete *next;
     915             : 
     916         882 :     for (pending = pendingDeletes; pending != NULL; pending = next)
     917             :     {
     918         130 :         next = pending->next;
     919         130 :         pendingDeletes = next;
     920             :         /* must explicitly free the list entry */
     921         130 :         pfree(pending);
     922             :     }
     923         752 : }
     924             : 
     925             : 
     926             : /*
     927             :  * AtSubCommit_smgr() --- Take care of subtransaction commit.
     928             :  *
     929             :  * Reassign all items in the pending-deletes list to the parent transaction.
     930             :  */
     931             : void
     932        8890 : AtSubCommit_smgr(void)
     933             : {
     934        8890 :     int         nestLevel = GetCurrentTransactionNestLevel();
     935             :     PendingRelDelete *pending;
     936             : 
     937        9360 :     for (pending = pendingDeletes; pending != NULL; pending = pending->next)
     938             :     {
     939         470 :         if (pending->nestLevel >= nestLevel)
     940         210 :             pending->nestLevel = nestLevel - 1;
     941             :     }
     942        8890 : }
     943             : 
     944             : /*
     945             :  * AtSubAbort_smgr() --- Take care of subtransaction abort.
     946             :  *
     947             :  * Delete created relations and forget about deleted relations.
     948             :  * We can execute these operations immediately because we know this
     949             :  * subtransaction will not commit.
     950             :  */
     951             : void
     952        9092 : AtSubAbort_smgr(void)
     953             : {
     954        9092 :     smgrDoPendingDeletes(false);
     955        9092 : }
     956             : 
     957             : void
     958       25396 : smgr_redo(XLogReaderState *record)
     959             : {
     960       25396 :     XLogRecPtr  lsn = record->EndRecPtr;
     961       25396 :     uint8       info = XLogRecGetInfo(record) & ~XLR_INFO_MASK;
     962             : 
     963             :     /* Backup blocks are not used in smgr records */
     964             :     Assert(!XLogRecHasAnyBlockRefs(record));
     965             : 
     966       25396 :     if (info == XLOG_SMGR_CREATE)
     967             :     {
     968       25304 :         xl_smgr_create *xlrec = (xl_smgr_create *) XLogRecGetData(record);
     969             :         SMgrRelation reln;
     970             : 
     971       25304 :         reln = smgropen(xlrec->rlocator, InvalidBackendId);
     972       25304 :         smgrcreate(reln, xlrec->forkNum, true);
     973             :     }
     974          92 :     else if (info == XLOG_SMGR_TRUNCATE)
     975             :     {
     976          92 :         xl_smgr_truncate *xlrec = (xl_smgr_truncate *) XLogRecGetData(record);
     977             :         SMgrRelation reln;
     978             :         Relation    rel;
     979             :         ForkNumber  forks[MAX_FORKNUM];
     980             :         BlockNumber blocks[MAX_FORKNUM];
     981          92 :         int         nforks = 0;
     982          92 :         bool        need_fsm_vacuum = false;
     983             : 
     984          92 :         reln = smgropen(xlrec->rlocator, InvalidBackendId);
     985             : 
     986             :         /*
     987             :          * Forcibly create relation if it doesn't exist (which suggests that
     988             :          * it was dropped somewhere later in the WAL sequence).  As in
     989             :          * XLogReadBufferForRedo, we prefer to recreate the rel and replay the
     990             :          * log as best we can until the drop is seen.
     991             :          */
     992          92 :         smgrcreate(reln, MAIN_FORKNUM, true);
     993             : 
     994             :         /*
     995             :          * Before we perform the truncation, update minimum recovery point to
     996             :          * cover this WAL record. Once the relation is truncated, there's no
     997             :          * going back. The buffer manager enforces the WAL-first rule for
     998             :          * normal updates to relation files, so that the minimum recovery
     999             :          * point is always updated before the corresponding change in the data
    1000             :          * file is flushed to disk. We have to do the same manually here.
    1001             :          *
    1002             :          * Doing this before the truncation means that if the truncation fails
    1003             :          * for some reason, you cannot start up the system even after restart,
    1004             :          * until you fix the underlying situation so that the truncation will
    1005             :          * succeed. Alternatively, we could update the minimum recovery point
    1006             :          * after truncation, but that would leave a small window where the
    1007             :          * WAL-first rule could be violated.
    1008             :          */
    1009          92 :         XLogFlush(lsn);
    1010             : 
    1011             :         /* Prepare for truncation of MAIN fork */
    1012          92 :         if ((xlrec->flags & SMGR_TRUNCATE_HEAP) != 0)
    1013             :         {
    1014          92 :             forks[nforks] = MAIN_FORKNUM;
    1015          92 :             blocks[nforks] = xlrec->blkno;
    1016          92 :             nforks++;
    1017             : 
    1018             :             /* Also tell xlogutils.c about it */
    1019          92 :             XLogTruncateRelation(xlrec->rlocator, MAIN_FORKNUM, xlrec->blkno);
    1020             :         }
    1021             : 
    1022             :         /* Prepare for truncation of FSM and VM too */
    1023          92 :         rel = CreateFakeRelcacheEntry(xlrec->rlocator);
    1024             : 
    1025         184 :         if ((xlrec->flags & SMGR_TRUNCATE_FSM) != 0 &&
    1026          92 :             smgrexists(reln, FSM_FORKNUM))
    1027             :         {
    1028          56 :             blocks[nforks] = FreeSpaceMapPrepareTruncateRel(rel, xlrec->blkno);
    1029          56 :             if (BlockNumberIsValid(blocks[nforks]))
    1030             :             {
    1031          56 :                 forks[nforks] = FSM_FORKNUM;
    1032          56 :                 nforks++;
    1033          56 :                 need_fsm_vacuum = true;
    1034             :             }
    1035             :         }
    1036         184 :         if ((xlrec->flags & SMGR_TRUNCATE_VM) != 0 &&
    1037          92 :             smgrexists(reln, VISIBILITYMAP_FORKNUM))
    1038             :         {
    1039          46 :             blocks[nforks] = visibilitymap_prepare_truncate(rel, xlrec->blkno);
    1040          46 :             if (BlockNumberIsValid(blocks[nforks]))
    1041             :             {
    1042          14 :                 forks[nforks] = VISIBILITYMAP_FORKNUM;
    1043          14 :                 nforks++;
    1044             :             }
    1045             :         }
    1046             : 
    1047             :         /* Do the real work to truncate relation forks */
    1048          92 :         if (nforks > 0)
    1049          92 :             smgrtruncate(reln, forks, nforks, blocks);
    1050             : 
    1051             :         /*
    1052             :          * Update upper-level FSM pages to account for the truncation. This is
    1053             :          * important because the just-truncated pages were likely marked as
    1054             :          * all-free, and would be preferentially selected.
    1055             :          */
    1056          92 :         if (need_fsm_vacuum)
    1057          56 :             FreeSpaceMapVacuumRange(rel, xlrec->blkno,
    1058             :                                     InvalidBlockNumber);
    1059             : 
    1060          92 :         FreeFakeRelcacheEntry(rel);
    1061             :     }
    1062             :     else
    1063           0 :         elog(PANIC, "smgr_redo: unknown op code %u", info);
    1064       25396 : }

Generated by: LCOV version 1.14