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=-5.5 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,UNWANTED_LANGUAGE_BODY,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 141F4C433E0 for ; Mon, 1 Jun 2020 15:08: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 D5E2120738 for ; Mon, 1 Jun 2020 15:08:19 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="SehFIFwV"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=armlinux.org.uk header.i=@armlinux.org.uk header.b="G8VBKHYp" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D5E2120738 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=armlinux.org.uk 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-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=R9BVSOZqgrcB9VxAinp6eQYEDXQBZsZ1TStGlmBMqrA=; b=SehFIFwV/a7z3D 5Iu07VqcBGSsmAbk/5wArXdI2O+MwPDai5jXcvt6dUutfiSevNUV6aaWqm0K4E7qujqn0alYdqj6N adCT6rutOqQxpZKNf61ppP1VzB+v58nBGMIZPl9vyfkK62A5E3niC9KaCPnYj0RjCEVPgwFegy4nf AM2m3tV8AmFh1CC6XFQoFHt5EP1Kq1UhiF0N89GkfQl5W+iTpnFUjn1/iziQstjm7U31SntwJc1cb 8aLRU6ilJ++3pN3PxDUpgDAVncPh1nHrlVYINeHZbX6Nx+KE3rmxwBLCMH4eQAMpcHtWYbmYk1G2H di4kE5/xCmn/x/lBoczw==; 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 1jfm2s-00076M-LK; Mon, 01 Jun 2020 15:08:10 +0000 Received: from pandora.armlinux.org.uk ([2001:4d48:ad52:3201:214:fdff:fe10:1be6]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jfm2n-00074d-9p for linux-arm-kernel@lists.infradead.org; Mon, 01 Jun 2020 15:08:08 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=qAq4uZ1ttFHDy5aUeojvBZHoZbUCeHSbfFMRl/qdBE4=; b=G8VBKHYp6BPpkFO36U+zS3RVK obm6EzNkbWV96jdLQYzj7dE5RbCCLSSt2eyHIkM9o7NFcLH4zRseHFG0Izd6MoPudDbU3niLN14gX 18w+vkdkwwbiFbS11D5pnEtsHMfD7cS4brzCeLCCtQcDctZEg1N1TF3rlwgtDz4BX3odXY6TXaWrX TyHl94ebQ4baDbFRfPfIuuOl4IadWVVWY9SbZdIFivhX7rEfbDfdG9rq7aYVUSkmSnbrUjAHQkyM+ DVZTH1+95ni1Xjror6gru5515fDs+1zLmbmLup/brhbhbvKvxYMGYF60bhL2OZQYtSujhofGRCnyH jznMtmynw==; Received: from shell.armlinux.org.uk ([2001:4d48:ad52:3201:5054:ff:fe00:4ec]:48056) by pandora.armlinux.org.uk with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.90_1) (envelope-from ) id 1jfm2W-0000c6-Ea; Mon, 01 Jun 2020 16:07:48 +0100 Received: from linux by shell.armlinux.org.uk with local (Exim 4.92) (envelope-from ) id 1jfm2T-0003P7-K4; Mon, 01 Jun 2020 16:07:45 +0100 Date: Mon, 1 Jun 2020 16:07:45 +0100 From: Russell King - ARM Linux admin To: =?utf-8?Q?=C5=81ukasz?= Stelmach Subject: Re: [PATCH 5/5] arm: kexec_file: load zImage or uImage, initrd and dtb Message-ID: <20200601150745.GL1551@shell.armlinux.org.uk> References: <20200601142754.26139-1-l.stelmach@samsung.com> <20200601142754.26139-6-l.stelmach@samsung.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20200601142754.26139-6-l.stelmach@samsung.com> User-Agent: Mutt/1.10.1 (2018-07-13) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200601_080805_920262_0A181C06 X-CRM114-Status: GOOD ( 31.42 ) 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: Kees Cook , Bartlomiej Zolnierkiewicz , Masahiro Yamada , Nick Desaulniers , linux-kernel@vger.kernel.org, AKASHI Takahiro , Ben Dooks , Thomas Gleixner , Enrico Weigelt , Ingo Molnar , linux-arm-kernel@lists.infradead.org, Marek Szyprowski Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gTW9uLCBKdW4gMDEsIDIwMjAgYXQgMDQ6Mjc6NTRQTSArMDIwMCwgxYF1a2FzeiBTdGVsbWFj aCB3cm90ZToKPiBUaGlzIGlzIGtleGVjX2ZpbGVfbG9hZCBpbXBsZW1lbnRhdGlvbiBmb3IgQVJN LiBJdCBsb2FkcyB6SW1hZ2UgYW5kCj4gaW5pdHJkIGZyb20gZmlsZSBkZXNjcmlwdGVycyBhbmQg cmVzdXNlcyBEVEIuCj4gCj4gTW9zdCBjb2RlIGlzIGRlcml2ZWQgZnJvbSBhcm02NCBrZXhlY19m aWxlX2xvYWQgaW1wbGVtZW50YXRpb24KPiBhbmQgZnJvbSBrZXhlYy10b29scy4KClBsZWFzZSBt YWtlIHRoZSB1SW1hZ2UgbG9hZGVyIGFibGUgdG8gYmUgY29uZmlndXJlZCBvdXQgb2YgdGhlCmtl cm5lbDsgaXQncyBhIGxlZ2FjeSBpbWFnZSBmb3JtYXQgbm93LCBhbmQgc29tZSBvZiB1cyBqdXN0 IGRvbid0CnVzZSBpdCBhbnltb3JlLiAgVGhhdCB3YXksIHRob3NlIHdobyB3aXNoIHRvIGhhdmUg aXQgY2FuLCBhbmQKdGhvc2Ugd2hvIHdpc2ggbm90IHRvIGNhbiBoYXZlIGEgc21hbGxlciBrZXJu ZWwuCgo+IENjOiBBS0FTSEkgVGFrYWhpcm8gPHRha2FoaXJvLmFrYXNoaUBsaW5hcm8ub3JnPgo+ IFNpZ25lZC1vZmYtYnk6IMWBdWthc3ogU3RlbG1hY2ggPGwuc3RlbG1hY2hAc2Ftc3VuZy5jb20+ Cj4gLS0tCj4gIGFyY2gvYXJtL0tjb25maWcgICAgICAgICAgICAgICAgICAgICB8ICAxNSArKwo+ ICBhcmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5oICAgICAgICAgfCAgMjYgKysrKwo+ICBhcmNo L2FybS9pbmNsdWRlL2FzbS9rZXhlYy5oICAgICAgICAgfCAgMTQgKysKPiAgYXJjaC9hcm0va2Vy bmVsL01ha2VmaWxlICAgICAgICAgICAgIHwgICA1ICstCj4gIGFyY2gvYXJtL2tlcm5lbC9rZXhl Y191aW1hZ2UuYyAgICAgICB8ICA4MCArKysrKysrKysrCj4gIGFyY2gvYXJtL2tlcm5lbC9rZXhl Y196aW1hZ2UuYyAgICAgICB8IDE5OSArKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGFyY2gv YXJtL2tlcm5lbC9tYWNoaW5lX2tleGVjLmMgICAgICB8ICAxMSArLQo+ICBhcmNoL2FybS9rZXJu ZWwvbWFjaGluZV9rZXhlY19maWxlLmMgfCAyMDkgKysrKysrKysrKysrKysrKysrKysrKysrKysr Cj4gIDggZmlsZXMgY2hhbmdlZCwgNTU0IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCj4g IGNyZWF0ZSBtb2RlIDEwMDY0NCBhcmNoL2FybS9rZXJuZWwva2V4ZWNfdWltYWdlLmMKPiAgY3Jl YXRlIG1vZGUgMTAwNjQ0IGFyY2gvYXJtL2tlcm5lbC9rZXhlY196aW1hZ2UuYwo+ICBjcmVhdGUg bW9kZSAxMDA2NDQgYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jCj4gCj4gZGlm ZiAtLWdpdCBhL2FyY2gvYXJtL0tjb25maWcgYi9hcmNoL2FybS9LY29uZmlnCj4gaW5kZXggYzc3 YzkzYzQ4NWEwLi42YWRiODQ5Y2IzMDQgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm0vS2NvbmZpZwo+ ICsrKyBiL2FyY2gvYXJtL0tjb25maWcKPiBAQCAtMTkxNyw2ICsxOTE3LDIxIEBAIGNvbmZpZyBL RVhFQwo+ICAJICBpcyBwcm9wZXJseSBzaHV0ZG93biwgc28gZG8gbm90IGJlIHN1cnByaXNlZCBp ZiB0aGlzIGNvZGUgZG9lcyBub3QKPiAgCSAgaW5pdGlhbGx5IHdvcmsgZm9yIHlvdS4KPiAgCj4g K2NvbmZpZyBLRVhFQ19GSUxFCj4gKwlib29sICJLZXhlYyBmaWxlIGJhc2VkIHN5c3RlbSBjYWxs IChFWFBFUklNRU5UQUwpIgo+ICsJZGVwZW5kcyBvbiAoIVNNUCB8fCBQTV9TTEVFUF9TTVApCj4g KwlkZXBlbmRzIG9uIFVTRV9PRgo+ICsJc2VsZWN0IEtFWEVDX0NPUkUKPiArCXNlbGVjdCBDUkMz Mgo+ICsJaGVscAo+ICsJICBUaGlzIGlzIG5ldyB2ZXJzaW9uIG9mIGtleGVjIHN5c3RlbSBjYWxs LiBUaGlzIHN5c3RlbSBjYWxsIGlzCj4gKwkgIGZpbGUgYmFzZWQgYW5kIHRha2VzIGZpbGUgZGVz Y3JpcHRvcnMgYXMgc3lzdGVtIGNhbGwgYXJndW1lbnQKPiArCSAgZm9yIGtlcm5lbCBhbmQgaW5p dHJhbWZzIGFzIG9wcG9zZWQgdG8gbGlzdCBvZiBzZWdtZW50cyBhcwo+ICsJICBhY2NlcHRlZCBi eSBwcmV2aW91cyBzeXN0ZW0gY2FsbC4KPiArCj4gKwkgIFRoZSBrZXJuZWwgdG8gYmUgbG9hZGVk IE1VU1Qgc3VwcG9ydCBGbGF0dGVuZWQgRGV2aWNlIFRyZWUKPiArCSAgKHNlbGVjdGVkIHdpdGgg Q09ORklHX1VTRV9PRikuCj4gKwo+ICBjb25maWcgQVRBR1NfUFJPQwo+ICAJYm9vbCAiRXhwb3J0 IGF0YWdzIGluIHByb2NmcyIKPiAgCWRlcGVuZHMgb24gQVRBR1MgJiYgS0VYRUMKPiBkaWZmIC0t Z2l0IGEvYXJjaC9hcm0vaW5jbHVkZS9hc20vaW1hZ2UuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNt L2ltYWdlLmgKPiBpbmRleCA2MjQ0Mzg3NDBmMjMuLjk1ZjIzODM3YjA0ZiAxMDA2NDQKPiAtLS0g YS9hcmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5oCj4gKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9h c20vaW1hZ2UuaAo+IEBAIC04LDggKzgsMTMgQEAKPiAgCQkJICgoKHgpID4+ICA4KSAmIDB4MDAw MGZmMDApIHwgIFwKPiAgCQkJICgoKHgpIDw8ICA4KSAmIDB4MDBmZjAwMDApIHwgIFwKPiAgCQkJ ICgoKHgpIDw8IDI0KSAmIDB4ZmYwMDAwMDApKQo+ICsjZGVmaW5lIFVJTUFHRV9NQUdJQyh4KSAo eCkKPiAgI2Vsc2UKPiAgI2RlZmluZSBaSU1BR0VfTUFHSUMoeCkgKHgpCj4gKyNkZWZpbmUgVUlN QUdFX01BR0lDKHgpICgoKCh4KSA+PiAyNCkgJiAweDAwMDAwMGZmKSB8IFwKPiArCQkJICgoKHgp ID4+ICA4KSAmIDB4MDAwMGZmMDApIHwgIFwKPiArCQkJICgoKHgpIDw8ICA4KSAmIDB4MDBmZjAw MDApIHwgIFwKPiArCQkJICgoKHgpIDw8IDI0KSAmIDB4ZmYwMDAwMDApKQo+ICAjZW5kaWYKPiAg Cj4gICNkZWZpbmUgQVJNX1pJTUFHRV9NQUdJQzEgWklNQUdFX01BR0lDKDB4MDE2ZjI4MTgpCj4g QEAgLTE3LDYgKzIyLDEyIEBACj4gICNkZWZpbmUgQVJNX1pJTUFHRV9NQUdJQzMgWklNQUdFX01B R0lDKDB4NWE1MzRjNGIpCj4gICNkZWZpbmUgQVJNX1pJTUFHRV9NQUdJQzQgWklNQUdFX01BR0lD KDB4NWE1MzQzNDQpCj4gIAo+ICsjZGVmaW5lIEFSTV9VSU1BR0VfTUFHSUMgVUlNQUdFX01BR0lD KDB4MjcwNTE5NTYpCj4gKyNkZWZpbmUgQVJNX1VJTUFHRV9OQU1FX0xFTgkJMzIKPiArI2RlZmlu ZSBBUk1fVUlNQUdFX1RZUEVfS0VSTkVMCQkyCj4gKyNkZWZpbmUgQVJNX1VJTUFHRV9UWVBFX0tF Uk5FTF9OT0xPQUQJMTQKPiArI2RlZmluZSBBUk1fVUlNQUdFX0FSQ0hfQVJNCQkyCj4gKwo+ICAj aWZuZGVmIF9fQVNTRU1CTFlfXwo+ICAKPiAgI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+Cj4gQEAg LTMzLDYgKzQ0LDIxIEBAIHN0cnVjdCBhcm1femltYWdlX2hlYWRlciB7Cj4gIAlfX2xlMzIgZXh0 ZW5zaW9uX3RhZ19vZmZzZXQ7Cj4gIH07Cj4gIAo+ICtzdHJ1Y3QgYXJtX3VpbWFnZV9oZWFkZXIg ewo+ICsJX19iZTMyIG1hZ2ljOwo+ICsJX19iZTMyIGhkcl9jcmM7Cj4gKwlfX2JlMzIgdGltZTsK PiArCV9fYmUzMiBzaXplOwo+ICsJX19iZTMyIGxvYWQ7Cj4gKwlfX2JlMzIgZW50cnk7Cj4gKwlf X2JlMzIgY3JjOwo+ICsJX191OCAgIG9zOwo+ICsJX191OCAgIGFyY2g7Cj4gKwlfX3U4ICAgdHlw ZTsKPiArCV9fdTggICBjb21wOwo+ICsJX191OCAgIG5hbWVbQVJNX1VJTUFHRV9OQU1FX0xFTl07 Cj4gK307Cj4gKwo+ICBzdHJ1Y3QgYXJtX3ppbWFnZV90YWcgewo+ICAJc3RydWN0IHRhZ19oZWFk ZXIgaGRyOwo+ICAJdW5pb24gewo+IGRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9r ZXhlYy5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20va2V4ZWMuaAo+IGluZGV4IDIyNzUxYjViNTcz NS4uZmRhMzVhZmE3MTk1IDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2tleGVj LmgKPiArKysgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9rZXhlYy5oCj4gQEAgLTgzLDYgKzgzLDIw IEBAIHN0YXRpYyBpbmxpbmUgc3RydWN0IHBhZ2UgKmJvb3RfcGZuX3RvX3BhZ2UodW5zaWduZWQg bG9uZyBib290X3BmbikKPiAgfQo+ICAjZGVmaW5lIGJvb3RfcGZuX3RvX3BhZ2UgYm9vdF9wZm5f dG9fcGFnZQo+ICAKPiArI2lmZGVmIENPTkZJR19LRVhFQ19GSUxFCj4gKwo+ICtleHRlcm4gY29u c3Qgc3RydWN0IGtleGVjX2ZpbGVfb3BzIGtleGVjX3ppbWFnZV9vcHM7Cj4gK2V4dGVybiBjb25z dCBzdHJ1Y3Qga2V4ZWNfZmlsZV9vcHMga2V4ZWNfdWltYWdlX29wczsKPiArCj4gK3N0cnVjdCBr aW1hZ2U7Cj4gKwo+ICtleHRlcm4gaW50IGxvYWRfb3RoZXJfc2VnbWVudHMoc3RydWN0IGtpbWFn ZSAqaW1hZ2UsCj4gKwkJdW5zaWduZWQgbG9uZyBrZXJuZWxfbG9hZF9hZGRyLCB1bnNpZ25lZCBs b25nIGtlcm5lbF9zaXplLAo+ICsJCWNoYXIgKmluaXRyZCwgdW5zaWduZWQgbG9uZyBpbml0cmRf bGVuLAo+ICsJCXVuc2lnbmVkIGxvbmcgaW5pdHJkX29mZnNldCwgY2hhciAqY21kbGluZSk7Cj4g Kwo+ICsjZW5kaWYgLyogQ09ORklHX0tFWEVDX0ZJTEUgKi8KPiArCj4gICNlbmRpZiAvKiBfX0FT U0VNQkxZX18gKi8KPiAgCj4gICNlbmRpZiAvKiBDT05GSUdfS0VYRUMgKi8KPiBkaWZmIC0tZ2l0 IGEvYXJjaC9hcm0va2VybmVsL01ha2VmaWxlIGIvYXJjaC9hcm0va2VybmVsL01ha2VmaWxlCj4g aW5kZXggODllNWQ4NjRlOTIzLi40NjZjNjgzYmI1NTEgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm0v a2VybmVsL01ha2VmaWxlCj4gKysrIGIvYXJjaC9hcm0va2VybmVsL01ha2VmaWxlCj4gQEAgLTMs NiArMyw3IEBACj4gICMgTWFrZWZpbGUgZm9yIHRoZSBsaW51eCBrZXJuZWwuCj4gICMKPiAgCj4g K0NGTEFHU19rZXhlY196aW1hZ2UubyA6PSAtRFRFWFRfT0ZGU0VUPSQoVEVYVF9PRkZTRVQpCj4g IENQUEZMQUdTX3ZtbGludXgubGRzIDo9IC1EVEVYVF9PRkZTRVQ9JChURVhUX09GRlNFVCkKPiAg QUZMQUdTX2hlYWQubyAgICAgICAgOj0gLURURVhUX09GRlNFVD0kKFRFWFRfT0ZGU0VUKQo+ICAK PiBAQCAtNTYsNyArNTcsOSBAQCBvYmotJChDT05GSUdfRlVOQ1RJT05fVFJBQ0VSKQkrPSBlbnRy eS1mdHJhY2Uubwo+ICBvYmotJChDT05GSUdfRFlOQU1JQ19GVFJBQ0UpCSs9IGZ0cmFjZS5vIGlu c24ubyBwYXRjaC5vCj4gIG9iai0kKENPTkZJR19GVU5DVElPTl9HUkFQSF9UUkFDRVIpCSs9IGZ0 cmFjZS5vIGluc24ubyBwYXRjaC5vCj4gIG9iai0kKENPTkZJR19KVU1QX0xBQkVMKQkrPSBqdW1w X2xhYmVsLm8gaW5zbi5vIHBhdGNoLm8KPiAtb2JqLSQoQ09ORklHX0tFWEVDKQkJKz0gbWFjaGlu ZV9rZXhlYy5vIHJlbG9jYXRlX2tlcm5lbC5vCj4gK29iai0kKENPTkZJR19LRVhFQ19DT1JFKQkr PSBtYWNoaW5lX2tleGVjLm8gcmVsb2NhdGVfa2VybmVsLm8KPiArb2JqLSQoQ09ORklHX0tFWEVD X0ZJTEUpCSs9IG1hY2hpbmVfa2V4ZWNfZmlsZS5vIGtleGVjX3ppbWFnZS5vCVwKPiArCQkJCSAg IGtleGVjX3VpbWFnZS5vCj4gICMgTWFpbiBzdGFmZnMgaW4gS1BST0JFUyBhcmUgaW4gYXJjaC9h cm0vcHJvYmVzLyAuCj4gIG9iai0kKENPTkZJR19LUFJPQkVTKQkJKz0gcGF0Y2gubyBpbnNuLm8K PiAgb2JqLSQoQ09ORklHX09BQklfQ09NUEFUKQkrPSBzeXNfb2FiaS1jb21wYXQubwo+IGRpZmYg LS1naXQgYS9hcmNoL2FybS9rZXJuZWwva2V4ZWNfdWltYWdlLmMgYi9hcmNoL2FybS9rZXJuZWwv a2V4ZWNfdWltYWdlLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAw MC4uNDcwMzM1NzRlMjRlCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2FyY2gvYXJtL2tlcm5lbC9r ZXhlY191aW1hZ2UuYwo+IEBAIC0wLDAgKzEsODAgQEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50 aWZpZXI6IEdQTC0yLjAKPiArLyoKPiArICogS2V4ZWMgdUltYWdlIGxvYWRlcgo+ICsgKgo+ICsg KiBDb3B5cmlnaHQgKEMpIDIwMjAgU2Ftc3VuZyBFbGVjdHJvbmljcwo+ICsgKiBBdXRob3I6IMWB dWthc3ogU3RlbG1hY2ggPGwuc3RlbG1hY2hAc2Ftc3VuZy5jb20+Cj4gKyAqLwo+ICsKPiArI2Rl ZmluZSBwcl9mbXQoZm10KQkia2V4ZWNfZmlsZSh1SW1hZ2UpOiAiIGZtdAo+ICsKPiArI2luY2x1 ZGUgPGFzbS9pbWFnZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvY3JjMzIuaD4KPiArI2luY2x1ZGUg PGxpbnV4L2Vyci5oPgo+ICsjaW5jbHVkZSA8bGludXgva2V4ZWMuaD4KPiArCj4gKyNkZWZpbmUg Y3JjMzJfb25lcyhjcmMsIGJ1ZiwgbGVuKSBcCj4gKwkoY3JjMzIoY3JjIF4gMHhmZmZmZmZmZiwg YnVmLCBsZW4pIF4gMHhmZmZmZmZmZikKPiArCj4gK3N0YXRpYyBpbnQgdWltYWdlX3Byb2JlKGNv bnN0IGNoYXIgKnVpbWFnZV9idWYsIHVuc2lnbmVkIGxvbmcgdWltYWdlX2xlbikKPiArewo+ICsJ Y29uc3Qgc3RydWN0IGFybV91aW1hZ2VfaGVhZGVyICpoID0KPiArCQkoc3RydWN0IGFybV91aW1h Z2VfaGVhZGVyICopIHVpbWFnZV9idWY7Cj4gKwlzdHJ1Y3QgYXJtX3VpbWFnZV9oZWFkZXIgdWhk cjsKPiArCXVuc2lnbmVkIGxvbmcgem9mZiA9IHNpemVvZihzdHJ1Y3QgYXJtX3VpbWFnZV9oZWFk ZXIpOwo+ICsJdWludDMyX3QgY3JjOwo+ICsKPiArCWlmIChoLT5tYWdpYyAhPSBBUk1fVUlNQUdF X01BR0lDKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCWlmIChoLT50eXBlICE9IEFSTV9V SU1BR0VfVFlQRV9LRVJORUwgJiYKPiArCSAgICBoLT50eXBlICE9IEFSTV9VSU1BR0VfVFlQRV9L RVJORUxfTk9MT0FEKXsKPiArCQlwcl9kZWJ1ZygiSW52YWxpZCBpbWFnZSB0eXBlOiAlZFxuIiwg aC0+dHlwZSk7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJaWYgKGgtPmFyY2gg IT0gQVJNX1VJTUFHRV9BUkNIX0FSTSkgewo+ICsJCXByX2RlYnVnKCJJbnZhbGlkeSBpbWFnZSBh cmNoOiAlZFxuIiwgaC0+YXJjaCk7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJ bWVtY3B5KChjaGFyICopJnVoZHIsIGgsIHNpemVvZih1aGRyKSk7Cj4gKwljcmMgPSBiZTMyX3Rv X2NwdSh1aGRyLmhkcl9jcmMpOwo+ICsJdWhkci5oZHJfY3JjID0gMDsKPiArCj4gKwlpZiAoY3Jj MzJfb25lcygwLCAoY2hhciAqKSZ1aGRyLCBzaXplb2YodWhkcikpICE9IGNyYykgewo+ICsJCXBy X2RlYnVnKCJDb3JydXB0IGhlYWRlciwgQ1JDIGRvIG5vdCBtYXRjaFxuIik7Cj4gKwkJcmV0dXJu IC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJY3JjID0gYmUzMl90b19jcHUodWhkci5jcmMpOwo+ICsJ aWYgKGNyYzMyX29uZXMoMCwgdWltYWdlX2J1ZiArIHpvZmYsIHVpbWFnZV9sZW4gLSB6b2ZmKSAh PSBjcmMpIHsKPiArCQlwcl9kZWJ1ZygiQ29ycnVwdCB6SW1hZ2UsIENSQyBkbyBub3QgbWF0Y2hc biIpOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsJfQo+ICsKPiArCXJldHVybiBrZXhlY196aW1h Z2Vfb3BzLnByb2JlKHVpbWFnZV9idWYgKyB6b2ZmLAo+ICsJCQkJICAgICAgdWltYWdlX2xlbiAt IHpvZmYpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCAqdWltYWdlX2xvYWQoc3RydWN0IGtpbWFn ZSAqaW1hZ2UsCj4gKwkJCQljaGFyICp1aW1hZ2UsIHVuc2lnbmVkIGxvbmcgdWltYWdlX2xlbiwK PiArCQkJCWNoYXIgKmluaXRyZCwgdW5zaWduZWQgbG9uZyBpbml0cmRfbGVuLAo+ICsJCQkJY2hh ciAqY21kbGluZSwgdW5zaWduZWQgbG9uZyBjbWRsaW5lX2xlbikKPiArewo+ICsJY29uc3Qgc3Ry dWN0IGFybV91aW1hZ2VfaGVhZGVyICpoID0KPiArCQkoc3RydWN0IGFybV91aW1hZ2VfaGVhZGVy ICopIHVpbWFnZTsKPiArCXVuc2lnbmVkIGxvbmcgemltYWdlX29mZnNldCA9IHNpemVvZihzdHJ1 Y3QgYXJtX3VpbWFnZV9oZWFkZXIpOwo+ICsKPiArCXByX2RlYnVnKCJMb2FkaW5nIHVJbWFnZSIp Owo+ICsJcmV0dXJuIGtleGVjX3ppbWFnZV9vcHMubG9hZChpbWFnZSwKPiArCQkJCSAgICAgdWlt YWdlICsgemltYWdlX29mZnNldCwKPiArCQkJCSAgICAgdWltYWdlX2xlbiAtIHppbWFnZV9vZmZz ZXQsCj4gKwkJCQkgICAgIGluaXRyZCwgaW5pdHJkX2xlbiwKPiArCQkJCSAgICAgY21kbGluZSwg Y21kbGluZV9sZW4pOwo+ICt9Cj4gKwo+ICtjb25zdCBzdHJ1Y3Qga2V4ZWNfZmlsZV9vcHMga2V4 ZWNfdWltYWdlX29wcyA9IHsKPiArCS5wcm9iZSA9IHVpbWFnZV9wcm9iZSwKPiArCS5sb2FkID0g dWltYWdlX2xvYWQsCj4gK307Cj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9rZXhlY196 aW1hZ2UuYyBiL2FyY2gvYXJtL2tlcm5lbC9rZXhlY196aW1hZ2UuYwo+IG5ldyBmaWxlIG1vZGUg MTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi5kMDk3OTVmYzkwNzIKPiAtLS0gL2Rldi9udWxs Cj4gKysrIGIvYXJjaC9hcm0va2VybmVsL2tleGVjX3ppbWFnZS5jCj4gQEAgLTAsMCArMSwxOTkg QEAKPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKPiArLyoKPiArICogS2V4 ZWMgekltYWdlIGxvYWRlcgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMjAgU2Ftc3VuZyBF bGVjdHJvbmljcwo+ICsgKiBBdXRob3I6IMWBdWthc3ogU3RlbG1hY2ggPGwuc3RlbG1hY2hAc2Ft c3VuZy5jb20+CgpQbGVhc2UgY3JlZGl0IG1lIGFzIHBhcnQgYXV0aG9yIG9mIHRoaXMgLSB5b3Ug aGF2ZSB0YWtlbiBzb21lIG9mIG15CmNvZGUgZnJvbSB0aGUgdXNlcnNwYWNlIGtleGVjIHRvb2wg KHN1Y2ggYXMgdGhlIGNvbnRlbnRzIG9mCmZpbmRfZXh0ZW5zaW9uX3RhZygpKSBhbmQgY29waWVk IGl0IGluIGhlcmUsIHNvIHRoaXMgaXMgbm90IGFsbCB5b3VyCm93biB3b3JrLgoKPiArICovCj4g Kwo+ICsjZGVmaW5lIHByX2ZtdChmbXQpCSJrZXhlY19maWxlKHpJbWFnZSk6ICIgZm10Cj4gKwo+ ICsjaW5jbHVkZSA8YXNtL2ltYWdlLmg+Cj4gKyNpbmNsdWRlIDxhc20vdW5hbGlnbmVkLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9lcnIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2tleGVjLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9tZW1ibG9jay5oPgo+ICsKPiArI2RlZmluZSBieXRlX3NpemUodCkgICAg KCh0KS0+aGRyLnNpemUgPDwgMikKPiArCj4gK3N0YXRpYyBjb25zdCB2b2lkICpmaW5kX2V4dGVu c2lvbl90YWcoY29uc3QgY2hhciAqYnVmLAo+ICsJCQkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBs ZW4sCj4gKwkJCQkJCSAgICAgICB1aW50MzJfdCB0YWdfaWQpCj4gK3sKPiArCWNvbnN0IHN0cnVj dCBhcm1femltYWdlX2hlYWRlciAqaCA9IChjb25zdCBzdHJ1Y3QgYXJtX3ppbWFnZV9oZWFkZXIg KilidWY7Cj4gKwljb25zdCBzdHJ1Y3QgYXJtX3ppbWFnZV90YWcgKnRhZzsKPiArCXVpbnQzMl90 IG9mZnNldCwgc2l6ZTsKPiArCXVpbnQzMl90IG1heCA9IGxlbiAtIHNpemVvZihzdHJ1Y3QgdGFn X2hlYWRlcik7Cj4gKwo+ICsJaWYgKGxlbiA8IHNpemVvZigqaCkgfHwKPiArCSAgICBoLT5tYWdp YyAhPSBBUk1fWklNQUdFX01BR0lDMSB8fAo+ICsJICAgIGgtPm1hZ2ljMiAhPSBBUk1fWklNQUdF X01BR0lDMikKPiArCQlyZXR1cm4gTlVMTDsKPiArCj4gKwlmb3IgKG9mZnNldCA9IGgtPmV4dGVu c2lvbl90YWdfb2Zmc2V0Owo+ICsJICAgICAodGFnID0gKHZvaWQgKikoYnVmICsgb2Zmc2V0KSkg IT0gTlVMTCAmJgo+ICsJCSAgICAgb2Zmc2V0IDwgbWF4ICYmCj4gKwkJICAgICAoc2l6ZSA9IGxl MzJfdG9fY3B1KGJ5dGVfc2l6ZSh0YWcpKSkgIT0gMCAmJgo+ICsJCSAgICAgb2Zmc2V0ICsgc2l6 ZSA8IGxlbjsKPiArCSAgICAgb2Zmc2V0ICs9IHNpemUpIHsKPiArCQlwcl9kZWJ1ZygiICBvZmZz ZXQgMHglMDh4IHRhZyAweCUwOHggc2l6ZSAldVxuIiwKPiArCQkJICBvZmZzZXQsIGxlMzJfdG9f Y3B1KHRhZy0+aGRyLnRhZyksIHNpemUpOwo+ICsJCWlmICh0YWctPmhkci50YWcgPT0gdGFnX2lk KQo+ICsJCQlyZXR1cm4gdGFnOwo+ICsJfQo+ICsKPiArCXJldHVybiBOVUxMOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW50IHppbWFnZV9wcm9iZShjb25zdCBjaGFyICprZXJuZWxfYnVmLCB1bnNpZ25l ZCBsb25nIGtlcm5lbF9sZW4pCj4gK3sKPiArCWNvbnN0IHN0cnVjdCBhcm1femltYWdlX2hlYWRl ciAqaCA9Cj4gKwkJKHN0cnVjdCBhcm1femltYWdlX2hlYWRlciAqKShrZXJuZWxfYnVmKTsKPiAr Cj4gKwlpZiAoIWggfHwgKGtlcm5lbF9sZW4gPCBzaXplb2YoKmgpKSkKPiArCQlyZXR1cm4gLUVJ TlZBTDsKPiArCj4gKwlpZiAoKGgtPm1hZ2ljICE9IEFSTV9aSU1BR0VfTUFHSUMxKSB8fAo+ICsJ ICAgIChoLT5tYWdpYzIgIT0gQVJNX1pJTUFHRV9NQUdJQzIpKQo+ICsJCXJldHVybiAtRUlOVkFM Owo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICsKPiArI2lmIGRlZmluZWQoREVCVUcpCj4g KyNkZWZpbmUgZGVidWdfb2Zmc2V0cygpICh7CQkJXAo+ICsJcHJfZGVidWcoIkltYWdlIG9mZnNl dHM6XG4iKTsJCVwKPiArCXByX2RlYnVnKCIgIGtlcm5lbCAweCUwOGx4IDB4JTA4bHhcbiIsIGtl cm5lbF9vZmZzZXQsIGtlcm5lbF9sZW4pOyBcCj4gKwlwcl9kZWJ1ZygiICB6aW1hZ2UgMHglMDhs eCAweCUwOGx4XG4iLCB6aW1hZ2Vfb2Zmc2V0LCB6aW1hZ2VfbGVuKTsgXAo+ICsJcHJfZGVidWco IiAgaW5pdHJkIDB4JTA4bHggMHglMDhseFxuIiwgaW5pdHJkX29mZnNldCwgaW5pdHJkX2xlbik7 IFwKPiArfSkKPiArI2Vsc2UKPiArI2RlZmluZSBkZWJ1Z19vZmZzZXRzKCkKPiArI2VuZGlmCj4g Kwo+ICtzdGF0aWMgdm9pZCAqemltYWdlX2xvYWQoc3RydWN0IGtpbWFnZSAqaW1hZ2UsCj4gKwkJ CQljaGFyICp6aW1hZ2UsIHVuc2lnbmVkIGxvbmcgemltYWdlX2xlbiwKPiArCQkJCWNoYXIgKmlu aXRyZCwgdW5zaWduZWQgbG9uZyBpbml0cmRfbGVuLAo+ICsJCQkJY2hhciAqY21kbGluZSwgdW5z aWduZWQgbG9uZyBjbWRsaW5lX2xlbikKPiArewo+ICsJc3RydWN0IGFybV96aW1hZ2VfaGVhZGVy ICpoOwo+ICsJc3RydWN0IGtleGVjX2J1ZiBrYnVmOwo+ICsJc3RydWN0IGtleGVjX3NlZ21lbnQg KnppbWFnZV9zZWdtZW50Owo+ICsJY29uc3Qgc3RydWN0IGFybV96aW1hZ2VfdGFnICprbHN6X3Rh ZzsKPiArCWNvbnN0IHN0cnVjdCBhcm1femltYWdlX3RhZ19kYyAqZGNzel90YWc7Cj4gKwlpbnQg cmV0ID0gLUVJTlZBTDsKPiArCj4gKwl1bnNpZ25lZCBsb25nIHppbWFnZV9tZW0gPSAweDIwMDAw OyAvKiBtYWxsb2MgNjRrQiArIHN0YWNrIDQga0IgKyBzb21lIGJzcyAqLwo+ICsJdW5zaWduZWQg bG9uZyBrZXJuZWxfbGVuID0gemltYWdlX2xlbiAqIDQ7IC8qIDQ6MSBjb21wcmVzc2lvbiAqLwoK VGhpcyBoYXMgYmVlbiBwcm92ZW4gd3JvbmcuCgo+ICsJdW5zaWduZWQgbG9uZyBrZXJuZWxfb2Zm c2V0ID0gbWVtYmxvY2tfc3RhcnRfb2ZfRFJBTSgpICsKPiArCQlBTElHTihURVhUX09GRlNFVCwg UEFHRV9TSVpFKTsKClRFWFRfT0ZGU0VUIGlzIGFjdHVhbGx5IGEgcHJvcGVydHkgb2YgdGhlIGxv YWRlZCBrZXJuZWwsIG5vdCBvZiB0aGUKY3VycmVudGx5IHJ1bm5pbmcga2VybmVsLiAgSSBoYXZl IGEgcGF0Y2ggdG8gYWRkIHRoYXQgaW50byB0aGUgekltYWdlCnRhZy4KCj4gKwl1bnNpZ25lZCBs b25nIHppbWFnZV9vZmZzZXQgPSBrZXJuZWxfb2Zmc2V0ICsKPiArCQlBTElHTihrZXJuZWxfbGVu LCBQQUdFX1NJWkUpOwo+ICsJdW5zaWduZWQgbG9uZyBpbml0cmRfb2Zmc2V0ID0gemltYWdlX29m ZnNldCArCj4gKwkJQUxJR04oemltYWdlX2xlbiArIHppbWFnZV9tZW0sIFBBR0VfU0laRSk7CgpT aW5jZSBrZXJuZWxfbGVuIGlzIHdyb25nLCB0aGVzZSB3aWxsIGJlIHdyb25nLi4uIHBsZWFzZSBv bmx5IGZhbGwKYmFjayB0byB0aGlzIGlmIHlvdSBkb24ndCBmaW5kIHRoZSBleHRlbnNpb24gdGFn IC0gaW4gb3RoZXIgd29yZHMsCmRlY2xhcmUgdGhlIHZhcmlhYmxlcyBoZXJlLCBidXQgZG9uJ3Qg aW5pdGlhbGlzZSB0aGVtLCBzZXQgdGhlbQpsb3dlciBkb3duIGluIHRoZSBmaWxlIGlmIHdlIGZh aWwgdG8gZmluZCB0aGUgZXh0ZW5zaW9uIHRhZy4KCj4gKwo+ICsJaWYgKGltYWdlLT50eXBlID09 IEtFWEVDX1RZUEVfQ1JBU0gpIHsKPiArCQlrZXJuZWxfb2Zmc2V0ICs9IGNyYXNoa19yZXMuc3Rh cnQ7Cj4gKwkJemltYWdlX29mZnNldCArPSBjcmFzaGtfcmVzLnN0YXJ0Owo+ICsJCWluaXRyZF9v ZmZzZXQgKz0gY3Jhc2hrX3Jlcy5zdGFydDsKPiArCX0KPiArCWRlYnVnX29mZnNldHMoKTsKPiAr Cj4gKwloID0gKHN0cnVjdCBhcm1femltYWdlX2hlYWRlciAqKXppbWFnZTsKPiArCj4gKwlrbHN6 X3RhZyA9IGZpbmRfZXh0ZW5zaW9uX3RhZyh6aW1hZ2UsIHppbWFnZV9sZW4sIFpJTUFHRV9UQUdf S1JOTF9TSVpFKTsKPiArCWlmIChrbHN6X3RhZykgewo+ICsJCXVpbnQzMl90ICpwID0gKHZvaWQg Kil6aW1hZ2UgKwo+ICsJCQlsZTMyX3RvX2NwdShrbHN6X3RhZy0+dS5rcm5sX3NpemUuc2l6ZV9w dHIpOwo+ICsJCXVpbnQzMl90IGVkYXRhX3NpemUgPSBsZTMyX3RvX2NwdShnZXRfdW5hbGlnbmVk KHApKTsKPiArCQl1aW50MzJfdCBic3Nfc2l6ZSA9IGxlMzJfdG9fY3B1KGtsc3pfdGFnLT51Lmty bmxfc2l6ZS5ic3Nfc2l6ZSk7Cj4gKwo+ICsJCWtlcm5lbF9sZW4gPSBlZGF0YV9zaXplICsgYnNz X3NpemU7Cj4gKwo+ICsJCXByX2RlYnVnKCJEZWNvbXByZXNzZWQga2VybmVsIHNpemVzOlxuIik7 Cj4gKwkJcHJfZGVidWcoIiB0ZXh0K2RhdGEgMHglMDhseCBic3MgMHglMDhseCB0b3RhbCAweCUw OGx4XG4iLAo+ICsJCQkgKHVuc2lnbmVkIGxvbmcpZWRhdGFfc2l6ZSwKPiArCQkJICh1bnNpZ25l ZCBsb25nKWJzc19zaXplLAo+ICsJCQkgKHVuc2lnbmVkIGxvbmcpa2VybmVsX2xlbik7Cj4gKwo+ ICsJCXppbWFnZV9vZmZzZXQgPSBrZXJuZWxfb2Zmc2V0ICsgQUxJR04oZWRhdGFfc2l6ZSwgUEFH RV9TSVpFKTsKPiArCQlpbml0cmRfb2Zmc2V0ID0gemltYWdlX29mZnNldCArCj4gKwkJCW1heChB TElHTih6aW1hZ2VfbGVuICsgMHgyMDAwMCwgUEFHRV9TSVpFKSwKPiArCQkJICAgIEFMSUdOKCh1 bnNpZ25lZCBsb25nKWJzc19zaXplLCBQQUdFX1NJWkUpKTsKPiArCQlkZWJ1Z19vZmZzZXRzKCk7 CgpUaGlzIGxvb2tzIGluY29ycmVjdCB0byBtZS4gIFBsZWFzZSBzZWUgdGhlIGtleGVjIHRvb2wg LSB3aGF0IGl0cyBkb2luZwppbiBpdHMgY29ycmVzcG9uZGluZyBzZWN0aW9uIHRoYXQgeW91IGNv cGllZCBzb21lIG9mIHRoaXMgY29kZSBmcm9tIGlzCmNhcmVmdWxseSB0aG91Z2h0IG91dCBhbmQg Y2FuJ3QgYmUgc2ltcGxpZmllZC4gIEVyZ28sIEkgdGhpbmsgdGhpcyBpcwp3cm9uZy4KCj4gKwl9 Cj4gKwo+ICsJZGNzel90YWcgPSBmaW5kX2V4dGVuc2lvbl90YWcoemltYWdlLCB6aW1hZ2VfbGVu LAo+ICsJCQkJICAgICAgWklNQUdFX1RBR19ERUNPTVBfU0laRSk7Cj4gKwlpZiAoZGNzel90YWcp IHsKPiArCQl1aW50MzJfdCBic3Nfc2l6ZSA9IGxlMzJfdG9fY3B1KGRjc3pfdGFnLT51LmRlY29t cF9zaXplLmJzc19zaXplKTsKPiArCQl1aW50MzJfdCBzdGFja19zaXplID0gbGUzMl90b19jcHUo ZGNzel90YWctPnUuZGVjb21wX3NpemUuc3RhY2tfc2l6ZSk7Cj4gKwkJdWludDMyX3QgbWFsbG9j X3NpemUgPSBsZTMyX3RvX2NwdShkY3N6X3RhZy0+dS5kZWNvbXBfc2l6ZS5tYWxsb2Nfc2l6ZSk7 Cj4gKwo+ICsJCXppbWFnZV9tZW0gPSBic3Nfc2l6ZSArIHN0YWNrX3NpemUgKyBtYWxsb2Nfc2l6 ZTsKPiArCj4gKwkJcHJfZGVidWcoIkRlY29tcHJlc3NvciBtZW1vcnkgcmVxdWlyZW1lbnRzOlxu Iik7Cj4gKwkJcHJfZGVidWcoIiBic3MgMHglMDhseCBzdGFjayAweCUwOGx4IG1hbGxvYyAweCUw OGx4IHRvdGFsIDB4JTA4bHhcbiIsCj4gKwkJCSAodW5zaWduZWQgbG9uZylic3Nfc2l6ZSwKPiAr CQkJICh1bnNpZ25lZCBsb25nKXN0YWNrX3NpemUsCj4gKwkJCSAodW5zaWduZWQgbG9uZyltYWxs b2Nfc2l6ZSwKPiArCQkJIHppbWFnZV9tZW0pOwo+ICsKPiArCQlpbml0cmRfb2Zmc2V0ID0gbWF4 KEFMSUdOKHppbWFnZV9vZmZzZXQgKyB6aW1hZ2VfbGVuICsKPiArCQkJCQkgIGJzc19zaXplICsg c3RhY2tfc2l6ZSArCj4gKwkJCQkJICBtYWxsb2Nfc2l6ZSwgUEFHRV9TSVpFKSwKPiArCQkJCSAg ICBBTElHTihrZXJuZWxfb2Zmc2V0ICsga2VybmVsX2xlbiwgUEFHRV9TSVpFKSk7Cj4gKwkJZGVi dWdfb2Zmc2V0cygpOwo+ICsJfQo+ICsKPiArCS8qCj4gKwkgKiB6SW1hZ2UgTVVTVCBiZSBsb2Fk ZWQgaW50byB0aGUgZmlyc3QgMTI4IE1pQiBvZiBwaHlzaWNhbAo+ICsJICogbWVtb3J5IGZvciBw cm9wZXIgbWVtb3J5IGRldGVjdGlvbi4gU2hvdWxkIHRoZSB1bmNvbXByZXNzZWQKPiArCSAqIGtl cm5lbCBiZSBsYXJnZXIgdGhhbiAxMjggTWlCLCB6SW1hZ2UgcmVsb2NhdGlvbiBiZWNvbWVzCj4g KwkgKiB1bmF2b2lkYWJsZSBhbmQgaXQgaXMgYmVzdCB0byByZWx5IG9uIHRoZSByZWxvY2F0aW9u IGNvZGUuCj4gKwkgKi8KPiArCWlmICgoKHppbWFnZV9vZmZzZXQgLSBrZXJuZWxfb2Zmc2V0KSAr IFBBR0VfU0laRSArIDB4ODAwMCkgPj0gU1pfMTI4TSkgewo+ICsJCXByX2RlYnVnKCJUaGUga2Vy bmVsIGlzIHRvbyBiaWcgKCVsZCBNaUIpIHRvIGF2b2lkICIKPiArCQkJICJ6SW1hZ2UgcmVsb2Nh dGlvbi4gTG9hZGluZyB6aW1hZ2UgYXQgMHglMDhseFxuIiwKPiArCQkJICgoemltYWdlX29mZnNl dCAtIGtlcm5lbF9vZmZzZXQpID4+IDIwKSwKPiArCQkJIGtlcm5lbF9vZmZzZXQpOwo+ICsJCXpp bWFnZV9vZmZzZXQgPSBrZXJuZWxfb2Zmc2V0Owo+ICsJfQo+ICsKPiArCWtidWYuaW1hZ2UgPSBp bWFnZTsKPiArCWtidWYudG9wX2Rvd24gPSBmYWxzZTsKPiArCj4gKwlrYnVmLmJ1Zl9taW4gPSB6 aW1hZ2Vfb2Zmc2V0Owo+ICsJa2J1Zi5idWZfbWF4ID0gVUxPTkdfTUFYOwo+ICsJa2J1Zi5idWZm ZXIgPSB6aW1hZ2U7Cj4gKwlrYnVmLmJ1ZnN6ID0gemltYWdlX2xlbjsKPiArCWtidWYuYnVmX2Fs aWduID0gUEFHRV9TSVpFOwo+ICsKPiArCWtidWYubWVtID0gS0VYRUNfQlVGX01FTV9VTktOT1dO Owo+ICsJa2J1Zi5tZW1zeiA9IHppbWFnZV9sZW47Cj4gKwo+ICsJcmV0ID0ga2V4ZWNfYWRkX2J1 ZmZlcigma2J1Zik7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiBFUlJfUFRSKHJldCk7Cj4gKwo+ ICsJcHJfZGVidWcoIkxvYWRlZCB6SW1hZ2UgYXQgMHglbHggYnVmc3o9MHglbHggbWVtc3o9MHgl bHhcbiIsCj4gKwkJIGtidWYubWVtLCBrYnVmLmJ1ZnN6LCBrYnVmLm1lbXN6KTsKPiArCj4gKwlp bml0cmRfb2Zmc2V0ICs9IGtidWYubWVtIC0gemltYWdlX29mZnNldDsKPiArCWRlYnVnX29mZnNl dHMoKTsKPiArCj4gKwl6aW1hZ2Vfc2VnbWVudCA9ICZpbWFnZS0+c2VnbWVudFtpbWFnZS0+bnJf c2VnbWVudHMgLSAxXTsKPiArCWltYWdlLT5zdGFydCA9IHppbWFnZV9zZWdtZW50LT5tZW07Cj4g Kwo+ICsJcmV0ID0gbG9hZF9vdGhlcl9zZWdtZW50cyhpbWFnZSwKPiArCQkJCSAgemltYWdlX3Nl Z21lbnQtPm1lbSwgemltYWdlX3NlZ21lbnQtPm1lbXN6LAo+ICsJCQkJICBpbml0cmQsIGluaXRy ZF9sZW4sIGluaXRyZF9vZmZzZXQsCj4gKwkJCQkgIGNtZGxpbmUpOwo+ICsJcmV0dXJuIEVSUl9Q VFIocmV0KTsKPiArfQo+ICsKPiArY29uc3Qgc3RydWN0IGtleGVjX2ZpbGVfb3BzIGtleGVjX3pp bWFnZV9vcHMgPSB7Cj4gKwkucHJvYmUgPSB6aW1hZ2VfcHJvYmUsCj4gKwkubG9hZCA9IHppbWFn ZV9sb2FkLAo+ICt9Owo+IGRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhl Yy5jIGIvYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWMuYwo+IGluZGV4IGMxMGEyZGZkNTNk MS4uMmU0NzgwZWZhYmI0IDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtL2tlcm5lbC9tYWNoaW5lX2tl eGVjLmMKPiArKysgYi9hcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhlYy5jCj4gQEAgLTkzLDEw ICs5MywxMyBAQCBpbnQgbWFjaGluZV9rZXhlY19wcmVwYXJlKHN0cnVjdCBraW1hZ2UgKmltYWdl KQo+ICAJCQkJCSAgICAgICBjdXJyZW50X3NlZ21lbnQtPm1lbXN6KSkKPiAgCQkJcmV0dXJuIC1F SU5WQUw7Cj4gIAo+IC0JCWVyciA9IGdldF91c2VyKGhlYWRlciwgKF9fYmUzMiopY3VycmVudF9z ZWdtZW50LT5idWYpOwo+IC0JCWlmIChlcnIpCj4gLQkJCXJldHVybiBlcnI7Cj4gLQo+ICsJCWlm IChpbWFnZS0+ZmlsZV9tb2RlKSB7Cj4gKwkJCWhlYWRlciA9ICooX19iZTMyICopY3VycmVudF9z ZWdtZW50LT5idWY7Cj4gKwkJfSBlbHNlIHsKPiArCQkJZXJyID0gZ2V0X3VzZXIoaGVhZGVyLCAo X19iZTMyICopY3VycmVudF9zZWdtZW50LT5idWYpOwo+ICsJCQlpZiAoZXJyKQo+ICsJCQkJcmV0 dXJuIGVycjsKPiArCQl9Cj4gIAkJaWYgKGhlYWRlciA9PSBjcHVfdG9fYmUzMihPRl9EVF9IRUFE RVIpKQo+ICAJCQlpbWFnZS0+YXJjaC5rZXJuZWxfcjIgPSBjdXJyZW50X3NlZ21lbnQtPm1lbTsK PiAgCX0KPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5j IGIvYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jCj4gbmV3IGZpbGUgbW9kZSAx MDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmVhZDY4MGYxZTc5NQo+IC0tLSAvZGV2L251bGwK PiArKysgYi9hcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhlY19maWxlLmMKPiBAQCAtMCwwICsx LDIwOSBAQAo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+ICsvKgo+ICsg KiBrZXhlY19maWxlIGZvciBhcm0KPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDE4IExpbmFy byBMaW1pdGVkCj4gKyAqIENvcHlyaWdodCAoQykgMjAyMCBTYW1zdW5nIEVsZWN0cm9uaWNzCj4g KyAqIEF1dGhvcnM6Cj4gKyAqICAgICBBS0FTSEkgVGFrYWhpcm8gPHRha2FoaXJvLmFrYXNoaUBs aW5hcm8ub3JnPgo+ICsgKiAgICAgxYF1a2FzeiBTdGVsbWFjaCA8bC5zdGVsbWFjaEBzYW1zdW5n LmNvbT4KPiArICoKPiArICovCj4gKwo+ICsjZGVmaW5lIHByX2ZtdChmbXQpICJrZXhlY19maWxl OiAiIGZtdAo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2tleGVjLmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9saWJmZHQuaD4KPiArI2luY2x1ZGUgPGxpbnV4L29mX2ZkdC5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvcmFuZG9tLmg+Cj4gKwo+ICsvKiByZWxldmFudCBkZXZpY2UgdHJlZSBwcm9wZXJ0aWVzICov Cj4gKyNkZWZpbmUgRkRUX1BST1BfSU5JVFJEX1NUQVJUCSJsaW51eCxpbml0cmQtc3RhcnQiCj4g KyNkZWZpbmUgRkRUX1BST1BfSU5JVFJEX0VORAkibGludXgsaW5pdHJkLWVuZCIKPiArI2RlZmlu ZSBGRFRfUFJPUF9CT09UQVJHUwkiYm9vdGFyZ3MiCj4gKyNkZWZpbmUgRkRUX1BST1BfUk5HX1NF RUQJInJuZy1zZWVkIgo+ICsKPiArc3RhdGljIGludCBzZXR1cF9kdGIoc3RydWN0IGtpbWFnZSAq aW1hZ2UsCj4gKwkJICAgICB1bnNpZ25lZCBsb25nIGluaXRyZF9sb2FkX2FkZHIsIHVuc2lnbmVk IGxvbmcgaW5pdHJkX2xlbiwKPiArCQkgICAgIGNoYXIgKmNtZGxpbmUsIHZvaWQgKmR0YikKPiAr ewo+ICsJaW50IG9mZiwgcmV0Owo+ICsKPiArCXJldCA9IGZkdF9wYXRoX29mZnNldChkdGIsICIv Y2hvc2VuIik7Cj4gKwlpZiAocmV0IDwgMCkKPiArCQlnb3RvIG91dDsKPiArCj4gKwlvZmYgPSBy ZXQ7Cj4gKwo+ICsJLyogYWRkIGJvb3RhcmdzICovCj4gKwlpZiAoY21kbGluZSkgewo+ICsJCXJl dCA9IGZkdF9zZXRwcm9wX3N0cmluZyhkdGIsIG9mZiwgRkRUX1BST1BfQk9PVEFSR1MsIGNtZGxp bmUpOwo+ICsJCWlmIChyZXQpCj4gKwkJCWdvdG8gb3V0Owo+ICsJfSBlbHNlIHsKPiArCQlyZXQg PSBmZHRfZGVscHJvcChkdGIsIG9mZiwgRkRUX1BST1BfQk9PVEFSR1MpOwo+ICsJCWlmIChyZXQg JiYgKHJldCAhPSAtRkRUX0VSUl9OT1RGT1VORCkpCj4gKwkJCWdvdG8gb3V0Owo+ICsJfQo+ICsK PiArCS8qIGFkZCBpbml0cmQtKiAqLwo+ICsJaWYgKGluaXRyZF9sb2FkX2FkZHIpIHsKPiArCQly ZXQgPSBmZHRfc2V0cHJvcF91NjQoZHRiLCBvZmYsIEZEVF9QUk9QX0lOSVRSRF9TVEFSVCwKPiAr CQkJCSAgICAgIGluaXRyZF9sb2FkX2FkZHIpOwo+ICsJCWlmIChyZXQpCj4gKwkJCWdvdG8gb3V0 Owo+ICsKPiArCQlyZXQgPSBmZHRfc2V0cHJvcF91NjQoZHRiLCBvZmYsIEZEVF9QUk9QX0lOSVRS RF9FTkQsCj4gKwkJCQkgICAgICBpbml0cmRfbG9hZF9hZGRyICsgaW5pdHJkX2xlbik7Cj4gKwkJ aWYgKHJldCkKPiArCQkJZ290byBvdXQ7Cj4gKwl9IGVsc2Ugewo+ICsJCXJldCA9IGZkdF9kZWxw cm9wKGR0Yiwgb2ZmLCBGRFRfUFJPUF9JTklUUkRfU1RBUlQpOwo+ICsJCWlmIChyZXQgJiYgKHJl dCAhPSAtRkRUX0VSUl9OT1RGT1VORCkpCj4gKwkJCWdvdG8gb3V0Owo+ICsKPiArCQlyZXQgPSBm ZHRfZGVscHJvcChkdGIsIG9mZiwgRkRUX1BST1BfSU5JVFJEX0VORCk7Cj4gKwkJaWYgKHJldCAm JiAocmV0ICE9IC1GRFRfRVJSX05PVEZPVU5EKSkKPiArCQkJZ290byBvdXQ7Cj4gKwl9Cj4gKwo+ ICsJLyogYWRkIHJuZy1zZWVkICovCj4gKwlpZiAocm5nX2lzX2luaXRpYWxpemVkKCkpIHsKPiAr CQljaGFyIHNlZWRbMTI4XTsKPiArCQlnZXRfcmFuZG9tX2J5dGVzKHNlZWQsIHNpemVvZihzZWVk KSk7Cj4gKwo+ICsJCXJldCA9IGZkdF9zZXRwcm9wKGR0Yiwgb2ZmLCBGRFRfUFJPUF9STkdfU0VF RCwKPiArCQkJCSAgc2VlZCwgc2l6ZW9mKHNlZWQpKTsKPiArCQlpZiAocmV0KQo+ICsJCQlnb3Rv IG91dDsKPiArCX0gZWxzZSB7Cj4gKwkJcHJfbm90aWNlKCJSTkcgaXMgbm90IGluaXRpYWxpc2Vk OiBvbWl0dGluZyBcIiVzXCIgcHJvcGVydHlcbiIsCj4gKwkJCQlGRFRfUFJPUF9STkdfU0VFRCk7 Cj4gKwkJcmV0ID0gMDsKPiArCX0KPiArCj4gK291dDoKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJu IChyZXQgPT0gLUZEVF9FUlJfTk9TUEFDRSkgPyAtRU5PTUVNIDogLUVJTlZBTDsKPiArCj4gKwly ZXR1cm4gMDsKPiArfQo+ICsvKgo+ICsgKiBNb3JlIHNwYWNlIG5lZWRlZCBzbyB0aGF0IHdlIGNh biBhZGQgaW5pdHJkLCBib290YXJncyBhbmQga2FzbHItc2VlZC4KPiArICovCj4gKyNkZWZpbmUg RFRCX0VYVFJBX1NQQUNFIDB4MTAwMAo+ICsKPiArc3RhdGljIGludCBjcmVhdGVfZHRiKHN0cnVj dCBraW1hZ2UgKmltYWdlLAo+ICsJCSAgICAgIHVuc2lnbmVkIGxvbmcgaW5pdHJkX2xvYWRfYWRk ciwgdW5zaWduZWQgbG9uZyBpbml0cmRfbGVuLAo+ICsJCSAgICAgIGNoYXIgKmNtZGxpbmUsIHZv aWQgKipkdGIpCj4gK3sKPiArCXZvaWQgKmJ1ZjsKPiArCXNpemVfdCBidWZfc2l6ZTsKPiArCXNp emVfdCBjbWRsaW5lX2xlbjsKPiArCWludCByZXQ7Cj4gKwo+ICsJY21kbGluZV9sZW4gPSBjbWRs aW5lID8gc3RybGVuKGNtZGxpbmUpIDogMDsKPiArCWJ1Zl9zaXplID0gZmR0X3RvdGFsc2l6ZShp bml0aWFsX2Jvb3RfcGFyYW1zKQo+ICsJCQkrIGNtZGxpbmVfbGVuICsgRFRCX0VYVFJBX1NQQUNF Owo+ICsKPiArCWZvciAoOzspIHsKPiArCQlidWYgPSB2bWFsbG9jKGJ1Zl9zaXplKTsKPiArCQlp ZiAoIWJ1ZikKPiArCQkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJCS8qIGR1cGxpY2F0ZSBhIGRl dmljZSB0cmVlIGJsb2IgKi8KPiArCQlyZXQgPSBmZHRfb3Blbl9pbnRvKGluaXRpYWxfYm9vdF9w YXJhbXMsIGJ1ZiwgYnVmX3NpemUpOwo+ICsJCWlmIChyZXQpCj4gKwkJCXJldHVybiAtRUlOVkFM Owo+ICsKPiArCQlyZXQgPSBzZXR1cF9kdGIoaW1hZ2UsIGluaXRyZF9sb2FkX2FkZHIsIGluaXRy ZF9sZW4sCj4gKwkJCQljbWRsaW5lLCBidWYpOwo+ICsJCWlmIChyZXQpIHsKPiArCQkJdmZyZWUo YnVmKTsKPiArCQkJaWYgKHJldCA9PSAtRU5PTUVNKSB7Cj4gKwkJCQkvKiB1bmxpa2VseSwgYnV0 IGp1c3QgaW4gY2FzZSAqLwo+ICsJCQkJYnVmX3NpemUgKz0gRFRCX0VYVFJBX1NQQUNFOwo+ICsJ CQkJY29udGludWU7Cj4gKwkJCX0gZWxzZSB7Cj4gKwkJCQlyZXR1cm4gcmV0Owo+ICsJCQl9Cj4g KwkJfQo+ICsKPiArCQkvKiB0cmltIGl0ICovCj4gKwkJZmR0X3BhY2soYnVmKTsKPiArCQkqZHRi ID0gYnVmOwo+ICsKPiArCQlyZXR1cm4gMDsKPiArCX0KPiArfQo+ICsKPiAraW50IGxvYWRfb3Ro ZXJfc2VnbWVudHMoc3RydWN0IGtpbWFnZSAqaW1hZ2UsCj4gKwkJCXVuc2lnbmVkIGxvbmcgemlt YWdlX2xvYWRfYWRkciwKPiArCQkJdW5zaWduZWQgbG9uZyB6aW1hZ2VfbGVuLAo+ICsJCQljaGFy ICppbml0cmQsCj4gKwkJCXVuc2lnbmVkIGxvbmcgaW5pdHJkX2xlbiwKPiArCQkJdW5zaWduZWQg bG9uZyBpbml0cmRfb2Zmc2V0LAo+ICsJCQljaGFyICpjbWRsaW5lKQo+ICt7Cj4gKwlzdHJ1Y3Qg a2V4ZWNfYnVmIGtidWY7Cj4gKwl2b2lkICpkdGIgPSBOVUxMOwo+ICsJdW5zaWduZWQgbG9uZyBp bml0cmRfbG9hZF9hZGRyID0gMDsKPiArCXVuc2lnbmVkIGxvbmcgZHRiX2xlbjsKPiArCWludCBy ZXQgPSAwOwo+ICsKPiArCWtidWYuaW1hZ2UgPSBpbWFnZTsKPiArCS8qIG5vdCBhbGxvY2F0ZSBh bnl0aGluZyBiZWxvdyB0aGUga2VybmVsICovCj4gKwlrYnVmLmJ1Zl9taW4gPSBpbml0cmRfb2Zm c2V0Owo+ICsJaWYgKGluaXRyZCkgewo+ICsJCWtidWYuYnVmZmVyID0gaW5pdHJkOwo+ICsJCWti dWYuYnVmc3ogPSBpbml0cmRfbGVuOwo+ICsJCWtidWYubWVtID0gS0VYRUNfQlVGX01FTV9VTktO T1dOOwo+ICsJCWtidWYubWVtc3ogPSBpbml0cmRfbGVuOwo+ICsJCWtidWYuYnVmX2FsaWduID0g UEFHRV9TSVpFOwo+ICsJCWtidWYuYnVmX21heCA9IFVMT05HX01BWDsKPiArCQlrYnVmLnRvcF9k b3duID0gZmFsc2U7Cj4gKwo+ICsJCXJldCA9IGtleGVjX2FkZF9idWZmZXIoJmtidWYpOwo+ICsJ CWlmIChyZXQpCj4gKwkJCWdvdG8gb3V0X2VycjsKPiArCj4gKwkJcHJfZGVidWcoIkxvYWRlZCBp bml0cmQgYXQgMHglbHggYnVmc3o9MHglbHggbWVtc3o9MHglbHhcbiIsCj4gKwkJCQlrYnVmLm1l bSwga2J1Zi5idWZzeiwga2J1Zi5tZW1zeik7Cj4gKwo+ICsJCWluaXRyZF9sb2FkX2FkZHIgPSBr YnVmLm1lbTsKPiArCQlrYnVmLmJ1Zl9taW4gPSBpbml0cmRfbG9hZF9hZGRyICsga2J1Zi5tZW1z ejsKPiArCX0KPiArCj4gKwkvKiBsb2FkIGR0YiAqLwo+ICsJcmV0ID0gY3JlYXRlX2R0YihpbWFn ZSwgaW5pdHJkX2xvYWRfYWRkciwgaW5pdHJkX2xlbiwgY21kbGluZSwgJmR0Yik7Cj4gKwlpZiAo cmV0KSB7Cj4gKwkJcHJfZXJyKCJQcmVwYXJpbmcgZm9yIG5ldyBkdGIgZmFpbGVkXG4iKTsKPiAr CQlnb3RvIG91dF9lcnI7Cj4gKwl9Cj4gKwo+ICsJZHRiX2xlbiA9IGZkdF90b3RhbHNpemUoZHRi KTsKPiArCWtidWYuYnVmZmVyID0gZHRiOwo+ICsJa2J1Zi5idWZzeiA9IGR0Yl9sZW47Cj4gKwlr YnVmLm1lbSA9IEtFWEVDX0JVRl9NRU1fVU5LTk9XTjsKPiArCWtidWYubWVtc3ogPSBkdGJfbGVu Owo+ICsJa2J1Zi5idWZfYWxpZ24gPSBQQUdFX1NJWkU7Cj4gKwlrYnVmLmJ1Zl9tYXggPSBVTE9O R19NQVg7Cj4gKwlrYnVmLnRvcF9kb3duID0gZmFsc2U7Cj4gKwo+ICsJcmV0ID0ga2V4ZWNfYWRk X2J1ZmZlcigma2J1Zik7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gb3V0X2VycjsKPiArCj4gKwlw cl9kZWJ1ZygiTG9hZGVkIGR0YiBhdCAweCVseCBidWZzej0weCVseCBtZW1zej0weCVseFxuIiwK PiArCQkga2J1Zi5tZW0sIGtidWYuYnVmc3osIGtidWYubWVtc3opOwo+ICsJcmV0dXJuIDA7Cj4g K291dF9lcnI6Cj4gKwl2ZnJlZShkdGIpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArY29u c3Qgc3RydWN0IGtleGVjX2ZpbGVfb3BzICogY29uc3Qga2V4ZWNfZmlsZV9sb2FkZXJzW10gPSB7 Cj4gKwkma2V4ZWNfdWltYWdlX29wcywKPiArCSZrZXhlY196aW1hZ2Vfb3BzLAo+ICsJTlVMTAo+ ICt9Owo+IC0tIAo+IDIuMjYuMgo+IAo+IAoKLS0gClJNSydzIFBhdGNoIHN5c3RlbTogaHR0cHM6 Ly93d3cuYXJtbGludXgub3JnLnVrL2RldmVsb3Blci9wYXRjaGVzLwpGVFRDIGZvciAwLjhtIChl c3QuIDE3NjJtKSBsaW5lIGluIHN1YnVyYmlhOiBzeW5jIGF0IDEzLjFNYnBzIGRvd24gNDI0a2Jw cyB1cAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGlu dXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRl YWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgt YXJtLWtlcm5lbAo= 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=-5.3 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,UNWANTED_LANGUAGE_BODY,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 8D2A3C433E0 for ; Mon, 1 Jun 2020 15:08:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4E07820738 for ; Mon, 1 Jun 2020 15:08:09 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=armlinux.org.uk header.i=@armlinux.org.uk header.b="G8VBKHYp" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728012AbgFAPII (ORCPT ); Mon, 1 Jun 2020 11:08:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38034 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726075AbgFAPIG (ORCPT ); Mon, 1 Jun 2020 11:08:06 -0400 Received: from pandora.armlinux.org.uk (pandora.armlinux.org.uk [IPv6:2001:4d48:ad52:3201:214:fdff:fe10:1be6]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A6513C05BD43 for ; Mon, 1 Jun 2020 08:08:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=armlinux.org.uk; s=pandora-2019; h=Sender:In-Reply-To: Content-Transfer-Encoding:Content-Type:MIME-Version:References:Message-ID: Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=qAq4uZ1ttFHDy5aUeojvBZHoZbUCeHSbfFMRl/qdBE4=; b=G8VBKHYp6BPpkFO36U+zS3RVK obm6EzNkbWV96jdLQYzj7dE5RbCCLSSt2eyHIkM9o7NFcLH4zRseHFG0Izd6MoPudDbU3niLN14gX 18w+vkdkwwbiFbS11D5pnEtsHMfD7cS4brzCeLCCtQcDctZEg1N1TF3rlwgtDz4BX3odXY6TXaWrX TyHl94ebQ4baDbFRfPfIuuOl4IadWVVWY9SbZdIFivhX7rEfbDfdG9rq7aYVUSkmSnbrUjAHQkyM+ DVZTH1+95ni1Xjror6gru5515fDs+1zLmbmLup/brhbhbvKvxYMGYF60bhL2OZQYtSujhofGRCnyH jznMtmynw==; Received: from shell.armlinux.org.uk ([2001:4d48:ad52:3201:5054:ff:fe00:4ec]:48056) by pandora.armlinux.org.uk with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.90_1) (envelope-from ) id 1jfm2W-0000c6-Ea; Mon, 01 Jun 2020 16:07:48 +0100 Received: from linux by shell.armlinux.org.uk with local (Exim 4.92) (envelope-from ) id 1jfm2T-0003P7-K4; Mon, 01 Jun 2020 16:07:45 +0100 Date: Mon, 1 Jun 2020 16:07:45 +0100 From: Russell King - ARM Linux admin To: =?utf-8?Q?=C5=81ukasz?= Stelmach Cc: Masahiro Yamada , Nick Desaulniers , Thomas Gleixner , Enrico Weigelt , Kees Cook , Ingo Molnar , Ben Dooks , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, AKASHI Takahiro , Bartlomiej Zolnierkiewicz , Marek Szyprowski Subject: Re: [PATCH 5/5] arm: kexec_file: load zImage or uImage, initrd and dtb Message-ID: <20200601150745.GL1551@shell.armlinux.org.uk> References: <20200601142754.26139-1-l.stelmach@samsung.com> <20200601142754.26139-6-l.stelmach@samsung.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20200601142754.26139-6-l.stelmach@samsung.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 Mon, Jun 01, 2020 at 04:27:54PM +0200, Łukasz Stelmach wrote: > This is kexec_file_load implementation for ARM. It loads zImage and > initrd from file descripters and resuses DTB. > > Most code is derived from arm64 kexec_file_load implementation > and from kexec-tools. Please make the uImage loader able to be configured out of the kernel; it's a legacy image format now, and some of us just don't use it anymore. That way, those who wish to have it can, and those who wish not to can have a smaller kernel. > Cc: AKASHI Takahiro > Signed-off-by: Łukasz Stelmach > --- > arch/arm/Kconfig | 15 ++ > arch/arm/include/asm/image.h | 26 ++++ > arch/arm/include/asm/kexec.h | 14 ++ > arch/arm/kernel/Makefile | 5 +- > arch/arm/kernel/kexec_uimage.c | 80 ++++++++++ > arch/arm/kernel/kexec_zimage.c | 199 +++++++++++++++++++++++++ > arch/arm/kernel/machine_kexec.c | 11 +- > arch/arm/kernel/machine_kexec_file.c | 209 +++++++++++++++++++++++++++ > 8 files changed, 554 insertions(+), 5 deletions(-) > create mode 100644 arch/arm/kernel/kexec_uimage.c > create mode 100644 arch/arm/kernel/kexec_zimage.c > create mode 100644 arch/arm/kernel/machine_kexec_file.c > > diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig > index c77c93c485a0..6adb849cb304 100644 > --- a/arch/arm/Kconfig > +++ b/arch/arm/Kconfig > @@ -1917,6 +1917,21 @@ config KEXEC > is properly shutdown, so do not be surprised if this code does not > initially work for you. > > +config KEXEC_FILE > + bool "Kexec file based system call (EXPERIMENTAL)" > + depends on (!SMP || PM_SLEEP_SMP) > + depends on USE_OF > + select KEXEC_CORE > + select CRC32 > + help > + This is new version of kexec system call. This system call is > + file based and takes file descriptors as system call argument > + for kernel and initramfs as opposed to list of segments as > + accepted by previous system call. > + > + The kernel to be loaded MUST support Flattened Device Tree > + (selected with CONFIG_USE_OF). > + > config ATAGS_PROC > bool "Export atags in procfs" > depends on ATAGS && KEXEC > diff --git a/arch/arm/include/asm/image.h b/arch/arm/include/asm/image.h > index 624438740f23..95f23837b04f 100644 > --- a/arch/arm/include/asm/image.h > +++ b/arch/arm/include/asm/image.h > @@ -8,8 +8,13 @@ > (((x) >> 8) & 0x0000ff00) | \ > (((x) << 8) & 0x00ff0000) | \ > (((x) << 24) & 0xff000000)) > +#define UIMAGE_MAGIC(x) (x) > #else > #define ZIMAGE_MAGIC(x) (x) > +#define UIMAGE_MAGIC(x) ((((x) >> 24) & 0x000000ff) | \ > + (((x) >> 8) & 0x0000ff00) | \ > + (((x) << 8) & 0x00ff0000) | \ > + (((x) << 24) & 0xff000000)) > #endif > > #define ARM_ZIMAGE_MAGIC1 ZIMAGE_MAGIC(0x016f2818) > @@ -17,6 +22,12 @@ > #define ARM_ZIMAGE_MAGIC3 ZIMAGE_MAGIC(0x5a534c4b) > #define ARM_ZIMAGE_MAGIC4 ZIMAGE_MAGIC(0x5a534344) > > +#define ARM_UIMAGE_MAGIC UIMAGE_MAGIC(0x27051956) > +#define ARM_UIMAGE_NAME_LEN 32 > +#define ARM_UIMAGE_TYPE_KERNEL 2 > +#define ARM_UIMAGE_TYPE_KERNEL_NOLOAD 14 > +#define ARM_UIMAGE_ARCH_ARM 2 > + > #ifndef __ASSEMBLY__ > > #include > @@ -33,6 +44,21 @@ struct arm_zimage_header { > __le32 extension_tag_offset; > }; > > +struct arm_uimage_header { > + __be32 magic; > + __be32 hdr_crc; > + __be32 time; > + __be32 size; > + __be32 load; > + __be32 entry; > + __be32 crc; > + __u8 os; > + __u8 arch; > + __u8 type; > + __u8 comp; > + __u8 name[ARM_UIMAGE_NAME_LEN]; > +}; > + > struct arm_zimage_tag { > struct tag_header hdr; > union { > diff --git a/arch/arm/include/asm/kexec.h b/arch/arm/include/asm/kexec.h > index 22751b5b5735..fda35afa7195 100644 > --- a/arch/arm/include/asm/kexec.h > +++ b/arch/arm/include/asm/kexec.h > @@ -83,6 +83,20 @@ static inline struct page *boot_pfn_to_page(unsigned long boot_pfn) > } > #define boot_pfn_to_page boot_pfn_to_page > > +#ifdef CONFIG_KEXEC_FILE > + > +extern const struct kexec_file_ops kexec_zimage_ops; > +extern const struct kexec_file_ops kexec_uimage_ops; > + > +struct kimage; > + > +extern int load_other_segments(struct kimage *image, > + unsigned long kernel_load_addr, unsigned long kernel_size, > + char *initrd, unsigned long initrd_len, > + unsigned long initrd_offset, char *cmdline); > + > +#endif /* CONFIG_KEXEC_FILE */ > + > #endif /* __ASSEMBLY__ */ > > #endif /* CONFIG_KEXEC */ > diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile > index 89e5d864e923..466c683bb551 100644 > --- a/arch/arm/kernel/Makefile > +++ b/arch/arm/kernel/Makefile > @@ -3,6 +3,7 @@ > # Makefile for the linux kernel. > # > > +CFLAGS_kexec_zimage.o := -DTEXT_OFFSET=$(TEXT_OFFSET) > CPPFLAGS_vmlinux.lds := -DTEXT_OFFSET=$(TEXT_OFFSET) > AFLAGS_head.o := -DTEXT_OFFSET=$(TEXT_OFFSET) > > @@ -56,7 +57,9 @@ obj-$(CONFIG_FUNCTION_TRACER) += entry-ftrace.o > obj-$(CONFIG_DYNAMIC_FTRACE) += ftrace.o insn.o patch.o > obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o insn.o patch.o > obj-$(CONFIG_JUMP_LABEL) += jump_label.o insn.o patch.o > -obj-$(CONFIG_KEXEC) += machine_kexec.o relocate_kernel.o > +obj-$(CONFIG_KEXEC_CORE) += machine_kexec.o relocate_kernel.o > +obj-$(CONFIG_KEXEC_FILE) += machine_kexec_file.o kexec_zimage.o \ > + kexec_uimage.o > # Main staffs in KPROBES are in arch/arm/probes/ . > obj-$(CONFIG_KPROBES) += patch.o insn.o > obj-$(CONFIG_OABI_COMPAT) += sys_oabi-compat.o > diff --git a/arch/arm/kernel/kexec_uimage.c b/arch/arm/kernel/kexec_uimage.c > new file mode 100644 > index 000000000000..47033574e24e > --- /dev/null > +++ b/arch/arm/kernel/kexec_uimage.c > @@ -0,0 +1,80 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Kexec uImage loader > + * > + * Copyright (C) 2020 Samsung Electronics > + * Author: Łukasz Stelmach > + */ > + > +#define pr_fmt(fmt) "kexec_file(uImage): " fmt > + > +#include > +#include > +#include > +#include > + > +#define crc32_ones(crc, buf, len) \ > + (crc32(crc ^ 0xffffffff, buf, len) ^ 0xffffffff) > + > +static int uimage_probe(const char *uimage_buf, unsigned long uimage_len) > +{ > + const struct arm_uimage_header *h = > + (struct arm_uimage_header *) uimage_buf; > + struct arm_uimage_header uhdr; > + unsigned long zoff = sizeof(struct arm_uimage_header); > + uint32_t crc; > + > + if (h->magic != ARM_UIMAGE_MAGIC) > + return -EINVAL; > + > + if (h->type != ARM_UIMAGE_TYPE_KERNEL && > + h->type != ARM_UIMAGE_TYPE_KERNEL_NOLOAD){ > + pr_debug("Invalid image type: %d\n", h->type); > + return -EINVAL; > + } > + > + if (h->arch != ARM_UIMAGE_ARCH_ARM) { > + pr_debug("Invalidy image arch: %d\n", h->arch); > + return -EINVAL; > + } > + > + memcpy((char *)&uhdr, h, sizeof(uhdr)); > + crc = be32_to_cpu(uhdr.hdr_crc); > + uhdr.hdr_crc = 0; > + > + if (crc32_ones(0, (char *)&uhdr, sizeof(uhdr)) != crc) { > + pr_debug("Corrupt header, CRC do not match\n"); > + return -EINVAL; > + } > + > + crc = be32_to_cpu(uhdr.crc); > + if (crc32_ones(0, uimage_buf + zoff, uimage_len - zoff) != crc) { > + pr_debug("Corrupt zImage, CRC do not match\n"); > + return -EINVAL; > + } > + > + return kexec_zimage_ops.probe(uimage_buf + zoff, > + uimage_len - zoff); > +} > + > +static void *uimage_load(struct kimage *image, > + char *uimage, unsigned long uimage_len, > + char *initrd, unsigned long initrd_len, > + char *cmdline, unsigned long cmdline_len) > +{ > + const struct arm_uimage_header *h = > + (struct arm_uimage_header *) uimage; > + unsigned long zimage_offset = sizeof(struct arm_uimage_header); > + > + pr_debug("Loading uImage"); > + return kexec_zimage_ops.load(image, > + uimage + zimage_offset, > + uimage_len - zimage_offset, > + initrd, initrd_len, > + cmdline, cmdline_len); > +} > + > +const struct kexec_file_ops kexec_uimage_ops = { > + .probe = uimage_probe, > + .load = uimage_load, > +}; > diff --git a/arch/arm/kernel/kexec_zimage.c b/arch/arm/kernel/kexec_zimage.c > new file mode 100644 > index 000000000000..d09795fc9072 > --- /dev/null > +++ b/arch/arm/kernel/kexec_zimage.c > @@ -0,0 +1,199 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Kexec zImage loader > + * > + * Copyright (C) 2020 Samsung Electronics > + * Author: Łukasz Stelmach Please credit me as part author of this - you have taken some of my code from the userspace kexec tool (such as the contents of find_extension_tag()) and copied it in here, so this is not all your own work. > + */ > + > +#define pr_fmt(fmt) "kexec_file(zImage): " fmt > + > +#include > +#include > +#include > +#include > +#include > + > +#define byte_size(t) ((t)->hdr.size << 2) > + > +static const void *find_extension_tag(const char *buf, > + unsigned long len, > + uint32_t tag_id) > +{ > + const struct arm_zimage_header *h = (const struct arm_zimage_header *)buf; > + const struct arm_zimage_tag *tag; > + uint32_t offset, size; > + uint32_t max = len - sizeof(struct tag_header); > + > + if (len < sizeof(*h) || > + h->magic != ARM_ZIMAGE_MAGIC1 || > + h->magic2 != ARM_ZIMAGE_MAGIC2) > + return NULL; > + > + for (offset = h->extension_tag_offset; > + (tag = (void *)(buf + offset)) != NULL && > + offset < max && > + (size = le32_to_cpu(byte_size(tag))) != 0 && > + offset + size < len; > + offset += size) { > + pr_debug(" offset 0x%08x tag 0x%08x size %u\n", > + offset, le32_to_cpu(tag->hdr.tag), size); > + if (tag->hdr.tag == tag_id) > + return tag; > + } > + > + return NULL; > +} > + > +static int zimage_probe(const char *kernel_buf, unsigned long kernel_len) > +{ > + const struct arm_zimage_header *h = > + (struct arm_zimage_header *)(kernel_buf); > + > + if (!h || (kernel_len < sizeof(*h))) > + return -EINVAL; > + > + if ((h->magic != ARM_ZIMAGE_MAGIC1) || > + (h->magic2 != ARM_ZIMAGE_MAGIC2)) > + return -EINVAL; > + > + return 0; > +} > + > + > +#if defined(DEBUG) > +#define debug_offsets() ({ \ > + pr_debug("Image offsets:\n"); \ > + pr_debug(" kernel 0x%08lx 0x%08lx\n", kernel_offset, kernel_len); \ > + pr_debug(" zimage 0x%08lx 0x%08lx\n", zimage_offset, zimage_len); \ > + pr_debug(" initrd 0x%08lx 0x%08lx\n", initrd_offset, initrd_len); \ > +}) > +#else > +#define debug_offsets() > +#endif > + > +static void *zimage_load(struct kimage *image, > + char *zimage, unsigned long zimage_len, > + char *initrd, unsigned long initrd_len, > + char *cmdline, unsigned long cmdline_len) > +{ > + struct arm_zimage_header *h; > + struct kexec_buf kbuf; > + struct kexec_segment *zimage_segment; > + const struct arm_zimage_tag *klsz_tag; > + const struct arm_zimage_tag_dc *dcsz_tag; > + int ret = -EINVAL; > + > + unsigned long zimage_mem = 0x20000; /* malloc 64kB + stack 4 kB + some bss */ > + unsigned long kernel_len = zimage_len * 4; /* 4:1 compression */ This has been proven wrong. > + unsigned long kernel_offset = memblock_start_of_DRAM() + > + ALIGN(TEXT_OFFSET, PAGE_SIZE); TEXT_OFFSET is actually a property of the loaded kernel, not of the currently running kernel. I have a patch to add that into the zImage tag. > + unsigned long zimage_offset = kernel_offset + > + ALIGN(kernel_len, PAGE_SIZE); > + unsigned long initrd_offset = zimage_offset + > + ALIGN(zimage_len + zimage_mem, PAGE_SIZE); Since kernel_len is wrong, these will be wrong... please only fall back to this if you don't find the extension tag - in other words, declare the variables here, but don't initialise them, set them lower down in the file if we fail to find the extension tag. > + > + if (image->type == KEXEC_TYPE_CRASH) { > + kernel_offset += crashk_res.start; > + zimage_offset += crashk_res.start; > + initrd_offset += crashk_res.start; > + } > + debug_offsets(); > + > + h = (struct arm_zimage_header *)zimage; > + > + klsz_tag = find_extension_tag(zimage, zimage_len, ZIMAGE_TAG_KRNL_SIZE); > + if (klsz_tag) { > + uint32_t *p = (void *)zimage + > + le32_to_cpu(klsz_tag->u.krnl_size.size_ptr); > + uint32_t edata_size = le32_to_cpu(get_unaligned(p)); > + uint32_t bss_size = le32_to_cpu(klsz_tag->u.krnl_size.bss_size); > + > + kernel_len = edata_size + bss_size; > + > + pr_debug("Decompressed kernel sizes:\n"); > + pr_debug(" text+data 0x%08lx bss 0x%08lx total 0x%08lx\n", > + (unsigned long)edata_size, > + (unsigned long)bss_size, > + (unsigned long)kernel_len); > + > + zimage_offset = kernel_offset + ALIGN(edata_size, PAGE_SIZE); > + initrd_offset = zimage_offset + > + max(ALIGN(zimage_len + 0x20000, PAGE_SIZE), > + ALIGN((unsigned long)bss_size, PAGE_SIZE)); > + debug_offsets(); This looks incorrect to me. Please see the kexec tool - what its doing in its corresponding section that you copied some of this code from is carefully thought out and can't be simplified. Ergo, I think this is wrong. > + } > + > + dcsz_tag = find_extension_tag(zimage, zimage_len, > + ZIMAGE_TAG_DECOMP_SIZE); > + if (dcsz_tag) { > + uint32_t bss_size = le32_to_cpu(dcsz_tag->u.decomp_size.bss_size); > + uint32_t stack_size = le32_to_cpu(dcsz_tag->u.decomp_size.stack_size); > + uint32_t malloc_size = le32_to_cpu(dcsz_tag->u.decomp_size.malloc_size); > + > + zimage_mem = bss_size + stack_size + malloc_size; > + > + pr_debug("Decompressor memory requirements:\n"); > + pr_debug(" bss 0x%08lx stack 0x%08lx malloc 0x%08lx total 0x%08lx\n", > + (unsigned long)bss_size, > + (unsigned long)stack_size, > + (unsigned long)malloc_size, > + zimage_mem); > + > + initrd_offset = max(ALIGN(zimage_offset + zimage_len + > + bss_size + stack_size + > + malloc_size, PAGE_SIZE), > + ALIGN(kernel_offset + kernel_len, PAGE_SIZE)); > + debug_offsets(); > + } > + > + /* > + * zImage MUST be loaded into the first 128 MiB of physical > + * memory for proper memory detection. Should the uncompressed > + * kernel be larger than 128 MiB, zImage relocation becomes > + * unavoidable and it is best to rely on the relocation code. > + */ > + if (((zimage_offset - kernel_offset) + PAGE_SIZE + 0x8000) >= SZ_128M) { > + pr_debug("The kernel is too big (%ld MiB) to avoid " > + "zImage relocation. Loading zimage at 0x%08lx\n", > + ((zimage_offset - kernel_offset) >> 20), > + kernel_offset); > + zimage_offset = kernel_offset; > + } > + > + kbuf.image = image; > + kbuf.top_down = false; > + > + kbuf.buf_min = zimage_offset; > + kbuf.buf_max = ULONG_MAX; > + kbuf.buffer = zimage; > + kbuf.bufsz = zimage_len; > + kbuf.buf_align = PAGE_SIZE; > + > + kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; > + kbuf.memsz = zimage_len; > + > + ret = kexec_add_buffer(&kbuf); > + if (ret) > + return ERR_PTR(ret); > + > + pr_debug("Loaded zImage at 0x%lx bufsz=0x%lx memsz=0x%lx\n", > + kbuf.mem, kbuf.bufsz, kbuf.memsz); > + > + initrd_offset += kbuf.mem - zimage_offset; > + debug_offsets(); > + > + zimage_segment = &image->segment[image->nr_segments - 1]; > + image->start = zimage_segment->mem; > + > + ret = load_other_segments(image, > + zimage_segment->mem, zimage_segment->memsz, > + initrd, initrd_len, initrd_offset, > + cmdline); > + return ERR_PTR(ret); > +} > + > +const struct kexec_file_ops kexec_zimage_ops = { > + .probe = zimage_probe, > + .load = zimage_load, > +}; > diff --git a/arch/arm/kernel/machine_kexec.c b/arch/arm/kernel/machine_kexec.c > index c10a2dfd53d1..2e4780efabb4 100644 > --- a/arch/arm/kernel/machine_kexec.c > +++ b/arch/arm/kernel/machine_kexec.c > @@ -93,10 +93,13 @@ int machine_kexec_prepare(struct kimage *image) > current_segment->memsz)) > return -EINVAL; > > - err = get_user(header, (__be32*)current_segment->buf); > - if (err) > - return err; > - > + if (image->file_mode) { > + header = *(__be32 *)current_segment->buf; > + } else { > + err = get_user(header, (__be32 *)current_segment->buf); > + if (err) > + return err; > + } > if (header == cpu_to_be32(OF_DT_HEADER)) > image->arch.kernel_r2 = current_segment->mem; > } > diff --git a/arch/arm/kernel/machine_kexec_file.c b/arch/arm/kernel/machine_kexec_file.c > new file mode 100644 > index 000000000000..ead680f1e795 > --- /dev/null > +++ b/arch/arm/kernel/machine_kexec_file.c > @@ -0,0 +1,209 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * kexec_file for arm > + * > + * Copyright (C) 2018 Linaro Limited > + * Copyright (C) 2020 Samsung Electronics > + * Authors: > + * AKASHI Takahiro > + * Łukasz Stelmach > + * > + */ > + > +#define pr_fmt(fmt) "kexec_file: " fmt > + > +#include > +#include > +#include > +#include > + > +/* relevant device tree properties */ > +#define FDT_PROP_INITRD_START "linux,initrd-start" > +#define FDT_PROP_INITRD_END "linux,initrd-end" > +#define FDT_PROP_BOOTARGS "bootargs" > +#define FDT_PROP_RNG_SEED "rng-seed" > + > +static int setup_dtb(struct kimage *image, > + unsigned long initrd_load_addr, unsigned long initrd_len, > + char *cmdline, void *dtb) > +{ > + int off, ret; > + > + ret = fdt_path_offset(dtb, "/chosen"); > + if (ret < 0) > + goto out; > + > + off = ret; > + > + /* add bootargs */ > + if (cmdline) { > + ret = fdt_setprop_string(dtb, off, FDT_PROP_BOOTARGS, cmdline); > + if (ret) > + goto out; > + } else { > + ret = fdt_delprop(dtb, off, FDT_PROP_BOOTARGS); > + if (ret && (ret != -FDT_ERR_NOTFOUND)) > + goto out; > + } > + > + /* add initrd-* */ > + if (initrd_load_addr) { > + ret = fdt_setprop_u64(dtb, off, FDT_PROP_INITRD_START, > + initrd_load_addr); > + if (ret) > + goto out; > + > + ret = fdt_setprop_u64(dtb, off, FDT_PROP_INITRD_END, > + initrd_load_addr + initrd_len); > + if (ret) > + goto out; > + } else { > + ret = fdt_delprop(dtb, off, FDT_PROP_INITRD_START); > + if (ret && (ret != -FDT_ERR_NOTFOUND)) > + goto out; > + > + ret = fdt_delprop(dtb, off, FDT_PROP_INITRD_END); > + if (ret && (ret != -FDT_ERR_NOTFOUND)) > + goto out; > + } > + > + /* add rng-seed */ > + if (rng_is_initialized()) { > + char seed[128]; > + get_random_bytes(seed, sizeof(seed)); > + > + ret = fdt_setprop(dtb, off, FDT_PROP_RNG_SEED, > + seed, sizeof(seed)); > + if (ret) > + goto out; > + } else { > + pr_notice("RNG is not initialised: omitting \"%s\" property\n", > + FDT_PROP_RNG_SEED); > + ret = 0; > + } > + > +out: > + if (ret) > + return (ret == -FDT_ERR_NOSPACE) ? -ENOMEM : -EINVAL; > + > + return 0; > +} > +/* > + * More space needed so that we can add initrd, bootargs and kaslr-seed. > + */ > +#define DTB_EXTRA_SPACE 0x1000 > + > +static int create_dtb(struct kimage *image, > + unsigned long initrd_load_addr, unsigned long initrd_len, > + char *cmdline, void **dtb) > +{ > + void *buf; > + size_t buf_size; > + size_t cmdline_len; > + int ret; > + > + cmdline_len = cmdline ? strlen(cmdline) : 0; > + buf_size = fdt_totalsize(initial_boot_params) > + + cmdline_len + DTB_EXTRA_SPACE; > + > + for (;;) { > + buf = vmalloc(buf_size); > + if (!buf) > + return -ENOMEM; > + > + /* duplicate a device tree blob */ > + ret = fdt_open_into(initial_boot_params, buf, buf_size); > + if (ret) > + return -EINVAL; > + > + ret = setup_dtb(image, initrd_load_addr, initrd_len, > + cmdline, buf); > + if (ret) { > + vfree(buf); > + if (ret == -ENOMEM) { > + /* unlikely, but just in case */ > + buf_size += DTB_EXTRA_SPACE; > + continue; > + } else { > + return ret; > + } > + } > + > + /* trim it */ > + fdt_pack(buf); > + *dtb = buf; > + > + return 0; > + } > +} > + > +int load_other_segments(struct kimage *image, > + unsigned long zimage_load_addr, > + unsigned long zimage_len, > + char *initrd, > + unsigned long initrd_len, > + unsigned long initrd_offset, > + char *cmdline) > +{ > + struct kexec_buf kbuf; > + void *dtb = NULL; > + unsigned long initrd_load_addr = 0; > + unsigned long dtb_len; > + int ret = 0; > + > + kbuf.image = image; > + /* not allocate anything below the kernel */ > + kbuf.buf_min = initrd_offset; > + if (initrd) { > + kbuf.buffer = initrd; > + kbuf.bufsz = initrd_len; > + kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; > + kbuf.memsz = initrd_len; > + kbuf.buf_align = PAGE_SIZE; > + kbuf.buf_max = ULONG_MAX; > + kbuf.top_down = false; > + > + ret = kexec_add_buffer(&kbuf); > + if (ret) > + goto out_err; > + > + pr_debug("Loaded initrd at 0x%lx bufsz=0x%lx memsz=0x%lx\n", > + kbuf.mem, kbuf.bufsz, kbuf.memsz); > + > + initrd_load_addr = kbuf.mem; > + kbuf.buf_min = initrd_load_addr + kbuf.memsz; > + } > + > + /* load dtb */ > + ret = create_dtb(image, initrd_load_addr, initrd_len, cmdline, &dtb); > + if (ret) { > + pr_err("Preparing for new dtb failed\n"); > + goto out_err; > + } > + > + dtb_len = fdt_totalsize(dtb); > + kbuf.buffer = dtb; > + kbuf.bufsz = dtb_len; > + kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; > + kbuf.memsz = dtb_len; > + kbuf.buf_align = PAGE_SIZE; > + kbuf.buf_max = ULONG_MAX; > + kbuf.top_down = false; > + > + ret = kexec_add_buffer(&kbuf); > + if (ret) > + goto out_err; > + > + pr_debug("Loaded dtb at 0x%lx bufsz=0x%lx memsz=0x%lx\n", > + kbuf.mem, kbuf.bufsz, kbuf.memsz); > + return 0; > +out_err: > + vfree(dtb); > + return ret; > +} > + > +const struct kexec_file_ops * const kexec_file_loaders[] = { > + &kexec_uimage_ops, > + &kexec_zimage_ops, > + NULL > +}; > -- > 2.26.2 > > -- RMK's Patch system: https://www.armlinux.org.uk/developer/patches/ FTTC for 0.8m (est. 1762m) line in suburbia: sync at 13.1Mbps down 424kbps up