ipc.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg)
#define	PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg)

Typedefs
typedef void(*	pg_on_exit_callback) (int code, Datum arg)
typedef void(*	shmem_startup_hook_type) (void)

Functions
void	proc_exit (int code) pg_attribute_noreturn()
void	shmem_exit (int code)
void	on_proc_exit (pg_on_exit_callback function, Datum arg)
void	on_shmem_exit (pg_on_exit_callback function, Datum arg)
void	before_shmem_exit (pg_on_exit_callback function, Datum arg)
void	cancel_before_shmem_exit (pg_on_exit_callback function, Datum arg)
void	on_exit_reset (void)
void	check_on_shmem_exit_lists_are_empty (void)
Size	CalculateShmemSize (int *num_semaphores)
void	CreateSharedMemoryAndSemaphores (void)
void	InitializeShmemGUCs (void)

Variables
PGDLLIMPORT bool	proc_exit_inprogress
PGDLLIMPORT bool	shmem_exit_inprogress
PGDLLIMPORT shmem_startup_hook_type	shmem_startup_hook

Macro Definition Documentation

PG_END_ENSURE_ERROR_CLEANUP

#define PG_END_ENSURE_ERROR_CLEANUP	(		cleanup_function,
			arg
	)

Value:

        cancel_before_shmem_exit(cleanup_function, arg); \
        PG_CATCH(); \
        { \
            cancel_before_shmem_exit(cleanup_function, arg); \
            cleanup_function (0, arg); \
            PG_RE_THROW(); \
        } \
        PG_END_TRY(); \
    } while (0)

Definition at line 52 of file ipc.h.

PG_ENSURE_ERROR_CLEANUP

#define PG_ENSURE_ERROR_CLEANUP	(		cleanup_function,
			arg
	)

Value:

    do { \
        before_shmem_exit(cleanup_function, arg); \
        PG_TRY()

Definition at line 47 of file ipc.h.

Typedef Documentation

pg_on_exit_callback

typedef void(* pg_on_exit_callback) (int code, Datum arg)

Definition at line 21 of file ipc.h.

shmem_startup_hook_type

typedef void(* shmem_startup_hook_type) (void)

Definition at line 22 of file ipc.h.

Function Documentation

before_shmem_exit()

void before_shmem_exit	(	pg_on_exit_callback	function,
		Datum	arg
	)

Definition at line 333 of file ipc.c.

{
    if (before_shmem_exit_index >= MAX_ON_EXITS)
        ereport(FATAL,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg_internal("out of before_shmem_exit slots")));
 
    before_shmem_exit_list[before_shmem_exit_index].function = function;
    before_shmem_exit_list[before_shmem_exit_index].arg = arg;
 
    ++before_shmem_exit_index;
 
    if (!atexit_callback_setup)
    {
        atexit(atexit_callback);
        atexit_callback_setup = true;
    }
}

References ONEXIT::arg, arg, atexit_callback(), atexit_callback_setup, before_shmem_exit_index, before_shmem_exit_list, ereport, errcode(), errmsg_internal(), FATAL, ONEXIT::function, and MAX_ON_EXITS.

Referenced by ApplyLauncherMain(), AtEOXact_Namespace(), AuxiliaryProcessMain(), CheckpointerMain(), Exec_ListenPreCommit(), InitPostgres(), InitTemporaryFileAccess(), LoadArchiveLibrary(), LockGXact(), logicalrep_worker_attach(), MarkAsPreparing(), ParallelApplyWorkerMain(), ParallelWorkerMain(), pgstat_initialize(), register_persistent_abort_backup_handler(), and ReplicationSlotInitialize().

CalculateShmemSize()

Size CalculateShmemSize

(

int *

num_semaphores

)

Definition at line 86 of file ipci.c.

