[RFC PATCH 17/60] hyper_dmabuf: use dynamic debug macros for logging

[Dongwon Kim <dongwon.kim@intel.com>]

From: Mateusz Polrola <mateuszx.potrola@intel.com>

Replaces printk to debug macros

Signed-off-by: Dongwon Kim <dongwon.kim@intel.com>
---
 drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c        |  4 +-
 drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h        |  4 ++
 drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c        | 46 +++++++++-----
 drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c      | 50 +++++++++------
 drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c        | 26 +++++---
 .../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c    | 60 ++++++++++++------
 .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c   | 73 +++++++++++++++-------
 .../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c    | 50 +++++++++------
 8 files changed, 206 insertions(+), 107 deletions(-)

diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
index ddcc955..9d99769 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
@@ -1,6 +1,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/workqueue.h>
+#include <linux/device.h>
 #include "hyper_dmabuf_conf.h"
 #include "hyper_dmabuf_msg.h"
 #include "hyper_dmabuf_drv.h"
@@ -36,7 +37,8 @@ static int hyper_dmabuf_drv_init(void)
 	hyper_dmabuf_private.backend_ops = &xen_backend_ops;
 #endif
 
-	printk( KERN_NOTICE "initializing database for imported/exported dmabufs\n");
+	dev_info(hyper_dmabuf_private.device,
+		 "initializing database for imported/exported dmabufs\n");
 
 	/* device structure initialization */
 	/* currently only does work-queue initialization */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
index 03d77d7..c16e8d4 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
@@ -1,6 +1,10 @@
 #ifndef __LINUX_PUBLIC_HYPER_DMABUF_DRV_H__
 #define __LINUX_PUBLIC_HYPER_DMABUF_DRV_H__
 
+#include <linux/device.h>
+
+struct hyper_dmabuf_req;
+
 struct list_reusable_id {
 	int id;
 	struct list_head list;
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
index 0f104b9..b61d29a 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
@@ -155,7 +155,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
 	struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
 
 	if (!sgt_info) {
-		printk("invalid hyper_dmabuf_id\n");
+		dev_err(hyper_dmabuf_private.device, "invalid hyper_dmabuf_id\n");
 		return -EINVAL;
 	}
 
@@ -168,7 +168,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
 	    !list_empty(&sgt_info->va_vmapped->list) ||
 	    !list_empty(&sgt_info->active_sgts->list) ||
 	    !list_empty(&sgt_info->active_attached->list))) {
-		printk("dma-buf is used by importer\n");
+		dev_warn(hyper_dmabuf_private.device, "dma-buf is used by importer\n");
 		return -EPERM;
 	}
 
@@ -273,7 +273,8 @@ static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf, struct device* dev,
 						 HYPER_DMABUF_OPS_ATTACH);
 
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 		return ret;
 	}
 
@@ -294,7 +295,8 @@ static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf, struct dma_buf_attac
 						 HYPER_DMABUF_OPS_DETACH);
 
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 }
 
@@ -331,7 +333,8 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme
 	kfree(page_info);
 
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 
 	return st;
@@ -363,7 +366,8 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment,
 						HYPER_DMABUF_OPS_UNMAP);
 
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 }
 
@@ -403,7 +407,8 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
 	}
 
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 
 	/*
@@ -429,7 +434,8 @@ static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_da
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 
 	return ret;
@@ -448,7 +454,8 @@ static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf, enum dma_data
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_END_CPU_ACCESS);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 
 	return 0;
@@ -467,7 +474,8 @@ static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf, unsigned long
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_KMAP_ATOMIC);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 
 	return NULL; /* for now NULL.. need to return the address of mapped region */
@@ -486,7 +494,8 @@ static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf, unsigned long
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_KUNMAP_ATOMIC);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 }
 
@@ -503,7 +512,8 @@ static void *hyper_dmabuf_ops_kmap(struct dma_buf *dmabuf, unsigned long pgnum)
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_KMAP);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 
 	return NULL; /* for now NULL.. need to return the address of mapped region */
@@ -522,7 +532,8 @@ static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum,
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_KUNMAP);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 }
 
@@ -539,7 +550,8 @@ static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf, struct vm_area_struct *
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_MMAP);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 
 	return ret;
@@ -558,7 +570,8 @@ static void *hyper_dmabuf_ops_vmap(struct dma_buf *dmabuf)
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_VMAP);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 
 	return NULL;
