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 283EF109879E for ; Fri, 20 Mar 2026 16:05:21 +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:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=CkIpc4ki1HFiMI4bFY+ovLSzz5zYcm+nizrLDGlHsWY=; b=qV40j+x7/lC/lM nzE0PLvNsSmG4z/ahrNg9t0uYjFywCrkYlmq/Q1ODP/5UuSX5sRLWyEMX7HbSGswyrP8UXbxCenK5 9JmHoVYR+UuwAZJZtmNYjwhi539olHGwhx59BCdtEcTV7/IvFb47TfZEcOGodeLuRb1hG0FW0voqH DryQTGuiV+R3MGudaJL9AyvvHissz8q+hDbI9//eZKVY9+m2CK1IK2fmTt7SYyErY3U0+ylrX3E6C ftH8mZdYGtT7imx8OH76ObTYyQfQNeDi+zEUS77f7WyKnOJCJJI2UikvtYCoFo+mUkZmRmhUraHsN Cgi7pdHYfxx7ibLmevDw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1w3cLW-0000000D5Rb-3OiC; Fri, 20 Mar 2026 16:05:10 +0000 Received: from us-smtp-delivery-124.mimecast.com ([170.10.133.124]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1w3cLT-0000000D5R7-3kai for linux-riscv@lists.infradead.org; Fri, 20 Mar 2026 16:05:09 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1774022707; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=wr0Rk6et5CA6CvUspb4cZnB+QZC0WZ+M0KIKtjqSsb8=; b=KZmO59EOjGMivtL/MptJDBvJMVPQT4c/2s9ZosIJECeZIqt1Kjfu8LxF5OD3MNNIomjtG8 fwb9TKhbkYVtcI/YXpOkqAQjUeHuQXdIJTW8bH2Nlr1DxqzP4L25IcqT1SQ6aRwaBHNE9d WUq7VwjpcxW/5iK/ga4rT/VYid3shuA= Received: from mx-prod-mc-05.mail-002.prod.us-west-2.aws.redhat.com (ec2-54-186-198-63.us-west-2.compute.amazonaws.com [54.186.198.63]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-350-k9FjHkmEOnuUF6ANXA1TnA-1; Fri, 20 Mar 2026 12:05:00 -0400 X-MC-Unique: k9FjHkmEOnuUF6ANXA1TnA-1 X-Mimecast-MFC-AGG-ID: k9FjHkmEOnuUF6ANXA1TnA_1774022699 Received: from mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mx-prod-mc-05.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id 3899B195609E; Fri, 20 Mar 2026 16:04:58 +0000 (UTC) Received: from cmirabil.redhat.com (unknown [10.2.16.157]) by mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTP id F036730001A1; Fri, 20 Mar 2026 16:04:55 +0000 (UTC) From: Charles Mirabile To: namcao@linutronix.de Cc: alex@ghiti.fr, aou@eecs.berkeley.edu, haxel@fzi.de, linux-kernel@vger.kernel.org, linux-riscv@lists.infradead.org, palmer@dabbelt.com, pjw@kernel.org, vitaly.wool@konsulko.com, cmirabil@redhat.com Subject: Re: [PATCH] riscv: Remove support for XIP kernel Date: Fri, 20 Mar 2026 12:04:43 -0400 Message-ID: <20260320160443.1850701-1-cmirabil@redhat.com> In-Reply-To: <20260202115403.2119218-1-namcao@linutronix.de> References: <20260202115403.2119218-1-namcao@linutronix.de> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.4.1 on 10.30.177.4 X-Mimecast-MFC-PROC-ID: WwmPYfE09panbJq1-ylQHD_rCB3dvV98eAgUUAH7oKU_1774022699 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260320_090508_104016_EB764D69 X-CRM114-Status: GOOD ( 47.08 ) 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 RnJvbTogY21pcmFiaWxAcmVkaGF0LmNvbQoKSGnigJQKCkNoaW1pbmcgaW4gYXMgYW5vdGhlciB2 b2ljZSBpbnRlcmVzdGVkIGluIG5vdCBzY3JhcHBpbmcgWElQLiBJIHRoaW5rClJJU0MtViBpcyBh biBpbnRlcmVzdGluZyBwb3NpdGlvbiBhcyBhbiBJU0Egb2YgYmVpbmcgYWJsZSB0byBzdXBwb3J0 CmJvdGggZGVza3RvcC9zZXJ2ZXIgY2xhc3MgaGlnaCBwZXJmb3JtYW5jZSBkZXNpZ25zLCBidXQg YWxzbyBsb3cgY29zdAplbWJlZGRlZCBhcHBsaWNhdGlvbnMuIFRoZSBhYmlsaXR5IHRvIHJ1biBs aW51eCBpbiBNLU1vZGUgd2l0aG91dCBhbgpNTVUsIGFuZCBldmVuIFhJUCBkaXJlY3RseSBmcm9t IHN0b3JhZ2Ugd2l0aGluIG9uZSBjb2RlIGJhc2UganVzdCBieQpjaGFuZ2luZyBjb25maWd1cmF0 aW9uIG9wdGlvbnMgaXMgZmFudGFzdGljIGFuZCBwb3NpdGlvbnMgbGludXggdG8gYmUKdGhlIG9i dmlvdXMga2VybmVsIG9mIGNob2ljZSBmb3IgYm90aCBraW5kcyBvZiBSSVNDLVYgaW1wbGVtZW50 YXRpb25zLgoKVGhhdCBiZWluZyBzYWlkLCBpdCBpcyBjbGVhciB0aGF0IHRoZXNlIHVzZS1jYXNl cyBhcmUgbm90IGJlaW5nIHRlc3RlZApvciBtYWludGFpbmVkLiBUaGUgYWRkaXRpb24gb2YgcnVu dGltZSBjb25zdGFudCBzdXBwb3J0IGZvciBSSVNDLVYgYWxzbwpicm9rZSBuby1tbXUgd2hpY2gg SSBmaXhlZCBpbjoKOGQ5MGQ5ODcyZWRhZSAoInJpc2N2OiBmaXggcnVudGltZSBjb25zdGFudCBz dXBwb3J0IGZvciBub21tdSBrZXJuZWxzIikKYW5kIGNsZWFybHkgaXMgYWxzbyBYSVAgd2hpY2gg SSBkaWQgbm90IHRlc3QgYXQgdGhlIHRpbWUgYW5kIGRpZCBub3QKcmVhbGl6ZS4gSSBoYXZlIGEg cGF0Y2ggdG8gZXNzZW50aWFsbHkganVzdCBkaXNhYmxlIHRoZSBydW50aW1lIGNvbnN0YW50cwps b2dpYyBvbiBSSVNDLVYgd2hlbiBDT05GSUdfWElQX0tFUk5FTCBpcyBlbmFibGVkIGhlcmUgdGhh dCBzaG91bGQgZml4IGl0OgpodHRwczovL2xvcmUua2VybmVsLm9yZy9sa21sLzIwMjYwMzIwMTU1 ODQzLjE4NDgxODAtMS1jbWlyYWJpbEByZWRoYXQuY29tCgpUaGF0IGJlaW5nIHNhaWQsIEluIHRy dXRoIEkgaGF2ZSBub3QgYWN0dWFsbHkgYnVpbHQgb3IgdXNlZCBhbiBYSVAgbGludXgKa2VybmVs IG9uIFJJU0MtViwgc28gSSBhbSBub3Qgc3VyZSBJIGNhbiB2b2x1bnRlZXIgdG8gdGVzdCBvciBt YWludGFpbiBpdAphdCB0aGlzIG1vbWVudCwgYnV0IEkgYW0gcGxhbm5pbmcgb24gZXhwZXJpbWVu dGluZyB3aXRoIE0tTW9kZSBub01NVSBYSVAKbGludXggb24gdGhlIHNpZml2ZSBoaWZpdmUgdW5s ZWFzaGVkIGJvYXJkIHdpdGggdGhlIGhvcGUgb2YgY3JlYXRpbmcgYQprZXJuZWwgdGhhdCBjYW4g YWN0IGFzIGEgbGludXhib290IHBheWxvYWQgYW5kIGVzc2VudGlhbGx5IHJlcGxhY2UgdGhlCmZp cm13YXJlIG9mIHRoZSBkZXZpY2UuIFdpdGggdGhlIGZpeCBJIHByb3Bvc2VkLCBwZXJoYXBzIGl0 IGlzIHRlbmFibGUgdG8Kbm90IHJlbW92ZSBYSVAgYXQgdGhpcyB0aW1lIGFuZCBnbyBiYWNrIHRv IHRoZSBzdGF0dXMgcXVvPyBJIHVuZGVyc3RhbmQKdGhhdCBpdCBpcyBqdXN0IGtpY2tpbmcgdGhl IGNhbiBkb3duIHRoZSByb2FkIHVudGlsIHRoZSBuZXh0IHRpbWUgc29tZW9uZQptYWtlcyBhIGNo YW5nZSB0aGF0IGJyZWFrcyBYSVAgYW5kIG5vIG9uZSBub3RpY2VzIGlmIG5vIG9uZSBpcyB0ZXN0 aW5nLApidXQgbWF5YmUgd2UgY2FuIGhhdmUgYSBjb252ZXJzYXRpb24gYWJvdXQgaG93IHdlIGNv dWxkIGltcHJvdmUgdGhlCnNpdHVhdGlvbiBpbiB0aGUgbWVhbnRpbWUgYW5kIGhhdmUgYW4gYWN0 dWFsIHBsYW4gdG8gY2F0Y2ggdGhhdCBiZWZvcmUKc3VjaCBhIGJyZWFraW5nIHBhdGNoIG1ha2Vz IGl0IHRvIG1haW5saW5lIG5leHQgdGltZS4KCkJlc3TigJRDaGFybGllCgpPbiBNb24sIEZlYiAw MiwgMjAyNiBhdCAxMjo1NDowM1BNICswMTAwLCBOYW0gQ2FvIHdyb3RlOgo+IFhJUCBoYXMgYSBo aXN0b3J5IG9mIGJlaW5nIGJyb2tlbiBmb3IgbG9uZyBwZXJpb2RzIG9mIHRpbWUuIEluIDIwMjMs IGl0IHdhcwo+IGJyb2tlbiBmb3IgMTggbW9udGhzIGJlZm9yZSBnZXR0aW5nIGZpeGVkIFsxXS4g SW4gMjAyNCBpdCB3YXMgNCBtb250aHMgWzJdLgo+IAo+IEFuZCBub3cgaXQgaXMgYnJva2VuIGFn YWluIHNpbmNlIGNvbW1pdCBhNDRmYjU3MjIxOTkgKCJyaXNjdjogQWRkIHJ1bnRpbWUKPiBjb25z dGFudCBzdXBwb3J0IiksIDEwIG1vbnRocyBhZ28uCj4gCj4gVGhlc2UgYXJlIGNsZWFyIHNpZ25z IHRoYXQgWElQIGZlYXR1cmUgaXMgbm90IGJlaW5nIHVzZWQuCj4gCj4gSSBvY2Nhc2lvbmFsbHkg bG9va2VkIGFmdGVyIFhJUCwgYnV0IG1vc3RseSBiZWNhdXNlIEkgd2FzIGJvcmVkIGFuZCBoYWQK PiBub3RoaW5nIGJldHRlciB0byBkby4KPiAKPiBSZW1vdmUgWElQIHN1cHBvcnQuIFJldmVydCBp cyBwb3NzaWJsZSBpZiBzb21lb25lIHNob3dzIHVwIGNvbXBsYWluaW5nLgo+IAo+IExpbms6IGh0 dHBzOi8vbG9yZS5rZXJuZWwub3JnL2xpbnV4LXJpc2N2LzIwMjMxMjEyLWN1c3RvbWFyeS1oYXJk Y292ZXItZTE5NDYyYmY4ZTc1QHdlbmR5LyBbMV0KPiBMaW5rOiBodHRwczovL2xvcmUua2VybmVs Lm9yZy9saW51eC1yaXNjdi8yMDI0MDUyNjExMDEwNC40NzA0MjktMS1uYW1jYW9AbGludXRyb25p eC5kZS8gWzJdCj4gU2lnbmVkLW9mZi1ieTogTmFtIENhbyA8bmFtY2FvQGxpbnV0cm9uaXguZGU+ Cj4gQ2M6IEZyZWRlcmlrIEhheGVsIDxoYXhlbEBmemkuZGU+Cj4gQ2M6IFZpdGFseSBXb29sIDx2 aXRhbHkud29vbEBrb25zdWxrby5jb20+Cj4gLS0tCj4gIGFyY2gvcmlzY3YvS2NvbmZpZyAgICAg ICAgICAgICAgICAgIHwgIDg2ICsrKysrKy0tLS0tLS0tLS0tLS0tLQo+ICBhcmNoL3Jpc2N2L0tj b25maWcuc29jcyAgICAgICAgICAgICB8ICAgOCArLQo+ICBhcmNoL3Jpc2N2L01ha2VmaWxlICAg ICAgICAgICAgICAgICB8ICAgMyAtCj4gIGFyY2gvcmlzY3YvYm9vdC9NYWtlZmlsZSAgICAgICAg ICAgIHwgIDExIC0tLQo+ICBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3BhZ2UuaCAgICAgICB8ICAy OSAtLS0tLS0tLQo+ICBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3BndGFibGUuaCAgICB8ICAyMCAt LS0tLQo+ICBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3Njcy5oICAgICAgICB8ICAgMSAtCj4gIGFy Y2gvcmlzY3YvaW5jbHVkZS9hc20vc2V0X21lbW9yeS5oIHwgICAyICstCj4gIGFyY2gvcmlzY3Yv aW5jbHVkZS9hc20veGlwX2ZpeHVwLmggIHwgIDQ5IC0tLS0tLS0tLS0tLQo+ICBhcmNoL3Jpc2N2 L2tlcm5lbC9oZWFkLlMgICAgICAgICAgICB8ICA0MSAtLS0tLS0tLS0tCj4gIGFyY2gvcmlzY3Yv a2VybmVsL2hlYWQuaCAgICAgICAgICAgIHwgICAzIC0KPiAgYXJjaC9yaXNjdi9rZXJuZWwvc2V0 dXAuYyAgICAgICAgICAgfCAgIDYgKy0KPiAgYXJjaC9yaXNjdi9rZXJuZWwvc3VzcGVuZF9lbnRy eS5TICAgfCAgIDIgLQo+ICBhcmNoL3Jpc2N2L2tlcm5lbC90cmFwcy5jICAgICAgICAgICB8ICAg NCAtCj4gIGFyY2gvcmlzY3Yva2VybmVsL3ZtY29yZV9pbmZvLmMgICAgIHwgICA3IC0tCj4gIGFy Y2gvcmlzY3Yva2VybmVsL3ZtbGludXgubGRzLlMgICAgIHwgICA1IC0tCj4gIGFyY2gvcmlzY3Yv bW0vaW5pdC5jICAgICAgICAgICAgICAgIHwgMTExICsrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KPiAgMTcgZmlsZXMgY2hhbmdlZCwgMzcgaW5zZXJ0aW9ucygrKSwgMzUxIGRlbGV0aW9ucygt KQo+ICBkZWxldGUgbW9kZSAxMDA2NDQgYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS94aXBfZml4dXAu aAo+IAo+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L0tjb25maWcgYi9hcmNoL3Jpc2N2L0tjb25m aWcKPiBpbmRleCA3ZTc2YjYzMTY0MjUuLmU4YWM2YzYxZTI3ZCAxMDA2NDQKPiAtLS0gYS9hcmNo L3Jpc2N2L0tjb25maWcKPiArKysgYi9hcmNoL3Jpc2N2L0tjb25maWcKPiBAQCAtNDgsOCArNDgs OCBAQCBjb25maWcgUklTQ1YKPiAgCXNlbGVjdCBBUkNIX0hBU19QVEVfU1BFQ0lBTAo+ICAJc2Vs ZWN0IEFSQ0hfSEFTX1NFVF9ESVJFQ1RfTUFQIGlmIE1NVQo+ICAJc2VsZWN0IEFSQ0hfSEFTX1NF VF9NRU1PUlkgaWYgTU1VCj4gLQlzZWxlY3QgQVJDSF9IQVNfU1RSSUNUX0tFUk5FTF9SV1ggaWYg TU1VICYmICFYSVBfS0VSTkVMCj4gLQlzZWxlY3QgQVJDSF9IQVNfU1RSSUNUX01PRFVMRV9SV1gg aWYgTU1VICYmICFYSVBfS0VSTkVMCj4gKwlzZWxlY3QgQVJDSF9IQVNfU1RSSUNUX0tFUk5FTF9S V1ggaWYgTU1VCj4gKwlzZWxlY3QgQVJDSF9IQVNfU1RSSUNUX01PRFVMRV9SV1ggaWYgTU1VCj4g IAlzZWxlY3QgQVJDSF9IQVNfU1lOQ19DT1JFX0JFRk9SRV9VU0VSTU9ERQo+ICAJc2VsZWN0IEFS Q0hfSEFTX1NZU0NBTExfV1JBUFBFUgo+ICAJc2VsZWN0IEFSQ0hfSEFTX1RJQ0tfQlJPQURDQVNU IGlmIEdFTkVSSUNfQ0xPQ0tFVkVOVFNfQlJPQURDQVNUCj4gQEAgLTg1LDcgKzg1LDcgQEAgY29u ZmlnIFJJU0NWCj4gIAlzZWxlY3QgQVJDSF9XQU5UX0ZSQU1FX1BPSU5URVJTCj4gIAlzZWxlY3Qg QVJDSF9XQU5UX0dFTkVSQUxfSFVHRVRMQiBpZiAhUklTQ1ZfSVNBX1NWTkFQT1QKPiAgCXNlbGVj dCBBUkNIX1dBTlRfSFVHRV9QTURfU0hBUkUgaWYgNjRCSVQKPiAtCXNlbGVjdCBBUkNIX1dBTlRf TERfT1JQSEFOX1dBUk4gaWYgIVhJUF9LRVJORUwKPiArCXNlbGVjdCBBUkNIX1dBTlRfTERfT1JQ SEFOX1dBUk4KPiAgCXNlbGVjdCBBUkNIX1dBTlRfT1BUSU1JWkVfREFYX1ZNRU1NQVAKPiAgCXNl bGVjdCBBUkNIX1dBTlRfT1BUSU1JWkVfSFVHRVRMQl9WTUVNTUFQCj4gIAlzZWxlY3QgQVJDSF9X QU5UU19OT19JTlNUUgo+IEBAIC0xMzAsMTMgKzEzMCwxMyBAQCBjb25maWcgUklTQ1YKPiAgCXNl bGVjdCBIQVZFX0FSQ0hfQVVESVRTWVNDQUxMCj4gIAlzZWxlY3QgSEFWRV9BUkNIX0hVR0VfVk1B TExPQyBpZiBIQVZFX0FSQ0hfSFVHRV9WTUFQCj4gIAlzZWxlY3QgSEFWRV9BUkNIX0hVR0VfVk1B UCBpZiBNTVUgJiYgNjRCSVQKPiAtCXNlbGVjdCBIQVZFX0FSQ0hfSlVNUF9MQUJFTCBpZiAhWElQ X0tFUk5FTAo+IC0Jc2VsZWN0IEhBVkVfQVJDSF9KVU1QX0xBQkVMX1JFTEFUSVZFIGlmICFYSVBf S0VSTkVMCj4gKwlzZWxlY3QgSEFWRV9BUkNIX0pVTVBfTEFCRUwKPiArCXNlbGVjdCBIQVZFX0FS Q0hfSlVNUF9MQUJFTF9SRUxBVElWRQo+ICAJc2VsZWN0IEhBVkVfQVJDSF9LQVNBTiBpZiBNTVUg JiYgNjRCSVQKPiAgCXNlbGVjdCBIQVZFX0FSQ0hfS0FTQU5fVk1BTExPQyBpZiBNTVUgJiYgNjRC SVQKPiAgCXNlbGVjdCBIQVZFX0FSQ0hfS0ZFTkNFIGlmIE1NVSAmJiA2NEJJVAo+ICAJc2VsZWN0 IEhBVkVfQVJDSF9LU1RBQ0tfRVJBU0UKPiAtCXNlbGVjdCBIQVZFX0FSQ0hfS0dEQiBpZiAhWElQ X0tFUk5FTAo+ICsJc2VsZWN0IEhBVkVfQVJDSF9LR0RCCj4gIAlzZWxlY3QgSEFWRV9BUkNIX0tH REJfUVhGRVJfUEtUCj4gIAlzZWxlY3QgSEFWRV9BUkNIX01NQVBfUk5EX0JJVFMgaWYgTU1VCj4g IAlzZWxlY3QgSEFWRV9BUkNIX01NQVBfUk5EX0NPTVBBVF9CSVRTIGlmIENPTVBBVAo+IEBAIC0x NTQsNyArMTU0LDcgQEAgY29uZmlnIFJJU0NWCj4gIAlzZWxlY3QgSEFWRV9DT05URVhUX1RSQUNL SU5HX1VTRVIKPiAgCXNlbGVjdCBIQVZFX0RFQlVHX0tNRU1MRUFLCj4gIAlzZWxlY3QgSEFWRV9E TUFfQ09OVElHVU9VUyBpZiBNTVUKPiAtCXNlbGVjdCBIQVZFX0RZTkFNSUNfRlRSQUNFIGlmICFY SVBfS0VSTkVMICYmIE1NVSAmJiAoQ0xBTkdfU1VQUE9SVFNfRFlOQU1JQ19GVFJBQ0UgfHwgR0ND X1NVUFBPUlRTX0RZTkFNSUNfRlRSQUNFKQo+ICsJc2VsZWN0IEhBVkVfRFlOQU1JQ19GVFJBQ0Ug aWYgTU1VICYmIChDTEFOR19TVVBQT1JUU19EWU5BTUlDX0ZUUkFDRSB8fCBHQ0NfU1VQUE9SVFNf RFlOQU1JQ19GVFJBQ0UpCj4gIAlzZWxlY3QgRlVOQ1RJT05fQUxJR05NRU5UXzRCIGlmIEhBVkVf RFlOQU1JQ19GVFJBQ0UgJiYgUklTQ1ZfSVNBX0MKPiAgCXNlbGVjdCBIQVZFX0RZTkFNSUNfRlRS QUNFX1dJVEhfRElSRUNUX0NBTExTIGlmIEhBVkVfRFlOQU1JQ19GVFJBQ0VfV0lUSF9DQUxMX09Q Uwo+ICAJc2VsZWN0IEhBVkVfRFlOQU1JQ19GVFJBQ0VfV0lUSF9DQUxMX09QUyBpZiAoRFlOQU1J Q19GVFJBQ0VfV0lUSF9BUkdTICYmICFDRkkpCj4gQEAgLTE2Miw3ICsxNjIsNyBAQCBjb25maWcg UklTQ1YKPiAgCXNlbGVjdCBIQVZFX0ZUUkFDRV9HUkFQSF9GVU5DCj4gIAlzZWxlY3QgSEFWRV9G VU5DVElPTl9HUkFQSF9UUkFDRVIgaWYgSEFWRV9EWU5BTUlDX0ZUUkFDRV9XSVRIX0FSR1MKPiAg CXNlbGVjdCBIQVZFX0ZVTkNUSU9OX0dSQVBIX0ZSRUdTCj4gLQlzZWxlY3QgSEFWRV9GVU5DVElP Tl9UUkFDRVIgaWYgIVhJUF9LRVJORUwgJiYgSEFWRV9EWU5BTUlDX0ZUUkFDRQo+ICsJc2VsZWN0 IEhBVkVfRlVOQ1RJT05fVFJBQ0VSIGlmIEhBVkVfRFlOQU1JQ19GVFJBQ0UKPiAgCXNlbGVjdCBI QVZFX0VCUEZfSklUIGlmIE1NVQo+ICAJc2VsZWN0IEhBVkVfR0VORVJJQ19USUZfQklUUwo+ICAJ c2VsZWN0IEhBVkVfR1VQX0ZBU1QgaWYgTU1VCj4gQEAgLTE3MSwxNiArMTcxLDE2IEBAIGNvbmZp ZyBSSVNDVgo+ICAJc2VsZWN0IEhBVkVfR0NDX1BMVUdJTlMKPiAgCXNlbGVjdCBIQVZFX0dFTkVS SUNfVkRTTyBpZiBNTVUKPiAgCXNlbGVjdCBIQVZFX0lSUV9USU1FX0FDQ09VTlRJTkcKPiAtCXNl bGVjdCBIQVZFX0tFUk5FTF9CWklQMiBpZiAhWElQX0tFUk5FTCAmJiAhRUZJX1pCT09UCj4gLQlz ZWxlY3QgSEFWRV9LRVJORUxfR1pJUCBpZiAhWElQX0tFUk5FTCAmJiAhRUZJX1pCT09UCj4gLQlz ZWxlY3QgSEFWRV9LRVJORUxfTFo0IGlmICFYSVBfS0VSTkVMICYmICFFRklfWkJPT1QKPiAtCXNl bGVjdCBIQVZFX0tFUk5FTF9MWk1BIGlmICFYSVBfS0VSTkVMICYmICFFRklfWkJPT1QKPiAtCXNl bGVjdCBIQVZFX0tFUk5FTF9MWk8gaWYgIVhJUF9LRVJORUwgJiYgIUVGSV9aQk9PVAo+IC0Jc2Vs ZWN0IEhBVkVfS0VSTkVMX1VOQ09NUFJFU1NFRCBpZiAhWElQX0tFUk5FTCAmJiAhRUZJX1pCT09U Cj4gLQlzZWxlY3QgSEFWRV9LRVJORUxfWlNURCBpZiAhWElQX0tFUk5FTCAmJiAhRUZJX1pCT09U Cj4gLQlzZWxlY3QgSEFWRV9LRVJORUxfWFogaWYgIVhJUF9LRVJORUwgJiYgIUVGSV9aQk9PVAo+ IC0Jc2VsZWN0IEhBVkVfS1BST0JFUyBpZiAhWElQX0tFUk5FTAo+IC0Jc2VsZWN0IEhBVkVfS1JF VFBST0JFUyBpZiAhWElQX0tFUk5FTAo+ICsJc2VsZWN0IEhBVkVfS0VSTkVMX0JaSVAyIGlmICFF RklfWkJPT1QKPiArCXNlbGVjdCBIQVZFX0tFUk5FTF9HWklQIGlmICFFRklfWkJPT1QKPiArCXNl bGVjdCBIQVZFX0tFUk5FTF9MWjQgaWYgIUVGSV9aQk9PVAo+ICsJc2VsZWN0IEhBVkVfS0VSTkVM X0xaTUEgaWYgIUVGSV9aQk9PVAo+ICsJc2VsZWN0IEhBVkVfS0VSTkVMX0xaTyBpZiAhRUZJX1pC T09UCj4gKwlzZWxlY3QgSEFWRV9LRVJORUxfVU5DT01QUkVTU0VEIGlmICFFRklfWkJPT1QKPiAr CXNlbGVjdCBIQVZFX0tFUk5FTF9aU1REIGlmICFFRklfWkJPT1QKPiArCXNlbGVjdCBIQVZFX0tF Uk5FTF9YWiBpZiAhRUZJX1pCT09UCj4gKwlzZWxlY3QgSEFWRV9LUFJPQkVTCj4gKwlzZWxlY3Qg SEFWRV9LUkVUUFJPQkVTCj4gIAkjIGh0dHBzOi8vZ2l0aHViLmNvbS9DbGFuZ0J1aWx0TGludXgv bGludXgvaXNzdWVzLzE4ODEKPiAgCXNlbGVjdCBIQVZFX0xEX0RFQURfQ09ERV9EQVRBX0VMSU1J TkFUSU9OIGlmICFMRF9JU19MTEQKPiAgCXNlbGVjdCBIQVZFX01PVkVfUE1ECj4gQEAgLTE5MSw5 ICsxOTEsOSBAQCBjb25maWcgUklTQ1YKPiAgCXNlbGVjdCBIQVZFX1BFUkZfUkVHUwo+ICAJc2Vs ZWN0IEhBVkVfUEVSRl9VU0VSX1NUQUNLX0RVTVAKPiAgCXNlbGVjdCBIQVZFX1BPU0lYX0NQVV9U SU1FUlNfVEFTS19XT1JLCj4gLQlzZWxlY3QgSEFWRV9QUkVFTVBUX0RZTkFNSUNfS0VZIGlmICFY SVBfS0VSTkVMCj4gKwlzZWxlY3QgSEFWRV9QUkVFTVBUX0RZTkFNSUNfS0VZCj4gIAlzZWxlY3Qg SEFWRV9SRUdTX0FORF9TVEFDS19BQ0NFU1NfQVBJCj4gLQlzZWxlY3QgSEFWRV9SRVRIT09LIGlm ICFYSVBfS0VSTkVMCj4gKwlzZWxlY3QgSEFWRV9SRVRIT09LCj4gIAlzZWxlY3QgSEFWRV9SU0VR Cj4gIAlzZWxlY3QgSEFWRV9SVVNUIGlmIFJVU1RDX1NVUFBPUlRTX1JJU0NWICYmIENDX0lTX0NM QU5HCj4gIAlzZWxlY3QgSEFWRV9TQU1QTEVfRlRSQUNFX0RJUkVDVAo+IEBAIC0yMTQsNyArMjE0 LDcgQEAgY29uZmlnIFJJU0NWCj4gIAlzZWxlY3QgUENJX0VDQU0gaWYgKEFDUEkgJiYgUENJKQo+ ICAJc2VsZWN0IFBDSV9NU0kgaWYgUENJCj4gIAlzZWxlY3QgUkVMT0NBVEFCTEUgaWYgIU1NVSAm JiAhUEhZU19SQU1fQkFTRV9GSVhFRAo+IC0Jc2VsZWN0IFJJU0NWX0FMVEVSTkFUSVZFIGlmICFY SVBfS0VSTkVMCj4gKwlzZWxlY3QgUklTQ1ZfQUxURVJOQVRJVkUKPiAgCXNlbGVjdCBSSVNDVl9B UExJQwo+ICAJc2VsZWN0IFJJU0NWX0lNU0lDCj4gIAlzZWxlY3QgUklTQ1ZfSU5UQwo+IEBAIC01 NDEsNyArNTQxLDYgQEAgZW5kY2hvaWNlCj4gIAo+ICBjb25maWcgUklTQ1ZfQUxURVJOQVRJVkUK PiAgCWJvb2wKPiAtCWRlcGVuZHMgb24gIVhJUF9LRVJORUwKPiAgCWhlbHAKPiAgCSAgVGhpcyBL Y29uZmlnIGFsbG93cyB0aGUga2VybmVsIHRvIGF1dG9tYXRpY2FsbHkgcGF0Y2ggdGhlCj4gIAkg IGVycmF0dW0gb3IgY3B1ZmVhdHVyZSByZXF1aXJlZCBieSB0aGUgZXhlY3V0aW9uIHBsYXRmb3Jt IGF0IHJ1bgo+IEBAIC0xMTI5LDcgKzExMjgsNiBAQCBjb25maWcgUEFSQVZJUlRfVElNRV9BQ0NP VU5USU5HCj4gIAo+ICBjb25maWcgUkVMT0NBVEFCTEUKPiAgCWJvb2wgIkJ1aWxkIGEgcmVsb2Nh dGFibGUga2VybmVsIgo+IC0JZGVwZW5kcyBvbiAhWElQX0tFUk5FTAo+ICAJc2VsZWN0IE1PRFVM RV9TRUNUSU9OUyBpZiBNT0RVTEVTCj4gIAlzZWxlY3QgQVJDSF9WTUxJTlVYX05FRURTX1JFTE9D Uwo+ICAJaGVscAo+IEBAIC0xMTQ2LDcgKzExNDQsNyBAQCBjb25maWcgUkVMT0NBVEFCTEUKPiAg Y29uZmlnIFJBTkRPTUlaRV9CQVNFCj4gICAgICAgICAgYm9vbCAiUmFuZG9taXplIHRoZSBhZGRy ZXNzIG9mIHRoZSBrZXJuZWwgaW1hZ2UiCj4gICAgICAgICAgc2VsZWN0IFJFTE9DQVRBQkxFCj4g LSAgICAgICAgZGVwZW5kcyBvbiBNTVUgJiYgNjRCSVQgJiYgIVhJUF9LRVJORUwKPiArICAgICAg ICBkZXBlbmRzIG9uIE1NVSAmJiA2NEJJVAo+ICAgICAgICAgIGhlbHAKPiAgICAgICAgICAgIFJh bmRvbWl6ZXMgdGhlIHZpcnR1YWwgYWRkcmVzcyBhdCB3aGljaCB0aGUga2VybmVsIGltYWdlIGlz Cj4gICAgICAgICAgICBsb2FkZWQsIGFzIGEgc2VjdXJpdHkgZmVhdHVyZSB0aGF0IGRldGVycyBl eHBsb2l0IGF0dGVtcHRzCj4gQEAgLTEyMzYsNyArMTIzNCw3IEBAIGNvbmZpZyBFRklfU1RVQgo+ ICAKPiAgY29uZmlnIEVGSQo+ICAJYm9vbCAiVUVGSSBydW50aW1lIHN1cHBvcnQiCj4gLQlkZXBl bmRzIG9uIE9GICYmICFYSVBfS0VSTkVMCj4gKwlkZXBlbmRzIG9uIE9GCj4gIAlkZXBlbmRzIG9u IE1NVQo+ICAJZGVmYXVsdCB5Cj4gIAlzZWxlY3QgQVJDSF9TVVBQT1JUU19BQ1BJIGlmIDY0QklU Cj4gQEAgLTEyODcsNDQgKzEyODUsNiBAQCBjb25maWcgUEhZU19SQU1fQkFTRQo+ICAJICBleHBs aWNpdGx5IHNwZWNpZmllZCB0byBydW4gZWFybHkgcmVsb2NhdGlvbnMgb2YgcmVhZC13cml0ZSBk YXRhCj4gIAkgIGZyb20gZmxhc2ggdG8gUkFNLgo+ICAKPiAtY29uZmlnIFhJUF9LRVJORUwKPiAt CWJvb2wgIktlcm5lbCBFeGVjdXRlLUluLVBsYWNlIGZyb20gUk9NIgo+IC0JZGVwZW5kcyBvbiBN TVUgJiYgU1BBUlNFTUVNICYmIE5PTlBPUlRBQkxFCj4gLQkjIFRoaXMgcHJldmVudHMgWElQIGZy b20gYmVpbmcgZW5hYmxlZCBieSBhbGx7eWVzLG1vZH1jb25maWcsIHdoaWNoCj4gLQkjIGZhaWwg dG8gYnVpbGQgc2luY2UgWElQIGRvZXNuJ3Qgc3VwcG9ydCBsYXJnZSBrZXJuZWxzLgo+IC0JZGVw ZW5kcyBvbiAhQ09NUElMRV9URVNUCj4gLQlzZWxlY3QgUEhZU19SQU1fQkFTRV9GSVhFRAo+IC0J aGVscAo+IC0JICBFeGVjdXRlLUluLVBsYWNlIGFsbG93cyB0aGUga2VybmVsIHRvIHJ1biBmcm9t IG5vbi12b2xhdGlsZSBzdG9yYWdlCj4gLQkgIGRpcmVjdGx5IGFkZHJlc3NhYmxlIGJ5IHRoZSBD UFUsIHN1Y2ggYXMgTk9SIGZsYXNoLiBUaGlzIHNhdmVzIFJBTQo+IC0JICBzcGFjZSBzaW5jZSB0 aGUgdGV4dCBzZWN0aW9uIG9mIHRoZSBrZXJuZWwgaXMgbm90IGxvYWRlZCBmcm9tIGZsYXNoCj4g LQkgIHRvIFJBTS4gIFJlYWQtd3JpdGUgc2VjdGlvbnMsIHN1Y2ggYXMgdGhlIGRhdGEgc2VjdGlv biBhbmQgc3RhY2ssCj4gLQkgIGFyZSBzdGlsbCBjb3BpZWQgdG8gUkFNLiAgVGhlIFhJUCBrZXJu ZWwgaXMgbm90IGNvbXByZXNzZWQgc2luY2UKPiAtCSAgaXQgaGFzIHRvIHJ1biBkaXJlY3RseSBm cm9tIGZsYXNoLCBzbyBpdCB3aWxsIHRha2UgbW9yZSBzcGFjZSB0bwo+IC0JICBzdG9yZSBpdC4g IFRoZSBmbGFzaCBhZGRyZXNzIHVzZWQgdG8gbGluayB0aGUga2VybmVsIG9iamVjdCBmaWxlcywK PiAtCSAgYW5kIGZvciBzdG9yaW5nIGl0LCBpcyBjb25maWd1cmF0aW9uIGRlcGVuZGVudC4gVGhl cmVmb3JlLCBpZiB5b3UKPiAtCSAgc2F5IFkgaGVyZSwgeW91IG11c3Qga25vdyB0aGUgcHJvcGVy IHBoeXNpY2FsIGFkZHJlc3Mgd2hlcmUgdG8KPiAtCSAgc3RvcmUgdGhlIGtlcm5lbCBpbWFnZSBk ZXBlbmRpbmcgb24geW91ciBvd24gZmxhc2ggbWVtb3J5IHVzYWdlLgo+IC0KPiAtCSAgQWxzbyBu b3RlIHRoYXQgdGhlIG1ha2UgdGFyZ2V0IGJlY29tZXMgIm1ha2UgeGlwSW1hZ2UiIHJhdGhlciB0 aGFuCj4gLQkgICJtYWtlIHpJbWFnZSIgb3IgIm1ha2UgSW1hZ2UiLiAgVGhlIGZpbmFsIGtlcm5l bCBiaW5hcnkgdG8gcHV0IGluCj4gLQkgIFJPTSBtZW1vcnkgd2lsbCBiZSBhcmNoL3Jpc2N2L2Jv b3QveGlwSW1hZ2UuCj4gLQo+IC0JICBTUEFSU0VNRU0gaXMgcmVxdWlyZWQgYmVjYXVzZSB0aGUg a2VybmVsIHRleHQgYW5kIHJvZGF0YSB0aGF0IGFyZQo+IC0JICBmbGFzaCByZXNpZGVudCBhcmUg bm90IGJhY2tlZCBieSBtZW1tYXAsIHRoZW4gYW55IGF0dGVtcHQgdG8gZ2V0Cj4gLQkgIGEgc3Ry dWN0IHBhZ2Ugb24gdGhvc2UgcmVnaW9ucyB3aWxsIHRyaWdnZXIgYSBmYXVsdC4KPiAtCj4gLQkg IElmIHVuc3VyZSwgc2F5IE4uCj4gLQo+IC1jb25maWcgWElQX1BIWVNfQUREUgo+IC0JaGV4ICJY SVAgS2VybmVsIFBoeXNpY2FsIExvY2F0aW9uIgo+IC0JZGVwZW5kcyBvbiBYSVBfS0VSTkVMCj4g LQlkZWZhdWx0ICIweDIxMDAwMDAwIgo+IC0JaGVscAo+IC0JICBUaGlzIGlzIHRoZSBwaHlzaWNh bCBhZGRyZXNzIGluIHlvdXIgZmxhc2ggbWVtb3J5IHRoZSBrZXJuZWwgd2lsbAo+IC0JICBiZSBs aW5rZWQgZm9yIGFuZCBzdG9yZWQgdG8uICBUaGlzIGFkZHJlc3MgaXMgZGVwZW5kZW50IG9uIHlv dXIKPiAtCSAgb3duIGZsYXNoIHVzYWdlLgo+IC0KPiAgY29uZmlnIFJJU0NWX0lTQV9GQUxMQkFD Swo+ICAJYm9vbCAiUGVybWl0IGZhbGxpbmcgYmFjayB0byBwYXJzaW5nIHJpc2N2LGlzYSBmb3Ig ZXh0ZW5zaW9uIHN1cHBvcnQgYnkgZGVmYXVsdCIKPiAgCWRlZmF1bHQgeQo+IGRpZmYgLS1naXQg YS9hcmNoL3Jpc2N2L0tjb25maWcuc29jcyBiL2FyY2gvcmlzY3YvS2NvbmZpZy5zb2NzCj4gaW5k ZXggZDYyMWI4NWRkNjNiLi5jMTc0YWMwZWM0NmIgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9yaXNjdi9L Y29uZmlnLnNvY3MKPiArKysgYi9hcmNoL3Jpc2N2L0tjb25maWcuc29jcwo+IEBAIC0yLDcgKzIs NyBAQCBtZW51ICJTb0Mgc2VsZWN0aW9uIgo+ICAKPiAgY29uZmlnIEFSQ0hfQU5ERVMKPiAgCWJv b2wgIkFuZGVzIFNvQ3MiCj4gLQlkZXBlbmRzIG9uIE1NVSAmJiAhWElQX0tFUk5FTAo+ICsJZGVw ZW5kcyBvbiBNTVUKPiAgCXNlbGVjdCBFUlJBVEFfQU5ERVMKPiAgCWhlbHAKPiAgCSAgVGhpcyBl bmFibGVzIHN1cHBvcnQgZm9yIEFuZGVzIFNvQyBwbGF0Zm9ybSBoYXJkd2FyZS4KPiBAQCAtMzMs NyArMzMsNyBAQCBjb25maWcgQVJDSF9SRU5FU0FTCj4gIAo+ICBjb25maWcgQVJDSF9TSUZJVkUK PiAgCWJvb2wgIlNpRml2ZSBTb0NzIgo+IC0Jc2VsZWN0IEVSUkFUQV9TSUZJVkUgaWYgIVhJUF9L RVJORUwKPiArCXNlbGVjdCBFUlJBVEFfU0lGSVZFCj4gIAloZWxwCj4gIAkgIFRoaXMgZW5hYmxl cyBzdXBwb3J0IGZvciBTaUZpdmUgU29DIHBsYXRmb3JtIGhhcmR3YXJlLgo+ICAKPiBAQCAtNjEs NyArNjEsNyBAQCBjb25maWcgU09DX1NUQVJGSVZFCj4gIAo+ICBjb25maWcgQVJDSF9TVU5YSQo+ ICAJYm9vbCAiQWxsd2lubmVyIHN1bjIwaSBTb0NzIgo+IC0JZGVwZW5kcyBvbiBNTVUgJiYgIVhJ UF9LRVJORUwKPiArCWRlcGVuZHMgb24gTU1VCj4gIAlzZWxlY3QgRVJSQVRBX1RIRUFECj4gIAlz ZWxlY3QgU1VONElfVElNRVIKPiAgCWhlbHAKPiBAQCAtNzgsNyArNzgsNyBAQCBjb25maWcgQVJD SF9URU5TVE9SUkVOVAo+ICAKPiAgY29uZmlnIEFSQ0hfVEhFQUQKPiAgCWJvb2wgIlQtSEVBRCBS SVNDLVYgU29DcyIKPiAtCWRlcGVuZHMgb24gTU1VICYmICFYSVBfS0VSTkVMCj4gKwlkZXBlbmRz IG9uIE1NVQo+ICAJc2VsZWN0IEVSUkFUQV9USEVBRAo+ICAJc2VsZWN0IFBNX0dFTkVSSUNfRE9N QUlOUyBpZiBQTQo+ICAJaGVscAo+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L01ha2VmaWxlIGIv YXJjaC9yaXNjdi9NYWtlZmlsZQo+IGluZGV4IDM3MWRhNzVhNDdmOS4uMmNkYTg3YTVhYWYxIDEw MDY0NAo+IC0tLSBhL2FyY2gvcmlzY3YvTWFrZWZpbGUKPiArKysgYi9hcmNoL3Jpc2N2L01ha2Vm aWxlCj4gQEAgLTE1MCw3ICsxNTAsNiBAQCBpZmRlZiBDT05GSUdfUklTQ1ZfTV9NT0RFCj4gIGJv b3QtaW1hZ2UtJChDT05GSUdfU09DX0NBTkFBTl9LMjEwKQk6PSBsb2FkZXIuYmluCj4gIGVuZGlm Cj4gIGJvb3QtaW1hZ2UtJChDT05GSUdfRUZJX1pCT09UKQkJOj0gdm1saW51ei5lZmkKPiAtYm9v dC1pbWFnZS0kKENPTkZJR19YSVBfS0VSTkVMKQkJOj0geGlwSW1hZ2UKPiAgS0JVSUxEX0lNQUdF CQkJCTo9ICQoYm9vdCkvJChib290LWltYWdlLXkpCj4gIAo+ICBsaWJzLXkgKz0gYXJjaC9yaXNj di9saWIvCj4gQEAgLTIxOCw4ICsyMTcsNiBAQCBkZWZpbmUgYXJjaGhlbHAKPiAgICBlY2hvICAn ICBJbWFnZS54egktIENvbXByZXNzZWQga2VybmVsIGltYWdlIChhcmNoL3Jpc2N2L2Jvb3QvSW1h Z2UueHopJwo+ICAgIGVjaG8gICcgIHZtbGludXouZWZpCS0gQ29tcHJlc3NlZCBFRkkga2VybmVs IGltYWdlIChhcmNoL3Jpc2N2L2Jvb3Qvdm1saW51ei5lZmkpJwo+ICAgIGVjaG8gICcJCSAgRGVm YXVsdCB3aGVuIENPTkZJR19FRklfWkJPT1Q9eScKPiAtICBlY2hvICAnICB4aXBJbWFnZQktIEV4 ZWN1dGUtaW4tcGxhY2Uga2VybmVsIGltYWdlIChhcmNoL3Jpc2N2L2Jvb3QveGlwSW1hZ2UpJwo+ IC0gIGVjaG8gICcJCSAgRGVmYXVsdCB3aGVuIENPTkZJR19YSVBfS0VSTkVMPXknCj4gICAgZWNo byAgJyAgaW5zdGFsbAktIEluc3RhbGwga2VybmVsIHVzaW5nICh5b3VyKSB+L2Jpbi8kKElOU1RB TExLRVJORUwpIG9yJwo+ICAgIGVjaG8gICcJCSAgKGRpc3RyaWJ1dGlvbikgL3NiaW4vJChJTlNU QUxMS0VSTkVMKSBvciBpbnN0YWxsIHRvICcKPiAgICBlY2hvICAnCQkgICQkKElOU1RBTExfUEFU SCknCj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvYm9vdC9NYWtlZmlsZSBiL2FyY2gvcmlzY3Yv Ym9vdC9NYWtlZmlsZQo+IGluZGV4IDUzMDFhZGY1ZjNmNS4uZmNmYmUzZjgxNGQ2IDEwMDY0NAo+ IC0tLSBhL2FyY2gvcmlzY3YvYm9vdC9NYWtlZmlsZQo+ICsrKyBiL2FyY2gvcmlzY3YvYm9vdC9N YWtlZmlsZQo+IEBAIC0yMCwxNyArMjAsNiBAQCBPQkpDT1BZRkxBR1NfeGlwSW1hZ2UgOj0tTyBi aW5hcnkgLVIgLm5vdGUgLVIgLm5vdGUuZ251LmJ1aWxkLWlkIC1SIC5jb21tZW50IC1TCj4gIAo+ ICB0YXJnZXRzIDo9IEltYWdlIEltYWdlLiogbG9hZGVyIGxvYWRlci5vIGxvYWRlci5sZHMgbG9h ZGVyLmJpbiB4aXBJbWFnZQo+ICAKPiAtaWZlcSAoJChDT05GSUdfWElQX0tFUk5FTCkseSkKPiAt Cj4gLXF1aWV0X2NtZF9ta3hpcCA9ICQocXVpZXRfY21kX29iamNvcHkpCj4gLWNtZF9ta3hpcCA9 ICQoY21kX29iamNvcHkpCj4gLQo+IC0kKG9iaikveGlwSW1hZ2U6IHZtbGludXggRk9SQ0UKPiAt CSQoY2FsbCBpZl9jaGFuZ2VkLG1reGlwKQo+IC0JQCQoa2VjaG8pICcgIFBoeXNpY2FsIEFkZHJl c3Mgb2YgeGlwSW1hZ2U6ICQoQ09ORklHX1hJUF9QSFlTX0FERFIpJwo+IC0KPiAtZW5kaWYKPiAt Cj4gICQob2JqKS9JbWFnZTogdm1saW51eCBGT1JDRQo+ICAJJChjYWxsIGlmX2NoYW5nZWQsb2Jq Y29weSkKPiAgCj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vcGFnZS5oIGIv YXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9wYWdlLmgKPiBpbmRleCAzYzUxN2JjOWVhYzUuLjljY2Q4 MGQ1N2ZmZSAxMDA2NDQKPiAtLS0gYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3BhZ2UuaAo+ICsr KyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vcGFnZS5oCj4gQEAgLTI5LDExICsyOSw3IEBACj4g ICNkZWZpbmUgUEFHRV9PRkZTRVRfTDUJCV9BQygweGZmNjAwMDAwMDAwMDAwMDAsIFVMKQo+ICAj ZGVmaW5lIFBBR0VfT0ZGU0VUX0w0CQlfQUMoMHhmZmZmYWY4MDAwMDAwMDAwLCBVTCkKPiAgI2Rl ZmluZSBQQUdFX09GRlNFVF9MMwkJX0FDKDB4ZmZmZmZmZDYwMDAwMDAwMCwgVUwpCj4gLSNpZmRl ZiBDT05GSUdfWElQX0tFUk5FTAo+IC0jZGVmaW5lIFBBR0VfT0ZGU0VUCQlQQUdFX09GRlNFVF9M Mwo+IC0jZWxzZQo+ICAjZGVmaW5lIFBBR0VfT0ZGU0VUCQlrZXJuZWxfbWFwLnBhZ2Vfb2Zmc2V0 Cj4gLSNlbmRpZiAvKiBDT05GSUdfWElQX0tFUk5FTCAqLwo+ICAjZWxzZQo+ICAjZGVmaW5lIFBB R0VfT0ZGU0VUCQlfQUMoMHhjMDAwMDAwMCwgVUwpCj4gICNlbmRpZiAvKiBDT05GSUdfNjRCSVQg Ki8KPiBAQCAtMTA1LDE1ICsxMDEsOCBAQCBzdHJ1Y3Qga2VybmVsX21hcHBpbmcgewo+ICAJLyog T2Zmc2V0IGJldHdlZW4gbGluZWFyIG1hcHBpbmcgdmlydHVhbCBhZGRyZXNzIGFuZCBrZXJuZWwg bG9hZCBhZGRyZXNzICovCj4gIAl1bnNpZ25lZCBsb25nIHZhX3BhX29mZnNldDsKPiAgCS8qIE9m ZnNldCBiZXR3ZWVuIGtlcm5lbCBtYXBwaW5nIHZpcnR1YWwgYWRkcmVzcyBhbmQga2VybmVsIGxv YWQgYWRkcmVzcyAqLwo+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiAtCXVuc2lnbmVkIGxv bmcgdmFfa2VybmVsX3hpcF90ZXh0X3BhX29mZnNldDsKPiAtCXVuc2lnbmVkIGxvbmcgdmFfa2Vy bmVsX3hpcF9kYXRhX3BhX29mZnNldDsKPiAtCXVpbnRwdHJfdCB4aXByb207Cj4gLQl1aW50cHRy X3QgeGlwcm9tX3N6Owo+IC0jZWxzZQo+ICAJdW5zaWduZWQgbG9uZyBwYWdlX29mZnNldDsKPiAg CXVuc2lnbmVkIGxvbmcgdmFfa2VybmVsX3BhX29mZnNldDsKPiAtI2VuZGlmCj4gIH07Cj4gIAo+ ICBleHRlcm4gc3RydWN0IGtlcm5lbF9tYXBwaW5nIGtlcm5lbF9tYXA7Cj4gQEAgLTEzMiwxNiAr MTIxLDcgQEAgZXh0ZXJuIHVuc2lnbmVkIGxvbmcgdm1lbW1hcF9zdGFydF9wZm47Cj4gIHZvaWQg KmxpbmVhcl9tYXBwaW5nX3BhX3RvX3ZhKHVuc2lnbmVkIGxvbmcgeCk7Cj4gICNlbmRpZgo+ICAK PiAtI2lmZGVmIENPTkZJR19YSVBfS0VSTkVMCj4gLSNkZWZpbmUga2VybmVsX21hcHBpbmdfcGFf dG9fdmEoeSkJKHsJCQkJCVwKPiAtCXVuc2lnbmVkIGxvbmcgX3kgPSAodW5zaWduZWQgbG9uZyko eSk7CQkJCQlcCj4gLQkoX3kgPCBwaHlzX3JhbV9iYXNlKSA/CQkJCQkJCVwKPiAtCQkodm9pZCAq KShfeSArIGtlcm5lbF9tYXAudmFfa2VybmVsX3hpcF90ZXh0X3BhX29mZnNldCkgOglcCj4gLQkJ KHZvaWQgKikoX3kgKyBrZXJuZWxfbWFwLnZhX2tlcm5lbF94aXBfZGF0YV9wYV9vZmZzZXQpOwkJ XAo+IC0JfSkKPiAtI2Vsc2UKPiAgI2RlZmluZSBrZXJuZWxfbWFwcGluZ19wYV90b192YSh5KSAo KHZvaWQgKikoKHVuc2lnbmVkIGxvbmcpKHkpICsga2VybmVsX21hcC52YV9rZXJuZWxfcGFfb2Zm c2V0KSkKPiAtI2VuZGlmCj4gIAo+ICAjZGVmaW5lIF9fcGFfdG9fdmFfbm9kZWJ1Zyh4KQkJbGlu ZWFyX21hcHBpbmdfcGFfdG9fdmEoeCkKPiAgCj4gQEAgLTE1MSwxNiArMTMxLDcgQEAgdm9pZCAq bGluZWFyX21hcHBpbmdfcGFfdG9fdmEodW5zaWduZWQgbG9uZyB4KTsKPiAgcGh5c19hZGRyX3Qg bGluZWFyX21hcHBpbmdfdmFfdG9fcGEodW5zaWduZWQgbG9uZyB4KTsKPiAgI2VuZGlmCj4gIAo+ IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiAtI2RlZmluZSBrZXJuZWxfbWFwcGluZ192YV90 b19wYSh5KSAoewkJCQkJCVwKPiAtCXVuc2lnbmVkIGxvbmcgX3kgPSAodW5zaWduZWQgbG9uZyko eSk7CQkJCQlcCj4gLQkoX3kgPCBrZXJuZWxfbWFwLnZpcnRfYWRkciArIGtlcm5lbF9tYXAueGlw cm9tX3N6KSA/CQkJXAo+IC0JCShfeSAtIGtlcm5lbF9tYXAudmFfa2VybmVsX3hpcF90ZXh0X3Bh X29mZnNldCkgOgkJXAo+IC0JCShfeSAtIGtlcm5lbF9tYXAudmFfa2VybmVsX3hpcF9kYXRhX3Bh X29mZnNldCk7CQkJXAo+IC0JfSkKPiAtI2Vsc2UKPiAgI2RlZmluZSBrZXJuZWxfbWFwcGluZ192 YV90b19wYSh5KSAoKHVuc2lnbmVkIGxvbmcpKHkpIC0ga2VybmVsX21hcC52YV9rZXJuZWxfcGFf b2Zmc2V0KQo+IC0jZW5kaWYKPiAgCj4gICNkZWZpbmUgX192YV90b19wYV9ub2RlYnVnKHgpCSh7 CQkJCQkJXAo+ICAJdW5zaWduZWQgbG9uZyBfeCA9IHg7CQkJCQkJCVwKPiBkaWZmIC0tZ2l0IGEv YXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9wZ3RhYmxlLmggYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNt L3BndGFibGUuaAo+IGluZGV4IDEzNDBhYTM5OGE3NC4uYTE4YzBmNjJiNDUyIDEwMDY0NAo+IC0t LSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vcGd0YWJsZS5oCj4gKysrIGIvYXJjaC9yaXNjdi9p bmNsdWRlL2FzbS9wZ3RhYmxlLmgKPiBAQCAtMTM0LDIxICsxMzQsNiBAQAo+ICAKPiAgI2luY2x1 ZGUgPGxpbnV4L3BhZ2VfdGFibGVfY2hlY2suaD4KPiAgCj4gLSNpZmRlZiBDT05GSUdfWElQX0tF Uk5FTAo+IC0jZGVmaW5lIFhJUF9GSVhVUChhZGRyKSAoewkJCQkJCQlcCj4gLQlleHRlcm4gY2hh ciBfc2RhdGFbXSwgX3N0YXJ0W10sIF9lbmRbXTsJCQkJCVwKPiAtCXVpbnRwdHJfdCBfX3JvbV9z dGFydF9kYXRhID0gQ09ORklHX1hJUF9QSFlTX0FERFIJCQlcCj4gLQkJCQkrICh1aW50cHRyX3Qp Jl9zZGF0YSAtICh1aW50cHRyX3QpJl9zdGFydDsJXAo+IC0JdWludHB0cl90IF9fcm9tX2VuZF9k YXRhID0gQ09ORklHX1hJUF9QSFlTX0FERFIJCQkJXAo+IC0JCQkJKyAodWludHB0cl90KSZfZW5k IC0gKHVpbnRwdHJfdCkmX3N0YXJ0OwlcCj4gLQl1aW50cHRyX3QgX19hID0gKHVpbnRwdHJfdCko YWRkcik7CQkJCQlcCj4gLQkoX19hID49IF9fcm9tX3N0YXJ0X2RhdGEgJiYgX19hIDwgX19yb21f ZW5kX2RhdGEpID8JCQlcCj4gLQkJX19hIC0gX19yb21fc3RhcnRfZGF0YSArIENPTkZJR19QSFlT X1JBTV9CQVNFIDoJX19hOwkJXAo+IC0JfSkKPiAtI2Vsc2UKPiAtI2RlZmluZSBYSVBfRklYVVAo YWRkcikJCShhZGRyKQo+IC0jZW5kaWYgLyogQ09ORklHX1hJUF9LRVJORUwgKi8KPiAtCj4gIHN0 cnVjdCBwdF9hbGxvY19vcHMgewo+ICAJcHRlX3QgKigqZ2V0X3B0ZV92aXJ0KShwaHlzX2FkZHJf dCBwYSk7Cj4gIAlwaHlzX2FkZHJfdCAoKmFsbG9jX3B0ZSkodWludHB0cl90IHZhKTsKPiBAQCAt MTI3MiwxMyArMTI1Nyw4IEBAIHN0YXRpYyBpbmxpbmUgcHRlX3QgcHRlX3N3cF9jbGVhcl9leGNs dXNpdmUocHRlX3QgcHRlKQo+ICBleHRlcm4gY2hhciBfc3RhcnRbXTsKPiAgZXh0ZXJuIHZvaWQg Kl9kdGJfZWFybHlfdmE7Cj4gIGV4dGVybiB1aW50cHRyX3QgX2R0Yl9lYXJseV9wYTsKPiAtI2lm IGRlZmluZWQoQ09ORklHX1hJUF9LRVJORUwpICYmIGRlZmluZWQoQ09ORklHX01NVSkKPiAtI2Rl ZmluZSBkdGJfZWFybHlfdmEJKCoodm9pZCAqKilYSVBfRklYVVAoJl9kdGJfZWFybHlfdmEpKQo+ IC0jZGVmaW5lIGR0Yl9lYXJseV9wYQkoKih1aW50cHRyX3QgKilYSVBfRklYVVAoJl9kdGJfZWFy bHlfcGEpKQo+IC0jZWxzZQo+ICAjZGVmaW5lIGR0Yl9lYXJseV92YQlfZHRiX2Vhcmx5X3ZhCj4g ICNkZWZpbmUgZHRiX2Vhcmx5X3BhCV9kdGJfZWFybHlfcGEKPiAtI2VuZGlmIC8qIENPTkZJR19Y SVBfS0VSTkVMICovCj4gIGV4dGVybiB1NjQgc2F0cF9tb2RlOwo+ICAKPiAgdm9pZCBwYWdpbmdf aW5pdCh2b2lkKTsKPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zY3MuaCBi L2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc2NzLmgKPiBpbmRleCBhYjc3MTRhYTkzYmQuLjAyM2E0 MTJmZTM4ZCAxMDA2NDQKPiAtLS0gYS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3Njcy5oCj4gKysr IGIvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zY3MuaAo+IEBAIC0xMCw3ICsxMCw2IEBACj4gIC8q IExvYWQgaW5pdF9zaGFkb3dfY2FsbF9zdGFjayB0byBncC4gKi8KPiAgLm1hY3JvIHNjc19sb2Fk X2luaXRfc3RhY2sKPiAgCWxhCWdwLCBpbml0X3NoYWRvd19jYWxsX3N0YWNrCj4gLQlYSVBfRklY VVBfT0ZGU0VUIGdwCj4gIC5lbmRtCj4gIAo+ICAvKiBMb2FkIHRoZSBwZXItQ1BVIElSUSBzaGFk b3cgY2FsbCBzdGFjayB0byBncC4gKi8KPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRl L2FzbS9zZXRfbWVtb3J5LmggYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3NldF9tZW1vcnkuaAo+ IGluZGV4IDg3Mzg5ZTkzMzI1YS4uZWY1OWUxNzE2YTJjIDEwMDY0NAo+IC0tLSBhL2FyY2gvcmlz Y3YvaW5jbHVkZS9hc20vc2V0X21lbW9yeS5oCj4gKysrIGIvYXJjaC9yaXNjdi9pbmNsdWRlL2Fz bS9zZXRfbWVtb3J5LmgKPiBAQCAtNDcsNyArNDcsNyBAQCBib29sIGtlcm5lbF9wYWdlX3ByZXNl bnQoc3RydWN0IHBhZ2UgKnBhZ2UpOwo+ICAKPiAgI2VuZGlmIC8qIF9fQVNTRU1CTEVSX18gKi8K PiAgCj4gLSNpZiBkZWZpbmVkKENPTkZJR19TVFJJQ1RfS0VSTkVMX1JXWCkgfHwgZGVmaW5lZChD T05GSUdfWElQX0tFUk5FTCkKPiArI2lmIGRlZmluZWQoQ09ORklHX1NUUklDVF9LRVJORUxfUldY KQo+ICAjaWZkZWYgQ09ORklHXzY0QklUCj4gICNkZWZpbmUgU0VDVElPTl9BTElHTiAoMSA8PCAy MSkKPiAgI2Vsc2UKPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS94aXBfZml4 dXAuaCBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20veGlwX2ZpeHVwLmgKPiBkZWxldGVkIGZpbGUg bW9kZSAxMDA2NDQKPiBpbmRleCBmM2Q1NjI5OWJjMjIuLjAwMDAwMDAwMDAwMAo+IC0tLSBhL2Fy Y2gvcmlzY3YvaW5jbHVkZS9hc20veGlwX2ZpeHVwLmgKPiArKysgL2Rldi9udWxsCj4gQEAgLTEs NDkgKzAsMCBAQAo+IC0vKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5ICov Cj4gLS8qCj4gLSAqIFhJUCBmaXh1cCBtYWNyb3MsIG9ubHkgdXNlZnVsIGluIGFzc2VtYmx5Lgo+ IC0gKi8KPiAtI2lmbmRlZiBfQVNNX1JJU0NWX1hJUF9GSVhVUF9ICj4gLSNkZWZpbmUgX0FTTV9S SVNDVl9YSVBfRklYVVBfSAo+IC0KPiAtI2luY2x1ZGUgPGxpbnV4L3BndGFibGUuaD4KPiAtCj4g LSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+IC0ubWFjcm8gWElQX0ZJWFVQX09GRlNFVCByZWcK PiAtCS8qIEZpeC11cCBhZGRyZXNzIGluIEZsYXNoIGludG8gYWRkcmVzcyBpbiBSQU0gZWFybHkg ZHVyaW5nIGJvb3QgYmVmb3JlCj4gLQkgKiBNTVUgaXMgdXAuIEJlY2F1c2UgZ2VuZXJhdGVkIGNv ZGUgInRoaW5rcyIgZGF0YSBpcyBpbiBGbGFzaCwgYnV0IGl0Cj4gLQkgKiBpcyBhY3R1YWxseSBp biBSQU0gKGFjdHVhbGx5IGRhdGEgaXMgYWxzbyBpbiBGbGFzaCwgYnV0IEZsYXNoIGlzCj4gLQkg KiByZWFkLW9ubHksIHRodXMgd2UgbmVlZCB0byB1c2UgdGhlIGRhdGEgcmVzaWRpbmcgaW4gUkFN KS4KPiAtCSAqCj4gLQkgKiBUaGUgc3RhcnQgb2YgZGF0YSBpbiBGbGFzaCBpcyBfc2RhdGEgYW5k IHRoZSBzdGFydCBvZiBkYXRhIGluIFJBTSBpcwo+IC0JICogQ09ORklHX1BIWVNfUkFNX0JBU0Uu IFNvIHRoaXMgZml4LXVwIGVzc2VudGlhbGx5IGRvZXMgdGhpczoKPiAtCSAqIHJlZyArPSBDT05G SUdfUEhZU19SQU1fQkFTRSAtIF9zdGFydAo+IC0JICovCj4gLQlsaSB0MCwgQ09ORklHX1BIWVNf UkFNX0JBU0UKPiAtICAgICAgICBhZGQgXHJlZywgXHJlZywgdDAKPiAtCWxhIHQwLCBfc2RhdGEK PiAtCXN1YiBccmVnLCBccmVnLCB0MAo+IC0uZW5kbQo+IC0ubWFjcm8gWElQX0ZJWFVQX0ZMQVNI X09GRlNFVCByZWcKPiAtCS8qIEluIGxpbmtlciBzY3JpcHQsIGF0IHRoZSB0cmFuc2l0aW9uIGZy b20gcmVhZC1vbmx5IHNlY3Rpb24gdG8KPiAtCSAqIHdyaXRhYmxlIHNlY3Rpb24sIHRoZSBWTUEg aXMgaW5jcmVhc2VkIHdoaWxlIExNQSByZW1haW5zIHRoZSBzYW1lLgo+IC0JICogKFNlZSBpbiBs aW5rZXIgc2NyaXB0IGhvdyBfc2RhdGEsIF9fZGF0YV9sb2MgYW5kIExPQURfT0ZGU0VUIGlzCj4g LQkgKiBjaGFuZ2VkKQo+IC0JICoKPiAtCSAqIENvbnNlcXVlbnRseSwgZWFybHkgZHVyaW5nIGJv b3QgYmVmb3JlIE1NVSBpcyB1cCwgdGhlIGdlbmVyYXRlZCBjb2RlCj4gLQkgKiByZWFkcyB0aGUg IndyaXRhYmxlIiBzZWN0aW9uIGF0IHdyb25nIGFkZHJlc3NlcywgYmVjYXVzZSBWTUEgaXMgdXNl ZAo+IC0JICogYnkgY29tcGlsZXIgdG8gZ2VuZXJhdGUgY29kZSwgYnV0IHRoZSBkYXRhIGlzIGxv Y2F0ZWQgaW4gRmxhc2ggdXNpbmcKPiAtCSAqIExNQS4KPiAtCSAqLwo+IC0JbGEgdDAsIF9zZGF0 YQo+IC0Jc3ViIFxyZWcsIFxyZWcsIHQwCj4gLQlsYSB0MCwgX19kYXRhX2xvYwo+IC0JYWRkIFxy ZWcsIFxyZWcsIHQwCj4gLS5lbmRtCj4gLSNlbHNlCj4gLS5tYWNybyBYSVBfRklYVVBfT0ZGU0VU IHJlZwo+IC0uZW5kbQo+IC0ubWFjcm8gWElQX0ZJWFVQX0ZMQVNIX09GRlNFVCByZWcKPiAtLmVu ZG0KPiAtI2VuZGlmIC8qIENPTkZJR19YSVBfS0VSTkVMICovCj4gLQo+IC0jZW5kaWYKPiBkaWZm IC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5TIGIvYXJjaC9yaXNjdi9rZXJuZWwvaGVh ZC5TCj4gaW5kZXggOWM5OWM1YWQ2ZmU4Li42NTAzOTkwNDQzNjggMTAwNjQ0Cj4gLS0tIGEvYXJj aC9yaXNjdi9rZXJuZWwvaGVhZC5TCj4gKysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5TCj4g QEAgLTE0LDcgKzE0LDYgQEAKPiAgI2luY2x1ZGUgPGFzbS9od2NhcC5oPgo+ICAjaW5jbHVkZSA8 YXNtL2ltYWdlLmg+Cj4gICNpbmNsdWRlIDxhc20vc2NzLmg+Cj4gLSNpbmNsdWRlIDxhc20veGlw X2ZpeHVwLmg+Cj4gICNpbmNsdWRlIDxhc20vdXNlcmNmaS5oPgo+ICAjaW5jbHVkZSAiZWZpLWhl YWRlci5TIgo+ICAKPiBAQCAtNzUsNyArNzQsNiBAQCBwZV9oZWFkX3N0YXJ0Ogo+ICByZWxvY2F0 ZV9lbmFibGVfbW11Ogo+ICAJLyogUmVsb2NhdGUgcmV0dXJuIGFkZHJlc3MgKi8KPiAgCWxhIGEx LCBrZXJuZWxfbWFwCj4gLQlYSVBfRklYVVBfT0ZGU0VUIGExCj4gIAlSRUdfTCBhMSwgS0VSTkVM X01BUF9WSVJUX0FERFIoYTEpCj4gIAlsYSBhMiwgX3N0YXJ0Cj4gIAlzdWIgYTEsIGExLCBhMgo+ IEBAIC04OSw3ICs4Nyw2IEBAIHJlbG9jYXRlX2VuYWJsZV9tbXU6Cj4gIAkvKiBDb21wdXRlIHNh dHAgZm9yIGtlcm5lbCBwYWdlIHRhYmxlcywgYnV0IGRvbid0IGxvYWQgaXQgeWV0ICovCj4gIAlz cmwgYTIsIGEwLCBQQUdFX1NISUZUCj4gIAlsYSBhMSwgc2F0cF9tb2RlCj4gLQlYSVBfRklYVVBf T0ZGU0VUIGExCj4gIAlSRUdfTCBhMSwgMChhMSkKPiAgCW9yIGEyLCBhMiwgYTEKPiAgCj4gQEAg LTEwMCw3ICs5Nyw2IEBAIHJlbG9jYXRlX2VuYWJsZV9tbXU6Cj4gIAkgKiB0byBlbnN1cmUgdGhl IG5ldyB0cmFuc2xhdGlvbnMgYXJlIGluIHVzZS4KPiAgCSAqLwo+ICAJbGEgYTAsIHRyYW1wb2xp bmVfcGdfZGlyCj4gLQlYSVBfRklYVVBfT0ZGU0VUIGEwCj4gIAlzcmwgYTAsIGEwLCBQQUdFX1NI SUZUCj4gIAlvciBhMCwgYTAsIGExCj4gIAlzZmVuY2Uudm1hCj4gQEAgLTE1NCwxMSArMTUwLDkg QEAgc2Vjb25kYXJ5X3N0YXJ0X3NiaToKPiAgCj4gIAkvKiBhMCBjb250YWlucyB0aGUgaGFydGlk ICYgYTEgY29udGFpbnMgYm9vdCBkYXRhICovCj4gIAlsaSBhMiwgU0JJX0hBUlRfQk9PVF9UQVNL X1BUUl9PRkZTRVQKPiAtCVhJUF9GSVhVUF9PRkZTRVQgYTIKPiAgCWFkZCBhMiwgYTIsIGExCj4g IAlSRUdfTCB0cCwgKGEyKQo+ICAJbGkgYTMsIFNCSV9IQVJUX0JPT1RfU1RBQ0tfUFRSX09GRlNF VAo+IC0JWElQX0ZJWFVQX09GRlNFVCBhMwo+ICAJYWRkIGEzLCBhMywgYTEKPiAgCVJFR19MIHNw LCAoYTMpCj4gIAo+IEBAIC0xNjcsNyArMTYxLDYgQEAgc2Vjb25kYXJ5X3N0YXJ0X3NiaToKPiAg I2lmZGVmIENPTkZJR19NTVUKPiAgCS8qIEVuYWJsZSB2aXJ0dWFsIG1lbW9yeSBhbmQgcmVsb2Nh dGUgdG8gdmlydHVhbCBhZGRyZXNzICovCj4gIAlsYSBhMCwgc3dhcHBlcl9wZ19kaXIKPiAtCVhJ UF9GSVhVUF9PRkZTRVQgYTAKPiAgCWNhbGwgcmVsb2NhdGVfZW5hYmxlX21tdQo+ICAjZW5kaWYK PiAgCWNhbGwgLkxzZXR1cF90cmFwX3ZlY3Rvcgo+IEBAIC0yNjksNDAgKzI2MiwxMyBAQCBTWU1f Q09ERV9TVEFSVChfc3RhcnRfa2VybmVsKQo+ICAuTGdvb2RfY29yZXM6Cj4gIAo+ICAJLyogVGhl IGxvdHRlcnkgc3lzdGVtIGlzIG9ubHkgcmVxdWlyZWQgZm9yIHNwaW53YWl0IGJvb3RpbmcgbWV0 aG9kICovCj4gLSNpZm5kZWYgQ09ORklHX1hJUF9LRVJORUwKPiAgCS8qIFBpY2sgb25lIGhhcnQg dG8gcnVuIHRoZSBtYWluIGJvb3Qgc2VxdWVuY2UgKi8KPiAgCWxhIGEzLCBoYXJ0X2xvdHRlcnkK PiAgCWxpIGEyLCAxCj4gIAlhbW9hZGQudyBhMywgYTIsIChhMykKPiAgCWJuZXogYTMsIC5Mc2Vj b25kYXJ5X3N0YXJ0Cj4gLQo+IC0jZWxzZQo+IC0JLyogaGFydF9sb3R0ZXJ5IGluIGZsYXNoIGNv bnRhaW5zIGEgbWFnaWMgbnVtYmVyICovCj4gLQlsYSBhMywgaGFydF9sb3R0ZXJ5Cj4gLQltdiBh MiwgYTMKPiAtCVhJUF9GSVhVUF9PRkZTRVQgYTIKPiAtCVhJUF9GSVhVUF9GTEFTSF9PRkZTRVQg YTMKPiAtCWx3IHQxLCAoYTMpCj4gLQlhbW9zd2FwLncgdDAsIHQxLCAoYTIpCj4gLQkvKiBmaXJz dCB0aW1lIGhlcmUgaWYgaGFydF9sb3R0ZXJ5IGluIFJBTSBpcyBub3Qgc2V0ICovCj4gLQliZXEg dDAsIHQxLCAuTHNlY29uZGFyeV9zdGFydAo+IC0KPiAtI2VuZGlmIC8qIENPTkZJR19YSVAgKi8K PiAgI2VuZGlmIC8qIENPTkZJR19SSVNDVl9CT09UX1NQSU5XQUlUICovCj4gIAo+IC0jaWZkZWYg Q09ORklHX1hJUF9LRVJORUwKPiAtCWxhIHNwLCBfZW5kICsgVEhSRUFEX1NJWkUKPiAtCVhJUF9G SVhVUF9PRkZTRVQgc3AKPiAtCW12IHMwLCBhMAo+IC0JbXYgczEsIGExCj4gLQljYWxsIF9fY29w eV9kYXRhCj4gLQo+IC0JLyogUmVzdG9yZSBhMCAmIGExIGNvcHkgKi8KPiAtCW12IGEwLCBzMAo+ IC0JbXYgYTEsIHMxCj4gLSNlbmRpZgo+IC0KPiAtI2lmbmRlZiBDT05GSUdfWElQX0tFUk5FTAo+ ICAJLyogQ2xlYXIgQlNTIGZvciBmbGF0IG5vbi1FTEYgaW1hZ2VzICovCj4gIAlsYSBhMywgX19i c3Nfc3RhcnQKPiAgCWxhIGE0LCBfX2Jzc19zdG9wCj4gQEAgLTMxMiwyMCArMjc4LDE2IEBAIFNZ TV9DT0RFX1NUQVJUKF9zdGFydF9rZXJuZWwpCj4gIAlhZGQgYTMsIGEzLCBSSVNDVl9TWlBUUgo+ ICAJYmx0IGEzLCBhNCwgLkxjbGVhcl9ic3MKPiAgLkxjbGVhcl9ic3NfZG9uZToKPiAtI2VuZGlm Cj4gIAlsYSBhMiwgYm9vdF9jcHVfaGFydGlkCj4gLQlYSVBfRklYVVBfT0ZGU0VUIGEyCj4gIAlS RUdfUyBhMCwgKGEyKQo+ICAKPiAgCS8qIEluaXRpYWxpemUgcGFnZSB0YWJsZXMgYW5kIHJlbG9j YXRlIHRvIHZpcnR1YWwgYWRkcmVzc2VzICovCj4gIAlsYSB0cCwgaW5pdF90YXNrCj4gIAlsYSBz cCwgaW5pdF90aHJlYWRfdW5pb24gKyBUSFJFQURfU0laRQo+IC0JWElQX0ZJWFVQX09GRlNFVCBz cAo+ICAJYWRkaSBzcCwgc3AsIC1QVF9TSVpFX09OX1NUQUNLCj4gIAlzY3NfbG9hZF9pbml0X3N0 YWNrCj4gICNpZmRlZiBDT05GSUdfQlVJTFRJTl9EVEIKPiAgCWxhIGEwLCBfX2R0Yl9zdGFydAo+ IC0JWElQX0ZJWFVQX09GRlNFVCBhMAo+ICAjZWxzZQo+ICAJbXYgYTAsIGExCj4gICNlbmRpZiAv KiBDT05GSUdfQlVJTFRJTl9EVEIgKi8KPiBAQCAtMzM1LDcgKzI5Nyw2IEBAIFNZTV9DT0RFX1NU QVJUKF9zdGFydF9rZXJuZWwpCj4gIAljYWxsIHNldHVwX3ZtCj4gICNpZmRlZiBDT05GSUdfTU1V Cj4gIAlsYSBhMCwgZWFybHlfcGdfZGlyCj4gLQlYSVBfRklYVVBfT0ZGU0VUIGEwCj4gIAljYWxs IHJlbG9jYXRlX2VuYWJsZV9tbXUKPiAgI2VuZGlmIC8qIENPTkZJR19NTVUgKi8KPiAgCj4gQEAg LTM3NCw5ICszMzUsNyBAQCBTWU1fQ09ERV9TVEFSVChfc3RhcnRfa2VybmVsKQo+ICAKPiAgCXNs bGkgYTMsIGEwLCBMR1JFRwo+ICAJbGEgYTEsIF9fY3B1X3NwaW53YWl0X3N0YWNrX3BvaW50ZXIK PiAtCVhJUF9GSVhVUF9PRkZTRVQgYTEKPiAgCWxhIGEyLCBfX2NwdV9zcGlud2FpdF90YXNrX3Bv aW50ZXIKPiAtCVhJUF9GSVhVUF9PRkZTRVQgYTIKPiAgCWFkZCBhMSwgYTMsIGExCj4gIAlhZGQg YTIsIGEzLCBhMgo+ICAKPiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5oIGIv YXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5oCj4gaW5kZXggYTU1NmZkYWFmZWQ5Li4wNWEwNGJlZjQ0 MmIgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5oCj4gKysrIGIvYXJjaC9y aXNjdi9rZXJuZWwvaGVhZC5oCj4gQEAgLTExLDkgKzExLDYgQEAKPiAgZXh0ZXJuIGF0b21pY190 IGhhcnRfbG90dGVyeTsKPiAgCj4gIGFzbWxpbmthZ2Ugdm9pZCBfX2luaXQgc2V0dXBfdm0odWlu dHB0cl90IGR0Yl9wYSk7Cj4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+IC1hc21saW5rYWdl IHZvaWQgX19pbml0IF9fY29weV9kYXRhKHZvaWQpOwo+IC0jZW5kaWYKPiAgCj4gICNpZmRlZiBD T05GSUdfUklTQ1ZfQk9PVF9TUElOV0FJVAo+ICBleHRlcm4gdm9pZCAqX19jcHVfc3BpbndhaXRf c3RhY2tfcG9pbnRlcltdOwo+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9zZXR1cC5j IGIvYXJjaC9yaXNjdi9rZXJuZWwvc2V0dXAuYwo+IGluZGV4IGI1YmM1ZmM2NWNlYS4uYzg5Y2My NzI0NDBiIDEwMDY0NAo+IC0tLSBhL2FyY2gvcmlzY3Yva2VybmVsL3NldHVwLmMKPiArKysgYi9h cmNoL3Jpc2N2L2tlcm5lbC9zZXR1cC5jCj4gQEAgLTQ2LDExICs0Niw3IEBACj4gICAqIFRoaXMg aXMgdXNlZCBiZWZvcmUgdGhlIGtlcm5lbCBpbml0aWFsaXplcyB0aGUgQlNTIHNvIGl0IGNhbid0 IGJlIGluIHRoZQo+ICAgKiBCU1MuCj4gICAqLwo+IC1hdG9taWNfdCBoYXJ0X2xvdHRlcnkgX19z ZWN0aW9uKCIuc2RhdGEiKQo+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiAtPSBBVE9NSUNf SU5JVCgweEMwMDFCRUVGKQo+IC0jZW5kaWYKPiAtOwo+ICthdG9taWNfdCBoYXJ0X2xvdHRlcnkg X19zZWN0aW9uKCIuc2RhdGEiKTsKPiAgdW5zaWduZWQgbG9uZyBib290X2NwdV9oYXJ0aWQ7Cj4g IEVYUE9SVF9TWU1CT0xfR1BMKGJvb3RfY3B1X2hhcnRpZCk7Cj4gIAo+IGRpZmYgLS1naXQgYS9h cmNoL3Jpc2N2L2tlcm5lbC9zdXNwZW5kX2VudHJ5LlMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9zdXNw ZW5kX2VudHJ5LlMKPiBpbmRleCAyZDU0ZjMwOWMxNDAuLmQ3MWI1NWZkNjI1OSAxMDA2NDQKPiAt LS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9zdXNwZW5kX2VudHJ5LlMKPiArKysgYi9hcmNoL3Jpc2N2 L2tlcm5lbC9zdXNwZW5kX2VudHJ5LlMKPiBAQCAtMTAsNyArMTAsNiBAQAo+ICAjaW5jbHVkZSA8 YXNtL2FzbS1vZmZzZXRzLmg+Cj4gICNpbmNsdWRlIDxhc20vYXNzZW1ibGVyLmg+Cj4gICNpbmNs dWRlIDxhc20vY3NyLmg+Cj4gLSNpbmNsdWRlIDxhc20veGlwX2ZpeHVwLmg+Cj4gIAo+ICAJLnRl eHQKPiAgCS5hbHRtYWNybwo+IEBAIC03MCw3ICs2OSw2IEBAIFNZTV9UWVBFRF9GVU5DX1NUQVJU KF9fY3B1X3Jlc3VtZV9lbnRlcikKPiAgCj4gIAkvKiBFbmFibGUgTU1VICovCj4gIAlsYQlhMCwg c3dhcHBlcl9wZ19kaXIKPiAtCVhJUF9GSVhVUF9PRkZTRVQgYTAKPiAgCWNhbGwJcmVsb2NhdGVf ZW5hYmxlX21tdQo+ICAKPiAgCS8qIFJlc3RvcmUgQTAgYW5kIEExICovCj4gZGlmZiAtLWdpdCBh L2FyY2gvcmlzY3Yva2VybmVsL3RyYXBzLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC90cmFwcy5jCj4g aW5kZXggNWZiNTdmYWQxODhhLi5iZGVjNTRkMTJiMmEgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9yaXNj di9rZXJuZWwvdHJhcHMuYwo+ICsrKyBiL2FyY2gvcmlzY3Yva2VybmVsL3RyYXBzLmMKPiBAQCAt MTQyLDExICsxNDIsNyBAQCBzdGF0aWMgdm9pZCBkb190cmFwX2Vycm9yKHN0cnVjdCBwdF9yZWdz ICpyZWdzLCBpbnQgc2lnbm8sIGludCBjb2RlLAo+ICAJfQo+ICB9Cj4gIAo+IC0jaWYgZGVmaW5l ZChDT05GSUdfWElQX0tFUk5FTCkgJiYgZGVmaW5lZChDT05GSUdfUklTQ1ZfQUxURVJOQVRJVkUp Cj4gLSNkZWZpbmUgX190cmFwX3NlY3Rpb24gX19ub2luc3RyX3NlY3Rpb24oIi54aXAudHJhcHMi KQo+IC0jZWxzZQo+ICAjZGVmaW5lIF9fdHJhcF9zZWN0aW9uIG5vaW5zdHIKPiAtI2VuZGlmCj4g ICNkZWZpbmUgRE9fRVJST1JfSU5GTyhuYW1lLCBzaWdubywgY29kZSwgc3RyKQkJCQkJXAo+ICBh c21saW5rYWdlIF9fdmlzaWJsZSBfX3RyYXBfc2VjdGlvbiB2b2lkIG5hbWUoc3RydWN0IHB0X3Jl Z3MgKnJlZ3MpCQlcCj4gIHsJCQkJCQkJCQkJXAo+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tl cm5lbC92bWNvcmVfaW5mby5jIGIvYXJjaC9yaXNjdi9rZXJuZWwvdm1jb3JlX2luZm8uYwo+IGlu ZGV4IGQ1ZTQ0OGFhOTBlNy4uNmQ3YTIyNTIyZDYzIDEwMDY0NAo+IC0tLSBhL2FyY2gvcmlzY3Yv a2VybmVsL3ZtY29yZV9pbmZvLmMKPiArKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC92bWNvcmVfaW5m by5jCj4gQEAgLTE5LDEzICsxOSw2IEBAIHZvaWQgYXJjaF9jcmFzaF9zYXZlX3ZtY29yZWluZm8o dm9pZCkKPiAgI2VuZGlmCj4gICNlbmRpZgo+ICAJdm1jb3JlaW5mb19hcHBlbmRfc3RyKCJOVU1C RVIoS0VSTkVMX0xJTktfQUREUik9MHglbHhcbiIsIEtFUk5FTF9MSU5LX0FERFIpOwo+IC0jaWZk ZWYgQ09ORklHX1hJUF9LRVJORUwKPiAtCS8qIFRPRE86IENvbW11bmljYXRlIHdpdGggY3Jhc2gt dXRpbGl0eSBkZXZlbG9wZXJzIG9uIHRoZSBpbmZvcm1hdGlvbiB0bwo+IC0JICogZXhwb3J0LiBU aGUgWElQIGNhc2UgaXMgbW9yZSBjb21wbGljYXRlZCwgYmVjYXVzZSB0aGUgdmlydHVhbC1waHlz aWNhbAo+IC0JICogYWRkcmVzcyBvZmZzZXQgZGVwZW5kcyBvbiB3aGV0aGVyIHRoZSBhZGRyZXNz IGlzIGluIFJPTSBvciBpbiBSQU0uCj4gLQkgKi8KPiAtI2Vsc2UKPiAgCXZtY29yZWluZm9fYXBw ZW5kX3N0cigiTlVNQkVSKHZhX2tlcm5lbF9wYV9vZmZzZXQpPTB4JWx4XG4iLAo+ICAJCQkJCQlr ZXJuZWxfbWFwLnZhX2tlcm5lbF9wYV9vZmZzZXQpOwo+IC0jZW5kaWYKPiAgfQo+IGRpZmYgLS1n aXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC92bWxpbnV4Lmxkcy5TIGIvYXJjaC9yaXNjdi9rZXJuZWwv dm1saW51eC5sZHMuUwo+IGluZGV4IDYxYmQ1YmE2NjgwYS4uM2I1ZmZjZjMyMTZkIDEwMDY0NAo+ IC0tLSBhL2FyY2gvcmlzY3Yva2VybmVsL3ZtbGludXgubGRzLlMKPiArKysgYi9hcmNoL3Jpc2N2 L2tlcm5lbC92bWxpbnV4Lmxkcy5TCj4gQEAgLTcsMTAgKzcsNiBAQAo+ICAjZGVmaW5lIFJPX0VY Q0VQVElPTl9UQUJMRV9BTElHTgk0Cj4gICNkZWZpbmUgUlVOVElNRV9ESVNDQVJEX0VYSVQKPiAg Cj4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+IC0jaW5jbHVkZSAidm1saW51eC14aXAubGRz LlMiCj4gLSNlbHNlCj4gLQo+ICAjaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KPiAgI2RlZmluZSBM T0FEX09GRlNFVCBLRVJORUxfTElOS19BRERSCj4gIAo+IEBAIC0xNzUsNCArMTcxLDMgQEAgU0VD VElPTlMKPiAgCj4gIAlESVNDQVJEUwo+ICB9Cj4gLSNlbmRpZiAvKiBDT05GSUdfWElQX0tFUk5F TCAqLwo+IGRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L21tL2luaXQuYyBiL2FyY2gvcmlzY3YvbW0v aW5pdC5jCj4gaW5kZXggMjVhOGY2OTNhNzY1Li5jN2VjNmMwMjM1ZTEgMTAwNjQ0Cj4gLS0tIGEv YXJjaC9yaXNjdi9tbS9pbml0LmMKPiArKysgYi9hcmNoL3Jpc2N2L21tL2luaXQuYwo+IEBAIC00 MSwyMCArNDEsMTcgQEAgdTY0IG5ld192bWFsbG9jW05SX0NQVVMgLyBzaXplb2YodTY0KSArIDFd Owo+ICAKPiAgc3RydWN0IGtlcm5lbF9tYXBwaW5nIGtlcm5lbF9tYXAgX19yb19hZnRlcl9pbml0 Owo+ICBFWFBPUlRfU1lNQk9MKGtlcm5lbF9tYXApOwo+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJO RUwKPiAtI2RlZmluZSBrZXJuZWxfbWFwCSgqKHN0cnVjdCBrZXJuZWxfbWFwcGluZyAqKVhJUF9G SVhVUCgma2VybmVsX21hcCkpCj4gLSNlbmRpZgo+ICAKPiAgI2lmZGVmIENPTkZJR182NEJJVAo+ IC11NjQgc2F0cF9tb2RlIF9fcm9fYWZ0ZXJfaW5pdCA9ICFJU19FTkFCTEVEKENPTkZJR19YSVBf S0VSTkVMKSA/IFNBVFBfTU9ERV81NyA6IFNBVFBfTU9ERV8zOTsKPiArdTY0IHNhdHBfbW9kZSBf X3JvX2FmdGVyX2luaXQgPSBTQVRQX01PREVfNTc7Cj4gICNlbHNlCj4gIHU2NCBzYXRwX21vZGUg X19yb19hZnRlcl9pbml0ID0gU0FUUF9NT0RFXzMyOwo+ICAjZW5kaWYKPiAgRVhQT1JUX1NZTUJP TChzYXRwX21vZGUpOwo+ICAKPiAgI2lmZGVmIENPTkZJR182NEJJVAo+IC1ib29sIHBndGFibGVf bDRfZW5hYmxlZCBfX3JvX2FmdGVyX2luaXQgPSAhSVNfRU5BQkxFRChDT05GSUdfWElQX0tFUk5F TCk7Cj4gLWJvb2wgcGd0YWJsZV9sNV9lbmFibGVkIF9fcm9fYWZ0ZXJfaW5pdCA9ICFJU19FTkFC TEVEKENPTkZJR19YSVBfS0VSTkVMKTsKPiArYm9vbCBwZ3RhYmxlX2w0X2VuYWJsZWQgX19yb19h ZnRlcl9pbml0ID0gdHJ1ZTsKPiArYm9vbCBwZ3RhYmxlX2w1X2VuYWJsZWQgX19yb19hZnRlcl9p bml0ID0gdHJ1ZTsKPiAgRVhQT1JUX1NZTUJPTChwZ3RhYmxlX2w0X2VuYWJsZWQpOwo+ICBFWFBP UlRfU1lNQk9MKHBndGFibGVfbDVfZW5hYmxlZCk7Cj4gICNlbmRpZgo+IEBAIC0xOTcsOSArMTk0 LDYgQEAgdm9pZCBfX2luaXQgYXJjaF9tbV9wcmVpbml0KHZvaWQpCj4gIAo+ICAvKiBMaW1pdCB0 aGUgbWVtb3J5IHNpemUgdmlhIG1lbS4gKi8KPiAgc3RhdGljIHBoeXNfYWRkcl90IG1lbW9yeV9s aW1pdDsKPiAtI2lmZGVmIENPTkZJR19YSVBfS0VSTkVMCj4gLSNkZWZpbmUgbWVtb3J5X2xpbWl0 CSgqKHBoeXNfYWRkcl90ICopWElQX0ZJWFVQKCZtZW1vcnlfbGltaXQpKQo+IC0jZW5kaWYgLyog Q09ORklHX1hJUF9LRVJORUwgKi8KPiAgCj4gIHN0YXRpYyBpbnQgX19pbml0IGVhcmx5X21lbShj aGFyICpwKQo+ICB7Cj4gQEAgLTIyMywxMCArMjE3LDcgQEAgc3RhdGljIHZvaWQgX19pbml0IHNl dHVwX2Jvb3RtZW0odm9pZCkKPiAgCXBoeXNfYWRkcl90IG1heF9tYXBwZWRfYWRkcjsKPiAgCXBo eXNfYWRkcl90IHBoeXNfcmFtX2VuZCwgdm1saW51eF9zdGFydDsKPiAgCj4gLQlpZiAoSVNfRU5B QkxFRChDT05GSUdfWElQX0tFUk5FTCkpCj4gLQkJdm1saW51eF9zdGFydCA9IF9fcGFfc3ltYm9s KCZfc2RhdGEpOwo+IC0JZWxzZQo+IC0JCXZtbGludXhfc3RhcnQgPSBfX3BhX3N5bWJvbCgmX3N0 YXJ0KTsKPiArCXZtbGludXhfc3RhcnQgPSBfX3BhX3N5bWJvbCgmX3N0YXJ0KTsKPiAgCj4gIAlt ZW1ibG9ja19lbmZvcmNlX21lbW9yeV9saW1pdChtZW1vcnlfbGltaXQpOwo+ICAKPiBAQCAtMjQ2 LDEyICsyMzcsMTAgQEAgc3RhdGljIHZvaWQgX19pbml0IHNldHVwX2Jvb3RtZW0odm9pZCkKPiAg CSAqIE1ha2Ugc3VyZSB3ZSBhbGlnbiB0aGUgc3RhcnQgb2YgdGhlIG1lbW9yeSBvbiBhIFBNRCBi b3VuZGFyeSBzbyB0aGF0Cj4gIAkgKiBhdCB3b3JzdCwgd2UgbWFwIHRoZSBsaW5lYXIgbWFwcGlu ZyB3aXRoIFBNRCBtYXBwaW5ncy4KPiAgCSAqLwo+IC0JaWYgKCFJU19FTkFCTEVEKENPTkZJR19Y SVBfS0VSTkVMKSkgewo+IC0JCXBoeXNfcmFtX2Jhc2UgPSBtZW1ibG9ja19zdGFydF9vZl9EUkFN KCkgJiBQTURfTUFTSzsKPiArCXBoeXNfcmFtX2Jhc2UgPSBtZW1ibG9ja19zdGFydF9vZl9EUkFN KCkgJiBQTURfTUFTSzsKPiAgI2lmZGVmIENPTkZJR19TUEFSU0VNRU1fVk1FTU1BUAo+IC0JCXZt ZW1tYXBfc3RhcnRfcGZuID0gcm91bmRfZG93bihwaHlzX3JhbV9iYXNlLCBWTUVNTUFQX0FERFJf QUxJR04pID4+IFBBR0VfU0hJRlQ7Cj4gKwl2bWVtbWFwX3N0YXJ0X3BmbiA9IHJvdW5kX2Rvd24o cGh5c19yYW1fYmFzZSwgVk1FTU1BUF9BRERSX0FMSUdOKSA+PiBQQUdFX1NISUZUOwo+ICAjZW5k aWYKPiAtCX0KPiAgCj4gIAkvKgo+ICAJICogSW4gNjQtYml0LCBhbnkgdXNlIG9mIF9fdmEvX19w YSBiZWZvcmUgdGhpcyBwb2ludCBpcyB3cm9uZyBhcyB3ZQo+IEBAIC0zNjYsMTMgKzM1NSw2IEBA IHN0YXRpYyBwdGVfdCBmaXhtYXBfcHRlW1BUUlNfUEVSX1BURV0gX19wYWdlX2FsaWduZWRfYnNz Owo+ICAKPiAgcGdkX3QgZWFybHlfcGdfZGlyW1BUUlNfUEVSX1BHRF0gX19pbml0ZGF0YSBfX2Fs aWduZWQoUEFHRV9TSVpFKTsKPiAgCj4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+IC0jZGVm aW5lIHB0X29wcwkJCSgqKHN0cnVjdCBwdF9hbGxvY19vcHMgKilYSVBfRklYVVAoJnB0X29wcykp Cj4gLSNkZWZpbmUgdHJhbXBvbGluZV9wZ19kaXIgICAgICAoKHBnZF90ICopWElQX0ZJWFVQKHRy YW1wb2xpbmVfcGdfZGlyKSkKPiAtI2RlZmluZSBmaXhtYXBfcHRlICAgICAgICAgICAgICgocHRl X3QgKilYSVBfRklYVVAoZml4bWFwX3B0ZSkpCj4gLSNkZWZpbmUgZWFybHlfcGdfZGlyICAgICAg ICAgICAoKHBnZF90ICopWElQX0ZJWFVQKGVhcmx5X3BnX2RpcikpCj4gLSNlbmRpZiAvKiBDT05G SUdfWElQX0tFUk5FTCAqLwo+IC0KPiAgc3RhdGljIGNvbnN0IHBncHJvdF90IHByb3RlY3Rpb25f bWFwWzE2XSA9IHsKPiAgCVtWTV9OT05FXQkJCQkJPSBQQUdFX05PTkUsCj4gIAlbVk1fUkVBRF0J CQkJCT0gUEFHRV9SRUFELAo+IEBAIC00NjksMzIgKzQ1MSwxNCBAQCBzdGF0aWMgcG1kX3QgdHJh bXBvbGluZV9wbWRbUFRSU19QRVJfUE1EXSBfX3BhZ2VfYWxpZ25lZF9ic3M7Cj4gIHN0YXRpYyBw bWRfdCBmaXhtYXBfcG1kW1BUUlNfUEVSX1BNRF0gX19wYWdlX2FsaWduZWRfYnNzOwo+ICBzdGF0 aWMgcG1kX3QgZWFybHlfcG1kW1BUUlNfUEVSX1BNRF0gX19pbml0ZGF0YSBfX2FsaWduZWQoUEFH RV9TSVpFKTsKPiAgCj4gLSNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAo+IC0jZGVmaW5lIHRyYW1w b2xpbmVfcG1kICgocG1kX3QgKilYSVBfRklYVVAodHJhbXBvbGluZV9wbWQpKQo+IC0jZGVmaW5l IGZpeG1hcF9wbWQgICAgICgocG1kX3QgKilYSVBfRklYVVAoZml4bWFwX3BtZCkpCj4gLSNkZWZp bmUgZWFybHlfcG1kICAgICAgKChwbWRfdCAqKVhJUF9GSVhVUChlYXJseV9wbWQpKQo+IC0jZW5k aWYgLyogQ09ORklHX1hJUF9LRVJORUwgKi8KPiAtCj4gIHN0YXRpYyBwNGRfdCB0cmFtcG9saW5l X3A0ZFtQVFJTX1BFUl9QNERdIF9fcGFnZV9hbGlnbmVkX2JzczsKPiAgc3RhdGljIHA0ZF90IGZp eG1hcF9wNGRbUFRSU19QRVJfUDREXSBfX3BhZ2VfYWxpZ25lZF9ic3M7Cj4gIHN0YXRpYyBwNGRf dCBlYXJseV9wNGRbUFRSU19QRVJfUDREXSBfX2luaXRkYXRhIF9fYWxpZ25lZChQQUdFX1NJWkUp Owo+ICAKPiAtI2lmZGVmIENPTkZJR19YSVBfS0VSTkVMCj4gLSNkZWZpbmUgdHJhbXBvbGluZV9w NGQgKChwNGRfdCAqKVhJUF9GSVhVUCh0cmFtcG9saW5lX3A0ZCkpCj4gLSNkZWZpbmUgZml4bWFw X3A0ZCAgICAgKChwNGRfdCAqKVhJUF9GSVhVUChmaXhtYXBfcDRkKSkKPiAtI2RlZmluZSBlYXJs eV9wNGQgICAgICAoKHA0ZF90ICopWElQX0ZJWFVQKGVhcmx5X3A0ZCkpCj4gLSNlbmRpZiAvKiBD T05GSUdfWElQX0tFUk5FTCAqLwo+IC0KPiAgc3RhdGljIHB1ZF90IHRyYW1wb2xpbmVfcHVkW1BU UlNfUEVSX1BVRF0gX19wYWdlX2FsaWduZWRfYnNzOwo+ICBzdGF0aWMgcHVkX3QgZml4bWFwX3B1 ZFtQVFJTX1BFUl9QVURdIF9fcGFnZV9hbGlnbmVkX2JzczsKPiAgc3RhdGljIHB1ZF90IGVhcmx5 X3B1ZFtQVFJTX1BFUl9QVURdIF9faW5pdGRhdGEgX19hbGlnbmVkKFBBR0VfU0laRSk7Cj4gIAo+ IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiAtI2RlZmluZSB0cmFtcG9saW5lX3B1ZCAoKHB1 ZF90ICopWElQX0ZJWFVQKHRyYW1wb2xpbmVfcHVkKSkKPiAtI2RlZmluZSBmaXhtYXBfcHVkICAg ICAoKHB1ZF90ICopWElQX0ZJWFVQKGZpeG1hcF9wdWQpKQo+IC0jZGVmaW5lIGVhcmx5X3B1ZCAg ICAgICgocHVkX3QgKilYSVBfRklYVVAoZWFybHlfcHVkKSkKPiAtI2VuZGlmIC8qIENPTkZJR19Y SVBfS0VSTkVMICovCj4gLQo+ICBzdGF0aWMgcG1kX3QgKl9faW5pdCBnZXRfcG1kX3ZpcnRfZWFy bHkocGh5c19hZGRyX3QgcGEpCj4gIHsKPiAgCS8qIEJlZm9yZSBNTVUgaXMgZW5hYmxlZCAqLwo+ IEBAIC03NjUsMjEgKzcyOSw2IEBAIHN0YXRpYyB1aW50cHRyX3QgX19tZW1pbml0IGJlc3RfbWFw X3NpemUocGh5c19hZGRyX3QgcGEsIHVpbnRwdHJfdCB2YSwgcGh5c19hZGRyCj4gIAlyZXR1cm4g UEFHRV9TSVpFOwo+ICB9Cj4gIAo+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJORUwKPiAtI2RlZmlu ZSBwaHlzX3JhbV9iYXNlICAoKihwaHlzX2FkZHJfdCAqKVhJUF9GSVhVUCgmcGh5c19yYW1fYmFz ZSkpCj4gLWV4dGVybiBjaGFyIF94aXByb21bXSwgX2V4aXByb21bXSwgX19kYXRhX2xvYzsKPiAt Cj4gLS8qIGNhbGxlZCBmcm9tIGhlYWQuUyB3aXRoIE1NVSBvZmYgKi8KPiAtYXNtbGlua2FnZSB2 b2lkIF9faW5pdCBfX2NvcHlfZGF0YSh2b2lkKQo+IC17Cj4gLQl2b2lkICpmcm9tID0gKHZvaWQg KikoJl9fZGF0YV9sb2MpOwo+IC0Jdm9pZCAqdG8gPSAodm9pZCAqKUNPTkZJR19QSFlTX1JBTV9C QVNFOwo+IC0Jc2l6ZV90IHN6ID0gKHNpemVfdCkoKHVpbnRwdHJfdCkoJl9lbmQpIC0gKHVpbnRw dHJfdCkoJl9zZGF0YSkpOwo+IC0KPiAtCW1lbWNweSh0bywgZnJvbSwgc3opOwo+IC19Cj4gLSNl bmRpZgo+IC0KPiAgI2lmZGVmIENPTkZJR19TVFJJQ1RfS0VSTkVMX1JXWAo+ICBzdGF0aWMgX19t ZW1pbml0IHBncHJvdF90IHBncHJvdF9mcm9tX3ZhKHVpbnRwdHJfdCB2YSkKPiAgewo+IEBAIC04 MTUsNyArNzY0LDcgQEAgc3RhdGljIF9fbWVtaW5pdCBwZ3Byb3RfdCBwZ3Byb3RfZnJvbV92YSh1 aW50cHRyX3QgdmEpCj4gIH0KPiAgI2VuZGlmIC8qIENPTkZJR19TVFJJQ1RfS0VSTkVMX1JXWCAq Lwo+ICAKPiAtI2lmIGRlZmluZWQoQ09ORklHXzY0QklUKSAmJiAhZGVmaW5lZChDT05GSUdfWElQ X0tFUk5FTCkKPiArI2lmIGRlZmluZWQoQ09ORklHXzY0QklUKQo+ICB1NjQgX19waV9zZXRfc2F0 cF9tb2RlX2Zyb21fY21kbGluZSh1aW50cHRyX3QgZHRiX3BhKTsKPiAgdTY0IF9fcGlfc2V0X3Nh dHBfbW9kZV9mcm9tX2ZkdCh1aW50cHRyX3QgZHRiX3BhKTsKPiAgCj4gQEAgLTk0MCwyOCArODg5 LDYgQEAgc3RhdGljIF9faW5pdCB2b2lkIHNldF9zYXRwX21vZGUodWludHB0cl90IGR0Yl9wYSkK PiAgI2Vycm9yICJzZXR1cF92bSgpIGlzIGNhbGxlZCBmcm9tIGhlYWQuUyBiZWZvcmUgcmVsb2Nh dGUgc28gaXQgc2hvdWxkIG5vdCB1c2UgYWJzb2x1dGUgYWRkcmVzc2luZy4iCj4gICNlbmRpZgo+ ICAKPiAtI2lmZGVmIENPTkZJR19YSVBfS0VSTkVMCj4gLXN0YXRpYyB2b2lkIF9faW5pdCBjcmVh dGVfa2VybmVsX3BhZ2VfdGFibGUocGdkX3QgKnBnZGlyLAo+IC0JCQkJCSAgICBfX2Fsd2F5c191 bnVzZWQgYm9vbCBlYXJseSkKPiAtewo+IC0JdWludHB0cl90IHZhLCBzdGFydF92YSwgZW5kX3Zh Owo+IC0KPiAtCS8qIE1hcCB0aGUgZmxhc2ggcmVzaWRlbnQgcGFydCAqLwo+IC0JZW5kX3ZhID0g a2VybmVsX21hcC52aXJ0X2FkZHIgKyBrZXJuZWxfbWFwLnhpcHJvbV9zejsKPiAtCWZvciAodmEg PSBrZXJuZWxfbWFwLnZpcnRfYWRkcjsgdmEgPCBlbmRfdmE7IHZhICs9IFBNRF9TSVpFKQo+IC0J CWNyZWF0ZV9wZ2RfbWFwcGluZyhwZ2RpciwgdmEsCj4gLQkJCQkgICBrZXJuZWxfbWFwLnhpcHJv bSArICh2YSAtIGtlcm5lbF9tYXAudmlydF9hZGRyKSwKPiAtCQkJCSAgIFBNRF9TSVpFLCBQQUdF X0tFUk5FTF9FWEVDKTsKPiAtCj4gLQkvKiBNYXAgdGhlIGRhdGEgaW4gUkFNICovCj4gLQlzdGFy dF92YSA9IGtlcm5lbF9tYXAudmlydF9hZGRyICsgKHVpbnRwdHJfdCkmX3NkYXRhIC0gKHVpbnRw dHJfdCkmX3N0YXJ0Owo+IC0JZW5kX3ZhID0ga2VybmVsX21hcC52aXJ0X2FkZHIgKyBrZXJuZWxf bWFwLnNpemU7Cj4gLQlmb3IgKHZhID0gc3RhcnRfdmE7IHZhIDwgZW5kX3ZhOyB2YSArPSBQTURf U0laRSkKPiAtCQljcmVhdGVfcGdkX21hcHBpbmcocGdkaXIsIHZhLAo+IC0JCQkJICAga2VybmVs X21hcC5waHlzX2FkZHIgKyAodmEgLSBzdGFydF92YSksCj4gLQkJCQkgICBQTURfU0laRSwgUEFH RV9LRVJORUwpOwo+IC19Cj4gLSNlbHNlCj4gIHN0YXRpYyB2b2lkIF9faW5pdCBjcmVhdGVfa2Vy bmVsX3BhZ2VfdGFibGUocGdkX3QgKnBnZGlyLCBib29sIGVhcmx5KQo+ICB7Cj4gIAl1aW50cHRy X3QgdmEsIGVuZF92YTsKPiBAQCAtOTc0LDcgKzkwMSw2IEBAIHN0YXRpYyB2b2lkIF9faW5pdCBj cmVhdGVfa2VybmVsX3BhZ2VfdGFibGUocGdkX3QgKnBnZGlyLCBib29sIGVhcmx5KQo+ICAJCQkJ ICAgZWFybHkgPwo+ICAJCQkJCVBBR0VfS0VSTkVMX0VYRUMgOiBwZ3Byb3RfZnJvbV92YSh2YSkp Owo+ICB9Cj4gLSNlbmRpZgo+ICAKPiAgLyoKPiAgICogU2V0dXAgYSA0TUIgbWFwcGluZyB0aGF0 IGVuY29tcGFzc2VzIHRoZSBkZXZpY2UgdHJlZTogZm9yIDY0LWJpdCBrZXJuZWwsCj4gQEAgLTEx MTYsMjcgKzEwNDIsMTEgQEAgYXNtbGlua2FnZSB2b2lkIF9faW5pdCBzZXR1cF92bSh1aW50cHRy X3QgZHRiX3BhKQo+ICAKPiAgCWtlcm5lbF9tYXAudmlydF9hZGRyID0gS0VSTkVMX0xJTktfQURE UiArIGtlcm5lbF9tYXAudmlydF9vZmZzZXQ7Cj4gIAo+IC0jaWZkZWYgQ09ORklHX1hJUF9LRVJO RUwKPiAtCWtlcm5lbF9tYXAueGlwcm9tID0gKHVpbnRwdHJfdClDT05GSUdfWElQX1BIWVNfQURE UjsKPiAtCWtlcm5lbF9tYXAueGlwcm9tX3N6ID0gKHVpbnRwdHJfdCkoJl9leGlwcm9tKSAtICh1 aW50cHRyX3QpKCZfeGlwcm9tKTsKPiAtCj4gLQlwaHlzX3JhbV9iYXNlID0gQ09ORklHX1BIWVNf UkFNX0JBU0U7Cj4gLSNpZmRlZiBDT05GSUdfU1BBUlNFTUVNX1ZNRU1NQVAKPiAtCXZtZW1tYXBf c3RhcnRfcGZuID0gcm91bmRfZG93bihwaHlzX3JhbV9iYXNlLCBWTUVNTUFQX0FERFJfQUxJR04p ID4+IFBBR0VfU0hJRlQ7Cj4gLSNlbmRpZgo+IC0Ja2VybmVsX21hcC5waHlzX2FkZHIgPSAodWlu dHB0cl90KUNPTkZJR19QSFlTX1JBTV9CQVNFOwo+IC0Ja2VybmVsX21hcC5zaXplID0gKHVpbnRw dHJfdCkoJl9lbmQpIC0gKHVpbnRwdHJfdCkoJl9zdGFydCk7Cj4gLQo+IC0Ja2VybmVsX21hcC52 YV9rZXJuZWxfeGlwX3RleHRfcGFfb2Zmc2V0ID0ga2VybmVsX21hcC52aXJ0X2FkZHIgLSBrZXJu ZWxfbWFwLnhpcHJvbTsKPiAtCWtlcm5lbF9tYXAudmFfa2VybmVsX3hpcF9kYXRhX3BhX29mZnNl dCA9IGtlcm5lbF9tYXAudmlydF9hZGRyIC0ga2VybmVsX21hcC5waHlzX2FkZHIKPiAtCQkJCQkJ KyAodWludHB0cl90KSZfc2RhdGEgLSAodWludHB0cl90KSZfc3RhcnQ7Cj4gLSNlbHNlCj4gIAlr ZXJuZWxfbWFwLnBoeXNfYWRkciA9ICh1aW50cHRyX3QpKCZfc3RhcnQpOwo+ICAJa2VybmVsX21h cC5zaXplID0gKHVpbnRwdHJfdCkoJl9lbmQpIC0ga2VybmVsX21hcC5waHlzX2FkZHI7Cj4gIAlr ZXJuZWxfbWFwLnZhX2tlcm5lbF9wYV9vZmZzZXQgPSBrZXJuZWxfbWFwLnZpcnRfYWRkciAtIGtl cm5lbF9tYXAucGh5c19hZGRyOwo+IC0jZW5kaWYKPiAgCj4gLSNpZiBkZWZpbmVkKENPTkZJR182 NEJJVCkgJiYgIWRlZmluZWQoQ09ORklHX1hJUF9LRVJORUwpCj4gKyNpZiBkZWZpbmVkKENPTkZJ R182NEJJVCkKPiAgCXNldF9zYXRwX21vZGUoZHRiX3BhKTsKPiAgCXNldF9tbWFwX3JuZF9iaXRz X21heCgpOwo+ICAjZW5kaWYKPiBAQCAtMTIwOSwxMyArMTExOSw4IEBAIGFzbWxpbmthZ2Ugdm9p ZCBfX2luaXQgc2V0dXBfdm0odWludHB0cl90IGR0Yl9wYSkKPiAgCWlmIChwZ3RhYmxlX2w0X2Vu YWJsZWQpCj4gIAkJY3JlYXRlX3B1ZF9tYXBwaW5nKHRyYW1wb2xpbmVfcHVkLCBrZXJuZWxfbWFw LnZpcnRfYWRkciwKPiAgCQkJCSAgICh1aW50cHRyX3QpdHJhbXBvbGluZV9wbWQsIFBVRF9TSVpF LCBQQUdFX1RBQkxFKTsKPiAtI2lmZGVmIENPTkZJR19YSVBfS0VSTkVMCj4gLQljcmVhdGVfcG1k X21hcHBpbmcodHJhbXBvbGluZV9wbWQsIGtlcm5lbF9tYXAudmlydF9hZGRyLAo+IC0JCQkgICBr ZXJuZWxfbWFwLnhpcHJvbSwgUE1EX1NJWkUsIFBBR0VfS0VSTkVMX0VYRUMpOwo+IC0jZWxzZQo+ ICAJY3JlYXRlX3BtZF9tYXBwaW5nKHRyYW1wb2xpbmVfcG1kLCBrZXJuZWxfbWFwLnZpcnRfYWRk ciwKPiAgCQkJICAga2VybmVsX21hcC5waHlzX2FkZHIsIFBNRF9TSVpFLCBQQUdFX0tFUk5FTF9F WEVDKTsKPiAtI2VuZGlmCj4gICNlbHNlCj4gIAkvKiBTZXR1cCB0cmFtcG9saW5lIFBHRCAqLwo+ ICAJY3JlYXRlX3BnZF9tYXBwaW5nKHRyYW1wb2xpbmVfcGdfZGlyLCBrZXJuZWxfbWFwLnZpcnRf YWRkciwKPiAtLSAKPiAyLjQ3LjMKPiAKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKbGludXgtcmlzY3ZAbGlz dHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xpbnV4LXJpc2N2Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (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 7CCC52E5B09 for ; Fri, 20 Mar 2026 16:05:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774022707; cv=none; b=TRMRdNV7vOXTeDPI6APQpN9oZj1V1NBvbwFseHRIlatPmkUcNRCvy+ClrRSFwYj5HiRhQMTiUFaQ2WdLJOBMJiQbkpWI+QRd66dbnluns/nj174AVGwnHg29Bv1xLb0jbDd3uPVWbd8uGq1m31hx3ilNWERmxivCdqMOPTpJyC4= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774022707; c=relaxed/simple; bh=jKWOx3UXpjWxLGXIBb6nSRpRWwj+vZ4OGS6DKG13CwU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type:Content-Disposition; b=HiiYx4+SQCnlA5uECWpcmqk1kTWmPLoOHY6ruW3v41cx8OMn9yJbQ3sBKTIbhKDlwmDQbUuqjPHJ9mzQhauiVUCSv8FAB3fN5NdrfjMrS42WVKdeovyDKlzUDq3GCaxS5OAd8WlKAQBQMumFIPrOfCJePBID7t/fgpO97sFWhmg= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=gAfowQjU; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="gAfowQjU" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1774022704; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=wr0Rk6et5CA6CvUspb4cZnB+QZC0WZ+M0KIKtjqSsb8=; b=gAfowQjU8rc1K/O1T2GbB/lbPqnj3SV8CBQKOsOX2tGON6f6scPh54y0drzggJLi6y0dXT 7r4dfcMRHsuHuCq9w1H8L8R5fPNgSF5pM6kUb3oD116rcQHTw4qS0ao6RmLW2ZEt8464Qm Lo9KnfHcREgTOrvEUvqQNKDlHpHVLTE= Received: from mx-prod-mc-05.mail-002.prod.us-west-2.aws.redhat.com (ec2-54-186-198-63.us-west-2.compute.amazonaws.com [54.186.198.63]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-350-k9FjHkmEOnuUF6ANXA1TnA-1; Fri, 20 Mar 2026 12:05:00 -0400 X-MC-Unique: k9FjHkmEOnuUF6ANXA1TnA-1 X-Mimecast-MFC-AGG-ID: k9FjHkmEOnuUF6ANXA1TnA_1774022699 Received: from mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.4]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mx-prod-mc-05.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id 3899B195609E; Fri, 20 Mar 2026 16:04:58 +0000 (UTC) Received: from cmirabil.redhat.com (unknown [10.2.16.157]) by mx-prod-int-01.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTP id F036730001A1; Fri, 20 Mar 2026 16:04:55 +0000 (UTC) From: Charles Mirabile To: namcao@linutronix.de Cc: alex@ghiti.fr, aou@eecs.berkeley.edu, haxel@fzi.de, linux-kernel@vger.kernel.org, linux-riscv@lists.infradead.org, palmer@dabbelt.com, pjw@kernel.org, vitaly.wool@konsulko.com, cmirabil@redhat.com Subject: Re: [PATCH] riscv: Remove support for XIP kernel Date: Fri, 20 Mar 2026 12:04:43 -0400 Message-ID: <20260320160443.1850701-1-cmirabil@redhat.com> In-Reply-To: <20260202115403.2119218-1-namcao@linutronix.de> 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 X-Scanned-By: MIMEDefang 3.4.1 on 10.30.177.4 From: cmirabil@redhat.com Hi— Chiming in as another voice interested in not scrapping XIP. I think RISC-V is an interesting position as an ISA of being able to support both desktop/server class high performance designs, but also low cost embedded applications. The ability to run linux in M-Mode without an MMU, and even XIP directly from storage within one code base just by changing configuration options is fantastic and positions linux to be the obvious kernel of choice for both kinds of RISC-V implementations. That being said, it is clear that these use-cases are not being tested or maintained. The addition of runtime constant support for RISC-V also broke no-mmu which I fixed in: 8d90d9872edae ("riscv: fix runtime constant support for nommu kernels") and clearly is also XIP which I did not test at the time and did not realize. I have a patch to essentially just disable the runtime constants logic on RISC-V when CONFIG_XIP_KERNEL is enabled here that should fix it: https://lore.kernel.org/lkml/20260320155843.1848180-1-cmirabil@redhat.com That being said, In truth I have not actually built or used an XIP linux kernel on RISC-V, so I am not sure I can volunteer to test or maintain it at this moment, but I am planning on experimenting with M-Mode noMMU XIP linux on the sifive hifive unleashed board with the hope of creating a kernel that can act as a linuxboot payload and essentially replace the firmware of the device. With the fix I proposed, perhaps it is tenable to not remove XIP at this time and go back to the status quo? I understand that it is just kicking the can down the road until the next time someone makes a change that breaks XIP and no one notices if no one is testing, but maybe we can have a conversation about how we could improve the situation in the meantime and have an actual plan to catch that before such a breaking patch makes it to mainline next time. Best—Charlie On Mon, Feb 02, 2026 at 12:54:03PM +0100, 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, > -- > 2.47.3 >