Repair some flakiness in CheckTargetForConflictsIn.

When we release and reacquire SerializableXactHashLock, we must recheck
whether an R/W conflict still needs to be flagged, because it could have
changed under us in the meantime.  And when we release the partition
lock, we must re-walk the list of predicate locks from the beginning,
because our pointer could get invalidated under us.

Bug report #5952 by Yamamoto Takashi.  Patch by Kevin Grittner.

diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
index 401acdb4715f75481ff94591a89f26620b8dc237..5096ea0c1c1722d2d47a67387930f542644c9297 100644 (file)
--- a/src/backend/storage/lmgr/predicate.c
+++ b/src/backend/storage/lmgr/predicate.c
@@ -3757,6 +3757,17 @@ CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag)
                    LWLockRelease(partitionLock);
                    LWLockRelease(SerializablePredicateLockListLock);
                    LWLockAcquire(partitionLock, LW_SHARED);
+
+                   /*
+                    * The list may have been altered by another process
+                    * while we weren't holding the partition lock.  Start
+                    * over at the front.
+                    */
+                   nextpredlock = (PREDICATELOCK *)
+                       SHMQueueNext(&(target->predicateLocks),
+                                    &(target->predicateLocks),
+                                    offsetof(PREDICATELOCK, targetLink));
+
                    LWLockAcquire(SerializableXactHashLock, LW_SHARED);
                }
            }
@@ -3770,7 +3781,19 @@ CheckTargetForConflictsIn(PREDICATELOCKTARGETTAG *targettag)
            LWLockRelease(SerializableXactHashLock);
            LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
-           FlagRWConflict(sxact, (SERIALIZABLEXACT *) MySerializableXact);
+           /*
+            * Re-check after getting exclusive lock because the other
+            * transaction may have flagged a conflict.
+            */
+           if (!SxactIsRolledBack(sxact)
+               && (!SxactIsCommitted(sxact)
+                   || TransactionIdPrecedes(GetTransactionSnapshot()->xmin,
+                                            sxact->finishedBefore))
+               && !RWConflictExists(sxact,
+                                    (SERIALIZABLEXACT *) MySerializableXact))
+           {
+               FlagRWConflict(sxact, (SERIALIZABLEXACT *) MySerializableXact);
+           }
 
            LWLockRelease(SerializableXactHashLock);
            LWLockAcquire(SerializableXactHashLock, LW_SHARED);