{
    Size        size;
    int         numSemas;
 
    /* Compute number of semaphores we'll need */
    numSemas = ProcGlobalSemas();
    numSemas += SpinlockSemas();
 
    /* 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, SpinlockSemaSize());
    size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE,
                                             sizeof(ShmemIndexEnt)));
    size = add_size(size, dsm_estimate_size());
    size = add_size(size, BufferShmemSize());
    size = add_size(size, LockShmemSize());
    size = add_size(size, PredicateLockShmemSize());
    size = add_size(size, ProcGlobalShmemSize());
    size = add_size(size, XLogPrefetchShmemSize());
    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, SInvalShmemSize());
    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, 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, WaitEventExtensionShmemSize());
#ifdef EXEC_BACKEND
    size = add_size(size, ShmemBackendArraySize());
#endif
 
    /* 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(), ApplyLauncherShmemSize(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), BTreeShmemSize(), BufferShmemSize(), CheckpointerShmemSize(), CLOGShmemSize(), CommitTsShmemSize(), dsm_estimate_size(), hash_estimate_size(), LockShmemSize(), LWLockShmemSize(), MultiXactShmemSize(), PgArchShmemSize(), PGSemaphoreShmemSize(), PMSignalShmemSize(), PredicateLockShmemSize(), ProcArrayShmemSize(), ProcGlobalSemas(), ProcGlobalShmemSize(), ProcSignalShmemSize(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), SHMEM_INDEX_SIZE, SInvalShmemSize(), SpinlockSemas(), SpinlockSemaSize(), StatsShmemSize(), SUBTRANSShmemSize(), SyncScanShmemSize(), total_addin_request, TwoPhaseShmemSize(), WaitEventExtensionShmemSize(), WalRcvShmemSize(), WalSndShmemSize(), XLogPrefetchShmemSize(), XLogRecoveryShmemSize(), and XLOGShmemSize().

Referenced by CreateSharedMemoryAndSemaphores(), and InitializeShmemGUCs().

cancel_before_shmem_exit()

void cancel_before_shmem_exit	(	pg_on_exit_callback	function,
		Datum	arg
	)

Definition at line 390 of file ipc.c.

{
    if (before_shmem_exit_index > 0 &&
        before_shmem_exit_list[before_shmem_exit_index - 1].function
        == function &&
        before_shmem_exit_list[before_shmem_exit_index - 1].arg == arg)
        --before_shmem_exit_index;
    else
        elog(ERROR, "before_shmem_exit callback (%p,0x%llx) is not the latest entry",
             function, (long long) arg);
}

References arg, before_shmem_exit_index, before_shmem_exit_list, elog(), and ERROR.

check_on_shmem_exit_lists_are_empty()

void check_on_shmem_exit_lists_are_empty

(

void

)

Definition at line 428 of file ipc.c.

{
    if (before_shmem_exit_index)
        elog(FATAL, "before_shmem_exit has been called prematurely");
    if (on_shmem_exit_index)
        elog(FATAL, "on_shmem_exit has been called prematurely");
    /* Checking DSM detach state seems unnecessary given the above */
}

References before_shmem_exit_index, elog(), FATAL, and on_shmem_exit_index.

Referenced by BackendInitialize().

CreateSharedMemoryAndSemaphores()

void CreateSharedMemoryAndSemaphores

(

void

)

Definition at line 175 of file ipci.c.

{
    PGShmemHeader *shim = NULL;
 
    if (!IsUnderPostmaster)
    {
        PGShmemHeader *seghdr;
        Size        size;
        int         numSemas;
 
        /* 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);
 
        /*
         * If spinlocks are disabled, initialize emulation layer (which
         * depends on semaphores, so the order is important here).
         */
#ifndef HAVE_SPINLOCKS
        SpinlockSemaInit();
#endif
    }
    else
    {
        /*
         * We are reattaching to an existing shared memory segment. This
         * should only be reached in the EXEC_BACKEND case.
         */
#ifndef EXEC_BACKEND
        elog(PANIC, "should be attached to shared memory already");
#endif
    }
 
    /*
     * Set up shared memory allocation mechanism
     */
    if (!IsUnderPostmaster)
        InitShmemAllocation();
 
    /*
     * Now initialize LWLocks, which do shared memory allocation and are
     * needed for InitShmemIndex.
     */
    CreateLWLocks();
 
    /*
     * Set up shmem.c index hashtable
     */
    InitShmemIndex();
 
    dsm_shmem_init();
 
    /*
     * Set up xlog, clog, and buffers
     */
    XLOGShmemInit();
    XLogPrefetchShmemInit();
    XLogRecoveryShmemInit();
    CLOGShmemInit();
    CommitTsShmemInit();
    SUBTRANSShmemInit();
    MultiXactShmemInit();
    InitBufferPool();
 
    /*
     * Set up lock manager
     */
    InitLocks();
 
    /*
     * Set up predicate lock manager
     */
    InitPredicateLocks();
 
    /*
     * Set up process table
     */
    if (!IsUnderPostmaster)
        InitProcGlobal();
    CreateSharedProcArray();
    CreateSharedBackendStatus();
    TwoPhaseShmemInit();
    BackgroundWorkerShmemInit();
 
    /*
     * Set up shared-inval messaging
     */
    CreateSharedInvalidationState();
 
    /*
     * Set up interprocess signaling mechanisms
     */
    PMSignalShmemInit();
    ProcSignalShmemInit();
    CheckpointerShmemInit();
    AutoVacuumShmemInit();
    ReplicationSlotsShmemInit();
    ReplicationOriginShmemInit();
    WalSndShmemInit();
    WalRcvShmemInit();
    PgArchShmemInit();
    ApplyLauncherShmemInit();
 
    /*
     * Set up other modules that need some shared memory space
     */
    BTreeShmemInit();
    SyncScanShmemInit();
    AsyncShmemInit();
    StatsShmemInit();
    WaitEventExtensionShmemInit();
 
#ifdef EXEC_BACKEND
 
    /*
     * Alloc the win32 shared backend array
     */
    if (!IsUnderPostmaster)
        ShmemBackendArrayAllocation();
#endif
 
    /* Initialize dynamic shared memory facilities. */
    if (!IsUnderPostmaster)
        dsm_postmaster_startup(shim);
 
    /*
     * Now give loadable modules a chance to set up their shmem allocations
     */
    if (shmem_startup_hook)
        shmem_startup_hook();
}

