[RFC,v4,13/17,media] vb2: add in-fence support to QBUF
Commit Message
From: Gustavo Padovan <gustavo.padovan@collabora.com>
Receive in-fence from userspace and add support for waiting on them
before queueing the buffer to the driver. Buffers are only queued
to the driver once they are ready. A buffer is ready when its
in-fence signals.
For queues that require vb2 to queue buffers to the v4l2 driver in same
order they are received from userspace we use fence_array to keep that
ordering. Basically we create a fence_array that contains both the current
fence and the fence from the previous buffer (which might be a fence array
as well). The base fence class for the fence_array becomes the new buffer
fence, waiting on that one guarantees that it won't be queued out of
order.
v5: - use fence_array to keep buffers ordered in vb2 core when
needed (Brian Stark)
- keep backward compatibility on the reserved2 field (Brian Stark)
- protect fence callback removal with lock (Brian Stark)
v4:
- Add a comment about dma_fence_add_callback() not returning a
error (Hans)
- Call dma_fence_put(vb->in_fence) if fence signaled (Hans)
- select SYNC_FILE under config VIDEOBUF2_CORE (Hans)
- Move dma_fence_is_signaled() check to __enqueue_in_driver() (Hans)
- Remove list_for_each_entry() in __vb2_core_qbuf() (Hans)
- Remove if (vb->state != VB2_BUF_STATE_QUEUED) from
vb2_start_streaming() (Hans)
- set IN_FENCE flags on __fill_v4l2_buffer (Hans)
- Queue buffers to the driver as soon as they are ready (Hans)
- call fill_user_buffer() after queuing the buffer (Hans)
- add err: label to clean up fence
- add dma_fence_wait() before calling vb2_start_streaming()
v3: - document fence parameter
- remove ternary if at vb2_qbuf() return (Mauro)
- do not change if conditions behaviour (Mauro)
v2:
- fix vb2_queue_or_prepare_buf() ret check
- remove check for VB2_MEMORY_DMABUF only (Javier)
- check num of ready buffers to start streaming
- when queueing, start from the first ready buffer
- handle queue cancel
Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.com>
---
drivers/media/v4l2-core/Kconfig | 1 +
drivers/media/v4l2-core/videobuf2-core.c | 179 ++++++++++++++++++++++++++++---
drivers/media/v4l2-core/videobuf2-v4l2.c | 29 ++++-
include/media/videobuf2-core.h | 17 ++-
4 files changed, 208 insertions(+), 18 deletions(-)
Comments
Hi Gustavo,
On Fri, Oct 20, 2017 at 07:50:08PM -0200, Gustavo Padovan wrote:
>From: Gustavo Padovan <gustavo.padovan@collabora.com>
>
>Receive in-fence from userspace and add support for waiting on them
>before queueing the buffer to the driver. Buffers are only queued
>to the driver once they are ready. A buffer is ready when its
>in-fence signals.
>
>For queues that require vb2 to queue buffers to the v4l2 driver in same
>order they are received from userspace we use fence_array to keep that
>ordering. Basically we create a fence_array that contains both the current
>fence and the fence from the previous buffer (which might be a fence array
>as well). The base fence class for the fence_array becomes the new buffer
>fence, waiting on that one guarantees that it won't be queued out of
>order.
The API sounds/looks good to me, makes sense to let driver opt in/out
via the ordered_in_vb2 thing. Thanks for implementing it!
>
>v5: - use fence_array to keep buffers ordered in vb2 core when
> needed (Brian Stark)
> - keep backward compatibility on the reserved2 field (Brian Stark)
> - protect fence callback removal with lock (Brian Stark)
Brian Starkey, but close ;-)
>
>v4:
> - Add a comment about dma_fence_add_callback() not returning a
> error (Hans)
> - Call dma_fence_put(vb->in_fence) if fence signaled (Hans)
> - select SYNC_FILE under config VIDEOBUF2_CORE (Hans)
> - Move dma_fence_is_signaled() check to __enqueue_in_driver() (Hans)
> - Remove list_for_each_entry() in __vb2_core_qbuf() (Hans)
> - Remove if (vb->state != VB2_BUF_STATE_QUEUED) from
> vb2_start_streaming() (Hans)
> - set IN_FENCE flags on __fill_v4l2_buffer (Hans)
> - Queue buffers to the driver as soon as they are ready (Hans)
> - call fill_user_buffer() after queuing the buffer (Hans)
> - add err: label to clean up fence
> - add dma_fence_wait() before calling vb2_start_streaming()
>
>v3: - document fence parameter
> - remove ternary if at vb2_qbuf() return (Mauro)
> - do not change if conditions behaviour (Mauro)
>
>v2:
> - fix vb2_queue_or_prepare_buf() ret check
> - remove check for VB2_MEMORY_DMABUF only (Javier)
> - check num of ready buffers to start streaming
> - when queueing, start from the first ready buffer
> - handle queue cancel
>
>Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.com>
>---
> drivers/media/v4l2-core/Kconfig | 1 +
> drivers/media/v4l2-core/videobuf2-core.c | 179 ++++++++++++++++++++++++++++---
> drivers/media/v4l2-core/videobuf2-v4l2.c | 29 ++++-
> include/media/videobuf2-core.h | 17 ++-
> 4 files changed, 208 insertions(+), 18 deletions(-)
>
>diff --git a/drivers/media/v4l2-core/Kconfig b/drivers/media/v4l2-core/Kconfig
>index a35c33686abf..3f988c407c80 100644
>--- a/drivers/media/v4l2-core/Kconfig
>+++ b/drivers/media/v4l2-core/Kconfig
>@@ -83,6 +83,7 @@ config VIDEOBUF_DVB
> # Used by drivers that need Videobuf2 modules
> config VIDEOBUF2_CORE
> select DMA_SHARED_BUFFER
>+ select SYNC_FILE
> tristate
>
> config VIDEOBUF2_MEMOPS
>diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c
>index 60f8b582396a..78f369dba3e3 100644
>--- a/drivers/media/v4l2-core/videobuf2-core.c
>+++ b/drivers/media/v4l2-core/videobuf2-core.c
>@@ -346,6 +346,7 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory,
> vb->index = q->num_buffers + buffer;
> vb->type = q->type;
> vb->memory = memory;
>+ spin_lock_init(&vb->fence_cb_lock);
> for (plane = 0; plane < num_planes; ++plane) {
> vb->planes[plane].length = plane_sizes[plane];
> vb->planes[plane].min_length = plane_sizes[plane];
>@@ -1222,6 +1223,9 @@ static void __enqueue_in_driver(struct vb2_buffer *vb)
> {
> struct vb2_queue *q = vb->vb2_queue;
>
>+ if (vb->in_fence && !dma_fence_is_signaled(vb->in_fence))
>+ return;
>+
> vb->state = VB2_BUF_STATE_ACTIVE;
> atomic_inc(&q->owned_by_drv_count);
>
>@@ -1273,6 +1277,20 @@ static int __buf_prepare(struct vb2_buffer *vb, const void *pb)
> return 0;
> }
>
>+static int __get_num_ready_buffers(struct vb2_queue *q)
>+{
>+ struct vb2_buffer *vb;
>+ int ready_count = 0;
>+
>+ /* count num of buffers ready in front of the queued_list */
>+ list_for_each_entry(vb, &q->queued_list, queued_entry) {
>+ if (!vb->in_fence || dma_fence_is_signaled(vb->in_fence))
>+ ready_count++;
I think there's still some races on vb->in_fence. Couldn't the
callback on any of the buffers in the queued_list have their callback
run at any moment?
That could make this loop do bad things, and similarly the loop in
vb2_start_streaming() which calls __enqueue_in_driver().
>+ }
>+
>+ return ready_count;
>+}
>+
> int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb)
> {
> struct vb2_buffer *vb;
>@@ -1361,7 +1379,74 @@ static int vb2_start_streaming(struct vb2_queue *q)
> return ret;
> }
>
>-int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
>+static struct dma_fence *__set_in_fence(struct vb2_queue *q,
>+ struct vb2_buffer *vb,
>+ struct dma_fence *fence)
>+{
>+ if (q->last_fence && dma_fence_is_signaled(q->last_fence)) {
>+ dma_fence_put(q->last_fence);
>+ q->last_fence = NULL;
>+ }
>+
>+ /* For drivers that require the ordering of buffers queued from
>+ * userspace to be the same it is queued to the driver - output
>+ * some m2m devices - we create a fence array with the fence from
>+ * the last queued buffer and this one, that way the fence for this
>+ * buffer can't signal before the last one.
>+ */
>+ if (q->is_output || q->ordered_in_vb2) {
Just a stylistic thing - you could invert this conditional and return
early, saving a level of indentation below.
>+ if (fence && q->last_fence) {
>+ struct dma_fence **fences;
>+ struct dma_fence_array *arr;
>+
>+ fences = kcalloc(2, sizeof(*fences), GFP_KERNEL);
>+ if (!fences)
>+ return ERR_PTR(-ENOMEM);
>+
>+ fences[0] = fence;
>+ fences[1] = q->last_fence;
>+
>+ arr = dma_fence_array_create(2, fences,
>+ dma_fence_context_alloc(1),
>+ 1, false);
I'm not sure if it's right to get a new fence_context every time here.
The comment on dma_fence_context_counter sounds like the vb2_queue
should have a single context of its own.
>+ if (!arr) {
>+ kfree(fences);
>+ return ERR_PTR(-ENOMEM);
>+ }
>+
>+ fence = &arr->base;
>+ } else if (!fence && q->last_fence) {
>+ fence = dma_fence_get(q->last_fence);
>+ }
>+
>+ q->last_fence = dma_fence_get(fence);
Seems like the refcounting isn't quite right here.
If you land in "else if (!fence && q->last_fence)", then "fence" gets
a new reference to q->last_fence, and you take another one here -
which looks like one too many.
I _think_ the right thing to do is just give the previous reference on
q->last_fence to "fence", without taking a new one:
} else if (!fence && q->last_fence) {
fence = q->last_fence;
}
That's analogous to the other path where fence is not-NULL, and the
fence-array takes ownership of the existing references on fence and
q->last_fence, without taking new references.
Please double check my logic though!
>+ }
>+
>+ return fence;
>+}
>+
>+static void vb2_qbuf_fence_cb(struct dma_fence *f, struct dma_fence_cb *cb)
>+{
>+ struct vb2_buffer *vb = container_of(cb, struct vb2_buffer, fence_cb);
>+ struct vb2_queue *q = vb->vb2_queue;
>+ unsigned long flags;
>+
>+ spin_lock_irqsave(&vb->fence_cb_lock, flags);
>+ if (!vb->in_fence) {
>+ spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
>+ return;
>+ }
>+
>+ dma_fence_put(vb->in_fence);
>+ vb->in_fence = NULL;
>+ spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
>+
>+ if (q->start_streaming_called)
>+ __enqueue_in_driver(vb);
>+}
>+
>+int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
>+ struct dma_fence *fence)
> {
> struct vb2_buffer *vb;
> int ret;
>@@ -1372,16 +1457,18 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
> case VB2_BUF_STATE_DEQUEUED:
> ret = __buf_prepare(vb, pb);
> if (ret)
>- return ret;
>+ goto err;
> break;
> case VB2_BUF_STATE_PREPARED:
> break;
> case VB2_BUF_STATE_PREPARING:
> dprintk(1, "buffer still being prepared\n");
>- return -EINVAL;
>+ ret = -EINVAL;
>+ goto err;
> default:
> dprintk(1, "invalid buffer state %d\n", vb->state);
>- return -EINVAL;
>+ ret = -EINVAL;
>+ goto err;
> }
>
> /*
>@@ -1398,30 +1485,75 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
>
> trace_vb2_qbuf(q, vb);
>
>+ vb->in_fence = __set_in_fence(q, vb, fence);
>+ if (IS_ERR(vb->in_fence)) {
>+ ret = PTR_ERR(vb->in_fence);
>+ goto err;
Between here, __set_in_fence() and vb2_qbuf() there's a reference
leaked on "fence" in the case of error. I'm not sure what semantics
you'd like, but it should be clear whose responsibility it is to clear
up "fence" if __set_in_fence() fails (at the moment, looks like no-one
does).
>+ }
... and if __set_in_fence() succeeds, then vb->in_fence now owns the
reference on "fence" that was passed in, so I guess you should set
fence = NULL here.
>+
>+ /*
>+ * If it is time to call vb2_start_streaming() wait for the fence
>+ * to signal first. Of course, this happens only once per streaming.
>+ * We want to run any step that might fail before we set the callback
>+ * to queue the fence when it signals.
>+ */
>+ if (fence && !q->start_streaming_called &&
I think this should be vb->in_fence now, and the same for all further
uses of "fence" in this function.
>+ __get_num_ready_buffers(q) == q->min_buffers_needed - 1)
>+ dma_fence_wait(fence, true);
>+
> /*
> * If streamon has been called, and we haven't yet called
> * start_streaming() since not enough buffers were queued, and
> * we now have reached the minimum number of queued buffers,
> * then we can finally call start_streaming().
>- *
>- * If already streaming, give the buffer to driver for processing.
>- * If not, the buffer will be given to driver on next streamon.
> */
> if (q->streaming && !q->start_streaming_called &&
>- q->queued_count >= q->min_buffers_needed) {
>+ __get_num_ready_buffers(q) >= q->min_buffers_needed) {
> ret = vb2_start_streaming(q);
> if (ret)
>- return ret;
>- } else if (q->start_streaming_called) {
>- __enqueue_in_driver(vb);
>+ goto err;
>+ }
>+
>+ /*
>+ * For explicit synchronization: If the fence didn't signal
>+ * yet we setup a callback to queue the buffer once the fence
>+ * signals, and then, return successfully. But if the fence
>+ * already signaled we lose the reference we held and queue the
>+ * buffer to the driver.
>+ */
>+ if (fence) {
>+ ret = dma_fence_add_callback(fence, &vb->fence_cb,
>+ vb2_qbuf_fence_cb);
>+ if (!ret)
>+ goto fill;
Just spotted that you should probably handle the -EINVAL case here and
jump to err.
>+
>+ dma_fence_put(fence);
>+ vb->in_fence = NULL;
> }
>
>+fill:
>+ /*
>+ * If already streaming and there is no fence to wait on
>+ * give the buffer to driver for processing.
>+ */
>+ if (q->start_streaming_called && !vb->in_fence)
>+ __enqueue_in_driver(vb);
The callback could have run just before this, clearing vb->in_fence
and ending up with __enqueue_in_driver() getting called twice.
>+
> /* Fill buffer information for the userspace */
> if (pb)
> call_void_bufop(q, fill_user_buffer, vb, pb);
>
> dprintk(2, "qbuf of buffer %d succeeded\n", vb->index);
> return 0;
>+
>+err:
>+ if (vb->in_fence) {
>+ dma_fence_put(vb->in_fence);
>+ vb->in_fence = NULL;
>+ }
>+
>+ return ret;
>+
> }
> EXPORT_SYMBOL_GPL(vb2_core_qbuf);
>
>@@ -1632,6 +1764,8 @@ EXPORT_SYMBOL_GPL(vb2_core_dqbuf);
> static void __vb2_queue_cancel(struct vb2_queue *q)
> {
> unsigned int i;
>+ struct vb2_buffer *vb;
>+ unsigned long flags;
>
> /*
> * Tell driver to stop all transactions and release all queued
>@@ -1659,6 +1793,21 @@ static void __vb2_queue_cancel(struct vb2_queue *q)
> q->queued_count = 0;
> q->error = 0;
>
>+ list_for_each_entry(vb, &q->queued_list, queued_entry) {
>+ spin_lock_irqsave(&vb->fence_cb_lock, flags);
>+ if (vb->in_fence) {
>+ dma_fence_remove_callback(vb->in_fence, &vb->fence_cb);
>+ dma_fence_put(vb->in_fence);
>+ vb->in_fence = NULL;
>+ }
>+ spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
>+ }
>+
>+ if (q->last_fence) {
>+ dma_fence_put(q->last_fence);
>+ q->last_fence = NULL;
>+ }
>+
> /*
> * Remove all buffers from videobuf's list...
> */
>@@ -1720,7 +1869,7 @@ int vb2_core_streamon(struct vb2_queue *q, unsigned int type)
> * Tell driver to start streaming provided sufficient buffers
> * are available.
> */
>- if (q->queued_count >= q->min_buffers_needed) {
>+ if (__get_num_ready_buffers(q) >= q->min_buffers_needed) {
> ret = v4l_vb2q_enable_media_source(q);
> if (ret)
> return ret;
>@@ -2240,7 +2389,7 @@ static int __vb2_init_fileio(struct vb2_queue *q, int read)
> * Queue all buffers.
> */
> for (i = 0; i < q->num_buffers; i++) {
>- ret = vb2_core_qbuf(q, i, NULL);
>+ ret = vb2_core_qbuf(q, i, NULL, NULL);
> if (ret)
> goto err_reqbufs;
> fileio->bufs[i].queued = 1;
>@@ -2419,7 +2568,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
>
> if (copy_timestamp)
> b->timestamp = ktime_get_ns();
>- ret = vb2_core_qbuf(q, index, NULL);
>+ ret = vb2_core_qbuf(q, index, NULL, NULL);
> dprintk(5, "vb2_dbuf result: %d\n", ret);
> if (ret)
> return ret;
>@@ -2522,7 +2671,7 @@ static int vb2_thread(void *data)
> if (copy_timestamp)
> vb->timestamp = ktime_get_ns();;
> if (!threadio->stop)
>- ret = vb2_core_qbuf(q, vb->index, NULL);
>+ ret = vb2_core_qbuf(q, vb->index, NULL, NULL);
> call_void_qop(q, wait_prepare, q);
> if (ret || threadio->stop)
> break;
>diff --git a/drivers/media/v4l2-core/videobuf2-v4l2.c b/drivers/media/v4l2-core/videobuf2-v4l2.c
>index 110fb45fef6f..4c09ea007d90 100644
>--- a/drivers/media/v4l2-core/videobuf2-v4l2.c
>+++ b/drivers/media/v4l2-core/videobuf2-v4l2.c
>@@ -23,6 +23,7 @@
> #include <linux/sched.h>
> #include <linux/freezer.h>
> #include <linux/kthread.h>
>+#include <linux/sync_file.h>
>
> #include <media/v4l2-dev.h>
> #include <media/v4l2-fh.h>
>@@ -178,6 +179,12 @@ static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b,
> return -EINVAL;
> }
>
>+ if ((b->fence_fd != 0 && b->fence_fd != -1) &&
>+ !(b->flags & V4L2_BUF_FLAG_IN_FENCE)) {
>+ dprintk(1, "%s: fence_fd set without IN_FENCE flag\n", opname);
>+ return -EINVAL;
>+ }
>+
> return __verify_planes_array(q->bufs[b->index], b);
> }
>
>@@ -203,9 +210,14 @@ static void __fill_v4l2_buffer(struct vb2_buffer *vb, void *pb)
> b->timestamp = ns_to_timeval(vb->timestamp);
> b->timecode = vbuf->timecode;
> b->sequence = vbuf->sequence;
>- b->fence_fd = -1;
> b->reserved = 0;
>
>+ b->fence_fd = -1;
>+ if (vb->in_fence)
>+ b->flags |= V4L2_BUF_FLAG_IN_FENCE;
>+ else
>+ b->flags &= ~V4L2_BUF_FLAG_IN_FENCE;
>+
> if (q->is_multiplanar) {
> /*
> * Fill in plane-related data if userspace provided an array
>@@ -560,6 +572,7 @@ EXPORT_SYMBOL_GPL(vb2_create_bufs);
>
> int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
> {
>+ struct dma_fence *fence = NULL;
> int ret;
>
> if (vb2_fileio_is_active(q)) {
>@@ -568,7 +581,19 @@ int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
> }
>
> ret = vb2_queue_or_prepare_buf(q, b, "qbuf");
>- return ret ? ret : vb2_core_qbuf(q, b->index, b);
>+ if (ret)
>+ return ret;
>+
>+ if (b->flags & V4L2_BUF_FLAG_IN_FENCE) {
>+ fence = sync_file_get_fence(b->fence_fd);
In DRM a fence_fd of -1 means "already signaled" - should that be
allowed here too?
Cheers,
-Brian
>+ if (!fence) {
>+ dprintk(1, "failed to get in-fence from fd %d\n",
>+ b->fence_fd);
>+ return -EINVAL;
>+ }
>+ }
>+
>+ return vb2_core_qbuf(q, b->index, b, fence);
> }
> EXPORT_SYMBOL_GPL(vb2_qbuf);
>
>diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
>index fc333e10e7d8..624ca2dce9ea 100644
>--- a/include/media/videobuf2-core.h
>+++ b/include/media/videobuf2-core.h
>@@ -16,6 +16,7 @@
> #include <linux/mutex.h>
> #include <linux/poll.h>
> #include <linux/dma-buf.h>
>+#include <linux/dma-fence.h>
>
> #define VB2_MAX_FRAME (32)
> #define VB2_MAX_PLANES (8)
>@@ -254,11 +255,20 @@ struct vb2_buffer {
> * all buffers queued from userspace
> * done_entry: entry on the list that stores all buffers ready
> * to be dequeued to userspace
>+ * in_fence: fence receive from vb2 client to wait on before
>+ * using the buffer (queueing to the driver)
>+ * fence_cb: fence callback information
>+ * fence_cb_lock: protect callback signal/remove
> */
> enum vb2_buffer_state state;
>
> struct list_head queued_entry;
> struct list_head done_entry;
>+
>+ struct dma_fence *in_fence;
>+ struct dma_fence_cb fence_cb;
>+ spinlock_t fence_cb_lock;
>+
> #ifdef CONFIG_VIDEO_ADV_DEBUG
> /*
> * Counters for how often these buffer-related ops are
>@@ -508,6 +518,7 @@ struct vb2_buf_ops {
> * @ordered_in_vb2: set by the driver to tell vb2 te guarantee the order
> * of buffer queue from userspace with QBUF() until they are
> * queued to the driver.
>+ * @last_fence: last in-fence received. Used to keep ordering.
> * @fileio: file io emulator internal data, used only if emulator is active
> * @threadio: thread io internal data, used only if thread is active
> */
>@@ -563,6 +574,8 @@ struct vb2_queue {
> unsigned int ordered_in_driver:1;
> unsigned int ordered_in_vb2:1;
>
>+ struct dma_fence *last_fence;
>+
> struct vb2_fileio_data *fileio;
> struct vb2_threadio_data *threadio;
>
>@@ -738,6 +751,7 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb);
> * @index: id number of the buffer
> * @pb: buffer structure passed from userspace to vidioc_qbuf handler
> * in driver
>+ * @fence: in-fence to wait on before queueing the buffer
> *
> * Should be called from vidioc_qbuf ioctl handler of a driver.
> * The passed buffer should have been verified.
>@@ -752,7 +766,8 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb);
> * The return values from this function are intended to be directly returned
> * from vidioc_qbuf handler in driver.
> */
>-int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb);
>+int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
>+ struct dma_fence *fence);
>
> /**
> * vb2_core_dqbuf() - Dequeue a buffer to the userspace
>--
>2.13.6
>
2017-10-25 Brian Starkey <brian.starkey@arm.com>:
> Hi Gustavo,
>
> On Fri, Oct 20, 2017 at 07:50:08PM -0200, Gustavo Padovan wrote:
> > From: Gustavo Padovan <gustavo.padovan@collabora.com>
> >
> > Receive in-fence from userspace and add support for waiting on them
> > before queueing the buffer to the driver. Buffers are only queued
> > to the driver once they are ready. A buffer is ready when its
> > in-fence signals.
> >
> > For queues that require vb2 to queue buffers to the v4l2 driver in same
> > order they are received from userspace we use fence_array to keep that
> > ordering. Basically we create a fence_array that contains both the current
> > fence and the fence from the previous buffer (which might be a fence array
> > as well). The base fence class for the fence_array becomes the new buffer
> > fence, waiting on that one guarantees that it won't be queued out of
> > order.
>
> The API sounds/looks good to me, makes sense to let driver opt in/out
> via the ordered_in_vb2 thing. Thanks for implementing it!
>
> >
> > v5: - use fence_array to keep buffers ordered in vb2 core when
> > needed (Brian Stark)
> > - keep backward compatibility on the reserved2 field (Brian Stark)
> > - protect fence callback removal with lock (Brian Stark)
>
> Brian Starkey, but close ;-)
>
> >
> > v4:
> > - Add a comment about dma_fence_add_callback() not returning a
> > error (Hans)
> > - Call dma_fence_put(vb->in_fence) if fence signaled (Hans)
> > - select SYNC_FILE under config VIDEOBUF2_CORE (Hans)
> > - Move dma_fence_is_signaled() check to __enqueue_in_driver() (Hans)
> > - Remove list_for_each_entry() in __vb2_core_qbuf() (Hans)
> > - Remove if (vb->state != VB2_BUF_STATE_QUEUED) from
> > vb2_start_streaming() (Hans)
> > - set IN_FENCE flags on __fill_v4l2_buffer (Hans)
> > - Queue buffers to the driver as soon as they are ready (Hans)
> > - call fill_user_buffer() after queuing the buffer (Hans)
> > - add err: label to clean up fence
> > - add dma_fence_wait() before calling vb2_start_streaming()
> >
> > v3: - document fence parameter
> > - remove ternary if at vb2_qbuf() return (Mauro)
> > - do not change if conditions behaviour (Mauro)
> >
> > v2:
> > - fix vb2_queue_or_prepare_buf() ret check
> > - remove check for VB2_MEMORY_DMABUF only (Javier)
> > - check num of ready buffers to start streaming
> > - when queueing, start from the first ready buffer
> > - handle queue cancel
> >
> > Signed-off-by: Gustavo Padovan <gustavo.padovan@collabora.com>
> > ---
> > drivers/media/v4l2-core/Kconfig | 1 +
> > drivers/media/v4l2-core/videobuf2-core.c | 179 ++++++++++++++++++++++++++++---
> > drivers/media/v4l2-core/videobuf2-v4l2.c | 29 ++++-
> > include/media/videobuf2-core.h | 17 ++-
> > 4 files changed, 208 insertions(+), 18 deletions(-)
> >
> > diff --git a/drivers/media/v4l2-core/Kconfig b/drivers/media/v4l2-core/Kconfig
> > index a35c33686abf..3f988c407c80 100644
> > --- a/drivers/media/v4l2-core/Kconfig
> > +++ b/drivers/media/v4l2-core/Kconfig
> > @@ -83,6 +83,7 @@ config VIDEOBUF_DVB
> > # Used by drivers that need Videobuf2 modules
> > config VIDEOBUF2_CORE
> > select DMA_SHARED_BUFFER
> > + select SYNC_FILE
> > tristate
> >
> > config VIDEOBUF2_MEMOPS
> > diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c
> > index 60f8b582396a..78f369dba3e3 100644
> > --- a/drivers/media/v4l2-core/videobuf2-core.c
> > +++ b/drivers/media/v4l2-core/videobuf2-core.c
> > @@ -346,6 +346,7 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory,
> > vb->index = q->num_buffers + buffer;
> > vb->type = q->type;
> > vb->memory = memory;
> > + spin_lock_init(&vb->fence_cb_lock);
> > for (plane = 0; plane < num_planes; ++plane) {
> > vb->planes[plane].length = plane_sizes[plane];
> > vb->planes[plane].min_length = plane_sizes[plane];
> > @@ -1222,6 +1223,9 @@ static void __enqueue_in_driver(struct vb2_buffer *vb)
> > {
> > struct vb2_queue *q = vb->vb2_queue;
> >
> > + if (vb->in_fence && !dma_fence_is_signaled(vb->in_fence))
> > + return;
> > +
> > vb->state = VB2_BUF_STATE_ACTIVE;
> > atomic_inc(&q->owned_by_drv_count);
> >
> > @@ -1273,6 +1277,20 @@ static int __buf_prepare(struct vb2_buffer *vb, const void *pb)
> > return 0;
> > }
> >
> > +static int __get_num_ready_buffers(struct vb2_queue *q)
> > +{
> > + struct vb2_buffer *vb;
> > + int ready_count = 0;
> > +
> > + /* count num of buffers ready in front of the queued_list */
> > + list_for_each_entry(vb, &q->queued_list, queued_entry) {
> > + if (!vb->in_fence || dma_fence_is_signaled(vb->in_fence))
> > + ready_count++;
>
> I think there's still some races on vb->in_fence. Couldn't the
> callback on any of the buffers in the queued_list have their callback
> run at any moment?
>
> That could make this loop do bad things, and similarly the loop in
> vb2_start_streaming() which calls __enqueue_in_driver().
>
> > + }
> > +
> > + return ready_count;
> > +}
> > +
> > int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb)
> > {
> > struct vb2_buffer *vb;
> > @@ -1361,7 +1379,74 @@ static int vb2_start_streaming(struct vb2_queue *q)
> > return ret;
> > }
> >
> > -int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
> > +static struct dma_fence *__set_in_fence(struct vb2_queue *q,
> > + struct vb2_buffer *vb,
> > + struct dma_fence *fence)
> > +{
> > + if (q->last_fence && dma_fence_is_signaled(q->last_fence)) {
> > + dma_fence_put(q->last_fence);
> > + q->last_fence = NULL;
> > + }
> > +
> > + /* For drivers that require the ordering of buffers queued from
> > + * userspace to be the same it is queued to the driver - output
> > + * some m2m devices - we create a fence array with the fence from
> > + * the last queued buffer and this one, that way the fence for this
> > + * buffer can't signal before the last one.
> > + */
> > + if (q->is_output || q->ordered_in_vb2) {
>
> Just a stylistic thing - you could invert this conditional and return
> early, saving a level of indentation below.
>
> > + if (fence && q->last_fence) {
> > + struct dma_fence **fences;
> > + struct dma_fence_array *arr;
> > +
> > + fences = kcalloc(2, sizeof(*fences), GFP_KERNEL);
> > + if (!fences)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + fences[0] = fence;
> > + fences[1] = q->last_fence;
> > +
> > + arr = dma_fence_array_create(2, fences,
> > + dma_fence_context_alloc(1),
> > + 1, false);
>
> I'm not sure if it's right to get a new fence_context every time here.
> The comment on dma_fence_context_counter sounds like the vb2_queue
> should have a single context of its own.
>
> > + if (!arr) {
> > + kfree(fences);
> > + return ERR_PTR(-ENOMEM);
> > + }
> > +
> > + fence = &arr->base;
> > + } else if (!fence && q->last_fence) {
> > + fence = dma_fence_get(q->last_fence);
> > + }
> > +
> > + q->last_fence = dma_fence_get(fence);
>
> Seems like the refcounting isn't quite right here.
>
> If you land in "else if (!fence && q->last_fence)", then "fence" gets
> a new reference to q->last_fence, and you take another one here -
> which looks like one too many.
>
> I _think_ the right thing to do is just give the previous reference on
> q->last_fence to "fence", without taking a new one:
>
> } else if (!fence && q->last_fence) {
> fence = q->last_fence;
> }
>
> That's analogous to the other path where fence is not-NULL, and the
> fence-array takes ownership of the existing references on fence and
> q->last_fence, without taking new references.
>
> Please double check my logic though!
>
> > + }
> > +
> > + return fence;
> > +}
> > +
> > +static void vb2_qbuf_fence_cb(struct dma_fence *f, struct dma_fence_cb *cb)
> > +{
> > + struct vb2_buffer *vb = container_of(cb, struct vb2_buffer, fence_cb);
> > + struct vb2_queue *q = vb->vb2_queue;
> > + unsigned long flags;
> > +
> > + spin_lock_irqsave(&vb->fence_cb_lock, flags);
> > + if (!vb->in_fence) {
> > + spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
> > + return;
> > + }
> > +
> > + dma_fence_put(vb->in_fence);
> > + vb->in_fence = NULL;
> > + spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
> > +
> > + if (q->start_streaming_called)
> > + __enqueue_in_driver(vb);
> > +}
> > +
> > +int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
> > + struct dma_fence *fence)
> > {
> > struct vb2_buffer *vb;
> > int ret;
> > @@ -1372,16 +1457,18 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
> > case VB2_BUF_STATE_DEQUEUED:
> > ret = __buf_prepare(vb, pb);
> > if (ret)
> > - return ret;
> > + goto err;
> > break;
> > case VB2_BUF_STATE_PREPARED:
> > break;
> > case VB2_BUF_STATE_PREPARING:
> > dprintk(1, "buffer still being prepared\n");
> > - return -EINVAL;
> > + ret = -EINVAL;
> > + goto err;
> > default:
> > dprintk(1, "invalid buffer state %d\n", vb->state);
> > - return -EINVAL;
> > + ret = -EINVAL;
> > + goto err;
> > }
> >
> > /*
> > @@ -1398,30 +1485,75 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
> >
> > trace_vb2_qbuf(q, vb);
> >
> > + vb->in_fence = __set_in_fence(q, vb, fence);
> > + if (IS_ERR(vb->in_fence)) {
> > + ret = PTR_ERR(vb->in_fence);
> > + goto err;
>
> Between here, __set_in_fence() and vb2_qbuf() there's a reference
> leaked on "fence" in the case of error. I'm not sure what semantics
> you'd like, but it should be clear whose responsibility it is to clear
> up "fence" if __set_in_fence() fails (at the moment, looks like no-one
> does).
>
> > + }
>
> ... and if __set_in_fence() succeeds, then vb->in_fence now owns the
> reference on "fence" that was passed in, so I guess you should set
> fence = NULL here.
>
> > +
> > + /*
> > + * If it is time to call vb2_start_streaming() wait for the fence
> > + * to signal first. Of course, this happens only once per streaming.
> > + * We want to run any step that might fail before we set the callback
> > + * to queue the fence when it signals.
> > + */
> > + if (fence && !q->start_streaming_called &&
>
> I think this should be vb->in_fence now, and the same for all further
> uses of "fence" in this function.
>
> > + __get_num_ready_buffers(q) == q->min_buffers_needed - 1)
> > + dma_fence_wait(fence, true);
> > +
> > /*
> > * If streamon has been called, and we haven't yet called
> > * start_streaming() since not enough buffers were queued, and
> > * we now have reached the minimum number of queued buffers,
> > * then we can finally call start_streaming().
> > - *
> > - * If already streaming, give the buffer to driver for processing.
> > - * If not, the buffer will be given to driver on next streamon.
> > */
> > if (q->streaming && !q->start_streaming_called &&
> > - q->queued_count >= q->min_buffers_needed) {
> > + __get_num_ready_buffers(q) >= q->min_buffers_needed) {
> > ret = vb2_start_streaming(q);
> > if (ret)
> > - return ret;
> > - } else if (q->start_streaming_called) {
> > - __enqueue_in_driver(vb);
> > + goto err;
> > + }
> > +
> > + /*
> > + * For explicit synchronization: If the fence didn't signal
> > + * yet we setup a callback to queue the buffer once the fence
> > + * signals, and then, return successfully. But if the fence
> > + * already signaled we lose the reference we held and queue the
> > + * buffer to the driver.
> > + */
> > + if (fence) {
> > + ret = dma_fence_add_callback(fence, &vb->fence_cb,
> > + vb2_qbuf_fence_cb);
> > + if (!ret)
> > + goto fill;
>
> Just spotted that you should probably handle the -EINVAL case here and
> jump to err.
>
> > +
> > + dma_fence_put(fence);
> > + vb->in_fence = NULL;
> > }
> >
> > +fill:
> > + /*
> > + * If already streaming and there is no fence to wait on
> > + * give the buffer to driver for processing.
> > + */
> > + if (q->start_streaming_called && !vb->in_fence)
> > + __enqueue_in_driver(vb);
>
> The callback could have run just before this, clearing vb->in_fence
> and ending up with __enqueue_in_driver() getting called twice.
>
> > +
> > /* Fill buffer information for the userspace */
> > if (pb)
> > call_void_bufop(q, fill_user_buffer, vb, pb);
> >
> > dprintk(2, "qbuf of buffer %d succeeded\n", vb->index);
> > return 0;
> > +
> > +err:
> > + if (vb->in_fence) {
> > + dma_fence_put(vb->in_fence);
> > + vb->in_fence = NULL;
> > + }
> > +
> > + return ret;
> > +
> > }
> > EXPORT_SYMBOL_GPL(vb2_core_qbuf);
> >
> > @@ -1632,6 +1764,8 @@ EXPORT_SYMBOL_GPL(vb2_core_dqbuf);
> > static void __vb2_queue_cancel(struct vb2_queue *q)
> > {
> > unsigned int i;
> > + struct vb2_buffer *vb;
> > + unsigned long flags;
> >
> > /*
> > * Tell driver to stop all transactions and release all queued
> > @@ -1659,6 +1793,21 @@ static void __vb2_queue_cancel(struct vb2_queue *q)
> > q->queued_count = 0;
> > q->error = 0;
> >
> > + list_for_each_entry(vb, &q->queued_list, queued_entry) {
> > + spin_lock_irqsave(&vb->fence_cb_lock, flags);
> > + if (vb->in_fence) {
> > + dma_fence_remove_callback(vb->in_fence, &vb->fence_cb);
> > + dma_fence_put(vb->in_fence);
> > + vb->in_fence = NULL;
> > + }
> > + spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
> > + }
> > +
> > + if (q->last_fence) {
> > + dma_fence_put(q->last_fence);
> > + q->last_fence = NULL;
> > + }
> > +
> > /*
> > * Remove all buffers from videobuf's list...
> > */
> > @@ -1720,7 +1869,7 @@ int vb2_core_streamon(struct vb2_queue *q, unsigned int type)
> > * Tell driver to start streaming provided sufficient buffers
> > * are available.
> > */
> > - if (q->queued_count >= q->min_buffers_needed) {
> > + if (__get_num_ready_buffers(q) >= q->min_buffers_needed) {
> > ret = v4l_vb2q_enable_media_source(q);
> > if (ret)
> > return ret;
> > @@ -2240,7 +2389,7 @@ static int __vb2_init_fileio(struct vb2_queue *q, int read)
> > * Queue all buffers.
> > */
> > for (i = 0; i < q->num_buffers; i++) {
> > - ret = vb2_core_qbuf(q, i, NULL);
> > + ret = vb2_core_qbuf(q, i, NULL, NULL);
> > if (ret)
> > goto err_reqbufs;
> > fileio->bufs[i].queued = 1;
> > @@ -2419,7 +2568,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
> >
> > if (copy_timestamp)
> > b->timestamp = ktime_get_ns();
> > - ret = vb2_core_qbuf(q, index, NULL);
> > + ret = vb2_core_qbuf(q, index, NULL, NULL);
> > dprintk(5, "vb2_dbuf result: %d\n", ret);
> > if (ret)
> > return ret;
> > @@ -2522,7 +2671,7 @@ static int vb2_thread(void *data)
> > if (copy_timestamp)
> > vb->timestamp = ktime_get_ns();;
> > if (!threadio->stop)
> > - ret = vb2_core_qbuf(q, vb->index, NULL);
> > + ret = vb2_core_qbuf(q, vb->index, NULL, NULL);
> > call_void_qop(q, wait_prepare, q);
> > if (ret || threadio->stop)
> > break;
> > diff --git a/drivers/media/v4l2-core/videobuf2-v4l2.c b/drivers/media/v4l2-core/videobuf2-v4l2.c
> > index 110fb45fef6f..4c09ea007d90 100644
> > --- a/drivers/media/v4l2-core/videobuf2-v4l2.c
> > +++ b/drivers/media/v4l2-core/videobuf2-v4l2.c
> > @@ -23,6 +23,7 @@
> > #include <linux/sched.h>
> > #include <linux/freezer.h>
> > #include <linux/kthread.h>
> > +#include <linux/sync_file.h>
> >
> > #include <media/v4l2-dev.h>
> > #include <media/v4l2-fh.h>
> > @@ -178,6 +179,12 @@ static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b,
> > return -EINVAL;
> > }
> >
> > + if ((b->fence_fd != 0 && b->fence_fd != -1) &&
> > + !(b->flags & V4L2_BUF_FLAG_IN_FENCE)) {
> > + dprintk(1, "%s: fence_fd set without IN_FENCE flag\n", opname);
> > + return -EINVAL;
> > + }
> > +
> > return __verify_planes_array(q->bufs[b->index], b);
> > }
> >
> > @@ -203,9 +210,14 @@ static void __fill_v4l2_buffer(struct vb2_buffer *vb, void *pb)
> > b->timestamp = ns_to_timeval(vb->timestamp);
> > b->timecode = vbuf->timecode;
> > b->sequence = vbuf->sequence;
> > - b->fence_fd = -1;
> > b->reserved = 0;
> >
> > + b->fence_fd = -1;
> > + if (vb->in_fence)
> > + b->flags |= V4L2_BUF_FLAG_IN_FENCE;
> > + else
> > + b->flags &= ~V4L2_BUF_FLAG_IN_FENCE;
> > +
> > if (q->is_multiplanar) {
> > /*
> > * Fill in plane-related data if userspace provided an array
> > @@ -560,6 +572,7 @@ EXPORT_SYMBOL_GPL(vb2_create_bufs);
> >
> > int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
> > {
> > + struct dma_fence *fence = NULL;
> > int ret;
> >
> > if (vb2_fileio_is_active(q)) {
> > @@ -568,7 +581,19 @@ int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
> > }
> >
> > ret = vb2_queue_or_prepare_buf(q, b, "qbuf");
> > - return ret ? ret : vb2_core_qbuf(q, b->index, b);
> > + if (ret)
> > + return ret;
> > +
> > + if (b->flags & V4L2_BUF_FLAG_IN_FENCE) {
> > + fence = sync_file_get_fence(b->fence_fd);
>
> In DRM a fence_fd of -1 means "already signaled" - should that be
> allowed here too?
If it is already signaled we shouldn't even set the IN_FENCE
flag. There isn't much to gain from that. The current code already makes
sure to guarantee the ordering if a buffer don't have a fence.
Gustavo
@@ -83,6 +83,7 @@ config VIDEOBUF_DVB
# Used by drivers that need Videobuf2 modules
config VIDEOBUF2_CORE
select DMA_SHARED_BUFFER
+ select SYNC_FILE
tristate
config VIDEOBUF2_MEMOPS
@@ -346,6 +346,7 @@ static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory,
vb->index = q->num_buffers + buffer;
vb->type = q->type;
vb->memory = memory;
+ spin_lock_init(&vb->fence_cb_lock);
for (plane = 0; plane < num_planes; ++plane) {
vb->planes[plane].length = plane_sizes[plane];
vb->planes[plane].min_length = plane_sizes[plane];
@@ -1222,6 +1223,9 @@ static void __enqueue_in_driver(struct vb2_buffer *vb)
{
struct vb2_queue *q = vb->vb2_queue;
+ if (vb->in_fence && !dma_fence_is_signaled(vb->in_fence))
+ return;
+
vb->state = VB2_BUF_STATE_ACTIVE;
atomic_inc(&q->owned_by_drv_count);
@@ -1273,6 +1277,20 @@ static int __buf_prepare(struct vb2_buffer *vb, const void *pb)
return 0;
}
+static int __get_num_ready_buffers(struct vb2_queue *q)
+{
+ struct vb2_buffer *vb;
+ int ready_count = 0;
+
+ /* count num of buffers ready in front of the queued_list */
+ list_for_each_entry(vb, &q->queued_list, queued_entry) {
+ if (!vb->in_fence || dma_fence_is_signaled(vb->in_fence))
+ ready_count++;
+ }
+
+ return ready_count;
+}
+
int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb)
{
struct vb2_buffer *vb;
@@ -1361,7 +1379,74 @@ static int vb2_start_streaming(struct vb2_queue *q)
return ret;
}
-int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
+static struct dma_fence *__set_in_fence(struct vb2_queue *q,
+ struct vb2_buffer *vb,
+ struct dma_fence *fence)
+{
+ if (q->last_fence && dma_fence_is_signaled(q->last_fence)) {
+ dma_fence_put(q->last_fence);
+ q->last_fence = NULL;
+ }
+
+ /* For drivers that require the ordering of buffers queued from
+ * userspace to be the same it is queued to the driver - output
+ * some m2m devices - we create a fence array with the fence from
+ * the last queued buffer and this one, that way the fence for this
+ * buffer can't signal before the last one.
+ */
+ if (q->is_output || q->ordered_in_vb2) {
+ if (fence && q->last_fence) {
+ struct dma_fence **fences;
+ struct dma_fence_array *arr;
+
+ fences = kcalloc(2, sizeof(*fences), GFP_KERNEL);
+ if (!fences)
+ return ERR_PTR(-ENOMEM);
+
+ fences[0] = fence;
+ fences[1] = q->last_fence;
+
+ arr = dma_fence_array_create(2, fences,
+ dma_fence_context_alloc(1),
+ 1, false);
+ if (!arr) {
+ kfree(fences);
+ return ERR_PTR(-ENOMEM);
+ }
+
+ fence = &arr->base;
+ } else if (!fence && q->last_fence) {
+ fence = dma_fence_get(q->last_fence);
+ }
+
+ q->last_fence = dma_fence_get(fence);
+ }
+
+ return fence;
+}
+
+static void vb2_qbuf_fence_cb(struct dma_fence *f, struct dma_fence_cb *cb)
+{
+ struct vb2_buffer *vb = container_of(cb, struct vb2_buffer, fence_cb);
+ struct vb2_queue *q = vb->vb2_queue;
+ unsigned long flags;
+
+ spin_lock_irqsave(&vb->fence_cb_lock, flags);
+ if (!vb->in_fence) {
+ spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
+ return;
+ }
+
+ dma_fence_put(vb->in_fence);
+ vb->in_fence = NULL;
+ spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
+
+ if (q->start_streaming_called)
+ __enqueue_in_driver(vb);
+}
+
+int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
+ struct dma_fence *fence)
{
struct vb2_buffer *vb;
int ret;
@@ -1372,16 +1457,18 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
case VB2_BUF_STATE_DEQUEUED:
ret = __buf_prepare(vb, pb);
if (ret)
- return ret;
+ goto err;
break;
case VB2_BUF_STATE_PREPARED:
break;
case VB2_BUF_STATE_PREPARING:
dprintk(1, "buffer still being prepared\n");
- return -EINVAL;
+ ret = -EINVAL;
+ goto err;
default:
dprintk(1, "invalid buffer state %d\n", vb->state);
- return -EINVAL;
+ ret = -EINVAL;
+ goto err;
}
/*
@@ -1398,30 +1485,75 @@ int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb)
trace_vb2_qbuf(q, vb);
+ vb->in_fence = __set_in_fence(q, vb, fence);
+ if (IS_ERR(vb->in_fence)) {
+ ret = PTR_ERR(vb->in_fence);
+ goto err;
+ }
+
+ /*
+ * If it is time to call vb2_start_streaming() wait for the fence
+ * to signal first. Of course, this happens only once per streaming.
+ * We want to run any step that might fail before we set the callback
+ * to queue the fence when it signals.
+ */
+ if (fence && !q->start_streaming_called &&
+ __get_num_ready_buffers(q) == q->min_buffers_needed - 1)
+ dma_fence_wait(fence, true);
+
/*
* If streamon has been called, and we haven't yet called
* start_streaming() since not enough buffers were queued, and
* we now have reached the minimum number of queued buffers,
* then we can finally call start_streaming().
- *
- * If already streaming, give the buffer to driver for processing.
- * If not, the buffer will be given to driver on next streamon.
*/
if (q->streaming && !q->start_streaming_called &&
- q->queued_count >= q->min_buffers_needed) {
+ __get_num_ready_buffers(q) >= q->min_buffers_needed) {
ret = vb2_start_streaming(q);
if (ret)
- return ret;
- } else if (q->start_streaming_called) {
- __enqueue_in_driver(vb);
+ goto err;
+ }
+
+ /*
+ * For explicit synchronization: If the fence didn't signal
+ * yet we setup a callback to queue the buffer once the fence
+ * signals, and then, return successfully. But if the fence
+ * already signaled we lose the reference we held and queue the
+ * buffer to the driver.
+ */
+ if (fence) {
+ ret = dma_fence_add_callback(fence, &vb->fence_cb,
+ vb2_qbuf_fence_cb);
+ if (!ret)
+ goto fill;
+
+ dma_fence_put(fence);
+ vb->in_fence = NULL;
}
+fill:
+ /*
+ * If already streaming and there is no fence to wait on
+ * give the buffer to driver for processing.
+ */
+ if (q->start_streaming_called && !vb->in_fence)
+ __enqueue_in_driver(vb);
+
/* Fill buffer information for the userspace */
if (pb)
call_void_bufop(q, fill_user_buffer, vb, pb);
dprintk(2, "qbuf of buffer %d succeeded\n", vb->index);
return 0;
+
+err:
+ if (vb->in_fence) {
+ dma_fence_put(vb->in_fence);
+ vb->in_fence = NULL;
+ }
+
+ return ret;
+
}
EXPORT_SYMBOL_GPL(vb2_core_qbuf);
@@ -1632,6 +1764,8 @@ EXPORT_SYMBOL_GPL(vb2_core_dqbuf);
static void __vb2_queue_cancel(struct vb2_queue *q)
{
unsigned int i;
+ struct vb2_buffer *vb;
+ unsigned long flags;
/*
* Tell driver to stop all transactions and release all queued
@@ -1659,6 +1793,21 @@ static void __vb2_queue_cancel(struct vb2_queue *q)
q->queued_count = 0;
q->error = 0;
+ list_for_each_entry(vb, &q->queued_list, queued_entry) {
+ spin_lock_irqsave(&vb->fence_cb_lock, flags);
+ if (vb->in_fence) {
+ dma_fence_remove_callback(vb->in_fence, &vb->fence_cb);
+ dma_fence_put(vb->in_fence);
+ vb->in_fence = NULL;
+ }
+ spin_unlock_irqrestore(&vb->fence_cb_lock, flags);
+ }
+
+ if (q->last_fence) {
+ dma_fence_put(q->last_fence);
+ q->last_fence = NULL;
+ }
+
/*
* Remove all buffers from videobuf's list...
*/
@@ -1720,7 +1869,7 @@ int vb2_core_streamon(struct vb2_queue *q, unsigned int type)
* Tell driver to start streaming provided sufficient buffers
* are available.
*/
- if (q->queued_count >= q->min_buffers_needed) {
+ if (__get_num_ready_buffers(q) >= q->min_buffers_needed) {
ret = v4l_vb2q_enable_media_source(q);
if (ret)
return ret;
@@ -2240,7 +2389,7 @@ static int __vb2_init_fileio(struct vb2_queue *q, int read)
* Queue all buffers.
*/
for (i = 0; i < q->num_buffers; i++) {
- ret = vb2_core_qbuf(q, i, NULL);
+ ret = vb2_core_qbuf(q, i, NULL, NULL);
if (ret)
goto err_reqbufs;
fileio->bufs[i].queued = 1;
@@ -2419,7 +2568,7 @@ static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_
if (copy_timestamp)
b->timestamp = ktime_get_ns();
- ret = vb2_core_qbuf(q, index, NULL);
+ ret = vb2_core_qbuf(q, index, NULL, NULL);
dprintk(5, "vb2_dbuf result: %d\n", ret);
if (ret)
return ret;
@@ -2522,7 +2671,7 @@ static int vb2_thread(void *data)
if (copy_timestamp)
vb->timestamp = ktime_get_ns();;
if (!threadio->stop)
- ret = vb2_core_qbuf(q, vb->index, NULL);
+ ret = vb2_core_qbuf(q, vb->index, NULL, NULL);
call_void_qop(q, wait_prepare, q);
if (ret || threadio->stop)
break;
@@ -23,6 +23,7 @@
#include <linux/sched.h>
#include <linux/freezer.h>
#include <linux/kthread.h>
+#include <linux/sync_file.h>
#include <media/v4l2-dev.h>
#include <media/v4l2-fh.h>
@@ -178,6 +179,12 @@ static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b,
return -EINVAL;
}
+ if ((b->fence_fd != 0 && b->fence_fd != -1) &&
+ !(b->flags & V4L2_BUF_FLAG_IN_FENCE)) {
+ dprintk(1, "%s: fence_fd set without IN_FENCE flag\n", opname);
+ return -EINVAL;
+ }
+
return __verify_planes_array(q->bufs[b->index], b);
}
@@ -203,9 +210,14 @@ static void __fill_v4l2_buffer(struct vb2_buffer *vb, void *pb)
b->timestamp = ns_to_timeval(vb->timestamp);
b->timecode = vbuf->timecode;
b->sequence = vbuf->sequence;
- b->fence_fd = -1;
b->reserved = 0;
+ b->fence_fd = -1;
+ if (vb->in_fence)
+ b->flags |= V4L2_BUF_FLAG_IN_FENCE;
+ else
+ b->flags &= ~V4L2_BUF_FLAG_IN_FENCE;
+
if (q->is_multiplanar) {
/*
* Fill in plane-related data if userspace provided an array
@@ -560,6 +572,7 @@ EXPORT_SYMBOL_GPL(vb2_create_bufs);
int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
{
+ struct dma_fence *fence = NULL;
int ret;
if (vb2_fileio_is_active(q)) {
@@ -568,7 +581,19 @@ int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b)
}
ret = vb2_queue_or_prepare_buf(q, b, "qbuf");
- return ret ? ret : vb2_core_qbuf(q, b->index, b);
+ if (ret)
+ return ret;
+
+ if (b->flags & V4L2_BUF_FLAG_IN_FENCE) {
+ fence = sync_file_get_fence(b->fence_fd);
+ if (!fence) {
+ dprintk(1, "failed to get in-fence from fd %d\n",
+ b->fence_fd);
+ return -EINVAL;
+ }
+ }
+
+ return vb2_core_qbuf(q, b->index, b, fence);
}
EXPORT_SYMBOL_GPL(vb2_qbuf);
@@ -16,6 +16,7 @@
#include <linux/mutex.h>
#include <linux/poll.h>
#include <linux/dma-buf.h>
+#include <linux/dma-fence.h>
#define VB2_MAX_FRAME (32)
#define VB2_MAX_PLANES (8)
@@ -254,11 +255,20 @@ struct vb2_buffer {
* all buffers queued from userspace
* done_entry: entry on the list that stores all buffers ready
* to be dequeued to userspace
+ * in_fence: fence receive from vb2 client to wait on before
+ * using the buffer (queueing to the driver)
+ * fence_cb: fence callback information
+ * fence_cb_lock: protect callback signal/remove
*/
enum vb2_buffer_state state;
struct list_head queued_entry;
struct list_head done_entry;
+
+ struct dma_fence *in_fence;
+ struct dma_fence_cb fence_cb;
+ spinlock_t fence_cb_lock;
+
#ifdef CONFIG_VIDEO_ADV_DEBUG
/*
* Counters for how often these buffer-related ops are
@@ -508,6 +518,7 @@ struct vb2_buf_ops {
* @ordered_in_vb2: set by the driver to tell vb2 te guarantee the order
* of buffer queue from userspace with QBUF() until they are
* queued to the driver.
+ * @last_fence: last in-fence received. Used to keep ordering.
* @fileio: file io emulator internal data, used only if emulator is active
* @threadio: thread io internal data, used only if thread is active
*/
@@ -563,6 +574,8 @@ struct vb2_queue {
unsigned int ordered_in_driver:1;
unsigned int ordered_in_vb2:1;
+ struct dma_fence *last_fence;
+
struct vb2_fileio_data *fileio;
struct vb2_threadio_data *threadio;
@@ -738,6 +751,7 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb);
* @index: id number of the buffer
* @pb: buffer structure passed from userspace to vidioc_qbuf handler
* in driver
+ * @fence: in-fence to wait on before queueing the buffer
*
* Should be called from vidioc_qbuf ioctl handler of a driver.
* The passed buffer should have been verified.
@@ -752,7 +766,8 @@ int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb);
* The return values from this function are intended to be directly returned
* from vidioc_qbuf handler in driver.
*/
-int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb);
+int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb,
+ struct dma_fence *fence);
/**
* vb2_core_dqbuf() - Dequeue a buffer to the userspace