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