[net-next-2.6.git] / drivers / s390 / net / smsgiucv_app.c

/*
 * Deliver z/VM CP special messages (SMSG) as uevents.
 *
 * The driver registers for z/VM CP special messages with the
 * "APP" prefix. Incoming messages are delivered to user space
 * as uevents.
 *
 * Copyright IBM Corp. 2010
 * Author(s): Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
 *
 */
#define KMSG_COMPONENT		"smsgiucv_app"
#define pr_fmt(fmt)		KMSG_COMPONENT ": " fmt

#include <linux/ctype.h>
#include <linux/err.h>
#include <linux/device.h>
#include <linux/list.h>
#include <linux/kobject.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <net/iucv/iucv.h>
#include "smsgiucv.h"

/* prefix used for SMSG registration */
#define SMSG_PREFIX		"APP"

/* SMSG related uevent environment variables */
#define ENV_SENDER_STR		"SMSG_SENDER="
#define ENV_SENDER_LEN		(strlen(ENV_SENDER_STR) + 8 + 1)
#define ENV_PREFIX_STR		"SMSG_ID="
#define ENV_PREFIX_LEN		(strlen(ENV_PREFIX_STR) + \
				 strlen(SMSG_PREFIX) + 1)
#define ENV_TEXT_STR		"SMSG_TEXT="
#define ENV_TEXT_LEN(msg)	(strlen(ENV_TEXT_STR) + strlen((msg)) + 1)

/* z/VM user ID which is permitted to send SMSGs
 * If the value is undefined or empty (""), special messages are
 * accepted from any z/VM user ID. */
static char *sender;
module_param(sender, charp, 0400);
MODULE_PARM_DESC(sender, "z/VM user ID from which CP SMSGs are accepted");

/* SMSG device representation */
static struct device *smsg_app_dev;

/* list element for queuing received messages for delivery */
struct smsg_app_event {
	struct list_head list;
	char *buf;
	char *envp[4];
};

/* queue for outgoing uevents */
static LIST_HEAD(smsg_event_queue);
static DEFINE_SPINLOCK(smsg_event_queue_lock);

static void smsg_app_event_free(struct smsg_app_event *ev)
{
	kfree(ev->buf);
	kfree(ev);
}

static struct smsg_app_event *smsg_app_event_alloc(const char *from,
						   const char *msg)
{
	struct smsg_app_event *ev;

	ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
	if (!ev)
		return NULL;

	ev->buf = kzalloc(ENV_SENDER_LEN + ENV_PREFIX_LEN +
			  ENV_TEXT_LEN(msg), GFP_ATOMIC);
	if (!ev->buf) {
		kfree(ev);
		return NULL;
	}

	/* setting up environment pointers into buf */
	ev->envp[0] = ev->buf;
	ev->envp[1] = ev->envp[0] + ENV_SENDER_LEN;
	ev->envp[2] = ev->envp[1] + ENV_PREFIX_LEN;
	ev->envp[3] = NULL;

	/* setting up environment: sender, prefix name, and message text */
	snprintf(ev->envp[0], ENV_SENDER_LEN, ENV_SENDER_STR "%s", from);
	snprintf(ev->envp[1], ENV_PREFIX_LEN, ENV_PREFIX_STR "%s", SMSG_PREFIX);
	snprintf(ev->envp[2], ENV_TEXT_LEN(msg), ENV_TEXT_STR "%s", msg);

	return ev;
}

static void smsg_event_work_fn(struct work_struct *work)
{
	LIST_HEAD(event_queue);
	struct smsg_app_event *p, *n;
	struct device *dev;

	dev = get_device(smsg_app_dev);
	if (!dev)
		return;

	spin_lock_bh(&smsg_event_queue_lock);
	list_splice_init(&smsg_event_queue, &event_queue);
	spin_unlock_bh(&smsg_event_queue_lock);

	list_for_each_entry_safe(p, n, &event_queue, list) {
		list_del(&p->list);
		kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, p->envp);
		smsg_app_event_free(p);
	}

	put_device(dev);
}
static DECLARE_WORK(smsg_event_work, smsg_event_work_fn);

static void smsg_app_callback(const char *from, char *msg)
{
	struct smsg_app_event *se;

	/* check if the originating z/VM user ID matches
	 * the configured sender. */
	if (sender && strlen(sender) > 0 && strcmp(from, sender) != 0)
		return;

	/* get start of message text (skip prefix and leading blanks) */
	msg += strlen(SMSG_PREFIX);
	while (*msg && isspace(*msg))
		msg++;
	if (*msg == '\0')
		return;

	/* allocate event list element and its environment */
	se = smsg_app_event_alloc(from, msg);
	if (!se)
		return;

	/* queue event and schedule work function */
	spin_lock(&smsg_event_queue_lock);
	list_add_tail(&se->list, &smsg_event_queue);
	spin_unlock(&smsg_event_queue_lock);

	schedule_work(&smsg_event_work);
	return;
}

