PostgreSQL Source Code  git master
shmem.h File Reference
#include "utils/hsearch.h"
Include dependency graph for shmem.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of 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)
 
HTABShmemInitHash (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 CreateSharedMemoryAndSemaphores(), 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 498 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(), CheckpointerShmemSize(), CreateSharedMemoryAndSemaphores(), CreateSharedProcArray(), estimate_variable_size(), EstimateComboCIDStateSpace(), EstimateGUCStateSpace(), EstimateLibraryStateSpace(), EstimateParamExecSpace(), EstimateParamListSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAppendEstimate(), ExecBitmapHeapEstimate(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecSortEstimate(), expand_planner_arrays(), hash_estimate_size(), index_parallelscan_estimate(), index_parallelscan_initialize(), LockShmemSize(), LWLockShmemSize(), MultiXactShmemSize(), 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().

499 {
500  Size result;
501 
502  result = s1 + s2;
503  /* We are assuming Size is an unsigned type here... */
504  if (result < s1 || result < s2)
505  ereport(ERROR,
506  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
507  errmsg("requested shared memory size overflows size_t")));
508  return result;
509 }
int errcode(int sqlerrcode)
Definition: elog.c:610
#define ERROR
Definition: elog.h:43
char * s1
char * s2
#define ereport(elevel,...)
Definition: elog.h:144
size_t Size
Definition: c.h:466
int errmsg(const char *fmt,...)
Definition: elog.c:824

◆ InitShmemAccess()

void InitShmemAccess ( void *  seghdr)

Definition at line 101 of file shmem.c.

References ShmemBase, ShmemEnd, and PGShmemHeader::totalsize.

Referenced by BackendRun(), and CreateSharedMemoryAndSemaphores().

102 {
103  PGShmemHeader *shmhdr = (PGShmemHeader *) seghdr;
104 
105  ShmemSegHdr = shmhdr;
106  ShmemBase = (void *) shmhdr;
107  ShmemEnd = (char *) ShmemBase + shmhdr->totalsize;
108 }
static PGShmemHeader * ShmemSegHdr
Definition: shmem.c:82
static void * ShmemBase
Definition: shmem.c:84
static void * ShmemEnd
Definition: shmem.c:86
Size totalsize
Definition: pg_shmem.h:34

◆ 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().

117 {
118  PGShmemHeader *shmhdr = ShmemSegHdr;
119  char *aligned;
120 
121  Assert(shmhdr != NULL);
122 
123  /*
124  * Initialize the spinlock used by ShmemAlloc. We must use
125  * ShmemAllocUnlocked, since obviously ShmemAlloc can't be called yet.
126  */
128 
130 
131  /*
132  * Allocations after this point should go through ShmemAlloc, which
133  * expects to allocate everything on cache line boundaries. Make sure the
134  * first allocation begins on a cache line boundary.
135  */
136  aligned = (char *)
137  (CACHELINEALIGN((((char *) shmhdr) + shmhdr->freeoffset)));
138  shmhdr->freeoffset = aligned - (char *) shmhdr;
139 
140  /* ShmemIndex can't be set up yet (need LWLocks first) */
141  shmhdr->index = NULL;
142  ShmemIndex = (HTAB *) NULL;
143 
144  /*
145  * Initialize ShmemVariableCache for transaction manager. (This doesn't
146  * really belong here, but not worth moving.)
147  */
149  ShmemAlloc(sizeof(*ShmemVariableCache));
150  memset(ShmemVariableCache, 0, sizeof(*ShmemVariableCache));
151 }
int slock_t
Definition: s_lock.h:934
VariableCacheData * VariableCache
Definition: transam.h:206
static PGShmemHeader * ShmemSegHdr
Definition: shmem.c:82
#define SpinLockInit(lock)
Definition: spin.h:60
void * ShmemAlloc(Size size)
Definition: shmem.c:161
static HTAB * ShmemIndex
Definition: shmem.c:91
Definition: dynahash.c:210
VariableCache ShmemVariableCache
Definition: varsup.c:34
void * ShmemAllocUnlocked(Size size)
Definition: shmem.c:247
#define Assert(condition)
Definition: c.h:738
#define CACHELINEALIGN(LEN)
Definition: c.h:694
slock_t * ShmemLock
Definition: shmem.c:88

◆ InitShmemIndex()

void InitShmemIndex ( void  )

Definition at line 292 of file shmem.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

293 {
294  HASHCTL info;
295  int hash_flags;
296 
297  /*
298  * Create the shared memory shmem index.
299  *
300  * Since ShmemInitHash calls ShmemInitStruct, which expects the ShmemIndex
301  * hashtable to exist already, we have a bit of a circularity problem in
302  * initializing the ShmemIndex itself. The special "ShmemIndex" hash
303  * table name will tell ShmemInitStruct to fake it.
304  */
306  info.entrysize = sizeof(ShmemIndexEnt);
307  hash_flags = HASH_ELEM;
308 
309  ShmemIndex = ShmemInitHash("ShmemIndex",
311  &info, hash_flags);
312 }
#define SHMEM_INDEX_SIZE
Definition: shmem.h:55
#define HASH_ELEM
Definition: hsearch.h:87
Size entrysize
Definition: hsearch.h:73
static HTAB * ShmemIndex
Definition: shmem.c:91
Size keysize
Definition: hsearch.h:72
#define SHMEM_INDEX_KEYSIZE
Definition: shmem.h:53
HTAB * ShmemInitHash(const char *name, long init_size, long max_size, HASHCTL *infoP, int hash_flags)
Definition: shmem.c:337

◆ mul_size()

Size mul_size ( Size  s1,
Size  s2 
)

Definition at line 515 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(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecInitParallelPlan(), 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().

516 {
517  Size result;
518 
519  if (s1 == 0 || s2 == 0)
520  return 0;
521  result = s1 * s2;
522  /* We are assuming Size is an unsigned type here... */
523  if (result / s2 != s1)
524  ereport(ERROR,
525  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
526  errmsg("requested shared memory size overflows size_t")));
527  return result;
528 }
int errcode(int sqlerrcode)
Definition: elog.c:610
#define ERROR
Definition: elog.h:43
char * s1
char * s2
#define ereport(elevel,...)
Definition: elog.h:144
size_t Size
Definition: c.h:466
int errmsg(const char *fmt,...)
Definition: elog.c:824

◆ RequestAddinShmemSpace()

void RequestAddinShmemSpace ( Size  size)

Definition at line 70 of file ipci.c.

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

Referenced by _PG_init().

71 {
73  return; /* too late */
75 }
bool IsUnderPostmaster
Definition: globals.c:109
static bool addin_request_allowed
Definition: ipci.c:55
static Size total_addin_request
Definition: ipci.c:54
Size add_size(Size s1, Size s2)
Definition: shmem.c:498

◆ 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().

284 {
285  return (addr >= ShmemBase) && (addr < ShmemEnd);
286 }
static void * ShmemBase
Definition: shmem.c:84
static void * ShmemEnd
Definition: shmem.c:86

◆ 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().

162 {
163  void *newSpace;
164  Size allocated_size;
165 
166  newSpace = ShmemAllocRaw(size, &allocated_size);
167  if (!newSpace)
168  ereport(ERROR,
169  (errcode(ERRCODE_OUT_OF_MEMORY),
170  errmsg("out of shared memory (%zu bytes requested)",
171  size)));
172  return newSpace;
173 }
int errcode(int sqlerrcode)
Definition: elog.c:610
#define ERROR
Definition: elog.h:43
static void * ShmemAllocRaw(Size size, Size *allocated_size)
Definition: shmem.c:195
#define ereport(elevel,...)
Definition: elog.h:144
size_t Size
Definition: c.h:466
int errmsg(const char *fmt,...)
Definition: elog.c:824

◆ ShmemAllocNoError()

void* ShmemAllocNoError ( Size  size)

Definition at line 181 of file shmem.c.

References ShmemAllocRaw().

Referenced by ShmemInitHash().

182 {
183  Size allocated_size;
184 
185  return ShmemAllocRaw(size, &allocated_size);
186 }
static void * ShmemAllocRaw(Size size, Size *allocated_size)
Definition: shmem.c:195
size_t Size
Definition: c.h:466

◆ 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().

248 {
249  Size newStart;
250  Size newFree;
251  void *newSpace;
252 
253  /*
254  * Ensure allocated space is adequately aligned.
255  */
256  size = MAXALIGN(size);
257 
258  Assert(ShmemSegHdr != NULL);
259 
260  newStart = ShmemSegHdr->freeoffset;
261 
262  newFree = newStart + size;
263  if (newFree > ShmemSegHdr->totalsize)
264  ereport(ERROR,
265  (errcode(ERRCODE_OUT_OF_MEMORY),
266  errmsg("out of shared memory (%zu bytes requested)",
267  size)));
268  ShmemSegHdr->freeoffset = newFree;
269 
270  newSpace = (void *) ((char *) ShmemBase + newStart);
271 
272  Assert(newSpace == (void *) MAXALIGN(newSpace));
273 
274  return newSpace;
275 }
static PGShmemHeader * ShmemSegHdr
Definition: shmem.c:82
int errcode(int sqlerrcode)
Definition: elog.c:610
static void * ShmemBase
Definition: shmem.c:84
#define ERROR
Definition: elog.h:43
Size totalsize
Definition: pg_shmem.h:34
#define ereport(elevel,...)
Definition: elog.h:144
#define Assert(condition)
Definition: c.h:738
Size freeoffset
Definition: pg_shmem.h:35
size_t Size
Definition: c.h:466
#define MAXALIGN(LEN)
Definition: c.h:691
int errmsg(const char *fmt,...)
Definition: elog.c:824

◆ ShmemInitHash()

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

Definition at line 337 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().

342 {
343  bool found;
344  void *location;
345 
346  /*
347  * Hash tables allocated in shared memory have a fixed directory; it can't
348  * grow or other backends wouldn't be able to find it. So, make sure we
349  * make it big enough to start with.
350  *
351  * The shared memory allocator must be specified too.
352  */
353  infoP->dsize = infoP->max_dsize = hash_select_dirsize(max_size);
354  infoP->alloc = ShmemAllocNoError;
355  hash_flags |= HASH_SHARED_MEM | HASH_ALLOC | HASH_DIRSIZE;
356 
357  /* look it up in the shmem index */
358  location = ShmemInitStruct(name,
359  hash_get_shared_size(infoP, hash_flags),
360  &found);
361 
362  /*
363  * if it already exists, attach to it rather than allocate and initialize
364  * new space
365  */
366  if (found)
367  hash_flags |= HASH_ATTACH;
368 
369  /* Pass location of hashtable header to hash_create */
370  infoP->hctl = (HASHHDR *) location;
371 
372  return hash_create(name, init_size, infoP, hash_flags);
373 }
void * ShmemAllocNoError(Size size)
Definition: shmem.c:181
#define HASH_SHARED_MEM
Definition: hsearch.h:94
long dsize
Definition: hsearch.h:69
#define HASH_ATTACH
Definition: hsearch.h:95
long max_dsize
Definition: hsearch.h:70
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:392
HashAllocFunc alloc
Definition: hsearch.h:77
HTAB * hash_create(const char *tabname, long nelem, HASHCTL *info, int flags)
Definition: dynahash.c:318
long hash_select_dirsize(long num_entries)
Definition: dynahash.c:781
Size hash_get_shared_size(HASHCTL *info, int flags)
Definition: dynahash.c:805
HASHHDR * hctl
Definition: hsearch.h:79
const char * name
Definition: encode.c:555
#define HASH_DIRSIZE
Definition: hsearch.h:85
#define HASH_ALLOC
Definition: hsearch.h:92

◆ ShmemInitStruct()

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

Definition at line 392 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(), InitBufferPool(), InitLocks(), InitPredicateLocks(), InitProcGlobal(), MultiXactShmemInit(), OldSerXidInit(), pgss_shmem_startup(), PMSignalShmemInit(), ProcSignalShmemInit(), ReplicationOriginShmemInit(), ReplicationSlotsShmemInit(), ShmemInitHash(), SimpleLruInit(), SnapMgrInit(), StrategyInitialize(), SyncScanShmemInit(), TwoPhaseShmemInit(), WalRcvShmemInit(), WalSndShmemInit(), and XLOGShmemInit().

393 {
394  ShmemIndexEnt *result;
395  void *structPtr;
396 
397  LWLockAcquire(ShmemIndexLock, LW_EXCLUSIVE);
398 
399  if (!ShmemIndex)
400  {
401  PGShmemHeader *shmemseghdr = ShmemSegHdr;
402 
403  /* Must be trying to create/attach to ShmemIndex itself */
404  Assert(strcmp(name, "ShmemIndex") == 0);
405 
406  if (IsUnderPostmaster)
407  {
408  /* Must be initializing a (non-standalone) backend */
409  Assert(shmemseghdr->index != NULL);
410  structPtr = shmemseghdr->index;
411  *foundPtr = true;
412  }
413  else
414  {
415  /*
416  * If the shmem index doesn't exist, we are bootstrapping: we must
417  * be trying to init the shmem index itself.
418  *
419  * Notice that the ShmemIndexLock is released before the shmem
420  * index has been initialized. This should be OK because no other
421  * process can be accessing shared memory yet.
422  */
423  Assert(shmemseghdr->index == NULL);
424  structPtr = ShmemAlloc(size);
425  shmemseghdr->index = structPtr;
426  *foundPtr = false;
427  }
428  LWLockRelease(ShmemIndexLock);
429  return structPtr;
430  }
431 
432  /* look it up in the shmem index */
433  result = (ShmemIndexEnt *)
435 
436  if (!result)
437  {
438  LWLockRelease(ShmemIndexLock);
439  ereport(ERROR,
440  (errcode(ERRCODE_OUT_OF_MEMORY),
441  errmsg("could not create ShmemIndex entry for data structure \"%s\"",
442  name)));
443  }
444 
445  if (*foundPtr)
446  {
447  /*
448  * Structure is in the shmem index so someone else has allocated it
449  * already. The size better be the same as the size we are trying to
450  * initialize to, or there is a name conflict (or worse).
451  */
452  if (result->size != size)
453  {
454  LWLockRelease(ShmemIndexLock);
455  ereport(ERROR,
456  (errmsg("ShmemIndex entry size is wrong for data structure"
457  " \"%s\": expected %zu, actual %zu",
458  name, size, result->size)));
459  }
460  structPtr = result->location;
461  }
462  else
463  {
464  Size allocated_size;
465 
466  /* It isn't in the table yet. allocate and initialize it */
467  structPtr = ShmemAllocRaw(size, &allocated_size);
468  if (structPtr == NULL)
469  {
470  /* out of memory; remove the failed ShmemIndex entry */
472  LWLockRelease(ShmemIndexLock);
473  ereport(ERROR,
474  (errcode(ERRCODE_OUT_OF_MEMORY),
475  errmsg("not enough shared memory for data structure"
476  " \"%s\" (%zu bytes requested)",
477  name, size)));
478  }
479  result->size = size;
480  result->allocated_size = allocated_size;
481  result->location = structPtr;
482  }
483 
484  LWLockRelease(ShmemIndexLock);
485 
486  Assert(ShmemAddrIsValid(structPtr));
487 
488  Assert(structPtr == (void *) CACHELINEALIGN(structPtr));
489 
490  return structPtr;
491 }
static PGShmemHeader * ShmemSegHdr
Definition: shmem.c:82
Size size
Definition: shmem.h:62
int errcode(int sqlerrcode)
Definition: elog.c:610
void * ShmemAlloc(Size size)
Definition: shmem.c:161
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:908
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1727
static HTAB * ShmemIndex
Definition: shmem.c:91
#define ERROR
Definition: elog.h:43
void * location
Definition: shmem.h:61
bool IsUnderPostmaster
Definition: globals.c:109
static void * ShmemAllocRaw(Size size, Size *allocated_size)
Definition: shmem.c:195
#define ereport(elevel,...)
Definition: elog.h:144
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
#define Assert(condition)
Definition: c.h:738
#define CACHELINEALIGN(LEN)
Definition: c.h:694
size_t Size
Definition: c.h:466
Size allocated_size
Definition: shmem.h:63
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1123
const char * name
Definition: encode.c:555
int errmsg(const char *fmt,...)
Definition: elog.c:824
void * index
Definition: pg_shmem.h:37

◆ 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().

69 {
70  SHM_QUEUE *nextElem = queue->next;
71  SHM_QUEUE *prevElem = queue->prev;
72 
73  Assert(ShmemAddrIsValid(queue));
74  Assert(ShmemAddrIsValid(nextElem));
75  Assert(ShmemAddrIsValid(prevElem));
76 
77  prevElem->next = queue->next;
78  nextElem->prev = queue->prev;
79 
80  queue->prev = queue->next = NULL;
81 }
struct SHM_QUEUE * next
Definition: shmem.h:31
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
struct SHM_QUEUE * prev
Definition: shmem.h:30
#define Assert(condition)
Definition: c.h:738

◆ 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().

58 {
59  Assert(ShmemAddrIsValid(queue));
60  queue->prev = queue->next = NULL;
61 }
struct SHM_QUEUE * next
Definition: shmem.h:31
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
struct SHM_QUEUE * prev
Definition: shmem.h:30
#define Assert(condition)
Definition: c.h:738

◆ 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().

181 {
182  Assert(ShmemAddrIsValid(queue));
183 
184  if (queue->prev == queue)
185  {
186  Assert(queue->next == queue);
187  return true;
188  }
189  return false;
190 }
struct SHM_QUEUE * next
Definition: shmem.h:31
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
struct SHM_QUEUE * prev
Definition: shmem.h:30
#define Assert(condition)
Definition: c.h:738

◆ SHMQueueInit()

void SHMQueueInit ( SHM_QUEUE 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().

109 {
110  SHM_QUEUE *nextPtr = queue->next;
111 
112  Assert(ShmemAddrIsValid(queue));
113  Assert(ShmemAddrIsValid(elem));
114 
115  elem->prev = nextPtr->prev;
116  elem->next = queue->next;
117  queue->next = elem;
118  nextPtr->prev = elem;
119 }
struct SHM_QUEUE * next
Definition: shmem.h:31
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
struct SHM_QUEUE * prev
Definition: shmem.h:30
#define Assert(condition)
Definition: c.h:738

◆ 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().

90 {
91  SHM_QUEUE *prevPtr = queue->prev;
92 
93  Assert(ShmemAddrIsValid(queue));
94  Assert(ShmemAddrIsValid(elem));
95 
96  elem->next = prevPtr->next;
97  elem->prev = queue->prev;
98  queue->prev = elem;
99  prevPtr->next = elem;
100 }
struct SHM_QUEUE * next
Definition: shmem.h:31
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
struct SHM_QUEUE * prev
Definition: shmem.h:30
#define Assert(condition)
Definition: c.h:738

◆ 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().

48 {
49  Assert(ShmemAddrIsValid(queue));
50  return (queue->prev == NULL);
51 }
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
struct SHM_QUEUE * prev
Definition: shmem.h:30
#define Assert(condition)
Definition: c.h:738

◆ SHMQueueNext()

Pointer SHMQueueNext ( const SHM_QUEUE queue,
const SHM_QUEUE curElem,
Size  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().

165 {
166  SHM_QUEUE *elemPtr = curElem->prev;
167 
168  Assert(ShmemAddrIsValid(curElem));
169 
170  if (elemPtr == queue) /* back to the queue head? */
171  return NULL;
172 
173  return (Pointer) (((char *) elemPtr) - linkOffset);
174 }
char * Pointer
Definition: c.h:344
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
struct SHM_QUEUE * prev
Definition: shmem.h:30
#define Assert(condition)
Definition: c.h:738