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