xref: /minix3/external/bsd/bind/dist/lib/isc/timer.c (revision 00b67f09dd46474d133c95011a48590a8e8f94c7)
1*00b67f09SDavid van Moolenbroek /*	$NetBSD: timer.c,v 1.10 2014/12/10 04:37:59 christos Exp $	*/
2*00b67f09SDavid van Moolenbroek 
3*00b67f09SDavid van Moolenbroek /*
4*00b67f09SDavid van Moolenbroek  * Copyright (C) 2004, 2005, 2007-2009, 2011-2014  Internet Systems Consortium, Inc. ("ISC")
5*00b67f09SDavid van Moolenbroek  * Copyright (C) 1998-2002  Internet Software Consortium.
6*00b67f09SDavid van Moolenbroek  *
7*00b67f09SDavid van Moolenbroek  * Permission to use, copy, modify, and/or distribute this software for any
8*00b67f09SDavid van Moolenbroek  * purpose with or without fee is hereby granted, provided that the above
9*00b67f09SDavid van Moolenbroek  * copyright notice and this permission notice appear in all copies.
10*00b67f09SDavid van Moolenbroek  *
11*00b67f09SDavid van Moolenbroek  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
12*00b67f09SDavid van Moolenbroek  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
13*00b67f09SDavid van Moolenbroek  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
14*00b67f09SDavid van Moolenbroek  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
15*00b67f09SDavid van Moolenbroek  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
16*00b67f09SDavid van Moolenbroek  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17*00b67f09SDavid van Moolenbroek  * PERFORMANCE OF THIS SOFTWARE.
18*00b67f09SDavid van Moolenbroek  */
19*00b67f09SDavid van Moolenbroek 
20*00b67f09SDavid van Moolenbroek /* Id */
21*00b67f09SDavid van Moolenbroek 
22*00b67f09SDavid van Moolenbroek /*! \file */
23*00b67f09SDavid van Moolenbroek 
24*00b67f09SDavid van Moolenbroek #include <config.h>
25*00b67f09SDavid van Moolenbroek 
26*00b67f09SDavid van Moolenbroek #include <isc/app.h>
27*00b67f09SDavid van Moolenbroek #include <isc/condition.h>
28*00b67f09SDavid van Moolenbroek #include <isc/heap.h>
29*00b67f09SDavid van Moolenbroek #include <isc/log.h>
30*00b67f09SDavid van Moolenbroek #include <isc/magic.h>
31*00b67f09SDavid van Moolenbroek #include <isc/mem.h>
32*00b67f09SDavid van Moolenbroek #include <isc/msgs.h>
33*00b67f09SDavid van Moolenbroek #include <isc/once.h>
34*00b67f09SDavid van Moolenbroek #include <isc/platform.h>
35*00b67f09SDavid van Moolenbroek #include <isc/task.h>
36*00b67f09SDavid van Moolenbroek #include <isc/thread.h>
37*00b67f09SDavid van Moolenbroek #include <isc/time.h>
38*00b67f09SDavid van Moolenbroek #include <isc/timer.h>
39*00b67f09SDavid van Moolenbroek #include <isc/util.h>
40*00b67f09SDavid van Moolenbroek 
41*00b67f09SDavid van Moolenbroek #ifdef OPENSSL_LEAKS
42*00b67f09SDavid van Moolenbroek #include <openssl/err.h>
43*00b67f09SDavid van Moolenbroek #endif
44*00b67f09SDavid van Moolenbroek 
45*00b67f09SDavid van Moolenbroek /* See task.c about the following definition: */
46*00b67f09SDavid van Moolenbroek #ifdef ISC_PLATFORM_USETHREADS
47*00b67f09SDavid van Moolenbroek #define USE_TIMER_THREAD
48*00b67f09SDavid van Moolenbroek #else
49*00b67f09SDavid van Moolenbroek #define USE_SHARED_MANAGER
50*00b67f09SDavid van Moolenbroek #endif	/* ISC_PLATFORM_USETHREADS */
51*00b67f09SDavid van Moolenbroek 
52*00b67f09SDavid van Moolenbroek #ifndef USE_TIMER_THREAD
53*00b67f09SDavid van Moolenbroek #include "timer_p.h"
54*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
55*00b67f09SDavid van Moolenbroek 
56*00b67f09SDavid van Moolenbroek #ifdef ISC_TIMER_TRACE
57*00b67f09SDavid van Moolenbroek #define XTRACE(s)			fprintf(stderr, "%s\n", (s))
58*00b67f09SDavid van Moolenbroek #define XTRACEID(s, t)			fprintf(stderr, "%s %p\n", (s), (t))
59*00b67f09SDavid van Moolenbroek #define XTRACETIME(s, d)		fprintf(stderr, "%s %u.%09u\n", (s), \
60*00b67f09SDavid van Moolenbroek 					       (d).seconds, (d).nanoseconds)
61*00b67f09SDavid van Moolenbroek #define XTRACETIME2(s, d, n)		fprintf(stderr, "%s %u.%09u %u.%09u\n", (s), \
62*00b67f09SDavid van Moolenbroek 					       (d).seconds, (d).nanoseconds, (n).seconds, (n).nanoseconds)
63*00b67f09SDavid van Moolenbroek #define XTRACETIMER(s, t, d)		fprintf(stderr, "%s %p %u.%09u\n", (s), (t), \
64*00b67f09SDavid van Moolenbroek 					       (d).seconds, (d).nanoseconds)
65*00b67f09SDavid van Moolenbroek #else
66*00b67f09SDavid van Moolenbroek #define XTRACE(s)
67*00b67f09SDavid van Moolenbroek #define XTRACEID(s, t)
68*00b67f09SDavid van Moolenbroek #define XTRACETIME(s, d)
69*00b67f09SDavid van Moolenbroek #define XTRACETIME2(s, d, n)
70*00b67f09SDavid van Moolenbroek #define XTRACETIMER(s, t, d)
71*00b67f09SDavid van Moolenbroek #endif /* ISC_TIMER_TRACE */
72*00b67f09SDavid van Moolenbroek 
73*00b67f09SDavid van Moolenbroek #define TIMER_MAGIC			ISC_MAGIC('T', 'I', 'M', 'R')
74*00b67f09SDavid van Moolenbroek #define VALID_TIMER(t)			ISC_MAGIC_VALID(t, TIMER_MAGIC)
75*00b67f09SDavid van Moolenbroek 
76*00b67f09SDavid van Moolenbroek typedef struct isc__timer isc__timer_t;
77*00b67f09SDavid van Moolenbroek typedef struct isc__timermgr isc__timermgr_t;
78*00b67f09SDavid van Moolenbroek 
79*00b67f09SDavid van Moolenbroek struct isc__timer {
80*00b67f09SDavid van Moolenbroek 	/*! Not locked. */
81*00b67f09SDavid van Moolenbroek 	isc_timer_t			common;
82*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *		manager;
83*00b67f09SDavid van Moolenbroek 	isc_mutex_t			lock;
84*00b67f09SDavid van Moolenbroek 	/*! Locked by timer lock. */
85*00b67f09SDavid van Moolenbroek 	unsigned int			references;
86*00b67f09SDavid van Moolenbroek 	isc_time_t			idle;
87*00b67f09SDavid van Moolenbroek 	/*! Locked by manager lock. */
88*00b67f09SDavid van Moolenbroek 	isc_timertype_t			type;
89*00b67f09SDavid van Moolenbroek 	isc_time_t			expires;
90*00b67f09SDavid van Moolenbroek 	isc_interval_t			interval;
91*00b67f09SDavid van Moolenbroek 	isc_task_t *			task;
92*00b67f09SDavid van Moolenbroek 	isc_taskaction_t		action;
93*00b67f09SDavid van Moolenbroek 	void *				arg;
94*00b67f09SDavid van Moolenbroek 	unsigned int			index;
95*00b67f09SDavid van Moolenbroek 	isc_time_t			due;
96*00b67f09SDavid van Moolenbroek 	LINK(isc__timer_t)		link;
97*00b67f09SDavid van Moolenbroek };
98*00b67f09SDavid van Moolenbroek 
99*00b67f09SDavid van Moolenbroek #define TIMER_MANAGER_MAGIC		ISC_MAGIC('T', 'I', 'M', 'M')
100*00b67f09SDavid van Moolenbroek #define VALID_MANAGER(m)		ISC_MAGIC_VALID(m, TIMER_MANAGER_MAGIC)
101*00b67f09SDavid van Moolenbroek 
102*00b67f09SDavid van Moolenbroek struct isc__timermgr {
103*00b67f09SDavid van Moolenbroek 	/* Not locked. */
104*00b67f09SDavid van Moolenbroek 	isc_timermgr_t			common;
105*00b67f09SDavid van Moolenbroek 	isc_mem_t *			mctx;
106*00b67f09SDavid van Moolenbroek 	isc_mutex_t			lock;
107*00b67f09SDavid van Moolenbroek 	/* Locked by manager lock. */
108*00b67f09SDavid van Moolenbroek 	isc_boolean_t			done;
109*00b67f09SDavid van Moolenbroek 	LIST(isc__timer_t)		timers;
110*00b67f09SDavid van Moolenbroek 	unsigned int			nscheduled;
111*00b67f09SDavid van Moolenbroek 	isc_time_t			due;
112*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
113*00b67f09SDavid van Moolenbroek 	isc_condition_t			wakeup;
114*00b67f09SDavid van Moolenbroek 	isc_thread_t			thread;
115*00b67f09SDavid van Moolenbroek #endif	/* USE_TIMER_THREAD */
116*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
117*00b67f09SDavid van Moolenbroek 	unsigned int			refs;
118*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
119*00b67f09SDavid van Moolenbroek 	isc_heap_t *			heap;
120*00b67f09SDavid van Moolenbroek };
121*00b67f09SDavid van Moolenbroek 
122*00b67f09SDavid van Moolenbroek /*%
123*00b67f09SDavid van Moolenbroek  * The following are intended for internal use (indicated by "isc__"
124*00b67f09SDavid van Moolenbroek  * prefix) but are not declared as static, allowing direct access from
125*00b67f09SDavid van Moolenbroek  * unit tests etc.
126*00b67f09SDavid van Moolenbroek  */
127*00b67f09SDavid van Moolenbroek 
128*00b67f09SDavid van Moolenbroek isc_result_t
129*00b67f09SDavid van Moolenbroek isc__timer_create(isc_timermgr_t *manager, isc_timertype_t type,
130*00b67f09SDavid van Moolenbroek 		  const isc_time_t *expires, const isc_interval_t *interval,
131*00b67f09SDavid van Moolenbroek 		  isc_task_t *task, isc_taskaction_t action, void *arg,
132*00b67f09SDavid van Moolenbroek 		  isc_timer_t **timerp);
133*00b67f09SDavid van Moolenbroek isc_result_t
134*00b67f09SDavid van Moolenbroek isc__timer_reset(isc_timer_t *timer, isc_timertype_t type,
135*00b67f09SDavid van Moolenbroek 		 const isc_time_t *expires, const isc_interval_t *interval,
136*00b67f09SDavid van Moolenbroek 		 isc_boolean_t purge);
137*00b67f09SDavid van Moolenbroek isc_timertype_t
138*00b67f09SDavid van Moolenbroek isc_timer_gettype(isc_timer_t *timer);
139*00b67f09SDavid van Moolenbroek isc_result_t
140*00b67f09SDavid van Moolenbroek isc__timer_touch(isc_timer_t *timer);
141*00b67f09SDavid van Moolenbroek void
142*00b67f09SDavid van Moolenbroek isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp);
143*00b67f09SDavid van Moolenbroek void
144*00b67f09SDavid van Moolenbroek isc__timer_detach(isc_timer_t **timerp);
145*00b67f09SDavid van Moolenbroek isc_result_t
146*00b67f09SDavid van Moolenbroek isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp);
147*00b67f09SDavid van Moolenbroek void
148*00b67f09SDavid van Moolenbroek isc_timermgr_poke(isc_timermgr_t *manager0);
149*00b67f09SDavid van Moolenbroek void
150*00b67f09SDavid van Moolenbroek isc__timermgr_destroy(isc_timermgr_t **managerp);
151*00b67f09SDavid van Moolenbroek 
152*00b67f09SDavid van Moolenbroek static struct isc__timermethods {
153*00b67f09SDavid van Moolenbroek 	isc_timermethods_t methods;
154*00b67f09SDavid van Moolenbroek 
155*00b67f09SDavid van Moolenbroek 	/*%
156*00b67f09SDavid van Moolenbroek 	 * The following are defined just for avoiding unused static functions.
157*00b67f09SDavid van Moolenbroek 	 */
158*00b67f09SDavid van Moolenbroek 	void *gettype;
159*00b67f09SDavid van Moolenbroek } timermethods = {
160*00b67f09SDavid van Moolenbroek 	{
161*00b67f09SDavid van Moolenbroek 		isc__timer_attach,
162*00b67f09SDavid van Moolenbroek 		isc__timer_detach,
163*00b67f09SDavid van Moolenbroek 		isc__timer_reset,
164*00b67f09SDavid van Moolenbroek 		isc__timer_touch
165*00b67f09SDavid van Moolenbroek 	},
166*00b67f09SDavid van Moolenbroek 	(void *)isc_timer_gettype
167*00b67f09SDavid van Moolenbroek };
168*00b67f09SDavid van Moolenbroek 
169*00b67f09SDavid van Moolenbroek static struct isc__timermgrmethods {
170*00b67f09SDavid van Moolenbroek 	isc_timermgrmethods_t methods;
171*00b67f09SDavid van Moolenbroek 	void *poke;		/* see above */
172*00b67f09SDavid van Moolenbroek } timermgrmethods = {
173*00b67f09SDavid van Moolenbroek 	{
174*00b67f09SDavid van Moolenbroek 		isc__timermgr_destroy,
175*00b67f09SDavid van Moolenbroek 		isc__timer_create
176*00b67f09SDavid van Moolenbroek 	},
177*00b67f09SDavid van Moolenbroek 	(void *)isc_timermgr_poke
178*00b67f09SDavid van Moolenbroek };
179*00b67f09SDavid van Moolenbroek 
180*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
181*00b67f09SDavid van Moolenbroek /*!
182*00b67f09SDavid van Moolenbroek  * If the manager is supposed to be shared, there can be only one.
183*00b67f09SDavid van Moolenbroek  */
184*00b67f09SDavid van Moolenbroek static isc__timermgr_t *timermgr = NULL;
185*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
186*00b67f09SDavid van Moolenbroek 
187*00b67f09SDavid van Moolenbroek static inline isc_result_t
schedule(isc__timer_t * timer,isc_time_t * now,isc_boolean_t signal_ok)188*00b67f09SDavid van Moolenbroek schedule(isc__timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) {
189*00b67f09SDavid van Moolenbroek 	isc_result_t result;
190*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager;
191*00b67f09SDavid van Moolenbroek 	isc_time_t due;
192*00b67f09SDavid van Moolenbroek 	int cmp;
193*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
194*00b67f09SDavid van Moolenbroek 	isc_boolean_t timedwait;
195*00b67f09SDavid van Moolenbroek #endif
196*00b67f09SDavid van Moolenbroek 
197*00b67f09SDavid van Moolenbroek 	/*!
198*00b67f09SDavid van Moolenbroek 	 * Note: the caller must ensure locking.
199*00b67f09SDavid van Moolenbroek 	 */
200*00b67f09SDavid van Moolenbroek 
201*00b67f09SDavid van Moolenbroek 	REQUIRE(timer->type != isc_timertype_inactive);
202*00b67f09SDavid van Moolenbroek 
203*00b67f09SDavid van Moolenbroek #ifndef USE_TIMER_THREAD
204*00b67f09SDavid van Moolenbroek 	UNUSED(signal_ok);
205*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
206*00b67f09SDavid van Moolenbroek 
207*00b67f09SDavid van Moolenbroek 	manager = timer->manager;
208*00b67f09SDavid van Moolenbroek 
209*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
210*00b67f09SDavid van Moolenbroek 	/*!
211*00b67f09SDavid van Moolenbroek 	 * If the manager was timed wait, we may need to signal the
212*00b67f09SDavid van Moolenbroek 	 * manager to force a wakeup.
213*00b67f09SDavid van Moolenbroek 	 */
214*00b67f09SDavid van Moolenbroek 	timedwait = ISC_TF(manager->nscheduled > 0 &&
215*00b67f09SDavid van Moolenbroek 			   isc_time_seconds(&manager->due) != 0);
216*00b67f09SDavid van Moolenbroek #endif
217*00b67f09SDavid van Moolenbroek 
218*00b67f09SDavid van Moolenbroek 	/*
219*00b67f09SDavid van Moolenbroek 	 * Compute the new due time.
220*00b67f09SDavid van Moolenbroek 	 */
221*00b67f09SDavid van Moolenbroek 	if (timer->type != isc_timertype_once) {
222*00b67f09SDavid van Moolenbroek 		result = isc_time_add(now, &timer->interval, &due);
223*00b67f09SDavid van Moolenbroek 		if (result != ISC_R_SUCCESS)
224*00b67f09SDavid van Moolenbroek 			return (result);
225*00b67f09SDavid van Moolenbroek 		if (timer->type == isc_timertype_limited &&
226*00b67f09SDavid van Moolenbroek 		    isc_time_compare(&timer->expires, &due) < 0)
227*00b67f09SDavid van Moolenbroek 			due = timer->expires;
228*00b67f09SDavid van Moolenbroek 	} else {
229*00b67f09SDavid van Moolenbroek 		if (isc_time_isepoch(&timer->idle))
230*00b67f09SDavid van Moolenbroek 			due = timer->expires;
231*00b67f09SDavid van Moolenbroek 		else if (isc_time_isepoch(&timer->expires))
232*00b67f09SDavid van Moolenbroek 			due = timer->idle;
233*00b67f09SDavid van Moolenbroek 		else if (isc_time_compare(&timer->idle, &timer->expires) < 0)
234*00b67f09SDavid van Moolenbroek 			due = timer->idle;
235*00b67f09SDavid van Moolenbroek 		else
236*00b67f09SDavid van Moolenbroek 			due = timer->expires;
237*00b67f09SDavid van Moolenbroek 	}
238*00b67f09SDavid van Moolenbroek 
239*00b67f09SDavid van Moolenbroek 	/*
240*00b67f09SDavid van Moolenbroek 	 * Schedule the timer.
241*00b67f09SDavid van Moolenbroek 	 */
242*00b67f09SDavid van Moolenbroek 
243*00b67f09SDavid van Moolenbroek 	if (timer->index > 0) {
244*00b67f09SDavid van Moolenbroek 		/*
245*00b67f09SDavid van Moolenbroek 		 * Already scheduled.
246*00b67f09SDavid van Moolenbroek 		 */
247*00b67f09SDavid van Moolenbroek 		cmp = isc_time_compare(&due, &timer->due);
248*00b67f09SDavid van Moolenbroek 		timer->due = due;
249*00b67f09SDavid van Moolenbroek 		switch (cmp) {
250*00b67f09SDavid van Moolenbroek 		case -1:
251*00b67f09SDavid van Moolenbroek 			isc_heap_increased(manager->heap, timer->index);
252*00b67f09SDavid van Moolenbroek 			break;
253*00b67f09SDavid van Moolenbroek 		case 1:
254*00b67f09SDavid van Moolenbroek 			isc_heap_decreased(manager->heap, timer->index);
255*00b67f09SDavid van Moolenbroek 			break;
256*00b67f09SDavid van Moolenbroek 		case 0:
257*00b67f09SDavid van Moolenbroek 			/* Nothing to do. */
258*00b67f09SDavid van Moolenbroek 			break;
259*00b67f09SDavid van Moolenbroek 		}
260*00b67f09SDavid van Moolenbroek 	} else {
261*00b67f09SDavid van Moolenbroek 		timer->due = due;
262*00b67f09SDavid van Moolenbroek 		result = isc_heap_insert(manager->heap, timer);
263*00b67f09SDavid van Moolenbroek 		if (result != ISC_R_SUCCESS) {
264*00b67f09SDavid van Moolenbroek 			INSIST(result == ISC_R_NOMEMORY);
265*00b67f09SDavid van Moolenbroek 			return (ISC_R_NOMEMORY);
266*00b67f09SDavid van Moolenbroek 		}
267*00b67f09SDavid van Moolenbroek 		manager->nscheduled++;
268*00b67f09SDavid van Moolenbroek 	}
269*00b67f09SDavid van Moolenbroek 
270*00b67f09SDavid van Moolenbroek 	XTRACETIMER(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
271*00b67f09SDavid van Moolenbroek 				   ISC_MSG_SCHEDULE, "schedule"), timer, due);
272*00b67f09SDavid van Moolenbroek 
273*00b67f09SDavid van Moolenbroek 	/*
274*00b67f09SDavid van Moolenbroek 	 * If this timer is at the head of the queue, we need to ensure
275*00b67f09SDavid van Moolenbroek 	 * that we won't miss it if it has a more recent due time than
276*00b67f09SDavid van Moolenbroek 	 * the current "next" timer.  We do this either by waking up the
277*00b67f09SDavid van Moolenbroek 	 * run thread, or explicitly setting the value in the manager.
278*00b67f09SDavid van Moolenbroek 	 */
279*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
280*00b67f09SDavid van Moolenbroek 
281*00b67f09SDavid van Moolenbroek 	/*
282*00b67f09SDavid van Moolenbroek 	 * This is a temporary (probably) hack to fix a bug on tru64 5.1
283*00b67f09SDavid van Moolenbroek 	 * and 5.1a.  Sometimes, pthread_cond_timedwait() doesn't actually
284*00b67f09SDavid van Moolenbroek 	 * return when the time expires, so here, we check to see if
285*00b67f09SDavid van Moolenbroek 	 * we're 15 seconds or more behind, and if we are, we signal
286*00b67f09SDavid van Moolenbroek 	 * the dispatcher.  This isn't such a bad idea as a general purpose
287*00b67f09SDavid van Moolenbroek 	 * watchdog, so perhaps we should just leave it in here.
288*00b67f09SDavid van Moolenbroek 	 */
289*00b67f09SDavid van Moolenbroek 	if (signal_ok && timedwait) {
290*00b67f09SDavid van Moolenbroek 		isc_interval_t fifteen;
291*00b67f09SDavid van Moolenbroek 		isc_time_t then;
292*00b67f09SDavid van Moolenbroek 
293*00b67f09SDavid van Moolenbroek 		isc_interval_set(&fifteen, 15, 0);
294*00b67f09SDavid van Moolenbroek 		result = isc_time_add(&manager->due, &fifteen, &then);
295*00b67f09SDavid van Moolenbroek 
296*00b67f09SDavid van Moolenbroek 		if (result == ISC_R_SUCCESS &&
297*00b67f09SDavid van Moolenbroek 		    isc_time_compare(&then, now) < 0) {
298*00b67f09SDavid van Moolenbroek 			SIGNAL(&manager->wakeup);
299*00b67f09SDavid van Moolenbroek 			signal_ok = ISC_FALSE;
300*00b67f09SDavid van Moolenbroek 			isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
301*00b67f09SDavid van Moolenbroek 				      ISC_LOGMODULE_TIMER, ISC_LOG_WARNING,
302*00b67f09SDavid van Moolenbroek 				      "*** POKED TIMER ***");
303*00b67f09SDavid van Moolenbroek 		}
304*00b67f09SDavid van Moolenbroek 	}
305*00b67f09SDavid van Moolenbroek 
306*00b67f09SDavid van Moolenbroek 	if (timer->index == 1 && signal_ok) {
307*00b67f09SDavid van Moolenbroek 		XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
308*00b67f09SDavid van Moolenbroek 				      ISC_MSG_SIGNALSCHED,
309*00b67f09SDavid van Moolenbroek 				      "signal (schedule)"));
310*00b67f09SDavid van Moolenbroek 		SIGNAL(&manager->wakeup);
311*00b67f09SDavid van Moolenbroek 	}
312*00b67f09SDavid van Moolenbroek #else /* USE_TIMER_THREAD */
313*00b67f09SDavid van Moolenbroek 	if (timer->index == 1 &&
314*00b67f09SDavid van Moolenbroek 	    isc_time_compare(&timer->due, &manager->due) < 0)
315*00b67f09SDavid van Moolenbroek 		manager->due = timer->due;
316*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
317*00b67f09SDavid van Moolenbroek 
318*00b67f09SDavid van Moolenbroek 	return (ISC_R_SUCCESS);
319*00b67f09SDavid van Moolenbroek }
320*00b67f09SDavid van Moolenbroek 
321*00b67f09SDavid van Moolenbroek static inline void
deschedule(isc__timer_t * timer)322*00b67f09SDavid van Moolenbroek deschedule(isc__timer_t *timer) {
323*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
324*00b67f09SDavid van Moolenbroek 	isc_boolean_t need_wakeup = ISC_FALSE;
325*00b67f09SDavid van Moolenbroek #endif
326*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager;
327*00b67f09SDavid van Moolenbroek 
328*00b67f09SDavid van Moolenbroek 	/*
329*00b67f09SDavid van Moolenbroek 	 * The caller must ensure locking.
330*00b67f09SDavid van Moolenbroek 	 */
331*00b67f09SDavid van Moolenbroek 
332*00b67f09SDavid van Moolenbroek 	manager = timer->manager;
333*00b67f09SDavid van Moolenbroek 	if (timer->index > 0) {
334*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
335*00b67f09SDavid van Moolenbroek 		if (timer->index == 1)
336*00b67f09SDavid van Moolenbroek 			need_wakeup = ISC_TRUE;
337*00b67f09SDavid van Moolenbroek #endif
338*00b67f09SDavid van Moolenbroek 		isc_heap_delete(manager->heap, timer->index);
339*00b67f09SDavid van Moolenbroek 		timer->index = 0;
340*00b67f09SDavid van Moolenbroek 		INSIST(manager->nscheduled > 0);
341*00b67f09SDavid van Moolenbroek 		manager->nscheduled--;
342*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
343*00b67f09SDavid van Moolenbroek 		if (need_wakeup) {
344*00b67f09SDavid van Moolenbroek 			XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
345*00b67f09SDavid van Moolenbroek 					      ISC_MSG_SIGNALDESCHED,
346*00b67f09SDavid van Moolenbroek 					      "signal (deschedule)"));
347*00b67f09SDavid van Moolenbroek 			SIGNAL(&manager->wakeup);
348*00b67f09SDavid van Moolenbroek 		}
349*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
350*00b67f09SDavid van Moolenbroek 	}
351*00b67f09SDavid van Moolenbroek }
352*00b67f09SDavid van Moolenbroek 
353*00b67f09SDavid van Moolenbroek static void
destroy(isc__timer_t * timer)354*00b67f09SDavid van Moolenbroek destroy(isc__timer_t *timer) {
355*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager = timer->manager;
356*00b67f09SDavid van Moolenbroek 
357*00b67f09SDavid van Moolenbroek 	/*
358*00b67f09SDavid van Moolenbroek 	 * The caller must ensure it is safe to destroy the timer.
359*00b67f09SDavid van Moolenbroek 	 */
360*00b67f09SDavid van Moolenbroek 
361*00b67f09SDavid van Moolenbroek 	LOCK(&manager->lock);
362*00b67f09SDavid van Moolenbroek 
363*00b67f09SDavid van Moolenbroek 	(void)isc_task_purgerange(timer->task,
364*00b67f09SDavid van Moolenbroek 				  timer,
365*00b67f09SDavid van Moolenbroek 				  ISC_TIMEREVENT_FIRSTEVENT,
366*00b67f09SDavid van Moolenbroek 				  ISC_TIMEREVENT_LASTEVENT,
367*00b67f09SDavid van Moolenbroek 				  NULL);
368*00b67f09SDavid van Moolenbroek 	deschedule(timer);
369*00b67f09SDavid van Moolenbroek 	UNLINK(manager->timers, timer, link);
370*00b67f09SDavid van Moolenbroek 
371*00b67f09SDavid van Moolenbroek 	UNLOCK(&manager->lock);
372*00b67f09SDavid van Moolenbroek 
373*00b67f09SDavid van Moolenbroek 	isc_task_detach(&timer->task);
374*00b67f09SDavid van Moolenbroek 	DESTROYLOCK(&timer->lock);
375*00b67f09SDavid van Moolenbroek 	timer->common.impmagic = 0;
376*00b67f09SDavid van Moolenbroek 	timer->common.magic = 0;
377*00b67f09SDavid van Moolenbroek 	isc_mem_put(manager->mctx, timer, sizeof(*timer));
378*00b67f09SDavid van Moolenbroek }
379*00b67f09SDavid van Moolenbroek 
380*00b67f09SDavid van Moolenbroek isc_result_t
isc__timer_create(isc_timermgr_t * manager0,isc_timertype_t type,const isc_time_t * expires,const isc_interval_t * interval,isc_task_t * task,isc_taskaction_t action,void * arg,isc_timer_t ** timerp)381*00b67f09SDavid van Moolenbroek isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
382*00b67f09SDavid van Moolenbroek 		  const isc_time_t *expires, const isc_interval_t *interval,
383*00b67f09SDavid van Moolenbroek 		  isc_task_t *task, isc_taskaction_t action, void *arg,
384*00b67f09SDavid van Moolenbroek 		  isc_timer_t **timerp)
385*00b67f09SDavid van Moolenbroek {
386*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
387*00b67f09SDavid van Moolenbroek 	isc__timer_t *timer;
388*00b67f09SDavid van Moolenbroek 	isc_result_t result;
389*00b67f09SDavid van Moolenbroek 	isc_time_t now;
390*00b67f09SDavid van Moolenbroek 
391*00b67f09SDavid van Moolenbroek 	/*
392*00b67f09SDavid van Moolenbroek 	 * Create a new 'type' timer managed by 'manager'.  The timers
393*00b67f09SDavid van Moolenbroek 	 * parameters are specified by 'expires' and 'interval'.  Events
394*00b67f09SDavid van Moolenbroek 	 * will be posted to 'task' and when dispatched 'action' will be
395*00b67f09SDavid van Moolenbroek 	 * called with 'arg' as the arg value.  The new timer is returned
396*00b67f09SDavid van Moolenbroek 	 * in 'timerp'.
397*00b67f09SDavid van Moolenbroek 	 */
398*00b67f09SDavid van Moolenbroek 
399*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_MANAGER(manager));
400*00b67f09SDavid van Moolenbroek 	REQUIRE(task != NULL);
401*00b67f09SDavid van Moolenbroek 	REQUIRE(action != NULL);
402*00b67f09SDavid van Moolenbroek 	if (expires == NULL)
403*00b67f09SDavid van Moolenbroek 		expires = isc_time_epoch;
404*00b67f09SDavid van Moolenbroek 	if (interval == NULL)
405*00b67f09SDavid van Moolenbroek 		interval = isc_interval_zero;
406*00b67f09SDavid van Moolenbroek 	REQUIRE(type == isc_timertype_inactive ||
407*00b67f09SDavid van Moolenbroek 		!(isc_time_isepoch(expires) && isc_interval_iszero(interval)));
408*00b67f09SDavid van Moolenbroek 	REQUIRE(timerp != NULL && *timerp == NULL);
409*00b67f09SDavid van Moolenbroek 	REQUIRE(type != isc_timertype_limited ||
410*00b67f09SDavid van Moolenbroek 		!(isc_time_isepoch(expires) || isc_interval_iszero(interval)));
411*00b67f09SDavid van Moolenbroek 
412*00b67f09SDavid van Moolenbroek 	/*
413*00b67f09SDavid van Moolenbroek 	 * Get current time.
414*00b67f09SDavid van Moolenbroek 	 */
415*00b67f09SDavid van Moolenbroek 	if (type != isc_timertype_inactive) {
416*00b67f09SDavid van Moolenbroek 		TIME_NOW(&now);
417*00b67f09SDavid van Moolenbroek 	} else {
418*00b67f09SDavid van Moolenbroek 		/*
419*00b67f09SDavid van Moolenbroek 		 * We don't have to do this, but it keeps the compiler from
420*00b67f09SDavid van Moolenbroek 		 * complaining about "now" possibly being used without being
421*00b67f09SDavid van Moolenbroek 		 * set, even though it will never actually happen.
422*00b67f09SDavid van Moolenbroek 		 */
423*00b67f09SDavid van Moolenbroek 		isc_time_settoepoch(&now);
424*00b67f09SDavid van Moolenbroek 	}
425*00b67f09SDavid van Moolenbroek 
426*00b67f09SDavid van Moolenbroek 
427*00b67f09SDavid van Moolenbroek 	timer = isc_mem_get(manager->mctx, sizeof(*timer));
428*00b67f09SDavid van Moolenbroek 	if (timer == NULL)
429*00b67f09SDavid van Moolenbroek 		return (ISC_R_NOMEMORY);
430*00b67f09SDavid van Moolenbroek 
431*00b67f09SDavid van Moolenbroek 	timer->manager = manager;
432*00b67f09SDavid van Moolenbroek 	timer->references = 1;
433*00b67f09SDavid van Moolenbroek 
434*00b67f09SDavid van Moolenbroek 	if (type == isc_timertype_once && !isc_interval_iszero(interval)) {
435*00b67f09SDavid van Moolenbroek 		result = isc_time_add(&now, interval, &timer->idle);
436*00b67f09SDavid van Moolenbroek 		if (result != ISC_R_SUCCESS) {
437*00b67f09SDavid van Moolenbroek 			isc_mem_put(manager->mctx, timer, sizeof(*timer));
438*00b67f09SDavid van Moolenbroek 			return (result);
439*00b67f09SDavid van Moolenbroek 		}
440*00b67f09SDavid van Moolenbroek 	} else
441*00b67f09SDavid van Moolenbroek 		isc_time_settoepoch(&timer->idle);
442*00b67f09SDavid van Moolenbroek 
443*00b67f09SDavid van Moolenbroek 	timer->type = type;
444*00b67f09SDavid van Moolenbroek 	timer->expires = *expires;
445*00b67f09SDavid van Moolenbroek 	timer->interval = *interval;
446*00b67f09SDavid van Moolenbroek 	timer->task = NULL;
447*00b67f09SDavid van Moolenbroek 	isc_task_attach(task, &timer->task);
448*00b67f09SDavid van Moolenbroek 	timer->action = action;
449*00b67f09SDavid van Moolenbroek 	/*
450*00b67f09SDavid van Moolenbroek 	 * Removing the const attribute from "arg" is the best of two
451*00b67f09SDavid van Moolenbroek 	 * evils here.  If the timer->arg member is made const, then
452*00b67f09SDavid van Moolenbroek 	 * it affects a great many recipients of the timer event
453*00b67f09SDavid van Moolenbroek 	 * which did not pass in an "arg" that was truly const.
454*00b67f09SDavid van Moolenbroek 	 * Changing isc_timer_create() to not have "arg" prototyped as const,
455*00b67f09SDavid van Moolenbroek 	 * though, can cause compilers warnings for calls that *do*
456*00b67f09SDavid van Moolenbroek 	 * have a truly const arg.  The caller will have to carefully
457*00b67f09SDavid van Moolenbroek 	 * keep track of whether arg started as a true const.
458*00b67f09SDavid van Moolenbroek 	 */
459*00b67f09SDavid van Moolenbroek 	DE_CONST(arg, timer->arg);
460*00b67f09SDavid van Moolenbroek 	timer->index = 0;
461*00b67f09SDavid van Moolenbroek 	result = isc_mutex_init(&timer->lock);
462*00b67f09SDavid van Moolenbroek 	if (result != ISC_R_SUCCESS) {
463*00b67f09SDavid van Moolenbroek 		isc_task_detach(&timer->task);
464*00b67f09SDavid van Moolenbroek 		isc_mem_put(manager->mctx, timer, sizeof(*timer));
465*00b67f09SDavid van Moolenbroek 		return (result);
466*00b67f09SDavid van Moolenbroek 	}
467*00b67f09SDavid van Moolenbroek 	ISC_LINK_INIT(timer, link);
468*00b67f09SDavid van Moolenbroek 	timer->common.impmagic = TIMER_MAGIC;
469*00b67f09SDavid van Moolenbroek 	timer->common.magic = ISCAPI_TIMER_MAGIC;
470*00b67f09SDavid van Moolenbroek 	timer->common.methods = (isc_timermethods_t *)&timermethods;
471*00b67f09SDavid van Moolenbroek 
472*00b67f09SDavid van Moolenbroek 	LOCK(&manager->lock);
473*00b67f09SDavid van Moolenbroek 
474*00b67f09SDavid van Moolenbroek 	/*
475*00b67f09SDavid van Moolenbroek 	 * Note we don't have to lock the timer like we normally would because
476*00b67f09SDavid van Moolenbroek 	 * there are no external references to it yet.
477*00b67f09SDavid van Moolenbroek 	 */
478*00b67f09SDavid van Moolenbroek 
479*00b67f09SDavid van Moolenbroek 	if (type != isc_timertype_inactive)
480*00b67f09SDavid van Moolenbroek 		result = schedule(timer, &now, ISC_TRUE);
481*00b67f09SDavid van Moolenbroek 	else
482*00b67f09SDavid van Moolenbroek 		result = ISC_R_SUCCESS;
483*00b67f09SDavid van Moolenbroek 	if (result == ISC_R_SUCCESS)
484*00b67f09SDavid van Moolenbroek 		APPEND(manager->timers, timer, link);
485*00b67f09SDavid van Moolenbroek 
486*00b67f09SDavid van Moolenbroek 	UNLOCK(&manager->lock);
487*00b67f09SDavid van Moolenbroek 
488*00b67f09SDavid van Moolenbroek 	if (result != ISC_R_SUCCESS) {
489*00b67f09SDavid van Moolenbroek 		timer->common.impmagic = 0;
490*00b67f09SDavid van Moolenbroek 		timer->common.magic = 0;
491*00b67f09SDavid van Moolenbroek 		DESTROYLOCK(&timer->lock);
492*00b67f09SDavid van Moolenbroek 		isc_task_detach(&timer->task);
493*00b67f09SDavid van Moolenbroek 		isc_mem_put(manager->mctx, timer, sizeof(*timer));
494*00b67f09SDavid van Moolenbroek 		return (result);
495*00b67f09SDavid van Moolenbroek 	}
496*00b67f09SDavid van Moolenbroek 
497*00b67f09SDavid van Moolenbroek 	*timerp = (isc_timer_t *)timer;
498*00b67f09SDavid van Moolenbroek 
499*00b67f09SDavid van Moolenbroek 	return (ISC_R_SUCCESS);
500*00b67f09SDavid van Moolenbroek }
501*00b67f09SDavid van Moolenbroek 
502*00b67f09SDavid van Moolenbroek isc_result_t
isc__timer_reset(isc_timer_t * timer0,isc_timertype_t type,const isc_time_t * expires,const isc_interval_t * interval,isc_boolean_t purge)503*00b67f09SDavid van Moolenbroek isc__timer_reset(isc_timer_t *timer0, isc_timertype_t type,
504*00b67f09SDavid van Moolenbroek 		 const isc_time_t *expires, const isc_interval_t *interval,
505*00b67f09SDavid van Moolenbroek 		 isc_boolean_t purge)
506*00b67f09SDavid van Moolenbroek {
507*00b67f09SDavid van Moolenbroek 	isc__timer_t *timer = (isc__timer_t *)timer0;
508*00b67f09SDavid van Moolenbroek 	isc_time_t now;
509*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager;
510*00b67f09SDavid van Moolenbroek 	isc_result_t result;
511*00b67f09SDavid van Moolenbroek 
512*00b67f09SDavid van Moolenbroek 	/*
513*00b67f09SDavid van Moolenbroek 	 * Change the timer's type, expires, and interval values to the given
514*00b67f09SDavid van Moolenbroek 	 * values.  If 'purge' is ISC_TRUE, any pending events from this timer
515*00b67f09SDavid van Moolenbroek 	 * are purged from its task's event queue.
516*00b67f09SDavid van Moolenbroek 	 */
517*00b67f09SDavid van Moolenbroek 
518*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_TIMER(timer));
519*00b67f09SDavid van Moolenbroek 	manager = timer->manager;
520*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_MANAGER(manager));
521*00b67f09SDavid van Moolenbroek 
522*00b67f09SDavid van Moolenbroek 	if (expires == NULL)
523*00b67f09SDavid van Moolenbroek 		expires = isc_time_epoch;
524*00b67f09SDavid van Moolenbroek 	if (interval == NULL)
525*00b67f09SDavid van Moolenbroek 		interval = isc_interval_zero;
526*00b67f09SDavid van Moolenbroek 	REQUIRE(type == isc_timertype_inactive ||
527*00b67f09SDavid van Moolenbroek 		!(isc_time_isepoch(expires) && isc_interval_iszero(interval)));
528*00b67f09SDavid van Moolenbroek 	REQUIRE(type != isc_timertype_limited ||
529*00b67f09SDavid van Moolenbroek 		!(isc_time_isepoch(expires) || isc_interval_iszero(interval)));
530*00b67f09SDavid van Moolenbroek 
531*00b67f09SDavid van Moolenbroek 	/*
532*00b67f09SDavid van Moolenbroek 	 * Get current time.
533*00b67f09SDavid van Moolenbroek 	 */
534*00b67f09SDavid van Moolenbroek 	if (type != isc_timertype_inactive) {
535*00b67f09SDavid van Moolenbroek 		TIME_NOW(&now);
536*00b67f09SDavid van Moolenbroek 	} else {
537*00b67f09SDavid van Moolenbroek 		/*
538*00b67f09SDavid van Moolenbroek 		 * We don't have to do this, but it keeps the compiler from
539*00b67f09SDavid van Moolenbroek 		 * complaining about "now" possibly being used without being
540*00b67f09SDavid van Moolenbroek 		 * set, even though it will never actually happen.
541*00b67f09SDavid van Moolenbroek 		 */
542*00b67f09SDavid van Moolenbroek 		isc_time_settoepoch(&now);
543*00b67f09SDavid van Moolenbroek 	}
544*00b67f09SDavid van Moolenbroek 
545*00b67f09SDavid van Moolenbroek 	LOCK(&manager->lock);
546*00b67f09SDavid van Moolenbroek 	LOCK(&timer->lock);
547*00b67f09SDavid van Moolenbroek 
548*00b67f09SDavid van Moolenbroek 	if (purge)
549*00b67f09SDavid van Moolenbroek 		(void)isc_task_purgerange(timer->task,
550*00b67f09SDavid van Moolenbroek 					  timer,
551*00b67f09SDavid van Moolenbroek 					  ISC_TIMEREVENT_FIRSTEVENT,
552*00b67f09SDavid van Moolenbroek 					  ISC_TIMEREVENT_LASTEVENT,
553*00b67f09SDavid van Moolenbroek 					  NULL);
554*00b67f09SDavid van Moolenbroek 	timer->type = type;
555*00b67f09SDavid van Moolenbroek 	timer->expires = *expires;
556*00b67f09SDavid van Moolenbroek 	timer->interval = *interval;
557*00b67f09SDavid van Moolenbroek 	if (type == isc_timertype_once && !isc_interval_iszero(interval)) {
558*00b67f09SDavid van Moolenbroek 		result = isc_time_add(&now, interval, &timer->idle);
559*00b67f09SDavid van Moolenbroek 	} else {
560*00b67f09SDavid van Moolenbroek 		isc_time_settoepoch(&timer->idle);
561*00b67f09SDavid van Moolenbroek 		result = ISC_R_SUCCESS;
562*00b67f09SDavid van Moolenbroek 	}
563*00b67f09SDavid van Moolenbroek 
564*00b67f09SDavid van Moolenbroek 	if (result == ISC_R_SUCCESS) {
565*00b67f09SDavid van Moolenbroek 		if (type == isc_timertype_inactive) {
566*00b67f09SDavid van Moolenbroek 			deschedule(timer);
567*00b67f09SDavid van Moolenbroek 			result = ISC_R_SUCCESS;
568*00b67f09SDavid van Moolenbroek 		} else
569*00b67f09SDavid van Moolenbroek 			result = schedule(timer, &now, ISC_TRUE);
570*00b67f09SDavid van Moolenbroek 	}
571*00b67f09SDavid van Moolenbroek 
572*00b67f09SDavid van Moolenbroek 	UNLOCK(&timer->lock);
573*00b67f09SDavid van Moolenbroek 	UNLOCK(&manager->lock);
574*00b67f09SDavid van Moolenbroek 
575*00b67f09SDavid van Moolenbroek 	return (result);
576*00b67f09SDavid van Moolenbroek }
577*00b67f09SDavid van Moolenbroek 
578*00b67f09SDavid van Moolenbroek isc_timertype_t
isc_timer_gettype(isc_timer_t * timer0)579*00b67f09SDavid van Moolenbroek isc_timer_gettype(isc_timer_t *timer0) {
580*00b67f09SDavid van Moolenbroek 	isc__timer_t *timer = (isc__timer_t *)timer0;
581*00b67f09SDavid van Moolenbroek 	isc_timertype_t t;
582*00b67f09SDavid van Moolenbroek 
583*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_TIMER(timer));
584*00b67f09SDavid van Moolenbroek 
585*00b67f09SDavid van Moolenbroek 	LOCK(&timer->lock);
586*00b67f09SDavid van Moolenbroek 	t = timer->type;
587*00b67f09SDavid van Moolenbroek 	UNLOCK(&timer->lock);
588*00b67f09SDavid van Moolenbroek 
589*00b67f09SDavid van Moolenbroek 	return (t);
590*00b67f09SDavid van Moolenbroek }
591*00b67f09SDavid van Moolenbroek 
592*00b67f09SDavid van Moolenbroek isc_result_t
isc__timer_touch(isc_timer_t * timer0)593*00b67f09SDavid van Moolenbroek isc__timer_touch(isc_timer_t *timer0) {
594*00b67f09SDavid van Moolenbroek 	isc__timer_t *timer = (isc__timer_t *)timer0;
595*00b67f09SDavid van Moolenbroek 	isc_result_t result;
596*00b67f09SDavid van Moolenbroek 	isc_time_t now;
597*00b67f09SDavid van Moolenbroek 
598*00b67f09SDavid van Moolenbroek 	/*
599*00b67f09SDavid van Moolenbroek 	 * Set the last-touched time of 'timer' to the current time.
600*00b67f09SDavid van Moolenbroek 	 */
601*00b67f09SDavid van Moolenbroek 
602*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_TIMER(timer));
603*00b67f09SDavid van Moolenbroek 
604*00b67f09SDavid van Moolenbroek 	LOCK(&timer->lock);
605*00b67f09SDavid van Moolenbroek 
606*00b67f09SDavid van Moolenbroek 	/*
607*00b67f09SDavid van Moolenbroek 	 * We'd like to
608*00b67f09SDavid van Moolenbroek 	 *
609*00b67f09SDavid van Moolenbroek 	 *	REQUIRE(timer->type == isc_timertype_once);
610*00b67f09SDavid van Moolenbroek 	 *
611*00b67f09SDavid van Moolenbroek 	 * but we cannot without locking the manager lock too, which we
612*00b67f09SDavid van Moolenbroek 	 * don't want to do.
613*00b67f09SDavid van Moolenbroek 	 */
614*00b67f09SDavid van Moolenbroek 
615*00b67f09SDavid van Moolenbroek 	TIME_NOW(&now);
616*00b67f09SDavid van Moolenbroek 	result = isc_time_add(&now, &timer->interval, &timer->idle);
617*00b67f09SDavid van Moolenbroek 
618*00b67f09SDavid van Moolenbroek 	UNLOCK(&timer->lock);
619*00b67f09SDavid van Moolenbroek 
620*00b67f09SDavid van Moolenbroek 	return (result);
621*00b67f09SDavid van Moolenbroek }
622*00b67f09SDavid van Moolenbroek 
623*00b67f09SDavid van Moolenbroek void
isc__timer_attach(isc_timer_t * timer0,isc_timer_t ** timerp)624*00b67f09SDavid van Moolenbroek isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) {
625*00b67f09SDavid van Moolenbroek 	isc__timer_t *timer = (isc__timer_t *)timer0;
626*00b67f09SDavid van Moolenbroek 
627*00b67f09SDavid van Moolenbroek 	/*
628*00b67f09SDavid van Moolenbroek 	 * Attach *timerp to timer.
629*00b67f09SDavid van Moolenbroek 	 */
630*00b67f09SDavid van Moolenbroek 
631*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_TIMER(timer));
632*00b67f09SDavid van Moolenbroek 	REQUIRE(timerp != NULL && *timerp == NULL);
633*00b67f09SDavid van Moolenbroek 
634*00b67f09SDavid van Moolenbroek 	LOCK(&timer->lock);
635*00b67f09SDavid van Moolenbroek 	timer->references++;
636*00b67f09SDavid van Moolenbroek 	UNLOCK(&timer->lock);
637*00b67f09SDavid van Moolenbroek 
638*00b67f09SDavid van Moolenbroek 	*timerp = (isc_timer_t *)timer;
639*00b67f09SDavid van Moolenbroek }
640*00b67f09SDavid van Moolenbroek 
641*00b67f09SDavid van Moolenbroek void
isc__timer_detach(isc_timer_t ** timerp)642*00b67f09SDavid van Moolenbroek isc__timer_detach(isc_timer_t **timerp) {
643*00b67f09SDavid van Moolenbroek 	isc__timer_t *timer;
644*00b67f09SDavid van Moolenbroek 	isc_boolean_t free_timer = ISC_FALSE;
645*00b67f09SDavid van Moolenbroek 
646*00b67f09SDavid van Moolenbroek 	/*
647*00b67f09SDavid van Moolenbroek 	 * Detach *timerp from its timer.
648*00b67f09SDavid van Moolenbroek 	 */
649*00b67f09SDavid van Moolenbroek 
650*00b67f09SDavid van Moolenbroek 	REQUIRE(timerp != NULL);
651*00b67f09SDavid van Moolenbroek 	timer = (isc__timer_t *)*timerp;
652*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_TIMER(timer));
653*00b67f09SDavid van Moolenbroek 
654*00b67f09SDavid van Moolenbroek 	LOCK(&timer->lock);
655*00b67f09SDavid van Moolenbroek 	REQUIRE(timer->references > 0);
656*00b67f09SDavid van Moolenbroek 	timer->references--;
657*00b67f09SDavid van Moolenbroek 	if (timer->references == 0)
658*00b67f09SDavid van Moolenbroek 		free_timer = ISC_TRUE;
659*00b67f09SDavid van Moolenbroek 	UNLOCK(&timer->lock);
660*00b67f09SDavid van Moolenbroek 
661*00b67f09SDavid van Moolenbroek 	if (free_timer)
662*00b67f09SDavid van Moolenbroek 		destroy(timer);
663*00b67f09SDavid van Moolenbroek 
664*00b67f09SDavid van Moolenbroek 	*timerp = NULL;
665*00b67f09SDavid van Moolenbroek }
666*00b67f09SDavid van Moolenbroek 
667*00b67f09SDavid van Moolenbroek static void
dispatch(isc__timermgr_t * manager,isc_time_t * now)668*00b67f09SDavid van Moolenbroek dispatch(isc__timermgr_t *manager, isc_time_t *now) {
669*00b67f09SDavid van Moolenbroek 	isc_boolean_t done = ISC_FALSE, post_event, need_schedule;
670*00b67f09SDavid van Moolenbroek 	isc_timerevent_t *event;
671*00b67f09SDavid van Moolenbroek 	isc_eventtype_t type = 0;
672*00b67f09SDavid van Moolenbroek 	isc__timer_t *timer;
673*00b67f09SDavid van Moolenbroek 	isc_result_t result;
674*00b67f09SDavid van Moolenbroek 	isc_boolean_t idle;
675*00b67f09SDavid van Moolenbroek 
676*00b67f09SDavid van Moolenbroek 	/*!
677*00b67f09SDavid van Moolenbroek 	 * The caller must be holding the manager lock.
678*00b67f09SDavid van Moolenbroek 	 */
679*00b67f09SDavid van Moolenbroek 
680*00b67f09SDavid van Moolenbroek 	while (manager->nscheduled > 0 && !done) {
681*00b67f09SDavid van Moolenbroek 		timer = isc_heap_element(manager->heap, 1);
682*00b67f09SDavid van Moolenbroek 		INSIST(timer != NULL && timer->type != isc_timertype_inactive);
683*00b67f09SDavid van Moolenbroek 		if (isc_time_compare(now, &timer->due) >= 0) {
684*00b67f09SDavid van Moolenbroek 			if (timer->type == isc_timertype_ticker) {
685*00b67f09SDavid van Moolenbroek 				type = ISC_TIMEREVENT_TICK;
686*00b67f09SDavid van Moolenbroek 				post_event = ISC_TRUE;
687*00b67f09SDavid van Moolenbroek 				need_schedule = ISC_TRUE;
688*00b67f09SDavid van Moolenbroek 			} else if (timer->type == isc_timertype_limited) {
689*00b67f09SDavid van Moolenbroek 				int cmp;
690*00b67f09SDavid van Moolenbroek 				cmp = isc_time_compare(now, &timer->expires);
691*00b67f09SDavid van Moolenbroek 				if (cmp >= 0) {
692*00b67f09SDavid van Moolenbroek 					type = ISC_TIMEREVENT_LIFE;
693*00b67f09SDavid van Moolenbroek 					post_event = ISC_TRUE;
694*00b67f09SDavid van Moolenbroek 					need_schedule = ISC_FALSE;
695*00b67f09SDavid van Moolenbroek 				} else {
696*00b67f09SDavid van Moolenbroek 					type = ISC_TIMEREVENT_TICK;
697*00b67f09SDavid van Moolenbroek 					post_event = ISC_TRUE;
698*00b67f09SDavid van Moolenbroek 					need_schedule = ISC_TRUE;
699*00b67f09SDavid van Moolenbroek 				}
700*00b67f09SDavid van Moolenbroek 			} else if (!isc_time_isepoch(&timer->expires) &&
701*00b67f09SDavid van Moolenbroek 				   isc_time_compare(now,
702*00b67f09SDavid van Moolenbroek 						    &timer->expires) >= 0) {
703*00b67f09SDavid van Moolenbroek 				type = ISC_TIMEREVENT_LIFE;
704*00b67f09SDavid van Moolenbroek 				post_event = ISC_TRUE;
705*00b67f09SDavid van Moolenbroek 				need_schedule = ISC_FALSE;
706*00b67f09SDavid van Moolenbroek 			} else {
707*00b67f09SDavid van Moolenbroek 				idle = ISC_FALSE;
708*00b67f09SDavid van Moolenbroek 
709*00b67f09SDavid van Moolenbroek 				LOCK(&timer->lock);
710*00b67f09SDavid van Moolenbroek 				if (!isc_time_isepoch(&timer->idle) &&
711*00b67f09SDavid van Moolenbroek 				    isc_time_compare(now,
712*00b67f09SDavid van Moolenbroek 						     &timer->idle) >= 0) {
713*00b67f09SDavid van Moolenbroek 					idle = ISC_TRUE;
714*00b67f09SDavid van Moolenbroek 				}
715*00b67f09SDavid van Moolenbroek 				UNLOCK(&timer->lock);
716*00b67f09SDavid van Moolenbroek 				if (idle) {
717*00b67f09SDavid van Moolenbroek 					type = ISC_TIMEREVENT_IDLE;
718*00b67f09SDavid van Moolenbroek 					post_event = ISC_TRUE;
719*00b67f09SDavid van Moolenbroek 					need_schedule = ISC_FALSE;
720*00b67f09SDavid van Moolenbroek 				} else {
721*00b67f09SDavid van Moolenbroek 					/*
722*00b67f09SDavid van Moolenbroek 					 * Idle timer has been touched;
723*00b67f09SDavid van Moolenbroek 					 * reschedule.
724*00b67f09SDavid van Moolenbroek 					 */
725*00b67f09SDavid van Moolenbroek 					XTRACEID(isc_msgcat_get(isc_msgcat,
726*00b67f09SDavid van Moolenbroek 								ISC_MSGSET_TIMER,
727*00b67f09SDavid van Moolenbroek 								ISC_MSG_IDLERESCHED,
728*00b67f09SDavid van Moolenbroek 								"idle reschedule"),
729*00b67f09SDavid van Moolenbroek 						 timer);
730*00b67f09SDavid van Moolenbroek 					post_event = ISC_FALSE;
731*00b67f09SDavid van Moolenbroek 					need_schedule = ISC_TRUE;
732*00b67f09SDavid van Moolenbroek 				}
733*00b67f09SDavid van Moolenbroek 			}
734*00b67f09SDavid van Moolenbroek 
735*00b67f09SDavid van Moolenbroek 			if (post_event) {
736*00b67f09SDavid van Moolenbroek 				XTRACEID(isc_msgcat_get(isc_msgcat,
737*00b67f09SDavid van Moolenbroek 							ISC_MSGSET_TIMER,
738*00b67f09SDavid van Moolenbroek 							ISC_MSG_POSTING,
739*00b67f09SDavid van Moolenbroek 							"posting"), timer);
740*00b67f09SDavid van Moolenbroek 				/*
741*00b67f09SDavid van Moolenbroek 				 * XXX We could preallocate this event.
742*00b67f09SDavid van Moolenbroek 				 */
743*00b67f09SDavid van Moolenbroek 				event = (isc_timerevent_t *)isc_event_allocate(manager->mctx,
744*00b67f09SDavid van Moolenbroek 							   timer,
745*00b67f09SDavid van Moolenbroek 							   type,
746*00b67f09SDavid van Moolenbroek 							   timer->action,
747*00b67f09SDavid van Moolenbroek 							   timer->arg,
748*00b67f09SDavid van Moolenbroek 							   sizeof(*event));
749*00b67f09SDavid van Moolenbroek 
750*00b67f09SDavid van Moolenbroek 				if (event != NULL) {
751*00b67f09SDavid van Moolenbroek 					event->due = timer->due;
752*00b67f09SDavid van Moolenbroek 					isc_task_send(timer->task,
753*00b67f09SDavid van Moolenbroek 						      ISC_EVENT_PTR(&event));
754*00b67f09SDavid van Moolenbroek 				} else
755*00b67f09SDavid van Moolenbroek 					UNEXPECTED_ERROR(__FILE__, __LINE__, "%s",
756*00b67f09SDavid van Moolenbroek 						 isc_msgcat_get(isc_msgcat,
757*00b67f09SDavid van Moolenbroek 							 ISC_MSGSET_TIMER,
758*00b67f09SDavid van Moolenbroek 							 ISC_MSG_EVENTNOTALLOC,
759*00b67f09SDavid van Moolenbroek 							 "couldn't "
760*00b67f09SDavid van Moolenbroek 							 "allocate event"));
761*00b67f09SDavid van Moolenbroek 			}
762*00b67f09SDavid van Moolenbroek 
763*00b67f09SDavid van Moolenbroek 			timer->index = 0;
764*00b67f09SDavid van Moolenbroek 			isc_heap_delete(manager->heap, 1);
765*00b67f09SDavid van Moolenbroek 			manager->nscheduled--;
766*00b67f09SDavid van Moolenbroek 
767*00b67f09SDavid van Moolenbroek 			if (need_schedule) {
768*00b67f09SDavid van Moolenbroek 				result = schedule(timer, now, ISC_FALSE);
769*00b67f09SDavid van Moolenbroek 				if (result != ISC_R_SUCCESS)
770*00b67f09SDavid van Moolenbroek 					UNEXPECTED_ERROR(__FILE__, __LINE__,
771*00b67f09SDavid van Moolenbroek 							 "%s: %u",
772*00b67f09SDavid van Moolenbroek 						isc_msgcat_get(isc_msgcat,
773*00b67f09SDavid van Moolenbroek 							ISC_MSGSET_TIMER,
774*00b67f09SDavid van Moolenbroek 							ISC_MSG_SCHEDFAIL,
775*00b67f09SDavid van Moolenbroek 							"couldn't schedule "
776*00b67f09SDavid van Moolenbroek 							"timer"),
777*00b67f09SDavid van Moolenbroek 							 result);
778*00b67f09SDavid van Moolenbroek 			}
779*00b67f09SDavid van Moolenbroek 		} else {
780*00b67f09SDavid van Moolenbroek 			manager->due = timer->due;
781*00b67f09SDavid van Moolenbroek 			done = ISC_TRUE;
782*00b67f09SDavid van Moolenbroek 		}
783*00b67f09SDavid van Moolenbroek 	}
784*00b67f09SDavid van Moolenbroek }
785*00b67f09SDavid van Moolenbroek 
786*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
787*00b67f09SDavid van Moolenbroek static isc_threadresult_t
788*00b67f09SDavid van Moolenbroek #ifdef _WIN32			/* XXXDCL */
789*00b67f09SDavid van Moolenbroek WINAPI
790*00b67f09SDavid van Moolenbroek #endif
run(void * uap)791*00b67f09SDavid van Moolenbroek run(void *uap) {
792*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager = uap;
793*00b67f09SDavid van Moolenbroek 	isc_time_t now;
794*00b67f09SDavid van Moolenbroek 	isc_result_t result;
795*00b67f09SDavid van Moolenbroek 
796*00b67f09SDavid van Moolenbroek 	LOCK(&manager->lock);
797*00b67f09SDavid van Moolenbroek 	while (!manager->done) {
798*00b67f09SDavid van Moolenbroek 		TIME_NOW(&now);
799*00b67f09SDavid van Moolenbroek 
800*00b67f09SDavid van Moolenbroek 		XTRACETIME(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
801*00b67f09SDavid van Moolenbroek 					  ISC_MSG_RUNNING,
802*00b67f09SDavid van Moolenbroek 					  "running"), now);
803*00b67f09SDavid van Moolenbroek 
804*00b67f09SDavid van Moolenbroek 		dispatch(manager, &now);
805*00b67f09SDavid van Moolenbroek 
806*00b67f09SDavid van Moolenbroek 		if (manager->nscheduled > 0) {
807*00b67f09SDavid van Moolenbroek 			XTRACETIME2(isc_msgcat_get(isc_msgcat,
808*00b67f09SDavid van Moolenbroek 						   ISC_MSGSET_GENERAL,
809*00b67f09SDavid van Moolenbroek 						   ISC_MSG_WAITUNTIL,
810*00b67f09SDavid van Moolenbroek 						   "waituntil"),
811*00b67f09SDavid van Moolenbroek 				    manager->due, now);
812*00b67f09SDavid van Moolenbroek 			result = WAITUNTIL(&manager->wakeup, &manager->lock, &manager->due);
813*00b67f09SDavid van Moolenbroek 			INSIST(result == ISC_R_SUCCESS ||
814*00b67f09SDavid van Moolenbroek 			       result == ISC_R_TIMEDOUT);
815*00b67f09SDavid van Moolenbroek 		} else {
816*00b67f09SDavid van Moolenbroek 			XTRACETIME(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
817*00b67f09SDavid van Moolenbroek 						  ISC_MSG_WAIT, "wait"), now);
818*00b67f09SDavid van Moolenbroek 			WAIT(&manager->wakeup, &manager->lock);
819*00b67f09SDavid van Moolenbroek 		}
820*00b67f09SDavid van Moolenbroek 		XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
821*00b67f09SDavid van Moolenbroek 				      ISC_MSG_WAKEUP, "wakeup"));
822*00b67f09SDavid van Moolenbroek 	}
823*00b67f09SDavid van Moolenbroek 	UNLOCK(&manager->lock);
824*00b67f09SDavid van Moolenbroek 
825*00b67f09SDavid van Moolenbroek #ifdef OPENSSL_LEAKS
826*00b67f09SDavid van Moolenbroek 	ERR_remove_state(0);
827*00b67f09SDavid van Moolenbroek #endif
828*00b67f09SDavid van Moolenbroek 
829*00b67f09SDavid van Moolenbroek 	return ((isc_threadresult_t)0);
830*00b67f09SDavid van Moolenbroek }
831*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
832*00b67f09SDavid van Moolenbroek 
833*00b67f09SDavid van Moolenbroek static isc_boolean_t
sooner(void * v1,void * v2)834*00b67f09SDavid van Moolenbroek sooner(void *v1, void *v2) {
835*00b67f09SDavid van Moolenbroek 	isc__timer_t *t1, *t2;
836*00b67f09SDavid van Moolenbroek 
837*00b67f09SDavid van Moolenbroek 	t1 = v1;
838*00b67f09SDavid van Moolenbroek 	t2 = v2;
839*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_TIMER(t1));
840*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_TIMER(t2));
841*00b67f09SDavid van Moolenbroek 
842*00b67f09SDavid van Moolenbroek 	if (isc_time_compare(&t1->due, &t2->due) < 0)
843*00b67f09SDavid van Moolenbroek 		return (ISC_TRUE);
844*00b67f09SDavid van Moolenbroek 	return (ISC_FALSE);
845*00b67f09SDavid van Moolenbroek }
846*00b67f09SDavid van Moolenbroek 
847*00b67f09SDavid van Moolenbroek static void
set_index(void * what,unsigned int index)848*00b67f09SDavid van Moolenbroek set_index(void *what, unsigned int index) {
849*00b67f09SDavid van Moolenbroek 	isc__timer_t *timer;
850*00b67f09SDavid van Moolenbroek 
851*00b67f09SDavid van Moolenbroek 	timer = what;
852*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_TIMER(timer));
853*00b67f09SDavid van Moolenbroek 
854*00b67f09SDavid van Moolenbroek 	timer->index = index;
855*00b67f09SDavid van Moolenbroek }
856*00b67f09SDavid van Moolenbroek 
857*00b67f09SDavid van Moolenbroek isc_result_t
isc__timermgr_create(isc_mem_t * mctx,isc_timermgr_t ** managerp)858*00b67f09SDavid van Moolenbroek isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
859*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager;
860*00b67f09SDavid van Moolenbroek 	isc_result_t result;
861*00b67f09SDavid van Moolenbroek 
862*00b67f09SDavid van Moolenbroek 	/*
863*00b67f09SDavid van Moolenbroek 	 * Create a timer manager.
864*00b67f09SDavid van Moolenbroek 	 */
865*00b67f09SDavid van Moolenbroek 
866*00b67f09SDavid van Moolenbroek 	REQUIRE(managerp != NULL && *managerp == NULL);
867*00b67f09SDavid van Moolenbroek 
868*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
869*00b67f09SDavid van Moolenbroek 	if (timermgr != NULL) {
870*00b67f09SDavid van Moolenbroek 		timermgr->refs++;
871*00b67f09SDavid van Moolenbroek 		*managerp = (isc_timermgr_t *)timermgr;
872*00b67f09SDavid van Moolenbroek 		return (ISC_R_SUCCESS);
873*00b67f09SDavid van Moolenbroek 	}
874*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
875*00b67f09SDavid van Moolenbroek 
876*00b67f09SDavid van Moolenbroek 	manager = isc_mem_get(mctx, sizeof(*manager));
877*00b67f09SDavid van Moolenbroek 	if (manager == NULL)
878*00b67f09SDavid van Moolenbroek 		return (ISC_R_NOMEMORY);
879*00b67f09SDavid van Moolenbroek 
880*00b67f09SDavid van Moolenbroek 	manager->common.impmagic = TIMER_MANAGER_MAGIC;
881*00b67f09SDavid van Moolenbroek 	manager->common.magic = ISCAPI_TIMERMGR_MAGIC;
882*00b67f09SDavid van Moolenbroek 	manager->common.methods = (isc_timermgrmethods_t *)&timermgrmethods;
883*00b67f09SDavid van Moolenbroek 	manager->mctx = NULL;
884*00b67f09SDavid van Moolenbroek 	manager->done = ISC_FALSE;
885*00b67f09SDavid van Moolenbroek 	INIT_LIST(manager->timers);
886*00b67f09SDavid van Moolenbroek 	manager->nscheduled = 0;
887*00b67f09SDavid van Moolenbroek 	isc_time_settoepoch(&manager->due);
888*00b67f09SDavid van Moolenbroek 	manager->heap = NULL;
889*00b67f09SDavid van Moolenbroek 	result = isc_heap_create(mctx, sooner, set_index, 0, &manager->heap);
890*00b67f09SDavid van Moolenbroek 	if (result != ISC_R_SUCCESS) {
891*00b67f09SDavid van Moolenbroek 		INSIST(result == ISC_R_NOMEMORY);
892*00b67f09SDavid van Moolenbroek 		isc_mem_put(mctx, manager, sizeof(*manager));
893*00b67f09SDavid van Moolenbroek 		return (ISC_R_NOMEMORY);
894*00b67f09SDavid van Moolenbroek 	}
895*00b67f09SDavid van Moolenbroek 	result = isc_mutex_init(&manager->lock);
896*00b67f09SDavid van Moolenbroek 	if (result != ISC_R_SUCCESS) {
897*00b67f09SDavid van Moolenbroek 		isc_heap_destroy(&manager->heap);
898*00b67f09SDavid van Moolenbroek 		isc_mem_put(mctx, manager, sizeof(*manager));
899*00b67f09SDavid van Moolenbroek 		return (result);
900*00b67f09SDavid van Moolenbroek 	}
901*00b67f09SDavid van Moolenbroek 	isc_mem_attach(mctx, &manager->mctx);
902*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
903*00b67f09SDavid van Moolenbroek 	if (isc_condition_init(&manager->wakeup) != ISC_R_SUCCESS) {
904*00b67f09SDavid van Moolenbroek 		isc_mem_detach(&manager->mctx);
905*00b67f09SDavid van Moolenbroek 		DESTROYLOCK(&manager->lock);
906*00b67f09SDavid van Moolenbroek 		isc_heap_destroy(&manager->heap);
907*00b67f09SDavid van Moolenbroek 		isc_mem_put(mctx, manager, sizeof(*manager));
908*00b67f09SDavid van Moolenbroek 		UNEXPECTED_ERROR(__FILE__, __LINE__,
909*00b67f09SDavid van Moolenbroek 				 "isc_condition_init() %s",
910*00b67f09SDavid van Moolenbroek 				 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
911*00b67f09SDavid van Moolenbroek 						ISC_MSG_FAILED, "failed"));
912*00b67f09SDavid van Moolenbroek 		return (ISC_R_UNEXPECTED);
913*00b67f09SDavid van Moolenbroek 	}
914*00b67f09SDavid van Moolenbroek 	if (isc_thread_create(run, manager, &manager->thread) !=
915*00b67f09SDavid van Moolenbroek 	    ISC_R_SUCCESS) {
916*00b67f09SDavid van Moolenbroek 		isc_mem_detach(&manager->mctx);
917*00b67f09SDavid van Moolenbroek 		(void)isc_condition_destroy(&manager->wakeup);
918*00b67f09SDavid van Moolenbroek 		DESTROYLOCK(&manager->lock);
919*00b67f09SDavid van Moolenbroek 		isc_heap_destroy(&manager->heap);
920*00b67f09SDavid van Moolenbroek 		isc_mem_put(mctx, manager, sizeof(*manager));
921*00b67f09SDavid van Moolenbroek 		UNEXPECTED_ERROR(__FILE__, __LINE__,
922*00b67f09SDavid van Moolenbroek 				 "isc_thread_create() %s",
923*00b67f09SDavid van Moolenbroek 				 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
924*00b67f09SDavid van Moolenbroek 						ISC_MSG_FAILED, "failed"));
925*00b67f09SDavid van Moolenbroek 		return (ISC_R_UNEXPECTED);
926*00b67f09SDavid van Moolenbroek 	}
927*00b67f09SDavid van Moolenbroek #endif
928*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
929*00b67f09SDavid van Moolenbroek 	manager->refs = 1;
930*00b67f09SDavid van Moolenbroek 	timermgr = manager;
931*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
932*00b67f09SDavid van Moolenbroek 
933*00b67f09SDavid van Moolenbroek 	*managerp = (isc_timermgr_t *)manager;
934*00b67f09SDavid van Moolenbroek 
935*00b67f09SDavid van Moolenbroek 	return (ISC_R_SUCCESS);
936*00b67f09SDavid van Moolenbroek }
937*00b67f09SDavid van Moolenbroek 
938*00b67f09SDavid van Moolenbroek void
isc_timermgr_poke(isc_timermgr_t * manager0)939*00b67f09SDavid van Moolenbroek isc_timermgr_poke(isc_timermgr_t *manager0) {
940*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
941*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
942*00b67f09SDavid van Moolenbroek 
943*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_MANAGER(manager));
944*00b67f09SDavid van Moolenbroek 
945*00b67f09SDavid van Moolenbroek 	SIGNAL(&manager->wakeup);
946*00b67f09SDavid van Moolenbroek #else
947*00b67f09SDavid van Moolenbroek 	UNUSED(manager0);
948*00b67f09SDavid van Moolenbroek #endif
949*00b67f09SDavid van Moolenbroek }
950*00b67f09SDavid van Moolenbroek 
951*00b67f09SDavid van Moolenbroek void
isc__timermgr_destroy(isc_timermgr_t ** managerp)952*00b67f09SDavid van Moolenbroek isc__timermgr_destroy(isc_timermgr_t **managerp) {
953*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager;
954*00b67f09SDavid van Moolenbroek 	isc_mem_t *mctx;
955*00b67f09SDavid van Moolenbroek 
956*00b67f09SDavid van Moolenbroek 	/*
957*00b67f09SDavid van Moolenbroek 	 * Destroy a timer manager.
958*00b67f09SDavid van Moolenbroek 	 */
959*00b67f09SDavid van Moolenbroek 
960*00b67f09SDavid van Moolenbroek 	REQUIRE(managerp != NULL);
961*00b67f09SDavid van Moolenbroek 	manager = (isc__timermgr_t *)*managerp;
962*00b67f09SDavid van Moolenbroek 	REQUIRE(VALID_MANAGER(manager));
963*00b67f09SDavid van Moolenbroek 
964*00b67f09SDavid van Moolenbroek 	LOCK(&manager->lock);
965*00b67f09SDavid van Moolenbroek 
966*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
967*00b67f09SDavid van Moolenbroek 	manager->refs--;
968*00b67f09SDavid van Moolenbroek 	if (manager->refs > 0) {
969*00b67f09SDavid van Moolenbroek 		UNLOCK(&manager->lock);
970*00b67f09SDavid van Moolenbroek 		*managerp = NULL;
971*00b67f09SDavid van Moolenbroek 		return;
972*00b67f09SDavid van Moolenbroek 	}
973*00b67f09SDavid van Moolenbroek 	timermgr = NULL;
974*00b67f09SDavid van Moolenbroek #endif /* USE_SHARED_MANAGER */
975*00b67f09SDavid van Moolenbroek 
976*00b67f09SDavid van Moolenbroek #ifndef USE_TIMER_THREAD
977*00b67f09SDavid van Moolenbroek 	isc__timermgr_dispatch((isc_timermgr_t *)manager);
978*00b67f09SDavid van Moolenbroek #endif
979*00b67f09SDavid van Moolenbroek 
980*00b67f09SDavid van Moolenbroek 	REQUIRE(EMPTY(manager->timers));
981*00b67f09SDavid van Moolenbroek 	manager->done = ISC_TRUE;
982*00b67f09SDavid van Moolenbroek 
983*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
984*00b67f09SDavid van Moolenbroek 	XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
985*00b67f09SDavid van Moolenbroek 			      ISC_MSG_SIGNALDESTROY, "signal (destroy)"));
986*00b67f09SDavid van Moolenbroek 	SIGNAL(&manager->wakeup);
987*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
988*00b67f09SDavid van Moolenbroek 
989*00b67f09SDavid van Moolenbroek 	UNLOCK(&manager->lock);
990*00b67f09SDavid van Moolenbroek 
991*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
992*00b67f09SDavid van Moolenbroek 	/*
993*00b67f09SDavid van Moolenbroek 	 * Wait for thread to exit.
994*00b67f09SDavid van Moolenbroek 	 */
995*00b67f09SDavid van Moolenbroek 	if (isc_thread_join(manager->thread, NULL) != ISC_R_SUCCESS)
996*00b67f09SDavid van Moolenbroek 		UNEXPECTED_ERROR(__FILE__, __LINE__,
997*00b67f09SDavid van Moolenbroek 				 "isc_thread_join() %s",
998*00b67f09SDavid van Moolenbroek 				 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
999*00b67f09SDavid van Moolenbroek 						ISC_MSG_FAILED, "failed"));
1000*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
1001*00b67f09SDavid van Moolenbroek 
1002*00b67f09SDavid van Moolenbroek 	/*
1003*00b67f09SDavid van Moolenbroek 	 * Clean up.
1004*00b67f09SDavid van Moolenbroek 	 */
1005*00b67f09SDavid van Moolenbroek #ifdef USE_TIMER_THREAD
1006*00b67f09SDavid van Moolenbroek 	(void)isc_condition_destroy(&manager->wakeup);
1007*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
1008*00b67f09SDavid van Moolenbroek 	DESTROYLOCK(&manager->lock);
1009*00b67f09SDavid van Moolenbroek 	isc_heap_destroy(&manager->heap);
1010*00b67f09SDavid van Moolenbroek 	manager->common.impmagic = 0;
1011*00b67f09SDavid van Moolenbroek 	manager->common.magic = 0;
1012*00b67f09SDavid van Moolenbroek 	mctx = manager->mctx;
1013*00b67f09SDavid van Moolenbroek 	isc_mem_put(mctx, manager, sizeof(*manager));
1014*00b67f09SDavid van Moolenbroek 	isc_mem_detach(&mctx);
1015*00b67f09SDavid van Moolenbroek 
1016*00b67f09SDavid van Moolenbroek 	*managerp = NULL;
1017*00b67f09SDavid van Moolenbroek 
1018*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1019*00b67f09SDavid van Moolenbroek 	timermgr = NULL;
1020*00b67f09SDavid van Moolenbroek #endif
1021*00b67f09SDavid van Moolenbroek }
1022*00b67f09SDavid van Moolenbroek 
1023*00b67f09SDavid van Moolenbroek #ifndef USE_TIMER_THREAD
1024*00b67f09SDavid van Moolenbroek isc_result_t
isc__timermgr_nextevent(isc_timermgr_t * manager0,isc_time_t * when)1025*00b67f09SDavid van Moolenbroek isc__timermgr_nextevent(isc_timermgr_t *manager0, isc_time_t *when) {
1026*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
1027*00b67f09SDavid van Moolenbroek 
1028*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1029*00b67f09SDavid van Moolenbroek 	if (manager == NULL)
1030*00b67f09SDavid van Moolenbroek 		manager = timermgr;
1031*00b67f09SDavid van Moolenbroek #endif
1032*00b67f09SDavid van Moolenbroek 	if (manager == NULL || manager->nscheduled == 0)
1033*00b67f09SDavid van Moolenbroek 		return (ISC_R_NOTFOUND);
1034*00b67f09SDavid van Moolenbroek 	*when = manager->due;
1035*00b67f09SDavid van Moolenbroek 	return (ISC_R_SUCCESS);
1036*00b67f09SDavid van Moolenbroek }
1037*00b67f09SDavid van Moolenbroek 
1038*00b67f09SDavid van Moolenbroek void
isc__timermgr_dispatch(isc_timermgr_t * manager0)1039*00b67f09SDavid van Moolenbroek isc__timermgr_dispatch(isc_timermgr_t *manager0) {
1040*00b67f09SDavid van Moolenbroek 	isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
1041*00b67f09SDavid van Moolenbroek 	isc_time_t now;
1042*00b67f09SDavid van Moolenbroek 
1043*00b67f09SDavid van Moolenbroek #ifdef USE_SHARED_MANAGER
1044*00b67f09SDavid van Moolenbroek 	if (manager == NULL)
1045*00b67f09SDavid van Moolenbroek 		manager = timermgr;
1046*00b67f09SDavid van Moolenbroek #endif
1047*00b67f09SDavid van Moolenbroek 	if (manager == NULL)
1048*00b67f09SDavid van Moolenbroek 		return;
1049*00b67f09SDavid van Moolenbroek 	TIME_NOW(&now);
1050*00b67f09SDavid van Moolenbroek 	dispatch(manager, &now);
1051*00b67f09SDavid van Moolenbroek }
1052*00b67f09SDavid van Moolenbroek #endif /* USE_TIMER_THREAD */
1053*00b67f09SDavid van Moolenbroek 
1054*00b67f09SDavid van Moolenbroek isc_result_t
isc__timer_register(void)1055*00b67f09SDavid van Moolenbroek isc__timer_register(void) {
1056*00b67f09SDavid van Moolenbroek 	return (isc_timer_register(isc__timermgr_create));
1057*00b67f09SDavid van Moolenbroek }
1058*00b67f09SDavid van Moolenbroek 
1059*00b67f09SDavid van Moolenbroek static isc_mutex_t createlock;
1060*00b67f09SDavid van Moolenbroek static isc_once_t once = ISC_ONCE_INIT;
1061*00b67f09SDavid van Moolenbroek static isc_timermgrcreatefunc_t timermgr_createfunc = NULL;
1062*00b67f09SDavid van Moolenbroek 
1063*00b67f09SDavid van Moolenbroek static void
initialize(void)1064*00b67f09SDavid van Moolenbroek initialize(void) {
1065*00b67f09SDavid van Moolenbroek 	RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
1066*00b67f09SDavid van Moolenbroek }
1067*00b67f09SDavid van Moolenbroek 
1068*00b67f09SDavid van Moolenbroek isc_result_t
isc_timer_register(isc_timermgrcreatefunc_t createfunc)1069*00b67f09SDavid van Moolenbroek isc_timer_register(isc_timermgrcreatefunc_t createfunc) {
1070*00b67f09SDavid van Moolenbroek 	isc_result_t result = ISC_R_SUCCESS;
1071*00b67f09SDavid van Moolenbroek 
1072*00b67f09SDavid van Moolenbroek 	RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
1073*00b67f09SDavid van Moolenbroek 
1074*00b67f09SDavid van Moolenbroek 	LOCK(&createlock);
1075*00b67f09SDavid van Moolenbroek 	if (timermgr_createfunc == NULL)
1076*00b67f09SDavid van Moolenbroek 		timermgr_createfunc = createfunc;
1077*00b67f09SDavid van Moolenbroek 	else
1078*00b67f09SDavid van Moolenbroek 		result = ISC_R_EXISTS;
1079*00b67f09SDavid van Moolenbroek 	UNLOCK(&createlock);
1080*00b67f09SDavid van Moolenbroek 
1081*00b67f09SDavid van Moolenbroek 	return (result);
1082*00b67f09SDavid van Moolenbroek }
1083*00b67f09SDavid van Moolenbroek 
1084*00b67f09SDavid van Moolenbroek isc_result_t
isc_timermgr_createinctx(isc_mem_t * mctx,isc_appctx_t * actx,isc_timermgr_t ** managerp)1085*00b67f09SDavid van Moolenbroek isc_timermgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
1086*00b67f09SDavid van Moolenbroek 			 isc_timermgr_t **managerp)
1087*00b67f09SDavid van Moolenbroek {
1088*00b67f09SDavid van Moolenbroek 	isc_result_t result;
1089*00b67f09SDavid van Moolenbroek 
1090*00b67f09SDavid van Moolenbroek 	LOCK(&createlock);
1091*00b67f09SDavid van Moolenbroek 
1092*00b67f09SDavid van Moolenbroek 	REQUIRE(timermgr_createfunc != NULL);
1093*00b67f09SDavid van Moolenbroek 	result = (*timermgr_createfunc)(mctx, managerp);
1094*00b67f09SDavid van Moolenbroek 
1095*00b67f09SDavid van Moolenbroek 	UNLOCK(&createlock);
1096*00b67f09SDavid van Moolenbroek 
1097*00b67f09SDavid van Moolenbroek 	if (result == ISC_R_SUCCESS)
1098*00b67f09SDavid van Moolenbroek 		isc_appctx_settimermgr(actx, *managerp);
1099*00b67f09SDavid van Moolenbroek 
1100*00b67f09SDavid van Moolenbroek 	return (result);
1101*00b67f09SDavid van Moolenbroek }
1102*00b67f09SDavid van Moolenbroek 
1103*00b67f09SDavid van Moolenbroek isc_result_t
isc_timermgr_create(isc_mem_t * mctx,isc_timermgr_t ** managerp)1104*00b67f09SDavid van Moolenbroek isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
1105*00b67f09SDavid van Moolenbroek 	isc_result_t result;
1106*00b67f09SDavid van Moolenbroek 
1107*00b67f09SDavid van Moolenbroek 	if (isc_bind9)
1108*00b67f09SDavid van Moolenbroek 		return (isc__timermgr_create(mctx, managerp));
1109*00b67f09SDavid van Moolenbroek 
1110*00b67f09SDavid van Moolenbroek 	LOCK(&createlock);
1111*00b67f09SDavid van Moolenbroek 
1112*00b67f09SDavid van Moolenbroek 	REQUIRE(timermgr_createfunc != NULL);
1113*00b67f09SDavid van Moolenbroek 	result = (*timermgr_createfunc)(mctx, managerp);
1114*00b67f09SDavid van Moolenbroek 
1115*00b67f09SDavid van Moolenbroek 	UNLOCK(&createlock);
1116*00b67f09SDavid van Moolenbroek 
1117*00b67f09SDavid van Moolenbroek 	return (result);
1118*00b67f09SDavid van Moolenbroek }
1119*00b67f09SDavid van Moolenbroek 
1120*00b67f09SDavid van Moolenbroek void
isc_timermgr_destroy(isc_timermgr_t ** managerp)1121*00b67f09SDavid van Moolenbroek isc_timermgr_destroy(isc_timermgr_t **managerp) {
1122*00b67f09SDavid van Moolenbroek 	REQUIRE(*managerp != NULL && ISCAPI_TIMERMGR_VALID(*managerp));
1123*00b67f09SDavid van Moolenbroek 
1124*00b67f09SDavid van Moolenbroek 	if (isc_bind9)
1125*00b67f09SDavid van Moolenbroek 		isc__timermgr_destroy(managerp);
1126*00b67f09SDavid van Moolenbroek 	else
1127*00b67f09SDavid van Moolenbroek 		(*managerp)->methods->destroy(managerp);
1128*00b67f09SDavid van Moolenbroek 
1129*00b67f09SDavid van Moolenbroek 	ENSURE(*managerp == NULL);
1130*00b67f09SDavid van Moolenbroek }
1131*00b67f09SDavid van Moolenbroek 
1132*00b67f09SDavid van Moolenbroek isc_result_t
isc_timer_create(isc_timermgr_t * manager,isc_timertype_t type,const isc_time_t * expires,const isc_interval_t * interval,isc_task_t * task,isc_taskaction_t action,void * arg,isc_timer_t ** timerp)1133*00b67f09SDavid van Moolenbroek isc_timer_create(isc_timermgr_t *manager, isc_timertype_t type,
1134*00b67f09SDavid van Moolenbroek 		 const isc_time_t *expires, const isc_interval_t *interval,
1135*00b67f09SDavid van Moolenbroek 		 isc_task_t *task, isc_taskaction_t action, void *arg,
1136*00b67f09SDavid van Moolenbroek 		 isc_timer_t **timerp)
1137*00b67f09SDavid van Moolenbroek {
1138*00b67f09SDavid van Moolenbroek 	REQUIRE(ISCAPI_TIMERMGR_VALID(manager));
1139*00b67f09SDavid van Moolenbroek 
1140*00b67f09SDavid van Moolenbroek 	if (isc_bind9)
1141*00b67f09SDavid van Moolenbroek 		return (isc__timer_create(manager, type, expires, interval,
1142*00b67f09SDavid van Moolenbroek 					  task, action, arg, timerp));
1143*00b67f09SDavid van Moolenbroek 
1144*00b67f09SDavid van Moolenbroek 	return (manager->methods->timercreate(manager, type, expires,
1145*00b67f09SDavid van Moolenbroek 					      interval, task, action, arg,
1146*00b67f09SDavid van Moolenbroek 					      timerp));
1147*00b67f09SDavid van Moolenbroek }
1148*00b67f09SDavid van Moolenbroek 
1149*00b67f09SDavid van Moolenbroek void
isc_timer_attach(isc_timer_t * timer,isc_timer_t ** timerp)1150*00b67f09SDavid van Moolenbroek isc_timer_attach(isc_timer_t *timer, isc_timer_t **timerp) {
1151*00b67f09SDavid van Moolenbroek 	REQUIRE(ISCAPI_TIMER_VALID(timer));
1152*00b67f09SDavid van Moolenbroek 	REQUIRE(timerp != NULL && *timerp == NULL);
1153*00b67f09SDavid van Moolenbroek 
1154*00b67f09SDavid van Moolenbroek 	if (isc_bind9)
1155*00b67f09SDavid van Moolenbroek 		isc__timer_attach(timer, timerp);
1156*00b67f09SDavid van Moolenbroek 	else
1157*00b67f09SDavid van Moolenbroek 		timer->methods->attach(timer, timerp);
1158*00b67f09SDavid van Moolenbroek 
1159*00b67f09SDavid van Moolenbroek 	ENSURE(*timerp == timer);
1160*00b67f09SDavid van Moolenbroek }
1161*00b67f09SDavid van Moolenbroek 
1162*00b67f09SDavid van Moolenbroek void
isc_timer_detach(isc_timer_t ** timerp)1163*00b67f09SDavid van Moolenbroek isc_timer_detach(isc_timer_t **timerp) {
1164*00b67f09SDavid van Moolenbroek 	REQUIRE(timerp != NULL && ISCAPI_TIMER_VALID(*timerp));
1165*00b67f09SDavid van Moolenbroek 
1166*00b67f09SDavid van Moolenbroek 	if (isc_bind9)
1167*00b67f09SDavid van Moolenbroek 		isc__timer_detach(timerp);
1168*00b67f09SDavid van Moolenbroek 	else
1169*00b67f09SDavid van Moolenbroek 		(*timerp)->methods->detach(timerp);
1170*00b67f09SDavid van Moolenbroek 
1171*00b67f09SDavid van Moolenbroek 	ENSURE(*timerp == NULL);
1172*00b67f09SDavid van Moolenbroek }
1173*00b67f09SDavid van Moolenbroek 
1174*00b67f09SDavid van Moolenbroek isc_result_t
isc_timer_reset(isc_timer_t * timer,isc_timertype_t type,const isc_time_t * expires,const isc_interval_t * interval,isc_boolean_t purge)1175*00b67f09SDavid van Moolenbroek isc_timer_reset(isc_timer_t *timer, isc_timertype_t type,
1176*00b67f09SDavid van Moolenbroek 		const isc_time_t *expires, const isc_interval_t *interval,
1177*00b67f09SDavid van Moolenbroek 		isc_boolean_t purge)
1178*00b67f09SDavid van Moolenbroek {
1179*00b67f09SDavid van Moolenbroek 	REQUIRE(ISCAPI_TIMER_VALID(timer));
1180*00b67f09SDavid van Moolenbroek 
1181*00b67f09SDavid van Moolenbroek 	if (isc_bind9)
1182*00b67f09SDavid van Moolenbroek 		return (isc__timer_reset(timer, type, expires,
1183*00b67f09SDavid van Moolenbroek 					 interval, purge));
1184*00b67f09SDavid van Moolenbroek 
1185*00b67f09SDavid van Moolenbroek 	return (timer->methods->reset(timer, type, expires, interval, purge));
1186*00b67f09SDavid van Moolenbroek }
1187*00b67f09SDavid van Moolenbroek 
1188*00b67f09SDavid van Moolenbroek isc_result_t
isc_timer_touch(isc_timer_t * timer)1189*00b67f09SDavid van Moolenbroek isc_timer_touch(isc_timer_t *timer) {
1190*00b67f09SDavid van Moolenbroek 	REQUIRE(ISCAPI_TIMER_VALID(timer));
1191*00b67f09SDavid van Moolenbroek 
1192*00b67f09SDavid van Moolenbroek 	if (isc_bind9)
1193*00b67f09SDavid van Moolenbroek 		return (isc__timer_touch(timer));
1194*00b67f09SDavid van Moolenbroek 
1195*00b67f09SDavid van Moolenbroek 	return (timer->methods->touch(timer));
1196*00b67f09SDavid van Moolenbroek }
1197