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 16/60] hyper_dmabuf: define hypervisor specific backend API
Date
For adoption of hyper_dmabuf driver to various hypervisors
other than Xen, a "backend" layer is defined and separated out
from existing one-body structure.

"Backend" is basically a list of entry points of function calls
that provides method to do Kernel's page-level sharing and inter
VMs communication using hypervisor's native mechanism (hypercall).

All backend APIs are listed up in "struct hyper_dmabuf_backend_ops"
as shown below.

struct hyper_dmabuf_backend_ops {
/* retreiving id of current virtual machine */
int (*get_vm_id)(void);

/* get pages shared via hypervisor-specific method */
int (*share_pages)(struct page **, int, int, void **);

/* make shared pages unshared via hypervisor specific method */
int (*unshare_pages)(void **, int);

/* map remotely shared pages on importer's side via
* hypervisor-specific method
*/
struct page ** (*map_shared_pages)(int, int, int, void **);

/* unmap and free shared pages on importer's side via
* hypervisor-specific method
*/
int (*unmap_shared_pages)(void **, int);

/* initialize communication environment */
int (*init_comm_env)(void);

void (*destroy_comm)(void);

/* upstream ch setup (receiving and responding) */
int (*init_rx_ch)(int);

/* downstream ch setup (transmitting and parsing responses) */
int (*init_tx_ch)(int);

int (*send_req)(int, struct hyper_dmabuf_req *, int);
};

Within this new structure, only backend APIs need to be re-designed or
replaced with new ones when porting this sharing model to a different
hypervisor environment, which is a lot simpler than completely redesiging
whole driver for a new hypervisor.

Signed-off-by: Dongwon Kim <dongwon.kim@intel.com>
---
drivers/xen/hyper_dmabuf/Makefile | 11 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h | 1 -
drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c | 33 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h | 112 ++----
drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c | 6 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c | 426 ++-------------------
drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h | 14 -
drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 134 +++----
drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h | 87 +++++
drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c | 52 ++-
drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h | 23 +-
.../xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c | 4 +-
drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 26 +-
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c | 303 +++++++++------
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h | 51 +--
.../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c | 67 ++--
.../hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h | 32 +-
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c | 22 ++
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h | 20 +
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c | 356 +++++++++++++++++
.../xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h | 19 +
21 files changed, 949 insertions(+), 850 deletions(-)
create mode 100644 drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
create mode 100644 drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c
create mode 100644 drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h
create mode 100644 drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
create mode 100644 drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h

diff --git a/drivers/xen/hyper_dmabuf/Makefile b/drivers/xen/hyper_dmabuf/Makefile
index c9b8b7f..d90cfc3 100644
--- a/drivers/xen/hyper_dmabuf/Makefile
+++ b/drivers/xen/hyper_dmabuf/Makefile
@@ -1,5 +1,7 @@
TARGET_MODULE:=hyper_dmabuf

+PLATFORM:=XEN
+
# If we running by kernel building system
ifneq ($(KERNELRELEASE),)
$(TARGET_MODULE)-objs := hyper_dmabuf_drv.o \
@@ -9,8 +11,13 @@ ifneq ($(KERNELRELEASE),)
hyper_dmabuf_msg.o \
hyper_dmabuf_id.o \
hyper_dmabuf_remote_sync.o \
- xen/hyper_dmabuf_xen_comm.o \
- xen/hyper_dmabuf_xen_comm_list.o
+
+ifeq ($(CONFIG_XEN), y)
+ $(TARGET_MODULE)-objs += xen/hyper_dmabuf_xen_comm.o \
+ xen/hyper_dmabuf_xen_comm_list.o \
+ xen/hyper_dmabuf_xen_shm.o \
+ xen/hyper_dmabuf_xen_drv.o
+endif

obj-$(CONFIG_HYPER_DMABUF) := $(TARGET_MODULE).o

diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
index 3d9b2d6..d012b05 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_conf.h
@@ -1,2 +1 @@
#define CURRENT_TARGET XEN
-#define INTER_DOMAIN_DMABUF_SYNCHRONIZATION
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
index 66d6cb9..ddcc955 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.c
@@ -1,15 +1,18 @@
-#include <linux/init.h> /* module_init, module_exit */
-#include <linux/module.h> /* version info, MODULE_LICENSE, MODULE_AUTHOR, printk() */
+#include <linux/init.h>
+#include <linux/module.h>
#include <linux/workqueue.h>
-#include <xen/grant_table.h>
-#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_conf.h"
+#include "hyper_dmabuf_msg.h"
+#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_list.h"
#include "hyper_dmabuf_id.h"
-#include "xen/hyper_dmabuf_xen_comm_list.h"
-#include "xen/hyper_dmabuf_xen_comm.h"

-MODULE_LICENSE("Dual BSD/GPL");
+#ifdef CONFIG_XEN
+#include "xen/hyper_dmabuf_xen_drv.h"
+extern struct hyper_dmabuf_backend_ops xen_backend_ops;
+#endif
+
+MODULE_LICENSE("GPL");
MODULE_AUTHOR("IOTG-PED, INTEL");

int register_device(void);
@@ -29,24 +32,24 @@ static int hyper_dmabuf_drv_init(void)
return -EINVAL;
}

+#ifdef CONFIG_XEN
+ hyper_dmabuf_private.backend_ops = &xen_backend_ops;
+#endif
+
printk( KERN_NOTICE "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");
- hyper_dmabuf_private.domid = hyper_dmabuf_get_domid();
+ hyper_dmabuf_private.domid = hyper_dmabuf_private.backend_ops->get_vm_id();

ret = hyper_dmabuf_table_init();
if (ret < 0) {
return -EINVAL;
}

- ret = hyper_dmabuf_ring_table_init();
- if (ret < 0) {
- return -EINVAL;
- }
+ ret = hyper_dmabuf_private.backend_ops->init_comm_env();

- ret = hyper_dmabuf_setup_data_dir();
if (ret < 0) {
return -EINVAL;
}
@@ -61,8 +64,7 @@ static void hyper_dmabuf_drv_exit(void)
/* hash tables for export/import entries and ring_infos */
hyper_dmabuf_table_destroy();

- hyper_dmabuf_cleanup_ringbufs();
- hyper_dmabuf_ring_table_destroy();
+ hyper_dmabuf_private.backend_ops->destroy_comm();

/* destroy workqueue */
if (hyper_dmabuf_private.work_queue)
@@ -72,7 +74,6 @@ static void hyper_dmabuf_drv_exit(void)
if (hyper_dmabuf_private.id_queue)
destroy_reusable_list();

- hyper_dmabuf_destroy_data_dir();
printk( KERN_NOTICE "dma_buf-src_sink model: Exiting" );
unregister_device();
}
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
index 37b0cc1..03d77d7 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_drv.h
@@ -6,94 +6,48 @@ struct list_reusable_id {
struct list_head list;
};

