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.5 2004/11/20 20:25:09 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 * Notes on machine-dependant code (in arch/arch/systimer.c) 47 * 48 * cputimer_intr_reload() Reload the one-shot (per-cpu basis) 49 * 50 * cputimer_count() Get the current absolute sysclock_t value. 51 */ 52 53 #include <sys/param.h> 54 #include <sys/kernel.h> 55 #include <sys/systm.h> 56 #include <sys/thread.h> 57 #include <sys/globaldata.h> 58 #include <sys/systimer.h> 59 #include <sys/thread2.h> 60 61 /* 62 * Execute ready systimers. Called directly from the platform-specific 63 * one-shot timer clock interrupt (e.g. clkintr()). Systimer functions are 64 * responsible for calling hardclock, statclock, and other finely-timed 65 * routines. 66 */ 67 void 68 systimer_intr(sysclock_t *timep, struct intrframe *frame) 69 { 70 globaldata_t gd = mycpu; 71 sysclock_t time = *timep; 72 systimer_t info; 73 74 if (gd->gd_syst_nest) 75 return; 76 77 crit_enter(); 78 ++gd->gd_syst_nest; 79 while ((info = TAILQ_FIRST(&gd->gd_systimerq)) != NULL) { 80 /* 81 * If we haven't reached the requested time, tell the cputimer 82 * how much is left and break out. 83 */ 84 if ((int)(info->time - time) > 0) { 85 cputimer_intr_reload(info->time - time); 86 break; 87 } 88 89 /* 90 * Dequeue and execute 91 */ 92 info->flags &= ~SYSTF_ONQUEUE; 93 TAILQ_REMOVE(info->queue, info, node); 94 crit_exit(); 95 info->func(info, frame); 96 crit_enter(); 97 98 /* 99 * Reinstall if periodic. If this is a non-queued periodic 100 * interrupt do not allow multiple events to build up (used 101 * for things like the callout timer to prevent premature timeouts 102 * due to long interrupt disablements, BIOS 8254 glitching, and so 103 * forth). However, we still want to keep things synchronized between 104 * cpus for efficient handling of the timer interrupt so jump in 105 * multiples of the periodic rate. 106 */ 107 if (info->periodic) { 108 info->time += info->periodic; 109 if ((info->flags & SYSTF_NONQUEUED) && 110 (int)(info->time - time) <= 0 111 ) { 112 info->time += ((time - info->time + info->periodic - 1) / 113 info->periodic) * info->periodic; 114 } 115 systimer_add(info); 116 } 117 } 118 if (info) 119 gd->gd_nextclock = info->time; 120 else 121 gd->gd_nextclock = 0; 122 --gd->gd_syst_nest; 123 crit_exit(); 124 } 125 126 void 127 systimer_add(systimer_t info) 128 { 129 struct globaldata *gd = mycpu; 130 131 KKASSERT((info->flags & (SYSTF_ONQUEUE|SYSTF_IPIRUNNING)) == 0); 132 crit_enter(); 133 if (info->gd == gd) { 134 systimer_t scan1; 135 systimer_t scan2; 136 scan1 = TAILQ_FIRST(&gd->gd_systimerq); 137 if (scan1 == NULL || (int)(scan1->time - info->time) > 0) { 138 gd->gd_nextclock = info->time; 139 cputimer_intr_reload(info->time - cputimer_count()); 140 TAILQ_INSERT_HEAD(&gd->gd_systimerq, info, node); 141 } else { 142 scan2 = TAILQ_LAST(&gd->gd_systimerq, systimerq); 143 for (;;) { 144 if (scan1 == NULL) { 145 TAILQ_INSERT_TAIL(&gd->gd_systimerq, info, node); 146 break; 147 } 148 if ((int)(scan1->time - info->time) > 0) { 149 TAILQ_INSERT_BEFORE(scan1, info, node); 150 break; 151 } 152 if ((int)(scan2->time - info->time) <= 0) { 153 TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, info, node); 154 break; 155 } 156 scan1 = TAILQ_NEXT(scan1, node); 157 scan2 = TAILQ_PREV(scan2, systimerq, node); 158 } 159 } 160 info->flags = (info->flags | SYSTF_ONQUEUE) & ~SYSTF_IPIRUNNING; 161 info->queue = &gd->gd_systimerq; 162 } else { 163 info->flags |= SYSTF_IPIRUNNING; 164 lwkt_send_ipiq(info->gd, (ipifunc_t)systimer_add, info); 165 } 166 crit_exit(); 167 } 168 169 /* 170 * systimer_del() 171 * 172 * Delete a system timer. Only the owning cpu can delete a timer. 173 */ 174 void 175 systimer_del(systimer_t info) 176 { 177 KKASSERT(info->gd == mycpu && (info->flags & SYSTF_IPIRUNNING) == 0); 178 crit_enter(); 179 if (info->flags & SYSTF_ONQUEUE) { 180 TAILQ_REMOVE(info->queue, info, node); 181 info->flags &= ~SYSTF_ONQUEUE; 182 } 183 crit_exit(); 184 } 185 186 /* 187 * systimer_init_periodic() 188 * 189 * Initialize a periodic timer at the specified frequency and add 190 * it to the system. The frequency is uncompensated and approximate. 191 * 192 * Try to synchronize multi registrations of the same or similar 193 * frequencies so the hardware interrupt is able to dispatch several 194 * at together by adjusting the phase of the initial interrupt. This 195 * helps SMP. Note that we are not attempting to synchronize to 196 * the realtime clock. 197 */ 198 void 199 systimer_init_periodic(systimer_t info, void *func, void *data, int hz) 200 { 201 sysclock_t base_count; 202 203 bzero(info, sizeof(struct systimer)); 204 info->periodic = cputimer_fromhz(hz); 205 base_count = cputimer_count(); 206 base_count = base_count - (base_count % info->periodic); 207 info->time = base_count + info->periodic; 208 info->func = func; 209 info->data = data; 210 info->gd = mycpu; 211 systimer_add(info); 212 } 213 214 void 215 systimer_init_periodic_nq(systimer_t info, void *func, void *data, int hz) 216 { 217 sysclock_t base_count; 218 219 bzero(info, sizeof(struct systimer)); 220 info->periodic = cputimer_fromhz(hz); 221 base_count = cputimer_count(); 222 base_count = base_count - (base_count % info->periodic); 223 info->time = base_count + info->periodic; 224 info->func = func; 225 info->data = data; 226 info->gd = mycpu; 227 info->flags |= SYSTF_NONQUEUED; 228 systimer_add(info); 229 } 230 231 /* 232 * systimer_init_oneshot() 233 * 234 * Initialize a periodic timer at the specified frequency and add 235 * it to the system. The frequency is uncompensated and approximate. 236 */ 237 void 238 systimer_init_oneshot(systimer_t info, void *func, void *data, int us) 239 { 240 bzero(info, sizeof(struct systimer)); 241 info->time = cputimer_count() + cputimer_fromus(us); 242 info->func = func; 243 info->data = data; 244 info->gd = mycpu; 245 systimer_add(info); 246 } 247 248