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;
 }
