diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
index 525ee78..023d7f4 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
@@ -44,7 +44,6 @@
 
 #ifdef CONFIG_HYPER_DMABUF_XEN
 #include "xen/hyper_dmabuf_xen_drv.h"
-extern struct hyper_dmabuf_backend_ops xen_backend_ops;
 #endif
 
 MODULE_LICENSE("GPL and additional rights");
@@ -52,14 +51,11 @@ MODULE_AUTHOR("Intel Corporation");
 
 struct hyper_dmabuf_private *hy_drv_priv;
 
-long hyper_dmabuf_ioctl(struct file *filp,
-			unsigned int cmd, unsigned long param);
-
-static void hyper_dmabuf_force_free(struct exported_sgt_info* exported,
-			            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;
+	struct file *filp = (struct file *)attr;
 
 	if (!filp || !exported)
 		return;
@@ -97,7 +93,8 @@ int hyper_dmabuf_release(struct inode *inode, struct file *filp)
 
 #ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
 
-unsigned int hyper_dmabuf_event_poll(struct file *filp, struct poll_table_struct *wait)
+unsigned int hyper_dmabuf_event_poll(struct file *filp,
+				     struct poll_table_struct *wait)
 {
 	unsigned int mask = 0;
 
@@ -153,15 +150,17 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
 
 			mutex_unlock(&hy_drv_priv->event_read_lock);
 			ret = wait_event_interruptible(hy_drv_priv->event_wait,
-						       !list_empty(&hy_drv_priv->event_list));
+				  !list_empty(&hy_drv_priv->event_list));
 
 			if (ret == 0)
-				ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock);
+				ret = mutex_lock_interruptible(
+					&hy_drv_priv->event_read_lock);
 
 			if (ret)
 				return ret;
 		} else {
-			unsigned length = (sizeof(struct hyper_dmabuf_event_hdr) + e->event_data.hdr.size);
+			unsigned int length = (sizeof(e->event_data.hdr) +
+						      e->event_data.hdr.size);
 
 			if (length > count - ret) {
 put_back_event:
@@ -172,20 +171,22 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
 			}
 
 			if (copy_to_user(buffer + ret, &e->event_data.hdr,
-					 sizeof(struct hyper_dmabuf_event_hdr))) {
+					 sizeof(e->event_data.hdr))) {
 				if (ret == 0)
 					ret = -EFAULT;
 
 				goto put_back_event;
 			}
 
-			ret += sizeof(struct hyper_dmabuf_event_hdr);
+			ret += sizeof(e->event_data.hdr);
 
-			if (copy_to_user(buffer + ret, e->event_data.data, e->event_data.hdr.size)) {
+			if (copy_to_user(buffer + ret, e->event_data.data,
+					 e->event_data.hdr.size)) {
 				/* error while copying void *data */
 
 				struct hyper_dmabuf_event_hdr dummy_hdr = {0};
-				ret -= sizeof(struct hyper_dmabuf_event_hdr);
+
+				ret -= sizeof(e->event_data.hdr);
 
 				/* nullifying hdr of the event in user buffer */
 				if (copy_to_user(buffer + ret, &dummy_hdr,
@@ -212,8 +213,7 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
 
 #endif
 
-static struct file_operations hyper_dmabuf_driver_fops =
-{
+static const struct file_operations hyper_dmabuf_driver_fops = {
 	.owner = THIS_MODULE,
 	.open = hyper_dmabuf_open,
 	.release = hyper_dmabuf_release,
@@ -246,7 +246,7 @@ int register_device(void)
 
 	hy_drv_priv->dev = hyper_dmabuf_miscdev.this_device;
 
-	/* TODO: Check if there is a different way to initialize dma mask nicely */
+	/* TODO: Check if there is a different way to initialize dma mask */
 	dma_coerce_mask_and_coherent(hy_drv_priv->dev, DMA_BIT_MASK(64));
 
 	return ret;
@@ -264,32 +264,30 @@ static int __init hyper_dmabuf_drv_init(void)
 {
 	int ret = 0;
 
-	printk( KERN_NOTICE "hyper_dmabuf_starting: Initialization started\n");
+	printk(KERN_NOTICE "hyper_dmabuf_starting: Initialization started\n");
 
 	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");
+		printk(KERN_ERR "hyper_dmabuf: Failed to create drv\n");
 		return -1;
 	}
 
 	ret = register_device();
-	if (ret < 0) {
+	if (ret < 0)
 		return ret;
-	}
 
 /* currently only supports XEN hypervisor */
-
 #ifdef CONFIG_HYPER_DMABUF_XEN
 	hy_drv_priv->backend_ops = &xen_backend_ops;
 #else
 	hy_drv_priv->backend_ops = NULL;
-	printk( KERN_ERR "hyper_dmabuf drv currently supports XEN only.\n");
+	printk(KERN_ERR "hyper_dmabuf drv currently supports XEN only.\n");
 #endif
 
 	if (hy_drv_priv->backend_ops == NULL) {
-		printk( KERN_ERR "Hyper_dmabuf: failed to be loaded - no backend found\n");
+		printk(KERN_ERR "Hyper_dmabuf: no backend found\n");
 		return -1;
 	}
 
@@ -385,10 +383,7 @@ static void hyper_dmabuf_drv_exit(void)
 	dev_info(hy_drv_priv->dev,
 		 "hyper_dmabuf driver: Exiting\n");
 
-	if (hy_drv_priv) {
-		kfree(hy_drv_priv);
-		hy_drv_priv = NULL;
-	}
+	kfree(hy_drv_priv);
 
 	unregister_device();
 }
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
index 2ead41b..049c694 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 *dev;
+	struct device *dev;
 
 	/* VM(domain) id of current VM instance */
 	int domid;
@@ -57,8 +57,8 @@ struct hyper_dmabuf_private {
 	/* flag that shows whether backend is initialized */
 	bool initialized;
 
-        wait_queue_head_t event_wait;
-        struct list_head event_list;
+	wait_queue_head_t event_wait;
+	struct list_head event_list;
 
 	spinlock_t event_lock;
 	struct mutex event_read_lock;
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
index 0498cda..a4945af 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
@@ -44,7 +44,8 @@ static void hyper_dmabuf_send_event_locked(struct hyper_dmabuf_event *e)
 	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 */
+	 * then remove the oldest event in the 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);
@@ -61,7 +62,7 @@ static void hyper_dmabuf_send_event_locked(struct hyper_dmabuf_event *e)
 	wake_up_interruptible(&hy_drv_priv->event_wait);
 }
 
-void hyper_dmabuf_events_release()
+void hyper_dmabuf_events_release(void)
 {
 	struct hyper_dmabuf_event *e, *et;
 	unsigned long irqflags;
@@ -100,15 +101,12 @@ int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid)
 
 	e = kzalloc(sizeof(*e), GFP_KERNEL);
 
-	if (!e) {
-		dev_err(hy_drv_priv->dev,
-			"no space left\n");
+	if (!e)
 		return -ENOMEM;
-	}
 
 	e->event_data.hdr.event_type = HYPER_DMABUF_NEW_IMPORT;
 	e->event_data.hdr.hid = hid;
-	e->event_data.data = (void*)imported->priv;
+	e->event_data.data = (void *)imported->priv;
 	e->event_data.hdr.size = imported->sz_priv;
 
 	spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
index e2466c7..312dea5 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
@@ -40,11 +40,8 @@ void store_reusable_hid(hyper_dmabuf_id_t hid)
 
 	new_reusable = kmalloc(sizeof(*new_reusable), GFP_KERNEL);
 
-	if (!new_reusable) {
-		dev_err(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
+	if (!new_reusable)
 		return;
-	}
 
 	new_reusable->hid = hid;
 
@@ -54,7 +51,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 = hy_drv_priv->id_queue;
-	hyper_dmabuf_id_t hid = {-1, {0,0,0}};
+	hyper_dmabuf_id_t hid = {-1, {0, 0, 0} };
 
 	/* check there is reusable id */
 	if (!list_empty(&reusable_head->list)) {
@@ -92,7 +89,7 @@ void destroy_reusable_list(void)
 
 hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
 {
-	static int count = 0;
+	static int count;
 	hyper_dmabuf_id_t hid;
 	struct list_reusable_id *reusable_head;
 
@@ -100,13 +97,11 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
 	if (count == 0) {
 		reusable_head = kmalloc(sizeof(*reusable_head), GFP_KERNEL);
 
-		if (!reusable_head) {
-			dev_err(hy_drv_priv->dev,
-				"No memory left to be allocated\n");
-			return (hyper_dmabuf_id_t){-1, {0,0,0}};
-		}
+		if (!reusable_head)
+			return (hyper_dmabuf_id_t){-1, {0, 0, 0} };
 
-		reusable_head->hid.id = -1; /* list head has an invalid count */
+		/* list head has an invalid count */
+		reusable_head->hid.id = -1;
 		INIT_LIST_HEAD(&reusable_head->list);
 		hy_drv_priv->id_queue = reusable_head;
 	}
@@ -116,9 +111,8 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
 	/*creating a new H-ID only if nothing in the reusable id queue
 	 * and count is less than maximum allowed
 	 */
-	if (hid.id == -1 && count < HYPER_DMABUF_ID_MAX) {
+	if (hid.id == -1 && count < HYPER_DMABUF_ID_MAX)
 		hid.id = HYPER_DMABUF_ID_CREATE(hy_drv_priv->domid, count++);
-	}
 
 	/* random data embedded in the id for security */
 	get_random_bytes(&hid.rng_key[0], 12);
@@ -131,7 +125,7 @@ bool hyper_dmabuf_hid_keycomp(hyper_dmabuf_id_t hid1, hyper_dmabuf_id_t hid2)
 	int i;
 
 	/* compare keys */
-	for (i=0; i<3; i++) {
+	for (i = 0; i < 3; i++) {
 		if (hid1.rng_key[i] != hid2.rng_key[i])
 			return false;
 	}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h
index a3336d9..61c4fb3 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h
@@ -26,10 +26,10 @@
 #define __HYPER_DMABUF_ID_H__
 
 #define HYPER_DMABUF_ID_CREATE(domid, cnt) \
-        ((((domid) & 0xFF) << 24) | ((cnt) & 0xFFFFFF))
+	((((domid) & 0xFF) << 24) | ((cnt) & 0xFFFFFF))
 
 #define HYPER_DMABUF_DOM_ID(hid) \
-        (((hid.id) >> 24) & 0xFF)
+	(((hid.id) >> 24) & 0xFF)
 
 /* currently maximum number of buffers shared
  * at any given moment is limited to 1000
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
index b328df7..f9040ed 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
@@ -91,7 +91,7 @@ static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported,
 	/* now create request for importer via ring */
 	op[0] = exported->hid.id;
 
-	for (i=0; i<3; i++)
+	for (i = 0; i < 3; i++)
 		op[i+1] = exported->hid.rng_key[i];
 
 	if (pg_info) {
@@ -113,10 +113,8 @@ static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported,
 
 	req = kcalloc(1, sizeof(*req), GFP_KERNEL);
 
-	if(!req) {
-		dev_err(hy_drv_priv->dev, "no more space left\n");
+	if (!req)
 		return -1;
-	}
 
 	/* composing a message to the importer */
 	hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT, &op[0]);
@@ -161,69 +159,71 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
 					     export_remote_attr->remote_domain);
 	if (hid.id != -1) {
 		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 (exported->unexport_sched) {
-					if (!cancel_delayed_work_sync(&exported->unexport)) {
-						dma_buf_put(dma_buf);
-						goto reexport;
-					}
-					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 != exported->sz_priv) {
-					kfree(exported->priv);
-
-					/* truncating size */
-					if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) {
-						exported->sz_priv = MAX_SIZE_PRIV_DATA;
-					} else {
-						exported->sz_priv = export_remote_attr->sz_priv;
-					}
-
-					exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL);
-
-					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 */
-				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;
-					}
-				}
 
+		if (!exported)
+			goto reexport;
+
+		if (exported->valid == false)
+			goto reexport;
+
+		/*
+		 * 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 (exported->unexport_sched) {
+			if (!cancel_delayed_work_sync(&exported->unexport)) {
 				dma_buf_put(dma_buf);
-				export_remote_attr->hid = hid;
-				return ret;
+				goto reexport;
 			}
+			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 != exported->sz_priv) {
+			kfree(exported->priv);
+
+			/* truncating size */
+			if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA)
+				exported->sz_priv = MAX_SIZE_PRIV_DATA;
+			else
+				exported->sz_priv = export_remote_attr->sz_priv;
+
+			exported->priv = kcalloc(1, exported->sz_priv,
+						 GFP_KERNEL);
+
+			if (!exported->priv) {
+				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 */
+		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 ret;
 	}
 
 reexport:
@@ -244,25 +244,22 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
 
 	exported = kcalloc(1, sizeof(*exported), GFP_KERNEL);
 
-	if(!exported) {
-		dev_err(hy_drv_priv->dev, "no more space left\n");
+	if (!exported) {
 		ret = -ENOMEM;
 		goto fail_sgt_info_creation;
 	}
 
 	/* possible truncation */
-	if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) {
+	if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA)
 		exported->sz_priv = MAX_SIZE_PRIV_DATA;
-	} else {
+	else
 		exported->sz_priv = export_remote_attr->sz_priv;
-	}
 
 	/* creating buffer for private data of buffer */
-	if(exported->sz_priv != 0) {
+	if (exported->sz_priv != 0) {
 		exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL);
 
-		if(!exported->priv) {
-			dev_err(hy_drv_priv->dev, "no more space left\n");
+		if (!exported->priv) {
 			ret = -ENOMEM;
 			goto fail_priv_creation;
 		}
@@ -273,7 +270,7 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
 	exported->hid = hyper_dmabuf_get_hid();
 
 	/* no more exported dmabuf allowed */
-	if(exported->hid.id == -1) {
+	if (exported->hid.id == -1) {
 		dev_err(hy_drv_priv->dev,
 			"exceeds allowed number of dmabuf to be exported\n");
 		ret = -ENOMEM;
@@ -286,28 +283,27 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
 
 	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;
 	}
 
-	exported->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL);
+	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;
 	}
 
-	exported->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL);
+	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;
 	}
 
-	exported->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL);
+	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;
 	}
