1 /*
2 * Copyright (C) 2004, 2005, 2007-2009 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /* $Id: app.c,v 1.64 2009/11/04 05:58:46 marka Exp $ */
19
20 /*! \file */
21
22 #include <config.h>
23
24 #include <sys/param.h> /* Openserver 5.0.6A and FD_SETSIZE */
25 #include <sys/types.h>
26
27 #include <stddef.h>
28 #include <stdlib.h>
29 #include <errno.h>
30 #include <unistd.h>
31 #include <signal.h>
32 #include <sys/time.h>
33 #ifdef HAVE_EPOLL
34 #include <sys/epoll.h>
35 #endif
36
37 #include <isc/app.h>
38 #include <isc/boolean.h>
39 #include <isc/condition.h>
40 #include <isc/mem.h>
41 #include <isc/msgs.h>
42 #include <isc/mutex.h>
43 #include <isc/event.h>
44 #include <isc/platform.h>
45 #include <isc/strerror.h>
46 #include <isc/string.h>
47 #include <isc/task.h>
48 #include <isc/time.h>
49 #include <isc/util.h>
50
51 /*%
52 * For BIND9 internal applications built with threads, we use a single app
53 * context and let multiple worker, I/O, timer threads do actual jobs.
54 * For other cases (including BIND9 built without threads) an app context acts
55 * as an event loop dispatching various events.
56 */
57 #if defined(ISC_PLATFORM_USETHREADS) && defined(BIND9)
58 #define USE_THREADS_SINGLECTX
59 #endif
60
61 #ifdef ISC_PLATFORM_USETHREADS
62 #include <pthread.h>
63 #endif
64
65 #ifndef USE_THREADS_SINGLECTX
66 #include "../timer_p.h"
67 #include "../task_p.h"
68 #include "socket_p.h"
69 #endif /* USE_THREADS_SINGLECTX */
70
71 #ifdef ISC_PLATFORM_USETHREADS
72 static pthread_t blockedthread;
73 #endif /* ISC_PLATFORM_USETHREADS */
74
75 /*%
76 * The following can be either static or public, depending on build environment.
77 */
78
79 #ifdef BIND9
80 #define ISC_APPFUNC_SCOPE
81 #else
82 #define ISC_APPFUNC_SCOPE static
83 #endif
84
85 ISC_APPFUNC_SCOPE isc_result_t isc__app_start(void);
86 ISC_APPFUNC_SCOPE isc_result_t isc__app_ctxstart(isc_appctx_t *ctx);
87 ISC_APPFUNC_SCOPE isc_result_t isc__app_onrun(isc_mem_t *mctx,
88 isc_task_t *task,
89 isc_taskaction_t action,
90 void *arg);
91 ISC_APPFUNC_SCOPE isc_result_t isc__app_ctxrun(isc_appctx_t *ctx);
92 ISC_APPFUNC_SCOPE isc_result_t isc__app_run(void);
93 ISC_APPFUNC_SCOPE isc_result_t isc__app_ctxshutdown(isc_appctx_t *ctx);
94 ISC_APPFUNC_SCOPE isc_result_t isc__app_shutdown(void);
95 ISC_APPFUNC_SCOPE isc_result_t isc__app_reload(void);
96 ISC_APPFUNC_SCOPE isc_result_t isc__app_ctxsuspend(isc_appctx_t *ctx);
97 ISC_APPFUNC_SCOPE void isc__app_ctxfinish(isc_appctx_t *ctx);
98 ISC_APPFUNC_SCOPE void isc__app_finish(void);
99 ISC_APPFUNC_SCOPE void isc__app_block(void);
100 ISC_APPFUNC_SCOPE void isc__app_unblock(void);
101 ISC_APPFUNC_SCOPE isc_result_t isc__appctx_create(isc_mem_t *mctx,
102 isc_appctx_t **ctxp);
103 ISC_APPFUNC_SCOPE void isc__appctx_destroy(isc_appctx_t **ctxp);
104 ISC_APPFUNC_SCOPE void isc__appctx_settaskmgr(isc_appctx_t *ctx,
105 isc_taskmgr_t *taskmgr);
106 ISC_APPFUNC_SCOPE void isc__appctx_setsocketmgr(isc_appctx_t *ctx,
107 isc_socketmgr_t *socketmgr);
108 ISC_APPFUNC_SCOPE void isc__appctx_settimermgr(isc_appctx_t *ctx,
109 isc_timermgr_t *timermgr);
110
111 /*
112 * The application context of this module. This implementation actually
113 * doesn't use it. (This may change in the future).
114 */
115 #define APPCTX_MAGIC ISC_MAGIC('A', 'p', 'c', 'x')
116 #define VALID_APPCTX(c) ISC_MAGIC_VALID(c, APPCTX_MAGIC)
117
118 typedef struct isc__appctx {
119 isc_appctx_t common;
120 isc_mem_t *mctx;
121 isc_mutex_t lock;
122 isc_eventlist_t on_run;
123 isc_boolean_t shutdown_requested;
124 isc_boolean_t running;
125
126 /*!
127 * We assume that 'want_shutdown' can be read and written atomically.
128 */
129 isc_boolean_t want_shutdown;
130 /*
131 * We assume that 'want_reload' can be read and written atomically.
132 */
133 isc_boolean_t want_reload;
134
135 isc_boolean_t blocked;
136
137 isc_taskmgr_t *taskmgr;
138 isc_socketmgr_t *socketmgr;
139 isc_timermgr_t *timermgr;
140 } isc__appctx_t;
141
142 static isc__appctx_t isc_g_appctx;
143
144 static struct {
145 isc_appmethods_t methods;
146
147 /*%
148 * The following are defined just for avoiding unused static functions.
149 */
150 #ifndef BIND9
151 void *run, *shutdown, *start, *onrun, *reload, *finish,
152 *block, *unblock;
153 #endif
154 } appmethods = {
155 {
156 isc__appctx_destroy,
157 isc__app_ctxstart,
158 isc__app_ctxrun,
159 isc__app_ctxsuspend,
160 isc__app_ctxshutdown,
161 isc__app_ctxfinish,
162 isc__appctx_settaskmgr,
163 isc__appctx_setsocketmgr,
164 isc__appctx_settimermgr
165 }
166 #ifndef BIND9
167 ,
168 (void *)isc__app_run, (void *)isc__app_shutdown,
169 (void *)isc__app_start, (void *)isc__app_onrun, (void *)isc__app_reload,
170 (void *)isc__app_finish, (void *)isc__app_block,
171 (void *)isc__app_unblock
172 #endif
173 };
174
175 #ifdef HAVE_LINUXTHREADS
176 /*!
177 * Linux has sigwait(), but it appears to prevent signal handlers from
178 * running, even if they're not in the set being waited for. This makes
179 * it impossible to get the default actions for SIGILL, SIGSEGV, etc.
180 * Instead of messing with it, we just use sigsuspend() instead.
181 */
182 #undef HAVE_SIGWAIT
183 /*!
184 * We need to remember which thread is the main thread...
185 */
186 static pthread_t main_thread;
187 #endif
188
189 #ifndef HAVE_SIGWAIT
190 static void
exit_action(int arg)191 exit_action(int arg) {
192 UNUSED(arg);
193 isc_g_appctx.want_shutdown = ISC_TRUE;
194 }
195
196 static void
reload_action(int arg)197 reload_action(int arg) {
198 UNUSED(arg);
199 isc_g_appctx.want_reload = ISC_TRUE;
200 }
201 #endif
202
203 static isc_result_t
handle_signal(int sig,void (* handler)(int))204 handle_signal(int sig, void (*handler)(int)) {
205 struct sigaction sa;
206 char strbuf[ISC_STRERRORSIZE];
207
208 memset(&sa, 0, sizeof(sa));
209 sa.sa_handler = handler;
210
211 if (sigfillset(&sa.sa_mask) != 0 ||
212 sigaction(sig, &sa, NULL) < 0) {
213 isc__strerror(errno, strbuf, sizeof(strbuf));
214 UNEXPECTED_ERROR(__FILE__, __LINE__,
215 isc_msgcat_get(isc_msgcat, ISC_MSGSET_APP,
216 ISC_MSG_SIGNALSETUP,
217 "handle_signal() %d setup: %s"),
218 sig, strbuf);
219 return (ISC_R_UNEXPECTED);
220 }
221
222 return (ISC_R_SUCCESS);
223 }
224
225 ISC_APPFUNC_SCOPE isc_result_t
isc__app_ctxstart(isc_appctx_t * ctx0)226 isc__app_ctxstart(isc_appctx_t *ctx0) {
227 isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
228 isc_result_t result;
229
230 REQUIRE(VALID_APPCTX(ctx));
231
232 /*
233 * Start an ISC library application.
234 */
235
236 #ifdef NEED_PTHREAD_INIT
237 /*
238 * BSDI 3.1 seg faults in pthread_sigmask() if we don't do this.
239 */
240 presult = pthread_init();
241 if (presult != 0) {
242 isc__strerror(presult, strbuf, sizeof(strbuf));
243 UNEXPECTED_ERROR(__FILE__, __LINE__,
244 "isc_app_start() pthread_init: %s", strbuf);
245 return (ISC_R_UNEXPECTED);
246 }
247 #endif
248
249 #ifdef HAVE_LINUXTHREADS
250 main_thread = pthread_self();
251 #endif
252
253 result = isc_mutex_init(&ctx->lock);
254 if (result != ISC_R_SUCCESS)
255 return (result);
256
257 ISC_LIST_INIT(ctx->on_run);
258
259 ctx->shutdown_requested = ISC_FALSE;
260 ctx->running = ISC_FALSE;
261 ctx->want_shutdown = ISC_FALSE;
262 ctx->want_reload = ISC_FALSE;
263 ctx->blocked = ISC_FALSE;
264
265 return (ISC_R_SUCCESS);
266 }
267
268 ISC_APPFUNC_SCOPE isc_result_t
isc__app_start(void)269 isc__app_start(void) {
270 isc_result_t result;
271 int presult;
272 sigset_t sset;
273 char strbuf[ISC_STRERRORSIZE];
274
275 isc_g_appctx.common.impmagic = APPCTX_MAGIC;
276 isc_g_appctx.common.magic = ISCAPI_APPCTX_MAGIC;
277 isc_g_appctx.common.methods = &appmethods.methods;
278 isc_g_appctx.mctx = NULL;
279 /* The remaining members will be initialized in ctxstart() */
280
281 result = isc__app_ctxstart((isc_appctx_t *)&isc_g_appctx);
282 if (result != ISC_R_SUCCESS)
283 return (result);
284
285 #ifndef HAVE_SIGWAIT
286 /*
287 * Install do-nothing handlers for SIGINT and SIGTERM.
288 *
289 * We install them now because BSDI 3.1 won't block
290 * the default actions, regardless of what we do with
291 * pthread_sigmask().
292 */
293 result = handle_signal(SIGINT, exit_action);
294 if (result != ISC_R_SUCCESS)
295 return (result);
296 result = handle_signal(SIGTERM, exit_action);
297 if (result != ISC_R_SUCCESS)
298 return (result);
299 #endif
300
301 /*
302 * Always ignore SIGPIPE.
303 */
304 result = handle_signal(SIGPIPE, SIG_IGN);
305 if (result != ISC_R_SUCCESS)
306 return (result);
307
308 /*
309 * On Solaris 2, delivery of a signal whose action is SIG_IGN
310 * will not cause sigwait() to return. We may have inherited
311 * unexpected actions for SIGHUP, SIGINT, and SIGTERM from our parent
312 * process (e.g, Solaris cron). Set an action of SIG_DFL to make
313 * sure sigwait() works as expected. Only do this for SIGTERM and
314 * SIGINT if we don't have sigwait(), since a different handler is
315 * installed above.
316 */
317 result = handle_signal(SIGHUP, SIG_DFL);
318 if (result != ISC_R_SUCCESS)
319 return (result);
320
321 #ifdef HAVE_SIGWAIT
322 result = handle_signal(SIGTERM, SIG_DFL);
323 if (result != ISC_R_SUCCESS)
324 return (result);
325 result = handle_signal(SIGINT, SIG_DFL);
326 if (result != ISC_R_SUCCESS)
327 return (result);
328 #endif
329
330 #ifdef ISC_PLATFORM_USETHREADS
331 /*
332 * Block SIGHUP, SIGINT, SIGTERM.
333 *
334 * If isc_app_start() is called from the main thread before any other
335 * threads have been created, then the pthread_sigmask() call below
336 * will result in all threads having SIGHUP, SIGINT and SIGTERM
337 * blocked by default, ensuring that only the thread that calls
338 * sigwait() for them will get those signals.
339 */
340 if (sigemptyset(&sset) != 0 ||
341 sigaddset(&sset, SIGHUP) != 0 ||
342 sigaddset(&sset, SIGINT) != 0 ||
343 sigaddset(&sset, SIGTERM) != 0) {
344 isc__strerror(errno, strbuf, sizeof(strbuf));
345 UNEXPECTED_ERROR(__FILE__, __LINE__,
346 "isc_app_start() sigsetops: %s", strbuf);
347 return (ISC_R_UNEXPECTED);
348 }
349 presult = pthread_sigmask(SIG_BLOCK, &sset, NULL);
350 if (presult != 0) {
351 isc__strerror(presult, strbuf, sizeof(strbuf));
352 UNEXPECTED_ERROR(__FILE__, __LINE__,
353 "isc_app_start() pthread_sigmask: %s",
354 strbuf);
355 return (ISC_R_UNEXPECTED);
356 }
357 #else /* ISC_PLATFORM_USETHREADS */
358 /*
359 * Unblock SIGHUP, SIGINT, SIGTERM.
360 *
361 * If we're not using threads, we need to make sure that SIGHUP,
362 * SIGINT and SIGTERM are not inherited as blocked from the parent
363 * process.
364 */
365 if (sigemptyset(&sset) != 0 ||
366 sigaddset(&sset, SIGHUP) != 0 ||
367 sigaddset(&sset, SIGINT) != 0 ||
368 sigaddset(&sset, SIGTERM) != 0) {
369 isc__strerror(errno, strbuf, sizeof(strbuf));
370 UNEXPECTED_ERROR(__FILE__, __LINE__,
371 "isc_app_start() sigsetops: %s", strbuf);
372 return (ISC_R_UNEXPECTED);
373 }
374 presult = sigprocmask(SIG_UNBLOCK, &sset, NULL);
375 if (presult != 0) {
376 isc__strerror(presult, strbuf, sizeof(strbuf));
377 UNEXPECTED_ERROR(__FILE__, __LINE__,
378 "isc_app_start() sigprocmask: %s", strbuf);
379 return (ISC_R_UNEXPECTED);
380 }
381 #endif /* ISC_PLATFORM_USETHREADS */
382
383 return (ISC_R_SUCCESS);
384 }
385
386 ISC_APPFUNC_SCOPE isc_result_t
isc__app_onrun(isc_mem_t * mctx,isc_task_t * task,isc_taskaction_t action,void * arg)387 isc__app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
388 void *arg)
389 {
390 isc_event_t *event;
391 isc_task_t *cloned_task = NULL;
392 isc_result_t result;
393
394 LOCK(&isc_g_appctx.lock);
395
396 if (isc_g_appctx.running) {
397 result = ISC_R_ALREADYRUNNING;
398 goto unlock;
399 }
400
401 /*
402 * Note that we store the task to which we're going to send the event
403 * in the event's "sender" field.
404 */
405 isc_task_attach(task, &cloned_task);
406 event = isc_event_allocate(mctx, cloned_task, ISC_APPEVENT_SHUTDOWN,
407 action, arg, sizeof(*event));
408 if (event == NULL) {
409 result = ISC_R_NOMEMORY;
410 goto unlock;
411 }
412
413 ISC_LIST_APPEND(isc_g_appctx.on_run, event, ev_link);
414
415 result = ISC_R_SUCCESS;
416
417 unlock:
418 UNLOCK(&isc_g_appctx.lock);
419
420 return (result);
421 }
422
423 #ifndef USE_THREADS_SINGLECTX
424 /*!
425 * Event loop for nonthreaded programs.
426 */
427 static isc_result_t
evloop(isc__appctx_t * ctx)428 evloop(isc__appctx_t *ctx) {
429 isc_result_t result;
430
431 while (!ctx->want_shutdown) {
432 int n;
433 isc_time_t when, now;
434 struct timeval tv, *tvp;
435 isc_socketwait_t *swait;
436 isc_boolean_t readytasks;
437 isc_boolean_t call_timer_dispatch = ISC_FALSE;
438
439 /*
440 * Check the reload (or suspend) case first for exiting the
441 * loop as fast as possible in case:
442 * - the direct call to isc__taskmgr_dispatch() in
443 * isc__app_ctxrun() completes all the tasks so far,
444 * - there is thus currently no active task, and
445 * - there is a timer event
446 */
447 if (ctx->want_reload) {
448 ctx->want_reload = ISC_FALSE;
449 return (ISC_R_RELOAD);
450 }
451
452 readytasks = isc__taskmgr_ready(ctx->taskmgr);
453 if (readytasks) {
454 tv.tv_sec = 0;
455 tv.tv_usec = 0;
456 tvp = &tv;
457 call_timer_dispatch = ISC_TRUE;
458 } else {
459 result = isc__timermgr_nextevent(ctx->timermgr, &when);
460 if (result != ISC_R_SUCCESS)
461 tvp = NULL;
462 else {
463 isc_uint64_t us;
464
465 TIME_NOW(&now);
466 us = isc_time_microdiff(&when, &now);
467 if (us == 0)
468 call_timer_dispatch = ISC_TRUE;
469 tv.tv_sec = us / 1000000;
470 tv.tv_usec = us % 1000000;
471 tvp = &tv;
472 }
473 }
474
475 swait = NULL;
476 n = isc__socketmgr_waitevents(ctx->socketmgr, tvp, &swait);
477
478 if (n == 0 || call_timer_dispatch) {
479 /*
480 * We call isc__timermgr_dispatch() only when
481 * necessary, in order to reduce overhead. If the
482 * select() call indicates a timeout, we need the
483 * dispatch. Even if not, if we set the 0-timeout
484 * for the select() call, we need to check the timer
485 * events. In the 'readytasks' case, there may be no
486 * timeout event actually, but there is no other way
487 * to reduce the overhead.
488 * Note that we do not have to worry about the case
489 * where a new timer is inserted during the select()
490 * call, since this loop only runs in the non-thread
491 * mode.
492 */
493 isc__timermgr_dispatch(ctx->timermgr);
494 }
495 if (n > 0)
496 (void)isc__socketmgr_dispatch(ctx->socketmgr, swait);
497 (void)isc__taskmgr_dispatch(ctx->taskmgr);
498 }
499 return (ISC_R_SUCCESS);
500 }
501 #endif /* USE_THREADS_SINGLECTX */
502
503 #ifndef ISC_PLATFORM_USETHREADS
504 /*
505 * This is a gross hack to support waiting for condition
506 * variables in nonthreaded programs in a limited way;
507 * see lib/isc/nothreads/include/isc/condition.h.
508 * We implement isc_condition_wait() by entering the
509 * event loop recursively until the want_shutdown flag
510 * is set by isc_condition_signal().
511 */
512
513 /*!
514 * \brief True if we are currently executing in the recursive
515 * event loop.
516 */
517 static isc_boolean_t in_recursive_evloop = ISC_FALSE;
518
519 /*!
520 * \brief True if we are exiting the event loop as the result of
521 * a call to isc_condition_signal() rather than a shutdown
522 * or reload.
523 */
524 static isc_boolean_t signalled = ISC_FALSE;
525
526 isc_result_t
isc__nothread_wait_hack(isc_condition_t * cp,isc_mutex_t * mp)527 isc__nothread_wait_hack(isc_condition_t *cp, isc_mutex_t *mp) {
528 isc_result_t result;
529
530 UNUSED(cp);
531 UNUSED(mp);
532
533 INSIST(!in_recursive_evloop);
534 in_recursive_evloop = ISC_TRUE;
535
536 INSIST(*mp == 1); /* Mutex must be locked on entry. */
537 --*mp;
538
539 result = evloop(&isc_g_appctx);
540 if (result == ISC_R_RELOAD)
541 isc_g_appctx.want_reload = ISC_TRUE;
542 if (signalled) {
543 isc_g_appctx.want_shutdown = ISC_FALSE;
544 signalled = ISC_FALSE;
545 }
546
547 ++*mp;
548 in_recursive_evloop = ISC_FALSE;
549 return (ISC_R_SUCCESS);
550 }
551
552 isc_result_t
isc__nothread_signal_hack(isc_condition_t * cp)553 isc__nothread_signal_hack(isc_condition_t *cp) {
554
555 UNUSED(cp);
556
557 INSIST(in_recursive_evloop);
558
559 isc_g_appctx.want_shutdown = ISC_TRUE;
560 signalled = ISC_TRUE;
561 return (ISC_R_SUCCESS);
562 }
563
564 #endif /* ISC_PLATFORM_USETHREADS */
565
566 ISC_APPFUNC_SCOPE isc_result_t
isc__app_ctxrun(isc_appctx_t * ctx0)567 isc__app_ctxrun(isc_appctx_t *ctx0) {
568 isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
569 int result;
570 isc_event_t *event, *next_event;
571 isc_task_t *task;
572 #ifdef USE_THREADS_SINGLECTX
573 sigset_t sset;
574 char strbuf[ISC_STRERRORSIZE];
575 #ifdef HAVE_SIGWAIT
576 int sig;
577 #endif
578 #endif /* USE_THREADS_SINGLECTX */
579
580 REQUIRE(VALID_APPCTX(ctx));
581
582 #ifdef HAVE_LINUXTHREADS
583 REQUIRE(main_thread == pthread_self());
584 #endif
585
586 LOCK(&ctx->lock);
587
588 if (!ctx->running) {
589 ctx->running = ISC_TRUE;
590
591 /*
592 * Post any on-run events (in FIFO order).
593 */
594 for (event = ISC_LIST_HEAD(ctx->on_run);
595 event != NULL;
596 event = next_event) {
597 next_event = ISC_LIST_NEXT(event, ev_link);
598 ISC_LIST_UNLINK(ctx->on_run, event, ev_link);
599 task = event->ev_sender;
600 event->ev_sender = NULL;
601 isc_task_sendanddetach(&task, &event);
602 }
603
604 }
605
606 UNLOCK(&ctx->lock);
607
608 #ifndef HAVE_SIGWAIT
609 /*
610 * Catch SIGHUP.
611 *
612 * We do this here to ensure that the signal handler is installed
613 * (i.e. that it wasn't a "one-shot" handler).
614 */
615 if (ctx == &isc_g_appctx) {
616 result = handle_signal(SIGHUP, reload_action);
617 if (result != ISC_R_SUCCESS)
618 return (ISC_R_SUCCESS);
619 }
620 #endif
621
622 #ifdef USE_THREADS_SINGLECTX
623 /*
624 * When we are using multiple contexts, we don't rely on signals.
625 */
626 if (ctx != &isc_g_appctx)
627 return (ISC_R_SUCCESS);
628
629 /*
630 * There is no danger if isc_app_shutdown() is called before we wait
631 * for signals. Signals are blocked, so any such signal will simply
632 * be made pending and we will get it when we call sigwait().
633 */
634
635 while (!ctx->want_shutdown) {
636 #ifdef HAVE_SIGWAIT
637 /*
638 * Wait for SIGHUP, SIGINT, or SIGTERM.
639 */
640 if (sigemptyset(&sset) != 0 ||
641 sigaddset(&sset, SIGHUP) != 0 ||
642 sigaddset(&sset, SIGINT) != 0 ||
643 sigaddset(&sset, SIGTERM) != 0) {
644 isc__strerror(errno, strbuf, sizeof(strbuf));
645 UNEXPECTED_ERROR(__FILE__, __LINE__,
646 "isc_app_run() sigsetops: %s", strbuf);
647 return (ISC_R_UNEXPECTED);
648 }
649
650 #ifndef HAVE_UNIXWARE_SIGWAIT
651 result = sigwait(&sset, &sig);
652 if (result == 0) {
653 if (sig == SIGINT || sig == SIGTERM)
654 ctx->want_shutdown = ISC_TRUE;
655 else if (sig == SIGHUP)
656 ctx->want_reload = ISC_TRUE;
657 }
658
659 #else /* Using UnixWare sigwait semantics. */
660 sig = sigwait(&sset);
661 if (sig >= 0) {
662 if (sig == SIGINT || sig == SIGTERM)
663 ctx->want_shutdown = ISC_TRUE;
664 else if (sig == SIGHUP)
665 ctx->want_reload = ISC_TRUE;
666 }
667
668 #endif /* HAVE_UNIXWARE_SIGWAIT */
669 #else /* Don't have sigwait(). */
670 /*
671 * Listen for all signals.
672 */
673 if (sigemptyset(&sset) != 0) {
674 isc__strerror(errno, strbuf, sizeof(strbuf));
675 UNEXPECTED_ERROR(__FILE__, __LINE__,
676 "isc_app_run() sigsetops: %s",
677 strbuf);
678 return (ISC_R_UNEXPECTED);
679 }
680 result = sigsuspend(&sset);
681 #endif /* HAVE_SIGWAIT */
682
683 if (ctx->want_reload) {
684 ctx->want_reload = ISC_FALSE;
685 return (ISC_R_RELOAD);
686 }
687
688 if (ctx->want_shutdown && ctx->blocked)
689 exit(1);
690 }
691
692 #else /* USE_THREADS_SINGLECTX */
693
694 (void)isc__taskmgr_dispatch(ctx->taskmgr);
695
696 result = evloop(ctx);
697 if (result != ISC_R_SUCCESS)
698 return (result);
699
700 #endif /* USE_THREADS_SINGLECTX */
701
702 return (ISC_R_SUCCESS);
703 }
704
705 ISC_APPFUNC_SCOPE isc_result_t
isc__app_run()706 isc__app_run() {
707 return (isc__app_ctxrun((isc_appctx_t *)&isc_g_appctx));
708 }
709
710 ISC_APPFUNC_SCOPE isc_result_t
isc__app_ctxshutdown(isc_appctx_t * ctx0)711 isc__app_ctxshutdown(isc_appctx_t *ctx0) {
712 isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
713 isc_boolean_t want_kill = ISC_TRUE;
714 char strbuf[ISC_STRERRORSIZE];
715
716 REQUIRE(VALID_APPCTX(ctx));
717
718 LOCK(&ctx->lock);
719
720 REQUIRE(ctx->running);
721
722 if (ctx->shutdown_requested)
723 want_kill = ISC_FALSE;
724 else
725 ctx->shutdown_requested = ISC_TRUE;
726
727 UNLOCK(&ctx->lock);
728
729 if (want_kill) {
730 if (ctx != &isc_g_appctx)
731 ctx->want_shutdown = ISC_TRUE;
732 else {
733 #ifdef HAVE_LINUXTHREADS
734 int result;
735
736 result = pthread_kill(main_thread, SIGTERM);
737 if (result != 0) {
738 isc__strerror(result, strbuf, sizeof(strbuf));
739 UNEXPECTED_ERROR(__FILE__, __LINE__,
740 "isc_app_shutdown() "
741 "pthread_kill: %s",
742 strbuf);
743 return (ISC_R_UNEXPECTED);
744 }
745 #else
746 if (kill(getpid(), SIGTERM) < 0) {
747 isc__strerror(errno, strbuf, sizeof(strbuf));
748 UNEXPECTED_ERROR(__FILE__, __LINE__,
749 "isc_app_shutdown() "
750 "kill: %s", strbuf);
751 return (ISC_R_UNEXPECTED);
752 }
753 #endif /* HAVE_LINUXTHREADS */
754 }
755 }
756
757 return (ISC_R_SUCCESS);
758 }
759
760 ISC_APPFUNC_SCOPE isc_result_t
isc__app_shutdown()761 isc__app_shutdown() {
762 return (isc__app_ctxshutdown((isc_appctx_t *)&isc_g_appctx));
763 }
764
765 ISC_APPFUNC_SCOPE isc_result_t
isc__app_ctxsuspend(isc_appctx_t * ctx0)766 isc__app_ctxsuspend(isc_appctx_t *ctx0) {
767 isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
768 isc_boolean_t want_kill = ISC_TRUE;
769 char strbuf[ISC_STRERRORSIZE];
770
771 REQUIRE(VALID_APPCTX(ctx));
772
773 LOCK(&ctx->lock);
774
775 REQUIRE(ctx->running);
776
777 /*
778 * Don't send the reload signal if we're shutting down.
779 */
780 if (ctx->shutdown_requested)
781 want_kill = ISC_FALSE;
782
783 UNLOCK(&ctx->lock);
784
785 if (want_kill) {
786 if (ctx != &isc_g_appctx)
787 ctx->want_reload = ISC_TRUE;
788 else {
789 #ifdef HAVE_LINUXTHREADS
790 int result;
791
792 result = pthread_kill(main_thread, SIGHUP);
793 if (result != 0) {
794 isc__strerror(result, strbuf, sizeof(strbuf));
795 UNEXPECTED_ERROR(__FILE__, __LINE__,
796 "isc_app_reload() "
797 "pthread_kill: %s",
798 strbuf);
799 return (ISC_R_UNEXPECTED);
800 }
801 #else
802 if (kill(getpid(), SIGHUP) < 0) {
803 isc__strerror(errno, strbuf, sizeof(strbuf));
804 UNEXPECTED_ERROR(__FILE__, __LINE__,
805 "isc_app_reload() "
806 "kill: %s", strbuf);
807 return (ISC_R_UNEXPECTED);
808 }
809 #endif
810 }
811 }
812
813 return (ISC_R_SUCCESS);
814 }
815
816 ISC_APPFUNC_SCOPE isc_result_t
isc__app_reload(void)817 isc__app_reload(void) {
818 return (isc__app_ctxsuspend((isc_appctx_t *)&isc_g_appctx));
819 }
820
821 ISC_APPFUNC_SCOPE void
isc__app_ctxfinish(isc_appctx_t * ctx0)822 isc__app_ctxfinish(isc_appctx_t *ctx0) {
823 isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
824
825 REQUIRE(VALID_APPCTX(ctx));
826
827 DESTROYLOCK(&ctx->lock);
828 }
829
830 ISC_APPFUNC_SCOPE void
isc__app_finish(void)831 isc__app_finish(void) {
832 isc__app_ctxfinish((isc_appctx_t *)&isc_g_appctx);
833 }
834
835 ISC_APPFUNC_SCOPE void
isc__app_block(void)836 isc__app_block(void) {
837 #ifdef ISC_PLATFORM_USETHREADS
838 sigset_t sset;
839 #endif /* ISC_PLATFORM_USETHREADS */
840 REQUIRE(isc_g_appctx.running);
841 REQUIRE(!isc_g_appctx.blocked);
842
843 isc_g_appctx.blocked = ISC_TRUE;
844 #ifdef ISC_PLATFORM_USETHREADS
845 blockedthread = pthread_self();
846 RUNTIME_CHECK(sigemptyset(&sset) == 0 &&
847 sigaddset(&sset, SIGINT) == 0 &&
848 sigaddset(&sset, SIGTERM) == 0);
849 RUNTIME_CHECK(pthread_sigmask(SIG_UNBLOCK, &sset, NULL) == 0);
850 #endif /* ISC_PLATFORM_USETHREADS */
851 }
852
853 ISC_APPFUNC_SCOPE void
isc__app_unblock(void)854 isc__app_unblock(void) {
855 #ifdef ISC_PLATFORM_USETHREADS
856 sigset_t sset;
857 #endif /* ISC_PLATFORM_USETHREADS */
858
859 REQUIRE(isc_g_appctx.running);
860 REQUIRE(isc_g_appctx.blocked);
861
862 isc_g_appctx.blocked = ISC_FALSE;
863
864 #ifdef ISC_PLATFORM_USETHREADS
865 REQUIRE(blockedthread == pthread_self());
866
867 RUNTIME_CHECK(sigemptyset(&sset) == 0 &&
868 sigaddset(&sset, SIGINT) == 0 &&
869 sigaddset(&sset, SIGTERM) == 0);
870 RUNTIME_CHECK(pthread_sigmask(SIG_BLOCK, &sset, NULL) == 0);
871 #endif /* ISC_PLATFORM_USETHREADS */
872 }
873
874 ISC_APPFUNC_SCOPE isc_result_t
isc__appctx_create(isc_mem_t * mctx,isc_appctx_t ** ctxp)875 isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
876 isc__appctx_t *ctx;
877
878 REQUIRE(mctx != NULL);
879 REQUIRE(ctxp != NULL && *ctxp == NULL);
880
881 ctx = isc_mem_get(mctx, sizeof(*ctx));
882 if (ctx == NULL)
883 return (ISC_R_NOMEMORY);
884
885 ctx->common.impmagic = APPCTX_MAGIC;
886 ctx->common.magic = ISCAPI_APPCTX_MAGIC;
887 ctx->common.methods = &appmethods.methods;
888
889 ctx->mctx = NULL;
890 isc_mem_attach(mctx, &ctx->mctx);
891
892 ctx->taskmgr = NULL;
893 ctx->socketmgr = NULL;
894 ctx->timermgr = NULL;
895
896 *ctxp = (isc_appctx_t *)ctx;
897
898 return (ISC_R_SUCCESS);
899 }
900
901 ISC_APPFUNC_SCOPE void
isc__appctx_destroy(isc_appctx_t ** ctxp)902 isc__appctx_destroy(isc_appctx_t **ctxp) {
903 isc__appctx_t *ctx;
904
905 REQUIRE(ctxp != NULL);
906 ctx = (isc__appctx_t *)*ctxp;
907 REQUIRE(VALID_APPCTX(ctx));
908
909 isc_mem_putanddetach(&ctx->mctx, ctx, sizeof(*ctx));
910
911 *ctxp = NULL;
912 }
913
914 ISC_APPFUNC_SCOPE void
isc__appctx_settaskmgr(isc_appctx_t * ctx0,isc_taskmgr_t * taskmgr)915 isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
916 isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
917
918 REQUIRE(VALID_APPCTX(ctx));
919
920 ctx->taskmgr = taskmgr;
921 }
922
923 ISC_APPFUNC_SCOPE void
isc__appctx_setsocketmgr(isc_appctx_t * ctx0,isc_socketmgr_t * socketmgr)924 isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
925 isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
926
927 REQUIRE(VALID_APPCTX(ctx));
928
929 ctx->socketmgr = socketmgr;
930 }
931
932 ISC_APPFUNC_SCOPE void
isc__appctx_settimermgr(isc_appctx_t * ctx0,isc_timermgr_t * timermgr)933 isc__appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
934 isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
935
936 REQUIRE(VALID_APPCTX(ctx));
937
938 ctx->timermgr = timermgr;
939 }
940
941 #ifdef USE_APPIMPREGISTER
942 isc_result_t
isc__app_register()943 isc__app_register() {
944 return (isc_app_register(isc__appctx_create));
945 }
946 #endif
947