contrib/bind/lib/isc/unix/app.c

   1 /*
   2  * Copyright (C) 2004, 2005, 2007, 2008  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.54.128.6 2008/10/15 03:41:17 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/msgs.h>
  41 #include <isc/mutex.h>
  42 #include <isc/event.h>
  43 #include <isc/platform.h>
  44 #include <isc/strerror.h>
  45 #include <isc/string.h>
  46 #include <isc/task.h>
  47 #include <isc/time.h>
  48 #include <isc/util.h>
  49
  50 #ifdef ISC_PLATFORM_USETHREADS
  51 #include <pthread.h>
  52 #else /* ISC_PLATFORM_USETHREADS */
  53 #include "../timer_p.h"
  54 #include "../task_p.h"
  55 #include "socket_p.h"
  56 #endif /* ISC_PLATFORM_USETHREADS */
  57
  58 static isc_eventlist_t          on_run;
  59 static isc_mutex_t              lock;
  60 static isc_boolean_t            shutdown_requested = ISC_FALSE;
  61 static isc_boolean_t            running = ISC_FALSE;
  62 /*!
  63  * We assume that 'want_shutdown' can be read and written atomically.
  64  */
  65 static volatile isc_boolean_t   want_shutdown = ISC_FALSE;
  66 /*
  67  * We assume that 'want_reload' can be read and written atomically.
  68  */
  69 static volatile isc_boolean_t   want_reload = ISC_FALSE;
  70
  71 static isc_boolean_t            blocked  = ISC_FALSE;
  72 #ifdef ISC_PLATFORM_USETHREADS
  73 static pthread_t                blockedthread;
  74 #endif /* ISC_PLATFORM_USETHREADS */
  75
  76 #ifdef HAVE_LINUXTHREADS
  77 /*!
  78  * Linux has sigwait(), but it appears to prevent signal handlers from
  79  * running, even if they're not in the set being waited for.  This makes
  80  * it impossible to get the default actions for SIGILL, SIGSEGV, etc.
  81  * Instead of messing with it, we just use sigsuspend() instead.
  82  */
  83 #undef HAVE_SIGWAIT
  84 /*!
  85  * We need to remember which thread is the main thread...
  86  */
  87 static pthread_t                main_thread;
  88 #endif
  89
  90 #ifndef HAVE_SIGWAIT
  91 static void
  92 exit_action(int arg) {
  93         UNUSED(arg);
  94         want_shutdown = ISC_TRUE;
  95 }
  96
  97 static void
  98 reload_action(int arg) {
  99         UNUSED(arg);
 100         want_reload = ISC_TRUE;
 101 }
 102 #endif
 103
 104 static isc_result_t
 105 handle_signal(int sig, void (*handler)(int)) {
 106         struct sigaction sa;
 107         char strbuf[ISC_STRERRORSIZE];
 108
 109         memset(&sa, 0, sizeof(sa));
 110         sa.sa_handler = handler;
 111
 112         if (sigfillset(&sa.sa_mask) != 0 ||
 113             sigaction(sig, &sa, NULL) < 0) {
 114                 isc__strerror(errno, strbuf, sizeof(strbuf));
 115                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 116                                  isc_msgcat_get(isc_msgcat, ISC_MSGSET_APP,
 117                                                ISC_MSG_SIGNALSETUP,
 118                                                "handle_signal() %d setup: %s"),
 119                                  sig, strbuf);
 120                 return (ISC_R_UNEXPECTED);
 121         }
 122
 123         return (ISC_R_SUCCESS);
 124 }
 125
 126 isc_result_t
 127 isc_app_start(void) {
 128         isc_result_t result;
 129         int presult;
 130         sigset_t sset;
 131         char strbuf[ISC_STRERRORSIZE];
 132
 133         /*
 134          * Start an ISC library application.
 135          */
 136
 137 #ifdef NEED_PTHREAD_INIT
 138         /*
 139          * BSDI 3.1 seg faults in pthread_sigmask() if we don't do this.
 140          */
 141         presult = pthread_init();
 142         if (presult != 0) {
 143                 isc__strerror(presult, strbuf, sizeof(strbuf));
 144                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 145                                  "isc_app_start() pthread_init: %s", strbuf);
 146                 return (ISC_R_UNEXPECTED);
 147         }
 148 #endif
 149
 150 #ifdef HAVE_LINUXTHREADS
 151         main_thread = pthread_self();
 152 #endif
 153
 154         result = isc_mutex_init(&lock);
 155         if (result != ISC_R_SUCCESS)
 156                 return (result);
 157
 158 #ifndef HAVE_SIGWAIT
 159         /*
 160          * Install do-nothing handlers for SIGINT and SIGTERM.
 161          *
 162          * We install them now because BSDI 3.1 won't block
 163          * the default actions, regardless of what we do with
 164          * pthread_sigmask().
 165          */
 166         result = handle_signal(SIGINT, exit_action);
 167         if (result != ISC_R_SUCCESS)
 168                 return (result);
 169         result = handle_signal(SIGTERM, exit_action);
 170         if (result != ISC_R_SUCCESS)
 171                 return (result);
 172 #endif
 173
 174         /*
 175          * Always ignore SIGPIPE.
 176          */
 177         result = handle_signal(SIGPIPE, SIG_IGN);
 178         if (result != ISC_R_SUCCESS)
 179                 return (result);
 180
 181         /*
 182          * On Solaris 2, delivery of a signal whose action is SIG_IGN
 183          * will not cause sigwait() to return. We may have inherited
 184          * unexpected actions for SIGHUP, SIGINT, and SIGTERM from our parent
 185          * process (e.g, Solaris cron).  Set an action of SIG_DFL to make
 186          * sure sigwait() works as expected.  Only do this for SIGTERM and
 187          * SIGINT if we don't have sigwait(), since a different handler is
 188          * installed above.
 189          */
 190         result = handle_signal(SIGHUP, SIG_DFL);
 191         if (result != ISC_R_SUCCESS)
 192                 return (result);
 193
 194 #ifdef HAVE_SIGWAIT
 195         result = handle_signal(SIGTERM, SIG_DFL);
 196         if (result != ISC_R_SUCCESS)
 197                 return (result);
 198         result = handle_signal(SIGINT, SIG_DFL);
 199         if (result != ISC_R_SUCCESS)
 200                 return (result);
 201 #endif
 202
 203 #ifdef ISC_PLATFORM_USETHREADS
 204         /*
 205          * Block SIGHUP, SIGINT, SIGTERM.
 206          *
 207          * If isc_app_start() is called from the main thread before any other
 208          * threads have been created, then the pthread_sigmask() call below
 209          * will result in all threads having SIGHUP, SIGINT and SIGTERM
 210          * blocked by default, ensuring that only the thread that calls
 211          * sigwait() for them will get those signals.
 212          */
 213         if (sigemptyset(&sset) != 0 ||
 214             sigaddset(&sset, SIGHUP) != 0 ||
 215             sigaddset(&sset, SIGINT) != 0 ||
 216             sigaddset(&sset, SIGTERM) != 0) {
 217                 isc__strerror(errno, strbuf, sizeof(strbuf));
 218                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 219                                  "isc_app_start() sigsetops: %s", strbuf);
 220                 return (ISC_R_UNEXPECTED);
 221         }
 222         presult = pthread_sigmask(SIG_BLOCK, &sset, NULL);
 223         if (presult != 0) {
 224                 isc__strerror(presult, strbuf, sizeof(strbuf));
 225                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 226                                  "isc_app_start() pthread_sigmask: %s",
 227                                  strbuf);
 228                 return (ISC_R_UNEXPECTED);
 229         }
 230 #else /* ISC_PLATFORM_USETHREADS */
 231         /*
 232          * Unblock SIGHUP, SIGINT, SIGTERM.
 233          *
 234          * If we're not using threads, we need to make sure that SIGHUP,
 235          * SIGINT and SIGTERM are not inherited as blocked from the parent
 236          * process.
 237          */
 238         if (sigemptyset(&sset) != 0 ||
 239             sigaddset(&sset, SIGHUP) != 0 ||
 240             sigaddset(&sset, SIGINT) != 0 ||
 241             sigaddset(&sset, SIGTERM) != 0) {
 242                 isc__strerror(errno, strbuf, sizeof(strbuf));
 243                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 244                                  "isc_app_start() sigsetops: %s", strbuf);
 245                 return (ISC_R_UNEXPECTED);
 246         }
 247         presult = sigprocmask(SIG_UNBLOCK, &sset, NULL);
 248         if (presult != 0) {
 249                 isc__strerror(presult, strbuf, sizeof(strbuf));
 250                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 251                                  "isc_app_start() sigprocmask: %s", strbuf);
 252                 return (ISC_R_UNEXPECTED);
 253         }
 254 #endif /* ISC_PLATFORM_USETHREADS */
 255
 256         ISC_LIST_INIT(on_run);
 257
 258         return (ISC_R_SUCCESS);
 259 }
 260
 261 isc_result_t
 262 isc_app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
 263               void *arg)
 264 {
 265         isc_event_t *event;
 266         isc_task_t *cloned_task = NULL;
 267         isc_result_t result;
 268
 269         LOCK(&lock);
 270
 271         if (running) {
 272                 result = ISC_R_ALREADYRUNNING;
 273                 goto unlock;
 274         }
 275
 276         /*
 277          * Note that we store the task to which we're going to send the event
 278          * in the event's "sender" field.
 279          */
 280         isc_task_attach(task, &cloned_task);
 281         event = isc_event_allocate(mctx, cloned_task, ISC_APPEVENT_SHUTDOWN,
 282                                    action, arg, sizeof(*event));
 283         if (event == NULL) {
 284                 result = ISC_R_NOMEMORY;
 285                 goto unlock;
 286         }
 287
 288         ISC_LIST_APPEND(on_run, event, ev_link);
 289
 290         result = ISC_R_SUCCESS;
 291
 292  unlock:
 293         UNLOCK(&lock);
 294
 295         return (result);
 296 }
 297
 298 #ifndef ISC_PLATFORM_USETHREADS
 299 /*!
 300  * Event loop for nonthreaded programs.
 301  */
 302 static isc_result_t
 303 evloop(void) {
 304         isc_result_t result;
 305         while (!want_shutdown) {
 306                 int n;
 307                 isc_time_t when, now;
 308                 struct timeval tv, *tvp;
 309                 isc_socketwait_t *swait;
 310                 isc_boolean_t readytasks;
 311                 isc_boolean_t call_timer_dispatch = ISC_FALSE;
 312
 313                 readytasks = isc__taskmgr_ready();
 314                 if (readytasks) {
 315                         tv.tv_sec = 0;
 316                         tv.tv_usec = 0;
 317                         tvp = &tv;
 318                         call_timer_dispatch = ISC_TRUE;
 319                 } else {
 320                         result = isc__timermgr_nextevent(&when);
 321                         if (result != ISC_R_SUCCESS)
 322                                 tvp = NULL;
 323                         else {
 324                                 isc_uint64_t us;
 325
 326                                 TIME_NOW(&now);
 327                                 us = isc_time_microdiff(&when, &now);
 328                                 if (us == 0)
 329                                         call_timer_dispatch = ISC_TRUE;
 330                                 tv.tv_sec = us / 1000000;
 331                                 tv.tv_usec = us % 1000000;
 332                                 tvp = &tv;
 333                         }
 334                 }
 335
 336                 swait = NULL;
 337                 n = isc__socketmgr_waitevents(tvp, &swait);
 338
 339                 if (n == 0 || call_timer_dispatch) {
 340                         /*
 341                          * We call isc__timermgr_dispatch() only when
 342                          * necessary, in order to reduce overhead.  If the
 343                          * select() call indicates a timeout, we need the
 344                          * dispatch.  Even if not, if we set the 0-timeout
 345                          * for the select() call, we need to check the timer
 346                          * events.  In the 'readytasks' case, there may be no
 347                          * timeout event actually, but there is no other way
 348                          * to reduce the overhead.
 349                          * Note that we do not have to worry about the case
 350                          * where a new timer is inserted during the select()
 351                          * call, since this loop only runs in the non-thread
 352                          * mode.
 353                          */
 354                         isc__timermgr_dispatch();
 355                 }
 356                 if (n > 0)
 357                         (void)isc__socketmgr_dispatch(swait);
 358                 (void)isc__taskmgr_dispatch();
 359
 360                 if (want_reload) {
 361                         want_reload = ISC_FALSE;
 362                         return (ISC_R_RELOAD);
 363                 }
 364         }
 365         return (ISC_R_SUCCESS);
 366 }
 367
 368 /*
 369  * This is a gross hack to support waiting for condition
 370  * variables in nonthreaded programs in a limited way;
 371  * see lib/isc/nothreads/include/isc/condition.h.
 372  * We implement isc_condition_wait() by entering the
 373  * event loop recursively until the want_shutdown flag
 374  * is set by isc_condition_signal().
 375  */
 376
 377 /*!
 378  * \brief True if we are currently executing in the recursive
 379  * event loop.
 380  */
 381 static isc_boolean_t in_recursive_evloop = ISC_FALSE;
 382
 383 /*!
 384  * \brief True if we are exiting the event loop as the result of
 385  * a call to isc_condition_signal() rather than a shutdown
 386  * or reload.
 387  */
 388 static isc_boolean_t signalled = ISC_FALSE;
 389
 390 isc_result_t
 391 isc__nothread_wait_hack(isc_condition_t *cp, isc_mutex_t *mp) {
 392         isc_result_t result;
 393
 394         UNUSED(cp);
 395         UNUSED(mp);
 396
 397         INSIST(!in_recursive_evloop);
 398         in_recursive_evloop = ISC_TRUE;
 399
 400         INSIST(*mp == 1); /* Mutex must be locked on entry. */
 401         --*mp;
 402
 403         result = evloop();
 404         if (result == ISC_R_RELOAD)
 405                 want_reload = ISC_TRUE;
 406         if (signalled) {
 407                 want_shutdown = ISC_FALSE;
 408                 signalled = ISC_FALSE;
 409         }
 410
 411         ++*mp;
 412         in_recursive_evloop = ISC_FALSE;
 413         return (ISC_R_SUCCESS);
 414 }
 415
 416 isc_result_t
 417 isc__nothread_signal_hack(isc_condition_t *cp) {
 418
 419         UNUSED(cp);
 420
 421         INSIST(in_recursive_evloop);
 422
 423         want_shutdown = ISC_TRUE;
 424         signalled = ISC_TRUE;
 425         return (ISC_R_SUCCESS);
 426 }
 427
 428 #endif /* ISC_PLATFORM_USETHREADS */
 429
 430 isc_result_t
 431 isc_app_run(void) {
 432         int result;
 433         isc_event_t *event, *next_event;
 434         isc_task_t *task;
 435 #ifdef ISC_PLATFORM_USETHREADS
 436         sigset_t sset;
 437         char strbuf[ISC_STRERRORSIZE];
 438 #ifdef HAVE_SIGWAIT
 439         int sig;
 440 #endif
 441 #endif /* ISC_PLATFORM_USETHREADS */
 442
 443 #ifdef HAVE_LINUXTHREADS
 444         REQUIRE(main_thread == pthread_self());
 445 #endif
 446
 447         LOCK(&lock);
 448
 449         if (!running) {
 450                 running = ISC_TRUE;
 451
 452                 /*
 453                  * Post any on-run events (in FIFO order).
 454                  */
 455                 for (event = ISC_LIST_HEAD(on_run);
 456                      event != NULL;
 457                      event = next_event) {
 458                         next_event = ISC_LIST_NEXT(event, ev_link);
 459                         ISC_LIST_UNLINK(on_run, event, ev_link);
 460                         task = event->ev_sender;
 461                         event->ev_sender = NULL;
 462                         isc_task_sendanddetach(&task, &event);
 463                 }
 464
 465         }
 466
 467         UNLOCK(&lock);
 468
 469 #ifndef HAVE_SIGWAIT
 470         /*
 471          * Catch SIGHUP.
 472          *
 473          * We do this here to ensure that the signal handler is installed
 474          * (i.e. that it wasn't a "one-shot" handler).
 475          */
 476         result = handle_signal(SIGHUP, reload_action);
 477         if (result != ISC_R_SUCCESS)
 478                 return (ISC_R_SUCCESS);
 479 #endif
 480
 481 #ifdef ISC_PLATFORM_USETHREADS
 482         /*
 483          * There is no danger if isc_app_shutdown() is called before we wait
 484          * for signals.  Signals are blocked, so any such signal will simply
 485          * be made pending and we will get it when we call sigwait().
 486          */
 487
 488         while (!want_shutdown) {
 489 #ifdef HAVE_SIGWAIT
 490                 /*
 491                  * Wait for SIGHUP, SIGINT, or SIGTERM.
 492                  */
 493                 if (sigemptyset(&sset) != 0 ||
 494                     sigaddset(&sset, SIGHUP) != 0 ||
 495                     sigaddset(&sset, SIGINT) != 0 ||
 496                     sigaddset(&sset, SIGTERM) != 0) {
 497                         isc__strerror(errno, strbuf, sizeof(strbuf));
 498                         UNEXPECTED_ERROR(__FILE__, __LINE__,
 499                                          "isc_app_run() sigsetops: %s", strbuf);
 500                         return (ISC_R_UNEXPECTED);
 501                 }
 502
 503 #ifndef HAVE_UNIXWARE_SIGWAIT
 504                 result = sigwait(&sset, &sig);
 505                 if (result == 0) {
 506                         if (sig == SIGINT ||
 507                             sig == SIGTERM)
 508                                 want_shutdown = ISC_TRUE;
 509                         else if (sig == SIGHUP)
 510                                 want_reload = ISC_TRUE;
 511                 }
 512
 513 #else /* Using UnixWare sigwait semantics. */
 514                 sig = sigwait(&sset);
 515                 if (sig >= 0) {
 516                         if (sig == SIGINT ||
 517                             sig == SIGTERM)
 518                                 want_shutdown = ISC_TRUE;
 519                         else if (sig == SIGHUP)
 520                                 want_reload = ISC_TRUE;
 521                 }
 522
 523 #endif /* HAVE_UNIXWARE_SIGWAIT */
 524 #else  /* Don't have sigwait(). */
 525                 /*
 526                  * Listen for all signals.
 527                  */
 528                 if (sigemptyset(&sset) != 0) {
 529                         isc__strerror(errno, strbuf, sizeof(strbuf));
 530                         UNEXPECTED_ERROR(__FILE__, __LINE__,
 531                                          "isc_app_run() sigsetops: %s", strbuf);
 532                         return (ISC_R_UNEXPECTED);
 533                 }
 534                 result = sigsuspend(&sset);
 535 #endif /* HAVE_SIGWAIT */
 536
 537                 if (want_reload) {
 538                         want_reload = ISC_FALSE;
 539                         return (ISC_R_RELOAD);
 540                 }
 541
 542                 if (want_shutdown && blocked)
 543                         exit(1);
 544         }
 545
 546 #else /* ISC_PLATFORM_USETHREADS */
 547
 548         (void)isc__taskmgr_dispatch();
 549
 550         result = evloop();
 551         if (result != ISC_R_SUCCESS)
 552                 return (result);
 553
 554 #endif /* ISC_PLATFORM_USETHREADS */
 555
 556         return (ISC_R_SUCCESS);
 557 }
 558
 559 isc_result_t
 560 isc_app_shutdown(void) {
 561         isc_boolean_t want_kill = ISC_TRUE;
 562         char strbuf[ISC_STRERRORSIZE];
 563
 564         LOCK(&lock);
 565
 566         REQUIRE(running);
 567
 568         if (shutdown_requested)
 569                 want_kill = ISC_FALSE;
 570         else
 571                 shutdown_requested = ISC_TRUE;
 572
 573         UNLOCK(&lock);
 574
 575         if (want_kill) {
 576 #ifdef HAVE_LINUXTHREADS
 577                 int result;
 578
 579                 result = pthread_kill(main_thread, SIGTERM);
 580                 if (result != 0) {
 581                         isc__strerror(result, strbuf, sizeof(strbuf));
 582                         UNEXPECTED_ERROR(__FILE__, __LINE__,
 583                                          "isc_app_shutdown() pthread_kill: %s",
 584                                          strbuf);
 585                         return (ISC_R_UNEXPECTED);
 586                 }
 587 #else
 588                 if (kill(getpid(), SIGTERM) < 0) {
 589                         isc__strerror(errno, strbuf, sizeof(strbuf));
 590                         UNEXPECTED_ERROR(__FILE__, __LINE__,
 591                                          "isc_app_shutdown() kill: %s", strbuf);
 592                         return (ISC_R_UNEXPECTED);
 593                 }
 594 #endif
 595         }
 596
 597         return (ISC_R_SUCCESS);
 598 }
 599
 600 isc_result_t
 601 isc_app_reload(void) {
 602         isc_boolean_t want_kill = ISC_TRUE;
 603         char strbuf[ISC_STRERRORSIZE];
 604
 605         LOCK(&lock);
 606
 607         REQUIRE(running);
 608
 609         /*
 610          * Don't send the reload signal if we're shutting down.
 611          */
 612         if (shutdown_requested)
 613                 want_kill = ISC_FALSE;
 614
 615         UNLOCK(&lock);
 616
 617         if (want_kill) {
 618 #ifdef HAVE_LINUXTHREADS
 619                 int result;
 620
 621                 result = pthread_kill(main_thread, SIGHUP);
 622                 if (result != 0) {
 623                         isc__strerror(result, strbuf, sizeof(strbuf));
 624                         UNEXPECTED_ERROR(__FILE__, __LINE__,
 625                                          "isc_app_reload() pthread_kill: %s",
 626                                          strbuf);
 627                         return (ISC_R_UNEXPECTED);
 628                 }
 629 #else
 630                 if (kill(getpid(), SIGHUP) < 0) {
 631                         isc__strerror(errno, strbuf, sizeof(strbuf));
 632                         UNEXPECTED_ERROR(__FILE__, __LINE__,
 633                                          "isc_app_reload() kill: %s", strbuf);
 634                         return (ISC_R_UNEXPECTED);
 635                 }
 636 #endif
 637         }
 638
 639         return (ISC_R_SUCCESS);
 640 }
 641
 642 void
 643 isc_app_finish(void) {
 644         DESTROYLOCK(&lock);
 645 }
 646
 647 void
 648 isc_app_block(void) {
 649 #ifdef ISC_PLATFORM_USETHREADS
 650         sigset_t sset;
 651 #endif /* ISC_PLATFORM_USETHREADS */
 652         REQUIRE(running);
 653         REQUIRE(!blocked);
 654
 655         blocked = ISC_TRUE;
 656 #ifdef ISC_PLATFORM_USETHREADS
 657         blockedthread = pthread_self();
 658         RUNTIME_CHECK(sigemptyset(&sset) == 0 &&
 659                       sigaddset(&sset, SIGINT) == 0 &&
 660                       sigaddset(&sset, SIGTERM) == 0);
 661         RUNTIME_CHECK(pthread_sigmask(SIG_UNBLOCK, &sset, NULL) == 0);
 662 #endif /* ISC_PLATFORM_USETHREADS */
 663 }
 664
 665 void
 666 isc_app_unblock(void) {
 667 #ifdef ISC_PLATFORM_USETHREADS
 668         sigset_t sset;
 669 #endif /* ISC_PLATFORM_USETHREADS */
 670
 671         REQUIRE(running);
 672         REQUIRE(blocked);
 673
 674         blocked = ISC_FALSE;
 675
 676 #ifdef ISC_PLATFORM_USETHREADS
 677         REQUIRE(blockedthread == pthread_self());
 678
 679         RUNTIME_CHECK(sigemptyset(&sset) == 0 &&
 680                       sigaddset(&sset, SIGINT) == 0 &&
 681                       sigaddset(&sset, SIGTERM) == 0);
 682         RUNTIME_CHECK(pthread_sigmask(SIG_BLOCK, &sset, NULL) == 0);
 683 #endif /* ISC_PLATFORM_USETHREADS */
 684 }