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>"); 220