Re: [Linaro-mm-sig] [RFC, v2, 5/9] hyper_dmabuf: default backend for XEN hypervisor

On 02/14/2018 03:50 AM, Dongwon Kim wrote:

From: "Matuesz Polrola" mateuszx.potrola@intel.com

The default backend for XEN hypervisor. This backend contains actual implementation of individual methods defined in "struct hyper_dmabuf_bknd_ops" defined as:

struct hyper_dmabuf_bknd_ops { /* backend initialization routine (optional) */ int (*init)(void);

     /* backend cleanup routine (optional) */
     int (*cleanup)(void);

     /* 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)(unsigned long, 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);

};

First two methods are for extra initialization or cleaning up possibly required for the current Hypervisor (optional). Third method (.get_vm_id) provides a way to get current VM's id, which will be used as an identication of source VM of shared hyper_DMABUF later.

All other methods are related to either memory sharing or inter-VM communication, which are minimum requirement for hyper_DMABUF driver. (Brief description of role of each method is embedded as a comment in the definition of the structure above and header file.)

Actual implementation of each of these methods specific to XEN is under backends/xen/. Their mappings are done as followed:

struct hyper_dmabuf_bknd_ops xen_bknd_ops = { .init = NULL, /* not needed for xen */ .cleanup = NULL, /* not needed for xen */ .get_vm_id = xen_be_get_domid, .share_pages = xen_be_share_pages, .unshare_pages = xen_be_unshare_pages, .map_shared_pages = (void *)xen_be_map_shared_pages, .unmap_shared_pages = xen_be_unmap_shared_pages, .init_comm_env = xen_be_init_comm_env, .destroy_comm = xen_be_destroy_comm, .init_rx_ch = xen_be_init_rx_rbuf, .init_tx_ch = xen_be_init_tx_rbuf, .send_req = xen_be_send_req, };

A section for Hypervisor Backend has been added to

"Documentation/hyper-dmabuf-sharing.txt" accordingly

Signed-off-by: Dongwon Kim dongwon.kim@intel.com Signed-off-by: Mateusz Polrola mateuszx.potrola@intel.com

---

drivers/dma-buf/hyper_dmabuf/Kconfig | 7 + drivers/dma-buf/hyper_dmabuf/Makefile | 7 + .../backends/xen/hyper_dmabuf_xen_comm.c | 941 +++++++++++++++++++++ .../backends/xen/hyper_dmabuf_xen_comm.h | 78 ++ .../backends/xen/hyper_dmabuf_xen_comm_list.c | 158 ++++ .../backends/xen/hyper_dmabuf_xen_comm_list.h | 67 ++ .../backends/xen/hyper_dmabuf_xen_drv.c | 46 + .../backends/xen/hyper_dmabuf_xen_drv.h | 53 ++ .../backends/xen/hyper_dmabuf_xen_shm.c | 525 ++++++++++++ .../backends/xen/hyper_dmabuf_xen_shm.h | 46 + drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.c | 10 + 11 files changed, 1938 insertions(+) create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.c create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.h create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.c create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.h create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.c create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.h create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.c create mode 100644 drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.h

diff --git a/drivers/dma-buf/hyper_dmabuf/Kconfig b/drivers/dma-buf/hyper_dmabuf/Kconfig index 5ebf516d65eb..68f3d6ce2c1f 100644 --- a/drivers/dma-buf/hyper_dmabuf/Kconfig +++ b/drivers/dma-buf/hyper_dmabuf/Kconfig @@ -20,4 +20,11 @@ config HYPER_DMABUF_SYSFS The location of sysfs is under "...." +config HYPER_DMABUF_XEN

•    bool "Configure hyper_dmabuf for XEN hypervisor"
  

•    default y
  

n?

•    depends on HYPER_DMABUF && XEN && XENFS
  

•    help
  

•      Enabling Hyper_DMABUF Backend for XEN hypervisor
  

• endmenu

diff --git a/drivers/dma-buf/hyper_dmabuf/Makefile b/drivers/dma-buf/hyper_dmabuf/Makefile index 3908522b396a..b9ab4eeca6f2 100644 --- a/drivers/dma-buf/hyper_dmabuf/Makefile +++ b/drivers/dma-buf/hyper_dmabuf/Makefile @@ -10,6 +10,13 @@ ifneq ($(KERNELRELEASE),) hyper_dmabuf_msg.o \ hyper_dmabuf_id.o \ +ifeq ($(CONFIG_HYPER_DMABUF_XEN), y)

• $(TARGET_MODULE)-objs += backends/xen/hyper_dmabuf_xen_comm.o \

• 		 backends/xen/hyper_dmabuf_xen_comm_list.o \
  

• 		 backends/xen/hyper_dmabuf_xen_shm.o \
  

• 		 backends/xen/hyper_dmabuf_xen_drv.o
  

+endif

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

# If we are running without kernel build system diff --git a/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.c b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.c new file mode 100644 index 000000000000..30bc4b6304ac --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.c @@ -0,0 +1,941 @@ +/*

• • Copyright © 2018 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• • Authors:
• • Dongwon Kim dongwon.kim@intel.com
• • Mateusz Polrola mateuszx.potrola@intel.com
• */

+#include <linux/errno.h> +#include <linux/slab.h> +#include <linux/workqueue.h> +#include <linux/delay.h> +#include <xen/grant_table.h> +#include <xen/events.h> +#include <xen/xenbus.h> +#include <asm/xen/page.h> +#include "hyper_dmabuf_xen_comm.h" +#include "hyper_dmabuf_xen_comm_list.h" +#include "../../hyper_dmabuf_drv.h"

+static int export_req_id;

can we avoid this?

+struct hyper_dmabuf_req req_pending = {0};

+static void xen_get_domid_delayed(struct work_struct *unused); +static void xen_init_comm_env_delayed(struct work_struct *unused);

+static DECLARE_DELAYED_WORK(get_vm_id_work, xen_get_domid_delayed); +static DECLARE_DELAYED_WORK(xen_init_comm_env_work, xen_init_comm_env_delayed);

+/* 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];
• sprintf(buf, "/local/domain/%d/data/hyper_dmabuf",

• hy_drv_priv->domid);
  

Here and below: please have a string constant for that

• return xenbus_mkdir(XBT_NIL, buf, "");

Please think of updating XenBus with a transaction, not XBT_NIL

+}

+/* 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
• */

+static int xen_comm_destroy_data_dir(void) +{

• char buf[255];
• sprintf(buf, "/local/domain/%d/data/hyper_dmabuf",

• hy_drv_priv->domid);
  

• return xenbus_rm(XBT_NIL, buf, "");

+}

+/* Adds xenstore entries with details of exporter ring created

• • for given remote domain. It requires special daemon running

what is this special daemon?

• • in dom0 to make sure that given remote domain will have right
• • permissions to access that data.
• */

+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", gref);
• if (ret) {

• dev_err(hy_drv_priv->dev,
  

Please do not touch global hy_drv_priv directly

• 	"Failed to write xenbus entry %s: %d\n",
  

• 	buf, ret);
  

• return ret;
  

• }
• ret = xenbus_printf(XBT_NIL, buf, "port", "%d", port);
• if (ret) {

• dev_err(hy_drv_priv->dev,
  

• 	"Failed to write xenbus entry %s: %d\n",
  

• 	buf, ret);
  

• return ret;
  

• }
• return 0;

+}

+/*

• • Queries details of ring exposed by remote domain.
• */

+static int xen_comm_get_ring_details(int domid, int rdomid,

• 		     int *grefid, int *port)
  

+{

• char buf[255];
• int ret;
• sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",

• rdomid, domid);
  

• ret = xenbus_scanf(XBT_NIL, buf, "grefid", "%d", grefid);

You'll have a race condition here as you are not using transactions, so you might read partial data from XenBus

• if (ret <= 0) {

• dev_err(hy_drv_priv->dev,
  

• 	"Failed to read xenbus entry %s: %d\n",
  

• 	buf, ret);
  

• return ret;
  

• }
• ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", port);

Ditto

• if (ret <= 0) {

• dev_err(hy_drv_priv->dev,
  

• 	"Failed to read xenbus entry %s: %d\n",
  

• 	buf, ret);
  

• return ret;
  

• }
• return (ret <= 0 ? 1 : 0);

+}

+static void xen_get_domid_delayed(struct work_struct *unused) +{

• struct xenbus_transaction xbt;
• int domid, ret;
• /* scheduling another if driver is still running

• * and xenstore has not been initialized
  

• */
  

Please think of using XenBus drivers for this (struct xenbus_driver) It might add some complexity in the backend (by dynamically registering/ unregistering XenBus driver), but will also let you run such code as you have here synchronously, e.g. see struct xenbus_driver.otherend_changed. This way you'll be able to implement XenBus state machine as other Xen front/back drivers do.

• if (likely(xenstored_ready == 0)) {

• dev_dbg(hy_drv_priv->dev,
  

• 	"Xenstore is not ready yet. Will retry in 500ms\n");
  

• schedule_delayed_work(&get_vm_id_work, msecs_to_jiffies(500));
  

• } else {

• xenbus_transaction_start(&xbt);
  

so, for consistency, please use transactions everywhere

• ret = xenbus_scanf(xbt, "domid", "", "%d", &domid);
  

• if (ret <= 0)
  

• 	domid = -1;
  

• xenbus_transaction_end(xbt, 0);
  

• /* try again since -1 is an invalid id for domain
  

•  * (but only if driver is still running)
  

•  */
  

• if (unlikely(domid == -1)) {
  

• 	dev_dbg(hy_drv_priv->dev,
  

• 		"domid==-1 is invalid. Will retry it in 500ms\n");
  

• 	schedule_delayed_work(&get_vm_id_work,
  

• 			      msecs_to_jiffies(500));
  

This doesn't seem to be designed right as you need to poll for values and have this worker

• } else {
  

• 	dev_info(hy_drv_priv->dev,
  

• 		 "Successfully retrieved domid from Xenstore:%d\n",
  

• 		 domid);
  

• 	hy_drv_priv->domid = domid;
  

• }
  

• }

+}

+int xen_be_get_domid(void) +{

• struct xenbus_transaction xbt;
• int domid;
• if (unlikely(xenstored_ready == 0)) {

• xen_get_domid_delayed(NULL);
  

• return -1;
  

• }
• xenbus_transaction_start(&xbt);
• if (!xenbus_scanf(xbt, "domid", "", "%d", &domid))

• domid = -1;
  

• xenbus_transaction_end(xbt, 0);
• return domid;

+}

+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 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.

If you implement xenbus_driver.otherend_changed and corresponding state machine this might not be needed

• • 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_dom_exporter_watch_cb(struct xenbus_watch *watch,

• 			 const char *path, const char *token)
  

+{

• int rdom, ret;
• uint32_t grefid, port;
• struct xen_comm_rx_ring_info *ring_info;
• /* Check which domain has changed its exporter rings */
• ret = sscanf(watch->node, "/local/domain/%d/", &rdom);
• if (ret <= 0)

• return;
  

• /* Check if we have importer ring for given remote domain already

• * created
  

• */
  

• ring_info = xen_comm_find_rx_ring(rdom);
• /* Try to query remote domain exporter ring details - if

• * that will fail and we have importer ring that means remote
  

• * domains has cleanup its exporter ring, so our importer ring
  

• * is no longer useful.
  

• *
  

• * 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 = xen_comm_get_ring_details(xen_be_get_domid(),

• 			rdom, &grefid, &port);
  

• if (ring_info && ret != 0) {

• dev_info(hy_drv_priv->dev,
  

• 	 "Remote exporter closed, cleaninup importer\n");
  

• xen_be_cleanup_rx_rbuf(rdom);
  

• } else if (!ring_info && ret == 0) {

• dev_info(hy_drv_priv->dev,
  

• 	 "Registering importer\n");
  

• xen_be_init_rx_rbuf(rdom);
  

• }

+}

+/* exporter needs to generated info for page sharing */ +int xen_be_init_tx_rbuf(int domid) +{

• 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;
• /* check if there's any existing tx channel in the table */
• ring_info = xen_comm_find_tx_ring(domid);
• if (ring_info) {

• dev_info(hy_drv_priv->dev,
  

• 	 "tx ring ch to domid = %d already exist\ngref = %d, port = %d\n",
  

• ring_info->rdomain, ring_info->gref_ring, ring_info->port);
  

• return 0;
  

• }
• ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
• if (!ring_info)

• return -ENOMEM;
  

• /* from exporter to importer */
• shared_ring = (void *)__get_free_pages(GFP_KERNEL, 1);
• if (shared_ring == 0) {

• kfree(ring_info);
  

• return -ENOMEM;
  

• }
• 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(domid,

• 				virt_to_mfn(shared_ring),
  

• 				0);
  

• if (ring_info->gref_ring < 0) {

• /* fail to get gref */
  

• kfree(ring_info);
  

• return -EFAULT;
  

• }
• alloc_unbound.dom = DOMID_SELF;
• alloc_unbound.remote_dom = domid;
• ret = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,

• 			  &alloc_unbound);
  

Please do not open-code: xenbus_alloc_evtchn

• if (ret) {

• dev_err(hy_drv_priv->dev,
  

• 	"Cannot allocate event channel\n");
  

• kfree(ring_info);
  

• return -EIO;
  

• }
• /* setting up interrupt */
• ret = bind_evtchn_to_irqhandler(alloc_unbound.port,

• 			front_ring_isr, 0,
  

• 			NULL, (void *) ring_info);
  

• if (ret < 0) {

• dev_err(hy_drv_priv->dev,
  

• 	"Failed to setup event channel\n");
  

• close.port = alloc_unbound.port;
  

• HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
  

Please do not open-code: xenbus_free_evtchn

• gnttab_end_foreign_access(ring_info->gref_ring, 0,
  

• 			virt_to_mfn(shared_ring));
  

• kfree(ring_info);
  

• return -EIO;
  

• }
• ring_info->rdomain = domid;
• ring_info->irq = ret;
• ring_info->port = alloc_unbound.port;
• mutex_init(&ring_info->lock);
• dev_dbg(hy_drv_priv->dev,

• "%s: allocated eventchannel gref %d  port: %d  irq: %d\n",
  

• __func__,
  

• ring_info->gref_ring,
  

• ring_info->port,
  

• ring_info->irq);
  

• ret = xen_comm_add_tx_ring(ring_info);

And what if we fail?

• ret = xen_comm_expose_ring_details(xen_be_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.
  

• */
  

• ring_info->watch.callback = remote_dom_exporter_watch_cb;
• ring_info->watch.node = kmalloc(255, GFP_KERNEL);
• if (!ring_info->watch.node) {

• kfree(ring_info);
  

• return -ENOMEM;
  

• }
• sprintf((char *)ring_info->watch.node,

• "/local/domain/%d/data/hyper_dmabuf/%d/port",
  

• domid, xen_be_get_domid());
  

• register_xenbus_watch(&ring_info->watch);
• return ret;

+}

+/* cleans up exporter ring created for given remote domain */ +void xen_be_cleanup_tx_rbuf(int domid) +{

• struct xen_comm_tx_ring_info *ring_info;
• struct xen_comm_rx_ring_info *rx_ring_info;
• /* check if we at all have exporter ring for given rdomain */
• ring_info = xen_comm_find_tx_ring(domid);
• if (!ring_info)

• return;
  

• 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 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);
• rx_ring_info = xen_comm_find_rx_ring(domid);
• if (!rx_ring_info)

• return;
  

• BACK_RING_INIT(&(rx_ring_info->ring_back),

•        rx_ring_info->ring_back.sring,
  

•        PAGE_SIZE);
  

why init on cleanup?

+}

