smsgiucv_app.c (5539B)
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 KMSG_COMPONENT "smsgiucv_app" 14#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 15 16#include <linux/ctype.h> 17#include <linux/err.h> 18#include <linux/device.h> 19#include <linux/list.h> 20#include <linux/kobject.h> 21#include <linux/module.h> 22#include <linux/slab.h> 23#include <linux/spinlock.h> 24#include <linux/workqueue.h> 25#include <net/iucv/iucv.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 snprintf(ev->envp[0], ENV_SENDER_LEN, ENV_SENDER_STR "%s", from); 91 snprintf(ev->envp[1], ENV_PREFIX_LEN, ENV_PREFIX_STR "%s", SMSG_PREFIX); 92 snprintf(ev->envp[2], ENV_TEXT_LEN(msg), ENV_TEXT_STR "%s", msg); 93 94 return ev; 95} 96 97static void smsg_event_work_fn(struct work_struct *work) 98{ 99 LIST_HEAD(event_queue); 100 struct smsg_app_event *p, *n; 101 struct device *dev; 102 103 dev = get_device(smsg_app_dev); 104 if (!dev) 105 return; 106 107 spin_lock_bh(&smsg_event_queue_lock); 108 list_splice_init(&smsg_event_queue, &event_queue); 109 spin_unlock_bh(&smsg_event_queue_lock); 110 111 list_for_each_entry_safe(p, n, &event_queue, list) { 112 list_del(&p->list); 113 kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, p->envp); 114 smsg_app_event_free(p); 115 } 116 117 put_device(dev); 118} 119static DECLARE_WORK(smsg_event_work, smsg_event_work_fn); 120 121static void smsg_app_callback(const char *from, char *msg) 122{ 123 struct smsg_app_event *se; 124 125 /* check if the originating z/VM user ID matches 126 * the configured sender. */ 127 if (sender && strlen(sender) > 0 && strcmp(from, sender) != 0) 128 return; 129 130 /* get start of message text (skip prefix and leading blanks) */ 131 msg += strlen(SMSG_PREFIX); 132 while (*msg && isspace(*msg)) 133 msg++; 134 if (*msg == '\0') 135 return; 136 137 /* allocate event list element and its environment */ 138 se = smsg_app_event_alloc(from, msg); 139 if (!se) 140 return; 141 142 /* queue event and schedule work function */ 143 spin_lock(&smsg_event_queue_lock); 144 list_add_tail(&se->list, &smsg_event_queue); 145 spin_unlock(&smsg_event_queue_lock); 146 147 schedule_work(&smsg_event_work); 148 return; 149} 150 151static int __init smsgiucv_app_init(void) 152{ 153 struct device_driver *smsgiucv_drv; 154 int rc; 155 156 if (!MACHINE_IS_VM) 157 return -ENODEV; 158 159 smsg_app_dev = kzalloc(sizeof(*smsg_app_dev), GFP_KERNEL); 160 if (!smsg_app_dev) 161 return -ENOMEM; 162 163 smsgiucv_drv = driver_find(SMSGIUCV_DRV_NAME, &iucv_bus); 164 if (!smsgiucv_drv) { 165 kfree(smsg_app_dev); 166 return -ENODEV; 167 } 168 169 rc = dev_set_name(smsg_app_dev, KMSG_COMPONENT); 170 if (rc) { 171 kfree(smsg_app_dev); 172 goto fail; 173 } 174 smsg_app_dev->bus = &iucv_bus; 175 smsg_app_dev->parent = iucv_root; 176 smsg_app_dev->release = (void (*)(struct device *)) kfree; 177 smsg_app_dev->driver = smsgiucv_drv; 178 rc = device_register(smsg_app_dev); 179 if (rc) { 180 put_device(smsg_app_dev); 181 goto fail; 182 } 183 184 /* convert sender to uppercase characters */ 185 if (sender) { 186 int len = strlen(sender); 187 while (len--) 188 sender[len] = toupper(sender[len]); 189 } 190 191 /* register with the smsgiucv device driver */ 192 rc = smsg_register_callback(SMSG_PREFIX, smsg_app_callback); 193 if (rc) { 194 device_unregister(smsg_app_dev); 195 goto fail; 196 } 197 198 rc = 0; 199fail: 200 return rc; 201} 202module_init(smsgiucv_app_init); 203 204static 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} 215module_exit(smsgiucv_app_exit); 216 217MODULE_LICENSE("GPL v2"); 218MODULE_DESCRIPTION("Deliver z/VM CP SMSG as uevents"); 219MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>");