lib/libc/isc/ev_timers.c

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