/*-------------------------------------------------------------------------

 *

 * 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

   * subsystemlist.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);

}