blob: ebcc9cea5e99e40ec31917f9c4c9dd90da81d8a5 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * SoftDog 0.07: A Software Watchdog Device
3 *
Wim Van Sebroeck143a2e52009-03-18 08:35:09 +00004 * (c) Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>,
5 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * Neither Alan Cox nor CymruNet Ltd. admit liability nor provide
13 * warranty for any of this software. This material is provided
14 * "AS-IS" and at no charge.
15 *
16 * (c) Copyright 1995 Alan Cox <alan@lxorguk.ukuu.org.uk>
17 *
18 * Software only watchdog driver. Unlike its big brother the WDT501P
19 * driver this won't always recover a failed machine.
20 *
21 * 03/96: Angelo Haritsis <ah@doc.ic.ac.uk> :
22 * Modularised.
23 * Added soft_margin; use upon insmod to change the timer delay.
24 * NB: uses same minor as wdt (WATCHDOG_MINOR); we could use separate
25 * minors.
26 *
27 * 19980911 Alan Cox
28 * Made SMP safe for 2.3.x
29 *
30 * 20011127 Joel Becker (jlbec@evilplan.org>
31 * Added soft_noboot; Allows testing the softdog trigger without
32 * requiring a recompile.
33 * Added WDIOC_GETTIMEOUT and WDIOC_SETTIMOUT.
34 *
35 * 20020530 Joel Becker <joel.becker@oracle.com>
Wim Van Sebroeck143a2e52009-03-18 08:35:09 +000036 * Added Matt Domsch's nowayout module option.
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 */
38
39#include <linux/module.h>
40#include <linux/moduleparam.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/types.h>
42#include <linux/timer.h>
43#include <linux/miscdevice.h>
44#include <linux/watchdog.h>
45#include <linux/fs.h>
46#include <linux/notifier.h>
47#include <linux/reboot.h>
48#include <linux/init.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080049#include <linux/jiffies.h>
Alan Coxf92d3742008-05-19 14:09:06 +010050#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52#define PFX "SoftDog: "
53
54#define TIMER_MARGIN 60 /* Default is 60 seconds */
55static int soft_margin = TIMER_MARGIN; /* in seconds */
56module_param(soft_margin, int, 0);
Alan Coxf92d3742008-05-19 14:09:06 +010057MODULE_PARM_DESC(soft_margin,
58 "Watchdog soft_margin in seconds. (0 < soft_margin < 65536, default="
59 __MODULE_STRING(TIMER_MARGIN) ")");
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Andrey Panin4bfdf372005-07-27 11:43:58 -070061static int nowayout = WATCHDOG_NOWAYOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062module_param(nowayout, int, 0);
Alan Coxf92d3742008-05-19 14:09:06 +010063MODULE_PARM_DESC(nowayout,
64 "Watchdog cannot be stopped once started (default="
65 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67#ifdef ONLY_TESTING
68static int soft_noboot = 1;
69#else
70static int soft_noboot = 0;
71#endif /* ONLY_TESTING */
72
73module_param(soft_noboot, int, 0);
74MODULE_PARM_DESC(soft_noboot, "Softdog action, set to 1 to ignore reboots, 0 to reboot (default depends on ONLY_TESTING)");
75
76/*
77 * Our timer
78 */
79
80static void watchdog_fire(unsigned long);
81
82static struct timer_list watchdog_ticktock =
83 TIMER_INITIALIZER(watchdog_fire, 0, 0);
Chuck Ebbert1cc77242005-08-19 14:14:07 +020084static unsigned long driver_open, orphan_timer;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085static char expect_close;
86
87
88/*
89 * If the timer expires..
90 */
91
92static void watchdog_fire(unsigned long data)
93{
Chuck Ebbert1cc77242005-08-19 14:14:07 +020094 if (test_and_clear_bit(0, &orphan_timer))
95 module_put(THIS_MODULE);
96
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 if (soft_noboot)
98 printk(KERN_CRIT PFX "Triggered - Reboot ignored.\n");
Alan Coxf92d3742008-05-19 14:09:06 +010099 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 printk(KERN_CRIT PFX "Initiating system reboot.\n");
Andrew Morton479d0f42005-07-26 21:41:38 -0700101 emergency_restart();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 printk(KERN_CRIT PFX "Reboot didn't ?????\n");
103 }
104}
105
106/*
107 * Softdog operations
108 */
109
110static int softdog_keepalive(void)
111{
112 mod_timer(&watchdog_ticktock, jiffies+(soft_margin*HZ));
113 return 0;
114}
115
116static int softdog_stop(void)
117{
118 del_timer(&watchdog_ticktock);
119 return 0;
120}
121
122static int softdog_set_heartbeat(int t)
123{
124 if ((t < 0x0001) || (t > 0xFFFF))
125 return -EINVAL;
126
127 soft_margin = t;
128 return 0;
129}
130
131/*
132 * /dev/watchdog handling
133 */
134
135static int softdog_open(struct inode *inode, struct file *file)
136{
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200137 if (test_and_set_bit(0, &driver_open))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 return -EBUSY;
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200139 if (!test_and_clear_bit(0, &orphan_timer))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 __module_get(THIS_MODULE);
141 /*
142 * Activate timer
143 */
144 softdog_keepalive();
145 return nonseekable_open(inode, file);
146}
147
148static int softdog_release(struct inode *inode, struct file *file)
149{
150 /*
151 * Shut off the timer.
152 * Lock it in if it's a module and we set nowayout
153 */
154 if (expect_close == 42) {
155 softdog_stop();
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200156 module_put(THIS_MODULE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 } else {
Alan Coxf92d3742008-05-19 14:09:06 +0100158 printk(KERN_CRIT PFX
159 "Unexpected close, not stopping watchdog!\n");
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200160 set_bit(0, &orphan_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 softdog_keepalive();
162 }
Chuck Ebbert1cc77242005-08-19 14:14:07 +0200163 clear_bit(0, &driver_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 expect_close = 0;
165 return 0;
166}
167
Alan Coxf92d3742008-05-19 14:09:06 +0100168static ssize_t softdog_write(struct file *file, const char __user *data,
169 size_t len, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
171 /*
172 * Refresh the timer.
173 */
Alan Coxf92d3742008-05-19 14:09:06 +0100174 if (len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 if (!nowayout) {
176 size_t i;
177
178 /* In case it was set long ago */
179 expect_close = 0;
180
181 for (i = 0; i != len; i++) {
182 char c;
183
184 if (get_user(c, data + i))
185 return -EFAULT;
186 if (c == 'V')
187 expect_close = 42;
188 }
189 }
190 softdog_keepalive();
191 }
192 return len;
193}
194
Alan Coxf92d3742008-05-19 14:09:06 +0100195static long softdog_ioctl(struct file *file, unsigned int cmd,
196 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197{
198 void __user *argp = (void __user *)arg;
199 int __user *p = argp;
200 int new_margin;
Alan Coxf92d3742008-05-19 14:09:06 +0100201 static const struct watchdog_info ident = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 .options = WDIOF_SETTIMEOUT |
203 WDIOF_KEEPALIVEPING |
204 WDIOF_MAGICCLOSE,
205 .firmware_version = 0,
206 .identity = "Software Watchdog",
207 };
208 switch (cmd) {
Alan Coxf92d3742008-05-19 14:09:06 +0100209 case WDIOC_GETSUPPORT:
210 return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
211 case WDIOC_GETSTATUS:
212 case WDIOC_GETBOOTSTATUS:
213 return put_user(0, p);
214 case WDIOC_KEEPALIVE:
215 softdog_keepalive();
216 return 0;
217 case WDIOC_SETTIMEOUT:
218 if (get_user(new_margin, p))
219 return -EFAULT;
220 if (softdog_set_heartbeat(new_margin))
221 return -EINVAL;
222 softdog_keepalive();
223 /* Fall */
224 case WDIOC_GETTIMEOUT:
225 return put_user(soft_margin, p);
Wim Van Sebroeck0c060902008-07-18 11:41:17 +0000226 default:
227 return -ENOTTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
229}
230
231/*
232 * Notifier for system down
233 */
234
235static int softdog_notify_sys(struct notifier_block *this, unsigned long code,
236 void *unused)
237{
Alan Coxf92d3742008-05-19 14:09:06 +0100238 if (code == SYS_DOWN || code == SYS_HALT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 /* Turn the WDT off */
240 softdog_stop();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 return NOTIFY_DONE;
242}
243
244/*
245 * Kernel Interfaces
246 */
247
Arjan van de Ven62322d22006-07-03 00:24:21 -0700248static const struct file_operations softdog_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 .owner = THIS_MODULE,
250 .llseek = no_llseek,
251 .write = softdog_write,
Alan Coxf92d3742008-05-19 14:09:06 +0100252 .unlocked_ioctl = softdog_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 .open = softdog_open,
254 .release = softdog_release,
255};
256
257static struct miscdevice softdog_miscdev = {
258 .minor = WATCHDOG_MINOR,
259 .name = "watchdog",
260 .fops = &softdog_fops,
261};
262
263static struct notifier_block softdog_notifier = {
264 .notifier_call = softdog_notify_sys,
265};
266
267static char banner[] __initdata = KERN_INFO "Software Watchdog Timer: 0.07 initialized. soft_noboot=%d soft_margin=%d sec (nowayout= %d)\n";
268
269static int __init watchdog_init(void)
270{
271 int ret;
272
Alan Coxf92d3742008-05-19 14:09:06 +0100273 /* Check that the soft_margin value is within it's range;
274 if not reset to the default */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 if (softdog_set_heartbeat(soft_margin)) {
276 softdog_set_heartbeat(TIMER_MARGIN);
Alan Coxf92d3742008-05-19 14:09:06 +0100277 printk(KERN_INFO PFX
278 "soft_margin must be 0 < soft_margin < 65536, using %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 TIMER_MARGIN);
280 }
281
282 ret = register_reboot_notifier(&softdog_notifier);
283 if (ret) {
Alan Coxf92d3742008-05-19 14:09:06 +0100284 printk(KERN_ERR PFX
285 "cannot register reboot notifier (err=%d)\n", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 return ret;
287 }
288
289 ret = misc_register(&softdog_miscdev);
290 if (ret) {
Alan Coxf92d3742008-05-19 14:09:06 +0100291 printk(KERN_ERR PFX
292 "cannot register miscdev on minor=%d (err=%d)\n",
293 WATCHDOG_MINOR, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 unregister_reboot_notifier(&softdog_notifier);
295 return ret;
296 }
297
298 printk(banner, soft_noboot, soft_margin, nowayout);
299
300 return 0;
301}
302
303static void __exit watchdog_exit(void)
304{
305 misc_deregister(&softdog_miscdev);
306 unregister_reboot_notifier(&softdog_notifier);
307}
308
309module_init(watchdog_init);
310module_exit(watchdog_exit);
311
312MODULE_AUTHOR("Alan Cox");
313MODULE_DESCRIPTION("Software Watchdog Device Driver");
314MODULE_LICENSE("GPL");
315MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);