From patchwork Fri Mar 29 00:15:57 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 161375 Delivered-To: patches@linaro.org Received: by 2002:a02:c6d8:0:0:0:0:0 with SMTP id r24csp1367837jan; Thu, 28 Mar 2019 17:16:10 -0700 (PDT) X-Received: by 2002:a63:1410:: with SMTP id u16mr41352770pgl.420.1553818570064; Thu, 28 Mar 2019 17:16:10 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1553818570; cv=none; d=google.com; s=arc-20160816; b=Uz2FelHK8TFh2g/0reXtBlC39mkLNZ8uopm/RXZs1BbW7H9v0OGhaEta9mXypa+TQv 5DIbF+a1j3hYP0hTfO/QsBBkSciUlcHMfYtK9kxgUsPZhyWNjse40Cy9XbbXfIcuFrbC aibaM5FoFj6D/0QNKHBCoq2K3N/i7BexmNKx74s5aDr7wQcpJUE/8sfwAWKIi70qw28K Nkg1qa02SYw//EgegfLxp6w72qcVqz7eppDmyHZlH8ZEIuZv12uZa3O/19EvBpTaFE9+ iJO6/6vppT58DmLCJ/fvtuipDRFUP2Pk638JTC4akUmKoZu9kuWr5Dg+bX0HtUeKWTMa eluA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=ZTwobsrCkifIL37CYr9tU4ZhHRJeSiebBZk0kjuGvSU=; b=YP2oygqRkGqTqU4NPEVwKTUYMfHDb1kHvdV8WjQJ1R0XFx9IqlZMvQaIze7hy4EnR7 p1bqiFeECOx4ArWu2mY3ZRDiv8gMMpSZkOlXSGL7HzburBmWblkBLuHodBZLAYRUxn6B gYBaON6bkasSVWSIa+mfu9o3WMf87OM10XRUyRqcKZQRrLDi2ejxVll360s0/a4+O3Fl 0POHHJSRCrNSF6M6hGqVdKG0DMV4meHb/z26fa6CBiSxyCGiMJgkdXQgVqRBfJEyxfzq 2zK9GO5wWRlXwlzmai56QrEEjyslEeGgh8pBWo/TQvuQQo2Ol7UnDzXwxwHNhHZ7l/Xd 70hQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=fzycxp1x; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id v35sor383891plg.59.2019.03.28.17.16.09 for (Google Transport Security); Thu, 28 Mar 2019 17:16:10 -0700 (PDT) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=fzycxp1x; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=ZTwobsrCkifIL37CYr9tU4ZhHRJeSiebBZk0kjuGvSU=; b=fzycxp1xgCpCxve4fPUMEtArPZpHi50Kj5Y3LJUY4515rXIn9FtKH0xDjhTsOKG6tW N8mYt7DjMBTXzXYn5TUmYIHoZnZpldlr8dE59/9pX8hCeBRxwIIUPMeDWIibkSEnZw9C 1Ijd1ydMVjSvEpEhFuHMdkKQH0tz54cysbsWyBgtKt2Uzlc+KtRV5LLUKyrfwqKY2xLG SKKiktdpOxJMGAl48frnlWjsR0cOYv9DWPbGlFyL0JHPIn2HkGyKvSx4+C6Z9E2Afwc/ ow0dSbeO5P84sC2QzJeTokkn3UzenJYKFGBQdKQBYBR1XbR3eMFRoTom9GrwPF1ePDqY 6xiA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=ZTwobsrCkifIL37CYr9tU4ZhHRJeSiebBZk0kjuGvSU=; b=fRfMcPLCJDNGoh/WT7/RG3uGMw/1AjI8WwfWSWlpj2Waqqo0zL3owMgHxcQMtK9ONe 8C9eED5tEf2iwXdNeEQ2hsuvELKh4Cg/qrw1w9sEGr+Ovw7XDa5zCsKZtzixqlrzpbEn VkZzm90r3c58MJCVMAXUzBJMWD0WPWyI8S+RuEd3fsm3YLMdXiBKUrpYfbvphSJX4SeB sf3QtW8ZVcWLjzZbaC5dFkLzeckIFqHQ3vA/SeXsdMmVH3ffuacfVzs9Vrv+P3FFcS+C CFlZrBQHMS2hJFIJr7bRdNyHA7YFwGfS7fgOef3T0fFCqJsE6k4JFzN/UkpSVf7c2DlL eQZg== X-Gm-Message-State: APjAAAVbe/KO06NxQvs5N4cX0SJd37fMUPfDnS5f5jEfFhaOWE+OaiHa lUDjVQ7LNuJQ+8Q4gulptf/CNzHe X-Google-Smtp-Source: APXvYqzDzG7OQoCy0iu6hcbcV7O8RRSGUx9Nm8KWHabkMJQjKB/6/ztSCxVsS3SW4tYIrudHOZ0wAQ== X-Received: by 2002:a17:902:2ec1:: with SMTP id r59mr45172143plb.171.1553818569441; Thu, 28 Mar 2019 17:16:09 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id g5sm430137pfo.53.2019.03.28.17.16.06 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 28 Mar 2019 17:16:07 -0700 (PDT) From: John Stultz To: lkml Cc: "Andrew F. Davis" , Laura Abbott , Benjamin Gaignard , Sumit Semwal , Liam Mark , Pratik Patel , Brian Starkey , Vincent Donnefort , Sudipto Paul , Xu YiPing , "Chenfeng (puck)" , butao , "Xiaqing (A)" , Yudongbin , Christoph Hellwig , Chenbo Feng , Alistair Strachan , dri-devel@lists.freedesktop.org, John Stultz Subject: [RFC][PATCH 1/6 v3] dma-buf: Add dma-buf heaps framework Date: Thu, 28 Mar 2019 17:15:57 -0700 Message-Id: <1553818562-2516-2-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> References: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> From: "Andrew F. Davis" This framework allows a unified userspace interface for dma-buf exporters, allowing userland to allocate specific types of memory for use in dma-buf sharing. Each heap is given its own device node, which a user can allocate a dma-buf fd from using the DMA_HEAP_IOC_ALLOC. This code is an evoluiton of the Android ION implementation, and a big thanks is due to its authors/maintainers over time for their effort: Rebecca Schultz Zavin, Colin Cross, Benjamin Gaignard, Laura Abbott, and many other contributors! Cc: Laura Abbott Cc: Benjamin Gaignard Cc: Sumit Semwal Cc: Liam Mark Cc: Pratik Patel Cc: Brian Starkey Cc: Vincent Donnefort Cc: Sudipto Paul Cc: Andrew F. Davis Cc: Xu YiPing Cc: "Chenfeng (puck)" Cc: butao Cc: "Xiaqing (A)" Cc: Yudongbin Cc: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: dri-devel@lists.freedesktop.org Signed-off-by: Andrew F. Davis Signed-off-by: John Stultz --- v2: * Folded down fixes I had previously shared in implementing heaps * Make flags a u64 (Suggested by Laura) * Add PAGE_ALIGN() fix to the core alloc funciton * IOCTL fixups suggested by Brian * Added fixes suggested by Benjamin * Removed core stats mgmt, as that should be implemented by per-heap code * Changed alloc to return a dma-buf fd, rather then a buffer (as it simplifies error handling) v3: * Removed scare-quotes in MAINTAINERS email address * Get rid of .release function as it didn't do anything (from Christoph) * Renamed filp to file (suggested by Christoph) * Split out ioctl handling to separate function (suggested by Christoph) * Add comment documenting PAGE_ALIGN usage (suggested by Brian) * Switch from idr to Xarray (suggested by Brian) * Fixup cdev creation (suggested by Brian) * Avoid EXPORT_SYMBOL until we finalize modules (suggested by Brian) * Make struct dma_heap internal only (folded in from Andrew) * Small cleanups suggested by GregKH * Provide class->devnode callback to get consistent /dev/ subdirectory naming (Suggested by Bjorn) --- MAINTAINERS | 18 ++++ drivers/dma-buf/Kconfig | 8 ++ drivers/dma-buf/Makefile | 1 + drivers/dma-buf/dma-heap.c | 234 ++++++++++++++++++++++++++++++++++++++++++ include/linux/dma-heap.h | 70 +++++++++++++ include/uapi/linux/dma-heap.h | 52 ++++++++++ 6 files changed, 383 insertions(+) create mode 100644 drivers/dma-buf/dma-heap.c create mode 100644 include/linux/dma-heap.h create mode 100644 include/uapi/linux/dma-heap.h -- 2.7.4 diff --git a/MAINTAINERS b/MAINTAINERS index c0057dd..cd9c495 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4719,6 +4719,24 @@ F: include/linux/*fence.h F: Documentation/driver-api/dma-buf.rst T: git git://anongit.freedesktop.org/drm/drm-misc +DMA-BUF HEAPS FRAMEWORK +M: Sumit Semwal +R: Andrew F. Davis +R: Benjamin Gaignard +R: Liam Mark +R: Laura Abbott +R: Brian Starkey +R: John Stultz +S: Maintained +L: linux-media@vger.kernel.org +L: dri-devel@lists.freedesktop.org +L: linaro-mm-sig@lists.linaro.org (moderated for non-subscribers) +F: include/uapi/linux/dma-heap.h +F: include/linux/dma-heap.h +F: drivers/dma-buf/dma-heap.c +F: drivers/dma-buf/heaps/* +T: git git://anongit.freedesktop.org/drm/drm-misc + DMA GENERIC OFFLOAD ENGINE SUBSYSTEM M: Vinod Koul L: dmaengine@vger.kernel.org diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig index 2e5a0fa..09c61db 100644 --- a/drivers/dma-buf/Kconfig +++ b/drivers/dma-buf/Kconfig @@ -39,4 +39,12 @@ config UDMABUF A driver to let userspace turn memfd regions into dma-bufs. Qemu can use this to create host dmabufs for guest framebuffers. +menuconfig DMABUF_HEAPS + bool "DMA-BUF Userland Memory Heaps" + select DMA_SHARED_BUFFER + help + Choose this option to enable the DMA-BUF userland memory heaps, + this allows userspace to allocate dma-bufs that can be shared between + drivers. + endmenu diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index 0913a6c..b0332f1 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -1,4 +1,5 @@ obj-y := dma-buf.o dma-fence.o dma-fence-array.o reservation.o seqno-fence.o +obj-$(CONFIG_DMABUF_HEAPS) += dma-heap.o obj-$(CONFIG_SYNC_FILE) += sync_file.o obj-$(CONFIG_SW_SYNC) += sw_sync.o sync_debug.o obj-$(CONFIG_UDMABUF) += udmabuf.o diff --git a/drivers/dma-buf/dma-heap.c b/drivers/dma-buf/dma-heap.c new file mode 100644 index 0000000..b52959e --- /dev/null +++ b/drivers/dma-buf/dma-heap.c @@ -0,0 +1,234 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Framework for userspace DMA-BUF allocations + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define DEVNAME "dma_heap" + +#define NUM_HEAP_MINORS 128 + +/** + * struct dma_heap - represents a dmabuf heap in the system + * @name: used for debugging/device-node name + * @ops: ops struct for this heap + * @minor minor number of this heap device + * @heap_devt heap device node + * @heap_cdev heap char device + * + * Represents a heap of memory from which buffers can be made. + */ +struct dma_heap { + const char *name; + struct dma_heap_ops *ops; + void *priv; + unsigned int minor; + dev_t heap_devt; + struct cdev heap_cdev; +}; + +static dev_t dma_heap_devt; +static struct class *dma_heap_class; +static DEFINE_XARRAY_ALLOC(dma_heap_minors); + +static int dma_heap_buffer_alloc(struct dma_heap *heap, size_t len, + unsigned int flags) +{ + /* + * Allocations from all heaps have to begin + * and end on page boundaries. + */ + len = PAGE_ALIGN(len); + if (!len) + return -EINVAL; + + return heap->ops->allocate(heap, len, flags); +} + +static int dma_heap_open(struct inode *inode, struct file *file) +{ + struct dma_heap *heap; + + heap = xa_load(&dma_heap_minors, iminor(inode)); + if (!heap) { + pr_err("dma_heap: minor %d unknown.\n", iminor(inode)); + return -ENODEV; + } + + /* instance data as context */ + file->private_data = heap; + nonseekable_open(inode, file); + + return 0; +} + +static long dma_heap_ioctl_allocate(struct file *file, unsigned long arg) +{ + struct dma_heap_allocation_data heap_allocation; + struct dma_heap *heap = file->private_data; + int fd; + + if (copy_from_user(&heap_allocation, (void __user *)arg, + sizeof(heap_allocation))) + return -EFAULT; + + if (heap_allocation.fd || + heap_allocation.reserved0 || + heap_allocation.reserved1 || + heap_allocation.reserved2) { + pr_warn_once("dma_heap: ioctl data not valid\n"); + return -EINVAL; + } + + if (heap_allocation.flags & ~DMA_HEAP_VALID_FLAGS) { + pr_warn_once("dma_heap: flags has invalid or unsupported flags set\n"); + return -EINVAL; + } + + fd = dma_heap_buffer_alloc(heap, heap_allocation.len, + heap_allocation.flags); + if (fd < 0) + return fd; + + heap_allocation.fd = fd; + + if (copy_to_user((void __user *)arg, &heap_allocation, + sizeof(heap_allocation))) + return -EFAULT; + + return 0; +} + +static long dma_heap_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + int ret = 0; + + switch (cmd) { + case DMA_HEAP_IOC_ALLOC: + ret = dma_heap_ioctl_allocate(file, arg); + break; + default: + return -ENOTTY; + } + + return ret; +} + +static const struct file_operations dma_heap_fops = { + .owner = THIS_MODULE, + .open = dma_heap_open, + .unlocked_ioctl = dma_heap_ioctl, +}; + +/** + * dma_heap_get_data() - get per-subdriver data for the heap + * @heap: DMA-Heap to retrieve private data for + * + * Returns: + * The per-subdriver data for the heap. + */ +void *dma_heap_get_data(struct dma_heap *heap) +{ + return heap->priv; +} + +struct dma_heap *dma_heap_add(const struct dma_heap_export_info *exp_info) +{ + struct dma_heap *heap; + struct device *dev_ret; + int ret; + + if (!exp_info->name || !strcmp(exp_info->name, "")) { + pr_err("dma_heap: Cannot add heap without a name\n"); + return ERR_PTR(-EINVAL); + } + + if (!exp_info->ops || !exp_info->ops->allocate) { + pr_err("dma_heap: Cannot add heap with invalid ops struct\n"); + return ERR_PTR(-EINVAL); + } + + heap = kzalloc(sizeof(*heap), GFP_KERNEL); + if (!heap) + return ERR_PTR(-ENOMEM); + + heap->name = exp_info->name; + heap->ops = exp_info->ops; + heap->priv = exp_info->priv; + + /* Find unused minor number */ + ret = xa_alloc(&dma_heap_minors, &heap->minor, heap, + XA_LIMIT(0, NUM_HEAP_MINORS - 1), GFP_KERNEL); + if (ret < 0) { + pr_err("dma_heap: Unable to get minor number for heap\n"); + return ERR_PTR(ret); + } + + /* Create device */ + heap->heap_devt = MKDEV(MAJOR(dma_heap_devt), heap->minor); + + cdev_init(&heap->heap_cdev, &dma_heap_fops); + ret = cdev_add(&heap->heap_cdev, heap->heap_devt, 1); + if (ret < 0) { + pr_err("dma_heap: Unable to add char device\n"); + return ERR_PTR(ret); + } + + /* + * TODO: Need to filter "name" to make + * sure we don't add something crazy + */ + dev_ret = device_create(dma_heap_class, + NULL, + heap->heap_devt, + NULL, + heap->name); + if (IS_ERR(dev_ret)) { + pr_err("dma_heap: Unable to create device\n"); + cdev_del(&heap->heap_cdev); + return (struct dma_heap *)dev_ret; + } + + return heap; +} + +static char *dma_heap_devnode(struct device *dev, umode_t *mode) +{ + return kasprintf(GFP_KERNEL, "dma_heap/%s", dev_name(dev)); +} + + +static int dma_heap_init(void) +{ + int ret; + + ret = alloc_chrdev_region(&dma_heap_devt, 0, NUM_HEAP_MINORS, DEVNAME); + if (ret) + return ret; + + dma_heap_class = class_create(THIS_MODULE, DEVNAME); + if (IS_ERR(dma_heap_class)) { + unregister_chrdev_region(dma_heap_devt, NUM_HEAP_MINORS); + return PTR_ERR(dma_heap_class); + } + dma_heap_class->devnode = dma_heap_devnode; + + return 0; +} +subsys_initcall(dma_heap_init); diff --git a/include/linux/dma-heap.h b/include/linux/dma-heap.h new file mode 100644 index 0000000..d7bf624 --- /dev/null +++ b/include/linux/dma-heap.h @@ -0,0 +1,70 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * DMABUF Heaps Allocation Infrastructure + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ + +#ifndef _DMA_HEAPS_H +#define _DMA_HEAPS_H + +#include +#include + +/** + * struct dma_heap_buffer - metadata for a particular buffer + * @heap: back pointer to the heap the buffer came from + * @dmabuf: backing dma-buf for this buffer + * @size: size of the buffer + * @flags: buffer specific flags + */ +struct dma_heap_buffer { + struct dma_heap *heap; + struct dma_buf *dmabuf; + size_t size; + unsigned long flags; +}; + +/** + * struct dma_heap_ops - ops to operate on a given heap + * @allocate: allocate dmabuf and return fd + * + * allocate returns dmabuf fd on success, -errno on error. + */ +struct dma_heap_ops { + int (*allocate)(struct dma_heap *heap, + unsigned long len, + unsigned long flags); +}; + +/** + * struct dma_heap_export_info - information needed to export a new dmabuf heap + * @name: used for debugging/device-node name + * @ops: ops struct for this heap + * @priv: heap exporter private data + * + * Information needed to export a new dmabuf heap. + */ +struct dma_heap_export_info { + const char *name; + struct dma_heap_ops *ops; + void *priv; +}; + +/** + * dma_heap_get_data() - get per-heap driver data + * @heap: DMA-Heap to retrieve private data for + * + * Returns: + * The per-heap data for the heap. + */ +void *dma_heap_get_data(struct dma_heap *heap); + +/** + * dma_heap_add - adds a heap to dmabuf heaps + * @exp_info: information needed to register this heap + */ +struct dma_heap *dma_heap_add(const struct dma_heap_export_info *exp_info); + +#endif /* _DMA_HEAPS_H */ diff --git a/include/uapi/linux/dma-heap.h b/include/uapi/linux/dma-heap.h new file mode 100644 index 0000000..0869811 --- /dev/null +++ b/include/uapi/linux/dma-heap.h @@ -0,0 +1,52 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* + * DMABUF Heaps Userspace API + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ +#ifndef _UAPI_LINUX_DMABUF_POOL_H +#define _UAPI_LINUX_DMABUF_POOL_H + +#include +#include + +/** + * DOC: DMABUF Heaps Userspace API + * + */ + +/* Currently no flags */ +#define DMA_HEAP_VALID_FLAGS (0) + +/** + * struct dma_heap_allocation_data - metadata passed from userspace for + * allocations + * @len: size of the allocation + * @flags: flags passed to pool + * @fd: will be populated with a fd which provdes the + * handle to the allocated dma-buf + * + * Provided by userspace as an argument to the ioctl + */ +struct dma_heap_allocation_data { + __u64 len; + __u64 flags; + __u32 fd; + __u32 reserved0; + __u32 reserved1; + __u32 reserved2; +}; + +#define DMA_HEAP_IOC_MAGIC 'H' + +/** + * DOC: DMA_HEAP_IOC_ALLOC - allocate memory from pool + * + * Takes an dma_heap_allocation_data struct and returns it with the fd field + * populated with the dmabuf handle of the allocation. + */ +#define DMA_HEAP_IOC_ALLOC _IOWR(DMA_HEAP_IOC_MAGIC, 0, \ + struct dma_heap_allocation_data) + +#endif /* _UAPI_LINUX_DMABUF_POOL_H */ From patchwork Fri Mar 29 00:15:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 161376 Delivered-To: patches@linaro.org Received: by 2002:a02:c6d8:0:0:0:0:0 with SMTP id r24csp1367870jan; Thu, 28 Mar 2019 17:16:12 -0700 (PDT) X-Received: by 2002:a63:c505:: with SMTP id f5mr39475200pgd.87.1553818572078; Thu, 28 Mar 2019 17:16:12 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1553818572; cv=none; d=google.com; s=arc-20160816; b=guLCs+phqGxutqXJFkpIDv49dcKA6yFJzf1BmWazH0MWsUhyw7jMQ05OQPplkt89E/ F08jNm39HGxuTtwpL65+3y83sWPKdzN8TgyCtT1JlLNq+LZtsn0SDEITub0V8C84CWJZ cTLWjxmE/C26pwpJW+nMayh3AE/032YSfdWypJS1NkoOvYOyEFk++wJr3yliSPMCHbRu TbeteV7IMKIHppCaVNVae9KFEthGiJA/+ko/WzXNxD2ZfBHV4+ClJ8w6v/aoVxDGlaHI 16AUEyJNloev19V8qd12HyjidrncI5tSSZ4h3Vz1ZstzSLQqoYafCHZ6uFBYU6WAUsKo d5+g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=vwodaJTJWlbuGUAF2VeBM228M5NhuAHeyTl9jv0943k=; b=PJBOt+NOhT/3PpGXwZoBh999ln/FEAUtWXG2QHOkEMymbU0/H8lsKtrfPo+Ojb4Zy9 lfvFf50zI1CAjh7iKS0nwG+n2tRQ3tTBZLhmrW/gIVNVeXU/4PObFyssDIhGLlofNWmu hC/bAAEUm7kUQBvA4d91rR4S/g7e3+lfwxGkoF48SPJnFYcfXwWWUQ70vx3cQ6kpr/vd qJzbIr3zgtqi5sh+fjiIo9coTgSufjkvkmcR2v5H/QT5tcVRWMwmJHzbRI+ZfB/3EHyV uaG74auZFxKDvPvdfvb76nP896CB6Zt+Yoc18dQoSssePpnd+dA06M4TCeKa2808oi5N hyCQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=xN5taMHI; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id i10sor427627plb.6.2019.03.28.17.16.12 for (Google Transport Security); Thu, 28 Mar 2019 17:16:12 -0700 (PDT) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=xN5taMHI; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=vwodaJTJWlbuGUAF2VeBM228M5NhuAHeyTl9jv0943k=; b=xN5taMHI98Vsc9kfh06Kh2e6xkrhHPT9+ZxUXXO/+cTLw9ZdSoBXVTiwI38c2wbqcY LJCsJenbfA1LRLjE7uMjbh05pvKPAr7leMzn75pjMSR1SJd5sczAPmTNaIGB6M/660eO XVJKgph3aOXPEL/eBlT95mNTR+lrCGvcK92X1dBv/IiNZh5762ceD7HCXdeK+rT0ir5+ +aN535qbmtfwLE/+Ob1lnC3q62onuswUesmc+enXaarXMEKTPqJ6bS0RvWV5Oxy4tpkW DtNqPq4Mg1k071VzD6vj7W8gMr5/oNK+NjBFYFFmIcrSYZVYbM0HivMJ4w9fzInMMbko zl0Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=vwodaJTJWlbuGUAF2VeBM228M5NhuAHeyTl9jv0943k=; b=TA9z9ZXbTpu5SdvOLUONHYdigjmprBmlys7UPpRc7sYFmqy/YkPk9VnR/neLBjoLTA H85f+yCbu/kHGO8kUbmPhVGjfWhgZ+8dIYfs1aNI5802h9h17FsOfJRCIM9jQKjxYfWJ D7EjQ2q4lzmUrjGqJF7iFqxkn6Qz34yM7lfzf71RA8H9F+WxACFJRfJ2LmSpOh4cqsXu ysAV1yHM1m0t4hMSmCrgBDlsdGrLhva4eC/XOg6MO/YTL7RKXFKFhirLM2Hpg2D6Q56K F87tDhYF5PKrzVLg7tONO3LqRZSbuAeNM6NXbo5vbKlMlyZ0MfSB3fl9mbBdqMbpVEU7 2LLA== X-Gm-Message-State: APjAAAWHQpKsCQG79gci68Lf6S3bunWsCQ4fx565NTAPbU8PB8o662Sb JfwaJfgIXJ96vnX6kVivRNYscEAG X-Google-Smtp-Source: APXvYqyitdv05XpxO3Dus4I062WatVOte15nSkcGDIszLw/LwRLPouOA+WSqwzx1PXvU5OZ0v7sfYA== X-Received: by 2002:a17:902:20e3:: with SMTP id v32mr45695880plg.213.1553818571625; Thu, 28 Mar 2019 17:16:11 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id g5sm430137pfo.53.2019.03.28.17.16.09 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 28 Mar 2019 17:16:10 -0700 (PDT) From: John Stultz To: lkml Cc: John Stultz , Laura Abbott , Benjamin Gaignard , Sumit Semwal , Liam Mark , Pratik Patel , Brian Starkey , Vincent Donnefort , Sudipto Paul , "Andrew F . Davis" , Xu YiPing , "Chenfeng (puck)" , butao , "Xiaqing (A)" , Yudongbin , Christoph Hellwig , Chenbo Feng , Alistair Strachan , dri-devel@lists.freedesktop.org Subject: [RFC][PATCH 2/6 v3] dma-buf: heaps: Add heap helpers Date: Thu, 28 Mar 2019 17:15:58 -0700 Message-Id: <1553818562-2516-3-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> References: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> Add generic helper dmabuf ops for dma heaps, so we can reduce the amount of duplicative code for the exported dmabufs. This code is an evolution of the Android ION implementation, so thanks to its original authors and maintainters: Rebecca Schultz Zavin, Colin Cross, Laura Abbott, and others! Cc: Laura Abbott Cc: Benjamin Gaignard Cc: Sumit Semwal Cc: Liam Mark Cc: Pratik Patel Cc: Brian Starkey Cc: Vincent Donnefort Cc: Sudipto Paul Cc: Andrew F. Davis Cc: Xu YiPing Cc: "Chenfeng (puck)" Cc: butao Cc: "Xiaqing (A)" Cc: Yudongbin Cc: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz --- v2: * Removed cache management performance hack that I had accidentally folded in. * Removed stats code that was in helpers * Lots of checkpatch cleanups v3: * Uninline INIT_HEAP_HELPER_BUFFER (suggested by Christoph) * Switch to WARN on buffer destroy failure (suggested by Brian) * buffer->kmap_cnt decrementing cleanup (suggested by Christoph) * Extra buffer->vaddr checking in dma_heap_dma_buf_kmap (suggested by Brian) * Switch to_helper_buffer from macro to inline function (suggested by Benjamin) * Rename kmap->vmap (folded in from Andrew) * Use vmap for vmapping - not begin_cpu_access (folded in from Andrew) * Drop kmap for now, as its optional (folded in from Andrew) * Fold dma_heap_map_user into the single caller (foled in from Andrew) * Folded in patch from Andrew to track page list per heap not sglist, which simplifies the tracking logic --- drivers/dma-buf/Makefile | 1 + drivers/dma-buf/heaps/Makefile | 2 + drivers/dma-buf/heaps/heap-helpers.c | 261 +++++++++++++++++++++++++++++++++++ drivers/dma-buf/heaps/heap-helpers.h | 55 ++++++++ include/linux/dma-heap.h | 14 +- 5 files changed, 320 insertions(+), 13 deletions(-) create mode 100644 drivers/dma-buf/heaps/Makefile create mode 100644 drivers/dma-buf/heaps/heap-helpers.c create mode 100644 drivers/dma-buf/heaps/heap-helpers.h -- 2.7.4 diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index b0332f1..09c2f2d 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -1,4 +1,5 @@ obj-y := dma-buf.o dma-fence.o dma-fence-array.o reservation.o seqno-fence.o +obj-$(CONFIG_DMABUF_HEAPS) += heaps/ obj-$(CONFIG_DMABUF_HEAPS) += dma-heap.o obj-$(CONFIG_SYNC_FILE) += sync_file.o obj-$(CONFIG_SW_SYNC) += sw_sync.o sync_debug.o diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile new file mode 100644 index 0000000..de49898 --- /dev/null +++ b/drivers/dma-buf/heaps/Makefile @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: GPL-2.0 +obj-y += heap-helpers.o diff --git a/drivers/dma-buf/heaps/heap-helpers.c b/drivers/dma-buf/heaps/heap-helpers.c new file mode 100644 index 0000000..00cbdbb --- /dev/null +++ b/drivers/dma-buf/heaps/heap-helpers.c @@ -0,0 +1,261 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include +#include +#include +#include +#include + +#include "heap-helpers.h" + +void INIT_HEAP_HELPER_BUFFER(struct heap_helper_buffer *buffer, + void (*free)(struct heap_helper_buffer *)) +{ + buffer->private_flags = 0; + buffer->priv_virt = NULL; + mutex_init(&buffer->lock); + buffer->vmap_cnt = 0; + buffer->vaddr = NULL; + INIT_LIST_HEAD(&buffer->attachments); + buffer->free = free; +} + + +static void *dma_heap_map_kernel(struct heap_helper_buffer *buffer) +{ + void *vaddr; + + vaddr = vmap(buffer->pages, buffer->pagecount, VM_MAP, PAGE_KERNEL); + if (!vaddr) + return ERR_PTR(-ENOMEM); + + return vaddr; +} + +void dma_heap_buffer_destroy(struct dma_heap_buffer *heap_buffer) +{ + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + + if (buffer->vmap_cnt > 0) { + WARN("%s: buffer still mapped in the kernel\n", + __func__); + vunmap(buffer->vaddr); + } + + buffer->free(buffer); +} + +static void *dma_heap_buffer_vmap_get(struct dma_heap_buffer *heap_buffer) +{ + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + void *vaddr; + + if (buffer->vmap_cnt) { + buffer->vmap_cnt++; + return buffer->vaddr; + } + vaddr = dma_heap_map_kernel(buffer); + if (WARN_ONCE(!vaddr, + "heap->ops->map_kernel should return ERR_PTR on error")) + return ERR_PTR(-EINVAL); + if (IS_ERR(vaddr)) + return vaddr; + buffer->vaddr = vaddr; + buffer->vmap_cnt++; + return vaddr; +} + +static void dma_heap_buffer_vmap_put(struct dma_heap_buffer *heap_buffer) +{ + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + + if (!--buffer->vmap_cnt) { + vunmap(buffer->vaddr); + buffer->vaddr = NULL; + } +} + +struct dma_heaps_attachment { + struct device *dev; + struct sg_table table; + struct list_head list; +}; + +static int dma_heap_attach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct dma_heaps_attachment *a; + struct dma_heap_buffer *heap_buffer = dmabuf->priv; + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + int ret; + + a = kzalloc(sizeof(*a), GFP_KERNEL); + if (!a) + return -ENOMEM; + + ret = sg_alloc_table_from_pages(&a->table, buffer->pages, + buffer->pagecount, 0, + buffer->pagecount << PAGE_SHIFT, + GFP_KERNEL); + if (ret) { + kfree(a); + return ret; + } + + a->dev = attachment->dev; + INIT_LIST_HEAD(&a->list); + + attachment->priv = a; + + mutex_lock(&buffer->lock); + list_add(&a->list, &buffer->attachments); + mutex_unlock(&buffer->lock); + + return 0; +} + +static void dma_heap_detatch(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct dma_heaps_attachment *a = attachment->priv; + struct dma_heap_buffer *heap_buffer = dmabuf->priv; + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + + mutex_lock(&buffer->lock); + list_del(&a->list); + mutex_unlock(&buffer->lock); + + sg_free_table(&a->table); + kfree(a); +} + +static struct sg_table *dma_heap_map_dma_buf( + struct dma_buf_attachment *attachment, + enum dma_data_direction direction) +{ + struct dma_heaps_attachment *a = attachment->priv; + struct sg_table *table; + + table = &a->table; + + if (!dma_map_sg(attachment->dev, table->sgl, table->nents, + direction)) + table = ERR_PTR(-ENOMEM); + return table; +} + +static void dma_heap_unmap_dma_buf(struct dma_buf_attachment *attachment, + struct sg_table *table, + enum dma_data_direction direction) +{ + dma_unmap_sg(attachment->dev, table->sgl, table->nents, direction); +} + +static vm_fault_t dma_heap_vm_fault(struct vm_fault *vmf) +{ + struct vm_area_struct *vma = vmf->vma; + struct heap_helper_buffer *buffer = vma->vm_private_data; + + vmf->page = buffer->pages[vmf->pgoff]; + get_page(vmf->page); + + return 0; +} + +static const struct vm_operations_struct dma_heap_vm_ops = { + .fault = dma_heap_vm_fault, +}; + +static int dma_heap_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma) +{ + struct dma_heap_buffer *heap_buffer = dmabuf->priv; + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + + if ((vma->vm_flags & (VM_SHARED | VM_MAYSHARE)) == 0) + return -EINVAL; + + vma->vm_ops = &dma_heap_vm_ops; + vma->vm_private_data = buffer; + + return 0; +} + +static void dma_heap_dma_buf_release(struct dma_buf *dmabuf) +{ + struct dma_heap_buffer *buffer = dmabuf->priv; + + dma_heap_buffer_destroy(buffer); +} + +static int dma_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct dma_heap_buffer *heap_buffer = dmabuf->priv; + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + struct dma_heaps_attachment *a; + int ret = 0; + + mutex_lock(&buffer->lock); + list_for_each_entry(a, &buffer->attachments, list) { + dma_sync_sg_for_cpu(a->dev, a->table.sgl, a->table.nents, + direction); + } + mutex_unlock(&buffer->lock); + + return ret; +} + +static int dma_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct dma_heap_buffer *heap_buffer = dmabuf->priv; + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + struct dma_heaps_attachment *a; + + mutex_lock(&buffer->lock); + list_for_each_entry(a, &buffer->attachments, list) { + dma_sync_sg_for_device(a->dev, a->table.sgl, a->table.nents, + direction); + } + mutex_unlock(&buffer->lock); + + return 0; +} + +void *dma_heap_dma_buf_vmap(struct dma_buf *dmabuf) +{ + struct dma_heap_buffer *heap_buffer = dmabuf->priv; + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + void *vaddr; + + mutex_lock(&buffer->lock); + vaddr = dma_heap_buffer_vmap_get(heap_buffer); + mutex_unlock(&buffer->lock); + + return vaddr; +} + +void dma_heap_dma_buf_vunmap(struct dma_buf *dmabuf, void *vaddr) +{ + struct dma_heap_buffer *heap_buffer = dmabuf->priv; + struct heap_helper_buffer *buffer = to_helper_buffer(heap_buffer); + + mutex_lock(&buffer->lock); + dma_heap_buffer_vmap_put(heap_buffer); + mutex_unlock(&buffer->lock); +} + +const struct dma_buf_ops heap_helper_ops = { + .map_dma_buf = dma_heap_map_dma_buf, + .unmap_dma_buf = dma_heap_unmap_dma_buf, + .mmap = dma_heap_mmap, + .release = dma_heap_dma_buf_release, + .attach = dma_heap_attach, + .detach = dma_heap_detatch, + .begin_cpu_access = dma_heap_dma_buf_begin_cpu_access, + .end_cpu_access = dma_heap_dma_buf_end_cpu_access, + .vmap = dma_heap_dma_buf_vmap, + .vunmap = dma_heap_dma_buf_vunmap, +}; diff --git a/drivers/dma-buf/heaps/heap-helpers.h b/drivers/dma-buf/heaps/heap-helpers.h new file mode 100644 index 0000000..a17502d --- /dev/null +++ b/drivers/dma-buf/heaps/heap-helpers.h @@ -0,0 +1,55 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * DMABUF Heaps helper code + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ + +#ifndef _HEAP_HELPERS_H +#define _HEAP_HELPERS_H + +#include +#include + +/** + * struct dma_heap_buffer - metadata for a particular buffer + * @heap: back pointer to the heap the buffer came from + * @dmabuf: backing dma-buf for this buffer + * @size: size of the buffer + * @flags: buffer specific flags + */ +struct dma_heap_buffer { + struct dma_heap *heap; + struct dma_buf *dmabuf; + size_t size; + unsigned long flags; +}; + +struct heap_helper_buffer { + struct dma_heap_buffer heap_buffer; + + unsigned long private_flags; + void *priv_virt; + struct mutex lock; + int vmap_cnt; + void *vaddr; + pgoff_t pagecount; + struct page **pages; + struct list_head attachments; + + void (*free)(struct heap_helper_buffer *buffer); + +}; + +static inline struct heap_helper_buffer *to_helper_buffer( + struct dma_heap_buffer *h) +{ + return container_of(h, struct heap_helper_buffer, heap_buffer); +} + +void INIT_HEAP_HELPER_BUFFER(struct heap_helper_buffer *buffer, + void (*free)(struct heap_helper_buffer *)); +extern const struct dma_buf_ops heap_helper_ops; + +#endif /* _HEAP_HELPERS_H */ diff --git a/include/linux/dma-heap.h b/include/linux/dma-heap.h index d7bf624..d17b839 100644 --- a/include/linux/dma-heap.h +++ b/include/linux/dma-heap.h @@ -12,19 +12,7 @@ #include #include -/** - * struct dma_heap_buffer - metadata for a particular buffer - * @heap: back pointer to the heap the buffer came from - * @dmabuf: backing dma-buf for this buffer - * @size: size of the buffer - * @flags: buffer specific flags - */ -struct dma_heap_buffer { - struct dma_heap *heap; - struct dma_buf *dmabuf; - size_t size; - unsigned long flags; -}; +struct dma_heap; /** * struct dma_heap_ops - ops to operate on a given heap From patchwork Fri Mar 29 00:15:59 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 161377 Delivered-To: patches@linaro.org Received: by 2002:a02:c6d8:0:0:0:0:0 with SMTP id r24csp1367892jan; Thu, 28 Mar 2019 17:16:14 -0700 (PDT) X-Received: by 2002:a17:902:1e6:: with SMTP id b93mr45628993plb.325.1553818574056; Thu, 28 Mar 2019 17:16:14 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1553818574; cv=none; d=google.com; s=arc-20160816; b=ZdpA95AJePp7d6hd7CPo3+Q2XdW0kOfEBNcirBeCk1/eeojdPZzIovjxfpkkt47Jx7 6HBawFikfeFjjSBNDN32bnjFi3f3Tst7d8P7tpiFmkAoAxwIufibaM/ykamqlk20CM/H u5Mx+MTNVOpgIBfbSWQeB5/YQAeYjr7YRkDDrng+hEJqOyJIFnM75y8MA0oqPqvhS4Wo EPIs6rTG7Y6J72ztuU9v4PH5s4nOE+mugJrw2ldGpTuinVoZzjodY8lB1d3NQNCL3i2K H4IGVHQMUgv9BJV5lZ7WcNExc8wbiNOS22/9qtX8Izi9BRsERIIw5BHdRZTvRzolOOBn 3pNQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=5ErZHW0xXHQOtHF8GgpwR2Y0iAGiFqBZ9Qw3SJrGI8Y=; b=u4eseJOFTVtiF8y2hsvBOpSBnnxowXRIJLTdkSAJb/qZFWuyIkKN0wx8fgWYjA3WkU Vlk0+oad89DKhffTyEZYdkAi2HsWQJrSi1MMQRkN8/SvMbJuTOLpo1PP4wRxrXhF0DjT Z13sB0BiqO31eSJYWmAoIBXXHqK5ensEXwDEtnqNoAcCQqPLKhs+NoObSR2BvFG+Kejb 5lCUAJv9xpnLdvL1BjtF/sWEfJDs2zPx+6/Zg2l3c64lh8n15bSewVwGhQ8NuMcJkAkY izETllfFVeF6nf601WTAjbMN6GsGuZJMX/n1yhlppQfXuuazw9BHN45y3sT+sD0x8dPm Atdg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=BbA1bYUl; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id y67sor469899pgy.46.2019.03.28.17.16.13 for (Google Transport Security); Thu, 28 Mar 2019 17:16:14 -0700 (PDT) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=BbA1bYUl; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=5ErZHW0xXHQOtHF8GgpwR2Y0iAGiFqBZ9Qw3SJrGI8Y=; b=BbA1bYUleMH6srk+p8AhjUT3zZT5o5NCDatjMmdD99ai86fogk8ueAsFxTXT/C6VbU DPsHf7QyWdNPoo9uJbr8YWf4f8ejXnxtLOAicBLGEG2khUGAFBDfgmBrD2q3sYJfDTL7 KPT/eZhRlqFMSf9eG0/1w8OAFDur9LtQlCrN5lco5BXHPhXFGgQ479Veoif5gTLOOBBC 4k1ElYAtJRuHHwG/77+ASDrCxATOgRjl8sYJzANXVeAmYMvSmDEbl1KDiqFpx751nWTc EQz6525IOlGtSDGtvox54avpS7qMuoDv3/mc9EQKjIisBYa35fD1gnm7Sv/tNLRTkDNX 4Kxw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=5ErZHW0xXHQOtHF8GgpwR2Y0iAGiFqBZ9Qw3SJrGI8Y=; b=ZxtFJ6JsB5FHWjBJ88z5CAw9kzNudSkqiQuwYSTSjKBMOX/UGoo5GHSiIDur4DJ9II /8xGQFrUQNnOrTUyfzd0TxpqfFC7UzNyPY3XLgyRZXN5Dg4q4AxWTtsqjrj99Cvk0bK1 SJCmRK8nFjCiYGLJsM08hR5KcaS3shplHWOES2mU76j0bwAFmULqLzUOpUVWKbzpLi1G PWLvC1X9v9fWRFJna2UqJLtsJjHxAAZlsBty6OVFkiXsUKy6kDSZvpxjmLEUTbz0TJ9s eXJasMXDjD3TO205i441/jsm953D7c6Clc0w0845kFkn0+paJJmDUz81DdlWURFoLuxB GAAg== X-Gm-Message-State: APjAAAXpwHbJESdgXHBSNC97PTDKa5AEdw/vIl3GUCoUU+EgznyUitc2 BxlqHmTkYP5JdjkZ1+006qfdYH2H X-Google-Smtp-Source: APXvYqzpRv45mSiBRK4F8uIHbxMsgJ9NfclX6N6S5IIrui0p7t2w7YqterIiSae09yISN9fiZ3NLag== X-Received: by 2002:a65:4bcc:: with SMTP id p12mr43127793pgr.187.1553818573589; Thu, 28 Mar 2019 17:16:13 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id g5sm430137pfo.53.2019.03.28.17.16.11 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 28 Mar 2019 17:16:12 -0700 (PDT) From: John Stultz To: lkml Cc: John Stultz , Laura Abbott , Benjamin Gaignard , Sumit Semwal , Liam Mark , Pratik Patel , Brian Starkey , Vincent Donnefort , Sudipto Paul , "Andrew F . Davis" , Xu YiPing , "Chenfeng (puck)" , butao , "Xiaqing (A)" , Yudongbin , Christoph Hellwig , Chenbo Feng , Alistair Strachan , dri-devel@lists.freedesktop.org Subject: [RFC][PATCH 3/6 v3] dma-buf: heaps: Add system heap to dmabuf heaps Date: Thu, 28 Mar 2019 17:15:59 -0700 Message-Id: <1553818562-2516-4-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> References: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> This patch adds system heap to the dma-buf heaps framework. This allows applications to get a page-allocator backed dma-buf for non-contiguous memory. This code is an evolution of the Android ION implementation, so thanks to its original authors and maintainters: Rebecca Schultz Zavin, Colin Cross, Laura Abbott, and others! Cc: Laura Abbott Cc: Benjamin Gaignard Cc: Sumit Semwal Cc: Liam Mark Cc: Pratik Patel Cc: Brian Starkey Cc: Vincent Donnefort Cc: Sudipto Paul Cc: Andrew F. Davis Cc: Xu YiPing Cc: "Chenfeng (puck)" Cc: butao Cc: "Xiaqing (A)" Cc: Yudongbin Cc: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: dri-devel@lists.freedesktop.org Reviewed-by: Benjamin Gaignard Signed-off-by: John Stultz --- v2: * Switch allocate to return dmabuf fd * Simplify init code * Checkpatch fixups * Droped dead system-contig code v3: * Whitespace fixups from Benjamin * Make sure we're zeroing the allocated pages (from Liam) * Use PAGE_ALIGN() consistently (suggested by Brian) * Fold in new registration style from Andrew * Avoid needless dynamic allocation of sys_heap (suggested by Christoph) * Minor cleanups * Folded in changes from Andrew to use simplified page list from the heap helpers --- drivers/dma-buf/Kconfig | 2 + drivers/dma-buf/heaps/Kconfig | 6 ++ drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/system_heap.c | 120 ++++++++++++++++++++++++++++++++++++ 4 files changed, 129 insertions(+) create mode 100644 drivers/dma-buf/heaps/Kconfig create mode 100644 drivers/dma-buf/heaps/system_heap.c -- 2.7.4 diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig index 09c61db..63c139d 100644 --- a/drivers/dma-buf/Kconfig +++ b/drivers/dma-buf/Kconfig @@ -47,4 +47,6 @@ menuconfig DMABUF_HEAPS this allows userspace to allocate dma-bufs that can be shared between drivers. +source "drivers/dma-buf/heaps/Kconfig" + endmenu diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig new file mode 100644 index 0000000..2050527 --- /dev/null +++ b/drivers/dma-buf/heaps/Kconfig @@ -0,0 +1,6 @@ +config DMABUF_HEAPS_SYSTEM + bool "DMA-BUF System Heap" + depends on DMABUF_HEAPS + help + Choose this option to enable the system dmabuf heap. The system heap + is backed by pages from the buddy allocator. If in doubt, say Y. diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index de49898..d1808ec 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -1,2 +1,3 @@ # SPDX-License-Identifier: GPL-2.0 obj-y += heap-helpers.o +obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o diff --git a/drivers/dma-buf/heaps/system_heap.c b/drivers/dma-buf/heaps/system_heap.c new file mode 100644 index 0000000..f58ee3f --- /dev/null +++ b/drivers/dma-buf/heaps/system_heap.c @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * DMABUF System heap exporter + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2019 Linaro Ltd. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "heap-helpers.h" + +struct system_heap { + struct dma_heap *heap; +} sys_heap; + +static void system_heap_free(struct heap_helper_buffer *buffer) +{ + pgoff_t pg; + + for (pg = 0; pg < buffer->pagecount; pg++) + __free_page(buffer->pages[pg]); + kfree(buffer->pages); + kfree(buffer); +} + +static int system_heap_allocate(struct dma_heap *heap, + unsigned long len, + unsigned long flags) +{ + struct heap_helper_buffer *helper_buffer; + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + struct dma_buf *dmabuf; + int ret = -ENOMEM; + pgoff_t pg; + + helper_buffer = kzalloc(sizeof(*helper_buffer), GFP_KERNEL); + if (!helper_buffer) + return -ENOMEM; + + INIT_HEAP_HELPER_BUFFER(helper_buffer, system_heap_free); + helper_buffer->heap_buffer.flags = flags; + helper_buffer->heap_buffer.heap = heap; + helper_buffer->heap_buffer.size = len; + + helper_buffer->pagecount = len / PAGE_SIZE; + helper_buffer->pages = kmalloc_array(helper_buffer->pagecount, + sizeof(*helper_buffer->pages), + GFP_KERNEL); + if (!helper_buffer->pages) { + ret = -ENOMEM; + goto err0; + } + + for (pg = 0; pg < helper_buffer->pagecount; pg++) { + helper_buffer->pages[pg] = alloc_page(GFP_KERNEL | __GFP_ZERO); + if (!helper_buffer->pages[pg]) + goto err1; + } + + /* create the dmabuf */ + exp_info.ops = &heap_helper_ops; + exp_info.size = len; + exp_info.flags = O_RDWR; + exp_info.priv = &helper_buffer->heap_buffer; + dmabuf = dma_buf_export(&exp_info); + if (IS_ERR(dmabuf)) { + ret = PTR_ERR(dmabuf); + goto err1; + } + + helper_buffer->heap_buffer.dmabuf = dmabuf; + + ret = dma_buf_fd(dmabuf, O_CLOEXEC); + if (ret < 0) { + dma_buf_put(dmabuf); + /* just return, as put will call release and that will free */ + return ret; + } + + return ret; + +err1: + while (pg > 0) + __free_page(helper_buffer->pages[--pg]); + kfree(helper_buffer->pages); +err0: + kfree(helper_buffer); + + return -ENOMEM; +} + +static struct dma_heap_ops system_heap_ops = { + .allocate = system_heap_allocate, +}; + +static int system_heap_create(void) +{ + struct dma_heap_export_info exp_info; + int ret = 0; + + exp_info.name = "system_heap"; + exp_info.ops = &system_heap_ops; + exp_info.priv = &sys_heap; + + sys_heap.heap = dma_heap_add(&exp_info); + if (IS_ERR(sys_heap.heap)) + ret = PTR_ERR(sys_heap.heap); + + return ret; +} +device_initcall(system_heap_create); From patchwork Fri Mar 29 00:16:00 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 161378 Delivered-To: patches@linaro.org Received: by 2002:a02:c6d8:0:0:0:0:0 with SMTP id r24csp1367913jan; Thu, 28 Mar 2019 17:16:15 -0700 (PDT) X-Received: by 2002:a17:902:8bca:: with SMTP id r10mr35671029plo.67.1553818575626; Thu, 28 Mar 2019 17:16:15 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1553818575; cv=none; d=google.com; s=arc-20160816; b=gvUipa7J1sUDO2AtBDM4pikaHrOrLFomLStzmcTtD63vzo/9jCsS6hun7FqXnBrye4 U6i034OYv1eWccLuYqfMiblUhU08bm6lxlzMfAYRHjO9/NxTYc1iJtmBLrdas1+1bxyP cVXGw8pn9Qr7gaZFH7KHxgq8GAH6MuFQ9z5B62LSB8iK0XKSb2V+v4mrRC0IuJLXBEgj dz1qlftGO4t/JxnJe5z0VO6Fou0zbpw1MpTeHQbJ9707w+9JJ7Oj91ev2liXwQd3MaWi uFMX/Nm6JmQryo3iQv2IHpf0MRRZVci44fNj30WCaaKT6KqVCgXJnm9FjIjggGY71Ugo zy9w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=pOVbcUlIdbhGECLbRdIpPVft1iuShrfaf8uMM9BcdOc=; b=k42mVxUOJI5O1EOOxTQj8d6puYmSNk2oUUJD3WQdVSUIkf74wg+pH10lSORBvEq6W4 MzB8C/cL1/9G43gaEA7xoc1BDSvsFeN3EiirEYHWg7J/uSqaXFIYgd/ZVjJVni5OxkTn nbiPG8qYyWLHnJLHtP0yL77oHbBib8knUe3OJFCjgz9UhxdvHPXgw9eaOj6vr/MgKPv7 EvppDikHUPAz+6ni9BsBWnt2m/RlhRoqvFTIYPAWPjKzDv3PhCP5MRUiy0MZTzcYbxFR nyqxPpzVYbyyIwutvds/1yDZeB0nEvDmX3uIe0LJW3NQGlUdCnDujOfTDkggc2fmdycK 1XVg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=F5JooO6M; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id f15sor465939pgj.56.2019.03.28.17.16.15 for (Google Transport Security); Thu, 28 Mar 2019 17:16:15 -0700 (PDT) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=F5JooO6M; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=pOVbcUlIdbhGECLbRdIpPVft1iuShrfaf8uMM9BcdOc=; b=F5JooO6M8bFSUsRtlTRXRpTknNCyoqWb/q8C8RdqxPLEZNJxkeTpqixA0nuGxopOTR IHeW4UvhrXn25IeB0TbbP5S+9QXC3UDjzy4zfT58zv1SAkkR9yh4O4F5mhfzl7wyKHlD qD7zig8me8NBnIVn2Ev21+VsmcfK3X5j08hlTYo1U5+m4Fg4zbueyCH5jBh+IBmJwkj/ SMWbCWeAftBQl3zWyWAej4x64DWNvZ8jBOQ4DRs2CRyMBvX9X1VN4ZFZAeB89fQas+S/ Xt4OgcExNS99xxDtrSnmI0XHxT9L1HJA7MHnkOx6cyQyOsePAFBue6tLdpXnBEbbyraL Bvrw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=pOVbcUlIdbhGECLbRdIpPVft1iuShrfaf8uMM9BcdOc=; b=dpMtUVXDxi5s3I2CzKMxbCeTxGaWtb/349e/dO3Us3kxYt4G6LKhgDX0kBCCyP0719 l9R6Oy/Ojhbt08AJOerHO6mjK4Yibp+4imey7Wh2srnMsIlMDS/+dItoOXH408O6WUh6 1l/q8SSVeO3ozENLOE5c8sroulC+vEfnEarkeC1z8wD+a1GsDXmL8B75jYil4xUlKMdp 7J2BEMeCPB1l81Xpzg2glCb3O4hs53DZg2TMMjqdIUJtBOO8wqJyXVi6DT5XwIQAjRM/ phVUCxYK3f+QMi/WzCo+sCUzLkDM8UynIlzLWVWT1jCiJPenGSmzMMi/4Cz+q6+X/o96 f2+g== X-Gm-Message-State: APjAAAX9eAbviXoVAG+EhPSE0dtY9GZ/hxNneIHzwAqc3DtCU6DgAw/+ znIl9y1kGB0IJU70sqPZ4PXIG9ht X-Google-Smtp-Source: APXvYqybmM98+7sVUoG8gvrk57ySIN+cjf5t3aBJmUZ+ATvK2vgdHi43Vu2hw9Pz2caBYFbePNzgcg== X-Received: by 2002:a63:5953:: with SMTP id j19mr28121189pgm.260.1553818575190; Thu, 28 Mar 2019 17:16:15 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id g5sm430137pfo.53.2019.03.28.17.16.13 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 28 Mar 2019 17:16:14 -0700 (PDT) From: John Stultz To: lkml Cc: John Stultz , Laura Abbott , Benjamin Gaignard , Sumit Semwal , Liam Mark , Pratik Patel , Brian Starkey , Vincent Donnefort , Sudipto Paul , "Andrew F . Davis" , Xu YiPing , "Chenfeng (puck)" , butao , "Xiaqing (A)" , Yudongbin , Christoph Hellwig , Chenbo Feng , Alistair Strachan , dri-devel@lists.freedesktop.org Subject: [RFC][PATCH 4/6 v3] dma-buf: heaps: Add CMA heap to dmabuf heapss Date: Thu, 28 Mar 2019 17:16:00 -0700 Message-Id: <1553818562-2516-5-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> References: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> This adds a CMA heap, which allows userspace to allocate a dma-buf of contiguous memory out of a CMA region. This code is an evolution of the Android ION implementation, so thanks to its original author and maintainters: Benjamin Gaignard, Laura Abbott, and others! Cc: Laura Abbott Cc: Benjamin Gaignard Cc: Sumit Semwal Cc: Liam Mark Cc: Pratik Patel Cc: Brian Starkey Cc: Vincent Donnefort Cc: Sudipto Paul Cc: Andrew F. Davis Cc: Xu YiPing Cc: "Chenfeng (puck)" Cc: butao Cc: "Xiaqing (A)" Cc: Yudongbin Cc: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz --- v2: * Switch allocate to return dmabuf fd * Simplify init code * Checkpatch fixups v3: * Switch to inline function for to_cma_heap() * Minor cleanups suggested by Brian * Fold in new registration style from Andrew * Folded in changes from Andrew to use simplified page list from the heap helpers --- drivers/dma-buf/heaps/Kconfig | 8 ++ drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/cma_heap.c | 170 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 179 insertions(+) create mode 100644 drivers/dma-buf/heaps/cma_heap.c -- 2.7.4 diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index 2050527..a5eef06 100644 --- a/drivers/dma-buf/heaps/Kconfig +++ b/drivers/dma-buf/heaps/Kconfig @@ -4,3 +4,11 @@ config DMABUF_HEAPS_SYSTEM help Choose this option to enable the system dmabuf heap. The system heap is backed by pages from the buddy allocator. If in doubt, say Y. + +config DMABUF_HEAPS_CMA + bool "DMA-BUF CMA Heap" + depends on DMABUF_HEAPS && DMA_CMA + help + Choose this option to enable dma-buf CMA heap. This heap is backed + by the Contiguous Memory Allocator (CMA). If your system has these + regions, you should say Y here. diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index d1808ec..6e54cde 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -1,3 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 obj-y += heap-helpers.o obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o +obj-$(CONFIG_DMABUF_HEAPS_CMA) += cma_heap.o diff --git a/drivers/dma-buf/heaps/cma_heap.c b/drivers/dma-buf/heaps/cma_heap.c new file mode 100644 index 0000000..f4485c60 --- /dev/null +++ b/drivers/dma-buf/heaps/cma_heap.c @@ -0,0 +1,170 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * DMABUF CMA heap exporter + * + * Copyright (C) 2012, 2019 Linaro Ltd. + * Author: for ST-Ericsson. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "heap-helpers.h" + +struct cma_heap { + struct dma_heap *heap; + struct cma *cma; +}; + +static void cma_heap_free(struct heap_helper_buffer *buffer) +{ + struct cma_heap *cma_heap = dma_heap_get_data(buffer->heap_buffer.heap); + struct page *pages = buffer->priv_virt; + unsigned long nr_pages; + + nr_pages = buffer->heap_buffer.size >> PAGE_SHIFT; + + /* free page list */ + kfree(buffer->pages); + /* release memory */ + cma_release(cma_heap->cma, pages, nr_pages); + kfree(buffer); +} + +/* dmabuf heap CMA operations functions */ +static int cma_heap_allocate(struct dma_heap *heap, + unsigned long len, + unsigned long flags) +{ + struct cma_heap *cma_heap = dma_heap_get_data(heap); + struct heap_helper_buffer *helper_buffer; + struct page *pages; + size_t size = PAGE_ALIGN(len); + unsigned long nr_pages = size >> PAGE_SHIFT; + unsigned long align = get_order(size); + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + struct dma_buf *dmabuf; + int ret = -ENOMEM; + pgoff_t pg; + + if (align > CONFIG_CMA_ALIGNMENT) + align = CONFIG_CMA_ALIGNMENT; + + helper_buffer = kzalloc(sizeof(*helper_buffer), GFP_KERNEL); + if (!helper_buffer) + return -ENOMEM; + + INIT_HEAP_HELPER_BUFFER(helper_buffer, cma_heap_free); + helper_buffer->heap_buffer.flags = flags; + helper_buffer->heap_buffer.heap = heap; + helper_buffer->heap_buffer.size = len; + + pages = cma_alloc(cma_heap->cma, nr_pages, align, false); + if (!pages) + goto free_buf; + + if (PageHighMem(pages)) { + unsigned long nr_clear_pages = nr_pages; + struct page *page = pages; + + while (nr_clear_pages > 0) { + void *vaddr = kmap_atomic(page); + + memset(vaddr, 0, PAGE_SIZE); + kunmap_atomic(vaddr); + page++; + nr_clear_pages--; + } + } else { + memset(page_address(pages), 0, size); + } + + helper_buffer->pagecount = nr_pages; + helper_buffer->pages = kmalloc_array(helper_buffer->pagecount, + sizeof(*helper_buffer->pages), + GFP_KERNEL); + if (!helper_buffer->pages) { + ret = -ENOMEM; + goto free_cma; + } + + for (pg = 0; pg < helper_buffer->pagecount; pg++) { + helper_buffer->pages[pg] = &pages[pg]; + if (!helper_buffer->pages[pg]) + goto free_pages; + } + + /* create the dmabuf */ + exp_info.ops = &heap_helper_ops; + exp_info.size = len; + exp_info.flags = O_RDWR; + exp_info.priv = &helper_buffer->heap_buffer; + dmabuf = dma_buf_export(&exp_info); + if (IS_ERR(dmabuf)) { + ret = PTR_ERR(dmabuf); + goto free_pages; + } + + helper_buffer->heap_buffer.dmabuf = dmabuf; + helper_buffer->priv_virt = pages; + + ret = dma_buf_fd(dmabuf, O_CLOEXEC); + if (ret < 0) { + dma_buf_put(dmabuf); + /* just return, as put will call release and that will free */ + return ret; + } + + return ret; + +free_pages: + kfree(helper_buffer->pages); +free_cma: + cma_release(cma_heap->cma, pages, nr_pages); +free_buf: + kfree(helper_buffer); + return ret; +} + +static struct dma_heap_ops cma_heap_ops = { + .allocate = cma_heap_allocate, +}; + +static int __add_cma_heap(struct cma *cma, void *data) +{ + struct cma_heap *cma_heap; + struct dma_heap_export_info exp_info; + + cma_heap = kzalloc(sizeof(*cma_heap), GFP_KERNEL); + if (!cma_heap) + return -ENOMEM; + cma_heap->cma = cma; + + exp_info.name = cma_get_name(cma); + exp_info.ops = &cma_heap_ops; + exp_info.priv = cma_heap; + + cma_heap->heap = dma_heap_add(&exp_info); + if (IS_ERR(cma_heap->heap)) { + int ret = PTR_ERR(cma_heap->heap); + + kfree(cma_heap); + return ret; + } + + return 0; +} + +static int add_cma_heaps(void) +{ + cma_for_each_area(__add_cma_heap, NULL); + return 0; +} +device_initcall(add_cma_heaps); From patchwork Fri Mar 29 00:16:01 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 161379 Delivered-To: patches@linaro.org Received: by 2002:a02:c6d8:0:0:0:0:0 with SMTP id r24csp1367935jan; Thu, 28 Mar 2019 17:16:17 -0700 (PDT) X-Received: by 2002:aa7:9095:: with SMTP id i21mr21568172pfa.134.1553818577459; Thu, 28 Mar 2019 17:16:17 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1553818577; cv=none; d=google.com; s=arc-20160816; b=pw14pkE6+jHsxGDQPCcDchVzjqt3CCECgyyGUx8Kj10rArJR95s9C81JK2YCzSCBW0 +kB+lefj637Xv6RoJqA9gzTETfsrOXIXi+r0FxHyf9kmQYCTcEqOFrx/g6er1eujwgRF 8Be1fXtaF0iiZfe4/e9WsIbU42rwVVCGFecuqLvvqu/3Dwr1YziiUero8tuEIzzv0AnR Qfq09QtmgjKHK4sXDYEzYaQM7eAv2KeBECwVRnnXueSOPI2h5VdPbjZpTJd2zTTGmJ/m uzN1qTUZw9l68KprIxamRLIV9Pbw5MEv1Hroj0Vb8l+qGjL+3EFUlgNubslrQWgvZnBM O3fA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=viFUhe6LpFGg7/lEQ9FuuvEf+iPLtzynE94Ig2iXdP4=; b=Bq4LkC3Qszcb9Mdh6Q9STcKhf0qz8SqLDF87iI/GXcgIdeWinGxRyFJ9PVRr/7K5xJ XVAJkTJL2rxfTgDqb4pQZI7PrU/8O1zHIictjAyiPSlPUL9PxhDrisC7fHfdy8g66LKS BTsVhgaZt6nEMRh7D9Jxei8feJZHQ8bpmg9WJT3yA8Yqiw6U5ojpgV80QgyjH3yFx6Fc eNek3L9IOgoOaUq/DwZ+IspG5vrHrFGmid68NvM8uksSLJfmhXXmzpnGfwbZT6+Csg9j Pn9gAT12XTA9HYMLPfJ/TaTmKkhr4WPfeXsoKddmq/nXDdQOUBU9qHtPrHYwlj0mmQe3 5k4w== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=jbrWas5H; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id e63sor504102pgc.0.2019.03.28.17.16.17 for (Google Transport Security); Thu, 28 Mar 2019 17:16:17 -0700 (PDT) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=jbrWas5H; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=viFUhe6LpFGg7/lEQ9FuuvEf+iPLtzynE94Ig2iXdP4=; b=jbrWas5HNRqZs34e4EA4kuqSyKUHSirDi13Gj9om1pVr9LulhBpFlTHm3m2vAPuaB9 BqGevEw5yA9mFF8DlnQJzWRQTEfjqTuycA6SHY5tXL0yZOF30uVjMdp9NfCqwiyGXFn3 44XAlFk4ggSs966npkH+B60bxf5itRnAkEkxt3iEe88x8GPILSEwlUvSX4dDcY/u+WsB J7fELthyiePGdt9nH2Xo2SVGnoFPXLP6rDNA1Hvn26TguqrAr5vpCjFVQqynsTjOU9GW ljUOxAmLDWm9NyAyIMti1s0YlLTY4ChDqkrwCNm2Cc3h+1LYyOGGa7D7t9fef7QElkgb I1Vw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=viFUhe6LpFGg7/lEQ9FuuvEf+iPLtzynE94Ig2iXdP4=; b=ZM8mMFc5fUaOFMuVNXXUdSaoQHnDMsX62JmaV5HFY7HFQpjnU6JuBDxbzLlSvHWuZm KBIku06Pn92S8Md5EC/W6OxZTTPph1phw/Yx29oNaA7jKhre2/mkEMiRDSFlnAp052pc GSMpqP4HYs9Wdyv7HKWqg/CQAJ9T3VxgMGQuA4oB31zCyoFBhTsA3St0ZiTEsUgE5p2e 71cJu0qkgjt+5HvAzR/A0CRmHt7eSzhOXBqtmA57m3+fn2rrh+x6W8xmkP1kGILNIG/J 7NeXTNm7KAmjr/meacOLViPCI2aPWGtD3M9FnbvIUeu89vPkUmFNq+K1rNuSwj62pQl1 KQjQ== X-Gm-Message-State: APjAAAVS3cNK0dg1tBZ99yQwBmwcBe3FDz+7n/qsc9Fj/NztY4PoDKVO zc5g9vq3jH6YuaMwsIRpYowU/+LZ X-Google-Smtp-Source: APXvYqz1p/ncf6/URKK0zdV7oDLW/ybTFu36vwYa7Q7TOAlb+vOUiPR//K6om5XDLdeNDejUBIk74g== X-Received: by 2002:a65:5c4b:: with SMTP id v11mr42054499pgr.411.1553818576987; Thu, 28 Mar 2019 17:16:16 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id g5sm430137pfo.53.2019.03.28.17.16.15 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 28 Mar 2019 17:16:16 -0700 (PDT) From: John Stultz To: lkml Cc: "Andrew F. Davis" , Benjamin Gaignard , Sumit Semwal , Liam Mark , Pratik Patel , Brian Starkey , Vincent Donnefort , Sudipto Paul , Xu YiPing , "Chenfeng (puck)" , butao , "Xiaqing (A)" , Yudongbin , Christoph Hellwig , Chenbo Feng , Alistair Strachan , dri-devel@lists.freedesktop.org, John Stultz Subject: [RFC][PATCH 5/6 v3] dma-buf: Add Dummy Importer Test Device Date: Thu, 28 Mar 2019 17:16:01 -0700 Message-Id: <1553818562-2516-6-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> References: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> From: "Andrew F. Davis" This dummy test driver lets us do some very basic testing of importing dma-bufs. It is based originally on TI's out of tree "DMA-BUF physical address user-space exporter" originally by Andrew F. Davis Cc: Benjamin Gaignard Cc: Sumit Semwal Cc: Liam Mark Cc: Pratik Patel Cc: Brian Starkey Cc: Vincent Donnefort Cc: Sudipto Paul Cc: Andrew F. Davis Cc: Xu YiPing Cc: "Chenfeng (puck)" Cc: butao Cc: "Xiaqing (A)" Cc: Yudongbin Cc: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: dri-devel@lists.freedesktop.org Signed-off-by: Andrew F. Davis [Renamed and refactored dma_buf_phys driver, rewote commitlog] Signed-off-by: John Stultz --- drivers/dma-buf/Kconfig | 6 + drivers/dma-buf/Makefile | 1 + drivers/dma-buf/dma-buf-testdev.c | 239 +++++++++++++++++++++++++++++++++++ include/uapi/linux/dma-buf-testdev.h | 37 ++++++ 4 files changed, 283 insertions(+) create mode 100644 drivers/dma-buf/dma-buf-testdev.c create mode 100644 include/uapi/linux/dma-buf-testdev.h -- 2.7.4 diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig index 63c139d..3cbcbe0 100644 --- a/drivers/dma-buf/Kconfig +++ b/drivers/dma-buf/Kconfig @@ -49,4 +49,10 @@ menuconfig DMABUF_HEAPS source "drivers/dma-buf/heaps/Kconfig" +config DMABUF_TESTDEV + bool "DMA-BUF Dummy Test Device" + depends on DMA_SHARED_BUFFER + help + This provides a dummy test device that can be used to test + importing dma-bufs. endmenu diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index 09c2f2d..69bf45d 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -4,3 +4,4 @@ obj-$(CONFIG_DMABUF_HEAPS) += dma-heap.o obj-$(CONFIG_SYNC_FILE) += sync_file.o obj-$(CONFIG_SW_SYNC) += sw_sync.o sync_debug.o obj-$(CONFIG_UDMABUF) += udmabuf.o +obj-$(CONFIG_DMABUF_TESTDEV) += dma-buf-testdev.o diff --git a/drivers/dma-buf/dma-buf-testdev.c b/drivers/dma-buf/dma-buf-testdev.c new file mode 100644 index 0000000..dc3ed93 --- /dev/null +++ b/drivers/dma-buf/dma-buf-testdev.c @@ -0,0 +1,239 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * DMA-BUF Dummy Importer Test Device + * + * Originally from TI DMA BUF contiguous buffer physical address + * user-space exporter + * + * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/ + * Andrew F. Davis + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define DEVICE_NAME "dma-buf-testdev" + +struct dma_buf_testdev_priv { + struct miscdevice miscdev; +}; + +struct dma_buf_testdev_file { + struct device *dev; + struct dma_buf *dma_buf; + struct dma_buf_attachment *attachment; + struct sg_table *sgt; +}; + +static int dma_buf_testdev_open(struct inode *inode, struct file *file) +{ + struct miscdevice *miscdev = file->private_data; + struct device *dev = miscdev->this_device; + struct dma_buf_testdev_file *priv; + + priv = kzalloc(sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + priv->dev = dev; + file->private_data = (void *)priv; + + return 0; +} + +static int dma_buf_testdev_release(struct inode *inode, struct file *file) +{ + struct dma_buf_testdev_file *priv = file->private_data; + + if (priv->attachment && priv->sgt) + dma_buf_unmap_attachment(priv->attachment, priv->sgt, + DMA_BIDIRECTIONAL); + if (priv->dma_buf && priv->attachment) + dma_buf_detach(priv->dma_buf, priv->attachment); + if (priv->dma_buf) + dma_buf_put(priv->dma_buf); + + kfree(priv); + + return 0; +} + +static int dma_buf_testdev_convert(struct dma_buf_testdev_file *priv, int fd, + phys_addr_t *phys) +{ + struct device *dev = priv->dev; + struct dma_buf *dma_buf; + struct dma_buf_attachment *attachment; + struct sg_table *sgt; + dma_addr_t dma_addr; + int ret; + + dma_buf = dma_buf_get(fd); + if (IS_ERR(dma_buf)) + return PTR_ERR(dma_buf); + + /* Attach as the parent device as it will have the correct DMA ops */ + attachment = dma_buf_attach(dma_buf, dev->parent); + if (IS_ERR(attachment)) { + ret = PTR_ERR(attachment); + goto fail_put; + } + + sgt = dma_buf_map_attachment(attachment, DMA_BIDIRECTIONAL); + if (IS_ERR(sgt)) { + ret = PTR_ERR(sgt); + goto fail_detach; + } + + /* Without PAT only physically contiguous buffers can be supported */ + if (sgt->orig_nents != 1) { + dev_err(dev, "DMA-BUF not contiguous\n"); + ret = -EINVAL; + goto fail_unmap; + } + + dma_addr = sg_dma_address(sgt->sgl); + + *phys = dma_addr; + + priv->dma_buf = dma_buf; + priv->attachment = attachment; + priv->sgt = sgt; + + return 0; + +fail_unmap: + dma_buf_unmap_attachment(attachment, sgt, DMA_BIDIRECTIONAL); +fail_detach: + dma_buf_detach(dma_buf, attachment); +fail_put: + dma_buf_put(dma_buf); + + return ret; +} + +static long dma_buf_testdev_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + struct dma_buf_testdev_file *priv = file->private_data; + + switch (cmd) { + case DMA_BUF_TESTDEV_IOC_CONVERT: + { + struct dma_buf_testdev_data data; + int ret; + + /* + * TODO: this should likely be properly serialized, but I + * see no reason this file would ever need to be shared. + */ + /* one attachment per file */ + if (priv->dma_buf) + return -EFAULT; + + if (copy_from_user(&data, (void __user *)arg, _IOC_SIZE(cmd))) + return -EFAULT; + + ret = dma_buf_testdev_convert(priv, data.fd, &data.phys); + if (ret) + return ret; + + if (copy_to_user((void __user *)arg, &data, _IOC_SIZE(cmd))) + return -EFAULT; + + break; + } + default: + return -ENOTTY; + } + + return 0; +} + +static const struct file_operations dma_buf_testdev_fops = { + .owner = THIS_MODULE, + .open = dma_buf_testdev_open, + .release = dma_buf_testdev_release, + .unlocked_ioctl = dma_buf_testdev_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = dma_buf_testdev_ioctl, +#endif +}; + +static int dma_buf_testdev_probe(struct platform_device *pdev) +{ + struct dma_buf_testdev_priv *priv; + struct device *dev = &pdev->dev; + int err; + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + dev_set_drvdata(dev, priv); + + dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32)); + + if (!dev->dma_parms) { + dev->dma_parms = devm_kzalloc(dev, sizeof(*dev->dma_parms), + GFP_KERNEL); + if (!dev->dma_parms) + return -ENOMEM; + } + dma_set_max_seg_size(dev, DMA_BIT_MASK(32)); + + priv->miscdev.minor = MISC_DYNAMIC_MINOR; + priv->miscdev.name = devm_kasprintf(dev, GFP_KERNEL, "%s", + DEVICE_NAME); + priv->miscdev.fops = &dma_buf_testdev_fops; + priv->miscdev.parent = dev; + err = misc_register(&priv->miscdev); + if (err) { + dev_err(dev, + "unable to register DMA-BUF to Phys misc device\n"); + return err; + } + + return 0; +} + +static int dma_buf_testdev_remove(struct platform_device *pdev) +{ + struct dma_buf_testdev_priv *priv = dev_get_drvdata(&pdev->dev); + + misc_deregister(&priv->miscdev); + + return 0; +} + +static struct platform_driver dma_buf_testdev_driver = { + .probe = dma_buf_testdev_probe, + .remove = dma_buf_testdev_remove, + .driver = { + .name = "dma_buf_testdev", + } +}; +module_platform_driver(dma_buf_testdev_driver); + +static int __init dma_buf_testdev_init(void) +{ + struct platform_device *pdev; + + pdev = platform_device_register_simple("dma_buf_testdev", -1, NULL, 0); + + return PTR_ERR_OR_ZERO(pdev); +} + +postcore_initcall(dma_buf_testdev_init); + +MODULE_AUTHOR("Andrew F. Davis "); +MODULE_DESCRIPTION("DMA-BUF Dummy Importer Test Device"); +MODULE_LICENSE("GPL v2"); diff --git a/include/uapi/linux/dma-buf-testdev.h b/include/uapi/linux/dma-buf-testdev.h new file mode 100644 index 0000000..b9706b8 --- /dev/null +++ b/include/uapi/linux/dma-buf-testdev.h @@ -0,0 +1,37 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* + * DMA-BUF Dummy Importer Test Device + * + * Copyright (C) 2018 Texas Instruments Incorporated - http://www.ti.com/ + * Andrew F. Davis + */ + +#ifndef DMA_BUF_TESTDEV_H +#define DMA_BUF_TESTDEV_H + +#include +#include + +/** + * struct dma_buf_testdev_data - metadata passed from userspace for conversion + * @fd: DMA-BUF fd for conversion + * @phys: populated with CPU physical address of DMA-BUF + */ +struct dma_buf_testdev_data { + __u32 fd; + __u64 phys; +}; + +#define DMA_BUF_TESTDEV_IOC_MAGIC 'D' + +/** + * DOC: DMA_BUF_TESTDEV_IOC_CONVERT - Convert DMA-BUF to physical address + * + * Takes a dma_buf_testdev_data struct containing a fd for a + * physicaly contigous buffer. Pins this buffer and populates + * phys field with the CPU physical address. + */ +#define DMA_BUF_TESTDEV_IOC_CONVERT _IOWR(DMA_BUF_TESTDEV_IOC_MAGIC, 0, \ + struct dma_buf_testdev_data) + +#endif /* DMA_BUF_PHYS_H */ From patchwork Fri Mar 29 00:16:02 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 161380 Delivered-To: patches@linaro.org Received: by 2002:a02:c6d8:0:0:0:0:0 with SMTP id r24csp1367956jan; Thu, 28 Mar 2019 17:16:19 -0700 (PDT) X-Received: by 2002:a62:445a:: with SMTP id r87mr43150351pfa.13.1553818579110; Thu, 28 Mar 2019 17:16:19 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1553818579; cv=none; d=google.com; s=arc-20160816; b=XhhexMoQoO4WUvs+R6L52uy/paP+agPVUorNEv972Z3T9nBxANhvYljolycJRB0jcM EYMcpBHrh0qUdnEzNOd/AhRPgnqtN/4N0ua62tmCzFsGTXbG8Iyk0egVyg9TOIo8xh0Q 841cn/C/wIPiUMH87F7F2xrr+60SCy465jfhCU35HrulSc8YXzdmA/wP2cblqfrvs8ih deTohgPLEFSUQgT+PnEOmkXR9RjdLG/XLHg0yZJS2gfUkGTjcJLz0rCEaqLjdo72pHhm Ie8EIfKdOJr8mfi7q/QOTpP4g3+2S62X2IlRzwyaZGnc4BhjSJIvLfCaENc2MU8M8G71 BpJA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=w3P2bWwFGQsyszNzoMrmRSuwoYaZS7mV0ew0iOcbMjY=; b=piIdnWxkHtDUEdPFFJQ6Hg0MXmiXrdI7HDt0TSncwhMB3N5rHsH6f6VBaivDA+xaet wG1wmcP8BIT7r+o6Xw9leLB8rhzplz0P24+8YLOXX4IkhYh287yPsobI/0Ti2tD5k32q o+wVRtiAooGZD5PV8TRcTwhyLjgJRcQjRqOeJ1cYzMpZOHcKwbkX4rAKTsfymvN9PrwO yUKuVMQ4E+z1ydXO+i4fVW1T9ZHiF+SW1L472qVsSmJT+hllynf/BVLcihcjT361eaXg ccN4sg5z6h3dcUZuYDh59uJxhDLdBoSYhsmKrd9zOuMvh4Vjd8Y0fR0JHIC5Qc+rRN5u j5VQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=fx3l2bTJ; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from mail-sor-f65.google.com (mail-sor-f65.google.com. [209.85.220.65]) by mx.google.com with SMTPS id j66sor416070pfc.35.2019.03.28.17.16.19 for (Google Transport Security); Thu, 28 Mar 2019 17:16:19 -0700 (PDT) Received-SPF: pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) client-ip=209.85.220.65; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=fx3l2bTJ; spf=pass (google.com: domain of john.stultz@linaro.org designates 209.85.220.65 as permitted sender) smtp.mailfrom=john.stultz@linaro.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=w3P2bWwFGQsyszNzoMrmRSuwoYaZS7mV0ew0iOcbMjY=; b=fx3l2bTJcYBDMflkoPB6mZiVxiwLlj7sDRku8ZTndkS9AF5lwEnnEOkqBjv1L4DLMf SyE6dzsU2VxGsj/oKNfu/p4RZCM8WSM5a1bxCFf892K+pxOgSZsMqwY6BO2KVIqjN1no lV11MWVHQZufhZ+pSkMVWofGuRgxfhJx74kNi8DwoQ/2XgcJHUNEM3fypnqx1hmfEpKo Ed+yRTHgG9X8lXs1PC9YTCSPftWdjkckg1ffwjgRuQpdICz8AT5MbRC+g/SgmywU+hCT VKza+jGynqTcNwAQI1inD4Eutkbl/e9tZVwaBQrGIJch42xd0KRrSvO9HJTsW3yzrL0b /81w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=w3P2bWwFGQsyszNzoMrmRSuwoYaZS7mV0ew0iOcbMjY=; b=I5KlM+7BKiOOeLBYzegPIXuKLOVAfGnvYNXtqvTdKwICu/exz7EV9gvKGax7VNM8iT BammfNRMLN/yXlTbSbw2bdfT1E5K9KrFR/iOZItYKSGM/+OXGJMttvImjCLzndc1H1Lv 4fMQ7vhgaev4fLIUVe0CTEb8KCnVSpvW7gBaWwtiEIbO0La1O1joZLV6uGXi+q5V47R/ LuqYd0ue5l5rTH3ndQQPpXMQGUr8l53dK2Z8282Un9GYDW3H9aN4qAJxMaW19rrCBXeU DhyjOFiDN33xSe1mnYHxpFVp9/+QeZ/Cgeeqoglcqvj4Nq3X8vP4Ti5pPLLUKEa1X4Xc oOyg== X-Gm-Message-State: APjAAAVLWC9SpQNyPx10xpPCvh5rogpK2gdaEsGepfVPuM4Km0FV9mw9 O+CXZH4LeJLxVlGLtkbybtrNJ6K0 X-Google-Smtp-Source: APXvYqwEFz87zAVsjaC/Keu5Z0JGD/6WcCDdiw2/LgYZjxmLTKlQoFwURvlp7iPk6Q95rzCABGcWQA== X-Received: by 2002:aa7:8282:: with SMTP id s2mr26226935pfm.7.1553818578724; Thu, 28 Mar 2019 17:16:18 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:4e72:b9ff:fe99:466a]) by smtp.gmail.com with ESMTPSA id g5sm430137pfo.53.2019.03.28.17.16.17 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 28 Mar 2019 17:16:17 -0700 (PDT) From: John Stultz To: lkml Cc: John Stultz , Benjamin Gaignard , Sumit Semwal , Liam Mark , Pratik Patel , Brian Starkey , Vincent Donnefort , Sudipto Paul , "Andrew F . Davis" , Xu YiPing , "Chenfeng (puck)" , butao , "Xiaqing (A)" , Yudongbin , Christoph Hellwig , Chenbo Feng , Alistair Strachan , dri-devel@lists.freedesktop.org Subject: [RFC][PATCH 6/6 v3] kselftests: Add dma-heap test Date: Thu, 28 Mar 2019 17:16:02 -0700 Message-Id: <1553818562-2516-7-git-send-email-john.stultz@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> References: <1553818562-2516-1-git-send-email-john.stultz@linaro.org> Add very trivial allocation and import test for dma-heaps. TODO: Still needs improvements Cc: Benjamin Gaignard Cc: Sumit Semwal Cc: Liam Mark Cc: Pratik Patel Cc: Brian Starkey Cc: Vincent Donnefort Cc: Sudipto Paul Cc: Andrew F. Davis Cc: Xu YiPing Cc: "Chenfeng (puck)" Cc: butao Cc: "Xiaqing (A)" Cc: Yudongbin Cc: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz --- v2: Switched to use reworked dma-heap apis v3: * Add simple mmap * Utilize dma-buf testdev to test importing --- tools/testing/selftests/dmabuf-heaps/Makefile | 11 ++ tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c | 169 +++++++++++++++++++++ 2 files changed, 180 insertions(+) create mode 100644 tools/testing/selftests/dmabuf-heaps/Makefile create mode 100644 tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c -- 2.7.4 diff --git a/tools/testing/selftests/dmabuf-heaps/Makefile b/tools/testing/selftests/dmabuf-heaps/Makefile new file mode 100644 index 0000000..c414ad3 --- /dev/null +++ b/tools/testing/selftests/dmabuf-heaps/Makefile @@ -0,0 +1,11 @@ +# SPDX-License-Identifier: GPL-2.0 +CFLAGS += -static -O3 -Wl,-no-as-needed -Wall +#LDLIBS += -lrt -lpthread -lm + +# these are all "safe" tests that don't modify +# system time or require escalated privileges +TEST_GEN_PROGS = dmabuf-heap + + +include ../lib.mk + diff --git a/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c new file mode 100644 index 0000000..df30465 --- /dev/null +++ b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c @@ -0,0 +1,169 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "../../../../include/uapi/linux/dma-heap.h" +#include "../../../../include/uapi/linux/dma-buf-testdev.h" + +#define DEVPATH "/dev/dma_heap" + +int dmabuf_importer_open(char *name) +{ + int ret, fd; + char buf[256]; + + ret = sprintf(buf, "/dev/%s", name); + if (ret < 0) { + printf("sprintf failed!\n"); + return ret; + } + + fd = open(buf, O_RDWR); + if (fd < 0) + printf("open %s failed!\n", buf); + return fd; +} + +int dmabuf_importer_import(int importer_fd, int dmabuf_fd, void *phys_addr) +{ + struct dma_buf_testdev_data data = { + .fd = dmabuf_fd, + .phys = 0, + }; + + int ret; + + if (phys_addr == NULL) + return -EINVAL; + + ret = ioctl(importer_fd, DMA_BUF_TESTDEV_IOC_CONVERT, &data); + if (ret < 0) + return ret; + + *(__u64 *)phys_addr = data.phys; + + return ret; +} + + +int dmabuf_heap_open(char *name) +{ + int ret, fd; + char buf[256]; + + ret = sprintf(buf, "%s/%s", DEVPATH, name); + if (ret < 0) { + printf("sprintf failed!\n"); + return ret; + } + + fd = open(buf, O_RDWR); + if (fd < 0) + printf("open %s failed!\n", buf); + return fd; +} + +int dmabuf_heap_alloc(int fd, size_t len, unsigned int flags, int *dmabuf_fd) +{ + struct dma_heap_allocation_data data = { + .len = len, + .flags = flags, + }; + int ret; + + if (dmabuf_fd == NULL) + return -EINVAL; + + ret = ioctl(fd, DMA_HEAP_IOC_ALLOC, &data); + if (ret < 0) + return ret; + *dmabuf_fd = (int)data.fd; + return ret; +} + +#define ONE_MEG (1024*1024) + +void do_test(char *heap_name) +{ + int heap_fd = -1, dmabuf_fd = -1, importer_fd = -1; + void *p; + int ret; + long phys; + + printf("Testing heap: %s\n", heap_name); + + heap_fd = dmabuf_heap_open(heap_name); + if (heap_fd < 0) + return; + + printf("Allocating 1 MEG\n"); + ret = dmabuf_heap_alloc(heap_fd, ONE_MEG, 0, &dmabuf_fd); + if (ret) + goto out; + + + /* mmap and write a simple pattern */ + p = mmap(NULL, + ONE_MEG, + PROT_READ | PROT_WRITE, + MAP_SHARED, + dmabuf_fd, + 0); + if (p == MAP_FAILED) { + printf("mmap() failed: %m\n"); + abort(); + } + printf("mmap passed\n"); + + memset(p, 1, ONE_MEG/2); + p = (char *)p + ONE_MEG/2; + memset(p, 0, ONE_MEG/2); + munmap(p, ONE_MEG); + + + importer_fd = dmabuf_importer_open("dma-buf-testdev"); + + ret = dmabuf_importer_import(importer_fd, dmabuf_fd, &phys); + if (ret) { + printf("Error importing to test device!\n"); + goto out; + } + printf("Import passed!\n"); + + /* DO SOMETHING WITH THE DMABUF HERE? */ + +out: + if (importer_fd >= 0) + close(importer_fd); + if (dmabuf_fd >= 0) + close(dmabuf_fd); + if (heap_fd >= 0) + close(heap_fd); +} + + +int main(void) +{ + DIR *d; + struct dirent *dir; + + d = opendir(DEVPATH); + if (!d) { + printf("No %s directory?\n", DEVPATH); + return -1; + } + + while ((dir = readdir(d)) != NULL) + do_test(dir->d_name); + + return 0; +}