@@ -577,7 +590,8 @@ static void hyper_dmabuf_ops_vunmap(struct dma_buf *dmabuf, void *vaddr)
 	ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
 						HYPER_DMABUF_OPS_VUNMAP);
 	if (ret < 0) {
-		printk("hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
+		dev_err(hyper_dmabuf_private.device,
+			"hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
 	}
 }
 
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
index 70107bb..b1e0bdb 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
@@ -25,7 +25,7 @@ static int hyper_dmabuf_tx_ch_setup(void *data)
 	int ret = 0;
 
 	if (!data) {
-		printk("user data is NULL\n");
+		dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
 		return -1;
 	}
 	tx_ch_attr = (struct ioctl_hyper_dmabuf_tx_ch_setup *)data;
@@ -42,7 +42,7 @@ static int hyper_dmabuf_rx_ch_setup(void *data)
 	int ret = 0;
 
 	if (!data) {
-		printk("user data is NULL\n");
+		dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
 		return -1;
 	}
 
@@ -67,7 +67,7 @@ static int hyper_dmabuf_export_remote(void *data)
 	int ret = 0;
 
 	if (!data) {
-		printk("user data is NULL\n");
+		dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
 		return -1;
 	}
 
@@ -76,7 +76,7 @@ static int hyper_dmabuf_export_remote(void *data)
 	dma_buf = dma_buf_get(export_remote_attr->dmabuf_fd);
 
 	if (!dma_buf) {
-		printk("Cannot get dma buf\n");
+		dev_err(hyper_dmabuf_private.device,  "Cannot get dma buf\n");
 		return -1;
 	}
 
@@ -94,7 +94,7 @@ static int hyper_dmabuf_export_remote(void *data)
 
 	attachment = dma_buf_attach(dma_buf, hyper_dmabuf_private.device);
 	if (!attachment) {
-		printk("Cannot get attachment\n");
+		dev_err(hyper_dmabuf_private.device, "Cannot get attachment\n");
 		return -1;
 	}
 
@@ -206,8 +206,10 @@ static int hyper_dmabuf_export_fd_ioctl(void *data)
 	int operand;
 	int ret = 0;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+
 	if (!data) {
-		printk("user data is NULL\n");
+		dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
 		return -EINVAL;
 	}
 
@@ -218,12 +220,15 @@ static int hyper_dmabuf_export_fd_ioctl(void *data)
 	if (sgt_info == NULL) /* can't find sgt from the table */
 		return -1;
 
-	printk("%s Found buffer gref %d  off %d last len %d nents %d domain %d\n", __func__,
-		sgt_info->ref_handle, sgt_info->frst_ofst,
-		sgt_info->last_len, sgt_info->nents,
-		HYPER_DMABUF_DOM_ID(sgt_info->hyper_dmabuf_id));
+	dev_dbg(hyper_dmabuf_private.device,
+		  "%s Found buffer gref %d  off %d last len %d nents %d domain %d\n", __func__,
+		  sgt_info->ref_handle, sgt_info->frst_ofst,
+		  sgt_info->last_len, sgt_info->nents,
+		  HYPER_DMABUF_DOM_ID(sgt_info->hyper_dmabuf_id));
 
 	if (!sgt_info->sgt) {
+		dev_dbg(hyper_dmabuf_private.device,
+			"%s buffer %d pages not mapped yet\n", __func__,sgt_info->hyper_dmabuf_id);
 		data_pages = ops->map_shared_pages(sgt_info->ref_handle,
 						   HYPER_DMABUF_DOM_ID(sgt_info->hyper_dmabuf_id),
 						   sgt_info->nents,
@@ -244,7 +249,7 @@ static int hyper_dmabuf_export_fd_ioctl(void *data)
 
 	if (!sgt_info->sgt || ret) {
 		kfree(req);
-		printk("Failed to create sgt or notify exporter\n");
+		dev_err(hyper_dmabuf_private.device, "Failed to create sgt or notify exporter\n");
 		return -EINVAL;
 	}
 	kfree(req);
@@ -258,6 +263,7 @@ static int hyper_dmabuf_export_fd_ioctl(void *data)
 		sgt_info->num_importers++;
 	}
 
+	dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
 	return ret;
 }
 
@@ -272,8 +278,10 @@ static int hyper_dmabuf_unexport(void *data)
 	struct hyper_dmabuf_req *req;
 	int ret;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+
 	if (!data) {
-		printk("user data is NULL\n");
+		dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
 		return -EINVAL;
 	}
 
@@ -302,6 +310,8 @@ static int hyper_dmabuf_unexport(void *data)
 	/* free msg */
 	kfree(req);
 
+	dev_dbg(hyper_dmabuf_private.device,
+		"Marking buffer %d as invalid\n", unexport_attr->hyper_dmabuf_id);
 	/* no longer valid */
 	sgt_info->valid = 0;
 
@@ -312,8 +322,9 @@ static int hyper_dmabuf_unexport(void *data)
 	 * is called (importer does this only when there's no
 	 * no consumer of locally exported FDs)
 	 */
-	printk("before claning up buffer completly\n");
 	if (!sgt_info->importer_exported) {
+		dev_dbg(hyper_dmabuf_private.device,
+			"claning up buffer %d completly\n", unexport_attr->hyper_dmabuf_id);
 		hyper_dmabuf_cleanup_sgt_info(sgt_info, false);
 		hyper_dmabuf_remove_exported(unexport_attr->hyper_dmabuf_id);
 		kfree(sgt_info);
@@ -321,6 +332,7 @@ static int hyper_dmabuf_unexport(void *data)
 		store_reusable_id(unexport_attr->hyper_dmabuf_id);
 	}
 
+	dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
 	return ret;
 }
 
