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
pg_noreturn void	proc_exit (int code)
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)
void	RegisterBuiltinShmemCallbacks (void)
Size	CalculateShmemSize (void)
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.

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

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.

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

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  )

extern

Definition at line 344 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, fb(), ONEXIT::function, function, and MAX_ON_EXITS.

Referenced by ApplyLauncherMain(), AtEOXact_Namespace(), autoprewarm_main(), AuxiliaryProcessMainCommon(), BecomeRegisteredListener(), CheckpointerMain(), InitializeLogRepWorker(), InitPostgres(), InitTemporaryFileAccess(), injection_points_set_local(), LoadArchiveLibrary(), LockGXact(), logicalrep_worker_attach(), MarkAsPreparing(), ParallelApplyWorkerMain(), ParallelWorkerMain(), pg_stash_advice_worker_main(), pgaio_init_backend(), pgstat_initialize(), register_persistent_abort_backup_handler(), RepackWorkerMain(), ReplicationSlotInitialize(), and ReplSlotSyncWorkerMain().

CalculateShmemSize()

Size CalculateShmemSize ( void  )

extern

Definition at line 57 of file ipci.c.

{
    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;
}

References add_size(), ShmemGetRequestedSize(), and total_addin_request.

Referenced by CreateSharedMemoryAndSemaphores(), and InitializeShmemGUCs().

cancel_before_shmem_exit()

void cancel_before_shmem_exit ( pg_on_exit_callback  function, Datum  arg  )

extern

Definition at line 401 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%" PRIx64 ") is not the latest entry",
             function, arg);
}

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

check_on_shmem_exit_lists_are_empty()

void check_on_shmem_exit_lists_are_empty ( void  )

extern

Definition at line 439 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  )

extern

Definition at line 120 of file ipci.c.

{
    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();
}

References Assert, CalculateShmemSize(), DEBUG3, dsm_postmaster_startup(), elog, fb(), GetConfigOption(), InitShmemAllocator(), IsUnderPostmaster, PGSharedMemoryCreate(), shmem_startup_hook, and ShmemInitRequested().

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

InitializeShmemGUCs()

void InitializeShmemGUCs ( void  )

extern

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

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

Referenced by PostgresSingleUserMain(), and PostmasterMain().

on_exit_reset()

void on_exit_reset ( void  )

extern

Definition at line 423 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  )

extern

Definition at line 316 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, fb(), ONEXIT::function, 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(), set_backtrace(), and smgrinit().

on_shmem_exit()

void on_shmem_exit ( pg_on_exit_callback  function, Datum  arg  )

extern

Definition at line 372 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, fb(), ONEXIT::function, function, MAX_ON_EXITS, on_shmem_exit_index, and on_shmem_exit_list.

Referenced by AutoVacWorkerMain(), CreateAuxProcessResourceOwner(), DataChecksumsWorkerLauncherMain(), dsm_postmaster_startup(), InitAuxiliaryProcess(), InitBufferManagerAccess(), InitProcess(), InitProcessPhase2(), InitWalSenderSlot(), InternalIpcMemoryCreate(), pgaio_worker_register(), PgArchiverMain(), PGSemaphoreInit(), PGSharedMemoryCreate(), pgss_shmem_init(), pgstat_beinit(), ProcSignalInit(), RegisterPostmasterChildActive(), replorigin_session_setup(), SharedInvalBackendInit(), StartupProcessMain(), WalReceiverMain(), and WalSummarizerMain().

proc_exit()

pg_noreturn void proc_exit ( int  code )

extern

Definition at line 105 of file ipc.c.

{
    /* not safe if forked by system(), etc. */
    if (MyProcPid != (int) getpid())
        elog(PANIC, "proc_exit() called in child process");
 
    /* 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 (AmAutoVacuumWorkerProcess())
            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 AmAutoVacuumWorkerProcess, DEBUG3, elog, fb(), mkdir, MyProcPid, PANIC, proc_exit_prepare(), S_IRWXG, S_IRWXO, S_IRWXU, and snprintf.

Referenced by apply_worker_exit(), ApplyWorkerMain(), auth_failed(), AutoVacLauncherMain(), AutoVacLauncherShutdown(), AutoVacWorkerMain(), BackendInitialize(), BackgroundWorkerMain(), BootstrapModeMain(), check_and_set_sync_info(), CheckerModeMain(), CheckpointerMain(), DisableSubscriptionAndExit(), errfinish(), ExitPostmaster(), FinishSyncWorker(), InitializeLogRepWorker(), IoWorkerMain(), maybe_reread_subscription(), PerformWalRecovery(), PgArchiverMain(), PostgresMain(), PostgresSingleUserMain(), PreRestoreCommand(), ProcessInterrupts(), ProcessMainLoopInterrupts(), ProcessParallelApplyInterrupts(), ProcessPgArchInterrupts(), ProcessRepliesIfAny(), ProcessSlotSyncMessage(), ProcessStandbyMessage(), ProcessStartupProcInterrupts(), ProcessSyncingTablesForApply(), ProcessWalSummarizerInterrupts(), ReplSlotSyncWorkerMain(), RestoreArchivedFile(), slotsync_reread_config(), StartLogicalReplication(), StartReplication(), StartupProcessMain(), StartupProcShutdownHandler(), SysLoggerMain(), test_shm_mq_main(), WaitEventSetWaitBlock(), WalRcvWaitForStartPosition(), WalReceiverMain(), WalSndDone(), WalSndDoneImmediate(), WalSndErrorCleanup(), WalSndShutdown(), WalSndWait(), and WalSummarizerMain().

RegisterBuiltinShmemCallbacks()

void RegisterBuiltinShmemCallbacks ( void  )

extern

Definition at line 168 of file ipci.c.

{
    /*
     * 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
}

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

shmem_exit()

void shmem_exit ( int  code )

extern

Definition at line 229 of file ipc.c.

{
    shmem_exit_inprogress = true;
 
    /*
     * Release any LWLocks we might be holding before callbacks run. This
     * prevents accessing locks in detached DSM segments and allows callbacks
     * to acquire new locks.
     */
    LWLockReleaseAll();
 
    /*
     * 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.
     */
    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, LWLockReleaseAll(), 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 41 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 46 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 31 of file ipci.c.

Referenced by CreateSharedMemoryAndSemaphores().