[deliverable/linux.git] / drivers / s390 / char / vmwatchdog.c

/*
 * Watchdog implementation based on z/VM Watchdog Timer API
 *
 * The user space watchdog daemon can use this driver as
 * /dev/vmwatchdog to have z/VM execute the specified CP
 * command when the timeout expires. The default command is
 * "IPL", which which cause an immediate reboot.
 */
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/watchdog.h>
#include <linux/smp_lock.h>

#include <asm/ebcdic.h>
#include <asm/io.h>
#include <asm/uaccess.h>

#define MAX_CMDLEN 240
#define MIN_INTERVAL 15
static char vmwdt_cmd[MAX_CMDLEN] = "IPL";
static int vmwdt_conceal;

static int vmwdt_nowayout = WATCHDOG_NOWAYOUT;

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
MODULE_DESCRIPTION("z/VM Watchdog Timer");
module_param_string(cmd, vmwdt_cmd, MAX_CMDLEN, 0644);
MODULE_PARM_DESC(cmd, "CP command that is run when the watchdog triggers");
module_param_named(conceal, vmwdt_conceal, bool, 0644);
MODULE_PARM_DESC(conceal, "Enable the CONCEAL CP option while the watchdog "
		" is active");
module_param_named(nowayout, vmwdt_nowayout, bool, 0);
MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started"
		" (default=CONFIG_WATCHDOG_NOWAYOUT)");
MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

static unsigned int vmwdt_interval = 60;
static unsigned long vmwdt_is_open;
static int vmwdt_expect_close;

enum vmwdt_func {
	/* function codes */
	wdt_init   = 0,
	wdt_change = 1,
	wdt_cancel = 2,
	/* flags */
	wdt_conceal = 0x80000000,
};

static int __diag288(enum vmwdt_func func, unsigned int timeout,
			    char *cmd, size_t len)
{
	register unsigned long __func asm("2") = func;
	register unsigned long __timeout asm("3") = timeout;
	register unsigned long __cmdp asm("4") = virt_to_phys(cmd);
	register unsigned long __cmdl asm("5") = len;
	int err;

	err = -EINVAL;
	asm volatile(
		"	diag	%1,%3,0x288\n"
		"0:	la	%0,0\n"
		"1:\n"
		EX_TABLE(0b,1b)
		: "+d" (err) : "d"(__func), "d"(__timeout),
		  "d"(__cmdp), "d"(__cmdl) : "1", "cc");
	return err;
}

static int vmwdt_keepalive(void)
{
	/* we allocate new memory every time to avoid having
	 * to track the state. static allocation is not an
	 * option since that might not be contiguous in real
	 * storage in case of a modular build */
	static char *ebc_cmd;
	size_t len;
	int ret;
	unsigned int func;

	ebc_cmd = kmalloc(MAX_CMDLEN, GFP_KERNEL);
	if (!ebc_cmd)
		return -ENOMEM;

	len = strlcpy(ebc_cmd, vmwdt_cmd, MAX_CMDLEN);
	ASCEBC(ebc_cmd, MAX_CMDLEN);
	EBC_TOUPPER(ebc_cmd, MAX_CMDLEN);

	func = vmwdt_conceal ? (wdt_init | wdt_conceal) : wdt_init;
	ret = __diag288(func, vmwdt_interval, ebc_cmd, len);
	WARN_ON(ret != 0);
	kfree(ebc_cmd);
	return ret;
}

static int vmwdt_disable(void)
{
	int ret = __diag288(wdt_cancel, 0, "", 0);
	WARN_ON(ret != 0);
	return ret;
}

static int __init vmwdt_probe(void)
{
	/* there is no real way to see if the watchdog is supported,
	 * so we try initializing it with a NOP command ("BEGIN")
	 * that won't cause any harm even if the following disable
	 * fails for some reason */
	static char __initdata ebc_begin[] = {
		194, 197, 199, 201, 213
	};
	if (__diag288(wdt_init, 15, ebc_begin, sizeof(ebc_begin)) != 0)
		return -EINVAL;
	return vmwdt_disable();
}

static int vmwdt_open(struct inode *i, struct file *f)
{
	int ret;
	lock_kernel();
	if (test_and_set_bit(0, &vmwdt_is_open)) {
		unlock_kernel();
		return -EBUSY;
	}
	ret = vmwdt_keepalive();
	if (ret)
		clear_bit(0, &vmwdt_is_open);
	unlock_kernel();
	return ret ? ret : nonseekable_open(i, f);
}

