ipci.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * ipci.c
 *    POSTGRES inter-process communication initialization code.
 *
 * Portions Copyright (c) 1996-2024, 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 "access/clog.h"
#include "access/commit_ts.h"
#include "access/multixact.h"
#include "access/nbtree.h"
#include "access/subtrans.h"
#include "access/syncscan.h"
#include "access/transam.h"
#include "access/twophase.h"
#include "access/xlogprefetcher.h"
#include "access/xlogrecovery.h"
#include "commands/async.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "postmaster/autovacuum.h"
#include "postmaster/bgworker_internals.h"
#include "postmaster/bgwriter.h"
#include "postmaster/walsummarizer.h"
#include "replication/logicallauncher.h"
#include "replication/origin.h"
#include "replication/slot.h"
#include "replication/slotsync.h"
#include "replication/walreceiver.h"
#include "replication/walsender.h"
#include "storage/bufmgr.h"
#include "storage/dsm.h"
#include "storage/dsm_registry.h"
#include "storage/ipc.h"
#include "storage/pg_shmem.h"
#include "storage/pmsignal.h"
#include "storage/predicate.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "storage/procsignal.h"
#include "storage/sinvaladt.h"
#include "utils/guc.h"
#include "utils/injection_point.h"
 
/* GUCs */
int         shared_memory_type = DEFAULT_SHARED_MEMORY_TYPE;
 
shmem_startup_hook_type shmem_startup_hook = NULL;
 
static Size total_addin_request = 0;
 
static void CreateOrAttachShmemStructs(void);
 
/*
 * 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 and number of semaphores needed.
 *
 * If num_semaphores is not NULL, it will be set to the number of semaphores
 * required.
 */
Size
CalculateShmemSize(int *num_semaphores)
{
    Size        size;
    int         numSemas;
 
    /* Compute number of semaphores we'll need */
    numSemas = ProcGlobalSemas();
 
    /* Return the number of semaphores if requested by the caller */
    if (num_semaphores)
        *num_semaphores = numSemas;
 
    /*
     * 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, PGSemaphoreShmemSize(numSemas));
    size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE,
                                             sizeof(ShmemIndexEnt)));
    size = add_size(size, dsm_estimate_size());
    size = add_size(size, DSMRegistryShmemSize());
    size = add_size(size, BufferManagerShmemSize());
    size = add_size(size, LockManagerShmemSize());
    size = add_size(size, PredicateLockShmemSize());
    size = add_size(size, ProcGlobalShmemSize());
    size = add_size(size, XLogPrefetchShmemSize());
    size = add_size(size, VarsupShmemSize());
    size = add_size(size, XLOGShmemSize());
    size = add_size(size, XLogRecoveryShmemSize());
    size = add_size(size, CLOGShmemSize());
    size = add_size(size, CommitTsShmemSize());
    size = add_size(size, SUBTRANSShmemSize());
    size = add_size(size, TwoPhaseShmemSize());
    size = add_size(size, BackgroundWorkerShmemSize());
    size = add_size(size, MultiXactShmemSize());
    size = add_size(size, LWLockShmemSize());
    size = add_size(size, ProcArrayShmemSize());
    size = add_size(size, BackendStatusShmemSize());
    size = add_size(size, SharedInvalShmemSize());
    size = add_size(size, PMSignalShmemSize());
    size = add_size(size, ProcSignalShmemSize());
    size = add_size(size, CheckpointerShmemSize());
    size = add_size(size, AutoVacuumShmemSize());
    size = add_size(size, ReplicationSlotsShmemSize());
    size = add_size(size, ReplicationOriginShmemSize());
    size = add_size(size, WalSndShmemSize());
    size = add_size(size, WalRcvShmemSize());
    size = add_size(size, WalSummarizerShmemSize());
    size = add_size(size, PgArchShmemSize());
    size = add_size(size, ApplyLauncherShmemSize());
    size = add_size(size, BTreeShmemSize());
    size = add_size(size, SyncScanShmemSize());
    size = add_size(size, AsyncShmemSize());
    size = add_size(size, StatsShmemSize());
    size = add_size(size, WaitEventCustomShmemSize());
    size = add_size(size, InjectionPointShmemSize());
    size = add_size(size, SlotSyncShmemSize());
 
    /* 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();
 
    CreateOrAttachShmemStructs();
 
    /*
     * 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;
    int         numSemas;
 
    Assert(!IsUnderPostmaster);
 
    /* Compute the size of the shared-memory block */
    size = CalculateShmemSize(&numSemas);
    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);
 
    InitShmemAccess(seghdr);
 
    /*
     * Create semaphores
     */
    PGReserveSemaphores(numSemas);
 
    /*
     * Set up shared memory allocation mechanism
     */
    InitShmemAllocation();
 
    /* Initialize subsystems */
    CreateOrAttachShmemStructs();
 
    /* 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();
}
 
/*
 * Initialize various subsystems, setting up their data structures in
 * shared memory.
 *
 * This is called by the postmaster or by a standalone backend.
 * It is also called by a backend forked from the postmaster in the
 * EXEC_BACKEND case.  In the latter case, the shared memory segment
 * already exists and has been physically attached to, but we have to
 * initialize pointers in local memory that reference the shared structures,
 * because we didn't inherit the correct pointer values from the postmaster
 * as we do in the fork() scenario.  The easiest way to do that is to run
 * through the same code as before.  (Note that the called routines mostly
 * check IsUnderPostmaster, rather than EXEC_BACKEND, to detect this case.
 * This is a bit code-wasteful and could be cleaned up.)
 */
