xref: /PHP-5.6/Zend/zend_signal.c (revision 7bcdbcf9)
1 /*
2   +----------------------------------------------------------------------+
3   | Zend Signal Handling                                                 |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 2008 The PHP Group                                     |
6   +----------------------------------------------------------------------+
7   | This source file is subject to version 3.01 of the PHP license,      |
8   | that is bundled with this package in the file LICENSE, and is        |
9   | available through the world-wide-web at the following url:           |
10   | http://www.php.net/license/3_01.txt                                  |
11   | If you did not receive a copy of the PHP license and are unable to   |
12   | obtain it through the world-wide-web, please send a note to          |
13   | license@php.net so we can mail you a copy immediately.               |
14   +----------------------------------------------------------------------+
15   | Authors: Lucas Nealan <lucas@php.net>                                |
16   |          Arnaud Le Blanc <lbarnaud@php.net>                          |
17   +----------------------------------------------------------------------+
18 
19    This software was contributed to PHP by Facebook Inc. in 2008.
20 
21    Future revisions and derivatives of this source code must acknowledge
22    Facebook Inc. as the original contributor of this module by leaving
23    this note intact in the source code.
24 
25    All other licensing and usage conditions are those of the PHP Group.
26 */
27 
28  /* $Id$ */
29 
30 #define _GNU_SOURCE
31 #include <string.h>
32 
33 #include "zend.h"
34 #include "zend_globals.h"
35 
36 #ifdef HAVE_SIGNAL_H
37 #include <signal.h>
38 #endif
39 
40 #ifdef HAVE_UNISTD_H
41 #include <unistd.h>
42 #endif
43 
44 #ifdef ZEND_SIGNALS
45 
46 #include "zend_signal.h"
47 
48 #ifdef ZTS
49 ZEND_API int zend_signal_globals_id;
50 #else
51 zend_signal_globals_t zend_signal_globals;
52 #endif
53 
54 static void zend_signal_handler(int signo, siginfo_t *siginfo, void *context TSRMLS_DC);
55 static int zend_signal_register(int signo, void (*handler)(int, siginfo_t*, void*) TSRMLS_DC);
56 
57 #ifdef __CYGWIN__
58 #define TIMEOUT_SIG SIGALRM
59 #else
60 #define TIMEOUT_SIG SIGPROF
61 #endif
62 
63 static int zend_sigs[] = { TIMEOUT_SIG, SIGHUP, SIGINT, SIGQUIT, SIGTERM, SIGUSR1, SIGUSR2 };
64 
65 #define SA_FLAGS_MASK ~(SA_NODEFER | SA_RESETHAND)
66 
67 /* True globals, written only at process startup */
68 static zend_signal_entry_t global_orig_handlers[NSIG];
69 static sigset_t            global_sigmask;
70 
71 /* {{{ zend_signal_handler_defer
72  *  Blocks signals if in critical section */
zend_signal_handler_defer(int signo,siginfo_t * siginfo,void * context)73 void zend_signal_handler_defer(int signo, siginfo_t *siginfo, void *context)
74 {
75 	int errno_save = errno;
76 	zend_signal_queue_t *queue, *qtmp;
77 	TSRMLS_FETCH();
78 
79 	if (SIGG(active)) {
80 		if (SIGG(depth) == 0) { /* try to handle signal */
81 			if (SIGG(blocked) != -1) { /* inverse */
82 				SIGG(blocked) = -1; /* signal is not blocked */
83 			}
84 			if (SIGG(running) == 0) {
85 				SIGG(running) = 1;
86 				zend_signal_handler(signo, siginfo, context TSRMLS_CC);
87 
88 				queue = SIGG(phead);
89 				SIGG(phead) = NULL;
90 
91 				while (queue) {
92 					zend_signal_handler(queue->zend_signal.signo, queue->zend_signal.siginfo, queue->zend_signal.context TSRMLS_CC);
93 					qtmp = queue->next;
94 					queue->next = SIGG(pavail);
95 					queue->zend_signal.signo = 0;
96 					SIGG(pavail) = queue;
97 					queue = qtmp;
98 				}
99 				SIGG(running) = 0;
100 			}
101 		} else { /* delay signal handling */
102 			SIGG(blocked) = 0; /* signal is blocked */
103 
104 			if ((queue = SIGG(pavail))) { /* if none available it's simply forgotton */
105 				SIGG(pavail) = queue->next;
106 				queue->zend_signal.signo = signo;
107 				queue->zend_signal.siginfo = siginfo;
108 				queue->zend_signal.context = context;
109 				queue->next = NULL;
110 
111 				if (SIGG(phead) && SIGG(ptail)) {
112 					SIGG(ptail)->next = queue;
113 				} else {
114 					SIGG(phead) = queue;
115 				}
116 				SIGG(ptail) = queue;
117 			}
118 #if ZEND_DEBUG
119 			else { /* this may not be safe to do, but could work and be useful */
120 				zend_output_debug_string(0, "zend_signal: not enough queue storage, lost signal (%d)", signo);
121 			}
122 #endif
123 		}
124 	} else {
125 		/* need to just run handler if we're inactive and getting a signal */
126 		zend_signal_handler(signo, siginfo, context TSRMLS_CC);
127 	}
128 
129 	errno = errno_save;
130 } /* }}} */
131 
132 /* {{{ zend_signal_handler_unblock
133  * Handle deferred signal from HANDLE_UNBLOCK_ALARMS */
zend_signal_handler_unblock(TSRMLS_D)134 ZEND_API void zend_signal_handler_unblock(TSRMLS_D)
135 {
136 	zend_signal_queue_t *queue;
137 	zend_signal_t zend_signal;
138 
139 	if (SIGG(active)) {
140 		SIGNAL_BEGIN_CRITICAL(); /* procmask to protect handler_defer as if it were called by the kernel */
141 		queue = SIGG(phead);
142 		SIGG(phead) = queue->next;
143 		zend_signal = queue->zend_signal;
144 		queue->next = SIGG(pavail);
145 		queue->zend_signal.signo = 0;
146 		SIGG(pavail) = queue;
147 
148 		zend_signal_handler_defer(zend_signal.signo, zend_signal.siginfo, zend_signal.context);
149 		SIGNAL_END_CRITICAL();
150 	}
151 }
152 /* }}} */
153 
154 /* {{{ zend_signal_handler
155  *  Call the previously registered handler for a signal
156  */
zend_signal_handler(int signo,siginfo_t * siginfo,void * context TSRMLS_DC)157 static void zend_signal_handler(int signo, siginfo_t *siginfo, void *context TSRMLS_DC)
158 {
159 	int errno_save = errno;
160 	struct sigaction sa = {{0}};
161 	sigset_t sigset;
162 	zend_signal_entry_t p_sig = SIGG(handlers)[signo-1];
163 
164 	if (p_sig.handler == SIG_DFL) { /* raise default handler */
165 		if (sigaction(signo, NULL, &sa) == 0) {
166 			sa.sa_handler = SIG_DFL;
167 			sigemptyset(&sa.sa_mask);
168 
169 			sigemptyset(&sigset);
170 			sigaddset(&sigset, signo);
171 
172 			if (sigaction(signo, &sa, NULL) == 0) {
173 				/* throw away any blocked signals */
174 				sigprocmask(SIG_UNBLOCK, &sigset, NULL);
175 				raise(signo);
176 			}
177 		}
178 	} else if (p_sig.handler != SIG_IGN) { /* ignore SIG_IGN */
179 		if (p_sig.flags & SA_SIGINFO) {
180 			if (p_sig.flags & SA_RESETHAND) {
181 				SIGG(handlers)[signo-1].flags   = 0;
182 				SIGG(handlers)[signo-1].handler = SIG_DFL;
183 			}
184 			(*(void (*)(int, siginfo_t*, void*))p_sig.handler)(signo, siginfo, context);
185 		} else {
186 			(*(void (*)(int))p_sig.handler)(signo);
187 		}
188 	}
189 
190 	errno = errno_save;
191 } /* }}} */
192 
193 /* {{{ zend_sigaction
194  *  Register a signal handler that will be deferred in critical sections */
zend_sigaction(int signo,const struct sigaction * act,struct sigaction * oldact TSRMLS_DC)195 ZEND_API int zend_sigaction(int signo, const struct sigaction *act, struct sigaction *oldact TSRMLS_DC)
196 {
197 	struct sigaction sa = {{0}};
198 	sigset_t sigset;
199 
200 	if (oldact != NULL) {
201 		oldact->sa_flags   = SIGG(handlers)[signo-1].flags;
202 		oldact->sa_handler = (void *) SIGG(handlers)[signo-1].handler;
203 		oldact->sa_mask    = global_sigmask;
204 	}
205 	if (act != NULL) {
206 		SIGG(handlers)[signo-1].flags = act->sa_flags;
207 		if (act->sa_flags & SA_SIGINFO) {
208 			SIGG(handlers)[signo-1].handler = (void *) act->sa_sigaction;
209 		} else {
210 			SIGG(handlers)[signo-1].handler = (void *) act->sa_handler;
211 		}
212 
213 		sa.sa_flags     = SA_SIGINFO | (act->sa_flags & SA_FLAGS_MASK);
214 		sa.sa_sigaction = zend_signal_handler_defer;
215 		sa.sa_mask      = global_sigmask;
216 
217 		if (sigaction(signo, &sa, NULL) < 0) {
218 			zend_error(E_ERROR, "Error installing signal handler for %d", signo);
219 		}
220 
221 		/* unsure this signal is not blocked */
222 		sigemptyset(&sigset);
223 		sigaddset(&sigset, signo);
224 		zend_sigprocmask(SIG_UNBLOCK, &sigset, NULL);
225 	}
226 
227 	return SUCCESS;
228 }
229 /* }}} */
230 
231 /* {{{ zend_signal
232  *  Register a signal handler that will be deferred in critical sections */
zend_signal(int signo,void (* handler)(int)TSRMLS_DC)233 ZEND_API int zend_signal(int signo, void (*handler)(int) TSRMLS_DC)
234 {
235 	struct sigaction sa = {{0}};
236 
237 	sa.sa_flags   = 0;
238 	sa.sa_handler = handler;
239 	sa.sa_mask    = global_sigmask;
240 
241 	return zend_sigaction(signo, &sa, NULL TSRMLS_CC);
242 }
243 /* }}} */
244 
245 /* {{{ zend_signal_register
246  *  Set a handler for a signal we want to defer.
247  *  Previously set handler must have been saved before.
248  */
zend_signal_register(int signo,void (* handler)(int,siginfo_t *,void *)TSRMLS_DC)249 static int zend_signal_register(int signo, void (*handler)(int, siginfo_t*, void*) TSRMLS_DC)
250 {
251 	struct sigaction sa = {{0}};
252 
253 	if (sigaction(signo, NULL, &sa) == 0) {
254 		if ((sa.sa_flags & SA_SIGINFO) && sa.sa_sigaction == handler) {
255 			return FAILURE;
256 		}
257 
258 		SIGG(handlers)[signo-1].flags = sa.sa_flags;
259 		if (sa.sa_flags & SA_SIGINFO) {
260 			SIGG(handlers)[signo-1].handler = (void *)sa.sa_sigaction;
261 		} else {
262 			SIGG(handlers)[signo-1].handler = (void *)sa.sa_handler;
263 		}
264 
265 		sa.sa_flags     = SA_SIGINFO; /* we'll use a siginfo handler */
266 		sa.sa_sigaction = handler;
267 		sa.sa_mask      = global_sigmask;
268 
269 		if (sigaction(signo, &sa, NULL) < 0) {
270 			zend_error(E_ERROR, "Error installing signal handler for %d", signo);
271 		}
272 
273 		return SUCCESS;
274 	}
275 	return FAILURE;
276 } /* }}} */
277 
278 /* {{{ zend_signal_activate
279  *  Install our signal handlers, per request */
zend_signal_activate(TSRMLS_D)280 void zend_signal_activate(TSRMLS_D)
281 {
282 	int x;
283 
284 	memcpy(&SIGG(handlers), &global_orig_handlers, sizeof(global_orig_handlers));
285 
286 	for (x=0; x < sizeof(zend_sigs) / sizeof(*zend_sigs); x++) {
287 		zend_signal_register(zend_sigs[x], zend_signal_handler_defer TSRMLS_CC);
288 	}
289 
290 	SIGG(active) = 1;
291 	SIGG(depth)  = 0;
292 } /* }}} */
293 
294 /* {{{ zend_signal_deactivate
295  * */
zend_signal_deactivate(TSRMLS_D)296 void zend_signal_deactivate(TSRMLS_D)
297 {
298 	int x;
299 	struct sigaction sa = {{0}};
300 
301 	if (SIGG(check)) {
302 		if (SIGG(depth) != 0) {
303 			zend_error(E_CORE_WARNING, "zend_signal: shutdown with non-zero blocking depth (%d)", SIGG(depth));
304 		}
305 		/* did anyone steal our installed handler */
306 		for (x=0; x < sizeof(zend_sigs) / sizeof(*zend_sigs); x++) {
307 			sigaction(zend_sigs[x], NULL, &sa);
308 			if (sa.sa_sigaction != zend_signal_handler_defer) {
309 				zend_error(E_CORE_WARNING, "zend_signal: handler was replaced for signal (%d) after startup", zend_sigs[x]);
310 			}
311 		}
312 	}
313 
314 	SIGNAL_BEGIN_CRITICAL();
315 	SIGG(active) = 0;
316 	SIGG(running) = 0;
317 	SIGG(blocked) = -1;
318 	SIGG(depth) = 0;
319 	SIGNAL_END_CRITICAL();
320 }
321 /* }}} */
322 
zend_signal_globals_ctor(zend_signal_globals_t * zend_signal_globals TSRMLS_DC)323 static void zend_signal_globals_ctor(zend_signal_globals_t *zend_signal_globals TSRMLS_DC)
324 {
325 	size_t x;
326 
327 	memset(zend_signal_globals, 0, sizeof(*zend_signal_globals));
328 	zend_signal_globals->blocked = -1;
329 
330 	for (x = 0; x < sizeof(zend_signal_globals->pstorage) / sizeof(*zend_signal_globals->pstorage); ++x) {
331 		zend_signal_queue_t *queue = &zend_signal_globals->pstorage[x];
332 		queue->zend_signal.signo = 0;
333 		queue->next = zend_signal_globals->pavail;
334 		zend_signal_globals->pavail = queue;
335 	}
336 }
337 
zend_signal_globals_dtor(zend_signal_globals_t * zend_signal_globals TSRMLS_DC)338 static void zend_signal_globals_dtor(zend_signal_globals_t *zend_signal_globals TSRMLS_DC)
339 {
340 	zend_signal_globals->blocked = -1;
341 }
342 
343 /* {{{ zend_signal_startup
344  * alloc zend signal globals */
zend_signal_startup()345 void zend_signal_startup()
346 {
347 	int signo;
348 	struct sigaction sa = {{0}};
349 
350 #ifdef ZTS
351 	ts_allocate_id(&zend_signal_globals_id, sizeof(zend_signal_globals_t), (ts_allocate_ctor) zend_signal_globals_ctor, (ts_allocate_dtor) zend_signal_globals_dtor);
352 #else
353 	zend_signal_globals_ctor(&zend_signal_globals);
354 #endif
355 
356 	/* Used to block signals during execution of signal handlers */
357 	sigfillset(&global_sigmask);
358 	sigdelset(&global_sigmask, SIGILL);
359 	sigdelset(&global_sigmask, SIGABRT);
360 	sigdelset(&global_sigmask, SIGFPE);
361 	sigdelset(&global_sigmask, SIGKILL);
362 	sigdelset(&global_sigmask, SIGSEGV);
363 	sigdelset(&global_sigmask, SIGCONT);
364 	sigdelset(&global_sigmask, SIGSTOP);
365 	sigdelset(&global_sigmask, SIGTSTP);
366 	sigdelset(&global_sigmask, SIGTTIN);
367 	sigdelset(&global_sigmask, SIGTTOU);
368 #ifdef SIGBUS
369 	sigdelset(&global_sigmask, SIGBUS);
370 #endif
371 #ifdef SIGSYS
372 	sigdelset(&global_sigmask, SIGSYS);
373 #endif
374 #ifdef SIGTRAP
375 	sigdelset(&global_sigmask, SIGTRAP);
376 #endif
377 
378 	/* Save previously registered signal handlers into orig_handlers */
379 	memset(&global_orig_handlers, 0, sizeof(global_orig_handlers));
380 	for (signo = 1; signo < NSIG; ++signo) {
381 		if (sigaction(signo, NULL, &sa) == 0) {
382 			global_orig_handlers[signo-1].flags = sa.sa_flags;
383 			if (sa.sa_flags & SA_SIGINFO) {
384 				global_orig_handlers[signo-1].handler = (void *) sa.sa_sigaction;
385 			} else {
386 				global_orig_handlers[signo-1].handler = (void *) sa.sa_handler;
387 			}
388 		}
389 	}
390 }
391 /* }}} */
392 
393 /* {{{ zend_signal_shutdown
394  * called by zend_shutdown */
zend_signal_shutdown(TSRMLS_D)395 void zend_signal_shutdown(TSRMLS_D)
396 {
397 #ifndef ZTS
398 	zend_signal_globals_dtor(&zend_signal_globals);
399 #endif
400 }
401 /* }}} */
402 
403 
404 #endif /* ZEND_SIGNALS */
405 
406 /*
407  * Local variables:
408  * tab-width: 4
409  * c-basic-offset: 4
410  * indent-tabs-mode: t
411  * End:
412  * vim600: fdm=marker
413  * vim: noet sw=4 ts=4
414  */
415