diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
index 76f57c2..387cc63 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
@@ -37,7 +37,6 @@
 #include <linux/dma-buf.h>
 #include "hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_ioctl.h"
-#include "hyper_dmabuf_msg.h"
 #include "hyper_dmabuf_list.h"
 #include "hyper_dmabuf_id.h"
 #include "hyper_dmabuf_event.h"
@@ -51,8 +50,8 @@ MODULE_AUTHOR("Intel Corporation");
 
 struct hyper_dmabuf_private *hy_drv_priv;
 
-static void hyper_dmabuf_force_free(struct exported_sgt_info *exported,
-				    void *attr)
+static void force_free(struct exported_sgt_info *exported,
+		       void *attr)
 {
 	struct ioctl_hyper_dmabuf_unexport unexport_attr;
 	struct file *filp = (struct file *)attr;
@@ -86,7 +85,7 @@ static int hyper_dmabuf_open(struct inode *inode, struct file *filp)
 
 static int hyper_dmabuf_release(struct inode *inode, struct file *filp)
 {
-	hyper_dmabuf_foreach_exported(hyper_dmabuf_force_free, filp);
+	hyper_dmabuf_foreach_exported(force_free, filp);
 
 	return 0;
 }
@@ -369,7 +368,7 @@ static void hyper_dmabuf_drv_exit(void)
 
 	/* destroy id_queue */
 	if (hy_drv_priv->id_queue)
-		destroy_reusable_list();
+		hyper_dmabuf_free_hid_list();
 
 #ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
 	/* clean up event queue */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
index ae8cb43..392ea99 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
@@ -28,16 +28,14 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/fs.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <linux/dma-buf.h>
 #include "hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_struct.h"
 #include "hyper_dmabuf_list.h"
 #include "hyper_dmabuf_event.h"
 
-static void hyper_dmabuf_send_event(struct hyper_dmabuf_event *e)
+static void send_event(struct hyper_dmabuf_event *e)
 {
 	struct hyper_dmabuf_event *oldest;
 	unsigned long irqflags;
@@ -110,7 +108,7 @@ int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid)
 	e->event_data.data = (void *)imported->priv;
 	e->event_data.hdr.size = imported->sz_priv;
 
-	hyper_dmabuf_send_event(e);
+	send_event(e);
 
 	dev_dbg(hy_drv_priv->dev,
 		"event number = %d :", hy_drv_priv->pending);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
index 312dea5..e67b84a 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
@@ -31,9 +31,8 @@
 #include <linux/random.h>
 #include "hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_id.h"
-#include "hyper_dmabuf_msg.h"
 
-void store_reusable_hid(hyper_dmabuf_id_t hid)
+void hyper_dmabuf_store_hid(hyper_dmabuf_id_t hid)
 {
 	struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
 	struct list_reusable_id *new_reusable;
@@ -48,7 +47,7 @@ void store_reusable_hid(hyper_dmabuf_id_t hid)
 	list_add(&new_reusable->list, &reusable_head->list);
 }
 
-static hyper_dmabuf_id_t retrieve_reusable_hid(void)
+static hyper_dmabuf_id_t get_reusable_hid(void)
 {
 	struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
 	hyper_dmabuf_id_t hid = {-1, {0, 0, 0} };
@@ -67,7 +66,7 @@ static hyper_dmabuf_id_t retrieve_reusable_hid(void)
 	return hid;
 }
 
-void destroy_reusable_list(void)
+void hyper_dmabuf_free_hid_list(void)
 {
 	struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
 	struct list_reusable_id *temp_head;
@@ -106,7 +105,7 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
 		hy_drv_priv->id_queue = reusable_head;
 	}
 
-	hid = retrieve_reusable_hid();
+	hid = get_reusable_hid();
 
 	/*creating a new H-ID only if nothing in the reusable id queue
 	 * and count is less than maximum allowed
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h
index 61c4fb3..ed690f3 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h
@@ -36,12 +36,16 @@
  */
 #define HYPER_DMABUF_ID_MAX 1000
 
-void store_reusable_hid(hyper_dmabuf_id_t hid);
+/* adding freed hid to the reusable list */
+void hyper_dmabuf_store_hid(hyper_dmabuf_id_t hid);
 
-void destroy_reusable_list(void);
+/* freeing the reusasble list */
+void hyper_dmabuf_free_hid_list(void);
 
+/* getting a hid available to use. */
 hyper_dmabuf_id_t hyper_dmabuf_get_hid(void);
 
+/* comparing two different hid */
 bool hyper_dmabuf_hid_keycomp(hyper_dmabuf_id_t hid1, hyper_dmabuf_id_t hid2);
 
 #endif /*__HYPER_DMABUF_ID_H*/
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
index 195cede..b40cf89 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
@@ -28,13 +28,9 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/miscdevice.h>
 #include <linux/uaccess.h>
 #include <linux/dma-buf.h>
-#include <linux/delay.h>
-#include <linux/list.h>
 #include "hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_id.h"
 #include "hyper_dmabuf_struct.h"
@@ -80,8 +76,8 @@ static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data)
 	return ret;
 }
 
