predicate.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/slru.h"
#include "access/subtrans.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/twophase_rmgr.h"
#include "access/xact.h"
#include "access/xlog.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "storage/predicate.h"
#include "storage/predicate_internals.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/tqual.h"

Include dependency graph for predicate.c:

Go to the source code of this file.

Data Structures
struct	OldSerXidControlData

Macros
#define	TargetTagIsCoveredBy(covered_target, covering_target)
#define	PredicateLockHashPartition(hashcode)   ((hashcode) % NUM_PREDICATELOCK_PARTITIONS)
#define	PredicateLockHashPartitionLock(hashcode)
#define	PredicateLockHashPartitionLockByIndex(i)   (&MainLWLockArray[PREDICATELOCK_MANAGER_LWLOCK_OFFSET + (i)].lock)
#define	NPREDICATELOCKTARGETENTS()   mul_size(max_predicate_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))
#define	SxactIsOnFinishedList(sxact)   (!SHMQueueIsDetached(&((sxact)->finishedLink)))
#define	SxactIsCommitted(sxact)   (((sxact)->flags & SXACT_FLAG_COMMITTED) != 0)
#define	SxactIsPrepared(sxact)   (((sxact)->flags & SXACT_FLAG_PREPARED) != 0)
#define	SxactIsRolledBack(sxact)   (((sxact)->flags & SXACT_FLAG_ROLLED_BACK) != 0)
#define	SxactIsDoomed(sxact)   (((sxact)->flags & SXACT_FLAG_DOOMED) != 0)
#define	SxactIsReadOnly(sxact)   (((sxact)->flags & SXACT_FLAG_READ_ONLY) != 0)
#define	SxactHasSummaryConflictIn(sxact)   (((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_IN) != 0)
#define	SxactHasSummaryConflictOut(sxact)   (((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_OUT) != 0)
#define	SxactHasConflictOut(sxact)   (((sxact)->flags & SXACT_FLAG_CONFLICT_OUT) != 0)
#define	SxactIsDeferrableWaiting(sxact)   (((sxact)->flags & SXACT_FLAG_DEFERRABLE_WAITING) != 0)
#define	SxactIsROSafe(sxact)   (((sxact)->flags & SXACT_FLAG_RO_SAFE) != 0)
#define	SxactIsROUnsafe(sxact)   (((sxact)->flags & SXACT_FLAG_RO_UNSAFE) != 0)
#define	PredicateLockTargetTagHashCode(predicatelocktargettag)   get_hash_value(PredicateLockTargetHash, predicatelocktargettag)
#define	PredicateLockHashCodeFromTargetHashCode(predicatelocktag, targethash)
#define	OldSerXidSlruCtl   (&OldSerXidSlruCtlData)
#define	OLDSERXID_PAGESIZE   BLCKSZ
#define	OLDSERXID_ENTRYSIZE   sizeof(SerCommitSeqNo)
#define	OLDSERXID_ENTRIESPERPAGE   (OLDSERXID_PAGESIZE / OLDSERXID_ENTRYSIZE)
#define	OLDSERXID_MAX_PAGE
#define	OldSerXidNextPage(page)   (((page) >= OLDSERXID_MAX_PAGE) ? 0 : (page) + 1)
#define	OldSerXidValue(slotno, xid)
#define	OldSerXidPage(xid)   ((((uint32) (xid)) / OLDSERXID_ENTRIESPERPAGE) % (OLDSERXID_MAX_PAGE + 1))
#define	OldSerXidSegment(page)   ((page) / SLRU_PAGES_PER_SEGMENT)

Typedefs
typedef struct OldSerXidControlData	OldSerXidControlData
typedef struct OldSerXidControlData *	OldSerXidControl

Functions
static SERIALIZABLEXACT *	CreatePredXact (void)
static void	ReleasePredXact (SERIALIZABLEXACT *sxact)
static SERIALIZABLEXACT *	FirstPredXact (void)
static SERIALIZABLEXACT *	NextPredXact (SERIALIZABLEXACT *sxact)
static bool	RWConflictExists (const SERIALIZABLEXACT *reader, const SERIALIZABLEXACT *writer)
static void	SetRWConflict (SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
static void	SetPossibleUnsafeConflict (SERIALIZABLEXACT *roXact, SERIALIZABLEXACT *activeXact)
static void	ReleaseRWConflict (RWConflict conflict)
static void	FlagSxactUnsafe (SERIALIZABLEXACT *sxact)
static bool	OldSerXidPagePrecedesLogically (int p, int q)
static void	OldSerXidInit (void)
static void	OldSerXidAdd (TransactionId xid, SerCommitSeqNo minConflictCommitSeqNo)
static SerCommitSeqNo	OldSerXidGetMinConflictCommitSeqNo (TransactionId xid)
static void	OldSerXidSetActiveSerXmin (TransactionId xid)
static uint32	predicatelock_hash (const void *key, Size keysize)
static void	SummarizeOldestCommittedSxact (void)
static Snapshot	GetSafeSnapshot (Snapshot snapshot)
static Snapshot	GetSerializableTransactionSnapshotInt (Snapshot snapshot, VirtualTransactionId *sourcevxid, int sourcepid)
static bool	PredicateLockExists (const PREDICATELOCKTARGETTAG *targettag)
static bool	GetParentPredicateLockTag (const PREDICATELOCKTARGETTAG *tag, PREDICATELOCKTARGETTAG *parent)
static bool	CoarserLockCovers (const PREDICATELOCKTARGETTAG *newtargettag)
static void	RemoveScratchTarget (bool lockheld)
static void	RestoreScratchTarget (bool lockheld)
static void	RemoveTargetIfNoLongerUsed (PREDICATELOCKTARGET *target, uint32 targettaghash)
static void	DeleteChildTargetLocks (const PREDICATELOCKTARGETTAG *newtargettag)
static int	MaxPredicateChildLocks (const PREDICATELOCKTARGETTAG *tag)
static bool	CheckAndPromotePredicateLockRequest (const PREDICATELOCKTARGETTAG *reqtag)
static void	DecrementParentLocks (const PREDICATELOCKTARGETTAG *targettag)
static void	CreatePredicateLock (const PREDICATELOCKTARGETTAG *targettag, uint32 targettaghash, SERIALIZABLEXACT *sxact)
static void	DeleteLockTarget (PREDICATELOCKTARGET *target, uint32 targettaghash)
static bool	TransferPredicateLocksToNewTarget (PREDICATELOCKTARGETTAG oldtargettag, PREDICATELOCKTARGETTAG newtargettag, bool removeOld)
static void	PredicateLockAcquire (const PREDICATELOCKTARGETTAG *targettag)
static void	DropAllPredicateLocksFromTable (Relation relation, bool transfer)
static void	SetNewSxactGlobalXmin (void)
static void	ClearOldPredicateLocks (void)
static void	ReleaseOneSerializableXact (SERIALIZABLEXACT *sxact, bool partial, bool summarize)
static bool	XidIsConcurrent (TransactionId xid)
static void	CheckTargetForConflictsIn (PREDICATELOCKTARGETTAG *targettag)
static void	FlagRWConflict (SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
static void	OnConflict_CheckForSerializationFailure (const SERIALIZABLEXACT *reader, SERIALIZABLEXACT *writer)
static bool	PredicateLockingNeededForRelation (Relation relation)
static bool	SerializationNeededForRead (Relation relation, Snapshot snapshot)
static bool	SerializationNeededForWrite (Relation relation)
void	CheckPointPredicate (void)
void	InitPredicateLocks (void)
Size	PredicateLockShmemSize (void)
PredicateLockData *	GetPredicateLockStatusData (void)
int	GetSafeSnapshotBlockingPids (int blocked_pid, int *output, int output_size)
Snapshot	GetSerializableTransactionSnapshot (Snapshot snapshot)
void	SetSerializableTransactionSnapshot (Snapshot snapshot, VirtualTransactionId *sourcevxid, int sourcepid)
void	RegisterPredicateLockingXid (TransactionId xid)
bool	PageIsPredicateLocked (Relation relation, BlockNumber blkno)
void	PredicateLockRelation (Relation relation, Snapshot snapshot)
void	PredicateLockPage (Relation relation, BlockNumber blkno, Snapshot snapshot)
void	PredicateLockTuple (Relation relation, HeapTuple tuple, Snapshot snapshot)
void	TransferPredicateLocksToHeapRelation (Relation relation)
void	PredicateLockPageSplit (Relation relation, BlockNumber oldblkno, BlockNumber newblkno)
void	PredicateLockPageCombine (Relation relation, BlockNumber oldblkno, BlockNumber newblkno)
void	ReleasePredicateLocks (bool isCommit)
void	CheckForSerializableConflictOut (bool visible, Relation relation, HeapTuple tuple, Buffer buffer, Snapshot snapshot)
void	CheckForSerializableConflictIn (Relation relation, HeapTuple tuple, Buffer buffer)
void	CheckTableForSerializableConflictIn (Relation relation)
void	PreCommit_CheckForSerializationFailure (void)
void	AtPrepare_PredicateLocks (void)
void	PostPrepare_PredicateLocks (TransactionId xid)
void	PredicateLockTwoPhaseFinish (TransactionId xid, bool isCommit)
void	predicatelock_twophase_recover (TransactionId xid, uint16 info, void *recdata, uint32 len)

Variables
static SlruCtlData	OldSerXidSlruCtlData
static OldSerXidControl	oldSerXidControl
static SERIALIZABLEXACT *	OldCommittedSxact
int	max_predicate_locks_per_xact
int	max_predicate_locks_per_relation
int	max_predicate_locks_per_page
static PredXactList	PredXact
static RWConflictPoolHeader	RWConflictPool
static HTAB *	SerializableXidHash
static HTAB *	PredicateLockTargetHash
static HTAB *	PredicateLockHash
static SHM_QUEUE *	FinishedSerializableTransactions
static const PREDICATELOCKTARGETTAG	ScratchTargetTag = {0, 0, 0, 0}
static uint32	ScratchTargetTagHash
static LWLock *	ScratchPartitionLock
static HTAB *	LocalPredicateLockHash = NULL
static SERIALIZABLEXACT *	MySerializableXact = InvalidSerializableXact
static bool	MyXactDidWrite = false

Macro Definition Documentation

#define NPREDICATELOCKTARGETENTS

(

)

mul_size(max_predicate_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))

Definition at line 253 of file predicate.c.

Referenced by InitPredicateLocks(), and PredicateLockShmemSize().

#define OLDSERXID_ENTRIESPERPAGE   (OLDSERXID_PAGESIZE / OLDSERXID_ENTRYSIZE)

Definition at line 318 of file predicate.c.

#define OLDSERXID_ENTRYSIZE   sizeof(SerCommitSeqNo)

Definition at line 317 of file predicate.c.

#define OLDSERXID_MAX_PAGE

Value:

Min(SLRU_PAGES_PER_SEGMENT * 0x10000 - 1, \
                                        (MaxTransactionId) / OLDSERXID_ENTRIESPERPAGE)

Definition at line 324 of file predicate.c.

Referenced by OldSerXidPagePrecedesLogically().

#define OLDSERXID_PAGESIZE   BLCKSZ

Definition at line 316 of file predicate.c.

#define OldSerXidNextPage

(

page

)

(((page) >= OLDSERXID_MAX_PAGE) ? 0 : (page) + 1)

Definition at line 327 of file predicate.c.

Referenced by OldSerXidAdd().

#define OldSerXidPage

(

xid

)

((((uint32) (xid)) / OLDSERXID_ENTRIESPERPAGE) % (OLDSERXID_MAX_PAGE + 1))

Definition at line 333 of file predicate.c.

Referenced by CheckPointPredicate(), OldSerXidAdd(), and OldSerXidGetMinConflictCommitSeqNo().

#define OldSerXidSegment

(

page

)

((page) / SLRU_PAGES_PER_SEGMENT)

Definition at line 334 of file predicate.c.

#define OldSerXidSlruCtl   (&OldSerXidSlruCtlData)

Definition at line 314 of file predicate.c.

Referenced by CheckPointPredicate(), OldSerXidAdd(), OldSerXidGetMinConflictCommitSeqNo(), and OldSerXidInit().

#define OldSerXidValue	(		slotno,
			xid
	)

Value:

(*((SerCommitSeqNo *) \
    (OldSerXidSlruCtl->shared->page_buffer[slotno] + \
    ((((uint32) (xid)) % OLDSERXID_ENTRIESPERPAGE) * OLDSERXID_ENTRYSIZE))))

Definition at line 329 of file predicate.c.

Referenced by OldSerXidAdd(), and OldSerXidGetMinConflictCommitSeqNo().

#define PredicateLockHashCodeFromTargetHashCode	(		predicatelocktag,
			targethash
	)

Value:

((targethash) ^ ((uint32) PointerGetDatum((predicatelocktag)->myXact)) \
     << LOG2_NUM_PREDICATELOCK_PARTITIONS)

Definition at line 304 of file predicate.c.

Referenced by CheckTargetForConflictsIn(), ClearOldPredicateLocks(), CreatePredicateLock(), DeleteChildTargetLocks(), DeleteLockTarget(), DropAllPredicateLocksFromTable(), predicatelock_hash(), ReleaseOneSerializableXact(), and TransferPredicateLocksToNewTarget().

#define PredicateLockHashPartition

(

hashcode

)

((hashcode) % NUM_PREDICATELOCK_PARTITIONS)

Definition at line 245 of file predicate.c.

#define PredicateLockHashPartitionLock

(

hashcode

)

Value:

(&MainLWLockArray[PREDICATELOCK_MANAGER_LWLOCK_OFFSET + \
		PredicateLockHashPartition(hashcode)].lock)

Definition at line 247 of file predicate.c.

Referenced by CheckTargetForConflictsIn(), ClearOldPredicateLocks(), CreatePredicateLock(), DeleteChildTargetLocks(), DeleteLockTarget(), InitPredicateLocks(), PageIsPredicateLocked(), ReleaseOneSerializableXact(), and TransferPredicateLocksToNewTarget().

#define PredicateLockHashPartitionLockByIndex

(

i

)

(&MainLWLockArray[PREDICATELOCK_MANAGER_LWLOCK_OFFSET + (i)].lock)

Definition at line 250 of file predicate.c.

Referenced by CheckTableForSerializableConflictIn(), DropAllPredicateLocksFromTable(), and GetPredicateLockStatusData().

#define PredicateLockTargetTagHashCode

(

predicatelocktargettag

)

get_hash_value(PredicateLockTargetHash, predicatelocktargettag)

Definition at line 291 of file predicate.c.

Referenced by CheckTargetForConflictsIn(), ClearOldPredicateLocks(), DecrementParentLocks(), DeleteChildTargetLocks(), DropAllPredicateLocksFromTable(), InitPredicateLocks(), PageIsPredicateLocked(), predicatelock_hash(), predicatelock_twophase_recover(), PredicateLockAcquire(), ReleaseOneSerializableXact(), and TransferPredicateLocksToNewTarget().

#define SxactHasConflictOut

(

sxact

)

(((sxact)->flags & SXACT_FLAG_CONFLICT_OUT) != 0)

Definition at line 278 of file predicate.c.

Referenced by CheckForSerializableConflictOut(), OnConflict_CheckForSerializationFailure(), ReleasePredicateLocks(), and SummarizeOldestCommittedSxact().

#define SxactHasSummaryConflictIn

(

sxact

)

