#include "utils/hsearch.h"

Include dependency graph for shmem.h:

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

Data Structures
struct	SHM_QUEUE

struct	ShmemIndexEnt

Macros
#define	SHMEM_INDEX_KEYSIZE (48)

#define	SHMEM_INDEX_SIZE (64)

Typedefs
typedef struct SHM_QUEUE	SHM_QUEUE

Functions
void	InitShmemAccess (void *seghdr)

void	InitShmemAllocation (void)

void *	ShmemAlloc (Size size)

void *	ShmemAllocNoError (Size size)

void *	ShmemAllocUnlocked (Size size)

bool	ShmemAddrIsValid (const void *addr)

void	InitShmemIndex (void)

HTAB *	ShmemInitHash (const char name, long init_size, long max_size, HASHCTL infoP, int hash_flags)

void *	ShmemInitStruct (const char name, Size size, bool foundPtr)

Size	add_size (Size s1, Size s2)

Size	mul_size (Size s1, Size s2)

void	RequestAddinShmemSpace (Size size)

void	SHMQueueInit (SHM_QUEUE *queue)

void	SHMQueueElemInit (SHM_QUEUE *queue)

void	SHMQueueDelete (SHM_QUEUE *queue)

void	SHMQueueInsertBefore (SHM_QUEUE queue, SHM_QUEUE elem)

void	SHMQueueInsertAfter (SHM_QUEUE queue, SHM_QUEUE elem)

Pointer	SHMQueueNext (const SHM_QUEUE queue, const SHM_QUEUE curElem, Size linkOffset)

Pointer	SHMQueuePrev (const SHM_QUEUE queue, const SHM_QUEUE curElem, Size linkOffset)

bool	SHMQueueEmpty (const SHM_QUEUE *queue)

bool	SHMQueueIsDetached (const SHM_QUEUE *queue)

Macro Definition Documentation

◆ SHMEM_INDEX_KEYSIZE

#define SHMEM_INDEX_KEYSIZE (48)

Definition at line 53 of file shmem.h.

Referenced by InitShmemIndex().

◆ SHMEM_INDEX_SIZE

#define SHMEM_INDEX_SIZE (64)

Definition at line 55 of file shmem.h.

Referenced by CalculateShmemSize(), and InitShmemIndex().

Typedef Documentation

◆ SHM_QUEUE

typedef struct SHM_QUEUE SHM_QUEUE

Function Documentation

◆ add_size()

Size add_size	(	Size	s1,
		Size	s2
	)

Definition at line 502 of file shmem.c.

References ereport, errcode(), errmsg(), ERROR, and s2.

Referenced by _bt_parallel_estimate_shared(), ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), begin_parallel_vacuum(), BTreeShmemSize(), BufferShmemSize(), CalculateShmemSize(), CheckpointerShmemSize(), CreateSharedProcArray(), estimate_variable_size(), EstimateComboCIDStateSpace(), EstimateGUCStateSpace(), EstimateLibraryStateSpace(), EstimateParamExecSpace(), EstimateParamListSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAggEstimate(), ExecAppendEstimate(), ExecBitmapHeapEstimate(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecMemoizeEstimate(), ExecSortEstimate(), expand_planner_arrays(), hash_estimate_size(), index_parallelscan_estimate(), index_parallelscan_initialize(), InitializeShmemGUCs(), LockShmemSize(), LWLockShmemSize(), MultiXactShmemSize(), PgArchShmemSize(), pgss_memsize(), PMSignalShmemSize(), PredicateLockShmemSize(), ProcArrayShmemSize(), ProcGlobalShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), RequestAddinShmemSpace(), SerializeTransactionState(), shm_toc_estimate(), SInvalShmemSize(), SnapMgrShmemSize(), StrategyShmemSize(), table_parallelscan_estimate(), tuplesort_estimate_shared(), TwoPhaseShmemSize(), WalRcvShmemSize(), WalSndShmemSize(), and XLOGShmemSize().

 {
     Size        result;
 
     result = s1 + s2;
     /* We are assuming Size is an unsigned type here... */
     if (result < s1 || result < s2)
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("requested shared memory size overflows size_t")));
     return result;
 }

