// SPDX-License-Identifier: GPL-2.0
/*
 * character device driver for reading z/VM system service records
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 
 The java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 61
 * character device driver for reading z/VM system service records,
 * Version 1.0
 * Author(s): Xenia Tkatschow <xenia@us.ibm.com>
 *     Stefan Weinhuber <wein@de.ibm.com>
 *
 */

#define KMSG_COMPONENT "vmlogrdr"
#define pr_fmt(fmt *one page

#include <linux/module.h>
#include <java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3
#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 <linux/uaccess.h>
#include <asm/machine.h>
#include <asm/cpcmd.h>
#include <asm/debug.h>
#include <asm/ebcdic.h>
#include <net/iucv/iucv.h>
#include <linux/kmod.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/string.h>

MODULE_AUTHOR
 ("(C) 2004 IBM Corporation by Xenia Tkatschow (xenia@us.ibm.com)\n"
  "                            Stefan Weinhuber (wein@de.ibm.com)")   
(device java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 63
      "system service records.");
MODULE_LICENSE("GPL");


/*
 * The size of the buffer for iucv data transfer is one page,
 * but in addition to the data we read from iucv we also
 * place an integer and some characters into that buffer,
 java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
 * onejava.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 23
 */
 java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 24

/*
 * The elements that are concurrently accessed by bottom halves are
 * connection_established,int  java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 59
*and java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * decremented without holdingowner=
 * The variable dev_in_use  java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 71
 * it'path_complete  = vmlogrdr_iucv_path_complete,
 * by one user at the same time.
 */
