Add entries to procarray

knizhnik · knizhnik · commit 4f5849da4c15 · 2015-09-11T19:38:54.000+03:00
diff --git a/contrib/pg_xtm/pg_dtm.c b/contrib/pg_xtm/pg_dtm.c
@@ -122,7 +122,7 @@ static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, Transaction
         /* Already should be IN_PROGRESS */
         /* CLOGTransactionIdSetTreeStatus(xid, nsubxids, subxids, TRANSACTION_STATUS_IN_PROGRESS, lsn); */
         if (status == TRANSACTION_STATUS_COMMITTED) { 
-            ProcArrayAdd(&ProcGlobal->allProcs[MyProc->pgprocno]);
+            ProcArrayAdd(&ProcGlobal->allProcs[AllocGXid(xid)]);
         }
         DtmHasSnapshot = false;
         DtmEnsureConnection();
diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
@@ -576,6 +576,139 @@ RemoveGXact(GlobalTransaction gxact)
 	elog(ERROR, "failed to find %p in GlobalTransaction array", gxact);
 }
 
+int
+AllocGXid(TransactionId xid)
+{
+	GlobalTransaction gxact;
+	PGPROC	   *proc;
+	PGXACT	   *pgxact;
+	int			i;
+    char gid[GIDSIZE];
+    
+    sprintf(gid, "%u", xid);
+
+	/* fail immediately if feature is disabled */
+	if (max_prepared_xacts == 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+				 errmsg("prepared transactions are disabled"),
+			  errhint("Set max_prepared_transactions to a nonzero value.")));
+
+	/* on first call, register the exit hook */
+	if (!twophaseExitRegistered)
+	{
+		before_shmem_exit(AtProcExit_Twophase, 0);
+		twophaseExitRegistered = true;
+	}
+
+	LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
+
+	/* Check for conflicting GID */
+	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
+	{
+		gxact = TwoPhaseState->prepXacts[i];
+		if (strcmp(gxact->gid, gid) == 0)
+		{
+			ereport(ERROR,
+					(errcode(ERRCODE_DUPLICATE_OBJECT),
+					 errmsg("transaction identifier \"%s\" is already in use",
+							gid)));
+		}
+	}
+
+	/* Get a free gxact from the freelist */
+	if (TwoPhaseState->freeGXacts == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_OUT_OF_MEMORY),
+				 errmsg("maximum number of prepared transactions reached"),
+				 errhint("Increase max_prepared_transactions (currently %d).",
+						 max_prepared_xacts)));
+	gxact = TwoPhaseState->freeGXacts;
+	TwoPhaseState->freeGXacts = gxact->next;
+
+	proc = &ProcGlobal->allProcs[gxact->pgprocno];
+	pgxact = &ProcGlobal->allPgXact[gxact->pgprocno];
+
+	/* Initialize the PGPROC entry */
+	MemSet(proc, 0, sizeof(PGPROC));
+	proc->pgprocno = gxact->pgprocno;
+	SHMQueueElemInit(&(proc->links));
+	proc->waitStatus = STATUS_OK;
+	/* We set up the gxact's VXID as InvalidBackendId/XID */
+	proc->lxid = (LocalTransactionId) xid;
+	pgxact->xid = xid;
+	pgxact->xmin = InvalidTransactionId;
+	pgxact->delayChkpt = false;
+	pgxact->vacuumFlags = 0;
+	proc->pid = 0;
+	proc->backendId = InvalidBackendId;
+	proc->databaseId = 0;
+	proc->roleId = 0;
+	proc->lwWaiting = false;
+	proc->lwWaitMode = 0;
+	proc->waitLock = NULL;
+	proc->waitProcLock = NULL;
+	for (i = 0; i < NUM_LOCK_PARTITIONS; i++)
+		SHMQueueInit(&(proc->myProcLocks[i]));
+	/* subxid data must be filled later by GXactLoadSubxactData */
+	pgxact->overflowed = false;
+	pgxact->nxids = 0;
+
+	gxact->prepared_at = 0;
+	/* initialize LSN to 0 (start of WAL) */
+	gxact->prepare_lsn = 0;
+	gxact->owner = 0;
+	gxact->locking_backend = MyBackendId;
+	gxact->valid = false;
+	strcpy(gxact->gid, gid);
+
+	/* And insert it into the active array */
+	Assert(TwoPhaseState->numPrepXacts < max_prepared_xacts);
+	TwoPhaseState->prepXacts[TwoPhaseState->numPrepXacts++] = gxact;
+
+	/*
+	 * Remember that we have this GlobalTransaction entry locked for us. If we
+	 * abort after this, we must release it.
+	 */
+	MyLockedGxact = gxact;
+
+	LWLockRelease(TwoPhaseStateLock);
+
+	return gxact->pgprocno;
+}
+
+void
+RemoveGXid(TransactionId xid)
+{
+	int			i;
+    char gid[GIDSIZE];
+    
+    sprintf(gid, "%u", xid);
+    
+	LWLockAcquire(TwoPhaseStateLock, LW_EXCLUSIVE);
+
+	for (i = 0; i < TwoPhaseState->numPrepXacts; i++)
+	{
+		if (strcmp(TwoPhaseState->prepXacts[i]->gid, gid) == 0)
+		{
+			/* remove from the active array */
+			TwoPhaseState->numPrepXacts--;
+			TwoPhaseState->prepXacts[i] = TwoPhaseState->prepXacts[TwoPhaseState->numPrepXacts];
+
+			/* and put it back in the freelist */
+			TwoPhaseState->prepXacts[i]->next = TwoPhaseState->freeGXacts;
+			TwoPhaseState->freeGXacts = TwoPhaseState->prepXacts[i];
+
+			LWLockRelease(TwoPhaseStateLock);
+
+			return;
+		}
+	}
+
+	LWLockRelease(TwoPhaseStateLock);
+    
+}
+
 /*
  * TransactionIdIsPrepared
  *		True iff transaction associated with the identifier is prepared
diff --git a/src/backend/storage/ipc/procarray.c b/src/backend/storage/ipc/procarray.c
@@ -3902,16 +3902,17 @@ void VacuumProcArray(Snapshot snapshot)
 			continue;
         }
         if (TransactionIsStillInProgress(pxid, snapshot)) { 
-            elog(WARNING, "ProcArray: %d is in progress\n", pxid);
+            //elog(WARNING, "procArray[%d]=%d is in progress\n", i, pxid);
             nInProgress += 1;
             continue;
         }
+        RemoveGXid(pxid);
         nCompleted += 1;
         memmove(&arrayP->pgprocnos[i], &arrayP->pgprocnos[i + 1],
                 (arrayP->numProcs - i - 1) * sizeof(int));
         arrayP->pgprocnos[arrayP->numProcs - 1] = -1;		/* for debugging */
         arrayP->numProcs--;
     }
 	LWLockRelease(ProcArrayLock);