+/* importer needs to know about shared page and port numbers for

• • ring buffer and event channel
• */

+int xen_be_init_rx_rbuf(int domid) +{

• struct xen_comm_rx_ring_info *ring_info;
• struct xen_comm_sring *sring;
• struct page *shared_ring;
• struct gnttab_map_grant_ref *map_ops;
• int ret;
• int rx_gref, rx_port;
• /* check if there's existing rx ring channel */
• ring_info = xen_comm_find_rx_ring(domid);
• if (ring_info) {

• dev_info(hy_drv_priv->dev,
  

• 	 "rx ring ch from domid = %d already exist\n",
  

• 	 ring_info->sdomain);
  

• return 0;
  

• }
• ret = xen_comm_get_ring_details(xen_be_get_domid(), domid,

• 			&rx_gref, &rx_port);
  

• if (ret) {

• dev_err(hy_drv_priv->dev,
  

• 	"Domain %d has not created exporter ring for current domain\n",
  

• 	domid);
  

• return ret;
  

• }
• ring_info = kmalloc(sizeof(*ring_info), GFP_KERNEL);
• if (!ring_info)

• return -ENOMEM;
  

• ring_info->sdomain = domid;
• ring_info->evtchn = rx_port;
• map_ops = kmalloc(sizeof(*map_ops), GFP_KERNEL);
• if (!map_ops) {

• ret = -ENOMEM;
  

• goto fail_no_map_ops;
  

• }
• if (gnttab_alloc_pages(1, &shared_ring)) {

• ret = -ENOMEM;
  

• goto fail_others;
  

• }

Please see xenbus_grant_ring

• gnttab_set_map_op(&map_ops[0],

• 	  (unsigned long)pfn_to_kaddr(
  

• 			page_to_pfn(shared_ring)),
  

• 	  GNTMAP_host_map, rx_gref, domid);
  

• gnttab_set_unmap_op(&ring_info->unmap_op,

• 	    (unsigned long)pfn_to_kaddr(
  

• 			page_to_pfn(shared_ring)),
  

• 	    GNTMAP_host_map, -1);
  

• ret = gnttab_map_refs(map_ops, NULL, &shared_ring, 1);
• if (ret < 0) {

• dev_err(hy_drv_priv->dev, "Cannot map ring\n");
  

• ret = -EFAULT;
  

• goto fail_others;
  

• }
• if (map_ops[0].status) {

• dev_err(hy_drv_priv->dev, "Ring mapping failed\n");
  

• ret = -EFAULT;
  

• goto fail_others;
  

• } else {

• ring_info->unmap_op.handle = map_ops[0].handle;
  

• }
• kfree(map_ops);
• 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_irq(domid, rx_port);
• if (ret < 0) {

• ret = -EIO;
  

• goto fail_others;
  

• }
• ring_info->irq = ret;
• dev_dbg(hy_drv_priv->dev,

• "%s: bound to eventchannel port: %d  irq: %d\n", __func__,
  

• rx_port,
  

• ring_info->irq);
  

• ret = xen_comm_add_rx_ring(ring_info);
• /* Setup communcation channel in opposite direction */
• if (!xen_comm_find_tx_ring(domid))

• ret = xen_be_init_tx_rbuf(domid);
  

• ret = request_irq(ring_info->irq,

• 	  back_ring_isr, 0,
  

• 	  NULL, (void *)ring_info);
  

• return ret;

+fail_others:

• kfree(map_ops);

+fail_no_map_ops:

• kfree(ring_info);
• return ret;

+}

+/* clenas up importer ring create for given source domain */ +void xen_be_cleanup_rx_rbuf(int domid) +{

• struct xen_comm_rx_ring_info *ring_info;
• struct xen_comm_tx_ring_info *tx_ring_info;
• struct page *shared_ring;
• /* check if we have importer ring created for given sdomain */
• ring_info = xen_comm_find_rx_ring(domid);
• if (!ring_info)

• return;
  

• 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);
• /* unmapping shared ring page */
• shared_ring = virt_to_page(ring_info->ring_back.sring);
• gnttab_unmap_refs(&ring_info->unmap_op, NULL, &shared_ring, 1);
• gnttab_free_pages(1, &shared_ring);
• kfree(ring_info);
• tx_ring_info = xen_comm_find_tx_ring(domid);
• if (!tx_ring_info)

• return;
  

• SHARED_RING_INIT(tx_ring_info->ring_front.sring);
• FRONT_RING_INIT(&(tx_ring_info->ring_front),

• 	tx_ring_info->ring_front.sring,
  

• 	PAGE_SIZE);
  

+}

+#ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD

+static void xen_rx_ch_add_delayed(struct work_struct *unused);

+static DECLARE_DELAYED_WORK(xen_rx_ch_auto_add_work, xen_rx_ch_add_delayed);

+#define DOMID_SCAN_START 1 /* domid = 1 */ +#define DOMID_SCAN_END 10 /* domid = 10 */