(((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_IN) != 0)

Definition at line 271 of file predicate.c.

Referenced by CheckForSerializableConflictOut(), and OnConflict_CheckForSerializationFailure().

#define SxactHasSummaryConflictOut

(

sxact

)

(((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_OUT) != 0)

Definition at line 272 of file predicate.c.

Referenced by CheckForSerializableConflictOut(), OnConflict_CheckForSerializationFailure(), and ReleasePredicateLocks().

#define SxactIsCommitted

(

sxact

)

(((sxact)->flags & SXACT_FLAG_COMMITTED) != 0)

Definition at line 266 of file predicate.c.

Referenced by CheckForSerializableConflictOut(), CheckTargetForConflictsIn(), GetSerializableTransactionSnapshotInt(), OnConflict_CheckForSerializationFailure(), PreCommit_CheckForSerializationFailure(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), and SetNewSxactGlobalXmin().

#define SxactIsDeferrableWaiting

(

sxact

)

(((sxact)->flags & SXACT_FLAG_DEFERRABLE_WAITING) != 0)

Definition at line 279 of file predicate.c.

Referenced by GetSafeSnapshotBlockingPids(), and ReleasePredicateLocks().

#define SxactIsDoomed

(

sxact

)

(((sxact)->flags & SXACT_FLAG_DOOMED) != 0)

Definition at line 269 of file predicate.c.

Referenced by CheckForSerializableConflictIn(), CheckForSerializableConflictOut(), CheckTargetForConflictsIn(), GetSerializableTransactionSnapshotInt(), OnConflict_CheckForSerializationFailure(), PreCommit_CheckForSerializationFailure(), ReleasePredicateLocks(), and RWConflictExists().

#define SxactIsOnFinishedList

(

sxact

)

(!SHMQueueIsDetached(&((sxact)->finishedLink)))

Definition at line 256 of file predicate.c.

Referenced by ReleaseOneSerializableXact(), and ReleasePredicateLocks().

#define SxactIsPrepared

(

sxact

)

(((sxact)->flags & SXACT_FLAG_PREPARED) != 0)

Definition at line 267 of file predicate.c.

Referenced by CheckForSerializableConflictOut(), OnConflict_CheckForSerializationFailure(), PostPrepare_PredicateLocks(), PreCommit_CheckForSerializationFailure(), predicatelock_twophase_recover(), and ReleasePredicateLocks().

#define SxactIsReadOnly

(

sxact

)

(((sxact)->flags & SXACT_FLAG_READ_ONLY) != 0)

Definition at line 270 of file predicate.c.

Referenced by CheckForSerializableConflictOut(), ClearOldPredicateLocks(), FlagSxactUnsafe(), GetSerializableTransactionSnapshotInt(), OnConflict_CheckForSerializationFailure(), PreCommit_CheckForSerializationFailure(), predicatelock_twophase_recover(), ReleasePredicateLocks(), SetPossibleUnsafeConflict(), and SummarizeOldestCommittedSxact().

#define SxactIsRolledBack

(

sxact

)

(((sxact)->flags & SXACT_FLAG_ROLLED_BACK) != 0)

Definition at line 268 of file predicate.c.

Referenced by ReleaseOneSerializableXact(), ReleasePredicateLocks(), and SetNewSxactGlobalXmin().

#define SxactIsROSafe

(

sxact

)

(((sxact)->flags & SXACT_FLAG_RO_SAFE) != 0)

Definition at line 280 of file predicate.c.

Referenced by FlagSxactUnsafe(), GetSafeSnapshot(), ReleasePredicateLocks(), and SerializationNeededForRead().

#define SxactIsROUnsafe

(

sxact

)

(((sxact)->flags & SXACT_FLAG_RO_UNSAFE) != 0)

Definition at line 281 of file predicate.c.

Referenced by GetSafeSnapshot(), and ReleasePredicateLocks().

#define TargetTagIsCoveredBy	(		covered_target,
			covering_target
	)

Value:

((GET_PREDICATELOCKTARGETTAG_RELATION(covered_target) == /* (2) */  \
	  GET_PREDICATELOCKTARGETTAG_RELATION(covering_target))                \
     && (GET_PREDICATELOCKTARGETTAG_OFFSET(covering_target) ==          \
		 InvalidOffsetNumber)                              /* (3) */  \
     && (((GET_PREDICATELOCKTARGETTAG_OFFSET(covered_target) !=         \
           InvalidOffsetNumber)                              /* (4a) */ \
          && (GET_PREDICATELOCKTARGETTAG_PAGE(covering_target) ==       \
              GET_PREDICATELOCKTARGETTAG_PAGE(covered_target)))         \
         || ((GET_PREDICATELOCKTARGETTAG_PAGE(covering_target) ==       \
			  InvalidBlockNumber)                             /* (4b) */ \
             && (GET_PREDICATELOCKTARGETTAG_PAGE(covered_target)        \
                 != InvalidBlockNumber)))                               \
     && (GET_PREDICATELOCKTARGETTAG_DB(covered_target) ==    /* (1) */  \
		 GET_PREDICATELOCKTARGETTAG_DB(covering_target)))

Definition at line 222 of file predicate.c.

Referenced by DeleteChildTargetLocks().

Typedef Documentation

typedef struct OldSerXidControlData* OldSerXidControl

Definition at line 344 of file predicate.c.

typedef struct OldSerXidControlData OldSerXidControlData

Function Documentation

void AtPrepare_PredicateLocks

(

void

)

Definition at line 4805 of file predicate.c.

References TwoPhasePredicateRecord::data, SERIALIZABLEXACT::flags, TwoPhasePredicateXactRecord::flags, InvalidSerializableXact, TwoPhasePredicateRecord::lockRecord, LW_SHARED, LWLockAcquire(), LWLockRelease(), MySerializableXact, PREDICATELOCKTAG::myTarget, offsetof, SERIALIZABLEXACT::predicateLocks, RegisterTwoPhaseRecord(), SHMQueueNext(), PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, TwoPhasePredicateLockRecord::target, TWOPHASE_RM_PREDICATELOCK_ID, TWOPHASEPREDICATERECORD_LOCK, TWOPHASEPREDICATERECORD_XACT, TwoPhasePredicateRecord::type, PREDICATELOCK::xactLink, TwoPhasePredicateRecord::xactRecord, SERIALIZABLEXACT::xmin, and TwoPhasePredicateXactRecord::xmin.

Referenced by PrepareTransaction().

{
    PREDICATELOCK *predlock;
    SERIALIZABLEXACT *sxact;
    TwoPhasePredicateRecord record;
    TwoPhasePredicateXactRecord *xactRecord;
    TwoPhasePredicateLockRecord *lockRecord;

    sxact = MySerializableXact;
    xactRecord = &(record.data.xactRecord);
    lockRecord = &(record.data.lockRecord);

    if (MySerializableXact == InvalidSerializableXact)
        return;

    /* Generate an xact record for our SERIALIZABLEXACT */
    record.type = TWOPHASEPREDICATERECORD_XACT;
    xactRecord->xmin = MySerializableXact->xmin;
    xactRecord->flags = MySerializableXact->flags;

    /*
     * Note that we don't include the list of conflicts in our out in the
     * statefile, because new conflicts can be added even after the
     * transaction prepares. We'll just make a conservative assumption during
     * recovery instead.
     */

    RegisterTwoPhaseRecord(TWOPHASE_RM_PREDICATELOCK_ID, 0,
                           &record, sizeof(record));

    /*
     * Generate a lock record for each lock.
     *
     * To do this, we need to walk the predicate lock list in our sxact rather
     * than using the local predicate lock table because the latter is not
     * guaranteed to be accurate.
     */
    LWLockAcquire(SerializablePredicateLockListLock, LW_SHARED);

    predlock = (PREDICATELOCK *)
        SHMQueueNext(&(sxact->predicateLocks),
                     &(sxact->predicateLocks),
                     offsetof(PREDICATELOCK, xactLink));

    while (predlock != NULL)
    {
        record.type = TWOPHASEPREDICATERECORD_LOCK;
        lockRecord->target = predlock->tag.myTarget->tag;

        RegisterTwoPhaseRecord(TWOPHASE_RM_PREDICATELOCK_ID, 0,
                               &record, sizeof(record));

        predlock = (PREDICATELOCK *)
            SHMQueueNext(&(sxact->predicateLocks),
                         &(predlock->xactLink),
                         offsetof(PREDICATELOCK, xactLink));
    }

    LWLockRelease(SerializablePredicateLockListLock);
}

static bool CheckAndPromotePredicateLockRequest ( const PREDICATELOCKTARGETTAG *  reqtag )

static

Definition at line 2251 of file predicate.c.

References LOCALPREDICATELOCK::childLocks, GetParentPredicateLockTag(), HASH_ENTER, hash_search(), LOCALPREDICATELOCK::held, MaxPredicateChildLocks(), and PredicateLockAcquire().

Referenced by PredicateLockAcquire().

{
    PREDICATELOCKTARGETTAG targettag,
                nexttag,
                promotiontag;
    LOCALPREDICATELOCK *parentlock;
    bool        found,
                promote;

    promote = false;

    targettag = *reqtag;

    /* check parents iteratively */
    while (GetParentPredicateLockTag(&targettag, &nexttag))
    {
        targettag = nexttag;
        parentlock = (LOCALPREDICATELOCK *) hash_search(LocalPredicateLockHash,
                                                        &targettag,
                                                        HASH_ENTER,
                                                        &found);
        if (!found)
        {
            parentlock->held = false;
            parentlock->childLocks = 1;
        }
        else
            parentlock->childLocks++;

        if (parentlock->childLocks >
            MaxPredicateChildLocks(&targettag))
        {
            /*
             * We should promote to this parent lock. Continue to check its
             * ancestors, however, both to get their child counts right and to
             * check whether we should just go ahead and promote to one of
             * them.
             */
            promotiontag = targettag;
            promote = true;
        }
    }

    if (promote)
    {
        /* acquire coarsest ancestor eligible for promotion */
        PredicateLockAcquire(&promotiontag);
        return true;
    }
    else
        return false;
}

void CheckForSerializableConflictIn	(	Relation	relation,
		HeapTuple	tuple,
		Buffer	buffer
	)

Definition at line 4326 of file predicate.c.

References BufferGetBlockNumber(), BufferIsValid, CheckTargetForConflictsIn(), RelFileNode::dbNode, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), ERROR, ItemPointerGetBlockNumber, ItemPointerGetOffsetNumber, MyXactDidWrite, RelationData::rd_id, RelationData::rd_node, SerializationNeededForWrite(), SET_PREDICATELOCKTARGETTAG_PAGE, SET_PREDICATELOCKTARGETTAG_RELATION, SET_PREDICATELOCKTARGETTAG_TUPLE, SxactIsDoomed, and HeapTupleData::t_self.

Referenced by _bt_check_unique(), _bt_doinsert(), heap_delete(), heap_insert(), heap_multi_insert(), heap_update(), and index_insert().

{
    PREDICATELOCKTARGETTAG targettag;

    if (!SerializationNeededForWrite(relation))
        return;

    /* Check if someone else has already decided that we need to die */
    if (SxactIsDoomed(MySerializableXact))
        ereport(ERROR,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                 errdetail_internal("Reason code: Canceled on identification as a pivot, during conflict in checking."),
                 errhint("The transaction might succeed if retried.")));

    /*
     * We're doing a write which might cause rw-conflicts now or later.
     * Memorize that fact.
     */
    MyXactDidWrite = true;

    /*
     * It is important that we check for locks from the finest granularity to
     * the coarsest granularity, so that granularity promotion doesn't cause
     * us to miss a lock.  The new (coarser) lock will be acquired before the
     * old (finer) locks are released.
     *
     * It is not possible to take and hold a lock across the checks for all
     * granularities because each target could be in a separate partition.
     */
    if (tuple != NULL)
    {
        SET_PREDICATELOCKTARGETTAG_TUPLE(targettag,
                                         relation->rd_node.dbNode,
                                         relation->rd_id,
                                         ItemPointerGetBlockNumber(&(tuple->t_self)),
                                         ItemPointerGetOffsetNumber(&(tuple->t_self)));
        CheckTargetForConflictsIn(&targettag);
    }

    if (BufferIsValid(buffer))
    {
        SET_PREDICATELOCKTARGETTAG_PAGE(targettag,
                                        relation->rd_node.dbNode,
                                        relation->rd_id,
                                        BufferGetBlockNumber(buffer));
        CheckTargetForConflictsIn(&targettag);
    }

    SET_PREDICATELOCKTARGETTAG_RELATION(targettag,
                                        relation->rd_node.dbNode,
                                        relation->rd_id);
    CheckTargetForConflictsIn(&targettag);
}

void CheckForSerializableConflictOut	(	bool	visible,
		Relation	relation,
		HeapTuple	tuple,
		Buffer	buffer,
		Snapshot	snapshot
	)

Definition at line 3945 of file predicate.c.

References Assert, SERIALIZABLEXACT::earliestOutConflictCommit, elog, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), ERROR, FlagRWConflict(), SERIALIZABLEXACT::flags, GetTopTransactionIdIfAny(), HASH_FIND, hash_search(), HEAPTUPLE_DEAD, HEAPTUPLE_DELETE_IN_PROGRESS, HEAPTUPLE_INSERT_IN_PROGRESS, HEAPTUPLE_LIVE, HEAPTUPLE_RECENTLY_DEAD, HeapTupleHeaderGetUpdateXid, HeapTupleHeaderGetXmin, HeapTupleSatisfiesVacuum(), SERIALIZABLEXACT::inConflicts, InvalidSerCommitSeqNo, InvalidTransactionId, SERIALIZABLEXACT::lastCommitBeforeSnapshot, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SERIALIZABLEXID::myXact, OldSerXidGetMinConflictCommitSeqNo(), RWConflictExists(), SERIALIZABLEXACT::SeqNo, SerializationNeededForRead(), SHMQueueEmpty(), SubTransGetTopmostTransaction(), SXACT_FLAG_DOOMED, SXACT_FLAG_SUMMARY_CONFLICT_OUT, SxactHasConflictOut, SxactHasSummaryConflictIn, SxactHasSummaryConflictOut, SxactIsCommitted, SxactIsDoomed, SxactIsPrepared, SxactIsReadOnly, HeapTupleData::t_data, SERIALIZABLEXACT::topXid, TransactionIdEquals, TransactionIdFollowsOrEquals(), TransactionIdIsValid, TransactionIdPrecedes(), TransactionXmin, SERIALIZABLEXIDTAG::xid, and XidIsConcurrent().

Referenced by bitgetpage(), heap_fetch(), heap_get_latest_tid(), heap_hot_search_buffer(), heapgetpage(), heapgettup(), and tablesample_getnext().

{
    TransactionId xid;
    SERIALIZABLEXIDTAG sxidtag;
    SERIALIZABLEXID *sxid;
    SERIALIZABLEXACT *sxact;
    HTSV_Result htsvResult;

    if (!SerializationNeededForRead(relation, snapshot))
        return;

    /* Check if someone else has already decided that we need to die */
    if (SxactIsDoomed(MySerializableXact))
    {
        ereport(ERROR,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                 errdetail_internal("Reason code: Canceled on identification as a pivot, during conflict out checking."),
                 errhint("The transaction might succeed if retried.")));
    }

    /*
     * Check to see whether the tuple has been written to by a concurrent
     * transaction, either to create it not visible to us, or to delete it
     * while it is visible to us.  The "visible" bool indicates whether the
     * tuple is visible to us, while HeapTupleSatisfiesVacuum checks what else
     * is going on with it.
     */
    htsvResult = HeapTupleSatisfiesVacuum(tuple, TransactionXmin, buffer);
    switch (htsvResult)
    {
        case HEAPTUPLE_LIVE:
            if (visible)
                return;
            xid = HeapTupleHeaderGetXmin(tuple->t_data);
            break;
        case HEAPTUPLE_RECENTLY_DEAD:
            if (!visible)
                return;
            xid = HeapTupleHeaderGetUpdateXid(tuple->t_data);
            break;
        case HEAPTUPLE_DELETE_IN_PROGRESS:
            xid = HeapTupleHeaderGetUpdateXid(tuple->t_data);
            break;
        case HEAPTUPLE_INSERT_IN_PROGRESS:
            xid = HeapTupleHeaderGetXmin(tuple->t_data);
            break;
        case HEAPTUPLE_DEAD:
            return;
        default:

            /*
             * The only way to get to this default clause is if a new value is
             * added to the enum type without adding it to this switch
             * statement.  That's a bug, so elog.
             */
            elog(ERROR, "unrecognized return value from HeapTupleSatisfiesVacuum: %u", htsvResult);

            /*
             * In spite of having all enum values covered and calling elog on
             * this default, some compilers think this is a code path which
             * allows xid to be used below without initialization. Silence
             * that warning.
             */
            xid = InvalidTransactionId;
    }
    Assert(TransactionIdIsValid(xid));
    Assert(TransactionIdFollowsOrEquals(xid, TransactionXmin));

    /*
     * Find top level xid.  Bail out if xid is too early to be a conflict, or
     * if it's our own xid.
     */
    if (TransactionIdEquals(xid, GetTopTransactionIdIfAny()))
        return;
    xid = SubTransGetTopmostTransaction(xid);
    if (TransactionIdPrecedes(xid, TransactionXmin))
        return;
    if (TransactionIdEquals(xid, GetTopTransactionIdIfAny()))
        return;

    /*
     * Find sxact or summarized info for the top level xid.
     */
    sxidtag.xid = xid;
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
    sxid = (SERIALIZABLEXID *)
        hash_search(SerializableXidHash, &sxidtag, HASH_FIND, NULL);
    if (!sxid)
    {
        /*
         * Transaction not found in "normal" SSI structures.  Check whether it
         * got pushed out to SLRU storage for "old committed" transactions.
         */
        SerCommitSeqNo conflictCommitSeqNo;

        conflictCommitSeqNo = OldSerXidGetMinConflictCommitSeqNo(xid);
        if (conflictCommitSeqNo != 0)
        {
            if (conflictCommitSeqNo != InvalidSerCommitSeqNo
                && (!SxactIsReadOnly(MySerializableXact)
                    || conflictCommitSeqNo
                    <= MySerializableXact->SeqNo.lastCommitBeforeSnapshot))
                ereport(ERROR,
                        (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                         errmsg("could not serialize access due to read/write dependencies among transactions"),
                         errdetail_internal("Reason code: Canceled on conflict out to old pivot %u.", xid),
                         errhint("The transaction might succeed if retried.")));

            if (SxactHasSummaryConflictIn(MySerializableXact)
                || !SHMQueueEmpty(&MySerializableXact->inConflicts))
                ereport(ERROR,
                        (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                         errmsg("could not serialize access due to read/write dependencies among transactions"),
                         errdetail_internal("Reason code: Canceled on identification as a pivot, with conflict out to old committed transaction %u.", xid),
                         errhint("The transaction might succeed if retried.")));

            MySerializableXact->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;
        }

        /* It's not serializable or otherwise not important. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }
    sxact = sxid->myXact;
    Assert(TransactionIdEquals(sxact->topXid, xid));
    if (sxact == MySerializableXact || SxactIsDoomed(sxact))
    {
        /* Can't conflict with ourself or a transaction that will roll back. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }

    /*
     * We have a conflict out to a transaction which has a conflict out to a
     * summarized transaction.  That summarized transaction must have
     * committed first, and we can't tell when it committed in relation to our
     * snapshot acquisition, so something needs to be canceled.
     */
    if (SxactHasSummaryConflictOut(sxact))
    {
        if (!SxactIsPrepared(sxact))
        {
            sxact->flags |= SXACT_FLAG_DOOMED;
            LWLockRelease(SerializableXactHashLock);
            return;
        }
        else
        {
            LWLockRelease(SerializableXactHashLock);
            ereport(ERROR,
                    (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                     errmsg("could not serialize access due to read/write dependencies among transactions"),
                     errdetail_internal("Reason code: Canceled on conflict out to old pivot."),
                     errhint("The transaction might succeed if retried.")));
        }
    }

    /*
     * If this is a read-only transaction and the writing transaction has
     * committed, and it doesn't have a rw-conflict to a transaction which
     * committed before it, no conflict.
     */
    if (SxactIsReadOnly(MySerializableXact)
        && SxactIsCommitted(sxact)
        && !SxactHasSummaryConflictOut(sxact)
        && (!SxactHasConflictOut(sxact)
            || MySerializableXact->SeqNo.lastCommitBeforeSnapshot < sxact->SeqNo.earliestOutConflictCommit))
    {
        /* Read-only transaction will appear to run first.  No conflict. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }

    if (!XidIsConcurrent(xid))
    {
        /* This write was already in our snapshot; no conflict. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }

    if (RWConflictExists(MySerializableXact, sxact))
    {
        /* We don't want duplicate conflict records in the list. */
        LWLockRelease(SerializableXactHashLock);
        return;
    }

    /*
     * Flag the conflict.  But first, if this conflict creates a dangerous
     * structure, ereport an error.
     */
    FlagRWConflict(MySerializableXact, sxact);
    LWLockRelease(SerializableXactHashLock);
}

