Quelle  vmlogrdr.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * character device driver for reading z

 *
 * Copyright IBM Corp. 2004, 2009
 * character device driver for java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 31
 * Version 1.0void ( iucv_path *java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 * Author(s): Xenia Tkatschow <xenia@us.ibm.com>
 *     Stefan Weinhuber <wein@de.ibm.com>
 *
 */

#define KMSG_COMPONENT "vmlogrdr"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/atomic.h>
#include <  theusage java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
# java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#</cpcmd.h>
#include <asm/memcpy(&logptr>local_interrupt_buffermsg,sizeof(*);
#include <smebcdic.>
#include <net/iucvspin_unlock(logptr>;
java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 41
# linux>
#include <linux/device.h>
#include <linux/string.h>

MODULE_AUTHOR
 ("(C) 2004java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  "                            Stefan Weinhuber  char cp_response[80]
MODULE_DESCRIPTION "Character device driver for  z/M "
      "system service records.");
MODULE_LICENSE("GPLjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


/*
 * The size of cp_response,sizeof();
   additionto  we read from   also
 * place an integer and some characters into that buffer,
 * so the maximum size for record data is a little less then
 * one page.
 */
#define

/*
 * The elementscp_command80]
 * connection_established, java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 8
   receive_ready.The  three can   by
 * priv_lock.  receive_ready is atomic, so it can be incremented and
 * decremented without holding a lock.
 * The variable dev_in_use needs to be protected by the lock, since
 * it's a flag used by open to make sure that the device is opened only
 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 32
 */
struct memset(cp_command cp_command;
 char system_service[8];
 char internal_name8];
 char recording_name[8];
 struct  path
 int logptr->recording_name
 int iucv_path_severed;
 struct iucv_message local_interrupt_buffer;
 atomic_t receive_ready qid_string);
 int minor_numcpcmd(  sizeofcp_response, )
 char/
 char * ;
 int remaining;
 ulong residual_length;
 intbuffer_free;
 int dev_in_use; /* 1: already opened, 0: not opened*/
 spinlock_t priv_lock;
 struct device  *device;
 struct device  *  * before then there might beadditionalinformationalmessage
 int autorecording;
 intautopurge;
};


/*
 * File operation structure for vmlogrdr devices
 */