◆ InitShmemAccess()

void InitShmemAccess ( void * seghdr )

Definition at line 101 of file shmem.c.

References ShmemBase, ShmemEnd, and PGShmemHeader::totalsize.

Referenced by BackendRun(), and CreateSharedMemoryAndSemaphores().

 {
     PGShmemHeader *shmhdr = (PGShmemHeader *) seghdr;
 
     ShmemSegHdr = shmhdr;
     ShmemBase = (void *) shmhdr;
     ShmemEnd = (char *) ShmemBase + shmhdr->totalsize;
 }

◆ InitShmemAllocation()

void InitShmemAllocation ( void )

Definition at line 116 of file shmem.c.

References Assert, CACHELINEALIGN, ShmemAlloc(), ShmemAllocUnlocked(), ShmemLock, ShmemSegHdr, ShmemVariableCache, and SpinLockInit.

Referenced by CreateSharedMemoryAndSemaphores().

 {
     PGShmemHeader *shmhdr = ShmemSegHdr;
     char       *aligned;
 
     Assert(shmhdr != NULL);
 
     /*
      * Initialize the spinlock used by ShmemAlloc.  We must use
      * ShmemAllocUnlocked, since obviously ShmemAlloc can't be called yet.
      */
     ShmemLock = (slock_t *) ShmemAllocUnlocked(sizeof(slock_t));
 
     SpinLockInit(ShmemLock);
 
     /*
      * Allocations after this point should go through ShmemAlloc, which
      * expects to allocate everything on cache line boundaries.  Make sure the
      * first allocation begins on a cache line boundary.
      */
     aligned = (char *)
         (CACHELINEALIGN((((char *) shmhdr) + shmhdr->freeoffset)));
     shmhdr->freeoffset = aligned - (char *) shmhdr;
 
     /* ShmemIndex can't be set up yet (need LWLocks first) */
     shmhdr->index = NULL;
     ShmemIndex = (HTAB *) NULL;
 
     /*
      * Initialize ShmemVariableCache for transaction manager. (This doesn't
      * really belong here, but not worth moving.)
      */
     ShmemVariableCache = (VariableCache)
         ShmemAlloc(sizeof(*ShmemVariableCache));
     memset(ShmemVariableCache, 0, sizeof(*ShmemVariableCache));
 }

◆ InitShmemIndex()

void InitShmemIndex ( void )

Definition at line 292 of file shmem.c.

References HASHCTL::entrysize, HASH_ELEM, HASH_STRINGS, HASHCTL::keysize, SHMEM_INDEX_KEYSIZE, SHMEM_INDEX_SIZE, and ShmemInitHash().

Referenced by CreateSharedMemoryAndSemaphores().

 {
     HASHCTL     info;
 
     /*
      * Create the shared memory shmem index.
      *
      * Since ShmemInitHash calls ShmemInitStruct, which expects the ShmemIndex
      * hashtable to exist already, we have a bit of a circularity problem in
      * initializing the ShmemIndex itself.  The special "ShmemIndex" hash
      * table name will tell ShmemInitStruct to fake it.
      */
     info.keysize = SHMEM_INDEX_KEYSIZE;
     info.entrysize = sizeof(ShmemIndexEnt);
 
     ShmemIndex = ShmemInitHash("ShmemIndex",
                                SHMEM_INDEX_SIZE, SHMEM_INDEX_SIZE,
                                &info,
                                HASH_ELEM | HASH_STRINGS);
 }

◆ mul_size()

Size mul_size	(	Size	s1,
		Size	s2
	)

Definition at line 519 of file shmem.c.

References ereport, errcode(), errmsg(), ERROR, and s2.

