1: /*
2: * Copyright (C) 2004, 2005, 2007-2009 Internet Systems Consortium, Inc. ("ISC")
3: * Copyright (C) 1998-2002 Internet Software Consortium.
4: *
5: * Permission to use, copy, modify, and/or 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 WITH
10: * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11: * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12: * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13: * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14: * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15: * PERFORMANCE OF THIS SOFTWARE.
16: */
17:
18: /* $Id: timer.c,v 1.1.1.1 2012/05/29 12:08:38 misho Exp $ */
19:
20: /*! \file */
21:
22: #include <config.h>
23:
24: #include <isc/condition.h>
25: #include <isc/heap.h>
26: #include <isc/log.h>
27: #include <isc/magic.h>
28: #include <isc/mem.h>
29: #include <isc/msgs.h>
30: #include <isc/platform.h>
31: #include <isc/task.h>
32: #include <isc/thread.h>
33: #include <isc/time.h>
34: #include <isc/timer.h>
35: #include <isc/util.h>
36:
37: #ifndef ISC_PLATFORM_USETHREADS
38: #include "timer_p.h"
39: #endif /* ISC_PLATFORM_USETHREADS */
40:
41: #ifdef ISC_TIMER_TRACE
42: #define XTRACE(s) fprintf(stderr, "%s\n", (s))
43: #define XTRACEID(s, t) fprintf(stderr, "%s %p\n", (s), (t))
44: #define XTRACETIME(s, d) fprintf(stderr, "%s %u.%09u\n", (s), \
45: (d).seconds, (d).nanoseconds)
46: #define XTRACETIME2(s, d, n) fprintf(stderr, "%s %u.%09u %u.%09u\n", (s), \
47: (d).seconds, (d).nanoseconds, (n).seconds, (n).nanoseconds)
48: #define XTRACETIMER(s, t, d) fprintf(stderr, "%s %p %u.%09u\n", (s), (t), \
49: (d).seconds, (d).nanoseconds)
50: #else
51: #define XTRACE(s)
52: #define XTRACEID(s, t)
53: #define XTRACETIME(s, d)
54: #define XTRACETIME2(s, d, n)
55: #define XTRACETIMER(s, t, d)
56: #endif /* ISC_TIMER_TRACE */
57:
58: #define TIMER_MAGIC ISC_MAGIC('T', 'I', 'M', 'R')
59: #define VALID_TIMER(t) ISC_MAGIC_VALID(t, TIMER_MAGIC)
60:
61: struct isc_timer {
62: /*! Not locked. */
63: unsigned int magic;
64: isc_timermgr_t * manager;
65: isc_mutex_t lock;
66: /*! Locked by timer lock. */
67: unsigned int references;
68: isc_time_t idle;
69: /*! Locked by manager lock. */
70: isc_timertype_t type;
71: isc_time_t expires;
72: isc_interval_t interval;
73: isc_task_t * task;
74: isc_taskaction_t action;
75: void * arg;
76: unsigned int index;
77: isc_time_t due;
78: LINK(isc_timer_t) link;
79: };
80:
81: #define TIMER_MANAGER_MAGIC ISC_MAGIC('T', 'I', 'M', 'M')
82: #define VALID_MANAGER(m) ISC_MAGIC_VALID(m, TIMER_MANAGER_MAGIC)
83:
84: struct isc_timermgr {
85: /* Not locked. */
86: unsigned int magic;
87: isc_mem_t * mctx;
88: isc_mutex_t lock;
89: /* Locked by manager lock. */
90: isc_boolean_t done;
91: LIST(isc_timer_t) timers;
92: unsigned int nscheduled;
93: isc_time_t due;
94: #ifdef ISC_PLATFORM_USETHREADS
95: isc_condition_t wakeup;
96: isc_thread_t thread;
97: #else /* ISC_PLATFORM_USETHREADS */
98: unsigned int refs;
99: #endif /* ISC_PLATFORM_USETHREADS */
100: isc_heap_t * heap;
101: };
102:
103: #ifndef ISC_PLATFORM_USETHREADS
104: /*!
105: * If threads are not in use, there can be only one.
106: */
107: static isc_timermgr_t *timermgr = NULL;
108: #endif /* ISC_PLATFORM_USETHREADS */
109:
110: static inline isc_result_t
111: schedule(isc_timer_t *timer, isc_time_t *now, isc_boolean_t signal_ok) {
112: isc_result_t result;
113: isc_timermgr_t *manager;
114: isc_time_t due;
115: int cmp;
116: #ifdef ISC_PLATFORM_USETHREADS
117: isc_boolean_t timedwait;
118: #endif
119:
120: /*!
121: * Note: the caller must ensure locking.
122: */
123:
124: REQUIRE(timer->type != isc_timertype_inactive);
125:
126: #ifndef ISC_PLATFORM_USETHREADS
127: UNUSED(signal_ok);
128: #endif /* ISC_PLATFORM_USETHREADS */
129:
130: manager = timer->manager;
131:
132: #ifdef ISC_PLATFORM_USETHREADS
133: /*!
134: * If the manager was timed wait, we may need to signal the
135: * manager to force a wakeup.
136: */
137: timedwait = ISC_TF(manager->nscheduled > 0 &&
138: isc_time_seconds(&manager->due) != 0);
139: #endif
140:
141: /*
142: * Compute the new due time.
143: */
144: if (timer->type != isc_timertype_once) {
145: result = isc_time_add(now, &timer->interval, &due);
146: if (result != ISC_R_SUCCESS)
147: return (result);
148: if (timer->type == isc_timertype_limited &&
149: isc_time_compare(&timer->expires, &due) < 0)
150: due = timer->expires;
151: } else {
152: if (isc_time_isepoch(&timer->idle))
153: due = timer->expires;
154: else if (isc_time_isepoch(&timer->expires))
155: due = timer->idle;
156: else if (isc_time_compare(&timer->idle, &timer->expires) < 0)
157: due = timer->idle;
158: else
159: due = timer->expires;
160: }
161:
162: /*
163: * Schedule the timer.
164: */
165:
166: if (timer->index > 0) {
167: /*
168: * Already scheduled.
169: */
170: cmp = isc_time_compare(&due, &timer->due);
171: timer->due = due;
172: switch (cmp) {
173: case -1:
174: isc_heap_increased(manager->heap, timer->index);
175: break;
176: case 1:
177: isc_heap_decreased(manager->heap, timer->index);
178: break;
179: case 0:
180: /* Nothing to do. */
181: break;
182: }
183: } else {
184: timer->due = due;
185: result = isc_heap_insert(manager->heap, timer);
186: if (result != ISC_R_SUCCESS) {
187: INSIST(result == ISC_R_NOMEMORY);
188: return (ISC_R_NOMEMORY);
189: }
190: manager->nscheduled++;
191: }
192:
193: XTRACETIMER(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
194: ISC_MSG_SCHEDULE, "schedule"), timer, due);
195:
196: /*
197: * If this timer is at the head of the queue, we need to ensure
198: * that we won't miss it if it has a more recent due time than
199: * the current "next" timer. We do this either by waking up the
200: * run thread, or explicitly setting the value in the manager.
201: */
202: #ifdef ISC_PLATFORM_USETHREADS
203:
204: /*
205: * This is a temporary (probably) hack to fix a bug on tru64 5.1
206: * and 5.1a. Sometimes, pthread_cond_timedwait() doesn't actually
207: * return when the time expires, so here, we check to see if
208: * we're 15 seconds or more behind, and if we are, we signal
209: * the dispatcher. This isn't such a bad idea as a general purpose
210: * watchdog, so perhaps we should just leave it in here.
211: */
212: if (signal_ok && timedwait) {
213: isc_interval_t fifteen;
214: isc_time_t then;
215:
216: isc_interval_set(&fifteen, 15, 0);
217: result = isc_time_add(&manager->due, &fifteen, &then);
218:
219: if (result == ISC_R_SUCCESS &&
220: isc_time_compare(&then, now) < 0) {
221: SIGNAL(&manager->wakeup);
222: signal_ok = ISC_FALSE;
223: isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
224: ISC_LOGMODULE_TIMER, ISC_LOG_WARNING,
225: "*** POKED TIMER ***");
226: }
227: }
228:
229: if (timer->index == 1 && signal_ok) {
230: XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
231: ISC_MSG_SIGNALSCHED,
232: "signal (schedule)"));
233: SIGNAL(&manager->wakeup);
234: }
235: #else /* ISC_PLATFORM_USETHREADS */
236: if (timer->index == 1 &&
237: isc_time_compare(&timer->due, &manager->due) < 0)
238: manager->due = timer->due;
239: #endif /* ISC_PLATFORM_USETHREADS */
240:
241: return (ISC_R_SUCCESS);
242: }
243:
244: static inline void
245: deschedule(isc_timer_t *timer) {
246: isc_boolean_t need_wakeup = ISC_FALSE;
247: isc_timermgr_t *manager;
248:
249: /*
250: * The caller must ensure locking.
251: */
252:
253: manager = timer->manager;
254: if (timer->index > 0) {
255: if (timer->index == 1)
256: need_wakeup = ISC_TRUE;
257: isc_heap_delete(manager->heap, timer->index);
258: timer->index = 0;
259: INSIST(manager->nscheduled > 0);
260: manager->nscheduled--;
261: #ifdef ISC_PLATFORM_USETHREADS
262: if (need_wakeup) {
263: XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
264: ISC_MSG_SIGNALDESCHED,
265: "signal (deschedule)"));
266: SIGNAL(&manager->wakeup);
267: }
268: #endif /* ISC_PLATFORM_USETHREADS */
269: }
270: }
271:
272: static void
273: destroy(isc_timer_t *timer) {
274: isc_timermgr_t *manager = timer->manager;
275:
276: /*
277: * The caller must ensure it is safe to destroy the timer.
278: */
279:
280: LOCK(&manager->lock);
281:
282: (void)isc_task_purgerange(timer->task,
283: timer,
284: ISC_TIMEREVENT_FIRSTEVENT,
285: ISC_TIMEREVENT_LASTEVENT,
286: NULL);
287: deschedule(timer);
288: UNLINK(manager->timers, timer, link);
289:
290: UNLOCK(&manager->lock);
291:
292: isc_task_detach(&timer->task);
293: DESTROYLOCK(&timer->lock);
294: timer->magic = 0;
295: isc_mem_put(manager->mctx, timer, sizeof(*timer));
296: }
297:
298: isc_result_t
299: isc_timer_create(isc_timermgr_t *manager, isc_timertype_t type,
300: isc_time_t *expires, isc_interval_t *interval,
301: isc_task_t *task, isc_taskaction_t action, const void *arg,
302: isc_timer_t **timerp)
303: {
304: isc_timer_t *timer;
305: isc_result_t result;
306: isc_time_t now;
307:
308: /*
309: * Create a new 'type' timer managed by 'manager'. The timers
310: * parameters are specified by 'expires' and 'interval'. Events
311: * will be posted to 'task' and when dispatched 'action' will be
312: * called with 'arg' as the arg value. The new timer is returned
313: * in 'timerp'.
314: */
315:
316: REQUIRE(VALID_MANAGER(manager));
317: REQUIRE(task != NULL);
318: REQUIRE(action != NULL);
319: if (expires == NULL)
320: expires = isc_time_epoch;
321: if (interval == NULL)
322: interval = isc_interval_zero;
323: REQUIRE(type == isc_timertype_inactive ||
324: !(isc_time_isepoch(expires) && isc_interval_iszero(interval)));
325: REQUIRE(timerp != NULL && *timerp == NULL);
326: REQUIRE(type != isc_timertype_limited ||
327: !(isc_time_isepoch(expires) || isc_interval_iszero(interval)));
328:
329: /*
330: * Get current time.
331: */
332: if (type != isc_timertype_inactive) {
333: TIME_NOW(&now);
334: } else {
335: /*
336: * We don't have to do this, but it keeps the compiler from
337: * complaining about "now" possibly being used without being
338: * set, even though it will never actually happen.
339: */
340: isc_time_settoepoch(&now);
341: }
342:
343:
344: timer = isc_mem_get(manager->mctx, sizeof(*timer));
345: if (timer == NULL)
346: return (ISC_R_NOMEMORY);
347:
348: timer->manager = manager;
349: timer->references = 1;
350:
351: if (type == isc_timertype_once && !isc_interval_iszero(interval)) {
352: result = isc_time_add(&now, interval, &timer->idle);
353: if (result != ISC_R_SUCCESS) {
354: isc_mem_put(manager->mctx, timer, sizeof(*timer));
355: return (result);
356: }
357: } else
358: isc_time_settoepoch(&timer->idle);
359:
360: timer->type = type;
361: timer->expires = *expires;
362: timer->interval = *interval;
363: timer->task = NULL;
364: isc_task_attach(task, &timer->task);
365: timer->action = action;
366: /*
367: * Removing the const attribute from "arg" is the best of two
368: * evils here. If the timer->arg member is made const, then
369: * it affects a great many recipients of the timer event
370: * which did not pass in an "arg" that was truly const.
371: * Changing isc_timer_create() to not have "arg" prototyped as const,
372: * though, can cause compilers warnings for calls that *do*
373: * have a truly const arg. The caller will have to carefully
374: * keep track of whether arg started as a true const.
375: */
376: DE_CONST(arg, timer->arg);
377: timer->index = 0;
378: result = isc_mutex_init(&timer->lock);
379: if (result != ISC_R_SUCCESS) {
380: isc_task_detach(&timer->task);
381: isc_mem_put(manager->mctx, timer, sizeof(*timer));
382: return (result);
383: }
384: ISC_LINK_INIT(timer, link);
385: timer->magic = TIMER_MAGIC;
386:
387: LOCK(&manager->lock);
388:
389: /*
390: * Note we don't have to lock the timer like we normally would because
391: * there are no external references to it yet.
392: */
393:
394: if (type != isc_timertype_inactive)
395: result = schedule(timer, &now, ISC_TRUE);
396: else
397: result = ISC_R_SUCCESS;
398: if (result == ISC_R_SUCCESS)
399: APPEND(manager->timers, timer, link);
400:
401: UNLOCK(&manager->lock);
402:
403: if (result != ISC_R_SUCCESS) {
404: timer->magic = 0;
405: DESTROYLOCK(&timer->lock);
406: isc_task_detach(&timer->task);
407: isc_mem_put(manager->mctx, timer, sizeof(*timer));
408: return (result);
409: }
410:
411: *timerp = timer;
412:
413: return (ISC_R_SUCCESS);
414: }
415:
416: isc_result_t
417: isc_timer_reset(isc_timer_t *timer, isc_timertype_t type,
418: isc_time_t *expires, isc_interval_t *interval,
419: isc_boolean_t purge)
420: {
421: isc_time_t now;
422: isc_timermgr_t *manager;
423: isc_result_t result;
424:
425: /*
426: * Change the timer's type, expires, and interval values to the given
427: * values. If 'purge' is ISC_TRUE, any pending events from this timer
428: * are purged from its task's event queue.
429: */
430:
431: REQUIRE(VALID_TIMER(timer));
432: manager = timer->manager;
433: REQUIRE(VALID_MANAGER(manager));
434: if (expires == NULL)
435: expires = isc_time_epoch;
436: if (interval == NULL)
437: interval = isc_interval_zero;
438: REQUIRE(type == isc_timertype_inactive ||
439: !(isc_time_isepoch(expires) && isc_interval_iszero(interval)));
440: REQUIRE(type != isc_timertype_limited ||
441: !(isc_time_isepoch(expires) || isc_interval_iszero(interval)));
442:
443: /*
444: * Get current time.
445: */
446: if (type != isc_timertype_inactive) {
447: TIME_NOW(&now);
448: } else {
449: /*
450: * We don't have to do this, but it keeps the compiler from
451: * complaining about "now" possibly being used without being
452: * set, even though it will never actually happen.
453: */
454: isc_time_settoepoch(&now);
455: }
456:
457: manager = timer->manager;
458:
459: LOCK(&manager->lock);
460: LOCK(&timer->lock);
461:
462: if (purge)
463: (void)isc_task_purgerange(timer->task,
464: timer,
465: ISC_TIMEREVENT_FIRSTEVENT,
466: ISC_TIMEREVENT_LASTEVENT,
467: NULL);
468: timer->type = type;
469: timer->expires = *expires;
470: timer->interval = *interval;
471: if (type == isc_timertype_once && !isc_interval_iszero(interval)) {
472: result = isc_time_add(&now, interval, &timer->idle);
473: } else {
474: isc_time_settoepoch(&timer->idle);
475: result = ISC_R_SUCCESS;
476: }
477:
478: if (result == ISC_R_SUCCESS) {
479: if (type == isc_timertype_inactive) {
480: deschedule(timer);
481: result = ISC_R_SUCCESS;
482: } else
483: result = schedule(timer, &now, ISC_TRUE);
484: }
485:
486: UNLOCK(&timer->lock);
487: UNLOCK(&manager->lock);
488:
489: return (result);
490: }
491:
492: isc_timertype_t
493: isc_timer_gettype(isc_timer_t *timer) {
494: isc_timertype_t t;
495:
496: REQUIRE(VALID_TIMER(timer));
497:
498: LOCK(&timer->lock);
499: t = timer->type;
500: UNLOCK(&timer->lock);
501:
502: return (t);
503: }
504:
505: isc_result_t
506: isc_timer_touch(isc_timer_t *timer) {
507: isc_result_t result;
508: isc_time_t now;
509:
510: /*
511: * Set the last-touched time of 'timer' to the current time.
512: */
513:
514: REQUIRE(VALID_TIMER(timer));
515:
516: LOCK(&timer->lock);
517:
518: /*
519: * We'd like to
520: *
521: * REQUIRE(timer->type == isc_timertype_once);
522: *
523: * but we cannot without locking the manager lock too, which we
524: * don't want to do.
525: */
526:
527: TIME_NOW(&now);
528: result = isc_time_add(&now, &timer->interval, &timer->idle);
529:
530: UNLOCK(&timer->lock);
531:
532: return (result);
533: }
534:
535: void
536: isc_timer_attach(isc_timer_t *timer, isc_timer_t **timerp) {
537: /*
538: * Attach *timerp to timer.
539: */
540:
541: REQUIRE(VALID_TIMER(timer));
542: REQUIRE(timerp != NULL && *timerp == NULL);
543:
544: LOCK(&timer->lock);
545: timer->references++;
546: UNLOCK(&timer->lock);
547:
548: *timerp = timer;
549: }
550:
551: void
552: isc_timer_detach(isc_timer_t **timerp) {
553: isc_timer_t *timer;
554: isc_boolean_t free_timer = ISC_FALSE;
555:
556: /*
557: * Detach *timerp from its timer.
558: */
559:
560: REQUIRE(timerp != NULL);
561: timer = *timerp;
562: REQUIRE(VALID_TIMER(timer));
563:
564: LOCK(&timer->lock);
565: REQUIRE(timer->references > 0);
566: timer->references--;
567: if (timer->references == 0)
568: free_timer = ISC_TRUE;
569: UNLOCK(&timer->lock);
570:
571: if (free_timer)
572: destroy(timer);
573:
574: *timerp = NULL;
575: }
576:
577: static void
578: dispatch(isc_timermgr_t *manager, isc_time_t *now) {
579: isc_boolean_t done = ISC_FALSE, post_event, need_schedule;
580: isc_timerevent_t *event;
581: isc_eventtype_t type = 0;
582: isc_timer_t *timer;
583: isc_result_t result;
584: isc_boolean_t idle;
585:
586: /*!
587: * The caller must be holding the manager lock.
588: */
589:
590: while (manager->nscheduled > 0 && !done) {
591: timer = isc_heap_element(manager->heap, 1);
592: INSIST(timer->type != isc_timertype_inactive);
593: if (isc_time_compare(now, &timer->due) >= 0) {
594: if (timer->type == isc_timertype_ticker) {
595: type = ISC_TIMEREVENT_TICK;
596: post_event = ISC_TRUE;
597: need_schedule = ISC_TRUE;
598: } else if (timer->type == isc_timertype_limited) {
599: int cmp;
600: cmp = isc_time_compare(now, &timer->expires);
601: if (cmp >= 0) {
602: type = ISC_TIMEREVENT_LIFE;
603: post_event = ISC_TRUE;
604: need_schedule = ISC_FALSE;
605: } else {
606: type = ISC_TIMEREVENT_TICK;
607: post_event = ISC_TRUE;
608: need_schedule = ISC_TRUE;
609: }
610: } else if (!isc_time_isepoch(&timer->expires) &&
611: isc_time_compare(now,
612: &timer->expires) >= 0) {
613: type = ISC_TIMEREVENT_LIFE;
614: post_event = ISC_TRUE;
615: need_schedule = ISC_FALSE;
616: } else {
617: idle = ISC_FALSE;
618:
619: LOCK(&timer->lock);
620: if (!isc_time_isepoch(&timer->idle) &&
621: isc_time_compare(now,
622: &timer->idle) >= 0) {
623: idle = ISC_TRUE;
624: }
625: UNLOCK(&timer->lock);
626: if (idle) {
627: type = ISC_TIMEREVENT_IDLE;
628: post_event = ISC_TRUE;
629: need_schedule = ISC_FALSE;
630: } else {
631: /*
632: * Idle timer has been touched;
633: * reschedule.
634: */
635: XTRACEID(isc_msgcat_get(isc_msgcat,
636: ISC_MSGSET_TIMER,
637: ISC_MSG_IDLERESCHED,
638: "idle reschedule"),
639: timer);
640: post_event = ISC_FALSE;
641: need_schedule = ISC_TRUE;
642: }
643: }
644:
645: if (post_event) {
646: XTRACEID(isc_msgcat_get(isc_msgcat,
647: ISC_MSGSET_TIMER,
648: ISC_MSG_POSTING,
649: "posting"), timer);
650: /*
651: * XXX We could preallocate this event.
652: */
653: event = (isc_timerevent_t *)isc_event_allocate(manager->mctx,
654: timer,
655: type,
656: timer->action,
657: timer->arg,
658: sizeof(*event));
659:
660: if (event != NULL) {
661: event->due = timer->due;
662: isc_task_send(timer->task,
663: ISC_EVENT_PTR(&event));
664: } else
665: UNEXPECTED_ERROR(__FILE__, __LINE__, "%s",
666: isc_msgcat_get(isc_msgcat,
667: ISC_MSGSET_TIMER,
668: ISC_MSG_EVENTNOTALLOC,
669: "couldn't "
670: "allocate event"));
671: }
672:
673: timer->index = 0;
674: isc_heap_delete(manager->heap, 1);
675: manager->nscheduled--;
676:
677: if (need_schedule) {
678: result = schedule(timer, now, ISC_FALSE);
679: if (result != ISC_R_SUCCESS)
680: UNEXPECTED_ERROR(__FILE__, __LINE__,
681: "%s: %u",
682: isc_msgcat_get(isc_msgcat,
683: ISC_MSGSET_TIMER,
684: ISC_MSG_SCHEDFAIL,
685: "couldn't schedule "
686: "timer"),
687: result);
688: }
689: } else {
690: manager->due = timer->due;
691: done = ISC_TRUE;
692: }
693: }
694: }
695:
696: #ifdef ISC_PLATFORM_USETHREADS
697: static isc_threadresult_t
698: #ifdef _WIN32 /* XXXDCL */
699: WINAPI
700: #endif
701: run(void *uap) {
702: isc_timermgr_t *manager = uap;
703: isc_time_t now;
704: isc_result_t result;
705:
706: LOCK(&manager->lock);
707: while (!manager->done) {
708: TIME_NOW(&now);
709:
710: XTRACETIME(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
711: ISC_MSG_RUNNING,
712: "running"), now);
713:
714: dispatch(manager, &now);
715:
716: if (manager->nscheduled > 0) {
717: XTRACETIME2(isc_msgcat_get(isc_msgcat,
718: ISC_MSGSET_GENERAL,
719: ISC_MSG_WAITUNTIL,
720: "waituntil"),
721: manager->due, now);
722: result = WAITUNTIL(&manager->wakeup, &manager->lock, &manager->due);
723: INSIST(result == ISC_R_SUCCESS ||
724: result == ISC_R_TIMEDOUT);
725: } else {
726: XTRACETIME(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
727: ISC_MSG_WAIT, "wait"), now);
728: WAIT(&manager->wakeup, &manager->lock);
729: }
730: XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
731: ISC_MSG_WAKEUP, "wakeup"));
732: }
733: UNLOCK(&manager->lock);
734:
735: return ((isc_threadresult_t)0);
736: }
737: #endif /* ISC_PLATFORM_USETHREADS */
738:
739: static isc_boolean_t
740: sooner(void *v1, void *v2) {
741: isc_timer_t *t1, *t2;
742:
743: t1 = v1;
744: t2 = v2;
745: REQUIRE(VALID_TIMER(t1));
746: REQUIRE(VALID_TIMER(t2));
747:
748: if (isc_time_compare(&t1->due, &t2->due) < 0)
749: return (ISC_TRUE);
750: return (ISC_FALSE);
751: }
752:
753: static void
754: set_index(void *what, unsigned int index) {
755: isc_timer_t *timer;
756:
757: timer = what;
758: REQUIRE(VALID_TIMER(timer));
759:
760: timer->index = index;
761: }
762:
763: isc_result_t
764: isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
765: isc_timermgr_t *manager;
766: isc_result_t result;
767:
768: /*
769: * Create a timer manager.
770: */
771:
772: REQUIRE(managerp != NULL && *managerp == NULL);
773:
774: #ifndef ISC_PLATFORM_USETHREADS
775: if (timermgr != NULL) {
776: timermgr->refs++;
777: *managerp = timermgr;
778: return (ISC_R_SUCCESS);
779: }
780: #endif /* ISC_PLATFORM_USETHREADS */
781:
782: manager = isc_mem_get(mctx, sizeof(*manager));
783: if (manager == NULL)
784: return (ISC_R_NOMEMORY);
785:
786: manager->magic = TIMER_MANAGER_MAGIC;
787: manager->mctx = NULL;
788: manager->done = ISC_FALSE;
789: INIT_LIST(manager->timers);
790: manager->nscheduled = 0;
791: isc_time_settoepoch(&manager->due);
792: manager->heap = NULL;
793: result = isc_heap_create(mctx, sooner, set_index, 0, &manager->heap);
794: if (result != ISC_R_SUCCESS) {
795: INSIST(result == ISC_R_NOMEMORY);
796: isc_mem_put(mctx, manager, sizeof(*manager));
797: return (ISC_R_NOMEMORY);
798: }
799: result = isc_mutex_init(&manager->lock);
800: if (result != ISC_R_SUCCESS) {
801: isc_heap_destroy(&manager->heap);
802: isc_mem_put(mctx, manager, sizeof(*manager));
803: return (result);
804: }
805: isc_mem_attach(mctx, &manager->mctx);
806: #ifdef ISC_PLATFORM_USETHREADS
807: if (isc_condition_init(&manager->wakeup) != ISC_R_SUCCESS) {
808: isc_mem_detach(&manager->mctx);
809: DESTROYLOCK(&manager->lock);
810: isc_heap_destroy(&manager->heap);
811: isc_mem_put(mctx, manager, sizeof(*manager));
812: UNEXPECTED_ERROR(__FILE__, __LINE__,
813: "isc_condition_init() %s",
814: isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
815: ISC_MSG_FAILED, "failed"));
816: return (ISC_R_UNEXPECTED);
817: }
818: if (isc_thread_create(run, manager, &manager->thread) !=
819: ISC_R_SUCCESS) {
820: isc_mem_detach(&manager->mctx);
821: (void)isc_condition_destroy(&manager->wakeup);
822: DESTROYLOCK(&manager->lock);
823: isc_heap_destroy(&manager->heap);
824: isc_mem_put(mctx, manager, sizeof(*manager));
825: UNEXPECTED_ERROR(__FILE__, __LINE__,
826: "isc_thread_create() %s",
827: isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
828: ISC_MSG_FAILED, "failed"));
829: return (ISC_R_UNEXPECTED);
830: }
831: #else /* ISC_PLATFORM_USETHREADS */
832: manager->refs = 1;
833: timermgr = manager;
834: #endif /* ISC_PLATFORM_USETHREADS */
835:
836: *managerp = manager;
837:
838: return (ISC_R_SUCCESS);
839: }
840:
841: void
842: isc_timermgr_poke(isc_timermgr_t *manager) {
843: #ifdef ISC_PLATFORM_USETHREADS
844: REQUIRE(VALID_MANAGER(manager));
845:
846: SIGNAL(&manager->wakeup);
847: #else
848: UNUSED(manager);
849: #endif
850: }
851:
852: void
853: isc_timermgr_destroy(isc_timermgr_t **managerp) {
854: isc_timermgr_t *manager;
855: isc_mem_t *mctx;
856:
857: /*
858: * Destroy a timer manager.
859: */
860:
861: REQUIRE(managerp != NULL);
862: manager = *managerp;
863: REQUIRE(VALID_MANAGER(manager));
864:
865: LOCK(&manager->lock);
866:
867: #ifndef ISC_PLATFORM_USETHREADS
868: if (manager->refs > 1) {
869: manager->refs--;
870: UNLOCK(&manager->lock);
871: *managerp = NULL;
872: return;
873: }
874:
875: isc__timermgr_dispatch();
876: #endif /* ISC_PLATFORM_USETHREADS */
877:
878: REQUIRE(EMPTY(manager->timers));
879: manager->done = ISC_TRUE;
880:
881: #ifdef ISC_PLATFORM_USETHREADS
882: XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TIMER,
883: ISC_MSG_SIGNALDESTROY, "signal (destroy)"));
884: SIGNAL(&manager->wakeup);
885: #endif /* ISC_PLATFORM_USETHREADS */
886:
887: UNLOCK(&manager->lock);
888:
889: #ifdef ISC_PLATFORM_USETHREADS
890: /*
891: * Wait for thread to exit.
892: */
893: if (isc_thread_join(manager->thread, NULL) != ISC_R_SUCCESS)
894: UNEXPECTED_ERROR(__FILE__, __LINE__,
895: "isc_thread_join() %s",
896: isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
897: ISC_MSG_FAILED, "failed"));
898: #endif /* ISC_PLATFORM_USETHREADS */
899:
900: /*
901: * Clean up.
902: */
903: #ifdef ISC_PLATFORM_USETHREADS
904: (void)isc_condition_destroy(&manager->wakeup);
905: #endif /* ISC_PLATFORM_USETHREADS */
906: DESTROYLOCK(&manager->lock);
907: isc_heap_destroy(&manager->heap);
908: manager->magic = 0;
909: mctx = manager->mctx;
910: isc_mem_put(mctx, manager, sizeof(*manager));
911: isc_mem_detach(&mctx);
912:
913: *managerp = NULL;
914: }
915:
916: #ifndef ISC_PLATFORM_USETHREADS
917: isc_result_t
918: isc__timermgr_nextevent(isc_time_t *when) {
919: if (timermgr == NULL || timermgr->nscheduled == 0)
920: return (ISC_R_NOTFOUND);
921: *when = timermgr->due;
922: return (ISC_R_SUCCESS);
923: }
924:
925: void
926: isc__timermgr_dispatch(void) {
927: isc_time_t now;
928: if (timermgr == NULL)
929: return;
930: TIME_NOW(&now);
931: dispatch(timermgr, &now);
932: }
933: #endif /* ISC_PLATFORM_USETHREADS */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to timer.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc