knownassignedxids-fix-with-locking-1.patch

*** a/src/backend/access/transam/xlog.c
--- b/src/backend/access/transam/xlog.c
***************
*** 6095,6102 **** StartupXLOG(void)
  			StartupSUBTRANS(oldestActiveXID);
  			StartupMultiXact();
  
- 			ProcArrayInitRecoveryInfo(oldestActiveXID);
- 
  			/*
  			 * If we're beginning at a shutdown checkpoint, we know that
  			 * nothing was running on the master at this point. So fake-up an
--- 6095,6100 ----
*** a/src/backend/storage/ipc/procarray.c
--- b/src/backend/storage/ipc/procarray.c
***************
*** 435,453 **** ProcArrayClearTransaction(PGPROC *proc)
  }
  
  /*
-  * ProcArrayInitRecoveryInfo
-  *
-  * When trying to assemble our snapshot we only care about xids after this value.
-  * See comments for LogStandbySnapshot().
-  */
- void
- ProcArrayInitRecoveryInfo(TransactionId oldestActiveXid)
- {
- 	latestObservedXid = oldestActiveXid;
- 	TransactionIdRetreat(latestObservedXid);
- }
- 
- /*
   * ProcArrayApplyRecoveryInfo -- apply recovery info about xids
   *
   * Takes us through 3 states: Initialized, Pending and Ready.
--- 435,440 ----
***************
*** 519,533 **** ProcArrayApplyRecoveryInfo(RunningTransactions running)
  	Assert(standbyState == STANDBY_INITIALIZED);
  
  	/*
! 	 * OK, we need to initialise from the RunningTransactionsData record
! 	 */
! 
! 	/*
! 	 * Remove all xids except xids later than the snapshot. We don't know
! 	 * exactly which ones that is until precisely now, so that is why we allow
! 	 * xids to be added only to remove most of them again here.
  	 */
- 	ExpireOldKnownAssignedTransactionIds(running->nextXid);
  	StandbyReleaseOldLocks(running->nextXid);
  
  	/*
--- 506,514 ----
  	Assert(standbyState == STANDBY_INITIALIZED);
  
  	/*
! 	 * Release any locks belonging to old transactions that are not
! 	 * running according to the running-xacts record.
  	 */
  	StandbyReleaseOldLocks(running->nextXid);
  
  	/*
***************
*** 536,544 **** ProcArrayApplyRecoveryInfo(RunningTransactions running)
  	LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
  
  	/*
- 	 * Combine the running xact data with already known xids, if any exist.
  	 * KnownAssignedXids is sorted so we cannot just add new xids, we have to
! 	 * combine them first, sort them and then re-add to KnownAssignedXids.
  	 *
  	 * Some of the new xids are top-level xids and some are subtransactions.
  	 * We don't call SubtransSetParent because it doesn't matter yet. If we
--- 517,524 ----
  	LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
  
  	/*
  	 * KnownAssignedXids is sorted so we cannot just add new xids, we have to
! 	 * sort them first.
  	 *
  	 * Some of the new xids are top-level xids and some are subtransactions.
  	 * We don't call SubtransSetParent because it doesn't matter yet. If we
***************
*** 547,597 **** ProcArrayApplyRecoveryInfo(RunningTransactions running)
  	 * xids to subtrans. If RunningXacts is overflowed then we don't have
  	 * enough information to correctly update subtrans anyway.
  	 */
  
  	/*
! 	 * Allocate a temporary array so we can combine xids. The total of both
! 	 * arrays should never normally exceed TOTAL_MAX_CACHED_SUBXIDS.
  	 */
