From mboxrd@z Thu Jan 1 00:00:00 1970 From: mcgrof@kernel.org Subject: [PATCH v4 06/16] ranges.h: add helpers to build and identify Linux section ranges Date: Fri, 19 Aug 2016 14:34:04 -0700 Message-ID: <1471642454-5679-7-git-send-email-mcgrof@kernel.org> References: <1471642454-5679-1-git-send-email-mcgrof@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1471642454-5679-1-git-send-email-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, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, linux@arm.linux.org.uk, 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 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, 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, x86@kernel.org, fontana@sharpeleven.org, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, 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, acme@redhat.com, ak@linux.intel.com, andriy.shevchenko@linux.intel.com, mcb30@ip List-Id: linux-arch.vger.kernel.org RnJvbTogIkx1aXMgUi4gUm9kcmlndWV6IiA8bWNncm9mQGtlcm5lbC5vcmc+CgpTZWN0aW9uIHJh bmdlcyBhcmUgb24gb25lIG9mIHRoZSB0eXBlcyBvZiBjdXN0b20gc2VjdGlvbnMKdHlwZXMgdXNl ZCBpbiBMaW51eC4gVGhpcyBwcm92aWRlcyBhIHNlcmllcyBvZiBoZWxwZXJzIGZvcgpkZWZpbmlu ZyB0aGVtIGFuZCB1c2luZyB0aGVtLiBNb3N0IGltcG9ydGFudGx5IHRoaXMgYWxzbwplbmFibGVz IHVzIHRvIGF2b2lkIG1vZGlmeWluZyB0aGUgbGlua2VyIHNjcmlwdCB3aGVuIHdlCmFkZCBhIG5l dyBzZWN0aW9uIHJhbmdlLgoKSXQgdHVybnMgb3V0IGEgbG90IG9mIGN1c3RvbSBzZWN0aW9ucyBh cmUgYWN0dWFsbHkgc2VjdGlvbiByYW5nZXMsCmFuZCB0aGVzZSBhcmUgdHlwaWNhbGx5IHNwZWxs ZWQgb3V0IGluIHRoZWlyIGFyY2hpdGVjdHVyZSBzcGVjaWZpYwphc20vc2VjdGlvbnMuaCBmaWxl IC0tIHdlIGFuYWJsZSBhcmNoaXRlY3R1cmVzIHRvIG92ZXJyaWRlIHdoYXQgYXNtCmlzIHVzZWQg Zm9yIHNlY3Rpb24gcmFuZ2VzIGJ1dCBzdGFydCBieSBkZWZhdWx0IHRydXN0aW5nIHRoZQphc20t Z2VuZXJpYyB2ZXJzaW9uIGFsbCBhcm91bmQuCgp2NDoKCm8gdG9ucyBvZiBkb2N1bWVudGF0aW9u IGxvdmUKbyBmaXggYXJjaC94ODYvdG9vbHMvcmVsb2NzLmMgdHlwbyAtIHdoaWNoIGNhdXNlZCBj b21waWxhdGlvbiBpc3N1ZXMKICBvbiBvbGQgdG9vbGNoYWlucwpvIHBvcnQgdG8gbmV3IHNoaW55 IHNwaGlueCBkb2N1bWVudGF0aW9uCm8gc3ByaW5rbGUgYSBmZXcgbW9yZSBuZWVkZWQgVk1MSU5V WF9TWU1CT0woKSAtIGZpeGVzCiAgY29tcGlsYXRpb24gb24gYmxhY2tmaW4KbyBuYW1lIGNoYW5n ZXMgYXMgc3VnZ2VzdGVkIGJ5IEJvcmlzOgotICVzL1NFQ1RJT05fVFlQRV9SQU5HRVMvcm5nL2cK LSAlcy9TRUNUSU9OX1RZUEUvU0VDVElPTl9DT1JFL2cKLSAlcy9zZWN0aW9uX3R5cGVfYXNtdHlw ZS9zZWN0aW9uX2NvcmVfdHlwZS9nCi0gJXMvc2VjdGlvbl90eXBlL3NlY3Rpb25fY29yZS9nCi0g JXMvc2VjdGlvbl9ybmcvc2V0X3NlY3Rpb25fcm5nL2cKLSByZWJyYW5kIERFQ0xBUkVfU0VDVElP Tl9STkcoKSBhcyBERUZJTkVfU0VDVElPTl9SQU5HRSgpIC0gdGhpcyBpcwogIHRoZSBhc20gdmVy c2lvbiBvZiB0aGUgcmVzcGVjdGl2ZSBDIHZlcnNpb24sIHRoaXMgd2lsbCBoYXZlIGEKICB1c2Vy c3BhY2UgQyBkZW1vIGFkZGVkIGxhdGVyLgpvIG1vdmUgX19MSU5VWF9SQU5HRSgpIGFuZCBfX0xJ TlVYX1JBTkdFX09SREVSKCkgLSBmaXhlcyBidWlsZHMKICBvbiBzcGFyYwpvIGFkZHMgc2VjdGlv biByYW5nZXMgdG8gbGlua2VyIHNjcmlwdApvIHJlbmFtZSBTRUNUSU9OX1JBTkdFX0FMTCgpCm8g dXNlIGRlZmF1bHQgYWxpZ25tZW50LCBmaXhlcyBidWlsZHMgb24gcG93ZXJwYyBhbmQgYXJtIGZv ciBib3RoCiAgX19MSU5VWF9SQU5HRSgpIGFuZCBfX0xJTlVYX1JBTkdFX09SREVSKCkKbyBleHBh bmQgZG9jdW1lbnRhdGlvbiB0byBkb2N1bWVudCBtb2R1bGVzIHN1cHBvcnQKbyBhZGQgbWFpbnRh aW5lcnMKbyB1c2UgZ2VuZXJpYy15Cgp2MzogbmV3IGluIHRoaXMgc2VyaWVzLCB1c2VzIGNvcHls ZWZ0LW5leHQKClNpZ25lZC1vZmYtYnk6IEx1aXMgUi4gUm9kcmlndWV6IDxtY2dyb2ZAa2VybmVs Lm9yZz4KLS0tCiBEb2N1bWVudGF0aW9uL3NlY3Rpb25zL2luZGV4LnJzdCAgIHwgICAxICsKIERv Y3VtZW50YXRpb24vc2VjdGlvbnMvcmFuZ2VzLnJzdCAgfCAgNDkgKysrKysrKysrKysrKysKIE1B SU5UQUlORVJTICAgICAgICAgICAgICAgICAgICAgICAgfCAgMTAgKysrCiBhcmNoL2FscGhhL2lu Y2x1ZGUvYXNtL0tidWlsZCAgICAgIHwgICAxICsKIGFyY2gvYXJjL2luY2x1ZGUvYXNtL0tidWls ZCAgICAgICAgfCAgIDEgKwogYXJjaC9hcm0vaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICB8ICAg MSArCiBhcmNoL2FybTY0L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgIHwgICAxICsKIGFyY2gvYXZy MzIvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgfCAgIDEgKwogYXJjaC9ibGFja2Zpbi9pbmNsdWRl L2FzbS9LYnVpbGQgICB8ICAgMSArCiBhcmNoL2M2eC9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAg IHwgICAxICsKIGFyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgfCAgIDEgKwogYXJj aC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICB8ICAgMSArCiBhcmNoL2g4MzAwL2luY2x1 ZGUvYXNtL0tidWlsZCAgICAgIHwgICAxICsKIGFyY2gvaGV4YWdvbi9pbmNsdWRlL2FzbS9LYnVp bGQgICAgfCAgIDEgKwogYXJjaC9pYTY0L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICB8ICAgMSAr CiBhcmNoL20zMnIvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgIHwgICAxICsKIGFyY2gvbTY4ay9p bmNsdWRlL2FzbS9LYnVpbGQgICAgICAgfCAgIDEgKwogYXJjaC9tZXRhZy9pbmNsdWRlL2FzbS9L YnVpbGQgICAgICB8ICAgMSArCiBhcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkIHwg ICAxICsKIGFyY2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgfCAgIDEgKwogYXJjaC9t bjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZCAgICB8ICAgMSArCiBhcmNoL25pb3MyL2luY2x1ZGUv YXNtL0tidWlsZCAgICAgIHwgICAxICsKIGFyY2gvb3BlbnJpc2MvaW5jbHVkZS9hc20vS2J1aWxk ICAgfCAgIDEgKwogYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20vS2J1aWxkICAgICB8ICAgMSArCiBh cmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vS2J1aWxkICAgIHwgICAxICsKIGFyY2gvczM5MC9pbmNs dWRlL2FzbS9LYnVpbGQgICAgICAgfCAgIDEgKwogYXJjaC9zY29yZS9pbmNsdWRlL2FzbS9LYnVp bGQgICAgICB8ICAgMSArCiBhcmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgIHwgICAx ICsKIGFyY2gvc3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgfCAgIDEgKwogYXJjaC90aWxl L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICB8ICAgMSArCiBhcmNoL3VtL2luY2x1ZGUvYXNtL0ti dWlsZCAgICAgICAgIHwgICAxICsKIGFyY2gvdW5pY29yZTMyL2luY2x1ZGUvYXNtL0tidWlsZCAg fCAgIDEgKwogYXJjaC94ODYvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICB8ICAgMSArCiBhcmNo L3g4Ni90b29scy9yZWxvY3MuYyAgICAgICAgICAgIHwgICAyICsKIGFyY2gveHRlbnNhL2luY2x1 ZGUvYXNtL0tidWlsZCAgICAgfCAgIDEgKwogaW5jbHVkZS9hc20tZ2VuZXJpYy9yYW5nZXMuaCAg ICAgICB8ICA4OSArKysrKysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9hc20tZ2VuZXJp Yy92bWxpbnV4Lmxkcy5oICB8ICAxMiArKystCiBpbmNsdWRlL2xpbnV4L3Jhbmdlcy5oICAgICAg ICAgICAgIHwgMTI4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDM4IGZp bGVzIGNoYW5nZWQsIDMyMCBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQogY3JlYXRlIG1v ZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vc2VjdGlvbnMvcmFuZ2VzLnJzdAogY3JlYXRlIG1vZGUg MTAwNjQ0IGluY2x1ZGUvYXNtLWdlbmVyaWMvcmFuZ2VzLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBp bmNsdWRlL2xpbnV4L3Jhbmdlcy5oCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zZWN0aW9u cy9pbmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2luZGV4LnJzdAppbmRleCBkNDEx ZTliMjJlYjMuLjZkZDkzZGRkNWRiZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zZWN0aW9u cy9pbmRleC5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9pbmRleC5yc3QKQEAgLTks MyArOSw0IEBAIHVzZWQgdGhyb3VnaG91dCB0aGUga2VybmVsIHRvIGhlbHAgZGVjbGFyZSBhbmQg ZGVmaW5lIHRoZW0uCiAgICA6bWF4ZGVwdGg6IDQKIAogICAgc2VjdGlvbi1jb3JlCisgICByYW5n ZXMKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvcmFuZ2VzLnJzdCBiL0RvY3Vt ZW50YXRpb24vc2VjdGlvbnMvcmFuZ2VzLnJzdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMDAuLjEyOTNkY2IzYWIzOAotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRp b24vc2VjdGlvbnMvcmFuZ2VzLnJzdApAQCAtMCwwICsxLDQ5IEBACis9PT09PT09PT09PT09PT09 PT09PQorTGludXggc2VjdGlvbiByYW5nZXMKKz09PT09PT09PT09PT09PT09PT09CisKK1RoaXMg ZG9jdW1lbnRzIExpbnV4JyB1c2Ugb2Ygc2VjdGlvbiByYW5nZXMsIGhvdyB5b3UgY2FuIHVzZQor dGhlbSBhbmQgaG93IHRoZXkgd29yay4KKworQWJvdXQgc2VjdGlvbiByYW5nZXMKKz09PT09PT09 PT09PT09PT09PT09CisKK0ludHJvZHVjdGlvbgorLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9j OjogaW5jbHVkZS9saW51eC9yYW5nZXMuaAorICAgOmRvYzogSW50cm9kdWN0aW9uCisKK1NlY3Rp b24gcmFuZ2UgbW9kdWxlIHN1cHBvcnQKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy4u IGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3Jhbmdlcy5oCisgICA6ZG9jOiBTZWN0aW9uIHJh bmdlIG1vZHVsZSBzdXBwb3J0CisKK1NlY3Rpb24gcmFuZ2UgaGVscGVycworPT09PT09PT09PT09 PT09PT09PT09CisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC9yYW5nZXMuaAorICAgOmRv YzogU2VjdGlvbiByYW5nZSBoZWxwZXJzCisKK0RFQ0xBUkVfU0VDVElPTl9SQU5HRQorLS0tLS0t LS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC9yYW5nZXMuaAor ICAgOmZ1bmN0aW9uczogREVDTEFSRV9TRUNUSU9OX1JBTkdFCisKK0RFRklORV9TRUNUSU9OX1JB TkdFCistLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgv cmFuZ2VzLmgKKyAgIDpmdW5jdGlvbnM6IERFRklORV9TRUNUSU9OX1JBTkdFCisKK1NFQ1RJT05f QUREUl9JTl9SQU5HRQorLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5j bHVkZS9saW51eC9yYW5nZXMuaAorICAgOmZ1bmN0aW9uczogU0VDVElPTl9BRERSX0lOX1JBTkdF CisKK19fTElOVVhfUkFOR0UKKy0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRl L2FzbS1nZW5lcmljL3Jhbmdlcy5oCisgICA6ZnVuY3Rpb25zOiBfX0xJTlVYX1JBTkdFCisKK19f TElOVVhfUkFOR0VfT1JERVIKKy0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBp bmNsdWRlL2FzbS1nZW5lcmljL3Jhbmdlcy5oCisgICA6ZnVuY3Rpb25zOiBfX0xJTlVYX1JBTkdF X09SREVSCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IDY4OWMx MjA3NTg0Mi4uMWEyMTc3NTFhYThhIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlO VEFJTkVSUwpAQCAtNTIxNyw2ICs1MjE3LDE2IEBAIFM6CVN1cHBvcnRlZAogRjoJZHJpdmVycy9i YXNlL3Bvd2VyL2RvbWFpbiouYwogRjoJaW5jbHVkZS9saW51eC9wbV9kb21haW4uaAogCitHRU5F UklDIFNFQ1RJT04gUkFOR0VTCitNOgkiTHVpcyBSLiBSb2RyaWd1ZXoiIDxtY2dyb2ZAa2VybmVs Lm9yZz4KK006CSJILiBQZXRlciBBbnZpbiIgPGhwYUB6eXRvci5jb20+CitMOglsaW51eC1hcmNo QHZnZXIua2VybmVsLm9yZworTDoJbGludXgta2VybmVsQHZnZXIua2VybmVsLm9yZworUzoJU3Vw cG9ydGVkCitGOglpbmNsdWRlL2FzbS1nZW5lcmljL3Jhbmdlcy5oCitGOglpbmNsdWRlL2xpbnV4 L3Jhbmdlcy5oCitGOglEb2N1bWVudGF0aW9uL3NlY3Rpb25zL3Jhbmdlcy5yc3QKKwogR0VORVJJ QyBTRUNUSU9OUwogTToJIkx1aXMgUi4gUm9kcmlndWV6IiA8bWNncm9mQGtlcm5lbC5vcmc+CiBN OglKb3NoIFBvaW1ib2V1ZiA8anBvaW1ib2VAcmVkaGF0LmNvbT4KZGlmZiAtLWdpdCBhL2FyY2gv YWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9hbHBoYS9pbmNsdWRlL2FzbS9LYnVpbGQK aW5kZXggNTQyMjgyN2YxNTg1Li5lNDRjODk2YjkxYzQgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEv aW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkCkBA IC0xMSwzICsxMSw0IEBAIGdlbmVyaWMteSArPSBwcmVlbXB0LmgKIGdlbmVyaWMteSArPSBzZWN0 aW9ucy5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24t Y29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvYXJjL2luY2x1 ZGUvYXNtL0tidWlsZCBiL2FyY2gvYXJjL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA5YTA5Mjk1 NzZkZTEuLmU1Mjk1NDEzZmRmOCAxMDA2NDQKLS0tIGEvYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1 aWxkCisrKyBiL2FyY2gvYXJjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNTEsMyArNTEsNCBAQCBn ZW5lcmljLXkgKz0gdmdhLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmlj LXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJh bmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2Fy bS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggNDc5MjM2MzViZTE2Li44ZTUyMzAwZTFlZWQgMTAw NjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2FybS9pbmNs dWRlL2FzbS9LYnVpbGQKQEAgLTQwLDMgKzQwLDQgQEAgZ2VuZXJpYy15ICs9IHRpbWV4LmgKIGdl bmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gdW5hbGlnbmVkLmgKIGdlbmVy aWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQg YS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20v S2J1aWxkCmluZGV4IDQyZDAwODA2ZTRmYi4uNWZmMTg0NTc0OTc2IDEwMDY0NAotLS0gYS9hcmNo L2FybTY0L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL0ti dWlsZApAQCAtNTMsMyArNTMsNCBAQCBnZW5lcmljLXkgKz0gdXNlci5oCiBnZW5lcmljLXkgKz0g dmdhLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitn ZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvYXZyMzIvaW5jbHVkZS9hc20v S2J1aWxkIGIvYXJjaC9hdnIzMi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZjJjM2I2NTZhMGU3 Li5lZGMxNzYzNDhkN2MgMTAwNjQ0Ci0tLSBhL2FyY2gvYXZyMzIvaW5jbHVkZS9hc20vS2J1aWxk CisrKyBiL2FyY2gvYXZyMzIvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0yMywzICsyMyw0IEBAIGdl bmVyaWMteSArPSB2Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMt eSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFu Z2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJj aC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggN2RlNjc0NDExYmVkLi4zNWI3NzUy ZTY1YzAgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxkCisrKyBi L2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxkCkBAIC00OSwzICs0OSw0IEBAIGdlbmVy aWMteSArPSB1c2VyLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkg Kz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdl cy5oCmRpZmYgLS1naXQgYS9hcmNoL2M2eC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2M2eC9p bmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMzgxMjdjZTc0N2JlLi5jZWRlMmE5NTBmYmYgMTAwNjQ0 Ci0tLSBhL2FyY2gvYzZ4L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2M2eC9pbmNsdWRl L2FzbS9LYnVpbGQKQEAgLTYzLDMgKzYzLDQgQEAgZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5lcmlj LXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkgKz0g c2VjdGlvbi1jb3JlLmgKK2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9j cmlzL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5k ZXggMzg1Y2Q4OGE5ZDllLi5mYjhiYjQxMTI3NzMgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9pbmNs dWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9jcmlzL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNDYs MyArNDYsNCBAQCBnZW5lcmljLXkgKz0gdmdhLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGlt ZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2Vu ZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2Zydi9pbmNsdWRlL2FzbS9LYnVp bGQgYi9hcmNoL2Zydi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggNDZkN2M1OTlkOWI4Li41MTkx ZmVjNjU1ZDcgMTAwNjQ0Ci0tLSBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9h cmNoL2Zydi9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTksMyArOSw0IEBAIGdlbmVyaWMteSArPSBw cmVlbXB0LmgKIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gd29yZC1h dC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFu Z2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvaDgzMDAvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9o ODMwMC9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMWVjMDRlYzFjODJiLi43OTI5YTk5MjU2NmMg MTAwNjQ0Ci0tLSBhL2FyY2gvaDgzMDAvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvaDgz MDAvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC03NiwzICs3Niw0IEBAIGdlbmVyaWMteSArPSB2Z2Eu aAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2Vu ZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdp dCBhL2FyY2gvaGV4YWdvbi9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2hleGFnb24vaW5jbHVk ZS9hc20vS2J1aWxkCmluZGV4IDM3ZDdiZmFlNzYxOS4uYWYxN2VlMzM0Nzg4IDEwMDY0NAotLS0g YS9hcmNoL2hleGFnb24vaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvaGV4YWdvbi9pbmNs dWRlL2FzbS9LYnVpbGQKQEAgLTYxLDMgKzYxLDQgQEAgZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5l cmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkg Kz0gc2VjdGlvbi1jb3JlLmgKK2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJj aC9pYTY0L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9LYnVpbGQK aW5kZXggNjcyYzZkNWRhMThjLi5kOGYyMjZiMzVhMGEgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9p bmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL0tidWlsZApAQCAt MTAsMyArMTAsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHZ0 aW1lLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlv bi1jb3JlLmgKK2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL2lu Y2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggNjEx MWUxNTIzNzUwLi4xYzY1MDRkMjkzMTIgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9pbmNsdWRlL2Fz bS9LYnVpbGQKKysrIGIvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTIsMyArMTIs NCBAQCBnZW5lcmljLXkgKz0gc2VjdGlvbnMuaAogZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgK IGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3Jl LmgKK2dlbmVyaWMteSArPSByYW5nZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9tNjhrL2luY2x1ZGUv YXNtL0tidWlsZCBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZWVmNzJjNDY0 YzliLi5kNDY1ZjUxYzIwODggMTAwNjQ0Ci0tLSBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVp bGQKKysrIGIvYXJjaC9tNjhrL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMzYsMyArMzYsNCBAQCBn ZW5lcmljLXkgKz0gdHlwZXMuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVy aWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0g cmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJj aC9tZXRhZy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggNTBlYmQ1YTMwZDE2Li5jODY5YjFlYmQ1 ODMgMTAwNjQ0Ci0tLSBhL2FyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gv bWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC01NywzICs1Nyw0IEBAIGdlbmVyaWMteSArPSB2 Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAog Z2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAt LWdpdCBhL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL21pY3JvYmxh emUvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGM2YzJjZjZlZGM5OC4uNjNjMDgzYTFmOGRhIDEw MDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gv bWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTEyLDMgKzEyLDQgQEAgZ2VuZXJpYy15 ICs9IHN5c2NhbGxzLmgKIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0g d29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkg Kz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9h cmNoL21pcHMvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDEyZjdjNTk4NGMwMy4uZWQyMjU2MDBj OGE0IDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gv bWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTIxLDMgKzIxLDQgQEAgZ2VuZXJpYy15ICs9IHVz ZXIuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAog Z2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAt LWdpdCBhL2FyY2gvbW4xMDMwMC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL21uMTAzMDAvaW5j bHVkZS9hc20vS2J1aWxkCmluZGV4IGY4MTQ1YmM4NTgzNS4uNjU2YWY3YjY5OTQwIDEwMDY0NAot LS0gYS9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbW4xMDMwMC9p bmNsdWRlL2FzbS9LYnVpbGQKQEAgLTExLDMgKzExLDQgQEAgZ2VuZXJpYy15ICs9IHNlY3Rpb25z LmgKIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRp bWUuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgK ZGlmZiAtLWdpdCBhL2FyY2gvbmlvczIvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9uaW9zMi9p bmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggYzljN2NiODJiMDBmLi5jNTU4ODA2NTlkNjcgMTAwNjQ0 Ci0tLSBhL2FyY2gvbmlvczIvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbmlvczIvaW5j bHVkZS9hc20vS2J1aWxkCkBAIC02NCwzICs2NCw0IEBAIGdlbmVyaWMteSArPSB2Z2EuaAogZ2Vu ZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15 ICs9IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2Fy Y2gvb3BlbnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9vcGVucmlzYy9pbmNsdWRlL2Fz bS9LYnVpbGQKaW5kZXggODYxNzVlNzAxODY5Li43ZDZhNzA0YjgwOGMgMTAwNjQ0Ci0tLSBhL2Fy Y2gvb3BlbnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvb3BlbnJpc2MvaW5jbHVk ZS9hc20vS2J1aWxkCkBAIC03MiwzICs3Miw0IEBAIGdlbmVyaWMteSArPSB2Z2EuaAogZ2VuZXJp Yy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9 IHNlY3Rpb24tY29yZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gv cGFyaXNjL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL0tidWls ZAppbmRleCA2ZjQzZjMzZjBlMGYuLjFhMjYzYTcxNThlMiAxMDA2NDQKLS0tIGEvYXJjaC9wYXJp c2MvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL0tidWls ZApAQCAtMzAsMyArMzAsNCBAQCBnZW5lcmljLXkgKz0gdmdhLmgKIGdlbmVyaWMteSArPSB3b3Jk LWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNv cmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5j bHVkZS9hc20vS2J1aWxkIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBi NDlmYWI3YmFiMmYuLjA2NWM2ZTg0ZmI2NyAxMDA2NDQKLS0tIGEvYXJjaC9wb3dlcnBjL2luY2x1 ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC04 LDMgKzgsNCBAQCBnZW5lcmljLXkgKz0gcHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gcndzZW0uaAog Z2VuZXJpYy15ICs9IHZ0aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJp Yy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxk IGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA4OWU3NGI1OWYzMmQuLjNlOGI5 NTkyN2NiNSAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9h cmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC05LDMgKzksNCBAQCBnZW5lcmljLXkgKz0g cHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHdvcmQt YXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJh bmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gv c2NvcmUvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGYwODlhMjY0Y2QzOC4uZjBjZGIyY2JjYTRk IDEwMDY0NAotLS0gYS9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3Nj b3JlL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTUsMyArMTUsNCBAQCBnZW5lcmljLXkgKz0geG9y LmgKIGdlbmVyaWMteSArPSBzZXJpYWwuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgK IGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYg LS1naXQgYS9hcmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvc2gvaW5jbHVkZS9hc20v S2J1aWxkCmluZGV4IDdiMDM1NmRjYTU2Mi4uYzliYjc5MzJhM2QxIDEwMDY0NAotLS0gYS9hcmNo L3NoL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZApA QCAtNDAsMyArNDAsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9 IHVjb250ZXh0LmgKIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29y ZS5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMvaW5jbHVk ZS9hc20vS2J1aWxkIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZDUxYjg0 ZDZiNGI3Li43OTY2NGQxMGU2M2IgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20v S2J1aWxkCisrKyBiL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0yMywzICsyMyw0 IEBAIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gdHlwZXMuaAogZ2Vu ZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAor Z2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3RpbGUvaW5jbHVkZS9hc20v S2J1aWxkIGIvYXJjaC90aWxlL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCA3YjhhNjUyZTQzYWUu Ljk1MWZhNGJlNTcxZCAxMDA2NDQKLS0tIGEvYXJjaC90aWxlL2luY2x1ZGUvYXNtL0tidWlsZAor KysgYi9hcmNoL3RpbGUvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC00MiwzICs0Miw0IEBAIGdlbmVy aWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gdHlwZXMuaAogZ2VuZXJpYy15ICs9 IHhvci5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKK2dlbmVyaWMteSArPSByYW5nZXMu aApkaWZmIC0tZ2l0IGEvYXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3VtL2luY2x1 ZGUvYXNtL0tidWlsZAppbmRleCBlOTg0OTgzNGQ1NWUuLjk5YmU1NDk0OWI5OSAxMDA2NDQKLS0t IGEvYXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC91bS9pbmNsdWRlL2FzbS9L YnVpbGQKQEAgLTI4LDMgKzI4LDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVy aWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSAr PSBzZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNo L3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2Fz bS9LYnVpbGQKaW5kZXggMjU2YzQ1YjNhZTM0Li42YzM1OTA1ZmUzNzEgMTAwNjQ0Ci0tLSBhL2Fy Y2gvdW5pY29yZTMyL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3VuaWNvcmUzMi9pbmNs dWRlL2FzbS9LYnVpbGQKQEAgLTY0LDMgKzY0LDQgQEAgZ2VuZXJpYy15ICs9IHVzZXIuaAogZ2Vu ZXJpYy15ICs9IHZnYS5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15 ICs9IHhvci5oCitnZW5lcmljLXkgKz0gcmFuZ2VzLmgKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2lu Y2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBmNjkx NGE1N2JjMTYuLmY3OTA3NTZmZGI0OCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20v S2J1aWxkCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTcsMyArMTcsNCBA QCBnZW5lcmljLXkgKz0gZWFybHlfaW9yZW1hcC5oCiBnZW5lcmljLXkgKz0gbWNzX3NwaW5sb2Nr LmgKIGdlbmVyaWMteSArPSBtbS1hcmNoLWhvb2tzLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNv cmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni90b29scy9y ZWxvY3MuYyBiL2FyY2gveDg2L3Rvb2xzL3JlbG9jcy5jCmluZGV4IDBjMmZhZThkOTI5ZC4uYzIx NWRiMDQ5OTIwIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni90b29scy9yZWxvY3MuYworKysgYi9hcmNo L3g4Ni90b29scy9yZWxvY3MuYwpAQCAtNjgsNiArNjgsOCBAQCBzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IHN5bV9yZWdleF9rZXJuZWxbU19OU1lNVFlQRVNdID0gewogCSJfX2VuZF9yb2RhdGF8 IgogCSJfX2luaXRyYW1mc19zdGFydHwiCiAJIihqaWZmaWVzfGppZmZpZXNfNjQpfCIKKwkiLnJv ZGF0YS5ybmcuKnwiCisJIi5pbml0LnRleHQucm5nLip8IgogI2lmIEVMRl9CSVRTID09IDY0CiAJ Il9fcGVyX2NwdV9sb2FkfCIKIAkiaW5pdF9wZXJfY3B1X18uKnwiCmRpZmYgLS1naXQgYS9hcmNo L3h0ZW5zYS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3h0ZW5zYS9pbmNsdWRlL2FzbS9LYnVp bGQKaW5kZXggODFjYTY4MTZiZDcyLi4yMjFiNmI2NTI1MDAgMTAwNjQ0Ci0tLSBhL2FyY2gveHRl bnNhL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3h0ZW5zYS9pbmNsdWRlL2FzbS9LYnVp bGQKQEAgLTMyLDMgKzMyLDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMt eSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBz ZWN0aW9uLWNvcmUuaAorZ2VuZXJpYy15ICs9IHJhbmdlcy5oCmRpZmYgLS1naXQgYS9pbmNsdWRl L2FzbS1nZW5lcmljL3Jhbmdlcy5oIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9yYW5nZXMuaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjc0Y2Q5NDFhYTJmOAotLS0gL2Rl di9udWxsCisrKyBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvcmFuZ2VzLmgKQEAgLTAsMCArMSw4OSBA QAorI2lmbmRlZiBfQVNNX0dFTkVSSUNfUkFOR0VTX0hfCisjZGVmaW5lIF9BU01fR0VORVJJQ19S QU5HRVNfSF8KKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgTHVpcyBSLiBSb2RyaWd1ZXogPG1j Z3JvZkBrZXJuZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5 b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVy bXMgb2YgY29weWxlZnQtbmV4dCAodmVyc2lvbiAwLjMuMSBvciBsYXRlcikgYXMgcHVibGlzaGVk CisgKiBhdCBodHRwOi8vY29weWxlZnQtbmV4dC5vcmcvLgorICovCisjaW5jbHVkZSA8YXNtL3Nl Y3Rpb24tY29yZS5oPgorCisjZGVmaW5lIFNFQ1RJT05fUk5HKHNlY3Rpb24sIG5hbWUpCQkJCQlc CisJU0VDVElPTl9DT1JFKHNlY3Rpb24sIHJuZywgbmFtZSwJCQkJXAorCQkgICAgIFNFQ1RJT05f T1JERVJfQU5ZKQorCisjZGVmaW5lIFNFQ1RJT05fUk5HX0xFVkVMKHNlY3Rpb24sIG5hbWUsIGxl dmVsKQkJCQlcCisJU0VDVElPTl9DT1JFKHNlY3Rpb24sIHJuZywgbmFtZSwgbGV2ZWwpCisKKyNk ZWZpbmUgU0VDVElPTl9STkdfQUxMKHNlY3Rpb24pCQkJCQlcCisJU0VDVElPTl9DT1JFX0FMTChz ZWN0aW9uLHJuZykKKworI2lmbmRlZiBzZXRfc2VjdGlvbl9ybmcKKyMgZGVmaW5lIHNldF9zZWN0 aW9uX3JuZyhzZWN0aW9uLCBuYW1lLCBmbGFncykJCQkJXAorCSBzZXRfc2VjdGlvbl9jb3JlKHNl Y3Rpb24sIHJuZywgbmFtZSwJCQkJXAorCQkJICBTRUNUSU9OX09SREVSX0FOWSwgZmxhZ3MpCisj ZW5kaWYKKworI2lmbmRlZiBzZXRfc2VjdGlvbl9ybmdfdHlwZQorIyBkZWZpbmUgc2V0X3NlY3Rp b25fcm5nX3R5cGUoc2VjdGlvbiwgbmFtZSwgZmxhZ3MsIHR5cGUpCQlcCisJIHNldF9zZWN0aW9u X2NvcmVfdHlwZShzZWN0aW9uLCBybmcsIG5hbWUsCQkJXAorCQkJICAgICAgIFNFQ1RJT05fT1JE RVJfQU5ZLCBmbGFncywgdHlwZSkKKyNlbmRpZgorCisjaWZuZGVmIHNldF9zZWN0aW9uX3JuZ19s ZXZlbAorIyBkZWZpbmUgc2V0X3NlY3Rpb25fcm5nX2xldmVsKHNlY3Rpb24sIG5hbWUsIGxldmVs LCBmbGFncykJCVwKKwkgc2V0X3NlY3Rpb25fY29yZShzZWN0aW9uLCBybmcsIG5hbWUsIGxldmVs LCBmbGFncykKKyNlbmRpZgorCisjaWZuZGVmIHB1c2hfc2VjdGlvbl9ybmcKKyMgZGVmaW5lIHB1 c2hfc2VjdGlvbl9ybmcoc2VjdGlvbiwgbmFtZSwgZmxhZ3MpCQkJCVwKKwkgcHVzaF9zZWN0aW9u X2NvcmUoc2VjdGlvbiwgcm5nLCBuYW1lLAkJCQlcCisJCQkgICBTRUNUSU9OX09SREVSX0FOWSwg ZmxhZ3MpCisjZW5kaWYKKworI2lmbmRlZiBwdXNoX3NlY3Rpb25fcm5nX2xldmVsCisjIGRlZmlu ZSBwdXNoX3NlY3Rpb25fcm5nX2xldmVsKHNlY3Rpb24sIG5hbWUsIGxldmVsLCBmbGFncykJCVwK KwkgcHVzaF9zZWN0aW9uX2NvcmUoc2VjdGlvbiwgcm5nLCBuYW1lLAkJCQlcCisJCQkgICBsZXZl bCwgZmxhZ3MpCisjZW5kaWYKKworI2lmbmRlZiBfX0FTU0VNQkxZX18KKy8qKgorICogX19MSU5V WF9SQU5HRSAtIHNob3J0IGhhbmQgYXNzb2NpYXRpb24gaW50byBhIHNlY3Rpb24gcmFuZ2UKKyAq CisgKiBAc2VjdGlvbjogRUxGIHNlY3Rpb24gbmFtZSB0byBwbGFjZSBzZWN0aW9uIHJhbmdlIGlu dG8KKyAqIEBuYW1lOiBzZWN0aW9uIHJhbmdlIG5hbWUKKyAqCisgKiBUaGlzIGhlbHBlciBjYW4g YmUgdXNlZCBieSBzdWJzeXN0ZW1zIHRvIGRlZmluZSB0aGVpciBvd24gc3Vic3lzdGVtCisgKiBz cGVjaWZpYyBoZWxwZXJzIHRvIGVhc2lseSBhc3NvY2lhdGUgYSBwaWVjZSBvZiBjb2RlIGJlaW5n IGRlZmluZWQgdG8gYQorICogc2VjdGlvbiByYW5nZS4KKyAqLworI2RlZmluZSBfX0xJTlVYX1JB TkdFKHNlY3Rpb24sIG5hbWUpCQkJCQlcCisJX19hdHRyaWJ1dGVfXygoX19zZWN0aW9uX18oU0VD VElPTl9STkcoc2VjdGlvbiwgbmFtZSkpKSkKKworLyoqCisgKiBfX0xJTlVYX1JBTkdFX09SREVS IC0gc2hvcnQgaGFuZCBhc3NvY2lhdGlvbiBpbnRvIGEgc2VjdGlvbiByYW5nZSBvZiBvcmRlcgor ICoKKyAqIEBzZWN0aW9uOiBFTEYgc2VjdGlvbiBuYW1lIHRvIHBsYWNlIHNlY3Rpb24gcmFuZ2Ug aW50bworICogQG5hbWU6IHNlY3Rpb24gcmFuZ2UgbmFtZQorICogQGxldmVsOiBvcmRlciBsZXZl bCwgYSBudW1iZXIuIFRoZSBvcmRlciBsZXZlbCBnZXRzIHR1Y2tlZCBpbnRvIHRoZQorICoJc2Vj dGlvbiBhcyBhIHBvc3RmaXggc3RyaW5nLiBPcmRlciBsZXZlbHMgYXJlIHNvcnRlZCB1c2luZwor ICogCWJpbnV0aWxzIFNPUlQoKSwgdGhlIG51bWJlciBpcyBzb3J0ZWQgYXMgYSBzdHJpbmcsIGFz IHN1Y2ggYmUKKyAqIAlzdXJlIHRvIGZpbGwgd2l0aCB6ZXJvZXMgYW55IGVtcHR5IGRpZ2l0cy4g Rm9yIGluc3RhbmNlIGlmIHlvdSBhcmUKKyAqIAl1c2luZyAzIGxldmVscyBvZiBkaWdpdHMgZm9y IG9yZGVyIGxldmVscywgdXNlIDAwMSBmb3IgdGhlIGZpcnN0IGVudHJ5LAorICogCTAwMDIgZm9y IHRoZSBzZWNvbmQsIDk5OSBmb3IgdGhlIGxhc3QgZW50cnkuIFlvdSBjYW4gdXNlIGhvd2V2ZXIg bWFueQorICogCWRpZ2l0cyB5b3UgbmVlZC4KKyAqCisgKiBUaGlzIGhlbHBlciBjYW4gYmUgdXNl ZCBieSBzdWJzeXN0ZW1zIHRvIGRlZmluZSB0aGVpciBvd24gc3Vic3lzdGVtIHNwZWNpZmljCisg KiBoZWxwZXJzIHRvIGVhc2lseSBhc3NvY2lhdGUgYSBwaWVjZSBvZiBjb2RlIGJlaW5nIGRlZmlu ZWQgdG8gYSBzZWN0aW9uIHJhbmdlCisgKiB3aXRoIGFuIGFzc29jaWF0ZWQgc3BlY2lmaWMgb3Jk ZXIgbGV2ZWwuIFRoZSBvcmRlciBsZXZlbCBwcm92aWRlcyB0aGUKKyAqIGFiaWxpdHkgZm9yIGV4 cGxpY2l0IHVzZXIgb3JkZXJpbmcgb2YgY29kZS4gU29ydGluZyB0YWtlcyBwbGFjZSBhdCBsaW5r CisgKiB0aW1lLCBhZnRlciBjb21waWxhdGlvbi4KKyAqLworI2RlZmluZSBfX0xJTlVYX1JBTkdF X09SREVSKHNlY3Rpb24sIG5hbWUsIGxldmVsKQkJCVwKKwlfX2F0dHJpYnV0ZV9fKChfX3NlY3Rp b25fXyhTRUNUSU9OX1JOR19MRVZFTChzZWN0aW9uLCBuYW1lLCBsZXZlbCkpKSkKKworI2VuZGlm IC8qIF9fQVNTRU1CTFlfXyAqLworCisjZW5kaWYgLyogX0FTTV9HRU5FUklDX1JBTkdFU19IXyAq LwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oIGIvaW5jbHVk ZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oCmluZGV4IDczMTA4NzI3NmEzMi4uYWQ4NDM1NTVl NmE0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmgKKysrIGIv aW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oCkBAIC01Niw2ICs1Niw3IEBACiAKICNp bmNsdWRlIDxsaW51eC9leHBvcnQuaD4KICNpbmNsdWRlIDxhc20vc2VjdGlvbi1jb3JlLmg+Cisj aW5jbHVkZSA8YXNtL3Jhbmdlcy5oPgogCiAvKiBBbGlnbiAuIHRvIGEgOCBieXRlIGJvdW5kYXJ5 IGVxdWFscyB0byBtYXhpbXVtIGZ1bmN0aW9uIGFsaWdubWVudC4gKi8KICNkZWZpbmUgQUxJR05f RlVOQ1RJT04oKSAgLiA9IEFMSUdOKDgpCkBAIC0yMDAsNiArMjAxLDcgQEAKIC8qIC5kYXRhIHNl Y3Rpb24gKi8KICNkZWZpbmUgREFUQV9EQVRBCQkJCQkJCVwKIAkqKFNFQ1RJT05fREFUQSkJCQkJ CQkJXAorCSooU09SVChTRUNUSU9OX1JOR19BTEwoU0VDVElPTl9EQVRBKSkpCQkJCVwKIAkqKFNF Q1RJT05fUkVGX0RBVEEpCQkJCQkJXAogCSooLmRhdGEuLnNoYXJlZF9hbGlnbmVkKSAvKiBwZXJj cHUgcmVsYXRlZCAqLwkJCVwKIAlNRU1fS0VFUChpbml0LmRhdGEpCQkJCQkJXApAQCAtMjY1LDcg KzI2Nyw5IEBACiAJLiA9IEFMSUdOKChhbGlnbikpOwkJCQkJCVwKIAlTRUNUSU9OX1JPREFUQSAg ICA6IEFUKEFERFIoU0VDVElPTl9ST0RBVEEpIC0gTE9BRF9PRkZTRVQpIHsJXAogCQlWTUxJTlVY X1NZTUJPTChfX3N0YXJ0X3JvZGF0YSkgPSAuOwkJCVwKLQkJKihTRUNUSU9OX1JPREFUQSkgKihT RUNUSU9OX0FMTChTRUNUSU9OX1JPREFUQSkpCVwKKwkJKihTRUNUSU9OX1JPREFUQSkJCQkJCVwK KwkJKihTT1JUKFNFQ1RJT05fUk5HX0FMTChTRUNUSU9OX1JPREFUQSkpKQkJXAorCQkqKFNFQ1RJ T05fQUxMKFNFQ1RJT05fUk9EQVRBKSkJCQkJXAogCQlST19BRlRFUl9JTklUX0RBVEEJLyogUmVh ZCBvbmx5IGFmdGVyIGluaXQgKi8JXAogCQkqKF9fdmVybWFnaWMpCQkvKiBLZXJuZWwgdmVyc2lv biBtYWdpYyAqLwlcCiAJCS4gPSBBTElHTig4KTsJCQkJCQlcCkBAIC00MzMsNyArNDM3LDkgQEAK ICAqIGR1cmluZyBzZWNvbmQgbGQgcnVuIGluIHNlY29uZCBsZCBwYXNzIHdoZW4gZ2VuZXJhdGlu ZyBTeXN0ZW0ubWFwICovCiAjZGVmaW5lIFRFWFRfVEVYVAkJCQkJCQlcCiAJCUFMSUdOX0ZVTkNU SU9OKCk7CQkJCQlcCi0JCSooLnRleHQuaG90IFNFQ1RJT05fVEVYVCAudGV4dC5maXh1cCAudGV4 dC51bmxpa2VseSkJXAorCQkqKC50ZXh0LmhvdCBTRUNUSU9OX1RFWFQpCQkJCVwKKwkJKihTT1JU KFNFQ1RJT05fUk5HX0FMTChTRUNUSU9OX1RFWFQpKSkJCQlcCisJCSooLnRleHQuZml4dXAgLnRl eHQudW5saWtlbHkpCQkJCVwKIAkJKihTRUNUSU9OX1JFRikJCQkJCQlcCiAJTUVNX0tFRVAoaW5p dC50ZXh0KQkJCQkJCVwKIAlNRU1fS0VFUChleGl0LnRleHQpCQkJCQkJXApAQCAtNTI5LDYgKzUz NSw3IEBACiAvKiBpbml0IGFuZCBleGl0IHNlY3Rpb24gaGFuZGxpbmcgKi8KICNkZWZpbmUgSU5J VF9EQVRBCQkJCQkJCVwKIAkqKFNFQ1RJT05fSU5JVF9EQVRBKQkJCQkJCVwKKwkqKFNPUlQoU0VD VElPTl9STkdfQUxMKFNFQ1RJT05fSU5JVF9EQVRBKSkpCQkJXAogCU1FTV9ESVNDQVJEKGluaXQu ZGF0YSkJCQkJCQlcCiAJS0VSTkVMX0NUT1JTKCkJCQkJCQkJXAogCU1DT1VOVF9SRUMoKQkJCQkJ CQlcCkBAIC01NTEsNiArNTU4LDcgQEAKIAogI2RlZmluZSBJTklUX1RFWFQJCQkJCQkJXAogCSoo U0VDVElPTl9JTklUKQkJCQkJCQlcCisJKihTT1JUKFNFQ1RJT05fUk5HX0FMTChTRUNUSU9OX0lO SVQpKSkJCQkJXAogCSooLnRleHQuc3RhcnR1cCkJCQkJCQlcCiAJTUVNX0RJU0NBUkQoaW5pdC50 ZXh0KQogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3Jhbmdlcy5oIGIvaW5jbHVkZS9saW51 eC9yYW5nZXMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjMwYjIx ODJiZDQ4NAotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUvbGludXgvcmFuZ2VzLmgKQEAgLTAs MCArMSwxMjggQEAKKyNpZm5kZWYgX0xJTlVYX1JBTkdFU19ICisjZGVmaW5lIF9MSU5VWF9SQU5H RVNfSAorLyoKKyAqIExpbnV4IHNlY3Rpb24gcmFuZ2VzCisgKgorICogQ29weXJpZ2h0IChDKSAy MDE2IEx1aXMgUi4gUm9kcmlndWV6IDxtY2dyb2ZAa2VybmVsLm9yZz4KKyAqCisgKiBUaGlzIHBy b2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1v ZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIGNvcHlsZWZ0LW5leHQgKHZlcnNpb24gMC4z LjEgb3IgbGF0ZXIpIGFzIHB1Ymxpc2hlZAorICogYXQgaHR0cDovL2NvcHlsZWZ0LW5leHQub3Jn Ly4KKyAqLworI2luY2x1ZGUgPGxpbnV4L3NlY3Rpb25zLmg+CisjaW5jbHVkZSA8YXNtL3Jhbmdl cy5oPgorCisjaWZuZGVmIF9fQVNTRU1CTFlfXworCisvKioKKyAqIERPQzogSW50cm9kdWN0aW9u CisgKgorICogQSBzZWN0aW9uIHJhbmdlcyBjb25zaXN0cyBvZiBleHBsaWNpdGx5IGFubm90YXRl ZCBzZXJpZXMgZXhlY3V0YWJsZSBjb2RlCisgKiBzdGl0Y2hlZCB0b2dldGhlciBmb3IgdGhlIHB1 cnBvc2Ugb2Ygc2VsZWN0aXZlIHBsYWNlbWVudCBpbnRvIHN0YW5kYXJkIG9yCisgKiBhcmNoaXRl Y3R1cmUgc3BlY2lmaWMgRUxGIHNlY3Rpb25zLiBXaGF0IEVMRiBzZWN0aW9uIGlzIHVzZWQgaXMg dXRpbGl0eQorICogc3BlY2lmaWMuIExpbnV4IGhhcyBoaXN0b3JpY2FsbHkgaW1wbGljaXRseSB1 c2VkIHNlY3Rpb24gcmFuZ2VzLCBob3dldmVyCisgKiB0aGV5IHdlcmUgYWxsIGJ1aWx0IGluIGFu IGFkaG9jIG1hbm5lciBhbmQgdHlwaWNhbGx5IHJlcXVpcmVkIGxpbmtlciBzY3JpcHQKKyAqIG1v ZGlmaWNhdGlvbnMgcGVyIGFyY2hpdGVjdHVyZS4gVGhlIHNlY3Rpb24gcmFuZ2UgQVBJIGFsbG93 cyBhZGRpbmcgbmV3CisgKiBidW5kbGVzIG9mIHN0aWNoZWQgZXhlY3V0YWJsZSBjb2RlIGludG8g Y3VzdG9tIEVMRiBzZWN0aW9ucyBieSBvbmx5CisgKiBtb2RpZnlpbmcgQyBvciBhc20gY29kZSBp biBhbiBhcmNoaXRlY3R1cmUgYWdub3N0aWMgZm9ybS4KKyAqCisgKiBUaGlzIGRvY3VtZW50cyB0 aGUgc2V0IG9mIGhlbHBlcnMgYXZhaWxhYmxlIHRvIGRlY2xhcmUsIGFuZCBkZWZpbmUgc2VjdGlv bgorICogcmFuZ2VzIGFuZCBhc3NvY2lhdGUgZWFjaCBzZWN0aW9uIHJhbmdlIHRvIGEgc3BlY2lm aWMgTGludXggRUxGIHNlY3Rpb24uCisgKi8KKworLyoqCisgKiBET0M6IFNlY3Rpb24gcmFuZ2Ug bW9kdWxlIHN1cHBvcnQKKyAqCisgKiBNb2R1bGVzIGNhbiB1c2Ugc2VjdGlvbiByYW5nZXMsIGhv d2V2ZXIgdGhlIHNlY3Rpb24gcmFuZ2UgZGVmaW5pdGlvbiBtdXN0IGJlCisgKiBidWlsdC1pbiB0 byB0aGUga2VybmVsLiBUaGF0IGlzLCB0aGUgY29kZSB0aGF0IGltcGxlbWVudHMKKyAqIERFRklO RV9TRUNUSU9OX1JBTkdFKCkgbXVzdCBiZSBidWlsdC1pbiwgYW5kIG1vZHVsYXIgY29kZSBjYW5u b3QgYWRkIG1vcmUKKyAqIGl0ZW1zIGluIHRvIHRoZSBzZWN0aW9uIHJhbmdlICh3aXRoIF9fTElO VVhfUkFOR0UoKSBvcgorICogX19MSU5VWF9SQU5HRV9PUkRFUigpKSwgdW5sZXNzIGtlcm5lbC9t b2R1bGUuYyBmaW5kX21vZHVsZV9zZWN0aW9ucygpIGFuZAorICogbW9kdWxlLWNvbW1vbi5sZHMu UyBhcmUgdXBkYXRlZCBhY2NvcmRpbmdseSB3aXRoIGEgcmVzcGVjdGl2ZSBtb2R1bGUKKyAqIG5v dGlmaWVyIHRvIGFjY291bnQgZm9yIHVwZGF0ZXMuIFRoaXMgcmVzdHJpY3Rpb24gbWF5IGJlIGVu aGFuY2VkIGluIHRoZQorICogZnV0dXJlLgorICovCisKKy8qKgorICogRE9DOiBTZWN0aW9uIHJh bmdlIGhlbHBlcnMKKyAqCisgKiBUaGVzZSBhcmUgaGVscGVycyBmb3Igc2VjdGlvbiByYW5nZXMu CisgKi8KKworLyoqCisgKiBERUNMQVJFX1NFQ1RJT05fUkFOR0UgLSBEZWNsYXJlcyBhIHNlY3Rp b24gcmFuZ2UKKyAqCisgKiBAbmFtZTogc2VjdGlvbiByYW5nZSBuYW1lCisgKgorICogRGVjbGFy ZXMgYSBzZWN0aW9uIHJhbmdlIHRvIGhlbHAgY29kZSBhY2Nlc3MgdGhlIHJhbmdlLiBUeXBpY2Fs bHkgaWYKKyAqIGEgc3Vic3lzdGVtcyBuZWVkcyBjb2RlIHRvIGhhdmUgZGlyZWN0IGFjY2VzcyB0 byB0aGUgc2VjdGlvbiByYW5nZSB0aGUKKyAqIHN1YnN5c3RlbSdzIGhlYWRlciBmaWxlIHdvdWxk IGRlY2xhcmUgdGhlIHNlY3Rpb24gcmFuZ2UuIENhcmUgc2hvdWxkIGJlCisgKiB0YWtlbiB0byBv bmx5IGRlY2xhcmUgdGhlIHNlY3Rpb24gcmFuZ2UgaW4gYSBoZWFkZXIgZmlsZSBpZiBhY2Nlc3Mg dG8gaXQKKyAqIGlzIHRydWx5IG5lZWRlZCBvdXRzaWRlIG9mIHRoZSBjb2RlIGRlZmluaW5nIGl0 LiBZb3UgdHlwaWNhbGx5IHdvdWxkCisgKiByYXRoZXIgaW5zdGVhZCBwcm92aWRlIGhlbHBlcnMg d2hpY2ggYWNjZXNzIHRoZSBzZWN0aW9uIHJhbmdlIHdpdGggc3BlY2lhbAorICogY29kZSBvbiBi ZWhhbGYgb2YgdGhlIGNhbGxlci4KKyAqLworI2RlZmluZSBERUNMQVJFX1NFQ1RJT05fUkFOR0Uo bmFtZSkJCQkJCVwKKwlERUNMQVJFX0xJTlVYX1NFQ1RJT05fUk8oY2hhciwgbmFtZSkKKworLyoq CisgKiBfX1NFQ1RJT05fUkFOR0VfQkVHSU4gLSBDb25zdHJ1Y3RzIHRoZSBiZWdpbm5pbmcgb2Yg YSBzZWN0aW9uIHJhbmdlCisgKgorICogQG5hbWU6IHNlY3Rpb24gcmFuZ2UgbmFtZQorICogQF9f c2VjdGlvbjogRUxGIHNlY3Rpb24gdG8gcGxhY2Ugc2VjdGlvbiByYW5nZSBpbnRvCisgKgorICog Q29uc3RydWN0cyB0aGUgYmVnaW5uaW5nIG9mIGEgc2VjdGlvbiByYW5nZS4gWW91IHdpbGwgdHlw aWNhbGx5IG5vdCBuZWVkCisgKiB0byB1c2UgdGhpcyBkaXJlY3RseS4KKyAqLworI2RlZmluZSBf X1NFQ1RJT05fUkFOR0VfQkVHSU4obmFtZSwgX19zZWN0aW9uKQkJCQlcCisJY29uc3QgX190eXBl b2ZfXyhWTUxJTlVYX1NZTUJPTChuYW1lKVswXSkJCQlcCisJICAgICAgX19hdHRyaWJ1dGVfXygo dXNlZCwJCQkJCVwKKwkJCSAgICAgd2VhaywJCQkJCVwKKwkJCSAgICAgX19hbGlnbmVkX18oTElO VVhfU0VDVElPTl9BTElHTk1FTlQobmFtZSkpLFwKKwkJCSAgICAgc2VjdGlvbihTRUNUSU9OX1JO R19MRVZFTChfX3NlY3Rpb24sIG5hbWUsKSkpKQorCisvKioKKyAqIF9fU0VDVElPTl9SQU5HRV9F TkQgLSBDb25zdHJ1Y3RzIHRoZSBlbmQgb2YgYSBzZWN0aW9uIHJhbmdlCisgKgorICogQG5hbWU6 IHNlY3Rpb24gcmFuZ2UgbmFtZQorICogQF9fc2VjdGlvbjogRUxGIHNlY3Rpb24gdG8gcGxhY2Ug c2VjdGlvbiByYW5nZSBpbnRvCisgKgorICogQ29uc3RydWN0cyB0aGUgZW5kIG9mIGEgc2VjdGlv biByYW5nZS4gWW91IHdpbGwgdHlwaWNhbGx5IG5vdCBuZWVkCisgKiB0byB1c2UgdGhpcyBkaXJl Y3RseS4KKyAqLworI2RlZmluZSBfX1NFQ1RJT05fUkFOR0VfRU5EKG5hbWUsIF9fc2VjdGlvbikJ CQkJXAorCWNvbnN0IF9fdHlwZW9mX18oVk1MSU5VWF9TWU1CT0wobmFtZSlbMF0pCQkJXAorCSAg ICAgIF9fYXR0cmlidXRlX18oKHVzZWQsCQkJCQlcCisJCQkgICAgIF9fYWxpZ25lZF9fKExJTlVY X1NFQ1RJT05fQUxJR05NRU5UKG5hbWUpKSxcCisJCQkgICAgIHNlY3Rpb24oU0VDVElPTl9STkdf TEVWRUwoX19zZWN0aW9uLCBuYW1lLCB+KSkpKQorCisvKioKKyAqIERFRklORV9TRUNUSU9OX1JB TkdFIC0gRGVmaW5lcyBhIHNlY3Rpb24gcmFuZ2UKKyAqCisgKiBAbmFtZTogc2VjdGlvbiByYW5n ZSBuYW1lCisgKiBAc2VjdGlvbjogRUxGIHNlY3Rpb24gbmFtZSB0byBwbGFjZSBzZWN0aW9uIHJh bmdlIGludG8KKyAqCisgKiBEZWZpbmVzIGEgc2VjdGlvbiByYW5nZSwgdXNlZCBmb3IgZXhlY3V0 YWJsZSBjb2RlLiBTZWN0aW9uIHJhbmdlcyBhcmUKKyAqIGRlZmluZWQgaW4gdGhlIGNvZGUgdGhh dCB0YWtlcyBvd25lcnNoaXAgYW5kIG1ha2VzIHVzZSBvZiB0aGUgc2VjdGlvbgorICogcmFuZ2Uu CisgKi8KKyNkZWZpbmUgREVGSU5FX1NFQ1RJT05fUkFOR0UobmFtZSwgc2VjdGlvbikJCQkJXAor CURFQ0xBUkVfTElOVVhfU0VDVElPTl9STyhjaGFyLCBuYW1lKTsJCQkJXAorCV9fU0VDVElPTl9S QU5HRV9CRUdJTihuYW1lLCBzZWN0aW9uKSBWTUxJTlVYX1NZTUJPTChuYW1lKVswXSA9IHt9O1wK KwlfX1NFQ1RJT05fUkFOR0VfRU5EKG5hbWUsIHNlY3Rpb24pIFZNTElOVVhfU1lNQk9MKG5hbWUj I19fZW5kKVswXSA9IHt9CisKKy8qKgorICogU0VDVElPTl9BRERSX0lOX1JBTkdFIC0gcmV0dXJu cyB0cnVlIGlmIGFkZHJlc3MgaXMgaW4gcmFuZ2UKKyAqCisgKiBAbmFtZTogc2VjdGlvbiByYW5n ZSBuYW1lCisgKiBAYWRkcjogYWRkcmVzcyB0byBxdWVyeSBmb3IKKyAqCisgKiBSZXR1cm5zIHRy dWUgaWYgdGhlIGFkZHJlc3MgaXMgaW4gdGhlIHNlY3Rpb24gcmFuZ2UuCisgKi8KKyNkZWZpbmUg U0VDVElPTl9BRERSX0lOX1JBTkdFKG5hbWUsIGFkZHIpCQkJCVwKKwkgKGFkZHIgPj0gKHVuc2ln bmVkIGxvbmcpIExJTlVYX1NFQ1RJT05fU1RBUlQobmFtZSkgJiYJCVwKKwkgIGFkZHIgPCAgKHVu c2lnbmVkIGxvbmcpIExJTlVYX1NFQ1RJT05fRU5EKG5hbWUpKQorCisjZW5kaWYgLyogX19BU1NF TUJMWV9fICovCisKKyNlbmRpZiAvKiBfTElOVVhfUkFOR0VTX0ggKi8KLS0gCjIuOS4yCgoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1h aWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVuLm9yZwpodHRwczovL2xpc3RzLnhlbi5vcmcv eGVuLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:39312 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755458AbcHSVe4 (ORCPT ); Fri, 19 Aug 2016 17:34:56 -0400 From: mcgrof@kernel.org Subject: [PATCH v4 06/16] ranges.h: add helpers to build and identify Linux section ranges Date: Fri, 19 Aug 2016 14:34:04 -0700 Message-ID: <1471642454-5679-7-git-send-email-mcgrof@kernel.org> In-Reply-To: <1471642454-5679-1-git-send-email-mcgrof@kernel.org> References: <1471642454-5679-1-git-send-email-mcgrof@kernel.org> Sender: linux-arch-owner@vger.kernel.org List-ID: To: hpa@zytor.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, linux@arm.linux.org.uk, 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 Cc: x86@kernel.org, luto@amacapital.net, keescook@chromium.org, 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, ananth@in.ibm.com, 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, acme@redhat.com, jolsa@kernel.org, msalter@redhat.com, chris@zankel.net, jcmvbkbc@gmail.com, linux-xtensa@linux-xtensa.org, paulus@samba.org, mpe@ellerman.id.au, James.Bottomley@HansenPartnership.com, "Luis R. Rodriguez" Message-ID: <20160819213404.sCNcl5M_LBSrgN1r4ZU-D4QwVRm1orX7mUBjk2Ecyfg@z> From: "Luis R. Rodriguez" 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 anable architectures to override what asm is used for section ranges but start by default trusting the asm-generic version all around. 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 | 49 ++++++++++++++ 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/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 | 89 ++++++++++++++++++++++++++ include/asm-generic/vmlinux.lds.h | 12 +++- include/linux/ranges.h | 128 +++++++++++++++++++++++++++++++++++++ 38 files changed, 320 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 d411e9b22eb3..6dd93ddd5dbe 100644 --- a/Documentation/sections/index.rst +++ b/Documentation/sections/index.rst @@ -9,3 +9,4 @@ used throughout the kernel to help declare and define them. :maxdepth: 4 section-core + ranges diff --git a/Documentation/sections/ranges.rst b/Documentation/sections/ranges.rst new file mode 100644 index 000000000000..1293dcb3ab38 --- /dev/null +++ b/Documentation/sections/ranges.rst @@ -0,0 +1,49 @@ +==================== +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 + +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 + +SECTION_ADDR_IN_RANGE +--------------------- +.. kernel-doc:: include/linux/ranges.h + :functions: SECTION_ADDR_IN_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/MAINTAINERS b/MAINTAINERS index 689c12075842..1a217751aa8a 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5217,6 +5217,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 9a0929576de1..e5295413fdf8 100644 --- a/arch/arc/include/asm/Kbuild +++ b/arch/arc/include/asm/Kbuild @@ -51,3 +51,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 47923635be16..8e52300e1eed 100644 --- a/arch/arm/include/asm/Kbuild +++ b/arch/arm/include/asm/Kbuild @@ -40,3 +40,4 @@ generic-y += timex.h generic-y += trace_clock.h generic-y += unaligned.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 42d00806e4fb..5ff184574976 100644 --- a/arch/arm64/include/asm/Kbuild +++ b/arch/arm64/include/asm/Kbuild @@ -53,3 +53,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 7de674411bed..35b7752e65c0 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -49,3 +49,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 eef72c464c9b..d465f51c2088 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -36,3 +36,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 50ebd5a30d16..c869b1ebd583 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -57,3 +57,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 12f7c5984c03..ed225600c8a4 100644 --- a/arch/mips/include/asm/Kbuild +++ b/arch/mips/include/asm/Kbuild @@ -21,3 +21,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 6f43f33f0e0f..1a263a7158e2 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -30,3 +30,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 b49fab7bab2f..065c6e84fb67 100644 --- a/arch/powerpc/include/asm/Kbuild +++ b/arch/powerpc/include/asm/Kbuild @@ -8,3 +8,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/s390/include/asm/Kbuild b/arch/s390/include/asm/Kbuild index 89e74b59f32d..3e8b95927cb5 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 d51b84d6b4b7..79664d10e63b 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild @@ -23,3 +23,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 7b8a652e43ae..951fa4be571d 100644 --- a/arch/tile/include/asm/Kbuild +++ b/arch/tile/include/asm/Kbuild @@ -42,3 +42,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 e9849834d55e..99be54949b99 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -28,3 +28,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 256c45b3ae34..6c35905fe371 100644 --- a/arch/unicore32/include/asm/Kbuild +++ b/arch/unicore32/include/asm/Kbuild @@ -64,3 +64,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 f6914a57bc16..f790756fdb48 100644 --- a/arch/x86/include/asm/Kbuild +++ b/arch/x86/include/asm/Kbuild @@ -17,3 +17,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 0c2fae8d929d..c215db049920 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 81ca6816bd72..221b6b652500 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -32,3 +32,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..74cd941aa2f8 --- /dev/null +++ b/include/asm-generic/ranges.h @@ -0,0 +1,89 @@ +#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 + +#define SECTION_RNG(section, name) \ + SECTION_CORE(section, rng, name, \ + SECTION_ORDER_ANY) + +#define SECTION_RNG_LEVEL(section, name, level) \ + SECTION_CORE(section, rng, name, level) + +#define SECTION_RNG_ALL(section) \ + SECTION_CORE_ALL(section,rng) + +#ifndef set_section_rng +# define set_section_rng(section, name, flags) \ + set_section_core(section, rng, name, \ + SECTION_ORDER_ANY, flags) +#endif + +#ifndef set_section_rng_type +# define set_section_rng_type(section, name, flags, type) \ + set_section_core_type(section, rng, name, \ + SECTION_ORDER_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, \ + SECTION_ORDER_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(section, name)))) + +/** + * __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_LEVEL(section, name, level)))) + +#endif /* __ASSEMBLY__ */ + +#endif /* _ASM_GENERIC_RANGES_H_ */ diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index 731087276a32..ad843555e6a4 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) @@ -200,6 +201,7 @@ /* .data section */ #define DATA_DATA \ *(SECTION_DATA) \ + *(SORT(SECTION_RNG_ALL(SECTION_DATA))) \ *(SECTION_REF_DATA) \ *(.data..shared_aligned) /* percpu related */ \ MEM_KEEP(init.data) \ @@ -265,7 +267,9 @@ . = ALIGN((align)); \ SECTION_RODATA : AT(ADDR(SECTION_RODATA) - LOAD_OFFSET) { \ VMLINUX_SYMBOL(__start_rodata) = .; \ - *(SECTION_RODATA) *(SECTION_ALL(SECTION_RODATA)) \ + *(SECTION_RODATA) \ + *(SORT(SECTION_RNG_ALL(SECTION_RODATA))) \ + *(SECTION_ALL(SECTION_RODATA)) \ RO_AFTER_INIT_DATA /* Read only after init */ \ *(__vermagic) /* Kernel version magic */ \ . = ALIGN(8); \ @@ -433,7 +437,9 @@ * during second ld run in second ld pass when generating System.map */ #define TEXT_TEXT \ ALIGN_FUNCTION(); \ - *(.text.hot SECTION_TEXT .text.fixup .text.unlikely) \ + *(.text.hot SECTION_TEXT) \ + *(SORT(SECTION_RNG_ALL(SECTION_TEXT))) \ + *(.text.fixup .text.unlikely) \ *(SECTION_REF) \ MEM_KEEP(init.text) \ MEM_KEEP(exit.text) \ @@ -529,6 +535,7 @@ /* init and exit section handling */ #define INIT_DATA \ *(SECTION_INIT_DATA) \ + *(SORT(SECTION_RNG_ALL(SECTION_INIT_DATA))) \ MEM_DISCARD(init.data) \ KERNEL_CTORS() \ MCOUNT_REC() \ @@ -551,6 +558,7 @@ #define INIT_TEXT \ *(SECTION_INIT) \ + *(SORT(SECTION_RNG_ALL(SECTION_INIT))) \ *(.text.startup) \ MEM_DISCARD(init.text) diff --git a/include/linux/ranges.h b/include/linux/ranges.h new file mode 100644 index 000000000000..30b2182bd484 --- /dev/null +++ b/include/linux/ranges.h @@ -0,0 +1,128 @@ +#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. + */ + +/** + * 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__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + weak, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_RNG_LEVEL(__section, 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__(VMLINUX_SYMBOL(name)[0]) \ + __attribute__((used, \ + __aligned__(LINUX_SECTION_ALIGNMENT(name)),\ + section(SECTION_RNG_LEVEL(__section, 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) VMLINUX_SYMBOL(name)[0] = {};\ + __SECTION_RANGE_END(name, section) VMLINUX_SYMBOL(name##__end)[0] = {} + +/** + * SECTION_ADDR_IN_RANGE - returns true if address is in range + * + * @name: section range name + * @addr: address to query for + * + * Returns true if the address is in the section range. + */ +#define SECTION_ADDR_IN_RANGE(name, addr) \ + (addr >= (unsigned long) LINUX_SECTION_START(name) && \ + addr < (unsigned long) LINUX_SECTION_END(name)) + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_RANGES_H */ -- 2.9.2