From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755069Ab3JDPri (ORCPT ); Fri, 4 Oct 2013 11:47:38 -0400 Received: from usindpps04.hds.com ([207.126.252.17]:41958 "EHLO usindpps04.hds.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754375Ab3JDPrg (ORCPT ); Fri, 4 Oct 2013 11:47:36 -0400 From: Seiji Aguchi To: "linux-kernel@vger.kernel.org" , "linux-efi@vger.kernel.org" , "tony.luck@intel.com" , "matt.fleming@intel.com" CC: "dle-develop@lists.sourceforge.net" , Tomoki Sekiyama Subject: RE: [RFC][PATCH v2] efivars,efi-pstore: Hold off deletion of sysfs entry until the scan is completed Thread-Topic: [RFC][PATCH v2] efivars,efi-pstore: Hold off deletion of sysfs entry until the scan is completed Thread-Index: AQHOu7+XfunCBWQX5U2oS2J+506e65nkujzQ Date: Fri, 4 Oct 2013 15:46:50 +0000 Message-ID: References: <5245E958.5040602@hds.com> In-Reply-To: <5245E958.5040602@hds.com> Accept-Language: ja-JP, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.74.73.11] Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 X-Proofpoint-SPF-Result: pass X-Proofpoint-SPF-Record: v=spf1 mx ip4:207.126.244.0/26 ip4:207.126.252.0/25 include:mktomail.com include:cloud.hds.com ~all X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10432:5.10.8794,1.0.431,0.0.0000 definitions=2013-10-04_02:2013-10-04,2013-10-04,1970-01-01 signatures=0 X-Proofpoint-Spam-Details: rule=notspam policy=outbound_policy score=0 spamscore=0 suspectscore=0 phishscore=0 adultscore=0 bulkscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=7.0.1-1305240000 definitions=main-1310040073 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id r94FljdT012613 Are there anyone who can review this bugfix? Seiji > -----Original Message----- > From: linux-kernel-owner@vger.kernel.org [mailto:linux-kernel-owner@vger.kernel.org] On Behalf Of Seiji Aguchi > Sent: Friday, September 27, 2013 4:24 PM > To: linux-kernel@vger.kernel.org; linux-efi@vger.kernel.org; tony.luck@intel.com; matt.fleming@intel.com > Cc: dle-develop@lists.sourceforge.net; Tomoki Sekiyama > Subject: [RFC][PATCH v2] efivars,efi-pstore: Hold off deletion of sysfs entry until the scan is completed > > Change form v1 > - Rebase to 3.12-rc2 > > Currently, when mounting pstore file system, a read callback of efi_pstore > driver runs mutiple times as below. > > - In the first read callback, scan efivar_sysfs_list from head and pass > a kmsg buffer of a entry to an upper pstore layer. > - In the second read callback, rescan efivar_sysfs_list from the entry and pass > another kmsg buffer to it. > - Repeat the scan and pass until the end of efivar_sysfs_list. > > In this process, an entry is read across the multiple read function calls. > To avoid race between the read and erasion, the whole process above is > protected by a spinlock, holding in open() and releasing in close(). > > At the same time, kmemdup() is called to pass the buffer to pstore filesystem > during it. > And then, it causes a following lockdep warning. > > To make the read callback runnable without taking spinlok, > holding off a deletion of sysfs entry if it happens while scanning it > via efi_pstore, and deleting it after the scan is completed. > > To implement it, this patch introduces two flags, scanning and deleting, > to efivar_entry. > Also, __efivar_entry_get() is removed because it was used in efi_pstore only. > > [ 1.143710] ------------[ cut here ]------------ > [ 1.144058] WARNING: CPU: 1 PID: 1 at kernel/lockdep.c:2740 > lockdep_trace_alloc+0x104/0x110() > [ 1.144058] DEBUG_LOCKS_WARN_ON(irqs_disabled_flags(flags)) > [ 1.144058] Modules linked in: > > [ 1.144058] CPU: 1 PID: 1 Comm: systemd Not tainted 3.11.0-rc5 #2 > [ 1.144058] 0000000000000009 ffff8800797e9ae0 ffffffff816614a5 > ffff8800797e9b28 > [ 1.144058] ffff8800797e9b18 ffffffff8105510d 0000000000000080 > 0000000000000046 > [ 1.144058] 00000000000000d0 00000000000003af ffffffff81ccd0c0 > ffff8800797e9b78 > [ 1.144058] Call Trace: > [ 1.144058] [] dump_stack+0x54/0x74 > [ 1.144058] [] warn_slowpath_common+0x7d/0xa0 > [ 1.144058] [] warn_slowpath_fmt+0x4c/0x50 > [ 1.144058] [] ? vsscanf+0x57f/0x7b0 > [ 1.144058] [] lockdep_trace_alloc+0x104/0x110 > [ 1.144058] [] __kmalloc_track_caller+0x50/0x280 > [ 1.144058] [] ? > efi_pstore_read_func.part.1+0x12b/0x170 > [ 1.144058] [] kmemdup+0x20/0x50 > [ 1.144058] [] efi_pstore_read_func.part.1+0x12b/0x170 > [ 1.144058] [] ? > efi_pstore_read_func.part.1+0x170/0x170 > [ 1.144058] [] efi_pstore_read_func+0xb4/0xe0 > [ 1.144058] [] __efivar_entry_iter+0xfb/0x120 > [ 1.144058] [] efi_pstore_read+0x3f/0x50 > [ 1.144058] [] pstore_get_records+0x9a/0x150 > [ 1.158207] [] ? selinux_d_instantiate+0x1c/0x20 > [ 1.158207] [] ? parse_options+0x80/0x80 > [ 1.158207] [] pstore_fill_super+0xa5/0xc0 > [ 1.158207] [] mount_single+0xa2/0xd0 > [ 1.158207] [] pstore_mount+0x18/0x20 > [ 1.158207] [] mount_fs+0x39/0x1b0 > [ 1.158207] [] ? __alloc_percpu+0x10/0x20 > [ 1.158207] [] vfs_kern_mount+0x63/0xf0 > [ 1.158207] [] do_mount+0x23e/0xa20 > [ 1.158207] [] ? strndup_user+0x4b/0xf0 > [ 1.158207] [] SyS_mount+0x83/0xc0 > [ 1.158207] [] system_call_fastpath+0x16/0x1b > [ 1.158207] ---[ end trace 61981bc62de9f6f4 ]--- > > Signed-off-by: Seiji Aguchi > --- > drivers/firmware/efi/efi-pstore.c | 145 +++++++++++++++++++++++++++++++++++--- > drivers/firmware/efi/efivars.c | 3 +- > drivers/firmware/efi/vars.c | 39 +++------- > include/linux/efi.h | 4 +- > 4 files changed, 151 insertions(+), 40 deletions(-) > > diff --git a/drivers/firmware/efi/efi-pstore.c b/drivers/firmware/efi/efi-pstore.c > index 5002d50..53001a5 100644 > --- a/drivers/firmware/efi/efi-pstore.c > +++ b/drivers/firmware/efi/efi-pstore.c > @@ -18,14 +18,12 @@ module_param_named(pstore_disable, efivars_pstore_disable, bool, 0644); > > static int efi_pstore_open(struct pstore_info *psi) > { > - efivar_entry_iter_begin(); > psi->data = NULL; > return 0; > } > > static int efi_pstore_close(struct pstore_info *psi) > { > - efivar_entry_iter_end(); > psi->data = NULL; > return 0; > } > @@ -39,6 +37,23 @@ struct pstore_read_data { > char **buf; > }; > > +/** > + * efi_pstore_read_func > + * @entry: reading entry > + * @data: data of the entry > + * > + * This function runs in non-atomic context. > + * > + * Also, it returns a size of NVRAM entry logged via efi_pstore_write(). > + * pstore in accordance with the returned value as below. > + * > + * size > 0: Got data of an entry logged via efi_pstore_write() successfully, > + * and pstore filesystem will continue reading subsequent entries. > + * size == 0: Entry was not logged via efi_pstore_write(), > + * and efi_pstore driver will continue reading subsequent entries. > + * size < 0: Failed to get data of entry logging via efi_pstore_write(), > + * and pstore will stop reading entry. > + */ > static int efi_pstore_read_func(struct efivar_entry *entry, void *data) > { > efi_guid_t vendor = LINUX_EFI_CRASH_GUID; > @@ -88,8 +103,9 @@ static int efi_pstore_read_func(struct efivar_entry *entry, void *data) > return 0; > > entry->var.DataSize = 1024; > - __efivar_entry_get(entry, &entry->var.Attributes, > - &entry->var.DataSize, entry->var.Data); > + efivar_entry_get(entry, &entry->var.Attributes, > + &entry->var.DataSize, entry->var.Data); > + > size = entry->var.DataSize; > > *cb_data->buf = kmemdup(entry->var.Data, size, GFP_KERNEL); > @@ -98,12 +114,114 @@ static int efi_pstore_read_func(struct efivar_entry *entry, void *data) > return size; > } > > +/** > + * efi_pstore_scan_sysfs_enter > + * @entry: scanning entry > + * @next: next entry > + * @head: list head > + */ > +static void efi_pstore_scan_sysfs_enter(struct efivar_entry *pos, > + struct efivar_entry *next, > + struct list_head *head) > +{ > + pos->scanning = true; > + if (&next->list != head) > + next->scanning = true; > + > + /* > + * Release a spin_lock because efi_pstore_read_func() should > + * run in non-atomic context to allocate buffer dynamically. > + */ > + efivar_entry_iter_end(); > +} > + > +/** > + * __efi_pstore_scan_sysfs_exit > + * @entry: deleting entry > + * @turn_off_scanning: Check if a scanning flag should be turned off > + */ > +static inline void __efi_pstore_scan_sysfs_exit(struct efivar_entry *entry, > + bool turn_off_scanning) > +{ > + if (entry->deleting) { > + list_del(&entry->list); > + efivar_entry_iter_end(); > + efivar_unregister(entry); > + efivar_entry_iter_begin(); > + } else if (turn_off_scanning) > + entry->scanning = false; > +} > + > +/** > + * efi_pstore_scan_sysfs_exit > + * @pos: scanning entry > + * @next: next entry > + * @head: list head > + * @stop: a flag checking if scanning will stop > + */ > +static void efi_pstore_scan_sysfs_exit(struct efivar_entry *pos, > + struct efivar_entry *next, > + struct list_head *head, bool stop) > +{ > + /* Hold a spinlock to access efivar_entry safely. */ > + efivar_entry_iter_begin(); > + __efi_pstore_scan_sysfs_exit(pos, true); > + if (stop) > + __efi_pstore_scan_sysfs_exit(next, &next->list != head); > +} > + > +/** > + * efi_pstore_sysfs_entry_iter > + * > + * @data: function-specific data to pass to callback > + * @pos: entry to begin iterating from > + * > + * You MUST call efivar_enter_iter_begin() before this function, and > + * efivar_entry_iter_end() afterwards. > + * > + * It is possible to begin iteration from an arbitrary entry within > + * the list by passing @pos. @pos is updated on return to point to > + * the next entry of the last one passed to efi_pstore_read_func(). > + * To begin iterating from the beginning of the list @pos must be %NULL. > + */ > +static int efi_pstore_sysfs_entry_iter(void *data, struct efivar_entry **pos) > +{ > + struct efivar_entry *entry, *n; > + struct list_head *head = &efivar_sysfs_list; > + int size = 0; > + > + if (!*pos) { > + list_for_each_entry_safe(entry, n, head, list) { > + efi_pstore_scan_sysfs_enter(entry, n, head); > + > + size = efi_pstore_read_func(entry, data); > + efi_pstore_scan_sysfs_exit(entry, n, head, size < 0); > + if (size) > + break; > + } > + *pos = n; > + return size; > + } > + > + list_for_each_entry_safe_from((*pos), n, head, list) { > + efi_pstore_scan_sysfs_enter((*pos), n, head); > + > + size = efi_pstore_read_func((*pos), data); > + efi_pstore_scan_sysfs_exit((*pos), n, head, size < 0); > + if (size) > + break; > + } > + *pos = n; > + return size; > +} > + > static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type, > int *count, struct timespec *timespec, > char **buf, bool *compressed, > struct pstore_info *psi) > { > struct pstore_read_data data; > + ssize_t size; > > data.id = id; > data.type = type; > @@ -112,8 +230,11 @@ static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type, > data.compressed = compressed; > data.buf = buf; > > - return __efivar_entry_iter(efi_pstore_read_func, &efivar_sysfs_list, &data, > - (struct efivar_entry **)&psi->data); > + efivar_entry_iter_begin(); > + size = efi_pstore_sysfs_entry_iter(&data, > + (struct efivar_entry **)&psi->data); > + efivar_entry_iter_end(); > + return size; > } > > static int efi_pstore_write(enum pstore_type_id type, > @@ -184,9 +305,17 @@ static int efi_pstore_erase_func(struct efivar_entry *entry, void *data) > return 0; > } > > + if (entry->scanning) { > + /* > + * Skip deletion because this entry will be deleted > + * after scanning is completed. > + */ > + entry->deleting = true; > + } else > + list_del(&entry->list); > + > /* found */ > __efivar_entry_delete(entry); > - list_del(&entry->list); > > return 1; > } > @@ -216,7 +345,7 @@ static int efi_pstore_erase(enum pstore_type_id type, u64 id, int count, > found = __efivar_entry_iter(efi_pstore_erase_func, &efivar_sysfs_list, &edata, &entry); > efivar_entry_iter_end(); > > - if (found) > + if (found && !entry->scanning) > efivar_unregister(entry); > > return 0; > diff --git a/drivers/firmware/efi/efivars.c b/drivers/firmware/efi/efivars.c > index 8a7432a..831bc5c 100644 > --- a/drivers/firmware/efi/efivars.c > +++ b/drivers/firmware/efi/efivars.c > @@ -388,7 +388,8 @@ static ssize_t efivar_delete(struct file *filp, struct kobject *kobj, > if (err) > return err; > > - efivar_unregister(entry); > + if (!entry->scanning) > + efivar_unregister(entry); > > /* It's dead Jim.... */ > return count; > diff --git a/drivers/firmware/efi/vars.c b/drivers/firmware/efi/vars.c > index 391c67b..573ed92 100644 > --- a/drivers/firmware/efi/vars.c > +++ b/drivers/firmware/efi/vars.c > @@ -683,8 +683,16 @@ struct efivar_entry *efivar_entry_find(efi_char16_t *name, efi_guid_t guid, > if (!found) > return NULL; > > - if (remove) > - list_del(&entry->list); > + if (remove) { > + if (entry->scanning) { > + /* > + * The entry will be deleted > + * after scanning is completed. > + */ > + entry->deleting = true; > + } else > + list_del(&entry->list); > + } > > return entry; > } > @@ -715,33 +723,6 @@ int efivar_entry_size(struct efivar_entry *entry, unsigned long *size) > EXPORT_SYMBOL_GPL(efivar_entry_size); > > /** > - * __efivar_entry_get - call get_variable() > - * @entry: read data for this variable > - * @attributes: variable attributes > - * @size: size of @data buffer > - * @data: buffer to store variable data > - * > - * The caller MUST call efivar_entry_iter_begin() and > - * efivar_entry_iter_end() before and after the invocation of this > - * function, respectively. > - */ > -int __efivar_entry_get(struct efivar_entry *entry, u32 *attributes, > - unsigned long *size, void *data) > -{ > - const struct efivar_operations *ops = __efivars->ops; > - efi_status_t status; > - > - WARN_ON(!spin_is_locked(&__efivars->lock)); > - > - status = ops->get_variable(entry->var.VariableName, > - &entry->var.VendorGuid, > - attributes, size, data); > - > - return efi_status_to_err(status); > -} > -EXPORT_SYMBOL_GPL(__efivar_entry_get); > - > -/** > * efivar_entry_get - call get_variable() > * @entry: read data for this variable > * @attributes: variable attributes > diff --git a/include/linux/efi.h b/include/linux/efi.h > index 5f8f176..1e3388e 100644 > --- a/include/linux/efi.h > +++ b/include/linux/efi.h > @@ -782,6 +782,8 @@ struct efivar_entry { > struct efi_variable var; > struct list_head list; > struct kobject kobj; > + bool scanning; > + bool deleting; > }; > > extern struct list_head efivar_sysfs_list; > @@ -809,8 +811,6 @@ int __efivar_entry_delete(struct efivar_entry *entry); > int efivar_entry_delete(struct efivar_entry *entry); > > int efivar_entry_size(struct efivar_entry *entry, unsigned long *size); > -int __efivar_entry_get(struct efivar_entry *entry, u32 *attributes, > - unsigned long *size, void *data); > int efivar_entry_get(struct efivar_entry *entry, u32 *attributes, > unsigned long *size, void *data); > int efivar_entry_set(struct efivar_entry *entry, u32 attributes, > -- > 1.8.2.1 > > -- > 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/ {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I From mboxrd@z Thu Jan 1 00:00:00 1970 From: Seiji Aguchi Subject: RE: [RFC][PATCH v2] efivars,efi-pstore: Hold off deletion of sysfs entry until the scan is completed Date: Fri, 4 Oct 2013 15:46:50 +0000 Message-ID: References: <5245E958.5040602@hds.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <5245E958.5040602-7rDLJAbr9SE@public.gmane.org> Content-Language: en-US Sender: linux-efi-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org To: "linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "linux-efi-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "tony.luck-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org" , "matt.fleming-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org" Cc: "dle-develop-5NWGOfrQmneRv+LV9MX5uipxlwaOVQ5f@public.gmane.org" , Tomoki Sekiyama List-Id: linux-efi@vger.kernel.org QXJlIHRoZXJlIGFueW9uZSB3aG8gY2FuIHJldmlldyB0aGlzIGJ1Z2ZpeD8NCg0KU2VpamkNCg0K PiAtLS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KPiBGcm9tOiBsaW51eC1rZXJuZWwtb3duZXJA dmdlci5rZXJuZWwub3JnIFttYWlsdG86bGludXgta2VybmVsLW93bmVyQHZnZXIua2VybmVsLm9y Z10gT24gQmVoYWxmIE9mIFNlaWppIEFndWNoaQ0KPiBTZW50OiBGcmlkYXksIFNlcHRlbWJlciAy NywgMjAxMyA0OjI0IFBNDQo+IFRvOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnOyBsaW51 eC1lZmlAdmdlci5rZXJuZWwub3JnOyB0b255Lmx1Y2tAaW50ZWwuY29tOyBtYXR0LmZsZW1pbmdA aW50ZWwuY29tDQo+IENjOiBkbGUtZGV2ZWxvcEBsaXN0cy5zb3VyY2Vmb3JnZS5uZXQ7IFRvbW9r aSBTZWtpeWFtYQ0KPiBTdWJqZWN0OiBbUkZDXVtQQVRDSCB2Ml0gZWZpdmFycyxlZmktcHN0b3Jl OiBIb2xkIG9mZiBkZWxldGlvbiBvZiBzeXNmcyBlbnRyeSB1bnRpbCB0aGUgc2NhbiBpcyBjb21w bGV0ZWQNCj4gDQo+IENoYW5nZSBmb3JtIHYxDQo+ICAtIFJlYmFzZSB0byAzLjEyLXJjMg0KPiAN Cj4gQ3VycmVudGx5LCB3aGVuIG1vdW50aW5nIHBzdG9yZSBmaWxlIHN5c3RlbSwgYSByZWFkIGNh bGxiYWNrIG9mIGVmaV9wc3RvcmUNCj4gZHJpdmVyIHJ1bnMgbXV0aXBsZSB0aW1lcyBhcyBiZWxv dy4NCj4gDQo+IC0gSW4gdGhlIGZpcnN0IHJlYWQgY2FsbGJhY2ssIHNjYW4gZWZpdmFyX3N5c2Zz X2xpc3QgZnJvbSBoZWFkIGFuZCBwYXNzDQo+ICAgYSBrbXNnIGJ1ZmZlciBvZiBhIGVudHJ5IHRv IGFuIHVwcGVyIHBzdG9yZSBsYXllci4NCj4gLSBJbiB0aGUgc2Vjb25kIHJlYWQgY2FsbGJhY2ss IHJlc2NhbiBlZml2YXJfc3lzZnNfbGlzdCBmcm9tIHRoZSBlbnRyeSBhbmQgcGFzcw0KPiAgIGFu b3RoZXIga21zZyBidWZmZXIgdG8gaXQuDQo+IC0gUmVwZWF0IHRoZSBzY2FuIGFuZCBwYXNzIHVu dGlsIHRoZSBlbmQgb2YgZWZpdmFyX3N5c2ZzX2xpc3QuDQo+IA0KPiBJbiB0aGlzIHByb2Nlc3Ms IGFuIGVudHJ5IGlzIHJlYWQgYWNyb3NzIHRoZSBtdWx0aXBsZSByZWFkIGZ1bmN0aW9uIGNhbGxz Lg0KPiBUbyBhdm9pZCByYWNlIGJldHdlZW4gdGhlIHJlYWQgYW5kIGVyYXNpb24sIHRoZSB3aG9s ZSBwcm9jZXNzIGFib3ZlIGlzDQo+IHByb3RlY3RlZCBieSBhIHNwaW5sb2NrLCBob2xkaW5nIGlu IG9wZW4oKSBhbmQgcmVsZWFzaW5nIGluIGNsb3NlKCkuDQo+IA0KPiBBdCB0aGUgc2FtZSB0aW1l LCBrbWVtZHVwKCkgaXMgY2FsbGVkIHRvIHBhc3MgdGhlIGJ1ZmZlciB0byBwc3RvcmUgZmlsZXN5 c3RlbQ0KPiBkdXJpbmcgaXQuDQo+IEFuZCB0aGVuLCBpdCBjYXVzZXMgYSBmb2xsb3dpbmcgbG9j a2RlcCB3YXJuaW5nLg0KPiANCj4gVG8gbWFrZSB0aGUgcmVhZCBjYWxsYmFjayBydW5uYWJsZSB3 aXRob3V0IHRha2luZyBzcGlubG9rLA0KPiBob2xkaW5nIG9mZiBhIGRlbGV0aW9uIG9mIHN5c2Zz IGVudHJ5IGlmIGl0IGhhcHBlbnMgd2hpbGUgc2Nhbm5pbmcgaXQNCj4gdmlhIGVmaV9wc3RvcmUs IGFuZCBkZWxldGluZyBpdCBhZnRlciB0aGUgc2NhbiBpcyBjb21wbGV0ZWQuDQo+IA0KPiBUbyBp bXBsZW1lbnQgaXQsIHRoaXMgcGF0Y2ggaW50cm9kdWNlcyB0d28gZmxhZ3MsIHNjYW5uaW5nIGFu ZCBkZWxldGluZywNCj4gdG8gZWZpdmFyX2VudHJ5Lg0KPiBBbHNvLCBfX2VmaXZhcl9lbnRyeV9n ZXQoKSBpcyByZW1vdmVkIGJlY2F1c2UgaXQgd2FzIHVzZWQgaW4gZWZpX3BzdG9yZSBvbmx5Lg0K PiANCj4gWyAgICAxLjE0MzcxMF0gLS0tLS0tLS0tLS0tWyBjdXQgaGVyZSBdLS0tLS0tLS0tLS0t DQo+IFsgICAgMS4xNDQwNThdIFdBUk5JTkc6IENQVTogMSBQSUQ6IDEgYXQga2VybmVsL2xvY2tk ZXAuYzoyNzQwDQo+IGxvY2tkZXBfdHJhY2VfYWxsb2MrMHgxMDQvMHgxMTAoKQ0KPiBbICAgIDEu MTQ0MDU4XSBERUJVR19MT0NLU19XQVJOX09OKGlycXNfZGlzYWJsZWRfZmxhZ3MoZmxhZ3MpKQ0K PiBbICAgIDEuMTQ0MDU4XSBNb2R1bGVzIGxpbmtlZCBpbjoNCj4gDQo+IFsgICAgMS4xNDQwNThd IENQVTogMSBQSUQ6IDEgQ29tbTogc3lzdGVtZCBOb3QgdGFpbnRlZCAzLjExLjAtcmM1ICMyDQo+ IFsgICAgMS4xNDQwNThdICAwMDAwMDAwMDAwMDAwMDA5IGZmZmY4ODAwNzk3ZTlhZTAgZmZmZmZm ZmY4MTY2MTRhNQ0KPiBmZmZmODgwMDc5N2U5YjI4DQo+IFsgICAgMS4xNDQwNThdICBmZmZmODgw MDc5N2U5YjE4IGZmZmZmZmZmODEwNTUxMGQgMDAwMDAwMDAwMDAwMDA4MA0KPiAwMDAwMDAwMDAw MDAwMDQ2DQo+IFsgICAgMS4xNDQwNThdICAwMDAwMDAwMDAwMDAwMGQwIDAwMDAwMDAwMDAwMDAz YWYgZmZmZmZmZmY4MWNjZDBjMA0KPiBmZmZmODgwMDc5N2U5Yjc4DQo+IFsgICAgMS4xNDQwNThd IENhbGwgVHJhY2U6DQo+IFsgICAgMS4xNDQwNThdICBbPGZmZmZmZmZmODE2NjE0YTU+XSBkdW1w X3N0YWNrKzB4NTQvMHg3NA0KPiBbICAgIDEuMTQ0MDU4XSAgWzxmZmZmZmZmZjgxMDU1MTBkPl0g d2Fybl9zbG93cGF0aF9jb21tb24rMHg3ZC8weGEwDQo+IFsgICAgMS4xNDQwNThdICBbPGZmZmZm ZmZmODEwNTUxN2M+XSB3YXJuX3Nsb3dwYXRoX2ZtdCsweDRjLzB4NTANCj4gWyAgICAxLjE0NDA1 OF0gIFs8ZmZmZmZmZmY4MTMxMjkwZj5dID8gdnNzY2FuZisweDU3Zi8weDdiMA0KPiBbICAgIDEu MTQ0MDU4XSAgWzxmZmZmZmZmZjgxMGJiZDc0Pl0gbG9ja2RlcF90cmFjZV9hbGxvYysweDEwNC8w eDExMA0KPiBbICAgIDEuMTQ0MDU4XSAgWzxmZmZmZmZmZjgxMTkyZGEwPl0gX19rbWFsbG9jX3Ry YWNrX2NhbGxlcisweDUwLzB4MjgwDQo+IFsgICAgMS4xNDQwNThdICBbPGZmZmZmZmZmODE1MTQ3 YmI+XSA/DQo+IGVmaV9wc3RvcmVfcmVhZF9mdW5jLnBhcnQuMSsweDEyYi8weDE3MA0KPiBbICAg IDEuMTQ0MDU4XSAgWzxmZmZmZmZmZjgxMTViMjYwPl0ga21lbWR1cCsweDIwLzB4NTANCj4gWyAg ICAxLjE0NDA1OF0gIFs8ZmZmZmZmZmY4MTUxNDdiYj5dIGVmaV9wc3RvcmVfcmVhZF9mdW5jLnBh cnQuMSsweDEyYi8weDE3MA0KPiBbICAgIDEuMTQ0MDU4XSAgWzxmZmZmZmZmZjgxNTE0ODAwPl0g Pw0KPiBlZmlfcHN0b3JlX3JlYWRfZnVuYy5wYXJ0LjErMHgxNzAvMHgxNzANCj4gWyAgICAxLjE0 NDA1OF0gIFs8ZmZmZmZmZmY4MTUxNDhiND5dIGVmaV9wc3RvcmVfcmVhZF9mdW5jKzB4YjQvMHhl MA0KPiBbICAgIDEuMTQ0MDU4XSAgWzxmZmZmZmZmZjgxNTEyYjdiPl0gX19lZml2YXJfZW50cnlf aXRlcisweGZiLzB4MTIwDQo+IFsgICAgMS4xNDQwNThdICBbPGZmZmZmZmZmODE1MTQyOGY+XSBl ZmlfcHN0b3JlX3JlYWQrMHgzZi8weDUwDQo+IFsgICAgMS4xNDQwNThdICBbPGZmZmZmZmZmODEy OGQ3YmE+XSBwc3RvcmVfZ2V0X3JlY29yZHMrMHg5YS8weDE1MA0KPiBbICAgIDEuMTU4MjA3XSAg WzxmZmZmZmZmZjgxMmFmMjVjPl0gPyBzZWxpbnV4X2RfaW5zdGFudGlhdGUrMHgxYy8weDIwDQo+ IFsgICAgMS4xNTgyMDddICBbPGZmZmZmZmZmODEyOGNlMzA+XSA/IHBhcnNlX29wdGlvbnMrMHg4 MC8weDgwDQo+IFsgICAgMS4xNTgyMDddICBbPGZmZmZmZmZmODEyOGNlZDU+XSBwc3RvcmVfZmls bF9zdXBlcisweGE1LzB4YzANCj4gWyAgICAxLjE1ODIwN10gIFs8ZmZmZmZmZmY4MTFhZTdkMj5d IG1vdW50X3NpbmdsZSsweGEyLzB4ZDANCj4gWyAgICAxLjE1ODIwN10gIFs8ZmZmZmZmZmY4MTI4 Y2NmOD5dIHBzdG9yZV9tb3VudCsweDE4LzB4MjANCj4gWyAgICAxLjE1ODIwN10gIFs8ZmZmZmZm ZmY4MTFhZThiOT5dIG1vdW50X2ZzKzB4MzkvMHgxYjANCj4gWyAgICAxLjE1ODIwN10gIFs8ZmZm ZmZmZmY4MTE2MDU1MD5dID8gX19hbGxvY19wZXJjcHUrMHgxMC8weDIwDQo+IFsgICAgMS4xNTgy MDddICBbPGZmZmZmZmZmODExYzk0OTM+XSB2ZnNfa2Vybl9tb3VudCsweDYzLzB4ZjANCj4gWyAg ICAxLjE1ODIwN10gIFs8ZmZmZmZmZmY4MTFjYmIwZT5dIGRvX21vdW50KzB4MjNlLzB4YTIwDQo+ IFsgICAgMS4xNTgyMDddICBbPGZmZmZmZmZmODExNWI1MWI+XSA/IHN0cm5kdXBfdXNlcisweDRi LzB4ZjANCj4gWyAgICAxLjE1ODIwN10gIFs8ZmZmZmZmZmY4MTFjYzM3Mz5dIFN5U19tb3VudCsw eDgzLzB4YzANCj4gWyAgICAxLjE1ODIwN10gIFs8ZmZmZmZmZmY4MTY3M2NjMj5dIHN5c3RlbV9j YWxsX2Zhc3RwYXRoKzB4MTYvMHgxYg0KPiBbICAgIDEuMTU4MjA3XSAtLS1bIGVuZCB0cmFjZSA2 MTk4MWJjNjJkZTlmNmY0IF0tLS0NCj4gDQo+IFNpZ25lZC1vZmYtYnk6IFNlaWppIEFndWNoaSA8 c2VpamkuYWd1Y2hpQGhkcy5jb20+DQo+IC0tLQ0KPiAgZHJpdmVycy9maXJtd2FyZS9lZmkvZWZp LXBzdG9yZS5jIHwgMTQ1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tDQo+ ICBkcml2ZXJzL2Zpcm13YXJlL2VmaS9lZml2YXJzLmMgICAgfCAgIDMgKy0NCj4gIGRyaXZlcnMv ZmlybXdhcmUvZWZpL3ZhcnMuYyAgICAgICB8ICAzOSArKystLS0tLS0tDQo+ICBpbmNsdWRlL2xp bnV4L2VmaS5oICAgICAgICAgICAgICAgfCAgIDQgKy0NCj4gIDQgZmlsZXMgY2hhbmdlZCwgMTUx IGluc2VydGlvbnMoKyksIDQwIGRlbGV0aW9ucygtKQ0KPiANCj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvZmlybXdhcmUvZWZpL2VmaS1wc3RvcmUuYyBiL2RyaXZlcnMvZmlybXdhcmUvZWZpL2VmaS1w c3RvcmUuYw0KPiBpbmRleCA1MDAyZDUwLi41MzAwMWE1IDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJz L2Zpcm13YXJlL2VmaS9lZmktcHN0b3JlLmMNCj4gKysrIGIvZHJpdmVycy9maXJtd2FyZS9lZmkv ZWZpLXBzdG9yZS5jDQo+IEBAIC0xOCwxNCArMTgsMTIgQEAgbW9kdWxlX3BhcmFtX25hbWVkKHBz dG9yZV9kaXNhYmxlLCBlZml2YXJzX3BzdG9yZV9kaXNhYmxlLCBib29sLCAwNjQ0KTsNCj4gDQo+ ICBzdGF0aWMgaW50IGVmaV9wc3RvcmVfb3BlbihzdHJ1Y3QgcHN0b3JlX2luZm8gKnBzaSkNCj4g IHsNCj4gLQllZml2YXJfZW50cnlfaXRlcl9iZWdpbigpOw0KPiAgCXBzaS0+ZGF0YSA9IE5VTEw7 DQo+ICAJcmV0dXJuIDA7DQo+ICB9DQo+IA0KPiAgc3RhdGljIGludCBlZmlfcHN0b3JlX2Nsb3Nl KHN0cnVjdCBwc3RvcmVfaW5mbyAqcHNpKQ0KPiAgew0KPiAtCWVmaXZhcl9lbnRyeV9pdGVyX2Vu ZCgpOw0KPiAgCXBzaS0+ZGF0YSA9IE5VTEw7DQo+ICAJcmV0dXJuIDA7DQo+ICB9DQo+IEBAIC0z OSw2ICszNywyMyBAQCBzdHJ1Y3QgcHN0b3JlX3JlYWRfZGF0YSB7DQo+ICAJY2hhciAqKmJ1ZjsN Cj4gIH07DQo+IA0KPiArLyoqDQo+ICsgKiBlZmlfcHN0b3JlX3JlYWRfZnVuYw0KPiArICogQGVu dHJ5OiByZWFkaW5nIGVudHJ5DQo+ICsgKiBAZGF0YTogIGRhdGEgb2YgdGhlIGVudHJ5DQo+ICsg Kg0KPiArICogVGhpcyBmdW5jdGlvbiBydW5zIGluIG5vbi1hdG9taWMgY29udGV4dC4NCj4gKyAq DQo+ICsgKiBBbHNvLCBpdCByZXR1cm5zIGEgc2l6ZSBvZiBOVlJBTSBlbnRyeSBsb2dnZWQgdmlh IGVmaV9wc3RvcmVfd3JpdGUoKS4NCj4gKyAqIHBzdG9yZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhl IHJldHVybmVkIHZhbHVlIGFzIGJlbG93Lg0KPiArICoNCj4gKyAqIHNpemUgPiAwOiBHb3QgZGF0 YSBvZiBhbiBlbnRyeSBsb2dnZWQgdmlhIGVmaV9wc3RvcmVfd3JpdGUoKSBzdWNjZXNzZnVsbHks DQo+ICsgKiAgICAgICAgICAgYW5kIHBzdG9yZSBmaWxlc3lzdGVtIHdpbGwgY29udGludWUgcmVh ZGluZyBzdWJzZXF1ZW50IGVudHJpZXMuDQo+ICsgKiBzaXplID09IDA6IEVudHJ5IHdhcyBub3Qg bG9nZ2VkIHZpYSBlZmlfcHN0b3JlX3dyaXRlKCksDQo+ICsgKiAgICAgICAgICAgIGFuZCBlZmlf cHN0b3JlIGRyaXZlciB3aWxsIGNvbnRpbnVlIHJlYWRpbmcgc3Vic2VxdWVudCBlbnRyaWVzLg0K PiArICogc2l6ZSA8IDA6IEZhaWxlZCB0byBnZXQgZGF0YSBvZiBlbnRyeSBsb2dnaW5nIHZpYSBl ZmlfcHN0b3JlX3dyaXRlKCksDQo+ICsgKiAgICAgICAgICAgYW5kIHBzdG9yZSB3aWxsIHN0b3Ag cmVhZGluZyBlbnRyeS4NCj4gKyAqLw0KPiAgc3RhdGljIGludCBlZmlfcHN0b3JlX3JlYWRfZnVu YyhzdHJ1Y3QgZWZpdmFyX2VudHJ5ICplbnRyeSwgdm9pZCAqZGF0YSkNCj4gIHsNCj4gIAllZmlf Z3VpZF90IHZlbmRvciA9IExJTlVYX0VGSV9DUkFTSF9HVUlEOw0KPiBAQCAtODgsOCArMTAzLDkg QEAgc3RhdGljIGludCBlZmlfcHN0b3JlX3JlYWRfZnVuYyhzdHJ1Y3QgZWZpdmFyX2VudHJ5ICpl bnRyeSwgdm9pZCAqZGF0YSkNCj4gIAkJcmV0dXJuIDA7DQo+IA0KPiAgCWVudHJ5LT52YXIuRGF0 YVNpemUgPSAxMDI0Ow0KPiAtCV9fZWZpdmFyX2VudHJ5X2dldChlbnRyeSwgJmVudHJ5LT52YXIu QXR0cmlidXRlcywNCj4gLQkJCSAgICZlbnRyeS0+dmFyLkRhdGFTaXplLCBlbnRyeS0+dmFyLkRh dGEpOw0KPiArCWVmaXZhcl9lbnRyeV9nZXQoZW50cnksICZlbnRyeS0+dmFyLkF0dHJpYnV0ZXMs DQo+ICsJCQkgJmVudHJ5LT52YXIuRGF0YVNpemUsIGVudHJ5LT52YXIuRGF0YSk7DQo+ICsNCj4g IAlzaXplID0gZW50cnktPnZhci5EYXRhU2l6ZTsNCj4gDQo+ICAJKmNiX2RhdGEtPmJ1ZiA9IGtt ZW1kdXAoZW50cnktPnZhci5EYXRhLCBzaXplLCBHRlBfS0VSTkVMKTsNCj4gQEAgLTk4LDEyICsx MTQsMTE0IEBAIHN0YXRpYyBpbnQgZWZpX3BzdG9yZV9yZWFkX2Z1bmMoc3RydWN0IGVmaXZhcl9l bnRyeSAqZW50cnksIHZvaWQgKmRhdGEpDQo+ICAJcmV0dXJuIHNpemU7DQo+ICB9DQo+IA0KPiAr LyoqDQo+ICsgKiBlZmlfcHN0b3JlX3NjYW5fc3lzZnNfZW50ZXINCj4gKyAqIEBlbnRyeTogc2Nh bm5pbmcgZW50cnkNCj4gKyAqIEBuZXh0OiBuZXh0IGVudHJ5DQo+ICsgKiBAaGVhZDogbGlzdCBo ZWFkDQo+ICsgKi8NCj4gK3N0YXRpYyB2b2lkIGVmaV9wc3RvcmVfc2Nhbl9zeXNmc19lbnRlcihz dHJ1Y3QgZWZpdmFyX2VudHJ5ICpwb3MsDQo+ICsJCQkJCXN0cnVjdCBlZml2YXJfZW50cnkgKm5l eHQsDQo+ICsJCQkJCXN0cnVjdCBsaXN0X2hlYWQgKmhlYWQpDQo+ICt7DQo+ICsJcG9zLT5zY2Fu bmluZyA9IHRydWU7DQo+ICsJaWYgKCZuZXh0LT5saXN0ICE9IGhlYWQpDQo+ICsJCW5leHQtPnNj YW5uaW5nID0gdHJ1ZTsNCj4gKw0KPiArCS8qDQo+ICsJICogUmVsZWFzZSBhIHNwaW5fbG9jayBi ZWNhdXNlIGVmaV9wc3RvcmVfcmVhZF9mdW5jKCkgc2hvdWxkDQo+ICsJICogcnVuIGluIG5vbi1h dG9taWMgY29udGV4dCB0byBhbGxvY2F0ZSBidWZmZXIgZHluYW1pY2FsbHkuDQo+ICsJICovDQo+ ICsJZWZpdmFyX2VudHJ5X2l0ZXJfZW5kKCk7DQo+ICt9DQo+ICsNCj4gKy8qKg0KPiArICogX19l ZmlfcHN0b3JlX3NjYW5fc3lzZnNfZXhpdA0KPiArICogQGVudHJ5OiBkZWxldGluZyBlbnRyeQ0K PiArICogQHR1cm5fb2ZmX3NjYW5uaW5nOiBDaGVjayBpZiBhIHNjYW5uaW5nIGZsYWcgc2hvdWxk IGJlIHR1cm5lZCBvZmYNCj4gKyAqLw0KPiArc3RhdGljIGlubGluZSB2b2lkIF9fZWZpX3BzdG9y ZV9zY2FuX3N5c2ZzX2V4aXQoc3RydWN0IGVmaXZhcl9lbnRyeSAqZW50cnksDQo+ICsJCQkJCQli b29sIHR1cm5fb2ZmX3NjYW5uaW5nKQ0KPiArew0KPiArCWlmIChlbnRyeS0+ZGVsZXRpbmcpIHsN Cj4gKwkJbGlzdF9kZWwoJmVudHJ5LT5saXN0KTsNCj4gKwkJZWZpdmFyX2VudHJ5X2l0ZXJfZW5k KCk7DQo+ICsJCWVmaXZhcl91bnJlZ2lzdGVyKGVudHJ5KTsNCj4gKwkJZWZpdmFyX2VudHJ5X2l0 ZXJfYmVnaW4oKTsNCj4gKwl9IGVsc2UgaWYgKHR1cm5fb2ZmX3NjYW5uaW5nKQ0KPiArCQllbnRy eS0+c2Nhbm5pbmcgPSBmYWxzZTsNCj4gK30NCj4gKw0KPiArLyoqDQo+ICsgKiBlZmlfcHN0b3Jl X3NjYW5fc3lzZnNfZXhpdA0KPiArICogQHBvczogc2Nhbm5pbmcgZW50cnkNCj4gKyAqIEBuZXh0 OiBuZXh0IGVudHJ5DQo+ICsgKiBAaGVhZDogbGlzdCBoZWFkDQo+ICsgKiBAc3RvcDogYSBmbGFn IGNoZWNraW5nIGlmIHNjYW5uaW5nIHdpbGwgc3RvcA0KPiArICovDQo+ICtzdGF0aWMgdm9pZCBl ZmlfcHN0b3JlX3NjYW5fc3lzZnNfZXhpdChzdHJ1Y3QgZWZpdmFyX2VudHJ5ICpwb3MsDQo+ICsJ CQkJICAgICAgIHN0cnVjdCBlZml2YXJfZW50cnkgKm5leHQsDQo+ICsJCQkJICAgICAgIHN0cnVj dCBsaXN0X2hlYWQgKmhlYWQsIGJvb2wgc3RvcCkNCj4gK3sNCj4gKwkvKiBIb2xkIGEgc3Bpbmxv Y2sgdG8gYWNjZXNzIGVmaXZhcl9lbnRyeSBzYWZlbHkuICovDQo+ICsJZWZpdmFyX2VudHJ5X2l0 ZXJfYmVnaW4oKTsNCj4gKwlfX2VmaV9wc3RvcmVfc2Nhbl9zeXNmc19leGl0KHBvcywgdHJ1ZSk7 DQo+ICsJaWYgKHN0b3ApDQo+ICsJCV9fZWZpX3BzdG9yZV9zY2FuX3N5c2ZzX2V4aXQobmV4dCwg Jm5leHQtPmxpc3QgIT0gaGVhZCk7DQo+ICt9DQo+ICsNCj4gKy8qKg0KPiArICogZWZpX3BzdG9y ZV9zeXNmc19lbnRyeV9pdGVyDQo+ICsgKg0KPiArICogQGRhdGE6IGZ1bmN0aW9uLXNwZWNpZmlj IGRhdGEgdG8gcGFzcyB0byBjYWxsYmFjaw0KPiArICogQHBvczogZW50cnkgdG8gYmVnaW4gaXRl cmF0aW5nIGZyb20NCj4gKyAqDQo+ICsgKiBZb3UgTVVTVCBjYWxsIGVmaXZhcl9lbnRlcl9pdGVy X2JlZ2luKCkgYmVmb3JlIHRoaXMgZnVuY3Rpb24sIGFuZA0KPiArICogZWZpdmFyX2VudHJ5X2l0 ZXJfZW5kKCkgYWZ0ZXJ3YXJkcy4NCj4gKyAqDQo+ICsgKiBJdCBpcyBwb3NzaWJsZSB0byBiZWdp biBpdGVyYXRpb24gZnJvbSBhbiBhcmJpdHJhcnkgZW50cnkgd2l0aGluDQo+ICsgKiB0aGUgbGlz dCBieSBwYXNzaW5nIEBwb3MuIEBwb3MgaXMgdXBkYXRlZCBvbiByZXR1cm4gdG8gcG9pbnQgdG8N Cj4gKyAqIHRoZSBuZXh0IGVudHJ5IG9mIHRoZSBsYXN0IG9uZSBwYXNzZWQgdG8gZWZpX3BzdG9y ZV9yZWFkX2Z1bmMoKS4NCj4gKyAqIFRvIGJlZ2luIGl0ZXJhdGluZyBmcm9tIHRoZSBiZWdpbm5p bmcgb2YgdGhlIGxpc3QgQHBvcyBtdXN0IGJlICVOVUxMLg0KPiArICovDQo+ICtzdGF0aWMgaW50 IGVmaV9wc3RvcmVfc3lzZnNfZW50cnlfaXRlcih2b2lkICpkYXRhLCBzdHJ1Y3QgZWZpdmFyX2Vu dHJ5ICoqcG9zKQ0KPiArew0KPiArCXN0cnVjdCBlZml2YXJfZW50cnkgKmVudHJ5LCAqbjsNCj4g KwlzdHJ1Y3QgbGlzdF9oZWFkICpoZWFkID0gJmVmaXZhcl9zeXNmc19saXN0Ow0KPiArCWludCBz aXplID0gMDsNCj4gKw0KPiArCWlmICghKnBvcykgew0KPiArCQlsaXN0X2Zvcl9lYWNoX2VudHJ5 X3NhZmUoZW50cnksIG4sIGhlYWQsIGxpc3QpIHsNCj4gKwkJCWVmaV9wc3RvcmVfc2Nhbl9zeXNm c19lbnRlcihlbnRyeSwgbiwgaGVhZCk7DQo+ICsNCj4gKwkJCXNpemUgPSBlZmlfcHN0b3JlX3Jl YWRfZnVuYyhlbnRyeSwgZGF0YSk7DQo+ICsJCQllZmlfcHN0b3JlX3NjYW5fc3lzZnNfZXhpdChl bnRyeSwgbiwgaGVhZCwgc2l6ZSA8IDApOw0KPiArCQkJaWYgKHNpemUpDQo+ICsJCQkJYnJlYWs7 DQo+ICsJCX0NCj4gKwkJKnBvcyA9IG47DQo+ICsJCXJldHVybiBzaXplOw0KPiArCX0NCj4gKw0K PiArCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZV9mcm9tKCgqcG9zKSwgbiwgaGVhZCwgbGlzdCkg ew0KPiArCQllZmlfcHN0b3JlX3NjYW5fc3lzZnNfZW50ZXIoKCpwb3MpLCBuLCBoZWFkKTsNCj4g Kw0KPiArCQlzaXplID0gZWZpX3BzdG9yZV9yZWFkX2Z1bmMoKCpwb3MpLCBkYXRhKTsNCj4gKwkJ ZWZpX3BzdG9yZV9zY2FuX3N5c2ZzX2V4aXQoKCpwb3MpLCBuLCBoZWFkLCBzaXplIDwgMCk7DQo+ ICsJCWlmIChzaXplKQ0KPiArCQkJYnJlYWs7DQo+ICsJfQ0KPiArCSpwb3MgPSBuOw0KPiArCXJl dHVybiBzaXplOw0KPiArfQ0KPiArDQo+ICBzdGF0aWMgc3NpemVfdCBlZmlfcHN0b3JlX3JlYWQo dTY0ICppZCwgZW51bSBwc3RvcmVfdHlwZV9pZCAqdHlwZSwNCj4gIAkJCSAgICAgICBpbnQgKmNv dW50LCBzdHJ1Y3QgdGltZXNwZWMgKnRpbWVzcGVjLA0KPiAgCQkJICAgICAgIGNoYXIgKipidWYs IGJvb2wgKmNvbXByZXNzZWQsDQo+ICAJCQkgICAgICAgc3RydWN0IHBzdG9yZV9pbmZvICpwc2kp DQo+ICB7DQo+ICAJc3RydWN0IHBzdG9yZV9yZWFkX2RhdGEgZGF0YTsNCj4gKwlzc2l6ZV90IHNp emU7DQo+IA0KPiAgCWRhdGEuaWQgPSBpZDsNCj4gIAlkYXRhLnR5cGUgPSB0eXBlOw0KPiBAQCAt MTEyLDggKzIzMCwxMSBAQCBzdGF0aWMgc3NpemVfdCBlZmlfcHN0b3JlX3JlYWQodTY0ICppZCwg ZW51bSBwc3RvcmVfdHlwZV9pZCAqdHlwZSwNCj4gIAlkYXRhLmNvbXByZXNzZWQgPSBjb21wcmVz c2VkOw0KPiAgCWRhdGEuYnVmID0gYnVmOw0KPiANCj4gLQlyZXR1cm4gX19lZml2YXJfZW50cnlf aXRlcihlZmlfcHN0b3JlX3JlYWRfZnVuYywgJmVmaXZhcl9zeXNmc19saXN0LCAmZGF0YSwNCj4g LQkJCQkgICAoc3RydWN0IGVmaXZhcl9lbnRyeSAqKikmcHNpLT5kYXRhKTsNCj4gKwllZml2YXJf ZW50cnlfaXRlcl9iZWdpbigpOw0KPiArCXNpemUgPSBlZmlfcHN0b3JlX3N5c2ZzX2VudHJ5X2l0 ZXIoJmRhdGEsDQo+ICsJCQkJCSAgIChzdHJ1Y3QgZWZpdmFyX2VudHJ5ICoqKSZwc2ktPmRhdGEp Ow0KPiArCWVmaXZhcl9lbnRyeV9pdGVyX2VuZCgpOw0KPiArCXJldHVybiBzaXplOw0KPiAgfQ0K PiANCj4gIHN0YXRpYyBpbnQgZWZpX3BzdG9yZV93cml0ZShlbnVtIHBzdG9yZV90eXBlX2lkIHR5 cGUsDQo+IEBAIC0xODQsOSArMzA1LDE3IEBAIHN0YXRpYyBpbnQgZWZpX3BzdG9yZV9lcmFzZV9m dW5jKHN0cnVjdCBlZml2YXJfZW50cnkgKmVudHJ5LCB2b2lkICpkYXRhKQ0KPiAgCQkJcmV0dXJu IDA7DQo+ICAJfQ0KPiANCj4gKwlpZiAoZW50cnktPnNjYW5uaW5nKSB7DQo+ICsJCS8qDQo+ICsJ CSAqIFNraXAgZGVsZXRpb24gYmVjYXVzZSB0aGlzIGVudHJ5IHdpbGwgYmUgZGVsZXRlZA0KPiAr CQkgKiBhZnRlciBzY2FubmluZyBpcyBjb21wbGV0ZWQuDQo+ICsJCSAqLw0KPiArCQllbnRyeS0+ ZGVsZXRpbmcgPSB0cnVlOw0KPiArCX0gZWxzZQ0KPiArCQlsaXN0X2RlbCgmZW50cnktPmxpc3Qp Ow0KPiArDQo+ICAJLyogZm91bmQgKi8NCj4gIAlfX2VmaXZhcl9lbnRyeV9kZWxldGUoZW50cnkp Ow0KPiAtCWxpc3RfZGVsKCZlbnRyeS0+bGlzdCk7DQo+IA0KPiAgCXJldHVybiAxOw0KPiAgfQ0K PiBAQCAtMjE2LDcgKzM0NSw3IEBAIHN0YXRpYyBpbnQgZWZpX3BzdG9yZV9lcmFzZShlbnVtIHBz dG9yZV90eXBlX2lkIHR5cGUsIHU2NCBpZCwgaW50IGNvdW50LA0KPiAgCWZvdW5kID0gX19lZml2 YXJfZW50cnlfaXRlcihlZmlfcHN0b3JlX2VyYXNlX2Z1bmMsICZlZml2YXJfc3lzZnNfbGlzdCwg JmVkYXRhLCAmZW50cnkpOw0KPiAgCWVmaXZhcl9lbnRyeV9pdGVyX2VuZCgpOw0KPiANCj4gLQlp ZiAoZm91bmQpDQo+ICsJaWYgKGZvdW5kICYmICFlbnRyeS0+c2Nhbm5pbmcpDQo+ICAJCWVmaXZh cl91bnJlZ2lzdGVyKGVudHJ5KTsNCj4gDQo+ICAJcmV0dXJuIDA7DQo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2Zpcm13YXJlL2VmaS9lZml2YXJzLmMgYi9kcml2ZXJzL2Zpcm13YXJlL2VmaS9lZml2 YXJzLmMNCj4gaW5kZXggOGE3NDMyYS4uODMxYmM1YyAxMDA2NDQNCj4gLS0tIGEvZHJpdmVycy9m aXJtd2FyZS9lZmkvZWZpdmFycy5jDQo+ICsrKyBiL2RyaXZlcnMvZmlybXdhcmUvZWZpL2VmaXZh cnMuYw0KPiBAQCAtMzg4LDcgKzM4OCw4IEBAIHN0YXRpYyBzc2l6ZV90IGVmaXZhcl9kZWxldGUo c3RydWN0IGZpbGUgKmZpbHAsIHN0cnVjdCBrb2JqZWN0ICprb2JqLA0KPiAgCWlmIChlcnIpDQo+ ICAJCXJldHVybiBlcnI7DQo+IA0KPiAtCWVmaXZhcl91bnJlZ2lzdGVyKGVudHJ5KTsNCj4gKwlp ZiAoIWVudHJ5LT5zY2FubmluZykNCj4gKwkJZWZpdmFyX3VucmVnaXN0ZXIoZW50cnkpOw0KPiAN Cj4gIAkvKiBJdCdzIGRlYWQgSmltLi4uLiAqLw0KPiAgCXJldHVybiBjb3VudDsNCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZmlybXdhcmUvZWZpL3ZhcnMuYyBiL2RyaXZlcnMvZmlybXdhcmUvZWZp L3ZhcnMuYw0KPiBpbmRleCAzOTFjNjdiLi41NzNlZDkyIDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJz L2Zpcm13YXJlL2VmaS92YXJzLmMNCj4gKysrIGIvZHJpdmVycy9maXJtd2FyZS9lZmkvdmFycy5j DQo+IEBAIC02ODMsOCArNjgzLDE2IEBAIHN0cnVjdCBlZml2YXJfZW50cnkgKmVmaXZhcl9lbnRy eV9maW5kKGVmaV9jaGFyMTZfdCAqbmFtZSwgZWZpX2d1aWRfdCBndWlkLA0KPiAgCWlmICghZm91 bmQpDQo+ICAJCXJldHVybiBOVUxMOw0KPiANCj4gLQlpZiAocmVtb3ZlKQ0KPiAtCQlsaXN0X2Rl bCgmZW50cnktPmxpc3QpOw0KPiArCWlmIChyZW1vdmUpIHsNCj4gKwkJaWYgKGVudHJ5LT5zY2Fu bmluZykgew0KPiArCQkJLyoNCj4gKwkJCSAqIFRoZSBlbnRyeSB3aWxsIGJlIGRlbGV0ZWQNCj4g KwkJCSAqIGFmdGVyIHNjYW5uaW5nIGlzIGNvbXBsZXRlZC4NCj4gKwkJCSAqLw0KPiArCQkJZW50 cnktPmRlbGV0aW5nID0gdHJ1ZTsNCj4gKwkJfSBlbHNlDQo+ICsJCQlsaXN0X2RlbCgmZW50cnkt Pmxpc3QpOw0KPiArCX0NCj4gDQo+ICAJcmV0dXJuIGVudHJ5Ow0KPiAgfQ0KPiBAQCAtNzE1LDMz ICs3MjMsNiBAQCBpbnQgZWZpdmFyX2VudHJ5X3NpemUoc3RydWN0IGVmaXZhcl9lbnRyeSAqZW50 cnksIHVuc2lnbmVkIGxvbmcgKnNpemUpDQo+ICBFWFBPUlRfU1lNQk9MX0dQTChlZml2YXJfZW50 cnlfc2l6ZSk7DQo+IA0KPiAgLyoqDQo+IC0gKiBfX2VmaXZhcl9lbnRyeV9nZXQgLSBjYWxsIGdl dF92YXJpYWJsZSgpDQo+IC0gKiBAZW50cnk6IHJlYWQgZGF0YSBmb3IgdGhpcyB2YXJpYWJsZQ0K PiAtICogQGF0dHJpYnV0ZXM6IHZhcmlhYmxlIGF0dHJpYnV0ZXMNCj4gLSAqIEBzaXplOiBzaXpl IG9mIEBkYXRhIGJ1ZmZlcg0KPiAtICogQGRhdGE6IGJ1ZmZlciB0byBzdG9yZSB2YXJpYWJsZSBk YXRhDQo+IC0gKg0KPiAtICogVGhlIGNhbGxlciBNVVNUIGNhbGwgZWZpdmFyX2VudHJ5X2l0ZXJf YmVnaW4oKSBhbmQNCj4gLSAqIGVmaXZhcl9lbnRyeV9pdGVyX2VuZCgpIGJlZm9yZSBhbmQgYWZ0 ZXIgdGhlIGludm9jYXRpb24gb2YgdGhpcw0KPiAtICogZnVuY3Rpb24sIHJlc3BlY3RpdmVseS4N Cj4gLSAqLw0KPiAtaW50IF9fZWZpdmFyX2VudHJ5X2dldChzdHJ1Y3QgZWZpdmFyX2VudHJ5ICpl bnRyeSwgdTMyICphdHRyaWJ1dGVzLA0KPiAtCQkgICAgICAgdW5zaWduZWQgbG9uZyAqc2l6ZSwg dm9pZCAqZGF0YSkNCj4gLXsNCj4gLQljb25zdCBzdHJ1Y3QgZWZpdmFyX29wZXJhdGlvbnMgKm9w cyA9IF9fZWZpdmFycy0+b3BzOw0KPiAtCWVmaV9zdGF0dXNfdCBzdGF0dXM7DQo+IC0NCj4gLQlX QVJOX09OKCFzcGluX2lzX2xvY2tlZCgmX19lZml2YXJzLT5sb2NrKSk7DQo+IC0NCj4gLQlzdGF0 dXMgPSBvcHMtPmdldF92YXJpYWJsZShlbnRyeS0+dmFyLlZhcmlhYmxlTmFtZSwNCj4gLQkJCQkg ICAmZW50cnktPnZhci5WZW5kb3JHdWlkLA0KPiAtCQkJCSAgIGF0dHJpYnV0ZXMsIHNpemUsIGRh dGEpOw0KPiAtDQo+IC0JcmV0dXJuIGVmaV9zdGF0dXNfdG9fZXJyKHN0YXR1cyk7DQo+IC19DQo+ IC1FWFBPUlRfU1lNQk9MX0dQTChfX2VmaXZhcl9lbnRyeV9nZXQpOw0KPiAtDQo+IC0vKioNCj4g ICAqIGVmaXZhcl9lbnRyeV9nZXQgLSBjYWxsIGdldF92YXJpYWJsZSgpDQo+ICAgKiBAZW50cnk6 IHJlYWQgZGF0YSBmb3IgdGhpcyB2YXJpYWJsZQ0KPiAgICogQGF0dHJpYnV0ZXM6IHZhcmlhYmxl IGF0dHJpYnV0ZXMNCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZWZpLmggYi9pbmNsdWRl L2xpbnV4L2VmaS5oDQo+IGluZGV4IDVmOGYxNzYuLjFlMzM4OGUgMTAwNjQ0DQo+IC0tLSBhL2lu Y2x1ZGUvbGludXgvZWZpLmgNCj4gKysrIGIvaW5jbHVkZS9saW51eC9lZmkuaA0KPiBAQCAtNzgy LDYgKzc4Miw4IEBAIHN0cnVjdCBlZml2YXJfZW50cnkgew0KPiAgCXN0cnVjdCBlZmlfdmFyaWFi bGUgdmFyOw0KPiAgCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsNCj4gIAlzdHJ1Y3Qga29iamVjdCBr b2JqOw0KPiArCWJvb2wgc2Nhbm5pbmc7DQo+ICsJYm9vbCBkZWxldGluZzsNCj4gIH07DQo+IA0K PiAgZXh0ZXJuIHN0cnVjdCBsaXN0X2hlYWQgZWZpdmFyX3N5c2ZzX2xpc3Q7DQo+IEBAIC04MDks OCArODExLDYgQEAgaW50IF9fZWZpdmFyX2VudHJ5X2RlbGV0ZShzdHJ1Y3QgZWZpdmFyX2VudHJ5 ICplbnRyeSk7DQo+ICBpbnQgZWZpdmFyX2VudHJ5X2RlbGV0ZShzdHJ1Y3QgZWZpdmFyX2VudHJ5 ICplbnRyeSk7DQo+IA0KPiAgaW50IGVmaXZhcl9lbnRyeV9zaXplKHN0cnVjdCBlZml2YXJfZW50 cnkgKmVudHJ5LCB1bnNpZ25lZCBsb25nICpzaXplKTsNCj4gLWludCBfX2VmaXZhcl9lbnRyeV9n ZXQoc3RydWN0IGVmaXZhcl9lbnRyeSAqZW50cnksIHUzMiAqYXR0cmlidXRlcywNCj4gLQkJICAg ICAgIHVuc2lnbmVkIGxvbmcgKnNpemUsIHZvaWQgKmRhdGEpOw0KPiAgaW50IGVmaXZhcl9lbnRy eV9nZXQoc3RydWN0IGVmaXZhcl9lbnRyeSAqZW50cnksIHUzMiAqYXR0cmlidXRlcywNCj4gIAkJ ICAgICB1bnNpZ25lZCBsb25nICpzaXplLCB2b2lkICpkYXRhKTsNCj4gIGludCBlZml2YXJfZW50 cnlfc2V0KHN0cnVjdCBlZml2YXJfZW50cnkgKmVudHJ5LCB1MzIgYXR0cmlidXRlcywNCj4gLS0N Cj4gMS44LjIuMQ0KPiANCj4gLS0NCj4gVG8gdW5zdWJzY3JpYmUgZnJvbSB0aGlzIGxpc3Q6IHNl bmQgdGhlIGxpbmUgInVuc3Vic2NyaWJlIGxpbnV4LWtlcm5lbCIgaW4NCj4gdGhlIGJvZHkgb2Yg YSBtZXNzYWdlIHRvIG1ham9yZG9tb0B2Z2VyLmtlcm5lbC5vcmcNCj4gTW9yZSBtYWpvcmRvbW8g aW5mbyBhdCAgaHR0cDovL3ZnZXIua2VybmVsLm9yZy9tYWpvcmRvbW8taW5mby5odG1sDQo+IFBs ZWFzZSByZWFkIHRoZSBGQVEgYXQgIGh0dHA6Ly93d3cudHV4Lm9yZy9sa21sLw0K