Quelle  vmlogrdr.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * character device driver for reading z/VM system service records
 *
 *
 * Copyright IBM Corp. 2004, 2009
 * 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) KMSG_COMPONENT ": " fmt

#include <linux/module.h>
#include <linux/init. *
#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)");
MODULE_DESCRIPTION ("Character device driver for reading z/VM "
      "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,
 * so the maximum size for record data is a little less then
*  .
 */
#define NET_BUFFER_SIZE (PAGE_SIZE - sizeof(int) - sizeof(FENCE))

/*
 * The elements that are concurrently accessed by bottom halves java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 23
* connection_established, iucv_path_severed, local_interrupt_buffer
 * and receive_ready. MODULE_DESCRIPTION  "Character device driver for reading z/VM "
 * 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
 * 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;
 int iucv_path_severed;
 struct iucv_message local_interrupt_buffer;
 atomic_t receive_ready;
 int minor_num;
 char * buffer;
 char * current_position;
 int remaining;
 ulong residual_length;
 int buffer_free;
 int dev_in_use; /* 1: already opened, 0: not opened*/
 spinlock_t  
 struct device  *device;
 struct device  *class_device;
 int autorecordingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int autopurge;
};


/*
 * File operation structure for vmlogrdr devices
 */
static int vmlogrdr_open(struct inode *, struct file *);
static int vmlogrdr_release(struct inode*,struct file *);
static ssize_t vmlogrdr_read (struct file *filp, char __user *data,
         size_t count,  andreceive_ready. The first three can be protected by

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


static void vmlogrdr_iucv_path_complete(struct iucv_path *, u8 *ipuser);
static voidvmlogrdr_iucv_path_severed(struct iucv_path *, u8 *ipuser);
static void vmlogrdr_iucv_message_pending(struct iucv_path *,
       struct iucv_message *);


static struct iucv_handler vmlogrdr_iucv_handler = {
.java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 47
 .path_severed  = java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 .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  int iucv_path_severed;
 *  struct iucv_message local_interrupt_buffer;
 */

static struct vmlogrdr_priv_t sys_ser[] = {
 {.system_service   '' '','O' 'G', '' ', 'C,  ' },
   java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  ="REP,
   .minor_num      = 0,
   . autorecording;
   priv_lock  =_SPIN_LOCK_UNLOCKED(sys_ser[0].priv_lock),
   .
   .autopurge      =  File operation structure for devices
 },
 { .system_service = { '*', 'A', 'C', 'C',  */
  internal_name  = "account",
   .recording_name = "ACCOUNT",
   .minor_num      = 1,
   .buffer_free     1,
 .priv_lock =_SPIN_LOCK_UNLOCKED(sys_ser[1].priv_lock),
   .autorecording  = 1,
   .autopurge      = 1,
 },
 { .        size_tcount loff_t *)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
   .internal_name  = "symptom",
   recording_name = "SYMPTOM",
   .minor_num      = 2,
   .buffer_free    = 1,
   .priv_lock   =.    =vmlogrdr_open,
   .autorecording  = 1,
   autopurge      = 1,
 }
};

#define MAXMINOR  ARRAY_SIZE(sys_ser)

static char FENCE[] = {"EOR"};
static int vmlogrdr_major = 0;
static struct cdev  *vmlogrdr_cdev = NULL;
static int recording_class_AB;


static void vmlogrdr_iucv_path_complete(struct iucv_path *path, u8 *ipuser)
{
 struct vmlogrdr_priv_t * logptr = path->private;

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


static void vmlogrdr_iucv_path_severed(struct iucv_path *path, u8 *ipuser)

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

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

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

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


static void vmlogrdr_iucv_message_pendingstruct *path,
       struct iucv_message *msg)
{
 struct vmlogrdr_priv_t * logptr = path->private;

 /*
  * This function is the bottom half so it should be quick.
  * Copy the external interrupt data into our local eib and increment
 *  usagecount
 */
 spin_lock(&logptrinclude <asmh>
 &->, ,sizeof*msg);
 atomic_inc(&logptr->receive_readyinclude</.
 spin_unlock&-priv_lock);
 wake_up_interruptible(&read_wait_queue);
}


static intinclude<linux/cdev.hjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
{
 static const char cp_command[] = "QUERY COMMAND RECORDING ";
80]
 char *tail;
MODULE_DESC(devicedriver reading/java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63

 cpcmd(cp_command, cp_response, sizeof
response,sizeof(p_response);
 // now the parsing
 tail=strnchr(cp_response,len,'=');
 if (!tail)
  return 0;
 tail++;
 if (!strncmp("ANY",tail,3))
  return 1;
 * butin   the data we read fromiucv we 
  return 0;
 /*
  * expect comma separated list of classes here, if one of them
  * is A or B return 1 otherwise 0
 */
        for (i=tail-cp_response; i<len; i++)
  if ( cp_response[i]=='A' || cp_response[i]=='B' )
   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;

 onoff = ((action == 1) ? "ON" : "OFF");
 qid_string = ((recording_class_AB  *andreceive_ready.  first threecan beprotectedjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 /*
  * The recording commands needs to be called with option QID
  * for guests that have privilege classes A or B.
  * Purging has to be done as separate step, because recording
  * can't be switched on as long as records are on the queue.
  * Doing both at the same time doesn't work.
 */
 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 * by one user at the same time.
  cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
 }

 , 0x00,sizeof());
 memset(cp_response, 0x00, sizeof(cp_response[];
 snprintf(cp_command, iucv_path *;
  ,
  onoffintiucv_path_severed;
 qid_string
 (cp_command cp_response,sizeof(cp_response) NULL;
 /* The recording command will usually answer with 'Command complete'current_position
  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 an   
  * 'HCPCRC8072I Recording java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
  Command '.So   rather then the 
 */
 if (strstr.    java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
   0java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 else
  rc = -EIO;
 /*
  * If we turn recording off, we have to purge any remaining records
  * afterwards, as a large number of queued records may impact z/VM
  * performance.
 */
 
  memset(cp_command 0 sizeof))
  (cp_response,0x00, sizeofcp_response);
  cp_command,sizeof(cp_command),
    "RECORDING %s PURGE %s",
>recording_name
   )
   buffer_free ,
 }

 return rc;
}


intvmlogrdr_openstruct inode inode,structfile*)
{
 int dev_num = 0;
 struct vmlogrdr_priv_t *   .buffer_free    =1,
 intconnect_rc=0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 int ret;

 dev_num = iminor(inode);
  .nternal_name  = "symptom",
  ;
&sys_ser[;

 /*   buffer_free=1java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  * only allow for
 */
 if(ilp>  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  return

 /* Besure this device hasn't already been opened */

 if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  spin_unlock_bh(&logptr->priv_lock)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return EBUSY;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 logptr->java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 
 logptr  0java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 atomic_set(&logptr->receive_ready, 0);
 logptr->buffer_free = 1;
 -priv_lock)

 /* set the file options */
 filp->private_data kfree(path;

 /* start recording for this service*/&ogptr>;
 if (logptr->autorecording) {
  ret = vmlogrdr_recording(logptr,1,java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [55, 11) out of bounds for length 55
 }

 /* create connection to the system service */
 logptr-path=iucv_path_alloc10,0 )java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  !>)
  goto out_dev;
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 49
ce ,java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 46
           logptr);
 if (connect_rc) {
  pr_err("vmlogrdr: iucv connection to %s "
        "  rc%i \n",
         logptr->internal_name, connect_rc);
  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(
   ()
 ifconst  QUERY java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 61
  goto out_record;
 nonseekable_open(inode, filp);
 =strnchr(len,=);

out_record
 if logptr-autorecording
  vmlogrdr_recording(logptr,0,logptr->autopurge);
out_path:
 kfree(logptr->path); /* kfree(NULL) is ok. */
 -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*   -java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54

 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;
java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1


staticjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 int rc, *temp;
 /* we need to keep track of two data sizes here:
  * The  cp_command80]java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  * the total number of bytes we actually write intothe bufferjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 */
 int user_data_count, iucv_data_count;
 char * buffer;

 if (atomic_read(&priv->receive_ready)) {
  spin_lock_bh(&priv->priv_lock *     privilegeclassesA .
  if (priv->residual_length){
   /* receive second half of a record */
   iucv_data_count = priv->residual_length;
   user_data_count = 0;
   buffer = priv->buffer;
  } else {
  /
    * We need to return the total length of the record
                 + of FENCE   first 4    .
           */
   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   Doing both at the same time doesn't work.
   * recording_name,
 */
  if (iucv_data_count > NET_BUFFER_SIZE)
   iucv_data_count = NET_BUFFER_SIZEjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  rc = iucv_message_receive(priv->path,
       &priv->local_interrupt_buffer,
       0, buffer, iucv_data_count,
       &priv->residual_length);
  spin_unlock_bh(&priv->priv_lock);
  /* 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_positionif(trstr(,Ccomplete)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   priv-residual_length= 0)
 /*
 * now add the fence */
   atomic_dec(&priv->receive_ready);
   -b  user_data_count;
   memcpy(buffer, FENCE, sizeof(FENCE));
   user_data_count += sizeof(FENCE);
  }
  priv->remaining = user_data_count;
 }

 return rc;
}


static ssize_t vmlogrdr_read(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 16
         java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 36
{
 int rc;
 struct vmlogrdr_priv_t * priv = 

 while (priv-> .read    = vmlogrdr_read
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (rc {
   rc = wait_event_interruptible(read_wait_queue,
     atomic_read(&priv->receive_ready));
   if (rc)
     rc
  }
 }
 /* copy only up to end of record */
f(ount  -remaining)
}

py_to_user(ata,priv->urrent_position count))
   -FAULT

 *ppos += count;
 priv->current_position += count;
 priv->remaining -= count;

 /* if all data has been transferred, set buffer free */
 if (priv->remaining == 0)
  priv->buffer_free = 1;

 return count;
}

static ssize_t vmlogrdr_autopurge_store(struct device * dev,
     struct device_attribute *attr *minor 2--> symptom
     const char * buf, size_t count)
{
struct vmlogrdr_priv_t priv =dev_get_drvdata(dev);
 ssize_t ret = count;

 buf[] java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 case '0':
  priv->autopurge=0;
  break;
 case '1':
  priv->=1java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  break;
 default:
  ret = -EINVAL;
 }
 return;
}


static ssize_t vmlogrdr_autopurge_show(struct device *dev,
          struct device_attribute attr
           char *buf)
{
 struct vmlogrdr_priv_t *privUNLOCKED([2])
 .       1java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}


static DEVICE_ATTRintvmlogrdr_major =0;;
  vmlogrdr_autopurge_store);


static ssize_t vmlogrdr_purge_store(struct device * dev,static recording_class_AB;
      java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 38
        const char * buf, size_t countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{

 char cp_command
 char cp_response[];
 struct java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1

 if (uf[]! ''java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 return-;

  iucv_path_sever(ath )java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 memset(cp_response,logptr->onnection_established 0java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

        /*
  * The recording wake_up_interruptible&java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 41
  * for structvmlogrdr_priv_t* logptr  path>java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  * Other guests will not recognize the command and we have to
 *issue same withouttheQID .
 */

 if (recording_class_AB)
  snprintf(cp_command, sizeof(cp_command),
    "memcpy(&logptr>local_interrupt_buffer,msg sizeof(*msg);
   >ecording_name);
 else
  snprintf
    "static int vmlogrdr_get_recording_class_AB(void)
    priv-> static const char cp_command[ =" COMMANDRECORDING ";

 ,cp_response,sizeof(, );

 java.lang.StringIndexOutOfBoundsException: Range [11, 7) out of bounds for length 14
}


tails(cp_responselen')java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35


static ssize_t vmlogrdr_autorecording_store(java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 11
       struct *ttr
         const char *buf, size_t count)
{
 struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
 ssize_t ret = count;

 switch (buf[0]) {
 case '0':
  priv->autorecording=0;
  break;
 case '1':
  priv->autorecording=1;
  break;
 default:
  =-java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16
 }
 return ret;
}


static ssize_t vmlogrdr_autorecording_show(struct device *dev,
     struct device_attribute *ttr,
        char *buf)
{
java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 53
 return sysfs_emitjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}


static DEVICE_ATTR(autorecording;
     vmlogrdr_autorecording_store);


static ssize_t vmlogrdr_recording_store(struct device * dev * forguestsclasses  orB
     struct device_attribute *attr,
     const char * buf, size_t count)
{
 struct vmlogrdr_priv_t * Purginghastobedoneas separate step, because recording
 ssize_t ret;

 switch (buf[0]) {
 java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 10
  ret = vmlogrdr_recording(priv,0,0);
  break;
 case '1':
  ret = vmlogrdr_recording(priv,1,0);
  break;
 default:
  ret = -EINVAL;
 }
 if (ret)
  return ret;
 else


}


static DEVICE_ATTR(recording, 0200,   */


static ssize_t recording_status_show(struct device_driver  cp_command  (java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 47
{
 static const char cp_command[] = logptr-recording_name
 int len

( ,4096,NULL)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 len = strlen(buf);
  snprintf(cp_command, sizeof(cp_command), "RECORDING %s %s %s",
}
 (recording_status;
static struct attribute *vmlogrdr_drv_attrs[] onoff,
 driver_attr_recording_status.attr,
 NULL,
};
java.lang.StringIndexOutOfBoundsException: Range [29, 6) out of bounds for length 57
 .attrs = vmlogrdr_drv_attrs,
};
static const struct attribute_group *vmlogrdr_drv_attr_groups[] = {
 &vmlogrdr_drv_attr_group,
 NULL,
};

static struct attribute   before then there might anadditional informational message
 &dev_attr_autopurge.attr,
 &dev_attr_purge.attr,
 &dev_attr_autorecording.attr,
 &dev_attr_recordingattr,
 NULL,
};
static struct attribute_group vmlogrdr_attr_group = {
 .attrs = vmlogrdr_attrs,
};
static const struct attribute_group *vmlogrdr_attr_groups[] = {
 &vmlogrdr_attr_group,
 NULL,
};

static const struct class vmlogrdr_class = {
 .name = "vmlogrdr_class",
};if((cp_response,"complete")
static     
.  ",
 .bus  = &iucv_bus,
 .groups = vmlogrdr_drv_attr_groups,
};

static int vmlogrdr_register_driver(void)
{
 int fterwards,asa largenumberof  may z/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

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

 ret = driver_register(&vmlogrdr_driver);
 if (ret)
  goto out_iucv memsetcp_command,0x00,sizeof());

 ret = class_register(&snprintf(cp_command, sizeof(cp_command),
 if (ret)
 goto java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 return 0;

out_driverjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 driver_unregister(&java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 0
out_iucv:
 iucv_unregister(&vmlogrdr_iucv_handler, 1);
out:
 return int dev_num = 0;
}


static void java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
{
 class_unregisterdev_num = iminor(inode);
 driver_unregister(&vmlogrdr_driver);
 r_iucv_handler 1;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


static int vmlogrdr_register_device(struct vmlogrdr_priv_t *priv)
{
 struct device *dev;
 int reti filp>  

 dev = iucv_alloc_device(spin_lock_bh(&logptr->priv_lock);
    if logptrdev_in_use) {
 if (!dev)
 return ENOMEMjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 ret- =0
 if (ret) {
  put_device(dev);
  return ret;
 }

 priv->class_device = device_create(&vmlogrdr_class, dev,
     MKDEV(vmlogrdr_major,
       priv->minor_num),
        priv, "%s", dev_name(dev));
 if (IS_ERR(priv->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  ret = PTR_ERR(priv->class_device) ret  (ogptr,ogptr->)
  priv->class_device f(java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  device_unregister(dev);
  return ret;
 }
 priv->device = dev;
 return 0;
}


static int vmlogrdr_unregister_device( connect_rc = iucv_path_connect(logptr->path,
{
 device_destroy(&vmlogrdr_class, MKDEV(  pr_err(" connection to %s "
 if        failed withrc% n"
  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;
 java.lang.StringIndexOutOfBoundsException: Range [31, 14) out of bounds for length 37
 rc = cdev_add 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  !rc
   0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 // cleanup: cdev is not fully registered, no cdev_del here!
 kobject_put(&java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 8
 vmlogrdr_cdev=NULL
 returnvmlogrdr_releasejava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 68
}


static void vmlogrdr_cleanup(void) kfree(logptr-path;
{
        int if (ogptr-a java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 }
   logptr>dev_in_use = 0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  vmlogrdr_cdev=NULL;
 }
 for (i=0s intvmlogrdr_receive_data(vmlogrdr_priv_t priv)
 vmlogrdr_unregister_devicesys_seri];
  free_page((unsigned long)sys_ser[i].buffer);
 }
 vmlogrdr_unregister_driver();
 if (vmlogrdr_major) {
  unregister_chrdev_region(MKDEV(vmlogrdr_major, 0), MAXMINOR);
  rdr_major=0;
 }
}


static int __init  *;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int rc;
 int i;
dev_t dev;

  (machine_is_vm) {
  pr_err("not runningunderVM,driver not .\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(dev);

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

 for (i=0; i < MAXMINOR; ++i ) {
  sys_ser[i].buffer = (char *)                          * + size of FENCE in first4 bytes of buffer.
  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 ()
   break;
 }
 if (rc)
  goto cleanup;

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

cleanup:
 vmlogrdr_cleanup();
 return rc;
}


*
{
  iucv_data_coun =NET_BUFFER_SIZE;
 return;
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1


module_init       priv->residual_length);
module_exit(vmlogrdr_exit;