#include "storage/spin.h"
#include "utils/hsearch.h"

Include dependency graph for shmem.h:

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

Data Structures
struct	ShmemIndexEnt

Macros
#define	SHMEM_INDEX_KEYSIZE (48)

#define	SHMEM_INDEX_SIZE (64)

Functions
void	InitShmemAccess (struct PGShmemHeader *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)

PGDLLIMPORT Size	pg_get_shmem_pagesize (void)

void	RequestAddinShmemSpace (Size size)

Variables
PGDLLIMPORT slock_t *	ShmemLock

Macro Definition Documentation

◆ SHMEM_INDEX_KEYSIZE

#define SHMEM_INDEX_KEYSIZE (48)

Definition at line 51 of file shmem.h.

◆ SHMEM_INDEX_SIZE

#define SHMEM_INDEX_SIZE (64)

Definition at line 53 of file shmem.h.

Function Documentation

◆ add_size()

Size add_size	(	Size	s1,
		Size	s2
	)

Definition at line 493 of file shmem.c.

{
    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;
}

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

Referenced by _brin_parallel_estimate_shared(), _bt_parallel_estimate_shared(), _gin_parallel_estimate_shared(), AioShmemSize(), ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), btestimateparallelscan(), BTreeShmemSize(), BufferManagerShmemSize(), CalculateShmemSize(), CheckpointerShmemSize(), estimate_variable_size(), EstimateClientConnectionInfoSpace(), EstimateComboCIDStateSpace(), EstimateGUCStateSpace(), EstimateLibraryStateSpace(), EstimateParamExecSpace(), EstimateParamListSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAggEstimate(), ExecAppendEstimate(), ExecBitmapHeapEstimate(), ExecBitmapHeapInitializeDSM(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecMemoizeEstimate(), ExecSortEstimate(), expand_planner_arrays(), FastPathLockShmemSize(), hash_estimate_size(), index_parallelscan_estimate(), index_parallelscan_initialize(), InitializeShmemGUCs(), InjectionPointShmemSize(), LockManagerShmemSize(), LWLockShmemSize(), MultiXactShmemSize(), pgaio_worker_shmem_size(), PgArchShmemSize(), PGProcShmemSize(), pgss_memsize(), PMSignalShmemSize(), PredicateLockShmemInit(), PredicateLockShmemSize(), ProcArrayShmemInit(), ProcArrayShmemSize(), ProcGlobalShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), RequestAddinShmemSpace(), SerializeTransactionState(), SharedInvalShmemSize(), shm_toc_estimate(), StatsShmemSize(), StrategyShmemSize(), table_parallelscan_estimate(), tuplesort_estimate_shared(), TwoPhaseShmemSize(), WaitEventCustomShmemSize(), WalRcvShmemSize(), WalSndShmemSize(), and XLOGShmemSize().

◆ InitShmemAccess()

void InitShmemAccess ( struct PGShmemHeader * seghdr )

Definition at line 102 of file shmem.c.

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

References ShmemBase, ShmemEnd, ShmemSegHdr, and PGShmemHeader::totalsize.

Referenced by CreateSharedMemoryAndSemaphores().

◆ InitShmemAllocation()

void InitShmemAllocation ( void )

Definition at line 115 of file shmem.c.

{
    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;
}

References Assert(), CACHELINEALIGN, PGShmemHeader::freeoffset, PGShmemHeader::index, ShmemAllocUnlocked(), ShmemIndex, ShmemLock, ShmemSegHdr, and SpinLockInit.

Referenced by CreateSharedMemoryAndSemaphores().

◆ InitShmemIndex()

void InitShmemIndex ( void )

Definition at line 283 of file shmem.c.

{
    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);
}

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

Referenced by CreateOrAttachShmemStructs().

◆ mul_size()

Size mul_size	(	Size	s1,
		Size	s2
	)

Definition at line 510 of file shmem.c.

{
    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;
}

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

Referenced by _brin_begin_parallel(), _bt_begin_parallel(), _gin_begin_parallel(), AioBackendShmemSize(), AioHandleDataShmemSize(), AioHandleIOVShmemSize(), AioHandleShmemSize(), ApplyLauncherShmemSize(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemInit(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), BTreeShmemSize(), BufferManagerShmemSize(), CheckpointerShmemSize(), EstimateComboCIDStateSpace(), EstimatePendingSyncsSpace(), EstimateReindexStateSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), ExecAggEstimate(), ExecBitmapHeapEstimate(), ExecBitmapHeapInitializeDSM(), ExecHashEstimate(), ExecIncrementalSortEstimate(), ExecInitParallelPlan(), ExecMemoizeEstimate(), ExecParallelRetrieveInstrumentation(), ExecParallelRetrieveJitInstrumentation(), ExecParallelSetupTupleQueues(), ExecSortEstimate(), FastPathLockShmemSize(), hash_estimate_size(), InitializeParallelDSM(), LWLockShmemSize(), parallel_vacuum_init(), PGProcShmemSize(), PGSemaphoreShmemSize(), PMSignalShmemSize(), PredicateLockShmemInit(), PredicateLockShmemSize(), ProcArrayShmemInit(), ProcArrayShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), SharedInvalShmemSize(), shm_toc_estimate(), tuplesort_estimate_shared(), TwoPhaseShmemSize(), WalSndShmemSize(), and XLOGShmemSize().

