2 * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * $DragonFly: src/sys/kern/kern_systimer.c,v 1.12 2007/10/16 11:12:59 sephe Exp $
38 * WARNING! THE SYSTIMER MODULE DOES NOT OPERATE OR DISPATCH WITH THE
39 * MP LOCK HELD. ALL CODE USING THIS MODULE MUST BE MP-SAFE.
41 * This code implements a fine-grained per-cpu system timer which is
42 * ultimately based on a hardware timer. The hardware timer abstraction
43 * is sufficiently disconnected from this code to support both per-cpu
44 * hardware timers or a single system-wide hardware timer.
46 * WARNING! During early boot if a new system timer is selected, existing
47 * timeouts will not be effected and will thus occur slower or faster.
48 * periodic timers will be adjusted at the next periodic load.
50 * Notes on machine-dependant code (in arch/arch/systimer.c)
52 * cputimer_intr_reload() Reload the one-shot (per-cpu basis)
55 #include <sys/param.h>
56 #include <sys/kernel.h>
57 #include <sys/systm.h>
58 #include <sys/thread.h>
59 #include <sys/globaldata.h>
60 #include <sys/systimer.h>
61 #include <sys/thread2.h>
64 * Execute ready systimers. Called directly from the platform-specific
65 * one-shot timer clock interrupt (e.g. clkintr()) or via an IPI. May
66 * be called simultaniously on multiple cpus and always operations on
67 * the current cpu's queue. Systimer functions are responsible for calling
68 * hardclock, statclock, and other finely-timed routines.
71 systimer_intr(sysclock_t *timep, int dummy, struct intrframe *frame)
73 globaldata_t gd = mycpu;
74 sysclock_t time = *timep;
82 while ((info = TAILQ_FIRST(&gd->gd_systimerq)) != NULL) {
84 * If we haven't reached the requested time, tell the cputimer
85 * how much is left and break out.
87 if ((int)(info->time - time) > 0) {
88 cputimer_intr_reload(info->time - time);
93 * Dequeue and execute, detect a loss of the systimer. Note
94 * that the in-progress systimer pointer can only be used to
95 * detect a loss of the systimer, it is only useful within
96 * this code sequence and becomes stale otherwise.
98 info->flags &= ~SYSTF_ONQUEUE;
99 TAILQ_REMOVE(info->queue, info, node);
100 gd->gd_systimer_inprog = info;
102 info->func(info, frame);
106 * The caller may deleted or even re-queue the systimer itself
107 * with a delete/add sequence. If the caller does not mess with
108 * the systimer we will requeue the periodic interval automatically.
110 * If this is a non-queued periodic interrupt, do not allow multiple
111 * events to build up (used for things like the callout timer to
112 * prevent premature timeouts due to long interrupt disablements,
113 * BIOS 8254 glitching, and so forth). However, we still want to
114 * keep things synchronized between cpus for efficient handling of
115 * the timer interrupt so jump in multiples of the periodic rate.
117 if (gd->gd_systimer_inprog == info && info->periodic) {
118 if (info->which != sys_cputimer) {
119 info->periodic = sys_cputimer->fromhz(info->freq);
120 info->which = sys_cputimer;
122 info->time += info->periodic;
123 if ((info->flags & SYSTF_NONQUEUED) &&
124 (int)(info->time - time) <= 0
126 info->time += ((time - info->time + info->periodic - 1) /
127 info->periodic) * info->periodic;
131 gd->gd_systimer_inprog = NULL;
138 systimer_intr_enable(void)
140 cputimer_intr_enable();
147 systimer_add(systimer_t info)
149 struct globaldata *gd = mycpu;
151 KKASSERT((info->flags & SYSTF_ONQUEUE) == 0);
153 if (info->gd == gd) {
156 scan1 = TAILQ_FIRST(&gd->gd_systimerq);
157 if (scan1 == NULL || (int)(scan1->time - info->time) > 0) {
158 cputimer_intr_reload(info->time - sys_cputimer->count());
159 TAILQ_INSERT_HEAD(&gd->gd_systimerq, info, node);
161 scan2 = TAILQ_LAST(&gd->gd_systimerq, systimerq);
164 TAILQ_INSERT_TAIL(&gd->gd_systimerq, info, node);
167 if ((int)(scan1->time - info->time) > 0) {
168 TAILQ_INSERT_BEFORE(scan1, info, node);
171 if ((int)(scan2->time - info->time) <= 0) {
172 TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, info, node);
175 scan1 = TAILQ_NEXT(scan1, node);
176 scan2 = TAILQ_PREV(scan2, systimerq, node);
179 info->flags = (info->flags | SYSTF_ONQUEUE) & ~SYSTF_IPIRUNNING;
180 info->queue = &gd->gd_systimerq;
183 KKASSERT((info->flags & SYSTF_IPIRUNNING) == 0);
184 info->flags |= SYSTF_IPIRUNNING;
185 lwkt_send_ipiq(info->gd, (ipifunc1_t)systimer_add, info);
187 panic("systimer_add: bad gd in info %p", info);
196 * Delete a system timer. Only the owning cpu can delete a timer.
201 systimer_del(systimer_t info)
203 struct globaldata *gd = info->gd;
205 KKASSERT(gd == mycpu && (info->flags & SYSTF_IPIRUNNING) == 0);
209 if (info->flags & SYSTF_ONQUEUE) {
210 TAILQ_REMOVE(info->queue, info, node);
211 info->flags &= ~SYSTF_ONQUEUE;
215 * Deal with dispatch races by clearing the in-progress systimer
216 * pointer. Only a direct pointer comparison can be used, the
217 * actual contents of the structure gd_systimer_inprog points to,
218 * if not equal to info, may be stale.
220 if (gd->gd_systimer_inprog == info)
221 gd->gd_systimer_inprog = NULL;
227 * systimer_init_periodic()
229 * Initialize a periodic timer at the specified frequency and add
230 * it to the system. The frequency is uncompensated and approximate.
232 * Try to synchronize multi registrations of the same or similar
233 * frequencies so the hardware interrupt is able to dispatch several
234 * at together by adjusting the phase of the initial interrupt. This
235 * helps SMP. Note that we are not attempting to synchronize to
236 * the realtime clock.
239 systimer_init_periodic(systimer_t info, void *func, void *data, int hz)
241 sysclock_t base_count;
243 bzero(info, sizeof(struct systimer));
244 info->periodic = sys_cputimer->fromhz(hz);
245 base_count = sys_cputimer->count();
246 base_count = base_count - (base_count % info->periodic);
247 info->time = base_count + info->periodic;
251 info->which = sys_cputimer;
257 systimer_init_periodic_nq(systimer_t info, void *func, void *data, int hz)
259 sysclock_t base_count;
261 bzero(info, sizeof(struct systimer));
262 info->periodic = sys_cputimer->fromhz(hz);
263 base_count = sys_cputimer->count();
264 base_count = base_count - (base_count % info->periodic);
265 info->time = base_count + info->periodic;
269 info->which = sys_cputimer;
271 info->flags |= SYSTF_NONQUEUED;
276 * Adjust the periodic interval for a periodic timer which is already
277 * running. The current timeout is not effected.
280 systimer_adjust_periodic(systimer_t info, int hz)
283 info->periodic = sys_cputimer->fromhz(hz);
285 info->which = sys_cputimer;
290 * systimer_init_oneshot()
292 * Initialize a periodic timer at the specified frequency and add
293 * it to the system. The frequency is uncompensated and approximate.
296 systimer_init_oneshot(systimer_t info, void *func, void *data, int us)
298 bzero(info, sizeof(struct systimer));
299 info->time = sys_cputimer->count() + sys_cputimer->fromus(us);
302 info->which = sys_cputimer;