1/* UML hardware watchdog, shamelessly stolen from:
2 *
3 *	SoftDog	0.05:	A Software Watchdog Device
4 *
5 *	(c) Copyright 1996 Alan Cox <alan@redhat.com>, All Rights Reserved.
6 *				http://www.redhat.com
7 *
8 *	This program is free software; you can redistribute it and/or
9 *	modify it under the terms of the GNU General Public License
10 *	as published by the Free Software Foundation; either version
11 *	2 of the License, or (at your option) any later version.
12 *
13 *	Neither Alan Cox nor CymruNet Ltd. admit liability nor provide
14 *	warranty for any of this software. This material is provided
15 *	"AS-IS" and at no charge.
16 *
17 *	(c) Copyright 1995    Alan Cox <alan@lxorguk.ukuu.org.uk>
18 *
19 *	Software only watchdog driver. Unlike its big brother the WDT501P
20 *	driver this won't always recover a failed machine.
21 *
22 *  03/96: Angelo Haritsis <ah@doc.ic.ac.uk> :
23 *	Modularised.
24 *	Added soft_margin; use upon insmod to change the timer delay.
25 *	NB: uses same minor as wdt (WATCHDOG_MINOR); we could use separate
26 *	    minors.
27 *
28 *  19980911 Alan Cox
29 *	Made SMP safe for 2.3.x
30 *
31 *  20011127 Joel Becker (jlbec@evilplan.org>
32 *	Added soft_noboot; Allows testing the softdog trigger without
33 *	requiring a recompile.
34 *	Added WDIOC_GETTIMEOUT and WDIOC_SETTIMOUT.
35 */
36
37#include <linux/module.h>
38#include <linux/types.h>
39#include <linux/kernel.h>
40#include <linux/fs.h>
41#include <linux/mm.h>
42#include <linux/miscdevice.h>
43#include <linux/watchdog.h>
44#include <linux/reboot.h>
45#include <linux/mutex.h>
46#include <linux/init.h>
47#include <linux/spinlock.h>
48#include <asm/uaccess.h>
49#include "mconsole.h"
50
51MODULE_LICENSE("GPL");
52
53static DEFINE_MUTEX(harddog_mutex);
54static DEFINE_SPINLOCK(lock);
55static int timer_alive;
56static int harddog_in_fd = -1;
57static int harddog_out_fd = -1;
58
59/*
60 *	Allow only one person to hold it open
61 */
62
63extern int start_watchdog(int *in_fd_ret, int *out_fd_ret, char *sock);
64
65static int harddog_open(struct inode *inode, struct file *file)
66{
67	int err = -EBUSY;
68	char *sock = NULL;
69
70	mutex_lock(&harddog_mutex);
71	spin_lock(&lock);
72	if(timer_alive)
73		goto err;
74#ifdef CONFIG_WATCHDOG_NOWAYOUT
75	__module_get(THIS_MODULE);
76#endif
77
78#ifdef CONFIG_MCONSOLE
79	sock = mconsole_notify_socket();
80#endif
81	err = start_watchdog(&harddog_in_fd, &harddog_out_fd, sock);
82	if(err)
83		goto err;
84
85	timer_alive = 1;
86	spin_unlock(&lock);
87	mutex_unlock(&harddog_mutex);
88	return nonseekable_open(inode, file);
89err:
90	spin_unlock(&lock);
91	mutex_unlock(&harddog_mutex);
92	return err;
93}
94
95extern void stop_watchdog(int in_fd, int out_fd);
96
97static int harddog_release(struct inode *inode, struct file *file)
98{
99	/*
100	 *	Shut off the timer.
101	 */
102
103	spin_lock(&lock);
104
105	stop_watchdog(harddog_in_fd, harddog_out_fd);
106	harddog_in_fd = -1;
107	harddog_out_fd = -1;
108
109	timer_alive=0;
110	spin_unlock(&lock);
111
112	return 0;
113}
114
115extern int ping_watchdog(int fd);
116
117static ssize_t harddog_write(struct file *file, const char __user *data, size_t len,
118			     loff_t *ppos)
119{
120	/*
121	 *	Refresh the timer.
122	 */
123	if(len)
124		return ping_watchdog(harddog_out_fd);
125	return 0;
126}
127
128static int harddog_ioctl_unlocked(struct file *file,
129				  unsigned int cmd, unsigned long arg)
130{
131	void __user *argp= (void __user *)arg;
132	static struct watchdog_info ident = {
133		WDIOC_SETTIMEOUT,
134		0,
135		"UML Hardware Watchdog"
136	};
137	switch (cmd) {
138		default:
139			return -ENOTTY;
140		case WDIOC_GETSUPPORT:
141			if(copy_to_user(argp, &ident, sizeof(ident)))
142				return -EFAULT;
143			return 0;
144		case WDIOC_GETSTATUS:
145		case WDIOC_GETBOOTSTATUS:
146			return put_user(0,(int __user *)argp);
147		case WDIOC_KEEPALIVE:
148			return ping_watchdog(harddog_out_fd);
149	}
150}
151
152static long harddog_ioctl(struct file *file,
153			  unsigned int cmd, unsigned long arg)
154{
155	long ret;
156
157	mutex_lock(&harddog_mutex);
158	ret = harddog_ioctl_unlocked(file, cmd, arg);
159	mutex_unlock(&harddog_mutex);
160
161	return ret;
162}
163
164static const struct file_operations harddog_fops = {
165	.owner		= THIS_MODULE,
166	.write		= harddog_write,
167	.unlocked_ioctl	= harddog_ioctl,
168	.open		= harddog_open,
169	.release	= harddog_release,
170	.llseek		= no_llseek,
171};
172
173static struct miscdevice harddog_miscdev = {
174	.minor		= WATCHDOG_MINOR,
175	.name		= "watchdog",
176	.fops		= &harddog_fops,
177};
178
179static char banner[] __initdata = KERN_INFO "UML Watchdog Timer\n";
180
181static int __init harddog_init(void)
182{
183	int ret;
184
185	ret = misc_register(&harddog_miscdev);
186
187	if (ret)
188		return ret;
189
190	printk(banner);
191
192	return 0;
193}
194
195static void __exit harddog_exit(void)
196{
197	misc_deregister(&harddog_miscdev);
198}
199
200module_init(harddog_init);
201module_exit(harddog_exit);
202