#include "port/atomics.h"
#include "storage/lwlocknames.h"
#include "storage/proclist_types.h"
#include "storage/lwlocklist.h"

Include dependency graph for lwlock.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	LWLock

union	LWLockPadded

Enumerations
enum	LWLockWaitState { LW_WS_NOT_WAITING , LW_WS_WAITING , LW_WS_PENDING_WAKEUP }

enum	LWLockMode { LW_EXCLUSIVE , LW_SHARED , LW_WAIT_UNTIL_FREE }

enum	BuiltinTrancheIds { LWTRANCHE_INVALID = NUM_INDIVIDUAL_LWLOCKS - 1 , LWTRANCHE_FIRST_USER_DEFINED }

Functions
	StaticAssertDecl (sizeof(LWLock)<=LWLOCK_PADDED_SIZE, "Miscalculated LWLock padding")

bool	LWLockAcquire (LWLock *lock, LWLockMode mode)

bool	LWLockConditionalAcquire (LWLock *lock, LWLockMode mode)

bool	LWLockAcquireOrWait (LWLock *lock, LWLockMode mode)

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)

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

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

void	InitLWLockAccess (void)

const char *	GetLWLockIdentifier (uint32 classId, uint16 eventId)

void	RequestNamedLWLockTranche (const char *tranche_name, int num_lwlocks)

LWLockPadded *	GetNamedLWLockTranche (const char *tranche_name)

int	LWLockNewTrancheId (const char *name)

void	LWLockInitialize (LWLock *lock, int tranche_id)

Variables
PGDLLIMPORT LWLockPadded *	MainLWLockArray

Macro Definition Documentation

◆ BUFFER_MAPPING_LWLOCK_OFFSET

#define BUFFER_MAPPING_LWLOCK_OFFSET NUM_INDIVIDUAL_LWLOCKS

Definition at line 94 of file lwlock.h.

◆ LOCK_MANAGER_LWLOCK_OFFSET

#define LOCK_MANAGER_LWLOCK_OFFSET (BUFFER_MAPPING_LWLOCK_OFFSET + NUM_BUFFER_PARTITIONS)

Definition at line 95 of file lwlock.h.

{
    LW_EXCLUSIVE,
    LW_SHARED,
    LW_WAIT_UNTIL_FREE,         /* A special mode used in PGPROC->lwWaitMode,
                                 * when waiting for lock to become free. Not
                                 * to be used as LWLockAcquire argument */
} LWLockMode;
 
 
#ifdef LOCK_DEBUG
extern PGDLLIMPORT bool Trace_lwlocks;
#endif
 
extern bool LWLockAcquire(LWLock *lock, LWLockMode mode);
extern bool LWLockConditionalAcquire(LWLock *lock, LWLockMode mode);
extern bool LWLockAcquireOrWait(LWLock *lock, LWLockMode mode);
extern void LWLockRelease(LWLock *lock);
extern void LWLockReleaseClearVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val);
extern void LWLockReleaseAll(void);
extern bool LWLockHeldByMe(LWLock *lock);
extern bool LWLockAnyHeldByMe(LWLock *lock, int nlocks, size_t stride);
extern bool LWLockHeldByMeInMode(LWLock *lock, LWLockMode mode);
 
extern bool LWLockWaitForVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 oldval, uint64 *newval);
extern void LWLockUpdateVar(LWLock *lock, pg_atomic_uint64 *valptr, uint64 val);
 
extern void InitLWLockAccess(void);
 
extern const char *GetLWLockIdentifier(uint32 classId, uint16 eventId);
 
/*
 * Extensions (or core code) can obtain an LWLocks by calling
 * RequestNamedLWLockTranche() during postmaster startup.  Subsequently,
 * call GetNamedLWLockTranche() to obtain a pointer to an array containing
 * the number of LWLocks requested.
 */
extern void RequestNamedLWLockTranche(const char *tranche_name, int num_lwlocks);
extern LWLockPadded *GetNamedLWLockTranche(const char *tranche_name);
 
/*
 * There is another, more flexible method of obtaining lwlocks. First, call
 * LWLockNewTrancheId to obtain a tranche ID; this allocates from a shared
 * counter.  Second, LWLockInitialize should be called just once per lwlock,
 * passing the tranche ID as an argument.
 */
extern int  LWLockNewTrancheId(const char *name);
extern void LWLockInitialize(LWLock *lock, int tranche_id);
 
/*
 * Every tranche ID less than NUM_INDIVIDUAL_LWLOCKS is reserved; also,
 * we reserve additional tranche IDs for builtin tranches not included in
 * the set of individual LWLocks.  A call to LWLockNewTrancheId will never
 * return a value less than LWTRANCHE_FIRST_USER_DEFINED.  The actual list of
 * built-in tranches is kept in lwlocklist.h.
 */
typedef enum BuiltinTrancheIds
{
    /*
     * LWTRANCHE_INVALID is an unused value that only exists to initialize the
     * rest of the tranches to appropriate values.
     */
    LWTRANCHE_INVALID = NUM_INDIVIDUAL_LWLOCKS - 1,
 
#define PG_LWLOCK(id, name)
#define PG_LWLOCKTRANCHE(id, name) LWTRANCHE_##id,
#include "storage/lwlocklist.h"
#undef PG_LWLOCK
#undef PG_LWLOCKTRANCHE
 
    LWTRANCHE_FIRST_USER_DEFINED,
}           BuiltinTrancheIds;
 
/*
 * Prior to PostgreSQL 9.4, we used an enum type called LWLockId to refer
 * to LWLocks.  New code should instead use LWLock *.  However, for the
 * convenience of third-party code, we include the following typedef.
 */
typedef LWLock *LWLockId;
 
#endif                          /* LWLOCK_H */

◆ LOG2_NUM_LOCK_PARTITIONS

#define LOG2_NUM_LOCK_PARTITIONS 4

Definition at line 86 of file lwlock.h.

◆ LOG2_NUM_PREDICATELOCK_PARTITIONS

#define LOG2_NUM_PREDICATELOCK_PARTITIONS 4

Definition at line 90 of file lwlock.h.

◆ LWLOCK_PADDED_SIZE

#define LWLOCK_PADDED_SIZE PG_CACHE_LINE_SIZE

Definition at line 62 of file lwlock.h.

◆ NUM_BUFFER_PARTITIONS

#define NUM_BUFFER_PARTITIONS 128

Definition at line 83 of file lwlock.h.

◆ NUM_FIXED_LWLOCKS

#define NUM_FIXED_LWLOCKS (PREDICATELOCK_MANAGER_LWLOCK_OFFSET + NUM_PREDICATELOCK_PARTITIONS)

Definition at line 99 of file lwlock.h.

◆ NUM_LOCK_PARTITIONS

#define NUM_LOCK_PARTITIONS (1 << LOG2_NUM_LOCK_PARTITIONS)

Definition at line 87 of file lwlock.h.

◆ NUM_PREDICATELOCK_PARTITIONS

#define NUM_PREDICATELOCK_PARTITIONS (1 << LOG2_NUM_PREDICATELOCK_PARTITIONS)

Definition at line 91 of file lwlock.h.

◆ PG_LWLOCK

#define PG_LWLOCK	(	id,
		name
	)

Definition at line 166 of file lwlock.h.

◆ PG_LWLOCKTRANCHE

#define PG_LWLOCKTRANCHE	(	id,
		name
	)	LWTRANCHE_##id,

Definition at line 167 of file lwlock.h.

◆ PREDICATELOCK_MANAGER_LWLOCK_OFFSET

#define PREDICATELOCK_MANAGER_LWLOCK_OFFSET (LOCK_MANAGER_LWLOCK_OFFSET + NUM_LOCK_PARTITIONS)

Definition at line 97 of file lwlock.h.

Typedef Documentation

◆ BuiltinTrancheIds

typedef enum BuiltinTrancheIds BuiltinTrancheIds

◆ LWLock

typedef struct LWLock LWLock

◆ LWLockId

typedef LWLock* LWLockId

Definition at line 180 of file lwlock.h.

◆ LWLockMode

typedef enum LWLockMode LWLockMode

◆ LWLockPadded

typedef union LWLockPadded LWLockPadded

◆ LWLockWaitState

typedef enum LWLockWaitState LWLockWaitState

Enumeration Type Documentation

◆ BuiltinTrancheIds

enum BuiltinTrancheIds

Enumerator
LWTRANCHE_INVALID
LWTRANCHE_FIRST_USER_DEFINED

Definition at line 158 of file lwlock.h.