-    elog(WARNING, "ProcArray: %d in progress, %d completed, %d total\n", nInProgress, nCompleted, arrayP->numProcs);
+    elog(WARNING, "VacuumProcArray: %d in progress, %d completed, %d total\n", nInProgress, nCompleted, arrayP->numProcs);
 }
diff --git a/src/include/access/twophase.h b/src/include/access/twophase.h
@@ -58,4 +58,7 @@ extern void FinishPreparedTransaction(const char *gid, bool isCommit);
 
 extern const char* GetLockedGlobalTransactionId(void);
 
+extern int  AllocGXid(TransactionId xid);
+extern void RemoveGXid(TransactionId xid);
+
 #endif   /* TWOPHASE_H */

Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,7 @@ static void DtmSetTransactionStatus(TransactionId xid, int nsubxids, Transaction`
`122`	`122`	`/* Already should be IN_PROGRESS */`
`123`	`123`	`/* CLOGTransactionIdSetTreeStatus(xid, nsubxids, subxids, TRANSACTION_STATUS_IN_PROGRESS, lsn); */`
`124`	`124`	`if (status == TRANSACTION_STATUS_COMMITTED) {`
`125`		`- ProcArrayAdd(&ProcGlobal->allProcs[MyProc->pgprocno]);`
	`125`	`+ ProcArrayAdd(&ProcGlobal->allProcs[AllocGXid(xid)]);`
`126`	`126`	`}`
`127`	`127`	`DtmHasSnapshot = false;`
`128`	`128`	`DtmEnsureConnection();`
Original file line number	Diff line number	Diff line change
`@@ -3902,16 +3902,17 @@ void VacuumProcArray(Snapshot snapshot)`
`3902`	`3902`	`continue;`
`3903`	`3903`	`}`
`3904`	`3904`	`if (TransactionIsStillInProgress(pxid, snapshot)) {`
`3905`		`- elog(WARNING, "ProcArray: %d is in progress\n", pxid);`
	`3905`	`+ //elog(WARNING, "procArray[%d]=%d is in progress\n", i, pxid);`
`3906`	`3906`	`nInProgress += 1;`
`3907`	`3907`	`continue;`
`3908`	`3908`	`}`
	`3909`	`+ RemoveGXid(pxid);`
`3909`	`3910`	`nCompleted += 1;`
`3910`	`3911`	`memmove(&arrayP->pgprocnos[i], &arrayP->pgprocnos[i + 1],`
`3911`	`3912`	`(arrayP->numProcs - i - 1) * sizeof(int));`
`3912`	`3913`	`arrayP->pgprocnos[arrayP->numProcs - 1] = -1; /* for debugging */`
`3913`	`3914`	`arrayP->numProcs--;`
`3914`	`3915`	`}`
`3915`	`3916`	`LWLockRelease(ProcArrayLock);`
`3916`		`- elog(WARNING, "ProcArray: %d in progress, %d completed, %d total\n", nInProgress, nCompleted, arrayP->numProcs);`
	`3917`	`+ elog(WARNING, "VacuumProcArray: %d in progress, %d completed, %d total\n", nInProgress, nCompleted, arrayP->numProcs);`
`3917`	`3918`	`}`