From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S935603AbcJ0C4c (ORCPT ); Wed, 26 Oct 2016 22:56:32 -0400 Received: from leo.clearchain.com ([199.73.29.74]:11803 "EHLO mail.clearchain.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932332AbcJ0C43 (ORCPT ); Wed, 26 Oct 2016 22:56:29 -0400 Date: Thu, 27 Oct 2016 12:56:16 +1000 From: Peter Hutterer To: Deepa Dinamani Cc: Dmitry Torokhov , linux-input@vger.kernel.org, linux-kernel@vger.kernel.org, arnd@arndb.de, y2038@lists.linaro.org Subject: Re: [PATCH v2 3/4] input: Deprecate real timestamps beyond year 2106 Message-ID: <20161027025616.GC14832@jelly> References: <1476761253-13450-1-git-send-email-deepa.kernel@gmail.com> <1476761253-13450-4-git-send-email-deepa.kernel@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1476761253-13450-4-git-send-email-deepa.kernel@gmail.com> User-Agent: Mutt/1.7.1 (2016-10-04) X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.4.3 (mail.clearchain.com [127.0.0.1]); Thu, 27 Oct 2016 13:32:04 +1030 (CST) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Mon, Oct 17, 2016 at 08:27:32PM -0700, Deepa Dinamani wrote: > struct timeval is not y2038 safe. > All usage of timeval in the kernel will be replaced by > y2038 safe structures. > > struct input_event maintains time for each input event. > Real time timestamps are not ideal for input as this > time can go backwards as noted in the patch a80b83b7b8 > by John Stultz. Hence, having the input_event.time fields > only big enough for monotonic and boot times are > sufficient. > > Leave the original input_event as is. This is to maintain > backward compatibility with existing userspace interfaces > that use input_event. > Introduce a new replacement struct raw_input_event. general comment here - please don't name it "raw_input_event". First, when you grep for input_event you want the new ones to show up too, so a struct input_event_raw would be better here. That also has better namespacing in general. Second though: the event isn't any more "raw" than the previous we had. I can't think of anything better than struct input_event_v2 though. > This replaces timeval with struct input_timeval. This structure > maintains time in __kernel_ulong_t or compat_ulong_t to allow > for architectures to override types as in the case of x32. > > The change requires any userspace utilities reading or writing > from event nodes to update their reading format to match > raw_input_event. The changes to the popular libraries will be > posted along with the kernel changes. > The driver version is also updated to reflect the change in > event format. Doesn't this break *all* of userspace then? I don't see anything to negotiate the type of input event the kernel gives me. And nothing right now checks for EVDEV_VERSION, so they all just assume it's a struct input_event. Best case, if the available events aren't a multiple of sizeof(struct input_event) userspace will bomb out, but unless that happens, everyone will just happily read old-style events. So we need some negotiation what is acceptable. Which also needs to address the race conditions we're going to get when events start coming in before the client has announced that it supports the new-style events. Cheers, Peter > Suggested-by: Arnd Bergmann > Signed-off-by: Deepa Dinamani > Reviewed-by: Arnd Bergmann > --- > drivers/input/evdev.c | 20 +++++++++---------- > drivers/input/input-compat.c | 29 ++++++++++++++------------- > drivers/input/input-compat.h | 19 +++++++++++------- > drivers/input/misc/uinput.c | 6 +++--- > include/linux/uinput.h | 2 +- > include/uapi/linux/input.h | 47 ++++++++++++++++++++++++++++++++++++++++++++ > 6 files changed, 88 insertions(+), 35 deletions(-) > > diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c > index b4e3171..459e3ba 100644 > --- a/drivers/input/evdev.c > +++ b/drivers/input/evdev.c > @@ -60,7 +60,7 @@ struct evdev_client { > bool revoked; > unsigned long *evmasks[EV_CNT]; > unsigned int bufsize; > - struct input_event buffer[]; > + struct raw_input_event buffer[]; > }; > > static size_t evdev_get_mask_cnt(unsigned int type) > @@ -113,7 +113,7 @@ static void __evdev_flush_queue(struct evdev_client *client, unsigned int type) > unsigned int i, head, num; > unsigned int mask = client->bufsize - 1; > bool is_report; > - struct input_event *ev; > + struct raw_input_event *ev; > > BUG_ON(type == EV_SYN); > > @@ -155,7 +155,7 @@ static void __evdev_flush_queue(struct evdev_client *client, unsigned int type) > > static void __evdev_queue_syn_dropped(struct evdev_client *client) > { > - struct input_event ev; > + struct raw_input_event ev; > struct timespec64 ts; > > switch (client->clk_type) { > @@ -236,7 +236,7 @@ static int evdev_set_clk_type(struct evdev_client *client, unsigned int clkid) > } > > static void __pass_event(struct evdev_client *client, > - const struct input_event *event) > + const struct raw_input_event *event) > { > client->buffer[client->head++] = *event; > client->head &= client->bufsize - 1; > @@ -268,7 +268,7 @@ static void evdev_pass_values(struct evdev_client *client, > { > struct evdev *evdev = client->evdev; > const struct input_value *v; > - struct input_event event; > + struct raw_input_event event; > struct timespec64 ts; > bool wakeup = false; > > @@ -507,7 +507,7 @@ static int evdev_open(struct inode *inode, struct file *file) > struct evdev *evdev = container_of(inode->i_cdev, struct evdev, cdev); > unsigned int bufsize = evdev_compute_buffer_size(evdev->handle.dev); > unsigned int size = sizeof(struct evdev_client) + > - bufsize * sizeof(struct input_event); > + bufsize * sizeof(struct raw_input_event); > struct evdev_client *client; > int error; > > @@ -542,7 +542,7 @@ static ssize_t evdev_write(struct file *file, const char __user *buffer, > { > struct evdev_client *client = file->private_data; > struct evdev *evdev = client->evdev; > - struct input_event event; > + struct raw_input_event event; > int retval = 0; > > if (count != 0 && count < input_event_size()) > @@ -575,7 +575,7 @@ static ssize_t evdev_write(struct file *file, const char __user *buffer, > } > > static int evdev_fetch_next_event(struct evdev_client *client, > - struct input_event *event) > + struct raw_input_event *event) > { > int have_event; > > @@ -597,7 +597,7 @@ static ssize_t evdev_read(struct file *file, char __user *buffer, > { > struct evdev_client *client = file->private_data; > struct evdev *evdev = client->evdev; > - struct input_event event; > + struct raw_input_event event; > size_t read = 0; > int error; > > @@ -1083,7 +1083,7 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd, > switch (cmd) { > > case EVIOCGVERSION: > - return put_user(EV_VERSION, ip); > + return put_user(EV_VERSION_1_2, ip); > > case EVIOCGID: > if (copy_to_user(p, &dev->id, sizeof(struct input_id))) > diff --git a/drivers/input/input-compat.c b/drivers/input/input-compat.c > index d84d20b..b58d35c 100644 > --- a/drivers/input/input-compat.c > +++ b/drivers/input/input-compat.c > @@ -15,13 +15,13 @@ > #ifdef CONFIG_COMPAT > > int input_event_from_user(const char __user *buffer, > - struct input_event *event) > + struct raw_input_event *event) > { > - if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) { > - struct input_event_compat compat_event; > + if (in_compat_syscall()) { > + struct raw_input_event_compat compat_event; > > if (copy_from_user(&compat_event, buffer, > - sizeof(struct input_event_compat))) > + sizeof(struct raw_input_event_compat))) > return -EFAULT; > > event->time.tv_sec = compat_event.time.tv_sec; > @@ -31,7 +31,8 @@ int input_event_from_user(const char __user *buffer, > event->value = compat_event.value; > > } else { > - if (copy_from_user(event, buffer, sizeof(struct input_event))) > + if (copy_from_user(event, buffer, > + sizeof(struct raw_input_event))) > return -EFAULT; > } > > @@ -39,10 +40,10 @@ int input_event_from_user(const char __user *buffer, > } > > int input_event_to_user(char __user *buffer, > - const struct input_event *event) > + const struct raw_input_event *event) > { > - if (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) { > - struct input_event_compat compat_event; > + if (in_compat_syscall()) { > + struct raw_input_event_compat compat_event; > > compat_event.time.tv_sec = event->time.tv_sec; > compat_event.time.tv_usec = event->time.tv_usec; > @@ -51,11 +52,11 @@ int input_event_to_user(char __user *buffer, > compat_event.value = event->value; > > if (copy_to_user(buffer, &compat_event, > - sizeof(struct input_event_compat))) > + sizeof(struct raw_input_event_compat))) > return -EFAULT; > > } else { > - if (copy_to_user(buffer, event, sizeof(struct input_event))) > + if (copy_to_user(buffer, event, sizeof(struct raw_input_event))) > return -EFAULT; > } > > @@ -100,18 +101,18 @@ int input_ff_effect_from_user(const char __user *buffer, size_t size, > #else > > int input_event_from_user(const char __user *buffer, > - struct input_event *event) > + struct raw_input_event *event) > { > - if (copy_from_user(event, buffer, sizeof(struct input_event))) > + if (copy_from_user(event, buffer, sizeof(struct raw_input_event))) > return -EFAULT; > > return 0; > } > > int input_event_to_user(char __user *buffer, > - const struct input_event *event) > + const struct raw_input_event *event) > { > - if (copy_to_user(buffer, event, sizeof(struct input_event))) > + if (copy_to_user(buffer, event, sizeof(struct raw_input_event))) > return -EFAULT; > > return 0; > diff --git a/drivers/input/input-compat.h b/drivers/input/input-compat.h > index 1563160..c18132d 100644 > --- a/drivers/input/input-compat.h > +++ b/drivers/input/input-compat.h > @@ -17,8 +17,13 @@ > > #ifdef CONFIG_COMPAT > > -struct input_event_compat { > - struct compat_timeval time; > +struct input_timeval_compat { > + compat_ulong_t tv_sec; > + compat_ulong_t tv_usec; > +}; > + > +struct raw_input_event_compat { > + struct input_timeval_compat time; > __u16 type; > __u16 code; > __s32 value; > @@ -55,24 +60,24 @@ struct ff_effect_compat { > > static inline size_t input_event_size(void) > { > - return (in_compat_syscall() && !COMPAT_USE_64BIT_TIME) ? > - sizeof(struct input_event_compat) : sizeof(struct input_event); > + return in_compat_syscall() ? sizeof(struct raw_input_event_compat) : > + sizeof(struct raw_input_event); > } > > #else > > static inline size_t input_event_size(void) > { > - return sizeof(struct input_event); > + return sizeof(struct raw_input_event); > } > > #endif /* CONFIG_COMPAT */ > > int input_event_from_user(const char __user *buffer, > - struct input_event *event); > + struct raw_input_event *event); > > int input_event_to_user(char __user *buffer, > - const struct input_event *event); > + const struct raw_input_event *event); > > int input_ff_effect_from_user(const char __user *buffer, size_t size, > struct ff_effect *effect); > diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c > index 3d75c5a..113a3ae 100644 > --- a/drivers/input/misc/uinput.c > +++ b/drivers/input/misc/uinput.c > @@ -562,7 +562,7 @@ static int uinput_setup_device_legacy(struct uinput_device *udev, > static ssize_t uinput_inject_events(struct uinput_device *udev, > const char __user *buffer, size_t count) > { > - struct input_event ev; > + struct raw_input_event ev; > size_t bytes = 0; > > if (count != 0 && count < input_event_size()) > @@ -608,7 +608,7 @@ static ssize_t uinput_write(struct file *file, const char __user *buffer, > } > > static bool uinput_fetch_next_event(struct uinput_device *udev, > - struct input_event *event) > + struct raw_input_event *event) > { > bool have_event; > > @@ -628,7 +628,7 @@ static bool uinput_fetch_next_event(struct uinput_device *udev, > static ssize_t uinput_events_to_user(struct uinput_device *udev, > char __user *buffer, size_t count) > { > - struct input_event event; > + struct raw_input_event event; > size_t read = 0; > > while (read + input_event_size() <= count && > diff --git a/include/linux/uinput.h b/include/linux/uinput.h > index 6527fb7..d1accb3 100644 > --- a/include/linux/uinput.h > +++ b/include/linux/uinput.h > @@ -71,7 +71,7 @@ struct uinput_device { > unsigned char ready; > unsigned char head; > unsigned char tail; > - struct input_event buff[UINPUT_BUFFER_SIZE]; > + struct raw_input_event buff[UINPUT_BUFFER_SIZE]; > int clk_type; > unsigned int ff_effects_max; > > diff --git a/include/uapi/linux/input.h b/include/uapi/linux/input.h > index e794f7b..6691d83 100644 > --- a/include/uapi/linux/input.h > +++ b/include/uapi/linux/input.h > @@ -22,6 +22,29 @@ > * The event structure itself > */ > > +/* The time structure for y2038 safe raw_input_event. > + * The fields use unsigned types to extend times until > + * year 2106 rather than 2038. > + */ > +struct input_timeval { > + __kernel_ulong_t tv_sec; > + __kernel_ulong_t tv_usec; > +}; > + > +struct raw_input_event { > + struct input_timeval time; > + __u16 type; > + __u16 code; > + __s32 value; > +}; > + > +#ifndef __KERNEL__ > + > +/* Userspace structure. > + * Definition maintained here for userspace that is not yet updated to use > + * struct raw_input_event. > + * Not to be used anywhere within the kernel. > + */ > struct input_event { > struct timeval time; > __u16 type; > @@ -29,11 +52,35 @@ struct input_event { > __s32 value; > }; > > +static inline void > +raw_input_to_input_event(const struct raw_input_event *raw, > + struct input_event *ev) > +{ > + ev->time.tv_sec = raw->time.tv_sec; > + ev->time.tv_usec = raw->time.tv_usec; > + ev->type = raw->type; > + ev->code = raw->code; > + ev->value = raw->value; > +} > + > +static inline void > +input_to_raw_event(const struct input_event *ev, struct raw_input_event *raw) > +{ > + raw->time.tv_sec = ev->time.tv_sec; > + raw->time.tv_usec = ev->time.tv_usec; > + raw->type = ev->type; > + raw->code = ev->code; > + raw->value = ev->value; > +} > + > +#endif > + > /* > * Protocol version. > */ > > #define EV_VERSION 0x010001 > +#define EV_VERSION_1_2 0x010002 > > /* > * IOCTLs (0x00 - 0x7f) > -- > 2.7.4 > > -- > To unsubscribe from this list: send the line "unsubscribe linux-input" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Peter Hutterer Subject: Re: [PATCH v2 3/4] input: Deprecate real timestamps beyond year 2106 Date: Thu, 27 Oct 2016 12:56:16 +1000 Message-ID: <20161027025616.GC14832@jelly> References: <1476761253-13450-1-git-send-email-deepa.kernel@gmail.com> <1476761253-13450-4-git-send-email-deepa.kernel@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1476761253-13450-4-git-send-email-deepa.kernel@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: y2038-bounces@lists.linaro.org Sender: "Y2038" To: Deepa Dinamani Cc: y2038@lists.linaro.org, Dmitry Torokhov , linux-kernel@vger.kernel.org, arnd@arndb.de, linux-input@vger.kernel.org List-Id: linux-input@vger.kernel.org T24gTW9uLCBPY3QgMTcsIDIwMTYgYXQgMDg6Mjc6MzJQTSAtMDcwMCwgRGVlcGEgRGluYW1hbmkg d3JvdGU6Cj4gc3RydWN0IHRpbWV2YWwgaXMgbm90IHkyMDM4IHNhZmUuCj4gQWxsIHVzYWdlIG9m IHRpbWV2YWwgaW4gdGhlIGtlcm5lbCB3aWxsIGJlIHJlcGxhY2VkIGJ5Cj4geTIwMzggc2FmZSBz dHJ1Y3R1cmVzLgo+IAo+IHN0cnVjdCBpbnB1dF9ldmVudCBtYWludGFpbnMgdGltZSBmb3IgZWFj aCBpbnB1dCBldmVudC4KPiBSZWFsIHRpbWUgdGltZXN0YW1wcyBhcmUgbm90IGlkZWFsIGZvciBp bnB1dCBhcyB0aGlzCj4gdGltZSBjYW4gZ28gYmFja3dhcmRzIGFzIG5vdGVkIGluIHRoZSBwYXRj aCBhODBiODNiN2I4Cj4gYnkgSm9obiBTdHVsdHouIEhlbmNlLCBoYXZpbmcgdGhlIGlucHV0X2V2 ZW50LnRpbWUgZmllbGRzCj4gb25seSBiaWcgZW5vdWdoIGZvciBtb25vdG9uaWMgYW5kIGJvb3Qg dGltZXMgYXJlCj4gc3VmZmljaWVudC4KPiAKPiBMZWF2ZSB0aGUgb3JpZ2luYWwgaW5wdXRfZXZl bnQgYXMgaXMuIFRoaXMgaXMgdG8gbWFpbnRhaW4KPiBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IHdp dGggZXhpc3RpbmcgdXNlcnNwYWNlIGludGVyZmFjZXMKPiB0aGF0IHVzZSBpbnB1dF9ldmVudC4K PiBJbnRyb2R1Y2UgYSBuZXcgcmVwbGFjZW1lbnQgc3RydWN0IHJhd19pbnB1dF9ldmVudC4KCmdl bmVyYWwgY29tbWVudCBoZXJlIC0gcGxlYXNlIGRvbid0IG5hbWUgaXQgInJhd19pbnB1dF9ldmVu dCIuCkZpcnN0LCB3aGVuIHlvdSBncmVwIGZvciBpbnB1dF9ldmVudCB5b3Ugd2FudCB0aGUgbmV3 IG9uZXMgdG8gc2hvdyB1cCB0b28sCnNvIGEgc3RydWN0IGlucHV0X2V2ZW50X3JhdyB3b3VsZCBi ZSBiZXR0ZXIgaGVyZS4gVGhhdCBhbHNvIGhhcyBiZXR0ZXIKbmFtZXNwYWNpbmcgaW4gZ2VuZXJh bC4gU2Vjb25kIHRob3VnaDogdGhlIGV2ZW50IGlzbid0IGFueSBtb3JlICJyYXciIHRoYW4KdGhl IHByZXZpb3VzIHdlIGhhZC4KCkkgY2FuJ3QgdGhpbmsgb2YgYW55dGhpbmcgYmV0dGVyIHRoYW4g c3RydWN0IGlucHV0X2V2ZW50X3YyIHRob3VnaC4KCj4gVGhpcyByZXBsYWNlcyB0aW1ldmFsIHdp dGggc3RydWN0IGlucHV0X3RpbWV2YWwuIFRoaXMgc3RydWN0dXJlCj4gbWFpbnRhaW5zIHRpbWUg aW4gX19rZXJuZWxfdWxvbmdfdCBvciBjb21wYXRfdWxvbmdfdCB0byBhbGxvdwo+IGZvciBhcmNo aXRlY3R1cmVzIHRvIG92ZXJyaWRlIHR5cGVzIGFzIGluIHRoZSBjYXNlIG9mIHgzMi4KPiAKPiBU aGUgY2hhbmdlIHJlcXVpcmVzIGFueSB1c2Vyc3BhY2UgdXRpbGl0aWVzIHJlYWRpbmcgb3Igd3Jp dGluZwo+IGZyb20gZXZlbnQgbm9kZXMgdG8gdXBkYXRlIHRoZWlyIHJlYWRpbmcgZm9ybWF0IHRv IG1hdGNoCj4gcmF3X2lucHV0X2V2ZW50LiBUaGUgY2hhbmdlcyB0byB0aGUgcG9wdWxhciBsaWJy YXJpZXMgd2lsbCBiZQo+IHBvc3RlZCBhbG9uZyB3aXRoIHRoZSBrZXJuZWwgY2hhbmdlcy4KPiBU aGUgZHJpdmVyIHZlcnNpb24gaXMgYWxzbyB1cGRhdGVkIHRvIHJlZmxlY3QgdGhlIGNoYW5nZSBp bgo+IGV2ZW50IGZvcm1hdC4KCkRvZXNuJ3QgdGhpcyBicmVhayAqYWxsKiBvZiB1c2Vyc3BhY2Ug dGhlbj8gSSBkb24ndCBzZWUgYW55dGhpbmcgdG8KbmVnb3RpYXRlIHRoZSB0eXBlIG9mIGlucHV0 IGV2ZW50IHRoZSBrZXJuZWwgZ2l2ZXMgbWUuIEFuZCBub3RoaW5nIHJpZ2h0IG5vdwpjaGVja3Mg Zm9yIEVWREVWX1ZFUlNJT04sIHNvIHRoZXkgYWxsIGp1c3QgYXNzdW1lIGl0J3MgYSBzdHJ1Y3QK aW5wdXRfZXZlbnQuIEJlc3QgY2FzZSwgaWYgdGhlIGF2YWlsYWJsZSBldmVudHMgYXJlbid0IGEg bXVsdGlwbGUgb2YKc2l6ZW9mKHN0cnVjdCBpbnB1dF9ldmVudCkgdXNlcnNwYWNlIHdpbGwgYm9t YiBvdXQsIGJ1dCB1bmxlc3MgdGhhdCBoYXBwZW5zLApldmVyeW9uZSB3aWxsIGp1c3QgaGFwcGls eSByZWFkIG9sZC1zdHlsZSBldmVudHMuCgpTbyB3ZSBuZWVkIHNvbWUgbmVnb3RpYXRpb24gd2hh dCBpcyBhY2NlcHRhYmxlLiBXaGljaCBhbHNvIG5lZWRzIHRvIGFkZHJlc3MKdGhlIHJhY2UgY29u ZGl0aW9ucyB3ZSdyZSBnb2luZyB0byBnZXQgd2hlbiBldmVudHMgc3RhcnQgY29taW5nIGluIGJl Zm9yZQp0aGUgY2xpZW50IGhhcyBhbm5vdW5jZWQgdGhhdCBpdCBzdXBwb3J0cyB0aGUgbmV3LXN0 eWxlIGV2ZW50cy4KCkNoZWVycywKICAgUGV0ZXIKCj4gU3VnZ2VzdGVkLWJ5OiBBcm5kIEJlcmdt YW5uIDxhcm5kQGFybmRiLmRlPgo+IFNpZ25lZC1vZmYtYnk6IERlZXBhIERpbmFtYW5pIDxkZWVw YS5rZXJuZWxAZ21haWwuY29tPgo+IFJldmlld2VkLWJ5OiBBcm5kIEJlcmdtYW5uIDxhcm5kQGFy bmRiLmRlPgo+IC0tLQo+ICBkcml2ZXJzL2lucHV0L2V2ZGV2LmMgICAgICAgIHwgMjAgKysrKysr KysrLS0tLS0tLS0tLQo+ICBkcml2ZXJzL2lucHV0L2lucHV0LWNvbXBhdC5jIHwgMjkgKysrKysr KysrKysrKystLS0tLS0tLS0tLS0tCj4gIGRyaXZlcnMvaW5wdXQvaW5wdXQtY29tcGF0LmggfCAx OSArKysrKysrKysrKy0tLS0tLS0KPiAgZHJpdmVycy9pbnB1dC9taXNjL3VpbnB1dC5jICB8ICA2 ICsrKy0tLQo+ICBpbmNsdWRlL2xpbnV4L3VpbnB1dC5oICAgICAgIHwgIDIgKy0KPiAgaW5jbHVk ZS91YXBpL2xpbnV4L2lucHV0LmggICB8IDQ3ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrCj4gIDYgZmlsZXMgY2hhbmdlZCwgODggaW5zZXJ0aW9ucygrKSwgMzUg ZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvZXZkZXYuYyBiL2Ry aXZlcnMvaW5wdXQvZXZkZXYuYwo+IGluZGV4IGI0ZTMxNzEuLjQ1OWUzYmEgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9pbnB1dC9ldmRldi5jCj4gKysrIGIvZHJpdmVycy9pbnB1dC9ldmRldi5jCj4g QEAgLTYwLDcgKzYwLDcgQEAgc3RydWN0IGV2ZGV2X2NsaWVudCB7Cj4gIAlib29sIHJldm9rZWQ7 Cj4gIAl1bnNpZ25lZCBsb25nICpldm1hc2tzW0VWX0NOVF07Cj4gIAl1bnNpZ25lZCBpbnQgYnVm c2l6ZTsKPiAtCXN0cnVjdCBpbnB1dF9ldmVudCBidWZmZXJbXTsKPiArCXN0cnVjdCByYXdfaW5w dXRfZXZlbnQgYnVmZmVyW107Cj4gIH07Cj4gIAo+ICBzdGF0aWMgc2l6ZV90IGV2ZGV2X2dldF9t YXNrX2NudCh1bnNpZ25lZCBpbnQgdHlwZSkKPiBAQCAtMTEzLDcgKzExMyw3IEBAIHN0YXRpYyB2 b2lkIF9fZXZkZXZfZmx1c2hfcXVldWUoc3RydWN0IGV2ZGV2X2NsaWVudCAqY2xpZW50LCB1bnNp Z25lZCBpbnQgdHlwZSkKPiAgCXVuc2lnbmVkIGludCBpLCBoZWFkLCBudW07Cj4gIAl1bnNpZ25l ZCBpbnQgbWFzayA9IGNsaWVudC0+YnVmc2l6ZSAtIDE7Cj4gIAlib29sIGlzX3JlcG9ydDsKPiAt CXN0cnVjdCBpbnB1dF9ldmVudCAqZXY7Cj4gKwlzdHJ1Y3QgcmF3X2lucHV0X2V2ZW50ICpldjsK PiAgCj4gIAlCVUdfT04odHlwZSA9PSBFVl9TWU4pOwo+ICAKPiBAQCAtMTU1LDcgKzE1NSw3IEBA IHN0YXRpYyB2b2lkIF9fZXZkZXZfZmx1c2hfcXVldWUoc3RydWN0IGV2ZGV2X2NsaWVudCAqY2xp ZW50LCB1bnNpZ25lZCBpbnQgdHlwZSkKPiAgCj4gIHN0YXRpYyB2b2lkIF9fZXZkZXZfcXVldWVf c3luX2Ryb3BwZWQoc3RydWN0IGV2ZGV2X2NsaWVudCAqY2xpZW50KQo+ICB7Cj4gLQlzdHJ1Y3Qg aW5wdXRfZXZlbnQgZXY7Cj4gKwlzdHJ1Y3QgcmF3X2lucHV0X2V2ZW50IGV2Owo+ICAJc3RydWN0 IHRpbWVzcGVjNjQgdHM7Cj4gIAo+ICAJc3dpdGNoIChjbGllbnQtPmNsa190eXBlKSB7Cj4gQEAg LTIzNiw3ICsyMzYsNyBAQCBzdGF0aWMgaW50IGV2ZGV2X3NldF9jbGtfdHlwZShzdHJ1Y3QgZXZk ZXZfY2xpZW50ICpjbGllbnQsIHVuc2lnbmVkIGludCBjbGtpZCkKPiAgfQo+ICAKPiAgc3RhdGlj IHZvaWQgX19wYXNzX2V2ZW50KHN0cnVjdCBldmRldl9jbGllbnQgKmNsaWVudCwKPiAtCQkJIGNv bnN0IHN0cnVjdCBpbnB1dF9ldmVudCAqZXZlbnQpCj4gKwkJCSBjb25zdCBzdHJ1Y3QgcmF3X2lu cHV0X2V2ZW50ICpldmVudCkKPiAgewo+ICAJY2xpZW50LT5idWZmZXJbY2xpZW50LT5oZWFkKytd ID0gKmV2ZW50Owo+ICAJY2xpZW50LT5oZWFkICY9IGNsaWVudC0+YnVmc2l6ZSAtIDE7Cj4gQEAg LTI2OCw3ICsyNjgsNyBAQCBzdGF0aWMgdm9pZCBldmRldl9wYXNzX3ZhbHVlcyhzdHJ1Y3QgZXZk ZXZfY2xpZW50ICpjbGllbnQsCj4gIHsKPiAgCXN0cnVjdCBldmRldiAqZXZkZXYgPSBjbGllbnQt PmV2ZGV2Owo+ICAJY29uc3Qgc3RydWN0IGlucHV0X3ZhbHVlICp2Owo+IC0Jc3RydWN0IGlucHV0 X2V2ZW50IGV2ZW50Owo+ICsJc3RydWN0IHJhd19pbnB1dF9ldmVudCBldmVudDsKPiAgCXN0cnVj dCB0aW1lc3BlYzY0IHRzOwo+ICAJYm9vbCB3YWtldXAgPSBmYWxzZTsKPiAgCj4gQEAgLTUwNyw3 ICs1MDcsNyBAQCBzdGF0aWMgaW50IGV2ZGV2X29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3Ry dWN0IGZpbGUgKmZpbGUpCj4gIAlzdHJ1Y3QgZXZkZXYgKmV2ZGV2ID0gY29udGFpbmVyX29mKGlu b2RlLT5pX2NkZXYsIHN0cnVjdCBldmRldiwgY2Rldik7Cj4gIAl1bnNpZ25lZCBpbnQgYnVmc2l6 ZSA9IGV2ZGV2X2NvbXB1dGVfYnVmZmVyX3NpemUoZXZkZXYtPmhhbmRsZS5kZXYpOwo+ICAJdW5z aWduZWQgaW50IHNpemUgPSBzaXplb2Yoc3RydWN0IGV2ZGV2X2NsaWVudCkgKwo+IC0JCQkJCWJ1 ZnNpemUgKiBzaXplb2Yoc3RydWN0IGlucHV0X2V2ZW50KTsKPiArCQkJCWJ1ZnNpemUgKiBzaXpl b2Yoc3RydWN0IHJhd19pbnB1dF9ldmVudCk7Cj4gIAlzdHJ1Y3QgZXZkZXZfY2xpZW50ICpjbGll bnQ7Cj4gIAlpbnQgZXJyb3I7Cj4gIAo+IEBAIC01NDIsNyArNTQyLDcgQEAgc3RhdGljIHNzaXpl X3QgZXZkZXZfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191c2VyICpidWZm ZXIsCj4gIHsKPiAgCXN0cnVjdCBldmRldl9jbGllbnQgKmNsaWVudCA9IGZpbGUtPnByaXZhdGVf ZGF0YTsKPiAgCXN0cnVjdCBldmRldiAqZXZkZXYgPSBjbGllbnQtPmV2ZGV2Owo+IC0Jc3RydWN0 IGlucHV0X2V2ZW50IGV2ZW50Owo+ICsJc3RydWN0IHJhd19pbnB1dF9ldmVudCBldmVudDsKPiAg CWludCByZXR2YWwgPSAwOwo+ICAKPiAgCWlmIChjb3VudCAhPSAwICYmIGNvdW50IDwgaW5wdXRf ZXZlbnRfc2l6ZSgpKQo+IEBAIC01NzUsNyArNTc1LDcgQEAgc3RhdGljIHNzaXplX3QgZXZkZXZf d3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191c2VyICpidWZmZXIsCj4gIH0K PiAgCj4gIHN0YXRpYyBpbnQgZXZkZXZfZmV0Y2hfbmV4dF9ldmVudChzdHJ1Y3QgZXZkZXZfY2xp ZW50ICpjbGllbnQsCj4gLQkJCQkgIHN0cnVjdCBpbnB1dF9ldmVudCAqZXZlbnQpCj4gKwkJCQkg IHN0cnVjdCByYXdfaW5wdXRfZXZlbnQgKmV2ZW50KQo+ICB7Cj4gIAlpbnQgaGF2ZV9ldmVudDsK PiAgCj4gQEAgLTU5Nyw3ICs1OTcsNyBAQCBzdGF0aWMgc3NpemVfdCBldmRldl9yZWFkKHN0cnVj dCBmaWxlICpmaWxlLCBjaGFyIF9fdXNlciAqYnVmZmVyLAo+ICB7Cj4gIAlzdHJ1Y3QgZXZkZXZf Y2xpZW50ICpjbGllbnQgPSBmaWxlLT5wcml2YXRlX2RhdGE7Cj4gIAlzdHJ1Y3QgZXZkZXYgKmV2 ZGV2ID0gY2xpZW50LT5ldmRldjsKPiAtCXN0cnVjdCBpbnB1dF9ldmVudCBldmVudDsKPiArCXN0 cnVjdCByYXdfaW5wdXRfZXZlbnQgZXZlbnQ7Cj4gIAlzaXplX3QgcmVhZCA9IDA7Cj4gIAlpbnQg ZXJyb3I7Cj4gIAo+IEBAIC0xMDgzLDcgKzEwODMsNyBAQCBzdGF0aWMgbG9uZyBldmRldl9kb19p b2N0bChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQgaW50IGNtZCwKPiAgCXN3aXRjaCAoY21k KSB7Cj4gIAo+ICAJY2FzZSBFVklPQ0dWRVJTSU9OOgo+IC0JCXJldHVybiBwdXRfdXNlcihFVl9W RVJTSU9OLCBpcCk7Cj4gKwkJcmV0dXJuIHB1dF91c2VyKEVWX1ZFUlNJT05fMV8yLCBpcCk7Cj4g IAo+ICAJY2FzZSBFVklPQ0dJRDoKPiAgCQlpZiAoY29weV90b191c2VyKHAsICZkZXYtPmlkLCBz aXplb2Yoc3RydWN0IGlucHV0X2lkKSkpCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvaW5w dXQtY29tcGF0LmMgYi9kcml2ZXJzL2lucHV0L2lucHV0LWNvbXBhdC5jCj4gaW5kZXggZDg0ZDIw Yi4uYjU4ZDM1YyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2lucHV0L2lucHV0LWNvbXBhdC5jCj4g KysrIGIvZHJpdmVycy9pbnB1dC9pbnB1dC1jb21wYXQuYwo+IEBAIC0xNSwxMyArMTUsMTMgQEAK PiAgI2lmZGVmIENPTkZJR19DT01QQVQKPiAgCj4gIGludCBpbnB1dF9ldmVudF9mcm9tX3VzZXIo Y29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwKPiAtCQkJICBzdHJ1Y3QgaW5wdXRfZXZlbnQgKmV2 ZW50KQo+ICsJCQkgIHN0cnVjdCByYXdfaW5wdXRfZXZlbnQgKmV2ZW50KQo+ICB7Cj4gLQlpZiAo aW5fY29tcGF0X3N5c2NhbGwoKSAmJiAhQ09NUEFUX1VTRV82NEJJVF9USU1FKSB7Cj4gLQkJc3Ry dWN0IGlucHV0X2V2ZW50X2NvbXBhdCBjb21wYXRfZXZlbnQ7Cj4gKwlpZiAoaW5fY29tcGF0X3N5 c2NhbGwoKSkgewo+ICsJCXN0cnVjdCByYXdfaW5wdXRfZXZlbnRfY29tcGF0IGNvbXBhdF9ldmVu dDsKPiAgCj4gIAkJaWYgKGNvcHlfZnJvbV91c2VyKCZjb21wYXRfZXZlbnQsIGJ1ZmZlciwKPiAt CQkJCSAgIHNpemVvZihzdHJ1Y3QgaW5wdXRfZXZlbnRfY29tcGF0KSkpCj4gKwkJCQkgICBzaXpl b2Yoc3RydWN0IHJhd19pbnB1dF9ldmVudF9jb21wYXQpKSkKPiAgCQkJcmV0dXJuIC1FRkFVTFQ7 Cj4gIAo+ICAJCWV2ZW50LT50aW1lLnR2X3NlYyA9IGNvbXBhdF9ldmVudC50aW1lLnR2X3NlYzsK PiBAQCAtMzEsNyArMzEsOCBAQCBpbnQgaW5wdXRfZXZlbnRfZnJvbV91c2VyKGNvbnN0IGNoYXIg X191c2VyICpidWZmZXIsCj4gIAkJZXZlbnQtPnZhbHVlID0gY29tcGF0X2V2ZW50LnZhbHVlOwo+ ICAKPiAgCX0gZWxzZSB7Cj4gLQkJaWYgKGNvcHlfZnJvbV91c2VyKGV2ZW50LCBidWZmZXIsIHNp emVvZihzdHJ1Y3QgaW5wdXRfZXZlbnQpKSkKPiArCQlpZiAoY29weV9mcm9tX3VzZXIoZXZlbnQs IGJ1ZmZlciwKPiArCQkJCSAgIHNpemVvZihzdHJ1Y3QgcmF3X2lucHV0X2V2ZW50KSkpCj4gIAkJ CXJldHVybiAtRUZBVUxUOwo+ICAJfQo+ICAKPiBAQCAtMzksMTAgKzQwLDEwIEBAIGludCBpbnB1 dF9ldmVudF9mcm9tX3VzZXIoY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwKPiAgfQo+ICAKPiAg aW50IGlucHV0X2V2ZW50X3RvX3VzZXIoY2hhciBfX3VzZXIgKmJ1ZmZlciwKPiAtCQkJY29uc3Qg c3RydWN0IGlucHV0X2V2ZW50ICpldmVudCkKPiArCQkJY29uc3Qgc3RydWN0IHJhd19pbnB1dF9l dmVudCAqZXZlbnQpCj4gIHsKPiAtCWlmIChpbl9jb21wYXRfc3lzY2FsbCgpICYmICFDT01QQVRf VVNFXzY0QklUX1RJTUUpIHsKPiAtCQlzdHJ1Y3QgaW5wdXRfZXZlbnRfY29tcGF0IGNvbXBhdF9l dmVudDsKPiArCWlmIChpbl9jb21wYXRfc3lzY2FsbCgpKSB7Cj4gKwkJc3RydWN0IHJhd19pbnB1 dF9ldmVudF9jb21wYXQgY29tcGF0X2V2ZW50Owo+ICAKPiAgCQljb21wYXRfZXZlbnQudGltZS50 dl9zZWMgPSBldmVudC0+dGltZS50dl9zZWM7Cj4gIAkJY29tcGF0X2V2ZW50LnRpbWUudHZfdXNl YyA9IGV2ZW50LT50aW1lLnR2X3VzZWM7Cj4gQEAgLTUxLDExICs1MiwxMSBAQCBpbnQgaW5wdXRf ZXZlbnRfdG9fdXNlcihjaGFyIF9fdXNlciAqYnVmZmVyLAo+ICAJCWNvbXBhdF9ldmVudC52YWx1 ZSA9IGV2ZW50LT52YWx1ZTsKPiAgCj4gIAkJaWYgKGNvcHlfdG9fdXNlcihidWZmZXIsICZjb21w YXRfZXZlbnQsCj4gLQkJCQkgc2l6ZW9mKHN0cnVjdCBpbnB1dF9ldmVudF9jb21wYXQpKSkKPiAr CQkJCSBzaXplb2Yoc3RydWN0IHJhd19pbnB1dF9ldmVudF9jb21wYXQpKSkKPiAgCQkJcmV0dXJu IC1FRkFVTFQ7Cj4gIAo+ICAJfSBlbHNlIHsKPiAtCQlpZiAoY29weV90b191c2VyKGJ1ZmZlciwg ZXZlbnQsIHNpemVvZihzdHJ1Y3QgaW5wdXRfZXZlbnQpKSkKPiArCQlpZiAoY29weV90b191c2Vy KGJ1ZmZlciwgZXZlbnQsIHNpemVvZihzdHJ1Y3QgcmF3X2lucHV0X2V2ZW50KSkpCj4gIAkJCXJl dHVybiAtRUZBVUxUOwo+ICAJfQo+ICAKPiBAQCAtMTAwLDE4ICsxMDEsMTggQEAgaW50IGlucHV0 X2ZmX2VmZmVjdF9mcm9tX3VzZXIoY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwgc2l6ZV90IHNp emUsCj4gICNlbHNlCj4gIAo+ICBpbnQgaW5wdXRfZXZlbnRfZnJvbV91c2VyKGNvbnN0IGNoYXIg X191c2VyICpidWZmZXIsCj4gLQkJCSBzdHJ1Y3QgaW5wdXRfZXZlbnQgKmV2ZW50KQo+ICsJCQkg c3RydWN0IHJhd19pbnB1dF9ldmVudCAqZXZlbnQpCj4gIHsKPiAtCWlmIChjb3B5X2Zyb21fdXNl cihldmVudCwgYnVmZmVyLCBzaXplb2Yoc3RydWN0IGlucHV0X2V2ZW50KSkpCj4gKwlpZiAoY29w eV9mcm9tX3VzZXIoZXZlbnQsIGJ1ZmZlciwgc2l6ZW9mKHN0cnVjdCByYXdfaW5wdXRfZXZlbnQp KSkKPiAgCQlyZXR1cm4gLUVGQVVMVDsKPiAgCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiAgaW50 IGlucHV0X2V2ZW50X3RvX3VzZXIoY2hhciBfX3VzZXIgKmJ1ZmZlciwKPiAtCQkJY29uc3Qgc3Ry dWN0IGlucHV0X2V2ZW50ICpldmVudCkKPiArCQkJY29uc3Qgc3RydWN0IHJhd19pbnB1dF9ldmVu dCAqZXZlbnQpCj4gIHsKPiAtCWlmIChjb3B5X3RvX3VzZXIoYnVmZmVyLCBldmVudCwgc2l6ZW9m KHN0cnVjdCBpbnB1dF9ldmVudCkpKQo+ICsJaWYgKGNvcHlfdG9fdXNlcihidWZmZXIsIGV2ZW50 LCBzaXplb2Yoc3RydWN0IHJhd19pbnB1dF9ldmVudCkpKQo+ICAJCXJldHVybiAtRUZBVUxUOwo+ ICAKPiAgCXJldHVybiAwOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2lucHV0LWNvbXBh dC5oIGIvZHJpdmVycy9pbnB1dC9pbnB1dC1jb21wYXQuaAo+IGluZGV4IDE1NjMxNjAuLmMxODEz MmQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9pbnB1dC9pbnB1dC1jb21wYXQuaAo+ICsrKyBiL2Ry aXZlcnMvaW5wdXQvaW5wdXQtY29tcGF0LmgKPiBAQCAtMTcsOCArMTcsMTMgQEAKPiAgCj4gICNp ZmRlZiBDT05GSUdfQ09NUEFUCj4gIAo+IC1zdHJ1Y3QgaW5wdXRfZXZlbnRfY29tcGF0IHsKPiAt CXN0cnVjdCBjb21wYXRfdGltZXZhbCB0aW1lOwo+ICtzdHJ1Y3QgaW5wdXRfdGltZXZhbF9jb21w YXQgewo+ICsJY29tcGF0X3Vsb25nX3QgdHZfc2VjOwo+ICsJY29tcGF0X3Vsb25nX3QgdHZfdXNl YzsKPiArfTsKPiArCj4gK3N0cnVjdCByYXdfaW5wdXRfZXZlbnRfY29tcGF0IHsKPiArCXN0cnVj dCBpbnB1dF90aW1ldmFsX2NvbXBhdCB0aW1lOwo+ICAJX191MTYgdHlwZTsKPiAgCV9fdTE2IGNv ZGU7Cj4gIAlfX3MzMiB2YWx1ZTsKPiBAQCAtNTUsMjQgKzYwLDI0IEBAIHN0cnVjdCBmZl9lZmZl Y3RfY29tcGF0IHsKPiAgCj4gIHN0YXRpYyBpbmxpbmUgc2l6ZV90IGlucHV0X2V2ZW50X3NpemUo dm9pZCkKPiAgewo+IC0JcmV0dXJuIChpbl9jb21wYXRfc3lzY2FsbCgpICYmICFDT01QQVRfVVNF XzY0QklUX1RJTUUpID8KPiAtCQlzaXplb2Yoc3RydWN0IGlucHV0X2V2ZW50X2NvbXBhdCkgOiBz aXplb2Yoc3RydWN0IGlucHV0X2V2ZW50KTsKPiArCXJldHVybiBpbl9jb21wYXRfc3lzY2FsbCgp ID8gc2l6ZW9mKHN0cnVjdCByYXdfaW5wdXRfZXZlbnRfY29tcGF0KSA6Cj4gKwkJCQkgICAgIHNp emVvZihzdHJ1Y3QgcmF3X2lucHV0X2V2ZW50KTsKPiAgfQo+ICAKPiAgI2Vsc2UKPiAgCj4gIHN0 YXRpYyBpbmxpbmUgc2l6ZV90IGlucHV0X2V2ZW50X3NpemUodm9pZCkKPiAgewo+IC0JcmV0dXJu IHNpemVvZihzdHJ1Y3QgaW5wdXRfZXZlbnQpOwo+ICsJcmV0dXJuIHNpemVvZihzdHJ1Y3QgcmF3 X2lucHV0X2V2ZW50KTsKPiAgfQo+ICAKPiAgI2VuZGlmIC8qIENPTkZJR19DT01QQVQgKi8KPiAg Cj4gIGludCBpbnB1dF9ldmVudF9mcm9tX3VzZXIoY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwK PiAtCQkJIHN0cnVjdCBpbnB1dF9ldmVudCAqZXZlbnQpOwo+ICsJCQkgc3RydWN0IHJhd19pbnB1 dF9ldmVudCAqZXZlbnQpOwo+ICAKPiAgaW50IGlucHV0X2V2ZW50X3RvX3VzZXIoY2hhciBfX3Vz ZXIgKmJ1ZmZlciwKPiAtCQkJY29uc3Qgc3RydWN0IGlucHV0X2V2ZW50ICpldmVudCk7Cj4gKwkJ CWNvbnN0IHN0cnVjdCByYXdfaW5wdXRfZXZlbnQgKmV2ZW50KTsKPiAgCj4gIGludCBpbnB1dF9m Zl9lZmZlY3RfZnJvbV91c2VyKGNvbnN0IGNoYXIgX191c2VyICpidWZmZXIsIHNpemVfdCBzaXpl LAo+ICAJCQkgICAgICBzdHJ1Y3QgZmZfZWZmZWN0ICplZmZlY3QpOwo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2lucHV0L21pc2MvdWlucHV0LmMgYi9kcml2ZXJzL2lucHV0L21pc2MvdWlucHV0LmMK PiBpbmRleCAzZDc1YzVhLi4xMTNhM2FlIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvaW5wdXQvbWlz Yy91aW5wdXQuYwo+ICsrKyBiL2RyaXZlcnMvaW5wdXQvbWlzYy91aW5wdXQuYwo+IEBAIC01NjIs NyArNTYyLDcgQEAgc3RhdGljIGludCB1aW5wdXRfc2V0dXBfZGV2aWNlX2xlZ2FjeShzdHJ1Y3Qg dWlucHV0X2RldmljZSAqdWRldiwKPiAgc3RhdGljIHNzaXplX3QgdWlucHV0X2luamVjdF9ldmVu dHMoc3RydWN0IHVpbnB1dF9kZXZpY2UgKnVkZXYsCj4gIAkJCQkgICAgY29uc3QgY2hhciBfX3Vz ZXIgKmJ1ZmZlciwgc2l6ZV90IGNvdW50KQo+ICB7Cj4gLQlzdHJ1Y3QgaW5wdXRfZXZlbnQgZXY7 Cj4gKwlzdHJ1Y3QgcmF3X2lucHV0X2V2ZW50IGV2Owo+ICAJc2l6ZV90IGJ5dGVzID0gMDsKPiAg Cj4gIAlpZiAoY291bnQgIT0gMCAmJiBjb3VudCA8IGlucHV0X2V2ZW50X3NpemUoKSkKPiBAQCAt NjA4LDcgKzYwOCw3IEBAIHN0YXRpYyBzc2l6ZV90IHVpbnB1dF93cml0ZShzdHJ1Y3QgZmlsZSAq ZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwKPiAgfQo+ICAKPiAgc3RhdGljIGJvb2wg dWlucHV0X2ZldGNoX25leHRfZXZlbnQoc3RydWN0IHVpbnB1dF9kZXZpY2UgKnVkZXYsCj4gLQkJ CQkgICAgc3RydWN0IGlucHV0X2V2ZW50ICpldmVudCkKPiArCQkJCSAgICBzdHJ1Y3QgcmF3X2lu cHV0X2V2ZW50ICpldmVudCkKPiAgewo+ICAJYm9vbCBoYXZlX2V2ZW50Owo+ICAKPiBAQCAtNjI4 LDcgKzYyOCw3IEBAIHN0YXRpYyBib29sIHVpbnB1dF9mZXRjaF9uZXh0X2V2ZW50KHN0cnVjdCB1 aW5wdXRfZGV2aWNlICp1ZGV2LAo+ICBzdGF0aWMgc3NpemVfdCB1aW5wdXRfZXZlbnRzX3RvX3Vz ZXIoc3RydWN0IHVpbnB1dF9kZXZpY2UgKnVkZXYsCj4gIAkJCQkgICAgIGNoYXIgX191c2VyICpi dWZmZXIsIHNpemVfdCBjb3VudCkKPiAgewo+IC0Jc3RydWN0IGlucHV0X2V2ZW50IGV2ZW50Owo+ ICsJc3RydWN0IHJhd19pbnB1dF9ldmVudCBldmVudDsKPiAgCXNpemVfdCByZWFkID0gMDsKPiAg Cj4gIAl3aGlsZSAocmVhZCArIGlucHV0X2V2ZW50X3NpemUoKSA8PSBjb3VudCAmJgo+IGRpZmYg LS1naXQgYS9pbmNsdWRlL2xpbnV4L3VpbnB1dC5oIGIvaW5jbHVkZS9saW51eC91aW5wdXQuaAo+ IGluZGV4IDY1MjdmYjcuLmQxYWNjYjMgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC91aW5w dXQuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvdWlucHV0LmgKPiBAQCAtNzEsNyArNzEsNyBAQCBz dHJ1Y3QgdWlucHV0X2RldmljZSB7Cj4gIAl1bnNpZ25lZCBjaGFyCQlyZWFkeTsKPiAgCXVuc2ln bmVkIGNoYXIJCWhlYWQ7Cj4gIAl1bnNpZ25lZCBjaGFyCQl0YWlsOwo+IC0Jc3RydWN0IGlucHV0 X2V2ZW50CWJ1ZmZbVUlOUFVUX0JVRkZFUl9TSVpFXTsKPiArCXN0cnVjdCByYXdfaW5wdXRfZXZl bnQJYnVmZltVSU5QVVRfQlVGRkVSX1NJWkVdOwo+ICAJaW50CQkJY2xrX3R5cGU7Cj4gIAl1bnNp Z25lZCBpbnQJCWZmX2VmZmVjdHNfbWF4Owo+ICAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBp L2xpbnV4L2lucHV0LmggYi9pbmNsdWRlL3VhcGkvbGludXgvaW5wdXQuaAo+IGluZGV4IGU3OTRm N2IuLjY2OTFkODMgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS91YXBpL2xpbnV4L2lucHV0LmgKPiAr KysgYi9pbmNsdWRlL3VhcGkvbGludXgvaW5wdXQuaAo+IEBAIC0yMiw2ICsyMiwyOSBAQAo+ICAg KiBUaGUgZXZlbnQgc3RydWN0dXJlIGl0c2VsZgo+ICAgKi8KPiAgCj4gKy8qIFRoZSB0aW1lIHN0 cnVjdHVyZSBmb3IgeTIwMzggc2FmZSByYXdfaW5wdXRfZXZlbnQuCj4gKyAqIFRoZSBmaWVsZHMg dXNlIHVuc2lnbmVkIHR5cGVzIHRvIGV4dGVuZCB0aW1lcyB1bnRpbAo+ICsgKiB5ZWFyIDIxMDYg cmF0aGVyIHRoYW4gMjAzOC4KPiArICovCj4gK3N0cnVjdCBpbnB1dF90aW1ldmFsIHsKPiArCV9f a2VybmVsX3Vsb25nX3QgdHZfc2VjOwo+ICsJX19rZXJuZWxfdWxvbmdfdCB0dl91c2VjOwo+ICt9 Owo+ICsKPiArc3RydWN0IHJhd19pbnB1dF9ldmVudCB7Cj4gKwlzdHJ1Y3QgaW5wdXRfdGltZXZh bCB0aW1lOwo+ICsJX191MTYgdHlwZTsKPiArCV9fdTE2IGNvZGU7Cj4gKwlfX3MzMiB2YWx1ZTsK PiArfTsKPiArCj4gKyNpZm5kZWYgX19LRVJORUxfXwo+ICsKPiArLyogVXNlcnNwYWNlIHN0cnVj dHVyZS4KPiArICogRGVmaW5pdGlvbiBtYWludGFpbmVkIGhlcmUgZm9yIHVzZXJzcGFjZSB0aGF0 IGlzIG5vdCB5ZXQgdXBkYXRlZCB0byB1c2UKPiArICogc3RydWN0IHJhd19pbnB1dF9ldmVudC4K PiArICogTm90IHRvIGJlIHVzZWQgYW55d2hlcmUgd2l0aGluIHRoZSBrZXJuZWwuCj4gKyAqLwo+ ICBzdHJ1Y3QgaW5wdXRfZXZlbnQgewo+ICAJc3RydWN0IHRpbWV2YWwgdGltZTsKPiAgCV9fdTE2 IHR5cGU7Cj4gQEAgLTI5LDExICs1MiwzNSBAQCBzdHJ1Y3QgaW5wdXRfZXZlbnQgewo+ICAJX19z MzIgdmFsdWU7Cj4gIH07Cj4gIAo+ICtzdGF0aWMgaW5saW5lIHZvaWQKPiArcmF3X2lucHV0X3Rv X2lucHV0X2V2ZW50KGNvbnN0IHN0cnVjdCByYXdfaW5wdXRfZXZlbnQgKnJhdywKPiArCQkJc3Ry dWN0IGlucHV0X2V2ZW50ICpldikKPiArewo+ICsJZXYtPnRpbWUudHZfc2VjID0gcmF3LT50aW1l LnR2X3NlYzsKPiArCWV2LT50aW1lLnR2X3VzZWMgPSByYXctPnRpbWUudHZfdXNlYzsKPiArCWV2 LT50eXBlID0gcmF3LT50eXBlOwo+ICsJZXYtPmNvZGUgPSByYXctPmNvZGU7Cj4gKwlldi0+dmFs dWUgPSByYXctPnZhbHVlOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHZvaWQKPiAraW5wdXRf dG9fcmF3X2V2ZW50KGNvbnN0IHN0cnVjdCBpbnB1dF9ldmVudCAqZXYsIHN0cnVjdCByYXdfaW5w dXRfZXZlbnQgKnJhdykKPiArewo+ICsJcmF3LT50aW1lLnR2X3NlYyA9IGV2LT50aW1lLnR2X3Nl YzsKPiArCXJhdy0+dGltZS50dl91c2VjID0gZXYtPnRpbWUudHZfdXNlYzsKPiArCXJhdy0+dHlw ZSA9IGV2LT50eXBlOwo+ICsJcmF3LT5jb2RlID0gZXYtPmNvZGU7Cj4gKwlyYXctPnZhbHVlID0g ZXYtPnZhbHVlOwo+ICt9Cj4gKwo+ICsjZW5kaWYKPiArCj4gIC8qCj4gICAqIFByb3RvY29sIHZl cnNpb24uCj4gICAqLwo+ICAKPiAgI2RlZmluZSBFVl9WRVJTSU9OCQkweDAxMDAwMQo+ICsjZGVm aW5lIEVWX1ZFUlNJT05fMV8yICAgICAgICAgMHgwMTAwMDIKPiAgCj4gIC8qCj4gICAqIElPQ1RM cyAoMHgwMCAtIDB4N2YpCj4gLS0gCj4gMi43LjQKPiAKPiAtLQo+IFRvIHVuc3Vic2NyaWJlIGZy b20gdGhpcyBsaXN0OiBzZW5kIHRoZSBsaW5lICJ1bnN1YnNjcmliZSBsaW51eC1pbnB1dCIgaW4K PiB0aGUgYm9keSBvZiBhIG1lc3NhZ2UgdG8gbWFqb3Jkb21vQHZnZXIua2VybmVsLm9yZwo+IE1v cmUgbWFqb3Jkb21vIGluZm8gYXQgIGh0dHA6Ly92Z2VyLmtlcm5lbC5vcmcvbWFqb3Jkb21vLWlu Zm8uaHRtbAo+IApfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpZMjAzOCBtYWlsaW5nIGxpc3QKWTIwMzhAbGlzdHMubGluYXJvLm9yZwpodHRwczovL2xpc3Rz LmxpbmFyby5vcmcvbWFpbG1hbi9saXN0aW5mby95MjAzOAo=