@@ -436,31 +432,32 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
 	/* send notification for export_fd to exporter */
 	op[0] = imported->hid.id;
 
-	for (i=0; i<3; i++)
+	for (i = 0; i < 3; i++)
 		op[i+1] = imported->hid.rng_key[i];
 
-	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]);
+	dev_dbg(hy_drv_priv->dev, "Export 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(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
+	if (!req)
 		return -ENOMEM;
-	}
 
 	hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD, &op[0]);
 
 	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_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]);
+		/* in case of timeout other end eventually will receive request,
+		 * so we need to undo it
+		 */
+		hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED,
+					&op[0]);
 		ops->send_req(op[0], req, false);
 		kfree(req);
-		dev_err(hy_drv_priv->dev, "Failed to create sgt or notify exporter\n");
+		dev_err(hy_drv_priv->dev,
+			"Failed to create sgt or notify exporter\n");
 		imported->importers--;
 		mutex_unlock(&hy_drv_priv->lock);
 		return ret;
@@ -471,64 +468,69 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
 	if (ret == HYPER_DMABUF_REQ_ERROR) {
 		dev_err(hy_drv_priv->dev,
 			"Buffer invalid {id:%d key:%d %d %d}, cannot import\n",
-			imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
-			imported->hid.rng_key[2]);
+			imported->hid.id, imported->hid.rng_key[0],
+			imported->hid.rng_key[1], imported->hid.rng_key[2]);
 
 		imported->importers--;
 		mutex_unlock(&hy_drv_priv->lock);
 		return -EINVAL;
-	} else {
-		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;
 	}
 
+	ret = 0;
+
+	dev_dbg(hy_drv_priv->dev,
+		"Found buffer gref %d off %d\n",
+		imported->ref_handle, imported->frst_ofst);
+
 	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));
