[linux.git] / drivers / s390 / char / sclp_async.c

/*
 * Enable Asynchronous Notification via SCLP.
 *
 * Copyright IBM Corp. 2009
 * Author(s): Hans-Joachim Picht <[email protected]>
 *
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/stat.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/ctype.h>
#include <linux/kmod.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/proc_fs.h>
#include <linux/sysctl.h>
#include <linux/utsname.h>
#include "sclp.h"

static int callhome_enabled;
static struct sclp_req *request;
static struct sclp_async_sccb *sccb;
static int sclp_async_send_wait(char *message);
static struct ctl_table_header *callhome_sysctl_header;
static DEFINE_SPINLOCK(sclp_async_lock);
#define SCLP_NORMAL_WRITE	0x00

struct async_evbuf {
	struct evbuf_header header;
	u64 reserved;
	u8 rflags;
	u8 empty;
	u8 rtype;
	u8 otype;
	char comp_id[12];
	char data[3000]; /* there is still some space left */
} __attribute__((packed));

struct sclp_async_sccb {
	struct sccb_header header;
	struct async_evbuf evbuf;
} __attribute__((packed));

static struct sclp_register sclp_async_register = {
	.send_mask = EVTYP_ASYNC_MASK,
};

static int call_home_on_panic(struct notifier_block *self,
			      unsigned long event, void *data)
{
	strncat(data, init_utsname()->nodename,
		sizeof(init_utsname()->nodename));
	sclp_async_send_wait(data);
	return NOTIFY_DONE;
}

static struct notifier_block call_home_panic_nb = {
	.notifier_call = call_home_on_panic,
	.priority = INT_MAX,
};

static int proc_handler_callhome(struct ctl_table *ctl, int write,
				 void __user *buffer, size_t *count,
				 loff_t *ppos)
{
	unsigned long val;
	int len, rc;
	char buf[3];

	if (!*count || (*ppos && !write)) {
		*count = 0;
		return 0;
	}
	if (!write) {
		len = snprintf(buf, sizeof(buf), "%d\n", callhome_enabled);
		rc = copy_to_user(buffer, buf, sizeof(buf));
		if (rc != 0)
			return -EFAULT;
	} else {
		len = *count;
		rc = copy_from_user(buf, buffer, sizeof(buf));
		if (rc != 0)
			return -EFAULT;
		buf[sizeof(buf) - 1] = '\0';
		if (strict_strtoul(buf, 0, &val) != 0)
			return -EINVAL;
		if (val != 0 && val != 1)
			return -EINVAL;
		callhome_enabled = val;
	}
	*count = len;
	*ppos += len;
	return 0;
}

static struct ctl_table callhome_table[] = {
	{
		.procname	= "callhome",
		.mode		= 0644,
		.proc_handler	= proc_handler_callhome,
	},
	{}
};

static struct ctl_table kern_dir_table[] = {
	{
		.procname	= "kernel",
		.maxlen		= 0,
		.mode		= 0555,
		.child		= callhome_table,
	},
	{}
};

/*
 * Function used to transfer asynchronous notification
 * records which waits for send completion
 */
static int sclp_async_send_wait(char *message)
{
	struct async_evbuf *evb;
	int rc;
	unsigned long flags;

	if (!callhome_enabled)
		return 0;
	sccb->evbuf.header.type = EVTYP_ASYNC;
	sccb->evbuf.rtype = 0xA5;
	sccb->evbuf.otype = 0x00;
	evb = &sccb->evbuf;
	request->command = SCLP_CMDW_WRITE_EVENT_DATA;
	request->sccb = sccb;
	request->status = SCLP_REQ_FILLED;
	strncpy(sccb->evbuf.data, message, sizeof(sccb->evbuf.data));
	/*
	 * Retain Queue
	 * e.g. 5639CC140 500 Red Hat RHEL5 Linux for zSeries (RHEL AS)
	 */
	strncpy(sccb->evbuf.comp_id, "000000000", sizeof(sccb->evbuf.comp_id));
	sccb->evbuf.header.length = sizeof(sccb->evbuf);
	sccb->header.length = sizeof(sccb->evbuf) + sizeof(sccb->header);
	sccb->header.function_code = SCLP_NORMAL_WRITE;
	rc = sclp_add_request(request);
	if (rc)
		return rc;
	spin_lock_irqsave(&sclp_async_lock, flags);
	while (request->status != SCLP_REQ_DONE &&
		request->status != SCLP_REQ_FAILED) {
		 sclp_sync_wait();
	}
	spin_unlock_irqrestore(&sclp_async_lock, flags);
	if (request->status != SCLP_REQ_DONE)
		return -EIO;
	rc = ((struct sclp_async_sccb *)
	       request->sccb)->header.response_code;
	if (rc != 0x0020)
		return -EIO;
	if (evb->header.flags != 0x80)
		return -EIO;
	return rc;
}