! 	xids = palloc(sizeof(TransactionId) * TOTAL_MAX_CACHED_SUBXIDS);
  
  	/*
! 	 * Get the remaining KnownAssignedXids. In most cases there won't be any
! 	 * at all since this exists only to catch a theoretical race condition.
! 	 */
! 	nxids = KnownAssignedXidsGet(xids, InvalidTransactionId);
! 	if (nxids > 0)
! 		KnownAssignedXidsDisplay(trace_recovery(DEBUG3));
! 
! 	/*
! 	 * Now we have a copy of any KnownAssignedXids we can zero the array
! 	 * before we re-insert combined snapshot.
! 	 */
! 	KnownAssignedXidsRemovePreceding(InvalidTransactionId);
! 
! 	/*
! 	 * Add to the temp array any xids which have not already completed, taking
! 	 * care not to overflow in extreme cases.
  	 */
  	for (i = 0; i < running->xcnt; i++)
  	{
  		TransactionId xid = running->xids[i];
  
  		/*
! 		 * The running-xacts snapshot can contain xids that were running at
! 		 * the time of the snapshot, yet complete before the snapshot was
! 		 * written to WAL. They're running now, so ignore them.
  		 */
  		if (TransactionIdDidCommit(xid) || TransactionIdDidAbort(xid))
  			continue;
  
  		xids[nxids++] = xid;
- 
- 		/*
- 		 * Test for overflow only after we have filtered out already complete
- 		 * transactions.
- 		 */
- 		if (nxids > TOTAL_MAX_CACHED_SUBXIDS)
- 			elog(ERROR, "too many xids to add into KnownAssignedXids");
  	}
  
  	if (nxids > 0)
--- 527,558 ----
  	 * xids to subtrans. If RunningXacts is overflowed then we don't have
  	 * enough information to correctly update subtrans anyway.
  	 */
+ 	Assert(procArray->numKnownAssignedXids == 0);
  
  	/*
! 	 * Allocate a temporary array to avoid modifying the array passed as
! 	 * argument.
  	 */
! 	xids = palloc(sizeof(TransactionId) * running->xcnt);
  
  	/*
! 	 * Add to the temp array any xids which have not already completed.
  	 */
+ 	nxids = 0;
  	for (i = 0; i < running->xcnt; i++)
  	{
  		TransactionId xid = running->xids[i];
  
  		/*
! 		 * The running-xacts snapshot can contain xids that were still visible
! 		 * in the procarray when the snapshot was taken, but were already
! 		 * WAL-logged as completed. They're not running anymore, so ignore
! 		 * them.
  		 */
  		if (TransactionIdDidCommit(xid) || TransactionIdDidAbort(xid))
  			continue;
  
  		xids[nxids++] = xid;
  	}
  
  	if (nxids > 0)
***************
*** 603,621 **** ProcArrayApplyRecoveryInfo(RunningTransactions running)
  		qsort(xids, nxids, sizeof(TransactionId), xidComparator);
  
  		/*
- 		 * Re-initialise latestObservedXid to the highest xid we've seen.
- 		 */
- 		latestObservedXid = xids[nxids - 1];
- 
- 		/*
  		 * Add the sorted snapshot into KnownAssignedXids
  		 */
  		for (i = 0; i < nxids; i++)
! 		{
! 			TransactionId xid = xids[i];
! 
! 			KnownAssignedXidsAdd(xid, xid, true);
! 		}
  
  		KnownAssignedXidsDisplay(trace_recovery(DEBUG3));
  	}
--- 564,573 ----
  		qsort(xids, nxids, sizeof(TransactionId), xidComparator);
  
  		/*
  		 * Add the sorted snapshot into KnownAssignedXids
  		 */
  		for (i = 0; i < nxids; i++)
! 			KnownAssignedXidsAdd(xids[i], xids[i], true);
  
  		KnownAssignedXidsDisplay(trace_recovery(DEBUG3));
  	}