+		"last len %d nents %d domain %d\n",
+		imported->last_len, imported->nents,
+		HYPER_DMABUF_DOM_ID(imported->hid));
 
 	if (!imported->sgt) {
 		dev_dbg(hy_drv_priv->dev,
-			"%s buffer {id:%d key:%d %d %d} pages not mapped yet\n", __func__,
-			imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
-			imported->hid.rng_key[2]);
+			"buffer {id:%d key:%d %d %d} pages not mapped yet\n",
+			imported->hid.id, imported->hid.rng_key[0],
+			imported->hid.rng_key[1], imported->hid.rng_key[2]);
 
 		data_pgs = ops->map_shared_pages(imported->ref_handle,
-						   HYPER_DMABUF_DOM_ID(imported->hid),
-						   imported->nents,
-						   &imported->refs_info);
+					HYPER_DMABUF_DOM_ID(imported->hid),
+					imported->nents,
+					&imported->refs_info);
 
 		if (!data_pgs) {
 			dev_err(hy_drv_priv->dev,
-				"Cannot map pages of buffer {id:%d key:%d %d %d}\n",
-				imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+				"can't map pages hid {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]);
 
 			imported->importers--;
+
 			req = kcalloc(1, sizeof(*req), GFP_KERNEL);
 
-			if (!req) {
-				dev_err(hy_drv_priv->dev,
-					"No more space left\n");
+			if (!req)
 				return -ENOMEM;
-			}
 
-			hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]);
-			ops->send_req(HYPER_DMABUF_DOM_ID(imported->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(&hy_drv_priv->lock);
 			return -EINVAL;
 		}
 
-		imported->sgt = hyper_dmabuf_create_sgt(data_pgs, imported->frst_ofst,
-							imported->last_len, imported->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(imported, 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 */
@@ -566,21 +568,19 @@ static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
 
 	req = kcalloc(1, sizeof(*req), GFP_KERNEL);
 
-	if (!req) {
-		dev_err(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
+	if (!req)
 		return;
-	}
 
 	op[0] = exported->hid.id;
 
-	for (i=0; i<3; i++)
+	for (i = 0; i < 3; i++)
 		op[i+1] = exported->hid.rng_key[i];
 
 	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 */
+	 * that buffer should not be used anymore
+	 */
 	ret = ops->send_req(exported->rdomid, req, true);
 	if (ret < 0) {
 		dev_err(hy_drv_priv->dev,
@@ -589,12 +589,10 @@ static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
 			exported->hid.rng_key[1], exported->hid.rng_key[2]);
 	}
 
-	/* free msg */
 	kfree(req);
 	exported->unexport_sched = false;
 
-	/*
-	 * Immediately clean-up if it has never been exported by importer
+	/* Immediately clean-up if it has never been exported by importer
 	 * (so no SGT is constructed on importer).
 	 * clean it up later in remote sync when final release ops
 	 * is called (importer does this only when there's no
@@ -669,25 +667,31 @@ static int hyper_dmabuf_query_ioctl(struct file *filp, void *data)
 		exported = hyper_dmabuf_find_exported(query_attr->hid);
 		if (exported) {
 			ret = hyper_dmabuf_query_exported(exported,
-							  query_attr->item, &query_attr->info);
+							  query_attr->item,
+							  &query_attr->info);
 		} else {
 			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]);
+				"hid {id:%d key:%d %d %d} not in exp 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 = hyper_dmabuf_find_imported(query_attr->hid);
 		if (imported) {
-			ret = hyper_dmabuf_query_imported(imported, query_attr->item,
+			ret = hyper_dmabuf_query_imported(imported,
+							  query_attr->item,
 							  &query_attr->info);
 		} else {
 			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]);
+				"hid {id:%d key:%d %d %d} not in imp 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;
 		}
 	}
@@ -696,12 +700,18 @@ static int hyper_dmabuf_query_ioctl(struct file *filp, void *data)
 }
 
 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),
-	HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORT_REMOTE, hyper_dmabuf_export_remote_ioctl, 0),
-	HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORT_FD, hyper_dmabuf_export_fd_ioctl, 0),
-	HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_UNEXPORT, hyper_dmabuf_unexport_ioctl, 0),
-	HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_QUERY, hyper_dmabuf_query_ioctl, 0),
+	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),
+	HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORT_REMOTE,
+			       hyper_dmabuf_export_remote_ioctl, 0),
+	HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORT_FD,
+			       hyper_dmabuf_export_fd_ioctl, 0),
+	HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_UNEXPORT,
+			       hyper_dmabuf_unexport_ioctl, 0),
+	HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_QUERY,
+			       hyper_dmabuf_query_ioctl, 0),
 };
 
 long hyper_dmabuf_ioctl(struct file *filp,
@@ -728,21 +738,23 @@ long hyper_dmabuf_ioctl(struct file *filp,
 	}
 
 	kdata = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
-	if (!kdata) {
-		dev_err(hy_drv_priv->dev, "no memory\n");
+	if (!kdata)
 		return -ENOMEM;
-	}
 
-	if (copy_from_user(kdata, (void __user *)param, _IOC_SIZE(cmd)) != 0) {
-		dev_err(hy_drv_priv->dev, "failed to copy from user arguments\n");
+	if (copy_from_user(kdata, (void __user *)param,
+			   _IOC_SIZE(cmd)) != 0) {
+		dev_err(hy_drv_priv->dev,
+			"failed to copy from user arguments\n");
 		ret = -EFAULT;
 		goto ioctl_error;
 	}
 
 	ret = func(filp, kdata);
 
-	if (copy_to_user((void __user *)param, kdata, _IOC_SIZE(cmd)) != 0) {
-		dev_err(hy_drv_priv->dev, "failed to copy to user arguments\n");
+	if (copy_to_user((void __user *)param, kdata,
+			 _IOC_SIZE(cmd)) != 0) {
+		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 3e9470a..5991a87 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
@@ -34,7 +34,7 @@ struct hyper_dmabuf_ioctl_desc {
 	const char *name;
 };
 
-#define HYPER_DMABUF_IOCTL_DEF(ioctl, _func, _flags) 	\
+#define HYPER_DMABUF_IOCTL_DEF(ioctl, _func, _flags)	\
 	[_IOC_NR(ioctl)] = {				\
 			.cmd = ioctl,			\
 			.func = _func,			\
@@ -42,6 +42,9 @@ struct hyper_dmabuf_ioctl_desc {
 			.name = #ioctl			\
 	}
 
+long hyper_dmabuf_ioctl(struct file *filp,
+			unsigned int cmd, unsigned long param);
+
 int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data);
 
 #endif //__HYPER_DMABUF_IOCTL_H__
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
index 907f76e..fbbcc39 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
@@ -52,18 +52,19 @@ void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
 	req->stat = HYPER_DMABUF_REQ_NOT_RESPONDED;
 	req->cmd = cmd;
 
-	switch(cmd) {
+	switch (cmd) {
 	/* as exporter, commands to importer */
 	case HYPER_DMABUF_EXPORT:
 		/* exporting pages for dmabuf */
 		/* command : HYPER_DMABUF_EXPORT,
-		 * op0~3 : hyper_dmabuf_id
+		 * op0~op3 : 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)
+		 * op9 ~ : Driver-specific private data
+		 *	   (e.g. graphic buffer's meta info)
 		 */
 
 		memcpy(&req->op[0], &op[0], 9 * sizeof(int) + op[8]);
@@ -72,34 +73,39 @@ void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
 	case HYPER_DMABUF_NOTIFY_UNEXPORT:
 		/* destroy sg_list for hyper_dmabuf_id on remote side */
 		/* command : DMABUF_DESTROY,
-		 * op0~3 : hyper_dmabuf_id_t hid
+		 * op0~op3 : hyper_dmabuf_id_t hid
 		 */
 
-		for (i=0; i < 4; i++)
+		for (i = 0; i < 4; 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,
-		 * op0~3 : hyper_dmabuf_id
+		/* dmabuf fd is being created on imported side or importing
+		 * failed
+		 *
+		 * command : HYPER_DMABUF_EXPORT_FD or
+		 *	     HYPER_DMABUF_EXPORT_FD_FAILED,
+		 * op0~op3 : hyper_dmabuf_id
 		 */
 
-		for (i=0; i < 4; i++)
+		for (i = 0; i < 4; i++)
 			req->op[i] = op[i];
 		break;
 
 	case HYPER_DMABUF_OPS_TO_REMOTE:
-		/* notifying dmabuf map/unmap to importer (probably not needed) */
-		/* for dmabuf synchronization */
+		/* notifying dmabuf map/unmap to importer (probably not needed)
+		 * for dmabuf synchronization
+		 */
 		break;
 
-	/* as importer, command to exporter */
 	case 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.
+		/* 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.
 		 * op0~3 : hyper_dmabuf_id
 		 * op4 : map(=1)/unmap(=2)/attach(=3)/detach(=4)
 		 */
@@ -116,7 +122,8 @@ void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
 static void cmd_process_work(struct work_struct *work)
 {
 	struct imported_sgt_info *imported;
-	struct cmd_process *proc = container_of(work, struct cmd_process, work);
+	struct cmd_process *proc = container_of(work,
+						struct cmd_process, work);
 	struct hyper_dmabuf_req *req;
 	int domid;
 	int i;
@@ -128,40 +135,42 @@ static void cmd_process_work(struct work_struct *work)
 	case HYPER_DMABUF_EXPORT:
 		/* exporting pages for dmabuf */
 		/* command : HYPER_DMABUF_EXPORT,
-		 * op0~3 : hyper_dmabuf_id
+		 * op0~op3 : 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)
+		 * 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 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->op[4] == 0) {
 			hyper_dmabuf_id_t exist = {req->op[0],
 						   {req->op[1], req->op[2],
-						   req->op[3]}};
+						   req->op[3] } };
 
 			imported = hyper_dmabuf_find_imported(exist);
 
 			if (!imported) {
 				dev_err(hy_drv_priv->dev,
-					"Can't find imported sgt_info from IMPORT_LIST\n");
+					"Can't find imported sgt_info\n");
 				break;
 			}
 
 			/* if size of new private data is different,
-			 * we reallocate it. */
+			 * we reallocate it.
+			 */
 			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);
+				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->valid = 0;
 					break;
@@ -181,26 +190,20 @@ static void cmd_process_work(struct work_struct *work)
 
 		imported = kcalloc(1, sizeof(*imported), GFP_KERNEL);
 
-		if (!imported) {
-			dev_err(hy_drv_priv->dev,
-				"No memory left to be allocated\n");
+		if (!imported)
 			break;
-		}
 
 		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");
-
 			kfree(imported);
 			break;
 		}
 
 		imported->hid.id = req->op[0];
 
-		for (i=0; i<3; i++)
+		for (i = 0; i < 3; i++)
 			imported->hid.rng_key[i] = req->op[i+1];
 
 		imported->nents = req->op[4];
@@ -230,13 +233,13 @@ static void cmd_process_work(struct work_struct *work)
 		break;
 
 	case HYPER_DMABUF_OPS_TO_REMOTE:
-		/* notifying dmabuf map/unmap to importer (probably not needed) */
-		/* for dmabuf synchronization */
+		/* notifying dmabuf map/unmap to importer
+		 * (probably not needed) for dmabuf synchronization
+		 */
 		break;
 
 	default:
 		/* shouldn't get here */
-		/* no matched command, nothing to do.. just return error */
 		break;
 	}
 
@@ -280,20 +283,22 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 		 * op0~3 : hyper_dmabuf_id
 		 */
 		dev_dbg(hy_drv_priv->dev,
-			"%s: processing HYPER_DMABUF_NOTIFY_UNEXPORT\n", __func__);
+			"processing HYPER_DMABUF_NOTIFY_UNEXPORT\n");
 
 		imported = hyper_dmabuf_find_imported(hid);
 
 		if (imported) {
 			/* if anything is still using dma_buf */
 			if (imported->importers) {
-				/*
-				 * Buffer is still in  use, just mark that it should
-				 * not be allowed to export its fd anymore.
+				/* Buffer is still in  use, just mark that
+				 * it should not be allowed to export its fd
+				 * anymore.
 				 */
 				imported->valid = false;
 			} else {
-				/* No one is using buffer, remove it from imported list */
+				/* No one is using buffer, remove it from
+				 * imported list
+				 */
 				hyper_dmabuf_remove_imported(hid);
 				kfree(imported);
 			}
@@ -306,10 +311,12 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 
 	/* dma buf remote synchronization */
 	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.
+		/* 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.
 		 * op0~3 : hyper_dmabuf_id
 		 * op1 : enum hyper_dmabuf_ops {....}
 		 */
@@ -330,27 +337,30 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 	if (req->cmd == HYPER_DMABUF_EXPORT_FD) {
 		/* find a corresponding SGT for the id */
 		dev_dbg(hy_drv_priv->dev,
-			"Processing HYPER_DMABUF_EXPORT_FD for buffer {id:%d key:%d %d %d}\n",
+			"HYPER_DMABUF_EXPORT_FD for {id:%d key:%d %d %d}\n",
 			hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
 
 		exported = hyper_dmabuf_find_exported(hid);
 
 		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]);
+				"buffer {id:%d key:%d %d %d} not found\n",
+				hid.id, hid.rng_key[0], hid.rng_key[1],
+				hid.rng_key[2]);
 
 			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]);
+				"Buffer no longer valid {id:%d key:%d %d %d}\n",
+				hid.id, hid.rng_key[0], hid.rng_key[1],
+				hid.rng_key[2]);
 
 			req->stat = HYPER_DMABUF_REQ_ERROR;
 		} else {
 			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]);
+				"Buffer still valid {id:%d key:%d %d %d}\n",
+				hid.id, hid.rng_key[0], hid.rng_key[1],
+				hid.rng_key[2]);
 
 			exported->active++;
 			req->stat = HYPER_DMABUF_REQ_PROCESSED;
@@ -360,15 +370,16 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 
 	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",
+			"HYPER_DMABUF_EXPORT_FD_FAILED for {id:%d key:%d %d %d}\n",
 			hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
 
 		exported = hyper_dmabuf_find_exported(hid);
 
 		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]);
+				"buffer {id:%d key:%d %d %d} not found\n",
+				hid.id, hid.rng_key[0], hid.rng_key[1],
+				hid.rng_key[2]);
 
 			req->stat = HYPER_DMABUF_REQ_ERROR;
 		} else {
@@ -382,19 +393,14 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 		"%s: putting request to workqueue\n", __func__);
 	temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL);
 
-	if (!temp_req) {
-		dev_err(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
+	if (!temp_req)
 		return -ENOMEM;
-	}
 
 	memcpy(temp_req, req, sizeof(*temp_req));
 
 	proc = kcalloc(1, sizeof(struct cmd_process), GFP_KERNEL);
 
 	if (!proc) {
-		dev_err(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
 		kfree(temp_req);
 		return -ENOMEM;
 	}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
index 7c694ec..9c8a76b 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
@@ -79,7 +79,9 @@ void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
 				 enum hyper_dmabuf_command command,
 				 int *operands);
 
-/* parse incoming request packet (or response) and take appropriate actions for those */
+/* parse incoming request packet (or response) and take
+ * appropriate actions for those
+ */
 int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req);
 
 #endif // __HYPER_DMABUF_MSG_H__
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
index 7e73170..03fdd30 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
@@ -53,18 +53,15 @@ static int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
 
 	op[0] = hid.id;
 
-	for (i=0; i<3; i++)
+	for (i = 0; i < 3; i++)
 		op[i+1] = hid.rng_key[i];
 
 	op[4] = dmabuf_ops;
 
 	req = kcalloc(1, sizeof(*req), GFP_KERNEL);
 
-	if (!req) {
-		dev_err(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
+	if (!req)
 		return -ENOMEM;
-	}
 
 	hyper_dmabuf_create_req(req, HYPER_DMABUF_OPS_TO_SOURCE, &op[0]);
 
@@ -81,8 +78,8 @@ static int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
 	return ret;
 }
 
-static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf,
-				   struct device* dev,
+static int hyper_dmabuf_ops_attach(struct dma_buf *dmabuf,
+				   struct device *dev,
 				   struct dma_buf_attachment *attach)
 {
 	struct imported_sgt_info *imported;
@@ -99,7 +96,7 @@ static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf,
 	return ret;
 }
 
-static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf,
+static void hyper_dmabuf_ops_detach(struct dma_buf *dmabuf,
 				    struct dma_buf_attachment *attach)
 {
 	struct imported_sgt_info *imported;
@@ -114,8 +111,9 @@ static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf,
 					HYPER_DMABUF_OPS_DETACH);
 }
 
