blob: 32515a201bbc65c4a0c6e9d48282a188ff16cdda [file] [log] [blame]
Hendrik Brueckner1ffaa642010-03-08 12:26:26 +01001/*
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090021#include <linux/slab.h>
Hendrik Brueckner1ffaa642010-03-08 12:26:26 +010022#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. */
42static char *sender;
43module_param(sender, charp, 0400);
44MODULE_PARM_DESC(sender, "z/VM user ID from which CP SMSGs are accepted");
45
46/* SMSG device representation */
47static struct device *smsg_app_dev;
48
49/* list element for queuing received messages for delivery */
50struct smsg_app_event {
51 struct list_head list;
52 char *buf;
53 char *envp[4];
54};
55
56/* queue for outgoing uevents */
57static LIST_HEAD(smsg_event_queue);
58static DEFINE_SPINLOCK(smsg_event_queue_lock);
59
60static void smsg_app_event_free(struct smsg_app_event *ev)
61{
62 kfree(ev->buf);
63 kfree(ev);
64}
65
66static 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
96static 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}
118static DECLARE_WORK(smsg_event_work, smsg_event_work_fn);
119
120static 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
150static 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);
Alan Sternfde25a92012-01-24 13:34:24 -0500171 goto fail;
Hendrik Brueckner1ffaa642010-03-08 12:26:26 +0100172 }
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);
Alan Sternfde25a92012-01-24 13:34:24 -0500180 goto fail;
Hendrik Brueckner1ffaa642010-03-08 12:26:26 +0100181 }
182
Hendrik Brueckner41b42872010-08-09 18:12:56 +0200183 /* convert sender to uppercase characters */
184 if (sender) {
185 int len = strlen(sender);
186 while (len--)
187 sender[len] = toupper(sender[len]);
188 }
189
Hendrik Brueckner1ffaa642010-03-08 12:26:26 +0100190 /* 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);
Alan Sternfde25a92012-01-24 13:34:24 -0500194 goto fail;
Hendrik Brueckner1ffaa642010-03-08 12:26:26 +0100195 }
196
197 rc = 0;
Alan Sternfde25a92012-01-24 13:34:24 -0500198fail:
Hendrik Brueckner1ffaa642010-03-08 12:26:26 +0100199 return rc;
200}
201module_init(smsgiucv_app_init);
202
203static void __exit smsgiucv_app_exit(void)
204{
205 /* unregister callback */
206 smsg_unregister_callback(SMSG_PREFIX, smsg_app_callback);
207
208 /* cancel pending work and flush any queued event work */
209 cancel_work_sync(&smsg_event_work);
210 smsg_event_work_fn(&smsg_event_work);
211
212 device_unregister(smsg_app_dev);
213}
214module_exit(smsgiucv_app_exit);
215
216MODULE_LICENSE("GPL v2");
217MODULE_DESCRIPTION("Deliver z/VM CP SMSG as uevents");
218MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>");