-static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported,
-					struct pages_info *pg_info)
+static int send_export_msg(struct exported_sgt_info *exported,
+			   struct pages_info *pg_info)
 {
 	struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
 	struct hyper_dmabuf_req *req;
@@ -102,7 +98,7 @@ static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported,
 					 pg_info->nents, &exported->refs_info);
 		if (op[7] < 0) {
 			dev_err(hy_drv_priv->dev, "pages sharing failed\n");
-			return -1;
+			return op[7];
 		}
 	}
 
@@ -114,7 +110,7 @@ static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported,
 	req = kcalloc(1, sizeof(*req), GFP_KERNEL);
 
 	if (!req)
-		return -1;
+		return -ENOMEM;
 
 	/* composing a message to the importer */
 	hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT, &op[0]);
@@ -212,7 +208,7 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
 			ret = -EINVAL;
 		} else {
 			/* send an export msg for updating priv in importer */
-			ret = hyper_dmabuf_send_export_msg(exported, NULL);
+			ret = send_export_msg(exported, NULL);
 
 			if (ret < 0) {
 				dev_err(hy_drv_priv->dev,
@@ -347,7 +343,7 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
 
 	export_remote_attr->hid = exported->hid;
 
-	ret = hyper_dmabuf_send_export_msg(exported, pg_info);
+	ret = send_export_msg(exported, pg_info);
 
 	if (ret < 0) {
 		dev_err(hy_drv_priv->dev,
@@ -550,7 +546,7 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
 /* unexport dmabuf from the database and send int req to the source domain
  * to unmap it.
  */
-static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
+static void delayed_unexport(struct work_struct *work)
 {
 	struct hyper_dmabuf_req *req;
 	struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
@@ -612,7 +608,7 @@ static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
 		hyper_dmabuf_remove_exported(exported->hid);
 
 		/* register hyper_dmabuf_id to the list for reuse */
-		store_reusable_hid(exported->hid);
+		hyper_dmabuf_store_hid(exported->hid);
 
 		if (exported->sz_priv > 0 && !exported->priv)
 			kfree(exported->priv);
@@ -649,8 +645,7 @@ int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data)
 		return 0;
 
 	exported->unexport_sched = true;
-	INIT_DELAYED_WORK(&exported->unexport,
-			  hyper_dmabuf_delayed_unexport);
+	INIT_DELAYED_WORK(&exported->unexport, delayed_unexport);
 	schedule_delayed_work(&exported->unexport,
 			      msecs_to_jiffies(unexport_attr->delay_ms));
 
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
index 1b3745e..bba6d1d 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
@@ -28,12 +28,9 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/cdev.h>
-#include <asm/uaccess.h>
 #include <linux/hashtable.h>
-#include <linux/dma-buf.h>
 #include "hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_list.h"
 #include "hyper_dmabuf_id.h"
@@ -43,7 +40,9 @@ DECLARE_HASHTABLE(hyper_dmabuf_hash_imported, MAX_ENTRY_IMPORTED);
 DECLARE_HASHTABLE(hyper_dmabuf_hash_exported, MAX_ENTRY_EXPORTED);
 
 #ifdef CONFIG_HYPER_DMABUF_SYSFS
-static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attribute *attr, char *buf)
+static ssize_t hyper_dmabuf_imported_show(struct device *drv,
+					  struct device_attribute *attr,
+					  char *buf)
 {
 	struct list_entry_imported *info_entry;
 	int bkt;
@@ -55,19 +54,23 @@ static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attr
 		int nents = info_entry->imported->nents;
 		bool valid = info_entry->imported->valid;
 		int num_importers = info_entry->imported->importers;
+
 		total += nents;
 		count += scnprintf(buf + count, PAGE_SIZE - count,
-				   "hid:{id:%d keys:%d %d %d}, nents:%d, v:%c, numi:%d\n",
-				   hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2],
-				   nents, (valid ? 't' : 'f'), num_importers);
+				"hid:{%d %d %d %d}, nent:%d, v:%c, numi:%d\n",
+				hid.id, hid.rng_key[0], hid.rng_key[1],
+				hid.rng_key[2], nents, (valid ? 't' : 'f'),
+				num_importers);
 	}
-	count += scnprintf(buf + count, PAGE_SIZE - count, "total nents: %lu\n",
-			   total);
+	count += scnprintf(buf + count, PAGE_SIZE - count,
+			   "total nents: %lu\n", total);
 
 	return count;
 }
 
-static ssize_t hyper_dmabuf_exported_show(struct device *drv, struct device_attribute *attr, char *buf)
+static ssize_t hyper_dmabuf_exported_show(struct device *drv,
+					  struct device_attribute *attr,
+					  char *buf)
 {
 	struct list_entry_exported *info_entry;
 	int bkt;
@@ -79,20 +82,22 @@ static ssize_t hyper_dmabuf_exported_show(struct device *drv, struct device_attr
 		int nents = info_entry->exported->nents;
 		bool valid = info_entry->exported->valid;
 		int importer_exported = info_entry->exported->active;
+
 		total += nents;
 		count += scnprintf(buf + count, PAGE_SIZE - count,
-				   "hid:{hid:%d keys:%d %d %d}, nents:%d, v:%c, ie:%d\n",
-				   hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2],
-				   nents, (valid ? 't' : 'f'), importer_exported);
+				   "hid:{%d %d %d %d}, nent:%d, v:%c, ie:%d\n",
+				   hid.id, hid.rng_key[0], hid.rng_key[1],
+				   hid.rng_key[2], nents, (valid ? 't' : 'f'),
+				   importer_exported);
 	}
