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.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_MUTT 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 EA50DC004D1 for ; Fri, 28 Sep 2018 08:38:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A639421748 for ; Fri, 28 Sep 2018 08:38:58 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A639421748 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=suse.de Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729354AbeI1PBf (ORCPT ); Fri, 28 Sep 2018 11:01:35 -0400 Received: from mx2.suse.de ([195.135.220.15]:50798 "EHLO mx1.suse.de" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1727389AbeI1PBe (ORCPT ); Fri, 28 Sep 2018 11:01:34 -0400 X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay1.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id 3BBA6ACBF; Fri, 28 Sep 2018 08:38:52 +0000 (UTC) Date: Fri, 28 Sep 2018 10:38:52 +0200 From: Borislav Petkov To: Lianbo Jiang Cc: linux-kernel@vger.kernel.org, kexec@lists.infradead.org, tglx@linutronix.de, mingo@redhat.com, hpa@zytor.com, x86@kernel.org, akpm@linux-foundation.org, dan.j.williams@intel.com, thomas.lendacky@amd.com, bhelgaas@google.com, baiyaowei@cmss.chinamobile.com, tiwai@suse.de, brijesh.singh@amd.com, dyoung@redhat.com, bhe@redhat.com, jroedel@suse.de Subject: Re: [PATCH v7 RESEND 4/4] kdump/vmcore: support encrypted old memory with SME enabled Message-ID: <20180928083852.GA21895@zn.tnic> References: <20180927071954.29615-1-lijiang@redhat.com> <20180927071954.29615-5-lijiang@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20180927071954.29615-5-lijiang@redhat.com> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, Sep 27, 2018 at 03:19:54PM +0800, Lianbo Jiang wrote: > In kdump kernel, we need to dump the old memory into vmcore file,if SME > is enabled in the first kernel, we have to remap the old memory with the > memory encryption mask, which will be automatically decrypted when we > read from DRAM. > > For SME kdump, there are two cases that doesn't support: ... and which are simply silly to support. > > ---------------------------------------------- > | first-kernel | second-kernel | kdump support | > | (mem_encrypt=on|off) | (yes|no) | > |--------------+---------------+---------------| > | on | on | yes | > | off | off | yes | > | on | off | no | > | off | on | no | > |______________|_______________|_______________| > > 1. SME is enabled in the first kernel, but SME is disabled in kdump kernel > In this case, because the old memory is encrypted, we can't decrypt the > old memory. > > 2. SME is disabled in the first kernel, but SME is enabled in kdump kernel > On the one hand, the old memory is unencrypted, the old memory can be dumped s/unencrypted/decrypted/g But I mentioned that already. > as usual, we don't need to enable SME in kdump kernel; On the other hand, it > will increase the complexity of the code, we will have to consider how to > pass the SME flag from the first kernel to the kdump kernel, it is really > too expensive to do this. > > This patches are only for SME kdump, the patches don't support SEV kdump. Please rewrite that commit message in passive voice. I.e., get rid of that "we". > > Signed-off-by: Lianbo Jiang > Reviewed-by: Tom Lendacky > --- > arch/x86/kernel/Makefile | 1 + > arch/x86/kernel/crash_dump_encrypt.c | 53 ++++++++++++++++++++++++++++ > fs/proc/vmcore.c | 21 +++++++---- > include/linux/crash_dump.h | 12 +++++++ > 4 files changed, 81 insertions(+), 6 deletions(-) > create mode 100644 arch/x86/kernel/crash_dump_encrypt.c > > diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile > index 8824d01c0c35..dfbeae0e35ce 100644 > --- a/arch/x86/kernel/Makefile > +++ b/arch/x86/kernel/Makefile > @@ -97,6 +97,7 @@ obj-$(CONFIG_KEXEC_CORE) += machine_kexec_$(BITS).o > obj-$(CONFIG_KEXEC_CORE) += relocate_kernel_$(BITS).o crash.o > obj-$(CONFIG_KEXEC_FILE) += kexec-bzimage64.o > obj-$(CONFIG_CRASH_DUMP) += crash_dump_$(BITS).o > +obj-$(CONFIG_AMD_MEM_ENCRYPT) += crash_dump_encrypt.o No no. This will build even in the CONFIG_CRASH_DUMP=n case. Why does this need to be even a separate compilation unit? It is a file containing a single function?!?! I would love to know what the logic behind this was... > obj-y += kprobes/ > obj-$(CONFIG_MODULES) += module.o > obj-$(CONFIG_DOUBLEFAULT) += doublefault.o > diff --git a/arch/x86/kernel/crash_dump_encrypt.c b/arch/x86/kernel/crash_dump_encrypt.c > new file mode 100644 > index 000000000000..e1b1a577f197 > --- /dev/null > +++ b/arch/x86/kernel/crash_dump_encrypt.c > @@ -0,0 +1,53 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Memory preserving reboot related code. > + * > + * Created by: Lianbo Jiang (lijiang@redhat.com) > + * Copyright (C) RedHat Corporation, 2018. All rights reserved > + */ > + > +#include > +#include > +#include > +#include > + > +/** > + * copy_oldmem_page_encrypted - copy one page from "oldmem encrypted" > + * @pfn: page frame number to be copied > + * @buf: target memory address for the copy; this can be in kernel address > + * space or user address space (see @userbuf) > + * @csize: number of bytes to copy > + * @offset: offset in bytes into the page (based on pfn) to begin the copy > + * @userbuf: if set, @buf is in user address space, use copy_to_user(), > + * otherwise @buf is in kernel address space, use memcpy(). > + * > + * Copy a page from "oldmem encrypted". For this page, there is no pte What is "oldmem encrypted"? Why can't you explain that in plain english? Note that those comments are not write-only but are meant for other people to read in the future. > + * mapped in the current kernel. We stitch up a pte, similar to > + * kmap_atomic. > + */ > + > +ssize_t copy_oldmem_page_encrypted(unsigned long pfn, char *buf, > + size_t csize, unsigned long offset, int userbuf) Align arguments on the opening brace. > +{ > + void *vaddr; > + > + if (!csize) > + return 0; > + > + vaddr = (__force void *)ioremap_encrypted(pfn << PAGE_SHIFT, > + PAGE_SIZE); Let it stick out. > + if (!vaddr) > + return -ENOMEM; > + > + if (userbuf) { > + if (copy_to_user((void __user *)buf, vaddr + offset, csize)) { > + iounmap((void __iomem *)vaddr); > + return -EFAULT; > + } > + } else > + memcpy(buf, vaddr + offset, csize); > + > + set_iounmap_nonlazy(); > + iounmap((void __iomem *)vaddr); > + return csize; > +} > diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c > index cbde728f8ac6..3065c8bada6a 100644 > --- a/fs/proc/vmcore.c > +++ b/fs/proc/vmcore.c > @@ -25,6 +25,9 @@ > #include > #include > #include > +#include > +#include > +#include Do you not see how the order of the include files is? First linux/ then asm/, then local headers. > #include "internal.h" And you don't need that if you drop that silly crash_dump_encrypt.c thing. > > /* List representing chunks of contiguous memory areas and their offsets in > @@ -98,7 +101,8 @@ static int pfn_is_ram(unsigned long pfn) > > /* Reads a page from the oldmem device from given offset. */ > static ssize_t read_from_oldmem(char *buf, size_t count, > - u64 *ppos, int userbuf) > + u64 *ppos, int userbuf, > + bool encrypted) > { > unsigned long pfn, offset; > size_t nr_bytes; > @@ -120,8 +124,11 @@ static ssize_t read_from_oldmem(char *buf, size_t count, > if (pfn_is_ram(pfn) == 0) > memset(buf, 0, nr_bytes); > else { > - tmp = copy_oldmem_page(pfn, buf, nr_bytes, > - offset, userbuf); > + tmp = encrypted ? copy_oldmem_page_encrypted(pfn, > + buf, nr_bytes, offset, userbuf) > + : copy_oldmem_page(pfn, buf, nr_bytes, > + offset, userbuf); Make that a simple if-else so that it can actually be readable. -- Regards/Gruss, Boris. SUSE Linux GmbH, GF: Felix Imendörffer, Jane Smithard, Graham Norton, HRB 21284 (AG Nürnberg) From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mx2.suse.de ([195.135.220.15] helo=mx1.suse.de) by casper.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1g5oIj-0001tO-5G for kexec@lists.infradead.org; Fri, 28 Sep 2018 08:39:07 +0000 Date: Fri, 28 Sep 2018 10:38:52 +0200 From: Borislav Petkov Subject: Re: [PATCH v7 RESEND 4/4] kdump/vmcore: support encrypted old memory with SME enabled Message-ID: <20180928083852.GA21895@zn.tnic> References: <20180927071954.29615-1-lijiang@redhat.com> <20180927071954.29615-5-lijiang@redhat.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20180927071954.29615-5-lijiang@redhat.com> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "kexec" Errors-To: kexec-bounces+dwmw2=infradead.org@lists.infradead.org To: Lianbo Jiang Cc: thomas.lendacky@amd.com, jroedel@suse.de, brijesh.singh@amd.com, bhe@redhat.com, tiwai@suse.de, x86@kernel.org, kexec@lists.infradead.org, linux-kernel@vger.kernel.org, mingo@redhat.com, baiyaowei@cmss.chinamobile.com, hpa@zytor.com, bhelgaas@google.com, tglx@linutronix.de, dyoung@redhat.com, akpm@linux-foundation.org, dan.j.williams@intel.com T24gVGh1LCBTZXAgMjcsIDIwMTggYXQgMDM6MTk6NTRQTSArMDgwMCwgTGlhbmJvIEppYW5nIHdy b3RlOgo+IEluIGtkdW1wIGtlcm5lbCwgd2UgbmVlZCB0byBkdW1wIHRoZSBvbGQgbWVtb3J5IGlu dG8gdm1jb3JlIGZpbGUsaWYgU01FCj4gaXMgZW5hYmxlZCBpbiB0aGUgZmlyc3Qga2VybmVsLCB3 ZSBoYXZlIHRvIHJlbWFwIHRoZSBvbGQgbWVtb3J5IHdpdGggdGhlCj4gbWVtb3J5IGVuY3J5cHRp b24gbWFzaywgd2hpY2ggd2lsbCBiZSBhdXRvbWF0aWNhbGx5IGRlY3J5cHRlZCB3aGVuIHdlCj4g cmVhZCBmcm9tIERSQU0uCj4gCj4gRm9yIFNNRSBrZHVtcCwgdGhlcmUgYXJlIHR3byBjYXNlcyB0 aGF0IGRvZXNuJ3Qgc3VwcG9ydDoKCi4uLiBhbmQgd2hpY2ggYXJlIHNpbXBseSBzaWxseSB0byBz dXBwb3J0LgoKPiAKPiAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQo+IHwgZmlyc3Qta2VybmVsIHwgc2Vjb25kLWtlcm5lbCB8IGtkdW1wIHN1cHBvcnQgfAo+ IHwgICAgICAobWVtX2VuY3J5cHQ9b258b2ZmKSAgICB8ICAgKHllc3xubykgICAgfAo+IHwtLS0t LS0tLS0tLS0tLSstLS0tLS0tLS0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tfAo+IHwgICAgIG9uICAg ICAgIHwgICAgIG9uICAgICAgICB8ICAgICB5ZXMgICAgICAgfAo+IHwgICAgIG9mZiAgICAgIHwg ICAgIG9mZiAgICAgICB8ICAgICB5ZXMgICAgICAgfAo+IHwgICAgIG9uICAgICAgIHwgICAgIG9m ZiAgICAgICB8ICAgICBubyAgICAgICAgfAo+IHwgICAgIG9mZiAgICAgIHwgICAgIG9uICAgICAg ICB8ICAgICBubyAgICAgICAgfAo+IHxfX19fX19fX19fX19fX3xfX19fX19fX19fX19fX198X19f X19fX19fX19fX19ffAo+IAo+IDEuIFNNRSBpcyBlbmFibGVkIGluIHRoZSBmaXJzdCBrZXJuZWws IGJ1dCBTTUUgaXMgZGlzYWJsZWQgaW4ga2R1bXAga2VybmVsCj4gSW4gdGhpcyBjYXNlLCBiZWNh dXNlIHRoZSBvbGQgbWVtb3J5IGlzIGVuY3J5cHRlZCwgd2UgY2FuJ3QgZGVjcnlwdCB0aGUKPiBv bGQgbWVtb3J5Lgo+IAo+IDIuIFNNRSBpcyBkaXNhYmxlZCBpbiB0aGUgZmlyc3Qga2VybmVsLCBi dXQgU01FIGlzIGVuYWJsZWQgaW4ga2R1bXAga2VybmVsCj4gT24gdGhlIG9uZSBoYW5kLCB0aGUg b2xkIG1lbW9yeSBpcyB1bmVuY3J5cHRlZCwgdGhlIG9sZCBtZW1vcnkgY2FuIGJlIGR1bXBlZAoK cy91bmVuY3J5cHRlZC9kZWNyeXB0ZWQvZwoKQnV0IEkgbWVudGlvbmVkIHRoYXQgYWxyZWFkeS4K Cj4gYXMgdXN1YWwsIHdlIGRvbid0IG5lZWQgdG8gZW5hYmxlIFNNRSBpbiBrZHVtcCBrZXJuZWw7 IE9uIHRoZSBvdGhlciBoYW5kLCBpdAo+IHdpbGwgaW5jcmVhc2UgdGhlIGNvbXBsZXhpdHkgb2Yg dGhlIGNvZGUsIHdlIHdpbGwgaGF2ZSB0byBjb25zaWRlciBob3cgdG8KPiBwYXNzIHRoZSBTTUUg ZmxhZyBmcm9tIHRoZSBmaXJzdCBrZXJuZWwgdG8gdGhlIGtkdW1wIGtlcm5lbCwgaXQgaXMgcmVh bGx5Cj4gdG9vIGV4cGVuc2l2ZSB0byBkbyB0aGlzLgo+IAo+IFRoaXMgcGF0Y2hlcyBhcmUgb25s eSBmb3IgU01FIGtkdW1wLCB0aGUgcGF0Y2hlcyBkb24ndCBzdXBwb3J0IFNFViBrZHVtcC4KClBs ZWFzZSByZXdyaXRlIHRoYXQgY29tbWl0IG1lc3NhZ2UgaW4gcGFzc2l2ZSB2b2ljZS4gSS5lLiwg Z2V0IHJpZCBvZgp0aGF0ICJ3ZSIuCgo+IAo+IFNpZ25lZC1vZmYtYnk6IExpYW5ibyBKaWFuZyA8 bGlqaWFuZ0ByZWRoYXQuY29tPgo+IFJldmlld2VkLWJ5OiBUb20gTGVuZGFja3kgPHRob21hcy5s ZW5kYWNreUBhbWQuY29tPgo+IC0tLQo+ICBhcmNoL3g4Ni9rZXJuZWwvTWFrZWZpbGUgICAgICAg ICAgICAgfCAgMSArCj4gIGFyY2gveDg2L2tlcm5lbC9jcmFzaF9kdW1wX2VuY3J5cHQuYyB8IDUz ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgZnMvcHJvYy92bWNvcmUuYyAgICAgICAg ICAgICAgICAgICAgIHwgMjEgKysrKysrKy0tLS0KPiAgaW5jbHVkZS9saW51eC9jcmFzaF9kdW1w LmggICAgICAgICAgIHwgMTIgKysrKysrKwo+ICA0IGZpbGVzIGNoYW5nZWQsIDgxIGluc2VydGlv bnMoKyksIDYgZGVsZXRpb25zKC0pCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL3g4Ni9rZXJu ZWwvY3Jhc2hfZHVtcF9lbmNyeXB0LmMKPiAKPiBkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVs L01ha2VmaWxlIGIvYXJjaC94ODYva2VybmVsL01ha2VmaWxlCj4gaW5kZXggODgyNGQwMWMwYzM1 Li5kZmJlYWUwZTM1Y2UgMTAwNjQ0Cj4gLS0tIGEvYXJjaC94ODYva2VybmVsL01ha2VmaWxlCj4g KysrIGIvYXJjaC94ODYva2VybmVsL01ha2VmaWxlCj4gQEAgLTk3LDYgKzk3LDcgQEAgb2JqLSQo Q09ORklHX0tFWEVDX0NPUkUpCSs9IG1hY2hpbmVfa2V4ZWNfJChCSVRTKS5vCj4gIG9iai0kKENP TkZJR19LRVhFQ19DT1JFKQkrPSByZWxvY2F0ZV9rZXJuZWxfJChCSVRTKS5vIGNyYXNoLm8KPiAg b2JqLSQoQ09ORklHX0tFWEVDX0ZJTEUpCSs9IGtleGVjLWJ6aW1hZ2U2NC5vCj4gIG9iai0kKENP TkZJR19DUkFTSF9EVU1QKQkrPSBjcmFzaF9kdW1wXyQoQklUUykubwo+ICtvYmotJChDT05GSUdf QU1EX01FTV9FTkNSWVBUKQkrPSBjcmFzaF9kdW1wX2VuY3J5cHQubwoKTm8gbm8uCgpUaGlzIHdp bGwgYnVpbGQgZXZlbiBpbiB0aGUgQ09ORklHX0NSQVNIX0RVTVA9biBjYXNlLgoKV2h5IGRvZXMg dGhpcyBuZWVkIHRvIGJlIGV2ZW4gYSBzZXBhcmF0ZSBjb21waWxhdGlvbiB1bml0PyBJdCBpcyBh IGZpbGUKY29udGFpbmluZyBhIHNpbmdsZSBmdW5jdGlvbj8hPyEKCkkgd291bGQgbG92ZSB0byBr bm93IHdoYXQgdGhlIGxvZ2ljIGJlaGluZCB0aGlzIHdhcy4uLgoKPiAgb2JqLXkJCQkJKz0ga3By b2Jlcy8KPiAgb2JqLSQoQ09ORklHX01PRFVMRVMpCQkrPSBtb2R1bGUubwo+ICBvYmotJChDT05G SUdfRE9VQkxFRkFVTFQpCSs9IGRvdWJsZWZhdWx0Lm8KPiBkaWZmIC0tZ2l0IGEvYXJjaC94ODYv a2VybmVsL2NyYXNoX2R1bXBfZW5jcnlwdC5jIGIvYXJjaC94ODYva2VybmVsL2NyYXNoX2R1bXBf ZW5jcnlwdC5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmUx YjFhNTc3ZjE5Nwo+IC0tLSAvZGV2L251bGwKPiArKysgYi9hcmNoL3g4Ni9rZXJuZWwvY3Jhc2hf ZHVtcF9lbmNyeXB0LmMKPiBAQCAtMCwwICsxLDUzIEBACj4gKy8vIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wCj4gKy8qCj4gKyAqCU1lbW9yeSBwcmVzZXJ2aW5nIHJlYm9vdCByZWxh dGVkIGNvZGUuCj4gKyAqCj4gKyAqCUNyZWF0ZWQgYnk6IExpYW5ibyBKaWFuZyAobGlqaWFuZ0By ZWRoYXQuY29tKQo+ICsgKglDb3B5cmlnaHQgKEMpIFJlZEhhdCBDb3Jwb3JhdGlvbiwgMjAxOC4g QWxsIHJpZ2h0cyByZXNlcnZlZAo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9lcnJuby5o Pgo+ICsjaW5jbHVkZSA8bGludXgvY3Jhc2hfZHVtcC5oPgo+ICsjaW5jbHVkZSA8bGludXgvdWFj Y2Vzcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW8uaD4KPiArCj4gKy8qKgo+ICsgKiBjb3B5X29s ZG1lbV9wYWdlX2VuY3J5cHRlZCAtIGNvcHkgb25lIHBhZ2UgZnJvbSAib2xkbWVtIGVuY3J5cHRl ZCIKPiArICogQHBmbjogcGFnZSBmcmFtZSBudW1iZXIgdG8gYmUgY29waWVkCj4gKyAqIEBidWY6 IHRhcmdldCBtZW1vcnkgYWRkcmVzcyBmb3IgdGhlIGNvcHk7IHRoaXMgY2FuIGJlIGluIGtlcm5l bCBhZGRyZXNzCj4gKyAqCXNwYWNlIG9yIHVzZXIgYWRkcmVzcyBzcGFjZSAoc2VlIEB1c2VyYnVm KQo+ICsgKiBAY3NpemU6IG51bWJlciBvZiBieXRlcyB0byBjb3B5Cj4gKyAqIEBvZmZzZXQ6IG9m ZnNldCBpbiBieXRlcyBpbnRvIHRoZSBwYWdlIChiYXNlZCBvbiBwZm4pIHRvIGJlZ2luIHRoZSBj b3B5Cj4gKyAqIEB1c2VyYnVmOiBpZiBzZXQsIEBidWYgaXMgaW4gdXNlciBhZGRyZXNzIHNwYWNl LCB1c2UgY29weV90b191c2VyKCksCj4gKyAqCW90aGVyd2lzZSBAYnVmIGlzIGluIGtlcm5lbCBh ZGRyZXNzIHNwYWNlLCB1c2UgbWVtY3B5KCkuCj4gKyAqCj4gKyAqIENvcHkgYSBwYWdlIGZyb20g Im9sZG1lbSBlbmNyeXB0ZWQiLiBGb3IgdGhpcyBwYWdlLCB0aGVyZSBpcyBubyBwdGUKCldoYXQg aXMgIm9sZG1lbSBlbmNyeXB0ZWQiPyBXaHkgY2FuJ3QgeW91IGV4cGxhaW4gdGhhdCBpbiBwbGFp biBlbmdsaXNoPwpOb3RlIHRoYXQgdGhvc2UgY29tbWVudHMgYXJlIG5vdCB3cml0ZS1vbmx5IGJ1 dCBhcmUgbWVhbnQgZm9yIG90aGVyCnBlb3BsZSB0byByZWFkIGluIHRoZSBmdXR1cmUuCgo+ICsg KiBtYXBwZWQgaW4gdGhlIGN1cnJlbnQga2VybmVsLiBXZSBzdGl0Y2ggdXAgYSBwdGUsIHNpbWls YXIgdG8KPiArICoga21hcF9hdG9taWMuCj4gKyAqLwo+ICsKPiArc3NpemVfdCBjb3B5X29sZG1l bV9wYWdlX2VuY3J5cHRlZCh1bnNpZ25lZCBsb25nIHBmbiwgY2hhciAqYnVmLAo+ICsJCXNpemVf dCBjc2l6ZSwgdW5zaWduZWQgbG9uZyBvZmZzZXQsIGludCB1c2VyYnVmKQoKQWxpZ24gYXJndW1l bnRzIG9uIHRoZSBvcGVuaW5nIGJyYWNlLgoKPiArewo+ICsJdm9pZCAgKnZhZGRyOwo+ICsKPiAr CWlmICghY3NpemUpCj4gKwkJcmV0dXJuIDA7Cj4gKwo+ICsJdmFkZHIgPSAoX19mb3JjZSB2b2lk ICopaW9yZW1hcF9lbmNyeXB0ZWQocGZuIDw8IFBBR0VfU0hJRlQsCj4gKwkJCQkJCSAgUEFHRV9T SVpFKTsKCkxldCBpdCBzdGljayBvdXQuCgo+ICsJaWYgKCF2YWRkcikKPiArCQlyZXR1cm4gLUVO T01FTTsKPiArCj4gKwlpZiAodXNlcmJ1Zikgewo+ICsJCWlmIChjb3B5X3RvX3VzZXIoKHZvaWQg X191c2VyICopYnVmLCB2YWRkciArIG9mZnNldCwgY3NpemUpKSB7Cj4gKwkJCWlvdW5tYXAoKHZv aWQgX19pb21lbSAqKXZhZGRyKTsKPiArCQkJcmV0dXJuIC1FRkFVTFQ7Cj4gKwkJfQo+ICsJfSBl bHNlCj4gKwkJbWVtY3B5KGJ1ZiwgdmFkZHIgKyBvZmZzZXQsIGNzaXplKTsKPiArCj4gKwlzZXRf aW91bm1hcF9ub25sYXp5KCk7Cj4gKwlpb3VubWFwKCh2b2lkIF9faW9tZW0gKil2YWRkcik7Cj4g KwlyZXR1cm4gY3NpemU7Cj4gK30KPiBkaWZmIC0tZ2l0IGEvZnMvcHJvYy92bWNvcmUuYyBiL2Zz L3Byb2Mvdm1jb3JlLmMKPiBpbmRleCBjYmRlNzI4ZjhhYzYuLjMwNjVjOGJhZGE2YSAxMDA2NDQK PiAtLS0gYS9mcy9wcm9jL3ZtY29yZS5jCj4gKysrIGIvZnMvcHJvYy92bWNvcmUuYwo+IEBAIC0y NSw2ICsyNSw5IEBACj4gICNpbmNsdWRlIDxsaW51eC9wYWdlbWFwLmg+Cj4gICNpbmNsdWRlIDxs aW51eC91YWNjZXNzLmg+Cj4gICNpbmNsdWRlIDxhc20vaW8uaD4KPiArI2luY2x1ZGUgPGxpbnV4 L2lvLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tZW1fZW5jcnlwdC5oPgo+ICsjaW5jbHVkZSA8YXNt L3BndGFibGUuaD4KCkRvIHlvdSBub3Qgc2VlIGhvdyB0aGUgb3JkZXIgb2YgdGhlIGluY2x1ZGUg ZmlsZXMgaXM/IEZpcnN0IGxpbnV4LyB0aGVuCmFzbS8sIHRoZW4gbG9jYWwgaGVhZGVycy4KCj4g ICNpbmNsdWRlICJpbnRlcm5hbC5oIgoKQW5kIHlvdSBkb24ndCBuZWVkIHRoYXQgaWYgeW91IGRy b3AgdGhhdCBzaWxseSBjcmFzaF9kdW1wX2VuY3J5cHQuYyB0aGluZy4KCj4gIAo+ICAvKiBMaXN0 IHJlcHJlc2VudGluZyBjaHVua3Mgb2YgY29udGlndW91cyBtZW1vcnkgYXJlYXMgYW5kIHRoZWly IG9mZnNldHMgaW4KPiBAQCAtOTgsNyArMTAxLDggQEAgc3RhdGljIGludCBwZm5faXNfcmFtKHVu c2lnbmVkIGxvbmcgcGZuKQo+ICAKPiAgLyogUmVhZHMgYSBwYWdlIGZyb20gdGhlIG9sZG1lbSBk ZXZpY2UgZnJvbSBnaXZlbiBvZmZzZXQuICovCj4gIHN0YXRpYyBzc2l6ZV90IHJlYWRfZnJvbV9v bGRtZW0oY2hhciAqYnVmLCBzaXplX3QgY291bnQsCj4gLQkJCQl1NjQgKnBwb3MsIGludCB1c2Vy YnVmKQo+ICsJCQkJdTY0ICpwcG9zLCBpbnQgdXNlcmJ1ZiwKPiArCQkJCWJvb2wgZW5jcnlwdGVk KQo+ICB7Cj4gIAl1bnNpZ25lZCBsb25nIHBmbiwgb2Zmc2V0Owo+ICAJc2l6ZV90IG5yX2J5dGVz Owo+IEBAIC0xMjAsOCArMTI0LDExIEBAIHN0YXRpYyBzc2l6ZV90IHJlYWRfZnJvbV9vbGRtZW0o Y2hhciAqYnVmLCBzaXplX3QgY291bnQsCj4gIAkJaWYgKHBmbl9pc19yYW0ocGZuKSA9PSAwKQo+ ICAJCQltZW1zZXQoYnVmLCAwLCBucl9ieXRlcyk7Cj4gIAkJZWxzZSB7Cj4gLQkJCXRtcCA9IGNv cHlfb2xkbWVtX3BhZ2UocGZuLCBidWYsIG5yX2J5dGVzLAo+IC0JCQkJCQlvZmZzZXQsIHVzZXJi dWYpOwo+ICsJCQl0bXAgPSBlbmNyeXB0ZWQgPyBjb3B5X29sZG1lbV9wYWdlX2VuY3J5cHRlZChw Zm4sCj4gKwkJCQkJICAgIGJ1ZiwgbnJfYnl0ZXMsIG9mZnNldCwgdXNlcmJ1ZikKPiArCQkJCQk6 IGNvcHlfb2xkbWVtX3BhZ2UocGZuLCBidWYsIG5yX2J5dGVzLAo+ICsJCQkJCQkJICAgb2Zmc2V0 LCB1c2VyYnVmKTsKCk1ha2UgdGhhdCBhIHNpbXBsZSBpZi1lbHNlIHNvIHRoYXQgaXQgY2FuIGFj dHVhbGx5IGJlIHJlYWRhYmxlLgoKLS0gClJlZ2FyZHMvR3J1c3MsCiAgICBCb3Jpcy4KClNVU0Ug TGludXggR21iSCwgR0Y6IEZlbGl4IEltZW5kw7ZyZmZlciwgSmFuZSBTbWl0aGFyZCwgR3JhaGFt IE5vcnRvbiwgSFJCIDIxMjg0IChBRyBOw7xybmJlcmcpCgpfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwprZXhlYyBtYWlsaW5nIGxpc3QKa2V4ZWNAbGlzdHMu aW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2tleGVjCg==