vmlogrdr.c

Go to the documentation of this file.

/*
 *  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 <[email protected]>
 *         Stefan Weinhuber <[email protected]>
 *
 */

#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 <asm/uaccess.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 ([email protected])\n"
     "                            Stefan Weinhuber ([email protected])");
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
 * one page.
 */
#define NET_BUFFER_SIZE (PAGE_SIZE - sizeof(int) - sizeof(FENCE))

/*
 * The elements that are concurrently accessed by bottom halves are
 * connection_established, iucv_path_severed, local_interrupt_buffer
 * and receive_ready. The first three can be protected 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
 * 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 priv_lock;
    struct device  *device;
    struct device  *class_device;
    int autorecording;
    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, loff_t * ppos);

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


static void vmlogrdr_iucv_path_complete(struct iucv_path *, u8 ipuser[16]);
static void vmlogrdr_iucv_path_severed(struct iucv_path *, u8 ipuser[16]);
static void vmlogrdr_iucv_message_pending(struct iucv_path *,
                      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 vmlogrdr_priv_t sys_ser[] = {
    { .system_service = "*LOGREC ",
      .internal_name  = "logrec",
      .recording_name = "EREP",
      .minor_num      = 0,
      .buffer_free    = 1,
      .priv_lock      = __SPIN_LOCK_UNLOCKED(sys_ser[0].priv_lock),
      .autorecording  = 1,
      .autopurge      = 1,
    },
    { .system_service = "*ACCOUNT",
      .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,
    },
    { .system_service = "*SYMPTOM",
      .internal_name  = "symptom",
      .recording_name = "SYMPTOM",
      .minor_num      = 2,
      .buffer_free    = 1,
      .priv_lock      = __SPIN_LOCK_UNLOCKED(sys_ser[2].priv_lock),
      .autorecording  = 1,
      .autopurge      = 1,
    }
};

#define MAXMINOR  (sizeof(sys_ser)/sizeof(struct vmlogrdr_priv_t))

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[16])
{
    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[16])
{
    struct vmlogrdr_priv_t * logptr = path->private;
    u8 reason = (u8) ipuser[8];

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

    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_pending(struct iucv_path *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
     * 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 int vmlogrdr_get_recording_class_AB(void)
{
    static const 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,sizeof(cp_response));
    // now the parsing
    tail=strnchr(cp_response,len,'=');
    if (!tail)
        return 0;
    tail++;
    if (!strncmp("ANY",tail,3))
        return 1;
    if (!strncmp("NONE",tail,4))
        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 cp_command[80];
    char cp_response[160];
    char *onoff, *qid_string;
    int rc;

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

    /*
     * The recording commands needs to be called with option QID
     * for guests that have previlege 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);
        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->recording_name,
        onoff,
        qid_string);
    cpcmd(cp_command, cp_response, sizeof(cp_response), NULL);
    /* The recording command will usually answer with 'Command complete'
     * on success, but when the specific service was never connected
     * before then there might be an additional informational message
     * 'HCPCRC8072I Recording entry not found' before the
     * 'Command complete'. So I use strstr rather then the strncmp.
     */
    if (strstr(cp_response,"Command complete"))
        rc = 0;
    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.
     */
    if (purge && (action == 0)) {
        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);
    }

    return rc;
}


static int vmlogrdr_open (struct inode *inode, struct file *filp)
{
    int dev_num = 0;
    struct vmlogrdr_priv_t * logptr = NULL;
    int connect_rc = 0;
    int ret;

    dev_num = iminor(inode);
    if (dev_num > MAXMINOR)
        return -ENODEV;
    logptr = &sys_ser[dev_num];

    /*
     * only allow for blocking reads to be open
     */
    if (filp->f_flags & O_NONBLOCK)
        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 = 0;
    logptr->iucv_path_severed = 0;
    atomic_set(&logptr->receive_ready, 0);
    logptr->buffer_free = 1;
    spin_unlock_bh(&logptr->priv_lock);

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

    /* start recording for this service*/
    if (logptr->autorecording) {
        ret = vmlogrdr_recording(logptr,1,logptr->autopurge);
        if (ret)
            pr_warning("vmlogrdr: failed to start "
                   "recording automatically\n");
    }

    /* create connection to the system service */
    logptr->path = iucv_path_alloc(10, 0, GFP_KERNEL);
    if (!logptr->path)
        goto out_dev;
    connect_rc = iucv_path_connect(logptr->path, &vmlogrdr_iucv_handler,
                       logptr->system_service, NULL, NULL,
                       logptr);
    if (connect_rc) {
        pr_err("vmlogrdr: iucv connection to %s "
               "failed with rc %i \n",
               logptr->system_service, 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(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_warning("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 bytes we need to receive from iucv and
     * the total number of bytes we actually write 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->residual_length){
            /* receive second half of a record */
            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
                         * + size of FENCE in the first 4 bytes of the buffer.
                 */
            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 > NET_BUFFER_SIZE)
            iucv_data_count = NET_BUFFER_SIZE;
        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_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, FENCE, sizeof(FENCE));
            user_data_count += sizeof(FENCE);
        }
        priv->remaining = user_data_count;
    }

    return rc;
}


