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 49/60] hyper_dmabuf: general clean-up and fixes
Date: Tue, 19 Dec 2017 11:30:05 -0800 [thread overview]
Message-ID: <1513711816-2618-49-git-send-email-dongwon.kim@intel.com> (raw)
In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com>
1. global hyper_dmabuf_private is now pointer(*hy_drv_priv)
pointing to private data structure initialized when driver
is initialized. This is freed when driver exits.
2. using shorter variable and type's names
3. remove unnecessary NULL checks
4. event-polling related funcs are now compiled only if
CONFIG_HYPER_DMABUF_EVENT_GEN is enabled.
Signed-off-by: Dongwon Kim <dongwon.kim@intel.com>
---
drivers/xen/hyper_dmabuf/Makefile | 7 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h | 25 -
drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 164 +++---
drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 13 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c | 60 +--
drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c | 16 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 569 ++++++++++-----------
drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h | 2 +
drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c | 88 ++--
drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h | 18 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 259 +++++-----
drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 18 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c | 284 +++++-----
drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h | 4 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c | 58 +--
drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h | 4 +-
.../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 170 +++---
drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c | 123 ++---
drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h | 10 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 24 +-
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 240 +++++----
.../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c | 6 +-
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c | 147 +++---
23 files changed, 1144 insertions(+), 1165 deletions(-)
delete mode 100644 drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
diff --git a/drivers/xen/hyper_dmabuf/Makefile b/drivers/xen/hyper_dmabuf/Makefile
index 1cd7a81..a113bfc 100644
--- a/drivers/xen/hyper_dmabuf/Makefile
+++ b/drivers/xen/hyper_dmabuf/Makefile
@@ -13,9 +13,12 @@ ifneq ($(KERNELRELEASE),)
hyper_dmabuf_id.o \
hyper_dmabuf_remote_sync.o \
hyper_dmabuf_query.o \
- hyper_dmabuf_event.o \
-ifeq ($(CONFIG_XEN), y)
+ifeq ($(CONFIG_HYPER_DMABUF_EVENT_GEN), y)
+ $(TARGET_MODULE)-objs += hyper_dmabuf_event.o
+endif
+
+ifeq ($(CONFIG_HYPER_DMABUF_XEN), y)
$(TARGET_MODULE)-objs += xen/hyper_dmabuf_xen_comm.o \
xen/hyper_dmabuf_xen_comm_list.o \
xen/hyper_dmabuf_xen_shm.o \
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
deleted file mode 100644
index d5125f2..0000000
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright © 2017 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- *
- */
-
-/* configuration */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
index 1c35a59..525ee78 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
@@ -36,7 +36,6 @@
#include <linux/poll.h>
#include <linux/dma-buf.h>
#include "hyper_dmabuf_drv.h"
-#include "hyper_dmabuf_conf.h"
#include "hyper_dmabuf_ioctl.h"
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_list.h"
@@ -51,13 +50,32 @@ extern struct hyper_dmabuf_backend_ops xen_backend_ops;
MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Intel Corporation");
-struct hyper_dmabuf_private hyper_dmabuf_private;
+struct hyper_dmabuf_private *hy_drv_priv;
long hyper_dmabuf_ioctl(struct file *filp,
unsigned int cmd, unsigned long param);
-void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* sgt_info,
- void *attr);
+static void hyper_dmabuf_force_free(struct exported_sgt_info* exported,
+ void *attr)
+{
+ struct ioctl_hyper_dmabuf_unexport unexport_attr;
+ struct file *filp = (struct file*) attr;
+
+ if (!filp || !exported)
+ return;
+
+ if (exported->filp == filp) {
+ dev_dbg(hy_drv_priv->dev,
+ "Forcefully releasing buffer {id:%d key:%d %d %d}\n",
+ exported->hid.id, exported->hid.rng_key[0],
+ exported->hid.rng_key[1], exported->hid.rng_key[2]);
+
+ unexport_attr.hid = exported->hid;
+ unexport_attr.delay_ms = 0;
+
+ hyper_dmabuf_unexport_ioctl(filp, &unexport_attr);
+ }
+}
int hyper_dmabuf_open(struct inode *inode, struct file *filp)
{
@@ -72,18 +90,20 @@ int hyper_dmabuf_open(struct inode *inode, struct file *filp)
int hyper_dmabuf_release(struct inode *inode, struct file *filp)
{
- hyper_dmabuf_foreach_exported(hyper_dmabuf_emergency_release, filp);
+ hyper_dmabuf_foreach_exported(hyper_dmabuf_force_free, filp);
return 0;
}
+#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
+
unsigned int hyper_dmabuf_event_poll(struct file *filp, struct poll_table_struct *wait)
{
unsigned int mask = 0;
- poll_wait(filp, &hyper_dmabuf_private.event_wait, wait);
+ poll_wait(filp, &hy_drv_priv->event_wait, wait);
- if (!list_empty(&hyper_dmabuf_private.event_list))
+ if (!list_empty(&hy_drv_priv->event_list))
mask |= POLLIN | POLLRDNORM;
return mask;
@@ -96,32 +116,32 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
/* only root can read events */
if (!capable(CAP_DAC_OVERRIDE)) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Only root can read events\n");
return -EFAULT;
}
/* make sure user buffer can be written */
if (!access_ok(VERIFY_WRITE, buffer, count)) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"User buffer can't be written.\n");
return -EFAULT;
}
- ret = mutex_lock_interruptible(&hyper_dmabuf_private.event_read_lock);
+ ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock);
if (ret)
return ret;
while (1) {
struct hyper_dmabuf_event *e = NULL;
- spin_lock_irq(&hyper_dmabuf_private.event_lock);
- if (!list_empty(&hyper_dmabuf_private.event_list)) {
- e = list_first_entry(&hyper_dmabuf_private.event_list,
+ spin_lock_irq(&hy_drv_priv->event_lock);
+ if (!list_empty(&hy_drv_priv->event_list)) {
+ e = list_first_entry(&hy_drv_priv->event_list,
struct hyper_dmabuf_event, link);
list_del(&e->link);
}
- spin_unlock_irq(&hyper_dmabuf_private.event_lock);
+ spin_unlock_irq(&hy_drv_priv->event_lock);
if (!e) {
if (ret)
@@ -131,12 +151,12 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
break;
}
- mutex_unlock(&hyper_dmabuf_private.event_read_lock);
- ret = wait_event_interruptible(hyper_dmabuf_private.event_wait,
- !list_empty(&hyper_dmabuf_private.event_list));
+ mutex_unlock(&hy_drv_priv->event_read_lock);
+ ret = wait_event_interruptible(hy_drv_priv->event_wait,
+ !list_empty(&hy_drv_priv->event_list));
if (ret == 0)
- ret = mutex_lock_interruptible(&hyper_dmabuf_private.event_read_lock);
+ ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock);
if (ret)
return ret;
@@ -145,9 +165,9 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
if (length > count - ret) {
put_back_event:
- spin_lock_irq(&hyper_dmabuf_private.event_lock);
- list_add(&e->link, &hyper_dmabuf_private.event_list);
- spin_unlock_irq(&hyper_dmabuf_private.event_lock);
+ spin_lock_irq(&hy_drv_priv->event_lock);
+ list_add(&e->link, &hy_drv_priv->event_list);
+ spin_unlock_irq(&hy_drv_priv->event_lock);
break;
}
@@ -170,7 +190,7 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
/* nullifying hdr of the event in user buffer */
if (copy_to_user(buffer + ret, &dummy_hdr,
sizeof(dummy_hdr))) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"failed to nullify invalid hdr already in userspace\n");
}
@@ -180,23 +200,30 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
}
ret += e->event_data.hdr.size;
- hyper_dmabuf_private.curr_num_event--;
+ hy_drv_priv->pending--;
kfree(e);
}
}
- mutex_unlock(&hyper_dmabuf_private.event_read_lock);
+ mutex_unlock(&hy_drv_priv->event_read_lock);
return ret;
}
+#endif
+
static struct file_operations hyper_dmabuf_driver_fops =
{
.owner = THIS_MODULE,
.open = hyper_dmabuf_open,
.release = hyper_dmabuf_release,
+
+/* poll and read interfaces are needed only for event-polling */
+#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
.read = hyper_dmabuf_event_read,
.poll = hyper_dmabuf_event_poll,
+#endif
+
.unlocked_ioctl = hyper_dmabuf_ioctl,
};
@@ -217,17 +244,17 @@ int register_device(void)
return ret;
}
- hyper_dmabuf_private.device = hyper_dmabuf_miscdev.this_device;
+ hy_drv_priv->dev = hyper_dmabuf_miscdev.this_device;
/* TODO: Check if there is a different way to initialize dma mask nicely */
- dma_coerce_mask_and_coherent(hyper_dmabuf_private.device, DMA_BIT_MASK(64));
+ dma_coerce_mask_and_coherent(hy_drv_priv->dev, DMA_BIT_MASK(64));
return ret;
}
void unregister_device(void)
{
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"hyper_dmabuf: unregister_device() is called\n");
misc_deregister(&hyper_dmabuf_miscdev);
@@ -239,9 +266,13 @@ static int __init hyper_dmabuf_drv_init(void)
printk( KERN_NOTICE "hyper_dmabuf_starting: Initialization started\n");
- mutex_init(&hyper_dmabuf_private.lock);
- mutex_init(&hyper_dmabuf_private.event_read_lock);
- spin_lock_init(&hyper_dmabuf_private.event_lock);
+ hy_drv_priv = kcalloc(1, sizeof(struct hyper_dmabuf_private),
+ GFP_KERNEL);
+
+ if (!hy_drv_priv) {
+ printk( KERN_ERR "hyper_dmabuf: Failed to create drv\n");
+ return -1;
+ }
ret = register_device();
if (ret < 0) {
@@ -251,64 +282,72 @@ static int __init hyper_dmabuf_drv_init(void)
/* currently only supports XEN hypervisor */
#ifdef CONFIG_HYPER_DMABUF_XEN
- hyper_dmabuf_private.backend_ops = &xen_backend_ops;
+ hy_drv_priv->backend_ops = &xen_backend_ops;
#else
- hyper_dmabuf_private.backend_ops = NULL;
+ hy_drv_priv->backend_ops = NULL;
printk( KERN_ERR "hyper_dmabuf drv currently supports XEN only.\n");
#endif
- if (hyper_dmabuf_private.backend_ops == NULL) {
+ if (hy_drv_priv->backend_ops == NULL) {
printk( KERN_ERR "Hyper_dmabuf: failed to be loaded - no backend found\n");
return -1;
}
- mutex_lock(&hyper_dmabuf_private.lock);
+ /* initializing mutexes and a spinlock */
+ mutex_init(&hy_drv_priv->lock);
+
+ mutex_lock(&hy_drv_priv->lock);
- hyper_dmabuf_private.backend_initialized = false;
+ hy_drv_priv->initialized = false;
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"initializing database for imported/exported dmabufs\n");
/* device structure initialization */
/* currently only does work-queue initialization */
- hyper_dmabuf_private.work_queue = create_workqueue("hyper_dmabuf_wqueue");
+ hy_drv_priv->work_queue = create_workqueue("hyper_dmabuf_wqueue");
ret = hyper_dmabuf_table_init();
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"failed to initialize table for exported/imported entries\n");
return ret;
}
#ifdef CONFIG_HYPER_DMABUF_SYSFS
- ret = hyper_dmabuf_register_sysfs(hyper_dmabuf_private.device);
+ ret = hyper_dmabuf_register_sysfs(hy_drv_priv->dev);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"failed to initialize sysfs\n");
return ret;
}
#endif
+#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
+ mutex_init(&hy_drv_priv->event_read_lock);
+ spin_lock_init(&hy_drv_priv->event_lock);
+
/* Initialize event queue */
- INIT_LIST_HEAD(&hyper_dmabuf_private.event_list);
- init_waitqueue_head(&hyper_dmabuf_private.event_wait);
+ INIT_LIST_HEAD(&hy_drv_priv->event_list);
+ init_waitqueue_head(&hy_drv_priv->event_wait);
- hyper_dmabuf_private.curr_num_event = 0;
- hyper_dmabuf_private.exited = false;
+ /* resetting number of pending events */
+ hy_drv_priv->pending = 0;
+#endif
- hyper_dmabuf_private.domid = hyper_dmabuf_private.backend_ops->get_vm_id();
+ hy_drv_priv->domid = hy_drv_priv->backend_ops->get_vm_id();
- ret = hyper_dmabuf_private.backend_ops->init_comm_env();
+ ret = hy_drv_priv->backend_ops->init_comm_env();
if (ret < 0) {
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"failed to initialize comm-env but it will re-attempt.\n");
} else {
- hyper_dmabuf_private.backend_initialized = true;
+ hy_drv_priv->initialized = true;
}
- mutex_unlock(&hyper_dmabuf_private.lock);
+ mutex_unlock(&hy_drv_priv->lock);
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Finishing up initialization of hyper_dmabuf drv\n");
/* interrupt for comm should be registered here: */
@@ -318,34 +357,39 @@ static int __init hyper_dmabuf_drv_init(void)
static void hyper_dmabuf_drv_exit(void)
{
#ifdef CONFIG_HYPER_DMABUF_SYSFS
- hyper_dmabuf_unregister_sysfs(hyper_dmabuf_private.device);
+ hyper_dmabuf_unregister_sysfs(hy_drv_priv->dev);
#endif
- mutex_lock(&hyper_dmabuf_private.lock);
+ mutex_lock(&hy_drv_priv->lock);
/* hash tables for export/import entries and ring_infos */
hyper_dmabuf_table_destroy();
- hyper_dmabuf_private.backend_ops->destroy_comm();
+ hy_drv_priv->backend_ops->destroy_comm();
/* destroy workqueue */
- if (hyper_dmabuf_private.work_queue)
- destroy_workqueue(hyper_dmabuf_private.work_queue);
+ if (hy_drv_priv->work_queue)
+ destroy_workqueue(hy_drv_priv->work_queue);
/* destroy id_queue */
- if (hyper_dmabuf_private.id_queue)
+ if (hy_drv_priv->id_queue)
destroy_reusable_list();
- hyper_dmabuf_private.exited = true;
-
+#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
/* clean up event queue */
hyper_dmabuf_events_release();
+#endif
- mutex_unlock(&hyper_dmabuf_private.lock);
+ mutex_unlock(&hy_drv_priv->lock);
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"hyper_dmabuf driver: Exiting\n");
+ if (hy_drv_priv) {
+ kfree(hy_drv_priv);
+ hy_drv_priv = NULL;
+ }
+
unregister_device();
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
index a4acdd9f..2ead41b 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
@@ -36,7 +36,7 @@ struct hyper_dmabuf_event {
};
struct hyper_dmabuf_private {
- struct device *device;
+ struct device *dev;
/* VM(domain) id of current VM instance */
int domid;
@@ -55,7 +55,7 @@ struct hyper_dmabuf_private {
struct mutex lock;
/* flag that shows whether backend is initialized */
- bool backend_initialized;
+ bool initialized;
wait_queue_head_t event_wait;
struct list_head event_list;
@@ -63,10 +63,8 @@ struct hyper_dmabuf_private {
spinlock_t event_lock;
struct mutex event_read_lock;
- int curr_num_event;
-
- /* indicate whether the driver is unloaded */
- bool exited;
+ /* # of pending events */
+ int pending;
};
struct list_reusable_id {
@@ -108,4 +106,7 @@ struct hyper_dmabuf_backend_ops {
int (*send_req)(int, struct hyper_dmabuf_req *, int);
};
+/* exporting global drv private info */
+extern struct hyper_dmabuf_private *hy_drv_priv;
+
#endif /* __LINUX_PUBLIC_HYPER_DMABUF_DRV_H__ */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
index 3e1498c..0498cda 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
@@ -32,37 +32,33 @@
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/dma-buf.h>
-#include <xen/grant_table.h>
-#include <asm/xen/page.h>
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_list.h"
#include "hyper_dmabuf_event.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
static void hyper_dmabuf_send_event_locked(struct hyper_dmabuf_event *e)
{
struct hyper_dmabuf_event *oldest;
- assert_spin_locked(&hyper_dmabuf_private.event_lock);
+ assert_spin_locked(&hy_drv_priv->event_lock);
/* check current number of event then if it hits the max num allowed
* then remove the oldest event in the list */
- if (hyper_dmabuf_private.curr_num_event > MAX_DEPTH_EVENT_QUEUE - 1) {
- oldest = list_first_entry(&hyper_dmabuf_private.event_list,
+ if (hy_drv_priv->pending > MAX_DEPTH_EVENT_QUEUE - 1) {
+ oldest = list_first_entry(&hy_drv_priv->event_list,
struct hyper_dmabuf_event, link);
list_del(&oldest->link);
- hyper_dmabuf_private.curr_num_event--;
+ hy_drv_priv->pending--;
kfree(oldest);
}
list_add_tail(&e->link,
- &hyper_dmabuf_private.event_list);
+ &hy_drv_priv->event_list);
- hyper_dmabuf_private.curr_num_event++;
+ hy_drv_priv->pending++;
- wake_up_interruptible(&hyper_dmabuf_private.event_wait);
+ wake_up_interruptible(&hy_drv_priv->event_wait);
}
void hyper_dmabuf_events_release()
@@ -70,34 +66,34 @@ void hyper_dmabuf_events_release()
struct hyper_dmabuf_event *e, *et;
unsigned long irqflags;
- spin_lock_irqsave(&hyper_dmabuf_private.event_lock, irqflags);
+ spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags);
- list_for_each_entry_safe(e, et, &hyper_dmabuf_private.event_list,
+ list_for_each_entry_safe(e, et, &hy_drv_priv->event_list,
link) {
list_del(&e->link);
kfree(e);
- hyper_dmabuf_private.curr_num_event--;
+ hy_drv_priv->pending--;
}
- if (hyper_dmabuf_private.curr_num_event) {
- dev_err(hyper_dmabuf_private.device,
+ if (hy_drv_priv->pending) {
+ dev_err(hy_drv_priv->dev,
"possible leak on event_list\n");
}
- spin_unlock_irqrestore(&hyper_dmabuf_private.event_lock, irqflags);
+ spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags);
}
int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid)
{
struct hyper_dmabuf_event *e;
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
+ struct imported_sgt_info *imported;
unsigned long irqflags;
- imported_sgt_info = hyper_dmabuf_find_imported(hid);
+ imported = hyper_dmabuf_find_imported(hid);
- if (!imported_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!imported) {
+ dev_err(hy_drv_priv->dev,
"can't find imported_sgt_info in the list\n");
return -EINVAL;
}
@@ -105,29 +101,29 @@ int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid)
e = kzalloc(sizeof(*e), GFP_KERNEL);
if (!e) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"no space left\n");
return -ENOMEM;
}
e->event_data.hdr.event_type = HYPER_DMABUF_NEW_IMPORT;
e->event_data.hdr.hid = hid;
- e->event_data.data = (void*)imported_sgt_info->priv;
- e->event_data.hdr.size = imported_sgt_info->sz_priv;
+ e->event_data.data = (void*)imported->priv;
+ e->event_data.hdr.size = imported->sz_priv;
- spin_lock_irqsave(&hyper_dmabuf_private.event_lock, irqflags);
+ spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags);
hyper_dmabuf_send_event_locked(e);
- spin_unlock_irqrestore(&hyper_dmabuf_private.event_lock, irqflags);
+ spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags);
- dev_dbg(hyper_dmabuf_private.device,
- "event number = %d :", hyper_dmabuf_private.curr_num_event);
+ dev_dbg(hy_drv_priv->dev,
+ "event number = %d :", hy_drv_priv->pending);
- dev_dbg(hyper_dmabuf_private.device,
- "generating events for {%d, %d, %d, %d}\n",
- imported_sgt_info->hid.id, imported_sgt_info->hid.rng_key[0],
- imported_sgt_info->hid.rng_key[1], imported_sgt_info->hid.rng_key[2]);
+ dev_dbg(hy_drv_priv->dev,
+ "generating events for {%d, %d, %d, %d}\n",
+ imported->hid.id, imported->hid.rng_key[0],
+ imported->hid.rng_key[1], imported->hid.rng_key[2]);
return 0;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
index cccdc19..e2466c7 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
@@ -33,17 +33,15 @@
#include "hyper_dmabuf_id.h"
#include "hyper_dmabuf_msg.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
void store_reusable_hid(hyper_dmabuf_id_t hid)
{
- struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
+ struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
struct list_reusable_id *new_reusable;
new_reusable = kmalloc(sizeof(*new_reusable), GFP_KERNEL);
if (!new_reusable) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return;
}
@@ -55,7 +53,7 @@ void store_reusable_hid(hyper_dmabuf_id_t hid)
static hyper_dmabuf_id_t retrieve_reusable_hid(void)
{
- struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
+ struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
hyper_dmabuf_id_t hid = {-1, {0,0,0}};
/* check there is reusable id */
@@ -74,7 +72,7 @@ static hyper_dmabuf_id_t retrieve_reusable_hid(void)
void destroy_reusable_list(void)
{
- struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
+ struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
struct list_reusable_id *temp_head;
if (reusable_head) {
@@ -103,14 +101,14 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
reusable_head = kmalloc(sizeof(*reusable_head), GFP_KERNEL);
if (!reusable_head) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return (hyper_dmabuf_id_t){-1, {0,0,0}};
}
reusable_head->hid.id = -1; /* list head has an invalid count */
INIT_LIST_HEAD(&reusable_head->list);
- hyper_dmabuf_private.id_queue = reusable_head;
+ hy_drv_priv->id_queue = reusable_head;
}
hid = retrieve_reusable_hid();
@@ -119,7 +117,7 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
* and count is less than maximum allowed
*/
if (hid.id == -1 && count < HYPER_DMABUF_ID_MAX) {
- hid.id = HYPER_DMABUF_ID_CREATE(hyper_dmabuf_private.domid, count++);
+ hid.id = HYPER_DMABUF_ID_CREATE(hy_drv_priv->domid, count++);
}
/* random data embedded in the id for security */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
index 15191c2..b328df7 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
@@ -45,16 +45,14 @@
#include "hyper_dmabuf_ops.h"
#include "hyper_dmabuf_query.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data)
{
struct ioctl_hyper_dmabuf_tx_ch_setup *tx_ch_attr;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
int ret = 0;
if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
+ dev_err(hy_drv_priv->dev, "user data is NULL\n");
return -EINVAL;
}
tx_ch_attr = (struct ioctl_hyper_dmabuf_tx_ch_setup *)data;
@@ -67,11 +65,11 @@ static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data)
static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data)
{
struct ioctl_hyper_dmabuf_rx_ch_setup *rx_ch_attr;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
int ret = 0;
if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
+ dev_err(hy_drv_priv->dev, "user data is NULL\n");
return -EINVAL;
}
@@ -82,48 +80,48 @@ static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data)
return ret;
}
-static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info,
- struct hyper_dmabuf_pages_info *page_info)
+static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported,
+ struct pages_info *pg_info)
{
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
struct hyper_dmabuf_req *req;
- int operands[MAX_NUMBER_OF_OPERANDS] = {0};
+ int op[MAX_NUMBER_OF_OPERANDS] = {0};
int ret, i;
/* now create request for importer via ring */
- operands[0] = sgt_info->hid.id;
+ op[0] = exported->hid.id;
for (i=0; i<3; i++)
- operands[i+1] = sgt_info->hid.rng_key[i];
-
- if (page_info) {
- operands[4] = page_info->nents;
- operands[5] = page_info->frst_ofst;
- operands[6] = page_info->last_len;
- operands[7] = ops->share_pages (page_info->pages, sgt_info->hyper_dmabuf_rdomain,
- page_info->nents, &sgt_info->refs_info);
- if (operands[7] < 0) {
- dev_err(hyper_dmabuf_private.device, "pages sharing failed\n");
+ op[i+1] = exported->hid.rng_key[i];
+
+ if (pg_info) {
+ op[4] = pg_info->nents;
+ op[5] = pg_info->frst_ofst;
+ op[6] = pg_info->last_len;
+ op[7] = ops->share_pages(pg_info->pgs, exported->rdomid,
+ pg_info->nents, &exported->refs_info);
+ if (op[7] < 0) {
+ dev_err(hy_drv_priv->dev, "pages sharing failed\n");
return -1;
}
}
- operands[8] = sgt_info->sz_priv;
+ op[8] = exported->sz_priv;
/* driver/application specific private info */
- memcpy(&operands[9], sgt_info->priv, operands[8]);
+ memcpy(&op[9], exported->priv, op[8]);
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if(!req) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ dev_err(hy_drv_priv->dev, "no more space left\n");
return -1;
}
/* composing a message to the importer */
- hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT, &op[0]);
- ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true);
+ ret = ops->send_req(exported->rdomid, req, true);
kfree(req);
@@ -132,24 +130,18 @@ static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info,
static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
{
- struct ioctl_hyper_dmabuf_export_remote *export_remote_attr;
+ struct ioctl_hyper_dmabuf_export_remote *export_remote_attr =
+ (struct ioctl_hyper_dmabuf_export_remote *)data;
struct dma_buf *dma_buf;
struct dma_buf_attachment *attachment;
struct sg_table *sgt;
- struct hyper_dmabuf_pages_info *page_info;
- struct hyper_dmabuf_sgt_info *sgt_info;
+ struct pages_info *pg_info;
+ struct exported_sgt_info *exported;
hyper_dmabuf_id_t hid;
int ret = 0;
- if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
- return -EINVAL;
- }
-
- export_remote_attr = (struct ioctl_hyper_dmabuf_export_remote *)data;
-
- if (hyper_dmabuf_private.domid == export_remote_attr->remote_domain) {
- dev_err(hyper_dmabuf_private.device,
+ if (hy_drv_priv->domid == export_remote_attr->remote_domain) {
+ dev_err(hy_drv_priv->dev,
"exporting to the same VM is not permitted\n");
return -EINVAL;
}
@@ -157,7 +149,7 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
dma_buf = dma_buf_get(export_remote_attr->dmabuf_fd);
if (IS_ERR(dma_buf)) {
- dev_err(hyper_dmabuf_private.device, "Cannot get dma buf\n");
+ dev_err(hy_drv_priv->dev, "Cannot get dma buf\n");
return PTR_ERR(dma_buf);
}
@@ -165,69 +157,79 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
* to the same domain and if yes and it's valid sgt_info,
* it returns hyper_dmabuf_id of pre-exported sgt_info
*/
- hid = hyper_dmabuf_find_hid_exported(dma_buf, export_remote_attr->remote_domain);
+ hid = hyper_dmabuf_find_hid_exported(dma_buf,
+ export_remote_attr->remote_domain);
if (hid.id != -1) {
- sgt_info = hyper_dmabuf_find_exported(hid);
- if (sgt_info != NULL) {
- if (sgt_info->valid) {
+ exported = hyper_dmabuf_find_exported(hid);
+ if (exported != NULL) {
+ if (exported->valid) {
/*
* Check if unexport is already scheduled for that buffer,
* if so try to cancel it. If that will fail, buffer needs
* to be reexport once again.
*/
- if (sgt_info->unexport_scheduled) {
- if (!cancel_delayed_work_sync(&sgt_info->unexport_work)) {
+ if (exported->unexport_sched) {
+ if (!cancel_delayed_work_sync(&exported->unexport)) {
dma_buf_put(dma_buf);
goto reexport;
}
- sgt_info->unexport_scheduled = 0;
+ exported->unexport_sched = false;
}
/* if there's any change in size of private data.
* we reallocate space for private data with new size */
- if (export_remote_attr->sz_priv != sgt_info->sz_priv) {
- kfree(sgt_info->priv);
+ if (export_remote_attr->sz_priv != exported->sz_priv) {
+ kfree(exported->priv);
/* truncating size */
if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) {
- sgt_info->sz_priv = MAX_SIZE_PRIV_DATA;
+ exported->sz_priv = MAX_SIZE_PRIV_DATA;
} else {
- sgt_info->sz_priv = export_remote_attr->sz_priv;
+ exported->sz_priv = export_remote_attr->sz_priv;
}
- sgt_info->priv = kcalloc(1, sgt_info->sz_priv, GFP_KERNEL);
+ exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL);
- if(!sgt_info->priv) {
- dev_err(hyper_dmabuf_private.device,
- "Can't reallocate priv because there's no more space left\n");
- hyper_dmabuf_remove_exported(sgt_info->hid);
- hyper_dmabuf_cleanup_sgt_info(sgt_info, true);
- kfree(sgt_info);
+ if(!exported->priv) {
+ dev_err(hy_drv_priv->dev,
+ "no more space left for priv\n");
+ hyper_dmabuf_remove_exported(exported->hid);
+ hyper_dmabuf_cleanup_sgt_info(exported, true);
+ kfree(exported);
+ dma_buf_put(dma_buf);
return -ENOMEM;
}
}
/* update private data in sgt_info with new ones */
- copy_from_user(sgt_info->priv, export_remote_attr->priv, sgt_info->sz_priv);
-
- /* send an export msg for updating priv in importer */
- ret = hyper_dmabuf_send_export_msg(sgt_info, NULL);
-
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device, "Failed to send a new private data\n");
+ ret = copy_from_user(exported->priv, export_remote_attr->priv,
+ exported->sz_priv);
+ if (ret) {
+ dev_err(hy_drv_priv->dev,
+ "Failed to load a new private data\n");
+ ret = -EINVAL;
+ } else {
+ /* send an export msg for updating priv in importer */
+ ret = hyper_dmabuf_send_export_msg(exported, NULL);
+
+ if (ret < 0) {
+ dev_err(hy_drv_priv->dev,
+ "Failed to send a new private data\n");
+ ret = -EBUSY;
+ }
}
dma_buf_put(dma_buf);
export_remote_attr->hid = hid;
- return 0;
+ return ret;
}
}
}
reexport:
- attachment = dma_buf_attach(dma_buf, hyper_dmabuf_private.device);
+ attachment = dma_buf_attach(dma_buf, hy_drv_priv->dev);
if (IS_ERR(attachment)) {
- dev_err(hyper_dmabuf_private.device, "Cannot get attachment\n");
+ dev_err(hy_drv_priv->dev, "Cannot get attachment\n");
ret = PTR_ERR(attachment);
goto fail_attach;
}
@@ -235,154 +237,165 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL);
if (IS_ERR(sgt)) {
- dev_err(hyper_dmabuf_private.device, "Cannot map attachment\n");
+ dev_err(hy_drv_priv->dev, "Cannot map attachment\n");
ret = PTR_ERR(sgt);
goto fail_map_attachment;
}
- sgt_info = kcalloc(1, sizeof(*sgt_info), GFP_KERNEL);
+ exported = kcalloc(1, sizeof(*exported), GFP_KERNEL);
- if(!sgt_info) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ if(!exported) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_sgt_info_creation;
}
/* possible truncation */
if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) {
- sgt_info->sz_priv = MAX_SIZE_PRIV_DATA;
+ exported->sz_priv = MAX_SIZE_PRIV_DATA;
} else {
- sgt_info->sz_priv = export_remote_attr->sz_priv;
+ exported->sz_priv = export_remote_attr->sz_priv;
}
/* creating buffer for private data of buffer */
- if(sgt_info->sz_priv != 0) {
- sgt_info->priv = kcalloc(1, sgt_info->sz_priv, GFP_KERNEL);
+ if(exported->sz_priv != 0) {
+ exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL);
- if(!sgt_info->priv) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ if(!exported->priv) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_priv_creation;
}
} else {
- dev_err(hyper_dmabuf_private.device, "size is 0\n");
+ dev_err(hy_drv_priv->dev, "size is 0\n");
}
- sgt_info->hid = hyper_dmabuf_get_hid();
+ exported->hid = hyper_dmabuf_get_hid();
/* no more exported dmabuf allowed */
- if(sgt_info->hid.id == -1) {
- dev_err(hyper_dmabuf_private.device,
+ if(exported->hid.id == -1) {
+ dev_err(hy_drv_priv->dev,
"exceeds allowed number of dmabuf to be exported\n");
ret = -ENOMEM;
goto fail_sgt_info_creation;
}
- /* TODO: We might need to consider using port number on event channel? */
- sgt_info->hyper_dmabuf_rdomain = export_remote_attr->remote_domain;
- sgt_info->dma_buf = dma_buf;
- sgt_info->valid = 1;
+ exported->rdomid = export_remote_attr->remote_domain;
+ exported->dma_buf = dma_buf;
+ exported->valid = true;
- sgt_info->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL);
- if (!sgt_info->active_sgts) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ exported->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL);
+ if (!exported->active_sgts) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_map_active_sgts;
}
- sgt_info->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL);
- if (!sgt_info->active_attached) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ exported->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL);
+ if (!exported->active_attached) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_map_active_attached;
}
- sgt_info->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL);
- if (!sgt_info->va_kmapped) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ exported->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL);
+ if (!exported->va_kmapped) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_map_va_kmapped;
}
- sgt_info->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL);
- if (!sgt_info->va_vmapped) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ exported->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL);
+ if (!exported->va_vmapped) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_map_va_vmapped;
}
- sgt_info->active_sgts->sgt = sgt;
- sgt_info->active_attached->attach = attachment;
- sgt_info->va_kmapped->vaddr = NULL;
- sgt_info->va_vmapped->vaddr = NULL;
+ exported->active_sgts->sgt = sgt;
+ exported->active_attached->attach = attachment;
+ exported->va_kmapped->vaddr = NULL;
+ exported->va_vmapped->vaddr = NULL;
/* initialize list of sgt, attachment and vaddr for dmabuf sync
* via shadow dma-buf
*/
- INIT_LIST_HEAD(&sgt_info->active_sgts->list);
- INIT_LIST_HEAD(&sgt_info->active_attached->list);
- INIT_LIST_HEAD(&sgt_info->va_kmapped->list);
- INIT_LIST_HEAD(&sgt_info->va_vmapped->list);
+ INIT_LIST_HEAD(&exported->active_sgts->list);
+ INIT_LIST_HEAD(&exported->active_attached->list);
+ INIT_LIST_HEAD(&exported->va_kmapped->list);
+ INIT_LIST_HEAD(&exported->va_vmapped->list);
/* copy private data to sgt_info */
- copy_from_user(sgt_info->priv, export_remote_attr->priv, sgt_info->sz_priv);
+ ret = copy_from_user(exported->priv, export_remote_attr->priv,
+ exported->sz_priv);
- page_info = hyper_dmabuf_ext_pgs(sgt);
- if (!page_info) {
- dev_err(hyper_dmabuf_private.device, "failed to construct page_info\n");
+ if (ret) {
+ dev_err(hy_drv_priv->dev,
+ "failed to load private data\n");
+ ret = -EINVAL;
goto fail_export;
}
- sgt_info->nents = page_info->nents;
+ pg_info = hyper_dmabuf_ext_pgs(sgt);
+ if (!pg_info) {
+ dev_err(hy_drv_priv->dev,
+ "failed to construct pg_info\n");
+ ret = -ENOMEM;
+ goto fail_export;
+ }
+
+ exported->nents = pg_info->nents;
/* now register it to export list */
- hyper_dmabuf_register_exported(sgt_info);
+ hyper_dmabuf_register_exported(exported);
- export_remote_attr->hid = sgt_info->hid;
+ export_remote_attr->hid = exported->hid;
- ret = hyper_dmabuf_send_export_msg(sgt_info, page_info);
+ ret = hyper_dmabuf_send_export_msg(exported, pg_info);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device, "failed to send out the export request\n");
+ dev_err(hy_drv_priv->dev,
+ "failed to send out the export request\n");
goto fail_send_request;
}
- /* free page_info */
- kfree(page_info->pages);
- kfree(page_info);
+ /* free pg_info */
+ kfree(pg_info->pgs);
+ kfree(pg_info);
- sgt_info->filp = filp;
+ exported->filp = filp;
return ret;
/* Clean-up if error occurs */
fail_send_request:
- hyper_dmabuf_remove_exported(sgt_info->hid);
+ hyper_dmabuf_remove_exported(exported->hid);
- /* free page_info */
- kfree(page_info->pages);
- kfree(page_info);
+ /* free pg_info */
+ kfree(pg_info->pgs);
+ kfree(pg_info);
fail_export:
- kfree(sgt_info->va_vmapped);
+ kfree(exported->va_vmapped);
fail_map_va_vmapped:
- kfree(sgt_info->va_kmapped);
+ kfree(exported->va_kmapped);
fail_map_va_kmapped:
- kfree(sgt_info->active_attached);
+ kfree(exported->active_attached);
fail_map_active_attached:
- kfree(sgt_info->active_sgts);
- kfree(sgt_info->priv);
+ kfree(exported->active_sgts);
+ kfree(exported->priv);
fail_priv_creation:
- kfree(sgt_info);
+ kfree(exported);
fail_map_active_sgts:
fail_sgt_info_creation:
- dma_buf_unmap_attachment(attachment, sgt, DMA_BIDIRECTIONAL);
+ dma_buf_unmap_attachment(attachment, sgt,
+ DMA_BIDIRECTIONAL);
fail_map_attachment:
dma_buf_detach(dma_buf, attachment);
@@ -395,143 +408,136 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
{
- struct ioctl_hyper_dmabuf_export_fd *export_fd_attr;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct ioctl_hyper_dmabuf_export_fd *export_fd_attr =
+ (struct ioctl_hyper_dmabuf_export_fd *)data;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
+ struct imported_sgt_info *imported;
struct hyper_dmabuf_req *req;
- struct page **data_pages;
- int operands[4];
+ struct page **data_pgs;
+ int op[4];
int i;
int ret = 0;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
-
- if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
- return -EINVAL;
- }
-
- export_fd_attr = (struct ioctl_hyper_dmabuf_export_fd *)data;
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
/* look for dmabuf for the id */
- sgt_info = hyper_dmabuf_find_imported(export_fd_attr->hid);
+ imported = hyper_dmabuf_find_imported(export_fd_attr->hid);
/* can't find sgt from the table */
- if (!sgt_info) {
- dev_err(hyper_dmabuf_private.device, "can't find the entry\n");
+ if (!imported) {
+ dev_err(hy_drv_priv->dev, "can't find the entry\n");
return -ENOENT;
}
- mutex_lock(&hyper_dmabuf_private.lock);
+ mutex_lock(&hy_drv_priv->lock);
- sgt_info->num_importers++;
+ imported->importers++;
/* send notification for export_fd to exporter */
- operands[0] = sgt_info->hid.id;
+ op[0] = imported->hid.id;
for (i=0; i<3; i++)
- operands[i+1] = sgt_info->hid.rng_key[i];
+ op[i+1] = imported->hid.rng_key[i];
- dev_dbg(hyper_dmabuf_private.device, "Exporting fd of buffer {id:%d key:%d %d %d}\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ dev_dbg(hy_drv_priv->dev, "Exporting fd of buffer {id:%d key:%d %d %d}\n",
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if (!req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
- hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD, &operands[0]);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD, &op[0]);
- ret = ops->send_req(HYPER_DMABUF_DOM_ID(sgt_info->hid), req, true);
+ ret = ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, true);
if (ret < 0) {
/* in case of timeout other end eventually will receive request, so we need to undo it */
- hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operands[0]);
- ops->send_req(operands[0], req, false);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]);
+ ops->send_req(op[0], req, false);
kfree(req);
- dev_err(hyper_dmabuf_private.device, "Failed to create sgt or notify exporter\n");
- sgt_info->num_importers--;
- mutex_unlock(&hyper_dmabuf_private.lock);
+ dev_err(hy_drv_priv->dev, "Failed to create sgt or notify exporter\n");
+ imported->importers--;
+ mutex_unlock(&hy_drv_priv->lock);
return ret;
}
kfree(req);
if (ret == HYPER_DMABUF_REQ_ERROR) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Buffer invalid {id:%d key:%d %d %d}, cannot import\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
- sgt_info->num_importers--;
- mutex_unlock(&hyper_dmabuf_private.lock);
+ imported->importers--;
+ mutex_unlock(&hy_drv_priv->lock);
return -EINVAL;
} else {
- dev_dbg(hyper_dmabuf_private.device, "Can import buffer {id:%d key:%d %d %d}\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ dev_dbg(hy_drv_priv->dev, "Can import buffer {id:%d key:%d %d %d}\n",
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
ret = 0;
}
- dev_dbg(hyper_dmabuf_private.device,
- "%s Found buffer gref %d off %d last len %d nents %d domain %d\n", __func__,
- sgt_info->ref_handle, sgt_info->frst_ofst,
- sgt_info->last_len, sgt_info->nents,
- HYPER_DMABUF_DOM_ID(sgt_info->hid));
+ dev_dbg(hy_drv_priv->dev,
+ "%s Found buffer gref %d off %d last len %d nents %d domain %d\n",
+ __func__, imported->ref_handle, imported->frst_ofst,
+ imported->last_len, imported->nents, HYPER_DMABUF_DOM_ID(imported->hid));
- if (!sgt_info->sgt) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (!imported->sgt) {
+ dev_dbg(hy_drv_priv->dev,
"%s buffer {id:%d key:%d %d %d} pages not mapped yet\n", __func__,
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
- data_pages = ops->map_shared_pages(sgt_info->ref_handle,
- HYPER_DMABUF_DOM_ID(sgt_info->hid),
- sgt_info->nents,
- &sgt_info->refs_info);
+ data_pgs = ops->map_shared_pages(imported->ref_handle,
+ HYPER_DMABUF_DOM_ID(imported->hid),
+ imported->nents,
+ &imported->refs_info);
- if (!data_pages) {
- dev_err(hyper_dmabuf_private.device,
+ if (!data_pgs) {
+ dev_err(hy_drv_priv->dev,
"Cannot map pages of buffer {id:%d key:%d %d %d}\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
- sgt_info->num_importers--;
+ imported->importers--;
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if (!req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No more space left\n");
return -ENOMEM;
}
- hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operands[0]);
- ops->send_req(HYPER_DMABUF_DOM_ID(sgt_info->hid), req, false);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]);
+ ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, false);
kfree(req);
- mutex_unlock(&hyper_dmabuf_private.lock);
+ mutex_unlock(&hy_drv_priv->lock);
return -EINVAL;
}
- sgt_info->sgt = hyper_dmabuf_create_sgt(data_pages, sgt_info->frst_ofst,
- sgt_info->last_len, sgt_info->nents);
+ imported->sgt = hyper_dmabuf_create_sgt(data_pgs, imported->frst_ofst,
+ imported->last_len, imported->nents);
}
- export_fd_attr->fd = hyper_dmabuf_export_fd(sgt_info, export_fd_attr->flags);
+ export_fd_attr->fd = hyper_dmabuf_export_fd(imported, export_fd_attr->flags);
if (export_fd_attr->fd < 0) {
/* fail to get fd */
ret = export_fd_attr->fd;
}
- mutex_unlock(&hyper_dmabuf_private.lock);
+ mutex_unlock(&hy_drv_priv->lock);
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return ret;
}
@@ -541,50 +547,51 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
{
struct hyper_dmabuf_req *req;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
+ struct exported_sgt_info *exported =
+ container_of(work, struct exported_sgt_info, unexport.work);
+ int op[4];
int i, ret;
- int operands[4];
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
- struct hyper_dmabuf_sgt_info *sgt_info =
- container_of(work, struct hyper_dmabuf_sgt_info, unexport_work.work);
- if (!sgt_info)
+ if (!exported)
return;
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Marking buffer {id:%d key:%d %d %d} as invalid\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ exported->hid.id, exported->hid.rng_key[0],
+ exported->hid.rng_key[1], exported->hid.rng_key[2]);
/* no longer valid */
- sgt_info->valid = 0;
+ exported->valid = false;
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if (!req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return;
}
- operands[0] = sgt_info->hid.id;
+ op[0] = exported->hid.id;
for (i=0; i<3; i++)
- operands[i+1] = sgt_info->hid.rng_key[i];
+ op[i+1] = exported->hid.rng_key[i];
- hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &operands[0]);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &op[0]);
- /* Now send unexport request to remote domain, marking that buffer should not be used anymore */
- ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true);
+ /* Now send unexport request to remote domain, marking
+ * that buffer should not be used anymore */
+ ret = ops->send_req(exported->rdomid, req, true);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"unexport message for buffer {id:%d key:%d %d %d} failed\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ exported->hid.id, exported->hid.rng_key[0],
+ exported->hid.rng_key[1], exported->hid.rng_key[2]);
}
/* free msg */
kfree(req);
- sgt_info->unexport_scheduled = 0;
+ exported->unexport_sched = false;
/*
* Immediately clean-up if it has never been exported by importer
@@ -593,104 +600,94 @@ static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
* is called (importer does this only when there's no
* no consumer of locally exported FDs)
*/
- if (!sgt_info->importer_exported) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (exported->active == 0) {
+ dev_dbg(hy_drv_priv->dev,
"claning up buffer {id:%d key:%d %d %d} completly\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ exported->hid.id, exported->hid.rng_key[0],
+ exported->hid.rng_key[1], exported->hid.rng_key[2]);
+
+ hyper_dmabuf_cleanup_sgt_info(exported, false);
+ hyper_dmabuf_remove_exported(exported->hid);
- hyper_dmabuf_cleanup_sgt_info(sgt_info, false);
- hyper_dmabuf_remove_exported(sgt_info->hid);
/* register hyper_dmabuf_id to the list for reuse */
- store_reusable_hid(sgt_info->hid);
+ store_reusable_hid(exported->hid);
- if (sgt_info->sz_priv > 0 && !sgt_info->priv)
- kfree(sgt_info->priv);
+ if (exported->sz_priv > 0 && !exported->priv)
+ kfree(exported->priv);
- kfree(sgt_info);
+ kfree(exported);
}
}
-/* Schedules unexport of dmabuf.
+/* Schedule unexport of dmabuf.
*/
-static int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data)
+int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data)
{
- struct ioctl_hyper_dmabuf_unexport *unexport_attr;
- struct hyper_dmabuf_sgt_info *sgt_info;
+ struct ioctl_hyper_dmabuf_unexport *unexport_attr =
+ (struct ioctl_hyper_dmabuf_unexport *)data;
+ struct exported_sgt_info *exported;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
-
- if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
- return -EINVAL;
- }
-
- unexport_attr = (struct ioctl_hyper_dmabuf_unexport *)data;
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
/* find dmabuf in export list */
- sgt_info = hyper_dmabuf_find_exported(unexport_attr->hid);
+ exported = hyper_dmabuf_find_exported(unexport_attr->hid);
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"scheduling unexport of buffer {id:%d key:%d %d %d}\n",
unexport_attr->hid.id, unexport_attr->hid.rng_key[0],
unexport_attr->hid.rng_key[1], unexport_attr->hid.rng_key[2]);
/* failed to find corresponding entry in export list */
- if (sgt_info == NULL) {
+ if (exported == NULL) {
unexport_attr->status = -ENOENT;
return -ENOENT;
}
- if (sgt_info->unexport_scheduled)
+ if (exported->unexport_sched)
return 0;
- sgt_info->unexport_scheduled = 1;
- INIT_DELAYED_WORK(&sgt_info->unexport_work, hyper_dmabuf_delayed_unexport);
- schedule_delayed_work(&sgt_info->unexport_work,
+ exported->unexport_sched = true;
+ INIT_DELAYED_WORK(&exported->unexport,
+ hyper_dmabuf_delayed_unexport);
+ schedule_delayed_work(&exported->unexport,
msecs_to_jiffies(unexport_attr->delay_ms));
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return 0;
}
static int hyper_dmabuf_query_ioctl(struct file *filp, void *data)
{
- struct ioctl_hyper_dmabuf_query *query_attr;
- struct hyper_dmabuf_sgt_info *sgt_info = NULL;
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info = NULL;
+ struct ioctl_hyper_dmabuf_query *query_attr =
+ (struct ioctl_hyper_dmabuf_query *)data;
+ struct exported_sgt_info *exported = NULL;
+ struct imported_sgt_info *imported = NULL;
int ret = 0;
- if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
- return -EINVAL;
- }
-
- query_attr = (struct ioctl_hyper_dmabuf_query *)data;
-
- if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hyper_dmabuf_private.domid) {
+ if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hy_drv_priv->domid) {
/* query for exported dmabuf */
- sgt_info = hyper_dmabuf_find_exported(query_attr->hid);
- if (sgt_info) {
- ret = hyper_dmabuf_query_exported(sgt_info,
+ exported = hyper_dmabuf_find_exported(query_attr->hid);
+ if (exported) {
+ ret = hyper_dmabuf_query_exported(exported,
query_attr->item, &query_attr->info);
} else {
- dev_err(hyper_dmabuf_private.device,
- "DMA BUF {id:%d key:%d %d %d} can't be found in the export list\n",
- query_attr->hid.id, query_attr->hid.rng_key[0], query_attr->hid.rng_key[1],
- query_attr->hid.rng_key[2]);
+ dev_err(hy_drv_priv->dev,
+ "DMA BUF {id:%d key:%d %d %d} not in the export list\n",
+ query_attr->hid.id, query_attr->hid.rng_key[0],
+ query_attr->hid.rng_key[1], query_attr->hid.rng_key[2]);
return -ENOENT;
}
} else {
/* query for imported dmabuf */
- imported_sgt_info = hyper_dmabuf_find_imported(query_attr->hid);
- if (imported_sgt_info) {
- ret = hyper_dmabuf_query_imported(imported_sgt_info,
- query_attr->item, &query_attr->info);
+ imported = hyper_dmabuf_find_imported(query_attr->hid);
+ if (imported) {
+ ret = hyper_dmabuf_query_imported(imported, query_attr->item,
+ &query_attr->info);
} else {
- dev_err(hyper_dmabuf_private.device,
- "DMA BUF {id:%d key:%d %d %d} can't be found in the imported list\n",
- query_attr->hid.id, query_attr->hid.rng_key[0], query_attr->hid.rng_key[1],
- query_attr->hid.rng_key[2]);
+ dev_err(hy_drv_priv->dev,
+ "DMA BUF {id:%d key:%d %d %d} not in the imported list\n",
+ query_attr->hid.id, query_attr->hid.rng_key[0],
+ query_attr->hid.rng_key[1], query_attr->hid.rng_key[2]);
return -ENOENT;
}
}
@@ -698,28 +695,6 @@ static int hyper_dmabuf_query_ioctl(struct file *filp, void *data)
return ret;
}
-void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* sgt_info,
- void *attr)
-{
- struct ioctl_hyper_dmabuf_unexport unexport_attr;
- struct file *filp = (struct file*) attr;
-
- if (!filp || !sgt_info)
- return;
-
- if (sgt_info->filp == filp) {
- dev_dbg(hyper_dmabuf_private.device,
- "Executing emergency release of buffer {id:%d key:%d %d %d}\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0],
- sgt_info->hid.rng_key[1], sgt_info->hid.rng_key[2]);
-
- unexport_attr.hid = sgt_info->hid;
- unexport_attr.delay_ms = 0;
-
- hyper_dmabuf_unexport_ioctl(filp, &unexport_attr);
- }
-}
-
const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = {
HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_TX_CH_SETUP, hyper_dmabuf_tx_ch_setup_ioctl, 0),
HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_RX_CH_SETUP, hyper_dmabuf_rx_ch_setup_ioctl, 0),
@@ -739,7 +714,7 @@ long hyper_dmabuf_ioctl(struct file *filp,
char *kdata;
if (nr > ARRAY_SIZE(hyper_dmabuf_ioctls)) {
- dev_err(hyper_dmabuf_private.device, "invalid ioctl\n");
+ dev_err(hy_drv_priv->dev, "invalid ioctl\n");
return -EINVAL;
}
@@ -748,18 +723,18 @@ long hyper_dmabuf_ioctl(struct file *filp,
func = ioctl->func;
if (unlikely(!func)) {
- dev_err(hyper_dmabuf_private.device, "no function\n");
+ dev_err(hy_drv_priv->dev, "no function\n");
return -EINVAL;
}
kdata = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
if (!kdata) {
- dev_err(hyper_dmabuf_private.device, "no memory\n");
+ dev_err(hy_drv_priv->dev, "no memory\n");
return -ENOMEM;
}
if (copy_from_user(kdata, (void __user *)param, _IOC_SIZE(cmd)) != 0) {
- dev_err(hyper_dmabuf_private.device, "failed to copy from user arguments\n");
+ dev_err(hy_drv_priv->dev, "failed to copy from user arguments\n");
ret = -EFAULT;
goto ioctl_error;
}
@@ -767,7 +742,7 @@ long hyper_dmabuf_ioctl(struct file *filp,
ret = func(filp, kdata);
if (copy_to_user((void __user *)param, kdata, _IOC_SIZE(cmd)) != 0) {
- dev_err(hyper_dmabuf_private.device, "failed to copy to user arguments\n");
+ dev_err(hy_drv_priv->dev, "failed to copy to user arguments\n");
ret = -EFAULT;
goto ioctl_error;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
index ebfbb84..3e9470a 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
@@ -42,4 +42,6 @@ struct hyper_dmabuf_ioctl_desc {
.name = #ioctl \
}
+int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data);
+
#endif //__HYPER_DMABUF_IOCTL_H__
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
index eaef2c1..1b3745e 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
@@ -39,24 +39,22 @@
#include "hyper_dmabuf_id.h"
#include "hyper_dmabuf_event.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
DECLARE_HASHTABLE(hyper_dmabuf_hash_imported, MAX_ENTRY_IMPORTED);
DECLARE_HASHTABLE(hyper_dmabuf_hash_exported, MAX_ENTRY_EXPORTED);
#ifdef CONFIG_HYPER_DMABUF_SYSFS
static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attribute *attr, char *buf)
{
- struct hyper_dmabuf_info_entry_imported *info_entry;
+ struct list_entry_imported *info_entry;
int bkt;
ssize_t count = 0;
size_t total = 0;
hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node) {
- hyper_dmabuf_id_t hid = info_entry->info->hid;
- int nents = info_entry->info->nents;
- bool valid = info_entry->info->valid;
- int num_importers = info_entry->info->num_importers;
+ hyper_dmabuf_id_t hid = info_entry->imported->hid;
+ int nents = info_entry->imported->nents;
+ bool valid = info_entry->imported->valid;
+ int num_importers = info_entry->imported->importers;
total += nents;
count += scnprintf(buf + count, PAGE_SIZE - count,
"hid:{id:%d keys:%d %d %d}, nents:%d, v:%c, numi:%d\n",
@@ -71,16 +69,16 @@ static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attr
static ssize_t hyper_dmabuf_exported_show(struct device *drv, struct device_attribute *attr, char *buf)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
int bkt;
ssize_t count = 0;
size_t total = 0;
hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node) {
- hyper_dmabuf_id_t hid = info_entry->info->hid;
- int nents = info_entry->info->nents;
- bool valid = info_entry->info->valid;
- int importer_exported = info_entry->info->importer_exported;
+ hyper_dmabuf_id_t hid = info_entry->exported->hid;
+ int nents = info_entry->exported->nents;
+ bool valid = info_entry->exported->valid;
+ int importer_exported = info_entry->exported->active;
total += nents;
count += scnprintf(buf + count, PAGE_SIZE - count,
"hid:{hid:%d keys:%d %d %d}, nents:%d, v:%c, ie:%d\n",
@@ -135,57 +133,57 @@ int hyper_dmabuf_table_destroy()
return 0;
}
-int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info)
+int hyper_dmabuf_register_exported(struct exported_sgt_info *exported)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
if (!info_entry) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
- info_entry->info = info;
+ info_entry->exported = exported;
hash_add(hyper_dmabuf_hash_exported, &info_entry->node,
- info_entry->info->hid.id);
+ info_entry->exported->hid.id);
return 0;
}
-int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info)
+int hyper_dmabuf_register_imported(struct imported_sgt_info* imported)
{
- struct hyper_dmabuf_info_entry_imported *info_entry;
+ struct list_entry_imported *info_entry;
info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
if (!info_entry) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
- info_entry->info = info;
+ info_entry->imported = imported;
hash_add(hyper_dmabuf_hash_imported, &info_entry->node,
- info_entry->info->hid.id);
+ info_entry->imported->hid.id);
return 0;
}
-struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
+struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
int bkt;
hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
/* checking hid.id first */
- if(info_entry->info->hid.id == hid.id) {
+ if(info_entry->exported->hid.id == hid.id) {
/* then key is compared */
- if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid))
- return info_entry->info;
+ if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid))
+ return info_entry->exported;
/* if key is unmatched, given HID is invalid, so returning NULL */
else
break;
@@ -197,29 +195,29 @@ struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
/* search for pre-exported sgt and return id of it if it exist */
hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
hyper_dmabuf_id_t hid = {-1, {0, 0, 0}};
int bkt;
hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
- if(info_entry->info->dma_buf == dmabuf &&
- info_entry->info->hyper_dmabuf_rdomain == domid)
- return info_entry->info->hid;
+ if(info_entry->exported->dma_buf == dmabuf &&
+ info_entry->exported->rdomid == domid)
+ return info_entry->exported->hid;
return hid;
}
-struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid)
+struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid)
{
- struct hyper_dmabuf_info_entry_imported *info_entry;
+ struct list_entry_imported *info_entry;
int bkt;
hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node)
/* checking hid.id first */
- if(info_entry->info->hid.id == hid.id) {
+ if(info_entry->imported->hid.id == hid.id) {
/* then key is compared */
- if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid))
- return info_entry->info;
+ if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid))
+ return info_entry->imported;
/* if key is unmatched, given HID is invalid, so returning NULL */
else {
break;
@@ -231,14 +229,14 @@ struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_i
int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
int bkt;
hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
/* checking hid.id first */
- if(info_entry->info->hid.id == hid.id) {
+ if(info_entry->exported->hid.id == hid.id) {
/* then key is compared */
- if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) {
+ if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid)) {
hash_del(&info_entry->node);
kfree(info_entry);
return 0;
@@ -252,14 +250,14 @@ int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid)
int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid)
{
- struct hyper_dmabuf_info_entry_imported *info_entry;
+ struct list_entry_imported *info_entry;
int bkt;
hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node)
/* checking hid.id first */
- if(info_entry->info->hid.id == hid.id) {
+ if(info_entry->imported->hid.id == hid.id) {
/* then key is compared */
- if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) {
+ if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid)) {
hash_del(&info_entry->node);
kfree(info_entry);
return 0;
@@ -272,15 +270,15 @@ int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid)
}
void hyper_dmabuf_foreach_exported(
- void (*func)(struct hyper_dmabuf_sgt_info *, void *attr),
+ void (*func)(struct exported_sgt_info *, void *attr),
void *attr)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
struct hlist_node *tmp;
int bkt;
hash_for_each_safe(hyper_dmabuf_hash_exported, bkt, tmp,
info_entry, node) {
- func(info_entry->info, attr);
+ func(info_entry->exported, attr);
}
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
index 8f64db8..d5c17ef 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
@@ -32,13 +32,13 @@
/* number of bits to be used for imported dmabufs hash table */
#define MAX_ENTRY_IMPORTED 7
-struct hyper_dmabuf_info_entry_exported {
- struct hyper_dmabuf_sgt_info *info;
+struct list_entry_exported {
+ struct exported_sgt_info *exported;
struct hlist_node node;
};
-struct hyper_dmabuf_info_entry_imported {
- struct hyper_dmabuf_imported_sgt_info *info;
+struct list_entry_imported {
+ struct imported_sgt_info *imported;
struct hlist_node node;
};
@@ -46,23 +46,23 @@ int hyper_dmabuf_table_init(void);
int hyper_dmabuf_table_destroy(void);
-int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info);
+int hyper_dmabuf_register_exported(struct exported_sgt_info *info);
/* search for pre-exported sgt and return id of it if it exist */
hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid);
-int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info);
+int hyper_dmabuf_register_imported(struct imported_sgt_info* info);
-struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid);
+struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid);
-struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid);
+struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid);
int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid);
int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid);
void hyper_dmabuf_foreach_exported(
- void (*func)(struct hyper_dmabuf_sgt_info *, void *attr),
+ void (*func)(struct exported_sgt_info *, void *attr),
void *attr);
int hyper_dmabuf_register_sysfs(struct device *dev);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
index ec37c3b..907f76e 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
@@ -31,7 +31,6 @@
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/dma-buf.h>
-#include <xen/grant_table.h>
#include <linux/workqueue.h>
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_drv.h"
@@ -39,58 +38,56 @@
#include "hyper_dmabuf_event.h"
#include "hyper_dmabuf_list.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
struct cmd_process {
struct work_struct work;
struct hyper_dmabuf_req *rq;
int domid;
};
-void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
- enum hyper_dmabuf_command command, int *operands)
+void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
+ enum hyper_dmabuf_command cmd, int *op)
{
int i;
- req->status = HYPER_DMABUF_REQ_NOT_RESPONDED;
- req->command = command;
+ req->stat = HYPER_DMABUF_REQ_NOT_RESPONDED;
+ req->cmd = cmd;
- switch(command) {
+ switch(cmd) {
/* as exporter, commands to importer */
case HYPER_DMABUF_EXPORT:
/* exporting pages for dmabuf */
/* command : HYPER_DMABUF_EXPORT,
- * operands0~3 : hyper_dmabuf_id
- * operands4 : number of pages to be shared
- * operands5 : offset of data in the first page
- * operands6 : length of data in the last page
- * operands7 : top-level reference number for shared pages
- * operands8 : size of private data (from operands9)
- * operands9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
+ * op0~3 : hyper_dmabuf_id
+ * op4 : number of pages to be shared
+ * op5 : offset of data in the first page
+ * op6 : length of data in the last page
+ * op7 : top-level reference number for shared pages
+ * op8 : size of private data (from op9)
+ * op9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
*/
- memcpy(&req->operands[0], &operands[0], 9 * sizeof(int) + operands[8]);
+ memcpy(&req->op[0], &op[0], 9 * sizeof(int) + op[8]);
break;
case HYPER_DMABUF_NOTIFY_UNEXPORT:
/* destroy sg_list for hyper_dmabuf_id on remote side */
/* command : DMABUF_DESTROY,
- * operands0~3 : hyper_dmabuf_id_t hid
+ * op0~3 : hyper_dmabuf_id_t hid
*/
for (i=0; i < 4; i++)
- req->operands[i] = operands[i];
+ req->op[i] = op[i];
break;
case HYPER_DMABUF_EXPORT_FD:
case HYPER_DMABUF_EXPORT_FD_FAILED:
/* dmabuf fd is being created on imported side or importing failed */
/* command : HYPER_DMABUF_EXPORT_FD or HYPER_DMABUF_EXPORT_FD_FAILED,
- * operands0~3 : hyper_dmabuf_id
+ * op0~3 : hyper_dmabuf_id
*/
for (i=0; i < 4; i++)
- req->operands[i] = operands[i];
+ req->op[i] = op[i];
break;
case HYPER_DMABUF_OPS_TO_REMOTE:
@@ -103,11 +100,11 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
/* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping
* or unmapping for synchronization with original exporter (e.g. i915) */
/* command : DMABUF_OPS_TO_SOURCE.
- * operands0~3 : hyper_dmabuf_id
- * operands4 : map(=1)/unmap(=2)/attach(=3)/detach(=4)
+ * op0~3 : hyper_dmabuf_id
+ * op4 : map(=1)/unmap(=2)/attach(=3)/detach(=4)
*/
for (i = 0; i < 5; i++)
- req->operands[i] = operands[i];
+ req->op[i] = op[i];
break;
default:
@@ -116,9 +113,9 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
}
}
-void cmd_process_work(struct work_struct *work)
+static void cmd_process_work(struct work_struct *work)
{
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
+ struct imported_sgt_info *imported;
struct cmd_process *proc = container_of(work, struct cmd_process, work);
struct hyper_dmabuf_req *req;
int domid;
@@ -127,107 +124,107 @@ void cmd_process_work(struct work_struct *work)
req = proc->rq;
domid = proc->domid;
- switch (req->command) {
+ switch (req->cmd) {
case HYPER_DMABUF_EXPORT:
/* exporting pages for dmabuf */
/* command : HYPER_DMABUF_EXPORT,
- * operands0~3 : hyper_dmabuf_id
- * operands4 : number of pages to be shared
- * operands5 : offset of data in the first page
- * operands6 : length of data in the last page
- * operands7 : top-level reference number for shared pages
- * operands8 : size of private data (from operands9)
- * operands9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
+ * op0~3 : hyper_dmabuf_id
+ * op4 : number of pages to be shared
+ * op5 : offset of data in the first page
+ * op6 : length of data in the last page
+ * op7 : top-level reference number for shared pages
+ * op8 : size of private data (from op9)
+ * op9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
*/
/* if nents == 0, it means it is a message only for priv synchronization
* for existing imported_sgt_info so not creating a new one */
- if (req->operands[4] == 0) {
- hyper_dmabuf_id_t exist = {req->operands[0],
- {req->operands[1], req->operands[2],
- req->operands[3]}};
+ if (req->op[4] == 0) {
+ hyper_dmabuf_id_t exist = {req->op[0],
+ {req->op[1], req->op[2],
+ req->op[3]}};
- imported_sgt_info = hyper_dmabuf_find_imported(exist);
+ imported = hyper_dmabuf_find_imported(exist);
- if (!imported_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!imported) {
+ dev_err(hy_drv_priv->dev,
"Can't find imported sgt_info from IMPORT_LIST\n");
break;
}
/* if size of new private data is different,
* we reallocate it. */
- if (imported_sgt_info->sz_priv != req->operands[8]) {
- kfree(imported_sgt_info->priv);
- imported_sgt_info->sz_priv = req->operands[8];
- imported_sgt_info->priv = kcalloc(1, req->operands[8], GFP_KERNEL);
- if (!imported_sgt_info->priv) {
- dev_err(hyper_dmabuf_private.device,
+ if (imported->sz_priv != req->op[8]) {
+ kfree(imported->priv);
+ imported->sz_priv = req->op[8];
+ imported->priv = kcalloc(1, req->op[8], GFP_KERNEL);
+ if (!imported->priv) {
+ dev_err(hy_drv_priv->dev,
"Fail to allocate priv\n");
/* set it invalid */
- imported_sgt_info->valid = 0;
+ imported->valid = 0;
break;
}
}
/* updating priv data */
- memcpy(imported_sgt_info->priv, &req->operands[9], req->operands[8]);
+ memcpy(imported->priv, &req->op[9], req->op[8]);
#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
/* generating import event */
- hyper_dmabuf_import_event(imported_sgt_info->hid);
+ hyper_dmabuf_import_event(imported->hid);
#endif
break;
}
- imported_sgt_info = kcalloc(1, sizeof(*imported_sgt_info), GFP_KERNEL);
+ imported = kcalloc(1, sizeof(*imported), GFP_KERNEL);
- if (!imported_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!imported) {
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
break;
}
- imported_sgt_info->sz_priv = req->operands[8];
- imported_sgt_info->priv = kcalloc(1, req->operands[8], GFP_KERNEL);
+ imported->sz_priv = req->op[8];
+ imported->priv = kcalloc(1, req->op[8], GFP_KERNEL);
- if (!imported_sgt_info->priv) {
- dev_err(hyper_dmabuf_private.device,
+ if (!imported->priv) {
+ dev_err(hy_drv_priv->dev,
"Fail to allocate priv\n");
- kfree(imported_sgt_info);
+ kfree(imported);
break;
}
- imported_sgt_info->hid.id = req->operands[0];
+ imported->hid.id = req->op[0];
for (i=0; i<3; i++)
- imported_sgt_info->hid.rng_key[i] = req->operands[i+1];
+ imported->hid.rng_key[i] = req->op[i+1];
- imported_sgt_info->nents = req->operands[4];
- imported_sgt_info->frst_ofst = req->operands[5];
- imported_sgt_info->last_len = req->operands[6];
- imported_sgt_info->ref_handle = req->operands[7];
+ imported->nents = req->op[4];
+ imported->frst_ofst = req->op[5];
+ imported->last_len = req->op[6];
+ imported->ref_handle = req->op[7];
- dev_dbg(hyper_dmabuf_private.device, "DMABUF was exported\n");
- dev_dbg(hyper_dmabuf_private.device, "\thid{id:%d key:%d %d %d}\n",
- req->operands[0], req->operands[1], req->operands[2],
- req->operands[3]);
- dev_dbg(hyper_dmabuf_private.device, "\tnents %d\n", req->operands[4]);
- dev_dbg(hyper_dmabuf_private.device, "\tfirst offset %d\n", req->operands[5]);
- dev_dbg(hyper_dmabuf_private.device, "\tlast len %d\n", req->operands[6]);
- dev_dbg(hyper_dmabuf_private.device, "\tgrefid %d\n", req->operands[7]);
+ dev_dbg(hy_drv_priv->dev, "DMABUF was exported\n");
+ dev_dbg(hy_drv_priv->dev, "\thid{id:%d key:%d %d %d}\n",
+ req->op[0], req->op[1], req->op[2],
+ req->op[3]);
+ dev_dbg(hy_drv_priv->dev, "\tnents %d\n", req->op[4]);
+ dev_dbg(hy_drv_priv->dev, "\tfirst offset %d\n", req->op[5]);
+ dev_dbg(hy_drv_priv->dev, "\tlast len %d\n", req->op[6]);
+ dev_dbg(hy_drv_priv->dev, "\tgrefid %d\n", req->op[7]);
- memcpy(imported_sgt_info->priv, &req->operands[9], req->operands[8]);
+ memcpy(imported->priv, &req->op[9], req->op[8]);
- imported_sgt_info->valid = 1;
- hyper_dmabuf_register_imported(imported_sgt_info);
+ imported->valid = true;
+ hyper_dmabuf_register_imported(imported);
#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
/* generating import event */
- hyper_dmabuf_import_event(imported_sgt_info->hid);
+ hyper_dmabuf_import_event(imported->hid);
#endif
break;
@@ -251,142 +248,142 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
{
struct cmd_process *proc;
struct hyper_dmabuf_req *temp_req;
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
- struct hyper_dmabuf_sgt_info *exp_sgt_info;
+ struct imported_sgt_info *imported;
+ struct exported_sgt_info *exported;
hyper_dmabuf_id_t hid;
int ret;
if (!req) {
- dev_err(hyper_dmabuf_private.device, "request is NULL\n");
+ dev_err(hy_drv_priv->dev, "request is NULL\n");
return -EINVAL;
}
- hid.id = req->operands[0];
- hid.rng_key[0] = req->operands[1];
- hid.rng_key[1] = req->operands[2];
- hid.rng_key[2] = req->operands[3];
+ hid.id = req->op[0];
+ hid.rng_key[0] = req->op[1];
+ hid.rng_key[1] = req->op[2];
+ hid.rng_key[2] = req->op[3];
- if ((req->command < HYPER_DMABUF_EXPORT) ||
- (req->command > HYPER_DMABUF_OPS_TO_SOURCE)) {
- dev_err(hyper_dmabuf_private.device, "invalid command\n");
+ if ((req->cmd < HYPER_DMABUF_EXPORT) ||
+ (req->cmd > HYPER_DMABUF_OPS_TO_SOURCE)) {
+ dev_err(hy_drv_priv->dev, "invalid command\n");
return -EINVAL;
}
- req->status = HYPER_DMABUF_REQ_PROCESSED;
+ req->stat = HYPER_DMABUF_REQ_PROCESSED;
/* HYPER_DMABUF_DESTROY requires immediate
* follow up so can't be processed in workqueue
*/
- if (req->command == HYPER_DMABUF_NOTIFY_UNEXPORT) {
+ if (req->cmd == HYPER_DMABUF_NOTIFY_UNEXPORT) {
/* destroy sg_list for hyper_dmabuf_id on remote side */
/* command : HYPER_DMABUF_NOTIFY_UNEXPORT,
- * operands0~3 : hyper_dmabuf_id
+ * op0~3 : hyper_dmabuf_id
*/
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: processing HYPER_DMABUF_NOTIFY_UNEXPORT\n", __func__);
- sgt_info = hyper_dmabuf_find_imported(hid);
+ imported = hyper_dmabuf_find_imported(hid);
- if (sgt_info) {
+ if (imported) {
/* if anything is still using dma_buf */
- if (sgt_info->num_importers) {
+ if (imported->importers) {
/*
* Buffer is still in use, just mark that it should
* not be allowed to export its fd anymore.
*/
- sgt_info->valid = 0;
+ imported->valid = false;
} else {
/* No one is using buffer, remove it from imported list */
hyper_dmabuf_remove_imported(hid);
- kfree(sgt_info);
+ kfree(imported);
}
} else {
- req->status = HYPER_DMABUF_REQ_ERROR;
+ req->stat = HYPER_DMABUF_REQ_ERROR;
}
- return req->command;
+ return req->cmd;
}
/* dma buf remote synchronization */
- if (req->command == HYPER_DMABUF_OPS_TO_SOURCE) {
+ if (req->cmd == HYPER_DMABUF_OPS_TO_SOURCE) {
/* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping
* or unmapping for synchronization with original exporter (e.g. i915) */
/* command : DMABUF_OPS_TO_SOURCE.
- * operands0~3 : hyper_dmabuf_id
- * operands1 : enum hyper_dmabuf_ops {....}
+ * op0~3 : hyper_dmabuf_id
+ * op1 : enum hyper_dmabuf_ops {....}
*/
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: HYPER_DMABUF_OPS_TO_SOURCE\n", __func__);
- ret = hyper_dmabuf_remote_sync(hid, req->operands[4]);
+ ret = hyper_dmabuf_remote_sync(hid, req->op[4]);
if (ret)
- req->status = HYPER_DMABUF_REQ_ERROR;
+ req->stat = HYPER_DMABUF_REQ_ERROR;
else
- req->status = HYPER_DMABUF_REQ_PROCESSED;
+ req->stat = HYPER_DMABUF_REQ_PROCESSED;
- return req->command;
+ return req->cmd;
}
/* synchronous dma_buf_fd export */
- if (req->command == HYPER_DMABUF_EXPORT_FD) {
+ if (req->cmd == HYPER_DMABUF_EXPORT_FD) {
/* find a corresponding SGT for the id */
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Processing HYPER_DMABUF_EXPORT_FD for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- exp_sgt_info = hyper_dmabuf_find_exported(hid);
+ exported = hyper_dmabuf_find_exported(hid);
- if (!exp_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!exported) {
+ dev_err(hy_drv_priv->dev,
"critical err: requested sgt_info can't be found for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- req->status = HYPER_DMABUF_REQ_ERROR;
- } else if (!exp_sgt_info->valid) {
- dev_dbg(hyper_dmabuf_private.device,
+ req->stat = HYPER_DMABUF_REQ_ERROR;
+ } else if (!exported->valid) {
+ dev_dbg(hy_drv_priv->dev,
"Buffer no longer valid - cannot export fd for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- req->status = HYPER_DMABUF_REQ_ERROR;
+ req->stat = HYPER_DMABUF_REQ_ERROR;
} else {
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Buffer still valid - can export fd for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- exp_sgt_info->importer_exported++;
- req->status = HYPER_DMABUF_REQ_PROCESSED;
+ exported->active++;
+ req->stat = HYPER_DMABUF_REQ_PROCESSED;
}
- return req->command;
+ return req->cmd;
}
- if (req->command == HYPER_DMABUF_EXPORT_FD_FAILED) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (req->cmd == HYPER_DMABUF_EXPORT_FD_FAILED) {
+ dev_dbg(hy_drv_priv->dev,
"Processing HYPER_DMABUF_EXPORT_FD_FAILED for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- exp_sgt_info = hyper_dmabuf_find_exported(hid);
+ exported = hyper_dmabuf_find_exported(hid);
- if (!exp_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!exported) {
+ dev_err(hy_drv_priv->dev,
"critical err: requested sgt_info can't be found for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- req->status = HYPER_DMABUF_REQ_ERROR;
+ req->stat = HYPER_DMABUF_REQ_ERROR;
} else {
- exp_sgt_info->importer_exported--;
- req->status = HYPER_DMABUF_REQ_PROCESSED;
+ exported->active--;
+ req->stat = HYPER_DMABUF_REQ_PROCESSED;
}
- return req->command;
+ return req->cmd;
}
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: putting request to workqueue\n", __func__);
temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL);
if (!temp_req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
@@ -396,7 +393,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
proc = kcalloc(1, sizeof(struct cmd_process), GFP_KERNEL);
if (!proc) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
kfree(temp_req);
return -ENOMEM;
@@ -407,7 +404,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
INIT_WORK(&(proc->work), cmd_process_work);
- queue_work(hyper_dmabuf_private.work_queue, &(proc->work));
+ queue_work(hy_drv_priv->work_queue, &(proc->work));
- return req->command;
+ return req->cmd;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
index 0f6e795..7c694ec 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
@@ -28,17 +28,17 @@
#define MAX_NUMBER_OF_OPERANDS 64
struct hyper_dmabuf_req {
- unsigned int request_id;
- unsigned int status;
- unsigned int command;
- unsigned int operands[MAX_NUMBER_OF_OPERANDS];
+ unsigned int req_id;
+ unsigned int stat;
+ unsigned int cmd;
+ unsigned int op[MAX_NUMBER_OF_OPERANDS];
};
struct hyper_dmabuf_resp {
- unsigned int response_id;
- unsigned int status;
- unsigned int command;
- unsigned int operands[MAX_NUMBER_OF_OPERANDS];
+ unsigned int resp_id;
+ unsigned int stat;
+ unsigned int cmd;
+ unsigned int op[MAX_NUMBER_OF_OPERANDS];
};
enum hyper_dmabuf_command {
@@ -75,7 +75,7 @@ enum hyper_dmabuf_req_feedback {
};
/* create a request packet with given command and operands */
-void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
+void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
enum hyper_dmabuf_command command,
int *operands);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
index 9313c42..7e73170 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
@@ -32,8 +32,6 @@
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/dma-buf.h>
-#include <xen/grant_table.h>
-#include <asm/xen/page.h>
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_ops.h"
@@ -45,122 +43,111 @@
#define WAIT_AFTER_SYNC_REQ 0
#define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
-inline int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
+static int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
{
struct hyper_dmabuf_req *req;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
- int operands[5];
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
+ int op[5];
int i;
int ret;
- operands[0] = hid.id;
+ op[0] = hid.id;
for (i=0; i<3; i++)
- operands[i+1] = hid.rng_key[i];
+ op[i+1] = hid.rng_key[i];
- operands[4] = dmabuf_ops;
+ op[4] = dmabuf_ops;
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if (!req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
- hyper_dmabuf_create_request(req, HYPER_DMABUF_OPS_TO_SOURCE, &operands[0]);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_OPS_TO_SOURCE, &op[0]);
/* send request and wait for a response */
ret = ops->send_req(HYPER_DMABUF_DOM_ID(hid), req, WAIT_AFTER_SYNC_REQ);
+ if (ret < 0) {
+ dev_dbg(hy_drv_priv->dev,
+ "dmabuf sync request failed:%d\n", req->op[4]);
+ }
+
kfree(req);
return ret;
}
-static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf, struct device* dev,
- struct dma_buf_attachment *attach)
+static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf,
+ struct device* dev,
+ struct dma_buf_attachment *attach)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!attach->dmabuf->priv)
return -EINVAL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv;
+ imported = (struct imported_sgt_info *)attach->dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_ATTACH);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- return ret;
- }
-
- return 0;
+ return ret;
}
-static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf, struct dma_buf_attachment *attach)
+static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf,
+ struct dma_buf_attachment *attach)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!attach->dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv;
+ imported = (struct imported_sgt_info *)attach->dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_DETACH);
-
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachment,
- enum dma_data_direction dir)
+ enum dma_data_direction dir)
{
struct sg_table *st;
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
- struct hyper_dmabuf_pages_info *page_info;
+ struct imported_sgt_info *imported;
+ struct pages_info *pg_info;
int ret;
if (!attachment->dmabuf->priv)
return NULL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attachment->dmabuf->priv;
+ imported = (struct imported_sgt_info *)attachment->dmabuf->priv;
/* extract pages from sgt */
- page_info = hyper_dmabuf_ext_pgs(sgt_info->sgt);
+ pg_info = hyper_dmabuf_ext_pgs(imported->sgt);
- if (!page_info) {
+ if (!pg_info) {
return NULL;
}
/* create a new sg_table with extracted pages */
- st = hyper_dmabuf_create_sgt(page_info->pages, page_info->frst_ofst,
- page_info->last_len, page_info->nents);
+ st = hyper_dmabuf_create_sgt(pg_info->pgs, pg_info->frst_ofst,
+ pg_info->last_len, pg_info->nents);
if (!st)
goto err_free_sg;
if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir))
goto err_free_sg;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_MAP);
- kfree(page_info->pages);
- kfree(page_info);
-
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
+ kfree(pg_info->pgs);
+ kfree(pg_info);
return st;
@@ -170,8 +157,8 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme
kfree(st);
}
- kfree(page_info->pages);
- kfree(page_info);
+ kfree(pg_info->pgs);
+ kfree(pg_info);
return NULL;
}
@@ -180,294 +167,251 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment,
struct sg_table *sg,
enum dma_data_direction dir)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!attachment->dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attachment->dmabuf->priv;
+ imported = (struct imported_sgt_info *)attachment->dmabuf->priv;
dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
sg_free_table(sg);
kfree(sg);
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_UNMAP);
-
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct imported_sgt_info *imported;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
int ret;
- int final_release;
+ int finish;
if (!dma_buf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dma_buf->priv;
+ imported = (struct imported_sgt_info *)dma_buf->priv;
- if (!dmabuf_refcount(sgt_info->dma_buf)) {
- sgt_info->dma_buf = NULL;
+ if (!dmabuf_refcount(imported->dma_buf)) {
+ imported->dma_buf = NULL;
}
- sgt_info->num_importers--;
+ imported->importers--;
- if (sgt_info->num_importers == 0) {
- ops->unmap_shared_pages(&sgt_info->refs_info, sgt_info->nents);
+ if (imported->importers == 0) {
+ ops->unmap_shared_pages(&imported->refs_info, imported->nents);
- if (sgt_info->sgt) {
- sg_free_table(sgt_info->sgt);
- kfree(sgt_info->sgt);
- sgt_info->sgt = NULL;
+ if (imported->sgt) {
+ sg_free_table(imported->sgt);
+ kfree(imported->sgt);
+ imported->sgt = NULL;
}
}
- final_release = sgt_info && !sgt_info->valid &&
- !sgt_info->num_importers;
+ finish = imported && !imported->valid &&
+ !imported->importers;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_RELEASE);
- if (ret < 0) {
- dev_warn(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
/*
* Check if buffer is still valid and if not remove it from imported list.
* That has to be done after sending sync request
*/
- if (final_release) {
- hyper_dmabuf_remove_imported(sgt_info->hid);
- kfree(sgt_info);
+ if (finish) {
+ hyper_dmabuf_remove_imported(imported->hid);
+ kfree(imported);
}
}
static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return -EINVAL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return ret;
}
static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return -EINVAL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_END_CPU_ACCESS);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return 0;
}
static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return NULL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_KMAP_ATOMIC);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return NULL; /* for now NULL.. need to return the address of mapped region */
}
static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_KUNMAP_ATOMIC);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static void *hyper_dmabuf_ops_kmap(struct dma_buf *dmabuf, unsigned long pgnum)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return NULL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_KMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
- return NULL; /* for now NULL.. need to return the address of mapped region */
+ /* for now NULL.. need to return the address of mapped region */
+ return NULL;
}
-static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr)
+static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum,
+ void *vaddr)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_KUNMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return -EINVAL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_MMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return ret;
}
static void *hyper_dmabuf_ops_vmap(struct dma_buf *dmabuf)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return NULL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_VMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return NULL;
}
static void hyper_dmabuf_ops_vunmap(struct dma_buf *dmabuf, void *vaddr)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_VUNMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static const struct dma_buf_ops hyper_dmabuf_ops = {
- .attach = hyper_dmabuf_ops_attach,
- .detach = hyper_dmabuf_ops_detach,
- .map_dma_buf = hyper_dmabuf_ops_map,
- .unmap_dma_buf = hyper_dmabuf_ops_unmap,
- .release = hyper_dmabuf_ops_release,
- .begin_cpu_access = (void*)hyper_dmabuf_ops_begin_cpu_access,
- .end_cpu_access = (void*)hyper_dmabuf_ops_end_cpu_access,
- .map_atomic = hyper_dmabuf_ops_kmap_atomic,
- .unmap_atomic = hyper_dmabuf_ops_kunmap_atomic,
- .map = hyper_dmabuf_ops_kmap,
- .unmap = hyper_dmabuf_ops_kunmap,
- .mmap = hyper_dmabuf_ops_mmap,
- .vmap = hyper_dmabuf_ops_vmap,
- .vunmap = hyper_dmabuf_ops_vunmap,
+ .attach = hyper_dmabuf_ops_attach,
+ .detach = hyper_dmabuf_ops_detach,
+ .map_dma_buf = hyper_dmabuf_ops_map,
+ .unmap_dma_buf = hyper_dmabuf_ops_unmap,
+ .release = hyper_dmabuf_ops_release,
+ .begin_cpu_access = (void*)hyper_dmabuf_ops_begin_cpu_access,
+ .end_cpu_access = (void*)hyper_dmabuf_ops_end_cpu_access,
+ .map_atomic = hyper_dmabuf_ops_kmap_atomic,
+ .unmap_atomic = hyper_dmabuf_ops_kunmap_atomic,
+ .map = hyper_dmabuf_ops_kmap,
+ .unmap = hyper_dmabuf_ops_kunmap,
+ .mmap = hyper_dmabuf_ops_mmap,
+ .vmap = hyper_dmabuf_ops_vmap,
+ .vunmap = hyper_dmabuf_ops_vunmap,
};
/* exporting dmabuf as fd */
-int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags)
+int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags)
{
int fd = -1;
/* call hyper_dmabuf_export_dmabuf and create
* and bind a handle for it then release
*/
- hyper_dmabuf_export_dma_buf(dinfo);
+ hyper_dmabuf_export_dma_buf(imported);
- if (dinfo->dma_buf) {
- fd = dma_buf_fd(dinfo->dma_buf, flags);
+ if (imported->dma_buf) {
+ fd = dma_buf_fd(imported->dma_buf, flags);
}
return fd;
}
-void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo)
+void hyper_dmabuf_export_dma_buf(struct imported_sgt_info *imported)
{
DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
exp_info.ops = &hyper_dmabuf_ops;
/* multiple of PAGE_SIZE, not considering offset */
- exp_info.size = dinfo->sgt->nents * PAGE_SIZE;
- exp_info.flags = /* not sure about flag */0;
- exp_info.priv = dinfo;
+ exp_info.size = imported->sgt->nents * PAGE_SIZE;
+ exp_info.flags = /* not sure about flag */ 0;
+ exp_info.priv = imported;
- dinfo->dma_buf = dma_buf_export(&exp_info);
+ imported->dma_buf = dma_buf_export(&exp_info);
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
index 8c06fc6..c5505a4 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
@@ -25,8 +25,8 @@
#ifndef __HYPER_DMABUF_OPS_H__
#define __HYPER_DMABUF_OPS_H__
-int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags);
+int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags);
-void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo);
+void hyper_dmabuf_export_dma_buf(struct imported_sgt_info *imported);
#endif /* __HYPER_DMABUF_IMP_H__ */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
index 39c9dee..36e888c 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
@@ -32,16 +32,12 @@
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_id.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
#define HYPER_DMABUF_SIZE(nents, first_offset, last_len) \
((nents)*PAGE_SIZE - (first_offset) - PAGE_SIZE + (last_len))
-int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
+int hyper_dmabuf_query_exported(struct exported_sgt_info *exported,
int query, unsigned long* info)
{
- int n;
-
switch (query)
{
case HYPER_DMABUF_QUERY_TYPE:
@@ -50,45 +46,46 @@ int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
/* exporting domain of this specific dmabuf*/
case HYPER_DMABUF_QUERY_EXPORTER:
- *info = HYPER_DMABUF_DOM_ID(sgt_info->hid);
+ *info = HYPER_DMABUF_DOM_ID(exported->hid);
break;
/* importing domain of this specific dmabuf */
case HYPER_DMABUF_QUERY_IMPORTER:
- *info = sgt_info->hyper_dmabuf_rdomain;
+ *info = exported->rdomid;
break;
/* size of dmabuf in byte */
case HYPER_DMABUF_QUERY_SIZE:
- *info = sgt_info->dma_buf->size;
+ *info = exported->dma_buf->size;
break;
/* whether the buffer is used by importer */
case HYPER_DMABUF_QUERY_BUSY:
- *info = (sgt_info->importer_exported == 0) ? false : true;
+ *info = (exported->active > 0);
break;
/* whether the buffer is unexported */
case HYPER_DMABUF_QUERY_UNEXPORTED:
- *info = !sgt_info->valid;
+ *info = !exported->valid;
break;
/* whether the buffer is scheduled to be unexported */
case HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED:
- *info = !sgt_info->unexport_scheduled;
+ *info = !exported->unexport_sched;
break;
/* size of private info attached to buffer */
case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
- *info = sgt_info->sz_priv;
+ *info = exported->sz_priv;
break;
/* copy private info attached to buffer */
case HYPER_DMABUF_QUERY_PRIV_INFO:
- if (sgt_info->sz_priv > 0) {
+ if (exported->sz_priv > 0) {
+ int n;
n = copy_to_user((void __user*) *info,
- sgt_info->priv,
- sgt_info->sz_priv);
+ exported->priv,
+ exported->sz_priv);
if (n != 0)
return -EINVAL;
}
@@ -102,11 +99,9 @@ int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
}
-int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_sgt_info,
+int hyper_dmabuf_query_imported(struct imported_sgt_info *imported,
int query, unsigned long *info)
{
- int n;
-
switch (query)
{
case HYPER_DMABUF_QUERY_TYPE:
@@ -115,50 +110,51 @@ int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_
/* exporting domain of this specific dmabuf*/
case HYPER_DMABUF_QUERY_EXPORTER:
- *info = HYPER_DMABUF_DOM_ID(imported_sgt_info->hid);
+ *info = HYPER_DMABUF_DOM_ID(imported->hid);
break;
/* importing domain of this specific dmabuf */
case HYPER_DMABUF_QUERY_IMPORTER:
- *info = hyper_dmabuf_private.domid;
+ *info = hy_drv_priv->domid;
break;
/* size of dmabuf in byte */
case HYPER_DMABUF_QUERY_SIZE:
- if (imported_sgt_info->dma_buf) {
+ if (imported->dma_buf) {
/* if local dma_buf is created (if it's ever mapped),
* retrieve it directly from struct dma_buf *
*/
- *info = imported_sgt_info->dma_buf->size;
+ *info = imported->dma_buf->size;
} else {
/* calcuate it from given nents, frst_ofst and last_len */
- *info = HYPER_DMABUF_SIZE(imported_sgt_info->nents,
- imported_sgt_info->frst_ofst,
- imported_sgt_info->last_len);
+ *info = HYPER_DMABUF_SIZE(imported->nents,
+ imported->frst_ofst,
+ imported->last_len);
}
break;
/* whether the buffer is used or not */
case HYPER_DMABUF_QUERY_BUSY:
/* checks if it's used by importer */
- *info = (imported_sgt_info->num_importers > 0) ? true : false;
+ *info = (imported->importers > 0);
break;
/* whether the buffer is unexported */
case HYPER_DMABUF_QUERY_UNEXPORTED:
- *info = !imported_sgt_info->valid;
+ *info = !imported->valid;
break;
/* size of private info attached to buffer */
case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
- *info = imported_sgt_info->sz_priv;
+ *info = imported->sz_priv;
break;
/* copy private info attached to buffer */
case HYPER_DMABUF_QUERY_PRIV_INFO:
- if (imported_sgt_info->sz_priv > 0) {
+ if (imported->sz_priv > 0) {
+ int n;
n = copy_to_user((void __user*) *info,
- imported_sgt_info->priv,
- imported_sgt_info->sz_priv);
+ imported->priv,
+ imported->sz_priv);
if (n != 0)
return -EINVAL;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
index 7bbb322..65ae738 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
@@ -1,10 +1,10 @@
#ifndef __HYPER_DMABUF_QUERY_H__
#define __HYPER_DMABUF_QUERY_H__
-int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_sgt_info,
+int hyper_dmabuf_query_imported(struct imported_sgt_info *imported,
int query, unsigned long *info);
-int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
+int hyper_dmabuf_query_exported(struct exported_sgt_info *exported,
int query, unsigned long *info);
#endif // __HYPER_DMABUF_QUERY_H__
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
index 9004406..01ec98c 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
@@ -39,8 +39,6 @@
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_sgl_proc.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
/* Whenever importer does dma operations from remote domain,
* a notification is sent to the exporter so that exporter
* issues equivalent dma operation on the original dma buf
@@ -58,7 +56,7 @@ extern struct hyper_dmabuf_private hyper_dmabuf_private;
*/
int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
{
- struct hyper_dmabuf_sgt_info *sgt_info;
+ struct exported_sgt_info *exported;
struct sgt_list *sgtl;
struct attachment_list *attachl;
struct kmap_vaddr_list *va_kmapl;
@@ -66,10 +64,10 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
int ret;
/* find a coresponding SGT for the id */
- sgt_info = hyper_dmabuf_find_exported(hid);
+ exported = hyper_dmabuf_find_exported(hid);
- if (!sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!exported) {
+ dev_err(hy_drv_priv->dev,
"dmabuf remote sync::can't find exported list\n");
return -ENOENT;
}
@@ -79,84 +77,84 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
attachl = kcalloc(1, sizeof(*attachl), GFP_KERNEL);
if (!attachl) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_ATTACH\n");
return -ENOMEM;
}
- attachl->attach = dma_buf_attach(sgt_info->dma_buf,
- hyper_dmabuf_private.device);
+ attachl->attach = dma_buf_attach(exported->dma_buf,
+ hy_drv_priv->dev);
if (!attachl->attach) {
kfree(attachl);
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_ATTACH\n");
return -ENOMEM;
}
- list_add(&attachl->list, &sgt_info->active_attached->list);
+ list_add(&attachl->list, &exported->active_attached->list);
break;
case HYPER_DMABUF_OPS_DETACH:
- if (list_empty(&sgt_info->active_attached->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_DETACH\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->active_attached->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_DETACH\n");
+ dev_err(hy_drv_priv->dev,
"no more dmabuf attachment left to be detached\n");
return -EFAULT;
}
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
- dma_buf_detach(sgt_info->dma_buf, attachl->attach);
+ dma_buf_detach(exported->dma_buf, attachl->attach);
list_del(&attachl->list);
kfree(attachl);
break;
case HYPER_DMABUF_OPS_MAP:
- if (list_empty(&sgt_info->active_attached->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->active_attached->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_MAP\n");
+ dev_err(hy_drv_priv->dev,
"no more dmabuf attachment left to be mapped\n");
return -EFAULT;
}
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
sgtl = kcalloc(1, sizeof(*sgtl), GFP_KERNEL);
if (!sgtl) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_MAP\n");
return -ENOMEM;
}
sgtl->sgt = dma_buf_map_attachment(attachl->attach, DMA_BIDIRECTIONAL);
if (!sgtl->sgt) {
kfree(sgtl);
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_MAP\n");
return -ENOMEM;
}
- list_add(&sgtl->list, &sgt_info->active_sgts->list);
+ list_add(&sgtl->list, &exported->active_sgts->list);
break;
case HYPER_DMABUF_OPS_UNMAP:
- if (list_empty(&sgt_info->active_sgts->list) ||
- list_empty(&sgt_info->active_attached->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_UNMAP\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->active_sgts->list) ||
+ list_empty(&exported->active_attached->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_UNMAP\n");
+ dev_err(hy_drv_priv->dev,
"no more SGT or attachment left to be unmapped\n");
return -EFAULT;
}
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
- sgtl = list_first_entry(&sgt_info->active_sgts->list,
+ sgtl = list_first_entry(&exported->active_sgts->list,
struct sgt_list, list);
dma_buf_unmap_attachment(attachl->attach, sgtl->sgt,
@@ -166,30 +164,30 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
break;
case HYPER_DMABUF_OPS_RELEASE:
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Buffer {id:%d key:%d %d %d} released, references left: %d\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2], sgt_info->importer_exported -1);
+ exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1],
+ exported->hid.rng_key[2], exported->active - 1);
- sgt_info->importer_exported--;
+ exported->active--;
/* If there are still importers just break, if no then continue with final cleanup */
- if (sgt_info->importer_exported)
+ if (exported->active)
break;
/*
* Importer just released buffer fd, check if there is any other importer still using it.
* If not and buffer was unexported, clean up shared data and remove that buffer.
*/
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Buffer {id:%d key:%d %d %d} final released\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1],
+ exported->hid.rng_key[2]);
- if (!sgt_info->valid && !sgt_info->importer_exported &&
- !sgt_info->unexport_scheduled) {
- hyper_dmabuf_cleanup_sgt_info(sgt_info, false);
+ if (!exported->valid && !exported->active &&
+ !exported->unexport_sched) {
+ hyper_dmabuf_cleanup_sgt_info(exported, false);
hyper_dmabuf_remove_exported(hid);
- kfree(sgt_info);
+ kfree(exported);
/* store hyper_dmabuf_id in the list for reuse */
store_reusable_hid(hid);
}
@@ -197,19 +195,19 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
break;
case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS:
- ret = dma_buf_begin_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL);
+ ret = dma_buf_begin_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
return ret;
}
break;
case HYPER_DMABUF_OPS_END_CPU_ACCESS:
- ret = dma_buf_end_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL);
+ ret = dma_buf_end_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
return ret;
}
break;
@@ -218,49 +216,49 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
case HYPER_DMABUF_OPS_KMAP:
va_kmapl = kcalloc(1, sizeof(*va_kmapl), GFP_KERNEL);
if (!va_kmapl) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
return -ENOMEM;
}
/* dummy kmapping of 1 page */
if (ops == HYPER_DMABUF_OPS_KMAP_ATOMIC)
- va_kmapl->vaddr = dma_buf_kmap_atomic(sgt_info->dma_buf, 1);
+ va_kmapl->vaddr = dma_buf_kmap_atomic(exported->dma_buf, 1);
else
- va_kmapl->vaddr = dma_buf_kmap(sgt_info->dma_buf, 1);
+ va_kmapl->vaddr = dma_buf_kmap(exported->dma_buf, 1);
if (!va_kmapl->vaddr) {
kfree(va_kmapl);
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
return -ENOMEM;
}
- list_add(&va_kmapl->list, &sgt_info->va_kmapped->list);
+ list_add(&va_kmapl->list, &exported->va_kmapped->list);
break;
case HYPER_DMABUF_OPS_KUNMAP_ATOMIC:
case HYPER_DMABUF_OPS_KUNMAP:
- if (list_empty(&sgt_info->va_kmapped->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->va_kmapped->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
+ dev_err(hy_drv_priv->dev,
"no more dmabuf VA to be freed\n");
return -EFAULT;
}
- va_kmapl = list_first_entry(&sgt_info->va_kmapped->list,
+ va_kmapl = list_first_entry(&exported->va_kmapped->list,
struct kmap_vaddr_list, list);
if (!va_kmapl->vaddr) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
return PTR_ERR(va_kmapl->vaddr);
}
/* unmapping 1 page */
if (ops == HYPER_DMABUF_OPS_KUNMAP_ATOMIC)
- dma_buf_kunmap_atomic(sgt_info->dma_buf, 1, va_kmapl->vaddr);
+ dma_buf_kunmap_atomic(exported->dma_buf, 1, va_kmapl->vaddr);
else
- dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr);
+ dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr);
list_del(&va_kmapl->list);
kfree(va_kmapl);
@@ -269,48 +267,48 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
case HYPER_DMABUF_OPS_MMAP:
/* currently not supported: looking for a way to create
* a dummy vma */
- dev_warn(hyper_dmabuf_private.device,
- "dmabuf remote sync::sychronized mmap is not supported\n");
+ dev_warn(hy_drv_priv->dev,
+ "remote sync::sychronized mmap is not supported\n");
break;
case HYPER_DMABUF_OPS_VMAP:
va_vmapl = kcalloc(1, sizeof(*va_vmapl), GFP_KERNEL);
if (!va_vmapl) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_VMAP\n");
return -ENOMEM;
}
/* dummy vmapping */
- va_vmapl->vaddr = dma_buf_vmap(sgt_info->dma_buf);
+ va_vmapl->vaddr = dma_buf_vmap(exported->dma_buf);
if (!va_vmapl->vaddr) {
kfree(va_vmapl);
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_VMAP\n");
return -ENOMEM;
}
- list_add(&va_vmapl->list, &sgt_info->va_vmapped->list);
+ list_add(&va_vmapl->list, &exported->va_vmapped->list);
break;
case HYPER_DMABUF_OPS_VUNMAP:
- if (list_empty(&sgt_info->va_vmapped->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->va_vmapped->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_VUNMAP\n");
+ dev_err(hy_drv_priv->dev,
"no more dmabuf VA to be freed\n");
return -EFAULT;
}
- va_vmapl = list_first_entry(&sgt_info->va_vmapped->list,
+ va_vmapl = list_first_entry(&exported->va_vmapped->list,
struct vmap_vaddr_list, list);
if (!va_vmapl || va_vmapl->vaddr == NULL) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_VUNMAP\n");
return -EFAULT;
}
- dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr);
+ dma_buf_vunmap(exported->dma_buf, va_vmapl->vaddr);
list_del(&va_vmapl->list);
kfree(va_vmapl);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
index 691a714..315c354 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
@@ -32,8 +32,6 @@
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/dma-buf.h>
-#include <xen/grant_table.h>
-#include <asm/xen/page.h>
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_sgl_proc.h"
@@ -41,8 +39,6 @@
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_list.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
#define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
int dmabuf_refcount(struct dma_buf *dma_buf)
@@ -66,60 +62,68 @@ static int hyper_dmabuf_get_num_pgs(struct sg_table *sgt)
sgl = sgt->sgl;
length = sgl->length - PAGE_SIZE + sgl->offset;
- num_pages += ((length + PAGE_SIZE - 1)/PAGE_SIZE); /* round-up */
+
+ /* round-up */
+ num_pages += ((length + PAGE_SIZE - 1)/PAGE_SIZE);
for (i = 1; i < sgt->nents; i++) {
sgl = sg_next(sgl);
- num_pages += ((sgl->length + PAGE_SIZE - 1) / PAGE_SIZE); /* round-up */
+
+ /* round-up */
+ num_pages += ((sgl->length + PAGE_SIZE - 1) /
+ PAGE_SIZE); /* round-up */
}
return num_pages;
}
/* extract pages directly from struct sg_table */
-struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
+struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
{
- struct hyper_dmabuf_pages_info *pinfo;
+ struct pages_info *pg_info;
int i, j, k;
int length;
struct scatterlist *sgl;
- pinfo = kmalloc(sizeof(*pinfo), GFP_KERNEL);
- if (!pinfo)
+ pg_info = kmalloc(sizeof(*pg_info), GFP_KERNEL);
+ if (!pg_info)
return NULL;
- pinfo->pages = kmalloc(sizeof(struct page *)*hyper_dmabuf_get_num_pgs(sgt), GFP_KERNEL);
- if (!pinfo->pages) {
- kfree(pinfo);
+ pg_info->pgs = kmalloc(sizeof(struct page *) *
+ hyper_dmabuf_get_num_pgs(sgt),
+ GFP_KERNEL);
+
+ if (!pg_info->pgs) {
+ kfree(pg_info);
return NULL;
}
sgl = sgt->sgl;
- pinfo->nents = 1;
- pinfo->frst_ofst = sgl->offset;
- pinfo->pages[0] = sg_page(sgl);
+ pg_info->nents = 1;
+ pg_info->frst_ofst = sgl->offset;
+ pg_info->pgs[0] = sg_page(sgl);
length = sgl->length - PAGE_SIZE + sgl->offset;
i = 1;
while (length > 0) {
- pinfo->pages[i] = nth_page(sg_page(sgl), i);
+ pg_info->pgs[i] = nth_page(sg_page(sgl), i);
length -= PAGE_SIZE;
- pinfo->nents++;
+ pg_info->nents++;
i++;
}
for (j = 1; j < sgt->nents; j++) {
sgl = sg_next(sgl);
- pinfo->pages[i++] = sg_page(sgl);
+ pg_info->pgs[i++] = sg_page(sgl);
length = sgl->length - PAGE_SIZE;
- pinfo->nents++;
+ pg_info->nents++;
k = 1;
while (length > 0) {
- pinfo->pages[i++] = nth_page(sg_page(sgl), k++);
+ pg_info->pgs[i++] = nth_page(sg_page(sgl), k++);
length -= PAGE_SIZE;
- pinfo->nents++;
+ pg_info->nents++;
}
}
@@ -127,13 +131,13 @@ struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
* lenght at that point will be 0 or negative,
* so to calculate last page size just add it to PAGE_SIZE
*/
- pinfo->last_len = PAGE_SIZE + length;
+ pg_info->last_len = PAGE_SIZE + length;
- return pinfo;
+ return pg_info;
}
/* create sg_table with given pages and other parameters */
-struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
+struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs,
int frst_ofst, int last_len, int nents)
{
struct sg_table *sgt;
@@ -157,31 +161,32 @@ struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
sgl = sgt->sgl;
- sg_set_page(sgl, pages[0], PAGE_SIZE-frst_ofst, frst_ofst);
+ sg_set_page(sgl, pgs[0], PAGE_SIZE-frst_ofst, frst_ofst);
for (i=1; i<nents-1; i++) {
sgl = sg_next(sgl);
- sg_set_page(sgl, pages[i], PAGE_SIZE, 0);
+ sg_set_page(sgl, pgs[i], PAGE_SIZE, 0);
}
if (nents > 1) /* more than one page */ {
sgl = sg_next(sgl);
- sg_set_page(sgl, pages[i], last_len, 0);
+ sg_set_page(sgl, pgs[i], last_len, 0);
}
return sgt;
}
-int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force)
+int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported,
+ int force)
{
struct sgt_list *sgtl;
struct attachment_list *attachl;
struct kmap_vaddr_list *va_kmapl;
struct vmap_vaddr_list *va_vmapl;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
- if (!sgt_info) {
- dev_err(hyper_dmabuf_private.device, "invalid hyper_dmabuf_id\n");
+ if (!exported) {
+ dev_err(hy_drv_priv->dev, "invalid hyper_dmabuf_id\n");
return -EINVAL;
}
@@ -190,35 +195,37 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
* side.
*/
if (!force &&
- sgt_info->importer_exported) {
- dev_warn(hyper_dmabuf_private.device, "dma-buf is used by importer\n");
+ exported->active) {
+ dev_warn(hy_drv_priv->dev,
+ "dma-buf is used by importer\n");
+
return -EPERM;
}
/* force == 1 is not recommended */
- while (!list_empty(&sgt_info->va_kmapped->list)) {
- va_kmapl = list_first_entry(&sgt_info->va_kmapped->list,
+ while (!list_empty(&exported->va_kmapped->list)) {
+ va_kmapl = list_first_entry(&exported->va_kmapped->list,
struct kmap_vaddr_list, list);
- dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr);
+ dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr);
list_del(&va_kmapl->list);
kfree(va_kmapl);
}
- while (!list_empty(&sgt_info->va_vmapped->list)) {
- va_vmapl = list_first_entry(&sgt_info->va_vmapped->list,
+ while (!list_empty(&exported->va_vmapped->list)) {
+ va_vmapl = list_first_entry(&exported->va_vmapped->list,
struct vmap_vaddr_list, list);
- dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr);
+ dma_buf_vunmap(exported->dma_buf, va_vmapl->vaddr);
list_del(&va_vmapl->list);
kfree(va_vmapl);
}
- while (!list_empty(&sgt_info->active_sgts->list)) {
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ while (!list_empty(&exported->active_sgts->list)) {
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
- sgtl = list_first_entry(&sgt_info->active_sgts->list,
+ sgtl = list_first_entry(&exported->active_sgts->list,
struct sgt_list, list);
dma_buf_unmap_attachment(attachl->attach, sgtl->sgt,
@@ -227,35 +234,35 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
kfree(sgtl);
}
- while (!list_empty(&sgt_info->active_sgts->list)) {
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ while (!list_empty(&exported->active_sgts->list)) {
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
- dma_buf_detach(sgt_info->dma_buf, attachl->attach);
+ dma_buf_detach(exported->dma_buf, attachl->attach);
list_del(&attachl->list);
kfree(attachl);
}
/* Start cleanup of buffer in reverse order to exporting */
- ops->unshare_pages(&sgt_info->refs_info, sgt_info->nents);
+ ops->unshare_pages(&exported->refs_info, exported->nents);
/* unmap dma-buf */
- dma_buf_unmap_attachment(sgt_info->active_attached->attach,
- sgt_info->active_sgts->sgt,
+ dma_buf_unmap_attachment(exported->active_attached->attach,
+ exported->active_sgts->sgt,
DMA_BIDIRECTIONAL);
/* detatch dma-buf */
- dma_buf_detach(sgt_info->dma_buf, sgt_info->active_attached->attach);
+ dma_buf_detach(exported->dma_buf, exported->active_attached->attach);
/* close connection to dma-buf completely */
- dma_buf_put(sgt_info->dma_buf);
- sgt_info->dma_buf = NULL;
-
- kfree(sgt_info->active_sgts);
- kfree(sgt_info->active_attached);
- kfree(sgt_info->va_kmapped);
- kfree(sgt_info->va_vmapped);
- kfree(sgt_info->priv);
+ dma_buf_put(exported->dma_buf);
+ exported->dma_buf = NULL;
+
+ kfree(exported->active_sgts);
+ kfree(exported->active_attached);
+ kfree(exported->va_kmapped);
+ kfree(exported->va_vmapped);
+ kfree(exported->priv);
return 0;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
index 237ccf5..930bade 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
@@ -28,13 +28,15 @@
int dmabuf_refcount(struct dma_buf *dma_buf);
/* extract pages directly from struct sg_table */
-struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt);
+struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt);
/* create sg_table with given pages and other parameters */
-struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
- int frst_ofst, int last_len, int nents);
+struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs,
+ int frst_ofst, int last_len,
+ int nents);
-int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force);
+int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported,
+ int force);
void hyper_dmabuf_free_sgt(struct sg_table *sgt);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
index 6f929f2..8a612d1 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
@@ -50,24 +50,20 @@ struct vmap_vaddr_list {
};
/* Exporter builds pages_info before sharing pages */
-struct hyper_dmabuf_pages_info {
+struct pages_info {
int frst_ofst; /* offset of data in the first page */
int last_len; /* length of data in the last page */
int nents; /* # of pages */
- struct page **pages; /* pages that contains reference numbers of shared pages*/
+ struct page **pgs; /* pages that contains reference numbers of shared pages*/
};
-/* Both importer and exporter use this structure to point to sg lists
- *
- * Exporter stores references to sgt in a hash table
+/* Exporter stores references to sgt in a hash table
* Exporter keeps these references for synchronization and tracking purposes
- *
- * Importer use this structure exporting to other drivers in the same domain
*/
-struct hyper_dmabuf_sgt_info {
+struct exported_sgt_info {
hyper_dmabuf_id_t hid; /* unique id to reference dmabuf in remote domain */
- int hyper_dmabuf_rdomain; /* domain importing this sgt */
+ int rdomid; /* domain importing this sgt */
struct dma_buf *dma_buf; /* needed to store this for freeing it later */
int nents;
@@ -79,10 +75,10 @@ struct hyper_dmabuf_sgt_info {
struct vmap_vaddr_list *va_vmapped;
bool valid; /* set to 0 once unexported. Needed to prevent further mapping by importer */
- int importer_exported; /* exported locally on importer's side */
+ int active; /* locally shared on importer's side */
void *refs_info; /* hypervisor-specific info for the references */
- struct delayed_work unexport_work;
- bool unexport_scheduled;
+ struct delayed_work unexport;
+ bool unexport_sched;
/* owner of buffer
* TODO: that is naiive as buffer may be reused by
@@ -99,7 +95,7 @@ struct hyper_dmabuf_sgt_info {
/* Importer store references (before mapping) on shared pages
* Importer store these references in the table and map it in
* its own memory map once userspace asks for reference for the buffer */
-struct hyper_dmabuf_imported_sgt_info {
+struct imported_sgt_info {
hyper_dmabuf_id_t hid; /* unique id for shared dmabuf imported */
int ref_handle; /* reference number of top level addressing page of shared pages */
@@ -112,7 +108,7 @@ struct hyper_dmabuf_imported_sgt_info {
void *refs_info;
bool valid;
- int num_importers;
+ int importers;
size_t sz_priv;
char *priv; /* device specific info (e.g. image's meta info?) */
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
index 920ecf4..f70b4ea 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
@@ -45,8 +45,6 @@ static int export_req_id = 0;
struct hyper_dmabuf_req req_pending = {0};
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
extern int xenstored_ready;
static void xen_get_domid_delayed(struct work_struct *unused);
@@ -62,7 +60,9 @@ static int xen_comm_setup_data_dir(void)
{
char buf[255];
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_private.domid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf",
+ hy_drv_priv->domid);
+
return xenbus_mkdir(XBT_NIL, buf, "");
}
@@ -76,7 +76,9 @@ static int xen_comm_destroy_data_dir(void)
{
char buf[255];
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_private.domid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf",
+ hy_drv_priv->domid);
+
return xenbus_rm(XBT_NIL, buf, "");
}
@@ -91,20 +93,26 @@ static int xen_comm_expose_ring_details(int domid, int rdomid,
char buf[255];
int ret;
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", domid, rdomid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
+ domid, rdomid);
+
ret = xenbus_printf(XBT_NIL, buf, "grefid", "%d", gref);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "Failed to write xenbus entry %s: %d\n", buf, ret);
+ dev_err(hy_drv_priv->dev,
+ "Failed to write xenbus entry %s: %d\n",
+ buf, ret);
+
return ret;
}
ret = xenbus_printf(XBT_NIL, buf, "port", "%d", port);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "Failed to write xenbus entry %s: %d\n", buf, ret);
+ dev_err(hy_drv_priv->dev,
+ "Failed to write xenbus entry %s: %d\n",
+ buf, ret);
+
return ret;
}
@@ -114,25 +122,32 @@ static int xen_comm_expose_ring_details(int domid, int rdomid,
/*
* Queries details of ring exposed by remote domain.
*/
-static int xen_comm_get_ring_details(int domid, int rdomid, int *grefid, int *port)
+static int xen_comm_get_ring_details(int domid, int rdomid,
+ int *grefid, int *port)
{
char buf[255];
int ret;
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", rdomid, domid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
+ rdomid, domid);
+
ret = xenbus_scanf(XBT_NIL, buf, "grefid", "%d", grefid);
if (ret <= 0) {
- dev_err(hyper_dmabuf_private.device,
- "Failed to read xenbus entry %s: %d\n", buf, ret);
+ dev_err(hy_drv_priv->dev,
+ "Failed to read xenbus entry %s: %d\n",
+ buf, ret);
+
return ret;
}
ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", port);
if (ret <= 0) {
- dev_err(hyper_dmabuf_private.device,
- "Failed to read xenbus entry %s: %d\n", buf, ret);
+ dev_err(hy_drv_priv->dev,
+ "Failed to read xenbus entry %s: %d\n",
+ buf, ret);
+
return ret;
}
@@ -146,9 +161,8 @@ void xen_get_domid_delayed(struct work_struct *unused)
/* scheduling another if driver is still running
* and xenstore has not been initialized */
- if (hyper_dmabuf_private.exited == false &&
- likely(xenstored_ready == 0)) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (likely(xenstored_ready == 0)) {
+ dev_dbg(hy_drv_priv->dev,
"Xenstore is not quite ready yet. Will retry it in 500ms\n");
schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500));
} else {
@@ -163,14 +177,14 @@ void xen_get_domid_delayed(struct work_struct *unused)
/* try again since -1 is an invalid id for domain
* (but only if driver is still running) */
- if (hyper_dmabuf_private.exited == false && unlikely(domid == -1)) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (unlikely(domid == -1)) {
+ dev_dbg(hy_drv_priv->dev,
"domid==-1 is invalid. Will retry it in 500ms\n");
schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500));
} else {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Successfully retrieved domid from Xenstore:%d\n", domid);
- hyper_dmabuf_private.domid = domid;
+ hy_drv_priv->domid = domid;
}
}
}
@@ -232,28 +246,30 @@ static void remote_dom_exporter_watch_cb(struct xenbus_watch *watch,
return;
}
- /* Check if we have importer ring for given remote domain alrady created */
+ /* Check if we have importer ring for given remote domain already
+ * created */
+
ring_info = xen_comm_find_rx_ring(rdom);
- /* Try to query remote domain exporter ring details - if that will
- * fail and we have importer ring that means remote domains has cleanup
- * its exporter ring, so our importer ring is no longer useful.
+ /* Try to query remote domain exporter ring details - if
+ * that will fail and we have importer ring that means remote
+ * domains has cleanup its exporter ring, so our importer ring
+ * is no longer useful.
*
* If querying details will succeed and we don't have importer ring,
- * it means that remote domain has setup it for us and we should connect
- * to it.
+ * it means that remote domain has setup it for us and we should
+ * connect to it.
*/
-
- ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), rdom,
- &grefid, &port);
+ ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(),
+ rdom, &grefid, &port);
if (ring_info && ret != 0) {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Remote exporter closed, cleaninup importer\n");
hyper_dmabuf_xen_cleanup_rx_rbuf(rdom);
} else if (!ring_info && ret == 0) {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Registering importer\n");
hyper_dmabuf_xen_init_rx_rbuf(rdom);
}
@@ -274,7 +290,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
ring_info = xen_comm_find_tx_ring(domid);
if (ring_info) {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"tx ring ch to domid = %d already exist\ngref = %d, port = %d\n",
ring_info->rdomain, ring_info->gref_ring, ring_info->port);
return 0;
@@ -283,7 +299,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
if (!ring_info) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No more spae left\n");
return -ENOMEM;
}
@@ -313,9 +329,9 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
alloc_unbound.dom = DOMID_SELF;
alloc_unbound.remote_dom = domid;
ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
- &alloc_unbound);
+ &alloc_unbound);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Cannot allocate event channel\n");
kfree(ring_info);
return -EIO;
@@ -327,7 +343,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
NULL, (void*) ring_info);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Failed to setup event channel\n");
close.port = alloc_unbound.port;
HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
@@ -343,7 +359,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
mutex_init(&ring_info->lock);
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: allocated eventchannel gref %d port: %d irq: %d\n",
__func__,
ring_info->gref_ring,
@@ -364,7 +380,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
ring_info->watch.node = (const char*) kmalloc(sizeof(char) * 255, GFP_KERNEL);
if (!ring_info->watch.node) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No more space left\n");
kfree(ring_info);
return -ENOMEM;
@@ -414,7 +430,8 @@ void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid)
if (!rx_ring_info)
return;
- BACK_RING_INIT(&(rx_ring_info->ring_back), rx_ring_info->ring_back.sring, PAGE_SIZE);
+ BACK_RING_INIT(&(rx_ring_info->ring_back), rx_ring_info->ring_back.sring,
+ PAGE_SIZE);
}
/* importer needs to know about shared page and port numbers for
@@ -436,25 +453,28 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
ring_info = xen_comm_find_rx_ring(domid);
if (ring_info) {
- dev_info(hyper_dmabuf_private.device,
- "rx ring ch from domid = %d already exist\n", ring_info->sdomain);
+ dev_info(hy_drv_priv->dev,
+ "rx ring ch from domid = %d already exist\n",
+ ring_info->sdomain);
+
return 0;
}
-
ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), domid,
&rx_gref, &rx_port);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "Domain %d has not created exporter ring for current domain\n", domid);
+ dev_err(hy_drv_priv->dev,
+ "Domain %d has not created exporter ring for current domain\n",
+ domid);
+
return ret;
}
ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
if (!ring_info) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
@@ -465,7 +485,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
map_ops = kmalloc(sizeof(*map_ops), GFP_KERNEL);
if (!map_ops) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
ret = -ENOMEM;
goto fail_no_map_ops;
@@ -476,21 +496,23 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
goto fail_others;
}
- gnttab_set_map_op(&map_ops[0], (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
+ gnttab_set_map_op(&map_ops[0],
+ (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
GNTMAP_host_map, rx_gref, domid);
- gnttab_set_unmap_op(&ring_info->unmap_op, (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
+ gnttab_set_unmap_op(&ring_info->unmap_op,
+ (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
GNTMAP_host_map, -1);
ret = gnttab_map_refs(map_ops, NULL, &shared_ring, 1);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device, "Cannot map ring\n");
+ dev_err(hy_drv_priv->dev, "Cannot map ring\n");
ret = -EFAULT;
goto fail_others;
}
if (map_ops[0].status) {
- dev_err(hyper_dmabuf_private.device, "Ring mapping failed\n");
+ dev_err(hy_drv_priv->dev, "Ring mapping failed\n");
ret = -EFAULT;
goto fail_others;
} else {
@@ -512,7 +534,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
ring_info->irq = ret;
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: bound to eventchannel port: %d irq: %d\n", __func__,
rx_port,
ring_info->irq);
@@ -569,7 +591,9 @@ void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid)
return;
SHARED_RING_INIT(tx_ring_info->ring_front.sring);
- FRONT_RING_INIT(&(tx_ring_info->ring_front), tx_ring_info->ring_front.sring, PAGE_SIZE);
+ FRONT_RING_INIT(&(tx_ring_info->ring_front),
+ tx_ring_info->ring_front.sring,
+ PAGE_SIZE);
}
#ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD
@@ -587,20 +611,20 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused)
char buf[128];
int i, dummy;
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Scanning new tx channel comming from another domain\n");
/* check other domains and schedule another work if driver
* is still running and backend is valid
*/
- if (hyper_dmabuf_private.exited == false &&
- hyper_dmabuf_private.backend_initialized == true) {
+ if (hy_drv_priv &&
+ hy_drv_priv->initialized) {
for (i = DOMID_SCAN_START; i < DOMID_SCAN_END + 1; i++) {
- if (i == hyper_dmabuf_private.domid)
+ if (i == hy_drv_priv->domid)
continue;
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", i,
- hyper_dmabuf_private.domid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
+ i, hy_drv_priv->domid);
ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", &dummy);
@@ -611,13 +635,14 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused)
ret = hyper_dmabuf_xen_init_rx_rbuf(i);
if (!ret)
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Finishing up setting up rx channel for domain %d\n", i);
}
}
/* check every 10 seconds */
- schedule_delayed_work(&xen_rx_ch_auto_add_work, msecs_to_jiffies(10000));
+ schedule_delayed_work(&xen_rx_ch_auto_add_work,
+ msecs_to_jiffies(10000));
}
}
@@ -630,21 +655,21 @@ void xen_init_comm_env_delayed(struct work_struct *unused)
/* scheduling another work if driver is still running
* and xenstore hasn't been initialized or dom_id hasn't
* been correctly retrieved. */
- if (hyper_dmabuf_private.exited == false &&
- likely(xenstored_ready == 0 ||
- hyper_dmabuf_private.domid == -1)) {
- dev_dbg(hyper_dmabuf_private.device,
- "Xenstore is not ready yet. Re-try this again in 500ms\n");
- schedule_delayed_work(&xen_init_comm_env_work, msecs_to_jiffies(500));
+ if (likely(xenstored_ready == 0 ||
+ hy_drv_priv->domid == -1)) {
+ dev_dbg(hy_drv_priv->dev,
+ "Xenstore not ready Will re-try in 500ms\n");
+ schedule_delayed_work(&xen_init_comm_env_work,
+ msecs_to_jiffies(500));
} else {
ret = xen_comm_setup_data_dir();
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Failed to create data dir in Xenstore\n");
} else {
- dev_info(hyper_dmabuf_private.device,
- "Successfully finished comm env initialization\n");
- hyper_dmabuf_private.backend_initialized = true;
+ dev_info(hy_drv_priv->dev,
+ "Successfully finished comm env init\n");
+ hy_drv_priv->initialized = true;
#ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD
xen_rx_ch_add_delayed(NULL);
@@ -659,20 +684,21 @@ int hyper_dmabuf_xen_init_comm_env(void)
xen_comm_ring_table_init();
- if (unlikely(xenstored_ready == 0 || hyper_dmabuf_private.domid == -1)) {
+ if (unlikely(xenstored_ready == 0 ||
+ hy_drv_priv->domid == -1)) {
xen_init_comm_env_delayed(NULL);
return -1;
}
ret = xen_comm_setup_data_dir();
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Failed to create data dir in Xenstore\n");
} else {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Successfully finished comm env initialization\n");
- hyper_dmabuf_private.backend_initialized = true;
+ hy_drv_priv->initialized = true;
}
return ret;
@@ -691,7 +717,8 @@ void hyper_dmabuf_xen_destroy_comm(void)
xen_comm_destroy_data_dir();
}
-int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
+int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req,
+ int wait)
{
struct xen_comm_front_ring *ring;
struct hyper_dmabuf_req *new_req;
@@ -706,22 +733,21 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
/* find a ring info for the channel */
ring_info = xen_comm_find_tx_ring(domid);
if (!ring_info) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Can't find ring info for the channel\n");
return -ENOENT;
}
- mutex_lock(&ring_info->lock);
ring = &ring_info->ring_front;
do_gettimeofday(&tv_start);
while (RING_FULL(ring)) {
- dev_dbg(hyper_dmabuf_private.device, "RING_FULL\n");
+ dev_dbg(hy_drv_priv->dev, "RING_FULL\n");
if (timeout == 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Timeout while waiting for an entry in the ring\n");
return -EIO;
}
@@ -731,15 +757,17 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
timeout = 1000;
+ mutex_lock(&ring_info->lock);
+
new_req = RING_GET_REQUEST(ring, ring->req_prod_pvt);
if (!new_req) {
mutex_unlock(&ring_info->lock);
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"NULL REQUEST\n");
return -EIO;
}
- req->request_id = xen_comm_next_req_id();
+ req->req_id = xen_comm_next_req_id();
/* update req_pending with current request */
memcpy(&req_pending, req, sizeof(req_pending));
@@ -756,7 +784,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
if (wait) {
while (timeout--) {
- if (req_pending.status !=
+ if (req_pending.stat !=
HYPER_DMABUF_REQ_NOT_RESPONDED)
break;
usleep_range(100, 120);
@@ -764,7 +792,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
if (timeout < 0) {
mutex_unlock(&ring_info->lock);
- dev_err(hyper_dmabuf_private.device, "request timed-out\n");
+ dev_err(hy_drv_priv->dev, "request timed-out\n");
return -EBUSY;
}
@@ -781,10 +809,8 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
}
if (tv_diff.tv_sec != 0 && tv_diff.tv_usec > 16000)
- dev_dbg(hyper_dmabuf_private.device, "send_req:time diff: %ld sec, %ld usec\n",
+ dev_dbg(hy_drv_priv->dev, "send_req:time diff: %ld sec, %ld usec\n",
tv_diff.tv_sec, tv_diff.tv_usec);
-
- return req_pending.status;
}
mutex_unlock(&ring_info->lock);
@@ -808,7 +834,7 @@ static irqreturn_t back_ring_isr(int irq, void *info)
ring_info = (struct xen_comm_rx_ring_info *)info;
ring = &ring_info->ring_back;
- dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s\n", __func__);
do {
rc = ring->req_cons;
@@ -828,13 +854,13 @@ static irqreturn_t back_ring_isr(int irq, void *info)
* the requester
*/
memcpy(&resp, &req, sizeof(resp));
- memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt), &resp,
- sizeof(resp));
+ memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt),
+ &resp, sizeof(resp));
ring->rsp_prod_pvt++;
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"sending response to exporter for request id:%d\n",
- resp.response_id);
+ resp.resp_id);
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify);
@@ -864,7 +890,7 @@ static irqreturn_t front_ring_isr(int irq, void *info)
ring_info = (struct xen_comm_tx_ring_info *)info;
ring = &ring_info->ring_front;
- dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s\n", __func__);
do {
more_to_do = 0;
@@ -876,33 +902,33 @@ static irqreturn_t front_ring_isr(int irq, void *info)
* in the response
*/
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"getting response from importer\n");
- if (req_pending.request_id == resp->response_id) {
- req_pending.status = resp->status;
+ if (req_pending.req_id == resp->resp_id) {
+ req_pending.stat = resp->stat;
}
- if (resp->status == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
+ if (resp->stat == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
/* parsing response */
ret = hyper_dmabuf_msg_parse(ring_info->rdomain,
(struct hyper_dmabuf_req *)resp);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"getting error while parsing response\n");
}
- } else if (resp->status == HYPER_DMABUF_REQ_PROCESSED) {
+ } else if (resp->stat == HYPER_DMABUF_REQ_PROCESSED) {
/* for debugging dma_buf remote synchronization */
- dev_dbg(hyper_dmabuf_private.device,
- "original request = 0x%x\n", resp->command);
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
+ "original request = 0x%x\n", resp->cmd);
+ dev_dbg(hy_drv_priv->dev,
"Just got HYPER_DMABUF_REQ_PROCESSED\n");
- } else if (resp->status == HYPER_DMABUF_REQ_ERROR) {
+ } else if (resp->stat == HYPER_DMABUF_REQ_ERROR) {
/* for debugging dma_buf remote synchronization */
- dev_dbg(hyper_dmabuf_private.device,
- "original request = 0x%x\n", resp->command);
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
+ "original request = 0x%x\n", resp->cmd);
+ dev_dbg(hy_drv_priv->dev,
"Just got HYPER_DMABUF_REQ_ERROR\n");
}
}
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
index 4708b49..7a8ec73 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
@@ -38,8 +38,6 @@
#include "hyper_dmabuf_xen_comm.h"
#include "hyper_dmabuf_xen_comm_list.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
DECLARE_HASHTABLE(xen_comm_tx_ring_hash, MAX_ENTRY_TX_RING);
DECLARE_HASHTABLE(xen_comm_rx_ring_hash, MAX_ENTRY_RX_RING);
@@ -56,7 +54,7 @@ int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info *ring_info)
info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
if (!info_entry) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
@@ -76,7 +74,7 @@ int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info *ring_info)
info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
if (!info_entry) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
index 908eda8..424417d 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
@@ -36,8 +36,6 @@
#define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
/*
* Creates 2 level page directory structure for referencing shared pages.
* Top level page is a single page that contains up to 1024 refids that
@@ -98,7 +96,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
if (!sh_pages_info) {
- dev_err(hyper_dmabuf_private.device, "No more space left\n");
+ dev_err(hy_drv_priv->dev, "No more space left\n");
return -ENOMEM;
}
@@ -107,10 +105,10 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
/* share data pages in readonly mode for security */
for (i=0; i<nents; i++) {
lvl2_table[i] = gnttab_grant_foreign_access(domid,
- pfn_to_mfn(page_to_pfn(pages[i])),
- true /* read-only from remote domain */);
+ pfn_to_mfn(page_to_pfn(pages[i])),
+ true /* read-only from remote domain */);
if (lvl2_table[i] == -ENOSPC) {
- dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
+ dev_err(hy_drv_priv->dev, "No more space left in grant table\n");
/* Unshare all already shared pages for lvl2 */
while(i--) {
@@ -124,10 +122,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
/* Share 2nd level addressing pages in readonly mode*/
for (i=0; i< n_lvl2_grefs; i++) {
lvl3_table[i] = gnttab_grant_foreign_access(domid,
- virt_to_mfn((unsigned long)lvl2_table+i*PAGE_SIZE ),
- true);
+ virt_to_mfn((unsigned long)lvl2_table+i*PAGE_SIZE ),
+ true);
+
if (lvl3_table[i] == -ENOSPC) {
- dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
+ dev_err(hy_drv_priv->dev, "No more space left in grant table\n");
/* Unshare all already shared pages for lvl3 */
while(i--) {
@@ -147,11 +146,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
/* Share lvl3_table in readonly mode*/
lvl3_gref = gnttab_grant_foreign_access(domid,
- virt_to_mfn((unsigned long)lvl3_table),
- true);
+ virt_to_mfn((unsigned long)lvl3_table),
+ true);
if (lvl3_gref == -ENOSPC) {
- dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
+ dev_err(hy_drv_priv->dev, "No more space left in grant table\n");
/* Unshare all pages for lvl3 */
while(i--) {
@@ -178,7 +177,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
/* Store exported pages refid to be unshared later */
sh_pages_info->lvl3_gref = lvl3_gref;
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return lvl3_gref;
err_cleanup:
@@ -190,16 +189,17 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
struct xen_shared_pages_info *sh_pages_info;
- int n_lvl2_grefs = (nents/REFS_PER_PAGE + ((nents % REFS_PER_PAGE) ? 1: 0));
+ int n_lvl2_grefs = (nents/REFS_PER_PAGE +
+ ((nents % REFS_PER_PAGE) ? 1: 0));
int i;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
if (sh_pages_info->lvl3_table == NULL ||
sh_pages_info->lvl2_table == NULL ||
sh_pages_info->lvl3_gref == -1) {
- dev_warn(hyper_dmabuf_private.device,
+ dev_warn(hy_drv_priv->dev,
"gref table for hyper_dmabuf already cleaned up\n");
return 0;
}
@@ -207,7 +207,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
/* End foreign access for data pages, but do not free them */
for (i = 0; i < nents; i++) {
if (gnttab_query_foreign_access(sh_pages_info->lvl2_table[i])) {
- dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n");
+ dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
}
gnttab_end_foreign_access_ref(sh_pages_info->lvl2_table[i], 0);
gnttab_free_grant_reference(sh_pages_info->lvl2_table[i]);
@@ -216,17 +216,17 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
/* End foreign access for 2nd level addressing pages */
for (i = 0; i < n_lvl2_grefs; i++) {
if (gnttab_query_foreign_access(sh_pages_info->lvl3_table[i])) {
- dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n");
+ dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
}
if (!gnttab_end_foreign_access_ref(sh_pages_info->lvl3_table[i], 1)) {
- dev_warn(hyper_dmabuf_private.device, "refid still in use!!!\n");
+ dev_warn(hy_drv_priv->dev, "refid still in use!!!\n");
}
gnttab_free_grant_reference(sh_pages_info->lvl3_table[i]);
}
/* End foreign access for top level addressing page */
if (gnttab_query_foreign_access(sh_pages_info->lvl3_gref)) {
- dev_warn(hyper_dmabuf_private.device, "gref not shared !!\n");
+ dev_warn(hy_drv_priv->dev, "gref not shared !!\n");
}
gnttab_end_foreign_access_ref(sh_pages_info->lvl3_gref, 1);
@@ -242,7 +242,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
kfree(sh_pages_info);
sh_pages_info = NULL;
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return 0;
}
@@ -270,27 +270,33 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
/* # of grefs in the last page of lvl2 table */
int nents_last = (nents - 1) % REFS_PER_PAGE + 1;
- int n_lvl2_grefs = (nents / REFS_PER_PAGE) + ((nents_last > 0) ? 1 : 0) -
+ int n_lvl2_grefs = (nents / REFS_PER_PAGE) +
+ ((nents_last > 0) ? 1 : 0) -
(nents_last == REFS_PER_PAGE);
int i, j, k;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
*refs_info = (void *) sh_pages_info;
- lvl2_table_pages = kcalloc(sizeof(struct page*), n_lvl2_grefs, GFP_KERNEL);
+ lvl2_table_pages = kcalloc(sizeof(struct page*), n_lvl2_grefs,
+ GFP_KERNEL);
+
data_pages = kcalloc(sizeof(struct page*), nents, GFP_KERNEL);
- lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs, GFP_KERNEL);
- lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs, GFP_KERNEL);
+ lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs,
+ GFP_KERNEL);
+
+ lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs,
+ GFP_KERNEL);
data_map_ops = kcalloc(sizeof(*data_map_ops), nents, GFP_KERNEL);
data_unmap_ops = kcalloc(sizeof(*data_unmap_ops), nents, GFP_KERNEL);
/* Map top level addressing page */
if (gnttab_alloc_pages(1, &lvl3_table_page)) {
- dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
+ dev_err(hy_drv_priv->dev, "Cannot allocate pages\n");
return NULL;
}
@@ -304,13 +310,16 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
GNTMAP_host_map | GNTMAP_readonly, -1);
if (gnttab_map_refs(&lvl3_map_ops, NULL, &lvl3_table_page, 1)) {
- dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed");
+ dev_err(hy_drv_priv->dev,
+ "HYPERVISOR map grant ref failed");
return NULL;
}
if (lvl3_map_ops.status) {
- dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed status = %d",
+ dev_err(hy_drv_priv->dev,
+ "HYPERVISOR map grant ref failed status = %d",
lvl3_map_ops.status);
+
goto error_cleanup_lvl3;
} else {
lvl3_unmap_ops.handle = lvl3_map_ops.handle;
@@ -318,35 +327,43 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
/* Map all second level pages */
if (gnttab_alloc_pages(n_lvl2_grefs, lvl2_table_pages)) {
- dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
+ dev_err(hy_drv_priv->dev, "Cannot allocate pages\n");
goto error_cleanup_lvl3;
}
for (i = 0; i < n_lvl2_grefs; i++) {
lvl2_table = (grant_ref_t *)pfn_to_kaddr(page_to_pfn(lvl2_table_pages[i]));
- gnttab_set_map_op(&lvl2_map_ops[i], (unsigned long)lvl2_table, GNTMAP_host_map | GNTMAP_readonly,
+ gnttab_set_map_op(&lvl2_map_ops[i],
+ (unsigned long)lvl2_table, GNTMAP_host_map |
+ GNTMAP_readonly,
lvl3_table[i], domid);
- gnttab_set_unmap_op(&lvl2_unmap_ops[i], (unsigned long)lvl2_table, GNTMAP_host_map | GNTMAP_readonly, -1);
+ gnttab_set_unmap_op(&lvl2_unmap_ops[i],
+ (unsigned long)lvl2_table, GNTMAP_host_map |
+ GNTMAP_readonly, -1);
}
/* Unmap top level page, as it won't be needed any longer */
- if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1)) {
- dev_err(hyper_dmabuf_private.device, "xen: cannot unmap top level page\n");
+ if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL,
+ &lvl3_table_page, 1)) {
+ dev_err(hy_drv_priv->dev,
+ "xen: cannot unmap top level page\n");
return NULL;
} else {
/* Mark that page was unmapped */
lvl3_unmap_ops.handle = -1;
}
- if (gnttab_map_refs(lvl2_map_ops, NULL, lvl2_table_pages, n_lvl2_grefs)) {
- dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed");
+ if (gnttab_map_refs(lvl2_map_ops, NULL,
+ lvl2_table_pages, n_lvl2_grefs)) {
+ dev_err(hy_drv_priv->dev,
+ "HYPERVISOR map grant ref failed");
return NULL;
}
/* Checks if pages were mapped correctly */
for (i = 0; i < n_lvl2_grefs; i++) {
if (lvl2_map_ops[i].status) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"HYPERVISOR map grant ref failed status = %d",
lvl2_map_ops[i].status);
goto error_cleanup_lvl2;
@@ -356,7 +373,8 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
}
if (gnttab_alloc_pages(nents, data_pages)) {
- dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
+ dev_err(hy_drv_priv->dev,
+ "Cannot allocate pages\n");
goto error_cleanup_lvl2;
}
@@ -366,13 +384,13 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
lvl2_table = pfn_to_kaddr(page_to_pfn(lvl2_table_pages[i]));
for (j = 0; j < REFS_PER_PAGE; j++) {
gnttab_set_map_op(&data_map_ops[k],
- (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
- GNTMAP_host_map | GNTMAP_readonly,
- lvl2_table[j], domid);
+ (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
+ GNTMAP_host_map | GNTMAP_readonly,
+ lvl2_table[j], domid);
gnttab_set_unmap_op(&data_unmap_ops[k],
- (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
- GNTMAP_host_map | GNTMAP_readonly, -1);
+ (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
+ GNTMAP_host_map | GNTMAP_readonly, -1);
k++;
}
}
@@ -382,25 +400,29 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
for (j = 0; j < nents_last; j++) {
gnttab_set_map_op(&data_map_ops[k],
- (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
- GNTMAP_host_map | GNTMAP_readonly,
- lvl2_table[j], domid);
+ (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
+ GNTMAP_host_map | GNTMAP_readonly,
+ lvl2_table[j], domid);
gnttab_set_unmap_op(&data_unmap_ops[k],
- (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
- GNTMAP_host_map | GNTMAP_readonly, -1);
+ (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
+ GNTMAP_host_map | GNTMAP_readonly, -1);
k++;
}
- if (gnttab_map_refs(data_map_ops, NULL, data_pages, nents)) {
- dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed\n");
+ if (gnttab_map_refs(data_map_ops, NULL,
+ data_pages, nents)) {
+ dev_err(hy_drv_priv->dev,
+ "HYPERVISOR map grant ref failed\n");
return NULL;
}
/* unmapping lvl2 table pages */
- if (gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages,
+ if (gnttab_unmap_refs(lvl2_unmap_ops,
+ NULL, lvl2_table_pages,
n_lvl2_grefs)) {
- dev_err(hyper_dmabuf_private.device, "Cannot unmap 2nd level refs\n");
+ dev_err(hy_drv_priv->dev,
+ "Cannot unmap 2nd level refs\n");
return NULL;
} else {
/* Mark that pages were unmapped */
@@ -411,7 +433,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
for (i = 0; i < nents; i++) {
if (data_map_ops[i].status) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"HYPERVISOR map grant ref failed status = %d\n",
data_map_ops[i].status);
goto error_cleanup_data;
@@ -431,7 +453,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
kfree(lvl2_unmap_ops);
kfree(data_map_ops);
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return data_pages;
error_cleanup_data:
@@ -442,13 +464,14 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
error_cleanup_lvl2:
if (lvl2_unmap_ops[0].handle != -1)
- gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages,
- n_lvl2_grefs);
+ gnttab_unmap_refs(lvl2_unmap_ops, NULL,
+ lvl2_table_pages, n_lvl2_grefs);
gnttab_free_pages(n_lvl2_grefs, lvl2_table_pages);
error_cleanup_lvl3:
if (lvl3_unmap_ops.handle != -1)
- gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1);
+ gnttab_unmap_refs(&lvl3_unmap_ops, NULL,
+ &lvl3_table_page, 1);
gnttab_free_pages(1, &lvl3_table_page);
kfree(lvl2_table_pages);
@@ -463,20 +486,20 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
struct xen_shared_pages_info *sh_pages_info;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
if (sh_pages_info->unmap_ops == NULL ||
sh_pages_info->data_pages == NULL) {
- dev_warn(hyper_dmabuf_private.device,
- "Imported pages already cleaned up or buffer was not imported yet\n");
+ dev_warn(hy_drv_priv->dev,
+ "pages already cleaned up or buffer not imported yet\n");
return 0;
}
if (gnttab_unmap_refs(sh_pages_info->unmap_ops, NULL,
sh_pages_info->data_pages, nents) ) {
- dev_err(hyper_dmabuf_private.device, "Cannot unmap data pages\n");
+ dev_err(hy_drv_priv->dev, "Cannot unmap data pages\n");
return -EFAULT;
}
@@ -489,6 +512,6 @@ int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
kfree(sh_pages_info);
sh_pages_info = NULL;
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return 0;
}
--
2.7.4
WARNING: multiple messages have this Message-ID (diff)
From: Dongwon Kim <dongwon.kim@intel.com>
To: linux-kernel@vger.kernel.org
Cc: xen-devel@lists.xenproject.org, mateuszx.potrola@intel.com,
dri-devel@lists.freedesktop.org, dongwon.kim@intel.com
Subject: [RFC PATCH 49/60] hyper_dmabuf: general clean-up and fixes
Date: Tue, 19 Dec 2017 11:30:05 -0800 [thread overview]
Message-ID: <1513711816-2618-49-git-send-email-dongwon.kim@intel.com> (raw)
In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com>
1. global hyper_dmabuf_private is now pointer(*hy_drv_priv)
pointing to private data structure initialized when driver
is initialized. This is freed when driver exits.
2. using shorter variable and type's names
3. remove unnecessary NULL checks
4. event-polling related funcs are now compiled only if
CONFIG_HYPER_DMABUF_EVENT_GEN is enabled.
Signed-off-by: Dongwon Kim <dongwon.kim@intel.com>
---
drivers/xen/hyper_dmabuf/Makefile | 7 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h | 25 -
drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 164 +++---
drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 13 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c | 60 +--
drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c | 16 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 569 ++++++++++-----------
drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h | 2 +
drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c | 88 ++--
drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h | 18 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 259 +++++-----
drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 18 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c | 284 +++++-----
drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h | 4 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c | 58 +--
drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h | 4 +-
.../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 170 +++---
drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c | 123 ++---
drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h | 10 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 24 +-
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 240 +++++----
.../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c | 6 +-
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c | 147 +++---
23 files changed, 1144 insertions(+), 1165 deletions(-)
delete mode 100644 drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
diff --git a/drivers/xen/hyper_dmabuf/Makefile b/drivers/xen/hyper_dmabuf/Makefile
index 1cd7a81..a113bfc 100644
--- a/drivers/xen/hyper_dmabuf/Makefile
+++ b/drivers/xen/hyper_dmabuf/Makefile
@@ -13,9 +13,12 @@ ifneq ($(KERNELRELEASE),)
hyper_dmabuf_id.o \
hyper_dmabuf_remote_sync.o \
hyper_dmabuf_query.o \
- hyper_dmabuf_event.o \
-ifeq ($(CONFIG_XEN), y)
+ifeq ($(CONFIG_HYPER_DMABUF_EVENT_GEN), y)
+ $(TARGET_MODULE)-objs += hyper_dmabuf_event.o
+endif
+
+ifeq ($(CONFIG_HYPER_DMABUF_XEN), y)
$(TARGET_MODULE)-objs += xen/hyper_dmabuf_xen_comm.o \
xen/hyper_dmabuf_xen_comm_list.o \
xen/hyper_dmabuf_xen_shm.o \
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
deleted file mode 100644
index d5125f2..0000000
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Copyright © 2017 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- *
- */
-
-/* configuration */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
index 1c35a59..525ee78 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
@@ -36,7 +36,6 @@
#include <linux/poll.h>
#include <linux/dma-buf.h>
#include "hyper_dmabuf_drv.h"
-#include "hyper_dmabuf_conf.h"
#include "hyper_dmabuf_ioctl.h"
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_list.h"
@@ -51,13 +50,32 @@ extern struct hyper_dmabuf_backend_ops xen_backend_ops;
MODULE_LICENSE("GPL and additional rights");
MODULE_AUTHOR("Intel Corporation");
-struct hyper_dmabuf_private hyper_dmabuf_private;
+struct hyper_dmabuf_private *hy_drv_priv;
long hyper_dmabuf_ioctl(struct file *filp,
unsigned int cmd, unsigned long param);
-void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* sgt_info,
- void *attr);
+static void hyper_dmabuf_force_free(struct exported_sgt_info* exported,
+ void *attr)
+{
+ struct ioctl_hyper_dmabuf_unexport unexport_attr;
+ struct file *filp = (struct file*) attr;
+
+ if (!filp || !exported)
+ return;
+
+ if (exported->filp == filp) {
+ dev_dbg(hy_drv_priv->dev,
+ "Forcefully releasing buffer {id:%d key:%d %d %d}\n",
+ exported->hid.id, exported->hid.rng_key[0],
+ exported->hid.rng_key[1], exported->hid.rng_key[2]);
+
+ unexport_attr.hid = exported->hid;
+ unexport_attr.delay_ms = 0;
+
+ hyper_dmabuf_unexport_ioctl(filp, &unexport_attr);
+ }
+}
int hyper_dmabuf_open(struct inode *inode, struct file *filp)
{
@@ -72,18 +90,20 @@ int hyper_dmabuf_open(struct inode *inode, struct file *filp)
int hyper_dmabuf_release(struct inode *inode, struct file *filp)
{
- hyper_dmabuf_foreach_exported(hyper_dmabuf_emergency_release, filp);
+ hyper_dmabuf_foreach_exported(hyper_dmabuf_force_free, filp);
return 0;
}
+#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
+
unsigned int hyper_dmabuf_event_poll(struct file *filp, struct poll_table_struct *wait)
{
unsigned int mask = 0;
- poll_wait(filp, &hyper_dmabuf_private.event_wait, wait);
+ poll_wait(filp, &hy_drv_priv->event_wait, wait);
- if (!list_empty(&hyper_dmabuf_private.event_list))
+ if (!list_empty(&hy_drv_priv->event_list))
mask |= POLLIN | POLLRDNORM;
return mask;
@@ -96,32 +116,32 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
/* only root can read events */
if (!capable(CAP_DAC_OVERRIDE)) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Only root can read events\n");
return -EFAULT;
}
/* make sure user buffer can be written */
if (!access_ok(VERIFY_WRITE, buffer, count)) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"User buffer can't be written.\n");
return -EFAULT;
}
- ret = mutex_lock_interruptible(&hyper_dmabuf_private.event_read_lock);
+ ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock);
if (ret)
return ret;
while (1) {
struct hyper_dmabuf_event *e = NULL;
- spin_lock_irq(&hyper_dmabuf_private.event_lock);
- if (!list_empty(&hyper_dmabuf_private.event_list)) {
- e = list_first_entry(&hyper_dmabuf_private.event_list,
+ spin_lock_irq(&hy_drv_priv->event_lock);
+ if (!list_empty(&hy_drv_priv->event_list)) {
+ e = list_first_entry(&hy_drv_priv->event_list,
struct hyper_dmabuf_event, link);
list_del(&e->link);
}
- spin_unlock_irq(&hyper_dmabuf_private.event_lock);
+ spin_unlock_irq(&hy_drv_priv->event_lock);
if (!e) {
if (ret)
@@ -131,12 +151,12 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
break;
}
- mutex_unlock(&hyper_dmabuf_private.event_read_lock);
- ret = wait_event_interruptible(hyper_dmabuf_private.event_wait,
- !list_empty(&hyper_dmabuf_private.event_list));
+ mutex_unlock(&hy_drv_priv->event_read_lock);
+ ret = wait_event_interruptible(hy_drv_priv->event_wait,
+ !list_empty(&hy_drv_priv->event_list));
if (ret == 0)
- ret = mutex_lock_interruptible(&hyper_dmabuf_private.event_read_lock);
+ ret = mutex_lock_interruptible(&hy_drv_priv->event_read_lock);
if (ret)
return ret;
@@ -145,9 +165,9 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
if (length > count - ret) {
put_back_event:
- spin_lock_irq(&hyper_dmabuf_private.event_lock);
- list_add(&e->link, &hyper_dmabuf_private.event_list);
- spin_unlock_irq(&hyper_dmabuf_private.event_lock);
+ spin_lock_irq(&hy_drv_priv->event_lock);
+ list_add(&e->link, &hy_drv_priv->event_list);
+ spin_unlock_irq(&hy_drv_priv->event_lock);
break;
}
@@ -170,7 +190,7 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
/* nullifying hdr of the event in user buffer */
if (copy_to_user(buffer + ret, &dummy_hdr,
sizeof(dummy_hdr))) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"failed to nullify invalid hdr already in userspace\n");
}
@@ -180,23 +200,30 @@ ssize_t hyper_dmabuf_event_read(struct file *filp, char __user *buffer,
}
ret += e->event_data.hdr.size;
- hyper_dmabuf_private.curr_num_event--;
+ hy_drv_priv->pending--;
kfree(e);
}
}
- mutex_unlock(&hyper_dmabuf_private.event_read_lock);
+ mutex_unlock(&hy_drv_priv->event_read_lock);
return ret;
}
+#endif
+
static struct file_operations hyper_dmabuf_driver_fops =
{
.owner = THIS_MODULE,
.open = hyper_dmabuf_open,
.release = hyper_dmabuf_release,
+
+/* poll and read interfaces are needed only for event-polling */
+#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
.read = hyper_dmabuf_event_read,
.poll = hyper_dmabuf_event_poll,
+#endif
+
.unlocked_ioctl = hyper_dmabuf_ioctl,
};
@@ -217,17 +244,17 @@ int register_device(void)
return ret;
}
- hyper_dmabuf_private.device = hyper_dmabuf_miscdev.this_device;
+ hy_drv_priv->dev = hyper_dmabuf_miscdev.this_device;
/* TODO: Check if there is a different way to initialize dma mask nicely */
- dma_coerce_mask_and_coherent(hyper_dmabuf_private.device, DMA_BIT_MASK(64));
+ dma_coerce_mask_and_coherent(hy_drv_priv->dev, DMA_BIT_MASK(64));
return ret;
}
void unregister_device(void)
{
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"hyper_dmabuf: unregister_device() is called\n");
misc_deregister(&hyper_dmabuf_miscdev);
@@ -239,9 +266,13 @@ static int __init hyper_dmabuf_drv_init(void)
printk( KERN_NOTICE "hyper_dmabuf_starting: Initialization started\n");
- mutex_init(&hyper_dmabuf_private.lock);
- mutex_init(&hyper_dmabuf_private.event_read_lock);
- spin_lock_init(&hyper_dmabuf_private.event_lock);
+ hy_drv_priv = kcalloc(1, sizeof(struct hyper_dmabuf_private),
+ GFP_KERNEL);
+
+ if (!hy_drv_priv) {
+ printk( KERN_ERR "hyper_dmabuf: Failed to create drv\n");
+ return -1;
+ }
ret = register_device();
if (ret < 0) {
@@ -251,64 +282,72 @@ static int __init hyper_dmabuf_drv_init(void)
/* currently only supports XEN hypervisor */
#ifdef CONFIG_HYPER_DMABUF_XEN
- hyper_dmabuf_private.backend_ops = &xen_backend_ops;
+ hy_drv_priv->backend_ops = &xen_backend_ops;
#else
- hyper_dmabuf_private.backend_ops = NULL;
+ hy_drv_priv->backend_ops = NULL;
printk( KERN_ERR "hyper_dmabuf drv currently supports XEN only.\n");
#endif
- if (hyper_dmabuf_private.backend_ops == NULL) {
+ if (hy_drv_priv->backend_ops == NULL) {
printk( KERN_ERR "Hyper_dmabuf: failed to be loaded - no backend found\n");
return -1;
}
- mutex_lock(&hyper_dmabuf_private.lock);
+ /* initializing mutexes and a spinlock */
+ mutex_init(&hy_drv_priv->lock);
+
+ mutex_lock(&hy_drv_priv->lock);
- hyper_dmabuf_private.backend_initialized = false;
+ hy_drv_priv->initialized = false;
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"initializing database for imported/exported dmabufs\n");
/* device structure initialization */
/* currently only does work-queue initialization */
- hyper_dmabuf_private.work_queue = create_workqueue("hyper_dmabuf_wqueue");
+ hy_drv_priv->work_queue = create_workqueue("hyper_dmabuf_wqueue");
ret = hyper_dmabuf_table_init();
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"failed to initialize table for exported/imported entries\n");
return ret;
}
#ifdef CONFIG_HYPER_DMABUF_SYSFS
- ret = hyper_dmabuf_register_sysfs(hyper_dmabuf_private.device);
+ ret = hyper_dmabuf_register_sysfs(hy_drv_priv->dev);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"failed to initialize sysfs\n");
return ret;
}
#endif
+#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
+ mutex_init(&hy_drv_priv->event_read_lock);
+ spin_lock_init(&hy_drv_priv->event_lock);
+
/* Initialize event queue */
- INIT_LIST_HEAD(&hyper_dmabuf_private.event_list);
- init_waitqueue_head(&hyper_dmabuf_private.event_wait);
+ INIT_LIST_HEAD(&hy_drv_priv->event_list);
+ init_waitqueue_head(&hy_drv_priv->event_wait);
- hyper_dmabuf_private.curr_num_event = 0;
- hyper_dmabuf_private.exited = false;
+ /* resetting number of pending events */
+ hy_drv_priv->pending = 0;
+#endif
- hyper_dmabuf_private.domid = hyper_dmabuf_private.backend_ops->get_vm_id();
+ hy_drv_priv->domid = hy_drv_priv->backend_ops->get_vm_id();
- ret = hyper_dmabuf_private.backend_ops->init_comm_env();
+ ret = hy_drv_priv->backend_ops->init_comm_env();
if (ret < 0) {
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"failed to initialize comm-env but it will re-attempt.\n");
} else {
- hyper_dmabuf_private.backend_initialized = true;
+ hy_drv_priv->initialized = true;
}
- mutex_unlock(&hyper_dmabuf_private.lock);
+ mutex_unlock(&hy_drv_priv->lock);
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Finishing up initialization of hyper_dmabuf drv\n");
/* interrupt for comm should be registered here: */
@@ -318,34 +357,39 @@ static int __init hyper_dmabuf_drv_init(void)
static void hyper_dmabuf_drv_exit(void)
{
#ifdef CONFIG_HYPER_DMABUF_SYSFS
- hyper_dmabuf_unregister_sysfs(hyper_dmabuf_private.device);
+ hyper_dmabuf_unregister_sysfs(hy_drv_priv->dev);
#endif
- mutex_lock(&hyper_dmabuf_private.lock);
+ mutex_lock(&hy_drv_priv->lock);
/* hash tables for export/import entries and ring_infos */
hyper_dmabuf_table_destroy();
- hyper_dmabuf_private.backend_ops->destroy_comm();
+ hy_drv_priv->backend_ops->destroy_comm();
/* destroy workqueue */
- if (hyper_dmabuf_private.work_queue)
- destroy_workqueue(hyper_dmabuf_private.work_queue);
+ if (hy_drv_priv->work_queue)
+ destroy_workqueue(hy_drv_priv->work_queue);
/* destroy id_queue */
- if (hyper_dmabuf_private.id_queue)
+ if (hy_drv_priv->id_queue)
destroy_reusable_list();
- hyper_dmabuf_private.exited = true;
-
+#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
/* clean up event queue */
hyper_dmabuf_events_release();
+#endif
- mutex_unlock(&hyper_dmabuf_private.lock);
+ mutex_unlock(&hy_drv_priv->lock);
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"hyper_dmabuf driver: Exiting\n");
+ if (hy_drv_priv) {
+ kfree(hy_drv_priv);
+ hy_drv_priv = NULL;
+ }
+
unregister_device();
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
index a4acdd9f..2ead41b 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
@@ -36,7 +36,7 @@ struct hyper_dmabuf_event {
};
struct hyper_dmabuf_private {
- struct device *device;
+ struct device *dev;
/* VM(domain) id of current VM instance */
int domid;
@@ -55,7 +55,7 @@ struct hyper_dmabuf_private {
struct mutex lock;
/* flag that shows whether backend is initialized */
- bool backend_initialized;
+ bool initialized;
wait_queue_head_t event_wait;
struct list_head event_list;
@@ -63,10 +63,8 @@ struct hyper_dmabuf_private {
spinlock_t event_lock;
struct mutex event_read_lock;
- int curr_num_event;
-
- /* indicate whether the driver is unloaded */
- bool exited;
+ /* # of pending events */
+ int pending;
};
struct list_reusable_id {
@@ -108,4 +106,7 @@ struct hyper_dmabuf_backend_ops {
int (*send_req)(int, struct hyper_dmabuf_req *, int);
};
+/* exporting global drv private info */
+extern struct hyper_dmabuf_private *hy_drv_priv;
+
#endif /* __LINUX_PUBLIC_HYPER_DMABUF_DRV_H__ */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
index 3e1498c..0498cda 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_event.c
@@ -32,37 +32,33 @@
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/dma-buf.h>
-#include <xen/grant_table.h>
-#include <asm/xen/page.h>
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_list.h"
#include "hyper_dmabuf_event.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
static void hyper_dmabuf_send_event_locked(struct hyper_dmabuf_event *e)
{
struct hyper_dmabuf_event *oldest;
- assert_spin_locked(&hyper_dmabuf_private.event_lock);
+ assert_spin_locked(&hy_drv_priv->event_lock);
/* check current number of event then if it hits the max num allowed
* then remove the oldest event in the list */
- if (hyper_dmabuf_private.curr_num_event > MAX_DEPTH_EVENT_QUEUE - 1) {
- oldest = list_first_entry(&hyper_dmabuf_private.event_list,
+ if (hy_drv_priv->pending > MAX_DEPTH_EVENT_QUEUE - 1) {
+ oldest = list_first_entry(&hy_drv_priv->event_list,
struct hyper_dmabuf_event, link);
list_del(&oldest->link);
- hyper_dmabuf_private.curr_num_event--;
+ hy_drv_priv->pending--;
kfree(oldest);
}
list_add_tail(&e->link,
- &hyper_dmabuf_private.event_list);
+ &hy_drv_priv->event_list);
- hyper_dmabuf_private.curr_num_event++;
+ hy_drv_priv->pending++;
- wake_up_interruptible(&hyper_dmabuf_private.event_wait);
+ wake_up_interruptible(&hy_drv_priv->event_wait);
}
void hyper_dmabuf_events_release()
@@ -70,34 +66,34 @@ void hyper_dmabuf_events_release()
struct hyper_dmabuf_event *e, *et;
unsigned long irqflags;
- spin_lock_irqsave(&hyper_dmabuf_private.event_lock, irqflags);
+ spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags);
- list_for_each_entry_safe(e, et, &hyper_dmabuf_private.event_list,
+ list_for_each_entry_safe(e, et, &hy_drv_priv->event_list,
link) {
list_del(&e->link);
kfree(e);
- hyper_dmabuf_private.curr_num_event--;
+ hy_drv_priv->pending--;
}
- if (hyper_dmabuf_private.curr_num_event) {
- dev_err(hyper_dmabuf_private.device,
+ if (hy_drv_priv->pending) {
+ dev_err(hy_drv_priv->dev,
"possible leak on event_list\n");
}
- spin_unlock_irqrestore(&hyper_dmabuf_private.event_lock, irqflags);
+ spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags);
}
int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid)
{
struct hyper_dmabuf_event *e;
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
+ struct imported_sgt_info *imported;
unsigned long irqflags;
- imported_sgt_info = hyper_dmabuf_find_imported(hid);
+ imported = hyper_dmabuf_find_imported(hid);
- if (!imported_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!imported) {
+ dev_err(hy_drv_priv->dev,
"can't find imported_sgt_info in the list\n");
return -EINVAL;
}
@@ -105,29 +101,29 @@ int hyper_dmabuf_import_event(hyper_dmabuf_id_t hid)
e = kzalloc(sizeof(*e), GFP_KERNEL);
if (!e) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"no space left\n");
return -ENOMEM;
}
e->event_data.hdr.event_type = HYPER_DMABUF_NEW_IMPORT;
e->event_data.hdr.hid = hid;
- e->event_data.data = (void*)imported_sgt_info->priv;
- e->event_data.hdr.size = imported_sgt_info->sz_priv;
+ e->event_data.data = (void*)imported->priv;
+ e->event_data.hdr.size = imported->sz_priv;
- spin_lock_irqsave(&hyper_dmabuf_private.event_lock, irqflags);
+ spin_lock_irqsave(&hy_drv_priv->event_lock, irqflags);
hyper_dmabuf_send_event_locked(e);
- spin_unlock_irqrestore(&hyper_dmabuf_private.event_lock, irqflags);
+ spin_unlock_irqrestore(&hy_drv_priv->event_lock, irqflags);
- dev_dbg(hyper_dmabuf_private.device,
- "event number = %d :", hyper_dmabuf_private.curr_num_event);
+ dev_dbg(hy_drv_priv->dev,
+ "event number = %d :", hy_drv_priv->pending);
- dev_dbg(hyper_dmabuf_private.device,
- "generating events for {%d, %d, %d, %d}\n",
- imported_sgt_info->hid.id, imported_sgt_info->hid.rng_key[0],
- imported_sgt_info->hid.rng_key[1], imported_sgt_info->hid.rng_key[2]);
+ dev_dbg(hy_drv_priv->dev,
+ "generating events for {%d, %d, %d, %d}\n",
+ imported->hid.id, imported->hid.rng_key[0],
+ imported->hid.rng_key[1], imported->hid.rng_key[2]);
return 0;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
index cccdc19..e2466c7 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
@@ -33,17 +33,15 @@
#include "hyper_dmabuf_id.h"
#include "hyper_dmabuf_msg.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
void store_reusable_hid(hyper_dmabuf_id_t hid)
{
- struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
+ struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
struct list_reusable_id *new_reusable;
new_reusable = kmalloc(sizeof(*new_reusable), GFP_KERNEL);
if (!new_reusable) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return;
}
@@ -55,7 +53,7 @@ void store_reusable_hid(hyper_dmabuf_id_t hid)
static hyper_dmabuf_id_t retrieve_reusable_hid(void)
{
- struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
+ struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
hyper_dmabuf_id_t hid = {-1, {0,0,0}};
/* check there is reusable id */
@@ -74,7 +72,7 @@ static hyper_dmabuf_id_t retrieve_reusable_hid(void)
void destroy_reusable_list(void)
{
- struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
+ struct list_reusable_id *reusable_head = hy_drv_priv->id_queue;
struct list_reusable_id *temp_head;
if (reusable_head) {
@@ -103,14 +101,14 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
reusable_head = kmalloc(sizeof(*reusable_head), GFP_KERNEL);
if (!reusable_head) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return (hyper_dmabuf_id_t){-1, {0,0,0}};
}
reusable_head->hid.id = -1; /* list head has an invalid count */
INIT_LIST_HEAD(&reusable_head->list);
- hyper_dmabuf_private.id_queue = reusable_head;
+ hy_drv_priv->id_queue = reusable_head;
}
hid = retrieve_reusable_hid();
@@ -119,7 +117,7 @@ hyper_dmabuf_id_t hyper_dmabuf_get_hid(void)
* and count is less than maximum allowed
*/
if (hid.id == -1 && count < HYPER_DMABUF_ID_MAX) {
- hid.id = HYPER_DMABUF_ID_CREATE(hyper_dmabuf_private.domid, count++);
+ hid.id = HYPER_DMABUF_ID_CREATE(hy_drv_priv->domid, count++);
}
/* random data embedded in the id for security */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
index 15191c2..b328df7 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
@@ -45,16 +45,14 @@
#include "hyper_dmabuf_ops.h"
#include "hyper_dmabuf_query.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data)
{
struct ioctl_hyper_dmabuf_tx_ch_setup *tx_ch_attr;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
int ret = 0;
if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
+ dev_err(hy_drv_priv->dev, "user data is NULL\n");
return -EINVAL;
}
tx_ch_attr = (struct ioctl_hyper_dmabuf_tx_ch_setup *)data;
@@ -67,11 +65,11 @@ static int hyper_dmabuf_tx_ch_setup_ioctl(struct file *filp, void *data)
static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data)
{
struct ioctl_hyper_dmabuf_rx_ch_setup *rx_ch_attr;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
int ret = 0;
if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
+ dev_err(hy_drv_priv->dev, "user data is NULL\n");
return -EINVAL;
}
@@ -82,48 +80,48 @@ static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data)
return ret;
}
-static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info,
- struct hyper_dmabuf_pages_info *page_info)
+static int hyper_dmabuf_send_export_msg(struct exported_sgt_info *exported,
+ struct pages_info *pg_info)
{
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
struct hyper_dmabuf_req *req;
- int operands[MAX_NUMBER_OF_OPERANDS] = {0};
+ int op[MAX_NUMBER_OF_OPERANDS] = {0};
int ret, i;
/* now create request for importer via ring */
- operands[0] = sgt_info->hid.id;
+ op[0] = exported->hid.id;
for (i=0; i<3; i++)
- operands[i+1] = sgt_info->hid.rng_key[i];
-
- if (page_info) {
- operands[4] = page_info->nents;
- operands[5] = page_info->frst_ofst;
- operands[6] = page_info->last_len;
- operands[7] = ops->share_pages (page_info->pages, sgt_info->hyper_dmabuf_rdomain,
- page_info->nents, &sgt_info->refs_info);
- if (operands[7] < 0) {
- dev_err(hyper_dmabuf_private.device, "pages sharing failed\n");
+ op[i+1] = exported->hid.rng_key[i];
+
+ if (pg_info) {
+ op[4] = pg_info->nents;
+ op[5] = pg_info->frst_ofst;
+ op[6] = pg_info->last_len;
+ op[7] = ops->share_pages(pg_info->pgs, exported->rdomid,
+ pg_info->nents, &exported->refs_info);
+ if (op[7] < 0) {
+ dev_err(hy_drv_priv->dev, "pages sharing failed\n");
return -1;
}
}
- operands[8] = sgt_info->sz_priv;
+ op[8] = exported->sz_priv;
/* driver/application specific private info */
- memcpy(&operands[9], sgt_info->priv, operands[8]);
+ memcpy(&op[9], exported->priv, op[8]);
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if(!req) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ dev_err(hy_drv_priv->dev, "no more space left\n");
return -1;
}
/* composing a message to the importer */
- hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT, &op[0]);
- ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true);
+ ret = ops->send_req(exported->rdomid, req, true);
kfree(req);
@@ -132,24 +130,18 @@ static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info,
static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
{
- struct ioctl_hyper_dmabuf_export_remote *export_remote_attr;
+ struct ioctl_hyper_dmabuf_export_remote *export_remote_attr =
+ (struct ioctl_hyper_dmabuf_export_remote *)data;
struct dma_buf *dma_buf;
struct dma_buf_attachment *attachment;
struct sg_table *sgt;
- struct hyper_dmabuf_pages_info *page_info;
- struct hyper_dmabuf_sgt_info *sgt_info;
+ struct pages_info *pg_info;
+ struct exported_sgt_info *exported;
hyper_dmabuf_id_t hid;
int ret = 0;
- if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
- return -EINVAL;
- }
-
- export_remote_attr = (struct ioctl_hyper_dmabuf_export_remote *)data;
-
- if (hyper_dmabuf_private.domid == export_remote_attr->remote_domain) {
- dev_err(hyper_dmabuf_private.device,
+ if (hy_drv_priv->domid == export_remote_attr->remote_domain) {
+ dev_err(hy_drv_priv->dev,
"exporting to the same VM is not permitted\n");
return -EINVAL;
}
@@ -157,7 +149,7 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
dma_buf = dma_buf_get(export_remote_attr->dmabuf_fd);
if (IS_ERR(dma_buf)) {
- dev_err(hyper_dmabuf_private.device, "Cannot get dma buf\n");
+ dev_err(hy_drv_priv->dev, "Cannot get dma buf\n");
return PTR_ERR(dma_buf);
}
@@ -165,69 +157,79 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
* to the same domain and if yes and it's valid sgt_info,
* it returns hyper_dmabuf_id of pre-exported sgt_info
*/
- hid = hyper_dmabuf_find_hid_exported(dma_buf, export_remote_attr->remote_domain);
+ hid = hyper_dmabuf_find_hid_exported(dma_buf,
+ export_remote_attr->remote_domain);
if (hid.id != -1) {
- sgt_info = hyper_dmabuf_find_exported(hid);
- if (sgt_info != NULL) {
- if (sgt_info->valid) {
+ exported = hyper_dmabuf_find_exported(hid);
+ if (exported != NULL) {
+ if (exported->valid) {
/*
* Check if unexport is already scheduled for that buffer,
* if so try to cancel it. If that will fail, buffer needs
* to be reexport once again.
*/
- if (sgt_info->unexport_scheduled) {
- if (!cancel_delayed_work_sync(&sgt_info->unexport_work)) {
+ if (exported->unexport_sched) {
+ if (!cancel_delayed_work_sync(&exported->unexport)) {
dma_buf_put(dma_buf);
goto reexport;
}
- sgt_info->unexport_scheduled = 0;
+ exported->unexport_sched = false;
}
/* if there's any change in size of private data.
* we reallocate space for private data with new size */
- if (export_remote_attr->sz_priv != sgt_info->sz_priv) {
- kfree(sgt_info->priv);
+ if (export_remote_attr->sz_priv != exported->sz_priv) {
+ kfree(exported->priv);
/* truncating size */
if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) {
- sgt_info->sz_priv = MAX_SIZE_PRIV_DATA;
+ exported->sz_priv = MAX_SIZE_PRIV_DATA;
} else {
- sgt_info->sz_priv = export_remote_attr->sz_priv;
+ exported->sz_priv = export_remote_attr->sz_priv;
}
- sgt_info->priv = kcalloc(1, sgt_info->sz_priv, GFP_KERNEL);
+ exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL);
- if(!sgt_info->priv) {
- dev_err(hyper_dmabuf_private.device,
- "Can't reallocate priv because there's no more space left\n");
- hyper_dmabuf_remove_exported(sgt_info->hid);
- hyper_dmabuf_cleanup_sgt_info(sgt_info, true);
- kfree(sgt_info);
+ if(!exported->priv) {
+ dev_err(hy_drv_priv->dev,
+ "no more space left for priv\n");
+ hyper_dmabuf_remove_exported(exported->hid);
+ hyper_dmabuf_cleanup_sgt_info(exported, true);
+ kfree(exported);
+ dma_buf_put(dma_buf);
return -ENOMEM;
}
}
/* update private data in sgt_info with new ones */
- copy_from_user(sgt_info->priv, export_remote_attr->priv, sgt_info->sz_priv);
-
- /* send an export msg for updating priv in importer */
- ret = hyper_dmabuf_send_export_msg(sgt_info, NULL);
-
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device, "Failed to send a new private data\n");
+ ret = copy_from_user(exported->priv, export_remote_attr->priv,
+ exported->sz_priv);
+ if (ret) {
+ dev_err(hy_drv_priv->dev,
+ "Failed to load a new private data\n");
+ ret = -EINVAL;
+ } else {
+ /* send an export msg for updating priv in importer */
+ ret = hyper_dmabuf_send_export_msg(exported, NULL);
+
+ if (ret < 0) {
+ dev_err(hy_drv_priv->dev,
+ "Failed to send a new private data\n");
+ ret = -EBUSY;
+ }
}
dma_buf_put(dma_buf);
export_remote_attr->hid = hid;
- return 0;
+ return ret;
}
}
}
reexport:
- attachment = dma_buf_attach(dma_buf, hyper_dmabuf_private.device);
+ attachment = dma_buf_attach(dma_buf, hy_drv_priv->dev);
if (IS_ERR(attachment)) {
- dev_err(hyper_dmabuf_private.device, "Cannot get attachment\n");
+ dev_err(hy_drv_priv->dev, "Cannot get attachment\n");
ret = PTR_ERR(attachment);
goto fail_attach;
}
@@ -235,154 +237,165 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL);
if (IS_ERR(sgt)) {
- dev_err(hyper_dmabuf_private.device, "Cannot map attachment\n");
+ dev_err(hy_drv_priv->dev, "Cannot map attachment\n");
ret = PTR_ERR(sgt);
goto fail_map_attachment;
}
- sgt_info = kcalloc(1, sizeof(*sgt_info), GFP_KERNEL);
+ exported = kcalloc(1, sizeof(*exported), GFP_KERNEL);
- if(!sgt_info) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ if(!exported) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_sgt_info_creation;
}
/* possible truncation */
if (export_remote_attr->sz_priv > MAX_SIZE_PRIV_DATA) {
- sgt_info->sz_priv = MAX_SIZE_PRIV_DATA;
+ exported->sz_priv = MAX_SIZE_PRIV_DATA;
} else {
- sgt_info->sz_priv = export_remote_attr->sz_priv;
+ exported->sz_priv = export_remote_attr->sz_priv;
}
/* creating buffer for private data of buffer */
- if(sgt_info->sz_priv != 0) {
- sgt_info->priv = kcalloc(1, sgt_info->sz_priv, GFP_KERNEL);
+ if(exported->sz_priv != 0) {
+ exported->priv = kcalloc(1, exported->sz_priv, GFP_KERNEL);
- if(!sgt_info->priv) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ if(!exported->priv) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_priv_creation;
}
} else {
- dev_err(hyper_dmabuf_private.device, "size is 0\n");
+ dev_err(hy_drv_priv->dev, "size is 0\n");
}
- sgt_info->hid = hyper_dmabuf_get_hid();
+ exported->hid = hyper_dmabuf_get_hid();
/* no more exported dmabuf allowed */
- if(sgt_info->hid.id == -1) {
- dev_err(hyper_dmabuf_private.device,
+ if(exported->hid.id == -1) {
+ dev_err(hy_drv_priv->dev,
"exceeds allowed number of dmabuf to be exported\n");
ret = -ENOMEM;
goto fail_sgt_info_creation;
}
- /* TODO: We might need to consider using port number on event channel? */
- sgt_info->hyper_dmabuf_rdomain = export_remote_attr->remote_domain;
- sgt_info->dma_buf = dma_buf;
- sgt_info->valid = 1;
+ exported->rdomid = export_remote_attr->remote_domain;
+ exported->dma_buf = dma_buf;
+ exported->valid = true;
- sgt_info->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL);
- if (!sgt_info->active_sgts) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ exported->active_sgts = kmalloc(sizeof(struct sgt_list), GFP_KERNEL);
+ if (!exported->active_sgts) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_map_active_sgts;
}
- sgt_info->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL);
- if (!sgt_info->active_attached) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ exported->active_attached = kmalloc(sizeof(struct attachment_list), GFP_KERNEL);
+ if (!exported->active_attached) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_map_active_attached;
}
- sgt_info->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL);
- if (!sgt_info->va_kmapped) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ exported->va_kmapped = kmalloc(sizeof(struct kmap_vaddr_list), GFP_KERNEL);
+ if (!exported->va_kmapped) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_map_va_kmapped;
}
- sgt_info->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL);
- if (!sgt_info->va_vmapped) {
- dev_err(hyper_dmabuf_private.device, "no more space left\n");
+ exported->va_vmapped = kmalloc(sizeof(struct vmap_vaddr_list), GFP_KERNEL);
+ if (!exported->va_vmapped) {
+ dev_err(hy_drv_priv->dev, "no more space left\n");
ret = -ENOMEM;
goto fail_map_va_vmapped;
}
- sgt_info->active_sgts->sgt = sgt;
- sgt_info->active_attached->attach = attachment;
- sgt_info->va_kmapped->vaddr = NULL;
- sgt_info->va_vmapped->vaddr = NULL;
+ exported->active_sgts->sgt = sgt;
+ exported->active_attached->attach = attachment;
+ exported->va_kmapped->vaddr = NULL;
+ exported->va_vmapped->vaddr = NULL;
/* initialize list of sgt, attachment and vaddr for dmabuf sync
* via shadow dma-buf
*/
- INIT_LIST_HEAD(&sgt_info->active_sgts->list);
- INIT_LIST_HEAD(&sgt_info->active_attached->list);
- INIT_LIST_HEAD(&sgt_info->va_kmapped->list);
- INIT_LIST_HEAD(&sgt_info->va_vmapped->list);
+ INIT_LIST_HEAD(&exported->active_sgts->list);
+ INIT_LIST_HEAD(&exported->active_attached->list);
+ INIT_LIST_HEAD(&exported->va_kmapped->list);
+ INIT_LIST_HEAD(&exported->va_vmapped->list);
/* copy private data to sgt_info */
- copy_from_user(sgt_info->priv, export_remote_attr->priv, sgt_info->sz_priv);
+ ret = copy_from_user(exported->priv, export_remote_attr->priv,
+ exported->sz_priv);
- page_info = hyper_dmabuf_ext_pgs(sgt);
- if (!page_info) {
- dev_err(hyper_dmabuf_private.device, "failed to construct page_info\n");
+ if (ret) {
+ dev_err(hy_drv_priv->dev,
+ "failed to load private data\n");
+ ret = -EINVAL;
goto fail_export;
}
- sgt_info->nents = page_info->nents;
+ pg_info = hyper_dmabuf_ext_pgs(sgt);
+ if (!pg_info) {
+ dev_err(hy_drv_priv->dev,
+ "failed to construct pg_info\n");
+ ret = -ENOMEM;
+ goto fail_export;
+ }
+
+ exported->nents = pg_info->nents;
/* now register it to export list */
- hyper_dmabuf_register_exported(sgt_info);
+ hyper_dmabuf_register_exported(exported);
- export_remote_attr->hid = sgt_info->hid;
+ export_remote_attr->hid = exported->hid;
- ret = hyper_dmabuf_send_export_msg(sgt_info, page_info);
+ ret = hyper_dmabuf_send_export_msg(exported, pg_info);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device, "failed to send out the export request\n");
+ dev_err(hy_drv_priv->dev,
+ "failed to send out the export request\n");
goto fail_send_request;
}
- /* free page_info */
- kfree(page_info->pages);
- kfree(page_info);
+ /* free pg_info */
+ kfree(pg_info->pgs);
+ kfree(pg_info);
- sgt_info->filp = filp;
+ exported->filp = filp;
return ret;
/* Clean-up if error occurs */
fail_send_request:
- hyper_dmabuf_remove_exported(sgt_info->hid);
+ hyper_dmabuf_remove_exported(exported->hid);
- /* free page_info */
- kfree(page_info->pages);
- kfree(page_info);
+ /* free pg_info */
+ kfree(pg_info->pgs);
+ kfree(pg_info);
fail_export:
- kfree(sgt_info->va_vmapped);
+ kfree(exported->va_vmapped);
fail_map_va_vmapped:
- kfree(sgt_info->va_kmapped);
+ kfree(exported->va_kmapped);
fail_map_va_kmapped:
- kfree(sgt_info->active_attached);
+ kfree(exported->active_attached);
fail_map_active_attached:
- kfree(sgt_info->active_sgts);
- kfree(sgt_info->priv);
+ kfree(exported->active_sgts);
+ kfree(exported->priv);
fail_priv_creation:
- kfree(sgt_info);
+ kfree(exported);
fail_map_active_sgts:
fail_sgt_info_creation:
- dma_buf_unmap_attachment(attachment, sgt, DMA_BIDIRECTIONAL);
+ dma_buf_unmap_attachment(attachment, sgt,
+ DMA_BIDIRECTIONAL);
fail_map_attachment:
dma_buf_detach(dma_buf, attachment);
@@ -395,143 +408,136 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data)
static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
{
- struct ioctl_hyper_dmabuf_export_fd *export_fd_attr;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct ioctl_hyper_dmabuf_export_fd *export_fd_attr =
+ (struct ioctl_hyper_dmabuf_export_fd *)data;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
+ struct imported_sgt_info *imported;
struct hyper_dmabuf_req *req;
- struct page **data_pages;
- int operands[4];
+ struct page **data_pgs;
+ int op[4];
int i;
int ret = 0;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
-
- if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
- return -EINVAL;
- }
-
- export_fd_attr = (struct ioctl_hyper_dmabuf_export_fd *)data;
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
/* look for dmabuf for the id */
- sgt_info = hyper_dmabuf_find_imported(export_fd_attr->hid);
+ imported = hyper_dmabuf_find_imported(export_fd_attr->hid);
/* can't find sgt from the table */
- if (!sgt_info) {
- dev_err(hyper_dmabuf_private.device, "can't find the entry\n");
+ if (!imported) {
+ dev_err(hy_drv_priv->dev, "can't find the entry\n");
return -ENOENT;
}
- mutex_lock(&hyper_dmabuf_private.lock);
+ mutex_lock(&hy_drv_priv->lock);
- sgt_info->num_importers++;
+ imported->importers++;
/* send notification for export_fd to exporter */
- operands[0] = sgt_info->hid.id;
+ op[0] = imported->hid.id;
for (i=0; i<3; i++)
- operands[i+1] = sgt_info->hid.rng_key[i];
+ op[i+1] = imported->hid.rng_key[i];
- dev_dbg(hyper_dmabuf_private.device, "Exporting fd of buffer {id:%d key:%d %d %d}\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ dev_dbg(hy_drv_priv->dev, "Exporting fd of buffer {id:%d key:%d %d %d}\n",
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if (!req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
- hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD, &operands[0]);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD, &op[0]);
- ret = ops->send_req(HYPER_DMABUF_DOM_ID(sgt_info->hid), req, true);
+ ret = ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, true);
if (ret < 0) {
/* in case of timeout other end eventually will receive request, so we need to undo it */
- hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operands[0]);
- ops->send_req(operands[0], req, false);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]);
+ ops->send_req(op[0], req, false);
kfree(req);
- dev_err(hyper_dmabuf_private.device, "Failed to create sgt or notify exporter\n");
- sgt_info->num_importers--;
- mutex_unlock(&hyper_dmabuf_private.lock);
+ dev_err(hy_drv_priv->dev, "Failed to create sgt or notify exporter\n");
+ imported->importers--;
+ mutex_unlock(&hy_drv_priv->lock);
return ret;
}
kfree(req);
if (ret == HYPER_DMABUF_REQ_ERROR) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Buffer invalid {id:%d key:%d %d %d}, cannot import\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
- sgt_info->num_importers--;
- mutex_unlock(&hyper_dmabuf_private.lock);
+ imported->importers--;
+ mutex_unlock(&hy_drv_priv->lock);
return -EINVAL;
} else {
- dev_dbg(hyper_dmabuf_private.device, "Can import buffer {id:%d key:%d %d %d}\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ dev_dbg(hy_drv_priv->dev, "Can import buffer {id:%d key:%d %d %d}\n",
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
ret = 0;
}
- dev_dbg(hyper_dmabuf_private.device,
- "%s Found buffer gref %d off %d last len %d nents %d domain %d\n", __func__,
- sgt_info->ref_handle, sgt_info->frst_ofst,
- sgt_info->last_len, sgt_info->nents,
- HYPER_DMABUF_DOM_ID(sgt_info->hid));
+ dev_dbg(hy_drv_priv->dev,
+ "%s Found buffer gref %d off %d last len %d nents %d domain %d\n",
+ __func__, imported->ref_handle, imported->frst_ofst,
+ imported->last_len, imported->nents, HYPER_DMABUF_DOM_ID(imported->hid));
- if (!sgt_info->sgt) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (!imported->sgt) {
+ dev_dbg(hy_drv_priv->dev,
"%s buffer {id:%d key:%d %d %d} pages not mapped yet\n", __func__,
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
- data_pages = ops->map_shared_pages(sgt_info->ref_handle,
- HYPER_DMABUF_DOM_ID(sgt_info->hid),
- sgt_info->nents,
- &sgt_info->refs_info);
+ data_pgs = ops->map_shared_pages(imported->ref_handle,
+ HYPER_DMABUF_DOM_ID(imported->hid),
+ imported->nents,
+ &imported->refs_info);
- if (!data_pages) {
- dev_err(hyper_dmabuf_private.device,
+ if (!data_pgs) {
+ dev_err(hy_drv_priv->dev,
"Cannot map pages of buffer {id:%d key:%d %d %d}\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ imported->hid.id, imported->hid.rng_key[0], imported->hid.rng_key[1],
+ imported->hid.rng_key[2]);
- sgt_info->num_importers--;
+ imported->importers--;
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if (!req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No more space left\n");
return -ENOMEM;
}
- hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT_FD_FAILED, &operands[0]);
- ops->send_req(HYPER_DMABUF_DOM_ID(sgt_info->hid), req, false);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_EXPORT_FD_FAILED, &op[0]);
+ ops->send_req(HYPER_DMABUF_DOM_ID(imported->hid), req, false);
kfree(req);
- mutex_unlock(&hyper_dmabuf_private.lock);
+ mutex_unlock(&hy_drv_priv->lock);
return -EINVAL;
}
- sgt_info->sgt = hyper_dmabuf_create_sgt(data_pages, sgt_info->frst_ofst,
- sgt_info->last_len, sgt_info->nents);
+ imported->sgt = hyper_dmabuf_create_sgt(data_pgs, imported->frst_ofst,
+ imported->last_len, imported->nents);
}
- export_fd_attr->fd = hyper_dmabuf_export_fd(sgt_info, export_fd_attr->flags);
+ export_fd_attr->fd = hyper_dmabuf_export_fd(imported, export_fd_attr->flags);
if (export_fd_attr->fd < 0) {
/* fail to get fd */
ret = export_fd_attr->fd;
}
- mutex_unlock(&hyper_dmabuf_private.lock);
+ mutex_unlock(&hy_drv_priv->lock);
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return ret;
}
@@ -541,50 +547,51 @@ static int hyper_dmabuf_export_fd_ioctl(struct file *filp, void *data)
static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
{
struct hyper_dmabuf_req *req;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
+ struct exported_sgt_info *exported =
+ container_of(work, struct exported_sgt_info, unexport.work);
+ int op[4];
int i, ret;
- int operands[4];
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
- struct hyper_dmabuf_sgt_info *sgt_info =
- container_of(work, struct hyper_dmabuf_sgt_info, unexport_work.work);
- if (!sgt_info)
+ if (!exported)
return;
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Marking buffer {id:%d key:%d %d %d} as invalid\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ exported->hid.id, exported->hid.rng_key[0],
+ exported->hid.rng_key[1], exported->hid.rng_key[2]);
/* no longer valid */
- sgt_info->valid = 0;
+ exported->valid = false;
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if (!req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return;
}
- operands[0] = sgt_info->hid.id;
+ op[0] = exported->hid.id;
for (i=0; i<3; i++)
- operands[i+1] = sgt_info->hid.rng_key[i];
+ op[i+1] = exported->hid.rng_key[i];
- hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &operands[0]);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &op[0]);
- /* Now send unexport request to remote domain, marking that buffer should not be used anymore */
- ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true);
+ /* Now send unexport request to remote domain, marking
+ * that buffer should not be used anymore */
+ ret = ops->send_req(exported->rdomid, req, true);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"unexport message for buffer {id:%d key:%d %d %d} failed\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ exported->hid.id, exported->hid.rng_key[0],
+ exported->hid.rng_key[1], exported->hid.rng_key[2]);
}
/* free msg */
kfree(req);
- sgt_info->unexport_scheduled = 0;
+ exported->unexport_sched = false;
/*
* Immediately clean-up if it has never been exported by importer
@@ -593,104 +600,94 @@ static void hyper_dmabuf_delayed_unexport(struct work_struct *work)
* is called (importer does this only when there's no
* no consumer of locally exported FDs)
*/
- if (!sgt_info->importer_exported) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (exported->active == 0) {
+ dev_dbg(hy_drv_priv->dev,
"claning up buffer {id:%d key:%d %d %d} completly\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ exported->hid.id, exported->hid.rng_key[0],
+ exported->hid.rng_key[1], exported->hid.rng_key[2]);
+
+ hyper_dmabuf_cleanup_sgt_info(exported, false);
+ hyper_dmabuf_remove_exported(exported->hid);
- hyper_dmabuf_cleanup_sgt_info(sgt_info, false);
- hyper_dmabuf_remove_exported(sgt_info->hid);
/* register hyper_dmabuf_id to the list for reuse */
- store_reusable_hid(sgt_info->hid);
+ store_reusable_hid(exported->hid);
- if (sgt_info->sz_priv > 0 && !sgt_info->priv)
- kfree(sgt_info->priv);
+ if (exported->sz_priv > 0 && !exported->priv)
+ kfree(exported->priv);
- kfree(sgt_info);
+ kfree(exported);
}
}
-/* Schedules unexport of dmabuf.
+/* Schedule unexport of dmabuf.
*/
-static int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data)
+int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data)
{
- struct ioctl_hyper_dmabuf_unexport *unexport_attr;
- struct hyper_dmabuf_sgt_info *sgt_info;
+ struct ioctl_hyper_dmabuf_unexport *unexport_attr =
+ (struct ioctl_hyper_dmabuf_unexport *)data;
+ struct exported_sgt_info *exported;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
-
- if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
- return -EINVAL;
- }
-
- unexport_attr = (struct ioctl_hyper_dmabuf_unexport *)data;
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
/* find dmabuf in export list */
- sgt_info = hyper_dmabuf_find_exported(unexport_attr->hid);
+ exported = hyper_dmabuf_find_exported(unexport_attr->hid);
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"scheduling unexport of buffer {id:%d key:%d %d %d}\n",
unexport_attr->hid.id, unexport_attr->hid.rng_key[0],
unexport_attr->hid.rng_key[1], unexport_attr->hid.rng_key[2]);
/* failed to find corresponding entry in export list */
- if (sgt_info == NULL) {
+ if (exported == NULL) {
unexport_attr->status = -ENOENT;
return -ENOENT;
}
- if (sgt_info->unexport_scheduled)
+ if (exported->unexport_sched)
return 0;
- sgt_info->unexport_scheduled = 1;
- INIT_DELAYED_WORK(&sgt_info->unexport_work, hyper_dmabuf_delayed_unexport);
- schedule_delayed_work(&sgt_info->unexport_work,
+ exported->unexport_sched = true;
+ INIT_DELAYED_WORK(&exported->unexport,
+ hyper_dmabuf_delayed_unexport);
+ schedule_delayed_work(&exported->unexport,
msecs_to_jiffies(unexport_attr->delay_ms));
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return 0;
}
static int hyper_dmabuf_query_ioctl(struct file *filp, void *data)
{
- struct ioctl_hyper_dmabuf_query *query_attr;
- struct hyper_dmabuf_sgt_info *sgt_info = NULL;
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info = NULL;
+ struct ioctl_hyper_dmabuf_query *query_attr =
+ (struct ioctl_hyper_dmabuf_query *)data;
+ struct exported_sgt_info *exported = NULL;
+ struct imported_sgt_info *imported = NULL;
int ret = 0;
- if (!data) {
- dev_err(hyper_dmabuf_private.device, "user data is NULL\n");
- return -EINVAL;
- }
-
- query_attr = (struct ioctl_hyper_dmabuf_query *)data;
-
- if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hyper_dmabuf_private.domid) {
+ if (HYPER_DMABUF_DOM_ID(query_attr->hid) == hy_drv_priv->domid) {
/* query for exported dmabuf */
- sgt_info = hyper_dmabuf_find_exported(query_attr->hid);
- if (sgt_info) {
- ret = hyper_dmabuf_query_exported(sgt_info,
+ exported = hyper_dmabuf_find_exported(query_attr->hid);
+ if (exported) {
+ ret = hyper_dmabuf_query_exported(exported,
query_attr->item, &query_attr->info);
} else {
- dev_err(hyper_dmabuf_private.device,
- "DMA BUF {id:%d key:%d %d %d} can't be found in the export list\n",
- query_attr->hid.id, query_attr->hid.rng_key[0], query_attr->hid.rng_key[1],
- query_attr->hid.rng_key[2]);
+ dev_err(hy_drv_priv->dev,
+ "DMA BUF {id:%d key:%d %d %d} not in the export list\n",
+ query_attr->hid.id, query_attr->hid.rng_key[0],
+ query_attr->hid.rng_key[1], query_attr->hid.rng_key[2]);
return -ENOENT;
}
} else {
/* query for imported dmabuf */
- imported_sgt_info = hyper_dmabuf_find_imported(query_attr->hid);
- if (imported_sgt_info) {
- ret = hyper_dmabuf_query_imported(imported_sgt_info,
- query_attr->item, &query_attr->info);
+ imported = hyper_dmabuf_find_imported(query_attr->hid);
+ if (imported) {
+ ret = hyper_dmabuf_query_imported(imported, query_attr->item,
+ &query_attr->info);
} else {
- dev_err(hyper_dmabuf_private.device,
- "DMA BUF {id:%d key:%d %d %d} can't be found in the imported list\n",
- query_attr->hid.id, query_attr->hid.rng_key[0], query_attr->hid.rng_key[1],
- query_attr->hid.rng_key[2]);
+ dev_err(hy_drv_priv->dev,
+ "DMA BUF {id:%d key:%d %d %d} not in the imported list\n",
+ query_attr->hid.id, query_attr->hid.rng_key[0],
+ query_attr->hid.rng_key[1], query_attr->hid.rng_key[2]);
return -ENOENT;
}
}
@@ -698,28 +695,6 @@ static int hyper_dmabuf_query_ioctl(struct file *filp, void *data)
return ret;
}
-void hyper_dmabuf_emergency_release(struct hyper_dmabuf_sgt_info* sgt_info,
- void *attr)
-{
- struct ioctl_hyper_dmabuf_unexport unexport_attr;
- struct file *filp = (struct file*) attr;
-
- if (!filp || !sgt_info)
- return;
-
- if (sgt_info->filp == filp) {
- dev_dbg(hyper_dmabuf_private.device,
- "Executing emergency release of buffer {id:%d key:%d %d %d}\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0],
- sgt_info->hid.rng_key[1], sgt_info->hid.rng_key[2]);
-
- unexport_attr.hid = sgt_info->hid;
- unexport_attr.delay_ms = 0;
-
- hyper_dmabuf_unexport_ioctl(filp, &unexport_attr);
- }
-}
-
const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = {
HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_TX_CH_SETUP, hyper_dmabuf_tx_ch_setup_ioctl, 0),
HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_RX_CH_SETUP, hyper_dmabuf_rx_ch_setup_ioctl, 0),
@@ -739,7 +714,7 @@ long hyper_dmabuf_ioctl(struct file *filp,
char *kdata;
if (nr > ARRAY_SIZE(hyper_dmabuf_ioctls)) {
- dev_err(hyper_dmabuf_private.device, "invalid ioctl\n");
+ dev_err(hy_drv_priv->dev, "invalid ioctl\n");
return -EINVAL;
}
@@ -748,18 +723,18 @@ long hyper_dmabuf_ioctl(struct file *filp,
func = ioctl->func;
if (unlikely(!func)) {
- dev_err(hyper_dmabuf_private.device, "no function\n");
+ dev_err(hy_drv_priv->dev, "no function\n");
return -EINVAL;
}
kdata = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
if (!kdata) {
- dev_err(hyper_dmabuf_private.device, "no memory\n");
+ dev_err(hy_drv_priv->dev, "no memory\n");
return -ENOMEM;
}
if (copy_from_user(kdata, (void __user *)param, _IOC_SIZE(cmd)) != 0) {
- dev_err(hyper_dmabuf_private.device, "failed to copy from user arguments\n");
+ dev_err(hy_drv_priv->dev, "failed to copy from user arguments\n");
ret = -EFAULT;
goto ioctl_error;
}
@@ -767,7 +742,7 @@ long hyper_dmabuf_ioctl(struct file *filp,
ret = func(filp, kdata);
if (copy_to_user((void __user *)param, kdata, _IOC_SIZE(cmd)) != 0) {
- dev_err(hyper_dmabuf_private.device, "failed to copy to user arguments\n");
+ dev_err(hy_drv_priv->dev, "failed to copy to user arguments\n");
ret = -EFAULT;
goto ioctl_error;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
index ebfbb84..3e9470a 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
@@ -42,4 +42,6 @@ struct hyper_dmabuf_ioctl_desc {
.name = #ioctl \
}
+int hyper_dmabuf_unexport_ioctl(struct file *filp, void *data);
+
#endif //__HYPER_DMABUF_IOCTL_H__
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
index eaef2c1..1b3745e 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.c
@@ -39,24 +39,22 @@
#include "hyper_dmabuf_id.h"
#include "hyper_dmabuf_event.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
DECLARE_HASHTABLE(hyper_dmabuf_hash_imported, MAX_ENTRY_IMPORTED);
DECLARE_HASHTABLE(hyper_dmabuf_hash_exported, MAX_ENTRY_EXPORTED);
#ifdef CONFIG_HYPER_DMABUF_SYSFS
static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attribute *attr, char *buf)
{
- struct hyper_dmabuf_info_entry_imported *info_entry;
+ struct list_entry_imported *info_entry;
int bkt;
ssize_t count = 0;
size_t total = 0;
hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node) {
- hyper_dmabuf_id_t hid = info_entry->info->hid;
- int nents = info_entry->info->nents;
- bool valid = info_entry->info->valid;
- int num_importers = info_entry->info->num_importers;
+ hyper_dmabuf_id_t hid = info_entry->imported->hid;
+ int nents = info_entry->imported->nents;
+ bool valid = info_entry->imported->valid;
+ int num_importers = info_entry->imported->importers;
total += nents;
count += scnprintf(buf + count, PAGE_SIZE - count,
"hid:{id:%d keys:%d %d %d}, nents:%d, v:%c, numi:%d\n",
@@ -71,16 +69,16 @@ static ssize_t hyper_dmabuf_imported_show(struct device *drv, struct device_attr
static ssize_t hyper_dmabuf_exported_show(struct device *drv, struct device_attribute *attr, char *buf)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
int bkt;
ssize_t count = 0;
size_t total = 0;
hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node) {
- hyper_dmabuf_id_t hid = info_entry->info->hid;
- int nents = info_entry->info->nents;
- bool valid = info_entry->info->valid;
- int importer_exported = info_entry->info->importer_exported;
+ hyper_dmabuf_id_t hid = info_entry->exported->hid;
+ int nents = info_entry->exported->nents;
+ bool valid = info_entry->exported->valid;
+ int importer_exported = info_entry->exported->active;
total += nents;
count += scnprintf(buf + count, PAGE_SIZE - count,
"hid:{hid:%d keys:%d %d %d}, nents:%d, v:%c, ie:%d\n",
@@ -135,57 +133,57 @@ int hyper_dmabuf_table_destroy()
return 0;
}
-int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info)
+int hyper_dmabuf_register_exported(struct exported_sgt_info *exported)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
if (!info_entry) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
- info_entry->info = info;
+ info_entry->exported = exported;
hash_add(hyper_dmabuf_hash_exported, &info_entry->node,
- info_entry->info->hid.id);
+ info_entry->exported->hid.id);
return 0;
}
-int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info)
+int hyper_dmabuf_register_imported(struct imported_sgt_info* imported)
{
- struct hyper_dmabuf_info_entry_imported *info_entry;
+ struct list_entry_imported *info_entry;
info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
if (!info_entry) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
- info_entry->info = info;
+ info_entry->imported = imported;
hash_add(hyper_dmabuf_hash_imported, &info_entry->node,
- info_entry->info->hid.id);
+ info_entry->imported->hid.id);
return 0;
}
-struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
+struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
int bkt;
hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
/* checking hid.id first */
- if(info_entry->info->hid.id == hid.id) {
+ if(info_entry->exported->hid.id == hid.id) {
/* then key is compared */
- if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid))
- return info_entry->info;
+ if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid))
+ return info_entry->exported;
/* if key is unmatched, given HID is invalid, so returning NULL */
else
break;
@@ -197,29 +195,29 @@ struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid)
/* search for pre-exported sgt and return id of it if it exist */
hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
hyper_dmabuf_id_t hid = {-1, {0, 0, 0}};
int bkt;
hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
- if(info_entry->info->dma_buf == dmabuf &&
- info_entry->info->hyper_dmabuf_rdomain == domid)
- return info_entry->info->hid;
+ if(info_entry->exported->dma_buf == dmabuf &&
+ info_entry->exported->rdomid == domid)
+ return info_entry->exported->hid;
return hid;
}
-struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid)
+struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid)
{
- struct hyper_dmabuf_info_entry_imported *info_entry;
+ struct list_entry_imported *info_entry;
int bkt;
hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node)
/* checking hid.id first */
- if(info_entry->info->hid.id == hid.id) {
+ if(info_entry->imported->hid.id == hid.id) {
/* then key is compared */
- if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid))
- return info_entry->info;
+ if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid))
+ return info_entry->imported;
/* if key is unmatched, given HID is invalid, so returning NULL */
else {
break;
@@ -231,14 +229,14 @@ struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_i
int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
int bkt;
hash_for_each(hyper_dmabuf_hash_exported, bkt, info_entry, node)
/* checking hid.id first */
- if(info_entry->info->hid.id == hid.id) {
+ if(info_entry->exported->hid.id == hid.id) {
/* then key is compared */
- if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) {
+ if(hyper_dmabuf_hid_keycomp(info_entry->exported->hid, hid)) {
hash_del(&info_entry->node);
kfree(info_entry);
return 0;
@@ -252,14 +250,14 @@ int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid)
int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid)
{
- struct hyper_dmabuf_info_entry_imported *info_entry;
+ struct list_entry_imported *info_entry;
int bkt;
hash_for_each(hyper_dmabuf_hash_imported, bkt, info_entry, node)
/* checking hid.id first */
- if(info_entry->info->hid.id == hid.id) {
+ if(info_entry->imported->hid.id == hid.id) {
/* then key is compared */
- if(hyper_dmabuf_hid_keycomp(info_entry->info->hid, hid)) {
+ if(hyper_dmabuf_hid_keycomp(info_entry->imported->hid, hid)) {
hash_del(&info_entry->node);
kfree(info_entry);
return 0;
@@ -272,15 +270,15 @@ int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid)
}
void hyper_dmabuf_foreach_exported(
- void (*func)(struct hyper_dmabuf_sgt_info *, void *attr),
+ void (*func)(struct exported_sgt_info *, void *attr),
void *attr)
{
- struct hyper_dmabuf_info_entry_exported *info_entry;
+ struct list_entry_exported *info_entry;
struct hlist_node *tmp;
int bkt;
hash_for_each_safe(hyper_dmabuf_hash_exported, bkt, tmp,
info_entry, node) {
- func(info_entry->info, attr);
+ func(info_entry->exported, attr);
}
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
index 8f64db8..d5c17ef 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_list.h
@@ -32,13 +32,13 @@
/* number of bits to be used for imported dmabufs hash table */
#define MAX_ENTRY_IMPORTED 7
-struct hyper_dmabuf_info_entry_exported {
- struct hyper_dmabuf_sgt_info *info;
+struct list_entry_exported {
+ struct exported_sgt_info *exported;
struct hlist_node node;
};
-struct hyper_dmabuf_info_entry_imported {
- struct hyper_dmabuf_imported_sgt_info *info;
+struct list_entry_imported {
+ struct imported_sgt_info *imported;
struct hlist_node node;
};
@@ -46,23 +46,23 @@ int hyper_dmabuf_table_init(void);
int hyper_dmabuf_table_destroy(void);
-int hyper_dmabuf_register_exported(struct hyper_dmabuf_sgt_info *info);
+int hyper_dmabuf_register_exported(struct exported_sgt_info *info);
/* search for pre-exported sgt and return id of it if it exist */
hyper_dmabuf_id_t hyper_dmabuf_find_hid_exported(struct dma_buf *dmabuf, int domid);
-int hyper_dmabuf_register_imported(struct hyper_dmabuf_imported_sgt_info* info);
+int hyper_dmabuf_register_imported(struct imported_sgt_info* info);
-struct hyper_dmabuf_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid);
+struct exported_sgt_info *hyper_dmabuf_find_exported(hyper_dmabuf_id_t hid);
-struct hyper_dmabuf_imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid);
+struct imported_sgt_info *hyper_dmabuf_find_imported(hyper_dmabuf_id_t hid);
int hyper_dmabuf_remove_exported(hyper_dmabuf_id_t hid);
int hyper_dmabuf_remove_imported(hyper_dmabuf_id_t hid);
void hyper_dmabuf_foreach_exported(
- void (*func)(struct hyper_dmabuf_sgt_info *, void *attr),
+ void (*func)(struct exported_sgt_info *, void *attr),
void *attr);
int hyper_dmabuf_register_sysfs(struct device *dev);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
index ec37c3b..907f76e 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
@@ -31,7 +31,6 @@
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/dma-buf.h>
-#include <xen/grant_table.h>
#include <linux/workqueue.h>
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_drv.h"
@@ -39,58 +38,56 @@
#include "hyper_dmabuf_event.h"
#include "hyper_dmabuf_list.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
struct cmd_process {
struct work_struct work;
struct hyper_dmabuf_req *rq;
int domid;
};
-void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
- enum hyper_dmabuf_command command, int *operands)
+void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
+ enum hyper_dmabuf_command cmd, int *op)
{
int i;
- req->status = HYPER_DMABUF_REQ_NOT_RESPONDED;
- req->command = command;
+ req->stat = HYPER_DMABUF_REQ_NOT_RESPONDED;
+ req->cmd = cmd;
- switch(command) {
+ switch(cmd) {
/* as exporter, commands to importer */
case HYPER_DMABUF_EXPORT:
/* exporting pages for dmabuf */
/* command : HYPER_DMABUF_EXPORT,
- * operands0~3 : hyper_dmabuf_id
- * operands4 : number of pages to be shared
- * operands5 : offset of data in the first page
- * operands6 : length of data in the last page
- * operands7 : top-level reference number for shared pages
- * operands8 : size of private data (from operands9)
- * operands9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
+ * op0~3 : hyper_dmabuf_id
+ * op4 : number of pages to be shared
+ * op5 : offset of data in the first page
+ * op6 : length of data in the last page
+ * op7 : top-level reference number for shared pages
+ * op8 : size of private data (from op9)
+ * op9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
*/
- memcpy(&req->operands[0], &operands[0], 9 * sizeof(int) + operands[8]);
+ memcpy(&req->op[0], &op[0], 9 * sizeof(int) + op[8]);
break;
case HYPER_DMABUF_NOTIFY_UNEXPORT:
/* destroy sg_list for hyper_dmabuf_id on remote side */
/* command : DMABUF_DESTROY,
- * operands0~3 : hyper_dmabuf_id_t hid
+ * op0~3 : hyper_dmabuf_id_t hid
*/
for (i=0; i < 4; i++)
- req->operands[i] = operands[i];
+ req->op[i] = op[i];
break;
case HYPER_DMABUF_EXPORT_FD:
case HYPER_DMABUF_EXPORT_FD_FAILED:
/* dmabuf fd is being created on imported side or importing failed */
/* command : HYPER_DMABUF_EXPORT_FD or HYPER_DMABUF_EXPORT_FD_FAILED,
- * operands0~3 : hyper_dmabuf_id
+ * op0~3 : hyper_dmabuf_id
*/
for (i=0; i < 4; i++)
- req->operands[i] = operands[i];
+ req->op[i] = op[i];
break;
case HYPER_DMABUF_OPS_TO_REMOTE:
@@ -103,11 +100,11 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
/* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping
* or unmapping for synchronization with original exporter (e.g. i915) */
/* command : DMABUF_OPS_TO_SOURCE.
- * operands0~3 : hyper_dmabuf_id
- * operands4 : map(=1)/unmap(=2)/attach(=3)/detach(=4)
+ * op0~3 : hyper_dmabuf_id
+ * op4 : map(=1)/unmap(=2)/attach(=3)/detach(=4)
*/
for (i = 0; i < 5; i++)
- req->operands[i] = operands[i];
+ req->op[i] = op[i];
break;
default:
@@ -116,9 +113,9 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
}
}
-void cmd_process_work(struct work_struct *work)
+static void cmd_process_work(struct work_struct *work)
{
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
+ struct imported_sgt_info *imported;
struct cmd_process *proc = container_of(work, struct cmd_process, work);
struct hyper_dmabuf_req *req;
int domid;
@@ -127,107 +124,107 @@ void cmd_process_work(struct work_struct *work)
req = proc->rq;
domid = proc->domid;
- switch (req->command) {
+ switch (req->cmd) {
case HYPER_DMABUF_EXPORT:
/* exporting pages for dmabuf */
/* command : HYPER_DMABUF_EXPORT,
- * operands0~3 : hyper_dmabuf_id
- * operands4 : number of pages to be shared
- * operands5 : offset of data in the first page
- * operands6 : length of data in the last page
- * operands7 : top-level reference number for shared pages
- * operands8 : size of private data (from operands9)
- * operands9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
+ * op0~3 : hyper_dmabuf_id
+ * op4 : number of pages to be shared
+ * op5 : offset of data in the first page
+ * op6 : length of data in the last page
+ * op7 : top-level reference number for shared pages
+ * op8 : size of private data (from op9)
+ * op9 ~ : Driver-specific private data (e.g. graphic buffer's meta info)
*/
/* if nents == 0, it means it is a message only for priv synchronization
* for existing imported_sgt_info so not creating a new one */
- if (req->operands[4] == 0) {
- hyper_dmabuf_id_t exist = {req->operands[0],
- {req->operands[1], req->operands[2],
- req->operands[3]}};
+ if (req->op[4] == 0) {
+ hyper_dmabuf_id_t exist = {req->op[0],
+ {req->op[1], req->op[2],
+ req->op[3]}};
- imported_sgt_info = hyper_dmabuf_find_imported(exist);
+ imported = hyper_dmabuf_find_imported(exist);
- if (!imported_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!imported) {
+ dev_err(hy_drv_priv->dev,
"Can't find imported sgt_info from IMPORT_LIST\n");
break;
}
/* if size of new private data is different,
* we reallocate it. */
- if (imported_sgt_info->sz_priv != req->operands[8]) {
- kfree(imported_sgt_info->priv);
- imported_sgt_info->sz_priv = req->operands[8];
- imported_sgt_info->priv = kcalloc(1, req->operands[8], GFP_KERNEL);
- if (!imported_sgt_info->priv) {
- dev_err(hyper_dmabuf_private.device,
+ if (imported->sz_priv != req->op[8]) {
+ kfree(imported->priv);
+ imported->sz_priv = req->op[8];
+ imported->priv = kcalloc(1, req->op[8], GFP_KERNEL);
+ if (!imported->priv) {
+ dev_err(hy_drv_priv->dev,
"Fail to allocate priv\n");
/* set it invalid */
- imported_sgt_info->valid = 0;
+ imported->valid = 0;
break;
}
}
/* updating priv data */
- memcpy(imported_sgt_info->priv, &req->operands[9], req->operands[8]);
+ memcpy(imported->priv, &req->op[9], req->op[8]);
#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
/* generating import event */
- hyper_dmabuf_import_event(imported_sgt_info->hid);
+ hyper_dmabuf_import_event(imported->hid);
#endif
break;
}
- imported_sgt_info = kcalloc(1, sizeof(*imported_sgt_info), GFP_KERNEL);
+ imported = kcalloc(1, sizeof(*imported), GFP_KERNEL);
- if (!imported_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!imported) {
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
break;
}
- imported_sgt_info->sz_priv = req->operands[8];
- imported_sgt_info->priv = kcalloc(1, req->operands[8], GFP_KERNEL);
+ imported->sz_priv = req->op[8];
+ imported->priv = kcalloc(1, req->op[8], GFP_KERNEL);
- if (!imported_sgt_info->priv) {
- dev_err(hyper_dmabuf_private.device,
+ if (!imported->priv) {
+ dev_err(hy_drv_priv->dev,
"Fail to allocate priv\n");
- kfree(imported_sgt_info);
+ kfree(imported);
break;
}
- imported_sgt_info->hid.id = req->operands[0];
+ imported->hid.id = req->op[0];
for (i=0; i<3; i++)
- imported_sgt_info->hid.rng_key[i] = req->operands[i+1];
+ imported->hid.rng_key[i] = req->op[i+1];
- imported_sgt_info->nents = req->operands[4];
- imported_sgt_info->frst_ofst = req->operands[5];
- imported_sgt_info->last_len = req->operands[6];
- imported_sgt_info->ref_handle = req->operands[7];
+ imported->nents = req->op[4];
+ imported->frst_ofst = req->op[5];
+ imported->last_len = req->op[6];
+ imported->ref_handle = req->op[7];
- dev_dbg(hyper_dmabuf_private.device, "DMABUF was exported\n");
- dev_dbg(hyper_dmabuf_private.device, "\thid{id:%d key:%d %d %d}\n",
- req->operands[0], req->operands[1], req->operands[2],
- req->operands[3]);
- dev_dbg(hyper_dmabuf_private.device, "\tnents %d\n", req->operands[4]);
- dev_dbg(hyper_dmabuf_private.device, "\tfirst offset %d\n", req->operands[5]);
- dev_dbg(hyper_dmabuf_private.device, "\tlast len %d\n", req->operands[6]);
- dev_dbg(hyper_dmabuf_private.device, "\tgrefid %d\n", req->operands[7]);
+ dev_dbg(hy_drv_priv->dev, "DMABUF was exported\n");
+ dev_dbg(hy_drv_priv->dev, "\thid{id:%d key:%d %d %d}\n",
+ req->op[0], req->op[1], req->op[2],
+ req->op[3]);
+ dev_dbg(hy_drv_priv->dev, "\tnents %d\n", req->op[4]);
+ dev_dbg(hy_drv_priv->dev, "\tfirst offset %d\n", req->op[5]);
+ dev_dbg(hy_drv_priv->dev, "\tlast len %d\n", req->op[6]);
+ dev_dbg(hy_drv_priv->dev, "\tgrefid %d\n", req->op[7]);
- memcpy(imported_sgt_info->priv, &req->operands[9], req->operands[8]);
+ memcpy(imported->priv, &req->op[9], req->op[8]);
- imported_sgt_info->valid = 1;
- hyper_dmabuf_register_imported(imported_sgt_info);
+ imported->valid = true;
+ hyper_dmabuf_register_imported(imported);
#ifdef CONFIG_HYPER_DMABUF_EVENT_GEN
/* generating import event */
- hyper_dmabuf_import_event(imported_sgt_info->hid);
+ hyper_dmabuf_import_event(imported->hid);
#endif
break;
@@ -251,142 +248,142 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
{
struct cmd_process *proc;
struct hyper_dmabuf_req *temp_req;
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
- struct hyper_dmabuf_sgt_info *exp_sgt_info;
+ struct imported_sgt_info *imported;
+ struct exported_sgt_info *exported;
hyper_dmabuf_id_t hid;
int ret;
if (!req) {
- dev_err(hyper_dmabuf_private.device, "request is NULL\n");
+ dev_err(hy_drv_priv->dev, "request is NULL\n");
return -EINVAL;
}
- hid.id = req->operands[0];
- hid.rng_key[0] = req->operands[1];
- hid.rng_key[1] = req->operands[2];
- hid.rng_key[2] = req->operands[3];
+ hid.id = req->op[0];
+ hid.rng_key[0] = req->op[1];
+ hid.rng_key[1] = req->op[2];
+ hid.rng_key[2] = req->op[3];
- if ((req->command < HYPER_DMABUF_EXPORT) ||
- (req->command > HYPER_DMABUF_OPS_TO_SOURCE)) {
- dev_err(hyper_dmabuf_private.device, "invalid command\n");
+ if ((req->cmd < HYPER_DMABUF_EXPORT) ||
+ (req->cmd > HYPER_DMABUF_OPS_TO_SOURCE)) {
+ dev_err(hy_drv_priv->dev, "invalid command\n");
return -EINVAL;
}
- req->status = HYPER_DMABUF_REQ_PROCESSED;
+ req->stat = HYPER_DMABUF_REQ_PROCESSED;
/* HYPER_DMABUF_DESTROY requires immediate
* follow up so can't be processed in workqueue
*/
- if (req->command == HYPER_DMABUF_NOTIFY_UNEXPORT) {
+ if (req->cmd == HYPER_DMABUF_NOTIFY_UNEXPORT) {
/* destroy sg_list for hyper_dmabuf_id on remote side */
/* command : HYPER_DMABUF_NOTIFY_UNEXPORT,
- * operands0~3 : hyper_dmabuf_id
+ * op0~3 : hyper_dmabuf_id
*/
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: processing HYPER_DMABUF_NOTIFY_UNEXPORT\n", __func__);
- sgt_info = hyper_dmabuf_find_imported(hid);
+ imported = hyper_dmabuf_find_imported(hid);
- if (sgt_info) {
+ if (imported) {
/* if anything is still using dma_buf */
- if (sgt_info->num_importers) {
+ if (imported->importers) {
/*
* Buffer is still in use, just mark that it should
* not be allowed to export its fd anymore.
*/
- sgt_info->valid = 0;
+ imported->valid = false;
} else {
/* No one is using buffer, remove it from imported list */
hyper_dmabuf_remove_imported(hid);
- kfree(sgt_info);
+ kfree(imported);
}
} else {
- req->status = HYPER_DMABUF_REQ_ERROR;
+ req->stat = HYPER_DMABUF_REQ_ERROR;
}
- return req->command;
+ return req->cmd;
}
/* dma buf remote synchronization */
- if (req->command == HYPER_DMABUF_OPS_TO_SOURCE) {
+ if (req->cmd == HYPER_DMABUF_OPS_TO_SOURCE) {
/* notifying dmabuf map/unmap to exporter, map will make the driver to do shadow mapping
* or unmapping for synchronization with original exporter (e.g. i915) */
/* command : DMABUF_OPS_TO_SOURCE.
- * operands0~3 : hyper_dmabuf_id
- * operands1 : enum hyper_dmabuf_ops {....}
+ * op0~3 : hyper_dmabuf_id
+ * op1 : enum hyper_dmabuf_ops {....}
*/
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: HYPER_DMABUF_OPS_TO_SOURCE\n", __func__);
- ret = hyper_dmabuf_remote_sync(hid, req->operands[4]);
+ ret = hyper_dmabuf_remote_sync(hid, req->op[4]);
if (ret)
- req->status = HYPER_DMABUF_REQ_ERROR;
+ req->stat = HYPER_DMABUF_REQ_ERROR;
else
- req->status = HYPER_DMABUF_REQ_PROCESSED;
+ req->stat = HYPER_DMABUF_REQ_PROCESSED;
- return req->command;
+ return req->cmd;
}
/* synchronous dma_buf_fd export */
- if (req->command == HYPER_DMABUF_EXPORT_FD) {
+ if (req->cmd == HYPER_DMABUF_EXPORT_FD) {
/* find a corresponding SGT for the id */
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Processing HYPER_DMABUF_EXPORT_FD for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- exp_sgt_info = hyper_dmabuf_find_exported(hid);
+ exported = hyper_dmabuf_find_exported(hid);
- if (!exp_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!exported) {
+ dev_err(hy_drv_priv->dev,
"critical err: requested sgt_info can't be found for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- req->status = HYPER_DMABUF_REQ_ERROR;
- } else if (!exp_sgt_info->valid) {
- dev_dbg(hyper_dmabuf_private.device,
+ req->stat = HYPER_DMABUF_REQ_ERROR;
+ } else if (!exported->valid) {
+ dev_dbg(hy_drv_priv->dev,
"Buffer no longer valid - cannot export fd for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- req->status = HYPER_DMABUF_REQ_ERROR;
+ req->stat = HYPER_DMABUF_REQ_ERROR;
} else {
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Buffer still valid - can export fd for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- exp_sgt_info->importer_exported++;
- req->status = HYPER_DMABUF_REQ_PROCESSED;
+ exported->active++;
+ req->stat = HYPER_DMABUF_REQ_PROCESSED;
}
- return req->command;
+ return req->cmd;
}
- if (req->command == HYPER_DMABUF_EXPORT_FD_FAILED) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (req->cmd == HYPER_DMABUF_EXPORT_FD_FAILED) {
+ dev_dbg(hy_drv_priv->dev,
"Processing HYPER_DMABUF_EXPORT_FD_FAILED for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- exp_sgt_info = hyper_dmabuf_find_exported(hid);
+ exported = hyper_dmabuf_find_exported(hid);
- if (!exp_sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!exported) {
+ dev_err(hy_drv_priv->dev,
"critical err: requested sgt_info can't be found for buffer {id:%d key:%d %d %d}\n",
hid.id, hid.rng_key[0], hid.rng_key[1], hid.rng_key[2]);
- req->status = HYPER_DMABUF_REQ_ERROR;
+ req->stat = HYPER_DMABUF_REQ_ERROR;
} else {
- exp_sgt_info->importer_exported--;
- req->status = HYPER_DMABUF_REQ_PROCESSED;
+ exported->active--;
+ req->stat = HYPER_DMABUF_REQ_PROCESSED;
}
- return req->command;
+ return req->cmd;
}
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: putting request to workqueue\n", __func__);
temp_req = kmalloc(sizeof(*temp_req), GFP_KERNEL);
if (!temp_req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
@@ -396,7 +393,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
proc = kcalloc(1, sizeof(struct cmd_process), GFP_KERNEL);
if (!proc) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
kfree(temp_req);
return -ENOMEM;
@@ -407,7 +404,7 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
INIT_WORK(&(proc->work), cmd_process_work);
- queue_work(hyper_dmabuf_private.work_queue, &(proc->work));
+ queue_work(hy_drv_priv->work_queue, &(proc->work));
- return req->command;
+ return req->cmd;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
index 0f6e795..7c694ec 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
@@ -28,17 +28,17 @@
#define MAX_NUMBER_OF_OPERANDS 64
struct hyper_dmabuf_req {
- unsigned int request_id;
- unsigned int status;
- unsigned int command;
- unsigned int operands[MAX_NUMBER_OF_OPERANDS];
+ unsigned int req_id;
+ unsigned int stat;
+ unsigned int cmd;
+ unsigned int op[MAX_NUMBER_OF_OPERANDS];
};
struct hyper_dmabuf_resp {
- unsigned int response_id;
- unsigned int status;
- unsigned int command;
- unsigned int operands[MAX_NUMBER_OF_OPERANDS];
+ unsigned int resp_id;
+ unsigned int stat;
+ unsigned int cmd;
+ unsigned int op[MAX_NUMBER_OF_OPERANDS];
};
enum hyper_dmabuf_command {
@@ -75,7 +75,7 @@ enum hyper_dmabuf_req_feedback {
};
/* create a request packet with given command and operands */
-void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
+void hyper_dmabuf_create_req(struct hyper_dmabuf_req *req,
enum hyper_dmabuf_command command,
int *operands);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
index 9313c42..7e73170 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.c
@@ -32,8 +32,6 @@
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/dma-buf.h>
-#include <xen/grant_table.h>
-#include <asm/xen/page.h>
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_ops.h"
@@ -45,122 +43,111 @@
#define WAIT_AFTER_SYNC_REQ 0
#define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
-inline int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
+static int hyper_dmabuf_sync_request(hyper_dmabuf_id_t hid, int dmabuf_ops)
{
struct hyper_dmabuf_req *req;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
- int operands[5];
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
+ int op[5];
int i;
int ret;
- operands[0] = hid.id;
+ op[0] = hid.id;
for (i=0; i<3; i++)
- operands[i+1] = hid.rng_key[i];
+ op[i+1] = hid.rng_key[i];
- operands[4] = dmabuf_ops;
+ op[4] = dmabuf_ops;
req = kcalloc(1, sizeof(*req), GFP_KERNEL);
if (!req) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
- hyper_dmabuf_create_request(req, HYPER_DMABUF_OPS_TO_SOURCE, &operands[0]);
+ hyper_dmabuf_create_req(req, HYPER_DMABUF_OPS_TO_SOURCE, &op[0]);
/* send request and wait for a response */
ret = ops->send_req(HYPER_DMABUF_DOM_ID(hid), req, WAIT_AFTER_SYNC_REQ);
+ if (ret < 0) {
+ dev_dbg(hy_drv_priv->dev,
+ "dmabuf sync request failed:%d\n", req->op[4]);
+ }
+
kfree(req);
return ret;
}
-static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf, struct device* dev,
- struct dma_buf_attachment *attach)
+static int hyper_dmabuf_ops_attach(struct dma_buf* dmabuf,
+ struct device* dev,
+ struct dma_buf_attachment *attach)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!attach->dmabuf->priv)
return -EINVAL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv;
+ imported = (struct imported_sgt_info *)attach->dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_ATTACH);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- return ret;
- }
-
- return 0;
+ return ret;
}
-static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf, struct dma_buf_attachment *attach)
+static void hyper_dmabuf_ops_detach(struct dma_buf* dmabuf,
+ struct dma_buf_attachment *attach)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!attach->dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attach->dmabuf->priv;
+ imported = (struct imported_sgt_info *)attach->dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_DETACH);
-
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachment,
- enum dma_data_direction dir)
+ enum dma_data_direction dir)
{
struct sg_table *st;
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
- struct hyper_dmabuf_pages_info *page_info;
+ struct imported_sgt_info *imported;
+ struct pages_info *pg_info;
int ret;
if (!attachment->dmabuf->priv)
return NULL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attachment->dmabuf->priv;
+ imported = (struct imported_sgt_info *)attachment->dmabuf->priv;
/* extract pages from sgt */
- page_info = hyper_dmabuf_ext_pgs(sgt_info->sgt);
+ pg_info = hyper_dmabuf_ext_pgs(imported->sgt);
- if (!page_info) {
+ if (!pg_info) {
return NULL;
}
/* create a new sg_table with extracted pages */
- st = hyper_dmabuf_create_sgt(page_info->pages, page_info->frst_ofst,
- page_info->last_len, page_info->nents);
+ st = hyper_dmabuf_create_sgt(pg_info->pgs, pg_info->frst_ofst,
+ pg_info->last_len, pg_info->nents);
if (!st)
goto err_free_sg;
if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir))
goto err_free_sg;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_MAP);
- kfree(page_info->pages);
- kfree(page_info);
-
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
+ kfree(pg_info->pgs);
+ kfree(pg_info);
return st;
@@ -170,8 +157,8 @@ static struct sg_table* hyper_dmabuf_ops_map(struct dma_buf_attachment *attachme
kfree(st);
}
- kfree(page_info->pages);
- kfree(page_info);
+ kfree(pg_info->pgs);
+ kfree(pg_info);
return NULL;
}
@@ -180,294 +167,251 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment,
struct sg_table *sg,
enum dma_data_direction dir)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!attachment->dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)attachment->dmabuf->priv;
+ imported = (struct imported_sgt_info *)attachment->dmabuf->priv;
dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
sg_free_table(sg);
kfree(sg);
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_UNMAP);
-
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct imported_sgt_info *imported;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
int ret;
- int final_release;
+ int finish;
if (!dma_buf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dma_buf->priv;
+ imported = (struct imported_sgt_info *)dma_buf->priv;
- if (!dmabuf_refcount(sgt_info->dma_buf)) {
- sgt_info->dma_buf = NULL;
+ if (!dmabuf_refcount(imported->dma_buf)) {
+ imported->dma_buf = NULL;
}
- sgt_info->num_importers--;
+ imported->importers--;
- if (sgt_info->num_importers == 0) {
- ops->unmap_shared_pages(&sgt_info->refs_info, sgt_info->nents);
+ if (imported->importers == 0) {
+ ops->unmap_shared_pages(&imported->refs_info, imported->nents);
- if (sgt_info->sgt) {
- sg_free_table(sgt_info->sgt);
- kfree(sgt_info->sgt);
- sgt_info->sgt = NULL;
+ if (imported->sgt) {
+ sg_free_table(imported->sgt);
+ kfree(imported->sgt);
+ imported->sgt = NULL;
}
}
- final_release = sgt_info && !sgt_info->valid &&
- !sgt_info->num_importers;
+ finish = imported && !imported->valid &&
+ !imported->importers;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_RELEASE);
- if (ret < 0) {
- dev_warn(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
/*
* Check if buffer is still valid and if not remove it from imported list.
* That has to be done after sending sync request
*/
- if (final_release) {
- hyper_dmabuf_remove_imported(sgt_info->hid);
- kfree(sgt_info);
+ if (finish) {
+ hyper_dmabuf_remove_imported(imported->hid);
+ kfree(imported);
}
}
static int hyper_dmabuf_ops_begin_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return -EINVAL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return ret;
}
static int hyper_dmabuf_ops_end_cpu_access(struct dma_buf *dmabuf, enum dma_data_direction dir)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return -EINVAL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_END_CPU_ACCESS);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return 0;
}
static void *hyper_dmabuf_ops_kmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return NULL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_KMAP_ATOMIC);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return NULL; /* for now NULL.. need to return the address of mapped region */
}
static void hyper_dmabuf_ops_kunmap_atomic(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_KUNMAP_ATOMIC);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static void *hyper_dmabuf_ops_kmap(struct dma_buf *dmabuf, unsigned long pgnum)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return NULL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_KMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
- return NULL; /* for now NULL.. need to return the address of mapped region */
+ /* for now NULL.. need to return the address of mapped region */
+ return NULL;
}
-static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum, void *vaddr)
+static void hyper_dmabuf_ops_kunmap(struct dma_buf *dmabuf, unsigned long pgnum,
+ void *vaddr)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_KUNMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static int hyper_dmabuf_ops_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return -EINVAL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_MMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return ret;
}
static void *hyper_dmabuf_ops_vmap(struct dma_buf *dmabuf)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return NULL;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_VMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
return NULL;
}
static void hyper_dmabuf_ops_vunmap(struct dma_buf *dmabuf, void *vaddr)
{
- struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct imported_sgt_info *imported;
int ret;
if (!dmabuf->priv)
return;
- sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dmabuf->priv;
+ imported = (struct imported_sgt_info *)dmabuf->priv;
- ret = hyper_dmabuf_sync_request(sgt_info->hid,
+ ret = hyper_dmabuf_sync_request(imported->hid,
HYPER_DMABUF_OPS_VUNMAP);
- if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
- "hyper_dmabuf::%s Error:send dmabuf sync request failed\n", __func__);
- }
}
static const struct dma_buf_ops hyper_dmabuf_ops = {
- .attach = hyper_dmabuf_ops_attach,
- .detach = hyper_dmabuf_ops_detach,
- .map_dma_buf = hyper_dmabuf_ops_map,
- .unmap_dma_buf = hyper_dmabuf_ops_unmap,
- .release = hyper_dmabuf_ops_release,
- .begin_cpu_access = (void*)hyper_dmabuf_ops_begin_cpu_access,
- .end_cpu_access = (void*)hyper_dmabuf_ops_end_cpu_access,
- .map_atomic = hyper_dmabuf_ops_kmap_atomic,
- .unmap_atomic = hyper_dmabuf_ops_kunmap_atomic,
- .map = hyper_dmabuf_ops_kmap,
- .unmap = hyper_dmabuf_ops_kunmap,
- .mmap = hyper_dmabuf_ops_mmap,
- .vmap = hyper_dmabuf_ops_vmap,
- .vunmap = hyper_dmabuf_ops_vunmap,
+ .attach = hyper_dmabuf_ops_attach,
+ .detach = hyper_dmabuf_ops_detach,
+ .map_dma_buf = hyper_dmabuf_ops_map,
+ .unmap_dma_buf = hyper_dmabuf_ops_unmap,
+ .release = hyper_dmabuf_ops_release,
+ .begin_cpu_access = (void*)hyper_dmabuf_ops_begin_cpu_access,
+ .end_cpu_access = (void*)hyper_dmabuf_ops_end_cpu_access,
+ .map_atomic = hyper_dmabuf_ops_kmap_atomic,
+ .unmap_atomic = hyper_dmabuf_ops_kunmap_atomic,
+ .map = hyper_dmabuf_ops_kmap,
+ .unmap = hyper_dmabuf_ops_kunmap,
+ .mmap = hyper_dmabuf_ops_mmap,
+ .vmap = hyper_dmabuf_ops_vmap,
+ .vunmap = hyper_dmabuf_ops_vunmap,
};
/* exporting dmabuf as fd */
-int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags)
+int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags)
{
int fd = -1;
/* call hyper_dmabuf_export_dmabuf and create
* and bind a handle for it then release
*/
- hyper_dmabuf_export_dma_buf(dinfo);
+ hyper_dmabuf_export_dma_buf(imported);
- if (dinfo->dma_buf) {
- fd = dma_buf_fd(dinfo->dma_buf, flags);
+ if (imported->dma_buf) {
+ fd = dma_buf_fd(imported->dma_buf, flags);
}
return fd;
}
-void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo)
+void hyper_dmabuf_export_dma_buf(struct imported_sgt_info *imported)
{
DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
exp_info.ops = &hyper_dmabuf_ops;
/* multiple of PAGE_SIZE, not considering offset */
- exp_info.size = dinfo->sgt->nents * PAGE_SIZE;
- exp_info.flags = /* not sure about flag */0;
- exp_info.priv = dinfo;
+ exp_info.size = imported->sgt->nents * PAGE_SIZE;
+ exp_info.flags = /* not sure about flag */ 0;
+ exp_info.priv = imported;
- dinfo->dma_buf = dma_buf_export(&exp_info);
+ imported->dma_buf = dma_buf_export(&exp_info);
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
index 8c06fc6..c5505a4 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ops.h
@@ -25,8 +25,8 @@
#ifndef __HYPER_DMABUF_OPS_H__
#define __HYPER_DMABUF_OPS_H__
-int hyper_dmabuf_export_fd(struct hyper_dmabuf_imported_sgt_info *dinfo, int flags);
+int hyper_dmabuf_export_fd(struct imported_sgt_info *imported, int flags);
-void hyper_dmabuf_export_dma_buf(struct hyper_dmabuf_imported_sgt_info *dinfo);
+void hyper_dmabuf_export_dma_buf(struct imported_sgt_info *imported);
#endif /* __HYPER_DMABUF_IMP_H__ */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
index 39c9dee..36e888c 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.c
@@ -32,16 +32,12 @@
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_id.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
#define HYPER_DMABUF_SIZE(nents, first_offset, last_len) \
((nents)*PAGE_SIZE - (first_offset) - PAGE_SIZE + (last_len))
-int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
+int hyper_dmabuf_query_exported(struct exported_sgt_info *exported,
int query, unsigned long* info)
{
- int n;
-
switch (query)
{
case HYPER_DMABUF_QUERY_TYPE:
@@ -50,45 +46,46 @@ int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
/* exporting domain of this specific dmabuf*/
case HYPER_DMABUF_QUERY_EXPORTER:
- *info = HYPER_DMABUF_DOM_ID(sgt_info->hid);
+ *info = HYPER_DMABUF_DOM_ID(exported->hid);
break;
/* importing domain of this specific dmabuf */
case HYPER_DMABUF_QUERY_IMPORTER:
- *info = sgt_info->hyper_dmabuf_rdomain;
+ *info = exported->rdomid;
break;
/* size of dmabuf in byte */
case HYPER_DMABUF_QUERY_SIZE:
- *info = sgt_info->dma_buf->size;
+ *info = exported->dma_buf->size;
break;
/* whether the buffer is used by importer */
case HYPER_DMABUF_QUERY_BUSY:
- *info = (sgt_info->importer_exported == 0) ? false : true;
+ *info = (exported->active > 0);
break;
/* whether the buffer is unexported */
case HYPER_DMABUF_QUERY_UNEXPORTED:
- *info = !sgt_info->valid;
+ *info = !exported->valid;
break;
/* whether the buffer is scheduled to be unexported */
case HYPER_DMABUF_QUERY_DELAYED_UNEXPORTED:
- *info = !sgt_info->unexport_scheduled;
+ *info = !exported->unexport_sched;
break;
/* size of private info attached to buffer */
case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
- *info = sgt_info->sz_priv;
+ *info = exported->sz_priv;
break;
/* copy private info attached to buffer */
case HYPER_DMABUF_QUERY_PRIV_INFO:
- if (sgt_info->sz_priv > 0) {
+ if (exported->sz_priv > 0) {
+ int n;
n = copy_to_user((void __user*) *info,
- sgt_info->priv,
- sgt_info->sz_priv);
+ exported->priv,
+ exported->sz_priv);
if (n != 0)
return -EINVAL;
}
@@ -102,11 +99,9 @@ int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
}
-int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_sgt_info,
+int hyper_dmabuf_query_imported(struct imported_sgt_info *imported,
int query, unsigned long *info)
{
- int n;
-
switch (query)
{
case HYPER_DMABUF_QUERY_TYPE:
@@ -115,50 +110,51 @@ int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_
/* exporting domain of this specific dmabuf*/
case HYPER_DMABUF_QUERY_EXPORTER:
- *info = HYPER_DMABUF_DOM_ID(imported_sgt_info->hid);
+ *info = HYPER_DMABUF_DOM_ID(imported->hid);
break;
/* importing domain of this specific dmabuf */
case HYPER_DMABUF_QUERY_IMPORTER:
- *info = hyper_dmabuf_private.domid;
+ *info = hy_drv_priv->domid;
break;
/* size of dmabuf in byte */
case HYPER_DMABUF_QUERY_SIZE:
- if (imported_sgt_info->dma_buf) {
+ if (imported->dma_buf) {
/* if local dma_buf is created (if it's ever mapped),
* retrieve it directly from struct dma_buf *
*/
- *info = imported_sgt_info->dma_buf->size;
+ *info = imported->dma_buf->size;
} else {
/* calcuate it from given nents, frst_ofst and last_len */
- *info = HYPER_DMABUF_SIZE(imported_sgt_info->nents,
- imported_sgt_info->frst_ofst,
- imported_sgt_info->last_len);
+ *info = HYPER_DMABUF_SIZE(imported->nents,
+ imported->frst_ofst,
+ imported->last_len);
}
break;
/* whether the buffer is used or not */
case HYPER_DMABUF_QUERY_BUSY:
/* checks if it's used by importer */
- *info = (imported_sgt_info->num_importers > 0) ? true : false;
+ *info = (imported->importers > 0);
break;
/* whether the buffer is unexported */
case HYPER_DMABUF_QUERY_UNEXPORTED:
- *info = !imported_sgt_info->valid;
+ *info = !imported->valid;
break;
/* size of private info attached to buffer */
case HYPER_DMABUF_QUERY_PRIV_INFO_SIZE:
- *info = imported_sgt_info->sz_priv;
+ *info = imported->sz_priv;
break;
/* copy private info attached to buffer */
case HYPER_DMABUF_QUERY_PRIV_INFO:
- if (imported_sgt_info->sz_priv > 0) {
+ if (imported->sz_priv > 0) {
+ int n;
n = copy_to_user((void __user*) *info,
- imported_sgt_info->priv,
- imported_sgt_info->sz_priv);
+ imported->priv,
+ imported->sz_priv);
if (n != 0)
return -EINVAL;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
index 7bbb322..65ae738 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_query.h
@@ -1,10 +1,10 @@
#ifndef __HYPER_DMABUF_QUERY_H__
#define __HYPER_DMABUF_QUERY_H__
-int hyper_dmabuf_query_imported(struct hyper_dmabuf_imported_sgt_info *imported_sgt_info,
+int hyper_dmabuf_query_imported(struct imported_sgt_info *imported,
int query, unsigned long *info);
-int hyper_dmabuf_query_exported(struct hyper_dmabuf_sgt_info *sgt_info,
+int hyper_dmabuf_query_exported(struct exported_sgt_info *exported,
int query, unsigned long *info);
#endif // __HYPER_DMABUF_QUERY_H__
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
index 9004406..01ec98c 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
@@ -39,8 +39,6 @@
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_sgl_proc.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
/* Whenever importer does dma operations from remote domain,
* a notification is sent to the exporter so that exporter
* issues equivalent dma operation on the original dma buf
@@ -58,7 +56,7 @@ extern struct hyper_dmabuf_private hyper_dmabuf_private;
*/
int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
{
- struct hyper_dmabuf_sgt_info *sgt_info;
+ struct exported_sgt_info *exported;
struct sgt_list *sgtl;
struct attachment_list *attachl;
struct kmap_vaddr_list *va_kmapl;
@@ -66,10 +64,10 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
int ret;
/* find a coresponding SGT for the id */
- sgt_info = hyper_dmabuf_find_exported(hid);
+ exported = hyper_dmabuf_find_exported(hid);
- if (!sgt_info) {
- dev_err(hyper_dmabuf_private.device,
+ if (!exported) {
+ dev_err(hy_drv_priv->dev,
"dmabuf remote sync::can't find exported list\n");
return -ENOENT;
}
@@ -79,84 +77,84 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
attachl = kcalloc(1, sizeof(*attachl), GFP_KERNEL);
if (!attachl) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_ATTACH\n");
return -ENOMEM;
}
- attachl->attach = dma_buf_attach(sgt_info->dma_buf,
- hyper_dmabuf_private.device);
+ attachl->attach = dma_buf_attach(exported->dma_buf,
+ hy_drv_priv->dev);
if (!attachl->attach) {
kfree(attachl);
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_ATTACH\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_ATTACH\n");
return -ENOMEM;
}
- list_add(&attachl->list, &sgt_info->active_attached->list);
+ list_add(&attachl->list, &exported->active_attached->list);
break;
case HYPER_DMABUF_OPS_DETACH:
- if (list_empty(&sgt_info->active_attached->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_DETACH\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->active_attached->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_DETACH\n");
+ dev_err(hy_drv_priv->dev,
"no more dmabuf attachment left to be detached\n");
return -EFAULT;
}
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
- dma_buf_detach(sgt_info->dma_buf, attachl->attach);
+ dma_buf_detach(exported->dma_buf, attachl->attach);
list_del(&attachl->list);
kfree(attachl);
break;
case HYPER_DMABUF_OPS_MAP:
- if (list_empty(&sgt_info->active_attached->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->active_attached->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_MAP\n");
+ dev_err(hy_drv_priv->dev,
"no more dmabuf attachment left to be mapped\n");
return -EFAULT;
}
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
sgtl = kcalloc(1, sizeof(*sgtl), GFP_KERNEL);
if (!sgtl) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_MAP\n");
return -ENOMEM;
}
sgtl->sgt = dma_buf_map_attachment(attachl->attach, DMA_BIDIRECTIONAL);
if (!sgtl->sgt) {
kfree(sgtl);
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_MAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_MAP\n");
return -ENOMEM;
}
- list_add(&sgtl->list, &sgt_info->active_sgts->list);
+ list_add(&sgtl->list, &exported->active_sgts->list);
break;
case HYPER_DMABUF_OPS_UNMAP:
- if (list_empty(&sgt_info->active_sgts->list) ||
- list_empty(&sgt_info->active_attached->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_UNMAP\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->active_sgts->list) ||
+ list_empty(&exported->active_attached->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_UNMAP\n");
+ dev_err(hy_drv_priv->dev,
"no more SGT or attachment left to be unmapped\n");
return -EFAULT;
}
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
- sgtl = list_first_entry(&sgt_info->active_sgts->list,
+ sgtl = list_first_entry(&exported->active_sgts->list,
struct sgt_list, list);
dma_buf_unmap_attachment(attachl->attach, sgtl->sgt,
@@ -166,30 +164,30 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
break;
case HYPER_DMABUF_OPS_RELEASE:
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Buffer {id:%d key:%d %d %d} released, references left: %d\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2], sgt_info->importer_exported -1);
+ exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1],
+ exported->hid.rng_key[2], exported->active - 1);
- sgt_info->importer_exported--;
+ exported->active--;
/* If there are still importers just break, if no then continue with final cleanup */
- if (sgt_info->importer_exported)
+ if (exported->active)
break;
/*
* Importer just released buffer fd, check if there is any other importer still using it.
* If not and buffer was unexported, clean up shared data and remove that buffer.
*/
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Buffer {id:%d key:%d %d %d} final released\n",
- sgt_info->hid.id, sgt_info->hid.rng_key[0], sgt_info->hid.rng_key[1],
- sgt_info->hid.rng_key[2]);
+ exported->hid.id, exported->hid.rng_key[0], exported->hid.rng_key[1],
+ exported->hid.rng_key[2]);
- if (!sgt_info->valid && !sgt_info->importer_exported &&
- !sgt_info->unexport_scheduled) {
- hyper_dmabuf_cleanup_sgt_info(sgt_info, false);
+ if (!exported->valid && !exported->active &&
+ !exported->unexport_sched) {
+ hyper_dmabuf_cleanup_sgt_info(exported, false);
hyper_dmabuf_remove_exported(hid);
- kfree(sgt_info);
+ kfree(exported);
/* store hyper_dmabuf_id in the list for reuse */
store_reusable_hid(hid);
}
@@ -197,19 +195,19 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
break;
case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS:
- ret = dma_buf_begin_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL);
+ ret = dma_buf_begin_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS\n");
return ret;
}
break;
case HYPER_DMABUF_OPS_END_CPU_ACCESS:
- ret = dma_buf_end_cpu_access(sgt_info->dma_buf, DMA_BIDIRECTIONAL);
+ ret = dma_buf_end_cpu_access(exported->dma_buf, DMA_BIDIRECTIONAL);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_END_CPU_ACCESS\n");
return ret;
}
break;
@@ -218,49 +216,49 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
case HYPER_DMABUF_OPS_KMAP:
va_kmapl = kcalloc(1, sizeof(*va_kmapl), GFP_KERNEL);
if (!va_kmapl) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
return -ENOMEM;
}
/* dummy kmapping of 1 page */
if (ops == HYPER_DMABUF_OPS_KMAP_ATOMIC)
- va_kmapl->vaddr = dma_buf_kmap_atomic(sgt_info->dma_buf, 1);
+ va_kmapl->vaddr = dma_buf_kmap_atomic(exported->dma_buf, 1);
else
- va_kmapl->vaddr = dma_buf_kmap(sgt_info->dma_buf, 1);
+ va_kmapl->vaddr = dma_buf_kmap(exported->dma_buf, 1);
if (!va_kmapl->vaddr) {
kfree(va_kmapl);
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_KMAP(_ATOMIC)\n");
return -ENOMEM;
}
- list_add(&va_kmapl->list, &sgt_info->va_kmapped->list);
+ list_add(&va_kmapl->list, &exported->va_kmapped->list);
break;
case HYPER_DMABUF_OPS_KUNMAP_ATOMIC:
case HYPER_DMABUF_OPS_KUNMAP:
- if (list_empty(&sgt_info->va_kmapped->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->va_kmapped->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
+ dev_err(hy_drv_priv->dev,
"no more dmabuf VA to be freed\n");
return -EFAULT;
}
- va_kmapl = list_first_entry(&sgt_info->va_kmapped->list,
+ va_kmapl = list_first_entry(&exported->va_kmapped->list,
struct kmap_vaddr_list, list);
if (!va_kmapl->vaddr) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_KUNMAP(_ATOMIC)\n");
return PTR_ERR(va_kmapl->vaddr);
}
/* unmapping 1 page */
if (ops == HYPER_DMABUF_OPS_KUNMAP_ATOMIC)
- dma_buf_kunmap_atomic(sgt_info->dma_buf, 1, va_kmapl->vaddr);
+ dma_buf_kunmap_atomic(exported->dma_buf, 1, va_kmapl->vaddr);
else
- dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr);
+ dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr);
list_del(&va_kmapl->list);
kfree(va_kmapl);
@@ -269,48 +267,48 @@ int hyper_dmabuf_remote_sync(hyper_dmabuf_id_t hid, int ops)
case HYPER_DMABUF_OPS_MMAP:
/* currently not supported: looking for a way to create
* a dummy vma */
- dev_warn(hyper_dmabuf_private.device,
- "dmabuf remote sync::sychronized mmap is not supported\n");
+ dev_warn(hy_drv_priv->dev,
+ "remote sync::sychronized mmap is not supported\n");
break;
case HYPER_DMABUF_OPS_VMAP:
va_vmapl = kcalloc(1, sizeof(*va_vmapl), GFP_KERNEL);
if (!va_vmapl) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_VMAP\n");
return -ENOMEM;
}
/* dummy vmapping */
- va_vmapl->vaddr = dma_buf_vmap(sgt_info->dma_buf);
+ va_vmapl->vaddr = dma_buf_vmap(exported->dma_buf);
if (!va_vmapl->vaddr) {
kfree(va_vmapl);
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VMAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_VMAP\n");
return -ENOMEM;
}
- list_add(&va_vmapl->list, &sgt_info->va_vmapped->list);
+ list_add(&va_vmapl->list, &exported->va_vmapped->list);
break;
case HYPER_DMABUF_OPS_VUNMAP:
- if (list_empty(&sgt_info->va_vmapped->list)) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
- dev_err(hyper_dmabuf_private.device,
+ if (list_empty(&exported->va_vmapped->list)) {
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_VUNMAP\n");
+ dev_err(hy_drv_priv->dev,
"no more dmabuf VA to be freed\n");
return -EFAULT;
}
- va_vmapl = list_first_entry(&sgt_info->va_vmapped->list,
+ va_vmapl = list_first_entry(&exported->va_vmapped->list,
struct vmap_vaddr_list, list);
if (!va_vmapl || va_vmapl->vaddr == NULL) {
- dev_err(hyper_dmabuf_private.device,
- "dmabuf remote sync::error while processing HYPER_DMABUF_OPS_VUNMAP\n");
+ dev_err(hy_drv_priv->dev,
+ "remote sync::HYPER_DMABUF_OPS_VUNMAP\n");
return -EFAULT;
}
- dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr);
+ dma_buf_vunmap(exported->dma_buf, va_vmapl->vaddr);
list_del(&va_vmapl->list);
kfree(va_vmapl);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
index 691a714..315c354 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.c
@@ -32,8 +32,6 @@
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/dma-buf.h>
-#include <xen/grant_table.h>
-#include <asm/xen/page.h>
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_sgl_proc.h"
@@ -41,8 +39,6 @@
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_list.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
#define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
int dmabuf_refcount(struct dma_buf *dma_buf)
@@ -66,60 +62,68 @@ static int hyper_dmabuf_get_num_pgs(struct sg_table *sgt)
sgl = sgt->sgl;
length = sgl->length - PAGE_SIZE + sgl->offset;
- num_pages += ((length + PAGE_SIZE - 1)/PAGE_SIZE); /* round-up */
+
+ /* round-up */
+ num_pages += ((length + PAGE_SIZE - 1)/PAGE_SIZE);
for (i = 1; i < sgt->nents; i++) {
sgl = sg_next(sgl);
- num_pages += ((sgl->length + PAGE_SIZE - 1) / PAGE_SIZE); /* round-up */
+
+ /* round-up */
+ num_pages += ((sgl->length + PAGE_SIZE - 1) /
+ PAGE_SIZE); /* round-up */
}
return num_pages;
}
/* extract pages directly from struct sg_table */
-struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
+struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
{
- struct hyper_dmabuf_pages_info *pinfo;
+ struct pages_info *pg_info;
int i, j, k;
int length;
struct scatterlist *sgl;
- pinfo = kmalloc(sizeof(*pinfo), GFP_KERNEL);
- if (!pinfo)
+ pg_info = kmalloc(sizeof(*pg_info), GFP_KERNEL);
+ if (!pg_info)
return NULL;
- pinfo->pages = kmalloc(sizeof(struct page *)*hyper_dmabuf_get_num_pgs(sgt), GFP_KERNEL);
- if (!pinfo->pages) {
- kfree(pinfo);
+ pg_info->pgs = kmalloc(sizeof(struct page *) *
+ hyper_dmabuf_get_num_pgs(sgt),
+ GFP_KERNEL);
+
+ if (!pg_info->pgs) {
+ kfree(pg_info);
return NULL;
}
sgl = sgt->sgl;
- pinfo->nents = 1;
- pinfo->frst_ofst = sgl->offset;
- pinfo->pages[0] = sg_page(sgl);
+ pg_info->nents = 1;
+ pg_info->frst_ofst = sgl->offset;
+ pg_info->pgs[0] = sg_page(sgl);
length = sgl->length - PAGE_SIZE + sgl->offset;
i = 1;
while (length > 0) {
- pinfo->pages[i] = nth_page(sg_page(sgl), i);
+ pg_info->pgs[i] = nth_page(sg_page(sgl), i);
length -= PAGE_SIZE;
- pinfo->nents++;
+ pg_info->nents++;
i++;
}
for (j = 1; j < sgt->nents; j++) {
sgl = sg_next(sgl);
- pinfo->pages[i++] = sg_page(sgl);
+ pg_info->pgs[i++] = sg_page(sgl);
length = sgl->length - PAGE_SIZE;
- pinfo->nents++;
+ pg_info->nents++;
k = 1;
while (length > 0) {
- pinfo->pages[i++] = nth_page(sg_page(sgl), k++);
+ pg_info->pgs[i++] = nth_page(sg_page(sgl), k++);
length -= PAGE_SIZE;
- pinfo->nents++;
+ pg_info->nents++;
}
}
@@ -127,13 +131,13 @@ struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt)
* lenght at that point will be 0 or negative,
* so to calculate last page size just add it to PAGE_SIZE
*/
- pinfo->last_len = PAGE_SIZE + length;
+ pg_info->last_len = PAGE_SIZE + length;
- return pinfo;
+ return pg_info;
}
/* create sg_table with given pages and other parameters */
-struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
+struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs,
int frst_ofst, int last_len, int nents)
{
struct sg_table *sgt;
@@ -157,31 +161,32 @@ struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
sgl = sgt->sgl;
- sg_set_page(sgl, pages[0], PAGE_SIZE-frst_ofst, frst_ofst);
+ sg_set_page(sgl, pgs[0], PAGE_SIZE-frst_ofst, frst_ofst);
for (i=1; i<nents-1; i++) {
sgl = sg_next(sgl);
- sg_set_page(sgl, pages[i], PAGE_SIZE, 0);
+ sg_set_page(sgl, pgs[i], PAGE_SIZE, 0);
}
if (nents > 1) /* more than one page */ {
sgl = sg_next(sgl);
- sg_set_page(sgl, pages[i], last_len, 0);
+ sg_set_page(sgl, pgs[i], last_len, 0);
}
return sgt;
}
-int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force)
+int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported,
+ int force)
{
struct sgt_list *sgtl;
struct attachment_list *attachl;
struct kmap_vaddr_list *va_kmapl;
struct vmap_vaddr_list *va_vmapl;
- struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_backend_ops *ops = hy_drv_priv->backend_ops;
- if (!sgt_info) {
- dev_err(hyper_dmabuf_private.device, "invalid hyper_dmabuf_id\n");
+ if (!exported) {
+ dev_err(hy_drv_priv->dev, "invalid hyper_dmabuf_id\n");
return -EINVAL;
}
@@ -190,35 +195,37 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
* side.
*/
if (!force &&
- sgt_info->importer_exported) {
- dev_warn(hyper_dmabuf_private.device, "dma-buf is used by importer\n");
+ exported->active) {
+ dev_warn(hy_drv_priv->dev,
+ "dma-buf is used by importer\n");
+
return -EPERM;
}
/* force == 1 is not recommended */
- while (!list_empty(&sgt_info->va_kmapped->list)) {
- va_kmapl = list_first_entry(&sgt_info->va_kmapped->list,
+ while (!list_empty(&exported->va_kmapped->list)) {
+ va_kmapl = list_first_entry(&exported->va_kmapped->list,
struct kmap_vaddr_list, list);
- dma_buf_kunmap(sgt_info->dma_buf, 1, va_kmapl->vaddr);
+ dma_buf_kunmap(exported->dma_buf, 1, va_kmapl->vaddr);
list_del(&va_kmapl->list);
kfree(va_kmapl);
}
- while (!list_empty(&sgt_info->va_vmapped->list)) {
- va_vmapl = list_first_entry(&sgt_info->va_vmapped->list,
+ while (!list_empty(&exported->va_vmapped->list)) {
+ va_vmapl = list_first_entry(&exported->va_vmapped->list,
struct vmap_vaddr_list, list);
- dma_buf_vunmap(sgt_info->dma_buf, va_vmapl->vaddr);
+ dma_buf_vunmap(exported->dma_buf, va_vmapl->vaddr);
list_del(&va_vmapl->list);
kfree(va_vmapl);
}
- while (!list_empty(&sgt_info->active_sgts->list)) {
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ while (!list_empty(&exported->active_sgts->list)) {
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
- sgtl = list_first_entry(&sgt_info->active_sgts->list,
+ sgtl = list_first_entry(&exported->active_sgts->list,
struct sgt_list, list);
dma_buf_unmap_attachment(attachl->attach, sgtl->sgt,
@@ -227,35 +234,35 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
kfree(sgtl);
}
- while (!list_empty(&sgt_info->active_sgts->list)) {
- attachl = list_first_entry(&sgt_info->active_attached->list,
+ while (!list_empty(&exported->active_sgts->list)) {
+ attachl = list_first_entry(&exported->active_attached->list,
struct attachment_list, list);
- dma_buf_detach(sgt_info->dma_buf, attachl->attach);
+ dma_buf_detach(exported->dma_buf, attachl->attach);
list_del(&attachl->list);
kfree(attachl);
}
/* Start cleanup of buffer in reverse order to exporting */
- ops->unshare_pages(&sgt_info->refs_info, sgt_info->nents);
+ ops->unshare_pages(&exported->refs_info, exported->nents);
/* unmap dma-buf */
- dma_buf_unmap_attachment(sgt_info->active_attached->attach,
- sgt_info->active_sgts->sgt,
+ dma_buf_unmap_attachment(exported->active_attached->attach,
+ exported->active_sgts->sgt,
DMA_BIDIRECTIONAL);
/* detatch dma-buf */
- dma_buf_detach(sgt_info->dma_buf, sgt_info->active_attached->attach);
+ dma_buf_detach(exported->dma_buf, exported->active_attached->attach);
/* close connection to dma-buf completely */
- dma_buf_put(sgt_info->dma_buf);
- sgt_info->dma_buf = NULL;
-
- kfree(sgt_info->active_sgts);
- kfree(sgt_info->active_attached);
- kfree(sgt_info->va_kmapped);
- kfree(sgt_info->va_vmapped);
- kfree(sgt_info->priv);
+ dma_buf_put(exported->dma_buf);
+ exported->dma_buf = NULL;
+
+ kfree(exported->active_sgts);
+ kfree(exported->active_attached);
+ kfree(exported->va_kmapped);
+ kfree(exported->va_vmapped);
+ kfree(exported->priv);
return 0;
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
index 237ccf5..930bade 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_sgl_proc.h
@@ -28,13 +28,15 @@
int dmabuf_refcount(struct dma_buf *dma_buf);
/* extract pages directly from struct sg_table */
-struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt);
+struct pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt);
/* create sg_table with given pages and other parameters */
-struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
- int frst_ofst, int last_len, int nents);
+struct sg_table* hyper_dmabuf_create_sgt(struct page **pgs,
+ int frst_ofst, int last_len,
+ int nents);
-int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force);
+int hyper_dmabuf_cleanup_sgt_info(struct exported_sgt_info *exported,
+ int force);
void hyper_dmabuf_free_sgt(struct sg_table *sgt);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
index 6f929f2..8a612d1 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
@@ -50,24 +50,20 @@ struct vmap_vaddr_list {
};
/* Exporter builds pages_info before sharing pages */
-struct hyper_dmabuf_pages_info {
+struct pages_info {
int frst_ofst; /* offset of data in the first page */
int last_len; /* length of data in the last page */
int nents; /* # of pages */
- struct page **pages; /* pages that contains reference numbers of shared pages*/
+ struct page **pgs; /* pages that contains reference numbers of shared pages*/
};
-/* Both importer and exporter use this structure to point to sg lists
- *
- * Exporter stores references to sgt in a hash table
+/* Exporter stores references to sgt in a hash table
* Exporter keeps these references for synchronization and tracking purposes
- *
- * Importer use this structure exporting to other drivers in the same domain
*/
-struct hyper_dmabuf_sgt_info {
+struct exported_sgt_info {
hyper_dmabuf_id_t hid; /* unique id to reference dmabuf in remote domain */
- int hyper_dmabuf_rdomain; /* domain importing this sgt */
+ int rdomid; /* domain importing this sgt */
struct dma_buf *dma_buf; /* needed to store this for freeing it later */
int nents;
@@ -79,10 +75,10 @@ struct hyper_dmabuf_sgt_info {
struct vmap_vaddr_list *va_vmapped;
bool valid; /* set to 0 once unexported. Needed to prevent further mapping by importer */
- int importer_exported; /* exported locally on importer's side */
+ int active; /* locally shared on importer's side */
void *refs_info; /* hypervisor-specific info for the references */
- struct delayed_work unexport_work;
- bool unexport_scheduled;
+ struct delayed_work unexport;
+ bool unexport_sched;
/* owner of buffer
* TODO: that is naiive as buffer may be reused by
@@ -99,7 +95,7 @@ struct hyper_dmabuf_sgt_info {
/* Importer store references (before mapping) on shared pages
* Importer store these references in the table and map it in
* its own memory map once userspace asks for reference for the buffer */
-struct hyper_dmabuf_imported_sgt_info {
+struct imported_sgt_info {
hyper_dmabuf_id_t hid; /* unique id for shared dmabuf imported */
int ref_handle; /* reference number of top level addressing page of shared pages */
@@ -112,7 +108,7 @@ struct hyper_dmabuf_imported_sgt_info {
void *refs_info;
bool valid;
- int num_importers;
+ int importers;
size_t sz_priv;
char *priv; /* device specific info (e.g. image's meta info?) */
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
index 920ecf4..f70b4ea 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
@@ -45,8 +45,6 @@ static int export_req_id = 0;
struct hyper_dmabuf_req req_pending = {0};
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
extern int xenstored_ready;
static void xen_get_domid_delayed(struct work_struct *unused);
@@ -62,7 +60,9 @@ static int xen_comm_setup_data_dir(void)
{
char buf[255];
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_private.domid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf",
+ hy_drv_priv->domid);
+
return xenbus_mkdir(XBT_NIL, buf, "");
}
@@ -76,7 +76,9 @@ static int xen_comm_destroy_data_dir(void)
{
char buf[255];
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf", hyper_dmabuf_private.domid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf",
+ hy_drv_priv->domid);
+
return xenbus_rm(XBT_NIL, buf, "");
}
@@ -91,20 +93,26 @@ static int xen_comm_expose_ring_details(int domid, int rdomid,
char buf[255];
int ret;
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", domid, rdomid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
+ domid, rdomid);
+
ret = xenbus_printf(XBT_NIL, buf, "grefid", "%d", gref);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "Failed to write xenbus entry %s: %d\n", buf, ret);
+ dev_err(hy_drv_priv->dev,
+ "Failed to write xenbus entry %s: %d\n",
+ buf, ret);
+
return ret;
}
ret = xenbus_printf(XBT_NIL, buf, "port", "%d", port);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "Failed to write xenbus entry %s: %d\n", buf, ret);
+ dev_err(hy_drv_priv->dev,
+ "Failed to write xenbus entry %s: %d\n",
+ buf, ret);
+
return ret;
}
@@ -114,25 +122,32 @@ static int xen_comm_expose_ring_details(int domid, int rdomid,
/*
* Queries details of ring exposed by remote domain.
*/
-static int xen_comm_get_ring_details(int domid, int rdomid, int *grefid, int *port)
+static int xen_comm_get_ring_details(int domid, int rdomid,
+ int *grefid, int *port)
{
char buf[255];
int ret;
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", rdomid, domid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
+ rdomid, domid);
+
ret = xenbus_scanf(XBT_NIL, buf, "grefid", "%d", grefid);
if (ret <= 0) {
- dev_err(hyper_dmabuf_private.device,
- "Failed to read xenbus entry %s: %d\n", buf, ret);
+ dev_err(hy_drv_priv->dev,
+ "Failed to read xenbus entry %s: %d\n",
+ buf, ret);
+
return ret;
}
ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", port);
if (ret <= 0) {
- dev_err(hyper_dmabuf_private.device,
- "Failed to read xenbus entry %s: %d\n", buf, ret);
+ dev_err(hy_drv_priv->dev,
+ "Failed to read xenbus entry %s: %d\n",
+ buf, ret);
+
return ret;
}
@@ -146,9 +161,8 @@ void xen_get_domid_delayed(struct work_struct *unused)
/* scheduling another if driver is still running
* and xenstore has not been initialized */
- if (hyper_dmabuf_private.exited == false &&
- likely(xenstored_ready == 0)) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (likely(xenstored_ready == 0)) {
+ dev_dbg(hy_drv_priv->dev,
"Xenstore is not quite ready yet. Will retry it in 500ms\n");
schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500));
} else {
@@ -163,14 +177,14 @@ void xen_get_domid_delayed(struct work_struct *unused)
/* try again since -1 is an invalid id for domain
* (but only if driver is still running) */
- if (hyper_dmabuf_private.exited == false && unlikely(domid == -1)) {
- dev_dbg(hyper_dmabuf_private.device,
+ if (unlikely(domid == -1)) {
+ dev_dbg(hy_drv_priv->dev,
"domid==-1 is invalid. Will retry it in 500ms\n");
schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500));
} else {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Successfully retrieved domid from Xenstore:%d\n", domid);
- hyper_dmabuf_private.domid = domid;
+ hy_drv_priv->domid = domid;
}
}
}
@@ -232,28 +246,30 @@ static void remote_dom_exporter_watch_cb(struct xenbus_watch *watch,
return;
}
- /* Check if we have importer ring for given remote domain alrady created */
+ /* Check if we have importer ring for given remote domain already
+ * created */
+
ring_info = xen_comm_find_rx_ring(rdom);
- /* Try to query remote domain exporter ring details - if that will
- * fail and we have importer ring that means remote domains has cleanup
- * its exporter ring, so our importer ring is no longer useful.
+ /* Try to query remote domain exporter ring details - if
+ * that will fail and we have importer ring that means remote
+ * domains has cleanup its exporter ring, so our importer ring
+ * is no longer useful.
*
* If querying details will succeed and we don't have importer ring,
- * it means that remote domain has setup it for us and we should connect
- * to it.
+ * it means that remote domain has setup it for us and we should
+ * connect to it.
*/
-
- ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), rdom,
- &grefid, &port);
+ ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(),
+ rdom, &grefid, &port);
if (ring_info && ret != 0) {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Remote exporter closed, cleaninup importer\n");
hyper_dmabuf_xen_cleanup_rx_rbuf(rdom);
} else if (!ring_info && ret == 0) {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Registering importer\n");
hyper_dmabuf_xen_init_rx_rbuf(rdom);
}
@@ -274,7 +290,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
ring_info = xen_comm_find_tx_ring(domid);
if (ring_info) {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"tx ring ch to domid = %d already exist\ngref = %d, port = %d\n",
ring_info->rdomain, ring_info->gref_ring, ring_info->port);
return 0;
@@ -283,7 +299,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
if (!ring_info) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No more spae left\n");
return -ENOMEM;
}
@@ -313,9 +329,9 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
alloc_unbound.dom = DOMID_SELF;
alloc_unbound.remote_dom = domid;
ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
- &alloc_unbound);
+ &alloc_unbound);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Cannot allocate event channel\n");
kfree(ring_info);
return -EIO;
@@ -327,7 +343,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
NULL, (void*) ring_info);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Failed to setup event channel\n");
close.port = alloc_unbound.port;
HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
@@ -343,7 +359,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
mutex_init(&ring_info->lock);
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: allocated eventchannel gref %d port: %d irq: %d\n",
__func__,
ring_info->gref_ring,
@@ -364,7 +380,7 @@ int hyper_dmabuf_xen_init_tx_rbuf(int domid)
ring_info->watch.node = (const char*) kmalloc(sizeof(char) * 255, GFP_KERNEL);
if (!ring_info->watch.node) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No more space left\n");
kfree(ring_info);
return -ENOMEM;
@@ -414,7 +430,8 @@ void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid)
if (!rx_ring_info)
return;
- BACK_RING_INIT(&(rx_ring_info->ring_back), rx_ring_info->ring_back.sring, PAGE_SIZE);
+ BACK_RING_INIT(&(rx_ring_info->ring_back), rx_ring_info->ring_back.sring,
+ PAGE_SIZE);
}
/* importer needs to know about shared page and port numbers for
@@ -436,25 +453,28 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
ring_info = xen_comm_find_rx_ring(domid);
if (ring_info) {
- dev_info(hyper_dmabuf_private.device,
- "rx ring ch from domid = %d already exist\n", ring_info->sdomain);
+ dev_info(hy_drv_priv->dev,
+ "rx ring ch from domid = %d already exist\n",
+ ring_info->sdomain);
+
return 0;
}
-
ret = xen_comm_get_ring_details(hyper_dmabuf_xen_get_domid(), domid,
&rx_gref, &rx_port);
if (ret) {
- dev_err(hyper_dmabuf_private.device,
- "Domain %d has not created exporter ring for current domain\n", domid);
+ dev_err(hy_drv_priv->dev,
+ "Domain %d has not created exporter ring for current domain\n",
+ domid);
+
return ret;
}
ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
if (!ring_info) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
@@ -465,7 +485,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
map_ops = kmalloc(sizeof(*map_ops), GFP_KERNEL);
if (!map_ops) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
ret = -ENOMEM;
goto fail_no_map_ops;
@@ -476,21 +496,23 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
goto fail_others;
}
- gnttab_set_map_op(&map_ops[0], (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
+ gnttab_set_map_op(&map_ops[0],
+ (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
GNTMAP_host_map, rx_gref, domid);
- gnttab_set_unmap_op(&ring_info->unmap_op, (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
+ gnttab_set_unmap_op(&ring_info->unmap_op,
+ (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
GNTMAP_host_map, -1);
ret = gnttab_map_refs(map_ops, NULL, &shared_ring, 1);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device, "Cannot map ring\n");
+ dev_err(hy_drv_priv->dev, "Cannot map ring\n");
ret = -EFAULT;
goto fail_others;
}
if (map_ops[0].status) {
- dev_err(hyper_dmabuf_private.device, "Ring mapping failed\n");
+ dev_err(hy_drv_priv->dev, "Ring mapping failed\n");
ret = -EFAULT;
goto fail_others;
} else {
@@ -512,7 +534,7 @@ int hyper_dmabuf_xen_init_rx_rbuf(int domid)
ring_info->irq = ret;
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"%s: bound to eventchannel port: %d irq: %d\n", __func__,
rx_port,
ring_info->irq);
@@ -569,7 +591,9 @@ void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid)
return;
SHARED_RING_INIT(tx_ring_info->ring_front.sring);
- FRONT_RING_INIT(&(tx_ring_info->ring_front), tx_ring_info->ring_front.sring, PAGE_SIZE);
+ FRONT_RING_INIT(&(tx_ring_info->ring_front),
+ tx_ring_info->ring_front.sring,
+ PAGE_SIZE);
}
#ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD
@@ -587,20 +611,20 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused)
char buf[128];
int i, dummy;
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"Scanning new tx channel comming from another domain\n");
/* check other domains and schedule another work if driver
* is still running and backend is valid
*/
- if (hyper_dmabuf_private.exited == false &&
- hyper_dmabuf_private.backend_initialized == true) {
+ if (hy_drv_priv &&
+ hy_drv_priv->initialized) {
for (i = DOMID_SCAN_START; i < DOMID_SCAN_END + 1; i++) {
- if (i == hyper_dmabuf_private.domid)
+ if (i == hy_drv_priv->domid)
continue;
- sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", i,
- hyper_dmabuf_private.domid);
+ sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
+ i, hy_drv_priv->domid);
ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", &dummy);
@@ -611,13 +635,14 @@ static void xen_rx_ch_add_delayed(struct work_struct *unused)
ret = hyper_dmabuf_xen_init_rx_rbuf(i);
if (!ret)
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Finishing up setting up rx channel for domain %d\n", i);
}
}
/* check every 10 seconds */
- schedule_delayed_work(&xen_rx_ch_auto_add_work, msecs_to_jiffies(10000));
+ schedule_delayed_work(&xen_rx_ch_auto_add_work,
+ msecs_to_jiffies(10000));
}
}
@@ -630,21 +655,21 @@ void xen_init_comm_env_delayed(struct work_struct *unused)
/* scheduling another work if driver is still running
* and xenstore hasn't been initialized or dom_id hasn't
* been correctly retrieved. */
- if (hyper_dmabuf_private.exited == false &&
- likely(xenstored_ready == 0 ||
- hyper_dmabuf_private.domid == -1)) {
- dev_dbg(hyper_dmabuf_private.device,
- "Xenstore is not ready yet. Re-try this again in 500ms\n");
- schedule_delayed_work(&xen_init_comm_env_work, msecs_to_jiffies(500));
+ if (likely(xenstored_ready == 0 ||
+ hy_drv_priv->domid == -1)) {
+ dev_dbg(hy_drv_priv->dev,
+ "Xenstore not ready Will re-try in 500ms\n");
+ schedule_delayed_work(&xen_init_comm_env_work,
+ msecs_to_jiffies(500));
} else {
ret = xen_comm_setup_data_dir();
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Failed to create data dir in Xenstore\n");
} else {
- dev_info(hyper_dmabuf_private.device,
- "Successfully finished comm env initialization\n");
- hyper_dmabuf_private.backend_initialized = true;
+ dev_info(hy_drv_priv->dev,
+ "Successfully finished comm env init\n");
+ hy_drv_priv->initialized = true;
#ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD
xen_rx_ch_add_delayed(NULL);
@@ -659,20 +684,21 @@ int hyper_dmabuf_xen_init_comm_env(void)
xen_comm_ring_table_init();
- if (unlikely(xenstored_ready == 0 || hyper_dmabuf_private.domid == -1)) {
+ if (unlikely(xenstored_ready == 0 ||
+ hy_drv_priv->domid == -1)) {
xen_init_comm_env_delayed(NULL);
return -1;
}
ret = xen_comm_setup_data_dir();
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Failed to create data dir in Xenstore\n");
} else {
- dev_info(hyper_dmabuf_private.device,
+ dev_info(hy_drv_priv->dev,
"Successfully finished comm env initialization\n");
- hyper_dmabuf_private.backend_initialized = true;
+ hy_drv_priv->initialized = true;
}
return ret;
@@ -691,7 +717,8 @@ void hyper_dmabuf_xen_destroy_comm(void)
xen_comm_destroy_data_dir();
}
-int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
+int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req,
+ int wait)
{
struct xen_comm_front_ring *ring;
struct hyper_dmabuf_req *new_req;
@@ -706,22 +733,21 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
/* find a ring info for the channel */
ring_info = xen_comm_find_tx_ring(domid);
if (!ring_info) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Can't find ring info for the channel\n");
return -ENOENT;
}
- mutex_lock(&ring_info->lock);
ring = &ring_info->ring_front;
do_gettimeofday(&tv_start);
while (RING_FULL(ring)) {
- dev_dbg(hyper_dmabuf_private.device, "RING_FULL\n");
+ dev_dbg(hy_drv_priv->dev, "RING_FULL\n");
if (timeout == 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"Timeout while waiting for an entry in the ring\n");
return -EIO;
}
@@ -731,15 +757,17 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
timeout = 1000;
+ mutex_lock(&ring_info->lock);
+
new_req = RING_GET_REQUEST(ring, ring->req_prod_pvt);
if (!new_req) {
mutex_unlock(&ring_info->lock);
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"NULL REQUEST\n");
return -EIO;
}
- req->request_id = xen_comm_next_req_id();
+ req->req_id = xen_comm_next_req_id();
/* update req_pending with current request */
memcpy(&req_pending, req, sizeof(req_pending));
@@ -756,7 +784,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
if (wait) {
while (timeout--) {
- if (req_pending.status !=
+ if (req_pending.stat !=
HYPER_DMABUF_REQ_NOT_RESPONDED)
break;
usleep_range(100, 120);
@@ -764,7 +792,7 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
if (timeout < 0) {
mutex_unlock(&ring_info->lock);
- dev_err(hyper_dmabuf_private.device, "request timed-out\n");
+ dev_err(hy_drv_priv->dev, "request timed-out\n");
return -EBUSY;
}
@@ -781,10 +809,8 @@ int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait)
}
if (tv_diff.tv_sec != 0 && tv_diff.tv_usec > 16000)
- dev_dbg(hyper_dmabuf_private.device, "send_req:time diff: %ld sec, %ld usec\n",
+ dev_dbg(hy_drv_priv->dev, "send_req:time diff: %ld sec, %ld usec\n",
tv_diff.tv_sec, tv_diff.tv_usec);
-
- return req_pending.status;
}
mutex_unlock(&ring_info->lock);
@@ -808,7 +834,7 @@ static irqreturn_t back_ring_isr(int irq, void *info)
ring_info = (struct xen_comm_rx_ring_info *)info;
ring = &ring_info->ring_back;
- dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s\n", __func__);
do {
rc = ring->req_cons;
@@ -828,13 +854,13 @@ static irqreturn_t back_ring_isr(int irq, void *info)
* the requester
*/
memcpy(&resp, &req, sizeof(resp));
- memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt), &resp,
- sizeof(resp));
+ memcpy(RING_GET_RESPONSE(ring, ring->rsp_prod_pvt),
+ &resp, sizeof(resp));
ring->rsp_prod_pvt++;
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"sending response to exporter for request id:%d\n",
- resp.response_id);
+ resp.resp_id);
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify);
@@ -864,7 +890,7 @@ static irqreturn_t front_ring_isr(int irq, void *info)
ring_info = (struct xen_comm_tx_ring_info *)info;
ring = &ring_info->ring_front;
- dev_dbg(hyper_dmabuf_private.device, "%s\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s\n", __func__);
do {
more_to_do = 0;
@@ -876,33 +902,33 @@ static irqreturn_t front_ring_isr(int irq, void *info)
* in the response
*/
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
"getting response from importer\n");
- if (req_pending.request_id == resp->response_id) {
- req_pending.status = resp->status;
+ if (req_pending.req_id == resp->resp_id) {
+ req_pending.stat = resp->stat;
}
- if (resp->status == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
+ if (resp->stat == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
/* parsing response */
ret = hyper_dmabuf_msg_parse(ring_info->rdomain,
(struct hyper_dmabuf_req *)resp);
if (ret < 0) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"getting error while parsing response\n");
}
- } else if (resp->status == HYPER_DMABUF_REQ_PROCESSED) {
+ } else if (resp->stat == HYPER_DMABUF_REQ_PROCESSED) {
/* for debugging dma_buf remote synchronization */
- dev_dbg(hyper_dmabuf_private.device,
- "original request = 0x%x\n", resp->command);
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
+ "original request = 0x%x\n", resp->cmd);
+ dev_dbg(hy_drv_priv->dev,
"Just got HYPER_DMABUF_REQ_PROCESSED\n");
- } else if (resp->status == HYPER_DMABUF_REQ_ERROR) {
+ } else if (resp->stat == HYPER_DMABUF_REQ_ERROR) {
/* for debugging dma_buf remote synchronization */
- dev_dbg(hyper_dmabuf_private.device,
- "original request = 0x%x\n", resp->command);
- dev_dbg(hyper_dmabuf_private.device,
+ dev_dbg(hy_drv_priv->dev,
+ "original request = 0x%x\n", resp->cmd);
+ dev_dbg(hy_drv_priv->dev,
"Just got HYPER_DMABUF_REQ_ERROR\n");
}
}
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
index 4708b49..7a8ec73 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
@@ -38,8 +38,6 @@
#include "hyper_dmabuf_xen_comm.h"
#include "hyper_dmabuf_xen_comm_list.h"
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
DECLARE_HASHTABLE(xen_comm_tx_ring_hash, MAX_ENTRY_TX_RING);
DECLARE_HASHTABLE(xen_comm_rx_ring_hash, MAX_ENTRY_RX_RING);
@@ -56,7 +54,7 @@ int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info *ring_info)
info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
if (!info_entry) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
@@ -76,7 +74,7 @@ int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info *ring_info)
info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
if (!info_entry) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"No memory left to be allocated\n");
return -ENOMEM;
}
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
index 908eda8..424417d 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
@@ -36,8 +36,6 @@
#define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
-extern struct hyper_dmabuf_private hyper_dmabuf_private;
-
/*
* Creates 2 level page directory structure for referencing shared pages.
* Top level page is a single page that contains up to 1024 refids that
@@ -98,7 +96,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
if (!sh_pages_info) {
- dev_err(hyper_dmabuf_private.device, "No more space left\n");
+ dev_err(hy_drv_priv->dev, "No more space left\n");
return -ENOMEM;
}
@@ -107,10 +105,10 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
/* share data pages in readonly mode for security */
for (i=0; i<nents; i++) {
lvl2_table[i] = gnttab_grant_foreign_access(domid,
- pfn_to_mfn(page_to_pfn(pages[i])),
- true /* read-only from remote domain */);
+ pfn_to_mfn(page_to_pfn(pages[i])),
+ true /* read-only from remote domain */);
if (lvl2_table[i] == -ENOSPC) {
- dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
+ dev_err(hy_drv_priv->dev, "No more space left in grant table\n");
/* Unshare all already shared pages for lvl2 */
while(i--) {
@@ -124,10 +122,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
/* Share 2nd level addressing pages in readonly mode*/
for (i=0; i< n_lvl2_grefs; i++) {
lvl3_table[i] = gnttab_grant_foreign_access(domid,
- virt_to_mfn((unsigned long)lvl2_table+i*PAGE_SIZE ),
- true);
+ virt_to_mfn((unsigned long)lvl2_table+i*PAGE_SIZE ),
+ true);
+
if (lvl3_table[i] == -ENOSPC) {
- dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
+ dev_err(hy_drv_priv->dev, "No more space left in grant table\n");
/* Unshare all already shared pages for lvl3 */
while(i--) {
@@ -147,11 +146,11 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
/* Share lvl3_table in readonly mode*/
lvl3_gref = gnttab_grant_foreign_access(domid,
- virt_to_mfn((unsigned long)lvl3_table),
- true);
+ virt_to_mfn((unsigned long)lvl3_table),
+ true);
if (lvl3_gref == -ENOSPC) {
- dev_err(hyper_dmabuf_private.device, "No more space left in grant table\n");
+ dev_err(hy_drv_priv->dev, "No more space left in grant table\n");
/* Unshare all pages for lvl3 */
while(i--) {
@@ -178,7 +177,7 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
/* Store exported pages refid to be unshared later */
sh_pages_info->lvl3_gref = lvl3_gref;
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return lvl3_gref;
err_cleanup:
@@ -190,16 +189,17 @@ int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
struct xen_shared_pages_info *sh_pages_info;
- int n_lvl2_grefs = (nents/REFS_PER_PAGE + ((nents % REFS_PER_PAGE) ? 1: 0));
+ int n_lvl2_grefs = (nents/REFS_PER_PAGE +
+ ((nents % REFS_PER_PAGE) ? 1: 0));
int i;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
if (sh_pages_info->lvl3_table == NULL ||
sh_pages_info->lvl2_table == NULL ||
sh_pages_info->lvl3_gref == -1) {
- dev_warn(hyper_dmabuf_private.device,
+ dev_warn(hy_drv_priv->dev,
"gref table for hyper_dmabuf already cleaned up\n");
return 0;
}
@@ -207,7 +207,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
/* End foreign access for data pages, but do not free them */
for (i = 0; i < nents; i++) {
if (gnttab_query_foreign_access(sh_pages_info->lvl2_table[i])) {
- dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n");
+ dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
}
gnttab_end_foreign_access_ref(sh_pages_info->lvl2_table[i], 0);
gnttab_free_grant_reference(sh_pages_info->lvl2_table[i]);
@@ -216,17 +216,17 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
/* End foreign access for 2nd level addressing pages */
for (i = 0; i < n_lvl2_grefs; i++) {
if (gnttab_query_foreign_access(sh_pages_info->lvl3_table[i])) {
- dev_warn(hyper_dmabuf_private.device, "refid not shared !!\n");
+ dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
}
if (!gnttab_end_foreign_access_ref(sh_pages_info->lvl3_table[i], 1)) {
- dev_warn(hyper_dmabuf_private.device, "refid still in use!!!\n");
+ dev_warn(hy_drv_priv->dev, "refid still in use!!!\n");
}
gnttab_free_grant_reference(sh_pages_info->lvl3_table[i]);
}
/* End foreign access for top level addressing page */
if (gnttab_query_foreign_access(sh_pages_info->lvl3_gref)) {
- dev_warn(hyper_dmabuf_private.device, "gref not shared !!\n");
+ dev_warn(hy_drv_priv->dev, "gref not shared !!\n");
}
gnttab_end_foreign_access_ref(sh_pages_info->lvl3_gref, 1);
@@ -242,7 +242,7 @@ int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents) {
kfree(sh_pages_info);
sh_pages_info = NULL;
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return 0;
}
@@ -270,27 +270,33 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
/* # of grefs in the last page of lvl2 table */
int nents_last = (nents - 1) % REFS_PER_PAGE + 1;
- int n_lvl2_grefs = (nents / REFS_PER_PAGE) + ((nents_last > 0) ? 1 : 0) -
+ int n_lvl2_grefs = (nents / REFS_PER_PAGE) +
+ ((nents_last > 0) ? 1 : 0) -
(nents_last == REFS_PER_PAGE);
int i, j, k;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
*refs_info = (void *) sh_pages_info;
- lvl2_table_pages = kcalloc(sizeof(struct page*), n_lvl2_grefs, GFP_KERNEL);
+ lvl2_table_pages = kcalloc(sizeof(struct page*), n_lvl2_grefs,
+ GFP_KERNEL);
+
data_pages = kcalloc(sizeof(struct page*), nents, GFP_KERNEL);
- lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs, GFP_KERNEL);
- lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs, GFP_KERNEL);
+ lvl2_map_ops = kcalloc(sizeof(*lvl2_map_ops), n_lvl2_grefs,
+ GFP_KERNEL);
+
+ lvl2_unmap_ops = kcalloc(sizeof(*lvl2_unmap_ops), n_lvl2_grefs,
+ GFP_KERNEL);
data_map_ops = kcalloc(sizeof(*data_map_ops), nents, GFP_KERNEL);
data_unmap_ops = kcalloc(sizeof(*data_unmap_ops), nents, GFP_KERNEL);
/* Map top level addressing page */
if (gnttab_alloc_pages(1, &lvl3_table_page)) {
- dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
+ dev_err(hy_drv_priv->dev, "Cannot allocate pages\n");
return NULL;
}
@@ -304,13 +310,16 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
GNTMAP_host_map | GNTMAP_readonly, -1);
if (gnttab_map_refs(&lvl3_map_ops, NULL, &lvl3_table_page, 1)) {
- dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed");
+ dev_err(hy_drv_priv->dev,
+ "HYPERVISOR map grant ref failed");
return NULL;
}
if (lvl3_map_ops.status) {
- dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed status = %d",
+ dev_err(hy_drv_priv->dev,
+ "HYPERVISOR map grant ref failed status = %d",
lvl3_map_ops.status);
+
goto error_cleanup_lvl3;
} else {
lvl3_unmap_ops.handle = lvl3_map_ops.handle;
@@ -318,35 +327,43 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
/* Map all second level pages */
if (gnttab_alloc_pages(n_lvl2_grefs, lvl2_table_pages)) {
- dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
+ dev_err(hy_drv_priv->dev, "Cannot allocate pages\n");
goto error_cleanup_lvl3;
}
for (i = 0; i < n_lvl2_grefs; i++) {
lvl2_table = (grant_ref_t *)pfn_to_kaddr(page_to_pfn(lvl2_table_pages[i]));
- gnttab_set_map_op(&lvl2_map_ops[i], (unsigned long)lvl2_table, GNTMAP_host_map | GNTMAP_readonly,
+ gnttab_set_map_op(&lvl2_map_ops[i],
+ (unsigned long)lvl2_table, GNTMAP_host_map |
+ GNTMAP_readonly,
lvl3_table[i], domid);
- gnttab_set_unmap_op(&lvl2_unmap_ops[i], (unsigned long)lvl2_table, GNTMAP_host_map | GNTMAP_readonly, -1);
+ gnttab_set_unmap_op(&lvl2_unmap_ops[i],
+ (unsigned long)lvl2_table, GNTMAP_host_map |
+ GNTMAP_readonly, -1);
}
/* Unmap top level page, as it won't be needed any longer */
- if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1)) {
- dev_err(hyper_dmabuf_private.device, "xen: cannot unmap top level page\n");
+ if (gnttab_unmap_refs(&lvl3_unmap_ops, NULL,
+ &lvl3_table_page, 1)) {
+ dev_err(hy_drv_priv->dev,
+ "xen: cannot unmap top level page\n");
return NULL;
} else {
/* Mark that page was unmapped */
lvl3_unmap_ops.handle = -1;
}
- if (gnttab_map_refs(lvl2_map_ops, NULL, lvl2_table_pages, n_lvl2_grefs)) {
- dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed");
+ if (gnttab_map_refs(lvl2_map_ops, NULL,
+ lvl2_table_pages, n_lvl2_grefs)) {
+ dev_err(hy_drv_priv->dev,
+ "HYPERVISOR map grant ref failed");
return NULL;
}
/* Checks if pages were mapped correctly */
for (i = 0; i < n_lvl2_grefs; i++) {
if (lvl2_map_ops[i].status) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"HYPERVISOR map grant ref failed status = %d",
lvl2_map_ops[i].status);
goto error_cleanup_lvl2;
@@ -356,7 +373,8 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
}
if (gnttab_alloc_pages(nents, data_pages)) {
- dev_err(hyper_dmabuf_private.device, "Cannot allocate pages\n");
+ dev_err(hy_drv_priv->dev,
+ "Cannot allocate pages\n");
goto error_cleanup_lvl2;
}
@@ -366,13 +384,13 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
lvl2_table = pfn_to_kaddr(page_to_pfn(lvl2_table_pages[i]));
for (j = 0; j < REFS_PER_PAGE; j++) {
gnttab_set_map_op(&data_map_ops[k],
- (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
- GNTMAP_host_map | GNTMAP_readonly,
- lvl2_table[j], domid);
+ (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
+ GNTMAP_host_map | GNTMAP_readonly,
+ lvl2_table[j], domid);
gnttab_set_unmap_op(&data_unmap_ops[k],
- (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
- GNTMAP_host_map | GNTMAP_readonly, -1);
+ (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
+ GNTMAP_host_map | GNTMAP_readonly, -1);
k++;
}
}
@@ -382,25 +400,29 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
for (j = 0; j < nents_last; j++) {
gnttab_set_map_op(&data_map_ops[k],
- (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
- GNTMAP_host_map | GNTMAP_readonly,
- lvl2_table[j], domid);
+ (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
+ GNTMAP_host_map | GNTMAP_readonly,
+ lvl2_table[j], domid);
gnttab_set_unmap_op(&data_unmap_ops[k],
- (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
- GNTMAP_host_map | GNTMAP_readonly, -1);
+ (unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
+ GNTMAP_host_map | GNTMAP_readonly, -1);
k++;
}
- if (gnttab_map_refs(data_map_ops, NULL, data_pages, nents)) {
- dev_err(hyper_dmabuf_private.device, "HYPERVISOR map grant ref failed\n");
+ if (gnttab_map_refs(data_map_ops, NULL,
+ data_pages, nents)) {
+ dev_err(hy_drv_priv->dev,
+ "HYPERVISOR map grant ref failed\n");
return NULL;
}
/* unmapping lvl2 table pages */
- if (gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages,
+ if (gnttab_unmap_refs(lvl2_unmap_ops,
+ NULL, lvl2_table_pages,
n_lvl2_grefs)) {
- dev_err(hyper_dmabuf_private.device, "Cannot unmap 2nd level refs\n");
+ dev_err(hy_drv_priv->dev,
+ "Cannot unmap 2nd level refs\n");
return NULL;
} else {
/* Mark that pages were unmapped */
@@ -411,7 +433,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
for (i = 0; i < nents; i++) {
if (data_map_ops[i].status) {
- dev_err(hyper_dmabuf_private.device,
+ dev_err(hy_drv_priv->dev,
"HYPERVISOR map grant ref failed status = %d\n",
data_map_ops[i].status);
goto error_cleanup_data;
@@ -431,7 +453,7 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
kfree(lvl2_unmap_ops);
kfree(data_map_ops);
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return data_pages;
error_cleanup_data:
@@ -442,13 +464,14 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
error_cleanup_lvl2:
if (lvl2_unmap_ops[0].handle != -1)
- gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages,
- n_lvl2_grefs);
+ gnttab_unmap_refs(lvl2_unmap_ops, NULL,
+ lvl2_table_pages, n_lvl2_grefs);
gnttab_free_pages(n_lvl2_grefs, lvl2_table_pages);
error_cleanup_lvl3:
if (lvl3_unmap_ops.handle != -1)
- gnttab_unmap_refs(&lvl3_unmap_ops, NULL, &lvl3_table_page, 1);
+ gnttab_unmap_refs(&lvl3_unmap_ops, NULL,
+ &lvl3_table_page, 1);
gnttab_free_pages(1, &lvl3_table_page);
kfree(lvl2_table_pages);
@@ -463,20 +486,20 @@ struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int n
int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
struct xen_shared_pages_info *sh_pages_info;
- dev_dbg(hyper_dmabuf_private.device, "%s entry\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
if (sh_pages_info->unmap_ops == NULL ||
sh_pages_info->data_pages == NULL) {
- dev_warn(hyper_dmabuf_private.device,
- "Imported pages already cleaned up or buffer was not imported yet\n");
+ dev_warn(hy_drv_priv->dev,
+ "pages already cleaned up or buffer not imported yet\n");
return 0;
}
if (gnttab_unmap_refs(sh_pages_info->unmap_ops, NULL,
sh_pages_info->data_pages, nents) ) {
- dev_err(hyper_dmabuf_private.device, "Cannot unmap data pages\n");
+ dev_err(hy_drv_priv->dev, "Cannot unmap data pages\n");
return -EFAULT;
}
@@ -489,6 +512,6 @@ int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
kfree(sh_pages_info);
sh_pages_info = NULL;
- dev_dbg(hyper_dmabuf_private.device, "%s exit\n", __func__);
+ dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
return 0;
}
--
2.7.4
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xenproject.org
https://lists.xenproject.org/mailman/listinfo/xen-devel
next prev parent reply other threads:[~2017-12-19 19:40 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 ` Dongwon Kim [this message]
2017-12-19 19:30 ` [RFC PATCH 49/60] hyper_dmabuf: general clean-up and fixes 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
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-49-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.