diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c index 5612db0e21..ad9e7ff8f0 100644 --- a/src/backend/access/transam/multixact.c +++ b/src/backend/access/transam/multixact.c @@ -3069,8 +3069,8 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB) * crash/basebackup, even though the state of the data directory would * require it. */ - Assert((MyPgXact->delayChkpt & DELAY_CHKPT_START) == 0); - MyPgXact->delayChkpt |= DELAY_CHKPT_START; + Assert(!MyPgXact->delayChkpt); + MyPgXact->delayChkpt = true; /* WAL log truncation */ WriteMTruncateXlogRec(newOldestMultiDB, @@ -3096,7 +3096,7 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB) /* Then offsets */ PerformOffsetsTruncation(oldestMulti, newOldestMulti); - MyPgXact->delayChkpt &= ~DELAY_CHKPT_START; + MyPgXact->delayChkpt = false; END_CRIT_SECTION(); LWLockRelease(MultiXactTruncationLock); diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c index 769a5fd714..d145836a79 100644 --- a/src/backend/access/transam/twophase.c +++ b/src/backend/access/transam/twophase.c @@ -476,8 +476,9 @@ MarkAsPreparingGuts(GlobalTransaction gxact, TransactionId xid, const char *gid, } pgxact->xid = xid; pgxact->xmin = InvalidTransactionId; - pgxact->delayChkpt = 0; + pgxact->delayChkpt = false; pgxact->vacuumFlags = 0; + proc->delayChkptEnd = false; proc->pid = 0; proc->databaseId = databaseid; proc->roleId = owner; @@ -1175,8 +1176,8 @@ EndPrepare(GlobalTransaction gxact) START_CRIT_SECTION(); - Assert((MyPgXact->delayChkpt & DELAY_CHKPT_START) == 0); - MyPgXact->delayChkpt |= DELAY_CHKPT_START; + Assert(!MyPgXact->delayChkpt); + MyPgXact->delayChkpt = true; XLogBeginInsert(); for (record = records.head; record != NULL; record = record->next) @@ -1219,7 +1220,7 @@ EndPrepare(GlobalTransaction gxact) * checkpoint starting after this will certainly see the gxact as a * candidate for fsyncing. */ - MyPgXact->delayChkpt &= ~DELAY_CHKPT_START; + MyPgXact->delayChkpt = false; /* * Remember that we have this GlobalTransaction entry locked for us. If @@ -2353,8 +2354,8 @@ RecordTransactionCommitPrepared(TransactionId xid, START_CRIT_SECTION(); /* See notes in RecordTransactionCommit */ - Assert((MyPgXact->delayChkpt & DELAY_CHKPT_START) == 0); - MyPgXact->delayChkpt |= DELAY_CHKPT_START; + Assert(!MyPgXact->delayChkpt); + MyPgXact->delayChkpt = true; /* * Emit the XLOG commit record. Note that we mark 2PC commits as @@ -2402,7 +2403,7 @@ RecordTransactionCommitPrepared(TransactionId xid, TransactionIdCommitTree(xid, nchildren, children); /* Checkpoint can proceed now */ - MyPgXact->delayChkpt &= ~DELAY_CHKPT_START; + MyPgXact->delayChkpt = false; END_CRIT_SECTION(); diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c index 5a86b6575e..ee923d20a4 100644 --- a/src/backend/access/transam/xact.c +++ b/src/backend/access/transam/xact.c @@ -1239,9 +1239,9 @@ RecordTransactionCommit(void) * This makes checkpoint's determination of which xacts are delayChkpt * a bit fuzzy, but it doesn't matter. */ - Assert((MyPgXact->delayChkpt & DELAY_CHKPT_START) == 0); + Assert(!MyPgXact->delayChkpt); START_CRIT_SECTION(); - MyPgXact->delayChkpt |= DELAY_CHKPT_START; + MyPgXact->delayChkpt = true; SetCurrentTransactionStopTimestamp(); @@ -1342,7 +1342,7 @@ RecordTransactionCommit(void) */ if (markXidCommitted) { - MyPgXact->delayChkpt &= ~DELAY_CHKPT_START; + MyPgXact->delayChkpt = false; END_CRIT_SECTION(); } diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index cc0229b934..5de7143f65 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -9064,27 +9064,25 @@ CreateCheckPoint(int flags) * and we will correctly flush the update below. So we cannot miss any * xacts we need to wait for. */ - vxids = GetVirtualXIDsDelayingChkpt(&nvxids, DELAY_CHKPT_START); + vxids = GetVirtualXIDsDelayingChkpt(&nvxids); if (nvxids > 0) { do { pg_usleep(10000L); /* wait for 10 msec */ - } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids, - DELAY_CHKPT_START)); + } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids)); } pfree(vxids); CheckPointGuts(checkPoint.redo, flags); - vxids = GetVirtualXIDsDelayingChkpt(&nvxids, DELAY_CHKPT_COMPLETE); + vxids = GetVirtualXIDsDelayingChkptEnd(&nvxids); if (nvxids > 0) { do { pg_usleep(10000L); /* wait for 10 msec */ - } while (HaveVirtualXIDsDelayingChkpt(vxids, nvxids, - DELAY_CHKPT_COMPLETE)); + } while (HaveVirtualXIDsDelayingChkptEnd(vxids, nvxids)); } pfree(vxids); diff --git a/src/backend/access/transam/xloginsert.c b/src/backend/access/transam/xloginsert.c index a8c140b06f..c033e7bd4c 100644 --- a/src/backend/access/transam/xloginsert.c +++ b/src/backend/access/transam/xloginsert.c @@ -899,7 +899,7 @@ XLogSaveBufferForHint(Buffer buffer, bool buffer_std) /* * Ensure no checkpoint can change our view of RedoRecPtr. */ - Assert((MyPgXact->delayChkpt & DELAY_CHKPT_START) != 0); + Assert(MyPgXact->delayChkpt); /* * Update RedoRecPtr so that we can make the right decision diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index 5d6f456c70..76a75a46b8 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -262,8 +262,8 @@ RelationTruncate(Relation rel, BlockNumber nblocks) * the blocks to not exist on disk at all, but not for them to have the * wrong contents. */ - Assert((MyPgXact->delayChkpt & DELAY_CHKPT_COMPLETE) == 0); - MyPgXact->delayChkpt |= DELAY_CHKPT_COMPLETE; + Assert(!MyProc->delayChkptEnd); + MyProc->delayChkptEnd = true; /* * We WAL-log the truncation before actually truncating, which means @@ -311,7 +311,7 @@ RelationTruncate(Relation rel, BlockNumber nblocks) smgrtruncate(rel->rd_smgr, MAIN_FORKNUM, nblocks); /* We've done all the critical work, so checkpoints are OK now. */ - MyPgXact->delayChkpt &= ~DELAY_CHKPT_COMPLETE; + MyProc->delayChkptEnd = false; } /* diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 027d5067a0..f0f3f02b2e 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -3471,8 +3471,8 @@ MarkBufferDirtyHint(Buffer buffer, bool buffer_std) * essential that CreateCheckpoint waits for virtual transactions * rather than full transactionids. */ - Assert((MyPgXact->delayChkpt & DELAY_CHKPT_START) == 0); - MyPgXact->delayChkpt |= DELAY_CHKPT_START; + Assert(!MyPgXact->delayChkpt); + MyPgXact->delayChkpt = true; delayChkpt = true; lsn = XLogSaveBufferForHint(buffer, buffer_std); } @@ -3506,7 +3506,7 @@ MarkBufferDirtyHint(Buffer buffer, bool buffer_std) UnlockBufHdr(bufHdr, buf_state); if (delayChkpt) - MyPgXact->delayChkpt &= ~DELAY_CHKPT_START; + MyPgXact->delayChkpt = false; if (dirtied) { diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c index d88d955091..1244e947f9 100644 --- a/src/backend/storage/ipc/procarray.c +++ b/src/backend/storage/ipc/procarray.c @@ -151,6 +151,11 @@ static void DisplayXidCache(void); #define xc_slow_answer_inc() ((void) 0) #endif /* XIDCACHE_DEBUG */ +static VirtualTransactionId *GetVirtualXIDsDelayingChkptGuts(int *nvxids, + int type); +static bool HaveVirtualXIDsDelayingChkptGuts(VirtualTransactionId *vxids, + int nvxids, int type); + /* Primitives for KnownAssignedXids array handling for standby */ static void KnownAssignedXidsCompress(bool force); static void KnownAssignedXidsAdd(TransactionId from_xid, TransactionId to_xid, @@ -434,8 +439,9 @@ ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid) /* must be cleared with xid/xmin: */ pgxact->vacuumFlags &= ~PROC_VACUUM_STATE_MASK; - /* be sure this is cleared in abort */ - pgxact->delayChkpt = 0; + /* be sure these are cleared in abort */ + pgxact->delayChkpt = false; + proc->delayChkptEnd = false; proc->recoveryConflictPending = false; @@ -459,8 +465,9 @@ ProcArrayEndTransactionInternal(PGPROC *proc, PGXACT *pgxact, /* must be cleared with xid/xmin: */ pgxact->vacuumFlags &= ~PROC_VACUUM_STATE_MASK; - /* be sure this is cleared in abort */ - pgxact->delayChkpt = 0; + /* be sure these are cleared in abort */ + pgxact->delayChkpt = false; + proc->delayChkptEnd = false; proc->recoveryConflictPending = false; @@ -2269,26 +2276,28 @@ GetOldestSafeDecodingTransactionId(bool catalogOnly) } /* - * GetVirtualXIDsDelayingChkpt -- Get the VXIDs of transactions that are - * delaying checkpoint because they have critical actions in progress. + * GetVirtualXIDsDelayingChkptGuts -- Get the VXIDs of transactions that are + * delaying the start or end of a checkpoint because they have critical + * actions in progress. * * Constructs an array of VXIDs of transactions that are currently in commit - * critical sections, as shown by having specified delayChkpt bits set in their - * PGXACT. + * critical sections, as shown by having specified delayChkpt or delayChkptEnd + * set. * * Returns a palloc'd array that should be freed by the caller. * *nvxids is the number of valid entries. * - * Note that because backends set or clear delayChkpt without holding any lock, - * the result is somewhat indeterminate, but we don't really care. Even in - * a multiprocessor with delayed writes to shared memory, it should be certain - * that setting of delayChkpt will propagate to shared memory when the backend - * takes a lock, so we cannot fail to see a virtual xact as delayChkpt if - * it's already inserted its commit record. Whether it takes a little while - * for clearing of delayChkpt to propagate is unimportant for correctness. + * Note that because backends set or clear delayChkpt and delayChkptEnd + * without holding any lock, the result is somewhat indeterminate, but we + * don't really care. Even in a multiprocessor with delayed writes to + * shared memory, it should be certain that setting of delayChkpt will + * propagate to shared memory when the backend takes a lock, so we cannot + * fail to see a virtual xact as delayChkpt if it's already inserted its + * commit record. Whether it takes a little while for clearing of + * delayChkpt to propagate is unimportant for correctness. */ -VirtualTransactionId * -GetVirtualXIDsDelayingChkpt(int *nvxids, int type) +static VirtualTransactionId * +GetVirtualXIDsDelayingChkptGuts(int *nvxids, int type) { VirtualTransactionId *vxids; ProcArrayStruct *arrayP = procArray; @@ -2309,7 +2318,8 @@ GetVirtualXIDsDelayingChkpt(int *nvxids, int type) volatile PGPROC *proc = &allProcs[pgprocno]; volatile PGXACT *pgxact = &allPgXact[pgprocno]; - if ((pgxact->delayChkpt & type) != 0) + if (((type & DELAY_CHKPT_START) && pgxact->delayChkpt) || + ((type & DELAY_CHKPT_COMPLETE) && proc->delayChkptEnd)) { VirtualTransactionId vxid; @@ -2325,6 +2335,26 @@ GetVirtualXIDsDelayingChkpt(int *nvxids, int type) return vxids; } +/* + * GetVirtualXIDsDelayingChkpt - Get the VXIDs of transactions that are + * delaying the start of a checkpoint. + */ +VirtualTransactionId * +GetVirtualXIDsDelayingChkpt(int *nvxids) +{ + return GetVirtualXIDsDelayingChkptGuts(nvxids, DELAY_CHKPT_START); +} + +/* + * GetVirtualXIDsDelayingChkptEnd - Get the VXIDs of transactions that are + * delaying the end of a checkpoint. + */ +VirtualTransactionId * +GetVirtualXIDsDelayingChkptEnd(int *nvxids) +{ + return GetVirtualXIDsDelayingChkptGuts(nvxids, DELAY_CHKPT_COMPLETE); +} + /* * HaveVirtualXIDsDelayingChkpt -- Are any of the specified VXIDs delaying? * @@ -2334,8 +2364,9 @@ GetVirtualXIDsDelayingChkpt(int *nvxids, int type) * Note: this is O(N^2) in the number of vxacts that are/were delaying, but * those numbers should be small enough for it not to be a problem. */ -bool -HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids, int type) +static bool +HaveVirtualXIDsDelayingChkptGuts(VirtualTransactionId *vxids, int nvxids, + int type) { bool result = false; ProcArrayStruct *arrayP = procArray; @@ -2354,7 +2385,8 @@ HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids, int type) GET_VXID_FROM_PGPROC(vxid, *proc); - if ((pgxact->delayChkpt & type) != 0 && + if ((((type & DELAY_CHKPT_START) && pgxact->delayChkpt) || + ((type & DELAY_CHKPT_COMPLETE) && proc->delayChkptEnd)) && VirtualTransactionIdIsValid(vxid)) { int i; @@ -2377,6 +2409,28 @@ HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids, int type) return result; } +/* + * HaveVirtualXIDsDelayingChkpt -- Are any of the specified VXIDs delaying + * the start of a checkpoint? + */ +bool +HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, int nvxids) +{ + return HaveVirtualXIDsDelayingChkptGuts(vxids, nvxids, + DELAY_CHKPT_START); +} + +/* + * HaveVirtualXIDsDelayingChkptEnd -- Are any of the specified VXIDs delaying + * the end of a checkpoint? + */ +bool +HaveVirtualXIDsDelayingChkptEnd(VirtualTransactionId *vxids, int nvxids) +{ + return HaveVirtualXIDsDelayingChkptGuts(vxids, nvxids, + DELAY_CHKPT_COMPLETE); +} + /* * BackendPidGetProc -- get a backend's PGPROC given its PID * diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h index e76ca8a11e..21a8fbe9d0 100644 --- a/src/include/storage/proc.h +++ b/src/include/storage/proc.h @@ -77,36 +77,8 @@ struct XidCache #define INVALID_PGPROCNO PG_INT32_MAX /* - * Flags for PGPROC.delayChkpt - * - * These flags can be used to delay the start or completion of a checkpoint - * for short periods. A flag is in effect if the corresponding bit is set in - * the PGPROC of any backend. - * - * For our purposes here, a checkpoint has three phases: (1) determine the - * location to which the redo pointer will be moved, (2) write all the - * data durably to disk, and (3) WAL-log the checkpoint. - * - * Setting DELAY_CHKPT_START prevents the system from moving from phase 1 - * to phase 2. This is useful when we are performing a WAL-logged modification - * of data that will be flushed to disk in phase 2. By setting this flag - * before writing WAL and clearing it after we've both written WAL and - * performed the corresponding modification, we ensure that if the WAL record - * is inserted prior to the new redo point, the corresponding data changes will - * also be flushed to disk before the checkpoint can complete. (In the - * extremely common case where the data being modified is in shared buffers - * and we acquire an exclusive content lock on the relevant buffers before - * writing WAL, this mechanism is not needed, because phase 2 will block - * until we release the content lock and then flush the modified data to - * disk.) - * - * Setting DELAY_CHKPT_COMPLETE prevents the system from moving from phase 2 - * to phase 3. This is useful if we are performing a WAL-logged operation that - * might invalidate buffers, such as relation truncation. In this case, we need - * to ensure that any buffers which were invalidated and thus not flushed by - * the checkpoint are actaully destroyed on disk. Replay can cope with a file - * or block that doesn't exist, but not with a block that has the wrong - * contents. + * Flags used only for type of internal functions + * GetVirtualXIDsDelayingChkptGuts and HaveVirtualXIDsDelayingChkptGuts. */ #define DELAY_CHKPT_START (1<<0) #define DELAY_CHKPT_COMPLETE (1<<1) @@ -185,6 +157,12 @@ struct PGPROC */ XLogRecPtr waitLSN; /* waiting for this LSN or higher */ int syncRepState; /* wait state for sync rep */ + bool delayChkptEnd; /* true if this proc delays checkpoint end; + * this doesn't have anything to do with + * sync rep but we don't want to change + * the size of PGPROC in released branches + * and thus must fit this new field into + * existing padding space */ SHM_QUEUE syncRepLinks; /* list link if process is in syncrep queue */ /* @@ -267,7 +245,7 @@ typedef struct PGXACT uint8 vacuumFlags; /* vacuum-related flags, see above */ bool overflowed; - int delayChkpt; /* for DELAY_CHKPT_* flags */ + bool delayChkpt; /* true if this proc delays checkpoint start */ uint8 nxids; } PGXACT; diff --git a/src/include/storage/procarray.h b/src/include/storage/procarray.h index a69632a70c..ea116cae21 100644 --- a/src/include/storage/procarray.h +++ b/src/include/storage/procarray.h @@ -92,9 +92,12 @@ extern TransactionId GetOldestXmin(Relation rel, int flags); extern TransactionId GetOldestActiveTransactionId(void); extern TransactionId GetOldestSafeDecodingTransactionId(bool catalogOnly); -extern VirtualTransactionId *GetVirtualXIDsDelayingChkpt(int *nvxids, int type); +extern VirtualTransactionId *GetVirtualXIDsDelayingChkpt(int *nvxids); +extern VirtualTransactionId *GetVirtualXIDsDelayingChkptEnd(int *nvxids); extern bool HaveVirtualXIDsDelayingChkpt(VirtualTransactionId *vxids, - int nvxids, int type); + int nvxids); +extern bool HaveVirtualXIDsDelayingChkptEnd(VirtualTransactionId *vxids, + int nvxids); extern PGPROC *BackendPidGetProc(int pid); extern PGPROC *BackendPidGetProcWithLock(int pid);