-	count += scnprintf(buf + count, PAGE_SIZE - count, "total nents: %lu\n",
-			   total);
+	count += scnprintf(buf + count, PAGE_SIZE - count,
+			   "total nents: %lu\n", total);
 
 	return count;
 }
 
-static DEVICE_ATTR(imported, S_IRUSR, hyper_dmabuf_imported_show, NULL);
-static DEVICE_ATTR(exported, S_IRUSR, hyper_dmabuf_exported_show, NULL);
+static DEVICE_ATTR(imported, 0400, hyper_dmabuf_imported_show, NULL);
+static DEVICE_ATTR(exported, 0400, hyper_dmabuf_exported_show, NULL);
 
 int hyper_dmabuf_register_sysfs(struct device *dev)
 {
@@ -118,18 +123,21 @@ int hyper_dmabuf_unregister_sysfs(struct device *dev)
 	device_remove_file(dev, &dev_attr_exported);
 	return 0;
 }
+
 #endif
 
-int hyper_dmabuf_table_init()
+int hyper_dmabuf_table_init(void)
 {
 	hash_init(hyper_dmabuf_hash_imported);
 	hash_init(hyper_dmabuf_hash_exported);
 	return 0;
 }
 
-int hyper_dmabuf_table_destroy()
+int hyper_dmabuf_table_destroy(void)
 {
-	/* TODO: cleanup hyper_dmabuf_hash_imported and hyper_dmabuf_hash_exported */
+	/* TODO: cleanup hyper_dmabuf_hash_imported
+	 * and hyper_dmabuf_hash_exported
+	 */
 	return 0;
 }
 
@@ -139,11 +147,8 @@ int hyper_dmabuf_register_exported(struct exported_sgt_info *exported)
 
 	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->exported = exported;
 
@@ -153,17 +158,14 @@ int hyper_dmabuf_register_exported(struct exported_sgt_info *exported)
 	return 0;
 }
 
-int hyper_dmabuf_register_imported(struct imported_sgt_info* imported)
+int hyper_dmabuf_register_imported(struct imported_sgt_info *imported)
 {
 	struct list_entry_imported *info_entry;
 
 	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->imported = imported;
 
@@ -180,28 +182,32 @@ struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
 
 	hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
 		/* checking hid.id first */
-		if(info_entry->exported->hid.id == hid.id) {
+		if (info_entry->exported->hid.id == hid.id) {
 			/* then key is compared */
-			if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid))
+			if (hyper_dmabuf_hid_keycomp(info_entry->exported->hid,
+						    hid))
 				return info_entry->exported;
-			/* if key is unmatched, given HID is invalid, so returning NULL */
-			else
-				break;
+
+			/* if key is unmatched, given HID is invalid,
+			 * so returning NULL
+			 */
+			break;
 		}
 
 	return NULL;
 }
 
 /* search for pre-exported sgt and return id of it if it exist */
-hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid)
+hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf,
+						 int domid)
 {
 	struct list_entry_exported *info_entry;
-	hyper_dmabuf_id_t hid = {-1, {0, 0, 0}};
+	hyper_dmabuf_id_t hid = {-1, {0, 0, 0} };
 	int bkt;
 
 	hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
-		if(info_entry->exported->dma_buf == dmabuf &&
-		   info_entry->exported->rdomid == domid)
+		if (info_entry->exported->dma_buf == dmabuf &&
+		    info_entry->exported->rdomid == domid)
 			return info_entry->exported->hid;
 
 	return hid;
@@ -214,14 +220,15 @@ struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid)
 
 	hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node)
 		/* checking hid.id first */
-		if(info_entry->imported->hid.id == hid.id) {
+		if (info_entry->imported->hid.id == hid.id) {
 			/* then key is compared */
-			if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid))
+			if (hyper_dmabuf_hid_keycomp(info_entry->imported->hid,
+						    hid))
 				return info_entry->imported;
-			/* if key is unmatched, given HID is invalid, so returning NULL */
-			else {
-				break;
-			}
+			/* if key is unmatched, given HID is invalid,
+			 * so returning NULL
+			 */
+			break;
 		}
 
 	return NULL;
@@ -234,15 +241,16 @@ int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid)
 
 	hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
 		/* checking hid.id first */
-		if(info_entry->exported->hid.id == hid.id) {
+		if (info_entry->exported->hid.id == hid.id) {
 			/* then key is compared */
-			if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid)) {
+			if (hyper_dmabuf_hid_keycomp(info_entry->exported->hid,
+						    hid)) {
 				hash_del(&info_entry->node);
 				kfree(info_entry);
 				return 0;
-			} else {
-				break;
 			}
+
+			break;
 		}
 
 	return -ENOENT;
@@ -255,15 +263,16 @@ int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid)
 
 	hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node)
 		/* checking hid.id first */
-		if(info_entry->imported->hid.id == hid.id) {
+		if (info_entry->imported->hid.id == hid.id) {
 			/* then key is compared */
-			if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid)) {
+			if (hyper_dmabuf_hid_keycomp(info_entry->imported->hid,
+						    hid)) {
 				hash_del(&info_entry->node);
 				kfree(info_entry);
 				return 0;
-			} else {
-				break;
 			}
+
+			break;
 		}
 
 	return -ENOENT;
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
index d5c17ef..f7102f5 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
@@ -33,13 +33,13 @@
 #define MAX_ENTRY_IMPORTED 7
 
 struct list_entry_exported {
-        struct exported_sgt_info *exported;
-        struct hlist_node node;
+	struct exported_sgt_info *exported;
+	struct hlist_node node;
 };
 
 struct list_entry_imported {
-        struct imported_sgt_info *imported;
-        struct hlist_node node;
+	struct imported_sgt_info *imported;
+	struct hlist_node node;
 };
 
 int hyper_dmabuf_table_init(void);
@@ -49,9 +49,10 @@ int hyper_dmabuf_table_destroy(void);
 int hyper_dmabuf_register_exported(struct exported_sgt_info *info);
 
 /* search for pre-exported sgt and return id of it if it exist */
-hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid);
+hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf,
+						 int domid);
 
-int hyper_dmabuf_register_imported(struct imported_sgt_info* info);
+int hyper_dmabuf_register_imported(struct imported_sgt_info *info);
 
 struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid);
 
@@ -61,11 +62,10 @@ int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid);
 
 int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid);
 
-void hyper_dmabuf_foreach_exported(
-	void (*func)(struct exported_sgt_info *, void *attr),
-	void *attr);
+void hyper_dmabuf_foreach_exported(void (*func)(struct exported_sgt_info *,
+				   void *attr), void *attr);
 
 int hyper_dmabuf_register_sysfs(struct device *dev);
 int hyper_dmabuf_unregister_sysfs(struct device *dev);
 
-#endif // __HYPER_DMABUF_LIST_H__
+#endif /* __HYPER_DMABUF_LIST_H__ */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
index fbbcc39..afc1fd6e 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
@@ -28,12 +28,10 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/dma-buf.h>
 #include <linux/workqueue.h>
-#include "hyper_dmabuf_msg.h"
 #include "hyper_dmabuf_drv.h"
