PostgreSQL Source Code git master
lwlock.c File Reference
#include "postgres.h"
#include "miscadmin.h"
#include "pg_trace.h"
#include "pgstat.h"
#include "port/pg_bitutils.h"
#include "postmaster/postmaster.h"
#include "storage/proc.h"
#include "storage/proclist.h"
#include "storage/spin.h"
#include "utils/memutils.h"
#include "storage/lwlocklist.h"
Include dependency graph for lwlock.c:

Go to the source code of this file.

Data Structures

struct  LWLockHandle
 
struct  NamedLWLockTrancheRequest
 

Macros

#define LW_FLAG_HAS_WAITERS   ((uint32) 1 << 30)
 
#define LW_FLAG_RELEASE_OK   ((uint32) 1 << 29)
 
#define LW_FLAG_LOCKED   ((uint32) 1 << 28)
 
#define LW_VAL_EXCLUSIVE   ((uint32) 1 << 24)
 
#define LW_VAL_SHARED   1
 
#define LW_LOCK_MASK   ((uint32) ((1 << 25)-1))
 
#define LW_SHARED_MASK   ((uint32) ((1 << 24)-1))
 
#define PG_LWLOCK(id, lockname)   [id] = CppAsString(lockname),
 
#define MAX_SIMUL_LWLOCKS   200
 
#define T_NAME(lock)    GetLWTrancheName((lock)->tranche)
 
#define PRINT_LWDEBUG(a, b, c)   ((void)0)
 
#define LOG_LWDEBUG(a, b, c)   ((void)0)
 

Typedefs

typedef struct LWLockHandle LWLockHandle
 
typedef struct NamedLWLockTrancheRequest NamedLWLockTrancheRequest
 

Functions

 StaticAssertDecl (LW_VAL_EXCLUSIVE >(uint32) MAX_BACKENDS, "MAX_BACKENDS too big for lwlock.c")
 
 StaticAssertDecl (lengthof(BuiltinTrancheNames)==LWTRANCHE_FIRST_USER_DEFINED, "missing entries in BuiltinTrancheNames[]")
 
static void InitializeLWLocks (void)
 
static void LWLockReportWaitStart (LWLock *lock)
 
static void LWLockReportWaitEnd (void)
 
static const char * GetLWTrancheName (uint16 trancheId)
 
static int NumLWLocksForNamedTranches (void)
 
Size LWLockShmemSize (void)
 
void CreateLWLocks (void)
 
void InitLWLockAccess (void)
 
LWLockPaddedGetNamedLWLockTranche (const char *tranche_name)
 
int LWLockNewTrancheId (void)
 
void LWLockRegisterTranche (int tranche_id, const char *tranche_name)
 
void RequestNamedLWLockTranche (const char *tranche_name, int num_lwlocks)
 
void LWLockInitialize (LWLock *lock, int tranche_id)
 
const char * GetLWLockIdentifier (uint32 classId, uint16 eventId)
 
static bool LWLockAttemptLock (LWLock *lock, LWLockMode mode)
 
static void LWLockWaitListLock (LWLock *lock)
 
static void LWLockWaitListUnlock (LWLock *lock)
 
static void LWLockWakeup (LWLock *lock)
 
static void LWLockQueueSelf (LWLock *lock, LWLockMode mode)
 
static void LWLockDequeueSelf (LWLock *lock)
 
bool LWLockAcquire (LWLock *lock, LWLockMode mode)
 
bool LWLockConditionalAcquire (LWLock *lock, LWLockMode mode)
 
bool LWLockAcquireOrWait (LWLock *lock, LWLockMode mode)
 
static bool LWLockConflictsWithVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval, bool *result)
 
bool LWLockWaitForVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval)
 
void LWLockUpdateVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
 
void LWLockRelease (LWLock *lock)
 
void LWLockReleaseClearVar (LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
 
void LWLockReleaseAll (void)
 
bool LWLockHeldByMe (LWLock *lock)
 
bool LWLockAnyHeldByMe (LWLock *lock, int nlocks, size_t stride)
 
bool LWLockHeldByMeInMode (LWLock *lock, LWLockMode mode)
 

Variables

static const char *const BuiltinTrancheNames []
 
static const char ** LWLockTrancheNames = NULL
 
static int LWLockTrancheNamesAllocated = 0
 
LWLockPaddedMainLWLockArray = NULL
 
static int num_held_lwlocks = 0
 
static LWLockHandle held_lwlocks [MAX_SIMUL_LWLOCKS]
 
static NamedLWLockTrancheRequestNamedLWLockTrancheRequestArray = NULL
 
static int NamedLWLockTrancheRequestsAllocated = 0
 
int NamedLWLockTrancheRequests = 0
 
NamedLWLockTrancheNamedLWLockTrancheArray = NULL
 

Macro Definition Documentation

◆ LOG_LWDEBUG

#define LOG_LWDEBUG (   a,
  b,
  c 
)    ((void)0)

Definition at line 299 of file lwlock.c.

◆ LW_FLAG_HAS_WAITERS

#define LW_FLAG_HAS_WAITERS   ((uint32) 1 << 30)

Definition at line 94 of file lwlock.c.

◆ LW_FLAG_LOCKED

#define LW_FLAG_LOCKED   ((uint32) 1 << 28)

Definition at line 96 of file lwlock.c.

◆ LW_FLAG_RELEASE_OK

#define LW_FLAG_RELEASE_OK   ((uint32) 1 << 29)

Definition at line 95 of file lwlock.c.

◆ LW_LOCK_MASK

#define LW_LOCK_MASK   ((uint32) ((1 << 25)-1))

Definition at line 101 of file lwlock.c.

◆ LW_SHARED_MASK

#define LW_SHARED_MASK   ((uint32) ((1 << 24)-1))

Definition at line 103 of file lwlock.c.

◆ LW_VAL_EXCLUSIVE

#define LW_VAL_EXCLUSIVE   ((uint32) 1 << 24)

Definition at line 98 of file lwlock.c.

◆ LW_VAL_SHARED

#define LW_VAL_SHARED   1

Definition at line 99 of file lwlock.c.

◆ MAX_SIMUL_LWLOCKS

#define MAX_SIMUL_LWLOCKS   200

Definition at line 196 of file lwlock.c.

◆ PG_LWLOCK

#define PG_LWLOCK (   id,
  lockname 
)    [id] = CppAsString(lockname),

◆ PRINT_LWDEBUG

#define PRINT_LWDEBUG (   a,
  b,
  c 
)    ((void)0)

Definition at line 298 of file lwlock.c.

◆ T_NAME

#define T_NAME (   lock)     GetLWTrancheName((lock)->tranche)

Definition at line 234 of file lwlock.c.

Typedef Documentation

◆ LWLockHandle

typedef struct LWLockHandle LWLockHandle

◆ NamedLWLockTrancheRequest

Function Documentation

◆ CreateLWLocks()

void CreateLWLocks ( void  )

Definition at line 450 of file lwlock.c.

451{
453 {
454 Size spaceLocks = LWLockShmemSize();
455 int *LWLockCounter;
456 char *ptr;
457
458 /* Allocate space */
459 ptr = (char *) ShmemAlloc(spaceLocks);
460
461 /* Leave room for dynamic allocation of tranches */
462 ptr += sizeof(int);
463
464 /* Ensure desired alignment of LWLock array */
465 ptr += LWLOCK_PADDED_SIZE - ((uintptr_t) ptr) % LWLOCK_PADDED_SIZE;
466
468
469 /*
470 * Initialize the dynamic-allocation counter for tranches, which is
471 * stored just before the first LWLock.
472 */
473 LWLockCounter = (int *) ((char *) MainLWLockArray - sizeof(int));
474 *LWLockCounter = LWTRANCHE_FIRST_USER_DEFINED;
475
476 /* Initialize all LWLocks */
478 }
479
480 /* Register named extension LWLock tranches in the current process. */
481 for (int i = 0; i < NamedLWLockTrancheRequests; i++)
483 NamedLWLockTrancheArray[i].trancheName);
484}
size_t Size
Definition: c.h:562
bool IsUnderPostmaster
Definition: globals.c:119
int i
Definition: isn.c:72
NamedLWLockTranche * NamedLWLockTrancheArray
Definition: lwlock.c:227
void LWLockRegisterTranche(int tranche_id, const char *tranche_name)
Definition: lwlock.c:628
int NamedLWLockTrancheRequests
Definition: lwlock.c:224
static void InitializeLWLocks(void)
Definition: lwlock.c:490
LWLockPadded * MainLWLockArray
Definition: lwlock.c:188
Size LWLockShmemSize(void)
Definition: lwlock.c:420
#define LWLOCK_PADDED_SIZE
Definition: lwlock.h:62
@ LWTRANCHE_FIRST_USER_DEFINED
Definition: lwlock.h:218
void * ShmemAlloc(Size size)
Definition: shmem.c:147

References i, InitializeLWLocks(), IsUnderPostmaster, LWLOCK_PADDED_SIZE, LWLockRegisterTranche(), LWLockShmemSize(), LWTRANCHE_FIRST_USER_DEFINED, MainLWLockArray, NamedLWLockTrancheArray, NamedLWLockTrancheRequests, and ShmemAlloc().

Referenced by CreateOrAttachShmemStructs().

◆ GetLWLockIdentifier()

const char * GetLWLockIdentifier ( uint32  classId,
uint16  eventId 
)

Definition at line 767 of file lwlock.c.

768{
769 Assert(classId == PG_WAIT_LWLOCK);
770 /* The event IDs are just tranche numbers. */
771 return GetLWTrancheName(eventId);
772}
#define Assert(condition)
Definition: c.h:815
static const char * GetLWTrancheName(uint16 trancheId)
Definition: lwlock.c:743
#define PG_WAIT_LWLOCK
Definition: wait_event.h:18

References Assert, GetLWTrancheName(), and PG_WAIT_LWLOCK.

Referenced by pgstat_get_wait_event().

◆ GetLWTrancheName()

static const char * GetLWTrancheName ( uint16  trancheId)
static

Definition at line 743 of file lwlock.c.

744{
745 /* Built-in tranche or individual LWLock? */
746 if (trancheId < LWTRANCHE_FIRST_USER_DEFINED)
747 return BuiltinTrancheNames[trancheId];
748
749 /*
750 * It's an extension tranche, so look in LWLockTrancheNames[]. However,
751 * it's possible that the tranche has never been registered in the current
752 * process, in which case give up and return "extension".
753 */
754 trancheId -= LWTRANCHE_FIRST_USER_DEFINED;
755
756 if (trancheId >= LWLockTrancheNamesAllocated ||
757 LWLockTrancheNames[trancheId] == NULL)
758 return "extension";
759
760 return LWLockTrancheNames[trancheId];
761}
static int LWLockTrancheNamesAllocated
Definition: lwlock.c:181
static const char *const BuiltinTrancheNames[]
Definition: lwlock.c:126
static const char ** LWLockTrancheNames
Definition: lwlock.c:180

References BuiltinTrancheNames, LWLockTrancheNames, LWLockTrancheNamesAllocated, and LWTRANCHE_FIRST_USER_DEFINED.

Referenced by GetLWLockIdentifier().

◆ GetNamedLWLockTranche()

LWLockPadded * GetNamedLWLockTranche ( const char *  tranche_name)

