drivers/s390/char/vmlogrdr.c

   1 /*
   2  *      character device driver for reading z/VM system service records
   3  *
   4  *
   5  *      Copyright IBM Corp. 2004, 2009
   6  *      character device driver for reading z/VM system service records,
   7  *      Version 1.0
   8  *      Author(s): Xenia Tkatschow <xenia@us.ibm.com>
   9  *                 Stefan Weinhuber <wein@de.ibm.com>
  10  *
  11  */
  12
  13 #define KMSG_COMPONENT "vmlogrdr"
  14 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  15
  16 #include <linux/module.h>
  17 #include <linux/init.h>
  18 #include <linux/slab.h>
  19 #include <linux/errno.h>
  20 #include <linux/types.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/spinlock.h>
  23 #include <linux/atomic.h>
  24 #include <asm/uaccess.h>
  25 #include <asm/cpcmd.h>
  26 #include <asm/debug.h>
  27 #include <asm/ebcdic.h>
  28 #include <net/iucv/iucv.h>
  29 #include <linux/kmod.h>
  30 #include <linux/cdev.h>
  31 #include <linux/device.h>
  32 #include <linux/string.h>
  33
  34 MODULE_AUTHOR
  35         ("(C) 2004 IBM Corporation by Xenia Tkatschow (xenia@us.ibm.com)\n"
  36          "                            Stefan Weinhuber (wein@de.ibm.com)");
  37 MODULE_DESCRIPTION ("Character device driver for reading z/VM "
  38                     "system service records.");
  39 MODULE_LICENSE("GPL");
  40
  41
  42 /*
  43  * The size of the buffer for iucv data transfer is one page,
  44  * but in addition to the data we read from iucv we also
  45  * place an integer and some characters into that buffer,
  46  * so the maximum size for record data is a little less then
  47  * one page.
  48  */
  49 #define NET_BUFFER_SIZE (PAGE_SIZE - sizeof(int) - sizeof(FENCE))
  50
  51 /*
  52  * The elements that are concurrently accessed by bottom halves are
  53  * connection_established, iucv_path_severed, local_interrupt_buffer
  54  * and receive_ready. The first three can be protected by
  55  * priv_lock.  receive_ready is atomic, so it can be incremented and
  56  * decremented without holding a lock.
  57  * The variable dev_in_use needs to be protected by the lock, since
  58  * it's a flag used by open to make sure that the device is opened only
  59  * by one user at the same time.
  60  */
  61 struct vmlogrdr_priv_t {
  62         char system_service[8];
  63         char internal_name[8];
  64         char recording_name[8];
  65         struct iucv_path *path;
  66         int connection_established;
  67         int iucv_path_severed;
  68         struct iucv_message local_interrupt_buffer;
  69         atomic_t receive_ready;
  70         int minor_num;
  71         char * buffer;
  72         char * current_position;
  73         int remaining;
  74         ulong residual_length;
  75         int buffer_free;
  76         int dev_in_use; /* 1: already opened, 0: not opened*/
  77         spinlock_t priv_lock;
  78         struct device  *device;
  79         struct device  *class_device;
  80         int autorecording;
  81         int autopurge;
  82 };
  83
  84
  85 /*
  86  * File operation structure for vmlogrdr devices
  87  */
  88 static int vmlogrdr_open(struct inode *, struct file *);
  89 static int vmlogrdr_release(struct inode *, struct file *);
  90 static ssize_t vmlogrdr_read (struct file *filp, char __user *data,
  91                               size_t count, loff_t * ppos);
  92
  93 static const struct file_operations vmlogrdr_fops = {
  94         .owner   = THIS_MODULE,
  95         .open    = vmlogrdr_open,
  96         .release = vmlogrdr_release,
  97         .read    = vmlogrdr_read,
  98         .llseek  = no_llseek,
  99 };
 100
 101
 102 static void vmlogrdr_iucv_path_complete(struct iucv_path *, u8 *ipuser);
 103 static void vmlogrdr_iucv_path_severed(struct iucv_path *, u8 *ipuser);
 104 static void vmlogrdr_iucv_message_pending(struct iucv_path *,
 105                                           struct iucv_message *);
 106
 107
 108 static struct iucv_handler vmlogrdr_iucv_handler = {
 109         .path_complete   = vmlogrdr_iucv_path_complete,
 110         .path_severed    = vmlogrdr_iucv_path_severed,
 111         .message_pending = vmlogrdr_iucv_message_pending,
 112 };
 113
 114
 115 static DECLARE_WAIT_QUEUE_HEAD(conn_wait_queue);
 116 static DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);
 117
 118 /*
 119  * pointer to system service private structure
 120  * minor number 0 --> logrec
 121  * minor number 1 --> account
 122  * minor number 2 --> symptom
 123  */
 124
 125 static struct vmlogrdr_priv_t sys_ser[] = {
 126         { .system_service = "*LOGREC ",
 127           .internal_name  = "logrec",
 128           .recording_name = "EREP",
 129           .minor_num      = 0,
 130           .buffer_free    = 1,
 131           .priv_lock      = __SPIN_LOCK_UNLOCKED(sys_ser[0].priv_lock),
 132           .autorecording  = 1,
 133           .autopurge      = 1,
 134         },
 135         { .system_service = "*ACCOUNT",
 136           .internal_name  = "account",
 137           .recording_name = "ACCOUNT",
 138           .minor_num      = 1,
 139           .buffer_free    = 1,
 140           .priv_lock      = __SPIN_LOCK_UNLOCKED(sys_ser[1].priv_lock),
 141           .autorecording  = 1,
 142           .autopurge      = 1,
 143         },
 144         { .system_service = "*SYMPTOM",
 145           .internal_name  = "symptom",
 146           .recording_name = "SYMPTOM",
 147           .minor_num      = 2,
 148           .buffer_free    = 1,
 149           .priv_lock      = __SPIN_LOCK_UNLOCKED(sys_ser[2].priv_lock),
 150           .autorecording  = 1,
 151           .autopurge      = 1,
 152         }
 153 };
 154
 155 #define MAXMINOR  (sizeof(sys_ser)/sizeof(struct vmlogrdr_priv_t))
 156
 157 static char FENCE[] = {"EOR"};
 158 static int vmlogrdr_major = 0;
 159 static struct cdev  *vmlogrdr_cdev = NULL;
 160 static int recording_class_AB;
 161
 162
 163 static void vmlogrdr_iucv_path_complete(struct iucv_path *path, u8 *ipuser)
 164 {
 165         struct vmlogrdr_priv_t * logptr = path->private;
 166
 167         spin_lock(&logptr->priv_lock);
 168         logptr->connection_established = 1;
 169         spin_unlock(&logptr->priv_lock);
 170         wake_up(&conn_wait_queue);
 171 }
 172
 173
 174 static void vmlogrdr_iucv_path_severed(struct iucv_path *path, u8 *ipuser)
 175 {
 176         struct vmlogrdr_priv_t * logptr = path->private;
 177         u8 reason = (u8) ipuser[8];
 178
 179         pr_err("vmlogrdr: connection severed with reason %i\n", reason);
 180
 181         iucv_path_sever(path, NULL);
 182         kfree(path);
 183         logptr->path = NULL;
 184
 185         spin_lock(&logptr->priv_lock);
 186         logptr->connection_established = 0;
 187         logptr->iucv_path_severed = 1;
 188         spin_unlock(&logptr->priv_lock);
 189
 190         wake_up(&conn_wait_queue);
 191         /* just in case we're sleeping waiting for a record */
 192         wake_up_interruptible(&read_wait_queue);
 193 }
 194
 195
 196 static void vmlogrdr_iucv_message_pending(struct iucv_path *path,
 197                                           struct iucv_message *msg)
 198 {
 199         struct vmlogrdr_priv_t * logptr = path->private;
 200
 201         /*
 202          * This function is the bottom half so it should be quick.
 203          * Copy the external interrupt data into our local eib and increment
 204          * the usage count
 205          */
 206         spin_lock(&logptr->priv_lock);
 207         memcpy(&logptr->local_interrupt_buffer, msg, sizeof(*msg));
 208         atomic_inc(&logptr->receive_ready);
 209         spin_unlock(&logptr->priv_lock);
 210         wake_up_interruptible(&read_wait_queue);
 211 }
 212
 213
 214 static int vmlogrdr_get_recording_class_AB(void)
 215 {
 216         static const char cp_command[] = "QUERY COMMAND RECORDING ";
 217         char cp_response[80];
 218         char *tail;
 219         int len,i;
 220
 221         cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 222         len = strnlen(cp_response,sizeof(cp_response));
 223         // now the parsing
 224         tail=strnchr(cp_response,len,'=');
 225         if (!tail)
 226                 return 0;
 227         tail++;
 228         if (!strncmp("ANY",tail,3))
 229                 return 1;
 230         if (!strncmp("NONE",tail,4))
 231                 return 0;
 232         /*
 233          * expect comma separated list of classes here, if one of them
 234          * is A or B return 1 otherwise 0
 235          */
 236         for (i=tail-cp_response; i<len; i++)
 237                 if ( cp_response[i]=='A' || cp_response[i]=='B' )
 238                         return 1;
 239         return 0;
 240 }
 241
 242
 243 static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr,
 244                               int action, int purge)
 245 {
 246
 247         char cp_command[80];
 248         char cp_response[160];
 249         char *onoff, *qid_string;
 250         int rc;
 251
 252         onoff = ((action == 1) ? "ON" : "OFF");
 253         qid_string = ((recording_class_AB == 1) ? " QID * " : "");
 254
 255         /*
 256          * The recording commands needs to be called with option QID
 257          * for guests that have previlege classes A or B.
 258          * Purging has to be done as separate step, because recording
 259          * can't be switched on as long as records are on the queue.
 260          * Doing both at the same time doesn't work.
 261          */
 262         if (purge && (action == 1)) {
 263                 memset(cp_command, 0x00, sizeof(cp_command));
 264                 memset(cp_response, 0x00, sizeof(cp_response));
 265                 snprintf(cp_command, sizeof(cp_command),
 266                          "RECORDING %s PURGE %s",
 267                          logptr->recording_name,
 268                          qid_string);
 269                 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 270         }
 271
 272         memset(cp_command, 0x00, sizeof(cp_command));
 273         memset(cp_response, 0x00, sizeof(cp_response));
 274         snprintf(cp_command, sizeof(cp_command), "RECORDING %s %s %s",
 275                 logptr->recording_name,
 276                 onoff,
 277                 qid_string);
 278         cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 279         /* The recording command will usually answer with 'Command complete'
 280          * on success, but when the specific service was never connected
 281          * before then there might be an additional informational message
 282          * 'HCPCRC8072I Recording entry not found' before the
 283          * 'Command complete'. So I use strstr rather then the strncmp.
 284          */
 285         if (strstr(cp_response,"Command complete"))
 286                 rc = 0;
 287         else
 288                 rc = -EIO;
 289         /*
 290          * If we turn recording off, we have to purge any remaining records
 291          * afterwards, as a large number of queued records may impact z/VM
 292          * performance.
 293          */
 294         if (purge && (action == 0)) {
 295                 memset(cp_command, 0x00, sizeof(cp_command));
 296                 memset(cp_response, 0x00, sizeof(cp_response));
 297                 snprintf(cp_command, sizeof(cp_command),
 298                          "RECORDING %s PURGE %s",
 299                          logptr->recording_name,
 300                          qid_string);
 301                 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 302         }
 303
 304         return rc;
 305 }
 306
 307
 308 static int vmlogrdr_open (struct inode *inode, struct file *filp)
 309 {
 310         int dev_num = 0;
 311         struct vmlogrdr_priv_t * logptr = NULL;
 312         int connect_rc = 0;
 313         int ret;
 314
 315         dev_num = iminor(inode);
 316         if (dev_num >= MAXMINOR)
 317                 return -ENODEV;
 318         logptr = &sys_ser[dev_num];
 319
 320         /*
 321          * only allow for blocking reads to be open
 322          */
 323         if (filp->f_flags & O_NONBLOCK)
 324                 return -EOPNOTSUPP;
 325
 326         /* Besure this device hasn't already been opened */
 327         spin_lock_bh(&logptr->priv_lock);
 328         if (logptr->dev_in_use) {
 329                 spin_unlock_bh(&logptr->priv_lock);
 330                 return -EBUSY;
 331         }
 332         logptr->dev_in_use = 1;
 333         logptr->connection_established = 0;
 334         logptr->iucv_path_severed = 0;
 335         atomic_set(&logptr->receive_ready, 0);
 336         logptr->buffer_free = 1;
 337         spin_unlock_bh(&logptr->priv_lock);
 338
 339         /* set the file options */
 340         filp->private_data = logptr;
 341
 342         /* start recording for this service*/
 343         if (logptr->autorecording) {
 344                 ret = vmlogrdr_recording(logptr,1,logptr->autopurge);
 345                 if (ret)
 346                         pr_warn("vmlogrdr: failed to start recording automatically\n");
 347         }
 348
 349         /* create connection to the system service */
 350         logptr->path = iucv_path_alloc(10, 0, GFP_KERNEL);
 351         if (!logptr->path)
 352                 goto out_dev;
 353         connect_rc = iucv_path_connect(logptr->path, &vmlogrdr_iucv_handler,
 354                                        logptr->system_service, NULL, NULL,
 355                                        logptr);
 356         if (connect_rc) {
 357                 pr_err("vmlogrdr: iucv connection to %s "
 358                        "failed with rc %i \n",
 359                        logptr->system_service, connect_rc);
 360                 goto out_path;
 361         }
 362
 363         /* We've issued the connect and now we must wait for a
 364          * ConnectionComplete or ConnectinSevered Interrupt
 365          * before we can continue to process.
 366          */
 367         wait_event(conn_wait_queue, (logptr->connection_established)
 368                    || (logptr->iucv_path_severed));
 369         if (logptr->iucv_path_severed)
 370                 goto out_record;
 371         nonseekable_open(inode, filp);
 372         return 0;
 373
 374 out_record:
 375         if (logptr->autorecording)
 376                 vmlogrdr_recording(logptr,0,logptr->autopurge);
 377 out_path:
 378         kfree(logptr->path);    /* kfree(NULL) is ok. */
 379         logptr->path = NULL;
 380 out_dev:
 381         logptr->dev_in_use = 0;
 382         return -EIO;
 383 }
 384
 385
 386 static int vmlogrdr_release (struct inode *inode, struct file *filp)
 387 {
 388         int ret;
 389
 390         struct vmlogrdr_priv_t * logptr = filp->private_data;
 391
 392         iucv_path_sever(logptr->path, NULL);
 393         kfree(logptr->path);
 394         logptr->path = NULL;
 395         if (logptr->autorecording) {
 396                 ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
 397                 if (ret)
 398                         pr_warn("vmlogrdr: failed to stop recording automatically\n");
 399         }
 400         logptr->dev_in_use = 0;
 401
 402         return 0;
 403 }
 404
 405
 406 static int vmlogrdr_receive_data(struct vmlogrdr_priv_t *priv)
 407 {
 408         int rc, *temp;
 409         /* we need to keep track of two data sizes here:
 410          * The number of bytes we need to receive from iucv and
 411          * the total number of bytes we actually write into the buffer.
 412          */
 413         int user_data_count, iucv_data_count;
 414         char * buffer;
 415
 416         if (atomic_read(&priv->receive_ready)) {
 417                 spin_lock_bh(&priv->priv_lock);
 418                 if (priv->residual_length){
 419                         /* receive second half of a record */
 420                         iucv_data_count = priv->residual_length;
 421                         user_data_count = 0;
 422                         buffer = priv->buffer;
 423                 } else {
 424                         /* receive a new record:
 425                          * We need to return the total length of the record
 426                          * + size of FENCE in the first 4 bytes of the buffer.
 427                          */
 428                         iucv_data_count = priv->local_interrupt_buffer.length;
 429                         user_data_count = sizeof(int);
 430                         temp = (int*)priv->buffer;
 431                         *temp= iucv_data_count + sizeof(FENCE);
 432                         buffer = priv->buffer + sizeof(int);
 433                 }
 434                 /*
 435                  * If the record is bigger than our buffer, we receive only
 436                  * a part of it. We can get the rest later.
 437                  */
 438                 if (iucv_data_count > NET_BUFFER_SIZE)
 439                         iucv_data_count = NET_BUFFER_SIZE;
 440                 rc = iucv_message_receive(priv->path,
 441                                           &priv->local_interrupt_buffer,
 442                                           0, buffer, iucv_data_count,
 443                                           &priv->residual_length);
 444                 spin_unlock_bh(&priv->priv_lock);
 445                 /* An rc of 5 indicates that the record was bigger than
 446                  * the buffer, which is OK for us. A 9 indicates that the
 447                  * record was purged befor we could receive it.
 448                  */
 449                 if (rc == 5)
 450                         rc = 0;
 451                 if (rc == 9)
 452                         atomic_set(&priv->receive_ready, 0);
 453         } else {
 454                 rc = 1;
 455         }
 456         if (!rc) {
 457                 priv->buffer_free = 0;
 458                 user_data_count += iucv_data_count;
 459                 priv->current_position = priv->buffer;
 460                 if (priv->residual_length == 0){
 461                         /* the whole record has been captured,
 462                          * now add the fence */
 463                         atomic_dec(&priv->receive_ready);
 464                         buffer = priv->buffer + user_data_count;
 465                         memcpy(buffer, FENCE, sizeof(FENCE));
 466                         user_data_count += sizeof(FENCE);
 467                 }
 468                 priv->remaining = user_data_count;
 469         }
 470
 471         return rc;
 472 }
 473
 474
 475 static ssize_t vmlogrdr_read(struct file *filp, char __user *data,
 476                              size_t count, loff_t * ppos)
 477 {
 478         int rc;
 479         struct vmlogrdr_priv_t * priv = filp->private_data;
 480
 481         while (priv->buffer_free) {
 482                 rc = vmlogrdr_receive_data(priv);
 483                 if (rc) {
 484                         rc = wait_event_interruptible(read_wait_queue,
 485                                         atomic_read(&priv->receive_ready));
 486                         if (rc)
 487                                 return rc;
 488                 }
 489         }
 490         /* copy only up to end of record */
 491         if (count > priv->remaining)
 492                 count = priv->remaining;
 493
 494         if (copy_to_user(data, priv->current_position, count))
 495                 return -EFAULT;
 496
 497         *ppos += count;
 498         priv->current_position += count;
 499         priv->remaining -= count;
 500
 501         /* if all data has been transferred, set buffer free */
 502         if (priv->remaining == 0)
 503                 priv->buffer_free = 1;
 504
 505         return count;
 506 }
 507
 508 static ssize_t vmlogrdr_autopurge_store(struct device * dev,
 509                                         struct device_attribute *attr,
 510                                         const char * buf, size_t count)
 511 {
 512         struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 513         ssize_t ret = count;
 514
 515         switch (buf[0]) {
 516         case '0':
 517                 priv->autopurge=0;
 518                 break;
 519         case '1':
 520                 priv->autopurge=1;
 521                 break;
 522         default:
 523                 ret = -EINVAL;
 524         }
 525         return ret;
 526 }
 527
 528
 529 static ssize_t vmlogrdr_autopurge_show(struct device *dev,
 530                                        struct device_attribute *attr,
 531                                        char *buf)
 532 {
 533         struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 534         return sprintf(buf, "%u\n", priv->autopurge);
 535 }
 536
 537
 538 static DEVICE_ATTR(autopurge, 0644, vmlogrdr_autopurge_show,
 539                    vmlogrdr_autopurge_store);
 540
 541
 542 static ssize_t vmlogrdr_purge_store(struct device * dev,
 543                                     struct device_attribute *attr,
 544                                     const char * buf, size_t count)
 545 {
 546
 547         char cp_command[80];
 548         char cp_response[80];
 549         struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 550
 551         if (buf[0] != '1')
 552                 return -EINVAL;
 553
 554         memset(cp_command, 0x00, sizeof(cp_command));
 555         memset(cp_response, 0x00, sizeof(cp_response));
 556
 557         /*
 558          * The recording command needs to be called with option QID
 559          * for guests that have previlege classes A or B.
 560          * Other guests will not recognize the command and we have to
 561          * issue the same command without the QID parameter.
 562          */
 563
 564         if (recording_class_AB)
 565                 snprintf(cp_command, sizeof(cp_command),
 566                          "RECORDING %s PURGE QID * ",
 567                          priv->recording_name);
 568         else
 569                 snprintf(cp_command, sizeof(cp_command),
 570                          "RECORDING %s PURGE ",
 571                          priv->recording_name);
 572
 573         cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 574
 575         return count;
 576 }
 577
 578
 579 static DEVICE_ATTR(purge, 0200, NULL, vmlogrdr_purge_store);
 580
 581
 582 static ssize_t vmlogrdr_autorecording_store(struct device *dev,
 583                                             struct device_attribute *attr,
 584                                             const char *buf, size_t count)
 585 {
 586         struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 587         ssize_t ret = count;
 588
 589         switch (buf[0]) {
 590         case '0':
 591                 priv->autorecording=0;
 592                 break;
 593         case '1':
 594                 priv->autorecording=1;
 595                 break;
 596         default:
 597                 ret = -EINVAL;
 598         }
 599         return ret;
 600 }
 601
 602
 603 static ssize_t vmlogrdr_autorecording_show(struct device *dev,
 604                                            struct device_attribute *attr,
 605                                            char *buf)
 606 {
 607         struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 608         return sprintf(buf, "%u\n", priv->autorecording);
 609 }
 610
 611
 612 static DEVICE_ATTR(autorecording, 0644, vmlogrdr_autorecording_show,
 613                    vmlogrdr_autorecording_store);
 614
 615
 616 static ssize_t vmlogrdr_recording_store(struct device * dev,
 617                                         struct device_attribute *attr,
 618                                         const char * buf, size_t count)
 619 {
 620         struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 621         ssize_t ret;
 622
 623         switch (buf[0]) {
 624         case '0':
 625                 ret = vmlogrdr_recording(priv,0,0);
 626                 break;
 627         case '1':
 628                 ret = vmlogrdr_recording(priv,1,0);
 629                 break;
 630         default:
 631                 ret = -EINVAL;
 632         }
 633         if (ret)
 634                 return ret;
 635         else
 636                 return count;
 637
 638 }
 639
 640
 641 static DEVICE_ATTR(recording, 0200, NULL, vmlogrdr_recording_store);
 642
 643
 644 static ssize_t vmlogrdr_recording_status_show(struct device_driver *driver,
 645                                               char *buf)
 646 {
 647
 648         static const char cp_command[] = "QUERY RECORDING ";
 649         int len;
 650
 651         cpcmd(cp_command, buf, 4096, NULL);
 652         len = strlen(buf);
 653         return len;
 654 }
 655 static DRIVER_ATTR(recording_status, 0444, vmlogrdr_recording_status_show,
 656                    NULL);
 657 static struct attribute *vmlogrdr_drv_attrs[] = {
 658         &driver_attr_recording_status.attr,
 659         NULL,
 660 };
 661 static struct attribute_group vmlogrdr_drv_attr_group = {
 662         .attrs = vmlogrdr_drv_attrs,
 663 };
 664 static const struct attribute_group *vmlogrdr_drv_attr_groups[] = {
 665         &vmlogrdr_drv_attr_group,
 666         NULL,
 667 };
 668
 669 static struct attribute *vmlogrdr_attrs[] = {
 670         &dev_attr_autopurge.attr,
 671         &dev_attr_purge.attr,
 672         &dev_attr_autorecording.attr,
 673         &dev_attr_recording.attr,
 674         NULL,
 675 };
 676 static struct attribute_group vmlogrdr_attr_group = {
 677         .attrs = vmlogrdr_attrs,
 678 };
 679 static const struct attribute_group *vmlogrdr_attr_groups[] = {
 680         &vmlogrdr_attr_group,
 681         NULL,
 682 };
 683
 684 static int vmlogrdr_pm_prepare(struct device *dev)
 685 {
 686         int rc;
 687         struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 688
 689         rc = 0;
 690         if (priv) {
 691                 spin_lock_bh(&priv->priv_lock);
 692                 if (priv->dev_in_use)
 693                         rc = -EBUSY;
 694                 spin_unlock_bh(&priv->priv_lock);
 695         }
 696         if (rc)
 697                 pr_err("vmlogrdr: device %s is busy. Refuse to suspend.\n",
 698                        dev_name(dev));
 699         return rc;
 700 }
 701
 702
 703 static const struct dev_pm_ops vmlogrdr_pm_ops = {
 704         .prepare = vmlogrdr_pm_prepare,
 705 };
 706
 707 static struct class *vmlogrdr_class;
 708 static struct device_driver vmlogrdr_driver = {
 709         .name = "vmlogrdr",
 710         .bus  = &iucv_bus,
 711         .pm = &vmlogrdr_pm_ops,
 712         .groups = vmlogrdr_drv_attr_groups,
 713 };
 714
 715 static int vmlogrdr_register_driver(void)
 716 {
 717         int ret;
 718
 719         /* Register with iucv driver */
 720         ret = iucv_register(&vmlogrdr_iucv_handler, 1);
 721         if (ret)
 722                 goto out;
 723
 724         ret = driver_register(&vmlogrdr_driver);
 725         if (ret)
 726                 goto out_iucv;
 727
 728         vmlogrdr_class = class_create(THIS_MODULE, "vmlogrdr");
 729         if (IS_ERR(vmlogrdr_class)) {
 730                 ret = PTR_ERR(vmlogrdr_class);
 731                 vmlogrdr_class = NULL;
 732                 goto out_driver;
 733         }
 734         return 0;
 735
 736 out_driver:
 737         driver_unregister(&vmlogrdr_driver);
 738 out_iucv:
 739         iucv_unregister(&vmlogrdr_iucv_handler, 1);
 740 out:
 741         return ret;
 742 }
 743
 744
 745 static void vmlogrdr_unregister_driver(void)
 746 {
 747         class_destroy(vmlogrdr_class);
 748         vmlogrdr_class = NULL;
 749         driver_unregister(&vmlogrdr_driver);
 750         iucv_unregister(&vmlogrdr_iucv_handler, 1);
 751 }
 752
 753
 754 static int vmlogrdr_register_device(struct vmlogrdr_priv_t *priv)
 755 {
 756         struct device *dev;
 757         int ret;
 758
 759         dev = kzalloc(sizeof(struct device), GFP_KERNEL);
 760         if (dev) {
 761                 dev_set_name(dev, "%s", priv->internal_name);
 762                 dev->bus = &iucv_bus;
 763                 dev->parent = iucv_root;
 764                 dev->driver = &vmlogrdr_driver;
 765                 dev->groups = vmlogrdr_attr_groups;
 766                 dev_set_drvdata(dev, priv);
 767                 /*
 768                  * The release function could be called after the
 769                  * module has been unloaded. It's _only_ task is to
 770                  * free the struct. Therefore, we specify kfree()
 771                  * directly here. (Probably a little bit obfuscating
 772                  * but legitime ...).
 773                  */
 774                 dev->release = (void (*)(struct device *))kfree;
 775         } else
 776                 return -ENOMEM;
 777         ret = device_register(dev);
 778         if (ret) {
 779                 put_device(dev);
 780                 return ret;
 781         }
 782
 783         priv->class_device = device_create(vmlogrdr_class, dev,
 784                                            MKDEV(vmlogrdr_major,
 785                                                  priv->minor_num),
 786                                            priv, "%s", dev_name(dev));
 787         if (IS_ERR(priv->class_device)) {
 788                 ret = PTR_ERR(priv->class_device);
 789                 priv->class_device=NULL;
 790                 device_unregister(dev);
 791                 return ret;
 792         }
 793         priv->device = dev;
 794         return 0;
 795 }
 796
 797
 798 static int vmlogrdr_unregister_device(struct vmlogrdr_priv_t *priv)
 799 {
 800         device_destroy(vmlogrdr_class, MKDEV(vmlogrdr_major, priv->minor_num));
 801         if (priv->device != NULL) {
 802                 device_unregister(priv->device);
 803                 priv->device=NULL;
 804         }
 805         return 0;
 806 }
 807
 808
 809 static int vmlogrdr_register_cdev(dev_t dev)
 810 {
 811         int rc = 0;
 812         vmlogrdr_cdev = cdev_alloc();
 813         if (!vmlogrdr_cdev) {
 814                 return -ENOMEM;
 815         }
 816         vmlogrdr_cdev->owner = THIS_MODULE;
 817         vmlogrdr_cdev->ops = &vmlogrdr_fops;
 818         vmlogrdr_cdev->dev = dev;
 819         rc = cdev_add(vmlogrdr_cdev, vmlogrdr_cdev->dev, MAXMINOR);
 820         if (!rc)
 821                 return 0;
 822
 823         // cleanup: cdev is not fully registered, no cdev_del here!
 824         kobject_put(&vmlogrdr_cdev->kobj);
 825         vmlogrdr_cdev=NULL;
 826         return rc;
 827 }
 828
 829
 830 static void vmlogrdr_cleanup(void)
 831 {
 832         int i;
 833
 834         if (vmlogrdr_cdev) {
 835                 cdev_del(vmlogrdr_cdev);
 836                 vmlogrdr_cdev=NULL;
 837         }
 838         for (i=0; i < MAXMINOR; ++i ) {
 839                 vmlogrdr_unregister_device(&sys_ser[i]);
 840                 free_page((unsigned long)sys_ser[i].buffer);
 841         }
 842         vmlogrdr_unregister_driver();
 843         if (vmlogrdr_major) {
 844                 unregister_chrdev_region(MKDEV(vmlogrdr_major, 0), MAXMINOR);
 845                 vmlogrdr_major=0;
 846         }
 847 }
 848
 849
 850 static int __init vmlogrdr_init(void)
 851 {
 852         int rc;
 853         int i;
 854         dev_t dev;
 855
 856         if (! MACHINE_IS_VM) {
 857                 pr_err("not running under VM, driver not loaded.\n");
 858                 return -ENODEV;
 859         }
 860
 861         recording_class_AB = vmlogrdr_get_recording_class_AB();
 862
 863         rc = alloc_chrdev_region(&dev, 0, MAXMINOR, "vmlogrdr");
 864         if (rc)
 865                 return rc;
 866         vmlogrdr_major = MAJOR(dev);
 867
 868         rc=vmlogrdr_register_driver();
 869         if (rc)
 870                 goto cleanup;
 871
 872         for (i=0; i < MAXMINOR; ++i ) {
 873                 sys_ser[i].buffer = (char *) get_zeroed_page(GFP_KERNEL);
 874                 if (!sys_ser[i].buffer) {
 875                         rc = -ENOMEM;
 876                         break;
 877                 }
 878                 sys_ser[i].current_position = sys_ser[i].buffer;
 879                 rc=vmlogrdr_register_device(&sys_ser[i]);
 880                 if (rc)
 881                         break;
 882         }
 883         if (rc)
 884                 goto cleanup;
 885
 886         rc = vmlogrdr_register_cdev(dev);
 887         if (rc)
 888                 goto cleanup;
 889         return 0;
 890
 891 cleanup:
 892         vmlogrdr_cleanup();
 893         return rc;
 894 }
 895
 896
 897 static void __exit vmlogrdr_exit(void)
 898 {
 899         vmlogrdr_cleanup();
 900         return;
 901 }
 902
 903
 904 module_init(vmlogrdr_init);
 905 module_exit(vmlogrdr_exit);