+#include "hyper_dmabuf_msg.h"
 #include "hyper_dmabuf_remote_sync.h"
 #include "hyper_dmabuf_event.h"
 #include "hyper_dmabuf_list.h"
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
index 03fdd30..bf805b1 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
@@ -28,9 +28,7 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/fs.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 #include <linux/dma-buf.h>
 #include "hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_struct.h"
@@ -43,7 +41,15 @@
 #define WAIT_AFTER_SYNC_REQ 0
 #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
 
-static int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
+static int dmabuf_refcount(struct dma_buf *dma_buf)
+{
+	if ((dma_buf != NULL) && (dma_buf->file != NULL))
+		return file_count(dma_buf->file);
+
+	return -EINVAL;
+}
+
+static int sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
 {
 	struct hyper_dmabuf_req *req;
 	struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
@@ -90,8 +96,7 @@ static int hyper_dmabuf_ops_attach(struct dma_buf *dmabuf,
 
 	imported = (struct imported_sgt_info *)attach->dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_ATTACH);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_ATTACH);
 
 	return ret;
 }
@@ -107,8 +112,7 @@ static void hyper_dmabuf_ops_detach(struct dma_buf *dmabuf,
 
 	imported = (struct imported_sgt_info *)attach->dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_DETACH);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_DETACH);
 }
 
 static struct sg_table *hyper_dmabuf_ops_map(
@@ -140,8 +144,7 @@ static struct sg_table *hyper_dmabuf_ops_map(
 	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);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_MAP);
 
 	kfree(pg_info->pgs);
 	kfree(pg_info);
@@ -177,8 +180,7 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment,
 	sg_free_table(sg);
 	kfree(sg);
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_UNMAP);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_UNMAP);
 }
 
 static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
@@ -211,8 +213,7 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
 	finish = imported && !imported->valid &&
 		 !imported->importers;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_RELEASE);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_RELEASE);
 
 	/*
 	 * Check if buffer is still valid and if not remove it
@@ -236,8 +237,7 @@ static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf,
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS);
 
 	return ret;
 }
@@ -253,8 +253,7 @@ static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf,
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_END_CPU_ACCESS);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_END_CPU_ACCESS);
 
 	return 0;
 }
@@ -270,8 +269,7 @@ static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf,
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_KMAP_ATOMIC);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_KMAP_ATOMIC);
 
 	/* TODO: NULL for now. Need to return the addr of mapped region */
 	return NULL;
@@ -288,8 +286,7 @@ static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf,
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_KUNMAP_ATOMIC);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_KUNMAP_ATOMIC);
 }
 
 static void *hyper_dmabuf_ops_kmap(struct dma_buf *dmabuf, unsigned long pgnum)
@@ -302,8 +299,7 @@ static void *hyper_dmabuf_ops_kmap(struct dma_buf *dmabuf, unsigned long pgnum)
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_KMAP);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_KMAP);
 
 	/* for now NULL.. need to return the address of mapped region */
 	return NULL;
@@ -320,8 +316,7 @@ static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum,
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_KUNMAP);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_KUNMAP);
 }
 
 static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf,
@@ -335,8 +330,7 @@ static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf,
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_MMAP);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_MMAP);
 
 	return ret;
 }
@@ -351,8 +345,7 @@ static void *hyper_dmabuf_ops_vmap(struct dma_buf *dmabuf)
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_VMAP);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_VMAP);
 
 	return NULL;
 }
@@ -367,8 +360,7 @@ static void hyper_dmabuf_ops_vunmap(struct dma_buf *dmabuf, void *vaddr)
 
 	imported = (struct imported_sgt_info *)dmabuf->priv;
 
-	ret = hyper_dmabuf_sync_request(imported->hid,
-					HYPER_DMABUF_OPS_VUNMAP);
+	ret = sync_request(imported->hid, HYPER_DMABUF_OPS_VUNMAP);
 }
 
 static const struct dma_buf_ops hyper_dmabuf_ops = {
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
index c9fe040..a82fd7b 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
@@ -28,7 +28,6 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/dma-buf.h>
 #include "hyper_dmabuf_drv.h"
@@ -36,7 +35,6 @@
 #include "hyper_dmabuf_list.h"
 #include "hyper_dmabuf_msg.h"
 #include "hyper_dmabuf_id.h"
-#include "hyper_dmabuf_msg.h"
 #include "hyper_dmabuf_sgl_proc.h"
 
 /* Whenever importer does dma operations from remote domain,
@@ -189,7 +187,7 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
 			hyper_dmabuf_remove_exported(hid);
 			kfree(exported);
 			/* store hyper_dmabuf_id in the list for reuse */
-			store_reusable_hid(hid);
+			hyper_dmabuf_store_hid(hid);
 		}
 
 		break;
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
index e9299e5..9ad7ab9 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
@@ -28,31 +28,18 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/fs.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 #include <linux/dma-buf.h>
 #include "hyper_dmabuf_drv.h"
 #include "hyper_dmabuf_struct.h"
 #include "hyper_dmabuf_sgl_proc.h"