-struct hyper_dmabuf_private {
- struct device *device;
- int domid;
- struct workqueue_struct *work_queue;
- struct list_reusable_id *id_queue;
-};
+struct hyper_dmabuf_backend_ops {
+ /* retreiving id of current virtual machine */
+ int (*get_vm_id)(void);

-typedef int (*hyper_dmabuf_ioctl_t)(void *data);
+ /* get pages shared via hypervisor-specific method */
+ int (*share_pages)(struct page **, int, int, void **);

-struct hyper_dmabuf_ioctl_desc {
- unsigned int cmd;
- int flags;
- hyper_dmabuf_ioctl_t func;
- const char *name;
-};
+ /* make shared pages unshared via hypervisor specific method */
+ int (*unshare_pages)(void **, int);

-#define HYPER_DMABUF_IOCTL_DEF(ioctl, _func, _flags) \
- [_IOC_NR(ioctl)] = { \
- .cmd = ioctl, \
- .func = _func, \
- .flags = _flags, \
- .name = #ioctl \
- }
+ /* map remotely shared pages on importer's side via
+ * hypervisor-specific method
+ */
+ struct page ** (*map_shared_pages)(int, int, int, void **);

-#define IOCTL_HYPER_DMABUF_EXPORTER_RING_SETUP \
-_IOC(_IOC_NONE, 'G', 0, sizeof(struct ioctl_hyper_dmabuf_exporter_ring_setup))
-struct ioctl_hyper_dmabuf_exporter_ring_setup {
- /* IN parameters */
- /* Remote domain id */
- uint32_t remote_domain;
-};
+ /* unmap and free shared pages on importer's side via
+ * hypervisor-specific method
+ */
+ int (*unmap_shared_pages)(void **, int);

-#define IOCTL_HYPER_DMABUF_IMPORTER_RING_SETUP \
-_IOC(_IOC_NONE, 'G', 1, sizeof(struct ioctl_hyper_dmabuf_importer_ring_setup))
-struct ioctl_hyper_dmabuf_importer_ring_setup {
- /* IN parameters */
- /* Source domain id */
- uint32_t source_domain;
-};
+ /* initialize communication environment */
+ int (*init_comm_env)(void);

-#define IOCTL_HYPER_DMABUF_EXPORT_REMOTE \
-_IOC(_IOC_NONE, 'G', 2, sizeof(struct ioctl_hyper_dmabuf_export_remote))
-struct ioctl_hyper_dmabuf_export_remote {
- /* IN parameters */
- /* DMA buf fd to be exported */
- uint32_t dmabuf_fd;
- /* Domain id to which buffer should be exported */
- uint32_t remote_domain;
- /* exported dma buf id */
- uint32_t hyper_dmabuf_id;
- uint32_t private[4];
-};
+ void (*destroy_comm)(void);

-#define IOCTL_HYPER_DMABUF_EXPORT_FD \
-_IOC(_IOC_NONE, 'G', 3, sizeof(struct ioctl_hyper_dmabuf_export_fd))
-struct ioctl_hyper_dmabuf_export_fd {
- /* IN parameters */
- /* hyper dmabuf id to be imported */
- uint32_t hyper_dmabuf_id;
- /* flags */
- uint32_t flags;
- /* OUT parameters */
- /* exported dma buf fd */
- uint32_t fd;
-};
+ /* upstream ch setup (receiving and responding) */
+ int (*init_rx_ch)(int);
+
+ /* downstream ch setup (transmitting and parsing responses) */
+ int (*init_tx_ch)(int);

-#define IOCTL_HYPER_DMABUF_UNEXPORT \
-_IOC(_IOC_NONE, 'G', 4, sizeof(struct ioctl_hyper_dmabuf_unexport))
-struct ioctl_hyper_dmabuf_unexport {
- /* IN parameters */
- /* hyper dmabuf id to be unexported */
- uint32_t hyper_dmabuf_id;
- /* OUT parameters */
- /* Status of request */
- uint32_t status;
+ int (*send_req)(int, struct hyper_dmabuf_req *, int);
};

-#define IOCTL_HYPER_DMABUF_QUERY \
-_IOC(_IOC_NONE, 'G', 5, sizeof(struct ioctl_hyper_dmabuf_query))
-struct ioctl_hyper_dmabuf_query {
- /* in parameters */
- /* hyper dmabuf id to be queried */
- uint32_t hyper_dmabuf_id;
- /* item to be queried */
- uint32_t item;
- /* OUT parameters */
- /* Value of queried item */
- uint32_t info;
+struct hyper_dmabuf_private {
+ struct device *device;
+ int domid;
+ struct workqueue_struct *work_queue;
+ struct list_reusable_id *id_queue;
+
+ /* backend ops - hypervisor specific */
+ struct hyper_dmabuf_backend_ops *backend_ops;
};

-#endif //__LINUX_PUBLIC_HYPER_DMABUF_DRV_H__
+#endif /* __LINUX_PUBLIC_HYPER_DMABUF_DRV_H__ */
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
index 7bbb179..b58a111 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_id.c
@@ -1,5 +1,6 @@
#include <linux/list.h>
#include <linux/slab.h>
+#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_id.h"

@@ -19,6 +20,7 @@ void store_reusable_id(int id)
static int retrieve_reusable_id(void)
{
struct list_reusable_id *reusable_head = hyper_dmabuf_private.id_queue;
+ int id;

/* check there is reusable id */
if (!list_empty(&reusable_head->list)) {
@@ -27,7 +29,9 @@ static int retrieve_reusable_id(void)
list);

list_del(&reusable_head->list);
- return reusable_head->id;
+ id = reusable_head->id;
+ kfree(reusable_head);
+ return id;
}

return -1;
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
index b109138..0f104b9 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.c
@@ -8,10 +8,12 @@
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_imp.h"
#include "hyper_dmabuf_id.h"
-#include "xen/hyper_dmabuf_xen_comm.h"
#include "hyper_dmabuf_msg.h"
+#include "hyper_dmabuf_drv.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)
@@ -138,397 +140,10 @@ struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
/* free sg_table */
void hyper_dmabuf_free_sgt(struct sg_table* sgt)
{
- sg_free_table(sgt);
- kfree(sgt);
-}
-
-/*
- * Creates 2 level page directory structure for referencing shared pages.
- * Top level page is a single page that contains up to 1024 refids that
- * point to 2nd level pages.
- * Each 2nd level page contains up to 1024 refids that point to shared
- * data pages.
- * There will always be one top level page and number of 2nd level pages
- * depends on number of shared data pages.
- *
- * Top level page 2nd level pages Data pages
- * +-------------------------+ ┌>+--------------------+ ┌--->+------------+
- * |2nd level page 0 refid |---┘ |Data page 0 refid |-┘ |Data page 0 |
- * |2nd level page 1 refid |---┐ |Data page 1 refid |-┐ +------------+
- * | ... | | | .... | |
- * |2nd level page 1023 refid|-┐ | |Data page 1023 refid| └--->+------------+
- * +-------------------------+ | | +--------------------+ |Data page 1 |
- * | | +------------+
- * | └>+--------------------+
- * | |Data page 1024 refid|
- * | |Data page 1025 refid|
- * | | ... |
- * | |Data page 2047 refid|
- * | +--------------------+
- * |
- * | .....
- * └-->+-----------------------+
- * |Data page 1047552 refid|
- * |Data page 1047553 refid|
- * | ... |
- * |Data page 1048575 refid|-->+------------------+
- * +-----------------------+ |Data page 1048575 |
- * +------------------+
- *
- * Using such 2 level structure it is possible to reference up to 4GB of
- * shared data using single refid pointing to top level page.
- *
- * Returns refid of top level page.
- */
-grant_ref_t hyper_dmabuf_create_addressing_tables(grant_ref_t *data_refs, int nents, int rdomain,
- struct hyper_dmabuf_shared_pages_info *shared_pages_info)
-{
- /*
- * Calculate number of pages needed for 2nd level addresing:
- */
- int n_2nd_level_pages = (nents/REFS_PER_PAGE +
- ((nents % REFS_PER_PAGE) ? 1: 0));
- int i;
- unsigned long gref_page_start;
- grant_ref_t *tmp_page;
- grant_ref_t top_level_ref;
- grant_ref_t * addr_refs;
- addr_refs = kcalloc(sizeof(grant_ref_t), n_2nd_level_pages, GFP_KERNEL);
-
- gref_page_start = __get_free_pages(GFP_KERNEL, n_2nd_level_pages);
- tmp_page = (grant_ref_t *)gref_page_start;
-
- /* Store 2nd level pages to be freed later */
- shared_pages_info->addr_pages = tmp_page;
-
- /*TODO: make sure that allocated memory is filled with 0*/
-
- /* Share 2nd level addressing pages in readonly mode*/
- for (i=0; i< n_2nd_level_pages; i++) {
- addr_refs[i] = gnttab_grant_foreign_access(rdomain,
- virt_to_mfn((unsigned long)tmp_page+i*PAGE_SIZE ),
- 1);
- }
-
- /*
- * fill second level pages with data refs
- */
- for (i = 0; i < nents; i++) {
- tmp_page[i] = data_refs[i];
- }
-
-
- /* allocate top level page */
- gref_page_start = __get_free_pages(GFP_KERNEL, 1);
- tmp_page = (grant_ref_t *)gref_page_start;
-
- /* Store top level page to be freed later */
- shared_pages_info->top_level_page = tmp_page;
-
- /*
- * fill top level page with reference numbers of second level pages refs.
- */
- for (i=0; i< n_2nd_level_pages; i++) {
- tmp_page[i] = addr_refs[i];
- }
-
- /* Share top level addressing page in readonly mode*/
- top_level_ref = gnttab_grant_foreign_access(rdomain,
- virt_to_mfn((unsigned long)tmp_page),
- 1);
-
- kfree(addr_refs);
-
- return top_level_ref;
-}
-
-/*
- * Maps provided top level ref id and then return array of pages containing data refs.
- */
-struct page** hyper_dmabuf_get_data_refs(grant_ref_t top_level_ref, int domid, int nents,
- struct hyper_dmabuf_shared_pages_info *shared_pages_info)
-{
- struct page *top_level_page;
- struct page **level2_pages;
-
- grant_ref_t *top_level_refs;
-
- struct gnttab_map_grant_ref top_level_map_ops;
- struct gnttab_unmap_grant_ref top_level_unmap_ops;
-
- struct gnttab_map_grant_ref *map_ops;
- struct gnttab_unmap_grant_ref *unmap_ops;
-
- unsigned long addr;
- int n_level2_refs = 0;
- int i;
-
- n_level2_refs = (nents / REFS_PER_PAGE) + ((nents % REFS_PER_PAGE) ? 1 : 0);
-
- level2_pages = kcalloc(sizeof(struct page*), n_level2_refs, GFP_KERNEL);
-
- map_ops = kcalloc(sizeof(map_ops[0]), REFS_PER_PAGE, GFP_KERNEL);
- unmap_ops = kcalloc(sizeof(unmap_ops[0]), REFS_PER_PAGE, GFP_KERNEL);
-
- /* Map top level addressing page */
- if (gnttab_alloc_pages(1, &top_level_page)) {
- printk("Cannot allocate pages\n");
- return NULL;
- }
-
- addr = (unsigned long)pfn_to_kaddr(page_to_pfn(top_level_page));
- gnttab_set_map_op(&top_level_map_ops, addr, GNTMAP_host_map | GNTMAP_readonly,
- top_level_ref, domid);
-
- gnttab_set_unmap_op(&top_level_unmap_ops, addr, GNTMAP_host_map | GNTMAP_readonly, -1);
-
- if (gnttab_map_refs(&top_level_map_ops, NULL, &top_level_page, 1)) {
- printk("\nxen: dom0: HYPERVISOR map grant ref failed");
- return NULL;
- }
-
- if (top_level_map_ops.status) {
- printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d",
- top_level_map_ops.status);
- return NULL;
- } else {
- top_level_unmap_ops.handle = top_level_map_ops.handle;
- }
-
- /* Parse contents of top level addressing page to find how many second level pages is there*/
- top_level_refs = pfn_to_kaddr(page_to_pfn(top_level_page));
-
- /* Map all second level pages */
- if (gnttab_alloc_pages(n_level2_refs, level2_pages)) {
- printk("Cannot allocate pages\n");
- return NULL;
- }
-
- for (i = 0; i < n_level2_refs; i++) {
- addr = (unsigned long)pfn_to_kaddr(page_to_pfn(level2_pages[i]));
- gnttab_set_map_op(&map_ops[i], addr, GNTMAP_host_map | GNTMAP_readonly,
- top_level_refs[i], domid);
- gnttab_set_unmap_op(&unmap_ops[i], addr, GNTMAP_host_map | GNTMAP_readonly, -1);
- }
-
- if (gnttab_map_refs(map_ops, NULL, level2_pages, n_level2_refs)) {
- printk("\nxen: dom0: HYPERVISOR map grant ref failed");
- return NULL;
- }
-
- /* Checks if pages were mapped correctly and at the same time is calculating total number of data refids*/
- for (i = 0; i < n_level2_refs; i++) {
- if (map_ops[i].status) {
- printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d",
- map_ops[i].status);
- return NULL;
- } else {
- unmap_ops[i].handle = map_ops[i].handle;
- }
- }
-
- /* Unmap top level page, as it won't be needed any longer */
- if (gnttab_unmap_refs(&top_level_unmap_ops, NULL, &top_level_page, 1)) {
- printk("\xen: cannot unmap top level page\n");
- return NULL;
- }
-
- gnttab_free_pages(1, &top_level_page);
- kfree(map_ops);
- shared_pages_info->unmap_ops = unmap_ops;
-
- return level2_pages;
-}
-
-
-/* This collects all reference numbers for 2nd level shared pages and create a table
- * with those in 1st level shared pages then return reference numbers for this top level
- * table. */
-grant_ref_t hyper_dmabuf_create_gref_table(struct page **pages, int rdomain, int nents,
- struct hyper_dmabuf_shared_pages_info *shared_pages_info)
-{
- int i = 0;
- grant_ref_t *data_refs;
- grant_ref_t top_level_ref;
-
- /* allocate temp array for refs of shared data pages */
- data_refs = kcalloc(nents, sizeof(grant_ref_t), GFP_KERNEL);
-
- /* share data pages in rw mode*/
- for (i=0; i<nents; i++) {
- data_refs[i] = gnttab_grant_foreign_access(rdomain,
- pfn_to_mfn(page_to_pfn(pages[i])),
- 0);
- }
-
- /* create additional shared pages with 2 level addressing of data pages */
- top_level_ref = hyper_dmabuf_create_addressing_tables(data_refs, nents, rdomain,
- shared_pages_info);
-
- /* Store exported pages refid to be unshared later */
- shared_pages_info->data_refs = data_refs;
- shared_pages_info->top_level_ref = top_level_ref;
-
- return top_level_ref;
-}
-
-int hyper_dmabuf_cleanup_gref_table(struct hyper_dmabuf_sgt_info *sgt_info) {
- uint32_t i = 0;
- struct hyper_dmabuf_shared_pages_info *shared_pages_info = &sgt_info->shared_pages_info;
-
- grant_ref_t *ref = shared_pages_info->top_level_page;
- int n_2nd_level_pages = (sgt_info->nents/REFS_PER_PAGE +
- ((sgt_info->nents % REFS_PER_PAGE) ? 1: 0));
-
-
- if (shared_pages_info->data_refs == NULL ||
- shared_pages_info->addr_pages == NULL ||
- shared_pages_info->top_level_page == NULL ||
- shared_pages_info->top_level_ref == -1) {
- printk("gref table for hyper_dmabuf already cleaned up\n");
- return 0;
- }
-
- /* End foreign access for 2nd level addressing pages */
- while(ref[i] != 0 && i < n_2nd_level_pages) {
- if (gnttab_query_foreign_access(ref[i])) {
- printk("refid not shared !!\n");
- }
- if (!gnttab_end_foreign_access_ref(ref[i], 1)) {
- printk("refid still in use!!!\n");
- }
- gnttab_free_grant_reference(ref[i]);
- i++;
- }
- free_pages((unsigned long)shared_pages_info->addr_pages, i);
-
-
- /* End foreign access for top level addressing page */
- if (gnttab_query_foreign_access(shared_pages_info->top_level_ref)) {
- printk("refid not shared !!\n");
- }
- gnttab_end_foreign_access_ref(shared_pages_info->top_level_ref, 1);
- gnttab_free_grant_reference(shared_pages_info->top_level_ref);
-
- free_pages((unsigned long)shared_pages_info->top_level_page, 1);
-
- /* End foreign access for data pages, but do not free them */
- for (i = 0; i < sgt_info->nents; i++) {
- if (gnttab_query_foreign_access(shared_pages_info->data_refs[i])) {
- printk("refid not shared !!\n");
- }
- gnttab_end_foreign_access_ref(shared_pages_info->data_refs[i], 0);
- gnttab_free_grant_reference(shared_pages_info->data_refs[i]);
- }
-
- kfree(shared_pages_info->data_refs);
-
- shared_pages_info->data_refs = NULL;
- shared_pages_info->addr_pages = NULL;
- shared_pages_info->top_level_page = NULL;
- shared_pages_info->top_level_ref = -1;
-
- return 0;
-}
-
-int hyper_dmabuf_cleanup_imported_pages(struct hyper_dmabuf_imported_sgt_info *sgt_info) {
- struct hyper_dmabuf_shared_pages_info *shared_pages_info = &sgt_info->shared_pages_info;
-
- if(shared_pages_info->unmap_ops == NULL ||
- shared_pages_info->data_pages == NULL) {
- printk("Imported pages already cleaned up or buffer was not imported yet\n");
- return 0;
- }
-
- if (gnttab_unmap_refs(shared_pages_info->unmap_ops, NULL,
- shared_pages_info->data_pages, sgt_info->nents) ) {
- printk("Cannot unmap data pages\n");
- return -EINVAL;
- }
-
- gnttab_free_pages(sgt_info->nents, shared_pages_info->data_pages);
- kfree(shared_pages_info->data_pages);
- kfree(shared_pages_info->unmap_ops);
- shared_pages_info->unmap_ops = NULL;
- shared_pages_info->data_pages = NULL;
-
- return 0;
-}
-
-/* map and construct sg_lists from reference numbers */
-struct sg_table* hyper_dmabuf_map_pages(grant_ref_t top_level_gref, int frst_ofst,
- int last_len, int nents, int sdomain,
- struct hyper_dmabuf_shared_pages_info *shared_pages_info)
-{
- struct sg_table *st;
- struct page **pages;
- struct gnttab_map_grant_ref *ops;
- struct gnttab_unmap_grant_ref *unmap_ops;
- unsigned long addr;
- grant_ref_t *refs;
- int i;
- int n_level2_refs = (nents / REFS_PER_PAGE) + ((nents % REFS_PER_PAGE) ? 1 : 0);
-
- /* Get data refids */
- struct page** refid_pages = hyper_dmabuf_get_data_refs(top_level_gref, sdomain, nents,
- shared_pages_info);
-
- pages = kcalloc(sizeof(struct page*), nents, GFP_KERNEL);
- if (pages == NULL) {
- return NULL;
- }
-
- /* allocate new pages that are mapped to shared pages via grant-table */
- if (gnttab_alloc_pages(nents, pages)) {
- printk("Cannot allocate pages\n");
- return NULL;
- }
-
- ops = kcalloc(nents, sizeof(struct gnttab_map_grant_ref),
- GFP_KERNEL);
- unmap_ops = kcalloc(nents, sizeof(struct gnttab_unmap_grant_ref),
- GFP_KERNEL);
-
- for (i=0; i<nents; i++) {
- addr = (unsigned long)pfn_to_kaddr(page_to_pfn(pages[i]));
- refs = pfn_to_kaddr(page_to_pfn(refid_pages[i / REFS_PER_PAGE]));
- gnttab_set_map_op(&ops[i], addr, GNTMAP_host_map | GNTMAP_readonly,
- refs[i % REFS_PER_PAGE], sdomain);
- gnttab_set_unmap_op(&unmap_ops[i], addr, GNTMAP_host_map | GNTMAP_readonly, -1);
- }
-
- if (gnttab_map_refs(ops, NULL, pages, nents)) {
- printk("\nxen: dom0: HYPERVISOR map grant ref failed\n");
- return NULL;
- }
-
- for (i=0; i<nents; i++) {
- if (ops[i].status) {
- printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d\n",
- ops[0].status);
- return NULL;
- } else {
- unmap_ops[i].handle = ops[i].handle;
- }
+ if (sgt) {
+ sg_free_table(sgt);
+ kfree(sgt);
}
-
- st = hyper_dmabuf_create_sgt(pages, frst_ofst, last_len, nents);
-
- if (gnttab_unmap_refs(shared_pages_info->unmap_ops, NULL, refid_pages,
- n_level2_refs) ) {
- printk("Cannot unmap 2nd level refs\n");
- return NULL;
- }
-
- gnttab_free_pages(n_level2_refs, refid_pages);
- kfree(refid_pages);
-
- kfree(shared_pages_info->unmap_ops);
- shared_pages_info->unmap_ops = unmap_ops;
- shared_pages_info->data_pages = pages;
- kfree(ops);
-
- return st;
}