***************
*** 623,630 **** ProcArrayApplyRecoveryInfo(RunningTransactions running)
  	pfree(xids);
  
  	/*
! 	 * Now we've got the running xids we need to set the global values thare
! 	 * used to track snapshots as they evolve further
  	 *
  	 * * latestCompletedXid which will be the xmax for snapshots *
  	 * lastOverflowedXid which shows whether snapshots overflow * nextXid
--- 575,582 ----
  	pfree(xids);
  
  	/*
! 	 * Now we've got the running xids we need to set the global values that
! 	 * are used to track snapshots as they evolve further.
  	 *
  	 * * latestCompletedXid which will be the xmax for snapshots *
  	 * lastOverflowedXid which shows whether snapshots overflow * nextXid
***************
*** 633,668 **** ProcArrayApplyRecoveryInfo(RunningTransactions running)
  	 * but the recovery snapshot isn't fully valid yet because we know there
  	 * are some subxids missing. We don't know the specific subxids that are
  	 * missing, so conservatively assume the last one is latestObservedXid.
- 	 * If no missing subxids, try to clear lastOverflowedXid.
- 	 *
- 	 * If the snapshot didn't overflow it's still possible that an overflow
- 	 * occurred in the gap between taking snapshot and logging record, so we
- 	 * also need to check if lastOverflowedXid is already ahead of us.
  	 */
  	if (running->subxid_overflow)
  	{
  		standbyState = STANDBY_SNAPSHOT_PENDING;
  
  		standbySnapshotPendingXmin = latestObservedXid;
! 		if (TransactionIdFollows(latestObservedXid,
! 								 procArray->lastOverflowedXid))
! 			procArray->lastOverflowedXid = latestObservedXid;
! 	}
! 	else if (TransactionIdFollows(procArray->lastOverflowedXid,
! 								  latestObservedXid))
! 	{
! 		standbyState = STANDBY_SNAPSHOT_PENDING;
! 
! 		standbySnapshotPendingXmin = procArray->lastOverflowedXid;
  	}
  	else
  	{
  		standbyState = STANDBY_SNAPSHOT_READY;
  
  		standbySnapshotPendingXmin = InvalidTransactionId;
! 		if (TransactionIdFollows(running->oldestRunningXid,
! 								 procArray->lastOverflowedXid))
! 			procArray->lastOverflowedXid = InvalidTransactionId;
  	}
  
  	/*
--- 585,607 ----
  	 * but the recovery snapshot isn't fully valid yet because we know there
  	 * are some subxids missing. We don't know the specific subxids that are
  	 * missing, so conservatively assume the last one is latestObservedXid.
  	 */
+ 	latestObservedXid = running->nextXid;
+ 	TransactionIdRetreat(latestObservedXid);
+ 
  	if (running->subxid_overflow)
  	{
  		standbyState = STANDBY_SNAPSHOT_PENDING;
  
  		standbySnapshotPendingXmin = latestObservedXid;
! 		procArray->lastOverflowedXid = latestObservedXid;
  	}
  	else
  	{
  		standbyState = STANDBY_SNAPSHOT_READY;
  
  		standbySnapshotPendingXmin = InvalidTransactionId;
! 		procArray->lastOverflowedXid = InvalidTransactionId;
  	}
  
  	/*
***************
*** 1407,1412 **** GetSnapshotData(Snapshot snapshot)
--- 1346,1355 ----
   * Similar to GetSnapshotData but returns more information. We include
   * all PGPROCs with an assigned TransactionId, even VACUUM processes.
   *
+  * We acquire XidGenLock, but the caller is responsible for releasing it.
+  * This ensures that no new XIDs enter the proc array until the caller has
+  * WAL-logged this snapshot, and releases the lock.
+  *
   * The returned data structure is statically allocated; caller should not
   * modify it, and must not assume it is valid past the next call.
   *
***************
*** 1526,1532 **** GetRunningTransactionData(void)
  	CurrentRunningXacts->oldestRunningXid = oldestRunningXid;
  	CurrentRunningXacts->latestCompletedXid = latestCompletedXid;
  
! 	LWLockRelease(XidGenLock);
  	LWLockRelease(ProcArrayLock);
  
  	Assert(TransactionIdIsValid(CurrentRunningXacts->nextXid));
--- 1469,1475 ----
  	CurrentRunningXacts->oldestRunningXid = oldestRunningXid;
  	CurrentRunningXacts->latestCompletedXid = latestCompletedXid;
  
! 	/* We don't release XidGenLock here, the caller is responsible for that */
  	LWLockRelease(ProcArrayLock);
  
  	Assert(TransactionIdIsValid(CurrentRunningXacts->nextXid));
***************
*** 2337,2346 **** DisplayXidCache(void)
   *		unobserved XIDs.
   *
   * RecordKnownAssignedTransactionIds() should be run for *every* WAL record
!  * type apart from XLOG_RUNNING_XACTS (since that initialises the first
!  * snapshot so that RecordKnownAssignedTransactionIds() can be called). Must
!  * be called for each record after we have executed StartupCLOG() et al,
!  * since we must ExtendCLOG() etc..
   *
   * Called during recovery in analogy with and in place of GetNewTransactionId()
   */
