From: Dongwon Kim <dongwon.kim@intel.com>
To: linux-kernel@vger.kernel.org
Cc: dri-devel@lists.freedesktop.org, xen-devel@lists.xenproject.org,
mateuszx.potrola@intel.com, dongwon.kim@intel.com
Subject: [RFC PATCH 50/60] hyper_dmabuf: fix styling err and warns caught by checkpatch.pl
Date: Tue, 19 Dec 2017 11:30:06 -0800 [thread overview]
Message-ID: <1513711816-2618-50-git-send-email-dongwon.kim@intel.com> (raw)
In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com>
Fixing all styling problems caught by checkpatch.pl
Signed-off-by: Dongwon Kim <dongwon.kim@intel.com>
---
drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 53 ++--
drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 6 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c | 12 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c | 24 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_id.h | 4 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 308 +++++++++++----------
drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h | 5 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 132 ++++-----
drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 4 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c | 58 ++--
drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c | 236 ++++++++--------
.../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 81 +++---
drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c | 15 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h | 2 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 78 ++++--
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 154 +++++------
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h | 21 +-
.../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c | 21 +-
.../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h | 16 +-
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h | 19 +-
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c | 128 +++++----
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h | 15 +-
include/uapi/xen/hyper_dmabuf.h | 26 +-
23 files changed, 739 insertions(+), 679 deletions(-)
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__
--
2.7.4
next prev parent reply other threads:[~2017-12-19 19:39 UTC|newest]
Thread overview: 159+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-12-19 19:29 [RFC PATCH 01/60] hyper_dmabuf: initial working version of hyper_dmabuf drv Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 02/60] hyper_dmabuf: added a doc for hyper_dmabuf sharing Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 03/60] hyper_dmabuf: re-use dma_buf previously exported if exist Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 04/60] hyper_dmabuf: new index, k for pointing a right n-th page Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 05/60] hyper_dmabuf: skip creating a comm ch if exist for the VM Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 06/60] hyper_dmabuf: map shared pages only once when importing Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 07/60] hyper_dmabuf: message parsing done via workqueue Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 08/60] hyper_dmabuf: automatic comm channel initialization using xenstore Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 09/60] hyper_dmabuf: indirect DMA_BUF synchronization via shadowing Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 10/60] hyper_dmabuf: make sure to free memory to prevent leak Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 11/60] hyper_dmabuf: check stack before unmapping/detaching shadow DMA_BUF Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 12/60] hyper_dmabuf: two different unexporting mechanisms Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 13/60] hyper_dmabuf: postponing cleanup of hyper_DMABUF Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 14/60] hyper_dmabuf: clean-up process based on file->f_count Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 15/60] hyper_dmabuf: reusing previously released hyper_dmabuf_id Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 16/60] hyper_dmabuf: define hypervisor specific backend API Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 17/60] hyper_dmabuf: use dynamic debug macros for logging Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 18/60] hyper_dmabuf: reset comm channel when one end has disconnected Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 19/60] hyper_dmabuf: fix the case with sharing a buffer with 2 pages Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 20/60] hyper_dmabuf: optimized loop with less condition check Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 21/60] hyper_dmabuf: exposing drv information using sysfs Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 22/60] hyper_dmabuf: configure license Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 23/60] hyper_dmabuf: use CONFIG_HYPER_DMABUF_XEN instead of CONFIG_XEN Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 24/60] hyper_dmabuf: waits for resp only if WAIT_AFTER_SYNC_REQ == 1 Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 25/60] hyper_dmabuf: introduced delayed unexport Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 26/60] hyper_dmabuf: add mutexes to prevent several race conditions Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 27/60] hyper_dmabuf: use proper error codes Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 28/60] hyper_dmabuf: address several synchronization issues Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 29/60] hyper_dmabuf: make sure to release allocated buffers when exiting Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 30/60] hyper_dmabuf: free already mapped pages when error happens Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 31/60] hyper_dmabuf: built-in compilation option Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 32/60] hyper_dmabuf: make all shared pages read-only Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 33/60] hyper_dmabuf: error checking on the result of dma_buf_map_attachment Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 34/60] hyper_dmabuf: extend DMA bitmask to 64-bits Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 35/60] hyper_dmabuf: 128bit hyper_dmabuf_id with random keys Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 36/60] hyper_dmabuf: error handling when share_pages fails Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 37/60] hyper_dmabuf: implementation of query ioctl Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 38/60] hyper_dmabuf: preventing self exporting of dma_buf Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 39/60] hyper_dmabuf: correcting DMA-BUF clean-up order Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 40/60] hyper_dmabuf: do not use 'private' as field name Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 41/60] hyper_dmabuf: re-organize driver source Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 42/60] hyper_dmabuf: always generate a new random keys Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:29 ` [RFC PATCH 43/60] hyper_dmabuf: fixes on memory leaks in various places Dongwon Kim
2017-12-19 19:29 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 44/60] hyper_dmabuf: proper handling of sgt_info->priv Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 45/60] hyper_dmabuf: adding poll/read for event generation Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 46/60] hyper_dmabuf: delay auto initialization of comm_env Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 47/60] hyper_dmabuf: fix issues with event-polling Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 48/60] hyper_dmabuf: add query items for buffer private info Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 49/60] hyper_dmabuf: general clean-up and fixes Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 50/60] hyper_dmabuf: fix styling err and warns caught by checkpatch.pl Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim [this message]
2017-12-19 19:30 ` [RFC PATCH 51/60] hyper_dmabuf: missing mutex_unlock and move spinlock Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 52/60] hyper_dmabuf: remove prefix 'hyper_dmabuf' from static func and backend APIs Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 53/60] hyper_dmabuf: define fastpath_export for exporting existing buffer Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 54/60] hyper_dmabuf: 'backend_ops' reduced to 'bknd_ops' and 'ops' to 'bknd_ops' Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 55/60] hyper_dmabuf: fixed wrong send_req call Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 56/60] hyper_dmabuf: add initialization and cleanup to bknd_ops Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 57/60] hyper_dmabuf: change type of ref to shared pages to unsigned long Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 58/60] hyper_dmabuf: move device node out of /dev/xen/ Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 59/60] hyper_dmabuf: freeing hy_drv_priv when drv init fails (v2) Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 19:30 ` [RFC PATCH 60/60] hyper_dmabuf: move hyper_dmabuf to under drivers/dma-buf/ Dongwon Kim
2017-12-19 19:30 ` Dongwon Kim
2017-12-19 23:27 ` [RFC PATCH 01/60] hyper_dmabuf: initial working version of hyper_dmabuf drv Dongwon Kim
2017-12-19 23:27 ` Dongwon Kim
2017-12-19 23:27 ` Dongwon Kim
2017-12-20 8:17 ` Juergen Gross
2017-12-20 8:17 ` [Xen-devel] " Juergen Gross
2018-01-10 23:21 ` Dongwon Kim
2018-01-10 23:21 ` [Xen-devel] " Dongwon Kim
2018-01-10 23:21 ` Dongwon Kim
2017-12-20 8:38 ` Oleksandr Andrushchenko
2017-12-20 8:38 ` [Xen-devel] " Oleksandr Andrushchenko
2018-01-10 23:14 ` Dongwon Kim
2018-01-10 23:14 ` [Xen-devel] " Dongwon Kim
2017-12-20 9:59 ` Daniel Vetter
2017-12-20 9:59 ` Daniel Vetter
2017-12-26 18:19 ` Matt Roper
2017-12-26 18:19 ` Matt Roper
2017-12-29 13:03 ` Tomeu Vizoso
2017-12-29 13:03 ` Tomeu Vizoso
2017-12-29 13:03 ` Tomeu Vizoso
2017-12-26 18:19 ` Matt Roper
2018-01-10 23:13 ` Dongwon Kim
2018-01-10 23:13 ` Dongwon Kim
2017-12-20 9:59 ` Daniel Vetter
2018-02-15 1:34 ` Dongwon Kim
2018-02-15 1:34 ` Dongwon Kim
2018-02-15 1:34 ` Dongwon Kim
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1513711816-2618-50-git-send-email-dongwon.kim@intel.com \
--to=dongwon.kim@intel.com \
--cc=dri-devel@lists.freedesktop.org \
--cc=linux-kernel@vger.kernel.org \
--cc=mateuszx.potrola@intel.com \
--cc=xen-devel@lists.xenproject.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.