blob: 7204f9662114f01f976fb7396f190f449c9d4f3c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * SoftDog 0.07: A Software Watchdog Device
3 *
Alan Cox29fa0582008-10-27 15:17:56 +00004 * (c) Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>, All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 * Neither Alan Cox nor CymruNet Ltd. admit liability nor provide
12 * warranty for any of this software. This material is provided
13 * "AS-IS" and at no charge.
14 *
15 * (c) Copyright 1995 Alan Cox <alan@lxorguk.ukuu.org.uk>
16 *
17 * Software only watchdog driver. Unlike its big brother the WDT501P
18 * driver this won't always recover a failed machine.
19 *
20 * 03/96: Angelo Haritsis <ah@doc.ic.ac.uk> :
21 * Modularised.
22 * Added soft_margin; use upon insmod to change the timer delay.
23 * NB: uses same minor as wdt (WATCHDOG_MINOR); we could use separate
24 * minors.
25 *
26 * 19980911 Alan Cox
27 * Made SMP safe for 2.3.x
28 *
29 * 20011127 Joel Becker (jlbec@evilplan.org>
30 * Added soft_noboot; Allows testing the softdog trigger without
31 * requiring a recompile.
32 * Added WDIOC_GETTIMEOUT and WDIOC_SETTIMOUT.
33 *
34 * 20020530 Joel Becker <joel.becker@oracle.com>
35 * Added Matt Domsch's nowayout module option.
36 */
37
38#include <linux/module.h>
39#include <linux/moduleparam.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/types.h>
41#include <linux/timer.h>
42#include <linux/miscdevice.h>
43#include <linux/watchdog.h>
44#include <linux/fs.h>
45#include <linux/notifier.h>
46#include <linux/reboot.h>
47#include <linux/init.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080048#include <linux/jiffies.h>
Alan Coxf92d3742008-05-19 14:09:06 +010049#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51#define PFX "SoftDog: "
52
53#define TIMER_MARGIN 60 /* Default is 60 seconds */
54static int soft_margin = TIMER_MARGIN; /* in seconds */
55module_param(soft_margin, int, 0);
Alan Coxf92d3742008-05-19 14:09:06 +010056MODULE_PARM_DESC(soft_margin,
57 "Watchdog soft_margin in seconds. (0 < soft_margin < 65536, default="
58 __MODULE_STRING(TIMER_MARGIN) ")");
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Andrey Panin4bfdf372005-07-27 11:43:58 -070060static int nowayout = WATCHDOG_NOWAYOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061module_param(nowayout, int, 0);
Alan Coxf92d3742008-05-19 14:09:06 +010062MODULE_PARM_DESC(nowayout,
63 "Watchdog cannot be stopped once started (default="
64 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66#ifdef ONLY_TESTING
67static int soft_noboot = 1;
68#else
69static int soft_noboot = 0;
70#endif /* ONLY_TESTING */
71
72module_param(soft_noboot, int, 0);
73MODULE_PARM_DESC(soft_noboot, "Softdog action, set to 1 to ignore reboots, 0 to reboot (default depends on ONLY_TESTING)");
74
75/*
76 * Our timer
77 */
78
79static void watchdog_fire(unsigned long);
80
81static struct timer_list watchdog_ticktock =
82 TIMER_INITIALIZER(watchdog_fire, 0, 0);
Chuck Ebbert1cc77242005-08-19 14:14:07 +020083static unsigned long driver_open, orphan_timer;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084static char expect_close;
85
86
87/*
88 * If the timer expires..
89 */
90
91static void watchdog_fire(unsigned long data)
92{
Chuck Ebbert1cc77242005-08-19 14:14:07 +020093 if (test_and_clear_bit(0, &orphan_timer))
94 module_put(THIS_MODULE);
95
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 if (soft_noboot)
97 printk(KERN_CRIT PFX "Triggered - Reboot ignored.\n");
Alan Coxf92d3742008-05-19 14:09:06 +010098 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 printk(KERN_CRIT PFX "Initiating system reboot.\n");
Andrew Morton479d0f42005-07-26 21:41:38 -0700100 emergency_restart();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 printk(KERN_CRIT PFX "Reboot didn't ?????\n");
102 }
103}
104
105/*
106 * Softdog operations
107 */
108
109static int softdog_keepalive(void)
110{
111 mod_timer(&watchdog_ticktock, jiffies+(soft_margin*HZ));
112 return 0;
113}
114
115static int softdog_stop(void)
116{
117 del_timer(&watchdog_ticktock);
118 return 0;
119}
120
121static int softdog_set_heartbeat(int t)
122{
123 if ((t < 0x0001) || (t > 0xFFFF))
124 return -EINVAL;
125
126 soft_margin = t;
127 return 0;
128}
129
130/*
131 * /dev/watchdog handling
132 */
133
134static int softdog_open(struct inode *inode, struct file *file)
135{
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200136 if (test_and_set_bit(0, &driver_open))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 return -EBUSY;
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200138 if (!test_and_clear_bit(0, &orphan_timer))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 __module_get(THIS_MODULE);
140 /*
141 * Activate timer
142 */
143 softdog_keepalive();
144 return nonseekable_open(inode, file);
145}
146
147static int softdog_release(struct inode *inode, struct file *file)
148{
149 /*
150 * Shut off the timer.
151 * Lock it in if it's a module and we set nowayout
152 */
153 if (expect_close == 42) {
154 softdog_stop();
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200155 module_put(THIS_MODULE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 } else {
Alan Coxf92d3742008-05-19 14:09:06 +0100157 printk(KERN_CRIT PFX
158 "Unexpected close, not stopping watchdog!\n");
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200159 set_bit(0, &orphan_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 softdog_keepalive();
161 }
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200162 clear_bit(0, &driver_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 expect_close = 0;
164 return 0;
165}
166
Alan Coxf92d3742008-05-19 14:09:06 +0100167static ssize_t softdog_write(struct file *file, const char __user *data,
168 size_t len, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
170 /*
171 * Refresh the timer.
172 */
Alan Coxf92d3742008-05-19 14:09:06 +0100173 if (len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 if (!nowayout) {
175 size_t i;
176
177 /* In case it was set long ago */
178 expect_close = 0;
179
180 for (i = 0; i != len; i++) {
181 char c;
182
183 if (get_user(c, data + i))
184 return -EFAULT;
185 if (c == 'V')
186 expect_close = 42;
187 }
188 }
189 softdog_keepalive();
190 }
191 return len;
192}
193
Alan Coxf92d3742008-05-19 14:09:06 +0100194static long softdog_ioctl(struct file *file, unsigned int cmd,
195 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{
197 void __user *argp = (void __user *)arg;
198 int __user *p = argp;
199 int new_margin;
Alan Coxf92d3742008-05-19 14:09:06 +0100200 static const struct watchdog_info ident = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 .options = WDIOF_SETTIMEOUT |
202 WDIOF_KEEPALIVEPING |
203 WDIOF_MAGICCLOSE,
204 .firmware_version = 0,
205 .identity = "Software Watchdog",
206 };
207 switch (cmd) {
Alan Coxf92d3742008-05-19 14:09:06 +0100208 case WDIOC_GETSUPPORT:
209 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
210 case WDIOC_GETSTATUS:
211 case WDIOC_GETBOOTSTATUS:
212 return put_user(0, p);
213 case WDIOC_KEEPALIVE:
214 softdog_keepalive();
215 return 0;
216 case WDIOC_SETTIMEOUT:
217 if (get_user(new_margin, p))
218 return -EFAULT;
219 if (softdog_set_heartbeat(new_margin))
220 return -EINVAL;
221 softdog_keepalive();
222 /* Fall */
223 case WDIOC_GETTIMEOUT:
224 return put_user(soft_margin, p);
Wim Van Sebroeck0c060902008-07-18 11:41:17 +0000225 default:
226 return -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 }
228}
229
230/*
231 * Notifier for system down
232 */
233
234static int softdog_notify_sys(struct notifier_block *this, unsigned long code,
235 void *unused)
236{
Alan Coxf92d3742008-05-19 14:09:06 +0100237 if (code == SYS_DOWN || code == SYS_HALT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 /* Turn the WDT off */
239 softdog_stop();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 return NOTIFY_DONE;
241}
242
243/*
244 * Kernel Interfaces
245 */
246
Arjan van de Ven62322d22006-07-03 00:24:21 -0700247static const struct file_operations softdog_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 .owner = THIS_MODULE,
249 .llseek = no_llseek,
250 .write = softdog_write,
Alan Coxf92d3742008-05-19 14:09:06 +0100251 .unlocked_ioctl = softdog_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 .open = softdog_open,
253 .release = softdog_release,
254};
255
256static struct miscdevice softdog_miscdev = {
257 .minor = WATCHDOG_MINOR,
258 .name = "watchdog",
259 .fops = &softdog_fops,
260};
261
262static struct notifier_block softdog_notifier = {
263 .notifier_call = softdog_notify_sys,
264};
265
266static char banner[] __initdata = KERN_INFO "Software Watchdog Timer: 0.07 initialized. soft_noboot=%d soft_margin=%d sec (nowayout= %d)\n";
267
268static int __init watchdog_init(void)
269{
270 int ret;
271
Alan Coxf92d3742008-05-19 14:09:06 +0100272 /* Check that the soft_margin value is within it's range;
273 if not reset to the default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 if (softdog_set_heartbeat(soft_margin)) {
275 softdog_set_heartbeat(TIMER_MARGIN);
Alan Coxf92d3742008-05-19 14:09:06 +0100276 printk(KERN_INFO PFX
277 "soft_margin must be 0 < soft_margin < 65536, using %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 TIMER_MARGIN);
279 }
280
281 ret = register_reboot_notifier(&softdog_notifier);
282 if (ret) {
Alan Coxf92d3742008-05-19 14:09:06 +0100283 printk(KERN_ERR PFX
284 "cannot register reboot notifier (err=%d)\n", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return ret;
286 }
287
288 ret = misc_register(&softdog_miscdev);
289 if (ret) {
Alan Coxf92d3742008-05-19 14:09:06 +0100290 printk(KERN_ERR PFX
291 "cannot register miscdev on minor=%d (err=%d)\n",
292 WATCHDOG_MINOR, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 unregister_reboot_notifier(&softdog_notifier);
294 return ret;
295 }
296
297 printk(banner, soft_noboot, soft_margin, nowayout);
298
299 return 0;
300}
301
302static void __exit watchdog_exit(void)
303{
304 misc_deregister(&softdog_miscdev);
305 unregister_reboot_notifier(&softdog_notifier);
306}
307
308module_init(watchdog_init);
309module_exit(watchdog_exit);
310
311MODULE_AUTHOR("Alan Cox");
312MODULE_DESCRIPTION("Software Watchdog Device Driver");
313MODULE_LICENSE("GPL");
314MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);