lkml.org 
[lkml]   [2017]   [Dec]   [19]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[RFC PATCH 49/60] hyper_dmabuf: general clean-up and fixes
    Date
    1. global hyper_dmabuf_private is now pointer(*hy_drv_priv)
    pointing to private data structure initialized when driver
    is initialized. This is freed when driver exits.

    2. using shorter variable and type's names

    3. remove unnecessary NULL checks

    4. event-polling related funcs are now compiled only if
    CONFIG_HYPER_DMABUF_EVENT_GEN is enabled.

    Signed-off-by: Dongwon Kim <dongwon.kim@intel.com>
    ---
    drivers/xen/hyper_dmabuf/Makefile | 7 +-
    drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h | 25 -
    drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 164 +++---
    drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 13 +-
    drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c | 60 +--
    drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c | 16 +-
    drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 569 ++++++++++-----------
    drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h | 2 +
    drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c | 88 ++--
    drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h | 18 +-
    drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 259 +++++-----
    drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 18 +-
    drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c | 284 +++++-----
    drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h | 4 +-
    drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c | 58 +--
    drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h | 4 +-
    .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 170 +++---
    drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c | 123 ++---
    drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h | 10 +-
    drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 24 +-
    .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 240 +++++----
    .../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c | 6 +-
    .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c | 147 +++---
    23 files changed, 1144 insertions(+), 1165 deletions(-)
    delete mode 100644 drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h

    diff --git a/drivers/xen/hyper_dmabuf/Makefile b/drivers/xen/hyper_dmabuf/Makefile
    index 1cd7a81..a113bfc 100644
    --- a/drivers/xen/hyper_dmabuf/Makefile
    +++ b/drivers/xen/hyper_dmabuf/Makefile
    @@ -13,9 +13,12 @@ ifneq ($(KERNELRELEASE),)
    hyper_dmabuf_id.o \
    hyper_dmabuf_remote_sync.o \
    hyper_dmabuf_query.o \
    - hyper_dmabuf_event.o \

    -ifeq ($(CONFIG_XEN), y)
    +ifeq ($(CONFIG_HYPER_DMABUF_EVENT_GEN), y)
    + $(TARGET_MODULE)-objs += hyper_dmabuf_event.o
    +endif
    +
    +ifeq ($(CONFIG_HYPER_DMABUF_XEN), y)
    $(TARGET_MODULE)-objs += xen/hyper_dmabuf_xen_comm.o \
    xen/hyper_dmabuf_xen_comm_list.o \
    xen/hyper_dmabuf_xen_shm.o \
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
    deleted file mode 100644
    index d5125f2..0000000
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
    +++ /dev/null
    @@ -1,25 +0,0 @@
    -/*
    - * Copyright © 2017 Intel Corporation
    - *
    - * Permission is hereby granted, free of charge, to any person obtaining a
    - * copy of this software and associated documentation files (the "Software"),
    - * to deal in the Software without restriction, including without limitation
    - * the rights to use, copy, modify, merge, publish, distribute, sublicense,
    - * and/or sell copies of the Software, and to permit persons to whom the
    - * Software is furnished to do so, subject to the following conditions:
    - *
    - * The above copyright notice and this permission notice (including the next
    - * paragraph) shall be included in all copies or substantial portions of the
    - * Software.
    - *
    - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
    - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
    - * IN THE SOFTWARE.
    - *
    - */
    -
    -/* configuration */
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
    index 1c35a59..525ee78 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
    @@ -36,7 +36,6 @@
    #include <linux/poll.h>
    #include <linux/dma-buf.h>
    #include "hyper_dmabuf_drv.h"
    -#include "hyper_dmabuf_conf.h"
    #include "hyper_dmabuf_ioctl.h"
    #include "hyper_dmabuf_msg.h"
    #include "hyper_dmabuf_list.h"
    @@ -51,13 +50,32 @@ extern struct hyper_dmabuf_backend_ops xen_backend_ops;
    MODULE_LICENSE("GPL and additional rights");
    MODULE_AUTHOR("Intel Corporation");

    -struct hyper_dmabuf_private hyper_dmabuf_private;
    +struct hyper_dmabuf_private *hy_drv_priv;

    long hyper_dmabuf_ioctl(struct file *filp,
    unsigned int cmd, unsigned long param);

    -void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* sgt_info,
    - void *attr);
    +static void hyper_dmabuf_force_free(struct exported_sgt_info* exported,
    + void *attr)
    +{
    + struct ioctl_hyper_dmabuf_unexport unexport_attr;
    + struct file *filp = (struct file*) attr;
    +
    + if (!filp || !exported)
    + return;
    +
    + if (exported->filp == filp) {
    + dev_dbg(hy_drv_priv->dev,
    + "Forcefully releasing buffer {id:%d key:%d %d %d}\n",
    + exported->hid.id, exported->hid.rng_key[0],
    + exported->hid.rng_key[1], exported->hid.rng_key[2]);
    +
    + unexport_attr.hid = exported->hid;
    + unexport_attr.delay_ms = 0;
    +
    + hyper_dmabuf_unexport_ioctl(filp, &unexport_attr);
    + }
    +}

    int hyper_dmabuf_open(struct inode *inode, struct file *filp)
    {
    @@ -72,18 +90,20 @@ int hyper_dmabuf_open(struct inode *inode, struct file *filp)

    int hyper_dmabuf_release(struct inode *inode, struct file *filp)
    {
    - hyper_dmabuf_foreach_exported(hyper_dmabuf_emergency_release, filp);
    + hyper_dmabuf_foreach_exported(hyper_dmabuf_force_free, filp);

    return 0;
    }

    +#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
    +
    unsigned int hyper_dmabuf_event_poll(struct file *filp, struct poll_table_struct *wait)
    {
    unsigned int mask = 0;

    - poll_wait(filp, &hyper_dmabuf_private.event_wait, wait);
    + poll_wait(filp, &hy_drv_priv->event_wait, wait);

    - if (!list_empty(&hyper_dmabuf_private.event_list))
    + if (!list_empty(&hy_drv_priv->event_list))
    mask |= POLLIN | POLLRDNORM;

    return mask;
    @@ -96,32 +116,32 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,

    /* only root can read events */
    if (!capable(CAP_DAC_OVERRIDE)) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "Only root can read events\n");
    return -EFAULT;
    }

    /* make sure user buffer can be written */
    if (!access_ok(VERIFY_WRITE, buffer, count)) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "User buffer can't be written.\n");
    return -EFAULT;
    }

    - ret = mutex_lock_interruptible(&hyper_dmabuf_private.event_read_lock);
    + ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock);
    if (ret)
    return ret;

    while (1) {
    struct hyper_dmabuf_event *e = NULL;

    - spin_lock_irq(&hyper_dmabuf_private.event_lock);
    - if (!list_empty(&hyper_dmabuf_private.event_list)) {
    - e = list_first_entry(&hyper_dmabuf_private.event_list,
    + spin_lock_irq(&hy_drv_priv->event_lock);
    + if (!list_empty(&hy_drv_priv->event_list)) {
    + e = list_first_entry(&hy_drv_priv->event_list,
    struct hyper_dmabuf_event, link);
    list_del(&e->link);
    }
    - spin_unlock_irq(&hyper_dmabuf_private.event_lock);
    + spin_unlock_irq(&hy_drv_priv->event_lock);

    if (!e) {
    if (ret)
    @@ -131,12 +151,12 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
    break;
    }

    - mutex_unlock(&hyper_dmabuf_private.event_read_lock);
    - ret = wait_event_interruptible(hyper_dmabuf_private.event_wait,
    - !list_empty(&hyper_dmabuf_private.event_list));
    + mutex_unlock(&hy_drv_priv->event_read_lock);
    + ret = wait_event_interruptible(hy_drv_priv->event_wait,
    + !list_empty(&hy_drv_priv->event_list));

    if (ret == 0)
    - ret = mutex_lock_interruptible(&hyper_dmabuf_private.event_read_lock);
    + ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock);

    if (ret)
    return ret;
    @@ -145,9 +165,9 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,

    if (length > count - ret) {
    put_back_event:
    - spin_lock_irq(&hyper_dmabuf_private.event_lock);
    - list_add(&e->link, &hyper_dmabuf_private.event_list);
    - spin_unlock_irq(&hyper_dmabuf_private.event_lock);
    + spin_lock_irq(&hy_drv_priv->event_lock);
    + list_add(&e->link, &hy_drv_priv->event_list);
    + spin_unlock_irq(&hy_drv_priv->event_lock);
    break;
    }

    @@ -170,7 +190,7 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
    /* nullifying hdr of the event in user buffer */
    if (copy_to_user(buffer + ret, &dummy_hdr,
    sizeof(dummy_hdr))) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "failed to nullify invalid hdr already in userspace\n");
    }

    @@ -180,23 +200,30 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
    }

    ret += e->event_data.hdr.size;
    - hyper_dmabuf_private.curr_num_event--;
    + hy_drv_priv->pending--;
    kfree(e);
    }
    }

    - mutex_unlock(&hyper_dmabuf_private.event_read_lock);
    + mutex_unlock(&hy_drv_priv->event_read_lock);

    return ret;
    }

    +#endif
    +
    static struct file_operations hyper_dmabuf_driver_fops =
    {
    .owner = THIS_MODULE,
    .open = hyper_dmabuf_open,
    .release = hyper_dmabuf_release,
    +
    +/* poll and read interfaces are needed only for event-polling */
    +#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
    .read = hyper_dmabuf_event_read,
    .poll = hyper_dmabuf_event_poll,
    +#endif
    +
    .unlocked_ioctl = hyper_dmabuf_ioctl,
    };

    @@ -217,17 +244,17 @@ int register_device(void)
    return ret;
    }

    - hyper_dmabuf_private.device = hyper_dmabuf_miscdev.this_device;
    + hy_drv_priv->dev = hyper_dmabuf_miscdev.this_device;

    /* TODO: Check if there is a different way to initialize dma mask nicely */
    - dma_coerce_mask_and_coherent(hyper_dmabuf_private.device, DMA_BIT_MASK(64));
    + dma_coerce_mask_and_coherent(hy_drv_priv->dev, DMA_BIT_MASK(64));

    return ret;
    }

    void unregister_device(void)
    {
    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "hyper_dmabuf: unregister_device() is called\n");

    misc_deregister(&hyper_dmabuf_miscdev);
    @@ -239,9 +266,13 @@ static int __init hyper_dmabuf_drv_init(void)

    printk( KERN_NOTICE "hyper_dmabuf_starting: Initialization started\n");

    - mutex_init(&hyper_dmabuf_private.lock);
    - mutex_init(&hyper_dmabuf_private.event_read_lock);
    - spin_lock_init(&hyper_dmabuf_private.event_lock);
    + hy_drv_priv = kcalloc(1, sizeof(struct hyper_dmabuf_private),
    + GFP_KERNEL);
    +
    + if (!hy_drv_priv) {
    + printk( KERN_ERR "hyper_dmabuf: Failed to create drv\n");
    + return -1;
    + }

    ret = register_device();
    if (ret < 0) {
    @@ -251,64 +282,72 @@ static int __init hyper_dmabuf_drv_init(void)
    /* currently only supports XEN hypervisor */

    #ifdef CONFIG_HYPER_DMABUF_XEN
    - hyper_dmabuf_private.backend_ops = &xen_backend_ops;
    + hy_drv_priv->backend_ops = &xen_backend_ops;
    #else
    - hyper_dmabuf_private.backend_ops = NULL;
    + hy_drv_priv->backend_ops = NULL;
    printk( KERN_ERR "hyper_dmabuf drv currently supports XEN only.\n");
    #endif

    - if (hyper_dmabuf_private.backend_ops == NULL) {
    + if (hy_drv_priv->backend_ops == NULL) {
    printk( KERN_ERR "Hyper_dmabuf: failed to be loaded - no backend found\n");
    return -1;
    }

    - mutex_lock(&hyper_dmabuf_private.lock);
    + /* initializing mutexes and a spinlock */
    + mutex_init(&hy_drv_priv->lock);
    +
    + mutex_lock(&hy_drv_priv->lock);

    - hyper_dmabuf_private.backend_initialized = false;
    + hy_drv_priv->initialized = false;

    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "initializing database for imported/exported dmabufs\n");

    /* device structure initialization */
    /* currently only does work-queue initialization */
    - hyper_dmabuf_private.work_queue = create_workqueue("hyper_dmabuf_wqueue");
    + hy_drv_priv->work_queue = create_workqueue("hyper_dmabuf_wqueue");

    ret = hyper_dmabuf_table_init();
    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "failed to initialize table for exported/imported entries\n");
    return ret;
    }

    #ifdef CONFIG_HYPER_DMABUF_SYSFS
    - ret = hyper_dmabuf_register_sysfs(hyper_dmabuf_private.device);
    + ret = hyper_dmabuf_register_sysfs(hy_drv_priv->dev);
    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "failed to initialize sysfs\n");
    return ret;
    }
    #endif

    +#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
    + mutex_init(&hy_drv_priv->event_read_lock);
    + spin_lock_init(&hy_drv_priv->event_lock);
    +
    /* Initialize event queue */
    - INIT_LIST_HEAD(&hyper_dmabuf_private.event_list);
    - init_waitqueue_head(&hyper_dmabuf_private.event_wait);
    + INIT_LIST_HEAD(&hy_drv_priv->event_list);
    + init_waitqueue_head(&hy_drv_priv->event_wait);

    - hyper_dmabuf_private.curr_num_event = 0;
    - hyper_dmabuf_private.exited = false;
    + /* resetting number of pending events */
    + hy_drv_priv->pending = 0;
    +#endif

    - hyper_dmabuf_private.domid = hyper_dmabuf_private.backend_ops->get_vm_id();
    + hy_drv_priv->domid = hy_drv_priv->backend_ops->get_vm_id();

    - ret = hyper_dmabuf_private.backend_ops->init_comm_env();
    + ret = hy_drv_priv->backend_ops->init_comm_env();
    if (ret < 0) {
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "failed to initialize comm-env but it will re-attempt.\n");
    } else {
    - hyper_dmabuf_private.backend_initialized = true;
    + hy_drv_priv->initialized = true;
    }

    - mutex_unlock(&hyper_dmabuf_private.lock);
    + mutex_unlock(&hy_drv_priv->lock);

    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "Finishing up initialization of hyper_dmabuf drv\n");

    /* interrupt for comm should be registered here: */
    @@ -318,34 +357,39 @@ static int __init hyper_dmabuf_drv_init(void)
    static void hyper_dmabuf_drv_exit(void)
    {
    #ifdef CONFIG_HYPER_DMABUF_SYSFS
    - hyper_dmabuf_unregister_sysfs(hyper_dmabuf_private.device);
    + hyper_dmabuf_unregister_sysfs(hy_drv_priv->dev);
    #endif

    - mutex_lock(&hyper_dmabuf_private.lock);
    + mutex_lock(&hy_drv_priv->lock);

    /* hash tables for export/import entries and ring_infos */
    hyper_dmabuf_table_destroy();

    - hyper_dmabuf_private.backend_ops->destroy_comm();
    + hy_drv_priv->backend_ops->destroy_comm();

    /* destroy workqueue */
    - if (hyper_dmabuf_private.work_queue)
    - destroy_workqueue(hyper_dmabuf_private.work_queue);
    + if (hy_drv_priv->work_queue)
    + destroy_workqueue(hy_drv_priv->work_queue);

    /* destroy id_queue */
    - if (hyper_dmabuf_private.id_queue)
    + if (hy_drv_priv->id_queue)
    destroy_reusable_list();

    - hyper_dmabuf_private.exited = true;
    -
    +#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
    /* clean up event queue */
    hyper_dmabuf_events_release();
    +#endif

    - mutex_unlock(&hyper_dmabuf_private.lock);
    + mutex_unlock(&hy_drv_priv->lock);

    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "hyper_dmabuf driver: Exiting\n");

    + if (hy_drv_priv) {
    + kfree(hy_drv_priv);
    + hy_drv_priv = NULL;
    + }
    +
    unregister_device();
    }

    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
    index a4acdd9f..2ead41b 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
    @@ -36,7 +36,7 @@ struct hyper_dmabuf_event {
    };

    struct hyper_dmabuf_private {
    - struct device *device;
    + struct device *dev;

    /* VM(domain) id of current VM instance */
    int domid;
    @@ -55,7 +55,7 @@ struct hyper_dmabuf_private {
    struct mutex lock;

    /* flag that shows whether backend is initialized */
    - bool backend_initialized;
    + bool initialized;

    wait_queue_head_t event_wait;
    struct list_head event_list;
    @@ -63,10 +63,8 @@ struct hyper_dmabuf_private {
    spinlock_t event_lock;
    struct mutex event_read_lock;

    - int curr_num_event;
    -
    - /* indicate whether the driver is unloaded */
    - bool exited;
    + /* # of pending events */
    + int pending;
    };

    struct list_reusable_id {
    @@ -108,4 +106,7 @@ struct hyper_dmabuf_backend_ops {
    int (*send_req)(int, struct hyper_dmabuf_req *, int);
    };

    +/* exporting global drv private info */
    +extern struct hyper_dmabuf_private *hy_drv_priv;
    +
    #endif /* __LINUX_PUBLIC_HYPER_DMABUF_DRV_H__ */
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
    index 3e1498c..0498cda 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
    @@ -32,37 +32,33 @@
    #include <linux/slab.h>
    #include <linux/module.h>
    #include <linux/dma-buf.h>
    -#include <xen/grant_table.h>
    -#include <asm/xen/page.h>
    #include "hyper_dmabuf_drv.h"
    #include "hyper_dmabuf_struct.h"
    #include "hyper_dmabuf_list.h"
    #include "hyper_dmabuf_event.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    static void hyper_dmabuf_send_event_locked(struct hyper_dmabuf_event *e)
    {
    struct hyper_dmabuf_event *oldest;

    - assert_spin_locked(&hyper_dmabuf_private.event_lock);
    + assert_spin_locked(&hy_drv_priv->event_lock);

    /* check current number of event then if it hits the max num allowed
    * then remove the oldest event in the list */
    - if (hyper_dmabuf_private.curr_num_event > MAX_DEPTH_EVENT_QUEUE - 1) {
    - oldest = list_first_entry(&hyper_dmabuf_private.event_list,
    + if (hy_drv_priv->pending > MAX_DEPTH_EVENT_QUEUE - 1) {
    + oldest = list_first_entry(&hy_drv_priv->event_list,
    struct hyper_dmabuf_event, link);
    list_del(&oldest->link);
    - hyper_dmabuf_private.curr_num_event--;
    + hy_drv_priv->pending--;
    kfree(oldest);
    }

    list_add_tail(&e->link,
    - &hyper_dmabuf_private.event_list);
    + &hy_drv_priv->event_list);

    - hyper_dmabuf_private.curr_num_event++;
    + hy_drv_priv->pending++;

    - wake_up_interruptible(&hyper_dmabuf_private.event_wait);
    + wake_up_interruptible(&hy_drv_priv->event_wait);
    }

    void hyper_dmabuf_events_release()
    @@ -70,34 +66,34 @@ void hyper_dmabuf_events_release()
    struct hyper_dmabuf_event *e, *et;
    unsigned long irqflags;

    - spin_lock_irqsave(&hyper_dmabuf_private.event_lock, irqflags);
    + spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags);

    - list_for_each_entry_safe(e, et, &hyper_dmabuf_private.event_list,
    + list_for_each_entry_safe(e, et, &hy_drv_priv->event_list,
    link) {
    list_del(&e->link);
    kfree(e);
    - hyper_dmabuf_private.curr_num_event--;
    + hy_drv_priv->pending--;
    }

    - if (hyper_dmabuf_private.curr_num_event) {
    - dev_err(hyper_dmabuf_private.device,
    + if (hy_drv_priv->pending) {
    + dev_err(hy_drv_priv->dev,
    "possible leak on event_list\n");
    }

    - spin_unlock_irqrestore(&hyper_dmabuf_private.event_lock, irqflags);
    + spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags);
    }

    int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid)
    {
    struct hyper_dmabuf_event *e;
    - struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
    + struct imported_sgt_info *imported;

    unsigned long irqflags;

    - imported_sgt_info = hyper_dmabuf_find_imported(hid);
    + imported = hyper_dmabuf_find_imported(hid);

    - if (!imported_sgt_info) {
    - dev_err(hyper_dmabuf_private.device,
    + if (!imported) {
    + dev_err(hy_drv_priv->dev,
    "can't find imported_sgt_info in the list\n");
    return -EINVAL;
    }
    @@ -105,29 +101,29 @@ int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid)
    e = kzalloc(sizeof(*e), GFP_KERNEL);

    if (!e) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "no space left\n");
    return -ENOMEM;
    }

    e->event_data.hdr.event_type = HYPER_DMABUF_NEW_IMPORT;
    e->event_data.hdr.hid = hid;
    - e->event_data.data = (void*)imported_sgt_info->priv;
    - e->event_data.hdr.size = imported_sgt_info->sz_priv;
    + e->event_data.data = (void*)imported->priv;
    + e->event_data.hdr.size = imported->sz_priv;

    - spin_lock_irqsave(&hyper_dmabuf_private.event_lock, irqflags);
    + spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags);

    hyper_dmabuf_send_event_locked(e);

    - spin_unlock_irqrestore(&hyper_dmabuf_private.event_lock, irqflags);
    + spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags);

    - dev_dbg(hyper_dmabuf_private.device,
    - "event number = %d :", hyper_dmabuf_private.curr_num_event);
    + dev_dbg(hy_drv_priv->dev,
    + "event number = %d :", hy_drv_priv->pending);

    - dev_dbg(hyper_dmabuf_private.device,
    - "generating events for {%d, %d, %d, %d}\n",
    - imported_sgt_info->hid.id, imported_sgt_info->hid.rng_key[0],
    - imported_sgt_info->hid.rng_key[1], imported_sgt_info->hid.rng_key[2]);
    + dev_dbg(hy_drv_priv->dev,
    + "generating events for {%d, %d, %d, %d}\n",
    + imported->hid.id, imported->hid.rng_key[0],
    + imported->hid.rng_key[1], imported->hid.rng_key[2]);

    return 0;
    }
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
    index cccdc19..e2466c7 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
    @@ -33,17 +33,15 @@
    #include "hyper_dmabuf_id.h"
    #include "hyper_dmabuf_msg.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    void store_reusable_hid(hyper_dmabuf_id_t hid)
    {
    - struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
    + struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
    struct list_reusable_id *new_reusable;

    new_reusable = kmalloc(sizeof(*new_reusable), GFP_KERNEL);

    if (!new_reusable) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return;
    }
    @@ -55,7 +53,7 @@ void store_reusable_hid(hyper_dmabuf_id_t hid)

    static hyper_dmabuf_id_t retrieve_reusable_hid(void)
    {
    - struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
    + struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
    hyper_dmabuf_id_t hid = {-1, {0,0,0}};

    /* check there is reusable id */
    @@ -74,7 +72,7 @@ static hyper_dmabuf_id_t retrieve_reusable_hid(void)

    void destroy_reusable_list(void)
    {
    - struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
    + struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
    struct list_reusable_id *temp_head;

    if (reusable_head) {
    @@ -103,14 +101,14 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
    reusable_head = kmalloc(sizeof(*reusable_head), GFP_KERNEL);

    if (!reusable_head) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return (hyper_dmabuf_id_t){-1, {0,0,0}};
    }

    reusable_head->hid.id = -1; /* list head has an invalid count */
    INIT_LIST_HEAD(&reusable_head->list);
    - hyper_dmabuf_private.id_queue = reusable_head;
    + hy_drv_priv->id_queue = reusable_head;
    }

    hid = retrieve_reusable_hid();
    @@ -119,7 +117,7 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
    * and count is less than maximum allowed
    */
    if (hid.id == -1 && count < HYPER_DMABUF_ID_MAX) {
    - hid.id = HYPER_DMABUF_ID_CREATE(hyper_dmabuf_private.domid, count++);
    + hid.id = HYPER_DMABUF_ID_CREATE(hy_drv_priv->domid, count++);
    }

    /* random data embedded in the id for security */
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
    index 15191c2..b328df7 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
    @@ -45,16 +45,14 @@
    #include "hyper_dmabuf_ops.h"
    #include "hyper_dmabuf_query.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data)
    {
    struct ioctl_hyper_dmabuf_tx_ch_setup *tx_ch_attr;
    - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
    + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
    int ret = 0;

    if (!data) {
    - dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
    + dev_err(hy_drv_priv->dev, "user data is NULL\n");
    return -EINVAL;
    }
    tx_ch_attr = (struct ioctl_hyper_dmabuf_tx_ch_setup *)data;
    @@ -67,11 +65,11 @@ static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data)
    static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data)
    {
    struct ioctl_hyper_dmabuf_rx_ch_setup *rx_ch_attr;
    - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
    + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
    int ret = 0;

    if (!data) {
    - dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
    + dev_err(hy_drv_priv->dev, "user data is NULL\n");
    return -EINVAL;
    }

    @@ -82,48 +80,48 @@ static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data)
    return ret;
    }

    -static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info,
    - struct hyper_dmabuf_pages_info *page_info)
    +static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported,
    + struct pages_info *pg_info)
    {
    - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
    + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
    struct hyper_dmabuf_req *req;
    - int operands[MAX_NUMBER_OF_OPERANDS] = {0};
    + int op[MAX_NUMBER_OF_OPERANDS] = {0};
    int ret, i;

    /* now create request for importer via ring */
    - operands[0] = sgt_info->hid.id;
    + op[0] = exported->hid.id;

    for (i=0; i<3; i++)
    - operands[i+1] = sgt_info->hid.rng_key[i];
    -
    - if (page_info) {
    - operands[4] = page_info->nents;
    - operands[5] = page_info->frst_ofst;
    - operands[6] = page_info->last_len;
    - operands[7] = ops->share_pages (page_info->pages, sgt_info->hyper_dmabuf_rdomain,
    - page_info->nents, &sgt_info->refs_info);
    - if (operands[7] < 0) {
    - dev_err(hyper_dmabuf_private.device, "pages sharing failed\n");
    + op[i+1] = exported->hid.rng_key[i];
    +
    + if (pg_info) {
    + op[4] = pg_info->nents;
    + op[5] = pg_info->frst_ofst;
    + op[6] = pg_info->last_len;
    + op[7] = ops->share_pages(pg_info->pgs, exported->rdomid,
    + pg_info->nents, &exported->refs_info);
    + if (op[7] < 0) {
    + dev_err(hy_drv_priv->dev, "pages sharing failed\n");
    return -1;
    }
    }

    - operands[8] = sgt_info->sz_priv;
    + op[8] = exported->sz_priv;

    /* driver/application specific private info */
    - memcpy(&operands[9], sgt_info->priv, operands[8]);
    + memcpy(&op[9], exported->priv, op[8]);

    req = kcalloc(1, sizeof(*req), GFP_KERNEL);

    if(!req) {
    - dev_err(hyper_dmabuf_private.device, "no more space left\n");
    + dev_err(hy_drv_priv->dev, "no more space left\n");
    return -1;
    }

    /* composing a message to the importer */
    - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]);
    + hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT, &op[0]);

    - ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true);
    + ret = ops->send_req(exported->rdomid, req, true);

    kfree(req);

    @@ -132,24 +130,18 @@ static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info,

    static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
    {
    - struct ioctl_hyper_dmabuf_export_remote *export_remote_attr;
    + struct ioctl_hyper_dmabuf_export_remote *export_remote_attr =
    + (struct ioctl_hyper_dmabuf_export_remote *)data;
    struct dma_buf *dma_buf;
    struct dma_buf_attachment *attachment;
    struct sg_table *sgt;
    - struct hyper_dmabuf_pages_info *page_info;
    - struct hyper_dmabuf_sgt_info *sgt_info;
    + struct pages_info *pg_info;
    + struct exported_sgt_info *exported;
    hyper_dmabuf_id_t hid;
    int ret = 0;

    - if (!data) {
    - dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
    - return -EINVAL;
    - }
    -
    - export_remote_attr = (struct ioctl_hyper_dmabuf_export_remote *)data;
    -
    - if (hyper_dmabuf_private.domid == export_remote_attr->remote_domain) {
    - dev_err(hyper_dmabuf_private.device,
    + if (hy_drv_priv->domid == export_remote_attr->remote_domain) {
    + dev_err(hy_drv_priv->dev,
    "exporting to the same VM is not permitted\n");
    return -EINVAL;
    }
    @@ -157,7 +149,7 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
    dma_buf = dma_buf_get(export_remote_attr->dmabuf_fd);

    if (IS_ERR(dma_buf)) {
    - dev_err(hyper_dmabuf_private.device, "Cannot get dma buf\n");
    + dev_err(hy_drv_priv->dev, "Cannot get dma buf\n");
    return PTR_ERR(dma_buf);
    }

    @@ -165,69 +157,79 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
    * to the same domain and if yes and it's valid sgt_info,
    * it returns hyper_dmabuf_id of pre-exported sgt_info
    */
    - hid = hyper_dmabuf_find_hid_exported(dma_buf, export_remote_attr->remote_domain);
    + hid = hyper_dmabuf_find_hid_exported(dma_buf,
    + export_remote_attr->remote_domain);
    if (hid.id != -1) {
    - sgt_info = hyper_dmabuf_find_exported(hid);
    - if (sgt_info != NULL) {
    - if (sgt_info->valid) {
    + exported = hyper_dmabuf_find_exported(hid);
    + if (exported != NULL) {
    + if (exported->valid) {
    /*
    * Check if unexport is already scheduled for that buffer,
    * if so try to cancel it. If that will fail, buffer needs
    * to be reexport once again.
    */
    - if (sgt_info->unexport_scheduled) {
    - if (!cancel_delayed_work_sync(&sgt_info->unexport_work)) {
    + if (exported->unexport_sched) {
    + if (!cancel_delayed_work_sync(&exported->unexport)) {
    dma_buf_put(dma_buf);
    goto reexport;
    }
    - sgt_info->unexport_scheduled = 0;
    + exported->unexport_sched = false;
    }

    /* if there's any change in size of private data.
    * we reallocate space for private data with new size */
    - if (export_remote_attr->sz_priv != sgt_info->sz_priv) {
    - kfree(sgt_info->priv);
    + if (export_remote_attr->sz_priv != exported->sz_priv) {
    + kfree(exported->priv);

    /* truncating size */
    if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) {
    - sgt_info->sz_priv = MAX_SIZE_PRIV_DATA;
    + exported->sz_priv = MAX_SIZE_PRIV_DATA;
    } else {
    - sgt_info->sz_priv = export_remote_attr->sz_priv;
    + exported->sz_priv = export_remote_attr->sz_priv;
    }

    - sgt_info->priv = kcalloc(1, sgt_info->sz_priv, GFP_KERNEL);
    + exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL);

    - if(!sgt_info->priv) {
    - dev_err(hyper_dmabuf_private.device,
    - "Can't reallocate priv because there's no more space left\n");
    - hyper_dmabuf_remove_exported(sgt_info->hid);
    - hyper_dmabuf_cleanup_sgt_info(sgt_info, true);
    - kfree(sgt_info);
    + if(!exported->priv) {
    + dev_err(hy_drv_priv->dev,
    + "no more space left for priv\n");
    + hyper_dmabuf_remove_exported(exported->hid);
    + hyper_dmabuf_cleanup_sgt_info(exported, true);
    + kfree(exported);
    + dma_buf_put(dma_buf);
    return -ENOMEM;
    }
    }

    /* update private data in sgt_info with new ones */
    - copy_from_user(sgt_info->priv, export_remote_attr->priv, sgt_info->sz_priv);
    -
    - /* send an export msg for updating priv in importer */
    - ret = hyper_dmabuf_send_export_msg(sgt_info, NULL);
    -
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device, "Failed to send a new private data\n");
    + ret = copy_from_user(exported->priv, export_remote_attr->priv,
    + exported->sz_priv);
    + if (ret) {
    + dev_err(hy_drv_priv->dev,
    + "Failed to load a new private data\n");
    + ret = -EINVAL;
    + } else {
    + /* send an export msg for updating priv in importer */
    + ret = hyper_dmabuf_send_export_msg(exported, NULL);
    +
    + if (ret < 0) {
    + dev_err(hy_drv_priv->dev,
    + "Failed to send a new private data\n");
    + ret = -EBUSY;
    + }
    }

    dma_buf_put(dma_buf);
    export_remote_attr->hid = hid;
    - return 0;
    + return ret;
    }
    }
    }

    reexport:
    - attachment = dma_buf_attach(dma_buf, hyper_dmabuf_private.device);
    + attachment = dma_buf_attach(dma_buf, hy_drv_priv->dev);
    if (IS_ERR(attachment)) {
    - dev_err(hyper_dmabuf_private.device, "Cannot get attachment\n");
    + dev_err(hy_drv_priv->dev, "Cannot get attachment\n");
    ret = PTR_ERR(attachment);
    goto fail_attach;
    }
    @@ -235,154 +237,165 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
    sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL);

    if (IS_ERR(sgt)) {
    - dev_err(hyper_dmabuf_private.device, "Cannot map attachment\n");
    + dev_err(hy_drv_priv->dev, "Cannot map attachment\n");
    ret = PTR_ERR(sgt);
    goto fail_map_attachment;
    }

    - sgt_info = kcalloc(1, sizeof(*sgt_info), GFP_KERNEL);
    + exported = kcalloc(1, sizeof(*exported), GFP_KERNEL);

    - if(!sgt_info) {
    - dev_err(hyper_dmabuf_private.device, "no more space left\n");
    + if(!exported) {
    + dev_err(hy_drv_priv->dev, "no more space left\n");
    ret = -ENOMEM;
    goto fail_sgt_info_creation;
    }

    /* possible truncation */
    if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) {
    - sgt_info->sz_priv = MAX_SIZE_PRIV_DATA;
    + exported->sz_priv = MAX_SIZE_PRIV_DATA;
    } else {
    - sgt_info->sz_priv = export_remote_attr->sz_priv;
    + exported->sz_priv = export_remote_attr->sz_priv;
    }

    /* creating buffer for private data of buffer */
    - if(sgt_info->sz_priv != 0) {
    - sgt_info->priv = kcalloc(1, sgt_info->sz_priv, GFP_KERNEL);
    + if(exported->sz_priv != 0) {
    + exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL);

    - if(!sgt_info->priv) {
    - dev_err(hyper_dmabuf_private.device, "no more space left\n");
    + if(!exported->priv) {
    + dev_err(hy_drv_priv->dev, "no more space left\n");
    ret = -ENOMEM;
    goto fail_priv_creation;
    }
    } else {
    - dev_err(hyper_dmabuf_private.device, "size is 0\n");
    + dev_err(hy_drv_priv->dev, "size is 0\n");
    }

    - sgt_info->hid = hyper_dmabuf_get_hid();
    + exported->hid = hyper_dmabuf_get_hid();

    /* no more exported dmabuf allowed */
    - if(sgt_info->hid.id == -1) {
    - dev_err(hyper_dmabuf_private.device,
    + if(exported->hid.id == -1) {
    + dev_err(hy_drv_priv->dev,
    "exceeds allowed number of dmabuf to be exported\n");
    ret = -ENOMEM;
    goto fail_sgt_info_creation;
    }

    - /* TODO: We might need to consider using port number on event channel? */
    - sgt_info->hyper_dmabuf_rdomain = export_remote_attr->remote_domain;
    - sgt_info->dma_buf = dma_buf;
    - sgt_info->valid = 1;
    + exported->rdomid = export_remote_attr->remote_domain;
    + exported->dma_buf = dma_buf;
    + exported->valid = true;

    - sgt_info->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL);
    - if (!sgt_info->active_sgts) {
    - dev_err(hyper_dmabuf_private.device, "no more space left\n");
    + exported->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL);
    + if (!exported->active_sgts) {
    + dev_err(hy_drv_priv->dev, "no more space left\n");
    ret = -ENOMEM;
    goto fail_map_active_sgts;
    }

    - sgt_info->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL);
    - if (!sgt_info->active_attached) {
    - dev_err(hyper_dmabuf_private.device, "no more space left\n");
    + exported->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL);
    + if (!exported->active_attached) {
    + dev_err(hy_drv_priv->dev, "no more space left\n");
    ret = -ENOMEM;
    goto fail_map_active_attached;
    }

    - sgt_info->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL);
    - if (!sgt_info->va_kmapped) {
    - dev_err(hyper_dmabuf_private.device, "no more space left\n");
    + exported->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL);
    + if (!exported->va_kmapped) {
    + dev_err(hy_drv_priv->dev, "no more space left\n");
    ret = -ENOMEM;
    goto fail_map_va_kmapped;
    }

    - sgt_info->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL);
    - if (!sgt_info->va_vmapped) {
    - dev_err(hyper_dmabuf_private.device, "no more space left\n");
    + exported->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL);
    + if (!exported->va_vmapped) {
    + dev_err(hy_drv_priv->dev, "no more space left\n");
    ret = -ENOMEM;
    goto fail_map_va_vmapped;
    }

    - sgt_info->active_sgts->sgt = sgt;
    - sgt_info->active_attached->attach = attachment;
    - sgt_info->va_kmapped->vaddr = NULL;
    - sgt_info->va_vmapped->vaddr = NULL;
    + exported->active_sgts->sgt = sgt;
    + exported->active_attached->attach = attachment;
    + exported->va_kmapped->vaddr = NULL;
    + exported->va_vmapped->vaddr = NULL;

    /* initialize list of sgt, attachment and vaddr for dmabuf sync
    * via shadow dma-buf
    */
    - INIT_LIST_HEAD(&sgt_info->active_sgts->list);
    - INIT_LIST_HEAD(&sgt_info->active_attached->list);
    - INIT_LIST_HEAD(&sgt_info->va_kmapped->list);
    - INIT_LIST_HEAD(&sgt_info->va_vmapped->list);
    + INIT_LIST_HEAD(&exported->active_sgts->list);
    + INIT_LIST_HEAD(&exported->active_attached->list);
    + INIT_LIST_HEAD(&exported->va_kmapped->list);
    + INIT_LIST_HEAD(&exported->va_vmapped->list);

    /* copy private data to sgt_info */
    - copy_from_user(sgt_info->priv, export_remote_attr->priv, sgt_info->sz_priv);
    + ret = copy_from_user(exported->priv, export_remote_attr->priv,
    + exported->sz_priv);

    - page_info = hyper_dmabuf_ext_pgs(sgt);
    - if (!page_info) {
    - dev_err(hyper_dmabuf_private.device, "failed to construct page_info\n");
    + if (ret) {
    + dev_err(hy_drv_priv->dev,
    + "failed to load private data\n");
    + ret = -EINVAL;
    goto fail_export;
    }

    - sgt_info->nents = page_info->nents;
    + pg_info = hyper_dmabuf_ext_pgs(sgt);
    + if (!pg_info) {
    + dev_err(hy_drv_priv->dev,
    + "failed to construct pg_info\n");
    + ret = -ENOMEM;
    + goto fail_export;
    + }
    +
    + exported->nents = pg_info->nents;

    /* now register it to export list */
    - hyper_dmabuf_register_exported(sgt_info);
    + hyper_dmabuf_register_exported(exported);

    - export_remote_attr->hid = sgt_info->hid;
    + export_remote_attr->hid = exported->hid;

    - ret = hyper_dmabuf_send_export_msg(sgt_info, page_info);
    + ret = hyper_dmabuf_send_export_msg(exported, pg_info);

    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device, "failed to send out the export request\n");
    + dev_err(hy_drv_priv->dev,
    + "failed to send out the export request\n");
    goto fail_send_request;
    }

    - /* free page_info */
    - kfree(page_info->pages);
    - kfree(page_info);
    + /* free pg_info */
    + kfree(pg_info->pgs);
    + kfree(pg_info);

    - sgt_info->filp = filp;
    + exported->filp = filp;

    return ret;

    /* Clean-up if error occurs */

    fail_send_request:
    - hyper_dmabuf_remove_exported(sgt_info->hid);
    + hyper_dmabuf_remove_exported(exported->hid);

    - /* free page_info */
    - kfree(page_info->pages);
    - kfree(page_info);
    + /* free pg_info */
    + kfree(pg_info->pgs);
    + kfree(pg_info);

    fail_export:
    - kfree(sgt_info->va_vmapped);
    + kfree(exported->va_vmapped);

    fail_map_va_vmapped:
    - kfree(sgt_info->va_kmapped);
    + kfree(exported->va_kmapped);

    fail_map_va_kmapped:
    - kfree(sgt_info->active_attached);
    + kfree(exported->active_attached);

    fail_map_active_attached:
    - kfree(sgt_info->active_sgts);
    - kfree(sgt_info->priv);
    + kfree(exported->active_sgts);
    + kfree(exported->priv);

    fail_priv_creation:
    - kfree(sgt_info);
    + kfree(exported);

    fail_map_active_sgts:
    fail_sgt_info_creation:
    - dma_buf_unmap_attachment(attachment, sgt, DMA_BIDIRECTIONAL);
    + dma_buf_unmap_attachment(attachment, sgt,
    + DMA_BIDIRECTIONAL);

    fail_map_attachment:
    dma_buf_detach(dma_buf, attachment);
    @@ -395,143 +408,136 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)

    static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
    {
    - struct ioctl_hyper_dmabuf_export_fd *export_fd_attr;
    - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct ioctl_hyper_dmabuf_export_fd *export_fd_attr =
    + (struct ioctl_hyper_dmabuf_export_fd *)data;
    + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
    + struct imported_sgt_info *imported;
    struct hyper_dmabuf_req *req;
    - struct page **data_pages;
    - int operands[4];
    + struct page **data_pgs;
    + int op[4];
    int i;
    int ret = 0;

    - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
    -
    - if (!data) {
    - dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
    - return -EINVAL;
    - }
    -
    - export_fd_attr = (struct ioctl_hyper_dmabuf_export_fd *)data;
    + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);

    /* look for dmabuf for the id */
    - sgt_info = hyper_dmabuf_find_imported(export_fd_attr->hid);
    + imported = hyper_dmabuf_find_imported(export_fd_attr->hid);

    /* can't find sgt from the table */
    - if (!sgt_info) {
    - dev_err(hyper_dmabuf_private.device, "can't find the entry\n");
    + if (!imported) {
    + dev_err(hy_drv_priv->dev, "can't find the entry\n");
    return -ENOENT;
    }

    - mutex_lock(&hyper_dmabuf_private.lock);
    + mutex_lock(&hy_drv_priv->lock);

    - sgt_info->num_importers++;
    + imported->importers++;

    /* send notification for export_fd to exporter */
    - operands[0] = sgt_info->hid.id;
    + op[0] = imported->hid.id;

    for (i=0; i<3; i++)
    - operands[i+1] = sgt_info->hid.rng_key[i];
    + op[i+1] = imported->hid.rng_key[i];

    - dev_dbg(hyper_dmabuf_private.device, "Exporting fd of buffer {id:%d key:%d %d %d}\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + dev_dbg(hy_drv_priv->dev, "Exporting fd of buffer {id:%d key:%d %d %d}\n",
    + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
    + imported->hid.rng_key[2]);

    req = kcalloc(1, sizeof(*req), GFP_KERNEL);

    if (!req) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return -ENOMEM;
    }

    - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD, &operands[0]);
    + hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD, &op[0]);

    - ret = ops->send_req(HYPER_DMABUF_DOM_ID(sgt_info->hid), req, true);
    + ret = ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, true);

    if (ret < 0) {
    /* in case of timeout other end eventually will receive request, so we need to undo it */
    - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operands[0]);
    - ops->send_req(operands[0], req, false);
    + hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]);
    + ops->send_req(op[0], req, false);
    kfree(req);
    - dev_err(hyper_dmabuf_private.device, "Failed to create sgt or notify exporter\n");
    - sgt_info->num_importers--;
    - mutex_unlock(&hyper_dmabuf_private.lock);
    + dev_err(hy_drv_priv->dev, "Failed to create sgt or notify exporter\n");
    + imported->importers--;
    + mutex_unlock(&hy_drv_priv->lock);
    return ret;
    }

    kfree(req);

    if (ret == HYPER_DMABUF_REQ_ERROR) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "Buffer invalid {id:%d key:%d %d %d}, cannot import\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
    + imported->hid.rng_key[2]);

    - sgt_info->num_importers--;
    - mutex_unlock(&hyper_dmabuf_private.lock);
    + imported->importers--;
    + mutex_unlock(&hy_drv_priv->lock);
    return -EINVAL;
    } else {
    - dev_dbg(hyper_dmabuf_private.device, "Can import buffer {id:%d key:%d %d %d}\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + dev_dbg(hy_drv_priv->dev, "Can import buffer {id:%d key:%d %d %d}\n",
    + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
    + imported->hid.rng_key[2]);

    ret = 0;
    }

    - dev_dbg(hyper_dmabuf_private.device,
    - "%s Found buffer gref %d off %d last len %d nents %d domain %d\n", __func__,
    - sgt_info->ref_handle, sgt_info->frst_ofst,
    - sgt_info->last_len, sgt_info->nents,
    - HYPER_DMABUF_DOM_ID(sgt_info->hid));
    + dev_dbg(hy_drv_priv->dev,
    + "%s Found buffer gref %d off %d last len %d nents %d domain %d\n",
    + __func__, imported->ref_handle, imported->frst_ofst,
    + imported->last_len, imported->nents, HYPER_DMABUF_DOM_ID(imported->hid));

    - if (!sgt_info->sgt) {
    - dev_dbg(hyper_dmabuf_private.device,
    + if (!imported->sgt) {
    + dev_dbg(hy_drv_priv->dev,
    "%s buffer {id:%d key:%d %d %d} pages not mapped yet\n", __func__,
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
    + imported->hid.rng_key[2]);

    - data_pages = ops->map_shared_pages(sgt_info->ref_handle,
    - HYPER_DMABUF_DOM_ID(sgt_info->hid),
    - sgt_info->nents,
    - &sgt_info->refs_info);
    + data_pgs = ops->map_shared_pages(imported->ref_handle,
    + HYPER_DMABUF_DOM_ID(imported->hid),
    + imported->nents,
    + &imported->refs_info);

    - if (!data_pages) {
    - dev_err(hyper_dmabuf_private.device,
    + if (!data_pgs) {
    + dev_err(hy_drv_priv->dev,
    "Cannot map pages of buffer {id:%d key:%d %d %d}\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
    + imported->hid.rng_key[2]);

    - sgt_info->num_importers--;
    + imported->importers--;
    req = kcalloc(1, sizeof(*req), GFP_KERNEL);

    if (!req) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No more space left\n");
    return -ENOMEM;
    }

    - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operands[0]);
    - ops->send_req(HYPER_DMABUF_DOM_ID(sgt_info->hid), req, false);
    + hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]);
    + ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, false);
    kfree(req);
    - mutex_unlock(&hyper_dmabuf_private.lock);
    + mutex_unlock(&hy_drv_priv->lock);
    return -EINVAL;
    }

    - sgt_info->sgt = hyper_dmabuf_create_sgt(data_pages, sgt_info->frst_ofst,
    - sgt_info->last_len, sgt_info->nents);
    + imported->sgt = hyper_dmabuf_create_sgt(data_pgs, imported->frst_ofst,
    + imported->last_len, imported->nents);

    }

    - export_fd_attr->fd = hyper_dmabuf_export_fd(sgt_info, export_fd_attr->flags);
    + export_fd_attr->fd = hyper_dmabuf_export_fd(imported, export_fd_attr->flags);

    if (export_fd_attr->fd < 0) {
    /* fail to get fd */
    ret = export_fd_attr->fd;
    }

    - mutex_unlock(&hyper_dmabuf_private.lock);
    + mutex_unlock(&hy_drv_priv->lock);

    - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
    return ret;
    }

    @@ -541,50 +547,51 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
    static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
    {
    struct hyper_dmabuf_req *req;
    + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
    + struct exported_sgt_info *exported =
    + container_of(work, struct exported_sgt_info, unexport.work);
    + int op[4];
    int i, ret;
    - int operands[4];
    - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
    - struct hyper_dmabuf_sgt_info *sgt_info =
    - container_of(work, struct hyper_dmabuf_sgt_info, unexport_work.work);

    - if (!sgt_info)
    + if (!exported)
    return;

    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "Marking buffer {id:%d key:%d %d %d} as invalid\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + exported->hid.id, exported->hid.rng_key[0],
    + exported->hid.rng_key[1], exported->hid.rng_key[2]);

    /* no longer valid */
    - sgt_info->valid = 0;
    + exported->valid = false;

    req = kcalloc(1, sizeof(*req), GFP_KERNEL);

    if (!req) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return;
    }

    - operands[0] = sgt_info->hid.id;
    + op[0] = exported->hid.id;

    for (i=0; i<3; i++)
    - operands[i+1] = sgt_info->hid.rng_key[i];
    + op[i+1] = exported->hid.rng_key[i];

    - hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &operands[0]);
    + hyper_dmabuf_create_req(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &op[0]);

    - /* Now send unexport request to remote domain, marking that buffer should not be used anymore */
    - ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true);
    + /* Now send unexport request to remote domain, marking
    + * that buffer should not be used anymore */
    + ret = ops->send_req(exported->rdomid, req, true);
    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "unexport message for buffer {id:%d key:%d %d %d} failed\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + exported->hid.id, exported->hid.rng_key[0],
    + exported->hid.rng_key[1], exported->hid.rng_key[2]);
    }

    /* free msg */
    kfree(req);
    - sgt_info->unexport_scheduled = 0;
    + exported->unexport_sched = false;

    /*
    * Immediately clean-up if it has never been exported by importer
    @@ -593,104 +600,94 @@ static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
    * is called (importer does this only when there's no
    * no consumer of locally exported FDs)
    */
    - if (!sgt_info->importer_exported) {
    - dev_dbg(hyper_dmabuf_private.device,
    + if (exported->active == 0) {
    + dev_dbg(hy_drv_priv->dev,
    "claning up buffer {id:%d key:%d %d %d} completly\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + exported->hid.id, exported->hid.rng_key[0],
    + exported->hid.rng_key[1], exported->hid.rng_key[2]);
    +
    + hyper_dmabuf_cleanup_sgt_info(exported, false);
    + hyper_dmabuf_remove_exported(exported->hid);

    - hyper_dmabuf_cleanup_sgt_info(sgt_info, false);
    - hyper_dmabuf_remove_exported(sgt_info->hid);
    /* register hyper_dmabuf_id to the list for reuse */
    - store_reusable_hid(sgt_info->hid);
    + store_reusable_hid(exported->hid);

    - if (sgt_info->sz_priv > 0 && !sgt_info->priv)
    - kfree(sgt_info->priv);
    + if (exported->sz_priv > 0 && !exported->priv)
    + kfree(exported->priv);

    - kfree(sgt_info);
    + kfree(exported);
    }
    }

    -/* Schedules unexport of dmabuf.
    +/* Schedule unexport of dmabuf.
    */
    -static int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data)
    +int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data)
    {
    - struct ioctl_hyper_dmabuf_unexport *unexport_attr;
    - struct hyper_dmabuf_sgt_info *sgt_info;
    + struct ioctl_hyper_dmabuf_unexport *unexport_attr =
    + (struct ioctl_hyper_dmabuf_unexport *)data;
    + struct exported_sgt_info *exported;

    - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
    -
    - if (!data) {
    - dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
    - return -EINVAL;
    - }
    -
    - unexport_attr = (struct ioctl_hyper_dmabuf_unexport *)data;
    + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);

    /* find dmabuf in export list */
    - sgt_info = hyper_dmabuf_find_exported(unexport_attr->hid);
    + exported = hyper_dmabuf_find_exported(unexport_attr->hid);

    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "scheduling unexport of buffer {id:%d key:%d %d %d}\n",
    unexport_attr->hid.id, unexport_attr->hid.rng_key[0],
    unexport_attr->hid.rng_key[1], unexport_attr->hid.rng_key[2]);

    /* failed to find corresponding entry in export list */
    - if (sgt_info == NULL) {
    + if (exported == NULL) {
    unexport_attr->status = -ENOENT;
    return -ENOENT;
    }

    - if (sgt_info->unexport_scheduled)
    + if (exported->unexport_sched)
    return 0;

    - sgt_info->unexport_scheduled = 1;
    - INIT_DELAYED_WORK(&sgt_info->unexport_work, hyper_dmabuf_delayed_unexport);
    - schedule_delayed_work(&sgt_info->unexport_work,
    + exported->unexport_sched = true;
    + INIT_DELAYED_WORK(&exported->unexport,
    + hyper_dmabuf_delayed_unexport);
    + schedule_delayed_work(&exported->unexport,
    msecs_to_jiffies(unexport_attr->delay_ms));

    - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
    return 0;
    }

    static int hyper_dmabuf_query_ioctl(struct file *filp, void *data)
    {
    - struct ioctl_hyper_dmabuf_query *query_attr;
    - struct hyper_dmabuf_sgt_info *sgt_info = NULL;
    - struct hyper_dmabuf_imported_sgt_info *imported_sgt_info = NULL;
    + struct ioctl_hyper_dmabuf_query *query_attr =
    + (struct ioctl_hyper_dmabuf_query *)data;
    + struct exported_sgt_info *exported = NULL;
    + struct imported_sgt_info *imported = NULL;
    int ret = 0;

    - if (!data) {
    - dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
    - return -EINVAL;
    - }
    -
    - query_attr = (struct ioctl_hyper_dmabuf_query *)data;
    -
    - if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hyper_dmabuf_private.domid) {
    + if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hy_drv_priv->domid) {
    /* query for exported dmabuf */
    - sgt_info = hyper_dmabuf_find_exported(query_attr->hid);
    - if (sgt_info) {
    - ret = hyper_dmabuf_query_exported(sgt_info,
    + exported = hyper_dmabuf_find_exported(query_attr->hid);
    + if (exported) {
    + ret = hyper_dmabuf_query_exported(exported,
    query_attr->item, &query_attr->info);
    } else {
    - dev_err(hyper_dmabuf_private.device,
    - "DMA BUF {id:%d key:%d %d %d} can't be found in the export list\n",
    - query_attr->hid.id, query_attr->hid.rng_key[0], query_attr->hid.rng_key[1],
    - query_attr->hid.rng_key[2]);
    + dev_err(hy_drv_priv->dev,
    + "DMA BUF {id:%d key:%d %d %d} not in the export list\n",
    + query_attr->hid.id, query_attr->hid.rng_key[0],
    + query_attr->hid.rng_key[1], query_attr->hid.rng_key[2]);
    return -ENOENT;
    }
    } else {
    /* query for imported dmabuf */
    - imported_sgt_info = hyper_dmabuf_find_imported(query_attr->hid);
    - if (imported_sgt_info) {
    - ret = hyper_dmabuf_query_imported(imported_sgt_info,
    - query_attr->item, &query_attr->info);
    + imported = hyper_dmabuf_find_imported(query_attr->hid);
    + if (imported) {
    + ret = hyper_dmabuf_query_imported(imported, query_attr->item,
    + &query_attr->info);
    } else {
    - dev_err(hyper_dmabuf_private.device,
    - "DMA BUF {id:%d key:%d %d %d} can't be found in the imported list\n",
    - query_attr->hid.id, query_attr->hid.rng_key[0], query_attr->hid.rng_key[1],
    - query_attr->hid.rng_key[2]);
    + dev_err(hy_drv_priv->dev,
    + "DMA BUF {id:%d key:%d %d %d} not in the imported list\n",
    + query_attr->hid.id, query_attr->hid.rng_key[0],
    + query_attr->hid.rng_key[1], query_attr->hid.rng_key[2]);
    return -ENOENT;
    }
    }
    @@ -698,28 +695,6 @@ static int hyper_dmabuf_query_ioctl(struct file *filp, void *data)
    return ret;
    }

    -void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* sgt_info,
    - void *attr)
    -{
    - struct ioctl_hyper_dmabuf_unexport unexport_attr;
    - struct file *filp = (struct file*) attr;
    -
    - if (!filp || !sgt_info)
    - return;
    -
    - if (sgt_info->filp == filp) {
    - dev_dbg(hyper_dmabuf_private.device,
    - "Executing emergency release of buffer {id:%d key:%d %d %d}\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0],
    - sgt_info->hid.rng_key[1], sgt_info->hid.rng_key[2]);
    -
    - unexport_attr.hid = sgt_info->hid;
    - unexport_attr.delay_ms = 0;
    -
    - hyper_dmabuf_unexport_ioctl(filp, &unexport_attr);
    - }
    -}
    -
    const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = {
    HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_TX_CH_SETUP, hyper_dmabuf_tx_ch_setup_ioctl, 0),
    HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_RX_CH_SETUP, hyper_dmabuf_rx_ch_setup_ioctl, 0),
    @@ -739,7 +714,7 @@ long hyper_dmabuf_ioctl(struct file *filp,
    char *kdata;

    if (nr > ARRAY_SIZE(hyper_dmabuf_ioctls)) {
    - dev_err(hyper_dmabuf_private.device, "invalid ioctl\n");
    + dev_err(hy_drv_priv->dev, "invalid ioctl\n");
    return -EINVAL;
    }

    @@ -748,18 +723,18 @@ long hyper_dmabuf_ioctl(struct file *filp,
    func = ioctl->func;

    if (unlikely(!func)) {
    - dev_err(hyper_dmabuf_private.device, "no function\n");
    + dev_err(hy_drv_priv->dev, "no function\n");
    return -EINVAL;
    }

    kdata = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
    if (!kdata) {
    - dev_err(hyper_dmabuf_private.device, "no memory\n");
    + dev_err(hy_drv_priv->dev, "no memory\n");
    return -ENOMEM;
    }

    if (copy_from_user(kdata, (void __user *)param, _IOC_SIZE(cmd)) != 0) {
    - dev_err(hyper_dmabuf_private.device, "failed to copy from user arguments\n");
    + dev_err(hy_drv_priv->dev, "failed to copy from user arguments\n");
    ret = -EFAULT;
    goto ioctl_error;
    }
    @@ -767,7 +742,7 @@ long hyper_dmabuf_ioctl(struct file *filp,
    ret = func(filp, kdata);

    if (copy_to_user((void __user *)param, kdata, _IOC_SIZE(cmd)) != 0) {
    - dev_err(hyper_dmabuf_private.device, "failed to copy to user arguments\n");
    + dev_err(hy_drv_priv->dev, "failed to copy to user arguments\n");
    ret = -EFAULT;
    goto ioctl_error;
    }
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
    index ebfbb84..3e9470a 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
    @@ -42,4 +42,6 @@ struct hyper_dmabuf_ioctl_desc {
    .name = #ioctl \
    }

    +int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data);
    +
    #endif //__HYPER_DMABUF_IOCTL_H__
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
    index eaef2c1..1b3745e 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
    @@ -39,24 +39,22 @@
    #include "hyper_dmabuf_id.h"
    #include "hyper_dmabuf_event.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    DECLARE_HASHTABLE(hyper_dmabuf_hash_imported, MAX_ENTRY_IMPORTED);
    DECLARE_HASHTABLE(hyper_dmabuf_hash_exported, MAX_ENTRY_EXPORTED);

    #ifdef CONFIG_HYPER_DMABUF_SYSFS
    static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attribute *attr, char *buf)
    {
    - struct hyper_dmabuf_info_entry_imported *info_entry;
    + struct list_entry_imported *info_entry;
    int bkt;
    ssize_t count = 0;
    size_t total = 0;

    hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node) {
    - hyper_dmabuf_id_t hid = info_entry->info->hid;
    - int nents = info_entry->info->nents;
    - bool valid = info_entry->info->valid;
    - int num_importers = info_entry->info->num_importers;
    + hyper_dmabuf_id_t hid = info_entry->imported->hid;
    + int nents = info_entry->imported->nents;
    + bool valid = info_entry->imported->valid;
    + int num_importers = info_entry->imported->importers;
    total += nents;
    count += scnprintf(buf + count, PAGE_SIZE - count,
    "hid:{id:%d keys:%d %d %d}, nents:%d, v:%c, numi:%d\n",
    @@ -71,16 +69,16 @@ static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attr

    static ssize_t hyper_dmabuf_exported_show(struct device *drv, struct device_attribute *attr, char *buf)
    {
    - struct hyper_dmabuf_info_entry_exported *info_entry;
    + struct list_entry_exported *info_entry;
    int bkt;
    ssize_t count = 0;
    size_t total = 0;

    hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node) {
    - hyper_dmabuf_id_t hid = info_entry->info->hid;
    - int nents = info_entry->info->nents;
    - bool valid = info_entry->info->valid;
    - int importer_exported = info_entry->info->importer_exported;
    + hyper_dmabuf_id_t hid = info_entry->exported->hid;
    + int nents = info_entry->exported->nents;
    + bool valid = info_entry->exported->valid;
    + int importer_exported = info_entry->exported->active;
    total += nents;
    count += scnprintf(buf + count, PAGE_SIZE - count,
    "hid:{hid:%d keys:%d %d %d}, nents:%d, v:%c, ie:%d\n",
    @@ -135,57 +133,57 @@ int hyper_dmabuf_table_destroy()
    return 0;
    }

    -int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info)
    +int hyper_dmabuf_register_exported(struct exported_sgt_info *exported)
    {
    - struct hyper_dmabuf_info_entry_exported *info_entry;
    + struct list_entry_exported *info_entry;

    info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);

    if (!info_entry) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return -ENOMEM;
    }

    - info_entry->info = info;
    + info_entry->exported = exported;

    hash_add(hyper_dmabuf_hash_exported, &info_entry->node,
    - info_entry->info->hid.id);
    + info_entry->exported->hid.id);

    return 0;
    }

    -int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info)
    +int hyper_dmabuf_register_imported(struct imported_sgt_info* imported)
    {
    - struct hyper_dmabuf_info_entry_imported *info_entry;
    + struct list_entry_imported *info_entry;

    info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);

    if (!info_entry) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return -ENOMEM;
    }

    - info_entry->info = info;
    + info_entry->imported = imported;

    hash_add(hyper_dmabuf_hash_imported, &info_entry->node,
    - info_entry->info->hid.id);
    + info_entry->imported->hid.id);

    return 0;
    }

    -struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
    +struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
    {
    - struct hyper_dmabuf_info_entry_exported *info_entry;
    + struct list_entry_exported *info_entry;
    int bkt;

    hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
    /* checking hid.id first */
    - if(info_entry->info->hid.id == hid.id) {
    + if(info_entry->exported->hid.id == hid.id) {
    /* then key is compared */
    - if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid))
    - return info_entry->info;
    + if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid))
    + return info_entry->exported;
    /* if key is unmatched, given HID is invalid, so returning NULL */
    else
    break;
    @@ -197,29 +195,29 @@ struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
    /* search for pre-exported sgt and return id of it if it exist */
    hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid)
    {
    - struct hyper_dmabuf_info_entry_exported *info_entry;
    + struct list_entry_exported *info_entry;
    hyper_dmabuf_id_t hid = {-1, {0, 0, 0}};
    int bkt;

    hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
    - if(info_entry->info->dma_buf == dmabuf &&
    - info_entry->info->hyper_dmabuf_rdomain == domid)
    - return info_entry->info->hid;
    + if(info_entry->exported->dma_buf == dmabuf &&
    + info_entry->exported->rdomid == domid)
    + return info_entry->exported->hid;

    return hid;
    }

    -struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid)
    +struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid)
    {
    - struct hyper_dmabuf_info_entry_imported *info_entry;
    + struct list_entry_imported *info_entry;
    int bkt;

    hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node)
    /* checking hid.id first */
    - if(info_entry->info->hid.id == hid.id) {
    + if(info_entry->imported->hid.id == hid.id) {
    /* then key is compared */
    - if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid))
    - return info_entry->info;
    + if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid))
    + return info_entry->imported;
    /* if key is unmatched, given HID is invalid, so returning NULL */
    else {
    break;
    @@ -231,14 +229,14 @@ struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_i

    int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid)
    {
    - struct hyper_dmabuf_info_entry_exported *info_entry;
    + struct list_entry_exported *info_entry;
    int bkt;

    hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
    /* checking hid.id first */
    - if(info_entry->info->hid.id == hid.id) {
    + if(info_entry->exported->hid.id == hid.id) {
    /* then key is compared */
    - if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) {
    + if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid)) {
    hash_del(&info_entry->node);
    kfree(info_entry);
    return 0;
    @@ -252,14 +250,14 @@ int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid)

    int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid)
    {
    - struct hyper_dmabuf_info_entry_imported *info_entry;
    + struct list_entry_imported *info_entry;
    int bkt;

    hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node)
    /* checking hid.id first */
    - if(info_entry->info->hid.id == hid.id) {
    + if(info_entry->imported->hid.id == hid.id) {
    /* then key is compared */
    - if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) {
    + if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid)) {
    hash_del(&info_entry->node);
    kfree(info_entry);
    return 0;
    @@ -272,15 +270,15 @@ int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid)
    }

    void hyper_dmabuf_foreach_exported(
    - void (*func)(struct hyper_dmabuf_sgt_info *, void *attr),
    + void (*func)(struct exported_sgt_info *, void *attr),
    void *attr)
    {
    - struct hyper_dmabuf_info_entry_exported *info_entry;
    + struct list_entry_exported *info_entry;
    struct hlist_node *tmp;
    int bkt;

    hash_for_each_safe(hyper_dmabuf_hash_exported, bkt, tmp,
    info_entry, node) {
    - func(info_entry->info, attr);
    + func(info_entry->exported, attr);
    }
    }
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
    index 8f64db8..d5c17ef 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
    @@ -32,13 +32,13 @@
    /* number of bits to be used for imported dmabufs hash table */
    #define MAX_ENTRY_IMPORTED 7

    -struct hyper_dmabuf_info_entry_exported {
    - struct hyper_dmabuf_sgt_info *info;
    +struct list_entry_exported {
    + struct exported_sgt_info *exported;
    struct hlist_node node;
    };

    -struct hyper_dmabuf_info_entry_imported {
    - struct hyper_dmabuf_imported_sgt_info *info;
    +struct list_entry_imported {
    + struct imported_sgt_info *imported;
    struct hlist_node node;
    };

    @@ -46,23 +46,23 @@ int hyper_dmabuf_table_init(void);

    int hyper_dmabuf_table_destroy(void);

    -int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info);
    +int hyper_dmabuf_register_exported(struct exported_sgt_info *info);

    /* search for pre-exported sgt and return id of it if it exist */
    hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid);

    -int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info);
    +int hyper_dmabuf_register_imported(struct imported_sgt_info* info);

    -struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid);
    +struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid);

    -struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid);
    +struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid);

    int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid);

    int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid);

    void hyper_dmabuf_foreach_exported(
    - void (*func)(struct hyper_dmabuf_sgt_info *, void *attr),
    + void (*func)(struct exported_sgt_info *, void *attr),
    void *attr);

    int hyper_dmabuf_register_sysfs(struct device *dev);
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
    index ec37c3b..907f76e 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
    @@ -31,7 +31,6 @@
    #include <linux/module.h>
    #include <linux/slab.h>
    #include <linux/dma-buf.h>
    -#include <xen/grant_table.h>
    #include <linux/workqueue.h>
    #include "hyper_dmabuf_msg.h"
    #include "hyper_dmabuf_drv.h"
    @@ -39,58 +38,56 @@
    #include "hyper_dmabuf_event.h"
    #include "hyper_dmabuf_list.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    struct cmd_process {
    struct work_struct work;
    struct hyper_dmabuf_req *rq;
    int domid;
    };

    -void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
    - enum hyper_dmabuf_command command, int *operands)
    +void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
    + enum hyper_dmabuf_command cmd, int *op)
    {
    int i;

    - req->status = HYPER_DMABUF_REQ_NOT_RESPONDED;
    - req->command = command;
    + req->stat = HYPER_DMABUF_REQ_NOT_RESPONDED;
    + req->cmd = cmd;

    - switch(command) {
    + switch(cmd) {
    /* as exporter, commands to importer */
    case HYPER_DMABUF_EXPORT:
    /* exporting pages for dmabuf */
    /* command : HYPER_DMABUF_EXPORT,
    - * operands0~3 : hyper_dmabuf_id
    - * operands4 : number of pages to be shared
    - * operands5 : offset of data in the first page
    - * operands6 : length of data in the last page
    - * operands7 : top-level reference number for shared pages
    - * operands8 : size of private data (from operands9)
    - * operands9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
    + * op0~3 : hyper_dmabuf_id
    + * op4 : number of pages to be shared
    + * op5 : offset of data in the first page
    + * op6 : length of data in the last page
    + * op7 : top-level reference number for shared pages
    + * op8 : size of private data (from op9)
    + * op9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
    */

    - memcpy(&req->operands[0], &operands[0], 9 * sizeof(int) + operands[8]);
    + memcpy(&req->op[0], &op[0], 9 * sizeof(int) + op[8]);
    break;

    case HYPER_DMABUF_NOTIFY_UNEXPORT:
    /* destroy sg_list for hyper_dmabuf_id on remote side */
    /* command : DMABUF_DESTROY,
    - * operands0~3 : hyper_dmabuf_id_t hid
    + * op0~3 : hyper_dmabuf_id_t hid
    */

    for (i=0; i < 4; i++)
    - req->operands[i] = operands[i];
    + req->op[i] = op[i];
    break;

    case HYPER_DMABUF_EXPORT_FD:
    case HYPER_DMABUF_EXPORT_FD_FAILED:
    /* dmabuf fd is being created on imported side or importing failed */
    /* command : HYPER_DMABUF_EXPORT_FD or HYPER_DMABUF_EXPORT_FD_FAILED,
    - * operands0~3 : hyper_dmabuf_id
    + * op0~3 : hyper_dmabuf_id
    */

    for (i=0; i < 4; i++)
    - req->operands[i] = operands[i];
    + req->op[i] = op[i];
    break;

    case HYPER_DMABUF_OPS_TO_REMOTE:
    @@ -103,11 +100,11 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
    /* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping
    * or unmapping for synchronization with original exporter (e.g. i915) */
    /* command : DMABUF_OPS_TO_SOURCE.
    - * operands0~3 : hyper_dmabuf_id
    - * operands4 : map(=1)/unmap(=2)/attach(=3)/detach(=4)
    + * op0~3 : hyper_dmabuf_id
    + * op4 : map(=1)/unmap(=2)/attach(=3)/detach(=4)
    */
    for (i = 0; i < 5; i++)
    - req->operands[i] = operands[i];
    + req->op[i] = op[i];
    break;

    default:
    @@ -116,9 +113,9 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
    }
    }

    -void cmd_process_work(struct work_struct *work)
    +static void cmd_process_work(struct work_struct *work)
    {
    - struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
    + struct imported_sgt_info *imported;
    struct cmd_process *proc = container_of(work, struct cmd_process, work);
    struct hyper_dmabuf_req *req;
    int domid;
    @@ -127,107 +124,107 @@ void cmd_process_work(struct work_struct *work)
    req = proc->rq;
    domid = proc->domid;

    - switch (req->command) {
    + switch (req->cmd) {
    case HYPER_DMABUF_EXPORT:
    /* exporting pages for dmabuf */
    /* command : HYPER_DMABUF_EXPORT,
    - * operands0~3 : hyper_dmabuf_id
    - * operands4 : number of pages to be shared
    - * operands5 : offset of data in the first page
    - * operands6 : length of data in the last page
    - * operands7 : top-level reference number for shared pages
    - * operands8 : size of private data (from operands9)
    - * operands9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
    + * op0~3 : hyper_dmabuf_id
    + * op4 : number of pages to be shared
    + * op5 : offset of data in the first page
    + * op6 : length of data in the last page
    + * op7 : top-level reference number for shared pages
    + * op8 : size of private data (from op9)
    + * op9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
    */

    /* if nents == 0, it means it is a message only for priv synchronization
    * for existing imported_sgt_info so not creating a new one */
    - if (req->operands[4] == 0) {
    - hyper_dmabuf_id_t exist = {req->operands[0],
    - {req->operands[1], req->operands[2],
    - req->operands[3]}};
    + if (req->op[4] == 0) {
    + hyper_dmabuf_id_t exist = {req->op[0],
    + {req->op[1], req->op[2],
    + req->op[3]}};

    - imported_sgt_info = hyper_dmabuf_find_imported(exist);
    + imported = hyper_dmabuf_find_imported(exist);

    - if (!imported_sgt_info) {
    - dev_err(hyper_dmabuf_private.device,
    + if (!imported) {
    + dev_err(hy_drv_priv->dev,
    "Can't find imported sgt_info from IMPORT_LIST\n");
    break;
    }

    /* if size of new private data is different,
    * we reallocate it. */
    - if (imported_sgt_info->sz_priv != req->operands[8]) {
    - kfree(imported_sgt_info->priv);
    - imported_sgt_info->sz_priv = req->operands[8];
    - imported_sgt_info->priv = kcalloc(1, req->operands[8], GFP_KERNEL);
    - if (!imported_sgt_info->priv) {
    - dev_err(hyper_dmabuf_private.device,
    + if (imported->sz_priv != req->op[8]) {
    + kfree(imported->priv);
    + imported->sz_priv = req->op[8];
    + imported->priv = kcalloc(1, req->op[8], GFP_KERNEL);
    + if (!imported->priv) {
    + dev_err(hy_drv_priv->dev,
    "Fail to allocate priv\n");

    /* set it invalid */
    - imported_sgt_info->valid = 0;
    + imported->valid = 0;
    break;
    }
    }

    /* updating priv data */
    - memcpy(imported_sgt_info->priv, &req->operands[9], req->operands[8]);
    + memcpy(imported->priv, &req->op[9], req->op[8]);

    #ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
    /* generating import event */
    - hyper_dmabuf_import_event(imported_sgt_info->hid);
    + hyper_dmabuf_import_event(imported->hid);
    #endif

    break;
    }

    - imported_sgt_info = kcalloc(1, sizeof(*imported_sgt_info), GFP_KERNEL);
    + imported = kcalloc(1, sizeof(*imported), GFP_KERNEL);

    - if (!imported_sgt_info) {
    - dev_err(hyper_dmabuf_private.device,
    + if (!imported) {
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    break;
    }

    - imported_sgt_info->sz_priv = req->operands[8];
    - imported_sgt_info->priv = kcalloc(1, req->operands[8], GFP_KERNEL);
    + imported->sz_priv = req->op[8];
    + imported->priv = kcalloc(1, req->op[8], GFP_KERNEL);

    - if (!imported_sgt_info->priv) {
    - dev_err(hyper_dmabuf_private.device,
    + if (!imported->priv) {
    + dev_err(hy_drv_priv->dev,
    "Fail to allocate priv\n");

    - kfree(imported_sgt_info);
    + kfree(imported);
    break;
    }

    - imported_sgt_info->hid.id = req->operands[0];
    + imported->hid.id = req->op[0];

    for (i=0; i<3; i++)
    - imported_sgt_info->hid.rng_key[i] = req->operands[i+1];
    + imported->hid.rng_key[i] = req->op[i+1];

    - imported_sgt_info->nents = req->operands[4];
    - imported_sgt_info->frst_ofst = req->operands[5];
    - imported_sgt_info->last_len = req->operands[6];
    - imported_sgt_info->ref_handle = req->operands[7];
    + imported->nents = req->op[4];
    + imported->frst_ofst = req->op[5];
    + imported->last_len = req->op[6];
    + imported->ref_handle = req->op[7];

    - dev_dbg(hyper_dmabuf_private.device, "DMABUF was exported\n");
    - dev_dbg(hyper_dmabuf_private.device, "\thid{id:%d key:%d %d %d}\n",
    - req->operands[0], req->operands[1], req->operands[2],
    - req->operands[3]);
    - dev_dbg(hyper_dmabuf_private.device, "\tnents %d\n", req->operands[4]);
    - dev_dbg(hyper_dmabuf_private.device, "\tfirst offset %d\n", req->operands[5]);
    - dev_dbg(hyper_dmabuf_private.device, "\tlast len %d\n", req->operands[6]);
    - dev_dbg(hyper_dmabuf_private.device, "\tgrefid %d\n", req->operands[7]);
    + dev_dbg(hy_drv_priv->dev, "DMABUF was exported\n");
    + dev_dbg(hy_drv_priv->dev, "\thid{id:%d key:%d %d %d}\n",
    + req->op[0], req->op[1], req->op[2],
    + req->op[3]);
    + dev_dbg(hy_drv_priv->dev, "\tnents %d\n", req->op[4]);
    + dev_dbg(hy_drv_priv->dev, "\tfirst offset %d\n", req->op[5]);
    + dev_dbg(hy_drv_priv->dev, "\tlast len %d\n", req->op[6]);
    + dev_dbg(hy_drv_priv->dev, "\tgrefid %d\n", req->op[7]);

    - memcpy(imported_sgt_info->priv, &req->operands[9], req->operands[8]);
    + memcpy(imported->priv, &req->op[9], req->op[8]);

    - imported_sgt_info->valid = 1;
    - hyper_dmabuf_register_imported(imported_sgt_info);
    + imported->valid = true;
    + hyper_dmabuf_register_imported(imported);

    #ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
    /* generating import event */
    - hyper_dmabuf_import_event(imported_sgt_info->hid);
    + hyper_dmabuf_import_event(imported->hid);
    #endif

    break;
    @@ -251,142 +248,142 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
    {
    struct cmd_process *proc;
    struct hyper_dmabuf_req *temp_req;
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    - struct hyper_dmabuf_sgt_info *exp_sgt_info;
    + struct imported_sgt_info *imported;
    + struct exported_sgt_info *exported;
    hyper_dmabuf_id_t hid;
    int ret;

    if (!req) {
    - dev_err(hyper_dmabuf_private.device, "request is NULL\n");
    + dev_err(hy_drv_priv->dev, "request is NULL\n");
    return -EINVAL;
    }

    - hid.id = req->operands[0];
    - hid.rng_key[0] = req->operands[1];
    - hid.rng_key[1] = req->operands[2];
    - hid.rng_key[2] = req->operands[3];
    + hid.id = req->op[0];
    + hid.rng_key[0] = req->op[1];
    + hid.rng_key[1] = req->op[2];
    + hid.rng_key[2] = req->op[3];

    - if ((req->command < HYPER_DMABUF_EXPORT) ||
    - (req->command > HYPER_DMABUF_OPS_TO_SOURCE)) {
    - dev_err(hyper_dmabuf_private.device, "invalid command\n");
    + if ((req->cmd < HYPER_DMABUF_EXPORT) ||
    + (req->cmd > HYPER_DMABUF_OPS_TO_SOURCE)) {
    + dev_err(hy_drv_priv->dev, "invalid command\n");
    return -EINVAL;
    }

    - req->status = HYPER_DMABUF_REQ_PROCESSED;
    + req->stat = HYPER_DMABUF_REQ_PROCESSED;

    /* HYPER_DMABUF_DESTROY requires immediate
    * follow up so can't be processed in workqueue
    */
    - if (req->command == HYPER_DMABUF_NOTIFY_UNEXPORT) {
    + if (req->cmd == HYPER_DMABUF_NOTIFY_UNEXPORT) {
    /* destroy sg_list for hyper_dmabuf_id on remote side */
    /* command : HYPER_DMABUF_NOTIFY_UNEXPORT,
    - * operands0~3 : hyper_dmabuf_id
    + * op0~3 : hyper_dmabuf_id
    */
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "%s: processing HYPER_DMABUF_NOTIFY_UNEXPORT\n", __func__);

    - sgt_info = hyper_dmabuf_find_imported(hid);
    + imported = hyper_dmabuf_find_imported(hid);

    - if (sgt_info) {
    + if (imported) {
    /* if anything is still using dma_buf */
    - if (sgt_info->num_importers) {
    + if (imported->importers) {
    /*
    * Buffer is still in use, just mark that it should
    * not be allowed to export its fd anymore.
    */
    - sgt_info->valid = 0;
    + imported->valid = false;
    } else {
    /* No one is using buffer, remove it from imported list */
    hyper_dmabuf_remove_imported(hid);
    - kfree(sgt_info);
    + kfree(imported);
    }
    } else {
    - req->status = HYPER_DMABUF_REQ_ERROR;
    + req->stat = HYPER_DMABUF_REQ_ERROR;
    }

    - return req->command;
    + return req->cmd;
    }

    /* dma buf remote synchronization */
    - if (req->command == HYPER_DMABUF_OPS_TO_SOURCE) {
    + if (req->cmd == HYPER_DMABUF_OPS_TO_SOURCE) {
    /* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping
    * or unmapping for synchronization with original exporter (e.g. i915) */

    /* command : DMABUF_OPS_TO_SOURCE.
    - * operands0~3 : hyper_dmabuf_id
    - * operands1 : enum hyper_dmabuf_ops {....}
    + * op0~3 : hyper_dmabuf_id
    + * op1 : enum hyper_dmabuf_ops {....}
    */
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "%s: HYPER_DMABUF_OPS_TO_SOURCE\n", __func__);

    - ret = hyper_dmabuf_remote_sync(hid, req->operands[4]);
    + ret = hyper_dmabuf_remote_sync(hid, req->op[4]);

    if (ret)
    - req->status = HYPER_DMABUF_REQ_ERROR;
    + req->stat = HYPER_DMABUF_REQ_ERROR;
    else
    - req->status = HYPER_DMABUF_REQ_PROCESSED;
    + req->stat = HYPER_DMABUF_REQ_PROCESSED;

    - return req->command;
    + return req->cmd;
    }

    /* synchronous dma_buf_fd export */
    - if (req->command == HYPER_DMABUF_EXPORT_FD) {
    + if (req->cmd == HYPER_DMABUF_EXPORT_FD) {
    /* find a corresponding SGT for the id */
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "Processing HYPER_DMABUF_EXPORT_FD for buffer {id:%d key:%d %d %d}\n",
    hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);

    - exp_sgt_info = hyper_dmabuf_find_exported(hid);
    + exported = hyper_dmabuf_find_exported(hid);

    - if (!exp_sgt_info) {
    - dev_err(hyper_dmabuf_private.device,
    + if (!exported) {
    + dev_err(hy_drv_priv->dev,
    "critical err: requested sgt_info can't be found for buffer {id:%d key:%d %d %d}\n",
    hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);

    - req->status = HYPER_DMABUF_REQ_ERROR;
    - } else if (!exp_sgt_info->valid) {
    - dev_dbg(hyper_dmabuf_private.device,
    + req->stat = HYPER_DMABUF_REQ_ERROR;
    + } else if (!exported->valid) {
    + dev_dbg(hy_drv_priv->dev,
    "Buffer no longer valid - cannot export fd for buffer {id:%d key:%d %d %d}\n",
    hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);

    - req->status = HYPER_DMABUF_REQ_ERROR;
    + req->stat = HYPER_DMABUF_REQ_ERROR;
    } else {
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "Buffer still valid - can export fd for buffer {id:%d key:%d %d %d}\n",
    hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);

    - exp_sgt_info->importer_exported++;
    - req->status = HYPER_DMABUF_REQ_PROCESSED;
    + exported->active++;
    + req->stat = HYPER_DMABUF_REQ_PROCESSED;
    }
    - return req->command;
    + return req->cmd;
    }

    - if (req->command == HYPER_DMABUF_EXPORT_FD_FAILED) {
    - dev_dbg(hyper_dmabuf_private.device,
    + if (req->cmd == HYPER_DMABUF_EXPORT_FD_FAILED) {
    + dev_dbg(hy_drv_priv->dev,
    "Processing HYPER_DMABUF_EXPORT_FD_FAILED for buffer {id:%d key:%d %d %d}\n",
    hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);

    - exp_sgt_info = hyper_dmabuf_find_exported(hid);
    + exported = hyper_dmabuf_find_exported(hid);

    - if (!exp_sgt_info) {
    - dev_err(hyper_dmabuf_private.device,
    + if (!exported) {
    + dev_err(hy_drv_priv->dev,
    "critical err: requested sgt_info can't be found for buffer {id:%d key:%d %d %d}\n",
    hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);

    - req->status = HYPER_DMABUF_REQ_ERROR;
    + req->stat = HYPER_DMABUF_REQ_ERROR;
    } else {
    - exp_sgt_info->importer_exported--;
    - req->status = HYPER_DMABUF_REQ_PROCESSED;
    + exported->active--;
    + req->stat = HYPER_DMABUF_REQ_PROCESSED;
    }
    - return req->command;
    + return req->cmd;
    }

    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "%s: putting request to workqueue\n", __func__);
    temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL);

    if (!temp_req) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return -ENOMEM;
    }
    @@ -396,7 +393,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
    proc = kcalloc(1, sizeof(struct cmd_process), GFP_KERNEL);

    if (!proc) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    kfree(temp_req);
    return -ENOMEM;
    @@ -407,7 +404,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)

    INIT_WORK(&(proc->work), cmd_process_work);

    - queue_work(hyper_dmabuf_private.work_queue, &(proc->work));
    + queue_work(hy_drv_priv->work_queue, &(proc->work));

    - return req->command;
    + return req->cmd;
    }
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
    index 0f6e795..7c694ec 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
    @@ -28,17 +28,17 @@
    #define MAX_NUMBER_OF_OPERANDS 64

    struct hyper_dmabuf_req {
    - unsigned int request_id;
    - unsigned int status;
    - unsigned int command;
    - unsigned int operands[MAX_NUMBER_OF_OPERANDS];
    + unsigned int req_id;
    + unsigned int stat;
    + unsigned int cmd;
    + unsigned int op[MAX_NUMBER_OF_OPERANDS];
    };

    struct hyper_dmabuf_resp {
    - unsigned int response_id;
    - unsigned int status;
    - unsigned int command;
    - unsigned int operands[MAX_NUMBER_OF_OPERANDS];
    + unsigned int resp_id;
    + unsigned int stat;
    + unsigned int cmd;
    + unsigned int op[MAX_NUMBER_OF_OPERANDS];
    };

    enum hyper_dmabuf_command {
    @@ -75,7 +75,7 @@ enum hyper_dmabuf_req_feedback {
    };

    /* create a request packet with given command and operands */
    -void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
    +void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
    enum hyper_dmabuf_command command,
    int *operands);

    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
    index 9313c42..7e73170 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
    @@ -32,8 +32,6 @@
    #include <linux/slab.h>
    #include <linux/module.h>
    #include <linux/dma-buf.h>
    -#include <xen/grant_table.h>
    -#include <asm/xen/page.h>
    #include "hyper_dmabuf_drv.h"
    #include "hyper_dmabuf_struct.h"
    #include "hyper_dmabuf_ops.h"
    @@ -45,122 +43,111 @@
    #define WAIT_AFTER_SYNC_REQ 0
    #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    -inline int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
    +static int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
    {
    struct hyper_dmabuf_req *req;
    - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
    - int operands[5];
    + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
    + int op[5];
    int i;
    int ret;

    - operands[0] = hid.id;
    + op[0] = hid.id;

    for (i=0; i<3; i++)
    - operands[i+1] = hid.rng_key[i];
    + op[i+1] = hid.rng_key[i];

    - operands[4] = dmabuf_ops;
    + op[4] = dmabuf_ops;

    req = kcalloc(1, sizeof(*req), GFP_KERNEL);

    if (!req) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return -ENOMEM;
    }

    - hyper_dmabuf_create_request(req, HYPER_DMABUF_OPS_TO_SOURCE, &operands[0]);
    + hyper_dmabuf_create_req(req, HYPER_DMABUF_OPS_TO_SOURCE, &op[0]);

    /* send request and wait for a response */
    ret = ops->send_req(HYPER_DMABUF_DOM_ID(hid), req, WAIT_AFTER_SYNC_REQ);

    + if (ret < 0) {
    + dev_dbg(hy_drv_priv->dev,
    + "dmabuf sync request failed:%d\n", req->op[4]);
    + }
    +
    kfree(req);

    return ret;
    }

    -static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf, struct device* dev,
    - struct dma_buf_attachment *attach)
    +static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf,
    + struct device* dev,
    + struct dma_buf_attachment *attach)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!attach->dmabuf->priv)
    return -EINVAL;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv;
    + imported = (struct imported_sgt_info *)attach->dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_ATTACH);

    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - return ret;
    - }
    -
    - return 0;
    + return ret;
    }

    -static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf, struct dma_buf_attachment *attach)
    +static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf,
    + struct dma_buf_attachment *attach)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!attach->dmabuf->priv)
    return;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv;
    + imported = (struct imported_sgt_info *)attach->dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_DETACH);
    -
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }
    }

    static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachment,
    - enum dma_data_direction dir)
    + enum dma_data_direction dir)
    {
    struct sg_table *st;
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    - struct hyper_dmabuf_pages_info *page_info;
    + struct imported_sgt_info *imported;
    + struct pages_info *pg_info;
    int ret;

    if (!attachment->dmabuf->priv)
    return NULL;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attachment->dmabuf->priv;
    + imported = (struct imported_sgt_info *)attachment->dmabuf->priv;

    /* extract pages from sgt */
    - page_info = hyper_dmabuf_ext_pgs(sgt_info->sgt);
    + pg_info = hyper_dmabuf_ext_pgs(imported->sgt);

    - if (!page_info) {
    + if (!pg_info) {
    return NULL;
    }

    /* create a new sg_table with extracted pages */
    - st = hyper_dmabuf_create_sgt(page_info->pages, page_info->frst_ofst,
    - page_info->last_len, page_info->nents);
    + st = hyper_dmabuf_create_sgt(pg_info->pgs, pg_info->frst_ofst,
    + pg_info->last_len, pg_info->nents);
    if (!st)
    goto err_free_sg;

    if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir))
    goto err_free_sg;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_MAP);

    - kfree(page_info->pages);
    - kfree(page_info);
    -
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }
    + kfree(pg_info->pgs);
    + kfree(pg_info);

    return st;

    @@ -170,8 +157,8 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme
    kfree(st);
    }

    - kfree(page_info->pages);
    - kfree(page_info);
    + kfree(pg_info->pgs);
    + kfree(pg_info);

    return NULL;
    }
    @@ -180,294 +167,251 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment,
    struct sg_table *sg,
    enum dma_data_direction dir)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!attachment->dmabuf->priv)
    return;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attachment->dmabuf->priv;
    + imported = (struct imported_sgt_info *)attachment->dmabuf->priv;

    dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);

    sg_free_table(sg);
    kfree(sg);

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_UNMAP);
    -
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }
    }

    static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
    + struct imported_sgt_info *imported;
    + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
    int ret;
    - int final_release;
    + int finish;

    if (!dma_buf->priv)
    return;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dma_buf->priv;
    + imported = (struct imported_sgt_info *)dma_buf->priv;

    - if (!dmabuf_refcount(sgt_info->dma_buf)) {
    - sgt_info->dma_buf = NULL;
    + if (!dmabuf_refcount(imported->dma_buf)) {
    + imported->dma_buf = NULL;
    }

    - sgt_info->num_importers--;
    + imported->importers--;

    - if (sgt_info->num_importers == 0) {
    - ops->unmap_shared_pages(&sgt_info->refs_info, sgt_info->nents);
    + if (imported->importers == 0) {
    + ops->unmap_shared_pages(&imported->refs_info, imported->nents);

    - if (sgt_info->sgt) {
    - sg_free_table(sgt_info->sgt);
    - kfree(sgt_info->sgt);
    - sgt_info->sgt = NULL;
    + if (imported->sgt) {
    + sg_free_table(imported->sgt);
    + kfree(imported->sgt);
    + imported->sgt = NULL;
    }
    }

    - final_release = sgt_info && !sgt_info->valid &&
    - !sgt_info->num_importers;
    + finish = imported && !imported->valid &&
    + !imported->importers;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_RELEASE);
    - if (ret < 0) {
    - dev_warn(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }

    /*
    * Check if buffer is still valid and if not remove it from imported list.
    * That has to be done after sending sync request
    */
    - if (final_release) {
    - hyper_dmabuf_remove_imported(sgt_info->hid);
    - kfree(sgt_info);
    + if (finish) {
    + hyper_dmabuf_remove_imported(imported->hid);
    + kfree(imported);
    }
    }

    static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return -EINVAL;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }

    return ret;
    }

    static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return -EINVAL;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_END_CPU_ACCESS);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }

    return 0;
    }

    static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return NULL;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_KMAP_ATOMIC);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }

    return NULL; /* for now NULL.. need to return the address of mapped region */
    }

    static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_KUNMAP_ATOMIC);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }
    }

    static void *hyper_dmabuf_ops_kmap(struct dma_buf *dmabuf, unsigned long pgnum)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return NULL;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_KMAP);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }

    - return NULL; /* for now NULL.. need to return the address of mapped region */
    + /* for now NULL.. need to return the address of mapped region */
    + return NULL;
    }

    -static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr)
    +static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum,
    + void *vaddr)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_KUNMAP);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }
    }

    static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return -EINVAL;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_MMAP);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }

    return ret;
    }

    static void *hyper_dmabuf_ops_vmap(struct dma_buf *dmabuf)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return NULL;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_VMAP);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }

    return NULL;
    }

    static void hyper_dmabuf_ops_vunmap(struct dma_buf *dmabuf, void *vaddr)
    {
    - struct hyper_dmabuf_imported_sgt_info *sgt_info;
    + struct imported_sgt_info *imported;
    int ret;

    if (!dmabuf->priv)
    return;

    - sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
    + imported = (struct imported_sgt_info *)dmabuf->priv;

    - ret = hyper_dmabuf_sync_request(sgt_info->hid,
    + ret = hyper_dmabuf_sync_request(imported->hid,
    HYPER_DMABUF_OPS_VUNMAP);
    - if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
    - }
    }

    static const struct dma_buf_ops hyper_dmabuf_ops = {
    - .attach = hyper_dmabuf_ops_attach,
    - .detach = hyper_dmabuf_ops_detach,
    - .map_dma_buf = hyper_dmabuf_ops_map,
    - .unmap_dma_buf = hyper_dmabuf_ops_unmap,
    - .release = hyper_dmabuf_ops_release,
    - .begin_cpu_access = (void*)hyper_dmabuf_ops_begin_cpu_access,
    - .end_cpu_access = (void*)hyper_dmabuf_ops_end_cpu_access,
    - .map_atomic = hyper_dmabuf_ops_kmap_atomic,
    - .unmap_atomic = hyper_dmabuf_ops_kunmap_atomic,
    - .map = hyper_dmabuf_ops_kmap,
    - .unmap = hyper_dmabuf_ops_kunmap,
    - .mmap = hyper_dmabuf_ops_mmap,
    - .vmap = hyper_dmabuf_ops_vmap,
    - .vunmap = hyper_dmabuf_ops_vunmap,
    + .attach = hyper_dmabuf_ops_attach,
    + .detach = hyper_dmabuf_ops_detach,
    + .map_dma_buf = hyper_dmabuf_ops_map,
    + .unmap_dma_buf = hyper_dmabuf_ops_unmap,
    + .release = hyper_dmabuf_ops_release,
    + .begin_cpu_access = (void*)hyper_dmabuf_ops_begin_cpu_access,
    + .end_cpu_access = (void*)hyper_dmabuf_ops_end_cpu_access,
    + .map_atomic = hyper_dmabuf_ops_kmap_atomic,
    + .unmap_atomic = hyper_dmabuf_ops_kunmap_atomic,
    + .map = hyper_dmabuf_ops_kmap,
    + .unmap = hyper_dmabuf_ops_kunmap,
    + .mmap = hyper_dmabuf_ops_mmap,
    + .vmap = hyper_dmabuf_ops_vmap,
    + .vunmap = hyper_dmabuf_ops_vunmap,
    };

    /* exporting dmabuf as fd */
    -int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags)
    +int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags)
    {
    int fd = -1;

    /* call hyper_dmabuf_export_dmabuf and create
    * and bind a handle for it then release
    */
    - hyper_dmabuf_export_dma_buf(dinfo);
    + hyper_dmabuf_export_dma_buf(imported);

    - if (dinfo->dma_buf) {
    - fd = dma_buf_fd(dinfo->dma_buf, flags);
    + if (imported->dma_buf) {
    + fd = dma_buf_fd(imported->dma_buf, flags);
    }

    return fd;
    }

    -void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo)
    +void hyper_dmabuf_export_dma_buf(struct imported_sgt_info *imported)
    {
    DEFINE_DMA_BUF_EXPORT_INFO(exp_info);

    exp_info.ops = &hyper_dmabuf_ops;

    /* multiple of PAGE_SIZE, not considering offset */
    - exp_info.size = dinfo->sgt->nents * PAGE_SIZE;
    - exp_info.flags = /* not sure about flag */0;
    - exp_info.priv = dinfo;
    + exp_info.size = imported->sgt->nents * PAGE_SIZE;
    + exp_info.flags = /* not sure about flag */ 0;
    + exp_info.priv = imported;

    - dinfo->dma_buf = dma_buf_export(&exp_info);
    + imported->dma_buf = dma_buf_export(&exp_info);
    }
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
    index 8c06fc6..c5505a4 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
    @@ -25,8 +25,8 @@
    #ifndef __HYPER_DMABUF_OPS_H__
    #define __HYPER_DMABUF_OPS_H__

    -int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags);
    +int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags);

    -void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo);
    +void hyper_dmabuf_export_dma_buf(struct imported_sgt_info *imported);

    #endif /* __HYPER_DMABUF_IMP_H__ */
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
    index 39c9dee..36e888c 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
    @@ -32,16 +32,12 @@
    #include "hyper_dmabuf_struct.h"
    #include "hyper_dmabuf_id.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    #define HYPER_DMABUF_SIZE(nents, first_offset, last_len) \
    ((nents)*PAGE_SIZE - (first_offset) - PAGE_SIZE + (last_len))

    -int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
    +int hyper_dmabuf_query_exported(struct exported_sgt_info *exported,
    int query, unsigned long* info)
    {
    - int n;
    -
    switch (query)
    {
    case HYPER_DMABUF_QUERY_TYPE:
    @@ -50,45 +46,46 @@ int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,

    /* exporting domain of this specific dmabuf*/
    case HYPER_DMABUF_QUERY_EXPORTER:
    - *info = HYPER_DMABUF_DOM_ID(sgt_info->hid);
    + *info = HYPER_DMABUF_DOM_ID(exported->hid);
    break;

    /* importing domain of this specific dmabuf */
    case HYPER_DMABUF_QUERY_IMPORTER:
    - *info = sgt_info->hyper_dmabuf_rdomain;
    + *info = exported->rdomid;
    break;

    /* size of dmabuf in byte */
    case HYPER_DMABUF_QUERY_SIZE:
    - *info = sgt_info->dma_buf->size;
    + *info = exported->dma_buf->size;
    break;

    /* whether the buffer is used by importer */
    case HYPER_DMABUF_QUERY_BUSY:
    - *info = (sgt_info->importer_exported == 0) ? false : true;
    + *info = (exported->active > 0);
    break;

    /* whether the buffer is unexported */
    case HYPER_DMABUF_QUERY_UNEXPORTED:
    - *info = !sgt_info->valid;
    + *info = !exported->valid;
    break;

    /* whether the buffer is scheduled to be unexported */
    case HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED:
    - *info = !sgt_info->unexport_scheduled;
    + *info = !exported->unexport_sched;
    break;

    /* size of private info attached to buffer */
    case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
    - *info = sgt_info->sz_priv;
    + *info = exported->sz_priv;
    break;

    /* copy private info attached to buffer */
    case HYPER_DMABUF_QUERY_PRIV_INFO:
    - if (sgt_info->sz_priv > 0) {
    + if (exported->sz_priv > 0) {
    + int n;
    n = copy_to_user((void __user*) *info,
    - sgt_info->priv,
    - sgt_info->sz_priv);
    + exported->priv,
    + exported->sz_priv);
    if (n != 0)
    return -EINVAL;
    }
    @@ -102,11 +99,9 @@ int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
    }


    -int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_sgt_info,
    +int hyper_dmabuf_query_imported(struct imported_sgt_info *imported,
    int query, unsigned long *info)
    {
    - int n;
    -
    switch (query)
    {
    case HYPER_DMABUF_QUERY_TYPE:
    @@ -115,50 +110,51 @@ int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_

    /* exporting domain of this specific dmabuf*/
    case HYPER_DMABUF_QUERY_EXPORTER:
    - *info = HYPER_DMABUF_DOM_ID(imported_sgt_info->hid);
    + *info = HYPER_DMABUF_DOM_ID(imported->hid);
    break;

    /* importing domain of this specific dmabuf */
    case HYPER_DMABUF_QUERY_IMPORTER:
    - *info = hyper_dmabuf_private.domid;
    + *info = hy_drv_priv->domid;
    break;

    /* size of dmabuf in byte */
    case HYPER_DMABUF_QUERY_SIZE:
    - if (imported_sgt_info->dma_buf) {
    + if (imported->dma_buf) {
    /* if local dma_buf is created (if it's ever mapped),
    * retrieve it directly from struct dma_buf *
    */
    - *info = imported_sgt_info->dma_buf->size;
    + *info = imported->dma_buf->size;
    } else {
    /* calcuate it from given nents, frst_ofst and last_len */
    - *info = HYPER_DMABUF_SIZE(imported_sgt_info->nents,
    - imported_sgt_info->frst_ofst,
    - imported_sgt_info->last_len);
    + *info = HYPER_DMABUF_SIZE(imported->nents,
    + imported->frst_ofst,
    + imported->last_len);
    }
    break;

    /* whether the buffer is used or not */
    case HYPER_DMABUF_QUERY_BUSY:
    /* checks if it's used by importer */
    - *info = (imported_sgt_info->num_importers > 0) ? true : false;
    + *info = (imported->importers > 0);
    break;

    /* whether the buffer is unexported */
    case HYPER_DMABUF_QUERY_UNEXPORTED:
    - *info = !imported_sgt_info->valid;
    + *info = !imported->valid;
    break;
    /* size of private info attached to buffer */
    case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
    - *info = imported_sgt_info->sz_priv;
    + *info = imported->sz_priv;
    break;

    /* copy private info attached to buffer */
    case HYPER_DMABUF_QUERY_PRIV_INFO:
    - if (imported_sgt_info->sz_priv > 0) {
    + if (imported->sz_priv > 0) {
    + int n;
    n = copy_to_user((void __user*) *info,
    - imported_sgt_info->priv,
    - imported_sgt_info->sz_priv);
    + imported->priv,
    + imported->sz_priv);
    if (n != 0)
    return -EINVAL;
    }
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
    index 7bbb322..65ae738 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
    @@ -1,10 +1,10 @@
    #ifndef __HYPER_DMABUF_QUERY_H__
    #define __HYPER_DMABUF_QUERY_H__

    -int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_sgt_info,
    +int hyper_dmabuf_query_imported(struct imported_sgt_info *imported,
    int query, unsigned long *info);

    -int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
    +int hyper_dmabuf_query_exported(struct exported_sgt_info *exported,
    int query, unsigned long *info);

    #endif // __HYPER_DMABUF_QUERY_H__
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
    index 9004406..01ec98c 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
    @@ -39,8 +39,6 @@
    #include "hyper_dmabuf_msg.h"
    #include "hyper_dmabuf_sgl_proc.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    /* Whenever importer does dma operations from remote domain,
    * a notification is sent to the exporter so that exporter
    * issues equivalent dma operation on the original dma buf
    @@ -58,7 +56,7 @@ extern struct hyper_dmabuf_private hyper_dmabuf_private;
    */
    int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
    {
    - struct hyper_dmabuf_sgt_info *sgt_info;
    + struct exported_sgt_info *exported;
    struct sgt_list *sgtl;
    struct attachment_list *attachl;
    struct kmap_vaddr_list *va_kmapl;
    @@ -66,10 +64,10 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
    int ret;

    /* find a coresponding SGT for the id */
    - sgt_info = hyper_dmabuf_find_exported(hid);
    + exported = hyper_dmabuf_find_exported(hid);

    - if (!sgt_info) {
    - dev_err(hyper_dmabuf_private.device,
    + if (!exported) {
    + dev_err(hy_drv_priv->dev,
    "dmabuf remote sync::can't find exported list\n");
    return -ENOENT;
    }
    @@ -79,84 +77,84 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
    attachl = kcalloc(1, sizeof(*attachl), GFP_KERNEL);

    if (!attachl) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_ATTACH\n");
    return -ENOMEM;
    }

    - attachl->attach = dma_buf_attach(sgt_info->dma_buf,
    - hyper_dmabuf_private.device);
    + attachl->attach = dma_buf_attach(exported->dma_buf,
    + hy_drv_priv->dev);

    if (!attachl->attach) {
    kfree(attachl);
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_ATTACH\n");
    return -ENOMEM;
    }

    - list_add(&attachl->list, &sgt_info->active_attached->list);
    + list_add(&attachl->list, &exported->active_attached->list);
    break;

    case HYPER_DMABUF_OPS_DETACH:
    - if (list_empty(&sgt_info->active_attached->list)) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_DETACH\n");
    - dev_err(hyper_dmabuf_private.device,
    + if (list_empty(&exported->active_attached->list)) {
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_DETACH\n");
    + dev_err(hy_drv_priv->dev,
    "no more dmabuf attachment left to be detached\n");
    return -EFAULT;
    }

    - attachl = list_first_entry(&sgt_info->active_attached->list,
    + attachl = list_first_entry(&exported->active_attached->list,
    struct attachment_list, list);

    - dma_buf_detach(sgt_info->dma_buf, attachl->attach);
    + dma_buf_detach(exported->dma_buf, attachl->attach);
    list_del(&attachl->list);
    kfree(attachl);
    break;

    case HYPER_DMABUF_OPS_MAP:
    - if (list_empty(&sgt_info->active_attached->list)) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
    - dev_err(hyper_dmabuf_private.device,
    + if (list_empty(&exported->active_attached->list)) {
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_MAP\n");
    + dev_err(hy_drv_priv->dev,
    "no more dmabuf attachment left to be mapped\n");
    return -EFAULT;
    }

    - attachl = list_first_entry(&sgt_info->active_attached->list,
    + attachl = list_first_entry(&exported->active_attached->list,
    struct attachment_list, list);

    sgtl = kcalloc(1, sizeof(*sgtl), GFP_KERNEL);

    if (!sgtl) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_MAP\n");
    return -ENOMEM;
    }

    sgtl->sgt = dma_buf_map_attachment(attachl->attach, DMA_BIDIRECTIONAL);
    if (!sgtl->sgt) {
    kfree(sgtl);
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_MAP\n");
    return -ENOMEM;
    }
    - list_add(&sgtl->list, &sgt_info->active_sgts->list);
    + list_add(&sgtl->list, &exported->active_sgts->list);
    break;

    case HYPER_DMABUF_OPS_UNMAP:
    - if (list_empty(&sgt_info->active_sgts->list) ||
    - list_empty(&sgt_info->active_attached->list)) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_UNMAP\n");
    - dev_err(hyper_dmabuf_private.device,
    + if (list_empty(&exported->active_sgts->list) ||
    + list_empty(&exported->active_attached->list)) {
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_UNMAP\n");
    + dev_err(hy_drv_priv->dev,
    "no more SGT or attachment left to be unmapped\n");
    return -EFAULT;
    }

    - attachl = list_first_entry(&sgt_info->active_attached->list,
    + attachl = list_first_entry(&exported->active_attached->list,
    struct attachment_list, list);
    - sgtl = list_first_entry(&sgt_info->active_sgts->list,
    + sgtl = list_first_entry(&exported->active_sgts->list,
    struct sgt_list, list);

    dma_buf_unmap_attachment(attachl->attach, sgtl->sgt,
    @@ -166,30 +164,30 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
    break;

    case HYPER_DMABUF_OPS_RELEASE:
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "Buffer {id:%d key:%d %d %d} released, references left: %d\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2], sgt_info->importer_exported -1);
    + exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1],
    + exported->hid.rng_key[2], exported->active - 1);

    - sgt_info->importer_exported--;
    + exported->active--;
    /* If there are still importers just break, if no then continue with final cleanup */
    - if (sgt_info->importer_exported)
    + if (exported->active)
    break;

    /*
    * Importer just released buffer fd, check if there is any other importer still using it.
    * If not and buffer was unexported, clean up shared data and remove that buffer.
    */
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "Buffer {id:%d key:%d %d %d} final released\n",
    - sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
    - sgt_info->hid.rng_key[2]);
    + exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1],
    + exported->hid.rng_key[2]);

    - if (!sgt_info->valid && !sgt_info->importer_exported &&
    - !sgt_info->unexport_scheduled) {
    - hyper_dmabuf_cleanup_sgt_info(sgt_info, false);
    + if (!exported->valid && !exported->active &&
    + !exported->unexport_sched) {
    + hyper_dmabuf_cleanup_sgt_info(exported, false);
    hyper_dmabuf_remove_exported(hid);
    - kfree(sgt_info);
    + kfree(exported);
    /* store hyper_dmabuf_id in the list for reuse */
    store_reusable_hid(hid);
    }
    @@ -197,19 +195,19 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
    break;

    case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS:
    - ret = dma_buf_begin_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL);
    + ret = dma_buf_begin_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL);
    if (ret) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
    return ret;
    }
    break;

    case HYPER_DMABUF_OPS_END_CPU_ACCESS:
    - ret = dma_buf_end_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL);
    + ret = dma_buf_end_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL);
    if (ret) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
    return ret;
    }
    break;
    @@ -218,49 +216,49 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
    case HYPER_DMABUF_OPS_KMAP:
    va_kmapl = kcalloc(1, sizeof(*va_kmapl), GFP_KERNEL);
    if (!va_kmapl) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
    return -ENOMEM;
    }

    /* dummy kmapping of 1 page */
    if (ops == HYPER_DMABUF_OPS_KMAP_ATOMIC)
    - va_kmapl->vaddr = dma_buf_kmap_atomic(sgt_info->dma_buf, 1);
    + va_kmapl->vaddr = dma_buf_kmap_atomic(exported->dma_buf, 1);
    else
    - va_kmapl->vaddr = dma_buf_kmap(sgt_info->dma_buf, 1);
    + va_kmapl->vaddr = dma_buf_kmap(exported->dma_buf, 1);

    if (!va_kmapl->vaddr) {
    kfree(va_kmapl);
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
    return -ENOMEM;
    }
    - list_add(&va_kmapl->list, &sgt_info->va_kmapped->list);
    + list_add(&va_kmapl->list, &exported->va_kmapped->list);
    break;

    case HYPER_DMABUF_OPS_KUNMAP_ATOMIC:
    case HYPER_DMABUF_OPS_KUNMAP:
    - if (list_empty(&sgt_info->va_kmapped->list)) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
    - dev_err(hyper_dmabuf_private.device,
    + if (list_empty(&exported->va_kmapped->list)) {
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
    + dev_err(hy_drv_priv->dev,
    "no more dmabuf VA to be freed\n");
    return -EFAULT;
    }

    - va_kmapl = list_first_entry(&sgt_info->va_kmapped->list,
    + va_kmapl = list_first_entry(&exported->va_kmapped->list,
    struct kmap_vaddr_list, list);
    if (!va_kmapl->vaddr) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
    return PTR_ERR(va_kmapl->vaddr);
    }

    /* unmapping 1 page */
    if (ops == HYPER_DMABUF_OPS_KUNMAP_ATOMIC)
    - dma_buf_kunmap_atomic(sgt_info->dma_buf, 1, va_kmapl->vaddr);
    + dma_buf_kunmap_atomic(exported->dma_buf, 1, va_kmapl->vaddr);
    else
    - dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr);
    + dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr);

    list_del(&va_kmapl->list);
    kfree(va_kmapl);
    @@ -269,48 +267,48 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
    case HYPER_DMABUF_OPS_MMAP:
    /* currently not supported: looking for a way to create
    * a dummy vma */
    - dev_warn(hyper_dmabuf_private.device,
    - "dmabuf remote sync::sychronized mmap is not supported\n");
    + dev_warn(hy_drv_priv->dev,
    + "remote sync::sychronized mmap is not supported\n");
    break;

    case HYPER_DMABUF_OPS_VMAP:
    va_vmapl = kcalloc(1, sizeof(*va_vmapl), GFP_KERNEL);

    if (!va_vmapl) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_VMAP\n");
    return -ENOMEM;
    }

    /* dummy vmapping */
    - va_vmapl->vaddr = dma_buf_vmap(sgt_info->dma_buf);
    + va_vmapl->vaddr = dma_buf_vmap(exported->dma_buf);

    if (!va_vmapl->vaddr) {
    kfree(va_vmapl);
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_VMAP\n");
    return -ENOMEM;
    }
    - list_add(&va_vmapl->list, &sgt_info->va_vmapped->list);
    + list_add(&va_vmapl->list, &exported->va_vmapped->list);
    break;

    case HYPER_DMABUF_OPS_VUNMAP:
    - if (list_empty(&sgt_info->va_vmapped->list)) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
    - dev_err(hyper_dmabuf_private.device,
    + if (list_empty(&exported->va_vmapped->list)) {
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_VUNMAP\n");
    + dev_err(hy_drv_priv->dev,
    "no more dmabuf VA to be freed\n");
    return -EFAULT;
    }
    - va_vmapl = list_first_entry(&sgt_info->va_vmapped->list,
    + va_vmapl = list_first_entry(&exported->va_vmapped->list,
    struct vmap_vaddr_list, list);
    if (!va_vmapl || va_vmapl->vaddr == NULL) {
    - dev_err(hyper_dmabuf_private.device,
    - "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
    + dev_err(hy_drv_priv->dev,
    + "remote sync::HYPER_DMABUF_OPS_VUNMAP\n");
    return -EFAULT;
    }

    - dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr);
    + dma_buf_vunmap(exported->dma_buf, va_vmapl->vaddr);

    list_del(&va_vmapl->list);
    kfree(va_vmapl);
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
    index 691a714..315c354 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
    @@ -32,8 +32,6 @@
    #include <linux/slab.h>
    #include <linux/module.h>
    #include <linux/dma-buf.h>
    -#include <xen/grant_table.h>
    -#include <asm/xen/page.h>
    #include "hyper_dmabuf_drv.h"
    #include "hyper_dmabuf_struct.h"
    #include "hyper_dmabuf_sgl_proc.h"
    @@ -41,8 +39,6 @@
    #include "hyper_dmabuf_msg.h"
    #include "hyper_dmabuf_list.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))

    int dmabuf_refcount(struct dma_buf *dma_buf)
    @@ -66,60 +62,68 @@ static int hyper_dmabuf_get_num_pgs(struct sg_table *sgt)
    sgl = sgt->sgl;

    length = sgl->length - PAGE_SIZE + sgl->offset;
    - num_pages += ((length + PAGE_SIZE - 1)/PAGE_SIZE); /* round-up */
    +
    + /* round-up */
    + num_pages += ((length + PAGE_SIZE - 1)/PAGE_SIZE);

    for (i = 1; i < sgt->nents; i++) {
    sgl = sg_next(sgl);
    - num_pages += ((sgl->length + PAGE_SIZE - 1) / PAGE_SIZE); /* round-up */
    +
    + /* round-up */
    + num_pages += ((sgl->length + PAGE_SIZE - 1) /
    + PAGE_SIZE); /* round-up */
    }

    return num_pages;
    }

    /* extract pages directly from struct sg_table */
    -struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
    +struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
    {
    - struct hyper_dmabuf_pages_info *pinfo;
    + struct pages_info *pg_info;
    int i, j, k;
    int length;
    struct scatterlist *sgl;

    - pinfo = kmalloc(sizeof(*pinfo), GFP_KERNEL);
    - if (!pinfo)
    + pg_info = kmalloc(sizeof(*pg_info), GFP_KERNEL);
    + if (!pg_info)
    return NULL;

    - pinfo->pages = kmalloc(sizeof(struct page *)*hyper_dmabuf_get_num_pgs(sgt), GFP_KERNEL);
    - if (!pinfo->pages) {
    - kfree(pinfo);
    + pg_info->pgs = kmalloc(sizeof(struct page *) *
    + hyper_dmabuf_get_num_pgs(sgt),
    + GFP_KERNEL);
    +
    + if (!pg_info->pgs) {
    + kfree(pg_info);
    return NULL;
    }

    sgl = sgt->sgl;

    - pinfo->nents = 1;
    - pinfo->frst_ofst = sgl->offset;
    - pinfo->pages[0] = sg_page(sgl);
    + pg_info->nents = 1;
    + pg_info->frst_ofst = sgl->offset;
    + pg_info->pgs[0] = sg_page(sgl);
    length = sgl->length - PAGE_SIZE + sgl->offset;
    i = 1;

    while (length > 0) {
    - pinfo->pages[i] = nth_page(sg_page(sgl), i);
    + pg_info->pgs[i] = nth_page(sg_page(sgl), i);
    length -= PAGE_SIZE;
    - pinfo->nents++;
    + pg_info->nents++;
    i++;
    }

    for (j = 1; j < sgt->nents; j++) {
    sgl = sg_next(sgl);
    - pinfo->pages[i++] = sg_page(sgl);
    + pg_info->pgs[i++] = sg_page(sgl);
    length = sgl->length - PAGE_SIZE;
    - pinfo->nents++;
    + pg_info->nents++;
    k = 1;

    while (length > 0) {
    - pinfo->pages[i++] = nth_page(sg_page(sgl), k++);
    + pg_info->pgs[i++] = nth_page(sg_page(sgl), k++);
    length -= PAGE_SIZE;
    - pinfo->nents++;
    + pg_info->nents++;
    }
    }

    @@ -127,13 +131,13 @@ struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
    * lenght at that point will be 0 or negative,
    * so to calculate last page size just add it to PAGE_SIZE
    */
    - pinfo->last_len = PAGE_SIZE + length;
    + pg_info->last_len = PAGE_SIZE + length;

    - return pinfo;
    + return pg_info;
    }

    /* create sg_table with given pages and other parameters */
    -struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
    +struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs,
    int frst_ofst, int last_len, int nents)
    {
    struct sg_table *sgt;
    @@ -157,31 +161,32 @@ struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,

    sgl = sgt->sgl;

    - sg_set_page(sgl, pages[0], PAGE_SIZE-frst_ofst, frst_ofst);
    + sg_set_page(sgl, pgs[0], PAGE_SIZE-frst_ofst, frst_ofst);

    for (i=1; i<nents-1; i++) {
    sgl = sg_next(sgl);
    - sg_set_page(sgl, pages[i], PAGE_SIZE, 0);
    + sg_set_page(sgl, pgs[i], PAGE_SIZE, 0);
    }

    if (nents > 1) /* more than one page */ {
    sgl = sg_next(sgl);
    - sg_set_page(sgl, pages[i], last_len, 0);
    + sg_set_page(sgl, pgs[i], last_len, 0);
    }

    return sgt;
    }

    -int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force)
    +int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported,
    + int force)
    {
    struct sgt_list *sgtl;
    struct attachment_list *attachl;
    struct kmap_vaddr_list *va_kmapl;
    struct vmap_vaddr_list *va_vmapl;
    - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
    + struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;

    - if (!sgt_info) {
    - dev_err(hyper_dmabuf_private.device, "invalid hyper_dmabuf_id\n");
    + if (!exported) {
    + dev_err(hy_drv_priv->dev, "invalid hyper_dmabuf_id\n");
    return -EINVAL;
    }

    @@ -190,35 +195,37 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
    * side.
    */
    if (!force &&
    - sgt_info->importer_exported) {
    - dev_warn(hyper_dmabuf_private.device, "dma-buf is used by importer\n");
    + exported->active) {
    + dev_warn(hy_drv_priv->dev,
    + "dma-buf is used by importer\n");
    +
    return -EPERM;
    }

    /* force == 1 is not recommended */
    - while (!list_empty(&sgt_info->va_kmapped->list)) {
    - va_kmapl = list_first_entry(&sgt_info->va_kmapped->list,
    + while (!list_empty(&exported->va_kmapped->list)) {
    + va_kmapl = list_first_entry(&exported->va_kmapped->list,
    struct kmap_vaddr_list, list);

    - dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr);
    + dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr);
    list_del(&va_kmapl->list);
    kfree(va_kmapl);
    }

    - while (!list_empty(&sgt_info->va_vmapped->list)) {
    - va_vmapl = list_first_entry(&sgt_info->va_vmapped->list,
    + while (!list_empty(&exported->va_vmapped->list)) {
    + va_vmapl = list_first_entry(&exported->va_vmapped->list,
    struct vmap_vaddr_list, list);

    - dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr);
    + dma_buf_vunmap(exported->dma_buf, va_vmapl->vaddr);
    list_del(&va_vmapl->list);
    kfree(va_vmapl);
    }

    - while (!list_empty(&sgt_info->active_sgts->list)) {
    - attachl = list_first_entry(&sgt_info->active_attached->list,
    + while (!list_empty(&exported->active_sgts->list)) {
    + attachl = list_first_entry(&exported->active_attached->list,
    struct attachment_list, list);

    - sgtl = list_first_entry(&sgt_info->active_sgts->list,
    + sgtl = list_first_entry(&exported->active_sgts->list,
    struct sgt_list, list);

    dma_buf_unmap_attachment(attachl->attach, sgtl->sgt,
    @@ -227,35 +234,35 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
    kfree(sgtl);
    }

    - while (!list_empty(&sgt_info->active_sgts->list)) {
    - attachl = list_first_entry(&sgt_info->active_attached->list,
    + while (!list_empty(&exported->active_sgts->list)) {
    + attachl = list_first_entry(&exported->active_attached->list,
    struct attachment_list, list);

    - dma_buf_detach(sgt_info->dma_buf, attachl->attach);
    + dma_buf_detach(exported->dma_buf, attachl->attach);
    list_del(&attachl->list);
    kfree(attachl);
    }

    /* Start cleanup of buffer in reverse order to exporting */
    - ops->unshare_pages(&sgt_info->refs_info, sgt_info->nents);
    + ops->unshare_pages(&exported->refs_info, exported->nents);

    /* unmap dma-buf */
    - dma_buf_unmap_attachment(sgt_info->active_attached->attach,
    - sgt_info->active_sgts->sgt,
    + dma_buf_unmap_attachment(exported->active_attached->attach,
    + exported->active_sgts->sgt,
    DMA_BIDIRECTIONAL);

    /* detatch dma-buf */
    - dma_buf_detach(sgt_info->dma_buf, sgt_info->active_attached->attach);
    + dma_buf_detach(exported->dma_buf, exported->active_attached->attach);

    /* close connection to dma-buf completely */
    - dma_buf_put(sgt_info->dma_buf);
    - sgt_info->dma_buf = NULL;
    -
    - kfree(sgt_info->active_sgts);
    - kfree(sgt_info->active_attached);
    - kfree(sgt_info->va_kmapped);
    - kfree(sgt_info->va_vmapped);
    - kfree(sgt_info->priv);
    + dma_buf_put(exported->dma_buf);
    + exported->dma_buf = NULL;
    +
    + kfree(exported->active_sgts);
    + kfree(exported->active_attached);
    + kfree(exported->va_kmapped);
    + kfree(exported->va_vmapped);
    + kfree(exported->priv);

    return 0;
    }
    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
    index 237ccf5..930bade 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
    @@ -28,13 +28,15 @@
    int dmabuf_refcount(struct dma_buf *dma_buf);

    /* extract pages directly from struct sg_table */
    -struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt);
    +struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt);

    /* create sg_table with given pages and other parameters */
    -struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
    - int frst_ofst, int last_len, int nents);
    +struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs,
    + int frst_ofst, int last_len,
    + int nents);

    -int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force);
    +int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported,
    + int force);

    void hyper_dmabuf_free_sgt(struct sg_table *sgt);

    diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
    index 6f929f2..8a612d1 100644
    --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
    +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
    @@ -50,24 +50,20 @@ struct vmap_vaddr_list {
    };

    /* Exporter builds pages_info before sharing pages */
    -struct hyper_dmabuf_pages_info {
    +struct pages_info {
    int frst_ofst; /* offset of data in the first page */
    int last_len; /* length of data in the last page */
    int nents; /* # of pages */
    - struct page **pages; /* pages that contains reference numbers of shared pages*/
    + struct page **pgs; /* pages that contains reference numbers of shared pages*/
    };


    -/* Both importer and exporter use this structure to point to sg lists
    - *
    - * Exporter stores references to sgt in a hash table
    +/* Exporter stores references to sgt in a hash table
    * Exporter keeps these references for synchronization and tracking purposes
    - *
    - * Importer use this structure exporting to other drivers in the same domain
    */
    -struct hyper_dmabuf_sgt_info {
    +struct exported_sgt_info {
    hyper_dmabuf_id_t hid; /* unique id to reference dmabuf in remote domain */
    - int hyper_dmabuf_rdomain; /* domain importing this sgt */
    + int rdomid; /* domain importing this sgt */

    struct dma_buf *dma_buf; /* needed to store this for freeing it later */
    int nents;
    @@ -79,10 +75,10 @@ struct hyper_dmabuf_sgt_info {
    struct vmap_vaddr_list *va_vmapped;

    bool valid; /* set to 0 once unexported. Needed to prevent further mapping by importer */
    - int importer_exported; /* exported locally on importer's side */
    + int active; /* locally shared on importer's side */
    void *refs_info; /* hypervisor-specific info for the references */
    - struct delayed_work unexport_work;
    - bool unexport_scheduled;
    + struct delayed_work unexport;
    + bool unexport_sched;

    /* owner of buffer
    * TODO: that is naiive as buffer may be reused by
    @@ -99,7 +95,7 @@ struct hyper_dmabuf_sgt_info {
    /* Importer store references (before mapping) on shared pages
    * Importer store these references in the table and map it in
    * its own memory map once userspace asks for reference for the buffer */
    -struct hyper_dmabuf_imported_sgt_info {
    +struct imported_sgt_info {
    hyper_dmabuf_id_t hid; /* unique id for shared dmabuf imported */

    int ref_handle; /* reference number of top level addressing page of shared pages */
    @@ -112,7 +108,7 @@ struct hyper_dmabuf_imported_sgt_info {

    void *refs_info;
    bool valid;
    - int num_importers;
    + int importers;

    size_t sz_priv;
    char *priv; /* device specific info (e.g. image's meta info?) */
    diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
    index 920ecf4..f70b4ea 100644
    --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
    +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
    @@ -45,8 +45,6 @@ static int export_req_id = 0;

    struct hyper_dmabuf_req req_pending = {0};

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    extern int xenstored_ready;

    static void xen_get_domid_delayed(struct work_struct *unused);
    @@ -62,7 +60,9 @@ static int xen_comm_setup_data_dir(void)
    {
    char buf[255];

    - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_private.domid);
    + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf",
    + hy_drv_priv->domid);
    +
    return xenbus_mkdir(XBT_NIL, buf, "");
    }

    @@ -76,7 +76,9 @@ static int xen_comm_destroy_data_dir(void)
    {
    char buf[255];

    - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_private.domid);
    + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf",
    + hy_drv_priv->domid);
    +
    return xenbus_rm(XBT_NIL, buf, "");
    }

    @@ -91,20 +93,26 @@ static int xen_comm_expose_ring_details(int domid, int rdomid,
    char buf[255];
    int ret;

    - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", domid, rdomid);
    + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
    + domid, rdomid);
    +
    ret = xenbus_printf(XBT_NIL, buf, "grefid", "%d", gref);

    if (ret) {
    - dev_err(hyper_dmabuf_private.device,
    - "Failed to write xenbus entry %s: %d\n", buf, ret);
    + dev_err(hy_drv_priv->dev,
    + "Failed to write xenbus entry %s: %d\n",
    + buf, ret);
    +
    return ret;
    }

    ret = xenbus_printf(XBT_NIL, buf, "port", "%d", port);

    if (ret) {
    - dev_err(hyper_dmabuf_private.device,
    - "Failed to write xenbus entry %s: %d\n", buf, ret);
    + dev_err(hy_drv_priv->dev,
    + "Failed to write xenbus entry %s: %d\n",
    + buf, ret);
    +
    return ret;
    }

    @@ -114,25 +122,32 @@ static int xen_comm_expose_ring_details(int domid, int rdomid,
    /*
    * Queries details of ring exposed by remote domain.
    */
    -static int xen_comm_get_ring_details(int domid, int rdomid, int *grefid, int *port)
    +static int xen_comm_get_ring_details(int domid, int rdomid,
    + int *grefid, int *port)
    {
    char buf[255];
    int ret;

    - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", rdomid, domid);
    + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
    + rdomid, domid);
    +
    ret = xenbus_scanf(XBT_NIL, buf, "grefid", "%d", grefid);

    if (ret <= 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "Failed to read xenbus entry %s: %d\n", buf, ret);
    + dev_err(hy_drv_priv->dev,
    + "Failed to read xenbus entry %s: %d\n",
    + buf, ret);
    +
    return ret;
    }

    ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", port);

    if (ret <= 0) {
    - dev_err(hyper_dmabuf_private.device,
    - "Failed to read xenbus entry %s: %d\n", buf, ret);
    + dev_err(hy_drv_priv->dev,
    + "Failed to read xenbus entry %s: %d\n",
    + buf, ret);
    +
    return ret;
    }

    @@ -146,9 +161,8 @@ void xen_get_domid_delayed(struct work_struct *unused)

    /* scheduling another if driver is still running
    * and xenstore has not been initialized */
    - if (hyper_dmabuf_private.exited == false &&
    - likely(xenstored_ready == 0)) {
    - dev_dbg(hyper_dmabuf_private.device,
    + if (likely(xenstored_ready == 0)) {
    + dev_dbg(hy_drv_priv->dev,
    "Xenstore is not quite ready yet. Will retry it in 500ms\n");
    schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500));
    } else {
    @@ -163,14 +177,14 @@ void xen_get_domid_delayed(struct work_struct *unused)

    /* try again since -1 is an invalid id for domain
    * (but only if driver is still running) */
    - if (hyper_dmabuf_private.exited == false && unlikely(domid == -1)) {
    - dev_dbg(hyper_dmabuf_private.device,
    + if (unlikely(domid == -1)) {
    + dev_dbg(hy_drv_priv->dev,
    "domid==-1 is invalid. Will retry it in 500ms\n");
    schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500));
    } else {
    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "Successfully retrieved domid from Xenstore:%d\n", domid);
    - hyper_dmabuf_private.domid = domid;
    + hy_drv_priv->domid = domid;
    }
    }
    }
    @@ -232,28 +246,30 @@ static void remote_dom_exporter_watch_cb(struct xenbus_watch *watch,
    return;
    }

    - /* Check if we have importer ring for given remote domain alrady created */
    + /* Check if we have importer ring for given remote domain already
    + * created */
    +
    ring_info = xen_comm_find_rx_ring(rdom);

    - /* Try to query remote domain exporter ring details - if that will
    - * fail and we have importer ring that means remote domains has cleanup
    - * its exporter ring, so our importer ring is no longer useful.
    + /* Try to query remote domain exporter ring details - if
    + * that will fail and we have importer ring that means remote
    + * domains has cleanup its exporter ring, so our importer ring
    + * is no longer useful.
    *
    * If querying details will succeed and we don't have importer ring,
    - * it means that remote domain has setup it for us and we should connect
    - * to it.
    + * it means that remote domain has setup it for us and we should
    + * connect to it.
    */

    -
    - ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), rdom,
    - &grefid, &port);
    + ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(),
    + rdom, &grefid, &port);

    if (ring_info && ret != 0) {
    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "Remote exporter closed, cleaninup importer\n");
    hyper_dmabuf_xen_cleanup_rx_rbuf(rdom);
    } else if (!ring_info && ret == 0) {
    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "Registering importer\n");
    hyper_dmabuf_xen_init_rx_rbuf(rdom);
    }
    @@ -274,7 +290,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
    ring_info = xen_comm_find_tx_ring(domid);

    if (ring_info) {
    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "tx ring ch to domid = %d already exist\ngref = %d, port = %d\n",
    ring_info->rdomain, ring_info->gref_ring, ring_info->port);
    return 0;
    @@ -283,7 +299,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
    ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);

    if (!ring_info) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No more spae left\n");
    return -ENOMEM;
    }
    @@ -313,9 +329,9 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
    alloc_unbound.dom = DOMID_SELF;
    alloc_unbound.remote_dom = domid;
    ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
    - &alloc_unbound);
    + &alloc_unbound);
    if (ret) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "Cannot allocate event channel\n");
    kfree(ring_info);
    return -EIO;
    @@ -327,7 +343,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
    NULL, (void*) ring_info);

    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "Failed to setup event channel\n");
    close.port = alloc_unbound.port;
    HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
    @@ -343,7 +359,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)

    mutex_init(&ring_info->lock);

    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "%s: allocated eventchannel gref %d port: %d irq: %d\n",
    __func__,
    ring_info->gref_ring,
    @@ -364,7 +380,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
    ring_info->watch.node = (const char*) kmalloc(sizeof(char) * 255, GFP_KERNEL);

    if (!ring_info->watch.node) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No more space left\n");
    kfree(ring_info);
    return -ENOMEM;
    @@ -414,7 +430,8 @@ void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid)
    if (!rx_ring_info)
    return;

    - BACK_RING_INIT(&(rx_ring_info->ring_back), rx_ring_info->ring_back.sring, PAGE_SIZE);
    + BACK_RING_INIT(&(rx_ring_info->ring_back), rx_ring_info->ring_back.sring,
    + PAGE_SIZE);
    }

    /* importer needs to know about shared page and port numbers for
    @@ -436,25 +453,28 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
    ring_info = xen_comm_find_rx_ring(domid);

    if (ring_info) {
    - dev_info(hyper_dmabuf_private.device,
    - "rx ring ch from domid = %d already exist\n", ring_info->sdomain);
    + dev_info(hy_drv_priv->dev,
    + "rx ring ch from domid = %d already exist\n",
    + ring_info->sdomain);
    +
    return 0;
    }

    -
    ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), domid,
    &rx_gref, &rx_port);

    if (ret) {
    - dev_err(hyper_dmabuf_private.device,
    - "Domain %d has not created exporter ring for current domain\n", domid);
    + dev_err(hy_drv_priv->dev,
    + "Domain %d has not created exporter ring for current domain\n",
    + domid);
    +
    return ret;
    }

    ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);

    if (!ring_info) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return -ENOMEM;
    }
    @@ -465,7 +485,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
    map_ops = kmalloc(sizeof(*map_ops), GFP_KERNEL);

    if (!map_ops) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    ret = -ENOMEM;
    goto fail_no_map_ops;
    @@ -476,21 +496,23 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
    goto fail_others;
    }

    - gnttab_set_map_op(&map_ops[0], (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
    + gnttab_set_map_op(&map_ops[0],
    + (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
    GNTMAP_host_map, rx_gref, domid);

    - gnttab_set_unmap_op(&ring_info->unmap_op, (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
    + gnttab_set_unmap_op(&ring_info->unmap_op,
    + (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
    GNTMAP_host_map, -1);

    ret = gnttab_map_refs(map_ops, NULL, &shared_ring, 1);
    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device, "Cannot map ring\n");
    + dev_err(hy_drv_priv->dev, "Cannot map ring\n");
    ret = -EFAULT;
    goto fail_others;
    }

    if (map_ops[0].status) {
    - dev_err(hyper_dmabuf_private.device, "Ring mapping failed\n");
    + dev_err(hy_drv_priv->dev, "Ring mapping failed\n");
    ret = -EFAULT;
    goto fail_others;
    } else {
    @@ -512,7 +534,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)

    ring_info->irq = ret;

    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "%s: bound to eventchannel port: %d irq: %d\n", __func__,
    rx_port,
    ring_info->irq);
    @@ -569,7 +591,9 @@ void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid)
    return;

    SHARED_RING_INIT(tx_ring_info->ring_front.sring);
    - FRONT_RING_INIT(&(tx_ring_info->ring_front), tx_ring_info->ring_front.sring, PAGE_SIZE);
    + FRONT_RING_INIT(&(tx_ring_info->ring_front),
    + tx_ring_info->ring_front.sring,
    + PAGE_SIZE);
    }

    #ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD
    @@ -587,20 +611,20 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused)
    char buf[128];
    int i, dummy;

    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "Scanning new tx channel comming from another domain\n");

    /* check other domains and schedule another work if driver
    * is still running and backend is valid
    */
    - if (hyper_dmabuf_private.exited == false &&
    - hyper_dmabuf_private.backend_initialized == true) {
    + if (hy_drv_priv &&
    + hy_drv_priv->initialized) {
    for (i = DOMID_SCAN_START; i < DOMID_SCAN_END + 1; i++) {
    - if (i == hyper_dmabuf_private.domid)
    + if (i == hy_drv_priv->domid)
    continue;

    - sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", i,
    - hyper_dmabuf_private.domid);
    + sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
    + i, hy_drv_priv->domid);

    ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", &dummy);

    @@ -611,13 +635,14 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused)
    ret = hyper_dmabuf_xen_init_rx_rbuf(i);

    if (!ret)
    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "Finishing up setting up rx channel for domain %d\n", i);
    }
    }

    /* check every 10 seconds */
    - schedule_delayed_work(&xen_rx_ch_auto_add_work, msecs_to_jiffies(10000));
    + schedule_delayed_work(&xen_rx_ch_auto_add_work,
    + msecs_to_jiffies(10000));
    }
    }

    @@ -630,21 +655,21 @@ void xen_init_comm_env_delayed(struct work_struct *unused)
    /* scheduling another work if driver is still running
    * and xenstore hasn't been initialized or dom_id hasn't
    * been correctly retrieved. */
    - if (hyper_dmabuf_private.exited == false &&
    - likely(xenstored_ready == 0 ||
    - hyper_dmabuf_private.domid == -1)) {
    - dev_dbg(hyper_dmabuf_private.device,
    - "Xenstore is not ready yet. Re-try this again in 500ms\n");
    - schedule_delayed_work(&xen_init_comm_env_work, msecs_to_jiffies(500));
    + if (likely(xenstored_ready == 0 ||
    + hy_drv_priv->domid == -1)) {
    + dev_dbg(hy_drv_priv->dev,
    + "Xenstore not ready Will re-try in 500ms\n");
    + schedule_delayed_work(&xen_init_comm_env_work,
    + msecs_to_jiffies(500));
    } else {
    ret = xen_comm_setup_data_dir();
    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "Failed to create data dir in Xenstore\n");
    } else {
    - dev_info(hyper_dmabuf_private.device,
    - "Successfully finished comm env initialization\n");
    - hyper_dmabuf_private.backend_initialized = true;
    + dev_info(hy_drv_priv->dev,
    + "Successfully finished comm env init\n");
    + hy_drv_priv->initialized = true;

    #ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD
    xen_rx_ch_add_delayed(NULL);
    @@ -659,20 +684,21 @@ int hyper_dmabuf_xen_init_comm_env(void)

    xen_comm_ring_table_init();

    - if (unlikely(xenstored_ready == 0 || hyper_dmabuf_private.domid == -1)) {
    + if (unlikely(xenstored_ready == 0 ||
    + hy_drv_priv->domid == -1)) {
    xen_init_comm_env_delayed(NULL);
    return -1;
    }

    ret = xen_comm_setup_data_dir();
    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "Failed to create data dir in Xenstore\n");
    } else {
    - dev_info(hyper_dmabuf_private.device,
    + dev_info(hy_drv_priv->dev,
    "Successfully finished comm env initialization\n");

    - hyper_dmabuf_private.backend_initialized = true;
    + hy_drv_priv->initialized = true;
    }

    return ret;
    @@ -691,7 +717,8 @@ void hyper_dmabuf_xen_destroy_comm(void)
    xen_comm_destroy_data_dir();
    }

    -int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
    +int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req,
    + int wait)
    {
    struct xen_comm_front_ring *ring;
    struct hyper_dmabuf_req *new_req;
    @@ -706,22 +733,21 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
    /* find a ring info for the channel */
    ring_info = xen_comm_find_tx_ring(domid);
    if (!ring_info) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "Can't find ring info for the channel\n");
    return -ENOENT;
    }

    - mutex_lock(&ring_info->lock);

    ring = &ring_info->ring_front;

    do_gettimeofday(&tv_start);

    while (RING_FULL(ring)) {
    - dev_dbg(hyper_dmabuf_private.device, "RING_FULL\n");
    + dev_dbg(hy_drv_priv->dev, "RING_FULL\n");

    if (timeout == 0) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "Timeout while waiting for an entry in the ring\n");
    return -EIO;
    }
    @@ -731,15 +757,17 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)

    timeout = 1000;

    + mutex_lock(&ring_info->lock);
    +
    new_req = RING_GET_REQUEST(ring, ring->req_prod_pvt);
    if (!new_req) {
    mutex_unlock(&ring_info->lock);
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "NULL REQUEST\n");
    return -EIO;
    }

    - req->request_id = xen_comm_next_req_id();
    + req->req_id = xen_comm_next_req_id();

    /* update req_pending with current request */
    memcpy(&req_pending, req, sizeof(req_pending));
    @@ -756,7 +784,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)

    if (wait) {
    while (timeout--) {
    - if (req_pending.status !=
    + if (req_pending.stat !=
    HYPER_DMABUF_REQ_NOT_RESPONDED)
    break;
    usleep_range(100, 120);
    @@ -764,7 +792,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)

    if (timeout < 0) {
    mutex_unlock(&ring_info->lock);
    - dev_err(hyper_dmabuf_private.device, "request timed-out\n");
    + dev_err(hy_drv_priv->dev, "request timed-out\n");
    return -EBUSY;
    }

    @@ -781,10 +809,8 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
    }

    if (tv_diff.tv_sec != 0 && tv_diff.tv_usec > 16000)
    - dev_dbg(hyper_dmabuf_private.device, "send_req:time diff: %ld sec, %ld usec\n",
    + dev_dbg(hy_drv_priv->dev, "send_req:time diff: %ld sec, %ld usec\n",
    tv_diff.tv_sec, tv_diff.tv_usec);
    -
    - return req_pending.status;
    }

    mutex_unlock(&ring_info->lock);
    @@ -808,7 +834,7 @@ static irqreturn_t back_ring_isr(int irq, void *info)
    ring_info = (struct xen_comm_rx_ring_info *)info;
    ring = &ring_info->ring_back;

    - dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s\n", __func__);

    do {
    rc = ring->req_cons;
    @@ -828,13 +854,13 @@ static irqreturn_t back_ring_isr(int irq, void *info)
    * the requester
    */
    memcpy(&resp, &req, sizeof(resp));
    - memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt), &resp,
    - sizeof(resp));
    + memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt),
    + &resp, sizeof(resp));
    ring->rsp_prod_pvt++;

    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "sending response to exporter for request id:%d\n",
    - resp.response_id);
    + resp.resp_id);

    RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify);

    @@ -864,7 +890,7 @@ static irqreturn_t front_ring_isr(int irq, void *info)
    ring_info = (struct xen_comm_tx_ring_info *)info;
    ring = &ring_info->ring_front;

    - dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s\n", __func__);

    do {
    more_to_do = 0;
    @@ -876,33 +902,33 @@ static irqreturn_t front_ring_isr(int irq, void *info)
    * in the response
    */

    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    "getting response from importer\n");

    - if (req_pending.request_id == resp->response_id) {
    - req_pending.status = resp->status;
    + if (req_pending.req_id == resp->resp_id) {
    + req_pending.stat = resp->stat;
    }

    - if (resp->status == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
    + if (resp->stat == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
    /* parsing response */
    ret = hyper_dmabuf_msg_parse(ring_info->rdomain,
    (struct hyper_dmabuf_req *)resp);

    if (ret < 0) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "getting error while parsing response\n");
    }
    - } else if (resp->status == HYPER_DMABUF_REQ_PROCESSED) {
    + } else if (resp->stat == HYPER_DMABUF_REQ_PROCESSED) {
    /* for debugging dma_buf remote synchronization */
    - dev_dbg(hyper_dmabuf_private.device,
    - "original request = 0x%x\n", resp->command);
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    + "original request = 0x%x\n", resp->cmd);
    + dev_dbg(hy_drv_priv->dev,
    "Just got HYPER_DMABUF_REQ_PROCESSED\n");
    - } else if (resp->status == HYPER_DMABUF_REQ_ERROR) {
    + } else if (resp->stat == HYPER_DMABUF_REQ_ERROR) {
    /* for debugging dma_buf remote synchronization */
    - dev_dbg(hyper_dmabuf_private.device,
    - "original request = 0x%x\n", resp->command);
    - dev_dbg(hyper_dmabuf_private.device,
    + dev_dbg(hy_drv_priv->dev,
    + "original request = 0x%x\n", resp->cmd);
    + dev_dbg(hy_drv_priv->dev,
    "Just got HYPER_DMABUF_REQ_ERROR\n");
    }
    }
    diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
    index 4708b49..7a8ec73 100644
    --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
    +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
    @@ -38,8 +38,6 @@
    #include "hyper_dmabuf_xen_comm.h"
    #include "hyper_dmabuf_xen_comm_list.h"

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    DECLARE_HASHTABLE(xen_comm_tx_ring_hash, MAX_ENTRY_TX_RING);
    DECLARE_HASHTABLE(xen_comm_rx_ring_hash, MAX_ENTRY_RX_RING);

    @@ -56,7 +54,7 @@ int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info *ring_info)
    info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);

    if (!info_entry) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return -ENOMEM;
    }
    @@ -76,7 +74,7 @@ int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info *ring_info)
    info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);

    if (!info_entry) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "No memory left to be allocated\n");
    return -ENOMEM;
    }
    diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
    index 908eda8..424417d 100644
    --- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
    +++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
    @@ -36,8 +36,6 @@

    #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))

    -extern struct hyper_dmabuf_private hyper_dmabuf_private;
    -
    /*
    * Creates 2 level page directory structure for referencing shared pages.
    * Top level page is a single page that contains up to 1024 refids that
    @@ -98,7 +96,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
    sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);

    if (!sh_pages_info) {
    - dev_err(hyper_dmabuf_private.device, "No more space left\n");
    + dev_err(hy_drv_priv->dev, "No more space left\n");
    return -ENOMEM;
    }

    @@ -107,10 +105,10 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
    /* share data pages in readonly mode for security */
    for (i=0; i<nents; i++) {
    lvl2_table[i] = gnttab_grant_foreign_access(domid,
    - pfn_to_mfn(page_to_pfn(pages[i])),
    - true /* read-only from remote domain */);
    + pfn_to_mfn(page_to_pfn(pages[i])),
    + true /* read-only from remote domain */);
    if (lvl2_table[i] == -ENOSPC) {
    - dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
    + dev_err(hy_drv_priv->dev, "No more space left in grant table\n");

    /* Unshare all already shared pages for lvl2 */
    while(i--) {
    @@ -124,10 +122,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
    /* Share 2nd level addressing pages in readonly mode*/
    for (i=0; i< n_lvl2_grefs; i++) {
    lvl3_table[i] = gnttab_grant_foreign_access(domid,
    - virt_to_mfn((unsigned long)lvl2_table+i*PAGE_SIZE ),
    - true);
    + virt_to_mfn((unsigned long)lvl2_table+i*PAGE_SIZE ),
    + true);
    +
    if (lvl3_table[i] == -ENOSPC) {
    - dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
    + dev_err(hy_drv_priv->dev, "No more space left in grant table\n");

    /* Unshare all already shared pages for lvl3 */
    while(i--) {
    @@ -147,11 +146,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,

    /* Share lvl3_table in readonly mode*/
    lvl3_gref = gnttab_grant_foreign_access(domid,
    - virt_to_mfn((unsigned long)lvl3_table),
    - true);
    + virt_to_mfn((unsigned long)lvl3_table),
    + true);

    if (lvl3_gref == -ENOSPC) {
    - dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
    + dev_err(hy_drv_priv->dev, "No more space left in grant table\n");

    /* Unshare all pages for lvl3 */
    while(i--) {
    @@ -178,7 +177,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
    /* Store exported pages refid to be unshared later */
    sh_pages_info->lvl3_gref = lvl3_gref;

    - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
    return lvl3_gref;

    err_cleanup:
    @@ -190,16 +189,17 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,

    int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
    struct xen_shared_pages_info *sh_pages_info;
    - int n_lvl2_grefs = (nents/REFS_PER_PAGE + ((nents % REFS_PER_PAGE) ? 1: 0));
    + int n_lvl2_grefs = (nents/REFS_PER_PAGE +
    + ((nents % REFS_PER_PAGE) ? 1: 0));
    int i;

    - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
    sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);

    if (sh_pages_info->lvl3_table == NULL ||
    sh_pages_info->lvl2_table == NULL ||
    sh_pages_info->lvl3_gref == -1) {
    - dev_warn(hyper_dmabuf_private.device,
    + dev_warn(hy_drv_priv->dev,
    "gref table for hyper_dmabuf already cleaned up\n");
    return 0;
    }
    @@ -207,7 +207,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
    /* End foreign access for data pages, but do not free them */
    for (i = 0; i < nents; i++) {
    if (gnttab_query_foreign_access(sh_pages_info->lvl2_table[i])) {
    - dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n");
    + dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
    }
    gnttab_end_foreign_access_ref(sh_pages_info->lvl2_table[i], 0);
    gnttab_free_grant_reference(sh_pages_info->lvl2_table[i]);
    @@ -216,17 +216,17 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
    /* End foreign access for 2nd level addressing pages */
    for (i = 0; i < n_lvl2_grefs; i++) {
    if (gnttab_query_foreign_access(sh_pages_info->lvl3_table[i])) {
    - dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n");
    + dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
    }
    if (!gnttab_end_foreign_access_ref(sh_pages_info->lvl3_table[i], 1)) {
    - dev_warn(hyper_dmabuf_private.device, "refid still in use!!!\n");
    + dev_warn(hy_drv_priv->dev, "refid still in use!!!\n");
    }
    gnttab_free_grant_reference(sh_pages_info->lvl3_table[i]);
    }

    /* End foreign access for top level addressing page */
    if (gnttab_query_foreign_access(sh_pages_info->lvl3_gref)) {
    - dev_warn(hyper_dmabuf_private.device, "gref not shared !!\n");
    + dev_warn(hy_drv_priv->dev, "gref not shared !!\n");
    }

    gnttab_end_foreign_access_ref(sh_pages_info->lvl3_gref, 1);
    @@ -242,7 +242,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
    kfree(sh_pages_info);
    sh_pages_info = NULL;

    - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
    return 0;
    }

    @@ -270,27 +270,33 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n

    /* # of grefs in the last page of lvl2 table */
    int nents_last = (nents - 1) % REFS_PER_PAGE + 1;
    - int n_lvl2_grefs = (nents / REFS_PER_PAGE) + ((nents_last > 0) ? 1 : 0) -
    + int n_lvl2_grefs = (nents / REFS_PER_PAGE) +
    + ((nents_last > 0) ? 1 : 0) -
    (nents_last == REFS_PER_PAGE);
    int i, j, k;

    - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);

    sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
    *refs_info = (void *) sh_pages_info;

    - lvl2_table_pages = kcalloc(sizeof(struct page*), n_lvl2_grefs, GFP_KERNEL);
    + lvl2_table_pages = kcalloc(sizeof(struct page*), n_lvl2_grefs,
    + GFP_KERNEL);
    +
    data_pages = kcalloc(sizeof(struct page*), nents, GFP_KERNEL);

    - lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs, GFP_KERNEL);
    - lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs, GFP_KERNEL);
    + lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs,
    + GFP_KERNEL);
    +
    + lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs,
    + GFP_KERNEL);

    data_map_ops = kcalloc(sizeof(*data_map_ops), nents, GFP_KERNEL);
    data_unmap_ops = kcalloc(sizeof(*data_unmap_ops), nents, GFP_KERNEL);

    /* Map top level addressing page */
    if (gnttab_alloc_pages(1, &lvl3_table_page)) {
    - dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
    + dev_err(hy_drv_priv->dev, "Cannot allocate pages\n");
    return NULL;
    }

    @@ -304,13 +310,16 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
    GNTMAP_host_map | GNTMAP_readonly, -1);

    if (gnttab_map_refs(&lvl3_map_ops, NULL, &lvl3_table_page, 1)) {
    - dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed");
    + dev_err(hy_drv_priv->dev,
    + "HYPERVISOR map grant ref failed");
    return NULL;
    }

    if (lvl3_map_ops.status) {
    - dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed status = %d",
    + dev_err(hy_drv_priv->dev,
    + "HYPERVISOR map grant ref failed status = %d",
    lvl3_map_ops.status);
    +
    goto error_cleanup_lvl3;
    } else {
    lvl3_unmap_ops.handle = lvl3_map_ops.handle;
    @@ -318,35 +327,43 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n

    /* Map all second level pages */
    if (gnttab_alloc_pages(n_lvl2_grefs, lvl2_table_pages)) {
    - dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
    + dev_err(hy_drv_priv->dev, "Cannot allocate pages\n");
    goto error_cleanup_lvl3;
    }

    for (i = 0; i < n_lvl2_grefs; i++) {
    lvl2_table = (grant_ref_t *)pfn_to_kaddr(page_to_pfn(lvl2_table_pages[i]));
    - gnttab_set_map_op(&lvl2_map_ops[i], (unsigned long)lvl2_table, GNTMAP_host_map | GNTMAP_readonly,
    + gnttab_set_map_op(&lvl2_map_ops[i],
    + (unsigned long)lvl2_table, GNTMAP_host_map |
    + GNTMAP_readonly,
    lvl3_table[i], domid);
    - gnttab_set_unmap_op(&lvl2_unmap_ops[i], (unsigned long)lvl2_table, GNTMAP_host_map | GNTMAP_readonly, -1);
    + gnttab_set_unmap_op(&lvl2_unmap_ops[i],
    + (unsigned long)lvl2_table, GNTMAP_host_map |
    + GNTMAP_readonly, -1);
    }

    /* Unmap top level page, as it won't be needed any longer */
    - if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1)) {
    - dev_err(hyper_dmabuf_private.device, "xen: cannot unmap top level page\n");
    + if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL,
    + &lvl3_table_page, 1)) {
    + dev_err(hy_drv_priv->dev,
    + "xen: cannot unmap top level page\n");
    return NULL;
    } else {
    /* Mark that page was unmapped */
    lvl3_unmap_ops.handle = -1;
    }

    - if (gnttab_map_refs(lvl2_map_ops, NULL, lvl2_table_pages, n_lvl2_grefs)) {
    - dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed");
    + if (gnttab_map_refs(lvl2_map_ops, NULL,
    + lvl2_table_pages, n_lvl2_grefs)) {
    + dev_err(hy_drv_priv->dev,
    + "HYPERVISOR map grant ref failed");
    return NULL;
    }

    /* Checks if pages were mapped correctly */
    for (i = 0; i < n_lvl2_grefs; i++) {
    if (lvl2_map_ops[i].status) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "HYPERVISOR map grant ref failed status = %d",
    lvl2_map_ops[i].status);
    goto error_cleanup_lvl2;
    @@ -356,7 +373,8 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
    }

    if (gnttab_alloc_pages(nents, data_pages)) {
    - dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
    + dev_err(hy_drv_priv->dev,
    + "Cannot allocate pages\n");
    goto error_cleanup_lvl2;
    }

    @@ -366,13 +384,13 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
    lvl2_table = pfn_to_kaddr(page_to_pfn(lvl2_table_pages[i]));
    for (j = 0; j < REFS_PER_PAGE; j++) {
    gnttab_set_map_op(&data_map_ops[k],
    - (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
    - GNTMAP_host_map | GNTMAP_readonly,
    - lvl2_table[j], domid);
    + (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
    + GNTMAP_host_map | GNTMAP_readonly,
    + lvl2_table[j], domid);

    gnttab_set_unmap_op(&data_unmap_ops[k],
    - (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
    - GNTMAP_host_map | GNTMAP_readonly, -1);
    + (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
    + GNTMAP_host_map | GNTMAP_readonly, -1);
    k++;
    }
    }
    @@ -382,25 +400,29 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n

    for (j = 0; j < nents_last; j++) {
    gnttab_set_map_op(&data_map_ops[k],
    - (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
    - GNTMAP_host_map | GNTMAP_readonly,
    - lvl2_table[j], domid);
    + (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
    + GNTMAP_host_map | GNTMAP_readonly,
    + lvl2_table[j], domid);

    gnttab_set_unmap_op(&data_unmap_ops[k],
    - (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
    - GNTMAP_host_map | GNTMAP_readonly, -1);
    + (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
    + GNTMAP_host_map | GNTMAP_readonly, -1);
    k++;
    }

    - if (gnttab_map_refs(data_map_ops, NULL, data_pages, nents)) {
    - dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed\n");
    + if (gnttab_map_refs(data_map_ops, NULL,
    + data_pages, nents)) {
    + dev_err(hy_drv_priv->dev,
    + "HYPERVISOR map grant ref failed\n");
    return NULL;
    }

    /* unmapping lvl2 table pages */
    - if (gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages,
    + if (gnttab_unmap_refs(lvl2_unmap_ops,
    + NULL, lvl2_table_pages,
    n_lvl2_grefs)) {
    - dev_err(hyper_dmabuf_private.device, "Cannot unmap 2nd level refs\n");
    + dev_err(hy_drv_priv->dev,
    + "Cannot unmap 2nd level refs\n");
    return NULL;
    } else {
    /* Mark that pages were unmapped */
    @@ -411,7 +433,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n

    for (i = 0; i < nents; i++) {
    if (data_map_ops[i].status) {
    - dev_err(hyper_dmabuf_private.device,
    + dev_err(hy_drv_priv->dev,
    "HYPERVISOR map grant ref failed status = %d\n",
    data_map_ops[i].status);
    goto error_cleanup_data;
    @@ -431,7 +453,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
    kfree(lvl2_unmap_ops);
    kfree(data_map_ops);

    - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
    return data_pages;

    error_cleanup_data:
    @@ -442,13 +464,14 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n

    error_cleanup_lvl2:
    if (lvl2_unmap_ops[0].handle != -1)
    - gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages,
    - n_lvl2_grefs);
    + gnttab_unmap_refs(lvl2_unmap_ops, NULL,
    + lvl2_table_pages, n_lvl2_grefs);
    gnttab_free_pages(n_lvl2_grefs, lvl2_table_pages);

    error_cleanup_lvl3:
    if (lvl3_unmap_ops.handle != -1)
    - gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1);
    + gnttab_unmap_refs(&lvl3_unmap_ops, NULL,
    + &lvl3_table_page, 1);
    gnttab_free_pages(1, &lvl3_table_page);

    kfree(lvl2_table_pages);
    @@ -463,20 +486,20 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
    int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
    struct xen_shared_pages_info *sh_pages_info;

    - dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);

    sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);

    if (sh_pages_info->unmap_ops == NULL ||
    sh_pages_info->data_pages == NULL) {
    - dev_warn(hyper_dmabuf_private.device,
    - "Imported pages already cleaned up or buffer was not imported yet\n");
    + dev_warn(hy_drv_priv->dev,
    + "pages already cleaned up or buffer not imported yet\n");
    return 0;
    }

    if (gnttab_unmap_refs(sh_pages_info->unmap_ops, NULL,
    sh_pages_info->data_pages, nents) ) {
    - dev_err(hyper_dmabuf_private.device, "Cannot unmap data pages\n");
    + dev_err(hy_drv_priv->dev, "Cannot unmap data pages\n");
    return -EFAULT;
    }

    @@ -489,6 +512,6 @@ int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
    kfree(sh_pages_info);
    sh_pages_info = NULL;

    - dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
    + dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
    return 0;
    }
    --
    2.7.4
    \
     
     \ /
      Last update: 2017-12-19 20:41    [W:7.683 / U:0.040 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site