References ApplyLauncherShmemInit(), Assert(), AsyncShmemInit(), AutoVacuumShmemInit(), BackgroundWorkerShmemInit(), BTreeShmemInit(), CalculateShmemSize(), CheckpointerShmemInit(), CLOGShmemInit(), CommitTsShmemInit(), CreateLWLocks(), CreateSharedBackendStatus(), CreateSharedInvalidationState(), CreateSharedProcArray(), DEBUG3, dsm_postmaster_startup(), dsm_shmem_init(), elog(), GetConfigOption(), InitBufferPool(), InitLocks(), InitPredicateLocks(), InitProcGlobal(), InitShmemAccess(), InitShmemAllocation(), InitShmemIndex(), IsUnderPostmaster, MultiXactShmemInit(), PANIC, PgArchShmemInit(), PGReserveSemaphores(), PGSharedMemoryCreate(), PMSignalShmemInit(), ProcSignalShmemInit(), ReplicationOriginShmemInit(), ReplicationSlotsShmemInit(), shmem_startup_hook, SpinlockSemaInit(), StatsShmemInit(), SUBTRANSShmemInit(), SyncScanShmemInit(), TwoPhaseShmemInit(), WaitEventExtensionShmemInit(), WalRcvShmemInit(), WalSndShmemInit(), XLogPrefetchShmemInit(), XLogRecoveryShmemInit(), and XLOGShmemInit().

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

InitializeShmemGUCs()

void InitializeShmemGUCs

(

void

)

Definition at line 333 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(NULL);
    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);
    }
}

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

Referenced by PostgresSingleUserMain(), and PostmasterMain().

on_exit_reset()

void on_exit_reset

(

void

)

Definition at line 412 of file ipc.c.

{
    before_shmem_exit_index = 0;
    on_shmem_exit_index = 0;
    on_proc_exit_index = 0;
    reset_on_dsm_detach();
}

References before_shmem_exit_index, on_proc_exit_index, on_shmem_exit_index, and reset_on_dsm_detach().

Referenced by InitPostmasterChild().

on_proc_exit()

void on_proc_exit	(	pg_on_exit_callback	function,
		Datum	arg
	)

Definition at line 305 of file ipc.c.

{
    if (on_proc_exit_index >= MAX_ON_EXITS)
        ereport(FATAL,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg_internal("out of on_proc_exit slots")));
 
    on_proc_exit_list[on_proc_exit_index].function = function;
    on_proc_exit_list[on_proc_exit_index].arg = arg;
 
    ++on_proc_exit_index;
 
    if (!atexit_callback_setup)
    {
        atexit(atexit_callback);
        atexit_callback_setup = true;
    }
}

References ONEXIT::arg, arg, atexit_callback(), atexit_callback_setup, ereport, errcode(), errmsg_internal(), FATAL, ONEXIT::function, MAX_ON_EXITS, on_proc_exit_index, and on_proc_exit_list.