+static void xen_rx_ch_add_delayed(struct work_struct *unused) +{

• int ret;
• char buf[128];
• int i, dummy;
• dev_dbg(hy_drv_priv->dev,

• "Scanning new tx channel comming from another domain\n");
  

This should be synchronous IMO, no scanners

• /* check other domains and schedule another work if driver

• * is still running and backend is valid
  

• */
  

• if (hy_drv_priv &&

•    hy_drv_priv->initialized) {
  

• for (i = DOMID_SCAN_START; i < DOMID_SCAN_END + 1; i++) {
  

• 	if (i == hy_drv_priv->domid)
  

• 		continue;
  

• 	sprintf(buf, "/local/domain/%d/data/hyper_dmabuf/%d",
  

• 		i, hy_drv_priv->domid);
  

• 	ret = xenbus_scanf(XBT_NIL, buf, "port", "%d", &dummy);
  

• 	if (ret > 0) {
  

• 		if (xen_comm_find_rx_ring(i) != NULL)
  

• 			continue;
  

• 		ret = xen_be_init_rx_rbuf(i);
  

• 		if (!ret)
  

• 			dev_info(hy_drv_priv->dev,
  

• 				 "Done rx ch init for VM %d\n",
  

• 				 i);
  

• 	}
  

• }
  

• /* check every 10 seconds */
  

• schedule_delayed_work(&xen_rx_ch_auto_add_work,
  

• 		      msecs_to_jiffies(10000));
  

• }

+}

+#endif /* CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD */

+void xen_init_comm_env_delayed(struct work_struct *unused) +{

• int ret;
• /* scheduling another work if driver is still running

• * and xenstore hasn't been initialized or dom_id hasn't
  

• * been correctly retrieved.
  

• */
  

• if (likely(xenstored_ready == 0 ||

•    hy_drv_priv->domid == -1)) {
  

• dev_dbg(hy_drv_priv->dev,
  

• 	"Xenstore not ready Will re-try in 500ms\n");
  

• schedule_delayed_work(&xen_init_comm_env_work,
  

• 		      msecs_to_jiffies(500));
  

• } else {

• ret = xen_comm_setup_data_dir();
  

• if (ret < 0) {
  

• 	dev_err(hy_drv_priv->dev,
  

• 		"Failed to create data dir in Xenstore\n");
  

• } else {
  

• 	dev_info(hy_drv_priv->dev,
  

• 		"Successfully finished comm env init\n");
  

• 	hy_drv_priv->initialized = true;
  

+#ifdef CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD

• 	xen_rx_ch_add_delayed(NULL);
  

+#endif /* CONFIG_HYPER_DMABUF_XEN_AUTO_RX_CH_ADD */

• }
  

• }

+}

+int xen_be_init_comm_env(void) +{

• int ret;
• xen_comm_ring_table_init();
• if (unlikely(xenstored_ready == 0 ||

•    hy_drv_priv->domid == -1)) {
  

• xen_init_comm_env_delayed(NULL);
  

• return -1;
  

• }
• ret = xen_comm_setup_data_dir();
• if (ret < 0) {

• dev_err(hy_drv_priv->dev,
  

• 	"Failed to create data dir in Xenstore\n");
  

• } else {

• dev_info(hy_drv_priv->dev,
  

• 	"Successfully finished comm env initialization\n");
  

• hy_drv_priv->initialized = true;
  

• }
• return ret;

+}

+/* cleans up all tx/rx rings */ +static void xen_be_cleanup_all_rbufs(void) +{

• xen_comm_foreach_tx_ring(xen_be_cleanup_tx_rbuf);
• xen_comm_foreach_rx_ring(xen_be_cleanup_rx_rbuf);

+}

+void xen_be_destroy_comm(void) +{

• xen_be_cleanup_all_rbufs();
• xen_comm_destroy_data_dir();

+}

+int xen_be_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;
• struct timeval tv_start, tv_end;
• struct timeval tv_diff;
• int timeout = 1000;
• /* find a ring info for the channel */
• ring_info = xen_comm_find_tx_ring(domid);
• if (!ring_info) {

• dev_err(hy_drv_priv->dev,
  

• 	"Can't find ring info for the channel\n");
  

• return -ENOENT;
  

• }
• ring = &ring_info->ring_front;
• do_gettimeofday(&tv_start);
• while (RING_FULL(ring)) {

• dev_dbg(hy_drv_priv->dev, "RING_FULL\n");
  

• if (timeout == 0) {
  

• 	dev_err(hy_drv_priv->dev,
  

• 		"Timeout while waiting for an entry in the ring\n");
  

• 	return -EIO;
  

• }
  

• usleep_range(100, 120);
  

• timeout--;
  

• }

Heh

• timeout = 1000;
• mutex_lock(&ring_info->lock);
• new_req = RING_GET_REQUEST(ring, ring->req_prod_pvt);
• if (!new_req) {

• mutex_unlock(&ring_info->lock);
  

• dev_err(hy_drv_priv->dev,
  

• 	"NULL REQUEST\n");
  

• return -EIO;
  

• }
• req->req_id = xen_comm_next_req_id();
• /* update req_pending with current request */
• memcpy(&req_pending, req, sizeof(req_pending));
• /* pass current request to the ring */
• memcpy(new_req, req, sizeof(*new_req));
• ring->req_prod_pvt++;
• RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(ring, notify);
• if (notify)

• notify_remote_via_irq(ring_info->irq);
  

• if (wait) {

• while (timeout--) {
  

• 	if (req_pending.stat !=
  

• 	    HYPER_DMABUF_REQ_NOT_RESPONDED)
  

• 		break;
  

• 	usleep_range(100, 120);
  

• }
  

• if (timeout < 0) {
  

• 	mutex_unlock(&ring_info->lock);
  

• 	dev_err(hy_drv_priv->dev,
  

• 		"request timed-out\n");
  

• 	return -EBUSY;
  

• }
  

• mutex_unlock(&ring_info->lock);
  

• do_gettimeofday(&tv_end);
  

• /* checking time duration for round-trip of a request
  

•  * for debugging
  

•  */
  

put it under debug #ifdef then?

• if (tv_end.tv_usec >= tv_start.tv_usec) {
  

• 	tv_diff.tv_sec = tv_end.tv_sec-tv_start.tv_sec;
  

• 	tv_diff.tv_usec = tv_end.tv_usec-tv_start.tv_usec;
  

• } else {
  

• 	tv_diff.tv_sec = tv_end.tv_sec-tv_start.tv_sec-1;
  

• 	tv_diff.tv_usec = tv_end.tv_usec+1000000-
  

• 			  tv_start.tv_usec;
  

• }
  

• if (tv_diff.tv_sec != 0 && tv_diff.tv_usec > 16000)
  

• 	dev_dbg(hy_drv_priv->dev,
  

• 		"send_req:time diff: %ld sec, %ld usec\n",
  

• 		tv_diff.tv_sec, tv_diff.tv_usec);
  

• }
• mutex_unlock(&ring_info->lock);
• return 0;

+}

