commit 1388d75ab847780ec9b208787724029ed3795520 Author: Robert Haas Date: Tue Oct 1 11:39:52 2013 -0400 Allow on-detach callbacks for shared memory segments. Just as backends must clean up their shared memory state (releasing lwlocks, buffer pins, etc.) before exiting, they must also perform any similar cleanups related to dynamic shared memory segments they have mapped. So add a mechanism to ensure that. Existing on_shmem_exit hooks include both "user level" cleanup such as transaction abort and removal of leftover temporary relations and also "low level" cleanup that forcibly released leftover shared memory resources. On-detach callbacks should run after the first group but before the second group, so split on_shmem_exit into early and late callbacks for that purpose. diff --git a/contrib/pg_stat_statements/pg_stat_statements.c b/contrib/pg_stat_statements/pg_stat_statements.c index ea930af..770f499 100644 --- a/contrib/pg_stat_statements/pg_stat_statements.c +++ b/contrib/pg_stat_statements/pg_stat_statements.c @@ -439,7 +439,7 @@ pgss_shmem_startup(void) * exit hook to dump the statistics to disk. */ if (!IsUnderPostmaster) - on_shmem_exit(pgss_shmem_shutdown, (Datum) 0); + on_shmem_exit(pgss_shmem_shutdown, (Datum) 0, SHMEM_EXIT_LATE); /* * Attempt to load old statistics from the dump file, if this is the first diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c index 62f4c18..4c41f8a 100644 --- a/src/backend/bootstrap/bootstrap.c +++ b/src/backend/bootstrap/bootstrap.c @@ -403,7 +403,7 @@ AuxiliaryProcessMain(int argc, char *argv[]) InitBufferPoolBackend(); /* register a shutdown callback for LWLock cleanup */ - on_shmem_exit(ShutdownAuxiliaryProcess, 0); + on_shmem_exit(ShutdownAuxiliaryProcess, 0, SHMEM_EXIT_EARLY); } /* diff --git a/src/backend/catalog/namespace.c b/src/backend/catalog/namespace.c index 4434dd6..3b4e0ca 100644 --- a/src/backend/catalog/namespace.c +++ b/src/backend/catalog/namespace.c @@ -3681,7 +3681,7 @@ AtEOXact_Namespace(bool isCommit) if (myTempNamespaceSubID != InvalidSubTransactionId) { if (isCommit) - on_shmem_exit(RemoveTempRelationsCallback, 0); + on_shmem_exit(RemoveTempRelationsCallback, 0, SHMEM_EXIT_EARLY); else { myTempNamespace = InvalidOid; diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c index 6414291..f273c0f 100644 --- a/src/backend/commands/async.c +++ b/src/backend/commands/async.c @@ -921,7 +921,7 @@ Exec_ListenPreCommit(void) */ if (!unlistenExitRegistered) { - on_shmem_exit(Async_UnlistenOnExit, 0); + on_shmem_exit(Async_UnlistenOnExit, 0, SHMEM_EXIT_EARLY); unlistenExitRegistered = true; } diff --git a/src/backend/port/ipc_test.c b/src/backend/port/ipc_test.c index 6020ef5..2e067ea 100644 --- a/src/backend/port/ipc_test.c +++ b/src/backend/port/ipc_test.c @@ -56,14 +56,19 @@ char *DataDir = "."; #define MAX_ON_EXITS 20 -static struct ONEXIT +struct ONEXIT { pg_on_exit_callback function; Datum arg; -} on_proc_exit_list[MAX_ON_EXITS], on_shmem_exit_list[MAX_ON_EXITS]; +}; + +static struct ONEXIT on_proc_exit_list[MAX_ON_EXITS]; +static struct ONEXIT on_shmem_exit_early_list[MAX_ON_EXITS]; +static struct ONEXIT on_shmem_exit_late_list[MAX_ON_EXITS]; static int on_proc_exit_index, - on_shmem_exit_index; + on_shmem_exit_early_index, + on_shmem_exit_late_index; void proc_exit(int code) @@ -78,28 +83,51 @@ proc_exit(int code) void shmem_exit(int code) { - 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; + while (--on_shmem_exit_early_index >= 0) + (*on_shmem_exit_early_list[on_shmem_exit_early_index].function) (code, + on_shmem_exit_early_list[on_shmem_exit_early_index].arg); + on_shmem_exit_early_index = 0; + + while (--on_shmem_exit_late_index >= 0) + (*on_shmem_exit_late_list[on_shmem_exit_late_index].function) (code, + on_shmem_exit_late_list[on_shmem_exit_late_index].arg); + on_shmem_exit_late_index = 0; } void -on_shmem_exit(pg_on_exit_callback function, Datum arg) +on_shmem_exit(pg_on_exit_callback function, Datum arg, shmem_exit_phase phase) { - if (on_shmem_exit_index >= MAX_ON_EXITS) - elog(FATAL, "out of on_shmem_exit slots"); + int *index; + struct ONEXIT *list; + + if (phase == SHMEM_EXIT_EARLY) + { + index = &on_shmem_exit_early_index; + list = on_shmem_exit_early_list; + } + else + { + Assert(phase == SHMEM_EXIT_LATE); + index = &on_shmem_exit_late_index; + list = on_shmem_exit_late_list; + } + + if (*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; + list[*index].function = function; + list[*index].arg = arg; - ++on_shmem_exit_index; + ++*index; } void on_exit_reset(void) { - on_shmem_exit_index = 0; + on_shmem_exit_early_index = 0; + on_shmem_exit_late_index = 0; on_proc_exit_index = 0; } diff --git a/src/backend/port/posix_sema.c b/src/backend/port/posix_sema.c index 061fd2d..ff0bb64 100644 --- a/src/backend/port/posix_sema.c +++ b/src/backend/port/posix_sema.c @@ -160,7 +160,7 @@ PGReserveSemaphores(int maxSemas, int port) maxSems = maxSemas; nextSemKey = port * 1000; - on_shmem_exit(ReleaseSemaphores, 0); + on_shmem_exit(ReleaseSemaphores, 0, SHMEM_EXIT_LATE); } /* diff --git a/src/backend/port/sysv_sema.c b/src/backend/port/sysv_sema.c index 2988561..2e10934 100644 --- a/src/backend/port/sysv_sema.c +++ b/src/backend/port/sysv_sema.c @@ -296,7 +296,7 @@ PGReserveSemaphores(int maxSemas, int port) nextSemaKey = port * 1000; nextSemaNumber = SEMAS_PER_SET; /* force sema set alloc on 1st call */ - on_shmem_exit(ReleaseSemaphores, 0); + on_shmem_exit(ReleaseSemaphores, 0, SHMEM_EXIT_LATE); } /* diff --git a/src/backend/port/sysv_shmem.c b/src/backend/port/sysv_shmem.c index b604407..aa80765 100644 --- a/src/backend/port/sysv_shmem.c +++ b/src/backend/port/sysv_shmem.c @@ -165,7 +165,7 @@ InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size) } /* Register on-exit routine to delete the new segment */ - on_shmem_exit(IpcMemoryDelete, Int32GetDatum(shmid)); + on_shmem_exit(IpcMemoryDelete, Int32GetDatum(shmid), SHMEM_EXIT_LATE); /* OK, should be able to attach to the segment */ memAddress = shmat(shmid, NULL, PG_SHMAT_FLAGS); @@ -174,7 +174,8 @@ InternalIpcMemoryCreate(IpcMemoryKey memKey, Size size) elog(FATAL, "shmat(id=%d) failed: %m", shmid); /* Register on-exit routine to detach new segment before deleting */ - on_shmem_exit(IpcMemoryDetach, PointerGetDatum(memAddress)); + on_shmem_exit(IpcMemoryDetach, PointerGetDatum(memAddress), + SHMEM_EXIT_LATE); /* * Store shmem key and ID in data directory lockfile. Format to try to diff --git a/src/backend/port/win32_sema.c b/src/backend/port/win32_sema.c index dc5054b..3f02fea 100644 --- a/src/backend/port/win32_sema.c +++ b/src/backend/port/win32_sema.c @@ -41,7 +41,7 @@ PGReserveSemaphores(int maxSemas, int port) numSems = 0; maxSems = maxSemas; - on_shmem_exit(ReleaseSemaphores, 0); + on_shmem_exit(ReleaseSemaphores, 0, SHMEM_EXIT_LATE); } /* diff --git a/src/backend/port/win32_shmem.c b/src/backend/port/win32_shmem.c index 0db8e8f..28cb739 100644 --- a/src/backend/port/win32_shmem.c +++ b/src/backend/port/win32_shmem.c @@ -212,7 +212,8 @@ PGSharedMemoryCreate(Size size, bool makePrivate, int port) /* Register on-exit routine to delete the new segment */ - on_shmem_exit(pgwin32_SharedMemoryDelete, PointerGetDatum(hmap2)); + on_shmem_exit(pgwin32_SharedMemoryDelete, PointerGetDatum(hmap2), + SHMEM_EXIT_LATE); /* * Get a pointer to the new shared memory segment. Map the whole segment diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 8c14d0f..6596fd3 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -1624,7 +1624,7 @@ AutoVacWorkerMain(int argc, char *argv[]) AutoVacuumShmem->av_startingWorker = NULL; LWLockRelease(AutovacuumLock); - on_shmem_exit(FreeWorkerInfo, 0); + on_shmem_exit(FreeWorkerInfo, 0, SHMEM_EXIT_LATE); /* wake up the launcher */ if (AutoVacuumShmem->av_launcherpid != 0) diff --git a/src/backend/postmaster/pgstat.c b/src/backend/postmaster/pgstat.c index b5ce2f6..2e2351e 100644 --- a/src/backend/postmaster/pgstat.c +++ b/src/backend/postmaster/pgstat.c @@ -2459,7 +2459,7 @@ pgstat_initialize(void) MyBEEntry = &BackendStatusArray[MyBackendId - 1]; /* Set up a process-exit hook to clean up */ - on_shmem_exit(pgstat_beshutdown_hook, 0); + on_shmem_exit(pgstat_beshutdown_hook, 0, SHMEM_EXIT_LATE); } /* ---------- diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c index 413f0b9..ea1773f 100644 --- a/src/backend/replication/walreceiver.c +++ b/src/backend/replication/walreceiver.c @@ -250,7 +250,7 @@ WalReceiverMain(void) SpinLockRelease(&walrcv->mutex); /* Arrange to clean up at walreceiver exit */ - on_shmem_exit(WalRcvDie, 0); + on_shmem_exit(WalRcvDie, 0, SHMEM_EXIT_LATE); OwnLatch(&walrcv->latch); diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index afd559d..a4505c2 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -1207,7 +1207,7 @@ InitWalSenderSlot(void) max_wal_senders))); /* Arrange to clean up at walsender exit */ - on_shmem_exit(WalSndKill, 0); + on_shmem_exit(WalSndKill, 0, SHMEM_EXIT_LATE); } /* Destroy the per-walsender data structure for this walsender process */ diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index f848391..276e29e 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -1741,7 +1741,7 @@ AtEOXact_Buffers(bool isCommit) void InitBufferPoolBackend(void) { - on_shmem_exit(AtProcExit_Buffers, 0); + on_shmem_exit(AtProcExit_Buffers, 0, SHMEM_EXIT_LATE); } /* diff --git a/src/backend/storage/ipc/dsm.c b/src/backend/storage/ipc/dsm.c index 9f9b91a..decf203 100644 --- a/src/backend/storage/ipc/dsm.c +++ b/src/backend/storage/ipc/dsm.c @@ -58,6 +58,14 @@ #define INVALID_CONTROL_SLOT ((uint32) -1) +/* Backend-local tracking for on-detach callbacks. */ +typedef struct dsm_segment_detach_callback +{ + on_dsm_detach_callback function; + Datum arg; + slist_node node; +} dsm_segment_detach_callback; + /* Backend-local state for a dynamic shared memory segment. */ struct dsm_segment { @@ -68,6 +76,7 @@ struct dsm_segment void *impl_private; /* Implementation-specific private data. */ void *mapped_address; /* Mapping address, or NULL if unmapped. */ Size mapped_size; /* Size of our mapping. */ + slist_head on_detach; /* On-detach callbacks. */ }; /* Shared-memory state for a dynamic shared memory segment. */ @@ -91,7 +100,6 @@ static void dsm_cleanup_for_mmap(void); static bool dsm_read_state_file(dsm_handle *h); static void dsm_write_state_file(dsm_handle h); static void dsm_postmaster_shutdown(int code, Datum arg); -static void dsm_backend_shutdown(int code, Datum arg); static dsm_segment *dsm_create_descriptor(void); static bool dsm_control_segment_sane(dsm_control_header *control, Size mapped_size); @@ -191,7 +199,7 @@ dsm_postmaster_startup(void) break; } dsm_control = dsm_control_address; - on_shmem_exit(dsm_postmaster_shutdown, 0); + on_shmem_exit(dsm_postmaster_shutdown, 0, SHMEM_EXIT_LATE); elog(DEBUG2, "created dynamic shared memory control segment %u (%lu bytes)", dsm_control_handle, (unsigned long) segsize); @@ -553,9 +561,6 @@ dsm_backend_startup(void) } #endif - /* Arrange to detach segments on exit. */ - on_shmem_exit(dsm_backend_shutdown, 0); - dsm_init_done = true; } @@ -715,8 +720,8 @@ dsm_attach(dsm_handle h) /* * At backend shutdown time, detach any segments that are still attached. */ -static void -dsm_backend_shutdown(int code, Datum arg) +void +dsm_backend_shutdown(void) { while (!dlist_is_empty(&dsm_segment_list)) { @@ -772,6 +777,27 @@ void dsm_detach(dsm_segment *seg) { /* + * Invoke registered callbacks. Just in case one of those callbacks + * throws a further error that brings us back here, pop the callback + * before invoking it, to avoid infinite error recursion. + */ + while (!slist_is_empty(&seg->on_detach)) + { + slist_node *node; + dsm_segment_detach_callback *cb; + on_dsm_detach_callback function; + Datum arg; + + node = slist_pop_head_node(&seg->on_detach); + cb = slist_container(dsm_segment_detach_callback, node, node); + function = cb->function; + arg = cb->arg; + pfree(cb); + + function(seg, arg); + } + + /* * Try to remove the mapping, if one exists. Normally, there will be, * but maybe not, if we failed partway through a create or attach * operation. We remove the mapping before decrementing the reference @@ -913,6 +939,44 @@ dsm_segment_handle(dsm_segment *seg) } /* + * Register an on-detach callback for a dynamic shared memory segment. + */ +void +on_dsm_detach(dsm_segment *seg, on_dsm_detach_callback function, Datum arg) +{ + dsm_segment_detach_callback *cb; + + cb = MemoryContextAlloc(TopMemoryContext, + sizeof(dsm_segment_detach_callback)); + cb->function = function; + cb->arg = arg; + slist_push_head(&seg->on_detach, &cb->node); +} + +/* + * Unregister an on-detach callback for a dynamic shared memory segment. + */ +void +on_dsm_detach_cancel(dsm_segment *seg, on_dsm_detach_callback function, + Datum arg) +{ + slist_mutable_iter iter; + + slist_foreach_modify(iter, &seg->on_detach) + { + dsm_segment_detach_callback *cb; + + cb = slist_container(dsm_segment_detach_callback, node, iter.cur); + if (cb->function == function && cb->arg == arg) + { + slist_delete_current(&iter); + pfree(cb); + break; + } + } +} + +/* * Create a segment descriptor. */ static dsm_segment * @@ -934,6 +998,8 @@ dsm_create_descriptor(void) seg->resowner = CurrentResourceOwner; ResourceOwnerRememberDSM(CurrentResourceOwner, seg); + slist_init(&seg->on_detach); + return seg; } diff --git a/src/backend/storage/ipc/ipc.c b/src/backend/storage/ipc/ipc.c index c339e9c..ae42366 100644 --- a/src/backend/storage/ipc/ipc.c +++ b/src/backend/storage/ipc/ipc.c @@ -27,6 +27,7 @@ #ifdef PROFILE_PID_DIR #include "postmaster/autovacuum.h" #endif +#include "storage/dsm.h" #include "storage/ipc.h" #include "tcop/tcopprot.h" @@ -64,14 +65,19 @@ static void proc_exit_prepare(int code); #define MAX_ON_EXITS 20 -static struct ONEXIT +struct ONEXIT { pg_on_exit_callback function; Datum arg; -} on_proc_exit_list[MAX_ON_EXITS], on_shmem_exit_list[MAX_ON_EXITS]; +}; + +static struct ONEXIT on_proc_exit_list[MAX_ON_EXITS]; +static struct ONEXIT on_shmem_exit_early_list[MAX_ON_EXITS]; +static struct ONEXIT on_shmem_exit_late_list[MAX_ON_EXITS]; static int on_proc_exit_index, - on_shmem_exit_index; + on_shmem_exit_early_index, + on_shmem_exit_late_index; /* ---------------------------------------------------------------- @@ -202,26 +208,61 @@ proc_exit_prepare(int code) /* ------------------ * Run all of the on_shmem_exit routines --- but don't actually exit. * This is used by the postmaster to re-initialize shared memory and - * semaphores after a backend dies horribly. + * semaphores after a backend dies horribly. As with proc_exit(), we + * remove each callback from the list before calling it, to avoid + * infinite loop in case of error. * ------------------ */ void shmem_exit(int code) { - elog(DEBUG3, "shmem_exit(%d): %d callbacks to make", - code, on_shmem_exit_index); + /* + * Call early callbacks. + * + * These are generally 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 early callbacks to make", + code, on_shmem_exit_early_index); + while (--on_shmem_exit_early_index >= 0) + (*on_shmem_exit_early_list[on_shmem_exit_early_index].function) (code, + on_shmem_exit_early_list[on_shmem_exit_early_index].arg); + on_shmem_exit_early_index = 0; /* - * call all the registered callbacks. + * 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. * - * As with proc_exit(), we remove each callback from the list before - * calling it, to avoid infinite loop in case of error. + * 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. */ - 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); + dsm_backend_shutdown(); - on_shmem_exit_index = 0; + /* + * Call late 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 late callbacks to make", + code, on_shmem_exit_late_index); + while (--on_shmem_exit_late_index >= 0) + (*on_shmem_exit_late_list[on_shmem_exit_late_index].function) (code, + on_shmem_exit_late_list[on_shmem_exit_late_index].arg); + on_shmem_exit_late_index = 0; } /* ---------------------------------------------------------------- @@ -277,17 +318,32 @@ on_proc_exit(pg_on_exit_callback function, Datum arg) * ---------------------------------------------------------------- */ void -on_shmem_exit(pg_on_exit_callback function, Datum arg) +on_shmem_exit(pg_on_exit_callback function, Datum arg, shmem_exit_phase phase) { - if (on_shmem_exit_index >= MAX_ON_EXITS) + int *index; + struct ONEXIT *list; + + if (phase == SHMEM_EXIT_EARLY) + { + index = &on_shmem_exit_early_index; + list = on_shmem_exit_early_list; + } + else + { + Assert(phase == SHMEM_EXIT_LATE); + index = &on_shmem_exit_late_index; + list = on_shmem_exit_late_list; + } + + if (*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; + list[*index].function = function; + list[*index].arg = arg; - ++on_shmem_exit_index; + ++*index; if (!atexit_callback_setup) { @@ -306,12 +362,28 @@ on_shmem_exit(pg_on_exit_callback function, Datum arg) * ---------------------------------------------------------------- */ void -cancel_shmem_exit(pg_on_exit_callback function, Datum arg) +cancel_shmem_exit(pg_on_exit_callback function, Datum arg, + shmem_exit_phase phase) { - if (on_shmem_exit_index > 0 && - on_shmem_exit_list[on_shmem_exit_index - 1].function == function && - on_shmem_exit_list[on_shmem_exit_index - 1].arg == arg) - --on_shmem_exit_index; + int *index; + struct ONEXIT *list; + + if (phase == SHMEM_EXIT_EARLY) + { + index = &on_shmem_exit_early_index; + list = on_shmem_exit_early_list; + } + else + { + Assert(phase == SHMEM_EXIT_LATE); + index = &on_shmem_exit_late_index; + list = on_shmem_exit_late_list; + } + + if (*index > 0 && + list[*index - 1].function == function && + list[*index - 1].arg == arg) + --*index; } /* ---------------------------------------------------------------- @@ -326,6 +398,7 @@ cancel_shmem_exit(pg_on_exit_callback function, Datum arg) void on_exit_reset(void) { - on_shmem_exit_index = 0; + on_shmem_exit_early_index = 0; + on_shmem_exit_late_index = 0; on_proc_exit_index = 0; } diff --git a/src/backend/storage/ipc/procsignal.c b/src/backend/storage/ipc/procsignal.c index c4b5d01..2533bf1 100644 --- a/src/backend/storage/ipc/procsignal.c +++ b/src/backend/storage/ipc/procsignal.c @@ -131,7 +131,8 @@ ProcSignalInit(int pss_idx) MyProcSignalSlot = slot; /* Set up to release the slot on process exit */ - on_shmem_exit(CleanupProcSignalState, Int32GetDatum(pss_idx)); + on_shmem_exit(CleanupProcSignalState, Int32GetDatum(pss_idx), + SHMEM_EXIT_LATE); } /* diff --git a/src/backend/storage/ipc/sinvaladt.c b/src/backend/storage/ipc/sinvaladt.c index 44d02c5..aaf958a 100644 --- a/src/backend/storage/ipc/sinvaladt.c +++ b/src/backend/storage/ipc/sinvaladt.c @@ -325,7 +325,8 @@ SharedInvalBackendInit(bool sendOnly) LWLockRelease(SInvalWriteLock); /* register exit routine to mark my entry inactive at exit */ - on_shmem_exit(CleanupInvalidationState, PointerGetDatum(segP)); + on_shmem_exit(CleanupInvalidationState, PointerGetDatum(segP), + SHMEM_EXIT_LATE); elog(DEBUG4, "my backend ID is %d", MyBackendId); } diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c index 4f88d3f..b1af5c6 100644 --- a/src/backend/storage/lmgr/lwlock.c +++ b/src/backend/storage/lmgr/lwlock.c @@ -138,7 +138,7 @@ init_lwlock_stats(void) spin_delay_counts = calloc(numLocks, sizeof(int)); block_counts = calloc(numLocks, sizeof(int)); counts_for_pid = MyProcPid; - on_shmem_exit(print_lwlock_stats, 0); + on_shmem_exit(print_lwlock_stats, 0, SHMEM_EXIT_LATE); } static void diff --git a/src/backend/storage/lmgr/proc.c b/src/backend/storage/lmgr/proc.c index 222251d..8dffea9 100644 --- a/src/backend/storage/lmgr/proc.c +++ b/src/backend/storage/lmgr/proc.c @@ -406,7 +406,7 @@ InitProcess(void) /* * Arrange to clean up at backend exit. */ - on_shmem_exit(ProcKill, 0); + on_shmem_exit(ProcKill, 0, SHMEM_EXIT_LATE); /* * Now that we have a PGPROC, we could try to acquire locks, so initialize @@ -435,7 +435,7 @@ InitProcessPhase2(void) /* * Arrange to clean that up at backend exit. */ - on_shmem_exit(RemoveProcFromArray, 0); + on_shmem_exit(RemoveProcFromArray, 0, SHMEM_EXIT_LATE); } /* @@ -563,7 +563,8 @@ InitAuxiliaryProcess(void) /* * Arrange to clean up at process exit. */ - on_shmem_exit(AuxiliaryProcKill, Int32GetDatum(proctype)); + on_shmem_exit(AuxiliaryProcKill, Int32GetDatum(proctype), + SHMEM_EXIT_LATE); } /* diff --git a/src/backend/utils/init/postinit.c b/src/backend/utils/init/postinit.c index 2c7f0f1..97a7d49 100644 --- a/src/backend/utils/init/postinit.c +++ b/src/backend/utils/init/postinit.c @@ -560,7 +560,7 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username, * down at exit. */ StartupXLOG(); - on_shmem_exit(ShutdownXLOG, 0); + on_shmem_exit(ShutdownXLOG, 0, SHMEM_EXIT_LATE); } /* @@ -587,15 +587,14 @@ InitPostgres(const char *in_dbname, Oid dboid, const char *username, RelationCacheInitializePhase2(); /* - * Set up process-exit callback to do pre-shutdown cleanup. This has to - * be after we've initialized all the low-level modules like the buffer - * manager, because during shutdown this has to run before the low-level - * modules start to close down. On the other hand, we want it in place - * before we begin our first transaction --- if we fail during the - * initialization transaction, as is entirely possible, we need the - * AbortTransaction call to clean up. + * Set up process-exit callback to do pre-shutdown cleanup. This is the + * first callback we register as SHMEM_EXIT_EARLY; thus, this will be the + * last thing we do before low-level modules like the buffer manager begin + * to close down. We need to have this in place before we begin our first + * transaction --- if we fail during the initialization transaction, as is + * entirely possible, we need the AbortTransaction call to clean up. */ - on_shmem_exit(ShutdownPostgres, 0); + on_shmem_exit(ShutdownPostgres, 0, SHMEM_EXIT_EARLY); /* The autovacuum launcher is done here */ if (IsAutoVacuumLauncherProcess()) diff --git a/src/include/storage/dsm.h b/src/include/storage/dsm.h index d906eba..5c7c981 100644 --- a/src/include/storage/dsm.h +++ b/src/include/storage/dsm.h @@ -17,8 +17,9 @@ typedef struct dsm_segment dsm_segment; -/* Initialization function. */ +/* Startup and shutdown functions. */ extern void dsm_postmaster_startup(void); +extern void dsm_backend_shutdown(void); /* Functions that create, update, or remove mappings. */ extern dsm_segment *dsm_create(Size size); @@ -36,4 +37,11 @@ extern void *dsm_segment_address(dsm_segment *seg); extern Size dsm_segment_map_length(dsm_segment *seg); extern dsm_handle dsm_segment_handle(dsm_segment *seg); +/* Cleanup hooks. */ +typedef void (*on_dsm_detach_callback) (dsm_segment *, Datum arg); +extern void on_dsm_detach(dsm_segment *seg, + on_dsm_detach_callback function, Datum arg); +extern void on_dsm_detach_cancel(dsm_segment *seg, + on_dsm_detach_callback function, Datum arg); + #endif /* DSM_H */ diff --git a/src/include/storage/ipc.h b/src/include/storage/ipc.h index ac4ac66..4989abb 100644 --- a/src/include/storage/ipc.h +++ b/src/include/storage/ipc.h @@ -21,6 +21,12 @@ typedef void (*pg_on_exit_callback) (int code, Datum arg); typedef void (*shmem_startup_hook_type) (void); +typedef enum +{ + SHMEM_EXIT_EARLY, /* user-level cleanup and transaction abort */ + SHMEM_EXIT_LATE /* low-level subsystem shutdown */ +} shmem_exit_phase; + /*---------- * API for handling cleanup that must occur during either ereport(ERROR) * or ereport(FATAL) exits from a block of code. (Typical examples are @@ -46,14 +52,14 @@ typedef void (*shmem_startup_hook_type) (void); */ #define PG_ENSURE_ERROR_CLEANUP(cleanup_function, arg) \ do { \ - on_shmem_exit(cleanup_function, arg); \ + on_shmem_exit(cleanup_function, arg, SHMEM_EXIT_EARLY); \ PG_TRY() #define PG_END_ENSURE_ERROR_CLEANUP(cleanup_function, arg) \ - cancel_shmem_exit(cleanup_function, arg); \ + cancel_shmem_exit(cleanup_function, arg, SHMEM_EXIT_EARLY); \ PG_CATCH(); \ { \ - cancel_shmem_exit(cleanup_function, arg); \ + cancel_shmem_exit(cleanup_function, arg, SHMEM_EXIT_EARLY); \ cleanup_function (0, arg); \ PG_RE_THROW(); \ } \ @@ -67,8 +73,10 @@ extern bool proc_exit_inprogress; extern void proc_exit(int code) __attribute__((noreturn)); extern void shmem_exit(int code); extern void on_proc_exit(pg_on_exit_callback function, Datum arg); -extern void on_shmem_exit(pg_on_exit_callback function, Datum arg); -extern void cancel_shmem_exit(pg_on_exit_callback function, Datum arg); +extern void on_shmem_exit(pg_on_exit_callback function, Datum arg, + shmem_exit_phase phase); +extern void cancel_shmem_exit(pg_on_exit_callback function, Datum arg, + shmem_exit_phase phase); extern void on_exit_reset(void); /* ipci.c */