Referenced by CreateLockFile(), InitCatCache(), llvm_session_initialize(), PostgresMain(), PostmasterMain(), pq_init(), select_perl_context(), sepgsql_avc_init(), and smgrinit().

on_shmem_exit()

void on_shmem_exit	(	pg_on_exit_callback	function,
		Datum	arg
	)

Definition at line 361 of file ipc.c.

{
    if (on_shmem_exit_index >= MAX_ON_EXITS)
        ereport(FATAL,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg_internal("out of on_shmem_exit slots")));
 
    on_shmem_exit_list[on_shmem_exit_index].function = function;
    on_shmem_exit_list[on_shmem_exit_index].arg = arg;
 
    ++on_shmem_exit_index;
 
    if (!atexit_callback_setup)
    {
        atexit(atexit_callback);
        atexit_callback_setup = true;
    }
}

References ONEXIT::arg, arg, atexit_callback(), atexit_callback_setup, ereport, errcode(), errmsg_internal(), FATAL, ONEXIT::function, MAX_ON_EXITS, on_shmem_exit_index, and on_shmem_exit_list.

Referenced by autoprewarm_main(), AutoVacWorkerMain(), CreateAuxProcessResourceOwner(), dsm_postmaster_startup(), InitAuxiliaryProcess(), InitBufferPoolAccess(), InitProcess(), InitProcessPhase2(), InitWalSenderSlot(), InternalIpcMemoryCreate(), PgArchiverMain(), PGReserveSemaphores(), PGSharedMemoryCreate(), pgss_shmem_startup(), pgstat_beinit(), ProcSignalInit(), replorigin_session_setup(), SharedInvalBackendInit(), StartupProcessMain(), and WalReceiverMain().

proc_exit()

void proc_exit

(

int

code

)

Definition at line 104 of file ipc.c.

{
    /* Clean up everything that must be cleaned up */
    proc_exit_prepare(code);
 
#ifdef PROFILE_PID_DIR
    {
        /*
         * If we are profiling ourself then gprof's mcleanup() is about to
         * write out a profile to ./gmon.out.  Since mcleanup() always uses a
         * fixed file name, each backend will overwrite earlier profiles. To
         * fix that, we create a separate subdirectory for each backend
         * (./gprof/pid) and 'cd' to that subdirectory before we exit() - that
         * forces mcleanup() to write each profile into its own directory.  We
         * end up with something like: $PGDATA/gprof/8829/gmon.out
         * $PGDATA/gprof/8845/gmon.out ...
         *
         * To avoid undesirable disk space bloat, autovacuum workers are
         * discriminated against: all their gmon.out files go into the same
         * subdirectory.  Without this, an installation that is "just sitting
         * there" nonetheless eats megabytes of disk space every few seconds.
         *
         * Note that we do this here instead of in an on_proc_exit() callback
         * because we want to ensure that this code executes last - we don't
         * want to interfere with any other on_proc_exit() callback.  For the
         * same reason, we do not include it in proc_exit_prepare ... so if
         * you are exiting in the "wrong way" you won't drop your profile in a
         * nice place.
         */
        char        gprofDirName[32];
 
        if (IsAutoVacuumWorkerProcess())
            snprintf(gprofDirName, 32, "gprof/avworker");
        else
            snprintf(gprofDirName, 32, "gprof/%d", (int) getpid());
 
        /*
         * Use mkdir() instead of MakePGDirectory() since we aren't making a
         * PG directory here.
         */
        mkdir("gprof", S_IRWXU | S_IRWXG | S_IRWXO);
        mkdir(gprofDirName, S_IRWXU | S_IRWXG | S_IRWXO);
        chdir(gprofDirName);
    }
#endif
 
    elog(DEBUG3, "exit(%d)", code);
 
    exit(code);
}

References DEBUG3, elog(), exit(), IsAutoVacuumWorkerProcess(), mkdir, proc_exit_prepare(), S_IRWXG, S_IRWXO, S_IRWXU, and snprintf.