Referenced by _bt_begin_parallel(), ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), begin_parallel_vacuum(), BTreeShmemSize(), BufferShmemSize(), CheckpointerShmemSize(), CreateSharedBackendStatus(), CreateSharedProcArray(), EstimateComboCIDStateSpace(), EstimatePendingSyncsSpace(), EstimateReindexStateSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAggEstimate(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecInitParallelPlan(), ExecMemoizeEstimate(), ExecParallelRetrieveInstrumentation(), ExecParallelRetrieveJitInstrumentation(), ExecParallelSetupTupleQueues(), ExecSortEstimate(), hash_estimate_size(), InitializeParallelDSM(), InitPredicateLocks(), LWLockShmemSize(), PGSemaphoreShmemSize(), PMSignalShmemSize(), PostmasterMarkPIDForWorkerNotify(), PredicateLockShmemSize(), ProcArrayShmemSize(), ProcGlobalShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), shm_toc_estimate(), SInvalShmemSize(), SnapMgrShmemSize(), tuplesort_estimate_shared(), TwoPhaseShmemSize(), WalSndShmemSize(), and XLOGShmemSize().

 {
     Size        result;
 
     if (s1 == 0 || s2 == 0)
         return 0;
     result = s1 * s2;
     /* We are assuming Size is an unsigned type here... */
     if (result / s2 != s1)
         ereport(ERROR,
                 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                  errmsg("requested shared memory size overflows size_t")));
     return result;
 }

◆ RequestAddinShmemSpace()

void RequestAddinShmemSpace ( Size size )

Definition at line 71 of file ipci.c.

References add_size(), addin_request_allowed, IsUnderPostmaster, and total_addin_request.

Referenced by _PG_init().

 {
     if (IsUnderPostmaster || !addin_request_allowed)
         return;                 /* too late */
     total_addin_request = add_size(total_addin_request, size);
 }

◆ ShmemAddrIsValid()

bool ShmemAddrIsValid ( const void * addr )

Definition at line 283 of file shmem.c.

References ShmemBase, and ShmemEnd.

Referenced by NextPredXact(), ReleasePredXact(), ShmemInitStruct(), SHMQueueDelete(), SHMQueueElemInit(), SHMQueueEmpty(), SHMQueueInit(), SHMQueueInsertAfter(), SHMQueueInsertBefore(), SHMQueueIsDetached(), SHMQueueNext(), and SHMQueuePrev().

 {
     return (addr >= ShmemBase) && (addr < ShmemEnd);
 }

◆ ShmemAlloc()

void* ShmemAlloc ( Size size )

Definition at line 161 of file shmem.c.

References ereport, errcode(), errmsg(), ERROR, and ShmemAllocRaw().

Referenced by CreateLWLocks(), InitPredicateLocks(), InitProcGlobal(), InitShmemAllocation(), PostmasterMarkPIDForWorkerNotify(), and ShmemInitStruct().

 {
     void       *newSpace;
     Size        allocated_size;
 
     newSpace = ShmemAllocRaw(size, &allocated_size);
     if (!newSpace)
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of shared memory (%zu bytes requested)",
                         size)));
     return newSpace;
 }

◆ ShmemAllocNoError()

void* ShmemAllocNoError ( Size size )

Definition at line 181 of file shmem.c.

References ShmemAllocRaw().

Referenced by ShmemInitHash().

 {
     Size        allocated_size;
 
     return ShmemAllocRaw(size, &allocated_size);
 }

◆ ShmemAllocUnlocked()

void* ShmemAllocUnlocked ( Size size )

Definition at line 247 of file shmem.c.

References Assert, ereport, errcode(), errmsg(), ERROR, PGShmemHeader::freeoffset, MAXALIGN, ShmemBase, and PGShmemHeader::totalsize.