static int vmwdt_close(struct inode *i, struct file *f)
{
	if (vmwdt_expect_close == 42)
		vmwdt_disable();
	vmwdt_expect_close = 0;
	clear_bit(0, &vmwdt_is_open);
	return 0;
}

static struct watchdog_info vmwdt_info = {
	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
	.firmware_version = 0,
	.identity = "z/VM Watchdog Timer",
};

static int vmwdt_ioctl(struct inode *i, struct file *f,
			  unsigned int cmd, unsigned long arg)
{
	switch (cmd) {
	case WDIOC_GETSUPPORT:
		if (copy_to_user((void __user *)arg, &vmwdt_info,
					sizeof(vmwdt_info)))
			return -EFAULT;
		return 0;
	case WDIOC_GETSTATUS:
	case WDIOC_GETBOOTSTATUS:
		return put_user(0, (int __user *)arg);
	case WDIOC_GETTEMP:
		return -EINVAL;
	case WDIOC_SETOPTIONS:
		{
			int options, ret;
			if (get_user(options, (int __user *)arg))
				return -EFAULT;
			ret = -EINVAL;
			if (options & WDIOS_DISABLECARD) {
				ret = vmwdt_disable();
				if (ret)
					return ret;
			}
			if (options & WDIOS_ENABLECARD) {
				ret = vmwdt_keepalive();
			}
			return ret;
		}
	case WDIOC_GETTIMEOUT:
		return put_user(vmwdt_interval, (int __user *)arg);
	case WDIOC_SETTIMEOUT:
		{
			int interval;
			if (get_user(interval, (int __user *)arg))
				return -EFAULT;
			if (interval < MIN_INTERVAL)
				return -EINVAL;
			vmwdt_interval = interval;
		}
		return vmwdt_keepalive();
	case WDIOC_KEEPALIVE:
		return vmwdt_keepalive();
	}

	return -EINVAL;
}

static ssize_t vmwdt_write(struct file *f, const char __user *buf,
				size_t count, loff_t *ppos)
{
	if(count) {
		if (!vmwdt_nowayout) {
			size_t i;

			/* note: just in case someone wrote the magic character
			 * five months ago... */
			vmwdt_expect_close = 0;

			for (i = 0; i != count; i++) {
				char c;
				if (get_user(c, buf+i))
					return -EFAULT;
				if (c == 'V')
					vmwdt_expect_close = 42;
			}
		}
		/* someone wrote to us, we should restart timer */
		vmwdt_keepalive();
	}
	return count;
}

static const struct file_operations vmwdt_fops = {
	.open    = &vmwdt_open,
	.release = &vmwdt_close,
	.ioctl   = &vmwdt_ioctl,
	.write   = &vmwdt_write,
	.owner   = THIS_MODULE,
};

static struct miscdevice vmwdt_dev = {
	.minor      = WATCHDOG_MINOR,
	.name       = "watchdog",
	.fops       = &vmwdt_fops,
};

static int __init vmwdt_init(void)
{
	int ret;

	ret = vmwdt_probe();
	if (ret)
		return ret;
	return misc_register(&vmwdt_dev);
}
module_init(vmwdt_init);

