contrib/bind/lib/isc/timer.c

   1 /*
   2  * Copyright (C) 2004, 2005, 2007-2009  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1998-2002  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: timer.c,v 1.81.32.7 2009/01/23 23:46:44 tbox Exp $ */
  19
  20 /*! \file */
  21
  22 #include <config.h>
  23
  24 #include <isc/condition.h>
  25 #include <isc/heap.h>
  26 #include <isc/log.h>
  27 #include <isc/magic.h>
  28 #include <isc/mem.h>
  29 #include <isc/msgs.h>
  30 #include <isc/platform.h>
  31 #include <isc/task.h>
  32 #include <isc/thread.h>
  33 #include <isc/time.h>
  34 #include <isc/timer.h>
  35 #include <isc/util.h>
  36
  37 #ifndef ISC_PLATFORM_USETHREADS
  38 #include "timer_p.h"
  39 #endif /* ISC_PLATFORM_USETHREADS */
  40
  41 #ifdef ISC_TIMER_TRACE
  42 #define XTRACE(s)                       fprintf(stderr, "%s\n", (s))
  43 #define XTRACEID(s, t)                  fprintf(stderr, "%s %p\n", (s), (t))
  44 #define XTRACETIME(s, d)                fprintf(stderr, "%s %u.%09u\n", (s), \
  45                                                (d).seconds, (d).nanoseconds)
  46 #define XTRACETIME2(s, d, n)            fprintf(stderr, "%s %u.%09u %u.%09u\n", (s), \
  47                                                (d).seconds, (d).nanoseconds, (n).seconds, (n).nanoseconds)
  48 #define XTRACETIMER(s, t, d)            fprintf(stderr, "%s %p %u.%09u\n", (s), (t), \
  49                                                (d).seconds, (d).nanoseconds)
  50 #else
  51 #define XTRACE(s)
  52 #define XTRACEID(s, t)
  53 #define XTRACETIME(s, d)
  54 #define XTRACETIME2(s, d, n)
  55 #define XTRACETIMER(s, t, d)
  56 #endif /* ISC_TIMER_TRACE */
  57
  58 #define TIMER_MAGIC                     ISC_MAGIC('T', 'I', 'M', 'R')
  59 #define VALID_TIMER(t)                  ISC_MAGIC_VALID(t, TIMER_MAGIC)
  60
  61 struct isc_timer {
  62         /*! Not locked. */
  63         unsigned int                    magic;
  64         isc_timermgr_t *                manager;
  65         isc_mutex_t                     lock;
  66         /*! Locked by timer lock. */
  67         unsigned int                    references;
  68         isc_time_t                      idle;
  69         /*! Locked by manager lock. */
  70         isc_timertype_t                 type;
  71         isc_time_t                      expires;
  72         isc_interval_t                  interval;
  73         isc_task_t *                    task;
  74         isc_taskaction_t                action;
  75         void *                          arg;
  76         unsigned int                    index;
  77         isc_time_t                      due;
  78         LINK(isc_timer_t)               link;
  79 };
  80
  81 #define TIMER_MANAGER_MAGIC             ISC_MAGIC('T', 'I', 'M', 'M')
  82 #define VALID_MANAGER(m)                ISC_MAGIC_VALID(m, TIMER_MANAGER_MAGIC)
  83
  84 struct isc_timermgr {
  85         /* Not locked. */
  86         unsigned int                    magic;
  87         isc_mem_t *                     mctx;
  88         isc_mutex_t                     lock;
  89         /* Locked by manager lock. */
  90         isc_boolean_t                   done;
  91         LIST(isc_timer_t)               timers;
  92         unsigned int                    nscheduled;
  93         isc_time_t                      due;
  94 #ifdef ISC_PLATFORM_USETHREADS
  95         isc_condition_t                 wakeup;
  96         isc_thread_t                    thread;
  97 #else /* ISC_PLATFORM_USETHREADS */
  98         unsigned int                    refs;
  99 #endif /* ISC_PLATFORM_USETHREADS */
 100         isc_heap_t *                    heap;
 101 };
 102
 103 #ifndef ISC_PLATFORM_USETHREADS
 104 /*!
 105  * If threads are not in use, there can be only one.
 106  */
 107 static isc_timermgr_t *timermgr = NULL;
 108 #endif /* ISC_PLATFORM_USETHREADS */
 109
 110 static inline isc_result_t
 111 schedule(isc_timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) {
 112         isc_result_t result;
 113         isc_timermgr_t *manager;
 114         isc_time_t due;
 115         int cmp;
 116 #ifdef ISC_PLATFORM_USETHREADS
 117         isc_boolean_t timedwait;
 118 #endif
 119
 120         /*!
 121          * Note: the caller must ensure locking.
 122          */
 123
 124         REQUIRE(timer->type != isc_timertype_inactive);
 125
 126 #ifndef ISC_PLATFORM_USETHREADS
 127         UNUSED(signal_ok);
 128 #endif /* ISC_PLATFORM_USETHREADS */
 129
 130         manager = timer->manager;
 131
 132 #ifdef ISC_PLATFORM_USETHREADS
 133         /*!
 134          * If the manager was timed wait, we may need to signal the
 135          * manager to force a wakeup.
 136          */
 137         timedwait = ISC_TF(manager->nscheduled > 0 &&
 138                            isc_time_seconds(&manager->due) != 0);
 139 #endif
 140
 141         /*
 142          * Compute the new due time.
 143          */
 144         if (timer->type != isc_timertype_once) {
 145                 result = isc_time_add(now, &timer->interval, &due);
 146                 if (result != ISC_R_SUCCESS)
 147                         return (result);
 148                 if (timer->type == isc_timertype_limited &&
 149                     isc_time_compare(&timer->expires, &due) < 0)
 150                         due = timer->expires;
 151         } else {
 152                 if (isc_time_isepoch(&timer->idle))
 153                         due = timer->expires;
 154                 else if (isc_time_isepoch(&timer->expires))
 155                         due = timer->idle;
 156                 else if (isc_time_compare(&timer->idle, &timer->expires) < 0)
 157                         due = timer->idle;
 158                 else
 159                         due = timer->expires;
 160         }
 161
 162         /*
 163          * Schedule the timer.
 164          */
 165
 166         if (timer->index > 0) {
 167                 /*
 168                  * Already scheduled.
 169                  */
 170                 cmp = isc_time_compare(&due, &timer->due);
 171                 timer->due = due;
 172                 switch (cmp) {
 173                 case -1:
 174                         isc_heap_increased(manager->heap, timer->index);
 175                         break;
 176                 case 1:
 177                         isc_heap_decreased(manager->heap, timer->index);
 178                         break;
 179                 case 0:
 180                         /* Nothing to do. */
 181                         break;
 182                 }
 183         } else {
 184                 timer->due = due;
 185                 result = isc_heap_insert(manager->heap, timer);
 186                 if (result != ISC_R_SUCCESS) {
 187                         INSIST(result == ISC_R_NOMEMORY);
 188                         return (ISC_R_NOMEMORY);
 189                 }
 190                 manager->nscheduled++;
 191         }
 192
 193         XTRACETIMER(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
 194                                    ISC_MSG_SCHEDULE, "schedule"), timer, due);
 195
 196         /*
 197          * If this timer is at the head of the queue, we need to ensure
 198          * that we won't miss it if it has a more recent due time than
 199          * the current "next" timer.  We do this either by waking up the
 200          * run thread, or explicitly setting the value in the manager.
 201          */
 202 #ifdef ISC_PLATFORM_USETHREADS
 203
 204         /*
 205          * This is a temporary (probably) hack to fix a bug on tru64 5.1
 206          * and 5.1a.  Sometimes, pthread_cond_timedwait() doesn't actually
 207          * return when the time expires, so here, we check to see if
 208          * we're 15 seconds or more behind, and if we are, we signal
 209          * the dispatcher.  This isn't such a bad idea as a general purpose
 210          * watchdog, so perhaps we should just leave it in here.
 211          */
 212         if (signal_ok && timedwait) {
 213                 isc_interval_t fifteen;
 214                 isc_time_t then;
 215
 216                 isc_interval_set(&fifteen, 15, 0);
 217                 result = isc_time_add(&manager->due, &fifteen, &then);
 218
 219                 if (result == ISC_R_SUCCESS &&
 220                     isc_time_compare(&then, now) < 0) {
 221                         SIGNAL(&manager->wakeup);
 222                         signal_ok = ISC_FALSE;
 223                         isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
 224                                       ISC_LOGMODULE_TIMER, ISC_LOG_WARNING,
 225                                       "*** POKED TIMER ***");
 226                 }
 227         }
 228
 229         if (timer->index == 1 && signal_ok) {
 230                 XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
 231                                       ISC_MSG_SIGNALSCHED,
 232                                       "signal (schedule)"));
 233                 SIGNAL(&manager->wakeup);
 234         }
 235 #else /* ISC_PLATFORM_USETHREADS */
 236         if (timer->index == 1 &&
 237             isc_time_compare(&timer->due, &manager->due) < 0)
 238                 manager->due = timer->due;
 239 #endif /* ISC_PLATFORM_USETHREADS */
 240
 241         return (ISC_R_SUCCESS);
 242 }
 243
 244 static inline void
 245 deschedule(isc_timer_t *timer) {
 246         isc_boolean_t need_wakeup = ISC_FALSE;
 247         isc_timermgr_t *manager;
 248
 249         /*
 250          * The caller must ensure locking.
 251          */
 252
 253         manager = timer->manager;
 254         if (timer->index > 0) {
 255                 if (timer->index == 1)
 256                         need_wakeup = ISC_TRUE;
 257                 isc_heap_delete(manager->heap, timer->index);
 258                 timer->index = 0;
 259                 INSIST(manager->nscheduled > 0);
 260                 manager->nscheduled--;
 261 #ifdef ISC_PLATFORM_USETHREADS
 262                 if (need_wakeup) {
 263                         XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
 264                                               ISC_MSG_SIGNALDESCHED,
 265                                               "signal (deschedule)"));
 266                         SIGNAL(&manager->wakeup);
 267                 }
 268 #endif /* ISC_PLATFORM_USETHREADS */
 269         }
 270 }
 271
 272 static void
 273 destroy(isc_timer_t *timer) {
 274         isc_timermgr_t *manager = timer->manager;
 275
 276         /*
 277          * The caller must ensure it is safe to destroy the timer.
 278          */
 279
 280         LOCK(&manager->lock);
 281
 282         (void)isc_task_purgerange(timer->task,
 283                                   timer,
 284                                   ISC_TIMEREVENT_FIRSTEVENT,
 285                                   ISC_TIMEREVENT_LASTEVENT,
 286                                   NULL);
 287         deschedule(timer);
 288         UNLINK(manager->timers, timer, link);
 289
 290         UNLOCK(&manager->lock);
 291
 292         isc_task_detach(&timer->task);
 293         DESTROYLOCK(&timer->lock);
 294         timer->magic = 0;
 295         isc_mem_put(manager->mctx, timer, sizeof(*timer));
 296 }
 297
 298 isc_result_t
 299 isc_timer_create(isc_timermgr_t *manager, isc_timertype_t type,
 300                  isc_time_t *expires, isc_interval_t *interval,
 301                  isc_task_t *task, isc_taskaction_t action, const void *arg,
 302                  isc_timer_t **timerp)
 303 {
 304         isc_timer_t *timer;
 305         isc_result_t result;
 306         isc_time_t now;
 307
 308         /*
 309          * Create a new 'type' timer managed by 'manager'.  The timers
 310          * parameters are specified by 'expires' and 'interval'.  Events
 311          * will be posted to 'task' and when dispatched 'action' will be
 312          * called with 'arg' as the arg value.  The new timer is returned
 313          * in 'timerp'.
 314          */
 315
 316         REQUIRE(VALID_MANAGER(manager));
 317         REQUIRE(task != NULL);
 318         REQUIRE(action != NULL);
 319         if (expires == NULL)
 320                 expires = isc_time_epoch;
 321         if (interval == NULL)
 322                 interval = isc_interval_zero;
 323         REQUIRE(type == isc_timertype_inactive ||
 324                 !(isc_time_isepoch(expires) && isc_interval_iszero(interval)));
 325         REQUIRE(timerp != NULL && *timerp == NULL);
 326         REQUIRE(type != isc_timertype_limited ||
 327                 !(isc_time_isepoch(expires) || isc_interval_iszero(interval)));
 328
 329         /*
 330          * Get current time.
 331          */
 332         if (type != isc_timertype_inactive) {
 333                 TIME_NOW(&now);
 334         } else {
 335                 /*
 336                  * We don't have to do this, but it keeps the compiler from
 337                  * complaining about "now" possibly being used without being
 338                  * set, even though it will never actually happen.
 339                  */
 340                 isc_time_settoepoch(&now);
 341         }
 342
 343
 344         timer = isc_mem_get(manager->mctx, sizeof(*timer));
 345         if (timer == NULL)
 346                 return (ISC_R_NOMEMORY);
 347
 348         timer->manager = manager;
 349         timer->references = 1;
 350
 351         if (type == isc_timertype_once && !isc_interval_iszero(interval)) {
 352                 result = isc_time_add(&now, interval, &timer->idle);
 353                 if (result != ISC_R_SUCCESS) {
 354                         isc_mem_put(manager->mctx, timer, sizeof(*timer));
 355                         return (result);
 356                 }
 357         } else
 358                 isc_time_settoepoch(&timer->idle);
 359
 360         timer->type = type;
 361         timer->expires = *expires;
 362         timer->interval = *interval;
 363         timer->task = NULL;
 364         isc_task_attach(task, &timer->task);
 365         timer->action = action;
 366         /*
 367          * Removing the const attribute from "arg" is the best of two
 368          * evils here.  If the timer->arg member is made const, then
 369          * it affects a great many recipients of the timer event
 370          * which did not pass in an "arg" that was truly const.
 371          * Changing isc_timer_create() to not have "arg" prototyped as const,
 372          * though, can cause compilers warnings for calls that *do*
 373          * have a truly const arg.  The caller will have to carefully
 374          * keep track of whether arg started as a true const.
 375          */
 376         DE_CONST(arg, timer->arg);
 377         timer->index = 0;
 378         result = isc_mutex_init(&timer->lock);
 379         if (result != ISC_R_SUCCESS) {
 380                 isc_task_detach(&timer->task);
 381                 isc_mem_put(manager->mctx, timer, sizeof(*timer));
 382                 return (result);
 383         }
 384         ISC_LINK_INIT(timer, link);
 385         timer->magic = TIMER_MAGIC;
 386
 387         LOCK(&manager->lock);
 388
 389         /*
 390          * Note we don't have to lock the timer like we normally would because
 391          * there are no external references to it yet.
 392          */
 393
 394         if (type != isc_timertype_inactive)
 395                 result = schedule(timer, &now, ISC_TRUE);
 396         else
 397                 result = ISC_R_SUCCESS;
 398         if (result == ISC_R_SUCCESS)
 399                 APPEND(manager->timers, timer, link);
 400
 401         UNLOCK(&manager->lock);
 402
 403         if (result != ISC_R_SUCCESS) {
 404                 timer->magic = 0;
 405                 DESTROYLOCK(&timer->lock);
 406                 isc_task_detach(&timer->task);
 407                 isc_mem_put(manager->mctx, timer, sizeof(*timer));
 408                 return (result);
 409         }
 410
 411         *timerp = timer;
 412
 413         return (ISC_R_SUCCESS);
 414 }
 415
 416 isc_result_t
 417 isc_timer_reset(isc_timer_t *timer, isc_timertype_t type,
 418                 isc_time_t *expires, isc_interval_t *interval,
 419                 isc_boolean_t purge)
 420 {
 421         isc_time_t now;
 422         isc_timermgr_t *manager;
 423         isc_result_t result;
 424
 425         /*
 426          * Change the timer's type, expires, and interval values to the given
 427          * values.  If 'purge' is ISC_TRUE, any pending events from this timer
 428          * are purged from its task's event queue.
 429          */
 430
 431         REQUIRE(VALID_TIMER(timer));
 432         manager = timer->manager;
 433         REQUIRE(VALID_MANAGER(manager));
 434         if (expires == NULL)
 435                 expires = isc_time_epoch;
 436         if (interval == NULL)
 437                 interval = isc_interval_zero;
 438         REQUIRE(type == isc_timertype_inactive ||
 439                 !(isc_time_isepoch(expires) && isc_interval_iszero(interval)));
 440         REQUIRE(type != isc_timertype_limited ||
 441                 !(isc_time_isepoch(expires) || isc_interval_iszero(interval)));
 442
 443         /*
 444          * Get current time.
 445          */
 446         if (type != isc_timertype_inactive) {
 447                 TIME_NOW(&now);
 448         } else {
 449                 /*
 450                  * We don't have to do this, but it keeps the compiler from
 451                  * complaining about "now" possibly being used without being
 452                  * set, even though it will never actually happen.
 453                  */
 454                 isc_time_settoepoch(&now);
 455         }
 456
 457         manager = timer->manager;
 458
 459         LOCK(&manager->lock);
 460         LOCK(&timer->lock);
 461
 462         if (purge)
 463                 (void)isc_task_purgerange(timer->task,
 464                                           timer,
 465                                           ISC_TIMEREVENT_FIRSTEVENT,
 466                                           ISC_TIMEREVENT_LASTEVENT,
 467                                           NULL);
 468         timer->type = type;
 469         timer->expires = *expires;
 470         timer->interval = *interval;
 471         if (type == isc_timertype_once && !isc_interval_iszero(interval)) {
 472                 result = isc_time_add(&now, interval, &timer->idle);
 473         } else {
 474                 isc_time_settoepoch(&timer->idle);
 475                 result = ISC_R_SUCCESS;
 476         }
 477
 478         if (result == ISC_R_SUCCESS) {
 479                 if (type == isc_timertype_inactive) {
 480                         deschedule(timer);
 481                         result = ISC_R_SUCCESS;
 482                 } else
 483                         result = schedule(timer, &now, ISC_TRUE);
 484         }
 485
 486         UNLOCK(&timer->lock);
 487         UNLOCK(&manager->lock);
 488
 489         return (result);
 490 }
 491
 492 isc_timertype_t
 493 isc_timer_gettype(isc_timer_t *timer) {
 494         isc_timertype_t t;
 495
 496         REQUIRE(VALID_TIMER(timer));
 497
 498         LOCK(&timer->lock);
 499         t = timer->type;
 500         UNLOCK(&timer->lock);
 501
 502         return (t);
 503 }
 504
 505 isc_result_t
 506 isc_timer_touch(isc_timer_t *timer) {
 507         isc_result_t result;
 508         isc_time_t now;
 509
 510         /*
 511          * Set the last-touched time of 'timer' to the current time.
 512          */
 513
 514         REQUIRE(VALID_TIMER(timer));
 515
 516         LOCK(&timer->lock);
 517
 518         /*
 519          * We'd like to
 520          *
 521          *      REQUIRE(timer->type == isc_timertype_once);
 522          *
 523          * but we cannot without locking the manager lock too, which we
 524          * don't want to do.
 525          */
 526
 527         TIME_NOW(&now);
 528         result = isc_time_add(&now, &timer->interval, &timer->idle);
 529
 530         UNLOCK(&timer->lock);
 531
 532         return (result);
 533 }
 534
 535 void
 536 isc_timer_attach(isc_timer_t *timer, isc_timer_t **timerp) {
 537         /*
 538          * Attach *timerp to timer.
 539          */
 540
 541         REQUIRE(VALID_TIMER(timer));
 542         REQUIRE(timerp != NULL && *timerp == NULL);
 543
 544         LOCK(&timer->lock);
 545         timer->references++;
 546         UNLOCK(&timer->lock);
 547
 548         *timerp = timer;
 549 }
 550
 551 void
 552 isc_timer_detach(isc_timer_t **timerp) {
 553         isc_timer_t *timer;
 554         isc_boolean_t free_timer = ISC_FALSE;
 555
 556         /*
 557          * Detach *timerp from its timer.
 558          */
 559
 560         REQUIRE(timerp != NULL);
 561         timer = *timerp;
 562         REQUIRE(VALID_TIMER(timer));
 563
 564         LOCK(&timer->lock);
 565         REQUIRE(timer->references > 0);
 566         timer->references--;
 567         if (timer->references == 0)
 568                 free_timer = ISC_TRUE;
 569         UNLOCK(&timer->lock);
 570
 571         if (free_timer)
 572                 destroy(timer);
 573
 574         *timerp = NULL;
 575 }
 576
 577 static void
 578 dispatch(isc_timermgr_t *manager, isc_time_t *now) {
 579         isc_boolean_t done = ISC_FALSE, post_event, need_schedule;
 580         isc_timerevent_t *event;
 581         isc_eventtype_t type = 0;
 582         isc_timer_t *timer;
 583         isc_result_t result;
 584         isc_boolean_t idle;
 585
 586         /*!
 587          * The caller must be holding the manager lock.
 588          */
 589
 590         while (manager->nscheduled > 0 && !done) {
 591                 timer = isc_heap_element(manager->heap, 1);
 592                 INSIST(timer->type != isc_timertype_inactive);
 593                 if (isc_time_compare(now, &timer->due) >= 0) {
 594                         if (timer->type == isc_timertype_ticker) {
 595                                 type = ISC_TIMEREVENT_TICK;
 596                                 post_event = ISC_TRUE;
 597                                 need_schedule = ISC_TRUE;
 598                         } else if (timer->type == isc_timertype_limited) {
 599                                 int cmp;
 600                                 cmp = isc_time_compare(now, &timer->expires);
 601                                 if (cmp >= 0) {
 602                                         type = ISC_TIMEREVENT_LIFE;
 603                                         post_event = ISC_TRUE;
 604                                         need_schedule = ISC_FALSE;
 605                                 } else {
 606                                         type = ISC_TIMEREVENT_TICK;
 607                                         post_event = ISC_TRUE;
 608                                         need_schedule = ISC_TRUE;
 609                                 }
 610                         } else if (!isc_time_isepoch(&timer->expires) &&
 611                                    isc_time_compare(now,
 612                                                     &timer->expires) >= 0) {
 613                                 type = ISC_TIMEREVENT_LIFE;
 614                                 post_event = ISC_TRUE;
 615                                 need_schedule = ISC_FALSE;
 616                         } else {
 617                                 idle = ISC_FALSE;
 618
 619                                 LOCK(&timer->lock);
 620                                 if (!isc_time_isepoch(&timer->idle) &&
 621                                     isc_time_compare(now,
 622                                                      &timer->idle) >= 0) {
 623                                         idle = ISC_TRUE;
 624                                 }
 625                                 UNLOCK(&timer->lock);
 626                                 if (idle) {
 627                                         type = ISC_TIMEREVENT_IDLE;
 628                                         post_event = ISC_TRUE;
 629                                         need_schedule = ISC_FALSE;
 630                                 } else {
 631                                         /*
 632                                          * Idle timer has been touched;
 633                                          * reschedule.
 634                                          */
 635                                         XTRACEID(isc_msgcat_get(isc_msgcat,
 636                                                                 ISC_MSGSET_TIMER,
 637                                                                 ISC_MSG_IDLERESCHED,
 638                                                                 "idle reschedule"),
 639                                                  timer);
 640                                         post_event = ISC_FALSE;
 641                                         need_schedule = ISC_TRUE;
 642                                 }
 643                         }
 644
 645                         if (post_event) {
 646                                 XTRACEID(isc_msgcat_get(isc_msgcat,
 647                                                         ISC_MSGSET_TIMER,
 648                                                         ISC_MSG_POSTING,
 649                                                         "posting"), timer);
 650                                 /*
 651                                  * XXX We could preallocate this event.
 652                                  */
 653                                 event = (isc_timerevent_t *)isc_event_allocate(manager->mctx,
 654                                                            timer,
 655                                                            type,
 656                                                            timer->action,
 657                                                            timer->arg,
 658                                                            sizeof(*event));
 659
 660                                 if (event != NULL) {
 661                                         event->due = timer->due;
 662                                         isc_task_send(timer->task,
 663                                                       ISC_EVENT_PTR(&event));
 664                                 } else
 665                                         UNEXPECTED_ERROR(__FILE__, __LINE__, "%s",
 666                                                  isc_msgcat_get(isc_msgcat,
 667                                                          ISC_MSGSET_TIMER,
 668                                                          ISC_MSG_EVENTNOTALLOC,
 669                                                          "couldn't "
 670                                                          "allocate event"));
 671                         }
 672
 673                         timer->index = 0;
 674                         isc_heap_delete(manager->heap, 1);
 675                         manager->nscheduled--;
 676
 677                         if (need_schedule) {
 678                                 result = schedule(timer, now, ISC_FALSE);
 679                                 if (result != ISC_R_SUCCESS)
 680                                         UNEXPECTED_ERROR(__FILE__, __LINE__,
 681                                                          "%s: %u",
 682                                                 isc_msgcat_get(isc_msgcat,
 683                                                         ISC_MSGSET_TIMER,
 684                                                         ISC_MSG_SCHEDFAIL,
 685                                                         "couldn't schedule "
 686                                                         "timer"),
 687                                                          result);
 688                         }
 689                 } else {
 690                         manager->due = timer->due;
 691                         done = ISC_TRUE;
 692                 }
 693         }
 694 }
 695
 696 #ifdef ISC_PLATFORM_USETHREADS
 697 static isc_threadresult_t
 698 #ifdef _WIN32                   /* XXXDCL */
 699 WINAPI
 700 #endif
 701 run(void *uap) {
 702         isc_timermgr_t *manager = uap;
 703         isc_time_t now;
 704         isc_result_t result;
 705
 706         LOCK(&manager->lock);
 707         while (!manager->done) {
 708                 TIME_NOW(&now);
 709
 710                 XTRACETIME(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 711                                           ISC_MSG_RUNNING,
 712                                           "running"), now);
 713
 714                 dispatch(manager, &now);
 715
 716                 if (manager->nscheduled > 0) {
 717                         XTRACETIME2(isc_msgcat_get(isc_msgcat,
 718                                                    ISC_MSGSET_GENERAL,
 719                                                    ISC_MSG_WAITUNTIL,
 720                                                    "waituntil"),
 721                                     manager->due, now);
 722                         result = WAITUNTIL(&manager->wakeup, &manager->lock, &manager->due);
 723                         INSIST(result == ISC_R_SUCCESS ||
 724                                result == ISC_R_TIMEDOUT);
 725                 } else {
 726                         XTRACETIME(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 727                                                   ISC_MSG_WAIT, "wait"), now);
 728                         WAIT(&manager->wakeup, &manager->lock);
 729                 }
 730                 XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
 731                                       ISC_MSG_WAKEUP, "wakeup"));
 732         }
 733         UNLOCK(&manager->lock);
 734
 735         return ((isc_threadresult_t)0);
 736 }
 737 #endif /* ISC_PLATFORM_USETHREADS */
 738
 739 static isc_boolean_t
 740 sooner(void *v1, void *v2) {
 741         isc_timer_t *t1, *t2;
 742
 743         t1 = v1;
 744         t2 = v2;
 745         REQUIRE(VALID_TIMER(t1));
 746         REQUIRE(VALID_TIMER(t2));
 747
 748         if (isc_time_compare(&t1->due, &t2->due) < 0)
 749                 return (ISC_TRUE);
 750         return (ISC_FALSE);
 751 }
 752
 753 static void
 754 set_index(void *what, unsigned int index) {
 755         isc_timer_t *timer;
 756
 757         timer = what;
 758         REQUIRE(VALID_TIMER(timer));
 759
 760         timer->index = index;
 761 }
 762
 763 isc_result_t
 764 isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
 765         isc_timermgr_t *manager;
 766         isc_result_t result;
 767
 768         /*
 769          * Create a timer manager.
 770          */
 771
 772         REQUIRE(managerp != NULL && *managerp == NULL);
 773
 774 #ifndef ISC_PLATFORM_USETHREADS
 775         if (timermgr != NULL) {
 776                 timermgr->refs++;
 777                 *managerp = timermgr;
 778                 return (ISC_R_SUCCESS);
 779         }
 780 #endif /* ISC_PLATFORM_USETHREADS */
 781
 782         manager = isc_mem_get(mctx, sizeof(*manager));
 783         if (manager == NULL)
 784                 return (ISC_R_NOMEMORY);
 785
 786         manager->magic = TIMER_MANAGER_MAGIC;
 787         manager->mctx = NULL;
 788         manager->done = ISC_FALSE;
 789         INIT_LIST(manager->timers);
 790         manager->nscheduled = 0;
 791         isc_time_settoepoch(&manager->due);
 792         manager->heap = NULL;
 793         result = isc_heap_create(mctx, sooner, set_index, 0, &manager->heap);
 794         if (result != ISC_R_SUCCESS) {
 795                 INSIST(result == ISC_R_NOMEMORY);
 796                 isc_mem_put(mctx, manager, sizeof(*manager));
 797                 return (ISC_R_NOMEMORY);
 798         }
 799         result = isc_mutex_init(&manager->lock);
 800         if (result != ISC_R_SUCCESS) {
 801                 isc_heap_destroy(&manager->heap);
 802                 isc_mem_put(mctx, manager, sizeof(*manager));
 803                 return (result);
 804         }
 805         isc_mem_attach(mctx, &manager->mctx);
 806 #ifdef ISC_PLATFORM_USETHREADS
 807         if (isc_condition_init(&manager->wakeup) != ISC_R_SUCCESS) {
 808                 isc_mem_detach(&manager->mctx);
 809                 DESTROYLOCK(&manager->lock);
 810                 isc_heap_destroy(&manager->heap);
 811                 isc_mem_put(mctx, manager, sizeof(*manager));
 812                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 813                                  "isc_condition_init() %s",
 814                                  isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 815                                                 ISC_MSG_FAILED, "failed"));
 816                 return (ISC_R_UNEXPECTED);
 817         }
 818         if (isc_thread_create(run, manager, &manager->thread) !=
 819             ISC_R_SUCCESS) {
 820                 isc_mem_detach(&manager->mctx);
 821                 (void)isc_condition_destroy(&manager->wakeup);
 822                 DESTROYLOCK(&manager->lock);
 823                 isc_heap_destroy(&manager->heap);
 824                 isc_mem_put(mctx, manager, sizeof(*manager));
 825                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 826                                  "isc_thread_create() %s",
 827                                  isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 828                                                 ISC_MSG_FAILED, "failed"));
 829                 return (ISC_R_UNEXPECTED);
 830         }
 831 #else /* ISC_PLATFORM_USETHREADS */
 832         manager->refs = 1;
 833         timermgr = manager;
 834 #endif /* ISC_PLATFORM_USETHREADS */
 835
 836         *managerp = manager;
 837
 838         return (ISC_R_SUCCESS);
 839 }
 840
 841 void
 842 isc_timermgr_poke(isc_timermgr_t *manager) {
 843 #ifdef ISC_PLATFORM_USETHREADS
 844         REQUIRE(VALID_MANAGER(manager));
 845
 846         SIGNAL(&manager->wakeup);
 847 #else
 848         UNUSED(manager);
 849 #endif
 850 }
 851
 852 void
 853 isc_timermgr_destroy(isc_timermgr_t **managerp) {
 854         isc_timermgr_t *manager;
 855         isc_mem_t *mctx;
 856
 857         /*
 858          * Destroy a timer manager.
 859          */
 860
 861         REQUIRE(managerp != NULL);
 862         manager = *managerp;
 863         REQUIRE(VALID_MANAGER(manager));
 864
 865         LOCK(&manager->lock);
 866
 867 #ifndef ISC_PLATFORM_USETHREADS
 868         if (manager->refs > 1) {
 869                 manager->refs--;
 870                 UNLOCK(&manager->lock);
 871                 *managerp = NULL;
 872                 return;
 873         }
 874
 875         isc__timermgr_dispatch();
 876 #endif /* ISC_PLATFORM_USETHREADS */
 877
 878         REQUIRE(EMPTY(manager->timers));
 879         manager->done = ISC_TRUE;
 880
 881 #ifdef ISC_PLATFORM_USETHREADS
 882         XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
 883                               ISC_MSG_SIGNALDESTROY, "signal (destroy)"));
 884         SIGNAL(&manager->wakeup);
 885 #endif /* ISC_PLATFORM_USETHREADS */
 886
 887         UNLOCK(&manager->lock);
 888
 889 #ifdef ISC_PLATFORM_USETHREADS
 890         /*
 891          * Wait for thread to exit.
 892          */
 893         if (isc_thread_join(manager->thread, NULL) != ISC_R_SUCCESS)
 894                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 895                                  "isc_thread_join() %s",
 896                                  isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 897                                                 ISC_MSG_FAILED, "failed"));
 898 #endif /* ISC_PLATFORM_USETHREADS */
 899
 900         /*
 901          * Clean up.
 902          */
 903 #ifdef ISC_PLATFORM_USETHREADS
 904         (void)isc_condition_destroy(&manager->wakeup);
 905 #endif /* ISC_PLATFORM_USETHREADS */
 906         DESTROYLOCK(&manager->lock);
 907         isc_heap_destroy(&manager->heap);
 908         manager->magic = 0;
 909         mctx = manager->mctx;
 910         isc_mem_put(mctx, manager, sizeof(*manager));
 911         isc_mem_detach(&mctx);
 912
 913         *managerp = NULL;
 914 }
 915
 916 #ifndef ISC_PLATFORM_USETHREADS
 917 isc_result_t
 918 isc__timermgr_nextevent(isc_time_t *when) {
 919         if (timermgr == NULL || timermgr->nscheduled == 0)
 920                 return (ISC_R_NOTFOUND);
 921         *when = timermgr->due;
 922         return (ISC_R_SUCCESS);
 923 }
 924
 925 void
 926 isc__timermgr_dispatch(void) {
 927         isc_time_t now;
 928         if (timermgr == NULL)
 929                 return;
 930         TIME_NOW(&now);
 931         dispatch(timermgr, &now);
 932 }
 933 #endif /* ISC_PLATFORM_USETHREADS */