Referenced by InitShmemAllocation(), PGReserveSemaphores(), and SpinlockSemaInit().

 {
     Size        newStart;
     Size        newFree;
     void       *newSpace;
 
     /*
      * Ensure allocated space is adequately aligned.
      */
     size = MAXALIGN(size);
 
     Assert(ShmemSegHdr != NULL);
 
     newStart = ShmemSegHdr->freeoffset;
 
     newFree = newStart + size;
     if (newFree > ShmemSegHdr->totalsize)
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of shared memory (%zu bytes requested)",
                         size)));
     ShmemSegHdr->freeoffset = newFree;
 
     newSpace = (void *) ((char *) ShmemBase + newStart);
 
     Assert(newSpace == (void *) MAXALIGN(newSpace));
 
     return newSpace;
 }

◆ ShmemInitHash()

HTAB* ShmemInitHash	(	const char *	name,
		long	init_size,
		long	max_size,
		HASHCTL *	infoP,
		int	hash_flags
	)

Definition at line 341 of file shmem.c.

References HASHCTL::alloc, HASHCTL::dsize, HASH_ALLOC, HASH_ATTACH, hash_create(), HASH_DIRSIZE, hash_get_shared_size(), hash_select_dirsize(), HASH_SHARED_MEM, HASHCTL::hctl, HASHCTL::max_dsize, ShmemAllocNoError(), and ShmemInitStruct().

Referenced by InitBufTable(), InitLocks(), InitPredicateLocks(), InitShmemIndex(), and pgss_shmem_startup().

 {
     bool        found;
     void       *location;
 
     /*
      * Hash tables allocated in shared memory have a fixed directory; it can't
      * grow or other backends wouldn't be able to find it. So, make sure we
      * make it big enough to start with.
      *
      * The shared memory allocator must be specified too.
      */
     infoP->dsize = infoP->max_dsize = hash_select_dirsize(max_size);
     infoP->alloc = ShmemAllocNoError;
     hash_flags |= HASH_SHARED_MEM | HASH_ALLOC | HASH_DIRSIZE;
 
     /* look it up in the shmem index */
     location = ShmemInitStruct(name,
                                hash_get_shared_size(infoP, hash_flags),
                                &found);
 
     /*
      * if it already exists, attach to it rather than allocate and initialize
      * new space
      */
     if (found)
         hash_flags |= HASH_ATTACH;
 
     /* Pass location of hashtable header to hash_create */
     infoP->hctl = (HASHHDR *) location;
 
     return hash_create(name, init_size, infoP, hash_flags);
 }

◆ ShmemInitStruct()

void* ShmemInitStruct	(	const char *	name,
		Size	size,
		bool *	foundPtr
	)

Definition at line 396 of file shmem.c.

References ShmemIndexEnt::allocated_size, Assert, CACHELINEALIGN, ereport, errcode(), errmsg(), ERROR, HASH_ENTER_NULL, HASH_REMOVE, hash_search(), PGShmemHeader::index, IsUnderPostmaster, ShmemIndexEnt::location, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), ShmemAddrIsValid(), ShmemAlloc(), ShmemAllocRaw(), ShmemSegHdr, and ShmemIndexEnt::size.

