aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/char/watchdog/softdog.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/char/watchdog/softdog.c')
-rw-r--r--drivers/char/watchdog/softdog.c309
1 files changed, 309 insertions, 0 deletions
diff --git a/drivers/char/watchdog/softdog.c b/drivers/char/watchdog/softdog.c
new file mode 100644
index 000000000000..117903498a01
--- /dev/null
+++ b/drivers/char/watchdog/softdog.c
@@ -0,0 +1,309 @@
1/*
2 * SoftDog 0.07: A Software Watchdog Device
3 *
4 * (c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
5 * http://www.redhat.com
6 *
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>
36 * Added Matt Domsch's nowayout module option.
37 */
38
39#include <linux/module.h>
40#include <linux/moduleparam.h>
41#include <linux/config.h>
42#include <linux/types.h>
43#include <linux/timer.h>
44#include <linux/miscdevice.h>
45#include <linux/watchdog.h>
46#include <linux/fs.h>
47#include <linux/notifier.h>
48#include <linux/reboot.h>
49#include <linux/init.h>
50#include <asm/uaccess.h>
51
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);
57MODULE_PARM_DESC(soft_margin, "Watchdog soft_margin in seconds. (0<soft_margin<65536, default=" __MODULE_STRING(TIMER_MARGIN) ")");
58
59#ifdef CONFIG_WATCHDOG_NOWAYOUT
60static int nowayout = 1;
61#else
62static int nowayout = 0;
63#endif
64
65module_param(nowayout, int, 0);
66MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
67
68#ifdef ONLY_TESTING
69static int soft_noboot = 1;
70#else
71static int soft_noboot = 0;
72#endif /* ONLY_TESTING */
73
74module_param(soft_noboot, int, 0);
75MODULE_PARM_DESC(soft_noboot, "Softdog action, set to 1 to ignore reboots, 0 to reboot (default depends on ONLY_TESTING)");
76
77/*
78 * Our timer
79 */
80
81static void watchdog_fire(unsigned long);
82
83static struct timer_list watchdog_ticktock =
84 TIMER_INITIALIZER(watchdog_fire, 0, 0);
85static unsigned long timer_alive;
86static char expect_close;
87
88
89/*
90 * If the timer expires..
91 */
92
93static void watchdog_fire(unsigned long data)
94{
95 if (soft_noboot)
96 printk(KERN_CRIT PFX "Triggered - Reboot ignored.\n");
97 else
98 {
99 printk(KERN_CRIT PFX "Initiating system reboot.\n");
100 machine_restart(NULL);
101 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{
136 if(test_and_set_bit(0, &timer_alive))
137 return -EBUSY;
138 if (nowayout)
139 __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();
155 } else {
156 printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
157 softdog_keepalive();
158 }
159 clear_bit(0, &timer_alive);
160 expect_close = 0;
161 return 0;
162}
163
164static ssize_t softdog_write(struct file *file, const char __user *data, size_t len, loff_t *ppos)
165{
166 /*
167 * Refresh the timer.
168 */
169 if(len) {
170 if (!nowayout) {
171 size_t i;
172
173 /* In case it was set long ago */
174 expect_close = 0;
175
176 for (i = 0; i != len; i++) {
177 char c;
178
179 if (get_user(c, data + i))
180 return -EFAULT;
181 if (c == 'V')
182 expect_close = 42;
183 }
184 }
185 softdog_keepalive();
186 }
187 return len;
188}
189
190static int softdog_ioctl(struct inode *inode, struct file *file,
191 unsigned int cmd, unsigned long arg)
192{
193 void __user *argp = (void __user *)arg;
194 int __user *p = argp;
195 int new_margin;
196 static struct watchdog_info ident = {
197 .options = WDIOF_SETTIMEOUT |
198 WDIOF_KEEPALIVEPING |
199 WDIOF_MAGICCLOSE,
200 .firmware_version = 0,
201 .identity = "Software Watchdog",
202 };
203 switch (cmd) {
204 default:
205 return -ENOIOCTLCMD;
206 case WDIOC_GETSUPPORT:
207 return copy_to_user(argp, &ident,
208 sizeof(ident)) ? -EFAULT : 0;
209 case WDIOC_GETSTATUS:
210 case WDIOC_GETBOOTSTATUS:
211 return put_user(0, p);
212 case WDIOC_KEEPALIVE:
213 softdog_keepalive();
214 return 0;
215 case WDIOC_SETTIMEOUT:
216 if (get_user(new_margin, p))
217 return -EFAULT;
218 if (softdog_set_heartbeat(new_margin))
219 return -EINVAL;
220 softdog_keepalive();
221 /* Fall */
222 case WDIOC_GETTIMEOUT:
223 return put_user(soft_margin, p);
224 }
225}
226
227/*
228 * Notifier for system down
229 */
230
231static int softdog_notify_sys(struct notifier_block *this, unsigned long code,
232 void *unused)
233{
234 if(code==SYS_DOWN || code==SYS_HALT) {
235 /* Turn the WDT off */
236 softdog_stop();
237 }
238 return NOTIFY_DONE;
239}
240
241/*
242 * Kernel Interfaces
243 */
244
245static struct file_operations softdog_fops = {
246 .owner = THIS_MODULE,
247 .llseek = no_llseek,
248 .write = softdog_write,
249 .ioctl = softdog_ioctl,
250 .open = softdog_open,
251 .release = softdog_release,
252};
253
254static struct miscdevice softdog_miscdev = {
255 .minor = WATCHDOG_MINOR,
256 .name = "watchdog",
257 .fops = &softdog_fops,
258};
259
260static struct notifier_block softdog_notifier = {
261 .notifier_call = softdog_notify_sys,
262};
263
264static char banner[] __initdata = KERN_INFO "Software Watchdog Timer: 0.07 initialized. soft_noboot=%d soft_margin=%d sec (nowayout= %d)\n";
265
266static int __init watchdog_init(void)
267{
268 int ret;
269
270 /* Check that the soft_margin value is within it's range ; if not reset to the default */
271 if (softdog_set_heartbeat(soft_margin)) {
272 softdog_set_heartbeat(TIMER_MARGIN);
273 printk(KERN_INFO PFX "soft_margin value must be 0<soft_margin<65536, using %d\n",
274 TIMER_MARGIN);
275 }
276
277 ret = register_reboot_notifier(&softdog_notifier);
278 if (ret) {
279 printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
280 ret);
281 return ret;
282 }
283
284 ret = misc_register(&softdog_miscdev);
285 if (ret) {
286 printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
287 WATCHDOG_MINOR, ret);
288 unregister_reboot_notifier(&softdog_notifier);
289 return ret;
290 }
291
292 printk(banner, soft_noboot, soft_margin, nowayout);
293
294 return 0;
295}
296
297static void __exit watchdog_exit(void)
298{
299 misc_deregister(&softdog_miscdev);
300 unregister_reboot_notifier(&softdog_notifier);
301}
302
303module_init(watchdog_init);
304module_exit(watchdog_exit);
305
306MODULE_AUTHOR("Alan Cox");
307MODULE_DESCRIPTION("Software Watchdog Device Driver");
308MODULE_LICENSE("GPL");
309MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);