-static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachment,
-					     enum dma_data_direction dir)
+static struct sg_table *hyper_dmabuf_ops_map(
+				struct dma_buf_attachment *attachment,
+				enum dma_data_direction dir)
 {
 	struct sg_table *st;
 	struct imported_sgt_info *imported;
@@ -130,9 +128,8 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme
 	/* extract pages from sgt */
 	pg_info = hyper_dmabuf_ext_pgs(imported->sgt);
 
-	if (!pg_info) {
+	if (!pg_info)
 		return NULL;
-	}
 
 	/* create a new sg_table with extracted pages */
 	st = hyper_dmabuf_create_sgt(pg_info->pgs, pg_info->frst_ofst,
@@ -140,8 +137,8 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme
 	if (!st)
 		goto err_free_sg;
 
-        if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir))
-                goto err_free_sg;
+	if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir))
+		goto err_free_sg;
 
 	ret = hyper_dmabuf_sync_request(imported->hid,
 					HYPER_DMABUF_OPS_MAP);
@@ -196,9 +193,8 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
 
 	imported = (struct imported_sgt_info *)dma_buf->priv;
 
-	if (!dmabuf_refcount(imported->dma_buf)) {
+	if (!dmabuf_refcount(imported->dma_buf))
 		imported->dma_buf = NULL;
-	}
 
 	imported->importers--;
 
@@ -219,8 +215,9 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
 					HYPER_DMABUF_OPS_RELEASE);
 
 	/*
-	 * Check if buffer is still valid and if not remove it from imported list.
-	 * That has to be done after sending sync request
+	 * Check if buffer is still valid and if not remove it
+	 * from imported list. That has to be done after sending
+	 * sync request
 	 */
 	if (finish) {
 		hyper_dmabuf_remove_imported(imported->hid);
@@ -228,7 +225,8 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
 	}
 }
 
-static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
+static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf,
+					     enum dma_data_direction dir)
 {
 	struct imported_sgt_info *imported;
 	int ret;
@@ -244,7 +242,8 @@ static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_da
 	return ret;
 }
 
-static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
+static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf,
+					   enum dma_data_direction dir)
 {
 	struct imported_sgt_info *imported;
 	int ret;
@@ -260,7 +259,8 @@ static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf, enum dma_data
 	return 0;
 }
 
-static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum)
+static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf,
+					  unsigned long pgnum)
 {
 	struct imported_sgt_info *imported;
 	int ret;
@@ -273,10 +273,12 @@ static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf, unsigned long
 	ret = hyper_dmabuf_sync_request(imported->hid,
 					HYPER_DMABUF_OPS_KMAP_ATOMIC);
 
-	return NULL; /* for now NULL.. need to return the address of mapped region */
+	/* TODO: NULL for now. Need to return the addr of mapped region */
+	return NULL;
 }
 
-static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr)
+static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf,
+					   unsigned long pgnum, void *vaddr)
 {
 	struct imported_sgt_info *imported;
 	int ret;
@@ -322,7 +324,8 @@ static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum,
 					HYPER_DMABUF_OPS_KUNMAP);
 }
 
