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.6 2005/04/27 04:56:36 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
evConsTime(time_t sec,long nsec)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
evAddTime(struct timespec addend1,struct timespec addend2)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
evSubTime(struct timespec minuend,struct timespec subtrahend)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
evCmpTime(struct timespec a,struct timespec b)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
evNowTime()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
evUTCTime()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
evLastEventTime(evContext opaqueCtx)153 evLastEventTime(evContext opaqueCtx) {
154 evContext_p *ctx = opaqueCtx.opaque;
155
156 return (ctx->lastEventTime);
157 }
158 #endif
159
160 struct timespec
evTimeSpec(struct timeval tv)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
evTimeVal(struct timespec ts)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
evSetTimer(evContext opaqueCtx,evTimerFunc func,void * uap,struct timespec due,struct timespec inter,evTimerID * opaqueID)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
evClearTimer(evContext opaqueCtx,evTimerID id)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
evConfigTimer(evContext opaqueCtx,evTimerID id,const char * param,int value)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
evResetTimer(evContext opaqueCtx,evTimerID id,evTimerFunc func,void * uap,struct timespec due,struct timespec inter)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
evSetIdleTimer(evContext opaqueCtx,evTimerFunc func,void * uap,struct timespec max_idle,evTimerID * opaqueID)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
evClearIdleTimer(evContext opaqueCtx,evTimerID id)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
evResetIdleTimer(evContext opaqueCtx,evTimerID opaqueID,evTimerFunc func,void * uap,struct timespec max_idle)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
evTouchIdleTimer(evContext opaqueCtx,evTimerID id)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
evCreateTimers(const evContext_p * ctx)431 evCreateTimers(const evContext_p *ctx) {
432
433 UNUSED(ctx);
434
435 return (heap_new(due_sooner, set_index, 2048));
436 }
437
438 void
evDestroyTimers(const evContext_p * ctx)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
due_sooner(void * a,void * b)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
set_index(void * what,int index)456 set_index(void *what, int index) {
457 evTimer *timer;
458
459 timer = what;
460 timer->index = index;
461 }
462
463 static void
free_timer(void * what,void * uap)464 free_timer(void *what, void *uap) {
465 evTimer *t = what;
466
467 UNUSED(uap);
468
469 FREE(t);
470 }
471
472 static void
print_timer(void * what,void * uap)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
idle_timeout(evContext opaqueCtx,void * uap,struct timespec due,struct timespec inter)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 */
516