From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8A555C32771 for ; Wed, 15 Jan 2020 16:37:23 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 6088C2073A for ; Wed, 15 Jan 2020 16:37:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729009AbgAOQhW (ORCPT ); Wed, 15 Jan 2020 11:37:22 -0500 Received: from foss.arm.com ([217.140.110.172]:39732 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726562AbgAOQhW (ORCPT ); Wed, 15 Jan 2020 11:37:22 -0500 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 4D710328; Wed, 15 Jan 2020 08:37:21 -0800 (PST) Received: from [10.1.199.115] (e120195-lin.cambridge.arm.com [10.1.199.115]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 610E43F718; Wed, 15 Jan 2020 08:37:20 -0800 (PST) Subject: Re: [RFC v5 44/57] objtool: arm64: Implement functions to add switch tables alternatives To: Julien Thierry , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: jpoimboe@redhat.com, peterz@infradead.org, catalin.marinas@arm.com, will@kernel.org References: <20200109160300.26150-1-jthierry@redhat.com> <20200109160300.26150-45-jthierry@redhat.com> From: Raphael Gault Message-ID: <370e38b3-3c0c-e552-16fa-36571dd8e66b@arm.com> Date: Wed, 15 Jan 2020 16:37:19 +0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.2.2 MIME-Version: 1.0 In-Reply-To: <20200109160300.26150-45-jthierry@redhat.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Julien, On 1/9/20 4:02 PM, Julien Thierry wrote: > This patch implements the functions required to identify and add as > alternatives all the possible destinations of the switch table. > This implementation relies on the new plugin introduced previously which > records information about the switch-table in a > .discard.switch_table_information section. I think you forgot to update the name of the section with respect to what was done in the previous patch (.discard.switch_table_info instead of .discard.switch_table_information). > > Signed-off-by: Raphael Gault > [J.T.: Update arch implementation to new prototypes, > Update switch table information section name, > Do some clean up, > Use the offset sign information, > Use the newly added rela to find the corresponding jump instruction] > Signed-off-by: Julien Thierry > --- > tools/objtool/arch/arm64/arch_special.c | 251 +++++++++++++++++- > .../objtool/arch/arm64/include/arch_special.h | 2 + > tools/objtool/check.c | 4 +- > tools/objtool/check.h | 2 + > 4 files changed, 255 insertions(+), 4 deletions(-) > > diff --git a/tools/objtool/arch/arm64/arch_special.c b/tools/objtool/arch/arm64/arch_special.c > index 5239489c9c57..a15f6697dc74 100644 > --- a/tools/objtool/arch/arm64/arch_special.c > +++ b/tools/objtool/arch/arm64/arch_special.c > @@ -1,15 +1,262 @@ > // SPDX-License-Identifier: GPL-2.0-or-later > > +#include > +#include > + > #include "../../special.h" > +#include "../../warn.h" > +#include "arch_special.h" > +#include "bit_operations.h" > +#include "insn_decode.h" > + > +/* > + * The arm64_switch_table_detection_plugin generate an array of elements > + * described by the following structure. > + * Each jump table found in the compilation unit is associated with one of > + * entries of the array. > + */ > +struct switch_table_info { > + u64 switch_table_ref; // Relocation target referencing the beginning of the jump table > + u64 dyn_jump_ref; // Relocation target referencing the set of instructions setting up the jump to the table > + u64 nb_entries; > + u64 offset_unsigned; > +} __attribute__((__packed__)); > + > +static bool insn_is_adr_pcrel(struct instruction *insn) > +{ > + u32 opcode = *(u32 *)(insn->sec->data->d_buf + insn->offset); > + > + return ((opcode >> 24) & 0x1f) == 0x10; > +} > + > +static s64 next_offset(void *table, u8 entry_size, bool is_signed) > +{ > + if (!is_signed) { > + switch (entry_size) { > + case 1: > + return *(u8 *)(table); > + case 2: > + return *(u16 *)(table); > + default: > + return *(u32 *)(table); > + } > + } else { > + switch (entry_size) { > + case 1: > + return *(s8 *)(table); > + case 2: > + return *(s16 *)(table); > + default: > + return *(s32 *)(table); > + } > + } > +} > + > +static u32 get_table_entry_size(u32 insn) > +{ > + unsigned char size = (insn >> 30) & ONES(2); > + > + switch (size) { > + case 0: > + return 1; > + case 1: > + return 2; > + default: > + return 4; > + } > +} > + > +static int add_possible_branch(struct objtool_file *file, > + struct instruction *insn, > + u32 base, s64 offset) > +{ > + struct instruction *dest_insn; > + struct alternative *alt; > + > + offset = base + 4 * offset; > + > + dest_insn = find_insn(file, insn->sec, offset); > + if (!dest_insn) > + return 0; > + > + alt = calloc(1, sizeof(*alt)); > + if (!alt) { > + WARN("allocation failure, can't add jump alternative"); > + return -1; > + } > + > + alt->insn = dest_insn; > + alt->skip_orig = true; > + list_add_tail(&alt->list, &insn->alts); > + return 0; > +} > + > +static struct switch_table_info *get_swt_info(struct section *swt_info_sec, > + struct instruction *insn) > +{ > + u64 *table_ref; > + > + if (!insn->jump_table) { > + WARN("no jump table available for %s+0x%lx", > + insn->sec->name, insn->offset); > + return NULL; > + } > + table_ref = (void *)(swt_info_sec->data->d_buf + > + insn->jump_table->offset); > + return container_of(table_ref, struct switch_table_info, > + switch_table_ref); > +} > + > +static int add_arm64_jump_table_dests(struct objtool_file *file, > + struct instruction *insn) > +{ > + struct switch_table_info *swt_info; > + struct section *objtool_data; > + struct section *rodata_sec; > + struct section *branch_sec; > + struct instruction *pre_jump_insn; > + u8 *switch_table; > + u32 entry_size; > + > + objtool_data = find_section_by_name(file->elf, > + ".discard.switch_table_info"); > + if (!objtool_data) > + return 0; > + > + /* > + * 1. Identify entry for the switch table > + * 2. Retrieve branch instruction > + * 3. Retrieve base offset > + * 3. For all entries in switch table: > + * 3.1. Compute new offset > + * 3.2. Create alternative instruction > + * 3.3. Add alt_instr to insn->alts list > + */ > + swt_info = get_swt_info(objtool_data, insn); > + > + /* retrieving pre jump instruction (ldr) */ > + branch_sec = insn->sec; > + pre_jump_insn = find_insn(file, branch_sec, > + insn->offset - 3 * sizeof(u32)); > + entry_size = get_table_entry_size(*(u32 *)(branch_sec->data->d_buf + > + pre_jump_insn->offset)); > + > + /* retrieving switch table content */ > + rodata_sec = find_section_by_name(file->elf, ".rodata"); > + switch_table = (u8 *)(rodata_sec->data->d_buf + > + insn->jump_table->addend); > + > + /* > + * iterating over the pre-jumps instruction in order to > + * retrieve switch base offset. > + */ > + while (pre_jump_insn && pre_jump_insn->offset <= insn->offset) { > + if (insn_is_adr_pcrel(pre_jump_insn)) { > + u64 base_offset; > + int i; > + > + base_offset = pre_jump_insn->offset + > + pre_jump_insn->immediate; > + > + /* > + * Once we have the switch table entry size > + * we add every possible destination using > + * alternatives of the original branch > + * instruction > + */ > + for (i = 0; i < swt_info->nb_entries; i++) { > + s64 table_offset = next_offset(switch_table, > + entry_size, > + !swt_info->offset_unsigned); > + > + if (add_possible_branch(file, insn, > + base_offset, > + table_offset)) { > + return -1; > + } > + switch_table += entry_size; > + } > + break; > + } > + pre_jump_insn = next_insn_same_sec(file, pre_jump_insn); > + } > + > + return 0; > +} > > int arch_add_jump_table_dests(struct objtool_file *file, > struct instruction *insn) > { > - return 0; > + return add_arm64_jump_table_dests(file, insn); > } > > +static struct rela *find_swt_info_jump_rela(struct section *swt_info_sec, > + u32 index) > +{ > + u32 rela_offset; > + > + rela_offset = index * sizeof(struct switch_table_info) + > + offsetof(struct switch_table_info, dyn_jump_ref); > + return find_rela_by_dest(swt_info_sec, rela_offset); > +} > + > +static struct rela *find_swt_info_table_rela(struct section *swt_info_sec, > + u32 index) > +{ > + u32 rela_offset; > + > + rela_offset = index * sizeof(struct switch_table_info) + > + offsetof(struct switch_table_info, switch_table_ref); > + return find_rela_by_dest(swt_info_sec, rela_offset); > +} > + > +/* > + * Aarch64 jump tables are just arrays of offsets (of varying size/signess) > + * representing the potential destination from a base address loaded by an adr > + * instruction. > + * > + * Aarch64 branches to jump tables are composed of multiple instructions: > + * > + * ldr x_offset, [x_offsets_table, x_index, ...] > + * adr x_dest_base, > + * add x_dest, x_target_base, x_offset, ... > + * br x_dest > + * > + * The arm64_switch_table_detection_plugin will make the connection between > + * the instruction setting x_offsets_table (dyn_jump_ref) and the actual > + * table of offsets (switch_table_ref) > + */ > struct rela *arch_find_switch_table(struct objtool_file *file, > struct instruction *insn) > { > - return NULL; > + struct section *objtool_data; > + struct rela *res = NULL; > + u32 nb_swt_entries = 0; > + u32 i; > + > + objtool_data = find_section_by_name(file->elf, > + ".discard.switch_table_info"); > + if (objtool_data) > + nb_swt_entries = objtool_data->sh.sh_size / > + sizeof(struct switch_table_info); > + > + for (i = 0; i < nb_swt_entries; i++) { > + struct rela *info_rela; > + > + info_rela = find_swt_info_jump_rela(objtool_data, i); > + if (info_rela && info_rela->sym->sec == insn->sec && > + info_rela->addend == insn->offset) { > + if (res) { > + WARN_FUNC("duplicate objtool_data rela", > + info_rela->sec, info_rela->offset); > + continue; > + } > + res = find_swt_info_table_rela(objtool_data, i); > + if (!res) > + WARN_FUNC("missing relocation in objtool data", > + info_rela->sec, info_rela->offset); > + } > + } > + > + return res; > } > diff --git a/tools/objtool/arch/arm64/include/arch_special.h b/tools/objtool/arch/arm64/include/arch_special.h > index a82a9b3e51df..b96bcee308cf 100644 > --- a/tools/objtool/arch/arm64/include/arch_special.h > +++ b/tools/objtool/arch/arm64/include/arch_special.h > @@ -3,6 +3,8 @@ > #ifndef _ARM64_ARCH_SPECIAL_H > #define _ARM64_ARCH_SPECIAL_H > > +#include > + > #define EX_ENTRY_SIZE 8 > #define EX_ORIG_OFFSET 0 > #define EX_NEW_OFFSET 4 > diff --git a/tools/objtool/check.c b/tools/objtool/check.c > index e0c6bda261c8..80ea5bbd36ab 100644 > --- a/tools/objtool/check.c > +++ b/tools/objtool/check.c > @@ -33,8 +33,8 @@ struct instruction *find_insn(struct objtool_file *file, > return NULL; > } > > -static struct instruction *next_insn_same_sec(struct objtool_file *file, > - struct instruction *insn) > +struct instruction *next_insn_same_sec(struct objtool_file *file, > + struct instruction *insn) > { > struct instruction *next = list_next_entry(insn, list); > > diff --git a/tools/objtool/check.h b/tools/objtool/check.h > index 91adec42782c..15165d04d9cb 100644 > --- a/tools/objtool/check.h > +++ b/tools/objtool/check.h > @@ -66,6 +66,8 @@ int check(const char *objname, bool orc); > > struct instruction *find_insn(struct objtool_file *file, > struct section *sec, unsigned long offset); > +struct instruction *next_insn_same_sec(struct objtool_file *file, > + struct instruction *insn); > > #define for_each_insn(file, insn) \ > list_for_each_entry(insn, &file->insn_list, list) > Cheers, -- Raphaël Gault From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9F385C32771 for ; Wed, 15 Jan 2020 16:37:34 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 68C632187F for ; Wed, 15 Jan 2020 16:37:34 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="pZ+9HPnT" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 68C632187F Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender:Content-Type: Content-Transfer-Encoding:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:From: References:To:Subject:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=yVra/AS8z7hSGoVlHdCMzCypBDAP94mCEXWleoWa14Y=; b=pZ+9HPnTuCbslbr09qU1LIYM0 3YBvxfes+abBAWgwSBc7jLP1ThcKDsbpOcy700IhzCj5WMUQFmBBLTkblnEQyFOdk2tEddHyqVXz/ icYWmS9LBbaJ1qx35CdmAgS/h55XW4084SDqCIr+yy6nowk3aJU1VUJ8RMeCyfVVQcIiKwsKA/hTM Jeb1f2bvd5wHzg45C0jfdMKFJrrTNqvTgejHug8wSkJL+kAKTW8OMzTG4tbV+uo9k3B9njL6mXsBb DrfHK3pPWuqrOhsnJ5VwSczcGxQDSBDV+0K1nBxAqlE8pNadYORkdXgsSraBZY1SY70RHTKH7BONX 3J1nUnnGg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1irlfd-0000Yj-Vg; Wed, 15 Jan 2020 16:37:29 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1irlfX-0000XJ-KQ for linux-arm-kernel@lists.infradead.org; Wed, 15 Jan 2020 16:37:28 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 4D710328; Wed, 15 Jan 2020 08:37:21 -0800 (PST) Received: from [10.1.199.115] (e120195-lin.cambridge.arm.com [10.1.199.115]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 610E43F718; Wed, 15 Jan 2020 08:37:20 -0800 (PST) Subject: Re: [RFC v5 44/57] objtool: arm64: Implement functions to add switch tables alternatives To: Julien Thierry , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org References: <20200109160300.26150-1-jthierry@redhat.com> <20200109160300.26150-45-jthierry@redhat.com> From: Raphael Gault Message-ID: <370e38b3-3c0c-e552-16fa-36571dd8e66b@arm.com> Date: Wed, 15 Jan 2020 16:37:19 +0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.2.2 MIME-Version: 1.0 In-Reply-To: <20200109160300.26150-45-jthierry@redhat.com> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200115_083723_763046_6159B620 X-CRM114-Status: GOOD ( 28.08 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: peterz@infradead.org, catalin.marinas@arm.com, will@kernel.org, jpoimboe@redhat.com Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org SGkgSnVsaWVuLAoKT24gMS85LzIwIDQ6MDIgUE0sIEp1bGllbiBUaGllcnJ5IHdyb3RlOgo+IFRo aXMgcGF0Y2ggaW1wbGVtZW50cyB0aGUgZnVuY3Rpb25zIHJlcXVpcmVkIHRvIGlkZW50aWZ5IGFu ZCBhZGQgYXMKPiBhbHRlcm5hdGl2ZXMgYWxsIHRoZSBwb3NzaWJsZSBkZXN0aW5hdGlvbnMgb2Yg dGhlIHN3aXRjaCB0YWJsZS4KPiBUaGlzIGltcGxlbWVudGF0aW9uIHJlbGllcyBvbiB0aGUgbmV3 IHBsdWdpbiBpbnRyb2R1Y2VkIHByZXZpb3VzbHkgd2hpY2gKPiByZWNvcmRzIGluZm9ybWF0aW9u IGFib3V0IHRoZSBzd2l0Y2gtdGFibGUgaW4gYQo+IC5kaXNjYXJkLnN3aXRjaF90YWJsZV9pbmZv cm1hdGlvbiBzZWN0aW9uLgoKSSB0aGluayB5b3UgZm9yZ290IHRvIHVwZGF0ZSB0aGUgbmFtZSBv ZiB0aGUgc2VjdGlvbiB3aXRoIHJlc3BlY3QgdG8gCndoYXQgd2FzIGRvbmUgaW4gdGhlIHByZXZp b3VzIHBhdGNoICguZGlzY2FyZC5zd2l0Y2hfdGFibGVfaW5mbyBpbnN0ZWFkIApvZiAuZGlzY2Fy ZC5zd2l0Y2hfdGFibGVfaW5mb3JtYXRpb24pLgoKPiAKPiBTaWduZWQtb2ZmLWJ5OiBSYXBoYWVs IEdhdWx0IDxyYXBoYWVsLmdhdWx0QGFybS5jb20+Cj4gW0ouVC46IFVwZGF0ZSBhcmNoIGltcGxl bWVudGF0aW9uIHRvIG5ldyBwcm90b3R5cGVzLAo+ICAgICAgICAgVXBkYXRlIHN3aXRjaCB0YWJs ZSBpbmZvcm1hdGlvbiBzZWN0aW9uIG5hbWUsCj4gICAgICAgICBEbyBzb21lIGNsZWFuIHVwLAo+ ICAgICAgICAgVXNlIHRoZSBvZmZzZXQgc2lnbiBpbmZvcm1hdGlvbiwKPiAgICAgICAgIFVzZSB0 aGUgbmV3bHkgYWRkZWQgcmVsYSB0byBmaW5kIHRoZSBjb3JyZXNwb25kaW5nIGp1bXAgaW5zdHJ1 Y3Rpb25dCj4gU2lnbmVkLW9mZi1ieTogSnVsaWVuIFRoaWVycnkgPGp0aGllcnJ5QHJlZGhhdC5j b20+Cj4gLS0tCj4gICB0b29scy9vYmp0b29sL2FyY2gvYXJtNjQvYXJjaF9zcGVjaWFsLmMgICAg ICAgfCAyNTEgKysrKysrKysrKysrKysrKystCj4gICAuLi4vb2JqdG9vbC9hcmNoL2FybTY0L2lu Y2x1ZGUvYXJjaF9zcGVjaWFsLmggfCAgIDIgKwo+ICAgdG9vbHMvb2JqdG9vbC9jaGVjay5jICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICA0ICstCj4gICB0b29scy9vYmp0b29sL2NoZWNrLmgg ICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIgKwo+ICAgNCBmaWxlcyBjaGFuZ2VkLCAyNTUg aW5zZXJ0aW9ucygrKSwgNCBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvdG9vbHMvb2Jq dG9vbC9hcmNoL2FybTY0L2FyY2hfc3BlY2lhbC5jIGIvdG9vbHMvb2JqdG9vbC9hcmNoL2FybTY0 L2FyY2hfc3BlY2lhbC5jCj4gaW5kZXggNTIzOTQ4OWM5YzU3Li5hMTVmNjY5N2RjNzQgMTAwNjQ0 Cj4gLS0tIGEvdG9vbHMvb2JqdG9vbC9hcmNoL2FybTY0L2FyY2hfc3BlY2lhbC5jCj4gKysrIGIv dG9vbHMvb2JqdG9vbC9hcmNoL2FybTY0L2FyY2hfc3BlY2lhbC5jCj4gQEAgLTEsMTUgKzEsMjYy IEBACj4gICAvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vci1sYXRlcgo+ICAg Cj4gKyNpbmNsdWRlIDxzdGRsaWIuaD4KPiArI2luY2x1ZGUgPHN0cmluZy5oPgo+ICsKPiAgICNp bmNsdWRlICIuLi8uLi9zcGVjaWFsLmgiCj4gKyNpbmNsdWRlICIuLi8uLi93YXJuLmgiCj4gKyNp bmNsdWRlICJhcmNoX3NwZWNpYWwuaCIKPiArI2luY2x1ZGUgImJpdF9vcGVyYXRpb25zLmgiCj4g KyNpbmNsdWRlICJpbnNuX2RlY29kZS5oIgo+ICsKPiArLyoKPiArICogVGhlIGFybTY0X3N3aXRj aF90YWJsZV9kZXRlY3Rpb25fcGx1Z2luIGdlbmVyYXRlIGFuIGFycmF5IG9mIGVsZW1lbnRzCj4g KyAqIGRlc2NyaWJlZCBieSB0aGUgZm9sbG93aW5nIHN0cnVjdHVyZS4KPiArICogRWFjaCBqdW1w IHRhYmxlIGZvdW5kIGluIHRoZSBjb21waWxhdGlvbiB1bml0IGlzIGFzc29jaWF0ZWQgd2l0aCBv bmUgb2YKPiArICogZW50cmllcyBvZiB0aGUgYXJyYXkuCj4gKyAqLwo+ICtzdHJ1Y3Qgc3dpdGNo X3RhYmxlX2luZm8gewo+ICsJdTY0IHN3aXRjaF90YWJsZV9yZWY7IC8vIFJlbG9jYXRpb24gdGFy Z2V0IHJlZmVyZW5jaW5nIHRoZSBiZWdpbm5pbmcgb2YgdGhlIGp1bXAgdGFibGUKPiArCXU2NCBk eW5fanVtcF9yZWY7IC8vIFJlbG9jYXRpb24gdGFyZ2V0IHJlZmVyZW5jaW5nIHRoZSBzZXQgb2Yg aW5zdHJ1Y3Rpb25zIHNldHRpbmcgdXAgdGhlIGp1bXAgdG8gdGhlIHRhYmxlCj4gKwl1NjQgbmJf ZW50cmllczsKPiArCXU2NCBvZmZzZXRfdW5zaWduZWQ7Cj4gK30gX19hdHRyaWJ1dGVfXygoX19w YWNrZWRfXykpOwo+ICsKPiArc3RhdGljIGJvb2wgaW5zbl9pc19hZHJfcGNyZWwoc3RydWN0IGlu c3RydWN0aW9uICppbnNuKQo+ICt7Cj4gKwl1MzIgb3Bjb2RlID0gKih1MzIgKikoaW5zbi0+c2Vj LT5kYXRhLT5kX2J1ZiArIGluc24tPm9mZnNldCk7Cj4gKwo+ICsJcmV0dXJuICgob3Bjb2RlID4+ IDI0KSAmIDB4MWYpID09IDB4MTA7Cj4gK30KPiArCj4gK3N0YXRpYyBzNjQgbmV4dF9vZmZzZXQo dm9pZCAqdGFibGUsIHU4IGVudHJ5X3NpemUsIGJvb2wgaXNfc2lnbmVkKQo+ICt7Cj4gKwlpZiAo IWlzX3NpZ25lZCkgewo+ICsJCXN3aXRjaCAoZW50cnlfc2l6ZSkgewo+ICsJCWNhc2UgMToKPiAr CQkJcmV0dXJuICoodTggKikodGFibGUpOwo+ICsJCWNhc2UgMjoKPiArCQkJcmV0dXJuICoodTE2 ICopKHRhYmxlKTsKPiArCQlkZWZhdWx0Ogo+ICsJCQlyZXR1cm4gKih1MzIgKikodGFibGUpOwo+ ICsJCX0KPiArCX0gZWxzZSB7Cj4gKwkJc3dpdGNoIChlbnRyeV9zaXplKSB7Cj4gKwkJY2FzZSAx Ogo+ICsJCQlyZXR1cm4gKihzOCAqKSh0YWJsZSk7Cj4gKwkJY2FzZSAyOgo+ICsJCQlyZXR1cm4g KihzMTYgKikodGFibGUpOwo+ICsJCWRlZmF1bHQ6Cj4gKwkJCXJldHVybiAqKHMzMiAqKSh0YWJs ZSk7Cj4gKwkJfQo+ICsJfQo+ICt9Cj4gKwo+ICtzdGF0aWMgdTMyIGdldF90YWJsZV9lbnRyeV9z aXplKHUzMiBpbnNuKQo+ICt7Cj4gKwl1bnNpZ25lZCBjaGFyIHNpemUgPSAoaW5zbiA+PiAzMCkg JiBPTkVTKDIpOwo+ICsKPiArCXN3aXRjaCAoc2l6ZSkgewo+ICsJY2FzZSAwOgo+ICsJCXJldHVy biAxOwo+ICsJY2FzZSAxOgo+ICsJCXJldHVybiAyOwo+ICsJZGVmYXVsdDoKPiArCQlyZXR1cm4g NDsKPiArCX0KPiArfQo+ICsKPiArc3RhdGljIGludCBhZGRfcG9zc2libGVfYnJhbmNoKHN0cnVj dCBvYmp0b29sX2ZpbGUgKmZpbGUsCj4gKwkJCSAgICAgICBzdHJ1Y3QgaW5zdHJ1Y3Rpb24gKmlu c24sCj4gKwkJCSAgICAgICB1MzIgYmFzZSwgczY0IG9mZnNldCkKPiArewo+ICsJc3RydWN0IGlu c3RydWN0aW9uICpkZXN0X2luc247Cj4gKwlzdHJ1Y3QgYWx0ZXJuYXRpdmUgKmFsdDsKPiArCj4g KwlvZmZzZXQgPSBiYXNlICsgNCAqIG9mZnNldDsKPiArCj4gKwlkZXN0X2luc24gPSBmaW5kX2lu c24oZmlsZSwgaW5zbi0+c2VjLCBvZmZzZXQpOwo+ICsJaWYgKCFkZXN0X2luc24pCj4gKwkJcmV0 dXJuIDA7Cj4gKwo+ICsJYWx0ID0gY2FsbG9jKDEsIHNpemVvZigqYWx0KSk7Cj4gKwlpZiAoIWFs dCkgewo+ICsJCVdBUk4oImFsbG9jYXRpb24gZmFpbHVyZSwgY2FuJ3QgYWRkIGp1bXAgYWx0ZXJu YXRpdmUiKTsKPiArCQlyZXR1cm4gLTE7Cj4gKwl9Cj4gKwo+ICsJYWx0LT5pbnNuID0gZGVzdF9p bnNuOwo+ICsJYWx0LT5za2lwX29yaWcgPSB0cnVlOwo+ICsJbGlzdF9hZGRfdGFpbCgmYWx0LT5s aXN0LCAmaW5zbi0+YWx0cyk7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVj dCBzd2l0Y2hfdGFibGVfaW5mbyAqZ2V0X3N3dF9pbmZvKHN0cnVjdCBzZWN0aW9uICpzd3RfaW5m b19zZWMsCj4gKwkJCQkJICAgICAgc3RydWN0IGluc3RydWN0aW9uICppbnNuKQo+ICt7Cj4gKwl1 NjQgKnRhYmxlX3JlZjsKPiArCj4gKwlpZiAoIWluc24tPmp1bXBfdGFibGUpIHsKPiArCQlXQVJO KCJubyBqdW1wIHRhYmxlIGF2YWlsYWJsZSBmb3IgJXMrMHglbHgiLAo+ICsJCSAgICAgaW5zbi0+ c2VjLT5uYW1lLCBpbnNuLT5vZmZzZXQpOwo+ICsJCXJldHVybiBOVUxMOwo+ICsJfQo+ICsJdGFi bGVfcmVmID0gKHZvaWQgKikoc3d0X2luZm9fc2VjLT5kYXRhLT5kX2J1ZiArCj4gKwkJCSAgICAg aW5zbi0+anVtcF90YWJsZS0+b2Zmc2V0KTsKPiArCXJldHVybiBjb250YWluZXJfb2YodGFibGVf cmVmLCBzdHJ1Y3Qgc3dpdGNoX3RhYmxlX2luZm8sCj4gKwkJCSAgICBzd2l0Y2hfdGFibGVfcmVm KTsKPiArfQo+ICsKPiArc3RhdGljIGludCBhZGRfYXJtNjRfanVtcF90YWJsZV9kZXN0cyhzdHJ1 Y3Qgb2JqdG9vbF9maWxlICpmaWxlLAo+ICsJCQkJICAgICAgc3RydWN0IGluc3RydWN0aW9uICpp bnNuKQo+ICt7Cj4gKwlzdHJ1Y3Qgc3dpdGNoX3RhYmxlX2luZm8gKnN3dF9pbmZvOwo+ICsJc3Ry dWN0IHNlY3Rpb24gKm9ianRvb2xfZGF0YTsKPiArCXN0cnVjdCBzZWN0aW9uICpyb2RhdGFfc2Vj Owo+ICsJc3RydWN0IHNlY3Rpb24gKmJyYW5jaF9zZWM7Cj4gKwlzdHJ1Y3QgaW5zdHJ1Y3Rpb24g KnByZV9qdW1wX2luc247Cj4gKwl1OCAqc3dpdGNoX3RhYmxlOwo+ICsJdTMyIGVudHJ5X3NpemU7 Cj4gKwo+ICsJb2JqdG9vbF9kYXRhID0gZmluZF9zZWN0aW9uX2J5X25hbWUoZmlsZS0+ZWxmLAo+ ICsJCQkJCSAgICAiLmRpc2NhcmQuc3dpdGNoX3RhYmxlX2luZm8iKTsKPiArCWlmICghb2JqdG9v bF9kYXRhKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCS8qCj4gKwkgKiAxLiBJZGVudGlmeSBlbnRy eSBmb3IgdGhlIHN3aXRjaCB0YWJsZQo+ICsJICogMi4gUmV0cmlldmUgYnJhbmNoIGluc3RydWN0 aW9uCj4gKwkgKiAzLiBSZXRyaWV2ZSBiYXNlIG9mZnNldAo+ICsJICogMy4gRm9yIGFsbCBlbnRy aWVzIGluIHN3aXRjaCB0YWJsZToKPiArCSAqICAgICAzLjEuIENvbXB1dGUgbmV3IG9mZnNldAo+ ICsJICogICAgIDMuMi4gQ3JlYXRlIGFsdGVybmF0aXZlIGluc3RydWN0aW9uCj4gKwkgKiAgICAg My4zLiBBZGQgYWx0X2luc3RyIHRvIGluc24tPmFsdHMgbGlzdAo+ICsJICovCj4gKwlzd3RfaW5m byA9IGdldF9zd3RfaW5mbyhvYmp0b29sX2RhdGEsIGluc24pOwo+ICsKPiArCS8qIHJldHJpZXZp bmcgcHJlIGp1bXAgaW5zdHJ1Y3Rpb24gKGxkcikgKi8KPiArCWJyYW5jaF9zZWMgPSBpbnNuLT5z ZWM7Cj4gKwlwcmVfanVtcF9pbnNuID0gZmluZF9pbnNuKGZpbGUsIGJyYW5jaF9zZWMsCj4gKwkJ CQkgIGluc24tPm9mZnNldCAtIDMgKiBzaXplb2YodTMyKSk7Cj4gKwllbnRyeV9zaXplID0gZ2V0 X3RhYmxlX2VudHJ5X3NpemUoKih1MzIgKikoYnJhbmNoX3NlYy0+ZGF0YS0+ZF9idWYgKwo+ICsJ CQkJCQkgICBwcmVfanVtcF9pbnNuLT5vZmZzZXQpKTsKPiArCj4gKwkvKiByZXRyaWV2aW5nIHN3 aXRjaCB0YWJsZSBjb250ZW50ICovCj4gKwlyb2RhdGFfc2VjID0gZmluZF9zZWN0aW9uX2J5X25h bWUoZmlsZS0+ZWxmLCAiLnJvZGF0YSIpOwo+ICsJc3dpdGNoX3RhYmxlID0gKHU4ICopKHJvZGF0 YV9zZWMtPmRhdGEtPmRfYnVmICsKPiArCQkJICAgICAgaW5zbi0+anVtcF90YWJsZS0+YWRkZW5k KTsKPiArCj4gKwkvKgo+ICsJICogaXRlcmF0aW5nIG92ZXIgdGhlIHByZS1qdW1wcyBpbnN0cnVj dGlvbiBpbiBvcmRlciB0bwo+ICsJICogcmV0cmlldmUgc3dpdGNoIGJhc2Ugb2Zmc2V0Lgo+ICsJ ICovCj4gKwl3aGlsZSAocHJlX2p1bXBfaW5zbiAmJiBwcmVfanVtcF9pbnNuLT5vZmZzZXQgPD0g aW5zbi0+b2Zmc2V0KSB7Cj4gKwkJaWYgKGluc25faXNfYWRyX3BjcmVsKHByZV9qdW1wX2luc24p KSB7Cj4gKwkJCXU2NCBiYXNlX29mZnNldDsKPiArCQkJaW50IGk7Cj4gKwo+ICsJCQliYXNlX29m ZnNldCA9IHByZV9qdW1wX2luc24tPm9mZnNldCArCj4gKwkJCQkgICAgICBwcmVfanVtcF9pbnNu LT5pbW1lZGlhdGU7Cj4gKwo+ICsJCQkvKgo+ICsJCQkgKiBPbmNlIHdlIGhhdmUgdGhlIHN3aXRj aCB0YWJsZSBlbnRyeSBzaXplCj4gKwkJCSAqIHdlIGFkZCBldmVyeSBwb3NzaWJsZSBkZXN0aW5h dGlvbiB1c2luZwo+ICsJCQkgKiBhbHRlcm5hdGl2ZXMgb2YgdGhlIG9yaWdpbmFsIGJyYW5jaAo+ ICsJCQkgKiBpbnN0cnVjdGlvbgo+ICsJCQkgKi8KPiArCQkJZm9yIChpID0gMDsgaSA8IHN3dF9p bmZvLT5uYl9lbnRyaWVzOyBpKyspIHsKPiArCQkJCXM2NCB0YWJsZV9vZmZzZXQgPSBuZXh0X29m ZnNldChzd2l0Y2hfdGFibGUsCj4gKwkJCQkJCQkgICAgICAgZW50cnlfc2l6ZSwKPiArCQkJCQkJ CSAgICAgICAhc3d0X2luZm8tPm9mZnNldF91bnNpZ25lZCk7Cj4gKwo+ICsJCQkJaWYgKGFkZF9w b3NzaWJsZV9icmFuY2goZmlsZSwgaW5zbiwKPiArCQkJCQkJCWJhc2Vfb2Zmc2V0LAo+ICsJCQkJ CQkJdGFibGVfb2Zmc2V0KSkgewo+ICsJCQkJCXJldHVybiAtMTsKPiArCQkJCX0KPiArCQkJCXN3 aXRjaF90YWJsZSArPSBlbnRyeV9zaXplOwo+ICsJCQl9Cj4gKwkJCWJyZWFrOwo+ICsJCX0KPiAr CQlwcmVfanVtcF9pbnNuID0gbmV4dF9pbnNuX3NhbWVfc2VjKGZpbGUsIHByZV9qdW1wX2luc24p Owo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gICAKPiAgIGludCBhcmNoX2FkZF9qdW1w X3RhYmxlX2Rlc3RzKHN0cnVjdCBvYmp0b29sX2ZpbGUgKmZpbGUsCj4gICAJCQkgICAgICBzdHJ1 Y3QgaW5zdHJ1Y3Rpb24gKmluc24pCj4gICB7Cj4gLQlyZXR1cm4gMDsKPiArCXJldHVybiBhZGRf YXJtNjRfanVtcF90YWJsZV9kZXN0cyhmaWxlLCBpbnNuKTsKPiAgIH0KPiAgIAo+ICtzdGF0aWMg c3RydWN0IHJlbGEgKmZpbmRfc3d0X2luZm9fanVtcF9yZWxhKHN0cnVjdCBzZWN0aW9uICpzd3Rf aW5mb19zZWMsCj4gKwkJCQkJICAgIHUzMiBpbmRleCkKPiArewo+ICsJdTMyIHJlbGFfb2Zmc2V0 Owo+ICsKPiArCXJlbGFfb2Zmc2V0ID0gaW5kZXggKiBzaXplb2Yoc3RydWN0IHN3aXRjaF90YWJs ZV9pbmZvKSArCj4gKwkJICAgICAgb2Zmc2V0b2Yoc3RydWN0IHN3aXRjaF90YWJsZV9pbmZvLCBk eW5fanVtcF9yZWYpOwo+ICsJcmV0dXJuIGZpbmRfcmVsYV9ieV9kZXN0KHN3dF9pbmZvX3NlYywg cmVsYV9vZmZzZXQpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHJlbGEgKmZpbmRfc3d0X2lu Zm9fdGFibGVfcmVsYShzdHJ1Y3Qgc2VjdGlvbiAqc3d0X2luZm9fc2VjLAo+ICsJCQkJCSAgICAg dTMyIGluZGV4KQo+ICt7Cj4gKwl1MzIgcmVsYV9vZmZzZXQ7Cj4gKwo+ICsJcmVsYV9vZmZzZXQg PSBpbmRleCAqIHNpemVvZihzdHJ1Y3Qgc3dpdGNoX3RhYmxlX2luZm8pICsKPiArCQkgICAgICBv ZmZzZXRvZihzdHJ1Y3Qgc3dpdGNoX3RhYmxlX2luZm8sIHN3aXRjaF90YWJsZV9yZWYpOwo+ICsJ cmV0dXJuIGZpbmRfcmVsYV9ieV9kZXN0KHN3dF9pbmZvX3NlYywgcmVsYV9vZmZzZXQpOwo+ICt9 Cj4gKwo+ICsvKgo+ICsgKiBBYXJjaDY0IGp1bXAgdGFibGVzIGFyZSBqdXN0IGFycmF5cyBvZiBv ZmZzZXRzIChvZiB2YXJ5aW5nIHNpemUvc2lnbmVzcykKPiArICogcmVwcmVzZW50aW5nIHRoZSBw b3RlbnRpYWwgZGVzdGluYXRpb24gZnJvbSBhIGJhc2UgYWRkcmVzcyBsb2FkZWQgYnkgYW4gYWRy Cj4gKyAqIGluc3RydWN0aW9uLgo+ICsgKgo+ICsgKiBBYXJjaDY0IGJyYW5jaGVzIHRvIGp1bXAg dGFibGVzIGFyZSBjb21wb3NlZCBvZiBtdWx0aXBsZSBpbnN0cnVjdGlvbnM6Cj4gKyAqCj4gKyAq ICAgICBsZHI8Pz4gIHhfb2Zmc2V0LCBbeF9vZmZzZXRzX3RhYmxlLCB4X2luZGV4LCAuLi5dCj4g KyAqICAgICBhZHIgICAgIHhfZGVzdF9iYXNlLCA8YWRkcj4KPiArICogICAgIGFkZCAgICAgeF9k ZXN0LCB4X3RhcmdldF9iYXNlLCB4X29mZnNldCwgLi4uCj4gKyAqICAgICBiciAgICAgIHhfZGVz dAo+ICsgKgo+ICsgKiBUaGUgYXJtNjRfc3dpdGNoX3RhYmxlX2RldGVjdGlvbl9wbHVnaW4gd2ls bCBtYWtlIHRoZSBjb25uZWN0aW9uIGJldHdlZW4KPiArICogdGhlIGluc3RydWN0aW9uIHNldHRp bmcgeF9vZmZzZXRzX3RhYmxlIChkeW5fanVtcF9yZWYpIGFuZCB0aGUgYWN0dWFsCj4gKyAqIHRh YmxlIG9mIG9mZnNldHMgKHN3aXRjaF90YWJsZV9yZWYpCj4gKyAqLwo+ICAgc3RydWN0IHJlbGEg KmFyY2hfZmluZF9zd2l0Y2hfdGFibGUoc3RydWN0IG9ianRvb2xfZmlsZSAqZmlsZSwKPiAgIAkJ CQkgICAgc3RydWN0IGluc3RydWN0aW9uICppbnNuKQo+ICAgewo+IC0JcmV0dXJuIE5VTEw7Cj4g KwlzdHJ1Y3Qgc2VjdGlvbiAqb2JqdG9vbF9kYXRhOwo+ICsJc3RydWN0IHJlbGEgKnJlcyA9IE5V TEw7Cj4gKwl1MzIgbmJfc3d0X2VudHJpZXMgPSAwOwo+ICsJdTMyIGk7Cj4gKwo+ICsJb2JqdG9v bF9kYXRhID0gZmluZF9zZWN0aW9uX2J5X25hbWUoZmlsZS0+ZWxmLAo+ICsJCQkJCSAgICAiLmRp c2NhcmQuc3dpdGNoX3RhYmxlX2luZm8iKTsKPiArCWlmIChvYmp0b29sX2RhdGEpCj4gKwkJbmJf c3d0X2VudHJpZXMgPSBvYmp0b29sX2RhdGEtPnNoLnNoX3NpemUgLwo+ICsJCQkJIHNpemVvZihz dHJ1Y3Qgc3dpdGNoX3RhYmxlX2luZm8pOwo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBuYl9zd3Rf ZW50cmllczsgaSsrKSB7Cj4gKwkJc3RydWN0IHJlbGEgKmluZm9fcmVsYTsKPiArCj4gKwkJaW5m b19yZWxhID0gZmluZF9zd3RfaW5mb19qdW1wX3JlbGEob2JqdG9vbF9kYXRhLCBpKTsKPiArCQlp ZiAoaW5mb19yZWxhICYmIGluZm9fcmVsYS0+c3ltLT5zZWMgPT0gaW5zbi0+c2VjICYmCj4gKwkJ ICAgIGluZm9fcmVsYS0+YWRkZW5kID09IGluc24tPm9mZnNldCkgewo+ICsJCQlpZiAocmVzKSB7 Cj4gKwkJCQlXQVJOX0ZVTkMoImR1cGxpY2F0ZSBvYmp0b29sX2RhdGEgcmVsYSIsCj4gKwkJCQkJ ICBpbmZvX3JlbGEtPnNlYywgaW5mb19yZWxhLT5vZmZzZXQpOwo+ICsJCQkJY29udGludWU7Cj4g KwkJCX0KPiArCQkJcmVzID0gZmluZF9zd3RfaW5mb190YWJsZV9yZWxhKG9ianRvb2xfZGF0YSwg aSk7Cj4gKwkJCWlmICghcmVzKQo+ICsJCQkJV0FSTl9GVU5DKCJtaXNzaW5nIHJlbG9jYXRpb24g aW4gb2JqdG9vbCBkYXRhIiwKPiArCQkJCQkgIGluZm9fcmVsYS0+c2VjLCBpbmZvX3JlbGEtPm9m ZnNldCk7Cj4gKwkJfQo+ICsJfQo+ICsKPiArCXJldHVybiByZXM7Cj4gICB9Cj4gZGlmZiAtLWdp dCBhL3Rvb2xzL29ianRvb2wvYXJjaC9hcm02NC9pbmNsdWRlL2FyY2hfc3BlY2lhbC5oIGIvdG9v bHMvb2JqdG9vbC9hcmNoL2FybTY0L2luY2x1ZGUvYXJjaF9zcGVjaWFsLmgKPiBpbmRleCBhODJh OWIzZTUxZGYuLmI5NmJjZWUzMDhjZiAxMDA2NDQKPiAtLS0gYS90b29scy9vYmp0b29sL2FyY2gv YXJtNjQvaW5jbHVkZS9hcmNoX3NwZWNpYWwuaAo+ICsrKyBiL3Rvb2xzL29ianRvb2wvYXJjaC9h cm02NC9pbmNsdWRlL2FyY2hfc3BlY2lhbC5oCj4gQEAgLTMsNiArMyw4IEBACj4gICAjaWZuZGVm IF9BUk02NF9BUkNIX1NQRUNJQUxfSAo+ICAgI2RlZmluZSBfQVJNNjRfQVJDSF9TUEVDSUFMX0gK PiAgIAo+ICsjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KPiArCj4gICAjZGVmaW5lIEVYX0VOVFJZ X1NJWkUJCTgKPiAgICNkZWZpbmUgRVhfT1JJR19PRkZTRVQJCTAKPiAgICNkZWZpbmUgRVhfTkVX X09GRlNFVAkJNAo+IGRpZmYgLS1naXQgYS90b29scy9vYmp0b29sL2NoZWNrLmMgYi90b29scy9v Ymp0b29sL2NoZWNrLmMKPiBpbmRleCBlMGM2YmRhMjYxYzguLjgwZWE1YmJkMzZhYiAxMDA2NDQK PiAtLS0gYS90b29scy9vYmp0b29sL2NoZWNrLmMKPiArKysgYi90b29scy9vYmp0b29sL2NoZWNr LmMKPiBAQCAtMzMsOCArMzMsOCBAQCBzdHJ1Y3QgaW5zdHJ1Y3Rpb24gKmZpbmRfaW5zbihzdHJ1 Y3Qgb2JqdG9vbF9maWxlICpmaWxlLAo+ICAgCXJldHVybiBOVUxMOwo+ICAgfQo+ICAgCj4gLXN0 YXRpYyBzdHJ1Y3QgaW5zdHJ1Y3Rpb24gKm5leHRfaW5zbl9zYW1lX3NlYyhzdHJ1Y3Qgb2JqdG9v bF9maWxlICpmaWxlLAo+IC0JCQkJCSAgICAgIHN0cnVjdCBpbnN0cnVjdGlvbiAqaW5zbikKPiAr c3RydWN0IGluc3RydWN0aW9uICpuZXh0X2luc25fc2FtZV9zZWMoc3RydWN0IG9ianRvb2xfZmls ZSAqZmlsZSwKPiArCQkJCSAgICAgICBzdHJ1Y3QgaW5zdHJ1Y3Rpb24gKmluc24pCj4gICB7Cj4g ICAJc3RydWN0IGluc3RydWN0aW9uICpuZXh0ID0gbGlzdF9uZXh0X2VudHJ5KGluc24sIGxpc3Qp Owo+ICAgCj4gZGlmZiAtLWdpdCBhL3Rvb2xzL29ianRvb2wvY2hlY2suaCBiL3Rvb2xzL29ianRv b2wvY2hlY2suaAo+IGluZGV4IDkxYWRlYzQyNzgyYy4uMTUxNjVkMDRkOWNiIDEwMDY0NAo+IC0t LSBhL3Rvb2xzL29ianRvb2wvY2hlY2suaAo+ICsrKyBiL3Rvb2xzL29ianRvb2wvY2hlY2suaAo+ IEBAIC02Niw2ICs2Niw4IEBAIGludCBjaGVjayhjb25zdCBjaGFyICpvYmpuYW1lLCBib29sIG9y Yyk7Cj4gICAKPiAgIHN0cnVjdCBpbnN0cnVjdGlvbiAqZmluZF9pbnNuKHN0cnVjdCBvYmp0b29s X2ZpbGUgKmZpbGUsCj4gICAJCQkgICAgICBzdHJ1Y3Qgc2VjdGlvbiAqc2VjLCB1bnNpZ25lZCBs b25nIG9mZnNldCk7Cj4gK3N0cnVjdCBpbnN0cnVjdGlvbiAqbmV4dF9pbnNuX3NhbWVfc2VjKHN0 cnVjdCBvYmp0b29sX2ZpbGUgKmZpbGUsCj4gKwkJCQkgICAgICAgc3RydWN0IGluc3RydWN0aW9u ICppbnNuKTsKPiAgIAo+ICAgI2RlZmluZSBmb3JfZWFjaF9pbnNuKGZpbGUsIGluc24pCQkJCQlc Cj4gICAJbGlzdF9mb3JfZWFjaF9lbnRyeShpbnNuLCAmZmlsZS0+aW5zbl9saXN0LCBsaXN0KQo+ IAoKQ2hlZXJzLAoKLS0gClJhcGhhw6tsIEdhdWx0CgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51 eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5v cmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==