From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Subject: [PATCH v6 03/14] ranges.h: add helpers to build and identify Linux section ranges Date: Mon, 9 Jan 2017 06:58:21 -0800 Message-ID: <20170109145833.11502-4-mcgrof@kernel.org> References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170109145833.11502-1-mcgrof@kernel.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: hpa@zytor.com, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com, dalias@libc.org, linux@arm.linux.org.uk Cc: gnomes@lxorguk.ukuu.org.uk, linux-ia64@vger.kernel.org, jkosina@suse.cz, benh@kernel.crashing.org, ming.lei@canonical.com, linux@rasmusvillemoes.dk, platform-driver-x86@vger.kernel.org, James.Bottomley@HansenPartnership.com, paul.gortmaker@windriver.com, paulus@samba.org, sparclinux@vger.kernel.org, wangnan0@huawei.com, mchehab@osg.samsung.com, linux-arch@vger.kernel.org, markus.heiser@darmarit.de, xen-devel@lists.xensource.com, msalter@redhat.com, linux-sh@vger.kernel.org, mpe@ellerman.id.au, joro@8bytes.org, x86@kernel.org, fontana@sharpeleven.org, dsahern@gmail.com, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, linux@roeck-us.net, linux-xtensa@linux-xtensa.org, pali.rohar@gmail.com, keescook@chromium.org, arnd@arndb.de, jani.nikula@intel.com, will.deacon@arm.com, rusty@rustcorp.com.au, rostedt@goodmis.org, ak@ List-Id: linux-arch.vger.kernel.org U2VjdGlvbiByYW5nZXMgYXJlIG9uIG9uZSBvZiB0aGUgdHlwZXMgb2YgY3VzdG9tIHNlY3Rpb25z CnR5cGVzIHVzZWQgaW4gTGludXguIFRoaXMgcHJvdmlkZXMgYSBzZXJpZXMgb2YgaGVscGVycyBm b3IKZGVmaW5pbmcgdGhlbSBhbmQgdXNpbmcgdGhlbS4gTW9zdCBpbXBvcnRhbnRseSB0aGlzIGFs c28KZW5hYmxlcyB1cyB0byBhdm9pZCBtb2RpZnlpbmcgdGhlIGxpbmtlciBzY3JpcHQgd2hlbiB3 ZQphZGQgYSBuZXcgc2VjdGlvbiByYW5nZS4KCkl0IHR1cm5zIG91dCBhIGxvdCBvZiBjdXN0b20g c2VjdGlvbnMgYXJlIGFjdHVhbGx5IHNlY3Rpb24gcmFuZ2VzLAphbmQgdGhlc2UgYXJlIHR5cGlj YWxseSBzcGVsbGVkIG91dCBpbiB0aGVpciBhcmNoaXRlY3R1cmUgc3BlY2lmaWMKYXNtL3NlY3Rp b25zLmggZmlsZSAtLSB3ZSBlbmFibGUgYXJjaGl0ZWN0dXJlcyB0byBvdmVycmlkZSB3aGF0IGFz bQppcyB1c2VkIGZvciBzZWN0aW9uIHJhbmdlcyBidXQgc3RhcnQgYnkgZGVmYXVsdCB0cnVzdGlu ZyB0aGUKYXNtLWdlbmVyaWMgdmVyc2lvbiBhbGwgYXJvdW5kLgoKQWx0aG91Z2ggdHlwaWNhbGx5 IHlvdSB3aWxsIG5vdCB3YW50IHRvIGhhdmUgc2VjdGlvbiByYW5nZXMgb3JkZXJlZAp3ZSBtdXN0 IHVzZSBTT1JUKCkgb24gdm1saW51eC5sZHMuUyBmb3Igc2VjdGlvbiByYW5nZXMgdG8gZW5hYmxl IHVzCnRvIGV4dGVuZCBhIHNlY3Rpb24gcmFuZ2Ugd2l0aG91dCBtb2RpZnlpbmcgdGhlIGxpbmtl ciBzY3JpcHQuIFRvCmFjY29tcGxpc2ggdGhpcyB3ZSB1c2UgYSBzcGVjaWFsIG9yZGVyIHN0cmlu ZyBmb3IgdGhlIGZpcnN0IGVsZW1lbnQKb2YgYSBzZWN0aW9uIHJhbmdlIC0tIHRoZSBlbXB0eSBz dHJpbmcgIiIgKHJlZmVyIHRvIF9fU0VDVElPTl9SQU5HRV9CRUdJTigpKSwKdGhlbiAifiIgZm9y IHRoZSBsYXN0IGVsZW1lbnQgKHJlZmVyIHRvIF9fU0VDVElPTl9SQU5HRV9CRUdJTigpKS4gSWYK eW91IHVzZSB0aGUgImFueSIgb3JkZXIgZm9yIGVsZW1lbnRzIGluIGJldHdlZW4gYW5kIHVzZSBT T1JUKCkgeW91IGVuZAp1cCBrZWVwaW5nIGFueSBhZGRlZCBlbGVtZW50IGluIGJldHdlZWVuIGFu ZCBhIHJlZmVyZW5jZSB0byB0aGUKYmVnaW5uaW5nIGFuZCBlbmQgb2YgdGhlIHNlY3Rpb24gcmFu Z2Ugd2l0aG91dCByZXF1aXJpbmcgY3VzdG9tIGxpbmtlcgpzY3JpcHQgbW9kaWZpY2F0aW9ucy4g U3BlY2lmaWMgb3JkZXIgYW5ub3RhdGlvbnMgYXJlIGFsc28gc3VwcG9ydGVkCnRvIGhlbHAgY29u c3RydWN0IHN5bnRoZXRpYyBmdW5jdGlvbnMsIGEgZGVtbyBmb3Igd2hpY2ggd2lsbCBiZSBwcm92 aWRlZApsYXRlci4KCnY1OgoKbyBVc2UgLi5ybmcuKiBpbnN0ZWFkIG9mIC5ybmcuKiBhcyBzdWdn ZXN0ZWQgYnkgTmljaG9sYXMgUGlnZ2luLgogIFRoaXMgaXMgdGhlIHR5cGljYWwgd2F5IHRvIGF2 b2lkIGNsYXNoIHdpdGggY29tcGlsZXIgZ2VuZXJhdGVkCiAgc2VjdGlvbi4KCm8gUmVwbGFjZSBz ZWN0aW9uIG1hY3JvcyB3aXRoIHNlY3Rpb24gbmFtZXMKCm8gRXh0ZW5kIGNvbW1pdCBsb2cgdG8g anVzdGlmeSBTT1JUKCkgYW5kIGV4cGxhaW4gd2h5IGFuZCBob3cgd2UgdXNlCiAgc3BlY2lmaWMg c3BlY2lhbCBzdHJpbmdzIGZvciB0aGUgYmVnaW5uaW5nLCBlbmQgZWxlbWVudHMgb2YgYSBzZWN0 aW9uCiAgcmFuZ2UgYW5kIHRoZSAiYW55IiBvcmRlciBmb3IgZWxlbWVudHMgaW4gYmV0d2Vlbi4K Cm8gRHJvcCBTRUNUSU9OX1JOR19BTEwoKSAtLSB3ZSBubyBsb25nZXIgbmVlZCB0aGlzIG9uIGxp bmtlciBzY3JpcHRzCgpvIFRvIG1ha2UgdGhpcyBlYXNpZXIgdG8gcmVhZCwgYXMgcGVyIE5pY2hv bGFzIFBpZ2dpbiwgYWRkIG91ciBvd24KICBTRUNUSU9OX1JBTkdFX1NUQVJUKCksIFNFQ1RJT05f UkFOR0VfRU5EKCkuIEFmdGVyIHJldmlld2luZyB0aGUKICBjaGFuZ2VzIGFmZmVjdGVkIGJ5IHRo aXMgaXQgc2VlbWVkIGNsZWFyZXIgYW5kIGJldHRlciB0aGVuIHRvIGFsc28KICB1c2Ugb3VyIG93 biBzcGVjaWZpYyBTRUNUSU9OX1JBTkdFX1NJWkUoKSwgYW5kIFNFQ1RJT05fUkFOR0VfRU1QVFko KSwKICBhbmQgU0VDVElPTl9SQU5HRV9BTElHTk1FTlQoKSBhcyB3ZWxsLgoKbyBXZSB3ZXJlIHVz aW5nIExJTlVYX1NFQ1RJT05fU1RBUlQoKSBhbmQgTElOVVhfU0VDVElPTl9FTkQoKSBpbiBzb21l IHBsYWNlcwogIGJ1dCBpbiBzb21lIG90aGVyIHBsYWNlcyBWTUxJTlVYX1NZTUJPTChuYW1lKSwg Vk1MSU5VWF9TWU1CT0wobmFtZSMjX19lbmQpLgogIFNpbmNlIHdlIGFyZSBhZGRpbmcgU0VDVElP Tl9SQU5HRV9TVEFSVCgpIGFuZCBTRUNUSU9OX1JBTkdFX0VORCgpIGp1c3QKICB1c2UgdGhvc2Ug Y29uc2lzdGVudGx5LgoKbyBNb3ZlIHRoZSBsaW5rZXIgdGFibGUgKihTT1JUKC5kYXRhLnJuZy4q KSkgdG8gYmUgcHJlc2VudCBiZWZvcmUKICB0aGUgcmVjZW50bHkgYWRkZWQgKiguZGF0YS5bMC05 YS16QS1aX10qKSB0byBlbnN1cmUgd2Uga2VlcCBzb3J0IG9yZGVyCiAgb24gdGhlIHNlY3Rpb24g cmFuZ2UuCgpvIEFkZHMgdGhlICJMaW51eCBzZWN0aW9uIG9yZGVyaW5nIiBkb2N1bWVudGF0aW9u LCBhcyBpdHMgbXVjaCBtb3JlCiAgcmVsZXZhbnQgYWZ0ZXIgdGhpcyBwYXRjaCwgaW4gcGFydGlj dWxhciB3aGVuIHRyZWF0aW5nIHRoZSAiYW55IgogIG9yZGVyIGxldmVsLgoKbyBGaXggcG93ZXJw YyAudGV4dCB1c2U6IC0tIGl0IGRvZXMgbm90IHVzZSBURVhUX1RFWFQgc28gd2UgbXVzdAogIGFk ZCBvdXIgKihTT1JUKC50ZXh0LnJuZy4qKSkgdG8gaXRzIGxpbmtlciBzY3JpcHQgbWFudWFsbHku Cgp2NDoKCm8gdG9ucyBvZiBkb2N1bWVudGF0aW9uIGxvdmUKbyBmaXggYXJjaC94ODYvdG9vbHMv cmVsb2NzLmMgdHlwbyAtIHdoaWNoIGNhdXNlZCBjb21waWxhdGlvbiBpc3N1ZXMKICBvbiBvbGQg dG9vbGNoYWlucwpvIHBvcnQgdG8gbmV3IHNoaW55IHNwaGlueCBkb2N1bWVudGF0aW9uCm8gc3By aW5rbGUgYSBmZXcgbW9yZSBuZWVkZWQgVk1MSU5VWF9TWU1CT0woKSAtIGZpeGVzCiAgY29tcGls YXRpb24gb24gYmxhY2tmaW4KbyBuYW1lIGNoYW5nZXMgYXMgc3VnZ2VzdGVkIGJ5IEJvcmlzOgot ICVzL1NFQ1RJT05fVFlQRV9SQU5HRVMvcm5nL2cKLSAlcy9TRUNUSU9OX1RZUEUvU0VDVElPTl9D T1JFL2cKLSAlcy9zZWN0aW9uX3R5cGVfYXNtdHlwZS9zZWN0aW9uX2NvcmVfdHlwZS9nCi0gJXMv c2VjdGlvbl90eXBlL3NlY3Rpb25fY29yZS9nCi0gJXMvc2VjdGlvbl9ybmcvc2V0X3NlY3Rpb25f cm5nL2cKLSByZWJyYW5kIERFQ0xBUkVfU0VDVElPTl9STkcoKSBhcyBERUZJTkVfU0VDVElPTl9S QU5HRSgpIC0gdGhpcyBpcwogIHRoZSBhc20gdmVyc2lvbiBvZiB0aGUgcmVzcGVjdGl2ZSBDIHZl cnNpb24sIHRoaXMgd2lsbCBoYXZlIGEKICB1c2Vyc3BhY2UgQyBkZW1vIGFkZGVkIGxhdGVyLgpv IG1vdmUgX19MSU5VWF9SQU5HRSgpIGFuZCBfX0xJTlVYX1JBTkdFX09SREVSKCkgLSBmaXhlcyBi dWlsZHMKICBvbiBzcGFyYwpvIGFkZHMgc2VjdGlvbiByYW5nZXMgdG8gbGlua2VyIHNjcmlwdApv IHJlbmFtZSBTRUNUSU9OX1JBTkdFX0FMTCgpCm8gdXNlIGRlZmF1bHQgYWxpZ25tZW50LCBmaXhl cyBidWlsZHMgb24gcG93ZXJwYyBhbmQgYXJtIGZvciBib3RoCiAgX19MSU5VWF9SQU5HRSgpIGFu ZCBfX0xJTlVYX1JBTkdFX09SREVSKCkKbyBleHBhbmQgZG9jdW1lbnRhdGlvbiB0byBkb2N1bWVu dCBtb2R1bGVzIHN1cHBvcnQKbyBhZGQgbWFpbnRhaW5lcnMKbyB1c2UgZ2VuZXJpYy15Cgp2Mzog bmV3IGluIHRoaXMgc2VyaWVzLCB1c2VzIGNvcHlsZWZ0LW5leHQKClNpZ25lZC1vZmYtYnk6IEx1 aXMgUi4gUm9kcmlndWV6IDxtY2dyb2ZAa2VybmVsLm9yZz4KLS0tCiBEb2N1bWVudGF0aW9uL3Nl Y3Rpb25zL2luZGV4LnJzdCAgICAgICAgfCAgIDEgKwogRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9y YW5nZXMucnN0ICAgICAgIHwgIDc0ICsrKysrKysrKysrKysKIERvY3VtZW50YXRpb24vc2VjdGlv bnMvc2VjdGlvbi1jb3JlLnJzdCB8ICAgNSArCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgMTAgKysKIGFyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkICAgICAg ICAgICB8ICAgMSArCiBhcmNoL2FyYy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgfCAg IDEgKwogYXJjaC9hcm0vaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgIHwgICAxICsKIGFy Y2gvYXJtNjQvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICB8ICAgMSArCiBhcmNoL2F2cjMy L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgfCAgIDEgKwogYXJjaC9ibGFja2Zpbi9pbmNs dWRlL2FzbS9LYnVpbGQgICAgICAgIHwgICAxICsKIGFyY2gvYzZ4L2luY2x1ZGUvYXNtL0tidWls ZCAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL2NyaXMvaW5jbHVkZS9hc20vS2J1aWxkICAgICAg ICAgICAgfCAgIDEgKwogYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgIHwg ICAxICsKIGFyY2gvaDgzMDAvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICB8ICAgMSArCiBh cmNoL2hleGFnb24vaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgfCAgIDEgKwogYXJjaC9pYTY0 L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsKIGFyY2gvbTMyci9pbmNsdWRl L2FzbS9LYnVpbGQgICAgICAgICAgICB8ICAgMSArCiBhcmNoL202OGsvaW5jbHVkZS9hc20vS2J1 aWxkICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9tZXRhZy9pbmNsdWRlL2FzbS9LYnVpbGQgICAg ICAgICAgIHwgICAxICsKIGFyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICB8 ICAgMSArCiBhcmNoL21pcHMvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgfCAgIDEgKwog YXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgIHwgICAxICsKIGFyY2gvbmlv czIvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICB8ICAgMSArCiBhcmNoL29wZW5yaXNjL2lu Y2x1ZGUvYXNtL0tidWlsZCAgICAgICAgfCAgIDEgKwogYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20v S2J1aWxkICAgICAgICAgIHwgICAxICsKIGFyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9LYnVpbGQg ICAgICAgICB8ICAgMSArCiBhcmNoL3Bvd2VycGMva2VybmVsL3ZtbGludXgubGRzLlMgICAgICAg fCAgIDEgKwogYXJjaC9zMzkwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsK IGFyY2gvc2NvcmUvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICB8ICAgMSArCiBhcmNoL3No L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9zcGFyYy9pbmNs dWRlL2FzbS9LYnVpbGQgICAgICAgICAgIHwgICAxICsKIGFyY2gvdGlsZS9pbmNsdWRlL2FzbS9L YnVpbGQgICAgICAgICAgICB8ICAgMSArCiBhcmNoL3VtL2luY2x1ZGUvYXNtL0tidWlsZCAgICAg ICAgICAgICAgfCAgIDEgKwogYXJjaC91bmljb3JlMzIvaW5jbHVkZS9hc20vS2J1aWxkICAgICAg IHwgICAxICsKIGFyY2gveDg2L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICB8ICAgMSAr CiBhcmNoL3g4Ni90b29scy9yZWxvY3MuYyAgICAgICAgICAgICAgICAgfCAgIDIgKwogYXJjaC94 dGVuc2EvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgIHwgICAxICsKIGluY2x1ZGUvYXNtLWdl bmVyaWMvcmFuZ2VzLmggICAgICAgICAgICB8ICA5MyArKysrKysrKysrKysrKysrCiBpbmNsdWRl L2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oICAgICAgfCAgNDEgKysrKysrKwogaW5jbHVkZS9h c20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oICAgICAgIHwgIDEyICsrLQogaW5jbHVkZS9saW51eC9y YW5nZXMuaCAgICAgICAgICAgICAgICAgIHwgMTgzICsrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrCiA0MSBmaWxlcyBjaGFuZ2VkLCA0NTEgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMo LSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL3NlY3Rpb25zL3Jhbmdlcy5yc3QK IGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2FzbS1nZW5lcmljL3Jhbmdlcy5oCiBjcmVhdGUg bW9kZSAxMDA2NDQgaW5jbHVkZS9saW51eC9yYW5nZXMuaAoKZGlmZiAtLWdpdCBhL0RvY3VtZW50 YXRpb24vc2VjdGlvbnMvaW5kZXgucnN0IGIvRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9pbmRleC5y c3QKaW5kZXggZjM3NTExZWYwNWU3Li40YTFkZjM4OWZhOTEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50 YXRpb24vc2VjdGlvbnMvaW5kZXgucnN0CisrKyBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvaW5k ZXgucnN0CkBAIC0xNSwzICsxNSw0IEBAIGNvbW1vbiBhIHNldCBvZiBMaW51eCBoZWxwZXJzIGZv ciBFTEYgc2VjdGlvbnMgYXJlIGFsc28gZG9jdW1lbnRlZC4KIAogICAgYmFja2dyb3VuZAogICAg c2VjdGlvbi1jb3JlCisgICByYW5nZXMKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdGlv bnMvcmFuZ2VzLnJzdCBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvcmFuZ2VzLnJzdApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmQ5ZDNhZjRlNTJjYgotLS0gL2Rldi9u dWxsCisrKyBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvcmFuZ2VzLnJzdApAQCAtMCwwICsxLDc0 IEBACis9PT09PT09PT09PT09PT09PT09PQorTGludXggc2VjdGlvbiByYW5nZXMKKz09PT09PT09 PT09PT09PT09PT09CisKK1RoaXMgZG9jdW1lbnRzIExpbnV4JyB1c2Ugb2Ygc2VjdGlvbiByYW5n ZXMsIGhvdyB5b3UgY2FuIHVzZQordGhlbSBhbmQgaG93IHRoZXkgd29yay4KKworQWJvdXQgc2Vj dGlvbiByYW5nZXMKKz09PT09PT09PT09PT09PT09PT09CisKK0ludHJvZHVjdGlvbgorLS0tLS0t LS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC9yYW5nZXMuaAorICAgOmRvYzog SW50cm9kdWN0aW9uCisKK1NlY3Rpb24gcmFuZ2UgbW9kdWxlIHN1cHBvcnQKKy0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3Jhbmdlcy5o CisgICA6ZG9jOiBTZWN0aW9uIHJhbmdlIG1vZHVsZSBzdXBwb3J0CisKK1NlY3Rpb24gcmFuZ2Ug aGVscGVycworPT09PT09PT09PT09PT09PT09PT09CisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9s aW51eC9yYW5nZXMuaAorICAgOmRvYzogU2VjdGlvbiByYW5nZSBoZWxwZXJzCisKK1NFQ1RJT05f UkFOR0VfU1RBUlQKKy0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRl L2xpbnV4L3Jhbmdlcy5oCisgICA6ZnVuY3Rpb25zOiBTRUNUSU9OX1JBTkdFX1NUQVJUCisKK1NF Q1RJT05fUkFOR0VfRU5ECistLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1 ZGUvbGludXgvcmFuZ2VzLmgKKyAgIDpmdW5jdGlvbnM6IFNFQ1RJT05fUkFOR0VfRU5ECisKK1NF Q1RJT05fUkFOR0VfU0laRQorLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5j bHVkZS9saW51eC9yYW5nZXMuaAorICAgOmZ1bmN0aW9uczogU0VDVElPTl9SQU5HRV9TSVpFCisK K1NFQ1RJT05fUkFOR0VfRU1QVFkKKy0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6 OiBpbmNsdWRlL2xpbnV4L3Jhbmdlcy5oCisgICA6ZnVuY3Rpb25zOiBTRUNUSU9OX1JBTkdFX0VN UFRZCisKK1NFQ1RJT05fUkFOR0VfQUREUl9XSVRISU4KKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3Jhbmdlcy5oCisgICA6ZnVuY3Rpb25z OiBTRUNUSU9OX1JBTkdFX0FERFJfV0lUSElOCisKK1NFQ1RJT05fUkFOR0VfQUxJR05NRU5UCist LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC9y YW5nZXMuaAorICAgOmZ1bmN0aW9uczogU0VDVElPTl9SQU5HRV9BTElHTk1FTlQKKworREVDTEFS RV9TRUNUSU9OX1JBTkdFCistLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBp bmNsdWRlL2xpbnV4L3Jhbmdlcy5oCisgICA6ZnVuY3Rpb25zOiBERUNMQVJFX1NFQ1RJT05fUkFO R0UKKworREVGSU5FX1NFQ1RJT05fUkFOR0UKKy0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJu ZWwtZG9jOjogaW5jbHVkZS9saW51eC9yYW5nZXMuaAorICAgOmZ1bmN0aW9uczogREVGSU5FX1NF Q1RJT05fUkFOR0UKKworX19MSU5VWF9SQU5HRQorLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRv Yzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMvcmFuZ2VzLmgKKyAgIDpmdW5jdGlvbnM6IF9fTElOVVhf UkFOR0UKKworX19MSU5VWF9SQU5HRV9PUkRFUgorLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2Vy bmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMvcmFuZ2VzLmgKKyAgIDpmdW5jdGlvbnM6IF9f TElOVVhfUkFOR0VfT1JERVIKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvc2Vj dGlvbi1jb3JlLnJzdCBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvc2VjdGlvbi1jb3JlLnJzdApp bmRleCBhYzU4MTVhMGQ5YjMuLjFmNjEzYTZjN2I3OCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlv bi9zZWN0aW9ucy9zZWN0aW9uLWNvcmUucnN0CisrKyBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMv c2VjdGlvbi1jb3JlLnJzdApAQCAtMTE0LDYgKzExNCwxMSBAQCBMaW51eCAucmVmXCogc2VjdGlv bnMKIC4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCiAg ICA6ZG9jOiAucmVmLnJvZGF0YQogCitMaW51eCBzZWN0aW9uIG9yZGVyaW5nCis9PT09PT09PT09 PT09PT09PT09PT09CisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9u LWNvcmUuaAorICAgOmRvYzogTGludXggc2VjdGlvbiBvcmRlcmluZworCiBHZW5lcmljIExpbnV4 IGtlcm5lbCBzZWN0aW9uIGhlbHBlcnMKID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQogCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IGFlODYx MzZmNGI5YS4uYzk2Y2EwMzJjMjc2IDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlO VEFJTkVSUwpAQCAtNTQyNCw2ICs1NDI0LDE2IEBAIFM6CVN1cHBvcnRlZAogRjoJZHJpdmVycy9i YXNlL3Bvd2VyL2RvbWFpbiouYwogRjoJaW5jbHVkZS9saW51eC9wbV9kb21haW4uaAogCitHRU5F UklDIFNFQ1RJT04gUkFOR0VTCitNOgkiTHVpcyBSLiBSb2RyaWd1ZXoiIDxtY2dyb2ZAa2VybmVs Lm9yZz4KK006CSJILiBQZXRlciBBbnZpbiIgPGhwYUB6eXRvci5jb20+CitMOglsaW51eC1hcmNo QHZnZXIua2VybmVsLm9yZworTDoJbGludXgta2VybmVsQHZnZXIua2VybmVsLm9yZworUzoJU3Vw cG9ydGVkCitGOglpbmNsdWRlL2FzbS1nZW5lcmljL3Jhbmdlcy5oCitGOglpbmNsdWRlL2xpbnV4 L3Jhbmdlcy5oCitGOglEb2N1bWVudGF0aW9uL3NlY3Rpb25zL3Jhbmdlcy5yc3QKKwogR0VORVJJ QyBTRUNUSU9OUwogTToJIkx1aXMgUi4gUm9kcmlndWV6IiA8bWNncm9mQGtlcm5lbC5vcmc+CiBN OglKb3NoIFBvaW1ib2V1ZiA8anBvaW1ib2VAcmVkaGF0LmNvbT4KZGlmZiAtLWdpdCBhL2FyY2gv YWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9hbHBoYS9pbmNsdWRlL2FzbS9LYnVpbGQK aW5kZXggNTQyMjgyN2YxNTg1Li5lNDRjODk2YjkxYzQgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEv aW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkCkBA IC0xMSwzICsxMSw0IEBAIGdlbmVyaWMteSArPSBwcmVlbXB0LmgKIGdlbmVyaWMteSArPSBzZWN0 aW9ucy5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24t Y29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvYXJjL2luY2x1 ZGUvYXNtL0tidWlsZCBiL2FyY2gvYXJjL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA3YjJjYjNk ZWE1ZmMuLmEzNzRiN2Y4Mzg4OCAxMDA2NDQKLS0tIGEvYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1 aWxkCisrKyBiL2FyY2gvYXJjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNTIsMyArNTIsNCBAQCBn ZW5lcmljLXkgKz0gdmdhLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmlj LXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJh bmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2Fy bS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggOWI2OWEyMmE5YWUxLi4wZDQ3Zjk4Y2NiYzAgMTAw NjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2FybS9pbmNs dWRlL2FzbS9LYnVpbGQKQEAgLTQyLDMgKzQyLDQgQEAgZ2VuZXJpYy15ICs9IHVuYWxpZ25lZC5o CiBnZW5lcmF0ZWQteSArPSBtYWNoLXR5cGVzLmgKIGdlbmVyYXRlZC15ICs9IHVuaXN0ZC1uci5o CiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKK2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZm IC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL0tidWlsZAppbmRleCAwMGFjZTVlODI2ZjEuLmU5OTM5Y2JkOTA2NyAxMDA2NDQKLS0t IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRl L2FzbS9LYnVpbGQKQEAgLTQ2LDMgKzQ2LDQgQEAgZ2VuZXJpYy15ICs9IHVzZXIuaAogZ2VuZXJp Yy15ICs9IHZnYS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNv cmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2luY2x1 ZGUvYXNtL0tidWlsZCBiL2FyY2gvYXZyMzIvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGYyYzNi NjU2YTBlNy4uZWRjMTc2MzQ4ZDdjIDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2luY2x1ZGUvYXNt L0tidWlsZAorKysgYi9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMjMsMyArMjMs NCBAQCBnZW5lcmljLXkgKz0gdmdhLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBn ZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15 ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL0tidWls ZCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGJmMjA1NDFiY2YyMS4u MzQyODQxNWIxOTk2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL0tidWls ZAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNDgsMyArNDgsNCBA QCBnZW5lcmljLXkgKz0gdXNlci5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2Vu ZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKK2dlbmVyaWMteSAr PSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9jNngvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJj aC9jNngvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDM4MTI3Y2U3NDdiZS4uY2VkZTJhOTUwZmJm IDEwMDY0NAotLS0gYS9hcmNoL2M2eC9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9jNngv aW5jbHVkZS9hc20vS2J1aWxkCkBAIC02MywzICs2Myw0IEBAIGdlbmVyaWMteSArPSB2Z2EuaAog Z2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJp Yy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBh L2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2NyaXMvaW5jbHVkZS9hc20vS2J1 aWxkCmluZGV4IDM4NWNkODhhOWQ5ZS4uZmI4YmI0MTEyNzczIDEwMDY0NAotLS0gYS9hcmNoL2Ny aXMvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQK QEAgLTQ2LDMgKzQ2LDQgQEAgZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5lcmljLXkgKz0gd29yZC1h dC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3Jl LmgKK2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9mcnYvaW5jbHVkZS9h c20vS2J1aWxkIGIvYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDQ2ZDdjNTk5ZDli OC4uNTE5MWZlYzY1NWQ3IDEwMDY0NAotLS0gYS9hcmNoL2Zydi9pbmNsdWRlL2FzbS9LYnVpbGQK KysrIGIvYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC05LDMgKzksNCBAQCBnZW5lcmlj LXkgKz0gcHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9 IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15 ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZCBi L2FyY2gvaDgzMDAvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDFlYzA0ZWMxYzgyYi4uNzkyOWE5 OTI1NjZjIDEwMDY0NAotLS0gYS9hcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9h cmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNzYsMyArNzYsNCBAQCBnZW5lcmljLXkg Kz0gdmdhLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9y LmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRp ZmYgLS1naXQgYS9hcmNoL2hleGFnb24vaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9oZXhhZ29u L2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCAzN2Q3YmZhZTc2MTkuLmFmMTdlZTMzNDc4OCAxMDA2 NDQKLS0tIGEvYXJjaC9oZXhhZ29uL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2hleGFn b24vaW5jbHVkZS9hc20vS2J1aWxkCkBAIC02MSwzICs2MSw0IEBAIGdlbmVyaWMteSArPSB2Z2Eu aAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2Vu ZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdp dCBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2lhNjQvaW5jbHVkZS9hc20v S2J1aWxkCmluZGV4IDY3MmM2ZDVkYTE4Yy4uZDhmMjI2YjM1YTBhIDEwMDY0NAotLS0gYS9hcmNo L2lhNjQvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9LYnVp bGQKQEAgLTEwLDMgKzEwLDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMt eSArPSB2dGltZS5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9 IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gv bTMyci9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL20zMnIvaW5jbHVkZS9hc20vS2J1aWxkCmlu ZGV4IDYxMTFlMTUyMzc1MC4uMWM2NTA0ZDI5MzEyIDEwMDY0NAotLS0gYS9hcmNoL20zMnIvaW5j bHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTEy LDMgKzEyLDQgQEAgZ2VuZXJpYy15ICs9IHNlY3Rpb25zLmgKIGdlbmVyaWMteSArPSB0cmFjZV9j bG9jay5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHNlY3Rp b24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9p bmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDEy NzdiNDViZjRmOS4uMDA2ZTI4NjNhZDM3IDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9h c20vS2J1aWxkCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTM1LDMgKzM1 LDQgQEAgZ2VuZXJpYy15ICs9IHR5cGVzLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5o CiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJp Yy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL21ldGFnL2luY2x1ZGUvYXNtL0tidWls ZCBiL2FyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGIxMDExMzc1Y2Q3YS4uNGE4 NDcxNDM0YTNlIDEwMDY0NAotLS0gYS9hcmNoL21ldGFnL2luY2x1ZGUvYXNtL0tidWlsZAorKysg Yi9hcmNoL21ldGFnL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNTYsMyArNTYsNCBAQCBnZW5lcmlj LXkgKz0gdmdhLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0g eG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5o CmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9t aWNyb2JsYXplL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBjNmMyY2Y2ZWRjOTguLjYzYzA4M2Ex ZjhkYSAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL0tidWlsZAorKysg Yi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0xMiwzICsxMiw0IEBAIGdl bmVyaWMteSArPSBzeXNjYWxscy5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJp Yy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2Vu ZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vS2J1 aWxkIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA3YTkzMmI0YTU1MzEuLmU4 NDRkNjA1ODI0OCAxMDA2NDQKLS0tIGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL0tidWlsZAorKysg Yi9hcmNoL21pcHMvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0yMiwzICsyMiw0IEBAIGdlbmVyaWMt eSArPSB1c2VyLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0g eG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5o CmRpZmYgLS1naXQgYS9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9tbjEw MzAwL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBmODE0NWJjODU4MzUuLjY1NmFmN2I2OTk0MCAx MDA2NDQKLS0tIGEvYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL21u MTAzMDAvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0xMSwzICsxMSw0IEBAIGdlbmVyaWMteSArPSBz ZWN0aW9ucy5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHdvcmQt YXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJh bmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL25pb3MyL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gv bmlvczIvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGM5YzdjYjgyYjAwZi4uYzU1ODgwNjU5ZDY3 IDEwMDY0NAotLS0gYS9hcmNoL25pb3MyL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL25p b3MyL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNjQsMyArNjQsNCBAQCBnZW5lcmljLXkgKz0gdmdh LmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdl bmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1n aXQgYS9hcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvb3BlbnJpc2MvaW5j bHVkZS9hc20vS2J1aWxkCmluZGV4IDg2MTc1ZTcwMTg2OS4uN2Q2YTcwNGI4MDhjIDEwMDY0NAot LS0gYS9hcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL29wZW5yaXNj L2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNzIsMyArNzIsNCBAQCBnZW5lcmljLXkgKz0gdmdhLmgK IGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVy aWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQg YS9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3BhcmlzYy9pbmNsdWRlL2Fz bS9LYnVpbGQKaW5kZXggMThhOWQ0YzVlYWQ3Li5mMTFkMTI0OTczOGYgMTAwNjQ0Ci0tLSBhL2Fy Y2gvcGFyaXNjL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3BhcmlzYy9pbmNsdWRlL2Fz bS9LYnVpbGQKQEAgLTI5LDMgKzI5LDQgQEAgZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5lcmljLXkg Kz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkgKz0gc2Vj dGlvbi1jb3JlLmgKK2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dl cnBjL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9LYnVpbGQK aW5kZXggNDMyMmQ5NzQ2Y2RiLi42MGQ4MzQ5MjQxYTcgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJw Yy9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL0tidWls ZApAQCAtOSwzICs5LDQgQEAgZ2VuZXJpYy15ICs9IHByZWVtcHQuaAogZ2VuZXJpYy15ICs9IHJ3 c2VtLmgKIGdlbmVyaWMteSArPSB2dGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgK K2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC92 bWxpbnV4Lmxkcy5TIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC92bWxpbnV4Lmxkcy5TCmluZGV4IDcz OTRiNzcwYWUxZi4uZmNmYzlkMTAyMzQ4IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVs L3ZtbGludXgubGRzLlMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC92bWxpbnV4Lmxkcy5TCkBA IC0xMDcsNiArMTA3LDcgQEAgU0VDVElPTlMKICNlbmRpZgogCQkvKiBjYXJlZnVsISBfX2Z0cl9h bHRfKiBzZWN0aW9ucyBuZWVkIHRvIGJlIGNsb3NlIHRvIC50ZXh0ICovCiAJCSooLnRleHQgLmZp eHVwIF9fZnRyX2FsdF8qIC5yZWYudGV4dCkKKwkJKihTT1JUKC50ZXh0LnJuZy4qKSkKIAkJU0NI RURfVEVYVAogCQlDUFVJRExFX1RFWFQKIAkJTE9DS19URVhUCmRpZmYgLS1naXQgYS9hcmNoL3Mz OTAvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL0tidWlsZAppbmRl eCA2M2ExYzI5MjRiOTEuLmMxYjg1YTM2MWU1ZCAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2luY2x1 ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC05LDMg KzksNCBAQCBnZW5lcmljLXkgKz0gcHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2su aAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNv cmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3Njb3JlL2luY2x1 ZGUvYXNtL0tidWlsZCBiL2FyY2gvc2NvcmUvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGYwODlh MjY0Y2QzOC4uZjBjZGIyY2JjYTRkIDEwMDY0NAotLS0gYS9hcmNoL3Njb3JlL2luY2x1ZGUvYXNt L0tidWlsZAorKysgYi9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTUsMyArMTUs NCBAQCBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZXJpYWwuaAogZ2VuZXJpYy15 ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJp Yy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZCBi L2FyY2gvc2gvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDdiMDM1NmRjYTU2Mi4uYzliYjc5MzJh M2QxIDEwMDY0NAotLS0gYS9hcmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3No L2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNDAsMyArNDAsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2Vf Y2xvY2suaAogZ2VuZXJpYy15ICs9IHVjb250ZXh0LmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2Vu ZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdp dCBhL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2Fz bS9LYnVpbGQKaW5kZXggNDM4Zjg2NTczZGM1Li4yODI4MDg4N2FjNzkgMTAwNjQ0Ci0tLSBhL2Fy Y2gvc3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20v S2J1aWxkCkBAIC0yMiwzICsyMiw0IEBAIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5l cmljLXkgKz0gdHlwZXMuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMt eSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9h cmNoL3RpbGUvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC90aWxlL2luY2x1ZGUvYXNtL0tidWls ZAppbmRleCBmYjZiODMxYzFmYmEuLjMzZjcwNjk3NjNhZSAxMDA2NDQKLS0tIGEvYXJjaC90aWxl L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3RpbGUvaW5jbHVkZS9hc20vS2J1aWxkCkBA IC00MSwzICs0MSw0IEBAIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0g dHlwZXMuaAogZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgK K2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC91bS9pbmNsdWRlL2FzbS9L YnVpbGQgYi9hcmNoL3VtL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA1ODBiZDVmZjgyOGYuLmI5 NTJkY2IzZTIxNiAxMDA2NDQKLS0tIGEvYXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIv YXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTI3LDMgKzI3LDQgQEAgZ2VuZXJpYy15ICs9 IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkg Kz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdl cy5oCmRpZmYgLS1naXQgYS9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNo L3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggODU3ODcwMmQ0OTk4Li45M2FiYmZk YWI1NDMgMTAwNjQ0Ci0tLSBhL2FyY2gvdW5pY29yZTMyL2luY2x1ZGUvYXNtL0tidWlsZAorKysg Yi9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTYxLDMgKzYxLDQgQEAgZ2Vu ZXJpYy15ICs9IHVzZXIuaAogZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5lcmljLXkgKz0gd29yZC1h dC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlm ZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gveDg2L2luY2x1ZGUv YXNtL0tidWlsZAppbmRleCBhZjk3NWYyMWVlZWUuLmY2NzJmMmZjMTgxZCAxMDA2NDQKLS0tIGEv YXJjaC94ODYvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL0ti dWlsZApAQCAtMTMsMyArMTMsNCBAQCBnZW5lcmljLXkgKz0gZWFybHlfaW9yZW1hcC5oCiBnZW5l cmljLXkgKz0gbWNzX3NwaW5sb2NrLmgKIGdlbmVyaWMteSArPSBtbS1hcmNoLWhvb2tzLmgKIGdl bmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1n aXQgYS9hcmNoL3g4Ni90b29scy9yZWxvY3MuYyBiL2FyY2gveDg2L3Rvb2xzL3JlbG9jcy5jCmlu ZGV4IDczZWI3ZmQ0YWVjNC4uZjk2ZmEyZGRmN2M5IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni90b29s cy9yZWxvY3MuYworKysgYi9hcmNoL3g4Ni90b29scy9yZWxvY3MuYwpAQCAtNjgsNiArNjgsOCBA QCBzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHN5bV9yZWdleF9rZXJuZWxbU19OU1lNVFlQRVNd ID0gewogCSJfX2VuZF9yb2RhdGF8IgogCSJfX2luaXRyYW1mc19zdGFydHwiCiAJIihqaWZmaWVz fGppZmZpZXNfNjQpfCIKKwkiLnJvZGF0YS4ucm5nLip8IgorCSIuaW5pdC50ZXh0Li5ybmcuKnwi CiAjaWYgRUxGX0JJVFMgPT0gNjQKIAkiX19wZXJfY3B1X2xvYWR8IgogCSJpbml0X3Blcl9jcHVf Xy4qfCIKZGlmZiAtLWdpdCBhL2FyY2gveHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gv eHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA3ODc5YzMxZTY2YTcuLjJiN2ZlNDhjMDIy NSAxMDA2NDQKLS0tIGEvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gv eHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMzMsMyArMzMsNCBAQCBnZW5lcmljLXkgKz0g dHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSAr PSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2Vz LmgKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvcmFuZ2VzLmggYi9pbmNsdWRlL2Fz bS1nZW5lcmljL3Jhbmdlcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAw MC4uNzVjMTk2ODY0ZjQ1Ci0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9y YW5nZXMuaApAQCAtMCwwICsxLDkzIEBACisjaWZuZGVmIF9BU01fR0VORVJJQ19SQU5HRVNfSF8K KyNkZWZpbmUgX0FTTV9HRU5FUklDX1JBTkdFU19IXworLyoKKyAqIENvcHlyaWdodCAoQykgMjAx NiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNncm9mQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9n cmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2Rp ZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiBjb3B5bGVmdC1uZXh0ICh2ZXJzaW9uIDAuMy4x IG9yIGxhdGVyKSBhcyBwdWJsaXNoZWQKKyAqIGF0IGh0dHA6Ly9jb3B5bGVmdC1uZXh0Lm9yZy8u CisgKi8KKyNpbmNsdWRlIDxhc20vc2VjdGlvbi1jb3JlLmg+CisKKyNpZm5kZWYgc2V0X3NlY3Rp b25fcm5nCisjIGRlZmluZSBzZXRfc2VjdGlvbl9ybmcoc2VjdGlvbiwgbmFtZSwgZmxhZ3MpCQkJ CVwKKwkgc2V0X3NlY3Rpb25fY29yZShzZWN0aW9uLCBybmcsIG5hbWUsCQkJCVwKKwkJCSAgYW55 LCBmbGFncykKKyNlbmRpZgorCisjaWZuZGVmIHNldF9zZWN0aW9uX3JuZ190eXBlCisjIGRlZmlu ZSBzZXRfc2VjdGlvbl9ybmdfdHlwZShzZWN0aW9uLCBuYW1lLCBmbGFncywgdHlwZSkJCVwKKwkg c2V0X3NlY3Rpb25fY29yZV90eXBlKHNlY3Rpb24sIHJuZywgbmFtZSwJCQlcCisJCQkgICAgICAg YW55LCBmbGFncywgdHlwZSkKKyNlbmRpZgorCisjaWZuZGVmIHNldF9zZWN0aW9uX3JuZ19sZXZl bAorIyBkZWZpbmUgc2V0X3NlY3Rpb25fcm5nX2xldmVsKHNlY3Rpb24sIG5hbWUsIGxldmVsLCBm bGFncykJCVwKKwkgc2V0X3NlY3Rpb25fY29yZShzZWN0aW9uLCBybmcsIG5hbWUsIGxldmVsLCBm bGFncykKKyNlbmRpZgorCisjaWZuZGVmIHB1c2hfc2VjdGlvbl9ybmcKKyMgZGVmaW5lIHB1c2hf c2VjdGlvbl9ybmcoc2VjdGlvbiwgbmFtZSwgZmxhZ3MpCQkJCVwKKwkgcHVzaF9zZWN0aW9uX2Nv cmUoc2VjdGlvbiwgcm5nLCBuYW1lLAkJCQlcCisJCQkgICBhbnksIGZsYWdzKQorI2VuZGlmCisK KyNpZm5kZWYgcHVzaF9zZWN0aW9uX3JuZ19sZXZlbAorIyBkZWZpbmUgcHVzaF9zZWN0aW9uX3Ju Z19sZXZlbChzZWN0aW9uLCBuYW1lLCBsZXZlbCwgZmxhZ3MpCQlcCisJIHB1c2hfc2VjdGlvbl9j b3JlKHNlY3Rpb24sIHJuZywgbmFtZSwJCQkJXAorCQkJICAgbGV2ZWwsIGZsYWdzKQorI2VuZGlm CisKKyNpZm5kZWYgX19BU1NFTUJMWV9fCisvKioKKyAqIF9fTElOVVhfUkFOR0UgLSBzaG9ydCBo YW5kIGFzc29jaWF0aW9uIGludG8gYSBzZWN0aW9uIHJhbmdlCisgKgorICogQHNlY3Rpb246IEVM RiBzZWN0aW9uIG5hbWUgdG8gcGxhY2Ugc2VjdGlvbiByYW5nZSBpbnRvCisgKiBAbmFtZTogc2Vj dGlvbiByYW5nZSBuYW1lCisgKgorICogVGhpcyBoZWxwZXIgY2FuIGJlIHVzZWQgYnkgc3Vic3lz dGVtcyB0byBkZWZpbmUgdGhlaXIgb3duIHN1YnN5c3RlbQorICogc3BlY2lmaWMgaGVscGVycyB0 byBlYXNpbHkgYXNzb2NpYXRlIGEgcGllY2Ugb2YgY29kZSBiZWluZyBkZWZpbmVkIHRvIGEKKyAq IHNlY3Rpb24gcmFuZ2UuCisgKi8KKyNkZWZpbmUgX19MSU5VWF9SQU5HRShzZWN0aW9uLCBuYW1l KQkJCQkJXAorCV9fYXR0cmlidXRlX18oKF9fc2VjdGlvbl9fKCNzZWN0aW9uICIuLnJuZy5uYW1l LmFueSIpKSkKKworLyoqCisgKiBfX0xJTlVYX1JBTkdFX09SREVSIC0gc2hvcnQgaGFuZCBhc3Nv Y2lhdGlvbiBpbnRvIGEgc2VjdGlvbiByYW5nZSBvZiBvcmRlcgorICoKKyAqIEBzZWN0aW9uOiBF TEYgc2VjdGlvbiBuYW1lIHRvIHBsYWNlIHNlY3Rpb24gcmFuZ2UgaW50bworICogQG5hbWU6IHNl Y3Rpb24gcmFuZ2UgbmFtZQorICogQGxldmVsOiBvcmRlciBsZXZlbCwgYSBudW1iZXIuIFRoZSBv cmRlciBsZXZlbCBnZXRzIHR1Y2tlZCBpbnRvIHRoZQorICoJc2VjdGlvbiBhcyBhIHBvc3RmaXgg c3RyaW5nLiBPcmRlciBsZXZlbHMgYXJlIHNvcnRlZCB1c2luZworICogCWJpbnV0aWxzIFNPUlQo KSwgdGhlIG51bWJlciBpcyBzb3J0ZWQgYXMgYSBzdHJpbmcsIGFzIHN1Y2ggYmUKKyAqIAlzdXJl IHRvIGZpbGwgd2l0aCB6ZXJvZXMgYW55IGVtcHR5IGRpZ2l0cy4gRm9yIGluc3RhbmNlIGlmIHlv dSBhcmUKKyAqIAl1c2luZyAzIGxldmVscyBvZiBkaWdpdHMgZm9yIG9yZGVyIGxldmVscywgdXNl IDAwMSBmb3IgdGhlIGZpcnN0IGVudHJ5LAorICogCTAwMDIgZm9yIHRoZSBzZWNvbmQsIDk5OSBm b3IgdGhlIGxhc3QgZW50cnkuIFlvdSBjYW4gdXNlIGhvd2V2ZXIgbWFueQorICogCWRpZ2l0cyB5 b3UgbmVlZC4KKyAqCisgKiBUaGlzIGhlbHBlciBjYW4gYmUgdXNlZCBieSBzdWJzeXN0ZW1zIHRv IGRlZmluZSB0aGVpciBvd24gc3Vic3lzdGVtIHNwZWNpZmljCisgKiBoZWxwZXJzIHRvIGVhc2ls eSBhc3NvY2lhdGUgYSBwaWVjZSBvZiBjb2RlIGJlaW5nIGRlZmluZWQgdG8gYSBzZWN0aW9uIHJh bmdlCisgKiB3aXRoIGFuIGFzc29jaWF0ZWQgc3BlY2lmaWMgb3JkZXIgbGV2ZWwuIFRoZSBvcmRl ciBsZXZlbCBwcm92aWRlcyB0aGUKKyAqIGFiaWxpdHkgZm9yIGV4cGxpY2l0IHVzZXIgb3JkZXJp bmcgb2YgY29kZS4gU29ydGluZyB0YWtlcyBwbGFjZSBhdCBsaW5rCisgKiB0aW1lLCBhZnRlciBj b21waWxhdGlvbi4KKyAqLworI2RlZmluZSBfX0xJTlVYX1JBTkdFX09SREVSKHNlY3Rpb24sIG5h bWUsIGxldmVsKQkJCVwKKwlfX2F0dHJpYnV0ZV9fKChfX3NlY3Rpb25fXygjc2VjdGlvbiAiLi5y bmcubmFtZS4iICNsZXZlbCkpKQorCisjZW5kaWYgLyogX19BU1NFTUJMWV9fICovCisKKyNpZmRl ZiBfX0FTU0VNQkxFUl9fCisKKyNpZm5kZWYgREVGSU5FX1NFQ1RJT05fUkFOR0UKKyNkZWZpbmUg REVGSU5FX1NFQ1RJT05fUkFOR0Uoc2VjdGlvbiwgbmFtZSkJCQkJXAorICBwdXNoX3NlY3Rpb25f cm5nX2xldmVsKHNlY3Rpb24sIG5hbWUsLCkgOwkJCQlcCisgIC5nbG9ibCBuYW1lIDsJCQkJCQkJ CVwKK25hbWU6IDsJCQkJCQkJCQlcCisgIC5wb3BzZWN0aW9uCQkJCQkJCQlcCisJCQkJCQkJCQlc CisgIHB1c2hfc2VjdGlvbl9ybmdfbGV2ZWwoc2VjdGlvbiwgbmFtZSwgfiwpIDsJCQkJXAorICAu cG9wc2VjdGlvbgorI2VuZGlmCisjZW5kaWYgLyogX19BU1NFTUJMRVJfXyAqLworCisjZW5kaWYg LyogX0FTTV9HRU5FUklDX1JBTkdFU19IXyAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hc20tZ2Vu ZXJpYy9zZWN0aW9uLWNvcmUuaCBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgK aW5kZXggYmIxNmJlZmM0MjUxLi42NWZiMDc2NzY1ZjggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYXNt LWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKysrIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9u LWNvcmUuaApAQCAtMTgzLDYgKzE4Myw0NyBAQAogICogb3IgZGF0YSBzdHJ1Y3R1cmVzIHBhcnQg b2YgdGhlIGluaXQgc2VjdGlvbnMuCiAgKi8KIAorLyoqCisgKiBET0M6IExpbnV4IHNlY3Rpb24g b3JkZXJpbmcKKyAqCisgKiBMaW51eCBtYXkgdXNlIGJpbnV0aWxzIGxpbmtlci1zY3JpcHQgJ1NP UlQoKScgb24gc2VjdGlvbnMgdG8gc29ydCBMaW51eAorICogc2VjdGlvbnMgYWxwaGEgbnVtZXJp Y2FsbHkuIExpbnV4IGhhcyBoaXN0b3JpY2FsbHkgdXNlZCAnU09SVCgpJyBpbgorICogYGBpbmNs dWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmhgYCwgaXRzIGEgd2VsbCBlc3RhYmxpc2hlZCBw cmFjdGljZS4gSWYKKyAqICdTT1JUKCknIGlzIHVzZWQgb24gYSBzZWN0aW9uIG9uZSBjYW4gcHJv dmlkZSBvcmRlcmluZyB1c2luZyBhIHBvc3RmaXggb24KKyAqIGVhY2ggc2VjdGlvbiBlbnRyeSBh ZGRlZC4gRm9yIGluc3RhbmNlIGlmIGEgbGlua2VyIHNjcmlwdCB1c2VzOjoKKyAqCisgKiAgICBT T1JUKC5mb28uKikKKyAqCisgKiBvbmUgY2FuIHRoZW4gYWRkIGVudHJpZXMgd2l0aCBleHBsaWNp dCBvcmRlcmluZyB1c2luZyBudW1lcmljIHBvc3RmaXhlcyBmb3IKKyAqIGVhY2ggZW50cnksIHdl IHJlZmVyIHRvIHRoZXNlIGFzICdvcmRlciBsZXZlbHMnLiBTaW5jZSAnU09SVCgpJyBzb3J0cyBh bHBoYQorICogbnVtZXJpY2FsbHkgYSBzcGVjaWZpYyBzZXJpZXMgc2V0IG9mIGRpZ2l0cyBtdXN0 IGJlIGFncmVlZCBhLXByaW9yaSB3aGljaAorICogd291bGQgZ2l2ZSBhbHNvIGFuIGlkZWEgb2Yg dGhlIG1heCBleHBlY3RlZCBudW1iZXIgb2YgZW50cmllcyBhZGRlZCB0byBhCisgKiBzZWN0aW9u LiBGb3IgaW5zdGFuY2UsIGlmIHlvdSBleHBlY3QgYSBtYXhpbXVtIG9mIDk5OSBlbnRyaWVzIHlv dSBjYW4gdXNlCisgKiAzIGRpZ2l0cyBmb3IgYSBzZWN0aW9uIG9yZGVyIGxldmVsLiBJZiB5b3Ug d2FudGVkIGFuIGVudHJ5IHRvIGJlIG9yZGVyZWQKKyAqIGZpcnN0IHlvdSBjb3VsZCB1c2UgdGhl IHBvc3RmaXggJzAwMCcsIGlmIHlvdSB3YW50ZWQgYW4gZW50cnkgdG8gZm9sbG93IHRoaXMKKyAq IHlvdSBjb3VsZCB1c2UgJzAwMScsIGFuZCBzbyBvbi4gV2UgY291bGQgZm9yIGluc3RhbmNlIGhh dmU6OgorICoKKyAqICAgIC5mb28uMDAwCisgKiAgICAuZm9vLjAwMQorICogICAgLmZvby4wMDIK KyAqCisgKiBPZnRlbiB0aW1lcyBvbmUgbWF5IHdhbnQgdGhlIG9wdGlvbiB0byBzcGVjaWZ5IG5v IG9yZGVyIGlzIHJlcXVpcmVkIGZvcgorICogY2VydGFpbiBlbGVtZW50cyBhZGRlZCB0byBhIHNl Y3Rpb24gd2hpY2ggZG9lcyB1c2UgJ1NPUlQoKScgb24gdGhlIGxpbmtlcgorICogc2NyaXB0LiBZ b3UgY2FuIHVzZSBhbnkgYXJiaXRyYXJ5IHN0cmluZyB2YWx1ZSB0byB0byBzcGVjaWZ5IG5vIG9y ZGVyIGlzCisgKiB1c2VkLCBzbyBsb25nIGFzIGl0cyB1c2VkIGNvbnNpc3RhbnRseS4gRm9yIGlu c3RhbmNlLCBvbmUgcG9zc2liaWxpdHkgaXMgdG8KKyAqIHVzZSB0aGUgJ2FueScgcG9zdGZpeC4g IEFsbCBlbnRyaWVzIG9uIHRoZSBzZWN0aW9uIHdvdWxkIHRoZW4gaGF2ZSBubworICogc3BlY2lm aWMgb3JkZXJpbmc6OgorICoKKyAqICAgIC5mb28uYW55CisgKiAgICAuZm9vLmFueQorICogICAg LmZvby5hbnkKKyAqCisgKiBUbyBoZWxwIGVzdGFibGlzaCBhIGNvbnZlbnRpb24gd2UgcmVzZXJ2 ZSB0aGUgc3BlY2lhbCBuYW1lICdhbnknIGZvciB0aGlzCisgKiBwdXJwb3NlLiBEZXZlbG9wZXJz IGNhbiB1c2UgYW5kIGV4cGVjdCB0aGUgJ2FueScgcG9zdGZpeCBzdHJpbmcgb24gc2VjdGlvbnMK KyAqIGFzIGEgaGVscGVyIHRvIGFubm90YXRlIHNlY3Rpb24gb3JkZXJpbmcgYXQgbGluayB0aW1l IGlzIG5vdCByZWxldmFudAorICogZm9yIGVudHJpZXMgb24gYSBzZWN0aW9uLgorICovCisKIC8q IENhbiBiZSB1c2VkIG9uIGZvby5TIGZvciBpbnN0YW5jZSAqLwogI2lmbmRlZiBfX3NldF9zZWN0 aW9uX2NvcmVfdHlwZQogIyBkZWZpbmUgX19zZXRfc2VjdGlvbl9jb3JlX3R5cGUoX19fc2VjdGlv biwgX19fY29yZSwgX19fbmFtZSwJCVwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMv dm1saW51eC5sZHMuaCBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaAppbmRleCA0 ODNmNjBjNDUxZjkuLjcxYmZkM2IzYzcxOSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hc20tZ2VuZXJp Yy92bWxpbnV4Lmxkcy5oCisrKyBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaApA QCAtNTYsNiArNTYsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvZXhwb3J0Lmg+CiAjaW5jbHVkZSA8 YXNtL3NlY3Rpb24tY29yZS5oPgorI2luY2x1ZGUgPGFzbS9yYW5nZXMuaD4KIAogLyogQWxpZ24g LiB0byBhIDggYnl0ZSBib3VuZGFyeSBlcXVhbHMgdG8gbWF4aW11bSBmdW5jdGlvbiBhbGlnbm1l bnQuICovCiAjZGVmaW5lIEFMSUdOX0ZVTkNUSU9OKCkgIC4gPSBBTElHTig4KQpAQCAtMjA1LDYg KzIwNiw3IEBACiAgKi8KICNkZWZpbmUgREFUQV9EQVRBCQkJCQkJCVwKIAkqKC5kYXRhIC5kYXRh LlswLTlhLXpBLVpfXSopCQkJCQlcCisJKihTT1JUKC5kYXRhLi5ybmcuKikpCQkJCQkJXAogCSoo LnJlZi5kYXRhKQkJCQkJCQlcCiAJKiguZGF0YS4uc2hhcmVkX2FsaWduZWQpIC8qIHBlcmNwdSBy ZWxhdGVkICovCQkJXAogCU1FTV9LRUVQKGluaXQuZGF0YSkJCQkJCQlcCkBAIC0yNzMsNyArMjc1 LDkgQEAKIAkuID0gQUxJR04oKGFsaWduKSk7CQkJCQkJXAogCS5yb2RhdGEgICAgICAgICAgIDog QVQoQUREUigucm9kYXRhKSAtIExPQURfT0ZGU0VUKSB7CQlcCiAJCVZNTElOVVhfU1lNQk9MKF9f c3RhcnRfcm9kYXRhKSA9IC47CQkJXAotCQkqKC5yb2RhdGEpICooLnJvZGF0YS4qKQkJCQkJXAor CQkqKC5yb2RhdGEpCQkJCQkJXAorCQkqKFNPUlQoLnJvZGF0YS4ucm5nLiopKQkJCQkJXAorCQkq KC5yb2RhdGEuKikJCQkJCQlcCiAJCVJPX0FGVEVSX0lOSVRfREFUQQkvKiBSZWFkIG9ubHkgYWZ0 ZXIgaW5pdCAqLwlcCiAJCUtFRVAoKihfX3Zlcm1hZ2ljKSkJLyogS2VybmVsIHZlcnNpb24gbWFn aWMgKi8JXAogCQkuID0gQUxJR04oOCk7CQkJCQkJXApAQCAtNDQ2LDcgKzQ1MCw5IEBACiAgKiBj b25mbGljdGluZyBzZWN0aW9uIG5hbWVzLCBhbmQgbXVzdCBwdWxsIGluIC50ZXh0LlswLTlhLXpB LVpfXSogKi8KICNkZWZpbmUgVEVYVF9URVhUCQkJCQkJCVwKIAkJQUxJR05fRlVOQ1RJT04oKTsJ CQkJCVwKLQkJKigudGV4dC5ob3QgLnRleHQgLnRleHQuZml4dXAgLnRleHQudW5saWtlbHkpCQlc CisJCSooLnRleHQuaG90IC50ZXh0KQkJCQkJXAorCQkqKFNPUlQoLnRleHQuLnJuZy4qKSkJCQkJ CVwKKwkJKigudGV4dC5maXh1cCAudGV4dC51bmxpa2VseSkJCQkJXAogCQkqKC5yZWYudGV4dCkJ CQkJCQlcCiAJTUVNX0tFRVAoaW5pdC50ZXh0KQkJCQkJCVwKIAlNRU1fS0VFUChleGl0LnRleHQp CQkJCQkJXApAQCAtNTQ5LDYgKzU1NSw3IEBACiAjZGVmaW5lIElOSVRfREFUQQkJCQkJCQlcCiAJ S0VFUCgqKFNPUlQoX19fa2VudHJ5KyopKSkJCQkJCVwKIAkqKC5pbml0LmRhdGEpCQkJCQkJCVwK KwkqKFNPUlQoLmluaXQuZGF0YS4ucm5nLiopKQkJCQkJXAogCU1FTV9ESVNDQVJEKGluaXQuZGF0 YSkJCQkJCQlcCiAJS0VSTkVMX0NUT1JTKCkJCQkJCQkJXAogCU1DT1VOVF9SRUMoKQkJCQkJCQlc CkBAIC01NzIsNiArNTc5LDcgQEAKIAogI2RlZmluZSBJTklUX1RFWFQJCQkJCQkJXAogCSooLmlu aXQudGV4dCkJCQkJCQkJXAorCSooU09SVCguaW5pdC50ZXh0Li5ybmcuKikpCQkJCQlcCiAJKigu dGV4dC5zdGFydHVwKQkJCQkJCVwKIAlNRU1fRElTQ0FSRChpbml0LnRleHQpCiAKZGlmZiAtLWdp dCBhL2luY2x1ZGUvbGludXgvcmFuZ2VzLmggYi9pbmNsdWRlL2xpbnV4L3Jhbmdlcy5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMWU2NDY3NGY2ZDdkCi0tLSAvZGV2 L251bGwKKysrIGIvaW5jbHVkZS9saW51eC9yYW5nZXMuaApAQCAtMCwwICsxLDE4MyBAQAorI2lm bmRlZiBfTElOVVhfUkFOR0VTX0gKKyNkZWZpbmUgX0xJTlVYX1JBTkdFU19ICisvKgorICogTGlu dXggc2VjdGlvbiByYW5nZXMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgTHVpcyBSLiBSb2Ry aWd1ZXogPG1jZ3JvZkBrZXJuZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNv ZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRl ciB0aGUgdGVybXMgb2YgY29weWxlZnQtbmV4dCAodmVyc2lvbiAwLjMuMSBvciBsYXRlcikgYXMg cHVibGlzaGVkCisgKiBhdCBodHRwOi8vY29weWxlZnQtbmV4dC5vcmcvLgorICovCisjaW5jbHVk ZSA8bGludXgvc2VjdGlvbnMuaD4KKyNpbmNsdWRlIDxhc20vcmFuZ2VzLmg+CisKKyNpZm5kZWYg X19BU1NFTUJMWV9fCisKKy8qKgorICogRE9DOiBJbnRyb2R1Y3Rpb24KKyAqCisgKiBBIHNlY3Rp b24gcmFuZ2VzIGNvbnNpc3RzIG9mIGV4cGxpY2l0bHkgYW5ub3RhdGVkIHNlcmllcyBleGVjdXRh YmxlIGNvZGUKKyAqIHN0aXRjaGVkIHRvZ2V0aGVyIGZvciB0aGUgcHVycG9zZSBvZiBzZWxlY3Rp dmUgcGxhY2VtZW50IGludG8gc3RhbmRhcmQgb3IKKyAqIGFyY2hpdGVjdHVyZSBzcGVjaWZpYyBF TEYgc2VjdGlvbnMuIFdoYXQgRUxGIHNlY3Rpb24gaXMgdXNlZCBpcyB1dGlsaXR5CisgKiBzcGVj aWZpYy4gTGludXggaGFzIGhpc3RvcmljYWxseSBpbXBsaWNpdGx5IHVzZWQgc2VjdGlvbiByYW5n ZXMsIGhvd2V2ZXIKKyAqIHRoZXkgd2VyZSBhbGwgYnVpbHQgaW4gYW4gYWRob2MgbWFubmVyIGFu ZCB0eXBpY2FsbHkgcmVxdWlyZWQgbGlua2VyIHNjcmlwdAorICogbW9kaWZpY2F0aW9ucyBwZXIg YXJjaGl0ZWN0dXJlLiBUaGUgc2VjdGlvbiByYW5nZSBBUEkgYWxsb3dzIGFkZGluZyBuZXcKKyAq IGJ1bmRsZXMgb2Ygc3RpY2hlZCBleGVjdXRhYmxlIGNvZGUgaW50byBjdXN0b20gRUxGIHNlY3Rp b25zIGJ5IG9ubHkKKyAqIG1vZGlmeWluZyBDIG9yIGFzbSBjb2RlIGluIGFuIGFyY2hpdGVjdHVy ZSBhZ25vc3RpYyBmb3JtLgorICoKKyAqIFRoaXMgZG9jdW1lbnRzIHRoZSBzZXQgb2YgaGVscGVy cyBhdmFpbGFibGUgdG8gZGVjbGFyZSwgYW5kIGRlZmluZSBzZWN0aW9uCisgKiByYW5nZXMgYW5k IGFzc29jaWF0ZSBlYWNoIHNlY3Rpb24gcmFuZ2UgdG8gYSBzcGVjaWZpYyBMaW51eCBFTEYgc2Vj dGlvbi4KKyAqLworCisvKioKKyAqIERPQzogU2VjdGlvbiByYW5nZSBtb2R1bGUgc3VwcG9ydAor ICoKKyAqIE1vZHVsZXMgY2FuIHVzZSBzZWN0aW9uIHJhbmdlcywgaG93ZXZlciB0aGUgc2VjdGlv biByYW5nZSBkZWZpbml0aW9uIG11c3QgYmUKKyAqIGJ1aWx0LWluIHRvIHRoZSBrZXJuZWwuIFRo YXQgaXMsIHRoZSBjb2RlIHRoYXQgaW1wbGVtZW50cworICogREVGSU5FX1NFQ1RJT05fUkFOR0Uo KSBtdXN0IGJlIGJ1aWx0LWluLCBhbmQgbW9kdWxhciBjb2RlIGNhbm5vdCBhZGQgbW9yZQorICog aXRlbXMgaW4gdG8gdGhlIHNlY3Rpb24gcmFuZ2UgKHdpdGggX19MSU5VWF9SQU5HRSgpIG9yCisg KiBfX0xJTlVYX1JBTkdFX09SREVSKCkpLCB1bmxlc3Mga2VybmVsL21vZHVsZS5jIGZpbmRfbW9k dWxlX3NlY3Rpb25zKCkgYW5kCisgKiBtb2R1bGUtY29tbW9uLmxkcy5TIGFyZSB1cGRhdGVkIGFj Y29yZGluZ2x5IHdpdGggYSByZXNwZWN0aXZlIG1vZHVsZQorICogbm90aWZpZXIgdG8gYWNjb3Vu dCBmb3IgdXBkYXRlcy4gVGhpcyByZXN0cmljdGlvbiBtYXkgYmUgZW5oYW5jZWQgaW4gdGhlCisg KiBmdXR1cmUuCisgKi8KKworLyoqCisgKiBET0M6IFNlY3Rpb24gcmFuZ2UgaGVscGVycworICoK KyAqIFRoZXNlIGFyZSBoZWxwZXJzIGZvciBzZWN0aW9uIHJhbmdlcy4KKyAqLworCisvKioKKyAq IFNFQ1RJT05fUkFOR0VfU1RBUlQgLSBnZXQgYWRkcmVzcyBvZiBzdGFydCBvZiBzZWN0aW9uIHJh bmdlCisgKgorICogQG5hbWU6IG5hbWUgb2YgdGhlIHNlY3Rpb24gcmFuZ2UKKyAqCisgKiBUaGlz IGdpdmVzIHlvdSB0aGUgc3RhcnQgYWRkcmVzcyBvZiB0aGUgc2VjdGlvbiByYW5nZS4KKyAqIFRo aXMgc2hvdWxkIGdpdmUgeW91IHRoZSBhZGRyZXNzIG9mIHRoZSBmaXJzdCBlbnRyeS4KKyAqCisg Ki8KKyNkZWZpbmUgU0VDVElPTl9SQU5HRV9TVEFSVChuYW1lKQlMSU5VWF9TRUNUSU9OX1NUQVJU KG5hbWUpCisKKy8qKgorICogU0VDVElPTl9SQU5HRV9FTkQgLSBnZXQgYWRkcmVzcyBvZiBlbmQg b2YgdGhlIHNlY3Rpb24gcmFuZ2UKKyAqCisgKiBAbmFtZTogbmFtZSBvZiB0aGUgc2VjdGlvbiBy YW5nZQorICoKKyAqIFRoaXMgZ2l2ZXMgeW91IHRoZSBlbmQgYWRkcmVzcyBvZiB0aGUgbGlua2Vy IHRhYmxlLgorICogVGhpcyB3aWxsIG1hdGNoIHRoZSBzdGFydCBhZGRyZXNzIGlmIHRoZSBsaW5r ZXIgdGFibGUKKyAqIGlzIGVtcHR5LgorICovCisjZGVmaW5lIFNFQ1RJT05fUkFOR0VfRU5EKG5h bWUpCQlMSU5VWF9TRUNUSU9OX0VORChuYW1lKQorCisvKioKKyAqIFNFQ1RJT05fUkFOR0VfU0la RSAtIGdldCBudW1iZXIgb2YgZW50cmllcyBpbiB0aGUgc2VjdGlvbiByYW5nZQorICoKKyAqIEBu YW1lOiBuYW1lIG9mIHRoZSBzZWN0aW9uIHJhbmdlCisgKgorICogVGhpcyBnaXZlcyB5b3UgdGhl IG51bWJlciBvZiBlbnRyaWVzIGluIHRoZSBzZWN0aW9uIHJhbmdlLgorICogRXhhbXBsZSB1c2Fn ZToKKyAqCisgKiAgIHVuc2lnbmVkIGludCBudW1fZW50cyA9IExJTktUQUJMRV9TSVpFKHNvbWVf Zm5zKTsKKyAqLworI2RlZmluZSBTRUNUSU9OX1JBTkdFX1NJWkUobmFtZSkJCQkJCVwKKwkoKFNF Q1RJT05fUkFOR0VfRU5EKG5hbWUpKSAtIChTRUNUSU9OX1JBTkdFX1NUQVJUKG5hbWUpKSkKKwor LyoqCisgKiBTRUNUSU9OX1JBTkdFX0VNUFRZIC0gY2hlY2sgaWYgc2VjdGlvbiByYW5nZSBoYXMg bm8gZW50cmllcworICoKKyAqIEBuYW1lOiBuYW1lIG9mIHRoZSBzZWN0aW9uIHJhbmdlCisgKgor ICogUmV0dXJucyB0cnVlIGlmIHRoZSBzZWN0aW9uIHJhbmdlIGlzIGVtdHB5LgorICoKKyAqICAg Ym9vbCBpc19lbXB0eSA9IExJTktUQUJMRV9FTVBUWShzb21lX2Zucyk7CisgKi8KKyNkZWZpbmUg U0VDVElPTl9SQU5HRV9FTVBUWShuYW1lKQkoU0VDVElPTl9SQU5HRV9TSVpFKG5hbWUpID09IDAp CisKKy8qKgorICogU0VDVElPTl9SQU5HRV9BRERSX1dJVEhJTiAtIHJldHVybnMgdHJ1ZSBpZiBh ZGRyZXNzIGlzIGluIHRoZSBzZWN0aW9uIHJhbmdlCisgKgorICogQG5hbWU6IG5hbWUgb2YgdGhl IHNlY3Rpb24gcmFuZ2UKKyAqIEBhZGRyOiBhZGRyZXNzIHRvIHF1ZXJ5IGZvcgorICoKKyAqIFJl dHVybnMgdHJ1ZSBpZiB0aGUgYWRkcmVzcyBpcyBpbiB0aGUgc2VjdGlvbiByYW5nZS4KKyAqLwor I2RlZmluZSBTRUNUSU9OX1JBTkdFX0FERFJfV0lUSElOKG5hbWUsIGFkZHIpCQkJCVwKKwkgKGFk ZHIgPj0gKHVuc2lnbmVkIGxvbmcpIFNFQ1RJT05fUkFOR0VfU1RBUlQobmFtZSkgJiYJCVwKKyAg ICAgICAgICBhZGRyIDwgKHVuc2lnbmVkIGxvbmcpIFNFQ1RJT05fUkFOR0VfRU5EKG5hbWUpKQor CisvKioKKyAqIFNFQ1RJT05fUkFOR0VfQUxJR05NRU5UIC0gZ2V0IHRoZSBhbGlnbm1lbnQgb2Yg dGhlIHNlY3Rpb24gcmFuZ2UKKyAqCisgKiBAbmFtZTogbmFtZSBvZiBsaW5rZXIgdGFibGUKKyAq CisgKiBHaXZlcyB5b3UgdGhlIGFsaWdubWVudCBmb3IgdGhlIHNlY3Rpb24gcmFuZ2UuCisgKi8K KyNkZWZpbmUgU0VDVElPTl9SQU5HRV9BTElHTk1FTlQobmFtZSkJTElOVVhfU0VDVElPTl9BTElH Tk1FTlQobmFtZSkKKworLyoqCisgKiBERUNMQVJFX1NFQ1RJT05fUkFOR0UgLSBEZWNsYXJlcyBh IHNlY3Rpb24gcmFuZ2UKKyAqCisgKiBAbmFtZTogc2VjdGlvbiByYW5nZSBuYW1lCisgKgorICog RGVjbGFyZXMgYSBzZWN0aW9uIHJhbmdlIHRvIGhlbHAgY29kZSBhY2Nlc3MgdGhlIHJhbmdlLiBU eXBpY2FsbHkgaWYKKyAqIGEgc3Vic3lzdGVtcyBuZWVkcyBjb2RlIHRvIGhhdmUgZGlyZWN0IGFj Y2VzcyB0byB0aGUgc2VjdGlvbiByYW5nZSB0aGUKKyAqIHN1YnN5c3RlbSdzIGhlYWRlciBmaWxl IHdvdWxkIGRlY2xhcmUgdGhlIHNlY3Rpb24gcmFuZ2UuIENhcmUgc2hvdWxkIGJlCisgKiB0YWtl biB0byBvbmx5IGRlY2xhcmUgdGhlIHNlY3Rpb24gcmFuZ2UgaW4gYSBoZWFkZXIgZmlsZSBpZiBh Y2Nlc3MgdG8gaXQKKyAqIGlzIHRydWx5IG5lZWRlZCBvdXRzaWRlIG9mIHRoZSBjb2RlIGRlZmlu aW5nIGl0LiBZb3UgdHlwaWNhbGx5IHdvdWxkCisgKiByYXRoZXIgaW5zdGVhZCBwcm92aWRlIGhl bHBlcnMgd2hpY2ggYWNjZXNzIHRoZSBzZWN0aW9uIHJhbmdlIHdpdGggc3BlY2lhbAorICogY29k ZSBvbiBiZWhhbGYgb2YgdGhlIGNhbGxlci4KKyAqLworI2RlZmluZSBERUNMQVJFX1NFQ1RJT05f UkFOR0UobmFtZSkJCQkJCVwKKwlERUNMQVJFX0xJTlVYX1NFQ1RJT05fUk8oY2hhciwgbmFtZSkK KworLyoqCisgKiBfX1NFQ1RJT05fUkFOR0VfQkVHSU4gLSBDb25zdHJ1Y3RzIHRoZSBiZWdpbm5p bmcgb2YgYSBzZWN0aW9uIHJhbmdlCisgKgorICogQG5hbWU6IHNlY3Rpb24gcmFuZ2UgbmFtZQor ICogQF9fc2VjdGlvbjogRUxGIHNlY3Rpb24gdG8gcGxhY2Ugc2VjdGlvbiByYW5nZSBpbnRvCisg KgorICogQ29uc3RydWN0cyB0aGUgYmVnaW5uaW5nIG9mIGEgc2VjdGlvbiByYW5nZS4gWW91IHdp bGwgdHlwaWNhbGx5IG5vdCBuZWVkCisgKiB0byB1c2UgdGhpcyBkaXJlY3RseS4KKyAqLworI2Rl ZmluZSBfX1NFQ1RJT05fUkFOR0VfQkVHSU4obmFtZSwgX19zZWN0aW9uKQkJCQlcCisJY29uc3Qg X190eXBlb2ZfXyhTRUNUSU9OX1JBTkdFX1NUQVJUKG5hbWUpWzBdKQkJCVwKKwkgICAgICBfX2F0 dHJpYnV0ZV9fKCh1c2VkLAkJCQkJXAorCQkJICAgICB3ZWFrLAkJCQkJXAorCQkJICAgICBfX2Fs aWduZWRfXyhTRUNUSU9OX1JBTkdFX0FMSUdOTUVOVChuYW1lKSksXAorCQkJICAgICBzZWN0aW9u KCNfX3NlY3Rpb24gIi4ucm5nLm5hbWUuIikpKQorCisvKioKKyAqIF9fU0VDVElPTl9SQU5HRV9F TkQgLSBDb25zdHJ1Y3RzIHRoZSBlbmQgb2YgYSBzZWN0aW9uIHJhbmdlCisgKgorICogQG5hbWU6 IHNlY3Rpb24gcmFuZ2UgbmFtZQorICogQF9fc2VjdGlvbjogRUxGIHNlY3Rpb24gdG8gcGxhY2Ug c2VjdGlvbiByYW5nZSBpbnRvCisgKgorICogQ29uc3RydWN0cyB0aGUgZW5kIG9mIGEgc2VjdGlv biByYW5nZS4gWW91IHdpbGwgdHlwaWNhbGx5IG5vdCBuZWVkCisgKiB0byB1c2UgdGhpcyBkaXJl Y3RseS4KKyAqLworI2RlZmluZSBfX1NFQ1RJT05fUkFOR0VfRU5EKG5hbWUsIF9fc2VjdGlvbikJ CQkJXAorCWNvbnN0IF9fdHlwZW9mX18oU0VDVElPTl9SQU5HRV9TVEFSVChuYW1lKVswXSkJCQlc CisJICAgICAgX19hdHRyaWJ1dGVfXygodXNlZCwJCQkJCVwKKwkJCSAgICAgX19hbGlnbmVkX18o U0VDVElPTl9SQU5HRV9BTElHTk1FTlQobmFtZSkpLFwKKwkJCSAgICAgc2VjdGlvbigjX19zZWN0 aW9uICIuLnJuZy5uYW1lLn4iKSkpCisKKy8qKgorICogREVGSU5FX1NFQ1RJT05fUkFOR0UgLSBE ZWZpbmVzIGEgc2VjdGlvbiByYW5nZQorICoKKyAqIEBuYW1lOiBzZWN0aW9uIHJhbmdlIG5hbWUK KyAqIEBzZWN0aW9uOiBFTEYgc2VjdGlvbiBuYW1lIHRvIHBsYWNlIHNlY3Rpb24gcmFuZ2UgaW50 bworICoKKyAqIERlZmluZXMgYSBzZWN0aW9uIHJhbmdlLCB1c2VkIGZvciBleGVjdXRhYmxlIGNv ZGUuIFNlY3Rpb24gcmFuZ2VzIGFyZQorICogZGVmaW5lZCBpbiB0aGUgY29kZSB0aGF0IHRha2Vz IG93bmVyc2hpcCBhbmQgbWFrZXMgdXNlIG9mIHRoZSBzZWN0aW9uCisgKiByYW5nZS4KKyAqLwor I2RlZmluZSBERUZJTkVfU0VDVElPTl9SQU5HRShuYW1lLCBzZWN0aW9uKQkJCQlcCisJREVDTEFS RV9MSU5VWF9TRUNUSU9OX1JPKGNoYXIsIG5hbWUpOwkJCQlcCisJX19TRUNUSU9OX1JBTkdFX0JF R0lOKG5hbWUsIHNlY3Rpb24pIFNFQ1RJT05fUkFOR0VfU1RBUlQobmFtZSlbMF0gPSB7fTtcCisJ X19TRUNUSU9OX1JBTkdFX0VORChuYW1lLCBzZWN0aW9uKSBTRUNUSU9OX1JBTkdFX0VORChuYW1l KVswXSA9IHt9CisKKyNlbmRpZiAvKiBfX0FTU0VNQkxZX18gKi8KKworI2VuZGlmIC8qIF9MSU5V WF9SQU5HRVNfSCAqLwotLSAKMi4xMS4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMu eGVuLm9yZwpodHRwczovL2xpc3RzLnhlbi5vcmcveGVuLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:52226 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S968066AbdAIO7G (ORCPT ); Mon, 9 Jan 2017 09:59:06 -0500 From: "Luis R. Rodriguez" Subject: [PATCH v6 03/14] ranges.h: add helpers to build and identify Linux section ranges Date: Mon, 9 Jan 2017 06:58:21 -0800 Message-ID: <20170109145833.11502-4-mcgrof@kernel.org> In-Reply-To: <20170109145833.11502-1-mcgrof@kernel.org> References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> Sender: linux-arch-owner@vger.kernel.org List-ID: To: hpa@zytor.com, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com, dalias@libc.org, linux@arm.linux.org.uk Cc: x86@kernel.org, luto@amacapital.net, keescook@chromium.org, linux@roeck-us.net, torvalds@linux-foundation.org, gregkh@linuxfoundation.org, rusty@rustcorp.com.au, gnomes@lxorguk.ukuu.org.uk, alan@linux.intel.com, dwmw2@infradead.org, arnd@arndb.de, ming.lei@canonical.com, linux-arch@vger.kernel.org, benh@kernel.crashing.org, pebolle@tiscali.nl, fontana@sharpeleven.org, david.vrabel@citrix.com, konrad.wilk@oracle.com, mcb30@ipxe.org, jgross@suse.com, andrew.cooper3@citrix.com, andriy.shevchenko@linux.intel.com, paul.gortmaker@windriver.com, xen-devel@lists.xensource.com, ak@linux.intel.com, pali.rohar@gmail.com, dvhart@infradead.org, platform-driver-x86@vger.kernel.org, mmarek@suse.com, linux@rasmusvillemoes.dk, jkosina@suse.cz, korea.drzix@gmail.com, linux-kbuild@vger.kernel.org, tony.luck@intel.com, akpm@linux-foundation.org, linux-ia64@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sh@vger.kernel.org, sparclinux@vger.kernel.org, catalin.marinas@arm.com, will.deacon@arm.com, rostedt@goodmis.org, jani.nikula@intel.com, mchehab@osg.samsung.com, markus.heiser@darmarit.de, jolsa@kernel.org, msalter@redhat.com, chris@zankel.net, jcmvbkbc@gmail.com, linux-xtensa@linux-xtensa.org, adrian.hunter@intel.com, dsahern@gmail.com, namhyung@kernel.org, wangnan0@huawei.com, dmitry.torokhov@gmail.com, joro@8bytes.org, paulus@samba.org, mpe@ellerman.id.au, James.Bottomley@HansenPartnership.com, "Luis R. Rodriguez" Message-ID: <20170109145821.MlBboISsxOkZqSgJqnwIiQiDcA-VLjIsdt8qfrNrKlU@z> Section ranges are on one of the types of custom sections types used in Linux. This provides a series of helpers for defining them and using them. Most importantly this also enables us to avoid modifying the linker script when we add a new section range. It turns out a lot of custom sections are actually section ranges, and these are typically spelled out in their architecture specific asm/sections.h file -- we enable architectures to override what asm is used for section ranges but start by default trusting the asm-generic version all around. Although typically you will not want to have section ranges ordered we must use SORT() on vmlinux.lds.S for section ranges to enable us to extend a section range without modifying the linker script. To accomplish this we use a special order string for the first element of a section range -- the empty string "" (refer to __SECTION_RANGE_BEGIN()), then "~" for the last element (refer to __SECTION_RANGE_BEGIN()). If you use the "any" order for elements in between and use SORT() you end up keeping any added element in betweeen and a reference to the beginning and end of the section range without requiring custom linker script modifications. Specific order annotations are also supported to help construct synthetic functions, a demo for which will be provided later. v5: o Use ..rng.* instead of .rng.* as suggested by Nicholas Piggin. This is the typical way to avoid clash with compiler generated section. o Replace section macros with section names o Extend commit log to justify SORT() and explain why and how we use specific special strings for the beginning, end elements of a section range and the "any" order for elements in between. o Drop SECTION_RNG_ALL() -- we no longer need this on linker scripts o To make this easier to read, as per Nicholas Piggin, add our own SECTION_RANGE_START(), SECTION_RANGE_END(). After reviewing the changes affected by this it seemed clearer and better then to also use our own specific SECTION_RANGE_SIZE(), and SECTION_RANGE_EMPTY(), and SECTION_RANGE_ALIGNMENT() as well. o We were using LINUX_SECTION_START() and LINUX_SECTION_END() in some places but in some other places VMLINUX_SYMBOL(name), VMLINUX_SYMBOL(name##__end). Since we are adding SECTION_RANGE_START() and SECTION_RANGE_END() just use those consistently. o Move the linker table *(SORT(.data.rng.*)) to be present before the recently added *(.data.[0-9a-zA-Z_]*) to ensure we keep sort order on the section range. o Adds the "Linux section ordering" documentation, as its much more relevant after this patch, in particular when treating the "any" order level. o Fix powerpc .text use: -- it does not use TEXT_TEXT so we must add our *(SORT(.text.rng.*)) to its linker script manually. v4: o tons of documentation love o fix arch/x86/tools/relocs.c typo - which caused compilation issues on old toolchains o port to new shiny sphinx documentation o sprinkle a few more needed VMLINUX_SYMBOL() - fixes compilation on blackfin o name changes as suggested by Boris: - %s/SECTION_TYPE_RANGES/rng/g - %s/SECTION_TYPE/SECTION_CORE/g - %s/section_type_asmtype/section_core_type/g - %s/section_type/section_core/g - %s/section_rng/set_section_rng/g - rebrand DECLARE_SECTION_RNG() as DEFINE_SECTION_RANGE() - this is the asm version of the respective C version, this will have a userspace C demo added later. o move __LINUX_RANGE() and __LINUX_RANGE_ORDER() - fixes builds on sparc o adds section ranges to linker script o rename SECTION_RANGE_ALL() o use default alignment, fixes builds on powerpc and arm for both __LINUX_RANGE() and __LINUX_RANGE_ORDER() o expand documentation to document modules support o add maintainers o use generic-y v3: new in this series, uses copyleft-next Signed-off-by: Luis R. Rodriguez --- Documentation/sections/index.rst | 1 + Documentation/sections/ranges.rst | 74 +++++++++++++ Documentation/sections/section-core.rst | 5 + MAINTAINERS | 10 ++ arch/alpha/include/asm/Kbuild | 1 + arch/arc/include/asm/Kbuild | 1 + arch/arm/include/asm/Kbuild | 1 + arch/arm64/include/asm/Kbuild | 1 + arch/avr32/include/asm/Kbuild | 1 + arch/blackfin/include/asm/Kbuild | 1 + arch/c6x/include/asm/Kbuild | 1 + arch/cris/include/asm/Kbuild | 1 + arch/frv/include/asm/Kbuild | 1 + arch/h8300/include/asm/Kbuild | 1 + arch/hexagon/include/asm/Kbuild | 1 + arch/ia64/include/asm/Kbuild | 1 + arch/m32r/include/asm/Kbuild | 1 + arch/m68k/include/asm/Kbuild | 1 + arch/metag/include/asm/Kbuild | 1 + arch/microblaze/include/asm/Kbuild | 1 + arch/mips/include/asm/Kbuild | 1 + arch/mn10300/include/asm/Kbuild | 1 + arch/nios2/include/asm/Kbuild | 1 + arch/openrisc/include/asm/Kbuild | 1 + arch/parisc/include/asm/Kbuild | 1 + arch/powerpc/include/asm/Kbuild | 1 + arch/powerpc/kernel/vmlinux.lds.S | 1 + arch/s390/include/asm/Kbuild | 1 + arch/score/include/asm/Kbuild | 1 + arch/sh/include/asm/Kbuild | 1 + arch/sparc/include/asm/Kbuild | 1 + arch/tile/include/asm/Kbuild | 1 + arch/um/include/asm/Kbuild | 1 + arch/unicore32/include/asm/Kbuild | 1 + arch/x86/include/asm/Kbuild | 1 + arch/x86/tools/relocs.c | 2 + arch/xtensa/include/asm/Kbuild | 1 + include/asm-generic/ranges.h | 93 ++++++++++++++++ include/asm-generic/section-core.h | 41 +++++++ include/asm-generic/vmlinux.lds.h | 12 ++- include/linux/ranges.h | 183 ++++++++++++++++++++++++++++++++ 41 files changed, 451 insertions(+), 2 deletions(-) create mode 100644 Documentation/sections/ranges.rst create mode 100644 include/asm-generic/ranges.h create mode 100644 include/linux/ranges.h diff --git a/Documentation/sections/index.rst b/Documentation/sections/index.rst index f37511ef05e7..4a1df389fa91 100644 --- a/Documentation/sections/index.rst +++ b/Documentation/sections/index.rst @@ -15,3 +15,4 @@ common a set of Linux helpers for ELF sections are also documented. background section-core + ranges diff --git a/Documentation/sections/ranges.rst b/Documentation/sections/ranges.rst new file mode 100644 index 000000000000..d9d3af4e52cb --- /dev/null +++ b/Documentation/sections/ranges.rst @@ -0,0 +1,74 @@ +==================== +Linux section ranges +==================== + +This documents Linux' use of section ranges, how you can use +them and how they work. + +About section ranges +==================== + +Introduction +------------ +.. kernel-doc:: include/linux/ranges.h + :doc: Introduction + +Section range module support +---------------------------- +.. kernel-doc:: include/linux/ranges.h + :doc: Section range module support + +Section range helpers +===================== +.. kernel-doc:: include/linux/ranges.h + :doc: Section range helpers + +SECTION_RANGE_START +------------------- +.. kernel-doc:: include/linux/ranges.h + :functions: SECTION_RANGE_START + +SECTION_RANGE_END +----------------- +.. kernel-doc:: include/linux/ranges.h + :functions: SECTION_RANGE_END + +SECTION_RANGE_SIZE +------------------ +.. kernel-doc:: include/linux/ranges.h + :functions: SECTION_RANGE_SIZE + +SECTION_RANGE_EMPTY +------------------- +.. kernel-doc:: include/linux/ranges.h + :functions: SECTION_RANGE_EMPTY + +SECTION_RANGE_ADDR_WITHIN +------------------------- +.. kernel-doc:: include/linux/ranges.h + :functions: SECTION_RANGE_ADDR_WITHIN + +SECTION_RANGE_ALIGNMENT +------------------------- +.. kernel-doc:: include/linux/ranges.h + :functions: SECTION_RANGE_ALIGNMENT + +DECLARE_SECTION_RANGE +--------------------- +.. kernel-doc:: include/linux/ranges.h + :functions: DECLARE_SECTION_RANGE + +DEFINE_SECTION_RANGE +-------------------- +.. kernel-doc:: include/linux/ranges.h + :functions: DEFINE_SECTION_RANGE + +__LINUX_RANGE +------------- +.. kernel-doc:: include/asm-generic/ranges.h + :functions: __LINUX_RANGE + +__LINUX_RANGE_ORDER +------------------- +.. kernel-doc:: include/asm-generic/ranges.h + :functions: __LINUX_RANGE_ORDER diff --git a/Documentation/sections/section-core.rst b/Documentation/sections/section-core.rst index ac5815a0d9b3..1f613a6c7b78 100644 --- a/Documentation/sections/section-core.rst +++ b/Documentation/sections/section-core.rst @@ -114,6 +114,11 @@ Linux .ref\* sections .. kernel-doc:: include/asm-generic/section-core.h :doc: .ref.rodata +Linux section ordering +====================== +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux section ordering + Generic Linux kernel section helpers ==================================== diff --git a/MAINTAINERS b/MAINTAINERS index ae86136f4b9a..c96ca032c276 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5424,6 +5424,16 @@ S: Supported F: drivers/base/power/domain*.c F: include/linux/pm_domain.h +GENERIC SECTION RANGES +M: "Luis R. Rodriguez" +M: "H. Peter Anvin" +L: linux-arch@vger.kernel.org +L: linux-kernel@vger.kernel.org +S: Supported +F: include/asm-generic/ranges.h +F: include/linux/ranges.h +F: Documentation/sections/ranges.rst + GENERIC SECTIONS M: "Luis R. Rodriguez" M: Josh Poimboeuf diff --git a/arch/alpha/include/asm/Kbuild b/arch/alpha/include/asm/Kbuild index 5422827f1585..e44c896b91c4 100644 --- a/arch/alpha/include/asm/Kbuild +++ b/arch/alpha/include/asm/Kbuild @@ -11,3 +11,4 @@ generic-y += preempt.h generic-y += sections.h generic-y += trace_clock.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/arc/include/asm/Kbuild b/arch/arc/include/asm/Kbuild index 7b2cb3dea5fc..a374b7f83888 100644 --- a/arch/arc/include/asm/Kbuild +++ b/arch/arc/include/asm/Kbuild @@ -52,3 +52,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/arm/include/asm/Kbuild b/arch/arm/include/asm/Kbuild index 9b69a22a9ae1..0d47f98ccbc0 100644 --- a/arch/arm/include/asm/Kbuild +++ b/arch/arm/include/asm/Kbuild @@ -42,3 +42,4 @@ generic-y += unaligned.h generated-y += mach-types.h generated-y += unistd-nr.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/arm64/include/asm/Kbuild b/arch/arm64/include/asm/Kbuild index 00ace5e826f1..e9939cbd9067 100644 --- a/arch/arm64/include/asm/Kbuild +++ b/arch/arm64/include/asm/Kbuild @@ -46,3 +46,4 @@ generic-y += user.h generic-y += vga.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/avr32/include/asm/Kbuild b/arch/avr32/include/asm/Kbuild index f2c3b656a0e7..edc176348d7c 100644 --- a/arch/avr32/include/asm/Kbuild +++ b/arch/avr32/include/asm/Kbuild @@ -23,3 +23,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/blackfin/include/asm/Kbuild b/arch/blackfin/include/asm/Kbuild index bf20541bcf21..3428415b1996 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -48,3 +48,4 @@ generic-y += user.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/c6x/include/asm/Kbuild b/arch/c6x/include/asm/Kbuild index 38127ce747be..cede2a950fbf 100644 --- a/arch/c6x/include/asm/Kbuild +++ b/arch/c6x/include/asm/Kbuild @@ -63,3 +63,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/cris/include/asm/Kbuild b/arch/cris/include/asm/Kbuild index 385cd88a9d9e..fb8bb4112773 100644 --- a/arch/cris/include/asm/Kbuild +++ b/arch/cris/include/asm/Kbuild @@ -46,3 +46,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/frv/include/asm/Kbuild b/arch/frv/include/asm/Kbuild index 46d7c599d9b8..5191fec655d7 100644 --- a/arch/frv/include/asm/Kbuild +++ b/arch/frv/include/asm/Kbuild @@ -9,3 +9,4 @@ generic-y += preempt.h generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/h8300/include/asm/Kbuild b/arch/h8300/include/asm/Kbuild index 1ec04ec1c82b..7929a992566c 100644 --- a/arch/h8300/include/asm/Kbuild +++ b/arch/h8300/include/asm/Kbuild @@ -76,3 +76,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/hexagon/include/asm/Kbuild b/arch/hexagon/include/asm/Kbuild index 37d7bfae7619..af17ee334788 100644 --- a/arch/hexagon/include/asm/Kbuild +++ b/arch/hexagon/include/asm/Kbuild @@ -61,3 +61,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/ia64/include/asm/Kbuild b/arch/ia64/include/asm/Kbuild index 672c6d5da18c..d8f226b35a0a 100644 --- a/arch/ia64/include/asm/Kbuild +++ b/arch/ia64/include/asm/Kbuild @@ -10,3 +10,4 @@ generic-y += trace_clock.h generic-y += vtime.h generic-y += word-at-a-time.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/m32r/include/asm/Kbuild b/arch/m32r/include/asm/Kbuild index 6111e1523750..1c6504d29312 100644 --- a/arch/m32r/include/asm/Kbuild +++ b/arch/m32r/include/asm/Kbuild @@ -12,3 +12,4 @@ generic-y += sections.h generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/m68k/include/asm/Kbuild b/arch/m68k/include/asm/Kbuild index 1277b45bf4f9..006e2863ad37 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -35,3 +35,4 @@ generic-y += types.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/metag/include/asm/Kbuild b/arch/metag/include/asm/Kbuild index b1011375cd7a..4a8471434a3e 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -56,3 +56,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/microblaze/include/asm/Kbuild b/arch/microblaze/include/asm/Kbuild index c6c2cf6edc98..63c083a1f8da 100644 --- a/arch/microblaze/include/asm/Kbuild +++ b/arch/microblaze/include/asm/Kbuild @@ -12,3 +12,4 @@ generic-y += syscalls.h generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/mips/include/asm/Kbuild b/arch/mips/include/asm/Kbuild index 7a932b4a5531..e844d6058248 100644 --- a/arch/mips/include/asm/Kbuild +++ b/arch/mips/include/asm/Kbuild @@ -22,3 +22,4 @@ generic-y += user.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/mn10300/include/asm/Kbuild b/arch/mn10300/include/asm/Kbuild index f8145bc85835..656af7b69940 100644 --- a/arch/mn10300/include/asm/Kbuild +++ b/arch/mn10300/include/asm/Kbuild @@ -11,3 +11,4 @@ generic-y += sections.h generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/nios2/include/asm/Kbuild b/arch/nios2/include/asm/Kbuild index c9c7cb82b00f..c55880659d67 100644 --- a/arch/nios2/include/asm/Kbuild +++ b/arch/nios2/include/asm/Kbuild @@ -64,3 +64,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/openrisc/include/asm/Kbuild b/arch/openrisc/include/asm/Kbuild index 86175e701869..7d6a704b808c 100644 --- a/arch/openrisc/include/asm/Kbuild +++ b/arch/openrisc/include/asm/Kbuild @@ -72,3 +72,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/parisc/include/asm/Kbuild b/arch/parisc/include/asm/Kbuild index 18a9d4c5ead7..f11d1249738f 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -29,3 +29,4 @@ generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/powerpc/include/asm/Kbuild b/arch/powerpc/include/asm/Kbuild index 4322d9746cdb..60d8349241a7 100644 --- a/arch/powerpc/include/asm/Kbuild +++ b/arch/powerpc/include/asm/Kbuild @@ -9,3 +9,4 @@ generic-y += preempt.h generic-y += rwsem.h generic-y += vtime.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S index 7394b770ae1f..fcfc9d102348 100644 --- a/arch/powerpc/kernel/vmlinux.lds.S +++ b/arch/powerpc/kernel/vmlinux.lds.S @@ -107,6 +107,7 @@ SECTIONS #endif /* careful! __ftr_alt_* sections need to be close to .text */ *(.text .fixup __ftr_alt_* .ref.text) + *(SORT(.text.rng.*)) SCHED_TEXT CPUIDLE_TEXT LOCK_TEXT diff --git a/arch/s390/include/asm/Kbuild b/arch/s390/include/asm/Kbuild index 63a1c2924b91..c1b85a361e5d 100644 --- a/arch/s390/include/asm/Kbuild +++ b/arch/s390/include/asm/Kbuild @@ -9,3 +9,4 @@ generic-y += preempt.h generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/score/include/asm/Kbuild b/arch/score/include/asm/Kbuild index f089a264cd38..f0cdb2cbca4d 100644 --- a/arch/score/include/asm/Kbuild +++ b/arch/score/include/asm/Kbuild @@ -15,3 +15,4 @@ generic-y += xor.h generic-y += serial.h generic-y += word-at-a-time.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/sh/include/asm/Kbuild b/arch/sh/include/asm/Kbuild index 7b0356dca562..c9bb7932a3d1 100644 --- a/arch/sh/include/asm/Kbuild +++ b/arch/sh/include/asm/Kbuild @@ -40,3 +40,4 @@ generic-y += trace_clock.h generic-y += ucontext.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/sparc/include/asm/Kbuild b/arch/sparc/include/asm/Kbuild index 438f86573dc5..28280887ac79 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild @@ -22,3 +22,4 @@ generic-y += trace_clock.h generic-y += types.h generic-y += word-at-a-time.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/tile/include/asm/Kbuild b/arch/tile/include/asm/Kbuild index fb6b831c1fba..33f7069763ae 100644 --- a/arch/tile/include/asm/Kbuild +++ b/arch/tile/include/asm/Kbuild @@ -41,3 +41,4 @@ generic-y += trace_clock.h generic-y += types.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/um/include/asm/Kbuild b/arch/um/include/asm/Kbuild index 580bd5ff828f..b952dcb3e216 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -27,3 +27,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/unicore32/include/asm/Kbuild b/arch/unicore32/include/asm/Kbuild index 8578702d4998..93abbfdab543 100644 --- a/arch/unicore32/include/asm/Kbuild +++ b/arch/unicore32/include/asm/Kbuild @@ -61,3 +61,4 @@ generic-y += user.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += ranges.h diff --git a/arch/x86/include/asm/Kbuild b/arch/x86/include/asm/Kbuild index af975f21eeee..f672f2fc181d 100644 --- a/arch/x86/include/asm/Kbuild +++ b/arch/x86/include/asm/Kbuild @@ -13,3 +13,4 @@ generic-y += early_ioremap.h generic-y += mcs_spinlock.h generic-y += mm-arch-hooks.h generic-y += section-core.h +generic-y += ranges.h diff --git a/arch/x86/tools/relocs.c b/arch/x86/tools/relocs.c index 73eb7fd4aec4..f96fa2ddf7c9 100644 --- a/arch/x86/tools/relocs.c +++ b/arch/x86/tools/relocs.c @@ -68,6 +68,8 @@ static const char * const sym_regex_kernel[S_NSYMTYPES] = { "__end_rodata|" "__initramfs_start|" "(jiffies|jiffies_64)|" + ".rodata..rng.*|" + ".init.text..rng.*|" #if ELF_BITS == 64 "__per_cpu_load|" "init_per_cpu__.*|" diff --git a/arch/xtensa/include/asm/Kbuild b/arch/xtensa/include/asm/Kbuild index 7879c31e66a7..2b7fe48c0225 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -33,3 +33,4 @@ generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h +generic-y += ranges.h diff --git a/include/asm-generic/ranges.h b/include/asm-generic/ranges.h new file mode 100644 index 000000000000..75c196864f45 --- /dev/null +++ b/include/asm-generic/ranges.h @@ -0,0 +1,93 @@ +#ifndef _ASM_GENERIC_RANGES_H_ +#define _ASM_GENERIC_RANGES_H_ +/* + * Copyright (C) 2016 Luis R. Rodriguez + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of copyleft-next (version 0.3.1 or later) as published + * at http://copyleft-next.org/. + */ +#include + +#ifndef set_section_rng +# define set_section_rng(section, name, flags) \ + set_section_core(section, rng, name, \ + any, flags) +#endif + +#ifndef set_section_rng_type +# define set_section_rng_type(section, name, flags, type) \ + set_section_core_type(section, rng, name, \ + any, flags, type) +#endif + +#ifndef set_section_rng_level +# define set_section_rng_level(section, name, level, flags) \ + set_section_core(section, rng, name, level, flags) +#endif + +#ifndef push_section_rng +# define push_section_rng(section, name, flags) \ + push_section_core(section, rng, name, \ + any, flags) +#endif + +#ifndef push_section_rng_level +# define push_section_rng_level(section, name, level, flags) \ + push_section_core(section, rng, name, \ + level, flags) +#endif + +#ifndef __ASSEMBLY__ +/** + * __LINUX_RANGE - short hand association into a section range + * + * @section: ELF section name to place section range into + * @name: section range name + * + * This helper can be used by subsystems to define their own subsystem + * specific helpers to easily associate a piece of code being defined to a + * section range. + */ +#define __LINUX_RANGE(section, name) \ + __attribute__((__section__(#section "..rng.name.any"))) + +/** + * __LINUX_RANGE_ORDER - short hand association into a section range of order + * + * @section: ELF section name to place section range into + * @name: section range name + * @level: order level, a number. The order level gets tucked into the + * section as a postfix string. Order levels are sorted using + * binutils SORT(), the number is sorted as a string, as such be + * sure to fill with zeroes any empty digits. For instance if you are + * using 3 levels of digits for order levels, use 001 for the first entry, + * 0002 for the second, 999 for the last entry. You can use however many + * digits you need. + * + * This helper can be used by subsystems to define their own subsystem specific + * helpers to easily associate a piece of code being defined to a section range + * with an associated specific order level. The order level provides the + * ability for explicit user ordering of code. Sorting takes place at link + * time, after compilation. + */ +#define __LINUX_RANGE_ORDER(section, name, level) \ + __attribute__((__section__(#section "..rng.name." #level))) + +#endif /* __ASSEMBLY__ */ + +#ifdef __ASSEMBLER__ + +#ifndef DEFINE_SECTION_RANGE +#define DEFINE_SECTION_RANGE(section, name) \ + push_section_rng_level(section, name,,) ; \ + .globl name ; \ +name: ; \ + .popsection \ + \ + push_section_rng_level(section, name, ~,) ; \ + .popsection +#endif +#endif /* __ASSEMBLER__ */ + +#endif /* _ASM_GENERIC_RANGES_H_ */ diff --git a/include/asm-generic/section-core.h b/include/asm-generic/section-core.h index bb16befc4251..65fb076765f8 100644 --- a/include/asm-generic/section-core.h +++ b/include/asm-generic/section-core.h @@ -183,6 +183,47 @@ * or data structures part of the init sections. */ +/** + * DOC: Linux section ordering + * + * Linux may use binutils linker-script 'SORT()' on sections to sort Linux + * sections alpha numerically. Linux has historically used 'SORT()' in + * ``include/asm-generic/vmlinux.lds.h``, its a well established practice. If + * 'SORT()' is used on a section one can provide ordering using a postfix on + * each section entry added. For instance if a linker script uses:: + * + * SORT(.foo.*) + * + * one can then add entries with explicit ordering using numeric postfixes for + * each entry, we refer to these as 'order levels'. Since 'SORT()' sorts alpha + * numerically a specific series set of digits must be agreed a-priori which + * would give also an idea of the max expected number of entries added to a + * section. For instance, if you expect a maximum of 999 entries you can use + * 3 digits for a section order level. If you wanted an entry to be ordered + * first you could use the postfix '000', if you wanted an entry to follow this + * you could use '001', and so on. We could for instance have:: + * + * .foo.000 + * .foo.001 + * .foo.002 + * + * Often times one may want the option to specify no order is required for + * certain elements added to a section which does use 'SORT()' on the linker + * script. You can use any arbitrary string value to to specify no order is + * used, so long as its used consistantly. For instance, one possibility is to + * use the 'any' postfix. All entries on the section would then have no + * specific ordering:: + * + * .foo.any + * .foo.any + * .foo.any + * + * To help establish a convention we reserve the special name 'any' for this + * purpose. Developers can use and expect the 'any' postfix string on sections + * as a helper to annotate section ordering at link time is not relevant + * for entries on a section. + */ + /* Can be used on foo.S for instance */ #ifndef __set_section_core_type # define __set_section_core_type(___section, ___core, ___name, \ diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index 483f60c451f9..71bfd3b3c719 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -56,6 +56,7 @@ #include #include +#include /* Align . to a 8 byte boundary equals to maximum function alignment. */ #define ALIGN_FUNCTION() . = ALIGN(8) @@ -205,6 +206,7 @@ */ #define DATA_DATA \ *(.data .data.[0-9a-zA-Z_]*) \ + *(SORT(.data..rng.*)) \ *(.ref.data) \ *(.data..shared_aligned) /* percpu related */ \ MEM_KEEP(init.data) \ @@ -273,7 +275,9 @@ . = ALIGN((align)); \ .rodata : AT(ADDR(.rodata) - LOAD_OFFSET) { \ VMLINUX_SYMBOL(__start_rodata) = .; \ - *(.rodata) *(.rodata.*) \ + *(.rodata) \ + *(SORT(.rodata..rng.*)) \ + *(.rodata.*) \ RO_AFTER_INIT_DATA /* Read only after init */ \ KEEP(*(__vermagic)) /* Kernel version magic */ \ . = ALIGN(8); \ @@ -446,7 +450,9 @@ * conflicting section names, and must pull in .text.[0-9a-zA-Z_]* */ #define TEXT_TEXT \ ALIGN_FUNCTION(); \ - *(.text.hot .text .text.fixup .text.unlikely) \ + *(.text.hot .text) \ + *(SORT(.text..rng.*)) \ + *(.text.fixup .text.unlikely) \ *(.ref.text) \ MEM_KEEP(init.text) \ MEM_KEEP(exit.text) \ @@ -549,6 +555,7 @@ #define INIT_DATA \ KEEP(*(SORT(___kentry+*))) \ *(.init.data) \ + *(SORT(.init.data..rng.*)) \ MEM_DISCARD(init.data) \ KERNEL_CTORS() \ MCOUNT_REC() \ @@ -572,6 +579,7 @@ #define INIT_TEXT \ *(.init.text) \ + *(SORT(.init.text..rng.*)) \ *(.text.startup) \ MEM_DISCARD(init.text) diff --git a/include/linux/ranges.h b/include/linux/ranges.h new file mode 100644 index 000000000000..1e64674f6d7d --- /dev/null +++ b/include/linux/ranges.h @@ -0,0 +1,183 @@ +#ifndef _LINUX_RANGES_H +#define _LINUX_RANGES_H +/* + * Linux section ranges + * + * Copyright (C) 2016 Luis R. Rodriguez + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of copyleft-next (version 0.3.1 or later) as published + * at http://copyleft-next.org/. + */ +#include +#include + +#ifndef __ASSEMBLY__ + +/** + * DOC: Introduction + * + * A section ranges consists of explicitly annotated series executable code + * stitched together for the purpose of selective placement into standard or + * architecture specific ELF sections. What ELF section is used is utility + * specific. Linux has historically implicitly used section ranges, however + * they were all built in an adhoc manner and typically required linker script + * modifications per architecture. The section range API allows adding new + * bundles of stiched executable code into custom ELF sections by only + * modifying C or asm code in an architecture agnostic form. + * + * This documents the set of helpers available to declare, and define section + * ranges and associate each section range to a specific Linux ELF section. + */ + +/** + * DOC: Section range module support + * + * Modules can use section ranges, however the section range definition must be + * built-in to the kernel. That is, the code that implements + * DEFINE_SECTION_RANGE() must be built-in, and modular code cannot add more + * items in to the section range (with __LINUX_RANGE() or + * __LINUX_RANGE_ORDER()), unless kernel/module.c find_module_sections() and + * module-common.lds.S are updated accordingly with a respective module + * notifier to account for updates. This restriction may be enhanced in the + * future. + */ + +/** + * DOC: Section range helpers + * + * These are helpers for section ranges. + */ + +/** + * SECTION_RANGE_START - get address of start of section range + * + * @name: name of the section range + * + * This gives you the start address of the section range. + * This should give you the address of the first entry. + * + */ +#define SECTION_RANGE_START(name) LINUX_SECTION_START(name) + +/** + * SECTION_RANGE_END - get address of end of the section range + * + * @name: name of the section range + * + * This gives you the end address of the linker table. + * This will match the start address if the linker table + * is empty. + */ +#define SECTION_RANGE_END(name) LINUX_SECTION_END(name) + +/** + * SECTION_RANGE_SIZE - get number of entries in the section range + * + * @name: name of the section range + * + * This gives you the number of entries in the section range. + * Example usage: + * + * unsigned int num_ents = LINKTABLE_SIZE(some_fns); + */ +#define SECTION_RANGE_SIZE(name) \ + ((SECTION_RANGE_END(name)) - (SECTION_RANGE_START(name))) + +/** + * SECTION_RANGE_EMPTY - check if section range has no entries + * + * @name: name of the section range + * + * Returns true if the section range is emtpy. + * + * bool is_empty = LINKTABLE_EMPTY(some_fns); + */ +#define SECTION_RANGE_EMPTY(name) (SECTION_RANGE_SIZE(name) == 0) + +/** + * SECTION_RANGE_ADDR_WITHIN - returns true if address is in the section range + * + * @name: name of the section range + * @addr: address to query for + * + * Returns true if the address is in the section range. + */ +#define SECTION_RANGE_ADDR_WITHIN(name, addr) \ + (addr >= (unsigned long) SECTION_RANGE_START(name) && \ + addr < (unsigned long) SECTION_RANGE_END(name)) + +/** + * SECTION_RANGE_ALIGNMENT - get the alignment of the section range + * + * @name: name of linker table + * + * Gives you the alignment for the section range. + */ +#define SECTION_RANGE_ALIGNMENT(name) LINUX_SECTION_ALIGNMENT(name) + +/** + * DECLARE_SECTION_RANGE - Declares a section range + * + * @name: section range name + * + * Declares a section range to help code access the range. Typically if + * a subsystems needs code to have direct access to the section range the + * subsystem's header file would declare the section range. Care should be + * taken to only declare the section range in a header file if access to it + * is truly needed outside of the code defining it. You typically would + * rather instead provide helpers which access the section range with special + * code on behalf of the caller. + */ +#define DECLARE_SECTION_RANGE(name) \ + DECLARE_LINUX_SECTION_RO(char, name) + +/** + * __SECTION_RANGE_BEGIN - Constructs the beginning of a section range + * + * @name: section range name + * @__section: ELF section to place section range into + * + * Constructs the beginning of a section range. You will typically not need + * to use this directly. + */ +#define __SECTION_RANGE_BEGIN(name, __section) \ + const __typeof__(SECTION_RANGE_START(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(SECTION_RANGE_ALIGNMENT(name)),\ + section(#__section "..rng.name."))) + +/** + * __SECTION_RANGE_END - Constructs the end of a section range + * + * @name: section range name + * @__section: ELF section to place section range into + * + * Constructs the end of a section range. You will typically not need + * to use this directly. + */ +#define __SECTION_RANGE_END(name, __section) \ + const __typeof__(SECTION_RANGE_START(name)[0]) \ + __attribute__((used, \ + __aligned__(SECTION_RANGE_ALIGNMENT(name)),\ + section(#__section "..rng.name.~"))) + +/** + * DEFINE_SECTION_RANGE - Defines a section range + * + * @name: section range name + * @section: ELF section name to place section range into + * + * Defines a section range, used for executable code. Section ranges are + * defined in the code that takes ownership and makes use of the section + * range. + */ +#define DEFINE_SECTION_RANGE(name, section) \ + DECLARE_LINUX_SECTION_RO(char, name); \ + __SECTION_RANGE_BEGIN(name, section) SECTION_RANGE_START(name)[0] = {};\ + __SECTION_RANGE_END(name, section) SECTION_RANGE_END(name)[0] = {} + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_RANGES_H */ -- 2.11.0