@@ -332,7 +344,7 @@ static int hyper_dmabuf_query(void *data)
 	int ret = 0;
 
 	if (!data) {
-		printk("user data is NULL\n");
+		dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
 		return -EINVAL;
 	}
 
@@ -343,7 +355,7 @@ static int hyper_dmabuf_query(void *data)
 
 	/* if dmabuf can't be found in both lists, return */
 	if (!(sgt_info && imported_sgt_info)) {
-		printk("can't find entry anywhere\n");
+		dev_err(hyper_dmabuf_private.device, "can't find entry anywhere\n");
 		return -EINVAL;
 	}
 
@@ -419,25 +431,25 @@ static long hyper_dmabuf_ioctl(struct file *filp,
 	func = ioctl->func;
 
 	if (unlikely(!func)) {
-		printk("no function\n");
+		dev_err(hyper_dmabuf_private.device, "no function\n");
 		return -EINVAL;
 	}
 
 	kdata = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
 	if (!kdata) {
-		printk("no memory\n");
+		dev_err(hyper_dmabuf_private.device, "no memory\n");
 		return -ENOMEM;
 	}
 
 	if (copy_from_user(kdata, (void __user *)param, _IOC_SIZE(cmd)) != 0) {
-		printk("failed to copy from user arguments\n");
+		dev_err(hyper_dmabuf_private.device, "failed to copy from user arguments\n");
 		return -EFAULT;
 	}
 
 	ret = func(kdata);
 
 	if (copy_to_user((void __user *)param, kdata, _IOC_SIZE(cmd)) != 0) {
-		printk("failed to copy to user arguments\n");
+		dev_err(hyper_dmabuf_private.device, "failed to copy to user arguments\n");
 		return -EFAULT;
 	}
 
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
index 4647115..9c38900 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
@@ -114,12 +114,12 @@ void cmd_process_work(struct work_struct *work)
 		imported_sgt_info->nents = req->operands[1];
 		imported_sgt_info->ref_handle = req->operands[4];
 
-		printk("DMABUF was exported\n");
-		printk("\thyper_dmabuf_id %d\n", req->operands[0]);
-		printk("\tnents %d\n", req->operands[1]);
-		printk("\tfirst offset %d\n", req->operands[2]);
-		printk("\tlast len %d\n", req->operands[3]);
-		printk("\tgrefid %d\n", req->operands[4]);
+		dev_dbg(hyper_dmabuf_private.device, "DMABUF was exported\n");
+		dev_dbg(hyper_dmabuf_private.device, "\thyper_dmabuf_id %d\n", req->operands[0]);
+		dev_dbg(hyper_dmabuf_private.device, "\tnents %d\n", req->operands[1]);
+		dev_dbg(hyper_dmabuf_private.device, "\tfirst offset %d\n", req->operands[2]);
+		dev_dbg(hyper_dmabuf_private.device, "\tlast len %d\n", req->operands[3]);
+		dev_dbg(hyper_dmabuf_private.device, "\tgrefid %d\n", req->operands[4]);
 
 		for (i=0; i<4; i++)
 			imported_sgt_info->private[i] = req->operands[5+i];
@@ -133,7 +133,8 @@ void cmd_process_work(struct work_struct *work)
 		sgt_info = hyper_dmabuf_find_exported(req->operands[0]);
 
 		if (!sgt_info) {
-			printk("critical err: requested sgt_info can't be found %d\n", req->operands[0]);
+			dev_err(hyper_dmabuf_private.device,
+				"critical err: requested sgt_info can't be found %d\n", req->operands[0]);
 			break;
 		}
 
@@ -163,13 +164,13 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 	int ret;
 
 	if (!req) {
-		printk("request is NULL\n");
+		dev_err(hyper_dmabuf_private.device, "request is NULL\n");
 		return -EINVAL;
 	}
 
 	if ((req->command < HYPER_DMABUF_EXPORT) ||
 		(req->command > HYPER_DMABUF_OPS_TO_SOURCE)) {
-		printk("invalid command\n");
+		dev_err(hyper_dmabuf_private.device, "invalid command\n");
 		return -EINVAL;
 	}
 
@@ -183,7 +184,8 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 		/* command : HYPER_DMABUF_NOTIFY_UNEXPORT,
 		 * operands0 : hyper_dmabuf_id
 		 */
-
+		dev_dbg(hyper_dmabuf_private.device,
+			"%s: processing HYPER_DMABUF_NOTIFY_UNEXPORT\n", __func__);
 		sgt_info = hyper_dmabuf_find_imported(req->operands[0]);
 
 		if (sgt_info) {
@@ -216,6 +218,8 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 		 * operands0 : hyper_dmabuf_id
 		 * operands1 : enum hyper_dmabuf_ops {....}
 		 */
+		dev_dbg(hyper_dmabuf_private.device,
+			"%s: HYPER_DMABUF_OPS_TO_SOURCE\n", __func__);
 		ret = hyper_dmabuf_remote_sync(req->operands[0], req->operands[1]);
 		if (ret)
 			req->status = HYPER_DMABUF_REQ_ERROR;
@@ -225,6 +229,8 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
 		return req->command;
 	}
 
+	dev_dbg(hyper_dmabuf_private.device,
+		"%s: putting request to workqueue\n", __func__);
 	temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL);
 
 	memcpy(temp_req, req, sizeof(*temp_req));
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
index 0f4735c..2758915 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
@@ -41,7 +41,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 	sgt_info = hyper_dmabuf_find_exported(id);
 
 	if (!sgt_info) {
-		printk("dmabuf remote sync::can't find exported list\n");
+		dev_err(hyper_dmabuf_private.device,
+			"dmabuf remote sync::can't find exported list\n");
 		return -EINVAL;
 	}
 