--- 2280,2287 ----
   *		unobserved XIDs.
   *
   * RecordKnownAssignedTransactionIds() should be run for *every* WAL record
!  * associated with a transaction. Must be called for each record after we
!  * have executed StartupCLOG() et al, since we must ExtendCLOG() etc..
   *
   * Called during recovery in analogy with and in place of GetNewTransactionId()
   */
***************
*** 2348,2360 **** void
  RecordKnownAssignedTransactionIds(TransactionId xid)
  {
  	Assert(standbyState >= STANDBY_INITIALIZED);
- 	Assert(TransactionIdIsValid(latestObservedXid));
  	Assert(TransactionIdIsValid(xid));
  
  	elog(trace_recovery(DEBUG4), "record known xact %u latestObservedXid %u",
  		 xid, latestObservedXid);
  
  	/*
  	 * When a newly observed xid arrives, it is frequently the case that it is
  	 * *not* the next xid in sequence. When this occurs, we must treat the
  	 * intervening xids as running also.
--- 2289,2308 ----
  RecordKnownAssignedTransactionIds(TransactionId xid)
  {
  	Assert(standbyState >= STANDBY_INITIALIZED);
  	Assert(TransactionIdIsValid(xid));
  
  	elog(trace_recovery(DEBUG4), "record known xact %u latestObservedXid %u",
  		 xid, latestObservedXid);
  
  	/*
+ 	 * If the KnownAssignedXids machinery isn't up yet, do nothing.
+ 	 */
+ 	if (standbyState == STANDBY_INITIALIZED)
+ 		return;
+ 
+ 	Assert(TransactionIdIsValid(latestObservedXid));
+ 
+ 	/*
  	 * When a newly observed xid arrives, it is frequently the case that it is
  	 * *not* the next xid in sequence. When this occurs, we must treat the
  	 * intervening xids as running also.
*** a/src/backend/storage/ipc/standby.c
--- b/src/backend/storage/ipc/standby.c
***************
*** 671,677 **** StandbyReleaseAllLocks(void)
  /*
   * StandbyReleaseOldLocks
   *		Release standby locks held by XIDs < removeXid, as long
!  *		as their not prepared transactions.
   */
  void
  StandbyReleaseOldLocks(TransactionId removeXid)
--- 671,677 ----
  /*
   * StandbyReleaseOldLocks
   *		Release standby locks held by XIDs < removeXid, as long
!  *		as they're not prepared transactions.
   */
  void
  StandbyReleaseOldLocks(TransactionId removeXid)
***************
*** 848,861 **** LogStandbySnapshot(TransactionId *oldestActiveXid, TransactionId *nextXid)
  	 * record we write, because standby will open up when it sees this.
  	 */
  	running = GetRunningTransactionData();
- 
- 	/*
- 	 * The gap between GetRunningTransactionData() and
- 	 * LogCurrentRunningXacts() is what most of the fuss is about here, so
- 	 * artifically extending this interval is a great way to test the little
- 	 * used parts of the code.
- 	 */
  	LogCurrentRunningXacts(running);
  
  	*oldestActiveXid = running->oldestRunningXid;
  	*nextXid = running->nextXid;
--- 848,856 ----
  	 * record we write, because standby will open up when it sees this.
  	 */
  	running = GetRunningTransactionData();
  	LogCurrentRunningXacts(running);
+ 	/* GetRunningTransactionData() acquired XidGenLock, we must release it */
+ 	LWLockRelease(XidGenLock);
  
  	*oldestActiveXid = running->oldestRunningXid;
  	*nextXid = running->nextXid;
*** a/src/include/storage/procarray.h
--- b/src/include/storage/procarray.h
***************
*** 28,34 **** extern void ProcArrayRemove(PGPROC *proc, TransactionId latestXid);
  extern void ProcArrayEndTransaction(PGPROC *proc, TransactionId latestXid);
  extern void ProcArrayClearTransaction(PGPROC *proc);
  
- extern void ProcArrayInitRecoveryInfo(TransactionId oldestActiveXid);
  extern void ProcArrayApplyRecoveryInfo(RunningTransactions running);
  extern void ProcArrayApplyXidAssignment(TransactionId topxid,
  							int nsubxids, TransactionId *subxids);
--- 28,33 ----