#include "postgres.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/dsm.h"
#include "storage/ipc.h"
#include "storage/lock.h"
#include "storage/pg_shmem.h"
#include "storage/proc.h"
#include "storage/shmem_internal.h"
#include "storage/subsystems.h"
#include "utils/guc.h"
#include "storage/subsystemlist.h"

Include dependency graph for ipci.c:

Macros
#define	PG_SHMEM_SUBSYSTEM(subsystem_callbacks) RegisterShmemCallbacks(&(subsystem_callbacks));

Functions
void	RequestAddinShmemSpace (Size size)

Size	CalculateShmemSize (void)

void	CreateSharedMemoryAndSemaphores (void)

void	RegisterBuiltinShmemCallbacks (void)

void	InitializeShmemGUCs (void)

Variables
int	shared_memory_type = DEFAULT_SHARED_MEMORY_TYPE

shmem_startup_hook_type	shmem_startup_hook = NULL

static Size	total_addin_request = 0

Macro Definition Documentation

◆ PG_SHMEM_SUBSYSTEM

#define PG_SHMEM_SUBSYSTEM ( subsystem_callbacks ) RegisterShmemCallbacks(&(subsystem_callbacks));

Function Documentation

◆ CalculateShmemSize()

Size CalculateShmemSize ( void )

Definition at line 57 of file ipci.c.

{
    Size        size;
 
    /*
     * Size of the Postgres shared-memory block is estimated via moderately-
     * accurate estimates for the big hogs, plus 100K for the stuff that's too
     * small to bother with estimating.
     *
     * We take some care to ensure that the total size request doesn't
     * overflow size_t.  If this gets through, we don't need to be so careful
     * during the actual allocation phase.
     */
    size = 100000;
    size = add_size(size, ShmemGetRequestedSize());
 
    /* include additional requested shmem from preload libraries */
    size = add_size(size, total_addin_request);
 
    /* might as well round it off to a multiple of a typical page size */
    size = add_size(size, 8192 - (size % 8192));
 
    return size;
}

References add_size(), ShmemGetRequestedSize(), and total_addin_request.

Referenced by CreateSharedMemoryAndSemaphores(), and InitializeShmemGUCs().

◆ CreateSharedMemoryAndSemaphores()

void CreateSharedMemoryAndSemaphores ( void )

Definition at line 120 of file ipci.c.

{
    PGShmemHeader *shim;
    PGShmemHeader *seghdr;
    Size        size;
 
    Assert(!IsUnderPostmaster);
 
    /* Compute the size of the shared-memory block */
    size = CalculateShmemSize();
    elog(DEBUG3, "invoking IpcMemoryCreate(size=%zu)", size);
 
    /*
     * Create the shmem segment
     */
    seghdr = PGSharedMemoryCreate(size, &shim);
 
    /*
     * Make sure that huge pages are never reported as "unknown" while the
     * server is running.
     */
    Assert(strcmp("unknown",
                  GetConfigOption("huge_pages_status", false, false)) != 0);
 
    /*
     * Set up shared memory allocation mechanism
     */
    InitShmemAllocator(seghdr);
 
    /* Initialize all shmem areas */
    ShmemInitRequested();
 
    /* Initialize dynamic shared memory facilities. */
    dsm_postmaster_startup(shim);
 
    /*
     * Now give loadable modules a chance to set up their shmem allocations
     */
    if (shmem_startup_hook)
        shmem_startup_hook();
}

References Assert, CalculateShmemSize(), DEBUG3, dsm_postmaster_startup(), elog, fb(), GetConfigOption(), InitShmemAllocator(), IsUnderPostmaster, PGSharedMemoryCreate(), shmem_startup_hook, and ShmemInitRequested().

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), PostmasterMain(), and PostmasterStateMachine().

◆ InitializeShmemGUCs()

void InitializeShmemGUCs ( void )

Definition at line 189 of file ipci.c.

{
    char        buf[64];
    Size        size_b;
    Size        size_mb;
    Size        hp_size;
 
    /*
     * Calculate the shared memory size and round up to the nearest megabyte.
     */
    size_b = CalculateShmemSize();
    size_mb = add_size(size_b, (1024 * 1024) - 1) / (1024 * 1024);
    sprintf(buf, "%zu", size_mb);
    SetConfigOption("shared_memory_size", buf,
                    PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
 
    /*
     * Calculate the number of huge pages required.
     */
    GetHugePageSize(&hp_size, NULL);
    if (hp_size != 0)
    {
        Size        hp_required;
 
        hp_required = size_b / hp_size;
        if (size_b % hp_size != 0)
            hp_required = add_size(hp_required, 1);
        sprintf(buf, "%zu", hp_required);
        SetConfigOption("shared_memory_size_in_huge_pages", buf,
                        PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
    }
 
    sprintf(buf, "%d", ProcGlobalSemas());
    SetConfigOption("num_os_semaphores", buf, PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
}

References add_size(), buf, CalculateShmemSize(), fb(), GetHugePageSize(), PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT, ProcGlobalSemas(), SetConfigOption(), and sprintf.

Referenced by PostgresSingleUserMain(), and PostmasterMain().

◆ RegisterBuiltinShmemCallbacks()

void RegisterBuiltinShmemCallbacks ( void )

Definition at line 168 of file ipci.c.

{
    /*
     * Call RegisterShmemCallbacks(...) on each subsystem listed in
     * subsystemslist.h
     */
#define PG_SHMEM_SUBSYSTEM(subsystem_callbacks) \
    RegisterShmemCallbacks(&(subsystem_callbacks));
 
#include "storage/subsystemlist.h"
 
#undef PG_SHMEM_SUBSYSTEM
}

Referenced by BootstrapModeMain(), PostgresSingleUserMain(), and PostmasterMain().

◆ RequestAddinShmemSpace()

void RequestAddinShmemSpace ( Size size )

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