The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_clock.c

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1991, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  * (c) UNIX System Laboratories, Inc.
    5  * All or some portions of this file are derived from material licensed
    6  * to the University of California by American Telephone and Telegraph
    7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
    8  * the permission of UNIX System Laboratories, Inc.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)kern_clock.c        8.5 (Berkeley) 1/21/94
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __FBSDID("$FreeBSD$");
   39 
   40 #include "opt_kdb.h"
   41 #include "opt_device_polling.h"
   42 #include "opt_hwpmc_hooks.h"
   43 #include "opt_ntp.h"
   44 #include "opt_watchdog.h"
   45 
   46 #include <sys/param.h>
   47 #include <sys/systm.h>
   48 #include <sys/callout.h>
   49 #include <sys/kdb.h>
   50 #include <sys/kernel.h>
   51 #include <sys/lock.h>
   52 #include <sys/ktr.h>
   53 #include <sys/mutex.h>
   54 #include <sys/proc.h>
   55 #include <sys/resource.h>
   56 #include <sys/resourcevar.h>
   57 #include <sys/sched.h>
   58 #include <sys/signalvar.h>
   59 #include <sys/smp.h>
   60 #include <vm/vm.h>
   61 #include <vm/pmap.h>
   62 #include <vm/vm_map.h>
   63 #include <sys/sysctl.h>
   64 #include <sys/bus.h>
   65 #include <sys/interrupt.h>
   66 #include <sys/limits.h>
   67 #include <sys/timetc.h>
   68 
   69 #ifdef GPROF
   70 #include <sys/gmon.h>
   71 #endif
   72 
   73 #ifdef HWPMC_HOOKS
   74 #include <sys/pmckern.h>
   75 #endif
   76 
   77 #ifdef DEVICE_POLLING
   78 extern void hardclock_device_poll(void);
   79 #endif /* DEVICE_POLLING */
   80 
   81 static void initclocks(void *dummy);
   82 SYSINIT(clocks, SI_SUB_CLOCKS, SI_ORDER_FIRST, initclocks, NULL);
   83 
   84 /* Spin-lock protecting profiling statistics. */
   85 static struct mtx time_lock;
   86 
   87 static int
   88 sysctl_kern_cp_time(SYSCTL_HANDLER_ARGS)
   89 {
   90         int error;
   91         long cp_time[CPUSTATES];
   92 #ifdef SCTL_MASK32
   93         int i;
   94         unsigned int cp_time32[CPUSTATES];
   95 #endif
   96 
   97         read_cpu_time(cp_time);
   98 #ifdef SCTL_MASK32
   99         if (req->flags & SCTL_MASK32) {
  100                 if (!req->oldptr)
  101                         return SYSCTL_OUT(req, 0, sizeof(cp_time32));
  102                 for (i = 0; i < CPUSTATES; i++)
  103                         cp_time32[i] = (unsigned int)cp_time[i];
  104                 error = SYSCTL_OUT(req, cp_time32, sizeof(cp_time32));
  105         } else
  106 #endif
  107         {
  108                 if (!req->oldptr)
  109                         return SYSCTL_OUT(req, 0, sizeof(cp_time));
  110                 error = SYSCTL_OUT(req, cp_time, sizeof(cp_time));
  111         }
  112         return error;
  113 }
  114 
  115 SYSCTL_PROC(_kern, OID_AUTO, cp_time, CTLTYPE_LONG|CTLFLAG_RD,
  116     0,0, sysctl_kern_cp_time, "LU", "CPU time statistics");
  117 
  118 static long empty[CPUSTATES];
  119 
  120 static int
  121 sysctl_kern_cp_times(SYSCTL_HANDLER_ARGS)
  122 {
  123         struct pcpu *pcpu;
  124         int error;
  125         int c;
  126         long *cp_time;
  127 #ifdef SCTL_MASK32
  128         unsigned int cp_time32[CPUSTATES];
  129         int i;
  130 #endif
  131 
  132         if (!req->oldptr) {
  133 #ifdef SCTL_MASK32
  134                 if (req->flags & SCTL_MASK32)
  135                         return SYSCTL_OUT(req, 0, sizeof(cp_time32) * (mp_maxid + 1));
  136                 else
  137 #endif
  138                         return SYSCTL_OUT(req, 0, sizeof(long) * CPUSTATES * (mp_maxid + 1));
  139         }
  140         for (error = 0, c = 0; error == 0 && c <= mp_maxid; c++) {
  141                 if (!CPU_ABSENT(c)) {
  142                         pcpu = pcpu_find(c);
  143                         cp_time = pcpu->pc_cp_time;
  144                 } else {
  145                         cp_time = empty;
  146                 }
  147 #ifdef SCTL_MASK32
  148                 if (req->flags & SCTL_MASK32) {
  149                         for (i = 0; i < CPUSTATES; i++)
  150                                 cp_time32[i] = (unsigned int)cp_time[i];
  151                         error = SYSCTL_OUT(req, cp_time32, sizeof(cp_time32));
  152                 } else
  153 #endif
  154                         error = SYSCTL_OUT(req, cp_time, sizeof(long) * CPUSTATES);
  155         }
  156         return error;
  157 }
  158 
  159 SYSCTL_PROC(_kern, OID_AUTO, cp_times, CTLTYPE_LONG|CTLFLAG_RD,
  160     0,0, sysctl_kern_cp_times, "LU", "per-CPU time statistics");
  161 
  162 void
  163 read_cpu_time(long *cp_time)
  164 {
  165         struct pcpu *pc;
  166         int i, j;
  167 
  168         /* Sum up global cp_time[]. */
  169         bzero(cp_time, sizeof(long) * CPUSTATES);
  170         for (i = 0; i <= mp_maxid; i++) {
  171                 if (CPU_ABSENT(i))
  172                         continue;
  173                 pc = pcpu_find(i);
  174                 for (j = 0; j < CPUSTATES; j++)
  175                         cp_time[j] += pc->pc_cp_time[j];
  176         }
  177 }
  178 
  179 #ifdef SW_WATCHDOG
  180 #include <sys/watchdog.h>
  181 
  182 static int watchdog_ticks;
  183 static int watchdog_enabled;
  184 static void watchdog_fire(void);
  185 static void watchdog_config(void *, u_int, int *);
  186 #endif /* SW_WATCHDOG */
  187 
  188 /*
  189  * Clock handling routines.
  190  *
  191  * This code is written to operate with two timers that run independently of
  192  * each other.
  193  *
  194  * The main timer, running hz times per second, is used to trigger interval
  195  * timers, timeouts and rescheduling as needed.
  196  *
  197  * The second timer handles kernel and user profiling,
  198  * and does resource use estimation.  If the second timer is programmable,
  199  * it is randomized to avoid aliasing between the two clocks.  For example,
  200  * the randomization prevents an adversary from always giving up the cpu
  201  * just before its quantum expires.  Otherwise, it would never accumulate
  202  * cpu ticks.  The mean frequency of the second timer is stathz.
  203  *
  204  * If no second timer exists, stathz will be zero; in this case we drive
  205  * profiling and statistics off the main clock.  This WILL NOT be accurate;
  206  * do not do it unless absolutely necessary.
  207  *
  208  * The statistics clock may (or may not) be run at a higher rate while
  209  * profiling.  This profile clock runs at profhz.  We require that profhz
  210  * be an integral multiple of stathz.
  211  *
  212  * If the statistics clock is running fast, it must be divided by the ratio
  213  * profhz/stathz for statistics.  (For profiling, every tick counts.)
  214  *
  215  * Time-of-day is maintained using a "timecounter", which may or may
  216  * not be related to the hardware generating the above mentioned
  217  * interrupts.
  218  */
  219 
  220 int     stathz;
  221 int     profhz;
  222 int     profprocs;
  223 int     ticks;
  224 int     psratio;
  225 
  226 /*
  227  * Initialize clock frequencies and start both clocks running.
  228  */
  229 /* ARGSUSED*/
  230 static void
  231 initclocks(dummy)
  232         void *dummy;
  233 {
  234         register int i;
  235 
  236         /*
  237          * Set divisors to 1 (normal case) and let the machine-specific
  238          * code do its bit.
  239          */
  240         mtx_init(&time_lock, "time lock", NULL, MTX_SPIN);
  241         cpu_initclocks();
  242 
  243         /*
  244          * Compute profhz/stathz, and fix profhz if needed.
  245          */
  246         i = stathz ? stathz : hz;
  247         if (profhz == 0)
  248                 profhz = i;
  249         psratio = profhz / i;
  250 #ifdef SW_WATCHDOG
  251         EVENTHANDLER_REGISTER(watchdog_list, watchdog_config, NULL, 0);
  252 #endif
  253 }
  254 
  255 /*
  256  * Each time the real-time timer fires, this function is called on all CPUs.
  257  * Note that hardclock() calls hardclock_cpu() for the boot CPU, so only
  258  * the other CPUs in the system need to call this function.
  259  */
  260 void
  261 hardclock_cpu(int usermode)
  262 {
  263         struct pstats *pstats;
  264         struct thread *td = curthread;
  265         struct proc *p = td->td_proc;
  266         int flags;
  267 
  268         /*
  269          * Run current process's virtual and profile time, as needed.
  270          */
  271         pstats = p->p_stats;
  272         flags = 0;
  273         if (usermode &&
  274             timevalisset(&pstats->p_timer[ITIMER_VIRTUAL].it_value)) {
  275                 PROC_SLOCK(p);
  276                 if (itimerdecr(&pstats->p_timer[ITIMER_VIRTUAL], tick) == 0)
  277                         flags |= TDF_ALRMPEND | TDF_ASTPENDING;
  278                 PROC_SUNLOCK(p);
  279         }
  280         if (timevalisset(&pstats->p_timer[ITIMER_PROF].it_value)) {
  281                 PROC_SLOCK(p);
  282                 if (itimerdecr(&pstats->p_timer[ITIMER_PROF], tick) == 0)
  283                         flags |= TDF_PROFPEND | TDF_ASTPENDING;
  284                 PROC_SUNLOCK(p);
  285         }
  286         thread_lock(td);
  287         sched_tick();
  288         td->td_flags |= flags;
  289         thread_unlock(td);
  290 
  291 #ifdef  HWPMC_HOOKS
  292         if (PMC_CPU_HAS_SAMPLES(PCPU_GET(cpuid)))
  293                 PMC_CALL_HOOK_UNLOCKED(curthread, PMC_FN_DO_SAMPLES, NULL);
  294 #endif
  295 }
  296 
  297 /*
  298  * The real-time timer, interrupting hz times per second.
  299  */
  300 void
  301 hardclock(int usermode, uintfptr_t pc)
  302 {
  303         int need_softclock = 0;
  304 
  305         hardclock_cpu(usermode);
  306 
  307         tc_ticktock();
  308         /*
  309          * If no separate statistics clock is available, run it from here.
  310          *
  311          * XXX: this only works for UP
  312          */
  313         if (stathz == 0) {
  314                 profclock(usermode, pc);
  315                 statclock(usermode);
  316         }
  317 
  318 #ifdef DEVICE_POLLING
  319         hardclock_device_poll();        /* this is very short and quick */
  320 #endif /* DEVICE_POLLING */
  321 
  322         /*
  323          * Process callouts at a very low cpu priority, so we don't keep the
  324          * relatively high clock interrupt priority any longer than necessary.
  325          */
  326         mtx_lock_spin_flags(&callout_lock, MTX_QUIET);
  327         ticks++;
  328         if (!TAILQ_EMPTY(&callwheel[ticks & callwheelmask])) {
  329                 need_softclock = 1;
  330         } else if (softticks + 1 == ticks)
  331                 ++softticks;
  332         mtx_unlock_spin_flags(&callout_lock, MTX_QUIET);
  333 
  334         /*
  335          * swi_sched acquires the thread lock, so we don't want to call it
  336          * with callout_lock held; incorrect locking order.
  337          */
  338         if (need_softclock)
  339                 swi_sched(softclock_ih, 0);
  340 
  341 #ifdef SW_WATCHDOG
  342         if (watchdog_enabled > 0 && --watchdog_ticks <= 0)
  343                 watchdog_fire();
  344 #endif /* SW_WATCHDOG */
  345 }
  346 
  347 /*
  348  * Compute number of ticks in the specified amount of time.
  349  */
  350 int
  351 tvtohz(tv)
  352         struct timeval *tv;
  353 {
  354         register unsigned long ticks;
  355         register long sec, usec;
  356 
  357         /*
  358          * If the number of usecs in the whole seconds part of the time
  359          * difference fits in a long, then the total number of usecs will
  360          * fit in an unsigned long.  Compute the total and convert it to
  361          * ticks, rounding up and adding 1 to allow for the current tick
  362          * to expire.  Rounding also depends on unsigned long arithmetic
  363          * to avoid overflow.
  364          *
  365          * Otherwise, if the number of ticks in the whole seconds part of
  366          * the time difference fits in a long, then convert the parts to
  367          * ticks separately and add, using similar rounding methods and
  368          * overflow avoidance.  This method would work in the previous
  369          * case but it is slightly slower and assumes that hz is integral.
  370          *
  371          * Otherwise, round the time difference down to the maximum
  372          * representable value.
  373          *
  374          * If ints have 32 bits, then the maximum value for any timeout in
  375          * 10ms ticks is 248 days.
  376          */
  377         sec = tv->tv_sec;
  378         usec = tv->tv_usec;
  379         if (usec < 0) {
  380                 sec--;
  381                 usec += 1000000;
  382         }
  383         if (sec < 0) {
  384 #ifdef DIAGNOSTIC
  385                 if (usec > 0) {
  386                         sec++;
  387                         usec -= 1000000;
  388                 }
  389                 printf("tvotohz: negative time difference %ld sec %ld usec\n",
  390                        sec, usec);
  391 #endif
  392                 ticks = 1;
  393         } else if (sec <= LONG_MAX / 1000000)
  394                 ticks = (sec * 1000000 + (unsigned long)usec + (tick - 1))
  395                         / tick + 1;
  396         else if (sec <= LONG_MAX / hz)
  397                 ticks = sec * hz
  398                         + ((unsigned long)usec + (tick - 1)) / tick + 1;
  399         else
  400                 ticks = LONG_MAX;
  401         if (ticks > INT_MAX)
  402                 ticks = INT_MAX;
  403         return ((int)ticks);
  404 }
  405 
  406 /*
  407  * Start profiling on a process.
  408  *
  409  * Kernel profiling passes proc0 which never exits and hence
  410  * keeps the profile clock running constantly.
  411  */
  412 void
  413 startprofclock(p)
  414         register struct proc *p;
  415 {
  416 
  417         PROC_LOCK_ASSERT(p, MA_OWNED);
  418         if (p->p_flag & P_STOPPROF)
  419                 return;
  420         if ((p->p_flag & P_PROFIL) == 0) {
  421                 p->p_flag |= P_PROFIL;
  422                 mtx_lock_spin(&time_lock);
  423                 if (++profprocs == 1)
  424                         cpu_startprofclock();
  425                 mtx_unlock_spin(&time_lock);
  426         }
  427 }
  428 
  429 /*
  430  * Stop profiling on a process.
  431  */
  432 void
  433 stopprofclock(p)
  434         register struct proc *p;
  435 {
  436 
  437         PROC_LOCK_ASSERT(p, MA_OWNED);
  438         if (p->p_flag & P_PROFIL) {
  439                 if (p->p_profthreads != 0) {
  440                         p->p_flag |= P_STOPPROF;
  441                         while (p->p_profthreads != 0)
  442                                 msleep(&p->p_profthreads, &p->p_mtx, PPAUSE,
  443                                     "stopprof", 0);
  444                         p->p_flag &= ~P_STOPPROF;
  445                 }
  446                 if ((p->p_flag & P_PROFIL) == 0)
  447                         return;
  448                 p->p_flag &= ~P_PROFIL;
  449                 mtx_lock_spin(&time_lock);
  450                 if (--profprocs == 0)
  451                         cpu_stopprofclock();
  452                 mtx_unlock_spin(&time_lock);
  453         }
  454 }
  455 
  456 /*
  457  * Statistics clock.  Updates rusage information and calls the scheduler
  458  * to adjust priorities of the active thread.
  459  *
  460  * This should be called by all active processors.
  461  */
  462 void
  463 statclock(int usermode)
  464 {
  465         struct rusage *ru;
  466         struct vmspace *vm;
  467         struct thread *td;
  468         struct proc *p;
  469         long rss;
  470         long *cp_time;
  471 
  472         td = curthread;
  473         p = td->td_proc;
  474 
  475         cp_time = (long *)PCPU_PTR(cp_time);
  476         if (usermode) {
  477                 /*
  478                  * Charge the time as appropriate.
  479                  */
  480 #ifdef KSE
  481                 if (p->p_flag & P_SA)
  482                         thread_statclock(1);
  483 #endif
  484                 td->td_uticks++;
  485                 if (p->p_nice > NZERO)
  486                         cp_time[CP_NICE]++;
  487                 else
  488                         cp_time[CP_USER]++;
  489         } else {
  490                 /*
  491                  * Came from kernel mode, so we were:
  492                  * - handling an interrupt,
  493                  * - doing syscall or trap work on behalf of the current
  494                  *   user process, or
  495                  * - spinning in the idle loop.
  496                  * Whichever it is, charge the time as appropriate.
  497                  * Note that we charge interrupts to the current process,
  498                  * regardless of whether they are ``for'' that process,
  499                  * so that we know how much of its real time was spent
  500                  * in ``non-process'' (i.e., interrupt) work.
  501                  */
  502                 if ((td->td_pflags & TDP_ITHREAD) ||
  503                     td->td_intr_nesting_level >= 2) {
  504                         td->td_iticks++;
  505                         cp_time[CP_INTR]++;
  506                 } else {
  507 #ifdef KSE
  508                         if (p->p_flag & P_SA)
  509                                 thread_statclock(0);
  510 #endif
  511                         td->td_pticks++;
  512                         td->td_sticks++;
  513                         if (!TD_IS_IDLETHREAD(td))
  514                                 cp_time[CP_SYS]++;
  515                         else
  516                                 cp_time[CP_IDLE]++;
  517                 }
  518         }
  519 
  520         /* Update resource usage integrals and maximums. */
  521         MPASS(p->p_vmspace != NULL);
  522         vm = p->p_vmspace;
  523         ru = &td->td_ru;
  524         ru->ru_ixrss += pgtok(vm->vm_tsize);
  525         ru->ru_idrss += pgtok(vm->vm_dsize);
  526         ru->ru_isrss += pgtok(vm->vm_ssize);
  527         rss = pgtok(vmspace_resident_count(vm));
  528         if (ru->ru_maxrss < rss)
  529                 ru->ru_maxrss = rss;
  530         CTR4(KTR_SCHED, "statclock: %p(%s) prio %d stathz %d",
  531             td, td->td_proc->p_comm, td->td_priority, (stathz)?stathz:hz);
  532         thread_lock_flags(td, MTX_QUIET);
  533         sched_clock(td);
  534         thread_unlock(td);
  535 }
  536 
  537 void
  538 profclock(int usermode, uintfptr_t pc)
  539 {
  540         struct thread *td;
  541 #ifdef GPROF
  542         struct gmonparam *g;
  543         uintfptr_t i;
  544 #endif
  545 
  546         td = curthread;
  547         if (usermode) {
  548                 /*
  549                  * Came from user mode; CPU was in user state.
  550                  * If this process is being profiled, record the tick.
  551                  * if there is no related user location yet, don't
  552                  * bother trying to count it.
  553                  */
  554                 if (td->td_proc->p_flag & P_PROFIL)
  555                         addupc_intr(td, pc, 1);
  556         }
  557 #ifdef GPROF
  558         else {
  559                 /*
  560                  * Kernel statistics are just like addupc_intr, only easier.
  561                  */
  562                 g = &_gmonparam;
  563                 if (g->state == GMON_PROF_ON && pc >= g->lowpc) {
  564                         i = PC_TO_I(g, pc);
  565                         if (i < g->textsize) {
  566                                 KCOUNT(g, i)++;
  567                         }
  568                 }
  569         }
  570 #endif
  571 }
  572 
  573 /*
  574  * Return information about system clocks.
  575  */
  576 static int
  577 sysctl_kern_clockrate(SYSCTL_HANDLER_ARGS)
  578 {
  579         struct clockinfo clkinfo;
  580         /*
  581          * Construct clockinfo structure.
  582          */
  583         bzero(&clkinfo, sizeof(clkinfo));
  584         clkinfo.hz = hz;
  585         clkinfo.tick = tick;
  586         clkinfo.profhz = profhz;
  587         clkinfo.stathz = stathz ? stathz : hz;
  588         return (sysctl_handle_opaque(oidp, &clkinfo, sizeof clkinfo, req));
  589 }
  590 
  591 SYSCTL_PROC(_kern, KERN_CLOCKRATE, clockrate, CTLTYPE_STRUCT|CTLFLAG_RD,
  592         0, 0, sysctl_kern_clockrate, "S,clockinfo",
  593         "Rate and period of various kernel clocks");
  594 
  595 #ifdef SW_WATCHDOG
  596 
  597 static void
  598 watchdog_config(void *unused __unused, u_int cmd, int *error)
  599 {
  600         u_int u;
  601 
  602         u = cmd & WD_INTERVAL;
  603         if (u >= WD_TO_1SEC) {
  604                 watchdog_ticks = (1 << (u - WD_TO_1SEC)) * hz;
  605                 watchdog_enabled = 1;
  606                 *error = 0;
  607         } else {
  608                 watchdog_enabled = 0;
  609         }
  610 }
  611 
  612 /*
  613  * Handle a watchdog timeout by dumping interrupt information and
  614  * then either dropping to DDB or panicking.
  615  */
  616 static void
  617 watchdog_fire(void)
  618 {
  619         int nintr;
  620         u_int64_t inttotal;
  621         u_long *curintr;
  622         char *curname;
  623 
  624         curintr = intrcnt;
  625         curname = intrnames;
  626         inttotal = 0;
  627         nintr = eintrcnt - intrcnt;
  628 
  629         printf("interrupt                   total\n");
  630         while (--nintr >= 0) {
  631                 if (*curintr)
  632                         printf("%-12s %20lu\n", curname, *curintr);
  633                 curname += strlen(curname) + 1;
  634                 inttotal += *curintr++;
  635         }
  636         printf("Total        %20ju\n", (uintmax_t)inttotal);
  637 
  638 #if defined(KDB) && !defined(KDB_UNATTENDED)
  639         kdb_backtrace();
  640         kdb_enter_why(KDB_WHY_WATCHDOG, "watchdog timeout");
  641 #else
  642         panic("watchdog timeout");
  643 #endif
  644 }
  645 
  646 #endif /* SW_WATCHDOG */

Cache object: 16be5a0c3381fd1ac5346b87d9ae52c2


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.