watchdog.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2004 Poul-Henning Kamp
    5  * Copyright (c) 2013 iXsystems.com,
    6  *               author: Alfred Perlstein <alfred@freebsd.org>
    7  *
    8  * All rights reserved.
    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  *    in this position and unchanged.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
   21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   30  *
   31  */
   32 
   33 #include "opt_ddb.h"
   34 
   35 #include <sys/cdefs.h>
   36 __FBSDID("$FreeBSD$");
   37 
   38 #include <sys/param.h>
   39 #include <sys/bus.h>
   40 #include <sys/conf.h>
   41 #include <sys/eventhandler.h>
   42 #include <sys/kdb.h>
   43 #include <sys/kernel.h>
   44 #include <sys/malloc.h>
   45 #include <sys/module.h>
   46 #include <sys/mutex.h>
   47 #include <sys/sysctl.h>
   48 #include <sys/syslog.h>
   49 #include <sys/systm.h>
   50 #include <sys/uio.h>
   51 #include <sys/watchdog.h>
   52 #include <machine/bus.h>
   53 
   54 #include <sys/syscallsubr.h> /* kern_clock_gettime() */
   55 
   56 static int wd_set_pretimeout(int newtimeout, int disableiftoolong);
   57 static void wd_timeout_cb(void *arg);
   58 
   59 static struct callout wd_pretimeo_handle;
   60 static int wd_pretimeout;
   61 static int wd_pretimeout_act = WD_SOFT_LOG;
   62 
   63 static struct callout wd_softtimeo_handle;
   64 static int wd_softtimer;        /* true = use softtimer instead of hardware
   65                                    watchdog */
   66 static int wd_softtimeout_act = WD_SOFT_LOG;    /* action for the software timeout */
   67 
   68 static struct cdev *wd_dev;
   69 static volatile u_int wd_last_u;    /* last timeout value set by kern_do_pat */
   70 static u_int wd_last_u_sysctl;    /* last timeout value set by kern_do_pat */
   71 static u_int wd_last_u_sysctl_secs;    /* wd_last_u in seconds */
   72 
   73 SYSCTL_NODE(_hw, OID_AUTO, watchdog, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
   74     "Main watchdog device");
   75 SYSCTL_UINT(_hw_watchdog, OID_AUTO, wd_last_u, CTLFLAG_RD,
   76     &wd_last_u_sysctl, 0, "Watchdog last update time");
   77 SYSCTL_UINT(_hw_watchdog, OID_AUTO, wd_last_u_secs, CTLFLAG_RD,
   78     &wd_last_u_sysctl_secs, 0, "Watchdog last update time");
   79 
   80 static int wd_lastpat_valid = 0;
   81 static time_t wd_lastpat = 0;   /* when the watchdog was last patted */
   82 
   83 /* Hook for external software watchdog to register for use if needed */
   84 void (*wdog_software_attach)(void);
   85 
   86 static void
   87 pow2ns_to_ts(int pow2ns, struct timespec *ts)
   88 {
   89         uint64_t ns;
   90 
   91         ns = 1ULL << pow2ns;
   92         ts->tv_sec = ns / 1000000000ULL;
   93         ts->tv_nsec = ns % 1000000000ULL;
   94 }
   95 
   96 static int
   97 pow2ns_to_ticks(int pow2ns)
   98 {
   99         struct timeval tv;
  100         struct timespec ts;
  101 
  102         pow2ns_to_ts(pow2ns, &ts);
  103         TIMESPEC_TO_TIMEVAL(&tv, &ts);
  104         return (tvtohz(&tv));
  105 }
  106 
  107 static int
  108 seconds_to_pow2ns(int seconds)
  109 {
  110         uint64_t power;
  111         uint64_t ns;
  112         uint64_t shifted;
  113 
  114         ns = ((uint64_t)seconds) * 1000000000ULL;
  115         power = flsll(ns);
  116         shifted = 1ULL << power;
  117         if (shifted <= ns) {
  118                 power++;
  119         }
  120         return (power);
  121 }
  122 
  123 int
  124 wdog_kern_pat(u_int utim)
  125 {
  126         int error;
  127         static int first = 1;
  128 
  129         if ((utim & WD_LASTVAL) != 0 && (utim & WD_INTERVAL) > 0)
  130                 return (EINVAL);
  131 
  132         if ((utim & WD_LASTVAL) != 0) {
  133                 /*
  134                  * if WD_LASTVAL is set, fill in the bits for timeout
  135                  * from the saved value in wd_last_u.
  136                  */
  137                 MPASS((wd_last_u & ~WD_INTERVAL) == 0);
  138                 utim &= ~WD_LASTVAL;
  139                 utim |= wd_last_u;
  140         } else {
  141                 /*
  142                  * Otherwise save the new interval.
  143                  * This can be zero (to disable the watchdog)
  144                  */
  145                 wd_last_u = (utim & WD_INTERVAL);
  146                 wd_last_u_sysctl = wd_last_u;
  147                 wd_last_u_sysctl_secs = pow2ns_to_ticks(wd_last_u) / hz;
  148         }
  149         if ((utim & WD_INTERVAL) == WD_TO_NEVER) {
  150                 utim = 0;
  151 
  152                 /* Assume all is well; watchdog signals failure. */
  153                 error = 0;
  154         } else {
  155                 /* Assume no watchdog available; watchdog flags success */
  156                 error = EOPNOTSUPP;
  157         }
  158         if (wd_softtimer) {
  159                 if (utim == 0) {
  160                         callout_stop(&wd_softtimeo_handle);
  161                 } else {
  162                         (void) callout_reset(&wd_softtimeo_handle,
  163                             pow2ns_to_ticks(utim), wd_timeout_cb, "soft");
  164                 }
  165                 error = 0;
  166         } else {
  167                 EVENTHANDLER_INVOKE(watchdog_list, utim, &error);
  168         }
  169         /*
  170          * If we no hardware watchdog responded, we have not tried to
  171          * attach an external software watchdog, and one is available,
  172          * attach it now and retry.
  173          */
  174         if (error == EOPNOTSUPP && first && *wdog_software_attach != NULL) {
  175                 (*wdog_software_attach)();
  176                 EVENTHANDLER_INVOKE(watchdog_list, utim, &error);
  177         }
  178         first = 0;
  179 
  180         wd_set_pretimeout(wd_pretimeout, true);
  181         /*
  182          * If we were able to arm/strobe the watchdog, then
  183          * update the last time it was strobed for WDIOC_GETTIMELEFT
  184          */
  185         if (!error) {
  186                 struct timespec ts;
  187 
  188                 error = kern_clock_gettime(curthread /* XXX */,
  189                     CLOCK_MONOTONIC_FAST, &ts);
  190                 if (!error) {
  191                         wd_lastpat = ts.tv_sec;
  192                         wd_lastpat_valid = 1;
  193                 }
  194         }
  195         return (error);
  196 }
  197 
  198 static int
  199 wd_valid_act(int act)
  200 {
  201 
  202         if ((act & ~(WD_SOFT_MASK)) != 0)
  203                 return false;
  204         return true;
  205 }
  206 
  207 static int
  208 wd_ioctl_patpat(caddr_t data)
  209 {
  210         u_int u;
  211 
  212         u = *(u_int *)data;
  213         if (u & ~(WD_ACTIVE | WD_PASSIVE | WD_LASTVAL | WD_INTERVAL))
  214                 return (EINVAL);
  215         if ((u & (WD_ACTIVE | WD_PASSIVE)) == (WD_ACTIVE | WD_PASSIVE))
  216                 return (EINVAL);
  217         if ((u & (WD_ACTIVE | WD_PASSIVE)) == 0 && ((u & WD_INTERVAL) > 0 ||
  218             (u & WD_LASTVAL) != 0))
  219                 return (EINVAL);
  220         if (u & WD_PASSIVE)
  221                 return (ENOSYS);        /* XXX Not implemented yet */
  222         u &= ~(WD_ACTIVE | WD_PASSIVE);
  223 
  224         return (wdog_kern_pat(u));
  225 }
  226 
  227 static int
  228 wd_get_time_left(struct thread *td, time_t *remainp)
  229 {
  230         struct timespec ts;
  231         int error;
  232 
  233         error = kern_clock_gettime(td, CLOCK_MONOTONIC_FAST, &ts);
  234         if (error)
  235                 return (error);
  236         if (!wd_lastpat_valid)
  237                 return (ENOENT);
  238         *remainp = ts.tv_sec - wd_lastpat;
  239         return (0);
  240 }
  241 
  242 static void
  243 wd_timeout_cb(void *arg)
  244 {
  245         const char *type = arg;
  246 
  247 #ifdef DDB
  248         if ((wd_pretimeout_act & WD_SOFT_DDB)) {
  249                 char kdb_why[80];
  250                 snprintf(kdb_why, sizeof(kdb_why), "watchdog %s-timeout", type);
  251                 kdb_backtrace();
  252                 kdb_enter(KDB_WHY_WATCHDOG, kdb_why);
  253         }
  254 #endif
  255         if ((wd_pretimeout_act & WD_SOFT_LOG))
  256                 log(LOG_EMERG, "watchdog %s-timeout, WD_SOFT_LOG\n", type);
  257         if ((wd_pretimeout_act & WD_SOFT_PRINTF))
  258                 printf("watchdog %s-timeout, WD_SOFT_PRINTF\n", type);
  259         if ((wd_pretimeout_act & WD_SOFT_PANIC))
  260                 panic("watchdog %s-timeout, WD_SOFT_PANIC set", type);
  261 }
  262 
  263 /*
  264  * Called to manage timeouts.
  265  * newtimeout needs to be in the range of 0 to actual watchdog timeout.
  266  * if 0, we disable the pre-timeout.
  267  * otherwise we set the pre-timeout provided it's not greater than the
  268  * current actual watchdog timeout.
  269  */
  270 static int
  271 wd_set_pretimeout(int newtimeout, int disableiftoolong)
  272 {
  273         u_int utime;
  274         struct timespec utime_ts;
  275         int timeout_ticks;
  276 
  277         utime = wdog_kern_last_timeout();
  278         pow2ns_to_ts(utime, &utime_ts);
  279         /* do not permit a pre-timeout >= than the timeout. */
  280         if (newtimeout >= utime_ts.tv_sec) {
  281                 /*
  282                  * If 'disableiftoolong' then just fall through
  283                  * so as to disable the pre-watchdog
  284                  */
  285                 if (disableiftoolong)
  286                         newtimeout = 0;
  287                 else
  288                         return EINVAL;
  289         }
  290 
  291         /* disable the pre-timeout */
  292         if (newtimeout == 0) {
  293                 wd_pretimeout = 0;
  294                 callout_stop(&wd_pretimeo_handle);
  295                 return 0;
  296         }
  297 
  298         timeout_ticks = pow2ns_to_ticks(utime) - (hz*newtimeout);
  299 #if 0
  300         printf("wd_set_pretimeout: "
  301             "newtimeout: %d, "
  302             "utime: %d -> utime_ticks: %d, "
  303             "hz*newtimeout: %d, "
  304             "timeout_ticks: %d -> sec: %d\n",
  305             newtimeout,
  306             utime, pow2ns_to_ticks(utime),
  307             hz*newtimeout,
  308             timeout_ticks, timeout_ticks / hz);
  309 #endif
  310 
  311         /* We determined the value is sane, so reset the callout */
  312         (void) callout_reset(&wd_pretimeo_handle,
  313             timeout_ticks, wd_timeout_cb, "pre");
  314         wd_pretimeout = newtimeout;
  315         return 0;
  316 }
  317 
  318 static int
  319 wd_ioctl(struct cdev *dev __unused, u_long cmd, caddr_t data,
  320     int flags __unused, struct thread *td)
  321 {
  322         u_int u;
  323         time_t timeleft;
  324         int error;
  325 
  326         error = 0;
  327 
  328         switch (cmd) {
  329         case WDIOC_SETSOFT:
  330                 u = *(int *)data;
  331                 /* do nothing? */
  332                 if (u == wd_softtimer)
  333                         break;
  334                 /* If there is a pending timeout disallow this ioctl */
  335                 if (wd_last_u != 0) {
  336                         error = EINVAL;
  337                         break;
  338                 }
  339                 wd_softtimer = u;
  340                 break;
  341         case WDIOC_SETSOFTTIMEOUTACT:
  342                 u = *(int *)data;
  343                 if (wd_valid_act(u)) {
  344                         wd_softtimeout_act = u;
  345                 } else {
  346                         error = EINVAL;
  347                 }
  348                 break;
  349         case WDIOC_SETPRETIMEOUTACT:
  350                 u = *(int *)data;
  351                 if (wd_valid_act(u)) {
  352                         wd_pretimeout_act = u;
  353                 } else {
  354                         error = EINVAL;
  355                 }
  356                 break;
  357         case WDIOC_GETPRETIMEOUT:
  358                 *(int *)data = (int)wd_pretimeout;
  359                 break;
  360         case WDIOC_SETPRETIMEOUT:
  361                 error = wd_set_pretimeout(*(int *)data, false);
  362                 break;
  363         case WDIOC_GETTIMELEFT:
  364                 error = wd_get_time_left(td, &timeleft);
  365                 if (error)
  366                         break;
  367                 *(int *)data = (int)timeleft;
  368                 break;
  369         case WDIOC_SETTIMEOUT:
  370                 u = *(u_int *)data;
  371                 error = wdog_kern_pat(seconds_to_pow2ns(u));
  372                 break;
  373         case WDIOC_GETTIMEOUT:
  374                 u = wdog_kern_last_timeout();
  375                 *(u_int *)data = u;
  376                 break;
  377         case WDIOCPATPAT:
  378                 error = wd_ioctl_patpat(data);
  379                 break;
  380         default:
  381                 error = ENOIOCTL;
  382                 break;
  383         }
  384         return (error);
  385 }
  386 
  387 /*
  388  * Return the last timeout set, this is NOT the seconds from NOW until timeout,
  389  * rather it is the amount of seconds passed to WDIOCPATPAT/WDIOC_SETTIMEOUT.
  390  */
  391 u_int
  392 wdog_kern_last_timeout(void)
  393 {
  394 
  395         return (wd_last_u);
  396 }
  397 
  398 static struct cdevsw wd_cdevsw = {
  399         .d_version =    D_VERSION,
  400         .d_ioctl =      wd_ioctl,
  401         .d_name =       "watchdog",
  402 };
  403 
  404 static int
  405 watchdog_modevent(module_t mod __unused, int type, void *data __unused)
  406 {
  407         switch(type) {
  408         case MOD_LOAD:
  409                 callout_init(&wd_pretimeo_handle, 1);
  410                 callout_init(&wd_softtimeo_handle, 1);
  411                 wd_dev = make_dev(&wd_cdevsw, 0,
  412                     UID_ROOT, GID_WHEEL, 0600, _PATH_WATCHDOG);
  413                 return 0;
  414         case MOD_UNLOAD:
  415                 callout_stop(&wd_pretimeo_handle);
  416                 callout_stop(&wd_softtimeo_handle);
  417                 callout_drain(&wd_pretimeo_handle);
  418                 callout_drain(&wd_softtimeo_handle);
  419                 destroy_dev(wd_dev);
  420                 return 0;
  421         case MOD_SHUTDOWN:
  422                 return 0;
  423         default:
  424                 return EOPNOTSUPP;
  425         }
  426 }
  427 
  428 DEV_MODULE(watchdog, watchdog_modevent, NULL);
Cache object: 9038252282fd1142c60aa8933f00568d
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/dev/watchdog/watchdog.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/watchdog/watchdog.c