-#include "hyper_dmabuf_id.h"
-#include "hyper_dmabuf_msg.h"
-#include "hyper_dmabuf_list.h"
 
 #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
 
-int dmabuf_refcount(struct dma_buf *dma_buf)
-{
-	if ((dma_buf != NULL) && (dma_buf->file != NULL))
-		return file_count(dma_buf->file);
-
-	return -1;
-}
-
 /* return total number of pages referenced by a sgt
  * for pre-calculation of # of pages behind a given sgt
  */
-static int hyper_dmabuf_get_num_pgs(struct sg_table *sgt)
+static int get_num_pgs(struct sg_table *sgt)
 {
 	struct scatterlist *sgl;
 	int length, i;
@@ -89,8 +76,9 @@ struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
 	if (!pg_info)
 		return NULL;
 
-	pg_info->pgs = kmalloc_array(hyper_dmabuf_get_num_pgs(sgt),
-				     sizeof(struct page *), GFP_KERNEL);
+	pg_info->pgs = kmalloc_array(get_num_pgs(sgt),
+				     sizeof(struct page *),
+				     GFP_KERNEL);
 
 	if (!pg_info->pgs) {
 		kfree(pg_info);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
index 152f78c..869d982 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
@@ -25,8 +25,6 @@
 #ifndef __HYPER_DMABUF_IMP_H__
 #define __HYPER_DMABUF_IMP_H__
 
-int dmabuf_refcount(struct dma_buf *dma_buf);
-
 /* extract pages directly from struct sg_table */
 struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt);
 
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 05f3521..4a073ce 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
@@ -26,13 +26,10 @@
  *
  */
 
-#include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/workqueue.h>
 #include <linux/delay.h>
-#include <linux/time.h>
 #include <xen/grant_table.h>
 #include <xen/events.h>
 #include <xen/xenbus.h>
@@ -152,7 +149,7 @@ static int xen_comm_get_ring_details(int domid, int rdomid,
 	return (ret <= 0 ? 1 : 0);
 }
 
-void xen_get_domid_delayed(struct work_struct *unused)
+static void xen_get_domid_delayed(struct work_struct *unused)
 {
 	struct xenbus_transaction xbt;
 	int domid, ret;
@@ -191,7 +188,7 @@ void xen_get_domid_delayed(struct work_struct *unused)
 	}
 }
 
-int hyper_dmabuf_xen_get_domid(void)
+int xen_be_get_domid(void)
 {
 	struct xenbus_transaction xbt;
 	int domid;
@@ -261,22 +258,22 @@ static void remote_dom_exporter_watch_cb(struct xenbus_watch *watch,
 	 * connect to it.
 	 */
 
-	ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(),
+	ret = xen_comm_get_ring_details(xen_be_get_domid(),
 					rdom, &grefid, &port);
 
 	if (ring_info && ret != 0) {
 		dev_info(hy_drv_priv->dev,
 			 "Remote exporter closed, cleaninup importer\n");
-		hyper_dmabuf_xen_cleanup_rx_rbuf(rdom);
+		xen_be_cleanup_rx_rbuf(rdom);
 	} else if (!ring_info && ret == 0) {
 		dev_info(hy_drv_priv->dev,
 			 "Registering importer\n");
-		hyper_dmabuf_xen_init_rx_rbuf(rdom);
+		xen_be_init_rx_rbuf(rdom);
 	}
 }
 
 /* exporter needs to generated info for page sharing */
-int hyper_dmabuf_xen_init_tx_rbuf(int domid)
+int xen_be_init_tx_rbuf(int domid)
 {
 	struct xen_comm_tx_ring_info *ring_info;
 	struct xen_comm_sring *sring;
@@ -365,7 +362,7 @@ 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(),
+	ret = xen_comm_expose_ring_details(xen_be_get_domid(),
 					   domid,
 					   ring_info->gref_ring,
 					   ring_info->port);
@@ -384,7 +381,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 
 	sprintf((char *)ring_info->watch.node,
 		"/local/domain/%d/data/hyper_dmabuf/%d/port",
-		domid, hyper_dmabuf_xen_get_domid());
+		domid, xen_be_get_domid());
 
 	register_xenbus_watch(&ring_info->watch);
 
@@ -392,7 +389,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 }
 
 /* cleans up exporter ring created for given remote domain */