+/* ISR for handling request */ +static irqreturn_t back_ring_isr(int irq, void *info) +{

• RING_IDX rc, rp;
• struct hyper_dmabuf_req req;
• struct hyper_dmabuf_resp resp;
• int notify, more_to_do;
• int ret;
• struct xen_comm_rx_ring_info *ring_info;
• struct xen_comm_back_ring *ring;
• ring_info = (struct xen_comm_rx_ring_info *)info;
• ring = &ring_info->ring_back;
• dev_dbg(hy_drv_priv->dev, "%s\n", __func__);
• do {

• rc = ring->req_cons;
  

• rp = ring->sring->req_prod;
  

• more_to_do = 0;
  

• while (rc != rp) {
  

• 	if (RING_REQUEST_CONS_OVERFLOW(ring, rc))
  

• 		break;
  

• 	memcpy(&req, RING_GET_REQUEST(ring, rc), sizeof(req));
  

• 	ring->req_cons = ++rc;
  

• 	ret = hyper_dmabuf_msg_parse(ring_info->sdomain, &req);
  

• 	if (ret > 0) {
  

• 		/* preparing a response for the request and
  

• 		 * send it to the requester
  

• 		 */
  

• 		memcpy(&resp, &req, sizeof(resp));
  

• 		memcpy(RING_GET_RESPONSE(ring,
  

• 					 ring->rsp_prod_pvt),
  

• 					 &resp, sizeof(resp));
  

• 		ring->rsp_prod_pvt++;
  

• 		dev_dbg(hy_drv_priv->dev,
  

• 			"responding to exporter for req:%d\n",
  

• 			resp.resp_id);
  

• 		RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring,
  

• 						     notify);
  

• 		if (notify)
  

• 			notify_remote_via_irq(ring_info->irq);
  

• 	}
  

• 	RING_FINAL_CHECK_FOR_REQUESTS(ring, more_to_do);
  

• }
  

• } while (more_to_do);
• return IRQ_HANDLED;

+}

+/* ISR for handling responses */ +static irqreturn_t front_ring_isr(int irq, void *info) +{

• /* front ring only care about response from back */
• struct hyper_dmabuf_resp *resp;
• RING_IDX i, rp;
• int more_to_do, ret;
• struct xen_comm_tx_ring_info *ring_info;
• struct xen_comm_front_ring *ring;
• ring_info = (struct xen_comm_tx_ring_info *)info;
• ring = &ring_info->ring_front;
• dev_dbg(hy_drv_priv->dev, "%s\n", __func__);
• do {

• more_to_do = 0;
  

• rp = ring->sring->rsp_prod;
  

• for (i = ring->rsp_cons; i != rp; i++) {
  

• 	resp = RING_GET_RESPONSE(ring, i);
  

• 	/* update pending request's status with what is
  

• 	 * in the response
  

• 	 */
  

• 	dev_dbg(hy_drv_priv->dev,
  

• 		"getting response from importer\n");
  

• 	if (req_pending.req_id == resp->resp_id)
  

• 		req_pending.stat = resp->stat;
  

• 	if (resp->stat == HYPER_DMABUF_REQ_NEEDS_FOLLOW_UP) {
  

• 		/* parsing response */
  

• 		ret = hyper_dmabuf_msg_parse(ring_info->rdomain,
  

• 			(struct hyper_dmabuf_req *)resp);
  

• 		if (ret < 0) {
  

• 			dev_err(hy_drv_priv->dev,
  

• 				"err while parsing resp\n");
  

• 		}
  

• 	} else if (resp->stat == HYPER_DMABUF_REQ_PROCESSED) {
  

• 		/* for debugging dma_buf remote synch */
  

• 		dev_dbg(hy_drv_priv->dev,
  

• 			"original request = 0x%x\n", resp->cmd);
  

• 		dev_dbg(hy_drv_priv->dev,
  

• 			"got HYPER_DMABUF_REQ_PROCESSED\n");
  

• 	} else if (resp->stat == HYPER_DMABUF_REQ_ERROR) {
  

• 		/* for debugging dma_buf remote synch */
  

• 		dev_dbg(hy_drv_priv->dev,
  

• 			"original request = 0x%x\n", resp->cmd);
  

• 		dev_dbg(hy_drv_priv->dev,
  

• 			"got HYPER_DMABUF_REQ_ERROR\n");
  

• 	}
  

• }
  

• ring->rsp_cons = i;
  

• if (i != ring->req_prod_pvt)
  

• 	RING_FINAL_CHECK_FOR_RESPONSES(ring, more_to_do);
  

• else
  

• 	ring->sring->rsp_event = i+1;
  

• } while (more_to_do);
• return IRQ_HANDLED;

+} diff --git a/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.h b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.h new file mode 100644 index 000000000000..c0d3139ace59 --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm.h @@ -0,0 +1,78 @@ +/*

• • Copyright © 2018 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• */

+#ifndef __HYPER_DMABUF_XEN_COMM_H__ +#define __HYPER_DMABUF_XEN_COMM_H__

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

+extern int xenstored_ready;

+DEFINE_RING_TYPES(xen_comm, struct hyper_dmabuf_req, struct hyper_dmabuf_resp);

+struct xen_comm_tx_ring_info {

• struct xen_comm_front_ring ring_front;
• int rdomain;
• int gref_ring;
• int irq;
• int port;
• struct mutex lock;
• struct xenbus_watch watch;

+};

+struct xen_comm_rx_ring_info {

• int sdomain;
• int irq;
• int evtchn;
• struct xen_comm_back_ring ring_back;
• struct gnttab_unmap_grant_ref unmap_op;

+};

+int xen_be_get_domid(void);

+int xen_be_init_comm_env(void);

+/* exporter needs to generated info for page sharing */ +int xen_be_init_tx_rbuf(int domid);

+/* importer needs to know about shared page and port numbers

• • for ring buffer and event channel
• */

+int xen_be_init_rx_rbuf(int domid);

+/* cleans up exporter ring created for given domain */ +void xen_be_cleanup_tx_rbuf(int domid);

+/* cleans up importer ring created for given domain */ +void xen_be_cleanup_rx_rbuf(int domid);

+void xen_be_destroy_comm(void);

+/* send request to the remote domain */ +int xen_be_send_req(int domid, struct hyper_dmabuf_req *req,

•     int wait);
  

+#endif /* __HYPER_DMABUF_XEN_COMM_H__ */ diff --git a/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.c b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.c new file mode 100644 index 000000000000..5a8e9d9b737f --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.c @@ -0,0 +1,158 @@ +/*

• • Copyright © 2018 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• • Authors:
• • Dongwon Kim dongwon.kim@intel.com
• • Mateusz Polrola mateuszx.potrola@intel.com
• */

+#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/slab.h> +#include <linux/cdev.h> +#include <linux/hashtable.h> +#include <xen/grant_table.h> +#include "../../hyper_dmabuf_drv.h" +#include "hyper_dmabuf_xen_comm.h" +#include "hyper_dmabuf_xen_comm_list.h"

+DECLARE_HASHTABLE(xen_comm_tx_ring_hash, MAX_ENTRY_TX_RING); +DECLARE_HASHTABLE(xen_comm_rx_ring_hash, MAX_ENTRY_RX_RING);

+void xen_comm_ring_table_init(void) +{

• hash_init(xen_comm_rx_ring_hash);
• hash_init(xen_comm_tx_ring_hash);

+}

+int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info *ring_info) +{

• struct xen_comm_tx_ring_info_entry *info_entry;
• info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
• if (!info_entry)

• return -ENOMEM;
  

• info_entry->info = ring_info;
• hash_add(xen_comm_tx_ring_hash, &info_entry->node,

• info_entry->info->rdomain);
  

• return 0;

+}

+int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info *ring_info) +{

• struct xen_comm_rx_ring_info_entry *info_entry;
• info_entry = kmalloc(sizeof(*info_entry), GFP_KERNEL);
• if (!info_entry)

• return -ENOMEM;
  

• info_entry->info = ring_info;
• hash_add(xen_comm_rx_ring_hash, &info_entry->node,

• info_entry->info->sdomain);
  

• return 0;

+}

