external/bsd/libbind/dist/isc/ev_timers.c

   1 /*      $NetBSD$        */
   2
   3 /*
   4  * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
   5  * Copyright (c) 1995-1999 by Internet Software Consortium
   6  *
   7  * Permission to use, copy, modify, and 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
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  17  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 /* ev_timers.c - implement timers for the eventlib
  21  * vix 09sep95 [initial]
  22  */
  23
  24 #if !defined(LINT) && !defined(CODECENTER)
  25 static const char rcsid[] = "Id: ev_timers.c,v 1.6 2005/04/27 04:56:36 sra Exp";
  26 #endif
  27
  28 /* Import. */
  29
  30 #include "port_before.h"
  31 #include "fd_setsize.h"
  32
  33 #include <errno.h>
  34
  35 #include <isc/assertions.h>
  36 #include <isc/eventlib.h>
  37 #include "eventlib_p.h"
  38
  39 #include "port_after.h"
  40
  41 /* Constants. */
  42
  43 #define MILLION 1000000
  44 #define BILLION 1000000000
  45
  46 /* Forward. */
  47
  48 static int due_sooner(void *, void *);
  49 static void set_index(void *, int);
  50 static void free_timer(void *, void *);
  51 static void print_timer(void *, void *);
  52 static void idle_timeout(evContext, void *, struct timespec, struct timespec);
  53
  54 /* Private type. */
  55
  56 typedef struct {
  57         evTimerFunc     func;
  58         void *          uap;
  59         struct timespec lastTouched;
  60         struct timespec max_idle;
  61         evTimer *       timer;
  62 } idle_timer;
  63
  64 /* Public. */
  65
  66 struct timespec
  67 evConsTime(time_t sec, long nsec) {
  68         struct timespec x;
  69
  70         x.tv_sec = sec;
  71         x.tv_nsec = nsec;
  72         return (x);
  73 }
  74
  75 struct timespec
  76 evAddTime(struct timespec addend1, struct timespec addend2) {
  77         struct timespec x;
  78
  79         x.tv_sec = addend1.tv_sec + addend2.tv_sec;
  80         x.tv_nsec = addend1.tv_nsec + addend2.tv_nsec;
  81         if (x.tv_nsec >= BILLION) {
  82                 x.tv_sec++;
  83                 x.tv_nsec -= BILLION;
  84         }
  85         return (x);
  86 }
  87
  88 struct timespec
  89 evSubTime(struct timespec minuend, struct timespec subtrahend) {
  90         struct timespec x;
  91
  92         x.tv_sec = minuend.tv_sec - subtrahend.tv_sec;
  93         if (minuend.tv_nsec >= subtrahend.tv_nsec)
  94                 x.tv_nsec = minuend.tv_nsec - subtrahend.tv_nsec;
  95         else {
  96                 x.tv_nsec = BILLION - subtrahend.tv_nsec + minuend.tv_nsec;
  97                 x.tv_sec--;
  98         }
  99         return (x);
 100 }
 101
 102 int
 103 evCmpTime(struct timespec a, struct timespec b) {
 104         long x = a.tv_sec - b.tv_sec;
 105
 106         if (x == 0L)
 107                 x = a.tv_nsec - b.tv_nsec;
 108         return (x < 0L ? (-1) : x > 0L ? (1) : (0));
 109 }
 110
 111 struct timespec
 112 evNowTime() {
 113         struct timeval now;
 114 #ifdef CLOCK_REALTIME
 115         struct timespec tsnow;
 116         int m = CLOCK_REALTIME;
 117
 118 #ifdef CLOCK_MONOTONIC
 119         if (__evOptMonoTime)
 120                 m = CLOCK_MONOTONIC;
 121 #endif
 122         if (clock_gettime(m, &tsnow) == 0)
 123                 return (tsnow);
 124 #endif
 125         if (gettimeofday(&now, NULL) < 0)
 126                 return (evConsTime(0, 0));
 127         return (evTimeSpec(now));
 128 }
 129
 130 struct timespec
 131 evUTCTime() {
 132         struct timeval now;
 133 #ifdef CLOCK_REALTIME
 134         struct timespec tsnow;
 135         if (clock_gettime(CLOCK_REALTIME, &tsnow) == 0)
 136                 return (tsnow);
 137 #endif
 138         if (gettimeofday(&now, NULL) < 0)
 139                 return (evConsTime(0, 0));
 140         return (evTimeSpec(now));
 141 }
 142
 143 struct timespec
 144 evLastEventTime(evContext opaqueCtx) {
 145         evContext_p *ctx = opaqueCtx.opaque;
 146
 147         return (ctx->lastEventTime);
 148 }
 149
 150 struct timespec
 151 evTimeSpec(struct timeval tv) {
 152         struct timespec ts;
 153
 154         ts.tv_sec = tv.tv_sec;
 155         ts.tv_nsec = tv.tv_usec * 1000;
 156         return (ts);
 157 }
 158
 159 struct timeval
 160 evTimeVal(struct timespec ts) {
 161         struct timeval tv;
 162
 163         tv.tv_sec = ts.tv_sec;
 164         tv.tv_usec = ts.tv_nsec / 1000;
 165         return (tv);
 166 }
 167
 168 int
 169 evSetTimer(evContext opaqueCtx,
 170            evTimerFunc func,
 171            void *uap,
 172            struct timespec due,
 173            struct timespec inter,
 174            evTimerID *opaqueID
 175 ) {
 176         evContext_p *ctx = opaqueCtx.opaque;
 177         evTimer *id;
 178
 179         evPrintf(ctx, 1,
 180 "evSetTimer(ctx %p, func %p, uap %p, due %ld.%09ld, inter %ld.%09ld)\n",
 181                  ctx, func, uap,
 182                  (long)due.tv_sec, due.tv_nsec,
 183                  (long)inter.tv_sec, inter.tv_nsec);
 184
 185 #ifdef __hpux
 186         /*
 187          * tv_sec and tv_nsec are unsigned.
 188          */
 189         if (due.tv_nsec >= BILLION)
 190                 EV_ERR(EINVAL);
 191
 192         if (inter.tv_nsec >= BILLION)
 193                 EV_ERR(EINVAL);
 194 #else
 195         if (due.tv_sec < 0 || due.tv_nsec < 0 || due.tv_nsec >= BILLION)
 196                 EV_ERR(EINVAL);
 197
 198         if (inter.tv_sec < 0 || inter.tv_nsec < 0 || inter.tv_nsec >= BILLION)
 199                 EV_ERR(EINVAL);
 200 #endif
 201
 202         /* due={0,0} is a magic cookie meaning "now." */
 203         if (due.tv_sec == (time_t)0 && due.tv_nsec == 0L)
 204                 due = evNowTime();
 205
 206         /* Allocate and fill. */
 207         OKNEW(id);
 208         id->func = func;
 209         id->uap = uap;
 210         id->due = due;
 211         id->inter = inter;
 212
 213         if (heap_insert(ctx->timers, id) < 0)
 214                 return (-1);
 215
 216         /* Remember the ID if the caller provided us a place for it. */
 217         if (opaqueID)
 218                 opaqueID->opaque = id;
 219
 220         if (ctx->debug > 7) {
 221                 evPrintf(ctx, 7, "timers after evSetTimer:\n");
 222                 (void) heap_for_each(ctx->timers, print_timer, (void *)ctx);
 223         }
 224
 225         return (0);
 226 }
 227
 228 int
 229 evClearTimer(evContext opaqueCtx, evTimerID id) {
 230         evContext_p *ctx = opaqueCtx.opaque;
 231         evTimer *del = id.opaque;
 232
 233         if (ctx->cur != NULL &&
 234             ctx->cur->type == Timer &&
 235             ctx->cur->u.timer.this == del) {
 236                 evPrintf(ctx, 8, "deferring delete of timer (executing)\n");
 237                 /*
 238                  * Setting the interval to zero ensures that evDrop() will
 239                  * clean up the timer.
 240                  */
 241                 del->inter = evConsTime(0, 0);
 242                 return (0);
 243         }
 244
 245         if (heap_element(ctx->timers, del->index) != del)
 246                 EV_ERR(ENOENT);
 247
 248         if (heap_delete(ctx->timers, del->index) < 0)
 249                 return (-1);
 250         FREE(del);
 251
 252         if (ctx->debug > 7) {
 253                 evPrintf(ctx, 7, "timers after evClearTimer:\n");
 254                 (void) heap_for_each(ctx->timers, print_timer, (void *)ctx);
 255         }
 256
 257         return (0);
 258 }
 259
 260 int
 261 evConfigTimer(evContext opaqueCtx,
 262              evTimerID id,
 263              const char *param,
 264              int value
 265 ) {
 266         evContext_p *ctx = opaqueCtx.opaque;
 267         evTimer *timer = id.opaque;
 268         int result=0;
 269
 270         UNUSED(value);
 271
 272         if (heap_element(ctx->timers, timer->index) != timer)
 273                 EV_ERR(ENOENT);
 274
 275         if (strcmp(param, "rate") == 0)
 276                 timer->mode |= EV_TMR_RATE;
 277         else if (strcmp(param, "interval") == 0)
 278                 timer->mode &= ~EV_TMR_RATE;
 279         else
 280                 EV_ERR(EINVAL);
 281
 282         return (result);
 283 }
 284
 285 int
 286 evResetTimer(evContext opaqueCtx,
 287              evTimerID id,
 288              evTimerFunc func,
 289              void *uap,
 290              struct timespec due,
 291              struct timespec inter
 292 ) {
 293         evContext_p *ctx = opaqueCtx.opaque;
 294         evTimer *timer = id.opaque;
 295         struct timespec old_due;
 296         int result=0;
 297
 298         if (heap_element(ctx->timers, timer->index) != timer)
 299                 EV_ERR(ENOENT);
 300
 301 #ifdef __hpux
 302         /*
 303          * tv_sec and tv_nsec are unsigned.
 304          */
 305         if (due.tv_nsec >= BILLION)
 306                 EV_ERR(EINVAL);
 307
 308         if (inter.tv_nsec >= BILLION)
 309                 EV_ERR(EINVAL);
 310 #else
 311         if (due.tv_sec < 0 || due.tv_nsec < 0 || due.tv_nsec >= BILLION)
 312                 EV_ERR(EINVAL);
 313
 314         if (inter.tv_sec < 0 || inter.tv_nsec < 0 || inter.tv_nsec >= BILLION)
 315                 EV_ERR(EINVAL);
 316 #endif
 317
 318         old_due = timer->due;
 319
 320         timer->func = func;
 321         timer->uap = uap;
 322         timer->due = due;
 323         timer->inter = inter;
 324
 325         switch (evCmpTime(due, old_due)) {
 326         case -1:
 327                 result = heap_increased(ctx->timers, timer->index);
 328                 break;
 329         case 0:
 330                 result = 0;
 331                 break;
 332         case 1:
 333                 result = heap_decreased(ctx->timers, timer->index);
 334                 break;
 335         }
 336
 337         if (ctx->debug > 7) {
 338                 evPrintf(ctx, 7, "timers after evResetTimer:\n");
 339                 (void) heap_for_each(ctx->timers, print_timer, (void *)ctx);
 340         }
 341
 342         return (result);
 343 }
 344
 345 int
 346 evSetIdleTimer(evContext opaqueCtx,
 347                 evTimerFunc func,
 348                 void *uap,
 349                 struct timespec max_idle,
 350                 evTimerID *opaqueID
 351 ) {
 352         evContext_p *ctx = opaqueCtx.opaque;
 353         idle_timer *tt;
 354
 355         /* Allocate and fill. */
 356         OKNEW(tt);
 357         tt->func = func;
 358         tt->uap = uap;
 359         tt->lastTouched = ctx->lastEventTime;
 360         tt->max_idle = max_idle;
 361
 362         if (evSetTimer(opaqueCtx, idle_timeout, tt,
 363                        evAddTime(ctx->lastEventTime, max_idle),
 364                        max_idle, opaqueID) < 0) {
 365                 FREE(tt);
 366                 return (-1);
 367         }
 368
 369         tt->timer = opaqueID->opaque;
 370
 371         return (0);
 372 }
 373
 374 int
 375 evClearIdleTimer(evContext opaqueCtx, evTimerID id) {
 376         evTimer *del = id.opaque;
 377         idle_timer *tt = del->uap;
 378
 379         FREE(tt);
 380         return (evClearTimer(opaqueCtx, id));
 381 }
 382
 383 int
 384 evResetIdleTimer(evContext opaqueCtx,
 385                  evTimerID opaqueID,
 386                  evTimerFunc func,
 387                  void *uap,
 388                  struct timespec max_idle
 389 ) {
 390         evContext_p *ctx = opaqueCtx.opaque;
 391         evTimer *timer = opaqueID.opaque;
 392         idle_timer *tt = timer->uap;
 393
 394         tt->func = func;
 395         tt->uap = uap;
 396         tt->lastTouched = ctx->lastEventTime;
 397         tt->max_idle = max_idle;
 398
 399         return (evResetTimer(opaqueCtx, opaqueID, idle_timeout, tt,
 400                              evAddTime(ctx->lastEventTime, max_idle),
 401                              max_idle));
 402 }
 403
 404 int
 405 evTouchIdleTimer(evContext opaqueCtx, evTimerID id) {
 406         evContext_p *ctx = opaqueCtx.opaque;
 407         evTimer *t = id.opaque;
 408         idle_timer *tt = t->uap;
 409
 410         tt->lastTouched = ctx->lastEventTime;
 411
 412         return (0);
 413 }
 414
 415 /* Public to the rest of eventlib. */
 416
 417 heap_context
 418 evCreateTimers(const evContext_p *ctx) {
 419
 420         UNUSED(ctx);
 421
 422         return (heap_new(due_sooner, set_index, 2048));
 423 }
 424
 425 void
 426 evDestroyTimers(const evContext_p *ctx) {
 427         (void) heap_for_each(ctx->timers, free_timer, NULL);
 428         (void) heap_free(ctx->timers);
 429 }
 430
 431 /* Private. */
 432
 433 static int
 434 due_sooner(void *a, void *b) {
 435         evTimer *a_timer, *b_timer;
 436
 437         a_timer = a;
 438         b_timer = b;
 439         return (evCmpTime(a_timer->due, b_timer->due) < 0);
 440 }
 441
 442 static void
 443 set_index(void *what, int index) {
 444         evTimer *timer;
 445
 446         timer = what;
 447         timer->index = index;
 448 }
 449
 450 static void
 451 free_timer(void *what, void *uap) {
 452         evTimer *t = what;
 453
 454         UNUSED(uap);
 455
 456         FREE(t);
 457 }
 458
 459 static void
 460 print_timer(void *what, void *uap) {
 461         evTimer *cur = what;
 462         evContext_p *ctx = uap;
 463
 464         cur = what;
 465         evPrintf(ctx, 7,
 466             "  func %p, uap %p, due %ld.%09ld, inter %ld.%09ld\n",
 467                  cur->func, cur->uap,
 468                  (long)cur->due.tv_sec, cur->due.tv_nsec,
 469                  (long)cur->inter.tv_sec, cur->inter.tv_nsec);
 470 }
 471
 472 static void
 473 idle_timeout(evContext opaqueCtx,
 474              void *uap,
 475              struct timespec due,
 476              struct timespec inter
 477 ) {
 478         evContext_p *ctx = opaqueCtx.opaque;
 479         idle_timer *this = uap;
 480         struct timespec idle;
 481
 482         UNUSED(due);
 483         UNUSED(inter);
 484
 485         idle = evSubTime(ctx->lastEventTime, this->lastTouched);
 486         if (evCmpTime(idle, this->max_idle) >= 0) {
 487                 (this->func)(opaqueCtx, this->uap, this->timer->due,
 488                              this->max_idle);
 489                 /*
 490                  * Setting the interval to zero will cause the timer to
 491                  * be cleaned up in evDrop().
 492                  */
 493                 this->timer->inter = evConsTime(0, 0);
 494                 FREE(this);
 495         } else {
 496                 /* evDrop() will reschedule the timer. */
 497                 this->timer->inter = evSubTime(this->max_idle, idle);
 498         }
 499 }
 500
 501 /*! \file */