From mboxrd@z Thu Jan 1 00:00:00 1970 From: mcgrof@kernel.org Subject: [PATCH v4 04/16] generic-sections: add section core helpers Date: Fri, 19 Aug 2016 14:32:53 -0700 Message-ID: <1471642385-5629-5-git-send-email-mcgrof@kernel.org> References: <1471642385-5629-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: <1471642385-5629-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+CgpMaW51eCBtYWtl cyBleHRlbnNpdmUgdXNlIG9mIGN1c3RvbSBFTEYgaGVhZGVyIHNlY3Rpb25zLApkb2N1bWVudGF0 aW9uIGZvciB0aGVzZSBhcmUgd2VsbCBzY2F0dGVycmVkLiBVbmlmeSB0aGlzCmRvY3VtZW50YXRp b24gaW4gYSBjZW50cmFsIHBsYWNlIGFuZCBwcm92aWRlIGhlbHBlcnMgdG8KYnVpbGQgY3VzdG9t IExpbnV4IHNlY3Rpb25zLgoKVGhpcyBhbHNvIGdlbmVyYWxpemVzIHNlY3Rpb25zIGNvZGUgdG8g ZW5hYmxlIGF2b2lkaW5nCm1vZGlmeWluZyB0aGUgbGlua2VyIHNjcmlwdHMgd2hlbiB3ZSB3YW50 IHRvIGFkZCBuZXcKY3VzdG9tIExpbnV4IHNlY3Rpb25zLiBJbiBvcmRlciB0byBtYWtlIHRoaXMg Z2VuZXJhbGx5CnVzZWZ1bCB3ZSBuZWVkIHRvIGVuc3VyZSBhbGwgYXJjaGl0ZWN0dXJlcyBjYW4g bWFrZSB1c2Ugb2YKY29yZSBzZWN0aW9uIGhlbHBlcnMgYnV0IHRoYXQgdGhleSBjYW4gYWxzbyBv dmVycmlkZSBzaG91bGQKdGhpcyBiZSBuZWVkZWQuIEluc3RlYWQgb2YgcmVseWluZyBvbiBzZWN0 aW9uLmggdGhpcyBhZGRzCmEgc2VjdGlvbnMtY29yZS5oIHNpbmNlIHRoaXMgd2lsbCBiZSB0YXJn ZXR0ZWQgdG8gYmUgc2FmZQp0byBiZSB1c2VkIG9uIGFzbSBjb2RlLCBsaW5rZXIgc2NyaXB0cyBh bmQgQyBjb2RlLgoKdjQ6CgpvIFBvcnQgdG8gc2hpbnkgbmV3IHNwaGlueCBkb2N1bWVudGF0aW9u IGZvcm1hdAoKbyBmaXggYSB1bmljb3JlMzIgYnVpbGQsIHR1cm5zIG91dCB0aGlzIGFjdHVhbGx5 IGZpeGVzIHVuaWNvcmUzMgogIGRlZmNvbmZpZyBidWlsZHMgd2hpY2ggd2VyZSBmYWlsaW5nIGZv ciBhIGxvbmcgd2hpbGUuIHVuaWNvcmUzMgogIGRvZXMgbm90IHNlZW0gdG8gZ3JvayB3ZWxsIHRo ZSB0eXBlIHBhc3NlZCBvbiBhIHNlY3Rpb24gZGVjbGFyYXRpb24sCiAgdGhpcyBpZ25vcmVzIGl0 LgoKbyBVc2UgVk1MSU5VWF9TWU1CT0woKSBpbiBtb3JlIHVzZXIgc3ltYm9scyAoZXh0ZXJuIEMg Y29kZSksIG5vdCBkb2luZwogIHRoaXMgd2FzIGNhdXNpbmcgZmluYWwgbGlua2VyIGlzc3VlcyB3 aXRoIGJsYWNrZmluIC0tIHRoaXMgaXMKICBhIENPTkZJR19IQVZFX1VOREVSU0NPUkVfU1lNQk9M X1BSRUZJWD15IGFyY2hpdGVjdHVyZS4gVGhlIG90aGVyIG9uZQogIGJlaW5nIG1ldGF0YWcuIG1l dGF0YWcgaXMgbm90IHN1cHBvcnRlZCBvbiAwLWRheSBzbyBJIGNhbm5vdCBjb25maXJtCiAgY29t cGlsYXRpb24gdGhlcmUuCgpvIEFkZGVkIFNFQ1RJT05fQ09SRSgpIGZvciBDIGNvZGUsIHVzZWQg bGF0ZXIgYnkgX19MSU5VWF9SQU5HRSgpCgpvIFNpbmNlIFNFQ1RJT05fQ09SRSgpIGlzIGRlZmlu ZWQgZm9yIGxpbmtlciBzY3JpcHQgYW5kIEMgY29kZSwgc2hhcmUKICB0aGUgc2FtZSBoZWxwZXIg YW5kIGp1c3QgdXNlIGEgX19zdHJpbmdpZnkoKSBmb3IgdGhlIEMgY29kZSBhcyBpcyBkb25lCiAg Zm9yIHRoZSBvdGhlciBDIGhlbHBlcnMuCgpvIG1vdmUgZ2VuZXJpYyBzZWN0aW9ucyB0byBhc20t Z2VuZXJpYy9zZWN0aW9uLWNvcmUuaCBpbnN0ZWFkLgogIFBvd2VyUEMgY29tcGlsYXRpb24gYmxv d3MgdXAgaWYgYXNtL2p1bXBfbGFiZWxzLmggZ2V0cwogIHNlY3Rpb24uaCBpbmNsdWRlZCwgZml4 aW5nIHRoaXMgaXMgbm90IGluIGFueSB3YXkgZWFzeS4KICBUaGUgbGlzdCBvZiBpc3N1ZXMgYXJl IGVuZGxlc3MuIE1vdmluZyBuZXcgZGF0YSB0byBhIG5ldwogIHNpbXBsZSBmaWxlIHJlc29sdmVz IHRoaXMuCgpvIHNpbmNlIHRoaW5ncyBhcmUgbm93IGluIGFzbS1nZW5lcmljL3NlY3Rpb24tY29y ZS5oIHRoZQogIGd1YXJkIGNoYW5nZXMgb24gYXNtLWdlbmVyaWMvc2VjdGlvbnMuaCBhbmQgZWFj aCBhcmNoaXRlY3R1cmUKICBzZWN0aW9ucy5oIGFyZSBubyBsb25nZXIgbmVlZGVkCgpvIEdpdmUg Z2VuZXJpYyBzZWN0aW9ucyBzb21lIG1haW50YWluZXIgbG92ZSwgdGhhdCBjaGFuZ2UgaXMKICBB Y2tlZC1ieSBBcm5kIEJlcmdtYW5uLCBKb3NoIGFuZCBocGEuCgpvIEEgZmV3IGNoZWNrcGF0Y2gu cGwgc3R5bGUgZml4ZXMKCm8gQXMgc3VnZ2VzdGVkIGJ5IEphbWVzIEhvZ2FuIHVzZSBnZW5lcmlj LXkgdG8gY29weSBnZW5lcmljCiAgaGVhZGVyIGZpbGVzIG9uIGFyY2hpdGVjdHVyZXMgdGhhdCBk byBub3QgaGF2ZSBhIHNlY3Rpb25zLmgKICBpbnN0ZWFkIG9mIHdyaXRpbmcgYSBzaW1wbGUgZmls ZSBvbmx5IHRvIGluY2x1ZGUgdGhlIGdlbmVyaWMgb25lLgoKdjM6CgpvIGFkZCBtaXNzaW5nIHNl Y3Rpb25zLmggZm9yIGFyY2hpdGVjdHVyZXMgdGhhdCBkaWQgbm90CiAgaGF2ZSBpdAoKbyBtb3Zl IGdlbmVyaWMgc2VjdGlvbnMgdG8gYXNtLWdlbmVyaWMvc2VjdGlvbnMuaAoKbyBhZGQgZ2VuZXJp YyBhc20gaGVscGVycyBzZWN0aW9uX3R5cGUoKSwgc2VjdGlvbl90eXBlX2FzbXR5cGUoKSwKICBw dXNoX3NlY3Rpb25fdHlwZSgpIC0tIHRoZXNlIGhlbHBlcnMgZW5hYmxlIGVhc3kgdXNlIGZvcgog IGZvciBsYXRlciBkZWNsYXJpbmcgYW5kIHVzaW5nIG9mIGN1c3RvbSBsaW51eCBzZWN0aW9ucyB1 c2luZwogIG1vcmUgc3RhbmRhcmQgQVBJcyBpbiBib3RoIEMgY29kZSwgYXNtIGNvZGUgKEMgYXNt IGNhbGxzLCBvcgogIGFzbSBmaWxlcyksIGVuYWJsaW5nIGZ1dHVyZSBzdGFuZGFyZGl6ZWQgc2Vj dGlvbiB0eXBlcyB0bwogIGJlIG1vcmUgaW1tZWRpYXRlbHkgYWNjZXNzaWJsZSB0byBhc20gY29k ZSwgbm90IGp1c3QgQyBjb2RlLgogIE5vdGUgZm9yIEFTTV9DTURfU0VQIHdlIHVzZSBieSBkZWZh dWx0ICJcbiIsIGFyY2hpdGVjdHVyZXMgbmVlZGVkCiAgdG8gb3ZlcnJpZGUgY2FuIGRvIHNvIG9u IHRoZWlyIG93biBzZWN0aW9ucy5oIHByaW9yIHRvIGluY2x1c2lvbgogIG9mIGFzbS1nZW5lcmlj L3NlY3Rpb25zLmgKClNpZ25lZC1vZmYtYnk6IEx1aXMgUi4gUm9kcmlndWV6IDxtY2dyb2ZAa2Vy bmVsLm9yZz4KLS0tCiBEb2N1bWVudGF0aW9uL2luZGV4LnJzdCAgICAgICAgICAgICAgICAgICB8 ICAgMSArCiBEb2N1bWVudGF0aW9uL3NlY3Rpb25zL2NvbmYucHkgICAgICAgICAgICB8ICAgNCAr CiBEb2N1bWVudGF0aW9uL3NlY3Rpb25zL2luZGV4LnJzdCAgICAgICAgICB8ICAxMSArCiBEb2N1 bWVudGF0aW9uL3NlY3Rpb25zL3NlY3Rpb24tY29yZS5yc3QgICB8IDE1MyArKysrKysrKysrKysr KwogTUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMTQgKysKIGFy Y2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJj L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJtL2luY2x1 ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJtNjQvaW5jbHVkZS9h c20vS2J1aWxkICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXZyMzIvaW5jbHVkZS9hc20vS2J1 aWxkICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxk ICAgICAgICAgIHwgICAxICsKIGFyY2gvYzZ4L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAg ICAgIHwgICAxICsKIGFyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgIHwg ICAxICsKIGFyY2gvZnJ2L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgIHwgICAxICsK IGFyY2gvaDgzMDAvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgIHwgICAxICsKIGFyY2gv aGV4YWdvbi9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgIHwgICAxICsKIGFyY2gvaWE2NC9p bmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvbTMyci9pbmNsdWRl L2FzbS9LYnVpbGQgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvbTY4ay9pbmNsdWRlL2FzbS9L YnVpbGQgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxk ICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9LYnVpbGQg ICAgICAgIHwgICAxICsKIGFyY2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAg IHwgICAxICsKIGFyY2gvbW4xMDMwMC9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgIHwgICAx ICsKIGFyY2gvbmlvczIvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgIHwgICAxICsKIGFy Y2gvb3BlbnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgIHwgICAxICsKIGFyY2gvcGFy aXNjL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcG93ZXJwYy9p bmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgIHwgICAxICsKIGFyY2gvczM5MC9pbmNsdWRlL2Fz bS9LYnVpbGQgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvc2NvcmUvaW5jbHVkZS9hc20vS2J1 aWxkICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvc2gvaW5jbHVkZS9hc20vS2J1aWxkICAgICAg ICAgICAgICAgIHwgICAxICsKIGFyY2gvc3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAg ICAgIHwgICAxICsKIGFyY2gvdGlsZS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgIHwg ICAxICsKIGFyY2gvdW0vaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICAgIHwgICAxICsK IGFyY2gvdW5pY29yZTMyL2luY2x1ZGUvYXNtL3NlY3Rpb24tY29yZS5oIHwgIDE5ICsrCiBhcmNo L3g4Ni9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL3h0ZW5z YS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICB8ICAgMSArCiBpbmNsdWRlL2FzbS1nZW5l cmljL3NlY3Rpb24tY29yZS5oICAgICAgICB8IDM0MSArKysrKysrKysrKysrKysrKysrKysrKysr KysrKysKIGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbnMuaCAgICAgICAgICAgIHwgICAyICsK IGluY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaCAgICAgICAgIHwgIDI3ICstLQogaW5j bHVkZS9saW51eC9zZWN0aW9ucy5oICAgICAgICAgICAgICAgICAgfCAxMTEgKysrKysrKysrKwog NDAgZmlsZXMgY2hhbmdlZCwgNzAwIGluc2VydGlvbnMoKyksIDEzIGRlbGV0aW9ucygtKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vc2VjdGlvbnMvY29uZi5weQogY3JlYXRlIG1v ZGUgMTAwNjQ0IERvY3VtZW50YXRpb24vc2VjdGlvbnMvaW5kZXgucnN0CiBjcmVhdGUgbW9kZSAx MDA2NDQgRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9zZWN0aW9uLWNvcmUucnN0CiBjcmVhdGUgbW9k ZSAxMDA2NDQgYXJjaC91bmljb3JlMzIvaW5jbHVkZS9hc20vc2VjdGlvbi1jb3JlLmgKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCiBjcmVhdGUg bW9kZSAxMDA2NDQgaW5jbHVkZS9saW51eC9zZWN0aW9ucy5oCgpkaWZmIC0tZ2l0IGEvRG9jdW1l bnRhdGlvbi9pbmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL2luZGV4LnJzdAppbmRleCBhMTVmODE4 NTViMzkuLjEwYzliODY3ZTMyNiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9pbmRleC5yc3QK KysrIGIvRG9jdW1lbnRhdGlvbi9pbmRleC5yc3QKQEAgLTE0LDYgKzE0LDcgQEAgQ29udGVudHM6 CiAgICBrZXJuZWwtZG9jdW1lbnRhdGlvbgogICAgbWVkaWEvaW5kZXgKICAgIGdwdS9pbmRleAor ICAgc2VjdGlvbnMvaW5kZXgKIAogSW5kaWNlcyBhbmQgdGFibGVzCiA9PT09PT09PT09PT09PT09 PT0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvY29uZi5weSBiL0RvY3VtZW50 YXRpb24vc2VjdGlvbnMvY29uZi5weQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLmZhYTFjNTc1OTVlMQotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vc2Vj dGlvbnMvY29uZi5weQpAQCAtMCwwICsxLDQgQEAKKyMgLSotIGNvZGluZzogdXRmLTg7IG1vZGU6 IHB5dGhvbiAtKi0KKworcHJvamVjdCA9ICdMaW51eCBLZXJuZWwgRUxGIHNlY3Rpb25zJworaHRt bF9zZWFyY2hfbGFuZ3VhZ2UgPSAnZW4nCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NlY3Rp b25zL2luZGV4LnJzdCBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvaW5kZXgucnN0Cm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZDQxMWU5YjIyZWIzCi0tLSAvZGV2L251 bGwKKysrIGIvRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9pbmRleC5yc3QKQEAgLTAsMCArMSwxMSBA QAorPT09PT09PT09PT09PT09PT09PT09PT09PQorTGludXggS2VybmVsIEVMRiBzZWN0aW9ucwor PT09PT09PT09PT09PT09PT09PT09PT09PQorCitUaGlzIGJvb2sgZG9jdW1lbnRzIHRoZSBMaW51 eCBrZXJuZWwncyB1c2Ugb2YgRUxGIHNlY3Rpb25zLCBhcyB3ZWxsIGFzIGhlbHBlcnMKK3VzZWQg dGhyb3VnaG91dCB0aGUga2VybmVsIHRvIGhlbHAgZGVjbGFyZSBhbmQgZGVmaW5lIHRoZW0uCisK Ky4uIHRvY3RyZWU6OgorICAgOm1heGRlcHRoOiA0CisKKyAgIHNlY3Rpb24tY29yZQpkaWZmIC0t Z2l0IGEvRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9zZWN0aW9uLWNvcmUucnN0IGIvRG9jdW1lbnRh dGlvbi9zZWN0aW9ucy9zZWN0aW9uLWNvcmUucnN0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMC4uZWNmNDIyOGJjNGY4Ci0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRh dGlvbi9zZWN0aW9ucy9zZWN0aW9uLWNvcmUucnN0CkBAIC0wLDAgKzEsMTUzIEBACis9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KK0NvcmUgTGludXgga2VybmVsIEVMRiBzZWN0aW9ucwor PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CisKK0Fib3V0Cis9PT09PQorCitUaGlzIGJv b2sgZG9jdW1lbnRzIHRoZSBkaWZmZXJlbnQgc3RhbmRhcmQgYW5kIGN1c3RvbSBFTEYgc2VjdGlv bnMgdXNlZAorb24gdGhlIExpbnV4IGtlcm5lbCwgd2hpY2ggd2UgcmVmZXIgdG8gYXMgdGhlIGBg Y29yZSBMaW51eCBzZWN0aW9uc2BgLiBXZQorc3RhcnQgb2ZmIGJ5IGRvY3VtZW50aW5nIHRoZSBz dGFuZGFyZCBFTEYgc2VjdGlvbnMgdXNlZCBieSBMaW51eCBhbmQgbW92ZQorb24gdG8gdGhlIGJh c2ljIGN1c3RvbSBFTEYgc2VjdGlvbnMsIGZvbGxvd2VkIGJ5IGEgc2V0IG9mIGhlbHBlcnMuIEVh Y2gKK3NlY3Rpb24gZG9jdW1lbnRlZCBkZXNjcmliZXMgdGhlIGdvYWwgb2YgdGhlIHNlY3Rpb24s IGFuZCBhZGRyZXNzZXMKK2NvbmN1cnJlbmN5IGNvbnNpZGVyYXRpb25zIHdoZW4gYXBwbGljYWJs ZS4KKworLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgK KyAgIDpkb2M6IEN1c3RvbSBsaW5rZXIgc2NyaXB0CisKK1N0YW5kYXJkIEVMRiBzZWN0aW9uIHVz ZSBpbiBMaW51eAorPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CisKKy4uIGtlcm5l bC1kb2M6OiBpbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCisgICA6ZG9jOiBTdGFu ZGFyZCBFTEYgc2VjdGlvbiB1c2UgaW4gTGludXgKKworU0VDVElPTl9ST0RBVEEKKy0tLS0tLS0t LS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUu aAorICAgOmRvYzogU0VDVElPTl9ST0RBVEEKKworU0VDVElPTl9ST0RBVEEKKy0tLS0tLS0tLS0t LS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAor ICAgOmRvYzogU0VDVElPTl9URVhUCisKK1NFQ1RJT05fREFUQQorLS0tLS0tLS0tLS0tCisuLiBr ZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAorICAgOmRvYzog U0VDVElPTl9EQVRBCisKK0xpbnV4IC5pbml0XCogc2VjdGlvbnMKKz09PT09PT09PT09PT09PT09 PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3Jl LmgKKyAgIDpkb2M6IExpbnV4IGluaXQgc2VjdGlvbnMKKworU0VDVElPTl9JTklUX0RBVEEKKy0t LS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0 aW9uLWNvcmUuaAorICAgOmRvYzogU0VDVElPTl9JTklUX0RBVEEKKworU0VDVElPTl9JTklUX1JP REFUQQorLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdl bmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IFNFQ1RJT05fSU5JVF9ST0RBVEEKKworU0VD VElPTl9JTklUX0NBTEwKKy0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVk ZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAorICAgOmRvYzogU0VDVElPTl9JTklUX0NBTEwK KworTGludXggLmV4aXRcKiBzZWN0aW9ucworPT09PT09PT09PT09PT09PT09PT09PQorCisuLiBr ZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAorICAgOmRvYzog TGludXggZXhpdCBzZWN0aW9ucworCitTRUNUSU9OX0VYSVQKKy0tLS0tLS0tLS0tLQorLi4ga2Vy bmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IFNF Q1RJT05fRVhJVAorCitTRUNUSU9OX0VYSVRfREFUQQorLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtl cm5lbC1kb2M6OiBpbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCisgICA6ZG9jOiBT RUNUSU9OX0VYSVRfREFUQQorCitTRUNUSU9OX0VYSVRfQ0FMTAorLS0tLS0tLS0tLS0tLS0tLS0K Ky4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCisgICA6 ZG9jOiBTRUNUSU9OX0VYSVRfQ0FMTAorCitMaW51eCAucmVmXCogc2VjdGlvbnMKKz09PT09PT09 PT09PT09PT09PT09PQorCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0 aW9uLWNvcmUuaAorICAgOmRvYzogTGludXggcmVmZXJlbmNlcyB0byBpbml0IHNlY3Rpb25zCisK K1NFQ1RJT05fUkVGCistLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdl bmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IFNFQ1RJT05fUkVGCisKK1NFQ1RJT05fUkVG X0RBVEEKKy0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2FzbS1nZW5l cmljL3NlY3Rpb24tY29yZS5oCisgICA6ZG9jOiBTRUNUSU9OX1JFRl9EQVRBCisKK1NFQ1RJT05f UkVGX1JPREFUQQorLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9h c20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAorICAgOmRvYzogU0VDVElPTl9SRUZfUk9EQVRBCisK K0xpbnV4IHNlY3Rpb24gb3JkZXJpbmcKKz09PT09PT09PT09PT09PT09PT09PT0KKy4uIGtlcm5l bC1kb2M6OiBpbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCisgICA6ZG9jOiBMaW51 eCBzZWN0aW9uIG9yZGVyaW5nCisKK1NFQ1RJT05fT1JERVJfQU5ZCistLS0tLS0tLS0tLS0tLS0t LQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAg IDpkb2M6IFNFQ1RJT05fT1JERVJfQU5ZCisKK0dlbmVyaWMgTGludXgga2VybmVsIHNlY3Rpb24g aGVscGVycworPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CisKK0ludHJvZHVj dGlvbgorLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvc2VjdGlv bnMuaAorICAgOmRvYzogSW50cm9kdWN0aW9uCisKK0xJTlVYX1NFQ1RJT05fQUxJR05NRU5UCist LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvc2Vj dGlvbnMuaAorICAgOmZ1bmN0aW9uczogTElOVVhfU0VDVElPTl9BTElHTk1FTlQKKworTElOVVhf U0VDVElPTl9TSVpFCistLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRl L2xpbnV4L3NlY3Rpb25zLmgKKyAgIDpmdW5jdGlvbnM6IExJTlVYX1NFQ1RJT05fU0laRQorCitM SU5VWF9TRUNUSU9OX0VNUFRZCistLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjog aW5jbHVkZS9saW51eC9zZWN0aW9ucy5oCisgICA6ZnVuY3Rpb25zOiBMSU5VWF9TRUNUSU9OX0VN UFRZCisKK0xJTlVYX1NFQ1RJT05fU1RBUlQKKy0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5l bC1kb2M6OiBpbmNsdWRlL2xpbnV4L3NlY3Rpb25zLmgKKyAgIDpmdW5jdGlvbnM6IExJTlVYX1NF Q1RJT05fU1RBUlQKKworTElOVVhfU0VDVElPTl9FTkQKKy0tLS0tLS0tLS0tLS0tLS0tCisuLiBr ZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC9zZWN0aW9ucy5oCisgICA6ZnVuY3Rpb25zOiBMSU5V WF9TRUNUSU9OX0VORAorCitERUNMQVJFX0xJTlVYX1NFQ1RJT04KKy0tLS0tLS0tLS0tLS0tLS0t LS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvbGludXgvc2VjdGlvbnMuaAorICAgOmZ1bmN0 aW9uczogREVDTEFSRV9MSU5VWF9TRUNUSU9OCisKK0RFQ0xBUkVfTElOVVhfU0VDVElPTl9STwor LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC9z ZWN0aW9ucy5oCisgICA6ZnVuY3Rpb25zOiBERUNMQVJFX0xJTlVYX1NFQ1RJT05fUk8KZGlmZiAt LWdpdCBhL01BSU5UQUlORVJTIGIvTUFJTlRBSU5FUlMKaW5kZXggNWFlYzAxODgzMDIwLi42ODlj MTIwNzU4NDIgMTAwNjQ0Ci0tLSBhL01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC01 MjE3LDYgKzUyMTcsMjAgQEAgUzoJU3VwcG9ydGVkCiBGOglkcml2ZXJzL2Jhc2UvcG93ZXIvZG9t YWluKi5jCiBGOglpbmNsdWRlL2xpbnV4L3BtX2RvbWFpbi5oCiAKK0dFTkVSSUMgU0VDVElPTlMK K006CSJMdWlzIFIuIFJvZHJpZ3VleiIgPG1jZ3JvZkBrZXJuZWwub3JnPgorTToJSm9zaCBQb2lt Ym9ldWYgPGpwb2ltYm9lQHJlZGhhdC5jb20+CitNOgkiSC4gUGV0ZXIgQW52aW4iIDxocGFAenl0 b3IuY29tPgorTDoJbGludXgtYXJjaEB2Z2VyLmtlcm5lbC5vcmcKK0w6CWxpbnV4LWtlcm5lbEB2 Z2VyLmtlcm5lbC5vcmcKK1Q6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4 L2tlcm5lbC9naXQvbWNncm9mL2xpbnV4LmdpdCBmb3ItYXJuZAorVDoJZ2l0IGdpdDovL2dpdC5r ZXJuZWwub3JnL3B1Yi9zY20vbGludXgva2VybmVsL2dpdC9tY2dyb2YvbGludXgtbmV4dC5naXQg Zm9yLWFybmQKK1M6CVN1cHBvcnRlZAorRjoJaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNv cmUuaAorRjoJaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9ucy5oCitGOglpbmNsdWRlL2FzbS1n ZW5lcmljL3ZtbGludXgubGRzLmgKK0Y6CURvY3VtZW50YXRpb24vc2VjdGlvbnMvc2VjdGlvbi1j b3JlLnJzdAorCiBHRU5FUklDIFVJTyBEUklWRVIgRk9SIFBDSSBERVZJQ0VTCiBNOgkiTWljaGFl bCBTLiBUc2lya2luIiA8bXN0QHJlZGhhdC5jb20+CiBMOglrdm1Admdlci5rZXJuZWwub3JnCmRp ZmYgLS1naXQgYS9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvYWxwaGEvaW5j bHVkZS9hc20vS2J1aWxkCmluZGV4IGJmODQ3NWNlODVlZS4uNTQyMjgyN2YxNTg1IDEwMDY0NAot LS0gYS9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2FscGhhL2luY2x1 ZGUvYXNtL0tidWlsZApAQCAtMTAsMyArMTAsNCBAQCBnZW5lcmljLXkgKz0gbW0tYXJjaC1ob29r cy5oCiBnZW5lcmljLXkgKz0gcHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbnMuaAogZ2Vu ZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaApkaWZm IC0tZ2l0IGEvYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9hcmMvaW5jbHVkZS9h c20vS2J1aWxkCmluZGV4IDBiMTBlZjJhNDM3Mi4uOWEwOTI5NTc2ZGUxIDEwMDY0NAotLS0gYS9h cmNoL2FyYy9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1 aWxkCkBAIC01MCwzICs1MCw0IEBAIGdlbmVyaWMteSArPSB1c2VyLmgKIGdlbmVyaWMteSArPSB2 Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAor Z2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRl L2FzbS9LYnVpbGQgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMDc0NTUzOGIy NmQzLi40NzkyMzYzNWJlMTYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL0tidWls ZAorKysgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTM5LDMgKzM5LDQgQEAgZ2Vu ZXJpYy15ICs9IHRlcm1pb3MuaAogZ2VuZXJpYy15ICs9IHRpbWV4LmgKIGdlbmVyaWMteSArPSB0 cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gdW5hbGlnbmVkLmgKK2dlbmVyaWMteSArPSBzZWN0 aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9h cmNoL2FybTY0L2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBmNDNkMmM0NGM3NjUuLjQyZDAwODA2 ZTRmYiAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJj aC9hcm02NC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTUyLDMgKzUyLDQgQEAgZ2VuZXJpYy15ICs9 IHVuYWxpZ25lZC5oCiBnZW5lcmljLXkgKz0gdXNlci5oCiBnZW5lcmljLXkgKz0gdmdhLmgKIGdl bmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQg YS9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvYXZyMzIvaW5jbHVkZS9hc20v S2J1aWxkCmluZGV4IDI0MWI5Yjk3MjlkOC4uZjJjM2I2NTZhMGU3IDEwMDY0NAotLS0gYS9hcmNo L2F2cjMyL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL0ti dWlsZApAQCAtMjIsMyArMjIsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJp Yy15ICs9IHZnYS5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9 IHhvci5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvYmxh Y2tmaW4vaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9LYnVp bGQKaW5kZXggOTFkNDljMGEzMTE4Li43ZGU2NzQ0MTFiZWQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxh Y2tmaW4vaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20v S2J1aWxkCkBAIC00OCwzICs0OCw0IEBAIGdlbmVyaWMteSArPSB1bmFsaWduZWQuaAogZ2VuZXJp Yy15ICs9IHVzZXIuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSAr PSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2M2 eC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2M2eC9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXgg NjQ0NjVlN2UyMjQ1Li4zODEyN2NlNzQ3YmUgMTAwNjQ0Ci0tLSBhL2FyY2gvYzZ4L2luY2x1ZGUv YXNtL0tidWlsZAorKysgYi9hcmNoL2M2eC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTYyLDMgKzYy LDQgQEAgZ2VuZXJpYy15ICs9IHVzZXIuaAogZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5lcmljLXkg Kz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkgKz0gc2Vj dGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9h cmNoL2NyaXMvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDE3Nzg4MDVmNjM4MC4uMzg1Y2Q4OGE5 ZDllIDEwMDY0NAotLS0gYS9hcmNoL2NyaXMvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gv Y3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTQ1LDMgKzQ1LDQgQEAgZ2VuZXJpYy15ICs9IHR5 cGVzLmgKIGdlbmVyaWMteSArPSB2Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgK IGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1n aXQgYS9hcmNoL2Zydi9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2Zydi9pbmNsdWRlL2FzbS9L YnVpbGQKaW5kZXggMWZhMDg0Y2YxYTQzLi40NmQ3YzU5OWQ5YjggMTAwNjQ0Ci0tLSBhL2FyY2gv ZnJ2L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2Zydi9pbmNsdWRlL2FzbS9LYnVpbGQK QEAgLTgsMyArOCw0IEBAIGdlbmVyaWMteSArPSBtbS1hcmNoLWhvb2tzLmgKIGdlbmVyaWMteSAr PSBwcmVlbXB0LmgKIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gd29y ZC1hdC1hLXRpbWUuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9h cmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvaDgzMDAvaW5jbHVkZS9hc20vS2J1 aWxkCmluZGV4IDM3M2NiMjMzMDFlMy4uMWVjMDRlYzFjODJiIDEwMDY0NAotLS0gYS9hcmNoL2g4 MzAwL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWls ZApAQCAtNzUsMyArNzUsNCBAQCBnZW5lcmljLXkgKz0gdW5hbGlnbmVkLmgKIGdlbmVyaWMteSAr PSB2Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3Iu aAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2hleGFnb24v aW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9oZXhhZ29uL2luY2x1ZGUvYXNtL0tidWlsZAppbmRl eCBkYjhkZGFiYzZiZDIuLjM3ZDdiZmFlNzYxOSAxMDA2NDQKLS0tIGEvYXJjaC9oZXhhZ29uL2lu Y2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2hleGFnb24vaW5jbHVkZS9hc20vS2J1aWxkCkBA IC02MCwzICs2MCw0IEBAIGdlbmVyaWMteSArPSB1bmFsaWduZWQuaAogZ2VuZXJpYy15ICs9IHZn YS5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCitn ZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9pbmNsdWRl L2FzbS9LYnVpbGQgYi9hcmNoL2lhNjQvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDUwMmE5MWQ4 ZGJiZC4uNjcyYzZkNWRhMThjIDEwMDY0NAotLS0gYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vS2J1 aWxkCisrKyBiL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTksMyArOSw0IEBAIGdl bmVyaWMteSArPSBwcmVlbXB0LmgKIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmlj LXkgKz0gdnRpbWUuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKK2dlbmVyaWMteSAr PSBzZWN0aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL0tidWls ZCBiL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggODYwZTQ0MDYxMWM5Li42MTEx ZTE1MjM3NTAgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIv YXJjaC9tMzJyL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTEsMyArMTEsNCBAQCBnZW5lcmljLXkg Kz0gcHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbnMuaAogZ2VuZXJpYy15ICs9IHRyYWNl X2Nsb2NrLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCitnZW5lcmljLXkgKz0gc2Vj dGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQgYi9h cmNoL202OGsvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGViODViZDljNjE4MC4uZWVmNzJjNDY0 YzliIDEwMDY0NAotLS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gv bTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTM1LDMgKzM1LDQgQEAgZ2VuZXJpYy15ICs9IHRy YWNlX2Nsb2NrLmgKIGdlbmVyaWMteSArPSB0eXBlcy5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1h LXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgK ZGlmZiAtLWdpdCBhL2FyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9tZXRhZy9p bmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMjlhY2I4OWRhYWFhLi41MGViZDVhMzBkMTYgMTAwNjQ0 Ci0tLSBhL2FyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbWV0YWcvaW5j bHVkZS9hc20vS2J1aWxkCkBAIC01NiwzICs1Niw0IEBAIGdlbmVyaWMteSArPSB1c2VyLmgKIGdl bmVyaWMteSArPSB2Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMt eSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNo L21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUv YXNtL0tidWlsZAppbmRleCBiMGFlODhjOWZlZDkuLmM2YzJjZjZlZGM5OCAxMDA2NDQKLS0tIGEv YXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL21pY3JvYmxhemUv aW5jbHVkZS9hc20vS2J1aWxkCkBAIC0xMSwzICsxMSw0IEBAIGdlbmVyaWMteSArPSBwcmVlbXB0 LmgKIGdlbmVyaWMteSArPSBzeXNjYWxscy5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAog Z2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUu aApkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbWlwcy9p bmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggOTc0MDA2NmNjNjMxLi4xMmY3YzU5ODRjMDMgMTAwNjQ0 Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9taXBzL2luY2x1 ZGUvYXNtL0tidWlsZApAQCAtMjAsMyArMjAsNCBAQCBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2su aAogZ2VuZXJpYy15ICs9IHVzZXIuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdl bmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQg YS9hcmNoL21uMTAzMDAvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9tbjEwMzAwL2luY2x1ZGUv YXNtL0tidWlsZAppbmRleCAxYzhkZDBmNWNkNWQuLmY4MTQ1YmM4NTgzNSAxMDA2NDQKLS0tIGEv YXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL21uMTAzMDAvaW5jbHVk ZS9hc20vS2J1aWxkCkBAIC0xMCwzICsxMCw0IEBAIGdlbmVyaWMteSArPSBwcmVlbXB0LmgKIGdl bmVyaWMteSArPSBzZWN0aW9ucy5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJp Yy15ICs9IHdvcmQtYXQtYS10aW1lLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaApkaWZm IC0tZ2l0IGEvYXJjaC9uaW9zMi9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL25pb3MyL2luY2x1 ZGUvYXNtL0tidWlsZAppbmRleCBkNjMzMzBlODgzNzkuLmM5YzdjYjgyYjAwZiAxMDA2NDQKLS0t IGEvYXJjaC9uaW9zMi9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9uaW9zMi9pbmNsdWRl L2FzbS9LYnVpbGQKQEAgLTYzLDMgKzYzLDQgQEAgZ2VuZXJpYy15ICs9IHVzZXIuaAogZ2VuZXJp Yy15ICs9IHZnYS5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9 IHhvci5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvb3Bl bnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9vcGVucmlzYy9pbmNsdWRlL2FzbS9LYnVp bGQKaW5kZXggMjgzMmYwMzFmYjExLi44NjE3NWU3MDE4NjkgMTAwNjQ0Ci0tLSBhL2FyY2gvb3Bl bnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvb3BlbnJpc2MvaW5jbHVkZS9hc20v S2J1aWxkCkBAIC03MSwzICs3MSw0IEBAIGdlbmVyaWMteSArPSB1c2VyLmgKIGdlbmVyaWMteSAr PSB2Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3Iu aAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL3BhcmlzYy9p bmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXgg ZjliM2E4MWFlZmNkLi42ZjQzZjMzZjBlMGYgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL2luY2x1 ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTI5 LDMgKzI5LDQgQEAgZ2VuZXJpYy15ICs9IHVzZXIuaAogZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5l cmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkg Kz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9L YnVpbGQgYi9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGFiOWY0ZTBlZDRj Zi4uYjQ5ZmFiN2JhYjJmIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vS2J1 aWxkCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTcsMyArNyw0IEBA IGdlbmVyaWMteSArPSBtY3Nfc3BpbmxvY2suaAogZ2VuZXJpYy15ICs9IHByZWVtcHQuaAogZ2Vu ZXJpYy15ICs9IHJ3c2VtLmgKIGdlbmVyaWMteSArPSB2dGltZS5oCitnZW5lcmljLXkgKz0gc2Vj dGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9h cmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDIwZjE5NmI4MmE2ZS4uODllNzRiNTlm MzJkIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gv czM5MC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTgsMyArOCw0IEBAIGdlbmVyaWMteSArPSBtbS1h cmNoLWhvb2tzLmgKIGdlbmVyaWMteSArPSBwcmVlbXB0LmgKIGdlbmVyaWMteSArPSB0cmFjZV9j bG9jay5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAorZ2VuZXJpYy15ICs9IHNlY3Rp b24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZCBiL2Fy Y2gvc2NvcmUvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGEwNTIxOGZmM2ZlNC4uZjA4OWEyNjRj ZDM4IDEwMDY0NAotLS0gYS9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNo L3Njb3JlL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTQsMyArMTQsNCBAQCBnZW5lcmljLXkgKz0g dHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkgKz0gc2VyaWFsLmgK IGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3Jl LmgKZGlmZiAtLWdpdCBhL2FyY2gvc2gvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9zaC9pbmNs dWRlL2FzbS9LYnVpbGQKaW5kZXggNzUxYzMzNzNhOTJjLi43YjAzNTZkY2E1NjIgMTAwNjQ0Ci0t LSBhL2FyY2gvc2gvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvc2gvaW5jbHVkZS9hc20v S2J1aWxkCkBAIC0zOSwzICszOSw0IEBAIGdlbmVyaWMteSArPSB0ZXJtaW9zLmgKIGdlbmVyaWMt eSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gdWNvbnRleHQuaAogZ2VuZXJpYy15ICs9 IHhvci5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvc3Bh cmMvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5k ZXggY2ZjOTE4MDY3ZjgwLi5kNTFiODRkNmI0YjcgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvaW5j bHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0y MiwzICsyMiw0IEBAIGdlbmVyaWMteSArPSBzZXJpYWwuaAogZ2VuZXJpYy15ICs9IHRyYWNlX2Ns b2NrLmgKIGdlbmVyaWMteSArPSB0eXBlcy5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUu aAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL3RpbGUvaW5j bHVkZS9hc20vS2J1aWxkIGIvYXJjaC90aWxlL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBiYTM1 YzQxYzcxZmYuLjdiOGE2NTJlNDNhZSAxMDA2NDQKLS0tIGEvYXJjaC90aWxlL2luY2x1ZGUvYXNt L0tidWlsZAorKysgYi9hcmNoL3RpbGUvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC00MSwzICs0MSw0 IEBAIGdlbmVyaWMteSArPSB0ZXJtaW9zLmgKIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBn ZW5lcmljLXkgKz0gdHlwZXMuaAogZ2VuZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkgKz0gc2Vj dGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvdW0vaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJj aC91bS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggOTA0ZjNlYmY0MjIwLi5lOTg0OTgzNGQ1NWUg MTAwNjQ0Ci0tLSBhL2FyY2gvdW0vaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvdW0vaW5j bHVkZS9hc20vS2J1aWxkCkBAIC0yNywzICsyNyw0IEBAIGdlbmVyaWMteSArPSB0b3BvbG9neS5o CiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1l LmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYg LS1naXQgYS9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9zZWN0aW9uLWNvcmUuaCBiL2FyY2gv dW5pY29yZTMyL2luY2x1ZGUvYXNtL3NlY3Rpb24tY29yZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMC4uZWJmZmVlZDg4MzVkCi0tLSAvZGV2L251bGwKKysrIGIvYXJj aC91bmljb3JlMzIvaW5jbHVkZS9hc20vc2VjdGlvbi1jb3JlLmgKQEAgLTAsMCArMSwxOSBAQAor I2lmbmRlZiBfX1VOSUNPUkVfU0VDVElPTl9DT1JFX0FTTV9IX18KKyNkZWZpbmUgX19VTklDT1JF X1NFQ1RJT05fQ09SRV9BU01fSF9fCisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IEx1aXMgUi4g Um9kcmlndWV6IDxtY2dyb2ZAa2VybmVsLm9yZz4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICog dW5kZXIgdGhlIHRlcm1zIG9mIGNvcHlsZWZ0LW5leHQgKHZlcnNpb24gMC4zLjEgb3IgbGF0ZXIp IGFzIHB1Ymxpc2hlZAorICogYXQgaHR0cDovL2NvcHlsZWZ0LW5leHQub3JnLy4KKyAqLworCisv KiBVbmljb3JlMzIgaGFzIGtub3duIHRvIG5vdCB3b3JrIHByb3Blcmx5IHdpdGggdGhlIHR5cGUg c2V0LCBzbyBpZ25vcmUgaXQgKi8KKworI2RlZmluZSBfX3NldF9zZWN0aW9uX2NvcmVfdHlwZShf X19zZWN0aW9uLCBfX19jb3JlLCBfX19uYW1lLAkJXAorCQkJCV9fX2xldmVsLCBfX19mbGFncywg X19fdHlwZSkJCVwKKwkuc2VjdGlvbiBfX19zZWN0aW9uLl9fX2NvcmUuX19fbmFtZS5fX19sZXZl bCwgX19fZmxhZ3MKKworI2luY2x1ZGUgPGFzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oPgorCisj ZW5kaWYgLyogX19VTklDT1JFX1NFQ1RJT05fQ09SRV9BU01fSF9fICovCmRpZmYgLS1naXQgYS9h cmNoL3g4Ni9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9LYnVpbGQK aW5kZXggMmNmZWQxNzRlM2M5Li5mNjkxNGE1N2JjMTYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2lu Y2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTE2 LDMgKzE2LDQgQEAgZ2VuZXJpYy15ICs9IGRtYS1jb250aWd1b3VzLmgKIGdlbmVyaWMteSArPSBl YXJseV9pb3JlbWFwLmgKIGdlbmVyaWMteSArPSBtY3Nfc3BpbmxvY2suaAogZ2VuZXJpYy15ICs9 IG1tLWFyY2gtaG9va3MuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQg YS9hcmNoL3h0ZW5zYS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3h0ZW5zYS9pbmNsdWRlL2Fz bS9LYnVpbGQKaW5kZXggMjhjZjRjNWQ2NWVmLi44MWNhNjgxNmJkNzIgMTAwNjQ0Ci0tLSBhL2Fy Y2gveHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3h0ZW5zYS9pbmNsdWRlL2Fz bS9LYnVpbGQKQEAgLTMxLDMgKzMxLDQgQEAgZ2VuZXJpYy15ICs9IHRvcG9sb2d5LmgKIGdlbmVy aWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2Vu ZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBh L2luY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmggYi9pbmNsdWRlL2FzbS1nZW5lcmlj L3NlY3Rpb24tY29yZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4u MmFiNTdlMmM0MTE3Ci0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0 aW9uLWNvcmUuaApAQCAtMCwwICsxLDM0MSBAQAorI2lmbmRlZiBfQVNNX0dFTkVSSUNfU0VDVElP Tl9DT1JFX0hfCisjZGVmaW5lIF9BU01fR0VORVJJQ19TRUNUSU9OX0NPUkVfSF8KKy8qCisgKiBM aW51eCBzZWN0aW9uIGNvcmUgZGVmaW5pdGlvbnMKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYg THVpcyBSLiBSb2RyaWd1ZXogPG1jZ3JvZkBrZXJuZWwub3JnPgorICoKKyAqIFRoaXMgcHJvZ3Jh bSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5 IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgY29weWxlZnQtbmV4dCAodmVyc2lvbiAwLjMuMSBv ciBsYXRlcikgYXMgcHVibGlzaGVkCisgKiBhdCBodHRwOi8vY29weWxlZnQtbmV4dC5vcmcvLgor ICovCisKKy8qKgorICogRE9DOiBDdXN0b20gbGlua2VyIHNjcmlwdAorICoKKyAqIFRoZSBMaW51 eCB2bWxpbnV4IGJpbmFyeSB1c2VzIGEgY3VzdG9tIGxpbmtlciBzY3JpcHQgb24gZWFjaCBhcmNo aXRlY3R1cmUKKyAqIHdoaWNoIGl0IHVzZXMgdG8gc3RyYXRlZ2ljYWxseSBwbGFjZSBzdGFuZGFy ZCBFTEYgc2VjdGlvbnMgYW5kIGFsc28gYWRkcworICogY3VzdG9tIHNwZWNpYWxpemVkIEVMRiBz ZWN0aW9ucy4gRWFjaCBhcmNoaXRlY3R1cmUgZGVmaW5lcyBpdHMgb3duIGN1c3RvbQorICogbGlu a2VyIGRlZmluZWQgaW4gYXJjaC8kKEFSQ0gpL2tlcm5lbC92bWxpbnV4Lmxkcy5TIC0tIHRoZXNl IGluIHR1cm4KKyAqIGluY2x1ZGUgYW5kIHVzZSBkZWZpbml0aW9ucyBpbiBpbmNsdWRlL2FzbS1n ZW5lcmljL3ZtbGludXgubGRzLmggYXMgd2VsbAorICogYXMgc29tZSBoZWxwZXJzIGRvY3VtZW50 ZWQgaW4gdGhpcyBjaGFwZXIuCisgKi8KKworLyoqCisgKiBET0M6IFN0YW5kYXJkIEVMRiBzZWN0 aW9uIHVzZSBpbiBMaW51eAorICoKKyAqIExpbnV4IG1ha2VzIHVzZSBvZiB0aGUgc3RhbmRhcmQg RUxGIHNlY3Rpb25zLCB0aGlzIHNlY3Rpb25zIGRvY3VtZW50cworICogdGhlc2UuCisgKi8KKwor LyoqCisgKiBET0M6IFNFQ1RJT05fUk9EQVRBCisgKgorICogTWFjcm8gbmFtZSBmb3IgY29kZSB3 aGljaCBtdXN0IGJlIHByb3RlY3RlZCBmcm9tIHdyaXRlIGFjY2VzcywgcmVhZCBvbmx5CisgKiBk YXRhLgorICovCisjZGVmaW5lIFNFQ1RJT05fUk9EQVRBCQkJLnJvZGF0YQorCisvKioKKyAqIERP QzogU0VDVElPTl9URVhUCisgKgorICogTWFjcm8gbmFtZSB1c2VkIHRvIGFubm90YXRlIGNvZGUg KGZ1bmN0aW9ucykgdXNlZCBkdXJpbmcgcmVndWxhcgorICoga2VybmVsIHJ1biB0aW1lLiBUaGlz IGlzIGNvbWJpbmVkIHdpdGggYFNFQ1RJT05fUk9EQVRBYCwgb25seSB0aGlzCisgKiBzZWN0aW9u IGFsc28gYWxsb3dzIGZvciBleGVjdXRpb24uCisgKgorICovCisjZGVmaW5lIFNFQ1RJT05fVEVY VAkJCS50ZXh0CisKKy8qKgorICogRE9DOiBTRUNUSU9OX0RBVEEKKyAqCisgKiBNYWNybyBuYW1l IGZvciByZWFkLXdyaXRlIGRhdGEuCisgKi8KKyNkZWZpbmUgU0VDVElPTl9EQVRBCQkJLmRhdGEK KworLyoqCisgKiBET0M6IExpbnV4IGluaXQgc2VjdGlvbnMKKyAqCisgKiBUaGVzZSBzZWN0aW9u cyBhcmUgdXNlZCBmb3IgY29kZSBhbmQgZGF0YSBzdHJ1Y3R1cmVzIHVzZWQgZHVyaW5nIGJvb3Qg b3IKKyAqIG1vZHVsZSBpbml0aWFsaXphdGlvbi4gT24gYXJjaGl0ZWN0dXJlcyB0aGF0IHN1cHBv cnQgaXQgKHg4NiwgeDg2XzY0KSwgYWxsCisgKiB0aGlzIGNvZGUgaXMgZnJlZWQgdXAgYnkgdGhl IGtlcm5lbCByaWdodCBiZWZvcmUgdGhlIGZpc3QgdXNlcnNwYWNlIGluaXQKKyAqIHByb2Nlc3Mg aXMgY2FsbGVkIHdoZW4gYnVpbHQtaW4gdG8gdGhlIGtlcm5lbCwgYW5kIGlmIG1vZHVsYXIgaXQg aXMgZnJlZWQKKyAqIGFmdGVyIG1vZHVsZSBpbml0aWFsaXphdGlvbi4gU2luY2UgdGhlIGNvZGUg aXMgZnJlZWQgc28gZWFybHksIGluIHRoZW9yeQorICogdGhlcmUgc2hvdWxkIGJlIG5vIHJhY2Vz IGFnYWluc3QgZnJlZWluZyB0aGlzIGNvZGUgd2l0aCBvdGhlciBDUFVzLiBJbml0CisgKiBzZWN0 aW9uIGNvZGUgYW5kIGRhdGEgc3RydWN0dXJlcyBzaG91bGQgbmV2ZXIgYmUgZXhwb3J0ZWQgd2l0 aAorICogRVhQT1JUX1NZTUJPTCooKSBhcyB0aGUgY29kZSB3aWxsIHF1aWNrbHkgYmVjb21lIHVu YXZhaWxhYmxlIHRvIHRoZSBrZXJuZWwKKyAqIGFmdGVyIGJvb3R1cC4KKyAqLworCisvKioKKyAq IERPQzogU0VDVElPTl9JTklUCisgKgorICogTWFjcm8gbmFtZSB1c2VkIHRvIGFubm90YXRlIGNv ZGUgKGZ1bmN0aW9ucykgdXNlZCBvbmx5IGR1cmluZyBib290IG9yIGRyaXZlcgorICogaW5pdGlh bGl6YXRpb24uCisgKgorICovCisjZGVmaW5lIFNFQ1RJT05fSU5JVAkJCS5pbml0LnRleHQKKwor LyoqCisgKiBET0M6IFNFQ1RJT05fSU5JVF9EQVRBCisgKgorICogTWFjcm8gbmFtZSB1c2VkIHRv IGFubm90YXRlIGRhdGEgc3RydWN0dXJlcyB1c2VkIG9ubHkgZHVyaW5nIGJvb3Qgb3IgZHJpdmVy CisgKiBpbml0aWFsaXphdGlvbi4KKyAqLworI2RlZmluZSBTRUNUSU9OX0lOSVRfREFUQQkJLmlu aXQuZGF0YQorCisvKioKKyAqIERPQzogU0VDVElPTl9JTklUX1JPREFUQQorICoKKyAqIE1hY3Jv IG5hbWUgdXNlZCB0byBhbm5vdGF0ZSByZWFkLW9ubHkgY29kZSAoZnVuY3Rpb25zKSB1c2VkIG9u bHkgZHVyaW5nIGJvb3QKKyAqIG9yIGRyaXZlciBpbml0aWFsaXphdGlvbi4KKyAqLworI2RlZmlu ZSBTRUNUSU9OX0lOSVRfUk9EQVRBCQkuaW5pdC5yb2RhdGEKKworLyoqCisgKiBET0M6IFNFQ1RJ T05fSU5JVF9DQUxMCisgKgorICogU3BlY2lhbCBtYWNybyBuYW1lIHVzZWQgdG8gYW5ub3RhdGUg c3Vic3lzdGVtIGluaXQgY2FsbC4gVGhlc2UgY2FsbHMgYXJlCisgKiBhcmUgbm93IGdyb3VwZWQg YnkgZnVuY3Rpb25hbGl0eSBpbnRvIHNlcGFyYXRlIHN1YnNlY3Rpb25zLiBPcmRlcmluZyBpbnNp ZGUKKyAqIHRoZSBzdWJzZWN0aW9ucyBpcyBkZXRlcm1pbmVkIGJ5IGxpbmsgb3JkZXIuCisgKi8K KyNkZWZpbmUgU0VDVElPTl9JTklUX0NBTEwJCS5pbml0Y2FsbAorCisvKioKKyAqIERPQzogTGlu dXggZXhpdCBzZWN0aW9ucworICoKKyAqIFRoZXNlIHNlY3Rpb25zIGFyZSB1c2VkIHRvIGRlY2xh cmUgYSBmdW5jdGlvbnMgYW5kIGRhdGEgc3RydWN0dXJlcyB3aGljaAorICogYXJlIG9ubHkgcmVx dWlyZWQgb24gZXhpdCwgdGhlIGZ1bmN0aW9uIG9yIGRhdGEgc3RydWN0dXJlIHdpbGwgYmUgZHJv cHBlZAorICogaWYgdGhlIGNvZGUgZGVjbGFyaW5nIHRoaXMgc2VjdGlvbiBpcyBub3QgY29tcGls ZWQgYXMgYSBtb2R1bGUgb24KKyAqIGFyY2hpdGVjdHVyZXMgdGhhdCBzdXBwb3J0IHRoaXMgKHg4 NiwgeDg2XzY0KS4gVGhlcmUgaXMgbm8gc3BlY2lhbCBjYXNlCisgKiBoYW5kbGluZyBmb3IgdGhp cyBjb2RlIHdoZW4gYnVpbHQtaW4gdG8gdGhlIGtlcm5lbC4KKyAqLworCisvKioKKyAqIERPQzog U0VDVElPTl9FWElUCisgKgorICogTWFjcm8gbmFtZSB1c2VkIHRvIGFubm90YXRlIGNvZGUgKGZ1 bmN0aW9ucykgdXNlZCBvbmx5IGR1cmluZyBtb2R1bGUKKyAqIHVubG9hZC4KKyAqLworI2RlZmlu ZSBTRUNUSU9OX0VYSVQJCQkuZXhpdC50ZXh0CisKKy8qKgorICogRE9DOiBTRUNUSU9OX0VYSVRf REFUQQorICoKKyAqIE1hY3JvIG5hbWUgdXNlZCB0byBhbm5vdGF0ZSBkYXRhIHN0cnVjdHVyZXMg dXNlZCBvbmx5IGR1cmluZyBtb2R1bGUKKyAqIHVubG9hZC4KKyAqLworI2RlZmluZSBTRUNUSU9O X0VYSVRfREFUQQkJLmV4aXQuZGF0YQorCisvKioKKyAqIERPQzogU0VDVElPTl9FWElUX0NBTEwK KyAqCisgKiBTcGVjaWFsIG1hY3JvIG5hbWUgdXNlZCB0byBhbm5vdGF0ZSBhbiBleGl0IGV4aXQg cm91dGluZSwgb3JkZXIKKyAqIGlzIGltcG9ydGFudCBhbmQgbWFpbnRhaW5lZCBieSBsaW5rIG9y ZGVyLgorICovCisjZGVmaW5lIFNFQ1RJT05fRVhJVF9DQUxMCQkuZXhpdGNhbGwuZXhpdAorCisv KioKKyAqIERPQzogTGludXggcmVmZXJlbmNlcyB0byBpbml0IHNlY3Rpb25zCisgKgorICogVGhl c2Ugc2VjdGlvbnMgYXJlIHVzZWQgdG8gdGVhY2ggbW9kcG9zdCB0byBub3Qgd2FybiBhYm91dCBw b3NzaWJsZQorICogbWlzdXNlcyBvZiBpbml0IHNlY3Rpb24gY29kZSBmcm9tIG90aGVyIHNlY3Rp b25zLiBJZiB5b3UgdXNlIHRoaXMKKyAqIHlvdXIgdXNlIGNhc2Ugc2hvdWxkIGRvY3VtZW50IHdo eSB5b3UgYXJlIGNlcnRhaW4gc3VjaCB1c2Ugb2YgaW5pdAorICogc2VjdGlvbmVkIGNvZGUgaXMg dmFsaWQuIEZvciBtb3JlIGRldGFpbHMgcmVmZXIgdG8gYGBpbmNsdWRlL2xpbnV4L2luaXQuaGBg CisgKiBgYF9fcmVmYGAsIGBgX19yZWZkYXRhYGAsIGFuZCBgYF9fcmVmY29uc3RgYCBkb2N1bWVu dGF0aW9uLgorICovCisKKy8qKgorICogRE9DOiBTRUNUSU9OX1JFRgorICoKKyAqIE1hY3JvIG5h bWUgdXNlZCB0byBhbm5vdGF0ZSB0aGF0IGNvZGUgKGZ1bmN0aW9ucykgZGVjbGFyZWQgd2l0aCB0 aGlzIHNlY3Rpb24KKyAqIGhhcyBiZWVuIHZldHRlZWQgYXMgdmFsaWQgZm9yIGl0cyByZWZlcmVu Y2Ugb3IgdXNlIG9mIG90aGVyIGNvZGUgKGZ1bmN0aW9ucykKKyAqIG9yIGRhdGEgc3RydWN0dXJl cyB3aGljaCBhcmUgcGFydCBvZiB0aGUgaW5pdCBzZWN0aW9ucy4KKyAqLworI2RlZmluZSBTRUNU SU9OX1JFRgkJCS5yZWYudGV4dAorCisvKioKKyAqIERPQzogU0VDVElPTl9SRUZfREFUQQorICoK KyAqIE1hY3JvIG5hbWUgdXNlZCB0byBhbm5vdGF0ZSBkYXRhIHN0cnVjdHVyZXMgZGVjbGFyZWQg d2l0aCB0aGlzIHNlY3Rpb24gaGF2ZQorICogYmVlbiB2ZXR0ZWVkIGZvciBpdHMgcmVmZXJlbmNl IG9yIHVzZSBvZiBvdGhlciBjb2RlIChmdW5jdGlvbnMpIG9yIGRhdGEKKyAqIHN0cnVjdHVyZXMg cGFydCBvZiB0aGUgaW5pdCBzZWN0aW9ucy4KKyAqLworI2RlZmluZSBTRUNUSU9OX1JFRl9EQVRB CQkucmVmLmRhdGEKKworLyoqCisgKiBET0M6IFNFQ1RJT05fUkVGX1JPREFUQQorICoKKyAqIE1h Y3JvIG5hbWUgdXNlZCB0byBhbm5vdGF0ZSBjb25zdCBjb2RlIChmdW5jdGlvbnMpIGNvbnN0IGRh dGEgc3RydWN0dXJlcworICogd2hpY2ggaGFzIGJlZW4gdmV0dGVlZCBmb3IgaXRzIHJlZmVyZW5j ZSBvciB1c2Ugb2Ygb3RoZXIgY29kZSAoZnVuY3Rpb25zKQorICogb3IgZGF0YSBzdHJ1Y3R1cmVz IHBhcnQgb2YgdGhlIGluaXQgc2VjdGlvbnMuCisgKi8KKyNkZWZpbmUgU0VDVElPTl9SRUZfUk9E QVRBCQkucmVmLnJvZGF0YQorCisvKioKKyAqIERPQzogTGludXggc2VjdGlvbiBvcmRlcmluZwor ICoKKyAqIExpbnV4IG1heSB1c2UgYmludXRpbHMgbGlua2VyLXNjcmlwdCAnU09SVCgpJyBvbiBz ZWN0aW9ucyB0byBzb3J0IExpbnV4CisgKiBzZWN0aW9ucy4gTGludXggaGFzIHVzZWQgJ1NPUlQo KScgaW4gYGBpbmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmhgYAorICogZm9yIHllYXJz LgorICovCisKKy8qKgorICogRE9DOiBTRUNUSU9OX09SREVSX0FOWQorICoKKyAqIE1hY3JvIG5h bWUgd2hpY2ggY2FuIGJlIHVzZWQgYXMgaGVscGVyIHRvIGFubm90YXRlIGN1c3RvbSBzZWN0aW9u CisgKiBvcmRlcmluZyBhdCBsaW5rIHRpbWUgaXMgbm90IHJlbGV2YW50IGZvciBzcGVjaWZpYyBz ZWN0aW9ucy4KKyAqLworI2RlZmluZSBTRUNUSU9OX09SREVSX0FOWQlhbnkKKworLyoKKyAqIFRo ZXNlIHNlY3Rpb24gX0FMTCgpIGhlbHBlcnMgYXJlIGZvciB1c2Ugb24gbGlua2VyIHNjcmlwdHMg YW5kIGhlbHBlcnMKKyAqLworI2RlZmluZSBTRUNUSU9OX0FMTChfX3NlY3Rpb24pCQkJCQkJXAor CV9fc2VjdGlvbiMjLioKKworI2RlZmluZSBfX1NFQ1RJT05fQ09SRShfX3NlY3Rpb24sIF9fY29y ZSwgX19uYW1lLCBfX2xldmVsKQkJXAorCV9fc2VjdGlvbi5fX2NvcmUuX19uYW1lLl9fbGV2ZWwK KworI2RlZmluZSBTRUNUSU9OX0NPUkVfQUxMKF9fc2VjdGlvbiwgX19jb3JlKQkJCQlcCisJX19z ZWN0aW9uIyMuIyNfX2NvcmUjIy4qCisKKy8qIENhbiBiZSB1c2VkIG9uIGZvby5TIGZvciBpbnN0 YW5jZSAqLworI2lmbmRlZiBfX3NldF9zZWN0aW9uX2NvcmVfdHlwZQorIyBkZWZpbmUgX19zZXRf c2VjdGlvbl9jb3JlX3R5cGUoX19fc2VjdGlvbiwgX19fY29yZSwgX19fbmFtZSwJCVwKKwkJCQkg X19fbGV2ZWwsIF9fX2ZsYWdzLCBfX190eXBlKQkJXAorCS5zZWN0aW9uIF9fX3NlY3Rpb24uX19f Y29yZS5fX19uYW1lLl9fX2xldmVsLCBfX19mbGFncywgX19fdHlwZQorI2VuZGlmCisKKyNpZm5k ZWYgX19zZXRfc2VjdGlvbl9jb3JlCisjIGRlZmluZSBfX3NldF9zZWN0aW9uX2NvcmUoX19fc2Vj dGlvbiwgX19fY29yZSwgX19fbmFtZSwgX19fbGV2ZWwsIF9fX2ZsYWdzKSBcCisJLnNlY3Rpb24g X19fc2VjdGlvbi5fX19jb3JlLl9fX25hbWUuX19fbGV2ZWwsIF9fX2ZsYWdzCisjZW5kaWYKKwor I2lmbmRlZiBfX3B1c2hfc2VjdGlvbl9jb3JlCisjIGRlZmluZSBfX3B1c2hfc2VjdGlvbl9jb3Jl KF9fc2VjdGlvbiwgX19jb3JlLCBfX25hbWUsIF9fbGV2ZWwsIF9fZmxhZ3MpIFwKKwkucHVzaHNl Y3Rpb24gX19zZWN0aW9uLl9fY29yZS5fX25hbWUuX19sZXZlbCwgX19mbGFncworI2VuZGlmCisK KyNpZmRlZiBfX0tFUk5FTF9fCisjaW5jbHVkZSA8bGludXgvc3RyaW5naWZ5Lmg+CisjZW5kaWYK KworI2lmIGRlZmluZWQoX19BU1NFTUJMRVJfXykgfHwgZGVmaW5lZChfX0FTU0VNQkxZX18pCisK KyMgaWZkZWYgTElOS0VSX1NDUklQVAorCisjICBpZm5kZWYgU0VDVElPTl9DT1JFCisjICAgZGVm aW5lIFNFQ1RJT05fQ09SRShfX3NlY3Rpb24sIF9fY29yZSwgX19uYW1lLCBfX2xldmVsKQkJXAor CV9fU0VDVElPTl9DT1JFKF9fc2VjdGlvbixfX2NvcmUsX19uYW1lLF9fbGV2ZWwpCisjICBlbmRp ZgorCisjIGVsc2UKKworIyAgaWZuZGVmIFNFQ1RJT05fQ09SRQorIyAgIGRlZmluZSBTRUNUSU9O X0NPUkUoX19zZWN0aW9uLCBfX2NvcmUsIF9fbmFtZSwgX19sZXZlbCkJCVwKKwlwdXNoX3NlY3Rp b25fY29yZShfX3NlY3Rpb24sIF9fY29yZSwgX19uYW1lLCBfX2xldmVsLCkKKyMgIGVuZGlmCisK KyMgIGlmbmRlZiBwdXNoX3NlY3Rpb25fY29yZQorIyAgIGRlZmluZSBwdXNoX3NlY3Rpb25fY29y ZShfX3NlY3Rpb24sIF9fY29yZSwgX19uYW1lLCBfX2xldmVsLCBfX2ZsYWdzKSBcCisJIF9fcHVz aF9zZWN0aW9uX2NvcmUoX19zZWN0aW9uLCBfX2NvcmUsIF9fbmFtZSwJCQkgIFwKKwkJCSAgICAg X19sZXZlbCwgX19zdHJpbmdpZnkoX19mbGFncykpCisjICBlbmRpZgorCisjICBpZm5kZWYgc2V0 X3NlY3Rpb25fY29yZQorIyAgIGRlZmluZSBzZXRfc2VjdGlvbl9jb3JlKF9fc2VjdGlvbiwgX19j b3JlLCBfX25hbWUsCQkJXAorCQkJICAgIF9fbGV2ZWwsIF9fZmxhZ3MpCQkJCVwKKwlfX3NldF9z ZWN0aW9uX2NvcmUoX19zZWN0aW9uLCBfX2NvcmUsIF9fbmFtZSwJCQlcCisJCQkgICBfX2xldmVs LCBfX3N0cmluZ2lmeShfX2ZsYWdzKSkKKyMgIGVuZGlmCisKKyMgIGlmbmRlZiBzZXRfc2VjdGlv bl9jb3JlX3R5cGUKKyMgICBkZWZpbmUgc2V0X3NlY3Rpb25fY29yZV90eXBlKF9fc2VjdGlvbiwg X19jb3JlLCBfX25hbWUsCQlcCisJCQkJIF9fbGV2ZWwsIF9fZmxhZ3MsIF9fdHlwZSkJCVwKKwlf X3NldF9zZWN0aW9uX2NvcmVfdHlwZShfX3NlY3Rpb24sIF9fY29yZSwgX19uYW1lLCBfX2xldmVs LAlcCisJCQkJX19zdHJpbmdpZnkoX19mbGFncyksIF9fdHlwZSkKKyMgIGVuZGlmCisKKyMgZW5k aWYgLyogTElOS0VSX1NDUklQVCAqLworI2Vsc2UgLyogZGVmaW5lZChfX0FTU0VNQkxFUl9fKSB8 fCBkZWZpbmVkKF9fQVNTRU1CTFlfXykgKi8KKworIyBpZm5kZWYgU0VDVElPTl9DT1JFCisjICBk ZWZpbmUgU0VDVElPTl9DT1JFKF9fc2VjdGlvbiwgX19jb3JlLCBfX25hbWUsIF9fbGV2ZWwpCQlc CisJX19zdHJpbmdpZnkoX19TRUNUSU9OX0NPUkUoX19zZWN0aW9uLF9fY29yZSxfX25hbWUsX19s ZXZlbCkpCisjIGVuZGlmCisKKy8qCisgKiBBcyBwZXIgZ2NjJ3MgZG9jdW1lbnRhdGlvbiBhIGNv bW1vbiBhc20gc2VwYXJhdG9yIGlzIGEgbmV3IGxpbmUgZm9sbG93ZWQKKyAqIGJ5IHRhYiBbMF0s IGl0IGhvd2V2ZXIgc2VlbXMgcG9zc2libGUgdG8gYWxzbyBqdXN0IHVzZSBhIG5ld2xpbmUgYXMg aXRzCisgKiB0aGUgbW9zdCBjb21tb25seSBlbXBpcmljYWxseSBvYnNlcnZlZCBzZW1hbnRpYyBh bmQgZm9sa3Mgc2VlbSB0byBhZ3JlZQorICogdGhpcyBldmVuIHdvcmtzIG9uIFMzOTAuIEluIGNh c2UgeW91ciBhcmNoaXRlY3R1cmUgZGlzYWdyZWVzIHlvdSBtYXkKKyAqIG92ZXJyaWRlIHRoaXMg YW5kIGRlZmluZSB5b3VyIG93biBhbmQga2VlcCB0aGUgcmVzdCBvZiB0aGUgbWFjcm9zLgorICoK KyAqIFswXSBodHRwczovL2djYy5nbnUub3JnL29ubGluZWRvY3MvZ2NjL0Jhc2ljLUFzbS5odG1s I0Jhc2ljLUFzbQorICovCisjIGlmbmRlZiBBU01fQ01EX1NFUAorIyAgZGVmaW5lIEFTTV9DTURf U0VQCSJcbiIKKyMgZW5kaWYKKworIyBpZm5kZWYgc2V0X3NlY3Rpb25fY29yZQorIyAgZGVmaW5l IHNldF9zZWN0aW9uX2NvcmUoX19zZWN0aW9uLCBfX2NvcmUsIF9fbmFtZSwgX19sZXZlbCwgX19m bGFncykJXAorCV9fc3RyaW5naWZ5KF9fc2V0X3NlY3Rpb25fY29yZV90eXBlKF9fc2VjdGlvbiwg X19jb3JlLCBfX25hbWUsCVwKKwkJCQkJICAgIF9fbGV2ZWwsIF9fc3RyaW5naWZ5KF9fZmxhZ3Mp KSkgXAorCUFTTV9DTURfU0VQCisjIGVuZGlmCisKKy8qCisgKiBTb21lIGFyY2hpdGVjdHVyZXMg KGFybSwgYW5kIGF2cjMyIGFyZSB0d28gZXhhbXBsZXMgb24ga3Byb2Jlcykgc2VlbQorICogY3Vy cmVudGx5IGV4cGxpY2l0bHkgc3BlY2lmeSB0aGUgdHlwZSBbMF0gLS0gdGhpcyBjYW4gYmUgYW55 IG9mIHRoZQorICogb3B0aW9uYWwgY29uc3RhbnRzIG9uIEVMRjoKKyAqCisgKiBAcHJvZ2JpdHMg LSBzZWN0aW9uIGNvbnRhaW5zIGRhdGEKKyAqIEBub2JpdHMgLSBzZWN0aW9uIGRvZXMgbm90IGNv bnRhaW4gZGF0YSAoaS5lLiwgc2VjdGlvbiBvbmx5IG9jY3VwaWVzIHNwYWNlKQorICogQG5vdGUg LSBzZWN0aW9uIGNvbnRhaW5zIGRhdGEgd2hpY2ggaXMgdXNlZCBieSB0aGluZ3Mgb3RoZXIgdGhh biB0aGUgcHJvZ3JhbQorICogQGluaXRfYXJyYXkgLSBzZWN0aW9uIGNvbnRhaW5zIGFuIGFycmF5 IG9mIHBvaW50ZXJzIHRvIGluaXQgZnVuY3Rpb25zCisgKiBAZmluaV9hcnJheSAtIHNlY3Rpb24g Y29udGFpbnMgYW4gYXJyYXkgb2YgcG9pbnRlcnMgdG8gZmluaXNoIGZ1bmN0aW9ucworICogQHBy ZWluaXRfYXJyYXkgLSBzZWN0aW9uIGNvbnRhaW5zIGFuIGFycmF5IG9mIHBvaW50ZXJzIHRvIHBy ZS1pbml0IGZ1bmN0aW9ucworICoKKyAqIEFSTSByZXF1aXJlcyAlIGluc3RlYWQgb2YgQC4KKyAq CisgKiBBdCBsZWFzdCBhcyBwZXIgbmFzbSAoeDg2L3g4Nl82NCBvbmx5KSwgaW4gdGhlIGFic2Vu Y2Ugb2YgcXVhbGlmaWVycyB0aGUKKyAqIGRlZmF1bHRzIGFyZSBhcyBmb2xsb3dzOgorICoKKyAq IHNlY3Rpb24gLnRleHQgICAgcHJvZ2JpdHMgIGFsbG9jICAgZXhlYyAgICBub3dyaXRlICBhbGln bj0xNgorICogc2VjdGlvbiAucm9kYXRhICBwcm9nYml0cyAgYWxsb2MgICBub2V4ZWMgIG5vd3Jp dGUgIGFsaWduPTQKKyAqIHNlY3Rpb24gLmxyb2RhdGEgcHJvZ2JpdHMgIGFsbG9jICAgbm9leGVj ICBub3dyaXRlICBhbGlnbj00CisgKiBzZWN0aW9uIC5kYXRhICAgIHByb2diaXRzICBhbGxvYyAg IG5vZXhlYyAgd3JpdGUgICAgYWxpZ249NAorICogc2VjdGlvbiAubGRhdGEgICBwcm9nYml0cyAg YWxsb2MgICBub2V4ZWMgIHdyaXRlICAgIGFsaWduPTQKKyAqIHNlY3Rpb24gLmJzcyAgICAgbm9i aXRzICAgIGFsbG9jICAgbm9leGVjICB3cml0ZSAgICBhbGlnbj00CisgKiBzZWN0aW9uIC5sYnNz ICAgIG5vYml0cyAgICBhbGxvYyAgIG5vZXhlYyAgd3JpdGUgICAgYWxpZ249NAorICogc2VjdGlv biAudGRhdGEgICBwcm9nYml0cyAgYWxsb2MgICBub2V4ZWMgIHdyaXRlICAgIGFsaWduPTQgICAg dGxzCisgKiBzZWN0aW9uIC50YnNzICAgIG5vYml0cyAgICBhbGxvYyAgIG5vZXhlYyAgd3JpdGUg ICAgYWxpZ249NCAgICB0bHMKKyAqIHNlY3Rpb24gLmNvbW1lbnQgcHJvZ2JpdHMgIG5vYWxsb2Mg bm9leGVjICBub3dyaXRlICBhbGlnbj0xCisgKiBzZWN0aW9uIG90aGVyICAgIHByb2diaXRzICBh bGxvYyAgIG5vZXhlYyAgbm93cml0ZSAgYWxpZ249MQorICoKKyAqIGdhcyBzaG91bGQgaGF2ZSBz ZW5zaWJsZSBkZWZhdWx0cyBmb3IgYXJjaGl0ZWN0dXJlcy4uLgorICoKKyAqIFswXSBodHRwOi8v d3d3Lm5hc20udXMvZG9jL25hc21kb2M3Lmh0bWwKKyAqLworIyBpZm5kZWYgc2V0X3NlY3Rpb25f Y29yZV90eXBlCisjICBkZWZpbmUgc2V0X3NlY3Rpb25fY29yZV90eXBlKF9fc2VjdGlvbiwgX19j b3JlLCBfX25hbWUsIF9fbGV2ZWwsCVwKKwkJCQlfX2ZsYWdzLCBfX3R5cGUpCQkJXAorCV9fc3Ry aW5naWZ5KF9fc2V0X3NlY3Rpb25fY29yZV90eXBlKF9fc2VjdGlvbiwgX19jb3JlLAkJXAorCQkJ CQkgICAgX19uYW1lLCBfX2xldmVsLAkJXAorCQkJCQkgICAgX19zdHJpbmdpZnkoX19mbGFncyks CVwKKwkJCQkJICAgIF9fdHlwZSkpCQkJXAorCUFTTV9DTURfU0VQCisjIGVuZGlmCisKKyMgaWZu ZGVmIHB1c2hfc2VjdGlvbl9jb3JlCisjICBkZWZpbmUgcHVzaF9zZWN0aW9uX2NvcmUoX19zZWN0 aW9uLCBfX2NvcmUsIF9fbmFtZSwJCQlcCisJCQkgICAgX19sZXZlbCwgX19mbGFncykJCQkJXAor CV9fc3RyaW5naWZ5KF9fcHVzaF9zZWN0aW9uX2NvcmUoX19zZWN0aW9uLCBfX2NvcmUsCQlcCisJ CQkJCV9fbmFtZSwJX19sZXZlbCwJCVwKKwkJCQkJX19zdHJpbmdpZnkoX19mbGFncykpKQkJXAor CUFTTV9DTURfU0VQCisjIGVuZGlmCisKKyNlbmRpZiAvKiBkZWZpbmVkKF9fQVNTRU1CTEVSX18p IHx8IGRlZmluZWQoX19BU1NFTUJMWV9fKSAqLworI2VuZGlmIC8qIF9BU01fR0VORVJJQ19TRUNU SU9OX0NPUkVfSF8gKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbnMu aCBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbnMuaAppbmRleCBhZjAyNTRjMDk0MjQuLjI5 ODI1MmRmM2M4MSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9ucy5oCisr KyBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbnMuaApAQCAtMSw2ICsxLDggQEAKICNpZm5k ZWYgX0FTTV9HRU5FUklDX1NFQ1RJT05TX0hfCiAjZGVmaW5lIF9BU01fR0VORVJJQ19TRUNUSU9O U19IXwogCisjaW5jbHVkZSA8YXNtL3NlY3Rpb24tY29yZS5oPgorCiAvKiBSZWZlcmVuY2VzIHRv IHNlY3Rpb24gYm91bmRhcmllcyAqLwogCiAjaW5jbHVkZSA8bGludXgvY29tcGlsZXIuaD4KZGlm ZiAtLWdpdCBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaCBiL2luY2x1ZGUvYXNt LWdlbmVyaWMvdm1saW51eC5sZHMuaAppbmRleCAyNDU2Mzk3MGZmN2IuLjczMTA4NzI3NmEzMiAx MDA2NDQKLS0tIGEvaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oCisrKyBiL2luY2x1 ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaApAQCAtNTUsNiArNTUsNyBAQAogI2VuZGlmCiAK ICNpbmNsdWRlIDxsaW51eC9leHBvcnQuaD4KKyNpbmNsdWRlIDxhc20vc2VjdGlvbi1jb3JlLmg+ CiAKIC8qIEFsaWduIC4gdG8gYSA4IGJ5dGUgYm91bmRhcnkgZXF1YWxzIHRvIG1heGltdW0gZnVu Y3Rpb24gYWxpZ25tZW50LiAqLwogI2RlZmluZSBBTElHTl9GVU5DVElPTigpICAuID0gQUxJR04o OCkKQEAgLTE5OCw4ICsxOTksOCBAQAogCiAvKiAuZGF0YSBzZWN0aW9uICovCiAjZGVmaW5lIERB VEFfREFUQQkJCQkJCQlcCi0JKiguZGF0YSkJCQkJCQkJXAotCSooLnJlZi5kYXRhKQkJCQkJCQlc CisJKihTRUNUSU9OX0RBVEEpCQkJCQkJCVwKKwkqKFNFQ1RJT05fUkVGX0RBVEEpCQkJCQkJXAog CSooLmRhdGEuLnNoYXJlZF9hbGlnbmVkKSAvKiBwZXJjcHUgcmVsYXRlZCAqLwkJCVwKIAlNRU1f S0VFUChpbml0LmRhdGEpCQkJCQkJXAogCU1FTV9LRUVQKGV4aXQuZGF0YSkJCQkJCQlcCkBAIC0y NjIsOSArMjYzLDkgQEAKICAqLwogI2RlZmluZSBST19EQVRBX1NFQ1RJT04oYWxpZ24pCQkJCQkJ XAogCS4gPSBBTElHTigoYWxpZ24pKTsJCQkJCQlcCi0JLnJvZGF0YSAgICAgICAgICAgOiBBVChB RERSKC5yb2RhdGEpIC0gTE9BRF9PRkZTRVQpIHsJCVwKKwlTRUNUSU9OX1JPREFUQSAgICA6IEFU KEFERFIoU0VDVElPTl9ST0RBVEEpIC0gTE9BRF9PRkZTRVQpIHsJXAogCQlWTUxJTlVYX1NZTUJP TChfX3N0YXJ0X3JvZGF0YSkgPSAuOwkJCVwKLQkJKigucm9kYXRhKSAqKC5yb2RhdGEuKikJCQkJ CVwKKwkJKihTRUNUSU9OX1JPREFUQSkgKihTRUNUSU9OX0FMTChTRUNUSU9OX1JPREFUQSkpCVwK IAkJUk9fQUZURVJfSU5JVF9EQVRBCS8qIFJlYWQgb25seSBhZnRlciBpbml0ICovCVwKIAkJKihf X3Zlcm1hZ2ljKQkJLyogS2VybmVsIHZlcnNpb24gbWFnaWMgKi8JXAogCQkuID0gQUxJR04oOCk7 CQkJCQkJXApAQCAtMzk0LDcgKzM5NSw3IEBACiAJCQkJCQkJCQlcCiAJLyogX18qaW5pdCBzZWN0 aW9ucyAqLwkJCQkJCVwKIAlfX2luaXRfcm9kYXRhIDogQVQoQUREUihfX2luaXRfcm9kYXRhKSAt IExPQURfT0ZGU0VUKSB7CQlcCi0JCSooLnJlZi5yb2RhdGEpCQkJCQkJXAorCQkqKFNFQ1RJT05f UkVGX1JPREFUQSkJCQkJCVwKIAkJTUVNX0tFRVAoaW5pdC5yb2RhdGEpCQkJCQlcCiAJCU1FTV9L RUVQKGV4aXQucm9kYXRhKQkJCQkJXAogCX0JCQkJCQkJCVwKQEAgLTQzMiw4ICs0MzMsOCBAQAog ICogZHVyaW5nIHNlY29uZCBsZCBydW4gaW4gc2Vjb25kIGxkIHBhc3Mgd2hlbiBnZW5lcmF0aW5n IFN5c3RlbS5tYXAgKi8KICNkZWZpbmUgVEVYVF9URVhUCQkJCQkJCVwKIAkJQUxJR05fRlVOQ1RJ T04oKTsJCQkJCVwKLQkJKigudGV4dC5ob3QgLnRleHQgLnRleHQuZml4dXAgLnRleHQudW5saWtl bHkpCQlcCi0JCSooLnJlZi50ZXh0KQkJCQkJCVwKKwkJKigudGV4dC5ob3QgU0VDVElPTl9URVhU IC50ZXh0LmZpeHVwIC50ZXh0LnVubGlrZWx5KQlcCisJCSooU0VDVElPTl9SRUYpCQkJCQkJXAog CU1FTV9LRUVQKGluaXQudGV4dCkJCQkJCQlcCiAJTUVNX0tFRVAoZXhpdC50ZXh0KQkJCQkJCVwK IApAQCAtNTI3LDExICs1MjgsMTEgQEAKIAogLyogaW5pdCBhbmQgZXhpdCBzZWN0aW9uIGhhbmRs aW5nICovCiAjZGVmaW5lIElOSVRfREFUQQkJCQkJCQlcCi0JKiguaW5pdC5kYXRhKQkJCQkJCQlc CisJKihTRUNUSU9OX0lOSVRfREFUQSkJCQkJCQlcCiAJTUVNX0RJU0NBUkQoaW5pdC5kYXRhKQkJ CQkJCVwKIAlLRVJORUxfQ1RPUlMoKQkJCQkJCQlcCiAJTUNPVU5UX1JFQygpCQkJCQkJCVwKLQkq KC5pbml0LnJvZGF0YSkJCQkJCQkJXAorCSooU0VDVElPTl9JTklUX1JPREFUQSkJCQkJCQlcCiAJ RlRSQUNFX0VWRU5UUygpCQkJCQkJCVwKIAlUUkFDRV9TWVNDQUxMUygpCQkJCQkJXAogCUtQUk9C RV9CTEFDS0xJU1QoKQkJCQkJCVwKQEAgLTU0OSwyNCArNTUwLDI0IEBACiAJRUFSTFlDT05fVEFC TEUoKQogCiAjZGVmaW5lIElOSVRfVEVYVAkJCQkJCQlcCi0JKiguaW5pdC50ZXh0KQkJCQkJCQlc CisJKihTRUNUSU9OX0lOSVQpCQkJCQkJCVwKIAkqKC50ZXh0LnN0YXJ0dXApCQkJCQkJXAogCU1F TV9ESVNDQVJEKGluaXQudGV4dCkKIAogI2RlZmluZSBFWElUX0RBVEEJCQkJCQkJXAotCSooLmV4 aXQuZGF0YSkJCQkJCQkJXAorCSooU0VDVElPTl9FWElUX0RBVEEpCQkJCQkJXAogCSooLmZpbmlf YXJyYXkpCQkJCQkJCVwKIAkqKC5kdG9ycykJCQkJCQkJXAogCU1FTV9ESVNDQVJEKGV4aXQuZGF0 YSkJCQkJCQlcCiAJTUVNX0RJU0NBUkQoZXhpdC5yb2RhdGEpCiAKICNkZWZpbmUgRVhJVF9URVhU CQkJCQkJCVwKLQkqKC5leGl0LnRleHQpCQkJCQkJCVwKKwkqKFNFQ1RJT05fRVhJVCkJCQkJCQkJ XAogCSooLnRleHQuZXhpdCkJCQkJCQkJXAogCU1FTV9ESVNDQVJEKGV4aXQudGV4dCkKIAogI2Rl ZmluZSBFWElUX0NBTEwJCQkJCQkJXAotCSooLmV4aXRjYWxsLmV4aXQpCisJKihTRUNUSU9OX0VY SVRfQ0FMTCkKIAogLyoKICAqIGJzcyAoQmxvY2sgU3RhcnRlZCBieSBTeW1ib2wpIC0gdW5pbml0 aWFsaXplZCBkYXRhCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3NlY3Rpb25zLmggYi9pbmNs dWRlL2xpbnV4L3NlY3Rpb25zLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi5mMjFjNmVlODhkZWQKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL2xpbnV4L3NlY3Rp b25zLmgKQEAgLTAsMCArMSwxMTEgQEAKKyNpZm5kZWYgX0xJTlVYX1NFQ1RJT05TX0gKKyNkZWZp bmUgX0xJTlVYX1NFQ1RJT05TX0gKKy8qCisgKiBMaW51eCBkZS1mYWN0byBzZWN0aW9ucworICoK KyAqIENvcHlyaWdodCAoQykgMjAxNiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNncm9mQGtlcm5lbC5v cmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiBjb3B5bGVm dC1uZXh0ICh2ZXJzaW9uIDAuMy4xIG9yIGxhdGVyKSBhcyBwdWJsaXNoZWQKKyAqIGF0IGh0dHA6 Ly9jb3B5bGVmdC1uZXh0Lm9yZy8uCisgKi8KKworI2luY2x1ZGUgPGFzbS9zZWN0aW9uLWNvcmUu aD4KKyNpbmNsdWRlIDxsaW51eC9leHBvcnQuaD4KKworI2lmbmRlZiBfX0FTU0VNQkxZX18KKwor LyoqCisgKiBET0M6IEludHJvZHVjdGlvbgorICoKKyAqIExpbnV4IGRlZmluZXMgYSBzZXQgb2Yg Y29tbW9uIGhlbHBlcnMgd2hpY2ggY2FuIGJlIHVzZWQgdG8gYWdhaW5zdCBpdHMgdXNlCisgKiBv ZiBzdGFuZGFyZCBvciBjdXN0b20gTGludXggc2VjdGlvbnMsIHRoaXMgc2VjdGlvbiBpcyBkZWRp Y2F0ZWQgdG8gdGhlc2UKKyAqIGhlbHBlcnMuCisgKi8KKworLyoqCisgKiBMSU5VWF9TRUNUSU9O X0FMSUdOTUVOVCAtIGdldCBzZWN0aW9uIGFsaWdubWVudAorICoKKyAqIEBuYW1lOiBzZWN0aW9u IG5hbWUKKyAqCisgKiBHaXZlcyB5b3UgdGhlIGFsaWdubWVudCBmb3IgdGhlIHNlY3Rpb24uCisg Ki8KKyNkZWZpbmUgTElOVVhfU0VDVElPTl9BTElHTk1FTlQobmFtZSkJX19hbGlnbm9mX18oKlZN TElOVVhfU1lNQk9MKG5hbWUpKQorCisvKioKKyAqIExJTlVYX1NFQ1RJT05fU0laRSAtIGdldCBu dW1iZXIgb2YgZW50cmllcyBpbiB0aGUgc2VjdGlvbgorICoKKyAqIEBuYW1lOiBzZWN0aW9uIG5h bWUKKyAqCisgKiBUaGlzIGdpdmVzIHlvdSB0aGUgbnVtYmVyIG9mIGVudHJpZXMgaW4gdGhlIHNl Y3Rpb24uCisgKiBFeGFtcGxlIHVzYWdlOgorICoKKyAqICAgdW5zaWduZWQgaW50IG51bV9mcm9i cyA9IExJTlVYX1NFQ1RJT05fU0laRShmcm9ibmljYXRvcl9mbnMpOworICovCisjZGVmaW5lIExJ TlVYX1NFQ1RJT05fU0laRShuYW1lKQkJCQkJXAorCSgoVk1MSU5VWF9TWU1CT0wobmFtZSMjX19l bmQpKSAtIChWTUxJTlVYX1NZTUJPTChuYW1lKSkpCisKKy8qKgorICogTElOVVhfU0VDVElPTl9F TVBUWSAtIGNoZWNrIGlmIHNlY3Rpb24gaGFzIG5vIGVudHJpZXMKKyAqCisgKiBAbmFtZTogc2Vj dGlvbiBuYW1lCisgKgorICogUmV0dXJucyB0cnVlIGlmIHNlY3Rpb24gaXMgZW10cHkuCisgKgor ICogICBib29sIGlzX2VtcHR5ID0gTElOVVhfU0VDVElPTl9FTVBUWShmcm9ibmljYXRvcl9mbnMp OworICovCisjZGVmaW5lIExJTlVYX1NFQ1RJT05fRU1QVFkobmFtZSkJKExJTlVYX1NFQ1RJT05f U0laRShuYW1lKSA9PSAwKQorCisvKioKKyAqIExJTlVYX1NFQ1RJT05fU1RBUlQgLSBnZXQgYWRk cmVzcyBvZiBzdGFydCBvZiBzZWN0aW9uCisgKgorICogQG5hbWU6IHNlY3Rpb24gbmFtZQorICoK KyAqIFRoaXMgZ2l2ZXMgeW91IHRoZSBzdGFydCBhZGRyZXNzIG9mIHRoZSBzZWN0aW9uLgorICog VGhpcyBzaG91bGQgZ2l2ZSB5b3UgdGhlIGFkZHJlc3Mgb2YgdGhlIGZpcnN0IGVudHJ5LgorICoK KyAqLworI2RlZmluZSBMSU5VWF9TRUNUSU9OX1NUQVJUKG5hbWUpCVZNTElOVVhfU1lNQk9MKG5h bWUpCisKKy8qKgorICogTElOVVhfU0VDVElPTl9FTkQgLSBnZXQgYWRkcmVzcyBvZiBlbmQgb2Yg dGhlIHNlY3Rpb24KKyAqCisgKiBAbmFtZTogc2VjdGlvbiBuYW1lCisgKgorICogVGhpcyBnaXZl cyB5b3UgdGhlIGVuZCBhZGRyZXNzIG9mIHRoZSBzZWN0aW9uLgorICogVGhpcyBzaG91bGQgZ2l2 ZSB5b3UgdGhlIGFkZHJlc3Mgb2YgdGhlIGVuZCBvZiB0aGUKKyAqIHNlY3Rpb24uIFRoaXMgd2ls bCBtYXRjaCB0aGUgc3RhcnQgYWRkcmVzcyBpZiB0aGUKKyAqIHNlY3Rpb24gaXMgZW1wdHkuCisg Ki8KKyNkZWZpbmUgTElOVVhfU0VDVElPTl9FTkQobmFtZSkJVk1MSU5VWF9TWU1CT0wobmFtZSMj X19lbmQpCisKKy8qKgorICogREVDTEFSRV9MSU5VWF9TRUNUSU9OIC0gRGVjbGFyZXMgYSBjdXN0 b20gTGludXggc2VjdGlvbgorICoKKyAqIEB0eXBlOiB0eXBlIG9mIGN1c3RvbSBMaW51eCBzZWN0 aW9uCisgKiBAbmFtZTogY3VzdG9tIHNlY3Rpb24gbmFtZQorICoKKyAqIERlY2xhcmVzIGEgcmVh ZC13cml0ZSBjdXN0b20gTGludXggc2VjdGlvbgorICovCisjZGVmaW5lIERFQ0xBUkVfTElOVVhf U0VDVElPTih0eXBlLCBuYW1lKQkJCQlcCisJIGV4dGVybiB0eXBlIFZNTElOVVhfU1lNQk9MKG5h bWUpW10sIFwKKwkJICAgICBWTUxJTlVYX1NZTUJPTChuYW1lIyNfX2VuZClbXQorCisvKioKKyAq IERFQ0xBUkVfTElOVVhfU0VDVElPTl9STyAtIERlY2xhcmVzIGEgcmVhZC1vbmx5IGN1c3RvbSBM aW51eCBzZWN0aW9uCisgKgorICogQHR5cGU6IHR5cGUgb2YgY3VzdG9tIExpbnV4IHNlY3Rpb24K KyAqIEBuYW1lOiBjdXN0b20gc2VjdGlvbiBuYW1lCisgKgorICogRGVjbGFyZXMgYSByZWFkLW9u bHkgY3VzdG9tIExpbnV4IHNlY3Rpb24KKyAqLworI2RlZmluZSBERUNMQVJFX0xJTlVYX1NFQ1RJ T05fUk8odHlwZSwgbmFtZSkJCQkJXAorCSBleHRlcm4gY29uc3QgdHlwZSBWTUxJTlVYX1NZTUJP TChuYW1lKVtdLAkJCVwKKwkJCSAgIFZNTElOVVhfU1lNQk9MKG5hbWUjI19fZW5kKVtdCisKKyNk ZWZpbmUgX19TRUNUSU9OX1RZUEUoc2VjdGlvbiwgdHlwZSwgbmFtZSwgbGV2ZWwpCQkJXAorCSNz ZWN0aW9uICIuIiAjdHlwZSAiLiIgI25hbWUgIi4iICNsZXZlbAorCisjZW5kaWYgLyogX19BU1NF TUJMWV9fICovCisKKyNlbmRpZiAvKiBfTElOVVhfU0VDVElPTlNfSCAqLwotLSAKMi45LjIKCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwg bWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9y Zy94ZW4tZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:44918 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754491AbcHSVrZ (ORCPT ); Fri, 19 Aug 2016 17:47:25 -0400 From: mcgrof@kernel.org Subject: [PATCH v4 04/16] generic-sections: add section core helpers Date: Fri, 19 Aug 2016 14:32:53 -0700 Message-ID: <1471642385-5629-5-git-send-email-mcgrof@kernel.org> In-Reply-To: <1471642385-5629-1-git-send-email-mcgrof@kernel.org> References: <1471642385-5629-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: <20160819213253.daCmO4qtJEJZVcwhe64QvSytuU3LXahOy3Ua_U3_GUA@z> From: "Luis R. Rodriguez" Linux makes extensive use of custom ELF header sections, documentation for these are well scatterred. Unify this documentation in a central place and provide helpers to build custom Linux sections. This also generalizes sections code to enable avoiding modifying the linker scripts when we want to add new custom Linux sections. In order to make this generally useful we need to ensure all architectures can make use of core section helpers but that they can also override should this be needed. Instead of relying on section.h this adds a sections-core.h since this will be targetted to be safe to be used on asm code, linker scripts and C code. v4: o Port to shiny new sphinx documentation format o fix a unicore32 build, turns out this actually fixes unicore32 defconfig builds which were failing for a long while. unicore32 does not seem to grok well the type passed on a section declaration, this ignores it. o Use VMLINUX_SYMBOL() in more user symbols (extern C code), not doing this was causing final linker issues with blackfin -- this is a CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX=y architecture. The other one being metatag. metatag is not supported on 0-day so I cannot confirm compilation there. o Added SECTION_CORE() for C code, used later by __LINUX_RANGE() o Since SECTION_CORE() is defined for linker script and C code, share the same helper and just use a __stringify() for the C code as is done for the other C helpers. o move generic sections to asm-generic/section-core.h instead. PowerPC compilation blows up if asm/jump_labels.h gets section.h included, fixing this is not in any way easy. The list of issues are endless. Moving new data to a new simple file resolves this. o since things are now in asm-generic/section-core.h the guard changes on asm-generic/sections.h and each architecture sections.h are no longer needed o Give generic sections some maintainer love, that change is Acked-by Arnd Bergmann, Josh and hpa. o A few checkpatch.pl style fixes o As suggested by James Hogan use generic-y to copy generic header files on architectures that do not have a sections.h instead of writing a simple file only to include the generic one. v3: o add missing sections.h for architectures that did not have it o move generic sections to asm-generic/sections.h o add generic asm helpers section_type(), section_type_asmtype(), push_section_type() -- these helpers enable easy use for for later declaring and using of custom linux sections using more standard APIs in both C code, asm code (C asm calls, or asm files), enabling future standardized section types to be more immediately accessible to asm code, not just C code. Note for ASM_CMD_SEP we use by default "\n", architectures needed to override can do so on their own sections.h prior to inclusion of asm-generic/sections.h Signed-off-by: Luis R. Rodriguez --- Documentation/index.rst | 1 + Documentation/sections/conf.py | 4 + Documentation/sections/index.rst | 11 + Documentation/sections/section-core.rst | 153 ++++++++++++++ MAINTAINERS | 14 ++ 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/section-core.h | 19 ++ arch/x86/include/asm/Kbuild | 1 + arch/xtensa/include/asm/Kbuild | 1 + include/asm-generic/section-core.h | 341 ++++++++++++++++++++++++++++++ include/asm-generic/sections.h | 2 + include/asm-generic/vmlinux.lds.h | 27 +-- include/linux/sections.h | 111 ++++++++++ 40 files changed, 700 insertions(+), 13 deletions(-) create mode 100644 Documentation/sections/conf.py create mode 100644 Documentation/sections/index.rst create mode 100644 Documentation/sections/section-core.rst create mode 100644 arch/unicore32/include/asm/section-core.h create mode 100644 include/asm-generic/section-core.h create mode 100644 include/linux/sections.h diff --git a/Documentation/index.rst b/Documentation/index.rst index a15f81855b39..10c9b867e326 100644 --- a/Documentation/index.rst +++ b/Documentation/index.rst @@ -14,6 +14,7 @@ Contents: kernel-documentation media/index gpu/index + sections/index Indices and tables ================== diff --git a/Documentation/sections/conf.py b/Documentation/sections/conf.py new file mode 100644 index 000000000000..faa1c57595e1 --- /dev/null +++ b/Documentation/sections/conf.py @@ -0,0 +1,4 @@ +# -*- coding: utf-8; mode: python -*- + +project = 'Linux Kernel ELF sections' +html_search_language = 'en' diff --git a/Documentation/sections/index.rst b/Documentation/sections/index.rst new file mode 100644 index 000000000000..d411e9b22eb3 --- /dev/null +++ b/Documentation/sections/index.rst @@ -0,0 +1,11 @@ +========================= +Linux Kernel ELF sections +========================= + +This book documents the Linux kernel's use of ELF sections, as well as helpers +used throughout the kernel to help declare and define them. + +.. toctree:: + :maxdepth: 4 + + section-core diff --git a/Documentation/sections/section-core.rst b/Documentation/sections/section-core.rst new file mode 100644 index 000000000000..ecf4228bc4f8 --- /dev/null +++ b/Documentation/sections/section-core.rst @@ -0,0 +1,153 @@ +============================== +Core Linux kernel ELF sections +============================== + +About +===== + +This book documents the different standard and custom ELF sections used +on the Linux kernel, which we refer to as the ``core Linux sections``. We +start off by documenting the standard ELF sections used by Linux and move +on to the basic custom ELF sections, followed by a set of helpers. Each +section documented describes the goal of the section, and addresses +concurrency considerations when applicable. + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Custom linker script + +Standard ELF section use in Linux +================================= + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Standard ELF section use in Linux + +SECTION_RODATA +-------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_RODATA + +SECTION_RODATA +-------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_TEXT + +SECTION_DATA +------------ +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_DATA + +Linux .init\* sections +====================== + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux init sections + +SECTION_INIT_DATA +----------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_INIT_DATA + +SECTION_INIT_RODATA +------------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_INIT_RODATA + +SECTION_INIT_CALL +----------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_INIT_CALL + +Linux .exit\* sections +====================== + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux exit sections + +SECTION_EXIT +------------ +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_EXIT + +SECTION_EXIT_DATA +----------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_EXIT_DATA + +SECTION_EXIT_CALL +----------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_EXIT_CALL + +Linux .ref\* sections +===================== + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux references to init sections + +SECTION_REF +----------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_REF + +SECTION_REF_DATA +---------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_REF_DATA + +SECTION_REF_RODATA +------------------ +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_REF_RODATA + +Linux section ordering +====================== +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux section ordering + +SECTION_ORDER_ANY +----------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: SECTION_ORDER_ANY + +Generic Linux kernel section helpers +==================================== + +Introduction +------------- +.. kernel-doc:: include/linux/sections.h + :doc: Introduction + +LINUX_SECTION_ALIGNMENT +----------------------- +.. kernel-doc:: include/linux/sections.h + :functions: LINUX_SECTION_ALIGNMENT + +LINUX_SECTION_SIZE +------------------ +.. kernel-doc:: include/linux/sections.h + :functions: LINUX_SECTION_SIZE + +LINUX_SECTION_EMPTY +------------------- +.. kernel-doc:: include/linux/sections.h + :functions: LINUX_SECTION_EMPTY + +LINUX_SECTION_START +------------------- +.. kernel-doc:: include/linux/sections.h + :functions: LINUX_SECTION_START + +LINUX_SECTION_END +----------------- +.. kernel-doc:: include/linux/sections.h + :functions: LINUX_SECTION_END + +DECLARE_LINUX_SECTION +--------------------- +.. kernel-doc:: include/linux/sections.h + :functions: DECLARE_LINUX_SECTION + +DECLARE_LINUX_SECTION_RO +------------------------ +.. kernel-doc:: include/linux/sections.h + :functions: DECLARE_LINUX_SECTION_RO diff --git a/MAINTAINERS b/MAINTAINERS index 5aec01883020..689c12075842 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5217,6 +5217,20 @@ S: Supported F: drivers/base/power/domain*.c F: include/linux/pm_domain.h +GENERIC SECTIONS +M: "Luis R. Rodriguez" +M: Josh Poimboeuf +M: "H. Peter Anvin" +L: linux-arch@vger.kernel.org +L: linux-kernel@vger.kernel.org +T: git git://git.kernel.org/pub/scm/linux/kernel/git/mcgrof/linux.git for-arnd +T: git git://git.kernel.org/pub/scm/linux/kernel/git/mcgrof/linux-next.git for-arnd +S: Supported +F: include/asm-generic/section-core.h +F: include/asm-generic/sections.h +F: include/asm-generic/vmlinux.lds.h +F: Documentation/sections/section-core.rst + GENERIC UIO DRIVER FOR PCI DEVICES M: "Michael S. Tsirkin" L: kvm@vger.kernel.org diff --git a/arch/alpha/include/asm/Kbuild b/arch/alpha/include/asm/Kbuild index bf8475ce85ee..5422827f1585 100644 --- a/arch/alpha/include/asm/Kbuild +++ b/arch/alpha/include/asm/Kbuild @@ -10,3 +10,4 @@ generic-y += mm-arch-hooks.h generic-y += preempt.h generic-y += sections.h generic-y += trace_clock.h +generic-y += section-core.h diff --git a/arch/arc/include/asm/Kbuild b/arch/arc/include/asm/Kbuild index 0b10ef2a4372..9a0929576de1 100644 --- a/arch/arc/include/asm/Kbuild +++ b/arch/arc/include/asm/Kbuild @@ -50,3 +50,4 @@ generic-y += user.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/arm/include/asm/Kbuild b/arch/arm/include/asm/Kbuild index 0745538b26d3..47923635be16 100644 --- a/arch/arm/include/asm/Kbuild +++ b/arch/arm/include/asm/Kbuild @@ -39,3 +39,4 @@ generic-y += termios.h generic-y += timex.h generic-y += trace_clock.h generic-y += unaligned.h +generic-y += section-core.h diff --git a/arch/arm64/include/asm/Kbuild b/arch/arm64/include/asm/Kbuild index f43d2c44c765..42d00806e4fb 100644 --- a/arch/arm64/include/asm/Kbuild +++ b/arch/arm64/include/asm/Kbuild @@ -52,3 +52,4 @@ generic-y += unaligned.h generic-y += user.h generic-y += vga.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/avr32/include/asm/Kbuild b/arch/avr32/include/asm/Kbuild index 241b9b9729d8..f2c3b656a0e7 100644 --- a/arch/avr32/include/asm/Kbuild +++ b/arch/avr32/include/asm/Kbuild @@ -22,3 +22,4 @@ generic-y += trace_clock.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/blackfin/include/asm/Kbuild b/arch/blackfin/include/asm/Kbuild index 91d49c0a3118..7de674411bed 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -48,3 +48,4 @@ generic-y += unaligned.h generic-y += user.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/c6x/include/asm/Kbuild b/arch/c6x/include/asm/Kbuild index 64465e7e2245..38127ce747be 100644 --- a/arch/c6x/include/asm/Kbuild +++ b/arch/c6x/include/asm/Kbuild @@ -62,3 +62,4 @@ generic-y += user.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/cris/include/asm/Kbuild b/arch/cris/include/asm/Kbuild index 1778805f6380..385cd88a9d9e 100644 --- a/arch/cris/include/asm/Kbuild +++ b/arch/cris/include/asm/Kbuild @@ -45,3 +45,4 @@ generic-y += types.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/frv/include/asm/Kbuild b/arch/frv/include/asm/Kbuild index 1fa084cf1a43..46d7c599d9b8 100644 --- a/arch/frv/include/asm/Kbuild +++ b/arch/frv/include/asm/Kbuild @@ -8,3 +8,4 @@ generic-y += mm-arch-hooks.h generic-y += preempt.h generic-y += trace_clock.h generic-y += word-at-a-time.h +generic-y += section-core.h diff --git a/arch/h8300/include/asm/Kbuild b/arch/h8300/include/asm/Kbuild index 373cb23301e3..1ec04ec1c82b 100644 --- a/arch/h8300/include/asm/Kbuild +++ b/arch/h8300/include/asm/Kbuild @@ -75,3 +75,4 @@ generic-y += unaligned.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/hexagon/include/asm/Kbuild b/arch/hexagon/include/asm/Kbuild index db8ddabc6bd2..37d7bfae7619 100644 --- a/arch/hexagon/include/asm/Kbuild +++ b/arch/hexagon/include/asm/Kbuild @@ -60,3 +60,4 @@ generic-y += unaligned.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/ia64/include/asm/Kbuild b/arch/ia64/include/asm/Kbuild index 502a91d8dbbd..672c6d5da18c 100644 --- a/arch/ia64/include/asm/Kbuild +++ b/arch/ia64/include/asm/Kbuild @@ -9,3 +9,4 @@ generic-y += preempt.h generic-y += trace_clock.h generic-y += vtime.h generic-y += word-at-a-time.h +generic-y += section-core.h diff --git a/arch/m32r/include/asm/Kbuild b/arch/m32r/include/asm/Kbuild index 860e440611c9..6111e1523750 100644 --- a/arch/m32r/include/asm/Kbuild +++ b/arch/m32r/include/asm/Kbuild @@ -11,3 +11,4 @@ generic-y += preempt.h generic-y += sections.h generic-y += trace_clock.h generic-y += word-at-a-time.h +generic-y += section-core.h diff --git a/arch/m68k/include/asm/Kbuild b/arch/m68k/include/asm/Kbuild index eb85bd9c6180..eef72c464c9b 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -35,3 +35,4 @@ generic-y += trace_clock.h generic-y += types.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/metag/include/asm/Kbuild b/arch/metag/include/asm/Kbuild index 29acb89daaaa..50ebd5a30d16 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -56,3 +56,4 @@ generic-y += user.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/microblaze/include/asm/Kbuild b/arch/microblaze/include/asm/Kbuild index b0ae88c9fed9..c6c2cf6edc98 100644 --- a/arch/microblaze/include/asm/Kbuild +++ b/arch/microblaze/include/asm/Kbuild @@ -11,3 +11,4 @@ generic-y += preempt.h generic-y += syscalls.h generic-y += trace_clock.h generic-y += word-at-a-time.h +generic-y += section-core.h diff --git a/arch/mips/include/asm/Kbuild b/arch/mips/include/asm/Kbuild index 9740066cc631..12f7c5984c03 100644 --- a/arch/mips/include/asm/Kbuild +++ b/arch/mips/include/asm/Kbuild @@ -20,3 +20,4 @@ generic-y += trace_clock.h generic-y += user.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/mn10300/include/asm/Kbuild b/arch/mn10300/include/asm/Kbuild index 1c8dd0f5cd5d..f8145bc85835 100644 --- a/arch/mn10300/include/asm/Kbuild +++ b/arch/mn10300/include/asm/Kbuild @@ -10,3 +10,4 @@ generic-y += preempt.h generic-y += sections.h generic-y += trace_clock.h generic-y += word-at-a-time.h +generic-y += section-core.h diff --git a/arch/nios2/include/asm/Kbuild b/arch/nios2/include/asm/Kbuild index d63330e88379..c9c7cb82b00f 100644 --- a/arch/nios2/include/asm/Kbuild +++ b/arch/nios2/include/asm/Kbuild @@ -63,3 +63,4 @@ generic-y += user.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/openrisc/include/asm/Kbuild b/arch/openrisc/include/asm/Kbuild index 2832f031fb11..86175e701869 100644 --- a/arch/openrisc/include/asm/Kbuild +++ b/arch/openrisc/include/asm/Kbuild @@ -71,3 +71,4 @@ generic-y += user.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/parisc/include/asm/Kbuild b/arch/parisc/include/asm/Kbuild index f9b3a81aefcd..6f43f33f0e0f 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -29,3 +29,4 @@ generic-y += user.h generic-y += vga.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/powerpc/include/asm/Kbuild b/arch/powerpc/include/asm/Kbuild index ab9f4e0ed4cf..b49fab7bab2f 100644 --- a/arch/powerpc/include/asm/Kbuild +++ b/arch/powerpc/include/asm/Kbuild @@ -7,3 +7,4 @@ generic-y += mcs_spinlock.h generic-y += preempt.h generic-y += rwsem.h generic-y += vtime.h +generic-y += section-core.h diff --git a/arch/s390/include/asm/Kbuild b/arch/s390/include/asm/Kbuild index 20f196b82a6e..89e74b59f32d 100644 --- a/arch/s390/include/asm/Kbuild +++ b/arch/s390/include/asm/Kbuild @@ -8,3 +8,4 @@ generic-y += mm-arch-hooks.h generic-y += preempt.h generic-y += trace_clock.h generic-y += word-at-a-time.h +generic-y += section-core.h diff --git a/arch/score/include/asm/Kbuild b/arch/score/include/asm/Kbuild index a05218ff3fe4..f089a264cd38 100644 --- a/arch/score/include/asm/Kbuild +++ b/arch/score/include/asm/Kbuild @@ -14,3 +14,4 @@ generic-y += trace_clock.h generic-y += xor.h generic-y += serial.h generic-y += word-at-a-time.h +generic-y += section-core.h diff --git a/arch/sh/include/asm/Kbuild b/arch/sh/include/asm/Kbuild index 751c3373a92c..7b0356dca562 100644 --- a/arch/sh/include/asm/Kbuild +++ b/arch/sh/include/asm/Kbuild @@ -39,3 +39,4 @@ generic-y += termios.h generic-y += trace_clock.h generic-y += ucontext.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/sparc/include/asm/Kbuild b/arch/sparc/include/asm/Kbuild index cfc918067f80..d51b84d6b4b7 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild @@ -22,3 +22,4 @@ generic-y += serial.h generic-y += trace_clock.h generic-y += types.h generic-y += word-at-a-time.h +generic-y += section-core.h diff --git a/arch/tile/include/asm/Kbuild b/arch/tile/include/asm/Kbuild index ba35c41c71ff..7b8a652e43ae 100644 --- a/arch/tile/include/asm/Kbuild +++ b/arch/tile/include/asm/Kbuild @@ -41,3 +41,4 @@ generic-y += termios.h generic-y += trace_clock.h generic-y += types.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/um/include/asm/Kbuild b/arch/um/include/asm/Kbuild index 904f3ebf4220..e9849834d55e 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -27,3 +27,4 @@ generic-y += topology.h generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/arch/unicore32/include/asm/section-core.h b/arch/unicore32/include/asm/section-core.h new file mode 100644 index 000000000000..ebffeed8835d --- /dev/null +++ b/arch/unicore32/include/asm/section-core.h @@ -0,0 +1,19 @@ +#ifndef __UNICORE_SECTION_CORE_ASM_H__ +#define __UNICORE_SECTION_CORE_ASM_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/. + */ + +/* Unicore32 has known to not work properly with the type set, so ignore it */ + +#define __set_section_core_type(___section, ___core, ___name, \ + ___level, ___flags, ___type) \ + .section ___section.___core.___name.___level, ___flags + +#include + +#endif /* __UNICORE_SECTION_CORE_ASM_H__ */ diff --git a/arch/x86/include/asm/Kbuild b/arch/x86/include/asm/Kbuild index 2cfed174e3c9..f6914a57bc16 100644 --- a/arch/x86/include/asm/Kbuild +++ b/arch/x86/include/asm/Kbuild @@ -16,3 +16,4 @@ generic-y += dma-contiguous.h generic-y += early_ioremap.h generic-y += mcs_spinlock.h generic-y += mm-arch-hooks.h +generic-y += section-core.h diff --git a/arch/xtensa/include/asm/Kbuild b/arch/xtensa/include/asm/Kbuild index 28cf4c5d65ef..81ca6816bd72 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -31,3 +31,4 @@ generic-y += topology.h generic-y += trace_clock.h generic-y += word-at-a-time.h generic-y += xor.h +generic-y += section-core.h diff --git a/include/asm-generic/section-core.h b/include/asm-generic/section-core.h new file mode 100644 index 000000000000..2ab57e2c4117 --- /dev/null +++ b/include/asm-generic/section-core.h @@ -0,0 +1,341 @@ +#ifndef _ASM_GENERIC_SECTION_CORE_H_ +#define _ASM_GENERIC_SECTION_CORE_H_ +/* + * Linux section core definitions + * + * 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/. + */ + +/** + * DOC: Custom linker script + * + * The Linux vmlinux binary uses a custom linker script on each architecture + * which it uses to strategically place standard ELF sections and also adds + * custom specialized ELF sections. Each architecture defines its own custom + * linker defined in arch/$(ARCH)/kernel/vmlinux.lds.S -- these in turn + * include and use definitions in include/asm-generic/vmlinux.lds.h as well + * as some helpers documented in this chaper. + */ + +/** + * DOC: Standard ELF section use in Linux + * + * Linux makes use of the standard ELF sections, this sections documents + * these. + */ + +/** + * DOC: SECTION_RODATA + * + * Macro name for code which must be protected from write access, read only + * data. + */ +#define SECTION_RODATA .rodata + +/** + * DOC: SECTION_TEXT + * + * Macro name used to annotate code (functions) used during regular + * kernel run time. This is combined with `SECTION_RODATA`, only this + * section also allows for execution. + * + */ +#define SECTION_TEXT .text + +/** + * DOC: SECTION_DATA + * + * Macro name for read-write data. + */ +#define SECTION_DATA .data + +/** + * DOC: Linux init sections + * + * These sections are used for code and data structures used during boot or + * module initialization. On architectures that support it (x86, x86_64), all + * this code is freed up by the kernel right before the fist userspace init + * process is called when built-in to the kernel, and if modular it is freed + * after module initialization. Since the code is freed so early, in theory + * there should be no races against freeing this code with other CPUs. Init + * section code and data structures should never be exported with + * EXPORT_SYMBOL*() as the code will quickly become unavailable to the kernel + * after bootup. + */ + +/** + * DOC: SECTION_INIT + * + * Macro name used to annotate code (functions) used only during boot or driver + * initialization. + * + */ +#define SECTION_INIT .init.text + +/** + * DOC: SECTION_INIT_DATA + * + * Macro name used to annotate data structures used only during boot or driver + * initialization. + */ +#define SECTION_INIT_DATA .init.data + +/** + * DOC: SECTION_INIT_RODATA + * + * Macro name used to annotate read-only code (functions) used only during boot + * or driver initialization. + */ +#define SECTION_INIT_RODATA .init.rodata + +/** + * DOC: SECTION_INIT_CALL + * + * Special macro name used to annotate subsystem init call. These calls are + * are now grouped by functionality into separate subsections. Ordering inside + * the subsections is determined by link order. + */ +#define SECTION_INIT_CALL .initcall + +/** + * DOC: Linux exit sections + * + * These sections are used to declare a functions and data structures which + * are only required on exit, the function or data structure will be dropped + * if the code declaring this section is not compiled as a module on + * architectures that support this (x86, x86_64). There is no special case + * handling for this code when built-in to the kernel. + */ + +/** + * DOC: SECTION_EXIT + * + * Macro name used to annotate code (functions) used only during module + * unload. + */ +#define SECTION_EXIT .exit.text + +/** + * DOC: SECTION_EXIT_DATA + * + * Macro name used to annotate data structures used only during module + * unload. + */ +#define SECTION_EXIT_DATA .exit.data + +/** + * DOC: SECTION_EXIT_CALL + * + * Special macro name used to annotate an exit exit routine, order + * is important and maintained by link order. + */ +#define SECTION_EXIT_CALL .exitcall.exit + +/** + * DOC: Linux references to init sections + * + * These sections are used to teach modpost to not warn about possible + * misuses of init section code from other sections. If you use this + * your use case should document why you are certain such use of init + * sectioned code is valid. For more details refer to ``include/linux/init.h`` + * ``__ref``, ``__refdata``, and ``__refconst`` documentation. + */ + +/** + * DOC: SECTION_REF + * + * Macro name used to annotate that code (functions) declared with this section + * has been vetteed as valid for its reference or use of other code (functions) + * or data structures which are part of the init sections. + */ +#define SECTION_REF .ref.text + +/** + * DOC: SECTION_REF_DATA + * + * Macro name used to annotate data structures declared with this section have + * been vetteed for its reference or use of other code (functions) or data + * structures part of the init sections. + */ +#define SECTION_REF_DATA .ref.data + +/** + * DOC: SECTION_REF_RODATA + * + * Macro name used to annotate const code (functions) const data structures + * which has been vetteed for its reference or use of other code (functions) + * or data structures part of the init sections. + */ +#define SECTION_REF_RODATA .ref.rodata + +/** + * DOC: Linux section ordering + * + * Linux may use binutils linker-script 'SORT()' on sections to sort Linux + * sections. Linux has used 'SORT()' in ``include/asm-generic/vmlinux.lds.h`` + * for years. + */ + +/** + * DOC: SECTION_ORDER_ANY + * + * Macro name which can be used as helper to annotate custom section + * ordering at link time is not relevant for specific sections. + */ +#define SECTION_ORDER_ANY any + +/* + * These section _ALL() helpers are for use on linker scripts and helpers + */ +#define SECTION_ALL(__section) \ + __section##.* + +#define __SECTION_CORE(__section, __core, __name, __level) \ + __section.__core.__name.__level + +#define SECTION_CORE_ALL(__section, __core) \ + __section##.##__core##.* + +/* Can be used on foo.S for instance */ +#ifndef __set_section_core_type +# define __set_section_core_type(___section, ___core, ___name, \ + ___level, ___flags, ___type) \ + .section ___section.___core.___name.___level, ___flags, ___type +#endif + +#ifndef __set_section_core +# define __set_section_core(___section, ___core, ___name, ___level, ___flags) \ + .section ___section.___core.___name.___level, ___flags +#endif + +#ifndef __push_section_core +# define __push_section_core(__section, __core, __name, __level, __flags) \ + .pushsection __section.__core.__name.__level, __flags +#endif + +#ifdef __KERNEL__ +#include +#endif + +#if defined(__ASSEMBLER__) || defined(__ASSEMBLY__) + +# ifdef LINKER_SCRIPT + +# ifndef SECTION_CORE +# define SECTION_CORE(__section, __core, __name, __level) \ + __SECTION_CORE(__section,__core,__name,__level) +# endif + +# else + +# ifndef SECTION_CORE +# define SECTION_CORE(__section, __core, __name, __level) \ + push_section_core(__section, __core, __name, __level,) +# endif + +# ifndef push_section_core +# define push_section_core(__section, __core, __name, __level, __flags) \ + __push_section_core(__section, __core, __name, \ + __level, __stringify(__flags)) +# endif + +# ifndef set_section_core +# define set_section_core(__section, __core, __name, \ + __level, __flags) \ + __set_section_core(__section, __core, __name, \ + __level, __stringify(__flags)) +# endif + +# ifndef set_section_core_type +# define set_section_core_type(__section, __core, __name, \ + __level, __flags, __type) \ + __set_section_core_type(__section, __core, __name, __level, \ + __stringify(__flags), __type) +# endif + +# endif /* LINKER_SCRIPT */ +#else /* defined(__ASSEMBLER__) || defined(__ASSEMBLY__) */ + +# ifndef SECTION_CORE +# define SECTION_CORE(__section, __core, __name, __level) \ + __stringify(__SECTION_CORE(__section,__core,__name,__level)) +# endif + +/* + * As per gcc's documentation a common asm separator is a new line followed + * by tab [0], it however seems possible to also just use a newline as its + * the most commonly empirically observed semantic and folks seem to agree + * this even works on S390. In case your architecture disagrees you may + * override this and define your own and keep the rest of the macros. + * + * [0] https://gcc.gnu.org/onlinedocs/gcc/Basic-Asm.html#Basic-Asm + */ +# ifndef ASM_CMD_SEP +# define ASM_CMD_SEP "\n" +# endif + +# ifndef set_section_core +# define set_section_core(__section, __core, __name, __level, __flags) \ + __stringify(__set_section_core_type(__section, __core, __name, \ + __level, __stringify(__flags))) \ + ASM_CMD_SEP +# endif + +/* + * Some architectures (arm, and avr32 are two examples on kprobes) seem + * currently explicitly specify the type [0] -- this can be any of the + * optional constants on ELF: + * + * @progbits - section contains data + * @nobits - section does not contain data (i.e., section only occupies space) + * @note - section contains data which is used by things other than the program + * @init_array - section contains an array of pointers to init functions + * @fini_array - section contains an array of pointers to finish functions + * @preinit_array - section contains an array of pointers to pre-init functions + * + * ARM requires % instead of @. + * + * At least as per nasm (x86/x86_64 only), in the absence of qualifiers the + * defaults are as follows: + * + * section .text progbits alloc exec nowrite align=16 + * section .rodata progbits alloc noexec nowrite align=4 + * section .lrodata progbits alloc noexec nowrite align=4 + * section .data progbits alloc noexec write align=4 + * section .ldata progbits alloc noexec write align=4 + * section .bss nobits alloc noexec write align=4 + * section .lbss nobits alloc noexec write align=4 + * section .tdata progbits alloc noexec write align=4 tls + * section .tbss nobits alloc noexec write align=4 tls + * section .comment progbits noalloc noexec nowrite align=1 + * section other progbits alloc noexec nowrite align=1 + * + * gas should have sensible defaults for architectures... + * + * [0] http://www.nasm.us/doc/nasmdoc7.html + */ +# ifndef set_section_core_type +# define set_section_core_type(__section, __core, __name, __level, \ + __flags, __type) \ + __stringify(__set_section_core_type(__section, __core, \ + __name, __level, \ + __stringify(__flags), \ + __type)) \ + ASM_CMD_SEP +# endif + +# ifndef push_section_core +# define push_section_core(__section, __core, __name, \ + __level, __flags) \ + __stringify(__push_section_core(__section, __core, \ + __name, __level, \ + __stringify(__flags))) \ + ASM_CMD_SEP +# endif + +#endif /* defined(__ASSEMBLER__) || defined(__ASSEMBLY__) */ +#endif /* _ASM_GENERIC_SECTION_CORE_H_ */ diff --git a/include/asm-generic/sections.h b/include/asm-generic/sections.h index af0254c09424..298252df3c81 100644 --- a/include/asm-generic/sections.h +++ b/include/asm-generic/sections.h @@ -1,6 +1,8 @@ #ifndef _ASM_GENERIC_SECTIONS_H_ #define _ASM_GENERIC_SECTIONS_H_ +#include + /* References to section boundaries */ #include diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h index 24563970ff7b..731087276a32 100644 --- a/include/asm-generic/vmlinux.lds.h +++ b/include/asm-generic/vmlinux.lds.h @@ -55,6 +55,7 @@ #endif #include +#include /* Align . to a 8 byte boundary equals to maximum function alignment. */ #define ALIGN_FUNCTION() . = ALIGN(8) @@ -198,8 +199,8 @@ /* .data section */ #define DATA_DATA \ - *(.data) \ - *(.ref.data) \ + *(SECTION_DATA) \ + *(SECTION_REF_DATA) \ *(.data..shared_aligned) /* percpu related */ \ MEM_KEEP(init.data) \ MEM_KEEP(exit.data) \ @@ -262,9 +263,9 @@ */ #define RO_DATA_SECTION(align) \ . = ALIGN((align)); \ - .rodata : AT(ADDR(.rodata) - LOAD_OFFSET) { \ + SECTION_RODATA : AT(ADDR(SECTION_RODATA) - LOAD_OFFSET) { \ VMLINUX_SYMBOL(__start_rodata) = .; \ - *(.rodata) *(.rodata.*) \ + *(SECTION_RODATA) *(SECTION_ALL(SECTION_RODATA)) \ RO_AFTER_INIT_DATA /* Read only after init */ \ *(__vermagic) /* Kernel version magic */ \ . = ALIGN(8); \ @@ -394,7 +395,7 @@ \ /* __*init sections */ \ __init_rodata : AT(ADDR(__init_rodata) - LOAD_OFFSET) { \ - *(.ref.rodata) \ + *(SECTION_REF_RODATA) \ MEM_KEEP(init.rodata) \ MEM_KEEP(exit.rodata) \ } \ @@ -432,8 +433,8 @@ * during second ld run in second ld pass when generating System.map */ #define TEXT_TEXT \ ALIGN_FUNCTION(); \ - *(.text.hot .text .text.fixup .text.unlikely) \ - *(.ref.text) \ + *(.text.hot SECTION_TEXT .text.fixup .text.unlikely) \ + *(SECTION_REF) \ MEM_KEEP(init.text) \ MEM_KEEP(exit.text) \ @@ -527,11 +528,11 @@ /* init and exit section handling */ #define INIT_DATA \ - *(.init.data) \ + *(SECTION_INIT_DATA) \ MEM_DISCARD(init.data) \ KERNEL_CTORS() \ MCOUNT_REC() \ - *(.init.rodata) \ + *(SECTION_INIT_RODATA) \ FTRACE_EVENTS() \ TRACE_SYSCALLS() \ KPROBE_BLACKLIST() \ @@ -549,24 +550,24 @@ EARLYCON_TABLE() #define INIT_TEXT \ - *(.init.text) \ + *(SECTION_INIT) \ *(.text.startup) \ MEM_DISCARD(init.text) #define EXIT_DATA \ - *(.exit.data) \ + *(SECTION_EXIT_DATA) \ *(.fini_array) \ *(.dtors) \ MEM_DISCARD(exit.data) \ MEM_DISCARD(exit.rodata) #define EXIT_TEXT \ - *(.exit.text) \ + *(SECTION_EXIT) \ *(.text.exit) \ MEM_DISCARD(exit.text) #define EXIT_CALL \ - *(.exitcall.exit) + *(SECTION_EXIT_CALL) /* * bss (Block Started by Symbol) - uninitialized data diff --git a/include/linux/sections.h b/include/linux/sections.h new file mode 100644 index 000000000000..f21c6ee88ded --- /dev/null +++ b/include/linux/sections.h @@ -0,0 +1,111 @@ +#ifndef _LINUX_SECTIONS_H +#define _LINUX_SECTIONS_H +/* + * Linux de-facto sections + * + * 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 + * + * Linux defines a set of common helpers which can be used to against its use + * of standard or custom Linux sections, this section is dedicated to these + * helpers. + */ + +/** + * LINUX_SECTION_ALIGNMENT - get section alignment + * + * @name: section name + * + * Gives you the alignment for the section. + */ +#define LINUX_SECTION_ALIGNMENT(name) __alignof__(*VMLINUX_SYMBOL(name)) + +/** + * LINUX_SECTION_SIZE - get number of entries in the section + * + * @name: section name + * + * This gives you the number of entries in the section. + * Example usage: + * + * unsigned int num_frobs = LINUX_SECTION_SIZE(frobnicator_fns); + */ +#define LINUX_SECTION_SIZE(name) \ + ((VMLINUX_SYMBOL(name##__end)) - (VMLINUX_SYMBOL(name))) + +/** + * LINUX_SECTION_EMPTY - check if section has no entries + * + * @name: section name + * + * Returns true if section is emtpy. + * + * bool is_empty = LINUX_SECTION_EMPTY(frobnicator_fns); + */ +#define LINUX_SECTION_EMPTY(name) (LINUX_SECTION_SIZE(name) == 0) + +/** + * LINUX_SECTION_START - get address of start of section + * + * @name: section name + * + * This gives you the start address of the section. + * This should give you the address of the first entry. + * + */ +#define LINUX_SECTION_START(name) VMLINUX_SYMBOL(name) + +/** + * LINUX_SECTION_END - get address of end of the section + * + * @name: section name + * + * This gives you the end address of the section. + * This should give you the address of the end of the + * section. This will match the start address if the + * section is empty. + */ +#define LINUX_SECTION_END(name) VMLINUX_SYMBOL(name##__end) + +/** + * DECLARE_LINUX_SECTION - Declares a custom Linux section + * + * @type: type of custom Linux section + * @name: custom section name + * + * Declares a read-write custom Linux section + */ +#define DECLARE_LINUX_SECTION(type, name) \ + extern type VMLINUX_SYMBOL(name)[], \ + VMLINUX_SYMBOL(name##__end)[] + +/** + * DECLARE_LINUX_SECTION_RO - Declares a read-only custom Linux section + * + * @type: type of custom Linux section + * @name: custom section name + * + * Declares a read-only custom Linux section + */ +#define DECLARE_LINUX_SECTION_RO(type, name) \ + extern const type VMLINUX_SYMBOL(name)[], \ + VMLINUX_SYMBOL(name##__end)[] + +#define __SECTION_TYPE(section, type, name, level) \ + #section "." #type "." #name "." #level + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_SECTIONS_H */ -- 2.9.2