static void __exit vmwdt_exit(void)
{
	WARN_ON(misc_deregister(&vmwdt_dev) != 0);
}
module_exit(vmwdt_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Watchdog implementation based on z/VM Watchdog Timer API
	3	*
	4	* The user space watchdog daemon can use this driver as
	5	* /dev/vmwatchdog to have z/VM execute the specified CP
	6	* command when the timeout expires. The default command is
	7	* "IPL", which which cause an immediate reboot.
	8	*/
	9	#include <linux/init.h>
	10	#include <linux/fs.h>
	11	#include <linux/kernel.h>
	12	#include <linux/miscdevice.h>
	13	#include <linux/module.h>
	14	#include <linux/moduleparam.h>
	15	#include <linux/watchdog.h>
3e0420f0	16	#include <linux/smp_lock.h>
1da177e4 LT	17
	18	#include <asm/ebcdic.h>
	19	#include <asm/io.h>
	20	#include <asm/uaccess.h>
	21
	22	#define MAX_CMDLEN 240
	23	#define MIN_INTERVAL 15
	24	static char vmwdt_cmd[MAX_CMDLEN] = "IPL";
	25	static int vmwdt_conceal;
	26
4bfdf378	27	static int vmwdt_nowayout = WATCHDOG_NOWAYOUT;
1da177e4 LT	28
	29	MODULE_LICENSE("GPL");
	30	MODULE_AUTHOR("Arnd Bergmann <arndb@de.ibm.com>");
	31	MODULE_DESCRIPTION("z/VM Watchdog Timer");
	32	module_param_string(cmd, vmwdt_cmd, MAX_CMDLEN, 0644);
	33	MODULE_PARM_DESC(cmd, "CP command that is run when the watchdog triggers");
	34	module_param_named(conceal, vmwdt_conceal, bool, 0644);
	35	MODULE_PARM_DESC(conceal, "Enable the CONCEAL CP option while the watchdog "
	36	" is active");
	37	module_param_named(nowayout, vmwdt_nowayout, bool, 0);
	38	MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started"
	39	" (default=CONFIG_WATCHDOG_NOWAYOUT)");
	40	MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
	41
	42	static unsigned int vmwdt_interval = 60;
	43	static unsigned long vmwdt_is_open;
	44	static int vmwdt_expect_close;
	45
	46	enum vmwdt_func {
	47	/* function codes */
	48	wdt_init = 0,
	49	wdt_change = 1,
	50	wdt_cancel = 2,
	51	/* flags */
	52	wdt_conceal = 0x80000000,
	53	};
	54
	55	static int __diag288(enum vmwdt_func func, unsigned int timeout,
	56	char *cmd, size_t len)
	57	{
94c12cc7 MS	58	register unsigned long __func asm("2") = func;
	59	register unsigned long __timeout asm("3") = timeout;
	60	register unsigned long __cmdp asm("4") = virt_to_phys(cmd);
	61	register unsigned long __cmdl asm("5") = len;
1da177e4 LT	62	int err;
1da177e4 LT	63
94c12cc7 MS	64	err = -EINVAL;
	65	asm volatile(
	66	" diag %1,%3,0x288\n"
	67	"0: la %0,0\n"
	68	"1:\n"
	69	EX_TABLE(0b,1b)
2b12f996 HC	70	: "+d" (err) : "d"(__func), "d"(__timeout),
2b12f996 HC	71	"d"(__cmdp), "d"(__cmdl) : "1", "cc");
1da177e4 LT	72	return err;
	73	}
	74
	75	static int vmwdt_keepalive(void)
	76	{
	77	/* we allocate new memory every time to avoid having
	78	* to track the state. static allocation is not an
	79	* option since that might not be contiguous in real
	80	* storage in case of a modular build */
	81	static char *ebc_cmd;
	82	size_t len;
	83	int ret;
	84	unsigned int func;
	85
	86	ebc_cmd = kmalloc(MAX_CMDLEN, GFP_KERNEL);
	87	if (!ebc_cmd)
	88	return -ENOMEM;
	89
	90	len = strlcpy(ebc_cmd, vmwdt_cmd, MAX_CMDLEN);
	91	ASCEBC(ebc_cmd, MAX_CMDLEN);
	92	EBC_TOUPPER(ebc_cmd, MAX_CMDLEN);
	93
	94	func = vmwdt_conceal ? (wdt_init \| wdt_conceal) : wdt_init;
	95	ret = __diag288(func, vmwdt_interval, ebc_cmd, len);
0d130066	96	WARN_ON(ret != 0);
1da177e4	97	kfree(ebc_cmd);
1da177e4 LT	98	return ret;
	99	}
	100
	101	static int vmwdt_disable(void)
	102	{
	103	int ret = __diag288(wdt_cancel, 0, "", 0);
0d130066	104	WARN_ON(ret != 0);
1da177e4 LT	105	return ret;
	106	}
	107
	108	static int __init vmwdt_probe(void)
	109	{
	110	/* there is no real way to see if the watchdog is supported,
	111	* so we try initializing it with a NOP command ("BEGIN")
	112	* that won't cause any harm even if the following disable
	113	* fails for some reason */
	114	static char __initdata ebc_begin[] = {
	115	194, 197, 199, 201, 213
	116	};
0d130066	117	if (__diag288(wdt_init, 15, ebc_begin, sizeof(ebc_begin)) != 0)
1da177e4	118	return -EINVAL;
1da177e4 LT	119	return vmwdt_disable();
	120	}
	121
	122	static int vmwdt_open(struct inode i, struct file f)
	123	{
	124	int ret;
3e0420f0 AB	125	lock_kernel();
	126	if (test_and_set_bit(0, &vmwdt_is_open)) {
	127	unlock_kernel();
1da177e4	128	return -EBUSY;
3e0420f0	129	}
1da177e4 LT	130	ret = vmwdt_keepalive();
	131	if (ret)
	132	clear_bit(0, &vmwdt_is_open);
3e0420f0	133	unlock_kernel();
1da177e4 LT	134	return ret ? ret : nonseekable_open(i, f);
	135	}
	136
	137	static int vmwdt_close(struct inode i, struct file f)
	138	{
	139	if (vmwdt_expect_close == 42)
	140	vmwdt_disable();
	141	vmwdt_expect_close = 0;
	142	clear_bit(0, &vmwdt_is_open);
	143	return 0;
	144	}
	145
	146	static struct watchdog_info vmwdt_info = {
	147	.options = WDIOF_SETTIMEOUT \| WDIOF_KEEPALIVEPING \| WDIOF_MAGICCLOSE,
	148	.firmware_version = 0,
	149	.identity = "z/VM Watchdog Timer",
	150	};
	151
	152	static int vmwdt_ioctl(struct inode i, struct file f,
	153	unsigned int cmd, unsigned long arg)
	154	{
	155	switch (cmd) {
	156	case WDIOC_GETSUPPORT:
	157	if (copy_to_user((void __user *)arg, &vmwdt_info,
	158	sizeof(vmwdt_info)))
	159	return -EFAULT;
	160	return 0;
	161	case WDIOC_GETSTATUS:
	162	case WDIOC_GETBOOTSTATUS:
d2c993d8	163	return put_user(0, (int __user *)arg);
1da177e4 LT	164	case WDIOC_GETTEMP:
	165	return -EINVAL;
	166	case WDIOC_SETOPTIONS:
	167	{
	168	int options, ret;
	169	if (get_user(options, (int __user *)arg))
	170	return -EFAULT;
	171	ret = -EINVAL;
	172	if (options & WDIOS_DISABLECARD) {
	173	ret = vmwdt_disable();
	174	if (ret)
	175	return ret;
	176	}
	177	if (options & WDIOS_ENABLECARD) {
	178	ret = vmwdt_keepalive();
	179	}
	180	return ret;
	181	}
	182	case WDIOC_GETTIMEOUT:
	183	return put_user(vmwdt_interval, (int __user *)arg);
	184	case WDIOC_SETTIMEOUT:
	185	{
	186	int interval;
	187	if (get_user(interval, (int __user *)arg))
	188	return -EFAULT;
	189	if (interval < MIN_INTERVAL)
	190	return -EINVAL;
	191	vmwdt_interval = interval;
	192	}
	193	return vmwdt_keepalive();
	194	case WDIOC_KEEPALIVE:
	195	return vmwdt_keepalive();
	196	}
	197
	198	return -EINVAL;
	199	}
	200
	201	static ssize_t vmwdt_write(struct file f, const char __user buf,
	202	size_t count, loff_t *ppos)
	203	{
	204	if(count) {
	205	if (!vmwdt_nowayout) {
	206	size_t i;
	207
	208	/* note: just in case someone wrote the magic character
	209	* five months ago... */
	210	vmwdt_expect_close = 0;
	211
	212	for (i = 0; i != count; i++) {
	213	char c;
	214	if (get_user(c, buf+i))
	215	return -EFAULT;
	216	if (c == 'V')
	217	vmwdt_expect_close = 42;
	218	}
	219	}
	220	/* someone wrote to us, we should restart timer */
	221	vmwdt_keepalive();
	222	}
	223	return count;
	224	}
	225
d54b1fdb	226	static const struct file_operations vmwdt_fops = {
1da177e4 LT	227	.open = &vmwdt_open,
	228	.release = &vmwdt_close,
	229	.ioctl = &vmwdt_ioctl,
	230	.write = &vmwdt_write,
	231	.owner = THIS_MODULE,
	232	};
	233
	234	static struct miscdevice vmwdt_dev = {
	235	.minor = WATCHDOG_MINOR,
	236	.name = "watchdog",
	237	.fops = &vmwdt_fops,
	238	};
	239
	240	static int __init vmwdt_init(void)
	241	{
	242	int ret;
	243
	244	ret = vmwdt_probe();
	245	if (ret)
	246	return ret;
	247	return misc_register(&vmwdt_dev);
	248	}
	249	module_init(vmwdt_init);
	250
	251	static void __exit vmwdt_exit(void)
	252	{
	253	WARN_ON(misc_deregister(&vmwdt_dev) != 0);
	254	}
	255	module_exit(vmwdt_exit);