#include "postgres.h"
#include "access/transam.h"
#include "miscadmin.h"
#include "storage/lwlock.h"
#include "storage/pg_shmem.h"
#include "storage/shmem.h"
#include "storage/spin.h"

Include dependency graph for shmem.c:

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)

Variables
static PGShmemHeader *	ShmemSegHdr

static void *	ShmemBase

static void *	ShmemEnd

slock_t *	ShmemLock

static HTAB *	ShmemIndex = NULL

Function Documentation

Size add_size	(	Size	s1,
		Size	s2
	)

Definition at line 475 of file shmem.c.

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

Referenced by ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), BTreeShmemSize(), BufferShmemSize(), CheckpointerShmemSize(), CreateSharedMemoryAndSemaphores(), CreateSharedProcArray(), estimate_variable_size(), EstimateComboCIDStateSpace(), EstimateGUCStateSpace(), EstimateLibraryStateSpace(), EstimateParamListSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecBitmapHeapEstimate(), hash_estimate_size(), heap_parallelscan_estimate(), index_parallelscan_estimate(), index_parallelscan_initialize(), LockShmemSize(), LWLockShmemSize(), MultiXactShmemSize(), pgss_memsize(), PMSignalShmemSize(), PredicateLockShmemSize(), ProcArrayShmemSize(), ProcGlobalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), RequestAddinShmemSpace(), SerializeTransactionState(), shm_toc_estimate(), SInvalShmemSize(), SnapMgrShmemSize(), StrategyShmemSize(), 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;
 }

void InitShmemAccess ( void * seghdr )

Definition at line 97 of file shmem.c.

References ShmemBase, ShmemEnd, and PGShmemHeader::totalsize.

Referenced by CreateSharedMemoryAndSemaphores().

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

void InitShmemAllocation ( void )

Definition at line 112 of file shmem.c.

References Assert, CACHELINEALIGN, PGShmemHeader::freeoffset, PGShmemHeader::index, NULL, 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));
 }

void InitShmemIndex ( void )

Definition at line 272 of file shmem.c.

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

Referenced by CreateSharedMemoryAndSemaphores().

 {
     HASHCTL     info;
     int         hash_flags;
 
     /*
      * 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);
     hash_flags = HASH_ELEM;
 
     ShmemIndex = ShmemInitHash("ShmemIndex",
                                SHMEM_INDEX_SIZE, SHMEM_INDEX_SIZE,
                                &info, hash_flags);
 }

Size mul_size	(	Size	s1,
		Size	s2
	)

Definition at line 492 of file shmem.c.

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

Referenced by ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), BTreeShmemSize(), BufferShmemSize(), CheckpointerShmemSize(), CreateSharedBackendStatus(), CreateSharedProcArray(), EstimateComboCIDStateSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecInitParallelPlan(), ExecParallelRetrieveInstrumentation(), ExecParallelSetupTupleQueues(), hash_estimate_size(), InitializeParallelDSM(), InitPredicateLocks(), LWLockShmemSize(), PGSemaphoreShmemSize(), PMSignalShmemSize(), PredicateLockShmemSize(), ProcArrayShmemSize(), ProcGlobalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), shm_toc_estimate(), SInvalShmemSize(), SnapMgrShmemSize(), 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;
 }

bool ShmemAddrIsValid ( const void * addr )

Definition at line 263 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);
 }

void* ShmemAlloc ( Size size )

Definition at line 157 of file shmem.c.

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

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

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

void* ShmemAllocNoError ( Size size )

Definition at line 176 of file shmem.c.

References Assert, CACHELINEALIGN, PGShmemHeader::freeoffset, NULL, ShmemBase, ShmemLock, SpinLockAcquire, SpinLockRelease, and totalsize.

Referenced by ShmemAlloc(), ShmemInitHash(), and ShmemInitStruct().

 {
     Size        newStart;
     Size        newFree;
     void       *newSpace;
 
     /*
      * Ensure all space is adequately aligned.  We used to only MAXALIGN this
      * space but experience has proved that on modern systems that is not good
      * enough.  Many parts of the system are very sensitive to critical data
      * structures getting split across cache line boundaries.  To avoid that,
      * attempt to align the beginning of the allocation to a cache line
      * boundary.  The calling code will still need to be careful about how it
      * uses the allocated space - e.g. by padding each element in an array of
      * structures out to a power-of-two size - but without this, even that
      * won't be sufficient.
      */
     size = CACHELINEALIGN(size);
 
     Assert(ShmemSegHdr != NULL);
 
     SpinLockAcquire(ShmemLock);
 
     newStart = ShmemSegHdr->freeoffset;
 
     newFree = newStart + size;
     if (newFree <= ShmemSegHdr->totalsize)
     {
         newSpace = (void *) ((char *) ShmemBase + newStart);
         ShmemSegHdr->freeoffset = newFree;
     }
     else
         newSpace = NULL;
 
     SpinLockRelease(ShmemLock);
 
     /* note this assert is okay with newSpace == NULL */
     Assert(newSpace == (void *) CACHELINEALIGN(newSpace));
 
     return newSpace;
 }

void* ShmemAllocUnlocked ( Size size )

Definition at line 227 of file shmem.c.

References Assert, ereport, errcode(), errmsg(), ERROR, PGShmemHeader::freeoffset, MAXALIGN, NULL, 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;
 }

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

Definition at line 317 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);
 }

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

Definition at line 372 of file shmem.c.

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

Referenced by ApplyLauncherShmemInit(), apw_init_shmem(), AsyncShmemInit(), AutoVacuumShmemInit(), BackendRandomShmemInit(), 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().

 {
     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
     {
         /* It isn't in the table yet. allocate and initialize it */
         structPtr = ShmemAllocNoError(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->location = structPtr;
     }
 
     LWLockRelease(ShmemIndexLock);
 
     Assert(ShmemAddrIsValid(structPtr));
 
     Assert(structPtr == (void *) CACHELINEALIGN(structPtr));
 
     return structPtr;
 }