@@ -54,7 +55,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 
 		if (!attachl->attach) {
 			kfree(attachl);
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n");
 			return -EINVAL;
 		}
 
@@ -63,8 +65,10 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 
 	case HYPER_DMABUF_OPS_DETACH:
 		if (list_empty(&sgt_info->active_attached->list)) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_DETACH\n");
-			printk("no more dmabuf attachment left to be detached\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_DETACH\n");
+			dev_err(hyper_dmabuf_private.device,
+				"no more dmabuf attachment left to be detached\n");
 			return -EINVAL;
 		}
 
@@ -78,8 +82,10 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 
 	case HYPER_DMABUF_OPS_MAP:
 		if (list_empty(&sgt_info->active_attached->list)) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
-			printk("no more dmabuf attachment left to be detached\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
+			dev_err(hyper_dmabuf_private.device,
+				"no more dmabuf attachment left to be detached\n");
 			return -EINVAL;
 		}
 
@@ -90,7 +96,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 		sgtl->sgt = dma_buf_map_attachment(attachl->attach, DMA_BIDIRECTIONAL);
 		if (!sgtl->sgt) {
 			kfree(sgtl);
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
 			return -EINVAL;
 		}
 		list_add(&sgtl->list, &sgt_info->active_sgts->list);
@@ -99,8 +106,10 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 	case HYPER_DMABUF_OPS_UNMAP:
 		if (list_empty(&sgt_info->active_sgts->list) ||
 		    list_empty(&sgt_info->active_attached->list)) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_UNMAP\n");
-			printk("no more SGT or attachment left to be freed\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_UNMAP\n");
+			dev_err(hyper_dmabuf_private.device,
+				"no more SGT or attachment left to be freed\n");
 			return -EINVAL;
 		}
 
@@ -140,7 +149,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 	case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS:
 		ret = dma_buf_begin_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL);
 		if (!ret) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
 			ret = -EINVAL;
 		}
 		break;
@@ -148,7 +158,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 	case HYPER_DMABUF_OPS_END_CPU_ACCESS:
 		ret = dma_buf_end_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL);
 		if (!ret) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
 			ret = -EINVAL;
 		}
 		break;
@@ -165,7 +176,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 
 		if (!va_kmapl->vaddr) {
 			kfree(va_kmapl);
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
 			return -EINVAL;
 		}
 		list_add(&va_kmapl->list, &sgt_info->va_kmapped->list);