void CheckPointPredicate

(

void

)

Definition at line 1043 of file predicate.c.

References OldSerXidControlData::headPage, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OldSerXidPage, OldSerXidSlruCtl, SimpleLruFlush(), SimpleLruTruncate(), OldSerXidControlData::tailXid, and TransactionIdIsValid.

Referenced by CheckPointGuts().

{
    int         tailPage;

    LWLockAcquire(OldSerXidLock, LW_EXCLUSIVE);

    /* Exit quickly if the SLRU is currently not in use. */
    if (oldSerXidControl->headPage < 0)
    {
        LWLockRelease(OldSerXidLock);
        return;
    }

    if (TransactionIdIsValid(oldSerXidControl->tailXid))
    {
        /* We can truncate the SLRU up to the page containing tailXid */
        tailPage = OldSerXidPage(oldSerXidControl->tailXid);
    }
    else
    {
        /*
         * The SLRU is no longer needed. Truncate to head before we set head
         * invalid.
         *
         * XXX: It's possible that the SLRU is not needed again until XID
         * wrap-around has happened, so that the segment containing headPage
         * that we leave behind will appear to be new again. In that case it
         * won't be removed until XID horizon advances enough to make it
         * current again.
         */
        tailPage = oldSerXidControl->headPage;
        oldSerXidControl->headPage = -1;
    }

    LWLockRelease(OldSerXidLock);

    /* Truncate away pages that are no longer required */
    SimpleLruTruncate(OldSerXidSlruCtl, tailPage);

    /*
     * Flush dirty SLRU pages to disk
     *
     * This is not actually necessary from a correctness point of view. We do
     * it merely as a debugging aid.
     *
     * We're doing this after the truncation to avoid writing pages right
     * before deleting the file in which they sit, which would be completely
     * pointless.
     */
    SimpleLruFlush(OldSerXidSlruCtl, true);
}

void CheckTableForSerializableConflictIn

(

Relation

relation

)

Definition at line 4410 of file predicate.c.

References Assert, RelFileNode::dbNode, FlagRWConflict(), GET_PREDICATELOCKTARGETTAG_DB, GET_PREDICATELOCKTARGETTAG_RELATION, hash_seq_init(), hash_seq_search(), i, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myXact, MyXactDidWrite, NUM_PREDICATELOCK_PARTITIONS, offsetof, PredicateLockHashPartitionLockByIndex, PREDICATELOCKTARGET::predicateLocks, RelationData::rd_id, RelationData::rd_index, RelationData::rd_node, RWConflictExists(), SerializationNeededForWrite(), SHMQueueNext(), PredXactListData::SxactGlobalXmin, PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, PREDICATELOCK::targetLink, and TransactionIdIsValid.

Referenced by ExecuteTruncate(), and heap_drop_with_catalog().

{
    HASH_SEQ_STATUS seqstat;
    PREDICATELOCKTARGET *target;
    Oid         dbId;
    Oid         heapId;
    int         i;

    /*
     * Bail out quickly if there are no serializable transactions running.
     * It's safe to check this without taking locks because the caller is
     * holding an ACCESS EXCLUSIVE lock on the relation.  No new locks which
     * would matter here can be acquired while that is held.
     */
    if (!TransactionIdIsValid(PredXact->SxactGlobalXmin))
        return;

    if (!SerializationNeededForWrite(relation))
        return;

    /*
     * We're doing a write which might cause rw-conflicts now or later.
     * Memorize that fact.
     */
    MyXactDidWrite = true;

    Assert(relation->rd_index == NULL); /* not an index relation */

    dbId = relation->rd_node.dbNode;
    heapId = relation->rd_id;

    LWLockAcquire(SerializablePredicateLockListLock, LW_EXCLUSIVE);
    for (i = 0; i < NUM_PREDICATELOCK_PARTITIONS; i++)
        LWLockAcquire(PredicateLockHashPartitionLockByIndex(i), LW_SHARED);
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);

    /* Scan through target list */
    hash_seq_init(&seqstat, PredicateLockTargetHash);

    while ((target = (PREDICATELOCKTARGET *) hash_seq_search(&seqstat)))
    {
        PREDICATELOCK *predlock;

        /*
         * Check whether this is a target which needs attention.
         */
        if (GET_PREDICATELOCKTARGETTAG_RELATION(target->tag) != heapId)
            continue;           /* wrong relation id */
        if (GET_PREDICATELOCKTARGETTAG_DB(target->tag) != dbId)
            continue;           /* wrong database id */

        /*
         * Loop through locks for this target and flag conflicts.
         */
        predlock = (PREDICATELOCK *)
            SHMQueueNext(&(target->predicateLocks),
                         &(target->predicateLocks),
                         offsetof(PREDICATELOCK, targetLink));
        while (predlock)
        {
            PREDICATELOCK *nextpredlock;

            nextpredlock = (PREDICATELOCK *)
                SHMQueueNext(&(target->predicateLocks),
                             &(predlock->targetLink),
                             offsetof(PREDICATELOCK, targetLink));

            if (predlock->tag.myXact != MySerializableXact
                && !RWConflictExists(predlock->tag.myXact, MySerializableXact))
            {
                FlagRWConflict(predlock->tag.myXact, MySerializableXact);
            }

            predlock = nextpredlock;
        }
    }

    /* Release locks in reverse order */
    LWLockRelease(SerializableXactHashLock);
    for (i = NUM_PREDICATELOCK_PARTITIONS - 1; i >= 0; i--)
        LWLockRelease(PredicateLockHashPartitionLockByIndex(i));
    LWLockRelease(SerializablePredicateLockListLock);
}

static void CheckTargetForConflictsIn ( PREDICATELOCKTARGETTAG *  targettag )

static

Definition at line 4148 of file predicate.c.

References Assert, DecrementParentLocks(), SERIALIZABLEXACT::finishedBefore, FlagRWConflict(), GET_PREDICATELOCKTARGETTAG_OFFSET, GetTransactionSnapshot(), HASH_FIND, HASH_REMOVE, hash_search_with_hash_value(), InvalidSerializableXact, IsSubTransaction(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myXact, offsetof, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, PREDICATELOCKTARGET::predicateLocks, PredicateLockTargetTagHashCode, RemoveTargetIfNoLongerUsed(), RWConflictExists(), SHMQueueDelete(), SHMQueueNext(), SxactIsCommitted, SxactIsDoomed, PREDICATELOCK::tag, PREDICATELOCK::targetLink, TransactionIdPrecedes(), and PREDICATELOCK::xactLink.

Referenced by CheckForSerializableConflictIn().

{
    uint32      targettaghash;
    LWLock     *partitionLock;
    PREDICATELOCKTARGET *target;
    PREDICATELOCK *predlock;
    PREDICATELOCK *mypredlock = NULL;
    PREDICATELOCKTAG mypredlocktag;

    Assert(MySerializableXact != InvalidSerializableXact);

    /*
     * The same hash and LW lock apply to the lock target and the lock itself.
     */
    targettaghash = PredicateLockTargetTagHashCode(targettag);
    partitionLock = PredicateLockHashPartitionLock(targettaghash);
    LWLockAcquire(partitionLock, LW_SHARED);
    target = (PREDICATELOCKTARGET *)
        hash_search_with_hash_value(PredicateLockTargetHash,
                                    targettag, targettaghash,
                                    HASH_FIND, NULL);
    if (!target)
    {
        /* Nothing has this target locked; we're done here. */
        LWLockRelease(partitionLock);
        return;
    }

    /*
     * Each lock for an overlapping transaction represents a conflict: a
     * rw-dependency in to this transaction.
     */
    predlock = (PREDICATELOCK *)
        SHMQueueNext(&(target->predicateLocks),
                     &(target->predicateLocks),
                     offsetof(PREDICATELOCK, targetLink));
    LWLockAcquire(SerializableXactHashLock, LW_SHARED);
    while (predlock)
    {
        SHM_QUEUE  *predlocktargetlink;
        PREDICATELOCK *nextpredlock;
        SERIALIZABLEXACT *sxact;

        predlocktargetlink = &(predlock->targetLink);
        nextpredlock = (PREDICATELOCK *)
            SHMQueueNext(&(target->predicateLocks),
                         predlocktargetlink,
                         offsetof(PREDICATELOCK, targetLink));

        sxact = predlock->tag.myXact;
        if (sxact == MySerializableXact)
        {
            /*
             * If we're getting a write lock on a tuple, we don't need a
             * predicate (SIREAD) lock on the same tuple. We can safely remove
             * our SIREAD lock, but we'll defer doing so until after the loop
             * because that requires upgrading to an exclusive partition lock.
             *
             * We can't use this optimization within a subtransaction because
             * the subtransaction could roll back, and we would be left
             * without any lock at the top level.
             */
            if (!IsSubTransaction()
                && GET_PREDICATELOCKTARGETTAG_OFFSET(*targettag))
            {
                mypredlock = predlock;
                mypredlocktag = predlock->tag;
            }
        }
        else if (!SxactIsDoomed(sxact)
                 && (!SxactIsCommitted(sxact)
                     || TransactionIdPrecedes(GetTransactionSnapshot()->xmin,
                                              sxact->finishedBefore))
                 && !RWConflictExists(sxact, MySerializableXact))
        {
            LWLockRelease(SerializableXactHashLock);
            LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);

            /*
             * Re-check after getting exclusive lock because the other
             * transaction may have flagged a conflict.
             */
            if (!SxactIsDoomed(sxact)
                && (!SxactIsCommitted(sxact)
                    || TransactionIdPrecedes(GetTransactionSnapshot()->xmin,
                                             sxact->finishedBefore))
                && !RWConflictExists(sxact, MySerializableXact))
            {
                FlagRWConflict(sxact, MySerializableXact);
            }

            LWLockRelease(SerializableXactHashLock);
            LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        }

        predlock = nextpredlock;
    }
    LWLockRelease(SerializableXactHashLock);
    LWLockRelease(partitionLock);

    /*
     * If we found one of our own SIREAD locks to remove, remove it now.
     *
     * At this point our transaction already has an ExclusiveRowLock on the
     * relation, so we are OK to drop the predicate lock on the tuple, if
     * found, without fearing that another write against the tuple will occur
     * before the MVCC information makes it to the buffer.
     */
    if (mypredlock != NULL)
    {
        uint32      predlockhashcode;
        PREDICATELOCK *rmpredlock;

        LWLockAcquire(SerializablePredicateLockListLock, LW_SHARED);
        LWLockAcquire(partitionLock, LW_EXCLUSIVE);
        LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);

        /*
         * Remove the predicate lock from shared memory, if it wasn't removed
         * while the locks were released.  One way that could happen is from
         * autovacuum cleaning up an index.
         */
        predlockhashcode = PredicateLockHashCodeFromTargetHashCode
            (&mypredlocktag, targettaghash);
        rmpredlock = (PREDICATELOCK *)
            hash_search_with_hash_value(PredicateLockHash,
                                        &mypredlocktag,
                                        predlockhashcode,
                                        HASH_FIND, NULL);
        if (rmpredlock != NULL)
        {
            Assert(rmpredlock == mypredlock);

            SHMQueueDelete(&(mypredlock->targetLink));
            SHMQueueDelete(&(mypredlock->xactLink));

            rmpredlock = (PREDICATELOCK *)
                hash_search_with_hash_value(PredicateLockHash,
                                            &mypredlocktag,
                                            predlockhashcode,
                                            HASH_REMOVE, NULL);
            Assert(rmpredlock == mypredlock);

            RemoveTargetIfNoLongerUsed(target, targettaghash);
        }

        LWLockRelease(SerializableXactHashLock);
        LWLockRelease(partitionLock);
        LWLockRelease(SerializablePredicateLockListLock);

        if (rmpredlock != NULL)
        {
            /*
             * Remove entry in local lock table if it exists. It's OK if it
             * doesn't exist; that means the lock was transferred to a new
             * target by a different backend.
             */
            hash_search_with_hash_value(LocalPredicateLockHash,
                                        targettag, targettaghash,
                                        HASH_REMOVE, NULL);

            DecrementParentLocks(targettag);
        }
    }
}

static void ClearOldPredicateLocks ( void  )

static

Definition at line 3586 of file predicate.c.

References Assert, PredXactListData::CanPartialClearThrough, SERIALIZABLEXACT::commitSeqNo, PREDICATELOCK::commitSeqNo, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, HASH_REMOVE, hash_search_with_hash_value(), PredXactListData::HavePartialClearedThrough, InvalidSerCommitSeqNo, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myTarget, offsetof, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PredicateLockTargetTagHashCode, ReleaseOneSerializableXact(), RemoveTargetIfNoLongerUsed(), SHMQueueDelete(), SHMQueueNext(), PredXactListData::SxactGlobalXmin, SxactIsReadOnly, PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, PREDICATELOCK::targetLink, TransactionIdIsValid, TransactionIdPrecedesOrEquals(), and PREDICATELOCK::xactLink.

Referenced by ReleasePredicateLocks().