-static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
+static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf,
+				 struct vm_area_struct *vma)
 {
 	struct imported_sgt_info *imported;
 	int ret;
@@ -374,8 +377,8 @@ static const struct dma_buf_ops hyper_dmabuf_ops = {
 	.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,
+	.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,
@@ -395,9 +398,8 @@ int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags)
 	 */
 	hyper_dmabuf_export_dma_buf(imported);
 
-	if (imported->dma_buf) {
+	if (imported->dma_buf)
 		fd = dma_buf_fd(imported->dma_buf, flags);
-	}
 
 	return fd;
 }
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
index 36e888c..1f2f56b 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
@@ -36,63 +36,63 @@
 	((nents)*PAGE_SIZE - (first_offset) - PAGE_SIZE + (last_len))
 
 int hyper_dmabuf_query_exported(struct exported_sgt_info *exported,
-				int query, unsigned long* info)
+				int query, unsigned long *info)
 {
-	switch (query)
-	{
-		case HYPER_DMABUF_QUERY_TYPE:
-			*info = EXPORTED;
-			break;
-
-		/* exporting domain of this specific dmabuf*/
-		case HYPER_DMABUF_QUERY_EXPORTER:
-			*info = HYPER_DMABUF_DOM_ID(exported->hid);
-			break;
-
-		/* importing domain of this specific dmabuf */
-		case HYPER_DMABUF_QUERY_IMPORTER:
-			*info = exported->rdomid;
-			break;
-
-		/* size of dmabuf in byte */
-		case HYPER_DMABUF_QUERY_SIZE:
-			*info = exported->dma_buf->size;
-			break;
-
-		/* whether the buffer is used by importer */
-		case HYPER_DMABUF_QUERY_BUSY:
-			*info = (exported->active > 0);
-			break;
-
-		/* whether the buffer is unexported */
-		case HYPER_DMABUF_QUERY_UNEXPORTED:
-			*info = !exported->valid;
-			break;
-
-		/* whether the buffer is scheduled to be unexported */
-		case HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED:
-			*info = !exported->unexport_sched;
-			break;
-
-		/* size of private info attached to buffer */
-		case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
-			*info = exported->sz_priv;
-			break;
-
-		/* copy private info attached to buffer */
-		case HYPER_DMABUF_QUERY_PRIV_INFO:
-			if (exported->sz_priv > 0) {
-				int n;
-				n = copy_to_user((void __user*) *info,
-						exported->priv,
-						exported->sz_priv);
-				if (n != 0)
-					return -EINVAL;
-			}
-			break;
-
-		default:
-			return -EINVAL;
+	switch (query) {
+	case HYPER_DMABUF_QUERY_TYPE:
+		*info = EXPORTED;
+		break;
+
+	/* exporting domain of this specific dmabuf*/
+	case HYPER_DMABUF_QUERY_EXPORTER:
+		*info = HYPER_DMABUF_DOM_ID(exported->hid);
+		break;
+
+	/* importing domain of this specific dmabuf */
+	case HYPER_DMABUF_QUERY_IMPORTER:
+		*info = exported->rdomid;
+		break;
+
+	/* size of dmabuf in byte */
+	case HYPER_DMABUF_QUERY_SIZE:
+		*info = exported->dma_buf->size;
+		break;
+
+	/* whether the buffer is used by importer */
+	case HYPER_DMABUF_QUERY_BUSY:
+		*info = (exported->active > 0);
+		break;
+
+	/* whether the buffer is unexported */
+	case HYPER_DMABUF_QUERY_UNEXPORTED:
+		*info = !exported->valid;
+		break;
+
+	/* whether the buffer is scheduled to be unexported */
+	case HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED:
+		*info = !exported->unexport_sched;
+		break;
+
+	/* size of private info attached to buffer */
+	case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
+		*info = exported->sz_priv;
+		break;
+
+	/* copy private info attached to buffer */
+	case HYPER_DMABUF_QUERY_PRIV_INFO:
+		if (exported->sz_priv > 0) {
+			int n;
+
+			n = copy_to_user((void __user *) *info,
+					exported->priv,
+					exported->sz_priv);
+			if (n != 0)
+				return -EINVAL;
+		}
+		break;
+
+	default:
+		return -EINVAL;
 	}
 
 	return 0;
@@ -102,66 +102,70 @@ int hyper_dmabuf_query_exported(struct exported_sgt_info *exported,
 int hyper_dmabuf_query_imported(struct imported_sgt_info *imported,
 				int query, unsigned long *info)
 {
-	switch (query)
-	{
-		case HYPER_DMABUF_QUERY_TYPE:
-			*info = IMPORTED;
-			break;
-
-		/* exporting domain of this specific dmabuf*/
-		case HYPER_DMABUF_QUERY_EXPORTER:
-			*info = HYPER_DMABUF_DOM_ID(imported->hid);
-			break;
-
-		/* importing domain of this specific dmabuf */
-		case HYPER_DMABUF_QUERY_IMPORTER:
-			*info = hy_drv_priv->domid;
-			break;
-
-		/* size of dmabuf in byte */
-		case HYPER_DMABUF_QUERY_SIZE:
-			if (imported->dma_buf) {
-				/* if local dma_buf is created (if it's ever mapped),
-				 * retrieve it directly from struct dma_buf *
-				 */
-				*info = imported->dma_buf->size;
-			} else {
-				/* calcuate it from given nents, frst_ofst and 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->importers > 0);
-			break;
-
-		/* whether the buffer is unexported */
-		case HYPER_DMABUF_QUERY_UNEXPORTED:
-			*info = !imported->valid;
-			break;
-		/* size of private info attached to buffer */
-		case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
-			*info = imported->sz_priv;
-			break;
-
-		/* copy private info attached to buffer */
-		case HYPER_DMABUF_QUERY_PRIV_INFO:
-			if (imported->sz_priv > 0) {
-				int n;
-				n = copy_to_user((void __user*) *info,
-						imported->priv,
-						imported->sz_priv);
-				if (n != 0)
-					return -EINVAL;
-			}
-			break;
-
-		default:
-			return -EINVAL;
+	switch (query) {
+	case HYPER_DMABUF_QUERY_TYPE:
+		*info = IMPORTED;
+		break;
+
+	/* exporting domain of this specific dmabuf*/
+	case HYPER_DMABUF_QUERY_EXPORTER:
+		*info = HYPER_DMABUF_DOM_ID(imported->hid);
+		break;
+
+	/* importing domain of this specific dmabuf */
+	case HYPER_DMABUF_QUERY_IMPORTER:
+		*info = hy_drv_priv->domid;
+		break;
+
+	/* size of dmabuf in byte */
+	case HYPER_DMABUF_QUERY_SIZE:
+		if (imported->dma_buf) {
+			/* if local dma_buf is created (if it's
+			 * ever mapped), retrieve it directly
+			 * from struct dma_buf *
+			 */
+			*info = imported->dma_buf->size;
+		} else {
+			/* calcuate it from given nents, frst_ofst
+			 * and 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->importers > 0);
+		break;
+
+	/* whether the buffer is unexported */
+	case HYPER_DMABUF_QUERY_UNEXPORTED:
+		*info = !imported->valid;
+		break;
+
+	/* size of private info attached to buffer */
+	case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
+		*info = imported->sz_priv;
+		break;
+
+	/* copy private info attached to buffer */
+	case HYPER_DMABUF_QUERY_PRIV_INFO:
+		if (imported->sz_priv > 0) {
+			int n;
+
+			n = copy_to_user((void __user *)*info,
+					imported->priv,
+					imported->sz_priv);
+			if (n != 0)
+				return -EINVAL;
+		}
+		break;
+
+	default:
+		return -EINVAL;
 	}
 
 	return 0;
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
index 01ec98c..c9fe040 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
@@ -76,11 +76,8 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 	case HYPER_DMABUF_OPS_ATTACH:
 		attachl = kcalloc(1, sizeof(*attachl), GFP_KERNEL);
 
-		if (!attachl) {
-			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_ATTACH\n");
+		if (!attachl)
 			return -ENOMEM;
-		}
 
 		attachl->attach = dma_buf_attach(exported->dma_buf,
 						 hy_drv_priv->dev);
@@ -126,13 +123,11 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 
 		sgtl = kcalloc(1, sizeof(*sgtl), GFP_KERNEL);
 
-		if (!sgtl) {
-			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_MAP\n");
+		if (!sgtl)
 			return -ENOMEM;
-		}
 
-		sgtl->sgt = dma_buf_map_attachment(attachl->attach, DMA_BIDIRECTIONAL);
+		sgtl->sgt = dma_buf_map_attachment(attachl->attach,
+						   DMA_BIDIRECTIONAL);
 		if (!sgtl->sgt) {
 			kfree(sgtl);
 			dev_err(hy_drv_priv->dev,
@@ -148,7 +143,7 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 			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");
+				"no SGT or attach left to be unmapped\n");
 			return -EFAULT;
 		}
 
@@ -165,23 +160,28 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 
 	case HYPER_DMABUF_OPS_RELEASE:
 		dev_dbg(hy_drv_priv->dev,
-			"Buffer {id:%d key:%d %d %d} released, references left: %d\n",
-			 exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1],
-			 exported->hid.rng_key[2], exported->active - 1);
+			"id:%d key:%d %d %d} released, ref left: %d\n",
+			 exported->hid.id, exported->hid.rng_key[0],
+			 exported->hid.rng_key[1], exported->hid.rng_key[2],
+			 exported->active - 1);
+
+		exported->active--;
 
-                exported->active--;
-		/* If there are still importers just break, if no then continue with final cleanup */
+		/* If there are still importers just break, if no then
+		 * continue with final cleanup
+		 */
 		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.
+		/* 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(hy_drv_priv->dev,
 			"Buffer {id:%d key:%d %d %d} final released\n",
-			exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1],
-			exported->hid.rng_key[2]);
+			exported->hid.id, exported->hid.rng_key[0],
+			exported->hid.rng_key[1], exported->hid.rng_key[2]);
 
 		if (!exported->valid && !exported->active &&
 		    !exported->unexport_sched) {
@@ -195,19 +195,21 @@ 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(exported->dma_buf, DMA_BIDIRECTIONAL);
+		ret = dma_buf_begin_cpu_access(exported->dma_buf,
+					       DMA_BIDIRECTIONAL);
 		if (ret) {
 			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
+				"HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
 			return ret;
 		}
 		break;
 
 	case HYPER_DMABUF_OPS_END_CPU_ACCESS:
-		ret = dma_buf_end_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL);
+		ret = dma_buf_end_cpu_access(exported->dma_buf,
+					     DMA_BIDIRECTIONAL);
 		if (ret) {
 			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
+				"HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
 			return ret;
 		}
 		break;
@@ -215,22 +217,21 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 	case HYPER_DMABUF_OPS_KMAP_ATOMIC:
 	case HYPER_DMABUF_OPS_KMAP:
 		va_kmapl = kcalloc(1, sizeof(*va_kmapl), GFP_KERNEL);
-		if (!va_kmapl) {
-			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
+		if (!va_kmapl)
 			return -ENOMEM;
-		}
 
 		/* dummy kmapping of 1 page */
 		if (ops == HYPER_DMABUF_OPS_KMAP_ATOMIC)
-			va_kmapl->vaddr = dma_buf_kmap_atomic(exported->dma_buf, 1);
+			va_kmapl->vaddr = dma_buf_kmap_atomic(
+						exported->dma_buf, 1);
 		else
-			va_kmapl->vaddr = dma_buf_kmap(exported->dma_buf, 1);
+			va_kmapl->vaddr = dma_buf_kmap(
+						exported->dma_buf, 1);
 
 		if (!va_kmapl->vaddr) {
 			kfree(va_kmapl);
 			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
+				"HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
 			return -ENOMEM;
 		}
 		list_add(&va_kmapl->list, &exported->va_kmapped->list);
@@ -240,7 +241,7 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 	case HYPER_DMABUF_OPS_KUNMAP:
 		if (list_empty(&exported->va_kmapped->list)) {
 			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
+				"HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
 			dev_err(hy_drv_priv->dev,
 				"no more dmabuf VA to be freed\n");
 			return -EFAULT;
@@ -250,15 +251,17 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 					    struct kmap_vaddr_list, list);
 		if (!va_kmapl->vaddr) {
 			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
+				"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(exported->dma_buf, 1, va_kmapl->vaddr);
+			dma_buf_kunmap_atomic(exported->dma_buf,
+					      1, va_kmapl->vaddr);
 		else
-			dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr);
+			dma_buf_kunmap(exported->dma_buf,
+				       1, va_kmapl->vaddr);
 
 		list_del(&va_kmapl->list);
 		kfree(va_kmapl);
@@ -266,7 +269,8 @@ 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 */
+		 * a dummy vma
+		 */
 		dev_warn(hy_drv_priv->dev,
 			 "remote sync::sychronized mmap is not supported\n");
 		break;
@@ -274,11 +278,8 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 	case HYPER_DMABUF_OPS_VMAP:
 		va_vmapl = kcalloc(1, sizeof(*va_vmapl), GFP_KERNEL);
 
-		if (!va_vmapl) {
-			dev_err(hy_drv_priv->dev,
-				"remote sync::HYPER_DMABUF_OPS_VMAP\n");
+		if (!va_vmapl)
 			return -ENOMEM;
-		}
 
 		/* dummy vmapping */
 		va_vmapl->vaddr = dma_buf_vmap(exported->dma_buf);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
index 315c354..e9299e5 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
@@ -89,9 +89,8 @@ struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
 	if (!pg_info)
 		return NULL;
 
-	pg_info->pgs = kmalloc(sizeof(struct page *) *
-			       hyper_dmabuf_get_num_pgs(sgt),
-			       GFP_KERNEL);
+	pg_info->pgs = kmalloc_array(hyper_dmabuf_get_num_pgs(sgt),
+				     sizeof(struct page *), GFP_KERNEL);
 
 	if (!pg_info->pgs) {
 		kfree(pg_info);
@@ -137,17 +136,17 @@ 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 **pgs,
-					 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)
 {
 	struct sg_table *sgt;
 	struct scatterlist *sgl;
 	int i, ret;
 
 	sgt = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
-	if (!sgt) {
+	if (!sgt)
 		return NULL;
-	}
 
 	ret = sg_alloc_table(sgt, nents, GFP_KERNEL);
 	if (ret) {
@@ -163,7 +162,7 @@ struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs,
 
 	sg_set_page(sgl, pgs[0], PAGE_SIZE-frst_ofst, frst_ofst);
 
-	for (i=1; i<nents-1; i++) {
+	for (i = 1; i < nents-1; i++) {
 		sgl = sg_next(sgl);
 		sg_set_page(sgl, pgs[i], PAGE_SIZE, 0);
 	}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
index 930bade..152f78c 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
@@ -31,7 +31,7 @@ int dmabuf_refcount(struct dma_buf *dma_buf);
 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 **pgs,
+struct sg_table *hyper_dmabuf_create_sgt(struct page **pgs,
 					 int frst_ofst, int last_len,
 					 int nents);
 
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
index 8a612d1..a11f804 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
@@ -51,67 +51,91 @@ struct vmap_vaddr_list {
 
 /* Exporter builds pages_info before sharing pages */
 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 **pgs; /* pages that contains reference numbers of shared pages*/
+	int frst_ofst;
+	int last_len;
+	int nents;
+	struct page **pgs;
 };
 
 
 /* Exporter stores references to sgt in a hash table
- * Exporter keeps these references for synchronization and tracking purposes
+ * Exporter keeps these references for synchronization
+ * and tracking purposes
  */
 struct exported_sgt_info {
-        hyper_dmabuf_id_t hid; /* unique id to reference dmabuf in remote domain */
-	int rdomid; /* domain importing this sgt */
+	hyper_dmabuf_id_t hid;
+
+	/* VM ID of importer */
+	int rdomid;
 
-	struct dma_buf *dma_buf; /* needed to store this for freeing it later */
+	struct dma_buf *dma_buf;
 	int nents;
 
-	/* list of remote activities on dma_buf */
+	/* list for tracking activities on dma_buf */
 	struct sgt_list *active_sgts;
 	struct attachment_list *active_attached;
 	struct kmap_vaddr_list *va_kmapped;
 	struct vmap_vaddr_list *va_vmapped;
 
-	bool valid; /* set to 0 once unexported. Needed to prevent further mapping by importer */
-	int active; /* locally shared on importer's side */
-	void *refs_info; /* hypervisor-specific info for the references */
+	/* set to 0 when unexported. Importer doesn't
+	 * do a new mapping of buffer if valid == false
+	 */
+	bool valid;
+
+	/* active == true if the buffer is actively used
+	 * (mapped) by importer
+	 */
+	int active;
+
+	/* hypervisor specific reference data for shared pages */
+	void *refs_info;
+
 	struct delayed_work unexport;
 	bool unexport_sched;
 
-	/* owner of buffer
-	 * TODO: that is naiive as buffer may be reused by
-	 * another userspace app, so here list of struct file should be kept
-	 * and emergency unexport should be executed only after last of buffer
-	 * uses releases hyper_dmabuf device
+	/* list for file pointers associated with all user space
+	 * application that have exported this same buffer to
+	 * another VM. This needs to be tracked to know whether
+	 * the buffer can be completely freed.
 	 */
 	struct file *filp;
 
+	/* size of private */
 	size_t sz_priv;
-	char *priv; /* device specific info (e.g. image's meta info?) */
+
+	/* private data associated with the exported buffer */
+	char *priv;
 };
 
-/* 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 */
+/* imported_sgt_info contains information about imported DMA_BUF
+ * this info is kept in IMPORT list and asynchorously retrieved and
+ * used to map DMA_BUF on importer VM's side upon export fd ioctl
+ * request from user-space
+ */
+
 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 */
-	int frst_ofst;	/* start offset in first shared page */
-	int last_len;	/* length of data in the last shared page */
-	int nents;	/* number of pages to be shared */
+	/* hypervisor-specific handle to pages */
+	int ref_handle;
+
+	/* offset and size info of DMA_BUF */
+	int frst_ofst;
+	int last_len;
+	int nents;
 
 	struct dma_buf *dma_buf;
-	struct sg_table *sgt; /* sgt pointer after importing buffer */
+	struct sg_table *sgt;
 
 	void *refs_info;
 	bool valid;
 	int importers;
 
+	/* size of private */
 	size_t sz_priv;
-	char *priv; /* device specific info (e.g. image's meta info?) */
+
+	/* private data associated with the exported buffer */
+	char *priv;
 };
 
 #endif /* __HYPER_DMABUF_STRUCT_H__ */
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 f70b4ea..05f3521 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
@@ -41,12 +41,10 @@
 #include "hyper_dmabuf_xen_comm_list.h"
 #include "../hyper_dmabuf_drv.h"
 
-static int export_req_id = 0;
+static int export_req_id;
 
 struct hyper_dmabuf_req req_pending = {0};
 
-extern int xenstored_ready;
-
 static void xen_get_domid_delayed(struct work_struct *unused);
 static void xen_init_comm_env_delayed(struct work_struct *unused);
 
@@ -160,15 +158,16 @@ void xen_get_domid_delayed(struct work_struct *unused)
 	int domid, ret;
 
 	/* scheduling another if driver is still running
-	 * and xenstore has not been initialized */
+	 * and xenstore has not been initialized
+	 */
 	if (likely(xenstored_ready == 0)) {
 		dev_dbg(hy_drv_priv->dev,
-			"Xenstore is not quite ready yet. Will retry it in 500ms\n");
+			"Xenstore is not ready yet. Will retry in 500ms\n");
 		schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500));
 	} else {
-	        xenbus_transaction_start(&xbt);
+		xenbus_transaction_start(&xbt);
 
-		ret = xenbus_scanf(xbt, "domid","", "%d", &domid);
+		ret = xenbus_scanf(xbt, "domid", "", "%d", &domid);
 
 		if (ret <= 0)
 			domid = -1;
@@ -176,14 +175,17 @@ void xen_get_domid_delayed(struct work_struct *unused)
 		xenbus_transaction_end(xbt, 0);
 
 		/* try again since -1 is an invalid id for domain
-		 * (but only if driver is still running) */
+		 * (but only if driver is still running)
+		 */
 		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));
+			schedule_delayed_work(&get_vm_id_work,
+					      msecs_to_jiffies(500));
 		} else {
 			dev_info(hy_drv_priv->dev,
-				"Successfully retrieved domid from Xenstore:%d\n", domid);
+				 "Successfully retrieved domid from Xenstore:%d\n",
+				 domid);
 			hy_drv_priv->domid = domid;
 		}
 	}