static void
CreateOrAttachShmemStructs(void)
{
    /*
     * Now initialize LWLocks, which do shared memory allocation and are
     * needed for InitShmemIndex.
     */
    CreateLWLocks();
 
    /*
     * Set up shmem.c index hashtable
     */
    InitShmemIndex();
 
    dsm_shmem_init();
    DSMRegistryShmemInit();
 
    /*
     * Set up xlog, clog, and buffers
     */
    VarsupShmemInit();
    XLOGShmemInit();
    XLogPrefetchShmemInit();
    XLogRecoveryShmemInit();
    CLOGShmemInit();
    CommitTsShmemInit();
    SUBTRANSShmemInit();
    MultiXactShmemInit();
    BufferManagerShmemInit();
 
    /*
     * Set up lock manager
     */
    LockManagerShmemInit();
 
    /*
     * Set up predicate lock manager
     */
    PredicateLockShmemInit();
 
    /*
     * Set up process table
     */
    if (!IsUnderPostmaster)
        InitProcGlobal();
    ProcArrayShmemInit();
    BackendStatusShmemInit();
    TwoPhaseShmemInit();
    BackgroundWorkerShmemInit();
 
    /*
     * Set up shared-inval messaging
     */
    SharedInvalShmemInit();
 
    /*
     * Set up interprocess signaling mechanisms
     */
    PMSignalShmemInit();
    ProcSignalShmemInit();
    CheckpointerShmemInit();
    AutoVacuumShmemInit();
    ReplicationSlotsShmemInit();
    ReplicationOriginShmemInit();
    WalSndShmemInit();
    WalRcvShmemInit();
    WalSummarizerShmemInit();
    PgArchShmemInit();
    ApplyLauncherShmemInit();
    SlotSyncShmemInit();
 
    /*
     * Set up other modules that need some shared memory space
     */
    BTreeShmemInit();
    SyncScanShmemInit();
    AsyncShmemInit();
    StatsShmemInit();
    WaitEventCustomShmemInit();
    InjectionPointShmemInit();
}
 
/*
 * 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;
    int         num_semas;
 
    /*
     * Calculate the shared memory size and round up to the nearest megabyte.
     */
    size_b = CalculateShmemSize(&num_semas);
    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 = add_size(size_b / hp_size, 1);
        sprintf(buf, "%zu", hp_required);
        SetConfigOption("shared_memory_size_in_huge_pages", buf,
                        PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
    }
 
    sprintf(buf, "%d", num_semas);
    SetConfigOption("num_os_semaphores", buf, PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
}