lkml.org 
[lkml]   [2017]   [Dec]   [19]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[RFC PATCH 49/60] hyper_dmabuf: general clean-up and fixes
Date
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
\
 
 \ /
  Last update: 2017-12-19 20:41    [W:0.721 / U:0.256 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site