| /* | |
| * Deliver z/VM CP special messages (SMSG) as uevents. | |
| * | |
| * The driver registers for z/VM CP special messages with the | |
| * "APP" prefix. Incoming messages are delivered to user space | |
| * as uevents. | |
| * | |
| * Copyright IBM Corp. 2010 | |
| * Author(s): Hendrik Brueckner <brueckner@linux.vnet.ibm.com> | |
| * | |
| */ | |
| #define KMSG_COMPONENT "smsgiucv_app" | |
| #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
| #include <linux/ctype.h> | |
| #include <linux/err.h> | |
| #include <linux/device.h> | |
| #include <linux/list.h> | |
| #include <linux/kobject.h> | |
| #include <linux/module.h> | |
| #include <linux/slab.h> | |
| #include <linux/spinlock.h> | |
| #include <linux/workqueue.h> | |
| #include <net/iucv/iucv.h> | |
| #include "smsgiucv.h" | |
| /* prefix used for SMSG registration */ | |
| #define SMSG_PREFIX "APP" | |
| /* SMSG related uevent environment variables */ | |
| #define ENV_SENDER_STR "SMSG_SENDER=" | |
| #define ENV_SENDER_LEN (strlen(ENV_SENDER_STR) + 8 + 1) | |
| #define ENV_PREFIX_STR "SMSG_ID=" | |
| #define ENV_PREFIX_LEN (strlen(ENV_PREFIX_STR) + \ | |
| strlen(SMSG_PREFIX) + 1) | |
| #define ENV_TEXT_STR "SMSG_TEXT=" | |
| #define ENV_TEXT_LEN(msg) (strlen(ENV_TEXT_STR) + strlen((msg)) + 1) | |
| /* z/VM user ID which is permitted to send SMSGs | |
| * If the value is undefined or empty (""), special messages are | |
| * accepted from any z/VM user ID. */ | |
| static char *sender; | |
| module_param(sender, charp, 0400); | |
| MODULE_PARM_DESC(sender, "z/VM user ID from which CP SMSGs are accepted"); | |
| /* SMSG device representation */ | |
| static struct device *smsg_app_dev; | |
| /* list element for queuing received messages for delivery */ | |
| struct smsg_app_event { | |
| struct list_head list; | |
| char *buf; | |
| char *envp[4]; | |
| }; | |
| /* queue for outgoing uevents */ | |
| static LIST_HEAD(smsg_event_queue); | |
| static DEFINE_SPINLOCK(smsg_event_queue_lock); | |
| static void smsg_app_event_free(struct smsg_app_event *ev) | |
| { | |
| kfree(ev->buf); | |
| kfree(ev); | |
| } | |
| static struct smsg_app_event *smsg_app_event_alloc(const char *from, | |
| const char *msg) | |
| { | |
| struct smsg_app_event *ev; | |
| ev = kzalloc(sizeof(*ev), GFP_ATOMIC); | |
| if (!ev) | |
| return NULL; | |
| ev->buf = kzalloc(ENV_SENDER_LEN + ENV_PREFIX_LEN + | |
| ENV_TEXT_LEN(msg), GFP_ATOMIC); | |
| if (!ev->buf) { | |
| kfree(ev); | |
| return NULL; | |
| } | |
| /* setting up environment pointers into buf */ | |
| ev->envp[0] = ev->buf; | |
| ev->envp[1] = ev->envp[0] + ENV_SENDER_LEN; | |
| ev->envp[2] = ev->envp[1] + ENV_PREFIX_LEN; | |
| ev->envp[3] = NULL; | |
| /* setting up environment: sender, prefix name, and message text */ | |
| snprintf(ev->envp[0], ENV_SENDER_LEN, ENV_SENDER_STR "%s", from); | |
| snprintf(ev->envp[1], ENV_PREFIX_LEN, ENV_PREFIX_STR "%s", SMSG_PREFIX); | |
| snprintf(ev->envp[2], ENV_TEXT_LEN(msg), ENV_TEXT_STR "%s", msg); | |
| return ev; | |
| } | |
| static void smsg_event_work_fn(struct work_struct *work) | |
| { | |
| LIST_HEAD(event_queue); | |
| struct smsg_app_event *p, *n; | |
| struct device *dev; | |
| dev = get_device(smsg_app_dev); | |
| if (!dev) | |
| return; | |
| spin_lock_bh(&smsg_event_queue_lock); | |
| list_splice_init(&smsg_event_queue, &event_queue); | |
| spin_unlock_bh(&smsg_event_queue_lock); | |
| list_for_each_entry_safe(p, n, &event_queue, list) { | |
| list_del(&p->list); | |
| kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, p->envp); | |
| smsg_app_event_free(p); | |
| } | |
| put_device(dev); | |
| } | |
| static DECLARE_WORK(smsg_event_work, smsg_event_work_fn); | |
| static void smsg_app_callback(const char *from, char *msg) | |
| { | |
| struct smsg_app_event *se; | |
| /* check if the originating z/VM user ID matches | |
| * the configured sender. */ | |
| if (sender && strlen(sender) > 0 && strcmp(from, sender) != 0) | |
| return; | |
| /* get start of message text (skip prefix and leading blanks) */ | |
| msg += strlen(SMSG_PREFIX); | |
| while (*msg && isspace(*msg)) | |
| msg++; | |
| if (*msg == '\0') | |
| return; | |
| /* allocate event list element and its environment */ | |
| se = smsg_app_event_alloc(from, msg); | |
| if (!se) | |
| return; | |
| /* queue event and schedule work function */ | |
| spin_lock(&smsg_event_queue_lock); | |
| list_add_tail(&se->list, &smsg_event_queue); | |
| spin_unlock(&smsg_event_queue_lock); | |
| schedule_work(&smsg_event_work); | |
| return; | |
| } | |
| static int __init smsgiucv_app_init(void) | |
| { | |
| struct device_driver *smsgiucv_drv; | |
| int rc; | |
| if (!MACHINE_IS_VM) | |
| return -ENODEV; | |
| smsg_app_dev = kzalloc(sizeof(*smsg_app_dev), GFP_KERNEL); | |
| if (!smsg_app_dev) | |
| return -ENOMEM; | |
| smsgiucv_drv = driver_find(SMSGIUCV_DRV_NAME, &iucv_bus); | |
| if (!smsgiucv_drv) { | |
| kfree(smsg_app_dev); | |
| return -ENODEV; | |
| } | |
| rc = dev_set_name(smsg_app_dev, KMSG_COMPONENT); | |
| if (rc) { | |
| kfree(smsg_app_dev); | |
| goto fail; | |
| } | |
| smsg_app_dev->bus = &iucv_bus; | |
| smsg_app_dev->parent = iucv_root; | |
| smsg_app_dev->release = (void (*)(struct device *)) kfree; | |
| smsg_app_dev->driver = smsgiucv_drv; | |
| rc = device_register(smsg_app_dev); | |
| if (rc) { | |
| put_device(smsg_app_dev); | |
| goto fail; | |
| } | |
| /* convert sender to uppercase characters */ | |
| if (sender) { | |
| int len = strlen(sender); | |
| while (len--) | |
| sender[len] = toupper(sender[len]); | |
| } | |
| /* register with the smsgiucv device driver */ | |
| rc = smsg_register_callback(SMSG_PREFIX, smsg_app_callback); | |
| if (rc) { | |
| device_unregister(smsg_app_dev); | |
| goto fail; | |
| } | |
| rc = 0; | |
| fail: | |
| return rc; | |
| } | |
| module_init(smsgiucv_app_init); | |
| static void __exit smsgiucv_app_exit(void) | |
| { | |
| /* unregister callback */ | |
| smsg_unregister_callback(SMSG_PREFIX, smsg_app_callback); | |
| /* cancel pending work and flush any queued event work */ | |
| cancel_work_sync(&smsg_event_work); | |
| smsg_event_work_fn(&smsg_event_work); | |
| device_unregister(smsg_app_dev); | |
| } | |
| module_exit(smsgiucv_app_exit); | |
| MODULE_LICENSE("GPL v2"); | |
| MODULE_DESCRIPTION("Deliver z/VM CP SMSG as uevents"); | |
| MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>"); |