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