@@ -199,21 +201,20 @@ int hyper_dmabuf_xen_get_domid(void)
 		return -1;
 	}
 
-        xenbus_transaction_start(&xbt);
+	xenbus_transaction_start(&xbt);
 
-        if (!xenbus_scanf(xbt, "domid","", "%d", &domid)) {
+	if (!xenbus_scanf(xbt, "domid", "", "%d", &domid))
 		domid = -1;
-        }
 
-        xenbus_transaction_end(xbt, 0);
+	xenbus_transaction_end(xbt, 0);
 
 	return domid;
 }
 
 static int xen_comm_next_req_id(void)
 {
-        export_req_id++;
-        return export_req_id;
+	export_req_id++;
+	return export_req_id;
 }
 
 /* For now cache latast rings as global variables TODO: keep them in list*/
@@ -236,19 +237,18 @@ static irqreturn_t back_ring_isr(int irq, void *info);
 static void remote_dom_exporter_watch_cb(struct xenbus_watch *watch,
 					 const char *path, const char *token)
 {
-	int rdom,ret;
+	int rdom, ret;
 	uint32_t grefid, port;
 	struct xen_comm_rx_ring_info *ring_info;
 
 	/* Check which domain has changed its exporter rings */
 	ret = sscanf(watch->node, "/local/domain/%d/", &rdom);
-	if (ret <= 0) {
+	if (ret <= 0)
 		return;
-	}
 
 	/* Check if we have importer ring for given remote domain already
-	 * created */
-
+	 * created
+	 */
 	ring_info = xen_comm_find_rx_ring(rdom);
 
 	/* Try to query remote domain exporter ring details - if
@@ -298,11 +298,8 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 
 	ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
 
-	if (!ring_info) {
-		dev_err(hy_drv_priv->dev,
-			"No more spae left\n");
+	if (!ring_info)
 		return -ENOMEM;
-	}
 
 	/* from exporter to importer */
 	shared_ring = (void *)__get_free_pages(GFP_KERNEL, 1);
@@ -318,8 +315,8 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 	FRONT_RING_INIT(&(ring_info->ring_front), sring, PAGE_SIZE);
 
 	ring_info->gref_ring = gnttab_grant_foreign_access(domid,
-							   virt_to_mfn(shared_ring),
-							   0);
+						virt_to_mfn(shared_ring),
+						0);
 	if (ring_info->gref_ring < 0) {
 		/* fail to get gref */
 		kfree(ring_info);
@@ -340,7 +337,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 	/* setting up interrupt */
 	ret = bind_evtchn_to_irqhandler(alloc_unbound.port,
 					front_ring_isr, 0,
-					NULL, (void*) ring_info);
+					NULL, (void *) ring_info);
 
 	if (ret < 0) {
 		dev_err(hy_drv_priv->dev,
@@ -368,25 +365,24 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 
 	ret = xen_comm_add_tx_ring(ring_info);
 
-	ret = xen_comm_expose_ring_details(hyper_dmabuf_xen_get_domid(), domid,
-					   ring_info->gref_ring, ring_info->port);
+	ret = xen_comm_expose_ring_details(hyper_dmabuf_xen_get_domid(),
+					   domid,
+					   ring_info->gref_ring,
+					   ring_info->port);
 
-	/*
-	 * Register watch for remote domain exporter ring.
+	/* Register watch for remote domain exporter ring.
 	 * When remote domain will setup its exporter ring,
 	 * we will automatically connect our importer ring to it.
 	 */
 	ring_info->watch.callback = remote_dom_exporter_watch_cb;
-	ring_info->watch.node = (const char*) kmalloc(sizeof(char) * 255, GFP_KERNEL);
+	ring_info->watch.node = kmalloc(255, GFP_KERNEL);
 
 	if (!ring_info->watch.node) {
-		dev_err(hy_drv_priv->dev,
-			"No more space left\n");
 		kfree(ring_info);
 		return -ENOMEM;
 	}
 
-	sprintf((char*)ring_info->watch.node,
+	sprintf((char *)ring_info->watch.node,
 		"/local/domain/%d/data/hyper_dmabuf/%d/port",
 		domid, hyper_dmabuf_xen_get_domid());
 
@@ -404,9 +400,8 @@ void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid)
 	/* check if we at all have exporter ring for given rdomain */
 	ring_info = xen_comm_find_tx_ring(domid);
 
-	if (!ring_info) {
+	if (!ring_info)
 		return;
-	}
 
 	xen_comm_remove_tx_ring(domid);
 
@@ -416,7 +411,7 @@ void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid)
 	/* No need to close communication channel, will be done by
 	 * this function
 	 */
-	unbind_from_irqhandler(ring_info->irq, (void*) ring_info);
+	unbind_from_irqhandler(ring_info->irq, (void *) ring_info);
 
 	/* No need to free sring page, will be freed by this function
 	 * when other side will end its access
@@ -430,7 +425,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,
+	BACK_RING_INIT(&(rx_ring_info->ring_back),
+		       rx_ring_info->ring_back.sring,
 		       PAGE_SIZE);
 }
 
@@ -473,11 +469,8 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 
 	ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
 
-	if (!ring_info) {
-		dev_err(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
+	if (!ring_info)
 		return -ENOMEM;
-	}
 
 	ring_info->sdomain = domid;
 	ring_info->evtchn = rx_port;
@@ -485,8 +478,6 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 	map_ops = kmalloc(sizeof(*map_ops), GFP_KERNEL);
 
 	if (!map_ops) {
-		dev_err(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
 		ret = -ENOMEM;
 		goto fail_no_map_ops;
 	}
@@ -497,11 +488,13 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 	}
 
 	gnttab_set_map_op(&map_ops[0],
-			  (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
+			  (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)),
+			    (unsigned long)pfn_to_kaddr(
+					page_to_pfn(shared_ring)),
 			    GNTMAP_host_map, -1);
 
 	ret = gnttab_map_refs(map_ops, NULL, &shared_ring, 1);
@@ -542,13 +535,12 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 	ret = xen_comm_add_rx_ring(ring_info);
 
 	/* Setup communcation channel in opposite direction */
-	if (!xen_comm_find_tx_ring(domid)) {
+	if (!xen_comm_find_tx_ring(domid))
 		ret = hyper_dmabuf_xen_init_tx_rbuf(domid);
-	}
 
 	ret = request_irq(ring_info->irq,
 			  back_ring_isr, 0,
-			  NULL, (void*)ring_info);
+			  NULL, (void *)ring_info);
 
 	return ret;
 
@@ -577,7 +569,7 @@ void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid)
 	xen_comm_remove_rx_ring(domid);
 
 	/* no need to close event channel, will be done by that function */
-	unbind_from_irqhandler(ring_info->irq, (void*)ring_info);
+	unbind_from_irqhandler(ring_info->irq, (void *)ring_info);
 
 	/* unmapping shared ring page */
 	shared_ring = virt_to_page(ring_info->ring_back.sring);
@@ -636,7 +628,8 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused)
 
 				if (!ret)
 					dev_info(hy_drv_priv->dev,
-						 "Finishing up setting up rx channel for domain %d\n", i);
+						 "Done rx ch init for VM %d\n",
+						 i);
 			}
 		}
 
