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