static int __init sclp_async_init(void)
{
	int rc;

	rc = sclp_register(&sclp_async_register);
	if (rc)
		return rc;
	rc = -EOPNOTSUPP;
	if (!(sclp_async_register.sclp_receive_mask & EVTYP_ASYNC_MASK))
		goto out_sclp;
	rc = -ENOMEM;
	callhome_sysctl_header = register_sysctl_table(kern_dir_table);
	if (!callhome_sysctl_header)
		goto out_sclp;
	request = kzalloc(sizeof(struct sclp_req), GFP_KERNEL);
	sccb = (struct sclp_async_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
	if (!request || !sccb)
		goto out_mem;
	rc = atomic_notifier_chain_register(&panic_notifier_list,
					    &call_home_panic_nb);
	if (!rc)
		goto out;
out_mem:
	kfree(request);
	free_page((unsigned long) sccb);
	unregister_sysctl_table(callhome_sysctl_header);
out_sclp:
	sclp_unregister(&sclp_async_register);
out:
	return rc;
}
module_init(sclp_async_init);

static void __exit sclp_async_exit(void)
{
	atomic_notifier_chain_unregister(&panic_notifier_list,
					 &call_home_panic_nb);
	unregister_sysctl_table(callhome_sysctl_header);
	sclp_unregister(&sclp_async_register);
	free_page((unsigned long) sccb);
	kfree(request);
}
module_exit(sclp_async_exit);

MODULE_AUTHOR("Copyright IBM Corp. 2009");
MODULE_AUTHOR("Hans-Joachim Picht <[email protected]>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("SCLP Asynchronous Notification Records");
Commit	Line	Data
c114728a HJP	1	/*
	2	* Enable Asynchronous Notification via SCLP.
	3	*
	4	* Copyright IBM Corp. 2009
	5	* Author(s): Hans-Joachim Picht <[email protected]>
	6	*
	7	*/
	8
	9	#include <linux/init.h>
	10	#include <linux/module.h>
	11	#include <linux/device.h>
	12	#include <linux/stat.h>
	13	#include <linux/string.h>
5a0e3ad6	14	#include <linux/slab.h>
c114728a HJP	15	#include <linux/ctype.h>
	16	#include <linux/kmod.h>
	17	#include <linux/err.h>
	18	#include <linux/errno.h>
	19	#include <linux/proc_fs.h>
	20	#include <linux/sysctl.h>
	21	#include <linux/utsname.h>
	22	#include "sclp.h"
	23
	24	static int callhome_enabled;
	25	static struct sclp_req *request;
	26	static struct sclp_async_sccb *sccb;
	27	static int sclp_async_send_wait(char *message);
	28	static struct ctl_table_header *callhome_sysctl_header;
	29	static DEFINE_SPINLOCK(sclp_async_lock);
c114728a HJP	30	#define SCLP_NORMAL_WRITE 0x00
	31
	32	struct async_evbuf {
	33	struct evbuf_header header;
	34	u64 reserved;
	35	u8 rflags;
	36	u8 empty;
	37	u8 rtype;
	38	u8 otype;
	39	char comp_id[12];
	40	char data[3000]; /* there is still some space left */
	41	} __attribute__((packed));
	42
	43	struct sclp_async_sccb {
	44	struct sccb_header header;
	45	struct async_evbuf evbuf;
	46	} __attribute__((packed));
	47
	48	static struct sclp_register sclp_async_register = {
	49	.send_mask = EVTYP_ASYNC_MASK,
	50	};
	51
	52	static int call_home_on_panic(struct notifier_block *self,
	53	unsigned long event, void *data)
	54	{
e8a79c9e HC	55	strncat(data, init_utsname()->nodename,
	56	sizeof(init_utsname()->nodename));
	57	sclp_async_send_wait(data);
	58	return NOTIFY_DONE;
c114728a HJP	59	}
	60
	61	static struct notifier_block call_home_panic_nb = {
	62	.notifier_call = call_home_on_panic,
	63	.priority = INT_MAX,
	64	};
	65
d3acf71f	66	static int proc_handler_callhome(struct ctl_table *ctl, int write,
c114728a HJP	67	void __user buffer, size_t count,
	68	loff_t *ppos)
	69	{
	70	unsigned long val;
	71	int len, rc;
3f0b3c33	72	char buf[3];
c114728a	73
3f0b3c33	74	if (!count \|\| (ppos && !write)) {
c114728a HJP	75	*count = 0;
	76	return 0;
	77	}
	78	if (!write) {
3f0b3c33	79	len = snprintf(buf, sizeof(buf), "%d\n", callhome_enabled);
c114728a HJP	80	rc = copy_to_user(buffer, buf, sizeof(buf));
	81	if (rc != 0)
	82	return -EFAULT;
	83	} else {
	84	len = *count;
	85	rc = copy_from_user(buf, buffer, sizeof(buf));
	86	if (rc != 0)
	87	return -EFAULT;
35ac734f	88	buf[sizeof(buf) - 1] = '\0';
c114728a HJP	89	if (strict_strtoul(buf, 0, &val) != 0)
	90	return -EINVAL;
	91	if (val != 0 && val != 1)
	92	return -EINVAL;
	93	callhome_enabled = val;
	94	}
	95	*count = len;
	96	*ppos += len;
	97	return 0;
	98	}
	99
	100	static struct ctl_table callhome_table[] = {
	101	{
	102	.procname = "callhome",
	103	.mode = 0644,
d3acf71f	104	.proc_handler = proc_handler_callhome,
c114728a	105	},
b05fd35d	106	{}
c114728a HJP	107	};
	108
	109	static struct ctl_table kern_dir_table[] = {
	110	{
c114728a HJP	111	.procname = "kernel",
	112	.maxlen = 0,
	113	.mode = 0555,
	114	.child = callhome_table,
	115	},
b05fd35d	116	{}
c114728a HJP	117	};
	118
	119	/*
	120	* Function used to transfer asynchronous notification
	121	* records which waits for send completion
	122	*/
	123	static int sclp_async_send_wait(char *message)
	124	{
	125	struct async_evbuf *evb;
	126	int rc;
	127	unsigned long flags;
	128
	129	if (!callhome_enabled)
	130	return 0;
	131	sccb->evbuf.header.type = EVTYP_ASYNC;
	132	sccb->evbuf.rtype = 0xA5;
	133	sccb->evbuf.otype = 0x00;
	134	evb = &sccb->evbuf;
	135	request->command = SCLP_CMDW_WRITE_EVENT_DATA;
	136	request->sccb = sccb;
	137	request->status = SCLP_REQ_FILLED;
	138	strncpy(sccb->evbuf.data, message, sizeof(sccb->evbuf.data));
	139	/*
	140	* Retain Queue
	141	* e.g. 5639CC140 500 Red Hat RHEL5 Linux for zSeries (RHEL AS)
	142	*/
	143	strncpy(sccb->evbuf.comp_id, "000000000", sizeof(sccb->evbuf.comp_id));
	144	sccb->evbuf.header.length = sizeof(sccb->evbuf);
	145	sccb->header.length = sizeof(sccb->evbuf) + sizeof(sccb->header);
	146	sccb->header.function_code = SCLP_NORMAL_WRITE;
	147	rc = sclp_add_request(request);
	148	if (rc)
	149	return rc;
	150	spin_lock_irqsave(&sclp_async_lock, flags);
	151	while (request->status != SCLP_REQ_DONE &&
	152	request->status != SCLP_REQ_FAILED) {
	153	sclp_sync_wait();
	154	}
	155	spin_unlock_irqrestore(&sclp_async_lock, flags);
	156	if (request->status != SCLP_REQ_DONE)
	157	return -EIO;
	158	rc = ((struct sclp_async_sccb *)
	159	request->sccb)->header.response_code;
	160	if (rc != 0x0020)
	161	return -EIO;
	162	if (evb->header.flags != 0x80)
	163	return -EIO;
	164	return rc;
	165	}
	166
	167	static int __init sclp_async_init(void)
	168	{
	169	int rc;
	170
	171	rc = sclp_register(&sclp_async_register);
	172	if (rc)
	173	return rc;
4a0fb4c4 HC	174	rc = -EOPNOTSUPP;
4a0fb4c4 HC	175	if (!(sclp_async_register.sclp_receive_mask & EVTYP_ASYNC_MASK))
c114728a	176	goto out_sclp;
c114728a	177	rc = -ENOMEM;
4a0fb4c4 HC	178	callhome_sysctl_header = register_sysctl_table(kern_dir_table);
	179	if (!callhome_sysctl_header)
	180	goto out_sclp;
c114728a	181	request = kzalloc(sizeof(struct sclp_req), GFP_KERNEL);
c114728a	182	sccb = (struct sclp_async_sccb *) get_zeroed_page(GFP_KERNEL \| GFP_DMA);
4a0fb4c4	183	if (!request \|\| !sccb)
c114728a	184	goto out_mem;
4a0fb4c4 HC	185	rc = atomic_notifier_chain_register(&panic_notifier_list,
4a0fb4c4 HC	186	&call_home_panic_nb);
e8a79c9e HC	187	if (!rc)
e8a79c9e HC	188	goto out;
c114728a HJP	189	out_mem:
	190	kfree(request);
	191	free_page((unsigned long) sccb);
c114728a HJP	192	unregister_sysctl_table(callhome_sysctl_header);
	193	out_sclp:
	194	sclp_unregister(&sclp_async_register);
4a0fb4c4	195	out:
c114728a	196	return rc;
c114728a HJP	197	}
	198	module_init(sclp_async_init);
	199
	200	static void __exit sclp_async_exit(void)
	201	{
	202	atomic_notifier_chain_unregister(&panic_notifier_list,
	203	&call_home_panic_nb);
	204	unregister_sysctl_table(callhome_sysctl_header);
	205	sclp_unregister(&sclp_async_register);
	206	free_page((unsigned long) sccb);
	207	kfree(request);
	208	}
	209	module_exit(sclp_async_exit);
	210
	211	MODULE_AUTHOR("Copyright IBM Corp. 2009");
	212	MODULE_AUTHOR("Hans-Joachim Picht <[email protected]>");
	213	MODULE_LICENSE("GPL");
	214	MODULE_DESCRIPTION("SCLP Asynchronous Notification Records");