{
    SERIALIZABLEXACT *finishedSxact;
    PREDICATELOCK *predlock;

    /*
     * Loop through finished transactions. They are in commit order, so we can
     * stop as soon as we find one that's still interesting.
     */
    LWLockAcquire(SerializableFinishedListLock, LW_EXCLUSIVE);
    finishedSxact = (SERIALIZABLEXACT *)
        SHMQueueNext(FinishedSerializableTransactions,
                     FinishedSerializableTransactions,
                     offsetof(SERIALIZABLEXACT, finishedLink));
    LWLockAcquire(SerializableXactHashLock, LW_SHARED);
    while (finishedSxact)
    {
        SERIALIZABLEXACT *nextSxact;

        nextSxact = (SERIALIZABLEXACT *)
            SHMQueueNext(FinishedSerializableTransactions,
                         &(finishedSxact->finishedLink),
                         offsetof(SERIALIZABLEXACT, finishedLink));
        if (!TransactionIdIsValid(PredXact->SxactGlobalXmin)
            || TransactionIdPrecedesOrEquals(finishedSxact->finishedBefore,
                                             PredXact->SxactGlobalXmin))
        {
            /*
             * This transaction committed before any in-progress transaction
             * took its snapshot. It's no longer interesting.
             */
            LWLockRelease(SerializableXactHashLock);
            SHMQueueDelete(&(finishedSxact->finishedLink));
            ReleaseOneSerializableXact(finishedSxact, false, false);
            LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        }
        else if (finishedSxact->commitSeqNo > PredXact->HavePartialClearedThrough
                 && finishedSxact->commitSeqNo <= PredXact->CanPartialClearThrough)
        {
            /*
             * Any active transactions that took their snapshot before this
             * transaction committed are read-only, so we can clear part of
             * its state.
             */
            LWLockRelease(SerializableXactHashLock);

            if (SxactIsReadOnly(finishedSxact))
            {
                /* A read-only transaction can be removed entirely */
                SHMQueueDelete(&(finishedSxact->finishedLink));
                ReleaseOneSerializableXact(finishedSxact, false, false);
            }
            else
            {
                /*
                 * A read-write transaction can only be partially cleared. We
                 * need to keep the SERIALIZABLEXACT but can release the
                 * SIREAD locks and conflicts in.
                 */
                ReleaseOneSerializableXact(finishedSxact, true, false);
            }

            PredXact->HavePartialClearedThrough = finishedSxact->commitSeqNo;
            LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        }
        else
        {
            /* Still interesting. */
            break;
        }
        finishedSxact = nextSxact;
    }
    LWLockRelease(SerializableXactHashLock);

    /*
     * Loop through predicate locks on dummy transaction for summarized data.
     */
    LWLockAcquire(SerializablePredicateLockListLock, LW_SHARED);
    predlock = (PREDICATELOCK *)
        SHMQueueNext(&OldCommittedSxact->predicateLocks,
                     &OldCommittedSxact->predicateLocks,
                     offsetof(PREDICATELOCK, xactLink));
    while (predlock)
    {
        PREDICATELOCK *nextpredlock;
        bool        canDoPartialCleanup;

        nextpredlock = (PREDICATELOCK *)
            SHMQueueNext(&OldCommittedSxact->predicateLocks,
                         &predlock->xactLink,
                         offsetof(PREDICATELOCK, xactLink));

        LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        Assert(predlock->commitSeqNo != 0);
        Assert(predlock->commitSeqNo != InvalidSerCommitSeqNo);
        canDoPartialCleanup = (predlock->commitSeqNo <= PredXact->CanPartialClearThrough);
        LWLockRelease(SerializableXactHashLock);

        /*
         * If this lock originally belonged to an old enough transaction, we
         * can release it.
         */
        if (canDoPartialCleanup)
        {
            PREDICATELOCKTAG tag;
            PREDICATELOCKTARGET *target;
            PREDICATELOCKTARGETTAG targettag;
            uint32      targettaghash;
            LWLock     *partitionLock;

            tag = predlock->tag;
            target = tag.myTarget;
            targettag = target->tag;
            targettaghash = PredicateLockTargetTagHashCode(&targettag);
            partitionLock = PredicateLockHashPartitionLock(targettaghash);

            LWLockAcquire(partitionLock, LW_EXCLUSIVE);

            SHMQueueDelete(&(predlock->targetLink));
            SHMQueueDelete(&(predlock->xactLink));

            hash_search_with_hash_value(PredicateLockHash, &tag,
                                        PredicateLockHashCodeFromTargetHashCode(&tag,
                                                                                targettaghash),
                                        HASH_REMOVE, NULL);
            RemoveTargetIfNoLongerUsed(target, targettaghash);

            LWLockRelease(partitionLock);
        }

        predlock = nextpredlock;
    }

    LWLockRelease(SerializablePredicateLockListLock);
    LWLockRelease(SerializableFinishedListLock);
}

static bool CoarserLockCovers ( const PREDICATELOCKTARGETTAG *  newtargettag )

static

Definition at line 2032 of file predicate.c.

References GetParentPredicateLockTag(), and PredicateLockExists().

Referenced by PredicateLockAcquire().

{
    PREDICATELOCKTARGETTAG targettag,
                parenttag;

    targettag = *newtargettag;

    /* check parents iteratively until no more */
    while (GetParentPredicateLockTag(&targettag, &parenttag))
    {
        targettag = parenttag;
        if (PredicateLockExists(&targettag))
            return true;
    }

    /* no more parents to check; lock is not covered */
    return false;
}

static void CreatePredicateLock ( const PREDICATELOCKTARGETTAG *  targettag, uint32  targettaghash, SERIALIZABLEXACT *  sxact  )

static

Definition at line 2378 of file predicate.c.

References PREDICATELOCK::commitSeqNo, ereport, errcode(), errhint(), errmsg(), ERROR, HASH_ENTER_NULL, hash_search_with_hash_value(), InvalidSerCommitSeqNo, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PREDICATELOCKTARGET::predicateLocks, SHMQueueInit(), SHMQueueInsertBefore(), PREDICATELOCK::targetLink, and PREDICATELOCK::xactLink.

Referenced by predicatelock_twophase_recover(), and PredicateLockAcquire().

{
    PREDICATELOCKTARGET *target;
    PREDICATELOCKTAG locktag;
    PREDICATELOCK *lock;
    LWLock     *partitionLock;
    bool        found;

    partitionLock = PredicateLockHashPartitionLock(targettaghash);

    LWLockAcquire(SerializablePredicateLockListLock, LW_SHARED);
    LWLockAcquire(partitionLock, LW_EXCLUSIVE);

    /* Make sure that the target is represented. */
    target = (PREDICATELOCKTARGET *)
        hash_search_with_hash_value(PredicateLockTargetHash,
                                    targettag, targettaghash,
                                    HASH_ENTER_NULL, &found);
    if (!target)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory"),
                 errhint("You might need to increase max_pred_locks_per_transaction.")));
    if (!found)
        SHMQueueInit(&(target->predicateLocks));

    /* We've got the sxact and target, make sure they're joined. */
    locktag.myTarget = target;
    locktag.myXact = sxact;
    lock = (PREDICATELOCK *)
        hash_search_with_hash_value(PredicateLockHash, &locktag,
                                    PredicateLockHashCodeFromTargetHashCode(&locktag, targettaghash),
                                    HASH_ENTER_NULL, &found);
    if (!lock)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of shared memory"),
                 errhint("You might need to increase max_pred_locks_per_transaction.")));

    if (!found)
    {
        SHMQueueInsertBefore(&(target->predicateLocks), &(lock->targetLink));
        SHMQueueInsertBefore(&(sxact->predicateLocks),
                             &(lock->xactLink));
        lock->commitSeqNo = InvalidSerCommitSeqNo;
    }

    LWLockRelease(partitionLock);
    LWLockRelease(SerializablePredicateLockListLock);
}

static SERIALIZABLEXACT * CreatePredXact ( void  )

static

Definition at line 566 of file predicate.c.

References PredXactListData::activeList, PredXactListData::availableList, PredXactListElementData::link, offsetof, SHMQueueDelete(), SHMQueueInsertBefore(), SHMQueueNext(), and PredXactListElementData::sxact.

Referenced by GetSerializableTransactionSnapshotInt(), InitPredicateLocks(), and predicatelock_twophase_recover().

{
    PredXactListElement ptle;

    ptle = (PredXactListElement)
        SHMQueueNext(&PredXact->availableList,
                     &PredXact->availableList,
                     offsetof(PredXactListElementData, link));
    if (!ptle)
        return NULL;

    SHMQueueDelete(&ptle->link);
    SHMQueueInsertBefore(&PredXact->activeList, &ptle->link);
    return &ptle->sxact;
}

static void DecrementParentLocks ( const PREDICATELOCKTARGETTAG *  targettag )

static

Definition at line 2316 of file predicate.c.

References Assert, LOCALPREDICATELOCK::childLocks, GetParentPredicateLockTag(), HASH_FIND, HASH_REMOVE, hash_search_with_hash_value(), LOCALPREDICATELOCK::held, PG_USED_FOR_ASSERTS_ONLY, and PredicateLockTargetTagHashCode.

Referenced by CheckTargetForConflictsIn(), and DeleteChildTargetLocks().

{
    PREDICATELOCKTARGETTAG parenttag,
                nexttag;

    parenttag = *targettag;

    while (GetParentPredicateLockTag(&parenttag, &nexttag))
    {
        uint32      targettaghash;
        LOCALPREDICATELOCK *parentlock,
                   *rmlock PG_USED_FOR_ASSERTS_ONLY;

        parenttag = nexttag;
        targettaghash = PredicateLockTargetTagHashCode(&parenttag);
        parentlock = (LOCALPREDICATELOCK *)
            hash_search_with_hash_value(LocalPredicateLockHash,
                                        &parenttag, targettaghash,
                                        HASH_FIND, NULL);

        /*
         * There's a small chance the parent lock doesn't exist in the lock
         * table. This can happen if we prematurely removed it because an
         * index split caused the child refcount to be off.
         */
        if (parentlock == NULL)
            continue;

        parentlock->childLocks--;

        /*
         * Under similar circumstances the parent lock's refcount might be
         * zero. This only happens if we're holding that lock (otherwise we
         * would have removed the entry).
         */
        if (parentlock->childLocks < 0)
        {
            Assert(parentlock->held);
            parentlock->childLocks = 0;
        }

        if ((parentlock->childLocks == 0) && (!parentlock->held))
        {
            rmlock = (LOCALPREDICATELOCK *)
                hash_search_with_hash_value(LocalPredicateLockHash,
                                            &parenttag, targettaghash,
                                            HASH_REMOVE, NULL);
            Assert(rmlock == parentlock);
        }
    }
}

static void DeleteChildTargetLocks ( const PREDICATELOCKTARGETTAG *  newtargettag )

static

Definition at line 2133 of file predicate.c.

References Assert, DecrementParentLocks(), HASH_REMOVE, hash_search_with_hash_value(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), MySerializableXact, PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, offsetof, PG_USED_FOR_ASSERTS_ONLY, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PredicateLockTargetTagHashCode, RemoveTargetIfNoLongerUsed(), SHMQueueDelete(), SHMQueueNext(), PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, PREDICATELOCK::targetLink, TargetTagIsCoveredBy, and PREDICATELOCK::xactLink.

Referenced by PredicateLockAcquire().

{
    SERIALIZABLEXACT *sxact;
    PREDICATELOCK *predlock;

    LWLockAcquire(SerializablePredicateLockListLock, LW_SHARED);
    sxact = MySerializableXact;
    predlock = (PREDICATELOCK *)
        SHMQueueNext(&(sxact->predicateLocks),
                     &(sxact->predicateLocks),
                     offsetof(PREDICATELOCK, xactLink));
    while (predlock)
    {
        SHM_QUEUE  *predlocksxactlink;
        PREDICATELOCK *nextpredlock;
        PREDICATELOCKTAG oldlocktag;
        PREDICATELOCKTARGET *oldtarget;
        PREDICATELOCKTARGETTAG oldtargettag;

        predlocksxactlink = &(predlock->xactLink);
        nextpredlock = (PREDICATELOCK *)
            SHMQueueNext(&(sxact->predicateLocks),
                         predlocksxactlink,
                         offsetof(PREDICATELOCK, xactLink));

        oldlocktag = predlock->tag;
        Assert(oldlocktag.myXact == sxact);
        oldtarget = oldlocktag.myTarget;
        oldtargettag = oldtarget->tag;

        if (TargetTagIsCoveredBy(oldtargettag, *newtargettag))
        {
            uint32      oldtargettaghash;
            LWLock     *partitionLock;
            PREDICATELOCK *rmpredlock PG_USED_FOR_ASSERTS_ONLY;

            oldtargettaghash = PredicateLockTargetTagHashCode(&oldtargettag);
            partitionLock = PredicateLockHashPartitionLock(oldtargettaghash);

            LWLockAcquire(partitionLock, LW_EXCLUSIVE);

            SHMQueueDelete(predlocksxactlink);
            SHMQueueDelete(&(predlock->targetLink));
            rmpredlock = hash_search_with_hash_value
                (PredicateLockHash,
                 &oldlocktag,
                 PredicateLockHashCodeFromTargetHashCode(&oldlocktag,
                                                         oldtargettaghash),
                 HASH_REMOVE, NULL);
            Assert(rmpredlock == predlock);

            RemoveTargetIfNoLongerUsed(oldtarget, oldtargettaghash);

            LWLockRelease(partitionLock);

            DecrementParentLocks(&oldtargettag);
        }

        predlock = nextpredlock;
    }
    LWLockRelease(SerializablePredicateLockListLock);
}

static void DeleteLockTarget ( PREDICATELOCKTARGET *  target, uint32  targettaghash  )

static

Definition at line 2608 of file predicate.c.

References Assert, HASH_REMOVE, hash_search_with_hash_value(), LW_EXCLUSIVE, LWLockAcquire(), LWLockHeldByMe(), LWLockRelease(), offsetof, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLock, PREDICATELOCKTARGET::predicateLocks, RemoveTargetIfNoLongerUsed(), SHMQueueDelete(), SHMQueueNext(), PREDICATELOCK::tag, PREDICATELOCK::targetLink, and PREDICATELOCK::xactLink.

Referenced by TransferPredicateLocksToNewTarget().

{
    PREDICATELOCK *predlock;
    SHM_QUEUE  *predlocktargetlink;
    PREDICATELOCK *nextpredlock;
    bool        found;

    Assert(LWLockHeldByMe(SerializablePredicateLockListLock));
    Assert(LWLockHeldByMe(PredicateLockHashPartitionLock(targettaghash)));

    predlock = (PREDICATELOCK *)
        SHMQueueNext(&(target->predicateLocks),
                     &(target->predicateLocks),
                     offsetof(PREDICATELOCK, targetLink));
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
    while (predlock)
    {
        predlocktargetlink = &(predlock->targetLink);
        nextpredlock = (PREDICATELOCK *)
            SHMQueueNext(&(target->predicateLocks),
                         predlocktargetlink,
                         offsetof(PREDICATELOCK, targetLink));

        SHMQueueDelete(&(predlock->xactLink));
        SHMQueueDelete(&(predlock->targetLink));

        hash_search_with_hash_value
            (PredicateLockHash,
             &predlock->tag,
             PredicateLockHashCodeFromTargetHashCode(&predlock->tag,
                                                     targettaghash),
             HASH_REMOVE, &found);
        Assert(found);

        predlock = nextpredlock;
    }
    LWLockRelease(SerializableXactHashLock);

    /* Remove the target itself, if possible. */
    RemoveTargetIfNoLongerUsed(target, targettaghash);
}

static void DropAllPredicateLocksFromTable ( Relation  relation, bool  transfer  )

static

Definition at line 2894 of file predicate.c.

References Assert, PREDICATELOCK::commitSeqNo, RelFileNode::dbNode, GET_PREDICATELOCKTARGETTAG_DB, GET_PREDICATELOCKTARGETTAG_RELATION, GET_PREDICATELOCKTARGETTAG_TYPE, HASH_ENTER, HASH_REMOVE, hash_search(), hash_search_with_hash_value(), hash_seq_init(), hash_seq_search(), i, InvalidOid, InvalidSerCommitSeqNo, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, NUM_PREDICATELOCK_PARTITIONS, offsetof, PredicateLockHashCodeFromTargetHashCode, PredicateLockHashPartitionLockByIndex, PredicateLockingNeededForRelation(), SERIALIZABLEXACT::predicateLocks, PREDICATELOCKTARGET::predicateLocks, PredicateLockTargetTagHashCode, PREDLOCKTAG_RELATION, RelationData::rd_id, RelationData::rd_index, RelationData::rd_node, RemoveScratchTarget(), RestoreScratchTarget(), SET_PREDICATELOCKTARGETTAG_RELATION, SHMQueueDelete(), SHMQueueInit(), SHMQueueInsertBefore(), SHMQueueNext(), PredXactListData::SxactGlobalXmin, PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, PREDICATELOCK::targetLink, TransactionIdIsValid, and PREDICATELOCK::xactLink.

Referenced by TransferPredicateLocksToHeapRelation().

