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.10 2007/04/30 07:18:54 dillon 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
);
95 info
->flags
&= ~SYSTF_ONQUEUE
;
96 TAILQ_REMOVE(info
->queue
, info
, node
);
98 info
->func(info
, frame
);
102 * Reinstall if periodic. If this is a non-queued periodic
103 * interrupt do not allow multiple events to build up (used
104 * for things like the callout timer to prevent premature timeouts
105 * due to long interrupt disablements, BIOS 8254 glitching, and so
106 * forth). However, we still want to keep things synchronized between
107 * cpus for efficient handling of the timer interrupt so jump in
108 * multiples of the periodic rate.
110 if (info
->periodic
) {
111 if (info
->which
!= sys_cputimer
) {
112 info
->periodic
= sys_cputimer
->fromhz(info
->freq
);
113 info
->which
= sys_cputimer
;
115 info
->time
+= info
->periodic
;
116 if ((info
->flags
& SYSTF_NONQUEUED
) &&
117 (int)(info
->time
- time
) <= 0
119 info
->time
+= ((time
- info
->time
+ info
->periodic
- 1) /
120 info
->periodic
) * info
->periodic
;
130 systimer_add(systimer_t info
)
132 struct globaldata
*gd
= mycpu
;
134 KKASSERT((info
->flags
& (SYSTF_ONQUEUE
|SYSTF_IPIRUNNING
)) == 0);
136 if (info
->gd
== gd
) {
139 scan1
= TAILQ_FIRST(&gd
->gd_systimerq
);
140 if (scan1
== NULL
|| (int)(scan1
->time
- info
->time
) > 0) {
141 cputimer_intr_reload(info
->time
- sys_cputimer
->count());
142 TAILQ_INSERT_HEAD(&gd
->gd_systimerq
, info
, node
);
144 scan2
= TAILQ_LAST(&gd
->gd_systimerq
, systimerq
);
147 TAILQ_INSERT_TAIL(&gd
->gd_systimerq
, info
, node
);
150 if ((int)(scan1
->time
- info
->time
) > 0) {
151 TAILQ_INSERT_BEFORE(scan1
, info
, node
);
154 if ((int)(scan2
->time
- info
->time
) <= 0) {
155 TAILQ_INSERT_AFTER(&gd
->gd_systimerq
, scan2
, info
, node
);
158 scan1
= TAILQ_NEXT(scan1
, node
);
159 scan2
= TAILQ_PREV(scan2
, systimerq
, node
);
162 info
->flags
= (info
->flags
| SYSTF_ONQUEUE
) & ~SYSTF_IPIRUNNING
;
163 info
->queue
= &gd
->gd_systimerq
;
166 info
->flags
|= SYSTF_IPIRUNNING
;
167 lwkt_send_ipiq(info
->gd
, (ipifunc1_t
)systimer_add
, info
);
169 panic("systimer_add: bad gd in info %p", info
);
178 * Delete a system timer. Only the owning cpu can delete a timer.
181 systimer_del(systimer_t info
)
183 KKASSERT(info
->gd
== mycpu
&& (info
->flags
& SYSTF_IPIRUNNING
) == 0);
185 if (info
->flags
& SYSTF_ONQUEUE
) {
186 TAILQ_REMOVE(info
->queue
, info
, node
);
187 info
->flags
&= ~SYSTF_ONQUEUE
;
193 * systimer_init_periodic()
195 * Initialize a periodic timer at the specified frequency and add
196 * it to the system. The frequency is uncompensated and approximate.
198 * Try to synchronize multi registrations of the same or similar
199 * frequencies so the hardware interrupt is able to dispatch several
200 * at together by adjusting the phase of the initial interrupt. This
201 * helps SMP. Note that we are not attempting to synchronize to
202 * the realtime clock.
205 systimer_init_periodic(systimer_t info
, void *func
, void *data
, int hz
)
207 sysclock_t base_count
;
209 bzero(info
, sizeof(struct systimer
));
210 info
->periodic
= sys_cputimer
->fromhz(hz
);
211 base_count
= sys_cputimer
->count();
212 base_count
= base_count
- (base_count
% info
->periodic
);
213 info
->time
= base_count
+ info
->periodic
;
217 info
->which
= sys_cputimer
;
223 systimer_init_periodic_nq(systimer_t info
, void *func
, void *data
, int hz
)
225 sysclock_t base_count
;
227 bzero(info
, sizeof(struct systimer
));
228 info
->periodic
= sys_cputimer
->fromhz(hz
);
229 base_count
= sys_cputimer
->count();
230 base_count
= base_count
- (base_count
% info
->periodic
);
231 info
->time
= base_count
+ info
->periodic
;
235 info
->which
= sys_cputimer
;
237 info
->flags
|= SYSTF_NONQUEUED
;
242 * Adjust the periodic interval for a periodic timer which is already
243 * running. The current timeout is not effected.
246 systimer_adjust_periodic(systimer_t info
, int hz
)
249 info
->periodic
= sys_cputimer
->fromhz(hz
);
251 info
->which
= sys_cputimer
;
256 * systimer_init_oneshot()
258 * Initialize a periodic timer at the specified frequency and add
259 * it to the system. The frequency is uncompensated and approximate.
262 systimer_init_oneshot(systimer_t info
, void *func
, void *data
, int us
)
264 bzero(info
, sizeof(struct systimer
));
265 info
->time
= sys_cputimer
->count() + sys_cputimer
->fromus(us
);
268 info
->which
= sys_cputimer
;