Referenced by ApplyLauncherShmemInit(), apw_init_shmem(), AsyncShmemInit(), AutoVacuumShmemInit(), AuxiliaryPidGetProc(), BackgroundWorkerShmemInit(), BTreeShmemInit(), CheckpointerShmemInit(), CommitTsShmemInit(), CreateSharedBackendStatus(), CreateSharedInvalidationState(), CreateSharedProcArray(), dsm_shmem_init(), InitBufferPool(), InitLocks(), InitPredicateLocks(), InitProcGlobal(), MultiXactShmemInit(), PgArchShmemInit(), pgss_shmem_startup(), PMSignalShmemInit(), ProcSignalShmemInit(), ReplicationOriginShmemInit(), ReplicationSlotsShmemInit(), SerialInit(), ShmemInitHash(), SimpleLruInit(), SnapMgrInit(), StrategyInitialize(), SyncScanShmemInit(), TwoPhaseShmemInit(), WalRcvShmemInit(), WalSndShmemInit(), and XLOGShmemInit().

 {
     ShmemIndexEnt *result;
     void       *structPtr;
 
     LWLockAcquire(ShmemIndexLock, LW_EXCLUSIVE);
 
     if (!ShmemIndex)
     {
         PGShmemHeader *shmemseghdr = ShmemSegHdr;
 
         /* Must be trying to create/attach to ShmemIndex itself */
         Assert(strcmp(name, "ShmemIndex") == 0);
 
         if (IsUnderPostmaster)
         {
             /* Must be initializing a (non-standalone) backend */
             Assert(shmemseghdr->index != NULL);
             structPtr = shmemseghdr->index;
             *foundPtr = true;
         }
         else
         {
             /*
              * If the shmem index doesn't exist, we are bootstrapping: we must
              * be trying to init the shmem index itself.
              *
              * Notice that the ShmemIndexLock is released before the shmem
              * index has been initialized.  This should be OK because no other
              * process can be accessing shared memory yet.
              */
             Assert(shmemseghdr->index == NULL);
             structPtr = ShmemAlloc(size);
             shmemseghdr->index = structPtr;
             *foundPtr = false;
         }
         LWLockRelease(ShmemIndexLock);
         return structPtr;
     }
 
     /* look it up in the shmem index */
     result = (ShmemIndexEnt *)
         hash_search(ShmemIndex, name, HASH_ENTER_NULL, foundPtr);
 
     if (!result)
     {
         LWLockRelease(ShmemIndexLock);
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("could not create ShmemIndex entry for data structure \"%s\"",
                         name)));
     }
 
     if (*foundPtr)
     {
         /*
          * Structure is in the shmem index so someone else has allocated it
          * already.  The size better be the same as the size we are trying to
          * initialize to, or there is a name conflict (or worse).
          */
         if (result->size != size)
         {
             LWLockRelease(ShmemIndexLock);
             ereport(ERROR,
                     (errmsg("ShmemIndex entry size is wrong for data structure"
                             " \"%s\": expected %zu, actual %zu",
                             name, size, result->size)));
         }
         structPtr = result->location;
     }
     else
     {
         Size        allocated_size;
 
         /* It isn't in the table yet. allocate and initialize it */
         structPtr = ShmemAllocRaw(size, &allocated_size);
         if (structPtr == NULL)
         {
             /* out of memory; remove the failed ShmemIndex entry */
             hash_search(ShmemIndex, name, HASH_REMOVE, NULL);
             LWLockRelease(ShmemIndexLock);
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("not enough shared memory for data structure"
                             " \"%s\" (%zu bytes requested)",
                             name, size)));
         }
         result->size = size;
         result->allocated_size = allocated_size;
         result->location = structPtr;
     }
 
     LWLockRelease(ShmemIndexLock);
 
     Assert(ShmemAddrIsValid(structPtr));
 
     Assert(structPtr == (void *) CACHELINEALIGN(structPtr));
 
     return structPtr;
 }

◆ SHMQueueDelete()

void SHMQueueDelete ( SHM_QUEUE * queue )

Definition at line 68 of file shmqueue.c.

References Assert, SHM_QUEUE::next, SHM_QUEUE::prev, and ShmemAddrIsValid().

Referenced by CheckTargetForConflictsIn(), CleanUpLock(), ClearOldPredicateLocks(), CreatePredXact(), DeleteChildTargetLocks(), DeleteLockTarget(), DropAllPredicateLocksFromTable(), LockAcquireExtended(), PostPrepare_Locks(), ProcWakeup(), ReleaseOneSerializableXact(), ReleasePredXact(), ReleaseRWConflict(), RemoveFromWaitQueue(), SetPossibleUnsafeConflict(), SetRWConflict(), SummarizeOldestCommittedSxact(), SyncRepCancelWait(), SyncRepCleanupAtProcExit(), SyncRepWakeQueue(), and TransferPredicateLocksToNewTarget().

 {
     SHM_QUEUE  *nextElem = queue->next;
     SHM_QUEUE  *prevElem = queue->prev;
 
     Assert(ShmemAddrIsValid(queue));
     Assert(ShmemAddrIsValid(nextElem));
     Assert(ShmemAddrIsValid(prevElem));
 
     prevElem->next = queue->next;
     nextElem->prev = queue->prev;
 
     queue->prev = queue->next = NULL;
 }