@@ -654,7 +647,8 @@ 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. */
+	 * been correctly retrieved.
+	 */
 	if (likely(xenstored_ready == 0 ||
 	    hy_drv_priv->domid == -1)) {
 		dev_dbg(hy_drv_priv->dev,
@@ -778,9 +772,8 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req,
 	ring->req_prod_pvt++;
 
 	RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(ring, notify);
-	if (notify) {
+	if (notify)
 		notify_remote_via_irq(ring_info->irq);
-	}
 
 	if (wait) {
 		while (timeout--) {
@@ -792,24 +785,29 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req,
 
 		if (timeout < 0) {
 			mutex_unlock(&ring_info->lock);
-			dev_err(hy_drv_priv->dev, "request timed-out\n");
+			dev_err(hy_drv_priv->dev,
+				"request timed-out\n");
 			return -EBUSY;
 		}
 
 		mutex_unlock(&ring_info->lock);
 		do_gettimeofday(&tv_end);
 
-		/* checking time duration for round-trip of a request for debugging */
+		/* checking time duration for round-trip of a request
+		 * for debugging
+		 */
 		if (tv_end.tv_usec >= tv_start.tv_usec) {
 			tv_diff.tv_sec = tv_end.tv_sec-tv_start.tv_sec;
 			tv_diff.tv_usec = tv_end.tv_usec-tv_start.tv_usec;
 		} else {
 			tv_diff.tv_sec = tv_end.tv_sec-tv_start.tv_sec-1;
-			tv_diff.tv_usec = tv_end.tv_usec+1000000-tv_start.tv_usec;
+			tv_diff.tv_usec = tv_end.tv_usec+1000000-
+					  tv_start.tv_usec;
 		}
 
 		if (tv_diff.tv_sec != 0 && tv_diff.tv_usec > 16000)
-			dev_dbg(hy_drv_priv->dev, "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);
 	}
 
@@ -850,23 +848,24 @@ static irqreturn_t back_ring_isr(int irq, void *info)
 			ret = hyper_dmabuf_msg_parse(ring_info->sdomain, &req);
 
 			if (ret > 0) {
-				/* preparing a response for the request and send it to
-				 * the requester
+				/* preparing a response for the request and
+				 * send it to the requester
 				 */
 				memcpy(&resp, &req, sizeof(resp));
-				memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt),
+				memcpy(RING_GET_RESPONSE(ring,
+							 ring->rsp_prod_pvt),
 							 &resp, sizeof(resp));
 				ring->rsp_prod_pvt++;
 
 				dev_dbg(hy_drv_priv->dev,
-					"sending response to exporter for request id:%d\n",
+					"responding to exporter for req:%d\n",
 					resp.resp_id);
 
-				RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify);
+				RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring,
+								     notify);
 
-				if (notify) {
+				if (notify)
 					notify_remote_via_irq(ring_info->irq);
-				}
 			}
 
 			RING_FINAL_CHECK_FOR_REQUESTS(ring, more_to_do);
@@ -905,41 +904,40 @@ static irqreturn_t front_ring_isr(int irq, void *info)
 			dev_dbg(hy_drv_priv->dev,
 				"getting response from importer\n");
 
-			if (req_pending.req_id == resp->resp_id) {
+			if (req_pending.req_id == resp->resp_id)
 				req_pending.stat = resp->stat;
-			}
 
 			if (resp->stat == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
 				/* parsing response */
 				ret = hyper_dmabuf_msg_parse(ring_info->rdomain,
-							(struct hyper_dmabuf_req *)resp);
+					(struct hyper_dmabuf_req *)resp);
 
 				if (ret < 0) {
 					dev_err(hy_drv_priv->dev,
-						"getting error while parsing response\n");
+						"err while parsing resp\n");
 				}
 			} else if (resp->stat == HYPER_DMABUF_REQ_PROCESSED) {
-				/* for debugging dma_buf remote synchronization */
+				/* for debugging dma_buf remote synch */
 				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");
+					"got HYPER_DMABUF_REQ_PROCESSED\n");
 			} else if (resp->stat == HYPER_DMABUF_REQ_ERROR) {
-				/* for debugging dma_buf remote synchronization */
+				/* for debugging dma_buf remote synch */
 				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");
+					"got HYPER_DMABUF_REQ_ERROR\n");
 			}
 		}
 
 		ring->rsp_cons = i;
 
-		if (i != ring->req_prod_pvt) {
+		if (i != ring->req_prod_pvt)
 			RING_FINAL_CHECK_FOR_RESPONSES(ring, more_to_do);
-		} else {
+		else
 			ring->sring->rsp_event = i+1;
-		}
+
 	} while (more_to_do);
 
 	return IRQ_HANDLED;
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h
index 80741c1..8e2d1d0 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h
@@ -29,23 +29,25 @@
 #include "xen/xenbus.h"
 #include "../hyper_dmabuf_msg.h"
 
+extern int xenstored_ready;
+
 DEFINE_RING_TYPES(xen_comm, struct hyper_dmabuf_req, struct hyper_dmabuf_resp);
 
 struct xen_comm_tx_ring_info {
-        struct xen_comm_front_ring ring_front;
+	struct xen_comm_front_ring ring_front;
 	int rdomain;
-        int gref_ring;
-        int irq;
-        int port;
+	int gref_ring;
+	int irq;
+	int port;
 	struct mutex lock;
 	struct xenbus_watch watch;
 };
 
 struct xen_comm_rx_ring_info {
-        int sdomain;
-        int irq;
-        int evtchn;
-        struct xen_comm_back_ring ring_back;
+	int sdomain;
+	int irq;
+	int evtchn;
+	struct xen_comm_back_ring ring_back;
 	struct gnttab_unmap_grant_ref unmap_op;
 };
 
@@ -70,6 +72,7 @@ void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid);
 void hyper_dmabuf_xen_destroy_comm(void);
 
 /* send request to the remote domain */
-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);
 
 #endif // __HYPER_DMABUF_XEN_COMM_H__
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 7a8ec73..343aab3 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
@@ -31,7 +31,6 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/cdev.h>
-#include <asm/uaccess.h>
 #include <linux/hashtable.h>
 #include <xen/grant_table.h>
 #include "../hyper_dmabuf_drv.h"
@@ -41,7 +40,7 @@
 DECLARE_HASHTABLE(xen_comm_tx_ring_hash, MAX_ENTRY_TX_RING);
 DECLARE_HASHTABLE(xen_comm_rx_ring_hash, MAX_ENTRY_RX_RING);
 
-void xen_comm_ring_table_init()
+void xen_comm_ring_table_init(void)
 {
 	hash_init(xen_comm_rx_ring_hash);
 	hash_init(xen_comm_tx_ring_hash);
@@ -53,11 +52,8 @@ 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(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
+	if (!info_entry)
 		return -ENOMEM;
-	}
 
 	info_entry->info = ring_info;
 
@@ -73,11 +69,8 @@ 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(hy_drv_priv->dev,
-			"No memory left to be allocated\n");
+	if (!info_entry)
 		return -ENOMEM;
-	}
 
 	info_entry->info = ring_info;
 
@@ -93,7 +86,7 @@ struct xen_comm_tx_ring_info *xen_comm_find_tx_ring(int domid)
 	int bkt;
 
 	hash_for_each(xen_comm_tx_ring_hash, bkt, info_entry, node)
-		if(info_entry->info->rdomain == domid)
+		if (info_entry->info->rdomain == domid)
 			return info_entry->info;
 
 	return NULL;
@@ -105,7 +98,7 @@ struct xen_comm_rx_ring_info *xen_comm_find_rx_ring(int domid)
 	int bkt;
 
 	hash_for_each(xen_comm_rx_ring_hash, bkt, info_entry, node)
-		if(info_entry->info->sdomain == domid)
+		if (info_entry->info->sdomain == domid)
 			return info_entry->info;
 
 	return NULL;
@@ -117,7 +110,7 @@ int xen_comm_remove_tx_ring(int domid)
 	int bkt;
 
 	hash_for_each(xen_comm_tx_ring_hash, bkt, info_entry, node)
-		if(info_entry->info->rdomain == domid) {
+		if (info_entry->info->rdomain == domid) {
 			hash_del(&info_entry->node);
 			kfree(info_entry);
 			return 0;
@@ -132,7 +125,7 @@ int xen_comm_remove_rx_ring(int domid)
 	int bkt;
 
 	hash_for_each(xen_comm_rx_ring_hash, bkt, info_entry, node)
-		if(info_entry->info->sdomain == domid) {
+		if (info_entry->info->sdomain == domid) {
 			hash_del(&info_entry->node);
 			kfree(info_entry);
 			return 0;
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h
index cde8ade..8502fe7 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h
@@ -31,13 +31,13 @@
 #define MAX_ENTRY_RX_RING 7
 
 struct xen_comm_tx_ring_info_entry {
-        struct xen_comm_tx_ring_info *info;
-        struct hlist_node node;
+	struct xen_comm_tx_ring_info *info;
+	struct hlist_node node;
 };
 
 struct xen_comm_rx_ring_info_entry {
-        struct xen_comm_rx_ring_info *info;
-        struct hlist_node node;
+	struct xen_comm_rx_ring_info *info;
+	struct hlist_node node;
 };
 
 void xen_comm_ring_table_init(void);
@@ -54,10 +54,14 @@ struct xen_comm_tx_ring_info *xen_comm_find_tx_ring(int domid);
 
 struct xen_comm_rx_ring_info *xen_comm_find_rx_ring(int domid);
 
-/* iterates over all exporter rings and calls provided function for each of them */
+/* iterates over all exporter rings and calls provided
+ * function for each of them
+ */
 void xen_comm_foreach_tx_ring(void (*func)(int domid));
 
-/* iterates over all importer rings and calls provided function for each of them */
+/* iterates over all importer rings and calls provided
+ * function for each of them
+ */
 void xen_comm_foreach_rx_ring(void (*func)(int domid));
 
 #endif // __HYPER_DMABUF_XEN_COMM_LIST_H__
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h
index c5fec24..e5bff09 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h
@@ -34,11 +34,20 @@ extern struct hyper_dmabuf_backend_ops xen_backend_ops;
  * when unsharing.
  */
 struct xen_shared_pages_info {
-        grant_ref_t lvl3_gref; /* top level refid */
-        grant_ref_t *lvl3_table; /* page of top level addressing, it contains refids of 2nd level pages */
-        grant_ref_t *lvl2_table; /* table of 2nd level pages, that contains refids to data pages */
-        struct gnttab_unmap_grant_ref* unmap_ops; /* unmap ops for mapped pages */
-        struct page **data_pages; /* data pages to be unmapped */
+	/* top level refid */
+	grant_ref_t lvl3_gref;
+
+	/* page of top level addressing, it contains refids of 2nd lvl pages */
+	grant_ref_t *lvl3_table;
+
+	/* table of 2nd level pages, that contains refids to data pages */
+	grant_ref_t *lvl2_table;
+
+	/* unmap ops for mapped pages */
+	struct gnttab_unmap_grant_ref *unmap_ops;
+
+	/* data pages to be unmapped */
+	struct page **data_pages;
 };
 
 #endif // __HYPER_DMABUF_XEN_COMM_H__
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 424417d..a86313a 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
@@ -40,19 +40,21 @@
  * Creates 2 level page directory structure for referencing shared pages.
  * Top level page is a single page that contains up to 1024 refids that
  * point to 2nd level pages.
+ *
  * Each 2nd level page contains up to 1024 refids that point to shared
  * data pages.
+ *
  * There will always be one top level page and number of 2nd level pages
  * depends on number of shared data pages.
  *
  *      3rd level page                2nd level pages            Data pages
- * +-------------------------+   ┌>+--------------------+ ┌--->+------------+
- * |2nd level page 0 refid   |---┘ |Data page 0 refid   |-┘    |Data page 0 |
- * |2nd level page 1 refid   |---┐ |Data page 1 refid   |-┐    +------------+
+ * +-------------------------+   ┌>+--------------------+ ┌>+------------+
+ * |2nd level page 0 refid   |---┘ |Data page 0 refid   |-┘ |Data page 0 |
+ * |2nd level page 1 refid   |---┐ |Data page 1 refid   |-┐ +------------+
  * |           ...           |   | |     ....           | |
- * |2nd level page 1023 refid|-┐ | |Data page 1023 refid| └--->+------------+
- * +-------------------------+ | | +--------------------+      |Data page 1 |
- *                             | |                             +------------+
+ * |2nd level page 1023 refid|-┐ | |Data page 1023 refid| └>+------------+
+ * +-------------------------+ | | +--------------------+   |Data page 1 |
+ *                             | |                          +------------+
  *                             | └>+--------------------+
  *                             |   |Data page 1024 refid|
  *                             |   |Data page 1025 refid|
@@ -65,9 +67,8 @@
  *                                 |Data page 1047552 refid|
  *                                 |Data page 1047553 refid|
  *                                 |       ...             |
- *                                 |Data page 1048575 refid|-->+------------------+
- *                                 +-----------------------+   |Data page 1048575 |
- *                                                             +------------------+
+ *                                 |Data page 1048575 refid|
+ *                                 +-----------------------+
  *
  * Using such 2 level structure it is possible to reference up to 4GB of
  * shared data using single refid pointing to top level page.
@@ -85,7 +86,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
 	 * Calculate number of pages needed for 2nd level addresing:
 	 */
 	int n_lvl2_grefs = (nents/REFS_PER_PAGE +
-			   ((nents % REFS_PER_PAGE) ? 1: 0));
+			   ((nents % REFS_PER_PAGE) ? 1 : 0));
 
 	struct xen_shared_pages_info *sh_pages_info;
 	int i;
@@ -95,23 +96,22 @@ 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(hy_drv_priv->dev, "No more space left\n");
+	if (!sh_pages_info)
 		return -ENOMEM;
-	}
 
 	*refs_info = (void *)sh_pages_info;
 
 	/* share data pages in readonly mode for security */
-	for (i=0; i<nents; i++) {
+	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 */);
+					true /* read only */);
 		if (lvl2_table[i] == -ENOSPC) {
-			dev_err(hy_drv_priv->dev, "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--) {
+			while (i--) {
 				gnttab_end_foreign_access_ref(lvl2_table[i], 0);
 				gnttab_free_grant_reference(lvl2_table[i]);
 			}
@@ -120,23 +120,26 @@ 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++) {
+	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 ),
+					virt_to_mfn(
+					(unsigned long)lvl2_table+i*PAGE_SIZE),
 					true);
 
 		if (lvl3_table[i] == -ENOSPC) {
-			dev_err(hy_drv_priv->dev, "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--) {
+			while (i--) {
 				gnttab_end_foreign_access_ref(lvl3_table[i], 1);
 				gnttab_free_grant_reference(lvl3_table[i]);
 			}
 
 			/* Unshare all pages for lvl2 */
-			while(nents--) {
-				gnttab_end_foreign_access_ref(lvl2_table[nents], 0);
+			while (nents--) {
+				gnttab_end_foreign_access_ref(
+							lvl2_table[nents], 0);
 				gnttab_free_grant_reference(lvl2_table[nents]);
 			}
 
@@ -150,16 +153,17 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
 			true);
 
 	if (lvl3_gref == -ENOSPC) {
-		dev_err(hy_drv_priv->dev, "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--) {
+		while (i--) {
 			gnttab_end_foreign_access_ref(lvl3_table[i], 1);
 			gnttab_free_grant_reference(lvl3_table[i]);
 		}
 
 		/* Unshare all pages for lvl2 */
-		while(nents--) {
+		while (nents--) {
 			gnttab_end_foreign_access_ref(lvl2_table[nents], 0);
 			gnttab_free_grant_reference(lvl2_table[nents]);
 		}
@@ -187,10 +191,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
 	return -ENOSPC;
 }
 
-int hyper_dmabuf_xen_unshare_pages(void **refs_info, 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));
+			    ((nents % REFS_PER_PAGE) ? 1 : 0));
 	int i;
 
 	dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
@@ -206,28 +211,28 @@ 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])) {
+		if (gnttab_query_foreign_access(sh_pages_info->lvl2_table[i]))
 			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]);
 	}
 
 	/* 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])) {
+		if (gnttab_query_foreign_access(sh_pages_info->lvl3_table[i]))
 			dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
-		}
-		if (!gnttab_end_foreign_access_ref(sh_pages_info->lvl3_table[i], 1)) {
+
+		if (!gnttab_end_foreign_access_ref(
+					sh_pages_info->lvl3_table[i], 1))
 			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)) {
+	if (gnttab_query_foreign_access(sh_pages_info->lvl3_gref))
 		dev_warn(hy_drv_priv->dev, "gref not shared !!\n");
-	}
 
 	gnttab_end_foreign_access_ref(sh_pages_info->lvl3_gref, 1);
 	gnttab_free_grant_reference(sh_pages_info->lvl3_gref);
@@ -246,10 +251,11 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
 	return 0;
 }
 
-/*
- * Maps provided top level ref id and then return array of pages containing data refs.
+/* Maps provided top level ref id and then return array of pages
+ * containing data refs.
  */
-struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int nents, void **refs_info)
+struct page **hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid,
+						int nents, void **refs_info)
 {
 	struct page *lvl3_table_page;
 	struct page **lvl2_table_pages;
@@ -280,19 +286,19 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 	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,
+	lvl2_table_pages = kcalloc(n_lvl2_grefs, sizeof(struct page *),
 				   GFP_KERNEL);
 
-	data_pages = kcalloc(sizeof(struct page*), nents, GFP_KERNEL);
+	data_pages = kcalloc(nents, sizeof(struct page *), GFP_KERNEL);
 
-	lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs,
+	lvl2_map_ops = kcalloc(n_lvl2_grefs, sizeof(*lvl2_map_ops),
 			       GFP_KERNEL);
 
-	lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs,
+	lvl2_unmap_ops = kcalloc(n_lvl2_grefs, sizeof(*lvl2_unmap_ops),
 				 GFP_KERNEL);
 
-	data_map_ops = kcalloc(sizeof(*data_map_ops), nents, GFP_KERNEL);
-	data_unmap_ops = kcalloc(sizeof(*data_unmap_ops), nents, GFP_KERNEL);
+	data_map_ops = kcalloc(nents, sizeof(*data_map_ops), GFP_KERNEL);
+	data_unmap_ops = kcalloc(nents, sizeof(*data_unmap_ops), GFP_KERNEL);
 
 	/* Map top level addressing page */
 	if (gnttab_alloc_pages(1, &lvl3_table_page)) {
@@ -332,7 +338,8 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 	}
 
 	for (i = 0; i < n_lvl2_grefs; i++) {
-		lvl2_table = (grant_ref_t *)pfn_to_kaddr(page_to_pfn(lvl2_table_pages[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,
@@ -348,11 +355,11 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 		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;
 	}
 
+	/* 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(hy_drv_priv->dev,
@@ -384,19 +391,22 @@ 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])),
+				(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])),
+				(unsigned long)pfn_to_kaddr(
+						page_to_pfn(data_pages[k])),
 				GNTMAP_host_map | GNTMAP_readonly, -1);
 			k++;
 		}
 	}
 
 	/* for grefs in the last lvl2 table page */
-	lvl2_table = pfn_to_kaddr(page_to_pfn(lvl2_table_pages[n_lvl2_grefs - 1]));
+	lvl2_table = pfn_to_kaddr(page_to_pfn(
+				lvl2_table_pages[n_lvl2_grefs - 1]));
 
 	for (j = 0; j < nents_last; j++) {
 		gnttab_set_map_op(&data_map_ops[k],
@@ -424,13 +434,12 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 		dev_err(hy_drv_priv->dev,
 			"Cannot unmap 2nd level refs\n");
 		return NULL;
-	} else {
-		/* Mark that pages were unmapped */
-		for (i = 0; i < n_lvl2_grefs; i++) {
-			lvl2_unmap_ops[i].handle = -1;
-		}
 	}
 
+	/* Mark that pages were unmapped */
+	for (i = 0; i < n_lvl2_grefs; i++)
+		lvl2_unmap_ops[i].handle = -1;
+
 	for (i = 0; i < nents; i++) {
 		if (data_map_ops[i].status) {
 			dev_err(hy_drv_priv->dev,
@@ -483,7 +492,8 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 	return NULL;
 }
 
-int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
+int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents)
+{
 	struct xen_shared_pages_info *sh_pages_info;
 
 	dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
@@ -498,7 +508,7 @@ int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
 	}
 
 	if (gnttab_unmap_refs(sh_pages_info->unmap_ops, NULL,
-			      sh_pages_info->data_pages, nents) ) {
+			      sh_pages_info->data_pages, nents)) {
 		dev_err(hy_drv_priv->dev, "Cannot unmap data pages\n");
 		return -EFAULT;
 	}
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h
index 629ec0f..e7ae731 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h
@@ -25,18 +25,21 @@
 #ifndef __HYPER_DMABUF_XEN_SHM_H__
 #define __HYPER_DMABUF_XEN_SHM_H__
 
-/* This collects all reference numbers for 2nd level shared pages and create a table
- * with those in 1st level shared pages then return reference numbers for this top level
- * table. */
+/* This collects all reference numbers for 2nd level shared pages and
+ * create a table with those in 1st level shared pages then return reference
+ * numbers for this top level table.
+ */
 int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
 				 void **refs_info);
 
 int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents);
 
-/* Maps provided top level ref id and then return array of pages containing data refs.
+/* Maps provided top level ref id and then return array of pages containing
+ * data refs.
  */
-struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int nents,
-						void **refs_info);
+struct page **hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid,
+						 int nents,
+						 void **refs_info);
 
 int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents);
 
diff --git a/include/uapi/xen/hyper_dmabuf.h b/include/uapi/xen/hyper_dmabuf.h
index e18dd9b..cb25299 100644
--- a/include/uapi/xen/hyper_dmabuf.h
+++ b/include/uapi/xen/hyper_dmabuf.h
@@ -28,8 +28,8 @@
 #define MAX_SIZE_PRIV_DATA 192
 
 typedef struct {
-        int id;
-        int rng_key[3]; /* 12bytes long random number */
+	int id;
+	int rng_key[3]; /* 12bytes long random number */
 } hyper_dmabuf_id_t;
 
 struct hyper_dmabuf_event_hdr {
@@ -115,20 +115,20 @@ struct ioctl_hyper_dmabuf_query {
 /* DMABUF query */
 
 enum hyper_dmabuf_query {
-        HYPER_DMABUF_QUERY_TYPE = 0x10,
-        HYPER_DMABUF_QUERY_EXPORTER,
-        HYPER_DMABUF_QUERY_IMPORTER,
-        HYPER_DMABUF_QUERY_SIZE,
-        HYPER_DMABUF_QUERY_BUSY,
-        HYPER_DMABUF_QUERY_UNEXPORTED,
-        HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED,
-        HYPER_DMABUF_QUERY_PRIV_INFO_SIZE,
-        HYPER_DMABUF_QUERY_PRIV_INFO,
+	HYPER_DMABUF_QUERY_TYPE = 0x10,
+	HYPER_DMABUF_QUERY_EXPORTER,
+	HYPER_DMABUF_QUERY_IMPORTER,
+	HYPER_DMABUF_QUERY_SIZE,
+	HYPER_DMABUF_QUERY_BUSY,
+	HYPER_DMABUF_QUERY_UNEXPORTED,
+	HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED,
+	HYPER_DMABUF_QUERY_PRIV_INFO_SIZE,
+	HYPER_DMABUF_QUERY_PRIV_INFO,
 };
 
 enum hyper_dmabuf_status {
-        EXPORTED= 0x01,
-        IMPORTED,
+	EXPORTED = 0x01,
+	IMPORTED,
 };
 
 #endif //__LINUX_PUBLIC_HYPER_DMABUF_H__
