drivers/s390/net/smsgiucv.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * IUCV special message driver
   4  *
   5  * Copyright IBM Corp. 2003, 2009
   6  *
   7  * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/init.h>
  12 #include <linux/errno.h>
  13 #include <linux/device.h>
  14 #include <linux/slab.h>
  15 #include <net/iucv/iucv.h>
  16 #include <asm/cpcmd.h>
  17 #include <asm/ebcdic.h>
  18 #include "smsgiucv.h"
  19
  20 struct smsg_callback {
  21         struct list_head list;
  22         const char *prefix;
  23         int len;
  24         void (*callback)(const char *from, char *str);
  25 };
  26
  27 MODULE_AUTHOR
  28    ("(C) 2003 IBM Corporation by Martin Schwidefsky (schwidefsky@de.ibm.com)");
  29 MODULE_DESCRIPTION ("Linux for S/390 IUCV special message driver");
  30
  31 static struct iucv_path *smsg_path;
  32
  33 static DEFINE_SPINLOCK(smsg_list_lock);
  34 static LIST_HEAD(smsg_list);
  35
  36 static int smsg_path_pending(struct iucv_path *, u8 *, u8 *);
  37 static void smsg_message_pending(struct iucv_path *, struct iucv_message *);
  38
  39 static struct iucv_handler smsg_handler = {
  40         .path_pending    = smsg_path_pending,
  41         .message_pending = smsg_message_pending,
  42 };
  43
  44 static int smsg_path_pending(struct iucv_path *path, u8 *ipvmid, u8 *ipuser)
  45 {
  46         if (strncmp(ipvmid, "*MSG    ", 8) != 0)
  47                 return -EINVAL;
  48         /* Path pending from *MSG. */
  49         return iucv_path_accept(path, &smsg_handler, "SMSGIUCV        ", NULL);
  50 }
  51
  52 static void smsg_message_pending(struct iucv_path *path,
  53                                  struct iucv_message *msg)
  54 {
  55         struct smsg_callback *cb;
  56         unsigned char *buffer;
  57         unsigned char sender[9];
  58         int rc, i;
  59
  60         buffer = kmalloc(msg->length + 1, GFP_ATOMIC | GFP_DMA);
  61         if (!buffer) {
  62                 iucv_message_reject(path, msg);
  63                 return;
  64         }
  65         rc = iucv_message_receive(path, msg, 0, buffer, msg->length, NULL);
  66         if (rc == 0) {
  67                 buffer[msg->length] = 0;
  68                 EBCASC(buffer, msg->length);
  69                 memcpy(sender, buffer, 8);
  70                 sender[8] = 0;
  71                 /* Remove trailing whitespace from the sender name. */
  72                 for (i = 7; i >= 0; i--) {
  73                         if (sender[i] != ' ' && sender[i] != '\t')
  74                                 break;
  75                         sender[i] = 0;
  76                 }
  77                 spin_lock(&smsg_list_lock);
  78                 list_for_each_entry(cb, &smsg_list, list)
  79                         if (strncmp(buffer + 8, cb->prefix, cb->len) == 0) {
  80                                 cb->callback(sender, buffer + 8);
  81                                 break;
  82                         }
  83                 spin_unlock(&smsg_list_lock);
  84         }
  85         kfree(buffer);
  86 }
  87
  88 int smsg_register_callback(const char *prefix,
  89                            void (*callback)(const char *from, char *str))
  90 {
  91         struct smsg_callback *cb;
  92
  93         cb = kmalloc(sizeof(struct smsg_callback), GFP_KERNEL);
  94         if (!cb)
  95                 return -ENOMEM;
  96         cb->prefix = prefix;
  97         cb->len = strlen(prefix);
  98         cb->callback = callback;
  99         spin_lock_bh(&smsg_list_lock);
 100         list_add_tail(&cb->list, &smsg_list);
 101         spin_unlock_bh(&smsg_list_lock);
 102         return 0;
 103 }
 104
 105 void smsg_unregister_callback(const char *prefix,
 106                               void (*callback)(const char *from,
 107                                                char *str))
 108 {
 109         struct smsg_callback *cb, *tmp;
 110
 111         spin_lock_bh(&smsg_list_lock);
 112         cb = NULL;
 113         list_for_each_entry(tmp, &smsg_list, list)
 114                 if (tmp->callback == callback &&
 115                     strcmp(tmp->prefix, prefix) == 0) {
 116                         cb = tmp;
 117                         list_del(&cb->list);
 118                         break;
 119                 }
 120         spin_unlock_bh(&smsg_list_lock);
 121         kfree(cb);
 122 }
 123
 124 static struct device_driver smsg_driver = {
 125         .owner = THIS_MODULE,
 126         .name = SMSGIUCV_DRV_NAME,
 127         .bus  = &iucv_bus,
 128 };
 129
 130 static void __exit smsg_exit(void)
 131 {
 132         cpcmd("SET SMSG OFF", NULL, 0, NULL);
 133         iucv_unregister(&smsg_handler, 1);
 134         driver_unregister(&smsg_driver);
 135 }
 136
 137 static int __init smsg_init(void)
 138 {
 139         int rc;
 140
 141         if (!MACHINE_IS_VM) {
 142                 rc = -EPROTONOSUPPORT;
 143                 goto out;
 144         }
 145         rc = driver_register(&smsg_driver);
 146         if (rc != 0)
 147                 goto out;
 148         rc = iucv_register(&smsg_handler, 1);
 149         if (rc)
 150                 goto out_driver;
 151         smsg_path = iucv_path_alloc(255, 0, GFP_KERNEL);
 152         if (!smsg_path) {
 153                 rc = -ENOMEM;
 154                 goto out_register;
 155         }
 156         rc = iucv_path_connect(smsg_path, &smsg_handler, "*MSG    ",
 157                                NULL, NULL, NULL);
 158         if (rc)
 159                 goto out_free_path;
 160
 161         cpcmd("SET SMSG IUCV", NULL, 0, NULL);
 162         return 0;
 163
 164 out_free_path:
 165         iucv_path_free(smsg_path);
 166         smsg_path = NULL;
 167 out_register:
 168         iucv_unregister(&smsg_handler, 1);
 169 out_driver:
 170         driver_unregister(&smsg_driver);
 171 out:
 172         return rc;
 173 }
 174
 175 module_init(smsg_init);
 176 module_exit(smsg_exit);
 177 MODULE_LICENSE("GPL");
 178
 179 EXPORT_SYMBOL(smsg_register_callback);
 180 EXPORT_SYMBOL(smsg_unregister_callback);