int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force)
@@ -537,6 +152,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
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;

if (!sgt_info) {
printk("invalid hyper_dmabuf_id\n");
@@ -598,7 +214,7 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
}

/* Start cleanup of buffer in reverse order to exporting */
- hyper_dmabuf_cleanup_gref_table(sgt_info);
+ ops->unshare_pages(&sgt_info->refs_info, sgt_info->nents);

/* unmap dma-buf */
dma_buf_unmap_attachment(sgt_info->active_attached->attach,
@@ -620,21 +236,22 @@ int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int fo
return 0;
}

-inline int hyper_dmabuf_sync_request_and_wait(int id, int ops)
+inline int hyper_dmabuf_sync_request_and_wait(int id, int dmabuf_ops)
{
- struct hyper_dmabuf_ring_rq *req;
+ struct hyper_dmabuf_req *req;
+ struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
int operands[2];
int ret;

operands[0] = id;
- operands[1] = ops;
+ operands[1] = dmabuf_ops;

req = kcalloc(1, sizeof(*req), GFP_KERNEL);

hyper_dmabuf_create_request(req, HYPER_DMABUF_OPS_TO_SOURCE, &operands[0]);

/* send request and wait for a response */
- ret = hyper_dmabuf_send_request(HYPER_DMABUF_DOM_ID(id), req, true);
+ ret = ops->send_req(HYPER_DMABUF_DOM_ID(id), req, true);

kfree(req);

@@ -753,6 +370,7 @@ static void hyper_dmabuf_ops_unmap(struct dma_buf_attachment *attachment,
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;
int ret;
int final_release;

@@ -761,16 +379,22 @@ static void hyper_dmabuf_ops_release(struct dma_buf *dma_buf)

sgt_info = (struct hyper_dmabuf_imported_sgt_info *)dma_buf->priv;

- final_release = sgt_info && !sgt_info->valid &&
- !dmabuf_refcount(sgt_info->dma_buf);
-
if (!dmabuf_refcount(sgt_info->dma_buf)) {
sgt_info->dma_buf = NULL;
}

- if (final_release) {
- hyper_dmabuf_cleanup_imported_pages(sgt_info);
+ sgt_info->num_importers--;
+
+ if (sgt_info->num_importers == 0) {
+ ops->unmap_shared_pages(&sgt_info->refs_info, sgt_info->nents);
hyper_dmabuf_free_sgt(sgt_info->sgt);
+ sgt_info->sgt = NULL;
+ }
+
+ final_release = sgt_info && !sgt_info->valid &&
+ !sgt_info->num_importers;
+
+ if (final_release) {
ret = hyper_dmabuf_sync_request_and_wait(sgt_info->hyper_dmabuf_id,
HYPER_DMABUF_OPS_RELEASE_FINAL);
} else {
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h
index 1b0801f..a4a6d63 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_imp.h
@@ -11,20 +11,6 @@ struct hyper_dmabuf_pages_info *hyper_dmabuf_ext_pgs(struct sg_table *sgt);
struct sg_table* hyper_dmabuf_create_sgt(struct page **pages,
int frst_ofst, int last_len, int nents);

-grant_ref_t hyper_dmabuf_create_gref_table(struct page **pages, int rdomain, int nents,
- struct hyper_dmabuf_shared_pages_info *shared_pages_info);
-
-int hyper_dmabuf_cleanup_gref_table(struct hyper_dmabuf_sgt_info *sgt_info);
-
-int hyper_dmabuf_cleanup_imported_pages(struct hyper_dmabuf_imported_sgt_info *sgt_info);
-
-/* map first level tables that contains reference numbers for actual shared pages */
-grant_ref_t *hyper_dmabuf_map_gref_table(grant_ref_t *gref_table, int n_pages_table);
-
-/* map and construct sg_lists from reference numbers */
-struct sg_table* hyper_dmabuf_map_pages(grant_ref_t gref, int frst_ofst, int last_len, int nents, int sdomain,
- struct hyper_dmabuf_shared_pages_info *shared_pages_info);
-
int hyper_dmabuf_cleanup_sgt_info(struct hyper_dmabuf_sgt_info *sgt_info, int force);

void hyper_dmabuf_free_sgt(struct sg_table *sgt);
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
index 5c6d9c8..70107bb 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c
@@ -8,47 +8,37 @@
#include <linux/delay.h>
#include <linux/list.h>
#include "hyper_dmabuf_struct.h"
-#include "hyper_dmabuf_imp.h"
+#include "hyper_dmabuf_ioctl.h"
#include "hyper_dmabuf_list.h"
+#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_id.h"
+#include "hyper_dmabuf_imp.h"
#include "hyper_dmabuf_query.h"
-#include "xen/hyper_dmabuf_xen_comm.h"
-#include "xen/hyper_dmabuf_xen_comm_list.h"
-#include "hyper_dmabuf_msg.h"

extern struct hyper_dmabuf_private hyper_dmabuf_private;

-static int hyper_dmabuf_exporter_ring_setup(void *data)
+static int hyper_dmabuf_tx_ch_setup(void *data)
{
- struct ioctl_hyper_dmabuf_exporter_ring_setup *ring_attr;
- struct hyper_dmabuf_ring_info_export *ring_info;
+ struct ioctl_hyper_dmabuf_tx_ch_setup *tx_ch_attr;
+ struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
int ret = 0;

if (!data) {
printk("user data is NULL\n");
return -1;
}
- ring_attr = (struct ioctl_hyper_dmabuf_exporter_ring_setup *)data;
-
- /* check if the ring ch already exists */
- ring_info = hyper_dmabuf_find_exporter_ring(ring_attr->remote_domain);
-
- if (ring_info) {
- printk("(exporter's) ring ch to domid = %d already exist\ngref = %d, port = %d\n",
- ring_info->rdomain, ring_info->gref_ring, ring_info->port);
- return 0;
- }
+ tx_ch_attr = (struct ioctl_hyper_dmabuf_tx_ch_setup *)data;

- ret = hyper_dmabuf_exporter_ringbuf_init(ring_attr->remote_domain);
+ ret = ops->init_tx_ch(tx_ch_attr->remote_domain);

return ret;
}

-static int hyper_dmabuf_importer_ring_setup(void *data)
+static int hyper_dmabuf_rx_ch_setup(void *data)
{
- struct ioctl_hyper_dmabuf_importer_ring_setup *setup_imp_ring_attr;
- struct hyper_dmabuf_ring_info_import *ring_info;
+ struct ioctl_hyper_dmabuf_rx_ch_setup *rx_ch_attr;
+ struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
int ret = 0;

if (!data) {
@@ -56,17 +46,9 @@ static int hyper_dmabuf_importer_ring_setup(void *data)
return -1;
}

- setup_imp_ring_attr = (struct ioctl_hyper_dmabuf_importer_ring_setup *)data;
-
- /* check if the ring ch already exist */
- ring_info = hyper_dmabuf_find_importer_ring(setup_imp_ring_attr->source_domain);
+ rx_ch_attr = (struct ioctl_hyper_dmabuf_rx_ch_setup *)data;

- if (ring_info) {
- printk("(importer's) ring ch to domid = %d already exist\n", ring_info->sdomain);
- return 0;
- }
-
- ret = hyper_dmabuf_importer_ringbuf_init(setup_imp_ring_attr->source_domain);
+ ret = ops->init_rx_ch(rx_ch_attr->source_domain);

return ret;
}
@@ -74,13 +56,14 @@ static int hyper_dmabuf_importer_ring_setup(void *data)
static int hyper_dmabuf_export_remote(void *data)
{
struct ioctl_hyper_dmabuf_export_remote *export_remote_attr;
+ struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
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 hyper_dmabuf_ring_rq *req;
- int operands[9];
+ struct hyper_dmabuf_req *req;
+ int operands[MAX_NUMBER_OF_OPERANDS];
int ret = 0;

if (!data) {
@@ -125,6 +108,7 @@ static int hyper_dmabuf_export_remote(void *data)
sgt_info = kmalloc(sizeof(*sgt_info), GFP_KERNEL);

sgt_info->hyper_dmabuf_id = hyper_dmabuf_get_id();
+
/* 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;
@@ -163,15 +147,14 @@ static int hyper_dmabuf_export_remote(void *data)

export_remote_attr->hyper_dmabuf_id = sgt_info->hyper_dmabuf_id;

- /* now create table of grefs for shared pages and */
-
/* now create request for importer via ring */
operands[0] = page_info->hyper_dmabuf_id;
operands[1] = page_info->nents;
operands[2] = page_info->frst_ofst;
operands[3] = page_info->last_len;
- operands[4] = hyper_dmabuf_create_gref_table(page_info->pages, export_remote_attr->remote_domain,
- page_info->nents, &sgt_info->shared_pages_info);
+ operands[4] = ops->share_pages (page_info->pages, export_remote_attr->remote_domain,
+ page_info->nents, &sgt_info->refs_info);
+
/* driver/application specific private info, max 32 bytes */
operands[5] = export_remote_attr->private[0];
operands[6] = export_remote_attr->private[1];
@@ -182,7 +165,8 @@ static int hyper_dmabuf_export_remote(void *data)

/* composing a message to the importer */
hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]);
- if(hyper_dmabuf_send_request(export_remote_attr->remote_domain, req, false))
+
+ if(ops->send_req(export_remote_attr->remote_domain, req, false))
goto fail_send_request;

/* free msg */
@@ -215,8 +199,10 @@ static int hyper_dmabuf_export_remote(void *data)
static int hyper_dmabuf_export_fd_ioctl(void *data)
{
struct ioctl_hyper_dmabuf_export_fd *export_fd_attr;
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
- struct hyper_dmabuf_ring_rq *req;
+ struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
+ struct hyper_dmabuf_imported_sgt_info *sgt_info;
+ struct hyper_dmabuf_req *req;
+ struct page **data_pages;
int operand;
int ret = 0;

@@ -228,43 +214,48 @@ static int hyper_dmabuf_export_fd_ioctl(void *data)
export_fd_attr = (struct ioctl_hyper_dmabuf_export_fd *)data;

/* look for dmabuf for the id */
- imported_sgt_info = hyper_dmabuf_find_imported(export_fd_attr->hyper_dmabuf_id);
- if (imported_sgt_info == NULL) /* can't find sgt from the table */
+ sgt_info = hyper_dmabuf_find_imported(export_fd_attr->hyper_dmabuf_id);
+ if (sgt_info == NULL) /* can't find sgt from the table */
return -1;

printk("%s Found buffer gref %d off %d last len %d nents %d domain %d\n", __func__,
- imported_sgt_info->gref, imported_sgt_info->frst_ofst,
- imported_sgt_info->last_len, imported_sgt_info->nents,
- HYPER_DMABUF_DOM_ID(imported_sgt_info->hyper_dmabuf_id));
-
- if (!imported_sgt_info->sgt) {
- imported_sgt_info->sgt = hyper_dmabuf_map_pages(imported_sgt_info->gref,
- imported_sgt_info->frst_ofst,
- imported_sgt_info->last_len,
- imported_sgt_info->nents,
- HYPER_DMABUF_DOM_ID(imported_sgt_info->hyper_dmabuf_id),
- &imported_sgt_info->shared_pages_info);
-
- /* send notifiticatio for first export_fd to exporter */
- operand = imported_sgt_info->hyper_dmabuf_id;
- req = kcalloc(1, sizeof(*req), GFP_KERNEL);
- hyper_dmabuf_create_request(req, HYPER_DMABUF_FIRST_EXPORT, &operand);
-
- ret = hyper_dmabuf_send_request(HYPER_DMABUF_DOM_ID(operand), req, false);
-
- if (!imported_sgt_info->sgt || ret) {
- kfree(req);
- printk("Failed to create sgt or notify exporter\n");
- return -EINVAL;
- }
+ sgt_info->ref_handle, sgt_info->frst_ofst,
+ sgt_info->last_len, sgt_info->nents,
+ HYPER_DMABUF_DOM_ID(sgt_info->hyper_dmabuf_id));
+
+ if (!sgt_info->sgt) {
+ data_pages = ops->map_shared_pages(sgt_info->ref_handle,
+ HYPER_DMABUF_DOM_ID(sgt_info->hyper_dmabuf_id),
+ sgt_info->nents,
+ &sgt_info->refs_info);
+
+ sgt_info->sgt = hyper_dmabuf_create_sgt(data_pages, sgt_info->frst_ofst,
+ sgt_info->last_len, sgt_info->nents);
+
+ }
+
+ /* send notification for export_fd to exporter */
+ operand = sgt_info->hyper_dmabuf_id;
+
+ req = kcalloc(1, sizeof(*req), GFP_KERNEL);
+ hyper_dmabuf_create_request(req, HYPER_DMABUF_FIRST_EXPORT, &operand);
+
+ ret = ops->send_req(HYPER_DMABUF_DOM_ID(operand), req, false);
+
+ if (!sgt_info->sgt || ret) {
kfree(req);
+ printk("Failed to create sgt or notify exporter\n");
+ return -EINVAL;
}
+ kfree(req);

- export_fd_attr->fd = hyper_dmabuf_export_fd(imported_sgt_info, export_fd_attr->flags);
+ export_fd_attr->fd = hyper_dmabuf_export_fd(sgt_info, export_fd_attr->flags);

if (export_fd_attr->fd < 0) {
/* fail to get fd */
ret = export_fd_attr->fd;
+ } else {
+ sgt_info->num_importers++;
}

return ret;
@@ -276,8 +267,9 @@ static int hyper_dmabuf_export_fd_ioctl(void *data)
static int hyper_dmabuf_unexport(void *data)
{
struct ioctl_hyper_dmabuf_unexport *unexport_attr;
+ struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops;
struct hyper_dmabuf_sgt_info *sgt_info;
- struct hyper_dmabuf_ring_rq *req;
+ struct hyper_dmabuf_req *req;
int ret;

if (!data) {
@@ -301,7 +293,7 @@ static int hyper_dmabuf_unexport(void *data)
hyper_dmabuf_create_request(req, HYPER_DMABUF_NOTIFY_UNEXPORT, &unexport_attr->hyper_dmabuf_id);

/* Now send unexport request to remote domain, marking that buffer should not be used anymore */
- ret = hyper_dmabuf_send_request(sgt_info->hyper_dmabuf_rdomain, req, true);
+ ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, true);
if (ret < 0) {
kfree(req);
return -EFAULT;
@@ -405,8 +397,8 @@ static int hyper_dmabuf_query(void *data)
}

static const struct hyper_dmabuf_ioctl_desc hyper_dmabuf_ioctls[] = {
- HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORTER_RING_SETUP, hyper_dmabuf_exporter_ring_setup, 0),
- HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_IMPORTER_RING_SETUP, hyper_dmabuf_importer_ring_setup, 0),
+ HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_TX_CH_SETUP, hyper_dmabuf_tx_ch_setup, 0),
+ HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_RX_CH_SETUP, hyper_dmabuf_rx_ch_setup, 0),
HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORT_REMOTE, hyper_dmabuf_export_remote, 0),
HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_EXPORT_FD, hyper_dmabuf_export_fd_ioctl, 0),
HYPER_DMABUF_IOCTL_DEF(IOCTL_HYPER_DMABUF_UNEXPORT, hyper_dmabuf_unexport, 0),
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
new file mode 100644
index 0000000..de216d3
--- /dev/null
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.h
@@ -0,0 +1,87 @@
+#ifndef __LINUX_PUBLIC_HYPER_DMABUF_IOCTL_H__
+#define __LINUX_PUBLIC_HYPER_DMABUF_IOCTL_H__
+
+typedef int (*hyper_dmabuf_ioctl_t)(void *data);
+
+struct hyper_dmabuf_ioctl_desc {
+ unsigned int cmd;
+ int flags;
+ hyper_dmabuf_ioctl_t func;
+ const char *name;
+};
+
+#define HYPER_DMABUF_IOCTL_DEF(ioctl, _func, _flags) \
+ [_IOC_NR(ioctl)] = { \
+ .cmd = ioctl, \
+ .func = _func, \
+ .flags = _flags, \
+ .name = #ioctl \
+ }
+
+#define IOCTL_HYPER_DMABUF_TX_CH_SETUP \
+_IOC(_IOC_NONE, 'G', 0, sizeof(struct ioctl_hyper_dmabuf_tx_ch_setup))
+struct ioctl_hyper_dmabuf_tx_ch_setup {
+ /* IN parameters */
+ /* Remote domain id */
+ int remote_domain;
+};
+
+#define IOCTL_HYPER_DMABUF_RX_CH_SETUP \
+_IOC(_IOC_NONE, 'G', 1, sizeof(struct ioctl_hyper_dmabuf_rx_ch_setup))
+struct ioctl_hyper_dmabuf_rx_ch_setup {
+ /* IN parameters */
+ /* Source domain id */
+ int source_domain;
+};
+
+#define IOCTL_HYPER_DMABUF_EXPORT_REMOTE \
+_IOC(_IOC_NONE, 'G', 2, sizeof(struct ioctl_hyper_dmabuf_export_remote))
+struct ioctl_hyper_dmabuf_export_remote {
+ /* IN parameters */
+ /* DMA buf fd to be exported */
+ int dmabuf_fd;
+ /* Domain id to which buffer should be exported */
+ int remote_domain;
+ /* exported dma buf id */
+ int hyper_dmabuf_id;
+ int private[4];
+};
+
+#define IOCTL_HYPER_DMABUF_EXPORT_FD \
+_IOC(_IOC_NONE, 'G', 3, sizeof(struct ioctl_hyper_dmabuf_export_fd))
+struct ioctl_hyper_dmabuf_export_fd {
+ /* IN parameters */
+ /* hyper dmabuf id to be imported */
+ int hyper_dmabuf_id;
+ /* flags */
+ int flags;
+ /* OUT parameters */
+ /* exported dma buf fd */
+ int fd;
+};
+
+#define IOCTL_HYPER_DMABUF_UNEXPORT \
+_IOC(_IOC_NONE, 'G', 4, sizeof(struct ioctl_hyper_dmabuf_unexport))
+struct ioctl_hyper_dmabuf_unexport {
+ /* IN parameters */
+ /* hyper dmabuf id to be unexported */
+ int hyper_dmabuf_id;
+ /* OUT parameters */
+ /* Status of request */
+ int status;
+};
+
+#define IOCTL_HYPER_DMABUF_QUERY \
+_IOC(_IOC_NONE, 'G', 5, sizeof(struct ioctl_hyper_dmabuf_query))
+struct ioctl_hyper_dmabuf_query {
+ /* in parameters */
+ /* hyper dmabuf id to be queried */
+ int hyper_dmabuf_id;
+ /* item to be queried */
+ int item;
+ /* OUT parameters */
+ /* Value of queried item */
+ int info;
+};
+
+#endif //__LINUX_PUBLIC_HYPER_DMABUF_DRV_H__
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
index a2d687f..4647115 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.c
@@ -5,11 +5,10 @@
#include <linux/dma-buf.h>
#include <xen/grant_table.h>
#include <linux/workqueue.h>
+#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_imp.h"
#include "hyper_dmabuf_remote_sync.h"
-#include "xen/hyper_dmabuf_xen_comm.h"
-#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_list.h"

#define FORCED_UNEXPORTING 0
@@ -18,18 +17,17 @@ extern struct hyper_dmabuf_private hyper_dmabuf_private;

struct cmd_process {
struct work_struct work;
- struct hyper_dmabuf_ring_rq *rq;
+ struct hyper_dmabuf_req *rq;
int domid;
};

-void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request,
- enum hyper_dmabuf_command command, int *operands)
+void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
+ enum hyper_dmabuf_command command, int *operands)
{
int i;

- request->request_id = hyper_dmabuf_next_req_id_export();
- request->status = HYPER_DMABUF_REQ_NOT_RESPONDED;
- request->command = command;
+ req->status = HYPER_DMABUF_REQ_NOT_RESPONDED;
+ req->command = command;

switch(command) {
/* as exporter, commands to importer */
@@ -44,7 +42,7 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request,
* operands5~8 : Driver-specific private data (e.g. graphic buffer's meta info)
*/
for (i=0; i < 8; i++)
- request->operands[i] = operands[i];
+ req->operands[i] = operands[i];
break;

case HYPER_DMABUF_NOTIFY_UNEXPORT:
@@ -52,7 +50,7 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request,
/* command : DMABUF_DESTROY,
* operands0 : hyper_dmabuf_id
*/
- request->operands[0] = operands[0];
+ req->operands[0] = operands[0];
break;

case HYPER_DMABUF_FIRST_EXPORT:
@@ -60,7 +58,7 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request,
/* command : HYPER_DMABUF_FIRST_EXPORT,
* operands0 : hyper_dmabuf_id
*/
- request->operands[0] = operands[0];
+ req->operands[0] = operands[0];
break;

case HYPER_DMABUF_OPS_TO_REMOTE:
@@ -77,7 +75,7 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request,
* operands1 : map(=1)/unmap(=2)/attach(=3)/detach(=4)
*/
for (i=0; i<2; i++)
- request->operands[i] = operands[i];
+ req->operands[i] = operands[i];
break;

default:
@@ -88,10 +86,10 @@ void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request,

void cmd_process_work(struct work_struct *work)
{
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
struct hyper_dmabuf_sgt_info *sgt_info;
+ struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
struct cmd_process *proc = container_of(work, struct cmd_process, work);
- struct hyper_dmabuf_ring_rq *req;
+ struct hyper_dmabuf_req *req;
int domid;
int i;

@@ -114,7 +112,7 @@ void cmd_process_work(struct work_struct *work)
imported_sgt_info->frst_ofst = req->operands[2];
imported_sgt_info->last_len = req->operands[3];
imported_sgt_info->nents = req->operands[1];
- imported_sgt_info->gref = req->operands[4];
+ imported_sgt_info->ref_handle = req->operands[4];

printk("DMABUF was exported\n");
printk("\thyper_dmabuf_id %d\n", req->operands[0]);
@@ -139,10 +137,7 @@ void cmd_process_work(struct work_struct *work)
break;
}

- if (sgt_info->importer_exported)
- printk("warning: exported flag is not supposed to be 1 already\n");
-
- sgt_info->importer_exported = 1;
+ sgt_info->importer_exported++;
break;

case HYPER_DMABUF_OPS_TO_REMOTE:
@@ -160,11 +155,11 @@ void cmd_process_work(struct work_struct *work)
kfree(proc);
}

-int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req)
+int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req)
{
struct cmd_process *proc;
- struct hyper_dmabuf_ring_rq *temp_req;
- struct hyper_dmabuf_imported_sgt_info *imported_sgt_info;
+ struct hyper_dmabuf_req *temp_req;
+ struct hyper_dmabuf_imported_sgt_info *sgt_info;
int ret;

if (!req) {
@@ -189,22 +184,21 @@ int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req)
* operands0 : hyper_dmabuf_id
*/

- imported_sgt_info =
- hyper_dmabuf_find_imported(req->operands[0]);
+ sgt_info = hyper_dmabuf_find_imported(req->operands[0]);

- if (imported_sgt_info) {
+ if (sgt_info) {
/* if anything is still using dma_buf */
- if (imported_sgt_info->dma_buf &&
- dmabuf_refcount(imported_sgt_info->dma_buf) > 0) {
+ if (sgt_info->dma_buf &&
+ dmabuf_refcount(sgt_info->dma_buf) > 0) {
/*
* Buffer is still in use, just mark that it should
* not be allowed to export its fd anymore.
*/
- imported_sgt_info->valid = 0;
+ sgt_info->valid = 0;
} else {
/* No one is using buffer, remove it from imported list */
hyper_dmabuf_remove_imported(req->operands[0]);
- kfree(imported_sgt_info);
+ kfree(sgt_info);
}
} else {
req->status = HYPER_DMABUF_REQ_ERROR;
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
index 1e9d827..ac4caeb 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_msg.h
@@ -1,6 +1,22 @@
#ifndef __HYPER_DMABUF_MSG_H__
#define __HYPER_DMABUF_MSG_H__

+#define MAX_NUMBER_OF_OPERANDS 9
+
+struct hyper_dmabuf_req {
+ unsigned int request_id;
+ unsigned int status;
+ unsigned int command;
+ unsigned int operands[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];
+};
+
enum hyper_dmabuf_command {
HYPER_DMABUF_EXPORT = 0x10,
HYPER_DMABUF_FIRST_EXPORT,
@@ -35,10 +51,11 @@ enum hyper_dmabuf_req_feedback {
};

/* create a request packet with given command and operands */
-void hyper_dmabuf_create_request(struct hyper_dmabuf_ring_rq *request,
- enum hyper_dmabuf_command command, int *operands);
+void hyper_dmabuf_create_request(struct hyper_dmabuf_req *req,
+ enum hyper_dmabuf_command command,
+ int *operands);

/* parse incoming request packet (or response) and take appropriate actions for those */
-int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_ring_rq *req);
+int hyper_dmabuf_msg_parse(int domid, struct hyper_dmabuf_req *req);

#endif // __HYPER_DMABUF_MSG_H__
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
index c5950e0..0f4735c 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_remote_sync.c
@@ -5,9 +5,9 @@
#include <linux/dma-buf.h>
#include "hyper_dmabuf_struct.h"
#include "hyper_dmabuf_list.h"
+#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_drv.h"
#include "hyper_dmabuf_id.h"
-#include "xen/hyper_dmabuf_xen_comm.h"
#include "hyper_dmabuf_msg.h"
#include "hyper_dmabuf_imp.h"

@@ -133,6 +133,8 @@ int hyper_dmabuf_remote_sync(int id, int ops)

case HYPER_DMABUF_OPS_RELEASE:
/* place holder */
+ sgt_info->importer_exported--;
+
break;

case HYPER_DMABUF_OPS_BEGIN_CPU_ACCESS:
diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
index b52f958..f053dd10 100644
--- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
+++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h
@@ -1,14 +1,6 @@
#ifndef __HYPER_DMABUF_STRUCT_H__
#define __HYPER_DMABUF_STRUCT_H__

-#include <xen/interface/grant_table.h>
-
-/* each grant_ref_t is 4 bytes, so total 4096 grant_ref_t can be
- * in this block meaning we can share 4KB*4096 = 16MB of buffer
- * (needs to be increased for large buffer use-cases such as 4K
- * frame buffer) */
-#define MAX_ALLOWED_NUM_PAGES_FOR_GREF_NUM_ARRAYS 4
-
/* stack of mapped sgts */
struct sgt_list {
struct sg_table *sgt;
@@ -33,15 +25,6 @@ struct vmap_vaddr_list {
struct list_head list;
};

-struct hyper_dmabuf_shared_pages_info {
- grant_ref_t *data_refs; /* table with shared buffer pages refid */
- grant_ref_t *addr_pages; /* pages of 2nd level addressing */
- grant_ref_t *top_level_page; /* page of top level addressing, it contains refids of 2nd level pages */
- grant_ref_t top_level_ref; /* top level refid */
- struct gnttab_unmap_grant_ref* unmap_ops; /* unmap ops for mapped pages */
- struct page **data_pages; /* data pages to be unmapped */
-};
-
/* Exporter builds pages_info before sharing pages */
struct hyper_dmabuf_pages_info {
int hyper_dmabuf_id; /* unique id to reference dmabuf in source domain */
@@ -69,8 +52,8 @@ struct hyper_dmabuf_sgt_info {
struct kmap_vaddr_list *va_kmapped;
struct vmap_vaddr_list *va_vmapped;
bool valid;
- bool importer_exported; /* exported locally on importer's side */
- struct hyper_dmabuf_shared_pages_info shared_pages_info;
+ int importer_exported; /* exported locally on importer's side */
+ void *refs_info; /* hypervisor-specific info for the references */
int private[4]; /* device specific info (e.g. image's meta info?) */
};

@@ -79,14 +62,15 @@ struct hyper_dmabuf_sgt_info {
* its own memory map once userspace asks for reference for the buffer */
struct hyper_dmabuf_imported_sgt_info {
int hyper_dmabuf_id; /* unique id to reference dmabuf (HYPER_DMABUF_ID_IMPORTER(source domain id, exporter's hyper_dmabuf_id */
+ int ref_handle; /* reference number of top level addressing page of shared pages */
int frst_ofst; /* start offset in shared page #1 */
int last_len; /* length of data in the last shared page */
int nents; /* number of pages to be shared */
- grant_ref_t gref; /* reference number of top level addressing page of shared pages */
struct dma_buf *dma_buf;
struct sg_table *sgt; /* sgt pointer after importing buffer */
- struct hyper_dmabuf_shared_pages_info shared_pages_info;
+ void *refs_info;
bool valid;
+ int num_importers;
int private[4]; /* 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 f9e0df3..bd37ec2 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.c
@@ -10,16 +10,15 @@
#include <asm/xen/page.h>
#include "hyper_dmabuf_xen_comm.h"
#include "hyper_dmabuf_xen_comm_list.h"
-#include "../hyper_dmabuf_imp.h"
-#include "../hyper_dmabuf_list.h"
-#include "../hyper_dmabuf_msg.h"

static int export_req_id = 0;

-struct hyper_dmabuf_ring_rq req_pending = {0};
+struct hyper_dmabuf_req req_pending = {0};

-/* Creates entry in xen store that will keep details of all exporter rings created by this domain */
-int32_t hyper_dmabuf_setup_data_dir()
+/* Creates entry in xen store that will keep details of all
+ * exporter rings created by this domain
+ */
+static int xen_comm_setup_data_dir(void)
{
char buf[255];

@@ -27,13 +26,13 @@ int32_t hyper_dmabuf_setup_data_dir()
return xenbus_mkdir(XBT_NIL, buf, "");
}

-
/* Removes entry from xenstore with exporter ring details.
- * Other domains that has connected to any of exporter rings created by this domain,
- * will be notified about removal of this entry and will treat that as signal to
- * cleanup importer rings created for this domain
+ * Other domains that has connected to any of exporter rings
+ * created by this domain, will be notified about removal of
+ * this entry and will treat that as signal to cleanup importer
+ * rings created for this domain
*/
-int32_t hyper_dmabuf_destroy_data_dir()
+static int xen_comm_destroy_data_dir(void)
{
char buf[255];

@@ -41,18 +40,19 @@ int32_t hyper_dmabuf_destroy_data_dir()
return xenbus_rm(XBT_NIL, buf, "");
}

-/*
- * Adds xenstore entries with details of exporter ring created for given remote domain.
- * It requires special daemon running in dom0 to make sure that given remote domain will
- * have right permissions to access that data.
+/* Adds xenstore entries with details of exporter ring created
+ * for given remote domain. It requires special daemon running
+ * in dom0 to make sure that given remote domain will have right
+ * permissions to access that data.
*/
-static int32_t hyper_dmabuf_expose_ring_details(uint32_t domid, uint32_t rdomid, uint32_t grefid, uint32_t port)
+static int xen_comm_expose_ring_details(int domid, int rdomid,
+ int gref, int port)
{
char buf[255];
int ret;

sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d", domid, rdomid);
- ret = xenbus_printf(XBT_NIL, buf, "grefid", "%d", grefid);
+ ret = xenbus_printf(XBT_NIL, buf, "grefid", "%d", gref);

if (ret) {
printk("Failed to write xenbus entry %s: %d\n", buf, ret);
@@ -72,7 +72,7 @@ static int32_t hyper_dmabuf_expose_ring_details(uint32_t domid, uint32_t rdomid,
/*
* Queries details of ring exposed by remote domain.
*/
-static int32_t hyper_dmabuf_get_ring_details(uint32_t domid, uint32_t rdomid, uint32_t *grefid, uint32_t *port)
+static int xen_comm_get_ring_details(int domid, int rdomid, int *grefid, int *port)
{
char buf[255];
int ret;
@@ -95,10 +95,10 @@ static int32_t hyper_dmabuf_get_ring_details(uint32_t domid, uint32_t rdomid, ui
return (ret <= 0 ? 1 : 0);
}

-int32_t hyper_dmabuf_get_domid(void)
+int hyper_dmabuf_get_domid(void)
{
struct xenbus_transaction xbt;
- int32_t domid;
+ int domid;

xenbus_transaction_start(&xbt);

@@ -110,29 +110,35 @@ int32_t hyper_dmabuf_get_domid(void)
return domid;
}

-int hyper_dmabuf_next_req_id_export(void)
+static int xen_comm_next_req_id(void)
{
export_req_id++;
return export_req_id;
}

/* For now cache latast rings as global variables TODO: keep them in list*/
-static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *info);
-static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info);
-
-/*
- * Callback function that will be called on any change of xenbus path being watched.
- * Used for detecting creation/destruction of remote domain exporter ring.
- * When remote domain's exporter ring will be detected, importer ring on this domain will be created.
- * When remote domain's exporter ring destruction will be detected it will celanup this domain importer ring.
- * Destruction can be caused by unloading module by remote domain or it's crash/force shutdown.
+static irqreturn_t front_ring_isr(int irq, void *info);
+static irqreturn_t back_ring_isr(int irq, void *info);
+
+/* Callback function that will be called on any change of xenbus path
+ * being watched. Used for detecting creation/destruction of remote
+ * domain exporter ring.
+ *
+ * When remote domain's exporter ring will be detected, importer ring
+ * on this domain will be created.
+ *
+ * When remote domain's exporter ring destruction will be detected it
+ * will celanup this domain importer ring.
+ *
+ * Destruction can be caused by unloading module by remote domain or
+ * it's crash/force shutdown.
*/
-static void remote_domain_exporter_watch_cb(struct xenbus_watch *watch,
- const char *path, const char *token)
+static void remote_dom_exporter_watch_cb(struct xenbus_watch *watch,
+ const char *path, const char *token)
{
int rdom,ret;
uint32_t grefid, port;
- struct hyper_dmabuf_ring_info_import *ring_info;
+ struct xen_comm_rx_ring_info *ring_info;

/* Check which domain has changed its exporter rings */
ret = sscanf(watch->node, "/local/domain/%d/", &rdom);
@@ -141,39 +147,49 @@ static void remote_domain_exporter_watch_cb(struct xenbus_watch *watch,
}

/* Check if we have importer ring for given remote domain alrady created */
- ring_info = hyper_dmabuf_find_importer_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.
- * 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.
+ 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.
+ *
+ * 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.
*/
- ret = hyper_dmabuf_get_ring_details(hyper_dmabuf_get_domid(), rdom, &grefid, &port);
+ ret = xen_comm_get_ring_details(hyper_dmabuf_get_domid(), rdom,
+ &grefid, &port);

if (ring_info && ret != 0) {
printk("Remote exporter closed, cleaninup importer\n");
- hyper_dmabuf_importer_ringbuf_cleanup(rdom);
+ hyper_dmabuf_xen_cleanup_rx_rbuf(rdom);
} else if (!ring_info && ret == 0) {
printk("Registering importer\n");
- hyper_dmabuf_importer_ringbuf_init(rdom);
+ hyper_dmabuf_xen_init_rx_rbuf(rdom);
}
}

/* exporter needs to generated info for page sharing */
-int hyper_dmabuf_exporter_ringbuf_init(int rdomain)
+int hyper_dmabuf_xen_init_tx_rbuf(int domid)
{
- struct hyper_dmabuf_ring_info_export *ring_info;
- struct hyper_dmabuf_sring *sring;
+ struct xen_comm_tx_ring_info *ring_info;
+ struct xen_comm_sring *sring;
struct evtchn_alloc_unbound alloc_unbound;
struct evtchn_close close;

void *shared_ring;
int ret;

- ring_info = (struct hyper_dmabuf_ring_info_export*)
- kmalloc(sizeof(*ring_info), GFP_KERNEL);
+ /* check if there's any existing tx channel in the table */
+ ring_info = xen_comm_find_tx_ring(domid);
+
+ if (ring_info) {
+ printk("tx ring ch to domid = %d already exist\ngref = %d, port = %d\n",
+ ring_info->rdomain, ring_info->gref_ring, ring_info->port);
+ return 0;
+ }
+
+ ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);

/* from exporter to importer */
shared_ring = (void *)__get_free_pages(GFP_KERNEL, 1);
@@ -181,20 +197,22 @@ int hyper_dmabuf_exporter_ringbuf_init(int rdomain)
return -EINVAL;
}

- sring = (struct hyper_dmabuf_sring *) shared_ring;
+ sring = (struct xen_comm_sring *) shared_ring;

SHARED_RING_INIT(sring);

FRONT_RING_INIT(&(ring_info->ring_front), sring, PAGE_SIZE);

- ring_info->gref_ring = gnttab_grant_foreign_access(rdomain,
- virt_to_mfn(shared_ring), 0);
+ ring_info->gref_ring = gnttab_grant_foreign_access(domid,
+ virt_to_mfn(shared_ring),
+ 0);
if (ring_info->gref_ring < 0) {
- return -EINVAL; /* fail to get gref */
+ /* fail to get gref */
+ return -EINVAL;
}

alloc_unbound.dom = DOMID_SELF;
- alloc_unbound.remote_dom = rdomain;
+ alloc_unbound.remote_dom = domid;
ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
&alloc_unbound);
if (ret != 0) {
@@ -204,7 +222,7 @@ int hyper_dmabuf_exporter_ringbuf_init(int rdomain)

/* setting up interrupt */
ret = bind_evtchn_to_irqhandler(alloc_unbound.port,
- hyper_dmabuf_front_ring_isr, 0,
+ front_ring_isr, 0,
NULL, (void*) ring_info);

if (ret < 0) {
@@ -216,7 +234,7 @@ int hyper_dmabuf_exporter_ringbuf_init(int rdomain)
return -EINVAL;
}

- ring_info->rdomain = rdomain;
+ ring_info->rdomain = domid;
ring_info->irq = ret;
ring_info->port = alloc_unbound.port;

@@ -226,109 +244,128 @@ int hyper_dmabuf_exporter_ringbuf_init(int rdomain)
ring_info->port,
ring_info->irq);

- ret = hyper_dmabuf_register_exporter_ring(ring_info);
+ ret = xen_comm_add_tx_ring(ring_info);

- ret = hyper_dmabuf_expose_ring_details(hyper_dmabuf_get_domid(), rdomain,
- ring_info->gref_ring, ring_info->port);
+ ret = xen_comm_expose_ring_details(hyper_dmabuf_get_domid(), domid,
+ ring_info->gref_ring, ring_info->port);

/*
* Register watch for remote domain exporter ring.
- * When remote domain will setup its exporter ring, we will automatically connect our importer ring to it.
+ * When remote domain will setup its exporter ring,
+ * we will automatically connect our importer ring to it.
*/
- ring_info->watch.callback = remote_domain_exporter_watch_cb;
+ ring_info->watch.callback = remote_dom_exporter_watch_cb;
ring_info->watch.node = (const char*) kmalloc(sizeof(char) * 255, GFP_KERNEL);
- sprintf((char*)ring_info->watch.node, "/local/domain/%d/data/hyper_dmabuf/%d/port", rdomain, hyper_dmabuf_get_domid());
+ sprintf((char*)ring_info->watch.node,
+ "/local/domain/%d/data/hyper_dmabuf/%d/port",
+ domid, hyper_dmabuf_get_domid());
+
register_xenbus_watch(&ring_info->watch);

return ret;
}

/* cleans up exporter ring created for given remote domain */
-void hyper_dmabuf_exporter_ringbuf_cleanup(int rdomain)
+void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid)
{
- struct hyper_dmabuf_ring_info_export *ring_info;
+ struct xen_comm_tx_ring_info *ring_info;

/* check if we at all have exporter ring for given rdomain */
- ring_info = hyper_dmabuf_find_exporter_ring(rdomain);
+ ring_info = xen_comm_find_tx_ring(domid);

if (!ring_info) {
return;
}

- hyper_dmabuf_remove_exporter_ring(rdomain);
+ xen_comm_remove_tx_ring(domid);

unregister_xenbus_watch(&ring_info->watch);
kfree(ring_info->watch.node);

- /* No need to close communication channel, will be done by this function */
- unbind_from_irqhandler(ring_info->irq, (void*) ring_info);
+ /* No need to close communication channel, will be done by
+ * this function
+ */
+ unbind_from_irqhandler(ring_info->irq, (void*) ring_info);

- /* No need to free sring page, will be freed by this function when other side will end its access */
+ /* No need to free sring page, will be freed by this function
+ * when other side will end its access
+ */
gnttab_end_foreign_access(ring_info->gref_ring, 0,
(unsigned long) ring_info->ring_front.sring);

kfree(ring_info);
}

-/* importer needs to know about shared page and port numbers for ring buffer and event channel */
-int hyper_dmabuf_importer_ringbuf_init(int sdomain)
+/* importer needs to know about shared page and port numbers for
+ * ring buffer and event channel
+ */
+int hyper_dmabuf_xen_init_rx_rbuf(int domid)
{
- struct hyper_dmabuf_ring_info_import *ring_info;
- struct hyper_dmabuf_sring *sring;
+ struct xen_comm_rx_ring_info *ring_info;
+ struct xen_comm_sring *sring;

struct page *shared_ring;

- struct gnttab_map_grant_ref *ops;
+ struct gnttab_map_grant_ref *map_ops;
+
int ret;
- int importer_gref, importer_port;
+ int rx_gref, rx_port;

- ret = hyper_dmabuf_get_ring_details(hyper_dmabuf_get_domid(), sdomain,
- &importer_gref, &importer_port);
+ /* check if there's existing rx ring channel */
+ ring_info = xen_comm_find_rx_ring(domid);
+
+ if (ring_info) {
+ printk("rx ring ch from domid = %d already exist\n", ring_info->sdomain);
+ return 0;
+ }
+
+ ret = xen_comm_get_ring_details(hyper_dmabuf_get_domid(), domid,
+ &rx_gref, &rx_port);

if (ret) {
- printk("Domain %d has not created exporter ring for current domain\n", sdomain);
+ printk("Domain %d has not created exporter ring for current domain\n", domid);
return ret;
}

- ring_info = (struct hyper_dmabuf_ring_info_import *)
- kmalloc(sizeof(*ring_info), GFP_KERNEL);
+ ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);

- ring_info->sdomain = sdomain;
- ring_info->evtchn = importer_port;
+ ring_info->sdomain = domid;
+ ring_info->evtchn = rx_port;

- ops = (struct gnttab_map_grant_ref*)kmalloc(sizeof(*ops), GFP_KERNEL);
+ map_ops = kmalloc(sizeof(*map_ops), GFP_KERNEL);

if (gnttab_alloc_pages(1, &shared_ring)) {
return -EINVAL;
}

- gnttab_set_map_op(&ops[0], (unsigned long)pfn_to_kaddr(page_to_pfn(shared_ring)),
- GNTMAP_host_map, importer_gref, sdomain);
+ 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)),
- GNTMAP_host_map, -1);
+ GNTMAP_host_map, -1);

- ret = gnttab_map_refs(ops, NULL, &shared_ring, 1);
+ ret = gnttab_map_refs(map_ops, NULL, &shared_ring, 1);
if (ret < 0) {
printk("Cannot map ring\n");
return -EINVAL;
}

- if (ops[0].status) {
+ if (map_ops[0].status) {
printk("Ring mapping failed\n");
return -EINVAL;
} else {
- ring_info->unmap_op.handle = ops[0].handle;
+ ring_info->unmap_op.handle = map_ops[0].handle;
}

- kfree(ops);
+ kfree(map_ops);

- sring = (struct hyper_dmabuf_sring*) pfn_to_kaddr(page_to_pfn(shared_ring));
+ sring = (struct xen_comm_sring *)pfn_to_kaddr(page_to_pfn(shared_ring));

BACK_RING_INIT(&ring_info->ring_back, sring, PAGE_SIZE);

- ret = bind_interdomain_evtchn_to_irqhandler(sdomain, importer_port,
- hyper_dmabuf_back_ring_isr, 0,
- NULL, (void*)ring_info);
+ ret = bind_interdomain_evtchn_to_irqhandler(domid, rx_port,
+ back_ring_isr, 0,
+ NULL, (void*)ring_info);
if (ret < 0) {
return -EINVAL;
}
@@ -336,35 +373,35 @@ int hyper_dmabuf_importer_ringbuf_init(int sdomain)
ring_info->irq = ret;

printk("%s: bound to eventchannel port: %d irq: %d\n", __func__,
- importer_port,
+ rx_port,
ring_info->irq);

- ret = hyper_dmabuf_register_importer_ring(ring_info);
+ ret = xen_comm_add_rx_ring(ring_info);

/* Setup communcation channel in opposite direction */
- if (!hyper_dmabuf_find_exporter_ring(sdomain)) {
- ret = hyper_dmabuf_exporter_ringbuf_init(sdomain);
+ if (!xen_comm_find_tx_ring(domid)) {
+ ret = hyper_dmabuf_xen_init_tx_rbuf(domid);
}

return ret;
}

/* clenas up importer ring create for given source domain */
-void hyper_dmabuf_importer_ringbuf_cleanup(int sdomain)
+void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid)
{
- struct hyper_dmabuf_ring_info_import *ring_info;
+ struct xen_comm_rx_ring_info *ring_info;
struct page *shared_ring;

/* check if we have importer ring created for given sdomain */
- ring_info = hyper_dmabuf_find_importer_ring(sdomain);
+ ring_info = xen_comm_find_rx_ring(domid);

if (!ring_info)
return;

- hyper_dmabuf_remove_importer_ring(sdomain);
+ xen_comm_remove_rx_ring(domid);

/* no need to close event channel, will be done by that function */
- unbind_from_irqhandler(ring_info->irq, (void*) ring_info);
+ unbind_from_irqhandler(ring_info->irq, (void*)ring_info);

/* unmapping shared ring page */
shared_ring = virt_to_page(ring_info->ring_back.sring);
@@ -374,23 +411,39 @@ void hyper_dmabuf_importer_ringbuf_cleanup(int sdomain)
kfree(ring_info);
}

-/* cleans up all exporter/importer rings */
-void hyper_dmabuf_cleanup_ringbufs(void)
+int hyper_dmabuf_xen_init_comm_env(void)
{
- hyper_dmabuf_foreach_exporter_ring(hyper_dmabuf_exporter_ringbuf_cleanup);
- hyper_dmabuf_foreach_importer_ring(hyper_dmabuf_importer_ringbuf_cleanup);
+ int ret;
+
+ xen_comm_ring_table_init();
+ ret = xen_comm_setup_data_dir();
+
+ return ret;
}

-int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req, int wait)
+/* cleans up all tx/rx rings */
+static void hyper_dmabuf_xen_cleanup_all_rbufs(void)
{
- struct hyper_dmabuf_front_ring *ring;
- struct hyper_dmabuf_ring_rq *new_req;
- struct hyper_dmabuf_ring_info_export *ring_info;
+ xen_comm_foreach_tx_ring(hyper_dmabuf_xen_cleanup_tx_rbuf);
+ xen_comm_foreach_rx_ring(hyper_dmabuf_xen_cleanup_rx_rbuf);
+}
+
+void hyper_dmabuf_xen_destroy_comm(void)
+{
+ hyper_dmabuf_xen_cleanup_all_rbufs();
+ xen_comm_destroy_data_dir();
+}
+
+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;
+ struct xen_comm_tx_ring_info *ring_info;
int notify;
int timeout = 1000;

/* find a ring info for the channel */
- ring_info = hyper_dmabuf_find_exporter_ring(domain);
+ ring_info = xen_comm_find_tx_ring(domid);
if (!ring_info) {
printk("Can't find ring info for the channel\n");
return -EINVAL;
@@ -407,6 +460,8 @@ int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req, int
return -EIO;
}

+ req->request_id = xen_comm_next_req_id();
+
/* update req_pending with current request */
memcpy(&req_pending, req, sizeof(req_pending));

@@ -438,19 +493,19 @@ int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req, int
}

