LXR linux/drivers/s390/net/smsgiucv

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