external/bsd/bind/dist/lib/isc/unix/app.c

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