blob: 93877284c59c8e5102d702500d555c5c60f4dc6b [file] [log] [blame]
Willy Tarreau8f38bd02009-05-10 08:53:33 +02001/*
2 * Asynchronous signal delivery functions.
3 *
Willy Tarreau24f4efa2010-08-27 17:56:48 +02004 * Copyright 2000-2010 Willy Tarreau <w@1wt.eu>
Willy Tarreau8f38bd02009-05-10 08:53:33 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <signal.h>
Willy Tarreaube8c7362009-07-23 13:40:20 +020014#include <string.h>
15
William Lallemand6e1796e2018-06-07 11:23:40 +020016#include <common/hathreads.h>
17
Willy Tarreau8f38bd02009-05-10 08:53:33 +020018#include <proto/signal.h>
19#include <proto/log.h>
Willy Tarreau24f4efa2010-08-27 17:56:48 +020020#include <proto/task.h>
Willy Tarreau8f38bd02009-05-10 08:53:33 +020021
22/* Principle : we keep an in-order list of the first occurrence of all received
23 * signals. All occurrences of a same signal are grouped though. The signal
24 * queue does not need to be deeper than the number of signals we can handle.
25 * The handlers will be called asynchronously with the signal number. They can
26 * check themselves the number of calls by checking the descriptor this signal.
27 */
28
29int signal_queue_len; /* length of signal queue, <= MAX_SIGNAL (1 entry per signal max) */
30int signal_queue[MAX_SIGNAL]; /* in-order queue of received signals */
31struct signal_descriptor signal_state[MAX_SIGNAL];
Willy Tarreaubafbe012017-11-24 17:34:44 +010032struct pool_head *pool_head_sig_handlers = NULL;
Willy Tarreau8f38bd02009-05-10 08:53:33 +020033sigset_t blocked_sig;
Willy Tarreaud0807c32010-08-27 18:26:11 +020034int signal_pending = 0; /* non-zero if t least one signal remains unprocessed */
Willy Tarreau8f38bd02009-05-10 08:53:33 +020035
Christopher Fauletb79a94c2017-05-30 15:34:30 +020036
Willy Tarreaud0807c32010-08-27 18:26:11 +020037/* Common signal handler, used by all signals. Received signals are queued.
38 * Signal number zero has a specific status, as it cannot be delivered by the
39 * system, any function may call it to perform asynchronous signal delivery.
40 */
41void signal_handler(int sig)
Willy Tarreau8f38bd02009-05-10 08:53:33 +020042{
Willy Tarreau1a53b5e2013-01-24 02:06:05 +010043 if (sig < 0 || sig >= MAX_SIGNAL) {
Willy Tarreau8f38bd02009-05-10 08:53:33 +020044 /* unhandled signal */
Willy Tarreau8f38bd02009-05-10 08:53:33 +020045 signal(sig, SIG_IGN);
Willy Tarreau24f4efa2010-08-27 17:56:48 +020046 qfprintf(stderr, "Received unhandled signal %d. Signal has been disabled.\n", sig);
Willy Tarreau8f38bd02009-05-10 08:53:33 +020047 return;
48 }
49
50 if (!signal_state[sig].count) {
51 /* signal was not queued yet */
52 if (signal_queue_len < MAX_SIGNAL)
53 signal_queue[signal_queue_len++] = sig;
54 else
55 qfprintf(stderr, "Signal %d : signal queue is unexpectedly full.\n", sig);
56 }
Willy Tarreaud0807c32010-08-27 18:26:11 +020057
Willy Tarreau8f38bd02009-05-10 08:53:33 +020058 signal_state[sig].count++;
Willy Tarreaud0807c32010-08-27 18:26:11 +020059 if (sig)
60 signal(sig, signal_handler); /* re-arm signal */
Willy Tarreau8f38bd02009-05-10 08:53:33 +020061}
62
Willy Tarreau8f38bd02009-05-10 08:53:33 +020063/* Call handlers of all pending signals and clear counts and queue length. The
64 * handlers may unregister themselves by calling signal_register() while they
65 * are called, just like it is done with normal signal handlers.
66 * Note that it is more efficient to call the inline version which checks the
67 * queue length before getting here.
68 */
69void __signal_process_queue()
70{
71 int sig, cur_pos = 0;
72 struct signal_descriptor *desc;
73 sigset_t old_sig;
74
75 /* block signal delivery during processing */
William Lallemand6e1796e2018-06-07 11:23:40 +020076 ha_sigmask(SIG_SETMASK, &blocked_sig, &old_sig);
Willy Tarreau8f38bd02009-05-10 08:53:33 +020077
Willy Tarreaud0807c32010-08-27 18:26:11 +020078 /* It is important that we scan the queue forwards so that we can
79 * catch any signal that would have been queued by another signal
80 * handler. That allows real signal handlers to redistribute signals
81 * to tasks subscribed to signal zero.
82 */
Willy Tarreau8f38bd02009-05-10 08:53:33 +020083 for (cur_pos = 0; cur_pos < signal_queue_len; cur_pos++) {
84 sig = signal_queue[cur_pos];
85 desc = &signal_state[sig];
86 if (desc->count) {
Willy Tarreau24f4efa2010-08-27 17:56:48 +020087 struct sig_handler *sh, *shb;
88 list_for_each_entry_safe(sh, shb, &desc->handlers, list) {
89 if ((sh->flags & SIG_F_TYPE_FCT) && sh->handler)
90 ((void (*)(struct sig_handler *))sh->handler)(sh);
91 else if ((sh->flags & SIG_F_TYPE_TASK) && sh->handler)
Willy Tarreauad8bd242018-07-26 16:11:33 +020092 task_wakeup(sh->handler, TASK_WOKEN_SIGNAL);
Willy Tarreau24f4efa2010-08-27 17:56:48 +020093 }
Willy Tarreau8f38bd02009-05-10 08:53:33 +020094 desc->count = 0;
95 }
96 }
97 signal_queue_len = 0;
98
99 /* restore signal delivery */
William Lallemand6e1796e2018-06-07 11:23:40 +0200100 ha_sigmask(SIG_SETMASK, &old_sig, NULL);
Willy Tarreau8f38bd02009-05-10 08:53:33 +0200101}
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200102
103/* perform minimal intializations, report 0 in case of error, 1 if OK. */
104int signal_init()
105{
106 int sig;
107
108 signal_queue_len = 0;
109 memset(signal_queue, 0, sizeof(signal_queue));
110 memset(signal_state, 0, sizeof(signal_state));
Willy Tarreaud50b4ac2016-04-20 10:33:15 +0200111
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200112 sigfillset(&blocked_sig);
Willy Tarreau6747e272013-01-04 16:20:20 +0100113 sigdelset(&blocked_sig, SIGPROF);
William Lallemand933642c2018-06-07 09:49:04 +0200114 /* man sigprocmask: If SIGBUS, SIGFPE, SIGILL, or SIGSEGV are
115 generated while they are blocked, the result is undefined, unless
116 the signal was generated by kill(2),
117 sigqueue(3), or raise(3) */
118 sigdelset(&blocked_sig, SIGBUS);
119 sigdelset(&blocked_sig, SIGFPE);
120 sigdelset(&blocked_sig, SIGILL);
121 sigdelset(&blocked_sig, SIGSEGV);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200122 for (sig = 0; sig < MAX_SIGNAL; sig++)
123 LIST_INIT(&signal_state[sig].handlers);
124
Willy Tarreaubafbe012017-11-24 17:34:44 +0100125 pool_head_sig_handlers = create_pool("sig_handlers", sizeof(struct sig_handler), MEM_F_SHARED);
126 return pool_head_sig_handlers != NULL;
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200127}
128
William Lallemandd3801c12018-09-11 10:06:23 +0200129/*
130 * This function should be called to unblock all signals
131 */
132void haproxy_unblock_signals()
133{
134 sigset_t set;
135
136 /* Ensure signals are not blocked. Some shells or service managers may
137 * accidently block all of our signals unfortunately, causing lots of
138 * zombie processes to remain in the background during reloads.
139 */
140 sigemptyset(&set);
141 ha_sigmask(SIG_SETMASK, &set, NULL);
142}
143
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200144/* releases all registered signal handlers */
145void deinit_signals()
146{
147 int sig;
148 struct sig_handler *sh, *shb;
149
150 for (sig = 0; sig < MAX_SIGNAL; sig++) {
Willy Tarreau6747e272013-01-04 16:20:20 +0100151 if (sig != SIGPROF)
152 signal(sig, SIG_DFL);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200153 list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) {
154 LIST_DEL(&sh->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100155 pool_free(pool_head_sig_handlers, sh);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200156 }
157 }
158}
159
160/* Register a function and an integer argument on a signal. A pointer to the
161 * newly allocated sig_handler is returned, or NULL in case of any error. The
162 * caller is responsible for unregistering the function when not used anymore.
163 * Note that passing a NULL as the function pointer enables interception of the
Willy Tarreaud0807c32010-08-27 18:26:11 +0200164 * signal without processing, which is identical to SIG_IGN. If the signal is
165 * zero (which the system cannot deliver), only internal functions will be able
166 * to notify the registered functions.
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200167 */
168struct sig_handler *signal_register_fct(int sig, void (*fct)(struct sig_handler *), int arg)
169{
170 struct sig_handler *sh;
171
Willy Tarreau1a53b5e2013-01-24 02:06:05 +0100172 if (sig < 0 || sig >= MAX_SIGNAL)
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200173 return NULL;
174
Willy Tarreaud0807c32010-08-27 18:26:11 +0200175 if (sig)
Willy Tarreauc39b0d12012-10-04 19:19:36 +0200176 signal(sig, fct ? signal_handler : SIG_IGN);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200177
178 if (!fct)
179 return NULL;
180
Willy Tarreaubafbe012017-11-24 17:34:44 +0100181 sh = pool_alloc(pool_head_sig_handlers);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200182 if (!sh)
183 return NULL;
184
185 sh->handler = fct;
186 sh->arg = arg;
187 sh->flags = SIG_F_TYPE_FCT;
188 LIST_ADDQ(&signal_state[sig].handlers, &sh->list);
189 return sh;
190}
191
192/* Register a task and a wake-up reason on a signal. A pointer to the newly
193 * allocated sig_handler is returned, or NULL in case of any error. The caller
194 * is responsible for unregistering the task when not used anymore. Note that
195 * passing a NULL as the task pointer enables interception of the signal
Willy Tarreaud0807c32010-08-27 18:26:11 +0200196 * without processing, which is identical to SIG_IGN. If the signal is zero
197 * (which the system cannot deliver), only internal functions will be able to
198 * notify the registered functions.
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200199 */
200struct sig_handler *signal_register_task(int sig, struct task *task, int reason)
201{
202 struct sig_handler *sh;
203
Willy Tarreau1a53b5e2013-01-24 02:06:05 +0100204 if (sig < 0 || sig >= MAX_SIGNAL)
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200205 return NULL;
206
Willy Tarreaud0807c32010-08-27 18:26:11 +0200207 if (sig)
208 signal(sig, signal_handler);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200209
210 if (!task)
211 return NULL;
212
Willy Tarreaubafbe012017-11-24 17:34:44 +0100213 sh = pool_alloc(pool_head_sig_handlers);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200214 if (!sh)
215 return NULL;
216
217 sh->handler = task;
218 sh->arg = reason & ~TASK_WOKEN_ANY;
219 sh->flags = SIG_F_TYPE_TASK;
220 LIST_ADDQ(&signal_state[sig].handlers, &sh->list);
221 return sh;
222}
223
224/* Immediately unregister a handler so that no further signals may be delivered
225 * to it. The struct is released so the caller may not reference it anymore.
226 */
227void signal_unregister_handler(struct sig_handler *handler)
228{
229 LIST_DEL(&handler->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100230 pool_free(pool_head_sig_handlers, handler);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200231}
232
233/* Immediately unregister a handler so that no further signals may be delivered
234 * to it. The handler struct does not need to be known, only the function or
235 * task pointer. This method is expensive because it scans all the list, so it
236 * should only be used for rare cases (eg: exit). The struct is released so the
237 * caller may not reference it anymore.
238 */
239void signal_unregister_target(int sig, void *target)
240{
241 struct sig_handler *sh, *shb;
242
Willy Tarreau1a53b5e2013-01-24 02:06:05 +0100243 if (sig < 0 || sig >= MAX_SIGNAL)
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200244 return;
245
246 if (!target)
247 return;
248
249 list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) {
250 if (sh->handler == target) {
251 LIST_DEL(&sh->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100252 pool_free(pool_head_sig_handlers, sh);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200253 break;
254 }
255 }
256}
William Lallemand31a1c1d2018-11-20 17:36:52 +0100257
258/*
259 * Immedialtely unregister every handler assigned to a signal <sig>.
260 * Once the handler list is empty, the signal is ignored with SIG_IGN.
261 */
262
263void signal_unregister(int sig)
264{
265 struct sig_handler *sh, *shb;
266
267 if (sig < 0 || sig >= MAX_SIGNAL)
268 return;
269
270 list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) {
271 LIST_DEL(&sh->list);
272 pool_free(pool_head_sig_handlers, sh);
273 }
274
275 signal(sig, SIG_IGN);
276}