2 * Copyright (c) 2009 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Alex Hornung <ahornung@gmail.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
35 #include <sys/param.h>
36 #include <sys/kernel.h>
37 #include <sys/systm.h>
38 #include <sys/malloc.h>
39 #include <sys/sysproto.h>
40 #include <sys/ioccom.h>
41 #include <sys/spinlock2.h>
43 #include <sys/device.h>
44 #include <sys/filedesc.h>
45 #include <sys/sysctl.h>
46 #include <sys/unistd.h>
47 #include <sys/event.h>
48 #include <sys/queue.h>
50 #include <machine/limits.h>
52 #ifdef WATCHDOG_ENABLE
53 static LIST_HEAD(, watchdog) wdoglist = LIST_HEAD_INITIALIZER(&wdoglist);
54 static struct spinlock wdogmtx;
55 static struct callout wdog_callout;
57 static int wdog_auto_enable = 1;
58 static int wdog_auto_period = WDOG_DEFAULT_PERIOD;
60 static void wdog_reset_all(void *unused);
63 wdog_register(struct watchdog *wd)
66 wd->period = WDOG_DEFAULT_PERIOD;
67 LIST_INSERT_HEAD(&wdoglist, wd, link);
68 spin_unlock(&wdogmtx);
72 kprintf("wdog: Watchdog %s registered, max period = %ds , period = %ds\n",
73 wd->name, wd->period_max, wd->period);
77 wdog_unregister(struct watchdog *wd)
80 LIST_REMOVE(wd, link);
81 spin_unlock(&wdogmtx);
83 kprintf("wdog: Watchdog %s unregistered\n", wd->name);
87 wdog_reset(struct watchdog *wd)
89 return (wd->period = wd->wdog_fn(wd->arg, wd->period));
93 wdog_reset_all(void *unused)
96 int period, min_period = INT_MAX;
99 LIST_FOREACH(wd, &wdoglist, link) {
100 period = wdog_reset(wd);
101 if (period < min_period)
104 if (wdog_auto_enable)
105 callout_reset(&wdog_callout, min_period * hz / 2, wdog_reset_all, NULL);
107 wdog_auto_period = min_period;
109 spin_unlock(&wdogmtx);
113 wdog_set_period(int period)
118 LIST_FOREACH(wd, &wdoglist, link) {
119 /* XXX: check for period_max */
122 spin_unlock(&wdogmtx);
127 wdog_sysctl_auto(SYSCTL_HANDLER_ARGS)
131 error = sysctl_handle_int(oidp, &wdog_auto_enable, 1, req);
132 if (error || req->newptr == NULL)
135 /* has changed, do something */
136 callout_stop(&wdog_callout);
137 if (wdog_auto_enable) {
138 wdog_reset_all(NULL);
141 kprintf("wdog: In-kernel automatic watchdog reset %s\n",
142 (wdog_auto_enable)?"enabled":"disabled");
148 wdog_sysctl_period(SYSCTL_HANDLER_ARGS)
152 error = sysctl_handle_int(oidp, &wdog_auto_period, WDOG_DEFAULT_PERIOD, req);
153 if (error || req->newptr == NULL)
156 /* has changed, do something */
157 callout_stop(&wdog_callout);
158 wdog_set_period(wdog_auto_period);
159 wdog_reset_all(NULL);
161 if (wdog_auto_period != 0)
162 kprintf("wdog: Watchdog period set to %ds\n", wdog_auto_period);
164 kprintf("wdog: Disabled watchdog(s)\n");
172 callout_stop(&wdog_callout);
174 wdog_reset_all(NULL);
177 static SYSCTL_NODE(_kern, OID_AUTO, watchdog, CTLFLAG_RW, 0, "watchdog");
178 SYSCTL_PROC(_kern_watchdog, OID_AUTO, auto, CTLTYPE_INT | CTLFLAG_RW,
179 NULL, 0, wdog_sysctl_auto, "I", "auto in-kernel watchdog reset "
180 "(0 = disabled, 1 = enabled)");
181 SYSCTL_PROC(_kern_watchdog, OID_AUTO, period, CTLTYPE_INT | CTLFLAG_RW,
182 NULL, 0, wdog_sysctl_period, "I", "watchdog period "
183 "(value in seconds)");
187 wdog_ioctl(struct dev_ioctl_args *ap)
189 if (wdog_auto_enable)
192 if (ap->a_cmd == WDIOCRESET) {
193 wdog_reset_all(NULL);
201 static struct dev_ops wdog_ops = {
203 .d_ioctl = wdog_ioctl,
210 make_dev(&wdog_ops, 0,
211 UID_ROOT, GID_WHEEL, 0600, "wdog");
212 callout_init_mp(&wdog_callout);
214 kprintf("wdog: In-kernel automatic watchdog reset %s\n",
215 (wdog_auto_enable)?"enabled":"disabled");
221 callout_stop(&wdog_callout);
222 callout_deactivate(&wdog_callout);
223 dev_ops_remove_all(&wdog_ops);
224 spin_uninit(&wdogmtx);
227 SYSINIT(wdog_register, SI_SUB_PRE_DRIVERS, SI_ORDER_ANY, wdog_init, NULL);
228 SYSUNINIT(wdog_register, SI_SUB_PRE_DRIVERS, SI_ORDER_ANY, wdog_uninit, NULL);
230 #endif /* WATCHDOG_ENABLE */