From mboxrd@z Thu Jan 1 00:00:00 1970 From: Kevin Brodsky Subject: Re: [PATCH v2 19/19] arm64: mte: Add Memory Tagging Extension documentation Date: Mon, 9 Mar 2020 14:30:12 +0000 Message-ID: References: <20200226180526.3272848-1-catalin.marinas@arm.com> <20200226180526.3272848-20-catalin.marinas@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Return-path: Received: from foss.arm.com ([217.140.110.172]:53252 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726617AbgCIOaQ (ORCPT ); Mon, 9 Mar 2020 10:30:16 -0400 In-Reply-To: <20200226180526.3272848-20-catalin.marinas@arm.com> Content-Language: en-GB Sender: linux-arch-owner@vger.kernel.org List-ID: To: Catalin Marinas , linux-arm-kernel@lists.infradead.org Cc: Will Deacon , Vincenzo Frascino , Szabolcs Nagy , Richard Earnshaw , Andrey Konovalov , Peter Collingbourne , linux-mm@kvack.org, linux-arch@vger.kernel.org On 26/02/2020 18:05, Catalin Marinas wrote: > From: Vincenzo Frascino > > Memory Tagging Extension (part of the ARMv8.5 Extensions) provides > a mechanism to detect the sources of memory related errors which > may be vulnerable to exploitation, including bounds violations, > use-after-free, use-after-return, use-out-of-scope and use before > initialization errors. > > Add Memory Tagging Extension documentation for the arm64 linux > kernel support. > > Signed-off-by: Vincenzo Frascino > Co-developed-by: Catalin Marinas > Signed-off-by: Catalin Marinas > --- > > Notes: > v2: > - Documented the uaccess kernel tag checking mode. > - Removed the BTI definitions from cpu-feature-registers.rst. > - Removed the paragraph stating that MTE depends on the tagged address > ABI (while the Kconfig entry does, there is no requirement for the > user to enable both). > - Changed the GCR_EL1.Exclude handling description following the change > in the prctl() interface (include vs exclude mask). > - Updated the example code. > > Documentation/arm64/cpu-feature-registers.rst | 2 + > Documentation/arm64/elf_hwcaps.rst | 5 + > Documentation/arm64/index.rst | 1 + > .../arm64/memory-tagging-extension.rst | 228 ++++++++++++++++++ > 4 files changed, 236 insertions(+) > create mode 100644 Documentation/arm64/memory-tagging-extension.rst > > diff --git a/Documentation/arm64/cpu-feature-registers.rst b/Documentation/arm64/cpu-feature-registers.rst > index 41937a8091aa..b5679fa85ad9 100644 > --- a/Documentation/arm64/cpu-feature-registers.rst > +++ b/Documentation/arm64/cpu-feature-registers.rst > @@ -174,6 +174,8 @@ infrastructure: > +------------------------------+---------+---------+ > | Name | bits | visible | > +------------------------------+---------+---------+ > + | MTE | [11-8] | y | > + +------------------------------+---------+---------+ > | SSBS | [7-4] | y | > +------------------------------+---------+---------+ > > diff --git a/Documentation/arm64/elf_hwcaps.rst b/Documentation/arm64/elf_hwcaps.rst > index 7dfb97dfe416..ca7f90e99e3a 100644 > --- a/Documentation/arm64/elf_hwcaps.rst > +++ b/Documentation/arm64/elf_hwcaps.rst > @@ -236,6 +236,11 @@ HWCAP2_RNG > > Functionality implied by ID_AA64ISAR0_EL1.RNDR == 0b0001. > > +HWCAP2_MTE > + > + Functionality implied by ID_AA64PFR1_EL1.MTE == 0b0010, as described > + by Documentation/arm64/memory-tagging-extension.rst. > + > 4. Unused AT_HWCAP bits > ----------------------- > > diff --git a/Documentation/arm64/index.rst b/Documentation/arm64/index.rst > index 5c0c69dc58aa..82970c6d384f 100644 > --- a/Documentation/arm64/index.rst > +++ b/Documentation/arm64/index.rst > @@ -13,6 +13,7 @@ ARM64 Architecture > hugetlbpage > legacy_instructions > memory > + memory-tagging-extension > pointer-authentication > silicon-errata > sve > diff --git a/Documentation/arm64/memory-tagging-extension.rst b/Documentation/arm64/memory-tagging-extension.rst > new file mode 100644 > index 000000000000..00ac0e22d5e9 > --- /dev/null > +++ b/Documentation/arm64/memory-tagging-extension.rst > @@ -0,0 +1,228 @@ > +=============================================== > +Memory Tagging Extension (MTE) in AArch64 Linux > +=============================================== > + > +Authors: Vincenzo Frascino > + Catalin Marinas > + > +Date: 2020-02-25 > + > +This document describes the provision of the Memory Tagging Extension > +functionality in AArch64 Linux. > + > +Introduction > +============ > + > +ARMv8.5 based processors introduce the Memory Tagging Extension (MTE) > +feature. MTE is built on top of the ARMv8.0 virtual address tagging TBI > +(Top Byte Ignore) feature and allows software to access a 4-bit > +allocation tag for each 16-byte granule in the physical address space. > +Such memory range must be mapped with the Normal-Tagged memory > +attribute. A logical tag is derived from bits 59-56 of the virtual > +address used for the memory access. A CPU with MTE enabled will compare > +the logical tag against the allocation tag and potentially raise an > +exception on mismatch, subject to system registers configuration. > + > +Userspace Support > +================= > + > +When ``CONFIG_ARM64_MTE`` is selected and Memory Tagging Extension is > +supported by the hardware, the kernel advertises the feature to > +userspace via ``HWCAP2_MTE``. > + > +PROT_MTE > +-------- > + > +To access the allocation tags, a user process must enable the Tagged > +memory attribute on an address range using a new ``prot`` flag for > +``mmap()`` and ``mprotect()``: > + > +``PROT_MTE`` - Pages allow access to the MTE allocation tags. > + > +The allocation tag is set to 0 when such pages are first mapped in the > +user address space and preserved on copy-on-write. ``MAP_SHARED`` is > +supported and the allocation tags can be shared between processes. > + > +**Note**: ``PROT_MTE`` is only supported on ``MAP_ANONYMOUS`` and > +RAM-based file mappings (``tmpfs``, ``memfd``). Passing it to other > +types of mapping will result in ``-EINVAL`` returned by these system > +calls. > + > +**Note**: The ``PROT_MTE`` flag (and corresponding memory type) cannot > +be cleared by ``mprotect()``. > + > +Tag Check Faults > +---------------- > + > +When ``PROT_MTE`` is enabled on an address range and a mismatch between > +the logical and allocation tags occurs on access, there are three > +configurable behaviours: > + > +- *Ignore* - This is the default mode. The CPU (and kernel) ignores the > + tag check fault. > + > +- *Synchronous* - The kernel raises a ``SIGSEGV`` synchronously, with > + ``.si_code = SEGV_MTESERR`` and ``.si_addr = ``. The > + memory access is not performed. > + > +- *Asynchronous* - The kernel raises a ``SIGSEGV``, in the current > + thread, asynchronously following one or multiple tag check faults, > + with ``.si_code = SEGV_MTEAERR`` and ``.si_addr = 0``. > + > +**Note**: There are no *match-all* logical tags available for user > +applications. > + > +The user can select the above modes, per thread, using the > +``prctl(PR_SET_TAGGED_ADDR_CTRL, flags, 0, 0, 0)`` system call where > +``flags`` contain one of the following values in the ``PR_MTE_TCF_MASK`` > +bit-field: > + > +- ``PR_MTE_TCF_NONE`` - *Ignore* tag check faults > +- ``PR_MTE_TCF_SYNC`` - *Synchronous* tag check fault mode > +- ``PR_MTE_TCF_ASYNC`` - *Asynchronous* tag check fault mode > + > +Tag checking can also be disabled for a user thread by setting the > +``PSTATE.TCO`` bit with ``MSR TCO, #1``. > + > +**Note**: Signal handlers are always invoked with ``PSTATE.TCO = 0``, > +irrespective of the interrupted context. > + > +**Note**: Kernel accesses to user memory (e.g. ``read()`` system call) > +follow the same tag checking mode as set by the current thread. > + > +Excluding Tags in the ``IRG``, ``ADDG`` and ``SUBG`` instructions > +----------------------------------------------------------------- > + > +The architecture allows excluding certain tags to be randomly generated > +via the ``GCR_EL1.Exclude`` register bit-field. By default, Linux > +excludes all tags other than 0. A user thread can enable specific tags > +in the randomly generated set using the ``prctl(PR_SET_TAGGED_ADDR_CTRL, > +flags, 0, 0, 0)`` system call where ``flags`` contains the tags bitmap > +in the ``PR_MTE_TAG_MASK`` bit-field. > + > +**Note**: The hardware uses an exclude mask but the ``prctl()`` > +interface provides an include mask. Maybe it's worth mentioning that a tag mask of 0x0, or equivalently an exclusion mask of  0xFFFF, results in the generated tag being always 0. This is not very clear even in the Arm ARM, where this is only specified in the pseudocode (I shall report this internally). Kevin > + > +Example of correct usage > +======================== > + > +*MTE Example code* > + > +.. code-block:: c > + > + /* > + * To be compiled with -march=armv8.5-a+memtag > + */ > + #include > + #include > + #include > + #include > + #include > + #include > + #include > + > + /* > + * From arch/arm64/include/uapi/asm/hwcap.h > + */ > + #define HWCAP2_MTE (1 << 18) > + > + /* > + * From arch/arm64/include/uapi/asm/mman.h > + */ > + #define PROT_MTE 0x20 > + > + /* > + * From include/uapi/linux/prctl.h > + */ > + #define PR_SET_TAGGED_ADDR_CTRL 55 > + #define PR_GET_TAGGED_ADDR_CTRL 56 > + # define PR_TAGGED_ADDR_ENABLE (1UL << 0) > + # define PR_MTE_TCF_SHIFT 1 > + # define PR_MTE_TCF_NONE (0UL << PR_MTE_TCF_SHIFT) > + # define PR_MTE_TCF_SYNC (1UL << PR_MTE_TCF_SHIFT) > + # define PR_MTE_TCF_ASYNC (2UL << PR_MTE_TCF_SHIFT) > + # define PR_MTE_TCF_MASK (3UL << PR_MTE_TCF_SHIFT) > + # define PR_MTE_TAG_SHIFT 3 > + # define PR_MTE_TAG_MASK (0xffffUL << PR_MTE_TAG_SHIFT) > + > + /* > + * Insert a random logical tag into the given pointer. > + */ > + #define insert_random_tag(ptr) ({ \ > + __u64 __val; \ > + asm("irg %0, %1" : "=r" (__val) : "r" (ptr)); \ > + __val; \ > + }) > + > + /* > + * Set the allocation tag on the destination address. > + */ > + #define set_tag(tagged_addr) do { \ > + asm volatile("stg %0, [%0]" : : "r" (tagged_addr) : "memory"); \ > + } while (0) > + > + int main() > + { > + unsigned long *a; > + unsigned long page_sz = getpagesize(); > + unsigned long hwcap2 = getauxval(AT_HWCAP2); > + > + /* check if MTE is present */ > + if (!(hwcap2 & HWCAP2_MTE)) > + return -1; > + > + /* > + * Enable the tagged address ABI, synchronous MTE tag check faults and > + * allow all non-zero tags in the randomly generated set. > + */ > + if (prctl(PR_SET_TAGGED_ADDR_CTRL, > + PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC | (0xfffe << PR_MTE_TAG_SHIFT), > + 0, 0, 0)) { > + perror("prctl() failed"); > + return -1; > + } > + > + a = mmap(0, page_sz, PROT_READ | PROT_WRITE, > + MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); > + if (a == MAP_FAILED) { > + perror("mmap() failed"); > + return -1; > + } > + > + /* > + * Enable MTE on the above anonymous mmap. The flag could be passed > + * directly to mmap() and skip this step. > + */ > + if (mprotect(a, page_sz, PROT_READ | PROT_WRITE | PROT_MTE)) { > + perror("mprotect() failed"); > + return -1; > + } > + > + /* access with the default tag (0) */ > + a[0] = 1; > + a[1] = 2; > + > + printf("a[0] = %lu a[1] = %lu\n", a[0], a[1]); > + > + /* set the logical and allocation tags */ > + a = (unsigned long *)insert_random_tag(a); > + set_tag(a); > + > + printf("%p\n", a); > + > + /* non-zero tag access */ > + a[0] = 3; > + printf("a[0] = %lu a[1] = %lu\n", a[0], a[1]); > + > + /* > + * If MTE is enabled correctly the next instruction will generate an > + * exception. > + */ > + printf("Expecting SIGSEGV...\n"); > + a[2] = 0xdead; > + > + /* this should not be printed in the PR_MTE_TCF_SYNC mode */ > + printf("...done\n"); > + > + return 0; > + } From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id F3167C10F29 for ; Mon, 9 Mar 2020 14:30:20 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C3E8121D56 for ; Mon, 9 Mar 2020 14:30:20 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="hhYS3YES" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C3E8121D56 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender:Content-Type: Content-Transfer-Encoding:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:From: References:To:Subject:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=YGtTqJBq6smtpAa3LyDGhqsCO01w74j9h2Hed7DoS2I=; b=hhYS3YESPwMALynyEY6ZjP5Y8 PTemzmPLzkT4ZyubqnJkZF0N4TFyoqlE6/m1k0++jqFQ9tJz/3mnMcEMDvq9eHZY372OZdv8QePs8 GBwJYHc/vDmuMswcWPXLPURii640gmWInFoCRVgYF4K/nk+E/7LlxEj0FXpmb8QChL1vG5C5f9+/r nWkal9BXJQrU/nxTEIDoZWxDCdwlaFe3qmhSXtvqkCnNU0ZwF79uXQOBfvPbNXen6iqX1DPA4VIX/ Bo/ZLGgwGOzXQ5LNQa74PRqv7odnEPA0Fro+VuVUSOAVGlGQZwz/AFsIJTKYD6qal6qKtfKE58IaR Nvxxus5Iw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jBJQC-0001iw-Aj; Mon, 09 Mar 2020 14:30:20 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jBJQ8-0001iY-3K for linux-arm-kernel@lists.infradead.org; Mon, 09 Mar 2020 14:30:18 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 93AAF30E; Mon, 9 Mar 2020 07:30:15 -0700 (PDT) Received: from [10.1.195.53] (e123572-lin.cambridge.arm.com [10.1.195.53]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 0D3AD3F67D; Mon, 9 Mar 2020 07:30:13 -0700 (PDT) Subject: Re: [PATCH v2 19/19] arm64: mte: Add Memory Tagging Extension documentation To: Catalin Marinas , linux-arm-kernel@lists.infradead.org References: <20200226180526.3272848-1-catalin.marinas@arm.com> <20200226180526.3272848-20-catalin.marinas@arm.com> From: Kevin Brodsky Message-ID: Date: Mon, 9 Mar 2020 14:30:12 +0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.9.1 MIME-Version: 1.0 In-Reply-To: <20200226180526.3272848-20-catalin.marinas@arm.com> Content-Language: en-GB X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200309_073016_233166_B3F53101 X-CRM114-Status: GOOD ( 36.44 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-arch@vger.kernel.org, Richard Earnshaw , Szabolcs Nagy , Peter Collingbourne , linux-mm@kvack.org, Andrey Konovalov , Vincenzo Frascino , Will Deacon Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gMjYvMDIvMjAyMCAxODowNSwgQ2F0YWxpbiBNYXJpbmFzIHdyb3RlOgo+IEZyb206IFZpbmNl bnpvIEZyYXNjaW5vIDx2aW5jZW56by5mcmFzY2lub0Bhcm0uY29tPgo+Cj4gTWVtb3J5IFRhZ2dp bmcgRXh0ZW5zaW9uIChwYXJ0IG9mIHRoZSBBUk12OC41IEV4dGVuc2lvbnMpIHByb3ZpZGVzCj4g YSBtZWNoYW5pc20gdG8gZGV0ZWN0IHRoZSBzb3VyY2VzIG9mIG1lbW9yeSByZWxhdGVkIGVycm9y cyB3aGljaAo+IG1heSBiZSB2dWxuZXJhYmxlIHRvIGV4cGxvaXRhdGlvbiwgaW5jbHVkaW5nIGJv dW5kcyB2aW9sYXRpb25zLAo+IHVzZS1hZnRlci1mcmVlLCB1c2UtYWZ0ZXItcmV0dXJuLCB1c2Ut b3V0LW9mLXNjb3BlIGFuZCB1c2UgYmVmb3JlCj4gaW5pdGlhbGl6YXRpb24gZXJyb3JzLgo+Cj4g QWRkIE1lbW9yeSBUYWdnaW5nIEV4dGVuc2lvbiBkb2N1bWVudGF0aW9uIGZvciB0aGUgYXJtNjQg bGludXgKPiBrZXJuZWwgc3VwcG9ydC4KPgo+IFNpZ25lZC1vZmYtYnk6IFZpbmNlbnpvIEZyYXNj aW5vIDx2aW5jZW56by5mcmFzY2lub0Bhcm0uY29tPgo+IENvLWRldmVsb3BlZC1ieTogQ2F0YWxp biBNYXJpbmFzIDxjYXRhbGluLm1hcmluYXNAYXJtLmNvbT4KPiBTaWduZWQtb2ZmLWJ5OiBDYXRh bGluIE1hcmluYXMgPGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+IC0tLQo+Cj4gTm90ZXM6Cj4g ICAgICB2MjoKPiAgICAgIC0gRG9jdW1lbnRlZCB0aGUgdWFjY2VzcyBrZXJuZWwgdGFnIGNoZWNr aW5nIG1vZGUuCj4gICAgICAtIFJlbW92ZWQgdGhlIEJUSSBkZWZpbml0aW9ucyBmcm9tIGNwdS1m ZWF0dXJlLXJlZ2lzdGVycy5yc3QuCj4gICAgICAtIFJlbW92ZWQgdGhlIHBhcmFncmFwaCBzdGF0 aW5nIHRoYXQgTVRFIGRlcGVuZHMgb24gdGhlIHRhZ2dlZCBhZGRyZXNzCj4gICAgICAgIEFCSSAo d2hpbGUgdGhlIEtjb25maWcgZW50cnkgZG9lcywgdGhlcmUgaXMgbm8gcmVxdWlyZW1lbnQgZm9y IHRoZQo+ICAgICAgICB1c2VyIHRvIGVuYWJsZSBib3RoKS4KPiAgICAgIC0gQ2hhbmdlZCB0aGUg R0NSX0VMMS5FeGNsdWRlIGhhbmRsaW5nIGRlc2NyaXB0aW9uIGZvbGxvd2luZyB0aGUgY2hhbmdl Cj4gICAgICAgIGluIHRoZSBwcmN0bCgpIGludGVyZmFjZSAoaW5jbHVkZSB2cyBleGNsdWRlIG1h c2spLgo+ICAgICAgLSBVcGRhdGVkIHRoZSBleGFtcGxlIGNvZGUuCj4KPiAgIERvY3VtZW50YXRp b24vYXJtNjQvY3B1LWZlYXR1cmUtcmVnaXN0ZXJzLnJzdCB8ICAgMiArCj4gICBEb2N1bWVudGF0 aW9uL2FybTY0L2VsZl9od2NhcHMucnN0ICAgICAgICAgICAgfCAgIDUgKwo+ICAgRG9jdW1lbnRh dGlvbi9hcm02NC9pbmRleC5yc3QgICAgICAgICAgICAgICAgIHwgICAxICsKPiAgIC4uLi9hcm02 NC9tZW1vcnktdGFnZ2luZy1leHRlbnNpb24ucnN0ICAgICAgICB8IDIyOCArKysrKysrKysrKysr KysrKysKPiAgIDQgZmlsZXMgY2hhbmdlZCwgMjM2IGluc2VydGlvbnMoKykKPiAgIGNyZWF0ZSBt b2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2FybTY0L21lbW9yeS10YWdnaW5nLWV4dGVuc2lvbi5y c3QKPgo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2FybTY0L2NwdS1mZWF0dXJlLXJlZ2lz dGVycy5yc3QgYi9Eb2N1bWVudGF0aW9uL2FybTY0L2NwdS1mZWF0dXJlLXJlZ2lzdGVycy5yc3QK PiBpbmRleCA0MTkzN2E4MDkxYWEuLmI1Njc5ZmE4NWFkOSAxMDA2NDQKPiAtLS0gYS9Eb2N1bWVu dGF0aW9uL2FybTY0L2NwdS1mZWF0dXJlLXJlZ2lzdGVycy5yc3QKPiArKysgYi9Eb2N1bWVudGF0 aW9uL2FybTY0L2NwdS1mZWF0dXJlLXJlZ2lzdGVycy5yc3QKPiBAQCAtMTc0LDYgKzE3NCw4IEBA IGluZnJhc3RydWN0dXJlOgo+ICAgICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t Ky0tLS0tLS0tLSstLS0tLS0tLS0rCj4gICAgICAgIHwgTmFtZSAgICAgICAgICAgICAgICAgICAg ICAgICB8ICBiaXRzICAgfCB2aXNpYmxlIHwKPiAgICAgICAgKy0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKwo+ICsgICAgIHwgTVRFICAgICAgICAgICAg ICAgICAgICAgICAgICB8IFsxMS04XSAgfCAgICB5ICAgIHwKPiArICAgICArLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rCj4gICAgICAgIHwgU1NCUyAg ICAgICAgICAgICAgICAgICAgICAgICB8IFs3LTRdICAgfCAgICB5ICAgIHwKPiAgICAgICAgKy0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSstLS0tLS0tLS0rLS0tLS0tLS0tKwo+ICAgCj4g ZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vYXJtNjQvZWxmX2h3Y2Fwcy5yc3QgYi9Eb2N1bWVu dGF0aW9uL2FybTY0L2VsZl9od2NhcHMucnN0Cj4gaW5kZXggN2RmYjk3ZGZlNDE2Li5jYTdmOTBl OTllM2EgMTAwNjQ0Cj4gLS0tIGEvRG9jdW1lbnRhdGlvbi9hcm02NC9lbGZfaHdjYXBzLnJzdAo+ ICsrKyBiL0RvY3VtZW50YXRpb24vYXJtNjQvZWxmX2h3Y2Fwcy5yc3QKPiBAQCAtMjM2LDYgKzIz NiwxMSBAQCBIV0NBUDJfUk5HCj4gICAKPiAgICAgICBGdW5jdGlvbmFsaXR5IGltcGxpZWQgYnkg SURfQUE2NElTQVIwX0VMMS5STkRSID09IDBiMDAwMS4KPiAgIAo+ICtIV0NBUDJfTVRFCj4gKwo+ ICsgICAgRnVuY3Rpb25hbGl0eSBpbXBsaWVkIGJ5IElEX0FBNjRQRlIxX0VMMS5NVEUgPT0gMGIw MDEwLCBhcyBkZXNjcmliZWQKPiArICAgIGJ5IERvY3VtZW50YXRpb24vYXJtNjQvbWVtb3J5LXRh Z2dpbmctZXh0ZW5zaW9uLnJzdC4KPiArCj4gICA0LiBVbnVzZWQgQVRfSFdDQVAgYml0cwo+ICAg LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiAgIAo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9u L2FybTY0L2luZGV4LnJzdCBiL0RvY3VtZW50YXRpb24vYXJtNjQvaW5kZXgucnN0Cj4gaW5kZXgg NWMwYzY5ZGM1OGFhLi44Mjk3MGM2ZDM4NGYgMTAwNjQ0Cj4gLS0tIGEvRG9jdW1lbnRhdGlvbi9h cm02NC9pbmRleC5yc3QKPiArKysgYi9Eb2N1bWVudGF0aW9uL2FybTY0L2luZGV4LnJzdAo+IEBA IC0xMyw2ICsxMyw3IEBAIEFSTTY0IEFyY2hpdGVjdHVyZQo+ICAgICAgIGh1Z2V0bGJwYWdlCj4g ICAgICAgbGVnYWN5X2luc3RydWN0aW9ucwo+ICAgICAgIG1lbW9yeQo+ICsgICAgbWVtb3J5LXRh Z2dpbmctZXh0ZW5zaW9uCj4gICAgICAgcG9pbnRlci1hdXRoZW50aWNhdGlvbgo+ICAgICAgIHNp bGljb24tZXJyYXRhCj4gICAgICAgc3ZlCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vYXJt NjQvbWVtb3J5LXRhZ2dpbmctZXh0ZW5zaW9uLnJzdCBiL0RvY3VtZW50YXRpb24vYXJtNjQvbWVt b3J5LXRhZ2dpbmctZXh0ZW5zaW9uLnJzdAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXgg MDAwMDAwMDAwMDAwLi4wMGFjMGUyMmQ1ZTkKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvRG9jdW1l bnRhdGlvbi9hcm02NC9tZW1vcnktdGFnZ2luZy1leHRlbnNpb24ucnN0Cj4gQEAgLTAsMCArMSwy MjggQEAKPiArPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K PiArTWVtb3J5IFRhZ2dpbmcgRXh0ZW5zaW9uIChNVEUpIGluIEFBcmNoNjQgTGludXgKPiArPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KPiArCj4gK0F1dGhv cnM6IFZpbmNlbnpvIEZyYXNjaW5vIDx2aW5jZW56by5mcmFzY2lub0Bhcm0uY29tPgo+ICsgICAg ICAgICBDYXRhbGluIE1hcmluYXMgPGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+ICsKPiArRGF0 ZTogMjAyMC0wMi0yNQo+ICsKPiArVGhpcyBkb2N1bWVudCBkZXNjcmliZXMgdGhlIHByb3Zpc2lv biBvZiB0aGUgTWVtb3J5IFRhZ2dpbmcgRXh0ZW5zaW9uCj4gK2Z1bmN0aW9uYWxpdHkgaW4gQUFy Y2g2NCBMaW51eC4KPiArCj4gK0ludHJvZHVjdGlvbgo+ICs9PT09PT09PT09PT0KPiArCj4gK0FS TXY4LjUgYmFzZWQgcHJvY2Vzc29ycyBpbnRyb2R1Y2UgdGhlIE1lbW9yeSBUYWdnaW5nIEV4dGVu c2lvbiAoTVRFKQo+ICtmZWF0dXJlLiBNVEUgaXMgYnVpbHQgb24gdG9wIG9mIHRoZSBBUk12OC4w IHZpcnR1YWwgYWRkcmVzcyB0YWdnaW5nIFRCSQo+ICsoVG9wIEJ5dGUgSWdub3JlKSBmZWF0dXJl IGFuZCBhbGxvd3Mgc29mdHdhcmUgdG8gYWNjZXNzIGEgNC1iaXQKPiArYWxsb2NhdGlvbiB0YWcg Zm9yIGVhY2ggMTYtYnl0ZSBncmFudWxlIGluIHRoZSBwaHlzaWNhbCBhZGRyZXNzIHNwYWNlLgo+ ICtTdWNoIG1lbW9yeSByYW5nZSBtdXN0IGJlIG1hcHBlZCB3aXRoIHRoZSBOb3JtYWwtVGFnZ2Vk IG1lbW9yeQo+ICthdHRyaWJ1dGUuIEEgbG9naWNhbCB0YWcgaXMgZGVyaXZlZCBmcm9tIGJpdHMg NTktNTYgb2YgdGhlIHZpcnR1YWwKPiArYWRkcmVzcyB1c2VkIGZvciB0aGUgbWVtb3J5IGFjY2Vz cy4gQSBDUFUgd2l0aCBNVEUgZW5hYmxlZCB3aWxsIGNvbXBhcmUKPiArdGhlIGxvZ2ljYWwgdGFn IGFnYWluc3QgdGhlIGFsbG9jYXRpb24gdGFnIGFuZCBwb3RlbnRpYWxseSByYWlzZSBhbgo+ICtl eGNlcHRpb24gb24gbWlzbWF0Y2gsIHN1YmplY3QgdG8gc3lzdGVtIHJlZ2lzdGVycyBjb25maWd1 cmF0aW9uLgo+ICsKPiArVXNlcnNwYWNlIFN1cHBvcnQKPiArPT09PT09PT09PT09PT09PT0KPiAr Cj4gK1doZW4gYGBDT05GSUdfQVJNNjRfTVRFYGAgaXMgc2VsZWN0ZWQgYW5kIE1lbW9yeSBUYWdn aW5nIEV4dGVuc2lvbiBpcwo+ICtzdXBwb3J0ZWQgYnkgdGhlIGhhcmR3YXJlLCB0aGUga2VybmVs IGFkdmVydGlzZXMgdGhlIGZlYXR1cmUgdG8KPiArdXNlcnNwYWNlIHZpYSBgYEhXQ0FQMl9NVEVg YC4KPiArCj4gK1BST1RfTVRFCj4gKy0tLS0tLS0tCj4gKwo+ICtUbyBhY2Nlc3MgdGhlIGFsbG9j YXRpb24gdGFncywgYSB1c2VyIHByb2Nlc3MgbXVzdCBlbmFibGUgdGhlIFRhZ2dlZAo+ICttZW1v cnkgYXR0cmlidXRlIG9uIGFuIGFkZHJlc3MgcmFuZ2UgdXNpbmcgYSBuZXcgYGBwcm90YGAgZmxh ZyBmb3IKPiArYGBtbWFwKClgYCBhbmQgYGBtcHJvdGVjdCgpYGA6Cj4gKwo+ICtgYFBST1RfTVRF YGAgLSBQYWdlcyBhbGxvdyBhY2Nlc3MgdG8gdGhlIE1URSBhbGxvY2F0aW9uIHRhZ3MuCj4gKwo+ ICtUaGUgYWxsb2NhdGlvbiB0YWcgaXMgc2V0IHRvIDAgd2hlbiBzdWNoIHBhZ2VzIGFyZSBmaXJz dCBtYXBwZWQgaW4gdGhlCj4gK3VzZXIgYWRkcmVzcyBzcGFjZSBhbmQgcHJlc2VydmVkIG9uIGNv cHktb24td3JpdGUuIGBgTUFQX1NIQVJFRGBgIGlzCj4gK3N1cHBvcnRlZCBhbmQgdGhlIGFsbG9j YXRpb24gdGFncyBjYW4gYmUgc2hhcmVkIGJldHdlZW4gcHJvY2Vzc2VzLgo+ICsKPiArKipOb3Rl Kio6IGBgUFJPVF9NVEVgYCBpcyBvbmx5IHN1cHBvcnRlZCBvbiBgYE1BUF9BTk9OWU1PVVNgYCBh bmQKPiArUkFNLWJhc2VkIGZpbGUgbWFwcGluZ3MgKGBgdG1wZnNgYCwgYGBtZW1mZGBgKS4gUGFz c2luZyBpdCB0byBvdGhlcgo+ICt0eXBlcyBvZiBtYXBwaW5nIHdpbGwgcmVzdWx0IGluIGBgLUVJ TlZBTGBgIHJldHVybmVkIGJ5IHRoZXNlIHN5c3RlbQo+ICtjYWxscy4KPiArCj4gKyoqTm90ZSoq OiBUaGUgYGBQUk9UX01URWBgIGZsYWcgKGFuZCBjb3JyZXNwb25kaW5nIG1lbW9yeSB0eXBlKSBj YW5ub3QKPiArYmUgY2xlYXJlZCBieSBgYG1wcm90ZWN0KClgYC4KPiArCj4gK1RhZyBDaGVjayBG YXVsdHMKPiArLS0tLS0tLS0tLS0tLS0tLQo+ICsKPiArV2hlbiBgYFBST1RfTVRFYGAgaXMgZW5h YmxlZCBvbiBhbiBhZGRyZXNzIHJhbmdlIGFuZCBhIG1pc21hdGNoIGJldHdlZW4KPiArdGhlIGxv Z2ljYWwgYW5kIGFsbG9jYXRpb24gdGFncyBvY2N1cnMgb24gYWNjZXNzLCB0aGVyZSBhcmUgdGhy ZWUKPiArY29uZmlndXJhYmxlIGJlaGF2aW91cnM6Cj4gKwo+ICstICpJZ25vcmUqIC0gVGhpcyBp cyB0aGUgZGVmYXVsdCBtb2RlLiBUaGUgQ1BVIChhbmQga2VybmVsKSBpZ25vcmVzIHRoZQo+ICsg IHRhZyBjaGVjayBmYXVsdC4KPiArCj4gKy0gKlN5bmNocm9ub3VzKiAtIFRoZSBrZXJuZWwgcmFp c2VzIGEgYGBTSUdTRUdWYGAgc3luY2hyb25vdXNseSwgd2l0aAo+ICsgIGBgLnNpX2NvZGUgPSBT RUdWX01URVNFUlJgYCBhbmQgYGAuc2lfYWRkciA9IDxmYXVsdC1hZGRyZXNzPmBgLiBUaGUKPiAr ICBtZW1vcnkgYWNjZXNzIGlzIG5vdCBwZXJmb3JtZWQuCj4gKwo+ICstICpBc3luY2hyb25vdXMq IC0gVGhlIGtlcm5lbCByYWlzZXMgYSBgYFNJR1NFR1ZgYCwgaW4gdGhlIGN1cnJlbnQKPiArICB0 aHJlYWQsIGFzeW5jaHJvbm91c2x5IGZvbGxvd2luZyBvbmUgb3IgbXVsdGlwbGUgdGFnIGNoZWNr IGZhdWx0cywKPiArICB3aXRoIGBgLnNpX2NvZGUgPSBTRUdWX01URUFFUlJgYCBhbmQgYGAuc2lf YWRkciA9IDBgYC4KPiArCj4gKyoqTm90ZSoqOiBUaGVyZSBhcmUgbm8gKm1hdGNoLWFsbCogbG9n aWNhbCB0YWdzIGF2YWlsYWJsZSBmb3IgdXNlcgo+ICthcHBsaWNhdGlvbnMuCj4gKwo+ICtUaGUg dXNlciBjYW4gc2VsZWN0IHRoZSBhYm92ZSBtb2RlcywgcGVyIHRocmVhZCwgdXNpbmcgdGhlCj4g K2BgcHJjdGwoUFJfU0VUX1RBR0dFRF9BRERSX0NUUkwsIGZsYWdzLCAwLCAwLCAwKWBgIHN5c3Rl bSBjYWxsIHdoZXJlCj4gK2BgZmxhZ3NgYCBjb250YWluIG9uZSBvZiB0aGUgZm9sbG93aW5nIHZh bHVlcyBpbiB0aGUgYGBQUl9NVEVfVENGX01BU0tgYAo+ICtiaXQtZmllbGQ6Cj4gKwo+ICstIGBg UFJfTVRFX1RDRl9OT05FYGAgIC0gKklnbm9yZSogdGFnIGNoZWNrIGZhdWx0cwo+ICstIGBgUFJf TVRFX1RDRl9TWU5DYGAgIC0gKlN5bmNocm9ub3VzKiB0YWcgY2hlY2sgZmF1bHQgbW9kZQo+ICst IGBgUFJfTVRFX1RDRl9BU1lOQ2BgIC0gKkFzeW5jaHJvbm91cyogdGFnIGNoZWNrIGZhdWx0IG1v ZGUKPiArCj4gK1RhZyBjaGVja2luZyBjYW4gYWxzbyBiZSBkaXNhYmxlZCBmb3IgYSB1c2VyIHRo cmVhZCBieSBzZXR0aW5nIHRoZQo+ICtgYFBTVEFURS5UQ09gYCBiaXQgd2l0aCBgYE1TUiBUQ08s ICMxYGAuCj4gKwo+ICsqKk5vdGUqKjogU2lnbmFsIGhhbmRsZXJzIGFyZSBhbHdheXMgaW52b2tl ZCB3aXRoIGBgUFNUQVRFLlRDTyA9IDBgYCwKPiAraXJyZXNwZWN0aXZlIG9mIHRoZSBpbnRlcnJ1 cHRlZCBjb250ZXh0Lgo+ICsKPiArKipOb3RlKio6IEtlcm5lbCBhY2Nlc3NlcyB0byB1c2VyIG1l bW9yeSAoZS5nLiBgYHJlYWQoKWBgIHN5c3RlbSBjYWxsKQo+ICtmb2xsb3cgdGhlIHNhbWUgdGFn IGNoZWNraW5nIG1vZGUgYXMgc2V0IGJ5IHRoZSBjdXJyZW50IHRocmVhZC4KPiArCj4gK0V4Y2x1 ZGluZyBUYWdzIGluIHRoZSBgYElSR2BgLCBgYEFEREdgYCBhbmQgYGBTVUJHYGAgaW5zdHJ1Y3Rp b25zCj4gKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCj4gKwo+ICtUaGUgYXJjaGl0ZWN0dXJlIGFsbG93cyBleGNsdWRpbmcg Y2VydGFpbiB0YWdzIHRvIGJlIHJhbmRvbWx5IGdlbmVyYXRlZAo+ICt2aWEgdGhlIGBgR0NSX0VM MS5FeGNsdWRlYGAgcmVnaXN0ZXIgYml0LWZpZWxkLiBCeSBkZWZhdWx0LCBMaW51eAo+ICtleGNs dWRlcyBhbGwgdGFncyBvdGhlciB0aGFuIDAuIEEgdXNlciB0aHJlYWQgY2FuIGVuYWJsZSBzcGVj aWZpYyB0YWdzCj4gK2luIHRoZSByYW5kb21seSBnZW5lcmF0ZWQgc2V0IHVzaW5nIHRoZSBgYHBy Y3RsKFBSX1NFVF9UQUdHRURfQUREUl9DVFJMLAo+ICtmbGFncywgMCwgMCwgMClgYCBzeXN0ZW0g Y2FsbCB3aGVyZSBgYGZsYWdzYGAgY29udGFpbnMgdGhlIHRhZ3MgYml0bWFwCj4gK2luIHRoZSBg YFBSX01URV9UQUdfTUFTS2BgIGJpdC1maWVsZC4KPiArCj4gKyoqTm90ZSoqOiBUaGUgaGFyZHdh cmUgdXNlcyBhbiBleGNsdWRlIG1hc2sgYnV0IHRoZSBgYHByY3RsKClgYAo+ICtpbnRlcmZhY2Ug cHJvdmlkZXMgYW4gaW5jbHVkZSBtYXNrLgoKTWF5YmUgaXQncyB3b3J0aCBtZW50aW9uaW5nIHRo YXQgYSB0YWcgbWFzayBvZiAweDAsIG9yIGVxdWl2YWxlbnRseSBhbiBleGNsdXNpb24gbWFzayAK b2bCoCAweEZGRkYsIHJlc3VsdHMgaW4gdGhlIGdlbmVyYXRlZCB0YWcgYmVpbmcgYWx3YXlzIDAu IFRoaXMgaXMgbm90IHZlcnkgY2xlYXIgZXZlbiAKaW4gdGhlIEFybSBBUk0sIHdoZXJlIHRoaXMg aXMgb25seSBzcGVjaWZpZWQgaW4gdGhlIHBzZXVkb2NvZGUgKEkgc2hhbGwgcmVwb3J0IHRoaXMg CmludGVybmFsbHkpLgoKS2V2aW4KCj4gKwo+ICtFeGFtcGxlIG9mIGNvcnJlY3QgdXNhZ2UKPiAr PT09PT09PT09PT09PT09PT09PT09PT09Cj4gKwo+ICsqTVRFIEV4YW1wbGUgY29kZSoKPiArCj4g Ky4uIGNvZGUtYmxvY2s6OiBjCj4gKwo+ICsgICAgLyoKPiArICAgICAqIFRvIGJlIGNvbXBpbGVk IHdpdGggLW1hcmNoPWFybXY4LjUtYSttZW10YWcKPiArICAgICAqLwo+ICsgICAgI2luY2x1ZGUg PGVycm5vLmg+Cj4gKyAgICAjaW5jbHVkZSA8c3RkaW8uaD4KPiArICAgICNpbmNsdWRlIDxzdGRs aWIuaD4KPiArICAgICNpbmNsdWRlIDx1bmlzdGQuaD4KPiArICAgICNpbmNsdWRlIDxzeXMvYXV4 di5oPgo+ICsgICAgI2luY2x1ZGUgPHN5cy9tbWFuLmg+Cj4gKyAgICAjaW5jbHVkZSA8c3lzL3By Y3RsLmg+Cj4gKwo+ICsgICAgLyoKPiArICAgICAqIEZyb20gYXJjaC9hcm02NC9pbmNsdWRlL3Vh cGkvYXNtL2h3Y2FwLmgKPiArICAgICAqLwo+ICsgICAgI2RlZmluZSBIV0NBUDJfTVRFICAgICAg ICAgICAgICAoMSA8PCAxOCkKPiArCj4gKyAgICAvKgo+ICsgICAgICogRnJvbSBhcmNoL2FybTY0 L2luY2x1ZGUvdWFwaS9hc20vbW1hbi5oCj4gKyAgICAgKi8KPiArICAgICNkZWZpbmUgUFJPVF9N VEUgICAgICAgICAgICAgICAgIDB4MjAKPiArCj4gKyAgICAvKgo+ICsgICAgICogRnJvbSBpbmNs dWRlL3VhcGkvbGludXgvcHJjdGwuaAo+ICsgICAgICovCj4gKyAgICAjZGVmaW5lIFBSX1NFVF9U QUdHRURfQUREUl9DVFJMIDU1Cj4gKyAgICAjZGVmaW5lIFBSX0dFVF9UQUdHRURfQUREUl9DVFJM IDU2Cj4gKyAgICAjIGRlZmluZSBQUl9UQUdHRURfQUREUl9FTkFCTEUgICgxVUwgPDwgMCkKPiAr ICAgICMgZGVmaW5lIFBSX01URV9UQ0ZfU0hJRlQgICAgICAgMQo+ICsgICAgIyBkZWZpbmUgUFJf TVRFX1RDRl9OT05FICAgICAgICAoMFVMIDw8IFBSX01URV9UQ0ZfU0hJRlQpCj4gKyAgICAjIGRl ZmluZSBQUl9NVEVfVENGX1NZTkMgICAgICAgICgxVUwgPDwgUFJfTVRFX1RDRl9TSElGVCkKPiAr ICAgICMgZGVmaW5lIFBSX01URV9UQ0ZfQVNZTkMgICAgICAgKDJVTCA8PCBQUl9NVEVfVENGX1NI SUZUKQo+ICsgICAgIyBkZWZpbmUgUFJfTVRFX1RDRl9NQVNLICAgICAgICAoM1VMIDw8IFBSX01U RV9UQ0ZfU0hJRlQpCj4gKyAgICAjIGRlZmluZSBQUl9NVEVfVEFHX1NISUZUICAgICAgIDMKPiAr ICAgICMgZGVmaW5lIFBSX01URV9UQUdfTUFTSyAgICAgICAgKDB4ZmZmZlVMIDw8IFBSX01URV9U QUdfU0hJRlQpCj4gKwo+ICsgICAgLyoKPiArICAgICAqIEluc2VydCBhIHJhbmRvbSBsb2dpY2Fs IHRhZyBpbnRvIHRoZSBnaXZlbiBwb2ludGVyLgo+ICsgICAgICovCj4gKyAgICAjZGVmaW5lIGlu c2VydF9yYW5kb21fdGFnKHB0cikgKHsgICAgICAgICAgICAgICAgICAgICAgIFwKPiArICAgICAg ICAgICAgX191NjQgX192YWw7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAo+ ICsgICAgICAgICAgICBhc20oImlyZyAlMCwgJTEiIDogIj1yIiAoX192YWwpIDogInIiIChwdHIp KTsgICBcCj4gKyAgICAgICAgICAgIF9fdmFsOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFwKPiArICAgIH0pCj4gKwo+ICsgICAgLyoKPiArICAgICAqIFNldCB0aGUg YWxsb2NhdGlvbiB0YWcgb24gdGhlIGRlc3RpbmF0aW9uIGFkZHJlc3MuCj4gKyAgICAgKi8KPiAr ICAgICNkZWZpbmUgc2V0X3RhZyh0YWdnZWRfYWRkcikgZG8geyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXAo+ICsgICAgICAgICAgICBhc20gdm9sYXRpbGUoInN0ZyAlMCwg WyUwXSIgOiA6ICJyIiAodGFnZ2VkX2FkZHIpIDogIm1lbW9yeSIpOyBcCj4gKyAgICB9IHdoaWxl ICgwKQo+ICsKPiArICAgIGludCBtYWluKCkKPiArICAgIHsKPiArICAgICAgICAgICAgdW5zaWdu ZWQgbG9uZyAqYTsKPiArICAgICAgICAgICAgdW5zaWduZWQgbG9uZyBwYWdlX3N6ID0gZ2V0cGFn ZXNpemUoKTsKPiArICAgICAgICAgICAgdW5zaWduZWQgbG9uZyBod2NhcDIgPSBnZXRhdXh2YWwo QVRfSFdDQVAyKTsKPiArCj4gKyAgICAgICAgICAgIC8qIGNoZWNrIGlmIE1URSBpcyBwcmVzZW50 ICovCj4gKyAgICAgICAgICAgIGlmICghKGh3Y2FwMiAmIEhXQ0FQMl9NVEUpKQo+ICsgICAgICAg ICAgICAgICAgICAgIHJldHVybiAtMTsKPiArCj4gKyAgICAgICAgICAgIC8qCj4gKyAgICAgICAg ICAgICAqIEVuYWJsZSB0aGUgdGFnZ2VkIGFkZHJlc3MgQUJJLCBzeW5jaHJvbm91cyBNVEUgdGFn IGNoZWNrIGZhdWx0cyBhbmQKPiArICAgICAgICAgICAgICogYWxsb3cgYWxsIG5vbi16ZXJvIHRh Z3MgaW4gdGhlIHJhbmRvbWx5IGdlbmVyYXRlZCBzZXQuCj4gKyAgICAgICAgICAgICAqLwo+ICsg ICAgICAgICAgICBpZiAocHJjdGwoUFJfU0VUX1RBR0dFRF9BRERSX0NUUkwsCj4gKyAgICAgICAg ICAgICAgICAgICAgICBQUl9UQUdHRURfQUREUl9FTkFCTEUgfCBQUl9NVEVfVENGX1NZTkMgfCAo MHhmZmZlIDw8IFBSX01URV9UQUdfU0hJRlQpLAo+ICsgICAgICAgICAgICAgICAgICAgICAgMCwg MCwgMCkpIHsKPiArICAgICAgICAgICAgICAgICAgICBwZXJyb3IoInByY3RsKCkgZmFpbGVkIik7 Cj4gKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIC0xOwo+ICsgICAgICAgICAgICB9Cj4gKwo+ ICsgICAgICAgICAgICBhID0gbW1hcCgwLCBwYWdlX3N6LCBQUk9UX1JFQUQgfCBQUk9UX1dSSVRF LAo+ICsgICAgICAgICAgICAgICAgICAgICBNQVBfUFJJVkFURSB8IE1BUF9BTk9OWU1PVVMsIC0x LCAwKTsKPiArICAgICAgICAgICAgaWYgKGEgPT0gTUFQX0ZBSUxFRCkgewo+ICsgICAgICAgICAg ICAgICAgICAgIHBlcnJvcigibW1hcCgpIGZhaWxlZCIpOwo+ICsgICAgICAgICAgICAgICAgICAg IHJldHVybiAtMTsKPiArICAgICAgICAgICAgfQo+ICsKPiArICAgICAgICAgICAgLyoKPiArICAg ICAgICAgICAgICogRW5hYmxlIE1URSBvbiB0aGUgYWJvdmUgYW5vbnltb3VzIG1tYXAuIFRoZSBm bGFnIGNvdWxkIGJlIHBhc3NlZAo+ICsgICAgICAgICAgICAgKiBkaXJlY3RseSB0byBtbWFwKCkg YW5kIHNraXAgdGhpcyBzdGVwLgo+ICsgICAgICAgICAgICAgKi8KPiArICAgICAgICAgICAgaWYg KG1wcm90ZWN0KGEsIHBhZ2Vfc3osIFBST1RfUkVBRCB8IFBST1RfV1JJVEUgfCBQUk9UX01URSkp IHsKPiArICAgICAgICAgICAgICAgICAgICBwZXJyb3IoIm1wcm90ZWN0KCkgZmFpbGVkIik7Cj4g KyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIC0xOwo+ICsgICAgICAgICAgICB9Cj4gKwo+ICsg ICAgICAgICAgICAvKiBhY2Nlc3Mgd2l0aCB0aGUgZGVmYXVsdCB0YWcgKDApICovCj4gKyAgICAg ICAgICAgIGFbMF0gPSAxOwo+ICsgICAgICAgICAgICBhWzFdID0gMjsKPiArCj4gKyAgICAgICAg ICAgIHByaW50ZigiYVswXSA9ICVsdSBhWzFdID0gJWx1XG4iLCBhWzBdLCBhWzFdKTsKPiArCj4g KyAgICAgICAgICAgIC8qIHNldCB0aGUgbG9naWNhbCBhbmQgYWxsb2NhdGlvbiB0YWdzICovCj4g KyAgICAgICAgICAgIGEgPSAodW5zaWduZWQgbG9uZyAqKWluc2VydF9yYW5kb21fdGFnKGEpOwo+ ICsgICAgICAgICAgICBzZXRfdGFnKGEpOwo+ICsKPiArICAgICAgICAgICAgcHJpbnRmKCIlcFxu IiwgYSk7Cj4gKwo+ICsgICAgICAgICAgICAvKiBub24temVybyB0YWcgYWNjZXNzICovCj4gKyAg ICAgICAgICAgIGFbMF0gPSAzOwo+ICsgICAgICAgICAgICBwcmludGYoImFbMF0gPSAlbHUgYVsx XSA9ICVsdVxuIiwgYVswXSwgYVsxXSk7Cj4gKwo+ICsgICAgICAgICAgICAvKgo+ICsgICAgICAg ICAgICAgKiBJZiBNVEUgaXMgZW5hYmxlZCBjb3JyZWN0bHkgdGhlIG5leHQgaW5zdHJ1Y3Rpb24g d2lsbCBnZW5lcmF0ZSBhbgo+ICsgICAgICAgICAgICAgKiBleGNlcHRpb24uCj4gKyAgICAgICAg ICAgICAqLwo+ICsgICAgICAgICAgICBwcmludGYoIkV4cGVjdGluZyBTSUdTRUdWLi4uXG4iKTsK PiArICAgICAgICAgICAgYVsyXSA9IDB4ZGVhZDsKPiArCj4gKyAgICAgICAgICAgIC8qIHRoaXMg c2hvdWxkIG5vdCBiZSBwcmludGVkIGluIHRoZSBQUl9NVEVfVENGX1NZTkMgbW9kZSAqLwo+ICsg ICAgICAgICAgICBwcmludGYoIi4uLmRvbmVcbiIpOwo+ICsKPiArICAgICAgICAgICAgcmV0dXJu IDA7Cj4gKyAgICB9CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0 cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGlu Zm8vbGludXgtYXJtLWtlcm5lbAo=