blob: 2484a44418088ae349b6f05de75fbdb6489c526e [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];
32sigset_t blocked_sig;
Willy Tarreaud0807c32010-08-27 18:26:11 +020033int signal_pending = 0; /* non-zero if t least one signal remains unprocessed */
Willy Tarreau8f38bd02009-05-10 08:53:33 +020034
Willy Tarreau2455ceb2018-11-26 15:57:34 +010035DECLARE_STATIC_POOL(pool_head_sig_handlers, "sig_handlers", sizeof(struct sig_handler));
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
Willy Tarreaub6b3df32018-11-26 16:31:20 +0100103/* perform minimal intializations */
104static void signal_init()
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200105{
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);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200124}
125
William Lallemandd3801c12018-09-11 10:06:23 +0200126/*
127 * This function should be called to unblock all signals
128 */
129void haproxy_unblock_signals()
130{
131 sigset_t set;
132
133 /* Ensure signals are not blocked. Some shells or service managers may
134 * accidently block all of our signals unfortunately, causing lots of
135 * zombie processes to remain in the background during reloads.
136 */
137 sigemptyset(&set);
138 ha_sigmask(SIG_SETMASK, &set, NULL);
139}
140
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200141/* releases all registered signal handlers */
142void deinit_signals()
143{
144 int sig;
145 struct sig_handler *sh, *shb;
146
147 for (sig = 0; sig < MAX_SIGNAL; sig++) {
Willy Tarreau6747e272013-01-04 16:20:20 +0100148 if (sig != SIGPROF)
149 signal(sig, SIG_DFL);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200150 list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) {
151 LIST_DEL(&sh->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100152 pool_free(pool_head_sig_handlers, sh);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200153 }
154 }
155}
156
157/* Register a function and an integer argument on a signal. A pointer to the
158 * newly allocated sig_handler is returned, or NULL in case of any error. The
159 * caller is responsible for unregistering the function when not used anymore.
160 * Note that passing a NULL as the function pointer enables interception of the
Willy Tarreaud0807c32010-08-27 18:26:11 +0200161 * signal without processing, which is identical to SIG_IGN. If the signal is
162 * zero (which the system cannot deliver), only internal functions will be able
163 * to notify the registered functions.
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200164 */
165struct sig_handler *signal_register_fct(int sig, void (*fct)(struct sig_handler *), int arg)
166{
167 struct sig_handler *sh;
168
Willy Tarreau1a53b5e2013-01-24 02:06:05 +0100169 if (sig < 0 || sig >= MAX_SIGNAL)
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200170 return NULL;
171
Willy Tarreaud0807c32010-08-27 18:26:11 +0200172 if (sig)
Willy Tarreauc39b0d12012-10-04 19:19:36 +0200173 signal(sig, fct ? signal_handler : SIG_IGN);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200174
175 if (!fct)
176 return NULL;
177
Willy Tarreaubafbe012017-11-24 17:34:44 +0100178 sh = pool_alloc(pool_head_sig_handlers);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200179 if (!sh)
180 return NULL;
181
182 sh->handler = fct;
183 sh->arg = arg;
184 sh->flags = SIG_F_TYPE_FCT;
185 LIST_ADDQ(&signal_state[sig].handlers, &sh->list);
186 return sh;
187}
188
189/* Register a task and a wake-up reason on a signal. A pointer to the newly
190 * allocated sig_handler is returned, or NULL in case of any error. The caller
191 * is responsible for unregistering the task when not used anymore. Note that
192 * passing a NULL as the task pointer enables interception of the signal
Willy Tarreaud0807c32010-08-27 18:26:11 +0200193 * without processing, which is identical to SIG_IGN. If the signal is zero
194 * (which the system cannot deliver), only internal functions will be able to
195 * notify the registered functions.
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200196 */
197struct sig_handler *signal_register_task(int sig, struct task *task, int reason)
198{
199 struct sig_handler *sh;
200
Willy Tarreau1a53b5e2013-01-24 02:06:05 +0100201 if (sig < 0 || sig >= MAX_SIGNAL)
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200202 return NULL;
203
Willy Tarreaud0807c32010-08-27 18:26:11 +0200204 if (sig)
205 signal(sig, signal_handler);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200206
207 if (!task)
208 return NULL;
209
Willy Tarreaubafbe012017-11-24 17:34:44 +0100210 sh = pool_alloc(pool_head_sig_handlers);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200211 if (!sh)
212 return NULL;
213
214 sh->handler = task;
215 sh->arg = reason & ~TASK_WOKEN_ANY;
216 sh->flags = SIG_F_TYPE_TASK;
217 LIST_ADDQ(&signal_state[sig].handlers, &sh->list);
218 return sh;
219}
220
221/* Immediately unregister a handler so that no further signals may be delivered
222 * to it. The struct is released so the caller may not reference it anymore.
223 */
224void signal_unregister_handler(struct sig_handler *handler)
225{
226 LIST_DEL(&handler->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100227 pool_free(pool_head_sig_handlers, handler);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200228}
229
230/* Immediately unregister a handler so that no further signals may be delivered
231 * to it. The handler struct does not need to be known, only the function or
232 * task pointer. This method is expensive because it scans all the list, so it
233 * should only be used for rare cases (eg: exit). The struct is released so the
234 * caller may not reference it anymore.
235 */
236void signal_unregister_target(int sig, void *target)
237{
238 struct sig_handler *sh, *shb;
239
Willy Tarreau1a53b5e2013-01-24 02:06:05 +0100240 if (sig < 0 || sig >= MAX_SIGNAL)
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200241 return;
242
243 if (!target)
244 return;
245
246 list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) {
247 if (sh->handler == target) {
248 LIST_DEL(&sh->list);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100249 pool_free(pool_head_sig_handlers, sh);
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200250 break;
251 }
252 }
253}
William Lallemand31a1c1d2018-11-20 17:36:52 +0100254
255/*
256 * Immedialtely unregister every handler assigned to a signal <sig>.
257 * Once the handler list is empty, the signal is ignored with SIG_IGN.
258 */
259
260void signal_unregister(int sig)
261{
262 struct sig_handler *sh, *shb;
263
264 if (sig < 0 || sig >= MAX_SIGNAL)
265 return;
266
267 list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) {
268 LIST_DEL(&sh->list);
269 pool_free(pool_head_sig_handlers, sh);
270 }
271
272 signal(sig, SIG_IGN);
273}
Willy Tarreaub6b3df32018-11-26 16:31:20 +0100274
275INITCALL0(STG_PREPARE, signal_init);