PageRenderTime 35ms CodeModel.GetById 19ms app.highlight 13ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/char/watchdog/softdog.c

https://bitbucket.org/evzijst/gittest
C | 309 lines | 198 code | 42 blank | 69 comment | 23 complexity | a71616c355eabf7da18ea6539f8dec55 MD5 | raw file
  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);