drivers/s390/char/sclp_async.c

   1 /*
   2  * Enable Asynchronous Notification via SCLP.
   3  *
   4  * Copyright IBM Corp. 2009
   5  * Author(s): Hans-Joachim Picht <hans@linux.vnet.ibm.com>
   6  *
   7  */
   8
   9 #include <linux/init.h>
  10 #include <linux/module.h>
  11 #include <linux/device.h>
  12 #include <linux/stat.h>
  13 #include <linux/string.h>
  14 #include <linux/ctype.h>
  15 #include <linux/kmod.h>
  16 #include <linux/err.h>
  17 #include <linux/errno.h>
  18 #include <linux/proc_fs.h>
  19 #include <linux/sysctl.h>
  20 #include <linux/utsname.h>
  21 #include "sclp.h"
  22
  23 static int callhome_enabled;
  24 static struct sclp_req *request;
  25 static struct sclp_async_sccb *sccb;
  26 static int sclp_async_send_wait(char *message);
  27 static struct ctl_table_header *callhome_sysctl_header;
  28 static DEFINE_SPINLOCK(sclp_async_lock);
  29 static char nodename[64];
  30 #define SCLP_NORMAL_WRITE       0x00
  31
  32 struct async_evbuf {
  33         struct evbuf_header header;
  34         u64 reserved;
  35         u8 rflags;
  36         u8 empty;
  37         u8 rtype;
  38         u8 otype;
  39         char comp_id[12];
  40         char data[3000]; /* there is still some space left */
  41 } __attribute__((packed));
  42
  43 struct sclp_async_sccb {
  44         struct sccb_header header;
  45         struct async_evbuf evbuf;
  46 } __attribute__((packed));
  47
  48 static struct sclp_register sclp_async_register = {
  49         .send_mask = EVTYP_ASYNC_MASK,
  50 };
  51
  52 static int call_home_on_panic(struct notifier_block *self,
  53                               unsigned long event, void *data)
  54 {
  55                 strncat(data, nodename, strlen(nodename));
  56                 sclp_async_send_wait(data);
  57                 return NOTIFY_DONE;
  58 }
  59
  60 static struct notifier_block call_home_panic_nb = {
  61         .notifier_call = call_home_on_panic,
  62         .priority = INT_MAX,
  63 };
  64
  65 static int proc_handler_callhome(struct ctl_table *ctl, int write,
  66                                  void __user *buffer, size_t *count,
  67                                  loff_t *ppos)
  68 {
  69         unsigned long val;
  70         int len, rc;
  71         char buf[2];
  72
  73         if (!*count | (*ppos && !write)) {
  74                 *count = 0;
  75                 return 0;
  76         }
  77         if (!write) {
  78                 len =  sprintf(buf, "%d\n", callhome_enabled);
  79                 buf[len] = '\0';
  80                 rc = copy_to_user(buffer, buf, sizeof(buf));
  81                 if (rc != 0)
  82                         return -EFAULT;
  83         } else {
  84                 len = *count;
  85                 rc = copy_from_user(buf, buffer, sizeof(buf));
  86                 if (rc != 0)
  87                         return -EFAULT;
  88                 if (strict_strtoul(buf, 0, &val) != 0)
  89                         return -EINVAL;
  90                 if (val != 0 && val != 1)
  91                         return -EINVAL;
  92                 callhome_enabled = val;
  93         }
  94         *count = len;
  95         *ppos += len;
  96         return 0;
  97 }
  98
  99 static struct ctl_table callhome_table[] = {
 100         {
 101                 .procname       = "callhome",
 102                 .mode           = 0644,
 103                 .proc_handler   = proc_handler_callhome,
 104         },
 105         { .ctl_name = 0 }
 106 };
 107
 108 static struct ctl_table kern_dir_table[] = {
 109         {
 110                 .ctl_name       = CTL_KERN,
 111                 .procname       = "kernel",
 112                 .maxlen         = 0,
 113                 .mode           = 0555,
 114                 .child          = callhome_table,
 115         },
 116         { .ctl_name = 0 }
 117 };
 118
 119 /*
 120  * Function used to transfer asynchronous notification
 121  * records which waits for send completion
 122  */
 123 static int sclp_async_send_wait(char *message)
 124 {
 125         struct async_evbuf *evb;
 126         int rc;
 127         unsigned long flags;
 128
 129         if (!callhome_enabled)
 130                 return 0;
 131         sccb->evbuf.header.type = EVTYP_ASYNC;
 132         sccb->evbuf.rtype = 0xA5;
 133         sccb->evbuf.otype = 0x00;
 134         evb = &sccb->evbuf;
 135         request->command = SCLP_CMDW_WRITE_EVENT_DATA;
 136         request->sccb = sccb;
 137         request->status = SCLP_REQ_FILLED;
 138         strncpy(sccb->evbuf.data, message, sizeof(sccb->evbuf.data));
 139         /*
 140          * Retain Queue
 141          * e.g. 5639CC140 500 Red Hat RHEL5 Linux for zSeries (RHEL AS)
 142          */
 143         strncpy(sccb->evbuf.comp_id, "000000000", sizeof(sccb->evbuf.comp_id));
 144         sccb->evbuf.header.length = sizeof(sccb->evbuf);
 145         sccb->header.length = sizeof(sccb->evbuf) + sizeof(sccb->header);
 146         sccb->header.function_code = SCLP_NORMAL_WRITE;
 147         rc = sclp_add_request(request);
 148         if (rc)
 149                 return rc;
 150         spin_lock_irqsave(&sclp_async_lock, flags);
 151         while (request->status != SCLP_REQ_DONE &&
 152                 request->status != SCLP_REQ_FAILED) {
 153                  sclp_sync_wait();
 154         }
 155         spin_unlock_irqrestore(&sclp_async_lock, flags);
 156         if (request->status != SCLP_REQ_DONE)
 157                 return -EIO;
 158         rc = ((struct sclp_async_sccb *)
 159                request->sccb)->header.response_code;
 160         if (rc != 0x0020)
 161                 return -EIO;
 162         if (evb->header.flags != 0x80)
 163                 return -EIO;
 164         return rc;
 165 }
 166
 167 static int __init sclp_async_init(void)
 168 {
 169         int rc;
 170
 171         rc = sclp_register(&sclp_async_register);
 172         if (rc)
 173                 return rc;
 174         callhome_sysctl_header = register_sysctl_table(kern_dir_table);
 175         if (!callhome_sysctl_header) {
 176                 rc = -ENOMEM;
 177                 goto out_sclp;
 178         }
 179         if (!(sclp_async_register.sclp_receive_mask & EVTYP_ASYNC_MASK)) {
 180                 rc = -EOPNOTSUPP;
 181                 goto out_sclp;
 182         }
 183         rc = -ENOMEM;
 184         request = kzalloc(sizeof(struct sclp_req), GFP_KERNEL);
 185         if (!request)
 186                 goto out_sys;
 187         sccb = (struct sclp_async_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 188         if (!sccb)
 189                 goto out_mem;
 190         rc =  atomic_notifier_chain_register(&panic_notifier_list,
 191                                              &call_home_panic_nb);
 192         if (rc)
 193                 goto out_mem;
 194
 195         strncpy(nodename, init_utsname()->nodename, 64);
 196         return 0;
 197
 198 out_mem:
 199         kfree(request);
 200         free_page((unsigned long) sccb);
 201 out_sys:
 202         unregister_sysctl_table(callhome_sysctl_header);
 203 out_sclp:
 204         sclp_unregister(&sclp_async_register);
 205         return rc;
 206
 207 }
 208 module_init(sclp_async_init);
 209
 210 static void __exit sclp_async_exit(void)
 211 {
 212         atomic_notifier_chain_unregister(&panic_notifier_list,
 213                                          &call_home_panic_nb);
 214         unregister_sysctl_table(callhome_sysctl_header);
 215         sclp_unregister(&sclp_async_register);
 216         free_page((unsigned long) sccb);
 217         kfree(request);
 218 }
 219 module_exit(sclp_async_exit);
 220
 221 MODULE_AUTHOR("Copyright IBM Corp. 2009");
 222 MODULE_AUTHOR("Hans-Joachim Picht <hans@linux.vnet.ibm.com>");
 223 MODULE_LICENSE("GPL");
 224 MODULE_DESCRIPTION("SCLP Asynchronous Notification Records");