[S390] smsgiucv_app: deliver z/VM CP special messages (SMSG) as uevents
authorHendrik Brueckner <brueckner@linux.vnet.ibm.com>
Mon, 8 Mar 2010 11:26:26 +0000 (12:26 +0100)
committerMartin Schwidefsky <sky@mschwide.boeblingen.de.ibm.com>
Mon, 8 Mar 2010 11:26:28 +0000 (12:26 +0100)
The smsgiucv_app driver registers a callback with the smsgiucv driver
to receive z/VM CP special messages (SMSG) starting with "APP".

When the callback is called for special messages, the driver creates
an uevent for the received message.  The uevent consists of additional
environment data containing the message prefix ("APP"), message sender,
and message content.

udev rules can be used to trigger application specific actions through
matching the content or sender of the special message.

Signed-off-by: Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
drivers/s390/net/Kconfig
drivers/s390/net/Makefile
drivers/s390/net/smsgiucv.c
drivers/s390/net/smsgiucv.h
drivers/s390/net/smsgiucv_app.c [new file with mode: 0644]

index cb909a5b5047e11fc6b3d6ddcca3a31811f73106..977bb4d4ed15425b6b780649c5c15d98e977c964 100644 (file)
@@ -43,6 +43,16 @@ config SMSGIUCV
          Select this option if you want to be able to receive SMSG messages
          from other VM guest systems.
 
+config SMSGIUCV_EVENT
+       tristate "Deliver IUCV special messages as uevents (VM only)"
+       depends on SMSGIUCV
+       help
+         Select this option to deliver CP special messages (SMSGs) as
+         uevents.  The driver handles only those special messages that
+         start with "APP".
+
+         To compile as a module, choose M. The module name is "smsgiucv_app".
+
 config CLAW
        tristate "CLAW device support"
        depends on CCW && NETDEVICES
index 6cab5a62f99e602194de9459e839cbd2a6ae4dd9..4dfe8c1092da3210edc06b0e56966ffe9448a600 100644 (file)
@@ -6,6 +6,7 @@ ctcm-y += ctcm_main.o ctcm_fsms.o ctcm_mpc.o ctcm_sysfs.o ctcm_dbug.o
 obj-$(CONFIG_CTCM) += ctcm.o fsm.o
 obj-$(CONFIG_NETIUCV) += netiucv.o fsm.o
 obj-$(CONFIG_SMSGIUCV) += smsgiucv.o
+obj-$(CONFIG_SMSGIUCV_EVENT) += smsgiucv_app.o
 obj-$(CONFIG_LCS) += lcs.o
 obj-$(CONFIG_CLAW) += claw.o
 qeth-y += qeth_core_sys.o qeth_core_main.o qeth_core_mpc.o
index 3e666b6e77b4e799cbce6ca6424f2ee87842c431..ecef1edee701013420d64fb99e2677e8a42e18df 100644 (file)
@@ -177,7 +177,7 @@ static const struct dev_pm_ops smsg_pm_ops = {
 
 static struct device_driver smsg_driver = {
        .owner = THIS_MODULE,
-       .name = "SMSGIUCV",
+       .name = SMSGIUCV_DRV_NAME,
        .bus  = &iucv_bus,
        .pm = &smsg_pm_ops,
 };
index 9410b45fde03efe5df14045d6e619a9d78196220..149a1151608d4f60ade750da2102f1aa2961bfb6 100644 (file)
@@ -5,6 +5,8 @@
  * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
  */
 
+#define SMSGIUCV_DRV_NAME     "SMSGIUCV"
+
 int  smsg_register_callback(const char *,
                            void (*)(const char *, char *));
 void smsg_unregister_callback(const char *,
diff --git a/drivers/s390/net/smsgiucv_app.c b/drivers/s390/net/smsgiucv_app.c
new file mode 100644 (file)
index 0000000..91579dc
--- /dev/null
@@ -0,0 +1,211 @@
+/*
+ * 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/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_put_driver;
+       }
+       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_put_driver;
+       }
+
+       /* register with the smsgiucv device driver */
+       rc = smsg_register_callback(SMSG_PREFIX, smsg_app_callback);
+       if (rc) {
+               device_unregister(smsg_app_dev);
+               goto fail_put_driver;
+       }
+
+       rc = 0;
+fail_put_driver:
+       put_driver(smsgiucv_drv);
+       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>");