{
    HASH_SEQ_STATUS seqstat;
    PREDICATELOCKTARGET *oldtarget;
    PREDICATELOCKTARGET *heaptarget;
    Oid         dbId;
    Oid         relId;
    Oid         heapId;
    int         i;
    bool        isIndex;
    bool        found;
    uint32      heaptargettaghash;

    /*
     * Bail out quickly if there are no serializable transactions running.
     * It's safe to check this without taking locks because the caller is
     * holding an ACCESS EXCLUSIVE lock on the relation.  No new locks which
     * would matter here can be acquired while that is held.
     */
    if (!TransactionIdIsValid(PredXact->SxactGlobalXmin))
        return;

    if (!PredicateLockingNeededForRelation(relation))
        return;

    dbId = relation->rd_node.dbNode;
    relId = relation->rd_id;
    if (relation->rd_index == NULL)
    {
        isIndex = false;
        heapId = relId;
    }
    else
    {
        isIndex = true;
        heapId = relation->rd_index->indrelid;
    }
    Assert(heapId != InvalidOid);
    Assert(transfer || !isIndex);   /* index OID only makes sense with
                                     * transfer */

    /* Retrieve first time needed, then keep. */
    heaptargettaghash = 0;
    heaptarget = NULL;

    /* Acquire locks on all lock partitions */
    LWLockAcquire(SerializablePredicateLockListLock, LW_EXCLUSIVE);
    for (i = 0; i < NUM_PREDICATELOCK_PARTITIONS; i++)
        LWLockAcquire(PredicateLockHashPartitionLockByIndex(i), LW_EXCLUSIVE);
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);

    /*
     * Remove the dummy entry to give us scratch space, so we know we'll be
     * able to create the new lock target.
     */
    if (transfer)
        RemoveScratchTarget(true);

    /* Scan through target map */
    hash_seq_init(&seqstat, PredicateLockTargetHash);

    while ((oldtarget = (PREDICATELOCKTARGET *) hash_seq_search(&seqstat)))
    {
        PREDICATELOCK *oldpredlock;

        /*
         * Check whether this is a target which needs attention.
         */
        if (GET_PREDICATELOCKTARGETTAG_RELATION(oldtarget->tag) != relId)
            continue;           /* wrong relation id */
        if (GET_PREDICATELOCKTARGETTAG_DB(oldtarget->tag) != dbId)
            continue;           /* wrong database id */
        if (transfer && !isIndex
            && GET_PREDICATELOCKTARGETTAG_TYPE(oldtarget->tag) == PREDLOCKTAG_RELATION)
            continue;           /* already the right lock */

        /*
         * If we made it here, we have work to do.  We make sure the heap
         * relation lock exists, then we walk the list of predicate locks for
         * the old target we found, moving all locks to the heap relation lock
         * -- unless they already hold that.
         */

        /*
         * First make sure we have the heap relation target.  We only need to
         * do this once.
         */
        if (transfer && heaptarget == NULL)
        {
            PREDICATELOCKTARGETTAG heaptargettag;

            SET_PREDICATELOCKTARGETTAG_RELATION(heaptargettag, dbId, heapId);
            heaptargettaghash = PredicateLockTargetTagHashCode(&heaptargettag);
            heaptarget = hash_search_with_hash_value(PredicateLockTargetHash,
                                                     &heaptargettag,
                                                     heaptargettaghash,
                                                     HASH_ENTER, &found);
            if (!found)
                SHMQueueInit(&heaptarget->predicateLocks);
        }

        /*
         * Loop through all the locks on the old target, replacing them with
         * locks on the new target.
         */
        oldpredlock = (PREDICATELOCK *)
            SHMQueueNext(&(oldtarget->predicateLocks),
                         &(oldtarget->predicateLocks),
                         offsetof(PREDICATELOCK, targetLink));
        while (oldpredlock)
        {
            PREDICATELOCK *nextpredlock;
            PREDICATELOCK *newpredlock;
            SerCommitSeqNo oldCommitSeqNo;
            SERIALIZABLEXACT *oldXact;

            nextpredlock = (PREDICATELOCK *)
                SHMQueueNext(&(oldtarget->predicateLocks),
                             &(oldpredlock->targetLink),
                             offsetof(PREDICATELOCK, targetLink));

            /*
             * Remove the old lock first. This avoids the chance of running
             * out of lock structure entries for the hash table.
             */
            oldCommitSeqNo = oldpredlock->commitSeqNo;
            oldXact = oldpredlock->tag.myXact;

            SHMQueueDelete(&(oldpredlock->xactLink));

            /*
             * No need for retail delete from oldtarget list, we're removing
             * the whole target anyway.
             */
            hash_search(PredicateLockHash,
                        &oldpredlock->tag,
                        HASH_REMOVE, &found);
            Assert(found);

            if (transfer)
            {
                PREDICATELOCKTAG newpredlocktag;

                newpredlocktag.myTarget = heaptarget;
                newpredlocktag.myXact = oldXact;
                newpredlock = (PREDICATELOCK *)
                    hash_search_with_hash_value(PredicateLockHash,
                                                &newpredlocktag,
                                                PredicateLockHashCodeFromTargetHashCode(&newpredlocktag,
                                                                                        heaptargettaghash),
                                                HASH_ENTER,
                                                &found);
                if (!found)
                {
                    SHMQueueInsertBefore(&(heaptarget->predicateLocks),
                                         &(newpredlock->targetLink));
                    SHMQueueInsertBefore(&(newpredlocktag.myXact->predicateLocks),
                                         &(newpredlock->xactLink));
                    newpredlock->commitSeqNo = oldCommitSeqNo;
                }
                else
                {
                    if (newpredlock->commitSeqNo < oldCommitSeqNo)
                        newpredlock->commitSeqNo = oldCommitSeqNo;
                }

                Assert(newpredlock->commitSeqNo != 0);
                Assert((newpredlock->commitSeqNo == InvalidSerCommitSeqNo)
                       || (newpredlock->tag.myXact == OldCommittedSxact));
            }

            oldpredlock = nextpredlock;
        }

        hash_search(PredicateLockTargetHash, &oldtarget->tag, HASH_REMOVE,
                    &found);
        Assert(found);
    }

    /* Put the scratch entry back */
    if (transfer)
        RestoreScratchTarget(true);

    /* Release locks in reverse order */
    LWLockRelease(SerializableXactHashLock);
    for (i = NUM_PREDICATELOCK_PARTITIONS - 1; i >= 0; i--)
        LWLockRelease(PredicateLockHashPartitionLockByIndex(i));
    LWLockRelease(SerializablePredicateLockListLock);
}

static SERIALIZABLEXACT * FirstPredXact ( void  )

static

Definition at line 598 of file predicate.c.

References PredXactListData::activeList, offsetof, SHMQueueNext(), and PredXactListElementData::sxact.

Referenced by GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), and SetNewSxactGlobalXmin().

{
    PredXactListElement ptle;

    ptle = (PredXactListElement)
        SHMQueueNext(&PredXact->activeList,
                     &PredXact->activeList,
                     offsetof(PredXactListElementData, link));
    if (!ptle)
        return NULL;

    return &ptle->sxact;
}

static void FlagRWConflict ( SERIALIZABLEXACT *  reader, SERIALIZABLEXACT *  writer  )

static

Definition at line 4502 of file predicate.c.

References Assert, SERIALIZABLEXACT::flags, OnConflict_CheckForSerializationFailure(), SetRWConflict(), SXACT_FLAG_SUMMARY_CONFLICT_IN, and SXACT_FLAG_SUMMARY_CONFLICT_OUT.

Referenced by CheckForSerializableConflictOut(), CheckTableForSerializableConflictIn(), and CheckTargetForConflictsIn().

{
    Assert(reader != writer);

    /* First, see if this conflict causes failure. */
    OnConflict_CheckForSerializationFailure(reader, writer);

    /* Actually do the conflict flagging. */
    if (reader == OldCommittedSxact)
        writer->flags |= SXACT_FLAG_SUMMARY_CONFLICT_IN;
    else if (writer == OldCommittedSxact)
        reader->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;
    else
        SetRWConflict(reader, writer);
}

static void FlagSxactUnsafe ( SERIALIZABLEXACT *  sxact )

static

Definition at line 736 of file predicate.c.

References Assert, SERIALIZABLEXACT::flags, RWConflictData::inLink, offsetof, SERIALIZABLEXACT::possibleUnsafeConflicts, ReleaseRWConflict(), SHMQueueNext(), SXACT_FLAG_RO_UNSAFE, RWConflictData::sxactIn, SxactIsReadOnly, SxactIsROSafe, and RWConflictData::sxactOut.

Referenced by ReleasePredicateLocks().

{
    RWConflict  conflict,
                nextConflict;

    Assert(SxactIsReadOnly(sxact));
    Assert(!SxactIsROSafe(sxact));

    sxact->flags |= SXACT_FLAG_RO_UNSAFE;

    /*
     * We know this isn't a safe snapshot, so we can stop looking for other
     * potential conflicts.
     */
    conflict = (RWConflict)
        SHMQueueNext(&sxact->possibleUnsafeConflicts,
                     &sxact->possibleUnsafeConflicts,
                     offsetof(RWConflictData, inLink));
    while (conflict)
    {
        nextConflict = (RWConflict)
            SHMQueueNext(&sxact->possibleUnsafeConflicts,
                         &conflict->inLink,
                         offsetof(RWConflictData, inLink));

        Assert(!SxactIsReadOnly(conflict->sxactOut));
        Assert(sxact == conflict->sxactIn);

        ReleaseRWConflict(conflict);

        conflict = nextConflict;
    }
}

static bool GetParentPredicateLockTag ( const PREDICATELOCKTARGETTAG *  tag, PREDICATELOCKTARGETTAG *  parent  )

static

Definition at line 1993 of file predicate.c.

References Assert, GET_PREDICATELOCKTARGETTAG_DB, GET_PREDICATELOCKTARGETTAG_PAGE, GET_PREDICATELOCKTARGETTAG_RELATION, GET_PREDICATELOCKTARGETTAG_TYPE, PREDLOCKTAG_PAGE, PREDLOCKTAG_RELATION, PREDLOCKTAG_TUPLE, SET_PREDICATELOCKTARGETTAG_PAGE, and SET_PREDICATELOCKTARGETTAG_RELATION.

Referenced by CheckAndPromotePredicateLockRequest(), CoarserLockCovers(), DecrementParentLocks(), and PredicateLockPageSplit().

{
    switch (GET_PREDICATELOCKTARGETTAG_TYPE(*tag))
    {
        case PREDLOCKTAG_RELATION:
            /* relation locks have no parent lock */
            return false;

        case PREDLOCKTAG_PAGE:
            /* parent lock is relation lock */
            SET_PREDICATELOCKTARGETTAG_RELATION(*parent,
                                                GET_PREDICATELOCKTARGETTAG_DB(*tag),
                                                GET_PREDICATELOCKTARGETTAG_RELATION(*tag));

            return true;

        case PREDLOCKTAG_TUPLE:
            /* parent lock is page lock */
            SET_PREDICATELOCKTARGETTAG_PAGE(*parent,
                                            GET_PREDICATELOCKTARGETTAG_DB(*tag),
                                            GET_PREDICATELOCKTARGETTAG_RELATION(*tag),
                                            GET_PREDICATELOCKTARGETTAG_PAGE(*tag));
            return true;
    }

    /* not reachable */
    Assert(false);
    return false;
}

PredicateLockData* GetPredicateLockStatusData

(

void

)

Definition at line 1399 of file predicate.c.

References Assert, hash_get_num_entries(), hash_seq_init(), hash_seq_search(), i, PredicateLockData::locktags, LW_SHARED, LWLockAcquire(), LWLockRelease(), PREDICATELOCKTAG::myTarget, PREDICATELOCKTAG::myXact, PredicateLockData::nelements, NUM_PREDICATELOCK_PARTITIONS, palloc(), PredicateLockHashPartitionLockByIndex, PREDICATELOCKTARGET::tag, PREDICATELOCK::tag, and PredicateLockData::xacts.

Referenced by pg_lock_status().

{
    PredicateLockData *data;
    int         i;
    int         els,
                el;
    HASH_SEQ_STATUS seqstat;
    PREDICATELOCK *predlock;

    data = (PredicateLockData *) palloc(sizeof(PredicateLockData));

    /*
     * To ensure consistency, take simultaneous locks on all partition locks
     * in ascending order, then SerializableXactHashLock.
     */
    for (i = 0; i < NUM_PREDICATELOCK_PARTITIONS; i++)
        LWLockAcquire(PredicateLockHashPartitionLockByIndex(i), LW_SHARED);
    LWLockAcquire(SerializableXactHashLock, LW_SHARED);

    /* Get number of locks and allocate appropriately-sized arrays. */
    els = hash_get_num_entries(PredicateLockHash);
    data->nelements = els;
    data->locktags = (PREDICATELOCKTARGETTAG *)
        palloc(sizeof(PREDICATELOCKTARGETTAG) * els);
    data->xacts = (SERIALIZABLEXACT *)
        palloc(sizeof(SERIALIZABLEXACT) * els);


    /* Scan through PredicateLockHash and copy contents */
    hash_seq_init(&seqstat, PredicateLockHash);

    el = 0;

    while ((predlock = (PREDICATELOCK *) hash_seq_search(&seqstat)))
    {
        data->locktags[el] = predlock->tag.myTarget->tag;
        data->xacts[el] = *predlock->tag.myXact;
        el++;
    }

    Assert(el == els);

    /* Release locks in reverse order */
    LWLockRelease(SerializableXactHashLock);
    for (i = NUM_PREDICATELOCK_PARTITIONS - 1; i >= 0; i--)
        LWLockRelease(PredicateLockHashPartitionLockByIndex(i));

    return data;
}

static Snapshot GetSafeSnapshot ( Snapshot  snapshot )

static

Definition at line 1514 of file predicate.c.

References Assert, DEBUG2, ereport, errcode(), errmsg(), SERIALIZABLEXACT::flags, GetSerializableTransactionSnapshotInt(), InvalidPid, InvalidSerializableXact, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SERIALIZABLEXACT::possibleUnsafeConflicts, ProcWaitForSignal(), ReleasePredicateLocks(), SHMQueueEmpty(), SXACT_FLAG_DEFERRABLE_WAITING, SxactIsROSafe, SxactIsROUnsafe, WAIT_EVENT_SAFE_SNAPSHOT, XactDeferrable, and XactReadOnly.

Referenced by GetSerializableTransactionSnapshot().

{
    Snapshot    snapshot;

    Assert(XactReadOnly && XactDeferrable);

    while (true)
    {
        /*
         * GetSerializableTransactionSnapshotInt is going to call
         * GetSnapshotData, so we need to provide it the static snapshot area
         * our caller passed to us.  The pointer returned is actually the same
         * one passed to it, but we avoid assuming that here.
         */
        snapshot = GetSerializableTransactionSnapshotInt(origSnapshot,
                                                         NULL, InvalidPid);

        if (MySerializableXact == InvalidSerializableXact)
            return snapshot;    /* no concurrent r/w xacts; it's safe */

        LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);

        /*
         * Wait for concurrent transactions to finish. Stop early if one of
         * them marked us as conflicted.
         */
        MySerializableXact->flags |= SXACT_FLAG_DEFERRABLE_WAITING;
        while (!(SHMQueueEmpty(&MySerializableXact->possibleUnsafeConflicts) ||
                 SxactIsROUnsafe(MySerializableXact)))
        {
            LWLockRelease(SerializableXactHashLock);
            ProcWaitForSignal(WAIT_EVENT_SAFE_SNAPSHOT);
            LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
        }
        MySerializableXact->flags &= ~SXACT_FLAG_DEFERRABLE_WAITING;

        if (!SxactIsROUnsafe(MySerializableXact))
        {
            LWLockRelease(SerializableXactHashLock);
            break;              /* success */
        }

        LWLockRelease(SerializableXactHashLock);

        /* else, need to retry... */
        ereport(DEBUG2,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg("deferrable snapshot was unsafe; trying a new one")));
        ReleasePredicateLocks(false);
    }

    /*
     * Now we have a safe snapshot, so we don't need to do any further checks.
     */
    Assert(SxactIsROSafe(MySerializableXact));
    ReleasePredicateLocks(false);

    return snapshot;
}

int GetSafeSnapshotBlockingPids	(	int	blocked_pid,
		int *	output,
		int	output_size
	)

Definition at line 1584 of file predicate.c.

References FirstPredXact(), RWConflictData::inLink, LW_SHARED, LWLockAcquire(), LWLockRelease(), NextPredXact(), offsetof, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, SHMQueueNext(), SxactIsDeferrableWaiting, and RWConflictData::sxactOut.

Referenced by pg_isolation_test_session_is_blocked(), and pg_safe_snapshot_blocking_pids().

{
    int         num_written = 0;
    SERIALIZABLEXACT *sxact;

    LWLockAcquire(SerializableXactHashLock, LW_SHARED);

    /* Find blocked_pid's SERIALIZABLEXACT by linear search. */
    for (sxact = FirstPredXact(); sxact != NULL; sxact = NextPredXact(sxact))
    {
        if (sxact->pid == blocked_pid)
            break;
    }

    /* Did we find it, and is it currently waiting in GetSafeSnapshot? */
    if (sxact != NULL && SxactIsDeferrableWaiting(sxact))
    {
        RWConflict  possibleUnsafeConflict;

        /* Traverse the list of possible unsafe conflicts collecting PIDs. */
        possibleUnsafeConflict = (RWConflict)
            SHMQueueNext(&sxact->possibleUnsafeConflicts,
                         &sxact->possibleUnsafeConflicts,
                         offsetof(RWConflictData, inLink));

        while (possibleUnsafeConflict != NULL && num_written < output_size)
        {
            output[num_written++] = possibleUnsafeConflict->sxactOut->pid;
            possibleUnsafeConflict = (RWConflict)
                SHMQueueNext(&sxact->possibleUnsafeConflicts,
                             &possibleUnsafeConflict->inLink,
                             offsetof(RWConflictData, inLink));
        }
    }

    LWLockRelease(SerializableXactHashLock);

    return num_written;
}

Snapshot GetSerializableTransactionSnapshot

(

Snapshot

snapshot

)

Definition at line 1636 of file predicate.c.

References Assert, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, GetSafeSnapshot(), GetSerializableTransactionSnapshotInt(), InvalidPid, IsolationIsSerializable, RecoveryInProgress(), XactDeferrable, and XactReadOnly.

Referenced by GetTransactionSnapshot().

