56 mul_size(max_locks_per_xact, add_size(MaxBackends, max_prepared_xacts))
113 "ShareUpdateExclusiveLock",
115 "ShareRowExclusiveLock",
117 "AccessExclusiveLock"
188 #define FAST_PATH_BITS_PER_SLOT 3
189 #define FAST_PATH_LOCKNUMBER_OFFSET 1
190 #define FAST_PATH_MASK ((1 << FAST_PATH_BITS_PER_SLOT) - 1)
191 #define FAST_PATH_GET_BITS(proc, n) \
192 (((proc)->fpLockBits >> (FAST_PATH_BITS_PER_SLOT * n)) & FAST_PATH_MASK)
193 #define FAST_PATH_BIT_POSITION(n, l) \
194 (AssertMacro((l) >= FAST_PATH_LOCKNUMBER_OFFSET), \
195 AssertMacro((l) < FAST_PATH_BITS_PER_SLOT+FAST_PATH_LOCKNUMBER_OFFSET), \
196 AssertMacro((n) < FP_LOCK_SLOTS_PER_BACKEND), \
197 ((l) - FAST_PATH_LOCKNUMBER_OFFSET + FAST_PATH_BITS_PER_SLOT * (n)))
198 #define FAST_PATH_SET_LOCKMODE(proc, n, l) \
199 (proc)->fpLockBits |= UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)
200 #define FAST_PATH_CLEAR_LOCKMODE(proc, n, l) \
201 (proc)->fpLockBits &= ~(UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l))
202 #define FAST_PATH_CHECK_LOCKMODE(proc, n, l) \
203 ((proc)->fpLockBits & (UINT64CONST(1) << FAST_PATH_BIT_POSITION(n, l)))
213 #define EligibleForRelationFastPath(locktag, mode) \
214 ((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
215 (locktag)->locktag_type == LOCKTAG_RELATION && \
216 (locktag)->locktag_field1 == MyDatabaseId && \
217 MyDatabaseId != InvalidOid && \
218 (mode) < ShareUpdateExclusiveLock)
219 #define ConflictsWithRelationFastPath(locktag, mode) \
220 ((locktag)->locktag_lockmethodid == DEFAULT_LOCKMETHOD && \
221 (locktag)->locktag_type == LOCKTAG_RELATION && \
222 (locktag)->locktag_field1 != InvalidOid && \
223 (mode) > ShareUpdateExclusiveLock)
246 #define FAST_PATH_STRONG_LOCK_HASH_BITS 10
247 #define FAST_PATH_STRONG_LOCK_HASH_PARTITIONS \
248 (1 << FAST_PATH_STRONG_LOCK_HASH_BITS)
249 #define FastPathStrongLockHashPartition(hashcode) \
250 ((hashcode) % FAST_PATH_STRONG_LOCK_HASH_PARTITIONS)
298 bool Trace_locks =
false;
299 bool Trace_userlocks =
false;
300 int Trace_lock_table = 0;
301 bool Debug_deadlocks =
false;
305 LOCK_DEBUG_ENABLED(
const LOCKTAG *tag)
310 || (Trace_lock_table &&
318 if (LOCK_DEBUG_ENABLED(&lock->
tag))
320 "%s: lock(%p) id(%u,%u,%u,%u,%u,%u) grantMask(%x) "
321 "req(%d,%d,%d,%d,%d,%d,%d)=%d "
322 "grant(%d,%d,%d,%d,%d,%d,%d)=%d wait(%d) type(%s)",
344 "%s: proclock(%p) lock(%p) method(%u) proc(%p) hold(%x)",
351 #define LOCK_PRINT(where, lock, type) ((void) 0)
352 #define PROCLOCK_PRINT(where, proclockP) ((void) 0)
374 bool decrement_strong_lock_count);
395 long init_table_size,
404 init_table_size = max_table_size / 2;
422 init_table_size *= 2;
554 uint32 lockhash = hashcode;
593 MemSet(&localtag, 0,
sizeof(localtag));
594 localtag.
lock = *locktag;
595 localtag.
mode = lockmode;
601 return (locallock && locallock->
nLocks > 0);
604 #ifdef USE_ASSERT_CHECKING
610 GetLockMethodLocalHash(
void)
630 bool hasWaiters =
false;
633 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
635 if (lockmode <= 0 || lockmode > lockMethodTable->
numLockModes)
636 elog(
ERROR,
"unrecognized lock mode: %d", lockmode);
639 if (LOCK_DEBUG_ENABLED(locktag))
640 elog(
LOG,
"LockHasWaiters: lock [%u,%u] %s",
648 MemSet(&localtag, 0,
sizeof(localtag));
649 localtag.
lock = *locktag;
650 localtag.
mode = lockmode;
659 if (!locallock || locallock->
nLocks <= 0)
678 lock = locallock->
lock;
679 LOCK_PRINT(
"LockHasWaiters: found", lock, lockmode);
762 bool reportMemoryError,
776 bool log_lock =
false;
779 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
781 if (lockmode <= 0 || lockmode > lockMethodTable->
numLockModes)
782 elog(
ERROR,
"unrecognized lock mode: %d", lockmode);
789 (
errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
790 errmsg(
"cannot acquire lock mode %s on database objects while recovery is in progress",
792 errhint(
"Only RowExclusiveLock or less can be acquired on database objects during recovery.")));
795 if (LOCK_DEBUG_ENABLED(locktag))
796 elog(
LOG,
"LockAcquire: lock [%u,%u] %s",
810 MemSet(&localtag, 0,
sizeof(localtag));
811 localtag.
lock = *locktag;
812 localtag.
mode = lockmode;
823 locallock->
lock = NULL;
852 *locallockp = locallock;
860 if (locallock->
nLocks > 0)
874 Assert(!IsRelationExtensionLockHeld);
933 locallock->
lock = NULL;
955 if (locallock->
nLocks == 0)
959 if (reportMemoryError)
961 (
errcode(ERRCODE_OUT_OF_MEMORY),
962 errmsg(
"out of shared memory"),
963 errhint(
"You might need to increase %s.",
"max_locks_per_transaction")));
993 if (locallock->
nLocks == 0)
997 if (reportMemoryError)
999 (
errcode(ERRCODE_OUT_OF_MEMORY),
1000 errmsg(
"out of shared memory"),
1001 errhint(
"You might need to increase %s.",
"max_locks_per_transaction")));
1007 locallock->
lock = lock;
1015 found_conflict =
true;
1020 if (!found_conflict)
1079 uint32 proclock_hashcode;
1090 elog(
PANIC,
"proclock table corrupted");
1096 LOCK_PRINT(
"LockAcquire: conditional lock failed",
1102 if (locallock->
nLocks == 0)
1115 LOCK_PRINT(
"LockAcquire: INCONSISTENT", lock, lockmode);
1121 LOCK_PRINT(
"LockAcquire: granted", lock, lockmode);
1167 uint32 proclock_hashcode;
1194 LOCK_PRINT(
"LockAcquire: new", lock, lockmode);
1198 LOCK_PRINT(
"LockAcquire: found", lock, lockmode);
1207 proclocktag.
myLock = lock;
1208 proclocktag.
myProc = proc;
1273 #ifdef CHECK_DEADLOCK_RISK
1296 if (
i >= (
int) lockmode)
1298 elog(
LOG,
"deadlock risk: raising lock level"
1299 " from %s to %s on object %u/%u/%u",
1325 elog(
ERROR,
"lock %s on object %u/%u/%u is already held",
1344 #ifdef USE_ASSERT_CHECKING
1346 IsRelationExtensionLockHeld = acquired;
1414 int conflictMask = lockMethodTable->
conflictTab[lockmode];
1416 int totalConflictsRemaining = 0;
1441 for (
i = 1;
i <= numLockModes;
i++)
1445 conflictsRemaining[
i] = 0;
1448 conflictsRemaining[
i] = lock->
granted[
i];
1450 --conflictsRemaining[
i];
1451 totalConflictsRemaining += conflictsRemaining[
i];
1455 if (totalConflictsRemaining == 0)
1457 PROCLOCK_PRINT(
"LockCheckConflicts: resolved (simple)", proclock);
1493 if (proclock != otherproclock &&
1495 (otherproclock->
holdMask & conflictMask) != 0)
1497 int intersectMask = otherproclock->
holdMask & conflictMask;
1499 for (
i = 1;
i <= numLockModes;
i++)
1503 if (conflictsRemaining[
i] <= 0)
1504 elog(
PANIC,
"proclocks held do not match lock");
1505 conflictsRemaining[
i]--;
1506 totalConflictsRemaining--;
1510 if (totalConflictsRemaining == 0)
1520 PROCLOCK_PRINT(
"LockCheckConflicts: conflicting (group)", proclock);
1562 bool wakeupNeeded =
false;
1576 if (lock->
granted[lockmode] == 0)
1582 LOCK_PRINT(
"UnGrantLock: updated", lock, lockmode);
1594 wakeupNeeded =
true;
1602 return wakeupNeeded;
1626 uint32 proclock_hashcode;
1637 elog(
PANIC,
"proclock table corrupted");
1646 LOCK_PRINT(
"CleanUpLock: deleting", lock, 0);
1655 else if (wakeupNeeded)
1681 if (lockOwners[
i].owner == owner)
1687 lockOwners[
i].
owner = owner;
1743 if (locallock == NULL)
1954 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
1956 if (lockmode <= 0 || lockmode > lockMethodTable->
numLockModes)
1957 elog(
ERROR,
"unrecognized lock mode: %d", lockmode);
1960 if (LOCK_DEBUG_ENABLED(locktag))
1961 elog(
LOG,
"LockRelease: lock [%u,%u] %s",
1969 MemSet(&localtag, 0,
sizeof(localtag));
1970 localtag.
lock = *locktag;
1971 localtag.
mode = lockmode;
1980 if (!locallock || locallock->
nLocks <= 0)
2003 if (lockOwners[
i].owner == owner)
2005 Assert(lockOwners[
i].nLocks > 0);
2006 if (--lockOwners[
i].nLocks == 0)
2012 if (i < locallock->numLockOwners)
2033 if (locallock->
nLocks > 0)
2081 lock = locallock->
lock;
2093 elog(
ERROR,
"failed to re-find shared lock object");
2094 locallock->
lock = lock;
2096 proclocktag.
myLock = lock;
2103 elog(
ERROR,
"failed to re-find shared proclock object");
2105 LOCK_PRINT(
"LockRelease: found", lock, lockmode);
2126 wakeupNeeded =
UnGrantLock(lock, lockmode, proclock, lockMethodTable);
2129 lockMethodTable, locallock->
hashcode,
2156 bool have_fast_path_lwlock =
false;
2159 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
2164 elog(
LOG,
"LockReleaseAll: lockmethod=%d", lockmethodid);
2195 if (locallock->
nLocks == 0)
2217 if (lockOwners[
i].owner == NULL)
2218 lockOwners[0] = lockOwners[
i];
2224 lockOwners[0].
owner == NULL &&
2225 lockOwners[0].
nLocks > 0)
2241 if (locallock->
proclock == NULL || locallock->
lock == NULL)
2248 elog(
PANIC,
"locallock table corrupted");
2258 if (!have_fast_path_lwlock)
2261 have_fast_path_lwlock =
true;
2278 have_fast_path_lwlock =
false;
2288 &locallock->
tag.
lock, lockmode,
false);
2294 if (locallock->
nLocks > 0)
2302 if (have_fast_path_lwlock)
2343 bool wakeupNeeded =
false;
2379 for (
i = 1;
i <= numLockModes;
i++)
2387 LOCK_PRINT(
"LockReleaseAll: updated", lock, 0);
2403 elog(
LOG,
"LockReleaseAll done");
2418 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
2444 if (locallocks == NULL)
2458 for (
i = nlocks - 1;
i >= 0;
i--)
2493 if (lockOwners[
i].owner == owner)
2495 Assert(lockOwners[
i].nLocks > 0);
2496 if (lockOwners[
i].nLocks < locallock->nLocks)
2507 if (i < locallock->numLockOwners)
2543 if (locallocks == NULL)
2557 for (
i = nlocks - 1;
i >= 0;
i--)
2583 else if (lockOwners[
i].owner == parent)
2593 lockOwners[ic].
owner = parent;
2602 if (ic < locallock->numLockOwners)
2653 bool result =
false;
2740 hashcode, lockmode);
2788 lockmode = locallock->
tag.
mode;
2802 (
errcode(ERRCODE_OUT_OF_MEMORY),
2803 errmsg(
"out of shared memory"),
2804 errhint(
"You might need to increase %s.",
"max_locks_per_transaction")));
2818 if (proclock == NULL)
2822 uint32 proclock_hashcode;
2832 elog(
ERROR,
"failed to re-find shared lock object");
2834 proclocktag.
myLock = lock;
2845 elog(
ERROR,
"failed to re-find shared proclock object");
2887 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
2889 if (lockmode <= 0 || lockmode > lockMethodTable->
numLockModes)
2890 elog(
ERROR,
"unrecognized lock mode: %d", lockmode);
2913 conflictMask = lockMethodTable->
conflictTab[lockmode];
2966 if (relid != proc->
fpRelId[f])
2977 if ((lockmask & conflictMask) == 0)
2984 vxids[count++] = vxid;
3029 if (conflictMask & proclock->
holdMask)
3045 for (
i = 0;
i < fast_count; ++
i)
3048 if (
i >= fast_count)
3049 vxids[count++] = vxid;
3059 elog(
PANIC,
"too many conflicting locks found");
3082 bool decrement_strong_lock_count)
3088 uint32 proclock_hashcode;
3106 elog(
PANIC,
"failed to re-find shared lock object");
3111 proclocktag.
myLock = lock;
3112 proclocktag.
myProc = proc;
3122 elog(
PANIC,
"failed to re-find shared proclock object");
3140 wakeupNeeded =
UnGrantLock(lock, lockmode, proclock, lockMethodTable);
3143 lockMethodTable, hashcode,
3151 if (decrement_strong_lock_count
3200 hash_ctl.
entrysize =
sizeof(PerLockTagEntry);
3203 lockhtab =
hash_create(
"CheckForSessionAndXactLocks table",
3214 PerLockTagEntry *hentry;
3226 if (locallock->
nLocks <= 0)
3230 hentry = (PerLockTagEntry *)
hash_search(lockhtab,
3234 hentry->sessLock = hentry->xactLock =
false;
3239 if (lockOwners[
i].owner == NULL)
3240 hentry->sessLock =
true;
3242 hentry->xactLock =
true;
3249 if (hentry->sessLock && hentry->xactLock)
3251 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3252 errmsg(
"cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3287 bool haveSessionLock;
3299 if (locallock->
nLocks <= 0)
3303 haveSessionLock = haveXactLock =
false;
3306 if (lockOwners[
i].owner == NULL)
3307 haveSessionLock =
true;
3309 haveXactLock =
true;
3317 if (haveSessionLock)
3319 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3320 errmsg(
"cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3399 bool haveSessionLock;
3403 if (locallock->
proclock == NULL || locallock->
lock == NULL)
3419 haveSessionLock = haveXactLock =
false;
3422 if (lockOwners[
i].owner == NULL)
3423 haveSessionLock =
true;
3425 haveXactLock =
true;
3433 if (haveSessionLock)
3435 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3436 errmsg(
"cannot PREPARE while holding both session-level and transaction-level locks on the same object")));
3439 if (locallock->
nLocks > 0)
3495 elog(
PANIC,
"we seem to have dropped a bit somewhere");
3515 proclocktag.
myLock = lock;
3516 proclocktag.
myProc = newproc;
3533 elog(
PANIC,
"duplicate entry found while reassigning a prepared transaction's locks");
3555 long max_table_size;
3562 max_table_size *= 2;
3640 instance = &
data->locks[el];
3647 instance->
pid = proc->
pid;
3675 instance = &
data->locks[el];
3681 instance->
pid = proc->
pid;
3710 if (
data->nelements > els)
3712 els =
data->nelements;
3734 instance->
pid = proc->
pid;
3871 if (theLock == NULL)
3875 bproc = &
data->procs[
data->nprocs++];
3876 bproc->
pid = blocked_proc->
pid;
3894 if (
data->nlocks >=
data->maxlocks)
3901 instance = &
data->locks[
data->nlocks];
3910 instance->
pid = proc->
pid;
3920 if (queue_size >
data->maxpids -
data->npids)
3923 data->npids + queue_size);
3925 sizeof(
int) *
data->maxpids);
3933 if (queued_proc == blocked_proc)
3935 data->waiter_pids[
data->npids++] = queued_proc->
pid;
4012 accessExclusiveLocks[
index].
xid = xid;
4033 return accessExclusiveLocks;
4107 elog(
LOG,
"DumpAllLocks: proclock->tag.myLock = NULL");
4155 uint32 proclock_hashcode;
4166 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
4187 (
errcode(ERRCODE_OUT_OF_MEMORY),
4188 errmsg(
"out of shared memory"),
4189 errhint(
"You might need to increase %s.",
"max_locks_per_transaction")));
4205 LOCK_PRINT(
"lock_twophase_recover: new", lock, lockmode);
4209 LOCK_PRINT(
"lock_twophase_recover: found", lock, lockmode);
4218 proclocktag.
myLock = lock;
4219 proclocktag.
myProc = proc;
4252 (
errcode(ERRCODE_OUT_OF_MEMORY),
4253 errmsg(
"out of shared memory"),
4254 errhint(
"You might need to increase %s.",
"max_locks_per_transaction")));
4290 elog(
ERROR,
"lock %s on object %u/%u/%u is already held",
4337 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
4369 elog(
ERROR,
"unrecognized lock method: %d", lockmethodid);
4602 (
errcode(ERRCODE_OUT_OF_MEMORY),
4603 errmsg(
"out of shared memory"),
4604 errhint(
"You might need to increase %s.",
"max_locks_per_transaction")));
4649 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)
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_thoroughly(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)
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)
static void WaitOnLock(LOCALLOCK *locallock, ResourceOwner owner, bool dontWait)
#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)
void lock_twophase_recover(TransactionId xid, uint16 info, void *recdata, uint32 len)
void LockReleaseSession(LOCKMETHODID lockmethodid)
void MarkLockClear(LOCALLOCK *locallock)
static bool IsRelationExtensionLockHeld PG_USED_FOR_ASSERTS_ONLY
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 GET_VXID_FROM_PGPROC(vxid_dst, proc)
#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 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 Datum PointerGetDatum(const void *X)
#define FP_LOCK_SLOTS_PER_BACKEND
@ PROC_WAIT_STATUS_WAITING
PGPROC * ProcNumberGetProc(ProcNumber procNumber)
PGPROC * BackendPidGetProcWithLock(int pid)
#define INVALID_PROC_NUMBER
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)
static pg_noinline void Size size
#define SpinLockInit(lock)
#define SpinLockRelease(lock)
#define SpinLockAcquire(lock)
ProcWaitStatus ProcSleep(LOCALLOCK *locallock, LockMethod lockMethodTable, bool dontWait)
void ProcLockWakeup(LockMethod lockMethodTable, LOCK *lock)
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]
VirtualTransactionId vxid
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