/* * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved. * * This code is derived from software contributed to The DragonFly Project * by Matthew Dillon * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * 3. Neither the name of The DragonFly Project nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific, prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * WARNING! THE SYSTIMER MODULE DOES NOT OPERATE OR DISPATCH WITH THE * MP LOCK HELD. ALL CODE USING THIS MODULE MUST BE MP-SAFE. * * This code implements a fine-grained per-cpu system timer which is * ultimately based on a hardware timer. The hardware timer abstraction * is sufficiently disconnected from this code to support both per-cpu * hardware timers or a single system-wide hardware timer. * * WARNING! During early boot if a new system timer is selected, existing * timeouts will not be effected and will thus occur slower or faster. * periodic timers will be adjusted at the next periodic load. * * Notes on machine-dependant code (in arch/arch/systimer.c) * * cputimer_intr_reload() Reload the one-shot (per-cpu basis) */ #include #include #include #include #include #include #include /* * Execute ready systimers. Called directly from the platform-specific * one-shot timer clock interrupt (e.g. clkintr()) or via an IPI. May * be called simultaniously on multiple cpus and always operations on * the current cpu's queue. Systimer functions are responsible for calling * hardclock, statclock, and other finely-timed routines. */ void systimer_intr(sysclock_t *timep, int in_ipi, struct intrframe *frame) { globaldata_t gd = mycpu; sysclock_t time = *timep; systimer_t info; if (gd->gd_syst_nest) return; crit_enter(); ++gd->gd_syst_nest; while ((info = TAILQ_FIRST(&gd->gd_systimerq)) != NULL) { /* * If we haven't reached the requested time, tell the cputimer * how much is left and break out. */ if ((ssysclock_t)(info->time - time) > 0) { cputimer_intr_reload(info->time - time); break; } /* * Dequeue and execute, detect a loss of the systimer. Note * that the in-progress systimer pointer can only be used to * detect a loss of the systimer, it is only useful within * this code sequence and becomes stale otherwise. */ info->flags &= ~SYSTF_ONQUEUE; TAILQ_REMOVE(info->queue, info, node); gd->gd_systimer_inprog = info; crit_exit(); info->func(info, in_ipi, frame); crit_enter(); /* * The caller may deleted or even re-queue the systimer itself * with a delete/add sequence. If the caller does not mess with * the systimer we will requeue the periodic interval automatically. * * If this is a non-queued periodic interrupt, do not allow multiple * events to build up (used for things like the callout timer to * prevent premature timeouts due to long interrupt disablements, * BIOS 8254 glitching, and so forth). However, we still want to * keep things synchronized between cpus for efficient handling of * the timer interrupt so jump in multiples of the periodic rate. */ if (gd->gd_systimer_inprog == info && info->periodic) { if (info->which != sys_cputimer) { info->periodic = sys_cputimer->fromhz(info->freq); info->which = sys_cputimer; } info->time += info->periodic; if ((info->flags & SYSTF_NONQUEUED) && (ssysclock_t)(info->time - time) <= 0 ) { info->time += roundup(time - info->time, info->periodic); } systimer_add(info); } gd->gd_systimer_inprog = NULL; } --gd->gd_syst_nest; crit_exit(); } void systimer_intr_enable(void) { cputimer_intr_enable(); } /* * MPSAFE */ void systimer_add(systimer_t info) { struct globaldata *gd = mycpu; KKASSERT((info->flags & SYSTF_ONQUEUE) == 0); crit_enter(); if (info->gd == gd) { systimer_t scan1; systimer_t scan2; scan1 = TAILQ_FIRST(&gd->gd_systimerq); if (scan1 == NULL || (ssysclock_t)(scan1->time - info->time) > 0) { cputimer_intr_reload(info->time - sys_cputimer->count()); TAILQ_INSERT_HEAD(&gd->gd_systimerq, info, node); } else { scan2 = TAILQ_LAST(&gd->gd_systimerq, systimerq); for (;;) { if (scan1 == NULL) { TAILQ_INSERT_TAIL(&gd->gd_systimerq, info, node); break; } if (info->flags & SYSTF_FIRST) { /* * When coincident events occur, the event being * added wants to be placed before the others. */ if ((ssysclock_t)(scan1->time - info->time) >= 0) { TAILQ_INSERT_BEFORE(scan1, info, node); break; } if ((ssysclock_t)(scan2->time - info->time) < 0) { TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, info, node); break; } } else { /* * When coincident events occur, the event being * added should be placed after the others. This * is the default. */ if ((ssysclock_t)(scan1->time - info->time) > 0) { TAILQ_INSERT_BEFORE(scan1, info, node); break; } if ((ssysclock_t)(scan2->time - info->time) <= 0) { TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, info, node); break; } } scan1 = TAILQ_NEXT(scan1, node); scan2 = TAILQ_PREV(scan2, systimerq, node); } } info->flags = (info->flags | SYSTF_ONQUEUE) & ~SYSTF_IPIRUNNING; info->queue = &gd->gd_systimerq; } else { KKASSERT((info->flags & SYSTF_IPIRUNNING) == 0); info->flags |= SYSTF_IPIRUNNING; lwkt_send_ipiq(info->gd, (ipifunc1_t)systimer_add, info); } crit_exit(); } /* * systimer_del() * * Delete a system timer. Only the owning cpu can delete a timer. * * MPSAFE */ void systimer_del(systimer_t info) { struct globaldata *gd = info->gd; KKASSERT(gd == mycpu && (info->flags & SYSTF_IPIRUNNING) == 0); crit_enter(); if (info->flags & SYSTF_ONQUEUE) { TAILQ_REMOVE(info->queue, info, node); info->flags &= ~SYSTF_ONQUEUE; } /* * Deal with dispatch races by clearing the in-progress systimer * pointer. Only a direct pointer comparison can be used, the * actual contents of the structure gd_systimer_inprog points to, * if not equal to info, may be stale. */ if (gd->gd_systimer_inprog == info) gd->gd_systimer_inprog = NULL; crit_exit(); } /* * systimer_init_periodic*() * * Initialize a periodic timer at the specified frequency and add * it to the system. The frequency is uncompensated and approximate. * * Try to synchronize multiple registrations of the same or similar * frequencies so the hardware interrupt is able to dispatch several * together. We do this by adjusting the phase of the initial timeout. * This helps SMP. Note that we are not attempting to synchronize to * the realtime clock. * * This synchronization is also depended upon for statclock, hardclock, * and schedclock. */ static __inline void _systimer_init_periodic(systimer_t info, systimer_func_t func, void *data, int64_t freq, int flags) { sysclock_t base_count; if (sys_cputimer->sync_base == 0) sys_cputimer->sync_base = sys_cputimer->count(); bzero(info, sizeof(struct systimer)); if ((flags & SYSTF_100KHZSYNC) && freq <= 100000) info->periodic = sys_cputimer->fromhz(100000) * (100000 / freq); if ((flags & SYSTF_MSSYNC) && freq <= 1000) info->periodic = sys_cputimer->fromhz(1000) * (1000 / freq); else info->periodic = sys_cputimer->fromhz(freq); base_count = sys_cputimer->count(); base_count = base_count - (base_count - sys_cputimer->sync_base) % info->periodic; info->time = base_count + info->periodic; if (flags & SYSTF_OFFSETCPU) info->time += mycpu->gd_cpuid * info->periodic / ncpus; if (flags & SYSTF_OFFSET50) info->time += info->periodic / 2; info->func = func; info->data = data; info->freq = freq; info->which = sys_cputimer; info->gd = mycpu; info->flags |= flags; systimer_add(info); } void systimer_init_periodic(systimer_t info, systimer_func_t func, void *data, int64_t freq) { _systimer_init_periodic(info, func, data, freq, 0); } void systimer_init_periodic_nq(systimer_t info, systimer_func_t func, void *data, int64_t freq) { _systimer_init_periodic(info, func, data, freq, SYSTF_NONQUEUED); } /* * These provide systimers whos periods are in perfect multiples of 1ms * or 0.1uS. This is used in situations where the caller wants to gang * multiple systimers together whos periods may have some coincident events, * in order for those coincident events to generate only one interrupt. * * This also allows the caller to make event ordering assumptions for * said coincident events. */ void systimer_init_periodic_nq1khz(systimer_t info, systimer_func_t func, void *data, int64_t freq) { _systimer_init_periodic(info, func, data, freq, SYSTF_NONQUEUED | SYSTF_MSSYNC); } void systimer_init_periodic_nq100khz(systimer_t info, systimer_func_t func, void *data, int64_t freq) { _systimer_init_periodic(info, func, data, freq, SYSTF_NONQUEUED | SYSTF_100KHZSYNC); } void systimer_init_periodic_flags(systimer_t info, systimer_func_t func, void *data, int64_t freq, int flags) { _systimer_init_periodic(info, func, data, freq, flags); } /* * Adjust the periodic interval for a periodic timer which is already * running. The current timeout is not effected. */ void systimer_adjust_periodic(systimer_t info, int64_t freq) { crit_enter(); info->periodic = sys_cputimer->fromhz(freq); info->freq = freq; info->which = sys_cputimer; crit_exit(); } /* * systimer_init_oneshot() * * Initialize a periodic timer at the specified frequency and add * it to the system. The frequency is uncompensated and approximate. */ void systimer_init_oneshot(systimer_t info, systimer_func_t func, void *data, int64_t us) { bzero(info, sizeof(struct systimer)); info->time = sys_cputimer->count() + sys_cputimer->fromus(us); info->func = func; info->data = data; info->which = sys_cputimer; info->gd = mycpu; info->us = us; systimer_add(info); } /* * sys_cputimer was changed, recalculate all existing systimers and kick the * new interrupt. */ static void systimer_changed_pcpu(void *arg __unused) { globaldata_t gd = mycpu; systimer_t info; crit_enter(); again: TAILQ_FOREACH(info, &gd->gd_systimerq, node) { if (info->which == sys_cputimer) continue; TAILQ_REMOVE(&gd->gd_systimerq, info, node); info->flags &= ~SYSTF_ONQUEUE; if (info->periodic) { _systimer_init_periodic(info, info->func, info->data, info->freq, info->flags); } else { info->time = sys_cputimer->count() + sys_cputimer->fromus(info->us); systimer_add(info); } goto again; } cputimer_intr_reload(1); crit_exit(); } void systimer_changed(void) { globaldata_t gd = mycpu; int i; systimer_changed_pcpu(NULL); for (i = 0; i < ncpus; ++i) { if (i != gd->gd_cpuid) { lwkt_send_ipiq(globaldata_find(i), systimer_changed_pcpu, NULL); } } }