{
    /*
     * LWTRANCHE_INVALID is an unused value that only exists to initialize the
     * rest of the tranches to appropriate values.
     */
    LWTRANCHE_INVALID = NUM_INDIVIDUAL_LWLOCKS - 1,
 
#define PG_LWLOCK(id, name)
#define PG_LWLOCKTRANCHE(id, name) LWTRANCHE_##id,
#include "storage/lwlocklist.h"
#undef PG_LWLOCK
#undef PG_LWLOCKTRANCHE
 
    LWTRANCHE_FIRST_USER_DEFINED,
}           BuiltinTrancheIds;

◆ LWLockMode

enum LWLockMode

Enumerator
LW_EXCLUSIVE
LW_SHARED
LW_WAIT_UNTIL_FREE

Definition at line 102 of file lwlock.h.

{
    LW_EXCLUSIVE,
    LW_SHARED,
    LW_WAIT_UNTIL_FREE,         /* A special mode used in PGPROC->lwWaitMode,
                                 * when waiting for lock to become free. Not
                                 * to be used as LWLockAcquire argument */
} LWLockMode;

◆ LWLockWaitState

enum LWLockWaitState

Enumerator
LW_WS_NOT_WAITING
LW_WS_WAITING
LW_WS_PENDING_WAKEUP

Definition at line 28 of file lwlock.h.

{
    LW_WS_NOT_WAITING,          /* not currently waiting / woken up */
    LW_WS_WAITING,              /* currently waiting */
    LW_WS_PENDING_WAKEUP,       /* removed from waitlist, but not yet
                                 * signalled */
}           LWLockWaitState;

Function Documentation

◆ GetLWLockIdentifier()

const char * GetLWLockIdentifier	(	uint32	classId,
		uint16	eventId
	)

extern

Definition at line 747 of file lwlock.c.

{
    Assert(classId == PG_WAIT_LWLOCK);
    /* The event IDs are just tranche numbers. */
    return GetLWTrancheName(eventId);
}

References Assert, fb(), GetLWTrancheName(), and PG_WAIT_LWLOCK.

Referenced by pgstat_get_wait_event(), test_lwlock_get_lwlock_identifier(), and test_startup_lwlocks().

◆ GetNamedLWLockTranche()

LWLockPadded * GetNamedLWLockTranche ( const char * tranche_name )

extern

Definition at line 522 of file lwlock.c.

{
    SpinLockAcquire(&LWLockTranches->lock);
    LocalNumUserDefinedTranches = LWLockTranches->num_user_defined;
    SpinLockRelease(&LWLockTranches->lock);
 
    /*
     * Obtain the position of base address of LWLock belonging to requested
     * tranche_name in MainLWLockArray.  LWLocks for user-defined tranches
     * requested with RequestNamedLWLockTranche() are placed in
     * MainLWLockArray after fixed locks.
     */
    for (int i = 0; i < LocalNumUserDefinedTranches; i++)
    {
        if (strcmp(LWLockTranches->user_defined[i].name,
                   tranche_name) == 0)
        {
            int         lock_pos = LWLockTranches->user_defined[i].main_array_idx;
 
            /*
             * GetNamedLWLockTranche() should only be used for locks requested
             * with RequestNamedLWLockTranche(), not those allocated with
             * LWLockNewTrancheId().
             */
            if (lock_pos == -1)
                elog(ERROR, "requested tranche was not registered with RequestNamedLWLockTranche()");
            return &MainLWLockArray[lock_pos];
        }
    }
 
    elog(ERROR, "requested tranche is not registered");
 
    /* just to keep compiler quiet */
    return NULL;
}

References elog, ERROR, fb(), i, LocalNumUserDefinedTranches, LWLockTrancheShmemData::lock, LWLockTranches, LWLockTrancheShmemData::main_array_idx, MainLWLockArray, LWLockTrancheShmemData::name, LWLockTrancheShmemData::num_user_defined, SpinLockAcquire(), SpinLockRelease(), and LWLockTrancheShmemData::user_defined.

Referenced by test_lwlock_tranche_lookup(), and test_startup_lwlocks().

◆ InitLWLockAccess()

void InitLWLockAccess ( void )

extern

Definition at line 506 of file lwlock.c.

{
#ifdef LWLOCK_STATS
    init_lwlock_stats();
#endif
}

References fb().

Referenced by InitAuxiliaryProcess(), and InitProcess().

◆ LWLockAcquire()

bool LWLockAcquire	(	LWLock *	lock,
		LWLockMode	mode
	)

extern

Definition at line 1150 of file lwlock.c.

{
    PGPROC     *proc = MyProc;
    bool        result = true;
    int         extraWaits = 0;
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
 
    lwstats = get_lwlock_stats_entry(lock);
#endif
 
    Assert(mode == LW_SHARED || mode == LW_EXCLUSIVE);
 
    PRINT_LWDEBUG("LWLockAcquire", lock, mode);
 
#ifdef LWLOCK_STATS
    /* Count lock acquisition attempts */
    if (mode == LW_EXCLUSIVE)
        lwstats->ex_acquire_count++;
    else
        lwstats->sh_acquire_count++;
#endif                          /* LWLOCK_STATS */
 
    /*
     * We can't wait if we haven't got a PGPROC.  This should only occur
     * during bootstrap or shared memory initialization.  Put an Assert here
     * to catch unsafe coding practices.
     */
    Assert(!(proc == NULL && IsUnderPostmaster));
 
    /* Ensure we will have room to remember the lock */
    if (num_held_lwlocks >= MAX_SIMUL_LWLOCKS)
        elog(ERROR, "too many LWLocks taken");
 
    /*
     * Lock out cancel/die interrupts until we exit the code section protected
     * by the LWLock.  This ensures that interrupts will not interfere with
     * manipulations of data structures in shared memory.
     */
    HOLD_INTERRUPTS();
 
    /*
     * Loop here to try to acquire lock after each time we are signaled by
     * LWLockRelease.
     *
     * NOTE: it might seem better to have LWLockRelease actually grant us the
     * lock, rather than retrying and possibly having to go back to sleep. But
     * in practice that is no good because it means a process swap for every
     * lock acquisition when two or more processes are contending for the same
     * lock.  Since LWLocks are normally used to protect not-very-long
     * sections of computation, a process needs to be able to acquire and
     * release the same lock many times during a single CPU time slice, even
     * in the presence of contention.  The efficiency of being able to do that
     * outweighs the inefficiency of sometimes wasting a process dispatch
     * cycle because the lock is not free when a released waiter finally gets
     * to run.  See pgsql-hackers archives for 29-Dec-01.
     */
    for (;;)
    {
        bool        mustwait;
 
        /*
         * Try to grab the lock the first time, we're not in the waitqueue
         * yet/anymore.
         */
        mustwait = LWLockAttemptLock(lock, mode);
 
        if (!mustwait)
        {
            LOG_LWDEBUG("LWLockAcquire", lock, "immediately acquired lock");
            break;              /* got the lock */
        }
 
        /*
         * Ok, at this point we couldn't grab the lock on the first try. We
         * cannot simply queue ourselves to the end of the list and wait to be
         * woken up because by now the lock could long have been released.
         * Instead add us to the queue and try to grab the lock again. If we
         * succeed we need to revert the queuing and be happy, otherwise we
         * recheck the lock. If we still couldn't grab it, we know that the
         * other locker will see our queue entries when releasing since they
         * existed before we checked for the lock.
         */
 
        /* add to the queue */
        LWLockQueueSelf(lock, mode);
 
        /* we're now guaranteed to be woken up if necessary */
        mustwait = LWLockAttemptLock(lock, mode);
 
        /* ok, grabbed the lock the second time round, need to undo queueing */
        if (!mustwait)
        {
            LOG_LWDEBUG("LWLockAcquire", lock, "acquired, undoing queue");
 
            LWLockDequeueSelf(lock);
            break;
        }
 
        /*
         * Wait until awakened.
         *
         * It is possible that we get awakened for a reason other than being
         * signaled by LWLockRelease.  If so, loop back and wait again.  Once
         * we've gotten the LWLock, re-increment the sema by the number of
         * additional signals received.
         */
        LOG_LWDEBUG("LWLockAcquire", lock, "waiting");
 
#ifdef LWLOCK_STATS
        lwstats->block_count++;
#endif
 
        LWLockReportWaitStart(lock);
        if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), mode);
 
        for (;;)
        {
            PGSemaphoreLock(proc->sem);
            if (proc->lwWaiting == LW_WS_NOT_WAITING)
                break;
            extraWaits++;
        }
 
        /* Retrying, allow LWLockRelease to release waiters again. */
        pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_WAKE_IN_PROGRESS);
 
#ifdef LOCK_DEBUG
        {
            /* not waiting anymore */
            uint32      nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
 
            Assert(nwaiters < MAX_BACKENDS);
        }