+struct xen_comm_tx_ring_info *xen_comm_find_tx_ring(int domid) +{

• struct xen_comm_tx_ring_info_entry *info_entry;
• int bkt;
• 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 xen_comm_rx_ring_info *xen_comm_find_rx_ring(int domid) +{

• struct xen_comm_rx_ring_info_entry *info_entry;
• int bkt;
• 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 xen_comm_remove_tx_ring(int domid) +{

• struct xen_comm_tx_ring_info_entry *info_entry;
• int bkt;
• 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);
  

• 	return 0;
  

• }
  

• return -ENOENT;

+}

+int xen_comm_remove_rx_ring(int domid) +{

• struct xen_comm_rx_ring_info_entry *info_entry;
• int bkt;
• 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);
  

• 	return 0;
  

• }
  

• return -ENOENT;

+}

+void xen_comm_foreach_tx_ring(void (*func)(int domid)) +{

• struct xen_comm_tx_ring_info_entry *info_entry;
• struct hlist_node *tmp;
• int bkt;
• hash_for_each_safe(xen_comm_tx_ring_hash, bkt, tmp,

• 	   info_entry, node) {
  

• func(info_entry->info->rdomain);
  

• }

+}

+void xen_comm_foreach_rx_ring(void (*func)(int domid)) +{

• struct xen_comm_rx_ring_info_entry *info_entry;
• struct hlist_node *tmp;
• int bkt;
• hash_for_each_safe(xen_comm_rx_ring_hash, bkt, tmp,

• 	   info_entry, node) {
  

• func(info_entry->info->sdomain);
  

• }

+} diff --git a/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.h b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.h new file mode 100644 index 000000000000..8d4b52bd41b0 --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_comm_list.h @@ -0,0 +1,67 @@ +/*

• • Copyright © 2018 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• */

+#ifndef __HYPER_DMABUF_XEN_COMM_LIST_H__ +#define __HYPER_DMABUF_XEN_COMM_LIST_H__

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

+struct xen_comm_tx_ring_info_entry {

• struct xen_comm_tx_ring_info *info;
• struct hlist_node node;

+};

+struct xen_comm_rx_ring_info_entry {

• struct xen_comm_rx_ring_info *info;
• struct hlist_node node;

+};

+void xen_comm_ring_table_init(void);

+int xen_comm_add_tx_ring(struct xen_comm_tx_ring_info *ring_info);

+int xen_comm_add_rx_ring(struct xen_comm_rx_ring_info *ring_info);

+int xen_comm_remove_tx_ring(int domid);

+int xen_comm_remove_rx_ring(int domid);

+struct xen_comm_tx_ring_info *xen_comm_find_tx_ring(int domid);

+struct xen_comm_rx_ring_info *xen_comm_find_rx_ring(int domid);

+/* iterates over all exporter rings and calls provided

• • function for each of them
• */

+void xen_comm_foreach_tx_ring(void (*func)(int domid));

+/* iterates over all importer rings and calls provided

• • function for each of them
• */

+void xen_comm_foreach_rx_ring(void (*func)(int domid));

+#endif // __HYPER_DMABUF_XEN_COMM_LIST_H__ diff --git a/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.c b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.c new file mode 100644 index 000000000000..8122dc15b4cb --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.c @@ -0,0 +1,46 @@ +/*

• • Copyright © 2018 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• • Authors:
• • Dongwon Kim dongwon.kim@intel.com
• • Mateusz Polrola mateuszx.potrola@intel.com
• */

+#include "../../hyper_dmabuf_drv.h" +#include "hyper_dmabuf_xen_comm.h" +#include "hyper_dmabuf_xen_shm.h"

+struct hyper_dmabuf_bknd_ops xen_bknd_ops = {

• .init = NULL, /* not needed for xen */
• .cleanup = NULL, /* not needed for xen */
• .get_vm_id = xen_be_get_domid,
• .share_pages = xen_be_share_pages,
• .unshare_pages = xen_be_unshare_pages,
• .map_shared_pages = (void *)xen_be_map_shared_pages,
• .unmap_shared_pages = xen_be_unmap_shared_pages,
• .init_comm_env = xen_be_init_comm_env,
• .destroy_comm = xen_be_destroy_comm,
• .init_rx_ch = xen_be_init_rx_rbuf,
• .init_tx_ch = xen_be_init_tx_rbuf,
• .send_req = xen_be_send_req,

+}; diff --git a/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.h b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.h new file mode 100644 index 000000000000..c97dc1c5d042 --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_drv.h @@ -0,0 +1,53 @@ +/*

• • Copyright © 2018 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• */

+#ifndef __HYPER_DMABUF_XEN_DRV_H__ +#define __HYPER_DMABUF_XEN_DRV_H__ +#include <xen/interface/grant_table.h>

+extern struct hyper_dmabuf_bknd_ops xen_bknd_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 {

• /* top level refid */
• grant_ref_t lvl3_gref;
• /* page of top level addressing, it contains refids of 2nd lvl pages */
• grant_ref_t *lvl3_table;
• /* table of 2nd level pages, that contains refids to data pages */
• grant_ref_t *lvl2_table;
• /* unmap ops for mapped pages */
• struct gnttab_unmap_grant_ref *unmap_ops;
• /* data pages to be unmapped */
• struct page **data_pages;

+};

+#endif // __HYPER_DMABUF_XEN_COMM_H__ diff --git a/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.c b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.c new file mode 100644 index 000000000000..b2dcef34e10f --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.c @@ -0,0 +1,525 @@ +/*

• • Copyright © 2018 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• • Authors:
• • Dongwon Kim dongwon.kim@intel.com
• • Mateusz Polrola mateuszx.potrola@intel.com
• */

+#include <linux/slab.h> +#include <xen/grant_table.h> +#include <asm/xen/page.h> +#include "hyper_dmabuf_xen_drv.h" +#include "../../hyper_dmabuf_drv.h"

+#define REFS_PER_PAGE (PAGE_SIZE/sizeof(grant_ref_t))

+/*

• • 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|
    

• •                             +-----------------------+
    

• • 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.
• */

This seems to be over-engineered, IMO

+int xen_be_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);
• if (!sh_pages_info)

• return -ENOMEM;
  

