src/backend/storage/ipc/ipci.c

   1 /*-------------------------------------------------------------------------
   2  *
   3  * ipci.c
   4  *        POSTGRES inter-process communication initialization code.
   5  *
   6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
   7  * Portions Copyright (c) 1994, Regents of the University of California
   8  *
   9  *
  10  * IDENTIFICATION
  11  *        src/backend/storage/ipc/ipci.c
  12  *
  13  *-------------------------------------------------------------------------
  14  */
  15 #include "postgres.h"
  16
  17 #include "access/clog.h"
  18 #include "access/commit_ts.h"
  19 #include "access/multixact.h"
  20 #include "access/nbtree.h"
  21 #include "access/subtrans.h"
  22 #include "access/syncscan.h"
  23 #include "access/transam.h"
  24 #include "access/twophase.h"
  25 #include "access/xlogprefetcher.h"
  26 #include "access/xlogrecovery.h"
  27 #include "commands/async.h"
  28 #include "commands/waitlsn.h"
  29 #include "miscadmin.h"
  30 #include "pgstat.h"
  31 #include "postmaster/autovacuum.h"
  32 #include "postmaster/bgworker_internals.h"
  33 #include "postmaster/bgwriter.h"
  34 #include "postmaster/postmaster.h"
  35 #include "postmaster/walsummarizer.h"
  36 #include "replication/logicallauncher.h"
  37 #include "replication/origin.h"
  38 #include "replication/slot.h"
  39 #include "replication/slotsync.h"
  40 #include "replication/walreceiver.h"
  41 #include "replication/walsender.h"
  42 #include "storage/bufmgr.h"
  43 #include "storage/dsm.h"
  44 #include "storage/dsm_registry.h"
  45 #include "storage/ipc.h"
  46 #include "storage/pg_shmem.h"
  47 #include "storage/pmsignal.h"
  48 #include "storage/predicate.h"
  49 #include "storage/proc.h"
  50 #include "storage/procarray.h"
  51 #include "storage/procsignal.h"
  52 #include "storage/sinvaladt.h"
  53 #include "storage/spin.h"
  54 #include "utils/guc.h"
  55 #include "utils/injection_point.h"
  56
  57 /* GUCs */
  58 int                     shared_memory_type = DEFAULT_SHARED_MEMORY_TYPE;
  59
  60 shmem_startup_hook_type shmem_startup_hook = NULL;
  61
  62 static Size total_addin_request = 0;
  63
  64 static void CreateOrAttachShmemStructs(void);
  65
  66 /*
  67  * RequestAddinShmemSpace
  68  *              Request that extra shmem space be allocated for use by
  69  *              a loadable module.
  70  *
  71  * This may only be called via the shmem_request_hook of a library that is
  72  * loaded into the postmaster via shared_preload_libraries.  Calls from
  73  * elsewhere will fail.
  74  */
  75 void
  76 RequestAddinShmemSpace(Size size)
  77 {
  78         if (!process_shmem_requests_in_progress)
  79                 elog(FATAL, "cannot request additional shared memory outside shmem_request_hook");
  80         total_addin_request = add_size(total_addin_request, size);
  81 }
  82
  83 /*
  84  * CalculateShmemSize
  85  *              Calculates the amount of shared memory and number of semaphores needed.
  86  *
  87  * If num_semaphores is not NULL, it will be set to the number of semaphores
  88  * required.
  89  */
  90 Size
  91 CalculateShmemSize(int *num_semaphores)
  92 {
  93         Size            size;
  94         int                     numSemas;
  95
  96         /* Compute number of semaphores we'll need */
  97         numSemas = ProcGlobalSemas();
  98
  99         /* Return the number of semaphores if requested by the caller */
 100         if (num_semaphores)
 101                 *num_semaphores = numSemas;
 102
 103         /*
 104          * Size of the Postgres shared-memory block is estimated via moderately-
 105          * accurate estimates for the big hogs, plus 100K for the stuff that's too
 106          * small to bother with estimating.
 107          *
 108          * We take some care to ensure that the total size request doesn't
 109          * overflow size_t.  If this gets through, we don't need to be so careful
 110          * during the actual allocation phase.
 111          */
 112         size = 100000;
 113         size = add_size(size, PGSemaphoreShmemSize(numSemas));
 114         size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE,
 115                                                                                          sizeof(ShmemIndexEnt)));
 116         size = add_size(size, dsm_estimate_size());
 117         size = add_size(size, DSMRegistryShmemSize());
 118         size = add_size(size, BufferManagerShmemSize());
 119         size = add_size(size, LockManagerShmemSize());
 120         size = add_size(size, PredicateLockShmemSize());
 121         size = add_size(size, ProcGlobalShmemSize());
 122         size = add_size(size, XLogPrefetchShmemSize());
 123         size = add_size(size, VarsupShmemSize());
 124         size = add_size(size, XLOGShmemSize());
 125         size = add_size(size, XLogRecoveryShmemSize());
 126         size = add_size(size, CLOGShmemSize());
 127         size = add_size(size, CommitTsShmemSize());
 128         size = add_size(size, SUBTRANSShmemSize());
 129         size = add_size(size, TwoPhaseShmemSize());
 130         size = add_size(size, BackgroundWorkerShmemSize());
 131         size = add_size(size, MultiXactShmemSize());
 132         size = add_size(size, LWLockShmemSize());
 133         size = add_size(size, ProcArrayShmemSize());
 134         size = add_size(size, BackendStatusShmemSize());
 135         size = add_size(size, SharedInvalShmemSize());
 136         size = add_size(size, PMSignalShmemSize());
 137         size = add_size(size, ProcSignalShmemSize());
 138         size = add_size(size, CheckpointerShmemSize());
 139         size = add_size(size, AutoVacuumShmemSize());
 140         size = add_size(size, ReplicationSlotsShmemSize());
 141         size = add_size(size, ReplicationOriginShmemSize());
 142         size = add_size(size, WalSndShmemSize());
 143         size = add_size(size, WalRcvShmemSize());
 144         size = add_size(size, WalSummarizerShmemSize());
 145         size = add_size(size, PgArchShmemSize());
 146         size = add_size(size, ApplyLauncherShmemSize());
 147         size = add_size(size, BTreeShmemSize());
 148         size = add_size(size, SyncScanShmemSize());
 149         size = add_size(size, AsyncShmemSize());
 150         size = add_size(size, StatsShmemSize());
 151         size = add_size(size, WaitEventCustomShmemSize());
 152         size = add_size(size, InjectionPointShmemSize());
 153         size = add_size(size, SlotSyncShmemSize());
 154         size = add_size(size, WaitLSNShmemSize());
 155
 156         /* include additional requested shmem from preload libraries */
 157         size = add_size(size, total_addin_request);
 158
 159         /* might as well round it off to a multiple of a typical page size */
 160         size = add_size(size, 8192 - (size % 8192));
 161
 162         return size;
 163 }
 164
 165 #ifdef EXEC_BACKEND
 166 /*
 167  * AttachSharedMemoryStructs
 168  *              Initialize a postmaster child process's access to shared memory
 169  *      structures.
 170  *
 171  * In !EXEC_BACKEND mode, we inherit everything through the fork, and this
 172  * isn't needed.
 173  */
 174 void
 175 AttachSharedMemoryStructs(void)
 176 {
 177         /* InitProcess must've been called already */
 178         Assert(MyProc != NULL);
 179         Assert(IsUnderPostmaster);
 180
 181         /*
 182          * In EXEC_BACKEND mode, backends don't inherit the number of fast-path
 183          * groups we calculated before setting the shmem up, so recalculate it.
 184          */
 185         InitializeFastPathLocks();
 186
 187         CreateOrAttachShmemStructs();
 188
 189         /*
 190          * Now give loadable modules a chance to set up their shmem allocations
 191          */
 192         if (shmem_startup_hook)
 193                 shmem_startup_hook();
 194 }
 195 #endif
 196
 197 /*
 198  * CreateSharedMemoryAndSemaphores
 199  *              Creates and initializes shared memory and semaphores.
 200  */
 201 void
 202 CreateSharedMemoryAndSemaphores(void)
 203 {
 204         PGShmemHeader *shim;
 205         PGShmemHeader *seghdr;
 206         Size            size;
 207         int                     numSemas;
 208
 209         Assert(!IsUnderPostmaster);
 210
 211         /* Compute the size of the shared-memory block */
 212         size = CalculateShmemSize(&numSemas);
 213         elog(DEBUG3, "invoking IpcMemoryCreate(size=%zu)", size);
 214
 215         /*
 216          * Create the shmem segment
 217          */
 218         seghdr = PGSharedMemoryCreate(size, &shim);
 219
 220         /*
 221          * Make sure that huge pages are never reported as "unknown" while the
 222          * server is running.
 223          */
 224         Assert(strcmp("unknown",
 225                                   GetConfigOption("huge_pages_status", false, false)) != 0);
 226
 227         InitShmemAccess(seghdr);
 228
 229         /*
 230          * Create semaphores
 231          */
 232         PGReserveSemaphores(numSemas);
 233
 234         /*
 235          * Set up shared memory allocation mechanism
 236          */
 237         InitShmemAllocation();
 238
 239         /* Initialize subsystems */
 240         CreateOrAttachShmemStructs();
 241
 242         /* Initialize dynamic shared memory facilities. */
 243         dsm_postmaster_startup(shim);
 244
 245         /*
 246          * Now give loadable modules a chance to set up their shmem allocations
 247          */
 248         if (shmem_startup_hook)
 249                 shmem_startup_hook();
 250 }
 251
 252 /*
 253  * Initialize various subsystems, setting up their data structures in
 254  * shared memory.
 255  *
 256  * This is called by the postmaster or by a standalone backend.
 257  * It is also called by a backend forked from the postmaster in the
 258  * EXEC_BACKEND case.  In the latter case, the shared memory segment
 259  * already exists and has been physically attached to, but we have to
 260  * initialize pointers in local memory that reference the shared structures,
 261  * because we didn't inherit the correct pointer values from the postmaster
 262  * as we do in the fork() scenario.  The easiest way to do that is to run
 263  * through the same code as before.  (Note that the called routines mostly
 264  * check IsUnderPostmaster, rather than EXEC_BACKEND, to detect this case.
 265  * This is a bit code-wasteful and could be cleaned up.)
 266  */
 267 static void
 268 CreateOrAttachShmemStructs(void)
 269 {
 270         /*
 271          * Now initialize LWLocks, which do shared memory allocation and are
 272          * needed for InitShmemIndex.
 273          */
 274         CreateLWLocks();
 275
 276         /*
 277          * Set up shmem.c index hashtable
 278          */
 279         InitShmemIndex();
 280
 281         dsm_shmem_init();
 282         DSMRegistryShmemInit();
 283
 284         /*
 285          * Set up xlog, clog, and buffers
 286          */
 287         VarsupShmemInit();
 288         XLOGShmemInit();
 289         XLogPrefetchShmemInit();
 290         XLogRecoveryShmemInit();
 291         CLOGShmemInit();
 292         CommitTsShmemInit();
 293         SUBTRANSShmemInit();
 294         MultiXactShmemInit();
 295         BufferManagerShmemInit();
 296
 297         /*
 298          * Set up lock manager
 299          */
 300         LockManagerShmemInit();
 301
 302         /*
 303          * Set up predicate lock manager
 304          */
 305         PredicateLockShmemInit();
 306
 307         /*
 308          * Set up process table
 309          */
 310         if (!IsUnderPostmaster)
 311                 InitProcGlobal();
 312         ProcArrayShmemInit();
 313         BackendStatusShmemInit();
 314         TwoPhaseShmemInit();
 315         BackgroundWorkerShmemInit();
 316
 317         /*
 318          * Set up shared-inval messaging
 319          */
 320         SharedInvalShmemInit();
 321
 322         /*
 323          * Set up interprocess signaling mechanisms
 324          */
 325         PMSignalShmemInit();
 326         ProcSignalShmemInit();
 327         CheckpointerShmemInit();
 328         AutoVacuumShmemInit();
 329         ReplicationSlotsShmemInit();
 330         ReplicationOriginShmemInit();
 331         WalSndShmemInit();
 332         WalRcvShmemInit();
 333         WalSummarizerShmemInit();
 334         PgArchShmemInit();
 335         ApplyLauncherShmemInit();
 336         SlotSyncShmemInit();
 337
 338         /*
 339          * Set up other modules that need some shared memory space
 340          */
 341         BTreeShmemInit();
 342         SyncScanShmemInit();
 343         AsyncShmemInit();
 344         StatsShmemInit();
 345         WaitEventCustomShmemInit();
 346         InjectionPointShmemInit();
 347         WaitLSNShmemInit();
 348 }
 349
 350 /*
 351  * InitializeShmemGUCs
 352  *
 353  * This function initializes runtime-computed GUCs related to the amount of
 354  * shared memory required for the current configuration.
 355  */
 356 void
 357 InitializeShmemGUCs(void)
 358 {
 359         char            buf[64];
 360         Size            size_b;
 361         Size            size_mb;
 362         Size            hp_size;
 363         int                     num_semas;
 364
 365         /*
 366          * Calculate the shared memory size and round up to the nearest megabyte.
 367          */
 368         size_b = CalculateShmemSize(&num_semas);
 369         size_mb = add_size(size_b, (1024 * 1024) - 1) / (1024 * 1024);
 370         sprintf(buf, "%zu", size_mb);
 371         SetConfigOption("shared_memory_size", buf,
 372                                         PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
 373
 374         /*
 375          * Calculate the number of huge pages required.
 376          */
 377         GetHugePageSize(&hp_size, NULL);
 378         if (hp_size != 0)
 379         {
 380                 Size            hp_required;
 381
 382                 hp_required = add_size(size_b / hp_size, 1);
 383                 sprintf(buf, "%zu", hp_required);
 384                 SetConfigOption("shared_memory_size_in_huge_pages", buf,
 385                                                 PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
 386         }
 387
 388         sprintf(buf, "%d", num_semas);
 389         SetConfigOption("num_os_semaphores", buf, PGC_INTERNAL, PGC_S_DYNAMIC_DEFAULT);
 390 }