@@ -174,15 +186,18 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 	case HYPER_DMABUF_OPS_KUNMAP_ATOMIC:
 	case HYPER_DMABUF_OPS_KUNMAP:
 		if (list_empty(&sgt_info->va_kmapped->list)) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
-			printk("no more dmabuf VA to be freed\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
+			dev_err(hyper_dmabuf_private.device,
+				"no more dmabuf VA to be freed\n");
 			return -EINVAL;
 		}
 
 		va_kmapl = list_first_entry(&sgt_info->va_kmapped->list,
 					    struct kmap_vaddr_list, list);
 		if (va_kmapl->vaddr == NULL) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
 			return -EINVAL;
 		}
 
@@ -199,7 +214,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 	case HYPER_DMABUF_OPS_MMAP:
 		/* currently not supported: looking for a way to create
 		 * a dummy vma */
-		printk("dmabuf remote sync::sychronized mmap is not supported\n");
+		dev_warn(hyper_dmabuf_private.device,
+			 "dmabuf remote sync::sychronized mmap is not supported\n");
 		break;
 
 	case HYPER_DMABUF_OPS_VMAP:
@@ -210,7 +226,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 
 		if (!va_vmapl->vaddr) {
 			kfree(va_vmapl);
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n");
 			return -EINVAL;
 		}
 		list_add(&va_vmapl->list, &sgt_info->va_vmapped->list);
@@ -218,14 +235,17 @@ int hyper_dmabuf_remote_sync(int id, int ops)
 
 	case HYPER_DMABUF_OPS_VUNMAP:
 		if (list_empty(&sgt_info->va_vmapped->list)) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
