Line data    Source code

       1              : /*-------------------------------------------------------------------------
       2              :  *
       3              :  * interrupt.c
       4              :  *    Interrupt handling routines.
       5              :  *
       6              :  * Portions Copyright (c) 1996-2026, 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        30237 : ProcessMainLoopInterrupts(void)
      35              : {
      36        30237 :     if (ProcSignalBarrierPending)
      37          386 :         ProcessProcSignalBarrier();
      38              : 
      39        30237 :     if (ConfigReloadPending)
      40              :     {
      41          105 :         ConfigReloadPending = false;
      42          105 :         ProcessConfigFile(PGC_SIGHUP);
      43              :     }
      44              : 
      45        30237 :     if (ShutdownRequestPending)
      46         1087 :         proc_exit(0);
      47              : 
      48              :     /* Perform logging of memory contexts of this process */
      49        29150 :     if (LogMemoryContextPending)
      50            0 :         ProcessLogMemoryContextInterrupt();
      51        29150 : }
      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 ProcessMainLoopInterrupts.
      59              :  */
      60              : void
      61          738 : SignalHandlerForConfigReload(SIGNAL_ARGS)
      62              : {
      63          738 :     ConfigReloadPending = true;
      64          738 :     SetLatch(MyLatch);
      65          738 : }
      66              : 
      67              : /*
      68              :  * Simple signal handler for exiting quickly as if due to a crash.
      69              :  *
      70              :  * Normally, this would be used for handling SIGQUIT.
      71              :  */
      72              : void
      73            0 : SignalHandlerForCrashExit(SIGNAL_ARGS)
      74              : {
      75              :     /*
      76              :      * We DO NOT want to run proc_exit() or atexit() callbacks -- we're here
      77              :      * because shared memory may be corrupted, so we don't want to try to
      78              :      * clean up our transaction.  Just nail the windows shut and get out of
      79              :      * town.  The callbacks wouldn't be safe to run from a signal handler,
      80              :      * anyway.
      81              :      *
      82              :      * Note we do _exit(2) not _exit(0).  This is to force the postmaster into
      83              :      * a system reset cycle if someone sends a manual SIGQUIT to a random
      84              :      * backend.  This is necessary precisely because we don't clean up our
      85              :      * shared memory state.  (The "dead man switch" mechanism in pmsignal.c
      86              :      * should ensure the postmaster sees this as a crash, too, but no harm in
      87              :      * being doubly sure.)
      88              :      */
      89            0 :     _exit(2);
      90              : }
      91              : 
      92              : /*
      93              :  * Simple signal handler for triggering a long-running background process to
      94              :  * shut down and exit.
      95              :  *
      96              :  * Typically, this handler would be used for SIGTERM, but some processes use
      97              :  * other signals. In particular, the checkpointer and parallel apply worker
      98              :  * exit on SIGUSR2, and the WAL writer exits on either SIGINT or SIGTERM.
      99              :  *
     100              :  * ShutdownRequestPending should be checked at a convenient place within the
     101              :  * main loop, or else the main loop should call ProcessMainLoopInterrupts.
     102              :  */
     103              : void
     104         4012 : SignalHandlerForShutdownRequest(SIGNAL_ARGS)
     105              : {
     106         4012 :     ShutdownRequestPending = true;
     107         4012 :     SetLatch(MyLatch);
     108         4012 : }