◆ SHMQueueElemInit()

void SHMQueueElemInit ( SHM_QUEUE * queue )

Definition at line 57 of file shmqueue.c.

References Assert, SHM_QUEUE::next, SHM_QUEUE::prev, and ShmemAddrIsValid().

Referenced by GetSerializableTransactionSnapshotInt(), InitAuxiliaryProcess(), InitProcess(), MarkAsPreparingGuts(), and predicatelock_twophase_recover().

 {
     Assert(ShmemAddrIsValid(queue));
     queue->prev = queue->next = NULL;
 }

◆ SHMQueueEmpty()

bool SHMQueueEmpty ( const SHM_QUEUE * queue )

Definition at line 180 of file shmqueue.c.

References Assert, SHM_QUEUE::next, SHM_QUEUE::prev, and ShmemAddrIsValid().

Referenced by CheckForSerializableConflictOut(), CleanUpLock(), GetSafeSnapshot(), InitAuxiliaryProcess(), InitProcess(), lock_twophase_recover(), ProcKill(), ReleasePredicateLocks(), RemoveTargetIfNoLongerUsed(), RWConflictExists(), SetupLockInTable(), SummarizeOldestCommittedSxact(), and TransferPredicateLocksToNewTarget().

 {
     Assert(ShmemAddrIsValid(queue));
 
     if (queue->prev == queue)
     {
         Assert(queue->next == queue);
         return true;
     }
     return false;
 }

◆ SHMQueueInit()

void SHMQueueInit ( SHM_QUEUE * queue )

Definition at line 36 of file shmqueue.c.

References Assert, SHM_QUEUE::next, SHM_QUEUE::prev, and ShmemAddrIsValid().

Referenced by CreatePredicateLock(), DropAllPredicateLocksFromTable(), GetSerializableTransactionSnapshotInt(), InitPredicateLocks(), InitProcGlobal(), lock_twophase_recover(), MarkAsPreparingGuts(), predicatelock_twophase_recover(), ProcQueueInit(), ReleaseOneSerializableXact(), SetupLockInTable(), TransferPredicateLocksToNewTarget(), and WalSndShmemInit().

 {
     Assert(ShmemAddrIsValid(queue));
     queue->prev = queue->next = queue;
 }

◆ SHMQueueInsertAfter()

void SHMQueueInsertAfter	(	SHM_QUEUE *	queue,
		SHM_QUEUE *	elem
	)

Definition at line 108 of file shmqueue.c.

References Assert, SHM_QUEUE::next, SHM_QUEUE::prev, and ShmemAddrIsValid().

Referenced by SyncRepQueueInsert().

 {
     SHM_QUEUE  *nextPtr = queue->next;
 
     Assert(ShmemAddrIsValid(queue));
     Assert(ShmemAddrIsValid(elem));
 
     elem->prev = nextPtr->prev;
     elem->next = queue->next;
     queue->next = elem;
     nextPtr->prev = elem;
 }

◆ SHMQueueInsertBefore()

void SHMQueueInsertBefore	(	SHM_QUEUE *	queue,
		SHM_QUEUE *	elem
	)

Definition at line 89 of file shmqueue.c.

References Assert, SHM_QUEUE::next, SHM_QUEUE::prev, and ShmemAddrIsValid().

Referenced by CreatePredicateLock(), CreatePredXact(), DeadLockCheck(), DropAllPredicateLocksFromTable(), InitPredicateLocks(), lock_twophase_recover(), PostPrepare_Locks(), ProcSleep(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), ReleasePredXact(), ReleaseRWConflict(), SetPossibleUnsafeConflict(), SetRWConflict(), SetupLockInTable(), and TransferPredicateLocksToNewTarget().

 {
     SHM_QUEUE  *prevPtr = queue->prev;
 
     Assert(ShmemAddrIsValid(queue));
     Assert(ShmemAddrIsValid(elem));
 
     elem->next = prevPtr->next;
     elem->prev = queue->prev;
     queue->prev = elem;
     prevPtr->next = elem;
 }

