Line data Source code
1 : /*------------------------------------------------------------------------- 2 : * 3 : * interrupt.c 4 : * Interrupt handling routines. 5 : * 6 : * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group 7 : * Portions Copyright (c) 1994, Regents of the University of California 8 : * 9 : * IDENTIFICATION 10 : * src/backend/postmaster/interrupt.c 11 : * 12 : *------------------------------------------------------------------------- 13 : */ 14 : 15 : #include "postgres.h" 16 : 17 : #include <unistd.h> 18 : 19 : #include "miscadmin.h" 20 : #include "postmaster/interrupt.h" 21 : #include "storage/ipc.h" 22 : #include "storage/latch.h" 23 : #include "storage/procsignal.h" 24 : #include "utils/guc.h" 25 : #include "utils/memutils.h" 26 : 27 : volatile sig_atomic_t ConfigReloadPending = false; 28 : volatile sig_atomic_t ShutdownRequestPending = false; 29 : 30 : /* 31 : * Simple interrupt handler for main loops of background processes. 32 : */ 33 : void 34 13956 : HandleMainLoopInterrupts(void) 35 : { 36 13956 : if (ProcSignalBarrierPending) 37 76 : ProcessProcSignalBarrier(); 38 : 39 13956 : if (ConfigReloadPending) 40 : { 41 72 : ConfigReloadPending = false; 42 72 : ProcessConfigFile(PGC_SIGHUP); 43 : } 44 : 45 13956 : if (ShutdownRequestPending) 46 688 : proc_exit(0); 47 : 48 : /* Perform logging of memory contexts of this process */ 49 13268 : if (LogMemoryContextPending) 50 0 : ProcessLogMemoryContextInterrupt(); 51 13268 : } 52 : 53 : /* 54 : * Simple signal handler for triggering a configuration reload. 55 : * 56 : * Normally, this handler would be used for SIGHUP. The idea is that code 57 : * which uses it would arrange to check the ConfigReloadPending flag at 58 : * convenient places inside main loops, or else call HandleMainLoopInterrupts. 59 : */ 60 : void 61 520 : SignalHandlerForConfigReload(SIGNAL_ARGS) 62 : { 63 520 : int save_errno = errno; 64 : 65 520 : ConfigReloadPending = true; 66 520 : SetLatch(MyLatch); 67 : 68 520 : errno = save_errno; 69 520 : } 70 : 71 : /* 72 : * Simple signal handler for exiting quickly as if due to a crash. 73 : * 74 : * Normally, this would be used for handling SIGQUIT. 75 : */ 76 : void 77 0 : SignalHandlerForCrashExit(SIGNAL_ARGS) 78 : { 79 : /* 80 : * We DO NOT want to run proc_exit() or atexit() callbacks -- we're here 81 : * because shared memory may be corrupted, so we don't want to try to 82 : * clean up our transaction. Just nail the windows shut and get out of 83 : * town. The callbacks wouldn't be safe to run from a signal handler, 84 : * anyway. 85 : * 86 : * Note we do _exit(2) not _exit(0). This is to force the postmaster into 87 : * a system reset cycle if someone sends a manual SIGQUIT to a random 88 : * backend. This is necessary precisely because we don't clean up our 89 : * shared memory state. (The "dead man switch" mechanism in pmsignal.c 90 : * should ensure the postmaster sees this as a crash, too, but no harm in 91 : * being doubly sure.) 92 : */ 93 0 : _exit(2); 94 : } 95 : 96 : /* 97 : * Simple signal handler for triggering a long-running background process to 98 : * shut down and exit. 99 : * 100 : * Typically, this handler would be used for SIGTERM, but some processes use 101 : * other signals. In particular, the checkpointer exits on SIGUSR2, and the WAL 102 : * writer and the logical replication parallel apply worker exits on either 103 : * SIGINT or SIGTERM. 104 : * 105 : * ShutdownRequestPending should be checked at a convenient place within the 106 : * main loop, or else the main loop should call HandleMainLoopInterrupts. 107 : */ 108 : void 109 2758 : SignalHandlerForShutdownRequest(SIGNAL_ARGS) 110 : { 111 2758 : int save_errno = errno; 112 : 113 2758 : ShutdownRequestPending = true; 114 2758 : SetLatch(MyLatch); 115 : 116 2758 : errno = save_errno; 117 2758 : }