Branch data     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                 :       32443 : ProcessMainLoopInterrupts(void)
      35                 :             : {
      36         [ +  + ]:       32443 :     if (ProcSignalBarrierPending)
      37                 :         637 :         ProcessProcSignalBarrier();
      38                 :             : 
      39         [ +  + ]:       32443 :     if (ConfigReloadPending)
      40                 :             :     {
      41                 :         133 :         ConfigReloadPending = false;
      42                 :         133 :         ProcessConfigFile(PGC_SIGHUP);
      43                 :             :     }
      44                 :             : 
      45         [ +  + ]:       32443 :     if (ShutdownRequestPending)
      46                 :        1215 :         proc_exit(0);
      47                 :             : 
      48                 :             :     /* Perform logging of memory contexts of this process */
      49         [ -  + ]:       31228 :     if (LogMemoryContextPending)
      50                 :           0 :         ProcessLogMemoryContextInterrupt();
      51                 :       31228 : }
      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                 :        3772 : SignalHandlerForShutdownRequest(SIGNAL_ARGS)
     105                 :             : {
     106                 :        3772 :     ShutdownRequestPending = true;
     107                 :        3772 :     SetLatch(MyLatch);
     108                 :        3772 : }