sys/kern/kern_systimer.c

   1 /*
   2  * Copyright (c) 2003 Matthew Dillon <dillon@backplane.com>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $DragonFly: src/sys/kern/kern_systimer.c,v 1.3 2004/05/06 18:09:29 dillon Exp $
  27  */
  28
  29 /*
  30  * WARNING!  THE SYSTIMER MODULE DOES NOT OPERATE OR DISPATCH WITH THE
  31  * MP LOCK HELD.  ALL CODE USING THIS MODULE MUST BE MP-SAFE.
  32  *
  33  * This code implements a fine-grained per-cpu system timer which is
  34  * ultimately based on a hardware timer.  The hardware timer abstraction
  35  * is sufficiently disconnected from this code to support both per-cpu
  36  * hardware timers or a single system-wide hardware timer.
  37  *
  38  * Notes on machine-dependant code (in arch/arch/systimer.c)
  39  *
  40  * cputimer_intr_reload()       Reload the one-shot (per-cpu basis)
  41  *
  42  * cputimer_count()             Get the current absolute sysclock_t value.
  43  */
  44
  45 #include <sys/param.h>
  46 #include <sys/kernel.h>
  47 #include <sys/systm.h>
  48 #include <sys/thread.h>
  49 #include <sys/globaldata.h>
  50 #include <sys/systimer.h>
  51 #include <sys/thread2.h>
  52
  53 /*
  54  * Execute ready systimers.  Called directly from the platform-specific
  55  * one-shot timer clock interrupt (e.g. clkintr()).  Systimer functions are
  56  * responsible for calling hardclock, statclock, and other finely-timed
  57  * routines.
  58  */
  59 void
  60 systimer_intr(sysclock_t *timep, struct intrframe *frame)
  61 {
  62     globaldata_t gd = mycpu;
  63     sysclock_t time = *timep;
  64     systimer_t info;
  65
  66     if (gd->gd_syst_nest)
  67         return;
  68
  69     crit_enter();
  70     ++gd->gd_syst_nest;
  71     while ((info = TAILQ_FIRST(&gd->gd_systimerq)) != NULL) {
  72         /*
  73          * If we haven't reached the requested time, tell the cputimer
  74          * how much is left and break out.
  75          */
  76         if ((int)(info->time - time) > 0) {
  77             cputimer_intr_reload(info->time - time);
  78             break;
  79         }
  80
  81         /*
  82          * Dequeue and execute
  83          */
  84         info->flags &= ~SYSTF_ONQUEUE;
  85         TAILQ_REMOVE(info->queue, info, node);
  86         crit_exit();
  87         info->func(info, frame);
  88         crit_enter();
  89
  90         /*
  91          * Reinstall if periodic
  92          */
  93         if (info->periodic) {
  94             info->time += info->periodic;
  95             systimer_add(info);
  96         }
  97     }
  98     if (info)
  99         gd->gd_nextclock = info->time;
 100     else
 101         gd->gd_nextclock = 0;
 102     --gd->gd_syst_nest;
 103     crit_exit();
 104 }
 105
 106 void
 107 systimer_add(systimer_t info)
 108 {
 109     struct globaldata *gd = mycpu;
 110
 111     KKASSERT((info->flags & (SYSTF_ONQUEUE|SYSTF_IPIRUNNING)) == 0);
 112     crit_enter();
 113     if (info->gd == gd) {
 114         systimer_t scan1;
 115         systimer_t scan2;
 116         scan1 = TAILQ_FIRST(&gd->gd_systimerq);
 117         if (scan1 == NULL || (int)(scan1->time - info->time) > 0) {
 118             gd->gd_nextclock = info->time;
 119             cputimer_intr_reload(info->time - cputimer_count());
 120             TAILQ_INSERT_HEAD(&gd->gd_systimerq, info, node);
 121         } else {
 122             scan2 = TAILQ_LAST(&gd->gd_systimerq, systimerq);
 123             for (;;) {
 124                 if (scan1 == NULL) {
 125                     TAILQ_INSERT_TAIL(&gd->gd_systimerq, info, node);
 126                     break;
 127                 }
 128                 if ((int)(scan1->time - info->time) > 0) {
 129                     TAILQ_INSERT_BEFORE(scan1, info, node);
 130                     break;
 131                 }
 132                 if ((int)(scan2->time - info->time) <= 0) {
 133                     TAILQ_INSERT_AFTER(&gd->gd_systimerq, scan2, info, node);
 134                     break;
 135                 }
 136                 scan1 = TAILQ_NEXT(scan1, node);
 137                 scan2 = TAILQ_PREV(scan2, systimerq, node);
 138             }
 139         }
 140         info->flags = (info->flags | SYSTF_ONQUEUE) & ~SYSTF_IPIRUNNING;
 141         info->queue = &gd->gd_systimerq;
 142     } else {
 143         info->flags |= SYSTF_IPIRUNNING;
 144         lwkt_send_ipiq(info->gd, (ipifunc_t)systimer_add, info);
 145     }
 146     crit_exit();
 147 }
 148
 149 /*
 150  * systimer_del()
 151  *
 152  *      Delete a system timer.  Only the owning cpu can delete a timer.
 153  */
 154 void
 155 systimer_del(systimer_t info)
 156 {
 157     KKASSERT(info->gd == mycpu && (info->flags & SYSTF_IPIRUNNING) == 0);
 158     crit_enter();
 159     if (info->flags & SYSTF_ONQUEUE) {
 160         TAILQ_REMOVE(info->queue, info, node);
 161         info->flags &= ~SYSTF_ONQUEUE;
 162     }
 163     crit_exit();
 164 }
 165
 166 /*
 167  * systimer_init_periodic()
 168  *
 169  *      Initialize a periodic timer at the specified frequency and add
 170  *      it to the system.  The frequency is uncompensated and approximate.
 171  *
 172  *      Try to synchronize multi registrations of the same or similar
 173  *      frequencies so the hardware interrupt is able to dispatch several
 174  *      at together by adjusting the phase of the initial interrupt.  This
 175  *      helps SMP.  Note that we are not attempting to synchronize to
 176  *      the realtime clock.
 177  */
 178 void
 179 systimer_init_periodic(systimer_t info, void *func, void *data, int hz)
 180 {
 181     sysclock_t base_count;
 182
 183     bzero(info, sizeof(struct systimer));
 184     info->periodic = cputimer_fromhz(hz);
 185     base_count = cputimer_count();
 186     base_count = base_count - (base_count % info->periodic);
 187     info->time = base_count + info->periodic;
 188     info->func = func;
 189     info->data = data;
 190     info->gd = mycpu;
 191     systimer_add(info);
 192 }
 193
 194 /*
 195  * systimer_init_oneshot()
 196  *
 197  *      Initialize a periodic timer at the specified frequency and add
 198  *      it to the system.  The frequency is uncompensated and approximate.
 199  */
 200 void
 201 systimer_init_oneshot(systimer_t info, void *func, void *data, int us)
 202 {
 203     bzero(info, sizeof(struct systimer));
 204     info->time = cputimer_count() + cputimer_fromus(us);
 205     info->func = func;
 206     info->data = data;
 207     info->gd = mycpu;
 208     systimer_add(info);
 209 }
 210