PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
procsignal.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * procsignal.c
4  * Routines for interprocess signalling
5  *
6  *
7  * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
8  * Portions Copyright (c) 1994, Regents of the University of California
9  *
10  * IDENTIFICATION
11  * src/backend/storage/ipc/procsignal.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 #include "postgres.h"
16 
17 #include <signal.h>
18 #include <unistd.h>
19 
20 #include "access/parallel.h"
21 #include "commands/async.h"
22 #include "miscadmin.h"
23 #include "storage/latch.h"
24 #include "storage/ipc.h"
25 #include "storage/proc.h"
26 #include "storage/shmem.h"
27 #include "storage/sinval.h"
28 #include "tcop/tcopprot.h"
29 
30 
31 /*
32  * The SIGUSR1 signal is multiplexed to support signalling multiple event
33  * types. The specific reason is communicated via flags in shared memory.
34  * We keep a boolean flag for each possible "reason", so that different
35  * reasons can be signaled to a process concurrently. (However, if the same
36  * reason is signaled more than once nearly simultaneously, the process may
37  * observe it only once.)
38  *
39  * Each process that wants to receive signals registers its process ID
40  * in the ProcSignalSlots array. The array is indexed by backend ID to make
41  * slot allocation simple, and to avoid having to search the array when you
42  * know the backend ID of the process you're signalling. (We do support
43  * signalling without backend ID, but it's a bit less efficient.)
44  *
45  * The flags are actually declared as "volatile sig_atomic_t" for maximum
46  * portability. This should ensure that loads and stores of the flag
47  * values are atomic, allowing us to dispense with any explicit locking.
48  */
49 typedef struct
50 {
51  pid_t pss_pid;
52  sig_atomic_t pss_signalFlags[NUM_PROCSIGNALS];
54 
55 /*
56  * We reserve a slot for each possible BackendId, plus one for each
57  * possible auxiliary process type. (This scheme assumes there is not
58  * more than one of any auxiliary process type at a time.)
59  */
60 #define NumProcSignalSlots (MaxBackends + NUM_AUXPROCTYPES)
61 
64 
65 static bool CheckProcSignal(ProcSignalReason reason);
66 static void CleanupProcSignalState(int status, Datum arg);
67 
68 /*
69  * ProcSignalShmemSize
70  * Compute space needed for procsignal's shared memory
71  */
72 Size
74 {
75  return NumProcSignalSlots * sizeof(ProcSignalSlot);
76 }
77 
78 /*
79  * ProcSignalShmemInit
80  * Allocate and initialize procsignal's shared memory
81  */
82 void
84 {
85  Size size = ProcSignalShmemSize();
86  bool found;
87 
88  ProcSignalSlots = (ProcSignalSlot *)
89  ShmemInitStruct("ProcSignalSlots", size, &found);
90 
91  /* If we're first, set everything to zeroes */
92  if (!found)
93  MemSet(ProcSignalSlots, 0, size);
94 }
95 
96 /*
97  * ProcSignalInit
98  * Register the current process in the procsignal array
99  *
100  * The passed index should be my BackendId if the process has one,
101  * or MaxBackends + aux process type if not.
102  */
103 void
104 ProcSignalInit(int pss_idx)
105 {
106  volatile ProcSignalSlot *slot;
107 
108  Assert(pss_idx >= 1 && pss_idx <= NumProcSignalSlots);
109 
110  slot = &ProcSignalSlots[pss_idx - 1];
111 
112  /* sanity check */
113  if (slot->pss_pid != 0)
114  elog(LOG, "process %d taking over ProcSignal slot %d, but it's not empty",
115  MyProcPid, pss_idx);
116 
117  /* Clear out any leftover signal reasons */
118  MemSet(slot->pss_signalFlags, 0, NUM_PROCSIGNALS * sizeof(sig_atomic_t));
119 
120  /* Mark slot with my PID */
121  slot->pss_pid = MyProcPid;
122 
123  /* Remember slot location for CheckProcSignal */
124  MyProcSignalSlot = slot;
125 
126  /* Set up to release the slot on process exit */
128 }
129 
130 /*
131  * CleanupProcSignalState
132  * Remove current process from ProcSignalSlots
133  *
134  * This function is called via on_shmem_exit() during backend shutdown.
135  */
136 static void
138 {
139  int pss_idx = DatumGetInt32(arg);
140  volatile ProcSignalSlot *slot;
141 
142  slot = &ProcSignalSlots[pss_idx - 1];
143  Assert(slot == MyProcSignalSlot);
144 
145  /*
146  * Clear MyProcSignalSlot, so that a SIGUSR1 received after this point
147  * won't try to access it after it's no longer ours (and perhaps even
148  * after we've unmapped the shared memory segment).
149  */
150  MyProcSignalSlot = NULL;
151 
152  /* sanity check */
153  if (slot->pss_pid != MyProcPid)
154  {
155  /*
156  * don't ERROR here. We're exiting anyway, and don't want to get into
157  * infinite loop trying to exit
158  */
159  elog(LOG, "process %d releasing ProcSignal slot %d, but it contains %d",
160  MyProcPid, pss_idx, (int) slot->pss_pid);
161  return; /* XXX better to zero the slot anyway? */
162  }
163 
164  slot->pss_pid = 0;
165 }
166 
167 /*
168  * SendProcSignal
169  * Send a signal to a Postgres process
170  *
171  * Providing backendId is optional, but it will speed up the operation.
172  *
173  * On success (a signal was sent), zero is returned.
174  * On error, -1 is returned, and errno is set (typically to ESRCH or EPERM).
175  *
176  * Not to be confused with ProcSendSignal
177  */
178 int
179 SendProcSignal(pid_t pid, ProcSignalReason reason, BackendId backendId)
180 {
181  volatile ProcSignalSlot *slot;
182 
183  if (backendId != InvalidBackendId)
184  {
185  slot = &ProcSignalSlots[backendId - 1];
186 
187  /*
188  * Note: Since there's no locking, it's possible that the target
189  * process detaches from shared memory and exits right after this
190  * test, before we set the flag and send signal. And the signal slot
191  * might even be recycled by a new process, so it's remotely possible
192  * that we set a flag for a wrong process. That's OK, all the signals
193  * are such that no harm is done if they're mistakenly fired.
194  */
195  if (slot->pss_pid == pid)
196  {
197  /* Atomically set the proper flag */
198  slot->pss_signalFlags[reason] = true;
199  /* Send signal */
200  return kill(pid, SIGUSR1);
201  }
202  }
203  else
204  {
205  /*
206  * BackendId not provided, so search the array using pid. We search
207  * the array back to front so as to reduce search overhead. Passing
208  * InvalidBackendId means that the target is most likely an auxiliary
209  * process, which will have a slot near the end of the array.
210  */
211  int i;
212 
213  for (i = NumProcSignalSlots - 1; i >= 0; i--)
214  {
215  slot = &ProcSignalSlots[i];
216 
217  if (slot->pss_pid == pid)
218  {
219  /* the above note about race conditions applies here too */
220 
221  /* Atomically set the proper flag */
222  slot->pss_signalFlags[reason] = true;
223  /* Send signal */
224  return kill(pid, SIGUSR1);
225  }
226  }
227  }
228 
229  errno = ESRCH;
230  return -1;
231 }
232 
233 /*
234  * CheckProcSignal - check to see if a particular reason has been
235  * signaled, and clear the signal flag. Should be called after receiving
236  * SIGUSR1.
237  */
238 static bool
240 {
241  volatile ProcSignalSlot *slot = MyProcSignalSlot;
242 
243  if (slot != NULL)
244  {
245  /* Careful here --- don't clear flag if we haven't seen it set */
246  if (slot->pss_signalFlags[reason])
247  {
248  slot->pss_signalFlags[reason] = false;
249  return true;
250  }
251  }
252 
253  return false;
254 }
255 
256 /*
257  * procsignal_sigusr1_handler - handle SIGUSR1 signal.
258  */
259 void
261 {
262  int save_errno = errno;
263 
266 
269 
272 
275 
278 
281 
284 
287 
290 
291  SetLatch(MyLatch);
292 
294 
295  errno = save_errno;
296 }
#define SIGUSR1
Definition: win32.h:211
static ProcSignalSlot * ProcSignalSlots
Definition: procsignal.c:62
void RecoveryConflictInterrupt(ProcSignalReason reason)
Definition: postgres.c:2699
int MyProcPid
Definition: globals.c:38
#define DatumGetInt32(X)
Definition: postgres.h:480
#define MemSet(start, val, len)
Definition: c.h:853
#define LOG
Definition: elog.h:26
static void CleanupProcSignalState(int status, Datum arg)
Definition: procsignal.c:137
int SendProcSignal(pid_t pid, ProcSignalReason reason, BackendId backendId)
Definition: procsignal.c:179
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:372
void on_shmem_exit(pg_on_exit_callback function, Datum arg)
Definition: ipc.c:348
Size ProcSignalShmemSize(void)
Definition: procsignal.c:73
#define InvalidBackendId
Definition: backendid.h:23
uintptr_t Datum
Definition: postgres.h:374
int BackendId
Definition: backendid.h:21
static bool CheckProcSignal(ProcSignalReason reason)
Definition: procsignal.c:239
void SetLatch(volatile Latch *latch)
Definition: latch.c:379
#define SIGNAL_ARGS
Definition: c.h:1079
#define NULL
Definition: c.h:226
#define Assert(condition)
Definition: c.h:671
size_t Size
Definition: c.h:353
void ProcSignalInit(int pss_idx)
Definition: procsignal.c:104
#define Int32GetDatum(X)
Definition: postgres.h:487
void HandleNotifyInterrupt(void)
Definition: async.c:1702
int i
ProcSignalReason
Definition: procsignal.h:30
sig_atomic_t pss_signalFlags[NUM_PROCSIGNALS]
Definition: procsignal.c:52
void * arg
void ProcSignalShmemInit(void)
Definition: procsignal.c:83
static volatile ProcSignalSlot * MyProcSignalSlot
Definition: procsignal.c:63
#define NumProcSignalSlots
Definition: procsignal.c:60
struct Latch * MyLatch
Definition: globals.c:51
void HandleParallelMessageInterrupt(void)
Definition: parallel.c:694
#define elog
Definition: elog.h:219
void latch_sigusr1_handler(void)
Definition: latch.c:1540
void procsignal_sigusr1_handler(SIGNAL_ARGS)
Definition: procsignal.c:260
static void static void status(const char *fmt,...) pg_attribute_printf(1
Definition: pg_regress.c:222
void HandleCatchupInterrupt(void)
Definition: sinval.c:157