From patchwork Wed Jul 24 00:36:52 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 169585 Delivered-To: patches@linaro.org Received: by 2002:a92:4782:0:0:0:0:0 with SMTP id e2csp9527422ilk; Tue, 23 Jul 2019 17:37:05 -0700 (PDT) X-Received: by 2002:aa7:8193:: with SMTP id g19mr8200927pfi.16.1563928625461; Tue, 23 Jul 2019 17:37:05 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1563928625; cv=none; d=google.com; s=arc-20160816; b=Gq7sVf4oD4bP0SC7fBtVHvcVvaGxSMAg+cfYkXXw9M4Gwaok7vzOGx7I0GP/hush2k BHx54A/o4qNI49ruvmSWvM76b4GG+3rytfjpmylQnYhwuKGlla/PBAaXNl9Esahudmvn uZwlxs/bq8u151Q4HxYHH6n2htEjjwYB11ifvJtKWBzjoiHJCBxsc+tSf6c8COkxV3sn tK4zxWDwyPKKmQ5jmVpZIxV52UI7v8Yfm4Yzumotpn0t3YIYL4RPNiPH6xi7LPZvjazy Gu0as7Fi8dc+7Irst/P1DjsN6DEudAay3GeQCexNqSWva6phdbwLaxLAoLk/A4YtKt7g JHxA== 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=g5tsHZ8wryaJFFcbueNAFqkanLadCR0J4WL5s8a6rKU=; b=rstRe32z5TpQuKziXXm2Bc2V99AxdyCSq3iOF5KQrTajyBq3uGYFfRMNWzDOH0MxOg LMkxlULDDKJ6P16tp3UQyLpO8qitB9TmbymyTvlIdXO1YYsN7f62Zt53moa4WTib7iQh ADLKsUMvsFARbK3IqCH6v34dL6guz1AUz73LPePO5gNrYtL89pUhvWOV8VgVw9oqIK4a Lxhrz705ySyrgdp8tHlhPec03ND6tuO7klHtdRzSRkWWJd/HAgYtZ/QsAwLLIGHjH/qF 4ujMMEayOfdC7SjxUKqLtbTPCixr70awgiA18N3tNIb3yDwItc752d/bTllPxcruczcf UGiw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ja72tyw8; 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 f10sor25070581pgg.6.2019.07.23.17.37.05 for (Google Transport Security); Tue, 23 Jul 2019 17:37:05 -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=ja72tyw8; 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=g5tsHZ8wryaJFFcbueNAFqkanLadCR0J4WL5s8a6rKU=; b=ja72tyw8dYv7jhFiQjrcprkpp2R0LVw94zLzew5oNcYuzq6MjF1AtTDhgrtw+GmVSE tHCUeDSFR7T8ZZ9D9U/oPiK7ZkM9gEbWVx/lSj8akXTRl/We7j1BBko1X90FALsJgabc pucxoG89CQS7aYtSgH9N3yoJsgvTheWgU2oJYgvfEOX0uXwHeBTnkE4KnQwnFmaJ9yCR DSPs2rDvZH77MhBG6+w4y13/rQ/0BFxQXgt1uxgGZcOnE4H9UAiKDzPb+rblO6Of6mnF /NNKbA8x/cEAm3hzI43ydDwBZtwF15sBTqTact+vpCNWR4el0Uh2RkcC0/k2qkr/DKoy Q9/A== 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=g5tsHZ8wryaJFFcbueNAFqkanLadCR0J4WL5s8a6rKU=; b=IPK0R7nAub67Hcnp9y6FSWXfcIAfZXDMtt7gyDeteDc/fCsEQcDZCNI5t3xlVB4/1v 7sWdAdAZgTYZmtEVNezF/xtui/UxcLWeIbJpNFlxZfYt6uF20bzYBdmUhE+gc2O7JaAy pyjbI+wfMCTVLDlZfhL47HE8DvQA4OlfMRzv8qoQNkBLdzaeWSi2OFaemWZsDBI4eoLd H13I6Mvv5JV2eun3L1hP8r25aF7HcvILzEW2BuafsSAYRwChlw828M1IW9RVcjBmNqff 1BGuJnaUijI3KZkVqcC0FvPYC9TCjhtjwZT0dSCGuHBg6pQCSDTTXqDNqgHNPRQjcGN/ yXRA== X-Gm-Message-State: APjAAAX4Zv0bosbjWbPP6BpbkD4Vc5XbBTOMFMHWPH6mx+fOKFAnSr0D qVlNkvGR/ZpEPZJ+9BoYfhuGIMNd X-Google-Smtp-Source: APXvYqxpmEMXY+pZEzJmBU0EPA4wR3Vr98jUZ5w/Bq0Rg74lROapXVihxWaohTwoWplc2fLalwVmfA== X-Received: by 2002:a65:404d:: with SMTP id h13mr77171045pgp.71.1563928624898; Tue, 23 Jul 2019 17:37:04 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id x26sm58890022pfq.69.2019.07.23.17.37.02 (version=TLS1_3 cipher=AEAD-AES256-GCM-SHA384 bits=256/256); Tue, 23 Jul 2019 17:37:04 -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 , Christoph Hellwig , Chenbo Feng , Alistair Strachan , Hridya Valsaraju , dri-devel@lists.freedesktop.org, John Stultz Subject: [PATCH v7 1/5] dma-buf: Add dma-buf heaps framework Date: Wed, 24 Jul 2019 00:36:52 +0000 Message-Id: <20190724003656.59780-2-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190724003656.59780-1-john.stultz@linaro.org> References: <20190724003656.59780-1-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: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: Hridya Valsaraju Cc: dri-devel@lists.freedesktop.org Reviewed-by: Benjamin Gaignard 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 than 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) v4: * Folded down dma-heap.h change that was in a following patch * Added fd_flags entry to allocation structure and pass it through to heap code for use on dma-buf fd creation (suggested by Benjamin) v5: * Minor cleanups v6: * Improved error path handling, minor whitespace fixes, both suggested by Brian v7: * Longer Kconfig description to quiet checkpatch warnings * Re-add compat_ioctl bits (Hridya noticed 32bit userland wasn't working) --- MAINTAINERS | 18 +++ drivers/dma-buf/Kconfig | 9 ++ drivers/dma-buf/Makefile | 1 + drivers/dma-buf/dma-heap.c | 252 ++++++++++++++++++++++++++++++++++ include/linux/dma-heap.h | 59 ++++++++ include/uapi/linux/dma-heap.h | 55 ++++++++ 6 files changed, 394 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.17.1 diff --git a/MAINTAINERS b/MAINTAINERS index 783569e3c4b4..189f1973b5d6 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4900,6 +4900,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 b6a9c2f1bc41..162e24e1e429 100644 --- a/drivers/dma-buf/Kconfig +++ b/drivers/dma-buf/Kconfig @@ -39,4 +39,13 @@ 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 options creates per heap chardevs in /dev/dma_heap/ which + allows userspace to use to allocate dma-bufs that can be shared + between drivers. + endmenu diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index e8c7310cb800..1cb3dd104825 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only obj-y := dma-buf.o dma-fence.o dma-fence-array.o dma-fence-chain.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 000000000000..809b082dac25 --- /dev/null +++ b/drivers/dma-buf/dma-heap.c @@ -0,0 +1,252 @@ +// 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 +#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 fd_flags, + unsigned int heap_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, fd_flags, heap_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) { + pr_warn_once("dma_heap: ioctl data not valid\n"); + return -EINVAL; + } + + if (heap_allocation.fd_flags & ~DMA_HEAP_VALID_FD_FLAGS) { + pr_warn_once("dma_heap: fd_flags has invalid or unsupported flags set\n"); + return -EINVAL; + } + + if (heap_allocation.heap_flags & ~DMA_HEAP_VALID_HEAP_FLAGS) { + pr_warn_once("dma_heap: heap flags has invalid or unsupported flags set\n"); + return -EINVAL; + } + + + fd = dma_heap_buffer_alloc(heap, heap_allocation.len, + heap_allocation.fd_flags, + heap_allocation.heap_flags); + if (fd < 0) + return fd; + + heap_allocation.fd = fd; + + if (copy_to_user((void __user *)arg, &heap_allocation, + sizeof(heap_allocation))) { + ksys_close(fd); + 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, +#ifdef CONFIG_COMPAT + .compat_ioctl = dma_heap_ioctl, +#endif +}; + +/** + * 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, *err_ret; + 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"); + err_ret = ERR_PTR(ret); + goto err0; + } + + /* 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"); + err_ret = ERR_PTR(ret); + goto err1; + } + + 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"); + err_ret = (struct dma_heap *)dev_ret; + goto err2; + } + + return heap; + +err2: + cdev_del(&heap->heap_cdev); +err1: + xa_erase(&dma_heap_minors, heap->minor); +err0: + kfree(heap); + return err_ret; + +} + +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 000000000000..7a1b633ac02f --- /dev/null +++ b/include/linux/dma-heap.h @@ -0,0 +1,59 @@ +/* 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; + +/** + * 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 fd_flags, + unsigned long heap_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 000000000000..6ce5cc68d238 --- /dev/null +++ b/include/uapi/linux/dma-heap.h @@ -0,0 +1,55 @@ +/* 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 + */ + +/* Valid FD_FLAGS are O_CLOEXEC, O_RDONLY, O_WRONLY, O_RDWR */ +#define DMA_HEAP_VALID_FD_FLAGS (O_CLOEXEC | O_ACCMODE) + +/* Currently no heap flags */ +#define DMA_HEAP_VALID_HEAP_FLAGS (0) + +/** + * struct dma_heap_allocation_data - metadata passed from userspace for + * allocations + * @len: size of the allocation + * @fd: will be populated with a fd which provdes the + * handle to the allocated dma-buf + * @fd_flags: file descriptor flags used when allocating + * @heap_flags: flags passed to heap + * + * Provided by userspace as an argument to the ioctl + */ +struct dma_heap_allocation_data { + __u64 len; + __u32 fd; + __u32 fd_flags; + __u64 heap_flags; + __u32 reserved0; + __u32 reserved1; +}; + +#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 Wed Jul 24 00:36:53 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 169586 Delivered-To: patches@linaro.org Received: by 2002:a92:4782:0:0:0:0:0 with SMTP id e2csp9527460ilk; Tue, 23 Jul 2019 17:37:07 -0700 (PDT) X-Received: by 2002:a62:1bca:: with SMTP id b193mr8200578pfb.57.1563928627504; Tue, 23 Jul 2019 17:37:07 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1563928627; cv=none; d=google.com; s=arc-20160816; b=Ob3o59xOpKgt0ACrltuKTImVVFLAlyUiimrcUihGdkDfgE3hkYbedb0oaVx3LTY5vS ch6uAbuJhR9hinHEVkaxMhitPGEVRzZL4VWrWZX851ALCfkvZPCaIxogWL7j2OVS5fyy thqtF03F9/vWwO7pYbR4hhr5qNfiANBV7XMT4Cz0Iqlnv67d4VZJ+JuEjJC0KY/byFrn 0IlLov42tazHocXjQpQLi07xVQ3WTSGRt3kUgclQz+aCoNdZ0rRoyek3jVPVq05YlJUc hspPPZTgmvRPzBBfvll656xjr9M0RsQNRP3QRQ8VpuYfAFsr7Q5fB6H+NnpQFCh/2vwB C5aA== 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=eCJcdrdV5vXslXNmNWdX1+xjDhPGdq+9No5ztEZ9ag0=; b=0R3CoiR5Gn8MBGnckYxivX2I3sB8AesS4ZYaGgNaGCCAbPwCtmrq4d4L3Np1sCEgqz d6rr2qmc6JhwNVbXmhh2pQ64Lhf3PFxkJrsmeH3Q/K3vI0hGXufTTZ/l1fAA9IqxRr9H 0JQjqN/N/etGd8d6jnOv78qx+flc3Fvf7Q+2J3oav8ec20/yTR9IEnPwK5nlOZEyFPc3 bZqnCPD+KX+Ov39//zGSlukHScOV8dV+hlg3K8MCKndKG7hQZUFlnuV9aUHy6p5jjURy WVbI4NBEny1GO8D6zv2nZR1rKprRxdCT3MPoCoSnleCwWFHdNGDQ0+GaOPr5FkdqHxUj U69w== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b="utRo4D/H"; 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 125sor5229861pgi.63.2019.07.23.17.37.07 for (Google Transport Security); Tue, 23 Jul 2019 17:37:07 -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="utRo4D/H"; 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=eCJcdrdV5vXslXNmNWdX1+xjDhPGdq+9No5ztEZ9ag0=; b=utRo4D/Hb3sozHOY2wm7Ih9x75qhFMAxKs6pLS5yxMcVNkTfhD2EXP0nyyJyGX72+x 8uYkguOPqCD1B84l8AFU9VfdLzGLSNojOXg19cvPcqAWBGTeVgWhjOZ5C/PqW6mZh2gP 1oLaVTF1BoNVsT61rIj0H/mKI4aQXl5z6HsuT8Rflh+4thKYszbvJP0o6/iy2pTzPDw2 AR93+qEvJKNUYX4tszYCHcY5dEPydIWtI0oIUWH1KMYuqTu2K6v6cOEh8hHZbxj2ZNvS 50gnQcOFE2SzbTuuZ90Fb87rwLXbitOTEL/IRHb4etDsh8n4tf5OwYn71tFdYKPKDSuU Amzg== 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=eCJcdrdV5vXslXNmNWdX1+xjDhPGdq+9No5ztEZ9ag0=; b=FElkCatuyMfkvUqOcev/2e36VfwmoZ8ZvuDRfmkPbtOOu9YEVgpG7ldOFAPqPIe6Hk MaoZ1YE6dUBQEpogHnSIj6sQjuMSQgGO9TEk/CqoLji9feJtJpvmEfNJPZa2sV5yKgkT F7AYEj/q6+ZlAewRk6Zz2QllXDLgmyjDExGBNkIYAbHjd2lofMbv/S9nmmLe/ZbKCSBp /W5dUDAHGwgMkhVU5DQPY80N924FgmZwhAb/aOOD7sQQWM/hbOeq6OB5H3gbDQ+pimYI Q4xe4uLCrNNeaE5EUAbI2yyGdwGJ9T1/r6w0xaBMA5McI7dyDeKbx7SqbzJ643DiQu+/ 9UUw== X-Gm-Message-State: APjAAAXGuO7XR8aOiVacwje7AauVAhpLec758f5FcC2wyu+YIv4WBF1j oH6t51qs1WoHEtFke8fE0EBMzcGg X-Google-Smtp-Source: APXvYqyq3aYiWmQkvR/qAy48XbEOER2AONFHRLatEgTPkG/5N9BpkPPLuGCZ+dj/0MBVF7/W3sIJQQ== X-Received: by 2002:a63:2c8:: with SMTP id 191mr77747242pgc.139.1563928627003; Tue, 23 Jul 2019 17:37:07 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id x26sm58890022pfq.69.2019.07.23.17.37.05 (version=TLS1_3 cipher=AEAD-AES256-GCM-SHA384 bits=256/256); Tue, 23 Jul 2019 17:37:06 -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" , Christoph Hellwig , Chenbo Feng , Alistair Strachan , Hridya Valsaraju , dri-devel@lists.freedesktop.org Subject: [PATCH v7 2/5] dma-buf: heaps: Add heap helpers Date: Wed, 24 Jul 2019 00:36:53 +0000 Message-Id: <20190724003656.59780-3-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190724003656.59780-1-john.stultz@linaro.org> References: <20190724003656.59780-1-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: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: Hridya Valsaraju Cc: dri-devel@lists.freedesktop.org Reviewed-by: Benjamin Gaignard 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 v4: * Moved dma-heap.h change out to previous patch v6: * Minor cleanups and typo fixes suggested by Brian v7: * Removed stray ; * Make init_heap_helper_buffer lowercase, as suggested by Christoph * Add dmabuf export helper to reduce boilerplate code --- drivers/dma-buf/Makefile | 1 + drivers/dma-buf/heaps/Makefile | 2 + drivers/dma-buf/heaps/heap-helpers.c | 276 +++++++++++++++++++++++++++ drivers/dma-buf/heaps/heap-helpers.h | 58 ++++++ 4 files changed, 337 insertions(+) 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.17.1 diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index 1cb3dd104825..e3e3dca29e46 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only obj-y := dma-buf.o dma-fence.o dma-fence-array.o dma-fence-chain.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 000000000000..de49898112db --- /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 000000000000..df1bd3cf7262 --- /dev/null +++ b/drivers/dma-buf/heaps/heap-helpers.c @@ -0,0 +1,276 @@ +// 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; + buffer->pagecount = 0; + buffer->pages = NULL; + INIT_LIST_HEAD(&buffer->attachments); + buffer->free = free; +} + +struct dma_buf *heap_helper_export_dmabuf( + struct heap_helper_buffer *helper_buffer, + int fd_flags) +{ + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + + exp_info.ops = &heap_helper_ops; + exp_info.size = helper_buffer->heap_buffer.size; + exp_info.flags = fd_flags; + exp_info.priv = &helper_buffer->heap_buffer; + + return dma_buf_export(&exp_info); +} + +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; +} + +static 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_detach(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; +} + +static 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; +} + +static 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_detach, + .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 000000000000..741c7ec013f5 --- /dev/null +++ b/drivers/dma-buf/heaps/heap-helpers.h @@ -0,0 +1,58 @@ +/* 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 *)); +struct dma_buf *heap_helper_export_dmabuf( + struct heap_helper_buffer *helper_buffer, + int fd_flags); +extern const struct dma_buf_ops heap_helper_ops; + + +#endif /* _HEAP_HELPERS_H */ From patchwork Wed Jul 24 00:36:54 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 169587 Delivered-To: patches@linaro.org Received: by 2002:a92:4782:0:0:0:0:0 with SMTP id e2csp9527497ilk; Tue, 23 Jul 2019 17:37:09 -0700 (PDT) X-Received: by 2002:a63:c342:: with SMTP id e2mr77892043pgd.79.1563928629174; Tue, 23 Jul 2019 17:37:09 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1563928629; cv=none; d=google.com; s=arc-20160816; b=0Z5VaWZ8tm4LIoIEVURr0peFUlbV+f5cg5Jer1U7APRVqIMA76y16IdOZy2S+wgj44 xmTkkNvm6GZ1f0q9EkeAEwrQApemfGhmeqmYu6JUgeM7wcBo4ifxWhj4BG8HtwMoiVbL NPK4lFpmraRruZeLBx/oLjIZy7pL9Fn4eY4RRlDkFVXvMOWVhNPBGsWXuUfLMdztsMTs Yk+WimPZrFA+iwyDBb4z7hMAtmEY2+Mo5NLgGWAPhCI2uTkjoMXVJZEB3apuHpoZY96S KavxbRTba4N0sy+1ScEcxmjMYuH7u2002Cu6GpOj0EPz6L/ZD27bZN6JGeUO3ZrVfNso X4ww== 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=cRgUrjkIfaz6iepdWbl+Z8FHJvikkt7XqivmX/WSvhU=; b=gF95skLDjg8rKlEZZhdnXgSDmheiBV5ZzoDTWB2OFdXV/74Z+0vTyJJD3AA1mLSzgm PE3zH+WjbpqOrSgjQM7VpJoiR8uPkEj8ig37hJRon5fDrQaBbIL5akW7CVXxK/kL0Ujq QRQAklAQ1YUYR/IULx2iqGaUwR46DRC9TpFy0fReEgOctJ2SLycKcdWkGEkr8WIywkCz owCtjT0lhUEjpgy/S4pHV1B9Qnl95QDOGQKeo2tTiK1dEfQS94HBJv6zwqsC/HdV5cwI baavKLwaE+gZtCRBZ3dfiWoPp88O5r92BFWGuyBwKNiroOn2dUz0DQgQWLIiFksPj/oQ wcew== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=GZag0zHA; 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 s7sor54083658plq.42.2019.07.23.17.37.09 for (Google Transport Security); Tue, 23 Jul 2019 17:37:09 -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=GZag0zHA; 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=cRgUrjkIfaz6iepdWbl+Z8FHJvikkt7XqivmX/WSvhU=; b=GZag0zHAOWD5R8fN8DJoy8togA+QfOKEIUSdoU7SoTPZrLcT5QzSTZqxRx+R0F0me3 HODDMresVAjijh0GX3Xuh1Nv4Q4hgjhf/Ym9LonsUFlaqBGBTJ8NbzqI3FEMvaR0l+fA UiaM/Y2tgFB0RoNQvpiQ+wedvYbw2/esJbRAkRKws+AbGgF0jDszqBzvLoUPYx70cg0b qS0eBdOyW+wn2Kf1o7PXAWpCzfMlQ5JF60D+AIa0aRHK2/f4Is0UATfvFDI25cf9PlsL hNE39dbsDWfr/EiBEzd5IhuEkrIZTtuIFb0zX6ctuaYehU97HSkRNl4Kx2Hg5LXN91l6 7LEg== 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=cRgUrjkIfaz6iepdWbl+Z8FHJvikkt7XqivmX/WSvhU=; b=Dadmh99pu7V5qgXJKT3iG3+rvm+XZYBG15XuEA6fRaY2ZbbROE7Tm9kkuzglLkJwzR YAQcD3qlXetqEm6ilg7UWukqYwKVQRmdRMorjDv0xf9rFJdjHWvmYfMTy+17A00bikly C0J0ji0SzcJTZBFvrVocPz4wiDiG9zpkoGBx9UCDqcQpYCsoVM9ALvx55sVKEFgPAp3U 0u/BMahma8yH7ZYwXy/+c5XariQGlBLOZVPMeuhR45+hStyIaZhfgR0yL/+BamwWrW3i mRWqBYKhyOIO/F+VifdRyx/lwudCiRzLUqJOda/L+9qtW28/SKRUEx7KGGH3IaUhN37I smmw== X-Gm-Message-State: APjAAAUzDn0BnqE0xNwJDzzTNyR70n9w/f3wba3m3DRJHYTwrA4d3+T8 iFOvd8iXv6Dfajtp2O8RkNYvoX+G X-Google-Smtp-Source: APXvYqytR6TxYeoHUSQ5+pWgeQbgrWji25dscymmkUuFJLLAPXcnjyZrh3UypGJt021XJ1Klh5cBhA== X-Received: by 2002:a17:902:a60d:: with SMTP id u13mr83790488plq.144.1563928628769; Tue, 23 Jul 2019 17:37:08 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id x26sm58890022pfq.69.2019.07.23.17.37.07 (version=TLS1_3 cipher=AEAD-AES256-GCM-SHA384 bits=256/256); Tue, 23 Jul 2019 17:37:07 -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" , Christoph Hellwig , Chenbo Feng , Alistair Strachan , Hridya Valsaraju , dri-devel@lists.freedesktop.org Subject: [PATCH v7 3/5] dma-buf: heaps: Add system heap to dmabuf heaps Date: Wed, 24 Jul 2019 00:36:54 +0000 Message-Id: <20190724003656.59780-4-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190724003656.59780-1-john.stultz@linaro.org> References: <20190724003656.59780-1-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: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: Hridya Valsaraju 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 v4: * Optimization to allocate pages in chunks, similar to old pagepool code * Use fd_flags when creating dmabuf fd (Suggested by Benjamin) v5: * Back out large order page allocations (was leaking memory, as the page array didn't properly track order size) v6: * Minor whitespace change suggested by Brian * Remove unused variable v7: * Use newly lower-cased init_heap_helper_buffer helper * Add system heap DOS avoidance suggested by Laura from ION code * Use new dmabuf export helper --- drivers/dma-buf/Kconfig | 2 + drivers/dma-buf/heaps/Kconfig | 6 ++ drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/system_heap.c | 123 ++++++++++++++++++++++++++++ 4 files changed, 132 insertions(+) create mode 100644 drivers/dma-buf/heaps/Kconfig create mode 100644 drivers/dma-buf/heaps/system_heap.c -- 2.17.1 diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig index 162e24e1e429..657ce743abda 100644 --- a/drivers/dma-buf/Kconfig +++ b/drivers/dma-buf/Kconfig @@ -48,4 +48,6 @@ menuconfig DMABUF_HEAPS allows userspace to use 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 000000000000..205052744169 --- /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 de49898112db..d1808eca2581 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 000000000000..5e3eb1fb3bcd --- /dev/null +++ b/drivers/dma-buf/heaps/system_heap.c @@ -0,0 +1,123 @@ +// 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 fd_flags, + unsigned long heap_flags) +{ + struct heap_helper_buffer *helper_buffer; + 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 = heap_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++) { + /* + * Avoid trying to allocate memory if the process + * has been killed by by SIGKILL + */ + if (fatal_signal_pending(current)) + goto err1; + + helper_buffer->pages[pg] = alloc_page(GFP_KERNEL | __GFP_ZERO); + if (!helper_buffer->pages[pg]) + goto err1; + } + + /* create the dmabuf */ + dmabuf = heap_helper_export_dmabuf(helper_buffer, fd_flags); + if (IS_ERR(dmabuf)) { + ret = PTR_ERR(dmabuf); + goto err1; + } + + helper_buffer->heap_buffer.dmabuf = dmabuf; + + ret = dma_buf_fd(dmabuf, fd_flags); + 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 Wed Jul 24 00:36:55 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 169588 Delivered-To: patches@linaro.org Received: by 2002:a92:4782:0:0:0:0:0 with SMTP id e2csp9527533ilk; Tue, 23 Jul 2019 17:37:11 -0700 (PDT) X-Received: by 2002:a62:7890:: with SMTP id t138mr232658pfc.238.1563928631408; Tue, 23 Jul 2019 17:37:11 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1563928631; cv=none; d=google.com; s=arc-20160816; b=E1yyK+gSDZpepmPl34QgyRABGflMH+uBij5tFYJrmYhmfYanE2qTwwqVIqosmvNAKP VImRsoQSfHya7Qr5cG0L+npUCdR5e6aqINiBsPKXK50xUOny7rxloYrXEse39+Fuueae 7V9uJWDo5ELc5FuUjVBeCUOOatICfeZvoOYdTUAQcAXNt0kwJH4r+WHVyS4vG69Z1dyG s4l8UTQi7FhunI0/wjiV1Zd9/CstNIwG/N4so6isb5ldly33d2cY2vL6CSgtlTiF30R3 IUTLNUErx2kM6HtOVot2TrwCZUQIUXXYc6wHv9fR5bTjvxGUqMnDkygFKFqomDV1tQrA 7FaQ== 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=gG4foaWh2iCNus5gyTRB5t5U1Yj3aDJJLs13UfI1dew=; b=L+NOZEqeSTDEG69coT5Phrkv3B/mbl4SdduAfPU9Gl5PKHAjE/xGnSBw9MwUUsUY2z gVMOwLme7NeMG2yGyVUI00ccJbSCgTtGjPHxj8k96U0ZGnD4vG3fAALmL8Ucv6QCYJtS cDbWaO3LwAjlFqjSamW/tamcgcumFkdIJnaUDS+ul1Jj7EHWmQUuSoQLuhRi1g4truOD FvC/vRbUr2Sb3Cljm9Qv8tjhRDd4bsvqocCrGjiMgNREnzAVDqyR0RNJuALbatPVduRj Kam2dnWn3/+ddL34z02tIfxPjO8JjvmCKUr/AnH0YtmOW9fdYsNebwuW1NqzxtRlFW1E i6Mw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=l7VX6cyQ; 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 142sor24389412pge.7.2019.07.23.17.37.11 for (Google Transport Security); Tue, 23 Jul 2019 17:37:11 -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=l7VX6cyQ; 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=gG4foaWh2iCNus5gyTRB5t5U1Yj3aDJJLs13UfI1dew=; b=l7VX6cyQMD/lJw9uHaDWvi7dlEGptXxL0eSfcqJpV0RRNnAEwi/ctaKByeW0TA3LYo JiJ4NBgBd80fNhVzdfVnAeuBeCgZD+PNzPp48YbCiVFqMkXiY+1LwcOYgJvHXjD9d3qH g8d2nz5zFdn5xs3/9Zb5SZCO0JWbdKYf/KTukVrSBcuYCU8cOlnrxRXnGx9q9U4glrXD ASfvjOgiZxg0D4YAuwEcliPMRQ75jR8HAg+5r3jklFGgYN0OtnHu0piPi3Yr+NSSgh+t pye9cWAjiUW86Nk0NJIx0uvHz0PJ3E/Pdn8zB1dNvC0SUpNU+VTXrCsnopeFeqqm1w7H CKNA== 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=gG4foaWh2iCNus5gyTRB5t5U1Yj3aDJJLs13UfI1dew=; b=dv8SY9eB1bSN/d0Ecctt2dpYXbfULwbwvrUln0RYzej4h6lQTnraT5RjEzdRqtVqKs cjTxzTCX+ada46a0daXPyyGo10/jnydoU4MfQO7TkQBtpG4ImF0XDq9so32zHJpzxjzO NE0MgWGex2V53+8o2lxKYx4nkWX6exPIdhTkWIxp/VwdF1jv7rRF32DzD3F/k0AIiDQW Jr1R7V/5VYGSfMcQgPjgBpmNlKZu6fCiAuymV+7xBuMus6bjch+Py8Ev9X15erVkspkR CFEuEsEj6GH+htmK5aeseW0rPlK50A6t5hnob7nYAhwrgKAzX23gUy/BnbxBUetsAvhg YpJg== X-Gm-Message-State: APjAAAXX7WcZp/90b/rFdJKUJu3N8uteAIKH8gnHExyLpUjKU5i+GwBI T3E6J3ube3rIjbB+/S8H58oBOJ/b X-Google-Smtp-Source: APXvYqweETm5iA3BCXYCb3vPssshCzfXVhSAvT3azAMwqPwU9HZEeDmh3U0qbAqbcfWlyp06Nd1mkA== X-Received: by 2002:a65:5882:: with SMTP id d2mr52834454pgu.134.1563928630847; Tue, 23 Jul 2019 17:37:10 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id x26sm58890022pfq.69.2019.07.23.17.37.08 (version=TLS1_3 cipher=AEAD-AES256-GCM-SHA384 bits=256/256); Tue, 23 Jul 2019 17:37: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" , Christoph Hellwig , Chenbo Feng , Alistair Strachan , Hridya Valsaraju , dri-devel@lists.freedesktop.org Subject: [PATCH v7 4/5] dma-buf: heaps: Add CMA heap to dmabuf heaps Date: Wed, 24 Jul 2019 00:36:55 +0000 Message-Id: <20190724003656.59780-5-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190724003656.59780-1-john.stultz@linaro.org> References: <20190724003656.59780-1-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: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: Hridya Valsaraju 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 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 v4: * Use the fd_flags when creating dmabuf fd (Suggested by Benjamin) * Use precalculated pagecount (Suggested by Andrew) v6: * Changed variable names to improve clarity, as suggested by Brian v7: * Use newly lower-cased init_heap_helper_buffer helper * Use new dmabuf export helper --- drivers/dma-buf/heaps/Kconfig | 8 ++ drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/cma_heap.c | 164 +++++++++++++++++++++++++++++++ 3 files changed, 173 insertions(+) create mode 100644 drivers/dma-buf/heaps/cma_heap.c -- 2.17.1 diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index 205052744169..a5eef06c4226 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 d1808eca2581..6e54cdec3da0 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 000000000000..cc657380ad60 --- /dev/null +++ b/drivers/dma-buf/heaps/cma_heap.c @@ -0,0 +1,164 @@ +// 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); + unsigned long nr_pages = buffer->pagecount; + struct page *cma_pages = buffer->priv_virt; + + /* free page list */ + kfree(buffer->pages); + /* release memory */ + cma_release(cma_heap->cma, 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 fd_flags, + unsigned long heap_flags) +{ + struct cma_heap *cma_heap = dma_heap_get_data(heap); + struct heap_helper_buffer *helper_buffer; + struct page *cma_pages; + size_t size = PAGE_ALIGN(len); + unsigned long nr_pages = size >> PAGE_SHIFT; + unsigned long align = get_order(size); + 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 = heap_flags; + helper_buffer->heap_buffer.heap = heap; + helper_buffer->heap_buffer.size = len; + + cma_pages = cma_alloc(cma_heap->cma, nr_pages, align, false); + if (!cma_pages) + goto free_buf; + + if (PageHighMem(cma_pages)) { + unsigned long nr_clear_pages = nr_pages; + struct page *page = cma_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(cma_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] = &cma_pages[pg]; + if (!helper_buffer->pages[pg]) + goto free_pages; + } + + /* create the dmabuf */ + dmabuf = heap_helper_export_dmabuf(helper_buffer, fd_flags); + if (IS_ERR(dmabuf)) { + ret = PTR_ERR(dmabuf); + goto free_pages; + } + + helper_buffer->heap_buffer.dmabuf = dmabuf; + helper_buffer->priv_virt = cma_pages; + + ret = dma_buf_fd(dmabuf, fd_flags); + 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, 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 Wed Jul 24 00:36:56 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: John Stultz X-Patchwork-Id: 169589 Delivered-To: patches@linaro.org Received: by 2002:a92:4782:0:0:0:0:0 with SMTP id e2csp9527566ilk; Tue, 23 Jul 2019 17:37:13 -0700 (PDT) X-Received: by 2002:a17:90a:bd93:: with SMTP id z19mr85965950pjr.49.1563928633055; Tue, 23 Jul 2019 17:37:13 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1563928633; cv=none; d=google.com; s=arc-20160816; b=Sf8WT98Q34tIokC1Nye6IoBl4+H9RzPAC8Yeqa+oZqW9cPN5jiNWF+lu407EnH6XXX xAipge73I8i2W8nj2AkDMBJw2i+pRA6YtR7YpL1uZBlgHNd6TNhNvkQ7/Dre78naqIR+ Xx3tf9PVq43Op5sWOKoHyrcBocAsac0mjC1UlMMIccCx1IUmGUdsroXGhCeppqdPq0dr 9Hzhbz7CqBpgUZOy806akNNsHozaxsLcEmnD3dsmASAIzl3J532sbPAZJZR2VbgzzSD3 vUZU8mTo+KzojsdLBs/cp0TDqNdOadnHjL4lGZjelx/+1ek9L0FnizhA/pU86dZ8p36k veyA== 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=jWzGO3kzW7ffNMSQJH7PkuzBm+8bRr6ltixOP2NA/dg=; b=CtS/1pcDlxh3eOwM2ULiKCX7XnIKEjTQ0e3jlGJBg5oF2Idt8tRBH9FoUqonuosB+v tfZNQMU8Uy+bDu9tFSCQss4PV3cXH6xJ2cLVafP+4NxIvSnU40jk7HQfofH9aEnqE0MQ sqWNBRXTpd1yEjEQ5XAjgB718kk42LNx7eHo05LR6cAs7svJOa9hYYy5+MgtyZauOowo uwvyjxy3iD/oWp7qqpuBwGgHevEU4EopE6oviObbPULHI8Ajd4+1UUMIAQKf+7nAYUjO ZDmyPQg51p5FI8APatlZNs3yOdGuwQevg9W5AWwvyzK0CfBQvbzD84APGdpcIy7jRdmr Obyw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=KY1gkI7S; 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 m93sor53645095pje.1.2019.07.23.17.37.12 for (Google Transport Security); Tue, 23 Jul 2019 17:37:13 -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=KY1gkI7S; 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=jWzGO3kzW7ffNMSQJH7PkuzBm+8bRr6ltixOP2NA/dg=; b=KY1gkI7SrnDx2GYC+fhCOK9fXj9Cz47JxT2JAhD5WFck2iBhoqyRJ37hWbw2Xk4b5x 6uRHbzxfxiz8PirTyjdUb4pM+ddo5IsEX3FDOgCEUETmNUcwn1zIMM8Rq8SubT0kmcTp wtKamm+lYCMbqi0oJ2Zsh4CrscprnKJv095DfXRyVE+aM7rg7kXt+sLgZ+F9BE90hkfp Qj9WaHL7CfjNoN/TNNn9b41Vx7Qhh3lMQ8QZKzzlO3JRSixzek0myg4dgNRg1pZnVHgM E9Ttys4/AEhBLNVOgwUY/rl/OcBKJioeFooAnV41y2/q5iz6pDtrI1sp2Zo5LF+03mri KQlQ== 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=jWzGO3kzW7ffNMSQJH7PkuzBm+8bRr6ltixOP2NA/dg=; b=LGD92cRloCQgRSh+q0//t7mnpHqt08QnYD3VtRcwCBRfGbOjfrDLKDwMTUFyiwshtd fmntGTkvufEd5LMvIwZGkPB5pN3TuTlP2yfp2HnTy05EIxuRFxhvUwFzeeqq9cIU4CD1 Twx96ZV1pBnbxBiHwT6XuodRVEvl+Nlult8Kj5DWdpAc/AAgCbNZBbXp3AYVc8L0wOLU PaNR3ak+5t+EaHa2ZYcUtEBh9FPluC5tVmyHLLTJl/QkWTpo7XRlspuiHxw0NnI8Ic69 jyJPIyFKYgyJPReIvKziTbcs8/54ITNGLT46v42dk3Mvs4acCaS1aef5dBGNwlixYyzA DT2A== X-Gm-Message-State: APjAAAU0iooO2l4hkrrbFmq+jFwaiJIGmI8FuIWpb9HisiqpWmarXtcg 1Jn5N+t7aVUrXKDaukc5TB3/7La2 X-Google-Smtp-Source: APXvYqxSqz3BUlJUL+S3IqhOBEcFzuHqZEpkeurQfHhWWh/L00LvBh9HdTffHogTTNZ3mGmOb9WO4A== X-Received: by 2002:a17:90a:3401:: with SMTP id o1mr84365628pjb.7.1563928632593; Tue, 23 Jul 2019 17:37:12 -0700 (PDT) Return-Path: Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id x26sm58890022pfq.69.2019.07.23.17.37.11 (version=TLS1_3 cipher=AEAD-AES256-GCM-SHA384 bits=256/256); Tue, 23 Jul 2019 17:37:11 -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" , Christoph Hellwig , Chenbo Feng , Alistair Strachan , Hridya Valsaraju , dri-devel@lists.freedesktop.org Subject: [PATCH v7 5/5] kselftests: Add dma-heap test Date: Wed, 24 Jul 2019 00:36:56 +0000 Message-Id: <20190724003656.59780-6-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190724003656.59780-1-john.stultz@linaro.org> References: <20190724003656.59780-1-john.stultz@linaro.org> Add very trivial allocation and import test for dma-heaps, utilizing the vgem driver as a test importer. A good chunk of this code taken from: tools/testing/selftests/android/ion/ionmap_test.c Originally by 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: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: Hridya Valsaraju Cc: dri-devel@lists.freedesktop.org Reviewed-by: Benjamin Gaignard Signed-off-by: John Stultz --- v2: * Switched to use reworked dma-heap apis v3: * Add simple mmap * Utilize dma-buf testdev to test importing v4: * Rework to use vgem * Pass in fd_flags to match interface changes * Skip . and .. dirs v6: * Number of style/cleanups suggested by Brian v7: * Whitespace fixup for checkpatch --- tools/testing/selftests/dmabuf-heaps/Makefile | 9 + .../selftests/dmabuf-heaps/dmabuf-heap.c | 235 ++++++++++++++++++ 2 files changed, 244 insertions(+) create mode 100644 tools/testing/selftests/dmabuf-heaps/Makefile create mode 100644 tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c -- 2.17.1 diff --git a/tools/testing/selftests/dmabuf-heaps/Makefile b/tools/testing/selftests/dmabuf-heaps/Makefile new file mode 100644 index 000000000000..8c4c36e2972d --- /dev/null +++ b/tools/testing/selftests/dmabuf-heaps/Makefile @@ -0,0 +1,9 @@ +# 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 000000000000..f36778d2d463 --- /dev/null +++ b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c @@ -0,0 +1,235 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + +#include "../../../../include/uapi/linux/dma-heap.h" + +#define DEVPATH "/dev/dma_heap" + +static int check_vgem(int fd) +{ + drm_version_t version = { 0 }; + char name[5]; + int ret; + + version.name_len = 4; + version.name = name; + + ret = ioctl(fd, DRM_IOCTL_VERSION, &version); + if (ret) + return 0; + + return !strcmp(name, "vgem"); +} + +static int open_vgem(void) +{ + int i, fd; + const char *drmstr = "/dev/dri/card"; + + fd = -1; + for (i = 0; i < 16; i++) { + char name[80]; + + sprintf(name, "%s%u", drmstr, i); + + fd = open(name, O_RDWR); + if (fd < 0) + continue; + + if (!check_vgem(fd)) { + close(fd); + continue; + } else { + break; + } + + } + return fd; +} + +static int import_vgem_fd(int vgem_fd, int dma_buf_fd, uint32_t *handle) +{ + struct drm_prime_handle import_handle = { + .fd = dma_buf_fd, + .flags = 0, + .handle = 0, + }; + int ret; + + ret = ioctl(vgem_fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &import_handle); + if (ret == 0) + *handle = import_handle.handle; + return ret; +} + +static void close_handle(int vgem_fd, uint32_t handle) +{ + struct drm_gem_close close = { + .handle = handle, + }; + + ioctl(vgem_fd, DRM_IOCTL_GEM_CLOSE, &close); +} + + +static 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; +} + +static int dmabuf_heap_alloc(int fd, size_t len, unsigned int flags, + int *dmabuf_fd) +{ + struct dma_heap_allocation_data data = { + .len = len, + .fd_flags = O_RDWR | O_CLOEXEC, + .heap_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; +} + +static void dmabuf_sync(int fd, int start_stop) +{ + struct dma_buf_sync sync = { + .flags = start_stop | DMA_BUF_SYNC_RW, + }; + int ret; + + ret = ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync); + if (ret) + printf("sync failed %d\n", errno); +} + +#define ONE_MEG (1024*1024) + +static void do_test(char *heap_name) +{ + int heap_fd = -1, dmabuf_fd = -1, importer_fd = -1; + uint32_t handle = 0; + void *p = NULL; + int ret; + + 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) { + printf("Allocation Failed!\n"); + 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"); + goto out; + } + printf("mmap passed\n"); + + + dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_START); + + memset(p, 1, ONE_MEG / 2); + memset((char *)p + ONE_MEG / 2, 0, ONE_MEG / 2); + dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_END); + + importer_fd = open_vgem(); + if (importer_fd < 0) { + ret = importer_fd; + printf("Failed to open vgem\n"); + goto out; + } + + ret = import_vgem_fd(importer_fd, dmabuf_fd, &handle); + if (ret < 0) { + printf("Failed to import buffer\n"); + goto out; + } + printf("import passed\n"); + + dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_START); + memset(p, 0xff, ONE_MEG); + dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_END); + printf("syncs passed\n"); + + close_handle(importer_fd, handle); + +out: + if (p) + munmap(p, ONE_MEG); + 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) { + if (!strncmp(dir->d_name, ".", 2)) + continue; + if (!strncmp(dir->d_name, "..", 3)) + continue; + + do_test(dir->d_name); + } + closedir(d); + + return 0; +}