[Linaro-mm-sig] [RFC 1/2] dma-buf: Introduce dma buffer sharing mechanism
robdclark at gmail.com
Wed Oct 12 06:50:53 PDT 2011
On Wed, Oct 12, 2011 at 8:35 AM, Dave Airlie <airlied at gmail.com> wrote:
>> well, the mmap is actually implemented by the buffer allocator
>> (v4l/drm).. although not sure if this was the point
> Then why not use the correct interface? doing some sort of not-quite
> generic interface isn't really helping anyone except adding an ABI
> that we have to support.
But what if you don't know who allocated the buffer? How do you know
what interface to use to mmap?
> If someone wants to bypass the current kernel APIs we should add a new
> API for them not shove it into this generic buffer sharing layer.
>> The intent was that this is for well defined formats.. ie. it would
>> need to be a format that both v4l and drm understood in the first
>> place for sharing to make sense at all..
> How will you know the stride to take a simple example? The userspace
> had to create this buffer somehow and wants to share it with
> "something", you sound like
> you really needs another API that is a simple accessor API that can
> handle mmaps.
Well, things like stride, width, height, color format, userspace needs
to know all this already, even for malloc()'d sw buffers. The
assumption is userspace already has a way to pass this information
around so it was not required to be duplicated by dmabuf.
>> Anyways, the basic reason is to handle random edge cases where you
>> need sw access to the buffer. For example, you are decoding video and
>> pull out a frame to generate a thumbnail w/ a sw jpeg encoder..
> Again, doesn't sound like it should be part of this API, and also
> sounds like the sw jpeg encoder will need more info about the buffer
> anyways like stride and format.
>> With this current scheme, synchronization could be handled in
>> dmabufops->mmap() and vm_ops->close().. it is perhaps a bit heavy to
>> require mmap/munmap for each sw access, but I suppose this isn't
>> really for the high-performance use case. It is just so that some
>> random bit of sw that gets passed a dmabuf handle without knowing who
>> allocated it can have sw access if really needed.
> So I think thats fine, write a sw accessor providers, don't go
> overloading the buffer sharing code.
But then we'd need a different set of accessors for every different
drm/v4l/etc driver, wouldn't we?
> This API will limit what people can use this buffer sharing for with
> pure hw accessors, you might say, oh buts its okay to fail the mmap
> then, but the chances of sw handling that I'm not so sure off.
I'm not entirely sure the case you are worried about.. sharing buffers
between multiple GPU's that understand same tiled formats? I guess
that is a bit different from a case like a jpeg encoder that is passed
a dmabuf handle without any idea where it came from..
I guess if sharing a buffer between multiple drm devices, there is
nothing stopping you from having some NOT_DMABUF_MMAPABLE flag you
pass when the buffer is allocated, then you don't have to support
dmabuf->mmap(), and instead mmap via device and use some sort of
DRM_CPU_PREP/FINI ioctls for synchronization..
More information about the dri-devel