Merge from vendor branch LIBPCAP:
[dragonfly.git] / sys / kern / kern_systimer.c
1 /*
2  * Copyright (c) 2003,2004 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
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
16  *    distribution.
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.
20  * 
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
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sys/kern/kern_systimer.c,v 1.10 2007/04/30 07:18:54 dillon Exp $
35  */
36
37 /*
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.
40  *
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.
45  *
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.
49  *
50  * Notes on machine-dependant code (in arch/arch/systimer.c)
51  *
52  * cputimer_intr_reload()       Reload the one-shot (per-cpu basis)
53  */
54
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>
62
63 /*
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.
69  */
70 void
71 systimer_intr(sysclock_t *timep, int dummy, struct intrframe *frame)
72 {
73     globaldata_t gd = mycpu;
74     sysclock_t time = *timep;
75     systimer_t info;
76
77     if (gd->gd_syst_nest)
78         return;
79
80     crit_enter();
81     ++gd->gd_syst_nest;
82     while ((info = TAILQ_FIRST(&gd->gd_systimerq)) != NULL) {
83         /*
84          * If we haven't reached the requested time, tell the cputimer
85          * how much is left and break out.
86          */
87         if ((int)(info->time - time) > 0) {
88             cputimer_intr_reload(info->time - time);
89             break;
90         }
91
92         /*
93          * Dequeue and execute
94          */
95         info->flags &= ~SYSTF_ONQUEUE;
96         TAILQ_REMOVE(info->queue, info, node);
97         crit_exit();
98         info->func(info, frame);
99         crit_enter();
100
101         /*
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.
109          */
110         if (info->periodic) {
111             if (info->which != sys_cputimer) {
112                 info->periodic = sys_cputimer->fromhz(info->freq);
113                 info->which = sys_cputimer;
114             }
115             info->time += info->periodic;
116             if ((info->flags & SYSTF_NONQUEUED) &&
117                 (int)(info->time - time) <= 0
118             ) {
119                 info->time += ((time - info->time + info->periodic - 1) / 
120                                 info->periodic) * info->periodic;
121             }
122             systimer_add(info);
123         }
124     }
125     --gd->gd_syst_nest;
126     crit_exit();
127 }
128
129 void
130 systimer_add(systimer_t info)
131 {
132     struct globaldata *gd = mycpu;
133
134     KKASSERT((info->flags & (SYSTF_ONQUEUE|SYSTF_IPIRUNNING)) == 0);
135     crit_enter();
136     if (info->gd == gd) {
137         systimer_t scan1;
138         systimer_t scan2;
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);
143         } else {
144             scan2 = TAILQ_LAST(&gd->gd_systimerq, systimerq);
145             for (;;) {
146                 if (scan1 == NULL) {
147                     TAILQ_INSERT_TAIL(&gd->gd_systimerq, info, node);
148                     break;
149                 }
150                 if ((int)(scan1->time - info->time) > 0) {
151                     TAILQ_INSERT_BEFORE(scan1, info, node);
152                     break;
153                 }
154                 if ((int)(scan2->time - info->time) <= 0) {
155                     TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, info, node);
156                     break;
157                 }
158                 scan1 = TAILQ_NEXT(scan1, node);
159                 scan2 = TAILQ_PREV(scan2, systimerq, node);
160             }
161         }
162         info->flags = (info->flags | SYSTF_ONQUEUE) & ~SYSTF_IPIRUNNING;
163         info->queue = &gd->gd_systimerq;
164     } else {
165 #ifdef SMP
166         info->flags |= SYSTF_IPIRUNNING;
167         lwkt_send_ipiq(info->gd, (ipifunc1_t)systimer_add, info);
168 #else
169         panic("systimer_add: bad gd in info %p", info);
170 #endif
171     }
172     crit_exit();
173 }
174
175 /*
176  * systimer_del()
177  *
178  *      Delete a system timer.  Only the owning cpu can delete a timer.
179  */
180 void
181 systimer_del(systimer_t info)
182 {
183     KKASSERT(info->gd == mycpu && (info->flags & SYSTF_IPIRUNNING) == 0);
184     crit_enter();
185     if (info->flags & SYSTF_ONQUEUE) {
186         TAILQ_REMOVE(info->queue, info, node);
187         info->flags &= ~SYSTF_ONQUEUE;
188     }
189     crit_exit();
190 }
191
192 /*
193  * systimer_init_periodic()
194  *
195  *      Initialize a periodic timer at the specified frequency and add
196  *      it to the system.  The frequency is uncompensated and approximate.
197  *
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.
203  */
204 void
205 systimer_init_periodic(systimer_t info, void *func, void *data, int hz)
206 {
207     sysclock_t base_count;
208
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;
214     info->func = func;
215     info->data = data;
216     info->freq = hz;
217     info->which = sys_cputimer;
218     info->gd = mycpu;
219     systimer_add(info);
220 }
221
222 void
223 systimer_init_periodic_nq(systimer_t info, void *func, void *data, int hz)
224 {
225     sysclock_t base_count;
226
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;
232     info->func = func;
233     info->data = data;
234     info->freq = hz;
235     info->which = sys_cputimer;
236     info->gd = mycpu;
237     info->flags |= SYSTF_NONQUEUED;
238     systimer_add(info);
239 }
240
241 /*
242  * Adjust the periodic interval for a periodic timer which is already
243  * running.  The current timeout is not effected.
244  */
245 void
246 systimer_adjust_periodic(systimer_t info, int hz)
247 {
248     crit_enter();
249     info->periodic = sys_cputimer->fromhz(hz);
250     info->freq = hz;
251     info->which = sys_cputimer;
252     crit_exit();
253 }
254
255 /*
256  * systimer_init_oneshot()
257  *
258  *      Initialize a periodic timer at the specified frequency and add
259  *      it to the system.  The frequency is uncompensated and approximate.
260  */
261 void
262 systimer_init_oneshot(systimer_t info, void *func, void *data, int us)
263 {
264     bzero(info, sizeof(struct systimer));
265     info->time = sys_cputimer->count() + sys_cputimer->fromus(us);
266     info->func = func;
267     info->data = data;
268     info->which = sys_cputimer;
269     info->gd = mycpu;
270     systimer_add(info);
271 }
272