-			printk("no more dmabuf VA to be freed\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
+			dev_err(hyper_dmabuf_private.device,
+				"no more dmabuf VA to be freed\n");
 			return -EINVAL;
 		}
 		va_vmapl = list_first_entry(&sgt_info->va_vmapped->list,
 					struct vmap_vaddr_list, list);
 		if (!va_vmapl || va_vmapl->vaddr == NULL) {
-			printk("dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
+			dev_err(hyper_dmabuf_private.device,
+				"dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
 			return -EINVAL;
 		}
 
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 bd37ec2..5e7a250 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
@@ -10,11 +10,14 @@
 #include <asm/xen/page.h>
 #include "hyper_dmabuf_xen_comm.h"
 #include "hyper_dmabuf_xen_comm_list.h"
+#include "../hyper_dmabuf_drv.h"
 
 static int export_req_id = 0;
 
 struct hyper_dmabuf_req req_pending = {0};
 
+extern struct hyper_dmabuf_private hyper_dmabuf_private;
+
 /* Creates entry in xen store that will keep details of all
  * exporter rings created by this domain
  */
@@ -55,14 +58,16 @@ static int xen_comm_expose_ring_details(int domid, int rdomid,
 	ret = xenbus_printf(XBT_NIL, buf, "grefid", "%d", gref);
 
 	if (ret) {
-		printk("Failed to write xenbus entry %s: %d\n", buf, ret);
+		dev_err(hyper_dmabuf_private.device,
+			"Failed to write xenbus entry %s: %d\n", buf, ret);
 		return ret;
 	}
 
 	ret = xenbus_printf(XBT_NIL, buf, "port", "%d", port);
 
 	if (ret) {
-		printk("Failed to write xenbus entry %s: %d\n", buf, ret);
+		dev_err(hyper_dmabuf_private.device,
+			"Failed to write xenbus entry %s: %d\n", buf, ret);
 		return ret;
 	}
 
@@ -81,14 +86,16 @@ static int xen_comm_get_ring_details(int domid, int rdomid, int *grefid, int *po
 	ret = xenbus_scanf(XBT_NIL, buf, "grefid", "%d", grefid);
 
 	if (ret <= 0) {
-		printk("Failed to read xenbus entry %s: %d\n", buf, ret);
+		dev_err(hyper_dmabuf_private.device,
+			"Failed to read xenbus entry %s: %d\n", buf, ret);
 		return ret;
 	}
 
 	ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", port);
 
 	if (ret <= 0) {
-		printk("Failed to read xenbus entry %s: %d\n", buf, ret);
+		dev_err(hyper_dmabuf_private.device,
+			"Failed to read xenbus entry %s: %d\n", buf, ret);
 		return ret;
 	}
 
@@ -161,10 +168,12 @@ static void remote_dom_exporter_watch_cb(struct xenbus_watch *watch,
 					&grefid, &port);
 
 	if (ring_info && ret != 0) {
-		printk("Remote exporter closed, cleaninup importer\n");
+		dev_info(hyper_dmabuf_private.device,
+			 "Remote exporter closed, cleaninup importer\n");
 		hyper_dmabuf_xen_cleanup_rx_rbuf(rdom);
 	} else if (!ring_info && ret == 0) {
-		printk("Registering importer\n");
+		dev_info(hyper_dmabuf_private.device,
+			 "Registering importer\n");
 		hyper_dmabuf_xen_init_rx_rbuf(rdom);
 	}
 }
@@ -184,7 +193,8 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 	ring_info = xen_comm_find_tx_ring(domid);
 
 	if (ring_info) {
-		printk("tx ring ch to domid = %d already exist\ngref = %d, port = %d\n",
+		dev_info(hyper_dmabuf_private.device,
+			 "tx ring ch to domid = %d already exist\ngref = %d, port = %d\n",
 		ring_info->rdomain, ring_info->gref_ring, ring_info->port);
 		return 0;
 	}
@@ -216,7 +226,8 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 	ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
 					&alloc_unbound);
 	if (ret != 0) {
-		printk("Cannot allocate event channel\n");
+		dev_err(hyper_dmabuf_private.device,
+			"Cannot allocate event channel\n");
 		return -EINVAL;
 	}
 
@@ -226,7 +237,8 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 					NULL, (void*) ring_info);
 
 	if (ret < 0) {
-		printk("Failed to setup event channel\n");
+		dev_err(hyper_dmabuf_private.device,
+			"Failed to setup event channel\n");
 		close.port = alloc_unbound.port;
 		HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
 		gnttab_end_foreign_access(ring_info->gref_ring, 0,
@@ -238,7 +250,8 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
 	ring_info->irq = ret;
 	ring_info->port = alloc_unbound.port;
 
-	printk("%s: allocated eventchannel gref %d  port: %d  irq: %d\n",
+	dev_dbg(hyper_dmabuf_private.device,
+		"%s: allocated eventchannel gref %d  port: %d  irq: %d\n",
 		__func__,
 		ring_info->gref_ring,
 		ring_info->port,
@@ -315,7 +328,8 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 	ring_info = xen_comm_find_rx_ring(domid);
 
 	if (ring_info) {
-		printk("rx ring ch from domid = %d already exist\n", ring_info->sdomain);
+		dev_info(hyper_dmabuf_private.device,
+			 "rx ring ch from domid = %d already exist\n", ring_info->sdomain);
 		return 0;
 	}
 
@@ -323,7 +337,8 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 					&rx_gref, &rx_port);
 
 	if (ret) {
-		printk("Domain %d has not created exporter ring for current domain\n", domid);
+		dev_err(hyper_dmabuf_private.device,
+			"Domain %d has not created exporter ring for current domain\n", domid);
 		return ret;
 	}
 
@@ -346,12 +361,12 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 
 	ret = gnttab_map_refs(map_ops, NULL, &shared_ring, 1);
 	if (ret < 0) {
-		printk("Cannot map ring\n");
+		dev_err(hyper_dmabuf_private.device, "Cannot map ring\n");
 		return -EINVAL;
 	}
 
 	if (map_ops[0].status) {
-		printk("Ring mapping failed\n");
+		dev_err(hyper_dmabuf_private.device, "Ring mapping failed\n");
 		return -EINVAL;
 	} else {
 		ring_info->unmap_op.handle = map_ops[0].handle;
@@ -372,7 +387,8 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
 
 	ring_info->irq = ret;
 
-	printk("%s: bound to eventchannel port: %d  irq: %d\n", __func__,
+	dev_dbg(hyper_dmabuf_private.device,
+		"%s: bound to eventchannel port: %d  irq: %d\n", __func__,
 		rx_port,
 		ring_info->irq);
 
@@ -445,7 +461,8 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
 	/* find a ring info for the channel */
 	ring_info = xen_comm_find_tx_ring(domid);
 	if (!ring_info) {
-		printk("Can't find ring info for the channel\n");
+		dev_err(hyper_dmabuf_private.device,
+			"Can't find ring info for the channel\n");
 		return -EINVAL;
 	}
 
@@ -456,7 +473,8 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
 
 	new_req = RING_GET_REQUEST(ring, ring->req_prod_pvt);
 	if (!new_req) {
-		printk("NULL REQUEST\n");
+		dev_err(hyper_dmabuf_private.device,
+			"NULL REQUEST\n");
 		return -EIO;
 	}
 
@@ -484,7 +502,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
 		}
 
 		if (timeout < 0) {
-			printk("request timed-out\n");
+			dev_err(hyper_dmabuf_private.device, "request timed-out\n");
 			return -EBUSY;
 		}
 	}
@@ -508,6 +526,8 @@ static irqreturn_t back_ring_isr(int irq, void *info)
 	ring_info = (struct xen_comm_rx_ring_info *)info;
 	ring = &ring_info->ring_back;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__);
+
 	do {
 		rc = ring->req_cons;
 		rp = ring->sring->req_prod;
@@ -558,6 +578,8 @@ static irqreturn_t front_ring_isr(int irq, void *info)
 	ring_info = (struct xen_comm_tx_ring_info *)info;
 	ring = &ring_info->ring_front;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__);
+
 	do {
 		more_to_do = 0;
 		rp = ring->sring->rsp_prod;
@@ -576,16 +598,21 @@ static irqreturn_t front_ring_isr(int irq, void *info)
 							(struct hyper_dmabuf_req *)resp);
 
 				if (ret < 0) {
-					printk("getting error while parsing response\n");
+					dev_err(hyper_dmabuf_private.device,
+						"getting error while parsing response\n");
 				}
 			} else if (resp->status == HYPER_DMABUF_REQ_PROCESSED) {
 				/* for debugging dma_buf remote synchronization */
-				printk("original request = 0x%x\n", resp->command);
-				printk("Just got HYPER_DMABUF_REQ_PROCESSED\n");
+				dev_dbg(hyper_dmabuf_private.device,
+					"original request = 0x%x\n", resp->command);
+				dev_dbg(hyper_dmabuf_private.device,
+					"Just got HYPER_DMABUF_REQ_PROCESSED\n");
 			} else if (resp->status == HYPER_DMABUF_REQ_ERROR) {
 				/* for debugging dma_buf remote synchronization */
-				printk("original request = 0x%x\n", resp->command);
-				printk("Just got HYPER_DMABUF_REQ_ERROR\n");
+				dev_dbg(hyper_dmabuf_private.device,
+					"original request = 0x%x\n", resp->command);
+				dev_dbg(hyper_dmabuf_private.device,
+					"Just got HYPER_DMABUF_REQ_ERROR\n");
 			}
 		}
 
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 c0045d4..cc9860b 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
@@ -4,9 +4,12 @@
 #include <xen/grant_table.h>
 #include <asm/xen/page.h>
 #include "hyper_dmabuf_xen_drv.h"
+#include "../hyper_dmabuf_drv.h"
 
 #define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
 
+extern struct hyper_dmabuf_private hyper_dmabuf_private;
+
 /*
  * Creates 2 level page directory structure for referencing shared pages.
  * Top level page is a single page that contains up to 1024 refids that
@@ -93,9 +96,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
 	/* Store lvl2_table pages to be freed later */
 	sh_pages_info->lvl2_table = lvl2_table;
 
+
 	/* Store exported pages refid to be unshared later */
 	sh_pages_info->lvl3_gref = lvl3_gref;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
 	return lvl3_gref;
 }
 
@@ -104,19 +109,21 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
 	int n_lvl2_grefs = (nents/REFS_PER_PAGE + ((nents % REFS_PER_PAGE) ? 1: 0));
 	int i;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
 	sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
 
 	if (sh_pages_info->lvl3_table == NULL ||
 	    sh_pages_info->lvl2_table ==  NULL ||
 	    sh_pages_info->lvl3_gref == -1) {
-		printk("gref table for hyper_dmabuf already cleaned up\n");
+		dev_warn(hyper_dmabuf_private.device,
+			 "gref table for hyper_dmabuf already cleaned up\n");
 		return 0;
 	}
 
 	/* 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])) {
-			printk("refid not shared !!\n");
+			dev_warn(hyper_dmabuf_private.device, "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]);
@@ -125,17 +132,17 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
 	/* End foreign access for 2nd level addressing pages */
 	for (i = 0; i < n_lvl2_grefs; i++) {
 		if (gnttab_query_foreign_access(sh_pages_info->lvl3_table[i])) {
-			printk("refid not shared !!\n");
+			dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n");
 		}
 		if (!gnttab_end_foreign_access_ref(sh_pages_info->lvl3_table[i], 1)) {
-			printk("refid still in use!!!\n");
+			dev_warn(hyper_dmabuf_private.device, "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)) {
-		printk("gref not shared !!\n");
+		dev_warn(hyper_dmabuf_private.device, "gref not shared !!\n");
 	}
 
 	gnttab_end_foreign_access_ref(sh_pages_info->lvl3_gref, 1);
@@ -151,6 +158,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
 	kfree(sh_pages_info);
 	sh_pages_info = NULL;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
 	return 0;
 }
 
@@ -180,6 +188,8 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 	int n_lvl2_grefs = (nents / REFS_PER_PAGE) + ((nents_last > 0) ? 1 : 0);
 	int i, j, k;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+
 	sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
 	*refs_info = (void *) sh_pages_info;
 
@@ -194,7 +204,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 
 	/* Map top level addressing page */
 	if (gnttab_alloc_pages(1, &lvl3_table_page)) {
-		printk("Cannot allocate pages\n");
+		dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
 		return NULL;
 	}
 
@@ -206,12 +216,12 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 	gnttab_set_unmap_op(&lvl3_unmap_ops, (unsigned long)lvl3_table, GNTMAP_host_map | GNTMAP_readonly, -1);
 
 	if (gnttab_map_refs(&lvl3_map_ops, NULL, &lvl3_table_page, 1)) {
-		printk("\nxen: dom0: HYPERVISOR map grant ref failed");
+		dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed");
 		return NULL;
 	}
 
 	if (lvl3_map_ops.status) {
-		printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d",
+		dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed status = %d",
 			lvl3_map_ops.status);
 		return NULL;
 	} else {
@@ -220,7 +230,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 
 	/* Map all second level pages */
 	if (gnttab_alloc_pages(n_lvl2_grefs, lvl2_table_pages)) {
-		printk("Cannot allocate pages\n");
+		dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
 		return NULL;
 	}
 
@@ -233,19 +243,19 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 
 	/* Unmap top level page, as it won't be needed any longer */
 	if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1)) {
-		printk("\xen: cannot unmap top level page\n");
+		dev_err(hyper_dmabuf_private.device, "xen: cannot unmap top level page\n");
 		return NULL;
 	}
 
 	if (gnttab_map_refs(lvl2_map_ops, NULL, lvl2_table_pages, n_lvl2_grefs)) {
-		printk("\nxen: dom0: HYPERVISOR map grant ref failed");
+		dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed");
 		return NULL;
 	}
 
 	/* Checks if pages were mapped correctly */
 	for (i = 0; i < n_lvl2_grefs; i++) {
 		if (lvl2_map_ops[i].status) {
-			printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d",
+			dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed status = %d",
 			       lvl2_map_ops[i].status);
 			return NULL;
 		} else {
@@ -254,7 +264,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 	}
 
 	if (gnttab_alloc_pages(nents, data_pages)) {
-		printk("Cannot allocate pages\n");
+		dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
 		return NULL;
 	}
 
