Annotation of embedaddon/php/Zend/zend_signal.c, revision 1.1.1.1
1.1 misho 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 */
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 */
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: */
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 */
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_WARNING, "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 */
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: */
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_WARNING, "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 */
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: * */
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:
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:
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 */
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 */
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: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend_signal.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend