58 mul_size(max_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))
115 "ShareUpdateExclusiveLock",
117 "ShareRowExclusiveLock",
119 "AccessExclusiveLock"
202 #define FAST_PATH_BITS_PER_SLOT 3
203 #define FAST_PATH_LOCKNUMBER_OFFSET 1
204 #define FAST_PATH_MASK ((1 << FAST_PATH_BITS_PER_SLOT) - 1)
205 #define FAST_PATH_GET_BITS(proc, n) \
206 (((proc)->fpLockBits >> (FAST_PATH_BITS_PER_SLOT * n)) & FAST_PATH_MASK)
207 #define FAST_PATH_BIT_POSITION(n, l) \
208 (AssertMacro((l) >= FAST_PATH_LOCKNUMBER_OFFSET), \
209 AssertMacro((l) < FAST_PATH_BITS_PER_SLOT+FAST_PATH_LOCKNUMBER_OFFSET), \
210 AssertMacro((n) < FP_LOCK_SLOTS_PER_BACKEND), \
211 ((l) - FAST_PATH_LOCKNUMBER_OFFSET + FAST_PATH_BITS_PER_SLOT * (n)))
212 #define FAST_PATH_SET_LOCKMODE(proc, n, l) \
213 (proc)->fpLockBits |= UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)
214 #define FAST_PATH_CLEAR_LOCKMODE(proc, n, l) \
215 (proc)->fpLockBits &= ~(UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l))
216 #define FAST_PATH_CHECK_LOCKMODE(proc, n, l) \
217 ((proc)->fpLockBits & (UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)))
227 #define EligibleForRelationFastPath(locktag, mode) \
228 ((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
229 (locktag)->locktag_type == LOCKTAG_RELATION && \
230 (locktag)->locktag_field1 == MyDatabaseId && \
231 MyDatabaseId != InvalidOid && \
232 (mode) < ShareUpdateExclusiveLock)
233 #define ConflictsWithRelationFastPath(locktag, mode) \
234 ((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
235 (locktag)->locktag_type == LOCKTAG_RELATION && \
236 (locktag)->locktag_field1 != InvalidOid && \
237 (mode) > ShareUpdateExclusiveLock)
260 #define FAST_PATH_STRONG_LOCK_HASH_BITS 10
261 #define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS \
262 (1 << FAST_PATH_STRONG_LOCK_HASH_BITS)
263 #define FastPathStrongLockHashPartition(hashcode) \
264 ((hashcode) % FAST_PATH_STRONG_LOCK_HASH_PARTITIONS)
312 bool Trace_locks =
false;
313 bool Trace_userlocks =
false;
314 int Trace_lock_table = 0;
315 bool Debug_deadlocks =
false;
319 LOCK_DEBUG_ENABLED(
const LOCKTAG *tag)
324 || (Trace_lock_table &&
332 if (LOCK_DEBUG_ENABLED(&lock->
tag))
334 "%s: lock(%p) id(%u,%u,%u,%u,%u,%u) grantMask(%x) "
335 "req(%d,%d,%d,%d,%d,%d,%d)=%d "
336 "grant(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)",
358 "%s: proclock(%p) lock(%p) method(%u) proc(%p) hold(%x)",
365 #define LOCK_PRINT(where, lock, type) ((void) 0)
366 #define PROCLOCK_PRINT(where, proclockP) ((void) 0)
387 bool decrement_strong_lock_count);
408 long init_table_size,
417 init_table_size = max_table_size / 2;
435 init_table_size *= 2;
567 uint32 lockhash = hashcode;
606 MemSet(&localtag, 0,
sizeof(localtag));
607 localtag.
lock = *locktag;
608 localtag.
mode = lockmode;
614 return (locallock && locallock->
nLocks > 0);
617 #ifdef USE_ASSERT_CHECKING
623 GetLockMethodLocalHash(
void)
643 bool hasWaiters =
false;
646 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
648 if (lockmode <= 0 || lockmode > lockMethodTable->
numLockModes)
649 elog(
ERROR,
"unrecognized lock mode: %d", lockmode);
652 if (LOCK_DEBUG_ENABLED(locktag))
653 elog(
LOG,
"LockHasWaiters: lock [%u,%u] %s",
661 MemSet(&localtag, 0,
sizeof(localtag));
662 localtag.
lock = *locktag;
663 localtag.
mode = lockmode;
672 if (!locallock || locallock->
nLocks <= 0)
691 lock = locallock->
lock;
692 LOCK_PRINT(
"LockHasWaiters: found", lock, lockmode);
775 bool reportMemoryError,
789 bool log_lock =
false;
792 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
794 if (lockmode <= 0 || lockmode > lockMethodTable->
numLockModes)
795 elog(
ERROR,
"unrecognized lock mode: %d", lockmode);
802 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
803 errmsg(
"cannot acquire lock mode %s on database objects while recovery is in progress",
805 errhint(
"Only RowExclusiveLock or less can be acquired on database objects during recovery.")));
808 if (LOCK_DEBUG_ENABLED(locktag))
809 elog(
LOG,
"LockAcquire: lock [%u,%u] %s",
823 MemSet(&localtag, 0,
sizeof(localtag));
824 localtag.
lock = *locktag;
825 localtag.
mode = lockmode;
836 locallock->
lock = NULL;
865 *locallockp = locallock;
873 if (locallock->
nLocks > 0)
887 Assert(!IsRelationExtensionLockHeld);
953 locallock->
lock = NULL;
975 if (locallock->
nLocks == 0)
979 if (reportMemoryError)
981 (
errcode(ERRCODE_OUT_OF_MEMORY),
982 errmsg(
"out of shared memory"),
983 errhint(
"You might need to increase max_locks_per_transaction.")));
1008 hashcode, lockmode);
1013 if (locallock->
nLocks == 0)
1017 if (reportMemoryError)
1019 (
errcode(ERRCODE_OUT_OF_MEMORY),
1020 errmsg(
"out of shared memory"),
1021 errhint(
"You might need to increase max_locks_per_transaction.")));
1027 locallock->
lock = lock;
1035 found_conflict =
true;
1040 if (!found_conflict)
1058 uint32 proclock_hashcode;
1068 elog(
PANIC,
"proclock table corrupted");
1074 LOCK_PRINT(
"LockAcquire: conditional lock failed", lock, lockmode);
1078 if (locallock->
nLocks == 0)
1124 LOCK_PRINT(
"LockAcquire: INCONSISTENT", lock, lockmode);
1130 LOCK_PRINT(
"LockAcquire: granted", lock, lockmode);
1176 uint32 proclock_hashcode;
1203 LOCK_PRINT(
"LockAcquire: new", lock, lockmode);
1207 LOCK_PRINT(
"LockAcquire: found", lock, lockmode);
1216 proclocktag.
myLock = lock;
1217 proclocktag.
myProc = proc;
1282 #ifdef CHECK_DEADLOCK_RISK
1305 if (
i >= (
int) lockmode)
1307 elog(
LOG,
"deadlock risk: raising lock level"
1308 " from %s to %s on object %u/%u/%u",
1334 elog(
ERROR,
"lock %s on object %u/%u/%u is already held",
1353 #ifdef USE_ASSERT_CHECKING
1355 IsRelationExtensionLockHeld = acquired;
1357 IsPageLockHeld = acquired;
1426 int conflictMask = lockMethodTable->
conflictTab[lockmode];
1428 int totalConflictsRemaining = 0;
1453 for (
i = 1;
i <= numLockModes;
i++)
1457 conflictsRemaining[
i] = 0;
1460 conflictsRemaining[
i] = lock->
granted[
i];
1462 --conflictsRemaining[
i];
1463 totalConflictsRemaining += conflictsRemaining[
i];
1467 if (totalConflictsRemaining == 0)
1469 PROCLOCK_PRINT(
"LockCheckConflicts: resolved (simple)", proclock);
1507 if (proclock != otherproclock &&
1509 (otherproclock->
holdMask & conflictMask) != 0)
1511 int intersectMask = otherproclock->
holdMask & conflictMask;
1513 for (
i = 1;
i <= numLockModes;
i++)
1517 if (conflictsRemaining[
i] <= 0)
1518 elog(
PANIC,
"proclocks held do not match lock");
1519 conflictsRemaining[
i]--;
1520 totalConflictsRemaining--;
1524 if (totalConflictsRemaining == 0)
1534 PROCLOCK_PRINT(
"LockCheckConflicts: conflicting (group)", proclock);
1576 bool wakeupNeeded =
false;
1590 if (lock->
granted[lockmode] == 0)
1596 LOCK_PRINT(
"UnGrantLock: updated", lock, lockmode);
1608 wakeupNeeded =
true;
1616 return wakeupNeeded;
1640 uint32 proclock_hashcode;
1651 elog(
PANIC,
"proclock table corrupted");
1660 LOCK_PRINT(
"CleanUpLock: deleting", lock, 0);
1669 else if (wakeupNeeded)
1695 if (lockOwners[
i].owner == owner)
1701 lockOwners[
i].
owner = owner;
1757 if (locallock == NULL)
1961 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
1963 if (lockmode <= 0 || lockmode > lockMethodTable->
numLockModes)
1964 elog(
ERROR,
"unrecognized lock mode: %d", lockmode);
1967 if (LOCK_DEBUG_ENABLED(locktag))
1968 elog(
LOG,
"LockRelease: lock [%u,%u] %s",
1976 MemSet(&localtag, 0,
sizeof(localtag));
1977 localtag.
lock = *locktag;
1978 localtag.
mode = lockmode;
1987 if (!locallock || locallock->
nLocks <= 0)
2010 if (lockOwners[
i].owner == owner)
2012 Assert(lockOwners[
i].nLocks > 0);
2013 if (--lockOwners[
i].nLocks == 0)
2019 if (i < locallock->numLockOwners)
2040 if (locallock->
nLocks > 0)
2088 lock = locallock->
lock;
2100 elog(
ERROR,
"failed to re-find shared lock object");
2101 locallock->
lock = lock;
2103 proclocktag.
myLock = lock;
2110 elog(
ERROR,
"failed to re-find shared proclock object");
2112 LOCK_PRINT(
"LockRelease: found", lock, lockmode);
2133 wakeupNeeded =
UnGrantLock(lock, lockmode, proclock, lockMethodTable);
2136 lockMethodTable, locallock->
hashcode,
2163 bool have_fast_path_lwlock =
false;
2166 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
2171 elog(
LOG,
"LockReleaseAll: lockmethod=%d", lockmethodid);
2202 if (locallock->
nLocks == 0)
2224 if (lockOwners[
i].owner == NULL)
2225 lockOwners[0] = lockOwners[
i];
2231 lockOwners[0].
owner == NULL &&
2232 lockOwners[0].
nLocks > 0)
2248 if (locallock->
proclock == NULL || locallock->
lock == NULL)
2255 elog(
PANIC,
"locallock table corrupted");
2265 if (!have_fast_path_lwlock)
2268 have_fast_path_lwlock =
true;
2285 have_fast_path_lwlock =
false;
2295 &locallock->
tag.
lock, lockmode,
false);
2301 if (locallock->
nLocks > 0)
2309 if (have_fast_path_lwlock)
2350 bool wakeupNeeded =
false;
2386 for (
i = 1;
i <= numLockModes;
i++)
2394 LOCK_PRINT(
"LockReleaseAll: updated", lock, 0);
2410 elog(
LOG,
"LockReleaseAll done");
2425 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
2451 if (locallocks == NULL)
2465 for (
i = nlocks - 1;
i >= 0;
i--)
2500 if (lockOwners[
i].owner == owner)
2502 Assert(lockOwners[
i].nLocks > 0);
2503 if (lockOwners[
i].nLocks < locallock->nLocks)
2514 if (i < locallock->numLockOwners)
2550 if (locallocks == NULL)
2564 for (
i = nlocks - 1;
i >= 0;
i--)
2590 else if (lockOwners[
i].owner == parent)
2600 lockOwners[ic].
owner = parent;
2609 if (ic < locallock->numLockOwners)
2660 bool result =
false;
2747 hashcode, lockmode);
2795 lockmode = locallock->
tag.
mode;
2809 (
errcode(ERRCODE_OUT_OF_MEMORY),
2810 errmsg(
"out of shared memory"),
2811 errhint(
"You might need to increase max_locks_per_transaction.")));
2825 if (proclock == NULL)
2829 uint32 proclock_hashcode;
2839 elog(
ERROR,
"failed to re-find shared lock object");
2841 proclocktag.
myLock = lock;
2852 elog(
ERROR,
"failed to re-find shared proclock object");
2894 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
2896 if (lockmode <= 0 || lockmode > lockMethodTable->
numLockModes)
2897 elog(
ERROR,
"unrecognized lock mode: %d", lockmode);
2920 conflictMask = lockMethodTable->
conflictTab[lockmode];
2973 if (relid != proc->
fpRelId[f])
2984 if ((lockmask & conflictMask) == 0)
2991 vxids[count++] = vxid;
3036 if (conflictMask & proclock->
holdMask)
3052 for (
i = 0;
i < fast_count; ++
i)
3055 if (
i >= fast_count)
3056 vxids[count++] = vxid;
3066 elog(
PANIC,
"too many conflicting locks found");
3089 bool decrement_strong_lock_count)
3095 uint32 proclock_hashcode;
3113 elog(
PANIC,
"failed to re-find shared lock object");
3118 proclocktag.
myLock = lock;
3119 proclocktag.
myProc = proc;
3129 elog(
PANIC,
"failed to re-find shared proclock object");
3147 wakeupNeeded =
UnGrantLock(lock, lockmode, proclock, lockMethodTable);
3150 lockMethodTable, hashcode,
3158 if (decrement_strong_lock_count
3207 hash_ctl.
entrysize =
sizeof(PerLockTagEntry);
3210 lockhtab =
hash_create(
"CheckForSessionAndXactLocks table",
3221 PerLockTagEntry *hentry;
3233 if (locallock->
nLocks <= 0)
3237 hentry = (PerLockTagEntry *)
hash_search(lockhtab,
3241 hentry->sessLock = hentry->xactLock =
false;
3246 if (lockOwners[
i].owner == NULL)
3247 hentry->sessLock =
true;
3249 hentry->xactLock =
true;
3256 if (hentry->sessLock && hentry->xactLock)
3258 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3259 errmsg(
"cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3294 bool haveSessionLock;
3306 if (locallock->
nLocks <= 0)
3310 haveSessionLock = haveXactLock =
false;
3313 if (lockOwners[
i].owner == NULL)
3314 haveSessionLock =
true;
3316 haveXactLock =
true;
3324 if (haveSessionLock)
3326 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3327 errmsg(
"cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3406 bool haveSessionLock;
3410 if (locallock->
proclock == NULL || locallock->
lock == NULL)
3426 haveSessionLock = haveXactLock =
false;
3429 if (lockOwners[
i].owner == NULL)
3430 haveSessionLock =
true;
3432 haveXactLock =
true;
3440 if (haveSessionLock)
3442 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3443 errmsg(
"cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3446 if (locallock->
nLocks > 0)
3502 elog(
PANIC,
"we seem to have dropped a bit somewhere");
3522 proclocktag.
myLock = lock;
3523 proclocktag.
myProc = newproc;
3540 elog(
PANIC,
"duplicate entry found while reassigning a prepared transaction's locks");
3562 long max_table_size;
3569 max_table_size *= 2;
3647 instance = &
data->locks[el];
3654 instance->
pid = proc->
pid;
3682 instance = &
data->locks[el];
3688 instance->
pid = proc->
pid;
3717 if (
data->nelements > els)
3719 els =
data->nelements;
3741 instance->
pid = proc->
pid;
3878 if (theLock == NULL)
3882 bproc = &
data->procs[
data->nprocs++];
3883 bproc->
pid = blocked_proc->
pid;
3901 if (
data->nlocks >=
data->maxlocks)
3908 instance = &
data->locks[
data->nlocks];
3917 instance->
pid = proc->
pid;
3927 if (queue_size >
data->maxpids -
data->npids)
3930 data->npids + queue_size);
3932 sizeof(
int) *
data->maxpids);
3939 if (queued_proc == blocked_proc)
3941 data->waiter_pids[
data->npids++] = queued_proc->
pid;
4018 accessExclusiveLocks[
index].
xid = xid;
4039 return accessExclusiveLocks;
4113 elog(
LOG,
"DumpAllLocks: proclock->tag.myLock = NULL");
4161 uint32 proclock_hashcode;
4172 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
4193 (
errcode(ERRCODE_OUT_OF_MEMORY),
4194 errmsg(
"out of shared memory"),
4195 errhint(
"You might need to increase max_locks_per_transaction.")));
4211 LOCK_PRINT(
"lock_twophase_recover: new", lock, lockmode);
4215 LOCK_PRINT(
"lock_twophase_recover: found", lock, lockmode);
4224 proclocktag.
myLock = lock;
4225 proclocktag.
myProc = proc;
4258 (
errcode(ERRCODE_OUT_OF_MEMORY),
4259 errmsg(
"out of shared memory"),
4260 errhint(
"You might need to increase max_locks_per_transaction.")));
4296 elog(
ERROR,
"lock %s on object %u/%u/%u is already held",
4343 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
4375 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
4608 (
errcode(ERRCODE_OUT_OF_MEMORY),
4609 errmsg(
"out of shared memory"),
4610 errhint(
"You might need to increase max_locks_per_transaction.")));
4655 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
uint32 LocalTransactionId
#define MemSet(start, val, len)
elog(ERROR, "%s: %s", p2, msg)
void DeadLockReport(void)
void hash_destroy(HTAB *hashp)
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
long hash_get_num_entries(HTAB *hashp)
Size hash_estimate_size(long num_entries, Size entrysize)
bool hash_update_hash_key(HTAB *hashp, void *existingEntry, const void *newKeyPtr)
uint32 get_hash_value(HTAB *hashp, const void *keyPtr)
void * hash_search_with_hash_value(HTAB *hashp, const void *keyPtr, uint32 hashvalue, HASHACTION action, bool *foundPtr)
void * hash_seq_search(HASH_SEQ_STATUS *status)
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
#define dlist_foreach(iter, lhead)
static void dlist_init(dlist_head *head)
static void dlist_delete(dlist_node *node)
static uint32 dclist_count(const dclist_head *head)
static bool dclist_is_empty(const dclist_head *head)
#define dlist_foreach_modify(iter, lhead)
static bool dlist_is_empty(const dlist_head *head)
static void dlist_push_tail(dlist_head *head, dlist_node *node)
static void dclist_delete_from(dclist_head *head, dlist_node *node)
static void dclist_init(dclist_head *head)
#define dlist_container(type, membername, ptr)
#define dclist_foreach(iter, lhead)
Assert(fmt[strlen(fmt) - 1] !='\n')
static bool XactLockForVirtualXact(VirtualTransactionId vxid, TransactionId xid, bool wait)
LockAcquireResult LockAcquire(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait)
static LOCALLOCK * awaitedLock
static void RemoveLocalLock(LOCALLOCK *locallock)
LockAcquireResult LockAcquireExtended(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock, bool dontWait, bool reportMemoryError, LOCALLOCK **locallockp)
static void LockReassignOwner(LOCALLOCK *locallock, ResourceOwner parent)
VirtualTransactionId * GetLockConflicts(const LOCKTAG *locktag, LOCKMODE lockmode, int *countp)
static const char *const lock_mode_names[]
#define LOCK_PRINT(where, lock, type)
bool DoLockModesConflict(LOCKMODE mode1, LOCKMODE mode2)
static PROCLOCK * SetupLockInTable(LockMethod lockMethodTable, PGPROC *proc, const LOCKTAG *locktag, uint32 hashcode, LOCKMODE lockmode)
static PROCLOCK * FastPathGetRelationLockEntry(LOCALLOCK *locallock)
void VirtualXactLockTableInsert(VirtualTransactionId vxid)
#define FastPathStrongLockHashPartition(hashcode)
static uint32 ProcLockHashCode(const PROCLOCKTAG *proclocktag, uint32 hashcode)
xl_standby_lock * GetRunningTransactionLocks(int *nlocks)
#define FAST_PATH_CHECK_LOCKMODE(proc, n, l)
void GrantAwaitedLock(void)
int LockWaiterCount(const LOCKTAG *locktag)
bool LockHeldByMe(const LOCKTAG *locktag, LOCKMODE lockmode)
void AtPrepare_Locks(void)
bool LockRelease(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
void lock_twophase_postcommit(TransactionId xid, uint16 info, void *recdata, uint32 len)
#define FAST_PATH_LOCKNUMBER_OFFSET
void GrantLock(LOCK *lock, PROCLOCK *proclock, LOCKMODE lockmode)
void VirtualXactLockTableCleanup(void)
static bool IsRelationExtensionLockHeld PG_USED_FOR_ASSERTS_ONLY
BlockedProcsData * GetBlockerStatusData(int blocked_pid)
bool VirtualXactLock(VirtualTransactionId vxid, bool wait)
static volatile FastPathStrongRelationLockData * FastPathStrongRelationLocks
void RemoveFromWaitQueue(PGPROC *proc, uint32 hashcode)
void LockReleaseAll(LOCKMETHODID lockmethodid, bool allLocks)
static void CheckAndSetLockHeld(LOCALLOCK *locallock, bool acquired)
#define ConflictsWithRelationFastPath(locktag, mode)
static bool FastPathTransferRelationLocks(LockMethod lockMethodTable, const LOCKTAG *locktag, uint32 hashcode)
static HTAB * LockMethodLocalHash
void LockReassignCurrentOwner(LOCALLOCK **locallocks, int nlocks)
static bool UnGrantLock(LOCK *lock, LOCKMODE lockmode, PROCLOCK *proclock, LockMethod lockMethodTable)
#define FAST_PATH_SET_LOCKMODE(proc, n, l)
#define PROCLOCK_PRINT(where, proclockP)
LockData * GetLockStatusData(void)
static void CleanUpLock(LOCK *lock, PROCLOCK *proclock, LockMethod lockMethodTable, uint32 hashcode, bool wakeupNeeded)
static uint32 proclock_hash(const void *key, Size keysize)
static bool FastPathUnGrantRelationLock(Oid relid, LOCKMODE lockmode)
void AbortStrongLockAcquire(void)
static bool FastPathGrantRelationLock(Oid relid, LOCKMODE lockmode)
static HTAB * LockMethodLockHash
static ResourceOwner awaitedOwner
void lock_twophase_postabort(TransactionId xid, uint16 info, void *recdata, uint32 len)
bool LockHasWaiters(const LOCKTAG *locktag, LOCKMODE lockmode, bool sessionLock)
static void GetSingleProcBlockerStatusData(PGPROC *blocked_proc, BlockedProcsData *data)
#define FAST_PATH_CLEAR_LOCKMODE(proc, n, l)
static const LockMethod LockMethods[]
void lock_twophase_standby_recover(TransactionId xid, uint16 info, void *recdata, uint32 len)
void LockReleaseCurrentOwner(LOCALLOCK **locallocks, int nlocks)
static void WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner)
void lock_twophase_recover(TransactionId xid, uint16 info, void *recdata, uint32 len)
void LockReleaseSession(LOCKMETHODID lockmethodid)
void MarkLockClear(LOCALLOCK *locallock)
const char * GetLockmodeName(LOCKMETHODID lockmethodid, LOCKMODE mode)
static const LockMethodData default_lockmethod
#define FAST_PATH_GET_BITS(proc, n)
static LOCALLOCK * StrongLockInProgress
#define FAST_PATH_BITS_PER_SLOT
static const LockMethodData user_lockmethod
static int FastPathLocalUseCount
#define EligibleForRelationFastPath(locktag, mode)
uint32 LockTagHashCode(const LOCKTAG *locktag)
static void BeginStrongLockAcquire(LOCALLOCK *locallock, uint32 fasthashcode)
bool LockCheckConflicts(LockMethod lockMethodTable, LOCKMODE lockmode, LOCK *lock, PROCLOCK *proclock)
static void GrantLockLocal(LOCALLOCK *locallock, ResourceOwner owner)
static const LOCKMASK LockConflicts[]
static void ReleaseLockIfHeld(LOCALLOCK *locallock, bool sessionLock)
LockMethod GetLocksMethodTable(const LOCK *lock)
static void FinishStrongLockAcquire(void)
#define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS
void PostPrepare_Locks(TransactionId xid)
static void LockRefindAndRelease(LockMethod lockMethodTable, PGPROC *proc, LOCKTAG *locktag, LOCKMODE lockmode, bool decrement_strong_lock_count)
static void CheckForSessionAndXactLocks(void)
static HTAB * LockMethodProcLockHash
struct TwoPhaseLockRecord TwoPhaseLockRecord
LockMethod GetLockTagsMethodTable(const LOCKTAG *locktag)
#define DEFAULT_LOCKMETHOD
struct LOCALLOCK LOCALLOCK
#define LOCK_LOCKTAG(lock)
#define SET_LOCKTAG_VIRTUALTRANSACTION(locktag, vxid)
@ LOCKTAG_RELATION_EXTEND
@ LOCKTAG_VIRTUALTRANSACTION
#define VirtualTransactionIdIsValid(vxid)
#define LockHashPartitionLock(hashcode)
#define LOCK_LOCKMETHOD(lock)
#define LOCKBIT_OFF(lockmode)
#define LOCALLOCK_LOCKMETHOD(llock)
#define InvalidLocalTransactionId
#define SET_LOCKTAG_TRANSACTION(locktag, xid)
#define SET_LOCKTAG_RELATION(locktag, dboid, reloid)
struct PROCLOCKTAG PROCLOCKTAG
#define LOCKBIT_ON(lockmode)
#define LocalTransactionIdIsValid(lxid)
#define LOCALLOCK_LOCKTAG(llock)
#define LockHashPartition(hashcode)
#define VirtualTransactionIdEquals(vxid1, vxid2)
struct LOCALLOCKTAG LOCALLOCKTAG
#define PROCLOCK_LOCKMETHOD(proclock)
#define LockHashPartitionLockByIndex(i)
@ LOCKACQUIRE_ALREADY_CLEAR
@ LOCKACQUIRE_ALREADY_HELD
#define GET_VXID_FROM_PGPROC(vxid, proc)
#define VirtualTransactionIdIsRecoveredPreparedXact(vxid)
#define AccessExclusiveLock
#define ShareRowExclusiveLock
#define ShareUpdateExclusiveLock
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
void LWLockRelease(LWLock *lock)
#define NUM_LOCK_PARTITIONS
#define LOG2_NUM_LOCK_PARTITIONS
void pfree(void *pointer)
MemoryContext TopMemoryContext
void * palloc0(Size size)
MemoryContext CurrentMemoryContext
void * repalloc(void *pointer, Size size)
void * MemoryContextAlloc(MemoryContext context, Size size)
#define START_CRIT_SECTION()
#define END_CRIT_SECTION()
static PgChecksumMode mode
static void static void status(const char *fmt,...) pg_attribute_printf(1
static Datum PointerGetDatum(const void *X)
#define FP_LOCK_SLOTS_PER_BACKEND
@ PROC_WAIT_STATUS_WAITING
PGPROC * BackendPidGetProcWithLock(int pid)
void set_ps_display_remove_suffix(void)
void set_ps_display_suffix(const char *suffix)
void ResourceOwnerRememberLock(ResourceOwner owner, LOCALLOCK *locallock)
ResourceOwner ResourceOwnerGetParent(ResourceOwner owner)
ResourceOwner CurrentResourceOwner
void ResourceOwnerForgetLock(ResourceOwner owner, LOCALLOCK *locallock)
Size add_size(Size s1, Size s2)
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
HTAB * ShmemInitHash(const char *name, long init_size, long max_size, HASHCTL *infoP, int hash_flags)
PGPROC * BackendIdGetProc(int backendID)
#define SpinLockInit(lock)
#define SpinLockRelease(lock)
#define SpinLockAcquire(lock)
void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock)
ProcWaitStatus ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable)
void LogAccessExclusiveLockPrepare(void)
void StandbyAcquireAccessExclusiveLock(TransactionId xid, Oid dbOid, Oid relOid)
void LogAccessExclusiveLock(Oid dbOid, Oid relOid)
uint32 count[FAST_PATH_STRONG_LOCK_HASH_PARTITIONS]
struct ResourceOwnerData * owner
LOCALLOCKOWNER * lockOwners
bool holdsStrongLockCount
uint8 locktag_lockmethodid
int requested[MAX_LOCKMODES]
int granted[MAX_LOCKMODES]
const LOCKMASK * conflictTab
const char *const * lockModeNames
Oid fpRelId[FP_LOCK_SLOTS_PER_BACKEND]
dlist_head lockGroupMembers
pg_atomic_uint64 waitStart
LocalTransactionId fpLocalTransactionId
dlist_head myProcLocks[NUM_LOCK_PARTITIONS]
ProcWaitStatus waitStatus
LocalTransactionId localTransactionId
#define InvalidTransactionId
#define FirstNormalObjectId
#define TransactionIdIsValid(xid)
void RegisterTwoPhaseRecord(TwoPhaseRmgrId rmid, uint16 info, const void *data, uint32 len)
TransactionId TwoPhaseGetXidByVirtualXID(VirtualTransactionId vxid, bool *have_more)
PGPROC * TwoPhaseGetDummyProc(TransactionId xid, bool lock_held)
#define TWOPHASE_RM_LOCK_ID
bool RecoveryInProgress(void)
#define XLogStandbyInfoActive()
static struct link * links