static int __init smsgiucv_app_init(void)
{
	struct device_driver *smsgiucv_drv;
	int rc;

	if (!MACHINE_IS_VM)
		return -ENODEV;

	smsg_app_dev = kzalloc(sizeof(*smsg_app_dev), GFP_KERNEL);
	if (!smsg_app_dev)
		return -ENOMEM;

	smsgiucv_drv = driver_find(SMSGIUCV_DRV_NAME, &iucv_bus);
	if (!smsgiucv_drv) {
		kfree(smsg_app_dev);
		return -ENODEV;
	}

	rc = dev_set_name(smsg_app_dev, KMSG_COMPONENT);
	if (rc) {
		kfree(smsg_app_dev);
		goto fail_put_driver;
	}
	smsg_app_dev->bus = &iucv_bus;
	smsg_app_dev->parent = iucv_root;
	smsg_app_dev->release = (void (*)(struct device *)) kfree;
	smsg_app_dev->driver = smsgiucv_drv;
	rc = device_register(smsg_app_dev);
	if (rc) {
		put_device(smsg_app_dev);
		goto fail_put_driver;
	}

	/* register with the smsgiucv device driver */
	rc = smsg_register_callback(SMSG_PREFIX, smsg_app_callback);
	if (rc) {
		device_unregister(smsg_app_dev);
		goto fail_put_driver;
	}

	rc = 0;
fail_put_driver:
	put_driver(smsgiucv_drv);
	return rc;
}
module_init(smsgiucv_app_init);

static void __exit smsgiucv_app_exit(void)
{
	/* unregister callback */
	smsg_unregister_callback(SMSG_PREFIX, smsg_app_callback);

	/* cancel pending work and flush any queued event work */
	cancel_work_sync(&smsg_event_work);
	smsg_event_work_fn(&smsg_event_work);

	device_unregister(smsg_app_dev);
}
module_exit(smsgiucv_app_exit);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("Deliver z/VM CP SMSG as uevents");
MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>");
Commit	Line	Data
1ffaa640 HB	1	/*
	2	* Deliver z/VM CP special messages (SMSG) as uevents.
	3	*
	4	* The driver registers for z/VM CP special messages with the
	5	* "APP" prefix. Incoming messages are delivered to user space
	6	* as uevents.
	7	*
	8	* Copyright IBM Corp. 2010
	9	* Author(s): Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
	10	*
	11	*/
	12	#define KMSG_COMPONENT "smsgiucv_app"
	13	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	14
	15	#include <linux/ctype.h>
	16	#include <linux/err.h>
	17	#include <linux/device.h>
	18	#include <linux/list.h>
	19	#include <linux/kobject.h>
	20	#include <linux/module.h>
