LCOV - code coverage report
Current view: top level - src/backend/access/transam - varsup.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 111 139 79.9 %
Date: 2019-11-13 22:07:24 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * varsup.c
       4             :  *    postgres OID & XID variables support routines
       5             :  *
       6             :  * Copyright (c) 2000-2019, PostgreSQL Global Development Group
       7             :  *
       8             :  * IDENTIFICATION
       9             :  *    src/backend/access/transam/varsup.c
      10             :  *
      11             :  *-------------------------------------------------------------------------
      12             :  */
      13             : 
      14             : #include "postgres.h"
      15             : 
      16             : #include "access/clog.h"
      17             : #include "access/commit_ts.h"
      18             : #include "access/subtrans.h"
      19             : #include "access/transam.h"
      20             : #include "access/xact.h"
      21             : #include "access/xlog.h"
      22             : #include "commands/dbcommands.h"
      23             : #include "miscadmin.h"
      24             : #include "postmaster/autovacuum.h"
      25             : #include "storage/pmsignal.h"
      26             : #include "storage/proc.h"
      27             : #include "utils/syscache.h"
      28             : 
      29             : 
      30             : /* Number of OIDs to prefetch (preallocate) per XLOG write */
      31             : #define VAR_OID_PREFETCH        8192
      32             : 
      33             : /* pointer to "variable cache" in shared memory (set up by shmem.c) */
      34             : VariableCache ShmemVariableCache = NULL;
      35             : 
      36             : 
      37             : /*
      38             :  * Allocate the next FullTransactionId for a new transaction or
      39             :  * subtransaction.
      40             :  *
      41             :  * The new XID is also stored into MyPgXact before returning.
      42             :  *
      43             :  * Note: when this is called, we are actually already inside a valid
      44             :  * transaction, since XIDs are now not allocated until the transaction
      45             :  * does something.  So it is safe to do a database lookup if we want to
      46             :  * issue a warning about XID wrap.
      47             :  */
      48             : FullTransactionId
      49      255620 : GetNewTransactionId(bool isSubXact)
      50             : {
      51             :     FullTransactionId full_xid;
      52             :     TransactionId xid;
      53             : 
      54             :     /*
      55             :      * Workers synchronize transaction state at the beginning of each parallel
      56             :      * operation, so we can't account for new XIDs after that point.
      57             :      */
      58      255620 :     if (IsInParallelMode())
      59           0 :         elog(ERROR, "cannot assign TransactionIds during a parallel operation");
      60             : 
      61             :     /*
      62             :      * During bootstrap initialization, we return the special bootstrap
      63             :      * transaction id.
      64             :      */
      65      255620 :     if (IsBootstrapProcessingMode())
      66             :     {
      67             :         Assert(!isSubXact);
      68         322 :         MyPgXact->xid = BootstrapTransactionId;
      69         322 :         return FullTransactionIdFromEpochAndXid(0, BootstrapTransactionId);
      70             :     }
      71             : 
      72             :     /* safety check, we should never get this far in a HS standby */
      73      255298 :     if (RecoveryInProgress())
      74           0 :         elog(ERROR, "cannot assign TransactionIds during recovery");
      75             : 
      76      255298 :     LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
      77             : 
      78      255298 :     full_xid = ShmemVariableCache->nextFullXid;
      79      255298 :     xid = XidFromFullTransactionId(full_xid);
      80             : 
      81             :     /*----------
      82             :      * Check to see if it's safe to assign another XID.  This protects against
      83             :      * catastrophic data loss due to XID wraparound.  The basic rules are:
      84             :      *
      85             :      * If we're past xidVacLimit, start trying to force autovacuum cycles.
      86             :      * If we're past xidWarnLimit, start issuing warnings.
      87             :      * If we're past xidStopLimit, refuse to execute transactions, unless
      88             :      * we are running in single-user mode (which gives an escape hatch
      89             :      * to the DBA who somehow got past the earlier defenses).
      90             :      *
      91             :      * Note that this coding also appears in GetNewMultiXactId.
      92             :      *----------
      93             :      */
      94      255298 :     if (TransactionIdFollowsOrEquals(xid, ShmemVariableCache->xidVacLimit))
      95             :     {
      96             :         /*
      97             :          * For safety's sake, we release XidGenLock while sending signals,
      98             :          * warnings, etc.  This is not so much because we care about
      99             :          * preserving concurrency in this situation, as to avoid any
     100             :          * possibility of deadlock while doing get_database_name(). First,
     101             :          * copy all the shared values we'll need in this path.
     102             :          */
     103        7756 :         TransactionId xidWarnLimit = ShmemVariableCache->xidWarnLimit;
     104        7756 :         TransactionId xidStopLimit = ShmemVariableCache->xidStopLimit;
     105        7756 :         TransactionId xidWrapLimit = ShmemVariableCache->xidWrapLimit;
     106        7756 :         Oid         oldest_datoid = ShmemVariableCache->oldestXidDB;
     107             : 
     108        7756 :         LWLockRelease(XidGenLock);
     109             : 
     110             :         /*
     111             :          * To avoid swamping the postmaster with signals, we issue the autovac
     112             :          * request only once per 64K transaction starts.  This still gives
     113             :          * plenty of chances before we get into real trouble.
     114             :          */
     115        7756 :         if (IsUnderPostmaster && (xid % 65536) == 0)
     116           0 :             SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
     117             : 
     118       15512 :         if (IsUnderPostmaster &&
     119        7756 :             TransactionIdFollowsOrEquals(xid, xidStopLimit))
     120             :         {
     121           0 :             char       *oldest_datname = get_database_name(oldest_datoid);
     122             : 
     123             :             /* complain even if that DB has disappeared */
     124           0 :             if (oldest_datname)
     125           0 :                 ereport(ERROR,
     126             :                         (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     127             :                          errmsg("database is not accepting commands to avoid wraparound data loss in database \"%s\"",
     128             :                                 oldest_datname),
     129             :                          errhint("Stop the postmaster and vacuum that database in single-user mode.\n"
     130             :                                  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
     131             :             else
     132           0 :                 ereport(ERROR,
     133             :                         (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
     134             :                          errmsg("database is not accepting commands to avoid wraparound data loss in database with OID %u",
     135             :                                 oldest_datoid),
     136             :                          errhint("Stop the postmaster and vacuum that database in single-user mode.\n"
     137             :                                  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
     138             :         }
     139        7756 :         else if (TransactionIdFollowsOrEquals(xid, xidWarnLimit))
     140             :         {
     141           0 :             char       *oldest_datname = get_database_name(oldest_datoid);
     142             : 
     143             :             /* complain even if that DB has disappeared */
     144           0 :             if (oldest_datname)
     145           0 :                 ereport(WARNING,
     146             :                         (errmsg("database \"%s\" must be vacuumed within %u transactions",
     147             :                                 oldest_datname,
     148             :                                 xidWrapLimit - xid),
     149             :                          errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
     150             :                                  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
     151             :             else
     152           0 :                 ereport(WARNING,
     153             :                         (errmsg("database with OID %u must be vacuumed within %u transactions",
     154             :                                 oldest_datoid,
     155             :                                 xidWrapLimit - xid),
     156             :                          errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
     157             :                                  "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
     158             :         }
     159             : 
     160             :         /* Re-acquire lock and start over */
     161        7756 :         LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
     162        7756 :         full_xid = ShmemVariableCache->nextFullXid;
     163        7756 :         xid = XidFromFullTransactionId(full_xid);
     164             :     }
     165             : 
     166             :     /*
     167             :      * If we are allocating the first XID of a new page of the commit log,
     168             :      * zero out that commit-log page before returning. We must do this while
     169             :      * holding XidGenLock, else another xact could acquire and commit a later
     170             :      * XID before we zero the page.  Fortunately, a page of the commit log
     171             :      * holds 32K or more transactions, so we don't have to do this very often.
     172             :      *
     173             :      * Extend pg_subtrans and pg_commit_ts too.
     174             :      */
     175      255298 :     ExtendCLOG(xid);
     176      255298 :     ExtendCommitTs(xid);
     177      255298 :     ExtendSUBTRANS(xid);
     178             : 
     179             :     /*
     180             :      * Now advance the nextFullXid counter.  This must not happen until after
     181             :      * we have successfully completed ExtendCLOG() --- if that routine fails,
     182             :      * we want the next incoming transaction to try it again.  We cannot
     183             :      * assign more XIDs until there is CLOG space for them.
     184             :      */
     185      255298 :     FullTransactionIdAdvance(&ShmemVariableCache->nextFullXid);
     186             : 
     187             :     /*
     188             :      * We must store the new XID into the shared ProcArray before releasing
     189             :      * XidGenLock.  This ensures that every active XID older than
     190             :      * latestCompletedXid is present in the ProcArray, which is essential for
     191             :      * correct OldestXmin tracking; see src/backend/access/transam/README.
     192             :      *
     193             :      * Note that readers of PGXACT xid fields should be careful to fetch the
     194             :      * value only once, rather than assume they can read a value multiple
     195             :      * times and get the same answer each time.  Note we are assuming that
     196             :      * TransactionId and int fetch/store are atomic.
     197             :      *
     198             :      * The same comments apply to the subxact xid count and overflow fields.
     199             :      *
     200             :      * Use of a write barrier prevents dangerous code rearrangement in this
     201             :      * function; other backends could otherwise e.g. be examining my subxids
     202             :      * info concurrently, and we don't want them to see an invalid
     203             :      * intermediate state, such as an incremented nxids before the array entry
     204             :      * is filled.
     205             :      *
     206             :      * Other processes that read nxids should do so before reading xids
     207             :      * elements with a pg_read_barrier() in between, so that they can be sure
     208             :      * not to read an uninitialized array element; see
     209             :      * src/backend/storage/lmgr/README.barrier.
     210             :      *
     211             :      * If there's no room to fit a subtransaction XID into PGPROC, set the
     212             :      * cache-overflowed flag instead.  This forces readers to look in
     213             :      * pg_subtrans to map subtransaction XIDs up to top-level XIDs. There is a
     214             :      * race-condition window, in that the new XID will not appear as running
     215             :      * until its parent link has been placed into pg_subtrans. However, that
     216             :      * will happen before anyone could possibly have a reason to inquire about
     217             :      * the status of the XID, so it seems OK.  (Snapshots taken during this
     218             :      * window *will* include the parent XID, so they will deliver the correct
     219             :      * answer later on when someone does have a reason to inquire.)
     220             :      */
     221      255298 :     if (!isSubXact)
     222      251280 :         MyPgXact->xid = xid; /* LWLockRelease acts as barrier */
     223             :     else
     224             :     {
     225        4018 :         int         nxids = MyPgXact->nxids;
     226             : 
     227        4018 :         if (nxids < PGPROC_MAX_CACHED_SUBXIDS)
     228             :         {
     229        1586 :             MyProc->subxids.xids[nxids] = xid;
     230        1586 :             pg_write_barrier();
     231        1586 :             MyPgXact->nxids = nxids + 1;
     232             :         }
     233             :         else
     234        2432 :             MyPgXact->overflowed = true;
     235             :     }
     236             : 
     237      255298 :     LWLockRelease(XidGenLock);
     238             : 
     239      255298 :     return full_xid;
     240             : }
     241             : 
     242             : /*
     243             :  * Read nextFullXid but don't allocate it.
     244             :  */
     245             : FullTransactionId
     246       99784 : ReadNextFullTransactionId(void)
     247             : {
     248             :     FullTransactionId fullXid;
     249             : 
     250       99784 :     LWLockAcquire(XidGenLock, LW_SHARED);
     251       99784 :     fullXid = ShmemVariableCache->nextFullXid;
     252       99784 :     LWLockRelease(XidGenLock);
     253             : 
     254       99784 :     return fullXid;
     255             : }
     256             : 
     257             : /*
     258             :  * Advance nextFullXid to the value after a given xid.  The epoch is inferred.
     259             :  * This must only be called during recovery or from two-phase start-up code.
     260             :  */
     261             : void
     262      245416 : AdvanceNextFullTransactionIdPastXid(TransactionId xid)
     263             : {
     264             :     FullTransactionId newNextFullXid;
     265             :     TransactionId next_xid;
     266             :     uint32      epoch;
     267             : 
     268             :     /*
     269             :      * It is safe to read nextFullXid without a lock, because this is only
     270             :      * called from the startup process or single-process mode, meaning that no
     271             :      * other process can modify it.
     272             :      */
     273             :     Assert(AmStartupProcess() || !IsUnderPostmaster);
     274             : 
     275             :     /* Fast return if this isn't an xid high enough to move the needle. */
     276      245416 :     next_xid = XidFromFullTransactionId(ShmemVariableCache->nextFullXid);
     277      245416 :     if (!TransactionIdFollowsOrEquals(xid, next_xid))
     278      240224 :         return;
     279             : 
     280             :     /*
     281             :      * Compute the FullTransactionId that comes after the given xid.  To do
     282             :      * this, we preserve the existing epoch, but detect when we've wrapped
     283             :      * into a new epoch.  This is necessary because WAL records and 2PC state
     284             :      * currently contain 32 bit xids.  The wrap logic is safe in those cases
     285             :      * because the span of active xids cannot exceed one epoch at any given
     286             :      * point in the WAL stream.
     287             :      */
     288        5192 :     TransactionIdAdvance(xid);
     289        5192 :     epoch = EpochFromFullTransactionId(ShmemVariableCache->nextFullXid);
     290        5192 :     if (unlikely(xid < next_xid))
     291           0 :         ++epoch;
     292        5192 :     newNextFullXid = FullTransactionIdFromEpochAndXid(epoch, xid);
     293             : 
     294             :     /*
     295             :      * We still need to take a lock to modify the value when there are
     296             :      * concurrent readers.
     297             :      */
     298        5192 :     LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
     299        5192 :     ShmemVariableCache->nextFullXid = newNextFullXid;
     300        5192 :     LWLockRelease(XidGenLock);
     301             : }
     302             : 
     303             : /*
     304             :  * Advance the cluster-wide value for the oldest valid clog entry.
     305             :  *
     306             :  * We must acquire CLogTruncationLock to advance the oldestClogXid. It's not
     307             :  * necessary to hold the lock during the actual clog truncation, only when we
     308             :  * advance the limit, as code looking up arbitrary xids is required to hold
     309             :  * CLogTruncationLock from when it tests oldestClogXid through to when it
     310             :  * completes the clog lookup.
     311             :  */
     312             : void
     313        1514 : AdvanceOldestClogXid(TransactionId oldest_datfrozenxid)
     314             : {
     315        1514 :     LWLockAcquire(CLogTruncationLock, LW_EXCLUSIVE);
     316        1514 :     if (TransactionIdPrecedes(ShmemVariableCache->oldestClogXid,
     317             :                               oldest_datfrozenxid))
     318             :     {
     319        1192 :         ShmemVariableCache->oldestClogXid = oldest_datfrozenxid;
     320             :     }
     321        1514 :     LWLockRelease(CLogTruncationLock);
     322        1514 : }
     323             : 
     324             : /*
     325             :  * Determine the last safe XID to allocate using the currently oldest
     326             :  * datfrozenxid (ie, the oldest XID that might exist in any database
     327             :  * of our cluster), and the OID of the (or a) database with that value.
     328             :  */
     329             : void
     330        2242 : SetTransactionIdLimit(TransactionId oldest_datfrozenxid, Oid oldest_datoid)
     331             : {
     332             :     TransactionId xidVacLimit;
     333             :     TransactionId xidWarnLimit;
     334             :     TransactionId xidStopLimit;
     335             :     TransactionId xidWrapLimit;
     336             :     TransactionId curXid;
     337             : 
     338             :     Assert(TransactionIdIsNormal(oldest_datfrozenxid));
     339             : 
     340             :     /*
     341             :      * The place where we actually get into deep trouble is halfway around
     342             :      * from the oldest potentially-existing XID.  (This calculation is
     343             :      * probably off by one or two counts, because the special XIDs reduce the
     344             :      * size of the loop a little bit.  But we throw in plenty of slop below,
     345             :      * so it doesn't matter.)
     346             :      */
     347        2242 :     xidWrapLimit = oldest_datfrozenxid + (MaxTransactionId >> 1);
     348        2242 :     if (xidWrapLimit < FirstNormalTransactionId)
     349           0 :         xidWrapLimit += FirstNormalTransactionId;
     350             : 
     351             :     /*
     352             :      * We'll refuse to continue assigning XIDs in interactive mode once we get
     353             :      * within 1M transactions of data loss.  This leaves lots of room for the
     354             :      * DBA to fool around fixing things in a standalone backend, while not
     355             :      * being significant compared to total XID space. (Note that since
     356             :      * vacuuming requires one transaction per table cleaned, we had better be
     357             :      * sure there's lots of XIDs left...)
     358             :      */
     359        2242 :     xidStopLimit = xidWrapLimit - 1000000;
     360        2242 :     if (xidStopLimit < FirstNormalTransactionId)
     361           0 :         xidStopLimit -= FirstNormalTransactionId;
     362             : 
     363             :     /*
     364             :      * We'll start complaining loudly when we get within 10M transactions of
     365             :      * the stop point.  This is kind of arbitrary, but if you let your gas
     366             :      * gauge get down to 1% of full, would you be looking for the next gas
     367             :      * station?  We need to be fairly liberal about this number because there
     368             :      * are lots of scenarios where most transactions are done by automatic
     369             :      * clients that won't pay attention to warnings. (No, we're not gonna make
     370             :      * this configurable.  If you know enough to configure it, you know enough
     371             :      * to not get in this kind of trouble in the first place.)
     372             :      */
     373        2242 :     xidWarnLimit = xidStopLimit - 10000000;
     374        2242 :     if (xidWarnLimit < FirstNormalTransactionId)
     375           0 :         xidWarnLimit -= FirstNormalTransactionId;
     376             : 
     377             :     /*
     378             :      * We'll start trying to force autovacuums when oldest_datfrozenxid gets
     379             :      * to be more than autovacuum_freeze_max_age transactions old.
     380             :      *
     381             :      * Note: guc.c ensures that autovacuum_freeze_max_age is in a sane range,
     382             :      * so that xidVacLimit will be well before xidWarnLimit.
     383             :      *
     384             :      * Note: autovacuum_freeze_max_age is a PGC_POSTMASTER parameter so that
     385             :      * we don't have to worry about dealing with on-the-fly changes in its
     386             :      * value.  It doesn't look practical to update shared state from a GUC
     387             :      * assign hook (too many processes would try to execute the hook,
     388             :      * resulting in race conditions as well as crashes of those not connected
     389             :      * to shared memory).  Perhaps this can be improved someday.  See also
     390             :      * SetMultiXactIdLimit.
     391             :      */
     392        2242 :     xidVacLimit = oldest_datfrozenxid + autovacuum_freeze_max_age;
     393        2242 :     if (xidVacLimit < FirstNormalTransactionId)
     394           0 :         xidVacLimit += FirstNormalTransactionId;
     395             : 
     396             :     /* Grab lock for just long enough to set the new limit values */
     397        2242 :     LWLockAcquire(XidGenLock, LW_EXCLUSIVE);
     398        2242 :     ShmemVariableCache->oldestXid = oldest_datfrozenxid;
     399        2242 :     ShmemVariableCache->xidVacLimit = xidVacLimit;
     400        2242 :     ShmemVariableCache->xidWarnLimit = xidWarnLimit;
     401        2242 :     ShmemVariableCache->xidStopLimit = xidStopLimit;
     402        2242 :     ShmemVariableCache->xidWrapLimit = xidWrapLimit;
     403        2242 :     ShmemVariableCache->oldestXidDB = oldest_datoid;
     404        2242 :     curXid = XidFromFullTransactionId(ShmemVariableCache->nextFullXid);
     405        2242 :     LWLockRelease(XidGenLock);
     406             : 
     407             :     /* Log the info */
     408        2242 :     ereport(DEBUG1,
     409             :             (errmsg("transaction ID wrap limit is %u, limited by database with OID %u",
     410             :                     xidWrapLimit, oldest_datoid)));
     411             : 
     412             :     /*
     413             :      * If past the autovacuum force point, immediately signal an autovac
     414             :      * request.  The reason for this is that autovac only processes one
     415             :      * database per invocation.  Once it's finished cleaning up the oldest
     416             :      * database, it'll call here, and we'll signal the postmaster to start
     417             :      * another iteration immediately if there are still any old databases.
     418             :      */
     419        2242 :     if (TransactionIdFollowsOrEquals(curXid, xidVacLimit) &&
     420           6 :         IsUnderPostmaster && !InRecovery)
     421           6 :         SendPostmasterSignal(PMSIGNAL_START_AUTOVAC_LAUNCHER);
     422             : 
     423             :     /* Give an immediate warning if past the wrap warn point */
     424        2242 :     if (TransactionIdFollowsOrEquals(curXid, xidWarnLimit) && !InRecovery)
     425             :     {
     426             :         char       *oldest_datname;
     427             : 
     428             :         /*
     429             :          * We can be called when not inside a transaction, for example during
     430             :          * StartupXLOG().  In such a case we cannot do database access, so we
     431             :          * must just report the oldest DB's OID.
     432             :          *
     433             :          * Note: it's also possible that get_database_name fails and returns
     434             :          * NULL, for example because the database just got dropped.  We'll
     435             :          * still warn, even though the warning might now be unnecessary.
     436             :          */
     437           0 :         if (IsTransactionState())
     438           0 :             oldest_datname = get_database_name(oldest_datoid);
     439             :         else
     440           0 :             oldest_datname = NULL;
     441             : 
     442           0 :         if (oldest_datname)
     443           0 :             ereport(WARNING,
     444             :                     (errmsg("database \"%s\" must be vacuumed within %u transactions",
     445             :                             oldest_datname,
     446             :                             xidWrapLimit - curXid),
     447             :                      errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
     448             :                              "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
     449             :         else
     450           0 :             ereport(WARNING,
     451             :                     (errmsg("database with OID %u must be vacuumed within %u transactions",
     452             :                             oldest_datoid,
     453             :                             xidWrapLimit - curXid),
     454             :                      errhint("To avoid a database shutdown, execute a database-wide VACUUM in that database.\n"
     455             :                              "You might also need to commit or roll back old prepared transactions, or drop stale replication slots.")));
     456             :     }
     457        2242 : }
     458             : 
     459             : 
     460             : /*
     461             :  * ForceTransactionIdLimitUpdate -- does the XID wrap-limit data need updating?
     462             :  *
     463             :  * We primarily check whether oldestXidDB is valid.  The cases we have in
     464             :  * mind are that that database was dropped, or the field was reset to zero
     465             :  * by pg_resetwal.  In either case we should force recalculation of the
     466             :  * wrap limit.  Also do it if oldestXid is old enough to be forcing
     467             :  * autovacuums or other actions; this ensures we update our state as soon
     468             :  * as possible once extra overhead is being incurred.
     469             :  */
     470             : bool
     471        2868 : ForceTransactionIdLimitUpdate(void)
     472             : {
     473             :     TransactionId nextXid;
     474             :     TransactionId xidVacLimit;
     475             :     TransactionId oldestXid;
     476             :     Oid         oldestXidDB;
     477             : 
     478             :     /* Locking is probably not really necessary, but let's be careful */
     479        2868 :     LWLockAcquire(XidGenLock, LW_SHARED);
     480        2868 :     nextXid = XidFromFullTransactionId(ShmemVariableCache->nextFullXid);
     481        2868 :     xidVacLimit = ShmemVariableCache->xidVacLimit;
     482        2868 :     oldestXid = ShmemVariableCache->oldestXid;
     483        2868 :     oldestXidDB = ShmemVariableCache->oldestXidDB;
     484        2868 :     LWLockRelease(XidGenLock);
     485             : 
     486        2868 :     if (!TransactionIdIsNormal(oldestXid))
     487           0 :         return true;            /* shouldn't happen, but just in case */
     488        2868 :     if (!TransactionIdIsValid(xidVacLimit))
     489           0 :         return true;            /* this shouldn't happen anymore either */
     490        2868 :     if (TransactionIdFollowsOrEquals(nextXid, xidVacLimit))
     491           2 :         return true;            /* past xidVacLimit, don't delay updating */
     492        2866 :     if (!SearchSysCacheExists1(DATABASEOID, ObjectIdGetDatum(oldestXidDB)))
     493           0 :         return true;            /* could happen, per comments above */
     494        2866 :     return false;
     495             : }
     496             : 
     497             : 
     498             : /*
     499             :  * GetNewObjectId -- allocate a new OID
     500             :  *
     501             :  * OIDs are generated by a cluster-wide counter.  Since they are only 32 bits
     502             :  * wide, counter wraparound will occur eventually, and therefore it is unwise
     503             :  * to assume they are unique unless precautions are taken to make them so.
     504             :  * Hence, this routine should generally not be used directly.  The only direct
     505             :  * callers should be GetNewOidWithIndex() and GetNewRelFileNode() in
     506             :  * catalog/catalog.c.
     507             :  */
     508             : Oid
     509      852774 : GetNewObjectId(void)
     510             : {
     511             :     Oid         result;
     512             : 
     513             :     /* safety check, we should never get this far in a HS standby */
     514      852774 :     if (RecoveryInProgress())
     515           0 :         elog(ERROR, "cannot assign OIDs during recovery");
     516             : 
     517      852774 :     LWLockAcquire(OidGenLock, LW_EXCLUSIVE);
     518             : 
     519             :     /*
     520             :      * Check for wraparound of the OID counter.  We *must* not return 0
     521             :      * (InvalidOid), and in normal operation we mustn't return anything below
     522             :      * FirstNormalObjectId since that range is reserved for initdb (see
     523             :      * IsCatalogRelationOid()).  Note we are relying on unsigned comparison.
     524             :      *
     525             :      * During initdb, we start the OID generator at FirstBootstrapObjectId, so
     526             :      * we only wrap if before that point when in bootstrap or standalone mode.
     527             :      * The first time through this routine after normal postmaster start, the
     528             :      * counter will be forced up to FirstNormalObjectId.  This mechanism
     529             :      * leaves the OIDs between FirstBootstrapObjectId and FirstNormalObjectId
     530             :      * available for automatic assignment during initdb, while ensuring they
     531             :      * will never conflict with user-assigned OIDs.
     532             :      */
     533      852774 :     if (ShmemVariableCache->nextOid < ((Oid) FirstNormalObjectId))
     534             :     {
     535      213456 :         if (IsPostmasterEnvironment)
     536             :         {
     537             :             /* wraparound, or first post-initdb assignment, in normal mode */
     538         292 :             ShmemVariableCache->nextOid = FirstNormalObjectId;
     539         292 :             ShmemVariableCache->oidCount = 0;
     540             :         }
     541             :         else
     542             :         {
     543             :             /* we may be bootstrapping, so don't enforce the full range */
     544      213164 :             if (ShmemVariableCache->nextOid < ((Oid) FirstBootstrapObjectId))
     545             :             {
     546             :                 /* wraparound in standalone mode (unlikely but possible) */
     547           0 :                 ShmemVariableCache->nextOid = FirstNormalObjectId;
     548           0 :                 ShmemVariableCache->oidCount = 0;
     549             :             }
     550             :         }
     551             :     }
     552             : 
     553             :     /* If we run out of logged for use oids then we must log more */
     554      852774 :     if (ShmemVariableCache->oidCount == 0)
     555             :     {
     556        1042 :         XLogPutNextOid(ShmemVariableCache->nextOid + VAR_OID_PREFETCH);
     557        1042 :         ShmemVariableCache->oidCount = VAR_OID_PREFETCH;
     558             :     }
     559             : 
     560      852774 :     result = ShmemVariableCache->nextOid;
     561             : 
     562      852774 :     (ShmemVariableCache->nextOid)++;
     563      852774 :     (ShmemVariableCache->oidCount)--;
     564             : 
     565      852774 :     LWLockRelease(OidGenLock);
     566             : 
     567      852774 :     return result;
     568             : }

Generated by: LCOV version 1.13