Linaro-mm-sig

linaro-mm-sig@lists.linaro.org

1 participants
2905 discussions

[PATCH 6/9] async: Add a convenience wrapper for waiting on implicit dma-buf

by Chris Wilson

dma-buf implicitly track their (DMA) rendering using a reservation_object, which tracks ether the last write (in an exclusive fence) or the current renders (with a set of shared fences). To wait upon a reservation object in conjunction with other sources, kfence_add_reservation() extracts the DMA fences from the object and adds the individual waits for the kfence. Signed-off-by: Chris Wilson <chris(a)chris-wilson.co.uk> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Shuah Khan <shuahkh(a)osg.samsung.com> Cc: Tejun Heo <tj(a)kernel.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Ingo Molnar <mingo(a)kernel.org> Cc: Kees Cook <keescook(a)chromium.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Andrey Ryabinin <aryabinin(a)virtuozzo.com> Cc: Davidlohr Bueso <dave(a)stgolabs.net> Cc: Nikolay Aleksandrov <nikolay(a)cumulusnetworks.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: "Peter Zijlstra (Intel)" <peterz(a)infradead.org> Cc: Rasmus Villemoes <linux(a)rasmusvillemoes.dk> Cc: Andy Shevchenko <andriy.shevchenko(a)linux.intel.com> Cc: Dmitry Vyukov <dvyukov(a)google.com> Cc: Alexander Potapenko <glider(a)google.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-media(a)vger.kernel.org Cc: dri-devel(a)lists.freedesktop.org Cc: linaro-mm-sig(a)lists.linaro.org --- include/linux/kfence.h | 5 ++++ kernel/async.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 65 insertions(+), 5 deletions(-) diff --git a/include/linux/kfence.h b/include/linux/kfence.h index 1abec5e6b23c..2f01eb052e4d 100644 --- a/include/linux/kfence.h +++ b/include/linux/kfence.h @@ -17,6 +17,7 @@ struct completion; struct fence; enum hrtimer_mode; +struct reservation_object; struct kfence { wait_queue_head_t wait; @@ -34,6 +35,10 @@ extern int kfence_add_completion(struct kfence *fence, extern int kfence_add_dma(struct kfence *fence, struct fence *dma, gfp_t gfp); +extern int kfence_add_reservation(struct kfence *fence, + struct reservation_object *resv, + bool write, + gfp_t gfp); extern int kfence_add_delay(struct kfence *fence, clockid_t clock, enum hrtimer_mode mode, ktime_t delay, u64 slack, diff --git a/kernel/async.c b/kernel/async.c index 5d02445e36b7..1fa1f39b5a74 100644 --- a/kernel/async.c +++ b/kernel/async.c @@ -54,9 +54,10 @@ asynchronous and synchronous parts of the kernel. #include <linux/kfence.h> #include <linux/ktime.h> #include <linux/export.h> -#include <linux/wait.h> +#include <linux/reservation.h> #include <linux/sched.h> #include <linux/slab.h> +#include <linux/wait.h> #include <linux/workqueue.h> #include "workqueue_internal.h" @@ -123,11 +124,17 @@ static atomic_t entry_count; * allowing multiple pending / signals to be sent before the kfence is * complete. * - * kfence_add() / kfence_add_completion() / kfence_add_dma() + * kfence_add() / kfence_add_completion() + * / kfence_add_dma() + * + * sets the kfence to wait upon another fence or completion respectively. To + * wait upon DMA activity, either use * - * sets the kfence to wait upon another fence, completion, or DMA fence - * respectively. To set the fence to wait for at least a certain period of - * time, or until after a certain point in time, use + * kfence_add_dma() or kfence_add_reservation() + * + * depending on the manner of DMA activity tracking. To set the fence to wait + * for at least a certain period of time, or until after a certain point in + * time, use * * kfence_add_timer() * @@ -547,6 +554,54 @@ int kfence_add_dma(struct kfence *fence, struct fence *dma, gfp_t gfp) EXPORT_SYMBOL_GPL(kfence_add_dma); /** + * kfence_add_reservation - set the fence to wait upon a reservation_object + * @fence: this kfence + * @resv: target reservation_object (collection of DMA fences) to wait upon + * @write: Wait for read or read/write access + * @gfp: the allowed allocation type + * + * kfence_add_reservation() causes the @fence to wait upon completion of the + * reservation object (a collection of DMA fences), either for read access + * or for read/write access. + * + * Returns 1 if the @fence was successfully to the waitqueues of @resv, 0 + * if @resev was already signaled (and so not added), or a negative error code. + */ +int kfence_add_reservation(struct kfence *fence, + struct reservation_object *resv, + bool write, + gfp_t gfp) +{ + struct fence *excl, **shared; + unsigned count, i; + int ret; + + ret = reservation_object_get_fences_rcu(resv, &excl, &count, &shared); + if (ret) + return ret; + + if (write) { + for (i = 0; i < count; i++) { + ret |= kfence_add_dma(fence, shared[i], gfp); + if (ret < 0) + goto out; + } + } + + if (excl) + ret |= kfence_add_dma(fence, excl, gfp); + +out: + fence_put(excl); + for (i = 0; i < count; i++) + fence_put(shared[i]); + kfree(shared); + + return ret; +} +EXPORT_SYMBOL_GPL(kfence_add_reservation); + +/** * kfence_add_delay - set the fence to wait for a period of time * @fence: this kfence * @clock: which clock to program -- 2.8.1

9 years

[PATCH 4/9] async: Extend kfences for listening on DMA fences

by Chris Wilson

dma-buf provides an interfaces for receiving notifications from DMA hardware. kfence provides a useful interface for collecting such fences and combining them with other events. Signed-off-by: Chris Wilson <chris(a)chris-wilson.co.uk> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Shuah Khan <shuahkh(a)osg.samsung.com> Cc: Tejun Heo <tj(a)kernel.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: Andrew Morton <akpm(a)linux-foundation.org> Cc: Ingo Molnar <mingo(a)kernel.org> Cc: Kees Cook <keescook(a)chromium.org> Cc: Thomas Gleixner <tglx(a)linutronix.de> Cc: "Paul E. McKenney" <paulmck(a)linux.vnet.ibm.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Andrey Ryabinin <aryabinin(a)virtuozzo.com> Cc: Davidlohr Bueso <dave(a)stgolabs.net> Cc: Nikolay Aleksandrov <nikolay(a)cumulusnetworks.com> Cc: "David S. Miller" <davem(a)davemloft.net> Cc: "Peter Zijlstra (Intel)" <peterz(a)infradead.org> Cc: Rasmus Villemoes <linux(a)rasmusvillemoes.dk> Cc: Andy Shevchenko <andriy.shevchenko(a)linux.intel.com> Cc: Dmitry Vyukov <dvyukov(a)google.com> Cc: Alexander Potapenko <glider(a)google.com> Cc: linux-kernel(a)vger.kernel.org Cc: linux-media(a)vger.kernel.org Cc: dri-devel(a)lists.freedesktop.org Cc: linaro-mm-sig(a)lists.linaro.org --- include/linux/kfence.h | 4 ++++ kernel/async.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 65 insertions(+), 2 deletions(-) diff --git a/include/linux/kfence.h b/include/linux/kfence.h index 82096bfafaa1..d71f30c626ae 100644 --- a/include/linux/kfence.h +++ b/include/linux/kfence.h @@ -15,6 +15,7 @@ #include <linux/wait.h> struct completion; +struct fence; struct kfence { wait_queue_head_t wait; @@ -29,6 +30,9 @@ extern int kfence_add(struct kfence *fence, struct kfence *after, gfp_t gfp); extern int kfence_add_completion(struct kfence *fence, struct completion *x, gfp_t gfp); +extern int kfence_add_dma(struct kfence *fence, + struct fence *dma, + gfp_t gfp); extern void kfence_pending(struct kfence *fence); extern void kfence_signal(struct kfence *fence); extern void kfence_wait(struct kfence *fence); diff --git a/kernel/async.c b/kernel/async.c index db22b890711e..01552d23a916 100644 --- a/kernel/async.c +++ b/kernel/async.c @@ -50,6 +50,7 @@ asynchronous and synchronous parts of the kernel. #include <linux/async.h> #include <linux/atomic.h> +#include <linux/fence.h> #include <linux/kfence.h> #include <linux/ktime.h> #include <linux/export.h> @@ -122,9 +123,10 @@ static atomic_t entry_count; * allowing multiple pending / signals to be sent before the kfence is * complete. * - * kfence_add() / kfence_add_completion() + * kfence_add() / kfence_add_completion() / kfence_add_dma() * - * sets the kfence to wait upon another fence, or completion respectively. + * sets the kfence to wait upon another fence, completion, or DMA fence + * respectively. * * Unlike completions, kfences are expected to live inside more complex graphs * and form the basis for parallel execution of interdependent and so are @@ -484,6 +486,63 @@ int kfence_add_completion(struct kfence *fence, struct completion *x, gfp_t gfp) } EXPORT_SYMBOL_GPL(kfence_add_completion); +struct dma_fence_cb { + struct fence_cb base; + struct kfence *fence; +}; + +static void dma_kfence_wake(struct fence *dma, struct fence_cb *data) +{ + struct dma_fence_cb *cb = container_of(data, typeof(*cb), base); + kfence_signal(cb->fence); + kfence_put(cb->fence); + kfree(cb); +} + +/** + * kfence_add_dma - set the fence to wait upon a DMA fence + * @fence: this kfence + * @dma: target DMA fence to wait upon + * @gfp: the allowed allocation type + * + * kfence_add_dma() causes the @fence to wait upon completion of a DMA fence. + * + * Returns 1 if the @fence was successfully to the waitqueue of @dma, 0 + * if @dma was already signaled (and so not added), or a negative error code. + */ +int kfence_add_dma(struct kfence *fence, struct fence *dma, gfp_t gfp) +{ + struct dma_fence_cb *cb; + int ret; + + if (!dma || fence_is_signaled(dma)) + return 0; + + cb = kmalloc(sizeof(*cb), gfp); + if (!cb) { + if (!gfpflags_allow_blocking(gfp)) + return -ENOMEM; + + return fence_wait(dma, false); + } + + cb->fence = kfence_get(fence); + kfence_pending(fence); + + ret = fence_add_callback(dma, &cb->base, dma_kfence_wake); + if (ret == 0) { + /* signal fence add and is pending */ + ret = 1; + } else { + dma_kfence_wake(dma, &cb->base); + if (ret == -ENOENT) /* fence already signaled */ + ret = 0; + } + + return ret; +} +EXPORT_SYMBOL_GPL(kfence_add_dma); + static async_cookie_t lowest_in_progress(struct async_domain *domain) { struct list_head *pending; -- 2.8.1

9 years

[PATCH v4 0/4] Generic zpos property

by Benjamin Gaignard

version 4: make sure that normalized zpos value is stay in the defined property range and warn user if not. Fix NULL pointer bug in rcar-du while setting zpos value. No changes in the other drivers. version 3: use kmalloc_array instead of kmalloc. Correct normalize_zpos computation (comeback to Mareck original code) version 2: add a zpos property into drm_plane structure to simplify code. This allow to get/set zpos value in core and not in drivers code. Fix various remarks. version 1: refactor Marek's patches to have per plane zpos property instead of only one in core. Benjamin Gaignard (3): drm: add generic zpos property drm: sti: use generic zpos for plane drm: rcar: use generic code for managing zpos plane property Marek Szyprowski (1): drm/exynos: use generic code for managing zpos plane property Documentation/DocBook/gpu.tmpl | 10 ++ drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_atomic.c | 4 + drivers/gpu/drm/drm_atomic_helper.c | 6 + drivers/gpu/drm/drm_blend.c | 230 ++++++++++++++++++++++++++++++ drivers/gpu/drm/drm_crtc_internal.h | 3 + drivers/gpu/drm/exynos/exynos_drm_drv.h | 2 - drivers/gpu/drm/exynos/exynos_drm_plane.c | 67 ++------- drivers/gpu/drm/exynos/exynos_mixer.c | 6 +- drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 2 +- drivers/gpu/drm/rcar-du/rcar_du_drv.h | 1 - drivers/gpu/drm/rcar-du/rcar_du_kms.c | 5 - drivers/gpu/drm/rcar-du/rcar_du_plane.c | 9 +- drivers/gpu/drm/rcar-du/rcar_du_plane.h | 2 - drivers/gpu/drm/sti/sti_mixer.c | 9 +- drivers/gpu/drm/sti/sti_plane.c | 80 ++++------- drivers/gpu/drm/sti/sti_plane.h | 2 - include/drm/drm_crtc.h | 30 ++++ 18 files changed, 331 insertions(+), 139 deletions(-) create mode 100644 drivers/gpu/drm/drm_blend.c Cc: Inki Dae <inki.dae(a)samsung.com> Cc: Daniel Vetter <daniel(a)ffwll.ch> Cc: Ville Syrjala <ville.syrjala(a)linux.intel.com> Cc: Joonyoung Shim <jy0922.shim(a)samsung.com> Cc: Seung-Woo Kim <sw0312.kim(a)samsung.com> Cc: Andrzej Hajda <a.hajda(a)samsung.com> Cc: Krzysztof Kozlowski <k.kozlowski(a)samsung.com> Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie(a)samsung.com> Cc: Tobias Jakobi <tjakobi(a)math.uni-bielefeld.de> Cc: Gustavo Padovan <gustavo(a)padovan.org> Cc: vincent.abriou(a)st.com Cc: fabien.dessenne(a)st.com Cc: Laurent Pinchart <laurent.pinchart(a)ideasonboard.com> -- 1.9.1

9 years

[PATCH 0/3] dma-buf: debugfs fixes

by Mathias Krause

This small series is the v2 of the patch posted initially here: http://www.spinics.net/lists/linux-media/msg101347.html It not only fixes the type mix-up and addresses Daniel's remark (patch 1), it also smoothes out the error handling in dma_buf_init_debugfs() (patch 2) and removes the then unneeded function dma_buf_debugfs_create_file() (patch 3). Please apply! Mathias Krause (3): dma-buf: propagate errors from dma_buf_describe() on debugfs read dma-buf: remove dma_buf directory on bufinfo file creation errors dma-buf: remove dma_buf_debugfs_create_file() drivers/dma-buf/dma-buf.c | 44 ++++++++++++++------------------------------ include/linux/dma-buf.h | 2 -- 2 files changed, 14 insertions(+), 32 deletions(-) -- 1.7.10.4

9 years

Re: [Linaro-mm-sig] [Mesa-dev] [RFC] New dma_buf -> EGLImage EGL extension - Final spec published!

by Rob Clark

So, if we wanted to extend this to support the fourcc-modifiers that we have on the kernel side for compressed/tiled/etc formats, what would be the right approach? A new version of the existing extension or a new EGL_EXT_image_dma_buf_import2 extension, or ?? BR, -R On Mon, Feb 25, 2013 at 6:54 AM, Tom Cooksey <tom.cooksey(a)arm.com> wrote: > Hi All, > > The final spec has had enum values assigned and been published on Khronos: > > http://www.khronos.org/registry/egl/extensions/EXT/EGL_EXT_image_dma_buf_im… > > Thanks to all who've provided input. > > > Cheers, > > Tom > > > >> -----Original Message----- >> From: mesa-dev-bounces+tom.cooksey=arm.com(a)lists.freedesktop.org [mailto:mesa-dev- >> bounces+tom.cooksey=arm.com(a)lists.freedesktop.org] On Behalf Of Tom Cooksey >> Sent: 04 October 2012 13:10 >> To: mesa-dev(a)lists.freedesktop.org; linaro-mm-sig(a)lists.linaro.org; dri- >> devel(a)lists.freedesktop.org; linux-media(a)vger.kernel.org >> Subject: [Mesa-dev] [RFC] New dma_buf -> EGLImage EGL extension - New draft! >> >> Hi All, >> >> After receiving a fair bit of feedback (thanks!), I've updated the >> EGL_EXT_image_dma_buf_import spec >> and expanded it to resolve a number of the issues. Please find the latest draft below and let >> me >> know any additional feedback you might have, either on the lists or by private e-mail - I >> don't mind >> which. >> >> I think the only remaining issue now is if we need a mechanism whereby an application can >> query >> which drm_fourcc.h formats EGL supports or if just failing with EGL_BAD_MATCH when the >> application >> has use one EGL doesn't support is sufficient. Any thoughts? >> >> >> Cheers, >> >> Tom >> >> >> --------------------8<-------------------- >> >> >> Name >> >> EXT_image_dma_buf_import >> >> Name Strings >> >> EGL_EXT_image_dma_buf_import >> >> Contributors >> >> Jesse Barker >> Rob Clark >> Tom Cooksey >> >> Contacts >> >> Jesse Barker (jesse 'dot' barker 'at' linaro 'dot' org) >> Tom Cooksey (tom 'dot' cooksey 'at' arm 'dot' com) >> >> Status >> >> DRAFT >> >> Version >> >> Version 4, October 04, 2012 >> >> Number >> >> EGL Extension ??? >> >> Dependencies >> >> EGL 1.2 is required. >> >> EGL_KHR_image_base is required. >> >> The EGL implementation must be running on a Linux kernel supporting the >> dma_buf buffer sharing mechanism. >> >> This extension is written against the wording of the EGL 1.2 Specification. >> >> Overview >> >> This extension allows creating an EGLImage from a Linux dma_buf file >> descriptor or multiple file descriptors in the case of multi-plane YUV >> images. >> >> New Types >> >> None >> >> New Procedures and Functions >> >> None >> >> New Tokens >> >> Accepted by the <target> parameter of eglCreateImageKHR: >> >> EGL_LINUX_DMA_BUF_EXT >> >> Accepted as an attribute in the <attrib_list> parameter of >> eglCreateImageKHR: >> >> EGL_LINUX_DRM_FOURCC_EXT >> EGL_DMA_BUF_PLANE0_FD_EXT >> EGL_DMA_BUF_PLANE0_OFFSET_EXT >> EGL_DMA_BUF_PLANE0_PITCH_EXT >> EGL_DMA_BUF_PLANE1_FD_EXT >> EGL_DMA_BUF_PLANE1_OFFSET_EXT >> EGL_DMA_BUF_PLANE1_PITCH_EXT >> EGL_DMA_BUF_PLANE2_FD_EXT >> EGL_DMA_BUF_PLANE2_OFFSET_EXT >> EGL_DMA_BUF_PLANE2_PITCH_EXT >> EGL_YUV_COLOR_SPACE_HINT_EXT >> EGL_SAMPLE_RANGE_HINT_EXT >> EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT >> EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT >> >> Accepted as the value for the EGL_YUV_COLOR_SPACE_HINT_EXT attribute: >> >> EGL_ITU_REC601_EXT >> EGL_ITU_REC709_EXT >> EGL_ITU_REC2020_EXT >> >> Accepted as the value for the EGL_SAMPLE_RANGE_HINT_EXT attribute: >> >> EGL_YUV_FULL_RANGE_EXT >> EGL_YUV_NARROW_RANGE_EXT >> >> Accepted as the value for the EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT & >> EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT attributes: >> >> EGL_YUV_CHROMA_SITING_0_EXT >> EGL_YUV_CHROMA_SITING_0_5_EXT >> >> >> Additions to Chapter 2 of the EGL 1.2 Specification (EGL Operation) >> >> Add to section 2.5.1 "EGLImage Specification" (as defined by the >> EGL_KHR_image_base specification), in the description of >> eglCreateImageKHR: >> >> "Values accepted for <target> are listed in Table aaa, below. >> >> +-------------------------+--------------------------------------------+ >> | <target> | Notes | >> +-------------------------+--------------------------------------------+ >> | EGL_LINUX_DMA_BUF_EXT | Used for EGLImages imported from Linux | >> | | dma_buf file descriptors | >> +-------------------------+--------------------------------------------+ >> Table aaa. Legal values for eglCreateImageKHR <target> parameter >> >> ... >> >> If <target> is EGL_LINUX_DMA_BUF_EXT, <dpy> must be a valid display, <ctx> >> must be EGL_NO_CONTEXT, and <buffer> must be NULL, cast into the type >> EGLClientBuffer. The details of the image is specified by the attributes >> passed into eglCreateImageKHR. Required attributes and their values are as >> follows: >> >> * EGL_WIDTH & EGL_HEIGHT: The logical dimensions of the buffer in pixels >> >> * EGL_LINUX_DRM_FOURCC_EXT: The pixel format of the buffer, as specified >> by drm_fourcc.h and used as the pixel_format parameter of the >> drm_mode_fb_cmd2 ioctl. >> >> * EGL_DMA_BUF_PLANE0_FD_EXT: The dma_buf file descriptor of plane 0 of >> the image. >> >> * EGL_DMA_BUF_PLANE0_OFFSET_EXT: The offset from the start of the >> dma_buf of the first sample in plane 0, in bytes. >> >> * EGL_DMA_BUF_PLANE0_PITCH_EXT: The number of bytes between the start of >> subsequent rows of samples in plane 0. May have special meaning for >> non-linear formats. >> >> For images in an RGB color-space or those using a single-plane YUV format, >> only the first plane's file descriptor, offset & pitch should be specified. >> For semi-planar YUV formats, the chroma samples are stored in plane 1 and >> for fully planar formats, U-samples are stored in plane 1 and V-samples are >> stored in plane 2. Planes 1 & 2 are specified by the following attributes, >> which have the same meanings as defined above for plane 0: >> >> * EGL_DMA_BUF_PLANE1_FD_EXT >> * EGL_DMA_BUF_PLANE1_OFFSET_EXT >> * EGL_DMA_BUF_PLANE1_PITCH_EXT >> * EGL_DMA_BUF_PLANE2_FD_EXT >> * EGL_DMA_BUF_PLANE2_OFFSET_EXT >> * EGL_DMA_BUF_PLANE2_PITCH_EXT >> >> In addition to the above required attributes, the application may also >> provide hints as to how the data should be interpreted by the GL. If any of >> these hints are not specified, the GL will guess based on the pixel format >> passed as the EGL_LINUX_DRM_FOURCC_EXT attribute or may fall-back to some >> default value. Not all GLs will be able to support all combinations of >> these hints and are free to use whatever settings they choose to achieve >> the closest possible match. >> >> * EGL_YUV_COLOR_SPACE_HINT_EXT: The color-space the data is in. Only >> relevant for images in a YUV format, ignored when specified for an >> image in an RGB format. Accepted values are: >> EGL_ITU_REC601_EXT, EGL_ITU_REC709_EXT & EGL_ITU_REC2020_EXT. >> >> * EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT & >> EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT: Where chroma samples are >> sited relative to luma samples when the image is in a sub-sampled >> format. When the image is not using chroma sub-sampling, the luma and >> chroma samples are assumed to be co-sited. Siting is split into the >> vertical and horizontal and is in a fixed range. A siting of zero >> means the first luma sample is taken from the same position in that >> dimension as the chroma sample. This is best illustrated in the >> diagram below: >> >> (0.5, 0.5) (0.0, 0.5) (0.0, 0.0) >> + + + + + + + + * + * + >> x x x x >> + + + + + + + + + + + + >> >> + + + + + + + + * + * + >> x x x x >> + + + + + + + + + + + + >> >> Luma samples (+), Chroma samples (x) Chrome & Luma samples (*) >> >> Note this attribute is ignored for RGB images and non sub-sampled >> YUV images. Accepted values are: EGL_YUV_CHROMA_SITING_0_EXT (0.0) >> & EGL_YUV_CHROMA_SITING_0_5_EXT (0.5) >> >> * EGL_SAMPLE_RANGE_HINT_EXT: The numerical range of samples. Only >> relevant for images in a YUV format, ignored when specified for >> images in an RGB format. Accepted values are: EGL_YUV_FULL_RANGE_EXT >> (0-256) & EGL_YUV_NARROW_RANGE_EXT (16-235). >> >> >> If eglCreateImageKHR is successful for a EGL_LINUX_DMA_BUF_EXT target, the >> EGL takes ownership of the file descriptor and is responsible for closing >> it, which it may do at any time while the EGLDisplay is initialized." >> >> >> Add to the list of error conditions for eglCreateImageKHR: >> >> "* If <target> is EGL_LINUX_DMA_BUF_EXT and <buffer> is not NULL, the >> error EGL_BAD_PARAMETER is generated. >> >> * If <target> is EGL_LINUX_DMA_BUF_EXT, and the list of attributes is >> incomplete, EGL_BAD_PARAMETER is generated. >> >> * If <target> is EGL_LINUX_DMA_BUF_EXT, and the EGL_LINUX_DRM_FOURCC_EXT >> attribute is set to a format not supported by the EGL, EGL_BAD_MATCH >> is generated. >> >> * If <target> is EGL_LINUX_DMA_BUF_EXT, and the EGL_LINUX_DRM_FOURCC_EXT >> attribute indicates a single-plane format, EGL_BAD_ATTRIBUTE is >> generated if any of the EGL_DMA_BUF_PLANE1_* or EGL_DMA_BUF_PLANE2_* >> attributes are specified. >> >> * If <target> is EGL_LINUX_DMA_BUF_EXT and the value specified for >> EGL_YUV_COLOR_SPACE_HINT_EXT is not EGL_ITU_REC601_EXT, >> EGL_ITU_REC709_EXT or EGL_ITU_REC2020_EXT, EGL_BAD_ATTRIBUTE is >> generated. >> >> * If <target> is EGL_LINUX_DMA_BUF_EXT and the value specified for >> EGL_SAMPLE_RANGE_HINT_EXT is not EGL_YUV_FULL_RANGE_EXT or >> EGL_YUV_NARROW_RANGE_EXT, EGL_BAD_ATTRIBUTE is generated. >> >> * If <target> is EGL_LINUX_DMA_BUF_EXT and the value specified for >> EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT or >> EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT is not >> EGL_YUV_CHROMA_SITING_0_EXT or EGL_YUV_CHROMA_SITING_0_5_EXT, >> EGL_BAD_ATTRIBUTE is generated. >> >> * If <target> is EGL_LINUX_DMA_BUF_EXT and one or more of the values >> specified for a plane's pitch or offset isn't supported by EGL, >> EGL_BAD_ACCESS is generated. >> >> * If <target> is EGL_LINUX_DMA_BUF_EXT and eglCreateImageKHR fails, >> EGL does not retain ownership of the file descriptor and it is the >> responsibility of the application to close it." >> >> >> Issues >> >> 1. Should this be a KHR or EXT extension? >> >> ANSWER: EXT. Khronos EGL working group not keen on this extension as it is >> seen as contradicting the EGLStream direction the specification is going in. >> The working group recommends creating additional specs to allow an EGLStream >> producer/consumer connected to v4l2/DRM or any other Linux interface. >> >> 2. Should this be a generic any platform extension, or a Linux-only >> extension which explicitly states the handles are dma_buf fds? >> >> ANSWER: There's currently no intention to port this extension to any OS not >> based on the Linux kernel. Consequently, this spec can be explicitly written >> against Linux and the dma_buf API. >> >> 3. Does ownership of the file descriptor pass to the EGL library? >> >> ANSWER: If eglCreateImageKHR is successful, EGL assumes ownership of the >> file descriptors and is responsible for closing them. >> >> 4. How are the different YUV color spaces handled (BT.709/BT.601)? >> >> ANSWER: The pixel formats defined in drm_fourcc.h only specify how the data >> is laid out in memory. It does not define how that data should be >> interpreted. Added a new EGL_YUV_COLOR_SPACE_HINT_EXT attribute to allow the >> application to specify which color space the data is in to allow the GL to >> choose an appropriate set of co-efficients if it needs to convert that data >> to RGB for example. >> >> 5. What chroma-siting is used for sub-sampled YUV formats? >> >> ANSWER: The chroma siting is not specified by either the v4l2 or DRM APIs. >> This is similar to the color-space issue (4) in that the chroma siting >> doesn't affect how the data is stored in memory. However, the GL will need >> to know the siting in order to filter the image correctly. While the visual >> impact of getting the siting wrong is minor, provision should be made to >> allow an application to specify the siting if desired. Added additional >> EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT & >> EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT attributes to allow the siting to >> be specified using a set of pre-defined values (0 or 0.5). >> >> 6. How can an application query which formats the EGL implementation >> supports? >> >> PROPOSAL: Don't provide a query mechanism but instead add an error condition >> that EGL_BAD_MATCH is raised if the EGL implementation doesn't support that >> particular format. >> >> 7. Which image formats should be supported and how is format specified? >> >> Seem to be two options 1) specify a new enum in this specification and >> enumerate all possible formats. 2) Use an existing enum already in Linux, >> either v4l2_mbus_pixelcode and/or those formats listed in drm_fourcc.h? >> >> ANSWER: Go for option 2) and just use values defined in drm_fourcc.h. >> >> 8. How can AYUV images be handled? >> >> ANSWER: At least on fourcc.org and in drm_fourcc.h, there only seems to be >> a single AYUV format and that is a packed format, so everything, including >> the alpha component would be in the first plane. >> >> 9. How can you import interlaced images? >> >> ANSWER: Interlaced frames are usually stored with the top & bottom fields >> interleaved in a single buffer. As the fields would need to be displayed as >> at different times, the application would create two EGLImages from the same >> buffer, one for the top field and another for the bottom. Both EGLImages >> would set the pitch to 2x the buffer width and the second EGLImage would use >> a suitable offset to indicate it started on the second line of the buffer. >> This should work regardless of whether the data is packed in a single plane, >> semi-planar or multi-planar. >> >> If each interlaced field is stored in a separate buffer then it should be >> trivial to create two EGLImages, one for each field's buffer. >> >> 10. How are semi-planar/planar formats handled that have a different >> width/height for Y' and CbCr such as YUV420? >> >> ANSWER: The spec says EGL_WIDTH & EGL_HEIGHT specify the *logical* width and >> height of the buffer in pixels. For pixel formats with sub-sampled Chroma >> values, it should be trivial for the EGL implementation to calculate the >> width/height of the Chroma sample buffers using the logical width & height >> and by inspecting the pixel format passed as the EGL_LINUX_DRM_FOURCC_EXT >> attribute. I.e. If the pixel format says it's YUV420, the Chroma buffer's >> width = EGL_WIDTH/2 & height =EGL_HEIGHT/2. >> >> 11. How are Bayer formats handled? >> >> ANSWER: As of Linux 2.6.34, drm_fourcc.h does not include any Bayer formats. >> However, future kernel versions may add such formats in which case they >> would be handled in the same way as any other format. >> >> 12. Should the spec support buffers which have samples in a "narrow range"? >> >> Content sampled from older analogue sources typically don't use the full >> (0-256) range of the data type storing the sample and instead use a narrow >> (16-235) range to allow some headroom & toeroom in the signals to avoid >> clipping signals which overshoot slightly during processing. This is >> sometimes known as signals using "studio swing". >> >> ANSWER: Add a new attribute to define if the samples use a narrow 16-235 >> range or the full 0-256 range. >> >> 13. Specifying the color space and range seems cumbersome, why not just >> allow the application to specify the full YUV->RGB color conversion matrix? >> >> ANSWER: Some hardware may not be able to use an arbitrary conversion matrix >> and needs to select an appropriate pre-defined matrix based on the color >> space and the sample range. >> >> 14. How do you handle EGL implementations which have restrictions on pitch >> and/or offset? >> >> ANSWER: Buffers being imported using dma_buf pretty much have to be >> allocated by a kernel-space driver. As such, it is expected that a system >> integrator would make sure all devices which allocate buffers suitable for >> exporting make sure they use a pitch supported by all possible importers. >> However, it is still possible eglCreateImageKHR can fail due to an >> unsupported pitch. Added a new error to the list indicating this. >> >> 15. Should this specification also describe how to export an existing >> EGLImage as a dma_buf file descriptor? >> >> ANSWER: No. Importing and exporting buffers are two separate operations and >> importing an existing dma_buf fd into an EGLImage is useful functionality in >> itself. Agree that exporting an EGLImage as a dma_buf fd is useful, E.g. it >> could be used by an OpenMAX IL implementation's OMX_UseEGLImage function to >> give access to the buffer backing an EGLImage to video hardware. However, >> exporting can be split into a separate extension specification. >> >> >> Revision History >> >> #4 (Tom Cooksey, October 04, 2012) >> - Fixed issue numbering! >> - Added issues 8 - 15. >> - Promoted proposal for Issue 3 to be the answer. >> - Added an additional attribute to allow an application to specify the color >> space as a hint which should address issue 4. >> - Added an additional attribute to allow an application to specify the chroma >> siting as a hint which should address issue 5. >> - Added an additional attribute to allow an application to specify the sample >> range as a hint which should address the new issue 12. >> - Added language to end of error section clarifying who owns the fd passed >> to eglCreateImageKHR if an error is generated. >> >> #3 (Tom Cooksey, August 16, 2012) >> - Changed name from EGL_EXT_image_external and re-written language to >> explicitly state this for use with Linux & dma_buf. >> - Added a list of issues, including some still open ones. >> >> #2 (Jesse Barker, May 30, 2012) >> - Revision to split eglCreateImageKHR functionality from export >> Functionality. >> - Update definition of EGLNativeBufferType to be a struct containing a list >> of handles to support multi-buffer/multi-planar formats. >> >> #1 (Jesse Barker, March 20, 2012) >> - Initial draft. >> >> >> >> >> _______________________________________________ >> mesa-dev mailing list >> mesa-dev(a)lists.freedesktop.org >> http://lists.freedesktop.org/mailman/listinfo/mesa-dev > > > > > _______________________________________________ > mesa-dev mailing list > mesa-dev(a)lists.freedesktop.org > http://lists.freedesktop.org/mailman/listinfo/mesa-dev

9 years

[PATCH] dma-buf: propagate errors from dma_buf_describe() on debugfs read

by Mathias Krause

The callback function dma_buf_describe() returns an int not void so the function pointer cast in dma_buf_show() is wrong. dma_buf_describe() can also fail when acquiring the mutex gets interrupted so always returning 0 in dma_buf_show() is wrong, too. Fix both issues by casting the function pointer to the correct type and propagate its return value. This type mismatch was caught by the PaX RAP plugin. Signed-off-by: Mathias Krause <minipli(a)googlemail.com> Cc: Sumit Semwal <sumit.semwal(a)linaro.org> Cc: Daniel Vetter <daniel.vetter(a)ffwll.ch> Cc: PaX Team <pageexec(a)freemail.hu> --- drivers/dma-buf/dma-buf.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index 6355ab38d630..0f2a4592fdd2 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -881,10 +881,9 @@ static int dma_buf_describe(struct seq_file *s) static int dma_buf_show(struct seq_file *s, void *unused) { - void (*func)(struct seq_file *) = s->private; + int (*func)(struct seq_file *) = s->private; - func(s); - return 0; + return func(s); } static int dma_buf_debug_open(struct inode *inode, struct file *file) -- 1.7.10.4

9 years

[PATCH 0/5] Ion cleanup

by Laura Abbott

Hi, This is some clean up of old Ion interfaces and APIs. These are interfaces that mostly existed before dma_buf was well integrated into the kernel along with reservations for board files. If there are objections to deletion I expect it to turn into a discussion about what other APIs need to be extended. Thanks, Laura Laura Abbott (5): staging: android: ion: Get rid of ion_sg_table staging: android: ion: Drop ion_phys interface staging: android: ion: Get rid of map_dma/unmap_dma staging: android: ion: Drop ion_carveout_allocate definitions staging: android: ion: Get rid of ion_reserve drivers/staging/android/ion/ion.c | 103 ++---------------------- drivers/staging/android/ion/ion.h | 41 ---------- drivers/staging/android/ion/ion_carveout_heap.c | 33 +------- drivers/staging/android/ion/ion_chunk_heap.c | 17 +--- drivers/staging/android/ion/ion_cma_heap.c | 34 +------- drivers/staging/android/ion/ion_priv.h | 30 +------ drivers/staging/android/ion/ion_system_heap.c | 44 +--------- 7 files changed, 19 insertions(+), 283 deletions(-) -- 2.5.5

9 years

Re: [Linaro-mm-sig] [RFC][PATCH 6/6] staging: android: ion: Introduce new ioctls for dynamic heaps

by Laura Abbott

On 06/08/2016 08:34 AM, Brian Starkey wrote: > Hi, > > I'm finding "usage_id" a bit confusing - there's not a very clear > distinction between usage_id and heap ID. > > For instance, ION_IOC_USAGE_CNT claims to return the number of usage > IDs, but seems to return the number of heaps (i.e. number heap IDs, some > of which might be usage_ids). > > Similarly, alloc2 claims to allocate by usage_id, but will just as > happily allocate by heap ID. > > Maybe this should just be described as a single heap ID namespace, where > some IDs represent groups of heap IDs. > For now I'm just going to focus on comments not about the heap ID mapping because I'm leaning towards dropping the heap ID mapping. > I've a few inline comments below. > > -Brian > > On Mon, Jun 06, 2016 at 11:23:33AM -0700, Laura Abbott wrote: >> From: Laura Abbott <labbott(a)fedoraproject.org> >> >> >> The Ion ABI for heaps is limiting to work with for more complex systems. >> Heaps have to be registered at boot time with known ids available to >> userspace. This becomes a tight ABI which is prone to breakage. >> >> Introduce a new mechanism for registering heap ids dynamically. A base >> set of heap ids are registered at boot time but there is no knowledge >> of fallbacks. Fallback information can be remapped and changed >> dynamically. Information about available heaps can also be queried with >> an ioctl to avoid the need to have heap ids be an ABI with userspace. >> >> Signed-off-by: Laura Abbott <labbott(a)redhat.com> >> --- >> drivers/staging/android/ion/ion-ioctl.c | 109 +++++++++++++++++-- >> drivers/staging/android/ion/ion.c | 184 ++++++++++++++++++++++++++++++-- >> drivers/staging/android/ion/ion_priv.h | 15 +++ >> drivers/staging/android/uapi/ion.h | 135 +++++++++++++++++++++++ >> 4 files changed, 426 insertions(+), 17 deletions(-) >> >> diff --git a/drivers/staging/android/ion/ion-ioctl.c b/drivers/staging/android/ion/ion-ioctl.c >> index 45b89e8..169cad8 100644 >> --- a/drivers/staging/android/ion/ion-ioctl.c >> +++ b/drivers/staging/android/ion/ion-ioctl.c >> @@ -22,6 +22,49 @@ >> #include "ion_priv.h" >> #include "compat_ion.h" >> >> +union ion_ioctl_arg { >> + struct ion_fd_data fd; >> + struct ion_allocation_data allocation; >> + struct ion_handle_data handle; >> + struct ion_custom_data custom; >> + struct ion_abi_version abi_version; >> + struct ion_new_alloc_data allocation2; >> + struct ion_usage_id_map id_map; >> + struct ion_usage_cnt usage_cnt; >> + struct ion_heap_query query; >> +}; >> + >> +static int validate_ioctl_arg(unsigned int cmd, union ion_ioctl_arg *arg) >> +{ >> + int ret = 0; >> + >> + switch (cmd) { >> + case ION_IOC_ABI_VERSION: >> + ret = arg->abi_version.reserved != 0; >> + break; >> + case ION_IOC_ALLOC2: >> + ret = arg->allocation2.reserved0 != 0; >> + ret |= arg->allocation2.reserved1 != 0; >> + ret |= arg->allocation2.reserved2 != 0; >> + break; >> + case ION_IOC_ID_MAP: >> + ret = arg->id_map.reserved0 != 0; >> + ret |= arg->id_map.reserved1 != 0; >> + break; >> + case ION_IOC_USAGE_CNT: >> + ret = arg->usage_cnt.reserved != 0; >> + break; >> + case ION_IOC_HEAP_QUERY: >> + ret = arg->query.reserved0 != 0; >> + ret |= arg->query.reserved1 != 0; >> + ret |= arg->query.reserved2 != 0; >> + break; >> + default: >> + break; >> + } >> + return ret ? -EINVAL : 0; >> +} >> + >> /* fix up the cases where the ioctl direction bits are incorrect */ >> static unsigned int ion_ioctl_dir(unsigned int cmd) >> { >> @@ -42,14 +85,7 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> struct ion_handle *cleanup_handle = NULL; >> int ret = 0; >> unsigned int dir; >> - >> - union { >> - struct ion_fd_data fd; >> - struct ion_allocation_data allocation; >> - struct ion_handle_data handle; >> - struct ion_custom_data custom; >> - struct ion_abi_version abi_version; >> - } data; >> + union ion_ioctl_arg data; >> >> dir = ion_ioctl_dir(cmd); >> >> @@ -60,7 +96,12 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> if (copy_from_user(&data, (void __user *)arg, _IOC_SIZE(cmd))) >> return -EFAULT; >> >> + ret = validate_ioctl_arg(cmd, &data); >> + if (ret) >> + return ret; >> + >> switch (cmd) { >> + /* Old ioctl */ >> case ION_IOC_ALLOC: >> { >> struct ion_handle *handle; >> @@ -77,6 +118,7 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> cleanup_handle = handle; >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_FREE: >> { >> struct ion_handle *handle; >> @@ -92,6 +134,7 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> mutex_unlock(&client->lock); >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_SHARE: >> case ION_IOC_MAP: >> { >> @@ -106,6 +149,7 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> ret = data.fd.fd; >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_IMPORT: >> { >> struct ion_handle *handle; >> @@ -117,11 +161,13 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> data.handle.handle = handle->id; >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_SYNC: >> { >> ret = ion_sync_for_device(client, data.fd.fd); >> break; >> } >> + /* Old ioctl */ >> case ION_IOC_CUSTOM: >> { >> if (!dev->custom_ioctl) >> @@ -135,6 +181,53 @@ long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >> data.abi_version.abi_version = ION_ABI_VERSION; >> break; >> } >> + case ION_IOC_ALLOC2: >> + { >> + struct ion_handle *handle; >> + >> + handle = ion_alloc2(client, data.allocation2.len, >> + data.allocation2.align, >> + data.allocation2.usage_id, >> + data.allocation2.flags); >> + if (IS_ERR(handle)) >> + return PTR_ERR(handle); >> + >> + if (data.allocation2.flags & ION_FLAG_NO_HANDLE) { >> + data.allocation2.fd = ion_share_dma_buf_fd(client, >> + handle); >> + ion_handle_put(handle); >> + if (data.allocation2.fd < 0) >> + ret = data.allocation2.fd; >> + } else { >> + data.allocation2.handle = handle->id; >> + >> + cleanup_handle = handle; >> + } >> + break; >> + } >> + case ION_IOC_ID_MAP: >> + { >> + ret = ion_map_usage_ids(client, >> + (unsigned int __user *)data.id_map.usage_ids, >> + data.id_map.cnt); >> + if (ret > 0) >> + data.id_map.new_id = ret; >> + break; >> + } >> + case ION_IOC_USAGE_CNT: >> + { >> + down_read(&client->dev->lock); >> + data.usage_cnt.cnt = client->dev->heap_cnt; >> + up_read(&client->dev->lock); >> + break; >> + } >> + case ION_IOC_HEAP_QUERY: >> + { >> + ret = ion_query_heaps(client, >> + (struct ion_heap_data __user *)data.query.heaps, >> + data.query.cnt); >> + break; >> + } >> default: >> return -ENOTTY; >> } >> diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c >> index 129707f..c096cb9 100644 >> --- a/drivers/staging/android/ion/ion.c >> +++ b/drivers/staging/android/ion/ion.c >> @@ -459,6 +459,48 @@ static struct ion_handle *__ion_alloc(struct ion_client *client, size_t len, >> return handle; >> } >> >> +struct ion_handle *ion_alloc2(struct ion_client *client, size_t len, >> + size_t align, unsigned int usage_id, >> + unsigned int flags) >> +{ >> + struct ion_device *dev = client->dev; >> + struct ion_heap *heap; >> + struct ion_handle *handle = ERR_PTR(-ENODEV); >> + >> + down_read(&dev->lock); >> + heap = idr_find(&dev->idr, usage_id); >> + if (!heap) { >> + handle = ERR_PTR(-EINVAL); >> + goto out; >> + } >> + >> + if (heap->type == ION_USAGE_ID_MAP) { >> + int i; >> + >> + for (i = 0; i < heap->fallback_cnt; i++){ >> + heap = idr_find(&dev->idr, heap->fallbacks[i]); >> + if (!heap) >> + continue; >> + >> + /* Don't recurse for now? */ >> + if (heap->type == ION_USAGE_ID_MAP) >> + continue; >> + >> + handle = __ion_alloc(client, len, align, heap, flags); >> + if (IS_ERR(handle)) >> + continue; >> + else >> + break; >> + } >> + } else { >> + handle = __ion_alloc(client, len, align, heap, flags); >> + } >> +out: >> + up_read(&dev->lock); >> + return handle; >> +} >> +EXPORT_SYMBOL(ion_alloc2); >> + >> struct ion_handle *ion_alloc(struct ion_client *client, size_t len, >> size_t align, unsigned int heap_mask, >> unsigned int flags) >> @@ -1243,6 +1285,55 @@ int ion_sync_for_device(struct ion_client *client, int fd) >> return 0; >> } >> >> +struct ion_query_data { >> + struct ion_heap_data __user *buffer; >> + int cnt; >> + int max_cnt; >> +}; >> + >> +int __ion_query(int id, void *p, void *data) >> +{ >> + struct ion_heap *heap = p; >> + struct ion_query_data *query = data; >> + struct ion_heap_data hdata = {0}; >> + >> + if (query->cnt >= query->max_cnt) >> + return -ENOSPC; >> + >> + strncpy(hdata.name, heap->name, 20); > > Why 20? > Arbitrary limit for a fixed size buffer. As noted below I need to make this a consistent #define. >> + hdata.name[sizeof(hdata.name) - 1] = '\0'; >> + hdata.type = heap->type; >> + hdata.usage_id = heap->id; >> + >> + return copy_to_user(&query->buffer[query->cnt++], &hdata, sizeof(hdata)); >> +} >> + >> +int ion_query_heaps(struct ion_client *client, >> + struct ion_heap_data __user *buffer, >> + int cnt) >> +{ >> + struct ion_device *dev = client->dev; >> + struct ion_query_data data; >> + int ret; >> + >> + data.buffer = buffer; >> + data.cnt = 0; >> + data.max_cnt = cnt; >> + >> + down_read(&dev->lock); >> + if (data.max_cnt < 0 || data.max_cnt > dev->heap_cnt) { > > Is the check against heap_cnt necessary? You could update the cnt > field in ion_heap_query to say how many were actually copied. > This was mostly a paranoid check to reduce risk of accidentally giving userspace access to something it shouldn't. Updating the count is still a good idea in case userspace wants fewer than are available. > I think you could probably drop ION_IOC_USAGE_COUNT by giving > ION_IOC_HEAP_QUERY similar semantics to the DRM ioctls: > - First call with buffer pointer = NULL, kernel sets cnt to space > required > - Userspace allocates buffer and calls the ioctl again, kernel fills > the buffer > I'm not that familiar with the DRM ioctls but this sounds like a good suggestion. One less ioctl to worry about. >> + ret = -EINVAL; >> + goto out; >> + } >> + ret = idr_for_each(&dev->idr, __ion_query, &data); >> +out: >> + up_read(&dev->lock); >> + >> + return ret; >> +} >> + >> + >> + >> static int ion_release(struct inode *inode, struct file *file) >> { >> struct ion_client *client = file->private_data; >> @@ -1407,13 +1498,69 @@ static int debug_shrink_get(void *data, u64 *val) >> DEFINE_SIMPLE_ATTRIBUTE(debug_shrink_fops, debug_shrink_get, >> debug_shrink_set, "%llu\n"); >> >> +int ion_map_usage_ids(struct ion_client *client, >> + unsigned int __user *usage_ids, >> + int cnt) >> +{ >> + struct ion_heap *heap = kzalloc(sizeof(*heap), GFP_KERNEL); >> + unsigned int *fallbacks; >> + int i; >> + int ret; >> + >> + if (!heap) >> + return -ENOMEM; >> + >> + fallbacks = kzalloc(sizeof(unsigned int)*cnt, GFP_KERNEL); >> + if (!fallbacks) { >> + ret = -ENOMEM; >> + goto out1; >> + } >> + >> + ret = copy_from_user(fallbacks, usage_ids, sizeof(unsigned int)*cnt); >> + if (ret) >> + goto out2; >> + >> + down_read(&client->dev->lock); >> + for (i = 0; i < cnt; i++) { >> + if (idr_find(&client->dev->idr, fallbacks[i]) == NULL) { >> + ret = -EINVAL; >> + goto out3; >> + } >> + } >> + up_read(&client->dev->lock); >> + >> + /* >> + * This is a racy check since the lock is dropped before the heap >> + * is actually added. It's okay though because ids are never actually >> + * deleted. Worst case some user gets an error back and an indication >> + * to fix races in their code. >> + */ >> + >> + heap->fallbacks = fallbacks; >> + heap->fallback_cnt = cnt; >> + heap->type = ION_USAGE_ID_MAP; >> + heap->id = ION_DYNAMIC_HEAP_ASSIGN; > > It would be nice for userspace to be able to give these usage heaps > meaningful names - That could be their intended usage ("camera", > "display") or their properties ("contiguous", "sram"). > >> + ion_device_add_heap(client->dev, heap); >> + return heap->id; >> +out3: >> + up_read(&client->dev->lock); >> +out2: >> + kfree(fallbacks); >> +out1: >> + kfree(heap); >> + return ret; >> +} >> + >> int ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap) >> { >> struct dentry *debug_file; >> int ret; >> >> - if (!heap->ops->allocate || !heap->ops->free || !heap->ops->map_dma || >> - !heap->ops->unmap_dma) { >> + if (heap->type != ION_USAGE_ID_MAP && >> + (!heap->ops->allocate || >> + !heap->ops->free || >> + !heap->ops->map_dma || >> + !heap->ops->unmap_dma)) { >> pr_err("%s: can not add heap with invalid ops struct.\n", >> __func__); >> return -EINVAL; >> @@ -1425,18 +1572,36 @@ int ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap) >> if (heap->flags & ION_HEAP_FLAG_DEFER_FREE) >> ion_heap_init_deferred_free(heap); >> >> - if ((heap->flags & ION_HEAP_FLAG_DEFER_FREE) || heap->ops->shrink) >> + if ((heap->flags & ION_HEAP_FLAG_DEFER_FREE) || (heap->ops && heap->ops->shrink)) >> ion_heap_init_shrinker(heap); >> >> heap->dev = dev; >> down_write(&dev->lock); >> >> - ret = idr_alloc(&dev->idr, heap, heap->id, heap->id + 1, GFP_KERNEL); >> - if (ret < 0 || ret != heap->id) { >> - pr_info("%s: Failed to add heap id, expected %d got %d\n", >> - __func__, heap->id, ret); >> - up_write(&dev->lock); >> - return ret < 0 ? ret : -EINVAL; >> + if (heap->id == ION_DYNAMIC_HEAP_ASSIGN) { >> + ret = idr_alloc(&dev->idr, heap, >> + ION_DYNAMIC_HEAP_ASSIGN + 1, 0, GFP_KERNEL); >> + if (ret < 0) >> + goto out_unlock; >> + >> + heap->id = ret; >> + } else { >> + ret = idr_alloc(&dev->idr, heap, heap->id, heap->id + 1, >> + GFP_KERNEL); >> + if (ret < 0 || ret != heap->id) { >> + pr_info("%s: Failed to add heap id, expected %d got %d\n", >> + __func__, heap->id, ret); >> + ret = ret < 0 ? ret : -EINVAL; >> + goto out_unlock; >> + } >> + } >> + >> + if (!heap->name) { >> + heap->name = kasprintf(GFP_KERNEL, "heap%d", heap->id); >> + if (!heap->name) { >> + ret = -ENOMEM; >> + goto out_unlock; >> + } >> } >> >> debug_file = debugfs_create_file(heap->name, 0664, >> @@ -1467,6 +1632,7 @@ int ion_device_add_heap(struct ion_device *dev, struct ion_heap *heap) >> } >> } >> dev->heap_cnt++; >> +out_unlock: >> up_write(&dev->lock); >> return 0; >> } >> diff --git a/drivers/staging/android/ion/ion_priv.h b/drivers/staging/android/ion/ion_priv.h >> index b09d751..e03e940 100644 >> --- a/drivers/staging/android/ion/ion_priv.h >> +++ b/drivers/staging/android/ion/ion_priv.h >> @@ -255,6 +255,9 @@ struct ion_heap { >> wait_queue_head_t waitqueue; >> struct task_struct *task; >> >> + unsigned int *fallbacks; >> + int fallback_cnt; >> + >> int (*debug_show)(struct ion_heap *heap, struct seq_file *, void *); >> }; >> >> @@ -381,6 +384,10 @@ size_t ion_heap_freelist_shrink(struct ion_heap *heap, >> size_t ion_heap_freelist_size(struct ion_heap *heap); >> >> >> +int ion_map_usage_ids(struct ion_client *client, >> + unsigned int __user *usage_ids, >> + int cnt); >> + >> /** >> * functions for creating and destroying the built in ion heaps. >> * architectures can add their own custom architecture specific >> @@ -495,4 +502,12 @@ struct ion_handle *ion_handle_get_by_id(struct ion_client *client, >> >> int ion_handle_put(struct ion_handle *handle); >> >> +struct ion_handle *ion_alloc2(struct ion_client *client, size_t len, >> + size_t align, unsigned int usage_id, >> + unsigned int flags); >> + >> +int ion_query_heaps(struct ion_client *client, >> + struct ion_heap_data __user *buffer, >> + int cnt); >> + >> #endif /* _ION_PRIV_H */ >> diff --git a/drivers/staging/android/uapi/ion.h b/drivers/staging/android/uapi/ion.h >> index 145005f..d36b4e4 100644 >> --- a/drivers/staging/android/uapi/ion.h >> +++ b/drivers/staging/android/uapi/ion.h >> @@ -45,10 +45,17 @@ enum ion_heap_type { >> * must be last so device specific heaps always >> * are at the end of this enum >> */ >> + ION_USAGE_ID_MAP, > > A short description for this would be nice > >> }; >> >> #define ION_NUM_HEAP_IDS (sizeof(unsigned int) * 8) >> >> +/* >> + * This isn't completely random. The old Ion heap ID namespace goes up to >> + * 32 bits so take the first one after that to use as a dynamic setting >> + */ >> +#define ION_DYNAMIC_HEAP_ASSIGN 33 >> + > > The old comment says 32, but the implementation looks like 16. > > Either way, shouldn't that be 32? If the previous max was 31, > 32 is next available - but in ion_device_add_heap() you use > ION_DYNAMIC_HEAP_ASSIGN + 1, which makes the first dynamically-assigned > ID 34. > >> /** >> * allocation flags - the lower 16 bits are used by core ion, the upper 16 >> * bits are reserved for use by the heaps themselves. >> @@ -65,6 +72,11 @@ enum ion_heap_type { >> * caches must be managed >> * manually >> */ >> +#define ION_FLAG_NO_HANDLE 3 /* >> + * Return only an fd associated with >> + * this buffer and not a handle >> + */ >> + >> >> /** >> * DOC: Ion Userspace API >> @@ -142,6 +154,96 @@ struct ion_abi_version { >> __u32 reserved; >> }; >> >> +/** >> + * struct ion_new_alloc_data - metadata to/from usersapce allocation v2 >> + * @len: size of the allocation >> + * @align: required alignment of the allocation >> + * @usage_id: mapping to heap id to allocate. Will try fallbacks >> + * if specified in the heap mapping >> + * @flags: flags passed to heap >> + * @handle: pointer that will be populated with a cookie to use to >> + * refer to this allocation >> + * @fd: optionally, may return just an fd with no handle >> + * reference >> + */ >> +struct ion_new_alloc_data { >> + __u64 len; >> + __u64 align; >> + __u32 usage_id; >> + __u32 flags; >> + /* >> + * I'd like to add a flag to just return the fd instead of just >> + * a handle for those who want to skip the next step. >> + */ >> + union { >> + __u32 fd; >> + __u32 handle; >> + }; >> + /* >> + * Allocation has a definite problem of 'creep' so give more than >> + * enough extra bits for expansion >> + */ >> + __u32 reserved0; >> + __u32 reserved1; >> + __u32 reserved2; >> +}; >> + >> +/** >> + * struct ion_usage_id_map - metadata to create a new usage map >> + * @usage_id - userspace allocated array of existing usage ids >> + * @cnt - number of ids to be mapped >> + * @new_id - will be populated with the new usage id >> + */ >> +struct ion_usage_id_map { >> + /* Array of usage ids provided by user */ >> + __u64 usage_ids; >> + __u32 cnt; >> + >> + /* Returned on success */ >> + __u32 new_id; >> + /* Fields for future growth */ >> + __u32 reserved0; >> + __u32 reserved1; >> +}; >> + >> +/** >> + * struct ion_usage_cnt - meta data for the count of heaps >> + * @cnt - returned count of number of heaps present >> + */ >> +struct ion_usage_cnt { >> + __u32 cnt; /* cnt returned */ >> + __u32 reserved; >> +}; >> + >> +/** >> + * struct ion_heap_data - data about a heap >> + * @name - first 32 characters of the heap name >> + * @type - heap type >> + * @usage_id - usage id for the heap >> + */ >> +struct ion_heap_data { >> + char name[32]; I realized I upped this to 32 and didn't update the code. I'm going to make this consistent. >> + __u32 type; >> + __u32 usage_id; > > For heaps with type ION_USAGE_ID_MAP I think userspace would want a way > to turn a usage_id back into a list of fallbacks to figure out that > usage_id == 34 means "only contiguous buffers" for instance. > Otherwise only the process that made the mapping can ever know what its > for. > >> + __u32 reserved0; >> + __u32 reserved1; >> + __u32 reserved2; >> +}; >> + >> +/** >> + * struct ion_heap_query - collection of data about all heaps >> + * @cnt - total number of heaps to be copied >> + * @heaps - buffer to copy heap data >> + */ >> +struct ion_heap_query { >> + __u32 cnt; /* Total number of heaps to be copied */ >> + __u64 heaps; /* buffer to be populated */ > > I guess this field needs explicit alignment to 64 bits > Yes, I was going by the suggestion in botching-up-ioctls.txt https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/Docume… >> + __u32 reserved0; >> + __u32 reserved1; >> + __u32 reserved2; >> +}; >> + >> + >> #define ION_IOC_MAGIC 'I' >> >> /** >> @@ -216,5 +318,38 @@ struct ion_abi_version { >> #define ION_IOC_ABI_VERSION _IOR(ION_IOC_MAGIC, 8, \ >> struct ion_abi_version) >> >> +/** >> + * DOC: ION_IOC_ALLOC2 - allocate memory via new API >> + * >> + * Same concept as ION_IOC_ALLOC except with updated ABI. Can return an fd >> + * directly in addition to a handle >> + */ >> +#define ION_IOC_ALLOC2 _IOWR(ION_IOC_MAGIC, 9, \ >> + struct ion_new_alloc_data) >> + >> +/** >> + * DOC: ION_IOC_ID_MAP - remap an array of heap IDs >> + * >> + * Takes an ion_usage_id_map structure populated with information about >> + * fallback information. Returns a new usage id for use in allocation. > > Can you mention the implied priority of the fallbacks here? > >> + */ >> +#define ION_IOC_ID_MAP _IOWR(ION_IOC_MAGIC, 10, \ >> + struct ion_usage_id_map) >> +/** >> + * DOC: ION_IOC_USAGE_CNT - returns a count of the number of usage ids >> + * >> + * Takes an ion_usage_cnt structure and returns the total number of usage >> + * ids available. > > Number of usage IDs or number of heaps? > >> + */ >> +#define ION_IOC_USAGE_CNT _IOR(ION_IOC_MAGIC, 11, \ >> + struct ion_usage_cnt) >> +/** >> + * DOC: ION_IOC_HEAP_QUERY - information about available heaps >> + * >> + * Takes an ion_heap_query structure and populates information about >> + * availble Ion heaps. >> + */ >> +#define ION_IOC_HEAP_QUERY _IOWR(ION_IOC_MAGIC, 12, \ >> + struct ion_heap_query) >> >> #endif /* _UAPI_LINUX_ION_H */ >> -- >> 2.5.5 >>

9 years

Re: [Linaro-mm-sig] [RFC][PATCH 0/6] ion: improved ABI

by Laura Abbott

On 06/08/2016 08:15 AM, Brian Starkey wrote: > Hi Laura, > > On Mon, Jun 06, 2016 at 11:23:27AM -0700, Laura Abbott wrote: >> The ABI for Ion's ioctl interface are a pain to work with. The heap IDs >> are a 32-bit non-discoverable namespace that form part of the ABI. There's >> no way to determine what ABI version is in use which leads to problems >> if the ABI changes or needs to be updated. >> >> This series is a first approach to give a better ABI for Ion. This includes: >> >> - Following the advice in botching-up-ioctls.txt >> - Ioctl for ABI version >> - Dynamic assignment of heap ids >> - queryable heap ids >> - Runtime mapping of heap ids, including fallbacks. This avoids the need to >> encode the fallbacks as an ABI. >> >> I'm most interested in feedback if this ABI is actually an improvement and >> usable. The heap id map/query interface seems error prone but I didn't have >> a cleaner solution. There aren't any kernel APIs for the new features as the >> focus was on a userspace API but I anticipate that following easily once >> the userspace API is established. >> > > If I understand it right, the big improvement here is that userspace can > find out what heap IDs are available, and what type of heap they > correspond to? This seems good. > > I'm not sure about how userspace is meant to use the usage mappings > though. Who calls ION_IOC_ID_MAP? > The thought was daemons (surfaceflinger, mediaserver etc.) would set this up. > (also, map/mapping is pretty overloaded. How about groups/groupings?) > That's a good suggestion. > If I assume that the thing calling ION_IOC_ID_MAP is the same thing > doing the allocating, then there doesn't seem to be much need for > creating mappings. The combined mapper/allocator would necessarily need > some knowledge about which types can satisfy which usage, and so could > follow something like this: > 1. The heaps can be queried, finding their IDs and types > 2. A mask of heap IDs can be created which satisfies a "usage", based > on the queried types > 3. Allocation operations can then simply use this constructed mask > > On the other hand, if I assume that the thing doing the allocating is > different to the thing doing the usage mapping (i.e. the allocator > doesn't need to know about heap _types_, only usages); then I can't see > a way for the allocator to figure out which usage_id it's meant to > allocate with - which puts it right back to the old problem of opaque > heap IDs (-> opaque usage_ids), except it's worse because they can > change dynamically. > I see your point about the mapping. My thought was that whoever was doing the mapping would have a way to pass information to the allocator or the allocator could do a query. Relying on the passing of information may not be plausible and I realize there isn't enough information from a query to determine what usage id to use. I like the suggestion of just using the query. One of the goals I initially had with this series was to get rid of the heap mask. The 32-bit heap mask became a name space that needed to be controlled across all targets and the fallbacks were difficult to change. The problem that actually wants to be solved is giving userspace enough information to determine what heap masks to allocate from. Just a query ioctl should be able to give that information as long as the requirement is that userspace clients match on the heap name + type only and not rely on the heap ids being constant (I don't think I made that clear with this version of the query ioctl so I'll make sure to clarify). The platform registration can adjust the priority order of the heap ids as necessary. Different names should be able to take care of any changes to the platform configuration. I'll think about this more when I work on v2. Thanks, Laura > Thanks, > Brian > >> >> Thanks, >> Laura >> >> P.S. Not to turn this into a bike shedding session but if you have suggestions >> for a name for this framework other than Ion I would be interested to hear >> them. Too many other things are already named Ion. >> >> Laura Abbott (6): >> staging: android: ion: return error value for ion_device_add_heap >> staging: android: ion: Switch to using an idr to manage heaps >> staging: android: ion: Drop heap type masks >> staging: android: ion: Pull out ion ioctls to a separate file >> staging: android: ion: Add an ioctl for ABI checking >> staging: android: ion: Introduce new ioctls for dynamic heaps >> >> drivers/staging/android/ion/Makefile | 3 +- >> drivers/staging/android/ion/ion-ioctl.c | 243 ++++++++++++++++++ >> drivers/staging/android/ion/ion.c | 438 ++++++++++++++++---------------- >> drivers/staging/android/ion/ion_priv.h | 109 +++++++- >> drivers/staging/android/uapi/ion.h | 164 +++++++++++- >> 5 files changed, 728 insertions(+), 229 deletions(-) >> create mode 100644 drivers/staging/android/ion/ion-ioctl.c >> >> -- 2.5.5

9 years

[RFC][PATCH 0/6] ion: improved ABI

by Laura Abbott

The ABI for Ion's ioctl interface are a pain to work with. The heap IDs are a 32-bit non-discoverable namespace that form part of the ABI. There's no way to determine what ABI version is in use which leads to problems if the ABI changes or needs to be updated. This series is a first approach to give a better ABI for Ion. This includes: - Following the advice in botching-up-ioctls.txt - Ioctl for ABI version - Dynamic assignment of heap ids - queryable heap ids - Runtime mapping of heap ids, including fallbacks. This avoids the need to encode the fallbacks as an ABI. I'm most interested in feedback if this ABI is actually an improvement and usable. The heap id map/query interface seems error prone but I didn't have a cleaner solution. There aren't any kernel APIs for the new features as the focus was on a userspace API but I anticipate that following easily once the userspace API is established. Thanks, Laura P.S. Not to turn this into a bike shedding session but if you have suggestions for a name for this framework other than Ion I would be interested to hear them. Too many other things are already named Ion. Laura Abbott (6): staging: android: ion: return error value for ion_device_add_heap staging: android: ion: Switch to using an idr to manage heaps staging: android: ion: Drop heap type masks staging: android: ion: Pull out ion ioctls to a separate file staging: android: ion: Add an ioctl for ABI checking staging: android: ion: Introduce new ioctls for dynamic heaps drivers/staging/android/ion/Makefile | 3 +- drivers/staging/android/ion/ion-ioctl.c | 243 ++++++++++++++++++ drivers/staging/android/ion/ion.c | 438 ++++++++++++++++---------------- drivers/staging/android/ion/ion_priv.h | 109 +++++++- drivers/staging/android/uapi/ion.h | 164 +++++++++++- 5 files changed, 728 insertions(+), 229 deletions(-) create mode 100644 drivers/staging/android/ion/ion-ioctl.c -- 2.5.5

9 years

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

Linaro-mm-sig