◆ SHMQueueIsDetached()

bool SHMQueueIsDetached ( const SHM_QUEUE * queue )

Definition at line 47 of file shmqueue.c.

References Assert, SHM_QUEUE::prev, and ShmemAddrIsValid().

Referenced by SyncRepCancelWait(), SyncRepCleanupAtProcExit(), and SyncRepWaitForLSN().

 {
     Assert(ShmemAddrIsValid(queue));
     return (queue->prev == NULL);
 }

◆ SHMQueueNext()

Pointer SHMQueueNext	(	const SHM_QUEUE *	queue,
		const SHM_QUEUE *	curElem,
		Size	linkOffset
	)

Definition at line 145 of file shmqueue.c.

References Assert, SHM_QUEUE::next, and ShmemAddrIsValid().

Referenced by AtPrepare_PredicateLocks(), CheckTableForSerializableConflictIn(), CheckTargetForConflictsIn(), ClearOldPredicateLocks(), CreatePredXact(), DeleteChildTargetLocks(), DeleteLockTarget(), DropAllPredicateLocksFromTable(), FindLockCycleRecurseMember(), FirstPredXact(), FlagSxactUnsafe(), GetLockConflicts(), GetLockmodeName(), GetSafeSnapshotBlockingPids(), GetSingleProcBlockerStatusData(), LockCheckConflicts(), LockReleaseAll(), NextPredXact(), OnConflict_CheckForSerializationFailure(), PostPrepare_Locks(), PreCommit_CheckForSerializationFailure(), ProcSleep(), ReleaseOneSerializableXact(), ReleasePredicateLocks(), RWConflictExists(), SetPossibleUnsafeConflict(), SetRWConflict(), SummarizeOldestCommittedSxact(), SyncRepUpdateSyncStandbysDefined(), SyncRepWakeQueue(), and TransferPredicateLocksToNewTarget().

 {
     SHM_QUEUE  *elemPtr = curElem->next;
 
     Assert(ShmemAddrIsValid(curElem));
 
     if (elemPtr == queue)       /* back to the queue head? */
         return NULL;
 
     return (Pointer) (((char *) elemPtr) - linkOffset);
 }

◆ SHMQueuePrev()

Pointer SHMQueuePrev	(	const SHM_QUEUE *	queue,
		const SHM_QUEUE *	curElem,
		Size	linkOffset
	)

Definition at line 164 of file shmqueue.c.

References Assert, SHM_QUEUE::prev, and ShmemAddrIsValid().

Referenced by SyncRepQueueInsert().

 {
     SHM_QUEUE  *elemPtr = curElem->prev;
 
     Assert(ShmemAddrIsValid(curElem));
 
     if (elemPtr == queue)       /* back to the queue head? */
         return NULL;
 
     return (Pointer) (((char *) elemPtr) - linkOffset);
 }

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ SHMEM_INDEX_KEYSIZE

◆ SHMEM_INDEX_SIZE

Typedef Documentation

◆ SHM_QUEUE

Function Documentation

◆ add_size()

◆ InitShmemAccess()

◆ InitShmemAllocation()

◆ InitShmemIndex()

◆ mul_size()

◆ RequestAddinShmemSpace()

◆ ShmemAddrIsValid()

◆ ShmemAlloc()

◆ ShmemAllocNoError()

◆ ShmemAllocUnlocked()

◆ ShmemInitHash()

◆ ShmemInitStruct()

◆ SHMQueueDelete()

◆ SHMQueueElemInit()

◆ SHMQueueEmpty()

◆ SHMQueueInit()

◆ SHMQueueInsertAfter()

◆ SHMQueueInsertBefore()

◆ SHMQueueIsDetached()

◆ SHMQueueNext()

◆ SHMQueuePrev()