#endif
 
        if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), mode);
        LWLockReportWaitEnd();
 
        LOG_LWDEBUG("LWLockAcquire", lock, "awakened");
 
        /* Now loop back and try to acquire lock again. */
        result = false;
    }
 
    if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_ENABLED())
        TRACE_POSTGRESQL_LWLOCK_ACQUIRE(T_NAME(lock), mode);
 
    /* Add lock to list of locks held by this backend */
    held_lwlocks[num_held_lwlocks].lock = lock;
    held_lwlocks[num_held_lwlocks++].mode = mode;
 
    /*
     * Fix the process wait semaphore's count for any absorbed wakeups.
     */
    while (extraWaits-- > 0)
        PGSemaphoreUnlock(proc->sem);
 
    return result;
}

References Assert, elog, ERROR, fb(), held_lwlocks, HOLD_INTERRUPTS, IsUnderPostmaster, LWLockHandle::lock, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_WAKE_IN_PROGRESS, 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_and_u32(), pg_atomic_fetch_sub_u32(), PG_USED_FOR_ASSERTS_ONLY, PGSemaphoreLock(), PGSemaphoreUnlock(), PRINT_LWDEBUG, result, PGPROC::sem, LWLock::state, and T_NAME.

Referenced by _bt_end_vacuum(), _bt_parallel_done(), _bt_parallel_primscan_schedule(), _bt_parallel_release(), _bt_parallel_seize(), _bt_start_vacuum(), _bt_vacuum_cycleid(), abort_logical_decoding_activation(), AbsorbSyncRequests(), ActivateCommitTs(), addLSNWaiter(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AdvanceXLInsertBuffer(), alloc_object(), AlterSystemSetConfigFile(), ApplyLauncherMain(), apw_detach_shmem(), apw_dump_now(), apw_load_buffers(), AsyncNotifyFreezeXids(), asyncQueueAddEntries(), asyncQueueAdvanceTail(), asyncQueueReadAllNotifications(), asyncQueueUnregister(), AtAbort_Twophase(), AtEOXact_LogicalRepWorkers(), AtPrepare_PredicateLocks(), attach_internal(), autoprewarm_main(), autoprewarm_start_worker(), AutoVacLauncherMain(), AutoVacuumRequestWork(), AutoVacWorkerMain(), BackendPidGetProc(), BackendXidGetPid(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BecomeRegisteredListener(), btparallelrescan(), BufferAlloc(), CallShmemCallbacksAfterStartup(), check_for_freed_segments(), CheckDeadLock(), CheckForSerializableConflictOut(), CheckLogicalSlotExists(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointTwoPhase(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), CleanupInvalidationState(), ClearOldPredicateLocks(), ComputeXidHorizons(), consume_xids_shortcut(), copy_replication_slot(), CountDBBackends(), CountDBConnections(), CountOtherDBBackends(), CountUserBackends(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateInitDecodingContext(), CreatePredicateLock(), CreateRestartPoint(), DataChecksumsWorkerLauncherMain(), DataChecksumsWorkerMain(), DeactivateCommitTs(), DeleteChildTargetLocks(), DeleteLockTarget(), deleteLSNWaiter(), destroy_superblock(), DisableLogicalDecoding(), DisableLogicalDecodingIfNecessary(), 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_get_total_size_from_handle(), 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_extended(), dshash_seq_next(), dsm_attach(), dsm_create(), dsm_detach(), dsm_pin_segment(), dsm_unpin_segment(), EnableLogicalDecoding(), ensure_active_superblock(), entry_reset(), ExecParallelHashMergeCounters(), ExecParallelHashPopChunkQueue(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ExtendBufferedRelShared(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), FindAndDropRelationBuffers(), FindDeletedTupleInLocalRel(), FinishPreparedTransaction(), 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(), GetMultiXactInfo(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestMultiXactId(), GetOldestRestartPoint(), GetOldestSafeDecodingTransactionId(), GetOldestUnsummarizedLSN(), GetPredicateLockStatusData(), GetPreparedTransactionList(), GetRunningTransactionData(), GetRunningTransactionLocks(), GetSafeSnapshot(), GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetStrictOldestNonRemovableTransactionId(), GetVirtualXIDsDelayingChkpt(), GetWaitEventCustomIdentifier(), GetWaitEventCustomNames(), GetWalSummarizerState(), HaveVirtualXIDsDelayingChkpt(), init_conflict_slot_xmin(), init_dsm_registry(), initGlobalChannelTable(), InitWalSender(), InjectionPointAttach(), InjectionPointDetach(), InjectionPointList(), InstallXLogFileSegment(), InvalidateBuffer(), InvalidateObsoleteReplicationSlots(), InvalidatePossiblyObsoleteSlot(), InvalidateVictimBuffer(), IoWorkerMain(), IsInstallXLogFileSegmentActive(), IsLogicalDecodingEnabled(), IsXLogLogicalInfoEnabled(), KnownAssignedXidsCompress(), KnownAssignedXidsReset(), launcher_exit(), lock_twophase_recover(), LockAcquireExtended(), LockErrorCleanup(), LockGXact(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), LockWaiterCount(), logicalrep_launcher_attach_dshmem(), logicalrep_pa_worker_stop(), logicalrep_reset_seqsync_start_time(), 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(), multixact_redo(), MultiXactAdvanceNextMXact(), MultiXactGetCheckptMulti(), MultiXactIdSetOldestMember(), MultiXactIdSetOldestVisible(), MultiXactSetNextMXact(), PageIsPredicateLocked(), perform_relmap_update(), pg_control_checkpoint(), pg_control_init(), pg_control_recovery(), pg_control_system(), pg_create_advice_stash(), pg_drop_advice_stash(), pg_get_replication_slots(), pg_get_shmem_allocations(), pg_get_shmem_allocations_numa(), pg_notification_queue_usage(), pg_set_stashed_advice(), pg_show_replication_origin_status(), pg_start_stash_advice_worker(), pg_stash_advice_worker_main(), pg_stat_get_subscription(), pg_stat_statements_internal(), pg_xact_status(), pgaio_worker_can_timeout(), pgaio_worker_die(), pgaio_worker_register(), pgsa_attach(), pgsa_detach_shmem(), pgsa_read_from_disk(), pgsa_restore_entries(), pgsa_restore_stashes(), 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_lock_flush_cb(), pgstat_lock_reset_all_cb(), pgstat_lock_snapshot_cb(), 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(), PredicateLockShmemInit(), PredicateLockTwoPhaseFinish(), PrefetchSharedBuffer(), PrescanPreparedTransactions(), ProcArrayAdd(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcArrayClearTransaction(), ProcArrayEndTransaction(), ProcArrayGetReplicationSlotXmin(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcArrayRemove(), ProcArraySetReplicationSlotXmin(), ProcessDatabase(), ProcessSequencesForSync(), ProcessSingleRelationFork(), ProcessSyncingTablesForApply(), ProcKill(), ProcNumberGetTransactionIds(), ProcSleep(), ReachedEndOfBackup(), read_relmap_file(), ReadMultiXactIdRange(), ReadNextFullTransactionId(), ReadNextMultiXactId(), ReadReplicationSlot(), RecordNewMultiXact(), RecoverPreparedTransactions(), RegisterDynamicBackgroundWorker(), RegisterPredicateLockingXid(), RelationCacheInitFilePreInvalidate(), RelationMapCopy(), RelationMapFinishBootstrap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), relmap_redo(), RemoveScratchTarget(), ReplicationSlotAcquire(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotName(), ReplicationSlotRelease(), ReplicationSlotReserveWal(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), replorigin_advance(), replorigin_get_progress(), replorigin_session_advance(), replorigin_session_get_progress(), replorigin_session_reset_internal(), replorigin_session_setup(), replorigin_state_clear(), RequestDisableLogicalDecoding(), reserve_wal_for_local_slot(), ResetInstallXLogFileSegmentActive(), resize(), RestoreScratchTarget(), restoreTwoPhaseData(), SaveSlotToPath(), SearchNamedReplicationSlot(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialSetActiveSerXmin(), set_indexsafe_procflags(), set_val_in_shmem(), SetCommitTsLimit(), SetDataChecksumsOff(), SetDataChecksumsOn(), SetDataChecksumsOnInProgress(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetNextObjectId(), SetOldestOffset(), SetTransactionIdLimit(), SetXidCommitTsInPage(), SharedInvalBackendInit(), ShmemInitStruct(), SICleanupQueue(), SIGetDataEntries(), SignalBackends(), SignalRecoveryConflict(), SignalRecoveryConflictWithDatabase(), SignalRecoveryConflictWithVirtualXID(), SIInsertDataEntries(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruTruncate(), SimpleLruWaitIO(), SimpleLruWriteAll(), SimpleLruZeroAndWritePage(), SlruDeleteSegment(), SlruInternalWritePage(), SnapBuildInitialSnapshot(), ss_get_location(), StandbyRecoverPreparedTransactions(), StandbySlotsHaveCaughtup(), StartDataChecksumsWorkerLauncher(), StartupDecodingContext(), StartupSUBTRANS(), StartupXLOG(), sts_parallel_scan_next(), SubTransSetParent(), SummarizeOldestCommittedSxact(), SummarizeWAL(), SwitchIntoArchiveRecovery(), synchronize_one_slot(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepReleaseWaiters(), SyncRepUpdateSyncStandbysDefined(), SyncRepWaitForLSN(), TablespaceCreateDbspace(), tbm_shared_iterate(), TerminateBackgroundWorker(), TerminateBackgroundWorkersForDatabase(), TerminateOtherDBBackends(), test_custom_stats_fixed_reset_all_cb(), test_custom_stats_fixed_snapshot_cb(), test_custom_stats_fixed_update(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_write(), test_startup_lwlocks(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TransactionTreeSetCommitTsData(), TransferPredicateLocksToNewTarget(), TrimCLOG(), TrimMultiXact(), TruncateMultiXact(), TwoPhaseGetGXact(), TwoPhaseGetOldestXidInCommit(), TwoPhaseGetXidByVirtualXID(), update_cached_xid_range(), update_synced_slots_inactive_since(), UpdateLogicalDecodingStatusEndOfRecovery(), UpdateMinRecoveryPoint(), vac_truncate_clog(), vacuum_rel(), VacuumUpdateCosts(), VirtualXactLock(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), wait_for_table_state_change(), wait_for_worker_state_change(), WaitEventCustomNew(), WaitForAllTransactionsToFinish(), WaitForReplicationWorkerAttach(), WaitForWalSummarization(), wakeupWaiters(), WakeupWalSummarizer(), WALInsertLockAcquire(), WALInsertLockAcquireExclusive(), WalSummarizerMain(), WalSummarizerShutdown(), write_relcache_init_file(), xact_redo(), XidCacheRemoveRunningXids(), xlog_redo(), XLogBackgroundFlush(), and XLogReportParameters().

◆ LWLockAcquireOrWait()

bool LWLockAcquireOrWait	(	LWLock *	lock,
		LWLockMode	mode
	)

extern

Definition at line 1378 of file lwlock.c.

{
    PGPROC     *proc = MyProc;
    bool        mustwait;
    int         extraWaits = 0;
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
 
    lwstats = get_lwlock_stats_entry(lock);
#endif
 
    Assert(mode == LW_SHARED || mode == LW_EXCLUSIVE);
 
    PRINT_LWDEBUG("LWLockAcquireOrWait", lock, mode);
 
    /* Ensure we will have room to remember the lock */
    if (num_held_lwlocks >= MAX_SIMUL_LWLOCKS)
        elog(ERROR, "too many LWLocks taken");
 
    /*
     * Lock out cancel/die interrupts until we exit the code section protected
     * by the LWLock.  This ensures that interrupts will not interfere with
     * manipulations of data structures in shared memory.
     */
    HOLD_INTERRUPTS();
 
    /*
     * NB: We're using nearly the same twice-in-a-row lock acquisition
     * protocol as LWLockAcquire(). Check its comments for details.
     */
    mustwait = LWLockAttemptLock(lock, mode);
 
    if (mustwait)
    {
        LWLockQueueSelf(lock, LW_WAIT_UNTIL_FREE);
 
        mustwait = LWLockAttemptLock(lock, mode);
 
        if (mustwait)
        {
            /*
             * Wait until awakened.  Like in LWLockAcquire, be prepared for
             * bogus wakeups.
             */
            LOG_LWDEBUG("LWLockAcquireOrWait", lock, "waiting");
 
#ifdef LWLOCK_STATS
            lwstats->block_count++;
#endif
 
            LWLockReportWaitStart(lock);
            if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
                TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), mode);
 
            for (;;)
            {
                PGSemaphoreLock(proc->sem);
                if (proc->lwWaiting == LW_WS_NOT_WAITING)
                    break;
                extraWaits++;
            }
 
#ifdef LOCK_DEBUG
            {
                /* not waiting anymore */
                uint32      nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
 
                Assert(nwaiters < MAX_BACKENDS);
            }
#endif
            if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
                TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), mode);
            LWLockReportWaitEnd();
 
            LOG_LWDEBUG("LWLockAcquireOrWait", lock, "awakened");
        }
        else
        {
            LOG_LWDEBUG("LWLockAcquireOrWait", lock, "acquired, undoing queue");
 
            /*
             * Got lock in the second attempt, undo queueing. We need to treat
             * this as having successfully acquired the lock, otherwise we'd
             * not necessarily wake up people we've prevented from acquiring
             * the lock.
             */
            LWLockDequeueSelf(lock);
        }
    }
 
    /*
     * Fix the process wait semaphore's count for any absorbed wakeups.
     */
    while (extraWaits-- > 0)
        PGSemaphoreUnlock(proc->sem);
 
    if (mustwait)
    {
        /* Failed to get lock, so release interrupt holdoff */
        RESUME_INTERRUPTS();
        LOG_LWDEBUG("LWLockAcquireOrWait", lock, "failed");
        if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_FAIL(T_NAME(lock), mode);
    }
    else
    {
        LOG_LWDEBUG("LWLockAcquireOrWait", lock, "succeeded");
        /* Add lock to list of locks held by this backend */
        held_lwlocks[num_held_lwlocks].lock = lock;
        held_lwlocks[num_held_lwlocks++].mode = mode;
        if (TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_ACQUIRE_OR_WAIT(T_NAME(lock), mode);
    }
 
    return !mustwait;
}

References Assert, elog, ERROR, fb(), 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
	)

extern

Definition at line 1903 of file lwlock.c.

{
    char       *held_lock_addr;
    char       *begin;
    char       *end;
    int         i;
 
    begin = (char *) lock;
    end = begin + nlocks * stride;
    for (i = 0; i < num_held_lwlocks; i++)
    {
        held_lock_addr = (char *) held_lwlocks[i].lock;
        if (held_lock_addr >= begin &&
            held_lock_addr < end &&
            (held_lock_addr - begin) % stride == 0)
            return true;
    }
    return false;
}

References fb(), held_lwlocks, i, and num_held_lwlocks.

◆ LWLockConditionalAcquire()

bool LWLockConditionalAcquire	(	LWLock *	lock,
		LWLockMode	mode
	)

extern

Definition at line 1321 of file lwlock.c.

{
    bool        mustwait;
 
    Assert(mode == LW_SHARED || mode == LW_EXCLUSIVE);
 
    PRINT_LWDEBUG("LWLockConditionalAcquire", lock, mode);
 
    /* Ensure we will have room to remember the lock */
    if (num_held_lwlocks >= MAX_SIMUL_LWLOCKS)
        elog(ERROR, "too many LWLocks taken");
 
    /*
     * Lock out cancel/die interrupts until we exit the code section protected
     * by the LWLock.  This ensures that interrupts will not interfere with
     * manipulations of data structures in shared memory.
     */
    HOLD_INTERRUPTS();
 
    /* Check for the lock */
    mustwait = LWLockAttemptLock(lock, mode);
 
    if (mustwait)
    {
        /* Failed to get lock, so release interrupt holdoff */
        RESUME_INTERRUPTS();
 
        LOG_LWDEBUG("LWLockConditionalAcquire", lock, "failed");
        if (TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_FAIL(T_NAME(lock), mode);
    }
    else
    {
        /* Add lock to list of locks held by this backend */
        held_lwlocks[num_held_lwlocks].lock = lock;
        held_lwlocks[num_held_lwlocks++].mode = mode;
        if (TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_CONDACQUIRE(T_NAME(lock), mode);
    }
    return !mustwait;
}

References Assert, elog, ERROR, fb(), 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 pgaio_worker_submit(), pgstat_io_flush_cb(), pgstat_lock_entry(), pgstat_lock_entry_shared(), pgstat_lock_flush_cb(), pgstat_slru_flush_cb(), pgstat_wal_flush_cb(), ProcArrayEndTransaction(), SimpleLruWaitIO(), ss_report_location(), TransactionIdSetPageStatus(), and XLogNeedsFlush().

◆ LWLockHeldByMe()

bool LWLockHeldByMe ( LWLock * lock )

extern

Definition at line 1885 of file lwlock.c.

{
    int         i;
 
    for (i = 0; i < num_held_lwlocks; i++)
    {
        if (held_lwlocks[i].lock == lock)
            return true;
    }
    return false;
}

References held_lwlocks, i, and num_held_lwlocks.

Referenced by alloc_object(), autovac_recalculate_workers_for_balance(), check_for_freed_segments_locked(), CompactCheckpointerRequestQueue(), delete_item(), DeleteLockTarget(), dshash_dump(), ensure_active_superblock(), get_best_segment(), GetLockHoldersAndWaiters(), GetOldestSafeDecodingTransactionId(), GetSnapshotDataReuse(), init_span(), InvalidatePossiblyObsoleteSlot(), logicalrep_pa_worker_count(), logicalrep_sync_worker_count(), logicalrep_worker_find(), logicalrep_worker_wakeup_ptr(), logicalrep_workers_find(), MaintainLatestCompletedXid(), MaintainLatestCompletedXidRecovery(), make_new_segment(), OnConflict_CheckForSerializationFailure(), pgsa_clear_advice_string(), pgsa_set_advice_string(), ProcArrayEndTransaction(), ProcArraySetReplicationSlotXmin(), ProcSleep(), ReleaseOneSerializableXact(), RemoveScratchTarget(), RemoveTargetIfNoLongerUsed(), resize(), RestoreScratchTarget(), SetNewSxactGlobalXmin(), SlruSelectLRUPage(), test_slru_page_readonly(), TransactionIdInRecentPast(), TwoPhaseGetGXact(), and VacuumUpdateCosts().

◆ LWLockHeldByMeInMode()

bool LWLockHeldByMeInMode	(	LWLock *	lock,
		LWLockMode	mode
	)

extern

Definition at line 1929 of file lwlock.c.

{
    int         i;
 
    for (i = 0; i < num_held_lwlocks; i++)
    {
        if (held_lwlocks[i].lock == lock && held_lwlocks[i].mode == mode)
            return true;
    }
    return false;
}

References held_lwlocks, i, mode, and num_held_lwlocks.

Referenced by DeleteLockTarget(), dshash_delete_current(), dshash_delete_entry(), dshash_seq_next(), InvalidatePossiblyObsoleteSlot(), JoinWaitQueue(), logicalrep_worker_cleanup(), logicalrep_worker_stop_internal(), MarkAsPreparingGuts(), pgaio_worker_choose_idle(), pgaio_worker_submission_queue_consume(), pgaio_worker_submission_queue_depth(), pgaio_worker_submission_queue_insert(), pgsa_create_stash(), pgsa_drop_stash(), pgsa_reset_all_stashes(), pgstat_create_replslot(), pgstat_drop_replslot(), PrepareRedoAdd(), PrepareRedoRemoveFull(), ProcArrayEndTransactionInternal(), ProcessTwoPhaseBuffer(), RemoveGXact(), ReplicationSlotsComputeRequiredXmin(), SimpleLruReadPage(), SimpleLruZeroPage(), SlruInternalWritePage(), SyncRepWakeQueue(), TransactionIdSetPageStatusInternal(), TransactionIdSetStatusBit(), TransferPredicateLocksToNewTarget(), and write_relmap_file().

◆ LWLockInitialize()

void LWLockInitialize	(	LWLock *	lock,
		int	tranche_id
	)

extern

Definition at line 670 of file lwlock.c.

{
    /* verify the tranche_id is valid */
    (void) GetLWTrancheName(tranche_id);
 
    pg_atomic_init_u32(&lock->state, 0);
#ifdef LOCK_DEBUG
    pg_atomic_init_u32(&lock->nwaiters, 0);
#endif
    lock->tranche = tranche_id;
    proclist_init(&lock->waiters);
}

References fb(), GetLWTrancheName(), pg_atomic_init_u32(), proclist_init(), LWLock::state, LWLock::tranche, and LWLock::waiters.

Referenced by apw_init_state(), btinitparallelscan(), create_internal(), dshash_create(), ExecAppendInitializeDSM(), ExecHashJoinInitializeDSM(), init_tdr_dsm(), InitShmemAllocator(), LWLockShmemInit(), pgsa_init_shared_state(), pgss_shmem_init(), pgstat_archiver_init_shmem_cb(), pgstat_bgwriter_init_shmem_cb(), pgstat_checkpointer_init_shmem_cb(), pgstat_init_entry(), pgstat_io_init_shmem_cb(), pgstat_lock_init_shmem_cb(), pgstat_slru_init_shmem_cb(), pgstat_wal_init_shmem_cb(), PredicateLockShmemInit(), ProcGlobalShmemInit(), ReplicationOriginShmemInit(), ReplicationSlotsShmemInit(), shmem_slru_init(), sts_initialize(), tbm_prepare_shared_iterate(), test_custom_stats_fixed_init_shmem_cb(), test_lwlock_initialize(), and XLOGShmemInit().

◆ LWLockNewTrancheId()

int LWLockNewTrancheId ( const char * name )

extern

Definition at line 562 of file lwlock.c.

{
    int         idx;
 
    if (!name)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("tranche name cannot be NULL")));
 
    if (strlen(name) >= NAMEDATALEN)
        ereport(ERROR,
                (errcode(ERRCODE_NAME_TOO_LONG),
                 errmsg("tranche name too long"),
                 errdetail("LWLock tranche names must be no longer than %d bytes.",
                           NAMEDATALEN - 1)));
 
    /* The counter and the tranche names are protected by the spinlock */
    SpinLockAcquire(&LWLockTranches->lock);
 
    if (LWLockTranches->num_user_defined >= MAX_USER_DEFINED_TRANCHES)
    {
        SpinLockRelease(&LWLockTranches->lock);
        ereport(ERROR,
                (errmsg("maximum number of tranches already registered"),
                 errdetail("No more than %d tranches may be registered.",
                           MAX_USER_DEFINED_TRANCHES)));
    }
 
    /* Allocate an entry in the user_defined array */
    idx = (LWLockTranches->num_user_defined)++;
 
    /* update our local copy while we're at it */
    LocalNumUserDefinedTranches = LWLockTranches->num_user_defined;
 
    /* Initialize it */
    strlcpy(LWLockTranches->user_defined[idx].name, name, NAMEDATALEN);
 
    /* the locks are not in the main array */
    LWLockTranches->user_defined[idx].main_array_idx = -1;
 
    SpinLockRelease(&LWLockTranches->lock);
 
    return LWTRANCHE_FIRST_USER_DEFINED + idx;
}

References ereport, errcode(), errdetail(), errmsg, ERROR, fb(), idx(), LocalNumUserDefinedTranches, LWLockTrancheShmemData::lock, LWLockTranches, LWTRANCHE_FIRST_USER_DEFINED, LWLockTrancheShmemData::main_array_idx, MAX_USER_DEFINED_TRANCHES, LWLockTrancheShmemData::name, name, NAMEDATALEN, LWLockTrancheShmemData::num_user_defined, SpinLockAcquire(), SpinLockRelease(), strlcpy(), and LWLockTrancheShmemData::user_defined.

Referenced by apw_init_state(), GetNamedDSA(), GetNamedDSHash(), init_tdr_dsm(), init_tranche(), pgsa_init_shared_state(), pgss_shmem_init(), shmem_slru_init(), test_basic(), test_create(), test_empty(), test_lwlock_tranche_create(), and test_random().

◆ LWLockRelease()

void LWLockRelease ( LWLock * lock )

extern

Definition at line 1767 of file lwlock.c.

{
    LWLockMode  mode;
    uint32      oldstate;
    bool        check_waiters;
    int         i;
 
    /*
     * Remove lock from list of locks held.  Usually, but not always, it will
     * be the latest-acquired lock; so search array backwards.
     */
    for (i = num_held_lwlocks; --i >= 0;)
        if (lock == held_lwlocks[i].lock)
            break;
 
    if (i < 0)
        elog(ERROR, "lock %s is not held", T_NAME(lock));
 
    mode = held_lwlocks[i].mode;
 
    num_held_lwlocks--;
    for (; i < num_held_lwlocks; i++)
        held_lwlocks[i] = held_lwlocks[i + 1];
 
    PRINT_LWDEBUG("LWLockRelease", lock, mode);
 
    /*
     * Release my hold on lock, after that it can immediately be acquired by
     * others, even if we still have to wakeup other waiters.
     */
    if (mode == LW_EXCLUSIVE)
        oldstate = pg_atomic_sub_fetch_u32(&lock->state, LW_VAL_EXCLUSIVE);
    else
        oldstate = pg_atomic_sub_fetch_u32(&lock->state, LW_VAL_SHARED);
 
    /* nobody else can have that kind of lock */
    Assert(!(oldstate & LW_VAL_EXCLUSIVE));
 
    if (TRACE_POSTGRESQL_LWLOCK_RELEASE_ENABLED())
        TRACE_POSTGRESQL_LWLOCK_RELEASE(T_NAME(lock));
 
    /*
     * Check if we're still waiting for backends to get scheduled, if so,
     * don't wake them up again.
     */
    if ((oldstate & LW_FLAG_HAS_WAITERS) &&
        !(oldstate & LW_FLAG_WAKE_IN_PROGRESS) &&
        (oldstate & LW_LOCK_MASK) == 0)
        check_waiters = true;
    else
        check_waiters = false;
 
    /*
     * As waking up waiters requires the spinlock to be acquired, only do so
     * if necessary.
     */
    if (check_waiters)
    {
        /* XXX: remove before commit? */
        LOG_LWDEBUG("LWLockRelease", lock, "releasing waiters");
        LWLockWakeup(lock);
    }
 
    /*
     * Now okay to allow cancel/die interrupts.
     */
    RESUME_INTERRUPTS();
}

References Assert, elog, ERROR, fb(), held_lwlocks, i, LOG_LWDEBUG, LW_EXCLUSIVE, LW_FLAG_HAS_WAITERS, LW_FLAG_WAKE_IN_PROGRESS, 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_parallel_done(), _bt_parallel_primscan_schedule(), _bt_parallel_release(), _bt_parallel_seize(), _bt_start_vacuum(), _bt_vacuum_cycleid(), abort_logical_decoding_activation(), AbsorbSyncRequests(), ActivateCommitTs(), addLSNWaiter(), AdvanceNextFullTransactionIdPastXid(), AdvanceOldestClogXid(), AdvanceOldestCommitTsXid(), AdvanceXLInsertBuffer(), alloc_object(), AlterSystemSetConfigFile(), ApplyLauncherMain(), apw_detach_shmem(), apw_dump_now(), apw_load_buffers(), AsyncNotifyFreezeXids(), asyncQueueAddEntries(), asyncQueueAdvanceTail(), asyncQueueProcessPageEntries(), asyncQueueReadAllNotifications(), asyncQueueUnregister(), AtAbort_Twophase(), AtEOXact_LogicalRepWorkers(), AtPrepare_PredicateLocks(), attach_internal(), autoprewarm_main(), autoprewarm_start_worker(), AutoVacLauncherMain(), AutoVacuumRequestWork(), AutoVacWorkerMain(), BackendPidGetProc(), BackendXidGetPid(), BecomeLockGroupLeader(), BecomeLockGroupMember(), BecomeRegisteredListener(), btparallelrescan(), BufferAlloc(), CallShmemCallbacksAfterStartup(), check_for_freed_segments(), CheckDeadLock(), CheckForSerializableConflictOut(), CheckLogicalSlotExists(), CheckPointPredicate(), CheckPointRelationMap(), CheckPointReplicationOrigin(), CheckPointReplicationSlots(), CheckPointTwoPhase(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), choose_next_subplan_for_leader(), choose_next_subplan_for_worker(), CleanupInvalidationState(), ClearOldPredicateLocks(), ComputeXidHorizons(), consume_xids_shortcut(), copy_replication_slot(), CountDBBackends(), CountDBConnections(), CountOtherDBBackends(), CountUserBackends(), CreateCheckPoint(), CreateEndOfRecoveryRecord(), CreateInitDecodingContext(), CreatePredicateLock(), CreateRestartPoint(), DataChecksumsWorkerLauncherMain(), DataChecksumsWorkerMain(), DeactivateCommitTs(), DeleteChildTargetLocks(), DeleteLockTarget(), deleteLSNWaiter(), destroy_superblock(), DisableLogicalDecoding(), DisableLogicalDecodingIfNecessary(), 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_get_total_size_from_handle(), 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_extended(), dshash_release_lock(), dshash_seq_next(), dshash_seq_term(), dsm_attach(), dsm_create(), dsm_detach(), dsm_pin_segment(), dsm_unpin_segment(), EnableLogicalDecoding(), ensure_active_superblock(), entry_reset(), ExecParallelHashMergeCounters(), ExecParallelHashPopChunkQueue(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExpireAllKnownAssignedTransactionIds(), ExpireOldKnownAssignedTransactionIds(), ExpireTreeKnownAssignedTransactionIds(), ExtendBufferedRelShared(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), FastPathGetRelationLockEntry(), FastPathTransferRelationLocks(), find_multixact_start(), FindAndDropRelationBuffers(), FindDeletedTupleInLocalRel(), FinishPreparedTransaction(), 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(), GetMultiXactInfo(), GetNewMultiXactId(), GetNewObjectId(), GetNewTransactionId(), GetOldestActiveTransactionId(), GetOldestMultiXactId(), GetOldestRestartPoint(), GetOldestSafeDecodingTransactionId(), GetOldestUnsummarizedLSN(), GetPredicateLockStatusData(), GetPreparedTransactionList(), GetRunningTransactionLocks(), GetSafeSnapshot(), GetSafeSnapshotBlockingPids(), GetSerializableTransactionSnapshotInt(), GetSnapshotData(), GetStrictOldestNonRemovableTransactionId(), GetVirtualXIDsDelayingChkpt(), GetWaitEventCustomIdentifier(), GetWaitEventCustomNames(), GetWalSummarizerState(), HaveVirtualXIDsDelayingChkpt(), init_conflict_slot_xmin(), init_dsm_registry(), initGlobalChannelTable(), InitWalSender(), InjectionPointAttach(), InjectionPointDetach(), InjectionPointList(), InstallXLogFileSegment(), InvalidateBuffer(), InvalidateObsoleteReplicationSlots(), InvalidatePossiblyObsoleteSlot(), InvalidateVictimBuffer(), IoWorkerMain(), IsInstallXLogFileSegmentActive(), IsLogicalDecodingEnabled(), IsXLogLogicalInfoEnabled(), KnownAssignedXidsCompress(), KnownAssignedXidsReset(), launcher_exit(), lock_twophase_recover(), LockAcquireExtended(), LockErrorCleanup(), LockGXact(), LockHasWaiters(), LockRefindAndRelease(), LockRelease(), LockReleaseAll(), LockWaiterCount(), logicalrep_launcher_attach_dshmem(), logicalrep_pa_worker_stop(), logicalrep_reset_seqsync_start_time(), 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(), 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_create_advice_stash(), pg_drop_advice_stash(), pg_get_replication_slots(), pg_get_shmem_allocations(), pg_get_shmem_allocations_numa(), pg_notification_queue_usage(), pg_set_stashed_advice(), pg_show_replication_origin_status(), pg_start_stash_advice_worker(), pg_stash_advice_worker_main(), pg_stat_get_subscription(), pg_stat_statements_internal(), pg_xact_status(), pgaio_worker_can_timeout(), pgaio_worker_die(), pgaio_worker_register(), pgaio_worker_submit(), pgsa_attach(), pgsa_detach_shmem(), pgsa_read_from_disk(), pgsa_restore_entries(), pgsa_restore_stashes(), 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_flush_cb(), pgstat_lock_reset_all_cb(), pgstat_lock_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(), PredicateLockShmemInit(), PredicateLockTwoPhaseFinish(), PrefetchSharedBuffer(), PrescanPreparedTransactions(), ProcArrayAdd(), ProcArrayApplyRecoveryInfo(), ProcArrayApplyXidAssignment(), ProcArrayClearTransaction(), ProcArrayEndTransaction(), ProcArrayGetReplicationSlotXmin(), ProcArrayGroupClearXid(), ProcArrayInstallImportedXmin(), ProcArrayInstallRestoredXmin(), ProcArrayRemove(), ProcArraySetReplicationSlotXmin(), ProcessDatabase(), ProcessSequencesForSync(), ProcessSingleRelationFork(), ProcessSyncingTablesForApply(), ProcKill(), ProcNumberGetTransactionIds(), ProcSleep(), ReachedEndOfBackup(), read_relmap_file(), ReadMultiXactIdRange(), ReadNextFullTransactionId(), ReadNextMultiXactId(), ReadReplicationSlot(), RecordNewMultiXact(), RecoverPreparedTransactions(), RegisterDynamicBackgroundWorker(), RegisterPredicateLockingXid(), RelationCacheInitFilePostInvalidate(), RelationMapCopy(), RelationMapFinishBootstrap(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), relmap_redo(), RemoveScratchTarget(), ReplicationSlotAcquire(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotName(), ReplicationSlotRelease(), ReplicationSlotReserveWal(), ReplicationSlotsComputeLogicalRestartLSN(), ReplicationSlotsComputeRequiredLSN(), ReplicationSlotsComputeRequiredXmin(), ReplicationSlotsCountDBSlots(), ReplicationSlotsDropDBSlots(), replorigin_advance(), replorigin_get_progress(), replorigin_session_advance(), replorigin_session_get_progress(), replorigin_session_reset_internal(), replorigin_session_setup(), replorigin_state_clear(), RequestDisableLogicalDecoding(), reserve_wal_for_local_slot(), ResetInstallXLogFileSegmentActive(), resize(), RestoreScratchTarget(), restoreTwoPhaseData(), SaveSlotToPath(), SearchNamedReplicationSlot(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SerialSetActiveSerXmin(), set_indexsafe_procflags(), set_val_in_shmem(), SetCommitTsLimit(), SetDataChecksumsOff(), SetDataChecksumsOn(), SetDataChecksumsOnInProgress(), SetInstallXLogFileSegmentActive(), SetMultiXactIdLimit(), SetNextObjectId(), SetOldestOffset(), SetTransactionIdLimit(), SetXidCommitTsInPage(), SharedInvalBackendInit(), ShmemInitStruct(), SICleanupQueue(), SIGetDataEntries(), SignalBackends(), SignalRecoveryConflict(), SignalRecoveryConflictWithDatabase(), SignalRecoveryConflictWithVirtualXID(), SIInsertDataEntries(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruTruncate(), SimpleLruWaitIO(), SimpleLruWriteAll(), SimpleLruZeroAndWritePage(), SlruDeleteSegment(), SlruInternalWritePage(), SnapBuildInitialSnapshot(), ss_get_location(), ss_report_location(), StandbyRecoverPreparedTransactions(), StandbySlotsHaveCaughtup(), StartDataChecksumsWorkerLauncher(), StartupDecodingContext(), StartupSUBTRANS(), StartupXLOG(), sts_parallel_scan_next(), SubTransGetParent(), SubTransSetParent(), SummarizeOldestCommittedSxact(), SummarizeWAL(), SwitchIntoArchiveRecovery(), synchronize_one_slot(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepReleaseWaiters(), SyncRepUpdateSyncStandbysDefined(), SyncRepWaitForLSN(), TablespaceCreateDbspace(), tbm_shared_iterate(), TerminateBackgroundWorker(), TerminateBackgroundWorkersForDatabase(), TerminateOtherDBBackends(), test_custom_stats_fixed_reset_all_cb(), test_custom_stats_fixed_snapshot_cb(), test_custom_stats_fixed_update(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_readonly(), test_slru_page_write(), test_startup_lwlocks(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdGetStatus(), TransactionIdIsInProgress(), TransactionIdSetPageStatus(), TransactionTreeSetCommitTsData(), TransferPredicateLocksToNewTarget(), TrimCLOG(), TrimMultiXact(), TruncateMultiXact(), TwoPhaseGetGXact(), TwoPhaseGetOldestXidInCommit(), TwoPhaseGetXidByVirtualXID(), update_cached_xid_range(), update_synced_slots_inactive_since(), UpdateLogicalDecodingStatusEndOfRecovery(), UpdateMinRecoveryPoint(), vac_truncate_clog(), vacuum_rel(), VacuumUpdateCosts(), VirtualXactLock(), VirtualXactLockTableCleanup(), VirtualXactLockTableInsert(), wait_for_table_state_change(), wait_for_worker_state_change(), WaitEventCustomNew(), WaitForAllTransactionsToFinish(), WaitForReplicationWorkerAttach(), WaitForWalSummarization(), wakeupWaiters(), WakeupWalSummarizer(), WalSummarizerMain(), WalSummarizerShutdown(), write_relcache_init_file(), xact_redo(), XidCacheRemoveRunningXids(), xlog_redo(), XLogBackgroundFlush(), XLogFlush(), XLogNeedsFlush(), and XLogReportParameters().

◆ LWLockReleaseAll()

void LWLockReleaseAll ( void )

extern

Definition at line 1866 of file lwlock.c.

{
    while (num_held_lwlocks > 0)
    {
        HOLD_INTERRUPTS();      /* match the upcoming RESUME_INTERRUPTS */
 
        LWLockRelease(held_lwlocks[num_held_lwlocks - 1].lock);
    }
 
    Assert(num_held_lwlocks == 0);
}

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

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

◆ LWLockReleaseClearVar()

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

extern

Definition at line 1840 of file lwlock.c.

{
    /*
     * Note that pg_atomic_exchange_u64 is a full barrier, so we're guaranteed
     * that the variable is updated before releasing the lock.
     */
    pg_atomic_exchange_u64(valptr, val);
 
    LWLockRelease(lock);
}

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

Referenced by WALInsertLockRelease().

◆ LWLockUpdateVar()

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

extern

Definition at line 1702 of file lwlock.c.

{
    proclist_head wakeup;
    proclist_mutable_iter iter;
 
    PRINT_LWDEBUG("LWLockUpdateVar", lock, LW_EXCLUSIVE);
 
    /*
     * Note that pg_atomic_exchange_u64 is a full barrier, so we're guaranteed
     * that the variable is updated before waking up waiters.
     */
    pg_atomic_exchange_u64(valptr, val);
 
    proclist_init(&wakeup);
 
    LWLockWaitListLock(lock);
 
    Assert(pg_atomic_read_u32(&lock->state) & LW_VAL_EXCLUSIVE);
 
    /*
     * See if there are any LW_WAIT_UNTIL_FREE waiters that need to be woken
     * up. They are always in the front of the queue.
     */
    proclist_foreach_modify(iter, &lock->waiters, lwWaitLink)
    {
        PGPROC     *waiter = GetPGProcByNumber(iter.cur);
 
        if (waiter->lwWaitMode != LW_WAIT_UNTIL_FREE)
            break;
 
        proclist_delete(&lock->waiters, iter.cur, lwWaitLink);
        proclist_push_tail(&wakeup, iter.cur, lwWaitLink);
 
        /* see LWLockWakeup() */
        Assert(waiter->lwWaiting == LW_WS_WAITING);
        waiter->lwWaiting = LW_WS_PENDING_WAKEUP;
    }
 
    /* We are done updating shared state of the lock itself. */
    LWLockWaitListUnlock(lock);
 
    /*
     * Awaken any waiters I removed from the queue.
     */
    proclist_foreach_modify(iter, &wakeup, lwWaitLink)
    {
        PGPROC     *waiter = GetPGProcByNumber(iter.cur);
 
        proclist_delete(&wakeup, iter.cur, lwWaitLink);
        /* check comment in LWLockWakeup() about this barrier */
        pg_write_barrier();
        waiter->lwWaiting = LW_WS_NOT_WAITING;
        PGSemaphoreUnlock(waiter->sem);
    }
}

References Assert, proclist_mutable_iter::cur, fb(), 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
	)

extern

Definition at line 1566 of file lwlock.c.

{
    PGPROC     *proc = MyProc;
    int         extraWaits = 0;
    bool        result = false;
#ifdef LWLOCK_STATS
    lwlock_stats *lwstats;
 
    lwstats = get_lwlock_stats_entry(lock);
#endif
 
    PRINT_LWDEBUG("LWLockWaitForVar", lock, LW_WAIT_UNTIL_FREE);
 
    /*
     * Lock out cancel/die interrupts while we sleep on the lock.  There is no
     * cleanup mechanism to remove us from the wait queue if we got
     * interrupted.
     */
    HOLD_INTERRUPTS();
 
    /*
     * Loop here to check the lock's status after each time we are signaled.
     */
    for (;;)
    {
        bool        mustwait;
 
        mustwait = LWLockConflictsWithVar(lock, valptr, oldval, newval,
                                          &result);
 
        if (!mustwait)
            break;              /* the lock was free or value didn't match */
 
        /*
         * Add myself to wait queue. Note that this is racy, somebody else
         * could wakeup before we're finished queuing. NB: We're using nearly
         * the same twice-in-a-row lock acquisition protocol as
         * LWLockAcquire(). Check its comments for details. The only
         * difference is that we also have to check the variable's values when
         * checking the state of the lock.
         */
        LWLockQueueSelf(lock, LW_WAIT_UNTIL_FREE);
 
        /*
         * Clear LW_FLAG_WAKE_IN_PROGRESS flag, to make sure we get woken up
         * as soon as the lock is released.
         */
        pg_atomic_fetch_and_u32(&lock->state, ~LW_FLAG_WAKE_IN_PROGRESS);
 
        /*
         * We're now guaranteed to be woken up if necessary. Recheck the lock
         * and variables state.
         */
        mustwait = LWLockConflictsWithVar(lock, valptr, oldval, newval,
                                          &result);
 
        /* Ok, no conflict after we queued ourselves. Undo queueing. */
        if (!mustwait)
        {
            LOG_LWDEBUG("LWLockWaitForVar", lock, "free, undoing queue");
 
            LWLockDequeueSelf(lock);
            break;
        }
 
        /*
         * Wait until awakened.
         *
         * It is possible that we get awakened for a reason other than being
         * signaled by LWLockRelease.  If so, loop back and wait again.  Once
         * we've gotten the LWLock, re-increment the sema by the number of
         * additional signals received.
         */
        LOG_LWDEBUG("LWLockWaitForVar", lock, "waiting");
 
#ifdef LWLOCK_STATS
        lwstats->block_count++;
#endif
 
        LWLockReportWaitStart(lock);
        if (TRACE_POSTGRESQL_LWLOCK_WAIT_START_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_WAIT_START(T_NAME(lock), LW_EXCLUSIVE);
 
        for (;;)
        {
            PGSemaphoreLock(proc->sem);
            if (proc->lwWaiting == LW_WS_NOT_WAITING)
                break;
            extraWaits++;
        }
 
#ifdef LOCK_DEBUG
        {
            /* not waiting anymore */
            uint32      nwaiters PG_USED_FOR_ASSERTS_ONLY = pg_atomic_fetch_sub_u32(&lock->nwaiters, 1);
 
            Assert(nwaiters < MAX_BACKENDS);
        }
#endif
 
        if (TRACE_POSTGRESQL_LWLOCK_WAIT_DONE_ENABLED())
            TRACE_POSTGRESQL_LWLOCK_WAIT_DONE(T_NAME(lock), LW_EXCLUSIVE);
        LWLockReportWaitEnd();
 
        LOG_LWDEBUG("LWLockWaitForVar", lock, "awakened");
 
        /* Now loop back and check the status of the lock again. */
    }
 
    /*
     * Fix the process wait semaphore's count for any absorbed wakeups.
     */
    while (extraWaits-- > 0)
        PGSemaphoreUnlock(proc->sem);
 
    /*
     * Now okay to allow cancel/die interrupts.
     */
    RESUME_INTERRUPTS();
 
    return result;
}

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

Referenced by WaitXLogInsertionsToFinish().

◆ RequestNamedLWLockTranche()

void RequestNamedLWLockTranche	(	const char *	tranche_name,
		int	num_lwlocks
	)

extern

Definition at line 620 of file lwlock.c.

{
    NamedLWLockTrancheRequest *request;
    MemoryContext oldcontext;
 
    if (!process_shmem_requests_in_progress)
        elog(FATAL, "cannot request additional LWLocks outside shmem_request_hook");
 
    if (!tranche_name)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_NAME),
                 errmsg("tranche name cannot be NULL")));
 
    if (strlen(tranche_name) >= NAMEDATALEN)
        ereport(ERROR,
                (errcode(ERRCODE_NAME_TOO_LONG),
                 errmsg("tranche name too long"),
                 errdetail("LWLock tranche names must be no longer than %d bytes.",
                           NAMEDATALEN - 1)));
 
    if (list_length(NamedLWLockTrancheRequests) >= MAX_USER_DEFINED_TRANCHES)
        ereport(ERROR,
                (errmsg("maximum number of tranches already registered"),
                 errdetail("No more than %d tranches may be registered.",
                           MAX_USER_DEFINED_TRANCHES)));
 
    /* Check that the name isn't already in use */
    foreach_ptr(NamedLWLockTrancheRequest, existing, NamedLWLockTrancheRequests)
    {
        if (strcmp(existing->tranche_name, tranche_name) == 0)
            elog(ERROR, "requested tranche \"%s\" is already registered", tranche_name);
    }
 
    if (IsPostmasterEnvironment)
        oldcontext = MemoryContextSwitchTo(PostmasterContext);
    else
        oldcontext = MemoryContextSwitchTo(TopMemoryContext);
 
    request = palloc0(sizeof(NamedLWLockTrancheRequest));
    strlcpy(request->tranche_name, tranche_name, NAMEDATALEN);
    request->num_lwlocks = num_lwlocks;
    NamedLWLockTrancheRequests = lappend(NamedLWLockTrancheRequests, request);
 
    MemoryContextSwitchTo(oldcontext);
}

References elog, ereport, errcode(), errdetail(), errmsg, ERROR, FATAL, fb(), foreach_ptr, IsPostmasterEnvironment, lappend(), list_length(), MAX_USER_DEFINED_TRANCHES, MemoryContextSwitchTo(), NAMEDATALEN, NamedLWLockTrancheRequests, palloc0(), PostmasterContext, process_shmem_requests_in_progress, strlcpy(), and TopMemoryContext.

Referenced by test_lwlock_tranches_shmem_request().

◆ StaticAssertDecl()

StaticAssertDecl	(	sizeof(LWLock)<=	LWLOCK_PADDED_SIZE,
		"Miscalculated LWLock padding"
	)

Variable Documentation

◆ MainLWLockArray

PGDLLIMPORT LWLockPadded* MainLWLockArray

extern

Definition at line 150 of file lwlock.c.

Referenced by BufMappingPartitionLock(), BufMappingPartitionLockByIndex(), GetNamedLWLockTranche(), LWLockShmemInit(), and LWLockShmemRequest().

Macros
#define	LWLOCK_PADDED_SIZE PG_CACHE_LINE_SIZE

#define	NUM_BUFFER_PARTITIONS 128

#define	LOG2_NUM_LOCK_PARTITIONS 4

#define	NUM_LOCK_PARTITIONS (1 << LOG2_NUM_LOCK_PARTITIONS)

#define	LOG2_NUM_PREDICATELOCK_PARTITIONS 4

#define	NUM_PREDICATELOCK_PARTITIONS (1 << LOG2_NUM_PREDICATELOCK_PARTITIONS)

#define	BUFFER_MAPPING_LWLOCK_OFFSET NUM_INDIVIDUAL_LWLOCKS

#define	LOCK_MANAGER_LWLOCK_OFFSET (BUFFER_MAPPING_LWLOCK_OFFSET + NUM_BUFFER_PARTITIONS)

#define	PREDICATELOCK_MANAGER_LWLOCK_OFFSET (LOCK_MANAGER_LWLOCK_OFFSET + NUM_LOCK_PARTITIONS)

#define	NUM_FIXED_LWLOCKS (PREDICATELOCK_MANAGER_LWLOCK_OFFSET + NUM_PREDICATELOCK_PARTITIONS)

#define	PG_LWLOCK(id, name)

#define	PG_LWLOCKTRANCHE(id, name) LWTRANCHE_##id,

Typedefs
typedef enum LWLockWaitState	LWLockWaitState

typedef struct LWLock	LWLock

typedef union LWLockPadded	LWLockPadded

typedef enum LWLockMode	LWLockMode

typedef enum BuiltinTrancheIds	BuiltinTrancheIds

typedef LWLock *	LWLockId

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ BUFFER_MAPPING_LWLOCK_OFFSET

◆ LOCK_MANAGER_LWLOCK_OFFSET

◆ LOG2_NUM_LOCK_PARTITIONS

◆ LOG2_NUM_PREDICATELOCK_PARTITIONS

◆ LWLOCK_PADDED_SIZE

◆ NUM_BUFFER_PARTITIONS

◆ NUM_FIXED_LWLOCKS

◆ NUM_LOCK_PARTITIONS

◆ NUM_PREDICATELOCK_PARTITIONS

◆ PG_LWLOCK

◆ PG_LWLOCKTRANCHE

◆ PREDICATELOCK_MANAGER_LWLOCK_OFFSET

Typedef Documentation

◆ BuiltinTrancheIds

◆ LWLock

◆ LWLockId

◆ LWLockMode

◆ LWLockPadded

◆ LWLockWaitState

Enumeration Type Documentation

◆ BuiltinTrancheIds

◆ LWLockMode

◆ LWLockWaitState

Function Documentation

◆ GetLWLockIdentifier()

◆ GetNamedLWLockTranche()

◆ InitLWLockAccess()

◆ LWLockAcquire()

◆ LWLockAcquireOrWait()

◆ LWLockAnyHeldByMe()

◆ LWLockConditionalAcquire()

◆ LWLockHeldByMe()

◆ LWLockHeldByMeInMode()

◆ LWLockInitialize()

◆ LWLockNewTrancheId()

◆ LWLockRelease()

◆ LWLockReleaseAll()

◆ LWLockReleaseClearVar()

◆ LWLockUpdateVar()

◆ LWLockWaitForVar()

◆ RequestNamedLWLockTranche()

◆ StaticAssertDecl()

Variable Documentation

◆ MainLWLockArray