◆ pg_get_shmem_pagesize()

PGDLLIMPORT Size pg_get_shmem_pagesize ( void )

Definition at line 742 of file shmem.c.

{
    Size        os_page_size;
#ifdef WIN32
    SYSTEM_INFO sysinfo;
 
    GetSystemInfo(&sysinfo);
    os_page_size = sysinfo.dwPageSize;
#else
    os_page_size = sysconf(_SC_PAGESIZE);
#endif
 
    Assert(IsUnderPostmaster);
    Assert(huge_pages_status != HUGE_PAGES_UNKNOWN);
 
    if (huge_pages_status == HUGE_PAGES_ON)
        GetHugePageSize(&os_page_size, NULL);
 
    return os_page_size;
}

References Assert(), GetHugePageSize(), HUGE_PAGES_ON, huge_pages_status, HUGE_PAGES_UNKNOWN, and IsUnderPostmaster.

Referenced by pg_buffercache_numa_pages(), and pg_get_shmem_allocations_numa().

◆ RequestAddinShmemSpace()

void RequestAddinShmemSpace ( Size size )

Definition at line 74 of file ipci.c.

{
    if (!process_shmem_requests_in_progress)
        elog(FATAL, "cannot request additional shared memory outside shmem_request_hook");
    total_addin_request = add_size(total_addin_request, size);
}

References add_size(), elog, FATAL, process_shmem_requests_in_progress, and total_addin_request.

Referenced by injection_shmem_request(), pgss_shmem_request(), test_aio_shmem_request(), and test_slru_shmem_request().

◆ ShmemAddrIsValid()

bool ShmemAddrIsValid ( const void * addr )

Definition at line 274 of file shmem.c.

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

References ShmemBase, and ShmemEnd.

Referenced by ReleasePredXact(), and ShmemInitStruct().

◆ ShmemAlloc()

void * ShmemAlloc ( Size size )

Definition at line 152 of file shmem.c.

{
    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;
}

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

Referenced by CreateLWLocks(), ShmemInitStruct(), and StatsShmemInit().

◆ ShmemAllocNoError()

void * ShmemAllocNoError ( Size size )

Definition at line 172 of file shmem.c.

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

References ShmemAllocRaw().

Referenced by ShmemInitHash().

◆ ShmemAllocUnlocked()

void * ShmemAllocUnlocked ( Size size )

Definition at line 238 of file shmem.c.

{
    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 = (char *) ShmemBase + newStart;
 
    Assert(newSpace == (void *) MAXALIGN(newSpace));
 
    return newSpace;
}

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

Referenced by InitShmemAllocation(), and PGReserveSemaphores().

◆ ShmemInitHash()

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

Definition at line 332 of file shmem.c.

{
    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);
}

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, name, ShmemAllocNoError(), and ShmemInitStruct().

Referenced by InitBufTable(), InitShmemIndex(), LockManagerShmemInit(), pgss_shmem_startup(), PredicateLockShmemInit(), and WaitEventCustomShmemInit().

◆ ShmemInitStruct()

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

Definition at line 387 of file shmem.c.

{
    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;
}

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(), name, ShmemAddrIsValid(), ShmemAlloc(), ShmemAllocRaw(), ShmemIndex, ShmemSegHdr, and ShmemIndexEnt::size.

Referenced by AioShmemInit(), ApplyLauncherShmemInit(), AsyncShmemInit(), AutoVacuumShmemInit(), BackendStatusShmemInit(), BackgroundWorkerShmemInit(), BTreeShmemInit(), BufferManagerShmemInit(), CheckpointerShmemInit(), CommitTsShmemInit(), dsm_shmem_init(), DSMRegistryShmemInit(), InitProcGlobal(), injection_shmem_startup(), InjectionPointShmemInit(), LockManagerShmemInit(), MultiXactShmemInit(), pgaio_worker_shmem_init(), PgArchShmemInit(), pgss_shmem_startup(), PMSignalShmemInit(), PredicateLockShmemInit(), ProcArrayShmemInit(), ProcSignalShmemInit(), ReplicationOriginShmemInit(), ReplicationSlotsShmemInit(), SerialInit(), SharedInvalShmemInit(), ShmemInitHash(), SimpleLruInit(), SlotSyncShmemInit(), StatsShmemInit(), StrategyInitialize(), SyncScanShmemInit(), test_aio_shmem_startup(), TwoPhaseShmemInit(), VarsupShmemInit(), WaitEventCustomShmemInit(), WalRcvShmemInit(), WalSndShmemInit(), WalSummarizerShmemInit(), XLogPrefetchShmemInit(), XLogRecoveryShmemInit(), and XLOGShmemInit().

Variable Documentation

◆ ShmemLock

PGDLLIMPORT slock_t* ShmemLock

extern

Definition at line 88 of file shmem.c.

Referenced by InitShmemAllocation(), LWLockNewTrancheId(), and ShmemAllocRaw().

Data Structures

Macros

Functions

Variables