ipci.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * ipci.c
 *    POSTGRES inter-process communication initialization code.
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/storage/ipc/ipci.c
 *
 *-------------------------------------------------------------------------
 */
#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"
 
/* GUCs */
int         shared_memory_type = DEFAULT_SHARED_MEMORY_TYPE;
 
shmem_startup_hook_type shmem_startup_hook = NULL;
 
static Size total_addin_request = 0;
 
/*
 * RequestAddinShmemSpace
 *      Request that extra shmem space be allocated for use by
 *      a loadable module.
 *
 * This may only be called via the shmem_request_hook of a library that is
 * loaded into the postmaster via shared_preload_libraries.  Calls from
 * elsewhere will fail.
 */
void
RequestAddinShmemSpace(Size size)
{
    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);
}
 
/*
 * CalculateShmemSize
 *      Calculates the amount of shared memory needed.
 */
Size
CalculateShmemSize(void)
{
    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;
}
 
#ifdef EXEC_BACKEND
/*
 * AttachSharedMemoryStructs
 *      Initialize a postmaster child process's access to shared memory
 *      structures.
 *
 * In !EXEC_BACKEND mode, we inherit everything through the fork, and this
 * isn't needed.
 */
void
AttachSharedMemoryStructs(void)
{
    /* InitProcess must've been called already */
    Assert(MyProc != NULL);
    Assert(IsUnderPostmaster);
 
    /*
     * In EXEC_BACKEND mode, backends don't inherit the number of fast-path
     * groups we calculated before setting the shmem up, so recalculate it.
     */
    InitializeFastPathLocks();
 
    /* Establish pointers to all shared memory areas in this backend */
    ShmemAttachRequested();
 
    /*
     * Now give loadable modules a chance to set up their shmem allocations
     */
    if (shmem_startup_hook)
        shmem_startup_hook();
}
#endif
 
/*
 * CreateSharedMemoryAndSemaphores
 *      Creates and initializes shared memory and semaphores.
 */
void
CreateSharedMemoryAndSemaphores(void)
{
    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();
}
 
/*
 * Early initialization of various subsystems, giving them a chance to
 * register their shared memory needs before the shared memory segment is
 * allocated.
 */
void
RegisterBuiltinShmemCallbacks(void)
{
    /*
     * 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
}
 
/*
 * InitializeShmemGUCs
 *
 * This function initializes runtime-computed GUCs related to the amount of
 * shared memory required for the current configuration.
 */
void
InitializeShmemGUCs(void)
{
    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);
}