From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ot1-x334.google.com (mail-ot1-x334.google.com [IPv6:2607:f8b0:4864:20::334]) by sourceware.org (Postfix) with ESMTPS id 2B7C93858025 for ; Thu, 28 Jan 2021 18:58:17 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 2B7C93858025 Received: by mail-ot1-x334.google.com with SMTP id i30so6209123ota.6 for ; Thu, 28 Jan 2021 10:58:17 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=BzVLjXd9NopDjntHdUj9vhi2RZSrmz4WCrTOnHybZn8=; b=lCbT3kakU0PRT4Hto5/9FeU84gtRIY6yyKw9fAOGiEcJWpXRp1EJqFrXa2FaSPEpuD kPIdXIK6qAEikJUmh8mT2wvp1gZtN++pL9+qU8uEVZsB9bfh8zmfDKTi+7X3MN/cXYRe 45A4xXvgnKqjYIgVj1WiU1BgeYg1AjEJ4FSOdCW+Chawhp8FqUvcHIV7VgHDOVAPaWSJ Wdk03mQXYE2pLa2rul0bjinHgzTtILXdkbggLTjuc7nC9Nmesk+vEw+XEG0/OK0Av2lC ksqFMxS1V5LeHIa4IfXFfdO5LevDNTYlgQBokRMC6PXwCP6NBDlKkWAWlQcfDSWao+eU 6+rA== X-Gm-Message-State: AOAM533F13DAlNOx5SyT/9BaTgr8axICE3UOTKxBrc077ju4rxDiy7B7 VOmMPFrJfBRrxCZKXBPrh4Y8QlYSEG9tBHlCZsg= X-Google-Smtp-Source: ABdhPJyrQrFXv03F3Dw0n1K4EsANFTrfnvnhWPqQEQXK+KVHAIKBZwZnvtjOWFG8QGmxeTl6X+ZJPtOYRNaWtC39RpQ= X-Received: by 2002:a9d:4786:: with SMTP id b6mr570792otf.269.1611860295863; Thu, 28 Jan 2021 10:58:15 -0800 (PST) MIME-Version: 1.0 References: <20210127122702.3044784-1-hjl.tools@gmail.com> <17c201f1-fbab-a603-1c24-6bca65d5cf78@linaro.org> In-Reply-To: <17c201f1-fbab-a603-1c24-6bca65d5cf78@linaro.org> From: "H.J. Lu" Date: Thu, 28 Jan 2021 10:57:39 -0800 Message-ID: Subject: V2 [PATCH] x86: Properly set usable CET feature bits [BZ #26625] To: Adhemerval Zanella Cc: GNU C Library , Florian Weimer , "Carlos O'Donell" Content-Type: multipart/mixed; boundary="0000000000005cf24205b9fa78ff" X-Spam-Status: No, score=-3035.9 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_LOTSOFHASH, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 28 Jan 2021 18:58:20 -0000 --0000000000005cf24205b9fa78ff Content-Type: text/plain; charset="UTF-8" On Thu, Jan 28, 2021 at 9:51 AM Adhemerval Zanella wrote: > > > > On 27/01/2021 09:27, H.J. Lu wrote: > > commit 94cd37ebb293321115a36a422b091fdb72d2fb08 > > Author: H.J. Lu > > Date: Wed Sep 16 05:27:32 2020 -0700 > > > > x86: Use HAS_CPU_FEATURE with IBT and SHSTK [BZ #26625] > > > > broke > > > > GLIBC_TUNABLES=glibc.cpu.hwcaps=-IBT,-SHSTK > > > > since it can no longer disable IBT nor SHSTK. Handle IBT and SHSTK with: > > > > 1. Revert commit 94cd37ebb293321115a36a422b091fdb72d2fb08. > > 2. Clears the usable CET feature bits if kernel doesn't support CET. > > 3. Add GLIBC_TUNABLES tests without dlopen. > > 4. Add tests to verify that CPU_FEATURE_USABLE on IBT and SHSTK matches > > _get_ssp. > > 5. Update GLIBC_TUNABLES tests with dlopen to verify that CET is disabled > > with GLIBC_TUNABLES. > > Patch looks ok with some minot nit below, but I am kind worried it would > require a lot of x86 testing where there are already results posted on > release wiki. I have tested the fixed glibc on i686, x32, x86-64 with --enable-cet on Tiger Lake and legacy CPU. There are no differences in test results. > Carlos and Florian, what do you think? Should we push it for the 2.33 release > on backport on the release branch? I prefer to fix it for glibc 2.33. It has happened multiple times to me when I need $ export GLIBC_TUNABLES=glibc.cpu.hwcaps=-IBT,-SHSTK to update OS on Tiger Lake. > > --- > > sysdeps/x86/Makefile | 8 ++++- > > sysdeps/x86/cpu-features.c | 11 +++++-- > > sysdeps/x86/dl-cet.c | 4 +-- > > sysdeps/x86/tst-cet-legacy-10-static.c | 1 + > > sysdeps/x86/tst-cet-legacy-10.c | 43 ++++++++++++++++++++++++++ > > sysdeps/x86/tst-cet-legacy-5.c | 11 ++++--- > > sysdeps/x86/tst-cet-legacy-6.c | 11 ++++--- > > sysdeps/x86/tst-cet-legacy-9-static.c | 1 + > > sysdeps/x86/tst-cet-legacy-9.c | 41 ++++++++++++++++++++++++ > > sysdeps/x86/tst-get-cpu-features.c | 2 ++ > > 10 files changed, 120 insertions(+), 13 deletions(-) > > create mode 100644 sysdeps/x86/tst-cet-legacy-10-static.c > > create mode 100644 sysdeps/x86/tst-cet-legacy-10.c > > create mode 100644 sysdeps/x86/tst-cet-legacy-9-static.c > > create mode 100644 sysdeps/x86/tst-cet-legacy-9.c > > > > diff --git a/sysdeps/x86/Makefile b/sysdeps/x86/Makefile > > index 7549507a9a..dd82674342 100644 > > --- a/sysdeps/x86/Makefile > > +++ b/sysdeps/x86/Makefile > > @@ -82,7 +82,9 @@ sysdep-dl-routines += dl-cet > > tests += tst-cet-legacy-1 tst-cet-legacy-1a tst-cet-legacy-2 \ > > tst-cet-legacy-2a tst-cet-legacy-3 tst-cet-legacy-4 \ > > tst-cet-legacy-5a tst-cet-legacy-6a tst-cet-legacy-7 \ > > - tst-cet-legacy-8 > > + tst-cet-legacy-8 tst-cet-legacy-9 tst-cet-legacy-9-static \ > > + tst-cet-legacy-10 tst-cet-legacy-10-static > > +tests-static += tst-cet-legacy-9-static tst-cet-legacy-10-static > > Do we need to stat the static variant to 'tests' rule as well? I always add the static variants to 'tests'. > > tst-cet-legacy-1a-ARGS = -- $(host-test-program-cmd) > > ifneq (no,$(have-tunables)) > > tests += tst-cet-legacy-4a tst-cet-legacy-4b tst-cet-legacy-4c \ > > @@ -123,6 +125,8 @@ CFLAGS-tst-cet-legacy-mod-6b.c += -fcf-protection > > CFLAGS-tst-cet-legacy-mod-6c.c += -fcf-protection > > CFLAGS-tst-cet-legacy-7.c += -fcf-protection=none > > CFLAGS-tst-cet-legacy-8.c += -mshstk > > +CFLAGS-tst-cet-legacy-10.c += -mshstk > > +CFLAGS-tst-cet-legacy-10-static.c += -mshstk > > > > $(objpfx)tst-cet-legacy-1: $(objpfx)tst-cet-legacy-mod-1.so \ > > $(objpfx)tst-cet-legacy-mod-2.so > > Ok. > > > @@ -163,6 +167,8 @@ $(objpfx)tst-cet-legacy-6b: $(libdl) > > $(objpfx)tst-cet-legacy-6b.out: $(objpfx)tst-cet-legacy-mod-6a.so \ > > $(objpfx)tst-cet-legacy-mod-6b.so > > tst-cet-legacy-6b-ENV = GLIBC_TUNABLES=glibc.cpu.hwcaps=-IBT,-SHSTK > > +tst-cet-legacy-9-ENV = GLIBC_TUNABLES=glibc.cpu.hwcaps=-IBT,-SHSTK > > +tst-cet-legacy-9-static-ENV = GLIBC_TUNABLES=glibc.cpu.hwcaps=-IBT,-SHSTK > > endif > > endif > > > > Ok. > > > diff --git a/sysdeps/x86/cpu-features.c b/sysdeps/x86/cpu-features.c > > index 6496512a0d..73b0a4dc9a 100644 > > --- a/sysdeps/x86/cpu-features.c > > +++ b/sysdeps/x86/cpu-features.c > > @@ -75,6 +75,7 @@ update_usable (struct cpu_features *cpu_features) > > CPU_FEATURE_SET_USABLE (cpu_features, PREFETCHWT1); > > CPU_FEATURE_SET_USABLE (cpu_features, OSPKE); > > CPU_FEATURE_SET_USABLE (cpu_features, WAITPKG); > > + CPU_FEATURE_SET_USABLE (cpu_features, SHSTK); > > CPU_FEATURE_SET_USABLE (cpu_features, GFNI); > > CPU_FEATURE_SET_USABLE (cpu_features, RDPID); > > CPU_FEATURE_SET_USABLE (cpu_features, RDRAND); > > @@ -84,6 +85,7 @@ update_usable (struct cpu_features *cpu_features) > > CPU_FEATURE_SET_USABLE (cpu_features, FSRM); > > CPU_FEATURE_SET_USABLE (cpu_features, SERIALIZE); > > CPU_FEATURE_SET_USABLE (cpu_features, TSXLDTRK); > > + CPU_FEATURE_SET_USABLE (cpu_features, IBT); > > CPU_FEATURE_SET_USABLE (cpu_features, LAHF64_SAHF64); > > CPU_FEATURE_SET_USABLE (cpu_features, LZCNT); > > CPU_FEATURE_SET_USABLE (cpu_features, SSE4A); > > Ok. > > > @@ -705,6 +707,11 @@ no_cpuid: > > /* Check CET status. */ > > unsigned int cet_status = get_cet_status (); > > > > + if ((cet_status & GNU_PROPERTY_X86_FEATURE_1_IBT) == 0) > > + CPU_FEATURE_UNSET (cpu_features, IBT) > > + if ((cet_status & GNU_PROPERTY_X86_FEATURE_1_SHSTK) == 0) > > + CPU_FEATURE_UNSET (cpu_features, SHSTK) > > + > > if (cet_status) > > { > > GL(dl_x86_feature_1) = cet_status; > > Ok > > > @@ -720,9 +727,9 @@ no_cpuid: > > GLIBC_TUNABLES=glibc.cpu.hwcaps=-IBT,-SHSTK > > */ > > unsigned int cet_feature = 0; > > - if (!HAS_CPU_FEATURE (IBT)) > > + if (!CPU_FEATURE_USABLE (IBT)) > > cet_feature |= GNU_PROPERTY_X86_FEATURE_1_IBT; > > - if (!HAS_CPU_FEATURE (SHSTK)) > > + if (!CPU_FEATURE_USABLE (SHSTK)) > > cet_feature |= GNU_PROPERTY_X86_FEATURE_1_SHSTK; > > > > if (cet_feature) > > Ok, it is changing the check from 'cpuid' field to 'usable'. > > > diff --git a/sysdeps/x86/dl-cet.c b/sysdeps/x86/dl-cet.c > > index a63b9c7164..c74e577289 100644 > > --- a/sysdeps/x86/dl-cet.c > > +++ b/sysdeps/x86/dl-cet.c > > @@ -77,11 +77,11 @@ dl_cet_check (struct link_map *m, const char *program) > > > > GLIBC_TUNABLES=glibc.cpu.hwcaps=-IBT,-SHSTK > > */ > > - enable_ibt &= (HAS_CPU_FEATURE (IBT) > > + enable_ibt &= (CPU_FEATURE_USABLE (IBT) > > && (enable_ibt_type == cet_always_on > > || (m->l_x86_feature_1_and > > & GNU_PROPERTY_X86_FEATURE_1_IBT) != 0)); > > - enable_shstk &= (HAS_CPU_FEATURE (SHSTK) > > + enable_shstk &= (CPU_FEATURE_USABLE (SHSTK) > > && (enable_shstk_type == cet_always_on > > || (m->l_x86_feature_1_and > > & GNU_PROPERTY_X86_FEATURE_1_SHSTK) != 0)); > > Ok. > > > diff --git a/sysdeps/x86/tst-cet-legacy-10-static.c b/sysdeps/x86/tst-cet-legacy-10-static.c > > new file mode 100644 > > index 0000000000..ecc1208e35 > > --- /dev/null > > +++ b/sysdeps/x86/tst-cet-legacy-10-static.c > > @@ -0,0 +1 @@ > > +#include "tst-cet-legacy-10.c" > > Ok. > > > diff --git a/sysdeps/x86/tst-cet-legacy-10.c b/sysdeps/x86/tst-cet-legacy-10.c > > new file mode 100644 > > index 0000000000..a618557f45 > > --- /dev/null > > +++ b/sysdeps/x86/tst-cet-legacy-10.c > > @@ -0,0 +1,43 @@ > > +/* Check CPU_FEATURE_USABLE on IBT and SHSTK. > > + Copyright (C) 2021 Free Software Foundation, Inc. > > + This file is part of the GNU C Library. > > + > > + The GNU C Library is free software; you can redistribute it and/or > > + modify it under the terms of the GNU Lesser General Public > > + License as published by the Free Software Foundation; either > > + version 2.1 of the License, or (at your option) any later version. > > + > > + The GNU C Library is distributed in the hope that it will be useful, > > + but WITHOUT ANY WARRANTY; without even the implied warranty of > > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > > + Lesser General Public License for more details. > > + > > + You should have received a copy of the GNU Lesser General Public > > + License along with the GNU C Library; if not, see > > + . */ > > + > > +#include > > +#include > > +#include > > +#include > > + > > +/* Check that CPU_FEATURE_USABLE on IBT and SHSTK matches _get_ssp. */ > > + > > +static int > > +do_test (void) > > +{ > > + if (_get_ssp () != 0) > > + { > > + if (CPU_FEATURE_USABLE (IBT) && CPU_FEATURE_USABLE (SHSTK)) > > + return EXIT_SUCCESS; > > + } > > + else > > + { > > + if (!CPU_FEATURE_USABLE (IBT) && !CPU_FEATURE_USABLE (SHSTK)) > > + return EXIT_SUCCESS; > > + } > > + > > + return EXIT_FAILURE; > > +} > > + > > +#include > > Ok. Checking on the _get_ssp documentation the idea is on hardware without CET > support it returns 0, right? Correct. > > diff --git a/sysdeps/x86/tst-cet-legacy-5.c b/sysdeps/x86/tst-cet-legacy-5.c > > index e3efeb1f4e..d870de3eae 100644 > > --- a/sysdeps/x86/tst-cet-legacy-5.c > > +++ b/sysdeps/x86/tst-cet-legacy-5.c > > @@ -37,6 +37,12 @@ do_test_1 (const char *modname, bool fail) > > int (*fp) (void); > > void *h; > > > > + /* NB: dlopen should never fail on non-CET platforms. If SHSTK is > > + disabled, assuming IBT is also disabled. */ > > + bool cet_enabled = _get_ssp () != 0 && !CET_MAYBE_DISABLED; > > + if (!cet_enabled) > > + fail = false; > > + > > h = dlopen (modname, RTLD_LAZY); > > if (h == NULL) > > { > > @@ -53,10 +59,7 @@ do_test_1 (const char *modname, bool fail) > > FAIL_EXIT1 ("cannot open '%s': %s\n", modname, err); > > } > > > > - /* NB: dlopen should never fail on non-CET platforms. If SHSTK is > > - disabled, assuming IBT is also disabled. */ > > - bool cet_enabled = _get_ssp () != 0 && !CET_MAYBE_DISABLED; > > - if (fail && cet_enabled) > > + if (fail) > > FAIL_EXIT1 ("dlopen should have failed\n"); > > > > fp = dlsym (h, "test"); > > Ok. > > > diff --git a/sysdeps/x86/tst-cet-legacy-6.c b/sysdeps/x86/tst-cet-legacy-6.c > > index 44b2ef5c7a..8e82ee2246 100644 > > --- a/sysdeps/x86/tst-cet-legacy-6.c > > +++ b/sysdeps/x86/tst-cet-legacy-6.c > > @@ -37,6 +37,12 @@ do_test_1 (const char *modname, bool fail) > > int (*fp) (void); > > void *h; > > > > + /* NB: dlopen should never fail on non-CET platforms. If SHSTK is > > + disabled, assuming IBT is also disabled. */ > > + bool cet_enabled = _get_ssp () != 0 && !CET_MAYBE_DISABLED; > > + if (!cet_enabled) > > + fail = false; > > + > > h = dlopen (modname, RTLD_LAZY); > > if (h == NULL) > > { > > @@ -53,10 +59,7 @@ do_test_1 (const char *modname, bool fail) > > FAIL_EXIT1 ("cannot open '%s': %s\n", modname, err); > > } > > > > - /* NB: dlopen should never fail on non-CET platforms. If SHSTK is > > - disabled, assuming IBT is also disabled. */ > > - bool cet_enabled = _get_ssp () != 0 && !CET_MAYBE_DISABLED; > > - if (fail && cet_enabled) > > + if (fail) > > FAIL_EXIT1 ("dlopen should have failed\n"); > > > > fp = dlsym (h, "test"); > > Ok. > > > diff --git a/sysdeps/x86/tst-cet-legacy-9-static.c b/sysdeps/x86/tst-cet-legacy-9-static.c > > new file mode 100644 > > index 0000000000..f9a8518b99 > > --- /dev/null > > +++ b/sysdeps/x86/tst-cet-legacy-9-static.c > > @@ -0,0 +1 @@ > > +#include "tst-cet-legacy-9.c" > > Ok. > > > diff --git a/sysdeps/x86/tst-cet-legacy-9.c b/sysdeps/x86/tst-cet-legacy-9.c > > new file mode 100644 > > index 0000000000..2b526c9055 > > --- /dev/null > > +++ b/sysdeps/x86/tst-cet-legacy-9.c > > @@ -0,0 +1,41 @@ > > +/* Check CET compatibility with legacy JIT engine via GLIBC_TUNABLES. > > + Copyright (C) 2021 Free Software Foundation, Inc. > > + This file is part of the GNU C Library. > > + > > + The GNU C Library is free software; you can redistribute it and/or > > + modify it under the terms of the GNU Lesser General Public > > + License as published by the Free Software Foundation; either > > + version 2.1 of the License, or (at your option) any later version. > > + > > + The GNU C Library is distributed in the hope that it will be useful, > > + but WITHOUT ANY WARRANTY; without even the implied warranty of > > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > > + Lesser General Public License for more details. > > + > > + You should have received a copy of the GNU Lesser General Public > > + License along with the GNU C Library; if not, see > > + . */ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +/* Check that mmapped legacy code won't trigger segfault with > > + -fcf-protection and GLIBC_TUNABLES=glibc.cpu.hwcaps=-IBT,-SHSTK. */ > > + > > +static int > > +do_test (void) > > +{ > > + void (*funcp) (void); > > + funcp = xmmap (NULL, 0x1000, PROT_EXEC | PROT_READ | PROT_WRITE, > > + MAP_ANONYMOUS | MAP_PRIVATE, -1); > > Although x86_64 only support 4k page currently (not counting large > pages, but which requires an additional mmap flag anyway), I think it > should use xsysconf (_SC_PAGESIZE) to be future-proof. Fixed. > > + printf ("mmap = %p\n", funcp); > > + /* Write RET instruction. */ > > + *(char *) funcp = 0xc3; > > + funcp (); > > + return EXIT_SUCCESS; > > +} > > + > > +#include > > Ok. > > > diff --git a/sysdeps/x86/tst-get-cpu-features.c b/sysdeps/x86/tst-get-cpu-features.c > > index dcdb86bb93..b5e7f6e7b0 100644 > > --- a/sysdeps/x86/tst-get-cpu-features.c > > +++ b/sysdeps/x86/tst-get-cpu-features.c > > @@ -301,6 +301,7 @@ do_test (void) > > CHECK_CPU_FEATURE_USABLE (OSPKE); > > CHECK_CPU_FEATURE_USABLE (WAITPKG); > > CHECK_CPU_FEATURE_USABLE (AVX512_VBMI2); > > + CHECK_CPU_FEATURE_USABLE (SHSTK); > > CHECK_CPU_FEATURE_USABLE (GFNI); > > CHECK_CPU_FEATURE_USABLE (VAES); > > CHECK_CPU_FEATURE_USABLE (VPCLMULQDQ); > > @@ -324,6 +325,7 @@ do_test (void) > > CHECK_CPU_FEATURE_USABLE (HYBRID); > > CHECK_CPU_FEATURE_USABLE (TSXLDTRK); > > CHECK_CPU_FEATURE_USABLE (PCONFIG); > > + CHECK_CPU_FEATURE_USABLE (IBT); > > CHECK_CPU_FEATURE_USABLE (AMX_BF16); > > CHECK_CPU_FEATURE_USABLE (AVX512_FP16); > > CHECK_CPU_FEATURE_USABLE (AMX_TILE); > > > > Ok.+ Here is the updated patch. OK for master? Thanks/ -- H.J. --0000000000005cf24205b9fa78ff Content-Type: text/x-patch; charset="US-ASCII"; name="0001-x86-Properly-set-usable-CET-feature-bits-BZ-26625.patch" Content-Disposition: attachment; filename="0001-x86-Properly-set-usable-CET-feature-bits-BZ-26625.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kkh7pt010 RnJvbSA2NWE5Y2E5YzIwZGI3ZmZkNjFmM2RlZmI0MDgzYjUxMzU4OWM3MjMxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiAiSC5KLiBMdSIgPGhqbC50b29sc0BnbWFpbC5jb20+CkRhdGU6 IFR1ZSwgMjYgSmFuIDIwMjEgMjA6NDg6NDUgLTA4MDAKU3ViamVjdDogW1BBVENIXSB4ODY6IFBy b3Blcmx5IHNldCB1c2FibGUgQ0VUIGZlYXR1cmUgYml0cyBbQlogIzI2NjI1XQoKY29tbWl0IDk0 Y2QzN2ViYjI5MzMyMTExNWEzNmE0MjJiMDkxZmRiNzJkMmZiMDgKQXV0aG9yOiBILkouIEx1IDxo amwudG9vbHNAZ21haWwuY29tPgpEYXRlOiAgIFdlZCBTZXAgMTYgMDU6Mjc6MzIgMjAyMCAtMDcw MAoKICAgIHg4NjogVXNlIEhBU19DUFVfRkVBVFVSRSB3aXRoIElCVCBhbmQgU0hTVEsgW0JaICMy NjYyNV0KCmJyb2tlCgpHTElCQ19UVU5BQkxFUz1nbGliYy5jcHUuaHdjYXBzPS1JQlQsLVNIU1RL CgpzaW5jZSBpdCBjYW4gbm8gbG9uZ2VyIGRpc2FibGUgSUJUIG5vciBTSFNUSy4gIEhhbmRsZSBJ QlQgYW5kIFNIU1RLIHdpdGg6CgoxLiBSZXZlcnQgY29tbWl0IDk0Y2QzN2ViYjI5MzMyMTExNWEz NmE0MjJiMDkxZmRiNzJkMmZiMDguCjIuIENsZWFycyB0aGUgdXNhYmxlIENFVCBmZWF0dXJlIGJp dHMgaWYga2VybmVsIGRvZXNuJ3Qgc3VwcG9ydCBDRVQuCjMuIEFkZCBHTElCQ19UVU5BQkxFUyB0 ZXN0cyB3aXRob3V0IGRsb3Blbi4KNC4gQWRkIHRlc3RzIHRvIHZlcmlmeSB0aGF0IENQVV9GRUFU VVJFX1VTQUJMRSBvbiBJQlQgYW5kIFNIU1RLIG1hdGNoZXMKX2dldF9zc3AuCjUuIFVwZGF0ZSBH TElCQ19UVU5BQkxFUyB0ZXN0cyB3aXRoIGRsb3BlbiB0byB2ZXJpZnkgdGhhdCBDRVQgaXMgZGlz YWJsZWQKd2l0aCBHTElCQ19UVU5BQkxFUy4KLS0tCiBzeXNkZXBzL3g4Ni9NYWtlZmlsZSAgICAg ICAgICAgICAgICAgICB8ICA4ICsrKystCiBzeXNkZXBzL3g4Ni9jcHUtZmVhdHVyZXMuYyAgICAg ICAgICAgICB8IDExICsrKysrLS0KIHN5c2RlcHMveDg2L2RsLWNldC5jICAgICAgICAgICAgICAg ICAgIHwgIDQgKy0tCiBzeXNkZXBzL3g4Ni90c3QtY2V0LWxlZ2FjeS0xMC1zdGF0aWMuYyB8ICAx ICsKIHN5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTEwLmMgICAgICAgIHwgNDMgKysrKysrKysr KysrKysrKysrKysrKysrKysKIHN5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTUuYyAgICAgICAg IHwgMTEgKysrKy0tLQogc3lzZGVwcy94ODYvdHN0LWNldC1sZWdhY3ktNi5jICAgICAgICAgfCAx MSArKysrLS0tCiBzeXNkZXBzL3g4Ni90c3QtY2V0LWxlZ2FjeS05LXN0YXRpYy5jICB8ICAxICsK IHN5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTkuYyAgICAgICAgIHwgNDIgKysrKysrKysrKysr KysrKysrKysrKysrKwogc3lzZGVwcy94ODYvdHN0LWdldC1jcHUtZmVhdHVyZXMuYyAgICAgfCAg MiArKwogMTAgZmlsZXMgY2hhbmdlZCwgMTIxIGluc2VydGlvbnMoKyksIDEzIGRlbGV0aW9ucygt KQogY3JlYXRlIG1vZGUgMTAwNjQ0IHN5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTEwLXN0YXRp Yy5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3lzZGVwcy94ODYvdHN0LWNldC1sZWdhY3ktMTAuYwog Y3JlYXRlIG1vZGUgMTAwNjQ0IHN5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTktc3RhdGljLmMK IGNyZWF0ZSBtb2RlIDEwMDY0NCBzeXNkZXBzL3g4Ni90c3QtY2V0LWxlZ2FjeS05LmMKCmRpZmYg LS1naXQgYS9zeXNkZXBzL3g4Ni9NYWtlZmlsZSBiL3N5c2RlcHMveDg2L01ha2VmaWxlCmluZGV4 IDc1NDk1MDdhOWEuLmRkODI2NzQzNDIgMTAwNjQ0Ci0tLSBhL3N5c2RlcHMveDg2L01ha2VmaWxl CisrKyBiL3N5c2RlcHMveDg2L01ha2VmaWxlCkBAIC04Miw3ICs4Miw5IEBAIHN5c2RlcC1kbC1y b3V0aW5lcyArPSBkbC1jZXQKIHRlc3RzICs9IHRzdC1jZXQtbGVnYWN5LTEgdHN0LWNldC1sZWdh Y3ktMWEgdHN0LWNldC1sZWdhY3ktMiBcCiAJIHRzdC1jZXQtbGVnYWN5LTJhIHRzdC1jZXQtbGVn YWN5LTMgdHN0LWNldC1sZWdhY3ktNCBcCiAJIHRzdC1jZXQtbGVnYWN5LTVhIHRzdC1jZXQtbGVn YWN5LTZhIHRzdC1jZXQtbGVnYWN5LTcgXAotCSB0c3QtY2V0LWxlZ2FjeS04CisJIHRzdC1jZXQt bGVnYWN5LTggdHN0LWNldC1sZWdhY3ktOSB0c3QtY2V0LWxlZ2FjeS05LXN0YXRpYyBcCisJIHRz dC1jZXQtbGVnYWN5LTEwIHRzdC1jZXQtbGVnYWN5LTEwLXN0YXRpYwordGVzdHMtc3RhdGljICs9 IHRzdC1jZXQtbGVnYWN5LTktc3RhdGljIHRzdC1jZXQtbGVnYWN5LTEwLXN0YXRpYwogdHN0LWNl dC1sZWdhY3ktMWEtQVJHUyA9IC0tICQoaG9zdC10ZXN0LXByb2dyYW0tY21kKQogaWZuZXEgKG5v LCQoaGF2ZS10dW5hYmxlcykpCiB0ZXN0cyArPSB0c3QtY2V0LWxlZ2FjeS00YSB0c3QtY2V0LWxl Z2FjeS00YiB0c3QtY2V0LWxlZ2FjeS00YyBcCkBAIC0xMjMsNiArMTI1LDggQEAgQ0ZMQUdTLXRz dC1jZXQtbGVnYWN5LW1vZC02Yi5jICs9IC1mY2YtcHJvdGVjdGlvbgogQ0ZMQUdTLXRzdC1jZXQt bGVnYWN5LW1vZC02Yy5jICs9IC1mY2YtcHJvdGVjdGlvbgogQ0ZMQUdTLXRzdC1jZXQtbGVnYWN5 LTcuYyArPSAtZmNmLXByb3RlY3Rpb249bm9uZQogQ0ZMQUdTLXRzdC1jZXQtbGVnYWN5LTguYyAr PSAtbXNoc3RrCitDRkxBR1MtdHN0LWNldC1sZWdhY3ktMTAuYyArPSAtbXNoc3RrCitDRkxBR1Mt dHN0LWNldC1sZWdhY3ktMTAtc3RhdGljLmMgKz0gLW1zaHN0awogCiAkKG9ianBmeCl0c3QtY2V0 LWxlZ2FjeS0xOiAkKG9ianBmeCl0c3QtY2V0LWxlZ2FjeS1tb2QtMS5zbyBcCiAJCSAgICAgICAk KG9ianBmeCl0c3QtY2V0LWxlZ2FjeS1tb2QtMi5zbwpAQCAtMTYzLDYgKzE2Nyw4IEBAICQob2Jq cGZ4KXRzdC1jZXQtbGVnYWN5LTZiOiAkKGxpYmRsKQogJChvYmpwZngpdHN0LWNldC1sZWdhY3kt NmIub3V0OiAkKG9ianBmeCl0c3QtY2V0LWxlZ2FjeS1tb2QtNmEuc28gXAogCQkJCSQob2JqcGZ4 KXRzdC1jZXQtbGVnYWN5LW1vZC02Yi5zbwogdHN0LWNldC1sZWdhY3ktNmItRU5WID0gR0xJQkNf VFVOQUJMRVM9Z2xpYmMuY3B1Lmh3Y2Fwcz0tSUJULC1TSFNUSwordHN0LWNldC1sZWdhY3ktOS1F TlYgPSBHTElCQ19UVU5BQkxFUz1nbGliYy5jcHUuaHdjYXBzPS1JQlQsLVNIU1RLCit0c3QtY2V0 LWxlZ2FjeS05LXN0YXRpYy1FTlYgPSBHTElCQ19UVU5BQkxFUz1nbGliYy5jcHUuaHdjYXBzPS1J QlQsLVNIU1RLCiBlbmRpZgogZW5kaWYKIApkaWZmIC0tZ2l0IGEvc3lzZGVwcy94ODYvY3B1LWZl YXR1cmVzLmMgYi9zeXNkZXBzL3g4Ni9jcHUtZmVhdHVyZXMuYwppbmRleCA2NDk2NTEyYTBkLi43 M2IwYTRkYzlhIDEwMDY0NAotLS0gYS9zeXNkZXBzL3g4Ni9jcHUtZmVhdHVyZXMuYworKysgYi9z eXNkZXBzL3g4Ni9jcHUtZmVhdHVyZXMuYwpAQCAtNzUsNiArNzUsNyBAQCB1cGRhdGVfdXNhYmxl IChzdHJ1Y3QgY3B1X2ZlYXR1cmVzICpjcHVfZmVhdHVyZXMpCiAgIENQVV9GRUFUVVJFX1NFVF9V U0FCTEUgKGNwdV9mZWF0dXJlcywgUFJFRkVUQ0hXVDEpOwogICBDUFVfRkVBVFVSRV9TRVRfVVNB QkxFIChjcHVfZmVhdHVyZXMsIE9TUEtFKTsKICAgQ1BVX0ZFQVRVUkVfU0VUX1VTQUJMRSAoY3B1 X2ZlYXR1cmVzLCBXQUlUUEtHKTsKKyAgQ1BVX0ZFQVRVUkVfU0VUX1VTQUJMRSAoY3B1X2ZlYXR1 cmVzLCBTSFNUSyk7CiAgIENQVV9GRUFUVVJFX1NFVF9VU0FCTEUgKGNwdV9mZWF0dXJlcywgR0ZO SSk7CiAgIENQVV9GRUFUVVJFX1NFVF9VU0FCTEUgKGNwdV9mZWF0dXJlcywgUkRQSUQpOwogICBD UFVfRkVBVFVSRV9TRVRfVVNBQkxFIChjcHVfZmVhdHVyZXMsIFJEUkFORCk7CkBAIC04NCw2ICs4 NSw3IEBAIHVwZGF0ZV91c2FibGUgKHN0cnVjdCBjcHVfZmVhdHVyZXMgKmNwdV9mZWF0dXJlcykK ICAgQ1BVX0ZFQVRVUkVfU0VUX1VTQUJMRSAoY3B1X2ZlYXR1cmVzLCBGU1JNKTsKICAgQ1BVX0ZF QVRVUkVfU0VUX1VTQUJMRSAoY3B1X2ZlYXR1cmVzLCBTRVJJQUxJWkUpOwogICBDUFVfRkVBVFVS RV9TRVRfVVNBQkxFIChjcHVfZmVhdHVyZXMsIFRTWExEVFJLKTsKKyAgQ1BVX0ZFQVRVUkVfU0VU X1VTQUJMRSAoY3B1X2ZlYXR1cmVzLCBJQlQpOwogICBDUFVfRkVBVFVSRV9TRVRfVVNBQkxFIChj cHVfZmVhdHVyZXMsIExBSEY2NF9TQUhGNjQpOwogICBDUFVfRkVBVFVSRV9TRVRfVVNBQkxFIChj cHVfZmVhdHVyZXMsIExaQ05UKTsKICAgQ1BVX0ZFQVRVUkVfU0VUX1VTQUJMRSAoY3B1X2ZlYXR1 cmVzLCBTU0U0QSk7CkBAIC03MDUsNiArNzA3LDExIEBAIG5vX2NwdWlkOgogICAvKiBDaGVjayBD RVQgc3RhdHVzLiAgKi8KICAgdW5zaWduZWQgaW50IGNldF9zdGF0dXMgPSBnZXRfY2V0X3N0YXR1 cyAoKTsKIAorICBpZiAoKGNldF9zdGF0dXMgJiBHTlVfUFJPUEVSVFlfWDg2X0ZFQVRVUkVfMV9J QlQpID09IDApCisgICAgQ1BVX0ZFQVRVUkVfVU5TRVQgKGNwdV9mZWF0dXJlcywgSUJUKQorICBp ZiAoKGNldF9zdGF0dXMgJiBHTlVfUFJPUEVSVFlfWDg2X0ZFQVRVUkVfMV9TSFNUSykgPT0gMCkK KyAgICBDUFVfRkVBVFVSRV9VTlNFVCAoY3B1X2ZlYXR1cmVzLCBTSFNUSykKKwogICBpZiAoY2V0 X3N0YXR1cykKICAgICB7CiAgICAgICBHTChkbF94ODZfZmVhdHVyZV8xKSA9IGNldF9zdGF0dXM7 CkBAIC03MjAsOSArNzI3LDkgQEAgbm9fY3B1aWQ6CiAJICAgICBHTElCQ19UVU5BQkxFUz1nbGli Yy5jcHUuaHdjYXBzPS1JQlQsLVNIU1RLCiAJICAgKi8KIAkgIHVuc2lnbmVkIGludCBjZXRfZmVh dHVyZSA9IDA7Ci0JICBpZiAoIUhBU19DUFVfRkVBVFVSRSAoSUJUKSkKKwkgIGlmICghQ1BVX0ZF QVRVUkVfVVNBQkxFIChJQlQpKQogCSAgICBjZXRfZmVhdHVyZSB8PSBHTlVfUFJPUEVSVFlfWDg2 X0ZFQVRVUkVfMV9JQlQ7Ci0JICBpZiAoIUhBU19DUFVfRkVBVFVSRSAoU0hTVEspKQorCSAgaWYg KCFDUFVfRkVBVFVSRV9VU0FCTEUgKFNIU1RLKSkKIAkgICAgY2V0X2ZlYXR1cmUgfD0gR05VX1BS T1BFUlRZX1g4Nl9GRUFUVVJFXzFfU0hTVEs7CiAKIAkgIGlmIChjZXRfZmVhdHVyZSkKZGlmZiAt LWdpdCBhL3N5c2RlcHMveDg2L2RsLWNldC5jIGIvc3lzZGVwcy94ODYvZGwtY2V0LmMKaW5kZXgg YTYzYjljNzE2NC4uYzc0ZTU3NzI4OSAxMDA2NDQKLS0tIGEvc3lzZGVwcy94ODYvZGwtY2V0LmMK KysrIGIvc3lzZGVwcy94ODYvZGwtY2V0LmMKQEAgLTc3LDExICs3NywxMSBAQCBkbF9jZXRfY2hl Y2sgKHN0cnVjdCBsaW5rX21hcCAqbSwgY29uc3QgY2hhciAqcHJvZ3JhbSkKIAogCSAgICAgR0xJ QkNfVFVOQUJMRVM9Z2xpYmMuY3B1Lmh3Y2Fwcz0tSUJULC1TSFNUSwogCSAgICovCi0JICBlbmFi bGVfaWJ0ICY9IChIQVNfQ1BVX0ZFQVRVUkUgKElCVCkKKwkgIGVuYWJsZV9pYnQgJj0gKENQVV9G RUFUVVJFX1VTQUJMRSAoSUJUKQogCQkJICYmIChlbmFibGVfaWJ0X3R5cGUgPT0gY2V0X2Fsd2F5 c19vbgogCQkJICAgICB8fCAobS0+bF94ODZfZmVhdHVyZV8xX2FuZAogCQkJCSAmIEdOVV9QUk9Q RVJUWV9YODZfRkVBVFVSRV8xX0lCVCkgIT0gMCkpOwotCSAgZW5hYmxlX3Noc3RrICY9IChIQVNf Q1BVX0ZFQVRVUkUgKFNIU1RLKQorCSAgZW5hYmxlX3Noc3RrICY9IChDUFVfRkVBVFVSRV9VU0FC TEUgKFNIU1RLKQogCQkJICAgJiYgKGVuYWJsZV9zaHN0a190eXBlID09IGNldF9hbHdheXNfb24K IAkJCSAgICAgICB8fCAobS0+bF94ODZfZmVhdHVyZV8xX2FuZAogCQkJCSAgICYgR05VX1BST1BF UlRZX1g4Nl9GRUFUVVJFXzFfU0hTVEspICE9IDApKTsKZGlmZiAtLWdpdCBhL3N5c2RlcHMveDg2 L3RzdC1jZXQtbGVnYWN5LTEwLXN0YXRpYy5jIGIvc3lzZGVwcy94ODYvdHN0LWNldC1sZWdhY3kt MTAtc3RhdGljLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uZWNjMTIw OGUzNQotLS0gL2Rldi9udWxsCisrKyBiL3N5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTEwLXN0 YXRpYy5jCkBAIC0wLDAgKzEgQEAKKyNpbmNsdWRlICJ0c3QtY2V0LWxlZ2FjeS0xMC5jIgpkaWZm IC0tZ2l0IGEvc3lzZGVwcy94ODYvdHN0LWNldC1sZWdhY3ktMTAuYyBiL3N5c2RlcHMveDg2L3Rz dC1jZXQtbGVnYWN5LTEwLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4u YTYxODU1N2Y0NQotLS0gL2Rldi9udWxsCisrKyBiL3N5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5 LTEwLmMKQEAgLTAsMCArMSw0MyBAQAorLyogQ2hlY2sgQ1BVX0ZFQVRVUkVfVVNBQkxFIG9uIElC VCBhbmQgU0hTVEsuCisgICBDb3B5cmlnaHQgKEMpIDIwMjEgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuCisgICBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgR05VIEMgTGlicmFyeS4KKwor ICAgVGhlIEdOVSBDIExpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCisgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCisgICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAgIHZlcnNpb24gMi4xIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBUaGUgR05VIEMg TGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgICBMaWNlbnNlIGFsb25nIHdpdGgg dGhlIEdOVSBDIExpYnJhcnk7IGlmIG5vdCwgc2VlCisgICA8aHR0cHM6Ly93d3cuZ251Lm9yZy9s aWNlbnNlcy8+LiAgKi8KKworI2luY2x1ZGUgPHg4NmludHJpbi5oPgorI2luY2x1ZGUgPHN5cy9w bGF0Zm9ybS94ODYuaD4KKyNpbmNsdWRlIDxzdXBwb3J0L3Rlc3QtZHJpdmVyLmg+CisjaW5jbHVk ZSA8c3VwcG9ydC94dW5pc3RkLmg+CisKKy8qIENoZWNrIHRoYXQgQ1BVX0ZFQVRVUkVfVVNBQkxF IG9uIElCVCBhbmQgU0hTVEsgbWF0Y2hlcyBfZ2V0X3NzcC4gICovCisKK3N0YXRpYyBpbnQKK2Rv X3Rlc3QgKHZvaWQpCit7CisgIGlmIChfZ2V0X3NzcCAoKSAhPSAwKQorICAgIHsKKyAgICAgIGlm IChDUFVfRkVBVFVSRV9VU0FCTEUgKElCVCkgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFIChTSFNUSykp CisJcmV0dXJuIEVYSVRfU1VDQ0VTUzsKKyAgICB9CisgIGVsc2UKKyAgICB7CisgICAgICBpZiAo IUNQVV9GRUFUVVJFX1VTQUJMRSAoSUJUKSAmJiAhQ1BVX0ZFQVRVUkVfVVNBQkxFIChTSFNUSykp CisJcmV0dXJuIEVYSVRfU1VDQ0VTUzsKKyAgICB9CisKKyAgcmV0dXJuIEVYSVRfRkFJTFVSRTsK K30KKworI2luY2x1ZGUgPHN1cHBvcnQvdGVzdC1kcml2ZXIuYz4KZGlmZiAtLWdpdCBhL3N5c2Rl cHMveDg2L3RzdC1jZXQtbGVnYWN5LTUuYyBiL3N5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTUu YwppbmRleCBlM2VmZWIxZjRlLi5kODcwZGUzZWFlIDEwMDY0NAotLS0gYS9zeXNkZXBzL3g4Ni90 c3QtY2V0LWxlZ2FjeS01LmMKKysrIGIvc3lzZGVwcy94ODYvdHN0LWNldC1sZWdhY3ktNS5jCkBA IC0zNyw2ICszNywxMiBAQCBkb190ZXN0XzEgKGNvbnN0IGNoYXIgKm1vZG5hbWUsIGJvb2wgZmFp bCkKICAgaW50ICgqZnApICh2b2lkKTsKICAgdm9pZCAqaDsKIAorICAvKiBOQjogZGxvcGVuIHNo b3VsZCBuZXZlciBmYWlsIG9uIG5vbi1DRVQgcGxhdGZvcm1zLiAgSWYgU0hTVEsgaXMKKyAgICAg ZGlzYWJsZWQsIGFzc3VtaW5nIElCVCBpcyBhbHNvIGRpc2FibGVkLiAgKi8KKyAgYm9vbCBjZXRf ZW5hYmxlZCA9IF9nZXRfc3NwICgpICE9IDAgJiYgIUNFVF9NQVlCRV9ESVNBQkxFRDsKKyAgaWYg KCFjZXRfZW5hYmxlZCkKKyAgICBmYWlsID0gZmFsc2U7CisKICAgaCA9IGRsb3BlbiAobW9kbmFt ZSwgUlRMRF9MQVpZKTsKICAgaWYgKGggPT0gTlVMTCkKICAgICB7CkBAIC01MywxMCArNTksNyBA QCBkb190ZXN0XzEgKGNvbnN0IGNoYXIgKm1vZG5hbWUsIGJvb2wgZmFpbCkKICAgICAgIEZBSUxf RVhJVDEgKCJjYW5ub3Qgb3BlbiAnJXMnOiAlc1xuIiwgbW9kbmFtZSwgZXJyKTsKICAgICB9CiAK LSAgLyogTkI6IGRsb3BlbiBzaG91bGQgbmV2ZXIgZmFpbCBvbiBub24tQ0VUIHBsYXRmb3Jtcy4g IElmIFNIU1RLIGlzCi0gICAgIGRpc2FibGVkLCBhc3N1bWluZyBJQlQgaXMgYWxzbyBkaXNhYmxl ZC4gICovCi0gIGJvb2wgY2V0X2VuYWJsZWQgPSBfZ2V0X3NzcCAoKSAhPSAwICYmICFDRVRfTUFZ QkVfRElTQUJMRUQ7Ci0gIGlmIChmYWlsICYmIGNldF9lbmFibGVkKQorICBpZiAoZmFpbCkKICAg ICBGQUlMX0VYSVQxICgiZGxvcGVuIHNob3VsZCBoYXZlIGZhaWxlZFxuIik7CiAKICAgZnAgPSBk bHN5bSAoaCwgInRlc3QiKTsKZGlmZiAtLWdpdCBhL3N5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5 LTYuYyBiL3N5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTYuYwppbmRleCA0NGIyZWY1YzdhLi44 ZTgyZWUyMjQ2IDEwMDY0NAotLS0gYS9zeXNkZXBzL3g4Ni90c3QtY2V0LWxlZ2FjeS02LmMKKysr IGIvc3lzZGVwcy94ODYvdHN0LWNldC1sZWdhY3ktNi5jCkBAIC0zNyw2ICszNywxMiBAQCBkb190 ZXN0XzEgKGNvbnN0IGNoYXIgKm1vZG5hbWUsIGJvb2wgZmFpbCkKICAgaW50ICgqZnApICh2b2lk KTsKICAgdm9pZCAqaDsKIAorICAvKiBOQjogZGxvcGVuIHNob3VsZCBuZXZlciBmYWlsIG9uIG5v bi1DRVQgcGxhdGZvcm1zLiAgSWYgU0hTVEsgaXMKKyAgICAgZGlzYWJsZWQsIGFzc3VtaW5nIElC VCBpcyBhbHNvIGRpc2FibGVkLiAgKi8KKyAgYm9vbCBjZXRfZW5hYmxlZCA9IF9nZXRfc3NwICgp ICE9IDAgJiYgIUNFVF9NQVlCRV9ESVNBQkxFRDsKKyAgaWYgKCFjZXRfZW5hYmxlZCkKKyAgICBm YWlsID0gZmFsc2U7CisKICAgaCA9IGRsb3BlbiAobW9kbmFtZSwgUlRMRF9MQVpZKTsKICAgaWYg KGggPT0gTlVMTCkKICAgICB7CkBAIC01MywxMCArNTksNyBAQCBkb190ZXN0XzEgKGNvbnN0IGNo YXIgKm1vZG5hbWUsIGJvb2wgZmFpbCkKICAgICAgIEZBSUxfRVhJVDEgKCJjYW5ub3Qgb3BlbiAn JXMnOiAlc1xuIiwgbW9kbmFtZSwgZXJyKTsKICAgICB9CiAKLSAgLyogTkI6IGRsb3BlbiBzaG91 bGQgbmV2ZXIgZmFpbCBvbiBub24tQ0VUIHBsYXRmb3Jtcy4gIElmIFNIU1RLIGlzCi0gICAgIGRp c2FibGVkLCBhc3N1bWluZyBJQlQgaXMgYWxzbyBkaXNhYmxlZC4gICovCi0gIGJvb2wgY2V0X2Vu YWJsZWQgPSBfZ2V0X3NzcCAoKSAhPSAwICYmICFDRVRfTUFZQkVfRElTQUJMRUQ7Ci0gIGlmIChm YWlsICYmIGNldF9lbmFibGVkKQorICBpZiAoZmFpbCkKICAgICBGQUlMX0VYSVQxICgiZGxvcGVu IHNob3VsZCBoYXZlIGZhaWxlZFxuIik7CiAKICAgZnAgPSBkbHN5bSAoaCwgInRlc3QiKTsKZGlm ZiAtLWdpdCBhL3N5c2RlcHMveDg2L3RzdC1jZXQtbGVnYWN5LTktc3RhdGljLmMgYi9zeXNkZXBz L3g4Ni90c3QtY2V0LWxlZ2FjeS05LXN0YXRpYy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAuLmY5YTg1MThiOTkKLS0tIC9kZXYvbnVsbAorKysgYi9zeXNkZXBzL3g4Ni90 c3QtY2V0LWxlZ2FjeS05LXN0YXRpYy5jCkBAIC0wLDAgKzEgQEAKKyNpbmNsdWRlICJ0c3QtY2V0 LWxlZ2FjeS05LmMiCmRpZmYgLS1naXQgYS9zeXNkZXBzL3g4Ni90c3QtY2V0LWxlZ2FjeS05LmMg Yi9zeXNkZXBzL3g4Ni90c3QtY2V0LWxlZ2FjeS05LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMC4uZmU0ZDhlNzNjOAotLS0gL2Rldi9udWxsCisrKyBiL3N5c2RlcHMveDg2 L3RzdC1jZXQtbGVnYWN5LTkuYwpAQCAtMCwwICsxLDQyIEBACisvKiBDaGVjayBDRVQgY29tcGF0 aWJpbGl0eSB3aXRoIGxlZ2FjeSBKSVQgZW5naW5lIHZpYSBHTElCQ19UVU5BQkxFUy4KKyAgIENv cHlyaWdodCAoQykgMjAyMSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4KKyAgIFRoaXMg ZmlsZSBpcyBwYXJ0IG9mIHRoZSBHTlUgQyBMaWJyYXJ5LgorCisgICBUaGUgR05VIEMgTGlicmFy eSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAgIG1v ZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMK KyAgIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlcgorICAgdmVyc2lvbiAyLjEgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlv bikgYW55IGxhdGVyIHZlcnNpb24uCisKKyAgIFRoZSBHTlUgQyBMaWJyYXJ5IGlzIGRpc3RyaWJ1 dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgICBidXQgV0lUSE9VVCBB TlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRo ZSBHTlUKKyAgIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMu CisKKyAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIg R2VuZXJhbCBQdWJsaWMKKyAgIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGUgR05VIEMgTGlicmFyeTsg aWYgbm90LCBzZWUKKyAgIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLworCisj aW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzeXMvbW1h bi5oPgorI2luY2x1ZGUgPHN1cHBvcnQvdGVzdC1kcml2ZXIuaD4KKyNpbmNsdWRlIDxzdXBwb3J0 L3h1bmlzdGQuaD4KKworLyogQ2hlY2sgdGhhdCBtbWFwcGVkIGxlZ2FjeSBjb2RlIHdvbid0IHRy aWdnZXIgc2VnZmF1bHQgd2l0aAorICAgLWZjZi1wcm90ZWN0aW9uIGFuZCBHTElCQ19UVU5BQkxF Uz1nbGliYy5jcHUuaHdjYXBzPS1JQlQsLVNIU1RLLiAgKi8KKworc3RhdGljIGludAorZG9fdGVz dCAodm9pZCkKK3sKKyAgdm9pZCAoKmZ1bmNwKSAodm9pZCk7CisgIHNpemVfdCBwYWdlX3NpemUg PSB4c3lzY29uZiAoX1NDX1BBR0VTSVpFKTsKKyAgZnVuY3AgPSB4bW1hcCAoTlVMTCwgcGFnZV9z aXplLCBQUk9UX0VYRUMgfCBQUk9UX1JFQUQgfCBQUk9UX1dSSVRFLAorCQkgTUFQX0FOT05ZTU9V UyB8IE1BUF9QUklWQVRFLCAtMSk7CisgIHByaW50ZiAoIm1tYXAgPSAlcFxuIiwgZnVuY3ApOwor ICAvKiBXcml0ZSBSRVQgaW5zdHJ1Y3Rpb24uICAqLworICAqKGNoYXIgKikgZnVuY3AgPSAweGMz OworICBmdW5jcCAoKTsKKyAgcmV0dXJuIEVYSVRfU1VDQ0VTUzsKK30KKworI2luY2x1ZGUgPHN1 cHBvcnQvdGVzdC1kcml2ZXIuYz4KZGlmZiAtLWdpdCBhL3N5c2RlcHMveDg2L3RzdC1nZXQtY3B1 LWZlYXR1cmVzLmMgYi9zeXNkZXBzL3g4Ni90c3QtZ2V0LWNwdS1mZWF0dXJlcy5jCmluZGV4IGRj ZGI4NmJiOTMuLmI1ZTdmNmU3YjAgMTAwNjQ0Ci0tLSBhL3N5c2RlcHMveDg2L3RzdC1nZXQtY3B1 LWZlYXR1cmVzLmMKKysrIGIvc3lzZGVwcy94ODYvdHN0LWdldC1jcHUtZmVhdHVyZXMuYwpAQCAt MzAxLDYgKzMwMSw3IEBAIGRvX3Rlc3QgKHZvaWQpCiAgIENIRUNLX0NQVV9GRUFUVVJFX1VTQUJM RSAoT1NQS0UpOwogICBDSEVDS19DUFVfRkVBVFVSRV9VU0FCTEUgKFdBSVRQS0cpOwogICBDSEVD S19DUFVfRkVBVFVSRV9VU0FCTEUgKEFWWDUxMl9WQk1JMik7CisgIENIRUNLX0NQVV9GRUFUVVJF X1VTQUJMRSAoU0hTVEspOwogICBDSEVDS19DUFVfRkVBVFVSRV9VU0FCTEUgKEdGTkkpOwogICBD SEVDS19DUFVfRkVBVFVSRV9VU0FCTEUgKFZBRVMpOwogICBDSEVDS19DUFVfRkVBVFVSRV9VU0FC TEUgKFZQQ0xNVUxRRFEpOwpAQCAtMzI0LDYgKzMyNSw3IEBAIGRvX3Rlc3QgKHZvaWQpCiAgIENI RUNLX0NQVV9GRUFUVVJFX1VTQUJMRSAoSFlCUklEKTsKICAgQ0hFQ0tfQ1BVX0ZFQVRVUkVfVVNB QkxFIChUU1hMRFRSSyk7CiAgIENIRUNLX0NQVV9GRUFUVVJFX1VTQUJMRSAoUENPTkZJRyk7Cisg IENIRUNLX0NQVV9GRUFUVVJFX1VTQUJMRSAoSUJUKTsKICAgQ0hFQ0tfQ1BVX0ZFQVRVUkVfVVNB QkxFIChBTVhfQkYxNik7CiAgIENIRUNLX0NQVV9GRUFUVVJFX1VTQUJMRSAoQVZYNTEyX0ZQMTYp OwogICBDSEVDS19DUFVfRkVBVFVSRV9VU0FCTEUgKEFNWF9USUxFKTsKLS0gCjIuMjkuMgoK --0000000000005cf24205b9fa78ff--