{
    Assert(IsolationIsSerializable());

    /*
     * Can't use serializable mode while recovery is still active, as it is,
     * for example, on a hot standby.  We could get here despite the check in
     * check_XactIsoLevel() if default_transaction_isolation is set to
     * serializable, so phrase the hint accordingly.
     */
    if (RecoveryInProgress())
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot use serializable mode in a hot standby"),
                 errdetail("\"default_transaction_isolation\" is set to \"serializable\"."),
                 errhint("You can use \"SET default_transaction_isolation = 'repeatable read'\" to change the default.")));

    /*
     * A special optimization is available for SERIALIZABLE READ ONLY
     * DEFERRABLE transactions -- we can wait for a suitable snapshot and
     * thereby avoid all SSI overhead once it's running.
     */
    if (XactReadOnly && XactDeferrable)
        return GetSafeSnapshot(snapshot);

    return GetSerializableTransactionSnapshotInt(snapshot,
                                                 NULL, InvalidPid);
}

static Snapshot GetSerializableTransactionSnapshotInt ( Snapshot  snapshot, VirtualTransactionId *  sourcevxid, int  sourcepid  )

static

Definition at line 1707 of file predicate.c.

References Assert, SERIALIZABLEXACT::commitSeqNo, CreatePredXact(), elog, HASHCTL::entrysize, ereport, errcode(), errdetail(), errmsg(), ERROR, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, FirstPredXact(), SERIALIZABLEXACT::flags, GET_VXID_FROM_PGPROC, GetSnapshotData(), GetTopTransactionIdIfAny(), HASH_BLOBS, hash_create(), HASH_ELEM, SERIALIZABLEXACT::inConflicts, InvalidSerCommitSeqNo, InvalidSerializableXact, InvalidTransactionId, IsInParallelMode(), HASHCTL::keysize, SERIALIZABLEXACT::lastCommitBeforeSnapshot, PredXactListData::LastSxactCommitSeqNo, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), max_predicate_locks_per_xact, max_prepared_xacts, MaxBackends, MemSet, MyProc, MyProcPid, MyXactDidWrite, NextPredXact(), OldSerXidSetActiveSerXmin(), SERIALIZABLEXACT::outConflicts, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, SERIALIZABLEXACT::predicateLocks, SERIALIZABLEXACT::prepareSeqNo, ProcArrayInstallImportedXmin(), RecoveryInProgress(), ReleasePredXact(), SERIALIZABLEXACT::SeqNo, SetPossibleUnsafeConflict(), SHMQueueElemInit(), SHMQueueInit(), SummarizeOldestCommittedSxact(), SXACT_FLAG_READ_ONLY, PredXactListData::SxactGlobalXmin, PredXactListData::SxactGlobalXminCount, SxactIsCommitted, SxactIsDoomed, SxactIsReadOnly, SERIALIZABLEXACT::topXid, TransactionIdEquals, TransactionIdFollows(), TransactionIdIsValid, SERIALIZABLEXACT::vxid, PredXactListData::WritableSxactCount, XactReadOnly, SnapshotData::xmin, and SERIALIZABLEXACT::xmin.

Referenced by GetSafeSnapshot(), GetSerializableTransactionSnapshot(), and SetSerializableTransactionSnapshot().

{
    PGPROC     *proc;
    VirtualTransactionId vxid;
    SERIALIZABLEXACT *sxact,
               *othersxact;
    HASHCTL     hash_ctl;

    /* We only do this for serializable transactions.  Once. */
    Assert(MySerializableXact == InvalidSerializableXact);

    Assert(!RecoveryInProgress());

    /*
     * Since all parts of a serializable transaction must use the same
     * snapshot, it is too late to establish one after a parallel operation
     * has begun.
     */
    if (IsInParallelMode())
        elog(ERROR, "cannot establish serializable snapshot during a parallel operation");

    proc = MyProc;
    Assert(proc != NULL);
    GET_VXID_FROM_PGPROC(vxid, *proc);

    /*
     * First we get the sxact structure, which may involve looping and access
     * to the "finished" list to free a structure for use.
     *
     * We must hold SerializableXactHashLock when taking/checking the snapshot
     * to avoid race conditions, for much the same reasons that
     * GetSnapshotData takes the ProcArrayLock.  Since we might have to
     * release SerializableXactHashLock to call SummarizeOldestCommittedSxact,
     * this means we have to create the sxact first, which is a bit annoying
     * (in particular, an elog(ERROR) in procarray.c would cause us to leak
     * the sxact).  Consider refactoring to avoid this.
     */
#ifdef TEST_OLDSERXID
    SummarizeOldestCommittedSxact();
#endif
    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
    do
    {
        sxact = CreatePredXact();
        /* If null, push out committed sxact to SLRU summary & retry. */
        if (!sxact)
        {
            LWLockRelease(SerializableXactHashLock);
            SummarizeOldestCommittedSxact();
            LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
        }
    } while (!sxact);

    /* Get the snapshot, or check that it's safe to use */
    if (!sourcevxid)
        snapshot = GetSnapshotData(snapshot);
    else if (!ProcArrayInstallImportedXmin(snapshot->xmin, sourcevxid))
    {
        ReleasePredXact(sxact);
        LWLockRelease(SerializableXactHashLock);
        ereport(ERROR,
                (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                 errmsg("could not import the requested snapshot"),
                 errdetail("The source process with PID %d is not running anymore.",
                           sourcepid)));
    }

    /*
     * If there are no serializable transactions which are not read-only, we
     * can "opt out" of predicate locking and conflict checking for a
     * read-only transaction.
     *
     * The reason this is safe is that a read-only transaction can only become
     * part of a dangerous structure if it overlaps a writable transaction
     * which in turn overlaps a writable transaction which committed before
     * the read-only transaction started.  A new writable transaction can
     * overlap this one, but it can't meet the other condition of overlapping
     * a transaction which committed before this one started.
     */
    if (XactReadOnly && PredXact->WritableSxactCount == 0)
    {
        ReleasePredXact(sxact);
        LWLockRelease(SerializableXactHashLock);
        return snapshot;
    }

    /* Maintain serializable global xmin info. */
    if (!TransactionIdIsValid(PredXact->SxactGlobalXmin))
    {
        Assert(PredXact->SxactGlobalXminCount == 0);
        PredXact->SxactGlobalXmin = snapshot->xmin;
        PredXact->SxactGlobalXminCount = 1;
        OldSerXidSetActiveSerXmin(snapshot->xmin);
    }
    else if (TransactionIdEquals(snapshot->xmin, PredXact->SxactGlobalXmin))
    {
        Assert(PredXact->SxactGlobalXminCount > 0);
        PredXact->SxactGlobalXminCount++;
    }
    else
    {
        Assert(TransactionIdFollows(snapshot->xmin, PredXact->SxactGlobalXmin));
    }

    /* Initialize the structure. */
    sxact->vxid = vxid;
    sxact->SeqNo.lastCommitBeforeSnapshot = PredXact->LastSxactCommitSeqNo;
    sxact->prepareSeqNo = InvalidSerCommitSeqNo;
    sxact->commitSeqNo = InvalidSerCommitSeqNo;
    SHMQueueInit(&(sxact->outConflicts));
    SHMQueueInit(&(sxact->inConflicts));
    SHMQueueInit(&(sxact->possibleUnsafeConflicts));
    sxact->topXid = GetTopTransactionIdIfAny();
    sxact->finishedBefore = InvalidTransactionId;
    sxact->xmin = snapshot->xmin;
    sxact->pid = MyProcPid;
    SHMQueueInit(&(sxact->predicateLocks));
    SHMQueueElemInit(&(sxact->finishedLink));
    sxact->flags = 0;
    if (XactReadOnly)
    {
        sxact->flags |= SXACT_FLAG_READ_ONLY;

        /*
         * Register all concurrent r/w transactions as possible conflicts; if
         * all of them commit without any outgoing conflicts to earlier
         * transactions then this snapshot can be deemed safe (and we can run
         * without tracking predicate locks).
         */
        for (othersxact = FirstPredXact();
             othersxact != NULL;
             othersxact = NextPredXact(othersxact))
        {
            if (!SxactIsCommitted(othersxact)
                && !SxactIsDoomed(othersxact)
                && !SxactIsReadOnly(othersxact))
            {
                SetPossibleUnsafeConflict(sxact, othersxact);
            }
        }
    }
    else
    {
        ++(PredXact->WritableSxactCount);
        Assert(PredXact->WritableSxactCount <=
               (MaxBackends + max_prepared_xacts));
    }

    MySerializableXact = sxact;
    MyXactDidWrite = false;     /* haven't written anything yet */

    LWLockRelease(SerializableXactHashLock);

    /* Initialize the backend-local hash table of parent locks */
    Assert(LocalPredicateLockHash == NULL);
    MemSet(&hash_ctl, 0, sizeof(hash_ctl));
    hash_ctl.keysize = sizeof(PREDICATELOCKTARGETTAG);
    hash_ctl.entrysize = sizeof(LOCALPREDICATELOCK);
    LocalPredicateLockHash = hash_create("Local predicate lock",
                                         max_predicate_locks_per_xact,
                                         &hash_ctl,
                                         HASH_ELEM | HASH_BLOBS);

    return snapshot;
}

void InitPredicateLocks

(

void

)

Definition at line 1108 of file predicate.c.

References PredXactListData::activeList, Assert, PredXactListData::availableList, RWConflictPoolHeaderData::availableList, PredXactListData::CanPartialClearThrough, SERIALIZABLEXACT::commitSeqNo, CreatePredXact(), PredXactListData::element, RWConflictPoolHeaderData::element, HASHCTL::entrysize, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, FirstNormalSerCommitSeqNo, SERIALIZABLEXACT::flags, HASHCTL::hash, HASH_BLOBS, HASH_ELEM, HASH_ENTER, HASH_FIXED_SIZE, HASH_FUNCTION, HASH_PARTITION, hash_search(), PredXactListData::HavePartialClearedThrough, i, SERIALIZABLEXACT::inConflicts, InvalidTransactionId, IsUnderPostmaster, HASHCTL::keysize, SERIALIZABLEXACT::lastCommitBeforeSnapshot, PredXactListData::LastSxactCommitSeqNo, PredXactListElementData::link, max_prepared_xacts, MaxBackends, MemSet, mul_size(), NPREDICATELOCKTARGETENTS, HASHCTL::num_partitions, NUM_PREDICATELOCK_PARTITIONS, PredXactListData::OldCommittedSxact, OldSerXidInit(), SERIALIZABLEXACT::outConflicts, RWConflictData::outLink, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, predicatelock_hash(), PredicateLockHashPartitionLock, SERIALIZABLEXACT::predicateLocks, PredicateLockTargetTagHashCode, PredXactListDataSize, PredXactListElementDataSize, SERIALIZABLEXACT::prepareSeqNo, RWConflictDataSize, RWConflictPoolHeaderDataSize, ScratchTargetTagHash, SERIALIZABLEXACT::SeqNo, SetInvalidVirtualTransactionId, ShmemAlloc(), ShmemInitHash(), ShmemInitStruct(), SHMQueueInit(), SHMQueueInsertBefore(), SXACT_FLAG_COMMITTED, PredXactListData::SxactGlobalXmin, PredXactListData::SxactGlobalXminCount, SERIALIZABLEXACT::topXid, SERIALIZABLEXACT::vxid, PredXactListData::WritableSxactCount, and SERIALIZABLEXACT::xmin.

Referenced by CreateSharedMemoryAndSemaphores().

{
    HASHCTL     info;
    long        max_table_size;
    Size        requestSize;
    bool        found;

#ifndef EXEC_BACKEND
    Assert(!IsUnderPostmaster);
#endif

    /*
     * Compute size of predicate lock target hashtable. Note these
     * calculations must agree with PredicateLockShmemSize!
     */
    max_table_size = NPREDICATELOCKTARGETENTS();

    /*
     * Allocate hash table for PREDICATELOCKTARGET structs.  This stores
     * per-predicate-lock-target information.
     */
    MemSet(&info, 0, sizeof(info));
    info.keysize = sizeof(PREDICATELOCKTARGETTAG);
    info.entrysize = sizeof(PREDICATELOCKTARGET);
    info.num_partitions = NUM_PREDICATELOCK_PARTITIONS;

    PredicateLockTargetHash = ShmemInitHash("PREDICATELOCKTARGET hash",
                                            max_table_size,
                                            max_table_size,
                                            &info,
                                            HASH_ELEM | HASH_BLOBS |
                                            HASH_PARTITION | HASH_FIXED_SIZE);

    /*
     * Reserve a dummy entry in the hash table; we use it to make sure there's
     * always one entry available when we need to split or combine a page,
     * because running out of space there could mean aborting a
     * non-serializable transaction.
     */
    if (!IsUnderPostmaster)
    {
        (void) hash_search(PredicateLockTargetHash, &ScratchTargetTag,
                           HASH_ENTER, &found);
        Assert(!found);
    }

    /* Pre-calculate the hash and partition lock of the scratch entry */
    ScratchTargetTagHash = PredicateLockTargetTagHashCode(&ScratchTargetTag);
    ScratchPartitionLock = PredicateLockHashPartitionLock(ScratchTargetTagHash);

    /*
     * Allocate hash table for PREDICATELOCK structs.  This stores per
     * xact-lock-of-a-target information.
     */
    MemSet(&info, 0, sizeof(info));
    info.keysize = sizeof(PREDICATELOCKTAG);
    info.entrysize = sizeof(PREDICATELOCK);
    info.hash = predicatelock_hash;
    info.num_partitions = NUM_PREDICATELOCK_PARTITIONS;

    /* Assume an average of 2 xacts per target */
    max_table_size *= 2;

    PredicateLockHash = ShmemInitHash("PREDICATELOCK hash",
                                      max_table_size,
                                      max_table_size,
                                      &info,
                                      HASH_ELEM | HASH_FUNCTION |
                                      HASH_PARTITION | HASH_FIXED_SIZE);

    /*
     * Compute size for serializable transaction hashtable. Note these
     * calculations must agree with PredicateLockShmemSize!
     */
    max_table_size = (MaxBackends + max_prepared_xacts);

    /*
     * Allocate a list to hold information on transactions participating in
     * predicate locking.
     *
     * Assume an average of 10 predicate locking transactions per backend.
     * This allows aggressive cleanup while detail is present before data must
     * be summarized for storage in SLRU and the "dummy" transaction.
     */
    max_table_size *= 10;

    PredXact = ShmemInitStruct("PredXactList",
                               PredXactListDataSize,
                               &found);
    Assert(found == IsUnderPostmaster);
    if (!found)
    {
        int         i;

        SHMQueueInit(&PredXact->availableList);
        SHMQueueInit(&PredXact->activeList);
        PredXact->SxactGlobalXmin = InvalidTransactionId;
        PredXact->SxactGlobalXminCount = 0;
        PredXact->WritableSxactCount = 0;
        PredXact->LastSxactCommitSeqNo = FirstNormalSerCommitSeqNo - 1;
        PredXact->CanPartialClearThrough = 0;
        PredXact->HavePartialClearedThrough = 0;
        requestSize = mul_size((Size) max_table_size,
                               PredXactListElementDataSize);
        PredXact->element = ShmemAlloc(requestSize);
        /* Add all elements to available list, clean. */
        memset(PredXact->element, 0, requestSize);
        for (i = 0; i < max_table_size; i++)
        {
            SHMQueueInsertBefore(&(PredXact->availableList),
                                 &(PredXact->element[i].link));
        }
        PredXact->OldCommittedSxact = CreatePredXact();
        SetInvalidVirtualTransactionId(PredXact->OldCommittedSxact->vxid);
        PredXact->OldCommittedSxact->prepareSeqNo = 0;
        PredXact->OldCommittedSxact->commitSeqNo = 0;
        PredXact->OldCommittedSxact->SeqNo.lastCommitBeforeSnapshot = 0;
        SHMQueueInit(&PredXact->OldCommittedSxact->outConflicts);
        SHMQueueInit(&PredXact->OldCommittedSxact->inConflicts);
        SHMQueueInit(&PredXact->OldCommittedSxact->predicateLocks);
        SHMQueueInit(&PredXact->OldCommittedSxact->finishedLink);
        SHMQueueInit(&PredXact->OldCommittedSxact->possibleUnsafeConflicts);
        PredXact->OldCommittedSxact->topXid = InvalidTransactionId;
        PredXact->OldCommittedSxact->finishedBefore = InvalidTransactionId;
        PredXact->OldCommittedSxact->xmin = InvalidTransactionId;
        PredXact->OldCommittedSxact->flags = SXACT_FLAG_COMMITTED;
        PredXact->OldCommittedSxact->pid = 0;
    }
    /* This never changes, so let's keep a local copy. */
    OldCommittedSxact = PredXact->OldCommittedSxact;

    /*
     * Allocate hash table for SERIALIZABLEXID structs.  This stores per-xid
     * information for serializable transactions which have accessed data.
     */
    MemSet(&info, 0, sizeof(info));
    info.keysize = sizeof(SERIALIZABLEXIDTAG);
    info.entrysize = sizeof(SERIALIZABLEXID);

    SerializableXidHash = ShmemInitHash("SERIALIZABLEXID hash",
                                        max_table_size,
                                        max_table_size,
                                        &info,
                                        HASH_ELEM | HASH_BLOBS |
                                        HASH_FIXED_SIZE);

    /*
     * Allocate space for tracking rw-conflicts in lists attached to the
     * transactions.
     *
     * Assume an average of 5 conflicts per transaction.  Calculations suggest
     * that this will prevent resource exhaustion in even the most pessimal
     * loads up to max_connections = 200 with all 200 connections pounding the
     * database with serializable transactions.  Beyond that, there may be
     * occasional transactions canceled when trying to flag conflicts. That's
     * probably OK.
     */
    max_table_size *= 5;

    RWConflictPool = ShmemInitStruct("RWConflictPool",
                                     RWConflictPoolHeaderDataSize,
                                     &found);
    Assert(found == IsUnderPostmaster);
    if (!found)
    {
        int         i;

        SHMQueueInit(&RWConflictPool->availableList);
        requestSize = mul_size((Size) max_table_size,
                               RWConflictDataSize);
        RWConflictPool->element = ShmemAlloc(requestSize);
        /* Add all elements to available list, clean. */
        memset(RWConflictPool->element, 0, requestSize);
        for (i = 0; i < max_table_size; i++)
        {
            SHMQueueInsertBefore(&(RWConflictPool->availableList),
                                 &(RWConflictPool->element[i].outLink));
        }
    }

    /*
     * Create or attach to the header for the list of finished serializable
     * transactions.
     */
    FinishedSerializableTransactions = (SHM_QUEUE *)
        ShmemInitStruct("FinishedSerializableTransactions",
                        sizeof(SHM_QUEUE),
                        &found);
    Assert(found == IsUnderPostmaster);
    if (!found)
        SHMQueueInit(FinishedSerializableTransactions);

    /*
     * Initialize the SLRU storage for old committed serializable
     * transactions.
     */
    OldSerXidInit();
}