static ssize_t vmlogrdr_read(struct file *filp, char __user *data,
                 size_t count, loff_t * ppos)
{
    int rc;
    struct vmlogrdr_priv_t * priv = filp->private_data;

    while (priv->buffer_free) {
        rc = vmlogrdr_receive_data(priv);
        if (rc) {
            rc = wait_event_interruptible(read_wait_queue,
                    atomic_read(&priv->receive_ready));
            if (rc)
                return rc;
        }
    }
    /* copy only up to end of record */
    if (count > priv->remaining)
        count = priv->remaining;

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

    *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,
                    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->autopurge=0;
        break;
    case '1':
        priv->autopurge=1;
        break;
    default:
        ret = -EINVAL;
    }
    return 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 sprintf(buf, "%u\n", priv->autopurge);
}


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


static ssize_t vmlogrdr_purge_store(struct device * dev,
                    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(dev);

    if (buf[0] != '1')
        return -EINVAL;

    memset(cp_command, 0x00, sizeof(cp_command));
    memset(cp_response, 0x00, sizeof(cp_response));

        /*
     * The recording command needs to be called with option QID
     * for guests that have previlege 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 * ",
             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, vmlogrdr_purge_store);


static ssize_t vmlogrdr_autorecording_store(struct device *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 (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 *dev,
                       struct device_attribute *attr,
                       char *buf)
{
    struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);
    return sprintf(buf, "%u\n", priv->autorecording);
}


static DEVICE_ATTR(autorecording, 0644, vmlogrdr_autorecording_show,
           vmlogrdr_autorecording_store);


static ssize_t vmlogrdr_recording_store(struct device * dev,
                    struct device_attribute *attr,
                    const char * buf, size_t count)
{
    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 vmlogrdr_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(recording_status, 0444, vmlogrdr_recording_status_show,
           NULL);
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,
    &dev_attr_autorecording.attr,
    &dev_attr_recording.attr,
    NULL,
};
static struct attribute_group vmlogrdr_attr_group = {
    .attrs = vmlogrdr_attrs,
};
static const struct attribute_group *vmlogrdr_attr_groups[] = {
    &vmlogrdr_attr_group,
    NULL,
};

static int vmlogrdr_pm_prepare(struct device *dev)
{
    int rc;
    struct vmlogrdr_priv_t *priv = dev_get_drvdata(dev);

    rc = 0;
    if (priv) {
        spin_lock_bh(&priv->priv_lock);
        if (priv->dev_in_use)
            rc = -EBUSY;
        spin_unlock_bh(&priv->priv_lock);
    }
    if (rc)
        pr_err("vmlogrdr: device %s is busy. Refuse to suspend.\n",
               dev_name(dev));
    return rc;
}


static const struct dev_pm_ops vmlogrdr_pm_ops = {
    .prepare = vmlogrdr_pm_prepare,
};

static struct class *vmlogrdr_class;
static struct device_driver vmlogrdr_driver = {
    .name = "vmlogrdr",
    .bus  = &iucv_bus,
    .pm = &vmlogrdr_pm_ops,
    .groups = vmlogrdr_drv_attr_groups,
};

static int vmlogrdr_register_driver(void)
{
    int ret;

    /* 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;

    vmlogrdr_class = class_create(THIS_MODULE, "vmlogrdr");
    if (IS_ERR(vmlogrdr_class)) {
        ret = PTR_ERR(vmlogrdr_class);
        vmlogrdr_class = NULL;
        goto out_driver;
    }
    return 0;

out_driver:
    driver_unregister(&vmlogrdr_driver);
out_iucv:
    iucv_unregister(&vmlogrdr_iucv_handler, 1);
out:
    return ret;
}


static void vmlogrdr_unregister_driver(void)
{
    class_destroy(vmlogrdr_class);
    vmlogrdr_class = NULL;
    driver_unregister(&vmlogrdr_driver);
    iucv_unregister(&vmlogrdr_iucv_handler, 1);
}


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

    dev = kzalloc(sizeof(struct device), GFP_KERNEL);
    if (dev) {
        dev_set_name(dev, priv->internal_name);
        dev->bus = &iucv_bus;
        dev->parent = iucv_root;
        dev->driver = &vmlogrdr_driver;
        dev->groups = vmlogrdr_attr_groups;
        dev_set_drvdata(dev, priv);
        /*
         * The release function could be called after the
         * module has been unloaded. It's _only_ task is to
         * free the struct. Therefore, we specify kfree()
         * directly here. (Probably a little bit obfuscating
         * but legitime ...).
         */
        dev->release = (void (*)(struct device *))kfree;
    } else
        return -ENOMEM;
    ret = device_register(dev);
    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->class_device)) {
        ret = PTR_ERR(priv->class_device);
        priv->class_device=NULL;
        device_unregister(dev);
        return ret;
    }
    priv->device = dev;
    return 0;
}


static int vmlogrdr_unregister_device(struct vmlogrdr_priv_t *priv)
{
    device_destroy(vmlogrdr_class, MKDEV(vmlogrdr_major, priv->minor_num));
    if (priv->device != NULL) {
        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;
    vmlogrdr_cdev->dev = dev;
    rc = cdev_add(vmlogrdr_cdev, vmlogrdr_cdev->dev, MAXMINOR);
    if (!rc)
        return 0;

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


static void vmlogrdr_cleanup(void)
{
        int i;

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


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

    if (! MACHINE_IS_VM) {
        pr_err("not running 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(dev);

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

    for (i=0; i < MAXMINOR; ++i ) {
        sys_ser[i].buffer = (char *) get_zeroed_page(GFP_KERNEL);
        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 (rc)
        goto cleanup;
    return 0;

cleanup:
    vmlogrdr_cleanup();
    return rc;
}


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


module_init(vmlogrdr_init);
module_exit(vmlogrdr_exit);