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

source code of linux/drivers/s390/net/smsgiucv_app.c