static int MaxPredicateChildLocks ( const PREDICATELOCKTARGETTAG *  tag )

static

Definition at line 2214 of file predicate.c.

References Assert, GET_PREDICATELOCKTARGETTAG_TYPE, max_predicate_locks_per_page, max_predicate_locks_per_relation, max_predicate_locks_per_xact, PREDLOCKTAG_PAGE, PREDLOCKTAG_RELATION, and PREDLOCKTAG_TUPLE.

Referenced by CheckAndPromotePredicateLockRequest().

{
    switch (GET_PREDICATELOCKTARGETTAG_TYPE(*tag))
    {
        case PREDLOCKTAG_RELATION:
            return max_predicate_locks_per_relation < 0
                ? (max_predicate_locks_per_xact
                   / (-max_predicate_locks_per_relation)) - 1
                : max_predicate_locks_per_relation;

        case PREDLOCKTAG_PAGE:
            return max_predicate_locks_per_page;

        case PREDLOCKTAG_TUPLE:

            /*
             * not reachable: nothing is finer-granularity than a tuple, so we
             * should never try to promote to it.
             */
            Assert(false);
            return 0;
    }

    /* not reachable */
    Assert(false);
    return 0;
}

static SERIALIZABLEXACT * NextPredXact ( SERIALIZABLEXACT *  sxact )

static

Definition at line 613 of file predicate.c.

References PredXactListData::activeList, Assert, PredXactListElementData::link, offsetof, ShmemAddrIsValid(), SHMQueueNext(), and PredXactListElementData::sxact.

Referenced by GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), and SetNewSxactGlobalXmin().

{
    PredXactListElement ptle;

    Assert(ShmemAddrIsValid(sxact));

    ptle = (PredXactListElement)
        (((char *) sxact)
         - offsetof(PredXactListElementData, sxact)
         + offsetof(PredXactListElementData, link));
    ptle = (PredXactListElement)
        SHMQueueNext(&PredXact->activeList,
                     &ptle->link,
                     offsetof(PredXactListElementData, link));
    if (!ptle)
        return NULL;

    return &ptle->sxact;
}

static void OldSerXidAdd ( TransactionId  xid, SerCommitSeqNo  minConflictCommitSeqNo  )

static

Definition at line 839 of file predicate.c.

References Assert, ereport, errhint(), errmsg(), FirstNormalTransactionId, OldSerXidControlData::headPage, OldSerXidControlData::headXid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), OldSerXidNextPage, OldSerXidPage, OldSerXidPagePrecedesLogically(), OldSerXidSlruCtl, OldSerXidValue, SimpleLruReadPage(), SimpleLruZeroPage(), OldSerXidControlData::tailXid, TransactionIdFollows(), TransactionIdIsValid, TransactionIdPrecedes(), WARNING, and OldSerXidControlData::warningIssued.

Referenced by SummarizeOldestCommittedSxact().

{
    TransactionId tailXid;
    int         targetPage;
    int         slotno;
    int         firstZeroPage;
    bool        isNewPage;

    Assert(TransactionIdIsValid(xid));

    targetPage = OldSerXidPage(xid);

    LWLockAcquire(OldSerXidLock, LW_EXCLUSIVE);

    /*
     * If no serializable transactions are active, there shouldn't be anything
     * to push out to the SLRU.  Hitting this assert would mean there's
     * something wrong with the earlier cleanup logic.
     */
    tailXid = oldSerXidControl->tailXid;
    Assert(TransactionIdIsValid(tailXid));

    /*
     * If the SLRU is currently unused, zero out the whole active region from
     * tailXid to headXid before taking it into use. Otherwise zero out only
     * any new pages that enter the tailXid-headXid range as we advance
     * headXid.
     */
    if (oldSerXidControl->headPage < 0)
    {
        firstZeroPage = OldSerXidPage(tailXid);
        isNewPage = true;
    }
    else
    {
        firstZeroPage = OldSerXidNextPage(oldSerXidControl->headPage);
        isNewPage = OldSerXidPagePrecedesLogically(oldSerXidControl->headPage,
                                                   targetPage);
    }

    if (!TransactionIdIsValid(oldSerXidControl->headXid)
        || TransactionIdFollows(xid, oldSerXidControl->headXid))
        oldSerXidControl->headXid = xid;
    if (isNewPage)
        oldSerXidControl->headPage = targetPage;

    /*
     * Give a warning if we're about to run out of SLRU pages.
     *
     * slru.c has a maximum of 64k segments, with 32 (SLRU_PAGES_PER_SEGMENT)
     * pages each. We need to store a 64-bit integer for each Xid, and with
     * default 8k block size, 65536*32 pages is only enough to cover 2^30
     * XIDs. If we're about to hit that limit and wrap around, warn the user.
     *
     * To avoid spamming the user, we only give one warning when we've used 1
     * billion XIDs, and stay silent until the situation is fixed and the
     * number of XIDs used falls below 800 million again.
     *
     * XXX: We have no safeguard to actually *prevent* the wrap-around,
     * though. All you get is a warning.
     */
    if (oldSerXidControl->warningIssued)
    {
        TransactionId lowWatermark;

        lowWatermark = tailXid + 800000000;
        if (lowWatermark < FirstNormalTransactionId)
            lowWatermark = FirstNormalTransactionId;
        if (TransactionIdPrecedes(xid, lowWatermark))
            oldSerXidControl->warningIssued = false;
    }
    else
    {
        TransactionId highWatermark;

        highWatermark = tailXid + 1000000000;
        if (highWatermark < FirstNormalTransactionId)
            highWatermark = FirstNormalTransactionId;
        if (TransactionIdFollows(xid, highWatermark))
        {
            oldSerXidControl->warningIssued = true;
            ereport(WARNING,
                    (errmsg("memory for serializable conflict tracking is nearly exhausted"),
                     errhint("There might be an idle transaction or a forgotten prepared transaction causing this.")));
        }
    }

    if (isNewPage)
    {
        /* Initialize intervening pages. */
        while (firstZeroPage != targetPage)
        {
            (void) SimpleLruZeroPage(OldSerXidSlruCtl, firstZeroPage);
            firstZeroPage = OldSerXidNextPage(firstZeroPage);
        }
        slotno = SimpleLruZeroPage(OldSerXidSlruCtl, targetPage);
    }
    else
        slotno = SimpleLruReadPage(OldSerXidSlruCtl, targetPage, true, xid);

    OldSerXidValue(slotno, xid) = minConflictCommitSeqNo;
    OldSerXidSlruCtl->shared->page_dirty[slotno] = true;

    LWLockRelease(OldSerXidLock);
}

static SerCommitSeqNo OldSerXidGetMinConflictCommitSeqNo ( TransactionId  xid )

static

Definition at line 951 of file predicate.c.

References Assert, OldSerXidControlData::headXid, LW_SHARED, LWLockAcquire(), LWLockRelease(), OldSerXidPage, OldSerXidSlruCtl, OldSerXidValue, SimpleLruReadPage_ReadOnly(), OldSerXidControlData::tailXid, TransactionIdFollows(), TransactionIdIsValid, TransactionIdPrecedes(), and val.

Referenced by CheckForSerializableConflictOut().

{
    TransactionId headXid;
    TransactionId tailXid;
    SerCommitSeqNo val;
    int         slotno;

    Assert(TransactionIdIsValid(xid));

    LWLockAcquire(OldSerXidLock, LW_SHARED);
    headXid = oldSerXidControl->headXid;
    tailXid = oldSerXidControl->tailXid;
    LWLockRelease(OldSerXidLock);

    if (!TransactionIdIsValid(headXid))
        return 0;

    Assert(TransactionIdIsValid(tailXid));

    if (TransactionIdPrecedes(xid, tailXid)
        || TransactionIdFollows(xid, headXid))
        return 0;

    /*
     * The following function must be called without holding OldSerXidLock,
     * but will return with that lock held, which must then be released.
     */
    slotno = SimpleLruReadPage_ReadOnly(OldSerXidSlruCtl,
                                        OldSerXidPage(xid), xid);
    val = OldSerXidValue(slotno, xid);
    LWLockRelease(OldSerXidLock);
    return val;
}

static void OldSerXidInit ( void  )

static

Definition at line 800 of file predicate.c.

References Assert, OldSerXidControlData::headPage, OldSerXidControlData::headXid, InvalidTransactionId, IsUnderPostmaster, LWTRANCHE_OLDSERXID_BUFFERS, NUM_OLDSERXID_BUFFERS, OldSerXidPagePrecedesLogically(), OldSerXidSlruCtl, ShmemInitStruct(), SimpleLruInit(), OldSerXidControlData::tailXid, and OldSerXidControlData::warningIssued.

Referenced by InitPredicateLocks().

{
    bool        found;

    /*
     * Set up SLRU management of the pg_serial data.
     */
    OldSerXidSlruCtl->PagePrecedes = OldSerXidPagePrecedesLogically;
    SimpleLruInit(OldSerXidSlruCtl, "oldserxid",
                  NUM_OLDSERXID_BUFFERS, 0, OldSerXidLock, "pg_serial",
                  LWTRANCHE_OLDSERXID_BUFFERS);
    /* Override default assumption that writes should be fsync'd */
    OldSerXidSlruCtl->do_fsync = false;

    /*
     * Create or attach to the OldSerXidControl structure.
     */
    oldSerXidControl = (OldSerXidControl)
        ShmemInitStruct("OldSerXidControlData", sizeof(OldSerXidControlData), &found);

    Assert(found == IsUnderPostmaster);
    if (!found)
    {
        /*
         * Set control information to reflect empty SLRU.
         */
        oldSerXidControl->headPage = -1;
        oldSerXidControl->headXid = InvalidTransactionId;
        oldSerXidControl->tailXid = InvalidTransactionId;
        oldSerXidControl->warningIssued = false;
    }
}

static bool OldSerXidPagePrecedesLogically ( int  p, int  q  )

static

Definition at line 777 of file predicate.c.

References Assert, and OLDSERXID_MAX_PAGE.

Referenced by OldSerXidAdd(), and OldSerXidInit().

{
    int         diff;

    /*
     * We have to compare modulo (OLDSERXID_MAX_PAGE+1)/2.  Both inputs should
     * be in the range 0..OLDSERXID_MAX_PAGE.
     */
    Assert(p >= 0 && p <= OLDSERXID_MAX_PAGE);
    Assert(q >= 0 && q <= OLDSERXID_MAX_PAGE);

    diff = p - q;
    if (diff >= ((OLDSERXID_MAX_PAGE + 1) / 2))
        diff -= OLDSERXID_MAX_PAGE + 1;
    else if (diff < -((int) (OLDSERXID_MAX_PAGE + 1) / 2))
        diff += OLDSERXID_MAX_PAGE + 1;
    return diff < 0;
}

static void OldSerXidSetActiveSerXmin ( TransactionId  xid )

static

Definition at line 992 of file predicate.c.

References Assert, OldSerXidControlData::headPage, OldSerXidControlData::headXid, InvalidTransactionId, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), RecoveryInProgress(), OldSerXidControlData::tailXid, TransactionIdFollows(), TransactionIdIsValid, and TransactionIdPrecedes().

Referenced by GetSerializableTransactionSnapshotInt(), predicatelock_twophase_recover(), and SetNewSxactGlobalXmin().

{
    LWLockAcquire(OldSerXidLock, LW_EXCLUSIVE);

    /*
     * When no sxacts are active, nothing overlaps, set the xid values to
     * invalid to show that there are no valid entries.  Don't clear headPage,
     * though.  A new xmin might still land on that page, and we don't want to
     * repeatedly zero out the same page.
     */
    if (!TransactionIdIsValid(xid))
    {
        oldSerXidControl->tailXid = InvalidTransactionId;
        oldSerXidControl->headXid = InvalidTransactionId;
        LWLockRelease(OldSerXidLock);
        return;
    }

    /*
     * When we're recovering prepared transactions, the global xmin might move
     * backwards depending on the order they're recovered. Normally that's not
     * OK, but during recovery no serializable transactions will commit, so
     * the SLRU is empty and we can get away with it.
     */
    if (RecoveryInProgress())
    {
        Assert(oldSerXidControl->headPage < 0);
        if (!TransactionIdIsValid(oldSerXidControl->tailXid)
            || TransactionIdPrecedes(xid, oldSerXidControl->tailXid))
        {
            oldSerXidControl->tailXid = xid;
        }
        LWLockRelease(OldSerXidLock);
        return;
    }

    Assert(!TransactionIdIsValid(oldSerXidControl->tailXid)
           || TransactionIdFollows(xid, oldSerXidControl->tailXid));

    oldSerXidControl->tailXid = xid;

    LWLockRelease(OldSerXidLock);
}

static void OnConflict_CheckForSerializationFailure ( const SERIALIZABLEXACT *  reader, SERIALIZABLEXACT *  writer  )

static

Definition at line 4537 of file predicate.c.

References Assert, SERIALIZABLEXACT::commitSeqNo, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), ERROR, SERIALIZABLEXACT::flags, SERIALIZABLEXACT::inConflicts, RWConflictData::inLink, SERIALIZABLEXACT::lastCommitBeforeSnapshot, LWLockHeldByMe(), LWLockRelease(), offsetof, SERIALIZABLEXACT::outConflicts, RWConflictData::outLink, SERIALIZABLEXACT::prepareSeqNo, SERIALIZABLEXACT::SeqNo, SHMQueueNext(), SXACT_FLAG_DOOMED, SxactHasConflictOut, SxactHasSummaryConflictIn, SxactHasSummaryConflictOut, RWConflictData::sxactIn, SxactIsCommitted, SxactIsDoomed, SxactIsPrepared, SxactIsReadOnly, RWConflictData::sxactOut, and SERIALIZABLEXACT::topXid.

Referenced by FlagRWConflict().