@@ -291,20 +301,20 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 	}
 
 	if (gnttab_map_refs(data_map_ops, NULL, data_pages, nents)) {
-		printk("\nxen: dom0: HYPERVISOR map grant ref failed\n");
+		dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed\n");
 		return NULL;
 	}
 
 	/* unmapping lvl2 table pages */
 	if (gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages,
 			      n_lvl2_grefs)) {
-		printk("Cannot unmap 2nd level refs\n");
+		dev_err(hyper_dmabuf_private.device, "Cannot unmap 2nd level refs\n");
 		return NULL;
 	}
 
 	for (i = 0; i < nents; i++) {
 		if (data_map_ops[i].status) {
-			printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d\n",
+			dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed status = %d\n",
 				data_map_ops[i].status);
 			return NULL;
 		} else {
@@ -323,23 +333,26 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
 	kfree(lvl2_unmap_ops);
 	kfree(data_map_ops);
 
+	dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
 	return data_pages;
 }
 
 int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
 	struct xen_shared_pages_info *sh_pages_info;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+
 	sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
 
 	if (sh_pages_info->unmap_ops == NULL ||
 	    sh_pages_info->data_pages == NULL) {
-		printk("Imported pages already cleaned up or buffer was not imported yet\n");
+		dev_warn(hyper_dmabuf_private.device, "Imported pages already cleaned up or buffer was not imported yet\n");
 		return 0;
 	}
 
 	if (gnttab_unmap_refs(sh_pages_info->unmap_ops, NULL,
 			      sh_pages_info->data_pages, nents) ) {
-		printk("Cannot unmap data pages\n");
+		dev_err(hyper_dmabuf_private.device, "Cannot unmap data pages\n");
 		return -EINVAL;
 	}
 
@@ -352,5 +365,6 @@ int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
 	kfree(sh_pages_info);
 	sh_pages_info = NULL;
 
+	dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
 	return 0;
 }
-- 
2.7.4