smsgiucv_app.c

  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(ev->buf);
 64	kfree(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(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(ev->envp[0], ENV_SENDER_LEN, ENV_SENDER_STR "%s", from);
 91	scnprintf(ev->envp[1], ENV_PREFIX_LEN, ENV_PREFIX_STR "%s",
 92		  SMSG_PREFIX);
 93	scnprintf(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(smsg_app_dev);
105	if (!dev)
106		return;
107
108	spin_lock_bh(&smsg_event_queue_lock);
109	list_splice_init(&smsg_event_queue, &event_queue);
110	spin_unlock_bh(&smsg_event_queue_lock);
111
112	list_for_each_entry_safe(p, n, &event_queue, list) {
113		list_del(&p->list);
114		kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, p->envp);
115		smsg_app_event_free(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(&smsg_event_queue_lock);
145	list_add_tail(&se->list, &smsg_event_queue);
146	spin_unlock(&smsg_event_queue_lock);
147
148	schedule_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, &iucv_bus);
161	if (!smsgiucv_drv)
162		return -ENODEV;
163
164	smsg_app_dev = iucv_alloc_device(NULL, smsgiucv_drv, NULL, "smsgiucv_app");
165	if (!smsg_app_dev)
166		return -ENOMEM;
167
168	rc = device_register(smsg_app_dev);
169	if (rc) {
170		put_device(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(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(&smsg_event_work);
201	smsg_event_work_fn(&smsg_event_work);
202
203	device_unregister(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>");