![[BACK]](/icons/back.gif){kind=icon}
Return to timer.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / sys / kern|
Return to timer.c CVS log | Up to [local] / prex-old / sys / kern |
1.1 nbrk 1: /*-
2: * Copyright (c) 2005-2007, Kohsuke Ohtani
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. Neither the name of the author nor the names of any co-contributors
14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: */
29:
30: /*
31: * timer.c - kernel timer services.
32: */
33:
34: #include <kernel.h>
35: #include <task.h>
36: #include <event.h>
37: #include <timer.h>
38: #include <irq.h>
39: #include <sched.h>
40: #include <thread.h>
41: #include <kmem.h>
42: #include <exception.h>
43:
44: static volatile u_long lbolt; /* ticks elapsed since bootup */
45: static struct event timer_event; /* event to wakeup timer thread */
46: static struct event delay_event; /* event for the delay thread */
47: static struct list timer_list; /* list of active timers */
48: static struct list expire_list; /* list of expired timers */
49: static void (*tick_hook)(int); /* hook routine for timer tick */
50:
51: /*
52: * Macro to get a timer element for the next timer expiration.
53: */
54: #define timer_next() \
55: (list_entry(list_first(&timer_list), struct timer, link))
56:
57: /*
58: * Helper routine to get remaining ticks for the expiration time.
59: * Return 0 if time already passed.
60: */
61: static u_long
62: time_remain(u_long expire)
63: {
64:
65: if (time_before(lbolt, expire))
66: return expire - lbolt;
67: return 0;
68: }
69:
70: /*
71: * Add a timer element to the timer list, in the proper place.
72: * Requires interrupts to be disabled by the caller.
73: */
74: static void
75: timer_add(struct timer *tmr, u_long ticks)
76: {
77: list_t head, n;
78: struct timer *t;
79:
80: tmr->expire = lbolt + ticks;
81:
82: /*
83: * We sort the timer list by time. So, we can quickly
84: * get the next expiration time from the head element
85: * of the timer list.
86: */
87: head = &timer_list;
88: for (n = list_first(head); n != head; n = list_next(n)) {
89: t = list_entry(n, struct timer, link);
90: if (time_before(tmr->expire, t->expire))
91: break;
92: }
93: list_insert(list_prev(n), &tmr->link);
94: }
95:
96: /*
97: * Execute a function after a specified length of time.
98: * A device driver can call timer_callout() or timer_stop()
99: * from ISR at interrupt level.
100: */
101: void
102: timer_callout(struct timer *tmr, void (*func)(void *),
103: void *arg, u_long msec)
104: {
105: u_long ticks;
106:
107: ASSERT(tmr);
108:
109: ticks = msec_to_tick(msec);
110: if (ticks == 0)
111: ticks = 1;
112:
113: irq_lock();
114:
115: /*
116: * Stop timer if running
117: */
118: if (tmr->active)
119: list_remove(&tmr->link);
120: /*
121: * Program timer
122: */
123: tmr->func = func;
124: tmr->arg = arg;
125: tmr->active = 1;
126: tmr->interval = 0;
127: timer_add(tmr, ticks);
128:
129: irq_unlock();
130: }
131:
132: void
133: timer_stop(struct timer *tmr)
134: {
135: ASSERT(tmr);
136:
137: irq_lock();
138: if (tmr->active) {
139: list_remove(&tmr->link);
140: tmr->active = 0;
141: }
142: irq_unlock();
143: }
144:
145: /*
146: * timer_delay - delay thread execution.
147: * The caller thread is blocked for the specified time.
148: * Returns 0 on success, or the remaining time (msec) on failure.
149: * This service is not available at interrupt level.
150: */
151: u_long
152: timer_delay(u_long msec)
153: {
154: struct timer *tmr;
155: u_long remain = 0;
156: int rc;
157:
158: ASSERT(irq_level == 0);
159:
160: rc = sched_tsleep(&delay_event, msec);
161: if (rc != SLP_TIMEOUT) {
162: tmr = &cur_thread->timeout;
163: remain = tick_to_msec(time_remain(tmr->expire));
164: }
165: return remain;
166: }
167:
168: /*
169: * timer_sleep - sleep system call.
170: * @delay: delay time in milli-second
171: * @remain: remaining time returned if the sleep is interrupted.
172: *
173: * Stop execution of current thread for the indicated amount of time.
174: * Returns EINTR if sleep is canceled by some reasons.
175: */
176: int
177: timer_sleep(u_long delay, u_long *remain)
178: {
179: u_long msec;
180: int err = 0;
181:
182: msec = timer_delay(delay);
183:
184: if (remain != NULL)
185: err = umem_copyout(&msec, remain, sizeof(u_long));
186: if (err == 0 && msec > 0)
187: err = EINTR;
188: return err;
189: }
190:
191: /*
192: * Alarm timer expired:
193: * Send an alarm exception to the target task.
194: */
195: static void
196: alarm_expire(void *task)
197: {
198:
199: exception_post((task_t)task, SIGALRM);
200: }
201:
202: /*
203: * timer_alarm - schedule an alarm exception.
204: * @delay: delay time in milli-second. If delay is 0, stop timer.
205: * @remain: remaining time of the previous alarm request.
206: *
207: * SIGALRM is sent to the caller task when specified delay time
208: * is passed.
209: */
210: int
211: timer_alarm(u_long delay, u_long *remain)
212: {
213: struct timer *tmr;
214: u_long msec = 0;
215: int err = 0;
216:
217: irq_lock();
218: tmr = &cur_task()->alarm;
219: if (tmr->active) {
220: /*
221: * Save the remaining time before we update
222: * the timer value.
223: */
224: msec = tick_to_msec(time_remain(tmr->expire));
225: }
226: if (delay == 0) {
227: timer_stop(tmr);
228: } else {
229: timer_callout(tmr, alarm_expire, cur_task(), delay);
230: }
231: irq_unlock();
232:
233: if (remain != NULL)
234: err = umem_copyout(&msec, remain, sizeof(u_long));
235: return err;
236: }
237:
238: /*
239: * timer_periodic - set periodic timer for the specified thread.
240: * @th: thread to set timer.
241: * @start: first time to wakeup. set 0 to stop timer.
242: * @period: time interval to wakeup. This must be non-zero.
243: * (The unit of start/period is milli-seconds.)
244: *
245: * The periodic thread will wait the timer period by calling
246: * timer_waitperiod().
247: */
248: int
249: timer_periodic(thread_t th, u_long start, u_long period)
250: {
251: struct timer *tmr;
252: int err = 0;
253:
254: ASSERT(irq_level == 0);
255:
256: if (start != 0 && period == 0)
257: return EINVAL;
258:
259: sched_lock();
260: if (!thread_valid(th)) {
261: sched_unlock();
262: return ESRCH;
263: }
264: if (th->task != cur_task()) {
265: sched_unlock();
266: return EPERM;
267: }
268: tmr = th->periodic;
269: if (start == 0) {
270: if (tmr != NULL && tmr->active)
271: timer_stop(tmr);
272: else
273: err = EINVAL;
274: } else {
275: if (tmr == NULL) {
276: /*
277: * Allocate a timer element at first call. We
278: * don't put this data in the thread structure
279: * because only a few threads will use the
280: * periodic timer function.
281: */
282: tmr = kmem_alloc(sizeof(struct timer));
283: if (tmr == NULL) {
284: sched_unlock();
285: return ENOMEM;
286: }
287: event_init(&tmr->event, "periodic");
288: tmr->active = 1;
289: th->periodic = tmr;
290: }
291: /*
292: * Program an interval timer.
293: */
294: irq_lock();
295: tmr->interval = msec_to_tick(period);
296: if (tmr->interval == 0)
297: tmr->interval = 1;
298: timer_add(tmr, msec_to_tick(start));
299: irq_unlock();
300: }
301: sched_unlock();
302: return err;
303: }
304:
305:
306: /*
307: * timer_waitperiod - wait next period of the periodic timer.
308: *
309: * Since this routine can exit by any exceptions, the control may
310: * return at non-period time. So, the caller must retry immediately
311: * if the error status is EINTR. This will be automatically done
312: * by the library stub routine.
313: */
314: int
315: timer_waitperiod(void)
316: {
317: struct timer *tmr;
318: int rc, err = 0;
319:
320: ASSERT(irq_level == 0);
321:
322: if ((tmr = cur_thread->periodic) == NULL)
323: return EINVAL;
324:
325: if (time_before(lbolt, tmr->expire)) {
326: /*
327: * Sleep until timer_tick() routine wakes us up.
328: */
329: rc = sched_sleep(&tmr->event);
330: if (rc != SLP_SUCCESS)
331: err = EINTR;
332: }
333: return err;
334: }
335:
336: /*
337: * Clean up our resource for the thread termination.
338: */
339: void
340: timer_cleanup(thread_t th)
341: {
342: if (th->periodic != NULL) {
343: timer_stop(th->periodic);
344: kmem_free(th->periodic);
345: }
346: }
347:
348: int
349: timer_hook(void (*func)(int))
350: {
351:
352: if (tick_hook != NULL)
353: return -1;
354: irq_lock();
355: tick_hook = func;
356: irq_unlock();
357: return 0;
358: }
359:
360: /*
361: * Timer thread.
362: *
363: * Handle all expired timers. Each callout routine is called
364: * with scheduler locked and interrupts enabled.
365: */
366: static void
367: timer_thread(u_long unused)
368: {
369: struct timer *tmr;
370:
371: for (;;) {
372:
373: /* Wait until next timer expiration. */
374: sched_sleep(&timer_event);
375:
376: while (!list_empty(&expire_list)) {
377: /*
378: * Callout
379: */
380: tmr = list_entry(list_first(&expire_list),
381: struct timer, link);
382: list_remove(&tmr->link);
383: tmr->active = 0;
384: sched_lock();
385: interrupt_enable();
386: (*tmr->func)(tmr->arg);
387:
388: /*
389: * Unlock scheduler here in order to give
390: * chance to higher priority threads to run.
391: */
392: sched_unlock();
393: interrupt_disable();
394: }
395: }
396: /* NOTREACHED */
397: }
398:
399: /*
400: * Timer tick handler
401: *
402: * timer_tick() is called straight from the real time clock interrupt.
403: * All interrupts are still disabled at the entry of this routine.
404: */
405: void
406: timer_tick(void)
407: {
408: struct timer *tmr;
409: u_long ticks;
410: int idle, wakeup = 0;
411:
412: /* Bump time in ticks. */
413: lbolt++;
414:
415: /*
416: * Handle all of the timer elements that have expired.
417: */
418: while (!list_empty(&timer_list) &&
419: time_after_eq(lbolt, timer_next()->expire)) {
420: /*
421: * Remove an expired timer from the list and wakup
422: * the appropriate thread. If it is periodic timer,
423: * reprogram the next expiration time. Otherwize,
424: * it is moved to the expired list.
425: */
426: tmr = timer_next();
427: list_remove(&tmr->link);
428: if (tmr->interval != 0) {
429: /*
430: * Periodic timer
431: */
432: ticks = time_remain(tmr->expire + tmr->interval);
433: if (ticks == 0)
434: ticks = 1;
435: timer_add(tmr, ticks);
436: sched_wakeup(&tmr->event);
437: } else {
438: /*
439: * One-shot timer
440: */
441: list_insert(&expire_list, &tmr->link);
442: wakeup = 1;
443: }
444: }
445: if (wakeup)
446: sched_wakeup(&timer_event);
447:
448: sched_tick();
449:
450: /*
451: * Call a hook routine for power management or profiling work.
452: */
453: if (tick_hook != NULL) {
454: idle = (cur_thread->prio == PRIO_IDLE) ? 1 : 0;
455: tick_hook(idle);
456: }
457: }
458:
459: u_long
460: timer_count(void)
461: {
462:
463: return lbolt;
464: }
465:
466: void
467: timer_info(struct info_timer *info)
468: {
469:
470: info->hz = HZ;
471: }
472:
473: #if defined(DEBUG) && defined(CONFIG_KDUMP)
474: void
475: timer_dump(void)
476: {
477: struct timer *tmr;
478: list_t head, n;
479:
480: printk("Timer dump:\n");
481: printk("lbolt=%d\n", lbolt);
482:
483: head = &timer_list;
484: for (n = list_first(head); n != head; n = list_next(n)) {
485: tmr = list_entry(n, struct timer, link);
486: printk("timer=%x func=%x arg=%x expire=%d\n", (int)tmr,
487: (int)tmr->func, (int)tmr->arg, (int)tmr->expire);
488: }
489: }
490: #endif
491:
492: /*
493: * Initialize the timer facility, called at system startup time.
494: */
495: void
496: timer_init(void)
497: {
498:
499: list_init(&timer_list);
500: list_init(&expire_list);
501: event_init(&timer_event, "timer");
502: event_init(&delay_event, "delay");
503:
504: /*
505: * Start timer thread
506: */
507: if (kernel_thread(PRIO_TIMER, timer_thread, 0) == NULL)
508: panic("timer_init");
509: }