Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6.git] / drivers / s390 / net / smsgiucv_app.c
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>
21 #include <linux/slab.h>
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         /* convert sender to uppercase characters */
184         if (sender) {
185                 int len = strlen(sender);
186                 while (len--)
187                         sender[len] = toupper(sender[len]);
188         }
189
190         /* register with the smsgiucv device driver */
191         rc = smsg_register_callback(SMSG_PREFIX, smsg_app_callback);
192         if (rc) {
193                 device_unregister(smsg_app_dev);
194                 goto fail_put_driver;
195         }
196
197         rc = 0;
198 fail_put_driver:
199         put_driver(smsgiucv_drv);
200         return rc;
201 }
202 module_init(smsgiucv_app_init);
203
204 static void __exit smsgiucv_app_exit(void)
205 {
206         /* unregister callback */
207         smsg_unregister_callback(SMSG_PREFIX, smsg_app_callback);
208
209         /* cancel pending work and flush any queued event work */
210         cancel_work_sync(&smsg_event_work);
211         smsg_event_work_fn(&smsg_event_work);
212
213         device_unregister(smsg_app_dev);
214 }
215 module_exit(smsgiucv_app_exit);
216
217 MODULE_LICENSE("GPL v2");
218 MODULE_DESCRIPTION("Deliver z/VM CP SMSG as uevents");
219 MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>");