• *refs_info = (void *)sh_pages_info;
• /* share data pages in readonly mode for security */
• for (i = 0; i < nents; i++) {

• lvl2_table[i] = gnttab_grant_foreign_access(domid,
  

• 			pfn_to_mfn(page_to_pfn(pages[i])),
  

• 			true /* read only */);
  

• if (lvl2_table[i] == -ENOSPC) {
  

• 	dev_err(hy_drv_priv->dev,
  

• 		"No more space left in grant table\n");
  

• 	/* Unshare all already shared pages for lvl2 */
  

• 	while (i--) {
  

• 		gnttab_end_foreign_access_ref(lvl2_table[i], 0);
  

• 		gnttab_free_grant_reference(lvl2_table[i]);
  

• 	}
  

• 	goto err_cleanup;
  

• }
  

• }
• /* Share 2nd level addressing pages in readonly mode*/
• for (i = 0; i < n_lvl2_grefs; i++) {

• lvl3_table[i] = gnttab_grant_foreign_access(domid,
  

• 			virt_to_mfn(
  

• 			(unsigned long)lvl2_table+i*PAGE_SIZE),
  

• 			true);
  

• if (lvl3_table[i] == -ENOSPC) {
  

• 	dev_err(hy_drv_priv->dev,
  

• 		"No more space left in grant table\n");
  

• 	/* Unshare all already shared pages for lvl3 */
  

• 	while (i--) {
  

• 		gnttab_end_foreign_access_ref(lvl3_table[i], 1);
  

• 		gnttab_free_grant_reference(lvl3_table[i]);
  

• 	}
  

• 	/* Unshare all pages for lvl2 */
  

• 	while (nents--) {
  

• 		gnttab_end_foreign_access_ref(
  

• 					lvl2_table[nents], 0);
  

• 		gnttab_free_grant_reference(lvl2_table[nents]);
  

• 	}
  

• 	goto err_cleanup;
  

• }
  

• }
• /* Share lvl3_table in readonly mode*/
• lvl3_gref = gnttab_grant_foreign_access(domid,

• 	virt_to_mfn((unsigned long)lvl3_table),
  

• 	true);
  

• if (lvl3_gref == -ENOSPC) {

• dev_err(hy_drv_priv->dev,
  

• 	"No more space left in grant table\n");
  

• /* Unshare all pages for lvl3 */
  

• while (i--) {
  

• 	gnttab_end_foreign_access_ref(lvl3_table[i], 1);
  

• 	gnttab_free_grant_reference(lvl3_table[i]);
  

• }
  

• /* Unshare all pages for lvl2 */
  

• while (nents--) {
  

• 	gnttab_end_foreign_access_ref(lvl2_table[nents], 0);
  

• 	gnttab_free_grant_reference(lvl2_table[nents]);
  

• }
  

• goto err_cleanup;
  

• }
• /* 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;
• dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
• return lvl3_gref;

+err_cleanup:

• free_pages((unsigned long)lvl2_table, n_lvl2_grefs);
• free_pages((unsigned long)lvl3_table, 1);
• return -ENOSPC;

+}

+int xen_be_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;
• dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
• sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
• if (sh_pages_info->lvl3_table == NULL ||

•    sh_pages_info->lvl2_table ==  NULL ||
  

•    sh_pages_info->lvl3_gref == -1) {
  

• dev_warn(hy_drv_priv->dev,
  

• 	 "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]))
  

• 	dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
  

• gnttab_end_foreign_access_ref(sh_pages_info->lvl2_table[i], 0);
  

• gnttab_free_grant_reference(sh_pages_info->lvl2_table[i]);
  

• }
• /* End foreign access for 2nd level addressing pages */
• for (i = 0; i < n_lvl2_grefs; i++) {

• if (gnttab_query_foreign_access(sh_pages_info->lvl3_table[i]))
  

• 	dev_warn(hy_drv_priv->dev, "refid not shared !!\n");
  

• if (!gnttab_end_foreign_access_ref(
  

• 			sh_pages_info->lvl3_table[i], 1))
  

• 	dev_warn(hy_drv_priv->dev, "refid still in use!!!\n");
  

• gnttab_free_grant_reference(sh_pages_info->lvl3_table[i]);
  

• }
• /* End foreign access for top level addressing page */
• if (gnttab_query_foreign_access(sh_pages_info->lvl3_gref))

• dev_warn(hy_drv_priv->dev, "gref not shared !!\n");
  

• gnttab_end_foreign_access_ref(sh_pages_info->lvl3_gref, 1);
• gnttab_free_grant_reference(sh_pages_info->lvl3_gref);
• /* 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;
• dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
• return 0;

+}

+/* Maps provided top level ref id and then return array of pages

• • containing data refs.
• */

+struct page **xen_be_map_shared_pages(unsigned long 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;
• /* # of grefs in the last page of lvl2 table */
• int nents_last = (nents - 1) % REFS_PER_PAGE + 1;
• int n_lvl2_grefs = (nents / REFS_PER_PAGE) +

• 	   ((nents_last > 0) ? 1 : 0) -
  

• 	   (nents_last == REFS_PER_PAGE);
  

• int i, j, k;
• dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
• sh_pages_info = kmalloc(sizeof(*sh_pages_info), GFP_KERNEL);
• *refs_info = (void *) sh_pages_info;
• lvl2_table_pages = kcalloc(n_lvl2_grefs, sizeof(struct page *),

• 		   GFP_KERNEL);
  

• data_pages = kcalloc(nents, sizeof(struct page *), GFP_KERNEL);
• lvl2_map_ops = kcalloc(n_lvl2_grefs, sizeof(*lvl2_map_ops),

• 	       GFP_KERNEL);
  

• lvl2_unmap_ops = kcalloc(n_lvl2_grefs, sizeof(*lvl2_unmap_ops),

• 		 GFP_KERNEL);
  

• data_map_ops = kcalloc(nents, sizeof(*data_map_ops), GFP_KERNEL);
• data_unmap_ops = kcalloc(nents, sizeof(*data_unmap_ops), GFP_KERNEL);
• /* Map top level addressing page */
• if (gnttab_alloc_pages(1, &lvl3_table_page)) {

• dev_err(hy_drv_priv->dev, "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)) {

• dev_err(hy_drv_priv->dev,
  

• 	"HYPERVISOR map grant ref failed");
  

• return NULL;
  

• }
• if (lvl3_map_ops.status) {

• dev_err(hy_drv_priv->dev,
  

• 	"HYPERVISOR map grant ref failed status = %d",
  

• 	lvl3_map_ops.status);
  

• goto error_cleanup_lvl3;
  

• } else {

• lvl3_unmap_ops.handle = lvl3_map_ops.handle;
  

• }
• /* Map all second level pages */
• if (gnttab_alloc_pages(n_lvl2_grefs, lvl2_table_pages)) {

• dev_err(hy_drv_priv->dev, "Cannot allocate pages\n");
  

• goto error_cleanup_lvl3;
  

• }
• for (i = 0; i < n_lvl2_grefs; i++) {

• lvl2_table = (grant_ref_t *)pfn_to_kaddr(
  

• 			page_to_pfn(lvl2_table_pages[i]));
  

• gnttab_set_map_op(&lvl2_map_ops[i],
  

• 		  (unsigned long)lvl2_table, GNTMAP_host_map |
  

• 		  GNTMAP_readonly,
  

• 		  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)) {
  

• dev_err(hy_drv_priv->dev,
  

• 	"xen: cannot unmap top level page\n");
  

• return NULL;
  

• }
• /* Mark that page was unmapped */
• lvl3_unmap_ops.handle = -1;
• if (gnttab_map_refs(lvl2_map_ops, NULL,

• 	    lvl2_table_pages, n_lvl2_grefs)) {
  

• dev_err(hy_drv_priv->dev,
  

• 	"HYPERVISOR map grant ref failed");
  

• return NULL;
  

• }
• /* Checks if pages were mapped correctly */
• for (i = 0; i < n_lvl2_grefs; i++) {

• if (lvl2_map_ops[i].status) {
  

• 	dev_err(hy_drv_priv->dev,
  

• 		"HYPERVISOR map grant ref failed status = %d",
  

• 		lvl2_map_ops[i].status);
  

• 	goto error_cleanup_lvl2;
  

• } else {
  

• 	lvl2_unmap_ops[i].handle = lvl2_map_ops[i].handle;
  

• }
  

• }
• if (gnttab_alloc_pages(nents, data_pages)) {

• dev_err(hy_drv_priv->dev,
  

• 	"Cannot allocate pages\n");
  

• goto error_cleanup_lvl2;
  

• }
• k = 0;
• for (i = 0; i < n_lvl2_grefs - 1; 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 | GNTMAP_readonly,
  

• 		lvl2_table[j], domid);
  

• 	gnttab_set_unmap_op(&data_unmap_ops[k],
  

• 		(unsigned long)pfn_to_kaddr(
  

• 				page_to_pfn(data_pages[k])),
  

• 		GNTMAP_host_map | GNTMAP_readonly, -1);
  

• 	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 | GNTMAP_readonly,
  

• 	lvl2_table[j], domid);
  

• gnttab_set_unmap_op(&data_unmap_ops[k],
  

• 	(unsigned long)pfn_to_kaddr(page_to_pfn(data_pages[k])),
  

• 	GNTMAP_host_map | GNTMAP_readonly, -1);
  

• k++;
  

• }
• if (gnttab_map_refs(data_map_ops, NULL,

• 	    data_pages, nents)) {
  

• dev_err(hy_drv_priv->dev,
  

• 	"HYPERVISOR map grant ref failed\n");
  

• return NULL;
  

• }
• /* unmapping lvl2 table pages */
• if (gnttab_unmap_refs(lvl2_unmap_ops,

• 	      NULL, lvl2_table_pages,
  

• 	      n_lvl2_grefs)) {
  

• dev_err(hy_drv_priv->dev,
  

• 	"Cannot unmap 2nd level refs\n");
  

• return NULL;
  

• }
• /* Mark that pages were unmapped */
• for (i = 0; i < n_lvl2_grefs; i++)

