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       12920 : HandleMainLoopInterrupts(void)
      35             : {
      36       12920 :     if (ProcSignalBarrierPending)
      37          84 :         ProcessProcSignalBarrier();
      38             : 
      39       12920 :     if (ConfigReloadPending)
      40             :     {
      41          74 :         ConfigReloadPending = false;
      42          74 :         ProcessConfigFile(PGC_SIGHUP);
      43             :     }
      44             : 
      45       12920 :     if (ShutdownRequestPending)
      46         734 :         proc_exit(0);
      47             : 
      48             :     /* Perform logging of memory contexts of this process */
      49       12186 :     if (LogMemoryContextPending)
      50           0 :         ProcessLogMemoryContextInterrupt();
      51       12186 : }
      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         544 : SignalHandlerForConfigReload(SIGNAL_ARGS)
      62             : {
      63         544 :     int         save_errno = errno;
      64             : 
      65         544 :     ConfigReloadPending = true;
      66         544 :     SetLatch(MyLatch);
      67             : 
      68         544 :     errno = save_errno;
      69         544 : }
      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        2916 : SignalHandlerForShutdownRequest(SIGNAL_ARGS)
     110             : {
     111        2916 :     int         save_errno = errno;
     112             : 
     113        2916 :     ShutdownRequestPending = true;
     114        2916 :     SetLatch(MyLatch);
     115             : 
     116        2916 :     errno = save_errno;
     117        2916 : }