-void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid)
+void xen_be_cleanup_tx_rbuf(int domid)
 {
 	struct xen_comm_tx_ring_info *ring_info;
 	struct xen_comm_rx_ring_info *rx_ring_info;
@@ -433,7 +430,7 @@ void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid)
 /* importer needs to know about shared page and port numbers for
  * ring buffer and event channel
  */
-int hyper_dmabuf_xen_init_rx_rbuf(int domid)
+int xen_be_init_rx_rbuf(int domid)
 {
 	struct xen_comm_rx_ring_info *ring_info;
 	struct xen_comm_sring *sring;
@@ -456,7 +453,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 		return 0;
 	}
 
-	ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), domid,
+	ret = xen_comm_get_ring_details(xen_be_get_domid(), domid,
 					&rx_gref, &rx_port);
 
 	if (ret) {
@@ -536,7 +533,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 
 	/* Setup communcation channel in opposite direction */
 	if (!xen_comm_find_tx_ring(domid))
-		ret = hyper_dmabuf_xen_init_tx_rbuf(domid);
+		ret = xen_be_init_tx_rbuf(domid);
 
 	ret = request_irq(ring_info->irq,
 			  back_ring_isr, 0,
@@ -554,7 +551,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 }
 
 /* clenas up importer ring create for given source domain */
-void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid)
+void xen_be_cleanup_rx_rbuf(int domid)
 {
 	struct xen_comm_rx_ring_info *ring_info;
 	struct xen_comm_tx_ring_info *tx_ring_info;
@@ -624,7 +621,7 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused)
 				if (xen_comm_find_rx_ring(i) != NULL)
 					continue;
 
-				ret = hyper_dmabuf_xen_init_rx_rbuf(i);
+				ret = xen_be_init_rx_rbuf(i);
 
 				if (!ret)
 					dev_info(hy_drv_priv->dev,
@@ -672,7 +669,7 @@ void xen_init_comm_env_delayed(struct work_struct *unused)
 	}
 }
 
-int hyper_dmabuf_xen_init_comm_env(void)
+int xen_be_init_comm_env(void)
 {
 	int ret;
 
@@ -699,19 +696,19 @@ int hyper_dmabuf_xen_init_comm_env(void)
 }
 
 /* cleans up all tx/rx rings */
-static void hyper_dmabuf_xen_cleanup_all_rbufs(void)
+static void xen_be_cleanup_all_rbufs(void)
 {
-	xen_comm_foreach_tx_ring(hyper_dmabuf_xen_cleanup_tx_rbuf);
-	xen_comm_foreach_rx_ring(hyper_dmabuf_xen_cleanup_rx_rbuf);
+	xen_comm_foreach_tx_ring(xen_be_cleanup_tx_rbuf);
+	xen_comm_foreach_rx_ring(xen_be_cleanup_rx_rbuf);
 }
 
-void hyper_dmabuf_xen_destroy_comm(void)
+void xen_be_destroy_comm(void)
 {
-	hyper_dmabuf_xen_cleanup_all_rbufs();
+	xen_be_cleanup_all_rbufs();
 	xen_comm_destroy_data_dir();
 }
 
-int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req,
+int xen_be_send_req(int domid, struct hyper_dmabuf_req *req,
 			      int wait)
 {
 	struct xen_comm_front_ring *ring;
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 8e2d1d0..70a2b70 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h
@@ -51,28 +51,28 @@ struct xen_comm_rx_ring_info {
 	struct gnttab_unmap_grant_ref unmap_op;
 };
 
-int hyper_dmabuf_xen_get_domid(void);
+int xen_be_get_domid(void);
 
-int hyper_dmabuf_xen_init_comm_env(void);
+int xen_be_init_comm_env(void);
 
 /* exporter needs to generated info for page sharing */
-int hyper_dmabuf_xen_init_tx_rbuf(int domid);
+int xen_be_init_tx_rbuf(int domid);
 
 /* importer needs to know about shared page and port numbers
  * for ring buffer and event channel
  */
-int hyper_dmabuf_xen_init_rx_rbuf(int domid);
+int xen_be_init_rx_rbuf(int domid);
 
 /* cleans up exporter ring created for given domain */
-void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid);
+void xen_be_cleanup_tx_rbuf(int domid);
 
 /* cleans up importer ring created for given domain */