• lvl2_unmap_ops[i].handle = -1;
  

• for (i = 0; i < nents; i++) {

• if (data_map_ops[i].status) {
  

• 	dev_err(hy_drv_priv->dev,
  

• 		"HYPERVISOR map grant ref failed status = %d\n",
  

• 		data_map_ops[i].status);
  

• 	goto error_cleanup_data;
  

• } 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);
• dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
• return data_pages;

+error_cleanup_data:

• gnttab_unmap_refs(data_unmap_ops, NULL, data_pages,

• 	  nents);
  

• gnttab_free_pages(nents, data_pages);

+error_cleanup_lvl2:

• if (lvl2_unmap_ops[0].handle != -1)

• gnttab_unmap_refs(lvl2_unmap_ops, NULL,
  

• 		  lvl2_table_pages, n_lvl2_grefs);
  

• gnttab_free_pages(n_lvl2_grefs, lvl2_table_pages);

+error_cleanup_lvl3:

• if (lvl3_unmap_ops.handle != -1)

• gnttab_unmap_refs(&lvl3_unmap_ops, NULL,
  

• 		  &lvl3_table_page, 1);
  

• gnttab_free_pages(1, &lvl3_table_page);
• kfree(lvl2_table_pages);
• kfree(lvl2_map_ops);
• kfree(lvl2_unmap_ops);
• kfree(data_map_ops);
• return NULL;

+}

+int xen_be_unmap_shared_pages(void **refs_info, int nents) +{

• struct xen_shared_pages_info *sh_pages_info;
• dev_dbg(hy_drv_priv->dev, "%s entry\n", __func__);
• sh_pages_info = (struct xen_shared_pages_info *)(*refs_info);
• if (sh_pages_info->unmap_ops == NULL ||

•    sh_pages_info->data_pages == NULL) {
  

• dev_warn(hy_drv_priv->dev,
  

• 	 "pages already cleaned up or buffer not imported yet\n");
  

• return 0;
  

• }
• if (gnttab_unmap_refs(sh_pages_info->unmap_ops, NULL,

• 	      sh_pages_info->data_pages, nents)) {
  

• dev_err(hy_drv_priv->dev, "Cannot unmap data pages\n");
  

• return -EFAULT;
  

• }
• 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;
• dev_dbg(hy_drv_priv->dev, "%s exit\n", __func__);
• return 0;

+} diff --git a/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.h b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.h new file mode 100644 index 000000000000..c39f241351f8 --- /dev/null +++ b/drivers/dma-buf/hyper_dmabuf/backends/xen/hyper_dmabuf_xen_shm.h @@ -0,0 +1,46 @@ +/*

• • Copyright © 2018 Intel Corporation
• • Permission is hereby granted, free of charge, to any person obtaining a
• • copy of this software and associated documentation files (the "Software"),
• • to deal in the Software without restriction, including without limitation
• • the rights to use, copy, modify, merge, publish, distribute, sublicense,
• • and/or sell copies of the Software, and to permit persons to whom the
• • Software is furnished to do so, subject to the following conditions:
• • The above copyright notice and this permission notice (including the next
• • paragraph) shall be included in all copies or substantial portions of the
• • Software.
• • THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
• • IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
• • FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
• • THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
• • LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
• • FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
• • IN THE SOFTWARE.
• */

+#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 xen_be_share_pages(struct page **pages, int domid, int nents,

•     void **refs_info);
  

+int xen_be_unshare_pages(void **refs_info, int nents);

+/* Maps provided top level ref id and then return array of pages containing

• • data refs.
• */

+struct page **xen_be_map_shared_pages(unsigned long lvl3_gref, int domid,

• 		      int nents,
  

• 		      void **refs_info);
  

+int xen_be_unmap_shared_pages(void **refs_info, int nents);

+#endif /* __HYPER_DMABUF_XEN_SHM_H__ */ diff --git a/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.c b/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.c index 18c1cd735ea2..3320f9dcc769 100644 --- a/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.c +++ b/drivers/dma-buf/hyper_dmabuf/hyper_dmabuf_drv.c @@ -42,6 +42,10 @@ #include "hyper_dmabuf_list.h" #include "hyper_dmabuf_id.h" +#ifdef CONFIG_HYPER_DMABUF_XEN +#include "backends/xen/hyper_dmabuf_xen_drv.h" +#endif

• MODULE_LICENSE("GPL and additional rights"); MODULE_AUTHOR("Intel Corporation");

@@ -145,7 +149,13 @@ static int __init hyper_dmabuf_drv_init(void) return ret; } +/* currently only supports XEN hypervisor */ +#ifdef CONFIG_HYPER_DMABUF_XEN

• hy_drv_priv->bknd_ops = &xen_bknd_ops;

+#else hy_drv_priv->bknd_ops = NULL;

• pr_err("hyper_dmabuf drv currently supports XEN only.\n");

+#endif if (hy_drv_priv->bknd_ops == NULL) { pr_err("Hyper_dmabuf: no backend found\n");