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
evConsTime(time_t sec,long nsec)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
evAddTime(struct timespec addend1,struct timespec addend2)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
evSubTime(struct timespec minuend,struct timespec subtrahend)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
evCmpTime(struct timespec a,struct timespec b)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
evNowTime(void)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
evUTCTime(void)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
evLastEventTime(evContext opaqueCtx)147 evLastEventTime(evContext opaqueCtx) {
148 evContext_p *ctx = opaqueCtx.opaque;
149
150 return (ctx->lastEventTime);
151 }
152 #endif
153
154 struct timespec
evTimeSpec(struct timeval tv)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
evTimeVal(struct timespec ts)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
evSetTimer(evContext opaqueCtx,evTimerFunc func,void * uap,struct timespec due,struct timespec inter,evTimerID * opaqueID)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
evClearTimer(evContext opaqueCtx,evTimerID id)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
evConfigTimer(evContext opaqueCtx,evTimerID id,const char * param,int value)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
evResetTimer(evContext opaqueCtx,evTimerID id,evTimerFunc func,void * uap,struct timespec due,struct timespec inter)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
evSetIdleTimer(evContext opaqueCtx,evTimerFunc func,void * uap,struct timespec max_idle,evTimerID * opaqueID)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
evClearIdleTimer(evContext opaqueCtx,evTimerID id)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
evResetIdleTimer(evContext opaqueCtx,evTimerID opaqueID,evTimerFunc func,void * uap,struct timespec max_idle)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
evTouchIdleTimer(evContext opaqueCtx,evTimerID id)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
evCreateTimers(const evContext_p * ctx)424 evCreateTimers(const evContext_p *ctx) {
425
426 UNUSED(ctx);
427
428 return (heap_new(due_sooner, set_index, 2048));
429 }
430
431 void
evDestroyTimers(const evContext_p * ctx)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
due_sooner(void * a,void * b)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
set_index(void * what,int index)449 set_index(void *what, int index) {
450 evTimer *timer;
451
452 timer = what;
453 timer->index = index;
454 }
455
456 static void
free_timer(void * what,void * uap)457 free_timer(void *what, void *uap) {
458 evTimer *t = what;
459
460 UNUSED(uap);
461
462 FREE(t);
463 }
464
465 static void
print_timer(void * what,void * uap)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
idle_timeout(evContext opaqueCtx,void * uap,struct timespec due,struct timespec inter)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 */
509