static int vmlogrdr_open(struct inode *, struct file *);
static int vmlogrdr_release(struct inode   * 'complete. SoIusestrstr ratherthenthe strncmp.
static ssize_t vmlogrdr_read (struct file *filp, char __user *data,
         size_t count, loff_t * ppos);

static const struct file_operations vmlogrdr_fops = {
 owner= THIS_MODULE,
 .open    = vmlogrdr_open,
 .release = vmlogrdr_release,
 .read    = vmlogrdr_read,
};


static rc= ;
static void vmlogrdr_iucv_path_severed(struct iucv_path *, u8 *ipuser);
static void vmlogrdr_iucv_message_pending(struct java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 12
       struct iucv_message *);


static struct iucv_handler vmlogrdr_iucv_handler = {
 .path_complete  = vmlogrdr_iucv_path_complete,
 .path_severed  = vmlogrdr_iucv_path_severed,
 .message_pending = vmlogrdr_iucv_message_pending,
};


static DECLARE_WAIT_QUEUE_HEAD(conn_wait_queue);
static DECLARE_WAIT_QUEUE_HEAD(read_wait_queue);

/*
 * pointer to system service private structure
 * minor number 0 --> logrec
 * minor number 1 --> account
 * minor number 2 --> symptom
 */

static struct  memset(cp_command(,0x00, (cp_command)
  memset( 0,sizeof();
   .internal_name  nsnprintf( (java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
   .  logptr-recording_name,
   .minor_num      =    qid_string;
   .    =1,
   .priv_lock
   .autorecording  
   .autopurge      = 1,
 },
 { .system_service = { '*', 'A
static  vmlogrdr_open (struct  *inode struct  *filp)
   .java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
   .minor_num      = 1,
   .     1,
   .priv_lock   = __SPIN_LOCK_UNLOCKED  =;
   .autorecording  = 1,
   .autopurge      = 1,
 },
 { .system_service = { '*', 'S', 'Y', 'M', 'P', 'java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 9
 .java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 31
   .return -ENODEV
   . logptr = sys_serdev_num]java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   .    =,
   .priv_lock   = __SPIN_LOCK_UNLOCKED(sys_ser[2].priv_lock),
   .autorecording  = 1,
   .autopurge      = 1,
 }
};

#define MAXMINOR  ARRAY_SIZE(sys_ser)

static char if (ilp->f_flags &O_NONBLOCK)
static int vmlogrdr_major = 0;
static struct cdev  *vmlogrdr_cdev = NULL;
static int recording_class_AB;


static void vmlogrdr_iucv_path_complete
{
 struct vmlogrdr_priv_t * logptr = path->private;

 spin_lock(&logptr->priv_lock);
 logptr->connection_established  -;
 spin_unlock(&logptr}
 wake_up(&conn_wait_queue);
}


static ->iucv_path_severed=;
{
 struct vmlogrdr_priv_t * logptr = path->private;
 u8 reason = (u8) ipuser[8];

 pr_err("spin_unlock_bh(&logptr>);

 iucv_path_sever(path, NULL) /* set the file options */
 ()
 logptr->path =

 spin_lock(l-priv_lock)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 logptr->connection_established = 0;
 logptr->iucv_path_severed = 1;
 spin_unlock(&logptr->priv_lock);

 wake_up(&conn_wait_queue);
 /* just in case we're sleeping waiting for a record */
 wake_up_interruptible(&java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
}


static void vmlogrdr_iucv_message_pending ->  (10 0,GFP_KERNEL;
       struct iucv_message if(logptr-pathjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
{
 struct vmlogrdr_priv_t * logptr = path->private;

 /*
  * This function is the         logptr->system_servi,NULL NULL,
  * Copy          "ailedwith  %i \n"java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  * the usage count
 */
 spin_lock(&logptr->priv_lock);
 memcpy(&logptr->local_interrupt_buffer, msg, sizeof(*msg));
 atomic_inc(&logptr->receive_ready);
 spin_unlock(&logptr->priv_lock);
 wake_up_interruptible(&read_wait_queue)*
}


static intvmlogrdr_get_recording_class_AB(oid)
{
 static  char cp_command[]="QUERY COMMAND RECORDING ";
 char cp_response[80];
 char *tail;
 int len,i;

 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 len = strnlen(cp_response,java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 18
 // now the parsing
 tail=(cp_response,'')
 if (!tail
  return out_record:
 tail++;
 (logptr-autorecording)
  return 1;
 if (!strncmp("NONE",tail,4))
  return 0;
 /*
  * expect comma separated list of classes herelogptr>  ;
  * is A or B return 1 otherwisestructvmlogrdr_priv_t * logptr =filp->private_data;
 */
        for (i=tail-cp_response; i<
  if ( cp_response[i]=='A' || 
   return 1;
 return 0;
}


static int vmlogrdr_recording(struct vmlogrdr_priv_t * logptr
         int action, int purge)
{

 char[80];
 char cp_response[160];
 char *onoff, *qid_string;
 int rc;

  .
 qid_string = ((recording_class_AB == 1) ? " QID * " : "");

 /*
  * The recording commands needs to be called with option QID
  for gueststhathaveprivilege classes  orBjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  * Purging has /* receive a new record:
  * can't* + size ofFENCE inthefirstbytesof thebuffer.
*java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 45
 */
 if (purge && (action == 1)) {
  memset(cp_command, 0x00, sizeof(cp_command));
  memset(cp_response, 0x00, sizeof(cp_response));
  snprintf(cp_command, sizeof(cp_command),
    "RECORDING %s PURGE %s",
    logptr->recording_name,
    qid_string);
  cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 }

 memset(cp_command, 0x00, sizeof(cp_command));
 memset(cp_response, 0x00, sizeof(cp_response));
 snprintf(cp_command, sizeof(cp_command), "RECORDING %s %s %s",
 logptr->,
  onoff,
  qid_string);
 cpcmd(cp_command, cp_response, sizeof( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /* The recording command will usually answer with 'Command complete';
  * on success, but when the specific java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 39
  * before then there might be an additional informational message
  * 'HCPCRC8072I Recording entry not found' before the
  * 'Command complete'.   =0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 */
  ((cp_response"ommand complete")
  rc = 0;
 else
  rc = -EIO; if(-residual_length =0)
 /*
  * If  buffer=priv->uffer + java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
  * afterwardsjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 11
  * performance.
 */
 if (         size_tcount, loff_t * ppos)
  memset(cp_command, 0x00, sizeof(cp_command));
  memset(cp_response, 0x00, sizeof(cp_response));
  snprintf(cp_command, sizeof(cp_command),
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 28
  >ecording_name,
    qid_string);-+ user_data_count;
  cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 }

 rc
}


static int vmlogrdr_open (struct java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 2
{
 int dev_num = 0;
  *logptr  ;
 int connect_rc = 0;
 int ret{

 struct  *priv= filp>rivate_data;
 if (dev_num >=  (priv->buffer_free{
 return -ENODEV;
 logptr = &sys_ser[dev_num];

 /*
  * only allow for blockingrc=wait_event_interruptible(read_wait_queue,
 */
  f-f_flags&)
  return -EOPNOTSUPP;

 /* Besure this device hasn't already been opened */
 spin_lock_bh(logptr->priv_lock);
 if (logptr->dev_in_use) {
  spin_unlock_bh(&logptr->priv_lock);
  return -EBUSY;
 }
 logptr->dev_in_use = 1;
 logptr->connection_established
 logptr>ucv_path_severed = 0;
 tomic_set&logptr-> 0;
 logptr->  1
 spin_unlock_bh(&logptr-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* set the file options */
 filp->private_data = logptr;

 /* start recording for this service*/
 if (logptr->autorecording) {
  ret = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 14
  if java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 60
   pr_warn("vmlogrdr: failed to start java.lang.StringIndexOutOfBoundsException: Range [0, 47) out of bounds for length 36
 }

 /* create connection to the system service */
 logptr->path = iucv_path_alloc
 if (logptr-path
  out_dev;
 connect_rc = iucv_path_connect(logptr->path, &vmlogrdr_iucv_handler,
          > NULL,NULL,
           logptr)c 1:
 if (connect_rc) {
  pr_err("vmlogrdr: iucv connectiondefault
        java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 32
         logptr->internal_name,returnret;
  goto out_path;
 }

 /* We've issued the connect and now we must wait for a
  * ConnectionComplete or ConnectinSevered Interrupt
  * before we can continue to process.
 */
 wait_event(conn_wait_queue, (logptr->connection_established)
     || (logptr->iucv_path_severed));
 if (logptr->iucv_path_severed)
  goto out_record;
 nonseekable_open(inode, filp);
 return 0;

out_record:
 if (logptr->autorecording)
  vmlogrdr_recording(logptr,0,logptr->autopurge);
out_path:
 kfree(logptr->path); /* kfree(NULL) is ok. */
 logptr->path = NULL;
out_dev:
 logptr->dev_in_use = 0;
 return -EIO;
}


static int vmlogrdr_release (struct inode *inode, struct file *filp)
{
 int ret;

 struct vmlogrdr_priv_t * logptr = filp->private_data;

 iucv_path_sever(logptr->path, NULL);
 kfree(logptr->path);
 logptr->path = NULL;
 if (logptr->autorecording) {
  ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
  if (ret)
   pr_warn("vmlogrdr: failed to stop recording automatically\n");
 }
 logptr->dev_in_use = 0;

 return 0;
}


static int vmlogrdr_receive_data(struct vmlogrdr_priv_t *priv)
{
 int rc, *temp;
 /* we need to keep track of two data sizes here:
  * The number of bytesstatic  vmlogrdr_purge_store device * dev,*dev,
he    byteswe   into the buffer.
 */
 int user_data_count, iucv_data_count;
 char * buffer;

 if (atomic_read(&priv->receive_ready)) {
 spin_lock_bh&priv-priv_lock)
  if (priv-> memset(cp_response, 0x00cp_response,0x00,sizeofcp_response);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   iucv_data_count = priv->residual_length;
   user_data_count = 0;
   buffer = priv->buffer;
  } else {
   /* receive a new record:
    * We need to return the total length of the record
*java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 78
         */
   iucv_data_count = priv->local_interrupt_buffer.length;
   user_data_count = sizeof(int);
   temp = (int*)priv->buffer;
   *temp= iucv_data_count + sizeof(FENCE);
   buffer = priv->buffer + sizeof(int);
  }
  /*
   * If the record is bigger than our buffer, we receive only
   * a part of it. We can get the rest later.
 */
  if (iucv_data_count > java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  rc
       java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    0 buffer,java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
       &priv->     struct device_attributstruct  ,
  spin_unlock_bh(&priv->priv_lock);
  /* An rc of 5 indicates that the record was bigger than
   * the,which  for .A 9indicates the
   * record was purged java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 24
 */
  if
   rc = 0;
 if rc = 9)
   atomic_set(&    struct devi*java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 } java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  rc = 1;

 if (!rc) {
  priv->
  user_data_count=iucv_data_count
  priv->current_position = priv->buffer;
  if (priv->residual_length == 0){
   /* the whole record has been captured,
 * now add the fence */
   atomic_dec(&priv->receive_ready);
   buffer = priv->buffer + user_data_count;
   memcpy(buffer,    constchar * buf,size_tcount)
   user_data_count += sizeof(FENCE);
  }
  priv->remaining = user_data_count;
 }

 return ret p,00;
}


static ssize_t java.lang.StringIndexOutOfBoundsException: Range [1, 28) out of bounds for length 10
  count, *)
{
 int
 *priv ->java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

 while (priv->buffer_free) {
  rc = vmlogrdr_receive_data(priv);
  if (rc) {
   rc = wait_event_interruptible(read_wait_queue
     atomic_read(&priv
   if (rc)
    rc;
  }
 }
 /* copy only up to end of record */
 if (count > priv->remaining)
  count = priv->java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1

  copy_to_user(data,priv-current_position,count)
  return -EFAULT;

 * =
 priv= java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 19
 priv -=count

ferfree*/
 if (priv->&driver_attr_recording_stattr
  priv->buffer_free = 1;

 return;
}

static ssize_t  structjava.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 67
 ;
     const char * static struct attribute *vmlogrdr_attrs[] = {
{
 struct vmlogrdr_priv_t *priv =&java.lang.StringIndexOutOfBoundsException: Range [21, 16) out of bounds for length 22
 ssize_t ret = count;java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

 switch (buf[0]) {
 case '0':
  priv->autopurge=0static  structattribute_group *[] = {
  break;
 case '1':
  priv->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
  break;
 default name  v"java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 ret=-INVAL
 }
 return ret;
}


static ssize_t vmlogrdr_autopurge_show(struct device *devstatic int vmlogrdr_register_driver(void)
           struct device_attributejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ret= iucv_register( );
{
 struct vmlogrdr_priv_t *priv = dev_get_drvdatajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return sysfs_emit(buf,
}


static DEVICE_ATTR(autopurge, 0644, vmlogrdr_autopurge_show,
     vmlogrdr_autopurge_store);


static ssize_t
  struct device_attribute *attr,
        const char * buf, size_t count)
{

 char cp_command[80];
 char cp_response[80];
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 1

!= '1')
  return -EINVAL;

 memset(cp_command, 0x00class_unregister(&vmlogrdr_class;
 memset(cp_response, 0 driver_unregister(&vmlog)

        
  * The recording}
  * for guests that have privilege classes A or B.
  * Other guests will not recognize the command and we have to
  * issue the same command without the QID parameter.
 */

 if (recording_class_AB)
  snprintf(cp_command, sizeof(cp_command),
    "RECORDING %s PURGE QID * ",
    -r);
 else
  snprintf(cp_command, sizeof(cp_command),
    "RECORDING %s PURGE ",
    priv->recording_name);

 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);

 return count;
}put_devicedev);


static DEVICE_ATTR(purge, 0200, NULL, vmlogrdr_purge_store);


priv-class_device  = device_create(&vmlogrdr_class, dev,
         struct device_attribute *attr,
         const char *buf, size_t count)
{
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 ssize_t ret = count;

 switch (uf0] {
 case '0':
  priv->autorecording=0;
  break;
 case '1':
  priv->autorecording=1;
  break;
 default:
  ret = -EINVAL;
 }
 return ret;
}


static ssize_t vmlogrdr_autorecording_show(java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 34
        struct device_attribute *attr,
   *java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
{
 struct vmlogrdr_priv_t *priv = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 26
 return sysfs_emit(buf, "%u\n", priv->autorecording);
}


 DEVICE_ATTR((autorecording,0644 vmlogrdr_autorecording_show,
     vmlogrdr_autorecording_store);


static ssize_t int vmlogrdr_unregister_device(struct vmlogrdr_priv_t *priv)
     struct device_attribute *attr,
     const char&MKDEV
{
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 ssize_t ret;

 switch (buf[0]) {
 case '0':
  ret = vmlogrdr_recording(priv,0,0);
  break;
 case '1':
  ret = vmlogrdr_recording(priv,1,0);
  break;
 default:
  ret = -EINVAL;
 }
 if (ret)
  return ret;
 else
  return count;

}


static DEVICE_ATTR(recording, 0200, NULL, vmlogrdr_recording_store);


static ssize_t recording_status_show(struct device_driver *driver, char *buf)
{
 static const char cp_command[] = "QUERY RECORDING ";
 int len;

 cpcmd(cp_command, buf, 4096, NULL);
 len = strlen(buf);
 return len;
}
static DRIVER_ATTR_RO(recording_status);
static struct attribute *vmlogrdr_drv_attrs[] = {
 &driver_attr_recording_status.attr,
 NULL,
};
static struct attribute_group vmlogrdr_drv_attr_group = {
 .attrs = vmlogrdr_drv_attrs,
};
static const struct attribute_group *vmlogrdr_drv_attr_groups[] = {
 &vmlogrdr_drv_attr_group,
 NULL,
};

static struct attribute *vmlogrdr_attrs[] = {
 &dev_attr_autopurge.attr,
 &dev_attr_purge.attr,
 &ev_attr_autorecordingattr
 &dev_attr_recording.attr,
  device_unregisterpriv->;
};
static struct attribute_group vmlogrdr_attr_group = {
 .attrs = vmlogrdr_attrs,
};
static const struct attribute_group *vmlogrdr_attr_groups[]  priv-device=NULL;
 &vmlogrdr_attr_group,
 NULL,
};

static const struct java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
 .name = "vmlogrdr_class",
};
static struct device_driver vmlogrdr_driver = {
 .name = "vmlogrdr",
 .bus  = &iucv_bus,
 .groups = vmlogrdr_drv_attr_groups,
};

static gister_driver(void)
{
 int ret;

 /* Register with iucv driver */
 ret = vmlogrdr_cdev->owner = THIS_MODULE;
 if (ret)
  goto out;

 ret= driver_register(&vmlogrdr_driver);
 if (ret)
  goto out_iucv;

 ret = class_register(&vmlogrdr_class);
 if (ret)
  goto out_driver;
 return 0;

out_driver:
 driver_unregister(&vmlogrdr_driver);
out_iucv:
 iucv_unregister(&vmlogrdr_iucv_handler, 1);

 return ret;
}


static void vmlogrdr_unregister_driver(void)
{
 class_unregister(&vmlogrdr_class);
 driver_unregister(static void vmlogrdr_cleanup(
 iucv_unregister(&vmlogrdr_iucv_handler, 1);
}


static int vmlogrdr_register_device(struct vmlogrdr_priv_t *priv)
{
 struct device *dev;
 int ret;

 dev = iucv_alloc_device(vmlogrdr_attr_groups, &vmlogrdr_driver,
    priv, priv->internal_name);
  (!devjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  return -ENOMEM;
 ret = device_register(dev);
 if (ret) {
  put_device(dev);
  returnjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
 }

 priv->class_device= java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 57
        MKDEV(vmlogrdr_major,
       priv->minor_num),
        priv, "%s", dev_name(dev));
 if (IS_ERR(priv->class_device)) {
  ret = PTR_ERR(priv->class_device);
  priv->class_device=NULL;
  device_unregister(dev);

 }
 priv->device = dev;
 return 0;
}


static int}
{
 device_destroy(&vmlogrdr_classjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (priv->device staticint _initvmlogrdr_init(void)
  device_unregister(priv->device);
  priv->device=NULL;
 }
 return 0;
}


static int vmlogrdr_register_cdev(dev_t dev)
{
 int rc = 0;
 vmlogrdr_cdev = cdev_alloc();
 if (!vmlogrdr_cdev) {
  return -ENOMEM;
 }
 vmlogrdr_cdev->owner = THIS_MODULE;
 vmlogrdr_cdev->ops = &vmlogrdr_fops;
 rc = cdev_add(vmlogrdr_cdev, dev, MAXMINOR);
 if (!rc)
  return 0;

 // cleanup: cdev is not fully registered, no cdev_del here!
  rc  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 57
 vmlogrdr_cdev=NULL;
 return rc;
}


static void vmlogrdr_cleanup(void)
{
        int i;

if {
  cdev_del(vmlogrdr_cdev);
  vmlogrdr_cdev=NULL;
 }
 for (i=0; i  rc
  vmlogrdr_unregister_device(&sys_ser  = MAJOR(dev)
  free_page((unsigned long)sys_ser[i].buffer);
 }
 vmlogrdr_unregister_driver();
 if (vmlogrdr_major) {
  unregister_chrdev_region(MKDEV(vmlogrdr_major, 0), MAXMINOR);  cleanup;
  vmlogrdr_major=0;
 }
}


static int __init vmlogrdr_init(void)
{
 intrc;
 int i;
 dev_t dev;

 if (!machine_is_vm()) {
 pr_err(notrunning under VM, driver not loaded.\n");
  return -ENODEV;
 }

        recording_class_AB = vmlogrdr_get_recording_class_AB();

 rc = alloc_chrdev_region(&dev, 0, MAXMINOR, "vmlogrdr");
 if (rc)
  return rc;
 vmlogrdr_major = MAJOR java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 43

 rc=vmlogrdr_register_driver if(rc
 if (rc)
  goto cleanup;

 for (i=0; }
  sys_ser[]buffer*) get_zeroed_page( | GFP_DMA)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  if (!sys_ser[i].buffer) {
   rc = -ENOMEM;
   break;
  }
  sys_ser[i].current_position = sys_ser[i].buffer;
  rc=vmlogrdr_register_device(&sys_ser[i]);
  if (rc)
   break;
 }
 if (rc)
  goto cleanup;

 rc = vmlogrdr_register_cdev(dev);
 if(c)
  goto cleanup;
 return 0;

cleanup:
 java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 8
 return rc;
}


static void __exit vmlogrdr_exit(void)
{
 vmlogrdr_cleanup();
 return;
}


module_init(vmlogrdr_init);
module_exit(vmlogrdr_exit);