-void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid);
+void xen_be_cleanup_rx_rbuf(int domid);
 
-void hyper_dmabuf_xen_destroy_comm(void);
+void xen_be_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 xen_be_send_req(int domid, struct hyper_dmabuf_req *req,
+		    int wait);
 
-#endif // __HYPER_DMABUF_XEN_COMM_H__
+#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 343aab3..15023db 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
@@ -28,7 +28,6 @@
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/cdev.h>
 #include <linux/hashtable.h>
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c
index aa4c2f5..23965b8 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c
@@ -26,25 +26,19 @@
  *
  */
 
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/module.h>
-#include <xen/grant_table.h>
-#include "../hyper_dmabuf_msg.h"
 #include "../hyper_dmabuf_drv.h"
-#include "hyper_dmabuf_xen_drv.h"
 #include "hyper_dmabuf_xen_comm.h"
 #include "hyper_dmabuf_xen_shm.h"
 
 struct hyper_dmabuf_backend_ops xen_backend_ops = {
-	.get_vm_id = hyper_dmabuf_xen_get_domid,
-	.share_pages = hyper_dmabuf_xen_share_pages,
-	.unshare_pages = hyper_dmabuf_xen_unshare_pages,
-	.map_shared_pages = (void *)hyper_dmabuf_xen_map_shared_pages,
-	.unmap_shared_pages = hyper_dmabuf_xen_unmap_shared_pages,
-	.init_comm_env = hyper_dmabuf_xen_init_comm_env,
-	.destroy_comm = hyper_dmabuf_xen_destroy_comm,
-	.init_rx_ch = hyper_dmabuf_xen_init_rx_rbuf,
-	.init_tx_ch = hyper_dmabuf_xen_init_tx_rbuf,
-	.send_req = hyper_dmabuf_xen_send_req,
+	.get_vm_id = xen_be_get_domid,
+	.share_pages = xen_be_share_pages,
+	.unshare_pages = xen_be_unshare_pages,
+	.map_shared_pages = (void *)xen_be_map_shared_pages,
+	.unmap_shared_pages = xen_be_unmap_shared_pages,
+	.init_comm_env = xen_be_init_comm_env,
+	.destroy_comm = xen_be_destroy_comm,
+	.init_rx_ch = xen_be_init_rx_rbuf,
+	.init_tx_ch = xen_be_init_tx_rbuf,
+	.send_req = xen_be_send_req,
 };
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 a86313a..16416f8 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
@@ -26,8 +26,6 @@
  *
  */
 
-#include <linux/kernel.h>
-#include <linux/errno.h>
 #include <linux/slab.h>
 #include <xen/grant_table.h>
 #include <asm/xen/page.h>
@@ -75,8 +73,8 @@
  *
  * Returns refid of top level page.
  */
-int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
-				 void **refs_info)
+int xen_be_share_pages(struct page **pages, int domid, int nents,
+		       void **refs_info)
 {
 	grant_ref_t lvl3_gref;
 	grant_ref_t *lvl2_table;
@@ -191,7 +189,7 @@ 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 xen_be_unshare_pages(void **refs_info, int nents)
 {
 	struct xen_shared_pages_info *sh_pages_info;
 	int n_lvl2_grefs = (nents/REFS_PER_PAGE +
@@ -254,8 +252,8 @@ 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.
  */
-struct page **hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid,
-						int nents, void **refs_info)
+struct page **xen_be_map_shared_pages(int lvl3_gref, int domid,
+				   int nents, void **refs_info)
 {
 	struct page *lvl3_table_page;
 	struct page **lvl2_table_pages;
@@ -492,7 +490,7 @@ struct page **hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid,
 	return NULL;
 }
 
-int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents)
+int xen_be_unmap_shared_pages(void **refs_info, int nents)
 {
 	struct xen_shared_pages_info *sh_pages_info;
 
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 e7ae731..e02fab0b 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h
@@ -29,18 +29,18 @@
  * 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 xen_be_share_pages(struct page **pages, int domid, int nents,
+		    void **refs_info);
 
-int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents);
+int xen_be_unshare_pages(void **refs_info, int nents);
 
 /* 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 **xen_be_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);
+int xen_be_unmap_shared_pages(void **refs_info, int nents);
 
 #endif /* __HYPER_DMABUF_XEN_SHM_H__ */