Definition at line 573 of file lwlock.c.

574{
575 int lock_pos;
576 int i;
577
578 /*
579 * Obtain the position of base address of LWLock belonging to requested
580 * tranche_name in MainLWLockArray. LWLocks for named tranches are placed
581 * in MainLWLockArray after fixed locks.
582 */
583 lock_pos = NUM_FIXED_LWLOCKS;
584 for (i = 0; i < NamedLWLockTrancheRequests; i++)
585 {
586 if (strcmp(NamedLWLockTrancheRequestArray[i].tranche_name,
587 tranche_name) == 0)
588 return &MainLWLockArray[lock_pos];
589
591 }
592
593 elog(ERROR, "requested tranche is not registered");
594
595 /* just to keep compiler quiet */
596 return NULL;
597}
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
static NamedLWLockTrancheRequest * NamedLWLockTrancheRequestArray
Definition: lwlock.c:215
#define NUM_FIXED_LWLOCKS
Definition: lwlock.h:109

References elog, ERROR, i, MainLWLockArray, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NUM_FIXED_LWLOCKS, and NamedLWLockTrancheRequest::num_lwlocks.

Referenced by pgss_shmem_startup().

◆ InitializeLWLocks()

static void InitializeLWLocks ( void  )
static

Definition at line 490 of file lwlock.c.

491{
492 int numNamedLocks = NumLWLocksForNamedTranches();
493 int id;
494 int i;
495 int j;
496 LWLockPadded *lock;
497
498 /* Initialize all individual LWLocks in main array */
499 for (id = 0, lock = MainLWLockArray; id < NUM_INDIVIDUAL_LWLOCKS; id++, lock++)
500 LWLockInitialize(&lock->lock, id);
501
502 /* Initialize buffer mapping LWLocks in main array */
504 for (id = 0; id < NUM_BUFFER_PARTITIONS; id++, lock++)
506
507 /* Initialize lmgrs' LWLocks in main array */
509 for (id = 0; id < NUM_LOCK_PARTITIONS; id++, lock++)
511
512 /* Initialize predicate lmgrs' LWLocks in main array */
514 for (id = 0; id < NUM_PREDICATELOCK_PARTITIONS; id++, lock++)
516
517 /*
518 * Copy the info about any named tranches into shared memory (so that
519 * other processes can see it), and initialize the requested LWLocks.
520 */
522 {
523 char *trancheNames;
524
526 &MainLWLockArray[NUM_FIXED_LWLOCKS + numNamedLocks];
527
528 trancheNames = (char *) NamedLWLockTrancheArray +
531
532 for (i = 0; i < NamedLWLockTrancheRequests; i++)
533 {
535 NamedLWLockTranche *tranche;
536 char *name;
537
539 tranche = &NamedLWLockTrancheArray[i];
540
541 name = trancheNames;
542 trancheNames += strlen(request->tranche_name) + 1;
543 strcpy(name, request->tranche_name);
544 tranche->trancheId = LWLockNewTrancheId();
545 tranche->trancheName = name;
546
547 for (j = 0; j < request->num_lwlocks; j++, lock++)
548 LWLockInitialize(&lock->lock, tranche->trancheId);
549 }
550 }
551}
int j
Definition: isn.c:73
int LWLockNewTrancheId(void)
Definition: lwlock.c:603
static int NumLWLocksForNamedTranches(void)
Definition: lwlock.c:405
void LWLockInitialize(LWLock *lock, int tranche_id)
Definition: lwlock.c:707
#define BUFFER_MAPPING_LWLOCK_OFFSET
Definition: lwlock.h:104
#define NUM_LOCK_PARTITIONS
Definition: lwlock.h:97
@ LWTRANCHE_PREDICATE_LOCK_MANAGER
Definition: lwlock.h:193
@ LWTRANCHE_BUFFER_MAPPING
Definition: lwlock.h:191
@ LWTRANCHE_LOCK_MANAGER
Definition: lwlock.h:192
#define LOCK_MANAGER_LWLOCK_OFFSET
Definition: lwlock.h:105
#define NUM_BUFFER_PARTITIONS
Definition: lwlock.h:93
#define PREDICATELOCK_MANAGER_LWLOCK_OFFSET
Definition: lwlock.h:107
#define NUM_PREDICATELOCK_PARTITIONS
Definition: lwlock.h:101
char tranche_name[NAMEDATALEN]
Definition: lwlock.c:211
char * trancheName
Definition: lwlock.h:80
LWLock lock
Definition: lwlock.h:70
const char * name

References BUFFER_MAPPING_LWLOCK_OFFSET, i, j, LWLockPadded::lock, LOCK_MANAGER_LWLOCK_OFFSET, LWLockInitialize(), LWLockNewTrancheId(), LWTRANCHE_BUFFER_MAPPING, LWTRANCHE_LOCK_MANAGER, LWTRANCHE_PREDICATE_LOCK_MANAGER, MainLWLockArray, name, NamedLWLockTrancheArray, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NUM_BUFFER_PARTITIONS, NUM_FIXED_LWLOCKS, NUM_LOCK_PARTITIONS, NamedLWLockTrancheRequest::num_lwlocks, NUM_PREDICATELOCK_PARTITIONS, NumLWLocksForNamedTranches(), PREDICATELOCK_MANAGER_LWLOCK_OFFSET, NamedLWLockTrancheRequest::tranche_name, NamedLWLockTranche::trancheId, and NamedLWLockTranche::trancheName.

Referenced by CreateLWLocks().

◆ InitLWLockAccess()

void InitLWLockAccess ( void  )

Definition at line 557 of file lwlock.c.

558{
559#ifdef LWLOCK_STATS
560 init_lwlock_stats();
561#endif
562}

Referenced by InitAuxiliaryProcess(), and InitProcess().

◆ LWLockAcquire()

bool LWLockAcquire ( LWLock lock,
LWLockMode  mode 
)

Definition at line 1168 of file lwlock.c.