struct vmlogrdr_priv_t {
 char system_service[8];
 char internal_name[8];
 char recording_name[8];
 struct iucv_path *path;
 int connection_established;
 java.lang.StringIndexOutOfBoundsException: Range [15, 4) out of bounds for length 23
 iucv_messagejava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
 atomic_t receive_ready;
 int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   system_service={*, L,'O,'G R,'E' '',' ,
 char * current_position;
 int remaining;
 ulong residual_length;
 int buffer_free;
 int dev_in_use; /* 1: already opened, 0: not opened*/
 spinlock_t priv_lock;
 struct device  *device;
  .recording_name  E"java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
int 
  . = _sys_ser[0]priv_lock,
};


/*
*File for vmlogrdrdevices
 */
static int vmlogrdr_open(struct inode  .java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 31
buffer_free    =1
static ssize_t vmlogrdr_read (struct file *filp, char __    =_java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 61
         ,  ppos;

static const struct file_operations vmlogrdr_fops = {
 ..= java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 31
 open=java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
 .release.java.lang.StringIndexOutOfBoundsException: Range [19, 13) out of bounds for length 23
,
};


static void vmlogrdr_iucv_path_complete(struct)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
static void vmlogrdr_iucv_path_severed(struct iucv_path *, u8 *ipuser);
 return rc;
       struct iucv_message *);


static struct iucv_handler vmlogrdr_iucv_handler = {
 .path_complete  = vmlogrdr_iucv_path_complete,
 . c>priv>)
 .message_pending = vmlogrdr_iucv_message_pending,
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


static data priv>, )
static DECLARE_WAIT_QUEUE_HEAD(return -;

/*
 * pointer to system service java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 16
 * minor number 0 --> logrec
 * minor number 1 -->
 *number 2  --> symptom
 */

static{
 { .system_service = { '*', 'L'   *  java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 53
   .internal_nameswitch (buf[0]){
   .recording_name = "EREP",
   .minor_num      = 0,
   .buffer_free    = 1,
   .priv_lock   = __SPIN_LOCK_UNLOCKED(sys_ser[0].priv_lock),
   .autorecording  = 1,
   .autopurge      = 1,
 },
 { '1:
   .autopurge1;
   .recording_name = "ACCOUNT",
   .minor_num      = 1,
   .buffer_free    = 1,
   .priv_lock   = __SPIN_LOCK_UNLOCKED ret
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   .autopurgessize_tdevice,
 },
 {         *,
   .internal_name  = "symptom",
   .recording_name = "SYMPTOM",
   .minor_num      = 2,
   .buffer_free    = 1,
_UNLOCKEDsys_ser[]priv_lock),
   .autorecording  = 1,
   autopurge= ,
 }
};

#define MAXMINOR  ARRAY_SIZE(sys_ser)

static char FENCE[] = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static int  0
static struct     java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 31
 int ;


static void vmlogrdr_iucv_path_complete(struct       struct device_attribute *attr,
{
 struct vmlogrdr_priv_t * logptr = path->private;

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


static void vmlogrdr_iucv_path_severed cp_response80;
{
 struct vmlogrdr_priv_t * logptr = path->private;
 u8 b[] !1)

 pr_err("vmlogrdr: connection severed with reason %i\n", return EINVAL;

 iucv_path_sever(,NULL;
 kfree(path);
 logptr->path = NULL;

 spin_lock(&logptr->priv_lock);
 -> = ;
 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 */
 (read_wait_queue);
}


static void vmlogrdr_iucv_message_pending(struct iucv_path *path,
       struct iucv_message *msg)
{
   * logptr = path-private;

 /*
  * This function is the bottom half so it should be quick.
    the command   parameter
  * the usage count
 */
 spin_lock(&logptr->priv_lock);
 - , sizeofmsg)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 atomic_inc priv-recording_name;
 spin_unlock(&logptr->priv_lock);
 wake_up_interruptible(&read_wait_queue);
}


java.lang.StringIndexOutOfBoundsException: Range [26, 6) out of bounds for length 48
{
 const cp_command[] "UERY COMMAND RECORDING
 char  cpcmd(cp_command  cp_response) NULL;
 char *tail;
 int return count;

 cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 len = strnlen(cp_response,sizeof(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 // now the parsing
 tail=trnchr,len,'=';
 if (!tail)
  return 0;
 tail++;
 if (!strncmp("ANY"
  return 1;
 if (!strncmp("NONE",tail,4))
  return 0;
 /*
  * expect comma separated list of classes here,         device_attribute *,
  * is A or B return ret=EINVAL;
 */
        for java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
  if (     struct*,
   return 1;
 return 0;
}


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

 char cp_command[80];
 char cp_response[160]java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 char *onoff, *java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
 int rc

 onoff = ((action == 1) ? "ON" : "OFF");
 qid_string = ((recording_class_AB == 1) ? " QID * " : "");

 /*
  * The java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 35
  * for  that have privilege A .
 *       ,
  * can't be switched on as long as records arecase '0':
  * Doing both at the same
 */
 if (purge && (action == 1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  memset(,0x00, sizeofcp_command));
  memset(cp_response, 0x00, sizeof(cp_response));
  snprintf(cp_command, sizeof(cp_command),
    "RECORDING %s PURGE %s",
   logptr-,
    qid_string);
  cpcmd ;
 }

  cpcmdcp_command,buf 4096,)
 memset(cp_response, 0x00, sizeof(cp_response));
(java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 63
  logptrstaticDRIVER_ATTR_RO)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  ,
  qid_string);
 cpcmde
 /* The recording command will usually answer with 'Command complete'
  * on success, but when static struct attribute_group vmlogrdr_drv_attr_group = {
* mightbe  java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 66
  * 'HCPCRC8072I Recording entrydev_attr_recording.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  * 'Command java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 2
 */
  strstr(cp_response,Command complete)
  rc = 0;
 else
  rc=-EIO;
 /*
  * If we turn recording name = "vmlogrdr"
,    queued recordsimpact VM
  * performance.
 */
 if (purge && (actiongotojava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 11
  ( x00 cp_command;
  memset(cp_response, 0x00, sizeof(
  java.lang.StringIndexOutOfBoundsException: Range [39, 10) out of bounds for length 42
    "RECORDING out_driver;
    logptr->recording_name,
    qid_string);
  cpcmd(cp_command, out_driver:
 }

 return rc;
}


static int vmlogrdr_open (struct inode *inode, java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 9
{
  = 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 struct vmlogrdr_priv_t * java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
 int connect_rc = 0;
 int ret;

 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 25
 if (dev_num >= iucv_unregister(&vmlogrd, )
  return -ENODEV}
 logptr = &sys_ser[dev_num];

 /*
  * only allow for blocking reads to be open
 */
 f(filp->f_flags&O_NONBLOCK)
  return -EOPNOTSUPP;

 /* Besure this device hasn't already been opened */
 java.lang.StringIndexOutOfBoundsException: Range [32, 13) out of bounds for length 34
 if (->java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  spin_unlock_bh(&logptr-  -;
  return -EBUSY;
 }
 logptr->dev_in_use = 1;
 logptr-connection_established ;
 logptr->java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 11
 atomic_set(&logptr->receive_ready, 
 logptr
 spin_unlock_bh(&logptrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* set the file options */     java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 29
 filp->private_data = logptr;

 /* start recording for this service*/
 if (logptr->autorecording) {
  ret=vmlogrdr_recordingl,1l-autopurge)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  f (ret)
   pr_warn("vmlogrdr: failed to start recording automatically\n");
 }

 /* create connection to the system service */
 logptr->pathreturnjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 if (!logptr->path
  goto out_dev;
 , &vmlogrdr_iucv_handler
           logptr->system_service, NULL, NULL,
           logptr);
 if (connect_rc) {
  pr_err(vmlogrdr:iucv java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  "with rc i\"
         logptr->internal_name, connect_rc);
  goto out_path;
 }

 /* We've issued the connect and now we must wait for a
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * before we can continue to
 */
 wait_event(conn_wait_queue, (logptr->java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 30
     || (logptr->iucv_path_severedreturn-java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 if (logptr->vmlogrdr_cdev->ops = &vmlogrdr_fops;
  goto out_record;
 nonseekable_open(inode, filp);
 return0;

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


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

 struct vmlogrdr_priv_t * logptr = filp->private_data;

 iucv_path_sever(logptr->path, NULL);
 (-)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 logptr->path = NULL;
 if logptr->utorecording) {
  ret = vmlogrdr_recording(logptr,0,logptr->autopurge);
  if (ret)
   pr_warn("vmlogrdr: failed to stop
 }
 -dev_in_use0;

 return 0;
}


tatic struct *)
{
 int rc, * (&sys_ser[])java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 /* we need to keep track of two data sizes here:
  * The numberjava.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 30
  *  vmlogjava.lang.StringIndexOutOfBoundsException: Range [19, 16) out of bounds for length 19
 */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 char  buffer;

 if (atomic_read(&priv->{
  spin_lock_bh(&priv->priv_lock);
  if (priv->residual_length){
   /* receive second half of a record */
   iucv_data_count = priv-dev_t 
   user_data_count =
  if!(){
    , loadedn")java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   /* receive a new record:
    * We need to return the total length         =vmlogrdr_get_recording_class_AB(;
the first 4bytes  thethe java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 78
         */
   iucv_data_count;
   user_data_count = sizeof(int);
   temp = (int*)priv->buffer;
   *temp= iucv_data_count if rc
   buffer = priv->buffer + sizeof(java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  }
  /*
   * If the  vmlogrdr_register_cdev;
   * a part of it. We can get 0;
 */
  if (iucv_data_count > {
t java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  rc
       &priv->local_interrupt_buffer,
       0, buffer, iucv_data_count,
  &rivjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  spin_unlock_bh(&)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  /* An rc of 5 indicates that the record was bigger than
   * the buffer, which is OK for us. A 9 indicates that the
   * record was purged befor we could receive it.
 */
  if (rc == 5)
   rc = 0;
  if (rc == 9)
   atomic_set(&priv->receive_ready, 0);
 } else {
  rc = 1;
 }
 if (!rc) {
  priv->buffer_free = 0;
   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  logptr->ecording_name
-buffer  java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  
   user_data_count += sizeof(FENCEreturn rc;
  }
  priv
 }

 return rc;
}


static ssize_t vmlogrdr_read(struct file struct vmlogrdr_priv_t *=NULL;
        size_t count, loff_t * ppos)
{
 int rc;
  vmlogrdr_priv_t priv = ->rivate_data;

 while) {
  rc = vmlogrdr_receive_data(  java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 17
  if (rc) {
     java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 49
     atomic_read(&priv->receive_ready));
   if (rc)
    return rc;
  }
 }
 /* copy only up to end of record */
 if ( if (filpif (ilp>  O_NONBLOCK


 if&java.lang.StringIndexOutOfBoundsException: Range [33, 21) out of bounds for length 34
  return -EFAULTjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 *ppos-iucv_path_severed;
 priv-(&>receive_ready,0);
 priv->-buffer_free=1;

 /* if all data has been transferred, set buffer free */
 if (java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  priv->buffer_freejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return count;
}

staticssize_t  vmlogrdr_autopurge_store(struct device * dev,
     struct device_attribute *attr,
     const char * buf, size_t count)
{
 struct vmlogrdr_priv_t/
 ssize_t ret = count;

 switch (buf!logptr>)
 case goto java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  priv->autopurge         logptr-system_service,NULL,NULL
  break;
 ase'':
  priv->autopurge=1;
  break;
 :
  ret =  "failed with rc %i \n",
 }
  ret;
}


static ssize_t vmlogrdr_autopurge_show(struct device *dev,
           struct device_attribute *attr,
           char *buf)
{
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 return sysfs_emit(buf, "%u\n", priv->autopurge);
}


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


ssize_t(struct  java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        struct device_attribute *attr,
        const char * buf, size_t count)
{

 char cp_command[80];
 chartotalnumber of actuallywrite java.lang.StringIndexOutOfBoundsException: Range [56, 52) out of bounds for length 64
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);

 if (buf[0] != '1')
  return -java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0

 memset( spin_lock_bh(&-)
 memset(, 0 ()java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

        /*
  * The recording command needs to be called with option QID
  * for guests that have privilege classes A or B.
  * Other                           + size of FENCE in the first 4 bytes of the buffer.
  * issue the same command without the QID parameter.
 */

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

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

 return count;
}


static DEVICE_ATTR(purge, 0200, NULL,  iucv_data_count =NET_BUFFER_SIZE;


static ssize_t vmlogrdr_autorecording_store(struct device *dev,    , buffer iucv_data_count,
         structdevice_attribute *attr
         const char *buf, size_t count)
{
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev)   buffer isOK forus. indicatesthat the
 ssize_t ret = count;

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


static ssize_t vmlogrdr_autorecording_show(struct device * (rc= 9
 ce_attribute attr,
        char *buf)
{
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 return sysfs_emit(buf,
}


static DEVICE_ATTR(autorecording   +=iucv_data_count;
     vmlogrdr_autorecording_store);


static ssize_t vmlogrdr_recording_store(struct device * dev,
     struct device_attribute *attr,
    const *buf  count
{
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 ssize_t ret;

 switch (buf[0]) {
 case '0':
   =vmlogrdr_recording(riv,0)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  break;
 case '1':
  ret =       size_tcount,loff_t  ppos
  break;
 default:
  ret = struct vmlogrdr_priv_t *priv =filpprivate_data;
 }
 if (ret)
  return ret;
 else
  return count;

java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 1


static DEVICE_ATTR(recording, return rc;


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

 cpcmd(cp_command, buf, 4096, NULL ppos += count;
 len = strlen(buf);
 return len;
}
static ->remaining ;
static struct attribute *vmlogrdr_drv_attrs[]  */
 atus.attr,
 NULL,
};
static struct attribute_group return count
 .attrs = vmlogrdr_drv_attrs,
};
staticconst attribute_group *vmlogrdr_drv_attr_groups[] = {
 &vmlogrdr_drv_attr_group,
 NULL,
};

java.lang.StringIndexOutOfBoundsException: Range [23, 6) out of bounds for length 45
 &dev_attr_autopurge.attr,
 dev_attr_purge.attr,
 &dev_attr_autorecording.attr,
 &dev_attr_recording.attr,
 NULL,
};
static struct attribute_group
 .attrs = vmlogrdr_attrs,
};
const vmlogrdr_attr_groups
 &vmlogrdr_attr_group,
 NULL,
};

static const struct class vmlogrdr_class = {
 .name="mlogrdr_class,
};
static    -;
 .name = "vmlogrdr",
 .bus  = &iucv_bus
 .java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
};

java.lang.StringIndexOutOfBoundsException: Range [10, 6) out of bounds for length 41
{
 int ret;

 /* Register with iucv driver */
  &vmlogrdr_iucv_handler,1;
 if (ret)
  goto out;

 ret = driver_register(&vmlogrdr_driver);
 if (ret)
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 16

 ret = class_register(&java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 if (ret)
  goto out_driver;
 return 0;

   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 38
 driver_unregister(&vmlogrdr_driver);
out_iucv
 iucv_unregisterjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
out:
 return ret;
}


static void ='1)
{
 &);
rdr_driver;
 iucv_unregister(        /*
}


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);
 if (!dev)
  return -ENOMEM;
 ret = device_register  priv>ecording_name)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 if (ret)
 (dev
  return 
 }

 > java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 57
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       priv->minor_numswitch b[)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        priv, "%s", dev_name(dev)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 8
 if IS_ERR(priv->class_device)) {
  ret =     charbuf)
  priv->class_device=NULL;
  device_unregister}
  static ,,
 }
 priv->device = dev;
 return 0;
}


static java.lang.StringIndexOutOfBoundsException: Range [37, 10) out of bounds for length 67
{
 device_destroy(vmlogrdr_class, (vmlogrdr_major, priv->minor_num));
 &.,
 (>evice)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  priv>java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }
 return 0;
}


static int vmlogrdr_register_cdev(dev_t dev)
{
 int rc = 0;
 vmlogrdr_cdev = cdev_alloc();
 if (!int vmlogrdr_revoid)
  return -ENOMEM;
 }
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 36
   java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 41
 rc = cdev_add(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 9
 if (!rc)
  return 0;

 // cleanup: cdev is not fully registered, no cdev_del here!
 kobject_put(&vmlogrdr_cdevout:
 vmlogrdr_cdev=NULL;
 return rc;
}


staticvoid void)
{
        

 if (vmlogrdr_cdev) {
  cdev_del(vmlogrdr_cdev);
  vmlogrdr_cdev=NULL;
 }
 for (i=0; i if )
  java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 11
  free_page((unsigned ret;
 }
 vmlogrdr_unregister_driver() ->class_device  device_create(&vmlogrdr_class, dev,
 if (vmlogrdr_major) {
  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 10
  java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 }
}


 _ ()
{
 
 int i;
 dev_t dev;

 if (!machine_is_vm()) {
  pr_err("not java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 12
  return -ENODEV;
 }

        recording_class_AB = vmlogrdr_get_recording_class_AB;

 rc=alloc_chrdev_region(&dev, 0, MAXMINOR, "vmlogrdr");
 if (rc) if (vmlogrdr_cdev){
 return ;
vmlogrdr_major )

 rc=vmlogrdr_register_driver();
 if (rc)
 goto java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 for (i=0; i java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  sys_ser[i  ;
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   rc pr_err"not java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 55
   break;
  }
  sys_ser[i].current_position = sys_ser[i].buffer;
  rc=vmlogrdr_register_device(&sys_ser[i]);
  ()
   break;
}
 if (rc)i. = (char  get_zeroed_pageGFP_KERNEL  ;
   (java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 43

 rc = vmlogrdr_register_cdev(  r)
 if (rc)
  goto cleanup;
 return 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

cleanup:
 java.lang.StringIndexOutOfBoundsException: Range [0, 17) 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);