/* ISR for handling request */
-static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info)
+static irqreturn_t back_ring_isr(int irq, void *info)
{
RING_IDX rc, rp;
- struct hyper_dmabuf_ring_rq req;
- struct hyper_dmabuf_ring_rp resp;
+ struct hyper_dmabuf_req req;
+ struct hyper_dmabuf_resp resp;

int notify, more_to_do;
int ret;

- struct hyper_dmabuf_ring_info_import *ring_info;
- struct hyper_dmabuf_back_ring *ring;
+ struct xen_comm_rx_ring_info *ring_info;
+ struct xen_comm_back_ring *ring;

- ring_info = (struct hyper_dmabuf_ring_info_import *)info;
+ ring_info = (struct xen_comm_rx_ring_info *)info;
ring = &ring_info->ring_back;

do {
@@ -490,17 +545,17 @@ static irqreturn_t hyper_dmabuf_back_ring_isr(int irq, void *info)
}

/* ISR for handling responses */
-static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *info)
+static irqreturn_t front_ring_isr(int irq, void *info)
{
/* front ring only care about response from back */
- struct hyper_dmabuf_ring_rp *resp;
+ struct hyper_dmabuf_resp *resp;
RING_IDX i, rp;
int more_to_do, ret;

- struct hyper_dmabuf_ring_info_export *ring_info;
- struct hyper_dmabuf_front_ring *ring;
+ struct xen_comm_tx_ring_info *ring_info;
+ struct xen_comm_front_ring *ring;

- ring_info = (struct hyper_dmabuf_ring_info_export *)info;
+ ring_info = (struct xen_comm_tx_ring_info *)info;
ring = &ring_info->ring_front;

do {
@@ -518,7 +573,7 @@ static irqreturn_t hyper_dmabuf_front_ring_isr(int irq, void *info)
if (resp->status == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
/* parsing response */
ret = hyper_dmabuf_msg_parse(ring_info->rdomain,
- (struct hyper_dmabuf_ring_rq *)resp);
+ (struct hyper_dmabuf_req *)resp);

if (ret < 0) {
printk("getting error while parsing response\n");
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h
index 4ab031a..ba41e9d 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm.h
@@ -3,27 +3,14 @@

#include "xen/interface/io/ring.h"
#include "xen/xenbus.h"
+#include "../hyper_dmabuf_msg.h"

#define MAX_NUMBER_OF_OPERANDS 9

-struct hyper_dmabuf_ring_rq {
- unsigned int request_id;
- unsigned int status;
- unsigned int command;
- unsigned int operands[MAX_NUMBER_OF_OPERANDS];
-};
-
-struct hyper_dmabuf_ring_rp {
- unsigned int response_id;
- unsigned int status;
- unsigned int command;
- unsigned int operands[MAX_NUMBER_OF_OPERANDS];
-};
+DEFINE_RING_TYPES(xen_comm, struct hyper_dmabuf_req, struct hyper_dmabuf_resp);

-DEFINE_RING_TYPES(hyper_dmabuf, struct hyper_dmabuf_ring_rq, struct hyper_dmabuf_ring_rp);
-
-struct hyper_dmabuf_ring_info_export {
- struct hyper_dmabuf_front_ring ring_front;
+struct xen_comm_tx_ring_info {
+ struct xen_comm_front_ring ring_front;
int rdomain;
int gref_ring;
int irq;
@@ -31,39 +18,35 @@ struct hyper_dmabuf_ring_info_export {
struct xenbus_watch watch;
};

-struct hyper_dmabuf_ring_info_import {
+struct xen_comm_rx_ring_info {
int sdomain;
int irq;
int evtchn;
- struct hyper_dmabuf_back_ring ring_back;
+ struct xen_comm_back_ring ring_back;
struct gnttab_unmap_grant_ref unmap_op;
};

-int32_t hyper_dmabuf_get_domid(void);
-int32_t hyper_dmabuf_setup_data_dir(void);
-int32_t hyper_dmabuf_destroy_data_dir(void);
+int hyper_dmabuf_get_domid(void);

-int hyper_dmabuf_next_req_id_export(void);
+int hyper_dmabuf_xen_init_comm_env(void);

/* exporter needs to generated info for page sharing */
-int hyper_dmabuf_exporter_ringbuf_init(int rdomain);
+int hyper_dmabuf_xen_init_tx_rbuf(int domid);

-/* importer needs to know about shared page and port numbers for ring buffer and event channel */
-int hyper_dmabuf_importer_ringbuf_init(int sdomain);
+/* importer needs to know about shared page and port numbers
+ * for ring buffer and event channel
+ */
+int hyper_dmabuf_xen_init_rx_rbuf(int domid);

/* cleans up exporter ring created for given domain */
-void hyper_dmabuf_exporter_ringbuf_cleanup(int rdomain);
+void hyper_dmabuf_xen_cleanup_tx_rbuf(int domid);

/* cleans up importer ring created for given domain */
-void hyper_dmabuf_importer_ringbuf_cleanup(int sdomain);
+void hyper_dmabuf_xen_cleanup_rx_rbuf(int domid);

-/* cleans up all exporter/importer rings */
-void hyper_dmabuf_cleanup_ringbufs(void);
+void hyper_dmabuf_xen_destroy_comm(void);

/* send request to the remote domain */
-int hyper_dmabuf_send_request(int domain, struct hyper_dmabuf_ring_rq *req, int wait);
-
-/* called by interrupt (WORKQUEUE) */
-int hyper_dmabuf_send_response(struct hyper_dmabuf_ring_rp* response, int domain);
+int hyper_dmabuf_xen_send_req(int domid, struct hyper_dmabuf_req *req, int wait);

#endif // __HYPER_DMABUF_XEN_COMM_H__
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.c
index a068276..2a1f45b 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
@@ -9,80 +9,73 @@
#include "hyper_dmabuf_xen_comm.h"
#include "hyper_dmabuf_xen_comm_list.h"

-DECLARE_HASHTABLE(hyper_dmabuf_hash_importer_ring, MAX_ENTRY_IMPORT_RING);
-DECLARE_HASHTABLE(hyper_dmabuf_hash_exporter_ring, MAX_ENTRY_EXPORT_RING);
+DECLARE_HASHTABLE(xen_comm_tx_ring_hash, MAX_ENTRY_TX_RING);
+DECLARE_HASHTABLE(xen_comm_rx_ring_hash, MAX_ENTRY_RX_RING);

-int hyper_dmabuf_ring_table_init()
+void xen_comm_ring_table_init()
{
- hash_init(hyper_dmabuf_hash_importer_ring);
- hash_init(hyper_dmabuf_hash_exporter_ring);
- return 0;
-}
-
-int hyper_dmabuf_ring_table_destroy()
-{
- /* TODO: cleanup tables*/
- return 0;
+ hash_init(xen_comm_rx_ring_hash);
+ hash_init(xen_comm_tx_ring_hash);
}

-int hyper_dmabuf_register_exporter_ring(struct hyper_dmabuf_ring_info_export *ring_info)
+int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info *ring_info)
{
- struct hyper_dmabuf_exporter_ring_info *info_entry;
+ struct xen_comm_tx_ring_info_entry *info_entry;

info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);

info_entry->info = ring_info;

- hash_add(hyper_dmabuf_hash_exporter_ring, &info_entry->node,
+ hash_add(xen_comm_tx_ring_hash, &info_entry->node,
info_entry->info->rdomain);

return 0;
}

-int hyper_dmabuf_register_importer_ring(struct hyper_dmabuf_ring_info_import *ring_info)
+int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info *ring_info)
{
- struct hyper_dmabuf_importer_ring_info *info_entry;
+ struct xen_comm_rx_ring_info_entry *info_entry;

info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);

info_entry->info = ring_info;

- hash_add(hyper_dmabuf_hash_importer_ring, &info_entry->node,
+ hash_add(xen_comm_rx_ring_hash, &info_entry->node,
info_entry->info->sdomain);

return 0;
}

-struct hyper_dmabuf_ring_info_export *hyper_dmabuf_find_exporter_ring(int domid)
+struct xen_comm_tx_ring_info *xen_comm_find_tx_ring(int domid)
{
- struct hyper_dmabuf_exporter_ring_info *info_entry;
+ struct xen_comm_tx_ring_info_entry *info_entry;
int bkt;

- hash_for_each(hyper_dmabuf_hash_exporter_ring, bkt, info_entry, node)
+ hash_for_each(xen_comm_tx_ring_hash, bkt, info_entry, node)
if(info_entry->info->rdomain == domid)
return info_entry->info;

return NULL;
}

-struct hyper_dmabuf_ring_info_import *hyper_dmabuf_find_importer_ring(int domid)
+struct xen_comm_rx_ring_info *xen_comm_find_rx_ring(int domid)
{
- struct hyper_dmabuf_importer_ring_info *info_entry;
+ struct xen_comm_rx_ring_info_entry *info_entry;
int bkt;

- hash_for_each(hyper_dmabuf_hash_importer_ring, bkt, info_entry, node)
+ hash_for_each(xen_comm_rx_ring_hash, bkt, info_entry, node)
if(info_entry->info->sdomain == domid)
return info_entry->info;

return NULL;
}

-int hyper_dmabuf_remove_exporter_ring(int domid)
+int xen_comm_remove_tx_ring(int domid)
{
- struct hyper_dmabuf_exporter_ring_info *info_entry;
+ struct xen_comm_tx_ring_info_entry *info_entry;
int bkt;

- hash_for_each(hyper_dmabuf_hash_exporter_ring, bkt, info_entry, node)
+ hash_for_each(xen_comm_tx_ring_hash, bkt, info_entry, node)
if(info_entry->info->rdomain == domid) {
hash_del(&info_entry->node);
kfree(info_entry);
@@ -92,12 +85,12 @@ int hyper_dmabuf_remove_exporter_ring(int domid)
return -1;
}

-int hyper_dmabuf_remove_importer_ring(int domid)
+int xen_comm_remove_rx_ring(int domid)
{
- struct hyper_dmabuf_importer_ring_info *info_entry;
+ struct xen_comm_rx_ring_info_entry *info_entry;
int bkt;

- hash_for_each(hyper_dmabuf_hash_importer_ring, bkt, info_entry, node)
+ hash_for_each(xen_comm_rx_ring_hash, bkt, info_entry, node)
if(info_entry->info->sdomain == domid) {
hash_del(&info_entry->node);
kfree(info_entry);
@@ -107,24 +100,26 @@ int hyper_dmabuf_remove_importer_ring(int domid)
return -1;
}

-void hyper_dmabuf_foreach_exporter_ring(void (*func)(int rdom))
+void xen_comm_foreach_tx_ring(void (*func)(int domid))
{
- struct hyper_dmabuf_exporter_ring_info *info_entry;
+ struct xen_comm_tx_ring_info_entry *info_entry;
struct hlist_node *tmp;
int bkt;

- hash_for_each_safe(hyper_dmabuf_hash_exporter_ring, bkt, tmp, info_entry, node) {
+ hash_for_each_safe(xen_comm_tx_ring_hash, bkt, tmp,
+ info_entry, node) {
func(info_entry->info->rdomain);
}
}

-void hyper_dmabuf_foreach_importer_ring(void (*func)(int sdom))
+void xen_comm_foreach_rx_ring(void (*func)(int domid))
{
- struct hyper_dmabuf_importer_ring_info *info_entry;
+ struct xen_comm_rx_ring_info_entry *info_entry;
struct hlist_node *tmp;
int bkt;

- hash_for_each_safe(hyper_dmabuf_hash_importer_ring, bkt, tmp, info_entry, node) {
+ hash_for_each_safe(xen_comm_rx_ring_hash, bkt, tmp,
+ info_entry, node) {
func(info_entry->info->sdomain);
}
}
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h
index fd1958c..18b3afd 100644
--- a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_comm_list.h
@@ -2,40 +2,38 @@
#define __HYPER_DMABUF_XEN_COMM_LIST_H__

/* number of bits to be used for exported dmabufs hash table */
-#define MAX_ENTRY_EXPORT_RING 7
+#define MAX_ENTRY_TX_RING 7
/* number of bits to be used for imported dmabufs hash table */
-#define MAX_ENTRY_IMPORT_RING 7
+#define MAX_ENTRY_RX_RING 7

-struct hyper_dmabuf_exporter_ring_info {
- struct hyper_dmabuf_ring_info_export *info;
+struct xen_comm_tx_ring_info_entry {
+ struct xen_comm_tx_ring_info *info;
struct hlist_node node;
};

-struct hyper_dmabuf_importer_ring_info {
- struct hyper_dmabuf_ring_info_import *info;
+struct xen_comm_rx_ring_info_entry {
+ struct xen_comm_rx_ring_info *info;
struct hlist_node node;
};

-int hyper_dmabuf_ring_table_init(void);
+void xen_comm_ring_table_init(void);

-int hyper_dmabuf_ring_table_destroy(void);
+int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info *ring_info);

-int hyper_dmabuf_register_exporter_ring(struct hyper_dmabuf_ring_info_export *ring_info);
+int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info *ring_info);

-int hyper_dmabuf_register_importer_ring(struct hyper_dmabuf_ring_info_import *ring_info);
+int xen_comm_remove_tx_ring(int domid);

-struct hyper_dmabuf_ring_info_export *hyper_dmabuf_find_exporter_ring(int domid);
+int xen_comm_remove_rx_ring(int domid);

-struct hyper_dmabuf_ring_info_import *hyper_dmabuf_find_importer_ring(int domid);
+struct xen_comm_tx_ring_info *xen_comm_find_tx_ring(int domid);

-int hyper_dmabuf_remove_exporter_ring(int domid);
-
-int hyper_dmabuf_remove_importer_ring(int domid);
+struct xen_comm_rx_ring_info *xen_comm_find_rx_ring(int domid);

/* iterates over all exporter rings and calls provided function for each of them */
-void hyper_dmabuf_foreach_exporter_ring(void (*func)(int rdom));
+void xen_comm_foreach_tx_ring(void (*func)(int domid));

/* iterates over all importer rings and calls provided function for each of them */
-void hyper_dmabuf_foreach_importer_ring(void (*func)(int sdom));
+void xen_comm_foreach_rx_ring(void (*func)(int domid));

#endif // __HYPER_DMABUF_XEN_COMM_LIST_H__
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c
new file mode 100644
index 0000000..e7b871a
--- /dev/null
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.c
@@ -0,0 +1,22 @@
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <xen/grant_table.h>
+#include "../hyper_dmabuf_msg.h"
+#include "../hyper_dmabuf_drv.h"
+#include "hyper_dmabuf_xen_drv.h"
+#include "hyper_dmabuf_xen_comm.h"
+#include "hyper_dmabuf_xen_shm.h"
+
+struct hyper_dmabuf_backend_ops xen_backend_ops = {
+ .get_vm_id = hyper_dmabuf_get_domid,
+ .share_pages = hyper_dmabuf_xen_share_pages,
+ .unshare_pages = hyper_dmabuf_xen_unshare_pages,
+ .map_shared_pages = (void *)hyper_dmabuf_xen_map_shared_pages,
+ .unmap_shared_pages = hyper_dmabuf_xen_unmap_shared_pages,
+ .init_comm_env = hyper_dmabuf_xen_init_comm_env,
+ .destroy_comm = hyper_dmabuf_xen_destroy_comm,
+ .init_rx_ch = hyper_dmabuf_xen_init_rx_rbuf,
+ .init_tx_ch = hyper_dmabuf_xen_init_tx_rbuf,
+ .send_req = hyper_dmabuf_xen_send_req,
+};
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h
new file mode 100644
index 0000000..e351c08
--- /dev/null
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_drv.h
@@ -0,0 +1,20 @@
+#ifndef __HYPER_DMABUF_XEN_DRV_H__
+#define __HYPER_DMABUF_XEN_DRV_H__
+#include <xen/interface/grant_table.h>
+
+extern struct hyper_dmabuf_backend_ops xen_backend_ops;
+
+/* Main purpose of this structure is to keep
+ * all references created or acquired for sharing
+ * pages with another domain for freeing those later
+ * when unsharing.
+ */
+struct xen_shared_pages_info {
+ grant_ref_t lvl3_gref; /* top level refid */
+ grant_ref_t *lvl3_table; /* page of top level addressing, it contains refids of 2nd level pages */
+ grant_ref_t *lvl2_table; /* table of 2nd level pages, that contains refids to data pages */
+ struct gnttab_unmap_grant_ref* unmap_ops; /* unmap ops for mapped pages */
+ struct page **data_pages; /* data pages to be unmapped */
+};
+
+#endif // __HYPER_DMABUF_XEN_COMM_H__
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
new file mode 100644
index 0000000..c0045d4
--- /dev/null
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.c
@@ -0,0 +1,356 @@
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <xen/grant_table.h>
+#include <asm/xen/page.h>
+#include "hyper_dmabuf_xen_drv.h"
+
+#define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))
+
+/*
+ * Creates 2 level page directory structure for referencing shared pages.
+ * Top level page is a single page that contains up to 1024 refids that
+ * point to 2nd level pages.
+ * Each 2nd level page contains up to 1024 refids that point to shared
+ * data pages.
+ * There will always be one top level page and number of 2nd level pages
+ * depends on number of shared data pages.
+ *
+ * 3rd level page 2nd level pages Data pages
+ * +-------------------------+ ┌>+--------------------+ ┌--->+------------+
+ * |2nd level page 0 refid |---┘ |Data page 0 refid |-┘ |Data page 0 |
+ * |2nd level page 1 refid |---┐ |Data page 1 refid |-┐ +------------+
+ * | ... | | | .... | |
+ * |2nd level page 1023 refid|-┐ | |Data page 1023 refid| └--->+------------+
+ * +-------------------------+ | | +--------------------+ |Data page 1 |
+ * | | +------------+
+ * | └>+--------------------+
+ * | |Data page 1024 refid|
+ * | |Data page 1025 refid|
+ * | | ... |
+ * | |Data page 2047 refid|
+ * | +--------------------+
+ * |
+ * | .....
+ * └-->+-----------------------+
+ * |Data page 1047552 refid|
+ * |Data page 1047553 refid|
+ * | ... |
+ * |Data page 1048575 refid|-->+------------------+
+ * +-----------------------+ |Data page 1048575 |
+ * +------------------+
+ *
+ * Using such 2 level structure it is possible to reference up to 4GB of
+ * shared data using single refid pointing to top level page.
+ *
+ * Returns refid of top level page.
+ */
+int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
+ void **refs_info)
+{
+ grant_ref_t lvl3_gref;
+ grant_ref_t *lvl2_table;
+ grant_ref_t *lvl3_table;
+
+ /*
+ * Calculate number of pages needed for 2nd level addresing:
+ */
+ int n_lvl2_grefs = (nents/REFS_PER_PAGE +
+ ((nents % REFS_PER_PAGE) ? 1: 0));
+
+ struct xen_shared_pages_info *sh_pages_info;
+ int i;
+
+ lvl3_table = (grant_ref_t *)__get_free_pages(GFP_KERNEL, 1);
+ lvl2_table = (grant_ref_t *)__get_free_pages(GFP_KERNEL, n_lvl2_grefs);
+
+ sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
+ *refs_info = (void *)sh_pages_info;
+
+ /* share data pages in rw mode*/
+ for (i=0; i<nents; i++) {
+ lvl2_table[i] = gnttab_grant_foreign_access(domid,
+ pfn_to_mfn(page_to_pfn(pages[i])),
+ 0);
+ }
+
+ /* 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 ),
+ 1);
+ }
+
+ /* Share lvl3_table in readonly mode*/
+ lvl3_gref = gnttab_grant_foreign_access(domid,
+ virt_to_mfn((unsigned long)lvl3_table),
+ 1);
+
+
+ /* Store lvl3_table page to be freed later */
+ sh_pages_info->lvl3_table = lvl3_table;
+
+ /* Store lvl2_table pages to be freed later */
+ sh_pages_info->lvl2_table = lvl2_table;
+
+ /* Store exported pages refid to be unshared later */
+ sh_pages_info->lvl3_gref = lvl3_gref;
+
+ return lvl3_gref;
+}
+
+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 i;
+
+ sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
+
+ if (sh_pages_info->lvl3_table == NULL ||
+ sh_pages_info->lvl2_table == NULL ||
+ sh_pages_info->lvl3_gref == -1) {
+ printk("gref table for hyper_dmabuf already cleaned up\n");
+ return 0;
+ }
+
+ /* End foreign access for data pages, but do not free them */
+ for (i = 0; i < nents; i++) {
+ if (gnttab_query_foreign_access(sh_pages_info->lvl2_table[i])) {
+ printk("refid not shared !!\n");
+ }
+ gnttab_end_foreign_access_ref(sh_pages_info->lvl2_table[i], 0);
+ gnttab_free_grant_reference(sh_pages_info->lvl2_table[i]);
+ }
+
+ /* End foreign access for 2nd level addressing pages */
+ for (i = 0; i < n_lvl2_grefs; i++) {
+ if (gnttab_query_foreign_access(sh_pages_info->lvl3_table[i])) {
+ printk("refid not shared !!\n");
+ }
+ if (!gnttab_end_foreign_access_ref(sh_pages_info->lvl3_table[i], 1)) {
+ printk("refid still in use!!!\n");
+ }
+ gnttab_free_grant_reference(sh_pages_info->lvl3_table[i]);
+ }
+
+ /* End foreign access for top level addressing page */
+ if (gnttab_query_foreign_access(sh_pages_info->lvl3_gref)) {
+ printk("gref not shared !!\n");
+ }
+
+ gnttab_end_foreign_access_ref(sh_pages_info->lvl3_gref, 1);
+ gnttab_free_grant_reference(sh_pages_info->lvl3_gref);
+
+ /* freeing all pages used for 2 level addressing */
+ free_pages((unsigned long)sh_pages_info->lvl2_table, n_lvl2_grefs);
+ free_pages((unsigned long)sh_pages_info->lvl3_table, 1);
+
+ sh_pages_info->lvl3_gref = -1;
+ sh_pages_info->lvl2_table = NULL;
+ sh_pages_info->lvl3_table = NULL;
+ kfree(sh_pages_info);
+ sh_pages_info = NULL;
+
+ return 0;
+}
+
+/*
+ * Maps provided top level ref id and then return array of pages containing data refs.
+ */
+struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int nents, void **refs_info)
+{
+ struct page *lvl3_table_page;
+ struct page **lvl2_table_pages;
+ struct page **data_pages;
+ struct xen_shared_pages_info *sh_pages_info;
+
+ grant_ref_t *lvl3_table;
+ grant_ref_t *lvl2_table;
+
+ struct gnttab_map_grant_ref lvl3_map_ops;
+ struct gnttab_unmap_grant_ref lvl3_unmap_ops;
+
+ struct gnttab_map_grant_ref *lvl2_map_ops;
+ struct gnttab_unmap_grant_ref *lvl2_unmap_ops;
+
+ struct gnttab_map_grant_ref *data_map_ops;
+ struct gnttab_unmap_grant_ref *data_unmap_ops;
+
+ int nents_last = nents % REFS_PER_PAGE;
+ int n_lvl2_grefs = (nents / REFS_PER_PAGE) + ((nents_last > 0) ? 1 : 0);
+ int i, j, k;
+
+ 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);
+ 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);
+
+ 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)) {
+ printk("Cannot allocate pages\n");
+ return NULL;
+ }
+
+ lvl3_table = (grant_ref_t *)pfn_to_kaddr(page_to_pfn(lvl3_table_page));
+
+ gnttab_set_map_op(&lvl3_map_ops, (unsigned long)lvl3_table, GNTMAP_host_map | GNTMAP_readonly,
+ (grant_ref_t)lvl3_gref, domid);
+
+ gnttab_set_unmap_op(&lvl3_unmap_ops, (unsigned long)lvl3_table, GNTMAP_host_map | GNTMAP_readonly, -1);
+
+ if (gnttab_map_refs(&lvl3_map_ops, NULL, &lvl3_table_page, 1)) {
+ printk("\nxen: dom0: HYPERVISOR map grant ref failed");
+ return NULL;
+ }
+
+ if (lvl3_map_ops.status) {
+ printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d",
+ lvl3_map_ops.status);
+ return NULL;
+ } else {
+ lvl3_unmap_ops.handle = lvl3_map_ops.handle;
+ }
+
+ /* Map all second level pages */
+ if (gnttab_alloc_pages(n_lvl2_grefs, lvl2_table_pages)) {
+ printk("Cannot allocate pages\n");
+ return NULL;
+ }
+
+ 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,
+ lvl3_table[i], domid);
+ 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)) {
+ printk("\xen: cannot unmap top level page\n");
+ return NULL;
+ }
+
+ if (gnttab_map_refs(lvl2_map_ops, NULL, lvl2_table_pages, n_lvl2_grefs)) {
+ printk("\nxen: dom0: HYPERVISOR map grant ref failed");
+ return NULL;
+ }
+
+ /* Checks if pages were mapped correctly */
+ for (i = 0; i < n_lvl2_grefs; i++) {
+ if (lvl2_map_ops[i].status) {
+ printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d",
+ lvl2_map_ops[i].status);
+ return NULL;
+ } else {
+ lvl2_unmap_ops[i].handle = lvl2_map_ops[i].handle;
+ }
+ }
+
+ if (gnttab_alloc_pages(nents, data_pages)) {
+ printk("Cannot allocate pages\n");
+ return NULL;
+ }
+
+ k = 0;
+
+ for (i = 0; i < (nents_last ? n_lvl2_grefs - 1 : n_lvl2_grefs); i++) {
+ 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,
+ 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, -1);
+ k++;
+ }
+ }
+
+ /* for grefs in the last lvl2 table page */
+ lvl2_table = pfn_to_kaddr(page_to_pfn(lvl2_table_pages[n_lvl2_grefs - 1]));
+
+ 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,
+ 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, -1);
+ k++;
+ }
+
+ if (gnttab_map_refs(data_map_ops, NULL, data_pages, nents)) {
+ printk("\nxen: dom0: HYPERVISOR map grant ref failed\n");
+ return NULL;
+ }
+
+ /* unmapping lvl2 table pages */
+ if (gnttab_unmap_refs(lvl2_unmap_ops, NULL, lvl2_table_pages,
+ n_lvl2_grefs)) {
+ printk("Cannot unmap 2nd level refs\n");
+ return NULL;
+ }
+
+ for (i = 0; i < nents; i++) {
+ if (data_map_ops[i].status) {
+ printk("\nxen: dom0: HYPERVISOR map grant ref failed status = %d\n",
+ data_map_ops[i].status);
+ return NULL;
+ } else {
+ data_unmap_ops[i].handle = data_map_ops[i].handle;
+ }
+ }
+
+ /* store these references for unmapping in the future */
+ sh_pages_info->unmap_ops = data_unmap_ops;
+ sh_pages_info->data_pages = data_pages;
+
+ gnttab_free_pages(1, &lvl3_table_page);
+ gnttab_free_pages(n_lvl2_grefs, lvl2_table_pages);
+ kfree(lvl2_table_pages);
+ kfree(lvl2_map_ops);
+ kfree(lvl2_unmap_ops);
+ kfree(data_map_ops);
+
+ return data_pages;
+}
+
+int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents) {
+ struct xen_shared_pages_info *sh_pages_info;
+
+ sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
+
+ if (sh_pages_info->unmap_ops == NULL ||
+ sh_pages_info->data_pages == NULL) {
+ printk("Imported pages already cleaned up or buffer was not imported yet\n");
+ return 0;
+ }
+
+ if (gnttab_unmap_refs(sh_pages_info->unmap_ops, NULL,
+ sh_pages_info->data_pages, nents) ) {
+ printk("Cannot unmap data pages\n");
+ return -EINVAL;
+ }
+
+ gnttab_free_pages(nents, sh_pages_info->data_pages);
+
+ kfree(sh_pages_info->data_pages);
+ kfree(sh_pages_info->unmap_ops);
+ sh_pages_info->unmap_ops = NULL;
+ sh_pages_info->data_pages = NULL;
+ kfree(sh_pages_info);
+ sh_pages_info = NULL;
+
+ return 0;
+}
diff --git a/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h
new file mode 100644
index 0000000..2287804
--- /dev/null
+++ b/drivers/xen/hyper_dmabuf/xen/hyper_dmabuf_xen_shm.h
@@ -0,0 +1,19 @@
+#ifndef __HYPER_DMABUF_XEN_SHM_H__
+#define __HYPER_DMABUF_XEN_SHM_H__
+
+/* This collects all reference numbers for 2nd level shared pages and create a table
+ * with those in 1st level shared pages then return reference numbers for this top level
+ * table. */
+int hyper_dmabuf_xen_share_pages(struct page **pages, int domid, int nents,
+ void **refs_info);
+
+int hyper_dmabuf_xen_unshare_pages(void **refs_info, int nents);
+
+/* Maps provided top level ref id and then return array of pages containing data refs.
+ */
+struct page ** hyper_dmabuf_xen_map_shared_pages(int lvl3_gref, int domid, int nents,
+ void **refs_info);
+
+int hyper_dmabuf_xen_unmap_shared_pages(void **refs_info, int nents);
+
+#endif /* __HYPER_DMABUF_XEN_SHM_H__ */
--
2.7.4
\
 
 \ /
  Last update: 2017-12-19 20:49    [W:0.661 / U:0.948 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site