Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1300532 > unrolled thread

Re: Re: [PATCH] Input: evdev - drop partial events after emptying the buffer

Back to article view | Back to linux.kernel

Contents

  Re: Re: [PATCH] Input: evdev - drop partial events after emptying the  buffer Aniroop Mathur <a.mathur@samsung.com> - 2016-01-04 09:00 +0100
    Re: Re: [PATCH] Input: evdev - drop partial events after emptying the buffer Benjamin Tissoires <benjamin.tissoires@gmail.com> - 2016-01-04 10:00 +0100

#1300532 — Re: Re: [PATCH] Input: evdev - drop partial events after emptying the buffer
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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1300559 — Re: Re: [PATCH] Input: evdev - drop partial events after emptying the buffer

On Mon, Jan 4, 2016 at 8:50 AM, Aniroop Mathur <a.mathur@samsung.com> wrote:
> On Jan 4, 2016 5:08 AM, "Peter Hutterer" <peter.hutterer@who-t.net> wrote:
>>
>> On Sat, Jan 02, 2016 at 08:39:21PM -0800, Dmitry Torokhov wrote:
>> > On Thu, Dec 31, 2015 at 03:36:47AM +0530, Aniroop Mathur wrote:
>> > > This patch introduces concept to drop partial events in evdev handler
>> > > itself after emptying the buffer which are dropped by all evdev
>> > > clients in userspace after SYN_DROPPED occurs.
>> > > This in turn saves space of partial events in evdev handler buffer
>> > > and reduces evdev client reading requests.
>> >
>> > Let's add a few people who write consumer code to see if this is
>> > something that they consider useful.
>>
>> yeah, it's useful though we already have the code in libevdev to work around
>> this. Still, it reduces the number of events discarde by the client, so it'll be a net
>> plus. but, afaict, there's a bug in this implementation.
>> The doc states: "Client should ignore all events up to and including next
>> SYN_REPORT event". If you drop partial events, you need to have an empty
>> SYN_REPORT after the SYN_DROPPED before you start with full events again.
>> This patch skips that, so after the SYN_DROPPED you have a valid full event
>> that will be ignored by any client currently capable of handling
>> SYN_DROPPED.
>> Example: let's assume a device sending ABS_X/ABS_Y fast enough to cause a
>> SYN_DROPPED, you may have this queue:
>>     ABS_X
>>     ABS_Y
>>     SYN_REPORT
>>     ...
>>     SYN_DROPPED
>>     ABS_Y      <---- partial event
>>     SYN_REPORT <---- client discards up to here, sync state
>>     ABS_X
>>     ABS_Y
>>     SYN_REPORT <---- first full event after sync
>>
>> With this patch this sequence becomes:
>>     ABS_X
>>     ABS_Y
>>     SYN_REPORT
>>     ...
>>     SYN_DROPPED
>>         [kernel discards ABS_Y + SYN_REPORT as partial event]
>>     ABS_X
>>     ABS_Y
>>     SYN_REPORT <--- client discards up to here, sync state
>>                <--- there is no event after sync
>>
>> That's a change in kernel behaviour and will make all current clients
>> potentially buggy, you'll really need the empty SYN_REPORT here.
>>
>
> Thank you for your input, Mr. Peter.
> Actually, there is a need to update the documentation as well after this patch
> so that clients no more ignore the events after SYN_DROPPED occurs and
> should read the events normally. I skipped updating the documentation in
> this patch as I thought of getting a consent first.
> * SYN_DROPPED:
>   - Used to indicate buffer overrun in the evdev client's event queue.
>     Client should ignore all events up to and including next SYN_REPORT
>     event and query the device (using EVIOCG* ioctls) to obtain its
>     current state
>     + From kernel version <4.4.x> onwards, clients do no need to ignore
>     + events anymore and should read normally as there will be no
>     + partial events after SYN_DROPPED occurs.

Hi Aniroop,

this just won't do. As Peter said, there are current implementation of
SYN_DROPPED around, which ignore the events until the next SYN_REPORT.
If you change the protocol by updating the doc, you will just break
existing userspace which has not included a check on the kernel
version (and honestly, checking the kernel version from the userspace
point of view is just a nightmare when distributions start backporting
changes here and there).

The kernel rule is "do not break userspace", so we can not accept this.
Peter suggested you just add an empty SYN_REPORT after SYN_DROPPED
which would solve the whole problem: clients already handling
SYN_DROPPED will receive the next valid event, and those who don't (or
which will be updated) will not have to do anything more.

The only cons I can think of is that multitouch protocol A will be a
pain to handle with this empty SYN_REPORT if you do not handle the
SYN_DROPPED as per the doc.
But on the other hand, if you have a MT protocol A device, you are
screwed anyway because you need mtdev and so let's use libevdev at
this point.

>
> As far as I've worked on client codes, this client code change is easy and

Nope, checking the kernel version is not "easy" as this is not reliable.

> even if some clients miss to update the code then it seems not much of
> a problem because 8 packets are already dropped so an additional packet
> would not cause any trouble in case of buffer overrun.

Nope again. In case of a SYN_DROPPED, the client syncs its internal
state by using ioctls. So if you drop one valid event, you are not in
sync again and the SYN_DROPPED is moot.

Cheers,
Benjamin

