The goal of this RFC is to understand if a common ioctl for specific memory regions allocations is needed/welcome.
Obviously it will not replace allocation done in linux kernel frameworks like v4l2, drm/kms or others, but offer an alternative when you don't want/need to use them for buffer allocation. To keep a compatibility with what already exist allocated buffers are exported in userland as dmabuf file descriptor (like ION is doing).
"Unix Device Memory Allocator" project [1] wants to create a userland library which may allow to select, depending of the devices constraint, the best back-end for allocation. With this RFC I would to propose to have common ioctl for a maximum of allocators to avoid to duplicated back-ends for this library.
One of the issues that lead me to propose this RFC it is that since the beginning it is a problem to allocate contiguous memory (CMA) without using v4l2 or drm/kms so the first allocator available in this RFC use CMA memory.
An other question is: do we have others memory regions that could be interested by this new framework ? I have in mind that some title memory regions could use it or replace ION heaps (system, carveout, etc...). Maybe it only solve CMA allocation issue, in this case there is no need to create a new framework but only a dedicated ioctl.
Maybe the first thing to do is to change the name and the location of this module, suggestions are welcome.
I have testing this code with the following program:
#include <errno.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/ioctl.h> #include <sys/mman.h> #include <sys/stat.h> #include <sys/types.h>
#include "simple-allocator.h"
#define LENGTH 1024*16
void main (void) { struct simple_allocate_data data; int fd = open("/dev/cma0", O_RDWR, 0); int ret; void *mem;
if (fd < 0) { printf("Can't open /dev/cma0\n"); return; }
memset(&data, 0, sizeof(data));
data.length = LENGTH; data.flags = O_RDWR | O_CLOEXEC;
ret = ioctl(fd, SA_IOC_ALLOC, &data); if (ret) { printf("Buffer allocation failed\n"); goto end; }
mem = mmap(0, LENGTH, PROT_READ | PROT_WRITE, MAP_SHARED, data.fd, 0); if (mem == MAP_FAILED) { printf("mmap failed\n"); }
memset(mem, 0xFF, LENGTH); munmap(mem, LENGTH);
printf("test simple allocator CMA OK\n"); end: close(fd); }
[1] https://github.com/cubanismo/allocator
Benjamin Gaignard (2): Create Simple Allocator module add CMA simple allocator module
Documentation/simple-allocator.txt | 81 ++++++++++ drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/simpleallocator/Kconfig | 17 +++ drivers/simpleallocator/Makefile | 2 + drivers/simpleallocator/simple-allocator-cma.c | 187 ++++++++++++++++++++++++ drivers/simpleallocator/simple-allocator-priv.h | 33 +++++ drivers/simpleallocator/simple-allocator.c | 180 +++++++++++++++++++++++ include/uapi/linux/simple-allocator.h | 35 +++++ 9 files changed, 538 insertions(+) create mode 100644 Documentation/simple-allocator.txt create mode 100644 drivers/simpleallocator/Kconfig create mode 100644 drivers/simpleallocator/Makefile create mode 100644 drivers/simpleallocator/simple-allocator-cma.c create mode 100644 drivers/simpleallocator/simple-allocator-priv.h create mode 100644 drivers/simpleallocator/simple-allocator.c create mode 100644 include/uapi/linux/simple-allocator.h
This is the core of simple allocator module. It aim to offert one common ioctl to allocate specific memory.
Signed-off-by: Benjamin Gaignard benjamin.gaignard@linaro.org --- Documentation/simple-allocator.txt | 81 +++++++++++ drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/simpleallocator/Kconfig | 10 ++ drivers/simpleallocator/Makefile | 1 + drivers/simpleallocator/simple-allocator-priv.h | 33 +++++ drivers/simpleallocator/simple-allocator.c | 180 ++++++++++++++++++++++++ include/uapi/linux/simple-allocator.h | 35 +++++ 8 files changed, 343 insertions(+) create mode 100644 Documentation/simple-allocator.txt create mode 100644 drivers/simpleallocator/Kconfig create mode 100644 drivers/simpleallocator/Makefile create mode 100644 drivers/simpleallocator/simple-allocator-priv.h create mode 100644 drivers/simpleallocator/simple-allocator.c create mode 100644 include/uapi/linux/simple-allocator.h
diff --git a/Documentation/simple-allocator.txt b/Documentation/simple-allocator.txt new file mode 100644 index 0000000..89ba883 --- /dev/null +++ b/Documentation/simple-allocator.txt @@ -0,0 +1,81 @@ +Simple Allocator Framework + +Simple Allocator offer a single ioctl SA_IOC_ALLOC to allocate buffers +on dedicated memory regions and export them as a dmabuf file descriptor. +Using dmabuf file descriptor allow to share this memory between processes +and/or import it into other frameworks like v4l2 or drm/kms (prime). +When userland wants to free the memory only a call to close() in needed +so it could done even without knowing that buffer has been allocated by +simple allocator ioctl. + +Each memory regions will be seen as a filein /dev/. +For example CMA regions will exposed has /dev/cmaX. + +Implementing a simple allocator +------------------------------- + +Simple Allocator provide helpers functions to register/unregister an +allocator: +- simple_allocator_register(struct sa_device *sadev) + Register simple_allocator_device using sa_device structure where name, + owner and allocate fields must be set. + +- simple_allocator_unregister(struct sa_device *sadev) + Unregister a simple allocator device. + +Using Simple Allocator /dev interface example +--------------------------------------------- + +This example of code allocate a buffer on the first CMA region (/dev/cma0) +before mmap and close it. + +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <sys/types.h> + +#include "simple-allocator.h" + +#define LENGTH 1024*16 + +void main (void) +{ + struct simple_allocate_data data; + int fd = open("/dev/cma0", O_RDWR, 0); + int ret; + void *mem; + + if (fd < 0) { + printf("Can't open /dev/cma0\n"); + return; + } + + memset(&data, 0, sizeof(data)); + + data.length = LENGTH; + data.flags = O_RDWR | O_CLOEXEC; + + ret = ioctl(fd, SA_IOC_ALLOC, &data); + if (ret) { + printf("Buffer allocation failed\n"); + goto end; + } + + mem = mmap(0, LENGTH, PROT_READ | PROT_WRITE, MAP_SHARED, data.fd, 0); + if (mem == MAP_FAILED) { + printf("mmap failed\n"); + } + + memset(mem, 0xFF, LENGTH); + munmap(mem, LENGTH); + + printf("test simple allocator CMA OK\n"); +end: + close(fd); +} diff --git a/drivers/Kconfig b/drivers/Kconfig index e1e2066..a6d8828 100644 --- a/drivers/Kconfig +++ b/drivers/Kconfig @@ -202,4 +202,6 @@ source "drivers/hwtracing/intel_th/Kconfig"
source "drivers/fpga/Kconfig"
+source "drivers/simpleallocator/Kconfig" + endmenu diff --git a/drivers/Makefile b/drivers/Makefile index 060026a..5081eb8 100644 --- a/drivers/Makefile +++ b/drivers/Makefile @@ -173,3 +173,4 @@ obj-$(CONFIG_STM) += hwtracing/stm/ obj-$(CONFIG_ANDROID) += android/ obj-$(CONFIG_NVMEM) += nvmem/ obj-$(CONFIG_FPGA) += fpga/ +obj-$(CONFIG_SIMPLE_ALLOCATOR) += simpleallocator/ diff --git a/drivers/simpleallocator/Kconfig b/drivers/simpleallocator/Kconfig new file mode 100644 index 0000000..c6fc2e3 --- /dev/null +++ b/drivers/simpleallocator/Kconfig @@ -0,0 +1,10 @@ +menu "Simple Allocator" + +config SIMPLE_ALLOCATOR + tristate "Simple Alllocator Framework" + select DMA_SHARED_BUFFER + ---help--- + The Simple Allocator Framework adds an API to allocate and share + memory in userland. + +endmenu diff --git a/drivers/simpleallocator/Makefile b/drivers/simpleallocator/Makefile new file mode 100644 index 0000000..e27c6ad --- /dev/null +++ b/drivers/simpleallocator/Makefile @@ -0,0 +1 @@ +obj-$(CONFIG_SIMPLE_ALLOCATOR) += simple-allocator.o diff --git a/drivers/simpleallocator/simple-allocator-priv.h b/drivers/simpleallocator/simple-allocator-priv.h new file mode 100644 index 0000000..33f5a33 --- /dev/null +++ b/drivers/simpleallocator/simple-allocator-priv.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) Linaro 2016 + * + * Author: Benjamin Gaignard benjamin.gaignard@linaro.org + * + * License terms: GNU General Public License (GPL) + */ + +#ifndef _SIMPLE_ALLOCATOR_PRIV_H_ +#define _SIMPLE_ALLOCATOR_PRIV_H_ + +#include <linux/cdev.h> +#include <linux/device.h> +#include <linux/dma-buf.h> + +/** + * struct sa_device - simple allocator device + * @owner: module owner, must be set to THIS_MODULE + * @name: name of the allocator + * @allocate: callabck for memory allocation + */ +struct sa_device { + struct device dev; + struct cdev chrdev; + struct module *owner; + const char *name; + struct dma_buf *(*allocate)(struct sa_device *, u64 length, u32 flags); +}; + +int simple_allocator_register(struct sa_device *sadev); +void simple_allocator_unregister(struct sa_device *sadev); + +#endif diff --git a/drivers/simpleallocator/simple-allocator.c b/drivers/simpleallocator/simple-allocator.c new file mode 100644 index 0000000..2f82396 --- /dev/null +++ b/drivers/simpleallocator/simple-allocator.c @@ -0,0 +1,180 @@ +/* + * Copyright (C) Linaro 2016 + * + * Author: Benjamin Gaignard benjamin.gaignard@linaro.org + * + * License terms: GNU General Public License (GPL) + */ + +#include <linux/module.h> +#include <linux/simple-allocator.h> +#include <linux/uaccess.h> + +#include "simple-allocator-priv.h" + +#define SA_MAJOR 222 +#define SA_NUM_DEVICES 256 +#define SA_NAME "simple_allocator" + +static int sa_minor; + +static struct class sa_class = { + .name = SA_NAME, +}; + +static long sa_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) +{ + struct sa_device *sadev = filp->private_data; + int ret = -ENODEV; + + switch (cmd) { + case SA_IOC_ALLOC: + { + struct simple_allocate_data data; + struct dma_buf *dmabuf; + + if (copy_from_user(&data, (void __user *)arg, _IOC_SIZE(cmd))) + return -EFAULT; + + if (data.version != 0) + return -EINVAL; + + dmabuf = sadev->allocate(sadev, data.length, data.flags); + if (!dmabuf) + return -EINVAL; + + data.fd = dma_buf_fd(dmabuf, data.flags); + if (data.fd < 0) { + dma_buf_put(dmabuf); + return -EINVAL; + } + + data.length = dmabuf->size; + + if (copy_to_user((void __user *)arg, &data, _IOC_SIZE(cmd))) { + dma_buf_put(dmabuf); + return -EFAULT; + } + + return 0; + } + } + return ret; +} + +static int sa_open(struct inode *inode, struct file *filp) +{ + struct sa_device *sadev = container_of(inode->i_cdev, + struct sa_device, chrdev); + + if (!sadev) + return -ENODEV; + + get_device(&sadev->dev); + filp->private_data = sadev; + return 0; +} + +static int sa_release(struct inode *inode, struct file *filp) +{ + struct sa_device *sadev = container_of(inode->i_cdev, + struct sa_device, chrdev); + + if (!sadev) + return -ENODEV; + + put_device(&sadev->dev); + return 0; +} + +static const struct file_operations sa_fops = { + .owner = THIS_MODULE, + .open = sa_open, + .release = sa_release, + .unlocked_ioctl = sa_ioctl, +}; + +/** + * simple_allocator_register - register a simple allocator + * @sadev: simple allocator structure to be registered + * + * Return 0 if allocator has been regsitered, either a negative value. + */ +int simple_allocator_register(struct sa_device *sadev) +{ + int ret; + + if (!sadev->name || !sadev->allocate || !sadev->owner) + return -EINVAL; + + cdev_init(&sadev->chrdev, &sa_fops); + sadev->chrdev.owner = sadev->owner; + + ret = cdev_add(&sadev->chrdev, MKDEV(SA_MAJOR, sa_minor), 1); + if (ret < 0) + return ret; + + sadev->dev.class = &sa_class; + sadev->dev.devt = MKDEV(SA_MAJOR, sa_minor); + dev_set_name(&sadev->dev, "%s%d", sadev->name, sa_minor); + ret = device_register(&sadev->dev); + if (ret < 0) + goto cleanup; + + sa_minor++; + return 0; + +cleanup: + cdev_del(&sadev->chrdev); + return ret; +} +EXPORT_SYMBOL_GPL(simple_allocator_register); + +/** + * simple_allocator_unregister - unregister a simple allocator + * @sadev: simple allocator device to be unregistered + */ +void simple_allocator_unregister(struct sa_device *sadev) +{ + if (!sadev) + return; + + cdev_del(&sadev->chrdev); + device_del(&sadev->dev); + put_device(&sadev->dev); +} +EXPORT_SYMBOL_GPL(simple_allocator_unregister); + +static int __init sa_init(void) +{ + dev_t dev = MKDEV(SA_MAJOR, 0); + int ret; + + ret = register_chrdev_region(dev, SA_NUM_DEVICES, SA_NAME); + if (ret < 0) + return ret; + + ret = class_register(&sa_class); + if (ret < 0) { + unregister_chrdev_region(dev, SA_NUM_DEVICES); + return -EIO; + } + + return 0; +} + +static void __exit sa_exit(void) +{ + dev_t dev = MKDEV(SA_MAJOR, 0); + + class_unregister(&sa_class); + unregister_chrdev_region(dev, SA_NUM_DEVICES); +} + +subsys_initcall(sa_init); +module_exit(sa_exit); + +MODULE_AUTHOR("Benjamin Gaignard benjamin.gaignard@linaro.org"); +MODULE_DESCRIPTION("Simple allocator"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS_CHARDEV_MAJOR(SA_MAJOR); diff --git a/include/uapi/linux/simple-allocator.h b/include/uapi/linux/simple-allocator.h new file mode 100644 index 0000000..5520a85 --- /dev/null +++ b/include/uapi/linux/simple-allocator.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) Linaro 2016 + * + * Author: Benjamin Gaignard benjamin.gaignard@linaro.org + * + * License terms: GNU General Public License (GPL), version 2 + */ + +#ifndef _SIMPLE_ALLOCATOR_H_ +#define _SIMPLE_ALLOCATOR_H_ + +#include <linux/ioctl.h> +#include <linux/types.h> + +/** + * struct simple_allocate_data - allocation parameters + * @version: structure version (must be set to 0) + * @length: size of the requested buffer + * @flags: mode flags for the file like O_RDWR or O_CLOEXEC + * @fd: returned file descriptor + */ +struct simple_allocate_data { + __u64 version; + __u64 length; + __u32 flags; + __u32 reserved1; + __s32 fd; + __u32 reserved2; +}; + +#define SA_IOC_MAGIC 'S' + +#define SA_IOC_ALLOC _IOWR(SA_IOC_MAGIC, 0, struct simple_allocate_data) + +#endif
This patch add simple allocator for CMA regions
Signed-off-by: Benjamin Gaignard benjamin.gaignard@linaro.org --- drivers/simpleallocator/Kconfig | 7 + drivers/simpleallocator/Makefile | 1 + drivers/simpleallocator/simple-allocator-cma.c | 187 +++++++++++++++++++++++++ 3 files changed, 195 insertions(+) create mode 100644 drivers/simpleallocator/simple-allocator-cma.c
diff --git a/drivers/simpleallocator/Kconfig b/drivers/simpleallocator/Kconfig index c6fc2e3..788fb0b 100644 --- a/drivers/simpleallocator/Kconfig +++ b/drivers/simpleallocator/Kconfig @@ -7,4 +7,11 @@ config SIMPLE_ALLOCATOR The Simple Allocator Framework adds an API to allocate and share memory in userland.
+config SIMPLE_ALLOCATOR_CMA + tristate "Simple Allocator CMA" + select SIMPLE_ALLOCATOR + depends on DMA_CMA + ---help--- + Select this option to enable Simple Allocator on CMA area. + endmenu diff --git a/drivers/simpleallocator/Makefile b/drivers/simpleallocator/Makefile index e27c6ad..4e11611 100644 --- a/drivers/simpleallocator/Makefile +++ b/drivers/simpleallocator/Makefile @@ -1 +1,2 @@ obj-$(CONFIG_SIMPLE_ALLOCATOR) += simple-allocator.o +obj-$(CONFIG_SIMPLE_ALLOCATOR_CMA) += simple-allocator-cma.o diff --git a/drivers/simpleallocator/simple-allocator-cma.c b/drivers/simpleallocator/simple-allocator-cma.c new file mode 100644 index 0000000..b240913 --- /dev/null +++ b/drivers/simpleallocator/simple-allocator-cma.c @@ -0,0 +1,187 @@ +/* + * Copyright (C) Linaro 2017 + * + * Author: Benjamin Gaignard benjamin.gaignard@linaro.org + * + * License terms: GNU General Public License (GPL) + */ + +#include <linux/cma.h> +#include <linux/module.h> +#include <linux/slab.h> + +#include "simple-allocator-priv.h" +#include "../mm/cma.h" + +struct sa_cma_device { + struct sa_device parent; + struct cma *cma; +}; + +struct sa_cma_buffer_info { + void *vaddr; + size_t count; + size_t size; + struct page *pages; + struct sa_cma_device *sa_cma; +}; + +static struct sa_cma_device *sa_cma[MAX_CMA_AREAS]; + +static inline struct sa_cma_device *to_sa_cma(struct sa_device *sadev) +{ + return container_of(sadev, struct sa_cma_device, parent); +} + +static struct sg_table *sa_cma_map_dma_buf(struct dma_buf_attachment *attach, + enum dma_data_direction direction) +{ + struct dma_buf *dmabuf = attach->dmabuf; + struct sa_cma_buffer_info *info = dmabuf->priv; + struct sg_table *sgt; + int ret; + + ret = sg_alloc_table(sgt, 1, GFP_KERNEL); + if (unlikely(ret)) + return NULL; + + sg_set_page(sgt->sgl, info->pages, PAGE_ALIGN(info->size), 0); + sg_dma_address(sgt->sgl) = (dma_addr_t) page_address(info->pages); + sg_dma_len(sgt->sgl) = PAGE_ALIGN(info->size); + + return sgt; +} + +static void sa_cma_unmap_dma_buf(struct dma_buf_attachment *attach, + struct sg_table *sgt, + enum dma_data_direction dir) +{ + kfree(sgt); +} + +static int sa_cma_mmap_dma_buf(struct dma_buf *dmabuf, + struct vm_area_struct *vma) +{ + struct sa_cma_buffer_info *info = dmabuf->priv; + unsigned long user_count = vma_pages(vma); + unsigned long count = info->count; + unsigned long pfn = page_to_pfn(info->pages); + unsigned long off = vma->vm_pgoff; + int ret = -ENXIO; + + if (off < count && user_count <= (count - off)) { + ret = remap_pfn_range(vma, vma->vm_start, + pfn + off, + user_count << PAGE_SHIFT, + vma->vm_page_prot); + } + + return ret; +} + +static void sa_cma_release_dma_buf(struct dma_buf *dmabuf) +{ + struct sa_cma_buffer_info *info = dmabuf->priv; + + cma_release(info->sa_cma->cma, info->pages, info->count); + + kfree(info); +} + +static void *sa_cma_kmap_dma_buf(struct dma_buf *dmabuf, unsigned long offset) +{ + struct sa_cma_buffer_info *info = dmabuf->priv; + + return page_address(info->pages) + offset; +} + +static struct dma_buf_ops sa_dma_buf_ops = { + .map_dma_buf = sa_cma_map_dma_buf, + .unmap_dma_buf = sa_cma_unmap_dma_buf, + .mmap = sa_cma_mmap_dma_buf, + .release = sa_cma_release_dma_buf, + .kmap_atomic = sa_cma_kmap_dma_buf, + .kmap = sa_cma_kmap_dma_buf, +}; + +static struct dma_buf *sa_cma_allocate(struct sa_device *sadev, + u64 length, u32 flags) +{ + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + struct sa_cma_buffer_info *info; + struct dma_buf *dmabuf; + + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) + return NULL; + + info->count = round_up(length, PAGE_SIZE); + info->size = length; + info->sa_cma = to_sa_cma(sadev); + + info->pages = cma_alloc(info->sa_cma->cma, info->count, 0); + + if (!info->pages) + goto cleanup; + + exp_info.ops = &sa_dma_buf_ops; + exp_info.size = info->size; + exp_info.flags = flags; + exp_info.priv = info; + + dmabuf = dma_buf_export(&exp_info); + if (IS_ERR(dmabuf)) + goto export_failed; + + return dmabuf; + +export_failed: + cma_release(info->sa_cma->cma, info->pages, info->count); +cleanup: + kfree(info); + return NULL; +} + +struct sa_cma_device *simple_allocator_register_cma(struct cma *cma) +{ + struct sa_cma_device *sa_cma; + int ret; + + sa_cma = kzalloc(sizeof(*sa_cma), GFP_KERNEL); + if (!sa_cma) + return NULL; + + sa_cma->cma = cma; + sa_cma->parent.owner = THIS_MODULE; + sa_cma->parent.name = "cma"; + sa_cma->parent.allocate = sa_cma_allocate; + + ret = simple_allocator_register(&sa_cma->parent); + if (ret) { + kfree(sa_cma); + return NULL; + } + + return sa_cma; +} + +static int __init sa_cma_init(void) +{ + int i; + + for (i = 0; i < cma_area_count; i++) + sa_cma[i] = simple_allocator_register_cma(&cma_areas[i]); + + return 0; +} + +static void __exit sa_cma_exit(void) +{ + int i; + + for (i = 0; i < cma_area_count; i++) + simple_allocator_unregister(&sa_cma[i]->parent); +} + +module_init(sa_cma_init); +module_exit(sa_cma_exit);
On Fri, Jan 20, 2017 at 04:32:29PM +0100, Benjamin Gaignard wrote:
The goal of this RFC is to understand if a common ioctl for specific memory regions allocations is needed/welcome.
Obviously it will not replace allocation done in linux kernel frameworks like v4l2, drm/kms or others, but offer an alternative when you don't want/need to use them for buffer allocation. To keep a compatibility with what already exist allocated buffers are exported in userland as dmabuf file descriptor (like ION is doing).
"Unix Device Memory Allocator" project [1] wants to create a userland library which may allow to select, depending of the devices constraint, the best back-end for allocation. With this RFC I would to propose to have common ioctl for a maximum of allocators to avoid to duplicated back-ends for this library.
One of the issues that lead me to propose this RFC it is that since the beginning it is a problem to allocate contiguous memory (CMA) without using v4l2 or drm/kms so the first allocator available in this RFC use CMA memory.
An other question is: do we have others memory regions that could be interested by this new framework ? I have in mind that some title memory regions could use it or replace ION heaps (system, carveout, etc...). Maybe it only solve CMA allocation issue, in this case there is no need to create a new framework but only a dedicated ioctl.
Maybe the first thing to do is to change the name and the location of this module, suggestions are welcome.
I have testing this code with the following program:
I'm still maintaining that we should just destage ION (with the todo items fixed), since that is already an uabi to do this (afaiui at least), and it's used on a few devices ... Please chat with Laura Abott. -Daniel
#include <errno.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/ioctl.h> #include <sys/mman.h> #include <sys/stat.h> #include <sys/types.h>
#include "simple-allocator.h"
#define LENGTH 1024*16
void main (void) { struct simple_allocate_data data; int fd = open("/dev/cma0", O_RDWR, 0); int ret; void *mem;
if (fd < 0) { printf("Can't open /dev/cma0\n"); return; }
memset(&data, 0, sizeof(data));
data.length = LENGTH; data.flags = O_RDWR | O_CLOEXEC;
ret = ioctl(fd, SA_IOC_ALLOC, &data); if (ret) { printf("Buffer allocation failed\n"); goto end; }
mem = mmap(0, LENGTH, PROT_READ | PROT_WRITE, MAP_SHARED, data.fd, 0); if (mem == MAP_FAILED) { printf("mmap failed\n"); }
memset(mem, 0xFF, LENGTH); munmap(mem, LENGTH);
printf("test simple allocator CMA OK\n"); end: close(fd); }
[1] https://github.com/cubanismo/allocator
Benjamin Gaignard (2): Create Simple Allocator module add CMA simple allocator module
Documentation/simple-allocator.txt | 81 ++++++++++ drivers/Kconfig | 2 + drivers/Makefile | 1 + drivers/simpleallocator/Kconfig | 17 +++ drivers/simpleallocator/Makefile | 2 + drivers/simpleallocator/simple-allocator-cma.c | 187 ++++++++++++++++++++++++ drivers/simpleallocator/simple-allocator-priv.h | 33 +++++ drivers/simpleallocator/simple-allocator.c | 180 +++++++++++++++++++++++ include/uapi/linux/simple-allocator.h | 35 +++++ 9 files changed, 538 insertions(+) create mode 100644 Documentation/simple-allocator.txt create mode 100644 drivers/simpleallocator/Kconfig create mode 100644 drivers/simpleallocator/Makefile create mode 100644 drivers/simpleallocator/simple-allocator-cma.c create mode 100644 drivers/simpleallocator/simple-allocator-priv.h create mode 100644 drivers/simpleallocator/simple-allocator.c create mode 100644 include/uapi/linux/simple-allocator.h
-- 1.9.1
On 01/23/2017 09:35 AM, Daniel Vetter wrote:
On Fri, Jan 20, 2017 at 04:32:29PM +0100, Benjamin Gaignard wrote:
The goal of this RFC is to understand if a common ioctl for specific memory regions allocations is needed/welcome.
Obviously it will not replace allocation done in linux kernel frameworks like v4l2, drm/kms or others, but offer an alternative when you don't want/need to use them for buffer allocation. To keep a compatibility with what already exist allocated buffers are exported in userland as dmabuf file descriptor (like ION is doing).
"Unix Device Memory Allocator" project [1] wants to create a userland library which may allow to select, depending of the devices constraint, the best back-end for allocation. With this RFC I would to propose to have common ioctl for a maximum of allocators to avoid to duplicated back-ends for this library.
One of the issues that lead me to propose this RFC it is that since the beginning it is a problem to allocate contiguous memory (CMA) without using v4l2 or drm/kms so the first allocator available in this RFC use CMA memory.
An other question is: do we have others memory regions that could be interested by this new framework ? I have in mind that some title memory regions could use it or replace ION heaps (system, carveout, etc...). Maybe it only solve CMA allocation issue, in this case there is no need to create a new framework but only a dedicated ioctl.
Maybe the first thing to do is to change the name and the location of this module, suggestions are welcome.
I have testing this code with the following program:
I'm still maintaining that we should just destage ION (with the todo items fixed), since that is already an uabi to do this (afaiui at least), and it's used on a few devices ... Please chat with Laura Abott. -Daniel
(I thought I sent this before but apparently it didn't go through. Apologies if this ends up as a repeat for anyone)
I've been reviewing this as well. Even if Ion is used on a number of devices, the model is still a bit clunky. I was hoping to see if it could be re-written from scratch in a framework like this and then either add a shim layer or just coax all devices out there to actually convert to the new framework.
I supposed another option is to destage as you suggested and work on an improved version in parallel.
Thanks, Laura
linaro-kernel@lists.linaro.org
-
Benjamin Gaignard -
Daniel Vetter -
Laura Abbott