{
    bool        failure;
    RWConflict  conflict;

    Assert(LWLockHeldByMe(SerializableXactHashLock));

    failure = false;

    /*------------------------------------------------------------------------
     * Check for already-committed writer with rw-conflict out flagged
     * (conflict-flag on W means that T2 committed before W):
     *
     *      R ------> W ------> T2
     *          rw        rw
     *
     * That is a dangerous structure, so we must abort. (Since the writer
     * has already committed, we must be the reader)
     *------------------------------------------------------------------------
     */
    if (SxactIsCommitted(writer)
        && (SxactHasConflictOut(writer) || SxactHasSummaryConflictOut(writer)))
        failure = true;

    /*------------------------------------------------------------------------
     * Check whether the writer has become a pivot with an out-conflict
     * committed transaction (T2), and T2 committed first:
     *
     *      R ------> W ------> T2
     *          rw        rw
     *
     * Because T2 must've committed first, there is no anomaly if:
     * - the reader committed before T2
     * - the writer committed before T2
     * - the reader is a READ ONLY transaction and the reader was concurrent
     *   with T2 (= reader acquired its snapshot before T2 committed)
     *
     * We also handle the case that T2 is prepared but not yet committed
     * here. In that case T2 has already checked for conflicts, so if it
     * commits first, making the above conflict real, it's too late for it
     * to abort.
     *------------------------------------------------------------------------
     */
    if (!failure)
    {
        if (SxactHasSummaryConflictOut(writer))
        {
            failure = true;
            conflict = NULL;
        }
        else
            conflict = (RWConflict)
                SHMQueueNext(&writer->outConflicts,
                             &writer->outConflicts,
                             offsetof(RWConflictData, outLink));
        while (conflict)
        {
            SERIALIZABLEXACT *t2 = conflict->sxactIn;

            if (SxactIsPrepared(t2)
                && (!SxactIsCommitted(reader)
                    || t2->prepareSeqNo <= reader->commitSeqNo)
                && (!SxactIsCommitted(writer)
                    || t2->prepareSeqNo <= writer->commitSeqNo)
                && (!SxactIsReadOnly(reader)
                    || t2->prepareSeqNo <= reader->SeqNo.lastCommitBeforeSnapshot))
            {
                failure = true;
                break;
            }
            conflict = (RWConflict)
                SHMQueueNext(&writer->outConflicts,
                             &conflict->outLink,
                             offsetof(RWConflictData, outLink));
        }
    }

    /*------------------------------------------------------------------------
     * Check whether the reader has become a pivot with a writer
     * that's committed (or prepared):
     *
     *      T0 ------> R ------> W
     *           rw        rw
     *
     * Because W must've committed first for an anomaly to occur, there is no
     * anomaly if:
     * - T0 committed before the writer
     * - T0 is READ ONLY, and overlaps the writer
     *------------------------------------------------------------------------
     */
    if (!failure && SxactIsPrepared(writer) && !SxactIsReadOnly(reader))
    {
        if (SxactHasSummaryConflictIn(reader))
        {
            failure = true;
            conflict = NULL;
        }
        else
            conflict = (RWConflict)
                SHMQueueNext(&reader->inConflicts,
                             &reader->inConflicts,
                             offsetof(RWConflictData, inLink));
        while (conflict)
        {
            SERIALIZABLEXACT *t0 = conflict->sxactOut;

            if (!SxactIsDoomed(t0)
                && (!SxactIsCommitted(t0)
                    || t0->commitSeqNo >= writer->prepareSeqNo)
                && (!SxactIsReadOnly(t0)
                    || t0->SeqNo.lastCommitBeforeSnapshot >= writer->prepareSeqNo))
            {
                failure = true;
                break;
            }
            conflict = (RWConflict)
                SHMQueueNext(&reader->inConflicts,
                             &conflict->inLink,
                             offsetof(RWConflictData, inLink));
        }
    }

    if (failure)
    {
        /*
         * We have to kill a transaction to avoid a possible anomaly from
         * occurring. If the writer is us, we can just ereport() to cause a
         * transaction abort. Otherwise we flag the writer for termination,
         * causing it to abort when it tries to commit. However, if the writer
         * is a prepared transaction, already prepared, we can't abort it
         * anymore, so we have to kill the reader instead.
         */
        if (MySerializableXact == writer)
        {
            LWLockRelease(SerializableXactHashLock);
            ereport(ERROR,
                    (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                     errmsg("could not serialize access due to read/write dependencies among transactions"),
                     errdetail_internal("Reason code: Canceled on identification as a pivot, during write."),
                     errhint("The transaction might succeed if retried.")));
        }
        else if (SxactIsPrepared(writer))
        {
            LWLockRelease(SerializableXactHashLock);

            /* if we're not the writer, we have to be the reader */
            Assert(MySerializableXact == reader);
            ereport(ERROR,
                    (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                     errmsg("could not serialize access due to read/write dependencies among transactions"),
                     errdetail_internal("Reason code: Canceled on conflict out to pivot %u, during read.", writer->topXid),
                     errhint("The transaction might succeed if retried.")));
        }
        writer->flags |= SXACT_FLAG_DOOMED;
    }
}

bool PageIsPredicateLocked	(	Relation	relation,
		BlockNumber	blkno
	)

Definition at line 1929 of file predicate.c.

References RelFileNode::dbNode, HASH_FIND, hash_search_with_hash_value(), LW_SHARED, LWLockAcquire(), LWLockRelease(), PredicateLockHashPartitionLock, PredicateLockTargetTagHashCode, RelationData::rd_id, RelationData::rd_node, and SET_PREDICATELOCKTARGETTAG_PAGE.

{
    PREDICATELOCKTARGETTAG targettag;
    uint32      targettaghash;
    LWLock     *partitionLock;
    PREDICATELOCKTARGET *target;

    SET_PREDICATELOCKTARGETTAG_PAGE(targettag,
                                    relation->rd_node.dbNode,
                                    relation->rd_id,
                                    blkno);

    targettaghash = PredicateLockTargetTagHashCode(&targettag);
    partitionLock = PredicateLockHashPartitionLock(targettaghash);
    LWLockAcquire(partitionLock, LW_SHARED);
    target = (PREDICATELOCKTARGET *)
        hash_search_with_hash_value(PredicateLockTargetHash,
                                    &targettag, targettaghash,
                                    HASH_FIND, NULL);
    LWLockRelease(partitionLock);

    return (target != NULL);
}

void PostPrepare_PredicateLocks

(

TransactionId

xid

)

Definition at line 4874 of file predicate.c.

References Assert, hash_destroy(), InvalidSerializableXact, MyXactDidWrite, SERIALIZABLEXACT::pid, and SxactIsPrepared.

Referenced by PrepareTransaction().

{
    if (MySerializableXact == InvalidSerializableXact)
        return;

    Assert(SxactIsPrepared(MySerializableXact));

    MySerializableXact->pid = 0;

    hash_destroy(LocalPredicateLockHash);
    LocalPredicateLockHash = NULL;

    MySerializableXact = InvalidSerializableXact;
    MyXactDidWrite = false;
}

void PreCommit_CheckForSerializationFailure

(

void

)

Definition at line 4712 of file predicate.c.

References Assert, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), ERROR, SERIALIZABLEXACT::flags, SERIALIZABLEXACT::inConflicts, RWConflictData::inLink, InvalidSerializableXact, IsolationIsSerializable, PredXactListData::LastSxactCommitSeqNo, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), offsetof, SERIALIZABLEXACT::prepareSeqNo, SHMQueueNext(), SXACT_FLAG_DOOMED, SXACT_FLAG_PREPARED, SxactIsCommitted, SxactIsDoomed, SxactIsPrepared, SxactIsReadOnly, and RWConflictData::sxactOut.

Referenced by CommitTransaction(), and PrepareTransaction().

{
    RWConflict  nearConflict;

    if (MySerializableXact == InvalidSerializableXact)
        return;

    Assert(IsolationIsSerializable());

    LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);

    /* Check if someone else has already decided that we need to die */
    if (SxactIsDoomed(MySerializableXact))
    {
        LWLockRelease(SerializableXactHashLock);
        ereport(ERROR,
                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                 errdetail_internal("Reason code: Canceled on identification as a pivot, during commit attempt."),
                 errhint("The transaction might succeed if retried.")));
    }

    nearConflict = (RWConflict)
        SHMQueueNext(&MySerializableXact->inConflicts,
                     &MySerializableXact->inConflicts,
                     offsetof(RWConflictData, inLink));
    while (nearConflict)
    {
        if (!SxactIsCommitted(nearConflict->sxactOut)
            && !SxactIsDoomed(nearConflict->sxactOut))
        {
            RWConflict  farConflict;

            farConflict = (RWConflict)
                SHMQueueNext(&nearConflict->sxactOut->inConflicts,
                             &nearConflict->sxactOut->inConflicts,
                             offsetof(RWConflictData, inLink));
            while (farConflict)
            {
                if (farConflict->sxactOut == MySerializableXact
                    || (!SxactIsCommitted(farConflict->sxactOut)
                        && !SxactIsReadOnly(farConflict->sxactOut)
                        && !SxactIsDoomed(farConflict->sxactOut)))
                {
                    /*
                     * Normally, we kill the pivot transaction to make sure we
                     * make progress if the failing transaction is retried.
                     * However, we can't kill it if it's already prepared, so
                     * in that case we commit suicide instead.
                     */
                    if (SxactIsPrepared(nearConflict->sxactOut))
                    {
                        LWLockRelease(SerializableXactHashLock);
                        ereport(ERROR,
                                (errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
                                 errmsg("could not serialize access due to read/write dependencies among transactions"),
                                 errdetail_internal("Reason code: Canceled on commit attempt with conflict in from prepared pivot."),
                                 errhint("The transaction might succeed if retried.")));
                    }
                    nearConflict->sxactOut->flags |= SXACT_FLAG_DOOMED;
                    break;
                }
                farConflict = (RWConflict)
                    SHMQueueNext(&nearConflict->sxactOut->inConflicts,
                                 &farConflict->inLink,
                                 offsetof(RWConflictData, inLink));
            }
        }

        nearConflict = (RWConflict)
            SHMQueueNext(&MySerializableXact->inConflicts,
                         &nearConflict->inLink,
                         offsetof(RWConflictData, inLink));
    }

    MySerializableXact->prepareSeqNo = ++(PredXact->LastSxactCommitSeqNo);
    MySerializableXact->flags |= SXACT_FLAG_PREPARED;

    LWLockRelease(SerializableXactHashLock);
}

static uint32 predicatelock_hash ( const void *  key, Size  keysize  )

static

Definition at line 1373 of file predicate.c.

References Assert, PREDICATELOCKTAG::myTarget, PredicateLockHashCodeFromTargetHashCode, PredicateLockTargetTagHashCode, and PREDICATELOCKTARGET::tag.

Referenced by InitPredicateLocks().

{
    const PREDICATELOCKTAG *predicatelocktag = (const PREDICATELOCKTAG *) key;
    uint32      targethash;

    Assert(keysize == sizeof(PREDICATELOCKTAG));

    /* Look into the associated target object, and compute its hash code */
    targethash = PredicateLockTargetTagHashCode(&predicatelocktag->myTarget->tag);

    return PredicateLockHashCodeFromTargetHashCode(predicatelocktag, targethash);
}

void predicatelock_twophase_recover	(	TransactionId	xid,
		uint16	info,
		void *	recdata,
		uint32	len
	)

Definition at line 4923 of file predicate.c.

References Assert, VirtualTransactionId::backendId, SERIALIZABLEXACT::commitSeqNo, CreatePredicateLock(), CreatePredXact(), TwoPhasePredicateRecord::data, ereport, errcode(), errmsg(), ERROR, SERIALIZABLEXACT::finishedBefore, SERIALIZABLEXACT::finishedLink, SERIALIZABLEXACT::flags, TwoPhasePredicateXactRecord::flags, HASH_ENTER, HASH_FIND, hash_search(), SERIALIZABLEXACT::inConflicts, InvalidBackendId, InvalidSerCommitSeqNo, InvalidSerializableXact, InvalidTransactionId, SERIALIZABLEXACT::lastCommitBeforeSnapshot, VirtualTransactionId::localTransactionId, TwoPhasePredicateRecord::lockRecord, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), max_prepared_xacts, MaxBackends, SERIALIZABLEXID::myXact, OldSerXidSetActiveSerXmin(), SERIALIZABLEXACT::outConflicts, SERIALIZABLEXACT::pid, SERIALIZABLEXACT::possibleUnsafeConflicts, SERIALIZABLEXACT::predicateLocks, PredicateLockTargetTagHashCode, SERIALIZABLEXACT::prepareSeqNo, RecoverySerCommitSeqNo, SERIALIZABLEXACT::SeqNo, SHMQueueElemInit(), SHMQueueInit(), SXACT_FLAG_SUMMARY_CONFLICT_IN, SXACT_FLAG_SUMMARY_CONFLICT_OUT, PredXactListData::SxactGlobalXmin, PredXactListData::SxactGlobalXminCount, SxactIsPrepared, SxactIsReadOnly, TwoPhasePredicateLockRecord::target, SERIALIZABLEXACT::topXid, TransactionIdEquals, TransactionIdFollows(), TransactionIdIsValid, TWOPHASEPREDICATERECORD_LOCK, TWOPHASEPREDICATERECORD_XACT, TwoPhasePredicateRecord::type, SERIALIZABLEXACT::vxid, PredXactListData::WritableSxactCount, TwoPhasePredicateRecord::xactRecord, SERIALIZABLEXIDTAG::xid, SERIALIZABLEXACT::xmin, and TwoPhasePredicateXactRecord::xmin.

{
    TwoPhasePredicateRecord *record;

    Assert(len == sizeof(TwoPhasePredicateRecord));

    record = (TwoPhasePredicateRecord *) recdata;

    Assert((record->type == TWOPHASEPREDICATERECORD_XACT) ||
           (record->type == TWOPHASEPREDICATERECORD_LOCK));

    if (record->type == TWOPHASEPREDICATERECORD_XACT)
    {
        /* Per-transaction record. Set up a SERIALIZABLEXACT. */
        TwoPhasePredicateXactRecord *xactRecord;
        SERIALIZABLEXACT *sxact;
        SERIALIZABLEXID *sxid;
        SERIALIZABLEXIDTAG sxidtag;
        bool        found;

        xactRecord = (TwoPhasePredicateXactRecord *) &record->data.xactRecord;

        LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
        sxact = CreatePredXact();
        if (!sxact)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of shared memory")));

        /* vxid for a prepared xact is InvalidBackendId/xid; no pid */
        sxact->vxid.backendId = InvalidBackendId;
        sxact->vxid.localTransactionId = (LocalTransactionId) xid;
        sxact->pid = 0;

        /* a prepared xact hasn't committed yet */
        sxact->prepareSeqNo = RecoverySerCommitSeqNo;
        sxact->commitSeqNo = InvalidSerCommitSeqNo;
        sxact->finishedBefore = InvalidTransactionId;

        sxact->SeqNo.lastCommitBeforeSnapshot = RecoverySerCommitSeqNo;

        /*
         * Don't need to track this; no transactions running at the time the
         * recovered xact started are still active, except possibly other
         * prepared xacts and we don't care whether those are RO_SAFE or not.
         */
        SHMQueueInit(&(sxact->possibleUnsafeConflicts));

        SHMQueueInit(&(sxact->predicateLocks));
        SHMQueueElemInit(&(sxact->finishedLink));

        sxact->topXid = xid;
        sxact->xmin = xactRecord->xmin;
        sxact->flags = xactRecord->flags;
        Assert(SxactIsPrepared(sxact));
        if (!SxactIsReadOnly(sxact))
        {
            ++(PredXact->WritableSxactCount);
            Assert(PredXact->WritableSxactCount <=
                   (MaxBackends + max_prepared_xacts));
        }

        /*
         * We don't know whether the transaction had any conflicts or not, so
         * we'll conservatively assume that it had both a conflict in and a
         * conflict out, and represent that with the summary conflict flags.
         */
        SHMQueueInit(&(sxact->outConflicts));
        SHMQueueInit(&(sxact->inConflicts));
        sxact->flags |= SXACT_FLAG_SUMMARY_CONFLICT_IN;
        sxact->flags |= SXACT_FLAG_SUMMARY_CONFLICT_OUT;

        /* Register the transaction's xid */
        sxidtag.xid = xid;
        sxid = (SERIALIZABLEXID *) hash_search(SerializableXidHash,
                                               &sxidtag,
                                               HASH_ENTER, &found);
        Assert(sxid != NULL);
        Assert(!found);
        sxid->myXact = (SERIALIZABLEXACT *) sxact;

        /*
         * Update global xmin. Note that this is a special case compared to
         * registering a normal transaction, because the global xmin might go
         * backwards. That's OK, because until recovery is over we're not
         * going to complete any transactions or create any non-prepared
         * transactions, so there's no danger of throwing away.
         */
        if ((!TransactionIdIsValid(PredXact->SxactGlobalXmin)) ||
            (TransactionIdFollows(PredXact->SxactGlobalXmin, sxact->xmin)))
        {
            PredXact->SxactGlobalXmin = sxact->xmin;
            PredXact->SxactGlobalXminCount = 1;
            OldSerXidSetActiveSerXmin(sxact->xmin);
        }
        else if (TransactionIdEquals(sxact->xmin, PredXact->SxactGlobalXmin))
        {
            Assert(PredXact->SxactGlobalXminCount > 0);
            PredXact->SxactGlobalXminCount++;
        }

        LWLockRelease(SerializableXactHashLock);
    }
    else if (record->type == TWOPHASEPREDICATERECORD_LOCK)
    {
        /* Lock record. Recreate the PREDICATELOCK */
        TwoPhasePredicateLockRecord *lockRecord;
        SERIALIZABLEXID *sxid;
        SERIALIZABLEXACT *sxact;
        SERIALIZABLEXIDTAG sxidtag;
        uint32      targettaghash;

        lockRecord = (TwoPhasePredicateLockRecord *) &record->data.lockRecord;
        targettaghash = PredicateLockTargetTagHashCode(&lockRecord->target);

        LWLockAcquire(SerializableXactHashLock, LW_SHARED);
        sxidtag.xid = xid;
        sxid = (SERIALIZABLEXID *)
            hash_search(SerializableXidHash, &sxidtag, HASH_FIND, NULL);
        LWLockRelease(SerializableXactHashLock);

        Assert(sxid != NULL);
        sxact = sxid->myXact;
        Assert(sxact != InvalidSerializableXact);

        CreatePredicateLock(&lockRecord->target, targettaghash, sxact);
    }
}