>
> Regards,
> Aniroop Mathur
>
>> > >
>> > > Signed-off-by: Aniroop Mathur <a.mathur@samsung.com>
>> > > ---
>> > >  drivers/input/evdev.c | 49 +++++++++++++++++++++++++++++++++++++++++++++----
>> > >  1 file changed, 45 insertions(+), 4 deletions(-)
>> > >
>> > > diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
>> > > index e9ae3d5..e7b612e 100644
>> > > --- a/drivers/input/evdev.c
>> > > +++ b/drivers/input/evdev.c
>> > > @@ -58,6 +58,7 @@ struct evdev_client {
>> > >     struct list_head node;
>> > >     unsigned int clk_type;
>> > >     bool revoked;
>> > > +   bool drop_pevent; /* specifies whether partial events need to be dropped */
>> > >     unsigned long *evmasks[EV_CNT]; > >     unsigned int bufsize;
>> > >     struct input_event buffer[];
>> > > @@ -192,6 +193,7 @@ static int evdev_set_clk_type(struct evdev_client *client, unsigned int clkid)
>> > >  {
>> > >     unsigned long flags;
>> > >     unsigned int clk_type;
>> > > +   struct input_event *ev;
>> > >
>> > >     switch (clkid) {
>> > >
>> > > @@ -218,6 +220,17 @@ static int evdev_set_clk_type(struct evdev_client *client, unsigned int clkid)
>> > >             spin_lock_irqsave(&client->buffer_lock, flags);
>> > >
>> > >             if (client->head != client->tail) {
>> > > +
>> > > +                   /*
>> > > +                    * Set drop_pevent to true if last event packet is
>> > > +                    * not stored completely in buffer.
>> > > +                    */
>> > > +                   client->head--;
>> > > +                   client->head &= client->bufsize - 1;
>> > > +                   ev = &client->buffer[client->head];
>> > > +                   if (!(ev->type == EV_SYN && ev->code == SYN_REPORT))
>> > > +                           client->drop_pevent = true;
>> > > +
>> > >                     client->packet_head = client->head = client->tail;
>> > >                     __evdev_queue_syn_dropped(client);
>> > >             }
>> > > @@ -228,31 +241,51 @@ static int evdev_set_clk_type(struct evdev_client *client, unsigned int clkid)
>> > >     return 0;
>> > >  }
>> > >
>> > > -static void __pass_event(struct evdev_client *client,
>> > > +static bool __pass_event(struct evdev_client *client,
>> > >                      const struct input_event *event)
>> > >  {
>> > > +   struct input_event *prev_ev;
>> > > +
>> > >     client->buffer[client->head++] = *event;
>> > >     client->head &= client->bufsize - 1;
>> > >
>> > >     if (unlikely(client->head == client->tail)) {
>> > >             /*
>> > > -            * This effectively "drops" all unconsumed events, leaving
>> > > -            * EV_SYN/SYN_DROPPED plus the newest event in the queue.
>> > > +            * This effectively "drops" all unconsumed events, storing
>> > > +            * EV_SYN/SYN_DROPPED and the newest event in the queue but
>> > > +            * only if it is not part of partial packet.
>> > > +            * Set drop_pevent to true if last event packet is not stored
>> > > +            * completely in buffer and set to false if SYN_REPORT occurs.
>> > >              */
>> > > +
>> > >             client->tail = (client->head - 2) & (client->bufsize - 1);
>> > >
>> > > +           prev_ev = &client->buffer[client->tail];
>> > > +           if (!(prev_ev->type == EV_SYN && prev_ev->code == SYN_REPORT)) {
>>
>> IMO a (prev_ev->type != EV_SYN || prev_ev->code != SYN_REPORT) would be
>> easier to read than this (!(a && b)).
>>
>> Cheers,
>>    Peter
>>
>> > > +                   client->drop_pevent = true;
>> > > +                   client->head--;
>> > > +                   client->head &= client->bufsize - 1;
>> > > +           }
>> > > +
>> > >             client->buffer[client->tail].time = event->time;
>> > >             client->buffer[client->tail].type = EV_SYN;
>> > >             client->buffer[client->tail].code = SYN_DROPPED;
>> > >             client->buffer[client->tail].value = 0;
>> > >
>> > >             client->packet_head = client->tail;
>> > > +
>> > > +           if (event->type == EV_SYN && event->code == SYN_REPORT) {
>> > > +                   client->drop_pevent = false;
>> > > +                   return true;
>> > > +           }
>> > >     }
>> > >
>> > >     if (event->type == EV_SYN && event->code == SYN_REPORT) {
>> > >             client->packet_head = client->head;
>> > >             kill_fasync(&client->fasync, SIGIO, POLL_IN);
>> > >     }
>> > > +
>> > > +   return false;
>> > >  }
>> > >
>> > >  static void evdev_pass_values(struct evdev_client *client,
>> > > @@ -284,10 +317,18 @@ static void evdev_pass_values(struct evdev_client *client,
>> > >                     wakeup = true;
>> > >             }
>> > >
>> > > +           /* drop partial events until SYN_REPORT occurs */
>> > > +           if (client->drop_pevent) {
>> > > +                   if (v->type == EV_SYN && v->code == SYN_REPORT)
>> > > +                           client->drop_pevent = false;
>> > > +                   continue;
>> > > +           }
>> > > +
>> > >             event.type = v->type;
>> > >             event.code = v->code;
>> > >             event.value = v->value;
>> > > -           __pass_event(client, &event);
>> > > +           if (__pass_event(client, &event))
>> > > +                   wakeup = false;
>> > >     }
>> > >
>> > >     spin_unlock(&client->buffer_lock);
>> > > --
>> > > 2.6.2
>> > >
>> >
>> > --
>> > Dmitry
>
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web