* 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,
/* Then offsets */
PerformOffsetsTruncation(oldestMulti, newOldestMulti);
- MyPgXact->delayChkpt &= ~DELAY_CHKPT_START;
+ MyPgXact->delayChkpt = false;
END_CRIT_SECTION();
LWLockRelease(MultiXactTruncationLock);
}
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;
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)
* 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
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
TransactionIdCommitTree(xid, nchildren, children);
/* Checkpoint can proceed now */
- MyPgXact->delayChkpt &= ~DELAY_CHKPT_START;
+ MyPgXact->delayChkpt = false;
END_CRIT_SECTION();
* 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();
*/
if (markXidCommitted)
{
- MyPgXact->delayChkpt &= ~DELAY_CHKPT_START;
+ MyPgXact->delayChkpt = false;
END_CRIT_SECTION();
}
* 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);
/*
* 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
* 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
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;
}
/*
* 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);
}
UnlockBufHdr(bufHdr, buf_state);
if (delayChkpt)
- MyPgXact->delayChkpt &= ~DELAY_CHKPT_START;
+ MyPgXact->delayChkpt = false;
if (dirtied)
{
#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,
/* 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;
/* 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;
}
/*
- * 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;
PGPROC *proc = &allProcs[pgprocno];
PGXACT *pgxact = &allPgXact[pgprocno];
- if ((pgxact->delayChkpt & type) != 0)
+ if (((type & DELAY_CHKPT_START) && pgxact->delayChkpt) ||
+ ((type & DELAY_CHKPT_COMPLETE) && proc->delayChkptEnd))
{
VirtualTransactionId vxid;
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?
*
* 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;
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;
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
*
#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)
*/
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 */
/*
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;
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);
projects / thirdparty / postgresql.git / commitdiff
