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