5a0e3ad6	21	#include <linux/slab.h>
1ffaa640 HB	22	#include <linux/spinlock.h>
	23	#include <linux/workqueue.h>
	24	#include <net/iucv/iucv.h>
	25	#include "smsgiucv.h"
	26
	27	/* prefix used for SMSG registration */
	28	#define SMSG_PREFIX "APP"
	29
	30	/* SMSG related uevent environment variables */
	31	#define ENV_SENDER_STR "SMSG_SENDER="
	32	#define ENV_SENDER_LEN (strlen(ENV_SENDER_STR) + 8 + 1)
	33	#define ENV_PREFIX_STR "SMSG_ID="
	34	#define ENV_PREFIX_LEN (strlen(ENV_PREFIX_STR) + \
	35	strlen(SMSG_PREFIX) + 1)
	36	#define ENV_TEXT_STR "SMSG_TEXT="
	37	#define ENV_TEXT_LEN(msg) (strlen(ENV_TEXT_STR) + strlen((msg)) + 1)
	38
	39	/* z/VM user ID which is permitted to send SMSGs
	40	* If the value is undefined or empty (""), special messages are
	41	* accepted from any z/VM user ID. */
	42	static char *sender;
	43	module_param(sender, charp, 0400);
	44	MODULE_PARM_DESC(sender, "z/VM user ID from which CP SMSGs are accepted");
	45
	46	/* SMSG device representation */
	47	static struct device *smsg_app_dev;
	48
	49	/* list element for queuing received messages for delivery */
	50	struct smsg_app_event {
	51	struct list_head list;
	52	char *buf;
	53	char *envp[4];
	54	};
	55
	56	/* queue for outgoing uevents */
	57	static LIST_HEAD(smsg_event_queue);
	58	static DEFINE_SPINLOCK(smsg_event_queue_lock);
	59
	60	static void smsg_app_event_free(struct smsg_app_event *ev)
	61	{
	62	kfree(ev->buf);
	63	kfree(ev);
	64	}
	65
	66	static struct smsg_app_event smsg_app_event_alloc(const char from,
	67	const char *msg)
	68	{
	69	struct smsg_app_event *ev;
	70
	71	ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
	72	if (!ev)
	73	return NULL;
	74
	75	ev->buf = kzalloc(ENV_SENDER_LEN + ENV_PREFIX_LEN +
	76	ENV_TEXT_LEN(msg), GFP_ATOMIC);
	77	if (!ev->buf) {
	78	kfree(ev);
	79	return NULL;
	80	}
	81
	82	/* setting up environment pointers into buf */
	83	ev->envp[0] = ev->buf;
	84	ev->envp[1] = ev->envp[0] + ENV_SENDER_LEN;
	85	ev->envp[2] = ev->envp[1] + ENV_PREFIX_LEN;
86	ev->envp[3] = NULL;
87
88	/* setting up environment: sender, prefix name, and message text */
89	snprintf(ev->envp[0], ENV_SENDER_LEN, ENV_SENDER_STR "%s", from);
90	snprintf(ev->envp[1], ENV_PREFIX_LEN, ENV_PREFIX_STR "%s", SMSG_PREFIX);
91	snprintf(ev->envp[2], ENV_TEXT_LEN(msg), ENV_TEXT_STR "%s", msg);
92
93	return ev;
94	}
95
96	static void smsg_event_work_fn(struct work_struct *work)
97	{
98	LIST_HEAD(event_queue);
99	struct smsg_app_event p, n;
100	struct device *dev;
101
102	dev = get_device(smsg_app_dev);
103	if (!dev)
104	return;
105
106	spin_lock_bh(&smsg_event_queue_lock);
107	list_splice_init(&smsg_event_queue, &event_queue);
108	spin_unlock_bh(&smsg_event_queue_lock);
109
110	list_for_each_entry_safe(p, n, &event_queue, list) {
111	list_del(&p->list);
112	kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, p->envp);
113	smsg_app_event_free(p);
114	}
115
116	put_device(dev);
117	}
118	static DECLARE_WORK(smsg_event_work, smsg_event_work_fn);
119
120	static void smsg_app_callback(const char from, char msg)
121	{
122	struct smsg_app_event *se;
123
124	/* check if the originating z/VM user ID matches
125	* the configured sender. */
126	if (sender && strlen(sender) > 0 && strcmp(from, sender) != 0)
127	return;
128
129	/* get start of message text (skip prefix and leading blanks) */
130	msg += strlen(SMSG_PREFIX);
131	while (msg && isspace(msg))
132	msg++;
133	if (*msg == '\0')
134	return;
135
136	/* allocate event list element and its environment */
137	se = smsg_app_event_alloc(from, msg);
138	if (!se)
139	return;
140
141	/* queue event and schedule work function */
142	spin_lock(&smsg_event_queue_lock);
143	list_add_tail(&se->list, &smsg_event_queue);
144	spin_unlock(&smsg_event_queue_lock);
145
146	schedule_work(&smsg_event_work);
147	return;
148	}
149
150	static int __init smsgiucv_app_init(void)
151	{
152	struct device_driver *smsgiucv_drv;
153	int rc;
154
155	if (!MACHINE_IS_VM)
156	return -ENODEV;
157
158	smsg_app_dev = kzalloc(sizeof(*smsg_app_dev), GFP_KERNEL);
159	if (!smsg_app_dev)
160	return -ENOMEM;
161
162	smsgiucv_drv = driver_find(SMSGIUCV_DRV_NAME, &iucv_bus);
163	if (!smsgiucv_drv) {
164	kfree(smsg_app_dev);
165	return -ENODEV;
166	}
167
168	rc = dev_set_name(smsg_app_dev, KMSG_COMPONENT);
169	if (rc) {
170	kfree(smsg_app_dev);
171	goto fail_put_driver;
172	}
173	smsg_app_dev->bus = &iucv_bus;
174	smsg_app_dev->parent = iucv_root;
175	smsg_app_dev->release = (void ()(struct device )) kfree;
176	smsg_app_dev->driver = smsgiucv_drv;
177	rc = device_register(smsg_app_dev);
178	if (rc) {
179	put_device(smsg_app_dev);
180	goto fail_put_driver;
181	}
182
183	/* register with the smsgiucv device driver */
184	rc = smsg_register_callback(SMSG_PREFIX, smsg_app_callback);
185	if (rc) {
186	device_unregister(smsg_app_dev);
187	goto fail_put_driver;
188	}
189
190	rc = 0;
191	fail_put_driver:
192	put_driver(smsgiucv_drv);
193	return rc;
194	}
195	module_init(smsgiucv_app_init);
196
197	static void __exit smsgiucv_app_exit(void)
198	{
199	/* unregister callback */
200	smsg_unregister_callback(SMSG_PREFIX, smsg_app_callback);
201
202	/* cancel pending work and flush any queued event work */
203	cancel_work_sync(&smsg_event_work);
204	smsg_event_work_fn(&smsg_event_work);
205
206	device_unregister(smsg_app_dev);
207	}
208	module_exit(smsgiucv_app_exit);
209
210	MODULE_LICENSE("GPL v2");
211	MODULE_DESCRIPTION("Deliver z/VM CP SMSG as uevents");
212	MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>");