media: v4l2-event: keep place in event list when combining events
PATCH 1/1 media: v4l2-event: keep place in event list when combining events
When subscribing to an event a fixed circular buffer of N (N >= 1) events is allocated for that file handle.
New events of the same type are added to that buffer and eventually the oldest event is removed from the buffer when VIDIOC_DQEVENT is called.
If the circular buffer is full, then the event framework will merge the two oldest events (what 'merge' means is event type specific).
So far, so good.
There is also a per-filehandle list of pending events for all event types. VIDIOC_DQEVENT always dequeues the oldest of that event list, and that event is removed from the corresponding circular buffer.
The problem occurs when the circular buffer is full and a new event arrives. Then the two oldest events are merged, but instead of keeping the position in the list of pending events, the merged event is added to the *end* of the list of pending events.
So if a lot of events are generated, then events can continually be pushed to the end of the list of pending events, and so are never or much later dequeued by the application.
Effectively this is a denial-of-service situation were the event is never seen by the application even though there are actually a lot of events.
So if you subscribe to events from control A and B, then change control A, then change control B, then change control A again, and now call VIDIOC_DQEVENT, you will get the event from control B followed by A, even though A was changed first.
This patch keeps the oldest event in its place in the 'pending events' list rather then moving it to the end, and in the test above you will now receive the event from control A first.
--- drivers/media/v4l2-core/v4l2-event.c | 65 ++++++++++++++++++++-------- 1 file changed, 47 insertions(+), 18 deletions(-)
drivers/media/v4l2-core/v4l2-event.c +47 -18
@@ -104,41 +104,70 @@ static void __v4l2_event_queue_fh(struct v4l2_fh *fh, {struct v4l2_subscribed_event *sev;struct v4l2_kevent *kev; -bool copy_payload = true;/* Are we subscribed? */ sev =v4l2_event_subscribed (fh, ev->type, ev->id);if (sev ==NULL )return ; -/* Increase event sequence number on fh. */ - fh->sequence++; -/* Do we have any free events? */ if (sev->in_use == sev->elems) { -/* no, remove the oldest one */ - kev = sev->events +sev_pos (sev,0 ); -list_del (&kev->list); - sev->in_use--; - sev->first =sev_pos (sev,1 ); - fh->navailable--; +/* +* No, so we have to make space. +* +* This is a bit tricky: the easy solution is to drop the oldest +* event from the fh->available list and add the new one to +* the end of the list. However, that can lead to situation +* were, if there are a lot of events, the oldest event keeps +* being removed before it can be dequeued by the application. +* Effectively this is a denial-of-service situation were the +* event is never seen by the application even though there are +* actually a lot of events. +* +* So instead we take care to keep the oldest event in its +* place, and instead either replace the event content with +* the new event (if sev->elems == 1) or merge the 2nd oldest +* event with the oldest event. +*/ +struct v4l2_kevent *oldest = sev->events +sev_pos (sev,0 ); +struct v4l2_kevent *second_oldest; +if (sev->elems ==1 ) {if (sev->ops && sev->ops->replace) { - sev->ops->replace (&kev->event, ev); - copy_payload = false; +/* Replace the oldest event with the new event */ + sev->ops->replace (&oldest->event, ev); + }else { + oldest->event.u = ev->u; } - }else if (sev->ops && sev->ops->merge) { -struct v4l2_kevent *second_oldest = - sev->events +sev_pos (sev,0 ); - sev->ops->merge (&kev->event, &second_oldest->event); +wake_up_all (&fh->wait); +return ; } + second_oldest = sev->events +sev_pos (sev,1 ); +if (sev->ops && sev->ops->merge) { +/* Merge the oldest event with the 2nd oldest event */ + sev->ops->merge (&oldest->event, &second_oldest->event); + } + +/* +* Replace the oldest event with the second oldest event in the +* event list. +*/ + second_oldest->event.sequence = oldest->event.sequence; + second_oldest->ts = oldest->ts; +list_del (&second_oldest->list); +list_replace_init (&oldest->list, &second_oldest->list); + sev->first =sev_pos (sev,1 ); + sev->in_use--; + fh->navailable--; } +/* Increase event sequence number on fh. */ + fh->sequence++; +/* Take one and fill it. */ kev = sev->events +sev_pos (sev, sev->in_use); kev->event.type = ev->type; -if (copy_payload) - kev->event.u = ev->u; + kev->event.u = ev->u; kev->event.id = ev->id; kev->ts = ts; kev->event.sequence = fh->sequence;
Signature · 1 line
2.51.0