Referenced by apply_worker_exit(), ApplyWorkerMain(), auth_failed(), AutoVacLauncherMain(), AutoVacWorkerMain(), AuxiliaryProcessMain(), BackendInitialize(), BootstrapModeMain(), CheckerModeMain(), DisableSubscriptionAndExit(), errfinish(), ExitPostmaster(), HandleCheckpointerInterrupts(), HandleMainLoopInterrupts(), HandlePgArchInterrupts(), HandleStartupProcInterrupts(), HandleWalWriterInterrupts(), InitializeLogRepWorker(), maybe_reread_subscription(), PerformWalRecovery(), pg_attribute_noreturn(), PgArchiverMain(), PostgresMain(), PostgresSingleUserMain(), PreRestoreCommand(), process_syncing_tables_for_apply(), ProcessInterrupts(), ProcessParallelApplyInterrupts(), ProcessRepliesIfAny(), ProcessStandbyMessage(), RestoreArchivedFile(), StartBackgroundWorker(), StartLogicalReplication(), StartReplication(), StartupProcessMain(), StartupProcShutdownHandler(), SysLoggerMain(), test_shm_mq_main(), WaitEventSetWaitBlock(), WalRcvWaitForStartPosition(), WalReceiverMain(), WalSndDone(), WalSndErrorCleanup(), and WalSndWait().

shmem_exit()

void shmem_exit

(

int

code

)

Definition at line 224 of file ipc.c.

{
    shmem_exit_inprogress = true;
 
    /*
     * Call before_shmem_exit callbacks.
     *
     * These should be things that need most of the system to still be up and
     * working, such as cleanup of temp relations, which requires catalog
     * access; or things that need to be completed because later cleanup steps
     * depend on them, such as releasing lwlocks.
     */
    elog(DEBUG3, "shmem_exit(%d): %d before_shmem_exit callbacks to make",
         code, before_shmem_exit_index);
    while (--before_shmem_exit_index >= 0)
        before_shmem_exit_list[before_shmem_exit_index].function(code,
                                                                 before_shmem_exit_list[before_shmem_exit_index].arg);
    before_shmem_exit_index = 0;
 
    /*
     * Call dynamic shared memory callbacks.
     *
     * These serve the same purpose as late callbacks, but for dynamic shared
     * memory segments rather than the main shared memory segment.
     * dsm_backend_shutdown() has the same kind of progressive logic we use
     * for the main shared memory segment; namely, it unregisters each
     * callback before invoking it, so that we don't get stuck in an infinite
     * loop if one of those callbacks itself throws an ERROR or FATAL.
     *
     * Note that explicitly calling this function here is quite different from
     * registering it as an on_shmem_exit callback for precisely this reason:
     * if one dynamic shared memory callback errors out, the remaining
     * callbacks will still be invoked.  Thus, hard-coding this call puts it
     * equal footing with callbacks for the main shared memory segment.
     */
    dsm_backend_shutdown();
 
    /*
     * Call on_shmem_exit callbacks.
     *
     * These are generally releasing low-level shared memory resources.  In
     * some cases, this is a backstop against the possibility that the early
     * callbacks might themselves fail, leading to re-entry to this routine;
     * in other cases, it's cleanup that only happens at process exit.
     */
    elog(DEBUG3, "shmem_exit(%d): %d on_shmem_exit callbacks to make",
         code, on_shmem_exit_index);
    while (--on_shmem_exit_index >= 0)
        on_shmem_exit_list[on_shmem_exit_index].function(code,
                                                         on_shmem_exit_list[on_shmem_exit_index].arg);
    on_shmem_exit_index = 0;
 
    shmem_exit_inprogress = false;
}

References arg, before_shmem_exit_index, before_shmem_exit_list, DEBUG3, dsm_backend_shutdown(), elog(), ONEXIT::function, on_shmem_exit_index, on_shmem_exit_list, and shmem_exit_inprogress.

Referenced by PostmasterStateMachine(), and proc_exit_prepare().

Variable Documentation

proc_exit_inprogress

PGDLLIMPORT bool proc_exit_inprogress

extern

Definition at line 40 of file ipc.c.

Referenced by die(), errstart(), llvm_release_context(), llvm_shutdown(), proc_exit_prepare(), ProcessRecoveryConflictInterrupts(), and StatementCancelHandler().

shmem_exit_inprogress

PGDLLIMPORT bool shmem_exit_inprogress

extern

Definition at line 45 of file ipc.c.

Referenced by AtAbort_Portals(), and shmem_exit().

shmem_startup_hook

PGDLLIMPORT shmem_startup_hook_type shmem_startup_hook

extern

Definition at line 57 of file ipci.c.

Referenced by _PG_init(), and CreateSharedMemoryAndSemaphores().