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