PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
lwlock.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * lwlock.c
4 * Lightweight lock manager
5 *
6 * Lightweight locks are intended primarily to provide mutual exclusion of
7 * access to shared-memory data structures. Therefore, they offer both
8 * exclusive and shared lock modes (to support read/write and read-only
9 * access to a shared object). There are few other frammishes. User-level
10 * locking should be done with the full lock manager --- which depends on
11 * LWLocks to protect its shared state.
12 *
13 * In addition to exclusive and shared modes, lightweight locks can be used to
14 * wait until a variable changes value. The variable is initially not set
15 * when the lock is acquired with LWLockAcquire, i.e. it remains set to the
16 * value it was set to when the lock was released last, and can be updated
17 * without releasing the lock by calling LWLockUpdateVar. LWLockWaitForVar
18 * waits for the variable to be updated, or until the lock is free. When
19 * releasing the lock with LWLockReleaseClearVar() the value can be set to an
20 * appropriate value for a free lock. The meaning of the variable is up to
21 * the caller, the lightweight lock code just assigns and compares it.
22 *
23 * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
24 * Portions Copyright (c) 1994, Regents of the University of California
25 *
26 * IDENTIFICATION
27 * src/backend/storage/lmgr/lwlock.c
28 *
29 * NOTES:
30 *
31 * This used to be a pretty straight forward reader-writer lock
32 * implementation, in which the internal state was protected by a
33 * spinlock. Unfortunately the overhead of taking the spinlock proved to be
34 * too high for workloads/locks that were taken in shared mode very
35 * frequently. Often we were spinning in the (obviously exclusive) spinlock,
36 * while trying to acquire a shared lock that was actually free.
37 *
38 * Thus a new implementation was devised that provides wait-free shared lock
39 * acquisition for locks that aren't exclusively locked.
40 *
41 * The basic idea is to have a single atomic variable 'lockcount' instead of
42 * the formerly separate shared and exclusive counters and to use atomic
43 * operations to acquire the lock. That's fairly easy to do for plain
44 * rw-spinlocks, but a lot harder for something like LWLocks that want to wait
45 * in the OS.
46 *
47 * For lock acquisition we use an atomic compare-and-exchange on the lockcount
48 * variable. For exclusive lock we swap in a sentinel value
49 * (LW_VAL_EXCLUSIVE), for shared locks we count the number of holders.
50 *
51 * To release the lock we use an atomic decrement to release the lock. If the
52 * new value is zero (we get that atomically), we know we can/have to release
53 * waiters.
54 *
55 * Obviously it is important that the sentinel value for exclusive locks
56 * doesn't conflict with the maximum number of possible share lockers -
57 * luckily MAX_BACKENDS makes that easily possible.
58 *
59 *
60 * The attentive reader might have noticed that naively doing the above has a
61 * glaring race condition: We try to lock using the atomic operations and
62 * notice that we have to wait. Unfortunately by the time we have finished
63 * queuing, the former locker very well might have already finished it's
64 * work. That's problematic because we're now stuck waiting inside the OS.
65
66 * To mitigate those races we use a two phased attempt at locking:
67 * Phase 1: Try to do it atomically, if we succeed, nice
68 * Phase 2: Add ourselves to the waitqueue of the lock
69 * Phase 3: Try to grab the lock again, if we succeed, remove ourselves from
70 * the queue
71 * Phase 4: Sleep till wake-up, goto Phase 1
72 *
73 * This protects us against the problem from above as nobody can release too
74 * quick, before we're queued, since after Phase 2 we're already queued.
75 * -------------------------------------------------------------------------
76 */
77#include "postgres.h"
78
79#include "miscadmin.h"
80#include "pg_trace.h"
81#include "pgstat.h"
82#include "port/pg_bitutils.h"
84#include "storage/proc.h"
85#include "storage/proclist.h"
86#include "storage/spin.h"
87#include "utils/memutils.h"
88
89#ifdef LWLOCK_STATS
90#include "utils/hsearch.h"
91#endif
92
93
94#define LW_FLAG_HAS_WAITERS ((uint32) 1 << 30)
95#define LW_FLAG_RELEASE_OK ((uint32) 1 << 29)
96#define LW_FLAG_LOCKED ((uint32) 1 << 28)
97
98#define LW_VAL_EXCLUSIVE ((uint32) 1 << 24)
99#define LW_VAL_SHARED 1
100
101#define LW_LOCK_MASK ((uint32) ((1 << 25)-1))
102/* Must be greater than MAX_BACKENDS - which is 2^23-1, so we're fine. */
103#define LW_SHARED_MASK ((uint32) ((1 << 24)-1))
104
106 "MAX_BACKENDS too big for lwlock.c");
107
108/*
109 * There are three sorts of LWLock "tranches":
110 *
111 * 1. The individually-named locks defined in lwlocklist.h each have their
112 * own tranche. We absorb the names of these tranches from there into
113 * BuiltinTrancheNames here.
114 *
115 * 2. There are some predefined tranches for built-in groups of locks.
116 * These are listed in enum BuiltinTrancheIds in lwlock.h, and their names
117 * appear in BuiltinTrancheNames[] below.
118 *
119 * 3. Extensions can create new tranches, via either RequestNamedLWLockTranche
120 * or LWLockRegisterTranche. The names of these that are known in the current
121 * process appear in LWLockTrancheNames[].
122 *
123 * All these names are user-visible as wait event names, so choose with care
124 * ... and do not forget to update the documentation's list of wait events.
125 */
126static const char *const BuiltinTrancheNames[] = {
127#define PG_LWLOCK(id, lockname) [id] = CppAsString(lockname),
128#include "storage/lwlocklist.h"
129#undef PG_LWLOCK
130 [LWTRANCHE_XACT_BUFFER] = "XactBuffer",
131 [LWTRANCHE_COMMITTS_BUFFER] = "CommitTsBuffer",
132 [LWTRANCHE_SUBTRANS_BUFFER] = "SubtransBuffer",
133 [LWTRANCHE_MULTIXACTOFFSET_BUFFER] = "MultiXactOffsetBuffer",
134 [LWTRANCHE_MULTIXACTMEMBER_BUFFER] = "MultiXactMemberBuffer",
135 [LWTRANCHE_NOTIFY_BUFFER] = "NotifyBuffer",
136 [LWTRANCHE_SERIAL_BUFFER] = "SerialBuffer",
137 [LWTRANCHE_WAL_INSERT] = "WALInsert",
138 [LWTRANCHE_BUFFER_CONTENT] = "BufferContent",
139 [LWTRANCHE_REPLICATION_ORIGIN_STATE] = "ReplicationOriginState",
140 [LWTRANCHE_REPLICATION_SLOT_IO] = "ReplicationSlotIO",
141 [LWTRANCHE_LOCK_FASTPATH] = "LockFastPath",
142 [LWTRANCHE_BUFFER_MAPPING] = "BufferMapping",
143 [LWTRANCHE_LOCK_MANAGER] = "LockManager",
144 [LWTRANCHE_PREDICATE_LOCK_MANAGER] = "PredicateLockManager",
145 [LWTRANCHE_PARALLEL_HASH_JOIN] = "ParallelHashJoin",
146 [LWTRANCHE_PARALLEL_QUERY_DSA] = "ParallelQueryDSA",
147 [LWTRANCHE_PER_SESSION_DSA] = "PerSessionDSA",
148 [LWTRANCHE_PER_SESSION_RECORD_TYPE] = "PerSessionRecordType",
149 [LWTRANCHE_PER_SESSION_RECORD_TYPMOD] = "PerSessionRecordTypmod",
150 [LWTRANCHE_SHARED_TUPLESTORE] = "SharedTupleStore",
151 [LWTRANCHE_SHARED_TIDBITMAP] = "SharedTidBitmap",
152 [LWTRANCHE_PARALLEL_APPEND] = "ParallelAppend",
153 [LWTRANCHE_PER_XACT_PREDICATE_LIST] = "PerXactPredicateList",
154 [LWTRANCHE_PGSTATS_DSA] = "PgStatsDSA",
155 [LWTRANCHE_PGSTATS_HASH] = "PgStatsHash",
156 [LWTRANCHE_PGSTATS_DATA] = "PgStatsData",
157 [LWTRANCHE_LAUNCHER_DSA] = "LogicalRepLauncherDSA",
158 [LWTRANCHE_LAUNCHER_HASH] = "LogicalRepLauncherHash",
159 [LWTRANCHE_DSM_REGISTRY_DSA] = "DSMRegistryDSA",
160 [LWTRANCHE_DSM_REGISTRY_HASH] = "DSMRegistryHash",
161 [LWTRANCHE_COMMITTS_SLRU] = "CommitTsSLRU",
162 [LWTRANCHE_MULTIXACTOFFSET_SLRU] = "MultixactOffsetSLRU",
163 [LWTRANCHE_MULTIXACTMEMBER_SLRU] = "MultixactMemberSLRU",
164 [LWTRANCHE_NOTIFY_SLRU] = "NotifySLRU",
165 [LWTRANCHE_SERIAL_SLRU] = "SerialSLRU",
166 [LWTRANCHE_SUBTRANS_SLRU] = "SubtransSLRU",
167 [LWTRANCHE_XACT_SLRU] = "XactSLRU",
168 [LWTRANCHE_PARALLEL_VACUUM_DSA] = "ParallelVacuumDSA",
169};
170
173 "missing entries in BuiltinTrancheNames[]");
174
175/*
176 * This is indexed by tranche ID minus LWTRANCHE_FIRST_USER_DEFINED, and
177 * stores the names of all dynamically-created tranches known to the current
178 * process. Any unused entries in the array will contain NULL.
179 */
180static const char **LWLockTrancheNames = NULL;
182
183/*
184 * This points to the main array of LWLocks in shared memory. Backends inherit
185 * the pointer by fork from the postmaster (except in the EXEC_BACKEND case,
186 * where we have special measures to pass it down).
187 */
189
190/*
191 * We use this structure to keep track of locked LWLocks for release
192 * during error recovery. Normally, only a few will be held at once, but
193 * occasionally the number can be much higher; for example, the pg_buffercache
194 * extension locks all buffer partitions simultaneously.
195 */
196#define MAX_SIMUL_LWLOCKS 200
197
198/* struct representing the LWLocks we're holding */
199typedef struct LWLockHandle
200{
204
205static int num_held_lwlocks = 0;
207
208/* struct representing the LWLock tranche request for named tranche */
210{
214
217
218/*
219 * NamedLWLockTrancheRequests is both the valid length of the request array,
220 * and the length of the shared-memory NamedLWLockTrancheArray later on.
221 * This variable and NamedLWLockTrancheArray are non-static so that
222 * postmaster.c can copy them to child processes in EXEC_BACKEND builds.
223 */
225
226/* points to data in shared memory: */
228
229static void InitializeLWLocks(void);
230static inline void LWLockReportWaitStart(LWLock *lock);
231static inline void LWLockReportWaitEnd(void);
232static const char *GetLWTrancheName(uint16 trancheId);
233
234#define T_NAME(lock) \
235 GetLWTrancheName((lock)->tranche)
236
237#ifdef LWLOCK_STATS
238typedef struct lwlock_stats_key
239{
240 int tranche;
241 void *instance;
242} lwlock_stats_key;
243
244typedef struct lwlock_stats
245{
246 lwlock_stats_key key;
247 int sh_acquire_count;
248 int ex_acquire_count;
249 int block_count;
250 int dequeue_self_count;
251 int spin_delay_count;
252} lwlock_stats;
253
254static HTAB *lwlock_stats_htab;
255static lwlock_stats lwlock_stats_dummy;
256#endif
257
258#ifdef LOCK_DEBUG
259bool Trace_lwlocks = false;
260
261inline static void
262PRINT_LWDEBUG(const char *where, LWLock *lock, LWLockMode mode)
263{
264 /* hide statement & context here, otherwise the log is just too verbose */
265 if (Trace_lwlocks)
266 {
268
269 ereport(LOG,
270 (errhidestmt(true),
271 errhidecontext(true),
272 errmsg_internal("%d: %s(%s %p): excl %u shared %u haswaiters %u waiters %u rOK %d",
273 MyProcPid,
274 where, T_NAME(lock), lock,
275 (state & LW_VAL_EXCLUSIVE) != 0,
277 (state & LW_FLAG_HAS_WAITERS) != 0,
278 pg_atomic_read_u32(&lock->nwaiters),
279 (state & LW_FLAG_RELEASE_OK) != 0)));
280 }
281}
282
283inline static void
284LOG_LWDEBUG(const char *where, LWLock *lock, const char *msg)
285{
286 /* hide statement & context here, otherwise the log is just too verbose */
287 if (Trace_lwlocks)
288 {
289 ereport(LOG,
290 (errhidestmt(true),
291 errhidecontext(true),
292 errmsg_internal("%s(%s %p): %s", where,
293 T_NAME(lock), lock, msg)));
294 }
295}
296
297#else /* not LOCK_DEBUG */
298#define PRINT_LWDEBUG(a,b,c) ((void)0)
299#define LOG_LWDEBUG(a,b,c) ((void)0)
300#endif /* LOCK_DEBUG */
301
302#ifdef LWLOCK_STATS
303
304static void init_lwlock_stats(void);
305static void print_lwlock_stats(int code, Datum arg);
306static lwlock_stats * get_lwlock_stats_entry(LWLock *lock);
307
308static void
309init_lwlock_stats(void)
310{
311 HASHCTL ctl;
312 static MemoryContext lwlock_stats_cxt = NULL;
313 static bool exit_registered = false;
314
315 if (lwlock_stats_cxt != NULL)
316 MemoryContextDelete(lwlock_stats_cxt);
317
318 /*
319 * The LWLock stats will be updated within a critical section, which
320 * requires allocating new hash entries. Allocations within a critical
321 * section are normally not allowed because running out of memory would
322 * lead to a PANIC, but LWLOCK_STATS is debugging code that's not normally
323 * turned on in production, so that's an acceptable risk. The hash entries
324 * are small, so the risk of running out of memory is minimal in practice.
325 */
326 lwlock_stats_cxt = AllocSetContextCreate(TopMemoryContext,
327 "LWLock stats",
329 MemoryContextAllowInCriticalSection(lwlock_stats_cxt, true);
330
331 ctl.keysize = sizeof(lwlock_stats_key);
332 ctl.entrysize = sizeof(lwlock_stats);
333 ctl.hcxt = lwlock_stats_cxt;
334 lwlock_stats_htab = hash_create("lwlock stats", 16384, &ctl,
336 if (!exit_registered)
337 {
338 on_shmem_exit(print_lwlock_stats, 0);
339 exit_registered = true;
340 }
341}
342
343static void
344print_lwlock_stats(int code, Datum arg)
345{
346 HASH_SEQ_STATUS scan;
347 lwlock_stats *lwstats;
348
349 hash_seq_init(&scan, lwlock_stats_htab);
350
351 /* Grab an LWLock to keep different backends from mixing reports */
353
354 while ((lwstats = (lwlock_stats *) hash_seq_search(&scan)) != NULL)
355 {
356 fprintf(stderr,
357 "PID %d lwlock %s %p: shacq %u exacq %u blk %u spindelay %u dequeue self %u\n",
358 MyProcPid, GetLWTrancheName(lwstats->key.tranche),
359 lwstats->key.instance, lwstats->sh_acquire_count,
360 lwstats->ex_acquire_count, lwstats->block_count,
361 lwstats->spin_delay_count, lwstats->dequeue_self_count);
362 }
363
365}
366
367static lwlock_stats *
368get_lwlock_stats_entry(LWLock *lock)
369{
370 lwlock_stats_key key;
371 lwlock_stats *lwstats;
372 bool found;
373
374 /*
375 * During shared memory initialization, the hash table doesn't exist yet.
376 * Stats of that phase aren't very interesting, so just collect operations
377 * on all locks in a single dummy entry.
378 */
379 if (lwlock_stats_htab == NULL)
380 return &lwlock_stats_dummy;
381
382 /* Fetch or create the entry. */
383 MemSet(&key, 0, sizeof(key));
384 key.tranche = lock->tranche;
385 key.instance = lock;
386 lwstats = hash_search(lwlock_stats_htab, &key, HASH_ENTER, &found);
387 if (!found)
388 {
389 lwstats->sh_acquire_count = 0;
390 lwstats->ex_acquire_count = 0;
391 lwstats->block_count = 0;
392 lwstats->dequeue_self_count = 0;
393 lwstats->spin_delay_count = 0;
394 }
395 return lwstats;
396}
397#endif /* LWLOCK_STATS */
398
399
400/*
401 * Compute number of LWLocks required by named tranches. These will be
402 * allocated in the main array.
403 */
404static int
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}
415
416/*
417 * Compute shmem space needed for LWLocks and named tranches.
418 */
419Size
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}
444
445/*
446 * Allocate shmem space for the main LWLock array and all tranches and
447 * initialize it. We also register extension LWLock tranches here.
448 */
449void
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}
485
486/*
487 * Initialize LWLocks that are fixed and those belonging to named tranches.
488 */
489static void
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}
552
553/*
554 * InitLWLockAccess - initialize backend-local state needed to hold LWLocks
555 */
556void
558{
559#ifdef LWLOCK_STATS
560 init_lwlock_stats();
561#endif
562}
563
564/*
565 * GetNamedLWLockTranche - returns the base address of LWLock from the
566 * specified tranche.
567 *
568 * Caller needs to retrieve the requested number of LWLocks starting from
569 * the base lock address returned by this API. This can be used for
570 * tranches that are requested by using RequestNamedLWLockTranche() API.
571 */
573GetNamedLWLockTranche(const char *tranche_name)
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}
598
599/*
600 * Allocate a new tranche ID.
601 */
602int
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}
616
617/*
618 * Register a dynamic tranche name in the lookup table of the current process.
619 *
620 * This routine will save a pointer to the tranche name passed as an argument,
621 * so the name should be allocated in a backend-lifetime context
622 * (shared memory, TopMemoryContext, static constant, or similar).
623 *
624 * The tranche name will be user-visible as a wait event name, so try to
625 * use a name that fits the style for those.
626 */
627void
628LWLockRegisterTranche(int tranche_id, const char *tranche_name)
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}
656
657/*
658 * RequestNamedLWLockTranche
659 * Request that extra LWLocks be allocated during postmaster
660 * startup.
661 *
662 * This may only be called via the shmem_request_hook of a library that is
663 * loaded into the postmaster via shared_preload_libraries. Calls from
664 * elsewhere will fail.
665 *
666 * The tranche name will be user-visible as a wait event name, so try to
667 * use a name that fits the style for those.
668 */
669void
670RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks)
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}
702
703/*
704 * LWLockInitialize - initialize a new lwlock; it's initially unlocked
705 */
706void
707LWLockInitialize(LWLock *lock, int tranche_id)
708{
710#ifdef LOCK_DEBUG
711 pg_atomic_init_u32(&lock->nwaiters, 0);
712#endif
713 lock->tranche = tranche_id;
714 proclist_init(&lock->waiters);
715}
716
717/*
718 * Report start of wait event for light-weight locks.
719 *
720 * This function will be used by all the light-weight lock calls which
721 * needs to wait to acquire the lock. This function distinguishes wait
722 * event based on tranche and lock id.
723 */
724static inline void
726{
728}
729
730/*
731 * Report end of wait event for light-weight locks.
732 */
733static inline void
735{
737}
738
739/*
740 * Return the name of an LWLock tranche.
741 */
742static const char *
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}
762
763/*
764 * Return an identifier for an LWLock based on the wait class and event.
765 */
766const char *
768{
769 Assert(classId == PG_WAIT_LWLOCK);
770 /* The event IDs are just tranche numbers. */
771 return GetLWTrancheName(eventId);
772}
773
774/*
775 * Internal function that tries to atomically acquire the lwlock in the passed
776 * in mode.
777 *
778 * This function will not block waiting for a lock to become free - that's the
779 * caller's job.
780 *
781 * Returns true if the lock isn't free and we need to wait.
782 */
783static bool
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}
845
846/*
847 * Lock the LWLock's wait list against concurrent activity.
848 *
849 * NB: even though the wait list is locked, non-conflicting lock operations
850 * may still happen concurrently.
851 *
852 * Time spent holding mutex should be short!
853 */
854static void
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}
899
900/*
901 * Unlock the LWLock's wait list.
902 *
903 * Note that it can be more efficient to manipulate flags and release the
904 * locks in a single atomic operation.
905 */
906static void
908{
910
911 old_state = pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_LOCKED);
912
913 Assert(old_state & LW_FLAG_LOCKED);
914}
915
916/*
917 * Wakeup all the lockers that currently have a chance to acquire the lock.
918 */
919static void
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}
1029
1030/*
1031 * Add ourselves to the end of the queue.
1032 *
1033 * NB: Mode can be LW_WAIT_UNTIL_FREE here!
1034 */
1035static void
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}
1070
1071/*
1072 * Remove ourselves from the waitlist.
1073 *
1074 * This is used if we queued ourselves because we thought we needed to sleep
1075 * but, after further checking, we discovered that we don't actually need to
1076 * do so.
1077 */
1078static void
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}
1158
1159/*
1160 * LWLockAcquire - acquire a lightweight lock in the specified mode
1161 *
1162 * If the lock is not available, sleep until it is. Returns true if the lock
1163 * was available immediately, false if we had to sleep.
1164 *
1165 * Side effect: cancel/die interrupts are held off until lock release.
1166 */
1167bool
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}
1330
1331/*
1332 * LWLockConditionalAcquire - acquire a lightweight lock in the specified mode
1333 *
1334 * If the lock is not available, return false with no side-effects.
1335 *
1336 * If successful, cancel/die interrupts are held off until lock release.
1337 */
1338bool
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}
1380
1381/*
1382 * LWLockAcquireOrWait - Acquire lock, or wait until it's free
1383 *
1384 * The semantics of this function are a bit funky. If the lock is currently
1385 * free, it is acquired in the given mode, and the function returns true. If
1386 * the lock isn't immediately free, the function waits until it is released
1387 * and returns false, but does not acquire the lock.
1388 *
1389 * This is currently used for WALWriteLock: when a backend flushes the WAL,
1390 * holding WALWriteLock, it can flush the commit records of many other
1391 * backends as a side-effect. Those other backends need to wait until the
1392 * flush finishes, but don't need to acquire the lock anymore. They can just
1393 * wake up, observe that their records have already been flushed, and return.
1394 */
1395bool
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}
1512
1513/*
1514 * Does the lwlock in its current state need to wait for the variable value to
1515 * change?
1516 *
1517 * If we don't need to wait, and it's because the value of the variable has
1518 * changed, store the current value in newval.
1519 *
1520 * *result is set to true if the lock was free, and false otherwise.
1521 */
1522static bool
1524 uint64 *newval, bool *result)
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}
1565
1566/*
1567 * LWLockWaitForVar - Wait until lock is free, or a variable is updated.
1568 *
1569 * If the lock is held and *valptr equals oldval, waits until the lock is
1570 * either freed, or the lock holder updates *valptr by calling
1571 * LWLockUpdateVar. If the lock is free on exit (immediately or after
1572 * waiting), returns true. If the lock is still held, but *valptr no longer
1573 * matches oldval, returns false and sets *newval to the current value in
1574 * *valptr.
1575 *
1576 * Note: this function ignores shared lock holders; if the lock is held
1577 * in shared mode, returns 'true'.
1578 *
1579 * Be aware that LWLockConflictsWithVar() does not include a memory barrier,
1580 * hence the caller of this function may want to rely on an explicit barrier or
1581 * an implied barrier via spinlock or LWLock to avoid memory ordering issues.
1582 */
1583bool
1585 uint64 *newval)
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}
1707
1708
1709/*
1710 * LWLockUpdateVar - Update a variable and wake up waiters atomically
1711 *
1712 * Sets *valptr to 'val', and wakes up all processes waiting for us with
1713 * LWLockWaitForVar(). It first sets the value atomically and then wakes up
1714 * waiting processes so that any process calling LWLockWaitForVar() on the same
1715 * lock is guaranteed to see the new value, and act accordingly.
1716 *
1717 * The caller must be holding the lock in exclusive mode.
1718 */
1719void
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}
1775
1776
1777/*
1778 * LWLockRelease - release a previously acquired lock
1779 */
1780void
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)
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}
1849
1850/*
1851 * LWLockReleaseClearVar - release a previously acquired lock, reset variable
1852 */
1853void
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}
1864
1865
1866/*
1867 * LWLockReleaseAll - release all currently-held locks
1868 *
1869 * Used to clean up after ereport(ERROR). An important difference between this
1870 * function and retail LWLockRelease calls is that InterruptHoldoffCount is
1871 * unchanged by this operation. This is necessary since InterruptHoldoffCount
1872 * has been set to an appropriate level earlier in error recovery. We could
1873 * decrement it below zero if we allow it to drop for each released lock!
1874 */
1875void
1877{
1878 while (num_held_lwlocks > 0)
1879 {
1880 HOLD_INTERRUPTS(); /* match the upcoming RESUME_INTERRUPTS */
1881
1883 }
1884}
1885
1886
1887/*
1888 * LWLockHeldByMe - test whether my process holds a lock in any mode
1889 *
1890 * This is meant as debug support only.
1891 */
1892bool
1894{
1895 int i;
1896
1897 for (i = 0; i < num_held_lwlocks; i++)
1898 {
1899 if (held_lwlocks[i].lock == lock)
1900 return true;
1901 }
1902 return false;
1903}
1904
1905/*
1906 * LWLockAnyHeldByMe - test whether my process holds any of an array of locks
1907 *
1908 * This is meant as debug support only.
1909 */
1910bool
1911LWLockAnyHeldByMe(LWLock *lock, int nlocks, size_t stride)
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}
1930
1931/*
1932 * LWLockHeldByMeInMode - test whether my process holds a lock in given mode
1933 *
1934 * This is meant as debug support only.
1935 */
1936bool
1938{
1939 int i;
1940
1941 for (i = 0; i < num_held_lwlocks; i++)
1942 {
1943 if (held_lwlocks[i].lock == lock && held_lwlocks[i].mode == mode)
1944 return true;
1945 }
1946 return false;
1947}
static uint32 pg_atomic_fetch_and_u32(volatile pg_atomic_uint32 *ptr, uint32 and_)
Definition: atomics.h:396
static bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval)
Definition: atomics.h:349
static uint32 pg_atomic_fetch_or_u32(volatile pg_atomic_uint32 *ptr, uint32 or_)
Definition: atomics.h:410
static uint32 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:439
static uint32 pg_atomic_fetch_sub_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
Definition: atomics.h:381
static void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition: atomics.h:221
#define pg_write_barrier()
Definition: atomics.h:157
static uint32 pg_atomic_fetch_add_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:366
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:239
static uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
Definition: atomics.h:467
static uint64 pg_atomic_exchange_u64(volatile pg_atomic_uint64 *ptr, uint64 newval)
Definition: atomics.h:503
#define PG_USED_FOR_ASSERTS_ONLY
Definition: c.h:201
#define Max(x, y)
Definition: c.h:952
#define Assert(condition)
Definition: c.h:812
uint64_t uint64
Definition: c.h:486
uint16_t uint16
Definition: c.h:484
#define pg_unreachable()
Definition: c.h:315
uint32_t uint32
Definition: c.h:485
#define lengthof(array)
Definition: c.h:742
#define MemSet(start, val, len)
Definition: c.h:974
size_t Size
Definition: c.h:559
#define fprintf(file, fmt, msg)
Definition: cubescan.l:21
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:955
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1420
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:352
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1385
int errmsg_internal(const char *fmt,...)
Definition: elog.c:1157
int errhidestmt(bool hide_stmt)
Definition: elog.c:1411
int errhidecontext(bool hide_ctx)
Definition: elog.c:1430
#define LOG
Definition: elog.h:31
#define FATAL
Definition: elog.h:41
#define PANIC
Definition: elog.h:42
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define ereport(elevel,...)
Definition: elog.h:149
int MyProcPid
Definition: globals.c:46
ProcNumber MyProcNumber
Definition: globals.c:89
bool IsUnderPostmaster
Definition: globals.c:119
#define newval
@ HASH_ENTER
Definition: hsearch.h:114
#define HASH_CONTEXT
Definition: hsearch.h:102
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_BLOBS
Definition: hsearch.h:97
static struct @161 value
long val
Definition: informix.c:689
void on_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:365
int j
Definition: isn.c:73
int i
Definition: isn.c:72
#define LW_VAL_EXCLUSIVE
Definition: lwlock.c:98
void LWLockUpdateVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
Definition: lwlock.c:1720
StaticAssertDecl(LW_VAL_EXCLUSIVE >(uint32) MAX_BACKENDS, "MAX_BACKENDS too big for lwlock.c")
static void LWLockWakeup(LWLock *lock)
Definition: lwlock.c:920
#define LW_FLAG_LOCKED
Definition: lwlock.c:96
bool LWLockHeldByMe(LWLock *lock)
Definition: lwlock.c:1893
static LWLockHandle held_lwlocks[MAX_SIMUL_LWLOCKS]
Definition: lwlock.c:206
static int LWLockTrancheNamesAllocated
Definition: lwlock.c:181
void LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val)
Definition: lwlock.c:1854
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1168
void CreateLWLocks(void)
Definition: lwlock.c:450
NamedLWLockTranche * NamedLWLockTrancheArray
Definition: lwlock.c:227
#define LW_VAL_SHARED
Definition: lwlock.c:99
static bool LWLockAttemptLock(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:784
static void LWLockWaitListLock(LWLock *lock)
Definition: lwlock.c:855
void LWLockRegisterTranche(int tranche_id, const char *tranche_name)
Definition: lwlock.c:628
LWLockPadded * GetNamedLWLockTranche(const char *tranche_name)
Definition: lwlock.c:573
bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1937
static void LWLockReportWaitEnd(void)
Definition: lwlock.c:734
struct LWLockHandle LWLockHandle
bool LWLockWaitForVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval)
Definition: lwlock.c:1584
int LWLockNewTrancheId(void)
Definition: lwlock.c:603
static const char * GetLWTrancheName(uint16 trancheId)
Definition: lwlock.c:743
#define LW_LOCK_MASK
Definition: lwlock.c:101
int NamedLWLockTrancheRequests
Definition: lwlock.c:224
void RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks)
Definition: lwlock.c:670
#define LW_FLAG_RELEASE_OK
Definition: lwlock.c:95
#define LW_FLAG_HAS_WAITERS
Definition: lwlock.c:94
#define MAX_SIMUL_LWLOCKS
Definition: lwlock.c:196
struct NamedLWLockTrancheRequest NamedLWLockTrancheRequest
static int NumLWLocksForNamedTranches(void)
Definition: lwlock.c:405
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1781
#define T_NAME(lock)
Definition: lwlock.c:234
static int num_held_lwlocks
Definition: lwlock.c:205
void LWLockReleaseAll(void)
Definition: lwlock.c:1876
static void InitializeLWLocks(void)
Definition: lwlock.c:490
void LWLockInitialize(LWLock *lock, int tranche_id)
Definition: lwlock.c:707
static int NamedLWLockTrancheRequestsAllocated
Definition: lwlock.c:216
static const char *const BuiltinTrancheNames[]
Definition: lwlock.c:126
static NamedLWLockTrancheRequest * NamedLWLockTrancheRequestArray
Definition: lwlock.c:215
static void LWLockWaitListUnlock(LWLock *lock)
Definition: lwlock.c:907
static const char ** LWLockTrancheNames
Definition: lwlock.c:180
#define LOG_LWDEBUG(a, b, c)
Definition: lwlock.c:299
bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1339
bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1396
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
LWLockPadded * MainLWLockArray
Definition: lwlock.c:188
const char * GetLWLockIdentifier(uint32 classId, uint16 eventId)
Definition: lwlock.c:767
static void LWLockDequeueSelf(LWLock *lock)
Definition: lwlock.c:1079
Size LWLockShmemSize(void)
Definition: lwlock.c:420
bool LWLockAnyHeldByMe(LWLock *lock, int nlocks, size_t stride)
Definition: lwlock.c:1911
#define LW_SHARED_MASK
Definition: lwlock.c:103
static bool LWLockConflictsWithVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval, bool *result)
Definition: lwlock.c:1523
void InitLWLockAccess(void)
Definition: lwlock.c:557
@ LW_WS_NOT_WAITING
Definition: lwlock.h:30
@ LW_WS_WAITING
Definition: lwlock.h:31
@ LW_WS_PENDING_WAKEUP
Definition: lwlock.h:32
#define LWLOCK_PADDED_SIZE
Definition: lwlock.h:62
#define BUFFER_MAPPING_LWLOCK_OFFSET
Definition: lwlock.h:104
#define NUM_LOCK_PARTITIONS
Definition: lwlock.h:97
@ LWTRANCHE_FIRST_USER_DEFINED
Definition: lwlock.h:218
@ LWTRANCHE_SHARED_TIDBITMAP
Definition: lwlock.h:200
@ LWTRANCHE_SERIAL_SLRU
Definition: lwlock.h:214
@ LWTRANCHE_PER_SESSION_DSA
Definition: lwlock.h:196
@ LWTRANCHE_PARALLEL_QUERY_DSA
Definition: lwlock.h:195
@ LWTRANCHE_COMMITTS_BUFFER
Definition: lwlock.h:180
@ LWTRANCHE_PARALLEL_VACUUM_DSA
Definition: lwlock.h:217
@ LWTRANCHE_PGSTATS_HASH
Definition: lwlock.h:204
@ LWTRANCHE_SUBTRANS_BUFFER
Definition: lwlock.h:181
@ LWTRANCHE_PER_SESSION_RECORD_TYPMOD
Definition: lwlock.h:198
@ LWTRANCHE_LAUNCHER_HASH
Definition: lwlock.h:207
@ LWTRANCHE_DSM_REGISTRY_DSA
Definition: lwlock.h:208
@ LWTRANCHE_XACT_BUFFER
Definition: lwlock.h:179
@ LWTRANCHE_DSM_REGISTRY_HASH
Definition: lwlock.h:209
@ LWTRANCHE_NOTIFY_SLRU
Definition: lwlock.h:213
@ LWTRANCHE_REPLICATION_ORIGIN_STATE
Definition: lwlock.h:188
@ LWTRANCHE_MULTIXACTOFFSET_SLRU
Definition: lwlock.h:212
@ LWTRANCHE_PARALLEL_APPEND
Definition: lwlock.h:201
@ LWTRANCHE_REPLICATION_SLOT_IO
Definition: lwlock.h:189
@ LWTRANCHE_SUBTRANS_SLRU
Definition: lwlock.h:215
@ LWTRANCHE_MULTIXACTMEMBER_SLRU
Definition: lwlock.h:211
@ LWTRANCHE_BUFFER_CONTENT
Definition: lwlock.h:187
@ LWTRANCHE_MULTIXACTMEMBER_BUFFER
Definition: lwlock.h:183
@ LWTRANCHE_NOTIFY_BUFFER
Definition: lwlock.h:184
@ LWTRANCHE_PER_SESSION_RECORD_TYPE
Definition: lwlock.h:197
@ LWTRANCHE_PREDICATE_LOCK_MANAGER
Definition: lwlock.h:193
@ LWTRANCHE_BUFFER_MAPPING
Definition: lwlock.h:191
@ LWTRANCHE_SERIAL_BUFFER
Definition: lwlock.h:185
@ LWTRANCHE_LAUNCHER_DSA
Definition: lwlock.h:206
@ LWTRANCHE_PGSTATS_DSA
Definition: lwlock.h:203
@ LWTRANCHE_PARALLEL_HASH_JOIN
Definition: lwlock.h:194
@ LWTRANCHE_COMMITTS_SLRU
Definition: lwlock.h:210
@ LWTRANCHE_PGSTATS_DATA
Definition: lwlock.h:205
@ LWTRANCHE_PER_XACT_PREDICATE_LIST
Definition: lwlock.h:202
@ LWTRANCHE_XACT_SLRU
Definition: lwlock.h:216
@ LWTRANCHE_MULTIXACTOFFSET_BUFFER
Definition: lwlock.h:182
@ LWTRANCHE_WAL_INSERT
Definition: lwlock.h:186
@ LWTRANCHE_LOCK_MANAGER
Definition: lwlock.h:192
@ LWTRANCHE_SHARED_TUPLESTORE
Definition: lwlock.h:199
@ LWTRANCHE_LOCK_FASTPATH
Definition: lwlock.h:190
#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_FIXED_LWLOCKS
Definition: lwlock.h:109
LWLockMode
Definition: lwlock.h:113
@ LW_SHARED
Definition: lwlock.h:115
@ LW_WAIT_UNTIL_FREE
Definition: lwlock.h:116
@ LW_EXCLUSIVE
Definition: lwlock.h:114
#define NUM_PREDICATELOCK_PARTITIONS
Definition: lwlock.h:101
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition: mcxt.c:1181
void * MemoryContextAllocZero(MemoryContext context, Size size)
Definition: mcxt.c:1215
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1541
MemoryContext TopMemoryContext
Definition: mcxt.c:149
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:454
void MemoryContextAllowInCriticalSection(MemoryContext context, bool allow)
Definition: mcxt.c:694
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
#define RESUME_INTERRUPTS()
Definition: miscadmin.h:135
#define HOLD_INTERRUPTS()
Definition: miscadmin.h:133
bool process_shmem_requests_in_progress
Definition: miscinit.c:1838
#define repalloc0_array(pointer, type, oldcount, count)
Definition: palloc.h:109
void * arg
static uint32 pg_nextpower2_32(uint32 num)
Definition: pg_bitutils.h:189
static PgChecksumMode mode
Definition: pg_checksums.c:55
#define NAMEDATALEN
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
void PGSemaphoreUnlock(PGSemaphore sema)
Definition: posix_sema.c:339
void PGSemaphoreLock(PGSemaphore sema)
Definition: posix_sema.c:319
uintptr_t Datum
Definition: postgres.h:64
#define MAX_BACKENDS
Definition: postmaster.h:138
#define GetPGProcByNumber(n)
Definition: proc.h:436
#define proclist_delete(list, procno, link_member)
Definition: proclist.h:187
static void proclist_init(proclist_head *list)
Definition: proclist.h:29
#define proclist_push_tail(list, procno, link_member)
Definition: proclist.h:191
#define proclist_push_head(list, procno, link_member)
Definition: proclist.h:189
#define proclist_foreach_modify(iter, lhead, link_member)
Definition: proclist.h:206
static bool proclist_is_empty(const proclist_head *list)
Definition: proclist.h:38
tree ctl
Definition: radixtree.h:1855
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:745
Size add_size(Size s1, Size s2)
Definition: shmem.c:488
Size mul_size(Size s1, Size s2)
Definition: shmem.c:505
void * ShmemAlloc(Size size)
Definition: shmem.c:147
slock_t * ShmemLock
Definition: shmem.c:87
static pg_noinline void Size size
Definition: slab.c:607
#define SpinLockRelease(lock)
Definition: spin.h:61
#define SpinLockAcquire(lock)
Definition: spin.h:59
PGPROC * MyProc
Definition: proc.c:66
Definition: dynahash.c:220
LWLockMode mode
Definition: lwlock.c:202
LWLock * lock
Definition: lwlock.c:201
Definition: lwlock.h:42
pg_atomic_uint32 state
Definition: lwlock.h:44
uint16 tranche
Definition: lwlock.h:43
proclist_head waiters
Definition: lwlock.h:45
char tranche_name[NAMEDATALEN]
Definition: lwlock.c:211
char * trancheName
Definition: lwlock.h:80
Definition: proc.h:162
uint8 lwWaitMode
Definition: proc.h:224
PGSemaphore sem
Definition: proc.h:166
uint8 lwWaiting
Definition: proc.h:223
Definition: regguts.h:323
LWLock lock
Definition: lwlock.h:70
#define PG_WAIT_LWLOCK
Definition: wait_event.h:18
static void pgstat_report_wait_start(uint32 wait_event_info)
Definition: wait_event.h:85
static void pgstat_report_wait_end(void)
Definition: wait_event.h:101
const char * name
static TimestampTz wakeup[NUM_WALRCV_WAKEUPS]
Definition: walreceiver.c:129