From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 60765 invoked by alias); 6 Sep 2019 14:46:57 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 60572 invoked by uid 89); 6 Sep 2019 14:46:55 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-23.7 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_LOTSOFHASH,RCVD_IN_DNSWL_NONE,SPF_HELO_PASS,SPF_PASS autolearn=ham version=3.3.1 spammy=Hook X-HELO: FRA01-MR2-obe.outbound.protection.outlook.com Received: from mail-eopbgr90051.outbound.protection.outlook.com (HELO FRA01-MR2-obe.outbound.protection.outlook.com) (40.107.9.51) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 06 Sep 2019 14:46:42 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=EFu5LKScaXvGIAy9Xkqla1D9Vyt9wN6KTHFlPCnuCgI=; b=lu9iJsBY7k1IYEPkFv/Y1Le7tdnxNQuhBxx8Q8C6CjHz1Lw/8fQa1jnJ3h6KxUi/k5v16hCfLkdbXWfCwTbBR7KXEDWFX6fcRv+/0wcI1LpSbRcrQsmK8N9Rjhyvp+Sjpfh2AVj8zkSc6FgqQqfERBup0xwWMt4JjYcEQ+7/AYI= Received: from DB6PR0802CA0046.eurprd08.prod.outlook.com (2603:10a6:4:a3::32) by PR2PR08MB4844.eurprd08.prod.outlook.com (2603:10a6:101:1d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2220.21; Fri, 6 Sep 2019 14:46:36 +0000 Received: from VE1EUR03FT028.eop-EUR03.prod.protection.outlook.com (2a01:111:f400:7e09::207) by DB6PR0802CA0046.outlook.office365.com (2603:10a6:4:a3::32) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2241.13 via Frontend Transport; Fri, 6 Sep 2019 14:46:36 +0000 Authentication-Results: spf=temperror (sender IP is 63.35.35.123) smtp.mailfrom=arm.com; gcc.gnu.org; dkim=pass (signature was verified) header.d=armh.onmicrosoft.com;gcc.gnu.org; dmarc=temperror action=none header.from=arm.com; Received-SPF: TempError (protection.outlook.com: error in processing during lookup of arm.com: DNS Timeout) Received: from 64aa7808-outbound-1.mta.getcheckrecipient.com (63.35.35.123) by VE1EUR03FT028.mail.protection.outlook.com (10.152.18.88) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2241.14 via Frontend Transport; Fri, 6 Sep 2019 14:46:34 +0000 Received: ("Tessian outbound d33df262a6a7:v27"); Fri, 06 Sep 2019 14:46:32 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: b3039bce74a201ca X-CR-MTA-TID: 64aa7808 Received: from 01f2e9e6bcf4.1 (cr-mta-lb-1.cr-mta-net [104.47.2.55]) by 64aa7808-outbound-1.mta.getcheckrecipient.com id 70BCCFBB-6226-474F-B72D-C0552A9A3F8C.1; Fri, 06 Sep 2019 14:46:27 +0000 Received: from EUR01-DB5-obe.outbound.protection.outlook.com (mail-db5eur01lp2055.outbound.protection.outlook.com [104.47.2.55]) by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id 01f2e9e6bcf4.1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384); Fri, 06 Sep 2019 14:46:27 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=mJ6by0o4Cgm8Cv7CGA9pSXWzZWXRrrhN/tYSbrucymId1HzN42/AHIL7tpYLCEZ13OhQF24x4dHE6IvfJUm4V+pri2JfnenOyT0twKlXfeIs4Iv2fEk3dOd2SVARgIVbyELYwQLgpS1honkUHgin6CGoz80/fRcZc3eNWjJR0qL+bvHNVkLWAtui6s3b6ae8Itd3O9tPH3CWEvnU5Q4BxzOL2VFnYfp/rozwB2JDkoblncAN2GFXMZ8BtZksogn8qvICK5nN8w+/rseVg7/vhFmm85yVueB3lg5Cd1C1YAiSLoqkk6X2zpdkTpBxn2TUE2eWiXTpSSnsHpnpCYNblw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=EFu5LKScaXvGIAy9Xkqla1D9Vyt9wN6KTHFlPCnuCgI=; b=kJYBq3kbcCqfgf4nxHNVAAT8zHQFMB274g56LKcWVO+V7X0Rt6ZgVkEztaNlDCqEsnhNXrW4s3FcbYiJUcBroK9KQmZxW1qjd45JZW8FM4hnV4D7F8tDgVFxH23WQTSCuKtFEzNrNWn9pKaRPyyDj8Hb1ewJtswLoiaJ4BvjF+lCyqnMp2AG3iHtQ3/nbIcIUFQE66VimnYMc19EXaUXVts0dOxNmOu7FAabrOaZesu39lWE0A8EkLNf9gr41UnjndE53gfrRmk6T51Z6WMgOsIWcBWDOUGeLTYLFesH6crsrXpVHgFJ2sq5E5bO4FCnWZIUCdY68/FBdAcw6IdNEQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=arm.com; dmarc=pass action=none header.from=arm.com; dkim=pass header.d=arm.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=armh.onmicrosoft.com; s=selector2-armh-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=EFu5LKScaXvGIAy9Xkqla1D9Vyt9wN6KTHFlPCnuCgI=; b=lu9iJsBY7k1IYEPkFv/Y1Le7tdnxNQuhBxx8Q8C6CjHz1Lw/8fQa1jnJ3h6KxUi/k5v16hCfLkdbXWfCwTbBR7KXEDWFX6fcRv+/0wcI1LpSbRcrQsmK8N9Rjhyvp+Sjpfh2AVj8zkSc6FgqQqfERBup0xwWMt4JjYcEQ+7/AYI= Received: from VI1PR08MB5471.eurprd08.prod.outlook.com (52.133.246.83) by VI1PR08MB3488.eurprd08.prod.outlook.com (20.177.59.30) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2241.14; Fri, 6 Sep 2019 14:46:24 +0000 Received: from VI1PR08MB5471.eurprd08.prod.outlook.com ([fe80::206a:65bd:e6a9:536b]) by VI1PR08MB5471.eurprd08.prod.outlook.com ([fe80::206a:65bd:e6a9:536b%2]) with mapi id 15.20.2241.018; Fri, 6 Sep 2019 14:46:24 +0000 From: Matthew Malcomson To: "gcc-patches@gcc.gnu.org" CC: "mliska@suse.cz" , "dodji@redhat.com" , nd , "kcc@google.com" , "jakub@redhat.com" , "dvyukov@google.com" Subject: [RFC][PATCH 15/X][libsanitizer] Add in MTE stubs Date: Fri, 06 Sep 2019 14:47:00 -0000 Message-ID: References: <156778058239.16148.17480879484406897649.scripted-patch-series@arm.com> In-Reply-To: <156778058239.16148.17480879484406897649.scripted-patch-series@arm.com> Authentication-Results-Original: spf=none (sender IP is ) smtp.mailfrom=Matthew.Malcomson@arm.com; X-Microsoft-Antispam-Untrusted: BCL:0;PCL:0;RULEID:(2390118)(7020095)(4652040)(8989299)(4534185)(4627221)(201703031133081)(201702281549075)(8990200)(5600166)(711020)(4605104)(1401327)(4618075)(2017052603328)(49563074)(7193020);SRVR:VI1PR08MB3488; x-checkrecipientrouted: true x-ms-oob-tlc-oobclassifiers: OLM:9508;OLM:9508; X-Forefront-Antispam-Report-Untrusted: SFV:NSPM;SFS:(10009020)(4636009)(39860400002)(396003)(346002)(376002)(136003)(366004)(54534003)(189003)(199004)(3846002)(6436002)(54906003)(53936002)(52536014)(6916009)(6116002)(5660300002)(71200400001)(8936002)(71190400001)(14454004)(14444005)(81166006)(2351001)(81156014)(256004)(446003)(8676002)(30864003)(5640700003)(52116002)(5024004)(53946003)(66446008)(44832011)(25786009)(9686003)(2501003)(86362001)(186003)(305945005)(486006)(476003)(6506007)(102836004)(11346002)(26005)(7696005)(74316002)(99286004)(7736002)(386003)(33656002)(316002)(55016002)(2906002)(66556008)(99936001)(478600001)(4326008)(76176011)(66946007)(64756008)(66616009)(66476007)(66066001)(569006);DIR:OUT;SFP:1101;SCL:1;SRVR:VI1PR08MB3488;H:VI1PR08MB5471.eurprd08.prod.outlook.com;FPR:;SPF:None;LANG:en;PTR:InfoNoRecords;MX:1;A:1; received-spf: None (protection.outlook.com: arm.com does not designate permitted sender hosts) X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam-Message-Info-Original: 97oy36xI3XhNhMcj8Fifm2eTAI/tiEy8aQwoEEmWmu/6+r8OgtW+zk/39Fd9CMc6UUpTI9j7lMZyHRDUK7VU5Cfdx0PkVvpguzIu/E7HKUyK4rIdmJKSTCvlun0S3yKt13A2uGy2OPqBBopOKkY7st+oeJtIqEdm6avOLMYt/VgUsRRPeyEbAuISI383ch8Tv7ifVUB8HWku320kwqEqo2qhnkwZT04VdZMCI92kLoml9EONa50JUgT+0yXy+YB7yX+1rcIb9oNehjqEqlSdUaTeEoscJUF+zZhX5j63VEyOZlJkVU2e79rb6K/v9VQqh7zKvPRAzO+j13lZOBhwWfetX7F9CtDkciCQ6grvX5WK1bpjWut5/HoitgF4UiB6XewryF3JvHXggKRqg80c5Ej7i/v5uAIs9OuzH85D0J0= x-ms-exchange-transport-forked: True Content-Type: multipart/mixed; boundary="_002_VI1PR08MB5471CA3016166350102AE8D4E0BA0VI1PR08MB5471eurp_" MIME-Version: 1.0 Original-Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Matthew.Malcomson@arm.com; Return-Path: Matthew.Malcomson@arm.com X-MS-Exchange-Transport-CrossTenantHeadersStripped: VE1EUR03FT028.eop-EUR03.prod.protection.outlook.com X-MS-Office365-Filtering-Correlation-Id-Prvs: b17ceda6-ea0f-43f5-06b1-08d732d8fd95 X-IsSubscribed: yes X-SW-Source: 2019-09/txt/msg00398.txt.bz2 --_002_VI1PR08MB5471CA3016166350102AE8D4E0BA0VI1PR08MB5471eurp_ Content-Type: text/plain; charset="us-ascii" Content-ID: Content-Transfer-Encoding: quoted-printable Content-length: 31005 This patch in the series is just for demonstration, here we add stubs where MTE would be implemented. At the moment all implementations are dummies of some sort, the assembly generated uses `mov` instead of `irg`, `add` instead of `addg`, and `sub` instead of `subg`. This should mean the binaries do all the same actions except ignoring tags. For a hardware implementation of memory tagging checks are done automatically so adding HWASAN_CHECK is not needed. This means that the `hwasan` pass is no longer needed. Similarly, the `sanopt` pass is not run when compiling for hardware memory tagging since it provides no benefit without the HWASAN_CHECK functions. This patch also gives backends extra control over how a tag is stored in a pointer and how many real-memory bytes is represented by each byte in the shadow space. gcc/ChangeLog: 2019-09-06 Matthew Malcomson * asan.c (hwasan_increment_tag): Avoid special handling around background tag for hardwawre implementation. (hwasan_copy_tag): New. (hwasan_tag_init): Choose initialisation value based on hardware/software tagging. (hwasan_emit_prologue): Account for hardware checking. (hwasan_emit_uncolour_frame): Account for hardware checking. (hwasan_finish_file): Assert not called for hardware checking. (hwasan_expand_check_ifn): Assert not called for hardware checking. (gate_hwasan): Don't run when have hardware checking. * asan.h (hwasan_copy_tag): New decl. (HWASAN_TAG_SIZE): Use backend hook if hardware checking. (HWASAN_TAG_GRANULE_SIZE): Use backend hook if hardware checking. * builtins.c (expand_builtin_alloca): Extra TODO comment. (expand_stack_restore): Extra TODO comment. * cfgexpand.c (expand_stack_vars): Only record untagged bases for hardware checking. * config/aarch64/aarch64.c (aarch64_tag_memory): Add dummy hook. (aarch64_gentag): Add dummy hook. (TARGET_MEMTAG_TAG): New. (TARGET_MEMTAG_GENTAG): New. * config/aarch64/aarch64.h (AARCH64_ISA_MEMTAG): New macro. (HARDWARE_MEMORY_TAGGING): Test for MTE. * config/aarch64/aarch64.md (random_tag, plain_offset_tag): New. (addtag4): Implement for MTE. * config/aarch64/predicates.md (aarch64_MTE_value_offset): New predicate. * defaults.h (HARDWARE_MEMORY_TAGGING): * doc/tm.texi: Document new hooks. * doc/tm.texi.in: Document new hooks. * internal-fn.c (expand_HWASAN_MARK): Account for hardware checking. * sanopt.c (sanitize_asan_mark_unpoison): * target.def (targetm.memtag.tag_size): New. (targetm.memtag.granule_size): New. (targetm.memtag.copy_tag): New. (targetm.memtag.tag): New. * targhooks.c (default_memtag_tag_size): New. (default_memtag_granule_size): New. (default_memtag_copy_tag): New. * targhooks.h (default_memtag_tag_size): New decl. (default_memtag_granule_size): New decl. (default_memtag_copy_tag): New decl. ############### Attachment also inlined for ease of reply ##########= ##### diff --git a/gcc/asan.h b/gcc/asan.h index 6e5ba8be606e9a1eae2afe57f17ccca5562167fd..2d697158a15e7e3078902c4fb74= 2819f90b9a0c4 100644 --- a/gcc/asan.h +++ b/gcc/asan.h @@ -27,10 +27,10 @@ extern void hwasan_finish_file (void); extern void hwasan_record_base (rtx); extern uint8_t hwasan_current_tag (); extern void hwasan_increment_tag (); +extern rtx hwasan_extract_tag (rtx); extern rtx hwasan_with_tag (rtx, poly_int64); extern void hwasan_tag_init (); extern rtx hwasan_create_untagged_base (rtx); -extern rtx hwasan_extract_tag (rtx tagged_pointer); extern rtx hwasan_base (); extern void hwasan_emit_prologue (rtx *, rtx *, poly_int64 *, uint8_t *, s= ize_t); extern rtx_insn *hwasan_emit_uncolour_frame (rtx, rtx, rtx_insn *); @@ -100,7 +100,7 @@ extern hash_set *asan_used_labels; required. If changing this value, be careful of the predicates/constraints on the addtag4 patterns in the backend. */ -#define HWASAN_TAG_SIZE 4 +#define HWASAN_TAG_SIZE (HARDWARE_MEMORY_TAGGING ? targetm.memtag.tag_size= () : 4) /* Tag Granule of HWASAN shadow stack. This is the size in real memory that each byte in the shadow memory ref= ers to. I.e. if a variable is X bytes long in memory then it's colour in s= hadow @@ -109,12 +109,12 @@ extern hash_set *asan_used_labels; two variables that are neighbours in memory and share a tag granule wou= ld need to share the same colour (as the shared tag granule can only store= one colour). */ -#define HWASAN_TAG_GRANULE_SIZE (1ULL << HWASAN_TAG_SIZE) -/* How many bits to shift in order to access the tag bits. - This approach assumes that the tag is stored in the top N bits of a poi= nter, - and hence that shifting a known amount will leave just the tag bits. */ -#define HWASAN_SHIFT 56 -#define HWASAN_SHIFT_RTX const_int_rtx[MAX_SAVED_CONST_INT + HWASAN_SHIFT] +#define HWASAN_TAG_GRANULE_SIZE (HARDWARE_MEMORY_TAGGING ? targetm.memtag.= granule_size () : (1ULL << HWASAN_TAG_SIZE)) + +/* + The following HWASAN_* macros are only used when HARDWARE_MEMORY_TAGGIN= G is + false, which is why we don't define anything for the case where it's tr= ue. + */ /* Define the tag for the stack background. NOTE: Having a background colour of zero is hard-coded in the runtime library, so we can't really change this. @@ -125,6 +125,11 @@ extern hash_set *asan_used_labels; ensure things like the return address etc can't be affected by accesses through pointer to a user-object. */ #define HWASAN_STACK_BACKGROUND 0 +/* How many bits to shift in order to access the tag bits. + This approach assumes that the tag is stored in the top N bits of a poi= nter, + and hence that shifting a known amount will leave just the tag bits. */ +#define HWASAN_SHIFT 56 +#define HWASAN_SHIFT_RTX const_int_rtx[MAX_SAVED_CONST_INT + HWASAN_SHIFT] =20 /* Various flags for Asan builtins. */ enum asan_check_flags diff --git a/gcc/asan.c b/gcc/asan.c index ad3d5a6451d3ecd9ff79b768c1e9a3fb92272a7e..5fc8e36865e5c442e7e68aa481c= 6899fde3ad16a 100644 --- a/gcc/asan.c +++ b/gcc/asan.c @@ -3914,7 +3914,7 @@ hwasan_increment_tag () =20 That's a help when debugging -- every variable should have a non-zero colour. */ - if (tag_offset =3D=3D HWASAN_STACK_BACKGROUND) + if (! HARDWARE_MEMORY_TAGGING && tag_offset =3D=3D HWASAN_STACK_BACKGROU= ND) tag_offset +=3D 1; } =20 @@ -3947,7 +3947,9 @@ hwasan_tag_init () asan_used_labels =3D NULL; =20 hwasan_base_ptr =3D NULL_RTX; - tag_offset =3D HWASAN_STACK_BACKGROUND + 1; + tag_offset =3D HARDWARE_MEMORY_TAGGING + ? 0 + : HWASAN_STACK_BACKGROUND + 1; } =20 void @@ -3958,7 +3960,8 @@ hwasan_emit_prologue (rtx *bases, size_t length) { /* - NOTE: bases contains both the tagged and untagged base. + NOTE: When running the software emulation we record both the tagged and + untagged bases. This allows us to get both the original frame tag and the untagged var= iable pointer with a minimal of extra instructions. =20 @@ -3969,8 +3972,8 @@ hwasan_emit_prologue (rtx *bases, pointers in __hwasan_tag_memory. We need the tagged base pointer to o= btain the base tag for an offset. =20 - We also will need the tagged base pointer for MTE, since the ADDTAG - instruction takes a tagged pointer. + We need the tagged base pointer for MTE, since the ADDTAG instruction = takes + a tagged pointer. */ for (size_t i =3D 0; (i * 2) + 1 < length; i++) { @@ -4002,19 +4005,29 @@ hwasan_emit_prologue (rtx *bases, gcc_assert (tmp % HWASAN_TAG_GRANULE_SIZE =3D=3D 0); =20 /* TODO Other options (i.e. inline options) */ - /* TODO At the moment we don't generate a random base tag for each - frame. When that happens we will need to generate the tag by - adding tags[i] to the frame tag fetched from `bases[i]`. */ - rtx ret =3D init_one_libfunc ("__hwasan_tag_memory"); - emit_library_call (ret, - LCT_NORMAL, - VOIDmode, - plus_constant (ptr_mode, untagged_bases[i], bot), - ptr_mode, - const_int_rtx[MAX_SAVED_CONST_INT + tags[i]], - QImode, - gen_int_mode (size, ptr_mode), - ptr_mode); + if (! HARDWARE_MEMORY_TAGGING ) + { + /* TODO At the moment we don't generate a random base tag for each + frame. When that happens we will need to generate the tag by + adding tags[i] to the frame tag fetched from `bases[i]`. */ + rtx ret =3D init_one_libfunc ("__hwasan_tag_memory"); + emit_library_call (ret, + LCT_NORMAL, + VOIDmode, + plus_constant (ptr_mode, untagged_bases[i], bot), + ptr_mode, + const_int_rtx[MAX_SAVED_CONST_INT + tags[i]], + QImode, + gen_int_mode (size, ptr_mode), + ptr_mode); + } + else + { + targetm.memtag.tag (bases[i], + bot, + tags[i], + gen_int_mode (size, ptr_mode)); + } } } =20 @@ -4046,11 +4059,19 @@ hwasan_emit_uncolour_frame (rtx dynamic, rtx vars, = rtx_insn *before) NULL_RTX, /* unsignedp =3D */0, OPTAB_DIRECT); =20 /* TODO Other options (i.e. inline options) */ - rtx ret =3D init_one_libfunc ("__hwasan_tag_memory"); - emit_library_call (ret, LCT_NORMAL, VOIDmode, - bot_rtx, ptr_mode, - const0_rtx, QImode, - size_rtx, ptr_mode); + if (! HARDWARE_MEMORY_TAGGING ) + { + rtx ret =3D init_one_libfunc ("__hwasan_tag_memory"); + emit_library_call (ret, LCT_NORMAL, VOIDmode, + bot_rtx, ptr_mode, + const0_rtx, QImode, + size_rtx, ptr_mode); + } + else + { + targetm.memtag.copy_tag (bot_rtx, stack_pointer_rtx); + targetm.memtag.tag (bot_rtx, 0, 0, size_rtx); + } =20 do_pending_stack_adjust (); rtx_insn *insns =3D get_insns (); @@ -4096,6 +4117,7 @@ static GTY(()) tree hwasan_ctor_statements; void hwasan_finish_file (void) { + gcc_assert (! HARDWARE_MEMORY_TAGGING); /* Avoid instrumenting code in the hwasan constructors/destructors. */ flag_sanitize &=3D ~SANITIZE_HWADDRESS; /* TODO Only do this if in userspace. @@ -4113,6 +4135,7 @@ hwasan_finish_file (void) bool hwasan_expand_check_ifn (gimple_stmt_iterator *iter, bool) { + gcc_assert (! HARDWARE_MEMORY_TAGGING); // TODO For now only implementing the function when using calls. // This is a little easier, and means I can rely on the library // implementation while checking my instrumentation code for now. @@ -4215,7 +4238,7 @@ hwasan_expand_mark_ifn (gimple_stmt_iterator *) bool gate_hwasan () { - return memory_tagging_p (); + return memory_tagging_p () && ! HARDWARE_MEMORY_TAGGING; } bool hardware_memory_tagging_p () diff --git a/gcc/builtins.c b/gcc/builtins.c index 3f32754c4d35fc34af7c53156d2a356f69a94a8f..544d07b67a74875fdd93b152b57= 20f58a10931a1 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -5312,6 +5312,17 @@ expand_builtin_frame_address (tree fndecl, tree exp) static rtx expand_builtin_alloca (tree exp) { + /* TODO For hardware memory tagging we will need to call the backend to = tag + this memory since the `hwasan` pass will not be run. + + The `hwasan` pass is mainly to add HWASAN_CHECK internal functions wh= ere + checks should be made. With hardware memory tagging the checks are d= one + automatically by the architecture. + + The `hwasan` pass also modifies the behaviour of the alloca builtin + function in a target-independent manner, but when memory tagging is + handled by the backend it is more convenient to handle the tagging in= the + alloca hook. */ rtx op0; rtx result; unsigned int align; @@ -6932,6 +6943,9 @@ expand_builtin_set_thread_pointer (tree exp) static void expand_stack_restore (tree var) { + /* TODO If memory tagging is enabled through the hardware we need to unc= olour + the stack from where we are to where we're going. (i.e. colour in the + background stack colour). */ rtx_insn *prev; rtx sa =3D expand_normal (var); =20 diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index 9f0872b32354cbc3186f3f2d2600f711a46926d1..061f00c2e1cf5d1b86fb3dd03d2= 7fd0bf905721a 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -1041,6 +1041,8 @@ struct stack_vars_data ASAN records HOST_WIDE_INT offsets (that was enough before the introduction of SVE vectors) which */ auto_vec hwasan_vec; + /* HWASAN needs to record untagged base pointers when there isn't hardwa= re + memory tagging enabled by the architecture. */ auto_vec hwasan_untagged_base_vec; auto_vec hwasan_base_vec; =20 @@ -1174,7 +1176,8 @@ expand_stack_vars (bool (*pred) (size_t), struct stac= k_vars_data *data) gcc_assert (stack_vars[i].alignb >=3D HWASAN_TAG_GRANULE_SIZE); offset =3D alloc_stack_frame_space (0, HWASAN_TAG_GRANULE_SIZE); data->hwasan_vec.safe_push (offset); - data->hwasan_untagged_base_vec.safe_push (virtual_stack_vars_rtx); + if (! HARDWARE_MEMORY_TAGGING) + data->hwasan_untagged_base_vec.safe_push (virtual_stack_vars_rtx); } /* ASAN description strings don't yet have a syntax for expressing polynomial offsets. */ @@ -1290,10 +1293,18 @@ expand_stack_vars (bool (*pred) (size_t), struct st= ack_vars_data *data) requirement means that the alignment requirement is greater than the required alignment for tags. */ - if (!large_untagged_base) - large_untagged_base =3D hwasan_create_untagged_base (large_base); data->hwasan_vec.safe_push (large_alloc); - data->hwasan_untagged_base_vec.safe_push (large_untagged_base); + + if (! HARDWARE_MEMORY_TAGGING ) + { + /* We only need to record the untagged bases for HWASAN, since + the runtime library for that doesn't accept tagged pointers. + For hardware implementations of memory tagging there is no + use of recording these untagged versions. */ + if (!large_untagged_base) + large_untagged_base =3D hwasan_create_untagged_base (large_base); + data->hwasan_untagged_base_vec.safe_push (large_untagged_base); + } } offset =3D large_alloc; large_alloc +=3D stack_vars[i].size; diff --git a/gcc/config/aarch64/aarch64.h b/gcc/config/aarch64/aarch64.h index 7bd3bf525dd71347a12ed9cd2227bc2cd6e9cc55..8ea219f25ecb13d26e5d84ee45e= 8ced61c3e72a9 100644 --- a/gcc/config/aarch64/aarch64.h +++ b/gcc/config/aarch64/aarch64.h @@ -235,6 +235,7 @@ extern unsigned aarch64_architecture_version; #define AARCH64_ISA_F16FML (aarch64_isa_flags & AARCH64_FL_F16FML) #define AARCH64_ISA_RCPC8_4 (aarch64_isa_flags & AARCH64_FL_RCPC8_4) #define AARCH64_ISA_V8_5 (aarch64_isa_flags & AARCH64_FL_V8_5) +#define AARCH64_ISA_MEMTAG (aarch64_isa_flags & AARCH64_FL_MEMTAG) =20 /* Crypto is an optional extension to AdvSIMD. */ #define TARGET_CRYPTO (TARGET_SIMD && AARCH64_ISA_CRYPTO) @@ -509,6 +510,10 @@ extern unsigned aarch64_architecture_version; #define EH_RETURN_STACKADJ_RTX gen_rtx_REG (Pmode, R4_REGNUM) #define EH_RETURN_HANDLER_RTX aarch64_eh_return_handler_rtx () =20 +/* We have memory tag checking if we have the MEMTAG extension enabled and + hence want to handle that and colouring memory ourselves. */ +#define HARDWARE_MEMORY_TAGGING AARCH64_ISA_MEMTAG + /* Don't use __builtin_setjmp until we've defined it. */ #undef DONT_USE_BUILTIN_SETJMP #define DONT_USE_BUILTIN_SETJMP 1 diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c index 8a290dcd9046be4775627dec0e9b3bf826ce3770..444021f81191a2eee3e50a4fcb4= ae6ccb33182ab 100644 --- a/gcc/config/aarch64/aarch64.c +++ b/gcc/config/aarch64/aarch64.c @@ -18772,6 +18772,22 @@ aarch64_stack_protect_guard (void) return NULL_TREE; } =20 +/* Implement TARGET_MEMTAG_TAG for AArch64. This is only available when + AARCH64_ISA_MEMTAG is available. TODO Eventually we would just want + something to emit a loop of STG or ST2G. Currently unimplemented. */ +void +aarch64_tag_memory (rtx tagged_start, poly_int64 address_offset, uint8_t t= ag_offset, + rtx size) +{ + return; +} + +void +aarch64_gentag (rtx a, rtx b) +{ + emit_insn (gen_random_tag (a, b)); +} + /* Implement TARGET_ASM_FILE_END for AArch64. This adds the AArch64 GNU N= OTE section at the end if needed. */ #define GNU_PROPERTY_AARCH64_FEATURE_1_AND 0xc0000000 @@ -19336,6 +19352,14 @@ aarch64_libgcc_floating_mode_supported_p #undef TARGET_GET_MULTILIB_ABI_NAME #define TARGET_GET_MULTILIB_ABI_NAME aarch64_get_multilib_abi_name =20 +#ifdef AARCH64_ISA_MEMTAG +#undef TARGET_MEMTAG_TAG +#define TARGET_MEMTAG_TAG aarch64_tag_memory + +#undef TARGET_MEMTAG_GENTAG +#define TARGET_MEMTAG_GENTAG aarch64_gentag +#endif + #if CHECKING_P #undef TARGET_RUN_TARGET_SELFTESTS #define TARGET_RUN_TARGET_SELFTESTS selftest::aarch64_run_selftests diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md index cb0d3ae6bbf3ed439c7b27683726f4c30b04777d..70a927b6b70e4e498d962c5e9cf= 1344f2661e377 100644 --- a/gcc/config/aarch64/aarch64.md +++ b/gcc/config/aarch64/aarch64.md @@ -231,6 +231,7 @@ (define_c_enum "unspec" [ UNSPEC_REV_SUBREG UNSPEC_SPECULATION_TRACKER UNSPEC_COPYSIGN + UNSPEC_GENTAG ]) =20 (define_c_enum "unspecv" [ @@ -409,6 +410,30 @@ (define_expand "cbranch4" " ) =20 +;; TODO +;; Need to put in some sort of random tag here. +;; At the moment skipping it because I don't know what instructions to = use. +;; (plus, starting at zero means that I can know what to expect during +;; development. +(define_insn "random_tag" + [(set (match_operand:DI 0 "register_operand" "=3Dr") + (unspec:DI [(match_operand:DI 1 "register_operand" "r")] UNSPEC_GENTAG))] + "" + ;; "AARCH64_ISA_MEMTAG" + "mov\\t%0, %1 // irg\\t%0, %1" +) + +(define_insn "plain_offset_tag" + [(set (match_operand:GPI 0 "register_operand" "=3Dr,r") + (addtag:GPI (match_operand:GPI 1 "register_operand" "r,r") + (match_operand:GPI 2 "aarch64_MTE_value_offset" "I,J") + (match_operand:GPI 3 "aarch64_MTE_tag_offset" "i,i")))] + "AARCH64_ISA_MEMTAG" + "@ + add\\t%0, %1, %2 // addg\\t%0, %1, %2, %3 + sub\\t%0, %1, #%n2 // subg\\t%0, %1, #%n2, %3" +) + (define_expand "addtag4" [(set (match_operand:GPI 0 "register_operand" "") (addtag:GPI (match_operand:GPI 1 "register_operand" "") @@ -417,13 +442,41 @@ (define_expand "addtag4" "" { gcc_assert (can_create_pseudo_p ()); - /* Simply add the two values as a constant and use that. The adddi patt= ern - will handle the fact that the integer is out of range for ADD. */ - poly_int64 val =3D rtx_to_poly_int64 (operands[2]); - val +=3D ((uint64_t)INTVAL(operands[3]) << 56); - emit_insn (gen_add3 (operands[0], operands[1], - immed_wide_int_const (val, mode))); - DONE; + + if (!AARCH64_ISA_MEMTAG) + { + /* TODO + Need to look into what the most efficient code sequence is. + Right now just want something to work so I can bootstrap again and + check for mistakes. + + This is a code sequence that would be emitted *many* times, so we + want it as small as possible. + */ + /* Simply add the two values as a constant and use that. The adddi + pattern will handle the fact that the integer is out of the + representable range. */ + poly_int64 val =3D rtx_to_poly_int64 (operands[2]); + val +=3D ((uint64_t)INTVAL(operands[3]) << 56); + emit_insn (gen_add3 (operands[0], operands[1], + immed_wide_int_const (val, mode))); + DONE; + } + else if (!aarch64_MTE_value_offset (operands[2], mode)) + { + /* Must always be able to create a pseudo register. + This pattern requires the ability to generate new pseudo registers, + since there's no way to handle a constant that's too large other than + adding that constant into the current register. + If we had a too-large constant at the point where we can't create= a + pseudo register, then using the basic `plus` pattern would end up= with + a `plus` pattern that has a too-large constant, which would fail = there + instead of here. */ + rtx newreg =3D gen_reg_rtx (mode); + emit_insn (gen_add3 (newreg, operands[1], operands[2])); + operands[2] =3D const0_rtx; + operands[1] =3D newreg; + } }) =20 (define_expand "cbranchcc4" diff --git a/gcc/config/aarch64/predicates.md b/gcc/config/aarch64/predicat= es.md index e2aa0290f833fbffedec1d8dab219f72eb17419e..0edfb6de7d1ddb466d114b7510e= 58499117061c5 100644 --- a/gcc/config/aarch64/predicates.md +++ b/gcc/config/aarch64/predicates.md @@ -141,6 +141,13 @@ (define_predicate "aarch64_MTE_tag_offset" (and (match_code "const_int") (match_test "IN_RANGE (INTVAL (op), 0, 16)"))) =20 +;; TODO +;; Will have to change the constant from 4096 to 64 when switching to a= ddg. +(define_predicate "aarch64_MTE_value_offset" + (and (match_code "const_int") + (match_test "IN_RANGE (INTVAL (op), -4096, 4096)"))) + + (define_predicate "aarch64_pluslong_strict_immedate" (and (match_operand 0 "aarch64_pluslong_immediate") (not (match_operand 0 "aarch64_plus_immediate")))) diff --git a/gcc/defaults.h b/gcc/defaults.h index b7534256119bd7834f2fa9d5f32863822d3b393a..b47fe6b35554091c9f3228169ad= 1f6ff4c692b14 100644 --- a/gcc/defaults.h +++ b/gcc/defaults.h @@ -1294,6 +1294,16 @@ see the files COPYING3 and COPYING.RUNTIME respectiv= ely. If not, see #define EH_RETURN_HANDLER_RTX NULL #endif =20 +/* Indicate whether this backend has automatic access checks for tagged + pointers (i.e. HWASAN) if so then HWASAN memory tagging can be implemen= ted + with much less instrumentation. + If a backend advertises that they have this it must also handle tagging + shadow memory themselves by implementing TARGET_MEMORY_TAG and avoiding= the + background stack colour automatically in the addtag pattern. */ +#ifndef HARDWARE_MEMORY_TAGGING +#define HARDWARE_MEMORY_TAGGING 0 +#endif + #ifdef GCC_INSN_FLAGS_H /* Dependent default target macro definitions =20 diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index 67d79a23799cd3057f7d91bd538c7ee76c836f82..7f0cc257a6634e3b0a2013b7fb9= ffa4083f19038 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -2968,6 +2968,30 @@ This hook defines the machine mode to use for the bo= olean result of conditional A target hook which lets a backend compute the set of pressure classes to = be used by those optimization passes which take register pressure into ac= count, as opposed to letting IRA compute them. It returns the number of r= egister classes stored in the array @var{pressure_classes}. @end deftypefn =20 +@deftypefn {Target Hook} uint8_t TARGET_MEMTAG_TAG_SIZE () +Return the size in bits of a tag for this platform. +@end deftypefn + +@deftypefn {Target Hook} uint8_t TARGET_MEMTAG_GRANULE_SIZE () +Return how many bytes in real memory each byte in shadow memory represents. +I.e. one byte in shadow memory being colour 1 implies the assocaiated +targetm.memtag.granule_size () bytes in real memory must all be accessed by +pointers tagged as 1. +@end deftypefn + +@deftypefn {Target Hook} void TARGET_MEMTAG_COPY_TAG (rtx @var{to}, rtx @v= ar{from}) +Emit insns to copy the tag in FROM to TO. +@end deftypefn + +@deftypefn {Target Hook} void TARGET_MEMTAG_TAG (rtx @var{tagged_start}, p= oly_int64 @var{address_offset}, uint8_t @var{tag_offset}, rtx @var{size}) +This function should emit an RTX to colour memory. +It's given arguments TAGGED_START, ADDRESS_OFFSET, TAG_OFFSET, SIZE, where +TAGGED_START and SIZE are RTL expressions, ADDRESS_OFFSET is a poly_int64 +and TAG_OFFSET is a uint8_t. +It should emit RTL to colour "shadow memory" for the relevant range the +colour of the tag it was given. +@end deftypefn + @deftypefn {Target Hook} void TARGET_MEMTAG_GENTAG (rtx @var{base}, rtx @v= ar{untagged}) Set the BASE argument to UNTAGGED with some random tag. This function is used to generate a tagged base for the current stack fram= e. diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index e1ec503befadb4061fbd3b95e55757fe22d33c39..6c77c09fca161dc3ade98d81b16= c1b01af3c0bc7 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -2370,6 +2370,14 @@ in the reload pass. =20 @hook TARGET_COMPUTE_PRESSURE_CLASSES =20 +@hook TARGET_MEMTAG_TAG_SIZE + +@hook TARGET_MEMTAG_GRANULE_SIZE + +@hook TARGET_MEMTAG_COPY_TAG + +@hook TARGET_MEMTAG_TAG + @hook TARGET_MEMTAG_GENTAG =20 @node Stack and Calling diff --git a/gcc/internal-fn.c b/gcc/internal-fn.c index c530fe8951c30987c874df83e74be6d058730134..a58a55ad59b2ad7a6b93e2f5f2b= bb40b8da51c5e 100644 --- a/gcc/internal-fn.c +++ b/gcc/internal-fn.c @@ -503,9 +503,6 @@ expand_HWASAN_MARK (internal_fn, gcall *gc) gcc_checking_assert (TREE_CODE (base) =3D=3D ADDR_EXPR); rtx base_rtx =3D expand_normal (base); =20 - rtx tag =3D is_poison ? const0_rtx : hwasan_extract_tag (base_rtx); - rtx address =3D hwasan_create_untagged_base (base_rtx); - tree len =3D gimple_call_arg (gc, 2); gcc_assert (tree_fits_shwi_p (len)); unsigned HOST_WIDE_INT size_in_bytes =3D tree_to_shwi (len); @@ -515,13 +512,24 @@ expand_HWASAN_MARK (internal_fn, gcall *gc) rtx size =3D gen_int_mode (size_in_bytes, Pmode); =20 /* TODO Other options (i.e. inline options) */ - rtx func =3D init_one_libfunc ("__hwasan_tag_memory"); - emit_library_call (func, - LCT_NORMAL, - VOIDmode, - address, ptr_mode, - tag, QImode, - size, ptr_mode); + if (! HARDWARE_MEMORY_TAGGING ) + { + rtx func =3D init_one_libfunc ("__hwasan_tag_memory"); + rtx address =3D hwasan_create_untagged_base (base_rtx); + rtx tag =3D is_poison ? const0_rtx : hwasan_extract_tag (base_rtx); + emit_library_call (func, + LCT_NORMAL, + VOIDmode, + address, ptr_mode, + tag, QImode, + size, ptr_mode); + } + else + { + if (is_poison) + targetm.memtag.copy_tag (base_rtx, stack_pointer_rtx); + targetm.memtag.tag (base_rtx, 0, 0, size); + } } =20 /* This should get expanded in the sanopt pass. */ diff --git a/gcc/target.def b/gcc/target.def index 5326cb070dec78f19bfe0844a9d5e50c69e7dcc1..e0c543254538c802e1e0a059e1a= 3e60a045a0cdf 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -6709,6 +6709,34 @@ HOOK_VECTOR_END (mode_switching) HOOK_VECTOR (TARGET_MEMTAG_, memtag) =20 DEFHOOK +(tag_size, + "Return the size in bits of a tag for this platform.", + uint8_t, (), default_memtag_tag_size) + +DEFHOOK +(granule_size, + "Return how many bytes in real memory each byte in shadow memory represen= ts.\n\ +I.e. one byte in shadow memory being colour 1 implies the assocaiated\n\ +targetm.memtag.granule_size () bytes in real memory must all be accessed b= y\n\ +pointers tagged as 1.", +uint8_t, (), default_memtag_granule_size) + +DEFHOOK +(copy_tag, + "Emit insns to copy the tag in FROM to TO.", +void, (rtx to, rtx from), default_memtag_copy_tag) + +DEFHOOK +(tag, + "This function should emit an RTX to colour memory.\n\ +It's given arguments TAGGED_START, ADDRESS_OFFSET, TAG_OFFSET, SIZE, where= \n\ +TAGGED_START and SIZE are RTL expressions, ADDRESS_OFFSET is a poly_int64\= n\ +and TAG_OFFSET is a uint8_t.\n\ +It should emit RTL to colour \"shadow memory\" for the relevant range the\= n\ +colour of the tag it was given.", + void, (rtx tagged_start, poly_int64 address_offset, uint8_t tag_offset, = rtx size), NULL) + +DEFHOOK (gentag, "Set the BASE argument to UNTAGGED with some random tag.\n\ This function is used to generate a tagged base for the current stack fram= e.", diff --git a/gcc/targhooks.h b/gcc/targhooks.h index 493ff3bb29263f8360bea0f7ead1092b4d0c646a..1c09bbad964b7705eea493a828d= 5906ad07481b6 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -288,5 +288,8 @@ extern rtx default_speculation_safe_value (machine_mode= , rtx, rtx, rtx); extern void default_remove_extra_call_preserved_regs (rtx_insn *, HARD_REG_SET *); =20 +extern uint8_t default_memtag_tag_size (); +extern uint8_t default_memtag_granule_size (); extern void default_memtag_gentag (rtx, rtx); +extern void default_memtag_copy_tag (rtx, rtx); #endif /* GCC_TARGHOOKS_H */ diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 58ec711ce81ee67d692e81d2616bd3422f6bd092..bf078295cbd9514778454cef775= dd288fd502641 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -70,6 +70,7 @@ along with GCC; see the file COPYING3. If not see #include "varasm.h" #include "flags.h" #include "explow.h" +#include "expmed.h" #include "calls.h" #include "expr.h" #include "output.h" @@ -83,6 +84,8 @@ along with GCC; see the file COPYING3. If not see #include "real.h" #include "langhooks.h" #include "sbitmap.h" +#include "attribs.h" +#include "asan.h" =20 bool default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED, @@ -2391,6 +2394,18 @@ default_remove_extra_call_preserved_regs (rtx_insn *= , HARD_REG_SET *) { } =20 +uint8_t +default_memtag_tag_size () +{ + return 4; +} + +uint8_t +default_memtag_granule_size () +{ + return 1ULL << default_memtag_tag_size (); +} + void default_memtag_gentag (rtx base, rtx untagged) { @@ -2402,5 +2417,40 @@ default_memtag_gentag (rtx base, rtx untagged) emit_move_insn (base, untagged); } =20 +void +default_memtag_copy_tag (rtx to, rtx from) +{ + /* TODO: For AArch64 this can cause a problem in LRA if the `to` + RTX eventually resolves to being the stack pointer. + This happens because the instruction that gets emitted from + `store_bit_field` corresponds to a pattern that can't handle the stack + pointer and LRA can't figure out to use a temporary register in the `= bfi` + instruction's place. + + This doesn't cause a problem at the moment since there's currently no= way + the stack pointer should be given to this function. The hook is only= used + when poisoning variables with HWASAN_MARK, and in that function the `= to` + RTX should always be pointing to a tagged variable on the stack (since + the variable is tagged it can't be the stack pointer since that is + untagged). + + Eventually we will be generating random tags as the "start" tag for e= ach + frame. When this happens we can no longer avoid the background colou= r at + compile time since we will not know what offset to avoid. + This will mean we no longer avoid a `tag_offset` of 0, and hence + `hwasan_with_tag` could emit simple PLUS statements. + + When that happens, the last variable on the stack could very well have + a zero tag offset and somewhere else in the compiler could optimise t= hat + to simply use the stack pointer. + + That would trigger an ICE due to LRA being unable to reload the + `insv_regdi` pattern. + + This is another thing that needs to be fixed but I'll deal with later= . */ + rtx temp =3D hwasan_extract_tag (from); + store_bit_field (to, 8, 56, 0, 0, + QImode, temp, false); +} =20 #include "gt-targhooks.h" --_002_VI1PR08MB5471CA3016166350102AE8D4E0BA0VI1PR08MB5471eurp_ Content-Type: text/plain; name="hwasan-implementation14.patch" Content-Description: hwasan-implementation14.patch Content-Disposition: attachment; filename="hwasan-implementation14.patch"; size=27735; creation-date="Fri, 06 Sep 2019 14:46:24 GMT"; modification-date="Fri, 06 Sep 2019 14:46:24 GMT" Content-ID: <6BC7BCC03094C443B39E87E111A5516D@eurprd08.prod.outlook.com> Content-Transfer-Encoding: base64 Content-length: 37597 ZGlmZiAtLWdpdCBhL2djYy9hc2FuLmggYi9nY2MvYXNhbi5oCmluZGV4IDZl NWJhOGJlNjA2ZTlhMWVhZTJhZmU1N2YxN2NjY2E1NTYyMTY3ZmQuLjJkNjk3 MTU4YTE1ZTdlMzA3ODkwMmM0ZmI3NDI4MTlmOTBiOWEwYzQgMTAwNjQ0Ci0t LSBhL2djYy9hc2FuLmgKKysrIGIvZ2NjL2FzYW4uaApAQCAtMjcsMTAgKzI3 LDEwIEBAIGV4dGVybiB2b2lkIGh3YXNhbl9maW5pc2hfZmlsZSAodm9pZCk7 CiBleHRlcm4gdm9pZCBod2FzYW5fcmVjb3JkX2Jhc2UgKHJ0eCk7CiBleHRl cm4gdWludDhfdCBod2FzYW5fY3VycmVudF90YWcgKCk7CiBleHRlcm4gdm9p ZCBod2FzYW5faW5jcmVtZW50X3RhZyAoKTsKK2V4dGVybiBydHggaHdhc2Fu X2V4dHJhY3RfdGFnIChydHgpOwogZXh0ZXJuIHJ0eCBod2FzYW5fd2l0aF90 YWcgKHJ0eCwgcG9seV9pbnQ2NCk7CiBleHRlcm4gdm9pZCBod2FzYW5fdGFn X2luaXQgKCk7CiBleHRlcm4gcnR4IGh3YXNhbl9jcmVhdGVfdW50YWdnZWRf YmFzZSAocnR4KTsKLWV4dGVybiBydHggaHdhc2FuX2V4dHJhY3RfdGFnIChy dHggdGFnZ2VkX3BvaW50ZXIpOwogZXh0ZXJuIHJ0eCBod2FzYW5fYmFzZSAo KTsKIGV4dGVybiB2b2lkIGh3YXNhbl9lbWl0X3Byb2xvZ3VlIChydHggKiwg cnR4ICosIHBvbHlfaW50NjQgKiwgdWludDhfdCAqLCBzaXplX3QpOwogZXh0 ZXJuIHJ0eF9pbnNuICpod2FzYW5fZW1pdF91bmNvbG91cl9mcmFtZSAocnR4 LCBydHgsIHJ0eF9pbnNuICopOwpAQCAtMTAwLDcgKzEwMCw3IEBAIGV4dGVy biBoYXNoX3NldCA8dHJlZT4gKmFzYW5fdXNlZF9sYWJlbHM7CiAgICByZXF1 aXJlZC4KICAgIElmIGNoYW5naW5nIHRoaXMgdmFsdWUsIGJlIGNhcmVmdWwg b2YgdGhlIHByZWRpY2F0ZXMvY29uc3RyYWludHMgb24gdGhlCiAgICBhZGR0 YWc8bW9kZT40IHBhdHRlcm5zIGluIHRoZSBiYWNrZW5kLiAgKi8KLSNkZWZp bmUgSFdBU0FOX1RBR19TSVpFIDQKKyNkZWZpbmUgSFdBU0FOX1RBR19TSVpF IChIQVJEV0FSRV9NRU1PUllfVEFHR0lORyA/IHRhcmdldG0ubWVtdGFnLnRh Z19zaXplICgpIDogNCkKIC8qIFRhZyBHcmFudWxlIG9mIEhXQVNBTiBzaGFk b3cgc3RhY2suCiAgICBUaGlzIGlzIHRoZSBzaXplIGluIHJlYWwgbWVtb3J5 IHRoYXQgZWFjaCBieXRlIGluIHRoZSBzaGFkb3cgbWVtb3J5IHJlZmVycwog ICAgdG8uICBJLmUuIGlmIGEgdmFyaWFibGUgaXMgWCBieXRlcyBsb25nIGlu IG1lbW9yeSB0aGVuIGl0J3MgY29sb3VyIGluIHNoYWRvdwpAQCAtMTA5LDEy ICsxMDksMTIgQEAgZXh0ZXJuIGhhc2hfc2V0IDx0cmVlPiAqYXNhbl91c2Vk X2xhYmVsczsKICAgIHR3byB2YXJpYWJsZXMgdGhhdCBhcmUgbmVpZ2hib3Vy cyBpbiBtZW1vcnkgYW5kIHNoYXJlIGEgdGFnIGdyYW51bGUgd291bGQKICAg IG5lZWQgdG8gc2hhcmUgdGhlIHNhbWUgY29sb3VyIChhcyB0aGUgc2hhcmVk IHRhZyBncmFudWxlIGNhbiBvbmx5IHN0b3JlIG9uZQogICAgY29sb3VyKS4g ICovCi0jZGVmaW5lIEhXQVNBTl9UQUdfR1JBTlVMRV9TSVpFICgxVUxMIDw8 IEhXQVNBTl9UQUdfU0laRSkKLS8qIEhvdyBtYW55IGJpdHMgdG8gc2hpZnQg aW4gb3JkZXIgdG8gYWNjZXNzIHRoZSB0YWcgYml0cy4KLSAgIFRoaXMgYXBw cm9hY2ggYXNzdW1lcyB0aGF0IHRoZSB0YWcgaXMgc3RvcmVkIGluIHRoZSB0 b3AgTiBiaXRzIG9mIGEgcG9pbnRlciwKLSAgIGFuZCBoZW5jZSB0aGF0IHNo aWZ0aW5nIGEga25vd24gYW1vdW50IHdpbGwgbGVhdmUganVzdCB0aGUgdGFn IGJpdHMuICAqLwotI2RlZmluZSBIV0FTQU5fU0hJRlQgNTYKLSNkZWZpbmUg SFdBU0FOX1NISUZUX1JUWCBjb25zdF9pbnRfcnR4W01BWF9TQVZFRF9DT05T VF9JTlQgKyBIV0FTQU5fU0hJRlRdCisjZGVmaW5lIEhXQVNBTl9UQUdfR1JB TlVMRV9TSVpFIChIQVJEV0FSRV9NRU1PUllfVEFHR0lORyA/IHRhcmdldG0u bWVtdGFnLmdyYW51bGVfc2l6ZSAoKSA6ICgxVUxMIDw8IEhXQVNBTl9UQUdf U0laRSkpCisKKy8qCisgICBUaGUgZm9sbG93aW5nIEhXQVNBTl8qIG1hY3Jv cyBhcmUgb25seSB1c2VkIHdoZW4gSEFSRFdBUkVfTUVNT1JZX1RBR0dJTkcg aXMKKyAgIGZhbHNlLCB3aGljaCBpcyB3aHkgd2UgZG9uJ3QgZGVmaW5lIGFu eXRoaW5nIGZvciB0aGUgY2FzZSB3aGVyZSBpdCdzIHRydWUuCisgKi8KIC8q IERlZmluZSB0aGUgdGFnIGZvciB0aGUgc3RhY2sgYmFja2dyb3VuZC4KICAg IE5PVEU6IEhhdmluZyBhIGJhY2tncm91bmQgY29sb3VyIG9mIHplcm8gaXMg aGFyZC1jb2RlZCBpbiB0aGUgcnVudGltZQogICAgbGlicmFyeSwgc28gd2Ug Y2FuJ3QgcmVhbGx5IGNoYW5nZSB0aGlzLgpAQCAtMTI1LDYgKzEyNSwxMSBA QCBleHRlcm4gaGFzaF9zZXQgPHRyZWU+ICphc2FuX3VzZWRfbGFiZWxzOwog ICAgZW5zdXJlIHRoaW5ncyBsaWtlIHRoZSByZXR1cm4gYWRkcmVzcyBldGMg Y2FuJ3QgYmUgYWZmZWN0ZWQgYnkgYWNjZXNzZXMKICAgIHRocm91Z2ggcG9p bnRlciB0byBhIHVzZXItb2JqZWN0LiAgKi8KICNkZWZpbmUgSFdBU0FOX1NU QUNLX0JBQ0tHUk9VTkQgMAorLyogSG93IG1hbnkgYml0cyB0byBzaGlmdCBp biBvcmRlciB0byBhY2Nlc3MgdGhlIHRhZyBiaXRzLgorICAgVGhpcyBhcHBy b2FjaCBhc3N1bWVzIHRoYXQgdGhlIHRhZyBpcyBzdG9yZWQgaW4gdGhlIHRv cCBOIGJpdHMgb2YgYSBwb2ludGVyLAorICAgYW5kIGhlbmNlIHRoYXQgc2hp ZnRpbmcgYSBrbm93biBhbW91bnQgd2lsbCBsZWF2ZSBqdXN0IHRoZSB0YWcg Yml0cy4gICovCisjZGVmaW5lIEhXQVNBTl9TSElGVCA1NgorI2RlZmluZSBI V0FTQU5fU0hJRlRfUlRYIGNvbnN0X2ludF9ydHhbTUFYX1NBVkVEX0NPTlNU X0lOVCArIEhXQVNBTl9TSElGVF0KIAogLyogVmFyaW91cyBmbGFncyBmb3Ig QXNhbiBidWlsdGlucy4gICovCiBlbnVtIGFzYW5fY2hlY2tfZmxhZ3MKZGlm ZiAtLWdpdCBhL2djYy9hc2FuLmMgYi9nY2MvYXNhbi5jCmluZGV4IGFkM2Q1 YTY0NTFkM2VjZDlmZjc5Yjc2OGMxZTlhM2ZiOTIyNzJhN2UuLjVmYzhlMzY4 NjVlNWM0NDJlN2U2OGFhNDgxYzY4OTlmZGUzYWQxNmEgMTAwNjQ0Ci0tLSBh L2djYy9hc2FuLmMKKysrIGIvZ2NjL2FzYW4uYwpAQCAtMzkxNCw3ICszOTE0 LDcgQEAgaHdhc2FuX2luY3JlbWVudF90YWcgKCkKIAogICAgICBUaGF0J3Mg YSBoZWxwIHdoZW4gZGVidWdnaW5nIC0tIGV2ZXJ5IHZhcmlhYmxlIHNob3Vs ZCBoYXZlIGEgbm9uLXplcm8KICAgICAgY29sb3VyLiAgKi8KLSAgaWYgKHRh Z19vZmZzZXQgPT0gSFdBU0FOX1NUQUNLX0JBQ0tHUk9VTkQpCisgIGlmICgh IEhBUkRXQVJFX01FTU9SWV9UQUdHSU5HICYmIHRhZ19vZmZzZXQgPT0gSFdB U0FOX1NUQUNLX0JBQ0tHUk9VTkQpCiAgICAgdGFnX29mZnNldCArPSAxOwog fQogCkBAIC0zOTQ3LDcgKzM5NDcsOSBAQCBod2FzYW5fdGFnX2luaXQgKCkK ICAgYXNhbl91c2VkX2xhYmVscyA9IE5VTEw7CiAKICAgaHdhc2FuX2Jhc2Vf cHRyID0gTlVMTF9SVFg7Ci0gIHRhZ19vZmZzZXQgPSBIV0FTQU5fU1RBQ0tf QkFDS0dST1VORCArIDE7CisgIHRhZ19vZmZzZXQgPSBIQVJEV0FSRV9NRU1P UllfVEFHR0lORworICAgID8gMAorICAgIDogSFdBU0FOX1NUQUNLX0JBQ0tH Uk9VTkQgKyAxOwogfQogCiB2b2lkCkBAIC0zOTU4LDcgKzM5NjAsOCBAQCBo d2FzYW5fZW1pdF9wcm9sb2d1ZSAocnR4ICpiYXNlcywKIAkJICAgICAgc2l6 ZV90IGxlbmd0aCkKIHsKICAgLyoKLSAgICBOT1RFOiBiYXNlcyBjb250YWlu cyBib3RoIHRoZSB0YWdnZWQgYW5kIHVudGFnZ2VkIGJhc2UuCisgICAgTk9U RTogV2hlbiBydW5uaW5nIHRoZSBzb2Z0d2FyZSBlbXVsYXRpb24gd2UgcmVj b3JkIGJvdGggdGhlIHRhZ2dlZCBhbmQKKyAgICB1bnRhZ2dlZCBiYXNlcy4K ICAgICBUaGlzIGFsbG93cyB1cyB0byBnZXQgYm90aCB0aGUgb3JpZ2luYWwg ZnJhbWUgdGFnIGFuZCB0aGUgdW50YWdnZWQgdmFyaWFibGUKICAgICBwb2lu dGVyIHdpdGggYSBtaW5pbWFsIG9mIGV4dHJhIGluc3RydWN0aW9ucy4KIApA QCAtMzk2OSw4ICszOTcyLDggQEAgaHdhc2FuX2VtaXRfcHJvbG9ndWUgKHJ0 eCAqYmFzZXMsCiAgICAgcG9pbnRlcnMgaW4gX19od2FzYW5fdGFnX21lbW9y eS4gIFdlIG5lZWQgdGhlIHRhZ2dlZCBiYXNlIHBvaW50ZXIgdG8gb2J0YWlu CiAgICAgdGhlIGJhc2UgdGFnIGZvciBhbiBvZmZzZXQuCiAKLSAgICBXZSBh bHNvIHdpbGwgbmVlZCB0aGUgdGFnZ2VkIGJhc2UgcG9pbnRlciBmb3IgTVRF LCBzaW5jZSB0aGUgQUREVEFHCi0gICAgaW5zdHJ1Y3Rpb24gdGFrZXMgYSB0 YWdnZWQgcG9pbnRlci4KKyAgICBXZSBuZWVkIHRoZSB0YWdnZWQgYmFzZSBw b2ludGVyIGZvciBNVEUsIHNpbmNlIHRoZSBBRERUQUcgaW5zdHJ1Y3Rpb24g dGFrZXMKKyAgICBhIHRhZ2dlZCBwb2ludGVyLgogICovCiAgIGZvciAoc2l6 ZV90IGkgPSAwOyAoaSAqIDIpICsgMSA8IGxlbmd0aDsgaSsrKQogICAgIHsK QEAgLTQwMDIsMTkgKzQwMDUsMjkgQEAgaHdhc2FuX2VtaXRfcHJvbG9ndWUg KHJ0eCAqYmFzZXMsCiAJZ2NjX2Fzc2VydCAodG1wICUgSFdBU0FOX1RBR19H UkFOVUxFX1NJWkUgPT0gMCk7CiAKICAgICAgIC8qIFRPRE8gT3RoZXIgb3B0 aW9ucyAoaS5lLiBpbmxpbmUgb3B0aW9ucykgICovCi0gICAgICAvKiBUT0RP IEF0IHRoZSBtb21lbnQgd2UgZG9uJ3QgZ2VuZXJhdGUgYSByYW5kb20gYmFz ZSB0YWcgZm9yIGVhY2gKLSAgICAgICAgIGZyYW1lLiAgV2hlbiB0aGF0IGhh cHBlbnMgd2Ugd2lsbCBuZWVkIHRvIGdlbmVyYXRlIHRoZSB0YWcgYnkKLSAg ICAgICAgIGFkZGluZyB0YWdzW2ldIHRvIHRoZSBmcmFtZSB0YWcgZmV0Y2hl ZCBmcm9tIGBiYXNlc1tpXWAuICAqLwotICAgICAgcnR4IHJldCA9IGluaXRf b25lX2xpYmZ1bmMgKCJfX2h3YXNhbl90YWdfbWVtb3J5Iik7Ci0gICAgICBl bWl0X2xpYnJhcnlfY2FsbCAocmV0LAotCSAgTENUX05PUk1BTCwKLQkgIFZP SURtb2RlLAotCSAgcGx1c19jb25zdGFudCAocHRyX21vZGUsIHVudGFnZ2Vk X2Jhc2VzW2ldLCBib3QpLAotCSAgcHRyX21vZGUsCi0JICBjb25zdF9pbnRf cnR4W01BWF9TQVZFRF9DT05TVF9JTlQgKyB0YWdzW2ldXSwKLQkgIFFJbW9k ZSwKLQkgIGdlbl9pbnRfbW9kZSAoc2l6ZSwgcHRyX21vZGUpLAotCSAgcHRy X21vZGUpOworICAgICAgaWYgKCEgSEFSRFdBUkVfTUVNT1JZX1RBR0dJTkcg KQorCXsKKwkgIC8qIFRPRE8gQXQgdGhlIG1vbWVudCB3ZSBkb24ndCBnZW5l cmF0ZSBhIHJhbmRvbSBiYXNlIHRhZyBmb3IgZWFjaAorCSAgICAgZnJhbWUu ICBXaGVuIHRoYXQgaGFwcGVucyB3ZSB3aWxsIG5lZWQgdG8gZ2VuZXJhdGUg dGhlIHRhZyBieQorCSAgICAgYWRkaW5nIHRhZ3NbaV0gdG8gdGhlIGZyYW1l IHRhZyBmZXRjaGVkIGZyb20gYGJhc2VzW2ldYC4gICovCisJICBydHggcmV0 ID0gaW5pdF9vbmVfbGliZnVuYyAoIl9faHdhc2FuX3RhZ19tZW1vcnkiKTsK KwkgIGVtaXRfbGlicmFyeV9jYWxsIChyZXQsCisJCQkgICAgIExDVF9OT1JN QUwsCisJCQkgICAgIFZPSURtb2RlLAorCQkJICAgICBwbHVzX2NvbnN0YW50 IChwdHJfbW9kZSwgdW50YWdnZWRfYmFzZXNbaV0sIGJvdCksCisJCQkgICAg IHB0cl9tb2RlLAorCQkJICAgICBjb25zdF9pbnRfcnR4W01BWF9TQVZFRF9D T05TVF9JTlQgKyB0YWdzW2ldXSwKKwkJCSAgICAgUUltb2RlLAorCQkJICAg ICBnZW5faW50X21vZGUgKHNpemUsIHB0cl9tb2RlKSwKKwkJCSAgICAgcHRy X21vZGUpOworCX0KKyAgICAgIGVsc2UKKwl7CisJICB0YXJnZXRtLm1lbXRh Zy50YWcgKGJhc2VzW2ldLAorCQkJICAgICAgYm90LAorCQkJICAgICAgdGFn c1tpXSwKKwkJCSAgICAgIGdlbl9pbnRfbW9kZSAoc2l6ZSwgcHRyX21vZGUp KTsKKwl9CiAgICAgfQogfQogCkBAIC00MDQ2LDExICs0MDU5LDE5IEBAIGh3 YXNhbl9lbWl0X3VuY29sb3VyX2ZyYW1lIChydHggZHluYW1pYywgcnR4IHZh cnMsIHJ0eF9pbnNuICpiZWZvcmUpCiAJCQkJICBOVUxMX1JUWCwgLyogdW5z aWduZWRwID0gKi8wLCBPUFRBQl9ESVJFQ1QpOwogCiAgIC8qIFRPRE8gT3Ro ZXIgb3B0aW9ucyAoaS5lLiBpbmxpbmUgb3B0aW9ucykgICovCi0gIHJ0eCBy ZXQgPSBpbml0X29uZV9saWJmdW5jICgiX19od2FzYW5fdGFnX21lbW9yeSIp OwotICBlbWl0X2xpYnJhcnlfY2FsbCAocmV0LCBMQ1RfTk9STUFMLCBWT0lE bW9kZSwKLSAgICAgIGJvdF9ydHgsIHB0cl9tb2RlLAotICAgICAgY29uc3Qw X3J0eCwgUUltb2RlLAotICAgICAgc2l6ZV9ydHgsIHB0cl9tb2RlKTsKKyAg aWYgKCEgSEFSRFdBUkVfTUVNT1JZX1RBR0dJTkcgKQorICAgIHsKKyAgICAg IHJ0eCByZXQgPSBpbml0X29uZV9saWJmdW5jICgiX19od2FzYW5fdGFnX21l bW9yeSIpOworICAgICAgZW1pdF9saWJyYXJ5X2NhbGwgKHJldCwgTENUX05P Uk1BTCwgVk9JRG1vZGUsCisJCQkgYm90X3J0eCwgcHRyX21vZGUsCisJCQkg Y29uc3QwX3J0eCwgUUltb2RlLAorCQkJIHNpemVfcnR4LCBwdHJfbW9kZSk7 CisgICAgfQorICBlbHNlCisgICAgeworICAgICAgdGFyZ2V0bS5tZW10YWcu Y29weV90YWcgKGJvdF9ydHgsIHN0YWNrX3BvaW50ZXJfcnR4KTsKKyAgICAg IHRhcmdldG0ubWVtdGFnLnRhZyAoYm90X3J0eCwgMCwgMCwgc2l6ZV9ydHgp OworICAgIH0KIAogICBkb19wZW5kaW5nX3N0YWNrX2FkanVzdCAoKTsKICAg cnR4X2luc24gKmluc25zID0gZ2V0X2luc25zICgpOwpAQCAtNDA5Niw2ICs0 MTE3LDcgQEAgc3RhdGljIEdUWSgoKSkgdHJlZSBod2FzYW5fY3Rvcl9zdGF0 ZW1lbnRzOwogdm9pZAogaHdhc2FuX2ZpbmlzaF9maWxlICh2b2lkKQogewor ICBnY2NfYXNzZXJ0ICghIEhBUkRXQVJFX01FTU9SWV9UQUdHSU5HKTsKICAg LyogQXZvaWQgaW5zdHJ1bWVudGluZyBjb2RlIGluIHRoZSBod2FzYW4gY29u c3RydWN0b3JzL2Rlc3RydWN0b3JzLiAgKi8KICAgZmxhZ19zYW5pdGl6ZSAm PSB+U0FOSVRJWkVfSFdBRERSRVNTOwogICAvKiBUT0RPIE9ubHkgZG8gdGhp cyBpZiBpbiB1c2Vyc3BhY2UuCkBAIC00MTEzLDYgKzQxMzUsNyBAQCBod2Fz YW5fZmluaXNoX2ZpbGUgKHZvaWQpCiBib29sCiBod2FzYW5fZXhwYW5kX2No ZWNrX2lmbiAoZ2ltcGxlX3N0bXRfaXRlcmF0b3IgKml0ZXIsIGJvb2wpCiB7 CisgIGdjY19hc3NlcnQgKCEgSEFSRFdBUkVfTUVNT1JZX1RBR0dJTkcpOwog ICAvLyBUT0RPIEZvciBub3cgb25seSBpbXBsZW1lbnRpbmcgdGhlIGZ1bmN0 aW9uIHdoZW4gdXNpbmcgY2FsbHMuCiAgIC8vIFRoaXMgaXMgYSBsaXR0bGUg ZWFzaWVyLCBhbmQgbWVhbnMgSSBjYW4gcmVseSBvbiB0aGUgbGlicmFyeQog ICAvLyBpbXBsZW1lbnRhdGlvbiB3aGlsZSBjaGVja2luZyBteSBpbnN0cnVt ZW50YXRpb24gY29kZSBmb3Igbm93LgpAQCAtNDIxNSw3ICs0MjM4LDcgQEAg aHdhc2FuX2V4cGFuZF9tYXJrX2lmbiAoZ2ltcGxlX3N0bXRfaXRlcmF0b3Ig KikKIGJvb2wKIGdhdGVfaHdhc2FuICgpCiB7Ci0gIHJldHVybiBtZW1vcnlf dGFnZ2luZ19wICgpOworICByZXR1cm4gbWVtb3J5X3RhZ2dpbmdfcCAoKSAm JiAhIEhBUkRXQVJFX01FTU9SWV9UQUdHSU5HOwogfQogYm9vbAogaGFyZHdh cmVfbWVtb3J5X3RhZ2dpbmdfcCAoKQpkaWZmIC0tZ2l0IGEvZ2NjL2J1aWx0 aW5zLmMgYi9nY2MvYnVpbHRpbnMuYwppbmRleCAzZjMyNzU0YzRkMzVmYzM0 YWY3YzUzMTU2ZDJhMzU2ZjY5YTk0YThmLi41NDRkMDdiNjdhNzQ4NzVmZGQ5 M2IxNTJiNTcyMGY1OGExMDkzMWExIDEwMDY0NAotLS0gYS9nY2MvYnVpbHRp bnMuYworKysgYi9nY2MvYnVpbHRpbnMuYwpAQCAtNTMxMiw2ICs1MzEyLDE3 IEBAIGV4cGFuZF9idWlsdGluX2ZyYW1lX2FkZHJlc3MgKHRyZWUgZm5kZWNs LCB0cmVlIGV4cCkKIHN0YXRpYyBydHgKIGV4cGFuZF9idWlsdGluX2FsbG9j YSAodHJlZSBleHApCiB7CisgIC8qIFRPRE8gRm9yIGhhcmR3YXJlIG1lbW9y eSB0YWdnaW5nIHdlIHdpbGwgbmVlZCB0byBjYWxsIHRoZSBiYWNrZW5kIHRv IHRhZworICAgICB0aGlzIG1lbW9yeSBzaW5jZSB0aGUgYGh3YXNhbmAgcGFz cyB3aWxsIG5vdCBiZSBydW4uCisKKyAgICAgVGhlIGBod2FzYW5gIHBhc3Mg aXMgbWFpbmx5IHRvIGFkZCBIV0FTQU5fQ0hFQ0sgaW50ZXJuYWwgZnVuY3Rp b25zIHdoZXJlCisgICAgIGNoZWNrcyBzaG91bGQgYmUgbWFkZS4gIFdpdGgg aGFyZHdhcmUgbWVtb3J5IHRhZ2dpbmcgdGhlIGNoZWNrcyBhcmUgZG9uZQor ICAgICBhdXRvbWF0aWNhbGx5IGJ5IHRoZSBhcmNoaXRlY3R1cmUuCisKKyAg ICAgVGhlIGBod2FzYW5gIHBhc3MgYWxzbyBtb2RpZmllcyB0aGUgYmVoYXZp b3VyIG9mIHRoZSBhbGxvY2EgYnVpbHRpbgorICAgICBmdW5jdGlvbiBpbiBh IHRhcmdldC1pbmRlcGVuZGVudCBtYW5uZXIsIGJ1dCB3aGVuIG1lbW9yeSB0 YWdnaW5nIGlzCisgICAgIGhhbmRsZWQgYnkgdGhlIGJhY2tlbmQgaXQgaXMg bW9yZSBjb252ZW5pZW50IHRvIGhhbmRsZSB0aGUgdGFnZ2luZyBpbiB0aGUK KyAgICAgYWxsb2NhIGhvb2suICAqLwogICBydHggb3AwOwogICBydHggcmVz dWx0OwogICB1bnNpZ25lZCBpbnQgYWxpZ247CkBAIC02OTMyLDYgKzY5NDMs OSBAQCBleHBhbmRfYnVpbHRpbl9zZXRfdGhyZWFkX3BvaW50ZXIgKHRyZWUg ZXhwKQogc3RhdGljIHZvaWQKIGV4cGFuZF9zdGFja19yZXN0b3JlICh0cmVl IHZhcikKIHsKKyAgLyogVE9ETyBJZiBtZW1vcnkgdGFnZ2luZyBpcyBlbmFi bGVkIHRocm91Z2ggdGhlIGhhcmR3YXJlIHdlIG5lZWQgdG8gdW5jb2xvdXIK KyAgICAgdGhlIHN0YWNrIGZyb20gd2hlcmUgd2UgYXJlIHRvIHdoZXJlIHdl J3JlIGdvaW5nLiAoaS5lLiBjb2xvdXIgaW4gdGhlCisgICAgIGJhY2tncm91 bmQgc3RhY2sgY29sb3VyKS4gICovCiAgIHJ0eF9pbnNuICpwcmV2OwogICBy dHggc2EgPSBleHBhbmRfbm9ybWFsICh2YXIpOwogCmRpZmYgLS1naXQgYS9n Y2MvY2ZnZXhwYW5kLmMgYi9nY2MvY2ZnZXhwYW5kLmMKaW5kZXggOWYwODcy YjMyMzU0Y2JjMzE4NmYzZjJkMjYwMGY3MTFhNDY5MjZkMS4uMDYxZjAwYzJl MWNmNWQxYjg2ZmIzZGQwM2QyN2ZkMGJmOTA1NzIxYSAxMDA2NDQKLS0tIGEv Z2NjL2NmZ2V4cGFuZC5jCisrKyBiL2djYy9jZmdleHBhbmQuYwpAQCAtMTA0 MSw2ICsxMDQxLDggQEAgc3RydWN0IHN0YWNrX3ZhcnNfZGF0YQogICAgICBB U0FOIHJlY29yZHMgSE9TVF9XSURFX0lOVCBvZmZzZXRzICh0aGF0IHdhcyBl bm91Z2ggYmVmb3JlIHRoZQogICAgICBpbnRyb2R1Y3Rpb24gb2YgU1ZFIHZl Y3RvcnMpIHdoaWNoICAqLwogICBhdXRvX3ZlYzxwb2x5X2ludDY0PiBod2Fz YW5fdmVjOworICAvKiBIV0FTQU4gbmVlZHMgdG8gcmVjb3JkIHVudGFnZ2Vk IGJhc2UgcG9pbnRlcnMgd2hlbiB0aGVyZSBpc24ndCBoYXJkd2FyZQorICAg ICBtZW1vcnkgdGFnZ2luZyBlbmFibGVkIGJ5IHRoZSBhcmNoaXRlY3R1cmUu ICAqLwogICBhdXRvX3ZlYzxydHg+IGh3YXNhbl91bnRhZ2dlZF9iYXNlX3Zl YzsKICAgYXV0b192ZWM8cnR4PiBod2FzYW5fYmFzZV92ZWM7CiAKQEAgLTEx NzQsNyArMTE3Niw4IEBAIGV4cGFuZF9zdGFja192YXJzIChib29sICgqcHJl ZCkgKHNpemVfdCksIHN0cnVjdCBzdGFja192YXJzX2RhdGEgKmRhdGEpCiAJ ICAgICAgZ2NjX2Fzc2VydCAoc3RhY2tfdmFyc1tpXS5hbGlnbmIgPj0gSFdB U0FOX1RBR19HUkFOVUxFX1NJWkUpOwogCSAgICAgIG9mZnNldCA9IGFsbG9j X3N0YWNrX2ZyYW1lX3NwYWNlICgwLCBIV0FTQU5fVEFHX0dSQU5VTEVfU0la RSk7CiAJICAgICAgZGF0YS0+aHdhc2FuX3ZlYy5zYWZlX3B1c2ggKG9mZnNl dCk7Ci0JICAgICAgZGF0YS0+aHdhc2FuX3VudGFnZ2VkX2Jhc2VfdmVjLnNh ZmVfcHVzaCAodmlydHVhbF9zdGFja192YXJzX3J0eCk7CisJICAgICAgaWYg KCEgSEFSRFdBUkVfTUVNT1JZX1RBR0dJTkcpCisJCWRhdGEtPmh3YXNhbl91 bnRhZ2dlZF9iYXNlX3ZlYy5zYWZlX3B1c2ggKHZpcnR1YWxfc3RhY2tfdmFy c19ydHgpOwogCSAgICB9CiAJICAvKiBBU0FOIGRlc2NyaXB0aW9uIHN0cmlu Z3MgZG9uJ3QgeWV0IGhhdmUgYSBzeW50YXggZm9yIGV4cHJlc3NpbmcKIAkg ICAgIHBvbHlub21pYWwgb2Zmc2V0cy4gICovCkBAIC0xMjkwLDEwICsxMjkz LDE4IEBAIGV4cGFuZF9zdGFja192YXJzIChib29sICgqcHJlZCkgKHNpemVf dCksIHN0cnVjdCBzdGFja192YXJzX2RhdGEgKmRhdGEpCiAJCSByZXF1aXJl bWVudCBtZWFucyB0aGF0IHRoZSBhbGlnbm1lbnQgcmVxdWlyZW1lbnQgaXMg Z3JlYXRlcgogCQkgdGhhbiB0aGUgcmVxdWlyZWQgYWxpZ25tZW50IGZvciB0 YWdzLgogCQkqLwotCSAgICAgIGlmICghbGFyZ2VfdW50YWdnZWRfYmFzZSkK LQkJbGFyZ2VfdW50YWdnZWRfYmFzZSA9IGh3YXNhbl9jcmVhdGVfdW50YWdn ZWRfYmFzZSAobGFyZ2VfYmFzZSk7CiAJICAgICAgZGF0YS0+aHdhc2FuX3Zl Yy5zYWZlX3B1c2ggKGxhcmdlX2FsbG9jKTsKLQkgICAgICBkYXRhLT5od2Fz YW5fdW50YWdnZWRfYmFzZV92ZWMuc2FmZV9wdXNoIChsYXJnZV91bnRhZ2dl ZF9iYXNlKTsKKworCSAgICAgIGlmICghIEhBUkRXQVJFX01FTU9SWV9UQUdH SU5HICkKKwkgICAgICB7CisJCS8qIFdlIG9ubHkgbmVlZCB0byByZWNvcmQg dGhlIHVudGFnZ2VkIGJhc2VzIGZvciBIV0FTQU4sIHNpbmNlCisJCSAgIHRo ZSBydW50aW1lIGxpYnJhcnkgZm9yIHRoYXQgZG9lc24ndCBhY2NlcHQgdGFn Z2VkIHBvaW50ZXJzLgorCQkgICBGb3IgaGFyZHdhcmUgaW1wbGVtZW50YXRp b25zIG9mIG1lbW9yeSB0YWdnaW5nIHRoZXJlIGlzIG5vCisJCSAgIHVzZSBv ZiByZWNvcmRpbmcgdGhlc2UgdW50YWdnZWQgdmVyc2lvbnMuICAqLworCQlp ZiAoIWxhcmdlX3VudGFnZ2VkX2Jhc2UpCisJCSAgbGFyZ2VfdW50YWdnZWRf YmFzZSA9IGh3YXNhbl9jcmVhdGVfdW50YWdnZWRfYmFzZSAobGFyZ2VfYmFz ZSk7CisJCWRhdGEtPmh3YXNhbl91bnRhZ2dlZF9iYXNlX3ZlYy5zYWZlX3B1 c2ggKGxhcmdlX3VudGFnZ2VkX2Jhc2UpOworCSAgICAgIH0KIAkgICAgfQog CSAgb2Zmc2V0ID0gbGFyZ2VfYWxsb2M7CiAJICBsYXJnZV9hbGxvYyArPSBz dGFja192YXJzW2ldLnNpemU7CmRpZmYgLS1naXQgYS9nY2MvY29uZmlnL2Fh cmNoNjQvYWFyY2g2NC5oIGIvZ2NjL2NvbmZpZy9hYXJjaDY0L2FhcmNoNjQu aAppbmRleCA3YmQzYmY1MjVkZDcxMzQ3YTEyZWQ5Y2QyMjI3YmMyY2Q2ZTlj YzU1Li44ZWEyMTlmMjVlY2IxM2QyNmU1ZDg0ZWU0NWU4Y2VkNjFjM2U3MmE5 IDEwMDY0NAotLS0gYS9nY2MvY29uZmlnL2FhcmNoNjQvYWFyY2g2NC5oCisr KyBiL2djYy9jb25maWcvYWFyY2g2NC9hYXJjaDY0LmgKQEAgLTIzNSw2ICsy MzUsNyBAQCBleHRlcm4gdW5zaWduZWQgYWFyY2g2NF9hcmNoaXRlY3R1cmVf dmVyc2lvbjsKICNkZWZpbmUgQUFSQ0g2NF9JU0FfRjE2Rk1MCSAgIChhYXJj aDY0X2lzYV9mbGFncyAmIEFBUkNINjRfRkxfRjE2Rk1MKQogI2RlZmluZSBB QVJDSDY0X0lTQV9SQ1BDOF80CSAgIChhYXJjaDY0X2lzYV9mbGFncyAmIEFB UkNINjRfRkxfUkNQQzhfNCkKICNkZWZpbmUgQUFSQ0g2NF9JU0FfVjhfNQkg ICAoYWFyY2g2NF9pc2FfZmxhZ3MgJiBBQVJDSDY0X0ZMX1Y4XzUpCisjZGVm aW5lIEFBUkNINjRfSVNBX01FTVRBRwkgICAoYWFyY2g2NF9pc2FfZmxhZ3Mg JiBBQVJDSDY0X0ZMX01FTVRBRykKIAogLyogQ3J5cHRvIGlzIGFuIG9wdGlv bmFsIGV4dGVuc2lvbiB0byBBZHZTSU1ELiAgKi8KICNkZWZpbmUgVEFSR0VU X0NSWVBUTyAoVEFSR0VUX1NJTUQgJiYgQUFSQ0g2NF9JU0FfQ1JZUFRPKQpA QCAtNTA5LDYgKzUxMCwxMCBAQCBleHRlcm4gdW5zaWduZWQgYWFyY2g2NF9h cmNoaXRlY3R1cmVfdmVyc2lvbjsKICNkZWZpbmUgRUhfUkVUVVJOX1NUQUNL QURKX1JUWAlnZW5fcnR4X1JFRyAoUG1vZGUsIFI0X1JFR05VTSkKICNkZWZp bmUgRUhfUkVUVVJOX0hBTkRMRVJfUlRYICBhYXJjaDY0X2VoX3JldHVybl9o YW5kbGVyX3J0eCAoKQogCisvKiBXZSBoYXZlIG1lbW9yeSB0YWcgY2hlY2tp bmcgaWYgd2UgaGF2ZSB0aGUgTUVNVEFHIGV4dGVuc2lvbiBlbmFibGVkIGFu ZAorICAgaGVuY2Ugd2FudCB0byBoYW5kbGUgdGhhdCBhbmQgY29sb3VyaW5n IG1lbW9yeSBvdXJzZWx2ZXMuICAqLworI2RlZmluZSBIQVJEV0FSRV9NRU1P UllfVEFHR0lORyBBQVJDSDY0X0lTQV9NRU1UQUcKKwogLyogRG9uJ3QgdXNl IF9fYnVpbHRpbl9zZXRqbXAgdW50aWwgd2UndmUgZGVmaW5lZCBpdC4gICov CiAjdW5kZWYgRE9OVF9VU0VfQlVJTFRJTl9TRVRKTVAKICNkZWZpbmUgRE9O VF9VU0VfQlVJTFRJTl9TRVRKTVAgMQpkaWZmIC0tZ2l0IGEvZ2NjL2NvbmZp Zy9hYXJjaDY0L2FhcmNoNjQuYyBiL2djYy9jb25maWcvYWFyY2g2NC9hYXJj aDY0LmMKaW5kZXggOGEyOTBkY2Q5MDQ2YmU0Nzc1NjI3ZGVjMGU5YjNiZjgy NmNlMzc3MC4uNDQ0MDIxZjgxMTkxYTJlZWUzZTUwYTRmY2I0YWU2Y2NiMzMx ODJhYiAxMDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy9hYXJjaDY0L2FhcmNoNjQu YworKysgYi9nY2MvY29uZmlnL2FhcmNoNjQvYWFyY2g2NC5jCkBAIC0xODc3 Miw2ICsxODc3MiwyMiBAQCBhYXJjaDY0X3N0YWNrX3Byb3RlY3RfZ3VhcmQg KHZvaWQpCiAgIHJldHVybiBOVUxMX1RSRUU7CiB9CiAKKy8qIEltcGxlbWVu dCBUQVJHRVRfTUVNVEFHX1RBRyBmb3IgQUFyY2g2NC4gVGhpcyBpcyBvbmx5 IGF2YWlsYWJsZSB3aGVuCisgICBBQVJDSDY0X0lTQV9NRU1UQUcgaXMgYXZh aWxhYmxlLiAgVE9ETyBFdmVudHVhbGx5IHdlIHdvdWxkIGp1c3Qgd2FudAor ICAgc29tZXRoaW5nIHRvIGVtaXQgYSBsb29wIG9mIFNURyBvciBTVDJHLiAg Q3VycmVudGx5IHVuaW1wbGVtZW50ZWQuICAqLwordm9pZAorYWFyY2g2NF90 YWdfbWVtb3J5IChydHggdGFnZ2VkX3N0YXJ0LCBwb2x5X2ludDY0IGFkZHJl c3Nfb2Zmc2V0LCB1aW50OF90IHRhZ19vZmZzZXQsCisJCSAgICBydHggc2l6 ZSkKK3sKKyAgcmV0dXJuOworfQorCit2b2lkCithYXJjaDY0X2dlbnRhZyAo cnR4IGEsIHJ0eCBiKQoreworICBlbWl0X2luc24gKGdlbl9yYW5kb21fdGFn IChhLCBiKSk7Cit9CisKIC8qIEltcGxlbWVudCBUQVJHRVRfQVNNX0ZJTEVf RU5EIGZvciBBQXJjaDY0LiAgVGhpcyBhZGRzIHRoZSBBQXJjaDY0IEdOVSBO T1RFCiAgICBzZWN0aW9uIGF0IHRoZSBlbmQgaWYgbmVlZGVkLiAgKi8KICNk ZWZpbmUgR05VX1BST1BFUlRZX0FBUkNINjRfRkVBVFVSRV8xX0FORAkweGMw MDAwMDAwCkBAIC0xOTMzNiw2ICsxOTM1MiwxNCBAQCBhYXJjaDY0X2xpYmdj Y19mbG9hdGluZ19tb2RlX3N1cHBvcnRlZF9wCiAjdW5kZWYgVEFSR0VUX0dF VF9NVUxUSUxJQl9BQklfTkFNRQogI2RlZmluZSBUQVJHRVRfR0VUX01VTFRJ TElCX0FCSV9OQU1FIGFhcmNoNjRfZ2V0X211bHRpbGliX2FiaV9uYW1lCiAK KyNpZmRlZiBBQVJDSDY0X0lTQV9NRU1UQUcKKyN1bmRlZiBUQVJHRVRfTUVN VEFHX1RBRworI2RlZmluZSBUQVJHRVRfTUVNVEFHX1RBRyBhYXJjaDY0X3Rh Z19tZW1vcnkKKworI3VuZGVmIFRBUkdFVF9NRU1UQUdfR0VOVEFHCisjZGVm aW5lIFRBUkdFVF9NRU1UQUdfR0VOVEFHIGFhcmNoNjRfZ2VudGFnCisjZW5k aWYKKwogI2lmIENIRUNLSU5HX1AKICN1bmRlZiBUQVJHRVRfUlVOX1RBUkdF VF9TRUxGVEVTVFMKICNkZWZpbmUgVEFSR0VUX1JVTl9UQVJHRVRfU0VMRlRF U1RTIHNlbGZ0ZXN0OjphYXJjaDY0X3J1bl9zZWxmdGVzdHMKZGlmZiAtLWdp dCBhL2djYy9jb25maWcvYWFyY2g2NC9hYXJjaDY0Lm1kIGIvZ2NjL2NvbmZp Zy9hYXJjaDY0L2FhcmNoNjQubWQKaW5kZXggY2IwZDNhZTZiYmYzZWQ0Mzlj N2IyNzY4MzcyNmY0YzMwYjA0Nzc3ZC4uNzBhOTI3YjZiNzBlNGU0OThkOTYy YzVlOWNmMTM0NGYyNjYxZTM3NyAxMDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy9h YXJjaDY0L2FhcmNoNjQubWQKKysrIGIvZ2NjL2NvbmZpZy9hYXJjaDY0L2Fh cmNoNjQubWQKQEAgLTIzMSw2ICsyMzEsNyBAQCAoZGVmaW5lX2NfZW51bSAi dW5zcGVjIiBbCiAgICAgVU5TUEVDX1JFVl9TVUJSRUcKICAgICBVTlNQRUNf U1BFQ1VMQVRJT05fVFJBQ0tFUgogICAgIFVOU1BFQ19DT1BZU0lHTgorICAg IFVOU1BFQ19HRU5UQUcKIF0pCiAKIChkZWZpbmVfY19lbnVtICJ1bnNwZWN2 IiBbCkBAIC00MDksNiArNDEwLDMwIEBAIChkZWZpbmVfZXhwYW5kICJjYnJh bmNoPG1vZGU+NCIKICAgIgogKQogCis7OyBUT0RPCis7OyAgICBOZWVkIHRv IHB1dCBpbiBzb21lIHNvcnQgb2YgcmFuZG9tIHRhZyBoZXJlLgorOzsgICAg QXQgdGhlIG1vbWVudCBza2lwcGluZyBpdCBiZWNhdXNlIEkgZG9uJ3Qga25v dyB3aGF0IGluc3RydWN0aW9ucyB0byB1c2UuCis7OyAgICAocGx1cywgc3Rh cnRpbmcgYXQgemVybyBtZWFucyB0aGF0IEkgY2FuIGtub3cgd2hhdCB0byBl eHBlY3QgZHVyaW5nCis7OyAgICBkZXZlbG9wbWVudC4KKyhkZWZpbmVfaW5z biAicmFuZG9tX3RhZyIKKyAgWyhzZXQgKG1hdGNoX29wZXJhbmQ6REkgMCAi cmVnaXN0ZXJfb3BlcmFuZCIgIj1yIikKKwkodW5zcGVjOkRJIFsobWF0Y2hf b3BlcmFuZDpESSAxICJyZWdpc3Rlcl9vcGVyYW5kIiAiciIpXSBVTlNQRUNf R0VOVEFHKSldCisgICIiCisgIDs7ICJBQVJDSDY0X0lTQV9NRU1UQUciCisg ICJtb3ZcXHQlMCwgJTEgLy8gaXJnXFx0JTAsICUxIgorKQorCisoZGVmaW5l X2luc24gInBsYWluX29mZnNldF90YWc8bW9kZT4iCisgIFsoc2V0IChtYXRj aF9vcGVyYW5kOkdQSSAwICJyZWdpc3Rlcl9vcGVyYW5kIiAiPXIsciIpCisg ICAgKGFkZHRhZzpHUEkgKG1hdGNoX29wZXJhbmQ6R1BJIDEgInJlZ2lzdGVy X29wZXJhbmQiICJyLHIiKQorICAgICAobWF0Y2hfb3BlcmFuZDpHUEkgMiAi YWFyY2g2NF9NVEVfdmFsdWVfb2Zmc2V0IiAiSSxKIikKKyAgICAgKG1hdGNo X29wZXJhbmQ6R1BJIDMgImFhcmNoNjRfTVRFX3RhZ19vZmZzZXQiICJpLGki KSkpXQorICAiQUFSQ0g2NF9JU0FfTUVNVEFHIgorICAiQAorICBhZGRcXHQl MCwgJTEsICUyICAgICAvLyBhZGRnXFx0JTAsICUxLCAlMiwgJTMKKyAgc3Vi XFx0JTAsICUxLCAjJW4yICAgLy8gc3ViZ1xcdCUwLCAlMSwgIyVuMiwgJTMi CispCisKIChkZWZpbmVfZXhwYW5kICJhZGR0YWc8bW9kZT40IgogICBbKHNl dCAobWF0Y2hfb3BlcmFuZDpHUEkgMCAicmVnaXN0ZXJfb3BlcmFuZCIgIiIp CiAgICAgKGFkZHRhZzpHUEkgKG1hdGNoX29wZXJhbmQ6R1BJIDEgInJlZ2lz dGVyX29wZXJhbmQiICIiKQpAQCAtNDE3LDEzICs0NDIsNDEgQEAgKGRlZmlu ZV9leHBhbmQgImFkZHRhZzxtb2RlPjQiCiAgICIiCiB7CiAgIGdjY19hc3Nl cnQgKGNhbl9jcmVhdGVfcHNldWRvX3AgKCkpOwotICAvKiBTaW1wbHkgYWRk IHRoZSB0d28gdmFsdWVzIGFzIGEgY29uc3RhbnQgYW5kIHVzZSB0aGF0LiAg VGhlIGFkZGRpIHBhdHRlcm4KLSAgICAgd2lsbCBoYW5kbGUgdGhlIGZhY3Qg dGhhdCB0aGUgaW50ZWdlciBpcyBvdXQgb2YgcmFuZ2UgZm9yIEFERC4gICov Ci0gIHBvbHlfaW50NjQgdmFsID0gcnR4X3RvX3BvbHlfaW50NjQgKG9wZXJh bmRzWzJdKTsKLSAgdmFsICs9ICgodWludDY0X3QpSU5UVkFMKG9wZXJhbmRz WzNdKSA8PCA1Nik7Ci0gIGVtaXRfaW5zbiAoZ2VuX2FkZDxtb2RlPjMgKG9w ZXJhbmRzWzBdLCBvcGVyYW5kc1sxXSwKLQkJCSAgICAgaW1tZWRfd2lkZV9p bnRfY29uc3QgKHZhbCwgPE1PREU+bW9kZSkpKTsKLSAgRE9ORTsKKworICBp ZiAoIUFBUkNINjRfSVNBX01FTVRBRykKKyAgICB7CisgICAgICAvKiBUT0RP CisJICBOZWVkIHRvIGxvb2sgaW50byB3aGF0IHRoZSBtb3N0IGVmZmljaWVu dCBjb2RlIHNlcXVlbmNlIGlzLgorCSAgUmlnaHQgbm93IGp1c3Qgd2FudCBz b21ldGhpbmcgdG8gd29yayBzbyBJIGNhbiBib290c3RyYXAgYWdhaW4gYW5k CisJICBjaGVjayBmb3IgbWlzdGFrZXMuCisKKwkgIFRoaXMgaXMgYSBjb2Rl IHNlcXVlbmNlIHRoYXQgd291bGQgYmUgZW1pdHRlZCAqbWFueSogdGltZXMs IHNvIHdlCisJICB3YW50IGl0IGFzIHNtYWxsIGFzIHBvc3NpYmxlLgorCSov CisgICAgLyogU2ltcGx5IGFkZCB0aGUgdHdvIHZhbHVlcyBhcyBhIGNvbnN0 YW50IGFuZCB1c2UgdGhhdC4gIFRoZSBhZGRkaQorICAgICAgIHBhdHRlcm4g d2lsbCBoYW5kbGUgdGhlIGZhY3QgdGhhdCB0aGUgaW50ZWdlciBpcyBvdXQg b2YgdGhlCisgICAgICAgcmVwcmVzZW50YWJsZSByYW5nZS4gICovCisgICAg ICBwb2x5X2ludDY0IHZhbCA9IHJ0eF90b19wb2x5X2ludDY0IChvcGVyYW5k c1syXSk7CisgICAgICB2YWwgKz0gKCh1aW50NjRfdClJTlRWQUwob3BlcmFu ZHNbM10pIDw8IDU2KTsKKyAgICAgIGVtaXRfaW5zbiAoZ2VuX2FkZDxtb2Rl PjMgKG9wZXJhbmRzWzBdLCBvcGVyYW5kc1sxXSwKKwkJCQkgaW1tZWRfd2lk ZV9pbnRfY29uc3QgKHZhbCwgPE1PREU+bW9kZSkpKTsKKyAgICAgIERPTkU7 CisgICAgfQorICBlbHNlIGlmICghYWFyY2g2NF9NVEVfdmFsdWVfb2Zmc2V0 IChvcGVyYW5kc1syXSwgPE1PREU+bW9kZSkpCisgICAgeworICAgICAgLyog TXVzdCBhbHdheXMgYmUgYWJsZSB0byBjcmVhdGUgYSBwc2V1ZG8gcmVnaXN0 ZXIuCisJIFRoaXMgcGF0dGVybiByZXF1aXJlcyB0aGUgYWJpbGl0eSB0byBn ZW5lcmF0ZSBuZXcgcHNldWRvIHJlZ2lzdGVycywKKwkgc2luY2UgdGhlcmUn cyBubyB3YXkgdG8gaGFuZGxlIGEgY29uc3RhbnQgdGhhdCdzIHRvbyBsYXJn ZSBvdGhlciB0aGFuCisgICAgICAgICBhZGRpbmcgdGhhdCBjb25zdGFudCBp bnRvIHRoZSBjdXJyZW50IHJlZ2lzdGVyLgorICAgICAgICAgSWYgd2UgaGFk IGEgdG9vLWxhcmdlIGNvbnN0YW50IGF0IHRoZSBwb2ludCB3aGVyZSB3ZSBj YW4ndCBjcmVhdGUgYQorICAgICAgICAgcHNldWRvIHJlZ2lzdGVyLCB0aGVu IHVzaW5nIHRoZSBiYXNpYyBgcGx1c2AgcGF0dGVybiB3b3VsZCBlbmQgdXAg d2l0aAorICAgICAgICAgYSBgcGx1c2AgcGF0dGVybiB0aGF0IGhhcyBhIHRv by1sYXJnZSBjb25zdGFudCwgd2hpY2ggd291bGQgZmFpbCB0aGVyZQorICAg ICAgICAgaW5zdGVhZCBvZiBoZXJlLiAqLworICAgICAgcnR4IG5ld3JlZyA9 IGdlbl9yZWdfcnR4ICg8TU9ERT5tb2RlKTsKKyAgICAgIGVtaXRfaW5zbiAo Z2VuX2FkZDxtb2RlPjMgKG5ld3JlZywgb3BlcmFuZHNbMV0sIG9wZXJhbmRz WzJdKSk7CisgICAgICBvcGVyYW5kc1syXSA9IGNvbnN0MF9ydHg7CisgICAg ICBvcGVyYW5kc1sxXSA9IG5ld3JlZzsKKyAgICB9CiB9KQogCiAoZGVmaW5l X2V4cGFuZCAiY2JyYW5jaGNjNCIKZGlmZiAtLWdpdCBhL2djYy9jb25maWcv YWFyY2g2NC9wcmVkaWNhdGVzLm1kIGIvZ2NjL2NvbmZpZy9hYXJjaDY0L3By ZWRpY2F0ZXMubWQKaW5kZXggZTJhYTAyOTBmODMzZmJmZmVkZWMxZDhkYWIy MTlmNzJlYjE3NDE5ZS4uMGVkZmI2ZGU3ZDFkZGI0NjZkMTE0Yjc1MTBlNTg0 OTkxMTcwNjFjNSAxMDA2NDQKLS0tIGEvZ2NjL2NvbmZpZy9hYXJjaDY0L3By ZWRpY2F0ZXMubWQKKysrIGIvZ2NjL2NvbmZpZy9hYXJjaDY0L3ByZWRpY2F0 ZXMubWQKQEAgLTE0MSw2ICsxNDEsMTMgQEAgKGRlZmluZV9wcmVkaWNhdGUg ImFhcmNoNjRfTVRFX3RhZ19vZmZzZXQiCiAgIChhbmQgKG1hdGNoX2NvZGUg ImNvbnN0X2ludCIpCiAgICAgICAgKG1hdGNoX3Rlc3QgIklOX1JBTkdFIChJ TlRWQUwgKG9wKSwgMCwgMTYpIikpKQogCis7OyBUT0RPCis7OyAgICBXaWxs IGhhdmUgdG8gY2hhbmdlIHRoZSBjb25zdGFudCBmcm9tIDQwOTYgdG8gNjQg d2hlbiBzd2l0Y2hpbmcgdG8gYWRkZy4KKyhkZWZpbmVfcHJlZGljYXRlICJh YXJjaDY0X01URV92YWx1ZV9vZmZzZXQiCisgIChhbmQgKG1hdGNoX2NvZGUg ImNvbnN0X2ludCIpCisgICAgICAgKG1hdGNoX3Rlc3QgIklOX1JBTkdFIChJ TlRWQUwgKG9wKSwgLTQwOTYsIDQwOTYpIikpKQorCisKIChkZWZpbmVfcHJl ZGljYXRlICJhYXJjaDY0X3BsdXNsb25nX3N0cmljdF9pbW1lZGF0ZSIKICAg KGFuZCAobWF0Y2hfb3BlcmFuZCAwICJhYXJjaDY0X3BsdXNsb25nX2ltbWVk aWF0ZSIpCiAgICAgICAgKG5vdCAobWF0Y2hfb3BlcmFuZCAwICJhYXJjaDY0 X3BsdXNfaW1tZWRpYXRlIikpKSkKZGlmZiAtLWdpdCBhL2djYy9kZWZhdWx0 cy5oIGIvZ2NjL2RlZmF1bHRzLmgKaW5kZXggYjc1MzQyNTYxMTliZDc4MzRm MmZhOWQ1ZjMyODYzODIyZDNiMzkzYS4uYjQ3ZmU2YjM1NTU0MDkxYzlmMzIy ODE2OWFkMWY2ZmY0YzY5MmIxNCAxMDA2NDQKLS0tIGEvZ2NjL2RlZmF1bHRz LmgKKysrIGIvZ2NjL2RlZmF1bHRzLmgKQEAgLTEyOTQsNiArMTI5NCwxNiBA QCBzZWUgdGhlIGZpbGVzIENPUFlJTkczIGFuZCBDT1BZSU5HLlJVTlRJTUUg cmVzcGVjdGl2ZWx5LiAgSWYgbm90LCBzZWUKICNkZWZpbmUgRUhfUkVUVVJO X0hBTkRMRVJfUlRYIE5VTEwKICNlbmRpZgogCisvKiBJbmRpY2F0ZSB3aGV0 aGVyIHRoaXMgYmFja2VuZCBoYXMgYXV0b21hdGljIGFjY2VzcyBjaGVja3Mg Zm9yIHRhZ2dlZAorICAgcG9pbnRlcnMgKGkuZS4gSFdBU0FOKSBpZiBzbyB0 aGVuIEhXQVNBTiBtZW1vcnkgdGFnZ2luZyBjYW4gYmUgaW1wbGVtZW50ZWQK KyAgIHdpdGggbXVjaCBsZXNzIGluc3RydW1lbnRhdGlvbi4KKyAgIElmIGEg YmFja2VuZCBhZHZlcnRpc2VzIHRoYXQgdGhleSBoYXZlIHRoaXMgaXQgbXVz dCBhbHNvIGhhbmRsZSB0YWdnaW5nCisgICBzaGFkb3cgbWVtb3J5IHRoZW1z ZWx2ZXMgYnkgaW1wbGVtZW50aW5nIFRBUkdFVF9NRU1PUllfVEFHIGFuZCBh dm9pZGluZyB0aGUKKyAgIGJhY2tncm91bmQgc3RhY2sgY29sb3VyIGF1dG9t YXRpY2FsbHkgaW4gdGhlIGFkZHRhZyBwYXR0ZXJuLiAgKi8KKyNpZm5kZWYg SEFSRFdBUkVfTUVNT1JZX1RBR0dJTkcKKyNkZWZpbmUgSEFSRFdBUkVfTUVN T1JZX1RBR0dJTkcgMAorI2VuZGlmCisKICNpZmRlZiBHQ0NfSU5TTl9GTEFH U19ICiAvKiBEZXBlbmRlbnQgZGVmYXVsdCB0YXJnZXQgbWFjcm8gZGVmaW5p dGlvbnMKIApkaWZmIC0tZ2l0IGEvZ2NjL2RvYy90bS50ZXhpIGIvZ2NjL2Rv Yy90bS50ZXhpCmluZGV4IDY3ZDc5YTIzNzk5Y2QzMDU3ZjdkOTFiZDUzOGM3 ZWU3NmM4MzZmODIuLjdmMGNjMjU3YTY2MzRlM2IwYTIwMTNiN2ZiOWZmYTQw ODNmMTkwMzggMTAwNjQ0Ci0tLSBhL2djYy9kb2MvdG0udGV4aQorKysgYi9n Y2MvZG9jL3RtLnRleGkKQEAgLTI5NjgsNiArMjk2OCwzMCBAQCBUaGlzIGhv b2sgZGVmaW5lcyB0aGUgbWFjaGluZSBtb2RlIHRvIHVzZSBmb3IgdGhlIGJv b2xlYW4gcmVzdWx0IG9mICBjb25kaXRpb25hbAogQSB0YXJnZXQgaG9vayB3 aGljaCBsZXRzIGEgYmFja2VuZCBjb21wdXRlIHRoZSBzZXQgb2YgcHJlc3N1 cmUgY2xhc3NlcyB0byAgYmUgdXNlZCBieSB0aG9zZSBvcHRpbWl6YXRpb24g cGFzc2VzIHdoaWNoIHRha2UgcmVnaXN0ZXIgcHJlc3N1cmUgaW50byAgYWNj b3VudCwgYXMgb3Bwb3NlZCB0byBsZXR0aW5nIElSQSBjb21wdXRlIHRoZW0u ICBJdCByZXR1cm5zIHRoZSBudW1iZXIgb2YgIHJlZ2lzdGVyIGNsYXNzZXMg c3RvcmVkIGluIHRoZSBhcnJheSBAdmFye3ByZXNzdXJlX2NsYXNzZXN9Lgog QGVuZCBkZWZ0eXBlZm4KIAorQGRlZnR5cGVmbiB7VGFyZ2V0IEhvb2t9IHVp bnQ4X3QgVEFSR0VUX01FTVRBR19UQUdfU0laRSAoKQorUmV0dXJuIHRoZSBz aXplIGluIGJpdHMgb2YgYSB0YWcgZm9yIHRoaXMgcGxhdGZvcm0uCitAZW5k IGRlZnR5cGVmbgorCitAZGVmdHlwZWZuIHtUYXJnZXQgSG9va30gdWludDhf dCBUQVJHRVRfTUVNVEFHX0dSQU5VTEVfU0laRSAoKQorUmV0dXJuIGhvdyBt YW55IGJ5dGVzIGluIHJlYWwgbWVtb3J5IGVhY2ggYnl0ZSBpbiBzaGFkb3cg bWVtb3J5IHJlcHJlc2VudHMuCitJLmUuIG9uZSBieXRlIGluIHNoYWRvdyBt ZW1vcnkgYmVpbmcgY29sb3VyIDEgaW1wbGllcyB0aGUgYXNzb2NhaWF0ZWQK K3RhcmdldG0ubWVtdGFnLmdyYW51bGVfc2l6ZSAoKSBieXRlcyBpbiByZWFs IG1lbW9yeSBtdXN0IGFsbCBiZSBhY2Nlc3NlZCBieQorcG9pbnRlcnMgdGFn Z2VkIGFzIDEuCitAZW5kIGRlZnR5cGVmbgorCitAZGVmdHlwZWZuIHtUYXJn ZXQgSG9va30gdm9pZCBUQVJHRVRfTUVNVEFHX0NPUFlfVEFHIChydHggQHZh cnt0b30sIHJ0eCBAdmFye2Zyb219KQorRW1pdCBpbnNucyB0byBjb3B5IHRo ZSB0YWcgaW4gRlJPTSB0byBUTy4KK0BlbmQgZGVmdHlwZWZuCisKK0BkZWZ0 eXBlZm4ge1RhcmdldCBIb29rfSB2b2lkIFRBUkdFVF9NRU1UQUdfVEFHIChy dHggQHZhcnt0YWdnZWRfc3RhcnR9LCBwb2x5X2ludDY0IEB2YXJ7YWRkcmVz c19vZmZzZXR9LCB1aW50OF90IEB2YXJ7dGFnX29mZnNldH0sIHJ0eCBAdmFy e3NpemV9KQorVGhpcyBmdW5jdGlvbiBzaG91bGQgZW1pdCBhbiBSVFggdG8g Y29sb3VyIG1lbW9yeS4KK0l0J3MgZ2l2ZW4gYXJndW1lbnRzIFRBR0dFRF9T VEFSVCwgQUREUkVTU19PRkZTRVQsIFRBR19PRkZTRVQsIFNJWkUsIHdoZXJl CitUQUdHRURfU1RBUlQgYW5kIFNJWkUgYXJlIFJUTCBleHByZXNzaW9ucywg QUREUkVTU19PRkZTRVQgaXMgYSBwb2x5X2ludDY0CithbmQgVEFHX09GRlNF VCBpcyBhIHVpbnQ4X3QuCitJdCBzaG91bGQgZW1pdCBSVEwgdG8gY29sb3Vy ICJzaGFkb3cgbWVtb3J5IiBmb3IgdGhlIHJlbGV2YW50IHJhbmdlIHRoZQor Y29sb3VyIG9mIHRoZSB0YWcgaXQgd2FzIGdpdmVuLgorQGVuZCBkZWZ0eXBl Zm4KKwogQGRlZnR5cGVmbiB7VGFyZ2V0IEhvb2t9IHZvaWQgVEFSR0VUX01F TVRBR19HRU5UQUcgKHJ0eCBAdmFye2Jhc2V9LCBydHggQHZhcnt1bnRhZ2dl ZH0pCiBTZXQgdGhlIEJBU0UgYXJndW1lbnQgdG8gVU5UQUdHRUQgd2l0aCBz b21lIHJhbmRvbSB0YWcuCiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gZ2Vu ZXJhdGUgYSB0YWdnZWQgYmFzZSBmb3IgdGhlIGN1cnJlbnQgc3RhY2sgZnJh bWUuCmRpZmYgLS1naXQgYS9nY2MvZG9jL3RtLnRleGkuaW4gYi9nY2MvZG9j L3RtLnRleGkuaW4KaW5kZXggZTFlYzUwM2JlZmFkYjQwNjFmYmQzYjk1ZTU1 NzU3ZmUyMmQzM2MzOS4uNmM3N2MwOWZjYTE2MWRjM2FkZTk4ZDgxYjE2YzFi MDFhZjNjMGJjNyAxMDA2NDQKLS0tIGEvZ2NjL2RvYy90bS50ZXhpLmluCisr KyBiL2djYy9kb2MvdG0udGV4aS5pbgpAQCAtMjM3MCw2ICsyMzcwLDE0IEBA IGluIHRoZSByZWxvYWQgcGFzcy4KIAogQGhvb2sgVEFSR0VUX0NPTVBVVEVf UFJFU1NVUkVfQ0xBU1NFUwogCitAaG9vayBUQVJHRVRfTUVNVEFHX1RBR19T SVpFCisKK0Bob29rIFRBUkdFVF9NRU1UQUdfR1JBTlVMRV9TSVpFCisKK0Bo b29rIFRBUkdFVF9NRU1UQUdfQ09QWV9UQUcKKworQGhvb2sgVEFSR0VUX01F TVRBR19UQUcKKwogQGhvb2sgVEFSR0VUX01FTVRBR19HRU5UQUcKIAogQG5v ZGUgU3RhY2sgYW5kIENhbGxpbmcKZGlmZiAtLWdpdCBhL2djYy9pbnRlcm5h bC1mbi5jIGIvZ2NjL2ludGVybmFsLWZuLmMKaW5kZXggYzUzMGZlODk1MWMz MDk4N2M4NzRkZjgzZTc0YmU2ZDA1ODczMDEzNC4uYTU4YTU1YWQ1OWIyYWQ3 YTZiOTNlMmY1ZjJiYmI0MGI4ZGE1MWM1ZSAxMDA2NDQKLS0tIGEvZ2NjL2lu dGVybmFsLWZuLmMKKysrIGIvZ2NjL2ludGVybmFsLWZuLmMKQEAgLTUwMyw5 ICs1MDMsNiBAQCBleHBhbmRfSFdBU0FOX01BUksgKGludGVybmFsX2ZuLCBn Y2FsbCAqZ2MpCiAgIGdjY19jaGVja2luZ19hc3NlcnQgKFRSRUVfQ09ERSAo YmFzZSkgPT0gQUREUl9FWFBSKTsKICAgcnR4IGJhc2VfcnR4ID0gZXhwYW5k X25vcm1hbCAoYmFzZSk7CiAKLSAgcnR4IHRhZyA9IGlzX3BvaXNvbiA/IGNv bnN0MF9ydHggOiBod2FzYW5fZXh0cmFjdF90YWcgKGJhc2VfcnR4KTsKLSAg cnR4IGFkZHJlc3MgPSBod2FzYW5fY3JlYXRlX3VudGFnZ2VkX2Jhc2UgKGJh c2VfcnR4KTsKLQogICB0cmVlIGxlbiA9IGdpbXBsZV9jYWxsX2FyZyAoZ2Ms IDIpOwogICBnY2NfYXNzZXJ0ICh0cmVlX2ZpdHNfc2h3aV9wIChsZW4pKTsK ICAgdW5zaWduZWQgSE9TVF9XSURFX0lOVCBzaXplX2luX2J5dGVzID0gdHJl ZV90b19zaHdpIChsZW4pOwpAQCAtNTE1LDEzICs1MTIsMjQgQEAgZXhwYW5k X0hXQVNBTl9NQVJLIChpbnRlcm5hbF9mbiwgZ2NhbGwgKmdjKQogICBydHgg c2l6ZSA9IGdlbl9pbnRfbW9kZSAoc2l6ZV9pbl9ieXRlcywgUG1vZGUpOwog CiAgIC8qIFRPRE8gT3RoZXIgb3B0aW9ucyAoaS5lLiBpbmxpbmUgb3B0aW9u cykgICovCi0gIHJ0eCBmdW5jID0gaW5pdF9vbmVfbGliZnVuYyAoIl9faHdh c2FuX3RhZ19tZW1vcnkiKTsKLSAgZW1pdF9saWJyYXJ5X2NhbGwgKGZ1bmMs Ci0gICAgICBMQ1RfTk9STUFMLAotICAgICAgVk9JRG1vZGUsCi0gICAgICBh ZGRyZXNzLCBwdHJfbW9kZSwKLSAgICAgIHRhZywgUUltb2RlLAotICAgICAg c2l6ZSwgcHRyX21vZGUpOworICBpZiAoISBIQVJEV0FSRV9NRU1PUllfVEFH R0lORyApCisgICAgeworICAgICAgcnR4IGZ1bmMgPSBpbml0X29uZV9saWJm dW5jICgiX19od2FzYW5fdGFnX21lbW9yeSIpOworICAgICAgcnR4IGFkZHJl c3MgPSBod2FzYW5fY3JlYXRlX3VudGFnZ2VkX2Jhc2UgKGJhc2VfcnR4KTsK KyAgICAgIHJ0eCB0YWcgPSBpc19wb2lzb24gPyBjb25zdDBfcnR4IDogaHdh c2FuX2V4dHJhY3RfdGFnIChiYXNlX3J0eCk7CisgICAgICBlbWl0X2xpYnJh cnlfY2FsbCAoZnVuYywKKwkJCSBMQ1RfTk9STUFMLAorCQkJIFZPSURtb2Rl LAorCQkJIGFkZHJlc3MsIHB0cl9tb2RlLAorCQkJIHRhZywgUUltb2RlLAor CQkJIHNpemUsIHB0cl9tb2RlKTsKKyAgICB9CisgIGVsc2UKKyAgICB7Cisg ICAgICBpZiAoaXNfcG9pc29uKQorCXRhcmdldG0ubWVtdGFnLmNvcHlfdGFn IChiYXNlX3J0eCwgc3RhY2tfcG9pbnRlcl9ydHgpOworICAgICAgdGFyZ2V0 bS5tZW10YWcudGFnIChiYXNlX3J0eCwgMCwgMCwgc2l6ZSk7CisgICAgfQog fQogCiAvKiBUaGlzIHNob3VsZCBnZXQgZXhwYW5kZWQgaW4gdGhlIHNhbm9w dCBwYXNzLiAgKi8KZGlmZiAtLWdpdCBhL2djYy90YXJnZXQuZGVmIGIvZ2Nj L3RhcmdldC5kZWYKaW5kZXggNTMyNmNiMDcwZGVjNzhmMTliZmUwODQ0YTlk NWU1MGM2OWU3ZGNjMS4uZTBjNTQzMjU0NTM4YzgwMmUxZTBhMDU5ZTFhM2U2 MGEwNDVhMGNkZiAxMDA2NDQKLS0tIGEvZ2NjL3RhcmdldC5kZWYKKysrIGIv Z2NjL3RhcmdldC5kZWYKQEAgLTY3MDksNiArNjcwOSwzNCBAQCBIT09LX1ZF Q1RPUl9FTkQgKG1vZGVfc3dpdGNoaW5nKQogSE9PS19WRUNUT1IgKFRBUkdF VF9NRU1UQUdfLCBtZW10YWcpCiAKIERFRkhPT0sKKyh0YWdfc2l6ZSwKKyAi UmV0dXJuIHRoZSBzaXplIGluIGJpdHMgb2YgYSB0YWcgZm9yIHRoaXMgcGxh dGZvcm0uIiwKKyB1aW50OF90LCAoKSwgZGVmYXVsdF9tZW10YWdfdGFnX3Np emUpCisKK0RFRkhPT0sKKyhncmFudWxlX3NpemUsCisgIlJldHVybiBob3cg bWFueSBieXRlcyBpbiByZWFsIG1lbW9yeSBlYWNoIGJ5dGUgaW4gc2hhZG93 IG1lbW9yeSByZXByZXNlbnRzLlxuXAorSS5lLiBvbmUgYnl0ZSBpbiBzaGFk b3cgbWVtb3J5IGJlaW5nIGNvbG91ciAxIGltcGxpZXMgdGhlIGFzc29jYWlh dGVkXG5cCit0YXJnZXRtLm1lbXRhZy5ncmFudWxlX3NpemUgKCkgYnl0ZXMg aW4gcmVhbCBtZW1vcnkgbXVzdCBhbGwgYmUgYWNjZXNzZWQgYnlcblwKK3Bv aW50ZXJzIHRhZ2dlZCBhcyAxLiIsCit1aW50OF90LCAoKSwgZGVmYXVsdF9t ZW10YWdfZ3JhbnVsZV9zaXplKQorCitERUZIT09LCisoY29weV90YWcsCisg IkVtaXQgaW5zbnMgdG8gY29weSB0aGUgdGFnIGluIEZST00gdG8gVE8uIiwK K3ZvaWQsIChydHggdG8sIHJ0eCBmcm9tKSwgZGVmYXVsdF9tZW10YWdfY29w eV90YWcpCisKK0RFRkhPT0sKKyh0YWcsCisgIlRoaXMgZnVuY3Rpb24gc2hv dWxkIGVtaXQgYW4gUlRYIHRvIGNvbG91ciBtZW1vcnkuXG5cCitJdCdzIGdp dmVuIGFyZ3VtZW50cyBUQUdHRURfU1RBUlQsIEFERFJFU1NfT0ZGU0VULCBU QUdfT0ZGU0VULCBTSVpFLCB3aGVyZVxuXAorVEFHR0VEX1NUQVJUIGFuZCBT SVpFIGFyZSBSVEwgZXhwcmVzc2lvbnMsIEFERFJFU1NfT0ZGU0VUIGlzIGEg cG9seV9pbnQ2NFxuXAorYW5kIFRBR19PRkZTRVQgaXMgYSB1aW50OF90Llxu XAorSXQgc2hvdWxkIGVtaXQgUlRMIHRvIGNvbG91ciBcInNoYWRvdyBtZW1v cnlcIiBmb3IgdGhlIHJlbGV2YW50IHJhbmdlIHRoZVxuXAorY29sb3VyIG9m IHRoZSB0YWcgaXQgd2FzIGdpdmVuLiIsCisgIHZvaWQsIChydHggdGFnZ2Vk X3N0YXJ0LCBwb2x5X2ludDY0IGFkZHJlc3Nfb2Zmc2V0LCB1aW50OF90IHRh Z19vZmZzZXQsIHJ0eCBzaXplKSwgTlVMTCkKKworREVGSE9PSwogKGdlbnRh ZywKICAiU2V0IHRoZSBCQVNFIGFyZ3VtZW50IHRvIFVOVEFHR0VEIHdpdGgg c29tZSByYW5kb20gdGFnLlxuXAogVGhpcyBmdW5jdGlvbiBpcyB1c2VkIHRv IGdlbmVyYXRlIGEgdGFnZ2VkIGJhc2UgZm9yIHRoZSBjdXJyZW50IHN0YWNr IGZyYW1lLiIsCmRpZmYgLS1naXQgYS9nY2MvdGFyZ2hvb2tzLmggYi9nY2Mv dGFyZ2hvb2tzLmgKaW5kZXggNDkzZmYzYmIyOTI2M2Y4MzYwYmVhMGY3ZWFk MTA5MmI0ZDBjNjQ2YS4uMWMwOWJiYWQ5NjRiNzcwNWVlYTQ5M2E4MjhkNTkw NmFkMDc0ODFiNiAxMDA2NDQKLS0tIGEvZ2NjL3Rhcmdob29rcy5oCisrKyBi L2djYy90YXJnaG9va3MuaApAQCAtMjg4LDUgKzI4OCw4IEBAIGV4dGVybiBy dHggZGVmYXVsdF9zcGVjdWxhdGlvbl9zYWZlX3ZhbHVlIChtYWNoaW5lX21v ZGUsIHJ0eCwgcnR4LCBydHgpOwogZXh0ZXJuIHZvaWQgZGVmYXVsdF9yZW1v dmVfZXh0cmFfY2FsbF9wcmVzZXJ2ZWRfcmVncyAocnR4X2luc24gKiwKIAkJ CQkJCSAgICAgIEhBUkRfUkVHX1NFVCAqKTsKIAorZXh0ZXJuIHVpbnQ4X3Qg ZGVmYXVsdF9tZW10YWdfdGFnX3NpemUgKCk7CitleHRlcm4gdWludDhfdCBk ZWZhdWx0X21lbXRhZ19ncmFudWxlX3NpemUgKCk7CiBleHRlcm4gdm9pZCBk ZWZhdWx0X21lbXRhZ19nZW50YWcgKHJ0eCwgcnR4KTsKK2V4dGVybiB2b2lk IGRlZmF1bHRfbWVtdGFnX2NvcHlfdGFnIChydHgsIHJ0eCk7CiAjZW5kaWYg LyogR0NDX1RBUkdIT09LU19IICovCmRpZmYgLS1naXQgYS9nY2MvdGFyZ2hv b2tzLmMgYi9nY2MvdGFyZ2hvb2tzLmMKaW5kZXggNThlYzcxMWNlODFlZTY3 ZDY5MmU4MWQyNjE2YmQzNDIyZjZiZDA5Mi4uYmYwNzgyOTVjYmQ5NTE0Nzc4 NDU0Y2VmNzc1ZGQyODhmZDUwMjY0MSAxMDA2NDQKLS0tIGEvZ2NjL3Rhcmdo b29rcy5jCisrKyBiL2djYy90YXJnaG9va3MuYwpAQCAtNzAsNiArNzAsNyBA QCBhbG9uZyB3aXRoIEdDQzsgc2VlIHRoZSBmaWxlIENPUFlJTkczLiAgSWYg bm90IHNlZQogI2luY2x1ZGUgInZhcmFzbS5oIgogI2luY2x1ZGUgImZsYWdz LmgiCiAjaW5jbHVkZSAiZXhwbG93LmgiCisjaW5jbHVkZSAiZXhwbWVkLmgi CiAjaW5jbHVkZSAiY2FsbHMuaCIKICNpbmNsdWRlICJleHByLmgiCiAjaW5j bHVkZSAib3V0cHV0LmgiCkBAIC04Myw2ICs4NCw4IEBAIGFsb25nIHdpdGgg R0NDOyBzZWUgdGhlIGZpbGUgQ09QWUlORzMuICBJZiBub3Qgc2VlCiAjaW5j bHVkZSAicmVhbC5oIgogI2luY2x1ZGUgImxhbmdob29rcy5oIgogI2luY2x1 ZGUgInNiaXRtYXAuaCIKKyNpbmNsdWRlICJhdHRyaWJzLmgiCisjaW5jbHVk ZSAiYXNhbi5oIgogCiBib29sCiBkZWZhdWx0X2xlZ2l0aW1hdGVfYWRkcmVz c19wIChtYWNoaW5lX21vZGUgbW9kZSBBVFRSSUJVVEVfVU5VU0VELApAQCAt MjM5MSw2ICsyMzk0LDE4IEBAIGRlZmF1bHRfcmVtb3ZlX2V4dHJhX2NhbGxf cHJlc2VydmVkX3JlZ3MgKHJ0eF9pbnNuICosIEhBUkRfUkVHX1NFVCAqKQog ewogfQogCit1aW50OF90CitkZWZhdWx0X21lbXRhZ190YWdfc2l6ZSAoKQor eworICByZXR1cm4gNDsKK30KKwordWludDhfdAorZGVmYXVsdF9tZW10YWdf Z3JhbnVsZV9zaXplICgpCit7CisgIHJldHVybiAxVUxMIDw8IGRlZmF1bHRf bWVtdGFnX3RhZ19zaXplICgpOworfQorCiB2b2lkCiBkZWZhdWx0X21lbXRh Z19nZW50YWcgKHJ0eCBiYXNlLCBydHggdW50YWdnZWQpCiB7CkBAIC0yNDAy LDUgKzI0MTcsNDAgQEAgZGVmYXVsdF9tZW10YWdfZ2VudGFnIChydHggYmFz ZSwgcnR4IHVudGFnZ2VkKQogICBlbWl0X21vdmVfaW5zbiAoYmFzZSwgdW50 YWdnZWQpOwogfQogCit2b2lkCitkZWZhdWx0X21lbXRhZ19jb3B5X3RhZyAo cnR4IHRvLCBydHggZnJvbSkKK3sKKyAgLyogVE9ETzogRm9yIEFBcmNoNjQg dGhpcyBjYW4gY2F1c2UgYSBwcm9ibGVtIGluIExSQSBpZiB0aGUgYHRvYAor ICAgICBSVFggZXZlbnR1YWxseSByZXNvbHZlcyB0byBiZWluZyB0aGUgc3Rh Y2sgcG9pbnRlci4KKyAgICAgVGhpcyBoYXBwZW5zIGJlY2F1c2UgdGhlIGlu c3RydWN0aW9uIHRoYXQgZ2V0cyBlbWl0dGVkIGZyb20KKyAgICAgYHN0b3Jl X2JpdF9maWVsZGAgY29ycmVzcG9uZHMgdG8gYSBwYXR0ZXJuIHRoYXQgY2Fu J3QgaGFuZGxlIHRoZSBzdGFjaworICAgICBwb2ludGVyIGFuZCBMUkEgY2Fu J3QgZmlndXJlIG91dCB0byB1c2UgYSB0ZW1wb3JhcnkgcmVnaXN0ZXIgaW4g dGhlIGBiZmlgCisgICAgIGluc3RydWN0aW9uJ3MgcGxhY2UuCisKKyAgICAg VGhpcyBkb2Vzbid0IGNhdXNlIGEgcHJvYmxlbSBhdCB0aGUgbW9tZW50IHNp bmNlIHRoZXJlJ3MgY3VycmVudGx5IG5vIHdheQorICAgICB0aGUgc3RhY2sg cG9pbnRlciBzaG91bGQgYmUgZ2l2ZW4gdG8gdGhpcyBmdW5jdGlvbi4gIFRo ZSBob29rIGlzIG9ubHkgdXNlZAorICAgICB3aGVuIHBvaXNvbmluZyB2YXJp YWJsZXMgd2l0aCBIV0FTQU5fTUFSSywgYW5kIGluIHRoYXQgZnVuY3Rpb24g dGhlIGB0b2AKKyAgICAgUlRYIHNob3VsZCBhbHdheXMgYmUgcG9pbnRpbmcg dG8gYSB0YWdnZWQgdmFyaWFibGUgb24gdGhlIHN0YWNrIChzaW5jZQorICAg ICB0aGUgdmFyaWFibGUgaXMgdGFnZ2VkIGl0IGNhbid0IGJlIHRoZSBzdGFj ayBwb2ludGVyIHNpbmNlIHRoYXQgaXMKKyAgICAgdW50YWdnZWQpLgorCisg ICAgIEV2ZW50dWFsbHkgd2Ugd2lsbCBiZSBnZW5lcmF0aW5nIHJhbmRvbSB0 YWdzIGFzIHRoZSAic3RhcnQiIHRhZyBmb3IgZWFjaAorICAgICBmcmFtZS4g IFdoZW4gdGhpcyBoYXBwZW5zIHdlIGNhbiBubyBsb25nZXIgYXZvaWQgdGhl IGJhY2tncm91bmQgY29sb3VyIGF0CisgICAgIGNvbXBpbGUgdGltZSBzaW5j ZSB3ZSB3aWxsIG5vdCBrbm93IHdoYXQgb2Zmc2V0IHRvIGF2b2lkLgorICAg ICBUaGlzIHdpbGwgbWVhbiB3ZSBubyBsb25nZXIgYXZvaWQgYSBgdGFnX29m ZnNldGAgb2YgMCwgYW5kIGhlbmNlCisgICAgIGBod2FzYW5fd2l0aF90YWdg IGNvdWxkIGVtaXQgc2ltcGxlIFBMVVMgc3RhdGVtZW50cy4KKworICAgICBX aGVuIHRoYXQgaGFwcGVucywgdGhlIGxhc3QgdmFyaWFibGUgb24gdGhlIHN0 YWNrIGNvdWxkIHZlcnkgd2VsbCBoYXZlCisgICAgIGEgemVybyB0YWcgb2Zm c2V0IGFuZCBzb21ld2hlcmUgZWxzZSBpbiB0aGUgY29tcGlsZXIgY291bGQg b3B0aW1pc2UgdGhhdAorICAgICB0byBzaW1wbHkgdXNlIHRoZSBzdGFjayBw b2ludGVyLgorCisgICAgIFRoYXQgd291bGQgdHJpZ2dlciBhbiBJQ0UgZHVl IHRvIExSQSBiZWluZyB1bmFibGUgdG8gcmVsb2FkIHRoZQorICAgICBgaW5z dl9yZWdkaWAgcGF0dGVybi4KKworICAgICBUaGlzIGlzIGFub3RoZXIgdGhp bmcgdGhhdCBuZWVkcyB0byBiZSBmaXhlZCBidXQgSSdsbCBkZWFsIHdpdGgg bGF0ZXIuICAqLworICBydHggdGVtcCA9IGh3YXNhbl9leHRyYWN0X3RhZyAo ZnJvbSk7CisgIHN0b3JlX2JpdF9maWVsZCAodG8sIDgsIDU2LCAwLCAwLAor CQkgICBRSW1vZGUsIHRlbXAsIGZhbHNlKTsKK30KIAogI2luY2x1ZGUgImd0 LXRhcmdob29rcy5oIgoK --_002_VI1PR08MB5471CA3016166350102AE8D4E0BA0VI1PR08MB5471eurp_--