From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-oi1-x22f.google.com (mail-oi1-x22f.google.com [IPv6:2607:f8b0:4864:20::22f]) by sourceware.org (Postfix) with ESMTPS id 8368F396DC37 for ; Thu, 7 Jan 2021 20:59:04 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 8368F396DC37 Received: by mail-oi1-x22f.google.com with SMTP id q25so8884419oij.10 for ; Thu, 07 Jan 2021 12:59:04 -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=8JDhdH989iTXRvGcB0/B4mzDPjdNEf6+h+cnBxwBJfo=; b=l0zxGijNs/EIx9giIo5e4REPJsfCHG9NbR6r5orbNkklWsPCVQcjLKfFgT6VBiGt5o IAoONjmT92Z68TU2GoEgcUu9T1viStxFumQdUZPyuuK2PyAD7k9NQ6BnN2tmOyq/IlGs atuZ5cROsfLn4/0ATKBPWvQ4dmatoi5vo3/v6WMfFnUejs9hbox1Zlu1prM6lXXax2jU 9TbUz9D951PF5yaqPfKU0mQVBhrqjbUTv3ybrmLb0RLnBXTyGJoox8eCTLXrJRe83yO0 EJl030WXtvBdA2RXfy6GNRHCiICEpH8sZ1dO3SXY4ekh/rMrIFLBCsAZvzD4LpW+X/GH K1ug== X-Gm-Message-State: AOAM530ZU2e4dozngm0cqWOoMLdGI4aXJwi0RNDTp0rQEqFoaCWS/kje Ne17DKNvd1bKnMCsBHGZEi/EJTRpk9SI6W6pXXo= X-Google-Smtp-Source: ABdhPJwDjGrq1eCvblRdTYmLtH/LBlZ/bVA8cKctbgiehwWlMAx7ZrBzdbAG3OwGvvNTjRaJmS+u8xuaOwXb5wUi/5E= X-Received: by 2002:aca:4d8b:: with SMTP id a133mr310336oib.79.1610053143769; Thu, 07 Jan 2021 12:59:03 -0800 (PST) MIME-Version: 1.0 References: <20201206144952.2109594-1-hjl.tools@gmail.com> <20201206144952.2109594-2-hjl.tools@gmail.com> <83ab601d-adbe-6d26-8d9c-235d52503171@linaro.org> In-Reply-To: From: "H.J. Lu" Date: Thu, 7 Jan 2021 12:58:27 -0800 Message-ID: Subject: Re: V6 [PATCH 1/2] x86: Support GNU_PROPERTY_X86_ISA_1_V[234] marker [BZ #26717] To: Adhemerval Zanella Cc: GNU C Library , Florian Weimer Content-Type: multipart/mixed; boundary="000000000000b4614805b855b583" X-Spam-Status: No, score=-3035.0 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, LIKELY_SPAM_BODY, 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, 07 Jan 2021 20:59:11 -0000 --000000000000b4614805b855b583 Content-Type: text/plain; charset="UTF-8" On Thu, Jan 7, 2021 at 12:09 PM Adhemerval Zanella wrote: > > > > On 06/01/2021 14:11, H.J. Lu wrote: > > Here is the updated patch. Tested under i686, x32 and x86-64 modes > > on x86-64-v2, x86-64-v3 and x86-64-v4 machines. > > > > OK for master? > > > > Thanks. > > > > LGTM with just two clarification below. > > Reviewed-by: Adhemerval Zanella > > > From 6630e06f9bcb361177d46c277cf8e67cbd722429 Mon Sep 17 00:00:00 2001 > > From: "H.J. Lu" > > Date: Fri, 9 Oct 2020 06:06:56 -0700 > > Subject: [PATCH] x86: Support GNU_PROPERTY_X86_ISA_1_V[234] marker [BZ #26717] > > > > GCC 11 supports -march=x86-64-v[234] to enable x86 micro-architecture ISA > > levels: > > > > https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97250 > > > > and -mneeded to emit GNU_PROPERTY_X86_ISA_1_NEEDED property with > > GNU_PROPERTY_X86_ISA_1_V[234] marker: > > > > https://gitlab.com/x86-psABIs/x86-64-ABI/-/merge_requests/13 > > > > Binutils support for GNU_PROPERTY_X86_ISA_1_V[234] marker were added by > > > > commit b0ab06937385e0ae25cebf1991787d64f439bf12 > > Author: H.J. Lu > > Date: Fri Oct 30 06:49:57 2020 -0700 > > > > x86: Support GNU_PROPERTY_X86_ISA_1_BASELINE marker > > > > and > > > > commit 32930e4edbc06bc6f10c435dbcc63131715df678 > > Author: H.J. Lu > > Date: Fri Oct 9 05:05:57 2020 -0700 > > > > x86: Support GNU_PROPERTY_X86_ISA_1_V[234] marker > > > > GNU_PROPERTY_X86_ISA_1_NEEDED property in x86 ELF binaries indicate the > > micro-architecture ISA level required to execute the binary. The marker > > must be added by programmers explicitly in one of 3 ways: > > > > 1. Pass -mneeded to GCC. > > 2. Add the marker in the linker inputs as this patch does. > > 3. Pass -z x86-64-v[234] to the linker. > > > > Add GNU_PROPERTY_X86_ISA_1_BASELINE and GNU_PROPERTY_X86_ISA_1_V[234] > > marker support to ld.so if binutils 2.32 or newer is used to build glibc: > > > > 1. Add GNU_PROPERTY_X86_ISA_1_BASELINE and GNU_PROPERTY_X86_ISA_1_V[234] > > markers to elf.h. > > 2. Add GNU_PROPERTY_X86_ISA_1_BASELINE and GNU_PROPERTY_X86_ISA_1_V[234] > > marker to abi-note.o based on the ISA level used to compile abi-note.o, > > assuming that the same ISA level is used to compile the whole glibc. > > 3. Add isa_1 to cpu_features to record the supported x86 ISA level. > > 4. Rename _dl_process_cet_property_note to _dl_process_property_note and > > add GNU_PROPERTY_X86_ISA_1_V[234] marker detection. > > 5. Update _rtld_main_check and _dl_open_check to check loaded objects > > with the incompatible ISA level. > > 6. Add a testcase to verify that dlopen an x86-64-v4 shared object fails > > on lesser platforms. > > 7. Use in dl-hwcaps-subdirs.c and tst-glibc-hwcaps.c. > > > > Tested under i686, x32 and x86-64 modes on x86-64-v2, x86-64-v3 and > > x86-64-v4 machines. > > > > Marked elf/tst-isa-level-1 with x86-64-v4, ran it on x86-64-v3 machine > > and got: > > > > [hjl@gnu-cfl-2 build-x86_64-linux]$ ./elf/tst-isa-level-1 > > ./elf/tst-isa-level-1: CPU ISA level is lower than required > > [hjl@gnu-cfl-2 build-x86_64-linux]$ > > --- > > config.h.in | 3 + > > elf/elf.h | 35 +++---- > > sysdeps/x86/Makefile | 30 ++++++ > > sysdeps/x86/abi-note.c | 29 ++++++ > > sysdeps/x86/configure | 79 ++++++++++++++ > > sysdeps/x86/configure.ac | 66 ++++++++++++ > > sysdeps/x86/cpu-features.c | 3 + > > sysdeps/x86/dl-cet.c | 12 ++- > > sysdeps/x86/dl-prop.h | 113 +++++++++++++++------ > > sysdeps/x86/get-isa-level.h | 66 ++++++++++++ > > sysdeps/x86/include/cpu-features.h | 2 + > > sysdeps/x86/isa-level.c | 97 ++++++++++++++++++ > > sysdeps/x86/link_map.h | 18 ++-- > > sysdeps/x86/tst-isa-level-1.c | 104 +++++++++++++++++++ > > sysdeps/x86/tst-isa-level-mod-1-baseline.c | 1 + > > sysdeps/x86/tst-isa-level-mod-1-v2.c | 1 + > > sysdeps/x86/tst-isa-level-mod-1-v3.c | 1 + > > sysdeps/x86/tst-isa-level-mod-1-v4.c | 1 + > > sysdeps/x86/tst-isa-level-mod-1.c | 25 +++++ > > sysdeps/x86_64/dl-hwcaps-subdirs.c | 30 ++---- > > sysdeps/x86_64/tst-glibc-hwcaps.c | 41 ++------ > > 21 files changed, 644 insertions(+), 113 deletions(-) > > create mode 100644 sysdeps/x86/abi-note.c > > create mode 100644 sysdeps/x86/get-isa-level.h > > create mode 100644 sysdeps/x86/isa-level.c > > create mode 100644 sysdeps/x86/tst-isa-level-1.c > > create mode 100644 sysdeps/x86/tst-isa-level-mod-1-baseline.c > > create mode 100644 sysdeps/x86/tst-isa-level-mod-1-v2.c > > create mode 100644 sysdeps/x86/tst-isa-level-mod-1-v3.c > > create mode 100644 sysdeps/x86/tst-isa-level-mod-1-v4.c > > create mode 100644 sysdeps/x86/tst-isa-level-mod-1.c > > > > diff --git a/config.h.in b/config.h.in > > index eca2d66a2c..947feeff36 100644 > > --- a/config.h.in > > +++ b/config.h.in > > @@ -269,4 +269,7 @@ > > /* The default value of x86 CET control. */ > > #define DEFAULT_DL_X86_CET_CONTROL cet_elf_property > > > > +/* Define if x86 ISA level should be included in shared libraries. */ > > +#undef INCLUDE_X86_ISA_LEVEL > > + > > #endif > > diff --git a/elf/elf.h b/elf/elf.h > > Ok. > > > index 4a9ae97dfc..9ebd052c8a 100644 > > --- a/elf/elf.h > > +++ b/elf/elf.h > > @@ -1324,31 +1324,26 @@ typedef struct > > > > /* The x86 instruction sets indicated by the corresponding bits are > > used in program. Their support in the hardware is optional. */ > > -#define GNU_PROPERTY_X86_ISA_1_USED 0xc0000000 > > +#define GNU_PROPERTY_X86_ISA_1_USED 0xc0010002 > > /* The x86 instruction sets indicated by the corresponding bits are > > used in program and they must be supported by the hardware. */ > > -#define GNU_PROPERTY_X86_ISA_1_NEEDED 0xc0000001 > > +#define GNU_PROPERTY_X86_ISA_1_NEEDED 0xc0008002 > > /* X86 processor-specific features used in program. */ > > #define GNU_PROPERTY_X86_FEATURE_1_AND 0xc0000002 > > > > -#define GNU_PROPERTY_X86_ISA_1_486 (1U << 0) > > -#define GNU_PROPERTY_X86_ISA_1_586 (1U << 1) > > -#define GNU_PROPERTY_X86_ISA_1_686 (1U << 2) > > -#define GNU_PROPERTY_X86_ISA_1_SSE (1U << 3) > > -#define GNU_PROPERTY_X86_ISA_1_SSE2 (1U << 4) > > -#define GNU_PROPERTY_X86_ISA_1_SSE3 (1U << 5) > > -#define GNU_PROPERTY_X86_ISA_1_SSSE3 (1U << 6) > > -#define GNU_PROPERTY_X86_ISA_1_SSE4_1 (1U << 7) > > -#define GNU_PROPERTY_X86_ISA_1_SSE4_2 (1U << 8) > > -#define GNU_PROPERTY_X86_ISA_1_AVX (1U << 9) > > -#define GNU_PROPERTY_X86_ISA_1_AVX2 (1U << 10) > > -#define GNU_PROPERTY_X86_ISA_1_AVX512F (1U << 11) > > -#define GNU_PROPERTY_X86_ISA_1_AVX512CD (1U << 12) > > -#define GNU_PROPERTY_X86_ISA_1_AVX512ER (1U << 13) > > -#define GNU_PROPERTY_X86_ISA_1_AVX512PF (1U << 14) > > -#define GNU_PROPERTY_X86_ISA_1_AVX512VL (1U << 15) > > -#define GNU_PROPERTY_X86_ISA_1_AVX512DQ (1U << 16) > > -#define GNU_PROPERTY_X86_ISA_1_AVX512BW (1U << 17) > > +/* GNU_PROPERTY_X86_ISA_1_BASELINE: CMOV, CX8 (cmpxchg8b), FPU (fld), > > + MMX, OSFXSR (fxsave), SCE (syscall), SSE and SSE2. */ > > +#define GNU_PROPERTY_X86_ISA_1_BASELINE (1U << 0) > > +/* GNU_PROPERTY_X86_ISA_1_V2: GNU_PROPERTY_X86_ISA_1_BASELINE, > > + CMPXCHG16B (cmpxchg16b), LAHF-SAHF (lahf), POPCNT (popcnt), SSE3, > > + SSSE3, SSE4.1 and SSE4.2. */ > > +#define GNU_PROPERTY_X86_ISA_1_V2 (1U << 1) > > +/* GNU_PROPERTY_X86_ISA_1_V3: GNU_PROPERTY_X86_ISA_1_V2, AVX, AVX2, BMI1, > > + BMI2, F16C, FMA, LZCNT, MOVBE, XSAVE. */ > > +#define GNU_PROPERTY_X86_ISA_1_V3 (1U << 2) > > +/* GNU_PROPERTY_X86_ISA_1_V4: GNU_PROPERTY_X86_ISA_1_V3, AVX512F, > > + AVX512BW, AVX512CD, AVX512DQ and AVX512VL. */ > > +#define GNU_PROPERTY_X86_ISA_1_V4 (1U << 3) > > > > /* This indicates that all executable sections are compatible with > > IBT. */ > > Ok. > > > diff --git a/sysdeps/x86/Makefile b/sysdeps/x86/Makefile > > index 081cc72e93..c814d5a195 100644 > > --- a/sysdeps/x86/Makefile > > +++ b/sysdeps/x86/Makefile > > @@ -9,6 +9,36 @@ sysdep_headers += sys/platform/x86.h > > tests += tst-get-cpu-features tst-get-cpu-features-static \ > > tst-cpu-features-cpuinfo tst-cpu-features-supports > > tests-static += tst-get-cpu-features-static > > +ifeq (yes,$(enable-x86-isa-level)) > > +tests += tst-isa-level-1 > > +modules-names += tst-isa-level-mod-1-baseline \ > > + tst-isa-level-mod-1-v2 \ > > + tst-isa-level-mod-1-v3 \ > > + tst-isa-level-mod-1-v4 \ > > + > > +# X86 ISA level baseline > > +CFLAGS-tst-isa-level-mod-1-baseline.c += -DINCLUDE_X86_ISA_LEVEL \ > > + -DISA_LEVEL=0x1 \ > > + -march=x86-64 > > +# X86 ISA level v2 > > +CFLAGS-tst-isa-level-mod-1-v2.c += -DINCLUDE_X86_ISA_LEVEL \ > > + -DISA_LEVEL=0x3 \ > > + -march=x86-64 > > +# X86 ISA level v3 > > +CFLAGS-tst-isa-level-mod-1-v3.c += -DINCLUDE_X86_ISA_LEVEL \ > > + -DISA_LEVEL=0x7 \ > > + -march=x86-64 > > +# X86 ISA level v4 > > +CFLAGS-tst-isa-level-mod-1-v4.c += -DINCLUDE_X86_ISA_LEVEL \ > > + -DISA_LEVEL=0xf \ > > + -march=x86-64 > > + > > +$(objpfx)tst-isa-level-1: $(libdl) > > +$(objpfx)tst-isa-level-1.out: $(objpfx)tst-isa-level-mod-1-baseline.so \ > > + $(objpfx)tst-isa-level-mod-1-v2.so \ > > + $(objpfx)tst-isa-level-mod-1-v3.so \ > > + $(objpfx)tst-isa-level-mod-1-v4.so > > +endif > > endif > > > > ifeq ($(subdir),math) > > Ok. > > > diff --git a/sysdeps/x86/abi-note.c b/sysdeps/x86/abi-note.c > > new file mode 100644 > > index 0000000000..5140e6ab47 > > --- /dev/null > > +++ b/sysdeps/x86/abi-note.c > > @@ -0,0 +1,29 @@ > > +/* Special .init and .fini section support. x86-64 version. > > + Copyright (C) 2020 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. > > + > > + In addition to the permissions in the GNU Lesser General Public > > + License, the Free Software Foundation gives you unlimited > > + permission to link the compiled version of this file with other > > + programs, and to distribute those programs without any restriction > > + coming from the use of this file. (The Lesser General Public > > + License restrictions do apply in other respects; for example, they > > + cover modification of the file, and distribution when not linked > > + into another program.) > > + > > + 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 > > Ok. > > > diff --git a/sysdeps/x86/configure b/sysdeps/x86/configure > > index 81cc4e80d6..5e32dc62b3 100644 > > --- a/sysdeps/x86/configure > > +++ b/sysdeps/x86/configure > > @@ -68,3 +68,82 @@ elif test $enable_cet = permissive; then > > fi > > config_vars="$config_vars > > enable-cet = $enable_cet" > > + > > +# Check if linker supports x86 ISA level. > > +{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for linker x86 ISA level support" >&5 > > +$as_echo_n "checking for linker x86 ISA level support... " >&6; } > > +if ${libc_cv_include_x86_isa_level+:} false; then : > > + $as_echo_n "(cached) " >&6 > > +else > > + cat > conftest1.S < > +#ifdef __LP64__ > > +# define P2ALIGN 3 > > +#else > > +# define P2ALIGN 2 > > +#endif > > + .section ".note.gnu.property", "a" > > + .p2align P2ALIGN > > + .long 1f - 0f /* name length. */ > > + .long 4f - 1f /* data length. */ > > + /* NT_GNU_PROPERTY_TYPE_0 */ > > + .long 5 /* note type. */ > > +0: > > + .asciz "GNU" /* vendor name. */ > > +1: > > + .p2align P2ALIGN > > + /* GNU_PROPERTY_X86_ISA_1_NEEDED */ > > + .long 0xc0008002 /* pr_type. */ > > + .long 3f - 2f /* pr_datasz. */ > > +2: > > + .long 0x1 > > +3: > > + .p2align P2ALIGN > > +4: > > +EOF > > +cat > conftest2.S < > +#ifdef __LP64__ > > +# define P2ALIGN 3 > > +#else > > +# define P2ALIGN 2 > > +#endif > > + .section ".note.gnu.property", "a" > > + .p2align P2ALIGN > > + .long 1f - 0f /* name length. */ > > + .long 4f - 1f /* data length. */ > > + /* NT_GNU_PROPERTY_TYPE_0 */ > > + .long 5 /* note type. */ > > +0: > > + .asciz "GNU" /* vendor name. */ > > +1: > > + .p2align P2ALIGN > > + /* GNU_PROPERTY_X86_ISA_1_NEEDED */ > > + .long 0xc0008002 /* pr_type. */ > > + .long 3f - 2f /* pr_datasz. */ > > +2: > > + .long 0x2 > > +3: > > + .p2align P2ALIGN > > +4: > > +EOF > > +libc_cv_include_x86_isa_level=no > > +if { ac_try='${CC-cc} $CFLAGS $CPPFLAGS -nostartfiles -nostdlib -r -o conftest conftest1.S conftest2.S' > > + { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5 > > + (eval $ac_try) 2>&5 > > + ac_status=$? > > + $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 > > + test $ac_status = 0; }; }; then > > + count=`LC_ALL=C $READELF -n conftest | grep NT_GNU_PROPERTY_TYPE_0 | wc -l` > > + if test "$count" = 1; then > > + libc_cv_include_x86_isa_level=yes > > + fi > > +fi > > +rm -f conftest* > > +fi > > +{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $libc_cv_include_x86_isa_level" >&5 > > +$as_echo "$libc_cv_include_x86_isa_level" >&6; } > > +if test $libc_cv_include_x86_isa_level = yes; then > > + $as_echo "#define INCLUDE_X86_ISA_LEVEL 1" >>confdefs.h > > + > > +fi > > +config_vars="$config_vars > > +enable-x86-isa-level = $libc_cv_include_x86_isa_level" > > diff --git a/sysdeps/x86/configure.ac b/sysdeps/x86/configure.ac > > index 8f3e1191f6..f94088f377 100644 > > --- a/sysdeps/x86/configure.ac > > +++ b/sysdeps/x86/configure.ac > > @@ -43,3 +43,69 @@ elif test $enable_cet = permissive; then > > AC_DEFINE(DEFAULT_DL_X86_CET_CONTROL, cet_permissive) > > fi > > LIBC_CONFIG_VAR([enable-cet], [$enable_cet]) > > + > > +# Check if linker supports x86 ISA level. > > +AC_CACHE_CHECK([for linker x86 ISA level support], > > + libc_cv_include_x86_isa_level, [dnl > > +cat > conftest1.S < > +#ifdef __LP64__ > > +# define P2ALIGN 3 > > +#else > > +# define P2ALIGN 2 > > +#endif > > + .section ".note.gnu.property", "a" > > + .p2align P2ALIGN > > + .long 1f - 0f /* name length. */ > > + .long 4f - 1f /* data length. */ > > + /* NT_GNU_PROPERTY_TYPE_0 */ > > + .long 5 /* note type. */ > > +0: > > + .asciz "GNU" /* vendor name. */ > > +1: > > + .p2align P2ALIGN > > + /* GNU_PROPERTY_X86_ISA_1_NEEDED */ > > + .long 0xc0008002 /* pr_type. */ > > + .long 3f - 2f /* pr_datasz. */ > > +2: > > + .long 0x1 > > +3: > > + .p2align P2ALIGN > > +4: > > +EOF > > +cat > conftest2.S < > +#ifdef __LP64__ > > +# define P2ALIGN 3 > > +#else > > +# define P2ALIGN 2 > > +#endif > > + .section ".note.gnu.property", "a" > > + .p2align P2ALIGN > > + .long 1f - 0f /* name length. */ > > + .long 4f - 1f /* data length. */ > > + /* NT_GNU_PROPERTY_TYPE_0 */ > > + .long 5 /* note type. */ > > +0: > > + .asciz "GNU" /* vendor name. */ > > +1: > > + .p2align P2ALIGN > > + /* GNU_PROPERTY_X86_ISA_1_NEEDED */ > > + .long 0xc0008002 /* pr_type. */ > > + .long 3f - 2f /* pr_datasz. */ > > +2: > > + .long 0x2 > > +3: > > + .p2align P2ALIGN > > +4: > > +EOF > > +libc_cv_include_x86_isa_level=no > > +if AC_TRY_COMMAND(${CC-cc} $CFLAGS $CPPFLAGS -nostartfiles -nostdlib -r -o conftest conftest1.S conftest2.S); then > > + count=`LC_ALL=C $READELF -n conftest | grep NT_GNU_PROPERTY_TYPE_0 | wc -l` > > + if test "$count" = 1; then > > + libc_cv_include_x86_isa_level=yes > > + fi > > +fi > > +rm -f conftest*]) > > +if test $libc_cv_include_x86_isa_level = yes; then > > + AC_DEFINE(INCLUDE_X86_ISA_LEVEL) > > +fi > > +LIBC_CONFIG_VAR([enable-x86-isa-level], [$libc_cv_include_x86_isa_level]) > > Skipping autogenerated file. > > > diff --git a/sysdeps/x86/cpu-features.c b/sysdeps/x86/cpu-features.c > > index 529c586193..e7da682a2e 100644 > > --- a/sysdeps/x86/cpu-features.c > > +++ b/sysdeps/x86/cpu-features.c > > @@ -19,6 +19,7 @@ > > #include > > #include > > #include > > +#include > > #if IS_IN (libc) && !defined SHARED > > # include > > # include > > @@ -290,6 +291,8 @@ update_usable (struct cpu_features *cpu_features) > > CPU_FEATURE_SET_USABLE (cpu_features, KL); > > CPU_FEATURE_SET_USABLE (cpu_features, WIDE_KL); > > } > > + > > + cpu_features->isa_1 = get_isa_level (cpu_features); > > } > > > > static void > > Ok. > > > diff --git a/sysdeps/x86/dl-cet.c b/sysdeps/x86/dl-cet.c > > index b4910f7634..ed7fd6d10d 100644 > > --- a/sysdeps/x86/dl-cet.c > > +++ b/sysdeps/x86/dl-cet.c > > @@ -76,10 +76,12 @@ dl_cet_check (struct link_map *m, const char *program) > > */ > > enable_ibt &= (HAS_CPU_FEATURE (IBT) > > && (enable_ibt_type == cet_always_on > > - || (m->l_cet & lc_ibt) != 0)); > > + || (m->l_x86_feature_1_and > > + & GNU_PROPERTY_X86_FEATURE_1_IBT) != 0)); > > enable_shstk &= (HAS_CPU_FEATURE (SHSTK) > > && (enable_shstk_type == cet_always_on > > - || (m->l_cet & lc_shstk) != 0)); > > + || (m->l_x86_feature_1_and > > + & GNU_PROPERTY_X86_FEATURE_1_SHSTK) != 0)); > > } > > > > /* ld.so is CET-enabled by kernel. But shared objects may not > > Ok. > > > @@ -111,7 +113,8 @@ dl_cet_check (struct link_map *m, const char *program) > > /* IBT is enabled only if it is enabled in executable as > > well as all shared objects. */ > > enable_ibt &= (enable_ibt_type == cet_always_on > > - || (l->l_cet & lc_ibt) != 0); > > + || (l->l_x86_feature_1_and > > + & GNU_PROPERTY_X86_FEATURE_1_IBT) != 0); > > if (!found_ibt_legacy && enable_ibt != ibt_enabled) > > { > > found_ibt_legacy = true; > > @@ -121,7 +124,8 @@ dl_cet_check (struct link_map *m, const char *program) > > /* SHSTK is enabled only if it is enabled in executable as > > well as all shared objects. */ > > enable_shstk &= (enable_shstk_type == cet_always_on > > - || (l->l_cet & lc_shstk) != 0); > > + || (l->l_x86_feature_1_and > > + & GNU_PROPERTY_X86_FEATURE_1_SHSTK) != 0); > > if (enable_shstk != shstk_enabled) > > { > > found_shstk_legacy = true; > > Ok. > > > diff --git a/sysdeps/x86/dl-prop.h b/sysdeps/x86/dl-prop.h > > index ce1667dc7a..56bd020b3c 100644 > > --- a/sysdeps/x86/dl-prop.h > > +++ b/sysdeps/x86/dl-prop.h > > @@ -19,14 +19,54 @@ > > #ifndef _DL_PROP_H > > #define _DL_PROP_H > > > > +#include > > + > > extern void _dl_cet_check (struct link_map *, const char *) > > attribute_hidden; > > extern void _dl_cet_open_check (struct link_map *) > > attribute_hidden; > > > > +static void > > +dl_isa_level_check (struct link_map *m, const char *program) > > +{ > > + const struct cpu_features *cpu_features = __get_cpu_features (); > > + unsigned int i; > > + struct link_map *l; > > + > > + i = m->l_searchlist.r_nlist; > > + while (i-- > 0) > > + { > > + /* Check each shared object to see if ISA level is compatible. */ > > + l = m->l_initfini[i]; > > + > > + /* Skip ISA level check if functions have been executed. */ > > + if (l->l_init_called) > > + continue; > > + > > +#ifdef SHARED > > + /* Skip ISA level check for ld.so since ld.so won't run if its ISA > > + level is higher than CPU. */ > > + if (l == &GL(dl_rtld_map) || l->l_real == &GL(dl_rtld_map)) > > + continue; > > +#endif > > + > > + if ((l->l_x86_isa_1_needed & cpu_features->isa_1) > > + != l->l_x86_isa_1_needed) > > + { > > + if (program) > > + _dl_fatal_printf ("%s: CPU ISA level is lower than required\n", > > + *l->l_name != '\0' ? l->l_name : program); > > + else > > + _dl_signal_error (0, l->l_name, "dlopen", > > + N_("CPU ISA level is lower than required")); > > + } > > + } > > +} > > + > > Ok. > > > static inline void __attribute__ ((always_inline)) > > _rtld_main_check (struct link_map *m, const char *program) > > { > > + dl_isa_level_check (m, program); > > #if CET_ENABLED > > _dl_cet_check (m, program); > > #endif > > @@ -35,20 +75,18 @@ _rtld_main_check (struct link_map *m, const char *program) > > static inline void __attribute__ ((always_inline)) > > _dl_open_check (struct link_map *m) > > { > > + dl_isa_level_check (m, NULL); > > #if CET_ENABLED > > _dl_cet_open_check (m); > > #endif > > } > > > > static inline void __attribute__ ((unused)) > > -_dl_process_cet_property_note (struct link_map *l, > > - const ElfW(Nhdr) *note, > > - const ElfW(Addr) size, > > - const ElfW(Addr) align) > > +_dl_process_property_note (struct link_map *l, const ElfW(Nhdr) *note, > > + const ElfW(Addr) size, const ElfW(Addr) align) > > { > > -#if CET_ENABLED > > /* Skip if we have seen a NT_GNU_PROPERTY_TYPE_0 note before. */ > > - if (l->l_cet != lc_unknown) > > + if (l->l_property != lc_property_unknown) > > return; > > > > /* The NT_GNU_PROPERTY_TYPE_0 note must be aliged to 4 bytes in > > Ok. > > > @@ -59,7 +97,8 @@ _dl_process_cet_property_note (struct link_map *l, > > > > const ElfW(Addr) start = (ElfW(Addr)) note; > > > > - unsigned int feature_1 = 0; > > + unsigned int feature_1_and = 0; > > + unsigned int isa_1_needed = 0; > > unsigned int last_type = 0; > > > > while ((ElfW(Addr)) (note + 1) - start < size) > > @@ -71,11 +110,11 @@ _dl_process_cet_property_note (struct link_map *l, > > { > > /* Stop if we see more than one GNU property note which may > > be generated by the older linker. */ > > - if (l->l_cet != lc_unknown) > > + if (l->l_property != lc_property_unknown) > > return; > > > > - /* Check CET status now. */ > > - l->l_cet = lc_none; > > + /* Check CET status and ISA levels now. */ > > + l->l_property = lc_property_none; > > > > /* Check for invalid property. */ > > if (note->n_descsz < 8 > > @@ -101,26 +140,37 @@ _dl_process_cet_property_note (struct link_map *l, > > > > last_type = type; > > > > - if (type == GNU_PROPERTY_X86_FEATURE_1_AND) > > + if (type == GNU_PROPERTY_X86_FEATURE_1_AND > > + || type == GNU_PROPERTY_X86_ISA_1_NEEDED) > > { > > - /* The size of GNU_PROPERTY_X86_FEATURE_1_AND is 4 > > - bytes. When seeing GNU_PROPERTY_X86_FEATURE_1_AND, > > - we stop the search regardless if its size is correct > > - or not. There is no point to continue if this note > > - is ill-formed. */ > > + /* The sizes of types which we are searching for are > > + 4 bytes. There is no point to continue if this > > + note is ill-formed. */ > > if (datasz != 4) > > return; > > > > - feature_1 = *(unsigned int *) ptr; > > - > > - /* Keep searching for the next GNU property note > > - generated by the older linker. */ > > - break; > > + /* NB: Stop the scan only after seeing all types which > > + we are searching for. */ > > + _Static_assert ((GNU_PROPERTY_X86_ISA_1_NEEDED > > > + GNU_PROPERTY_X86_FEATURE_1_AND), > > + "GNU_PROPERTY_X86_ISA_1_NEEDED > " > > + "GNU_PROPERTY_X86_FEATURE_1_AND"); > > + if (type == GNU_PROPERTY_X86_FEATURE_1_AND) > > + feature_1_and = *(unsigned int *) ptr; > > + else > > + { > > + isa_1_needed = *(unsigned int *) ptr; > > + > > + /* Keep searching for the next GNU property note > > + generated by the older linker. */ > > + break; > > + } > > } > > - else if (type > GNU_PROPERTY_X86_FEATURE_1_AND) > > + else if (type > GNU_PROPERTY_X86_ISA_1_NEEDED) > > { > > - /* Stop since property type is in ascending order. */ > > - return; > > + /* Stop the scan since property type is in ascending > > + order. */ > > + break; > > } > > > > /* Check the next property item. */ > > Ok. > > > @@ -137,18 +187,21 @@ _dl_process_cet_property_note (struct link_map *l, > > } > > > > /* We get here only if there is one or no GNU property note. */ > > - if ((feature_1 & GNU_PROPERTY_X86_FEATURE_1_IBT)) > > - l->l_cet |= lc_ibt; > > - if ((feature_1 & GNU_PROPERTY_X86_FEATURE_1_SHSTK)) > > - l->l_cet |= lc_shstk; > > -#endif > > + if (isa_1_needed != 0 || feature_1_and != 0) > > + { > > + l->l_property = lc_property_valid; > > + l->l_x86_isa_1_needed = isa_1_needed; > > + l->l_x86_feature_1_and = feature_1_and; > > + } > > + else > > + l->l_property = lc_property_none; > > } > > > > static inline void __attribute__ ((unused)) > > _dl_process_pt_note (struct link_map *l, int fd, const ElfW(Phdr) *ph) > > { > > const ElfW(Nhdr) *note = (const void *) (ph->p_vaddr + l->l_addr); > > - _dl_process_cet_property_note (l, note, ph->p_memsz, ph->p_align); > > + _dl_process_property_note (l, note, ph->p_memsz, ph->p_align); > > } > > > > static inline int __attribute__ ((always_inline)) > > Ok. > > > diff --git a/sysdeps/x86/get-isa-level.h b/sysdeps/x86/get-isa-level.h > > new file mode 100644 > > index 0000000000..a86e1e8941 > > --- /dev/null > > +++ b/sysdeps/x86/get-isa-level.h > > @@ -0,0 +1,66 @@ > > +/* Get x86 ISA level. > > + This file is part of the GNU C Library. > > + Copyright (C) 2020 Free Software Foundation, Inc. > > + > > + 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 > > + > > +/* Get GNU_PROPERTY_X86_ISA_1_BASELINE and GNU_PROPERTY_X86_ISA_1_V[234] > > + ISA level. */ > > + > > +static unsigned int > > +get_isa_level (const struct cpu_features *cpu_features) > > +{ > > + unsigned int isa_level = 0; > > + > > + if (CPU_FEATURE_USABLE_P (cpu_features, CMOV) > > + && CPU_FEATURE_USABLE_P (cpu_features, CX8) > > + && CPU_FEATURE_CPU_P (cpu_features, FPU) > > + && CPU_FEATURE_USABLE_P (cpu_features, FXSR) > > + && CPU_FEATURE_USABLE_P (cpu_features, MMX) > > + && CPU_FEATURE_USABLE_P (cpu_features, SSE) > > + && CPU_FEATURE_USABLE_P (cpu_features, SSE2)) > > + { > > + isa_level = GNU_PROPERTY_X86_ISA_1_BASELINE; > > + if (CPU_FEATURE_USABLE_P (cpu_features, CMPXCHG16B) > > + && CPU_FEATURE_USABLE_P (cpu_features, LAHF64_SAHF64) > > + && CPU_FEATURE_USABLE_P (cpu_features, POPCNT) > > + && CPU_FEATURE_USABLE_P (cpu_features, SSE3) > > + && CPU_FEATURE_USABLE_P (cpu_features, SSSE3) > > + && CPU_FEATURE_USABLE_P (cpu_features, SSE4_1) > > + && CPU_FEATURE_USABLE_P (cpu_features, SSE4_2)) > > + { > > + isa_level |= GNU_PROPERTY_X86_ISA_1_V2; > > + if (CPU_FEATURE_USABLE_P (cpu_features, AVX) > > + && CPU_FEATURE_USABLE_P (cpu_features, AVX2) > > + && CPU_FEATURE_USABLE_P (cpu_features, F16C) > > + && CPU_FEATURE_USABLE_P (cpu_features, FMA) > > + && CPU_FEATURE_USABLE_P (cpu_features, LZCNT) > > + && CPU_FEATURE_USABLE_P (cpu_features, MOVBE)) > > + { > > + isa_level |= GNU_PROPERTY_X86_ISA_1_V3; > > + if (CPU_FEATURE_USABLE_P (cpu_features, AVX512F) > > + && CPU_FEATURE_USABLE_P (cpu_features, AVX512BW) > > + && CPU_FEATURE_USABLE_P (cpu_features, AVX512CD) > > + && CPU_FEATURE_USABLE_P (cpu_features, AVX512DQ) > > + && CPU_FEATURE_USABLE_P (cpu_features, AVX512VL)) > > + isa_level |= GNU_PROPERTY_X86_ISA_1_V4; > > + } > > + } > > + } > > + > > + return isa_level; > > +} > > Ok, is there any plan to add the gcc ISA_1_VX for 32-bit ABI as well? I am > asking because if there is no upcoming plan maybe an option is just to > return 0 for !__X86_64__. Although there is no official plan to support it in 32-bit, since the ISA level support implemented in GCC and binutils is independent of 32-bit or 64-bit, 32-bit also get the same feature: [hjl@gnu-cfl-2 tmp]$ touch x.c [hjl@gnu-cfl-2 tmp]$ /usr/gcc-11.0.0-x32/bin/gcc -c -mneeded x.c -mavx2 [hjl@gnu-cfl-2 tmp]$ readelf -n x.o Displaying notes found in: .note.gnu.property Owner Data size Description GNU 0x00000010 NT_GNU_PROPERTY_TYPE_0 Properties: x86 ISA needed: x86-64-baseline, x86-64-v2, x86-64-v3 GNU 0x00000020 NT_GNU_PROPERTY_TYPE_0 Properties: x86 ISA used: x86 feature used: x86 [hjl@gnu-cfl-2 tmp]$ /usr/gcc-11.0.0-x32/bin/gcc -c -mneeded x.c -mavx2 -m32 [hjl@gnu-cfl-2 tmp]$ readelf -n x.o Displaying notes found in: .note.gnu.property Owner Data size Description GNU 0x0000000c NT_GNU_PROPERTY_TYPE_0 Properties: x86 ISA needed: x86-64-baseline, x86-64-v2, x86-64-v3 GNU 0x00000018 NT_GNU_PROPERTY_TYPE_0 Properties: x86 ISA used: x86 feature used: x86 [hjl@gnu-cfl-2 tmp]$ The glibc implementation also works on 32-bit. > > diff --git a/sysdeps/x86/include/cpu-features.h b/sysdeps/x86/include/cpu-features.h > > index ffe300c931..99e7ee08cf 100644 > > --- a/sysdeps/x86/include/cpu-features.h > > +++ b/sysdeps/x86/include/cpu-features.h > > @@ -123,6 +123,8 @@ struct cpu_features > > struct cpu_features_basic basic; > > struct cpuid_features features[COMMON_CPUID_INDEX_MAX]; > > unsigned int preferred[PREFERRED_FEATURE_INDEX_MAX]; > > + /* X86 micro-architecture ISA levels. */ > > + unsigned int isa_1; > > /* The state size for XSAVEC or XSAVE. The type must be unsigned long > > int so that we use > > > > Ok. > > > diff --git a/sysdeps/x86/isa-level.c b/sysdeps/x86/isa-level.c > > new file mode 100644 > > index 0000000000..aaf524cb56 > > --- /dev/null > > +++ b/sysdeps/x86/isa-level.c > > @@ -0,0 +1,97 @@ > > +/* ELF program property for x86 ISA level. > > + Copyright (C) 2020 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. > > + > > + In addition to the permissions in the GNU Lesser General Public > > + License, the Free Software Foundation gives you unlimited > > + permission to link the compiled version of this file with other > > + programs, and to distribute those programs without any restriction > > + coming from the use of this file. (The Lesser General Public > > + License restrictions do apply in other respects; for example, they > > + cover modification of the file, and distribution when not linked > > + into another program.) > > + > > + 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 > > + > > +/* ELF program property for x86 ISA level. */ > > +#ifdef INCLUDE_X86_ISA_LEVEL > > +# if defined __x86_64__ || defined __FXSR__ || !defined _SOFT_FLOAT \ > > + || defined __MMX__ || defined __SSE__ || defined __SSE2__ > > +# define ISA_BASELINE GNU_PROPERTY_X86_ISA_1_BASELINE > > +# else > > +# define ISA_BASELINE 0 > > +# endif > > + > > +# if defined __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 \ > > + || (defined __x86_64__ && defined __LAHF_SAHF__) \ > > + || defined __POPCNT__ || defined __SSE3__ \ > > + || defined __SSSE3__ || defined __SSE4_1__ || defined __SSE4_2__ > > +# define ISA_V2 GNU_PROPERTY_X86_ISA_1_V2 > > +# else > > +# define ISA_V2 0 > > +# endif > > + > > +# if defined __AVX__ || defined __AVX2__ || defined __F16C__ \ > > + || defined __FMA__ || defined __LZCNT__ || defined __MOVBE__ \ > > + || defined __XSAVE__ > > +# define ISA_V3 GNU_PROPERTY_X86_ISA_1_V3 > > +# else > > +# define ISA_V3 0 > > +# endif > > + > > +# if defined __AVX512F__ || defined __AVX512BW__ || defined __AVX512CD__ \ > > + || defined __AVX512DQ__ || defined __AVX512VL__ > > +# define ISA_V4 GNU_PROPERTY_X86_ISA_1_V4 > > +# else > > +# define ISA_V4 0 > > +# endif > > + > > +# ifndef ISA_LEVEL > > +# define ISA_LEVEL (ISA_BASELINE | ISA_V2 | ISA_V3 | ISA_V4) > > +# endif > > + > > +# if ISA_LEVEL > > +# ifdef __LP64__ > > +# define PROPERTY_ALIGN 3 > > +# else > > +# define PROPERTY_ALIGN 2 > > +# endif > > + > > +# define note_stringify(arg) note_stringify_1(arg) > > +# define note_stringify_1(arg) #arg > > + > > +asm(".pushsection \".note.gnu.property\",\"a\",@note\n" > > +" .p2align " note_stringify (PROPERTY_ALIGN) > > + /* name length. */ > > +"\n .long 1f - 0f\n" > > + /* data length. */ > > +" .long 4f - 1f\n" > > + /* note type: NT_GNU_PROPERTY_TYPE_0. */ > > +" .long " note_stringify (NT_GNU_PROPERTY_TYPE_0) > > + /* vendor name. */ > > +"\n0: .asciz \"GNU\"\n" > > +"1: .p2align " note_stringify (PROPERTY_ALIGN) > > + /* pr_type: GNU_PROPERTY_X86_ISA_1_NEEDED. */ > > +"\n .long " note_stringify (GNU_PROPERTY_X86_ISA_1_NEEDED) > > + /* pr_datasz. */ > > +"\n .long 3f - 2f\n" > > + /* GNU_PROPERTY_X86_ISA_1_V[234]. */ > > +"2:\n .long " note_stringify (ISA_LEVEL) > > +"\n3:\n .p2align " note_stringify (PROPERTY_ALIGN) > > +"\n4:\n .popsection"); > > +# endif /* ISA_LEVEL */ > > +#endif /* INCLUDE_X86_ISA_LEVEL */ > > Ok. > > > diff --git a/sysdeps/x86/link_map.h b/sysdeps/x86/link_map.h > > index 8074739b47..4c46a25f83 100644 > > --- a/sysdeps/x86/link_map.h > > +++ b/sysdeps/x86/link_map.h > > @@ -16,12 +16,16 @@ > > License along with the GNU C Library; if not, see > > . */ > > > > -/* If this object is enabled with CET. */ > > +/* if this object has GNU property. */ > > enum > > { > > - lc_unknown = 0, /* Unknown CET status. */ > > - lc_none = 1 << 0, /* Not enabled with CET. */ > > - lc_ibt = 1 << 1, /* Enabled with IBT. */ > > - lc_shstk = 1 << 2, /* Enabled with STSHK. */ > > - lc_ibt_and_shstk = lc_ibt | lc_shstk /* Enabled with both. */ > > - } l_cet:3; > > + lc_property_unknown = 0, /* Unknown property status. */ > > + lc_property_none = 1 << 0, /* No property. */ > > + lc_property_valid = 1 << 1 /* Has valid property. */ > > + } l_property:2; > > + > > +/* GNU_PROPERTY_X86_FEATURE_1_AND of this object. */ > > +unsigned int l_x86_feature_1_and; > > + > > +/* GNU_PROPERTY_X86_ISA_1_NEEDED of this object. */ > > +unsigned int l_x86_isa_1_needed; > > Ok. > > > diff --git a/sysdeps/x86/tst-isa-level-1.c b/sysdeps/x86/tst-isa-level-1.c > > new file mode 100644 > > index 0000000000..dc31d71ad2 > > --- /dev/null > > +++ b/sysdeps/x86/tst-isa-level-1.c > > @@ -0,0 +1,104 @@ > > +/* Check ISA level on dlopened shared object. > > + Copyright (C) 2020 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 > > +#include > > +#include > > +#include > > + > > +static void > > +do_test_1 (const char *modname, bool fail) > > +{ > > + int (*fp) (void); > > + void *h; > > + > > + h = dlopen (modname, RTLD_LAZY); > > + if (h == NULL) > > + { > > + const char *err = dlerror (); > > + if (fail) > > + { > > + if (strstr (err, "CPU ISA level is lower than required") == NULL) > > + FAIL_EXIT1 ("incorrect dlopen '%s' error: %s\n", modname, err); > > + > > + return; > > + } > > + > > + FAIL_EXIT1 ("cannot open '%s': %s\n", modname, err); > > + } > > + > > + if (fail) > > + FAIL_EXIT1 ("dlopen '%s' should have failed\n", modname); > > + > > + fp = xdlsym (h, "test"); > > + > > + if (fp () != 0) > > + FAIL_EXIT1 ("test () != 0\n"); > > + > > + dlclose (h); > > +} > > + > > +static int > > +do_test (void) > > +{ > > + const struct cpu_features *cpu_features > > + = __x86_get_cpu_features (COMMON_CPUID_INDEX_MAX); > > + unsigned int isa_level = get_isa_level (cpu_features); > > + bool has_isa_baseline = ((isa_level & GNU_PROPERTY_X86_ISA_1_BASELINE) > > + == GNU_PROPERTY_X86_ISA_1_BASELINE); > > + bool has_isa_v2 = ((isa_level & GNU_PROPERTY_X86_ISA_1_V2) > > + == GNU_PROPERTY_X86_ISA_1_V2); > > + bool has_isa_v3 = ((isa_level & GNU_PROPERTY_X86_ISA_1_V3) > > + == GNU_PROPERTY_X86_ISA_1_V3); > > + bool has_isa_v4 = ((isa_level & GNU_PROPERTY_X86_ISA_1_V4) > > + == GNU_PROPERTY_X86_ISA_1_V4); > > + > > + if (!has_isa_baseline) > > + { > > + do_test_1 ("tst-isa-level-mod-1-baseline.so", true); > > + return EXIT_SUCCESS; > > + } > > + > > + do_test_1 ("tst-isa-level-mod-1-baseline.so", false); > > + > > + /* Skip on x86-64-v4 platforms since dlopen v4 module always works. */ > > + if (has_isa_v4) > > + return EXIT_UNSUPPORTED; > > Not sure if unsupported is the right error code here, since the isa > selection is just ignored (not really not supported). I will change it to EXIT_SUCCESS. > > + > > + do_test_1 ("tst-isa-level-mod-1-v4.so", true); > > + > > + /* Skip on x86-64-v3 platforms since dlopen v3 module always works. */ > > + if (has_isa_v3) > > + return EXIT_SUCCESS; > > + > > + do_test_1 ("tst-isa-level-mod-1-v3.so", true); > > + > > + /* Skip on x86-64-v2 platforms since dlopen v2 module always works. */ > > + if (has_isa_v2) > > + return EXIT_SUCCESS; > > + > > + do_test_1 ("tst-isa-level-mod-1-v2.so", true); > > + > > + return EXIT_SUCCESS; > > +} > > + > > +#include > > diff --git a/sysdeps/x86/tst-isa-level-mod-1-baseline.c b/sysdeps/x86/tst-isa-level-mod-1-baseline.c > > new file mode 100644 > > index 0000000000..d6fe0685a4 > > --- /dev/null > > +++ b/sysdeps/x86/tst-isa-level-mod-1-baseline.c > > @@ -0,0 +1 @@ > > +#include "tst-isa-level-mod-1.c" > > diff --git a/sysdeps/x86/tst-isa-level-mod-1-v2.c b/sysdeps/x86/tst-isa-level-mod-1-v2.c > > new file mode 100644 > > index 0000000000..d6fe0685a4 > > --- /dev/null > > +++ b/sysdeps/x86/tst-isa-level-mod-1-v2.c > > @@ -0,0 +1 @@ > > +#include "tst-isa-level-mod-1.c" > > diff --git a/sysdeps/x86/tst-isa-level-mod-1-v3.c b/sysdeps/x86/tst-isa-level-mod-1-v3.c > > new file mode 100644 > > index 0000000000..d6fe0685a4 > > --- /dev/null > > +++ b/sysdeps/x86/tst-isa-level-mod-1-v3.c > > @@ -0,0 +1 @@ > > +#include "tst-isa-level-mod-1.c" > > diff --git a/sysdeps/x86/tst-isa-level-mod-1-v4.c b/sysdeps/x86/tst-isa-level-mod-1-v4.c > > new file mode 100644 > > index 0000000000..d6fe0685a4 > > --- /dev/null > > +++ b/sysdeps/x86/tst-isa-level-mod-1-v4.c > > @@ -0,0 +1 @@ > > +#include "tst-isa-level-mod-1.c" > > Ok. > > > diff --git a/sysdeps/x86/tst-isa-level-mod-1.c b/sysdeps/x86/tst-isa-level-mod-1.c > > new file mode 100644 > > index 0000000000..40a2e1d99f > > --- /dev/null > > +++ b/sysdeps/x86/tst-isa-level-mod-1.c > > @@ -0,0 +1,25 @@ > > +/* Check ISA level on dlopened shared object. > > + Copyright (C) 2019-2020 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 > > + > > +int > > +test (void) > > +{ > > + return 0; > > +} > > Ok. > > > diff --git a/sysdeps/x86_64/dl-hwcaps-subdirs.c b/sysdeps/x86_64/dl-hwcaps-subdirs.c > > index 0aaa635a00..e030534f1b 100644 > > --- a/sysdeps/x86_64/dl-hwcaps-subdirs.c > > +++ b/sysdeps/x86_64/dl-hwcaps-subdirs.c > > @@ -18,6 +18,7 @@ > > > > #include > > #include > > +#include > > > > const char _dl_hwcaps_subdirs[] = "x86-64-v4:x86-64-v3:x86-64-v2"; > > enum { subdirs_count = 3 }; /* Number of components in _dl_hwcaps_subdirs. */ > > @@ -25,40 +26,25 @@ enum { subdirs_count = 3 }; /* Number of components in _dl_hwcaps_subdirs. */ > > uint32_t > > _dl_hwcaps_subdirs_active (void) > > { > > + const struct cpu_features *cpu_features > > + = __x86_get_cpu_features (COMMON_CPUID_INDEX_MAX); > > + unsigned int isa_level = get_isa_level (cpu_features); > > int active = 0; > > > > /* Test in reverse preference order. */ > > > > /* x86-64-v2. */ > > - if (!(CPU_FEATURE_USABLE (CMPXCHG16B) > > - && CPU_FEATURE_USABLE (LAHF64_SAHF64) > > - && CPU_FEATURE_USABLE (POPCNT) > > - && CPU_FEATURE_USABLE (SSE3) > > - && CPU_FEATURE_USABLE (SSE4_1) > > - && CPU_FEATURE_USABLE (SSE4_2) > > - && CPU_FEATURE_USABLE (SSSE3))) > > + if (!(isa_level & GNU_PROPERTY_X86_ISA_1_V2)) > > return _dl_hwcaps_subdirs_build_bitmask (subdirs_count, active); > > ++active; > > > > /* x86-64-v3. */ > > - if (!(CPU_FEATURE_USABLE (AVX) > > - && CPU_FEATURE_USABLE (AVX2) > > - && CPU_FEATURE_USABLE (BMI1) > > - && CPU_FEATURE_USABLE (BMI2) > > - && CPU_FEATURE_USABLE (F16C) > > - && CPU_FEATURE_USABLE (FMA) > > - && CPU_FEATURE_USABLE (LZCNT) > > - && CPU_FEATURE_USABLE (MOVBE) > > - && CPU_FEATURE_USABLE (OSXSAVE))) > > + if (!(isa_level & GNU_PROPERTY_X86_ISA_1_V3)) > > return _dl_hwcaps_subdirs_build_bitmask (subdirs_count, active); > > ++active; > > > > - /* x86-64-v4. */ > > - if (!(CPU_FEATURE_USABLE (AVX512F) > > - && CPU_FEATURE_USABLE (AVX512BW) > > - && CPU_FEATURE_USABLE (AVX512CD) > > - && CPU_FEATURE_USABLE (AVX512DQ) > > - && CPU_FEATURE_USABLE (AVX512VL))) > > + /* x86-64-v4. */ > > + if (!(isa_level & GNU_PROPERTY_X86_ISA_1_V4)) > > return _dl_hwcaps_subdirs_build_bitmask (subdirs_count, active); > > ++active; > > > > diff --git a/sysdeps/x86_64/tst-glibc-hwcaps.c b/sysdeps/x86_64/tst-glibc-hwcaps.c > > index 8bdcb91db0..37b61d3c84 100644 > > --- a/sysdeps/x86_64/tst-glibc-hwcaps.c > > +++ b/sysdeps/x86_64/tst-glibc-hwcaps.c > > @@ -19,7 +19,8 @@ > > #include > > #include > > #include > > -#include > > +#include > > +#include > > > > extern int marker2 (void); > > extern int marker3 (void); > > @@ -31,35 +32,15 @@ compute_level (void) > > { > > const struct cpu_features *cpu_features > > = __x86_get_cpu_features (COMMON_CPUID_INDEX_MAX); > > - > > - if (!(CPU_FEATURE_USABLE_P (cpu_features, CMPXCHG16B) > > - && CPU_FEATURE_USABLE_P (cpu_features, LAHF64_SAHF64) > > - && CPU_FEATURE_USABLE_P (cpu_features, POPCNT) > > - && CPU_FEATURE_USABLE_P (cpu_features, MMX) > > - && CPU_FEATURE_USABLE_P (cpu_features, SSE) > > - && CPU_FEATURE_USABLE_P (cpu_features, SSE2) > > - && CPU_FEATURE_USABLE_P (cpu_features, SSE3) > > - && CPU_FEATURE_USABLE_P (cpu_features, SSSE3) > > - && CPU_FEATURE_USABLE_P (cpu_features, SSE4_1) > > - && CPU_FEATURE_USABLE_P (cpu_features, SSE4_2))) > > - return 1; > > - if (!(CPU_FEATURE_USABLE_P (cpu_features, AVX) > > - && CPU_FEATURE_USABLE_P (cpu_features, AVX2) > > - && CPU_FEATURE_USABLE_P (cpu_features, BMI1) > > - && CPU_FEATURE_USABLE_P (cpu_features, BMI2) > > - && CPU_FEATURE_USABLE_P (cpu_features, F16C) > > - && CPU_FEATURE_USABLE_P (cpu_features, FMA) > > - && CPU_FEATURE_USABLE_P (cpu_features, LZCNT) > > - && CPU_FEATURE_USABLE_P (cpu_features, MOVBE) > > - && CPU_FEATURE_USABLE_P (cpu_features, OSXSAVE))) > > - return 2; > > - if (!(CPU_FEATURE_USABLE_P (cpu_features, AVX512F) > > - && CPU_FEATURE_USABLE_P (cpu_features, AVX512BW) > > - && CPU_FEATURE_USABLE_P (cpu_features, AVX512CD) > > - && CPU_FEATURE_USABLE_P (cpu_features, AVX512DQ) > > - && CPU_FEATURE_USABLE_P (cpu_features, AVX512VL))) > > - return 3; > > - return 4; > > + unsigned int isa_level = get_isa_level (cpu_features); > > + > > + if (!(isa_level & GNU_PROPERTY_X86_ISA_1_V2)) > > + return 1; > > + if (!(isa_level & GNU_PROPERTY_X86_ISA_1_V3)) > > + return 2; > > + if (!(isa_level & GNU_PROPERTY_X86_ISA_1_V4)) > > + return 3; > > + return 4; > > } > > > > static int > > -- > > 2.29.2 > > Ok. This is the patch I am checking in. Thanks. -- H.J. --000000000000b4614805b855b583 Content-Type: text/x-patch; charset="US-ASCII"; name="0001-x86-Support-GNU_PROPERTY_X86_ISA_1_V-234-marker-BZ-2.patch" Content-Disposition: attachment; filename="0001-x86-Support-GNU_PROPERTY_X86_ISA_1_V-234-marker-BZ-2.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kjnc1h650 RnJvbSA2ZGZhMWFjNjI2MzVlMDVkMTM2MDBiZDFlNmUwYTc3MGE0NDg3NWI0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiAiSC5KLiBMdSIgPGhqbC50b29sc0BnbWFpbC5jb20+CkRhdGU6 IEZyaSwgOSBPY3QgMjAyMCAwNjowNjo1NiAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIHg4NjogU3Vw cG9ydCBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1ZbMjM0XSBtYXJrZXIgW0JaICMyNjcxN10KCkdD QyAxMSBzdXBwb3J0cyAtbWFyY2g9eDg2LTY0LXZbMjM0XSB0byBlbmFibGUgeDg2IG1pY3JvLWFy Y2hpdGVjdHVyZSBJU0EKbGV2ZWxzOgoKaHR0cHM6Ly9nY2MuZ251Lm9yZy9idWd6aWxsYS9zaG93 X2J1Zy5jZ2k/aWQ9OTcyNTAKCmFuZCAtbW5lZWRlZCB0byBlbWl0IEdOVV9QUk9QRVJUWV9YODZf SVNBXzFfTkVFREVEIHByb3BlcnR5IHdpdGgKR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9WWzIzNF0g bWFya2VyOgoKaHR0cHM6Ly9naXRsYWIuY29tL3g4Ni1wc0FCSXMveDg2LTY0LUFCSS8tL21lcmdl X3JlcXVlc3RzLzEzCgpCaW51dGlscyBzdXBwb3J0IGZvciBHTlVfUFJPUEVSVFlfWDg2X0lTQV8x X1ZbMjM0XSBtYXJrZXIgd2VyZSBhZGRlZCBieQoKY29tbWl0IGIwYWIwNjkzNzM4NWUwYWUyNWNl YmYxOTkxNzg3ZDY0ZjQzOWJmMTIKQXV0aG9yOiBILkouIEx1IDxoamwudG9vbHNAZ21haWwuY29t PgpEYXRlOiAgIEZyaSBPY3QgMzAgMDY6NDk6NTcgMjAyMCAtMDcwMAoKICAgIHg4NjogU3VwcG9y dCBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX0JBU0VMSU5FIG1hcmtlcgoKYW5kCgpjb21taXQgMzI5 MzBlNGVkYmMwNmJjNmYxMGM0MzVkYmNjNjMxMzE3MTVkZjY3OApBdXRob3I6IEguSi4gTHUgPGhq bC50b29sc0BnbWFpbC5jb20+CkRhdGU6ICAgRnJpIE9jdCA5IDA1OjA1OjU3IDIwMjAgLTA3MDAK CiAgICB4ODY6IFN1cHBvcnQgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9WWzIzNF0gbWFya2VyCgpH TlVfUFJPUEVSVFlfWDg2X0lTQV8xX05FRURFRCBwcm9wZXJ0eSBpbiB4ODYgRUxGIGJpbmFyaWVz IGluZGljYXRlIHRoZQptaWNyby1hcmNoaXRlY3R1cmUgSVNBIGxldmVsIHJlcXVpcmVkIHRvIGV4 ZWN1dGUgdGhlIGJpbmFyeS4gIFRoZSBtYXJrZXIKbXVzdCBiZSBhZGRlZCBieSBwcm9ncmFtbWVy cyBleHBsaWNpdGx5IGluIG9uZSBvZiAzIHdheXM6CgoxLiBQYXNzIC1tbmVlZGVkIHRvIEdDQy4K Mi4gQWRkIHRoZSBtYXJrZXIgaW4gdGhlIGxpbmtlciBpbnB1dHMgYXMgdGhpcyBwYXRjaCBkb2Vz LgozLiBQYXNzIC16IHg4Ni02NC12WzIzNF0gdG8gdGhlIGxpbmtlci4KCkFkZCBHTlVfUFJPUEVS VFlfWDg2X0lTQV8xX0JBU0VMSU5FIGFuZCBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1ZbMjM0XQpt YXJrZXIgc3VwcG9ydCB0byBsZC5zbyBpZiBiaW51dGlscyAyLjMyIG9yIG5ld2VyIGlzIHVzZWQg dG8gYnVpbGQgZ2xpYmM6CgoxLiBBZGQgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9CQVNFTElORSBh bmQgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9WWzIzNF0KbWFya2VycyB0byBlbGYuaC4KMi4gQWRk IEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfQkFTRUxJTkUgYW5kIEdOVV9QUk9QRVJUWV9YODZfSVNB XzFfVlsyMzRdCm1hcmtlciB0byBhYmktbm90ZS5vIGJhc2VkIG9uIHRoZSBJU0EgbGV2ZWwgdXNl ZCB0byBjb21waWxlIGFiaS1ub3RlLm8sCmFzc3VtaW5nIHRoYXQgdGhlIHNhbWUgSVNBIGxldmVs IGlzIHVzZWQgdG8gY29tcGlsZSB0aGUgd2hvbGUgZ2xpYmMuCjMuIEFkZCBpc2FfMSB0byBjcHVf ZmVhdHVyZXMgdG8gcmVjb3JkIHRoZSBzdXBwb3J0ZWQgeDg2IElTQSBsZXZlbC4KNC4gUmVuYW1l IF9kbF9wcm9jZXNzX2NldF9wcm9wZXJ0eV9ub3RlIHRvIF9kbF9wcm9jZXNzX3Byb3BlcnR5X25v dGUgYW5kCmFkZCBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1ZbMjM0XSBtYXJrZXIgZGV0ZWN0aW9u Lgo1LiBVcGRhdGUgX3J0bGRfbWFpbl9jaGVjayBhbmQgX2RsX29wZW5fY2hlY2sgdG8gY2hlY2sg bG9hZGVkIG9iamVjdHMKd2l0aCB0aGUgaW5jb21wYXRpYmxlIElTQSBsZXZlbC4KNi4gQWRkIGEg dGVzdGNhc2UgdG8gdmVyaWZ5IHRoYXQgZGxvcGVuIGFuIHg4Ni02NC12NCBzaGFyZWQgb2JqZWN0 IGZhaWxzCm9uIGxlc3NlciBwbGF0Zm9ybXMuCjcuIFVzZSA8Z2V0LWlzYS1sZXZlbC5oPiBpbiBk bC1od2NhcHMtc3ViZGlycy5jIGFuZCB0c3QtZ2xpYmMtaHdjYXBzLmMuCgpUZXN0ZWQgdW5kZXIg aTY4NiwgeDMyIGFuZCB4ODYtNjQgbW9kZXMgb24geDg2LTY0LXYyLCB4ODYtNjQtdjMgYW5kCng4 Ni02NC12NCBtYWNoaW5lcy4KCk1hcmtlZCBlbGYvdHN0LWlzYS1sZXZlbC0xIHdpdGggeDg2LTY0 LXY0LCByYW4gaXQgb24geDg2LTY0LXYzIG1hY2hpbmUKYW5kIGdvdDoKCltoamxAZ251LWNmbC0y IGJ1aWxkLXg4Nl82NC1saW51eF0kIC4vZWxmL3RzdC1pc2EtbGV2ZWwtMQouL2VsZi90c3QtaXNh LWxldmVsLTE6IENQVSBJU0EgbGV2ZWwgaXMgbG93ZXIgdGhhbiByZXF1aXJlZApbaGpsQGdudS1j ZmwtMiBidWlsZC14ODZfNjQtbGludXhdJAotLS0KIGNvbmZpZy5oLmluICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICAgMyArCiBlbGYvZWxmLmggICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgMzUgKysrLS0tLQogc3lzZGVwcy94ODYvTWFrZWZpbGUgICAgICAgICAg ICAgICAgICAgICAgIHwgIDMwICsrKysrKwogc3lzZGVwcy94ODYvYWJpLW5vdGUuYyAgICAgICAg ICAgICAgICAgICAgIHwgIDI5ICsrKysrKwogc3lzZGVwcy94ODYvY29uZmlndXJlICAgICAgICAg ICAgICAgICAgICAgIHwgIDc5ICsrKysrKysrKysrKysrCiBzeXNkZXBzL3g4Ni9jb25maWd1cmUu YWMgICAgICAgICAgICAgICAgICAgfCAgNjYgKysrKysrKysrKysrCiBzeXNkZXBzL3g4Ni9jcHUt ZmVhdHVyZXMuYyAgICAgICAgICAgICAgICAgfCAgIDMgKwogc3lzZGVwcy94ODYvZGwtY2V0LmMg ICAgICAgICAgICAgICAgICAgICAgIHwgIDEyICsrLQogc3lzZGVwcy94ODYvZGwtcHJvcC5oICAg ICAgICAgICAgICAgICAgICAgIHwgMTEzICsrKysrKysrKysrKysrKy0tLS0tLQogc3lzZGVwcy94 ODYvZ2V0LWlzYS1sZXZlbC5oICAgICAgICAgICAgICAgIHwgIDY2ICsrKysrKysrKysrKwogc3lz ZGVwcy94ODYvaW5jbHVkZS9jcHUtZmVhdHVyZXMuaCAgICAgICAgIHwgICAyICsKIHN5c2RlcHMv eDg2L2lzYS1sZXZlbC5jICAgICAgICAgICAgICAgICAgICB8ICA5NyArKysrKysrKysrKysrKysr KysKIHN5c2RlcHMveDg2L2xpbmtfbWFwLmggICAgICAgICAgICAgICAgICAgICB8ICAxOCArKy0t CiBzeXNkZXBzL3g4Ni90c3QtaXNhLWxldmVsLTEuYyAgICAgICAgICAgICAgfCAxMDQgKysrKysr KysrKysrKysrKysrKwogc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZlbC1tb2QtMS1iYXNlbGluZS5j IHwgICAxICsKIHN5c2RlcHMveDg2L3RzdC1pc2EtbGV2ZWwtbW9kLTEtdjIuYyAgICAgICB8ICAg MSArCiBzeXNkZXBzL3g4Ni90c3QtaXNhLWxldmVsLW1vZC0xLXYzLmMgICAgICAgfCAgIDEgKwog c3lzZGVwcy94ODYvdHN0LWlzYS1sZXZlbC1tb2QtMS12NC5jICAgICAgIHwgICAxICsKIHN5c2Rl cHMveDg2L3RzdC1pc2EtbGV2ZWwtbW9kLTEuYyAgICAgICAgICB8ICAyNSArKysrKwogc3lzZGVw cy94ODZfNjQvZGwtaHdjYXBzLXN1YmRpcnMuYyAgICAgICAgIHwgIDMwICsrLS0tLQogc3lzZGVw cy94ODZfNjQvdHN0LWdsaWJjLWh3Y2Fwcy5jICAgICAgICAgIHwgIDQxICsrLS0tLS0tCiAyMSBm aWxlcyBjaGFuZ2VkLCA2NDQgaW5zZXJ0aW9ucygrKSwgMTEzIGRlbGV0aW9ucygtKQogY3JlYXRl IG1vZGUgMTAwNjQ0IHN5c2RlcHMveDg2L2FiaS1ub3RlLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBz eXNkZXBzL3g4Ni9nZXQtaXNhLWxldmVsLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBzeXNkZXBzL3g4 Ni9pc2EtbGV2ZWwuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IHN5c2RlcHMveDg2L3RzdC1pc2EtbGV2 ZWwtMS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZlbC1tb2Qt MS1iYXNlbGluZS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZl bC1tb2QtMS12Mi5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZl bC1tb2QtMS12My5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZl bC1tb2QtMS12NC5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZl bC1tb2QtMS5jCgpkaWZmIC0tZ2l0IGEvY29uZmlnLmguaW4gYi9jb25maWcuaC5pbgppbmRleCBl Y2EyZDY2YTJjLi45NDdmZWVmZjM2IDEwMDY0NAotLS0gYS9jb25maWcuaC5pbgorKysgYi9jb25m aWcuaC5pbgpAQCAtMjY5LDQgKzI2OSw3IEBACiAvKiBUaGUgZGVmYXVsdCB2YWx1ZSBvZiB4ODYg Q0VUIGNvbnRyb2wuICAqLwogI2RlZmluZSBERUZBVUxUX0RMX1g4Nl9DRVRfQ09OVFJPTCBjZXRf ZWxmX3Byb3BlcnR5CiAKKy8qIERlZmluZSBpZiB4ODYgSVNBIGxldmVsIHNob3VsZCBiZSBpbmNs dWRlZCBpbiBzaGFyZWQgbGlicmFyaWVzLiAgKi8KKyN1bmRlZiBJTkNMVURFX1g4Nl9JU0FfTEVW RUwKKwogI2VuZGlmCmRpZmYgLS1naXQgYS9lbGYvZWxmLmggYi9lbGYvZWxmLmgKaW5kZXggNGE5 YWU5N2RmYy4uOWViZDA1MmM4YSAxMDA2NDQKLS0tIGEvZWxmL2VsZi5oCisrKyBiL2VsZi9lbGYu aApAQCAtMTMyNCwzMSArMTMyNCwyNiBAQCB0eXBlZGVmIHN0cnVjdAogCiAvKiBUaGUgeDg2IGlu c3RydWN0aW9uIHNldHMgaW5kaWNhdGVkIGJ5IHRoZSBjb3JyZXNwb25kaW5nIGJpdHMgYXJlCiAg ICB1c2VkIGluIHByb2dyYW0uICBUaGVpciBzdXBwb3J0IGluIHRoZSBoYXJkd2FyZSBpcyBvcHRp b25hbC4gICovCi0jZGVmaW5lIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfVVNFRAkJMHhjMDAwMDAw MAorI2RlZmluZSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1VTRUQJCTB4YzAwMTAwMDIKIC8qIFRo ZSB4ODYgaW5zdHJ1Y3Rpb24gc2V0cyBpbmRpY2F0ZWQgYnkgdGhlIGNvcnJlc3BvbmRpbmcgYml0 cyBhcmUKICAgIHVzZWQgaW4gcHJvZ3JhbSBhbmQgdGhleSBtdXN0IGJlIHN1cHBvcnRlZCBieSB0 aGUgaGFyZHdhcmUuICAgKi8KLSNkZWZpbmUgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9ORUVERUQJ CTB4YzAwMDAwMDEKKyNkZWZpbmUgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9ORUVERUQJCTB4YzAw MDgwMDIKIC8qIFg4NiBwcm9jZXNzb3Itc3BlY2lmaWMgZmVhdHVyZXMgdXNlZCBpbiBwcm9ncmFt LiAgKi8KICNkZWZpbmUgR05VX1BST1BFUlRZX1g4Nl9GRUFUVVJFXzFfQU5ECQkweGMwMDAwMDAy CiAKLSNkZWZpbmUgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV80ODYJCSgxVSA8PCAwKQotI2RlZmlu ZSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xXzU4NgkJKDFVIDw8IDEpCi0jZGVmaW5lIEdOVV9QUk9Q RVJUWV9YODZfSVNBXzFfNjg2CQkoMVUgPDwgMikKLSNkZWZpbmUgR05VX1BST1BFUlRZX1g4Nl9J U0FfMV9TU0UJCSgxVSA8PCAzKQotI2RlZmluZSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1NTRTIJ CSgxVSA8PCA0KQotI2RlZmluZSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1NTRTMJCSgxVSA8PCA1 KQotI2RlZmluZSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1NTU0UzCQkoMVUgPDwgNikKLSNkZWZp bmUgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9TU0U0XzEJCSgxVSA8PCA3KQotI2RlZmluZSBHTlVf UFJPUEVSVFlfWDg2X0lTQV8xX1NTRTRfMgkJKDFVIDw8IDgpCi0jZGVmaW5lIEdOVV9QUk9QRVJU WV9YODZfSVNBXzFfQVZYCQkoMVUgPDwgOSkKLSNkZWZpbmUgR05VX1BST1BFUlRZX1g4Nl9JU0Ff MV9BVlgyCQkoMVUgPDwgMTApCi0jZGVmaW5lIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfQVZYNTEy RgkJKDFVIDw8IDExKQotI2RlZmluZSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX0FWWDUxMkNECQko MVUgPDwgMTIpCi0jZGVmaW5lIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfQVZYNTEyRVIJCSgxVSA8 PCAxMykKLSNkZWZpbmUgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9BVlg1MTJQRgkJKDFVIDw8IDE0 KQotI2RlZmluZSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX0FWWDUxMlZMCQkoMVUgPDwgMTUpCi0j ZGVmaW5lIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfQVZYNTEyRFEJCSgxVSA8PCAxNikKLSNkZWZp bmUgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9BVlg1MTJCVwkJKDFVIDw8IDE3KQorLyogR05VX1BS T1BFUlRZX1g4Nl9JU0FfMV9CQVNFTElORTogQ01PViwgQ1g4IChjbXB4Y2hnOGIpLCBGUFUgKGZs ZCksCisgICBNTVgsIE9TRlhTUiAoZnhzYXZlKSwgU0NFIChzeXNjYWxsKSwgU1NFIGFuZCBTU0Uy LiAgKi8KKyNkZWZpbmUgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9CQVNFTElORQkJKDFVIDw8IDAp CisvKiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1YyOiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX0JB U0VMSU5FLAorICAgQ01QWENIRzE2QiAoY21weGNoZzE2YiksIExBSEYtU0FIRiAobGFoZiksIFBP UENOVCAocG9wY250KSwgU1NFMywKKyAgIFNTU0UzLCBTU0U0LjEgYW5kIFNTRTQuMi4gICovCisj ZGVmaW5lIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfVjIJCSgxVSA8PCAxKQorLyogR05VX1BST1BF UlRZX1g4Nl9JU0FfMV9WMzogR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9WMiwgQVZYLCBBVlgyLCBC TUkxLAorICAgQk1JMiwgRjE2QywgRk1BLCBMWkNOVCwgTU9WQkUsIFhTQVZFLiAgKi8KKyNkZWZp bmUgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9WMwkJKDFVIDw8IDIpCisvKiBHTlVfUFJPUEVSVFlf WDg2X0lTQV8xX1Y0OiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1YzLCBBVlg1MTJGLAorICAgQVZY NTEyQlcsIEFWWDUxMkNELCBBVlg1MTJEUSBhbmQgQVZYNTEyVkwuICAqLworI2RlZmluZSBHTlVf UFJPUEVSVFlfWDg2X0lTQV8xX1Y0CQkoMVUgPDwgMykKIAogLyogVGhpcyBpbmRpY2F0ZXMgdGhh dCBhbGwgZXhlY3V0YWJsZSBzZWN0aW9ucyBhcmUgY29tcGF0aWJsZSB3aXRoCiAgICBJQlQuICAq LwpkaWZmIC0tZ2l0IGEvc3lzZGVwcy94ODYvTWFrZWZpbGUgYi9zeXNkZXBzL3g4Ni9NYWtlZmls ZQppbmRleCAwODFjYzcyZTkzLi5jODE0ZDVhMTk1IDEwMDY0NAotLS0gYS9zeXNkZXBzL3g4Ni9N YWtlZmlsZQorKysgYi9zeXNkZXBzL3g4Ni9NYWtlZmlsZQpAQCAtOSw2ICs5LDM2IEBAIHN5c2Rl cF9oZWFkZXJzICs9IHN5cy9wbGF0Zm9ybS94ODYuaAogdGVzdHMgKz0gdHN0LWdldC1jcHUtZmVh dHVyZXMgdHN0LWdldC1jcHUtZmVhdHVyZXMtc3RhdGljIFwKIAkgdHN0LWNwdS1mZWF0dXJlcy1j cHVpbmZvIHRzdC1jcHUtZmVhdHVyZXMtc3VwcG9ydHMKIHRlc3RzLXN0YXRpYyArPSB0c3QtZ2V0 LWNwdS1mZWF0dXJlcy1zdGF0aWMKK2lmZXEgKHllcywkKGVuYWJsZS14ODYtaXNhLWxldmVsKSkK K3Rlc3RzICs9IHRzdC1pc2EtbGV2ZWwtMQorbW9kdWxlcy1uYW1lcyArPSB0c3QtaXNhLWxldmVs LW1vZC0xLWJhc2VsaW5lIFwKKwkJIHRzdC1pc2EtbGV2ZWwtbW9kLTEtdjIgXAorCQkgdHN0LWlz YS1sZXZlbC1tb2QtMS12MyBcCisJCSB0c3QtaXNhLWxldmVsLW1vZC0xLXY0IFwKKworIyBYODYg SVNBIGxldmVsIGJhc2VsaW5lCitDRkxBR1MtdHN0LWlzYS1sZXZlbC1tb2QtMS1iYXNlbGluZS5j ICs9IC1ESU5DTFVERV9YODZfSVNBX0xFVkVMIFwKKwkJCQkJIC1ESVNBX0xFVkVMPTB4MSBcCisJ CQkJCSAtbWFyY2g9eDg2LTY0CisjIFg4NiBJU0EgbGV2ZWwgdjIKK0NGTEFHUy10c3QtaXNhLWxl dmVsLW1vZC0xLXYyLmMgKz0gLURJTkNMVURFX1g4Nl9JU0FfTEVWRUwgXAorCQkJCSAgIC1ESVNB X0xFVkVMPTB4MyBcCisJCQkJICAgLW1hcmNoPXg4Ni02NAorIyBYODYgSVNBIGxldmVsIHYzCitD RkxBR1MtdHN0LWlzYS1sZXZlbC1tb2QtMS12My5jICs9IC1ESU5DTFVERV9YODZfSVNBX0xFVkVM IFwKKwkJCQkgICAtRElTQV9MRVZFTD0weDcgXAorCQkJCSAgIC1tYXJjaD14ODYtNjQKKyMgWDg2 IElTQSBsZXZlbCB2NAorQ0ZMQUdTLXRzdC1pc2EtbGV2ZWwtbW9kLTEtdjQuYyArPSAtRElOQ0xV REVfWDg2X0lTQV9MRVZFTCBcCisJCQkJICAgLURJU0FfTEVWRUw9MHhmIFwKKwkJCQkgICAtbWFy Y2g9eDg2LTY0CisKKyQob2JqcGZ4KXRzdC1pc2EtbGV2ZWwtMTogJChsaWJkbCkKKyQob2JqcGZ4 KXRzdC1pc2EtbGV2ZWwtMS5vdXQ6ICQob2JqcGZ4KXRzdC1pc2EtbGV2ZWwtbW9kLTEtYmFzZWxp bmUuc28gXAorCQkJICAgICAgJChvYmpwZngpdHN0LWlzYS1sZXZlbC1tb2QtMS12Mi5zbyBcCisJ CQkgICAgICAkKG9ianBmeCl0c3QtaXNhLWxldmVsLW1vZC0xLXYzLnNvIFwKKwkJCSAgICAgICQo b2JqcGZ4KXRzdC1pc2EtbGV2ZWwtbW9kLTEtdjQuc28KK2VuZGlmCiBlbmRpZgogCiBpZmVxICgk KHN1YmRpciksbWF0aCkKZGlmZiAtLWdpdCBhL3N5c2RlcHMveDg2L2FiaS1ub3RlLmMgYi9zeXNk ZXBzL3g4Ni9hYmktbm90ZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAu LjUxNDBlNmFiNDcKLS0tIC9kZXYvbnVsbAorKysgYi9zeXNkZXBzL3g4Ni9hYmktbm90ZS5jCkBA IC0wLDAgKzEsMjkgQEAKKy8qIFNwZWNpYWwgLmluaXQgYW5kIC5maW5pIHNlY3Rpb24gc3VwcG9y dC4gIHg4Ni02NCB2ZXJzaW9uLgorICAgQ29weXJpZ2h0IChDKSAyMDIwIEZyZWUgU29mdHdhcmUg Rm91bmRhdGlvbiwgSW5jLgorICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgdGhlIEdOVSBDIExpYnJh cnkuCisKKyAgIFRoZSBHTlUgQyBMaWJyYXJ5IGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVk aXN0cmlidXRlIGl0IGFuZC9vcgorICAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICAgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCisgICB2ZXJzaW9uIDIuMSBvZiB0aGUg TGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgSW4g YWRkaXRpb24gdG8gdGhlIHBlcm1pc3Npb25zIGluIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVi bGljCisgICBMaWNlbnNlLCB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uIGdpdmVzIHlvdSB1 bmxpbWl0ZWQKKyAgIHBlcm1pc3Npb24gdG8gbGluayB0aGUgY29tcGlsZWQgdmVyc2lvbiBvZiB0 aGlzIGZpbGUgd2l0aCBvdGhlcgorICAgcHJvZ3JhbXMsIGFuZCB0byBkaXN0cmlidXRlIHRob3Nl IHByb2dyYW1zIHdpdGhvdXQgYW55IHJlc3RyaWN0aW9uCisgICBjb21pbmcgZnJvbSB0aGUgdXNl IG9mIHRoaXMgZmlsZS4gIChUaGUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgICBMaWNlbnNlIHJl c3RyaWN0aW9ucyBkbyBhcHBseSBpbiBvdGhlciByZXNwZWN0czsgZm9yIGV4YW1wbGUsIHRoZXkK KyAgIGNvdmVyIG1vZGlmaWNhdGlvbiBvZiB0aGUgZmlsZSwgYW5kIGRpc3RyaWJ1dGlvbiB3aGVu IG5vdCBsaW5rZWQKKyAgIGludG8gYW5vdGhlciBwcm9ncmFtLikKKworICAgVGhlIEdOVSBDIExp YnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICAgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBv ZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICAgTGljZW5zZSBhbG9uZyB3aXRoIHRo ZSBHTlUgQyBMaWJyYXJ5OyBpZiBub3QsIHNlZQorICAgPGh0dHBzOi8vd3d3LmdudS5vcmcvbGlj ZW5zZXMvPi4gICovCisKKyNpbmNsdWRlIDxpc2EtbGV2ZWwuYz4KKyNpbmNsdWRlIDxjc3UvYWJp LW5vdGUuYz4KZGlmZiAtLWdpdCBhL3N5c2RlcHMveDg2L2NvbmZpZ3VyZSBiL3N5c2RlcHMveDg2 L2NvbmZpZ3VyZQppbmRleCA4MWNjNGU4MGQ2Li41ZTMyZGM2MmIzIDEwMDY0NAotLS0gYS9zeXNk ZXBzL3g4Ni9jb25maWd1cmUKKysrIGIvc3lzZGVwcy94ODYvY29uZmlndXJlCkBAIC02OCwzICs2 OCw4MiBAQCBlbGlmIHRlc3QgJGVuYWJsZV9jZXQgPSBwZXJtaXNzaXZlOyB0aGVuCiBmaQogY29u ZmlnX3ZhcnM9IiRjb25maWdfdmFycwogZW5hYmxlLWNldCA9ICRlbmFibGVfY2V0IgorCisjIENo ZWNrIGlmIGxpbmtlciBzdXBwb3J0cyB4ODYgSVNBIGxldmVsLgoreyAkYXNfZWNobyAiJGFzX21l OiR7YXNfbGluZW5vLSRMSU5FTk99OiBjaGVja2luZyBmb3IgbGlua2VyIHg4NiBJU0EgbGV2ZWwg c3VwcG9ydCIgPiY1CiskYXNfZWNob19uICJjaGVja2luZyBmb3IgbGlua2VyIHg4NiBJU0EgbGV2 ZWwgc3VwcG9ydC4uLiAiID4mNjsgfQoraWYgJHtsaWJjX2N2X2luY2x1ZGVfeDg2X2lzYV9sZXZl bCs6fSBmYWxzZTsgdGhlbiA6CisgICRhc19lY2hvX24gIihjYWNoZWQpICIgPiY2CitlbHNlCisg IGNhdCA+IGNvbmZ0ZXN0MS5TIDw8RU9GCisjaWZkZWYgX19MUDY0X18KKyMgZGVmaW5lIFAyQUxJ R04gMworI2Vsc2UKKyMgZGVmaW5lIFAyQUxJR04gMgorI2VuZGlmCisJLnNlY3Rpb24gIi5ub3Rl LmdudS5wcm9wZXJ0eSIsICJhIgorCS5wMmFsaWduIFAyQUxJR04KKwkubG9uZyAxZiAtIDBmCQkv KiBuYW1lIGxlbmd0aC4gICovCisJLmxvbmcgNGYgLSAxZgkJLyogZGF0YSBsZW5ndGguICAqLwor CS8qIE5UX0dOVV9QUk9QRVJUWV9UWVBFXzAgKi8KKwkubG9uZyA1CQkJLyogbm90ZSB0eXBlLiAg Ki8KKzA6CisJLmFzY2l6ICJHTlUiCQkvKiB2ZW5kb3IgbmFtZS4gICovCisxOgorCS5wMmFsaWdu IFAyQUxJR04KKwkvKiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX05FRURFRCAqLworCS5sb25nIDB4 YzAwMDgwMDIJLyogcHJfdHlwZS4gICovCisJLmxvbmcgM2YgLSAyZgkJLyogcHJfZGF0YXN6LiAg Ki8KKzI6CisJLmxvbmcgMHgxCiszOgorCS5wMmFsaWduIFAyQUxJR04KKzQ6CitFT0YKK2NhdCA+ IGNvbmZ0ZXN0Mi5TIDw8RU9GCisjaWZkZWYgX19MUDY0X18KKyMgZGVmaW5lIFAyQUxJR04gMwor I2Vsc2UKKyMgZGVmaW5lIFAyQUxJR04gMgorI2VuZGlmCisJLnNlY3Rpb24gIi5ub3RlLmdudS5w cm9wZXJ0eSIsICJhIgorCS5wMmFsaWduIFAyQUxJR04KKwkubG9uZyAxZiAtIDBmCQkvKiBuYW1l IGxlbmd0aC4gICovCisJLmxvbmcgNGYgLSAxZgkJLyogZGF0YSBsZW5ndGguICAqLworCS8qIE5U X0dOVV9QUk9QRVJUWV9UWVBFXzAgKi8KKwkubG9uZyA1CQkJLyogbm90ZSB0eXBlLiAgKi8KKzA6 CisJLmFzY2l6ICJHTlUiCQkvKiB2ZW5kb3IgbmFtZS4gICovCisxOgorCS5wMmFsaWduIFAyQUxJ R04KKwkvKiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX05FRURFRCAqLworCS5sb25nIDB4YzAwMDgw MDIJLyogcHJfdHlwZS4gICovCisJLmxvbmcgM2YgLSAyZgkJLyogcHJfZGF0YXN6LiAgKi8KKzI6 CisJLmxvbmcgMHgyCiszOgorCS5wMmFsaWduIFAyQUxJR04KKzQ6CitFT0YKK2xpYmNfY3ZfaW5j bHVkZV94ODZfaXNhX2xldmVsPW5vCitpZiB7IGFjX3RyeT0nJHtDQy1jY30gJENGTEFHUyAkQ1BQ RkxBR1MgLW5vc3RhcnRmaWxlcyAtbm9zdGRsaWIgLXIgLW8gY29uZnRlc3QgY29uZnRlc3QxLlMg Y29uZnRlc3QyLlMnCisgIHsgeyBldmFsIGVjaG8gIlwiXCRhc19tZVwiOiR7YXNfbGluZW5vLSRM SU5FTk99OiBcIiRhY190cnlcIiI7IH0gPiY1CisgIChldmFsICRhY190cnkpIDI+JjUKKyAgYWNf c3RhdHVzPSQ/CisgICRhc19lY2hvICIkYXNfbWU6JHthc19saW5lbm8tJExJTkVOT306IFwkPyA9 ICRhY19zdGF0dXMiID4mNQorICB0ZXN0ICRhY19zdGF0dXMgPSAwOyB9OyB9OyB0aGVuCisgIGNv dW50PWBMQ19BTEw9QyAkUkVBREVMRiAtbiBjb25mdGVzdCB8IGdyZXAgTlRfR05VX1BST1BFUlRZ X1RZUEVfMCB8IHdjIC1sYAorICBpZiB0ZXN0ICIkY291bnQiID0gMTsgdGhlbgorICAgIGxpYmNf Y3ZfaW5jbHVkZV94ODZfaXNhX2xldmVsPXllcworICBmaQorZmkKK3JtIC1mIGNvbmZ0ZXN0Kgor ZmkKK3sgJGFzX2VjaG8gIiRhc19tZToke2FzX2xpbmVuby0kTElORU5PfTogcmVzdWx0OiAkbGli Y19jdl9pbmNsdWRlX3g4Nl9pc2FfbGV2ZWwiID4mNQorJGFzX2VjaG8gIiRsaWJjX2N2X2luY2x1 ZGVfeDg2X2lzYV9sZXZlbCIgPiY2OyB9CitpZiB0ZXN0ICRsaWJjX2N2X2luY2x1ZGVfeDg2X2lz YV9sZXZlbCA9IHllczsgdGhlbgorICAkYXNfZWNobyAiI2RlZmluZSBJTkNMVURFX1g4Nl9JU0Ff TEVWRUwgMSIgPj5jb25mZGVmcy5oCisKK2ZpCitjb25maWdfdmFycz0iJGNvbmZpZ192YXJzCitl bmFibGUteDg2LWlzYS1sZXZlbCA9ICRsaWJjX2N2X2luY2x1ZGVfeDg2X2lzYV9sZXZlbCIKZGlm ZiAtLWdpdCBhL3N5c2RlcHMveDg2L2NvbmZpZ3VyZS5hYyBiL3N5c2RlcHMveDg2L2NvbmZpZ3Vy ZS5hYwppbmRleCA4ZjNlMTE5MWY2Li5mOTQwODhmMzc3IDEwMDY0NAotLS0gYS9zeXNkZXBzL3g4 Ni9jb25maWd1cmUuYWMKKysrIGIvc3lzZGVwcy94ODYvY29uZmlndXJlLmFjCkBAIC00MywzICs0 Myw2OSBAQCBlbGlmIHRlc3QgJGVuYWJsZV9jZXQgPSBwZXJtaXNzaXZlOyB0aGVuCiAgIEFDX0RF RklORShERUZBVUxUX0RMX1g4Nl9DRVRfQ09OVFJPTCwgY2V0X3Blcm1pc3NpdmUpCiBmaQogTElC Q19DT05GSUdfVkFSKFtlbmFibGUtY2V0XSwgWyRlbmFibGVfY2V0XSkKKworIyBDaGVjayBpZiBs aW5rZXIgc3VwcG9ydHMgeDg2IElTQSBsZXZlbC4KK0FDX0NBQ0hFX0NIRUNLKFtmb3IgbGlua2Vy IHg4NiBJU0EgbGV2ZWwgc3VwcG9ydF0sCisJICAgICAgIGxpYmNfY3ZfaW5jbHVkZV94ODZfaXNh X2xldmVsLCBbZG5sCitjYXQgPiBjb25mdGVzdDEuUyA8PEVPRgorI2lmZGVmIF9fTFA2NF9fCisj IGRlZmluZSBQMkFMSUdOIDMKKyNlbHNlCisjIGRlZmluZSBQMkFMSUdOIDIKKyNlbmRpZgorCS5z ZWN0aW9uICIubm90ZS5nbnUucHJvcGVydHkiLCAiYSIKKwkucDJhbGlnbiBQMkFMSUdOCisJLmxv bmcgMWYgLSAwZgkJLyogbmFtZSBsZW5ndGguICAqLworCS5sb25nIDRmIC0gMWYJCS8qIGRhdGEg bGVuZ3RoLiAgKi8KKwkvKiBOVF9HTlVfUFJPUEVSVFlfVFlQRV8wICovCisJLmxvbmcgNQkJCS8q IG5vdGUgdHlwZS4gICovCiswOgorCS5hc2NpeiAiR05VIgkJLyogdmVuZG9yIG5hbWUuICAqLwor MToKKwkucDJhbGlnbiBQMkFMSUdOCisJLyogR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9ORUVERUQg Ki8KKwkubG9uZyAweGMwMDA4MDAyCS8qIHByX3R5cGUuICAqLworCS5sb25nIDNmIC0gMmYJCS8q IHByX2RhdGFzei4gICovCisyOgorCS5sb25nIDB4MQorMzoKKwkucDJhbGlnbiBQMkFMSUdOCis0 OgorRU9GCitjYXQgPiBjb25mdGVzdDIuUyA8PEVPRgorI2lmZGVmIF9fTFA2NF9fCisjIGRlZmlu ZSBQMkFMSUdOIDMKKyNlbHNlCisjIGRlZmluZSBQMkFMSUdOIDIKKyNlbmRpZgorCS5zZWN0aW9u ICIubm90ZS5nbnUucHJvcGVydHkiLCAiYSIKKwkucDJhbGlnbiBQMkFMSUdOCisJLmxvbmcgMWYg LSAwZgkJLyogbmFtZSBsZW5ndGguICAqLworCS5sb25nIDRmIC0gMWYJCS8qIGRhdGEgbGVuZ3Ro LiAgKi8KKwkvKiBOVF9HTlVfUFJPUEVSVFlfVFlQRV8wICovCisJLmxvbmcgNQkJCS8qIG5vdGUg dHlwZS4gICovCiswOgorCS5hc2NpeiAiR05VIgkJLyogdmVuZG9yIG5hbWUuICAqLworMToKKwku cDJhbGlnbiBQMkFMSUdOCisJLyogR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9ORUVERUQgKi8KKwku bG9uZyAweGMwMDA4MDAyCS8qIHByX3R5cGUuICAqLworCS5sb25nIDNmIC0gMmYJCS8qIHByX2Rh dGFzei4gICovCisyOgorCS5sb25nIDB4MgorMzoKKwkucDJhbGlnbiBQMkFMSUdOCis0OgorRU9G CitsaWJjX2N2X2luY2x1ZGVfeDg2X2lzYV9sZXZlbD1ubworaWYgQUNfVFJZX0NPTU1BTkQoJHtD Qy1jY30gJENGTEFHUyAkQ1BQRkxBR1MgLW5vc3RhcnRmaWxlcyAtbm9zdGRsaWIgLXIgLW8gY29u ZnRlc3QgY29uZnRlc3QxLlMgY29uZnRlc3QyLlMpOyB0aGVuCisgIGNvdW50PWBMQ19BTEw9QyAk UkVBREVMRiAtbiBjb25mdGVzdCB8IGdyZXAgTlRfR05VX1BST1BFUlRZX1RZUEVfMCB8IHdjIC1s YAorICBpZiB0ZXN0ICIkY291bnQiID0gMTsgdGhlbgorICAgIGxpYmNfY3ZfaW5jbHVkZV94ODZf aXNhX2xldmVsPXllcworICBmaQorZmkKK3JtIC1mIGNvbmZ0ZXN0Kl0pCitpZiB0ZXN0ICRsaWJj X2N2X2luY2x1ZGVfeDg2X2lzYV9sZXZlbCA9IHllczsgdGhlbgorICBBQ19ERUZJTkUoSU5DTFVE RV9YODZfSVNBX0xFVkVMKQorZmkKK0xJQkNfQ09ORklHX1ZBUihbZW5hYmxlLXg4Ni1pc2EtbGV2 ZWxdLCBbJGxpYmNfY3ZfaW5jbHVkZV94ODZfaXNhX2xldmVsXSkKZGlmZiAtLWdpdCBhL3N5c2Rl cHMveDg2L2NwdS1mZWF0dXJlcy5jIGIvc3lzZGVwcy94ODYvY3B1LWZlYXR1cmVzLmMKaW5kZXgg NTI5YzU4NjE5My4uZTdkYTY4MmEyZSAxMDA2NDQKLS0tIGEvc3lzZGVwcy94ODYvY3B1LWZlYXR1 cmVzLmMKKysrIGIvc3lzZGVwcy94ODYvY3B1LWZlYXR1cmVzLmMKQEAgLTE5LDYgKzE5LDcgQEAK ICNpbmNsdWRlIDxjcHVpZC5oPgogI2luY2x1ZGUgPGRsLWh3Y2FwLmg+CiAjaW5jbHVkZSA8bGli Yy1wb2ludGVyLWFyaXRoLmg+CisjaW5jbHVkZSA8Z2V0LWlzYS1sZXZlbC5oPgogI2lmIElTX0lO IChsaWJjKSAmJiAhZGVmaW5lZCBTSEFSRUQKICMgaW5jbHVkZSA8YXNzZXJ0Lmg+CiAjIGluY2x1 ZGUgPHVuaXN0ZC5oPgpAQCAtMjkwLDYgKzI5MSw4IEBAIHVwZGF0ZV91c2FibGUgKHN0cnVjdCBj cHVfZmVhdHVyZXMgKmNwdV9mZWF0dXJlcykKICAgICAgIENQVV9GRUFUVVJFX1NFVF9VU0FCTEUg KGNwdV9mZWF0dXJlcywgS0wpOwogICAgICAgQ1BVX0ZFQVRVUkVfU0VUX1VTQUJMRSAoY3B1X2Zl YXR1cmVzLCBXSURFX0tMKTsKICAgICB9CisKKyAgY3B1X2ZlYXR1cmVzLT5pc2FfMSA9IGdldF9p c2FfbGV2ZWwgKGNwdV9mZWF0dXJlcyk7CiB9CiAKIHN0YXRpYyB2b2lkCmRpZmYgLS1naXQgYS9z eXNkZXBzL3g4Ni9kbC1jZXQuYyBiL3N5c2RlcHMveDg2L2RsLWNldC5jCmluZGV4IGI0OTEwZjc2 MzQuLmVkN2ZkNmQxMGQgMTAwNjQ0Ci0tLSBhL3N5c2RlcHMveDg2L2RsLWNldC5jCisrKyBiL3N5 c2RlcHMveDg2L2RsLWNldC5jCkBAIC03NiwxMCArNzYsMTIgQEAgZGxfY2V0X2NoZWNrIChzdHJ1 Y3QgbGlua19tYXAgKm0sIGNvbnN0IGNoYXIgKnByb2dyYW0pCiAJICAgKi8KIAkgIGVuYWJsZV9p YnQgJj0gKEhBU19DUFVfRkVBVFVSRSAoSUJUKQogCQkJICYmIChlbmFibGVfaWJ0X3R5cGUgPT0g Y2V0X2Fsd2F5c19vbgotCQkJICAgICB8fCAobS0+bF9jZXQgJiBsY19pYnQpICE9IDApKTsKKwkJ CSAgICAgfHwgKG0tPmxfeDg2X2ZlYXR1cmVfMV9hbmQKKwkJCQkgJiBHTlVfUFJPUEVSVFlfWDg2 X0ZFQVRVUkVfMV9JQlQpICE9IDApKTsKIAkgIGVuYWJsZV9zaHN0ayAmPSAoSEFTX0NQVV9GRUFU VVJFIChTSFNUSykKIAkJCSAgICYmIChlbmFibGVfc2hzdGtfdHlwZSA9PSBjZXRfYWx3YXlzX29u Ci0JCQkgICAgICAgfHwgKG0tPmxfY2V0ICYgbGNfc2hzdGspICE9IDApKTsKKwkJCSAgICAgICB8 fCAobS0+bF94ODZfZmVhdHVyZV8xX2FuZAorCQkJCSAgICYgR05VX1BST1BFUlRZX1g4Nl9GRUFU VVJFXzFfU0hTVEspICE9IDApKTsKIAl9CiAKICAgICAgIC8qIGxkLnNvIGlzIENFVC1lbmFibGVk IGJ5IGtlcm5lbC4gIEJ1dCBzaGFyZWQgb2JqZWN0cyBtYXkgbm90CkBAIC0xMTEsNyArMTEzLDgg QEAgZGxfY2V0X2NoZWNrIChzdHJ1Y3QgbGlua19tYXAgKm0sIGNvbnN0IGNoYXIgKnByb2dyYW0p CiAJICAgICAgLyogSUJUIGlzIGVuYWJsZWQgb25seSBpZiBpdCBpcyBlbmFibGVkIGluIGV4ZWN1 dGFibGUgYXMKIAkJIHdlbGwgYXMgYWxsIHNoYXJlZCBvYmplY3RzLiAgKi8KIAkgICAgICBlbmFi bGVfaWJ0ICY9IChlbmFibGVfaWJ0X3R5cGUgPT0gY2V0X2Fsd2F5c19vbgotCQkJICAgICB8fCAo bC0+bF9jZXQgJiBsY19pYnQpICE9IDApOworCQkJICAgICB8fCAobC0+bF94ODZfZmVhdHVyZV8x X2FuZAorCQkJCSAmIEdOVV9QUk9QRVJUWV9YODZfRkVBVFVSRV8xX0lCVCkgIT0gMCk7CiAJICAg ICAgaWYgKCFmb3VuZF9pYnRfbGVnYWN5ICYmIGVuYWJsZV9pYnQgIT0gaWJ0X2VuYWJsZWQpCiAJ CXsKIAkJICBmb3VuZF9pYnRfbGVnYWN5ID0gdHJ1ZTsKQEAgLTEyMSw3ICsxMjQsOCBAQCBkbF9j ZXRfY2hlY2sgKHN0cnVjdCBsaW5rX21hcCAqbSwgY29uc3QgY2hhciAqcHJvZ3JhbSkKIAkgICAg ICAvKiBTSFNUSyBpcyBlbmFibGVkIG9ubHkgaWYgaXQgaXMgZW5hYmxlZCBpbiBleGVjdXRhYmxl IGFzCiAJCSB3ZWxsIGFzIGFsbCBzaGFyZWQgb2JqZWN0cy4gICovCiAJICAgICAgZW5hYmxlX3No c3RrICY9IChlbmFibGVfc2hzdGtfdHlwZSA9PSBjZXRfYWx3YXlzX29uCi0JCQkgICAgICAgfHwg KGwtPmxfY2V0ICYgbGNfc2hzdGspICE9IDApOworCQkJICAgICAgIHx8IChsLT5sX3g4Nl9mZWF0 dXJlXzFfYW5kCisJCQkJICAgJiBHTlVfUFJPUEVSVFlfWDg2X0ZFQVRVUkVfMV9TSFNUSykgIT0g MCk7CiAJICAgICAgaWYgKGVuYWJsZV9zaHN0ayAhPSBzaHN0a19lbmFibGVkKQogCQl7CiAJCSAg Zm91bmRfc2hzdGtfbGVnYWN5ID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL3N5c2RlcHMveDg2L2RsLXBy b3AuaCBiL3N5c2RlcHMveDg2L2RsLXByb3AuaAppbmRleCBjZTE2NjdkYzdhLi41NmJkMDIwYjNj IDEwMDY0NAotLS0gYS9zeXNkZXBzL3g4Ni9kbC1wcm9wLmgKKysrIGIvc3lzZGVwcy94ODYvZGwt cHJvcC5oCkBAIC0xOSwxNCArMTksNTQgQEAKICNpZm5kZWYgX0RMX1BST1BfSAogI2RlZmluZSBf RExfUFJPUF9ICiAKKyNpbmNsdWRlIDxsaWJpbnRsLmg+CisKIGV4dGVybiB2b2lkIF9kbF9jZXRf Y2hlY2sgKHN0cnVjdCBsaW5rX21hcCAqLCBjb25zdCBjaGFyICopCiAgICAgYXR0cmlidXRlX2hp ZGRlbjsKIGV4dGVybiB2b2lkIF9kbF9jZXRfb3Blbl9jaGVjayAoc3RydWN0IGxpbmtfbWFwICop CiAgICAgYXR0cmlidXRlX2hpZGRlbjsKIAorc3RhdGljIHZvaWQKK2RsX2lzYV9sZXZlbF9jaGVj ayAoc3RydWN0IGxpbmtfbWFwICptLCBjb25zdCBjaGFyICpwcm9ncmFtKQoreworICBjb25zdCBz dHJ1Y3QgY3B1X2ZlYXR1cmVzICpjcHVfZmVhdHVyZXMgPSBfX2dldF9jcHVfZmVhdHVyZXMgKCk7 CisgIHVuc2lnbmVkIGludCBpOworICBzdHJ1Y3QgbGlua19tYXAgKmw7CisKKyAgaSA9IG0tPmxf c2VhcmNobGlzdC5yX25saXN0OworICB3aGlsZSAoaS0tID4gMCkKKyAgICB7CisgICAgICAvKiBD aGVjayBlYWNoIHNoYXJlZCBvYmplY3QgdG8gc2VlIGlmIElTQSBsZXZlbCBpcyBjb21wYXRpYmxl LiAgKi8KKyAgICAgIGwgPSBtLT5sX2luaXRmaW5pW2ldOworCisgICAgICAvKiBTa2lwIElTQSBs ZXZlbCBjaGVjayBpZiBmdW5jdGlvbnMgaGF2ZSBiZWVuIGV4ZWN1dGVkLiAgKi8KKyAgICAgIGlm IChsLT5sX2luaXRfY2FsbGVkKQorCWNvbnRpbnVlOworCisjaWZkZWYgU0hBUkVECisgICAgICAv KiBTa2lwIElTQSBsZXZlbCBjaGVjayBmb3IgbGQuc28gc2luY2UgbGQuc28gd29uJ3QgcnVuIGlm IGl0cyBJU0EKKwkgbGV2ZWwgaXMgaGlnaGVyIHRoYW4gQ1BVLiAgKi8KKyAgICAgIGlmIChsID09 ICZHTChkbF9ydGxkX21hcCkgfHwgbC0+bF9yZWFsID09ICZHTChkbF9ydGxkX21hcCkpCisJY29u dGludWU7CisjZW5kaWYKKworICAgICAgaWYgKChsLT5sX3g4Nl9pc2FfMV9uZWVkZWQgJiBjcHVf ZmVhdHVyZXMtPmlzYV8xKQorCSAgIT0gbC0+bF94ODZfaXNhXzFfbmVlZGVkKQorCXsKKwkgIGlm IChwcm9ncmFtKQorCSAgICBfZGxfZmF0YWxfcHJpbnRmICgiJXM6IENQVSBJU0EgbGV2ZWwgaXMg bG93ZXIgdGhhbiByZXF1aXJlZFxuIiwKKwkJCSAgICAgICpsLT5sX25hbWUgIT0gJ1wwJyA/IGwt PmxfbmFtZSA6IHByb2dyYW0pOworCSAgZWxzZQorCSAgICBfZGxfc2lnbmFsX2Vycm9yICgwLCBs LT5sX25hbWUsICJkbG9wZW4iLAorCQkJICAgICAgTl8oIkNQVSBJU0EgbGV2ZWwgaXMgbG93ZXIg dGhhbiByZXF1aXJlZCIpKTsKKwl9CisgICAgfQorfQorCiBzdGF0aWMgaW5saW5lIHZvaWQgX19h dHRyaWJ1dGVfXyAoKGFsd2F5c19pbmxpbmUpKQogX3J0bGRfbWFpbl9jaGVjayAoc3RydWN0IGxp bmtfbWFwICptLCBjb25zdCBjaGFyICpwcm9ncmFtKQogeworICBkbF9pc2FfbGV2ZWxfY2hlY2sg KG0sIHByb2dyYW0pOwogI2lmIENFVF9FTkFCTEVECiAgIF9kbF9jZXRfY2hlY2sgKG0sIHByb2dy YW0pOwogI2VuZGlmCkBAIC0zNSwyMCArNzUsMTggQEAgX3J0bGRfbWFpbl9jaGVjayAoc3RydWN0 IGxpbmtfbWFwICptLCBjb25zdCBjaGFyICpwcm9ncmFtKQogc3RhdGljIGlubGluZSB2b2lkIF9f YXR0cmlidXRlX18gKChhbHdheXNfaW5saW5lKSkKIF9kbF9vcGVuX2NoZWNrIChzdHJ1Y3QgbGlu a19tYXAgKm0pCiB7CisgIGRsX2lzYV9sZXZlbF9jaGVjayAobSwgTlVMTCk7CiAjaWYgQ0VUX0VO QUJMRUQKICAgX2RsX2NldF9vcGVuX2NoZWNrIChtKTsKICNlbmRpZgogfQogCiBzdGF0aWMgaW5s aW5lIHZvaWQgX19hdHRyaWJ1dGVfXyAoKHVudXNlZCkpCi1fZGxfcHJvY2Vzc19jZXRfcHJvcGVy dHlfbm90ZSAoc3RydWN0IGxpbmtfbWFwICpsLAotCQkJICAgICAgY29uc3QgRWxmVyhOaGRyKSAq bm90ZSwKLQkJCSAgICAgIGNvbnN0IEVsZlcoQWRkcikgc2l6ZSwKLQkJCSAgICAgIGNvbnN0IEVs ZlcoQWRkcikgYWxpZ24pCitfZGxfcHJvY2Vzc19wcm9wZXJ0eV9ub3RlIChzdHJ1Y3QgbGlua19t YXAgKmwsIGNvbnN0IEVsZlcoTmhkcikgKm5vdGUsCisJCQkgICBjb25zdCBFbGZXKEFkZHIpIHNp emUsIGNvbnN0IEVsZlcoQWRkcikgYWxpZ24pCiB7Ci0jaWYgQ0VUX0VOQUJMRUQKICAgLyogU2tp cCBpZiB3ZSBoYXZlIHNlZW4gYSBOVF9HTlVfUFJPUEVSVFlfVFlQRV8wIG5vdGUgYmVmb3JlLiAg Ki8KLSAgaWYgKGwtPmxfY2V0ICE9IGxjX3Vua25vd24pCisgIGlmIChsLT5sX3Byb3BlcnR5ICE9 IGxjX3Byb3BlcnR5X3Vua25vd24pCiAgICAgcmV0dXJuOwogCiAgIC8qIFRoZSBOVF9HTlVfUFJP UEVSVFlfVFlQRV8wIG5vdGUgbXVzdCBiZSBhbGlnZWQgdG8gNCBieXRlcyBpbgpAQCAtNTksNyAr OTcsOCBAQCBfZGxfcHJvY2Vzc19jZXRfcHJvcGVydHlfbm90ZSAoc3RydWN0IGxpbmtfbWFwICps LAogCiAgIGNvbnN0IEVsZlcoQWRkcikgc3RhcnQgPSAoRWxmVyhBZGRyKSkgbm90ZTsKIAotICB1 bnNpZ25lZCBpbnQgZmVhdHVyZV8xID0gMDsKKyAgdW5zaWduZWQgaW50IGZlYXR1cmVfMV9hbmQg PSAwOworICB1bnNpZ25lZCBpbnQgaXNhXzFfbmVlZGVkID0gMDsKICAgdW5zaWduZWQgaW50IGxh c3RfdHlwZSA9IDA7CiAKICAgd2hpbGUgKChFbGZXKEFkZHIpKSAobm90ZSArIDEpIC0gc3RhcnQg PCBzaXplKQpAQCAtNzEsMTEgKzExMCwxMSBAQCBfZGxfcHJvY2Vzc19jZXRfcHJvcGVydHlfbm90 ZSAoc3RydWN0IGxpbmtfbWFwICpsLAogCXsKIAkgIC8qIFN0b3AgaWYgd2Ugc2VlIG1vcmUgdGhh biBvbmUgR05VIHByb3BlcnR5IG5vdGUgd2hpY2ggbWF5CiAJICAgICBiZSBnZW5lcmF0ZWQgYnkg dGhlIG9sZGVyIGxpbmtlci4gICovCi0JICBpZiAobC0+bF9jZXQgIT0gbGNfdW5rbm93bikKKwkg IGlmIChsLT5sX3Byb3BlcnR5ICE9IGxjX3Byb3BlcnR5X3Vua25vd24pCiAJICAgIHJldHVybjsK IAotCSAgLyogQ2hlY2sgQ0VUIHN0YXR1cyBub3cuICAqLwotCSAgbC0+bF9jZXQgPSBsY19ub25l OworCSAgLyogQ2hlY2sgQ0VUIHN0YXR1cyBhbmQgSVNBIGxldmVscyBub3cuICAqLworCSAgbC0+ bF9wcm9wZXJ0eSA9IGxjX3Byb3BlcnR5X25vbmU7CiAKIAkgIC8qIENoZWNrIGZvciBpbnZhbGlk IHByb3BlcnR5LiAgKi8KIAkgIGlmIChub3RlLT5uX2Rlc2NzeiA8IDgKQEAgLTEwMSwyNiArMTQw LDM3IEBAIF9kbF9wcm9jZXNzX2NldF9wcm9wZXJ0eV9ub3RlIChzdHJ1Y3QgbGlua19tYXAgKmws CiAKIAkgICAgICBsYXN0X3R5cGUgPSB0eXBlOwogCi0JICAgICAgaWYgKHR5cGUgPT0gR05VX1BS T1BFUlRZX1g4Nl9GRUFUVVJFXzFfQU5EKQorCSAgICAgIGlmICh0eXBlID09IEdOVV9QUk9QRVJU WV9YODZfRkVBVFVSRV8xX0FORAorCQkgIHx8IHR5cGUgPT0gR05VX1BST1BFUlRZX1g4Nl9JU0Ff MV9ORUVERUQpCiAJCXsKLQkJICAvKiBUaGUgc2l6ZSBvZiBHTlVfUFJPUEVSVFlfWDg2X0ZFQVRV UkVfMV9BTkQgaXMgNAotCQkgICAgIGJ5dGVzLiAgV2hlbiBzZWVpbmcgR05VX1BST1BFUlRZX1g4 Nl9GRUFUVVJFXzFfQU5ELAotCQkgICAgIHdlIHN0b3AgdGhlIHNlYXJjaCByZWdhcmRsZXNzIGlm IGl0cyBzaXplIGlzIGNvcnJlY3QKLQkJICAgICBvciBub3QuICBUaGVyZSBpcyBubyBwb2ludCB0 byBjb250aW51ZSBpZiB0aGlzIG5vdGUKLQkJICAgICBpcyBpbGwtZm9ybWVkLiAgKi8KKwkJICAv KiBUaGUgc2l6ZXMgb2YgdHlwZXMgd2hpY2ggd2UgYXJlIHNlYXJjaGluZyBmb3IgYXJlCisJCSAg ICAgNCBieXRlcy4gIFRoZXJlIGlzIG5vIHBvaW50IHRvIGNvbnRpbnVlIGlmIHRoaXMKKwkJICAg ICBub3RlIGlzIGlsbC1mb3JtZWQuICAqLwogCQkgIGlmIChkYXRhc3ogIT0gNCkKIAkJICAgIHJl dHVybjsKIAotCQkgIGZlYXR1cmVfMSA9ICoodW5zaWduZWQgaW50ICopIHB0cjsKLQotCQkgIC8q IEtlZXAgc2VhcmNoaW5nIGZvciB0aGUgbmV4dCBHTlUgcHJvcGVydHkgbm90ZQotCQkgICAgIGdl bmVyYXRlZCBieSB0aGUgb2xkZXIgbGlua2VyLiAgKi8KLQkJICBicmVhazsKKwkJICAvKiBOQjog U3RvcCB0aGUgc2NhbiBvbmx5IGFmdGVyIHNlZWluZyBhbGwgdHlwZXMgd2hpY2gKKwkJICAgICB3 ZSBhcmUgc2VhcmNoaW5nIGZvci4gICovCisJCSAgX1N0YXRpY19hc3NlcnQgKChHTlVfUFJPUEVS VFlfWDg2X0lTQV8xX05FRURFRCA+CisJCQkJICAgR05VX1BST1BFUlRZX1g4Nl9GRUFUVVJFXzFf QU5EKSwKKwkJCQkgICJHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX05FRURFRCA+ICIKKwkJCQkgICJH TlVfUFJPUEVSVFlfWDg2X0ZFQVRVUkVfMV9BTkQiKTsKKwkJICBpZiAodHlwZSA9PSBHTlVfUFJP UEVSVFlfWDg2X0ZFQVRVUkVfMV9BTkQpCisJCSAgICBmZWF0dXJlXzFfYW5kID0gKih1bnNpZ25l ZCBpbnQgKikgcHRyOworCQkgIGVsc2UKKwkJICAgIHsKKwkJICAgICAgaXNhXzFfbmVlZGVkID0g Kih1bnNpZ25lZCBpbnQgKikgcHRyOworCisJCSAgICAgIC8qIEtlZXAgc2VhcmNoaW5nIGZvciB0 aGUgbmV4dCBHTlUgcHJvcGVydHkgbm90ZQorCQkJIGdlbmVyYXRlZCBieSB0aGUgb2xkZXIgbGlu a2VyLiAgKi8KKwkJICAgICAgYnJlYWs7CisJCSAgICB9CiAJCX0KLQkgICAgICBlbHNlIGlmICh0 eXBlID4gR05VX1BST1BFUlRZX1g4Nl9GRUFUVVJFXzFfQU5EKQorCSAgICAgIGVsc2UgaWYgKHR5 cGUgPiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX05FRURFRCkKIAkJewotCQkgIC8qIFN0b3Agc2lu Y2UgcHJvcGVydHkgdHlwZSBpcyBpbiBhc2NlbmRpbmcgb3JkZXIuICAqLwotCQkgIHJldHVybjsK KwkJICAvKiBTdG9wIHRoZSBzY2FuIHNpbmNlIHByb3BlcnR5IHR5cGUgaXMgaW4gYXNjZW5kaW5n CisJCSAgICAgb3JkZXIuICAqLworCQkgIGJyZWFrOwogCQl9CiAKIAkgICAgICAvKiBDaGVjayB0 aGUgbmV4dCBwcm9wZXJ0eSBpdGVtLiAgKi8KQEAgLTEzNywxOCArMTg3LDIxIEBAIF9kbF9wcm9j ZXNzX2NldF9wcm9wZXJ0eV9ub3RlIChzdHJ1Y3QgbGlua19tYXAgKmwsCiAgICAgfQogCiAgIC8q IFdlIGdldCBoZXJlIG9ubHkgaWYgdGhlcmUgaXMgb25lIG9yIG5vIEdOVSBwcm9wZXJ0eSBub3Rl LiAgKi8KLSAgaWYgKChmZWF0dXJlXzEgJiBHTlVfUFJPUEVSVFlfWDg2X0ZFQVRVUkVfMV9JQlQp KQotICAgIGwtPmxfY2V0IHw9IGxjX2lidDsKLSAgaWYgKChmZWF0dXJlXzEgJiBHTlVfUFJPUEVS VFlfWDg2X0ZFQVRVUkVfMV9TSFNUSykpCi0gICAgbC0+bF9jZXQgfD0gbGNfc2hzdGs7Ci0jZW5k aWYKKyAgaWYgKGlzYV8xX25lZWRlZCAhPSAwIHx8IGZlYXR1cmVfMV9hbmQgIT0gMCkKKyAgICB7 CisgICAgICBsLT5sX3Byb3BlcnR5ID0gbGNfcHJvcGVydHlfdmFsaWQ7CisgICAgICBsLT5sX3g4 Nl9pc2FfMV9uZWVkZWQgPSBpc2FfMV9uZWVkZWQ7CisgICAgICBsLT5sX3g4Nl9mZWF0dXJlXzFf YW5kID0gZmVhdHVyZV8xX2FuZDsKKyAgICB9CisgIGVsc2UKKyAgICBsLT5sX3Byb3BlcnR5ID0g bGNfcHJvcGVydHlfbm9uZTsKIH0KIAogc3RhdGljIGlubGluZSB2b2lkIF9fYXR0cmlidXRlX18g KCh1bnVzZWQpKQogX2RsX3Byb2Nlc3NfcHRfbm90ZSAoc3RydWN0IGxpbmtfbWFwICpsLCBpbnQg ZmQsIGNvbnN0IEVsZlcoUGhkcikgKnBoKQogewogICBjb25zdCBFbGZXKE5oZHIpICpub3RlID0g KGNvbnN0IHZvaWQgKikgKHBoLT5wX3ZhZGRyICsgbC0+bF9hZGRyKTsKLSAgX2RsX3Byb2Nlc3Nf Y2V0X3Byb3BlcnR5X25vdGUgKGwsIG5vdGUsIHBoLT5wX21lbXN6LCBwaC0+cF9hbGlnbik7Cisg IF9kbF9wcm9jZXNzX3Byb3BlcnR5X25vdGUgKGwsIG5vdGUsIHBoLT5wX21lbXN6LCBwaC0+cF9h bGlnbik7CiB9CiAKIHN0YXRpYyBpbmxpbmUgaW50IF9fYXR0cmlidXRlX18gKChhbHdheXNfaW5s aW5lKSkKZGlmZiAtLWdpdCBhL3N5c2RlcHMveDg2L2dldC1pc2EtbGV2ZWwuaCBiL3N5c2RlcHMv eDg2L2dldC1pc2EtbGV2ZWwuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw Li5hODZlMWU4OTQxCi0tLSAvZGV2L251bGwKKysrIGIvc3lzZGVwcy94ODYvZ2V0LWlzYS1sZXZl bC5oCkBAIC0wLDAgKzEsNjYgQEAKKy8qIEdldCB4ODYgSVNBIGxldmVsLgorICAgVGhpcyBmaWxl IGlzIHBhcnQgb2YgdGhlIEdOVSBDIExpYnJhcnkuCisgICBDb3B5cmlnaHQgKEMpIDIwMjAgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisKKyAgIFRoZSBHTlUgQyBMaWJyYXJ5IGlzIGZy ZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICAgbW9kaWZ5IGl0 IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYworICAgTGlj ZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy CisgICB2ZXJzaW9uIDIuMSBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkg bGF0ZXIgdmVyc2lvbi4KKworICAgVGhlIEdOVSBDIExpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4g dGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJS QU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgICBNRVJDSEFOVEFC SUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQor ICAgTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKworICAg WW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFs IFB1YmxpYworICAgTGljZW5zZSBhbG9uZyB3aXRoIHRoZSBHTlUgQyBMaWJyYXJ5OyBpZiBub3Qs IHNlZQorICAgPGh0dHBzOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4gICovCisKKyNpbmNsdWRl IDxzeXMvcGxhdGZvcm0veDg2Lmg+CisKKy8qIEdldCBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX0JB U0VMSU5FIGFuZCBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1ZbMjM0XQorICAgSVNBIGxldmVsLiAg Ki8KKworc3RhdGljIHVuc2lnbmVkIGludAorZ2V0X2lzYV9sZXZlbCAoY29uc3Qgc3RydWN0IGNw dV9mZWF0dXJlcyAqY3B1X2ZlYXR1cmVzKQoreworICB1bnNpZ25lZCBpbnQgaXNhX2xldmVsID0g MDsKKworICBpZiAoQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgQ01PVikKKyAg ICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRV9QIChjcHVfZmVhdHVyZXMsIENYOCkKKyAgICAgICYm IENQVV9GRUFUVVJFX0NQVV9QIChjcHVfZmVhdHVyZXMsIEZQVSkKKyAgICAgICYmIENQVV9GRUFU VVJFX1VTQUJMRV9QIChjcHVfZmVhdHVyZXMsIEZYU1IpCisgICAgICAmJiBDUFVfRkVBVFVSRV9V U0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBNTVgpCisgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVf UCAoY3B1X2ZlYXR1cmVzLCBTU0UpCisgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1 X2ZlYXR1cmVzLCBTU0UyKSkKKyAgICB7CisgICAgICBpc2FfbGV2ZWwgPSBHTlVfUFJPUEVSVFlf WDg2X0lTQV8xX0JBU0VMSU5FOworICAgICAgaWYgKENQVV9GRUFUVVJFX1VTQUJMRV9QIChjcHVf ZmVhdHVyZXMsIENNUFhDSEcxNkIpCisJICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2Zl YXR1cmVzLCBMQUhGNjRfU0FIRjY0KQorCSAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9m ZWF0dXJlcywgUE9QQ05UKQorCSAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJl cywgU1NFMykKKwkgICYmIENQVV9GRUFUVVJFX1VTQUJMRV9QIChjcHVfZmVhdHVyZXMsIFNTU0Uz KQorCSAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgU1NFNF8xKQorCSAg JiYgQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgU1NFNF8yKSkKKwl7CisJICBp c2FfbGV2ZWwgfD0gR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9WMjsKKwkgIGlmIChDUFVfRkVBVFVS RV9VU0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBBVlgpCisJICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNB QkxFX1AgKGNwdV9mZWF0dXJlcywgQVZYMikKKwkgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVf UCAoY3B1X2ZlYXR1cmVzLCBGMTZDKQorCSAgICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRV9QIChj cHVfZmVhdHVyZXMsIEZNQSkKKwkgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2Zl YXR1cmVzLCBMWkNOVCkKKwkgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2ZlYXR1 cmVzLCBNT1ZCRSkpCisJICAgIHsKKwkgICAgICBpc2FfbGV2ZWwgfD0gR05VX1BST1BFUlRZX1g4 Nl9JU0FfMV9WMzsKKwkgICAgICBpZiAoQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJl cywgQVZYNTEyRikKKwkJICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBB Vlg1MTJCVykKKwkJICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBBVlg1 MTJDRCkKKwkJICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBBVlg1MTJE USkKKwkJICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBBVlg1MTJWTCkp CisJCWlzYV9sZXZlbCB8PSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1Y0OworCSAgICB9CisJfQor ICAgIH0KKworICByZXR1cm4gaXNhX2xldmVsOworfQpkaWZmIC0tZ2l0IGEvc3lzZGVwcy94ODYv aW5jbHVkZS9jcHUtZmVhdHVyZXMuaCBiL3N5c2RlcHMveDg2L2luY2x1ZGUvY3B1LWZlYXR1cmVz LmgKaW5kZXggZmZlMzAwYzkzMS4uOTllN2VlMDhjZiAxMDA2NDQKLS0tIGEvc3lzZGVwcy94ODYv aW5jbHVkZS9jcHUtZmVhdHVyZXMuaAorKysgYi9zeXNkZXBzL3g4Ni9pbmNsdWRlL2NwdS1mZWF0 dXJlcy5oCkBAIC0xMjMsNiArMTIzLDggQEAgc3RydWN0IGNwdV9mZWF0dXJlcwogICBzdHJ1Y3Qg Y3B1X2ZlYXR1cmVzX2Jhc2ljIGJhc2ljOwogICBzdHJ1Y3QgY3B1aWRfZmVhdHVyZXMgZmVhdHVy ZXNbQ09NTU9OX0NQVUlEX0lOREVYX01BWF07CiAgIHVuc2lnbmVkIGludCBwcmVmZXJyZWRbUFJF RkVSUkVEX0ZFQVRVUkVfSU5ERVhfTUFYXTsKKyAgLyogWDg2IG1pY3JvLWFyY2hpdGVjdHVyZSBJ U0EgbGV2ZWxzLiAgKi8KKyAgdW5zaWduZWQgaW50IGlzYV8xOwogICAvKiBUaGUgc3RhdGUgc2l6 ZSBmb3IgWFNBVkVDIG9yIFhTQVZFLiAgVGhlIHR5cGUgbXVzdCBiZSB1bnNpZ25lZCBsb25nCiAg ICAgIGludCBzbyB0aGF0IHdlIHVzZQogCmRpZmYgLS1naXQgYS9zeXNkZXBzL3g4Ni9pc2EtbGV2 ZWwuYyBiL3N5c2RlcHMveDg2L2lzYS1sZXZlbC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAuLmFhZjUyNGNiNTYKLS0tIC9kZXYvbnVsbAorKysgYi9zeXNkZXBzL3g4Ni9p c2EtbGV2ZWwuYwpAQCAtMCwwICsxLDk3IEBACisvKiBFTEYgcHJvZ3JhbSBwcm9wZXJ0eSBmb3Ig eDg2IElTQSBsZXZlbC4KKyAgIENvcHlyaWdodCAoQykgMjAyMCBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4KKyAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBHTlUgQyBMaWJyYXJ5Lgor CisgICBUaGUgR05VIEMgTGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJp YnV0ZSBpdCBhbmQvb3IKKyAgIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBM ZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAgIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVl IFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlcgorICAgdmVyc2lvbiAyLjEgb2YgdGhlIExpY2Vu c2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisKKyAgIEluIGFkZGl0 aW9uIHRvIHRoZSBwZXJtaXNzaW9ucyBpbiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwor ICAgTGljZW5zZSwgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiBnaXZlcyB5b3UgdW5saW1p dGVkCisgICBwZXJtaXNzaW9uIHRvIGxpbmsgdGhlIGNvbXBpbGVkIHZlcnNpb24gb2YgdGhpcyBm aWxlIHdpdGggb3RoZXIKKyAgIHByb2dyYW1zLCBhbmQgdG8gZGlzdHJpYnV0ZSB0aG9zZSBwcm9n cmFtcyB3aXRob3V0IGFueSByZXN0cmljdGlvbgorICAgY29taW5nIGZyb20gdGhlIHVzZSBvZiB0 aGlzIGZpbGUuICAoVGhlIExlc3NlciBHZW5lcmFsIFB1YmxpYworICAgTGljZW5zZSByZXN0cmlj dGlvbnMgZG8gYXBwbHkgaW4gb3RoZXIgcmVzcGVjdHM7IGZvciBleGFtcGxlLCB0aGV5CisgICBj b3ZlciBtb2RpZmljYXRpb24gb2YgdGhlIGZpbGUsIGFuZCBkaXN0cmlidXRpb24gd2hlbiBub3Qg bGlua2VkCisgICBpbnRvIGFub3RoZXIgcHJvZ3JhbS4pCisKKyAgIFRoZSBHTlUgQyBMaWJyYXJ5 IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCisgICBi dXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50 eSBvZgorICAgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZSBHTlUKKyAgIExlc3NlciBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBt b3JlIGRldGFpbHMuCisKKyAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhl IEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKKyAgIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGUgR05V IEMgTGlicmFyeTsgaWYgbm90LCBzZWUKKyAgIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vuc2Vz Lz4uICAqLworCisjaW5jbHVkZSA8ZWxmLmg+CisKKy8qIEVMRiBwcm9ncmFtIHByb3BlcnR5IGZv ciB4ODYgSVNBIGxldmVsLiAgKi8KKyNpZmRlZiBJTkNMVURFX1g4Nl9JU0FfTEVWRUwKKyMgaWYg ZGVmaW5lZCBfX3g4Nl82NF9fIHx8IGRlZmluZWQgX19GWFNSX18gfHwgIWRlZmluZWQgX1NPRlRf RkxPQVQgXAorICAgICB8fCBkZWZpbmVkICBfX01NWF9fIHx8IGRlZmluZWQgX19TU0VfXyB8fCBk ZWZpbmVkIF9fU1NFMl9fCisjICBkZWZpbmUgSVNBX0JBU0VMSU5FCUdOVV9QUk9QRVJUWV9YODZf SVNBXzFfQkFTRUxJTkUKKyMgZWxzZQorIyAgZGVmaW5lIElTQV9CQVNFTElORQkwCisjIGVuZGlm CisKKyMgaWYgZGVmaW5lZCBfX0dDQ19IQVZFX1NZTkNfQ09NUEFSRV9BTkRfU1dBUF8xNiBcCisg ICAgIHx8IChkZWZpbmVkIF9feDg2XzY0X18gJiYgZGVmaW5lZCBfX0xBSEZfU0FIRl9fKSBcCisg ICAgIHx8IGRlZmluZWQgX19QT1BDTlRfXyB8fCBkZWZpbmVkIF9fU1NFM19fIFwKKyAgICAgfHwg ZGVmaW5lZCBfX1NTU0UzX18gfHwgZGVmaW5lZCBfX1NTRTRfMV9fIHx8IGRlZmluZWQgX19TU0U0 XzJfXworIyAgZGVmaW5lIElTQV9WMglHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1YyCisjIGVsc2UK KyMgIGRlZmluZSBJU0FfVjIJMAorIyBlbmRpZgorCisjIGlmIGRlZmluZWQgX19BVlhfXyB8fCBk ZWZpbmVkIF9fQVZYMl9fIHx8IGRlZmluZWQgX19GMTZDX18gXAorICAgICB8fCBkZWZpbmVkIF9f Rk1BX18gfHwgZGVmaW5lZCBfX0xaQ05UX18gfHwgZGVmaW5lZCBfX01PVkJFX18gXAorICAgICB8 fCBkZWZpbmVkIF9fWFNBVkVfXworIyAgZGVmaW5lIElTQV9WMwlHTlVfUFJPUEVSVFlfWDg2X0lT QV8xX1YzCisjIGVsc2UKKyMgIGRlZmluZSBJU0FfVjMJMAorIyBlbmRpZgorCisjIGlmIGRlZmlu ZWQgX19BVlg1MTJGX18gfHwgZGVmaW5lZCBfX0FWWDUxMkJXX18gfHwgZGVmaW5lZCBfX0FWWDUx MkNEX18gXAorICAgICB8fCBkZWZpbmVkIF9fQVZYNTEyRFFfXyB8fCBkZWZpbmVkIF9fQVZYNTEy VkxfXworIyAgZGVmaW5lIElTQV9WNAlHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1Y0CisjIGVsc2UK KyMgIGRlZmluZSBJU0FfVjQJMAorIyBlbmRpZgorCisjIGlmbmRlZiBJU0FfTEVWRUwKKyMgIGRl ZmluZSBJU0FfTEVWRUwgKElTQV9CQVNFTElORSB8IElTQV9WMiB8IElTQV9WMyB8IElTQV9WNCkK KyMgZW5kaWYKKworIyBpZiBJU0FfTEVWRUwKKyMgIGlmZGVmIF9fTFA2NF9fCisjICAgZGVmaW5l IFBST1BFUlRZX0FMSUdOIDMKKyMgIGVsc2UKKyMgICBkZWZpbmUgUFJPUEVSVFlfQUxJR04gMgor IyAgZW5kaWYKKworIyAgZGVmaW5lIG5vdGVfc3RyaW5naWZ5KGFyZykgbm90ZV9zdHJpbmdpZnlf MShhcmcpCisjICBkZWZpbmUgbm90ZV9zdHJpbmdpZnlfMShhcmcpICNhcmcKKworYXNtKCIucHVz aHNlY3Rpb24gXCIubm90ZS5nbnUucHJvcGVydHlcIixcImFcIixAbm90ZVxuIgorIgkucDJhbGln biAiIG5vdGVfc3RyaW5naWZ5IChQUk9QRVJUWV9BTElHTikKKwkvKiBuYW1lIGxlbmd0aC4gICov CisiXG4JLmxvbmcgMWYgLSAwZlxuIgorCS8qIGRhdGEgbGVuZ3RoLiAgKi8KKyIJLmxvbmcgNGYg LSAxZlxuIgorCS8qIG5vdGUgdHlwZTogTlRfR05VX1BST1BFUlRZX1RZUEVfMC4gICovCisiCS5s b25nICIgbm90ZV9zdHJpbmdpZnkgKE5UX0dOVV9QUk9QRVJUWV9UWVBFXzApCisJLyogdmVuZG9y IG5hbWUuICAqLworIlxuMDoJLmFzY2l6IFwiR05VXCJcbiIKKyIxOgkucDJhbGlnbiAiIG5vdGVf c3RyaW5naWZ5IChQUk9QRVJUWV9BTElHTikKKwkvKiBwcl90eXBlOiBHTlVfUFJPUEVSVFlfWDg2 X0lTQV8xX05FRURFRC4gICovCisiXG4JLmxvbmcgIiBub3RlX3N0cmluZ2lmeSAoR05VX1BST1BF UlRZX1g4Nl9JU0FfMV9ORUVERUQpCisJLyogcHJfZGF0YXN6LiAgKi8KKyJcbgkubG9uZyAzZiAt IDJmXG4iCisJLyogR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9WWzIzNF0uICAqLworIjI6XG4JIC5s b25nICIgbm90ZV9zdHJpbmdpZnkgKElTQV9MRVZFTCkKKyJcbjM6XG4JLnAyYWxpZ24gIiBub3Rl X3N0cmluZ2lmeSAoUFJPUEVSVFlfQUxJR04pCisiXG40OlxuIC5wb3BzZWN0aW9uIik7CisjIGVu ZGlmIC8qIElTQV9MRVZFTCAqLworI2VuZGlmIC8qIElOQ0xVREVfWDg2X0lTQV9MRVZFTCAqLwpk aWZmIC0tZ2l0IGEvc3lzZGVwcy94ODYvbGlua19tYXAuaCBiL3N5c2RlcHMveDg2L2xpbmtfbWFw LmgKaW5kZXggODA3NDczOWI0Ny4uNGM0NmEyNWY4MyAxMDA2NDQKLS0tIGEvc3lzZGVwcy94ODYv bGlua19tYXAuaAorKysgYi9zeXNkZXBzL3g4Ni9saW5rX21hcC5oCkBAIC0xNiwxMiArMTYsMTYg QEAKICAgIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGUgR05VIEMgTGlicmFyeTsgaWYgbm90LCBzZWUK ICAgIDxodHRwczovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLwogCi0vKiBJZiB0aGlzIG9i amVjdCBpcyBlbmFibGVkIHdpdGggQ0VULiAgKi8KKy8qIGlmIHRoaXMgb2JqZWN0IGhhcyBHTlUg cHJvcGVydHkuICAqLwogZW51bQogICB7Ci0gICAgbGNfdW5rbm93biA9IDAsCQkJIC8qIFVua25v d24gQ0VUIHN0YXR1cy4gICovCi0gICAgbGNfbm9uZSA9IDEgPDwgMCwJCQkgLyogTm90IGVuYWJs ZWQgd2l0aCBDRVQuICAqLwotICAgIGxjX2lidCA9IDEgPDwgMSwJCQkgLyogRW5hYmxlZCB3aXRo IElCVC4gICovCi0gICAgbGNfc2hzdGsgPSAxIDw8IDIsCQkJIC8qIEVuYWJsZWQgd2l0aCBTVFNI Sy4gICovCi0gICAgbGNfaWJ0X2FuZF9zaHN0ayA9IGxjX2lidCB8IGxjX3Noc3RrIC8qIEVuYWJs ZWQgd2l0aCBib3RoLiAgKi8KLSAgfSBsX2NldDozOworICAgIGxjX3Byb3BlcnR5X3Vua25vd24g PSAwLAkJLyogVW5rbm93biBwcm9wZXJ0eSBzdGF0dXMuICAqLworICAgIGxjX3Byb3BlcnR5X25v bmUgPSAxIDw8IDAsCQkvKiBObyBwcm9wZXJ0eS4gICovCisgICAgbGNfcHJvcGVydHlfdmFsaWQg PSAxIDw8IDEJCS8qIEhhcyB2YWxpZCBwcm9wZXJ0eS4gICovCisgIH0gbF9wcm9wZXJ0eToyOwor CisvKiBHTlVfUFJPUEVSVFlfWDg2X0ZFQVRVUkVfMV9BTkQgb2YgdGhpcyBvYmplY3QuICAqLwor dW5zaWduZWQgaW50IGxfeDg2X2ZlYXR1cmVfMV9hbmQ7CisKKy8qIEdOVV9QUk9QRVJUWV9YODZf SVNBXzFfTkVFREVEIG9mIHRoaXMgb2JqZWN0LiAgKi8KK3Vuc2lnbmVkIGludCBsX3g4Nl9pc2Ff MV9uZWVkZWQ7CmRpZmYgLS1naXQgYS9zeXNkZXBzL3g4Ni90c3QtaXNhLWxldmVsLTEuYyBiL3N5 c2RlcHMveDg2L3RzdC1pc2EtbGV2ZWwtMS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAuLmNmNjExZThiNzgKLS0tIC9kZXYvbnVsbAorKysgYi9zeXNkZXBzL3g4Ni90c3Qt aXNhLWxldmVsLTEuYwpAQCAtMCwwICsxLDEwNCBAQAorLyogQ2hlY2sgSVNBIGxldmVsIG9uIGRs b3BlbmVkIHNoYXJlZCBvYmplY3QuCisgICBDb3B5cmlnaHQgKEMpIDIwMjAgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uLCBJbmMuCisgICBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgR05VIEMgTGli cmFyeS4KKworICAgVGhlIEdOVSBDIExpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAgIHZlcnNpb24gMi4xIG9mIHRo ZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBU aGUgR05VIEMgTGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwg YmUgdXNlZnVsLAorICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl IGltcGxpZWQgd2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgICBMZXNzZXIgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2 ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgICBMaWNlbnNlIGFs b25nIHdpdGggdGhlIEdOVSBDIExpYnJhcnk7IGlmIG5vdCwgc2VlCisgICA8aHR0cHM6Ly93d3cu Z251Lm9yZy9saWNlbnNlcy8+LiAgKi8KKworI2luY2x1ZGUgPHN0ZGxpYi5oPgorI2luY2x1ZGUg PHN0ZGJvb2wuaD4KKyNpbmNsdWRlIDxzdHJpbmcuaD4KKyNpbmNsdWRlIDxlbGYuaD4KKyNpbmNs dWRlIDxnZXQtaXNhLWxldmVsLmg+CisjaW5jbHVkZSA8c3VwcG9ydC94ZGxmY24uaD4KKyNpbmNs dWRlIDxzdXBwb3J0L2NoZWNrLmg+CisjaW5jbHVkZSA8c3VwcG9ydC90ZXN0LWRyaXZlci5oPgor CitzdGF0aWMgdm9pZAorZG9fdGVzdF8xIChjb25zdCBjaGFyICptb2RuYW1lLCBib29sIGZhaWwp Cit7CisgIGludCAoKmZwKSAodm9pZCk7CisgIHZvaWQgKmg7CisKKyAgaCA9IGRsb3BlbiAobW9k bmFtZSwgUlRMRF9MQVpZKTsKKyAgaWYgKGggPT0gTlVMTCkKKyAgICB7CisgICAgICBjb25zdCBj aGFyICplcnIgPSBkbGVycm9yICgpOworICAgICAgaWYgKGZhaWwpCisJeworCSAgaWYgKHN0cnN0 ciAoZXJyLCAiQ1BVIElTQSBsZXZlbCBpcyBsb3dlciB0aGFuIHJlcXVpcmVkIikgPT0gTlVMTCkK KwkgICAgRkFJTF9FWElUMSAoImluY29ycmVjdCBkbG9wZW4gJyVzJyBlcnJvcjogJXNcbiIsIG1v ZG5hbWUsIGVycik7CisKKwkgIHJldHVybjsKKwl9CisKKyAgICAgIEZBSUxfRVhJVDEgKCJjYW5u b3Qgb3BlbiAnJXMnOiAlc1xuIiwgbW9kbmFtZSwgZXJyKTsKKyAgICB9CisKKyAgaWYgKGZhaWwp CisgICAgRkFJTF9FWElUMSAoImRsb3BlbiAnJXMnIHNob3VsZCBoYXZlIGZhaWxlZFxuIiwgbW9k bmFtZSk7CisKKyAgZnAgPSB4ZGxzeW0gKGgsICJ0ZXN0Iik7CisKKyAgaWYgKGZwICgpICE9IDAp CisgICAgRkFJTF9FWElUMSAoInRlc3QgKCkgIT0gMFxuIik7CisKKyAgZGxjbG9zZSAoaCk7Cit9 CisKK3N0YXRpYyBpbnQKK2RvX3Rlc3QgKHZvaWQpCit7CisgIGNvbnN0IHN0cnVjdCBjcHVfZmVh dHVyZXMgKmNwdV9mZWF0dXJlcworICAgID0gX194ODZfZ2V0X2NwdV9mZWF0dXJlcyAoQ09NTU9O X0NQVUlEX0lOREVYX01BWCk7CisgIHVuc2lnbmVkIGludCBpc2FfbGV2ZWwgPSBnZXRfaXNhX2xl dmVsIChjcHVfZmVhdHVyZXMpOworICBib29sIGhhc19pc2FfYmFzZWxpbmUgPSAoKGlzYV9sZXZl bCAmIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfQkFTRUxJTkUpCisJCQkgICA9PSBHTlVfUFJPUEVS VFlfWDg2X0lTQV8xX0JBU0VMSU5FKTsKKyAgYm9vbCBoYXNfaXNhX3YyID0gKChpc2FfbGV2ZWwg JiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1YyKQorCQkJICAgPT0gR05VX1BST1BFUlRZX1g4Nl9J U0FfMV9WMik7CisgIGJvb2wgaGFzX2lzYV92MyA9ICgoaXNhX2xldmVsICYgR05VX1BST1BFUlRZ X1g4Nl9JU0FfMV9WMykKKwkJCSAgID09IEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfVjMpOworICBi b29sIGhhc19pc2FfdjQgPSAoKGlzYV9sZXZlbCAmIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfVjQp CisJCQkgICA9PSBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1Y0KTsKKworICBpZiAoIWhhc19pc2Ff YmFzZWxpbmUpCisgICAgeworICAgICAgZG9fdGVzdF8xICgidHN0LWlzYS1sZXZlbC1tb2QtMS1i YXNlbGluZS5zbyIsIHRydWUpOworICAgICAgcmV0dXJuIEVYSVRfU1VDQ0VTUzsKKyAgICB9CisK KyAgZG9fdGVzdF8xICgidHN0LWlzYS1sZXZlbC1tb2QtMS1iYXNlbGluZS5zbyIsIGZhbHNlKTsK KworICAvKiBTa2lwIG9uIHg4Ni02NC12NCBwbGF0Zm9ybXMgc2luY2UgZGxvcGVuIHY0IG1vZHVs ZSBhbHdheXMgd29ya3MuICAqLworICBpZiAoaGFzX2lzYV92NCkKKyAgICByZXR1cm4gRVhJVF9T VUNDRVNTOworCisgIGRvX3Rlc3RfMSAoInRzdC1pc2EtbGV2ZWwtbW9kLTEtdjQuc28iLCB0cnVl KTsKKworICAvKiBTa2lwIG9uIHg4Ni02NC12MyBwbGF0Zm9ybXMgc2luY2UgZGxvcGVuIHYzIG1v ZHVsZSBhbHdheXMgd29ya3MuICAqLworICBpZiAoaGFzX2lzYV92MykKKyAgICByZXR1cm4gRVhJ VF9TVUNDRVNTOworCisgIGRvX3Rlc3RfMSAoInRzdC1pc2EtbGV2ZWwtbW9kLTEtdjMuc28iLCB0 cnVlKTsKKworICAvKiBTa2lwIG9uIHg4Ni02NC12MiBwbGF0Zm9ybXMgc2luY2UgZGxvcGVuIHYy IG1vZHVsZSBhbHdheXMgd29ya3MuICAqLworICBpZiAoaGFzX2lzYV92MikKKyAgICByZXR1cm4g RVhJVF9TVUNDRVNTOworCisgIGRvX3Rlc3RfMSAoInRzdC1pc2EtbGV2ZWwtbW9kLTEtdjIuc28i LCB0cnVlKTsKKworICByZXR1cm4gRVhJVF9TVUNDRVNTOworfQorCisjaW5jbHVkZSA8c3VwcG9y dC90ZXN0LWRyaXZlci5jPgpkaWZmIC0tZ2l0IGEvc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZlbC1t b2QtMS1iYXNlbGluZS5jIGIvc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZlbC1tb2QtMS1iYXNlbGlu ZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLmQ2ZmUwNjg1YTQKLS0t IC9kZXYvbnVsbAorKysgYi9zeXNkZXBzL3g4Ni90c3QtaXNhLWxldmVsLW1vZC0xLWJhc2VsaW5l LmMKQEAgLTAsMCArMSBAQAorI2luY2x1ZGUgInRzdC1pc2EtbGV2ZWwtbW9kLTEuYyIKZGlmZiAt LWdpdCBhL3N5c2RlcHMveDg2L3RzdC1pc2EtbGV2ZWwtbW9kLTEtdjIuYyBiL3N5c2RlcHMveDg2 L3RzdC1pc2EtbGV2ZWwtbW9kLTEtdjIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwLi5kNmZlMDY4NWE0Ci0tLSAvZGV2L251bGwKKysrIGIvc3lzZGVwcy94ODYvdHN0LWlz YS1sZXZlbC1tb2QtMS12Mi5jCkBAIC0wLDAgKzEgQEAKKyNpbmNsdWRlICJ0c3QtaXNhLWxldmVs LW1vZC0xLmMiCmRpZmYgLS1naXQgYS9zeXNkZXBzL3g4Ni90c3QtaXNhLWxldmVsLW1vZC0xLXYz LmMgYi9zeXNkZXBzL3g4Ni90c3QtaXNhLWxldmVsLW1vZC0xLXYzLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uZDZmZTA2ODVhNAotLS0gL2Rldi9udWxsCisrKyBiL3N5 c2RlcHMveDg2L3RzdC1pc2EtbGV2ZWwtbW9kLTEtdjMuYwpAQCAtMCwwICsxIEBACisjaW5jbHVk ZSAidHN0LWlzYS1sZXZlbC1tb2QtMS5jIgpkaWZmIC0tZ2l0IGEvc3lzZGVwcy94ODYvdHN0LWlz YS1sZXZlbC1tb2QtMS12NC5jIGIvc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZlbC1tb2QtMS12NC5j Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLmQ2ZmUwNjg1YTQKLS0tIC9k ZXYvbnVsbAorKysgYi9zeXNkZXBzL3g4Ni90c3QtaXNhLWxldmVsLW1vZC0xLXY0LmMKQEAgLTAs MCArMSBAQAorI2luY2x1ZGUgInRzdC1pc2EtbGV2ZWwtbW9kLTEuYyIKZGlmZiAtLWdpdCBhL3N5 c2RlcHMveDg2L3RzdC1pc2EtbGV2ZWwtbW9kLTEuYyBiL3N5c2RlcHMveDg2L3RzdC1pc2EtbGV2 ZWwtbW9kLTEuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwLi40MGEyZTFk OTlmCi0tLSAvZGV2L251bGwKKysrIGIvc3lzZGVwcy94ODYvdHN0LWlzYS1sZXZlbC1tb2QtMS5j CkBAIC0wLDAgKzEsMjUgQEAKKy8qIENoZWNrIElTQSBsZXZlbCBvbiBkbG9wZW5lZCBzaGFyZWQg b2JqZWN0LgorICAgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjAgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uLCBJbmMuCisgICBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgR05VIEMgTGlicmFyeS4KKwor ICAgVGhlIEdOVSBDIExpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1 dGUgaXQgYW5kL29yCisgICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVz c2VyIEdlbmVyYWwgUHVibGljCisgICBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBT b2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKKyAgIHZlcnNpb24gMi4xIG9mIHRoZSBMaWNlbnNl LCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBUaGUgR05VIEMg TGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAorICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgICBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSBmb3IgbW9yZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5 IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCisgICBMaWNlbnNlIGFsb25nIHdpdGgg dGhlIEdOVSBDIExpYnJhcnk7IGlmIG5vdCwgc2VlCisgICA8aHR0cHM6Ly93d3cuZ251Lm9yZy9s aWNlbnNlcy8+LiAgKi8KKworI2luY2x1ZGUgPGlzYS1sZXZlbC5jPgorCitpbnQKK3Rlc3QgKHZv aWQpCit7CisgIHJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvc3lzZGVwcy94ODZfNjQvZGwtaHdj YXBzLXN1YmRpcnMuYyBiL3N5c2RlcHMveDg2XzY0L2RsLWh3Y2Fwcy1zdWJkaXJzLmMKaW5kZXgg MGFhYTYzNWEwMC4uZTAzMDUzNGYxYiAxMDA2NDQKLS0tIGEvc3lzZGVwcy94ODZfNjQvZGwtaHdj YXBzLXN1YmRpcnMuYworKysgYi9zeXNkZXBzL3g4Nl82NC9kbC1od2NhcHMtc3ViZGlycy5jCkBA IC0xOCw2ICsxOCw3IEBACiAKICNpbmNsdWRlIDxkbC1od2NhcHMuaD4KICNpbmNsdWRlIDxjcHUt ZmVhdHVyZXMuaD4KKyNpbmNsdWRlIDxnZXQtaXNhLWxldmVsLmg+CiAKIGNvbnN0IGNoYXIgX2Rs X2h3Y2Fwc19zdWJkaXJzW10gPSAieDg2LTY0LXY0Ong4Ni02NC12Mzp4ODYtNjQtdjIiOwogZW51 bSB7IHN1YmRpcnNfY291bnQgPSAzIH07IC8qIE51bWJlciBvZiBjb21wb25lbnRzIGluIF9kbF9o d2NhcHNfc3ViZGlycy4gICovCkBAIC0yNSw0MCArMjYsMjUgQEAgZW51bSB7IHN1YmRpcnNfY291 bnQgPSAzIH07IC8qIE51bWJlciBvZiBjb21wb25lbnRzIGluIF9kbF9od2NhcHNfc3ViZGlycy4g ICovCiB1aW50MzJfdAogX2RsX2h3Y2Fwc19zdWJkaXJzX2FjdGl2ZSAodm9pZCkKIHsKKyAgY29u c3Qgc3RydWN0IGNwdV9mZWF0dXJlcyAqY3B1X2ZlYXR1cmVzCisgICAgPSBfX3g4Nl9nZXRfY3B1 X2ZlYXR1cmVzIChDT01NT05fQ1BVSURfSU5ERVhfTUFYKTsKKyAgdW5zaWduZWQgaW50IGlzYV9s ZXZlbCA9IGdldF9pc2FfbGV2ZWwgKGNwdV9mZWF0dXJlcyk7CiAgIGludCBhY3RpdmUgPSAwOwog CiAgIC8qIFRlc3QgaW4gcmV2ZXJzZSBwcmVmZXJlbmNlIG9yZGVyLiAgKi8KIAogICAvKiB4ODYt NjQtdjIuICAqLwotICBpZiAoIShDUFVfRkVBVFVSRV9VU0FCTEUgKENNUFhDSEcxNkIpCi0gICAg ICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRSAoTEFIRjY0X1NBSEY2NCkKLSAgICAgICAgJiYgQ1BV X0ZFQVRVUkVfVVNBQkxFIChQT1BDTlQpCi0gICAgICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRSAo U1NFMykKLSAgICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFIChTU0U0XzEpCi0gICAgICAgICYm IENQVV9GRUFUVVJFX1VTQUJMRSAoU1NFNF8yKQotICAgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FC TEUgKFNTU0UzKSkpCisgIGlmICghKGlzYV9sZXZlbCAmIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFf VjIpKQogICAgIHJldHVybiBfZGxfaHdjYXBzX3N1YmRpcnNfYnVpbGRfYml0bWFzayAoc3ViZGly c19jb3VudCwgYWN0aXZlKTsKICAgKythY3RpdmU7CiAKICAgLyogeDg2LTY0LXYzLiAgKi8KLSAg aWYgKCEoQ1BVX0ZFQVRVUkVfVVNBQkxFIChBVlgpCi0gICAgICAgICYmIENQVV9GRUFUVVJFX1VT QUJMRSAoQVZYMikKLSAgICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFIChCTUkxKQotICAgICAg ICAmJiBDUFVfRkVBVFVSRV9VU0FCTEUgKEJNSTIpCi0gICAgICAgICYmIENQVV9GRUFUVVJFX1VT QUJMRSAoRjE2QykKLSAgICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFIChGTUEpCi0gICAgICAg ICYmIENQVV9GRUFUVVJFX1VTQUJMRSAoTFpDTlQpCi0gICAgICAgICYmIENQVV9GRUFUVVJFX1VT QUJMRSAoTU9WQkUpCi0gICAgICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRSAoT1NYU0FWRSkpKQor ICBpZiAoIShpc2FfbGV2ZWwgJiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1YzKSkKICAgICByZXR1 cm4gX2RsX2h3Y2Fwc19zdWJkaXJzX2J1aWxkX2JpdG1hc2sgKHN1YmRpcnNfY291bnQsIGFjdGl2 ZSk7CiAgICsrYWN0aXZlOwogCi0gLyogeDg2LTY0LXY0LiAgKi8KLSAgaWYgKCEoQ1BVX0ZFQVRV UkVfVVNBQkxFIChBVlg1MTJGKQotICAgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FCTEUgKEFWWDUx MkJXKQotICAgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FCTEUgKEFWWDUxMkNEKQotICAgICAgICAm JiBDUFVfRkVBVFVSRV9VU0FCTEUgKEFWWDUxMkRRKQotICAgICAgICAmJiBDUFVfRkVBVFVSRV9V U0FCTEUgKEFWWDUxMlZMKSkpCisgIC8qIHg4Ni02NC12NC4gICovCisgIGlmICghKGlzYV9sZXZl bCAmIEdOVV9QUk9QRVJUWV9YODZfSVNBXzFfVjQpKQogICAgIHJldHVybiBfZGxfaHdjYXBzX3N1 YmRpcnNfYnVpbGRfYml0bWFzayAoc3ViZGlyc19jb3VudCwgYWN0aXZlKTsKICAgKythY3RpdmU7 CiAKZGlmZiAtLWdpdCBhL3N5c2RlcHMveDg2XzY0L3RzdC1nbGliYy1od2NhcHMuYyBiL3N5c2Rl cHMveDg2XzY0L3RzdC1nbGliYy1od2NhcHMuYwppbmRleCA4YmRjYjkxZGIwLi4zN2I2MWQzYzg0 IDEwMDY0NAotLS0gYS9zeXNkZXBzL3g4Nl82NC90c3QtZ2xpYmMtaHdjYXBzLmMKKysrIGIvc3lz ZGVwcy94ODZfNjQvdHN0LWdsaWJjLWh3Y2Fwcy5jCkBAIC0xOSw3ICsxOSw4IEBACiAjaW5jbHVk ZSA8c3RkaW8uaD4KICNpbmNsdWRlIDxzdXBwb3J0L2NoZWNrLmg+CiAjaW5jbHVkZSA8c3lzL3Bh cmFtLmg+Ci0jaW5jbHVkZSA8c3lzL3BsYXRmb3JtL3g4Ni5oPgorI2luY2x1ZGUgPGVsZi5oPgor I2luY2x1ZGUgPGdldC1pc2EtbGV2ZWwuaD4KIAogZXh0ZXJuIGludCBtYXJrZXIyICh2b2lkKTsK IGV4dGVybiBpbnQgbWFya2VyMyAodm9pZCk7CkBAIC0zMSwzNSArMzIsMTUgQEAgY29tcHV0ZV9s ZXZlbCAodm9pZCkKIHsKICAgY29uc3Qgc3RydWN0IGNwdV9mZWF0dXJlcyAqY3B1X2ZlYXR1cmVz CiAgICAgPSBfX3g4Nl9nZXRfY3B1X2ZlYXR1cmVzIChDT01NT05fQ1BVSURfSU5ERVhfTUFYKTsK LQotIGlmICghKENQVV9GRUFUVVJFX1VTQUJMRV9QIChjcHVfZmVhdHVyZXMsIENNUFhDSEcxNkIp Ci0gICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgTEFIRjY0X1NB SEY2NCkKLSAgICAgICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBQT1BD TlQpCi0gICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgTU1YKQot ICAgICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRV9QIChjcHVfZmVhdHVyZXMsIFNTRSkKLSAgICAg ICAmJiBDUFVfRkVBVFVSRV9VU0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBTU0UyKQotICAgICAgICYm IENQVV9GRUFUVVJFX1VTQUJMRV9QIChjcHVfZmVhdHVyZXMsIFNTRTMpCi0gICAgICAgJiYgQ1BV X0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgU1NTRTMpCi0gICAgICAgJiYgQ1BVX0ZF QVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgU1NFNF8xKQotICAgICAgICYmIENQVV9GRUFU VVJFX1VTQUJMRV9QIChjcHVfZmVhdHVyZXMsIFNTRTRfMikpKQotICAgcmV0dXJuIDE7Ci0gaWYg KCEoQ1BVX0ZFQVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgQVZYKQotICAgICAgICYmIENQ VV9GRUFUVVJFX1VTQUJMRV9QIChjcHVfZmVhdHVyZXMsIEFWWDIpCi0gICAgICAgJiYgQ1BVX0ZF QVRVUkVfVVNBQkxFX1AgKGNwdV9mZWF0dXJlcywgQk1JMSkKLSAgICAgICAmJiBDUFVfRkVBVFVS RV9VU0FCTEVfUCAoY3B1X2ZlYXR1cmVzLCBCTUkyKQotICAgICAgICYmIENQVV9GRUFUVVJFX1VT QUJMRV9QIChjcHVfZmVhdHVyZXMsIEYxNkMpCi0gICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxF X1AgKGNwdV9mZWF0dXJlcywgRk1BKQotICAgICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRV9QIChj cHVfZmVhdHVyZXMsIExaQ05UKQotICAgICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRV9QIChjcHVf ZmVhdHVyZXMsIE1PVkJFKQotICAgICAgICYmIENQVV9GRUFUVVJFX1VTQUJMRV9QIChjcHVfZmVh dHVyZXMsIE9TWFNBVkUpKSkKLSAgIHJldHVybiAyOwotIGlmICghKENQVV9GRUFUVVJFX1VTQUJM RV9QIChjcHVfZmVhdHVyZXMsIEFWWDUxMkYpCi0gICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxF X1AgKGNwdV9mZWF0dXJlcywgQVZYNTEyQlcpCi0gICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxF X1AgKGNwdV9mZWF0dXJlcywgQVZYNTEyQ0QpCi0gICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxF X1AgKGNwdV9mZWF0dXJlcywgQVZYNTEyRFEpCi0gICAgICAgJiYgQ1BVX0ZFQVRVUkVfVVNBQkxF X1AgKGNwdV9mZWF0dXJlcywgQVZYNTEyVkwpKSkKLSAgIHJldHVybiAzOwotIHJldHVybiA0Owor ICB1bnNpZ25lZCBpbnQgaXNhX2xldmVsID0gZ2V0X2lzYV9sZXZlbCAoY3B1X2ZlYXR1cmVzKTsK KworICBpZiAoIShpc2FfbGV2ZWwgJiBHTlVfUFJPUEVSVFlfWDg2X0lTQV8xX1YyKSkKKyAgICBy ZXR1cm4gMTsKKyAgaWYgKCEoaXNhX2xldmVsICYgR05VX1BST1BFUlRZX1g4Nl9JU0FfMV9WMykp CisgICAgcmV0dXJuIDI7CisgIGlmICghKGlzYV9sZXZlbCAmIEdOVV9QUk9QRVJUWV9YODZfSVNB XzFfVjQpKQorICAgIHJldHVybiAzOworICByZXR1cm4gNDsKIH0KIAogc3RhdGljIGludAotLSAK Mi4yOS4yCgo= --000000000000b4614805b855b583--