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 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 smtp.lore.kernel.org (Postfix) with ESMTPS id 4D13EC56201 for ; Fri, 20 Feb 2026 15:35:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To: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-Owner; bh=Cvxfyq7B16DaGNv8vkkGKPws9Bo8l33ShJLemx2czac=; b=v0pxrxI9I/acTP HiIl9Iex8Vl9UzFXLU/VJ+jclszu3DFiX5iyuhyFfYfA8ev/I4t9vlHPdwhBDmH4bwZREg4MsDY1f 05yNyd5NtaYIutW3Q5YvGaTLOP1q9giM7CYS7vclkibUZuap5vX7ckArKNps2Qd9GutkXKPg7Gpke JqK3uIUUE2oBcGmTYC3l8q5ShOjGxcbmiTLR/I5CaubmpvQKK1I4j9+9VVWpUYsGyt6us3wJv+iKJ siA6tHPb+vX9g2fNIS6lkPoT695bnCS7yr529U1BgEslCBxy02+tXKMDMLygUvd1NPKp8ME8pFesD onSr3YQU2SxNyNTWf+dg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1vtSXE-0000000F2tC-33RL; Fri, 20 Feb 2026 15:35:16 +0000 Received: from sea.source.kernel.org ([172.234.252.31]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1vtSX9-0000000F2r6-2rHU for linux-riscv@lists.infradead.org; Fri, 20 Feb 2026 15:35:15 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sea.source.kernel.org (Postfix) with ESMTP id 5DD7541A0E; Fri, 20 Feb 2026 15:35:11 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 383C8C116C6; Fri, 20 Feb 2026 15:35:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1771601711; bh=hMocGbqb+DjCzyxxuriJP4ipo7LDuCuBbgPZfyi0fzU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=NRR2zRaZX2VHq71MdxVNVVJTx87Fl01z8LgRxWvU5eRllDVC2fDHbiBbmxXibws+t eNMdyn7VPFvtWLTh/+g9RCy+q8yDrjq63DBgU4qbY0hX29udHXFz90wNlZs0w/hNj8 4LSO86t2r2g8MsPUURxWy/O5m3lgKkCDbq7uePq8BF38SCNDjx1DLl9sRff1sxjNMK AzvOvi6cW+r+72DWm5pgpde3Kxq6G1GONWqwHV/neOI60S7NX2a3DLyRMRN6cg49CL DveWqnaq5iEAHdkfzePO4f0+UjzZm5hFOK2P3zXLSstzJ+5i01qSyFSA+av8ZS68iH WMJyxaNBr8tyg== Date: Fri, 20 Feb 2026 23:16:37 +0800 From: Jisheng Zhang To: Kunwu Chan Cc: Nam Cao , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, Zhouyi Zhou , Frederik Haxel , Vitaly Wool Subject: Re: [PATCH] riscv: Remove support for XIP kernel Message-ID: References: <20260202115403.2119218-1-namcao@linutronix.de> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260220_073511_783963_76B0656E X-CRM114-Status: GOOD ( 45.14 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org T24gRnJpLCBGZWIgMTMsIDIwMjYgYXQgMDU6Mzc6NDVQTSArMDgwMCwgS3Vud3UgQ2hhbiB3cm90 ZToKPiBIaSwKPiAKPiBQbGVhc2UgZG9uJ3QgcmVtb3ZlIENPTkZJR19YSVBfS0VSTkVMLgoKQ2Fu IHlvdSBwbHogc2hvdyBhIHJlYWwgYW5kIHZhbGlkIHVzYWdlIG9mIFhJUCB3aXRoIGxpbnV4LXJp c2N2PwpJZiB3ZSB0YWtlIGEgbG9vayBhdCB0aGUgY29kZSwgaXQncyBvYnZpb3VzIHRoZSBYSVAg bWVzcyB0aGUgcmlzY3YKYXJjaCBjb2RlLiBTbyB3aGVuIHBlb3BsZSBtb2RpZmllcyB0aGUgcmlz Y3YgYXJjaCBjb2RlLCAgdGhleSBoYXZlIHRvCnRha2UgY2FyZSBvZiB0aGUgWElQLCB0aGUgdGlt ZSBzcGVudCBoZXJlIGlzIGEgdG90YWxseSB3YXN0ZSwgdGhlIGdhaW4KZG9lcyBub3QgY29tcGVu c2F0ZSBmb3IgdGhlIGxvc3MuCgo+IAo+IFpob3V5aSBaaG91IHpob3V6aG91eWlAZ21haWwuY29t IDxtYWlsdG86emhvdXpob3V5aUBnbWFpbC5jb20+YW5kIEkgYXJlCj4gd2lsbGluZyB0byB0YWtl IG92ZXIKPiBtYWludGFpbmVyc2hpcCBhbmQga2VlcCBpdCBidWlsZC10ZXN0ZWQgYW5kIG1haW50 YWluZWQgZ29pbmcgZm9yd2FyZC4KCgokIGdpdCBsb2cgLS1vbmVsaW5lIC0tYXV0aG9yPSJLdW53 dSBDaGFuIiAtLSBhcmNoL3Jpc2N2ICc6KGV4Y2x1ZGUpYXJjaC9yaXNjdi9kdHMnIHx3YyAtbAow CgokIGdpdCBsb2cgLS1vbmVsaW5lIC0tYXV0aG9yPSJaaG91eWkiIC0tIGFyY2gvcmlzY3YgJzoo ZXhjbHVkZSlhcmNoL3Jpc2N2L2R0cycgfHdjIC1sCjAKClNvcnJ5IGZvciBiZWluZyB0b28gaHlw ZXJjcml0aWNhbCwgYnV0IE1BSU5UQUlORVJTIGRvZXNuJ3Qgd29yayBsaWtlCnRoaXMsIEkgZG9u J3QgdGhpbmsgYSBwZXJzb24gY2FuIHJlYWxseSBtYWludGFpbiB0aGUgcmlzY3YgeGlwIGNvZGUK aWYgaGUvc2hlIGhhc24ndCBuZXZlciB1cHN0cmVhbWVkIGFueSBwYXRjaCB0byByaXNjdiBhcmNo IHNvdXJjZSBjb2RlLgpUaGUgZmluYWwgcmVzdWx0IHdvdWxkIGJlIHRoZSBtYWludGFpbnNoaXAg aXMgb2ZmbG9hZGVkIHRvIHBhdGNoIGF1dGhvcnMKYW5kIHJpc2N2IGFyY2ggbWFpbnRhaW5lcnMu Cgo+IAo+IFdlIHdpbGwgc2VuZCBhIE1BSU5UQUlORVJTIHBhdGNoIHNob3J0bHkuCgpTZWUgYWJv dmUsIGhvdyBkb2VzIGEgcGVyc29uIHdobyBoYXMgbmV2ZXIgY29udHJpYnV0ZWQgb25lIExvQyB0 bwpjb3Jlc3BvbmRpbmcgY29kZSBtYWludGFpbiB0aGUgY29kZT8KCj4gCj4gCj4gVGhhbngswqAg S3Vud3UKPiAKPiBPbiAyLzIvMjYgMTk6NTQsIE5hbSBDYW8gd3JvdGU6Cj4gPiBYSVAgaGFzIGEg aGlzdG9yeSBvZiBiZWluZyBicm9rZW4gZm9yIGxvbmcgcGVyaW9kcyBvZiB0aW1lLiBJbiAyMDIz LCBpdCB3YXMKPiA+IGJyb2tlbiBmb3IgMTggbW9udGhzIGJlZm9yZSBnZXR0aW5nIGZpeGVkIFsx XS4gSW4gMjAyNCBpdCB3YXMgNCBtb250aHMgWzJdLgo+ID4KPiA+IEFuZCBub3cgaXQgaXMgYnJv a2VuIGFnYWluIHNpbmNlIGNvbW1pdCBhNDRmYjU3MjIxOTkgKCJyaXNjdjogQWRkIHJ1bnRpbWUK PiA+IGNvbnN0YW50IHN1cHBvcnQiKSwgMTAgbW9udGhzIGFnby4KPiA+Cj4gPiBUaGVzZSBhcmUg Y2xlYXIgc2lnbnMgdGhhdCBYSVAgZmVhdHVyZSBpcyBub3QgYmVpbmcgdXNlZC4KPiA+Cj4gPiBJ IG9jY2FzaW9uYWxseSBsb29rZWQgYWZ0ZXIgWElQLCBidXQgbW9zdGx5IGJlY2F1c2UgSSB3YXMg Ym9yZWQgYW5kIGhhZAo+ID4gbm90aGluZyBiZXR0ZXIgdG8gZG8uCj4gPgo+ID4gUmVtb3ZlIFhJ UCBzdXBwb3J0LiBSZXZlcnQgaXMgcG9zc2libGUgaWYgc29tZW9uZSBzaG93cyB1cCBjb21wbGFp bmluZy4KPiA+Cj4gPiBMaW5rOiBodHRwczovL2xvcmUua2VybmVsLm9yZy9saW51eC1yaXNjdi8y MDIzMTIxMi1jdXN0b21hcnktaGFyZGNvdmVyLWUxOTQ2MmJmOGU3NUB3ZW5keS8gWzFdCj4gPiBM aW5rOiBodHRwczovL2xvcmUua2VybmVsLm9yZy9saW51eC1yaXNjdi8yMDI0MDUyNjExMDEwNC40 NzA0MjktMS1uYW1jYW9AbGludXRyb25peC5kZS8gWzJdCj4gPiBTaWduZWQtb2ZmLWJ5OiBOYW0g Q2FvIDxuYW1jYW9AbGludXRyb25peC5kZT4KPiA+IENjOiBGcmVkZXJpayBIYXhlbCA8aGF4ZWxA ZnppLmRlPgo+ID4gQ2M6IFZpdGFseSBXb29sIDx2aXRhbHkud29vbEBrb25zdWxrby5jb20+Cj4g PiAtLS0KPiA+ICBhcmNoL3Jpc2N2L0tjb25maWcgICAgICAgICAgICAgICAgICB8ICA4NiArKysr KystLS0tLS0tLS0tLS0tLS0KPiA+ICBhcmNoL3Jpc2N2L0tjb25maWcuc29jcyAgICAgICAgICAg ICB8ICAgOCArLQo+ID4gIGFyY2gvcmlzY3YvTWFrZWZpbGUgICAgICAgICAgICAgICAgIHwgICAz IC0KPiA+ICBhcmNoL3Jpc2N2L2Jvb3QvTWFrZWZpbGUgICAgICAgICAgICB8ICAxMSAtLS0KPiA+ ICBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3BhZ2UuaCAgICAgICB8ICAyOSAtLS0tLS0tLQo+ID4g IGFyY2gvcmlzY3YvaW5jbHVkZS9hc20vcGd0YWJsZS5oICAgIHwgIDIwIC0tLS0tCj4gPiAgYXJj aC9yaXNjdi9pbmNsdWRlL2FzbS9zY3MuaCAgICAgICAgfCAgIDEgLQo+ID4gIGFyY2gvcmlzY3Yv aW5jbHVkZS9hc20vc2V0X21lbW9yeS5oIHwgICAyICstCj4gPiAgYXJjaC9yaXNjdi9pbmNsdWRl L2FzbS94aXBfZml4dXAuaCAgfCAgNDkgLS0tLS0tLS0tLS0tCj4gPiAgYXJjaC9yaXNjdi9rZXJu ZWwvaGVhZC5TICAgICAgICAgICAgfCAgNDEgLS0tLS0tLS0tLQo+ID4gIGFyY2gvcmlzY3Yva2Vy bmVsL2hlYWQuaCAgICAgICAgICAgIHwgICAzIC0KPiA+ICBhcmNoL3Jpc2N2L2tlcm5lbC9zZXR1 cC5jICAgICAgICAgICB8ICAgNiArLQo+ID4gIGFyY2gvcmlzY3Yva2VybmVsL3N1c3BlbmRfZW50 cnkuUyAgIHwgICAyIC0KPiA+ICBhcmNoL3Jpc2N2L2tlcm5lbC90cmFwcy5jICAgICAgICAgICB8 ICAgNCAtCj4gPiAgYXJjaC9yaXNjdi9rZXJuZWwvdm1jb3JlX2luZm8uYyAgICAgfCAgIDcgLS0K PiA+ICBhcmNoL3Jpc2N2L2tlcm5lbC92bWxpbnV4Lmxkcy5TICAgICB8ICAgNSAtLQo+ID4gIGFy Y2gvcmlzY3YvbW0vaW5pdC5jICAgICAgICAgICAgICAgIHwgMTExICsrLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0KPiA+ICAxNyBmaWxlcyBjaGFuZ2VkLCAzNyBpbnNlcnRpb25zKCspLCAzNTEg ZGVsZXRpb25zKC0pCj4gPiAgZGVsZXRlIG1vZGUgMTAwNjQ0IGFyY2gvcmlzY3YvaW5jbHVkZS9h c20veGlwX2ZpeHVwLmgKPiA+Cj4gPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9LY29uZmlnIGIv YXJjaC9yaXNjdi9LY29uZmlnCj4gPiBpbmRleCA3ZTc2YjYzMTY0MjUuLmU4YWM2YzYxZTI3ZCAx MDA2NDQKPiA+IC0tLSBhL2FyY2gvcmlzY3YvS2NvbmZpZwo+ID4gKysrIGIvYXJjaC9yaXNjdi9L Y29uZmlnCj4gPiBAQCAtNDgsOCArNDgsOCBAQCBjb25maWcgUklTQ1YKPiA+ICAJc2VsZWN0IEFS Q0hfSEFTX1BURV9TUEVDSUFMCj4gPiAgCXNlbGVjdCBBUkNIX0hBU19TRVRfRElSRUNUX01BUCBp ZiBNTVUKPiA+ICAJc2VsZWN0IEFSQ0hfSEFTX1NFVF9NRU1PUlkgaWYgTU1VCj4gPiAtCXNlbGVj dCBBUkNIX0hBU19TVFJJQ1RfS0VSTkVMX1JXWCBpZiBNTVUgJiYgIVhJUF9LRVJORUwKPiA+IC0J c2VsZWN0IEFSQ0hfSEFTX1NUUklDVF9NT0RVTEVfUldYIGlmIE1NVSAmJiAhWElQX0tFUk5FTAo+ ID4gKwlzZWxlY3QgQVJDSF9IQVNfU1RSSUNUX0tFUk5FTF9SV1ggaWYgTU1VCj4gPiArCXNlbGVj dCBBUkNIX0hBU19TVFJJQ1RfTU9EVUxFX1JXWCBpZiBNTVUKPiA+ICAJc2VsZWN0IEFSQ0hfSEFT X1NZTkNfQ09SRV9CRUZPUkVfVVNFUk1PREUKPiA+ICAJc2VsZWN0IEFSQ0hfSEFTX1NZU0NBTExf V1JBUFBFUgo+ID4gIAlzZWxlY3QgQVJDSF9IQVNfVElDS19CUk9BRENBU1QgaWYgR0VORVJJQ19D TE9DS0VWRU5UU19CUk9BRENBU1QKPiA+IEBAIC04NSw3ICs4NSw3IEBAIGNvbmZpZyBSSVNDVgo+ ID4gIAlzZWxlY3QgQVJDSF9XQU5UX0ZSQU1FX1BPSU5URVJTCj4gPiAgCXNlbGVjdCBBUkNIX1dB TlRfR0VORVJBTF9IVUdFVExCIGlmICFSSVNDVl9JU0FfU1ZOQVBPVAo+ID4gIAlzZWxlY3QgQVJD SF9XQU5UX0hVR0VfUE1EX1NIQVJFIGlmIDY0QklUCj4gPiAtCXNlbGVjdCBBUkNIX1dBTlRfTERf T1JQSEFOX1dBUk4gaWYgIVhJUF9LRVJORUwKPiA+ICsJc2VsZWN0IEFSQ0hfV0FOVF9MRF9PUlBI QU5fV0FSTgo+ID4gIAlzZWxlY3QgQVJDSF9XQU5UX09QVElNSVpFX0RBWF9WTUVNTUFQCj4gPiAg CXNlbGVjdCBBUkNIX1dBTlRfT1BUSU1JWkVfSFVHRVRMQl9WTUVNTUFQCj4gPiAgCXNlbGVjdCBB UkNIX1dBTlRTX05PX0lOU1RSCj4gPiBAQCAtMTMwLDEzICsxMzAsMTMgQEAgY29uZmlnIFJJU0NW Cj4gPiAgCXNlbGVjdCBIQVZFX0FSQ0hfQVVESVRTWVNDQUxMCj4gPiAgCXNlbGVjdCBIQVZFX0FS Q0hfSFVHRV9WTUFMTE9DIGlmIEhBVkVfQVJDSF9IVUdFX1ZNQVAKPiA+ICAJc2VsZWN0IEhBVkVf QVJDSF9IVUdFX1ZNQVAgaWYgTU1VICYmIDY0QklUCj4gPiAtCXNlbGVjdCBIQVZFX0FSQ0hfSlVN UF9MQUJFTCBpZiAhWElQX0tFUk5FTAo+ID4gLQlzZWxlY3QgSEFWRV9BUkNIX0pVTVBfTEFCRUxf UkVMQVRJVkUgaWYgIVhJUF9LRVJORUwKPiA+ICsJc2VsZWN0IEhBVkVfQVJDSF9KVU1QX0xBQkVM Cj4gPiArCXNlbGVjdCBIQVZFX0FSQ0hfSlVNUF9MQUJFTF9SRUxBVElWRQo+ID4gIAlzZWxlY3Qg SEFWRV9BUkNIX0tBU0FOIGlmIE1NVSAmJiA2NEJJVAo+ID4gIAlzZWxlY3QgSEFWRV9BUkNIX0tB U0FOX1ZNQUxMT0MgaWYgTU1VICYmIDY0QklUCj4gPiAgCXNlbGVjdCBIQVZFX0FSQ0hfS0ZFTkNF IGlmIE1NVSAmJiA2NEJJVAo+ID4gIAlzZWxlY3QgSEFWRV9BUkNIX0tTVEFDS19FUkFTRQo+ID4g LQlzZWxlY3QgSEFWRV9BUkNIX0tHREIgaWYgIVhJUF9LRVJORUwKPiA+ICsJc2VsZWN0IEhBVkVf QVJDSF9LR0RCCj4gPiAgCXNlbGVjdCBIQVZFX0FSQ0hfS0dEQl9RWEZFUl9QS1QKPiA+ICAJc2Vs ZWN0IEhBVkVfQVJDSF9NTUFQX1JORF9CSVRTIGlmIE1NVQo+ID4gIAlzZWxlY3QgSEFWRV9BUkNI X01NQVBfUk5EX0NPTVBBVF9CSVRTIGlmIENPTVBBVAo+ID4gQEAgLTE1NCw3ICsxNTQsNyBAQCBj b25maWcgUklTQ1YKPiA+ICAJc2VsZWN0IEhBVkVfQ09OVEVYVF9UUkFDS0lOR19VU0VSCj4gPiAg CXNlbGVjdCBIQVZFX0RFQlVHX0tNRU1MRUFLCj4gPiAgCXNlbGVjdCBIQVZFX0RNQV9DT05USUdV T1VTIGlmIE1NVQo+ID4gLQlzZWxlY3QgSEFWRV9EWU5BTUlDX0ZUUkFDRSBpZiAhWElQX0tFUk5F TCAmJiBNTVUgJiYgKENMQU5HX1NVUFBPUlRTX0RZTkFNSUNfRlRSQUNFIHx8IEdDQ19TVVBQT1JU U19EWU5BTUlDX0ZUUkFDRSkKPiA+ICsJc2VsZWN0IEhBVkVfRFlOQU1JQ19GVFJBQ0UgaWYgTU1V ICYmIChDTEFOR19TVVBQT1JUU19EWU5BTUlDX0ZUUkFDRSB8fCBHQ0NfU1VQUE9SVFNfRFlOQU1J Q19GVFJBQ0UpCj4gPiAgCXNlbGVjdCBGVU5DVElPTl9BTElHTk1FTlRfNEIgaWYgSEFWRV9EWU5B TUlDX0ZUUkFDRSAmJiBSSVNDVl9JU0FfQwo+ID4gIAlzZWxlY3QgSEFWRV9EWU5BTUlDX0ZUUkFD RV9XSVRIX0RJUkVDVF9DQUxMUyBpZiBIQVZFX0RZTkFNSUNfRlRSQUNFX1dJVEhfQ0FMTF9PUFMK PiA+ICAJc2VsZWN0IEhBVkVfRFlOQU1JQ19GVFJBQ0VfV0lUSF9DQUxMX09QUyBpZiAoRFlOQU1J Q19GVFJBQ0VfV0lUSF9BUkdTICYmICFDRkkpCj4gPiBAQCAtMTYyLDcgKzE2Miw3IEBAIGNvbmZp ZyBSSVNDVgo+ID4gIAlzZWxlY3QgSEFWRV9GVFJBQ0VfR1JBUEhfRlVOQwo+ID4gIAlzZWxlY3Qg SEFWRV9GVU5DVElPTl9HUkFQSF9UUkFDRVIgaWYgSEFWRV9EWU5BTUlDX0ZUUkFDRV9XSVRIX0FS R1MKPiA+ICAJc2VsZWN0IEhBVkVfRlVOQ1RJT05fR1JBUEhfRlJFR1MKPiA+IC0Jc2VsZWN0IEhB VkVfRlVOQ1RJT05fVFJBQ0VSIGlmICFYSVBfS0VSTkVMICYmIEhBVkVfRFlOQU1JQ19GVFJBQ0UK PiA+ICsJc2VsZWN0IEhBVkVfRlVOQ1RJT05fVFJBQ0VSIGlmIEhBVkVfRFlOQU1JQ19GVFJBQ0UK PiA+ICAJc2VsZWN0IEhBVkVfRUJQRl9KSVQgaWYgTU1VCj4gPiAgCXNlbGVjdCBIQVZFX0dFTkVS SUNfVElGX0JJVFMKPiA+ICAJc2VsZWN0IEhBVkVfR1VQX0ZBU1QgaWYgTU1VCj4gPiBAQCAtMTcx LDE2ICsxNzEsMTYgQEAgY29uZmlnIFJJU0NWCj4gPiAgCXNlbGVjdCBIQVZFX0dDQ19QTFVHSU5T Cj4gPiAgCXNlbGVjdCBIQVZFX0dFTkVSSUNfVkRTTyBpZiBNTVUKPiA+ICAJc2VsZWN0IEhBVkVf SVJRX1RJTUVfQUNDT1VOVElORwo+ID4gLQlzZWxlY3QgSEFWRV9LRVJORUxfQlpJUDIgaWYgIVhJ UF9LRVJORUwgJiYgIUVGSV9aQk9PVAo+ID4gLQlzZWxlY3QgSEFWRV9LRVJORUxfR1pJUCBpZiAh WElQX0tFUk5FTCAmJiAhRUZJX1pCT09UCj4gPiAtCXNlbGVjdCBIQVZFX0tFUk5FTF9MWjQgaWYg IVhJUF9LRVJORUwgJiYgIUVGSV9aQk9PVAo+ID4gLQlzZWxlY3QgSEFWRV9LRVJORUxfTFpNQSBp ZiAhWElQX0tFUk5FTCAmJiAhRUZJX1pCT09UCj4gPiAtCXNlbGVjdCBIQVZFX0tFUk5FTF9MWk8g aWYgIVhJUF9LRVJORUwgJiYgIUVGSV9aQk9PVAo+ID4gLQlzZWxlY3QgSEFWRV9LRVJORUxfVU5D T01QUkVTU0VEIGlmICFYSVBfS0VSTkVMICYmICFFRklfWkJPT1QKPiA+IC0Jc2VsZWN0IEhBVkVf S0VSTkVMX1pTVEQgaWYgIVhJUF9LRVJORUwgJiYgIUVGSV9aQk9PVAo+ID4gLQlzZWxlY3QgSEFW RV9LRVJORUxfWFogaWYgIVhJUF9LRVJORUwgJiYgIUVGSV9aQk9PVAo+ID4gLQlzZWxlY3QgSEFW RV9LUFJPQkVTIGlmICFYSVBfS0VSTkVMCj4gPiAtCXNlbGVjdCBIQVZFX0tSRVRQUk9CRVMgaWYg IVhJUF9LRVJORUwKPiA+ICsJc2VsZWN0IEhBVkVfS0VSTkVMX0JaSVAyIGlmICFFRklfWkJPT1QK PiA+ICsJc2VsZWN0IEhBVkVfS0VSTkVMX0daSVAgaWYgIUVGSV9aQk9PVAo+ID4gKwlzZWxlY3Qg SEFWRV9LRVJORUxfTFo0IGlmICFFRklfWkJPT1QKPiA+ICsJc2VsZWN0IEhBVkVfS0VSTkVMX0xa TUEgaWYgIUVGSV9aQk9PVAo+ID4gKwlzZWxlY3QgSEFWRV9LRVJORUxfTFpPIGlmICFFRklfWkJP T1QKPiA+ICsJc2VsZWN0IEhBVkVfS0VSTkVMX1VOQ09NUFJFU1NFRCBpZiAhRUZJX1pCT09UCj4g PiArCXNlbGVjdCBIQVZFX0tFUk5FTF9aU1REIGlmICFFRklfWkJPT1QKPiA+ICsJc2VsZWN0IEhB VkVfS0VSTkVMX1haIGlmICFFRklfWkJPT1QKPiA+ICsJc2VsZWN0IEhBVkVfS1BST0JFUwo+ID4g KwlzZWxlY3QgSEFWRV9LUkVUUFJPQkVTCj4gPiAgCSMgaHR0cHM6Ly9naXRodWIuY29tL0NsYW5n QnVpbHRMaW51eC9saW51eC9pc3N1ZXMvMTg4MQo+ID4gIAlzZWxlY3QgSEFWRV9MRF9ERUFEX0NP REVfREFUQV9FTElNSU5BVElPTiBpZiAhTERfSVNfTExECj4gPiAgCXNlbGVjdCBIQVZFX01PVkVf UE1ECj4gPiBAQCAtMTkxLDkgKzE5MSw5IEBAIGNvbmZpZyBSSVNDVgo+ID4gIAlzZWxlY3QgSEFW RV9QRVJGX1JFR1MKPiA+ICAJc2VsZWN0IEhBVkVfUEVSRl9VU0VSX1NUQUNLX0RVTVAKPiA+ICAJ c2VsZWN0IEhBVkVfUE9TSVhfQ1BVX1RJTUVSU19UQVNLX1dPUksKPiA+IC0Jc2VsZWN0IEhBVkVf UFJFRU1QVF9EWU5BTUlDX0tFWSBpZiAhWElQX0tFUk5FTAo+ID4gKwlzZWxlY3QgSEFWRV9QUkVF TVBUX0RZTkFNSUNfS0VZCj4gPiAgCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FDQ0VTU19B UEkKPiA+IC0Jc2VsZWN0IEhBVkVfUkVUSE9PSyBpZiAhWElQX0tFUk5FTAo+ID4gKwlzZWxlY3Qg SEFWRV9SRVRIT09LCj4gPiAgCXNlbGVjdCBIQVZFX1JTRVEKPiA+ICAJc2VsZWN0IEhBVkVfUlVT VCBpZiBSVVNUQ19TVVBQT1JUU19SSVNDViAmJiBDQ19JU19DTEFORwo+ID4gIAlzZWxlY3QgSEFW RV9TQU1QTEVfRlRSQUNFX0RJUkVDVAo+ID4gQEAgLTIxNCw3ICsyMTQsNyBAQCBjb25maWcgUklT Q1YKPiA+ICAJc2VsZWN0IFBDSV9FQ0FNIGlmIChBQ1BJICYmIFBDSSkKPiA+ICAJc2VsZWN0IFBD SV9NU0kgaWYgUENJCj4gPiAgCXNlbGVjdCBSRUxPQ0FUQUJMRSBpZiAhTU1VICYmICFQSFlTX1JB TV9CQVNFX0ZJWEVECj4gPiAtCXNlbGVjdCBSSVNDVl9BTFRFUk5BVElWRSBpZiAhWElQX0tFUk5F TAo+ID4gKwlzZWxlY3QgUklTQ1ZfQUxURVJOQVRJVkUKPiA+ICAJc2VsZWN0IFJJU0NWX0FQTElD Cj4gPiAgCXNlbGVjdCBSSVNDVl9JTVNJQwo+ID4gIAlzZWxlY3QgUklTQ1ZfSU5UQwo+ID4gQEAg LTU0MSw3ICs1NDEsNiBAQCBlbmRjaG9pY2UKPiA+ICAKPiA+ICBjb25maWcgUklTQ1ZfQUxURVJO QVRJVkUKPiA+ICAJYm9vbAo+ID4gLQlkZXBlbmRzIG9uICFYSVBfS0VSTkVMCj4gPiAgCWhlbHAK PiA+ICAJICBUaGlzIEtjb25maWcgYWxsb3dzIHRoZSBrZXJuZWwgdG8gYXV0b21hdGljYWxseSBw YXRjaCB0aGUKPiA+ICAJICBlcnJhdHVtIG9yIGNwdWZlYXR1cmUgcmVxdWlyZWQgYnkgdGhlIGV4 ZWN1dGlvbiBwbGF0Zm9ybSBhdCBydW4KPiA+IEBAIC0xMTI5LDcgKzExMjgsNiBAQCBjb25maWcg UEFSQVZJUlRfVElNRV9BQ0NPVU5USU5HCj4gPiAgCj4gPiAgY29uZmlnIFJFTE9DQVRBQkxFCj4g PiAgCWJvb2wgIkJ1aWxkIGEgcmVsb2NhdGFibGUga2VybmVsIgo+ID4gLQlkZXBlbmRzIG9uICFY SVBfS0VSTkVMCj4gPiAgCXNlbGVjdCBNT0RVTEVfU0VDVElPTlMgaWYgTU9EVUxFUwo+ID4gIAlz ZWxlY3QgQVJDSF9WTUxJTlVYX05FRURTX1JFTE9DUwo+ID4gIAloZWxwCj4gPiBAQCAtMTE0Niw3 ICsxMTQ0LDcgQEAgY29uZmlnIFJFTE9DQVRBQkxFCj4gPiAgY29uZmlnIFJBTkRPTUlaRV9CQVNF Cj4gPiAgICAgICAgICBib29sICJSYW5kb21pemUgdGhlIGFkZHJlc3Mgb2YgdGhlIGtlcm5lbCBp bWFnZSIKPiA+ICAgICAgICAgIHNlbGVjdCBSRUxPQ0FUQUJMRQo+ID4gLSAgICAgICAgZGVwZW5k cyBvbiBNTVUgJiYgNjRCSVQgJiYgIVhJUF9LRVJORUwKPiA+ICsgICAgICAgIGRlcGVuZHMgb24g TU1VICYmIDY0QklUCj4gPiAgICAgICAgICBoZWxwCj4gPiAgICAgICAgICAgIFJhbmRvbWl6ZXMg dGhlIHZpcnR1YWwgYWRkcmVzcyBhdCB3aGljaCB0aGUga2VybmVsIGltYWdlIGlzCj4gPiAgICAg ICAgICAgIGxvYWRlZCwgYXMgYSBzZWN1cml0eSBmZWF0dXJlIHRoYXQgZGV0ZXJzIGV4cGxvaXQg YXR0ZW1wdHMKPiA+IEBAIC0xMjM2LDcgKzEyMzQsNyBAQCBjb25maWcgRUZJX1NUVUIKPiA+ICAK PiA+ICBjb25maWcgRUZJCj4gPiAgCWJvb2wgIlVFRkkgcnVudGltZSBzdXBwb3J0Igo+ID4gLQlk ZXBlbmRzIG9uIE9GICYmICFYSVBfS0VSTkVMCj4gPiArCWRlcGVuZHMgb24gT0YKPiA+ICAJZGVw ZW5kcyBvbiBNTVUKPiA+ICAJZGVmYXVsdCB5Cj4gPiAgCXNlbGVjdCBBUkNIX1NVUFBPUlRTX0FD UEkgaWYgNjRCSVQKPiA+IEBAIC0xMjg3LDQ0ICsxMjg1LDYgQEAgY29uZmlnIFBIWVNfUkFNX0JB U0UKPiA+ICAJICBleHBsaWNpdGx5IHNwZWNpZmllZCB0byBydW4gZWFybHkgcmVsb2NhdGlvbnMg b2YgcmVhZC13cml0ZSBkYXRhCj4gPiAgCSAgZnJvbSBmbGFzaCB0byBSQU0uCj4gPiAgCj4gPiAt Y29uZmlnIFhJUF9LRVJORUwKPiA+IC0JYm9vbCAiS2VybmVsIEV4ZWN1dGUtSW4tUGxhY2UgZnJv bSBST00iCj4gPiAtCWRlcGVuZHMgb24gTU1VICYmIFNQQVJTRU1FTSAmJiBOT05QT1JUQUJMRQo+ ID4gLQkjIFRoaXMgcHJldmVudHMgWElQIGZyb20gYmVpbmcgZW5hYmxlZCBieSBhbGx7eWVzLG1v ZH1jb25maWcsIHdoaWNoCj4gPiAtCSMgZmFpbCB0byBidWlsZCBzaW5jZSBYSVAgZG9lc24ndCBz dXBwb3J0IGxhcmdlIGtlcm5lbHMuCj4gPiAtCWRlcGVuZHMgb24gIUNPTVBJTEVfVEVTVAo+ID4g LQlzZWxlY3QgUEhZU19SQU1fQkFTRV9GSVhFRAo+ID4gLQloZWxwCj4gPiAtCSAgRXhlY3V0ZS1J bi1QbGFjZSBhbGxvd3MgdGhlIGtlcm5lbCB0byBydW4gZnJvbSBub24tdm9sYXRpbGUgc3RvcmFn ZQo+ID4gLQkgIGRpcmVjdGx5IGFkZHJlc3NhYmxlIGJ5IHRoZSBDUFUsIHN1Y2ggYXMgTk9SIGZs YXNoLiBUaGlzIHNhdmVzIFJBTQo+ID4gLQkgIHNwYWNlIHNpbmNlIHRoZSB0ZXh0IHNlY3Rpb24g b2YgdGhlIGtlcm5lbCBpcyBub3QgbG9hZGVkIGZyb20gZmxhc2gKPiA+IC0JICB0byBSQU0uICBS ZWFkLXdyaXRlIHNlY3Rpb25zLCBzdWNoIGFzIHRoZSBkYXRhIHNlY3Rpb24gYW5kIHN0YWNrLAo+ ID4gLQkgIGFyZSBzdGlsbCBjb3BpZWQgdG8gUkFNLiAgVGhlIFhJUCBrZXJuZWwgaXMgbm90IGNv bXByZXNzZWQgc2luY2UKPiA+IC0JICBpdCBoYXMgdG8gcnVuIGRpcmVjdGx5IGZyb20gZmxhc2gs IHNvIGl0IHdpbGwgdGFrZSBtb3JlIHNwYWNlIHRvCj4gPiAtCSAgc3RvcmUgaXQuICBUaGUgZmxh c2ggYWRkcmVzcyB1c2VkIHRvIGxpbmsgdGhlIGtlcm5lbCBvYmplY3QgZmlsZXMsCj4gPiAtCSAg YW5kIGZvciBzdG9yaW5nIGl0LCBpcyBjb25maWd1cmF0aW9uIGRlcGVuZGVudC4gVGhlcmVmb3Jl LCBpZiB5b3UKPiA+IC0JICBzYXkgWSBoZXJlLCB5b3UgbXVzdCBrbm93IHRoZSBwcm9wZXIgcGh5 c2ljYWwgYWRkcmVzcyB3aGVyZSB0bwo+ID4gLQkgIHN0b3JlIHRoZSBrZXJuZWwgaW1hZ2UgZGVw ZW5kaW5nIG9uIHlvdXIgb3duIGZsYXNoIG1lbW9yeSB1c2FnZS4KPiA+IC0KPiA+IC0JICBBbHNv IG5vdGUgdGhhdCB0aGUgbWFrZSB0YXJnZXQgYmVjb21lcyAibWFrZSB4aXBJbWFnZSIgcmF0aGVy IHRoYW4KPiA+IC0JICAibWFrZSB6SW1hZ2UiIG9yICJtYWtlIEltYWdlIi4gIFRoZSBmaW5hbCBr ZXJuZWwgYmluYXJ5IHRvIHB1dCBpbgo+ID4gLQkgIFJPTSBtZW1vcnkgd2lsbCBiZSBhcmNoL3Jp c2N2L2Jvb3QveGlwSW1hZ2UuCj4gPiAtCj4gPiAtCSAgU1BBUlNFTUVNIGlzIHJlcXVpcmVkIGJl Y2F1c2UgdGhlIGtlcm5lbCB0ZXh0IGFuZCByb2RhdGEgdGhhdCBhcmUKPiA+IC0JICBmbGFzaCBy ZXNpZGVudCBhcmUgbm90IGJhY2tlZCBieSBtZW1tYXAsIHRoZW4gYW55IGF0dGVtcHQgdG8gZ2V0 Cj4gPiAtCSAgYSBzdHJ1Y3QgcGFnZSBvbiB0aG9zZSByZWdpb25zIHdpbGwgdHJpZ2dlciBhIGZh dWx0Lgo+ID4gLQo+ID4gLQkgIElmIHVuc3VyZSwgc2F5IE4uCj4gPiAtCj4gPiAtY29uZmlnIFhJ UF9QSFlTX0FERFIKPiA+IC0JaGV4ICJYSVAgS2VybmVsIFBoeXNpY2FsIExvY2F0aW9uIgo+ID4g LQlkZXBlbmRzIG9uIFhJUF9LRVJORUwKPiA+IC0JZGVmYXVsdCAiMHgyMTAwMDAwMCIKPiA+IC0J aGVscAo+ID4gLQkgIFRoaXMgaXMgdGhlIHBoeXNpY2FsIGFkZHJlc3MgaW4geW91ciBmbGFzaCBt ZW1vcnkgdGhlIGtlcm5lbCB3aWxsCj4gPiAtCSAgYmUgbGlua2VkIGZvciBhbmQgc3RvcmVkIHRv LiAgVGhpcyBhZGRyZXNzIGlzIGRlcGVuZGVudCBvbiB5b3VyCj4gPiAtCSAgb3duIGZsYXNoIHVz YWdlLgo+ID4gLQo+ID4gIGNvbmZpZyBSSVNDVl9JU0FfRkFMTEJBQ0sKPiA+ICAJYm9vbCAiUGVy bWl0IGZhbGxpbmcgYmFjayB0byBwYXJzaW5nIHJpc2N2LGlzYSBmb3IgZXh0ZW5zaW9uIHN1cHBv cnQgYnkgZGVmYXVsdCIKPiA+ICAJZGVmYXVsdCB5Cj4gPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNj di9LY29uZmlnLnNvY3MgYi9hcmNoL3Jpc2N2L0tjb25maWcuc29jcwo+ID4gaW5kZXggZDYyMWI4 NWRkNjNiLi5jMTc0YWMwZWM0NmIgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNoL3Jpc2N2L0tjb25maWcu c29jcwo+ID4gKysrIGIvYXJjaC9yaXNjdi9LY29uZmlnLnNvY3MKPiA+IEBAIC0yLDcgKzIsNyBA QCBtZW51ICJTb0Mgc2VsZWN0aW9uIgo+ID4gIAo+ID4gIGNvbmZpZyBBUkNIX0FOREVTCj4gPiAg CWJvb2wgIkFuZGVzIFNvQ3MiCj4gPiAtCWRlcGVuZHMgb24gTU1VICYmICFYSVBfS0VSTkVMCj4g PiArCWRlcGVuZHMgb24gTU1VCj4gPiAgCXNlbGVjdCBFUlJBVEFfQU5ERVMKPiA+ICAJaGVscAo+ ID4gIAkgIFRoaXMgZW5hYmxlcyBzdXBwb3J0IGZvciBBbmRlcyBTb0MgcGxhdGZvcm0gaGFyZHdh cmUuCj4gPiBAQCAtMzMsNyArMzMsNyBAQCBjb25maWcgQVJDSF9SRU5FU0FTCj4gPiAgCj4gPiAg Y29uZmlnIEFSQ0hfU0lGSVZFCj4gPiAgCWJvb2wgIlNpRml2ZSBTb0NzIgo+ID4gLQlzZWxlY3Qg RVJSQVRBX1NJRklWRSBpZiAhWElQX0tFUk5FTAo+ID4gKwlzZWxlY3QgRVJSQVRBX1NJRklWRQo+ ID4gIAloZWxwCj4gPiAgCSAgVGhpcyBlbmFibGVzIHN1cHBvcnQgZm9yIFNpRml2ZSBTb0MgcGxh dGZvcm0gaGFyZHdhcmUuCj4gPiAgCj4gPiBAQCAtNjEsNyArNjEsNyBAQCBjb25maWcgU09DX1NU QVJGSVZFCj4gPiAgCj4gPiAgY29uZmlnIEFSQ0hfU1VOWEkKPiA+ICAJYm9vbCAiQWxsd2lubmVy IHN1bjIwaSBTb0NzIgo+ID4gLQlkZXBlbmRzIG9uIE1NVSAmJiAhWElQX0tFUk5FTAo+ID4gKwlk ZXBlbmRzIG9uIE1NVQo+ID4gIAlzZWxlY3QgRVJSQVRBX1RIRUFECj4gPiAgCXNlbGVjdCBTVU40 SV9USU1FUgo+ID4gIAloZWxwCj4gPiBAQCAtNzgsNyArNzgsNyBAQCBjb25maWcgQVJDSF9URU5T VE9SUkVOVAo+ID4gIAo+ID4gIGNvbmZpZyBBUkNIX1RIRUFECj4gPiAgCWJvb2wgIlQtSEVBRCBS SVNDLVYgU29DcyIKPiA+IC0JZGVwZW5kcyBvbiBNTVUgJiYgIVhJUF9LRVJORUwKPiA+ICsJZGVw ZW5kcyBvbiBNTVUKPiA+ICAJc2VsZWN0IEVSUkFUQV9USEVBRAo+ID4gIAlzZWxlY3QgUE1fR0VO RVJJQ19ET01BSU5TIGlmIFBNCj4gPiAgCWhlbHAKPiA+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2 L01ha2VmaWxlIGIvYXJjaC9yaXNjdi9NYWtlZmlsZQo+ID4gaW5kZXggMzcxZGE3NWE0N2Y5Li4y Y2RhODdhNWFhZjEgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNoL3Jpc2N2L01ha2VmaWxlCj4gPiArKysg Yi9hcmNoL3Jpc2N2L01ha2VmaWxlCj4gPiBAQCAtMTUwLDcgKzE1MCw2IEBAIGlmZGVmIENPTkZJ R19SSVNDVl9NX01PREUKPiA+ICBib290LWltYWdlLSQoQ09ORklHX1NPQ19DQU5BQU5fSzIxMCkJ Oj0gbG9hZGVyLmJpbgo+ID4gIGVuZGlmCj4gPiAgYm9vdC1pbWFnZS0kKENPTkZJR19FRklfWkJP T1QpCQk6PSB2bWxpbnV6LmVmaQo+ID4gLWJvb3QtaW1hZ2UtJChDT05GSUdfWElQX0tFUk5FTCkJ CTo9IHhpcEltYWdlCj4gPiAgS0JVSUxEX0lNQUdFCQkJCTo9ICQoYm9vdCkvJChib290LWltYWdl LXkpCj4gPiAgCj4gPiAgbGlicy15ICs9IGFyY2gvcmlzY3YvbGliLwo+ID4gQEAgLTIxOCw4ICsy MTcsNiBAQCBkZWZpbmUgYXJjaGhlbHAKPiA+ICAgIGVjaG8gICcgIEltYWdlLnh6CS0gQ29tcHJl c3NlZCBrZXJuZWwgaW1hZ2UgKGFyY2gvcmlzY3YvYm9vdC9JbWFnZS54eiknCj4gPiAgICBlY2hv ICAnICB2bWxpbnV6LmVmaQktIENvbXByZXNzZWQgRUZJIGtlcm5lbCBpbWFnZSAoYXJjaC9yaXNj di9ib290L3ZtbGludXouZWZpKScKPiA+ICAgIGVjaG8gICcJCSAgRGVmYXVsdCB3aGVuIENPTkZJ R19FRklfWkJPT1Q9eScKPiA+IC0gIGVjaG8gICcgIHhpcEltYWdlCS0gRXhlY3V0ZS1pbi1wbGFj ZSBrZXJuZWwgaW1hZ2UgKGFyY2gvcmlzY3YvYm9vdC94aXBJbWFnZSknCj4gPiAtICBlY2hvICAn CQkgIERlZmF1bHQgd2hlbiBDT05GSUdfWElQX0tFUk5FTD15Jwo+ID4gICAgZWNobyAgJyAgaW5z dGFsbAktIEluc3RhbGwga2VybmVsIHVzaW5nICh5b3VyKSB+L2Jpbi8kKElOU1RBTExLRVJORUwp IG9yJwo+ID4gICAgZWNobyAgJwkJICAoZGlzdHJpYnV0aW9uKSAvc2Jpbi8kKElOU1RBTExLRVJO RUwpIG9yIGluc3RhbGwgdG8gJwo+ID4gICAgZWNobyAgJwkJICAkJChJTlNUQUxMX1BBVEgpJwo+ ID4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvYm9vdC9NYWtlZmlsZSBiL2FyY2gvcmlzY3YvYm9v dC9NYWtlZmlsZQo+ID4gaW5kZXggNTMwMWFkZjVmM2Y1Li5mY2ZiZTNmODE0ZDYgMTAwNjQ0Cj4g PiAtLS0gYS9hcmNoL3Jpc2N2L2Jvb3QvTWFrZWZpbGUKPiA+ICsrKyBiL2FyY2gvcmlzY3YvYm9v dC9NYWtlZmlsZQo+ID4gQEAgLTIwLDE3ICsyMCw2IEBAIE9CSkNPUFlGTEFHU194aXBJbWFnZSA6 PS1PIGJpbmFyeSAtUiAubm90ZSAtUiAubm90ZS5nbnUuYnVpbGQtaWQgLVIgLmNvbW1lbnQgLVMK PiA+ICAKPiA+ICB0YXJnZXRzIDo9IEltYWdlIEltYWdlLiogbG9hZGVyIGxvYWRlci5vIGxvYWRl ci5sZHMgbG9hZGVyLmJpbiB4aXBJbWFnZQo+ID4gIAo+ID4gLWlmZXEgKCQoQ09ORklHX1hJUF9L RVJORUwpLHkpCj4gPiAtCj4gPiAtcXVpZXRfY21kX21reGlwID0gJChxdWlldF9jbWRfb2JqY29w eSkKPiA+IC1jbWRfbWt4aXAgPSAkKGNtZF9vYmpjb3B5KQo+ID4gLQo+ID4gLSQob2JqKS94aXBJ bWFnZTogdm1saW51eCBGT1JDRQo+ID4gLQkkKGNhbGwgaWZfY2hhbmdlZCxta3hpcCkKPiA+IC0J QCQoa2VjaG8pICcgIFBoeXNpY2FsIEFkZHJlc3Mgb2YgeGlwSW1hZ2U6ICQoQ09ORklHX1hJUF9Q SFlTX0FERFIpJwo+ID4gLQo+ID4gLWVuZGlmCj4gPiAtCj4gPiAgJChvYmopL0ltYWdlOiB2bWxp bnV4IEZPUkNFCj4gPiAgCSQoY2FsbCBpZl9jaGFuZ2VkLG9iamNvcHkpCj4gPiAgCj4gPiBkaWZm IC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9wYWdlLmggYi9hcmNoL3Jpc2N2L2luY2x1 ZGUvYXNtL3BhZ2UuaAo+ID4gaW5kZXggM2M1MTdiYzllYWM1Li45Y2NkODBkNTdmZmUgMTAwNjQ0 Cj4gPiAtLS0gYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3BhZ2UuaAo+ID4gKysrIGIvYXJjaC9y aXNjdi9pbmNsdWRlL2FzbS9wYWdlLmgKPiA+IEBAIC0yOSwxMSArMjksNyBAQAo+ID4gICNkZWZp bmUgUEFHRV9PRkZTRVRfTDUJCV9BQygweGZmNjAwMDAwMDAwMDAwMDAsIFVMKQo+ID4gICNkZWZp bmUgUEFHRV9PRkZTRVRfTDQJCV9BQygweGZmZmZhZjgwMDAwMDAwMDAsIFVMKQo+ID4gICNkZWZp bmUgUEFHRV9PRkZTRVRfTDMJCV9BQygweGZmZmZmZmQ2MDAwMDAwMDAsIFVMKQo+ID4gLSNpZmRl ZiBDT05GSUdfWElQX0tFUk5FTAo+ID4gLSNkZWZpbmUgUEFHRV9PRkZTRVQJCVBBR0VfT0ZGU0VU X0wzCj4gPiAtI2Vsc2UKPiA+ICAjZGVmaW5lIFBBR0VfT0ZGU0VUCQlrZXJuZWxfbWFwLnBhZ2Vf b2Zmc2V0Cj4gPiAtI2VuZGlmIC8qIENPTkZJR19YSVBfS0VSTkVMICovCj4gPiAgI2Vsc2UKPiA+ ICAjZGVmaW5lIFBBR0VfT0ZGU0VUCQlfQUMoMHhjMDAwMDAwMCwgVUwpCj4gPiAgI2VuZGlmIC8q IENPTkZJR182NEJJVCAqLwo+ID4gQEAgLTEwNSwxNSArMTAxLDggQEAgc3RydWN0IGtlcm5lbF9t YXBwaW5nIHsKPiA+ICAJLyogT2Zmc2V0IGJldHdlZW4gbGluZWFyIG1hcHBpbmcgdmlydHVhbCBh ZGRyZXNzIGFuZCBrZXJuZWwgbG9hZCBhZGRyZXNzICovCj4gPiAgCXVuc2lnbmVkIGxvbmcgdmFf cGFfb2Zmc2V0Owo+ID4gIAkvKiBPZmZzZXQgYmV0d2VlbiBrZXJuZWwgbWFwcGluZyB2aXJ0dWFs IGFkZHJlc3MgYW5kIGtlcm5lbCBsb2FkIGFkZHJlc3MgKi8KPiA+IC0jaWZkZWYgQ09ORklHX1hJ UF9LRVJORUwKPiA+IC0JdW5zaWduZWQgbG9uZyB2YV9rZXJuZWxfeGlwX3RleHRfcGFfb2Zmc2V0 Owo+ID4gLQl1bnNpZ25lZCBsb25nIHZhX2tlcm5lbF94aXBfZGF0YV9wYV9vZmZzZXQ7Cj4gPiAt CXVpbnRwdHJfdCB4aXByb207Cj4gPiAtCXVpbnRwdHJfdCB4aXByb21fc3o7Cj4gPiAtI2Vsc2UK PiA+ICAJdW5zaWduZWQgbG9uZyBwYWdlX29mZnNldDsKPiA+ICAJdW5zaWduZWQgbG9uZyB2YV9r ZXJuZWxfcGFfb2Zmc2V0Owo+ID4gLSNlbmRpZgo+ID4gIH07Cj4gPiAgCj4gPiAgZXh0ZXJuIHN0 cnVjdCBrZXJuZWxfbWFwcGluZyBrZXJuZWxfbWFwOwo+ID4gQEAgLTEzMiwxNiArMTIxLDcgQEAg ZXh0ZXJuIHVuc2lnbmVkIGxvbmcgdm1lbW1hcF9zdGFydF9wZm47Cj4gPiAgdm9pZCAqbGluZWFy X21hcHBpbmdfcGFfdG9fdmEodW5zaWduZWQgbG9uZyB4KTsKPiA+ICAjZW5kaWYKPiA+ICAKPiA+ IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiA+IC0jZGVmaW5lIGtlcm5lbF9tYXBwaW5nX3Bh X3RvX3ZhKHkpCSh7CQkJCQlcCj4gPiAtCXVuc2lnbmVkIGxvbmcgX3kgPSAodW5zaWduZWQgbG9u ZykoeSk7CQkJCQlcCj4gPiAtCShfeSA8IHBoeXNfcmFtX2Jhc2UpID8JCQkJCQkJXAo+ID4gLQkJ KHZvaWQgKikoX3kgKyBrZXJuZWxfbWFwLnZhX2tlcm5lbF94aXBfdGV4dF9wYV9vZmZzZXQpIDoJ XAo+ID4gLQkJKHZvaWQgKikoX3kgKyBrZXJuZWxfbWFwLnZhX2tlcm5lbF94aXBfZGF0YV9wYV9v ZmZzZXQpOwkJXAo+ID4gLQl9KQo+ID4gLSNlbHNlCj4gPiAgI2RlZmluZSBrZXJuZWxfbWFwcGlu Z19wYV90b192YSh5KSAoKHZvaWQgKikoKHVuc2lnbmVkIGxvbmcpKHkpICsga2VybmVsX21hcC52 YV9rZXJuZWxfcGFfb2Zmc2V0KSkKPiA+IC0jZW5kaWYKPiA+ICAKPiA+ICAjZGVmaW5lIF9fcGFf dG9fdmFfbm9kZWJ1Zyh4KQkJbGluZWFyX21hcHBpbmdfcGFfdG9fdmEoeCkKPiA+ICAKPiA+IEBA IC0xNTEsMTYgKzEzMSw3IEBAIHZvaWQgKmxpbmVhcl9tYXBwaW5nX3BhX3RvX3ZhKHVuc2lnbmVk IGxvbmcgeCk7Cj4gPiAgcGh5c19hZGRyX3QgbGluZWFyX21hcHBpbmdfdmFfdG9fcGEodW5zaWdu ZWQgbG9uZyB4KTsKPiA+ICAjZW5kaWYKPiA+ICAKPiA+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJO RUwKPiA+IC0jZGVmaW5lIGtlcm5lbF9tYXBwaW5nX3ZhX3RvX3BhKHkpICh7CQkJCQkJXAo+ID4g LQl1bnNpZ25lZCBsb25nIF95ID0gKHVuc2lnbmVkIGxvbmcpKHkpOwkJCQkJXAo+ID4gLQkoX3kg PCBrZXJuZWxfbWFwLnZpcnRfYWRkciArIGtlcm5lbF9tYXAueGlwcm9tX3N6KSA/CQkJXAo+ID4g LQkJKF95IC0ga2VybmVsX21hcC52YV9rZXJuZWxfeGlwX3RleHRfcGFfb2Zmc2V0KSA6CQlcCj4g PiAtCQkoX3kgLSBrZXJuZWxfbWFwLnZhX2tlcm5lbF94aXBfZGF0YV9wYV9vZmZzZXQpOwkJCVwK PiA+IC0JfSkKPiA+IC0jZWxzZQo+ID4gICNkZWZpbmUga2VybmVsX21hcHBpbmdfdmFfdG9fcGEo eSkgKCh1bnNpZ25lZCBsb25nKSh5KSAtIGtlcm5lbF9tYXAudmFfa2VybmVsX3BhX29mZnNldCkK PiA+IC0jZW5kaWYKPiA+ICAKPiA+ICAjZGVmaW5lIF9fdmFfdG9fcGFfbm9kZWJ1Zyh4KQkoewkJ CQkJCVwKPiA+ICAJdW5zaWduZWQgbG9uZyBfeCA9IHg7CQkJCQkJCVwKPiA+IGRpZmYgLS1naXQg YS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3BndGFibGUuaCBiL2FyY2gvcmlzY3YvaW5jbHVkZS9h c20vcGd0YWJsZS5oCj4gPiBpbmRleCAxMzQwYWEzOThhNzQuLmExOGMwZjYyYjQ1MiAxMDA2NDQK PiA+IC0tLSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vcGd0YWJsZS5oCj4gPiArKysgYi9hcmNo L3Jpc2N2L2luY2x1ZGUvYXNtL3BndGFibGUuaAo+ID4gQEAgLTEzNCwyMSArMTM0LDYgQEAKPiA+ ICAKPiA+ICAjaW5jbHVkZSA8bGludXgvcGFnZV90YWJsZV9jaGVjay5oPgo+ID4gIAo+ID4gLSNp ZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ID4gLSNkZWZpbmUgWElQX0ZJWFVQKGFkZHIpICh7CQkJ CQkJCVwKPiA+IC0JZXh0ZXJuIGNoYXIgX3NkYXRhW10sIF9zdGFydFtdLCBfZW5kW107CQkJCQlc Cj4gPiAtCXVpbnRwdHJfdCBfX3JvbV9zdGFydF9kYXRhID0gQ09ORklHX1hJUF9QSFlTX0FERFIJ CQlcCj4gPiAtCQkJCSsgKHVpbnRwdHJfdCkmX3NkYXRhIC0gKHVpbnRwdHJfdCkmX3N0YXJ0Owlc Cj4gPiAtCXVpbnRwdHJfdCBfX3JvbV9lbmRfZGF0YSA9IENPTkZJR19YSVBfUEhZU19BRERSCQkJ CVwKPiA+IC0JCQkJKyAodWludHB0cl90KSZfZW5kIC0gKHVpbnRwdHJfdCkmX3N0YXJ0OwlcCj4g PiAtCXVpbnRwdHJfdCBfX2EgPSAodWludHB0cl90KShhZGRyKTsJCQkJCVwKPiA+IC0JKF9fYSA+ PSBfX3JvbV9zdGFydF9kYXRhICYmIF9fYSA8IF9fcm9tX2VuZF9kYXRhKSA/CQkJXAo+ID4gLQkJ X19hIC0gX19yb21fc3RhcnRfZGF0YSArIENPTkZJR19QSFlTX1JBTV9CQVNFIDoJX19hOwkJXAo+ ID4gLQl9KQo+ID4gLSNlbHNlCj4gPiAtI2RlZmluZSBYSVBfRklYVVAoYWRkcikJCShhZGRyKQo+ ID4gLSNlbmRpZiAvKiBDT05GSUdfWElQX0tFUk5FTCAqLwo+ID4gLQo+ID4gIHN0cnVjdCBwdF9h bGxvY19vcHMgewo+ID4gIAlwdGVfdCAqKCpnZXRfcHRlX3ZpcnQpKHBoeXNfYWRkcl90IHBhKTsK PiA+ICAJcGh5c19hZGRyX3QgKCphbGxvY19wdGUpKHVpbnRwdHJfdCB2YSk7Cj4gPiBAQCAtMTI3 MiwxMyArMTI1Nyw4IEBAIHN0YXRpYyBpbmxpbmUgcHRlX3QgcHRlX3N3cF9jbGVhcl9leGNsdXNp dmUocHRlX3QgcHRlKQo+ID4gIGV4dGVybiBjaGFyIF9zdGFydFtdOwo+ID4gIGV4dGVybiB2b2lk ICpfZHRiX2Vhcmx5X3ZhOwo+ID4gIGV4dGVybiB1aW50cHRyX3QgX2R0Yl9lYXJseV9wYTsKPiA+ IC0jaWYgZGVmaW5lZChDT05GSUdfWElQX0tFUk5FTCkgJiYgZGVmaW5lZChDT05GSUdfTU1VKQo+ ID4gLSNkZWZpbmUgZHRiX2Vhcmx5X3ZhCSgqKHZvaWQgKiopWElQX0ZJWFVQKCZfZHRiX2Vhcmx5 X3ZhKSkKPiA+IC0jZGVmaW5lIGR0Yl9lYXJseV9wYQkoKih1aW50cHRyX3QgKilYSVBfRklYVVAo Jl9kdGJfZWFybHlfcGEpKQo+ID4gLSNlbHNlCj4gPiAgI2RlZmluZSBkdGJfZWFybHlfdmEJX2R0 Yl9lYXJseV92YQo+ID4gICNkZWZpbmUgZHRiX2Vhcmx5X3BhCV9kdGJfZWFybHlfcGEKPiA+IC0j ZW5kaWYgLyogQ09ORklHX1hJUF9LRVJORUwgKi8KPiA+ICBleHRlcm4gdTY0IHNhdHBfbW9kZTsK PiA+ICAKPiA+ICB2b2lkIHBhZ2luZ19pbml0KHZvaWQpOwo+ID4gZGlmZiAtLWdpdCBhL2FyY2gv cmlzY3YvaW5jbHVkZS9hc20vc2NzLmggYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3Njcy5oCj4g PiBpbmRleCBhYjc3MTRhYTkzYmQuLjAyM2E0MTJmZTM4ZCAxMDA2NDQKPiA+IC0tLSBhL2FyY2gv cmlzY3YvaW5jbHVkZS9hc20vc2NzLmgKPiA+ICsrKyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20v c2NzLmgKPiA+IEBAIC0xMCw3ICsxMCw2IEBACj4gPiAgLyogTG9hZCBpbml0X3NoYWRvd19jYWxs X3N0YWNrIHRvIGdwLiAqLwo+ID4gIC5tYWNybyBzY3NfbG9hZF9pbml0X3N0YWNrCj4gPiAgCWxh CWdwLCBpbml0X3NoYWRvd19jYWxsX3N0YWNrCj4gPiAtCVhJUF9GSVhVUF9PRkZTRVQgZ3AKPiA+ ICAuZW5kbQo+ID4gIAo+ID4gIC8qIExvYWQgdGhlIHBlci1DUFUgSVJRIHNoYWRvdyBjYWxsIHN0 YWNrIHRvIGdwLiAqLwo+ID4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc2V0 X21lbW9yeS5oIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zZXRfbWVtb3J5LmgKPiA+IGluZGV4 IDg3Mzg5ZTkzMzI1YS4uZWY1OWUxNzE2YTJjIDEwMDY0NAo+ID4gLS0tIGEvYXJjaC9yaXNjdi9p bmNsdWRlL2FzbS9zZXRfbWVtb3J5LmgKPiA+ICsrKyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20v c2V0X21lbW9yeS5oCj4gPiBAQCAtNDcsNyArNDcsNyBAQCBib29sIGtlcm5lbF9wYWdlX3ByZXNl bnQoc3RydWN0IHBhZ2UgKnBhZ2UpOwo+ID4gIAo+ID4gICNlbmRpZiAvKiBfX0FTU0VNQkxFUl9f ICovCj4gPiAgCj4gPiAtI2lmIGRlZmluZWQoQ09ORklHX1NUUklDVF9LRVJORUxfUldYKSB8fCBk ZWZpbmVkKENPTkZJR19YSVBfS0VSTkVMKQo+ID4gKyNpZiBkZWZpbmVkKENPTkZJR19TVFJJQ1Rf S0VSTkVMX1JXWCkKPiA+ICAjaWZkZWYgQ09ORklHXzY0QklUCj4gPiAgI2RlZmluZSBTRUNUSU9O X0FMSUdOICgxIDw8IDIxKQo+ID4gICNlbHNlCj4gPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9p bmNsdWRlL2FzbS94aXBfZml4dXAuaCBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20veGlwX2ZpeHVw LmgKPiA+IGRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAo+ID4gaW5kZXggZjNkNTYyOTliYzIyLi4w MDAwMDAwMDAwMDAKPiA+IC0tLSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20veGlwX2ZpeHVwLmgK PiA+ICsrKyAvZGV2L251bGwKPiA+IEBAIC0xLDQ5ICswLDAgQEAKPiA+IC0vKiBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5ICovCj4gPiAtLyoKPiA+IC0gKiBYSVAgZml4dXAg bWFjcm9zLCBvbmx5IHVzZWZ1bCBpbiBhc3NlbWJseS4KPiA+IC0gKi8KPiA+IC0jaWZuZGVmIF9B U01fUklTQ1ZfWElQX0ZJWFVQX0gKPiA+IC0jZGVmaW5lIF9BU01fUklTQ1ZfWElQX0ZJWFVQX0gK PiA+IC0KPiA+IC0jaW5jbHVkZSA8bGludXgvcGd0YWJsZS5oPgo+ID4gLQo+ID4gLSNpZmRlZiBD T05GSUdfWElQX0tFUk5FTAo+ID4gLS5tYWNybyBYSVBfRklYVVBfT0ZGU0VUIHJlZwo+ID4gLQkv KiBGaXgtdXAgYWRkcmVzcyBpbiBGbGFzaCBpbnRvIGFkZHJlc3MgaW4gUkFNIGVhcmx5IGR1cmlu ZyBib290IGJlZm9yZQo+ID4gLQkgKiBNTVUgaXMgdXAuIEJlY2F1c2UgZ2VuZXJhdGVkIGNvZGUg InRoaW5rcyIgZGF0YSBpcyBpbiBGbGFzaCwgYnV0IGl0Cj4gPiAtCSAqIGlzIGFjdHVhbGx5IGlu IFJBTSAoYWN0dWFsbHkgZGF0YSBpcyBhbHNvIGluIEZsYXNoLCBidXQgRmxhc2ggaXMKPiA+IC0J ICogcmVhZC1vbmx5LCB0aHVzIHdlIG5lZWQgdG8gdXNlIHRoZSBkYXRhIHJlc2lkaW5nIGluIFJB TSkuCj4gPiAtCSAqCj4gPiAtCSAqIFRoZSBzdGFydCBvZiBkYXRhIGluIEZsYXNoIGlzIF9zZGF0 YSBhbmQgdGhlIHN0YXJ0IG9mIGRhdGEgaW4gUkFNIGlzCj4gPiAtCSAqIENPTkZJR19QSFlTX1JB TV9CQVNFLiBTbyB0aGlzIGZpeC11cCBlc3NlbnRpYWxseSBkb2VzIHRoaXM6Cj4gPiAtCSAqIHJl ZyArPSBDT05GSUdfUEhZU19SQU1fQkFTRSAtIF9zdGFydAo+ID4gLQkgKi8KPiA+IC0JbGkgdDAs IENPTkZJR19QSFlTX1JBTV9CQVNFCj4gPiAtICAgICAgICBhZGQgXHJlZywgXHJlZywgdDAKPiA+ IC0JbGEgdDAsIF9zZGF0YQo+ID4gLQlzdWIgXHJlZywgXHJlZywgdDAKPiA+IC0uZW5kbQo+ID4g LS5tYWNybyBYSVBfRklYVVBfRkxBU0hfT0ZGU0VUIHJlZwo+ID4gLQkvKiBJbiBsaW5rZXIgc2Ny aXB0LCBhdCB0aGUgdHJhbnNpdGlvbiBmcm9tIHJlYWQtb25seSBzZWN0aW9uIHRvCj4gPiAtCSAq IHdyaXRhYmxlIHNlY3Rpb24sIHRoZSBWTUEgaXMgaW5jcmVhc2VkIHdoaWxlIExNQSByZW1haW5z IHRoZSBzYW1lLgo+ID4gLQkgKiAoU2VlIGluIGxpbmtlciBzY3JpcHQgaG93IF9zZGF0YSwgX19k YXRhX2xvYyBhbmQgTE9BRF9PRkZTRVQgaXMKPiA+IC0JICogY2hhbmdlZCkKPiA+IC0JICoKPiA+ IC0JICogQ29uc2VxdWVudGx5LCBlYXJseSBkdXJpbmcgYm9vdCBiZWZvcmUgTU1VIGlzIHVwLCB0 aGUgZ2VuZXJhdGVkIGNvZGUKPiA+IC0JICogcmVhZHMgdGhlICJ3cml0YWJsZSIgc2VjdGlvbiBh dCB3cm9uZyBhZGRyZXNzZXMsIGJlY2F1c2UgVk1BIGlzIHVzZWQKPiA+IC0JICogYnkgY29tcGls ZXIgdG8gZ2VuZXJhdGUgY29kZSwgYnV0IHRoZSBkYXRhIGlzIGxvY2F0ZWQgaW4gRmxhc2ggdXNp bmcKPiA+IC0JICogTE1BLgo+ID4gLQkgKi8KPiA+IC0JbGEgdDAsIF9zZGF0YQo+ID4gLQlzdWIg XHJlZywgXHJlZywgdDAKPiA+IC0JbGEgdDAsIF9fZGF0YV9sb2MKPiA+IC0JYWRkIFxyZWcsIFxy ZWcsIHQwCj4gPiAtLmVuZG0KPiA+IC0jZWxzZQo+ID4gLS5tYWNybyBYSVBfRklYVVBfT0ZGU0VU IHJlZwo+ID4gLS5lbmRtCj4gPiAtLm1hY3JvIFhJUF9GSVhVUF9GTEFTSF9PRkZTRVQgcmVnCj4g PiAtLmVuZG0KPiA+IC0jZW5kaWYgLyogQ09ORklHX1hJUF9LRVJORUwgKi8KPiA+IC0KPiA+IC0j ZW5kaWYKPiA+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9oZWFkLlMgYi9hcmNoL3Jp c2N2L2tlcm5lbC9oZWFkLlMKPiA+IGluZGV4IDljOTljNWFkNmZlOC4uNjUwMzk5MDQ0MzY4IDEw MDY0NAo+ID4gLS0tIGEvYXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5TCj4gPiArKysgYi9hcmNoL3Jp c2N2L2tlcm5lbC9oZWFkLlMKPiA+IEBAIC0xNCw3ICsxNCw2IEBACj4gPiAgI2luY2x1ZGUgPGFz bS9od2NhcC5oPgo+ID4gICNpbmNsdWRlIDxhc20vaW1hZ2UuaD4KPiA+ICAjaW5jbHVkZSA8YXNt L3Njcy5oPgo+ID4gLSNpbmNsdWRlIDxhc20veGlwX2ZpeHVwLmg+Cj4gPiAgI2luY2x1ZGUgPGFz bS91c2VyY2ZpLmg+Cj4gPiAgI2luY2x1ZGUgImVmaS1oZWFkZXIuUyIKPiA+ICAKPiA+IEBAIC03 NSw3ICs3NCw2IEBAIHBlX2hlYWRfc3RhcnQ6Cj4gPiAgcmVsb2NhdGVfZW5hYmxlX21tdToKPiA+ ICAJLyogUmVsb2NhdGUgcmV0dXJuIGFkZHJlc3MgKi8KPiA+ICAJbGEgYTEsIGtlcm5lbF9tYXAK PiA+IC0JWElQX0ZJWFVQX09GRlNFVCBhMQo+ID4gIAlSRUdfTCBhMSwgS0VSTkVMX01BUF9WSVJU X0FERFIoYTEpCj4gPiAgCWxhIGEyLCBfc3RhcnQKPiA+ICAJc3ViIGExLCBhMSwgYTIKPiA+IEBA IC04OSw3ICs4Nyw2IEBAIHJlbG9jYXRlX2VuYWJsZV9tbXU6Cj4gPiAgCS8qIENvbXB1dGUgc2F0 cCBmb3Iga2VybmVsIHBhZ2UgdGFibGVzLCBidXQgZG9uJ3QgbG9hZCBpdCB5ZXQgKi8KPiA+ICAJ c3JsIGEyLCBhMCwgUEFHRV9TSElGVAo+ID4gIAlsYSBhMSwgc2F0cF9tb2RlCj4gPiAtCVhJUF9G SVhVUF9PRkZTRVQgYTEKPiA+ICAJUkVHX0wgYTEsIDAoYTEpCj4gPiAgCW9yIGEyLCBhMiwgYTEK PiA+ICAKPiA+IEBAIC0xMDAsNyArOTcsNiBAQCByZWxvY2F0ZV9lbmFibGVfbW11Ogo+ID4gIAkg KiB0byBlbnN1cmUgdGhlIG5ldyB0cmFuc2xhdGlvbnMgYXJlIGluIHVzZS4KPiA+ICAJICovCj4g PiAgCWxhIGEwLCB0cmFtcG9saW5lX3BnX2Rpcgo+ID4gLQlYSVBfRklYVVBfT0ZGU0VUIGEwCj4g PiAgCXNybCBhMCwgYTAsIFBBR0VfU0hJRlQKPiA+ICAJb3IgYTAsIGEwLCBhMQo+ID4gIAlzZmVu Y2Uudm1hCj4gPiBAQCAtMTU0LDExICsxNTAsOSBAQCBzZWNvbmRhcnlfc3RhcnRfc2JpOgo+ID4g IAo+ID4gIAkvKiBhMCBjb250YWlucyB0aGUgaGFydGlkICYgYTEgY29udGFpbnMgYm9vdCBkYXRh ICovCj4gPiAgCWxpIGEyLCBTQklfSEFSVF9CT09UX1RBU0tfUFRSX09GRlNFVAo+ID4gLQlYSVBf RklYVVBfT0ZGU0VUIGEyCj4gPiAgCWFkZCBhMiwgYTIsIGExCj4gPiAgCVJFR19MIHRwLCAoYTIp Cj4gPiAgCWxpIGEzLCBTQklfSEFSVF9CT09UX1NUQUNLX1BUUl9PRkZTRVQKPiA+IC0JWElQX0ZJ WFVQX09GRlNFVCBhMwo+ID4gIAlhZGQgYTMsIGEzLCBhMQo+ID4gIAlSRUdfTCBzcCwgKGEzKQo+ ID4gIAo+ID4gQEAgLTE2Nyw3ICsxNjEsNiBAQCBzZWNvbmRhcnlfc3RhcnRfc2JpOgo+ID4gICNp ZmRlZiBDT05GSUdfTU1VCj4gPiAgCS8qIEVuYWJsZSB2aXJ0dWFsIG1lbW9yeSBhbmQgcmVsb2Nh dGUgdG8gdmlydHVhbCBhZGRyZXNzICovCj4gPiAgCWxhIGEwLCBzd2FwcGVyX3BnX2Rpcgo+ID4g LQlYSVBfRklYVVBfT0ZGU0VUIGEwCj4gPiAgCWNhbGwgcmVsb2NhdGVfZW5hYmxlX21tdQo+ID4g ICNlbmRpZgo+ID4gIAljYWxsIC5Mc2V0dXBfdHJhcF92ZWN0b3IKPiA+IEBAIC0yNjksNDAgKzI2 MiwxMyBAQCBTWU1fQ09ERV9TVEFSVChfc3RhcnRfa2VybmVsKQo+ID4gIC5MZ29vZF9jb3JlczoK PiA+ICAKPiA+ICAJLyogVGhlIGxvdHRlcnkgc3lzdGVtIGlzIG9ubHkgcmVxdWlyZWQgZm9yIHNw aW53YWl0IGJvb3RpbmcgbWV0aG9kICovCj4gPiAtI2lmbmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ ID4gIAkvKiBQaWNrIG9uZSBoYXJ0IHRvIHJ1biB0aGUgbWFpbiBib290IHNlcXVlbmNlICovCj4g PiAgCWxhIGEzLCBoYXJ0X2xvdHRlcnkKPiA+ICAJbGkgYTIsIDEKPiA+ICAJYW1vYWRkLncgYTMs IGEyLCAoYTMpCj4gPiAgCWJuZXogYTMsIC5Mc2Vjb25kYXJ5X3N0YXJ0Cj4gPiAtCj4gPiAtI2Vs c2UKPiA+IC0JLyogaGFydF9sb3R0ZXJ5IGluIGZsYXNoIGNvbnRhaW5zIGEgbWFnaWMgbnVtYmVy ICovCj4gPiAtCWxhIGEzLCBoYXJ0X2xvdHRlcnkKPiA+IC0JbXYgYTIsIGEzCj4gPiAtCVhJUF9G SVhVUF9PRkZTRVQgYTIKPiA+IC0JWElQX0ZJWFVQX0ZMQVNIX09GRlNFVCBhMwo+ID4gLQlsdyB0 MSwgKGEzKQo+ID4gLQlhbW9zd2FwLncgdDAsIHQxLCAoYTIpCj4gPiAtCS8qIGZpcnN0IHRpbWUg aGVyZSBpZiBoYXJ0X2xvdHRlcnkgaW4gUkFNIGlzIG5vdCBzZXQgKi8KPiA+IC0JYmVxIHQwLCB0 MSwgLkxzZWNvbmRhcnlfc3RhcnQKPiA+IC0KPiA+IC0jZW5kaWYgLyogQ09ORklHX1hJUCAqLwo+ ID4gICNlbmRpZiAvKiBDT05GSUdfUklTQ1ZfQk9PVF9TUElOV0FJVCAqLwo+ID4gIAo+ID4gLSNp ZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ID4gLQlsYSBzcCwgX2VuZCArIFRIUkVBRF9TSVpFCj4g PiAtCVhJUF9GSVhVUF9PRkZTRVQgc3AKPiA+IC0JbXYgczAsIGEwCj4gPiAtCW12IHMxLCBhMQo+ ID4gLQljYWxsIF9fY29weV9kYXRhCj4gPiAtCj4gPiAtCS8qIFJlc3RvcmUgYTAgJiBhMSBjb3B5 ICovCj4gPiAtCW12IGEwLCBzMAo+ID4gLQltdiBhMSwgczEKPiA+IC0jZW5kaWYKPiA+IC0KPiA+ IC0jaWZuZGVmIENPTkZJR19YSVBfS0VSTkVMCj4gPiAgCS8qIENsZWFyIEJTUyBmb3IgZmxhdCBu b24tRUxGIGltYWdlcyAqLwo+ID4gIAlsYSBhMywgX19ic3Nfc3RhcnQKPiA+ICAJbGEgYTQsIF9f YnNzX3N0b3AKPiA+IEBAIC0zMTIsMjAgKzI3OCwxNiBAQCBTWU1fQ09ERV9TVEFSVChfc3RhcnRf a2VybmVsKQo+ID4gIAlhZGQgYTMsIGEzLCBSSVNDVl9TWlBUUgo+ID4gIAlibHQgYTMsIGE0LCAu TGNsZWFyX2Jzcwo+ID4gIC5MY2xlYXJfYnNzX2RvbmU6Cj4gPiAtI2VuZGlmCj4gPiAgCWxhIGEy LCBib290X2NwdV9oYXJ0aWQKPiA+IC0JWElQX0ZJWFVQX09GRlNFVCBhMgo+ID4gIAlSRUdfUyBh MCwgKGEyKQo+ID4gIAo+ID4gIAkvKiBJbml0aWFsaXplIHBhZ2UgdGFibGVzIGFuZCByZWxvY2F0 ZSB0byB2aXJ0dWFsIGFkZHJlc3NlcyAqLwo+ID4gIAlsYSB0cCwgaW5pdF90YXNrCj4gPiAgCWxh IHNwLCBpbml0X3RocmVhZF91bmlvbiArIFRIUkVBRF9TSVpFCj4gPiAtCVhJUF9GSVhVUF9PRkZT RVQgc3AKPiA+ICAJYWRkaSBzcCwgc3AsIC1QVF9TSVpFX09OX1NUQUNLCj4gPiAgCXNjc19sb2Fk X2luaXRfc3RhY2sKPiA+ICAjaWZkZWYgQ09ORklHX0JVSUxUSU5fRFRCCj4gPiAgCWxhIGEwLCBf X2R0Yl9zdGFydAo+ID4gLQlYSVBfRklYVVBfT0ZGU0VUIGEwCj4gPiAgI2Vsc2UKPiA+ICAJbXYg YTAsIGExCj4gPiAgI2VuZGlmIC8qIENPTkZJR19CVUlMVElOX0RUQiAqLwo+ID4gQEAgLTMzNSw3 ICsyOTcsNiBAQCBTWU1fQ09ERV9TVEFSVChfc3RhcnRfa2VybmVsKQo+ID4gIAljYWxsIHNldHVw X3ZtCj4gPiAgI2lmZGVmIENPTkZJR19NTVUKPiA+ICAJbGEgYTAsIGVhcmx5X3BnX2Rpcgo+ID4g LQlYSVBfRklYVVBfT0ZGU0VUIGEwCj4gPiAgCWNhbGwgcmVsb2NhdGVfZW5hYmxlX21tdQo+ID4g ICNlbmRpZiAvKiBDT05GSUdfTU1VICovCj4gPiAgCj4gPiBAQCAtMzc0LDkgKzMzNSw3IEBAIFNZ TV9DT0RFX1NUQVJUKF9zdGFydF9rZXJuZWwpCj4gPiAgCj4gPiAgCXNsbGkgYTMsIGEwLCBMR1JF Rwo+ID4gIAlsYSBhMSwgX19jcHVfc3BpbndhaXRfc3RhY2tfcG9pbnRlcgo+ID4gLQlYSVBfRklY VVBfT0ZGU0VUIGExCj4gPiAgCWxhIGEyLCBfX2NwdV9zcGlud2FpdF90YXNrX3BvaW50ZXIKPiA+ IC0JWElQX0ZJWFVQX09GRlNFVCBhMgo+ID4gIAlhZGQgYTEsIGEzLCBhMQo+ID4gIAlhZGQgYTIs IGEzLCBhMgo+ID4gIAo+ID4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yva2VybmVsL2hlYWQuaCBi L2FyY2gvcmlzY3Yva2VybmVsL2hlYWQuaAo+ID4gaW5kZXggYTU1NmZkYWFmZWQ5Li4wNWEwNGJl ZjQ0MmIgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9oZWFkLmgKPiA+ICsrKyBi L2FyY2gvcmlzY3Yva2VybmVsL2hlYWQuaAo+ID4gQEAgLTExLDkgKzExLDYgQEAKPiA+ICBleHRl cm4gYXRvbWljX3QgaGFydF9sb3R0ZXJ5Owo+ID4gIAo+ID4gIGFzbWxpbmthZ2Ugdm9pZCBfX2lu aXQgc2V0dXBfdm0odWludHB0cl90IGR0Yl9wYSk7Cj4gPiAtI2lmZGVmIENPTkZJR19YSVBfS0VS TkVMCj4gPiAtYXNtbGlua2FnZSB2b2lkIF9faW5pdCBfX2NvcHlfZGF0YSh2b2lkKTsKPiA+IC0j ZW5kaWYKPiA+ICAKPiA+ICAjaWZkZWYgQ09ORklHX1JJU0NWX0JPT1RfU1BJTldBSVQKPiA+ICBl eHRlcm4gdm9pZCAqX19jcHVfc3BpbndhaXRfc3RhY2tfcG9pbnRlcltdOwo+ID4gZGlmZiAtLWdp dCBhL2FyY2gvcmlzY3Yva2VybmVsL3NldHVwLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9zZXR1cC5j Cj4gPiBpbmRleCBiNWJjNWZjNjVjZWEuLmM4OWNjMjcyNDQwYiAxMDA2NDQKPiA+IC0tLSBhL2Fy Y2gvcmlzY3Yva2VybmVsL3NldHVwLmMKPiA+ICsrKyBiL2FyY2gvcmlzY3Yva2VybmVsL3NldHVw LmMKPiA+IEBAIC00NiwxMSArNDYsNyBAQAo+ID4gICAqIFRoaXMgaXMgdXNlZCBiZWZvcmUgdGhl IGtlcm5lbCBpbml0aWFsaXplcyB0aGUgQlNTIHNvIGl0IGNhbid0IGJlIGluIHRoZQo+ID4gICAq IEJTUy4KPiA+ICAgKi8KPiA+IC1hdG9taWNfdCBoYXJ0X2xvdHRlcnkgX19zZWN0aW9uKCIuc2Rh dGEiKQo+ID4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ID4gLT0gQVRPTUlDX0lOSVQoMHhD MDAxQkVFRikKPiA+IC0jZW5kaWYKPiA+IC07Cj4gPiArYXRvbWljX3QgaGFydF9sb3R0ZXJ5IF9f c2VjdGlvbigiLnNkYXRhIik7Cj4gPiAgdW5zaWduZWQgbG9uZyBib290X2NwdV9oYXJ0aWQ7Cj4g PiAgRVhQT1JUX1NZTUJPTF9HUEwoYm9vdF9jcHVfaGFydGlkKTsKPiA+ICAKPiA+IGRpZmYgLS1n aXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9zdXNwZW5kX2VudHJ5LlMgYi9hcmNoL3Jpc2N2L2tlcm5l bC9zdXNwZW5kX2VudHJ5LlMKPiA+IGluZGV4IDJkNTRmMzA5YzE0MC4uZDcxYjU1ZmQ2MjU5IDEw MDY0NAo+ID4gLS0tIGEvYXJjaC9yaXNjdi9rZXJuZWwvc3VzcGVuZF9lbnRyeS5TCj4gPiArKysg Yi9hcmNoL3Jpc2N2L2tlcm5lbC9zdXNwZW5kX2VudHJ5LlMKPiA+IEBAIC0xMCw3ICsxMCw2IEBA Cj4gPiAgI2luY2x1ZGUgPGFzbS9hc20tb2Zmc2V0cy5oPgo+ID4gICNpbmNsdWRlIDxhc20vYXNz ZW1ibGVyLmg+Cj4gPiAgI2luY2x1ZGUgPGFzbS9jc3IuaD4KPiA+IC0jaW5jbHVkZSA8YXNtL3hp cF9maXh1cC5oPgo+ID4gIAo+ID4gIAkudGV4dAo+ID4gIAkuYWx0bWFjcm8KPiA+IEBAIC03MCw3 ICs2OSw2IEBAIFNZTV9UWVBFRF9GVU5DX1NUQVJUKF9fY3B1X3Jlc3VtZV9lbnRlcikKPiA+ICAK PiA+ICAJLyogRW5hYmxlIE1NVSAqLwo+ID4gIAlsYQlhMCwgc3dhcHBlcl9wZ19kaXIKPiA+IC0J WElQX0ZJWFVQX09GRlNFVCBhMAo+ID4gIAljYWxsCXJlbG9jYXRlX2VuYWJsZV9tbXUKPiA+ICAK PiA+ICAJLyogUmVzdG9yZSBBMCBhbmQgQTEgKi8KPiA+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2 L2tlcm5lbC90cmFwcy5jIGIvYXJjaC9yaXNjdi9rZXJuZWwvdHJhcHMuYwo+ID4gaW5kZXggNWZi NTdmYWQxODhhLi5iZGVjNTRkMTJiMmEgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNoL3Jpc2N2L2tlcm5l bC90cmFwcy5jCj4gPiArKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC90cmFwcy5jCj4gPiBAQCAtMTQy LDExICsxNDIsNyBAQCBzdGF0aWMgdm9pZCBkb190cmFwX2Vycm9yKHN0cnVjdCBwdF9yZWdzICpy ZWdzLCBpbnQgc2lnbm8sIGludCBjb2RlLAo+ID4gIAl9Cj4gPiAgfQo+ID4gIAo+ID4gLSNpZiBk ZWZpbmVkKENPTkZJR19YSVBfS0VSTkVMKSAmJiBkZWZpbmVkKENPTkZJR19SSVNDVl9BTFRFUk5B VElWRSkKPiA+IC0jZGVmaW5lIF9fdHJhcF9zZWN0aW9uIF9fbm9pbnN0cl9zZWN0aW9uKCIueGlw LnRyYXBzIikKPiA+IC0jZWxzZQo+ID4gICNkZWZpbmUgX190cmFwX3NlY3Rpb24gbm9pbnN0cgo+ ID4gLSNlbmRpZgo+ID4gICNkZWZpbmUgRE9fRVJST1JfSU5GTyhuYW1lLCBzaWdubywgY29kZSwg c3RyKQkJCQkJXAo+ID4gIGFzbWxpbmthZ2UgX192aXNpYmxlIF9fdHJhcF9zZWN0aW9uIHZvaWQg bmFtZShzdHJ1Y3QgcHRfcmVncyAqcmVncykJCVwKPiA+ICB7CQkJCQkJCQkJCVwKPiA+IGRpZmYg LS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC92bWNvcmVfaW5mby5jIGIvYXJjaC9yaXNjdi9rZXJu ZWwvdm1jb3JlX2luZm8uYwo+ID4gaW5kZXggZDVlNDQ4YWE5MGU3Li42ZDdhMjI1MjJkNjMgMTAw NjQ0Cj4gPiAtLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC92bWNvcmVfaW5mby5jCj4gPiArKysgYi9h cmNoL3Jpc2N2L2tlcm5lbC92bWNvcmVfaW5mby5jCj4gPiBAQCAtMTksMTMgKzE5LDYgQEAgdm9p ZCBhcmNoX2NyYXNoX3NhdmVfdm1jb3JlaW5mbyh2b2lkKQo+ID4gICNlbmRpZgo+ID4gICNlbmRp Zgo+ID4gIAl2bWNvcmVpbmZvX2FwcGVuZF9zdHIoIk5VTUJFUihLRVJORUxfTElOS19BRERSKT0w eCVseFxuIiwgS0VSTkVMX0xJTktfQUREUik7Cj4gPiAtI2lmZGVmIENPTkZJR19YSVBfS0VSTkVM Cj4gPiAtCS8qIFRPRE86IENvbW11bmljYXRlIHdpdGggY3Jhc2gtdXRpbGl0eSBkZXZlbG9wZXJz IG9uIHRoZSBpbmZvcm1hdGlvbiB0bwo+ID4gLQkgKiBleHBvcnQuIFRoZSBYSVAgY2FzZSBpcyBt b3JlIGNvbXBsaWNhdGVkLCBiZWNhdXNlIHRoZSB2aXJ0dWFsLXBoeXNpY2FsCj4gPiAtCSAqIGFk ZHJlc3Mgb2Zmc2V0IGRlcGVuZHMgb24gd2hldGhlciB0aGUgYWRkcmVzcyBpcyBpbiBST00gb3Ig aW4gUkFNLgo+ID4gLQkgKi8KPiA+IC0jZWxzZQo+ID4gIAl2bWNvcmVpbmZvX2FwcGVuZF9zdHIo Ik5VTUJFUih2YV9rZXJuZWxfcGFfb2Zmc2V0KT0weCVseFxuIiwKPiA+ICAJCQkJCQlrZXJuZWxf bWFwLnZhX2tlcm5lbF9wYV9vZmZzZXQpOwo+ID4gLSNlbmRpZgo+ID4gIH0KPiA+IGRpZmYgLS1n aXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC92bWxpbnV4Lmxkcy5TIGIvYXJjaC9yaXNjdi9rZXJuZWwv dm1saW51eC5sZHMuUwo+ID4gaW5kZXggNjFiZDViYTY2ODBhLi4zYjVmZmNmMzIxNmQgMTAwNjQ0 Cj4gPiAtLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC92bWxpbnV4Lmxkcy5TCj4gPiArKysgYi9hcmNo L3Jpc2N2L2tlcm5lbC92bWxpbnV4Lmxkcy5TCj4gPiBAQCAtNywxMCArNyw2IEBACj4gPiAgI2Rl ZmluZSBST19FWENFUFRJT05fVEFCTEVfQUxJR04JNAo+ID4gICNkZWZpbmUgUlVOVElNRV9ESVND QVJEX0VYSVQKPiA+ICAKPiA+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiA+IC0jaW5jbHVk ZSAidm1saW51eC14aXAubGRzLlMiCj4gPiAtI2Vsc2UKPiA+IC0KPiA+ICAjaW5jbHVkZSA8YXNt L3BndGFibGUuaD4KPiA+ICAjZGVmaW5lIExPQURfT0ZGU0VUIEtFUk5FTF9MSU5LX0FERFIKPiA+ ICAKPiA+IEBAIC0xNzUsNCArMTcxLDMgQEAgU0VDVElPTlMKPiA+ICAKPiA+ICAJRElTQ0FSRFMK PiA+ICB9Cj4gPiAtI2VuZGlmIC8qIENPTkZJR19YSVBfS0VSTkVMICovCj4gPiBkaWZmIC0tZ2l0 IGEvYXJjaC9yaXNjdi9tbS9pbml0LmMgYi9hcmNoL3Jpc2N2L21tL2luaXQuYwo+ID4gaW5kZXgg MjVhOGY2OTNhNzY1Li5jN2VjNmMwMjM1ZTEgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNoL3Jpc2N2L21t L2luaXQuYwo+ID4gKysrIGIvYXJjaC9yaXNjdi9tbS9pbml0LmMKPiA+IEBAIC00MSwyMCArNDEs MTcgQEAgdTY0IG5ld192bWFsbG9jW05SX0NQVVMgLyBzaXplb2YodTY0KSArIDFdOwo+ID4gIAo+ ID4gIHN0cnVjdCBrZXJuZWxfbWFwcGluZyBrZXJuZWxfbWFwIF9fcm9fYWZ0ZXJfaW5pdDsKPiA+ ICBFWFBPUlRfU1lNQk9MKGtlcm5lbF9tYXApOwo+ID4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5F TAo+ID4gLSNkZWZpbmUga2VybmVsX21hcAkoKihzdHJ1Y3Qga2VybmVsX21hcHBpbmcgKilYSVBf RklYVVAoJmtlcm5lbF9tYXApKQo+ID4gLSNlbmRpZgo+ID4gIAo+ID4gICNpZmRlZiBDT05GSUdf NjRCSVQKPiA+IC11NjQgc2F0cF9tb2RlIF9fcm9fYWZ0ZXJfaW5pdCA9ICFJU19FTkFCTEVEKENP TkZJR19YSVBfS0VSTkVMKSA/IFNBVFBfTU9ERV81NyA6IFNBVFBfTU9ERV8zOTsKPiA+ICt1NjQg c2F0cF9tb2RlIF9fcm9fYWZ0ZXJfaW5pdCA9IFNBVFBfTU9ERV81NzsKPiA+ICAjZWxzZQo+ID4g IHU2NCBzYXRwX21vZGUgX19yb19hZnRlcl9pbml0ID0gU0FUUF9NT0RFXzMyOwo+ID4gICNlbmRp Zgo+ID4gIEVYUE9SVF9TWU1CT0woc2F0cF9tb2RlKTsKPiA+ICAKPiA+ICAjaWZkZWYgQ09ORklH XzY0QklUCj4gPiAtYm9vbCBwZ3RhYmxlX2w0X2VuYWJsZWQgX19yb19hZnRlcl9pbml0ID0gIUlT X0VOQUJMRUQoQ09ORklHX1hJUF9LRVJORUwpOwo+ID4gLWJvb2wgcGd0YWJsZV9sNV9lbmFibGVk IF9fcm9fYWZ0ZXJfaW5pdCA9ICFJU19FTkFCTEVEKENPTkZJR19YSVBfS0VSTkVMKTsKPiA+ICti b29sIHBndGFibGVfbDRfZW5hYmxlZCBfX3JvX2FmdGVyX2luaXQgPSB0cnVlOwo+ID4gK2Jvb2wg cGd0YWJsZV9sNV9lbmFibGVkIF9fcm9fYWZ0ZXJfaW5pdCA9IHRydWU7Cj4gPiAgRVhQT1JUX1NZ TUJPTChwZ3RhYmxlX2w0X2VuYWJsZWQpOwo+ID4gIEVYUE9SVF9TWU1CT0wocGd0YWJsZV9sNV9l bmFibGVkKTsKPiA+ICAjZW5kaWYKPiA+IEBAIC0xOTcsOSArMTk0LDYgQEAgdm9pZCBfX2luaXQg YXJjaF9tbV9wcmVpbml0KHZvaWQpCj4gPiAgCj4gPiAgLyogTGltaXQgdGhlIG1lbW9yeSBzaXpl IHZpYSBtZW0uICovCj4gPiAgc3RhdGljIHBoeXNfYWRkcl90IG1lbW9yeV9saW1pdDsKPiA+IC0j aWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiA+IC0jZGVmaW5lIG1lbW9yeV9saW1pdAkoKihwaHlz X2FkZHJfdCAqKVhJUF9GSVhVUCgmbWVtb3J5X2xpbWl0KSkKPiA+IC0jZW5kaWYgLyogQ09ORklH X1hJUF9LRVJORUwgKi8KPiA+ICAKPiA+ICBzdGF0aWMgaW50IF9faW5pdCBlYXJseV9tZW0oY2hh ciAqcCkKPiA+ICB7Cj4gPiBAQCAtMjIzLDEwICsyMTcsNyBAQCBzdGF0aWMgdm9pZCBfX2luaXQg c2V0dXBfYm9vdG1lbSh2b2lkKQo+ID4gIAlwaHlzX2FkZHJfdCBtYXhfbWFwcGVkX2FkZHI7Cj4g PiAgCXBoeXNfYWRkcl90IHBoeXNfcmFtX2VuZCwgdm1saW51eF9zdGFydDsKPiA+ICAKPiA+IC0J aWYgKElTX0VOQUJMRUQoQ09ORklHX1hJUF9LRVJORUwpKQo+ID4gLQkJdm1saW51eF9zdGFydCA9 IF9fcGFfc3ltYm9sKCZfc2RhdGEpOwo+ID4gLQllbHNlCj4gPiAtCQl2bWxpbnV4X3N0YXJ0ID0g X19wYV9zeW1ib2woJl9zdGFydCk7Cj4gPiArCXZtbGludXhfc3RhcnQgPSBfX3BhX3N5bWJvbCgm X3N0YXJ0KTsKPiA+ICAKPiA+ICAJbWVtYmxvY2tfZW5mb3JjZV9tZW1vcnlfbGltaXQobWVtb3J5 X2xpbWl0KTsKPiA+ICAKPiA+IEBAIC0yNDYsMTIgKzIzNywxMCBAQCBzdGF0aWMgdm9pZCBfX2lu aXQgc2V0dXBfYm9vdG1lbSh2b2lkKQo+ID4gIAkgKiBNYWtlIHN1cmUgd2UgYWxpZ24gdGhlIHN0 YXJ0IG9mIHRoZSBtZW1vcnkgb24gYSBQTUQgYm91bmRhcnkgc28gdGhhdAo+ID4gIAkgKiBhdCB3 b3JzdCwgd2UgbWFwIHRoZSBsaW5lYXIgbWFwcGluZyB3aXRoIFBNRCBtYXBwaW5ncy4KPiA+ICAJ ICovCj4gPiAtCWlmICghSVNfRU5BQkxFRChDT05GSUdfWElQX0tFUk5FTCkpIHsKPiA+IC0JCXBo eXNfcmFtX2Jhc2UgPSBtZW1ibG9ja19zdGFydF9vZl9EUkFNKCkgJiBQTURfTUFTSzsKPiA+ICsJ cGh5c19yYW1fYmFzZSA9IG1lbWJsb2NrX3N0YXJ0X29mX0RSQU0oKSAmIFBNRF9NQVNLOwo+ID4g ICNpZmRlZiBDT05GSUdfU1BBUlNFTUVNX1ZNRU1NQVAKPiA+IC0JCXZtZW1tYXBfc3RhcnRfcGZu ID0gcm91bmRfZG93bihwaHlzX3JhbV9iYXNlLCBWTUVNTUFQX0FERFJfQUxJR04pID4+IFBBR0Vf U0hJRlQ7Cj4gPiArCXZtZW1tYXBfc3RhcnRfcGZuID0gcm91bmRfZG93bihwaHlzX3JhbV9iYXNl LCBWTUVNTUFQX0FERFJfQUxJR04pID4+IFBBR0VfU0hJRlQ7Cj4gPiAgI2VuZGlmCj4gPiAtCX0K PiA+ICAKPiA+ICAJLyoKPiA+ICAJICogSW4gNjQtYml0LCBhbnkgdXNlIG9mIF9fdmEvX19wYSBi ZWZvcmUgdGhpcyBwb2ludCBpcyB3cm9uZyBhcyB3ZQo+ID4gQEAgLTM2NiwxMyArMzU1LDYgQEAg c3RhdGljIHB0ZV90IGZpeG1hcF9wdGVbUFRSU19QRVJfUFRFXSBfX3BhZ2VfYWxpZ25lZF9ic3M7 Cj4gPiAgCj4gPiAgcGdkX3QgZWFybHlfcGdfZGlyW1BUUlNfUEVSX1BHRF0gX19pbml0ZGF0YSBf X2FsaWduZWQoUEFHRV9TSVpFKTsKPiA+ICAKPiA+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwK PiA+IC0jZGVmaW5lIHB0X29wcwkJCSgqKHN0cnVjdCBwdF9hbGxvY19vcHMgKilYSVBfRklYVVAo JnB0X29wcykpCj4gPiAtI2RlZmluZSB0cmFtcG9saW5lX3BnX2RpciAgICAgICgocGdkX3QgKilY SVBfRklYVVAodHJhbXBvbGluZV9wZ19kaXIpKQo+ID4gLSNkZWZpbmUgZml4bWFwX3B0ZSAgICAg ICAgICAgICAoKHB0ZV90ICopWElQX0ZJWFVQKGZpeG1hcF9wdGUpKQo+ID4gLSNkZWZpbmUgZWFy bHlfcGdfZGlyICAgICAgICAgICAoKHBnZF90ICopWElQX0ZJWFVQKGVhcmx5X3BnX2RpcikpCj4g PiAtI2VuZGlmIC8qIENPTkZJR19YSVBfS0VSTkVMICovCj4gPiAtCj4gPiAgc3RhdGljIGNvbnN0 IHBncHJvdF90IHByb3RlY3Rpb25fbWFwWzE2XSA9IHsKPiA+ICAJW1ZNX05PTkVdCQkJCQk9IFBB R0VfTk9ORSwKPiA+ICAJW1ZNX1JFQURdCQkJCQk9IFBBR0VfUkVBRCwKPiA+IEBAIC00NjksMzIg KzQ1MSwxNCBAQCBzdGF0aWMgcG1kX3QgdHJhbXBvbGluZV9wbWRbUFRSU19QRVJfUE1EXSBfX3Bh Z2VfYWxpZ25lZF9ic3M7Cj4gPiAgc3RhdGljIHBtZF90IGZpeG1hcF9wbWRbUFRSU19QRVJfUE1E XSBfX3BhZ2VfYWxpZ25lZF9ic3M7Cj4gPiAgc3RhdGljIHBtZF90IGVhcmx5X3BtZFtQVFJTX1BF Ul9QTURdIF9faW5pdGRhdGEgX19hbGlnbmVkKFBBR0VfU0laRSk7Cj4gPiAgCj4gPiAtI2lmZGVm IENPTkZJR19YSVBfS0VSTkVMCj4gPiAtI2RlZmluZSB0cmFtcG9saW5lX3BtZCAoKHBtZF90ICop WElQX0ZJWFVQKHRyYW1wb2xpbmVfcG1kKSkKPiA+IC0jZGVmaW5lIGZpeG1hcF9wbWQgICAgICgo cG1kX3QgKilYSVBfRklYVVAoZml4bWFwX3BtZCkpCj4gPiAtI2RlZmluZSBlYXJseV9wbWQgICAg ICAoKHBtZF90ICopWElQX0ZJWFVQKGVhcmx5X3BtZCkpCj4gPiAtI2VuZGlmIC8qIENPTkZJR19Y SVBfS0VSTkVMICovCj4gPiAtCj4gPiAgc3RhdGljIHA0ZF90IHRyYW1wb2xpbmVfcDRkW1BUUlNf UEVSX1A0RF0gX19wYWdlX2FsaWduZWRfYnNzOwo+ID4gIHN0YXRpYyBwNGRfdCBmaXhtYXBfcDRk W1BUUlNfUEVSX1A0RF0gX19wYWdlX2FsaWduZWRfYnNzOwo+ID4gIHN0YXRpYyBwNGRfdCBlYXJs eV9wNGRbUFRSU19QRVJfUDREXSBfX2luaXRkYXRhIF9fYWxpZ25lZChQQUdFX1NJWkUpOwo+ID4g IAo+ID4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ID4gLSNkZWZpbmUgdHJhbXBvbGluZV9w NGQgKChwNGRfdCAqKVhJUF9GSVhVUCh0cmFtcG9saW5lX3A0ZCkpCj4gPiAtI2RlZmluZSBmaXht YXBfcDRkICAgICAoKHA0ZF90ICopWElQX0ZJWFVQKGZpeG1hcF9wNGQpKQo+ID4gLSNkZWZpbmUg ZWFybHlfcDRkICAgICAgKChwNGRfdCAqKVhJUF9GSVhVUChlYXJseV9wNGQpKQo+ID4gLSNlbmRp ZiAvKiBDT05GSUdfWElQX0tFUk5FTCAqLwo+ID4gLQo+ID4gIHN0YXRpYyBwdWRfdCB0cmFtcG9s aW5lX3B1ZFtQVFJTX1BFUl9QVURdIF9fcGFnZV9hbGlnbmVkX2JzczsKPiA+ICBzdGF0aWMgcHVk X3QgZml4bWFwX3B1ZFtQVFJTX1BFUl9QVURdIF9fcGFnZV9hbGlnbmVkX2JzczsKPiA+ICBzdGF0 aWMgcHVkX3QgZWFybHlfcHVkW1BUUlNfUEVSX1BVRF0gX19pbml0ZGF0YSBfX2FsaWduZWQoUEFH RV9TSVpFKTsKPiA+ICAKPiA+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiA+IC0jZGVmaW5l IHRyYW1wb2xpbmVfcHVkICgocHVkX3QgKilYSVBfRklYVVAodHJhbXBvbGluZV9wdWQpKQo+ID4g LSNkZWZpbmUgZml4bWFwX3B1ZCAgICAgKChwdWRfdCAqKVhJUF9GSVhVUChmaXhtYXBfcHVkKSkK PiA+IC0jZGVmaW5lIGVhcmx5X3B1ZCAgICAgICgocHVkX3QgKilYSVBfRklYVVAoZWFybHlfcHVk KSkKPiA+IC0jZW5kaWYgLyogQ09ORklHX1hJUF9LRVJORUwgKi8KPiA+IC0KPiA+ICBzdGF0aWMg cG1kX3QgKl9faW5pdCBnZXRfcG1kX3ZpcnRfZWFybHkocGh5c19hZGRyX3QgcGEpCj4gPiAgewo+ ID4gIAkvKiBCZWZvcmUgTU1VIGlzIGVuYWJsZWQgKi8KPiA+IEBAIC03NjUsMjEgKzcyOSw2IEBA IHN0YXRpYyB1aW50cHRyX3QgX19tZW1pbml0IGJlc3RfbWFwX3NpemUocGh5c19hZGRyX3QgcGEs IHVpbnRwdHJfdCB2YSwgcGh5c19hZGRyCj4gPiAgCXJldHVybiBQQUdFX1NJWkU7Cj4gPiAgfQo+ ID4gIAo+ID4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ID4gLSNkZWZpbmUgcGh5c19yYW1f YmFzZSAgKCoocGh5c19hZGRyX3QgKilYSVBfRklYVVAoJnBoeXNfcmFtX2Jhc2UpKQo+ID4gLWV4 dGVybiBjaGFyIF94aXByb21bXSwgX2V4aXByb21bXSwgX19kYXRhX2xvYzsKPiA+IC0KPiA+IC0v KiBjYWxsZWQgZnJvbSBoZWFkLlMgd2l0aCBNTVUgb2ZmICovCj4gPiAtYXNtbGlua2FnZSB2b2lk IF9faW5pdCBfX2NvcHlfZGF0YSh2b2lkKQo+ID4gLXsKPiA+IC0Jdm9pZCAqZnJvbSA9ICh2b2lk ICopKCZfX2RhdGFfbG9jKTsKPiA+IC0Jdm9pZCAqdG8gPSAodm9pZCAqKUNPTkZJR19QSFlTX1JB TV9CQVNFOwo+ID4gLQlzaXplX3Qgc3ogPSAoc2l6ZV90KSgodWludHB0cl90KSgmX2VuZCkgLSAo dWludHB0cl90KSgmX3NkYXRhKSk7Cj4gPiAtCj4gPiAtCW1lbWNweSh0bywgZnJvbSwgc3opOwo+ ID4gLX0KPiA+IC0jZW5kaWYKPiA+IC0KPiA+ICAjaWZkZWYgQ09ORklHX1NUUklDVF9LRVJORUxf UldYCj4gPiAgc3RhdGljIF9fbWVtaW5pdCBwZ3Byb3RfdCBwZ3Byb3RfZnJvbV92YSh1aW50cHRy X3QgdmEpCj4gPiAgewo+ID4gQEAgLTgxNSw3ICs3NjQsNyBAQCBzdGF0aWMgX19tZW1pbml0IHBn cHJvdF90IHBncHJvdF9mcm9tX3ZhKHVpbnRwdHJfdCB2YSkKPiA+ICB9Cj4gPiAgI2VuZGlmIC8q IENPTkZJR19TVFJJQ1RfS0VSTkVMX1JXWCAqLwo+ID4gIAo+ID4gLSNpZiBkZWZpbmVkKENPTkZJ R182NEJJVCkgJiYgIWRlZmluZWQoQ09ORklHX1hJUF9LRVJORUwpCj4gPiArI2lmIGRlZmluZWQo Q09ORklHXzY0QklUKQo+ID4gIHU2NCBfX3BpX3NldF9zYXRwX21vZGVfZnJvbV9jbWRsaW5lKHVp bnRwdHJfdCBkdGJfcGEpOwo+ID4gIHU2NCBfX3BpX3NldF9zYXRwX21vZGVfZnJvbV9mZHQodWlu dHB0cl90IGR0Yl9wYSk7Cj4gPiAgCj4gPiBAQCAtOTQwLDI4ICs4ODksNiBAQCBzdGF0aWMgX19p bml0IHZvaWQgc2V0X3NhdHBfbW9kZSh1aW50cHRyX3QgZHRiX3BhKQo+ID4gICNlcnJvciAic2V0 dXBfdm0oKSBpcyBjYWxsZWQgZnJvbSBoZWFkLlMgYmVmb3JlIHJlbG9jYXRlIHNvIGl0IHNob3Vs ZCBub3QgdXNlIGFic29sdXRlIGFkZHJlc3NpbmcuIgo+ID4gICNlbmRpZgo+ID4gIAo+ID4gLSNp ZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ID4gLXN0YXRpYyB2b2lkIF9faW5pdCBjcmVhdGVfa2Vy bmVsX3BhZ2VfdGFibGUocGdkX3QgKnBnZGlyLAo+ID4gLQkJCQkJICAgIF9fYWx3YXlzX3VudXNl ZCBib29sIGVhcmx5KQo+ID4gLXsKPiA+IC0JdWludHB0cl90IHZhLCBzdGFydF92YSwgZW5kX3Zh Owo+ID4gLQo+ID4gLQkvKiBNYXAgdGhlIGZsYXNoIHJlc2lkZW50IHBhcnQgKi8KPiA+IC0JZW5k X3ZhID0ga2VybmVsX21hcC52aXJ0X2FkZHIgKyBrZXJuZWxfbWFwLnhpcHJvbV9zejsKPiA+IC0J Zm9yICh2YSA9IGtlcm5lbF9tYXAudmlydF9hZGRyOyB2YSA8IGVuZF92YTsgdmEgKz0gUE1EX1NJ WkUpCj4gPiAtCQljcmVhdGVfcGdkX21hcHBpbmcocGdkaXIsIHZhLAo+ID4gLQkJCQkgICBrZXJu ZWxfbWFwLnhpcHJvbSArICh2YSAtIGtlcm5lbF9tYXAudmlydF9hZGRyKSwKPiA+IC0JCQkJICAg UE1EX1NJWkUsIFBBR0VfS0VSTkVMX0VYRUMpOwo+ID4gLQo+ID4gLQkvKiBNYXAgdGhlIGRhdGEg aW4gUkFNICovCj4gPiAtCXN0YXJ0X3ZhID0ga2VybmVsX21hcC52aXJ0X2FkZHIgKyAodWludHB0 cl90KSZfc2RhdGEgLSAodWludHB0cl90KSZfc3RhcnQ7Cj4gPiAtCWVuZF92YSA9IGtlcm5lbF9t YXAudmlydF9hZGRyICsga2VybmVsX21hcC5zaXplOwo+ID4gLQlmb3IgKHZhID0gc3RhcnRfdmE7 IHZhIDwgZW5kX3ZhOyB2YSArPSBQTURfU0laRSkKPiA+IC0JCWNyZWF0ZV9wZ2RfbWFwcGluZyhw Z2RpciwgdmEsCj4gPiAtCQkJCSAgIGtlcm5lbF9tYXAucGh5c19hZGRyICsgKHZhIC0gc3RhcnRf dmEpLAo+ID4gLQkJCQkgICBQTURfU0laRSwgUEFHRV9LRVJORUwpOwo+ID4gLX0KPiA+IC0jZWxz ZQo+ID4gIHN0YXRpYyB2b2lkIF9faW5pdCBjcmVhdGVfa2VybmVsX3BhZ2VfdGFibGUocGdkX3Qg KnBnZGlyLCBib29sIGVhcmx5KQo+ID4gIHsKPiA+ICAJdWludHB0cl90IHZhLCBlbmRfdmE7Cj4g PiBAQCAtOTc0LDcgKzkwMSw2IEBAIHN0YXRpYyB2b2lkIF9faW5pdCBjcmVhdGVfa2VybmVsX3Bh Z2VfdGFibGUocGdkX3QgKnBnZGlyLCBib29sIGVhcmx5KQo+ID4gIAkJCQkgICBlYXJseSA/Cj4g PiAgCQkJCQlQQUdFX0tFUk5FTF9FWEVDIDogcGdwcm90X2Zyb21fdmEodmEpKTsKPiA+ICB9Cj4g PiAtI2VuZGlmCj4gPiAgCj4gPiAgLyoKPiA+ICAgKiBTZXR1cCBhIDRNQiBtYXBwaW5nIHRoYXQg ZW5jb21wYXNzZXMgdGhlIGRldmljZSB0cmVlOiBmb3IgNjQtYml0IGtlcm5lbCwKPiA+IEBAIC0x MTE2LDI3ICsxMDQyLDExIEBAIGFzbWxpbmthZ2Ugdm9pZCBfX2luaXQgc2V0dXBfdm0odWludHB0 cl90IGR0Yl9wYSkKPiA+ICAKPiA+ICAJa2VybmVsX21hcC52aXJ0X2FkZHIgPSBLRVJORUxfTElO S19BRERSICsga2VybmVsX21hcC52aXJ0X29mZnNldDsKPiA+ICAKPiA+IC0jaWZkZWYgQ09ORklH X1hJUF9LRVJORUwKPiA+IC0Ja2VybmVsX21hcC54aXByb20gPSAodWludHB0cl90KUNPTkZJR19Y SVBfUEhZU19BRERSOwo+ID4gLQlrZXJuZWxfbWFwLnhpcHJvbV9zeiA9ICh1aW50cHRyX3QpKCZf ZXhpcHJvbSkgLSAodWludHB0cl90KSgmX3hpcHJvbSk7Cj4gPiAtCj4gPiAtCXBoeXNfcmFtX2Jh c2UgPSBDT05GSUdfUEhZU19SQU1fQkFTRTsKPiA+IC0jaWZkZWYgQ09ORklHX1NQQVJTRU1FTV9W TUVNTUFQCj4gPiAtCXZtZW1tYXBfc3RhcnRfcGZuID0gcm91bmRfZG93bihwaHlzX3JhbV9iYXNl LCBWTUVNTUFQX0FERFJfQUxJR04pID4+IFBBR0VfU0hJRlQ7Cj4gPiAtI2VuZGlmCj4gPiAtCWtl cm5lbF9tYXAucGh5c19hZGRyID0gKHVpbnRwdHJfdClDT05GSUdfUEhZU19SQU1fQkFTRTsKPiA+ IC0Ja2VybmVsX21hcC5zaXplID0gKHVpbnRwdHJfdCkoJl9lbmQpIC0gKHVpbnRwdHJfdCkoJl9z dGFydCk7Cj4gPiAtCj4gPiAtCWtlcm5lbF9tYXAudmFfa2VybmVsX3hpcF90ZXh0X3BhX29mZnNl dCA9IGtlcm5lbF9tYXAudmlydF9hZGRyIC0ga2VybmVsX21hcC54aXByb207Cj4gPiAtCWtlcm5l bF9tYXAudmFfa2VybmVsX3hpcF9kYXRhX3BhX29mZnNldCA9IGtlcm5lbF9tYXAudmlydF9hZGRy IC0ga2VybmVsX21hcC5waHlzX2FkZHIKPiA+IC0JCQkJCQkrICh1aW50cHRyX3QpJl9zZGF0YSAt ICh1aW50cHRyX3QpJl9zdGFydDsKPiA+IC0jZWxzZQo+ID4gIAlrZXJuZWxfbWFwLnBoeXNfYWRk ciA9ICh1aW50cHRyX3QpKCZfc3RhcnQpOwo+ID4gIAlrZXJuZWxfbWFwLnNpemUgPSAodWludHB0 cl90KSgmX2VuZCkgLSBrZXJuZWxfbWFwLnBoeXNfYWRkcjsKPiA+ICAJa2VybmVsX21hcC52YV9r ZXJuZWxfcGFfb2Zmc2V0ID0ga2VybmVsX21hcC52aXJ0X2FkZHIgLSBrZXJuZWxfbWFwLnBoeXNf YWRkcjsKPiA+IC0jZW5kaWYKPiA+ICAKPiA+IC0jaWYgZGVmaW5lZChDT05GSUdfNjRCSVQpICYm ICFkZWZpbmVkKENPTkZJR19YSVBfS0VSTkVMKQo+ID4gKyNpZiBkZWZpbmVkKENPTkZJR182NEJJ VCkKPiA+ICAJc2V0X3NhdHBfbW9kZShkdGJfcGEpOwo+ID4gIAlzZXRfbW1hcF9ybmRfYml0c19t YXgoKTsKPiA+ICAjZW5kaWYKPiA+IEBAIC0xMjA5LDEzICsxMTE5LDggQEAgYXNtbGlua2FnZSB2 b2lkIF9faW5pdCBzZXR1cF92bSh1aW50cHRyX3QgZHRiX3BhKQo+ID4gIAlpZiAocGd0YWJsZV9s NF9lbmFibGVkKQo+ID4gIAkJY3JlYXRlX3B1ZF9tYXBwaW5nKHRyYW1wb2xpbmVfcHVkLCBrZXJu ZWxfbWFwLnZpcnRfYWRkciwKPiA+ICAJCQkJICAgKHVpbnRwdHJfdCl0cmFtcG9saW5lX3BtZCwg UFVEX1NJWkUsIFBBR0VfVEFCTEUpOwo+ID4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ID4g LQljcmVhdGVfcG1kX21hcHBpbmcodHJhbXBvbGluZV9wbWQsIGtlcm5lbF9tYXAudmlydF9hZGRy LAo+ID4gLQkJCSAgIGtlcm5lbF9tYXAueGlwcm9tLCBQTURfU0laRSwgUEFHRV9LRVJORUxfRVhF Qyk7Cj4gPiAtI2Vsc2UKPiA+ICAJY3JlYXRlX3BtZF9tYXBwaW5nKHRyYW1wb2xpbmVfcG1kLCBr ZXJuZWxfbWFwLnZpcnRfYWRkciwKPiA+ICAJCQkgICBrZXJuZWxfbWFwLnBoeXNfYWRkciwgUE1E X1NJWkUsIFBBR0VfS0VSTkVMX0VYRUMpOwo+ID4gLSNlbmRpZgo+ID4gICNlbHNlCj4gPiAgCS8q IFNldHVwIHRyYW1wb2xpbmUgUEdEICovCj4gPiAgCWNyZWF0ZV9wZ2RfbWFwcGluZyh0cmFtcG9s aW5lX3BnX2Rpciwga2VybmVsX21hcC52aXJ0X2FkZHIsCj4gCj4gLS0gCj4gVGhhbngsIEt1bnd1 Cj4gCj4gCj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K PiBsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKPiBsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQu b3JnCj4gaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1y aXNjdgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGlu dXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0 cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1yaXNjdgo= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 892CA29B78F for ; Fri, 20 Feb 2026 15:35:11 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771601711; cv=none; b=Co1oE2mNdrdnd1nXhUxUwJkknST/YkQn6IeX8AakDa0RWb801MO+5KtbJDuruGG1MGqIgLxUguhLDP/EH8cya33pq+vGOPqvIuWx0+kLFSEIzTo+4KFtG2moSRs6umUZjMMfxuVxRBMN6ObDK5elSH8GoVFrqGkRZmJfqzN6u2Y= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1771601711; c=relaxed/simple; bh=hMocGbqb+DjCzyxxuriJP4ipo7LDuCuBbgPZfyi0fzU=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=qs5ruEmLO0P0YyDLdlD3U30RemVRKhxx2QtSnqAMMLhEsvjW3LWICPWscJkIq2T+VeDtIft2QGqotKhCVhfTsV1dKeyxmiw5aBVtF5xzdf1Z3q+KurlvwSpWIC921VA4wvzz1oYMWqv2ZZmVVo2w/GesoHdnPD5/vMk5h8jxGF0= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=NRR2zRaZ; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="NRR2zRaZ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 383C8C116C6; Fri, 20 Feb 2026 15:35:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1771601711; bh=hMocGbqb+DjCzyxxuriJP4ipo7LDuCuBbgPZfyi0fzU=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=NRR2zRaZX2VHq71MdxVNVVJTx87Fl01z8LgRxWvU5eRllDVC2fDHbiBbmxXibws+t eNMdyn7VPFvtWLTh/+g9RCy+q8yDrjq63DBgU4qbY0hX29udHXFz90wNlZs0w/hNj8 4LSO86t2r2g8MsPUURxWy/O5m3lgKkCDbq7uePq8BF38SCNDjx1DLl9sRff1sxjNMK AzvOvi6cW+r+72DWm5pgpde3Kxq6G1GONWqwHV/neOI60S7NX2a3DLyRMRN6cg49CL DveWqnaq5iEAHdkfzePO4f0+UjzZm5hFOK2P3zXLSstzJ+5i01qSyFSA+av8ZS68iH WMJyxaNBr8tyg== Date: Fri, 20 Feb 2026 23:16:37 +0800 From: Jisheng Zhang To: Kunwu Chan Cc: Nam Cao , Paul Walmsley , Palmer Dabbelt , Albert Ou , Alexandre Ghiti , linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, Zhouyi Zhou , Frederik Haxel , Vitaly Wool Subject: Re: [PATCH] riscv: Remove support for XIP kernel Message-ID: References: <20260202115403.2119218-1-namcao@linutronix.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: On Fri, Feb 13, 2026 at 05:37:45PM +0800, Kunwu Chan wrote: > Hi, > > Please don't remove CONFIG_XIP_KERNEL. Can you plz show a real and valid usage of XIP with linux-riscv? If we take a look at the code, it's obvious the XIP mess the riscv arch code. So when people modifies the riscv arch code, they have to take care of the XIP, the time spent here is a totally waste, the gain does not compensate for the loss. > > Zhouyi Zhou zhouzhouyi@gmail.com and I are > willing to take over > maintainership and keep it build-tested and maintained going forward. $ git log --oneline --author="Kunwu Chan" -- arch/riscv ':(exclude)arch/riscv/dts' |wc -l 0 $ git log --oneline --author="Zhouyi" -- arch/riscv ':(exclude)arch/riscv/dts' |wc -l 0 Sorry for being too hypercritical, but MAINTAINERS doesn't work like this, I don't think a person can really maintain the riscv xip code if he/she hasn't never upstreamed any patch to riscv arch source code. The final result would be the maintainship is offloaded to patch authors and riscv arch maintainers. > > We will send a MAINTAINERS patch shortly. See above, how does a person who has never contributed one LoC to coresponding code maintain the code? > > > Thanx,  Kunwu > > On 2/2/26 19:54, Nam Cao wrote: > > XIP has a history of being broken for long periods of time. In 2023, it was > > broken for 18 months before getting fixed [1]. In 2024 it was 4 months [2]. > > > > And now it is broken again since commit a44fb5722199 ("riscv: Add runtime > > constant support"), 10 months ago. > > > > These are clear signs that XIP feature is not being used. > > > > I occasionally looked after XIP, but mostly because I was bored and had > > nothing better to do. > > > > Remove XIP support. Revert is possible if someone shows up complaining. > > > > Link: https://lore.kernel.org/linux-riscv/20231212-customary-hardcover-e19462bf8e75@wendy/ [1] > > Link: https://lore.kernel.org/linux-riscv/20240526110104.470429-1-namcao@linutronix.de/ [2] > > Signed-off-by: Nam Cao > > Cc: Frederik Haxel > > Cc: Vitaly Wool > > --- > > arch/riscv/Kconfig | 86 ++++++--------------- > > arch/riscv/Kconfig.socs | 8 +- > > arch/riscv/Makefile | 3 - > > arch/riscv/boot/Makefile | 11 --- > > arch/riscv/include/asm/page.h | 29 -------- > > arch/riscv/include/asm/pgtable.h | 20 ----- > > arch/riscv/include/asm/scs.h | 1 - > > arch/riscv/include/asm/set_memory.h | 2 +- > > arch/riscv/include/asm/xip_fixup.h | 49 ------------ > > arch/riscv/kernel/head.S | 41 ---------- > > arch/riscv/kernel/head.h | 3 - > > arch/riscv/kernel/setup.c | 6 +- > > arch/riscv/kernel/suspend_entry.S | 2 - > > arch/riscv/kernel/traps.c | 4 - > > arch/riscv/kernel/vmcore_info.c | 7 -- > > arch/riscv/kernel/vmlinux.lds.S | 5 -- > > arch/riscv/mm/init.c | 111 ++-------------------------- > > 17 files changed, 37 insertions(+), 351 deletions(-) > > delete mode 100644 arch/riscv/include/asm/xip_fixup.h > > > > diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig > > index 7e76b6316425..e8ac6c61e27d 100644 > > --- a/arch/riscv/Kconfig > > +++ b/arch/riscv/Kconfig > > @@ -48,8 +48,8 @@ config RISCV > > select ARCH_HAS_PTE_SPECIAL > > select ARCH_HAS_SET_DIRECT_MAP if MMU > > select ARCH_HAS_SET_MEMORY if MMU > > - select ARCH_HAS_STRICT_KERNEL_RWX if MMU && !XIP_KERNEL > > - select ARCH_HAS_STRICT_MODULE_RWX if MMU && !XIP_KERNEL > > + select ARCH_HAS_STRICT_KERNEL_RWX if MMU > > + select ARCH_HAS_STRICT_MODULE_RWX if MMU > > select ARCH_HAS_SYNC_CORE_BEFORE_USERMODE > > select ARCH_HAS_SYSCALL_WRAPPER > > select ARCH_HAS_TICK_BROADCAST if GENERIC_CLOCKEVENTS_BROADCAST > > @@ -85,7 +85,7 @@ config RISCV > > select ARCH_WANT_FRAME_POINTERS > > select ARCH_WANT_GENERAL_HUGETLB if !RISCV_ISA_SVNAPOT > > select ARCH_WANT_HUGE_PMD_SHARE if 64BIT > > - select ARCH_WANT_LD_ORPHAN_WARN if !XIP_KERNEL > > + select ARCH_WANT_LD_ORPHAN_WARN > > select ARCH_WANT_OPTIMIZE_DAX_VMEMMAP > > select ARCH_WANT_OPTIMIZE_HUGETLB_VMEMMAP > > select ARCH_WANTS_NO_INSTR > > @@ -130,13 +130,13 @@ config RISCV > > select HAVE_ARCH_AUDITSYSCALL > > select HAVE_ARCH_HUGE_VMALLOC if HAVE_ARCH_HUGE_VMAP > > select HAVE_ARCH_HUGE_VMAP if MMU && 64BIT > > - select HAVE_ARCH_JUMP_LABEL if !XIP_KERNEL > > - select HAVE_ARCH_JUMP_LABEL_RELATIVE if !XIP_KERNEL > > + select HAVE_ARCH_JUMP_LABEL > > + select HAVE_ARCH_JUMP_LABEL_RELATIVE > > select HAVE_ARCH_KASAN if MMU && 64BIT > > select HAVE_ARCH_KASAN_VMALLOC if MMU && 64BIT > > select HAVE_ARCH_KFENCE if MMU && 64BIT > > select HAVE_ARCH_KSTACK_ERASE > > - select HAVE_ARCH_KGDB if !XIP_KERNEL > > + select HAVE_ARCH_KGDB > > select HAVE_ARCH_KGDB_QXFER_PKT > > select HAVE_ARCH_MMAP_RND_BITS if MMU > > select HAVE_ARCH_MMAP_RND_COMPAT_BITS if COMPAT > > @@ -154,7 +154,7 @@ config RISCV > > select HAVE_CONTEXT_TRACKING_USER > > select HAVE_DEBUG_KMEMLEAK > > select HAVE_DMA_CONTIGUOUS if MMU > > - select HAVE_DYNAMIC_FTRACE if !XIP_KERNEL && MMU && (CLANG_SUPPORTS_DYNAMIC_FTRACE || GCC_SUPPORTS_DYNAMIC_FTRACE) > > + select HAVE_DYNAMIC_FTRACE if MMU && (CLANG_SUPPORTS_DYNAMIC_FTRACE || GCC_SUPPORTS_DYNAMIC_FTRACE) > > select FUNCTION_ALIGNMENT_4B if HAVE_DYNAMIC_FTRACE && RISCV_ISA_C > > select HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS if HAVE_DYNAMIC_FTRACE_WITH_CALL_OPS > > select HAVE_DYNAMIC_FTRACE_WITH_CALL_OPS if (DYNAMIC_FTRACE_WITH_ARGS && !CFI) > > @@ -162,7 +162,7 @@ config RISCV > > select HAVE_FTRACE_GRAPH_FUNC > > select HAVE_FUNCTION_GRAPH_TRACER if HAVE_DYNAMIC_FTRACE_WITH_ARGS > > select HAVE_FUNCTION_GRAPH_FREGS > > - select HAVE_FUNCTION_TRACER if !XIP_KERNEL && HAVE_DYNAMIC_FTRACE > > + select HAVE_FUNCTION_TRACER if HAVE_DYNAMIC_FTRACE > > select HAVE_EBPF_JIT if MMU > > select HAVE_GENERIC_TIF_BITS > > select HAVE_GUP_FAST if MMU > > @@ -171,16 +171,16 @@ config RISCV > > select HAVE_GCC_PLUGINS > > select HAVE_GENERIC_VDSO if MMU > > select HAVE_IRQ_TIME_ACCOUNTING > > - select HAVE_KERNEL_BZIP2 if !XIP_KERNEL && !EFI_ZBOOT > > - select HAVE_KERNEL_GZIP if !XIP_KERNEL && !EFI_ZBOOT > > - select HAVE_KERNEL_LZ4 if !XIP_KERNEL && !EFI_ZBOOT > > - select HAVE_KERNEL_LZMA if !XIP_KERNEL && !EFI_ZBOOT > > - select HAVE_KERNEL_LZO if !XIP_KERNEL && !EFI_ZBOOT > > - select HAVE_KERNEL_UNCOMPRESSED if !XIP_KERNEL && !EFI_ZBOOT > > - select HAVE_KERNEL_ZSTD if !XIP_KERNEL && !EFI_ZBOOT > > - select HAVE_KERNEL_XZ if !XIP_KERNEL && !EFI_ZBOOT > > - select HAVE_KPROBES if !XIP_KERNEL > > - select HAVE_KRETPROBES if !XIP_KERNEL > > + select HAVE_KERNEL_BZIP2 if !EFI_ZBOOT > > + select HAVE_KERNEL_GZIP if !EFI_ZBOOT > > + select HAVE_KERNEL_LZ4 if !EFI_ZBOOT > > + select HAVE_KERNEL_LZMA if !EFI_ZBOOT > > + select HAVE_KERNEL_LZO if !EFI_ZBOOT > > + select HAVE_KERNEL_UNCOMPRESSED if !EFI_ZBOOT > > + select HAVE_KERNEL_ZSTD if !EFI_ZBOOT > > + select HAVE_KERNEL_XZ if !EFI_ZBOOT > > + select HAVE_KPROBES > > + select HAVE_KRETPROBES > > # https://github.com/ClangBuiltLinux/linux/issues/1881 > > select HAVE_LD_DEAD_CODE_DATA_ELIMINATION if !LD_IS_LLD > > select HAVE_MOVE_PMD > > @@ -191,9 +191,9 @@ config RISCV > > select HAVE_PERF_REGS > > select HAVE_PERF_USER_STACK_DUMP > > select HAVE_POSIX_CPU_TIMERS_TASK_WORK > > - select HAVE_PREEMPT_DYNAMIC_KEY if !XIP_KERNEL > > + select HAVE_PREEMPT_DYNAMIC_KEY > > select HAVE_REGS_AND_STACK_ACCESS_API > > - select HAVE_RETHOOK if !XIP_KERNEL > > + select HAVE_RETHOOK > > select HAVE_RSEQ > > select HAVE_RUST if RUSTC_SUPPORTS_RISCV && CC_IS_CLANG > > select HAVE_SAMPLE_FTRACE_DIRECT > > @@ -214,7 +214,7 @@ config RISCV > > select PCI_ECAM if (ACPI && PCI) > > select PCI_MSI if PCI > > select RELOCATABLE if !MMU && !PHYS_RAM_BASE_FIXED > > - select RISCV_ALTERNATIVE if !XIP_KERNEL > > + select RISCV_ALTERNATIVE > > select RISCV_APLIC > > select RISCV_IMSIC > > select RISCV_INTC > > @@ -541,7 +541,6 @@ endchoice > > > > config RISCV_ALTERNATIVE > > bool > > - depends on !XIP_KERNEL > > help > > This Kconfig allows the kernel to automatically patch the > > erratum or cpufeature required by the execution platform at run > > @@ -1129,7 +1128,6 @@ config PARAVIRT_TIME_ACCOUNTING > > > > config RELOCATABLE > > bool "Build a relocatable kernel" > > - depends on !XIP_KERNEL > > select MODULE_SECTIONS if MODULES > > select ARCH_VMLINUX_NEEDS_RELOCS > > help > > @@ -1146,7 +1144,7 @@ config RELOCATABLE > > config RANDOMIZE_BASE > > bool "Randomize the address of the kernel image" > > select RELOCATABLE > > - depends on MMU && 64BIT && !XIP_KERNEL > > + depends on MMU && 64BIT > > help > > Randomizes the virtual address at which the kernel image is > > loaded, as a security feature that deters exploit attempts > > @@ -1236,7 +1234,7 @@ config EFI_STUB > > > > config EFI > > bool "UEFI runtime support" > > - depends on OF && !XIP_KERNEL > > + depends on OF > > depends on MMU > > default y > > select ARCH_SUPPORTS_ACPI if 64BIT > > @@ -1287,44 +1285,6 @@ config PHYS_RAM_BASE > > explicitly specified to run early relocations of read-write data > > from flash to RAM. > > > > -config XIP_KERNEL > > - bool "Kernel Execute-In-Place from ROM" > > - depends on MMU && SPARSEMEM && NONPORTABLE > > - # This prevents XIP from being enabled by all{yes,mod}config, which > > - # fail to build since XIP doesn't support large kernels. > > - depends on !COMPILE_TEST > > - select PHYS_RAM_BASE_FIXED > > - help > > - Execute-In-Place allows the kernel to run from non-volatile storage > > - directly addressable by the CPU, such as NOR flash. This saves RAM > > - space since the text section of the kernel is not loaded from flash > > - to RAM. Read-write sections, such as the data section and stack, > > - are still copied to RAM. The XIP kernel is not compressed since > > - it has to run directly from flash, so it will take more space to > > - store it. The flash address used to link the kernel object files, > > - and for storing it, is configuration dependent. Therefore, if you > > - say Y here, you must know the proper physical address where to > > - store the kernel image depending on your own flash memory usage. > > - > > - Also note that the make target becomes "make xipImage" rather than > > - "make zImage" or "make Image". The final kernel binary to put in > > - ROM memory will be arch/riscv/boot/xipImage. > > - > > - SPARSEMEM is required because the kernel text and rodata that are > > - flash resident are not backed by memmap, then any attempt to get > > - a struct page on those regions will trigger a fault. > > - > > - If unsure, say N. > > - > > -config XIP_PHYS_ADDR > > - hex "XIP Kernel Physical Location" > > - depends on XIP_KERNEL > > - default "0x21000000" > > - help > > - This is the physical address in your flash memory the kernel will > > - be linked for and stored to. This address is dependent on your > > - own flash usage. > > - > > config RISCV_ISA_FALLBACK > > bool "Permit falling back to parsing riscv,isa for extension support by default" > > default y > > diff --git a/arch/riscv/Kconfig.socs b/arch/riscv/Kconfig.socs > > index d621b85dd63b..c174ac0ec46b 100644 > > --- a/arch/riscv/Kconfig.socs > > +++ b/arch/riscv/Kconfig.socs > > @@ -2,7 +2,7 @@ menu "SoC selection" > > > > config ARCH_ANDES > > bool "Andes SoCs" > > - depends on MMU && !XIP_KERNEL > > + depends on MMU > > select ERRATA_ANDES > > help > > This enables support for Andes SoC platform hardware. > > @@ -33,7 +33,7 @@ config ARCH_RENESAS > > > > config ARCH_SIFIVE > > bool "SiFive SoCs" > > - select ERRATA_SIFIVE if !XIP_KERNEL > > + select ERRATA_SIFIVE > > help > > This enables support for SiFive SoC platform hardware. > > > > @@ -61,7 +61,7 @@ config SOC_STARFIVE > > > > config ARCH_SUNXI > > bool "Allwinner sun20i SoCs" > > - depends on MMU && !XIP_KERNEL > > + depends on MMU > > select ERRATA_THEAD > > select SUN4I_TIMER > > help > > @@ -78,7 +78,7 @@ config ARCH_TENSTORRENT > > > > config ARCH_THEAD > > bool "T-HEAD RISC-V SoCs" > > - depends on MMU && !XIP_KERNEL > > + depends on MMU > > select ERRATA_THEAD > > select PM_GENERIC_DOMAINS if PM > > help > > diff --git a/arch/riscv/Makefile b/arch/riscv/Makefile > > index 371da75a47f9..2cda87a5aaf1 100644 > > --- a/arch/riscv/Makefile > > +++ b/arch/riscv/Makefile > > @@ -150,7 +150,6 @@ ifdef CONFIG_RISCV_M_MODE > > boot-image-$(CONFIG_SOC_CANAAN_K210) := loader.bin > > endif > > boot-image-$(CONFIG_EFI_ZBOOT) := vmlinuz.efi > > -boot-image-$(CONFIG_XIP_KERNEL) := xipImage > > KBUILD_IMAGE := $(boot)/$(boot-image-y) > > > > libs-y += arch/riscv/lib/ > > @@ -218,8 +217,6 @@ define archhelp > > echo ' Image.xz - Compressed kernel image (arch/riscv/boot/Image.xz)' > > echo ' vmlinuz.efi - Compressed EFI kernel image (arch/riscv/boot/vmlinuz.efi)' > > echo ' Default when CONFIG_EFI_ZBOOT=y' > > - echo ' xipImage - Execute-in-place kernel image (arch/riscv/boot/xipImage)' > > - echo ' Default when CONFIG_XIP_KERNEL=y' > > echo ' install - Install kernel using (your) ~/bin/$(INSTALLKERNEL) or' > > echo ' (distribution) /sbin/$(INSTALLKERNEL) or install to ' > > echo ' $$(INSTALL_PATH)' > > diff --git a/arch/riscv/boot/Makefile b/arch/riscv/boot/Makefile > > index 5301adf5f3f5..fcfbe3f814d6 100644 > > --- a/arch/riscv/boot/Makefile > > +++ b/arch/riscv/boot/Makefile > > @@ -20,17 +20,6 @@ OBJCOPYFLAGS_xipImage :=-O binary -R .note -R .note.gnu.build-id -R .comment -S > > > > targets := Image Image.* loader loader.o loader.lds loader.bin xipImage > > > > -ifeq ($(CONFIG_XIP_KERNEL),y) > > - > > -quiet_cmd_mkxip = $(quiet_cmd_objcopy) > > -cmd_mkxip = $(cmd_objcopy) > > - > > -$(obj)/xipImage: vmlinux FORCE > > - $(call if_changed,mkxip) > > - @$(kecho) ' Physical Address of xipImage: $(CONFIG_XIP_PHYS_ADDR)' > > - > > -endif > > - > > $(obj)/Image: vmlinux FORCE > > $(call if_changed,objcopy) > > > > diff --git a/arch/riscv/include/asm/page.h b/arch/riscv/include/asm/page.h > > index 3c517bc9eac5..9ccd80d57ffe 100644 > > --- a/arch/riscv/include/asm/page.h > > +++ b/arch/riscv/include/asm/page.h > > @@ -29,11 +29,7 @@ > > #define PAGE_OFFSET_L5 _AC(0xff60000000000000, UL) > > #define PAGE_OFFSET_L4 _AC(0xffffaf8000000000, UL) > > #define PAGE_OFFSET_L3 _AC(0xffffffd600000000, UL) > > -#ifdef CONFIG_XIP_KERNEL > > -#define PAGE_OFFSET PAGE_OFFSET_L3 > > -#else > > #define PAGE_OFFSET kernel_map.page_offset > > -#endif /* CONFIG_XIP_KERNEL */ > > #else > > #define PAGE_OFFSET _AC(0xc0000000, UL) > > #endif /* CONFIG_64BIT */ > > @@ -105,15 +101,8 @@ struct kernel_mapping { > > /* Offset between linear mapping virtual address and kernel load address */ > > unsigned long va_pa_offset; > > /* Offset between kernel mapping virtual address and kernel load address */ > > -#ifdef CONFIG_XIP_KERNEL > > - unsigned long va_kernel_xip_text_pa_offset; > > - unsigned long va_kernel_xip_data_pa_offset; > > - uintptr_t xiprom; > > - uintptr_t xiprom_sz; > > -#else > > unsigned long page_offset; > > unsigned long va_kernel_pa_offset; > > -#endif > > }; > > > > extern struct kernel_mapping kernel_map; > > @@ -132,16 +121,7 @@ extern unsigned long vmemmap_start_pfn; > > void *linear_mapping_pa_to_va(unsigned long x); > > #endif > > > > -#ifdef CONFIG_XIP_KERNEL > > -#define kernel_mapping_pa_to_va(y) ({ \ > > - unsigned long _y = (unsigned long)(y); \ > > - (_y < phys_ram_base) ? \ > > - (void *)(_y + kernel_map.va_kernel_xip_text_pa_offset) : \ > > - (void *)(_y + kernel_map.va_kernel_xip_data_pa_offset); \ > > - }) > > -#else > > #define kernel_mapping_pa_to_va(y) ((void *)((unsigned long)(y) + kernel_map.va_kernel_pa_offset)) > > -#endif > > > > #define __pa_to_va_nodebug(x) linear_mapping_pa_to_va(x) > > > > @@ -151,16 +131,7 @@ void *linear_mapping_pa_to_va(unsigned long x); > > phys_addr_t linear_mapping_va_to_pa(unsigned long x); > > #endif > > > > -#ifdef CONFIG_XIP_KERNEL > > -#define kernel_mapping_va_to_pa(y) ({ \ > > - unsigned long _y = (unsigned long)(y); \ > > - (_y < kernel_map.virt_addr + kernel_map.xiprom_sz) ? \ > > - (_y - kernel_map.va_kernel_xip_text_pa_offset) : \ > > - (_y - kernel_map.va_kernel_xip_data_pa_offset); \ > > - }) > > -#else > > #define kernel_mapping_va_to_pa(y) ((unsigned long)(y) - kernel_map.va_kernel_pa_offset) > > -#endif > > > > #define __va_to_pa_nodebug(x) ({ \ > > unsigned long _x = x; \ > > diff --git a/arch/riscv/include/asm/pgtable.h b/arch/riscv/include/asm/pgtable.h > > index 1340aa398a74..a18c0f62b452 100644 > > --- a/arch/riscv/include/asm/pgtable.h > > +++ b/arch/riscv/include/asm/pgtable.h > > @@ -134,21 +134,6 @@ > > > > #include > > > > -#ifdef CONFIG_XIP_KERNEL > > -#define XIP_FIXUP(addr) ({ \ > > - extern char _sdata[], _start[], _end[]; \ > > - uintptr_t __rom_start_data = CONFIG_XIP_PHYS_ADDR \ > > - + (uintptr_t)&_sdata - (uintptr_t)&_start; \ > > - uintptr_t __rom_end_data = CONFIG_XIP_PHYS_ADDR \ > > - + (uintptr_t)&_end - (uintptr_t)&_start; \ > > - uintptr_t __a = (uintptr_t)(addr); \ > > - (__a >= __rom_start_data && __a < __rom_end_data) ? \ > > - __a - __rom_start_data + CONFIG_PHYS_RAM_BASE : __a; \ > > - }) > > -#else > > -#define XIP_FIXUP(addr) (addr) > > -#endif /* CONFIG_XIP_KERNEL */ > > - > > struct pt_alloc_ops { > > pte_t *(*get_pte_virt)(phys_addr_t pa); > > phys_addr_t (*alloc_pte)(uintptr_t va); > > @@ -1272,13 +1257,8 @@ static inline pte_t pte_swp_clear_exclusive(pte_t pte) > > extern char _start[]; > > extern void *_dtb_early_va; > > extern uintptr_t _dtb_early_pa; > > -#if defined(CONFIG_XIP_KERNEL) && defined(CONFIG_MMU) > > -#define dtb_early_va (*(void **)XIP_FIXUP(&_dtb_early_va)) > > -#define dtb_early_pa (*(uintptr_t *)XIP_FIXUP(&_dtb_early_pa)) > > -#else > > #define dtb_early_va _dtb_early_va > > #define dtb_early_pa _dtb_early_pa > > -#endif /* CONFIG_XIP_KERNEL */ > > extern u64 satp_mode; > > > > void paging_init(void); > > diff --git a/arch/riscv/include/asm/scs.h b/arch/riscv/include/asm/scs.h > > index ab7714aa93bd..023a412fe38d 100644 > > --- a/arch/riscv/include/asm/scs.h > > +++ b/arch/riscv/include/asm/scs.h > > @@ -10,7 +10,6 @@ > > /* Load init_shadow_call_stack to gp. */ > > .macro scs_load_init_stack > > la gp, init_shadow_call_stack > > - XIP_FIXUP_OFFSET gp > > .endm > > > > /* Load the per-CPU IRQ shadow call stack to gp. */ > > diff --git a/arch/riscv/include/asm/set_memory.h b/arch/riscv/include/asm/set_memory.h > > index 87389e93325a..ef59e1716a2c 100644 > > --- a/arch/riscv/include/asm/set_memory.h > > +++ b/arch/riscv/include/asm/set_memory.h > > @@ -47,7 +47,7 @@ bool kernel_page_present(struct page *page); > > > > #endif /* __ASSEMBLER__ */ > > > > -#if defined(CONFIG_STRICT_KERNEL_RWX) || defined(CONFIG_XIP_KERNEL) > > +#if defined(CONFIG_STRICT_KERNEL_RWX) > > #ifdef CONFIG_64BIT > > #define SECTION_ALIGN (1 << 21) > > #else > > diff --git a/arch/riscv/include/asm/xip_fixup.h b/arch/riscv/include/asm/xip_fixup.h > > deleted file mode 100644 > > index f3d56299bc22..000000000000 > > --- a/arch/riscv/include/asm/xip_fixup.h > > +++ /dev/null > > @@ -1,49 +0,0 @@ > > -/* SPDX-License-Identifier: GPL-2.0-only */ > > -/* > > - * XIP fixup macros, only useful in assembly. > > - */ > > -#ifndef _ASM_RISCV_XIP_FIXUP_H > > -#define _ASM_RISCV_XIP_FIXUP_H > > - > > -#include > > - > > -#ifdef CONFIG_XIP_KERNEL > > -.macro XIP_FIXUP_OFFSET reg > > - /* Fix-up address in Flash into address in RAM early during boot before > > - * MMU is up. Because generated code "thinks" data is in Flash, but it > > - * is actually in RAM (actually data is also in Flash, but Flash is > > - * read-only, thus we need to use the data residing in RAM). > > - * > > - * The start of data in Flash is _sdata and the start of data in RAM is > > - * CONFIG_PHYS_RAM_BASE. So this fix-up essentially does this: > > - * reg += CONFIG_PHYS_RAM_BASE - _start > > - */ > > - li t0, CONFIG_PHYS_RAM_BASE > > - add \reg, \reg, t0 > > - la t0, _sdata > > - sub \reg, \reg, t0 > > -.endm > > -.macro XIP_FIXUP_FLASH_OFFSET reg > > - /* In linker script, at the transition from read-only section to > > - * writable section, the VMA is increased while LMA remains the same. > > - * (See in linker script how _sdata, __data_loc and LOAD_OFFSET is > > - * changed) > > - * > > - * Consequently, early during boot before MMU is up, the generated code > > - * reads the "writable" section at wrong addresses, because VMA is used > > - * by compiler to generate code, but the data is located in Flash using > > - * LMA. > > - */ > > - la t0, _sdata > > - sub \reg, \reg, t0 > > - la t0, __data_loc > > - add \reg, \reg, t0 > > -.endm > > -#else > > -.macro XIP_FIXUP_OFFSET reg > > -.endm > > -.macro XIP_FIXUP_FLASH_OFFSET reg > > -.endm > > -#endif /* CONFIG_XIP_KERNEL */ > > - > > -#endif > > diff --git a/arch/riscv/kernel/head.S b/arch/riscv/kernel/head.S > > index 9c99c5ad6fe8..650399044368 100644 > > --- a/arch/riscv/kernel/head.S > > +++ b/arch/riscv/kernel/head.S > > @@ -14,7 +14,6 @@ > > #include > > #include > > #include > > -#include > > #include > > #include "efi-header.S" > > > > @@ -75,7 +74,6 @@ pe_head_start: > > relocate_enable_mmu: > > /* Relocate return address */ > > la a1, kernel_map > > - XIP_FIXUP_OFFSET a1 > > REG_L a1, KERNEL_MAP_VIRT_ADDR(a1) > > la a2, _start > > sub a1, a1, a2 > > @@ -89,7 +87,6 @@ relocate_enable_mmu: > > /* Compute satp for kernel page tables, but don't load it yet */ > > srl a2, a0, PAGE_SHIFT > > la a1, satp_mode > > - XIP_FIXUP_OFFSET a1 > > REG_L a1, 0(a1) > > or a2, a2, a1 > > > > @@ -100,7 +97,6 @@ relocate_enable_mmu: > > * to ensure the new translations are in use. > > */ > > la a0, trampoline_pg_dir > > - XIP_FIXUP_OFFSET a0 > > srl a0, a0, PAGE_SHIFT > > or a0, a0, a1 > > sfence.vma > > @@ -154,11 +150,9 @@ secondary_start_sbi: > > > > /* a0 contains the hartid & a1 contains boot data */ > > li a2, SBI_HART_BOOT_TASK_PTR_OFFSET > > - XIP_FIXUP_OFFSET a2 > > add a2, a2, a1 > > REG_L tp, (a2) > > li a3, SBI_HART_BOOT_STACK_PTR_OFFSET > > - XIP_FIXUP_OFFSET a3 > > add a3, a3, a1 > > REG_L sp, (a3) > > > > @@ -167,7 +161,6 @@ secondary_start_sbi: > > #ifdef CONFIG_MMU > > /* Enable virtual memory and relocate to virtual address */ > > la a0, swapper_pg_dir > > - XIP_FIXUP_OFFSET a0 > > call relocate_enable_mmu > > #endif > > call .Lsetup_trap_vector > > @@ -269,40 +262,13 @@ SYM_CODE_START(_start_kernel) > > .Lgood_cores: > > > > /* The lottery system is only required for spinwait booting method */ > > -#ifndef CONFIG_XIP_KERNEL > > /* Pick one hart to run the main boot sequence */ > > la a3, hart_lottery > > li a2, 1 > > amoadd.w a3, a2, (a3) > > bnez a3, .Lsecondary_start > > - > > -#else > > - /* hart_lottery in flash contains a magic number */ > > - la a3, hart_lottery > > - mv a2, a3 > > - XIP_FIXUP_OFFSET a2 > > - XIP_FIXUP_FLASH_OFFSET a3 > > - lw t1, (a3) > > - amoswap.w t0, t1, (a2) > > - /* first time here if hart_lottery in RAM is not set */ > > - beq t0, t1, .Lsecondary_start > > - > > -#endif /* CONFIG_XIP */ > > #endif /* CONFIG_RISCV_BOOT_SPINWAIT */ > > > > -#ifdef CONFIG_XIP_KERNEL > > - la sp, _end + THREAD_SIZE > > - XIP_FIXUP_OFFSET sp > > - mv s0, a0 > > - mv s1, a1 > > - call __copy_data > > - > > - /* Restore a0 & a1 copy */ > > - mv a0, s0 > > - mv a1, s1 > > -#endif > > - > > -#ifndef CONFIG_XIP_KERNEL > > /* Clear BSS for flat non-ELF images */ > > la a3, __bss_start > > la a4, __bss_stop > > @@ -312,20 +278,16 @@ SYM_CODE_START(_start_kernel) > > add a3, a3, RISCV_SZPTR > > blt a3, a4, .Lclear_bss > > .Lclear_bss_done: > > -#endif > > la a2, boot_cpu_hartid > > - XIP_FIXUP_OFFSET a2 > > REG_S a0, (a2) > > > > /* Initialize page tables and relocate to virtual addresses */ > > la tp, init_task > > la sp, init_thread_union + THREAD_SIZE > > - XIP_FIXUP_OFFSET sp > > addi sp, sp, -PT_SIZE_ON_STACK > > scs_load_init_stack > > #ifdef CONFIG_BUILTIN_DTB > > la a0, __dtb_start > > - XIP_FIXUP_OFFSET a0 > > #else > > mv a0, a1 > > #endif /* CONFIG_BUILTIN_DTB */ > > @@ -335,7 +297,6 @@ SYM_CODE_START(_start_kernel) > > call setup_vm > > #ifdef CONFIG_MMU > > la a0, early_pg_dir > > - XIP_FIXUP_OFFSET a0 > > call relocate_enable_mmu > > #endif /* CONFIG_MMU */ > > > > @@ -374,9 +335,7 @@ SYM_CODE_START(_start_kernel) > > > > slli a3, a0, LGREG > > la a1, __cpu_spinwait_stack_pointer > > - XIP_FIXUP_OFFSET a1 > > la a2, __cpu_spinwait_task_pointer > > - XIP_FIXUP_OFFSET a2 > > add a1, a3, a1 > > add a2, a3, a2 > > > > diff --git a/arch/riscv/kernel/head.h b/arch/riscv/kernel/head.h > > index a556fdaafed9..05a04bef442b 100644 > > --- a/arch/riscv/kernel/head.h > > +++ b/arch/riscv/kernel/head.h > > @@ -11,9 +11,6 @@ > > extern atomic_t hart_lottery; > > > > asmlinkage void __init setup_vm(uintptr_t dtb_pa); > > -#ifdef CONFIG_XIP_KERNEL > > -asmlinkage void __init __copy_data(void); > > -#endif > > > > #ifdef CONFIG_RISCV_BOOT_SPINWAIT > > extern void *__cpu_spinwait_stack_pointer[]; > > diff --git a/arch/riscv/kernel/setup.c b/arch/riscv/kernel/setup.c > > index b5bc5fc65cea..c89cc272440b 100644 > > --- a/arch/riscv/kernel/setup.c > > +++ b/arch/riscv/kernel/setup.c > > @@ -46,11 +46,7 @@ > > * This is used before the kernel initializes the BSS so it can't be in the > > * BSS. > > */ > > -atomic_t hart_lottery __section(".sdata") > > -#ifdef CONFIG_XIP_KERNEL > > -= ATOMIC_INIT(0xC001BEEF) > > -#endif > > -; > > +atomic_t hart_lottery __section(".sdata"); > > unsigned long boot_cpu_hartid; > > EXPORT_SYMBOL_GPL(boot_cpu_hartid); > > > > diff --git a/arch/riscv/kernel/suspend_entry.S b/arch/riscv/kernel/suspend_entry.S > > index 2d54f309c140..d71b55fd6259 100644 > > --- a/arch/riscv/kernel/suspend_entry.S > > +++ b/arch/riscv/kernel/suspend_entry.S > > @@ -10,7 +10,6 @@ > > #include > > #include > > #include > > -#include > > > > .text > > .altmacro > > @@ -70,7 +69,6 @@ SYM_TYPED_FUNC_START(__cpu_resume_enter) > > > > /* Enable MMU */ > > la a0, swapper_pg_dir > > - XIP_FIXUP_OFFSET a0 > > call relocate_enable_mmu > > > > /* Restore A0 and A1 */ > > diff --git a/arch/riscv/kernel/traps.c b/arch/riscv/kernel/traps.c > > index 5fb57fad188a..bdec54d12b2a 100644 > > --- a/arch/riscv/kernel/traps.c > > +++ b/arch/riscv/kernel/traps.c > > @@ -142,11 +142,7 @@ static void do_trap_error(struct pt_regs *regs, int signo, int code, > > } > > } > > > > -#if defined(CONFIG_XIP_KERNEL) && defined(CONFIG_RISCV_ALTERNATIVE) > > -#define __trap_section __noinstr_section(".xip.traps") > > -#else > > #define __trap_section noinstr > > -#endif > > #define DO_ERROR_INFO(name, signo, code, str) \ > > asmlinkage __visible __trap_section void name(struct pt_regs *regs) \ > > { \ > > diff --git a/arch/riscv/kernel/vmcore_info.c b/arch/riscv/kernel/vmcore_info.c > > index d5e448aa90e7..6d7a22522d63 100644 > > --- a/arch/riscv/kernel/vmcore_info.c > > +++ b/arch/riscv/kernel/vmcore_info.c > > @@ -19,13 +19,6 @@ void arch_crash_save_vmcoreinfo(void) > > #endif > > #endif > > vmcoreinfo_append_str("NUMBER(KERNEL_LINK_ADDR)=0x%lx\n", KERNEL_LINK_ADDR); > > -#ifdef CONFIG_XIP_KERNEL > > - /* TODO: Communicate with crash-utility developers on the information to > > - * export. The XIP case is more complicated, because the virtual-physical > > - * address offset depends on whether the address is in ROM or in RAM. > > - */ > > -#else > > vmcoreinfo_append_str("NUMBER(va_kernel_pa_offset)=0x%lx\n", > > kernel_map.va_kernel_pa_offset); > > -#endif > > } > > diff --git a/arch/riscv/kernel/vmlinux.lds.S b/arch/riscv/kernel/vmlinux.lds.S > > index 61bd5ba6680a..3b5ffcf3216d 100644 > > --- a/arch/riscv/kernel/vmlinux.lds.S > > +++ b/arch/riscv/kernel/vmlinux.lds.S > > @@ -7,10 +7,6 @@ > > #define RO_EXCEPTION_TABLE_ALIGN 4 > > #define RUNTIME_DISCARD_EXIT > > > > -#ifdef CONFIG_XIP_KERNEL > > -#include "vmlinux-xip.lds.S" > > -#else > > - > > #include > > #define LOAD_OFFSET KERNEL_LINK_ADDR > > > > @@ -175,4 +171,3 @@ SECTIONS > > > > DISCARDS > > } > > -#endif /* CONFIG_XIP_KERNEL */ > > diff --git a/arch/riscv/mm/init.c b/arch/riscv/mm/init.c > > index 25a8f693a765..c7ec6c0235e1 100644 > > --- a/arch/riscv/mm/init.c > > +++ b/arch/riscv/mm/init.c > > @@ -41,20 +41,17 @@ u64 new_vmalloc[NR_CPUS / sizeof(u64) + 1]; > > > > struct kernel_mapping kernel_map __ro_after_init; > > EXPORT_SYMBOL(kernel_map); > > -#ifdef CONFIG_XIP_KERNEL > > -#define kernel_map (*(struct kernel_mapping *)XIP_FIXUP(&kernel_map)) > > -#endif > > > > #ifdef CONFIG_64BIT > > -u64 satp_mode __ro_after_init = !IS_ENABLED(CONFIG_XIP_KERNEL) ? SATP_MODE_57 : SATP_MODE_39; > > +u64 satp_mode __ro_after_init = SATP_MODE_57; > > #else > > u64 satp_mode __ro_after_init = SATP_MODE_32; > > #endif > > EXPORT_SYMBOL(satp_mode); > > > > #ifdef CONFIG_64BIT > > -bool pgtable_l4_enabled __ro_after_init = !IS_ENABLED(CONFIG_XIP_KERNEL); > > -bool pgtable_l5_enabled __ro_after_init = !IS_ENABLED(CONFIG_XIP_KERNEL); > > +bool pgtable_l4_enabled __ro_after_init = true; > > +bool pgtable_l5_enabled __ro_after_init = true; > > EXPORT_SYMBOL(pgtable_l4_enabled); > > EXPORT_SYMBOL(pgtable_l5_enabled); > > #endif > > @@ -197,9 +194,6 @@ void __init arch_mm_preinit(void) > > > > /* Limit the memory size via mem. */ > > static phys_addr_t memory_limit; > > -#ifdef CONFIG_XIP_KERNEL > > -#define memory_limit (*(phys_addr_t *)XIP_FIXUP(&memory_limit)) > > -#endif /* CONFIG_XIP_KERNEL */ > > > > static int __init early_mem(char *p) > > { > > @@ -223,10 +217,7 @@ static void __init setup_bootmem(void) > > phys_addr_t max_mapped_addr; > > phys_addr_t phys_ram_end, vmlinux_start; > > > > - if (IS_ENABLED(CONFIG_XIP_KERNEL)) > > - vmlinux_start = __pa_symbol(&_sdata); > > - else > > - vmlinux_start = __pa_symbol(&_start); > > + vmlinux_start = __pa_symbol(&_start); > > > > memblock_enforce_memory_limit(memory_limit); > > > > @@ -246,12 +237,10 @@ static void __init setup_bootmem(void) > > * Make sure we align the start of the memory on a PMD boundary so that > > * at worst, we map the linear mapping with PMD mappings. > > */ > > - if (!IS_ENABLED(CONFIG_XIP_KERNEL)) { > > - phys_ram_base = memblock_start_of_DRAM() & PMD_MASK; > > + phys_ram_base = memblock_start_of_DRAM() & PMD_MASK; > > #ifdef CONFIG_SPARSEMEM_VMEMMAP > > - vmemmap_start_pfn = round_down(phys_ram_base, VMEMMAP_ADDR_ALIGN) >> PAGE_SHIFT; > > + vmemmap_start_pfn = round_down(phys_ram_base, VMEMMAP_ADDR_ALIGN) >> PAGE_SHIFT; > > #endif > > - } > > > > /* > > * In 64-bit, any use of __va/__pa before this point is wrong as we > > @@ -366,13 +355,6 @@ static pte_t fixmap_pte[PTRS_PER_PTE] __page_aligned_bss; > > > > pgd_t early_pg_dir[PTRS_PER_PGD] __initdata __aligned(PAGE_SIZE); > > > > -#ifdef CONFIG_XIP_KERNEL > > -#define pt_ops (*(struct pt_alloc_ops *)XIP_FIXUP(&pt_ops)) > > -#define trampoline_pg_dir ((pgd_t *)XIP_FIXUP(trampoline_pg_dir)) > > -#define fixmap_pte ((pte_t *)XIP_FIXUP(fixmap_pte)) > > -#define early_pg_dir ((pgd_t *)XIP_FIXUP(early_pg_dir)) > > -#endif /* CONFIG_XIP_KERNEL */ > > - > > static const pgprot_t protection_map[16] = { > > [VM_NONE] = PAGE_NONE, > > [VM_READ] = PAGE_READ, > > @@ -469,32 +451,14 @@ static pmd_t trampoline_pmd[PTRS_PER_PMD] __page_aligned_bss; > > static pmd_t fixmap_pmd[PTRS_PER_PMD] __page_aligned_bss; > > static pmd_t early_pmd[PTRS_PER_PMD] __initdata __aligned(PAGE_SIZE); > > > > -#ifdef CONFIG_XIP_KERNEL > > -#define trampoline_pmd ((pmd_t *)XIP_FIXUP(trampoline_pmd)) > > -#define fixmap_pmd ((pmd_t *)XIP_FIXUP(fixmap_pmd)) > > -#define early_pmd ((pmd_t *)XIP_FIXUP(early_pmd)) > > -#endif /* CONFIG_XIP_KERNEL */ > > - > > static p4d_t trampoline_p4d[PTRS_PER_P4D] __page_aligned_bss; > > static p4d_t fixmap_p4d[PTRS_PER_P4D] __page_aligned_bss; > > static p4d_t early_p4d[PTRS_PER_P4D] __initdata __aligned(PAGE_SIZE); > > > > -#ifdef CONFIG_XIP_KERNEL > > -#define trampoline_p4d ((p4d_t *)XIP_FIXUP(trampoline_p4d)) > > -#define fixmap_p4d ((p4d_t *)XIP_FIXUP(fixmap_p4d)) > > -#define early_p4d ((p4d_t *)XIP_FIXUP(early_p4d)) > > -#endif /* CONFIG_XIP_KERNEL */ > > - > > static pud_t trampoline_pud[PTRS_PER_PUD] __page_aligned_bss; > > static pud_t fixmap_pud[PTRS_PER_PUD] __page_aligned_bss; > > static pud_t early_pud[PTRS_PER_PUD] __initdata __aligned(PAGE_SIZE); > > > > -#ifdef CONFIG_XIP_KERNEL > > -#define trampoline_pud ((pud_t *)XIP_FIXUP(trampoline_pud)) > > -#define fixmap_pud ((pud_t *)XIP_FIXUP(fixmap_pud)) > > -#define early_pud ((pud_t *)XIP_FIXUP(early_pud)) > > -#endif /* CONFIG_XIP_KERNEL */ > > - > > static pmd_t *__init get_pmd_virt_early(phys_addr_t pa) > > { > > /* Before MMU is enabled */ > > @@ -765,21 +729,6 @@ static uintptr_t __meminit best_map_size(phys_addr_t pa, uintptr_t va, phys_addr > > return PAGE_SIZE; > > } > > > > -#ifdef CONFIG_XIP_KERNEL > > -#define phys_ram_base (*(phys_addr_t *)XIP_FIXUP(&phys_ram_base)) > > -extern char _xiprom[], _exiprom[], __data_loc; > > - > > -/* called from head.S with MMU off */ > > -asmlinkage void __init __copy_data(void) > > -{ > > - void *from = (void *)(&__data_loc); > > - void *to = (void *)CONFIG_PHYS_RAM_BASE; > > - size_t sz = (size_t)((uintptr_t)(&_end) - (uintptr_t)(&_sdata)); > > - > > - memcpy(to, from, sz); > > -} > > -#endif > > - > > #ifdef CONFIG_STRICT_KERNEL_RWX > > static __meminit pgprot_t pgprot_from_va(uintptr_t va) > > { > > @@ -815,7 +764,7 @@ static __meminit pgprot_t pgprot_from_va(uintptr_t va) > > } > > #endif /* CONFIG_STRICT_KERNEL_RWX */ > > > > -#if defined(CONFIG_64BIT) && !defined(CONFIG_XIP_KERNEL) > > +#if defined(CONFIG_64BIT) > > u64 __pi_set_satp_mode_from_cmdline(uintptr_t dtb_pa); > > u64 __pi_set_satp_mode_from_fdt(uintptr_t dtb_pa); > > > > @@ -940,28 +889,6 @@ static __init void set_satp_mode(uintptr_t dtb_pa) > > #error "setup_vm() is called from head.S before relocate so it should not use absolute addressing." > > #endif > > > > -#ifdef CONFIG_XIP_KERNEL > > -static void __init create_kernel_page_table(pgd_t *pgdir, > > - __always_unused bool early) > > -{ > > - uintptr_t va, start_va, end_va; > > - > > - /* Map the flash resident part */ > > - end_va = kernel_map.virt_addr + kernel_map.xiprom_sz; > > - for (va = kernel_map.virt_addr; va < end_va; va += PMD_SIZE) > > - create_pgd_mapping(pgdir, va, > > - kernel_map.xiprom + (va - kernel_map.virt_addr), > > - PMD_SIZE, PAGE_KERNEL_EXEC); > > - > > - /* Map the data in RAM */ > > - start_va = kernel_map.virt_addr + (uintptr_t)&_sdata - (uintptr_t)&_start; > > - end_va = kernel_map.virt_addr + kernel_map.size; > > - for (va = start_va; va < end_va; va += PMD_SIZE) > > - create_pgd_mapping(pgdir, va, > > - kernel_map.phys_addr + (va - start_va), > > - PMD_SIZE, PAGE_KERNEL); > > -} > > -#else > > static void __init create_kernel_page_table(pgd_t *pgdir, bool early) > > { > > uintptr_t va, end_va; > > @@ -974,7 +901,6 @@ static void __init create_kernel_page_table(pgd_t *pgdir, bool early) > > early ? > > PAGE_KERNEL_EXEC : pgprot_from_va(va)); > > } > > -#endif > > > > /* > > * Setup a 4MB mapping that encompasses the device tree: for 64-bit kernel, > > @@ -1116,27 +1042,11 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) > > > > kernel_map.virt_addr = KERNEL_LINK_ADDR + kernel_map.virt_offset; > > > > -#ifdef CONFIG_XIP_KERNEL > > - kernel_map.xiprom = (uintptr_t)CONFIG_XIP_PHYS_ADDR; > > - kernel_map.xiprom_sz = (uintptr_t)(&_exiprom) - (uintptr_t)(&_xiprom); > > - > > - phys_ram_base = CONFIG_PHYS_RAM_BASE; > > -#ifdef CONFIG_SPARSEMEM_VMEMMAP > > - vmemmap_start_pfn = round_down(phys_ram_base, VMEMMAP_ADDR_ALIGN) >> PAGE_SHIFT; > > -#endif > > - kernel_map.phys_addr = (uintptr_t)CONFIG_PHYS_RAM_BASE; > > - kernel_map.size = (uintptr_t)(&_end) - (uintptr_t)(&_start); > > - > > - kernel_map.va_kernel_xip_text_pa_offset = kernel_map.virt_addr - kernel_map.xiprom; > > - kernel_map.va_kernel_xip_data_pa_offset = kernel_map.virt_addr - kernel_map.phys_addr > > - + (uintptr_t)&_sdata - (uintptr_t)&_start; > > -#else > > kernel_map.phys_addr = (uintptr_t)(&_start); > > kernel_map.size = (uintptr_t)(&_end) - kernel_map.phys_addr; > > kernel_map.va_kernel_pa_offset = kernel_map.virt_addr - kernel_map.phys_addr; > > -#endif > > > > -#if defined(CONFIG_64BIT) && !defined(CONFIG_XIP_KERNEL) > > +#if defined(CONFIG_64BIT) > > set_satp_mode(dtb_pa); > > set_mmap_rnd_bits_max(); > > #endif > > @@ -1209,13 +1119,8 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) > > if (pgtable_l4_enabled) > > create_pud_mapping(trampoline_pud, kernel_map.virt_addr, > > (uintptr_t)trampoline_pmd, PUD_SIZE, PAGE_TABLE); > > -#ifdef CONFIG_XIP_KERNEL > > - create_pmd_mapping(trampoline_pmd, kernel_map.virt_addr, > > - kernel_map.xiprom, PMD_SIZE, PAGE_KERNEL_EXEC); > > -#else > > create_pmd_mapping(trampoline_pmd, kernel_map.virt_addr, > > kernel_map.phys_addr, PMD_SIZE, PAGE_KERNEL_EXEC); > > -#endif > > #else > > /* Setup trampoline PGD */ > > create_pgd_mapping(trampoline_pg_dir, kernel_map.virt_addr, > > -- > Thanx, Kunwu > > > _______________________________________________ > linux-riscv mailing list > linux-riscv@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/linux-riscv