1169{
1170 PGPROC *proc = MyProc;
1171 bool result = true;
1172 int extraWaits = 0;
1173#ifdef LWLOCK_STATS
1174 lwlock_stats *lwstats;
1175
1176 lwstats = get_lwlock_stats_entry(lock);
1177#endif
1178
1180
1181 PRINT_LWDEBUG("LWLockAcquire", lock, mode);
1182
1183#ifdef LWLOCK_STATS
1184 /* Count lock acquisition attempts */
1185 if (mode == LW_EXCLUSIVE)
1186 lwstats->ex_acquire_count++;
1187 else
1188 lwstats->sh_acquire_count++;
1189#endif /* LWLOCK_STATS */
1190
1191 /*
1192 * We can't wait if we haven't got a PGPROC. This should only occur
1193 * during bootstrap or shared memory initialization. Put an Assert here
1194 * to catch unsafe coding practices.
1195 */
1196 Assert(!(proc == NULL && IsUnderPostmaster));
1197
1198 /* Ensure we will have room to remember the lock */
1200 elog(ERROR, "too many LWLocks taken");
1201
1202 /*
1203 * Lock out cancel/die interrupts until we exit the code section protected
1204 * by the LWLock. This ensures that interrupts will not interfere with
1205 * manipulations of data structures in shared memory.
1206 */
1208
1209 /*
1210 * Loop here to try to acquire lock after each time we are signaled by
1211 * LWLockRelease.
1212 *
1213 * NOTE: it might seem better to have LWLockRelease actually grant us the
1214 * lock, rather than retrying and possibly having to go back to sleep. But
1215 * in practice that is no good because it means a process swap for every
1216 * lock acquisition when two or more processes are contending for the same
1217 * lock. Since LWLocks are normally used to protect not-very-long
1218 * sections of computation, a process needs to be able to acquire and
1219 * release the same lock many times during a single CPU time slice, even
1220 * in the presence of contention. The efficiency of being able to do that
1221 * outweighs the inefficiency of sometimes wasting a process dispatch
1222 * cycle because the lock is not free when a released waiter finally gets
1223 * to run. See pgsql-hackers archives for 29-Dec-01.
1224 */
1225 for (;;)
1226 {
1227 bool mustwait;
1228
1229 /*
1230 * Try to grab the lock the first time, we're not in the waitqueue
1231 * yet/anymore.
1232 */
1233 mustwait = LWLockAttemptLock(lock, mode);
1234
1235 if (!mustwait)
1236 {
1237 LOG_LWDEBUG("LWLockAcquire", lock, "immediately acquired lock");
1238 break; /* got the lock */
1239 }
1240
1241 /*
1242 * Ok, at this point we couldn't grab the lock on the first try. We
1243 * cannot simply queue ourselves to the end of the list and wait to be
1244 * woken up because by now the lock could long have been released.
1245 * Instead add us to the queue and try to grab the lock again. If we
1246 * succeed we need to revert the queuing and be happy, otherwise we
1247 * recheck the lock. If we still couldn't grab it, we know that the
1248 * other locker will see our queue entries when releasing since they
1249 * existed before we checked for the lock.
1250 */
1251
1252 /* add to the queue */
1253 LWLockQueueSelf(lock, mode);
1254
1255 /* we're now guaranteed to be woken up if necessary */
1256 mustwait = LWLockAttemptLock(lock, mode);
1257
1258 /* ok, grabbed the lock the second time round, need to undo queueing */
1259 if (!mustwait)
1260 {
1261 LOG_LWDEBUG("LWLockAcquire", lock, "acquired, undoing queue");
1262
1263 LWLockDequeueSelf(lock);
1264 break;
1265 }
1266
1267 /*
1268 * Wait until awakened.
1269 *
1270 * It is possible that we get awakened for a reason other than being
1271 * signaled by LWLockRelease. If so, loop back and wait again. Once
1272 * we've gotten the LWLock, re-increment the sema by the number of
1273 * additional signals received.
1274 */
1275 LOG_LWDEBUG("LWLockAcquire", lock, "waiting");
1276
1277#ifdef LWLOCK_STATS
1278 lwstats->block_count++;
1279#endif
1280
1282 if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
1283 TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), mode);
1284
1285 for (;;)
1286 {
1287 PGSemaphoreLock(proc->sem);
1288 if (proc->lwWaiting == LW_WS_NOT_WAITING)
1289 break;
1290 extraWaits++;
1291 }
1292
1293 /* Retrying, allow LWLockRelease to release waiters again. */
1295
1296#ifdef LOCK_DEBUG
1297 {
1298 /* not waiting anymore */
1299 uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
1300
1301 Assert(nwaiters < MAX_BACKENDS);
1302 }
1303#endif
1304
1305 if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
1306 TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), mode);
1308
1309 LOG_LWDEBUG("LWLockAcquire", lock, "awakened");
1310
1311 /* Now loop back and try to acquire lock again. */
1312 result = false;
1313 }
1314
1315 if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_ENABLED())
1316 TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(lock), mode);
1317
1318 /* Add lock to list of locks held by this backend */
1321
1322 /*
1323 * Fix the process wait semaphore's count for any absorbed wakeups.
1324 */
1325 while (extraWaits-- > 0)
1326 PGSemaphoreUnlock(proc->sem);
1327
1328 return result;
1329}
static uint32 pg_atomic_fetch_or_u32(volatile pg_atomic_uint32 *ptr, uint32 or_)
Definition: atomics.h:410
static uint32 pg_atomic_fetch_sub_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:381
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:204
uint32_t uint32
Definition: c.h:488
static LWLockHandle held_lwlocks[MAX_SIMUL_LWLOCKS]
Definition: lwlock.c:206
static bool LWLockAttemptLock(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:784
static void LWLockReportWaitEnd(void)
Definition: lwlock.c:734
#define LW_FLAG_RELEASE_OK
Definition: lwlock.c:95
#define MAX_SIMUL_LWLOCKS
Definition: lwlock.c:196
#define T_NAME(lock)
Definition: lwlock.c:234
static int num_held_lwlocks
Definition: lwlock.c:205
#define LOG_LWDEBUG(a, b, c)
Definition: lwlock.c:299
static void LWLockQueueSelf(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1036
#define PRINT_LWDEBUG(a, b, c)
Definition: lwlock.c:298
static void LWLockReportWaitStart(LWLock *lock)
Definition: lwlock.c:725
static void LWLockDequeueSelf(LWLock *lock)
Definition: lwlock.c:1079
@ LW_WS_NOT_WAITING
Definition: lwlock.h:30
@ LW_SHARED
Definition: lwlock.h:115
@ LW_EXCLUSIVE
Definition: lwlock.h:114
#define HOLD_INTERRUPTS()
Definition: miscadmin.h:133
static PgChecksumMode mode
Definition: pg_checksums.c:55
void PGSemaphoreUnlock(PGSemaphore sema)
Definition: posix_sema.c:339
void PGSemaphoreLock(PGSemaphore sema)
Definition: posix_sema.c:319
#define MAX_BACKENDS
Definition: postmaster.h:138
PGPROC * MyProc
Definition: proc.c:66
LWLockMode mode
Definition: lwlock.c:202
LWLock * lock
Definition: lwlock.c:201
pg_atomic_uint32 state
Definition: lwlock.h:44
Definition: proc.h:162
PGSemaphore sem
Definition: proc.h:166
uint8 lwWaiting
Definition: proc.h:223

References Assert, elog, ERROR, held_lwlocks, HOLD_INTERRUPTS, IsUnderPostmaster, LWLockHandle::lock, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_RELEASE_OK, LW_SHARED, LW_WS_NOT_WAITING, LWLockAttemptLock(), LWLockDequeueSelf(), LWLockQueueSelf(), LWLockReportWaitEnd(), LWLockReportWaitStart(), PGPROC::lwWaiting, MAX_BACKENDS, MAX_SIMUL_LWLOCKS, LWLockHandle::mode, mode, MyProc, num_held_lwlocks, pg_atomic_fetch_or_u32(), pg_atomic_fetch_sub_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), PRINT_LWDEBUG, PGPROC::sem, LWLock::state, and T_NAME.

Referenced by _bt_end_vacuum(), _bt_start_vacuum(), _bt_vacuum_cycleid(), AbsorbSyncRequests(), ActivateCommitTs(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AdvanceXLInsertBuffer(), alloc_object(), AlterSystemSetConfigFile(), ApplyLauncherMain(), apw_detach_shmem(), apw_dump_now(), apw_load_buffers(), asyncQueueAddEntries(), asyncQueueAdvanceTail(), asyncQueueReadAllNotifications(), asyncQueueUnregister(), AtAbort_Twophase(), AtEOXact_LogicalRepWorkers(), AtPrepare_PredicateLocks(), attach_internal(), autoprewarm_main(), autoprewarm_start_worker(), AutoVacuumRequestWork(), AutoVacWorkerMain(), BackendPidGetProc(), BackendXidGetPid(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BootStrapCLOG(), BootStrapMultiXact(), BootStrapSUBTRANS(), BufferAlloc(), CancelDBBackends(), check_for_freed_segments(), CheckDeadLock(), CheckForSerializableConflictOut(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointTwoPhase(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), CleanupInvalidationState(), ClearOldPredicateLocks(), clog_redo(), commit_ts_redo(), ComputeXidHorizons(), consume_xids_shortcut(), copy_replication_slot(), CountDBBackends(), CountDBConnections(), CountOtherDBBackends(), CountUserBackends(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateInitDecodingContext(), CreatePredicateLock(), CreateRestartPoint(), DeactivateCommitTs(), DeleteChildTargetLocks(), DeleteLockTarget(), destroy_superblock(), do_autovacuum(), do_pg_backup_start(), do_pg_backup_stop(), do_start_worker(), DropAllPredicateLocksFromTable(), DropTableSpace(), dsa_allocate_extended(), dsa_dump(), dsa_free(), dsa_get_total_size(), dsa_pin(), dsa_release_in_place(), dsa_set_size_limit(), dsa_trim(), dsa_unpin(), dshash_delete_key(), dshash_dump(), dshash_find(), dshash_find_or_insert(), dshash_seq_next(), dsm_attach(), dsm_create(), dsm_detach(), dsm_pin_segment(), dsm_unpin_segment(), ensure_active_superblock(), entry_reset(), EvictUnpinnedBuffer(), Exec_ListenPreCommit(), ExecParallelHashMergeCounters(), ExecParallelHashPopChunkQueue(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ExtendBufferedRelShared(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), FindAndDropRelationBuffers(), FinishPreparedTransaction(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), ForceTransactionIdLimitUpdate(), ForwardSyncRequest(), FreeWorkerInfo(), get_local_synced_slots(), get_val_in_shmem(), get_xid_status(), GetBackgroundWorkerPid(), GetBackgroundWorkerTypeByPid(), GetBlockerStatusData(), GetConflictingVirtualXIDs(), GetCurrentVirtualXIDs(), GetLastImportantRecPtr(), GetLastSegSwitchData(), GetLatestCommitTsData(), GetLeaderApplyWorkerPid(), GetLockConflicts(), GetLockStatusData(), GetMultiXactIdMembers(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestMultiXactId(), GetOldestRestartPoint(), GetOldestSafeDecodingTransactionId(), GetOldestUnsummarizedLSN(), GetPredicateLockStatusData(), GetPreparedTransactionList(), GetRunningTransactionData(), GetRunningTransactionLocks(), GetSafeSnapshot(), GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetStrictOldestNonRemovableTransactionId(), GetVirtualXIDsDelayingChkpt(), GetWaitEventCustomIdentifier(), GetWaitEventCustomNames(), GetWalSummarizerState(), HaveVirtualXIDsDelayingChkpt(), init_dsm_registry(), injection_shmem_startup(), injection_stats_fixed_reset_all_cb(), injection_stats_fixed_snapshot_cb(), InjectionPointAttach(), InjectionPointDetach(), InstallXLogFileSegment(), InvalidateBuffer(), InvalidateObsoleteReplicationSlots(), InvalidatePossiblyObsoleteSlot(), InvalidateVictimBuffer(), IsInstallXLogFileSegmentActive(), KnownAssignedXidsCompress(), KnownAssignedXidsReset(), lock_twophase_recover(), LockAcquireExtended(), LockBuffer(), LockErrorCleanup(), LockGXact(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), LockWaiterCount(), logicalrep_launcher_attach_dshmem(), logicalrep_pa_worker_stop(), logicalrep_worker_attach(), logicalrep_worker_detach(), logicalrep_worker_launch(), logicalrep_worker_stop(), logicalrep_worker_stop_internal(), logicalrep_worker_wakeup(), logicalrep_workers_find(), LookupGXact(), LookupGXactBySubid(), MarkAsPrepared(), MarkAsPreparing(), MaybeExtendOffsetSlru(), multixact_redo(), MultiXactAdvanceNextMXact(), MultiXactGetCheckptMulti(), MultiXactIdSetOldestMember(), MultiXactIdSetOldestVisible(), MultiXactSetNextMXact(), PageIsPredicateLocked(), perform_relmap_update(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_get_replication_slots(), pg_get_shmem_allocations(), pg_notification_queue_usage(), pg_show_replication_origin_status(), pg_stat_get_subscription(), pg_stat_statements_internal(), pg_xact_status(), pgss_shmem_startup(), pgss_store(), pgstat_archiver_reset_all_cb(), pgstat_archiver_snapshot_cb(), pgstat_bgwriter_reset_all_cb(), pgstat_bgwriter_snapshot_cb(), pgstat_build_snapshot(), pgstat_checkpointer_reset_all_cb(), pgstat_checkpointer_snapshot_cb(), pgstat_fetch_replslot(), pgstat_io_flush_cb(), pgstat_io_reset_all_cb(), pgstat_io_snapshot_cb(), pgstat_lock_entry(), pgstat_lock_entry_shared(), pgstat_reset_matching_entries(), pgstat_reset_replslot(), pgstat_reset_slru_counter_internal(), pgstat_slru_flush_cb(), pgstat_slru_snapshot_cb(), pgstat_wal_flush_cb(), pgstat_wal_reset_all_cb(), pgstat_wal_snapshot_cb(), PostPrepare_Locks(), PostPrepare_MultiXact(), PostPrepare_Twophase(), PreCommit_CheckForSerializationFailure(), PreCommit_Notify(), predicatelock_twophase_recover(), PredicateLockPageSplit(), PredicateLockTwoPhaseFinish(), PrefetchSharedBuffer(), PrescanPreparedTransactions(), ProcArrayAdd(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcArrayClearTransaction(), ProcArrayEndTransaction(), ProcArrayGetReplicationSlotXmin(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcArrayRemove(), ProcArraySetReplicationSlotXmin(), process_syncing_tables_for_apply(), ProcKill(), ProcNumberGetTransactionIds(), ProcSleep(), ReachedEndOfBackup(), read_relmap_file(), ReadMultiXactCounts(), ReadMultiXactIdRange(), ReadNextFullTransactionId(), ReadNextMultiXactId(), ReadReplicationSlot(), RecordNewMultiXact(), RecoverPreparedTransactions(), RegisterDynamicBackgroundWorker(), RegisterPredicateLockingXid(), RelationCacheInitFilePreInvalidate(), RelationMapCopy(), RelationMapFinishBootstrap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), relmap_redo(), RemoveScratchTarget(), ReplicationOriginExitCleanup(), ReplicationSlotAcquire(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotName(), ReplicationSlotRelease(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), replorigin_advance(), replorigin_get_progress(), replorigin_session_advance(), replorigin_session_get_progress(), replorigin_session_reset(), replorigin_session_setup(), replorigin_state_clear(), resize(), RestoreScratchTarget(), restoreTwoPhaseData(), SaveSlotToPath(), SearchNamedReplicationSlot(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialInit(), SerialSetActiveSerXmin(), set_indexsafe_procflags(), set_val_in_shmem(), SetCommitTsLimit(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetNextObjectId(), SetOffsetVacuumLimit(), SetTransactionIdLimit(), SetXidCommitTsInPage(), SharedInvalBackendInit(), ShmemInitStruct(), SICleanupQueue(), SIGetDataEntries(), SignalBackends(), SignalVirtualTransaction(), SIInsertDataEntries(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruTruncate(), SimpleLruWaitIO(), SimpleLruWriteAll(), SlruDeleteSegment(), SlruInternalWritePage(), SnapBuildInitialSnapshot(), ss_get_location(), StandbyRecoverPreparedTransactions(), StandbySlotsHaveCaughtup(), StartupDecodingContext(), StartupSUBTRANS(), StartupXLOG(), sts_parallel_scan_next(), SubTransSetParent(), SummarizeOldestCommittedSxact(), SummarizeWAL(), SwitchIntoArchiveRecovery(), synchronize_one_slot(), SyncOneBuffer(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepReleaseWaiters(), SyncRepUpdateSyncStandbysDefined(), SyncRepWaitForLSN(), TablespaceCreateDbspace(), tbm_shared_iterate(), TerminateBackgroundWorker(), TerminateOtherDBBackends(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_write(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdIsActive(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TransactionTreeSetCommitTsData(), TransferPredicateLocksToNewTarget(), TrimCLOG(), TrimMultiXact(), TruncateMultiXact(), TwoPhaseGetGXact(), TwoPhaseGetXidByVirtualXID(), update_cached_xid_range(), update_synced_slots_inactive_since(), UpdateMinRecoveryPoint(), vac_truncate_clog(), vacuum_rel(), VacuumUpdateCosts(), validate_sync_standby_slots(), VirtualXactLock(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), wait_for_relation_state_change(), wait_for_worker_state_change(), WaitEventCustomNew(), WaitForReplicationWorkerAttach(), WaitForWalSummarization(), WakeupWalSummarizer(), WALInsertLockAcquire(), WALInsertLockAcquireExclusive(), WalSummarizerMain(), WalSummarizerShutdown(), write_relcache_init_file(), xact_redo(), XidCacheRemoveRunningXids(), xlog_redo(), XLogBackgroundFlush(), XLogReportParameters(), XLogShutdownWalRcv(), and ZeroAndLockBuffer().

◆ LWLockAcquireOrWait()

bool LWLockAcquireOrWait ( LWLock lock,
LWLockMode  mode 
)

Definition at line 1396 of file lwlock.c.

1397{
1398 PGPROC *proc = MyProc;
1399 bool mustwait;
1400 int extraWaits = 0;
1401#ifdef LWLOCK_STATS
1402 lwlock_stats *lwstats;
1403
1404 lwstats = get_lwlock_stats_entry(lock);
1405#endif
1406
1408
1409 PRINT_LWDEBUG("LWLockAcquireOrWait", lock, mode);
1410
1411 /* Ensure we will have room to remember the lock */
1413 elog(ERROR, "too many LWLocks taken");
1414
1415 /*
1416 * Lock out cancel/die interrupts until we exit the code section protected
1417 * by the LWLock. This ensures that interrupts will not interfere with
1418 * manipulations of data structures in shared memory.
1419 */
1421
1422 /*
1423 * NB: We're using nearly the same twice-in-a-row lock acquisition
1424 * protocol as LWLockAcquire(). Check its comments for details.
1425 */
1426 mustwait = LWLockAttemptLock(lock, mode);
1427
1428 if (mustwait)
1429 {
1431
1432 mustwait = LWLockAttemptLock(lock, mode);
1433
1434 if (mustwait)
1435 {
1436 /*
1437 * Wait until awakened. Like in LWLockAcquire, be prepared for
1438 * bogus wakeups.
1439 */
1440 LOG_LWDEBUG("LWLockAcquireOrWait", lock, "waiting");
1441
1442#ifdef LWLOCK_STATS
1443 lwstats->block_count++;
1444#endif
1445
1447 if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
1448 TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), mode);
1449
1450 for (;;)
1451 {
1452 PGSemaphoreLock(proc->sem);
1453 if (proc->lwWaiting == LW_WS_NOT_WAITING)
1454 break;
1455 extraWaits++;
1456 }
1457
1458#ifdef LOCK_DEBUG
1459 {
1460 /* not waiting anymore */
1461 uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
1462
1463 Assert(nwaiters < MAX_BACKENDS);
1464 }
1465#endif
1466 if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
1467 TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), mode);
1469
1470 LOG_LWDEBUG("LWLockAcquireOrWait", lock, "awakened");
1471 }
1472 else
1473 {
1474 LOG_LWDEBUG("LWLockAcquireOrWait", lock, "acquired, undoing queue");
1475
1476 /*
1477 * Got lock in the second attempt, undo queueing. We need to treat
1478 * this as having successfully acquired the lock, otherwise we'd
1479 * not necessarily wake up people we've prevented from acquiring
1480 * the lock.
1481 */
1482 LWLockDequeueSelf(lock);
1483 }
1484 }
1485
1486 /*
1487 * Fix the process wait semaphore's count for any absorbed wakeups.
1488 */
1489 while (extraWaits-- > 0)
1490 PGSemaphoreUnlock(proc->sem);
1491
1492 if (mustwait)
1493 {
1494 /* Failed to get lock, so release interrupt holdoff */
1496 LOG_LWDEBUG("LWLockAcquireOrWait", lock, "failed");
1497 if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL_ENABLED())
1498 TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL(T_NAME(lock), mode);
1499 }
1500 else
1501 {
1502 LOG_LWDEBUG("LWLockAcquireOrWait", lock, "succeeded");
1503 /* Add lock to list of locks held by this backend */
1506 if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_ENABLED())
1507 TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT(T_NAME(lock), mode);
1508 }
1509
1510 return !mustwait;
1511}
@ LW_WAIT_UNTIL_FREE
Definition: lwlock.h:116
#define RESUME_INTERRUPTS()
Definition: miscadmin.h:135

References Assert, elog, ERROR, held_lwlocks, HOLD_INTERRUPTS, LWLockHandle::lock, LOG_LWDEBUG, LW_EXCLUSIVE, LW_SHARED, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LWLockAttemptLock(), LWLockDequeueSelf(), LWLockQueueSelf(), LWLockReportWaitEnd(), LWLockReportWaitStart(), PGPROC::lwWaiting, MAX_BACKENDS, MAX_SIMUL_LWLOCKS, LWLockHandle::mode, mode, MyProc, num_held_lwlocks, pg_atomic_fetch_sub_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), PRINT_LWDEBUG, RESUME_INTERRUPTS, PGPROC::sem, and T_NAME.

Referenced by XLogFlush().

◆ LWLockAnyHeldByMe()

bool LWLockAnyHeldByMe ( LWLock lock,
int  nlocks,
size_t  stride 
)

Definition at line 1911 of file lwlock.c.

1912{
1913 char *held_lock_addr;
1914 char *begin;
1915 char *end;
1916 int i;
1917
1918 begin = (char *) lock;
1919 end = begin + nlocks * stride;
1920 for (i = 0; i < num_held_lwlocks; i++)
1921 {
1922 held_lock_addr = (char *) held_lwlocks[i].lock;
1923 if (held_lock_addr >= begin &&
1924 held_lock_addr < end &&
1925 (held_lock_addr - begin) % stride == 0)
1926 return true;
1927 }
1928 return false;
1929}

References held_lwlocks, i, and num_held_lwlocks.

◆ LWLockAttemptLock()

static bool LWLockAttemptLock ( LWLock lock,
LWLockMode  mode 
)
static

Definition at line 784 of file lwlock.c.

785{
786 uint32 old_state;
787
789
790 /*
791 * Read once outside the loop, later iterations will get the newer value
792 * via compare & exchange.
793 */
794 old_state = pg_atomic_read_u32(&lock->state);
795
796 /* loop until we've determined whether we could acquire the lock or not */
797 while (true)
798 {
799 uint32 desired_state;
800 bool lock_free;
801
802 desired_state = old_state;
803
804 if (mode == LW_EXCLUSIVE)
805 {
806 lock_free = (old_state & LW_LOCK_MASK) == 0;
807 if (lock_free)
808 desired_state += LW_VAL_EXCLUSIVE;
809 }
810 else
811 {
812 lock_free = (old_state & LW_VAL_EXCLUSIVE) == 0;
813 if (lock_free)
814 desired_state += LW_VAL_SHARED;
815 }
816
817 /*
818 * Attempt to swap in the state we are expecting. If we didn't see
819 * lock to be free, that's just the old value. If we saw it as free,
820 * we'll attempt to mark it acquired. The reason that we always swap
821 * in the value is that this doubles as a memory barrier. We could try
822 * to be smarter and only swap in values if we saw the lock as free,
823 * but benchmark haven't shown it as beneficial so far.
824 *
825 * Retry if the value changed since we last looked at it.
826 */
828 &old_state, desired_state))
829 {
830 if (lock_free)
831 {
832 /* Great! Got the lock. */
833#ifdef LOCK_DEBUG
834 if (mode == LW_EXCLUSIVE)
835 lock->owner = MyProc;
836#endif
837 return false;
838 }
839 else
840 return true; /* somebody else has the lock */
841 }
842 }
844}
static bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval)
Definition: atomics.h:349
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:239
#define pg_unreachable()
Definition: c.h:318
#define LW_VAL_EXCLUSIVE
Definition: lwlock.c:98
#define LW_VAL_SHARED
Definition: lwlock.c:99
#define LW_LOCK_MASK
Definition: lwlock.c:101

References Assert, LW_EXCLUSIVE, LW_LOCK_MASK, LW_SHARED, LW_VAL_EXCLUSIVE, LW_VAL_SHARED, mode, MyProc, pg_atomic_compare_exchange_u32(), pg_atomic_read_u32(), pg_unreachable, and LWLock::state.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockConditionalAcquire().

◆ LWLockConditionalAcquire()

bool LWLockConditionalAcquire ( LWLock lock,
LWLockMode  mode 
)

Definition at line 1339 of file lwlock.c.

1340{
1341 bool mustwait;
1342
1344
1345 PRINT_LWDEBUG("LWLockConditionalAcquire", lock, mode);
1346
1347 /* Ensure we will have room to remember the lock */
1349 elog(ERROR, "too many LWLocks taken");
1350
1351 /*
1352 * Lock out cancel/die interrupts until we exit the code section protected
1353 * by the LWLock. This ensures that interrupts will not interfere with
1354 * manipulations of data structures in shared memory.
1355 */
1357
1358 /* Check for the lock */
1359 mustwait = LWLockAttemptLock(lock, mode);
1360
1361 if (mustwait)
1362 {
1363 /* Failed to get lock, so release interrupt holdoff */
1365
1366 LOG_LWDEBUG("LWLockConditionalAcquire", lock, "failed");
1367 if (TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL_ENABLED())
1368 TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(T_NAME(lock), mode);
1369 }
1370 else
1371 {
1372 /* Add lock to list of locks held by this backend */
1375 if (TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_ENABLED())
1376 TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE(T_NAME(lock), mode);
1377 }
1378 return !mustwait;
1379}

References Assert, elog, ERROR, held_lwlocks, HOLD_INTERRUPTS, LWLockHandle::lock, LOG_LWDEBUG, LW_EXCLUSIVE, LW_SHARED, LWLockAttemptLock(), MAX_SIMUL_LWLOCKS, LWLockHandle::mode, mode, num_held_lwlocks, PRINT_LWDEBUG, RESUME_INTERRUPTS, and T_NAME.

Referenced by ConditionalLockBuffer(), GetVictimBuffer(), pgstat_io_flush_cb(), pgstat_lock_entry(), pgstat_lock_entry_shared(), pgstat_slru_flush_cb(), pgstat_wal_flush_cb(), ProcArrayEndTransaction(), SimpleLruWaitIO(), ss_report_location(), TransactionIdSetPageStatus(), and XLogNeedsFlush().

◆ LWLockConflictsWithVar()

static bool LWLockConflictsWithVar ( LWLock lock,
pg_atomic_uint64 valptr,
uint64  oldval,
uint64 newval,
bool *  result 
)
static

Definition at line 1523 of file lwlock.c.

1525{
1526 bool mustwait;
1527 uint64 value;
1528
1529 /*
1530 * Test first to see if it the slot is free right now.
1531 *
1532 * XXX: the unique caller of this routine, WaitXLogInsertionsToFinish()
1533 * via LWLockWaitForVar(), uses an implied barrier with a spinlock before
1534 * this, so we don't need a memory barrier here as far as the current
1535 * usage is concerned. But that might not be safe in general.
1536 */
1537 mustwait = (pg_atomic_read_u32(&lock->state) & LW_VAL_EXCLUSIVE) != 0;
1538
1539 if (!mustwait)
1540 {
1541 *result = true;
1542 return false;
1543 }
1544
1545 *result = false;
1546
1547 /*
1548 * Reading this value atomically is safe even on platforms where uint64
1549 * cannot be read without observing a torn value.
1550 */
1551 value = pg_atomic_read_u64(valptr);
1552
1553 if (value != oldval)
1554 {
1555 mustwait = false;
1556 *newval = value;
1557 }
1558 else
1559 {
1560 mustwait = true;
1561 }
1562
1563 return mustwait;
1564}
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:467
uint64_t uint64
Definition: c.h:489
#define newval
static struct @162 value

References LW_VAL_EXCLUSIVE, newval, pg_atomic_read_u32(), pg_atomic_read_u64(), LWLock::state, and value.

Referenced by LWLockWaitForVar().

◆ LWLockDequeueSelf()

static void LWLockDequeueSelf ( LWLock lock)
static

Definition at line 1079 of file lwlock.c.

1080{
1081 bool on_waitlist;
1082
1083#ifdef LWLOCK_STATS
1084 lwlock_stats *lwstats;
1085
1086 lwstats = get_lwlock_stats_entry(lock);
1087
1088 lwstats->dequeue_self_count++;
1089#endif
1090
1091 LWLockWaitListLock(lock);
1092
1093 /*
1094 * Remove ourselves from the waitlist, unless we've already been removed.
1095 * The removal happens with the wait list lock held, so there's no race in
1096 * this check.
1097 */
1098 on_waitlist = MyProc->lwWaiting == LW_WS_WAITING;
1099 if (on_waitlist)
1100 proclist_delete(&lock->waiters, MyProcNumber, lwWaitLink);
1101
1102 if (proclist_is_empty(&lock->waiters) &&
1104 {
1106 }
1107
1108 /* XXX: combine with fetch_and above? */
1110
1111 /* clear waiting state again, nice for debugging */
1112 if (on_waitlist)
1114 else
1115 {
1116 int extraWaits = 0;
1117
1118 /*
1119 * Somebody else dequeued us and has or will wake us up. Deal with the
1120 * superfluous absorption of a wakeup.
1121 */
1122
1123 /*
1124 * Reset RELEASE_OK flag if somebody woke us before we removed
1125 * ourselves - they'll have set it to false.
1126 */
1128
1129 /*
1130 * Now wait for the scheduled wakeup, otherwise our ->lwWaiting would
1131 * get reset at some inconvenient point later. Most of the time this
1132 * will immediately return.
1133 */
1134 for (;;)
1135 {
1138 break;
1139 extraWaits++;
1140 }
1141
1142 /*
1143 * Fix the process wait semaphore's count for any absorbed wakeups.
1144 */
1145 while (extraWaits-- > 0)
1147 }
1148
1149#ifdef LOCK_DEBUG
1150 {
1151 /* not waiting anymore */
1152 uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
1153
1154 Assert(nwaiters < MAX_BACKENDS);
1155 }
1156#endif
1157}
static uint32 pg_atomic_fetch_and_u32(volatile pg_atomic_uint32 *ptr, uint32 and_)
Definition: atomics.h:396
ProcNumber MyProcNumber
Definition: globals.c:89
static void LWLockWaitListLock(LWLock *lock)
Definition: lwlock.c:855
#define LW_FLAG_HAS_WAITERS
Definition: lwlock.c:94
static void LWLockWaitListUnlock(LWLock *lock)
Definition: lwlock.c:907
@ LW_WS_WAITING
Definition: lwlock.h:31
#define proclist_delete(list, procno, link_member)
Definition: proclist.h:187
static bool proclist_is_empty(const proclist_head *list)
Definition: proclist.h:38
proclist_head waiters
Definition: lwlock.h:45

References Assert, LW_FLAG_HAS_WAITERS, LW_FLAG_RELEASE_OK, LW_WS_NOT_WAITING, LW_WS_WAITING, LWLockWaitListLock(), LWLockWaitListUnlock(), PGPROC::lwWaiting, MAX_BACKENDS, MyProc, MyProcNumber, pg_atomic_fetch_and_u32(), pg_atomic_fetch_or_u32(), pg_atomic_fetch_sub_u32(), pg_atomic_read_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), proclist_delete, proclist_is_empty(), PGPROC::sem, LWLock::state, and LWLock::waiters.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockWaitForVar().

◆ LWLockHeldByMe()

◆ LWLockHeldByMeInMode()

◆ LWLockInitialize()

◆ LWLockNewTrancheId()

int LWLockNewTrancheId ( void  )

Definition at line 603 of file lwlock.c.

604{
605 int result;
606 int *LWLockCounter;
607
608 LWLockCounter = (int *) ((char *) MainLWLockArray - sizeof(int));
609 /* We use the ShmemLock spinlock to protect LWLockCounter */
611 result = (*LWLockCounter)++;
613
614 return result;
615}
slock_t * ShmemLock
Definition: shmem.c:87
#define SpinLockRelease(lock)
Definition: spin.h:61
#define SpinLockAcquire(lock)
Definition: spin.h:59

References MainLWLockArray, ShmemLock, SpinLockAcquire, and SpinLockRelease.

Referenced by apw_init_state(), InitializeLWLocks(), tdr_init_shmem(), test_basic(), test_create(), test_dsa_basic(), test_dsa_resowners(), test_empty(), test_random(), and test_slru_shmem_startup().

◆ LWLockQueueSelf()

static void LWLockQueueSelf ( LWLock lock,
LWLockMode  mode 
)
static

Definition at line 1036 of file lwlock.c.

1037{
1038 /*
1039 * If we don't have a PGPROC structure, there's no way to wait. This
1040 * should never occur, since MyProc should only be null during shared
1041 * memory initialization.
1042 */
1043 if (MyProc == NULL)
1044 elog(PANIC, "cannot wait without a PGPROC structure");
1045
1047 elog(PANIC, "queueing for lock while waiting on another one");
1048
1049 LWLockWaitListLock(lock);
1050
1051 /* setting the flag is protected by the spinlock */
1053
1056
1057 /* LW_WAIT_UNTIL_FREE waiters are always at the front of the queue */
1058 if (mode == LW_WAIT_UNTIL_FREE)
1059 proclist_push_head(&lock->waiters, MyProcNumber, lwWaitLink);
1060 else
1061 proclist_push_tail(&lock->waiters, MyProcNumber, lwWaitLink);
1062
1063 /* Can release the mutex now */
1065
1066#ifdef LOCK_DEBUG
1067 pg_atomic_fetch_add_u32(&lock->nwaiters, 1);
1068#endif
1069}
static uint32 pg_atomic_fetch_add_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:366
#define PANIC
Definition: elog.h:42
#define proclist_push_tail(list, procno, link_member)
Definition: proclist.h:191
#define proclist_push_head(list, procno, link_member)
Definition: proclist.h:189
uint8 lwWaitMode
Definition: proc.h:224

References elog, LW_FLAG_HAS_WAITERS, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LW_WS_WAITING, LWLockWaitListLock(), LWLockWaitListUnlock(), PGPROC::lwWaiting, PGPROC::lwWaitMode, mode, MyProc, MyProcNumber, PANIC, pg_atomic_fetch_add_u32(), pg_atomic_fetch_or_u32(), proclist_push_head, proclist_push_tail, LWLock::state, and LWLock::waiters.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockWaitForVar().

◆ LWLockRegisterTranche()

void LWLockRegisterTranche ( int  tranche_id,
const char *  tranche_name 
)

Definition at line 628 of file lwlock.c.

629{
630 /* This should only be called for user-defined tranches. */
631 if (tranche_id < LWTRANCHE_FIRST_USER_DEFINED)
632 return;
633
634 /* Convert to array index. */
635 tranche_id -= LWTRANCHE_FIRST_USER_DEFINED;
636
637 /* If necessary, create or enlarge array. */
638 if (tranche_id >= LWLockTrancheNamesAllocated)
639 {
640 int newalloc;
641
642 newalloc = pg_nextpower2_32(Max(8, tranche_id + 1));
643
644 if (LWLockTrancheNames == NULL)
645 LWLockTrancheNames = (const char **)
647 newalloc * sizeof(char *));
648 else
652 }
653
654 LWLockTrancheNames[tranche_id] = tranche_name;
655}
#define Max(x, y)
Definition: c.h:955
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1215
MemoryContext TopMemoryContext
Definition: mcxt.c:149
#define repalloc0_array(pointer, type, oldcount, count)
Definition: palloc.h:109
static uint32 pg_nextpower2_32(uint32 num)
Definition: pg_bitutils.h:189

References LWLockTrancheNames, LWLockTrancheNamesAllocated, LWTRANCHE_FIRST_USER_DEFINED, Max, MemoryContextAllocZero(), pg_nextpower2_32(), repalloc0_array, and TopMemoryContext.

Referenced by apw_init_shmem(), CreateLWLocks(), tdr_attach_shmem(), test_basic(), test_create(), test_dsa_basic(), test_dsa_resowners(), test_empty(), test_random(), and test_slru_shmem_startup().

◆ LWLockRelease()

void LWLockRelease ( LWLock lock)

Definition at line 1781 of file lwlock.c.

1782{
1784 uint32 oldstate;
1785 bool check_waiters;
1786 int i;
1787
1788 /*
1789 * Remove lock from list of locks held. Usually, but not always, it will
1790 * be the latest-acquired lock; so search array backwards.
1791 */
1792 for (i = num_held_lwlocks; --i >= 0;)
1793 if (lock == held_lwlocks[i].lock)
1794 break;
1795
1796 if (i < 0)
1797 elog(ERROR, "lock %s is not held", T_NAME(lock));
1798
1800
1802 for (; i < num_held_lwlocks; i++)
1803 held_lwlocks[i] = held_lwlocks[i + 1];
1804
1805 PRINT_LWDEBUG("LWLockRelease", lock, mode);
1806
1807 /*
1808 * Release my hold on lock, after that it can immediately be acquired by
1809 * others, even if we still have to wakeup other waiters.
1810 */
1811 if (mode == LW_EXCLUSIVE)
1812 oldstate = pg_atomic_sub_fetch_u32(&lock->state, LW_VAL_EXCLUSIVE);
1813 else
1814 oldstate = pg_atomic_sub_fetch_u32(&lock->state, LW_VAL_SHARED);
1815
1816 /* nobody else can have that kind of lock */
1817 Assert(!(oldstate & LW_VAL_EXCLUSIVE));
1818
1819 if (TRACE_POSTGRESQL_LWLOCK_RELEASE_ENABLED())
1820 TRACE_POSTGRESQL_LWLOCK_RELEASE(T_NAME(lock));
1821
1822 /*
1823 * We're still waiting for backends to get scheduled, don't wake them up
1824 * again.
1825 */
1826 if ((oldstate & (LW_FLAG_HAS_WAITERS | LW_FLAG_RELEASE_OK)) ==
1828 (oldstate & LW_LOCK_MASK) == 0)
1829 check_waiters = true;
1830 else
1831 check_waiters = false;
1832
1833 /*
1834 * As waking up waiters requires the spinlock to be acquired, only do so
1835 * if necessary.
1836 */
1837 if (check_waiters)
1838 {
1839 /* XXX: remove before commit? */
1840 LOG_LWDEBUG("LWLockRelease", lock, "releasing waiters");
1841 LWLockWakeup(lock);
1842 }
1843
1844 /*
1845 * Now okay to allow cancel/die interrupts.
1846 */
1848}
static uint32 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:439
static void LWLockWakeup(LWLock *lock)
Definition: lwlock.c:920
LWLockMode
Definition: lwlock.h:113

References Assert, elog, ERROR, held_lwlocks, i, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_HAS_WAITERS, LW_FLAG_RELEASE_OK, LW_LOCK_MASK, LW_VAL_EXCLUSIVE, LW_VAL_SHARED, LWLockWakeup(), LWLockHandle::mode, mode, num_held_lwlocks, pg_atomic_sub_fetch_u32(), PRINT_LWDEBUG, RESUME_INTERRUPTS, LWLock::state, and T_NAME.

Referenced by _bt_end_vacuum(), _bt_start_vacuum(), _bt_vacuum_cycleid(), AbsorbSyncRequests(), ActivateCommitTs(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AdvanceXLInsertBuffer(), alloc_object(), AlterSystemSetConfigFile(), ApplyLauncherMain(), apw_detach_shmem(), apw_dump_now(), apw_load_buffers(), asyncQueueAddEntries(), asyncQueueAdvanceTail(), asyncQueueReadAllNotifications(), asyncQueueUnregister(), AtAbort_Twophase(), AtEOXact_LogicalRepWorkers(), AtPrepare_PredicateLocks(), attach_internal(), autoprewarm_main(), autoprewarm_start_worker(), AutoVacuumRequestWork(), AutoVacWorkerMain(), BackendPidGetProc(), BackendXidGetPid(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BootStrapCLOG(), BootStrapMultiXact(), BootStrapSUBTRANS(), BufferAlloc(), CancelDBBackends(), check_for_freed_segments(), CheckDeadLock(), CheckForSerializableConflictOut(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointTwoPhase(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), CleanupInvalidationState(), ClearOldPredicateLocks(), clog_redo(), commit_ts_redo(), ComputeXidHorizons(), consume_xids_shortcut(), copy_replication_slot(), CountDBBackends(), CountDBConnections(), CountOtherDBBackends(), CountUserBackends(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateInitDecodingContext(), CreatePredicateLock(), CreateRestartPoint(), DeactivateCommitTs(), DeleteChildTargetLocks(), DeleteLockTarget(), destroy_superblock(), do_autovacuum(), do_pg_backup_start(), do_pg_backup_stop(), do_start_worker(), DropAllPredicateLocksFromTable(), DropTableSpace(), dsa_allocate_extended(), dsa_dump(), dsa_free(), dsa_get_total_size(), dsa_pin(), dsa_release_in_place(), dsa_set_size_limit(), dsa_trim(), dsa_unpin(), dshash_delete_entry(), dshash_delete_key(), dshash_dump(), dshash_find(), dshash_find_or_insert(), dshash_release_lock(), dshash_seq_next(), dshash_seq_term(), dsm_attach(), dsm_create(), dsm_detach(), dsm_pin_segment(), dsm_unpin_segment(), ensure_active_superblock(), entry_reset(), EvictUnpinnedBuffer(), Exec_ListenPreCommit(), ExecParallelHashMergeCounters(), ExecParallelHashPopChunkQueue(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ExtendBufferedRelShared(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), find_multixact_start(), FindAndDropRelationBuffers(), FinishPreparedTransaction(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), ForceTransactionIdLimitUpdate(), ForwardSyncRequest(), FreeWorkerInfo(), get_local_synced_slots(), get_val_in_shmem(), get_xid_status(), GetBackgroundWorkerPid(), GetBackgroundWorkerTypeByPid(), GetBlockerStatusData(), GetConflictingVirtualXIDs(), GetCurrentVirtualXIDs(), GetLastImportantRecPtr(), GetLastSegSwitchData(), GetLatestCommitTsData(), GetLeaderApplyWorkerPid(), GetLockConflicts(), GetLockStatusData(), GetMultiXactIdMembers(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestMultiXactId(), GetOldestRestartPoint(), GetOldestSafeDecodingTransactionId(), GetOldestUnsummarizedLSN(), GetPredicateLockStatusData(), GetPreparedTransactionList(), GetRunningTransactionLocks(), GetSafeSnapshot(), GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetStrictOldestNonRemovableTransactionId(), GetVictimBuffer(), GetVirtualXIDsDelayingChkpt(), GetWaitEventCustomIdentifier(), GetWaitEventCustomNames(), GetWalSummarizerState(), HaveVirtualXIDsDelayingChkpt(), init_dsm_registry(), injection_shmem_startup(), injection_stats_fixed_reset_all_cb(), injection_stats_fixed_snapshot_cb(), InjectionPointAttach(), InjectionPointDetach(), InstallXLogFileSegment(), InvalidateBuffer(), InvalidateObsoleteReplicationSlots(), InvalidatePossiblyObsoleteSlot(), InvalidateVictimBuffer(), IsInstallXLogFileSegmentActive(), KnownAssignedXidsCompress(), KnownAssignedXidsReset(), lock_twophase_recover(), LockAcquireExtended(), LockBuffer(), LockErrorCleanup(), LockGXact(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), LockWaiterCount(), logicalrep_launcher_attach_dshmem(), logicalrep_pa_worker_stop(), logicalrep_worker_attach(), logicalrep_worker_detach(), logicalrep_worker_launch(), logicalrep_worker_stop(), logicalrep_worker_stop_internal(), logicalrep_worker_wakeup(), logicalrep_workers_find(), LogStandbySnapshot(), LookupGXact(), LookupGXactBySubid(), LWLockReleaseAll(), LWLockReleaseClearVar(), MarkAsPrepared(), MarkAsPreparing(), MaybeExtendOffsetSlru(), multixact_redo(), MultiXactAdvanceNextMXact(), MultiXactGetCheckptMulti(), MultiXactIdSetOldestMember(), MultiXactIdSetOldestVisible(), MultiXactSetNextMXact(), OnConflict_CheckForSerializationFailure(), PageIsPredicateLocked(), perform_relmap_update(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_get_replication_slots(), pg_get_shmem_allocations(), pg_notification_queue_usage(), pg_show_replication_origin_status(), pg_stat_get_subscription(), pg_stat_statements_internal(), pg_xact_status(), pgss_shmem_startup(), pgss_store(), pgstat_archiver_reset_all_cb(), pgstat_archiver_snapshot_cb(), pgstat_bgwriter_reset_all_cb(), pgstat_bgwriter_snapshot_cb(), pgstat_build_snapshot(), pgstat_checkpointer_reset_all_cb(), pgstat_checkpointer_snapshot_cb(), pgstat_fetch_replslot(), pgstat_io_flush_cb(), pgstat_io_reset_all_cb(), pgstat_io_snapshot_cb(), pgstat_reset_matching_entries(), pgstat_reset_replslot(), pgstat_reset_slru_counter_internal(), pgstat_slru_flush_cb(), pgstat_slru_snapshot_cb(), pgstat_unlock_entry(), pgstat_wal_flush_cb(), pgstat_wal_reset_all_cb(), pgstat_wal_snapshot_cb(), PostPrepare_Locks(), PostPrepare_MultiXact(), PostPrepare_Twophase(), PreCommit_CheckForSerializationFailure(), PreCommit_Notify(), predicatelock_twophase_recover(), PredicateLockPageSplit(), PredicateLockTwoPhaseFinish(), PrefetchSharedBuffer(), PrescanPreparedTransactions(), ProcArrayAdd(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcArrayClearTransaction(), ProcArrayEndTransaction(), ProcArrayGetReplicationSlotXmin(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcArrayRemove(), ProcArraySetReplicationSlotXmin(), process_syncing_tables_for_apply(), ProcKill(), ProcNumberGetTransactionIds(), ProcSleep(), ReachedEndOfBackup(), read_relmap_file(), ReadMultiXactCounts(), ReadMultiXactIdRange(), ReadNextFullTransactionId(), ReadNextMultiXactId(), ReadReplicationSlot(), RecordNewMultiXact(), RecoverPreparedTransactions(), RegisterDynamicBackgroundWorker(), RegisterPredicateLockingXid(), RelationCacheInitFilePostInvalidate(), RelationMapCopy(), RelationMapFinishBootstrap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), relmap_redo(), RemoveScratchTarget(), ReplicationOriginExitCleanup(), ReplicationSlotAcquire(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotName(), ReplicationSlotRelease(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), replorigin_advance(), replorigin_get_progress(), replorigin_session_advance(), replorigin_session_get_progress(), replorigin_session_reset(), replorigin_session_setup(), replorigin_state_clear(), resize(), RestoreScratchTarget(), restoreTwoPhaseData(), SaveSlotToPath(), SearchNamedReplicationSlot(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialInit(), SerialSetActiveSerXmin(), set_indexsafe_procflags(), set_val_in_shmem(), SetCommitTsLimit(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetNextObjectId(), SetOffsetVacuumLimit(), SetTransactionIdLimit(), SetXidCommitTsInPage(), SharedInvalBackendInit(), ShmemInitStruct(), SICleanupQueue(), SIGetDataEntries(), SignalBackends(), SignalVirtualTransaction(), SIInsertDataEntries(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruTruncate(), SimpleLruWaitIO(), SimpleLruWriteAll(), SlruDeleteSegment(), SlruInternalWritePage(), SnapBuildInitialSnapshot(), ss_get_location(), ss_report_location(), StandbyRecoverPreparedTransactions(), StandbySlotsHaveCaughtup(), StartupDecodingContext(), StartupSUBTRANS(), StartupXLOG(), sts_parallel_scan_next(), SubTransGetParent(), SubTransSetParent(), SummarizeOldestCommittedSxact(), SummarizeWAL(), SwitchIntoArchiveRecovery(), synchronize_one_slot(), SyncOneBuffer(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepReleaseWaiters(), SyncRepUpdateSyncStandbysDefined(), SyncRepWaitForLSN(), TablespaceCreateDbspace(), tbm_shared_iterate(), TerminateBackgroundWorker(), TerminateOtherDBBackends(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_readonly(), test_slru_page_write(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdGetStatus(), TransactionIdIsActive(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TransactionTreeSetCommitTsData(), TransferPredicateLocksToNewTarget(), TrimCLOG(), TrimMultiXact(), TruncateMultiXact(), TwoPhaseGetGXact(), TwoPhaseGetXidByVirtualXID(), update_cached_xid_range(), update_synced_slots_inactive_since(), UpdateMinRecoveryPoint(), vac_truncate_clog(), vacuum_rel(), VacuumUpdateCosts(), validate_sync_standby_slots(), VirtualXactLock(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), wait_for_relation_state_change(), wait_for_worker_state_change(), WaitEventCustomNew(), WaitForReplicationWorkerAttach(), WaitForWalSummarization(), WakeupWalSummarizer(), WalSummarizerMain(), WalSummarizerShutdown(), write_relcache_init_file(), xact_redo(), XidCacheRemoveRunningXids(), xlog_redo(), XLogBackgroundFlush(), XLogFlush(), XLogNeedsFlush(), XLogReportParameters(), and XLogShutdownWalRcv().

◆ LWLockReleaseAll()

void LWLockReleaseAll ( void  )

Definition at line 1876 of file lwlock.c.

1877{
1878 while (num_held_lwlocks > 0)
1879 {
1880 HOLD_INTERRUPTS(); /* match the upcoming RESUME_INTERRUPTS */
1881
1883 }
1884}
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1781

References held_lwlocks, HOLD_INTERRUPTS, LWLockRelease(), and num_held_lwlocks.

Referenced by AbortSubTransaction(), AbortTransaction(), AuxiliaryProcKill(), BackgroundWriterMain(), CheckpointerMain(), pgarch_archiveXlog(), ProcKill(), ShutdownAuxiliaryProcess(), WalSndErrorCleanup(), WalSummarizerMain(), and WalWriterMain().

◆ LWLockReleaseClearVar()

void LWLockReleaseClearVar ( LWLock lock,
pg_atomic_uint64 valptr,
uint64  val 
)

Definition at line 1854 of file lwlock.c.

1855{
1856 /*
1857 * Note that pg_atomic_exchange_u64 is a full barrier, so we're guaranteed
1858 * that the variable is updated before releasing the lock.
1859 */
1860 pg_atomic_exchange_u64(valptr, val);
1861
1862 LWLockRelease(lock);
1863}
static uint64 pg_atomic_exchange_u64(volatile pg_atomic_uint64 *ptr, uint64 newval)
Definition: atomics.h:503
long val
Definition: informix.c:689

References LWLockRelease(), pg_atomic_exchange_u64(), and val.

Referenced by WALInsertLockRelease().

◆ LWLockReportWaitEnd()

static void LWLockReportWaitEnd ( void  )
inlinestatic

Definition at line 734 of file lwlock.c.

735{
737}
static void pgstat_report_wait_end(void)
Definition: wait_event.h:101

References pgstat_report_wait_end().

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockWaitForVar().

◆ LWLockReportWaitStart()

static void LWLockReportWaitStart ( LWLock lock)
inlinestatic

Definition at line 725 of file lwlock.c.

726{
728}
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:85

References PG_WAIT_LWLOCK, pgstat_report_wait_start(), and LWLock::tranche.

Referenced by LWLockAcquire(), LWLockAcquireOrWait(), and LWLockWaitForVar().

◆ LWLockShmemSize()

Size LWLockShmemSize ( void  )

Definition at line 420 of file lwlock.c.

421{
422 Size size;
423 int i;
424 int numLocks = NUM_FIXED_LWLOCKS;
425
426 /* Calculate total number of locks needed in the main array. */
427 numLocks += NumLWLocksForNamedTranches();
428
429 /* Space for the LWLock array. */
430 size = mul_size(numLocks, sizeof(LWLockPadded));
431
432 /* Space for dynamic allocation counter, plus room for alignment. */
433 size = add_size(size, sizeof(int) + LWLOCK_PADDED_SIZE);
434
435 /* space for named tranches. */
437
438 /* space for name of each tranche. */
439 for (i = 0; i < NamedLWLockTrancheRequests; i++)
440 size = add_size(size, strlen(NamedLWLockTrancheRequestArray[i].tranche_name) + 1);
441
442 return size;
443}
Size add_size(Size s1, Size s2)
Definition: shmem.c:488
Size mul_size(Size s1, Size s2)
Definition: shmem.c:505
static pg_noinline void Size size
Definition: slab.c:607

References add_size(), i, LWLOCK_PADDED_SIZE, mul_size(), NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NUM_FIXED_LWLOCKS, NumLWLocksForNamedTranches(), and size.

Referenced by CalculateShmemSize(), and CreateLWLocks().

◆ LWLockUpdateVar()

void LWLockUpdateVar ( LWLock lock,
pg_atomic_uint64 valptr,
uint64  val 
)

Definition at line 1720 of file lwlock.c.

1721{
1724
1725 PRINT_LWDEBUG("LWLockUpdateVar", lock, LW_EXCLUSIVE);
1726
1727 /*
1728 * Note that pg_atomic_exchange_u64 is a full barrier, so we're guaranteed
1729 * that the variable is updated before waking up waiters.
1730 */
1731 pg_atomic_exchange_u64(valptr, val);
1732
1734
1735 LWLockWaitListLock(lock);
1736
1738
1739 /*
1740 * See if there are any LW_WAIT_UNTIL_FREE waiters that need to be woken
1741 * up. They are always in the front of the queue.
1742 */
1743 proclist_foreach_modify(iter, &lock->waiters, lwWaitLink)
1744 {
1745 PGPROC *waiter = GetPGProcByNumber(iter.cur);
1746
1747 if (waiter->lwWaitMode != LW_WAIT_UNTIL_FREE)
1748 break;
1749
1750 proclist_delete(&lock->waiters, iter.cur, lwWaitLink);
1751 proclist_push_tail(&wakeup, iter.cur, lwWaitLink);
1752
1753 /* see LWLockWakeup() */
1754 Assert(waiter->lwWaiting == LW_WS_WAITING);
1756 }
1757
1758 /* We are done updating shared state of the lock itself. */
1760
1761 /*
1762 * Awaken any waiters I removed from the queue.
1763 */
1764 proclist_foreach_modify(iter, &wakeup, lwWaitLink)
1765 {
1766 PGPROC *waiter = GetPGProcByNumber(iter.cur);
1767
1768 proclist_delete(&wakeup, iter.cur, lwWaitLink);
1769 /* check comment in LWLockWakeup() about this barrier */
1771 waiter->lwWaiting = LW_WS_NOT_WAITING;
1772 PGSemaphoreUnlock(waiter->sem);
1773 }
1774}
#define pg_write_barrier()
Definition: atomics.h:157
@ LW_WS_PENDING_WAKEUP
Definition: lwlock.h:32
#define GetPGProcByNumber(n)
Definition: proc.h:423
#define proclist_foreach_modify(iter, lhead, link_member)
Definition: proclist.h:206
static TimestampTz wakeup[NUM_WALRCV_WAKEUPS]
Definition: walreceiver.c:129

References Assert, proclist_mutable_iter::cur, GetPGProcByNumber, LW_EXCLUSIVE, LW_VAL_EXCLUSIVE, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LW_WS_PENDING_WAKEUP, LW_WS_WAITING, LWLockWaitListLock(), LWLockWaitListUnlock(), PGPROC::lwWaiting, PGPROC::lwWaitMode, pg_atomic_exchange_u64(), pg_atomic_read_u32(), pg_write_barrier, PGSemaphoreUnlock(), PRINT_LWDEBUG, proclist_delete, proclist_foreach_modify, proclist_init(), proclist_push_tail, PGPROC::sem, LWLock::state, val, LWLock::waiters, and wakeup.

Referenced by WALInsertLockAcquireExclusive(), and WALInsertLockUpdateInsertingAt().

◆ LWLockWaitForVar()

bool LWLockWaitForVar ( LWLock lock,
pg_atomic_uint64 valptr,
uint64  oldval,
uint64 newval 
)

Definition at line 1584 of file lwlock.c.

1586{
1587 PGPROC *proc = MyProc;
1588 int extraWaits = 0;
1589 bool result = false;
1590#ifdef LWLOCK_STATS
1591 lwlock_stats *lwstats;
1592
1593 lwstats = get_lwlock_stats_entry(lock);
1594#endif
1595
1596 PRINT_LWDEBUG("LWLockWaitForVar", lock, LW_WAIT_UNTIL_FREE);
1597
1598 /*
1599 * Lock out cancel/die interrupts while we sleep on the lock. There is no
1600 * cleanup mechanism to remove us from the wait queue if we got
1601 * interrupted.
1602 */
1604
1605 /*
1606 * Loop here to check the lock's status after each time we are signaled.
1607 */
1608 for (;;)
1609 {
1610 bool mustwait;
1611
1612 mustwait = LWLockConflictsWithVar(lock, valptr, oldval, newval,
1613 &result);
1614
1615 if (!mustwait)
1616 break; /* the lock was free or value didn't match */
1617
1618 /*
1619 * Add myself to wait queue. Note that this is racy, somebody else
1620 * could wakeup before we're finished queuing. NB: We're using nearly
1621 * the same twice-in-a-row lock acquisition protocol as
1622 * LWLockAcquire(). Check its comments for details. The only
1623 * difference is that we also have to check the variable's values when
1624 * checking the state of the lock.
1625 */
1627
1628 /*
1629 * Set RELEASE_OK flag, to make sure we get woken up as soon as the
1630 * lock is released.
1631 */
1633
1634 /*
1635 * We're now guaranteed to be woken up if necessary. Recheck the lock
1636 * and variables state.
1637 */
1638 mustwait = LWLockConflictsWithVar(lock, valptr, oldval, newval,
1639 &result);
1640
1641 /* Ok, no conflict after we queued ourselves. Undo queueing. */
1642 if (!mustwait)
1643 {
1644 LOG_LWDEBUG("LWLockWaitForVar", lock, "free, undoing queue");
1645
1646 LWLockDequeueSelf(lock);
1647 break;
1648 }
1649
1650 /*
1651 * Wait until awakened.
1652 *
1653 * It is possible that we get awakened for a reason other than being
1654 * signaled by LWLockRelease. If so, loop back and wait again. Once
1655 * we've gotten the LWLock, re-increment the sema by the number of
1656 * additional signals received.
1657 */
1658 LOG_LWDEBUG("LWLockWaitForVar", lock, "waiting");
1659
1660#ifdef LWLOCK_STATS
1661 lwstats->block_count++;
1662#endif
1663
1665 if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
1666 TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), LW_EXCLUSIVE);
1667
1668 for (;;)
1669 {
1670 PGSemaphoreLock(proc->sem);
1671 if (proc->lwWaiting == LW_WS_NOT_WAITING)
1672 break;
1673 extraWaits++;
1674 }
1675
1676#ifdef LOCK_DEBUG
1677 {
1678 /* not waiting anymore */
1679 uint32 nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
1680
1681 Assert(nwaiters < MAX_BACKENDS);
1682 }
1683#endif
1684
1685 if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
1686 TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), LW_EXCLUSIVE);
1688
1689 LOG_LWDEBUG("LWLockWaitForVar", lock, "awakened");
1690
1691 /* Now loop back and check the status of the lock again. */
1692 }
1693
1694 /*
1695 * Fix the process wait semaphore's count for any absorbed wakeups.
1696 */
1697 while (extraWaits-- > 0)
1698 PGSemaphoreUnlock(proc->sem);
1699
1700 /*
1701 * Now okay to allow cancel/die interrupts.
1702 */
1704
1705 return result;
1706}
static bool LWLockConflictsWithVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval, bool *result)
Definition: lwlock.c:1523

References Assert, HOLD_INTERRUPTS, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_RELEASE_OK, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LWLockConflictsWithVar(), LWLockDequeueSelf(), LWLockQueueSelf(), LWLockReportWaitEnd(), LWLockReportWaitStart(), PGPROC::lwWaiting, MAX_BACKENDS, MyProc, newval, pg_atomic_fetch_or_u32(), pg_atomic_fetch_sub_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), PRINT_LWDEBUG, RESUME_INTERRUPTS, PGPROC::sem, LWLock::state, and T_NAME.

Referenced by WaitXLogInsertionsToFinish().

◆ LWLockWaitListLock()

static void LWLockWaitListLock ( LWLock lock)
static

Definition at line 855 of file lwlock.c.

856{
857 uint32 old_state;
858#ifdef LWLOCK_STATS
859 lwlock_stats *lwstats;
860 uint32 delays = 0;
861
862 lwstats = get_lwlock_stats_entry(lock);
863#endif
864
865 while (true)
866 {
867 /* always try once to acquire lock directly */
868 old_state = pg_atomic_fetch_or_u32(&lock->state, LW_FLAG_LOCKED);
869 if (!(old_state & LW_FLAG_LOCKED))
870 break; /* got lock */
871
872 /* and then spin without atomic operations until lock is released */
873 {
874 SpinDelayStatus delayStatus;
875
876 init_local_spin_delay(&delayStatus);
877
878 while (old_state & LW_FLAG_LOCKED)
879 {
880 perform_spin_delay(&delayStatus);
881 old_state = pg_atomic_read_u32(&lock->state);
882 }
883#ifdef LWLOCK_STATS
884 delays += delayStatus.delays;
885#endif
886 finish_spin_delay(&delayStatus);
887 }
888
889 /*
890 * Retry. The lock might obviously already be re-acquired by the time
891 * we're attempting to get it again.
892 */
893 }
894
895#ifdef LWLOCK_STATS
896 lwstats->spin_delay_count += delays;
897#endif
898}
#define LW_FLAG_LOCKED
Definition: lwlock.c:96
void perform_spin_delay(SpinDelayStatus *status)
Definition: s_lock.c:126
void finish_spin_delay(SpinDelayStatus *status)
Definition: s_lock.c:186
#define init_local_spin_delay(status)
Definition: s_lock.h:751

References SpinDelayStatus::delays, finish_spin_delay(), init_local_spin_delay, LW_FLAG_LOCKED, perform_spin_delay(), pg_atomic_fetch_or_u32(), pg_atomic_read_u32(), and LWLock::state.

Referenced by LWLockDequeueSelf(), LWLockQueueSelf(), LWLockUpdateVar(), and LWLockWakeup().

◆ LWLockWaitListUnlock()

static void LWLockWaitListUnlock ( LWLock lock)
static

Definition at line 907 of file lwlock.c.

908{
910
911 old_state = pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_LOCKED);
912
913 Assert(old_state & LW_FLAG_LOCKED);
914}

References Assert, LW_FLAG_LOCKED, pg_atomic_fetch_and_u32(), PG_USED_FOR_ASSERTS_ONLY, and LWLock::state.

Referenced by LWLockDequeueSelf(), LWLockQueueSelf(), and LWLockUpdateVar().

◆ LWLockWakeup()

static void LWLockWakeup ( LWLock lock)
static

Definition at line 920 of file lwlock.c.

921{
922 bool new_release_ok;
923 bool wokeup_somebody = false;
926
928
929 new_release_ok = true;
930
931 /* lock wait list while collecting backends to wake up */
932 LWLockWaitListLock(lock);
933
934 proclist_foreach_modify(iter, &lock->waiters, lwWaitLink)
935 {
936 PGPROC *waiter = GetPGProcByNumber(iter.cur);
937
938 if (wokeup_somebody && waiter->lwWaitMode == LW_EXCLUSIVE)
939 continue;
940
941 proclist_delete(&lock->waiters, iter.cur, lwWaitLink);
942 proclist_push_tail(&wakeup, iter.cur, lwWaitLink);
943
944 if (waiter->lwWaitMode != LW_WAIT_UNTIL_FREE)
945 {
946 /*
947 * Prevent additional wakeups until retryer gets to run. Backends
948 * that are just waiting for the lock to become free don't retry
949 * automatically.
950 */
951 new_release_ok = false;
952
953 /*
954 * Don't wakeup (further) exclusive locks.
955 */
956 wokeup_somebody = true;
957 }
958
959 /*
960 * Signal that the process isn't on the wait list anymore. This allows
961 * LWLockDequeueSelf() to remove itself of the waitlist with a
962 * proclist_delete(), rather than having to check if it has been
963 * removed from the list.
964 */
965 Assert(waiter->lwWaiting == LW_WS_WAITING);
967
968 /*
969 * Once we've woken up an exclusive lock, there's no point in waking
970 * up anybody else.
971 */
972 if (waiter->lwWaitMode == LW_EXCLUSIVE)
973 break;
974 }
975
977
978 /* unset required flags, and release lock, in one fell swoop */
979 {
980 uint32 old_state;
981 uint32 desired_state;
982
983 old_state = pg_atomic_read_u32(&lock->state);
984 while (true)
985 {
986 desired_state = old_state;
987
988 /* compute desired flags */
989
990 if (new_release_ok)
991 desired_state |= LW_FLAG_RELEASE_OK;
992 else
993 desired_state &= ~LW_FLAG_RELEASE_OK;
994
996 desired_state &= ~LW_FLAG_HAS_WAITERS;
997
998 desired_state &= ~LW_FLAG_LOCKED; /* release lock */
999
1000 if (pg_atomic_compare_exchange_u32(&lock->state, &old_state,
1001 desired_state))
1002 break;
1003 }
1004 }
1005
1006 /* Awaken any waiters I removed from the queue. */
1007 proclist_foreach_modify(iter, &wakeup, lwWaitLink)
1008 {
1009 PGPROC *waiter = GetPGProcByNumber(iter.cur);
1010
1011 LOG_LWDEBUG("LWLockRelease", lock, "release waiter");
1012 proclist_delete(&wakeup, iter.cur, lwWaitLink);
1013
1014 /*
1015 * Guarantee that lwWaiting being unset only becomes visible once the
1016 * unlink from the link has completed. Otherwise the target backend
1017 * could be woken up for other reason and enqueue for a new lock - if
1018 * that happens before the list unlink happens, the list would end up
1019 * being corrupted.
1020 *
1021 * The barrier pairs with the LWLockWaitListLock() when enqueuing for
1022 * another lock.
1023 */
1025 waiter->lwWaiting = LW_WS_NOT_WAITING;
1026 PGSemaphoreUnlock(waiter->sem);
1027 }
1028}

References Assert, proclist_mutable_iter::cur, GetPGProcByNumber, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_HAS_WAITERS, LW_FLAG_RELEASE_OK, LW_WAIT_UNTIL_FREE, LW_WS_NOT_WAITING, LW_WS_PENDING_WAKEUP, LW_WS_WAITING, LWLockWaitListLock(), PGPROC::lwWaiting, PGPROC::lwWaitMode, pg_atomic_compare_exchange_u32(), pg_atomic_read_u32(), pg_write_barrier, PGSemaphoreUnlock(), proclist_delete, proclist_foreach_modify, proclist_init(), proclist_is_empty(), proclist_push_tail, PGPROC::sem, LWLock::state, LWLock::waiters, and wakeup.

Referenced by LWLockRelease().

◆ NumLWLocksForNamedTranches()

static int NumLWLocksForNamedTranches ( void  )
static

Definition at line 405 of file lwlock.c.

406{
407 int numLocks = 0;
408 int i;
409
410 for (i = 0; i < NamedLWLockTrancheRequests; i++)
411 numLocks += NamedLWLockTrancheRequestArray[i].num_lwlocks;
412
413 return numLocks;
414}

References i, NamedLWLockTrancheRequestArray, and NamedLWLockTrancheRequests.

Referenced by InitializeLWLocks(), and LWLockShmemSize().

◆ RequestNamedLWLockTranche()

void RequestNamedLWLockTranche ( const char *  tranche_name,
int  num_lwlocks 
)

Definition at line 670 of file lwlock.c.

671{
673
675 elog(FATAL, "cannot request additional LWLocks outside shmem_request_hook");
676
678 {
683 * sizeof(NamedLWLockTrancheRequest));
684 }
685
687 {
689
692 i * sizeof(NamedLWLockTrancheRequest));
694 }
695
697 Assert(strlen(tranche_name) + 1 <= NAMEDATALEN);
698 strlcpy(request->tranche_name, tranche_name, NAMEDATALEN);
699 request->num_lwlocks = num_lwlocks;
701}
#define FATAL
Definition: elog.h:41
static int NamedLWLockTrancheRequestsAllocated
Definition: lwlock.c:216
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1541
bool process_shmem_requests_in_progress
Definition: miscinit.c:1838
#define NAMEDATALEN
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45

References Assert, elog, FATAL, i, MemoryContextAlloc(), NAMEDATALEN, NamedLWLockTrancheRequestArray, NamedLWLockTrancheRequests, NamedLWLockTrancheRequestsAllocated, NamedLWLockTrancheRequest::num_lwlocks, pg_nextpower2_32(), process_shmem_requests_in_progress, repalloc(), strlcpy(), TopMemoryContext, and NamedLWLockTrancheRequest::tranche_name.

Referenced by pgss_shmem_request().

◆ StaticAssertDecl() [1/2]

StaticAssertDecl ( lengthof(BuiltinTrancheNames = =LWTRANCHE_FIRST_USER_DEFINED,
"missing entries in BuiltinTrancheNames [] 
)

◆ StaticAssertDecl() [2/2]

StaticAssertDecl ( LW_VAL_EXCLUSIVE  ,
(uint32 MAX_BACKENDS,
"MAX_BACKENDS too big for lwlock.c  
)

Variable Documentation

◆ BuiltinTrancheNames

const char* const BuiltinTrancheNames[]
static

Definition at line 126 of file lwlock.c.

Referenced by GetLWTrancheName().

◆ held_lwlocks

◆ LWLockTrancheNames

const char** LWLockTrancheNames = NULL
static

Definition at line 180 of file lwlock.c.

Referenced by GetLWTrancheName(), and LWLockRegisterTranche().

◆ LWLockTrancheNamesAllocated

int LWLockTrancheNamesAllocated = 0
static

Definition at line 181 of file lwlock.c.

Referenced by GetLWTrancheName(), and LWLockRegisterTranche().

◆ MainLWLockArray

◆ NamedLWLockTrancheArray

NamedLWLockTranche* NamedLWLockTrancheArray = NULL

Definition at line 227 of file lwlock.c.

Referenced by CreateLWLocks(), and InitializeLWLocks().

◆ NamedLWLockTrancheRequestArray

NamedLWLockTrancheRequest* NamedLWLockTrancheRequestArray = NULL
static

◆ NamedLWLockTrancheRequests

int NamedLWLockTrancheRequests = 0

◆ NamedLWLockTrancheRequestsAllocated

int NamedLWLockTrancheRequestsAllocated = 0
static

Definition at line 216 of file lwlock.c.

Referenced by RequestNamedLWLockTranche().

◆ num_held_lwlocks