From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Subject: [PATCH v6 01/14] generic-sections: add section core helpers Date: Mon, 9 Jan 2017 06:58:19 -0800 Message-ID: <20170109145833.11502-2-mcgrof@kernel.org> References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20170109145833.11502-1-mcgrof@kernel.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: hpa@zytor.com, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com, dalias@libc.org, linux@arm.linux.org.uk Cc: gnomes@lxorguk.ukuu.org.uk, linux-ia64@vger.kernel.org, jkosina@suse.cz, benh@kernel.crashing.org, ming.lei@canonical.com, linux@rasmusvillemoes.dk, platform-driver-x86@vger.kernel.org, James.Bottomley@HansenPartnership.com, paul.gortmaker@windriver.com, paulus@samba.org, sparclinux@vger.kernel.org, wangnan0@huawei.com, mchehab@osg.samsung.com, linux-arch@vger.kernel.org, markus.heiser@darmarit.de, xen-devel@lists.xensource.com, msalter@redhat.com, linux-sh@vger.kernel.org, mpe@ellerman.id.au, joro@8bytes.org, x86@kernel.org, fontana@sharpeleven.org, dsahern@gmail.com, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, dvhart@infradead.org, dwmw2@infradead.org, linux@roeck-us.net, linux-xtensa@linux-xtensa.org, pali.rohar@gmail.com, keescook@chromium.org, arnd@arndb.de, jani.nikula@intel.com, will.deacon@arm.com, rusty@rustcorp.com.au, rostedt@goodmis.org, ak@ List-Id: linux-arch.vger.kernel.org TGludXggbWFrZXMgZXh0ZW5zaXZlIHVzZSBvZiBjdXN0b20gRUxGIGhlYWRlciBzZWN0aW9ucywK ZG9jdW1lbnRhdGlvbiBmb3IgdGhlc2UgYXJlIHdlbGwgc2NhdHRlcnJlZC4gVW5pZnkgdGhpcwpk b2N1bWVudGF0aW9uIGluIGEgY2VudHJhbCBwbGFjZSBhbmQgcHJvdmlkZSBoZWxwZXJzIHRvCmJ1 aWxkIGN1c3RvbSBMaW51eCBzZWN0aW9ucy4KClRoaXMgYWxzbyBnZW5lcmFsaXplcyBzZWN0aW9u cyBjb2RlIHRvIGVuYWJsZSBhdm9pZGluZwptb2RpZnlpbmcgdGhlIGxpbmtlciBzY3JpcHRzIHdo ZW4gd2Ugd2FudCB0byBhZGQgbmV3CmN1c3RvbSBMaW51eCBzZWN0aW9ucy4gSW4gb3JkZXIgdG8g bWFrZSB0aGlzIGdlbmVyYWxseQp1c2VmdWwgd2UgbmVlZCB0byBlbnN1cmUgYWxsIGFyY2hpdGVj dHVyZXMgY2FuIG1ha2UgdXNlIG9mCmNvcmUgc2VjdGlvbiBoZWxwZXJzIGJ1dCB0aGF0IHRoZXkg Y2FuIGFsc28gb3ZlcnJpZGUgc2hvdWxkCnRoaXMgYmUgbmVlZGVkLiBJbnN0ZWFkIG9mIHJlbHlp bmcgb24gc2VjdGlvbi5oIHRoaXMgYWRkcwphIHNlY3Rpb25zLWNvcmUuaCBzaW5jZSB0aGlzIHdp bGwgYmUgdGFyZ2V0dGVkIHRvIGJlIHNhZmUKdG8gYmUgdXNlZCBvbiBhc20gY29kZSwgbGlua2Vy IHNjcmlwdHMgYW5kIEMgY29kZS4KCnY1OgoKbyBIdWdlIGRvY3VtZW50YXRpb24gcmV2YW1wIGJh c2VkIG9uIGEgY2FyZWZ1bCByZXZpZXcgb2YgdGhlIEVMRgogIHNwZWNpZmljYXRpb25zLiBJbmNs dWRlcyBkb2N1bWVudGF0aW9uIG5vdyBhbHNvIGFib3V0IHVzYWdlIG9mCiAgdHdvIGRvdHMgKC4u KSB3aGVuIHByZWZpeGluZyBFTEYgcHJvZ3JhbSBzcGVjaWZpYyBzZWN0aW9ucy4KCm8gUmVwbGFj ZSBtYWNyb3MgZm9yIHNlY3Rpb25zIG5hbWVzIGluIGZhdm9yIG9mIGp1c3QgdXNpbmcKICB0aGUg c2VjdGlvbiBuYW1lcyBleHBsaWNpdGx5IGluIHRoZSBsaW5rZXIgc2NyaXB0LiBUaGlzIGlzCiAg cGVyaGFwcyBtb3JlIHdvcmsgdG8gZ3JlcCBidXQgdGhpcyBpcyB3aGF0IGZvbGtzIHNlZW0gdG8K ICBjdXJyZW50bHkgcHJlZmVyLgoKbyBGaXggLnRleHQgYW5kIC5yb2RhdGEgZG9jdW1lbnRhdGlv biB0byBleHBsYWluIG1lbW9yeSBwcm90ZWN0aW9uCiAgc3RyYXRlZ2llcyB3aGljaCBhcmNoaXRl Y3R1cmVzIGNhbiBlbWJyYWNlIHVwb24gaW5pdGlhbGl6YXRpb24KICAoZG9jdW1lbnRzIENPTkZJ R19ERUJVR19ST0RBVEEgYW5kIG1hcmtfcm9kYXRhX3JvKCkpCgpvIFNraXAgdGhlICdMaW51eCBz ZWN0aW9uIG9yZGVyaW5nJyBkb2N1bWVudGF0aW9uIHNlY3Rpb24sIHdlJ2xsIGluc3RlYWQKICBh ZGQgdGhpcyBvbiBzdWJzZXF1ZW50IHBhdGNoIHdoaWNoIHdpbGwgZXhwYW5kIG9uIGl0IGNvbnNp ZGVyYWJseQoKbyBEcm9wcGVkIHRyZWUgb24gTUFJTlRBSU5FUlMgLS0gYXMgcGVyIGRpc2N1c3Np b25zIHdpdGggQXJuZCwgaHBhIGFuZAogIEpvc2gsIGl0cyBlYXNpZXIgdG8ganVzdCBsZXQgY2hh bmdlcyBmb3Igc2VjdGlvbnMgZ28gaW4gdGhyb3VnaCB0aGUKICByZXNwZWN0aXZlIHRyZWUgdGhh dCBuZWVkcyB0aGUgY2hhbmdlcy4KCm8gRml4IHR5cG9zIG9uIGRvY3VtZW50YXRpb24KCm8gRHJv cHBlZCBTRUNUSU9OX0FMTCgpLCBfX1NFQ1RJT05fQ09SRSgpLCBTRUNUSU9OX0NPUkVfQUxMKCkg bWFjcm9zCiAgc2luY2Ugd2UgYXJlIGZhdm9yaW5nIHVzaW5nIGV4cGxpY2l0IHNlY3Rpb24gbmFt ZXMuIFRoZXNlIGFyZQogIHVzZWxlc3MgaWYgd2UgYXJlIGJlaW5nIGV4cGxpY2l0LgoKbyBEcm9w IExJTlVYX1NFQ1RJT05fU0laRSgpLCBMSU5VWF9TRUNUSU9OX0VNUFRZKCkgaW4gZmF2b3Igb2Yg aGF2aW5nCiAgc2VjdGlvbiByYW5nZXMgYW5kIGxpbmtlciB0YWJsZXMgZGVmaW5lIHRoZWlyIG93 biwgdG8gYXZvaWQgY29uZnVzaW9uCiAgYW5kIG1ha2UgY29kZSBtb3JlIHJlYWRhYmxlLgoKbyBB ZGQgX19kZWZpbmVfaW5pdGNhbGwoKSBkb2N1bWVudGF0aW9uIGFuZCBhIHNtYWxsIHNlY3Rpb24g ZGVzY3JpYmluZwogIG91ciBjdXJyZW50IGluaXRjYWxsIGxldmVscy4gVGhpcyBzaG91bGQgaGVs cCBhbHNvIGNsYXJpZnkgd2hhdCB3YXMKICBtZWFudCBhYm91dCBrZWVwaW5nIGJhY2t3YXJkIGNv bXBhdGlibGl0eS4KCnY0OgoKbyBQb3J0IHRvIHNoaW55IG5ldyBzcGhpbnggZG9jdW1lbnRhdGlv biBmb3JtYXQKCm8gZml4IGEgdW5pY29yZTMyIGJ1aWxkLCB0dXJucyBvdXQgdGhpcyBhY3R1YWxs eSBmaXhlcyB1bmljb3JlMzIKICBkZWZjb25maWcgYnVpbGRzIHdoaWNoIHdlcmUgZmFpbGluZyBm b3IgYSBsb25nIHdoaWxlLiB1bmljb3JlMzIKICBkb2VzIG5vdCBzZWVtIHRvIGdyb2sgd2VsbCB0 aGUgdHlwZSBwYXNzZWQgb24gYSBzZWN0aW9uIGRlY2xhcmF0aW9uLAogIHRoaXMgaWdub3JlcyBp dC4KCm8gVXNlIFZNTElOVVhfU1lNQk9MKCkgaW4gbW9yZSB1c2VyIHN5bWJvbHMgKGV4dGVybiBD IGNvZGUpLCBub3QgZG9pbmcKICB0aGlzIHdhcyBjYXVzaW5nIGZpbmFsIGxpbmtlciBpc3N1ZXMg d2l0aCBibGFja2ZpbiAtLSB0aGlzIGlzCiAgYSBDT05GSUdfSEFWRV9VTkRFUlNDT1JFX1NZTUJP TF9QUkVGSVg9eSBhcmNoaXRlY3R1cmUuIFRoZSBvdGhlciBvbmUKICBiZWluZyBtZXRhdGFnLiBt ZXRhdGFnIGlzIG5vdCBzdXBwb3J0ZWQgb24gMC1kYXkgc28gSSBjYW5ub3QgY29uZmlybQogIGNv bXBpbGF0aW9uIHRoZXJlLgoKbyBBZGRlZCBTRUNUSU9OX0NPUkUoKSBmb3IgQyBjb2RlLCB1c2Vk IGxhdGVyIGJ5IF9fTElOVVhfUkFOR0UoKQoKbyBTaW5jZSBTRUNUSU9OX0NPUkUoKSBpcyBkZWZp bmVkIGZvciBsaW5rZXIgc2NyaXB0IGFuZCBDIGNvZGUsIHNoYXJlCiAgdGhlIHNhbWUgaGVscGVy IGFuZCBqdXN0IHVzZSBhIF9fc3RyaW5naWZ5KCkgZm9yIHRoZSBDIGNvZGUgYXMgaXMgZG9uZQog IGZvciB0aGUgb3RoZXIgQyBoZWxwZXJzLgoKbyBtb3ZlIGdlbmVyaWMgc2VjdGlvbnMgdG8gYXNt LWdlbmVyaWMvc2VjdGlvbi1jb3JlLmggaW5zdGVhZC4KICBQb3dlclBDIGNvbXBpbGF0aW9uIGJs b3dzIHVwIGlmIGFzbS9qdW1wX2xhYmVscy5oIGdldHMKICBzZWN0aW9uLmggaW5jbHVkZWQsIGZp eGluZyB0aGlzIGlzIG5vdCBpbiBhbnkgd2F5IGVhc3kuCiAgVGhlIGxpc3Qgb2YgaXNzdWVzIGFy ZSBlbmRsZXNzLiBNb3ZpbmcgbmV3IGRhdGEgdG8gYSBuZXcKICBzaW1wbGUgZmlsZSByZXNvbHZl cyB0aGlzLgoKbyBzaW5jZSB0aGluZ3MgYXJlIG5vdyBpbiBhc20tZ2VuZXJpYy9zZWN0aW9uLWNv cmUuaCB0aGUKICBndWFyZCBjaGFuZ2VzIG9uIGFzbS1nZW5lcmljL3NlY3Rpb25zLmggYW5kIGVh Y2ggYXJjaGl0ZWN0dXJlCiAgc2VjdGlvbnMuaCBhcmUgbm8gbG9uZ2VyIG5lZWRlZAoKbyBHaXZl IGdlbmVyaWMgc2VjdGlvbnMgc29tZSBtYWludGFpbmVyIGxvdmUsIHRoYXQgY2hhbmdlIGlzCiAg QWNrZWQtYnkgQXJuZCBCZXJnbWFubiwgSm9zaCBhbmQgaHBhLgoKbyBBIGZldyBjaGVja3BhdGNo LnBsIHN0eWxlIGZpeGVzCgpvIEFzIHN1Z2dlc3RlZCBieSBKYW1lcyBIb2dhbiB1c2UgZ2VuZXJp Yy15IHRvIGNvcHkgZ2VuZXJpYwogIGhlYWRlciBmaWxlcyBvbiBhcmNoaXRlY3R1cmVzIHRoYXQg ZG8gbm90IGhhdmUgYSBzZWN0aW9ucy5oCiAgaW5zdGVhZCBvZiB3cml0aW5nIGEgc2ltcGxlIGZp bGUgb25seSB0byBpbmNsdWRlIHRoZSBnZW5lcmljIG9uZS4KCnYzOgoKbyBhZGQgbWlzc2luZyBz ZWN0aW9ucy5oIGZvciBhcmNoaXRlY3R1cmVzIHRoYXQgZGlkIG5vdAogIGhhdmUgaXQKCm8gbW92 ZSBnZW5lcmljIHNlY3Rpb25zIHRvIGFzbS1nZW5lcmljL3NlY3Rpb25zLmgKCm8gYWRkIGdlbmVy aWMgYXNtIGhlbHBlcnMgc2VjdGlvbl90eXBlKCksIHNlY3Rpb25fdHlwZV9hc210eXBlKCksCiAg cHVzaF9zZWN0aW9uX3R5cGUoKSAtLSB0aGVzZSBoZWxwZXJzIGVuYWJsZSBlYXN5IHVzZSBmb3IK ICBmb3IgbGF0ZXIgZGVjbGFyaW5nIGFuZCB1c2luZyBvZiBjdXN0b20gbGludXggc2VjdGlvbnMg dXNpbmcKICBtb3JlIHN0YW5kYXJkIEFQSXMgaW4gYm90aCBDIGNvZGUsIGFzbSBjb2RlIChDIGFz bSBjYWxscywgb3IKICBhc20gZmlsZXMpLCBlbmFibGluZyBmdXR1cmUgc3RhbmRhcmRpemVkIHNl Y3Rpb24gdHlwZXMgdG8KICBiZSBtb3JlIGltbWVkaWF0ZWx5IGFjY2Vzc2libGUgdG8gYXNtIGNv ZGUsIG5vdCBqdXN0IEMgY29kZS4KICBOb3RlIGZvciBBU01fQ01EX1NFUCB3ZSB1c2UgYnkgZGVm YXVsdCAiXG4iLCBhcmNoaXRlY3R1cmVzIG5lZWRlZAogIHRvIG92ZXJyaWRlIGNhbiBkbyBzbyBv biB0aGVpciBvd24gc2VjdGlvbnMuaCBwcmlvciB0byBpbmNsdXNpb24KICBvZiBhc20tZ2VuZXJp Yy9zZWN0aW9ucy5oCgpTaWduZWQtb2ZmLWJ5OiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNncm9mQGtl cm5lbC5vcmc+Ci0tLQogRG9jdW1lbnRhdGlvbi9pbmRleC5yc3QgICAgICAgICAgICAgICAgICAg fCAgIDEgKwogRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9iYWNrZ3JvdW5kLnJzdCAgICAgfCAxMDUg KysrKysrKysrKwogRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9jb25mLnB5ICAgICAgICAgICAgfCAg IDQgKwogRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9pbmRleC5yc3QgICAgICAgICAgfCAgMTcgKysK IERvY3VtZW50YXRpb24vc2VjdGlvbnMvc2VjdGlvbi1jb3JlLnJzdCAgIHwgMTQ4ICsrKysrKysr KysrKysrCiBNQUlOVEFJTkVSUyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAxMiAr KwogYXJjaC9hbHBoYS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgfCAgIDEgKwogYXJj aC9hcmMvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9hcm0v aW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9hcm02NC9pbmNs dWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9hdnIzMi9pbmNsdWRlL2Fz bS9LYnVpbGQgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9L YnVpbGQgICAgICAgICAgfCAgIDEgKwogYXJjaC9jNngvaW5jbHVkZS9hc20vS2J1aWxkICAgICAg ICAgICAgICAgfCAgIDEgKwogYXJjaC9jcmlzL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAg ICAgfCAgIDEgKwogYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgICAgfCAg IDEgKwogYXJjaC9oODMwMC9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgfCAgIDEgKwog YXJjaC9oZXhhZ29uL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgfCAgIDEgKwogYXJjaC9p YTY0L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9tMzJyL2lu Y2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9tNjhrL2luY2x1ZGUv YXNtL0tidWlsZCAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9tZXRhZy9pbmNsdWRlL2FzbS9L YnVpbGQgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL0ti dWlsZCAgICAgICAgfCAgIDEgKwogYXJjaC9taXBzL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAg ICAgICAgfCAgIDEgKwogYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAg fCAgIDEgKwogYXJjaC9uaW9zMi9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgfCAgIDEg KwogYXJjaC9vcGVucmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgfCAgIDEgKwogYXJj aC9wYXJpc2MvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9wb3dl cnBjL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgfCAgIDEgKwogYXJjaC9zMzkwL2luY2x1 ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9zY29yZS9pbmNsdWRlL2Fz bS9LYnVpbGQgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9zaC9pbmNsdWRlL2FzbS9LYnVpbGQg ICAgICAgICAgICAgICAgfCAgIDEgKwogYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9LYnVpbGQgICAg ICAgICAgICAgfCAgIDEgKwogYXJjaC90aWxlL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAg ICAgfCAgIDEgKwogYXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgICAgICAgfCAg IDEgKwogYXJjaC91bmljb3JlMzIvaW5jbHVkZS9hc20vc2VjdGlvbi1jb3JlLmggfCAgMTkgKysK IGFyY2gveDg2L2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gv eHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICAgIHwgICAxICsKIGluY2x1ZGUvYXNt LWdlbmVyaWMvc2VjdGlvbi1jb3JlLmggICAgICAgIHwgMzA3ICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKwogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9ucy5oICAgICAgICAgICAgfCAg IDIgKwogaW5jbHVkZS9hc20tZ2VuZXJpYy92bWxpbnV4Lmxkcy5oICAgICAgICAgfCAgIDEgKwog aW5jbHVkZS9saW51eC9pbml0LmggICAgICAgICAgICAgICAgICAgICAgfCAgODkgKysrKysrKy0t CiBpbmNsdWRlL2xpbnV4L3NlY3Rpb25zLmggICAgICAgICAgICAgICAgICB8ICA4NyArKysrKysr KysKIDQyIGZpbGVzIGNoYW5nZWQsIDgwOSBpbnNlcnRpb25zKCspLCAxMyBkZWxldGlvbnMoLSkK IGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL3NlY3Rpb25zL2JhY2tncm91bmQucnN0 CiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9jb25mLnB5CiBjcmVh dGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9zZWN0aW9ucy9pbmRleC5yc3QKIGNyZWF0ZSBt b2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL3NlY3Rpb25zL3NlY3Rpb24tY29yZS5yc3QKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBhcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9zZWN0aW9uLWNvcmUuaAog Y3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2xpbnV4L3NlY3Rpb25zLmgKCmRpZmYgLS1naXQgYS9E b2N1bWVudGF0aW9uL2luZGV4LnJzdCBiL0RvY3VtZW50YXRpb24vaW5kZXgucnN0CmluZGV4IGNi NWQ3NzY5OWM2MC4uNzFlMDMwNWMwMzZkIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2luZGV4 LnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2luZGV4LnJzdApAQCAtNTcsNiArNTcsNyBAQCBuZWVk ZWQpLgogICAgbWVkaWEvaW5kZXgKICAgIGdwdS9pbmRleAogICAgc2VjdXJpdHkvaW5kZXgKKyAg IHNlY3Rpb25zL2luZGV4CiAgICBzb3VuZC9pbmRleAogICAgY3J5cHRvL2luZGV4CiAKZGlmZiAt LWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvYmFja2dyb3VuZC5yc3QgYi9Eb2N1bWVudGF0 aW9uL3NlY3Rpb25zL2JhY2tncm91bmQucnN0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMC4uMGVjZjkxMDRhYWEyCi0tLSAvZGV2L251bGwKKysrIGIvRG9jdW1lbnRhdGlv bi9zZWN0aW9ucy9iYWNrZ3JvdW5kLnJzdApAQCAtMCwwICsxLDEwNSBAQAorPT09PT09PT09PT09 PT09PT09PT09PQorRUxGIHNlY3Rpb24gYmFja2dyb3VuZAorPT09PT09PT09PT09PT09PT09PT09 PQorCitBYm91dAorPT09PT0KKworVGhlIHB1cnBvc2Ugb2YgdGhpcyBjaGFwdGVyIGlzIHRvIGhl bHAgdGhvc2Ugbm90IGZhbWlsaWFyIHdpdGggRUxGIHRvIGJydXNoIHVwCit0aGUgbGF0ZXN0IEVM RiBzcGVjaWZpY2F0aW9ucyBpbiBvcmRlciB0byBoZWxwIHVuZGVyc3RhbmQgaG93IExpbnV4IHVz ZXMgYW5kCitkZWZpbmVzIGl0cyBvd24gRUxGIHNlY3Rpb25zLgorCitTdGFuZGFyZGl6ZWQgRUxG Cis9PT09PT09PT09PT09PT09CisKK1RoZSBmaXJzdCBwdWJsaWNhdGlvbiBkb2N1bWVudGluZyBF TEYgd2FzIFVOSVggU3lzdGVtIExhYm9yYXRvcmllcycgKFVTTCkKKypTeXN0ZW0gViBSZWxlYXNl IDQgQXBwbGljYXRpb24gQmluYXJ5IEludGVyZmFjZSogKGBTUlY0IEFCSWBfKSBzcGVjaWZpY2F0 aW9uLgorT3JpZ2luYWxseSBFTEYgd2FzIG9ubHkgYSBzbWFsbCBwYXJ0IG9mIHRoZSBTUlY0IEFC SSwgd2l0aCB0aW1lIGhvd2V2ZXIgbmV3CitzcGVjaWZpY2F0aW9ucyBvbmx5IHB1dCBmb2N1cyBv biBFTEYsIHN1Y2ggd2FzIHRoZSBjYXNlIG9mIHRoZSAqVElTIFBvcnRhYmxlCitGb3JtYXRzIFNw ZWNpZmljYXRpb24gdmVyc2lvbiAxLjIqIChgVElTIDEuMmBfKS4gQXMgb2YgVElTIDEuMiwgRUxG IHdhcworc3VwcGxlbWVudGVkIHdpdGggcHJvY2Vzc29yIHNwZWNpZmljIEVMRiBhZGRlbmR1bXMs IGF2YWlsYWJsZSBvbiB0aGUgKkxpbnV4CitGb3VuZGF0aW9uIHJlZmVyZW5jZWQgc3BlY2lmaWNh dGlvbiBwYWdlKiAoYExGIHJlZiBwYWdlYF8pLiBUaGUgbGF0ZXN0IEVMRgorc3BlY2lmaWNhdGlv biBpcyB0aGUgKlN5c3RlbSBWIEFwcGxpY2F0aW9uIEJpbmFyeSBJbnRlcmZhY2UgLSBEUkFGVCAt IDI0IEFwcmlsCisyMDAxKiAoYGdhYmk0YF8pLgorCisuLiBfU1JWNCBBQkk6IGh0dHA6Ly93d3cu c2NvLmNvbS9kZXZlbG9wZXJzL2RldnNwZWNzL2dhYmk0MS5wZGYKKy4uIF9USVMgMS4yOiBodHRw czovL3JlZnNwZWNzLmxpbnV4YmFzZS5vcmcvZWxmL2VsZi5wZGYKKy4uIF9MRiByZWYgcGFnZTog aHR0cHM6Ly9yZWZzcGVjcy5saW51eGJhc2Uub3JnLworLi4gX2dhYmk0OiBodHRwczovL3JlZnNw ZWNzLmxpbnV4YmFzZS5vcmcvZWxmL2dhYmk0Ky9jb250ZW50cy5odG1sCisKK0VMRiB2aWV3cyBv biBMaW51eAorPT09PT09PT09PT09PT09PT09CisKK1RoZXJlIGFyZSB0d28gdmlld3Mgd2hpY2gg Y2FuIGJlIHVzZWQgZm9yIGluc3BlY3RpbmcgZGF0YSBpbiBhbiBFTEYgZmlsZSwgYQorTGlua2lu ZyB2aWV3LCBhbmQgYW4gRXhlY3V0aW9uIHZpZXcuIEEgU2VjdGlvbiBIZWFkZXIgVGFibGUgZW5h YmxlcyBvbmUgdG8KK2Rlc2NyaWJlIGFuIG9iamVjdCB1c2luZyB0aGUgTGlua2luZyB2aWV3IHdo aWxlIGEgUHJvZ3JhbSBIZWFkZXIgVGFibGUgZW5hYmxlcworb25lIHRvIGRlc2NyaWJlIGFuIG9i amVjdCB1c2luZyB0aGUgRXhlY3V0aW9uIHZpZXcuIFRoZSB2aWV3cyBhcmUgbm90IG11dHVhbGx5 CitleGNsdXNpdmUuIEZvciBpbnRhbmNlLCB2bWxpbnV4IGNhbiBiZSB2aWV3ZWQgdW5kZXIgYm90 aCB2aWV3cywgYGByZWFkZWxmIC1TCit2bWxpbnV4YGAgZm9yIHRoZSBMaW5raW5nIHZpZXcsIGFu ZCBgYHJlYWRlbGYgLWwgdm1saW51eGBgIGZvciB0aGUgRXhlY3V0aW9uCit2aWV3LiAgSW4gTGlu dXggb25seSB0aGUgdm1saW51eCBmaWxlIHdpbGwgaGF2ZSBhbiBFeGVjdXRpb24gdmlldywgZXZl biBtb2R1bGVzCitsYWNrIGFuIEV4ZWN1dGlvbiB2aWV3IGdpdmVuIHRoYXQgdm1saW51eCBpcyB0 aGUgb25seSBmaWxlIHRoYXQgZGVzY3JpYmVzIGhvdwordGhlIHRoZSBrZXJuZWwgcnVucyBmcm9t IHRoZSBzdGFydC4gIEFsbCBvdGhlciBMaW51eCBrZXJuZWwgb2JqZWN0IGZpbGVzIGhhdmUKK2Fu IGF2YWlsYWJsZSBMaW5raW5nIHZpZXcuCisKK1VuZGVyIHRoZSBMaW5raW5nIHZpZXcsIHRoZSBT ZWN0aW9uIEhlYWRlciBUYWJsZSBkZXNjcmliZXMgYWxsIGF2YWlsYWJsZQorc2VjdGlvbnMuIFRo ZSBTZWN0aW9uIEhlYWRlciBUYWJsZSBpcyBhbiBhcnJheSBvZiBFTEYgc2VjdGlvbiBoZWFkZXIg ZGF0YQorc3RydWN0dXJlcy4gSWYgb24gYSAzMi1iaXQgc3lzdGVtIHRoaXMgaXMgYGBzdHJ1Y3Qg ZWxmMzJfc2hkYGAsIGlmIG9uIGEgNjQtYml0Cit0aGlzIGlzIGBgc3RydWN0IGVsZjY0X3NoZHJg YC4gU2VjdGlvbnMgYXJlIG9ubHkgdmlzaWJsZSBvbiBvYmplY3QgZmlsZXMgdGhhdAoraGF2ZSBh IExpbmtpbmcgdmlldywgc2luY2UgYWxsIExpbnV4IGtlcm5lbCBmaWxlcyBoYXZlIExpbmtpbmcg dmlldywgYWxsIGtlcm5lbAorb2JqZWN0cyBoYXZlIEVMRiBzZWN0aW9ucy4KKworTGltaXRhdGlv bnMgb24gRUxGIHNlY3Rpb25zCis9PT09PT09PT09PT09PT09PT09PT09PT09PT0KKworV2UgcHJv dmlkZSBhIHN1bW1hcnkgb24gdGhlIGxpbWl0YXRpb25zIG9mIEVMRiBzZWN0aW9ucy4gUmVmZXIg dG8gdGhlIHB1YmxpYworRUxGIHNwZWNpZmljYXRpb25zIGZvciBkZXRhaWxzLiBOb3RlIHRoYXQg NjQtYml0IGxpbWl0YXRpb25zIG1heSBkZXBlbmQKK29uIHByb2Nlc3NvciBzcGVjaWZpYyBzZWN0 aW9uIGF0dHJpYnV0ZXMgdG8gYmUgdXNlZCwgcmVmZXIgdG8geW91ciBwcm9jZXNzc29yCitzcGVj aWZpY2F0aW9uIGlmIHVuc3VyZS4KKworSXRzIHdvcnRoIGVsbGFib3JhdGluZyBvbiB0aGUgbGlt aXRhdGlvbnMgb24gdGhlIG5hbWUgb2YgYW4gRUxGIHNlY3Rpb246CitFTEYgc2VjdGlvbiBuYW1l cyBhcmUgc3RvcmVkIGFzIHN0cmluZ3MgYXMgcGVyIHRoZSBFTEYgc3BlY2lmaWNhdGlvbiwgYW5k CithcyBjYW4gYmUgZXhwZWN0ZWQsIHRoZXNlIGRvbid0IGhhdmUgZXhwbGljaXQgbGltaXRhdGlv bnMuIFRoZSBpbXBsaWNpdAorbGltaXRhdGlvbiB0aGVuIGRlcGVuZHMgb24gdGhlIHNpemUgb2Yg YW4gRUxGIG9iamVjdCBmaWxlIGFuZCBFTEYgc2VjdGlvbi4KKworSWYgdXNpbmcgcmVhbGx5IGxh cmdlIGtlcm5lbHMgb3Igb2JqZWN0cyB3aXRoIGxhcmdlIGFtb3VudHMgb2Ygc2VjdGlvbnMgb25l Cit3b3VsZCBzdGlsbCBuZWVkIHRvIGJlIHN1cmUgdGhhdCBFTEYgbG9hZGVyIGluIGNoYXJnZSBv ZiBsb2FkaW5nIHRoZSBMaW51eAora2VybmVsIGlzIHByb3Blcmx5IHVwZGF0ZWQgdG8gaGFuZGxl IGNvcGluZyB3aXRoIHRoZSBsYXRlc3QgRUxGIGV4dGVuc2lvbnMuCisKKyAgIC4uIGZsYXQtdGFi bGU6OiBMaW1pdGF0aW9ucyBvbiBFTEYgU2VjdGlvbnMKKworICAgICAgKiAtIFNlY3Rpb24gYXR0 cmlidXRlCisgICAgICAgIC0gMzItYml0CisgICAgICAgIC0gNjQtYml0CisKKyAgICAgICogLSBF TEYgc2VjdGlvbiBuYW1lCisgICAgICAgIC0gU2l6ZSBvZiBhbiBFTEYgc2VjdGlvbgorICAgICAg ICAtIFNpemUgb2YgYW4gRUxGIHNlY3Rpb24KKworICAgICAgKiAtIFNpemUgb2YgYW4gRUxGIHNl Y3Rpb24KKyAgICAgICAgLSA0IEdpQgorICAgICAgICAtIDE2IEVpQgorCisgICAgICAqIC0gTWF4 IG51bWJlciBvZiBzZWN0aW9ucyBpbiBhbiBvYmplY3QgZmlsZQorICAgICAgICAtIDQgR2lFbnRy aWVzICg0Mjk0OTY3Mjk2KQorICAgICAgICAtIDE2IEVpRW50cmllcyAoMTg0NDY3NDQwNzM3MDk1 NTE2MTYpCisKK1Byb2dyYW0gc3BlY2lmaWMgRUxGIHNlY3Rpb25zCis9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQorCitUaGUgRUxGIHNwZWNpZmljYXRpb24gYWxsb3dzIGZvciBhIHNlY3Rp b24gdHlwZSB0byBiZSBzcGVjaWZpZWQgYXMKKypQcm9ncmFtIHNwZWNpZmljIHNlY3Rpb24qLCBk ZWZpbmVkIGFzIGBgU0hUX1BST0dCSVRTYGAuIFRoaXMgc2VjdGlvbnMgdHlwZQorZW5hYmxlcyBw cm9ncmFtcyB0byBjdXN0b21pemUgc2VjdGlvbnMgZm9yIHRoZWlyIG93biB1c2UuIEluIGFzc2Vt Ymx5IHRoaXMKK3NwZWNpZmllZCBgYEBwcm9nYml0c2BgIG9uIG1vc3QgYXJjaGl0ZWN0dXJlcywg b24gQVJNIHRoaXMgaXMgYGAlcHJvZ2JpdHNgYC4KKworYGBTSFRfUFJPR0JJVFNgYCBpcyB1c2Vk IGJ5IExpbnV4IGZvciBkZWZpbmluZyBhbmQgdXNpbmcgTGludXggRUxGIHNlY3Rpb25zLgorCitT cGVjaWFsIEVMRiBTZWN0aW9ucworPT09PT09PT09PT09PT09PT09PT0KKworVGhlIEVMRiBzcGVj aWZpY2F0aW9uIGRlZmluZXMgKlNwZWNpYWwgRUxGIFNlY3Rpb25zKiBvbiBjaGFwdGVyIDQgKGBn YWJpNAorY2g0YF8pLiBUaGVzZSBhcmUgZGVmaW5lZCBhcyBzZWN0aW9ucyB3aGljaCBob2xkIHBy b2dyYW0gYW5kIGNvbnRyb2wKK2luZm9ybWF0aW9uLiBPZiB0aGVzZSBzZWN0aW9ucywgYSBmZXcg aGF2ZSB0aGUgc2VjdGlvbiB0eXBlIGFzCitgYFNIVF9QUk9HQklUU2BgLiBUaGlzIGVuYWJsZXMg TGludXggdG8gKmZ1cnRoZXIgY3VzdG9taXplKiB1c2Ugb2YgdGhlIHNlY3Rpb24KK2JleW9uZCB3 aGF0IHRoZSBFTEYgc3BlY2lmaWNhdGlvbiBzdWdnZXN0cy4KKworLi4gX2dhYmk0IGNoNDogaHR0 cHM6Ly9yZWZzcGVjcy5saW51eGJhc2Uub3JnL2VsZi9nYWJpNCsvY2g0LnNoZWFkZXIuaHRtbCNz cGVjaWFsX3NlY3Rpb25zCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2NvbmYu cHkgYi9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2NvbmYucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5mYWExYzU3NTk1ZTEKLS0tIC9kZXYvbnVsbAorKysgYi9Eb2N1 bWVudGF0aW9uL3NlY3Rpb25zL2NvbmYucHkKQEAgLTAsMCArMSw0IEBACisjIC0qLSBjb2Rpbmc6 IHV0Zi04OyBtb2RlOiBweXRob24gLSotCisKK3Byb2plY3QgPSAnTGludXggS2VybmVsIEVMRiBz ZWN0aW9ucycKK2h0bWxfc2VhcmNoX2xhbmd1YWdlID0gJ2VuJwpkaWZmIC0tZ2l0IGEvRG9jdW1l bnRhdGlvbi9zZWN0aW9ucy9pbmRleC5yc3QgYi9Eb2N1bWVudGF0aW9uL3NlY3Rpb25zL2luZGV4 LnJzdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmYzNzUxMWVmMDVl NwotLS0gL2Rldi9udWxsCisrKyBiL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvaW5kZXgucnN0CkBA IC0wLDAgKzEsMTcgQEAKKz09PT09PT09PT09PT09PT09PT09PT09PT0KK0xpbnV4IEtlcm5lbCBF TEYgc2VjdGlvbnMKKz09PT09PT09PT09PT09PT09PT09PT09PT0KKworVGhpcyBib29rIGRvY3Vt ZW50cyB0aGUgZGlmZmVyZW50IEVMRiBzZWN0aW9ucyB1c2VkIG9uIHRoZSBMaW51eCBrZXJuZWwu CitXZSBzdGFydCBvZmYgYnkgcHJvdmlkaW5nIHJlZmVyZW5jZXMgdG8gaG93IEVMRiB3YXMgc3Rh bmRhcmRpemVkLCByZWZlcmVuY2VzCit0byB0aGUgc3RhbmRhcmRzIG9uIEVMRiBzZWN0aW9ucywg cmV2aWV3IGxpbWl0YXRpb25zIG9mIEVMRiBzZWN0aW9ucywgYW5kCitmaW5hbGx5IGhvdyBMaW51 eCB1c2VzIEVMRiBzZWN0aW9ucyBpbiB0aGUgTGludXgga2VybmVsLiBDZXJ0YWluIGltcG9ydGFu dAorTGludXggRUxGIHNlY3Rpb25zIGFyZSBkb2N1bWVudGVkIGNhcmVmdWxseTogd2UgZGVzY3Jp YmUgdGhlIGdvYWwgb2YgdGhlCitFTEYgc2VjdGlvbiwgYW5kIGFkZHJlc3MgY29uY3VycmVuY3kg Y29uc2lkZXJhdGlvbnMgd2hlbiBhcHBsaWNhYmxlLiBBIGZldworY29tbW9uIGEgc2V0IG9mIExp bnV4IGhlbHBlcnMgZm9yIEVMRiBzZWN0aW9ucyBhcmUgYWxzbyBkb2N1bWVudGVkLgorCisuLiB0 b2N0cmVlOjoKKyAgIDptYXhkZXB0aDogNAorCisgICBiYWNrZ3JvdW5kCisgICBzZWN0aW9uLWNv cmUKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc2VjdGlvbnMvc2VjdGlvbi1jb3JlLnJzdCBi L0RvY3VtZW50YXRpb24vc2VjdGlvbnMvc2VjdGlvbi1jb3JlLnJzdApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmFjNTgxNWEwZDliMwotLS0gL2Rldi9udWxsCisrKyBi L0RvY3VtZW50YXRpb24vc2VjdGlvbnMvc2VjdGlvbi1jb3JlLnJzdApAQCAtMCwwICsxLDE0OCBA QAorPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KK0xpbnV4IEVMRiBwcm9ncmFt IHNwZWNpZmljIHNlY3Rpb25zCis9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQor CisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAorICAg OmRvYzogTGludXggRUxGIHByb2dyYW0gc3BlY2lmaWMgc2VjdGlvbnMKKworTGludXggbGlua2Vy IHNjcmlwdAorPT09PT09PT09PT09PT09PT09PQorCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9h c20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAorICAgOmRvYzogTGludXggbGlua2VyIHNjcmlwdAor CitNZW1vcnkgcHJvdGVjdGlvbgorLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBp bmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCisgICA6ZG9jOiBNZW1vcnkgcHJvdGVj dGlvbgorCittYXJrX3JvZGF0YV9ybworLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5l bC1kb2M6OiBpbmNsdWRlL2xpbnV4L2luaXQuaAorICAgOmZ1bmN0aW9uczogbWFya19yb2RhdGFf cm8KKworLnJvZGF0YQorLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVy aWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IC5yb2RhdGEKKworLnRleHQKKy0tLS0tCisuLiBr ZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAorICAgOmRvYzog LnRleHQKKworLmRhdGEKKy0tLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNt LWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IC5kYXRhCisKK0xpbnV4IC5pbml0XCog c2VjdGlvbnMKKz09PT09PT09PT09PT09PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGluY2x1 ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IExpbnV4IGluaXQgc2VjdGlv bnMKKworLmluaXQudGV4dAorLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNt LWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IC5pbml0LnRleHQKKworLmluaXQuZGF0 YQorLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlv bi1jb3JlLmgKKyAgIDpkb2M6IC5pbml0LmRhdGEKKworLmluaXQucm9kYXRhCistLS0tLS0tLS0t LS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCisg ICA6ZG9jOiAuaW5pdC5yb2RhdGEKKworSW5pdGNhbGwgbGV2ZWxzCistLS0tLS0tLS0tLS0tLS0K Ky4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L2luaXQuaAorICAgOmRvYzogSW5pdGNhbGwg bGV2ZWxzCisKKy5pbml0Y2FsbAorLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBp bmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCisgICA6ZG9jOiAuaW5pdGNhbGwKKwor X19kZWZpbmVfaW5pdGNhbGwKKy0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5j bHVkZS9saW51eC9pbml0LmgKKyAgIDpmdW5jdGlvbnM6IF9fZGVmaW5lX2luaXRjYWxsCisKK0xp bnV4IC5leGl0XCogc2VjdGlvbnMKKz09PT09PT09PT09PT09PT09PT09PT0KKworLi4ga2VybmVs LWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IExpbnV4 IGV4aXQgc2VjdGlvbnMKKworLmV4aXQudGV4dAorLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6 IGluY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IC5leGl0LnRleHQK KworLmV4aXQuZGF0YQorLS0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdl bmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IC5leGl0LmRhdGEKKworLmV4aXRjYWxsLmV4 aXQKKy0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9hc20tZ2VuZXJpYy9z ZWN0aW9uLWNvcmUuaAorICAgOmRvYzogLmV4aXRjYWxsLmV4aXQKKworTGludXggLnJlZlwqIHNl Y3Rpb25zCis9PT09PT09PT09PT09PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUv YXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IExpbnV4IHJlZmVyZW5jZXMgdG8g aW5pdCBzZWN0aW9ucworCisucmVmLnRleHQKKy0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGlu Y2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IC5yZWYudGV4dAorCisu cmVmLmRhdGEKKy0tLS0tLS0tLQorLi4ga2VybmVsLWRvYzo6IGluY2x1ZGUvYXNtLWdlbmVyaWMv c2VjdGlvbi1jb3JlLmgKKyAgIDpkb2M6IC5yZWYuZGF0YQorCisucmVmLnJvZGF0YQorLS0tLS0t LS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5o CisgICA6ZG9jOiAucmVmLnJvZGF0YQorCitHZW5lcmljIExpbnV4IGtlcm5lbCBzZWN0aW9uIGhl bHBlcnMKKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQorCitJbnRyb2R1Y3Rp b24KKy0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3NlY3Rpb25z LmgKKyAgIDpkb2M6IEludHJvZHVjdGlvbgorCitMSU5VWF9TRUNUSU9OX0FMSUdOTUVOVAorLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRlL2xpbnV4L3NlY3Rp b25zLmgKKyAgIDpmdW5jdGlvbnM6IExJTlVYX1NFQ1RJT05fQUxJR05NRU5UCisKK0xJTlVYX1NF Q1RJT05fU1RBUlQKKy0tLS0tLS0tLS0tLS0tLS0tLS0KKy4uIGtlcm5lbC1kb2M6OiBpbmNsdWRl L2xpbnV4L3NlY3Rpb25zLmgKKyAgIDpmdW5jdGlvbnM6IExJTlVYX1NFQ1RJT05fU1RBUlQKKwor TElOVVhfU0VDVElPTl9FTkQKKy0tLS0tLS0tLS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5j bHVkZS9saW51eC9zZWN0aW9ucy5oCisgICA6ZnVuY3Rpb25zOiBMSU5VWF9TRUNUSU9OX0VORAor CitERUNMQVJFX0xJTlVYX1NFQ1RJT04KKy0tLS0tLS0tLS0tLS0tLS0tLS0tLQorLi4ga2VybmVs LWRvYzo6IGluY2x1ZGUvbGludXgvc2VjdGlvbnMuaAorICAgOmZ1bmN0aW9uczogREVDTEFSRV9M SU5VWF9TRUNUSU9OCisKK0RFQ0xBUkVfTElOVVhfU0VDVElPTl9STworLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCisuLiBrZXJuZWwtZG9jOjogaW5jbHVkZS9saW51eC9zZWN0aW9ucy5oCisgICA6 ZnVuY3Rpb25zOiBERUNMQVJFX0xJTlVYX1NFQ1RJT05fUk8KZGlmZiAtLWdpdCBhL01BSU5UQUlO RVJTIGIvTUFJTlRBSU5FUlMKaW5kZXggYzY4YTZiYjE3OTY2Li5hZTg2MTM2ZjRiOWEgMTAwNjQ0 Ci0tLSBhL01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC01NDI0LDYgKzU0MjQsMTgg QEAgUzoJU3VwcG9ydGVkCiBGOglkcml2ZXJzL2Jhc2UvcG93ZXIvZG9tYWluKi5jCiBGOglpbmNs dWRlL2xpbnV4L3BtX2RvbWFpbi5oCiAKK0dFTkVSSUMgU0VDVElPTlMKK006CSJMdWlzIFIuIFJv ZHJpZ3VleiIgPG1jZ3JvZkBrZXJuZWwub3JnPgorTToJSm9zaCBQb2ltYm9ldWYgPGpwb2ltYm9l QHJlZGhhdC5jb20+CitNOgkiSC4gUGV0ZXIgQW52aW4iIDxocGFAenl0b3IuY29tPgorTDoJbGlu dXgtYXJjaEB2Z2VyLmtlcm5lbC5vcmcKK0w6CWxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcK K1M6CVN1cHBvcnRlZAorRjoJaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9uLWNvcmUuaAorRjoJ aW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0aW9ucy5oCitGOglpbmNsdWRlL2FzbS1nZW5lcmljL3Zt bGludXgubGRzLmgKK0Y6CURvY3VtZW50YXRpb24vc2VjdGlvbnMvc2VjdGlvbi1jb3JlLnJzdAor CiBHRU5FUklDIFVJTyBEUklWRVIgRk9SIFBDSSBERVZJQ0VTCiBNOgkiTWljaGFlbCBTLiBUc2ly a2luIiA8bXN0QHJlZGhhdC5jb20+CiBMOglrdm1Admdlci5rZXJuZWwub3JnCmRpZmYgLS1naXQg YS9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20v S2J1aWxkCmluZGV4IGJmODQ3NWNlODVlZS4uNTQyMjgyN2YxNTg1IDEwMDY0NAotLS0gYS9hcmNo L2FscGhhL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2FscGhhL2luY2x1ZGUvYXNtL0ti dWlsZApAQCAtMTAsMyArMTAsNCBAQCBnZW5lcmljLXkgKz0gbW0tYXJjaC1ob29rcy5oCiBnZW5l cmljLXkgKz0gcHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbnMuaAogZ2VuZXJpYy15ICs9 IHRyYWNlX2Nsb2NrLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEv YXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1aWxk CmluZGV4IGMzMzI2MDQ2MDZkZC4uN2IyY2IzZGVhNWZjIDEwMDY0NAotLS0gYS9hcmNoL2FyYy9p bmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9hcmMvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC01 MSwzICs1MSw0IEBAIGdlbmVyaWMteSArPSB1c2VyLmgKIGdlbmVyaWMteSArPSB2Z2EuaAogZ2Vu ZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15 ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9LYnVp bGQgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZWZiMjE3NTdkNDFmLi45YjY5 YTIyYTlhZTEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9h cmNoL2FybS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTQxLDMgKzQxLDQgQEAgZ2VuZXJpYy15ICs9 IHVuYWxpZ25lZC5oCiAKIGdlbmVyYXRlZC15ICs9IG1hY2gtdHlwZXMuaAogZ2VuZXJhdGVkLXkg Kz0gdW5pc3RkLW5yLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEv YXJjaC9hcm02NC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL0ti dWlsZAppbmRleCA4MzY1YTg0YzI2NDAuLjAwYWNlNWU4MjZmMSAxMDA2NDQKLS0tIGEvYXJjaC9h cm02NC9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9LYnVp bGQKQEAgLTQ1LDMgKzQ1LDQgQEAgZ2VuZXJpYy15ICs9IHVuYWxpZ25lZC5oCiBnZW5lcmljLXkg Kz0gdXNlci5oCiBnZW5lcmljLXkgKz0gdmdhLmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJp Yy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2F2cjMyL2luY2x1ZGUvYXNt L0tidWlsZCBiL2FyY2gvYXZyMzIvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDI0MWI5Yjk3Mjlk OC4uZjJjM2I2NTZhMGU3IDEwMDY0NAotLS0gYS9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL0tidWls ZAorKysgYi9hcmNoL2F2cjMyL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMjIsMyArMjIsNCBAQCBn ZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5lcmljLXkg Kz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkgKz0gc2Vj dGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxk IGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMmZiNjdiNTlkMTg4Li5i ZjIwNTQxYmNmMjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxk CisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vS2J1aWxkCkBAIC00NywzICs0Nyw0IEBA IGdlbmVyaWMteSArPSB1bmFsaWduZWQuaAogZ2VuZXJpYy15ICs9IHVzZXIuaAogZ2VuZXJpYy15 ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNl Y3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2M2eC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9h cmNoL2M2eC9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggNjQ0NjVlN2UyMjQ1Li4zODEyN2NlNzQ3 YmUgMTAwNjQ0Ci0tLSBhL2FyY2gvYzZ4L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2M2 eC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTYyLDMgKzYyLDQgQEAgZ2VuZXJpYy15ICs9IHVzZXIu aAogZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2Vu ZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBh L2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2NyaXMvaW5jbHVkZS9hc20vS2J1 aWxkCmluZGV4IDE3Nzg4MDVmNjM4MC4uMzg1Y2Q4OGE5ZDllIDEwMDY0NAotLS0gYS9hcmNoL2Ny aXMvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQK QEAgLTQ1LDMgKzQ1LDQgQEAgZ2VuZXJpYy15ICs9IHR5cGVzLmgKIGdlbmVyaWMteSArPSB2Z2Eu aAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2Vu ZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2Zydi9pbmNsdWRlL2Fz bS9LYnVpbGQgYi9hcmNoL2Zydi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMWZhMDg0Y2YxYTQz Li40NmQ3YzU5OWQ5YjggMTAwNjQ0Ci0tLSBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL0tidWlsZAor KysgYi9hcmNoL2Zydi9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTgsMyArOCw0IEBAIGdlbmVyaWMt eSArPSBtbS1hcmNoLWhvb2tzLmgKIGdlbmVyaWMteSArPSBwcmVlbXB0LmgKIGdlbmVyaWMteSAr PSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAorZ2VuZXJpYy15 ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0ti dWlsZCBiL2FyY2gvaDgzMDAvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDM3M2NiMjMzMDFlMy4u MWVjMDRlYzFjODJiIDEwMDY0NAotLS0gYS9hcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZAor KysgYi9hcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNzUsMyArNzUsNCBAQCBnZW5l cmljLXkgKz0gdW5hbGlnbmVkLmgKIGdlbmVyaWMteSArPSB2Z2EuaAogZ2VuZXJpYy15ICs9IHdv cmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24t Y29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL2hleGFnb24vaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJj aC9oZXhhZ29uL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBkYjhkZGFiYzZiZDIuLjM3ZDdiZmFl NzYxOSAxMDA2NDQKLS0tIGEvYXJjaC9oZXhhZ29uL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9h cmNoL2hleGFnb24vaW5jbHVkZS9hc20vS2J1aWxkCkBAIC02MCwzICs2MCw0IEBAIGdlbmVyaWMt eSArPSB1bmFsaWduZWQuaAogZ2VuZXJpYy15ICs9IHZnYS5oCiBnZW5lcmljLXkgKz0gd29yZC1h dC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3Jl LmgKZGlmZiAtLWdpdCBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2lhNjQv aW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDUwMmE5MWQ4ZGJiZC4uNjcyYzZkNWRhMThjIDEwMDY0 NAotLS0gYS9hcmNoL2lhNjQvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvaWE2NC9pbmNs dWRlL2FzbS9LYnVpbGQKQEAgLTksMyArOSw0IEBAIGdlbmVyaWMteSArPSBwcmVlbXB0LmgKIGdl bmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gdnRpbWUuaAogZ2VuZXJpYy15 ICs9IHdvcmQtYXQtYS10aW1lLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaApkaWZmIC0t Z2l0IGEvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbTMyci9pbmNsdWRlL2Fz bS9LYnVpbGQKaW5kZXggODYwZTQ0MDYxMWM5Li42MTExZTE1MjM3NTAgMTAwNjQ0Ci0tLSBhL2Fy Y2gvbTMyci9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9tMzJyL2luY2x1ZGUvYXNtL0ti dWlsZApAQCAtMTEsMyArMTEsNCBAQCBnZW5lcmljLXkgKz0gcHJlZW1wdC5oCiBnZW5lcmljLXkg Kz0gc2VjdGlvbnMuaAogZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMteSArPSB3 b3JkLWF0LWEtdGltZS5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBh L2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL202OGsvaW5jbHVkZS9hc20vS2J1 aWxkCmluZGV4IDFmMmU1ZDMxY2IyNC4uMTI3N2I0NWJmNGY5IDEwMDY0NAotLS0gYS9hcmNoL202 OGsvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQK QEAgLTM0LDMgKzM0LDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMteSAr PSB0eXBlcy5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhv ci5oCitnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvbWV0YWcv aW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9tZXRhZy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXgg MTY3MTUwYzcwMWQxLi5iMTAxMTM3NWNkN2EgMTAwNjQ0Ci0tLSBhL2FyY2gvbWV0YWcvaW5jbHVk ZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC01NSwz ICs1NSw0IEBAIGdlbmVyaWMteSArPSB1c2VyLmgKIGdlbmVyaWMteSArPSB2Z2EuaAogZ2VuZXJp Yy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9 IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20v S2J1aWxkIGIvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBiMGFlODhj OWZlZDkuLmM2YzJjZjZlZGM5OCAxMDA2NDQKLS0tIGEvYXJjaC9taWNyb2JsYXplL2luY2x1ZGUv YXNtL0tidWlsZAorKysgYi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0x MSwzICsxMSw0IEBAIGdlbmVyaWMteSArPSBwcmVlbXB0LmgKIGdlbmVyaWMteSArPSBzeXNjYWxs cy5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10 aW1lLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEvYXJjaC9taXBz L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXgg ZWQwNzE3OWZlMjZhLi43YTkzMmI0YTU1MzEgMTAwNjQ0Ci0tLSBhL2FyY2gvbWlwcy9pbmNsdWRl L2FzbS9LYnVpbGQKKysrIGIvYXJjaC9taXBzL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMjEsMyAr MjEsNCBAQCBnZW5lcmljLXkgKz0gdW5hbGlnbmVkLmgKIGdlbmVyaWMteSArPSB1c2VyLmgKIGdl bmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKK2dlbmVyaWMt eSArPSBzZWN0aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEvYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNt L0tidWlsZCBiL2FyY2gvbW4xMDMwMC9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMWM4ZGQwZjVj ZDVkLi5mODE0NWJjODU4MzUgMTAwNjQ0Ci0tLSBhL2FyY2gvbW4xMDMwMC9pbmNsdWRlL2FzbS9L YnVpbGQKKysrIGIvYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTAsMyArMTAs NCBAQCBnZW5lcmljLXkgKz0gcHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbnMuaAogZ2Vu ZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCitn ZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gvbmlvczIvaW5jbHVk ZS9hc20vS2J1aWxkIGIvYXJjaC9uaW9zMi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZDYzMzMw ZTg4Mzc5Li5jOWM3Y2I4MmIwMGYgMTAwNjQ0Ci0tLSBhL2FyY2gvbmlvczIvaW5jbHVkZS9hc20v S2J1aWxkCisrKyBiL2FyY2gvbmlvczIvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC02MywzICs2Myw0 IEBAIGdlbmVyaWMteSArPSB1c2VyLmgKIGdlbmVyaWMteSArPSB2Z2EuaAogZ2VuZXJpYy15ICs9 IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rp b24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNtL0tidWlsZCBi L2FyY2gvb3BlbnJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDI4MzJmMDMxZmIxMS4uODYx NzVlNzAxODY5IDEwMDY0NAotLS0gYS9hcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNtL0tidWlsZAor KysgYi9hcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNzEsMyArNzEsNCBAQCBn ZW5lcmljLXkgKz0gdXNlci5oCiBnZW5lcmljLXkgKz0gdmdhLmgKIGdlbmVyaWMteSArPSB3b3Jk LWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNv cmUuaApkaWZmIC0tZ2l0IGEvYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9w YXJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDkxZjUzYzA3ZjQxMC4uMThhOWQ0YzVlYWQ3 IDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9w YXJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0yOCwzICsyOCw0IEBAIGdlbmVyaWMteSArPSB1 c2VyLmgKIGdlbmVyaWMteSArPSB2Z2EuaAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgK IGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1n aXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9wb3dlcnBjL2luY2x1 ZGUvYXNtL0tidWlsZAppbmRleCA1YzRmYmM4MGRjNmMuLjQzMjJkOTc0NmNkYiAxMDA2NDQKLS0t IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3Bvd2VycGMvaW5j bHVkZS9hc20vS2J1aWxkCkBAIC04LDMgKzgsNCBAQCBnZW5lcmljLXkgKz0gbWNzX3NwaW5sb2Nr LmgKIGdlbmVyaWMteSArPSBwcmVlbXB0LmgKIGdlbmVyaWMteSArPSByd3NlbS5oCiBnZW5lcmlj LXkgKz0gdnRpbWUuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9h cmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL0tidWls ZAppbmRleCA4YWVhMzJmZThiZDIuLjYzYTFjMjkyNGI5MSAxMDA2NDQKLS0tIGEvYXJjaC9zMzkw L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vS2J1aWxkCkBA IC04LDMgKzgsNCBAQCBnZW5lcmljLXkgKz0gbW0tYXJjaC1ob29rcy5oCiBnZW5lcmljLXkgKz0g cHJlZW1wdC5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHdvcmQt YXQtYS10aW1lLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEvYXJj aC9zY29yZS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3Njb3JlL2luY2x1ZGUvYXNtL0tidWls ZAppbmRleCBhMDUyMThmZjNmZTQuLmYwODlhMjY0Y2QzOCAxMDA2NDQKLS0tIGEvYXJjaC9zY29y ZS9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9zY29yZS9pbmNsdWRlL2FzbS9LYnVpbGQK QEAgLTE0LDMgKzE0LDQgQEAgZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdlbmVyaWMteSAr PSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlcmlhbC5oCiBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRp bWUuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL3NoL2lu Y2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvc2gvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDc1MWMz MzczYTkyYy4uN2IwMzU2ZGNhNTYyIDEwMDY0NAotLS0gYS9hcmNoL3NoL2luY2x1ZGUvYXNtL0ti dWlsZAorKysgYi9hcmNoL3NoL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMzksMyArMzksNCBAQCBn ZW5lcmljLXkgKz0gdGVybWlvcy5oCiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJp Yy15ICs9IHVjb250ZXh0LmgKIGdlbmVyaWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rp b24tY29yZS5oCmRpZmYgLS1naXQgYS9hcmNoL3NwYXJjL2luY2x1ZGUvYXNtL0tidWlsZCBiL2Fy Y2gvc3BhcmMvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDA1NjliZmFjNGFmYi4uNDM4Zjg2NTcz ZGM1IDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNo L3NwYXJjL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMjEsMyArMjEsNCBAQCBnZW5lcmljLXkgKz0g c2VyaWFsLmgKIGdlbmVyaWMteSArPSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gdHlwZXMu aAogZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKK2dlbmVyaWMteSArPSBzZWN0aW9uLWNv cmUuaApkaWZmIC0tZ2l0IGEvYXJjaC90aWxlL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvdGls ZS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggMmQxZjU2Mzg5NzRjLi5mYjZiODMxYzFmYmEgMTAw NjQ0Ci0tLSBhL2FyY2gvdGlsZS9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC90aWxlL2lu Y2x1ZGUvYXNtL0tidWlsZApAQCAtNDAsMyArNDAsNCBAQCBnZW5lcmljLXkgKz0gdGVybWlvcy5o CiBnZW5lcmljLXkgKz0gdHJhY2VfY2xvY2suaAogZ2VuZXJpYy15ICs9IHR5cGVzLmgKIGdlbmVy aWMteSArPSB4b3IuaAorZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCmRpZmYgLS1naXQgYS9h cmNoL3VtL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvdW0vaW5jbHVkZS9hc20vS2J1aWxkCmlu ZGV4IDA1MmY3ZjZkMDU1MS4uNTgwYmQ1ZmY4MjhmIDEwMDY0NAotLS0gYS9hcmNoL3VtL2luY2x1 ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3VtL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMjYsMyAr MjYsNCBAQCBnZW5lcmljLXkgKz0gdG9wb2xvZ3kuaAogZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2Nr LmgKIGdlbmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKK2dl bmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEvYXJjaC91bmljb3JlMzIvaW5j bHVkZS9hc20vc2VjdGlvbi1jb3JlLmggYi9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9zZWN0 aW9uLWNvcmUuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjBiOWM2 ODQyOWExYQotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvdW5pY29yZTMyL2luY2x1ZGUvYXNtL3Nl Y3Rpb24tY29yZS5oCkBAIC0wLDAgKzEsMTkgQEAKKyNpZm5kZWYgX19VTklDT1JFX1NFQ1RJT05f Q09SRV9BU01fSF9fCisjZGVmaW5lIF9fVU5JQ09SRV9TRUNUSU9OX0NPUkVfQVNNX0hfXworLyoK KyAqIENvcHlyaWdodCAoQykgMjAxNiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNncm9mQGtlcm5lbC5v cmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiBjb3B5bGVm dC1uZXh0ICh2ZXJzaW9uIDAuMy4xIG9yIGxhdGVyKSBhcyBwdWJsaXNoZWQKKyAqIGF0IGh0dHA6 Ly9jb3B5bGVmdC1uZXh0Lm9yZy8uCisgKi8KKworLyogVW5pY29yZTMyIGhhcyBrbm93biB0byBu b3Qgd29yayBwcm9wZXJseSB3aXRoIHRoZSB0eXBlIHNldCwgc28gaWdub3JlIGl0ICovCisKKyNk ZWZpbmUgX19zZXRfc2VjdGlvbl9jb3JlX3R5cGUoX19fc2VjdGlvbiwgX19fY29yZSwgX19fbmFt ZSwJCVwKKwkJCQlfX19sZXZlbCwgX19fZmxhZ3MsIF9fX3R5cGUpCQlcCisJLnNlY3Rpb24gX19f c2VjdGlvbi4uX19fY29yZS5fX19uYW1lLl9fX2xldmVsLCBfX19mbGFncworCisjaW5jbHVkZSA8 YXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmg+CisKKyNlbmRpZiAvKiBfX1VOSUNPUkVfU0VDVElP Tl9DT1JFX0FTTV9IX18gKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL0tidWls ZCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCAyYjg5MmUyMzEzYTkuLmFmOTc1 ZjIxZWVlZSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2Fy Y2gveDg2L2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMTIsMyArMTIsNCBAQCBnZW5lcmljLXkgKz0g ZG1hLWNvbnRpZ3VvdXMuaAogZ2VuZXJpYy15ICs9IGVhcmx5X2lvcmVtYXAuaAogZ2VuZXJpYy15 ICs9IG1jc19zcGlubG9jay5oCiBnZW5lcmljLXkgKz0gbW0tYXJjaC1ob29rcy5oCitnZW5lcmlj LXkgKz0gc2VjdGlvbi1jb3JlLmgKZGlmZiAtLWdpdCBhL2FyY2gveHRlbnNhL2luY2x1ZGUvYXNt L0tidWlsZCBiL2FyY2gveHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBiN2ZiYWE1NmI1 MWEuLjc4NzljMzFlNjZhNyAxMDA2NDQKLS0tIGEvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vS2J1 aWxkCisrKyBiL2FyY2gveHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtMzIsMyArMzIsNCBA QCBnZW5lcmljLXkgKz0gdG9wb2xvZ3kuaAogZ2VuZXJpYy15ICs9IHRyYWNlX2Nsb2NrLmgKIGdl bmVyaWMteSArPSB3b3JkLWF0LWEtdGltZS5oCiBnZW5lcmljLXkgKz0geG9yLmgKK2dlbmVyaWMt eSArPSBzZWN0aW9uLWNvcmUuaApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hc20tZ2VuZXJpYy9zZWN0 aW9uLWNvcmUuaCBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbi1jb3JlLmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5iYjE2YmVmYzQyNTEKLS0tIC9kZXYvbnVs bAorKysgYi9pbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb24tY29yZS5oCkBAIC0wLDAgKzEsMzA3 IEBACisjaWZuZGVmIF9BU01fR0VORVJJQ19TRUNUSU9OX0NPUkVfSF8KKyNkZWZpbmUgX0FTTV9H RU5FUklDX1NFQ1RJT05fQ09SRV9IXworLyoKKyAqIExpbnV4IHNlY3Rpb24gY29yZSBkZWZpbml0 aW9ucworICoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNncm9m QGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBv ZiBjb3B5bGVmdC1uZXh0ICh2ZXJzaW9uIDAuMy4xIG9yIGxhdGVyKSBhcyBwdWJsaXNoZWQKKyAq IGF0IGh0dHA6Ly9jb3B5bGVmdC1uZXh0Lm9yZy8uCisgKi8KKworLyoqCisgKiBET0M6IExpbnV4 IEVMRiBwcm9ncmFtIHNwZWNpZmljIHNlY3Rpb25zCisgKgorICogTGludXggbWFrZXMgZXh0ZW5z aXZlIHVzZSBvZiBgYFNIVF9QUk9HQklUU2BgIHRvIGJvdGggZXh0ZW5kIHVzZSBhbmQKKyAqIGRl ZmluaXRpb24gb2YgKlNwZWNpYWwgRUxGIFNlY3Rpb25zKiAoYGdhYmk0IGNoNGBfKSBhbmQgdG8g ZGVmaW5lIGl0cyBvd24KKyAqIHNlY3Rpb25zLiBUaGlzIGNoYXBlciBpcyBkZWRpY2F0ZWQgdG8g ZG9jdW1lbnRpbmcgTGludXggcHJvZ3JhbSBzcGVjaWZpYworICogc2VjdGlvbnMgYW5kIGhlbHBl cnMgYXZhaWxhYmxlIHRvIG1ha2UgdXNlIG9mIHRoZXNlIGVhc2llciB0byBpbXBsZW1lbnQgYW5k CisgKiB1c2UuCisgKgorICogLi4gX2dhYmk0IGNoNDogaHR0cHM6Ly9yZWZzcGVjcy5saW51eGJh c2Uub3JnL2VsZi9nYWJpNCsvY2g0LnNoZWFkZXIuaHRtbCNzcGVjaWFsX3NlY3Rpb25zCisgKi8K KworLyoqCisgKiBET0M6IExpbnV4IGxpbmtlciBzY3JpcHQKKyAqCisgKiBMaW51eCB1c2VzIGEg Y3VzdG9tIGxpbmtlciBzY3JpcHQgdG8gYnVpbGQgdGhlIHZtbGludXggYmluYXJ5LCBpdCB1c2Vz IGl0IHRvCisgKiBzdHJhdGVnaWNhbGx5IHBsYWNlIGFuZCBkZWZpbmUgTGludXggRUxGIHNlY3Rp b25zLiAgRWFjaCBhcmNoaXRlY3R1cmUgbmVlZHMKKyAqIHRvIGltcGxlbWVudCBpdHMgb3duIGxp bmtlciBzY3JpcHQsIGl0IGlzIGV4cGVjdGVkIHRvIHJlc2lkZSBpbgorICogYGBhcmNoLyQoQVJD SCkva2VybmVsL3ZtbGludXgubGRzLlNgYC4gIEFyY2hpdGVjdHVyZSBMaW51eCBsaW5rZXIgc2Ny aXB0cyBpbgorICogdHVybiBpbmNsdWRlIGFuZCB1c2UgZGVmaW5pdGlvbnMgZnJvbSBgYGluY2x1 ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaGBgLAorICogYXMgd2VsbCBhcyBzb21lIGhlbHBl cnMgZG9jdW1lbnRlZCBpbiB0aGlzIGNoYXB0ZXIuCisgKgorICogSW4gYXNzZW1ibHkgaXQgaXMg Y29tbW9uIHByYWN0aWNlIHRvIHVzZSBkb3RzIChgYC5gYCkgaW4gbGFiZWxzIHRvIGF2b2lkCisg KiBjbGFzaGVzIHdpdGggQyBzeW1ib2xzLiBTaW1pbGFybHksIGEgZG90IChgYC5gYCkgY2FuIGJl IHBhcnQgb2YgYSBzZWN0aW9uCisgKiBuYW1lIGJ1dCBub3QgYSBDIHN5bWJvbC4gSGlzdG9yaWNh bGx5IHRoZW4sIHR3byBkb3RzIGFyZSB1c2VkIChgYC4uYGApCisgKiBoYXZlIGJlZW4gdXNlZCBp biBsaW5rZXIgc2NyaXB0cyB3aGVuIGFkZGluZyBwcm9ncmFtIHNwZWNpZmljIHNlY3Rpb25zCisg KiB3aGVuIHRoZXJlIGFyZSBjb25jZXJucyB0byBhdm9pZCBjbGFzaGVzIHdpdGggY29tcGlsZXIg Z2VuZXJhdGVkIHNlY3Rpb25zLgorICovCisKKy8qKgorICogRE9DOiBNZW1vcnkgcHJvdGVjdGlv bgorICoKKyAqIExpbnV4IGFsbG93cyBhcmNoaXRlY3R1cmVzIHdoaWNoIHN1cHBvcnQgbWVtb3J5 IHByb3RlY3Rpb24gZmVhdHVyZXMgdG8KKyAqIHRha2UgYWR2YW50YWdlIG9mIHRoZW0gYnkgbGV0 dGluZyBhcmNoaXRlY3R1cmVzIGRlZmluZSBhbmQgZW5hYmxlCisgKiBgYENPTkZJR19ERUJVR19S T0RBVEFgYCBhbmQgaW1wbGVtZW50IGEgbWFya19yb2RhdGFfcm8oKSBjYWxsLgorICogbWFya19y b2RhdGFfcm8oKSBjYW4gYmUgdXNlZCBmb3IgaW5zdGFuY2UgdG8gbWFyayBzcGVjaWZpYyBzZWN0 aW9ucyBhcworICogcmVhZC1vbmx5IG9yIG5vbi1leGVjdXRhYmxlLgorICoKKyAqIExpbnV4IHR5 cGljYWxseSBmb2xsb3dzIGEgY29udmVudGlvbiB0byBoYXZlIHRoZSAucm9kYXRhIEVMRiBzZWN0 aW9uIGZvbGxvdworICogYWZ0ZXIgdGhlIC50ZXh0IEVMRiBzZWN0aW9uLCBpdCBkb2VzIHRoaXMg dG8gaGVscCBhcmNoaXRlY3R1cmVzIHdoaWNoCisgKiBzdXBwb3J0IG1lbW9yeSBwcm90ZWN0aW9u IHRvIG1hcmsgYm90aCAudGV4dCBhbmQgLnJvZGF0YSBhcyByZWFkLW9ubHkgaW4KKyAqIG9uZSBz aG90LgorICoKKyAqIEZvciBtb3JlIGRldGFpbHMgcmVmZXIgdG8gbWFya19yb2RhdGFfcm8oKS4K KyAqLworCisvKioKKyAqIERPQzogLnJvZGF0YQorICoKKyAqIEVMRiBzZWN0aW9uIHVzZWQgZm9y IGRhdGEgd2hpY2ggbXVzdCBiZSBwcm90ZWN0ZWQgZnJvbSB3cml0ZSBhY2Nlc3MuCisgKi8KKwor LyoqCisgKiBET0M6IC50ZXh0CisgKgorICogRUxGIHNlY3Rpb24gbmFtZSB1c2VkIGZvciBjb2Rl IChmdW5jdGlvbnMpIHVzZWQgZHVyaW5nIHJlZ3VsYXIKKyAqIGtlcm5lbCBydW4gdGltZS4KKyAq LworCisvKioKKyAqIERPQzogLmRhdGEKKyAqCisgKiBFTEYgc2VjdGlvbiB1c2VkIGZvciByZWFk LXdyaXRlIGRhdGEuCisgKi8KKworLyoqCisgKiBET0M6IExpbnV4IGluaXQgc2VjdGlvbnMKKyAq CisgKiBUaGVzZSBzZWN0aW9ucyBhcmUgdXNlZCBmb3IgY29kZSBhbmQgZGF0YSBzdHJ1Y3R1cmVz IHVzZWQgZHVyaW5nIGJvb3Qgb3IKKyAqIG1vZHVsZSBpbml0aWFsaXphdGlvbi4gT24gYXJjaGl0 ZWN0dXJlcyB0aGF0IHN1cHBvcnQgaXQgKHg4NiwgeDg2XzY0KSwgYWxsCisgKiB0aGlzIGNvZGUg aXMgZnJlZWQgdXAgYnkgdGhlIGtlcm5lbCByaWdodCBiZWZvcmUgdGhlIGZpc3QgdXNlcnNwYWNl IGluaXQKKyAqIHByb2Nlc3MgaXMgY2FsbGVkIHdoZW4gYnVpbHQtaW4gdG8gdGhlIGtlcm5lbCwg YW5kIGlmIG1vZHVsYXIgaXQgaXMgZnJlZWQKKyAqIGFmdGVyIG1vZHVsZSBpbml0aWFsaXphdGlv bi4gU2luY2UgdGhlIGNvZGUgaXMgZnJlZWQgc28gZWFybHksIGluIHRoZW9yeQorICogdGhlcmUg c2hvdWxkIGJlIG5vIHJhY2VzIGFnYWluc3QgZnJlZWluZyB0aGlzIGNvZGUgd2l0aCBvdGhlciBD UFVzLiBJbml0CisgKiBzZWN0aW9uIGNvZGUgYW5kIGRhdGEgc3RydWN0dXJlcyBzaG91bGQgbmV2 ZXIgYmUgZXhwb3J0ZWQgd2l0aAorICogRVhQT1JUX1NZTUJPTCooKSBhcyB0aGUgY29kZSB3aWxs IHF1aWNrbHkgYmVjb21lIHVuYXZhaWxhYmxlIHRvIHRoZSBrZXJuZWwKKyAqIGFmdGVyIGJvb3R1 cC4KKyAqLworCisvKioKKyAqIERPQzogLmluaXQudGV4dAorICoKKyAqIEVMRiBzZWN0aW9uIGZv ciBjb2RlIChmdW5jdGlvbnMpIHVzZWQgb25seSBkdXJpbmcgYm9vdCBvciBkcml2ZXIKKyAqIGlu aXRpYWxpemF0aW9uLgorICoKKyAqLworCisvKioKKyAqIERPQzogLmluaXQuZGF0YQorICoKKyAq IEVMRiBzZWN0aW9uIHVzZWQgZm9yIGRhdGEgc3RydWN0dXJlcyB1c2VkIG9ubHkgZHVyaW5nIGJv b3Qgb3IgZHJpdmVyCisgKiBpbml0aWFsaXphdGlvbi4KKyAqLworCisvKioKKyAqIERPQzogLmlu aXQucm9kYXRhCisgKgorICogRUxGIHNlY3Rpb24gdXNlZCBmb3IgcmVhZC1vbmx5IGNvZGUgKGZ1 bmN0aW9ucykgdXNlZCBvbmx5IGR1cmluZyBib290CisgKiBvciBkcml2ZXIgaW5pdGlhbGl6YXRp b24uCisgKi8KKworLyoqCisgKiBET0M6IC5pbml0Y2FsbAorICoKKyAqIEVMRiBzZWN0aW9uIHVz ZWQgZm9yIHN1YnN5c3RlbSBpbml0IGNhbGxzLiBUaGVyZSBhcmUgaW5pdCBsZXZlbHMKKyAqIHJl cHJlc2VudGluZyBkaWZmZXJlbnQgZnVuY3Rpb25hbGl0eSBpbiB0aGUga2VybmVsLiBGb3IgbW9y ZSBkZXRhaWxzCisgKiByZWZlciB0byBfX2RlZmluZV9pbml0Y2FsbCgpLgorICovCisKKy8qKgor ICogRE9DOiBMaW51eCBleGl0IHNlY3Rpb25zCisgKgorICogVGhlc2Ugc2VjdGlvbnMgYXJlIHVz ZWQgdG8gZGVjbGFyZSBhIGZ1bmN0aW9ucyBhbmQgZGF0YSBzdHJ1Y3R1cmVzIHdoaWNoCisgKiBh cmUgb25seSByZXF1aXJlZCBvbiBleGl0LCB0aGUgZnVuY3Rpb24gb3IgZGF0YSBzdHJ1Y3R1cmUg d2lsbCBiZSBkcm9wcGVkCisgKiBpZiB0aGUgY29kZSBkZWNsYXJpbmcgdGhpcyBzZWN0aW9uIGlz IG5vdCBjb21waWxlZCBhcyBhIG1vZHVsZSBvbgorICogYXJjaGl0ZWN0dXJlcyB0aGF0IHN1cHBv cnQgdGhpcyAoeDg2LCB4ODZfNjQpLiBUaGVyZSBpcyBubyBzcGVjaWFsIGNhc2UKKyAqIGhhbmRs aW5nIGZvciB0aGlzIGNvZGUgd2hlbiBidWlsdC1pbiB0byB0aGUga2VybmVsLgorICovCisKKy8q KgorICogRE9DOiAuZXhpdC50ZXh0CisgKgorICogRUxGIHNlY3Rpb24gdXNlZCB0byBmb3IgY29k ZSAoZnVuY3Rpb25zKSB1c2VkIG9ubHkgZHVyaW5nIG1vZHVsZSB1bmxvYWQuCisgKi8KKworLyoq CisgKiBET0M6IC5leGl0LmRhdGEKKyAqCisgKiBFTEYgc2VjdGlvbiB1c2VkIHRvIGZvciBkYXRh IHN0cnVjdHVyZXMgdXNlZCBvbmx5IGR1cmluZyBtb2R1bGUKKyAqIHVubG9hZC4KKyAqLworCisv KioKKyAqIERPQzogLmV4aXRjYWxsLmV4aXQKKyAqCisgKiBFTEYgc2VjdGlvbiB1c2VkIGZvciBl eGl0IHJvdXRpbmVzLCBvcmRlciBpcyBpbXBvcnRhbnQgYW5kIG1haW50YWluZWQgYnkKKyAqIGxp bmsgb3JkZXIuCisgKi8KKworLyoqCisgKiBET0M6IExpbnV4IHJlZmVyZW5jZXMgdG8gaW5pdCBz ZWN0aW9ucworICoKKyAqIFRoZXNlIHNlY3Rpb25zIGFyZSB1c2VkIHRvIHRlYWNoIG1vZHBvc3Qg dG8gbm90IHdhcm4gYWJvdXQgcG9zc2libGUKKyAqIG1pc3VzZXMgb2YgaW5pdCBzZWN0aW9uIGNv ZGUgZnJvbSBvdGhlciBzZWN0aW9ucy4gSWYgeW91IHVzZSB0aGlzCisgKiB5b3VyIHVzZSBjYXNl IHNob3VsZCBkb2N1bWVudCB3aHkgeW91IGFyZSBjZXJ0YWluIHN1Y2ggdXNlIG9mIGluaXQKKyAq IHNlY3Rpb25lZCBjb2RlIGlzIHZhbGlkLiBGb3IgbW9yZSBkZXRhaWxzIHJlZmVyIHRvIGBgaW5j bHVkZS9saW51eC9pbml0LmhgYAorICogYGBfX3JlZmBgLCBgYF9fcmVmZGF0YWBgLCBhbmQgYGBf X3JlZmNvbnN0YGAgZG9jdW1lbnRhdGlvbi4KKyAqLworCisvKioKKyAqIERPQzogLnJlZi50ZXh0 CisgKgorICogRUxGIHNlY3Rpb24gdXNlZCB0byBhbm5vdGF0ZSBjb2RlIChmdW5jdGlvbnMpIHdo aWNoIGhhcyBiZWVuIHZldHRlZWQgYXMKKyAqIHZhbGlkIGZvciBpdHMgcmVmZXJlbmNlIG9yIHVz ZSBvZiBvdGhlciBjb2RlIChmdW5jdGlvbnMpIG9yIGRhdGEgc3RydWN0dXJlcworICogd2hpY2gg YXJlIHBhcnQgb2YgdGhlIGluaXQgc2VjdGlvbnMuCisgKi8KKworLyoqCisgKiBET0M6IC5yZWYu ZGF0YQorICoKKyAqIEVMRiBzZWN0aW9uIHVzZWQgZm9yIGRhdGEgc3RydWN0dXJlcyB3aGljaCBo YXZlIGJlZW4gdmV0dGVlZCBmb3IgaXRzCisgKiByZWZlcmVuY2Ugb3IgdXNlIG9mIG90aGVyIGNv ZGUgKGZ1bmN0aW9ucykgb3IgZGF0YSBzdHJ1Y3R1cmVzIHBhcnQgb2YgdGhlCisgKiBpbml0IHNl Y3Rpb25zLgorICovCisKKy8qKgorICogRE9DOiAucmVmLnJvZGF0YQorICoKKyAqIEVMRiBzZWN0 aW9uIHVzZWQgdG8gYW5ub3RhdGUgY29uc3QgY29kZSAoZnVuY3Rpb25zKSBjb25zdCBkYXRhIHN0 cnVjdHVyZXMKKyAqIHdoaWNoIGhhcyBiZWVuIHZldHRlZWQgZm9yIGl0cyByZWZlcmVuY2Ugb3Ig dXNlIG9mIG90aGVyIGNvZGUgKGZ1bmN0aW9ucykKKyAqIG9yIGRhdGEgc3RydWN0dXJlcyBwYXJ0 IG9mIHRoZSBpbml0IHNlY3Rpb25zLgorICovCisKKy8qIENhbiBiZSB1c2VkIG9uIGZvby5TIGZv ciBpbnN0YW5jZSAqLworI2lmbmRlZiBfX3NldF9zZWN0aW9uX2NvcmVfdHlwZQorIyBkZWZpbmUg X19zZXRfc2VjdGlvbl9jb3JlX3R5cGUoX19fc2VjdGlvbiwgX19fY29yZSwgX19fbmFtZSwJCVwK KwkJCQkgX19fbGV2ZWwsIF9fX2ZsYWdzLCBfX190eXBlKQkJXAorCS5zZWN0aW9uIF9fX3NlY3Rp b24uLl9fX2NvcmUuX19fbmFtZS5fX19sZXZlbCwgX19fZmxhZ3MsIF9fX3R5cGUKKyNlbmRpZgor CisjaWZuZGVmIF9fc2V0X3NlY3Rpb25fY29yZQorIyBkZWZpbmUgX19zZXRfc2VjdGlvbl9jb3Jl KF9fX3NlY3Rpb24sIF9fX2NvcmUsIF9fX25hbWUsIF9fX2xldmVsLCBfX19mbGFncykgXAorCS5z ZWN0aW9uIF9fX3NlY3Rpb24uLl9fX2NvcmUuX19fbmFtZS5fX19sZXZlbCwgX19fZmxhZ3MKKyNl bmRpZgorCisjaWZuZGVmIF9fcHVzaF9zZWN0aW9uX2NvcmUKKyMgZGVmaW5lIF9fcHVzaF9zZWN0 aW9uX2NvcmUoX19zZWN0aW9uLCBfX2NvcmUsIF9fbmFtZSwgX19sZXZlbCwgX19mbGFncykgXAor CS5wdXNoc2VjdGlvbiBfX3NlY3Rpb24uLl9fY29yZS5fX25hbWUuX19sZXZlbCwgX19mbGFncwor I2VuZGlmCisKKyNpZmRlZiBfX0tFUk5FTF9fCisjaW5jbHVkZSA8bGludXgvc3RyaW5naWZ5Lmg+ CisjZW5kaWYKKworI2lmIGRlZmluZWQoX19BU1NFTUJMRVJfXykgfHwgZGVmaW5lZChfX0FTU0VN QkxZX18pCisKKyMgaWZuZGVmIExJTktFUl9TQ1JJUFQKKworIyAgaWZuZGVmIHB1c2hfc2VjdGlv bl9jb3JlCisjICAgZGVmaW5lIHB1c2hfc2VjdGlvbl9jb3JlKF9fc2VjdGlvbiwgX19jb3JlLCBf X25hbWUsIF9fbGV2ZWwsIF9fZmxhZ3MpIFwKKwkgX19wdXNoX3NlY3Rpb25fY29yZShfX3NlY3Rp b24sIF9fY29yZSwgX19uYW1lLAkJCSAgXAorCQkJICAgICBfX2xldmVsLCBfX3N0cmluZ2lmeShf X2ZsYWdzKSkKKyMgIGVuZGlmCisKKyMgIGlmbmRlZiBzZXRfc2VjdGlvbl9jb3JlCisjICAgZGVm aW5lIHNldF9zZWN0aW9uX2NvcmUoX19zZWN0aW9uLCBfX2NvcmUsIF9fbmFtZSwJCQlcCisJCQkg ICAgX19sZXZlbCwgX19mbGFncykJCQkJXAorCV9fc2V0X3NlY3Rpb25fY29yZShfX3NlY3Rpb24s IF9fY29yZSwgX19uYW1lLAkJCVwKKwkJCSAgIF9fbGV2ZWwsIF9fc3RyaW5naWZ5KF9fZmxhZ3Mp KQorIyAgZW5kaWYKKworIyAgaWZuZGVmIHNldF9zZWN0aW9uX2NvcmVfdHlwZQorIyAgIGRlZmlu ZSBzZXRfc2VjdGlvbl9jb3JlX3R5cGUoX19zZWN0aW9uLCBfX2NvcmUsIF9fbmFtZSwJCVwKKwkJ CQkgX19sZXZlbCwgX19mbGFncywgX190eXBlKQkJXAorCV9fc2V0X3NlY3Rpb25fY29yZV90eXBl KF9fc2VjdGlvbiwgX19jb3JlLCBfX25hbWUsIF9fbGV2ZWwsCVwKKwkJCQlfX3N0cmluZ2lmeShf X2ZsYWdzKSwgX190eXBlKQorIyAgZW5kaWYKKworIyBlbmRpZiAvKiBMSU5LRVJfU0NSSVBUICov CisjZWxzZSAvKiBkZWZpbmVkKF9fQVNTRU1CTEVSX18pIHx8IGRlZmluZWQoX19BU1NFTUJMWV9f KSAqLworCisvKgorICogQXMgcGVyIGdjYydzIGRvY3VtZW50YXRpb24gYSBjb21tb24gYXNtIHNl cGFyYXRvciBpcyBhIG5ldyBsaW5lIGZvbGxvd2VkCisgKiBieSB0YWIgWzBdLCBpdCBob3dldmVy IHNlZW1zIHBvc3NpYmxlIHRvIGFsc28ganVzdCB1c2UgYSBuZXdsaW5lIGFzIGl0cworICogdGhl IG1vc3QgY29tbW9ubHkgZW1waXJpY2FsbHkgb2JzZXJ2ZWQgc2VtYW50aWMgYW5kIGZvbGtzIHNl ZW0gdG8gYWdyZWUKKyAqIHRoaXMgZXZlbiB3b3JrcyBvbiBTMzkwLiBJbiBjYXNlIHlvdXIgYXJj aGl0ZWN0dXJlIGRpc2FncmVlcyB5b3UgbWF5CisgKiBvdmVycmlkZSB0aGlzIGFuZCBkZWZpbmUg eW91ciBvd24gYW5kIGtlZXAgdGhlIHJlc3Qgb2YgdGhlIG1hY3Jvcy4KKyAqCisgKiBbMF0gaHR0 cHM6Ly9nY2MuZ251Lm9yZy9vbmxpbmVkb2NzL2djYy9CYXNpYy1Bc20uaHRtbCNCYXNpYy1Bc20K KyAqLworIyBpZm5kZWYgQVNNX0NNRF9TRVAKKyMgIGRlZmluZSBBU01fQ01EX1NFUAkiXG4iCisj IGVuZGlmCisKKyMgaWZuZGVmIHNldF9zZWN0aW9uX2NvcmUKKyMgIGRlZmluZSBzZXRfc2VjdGlv bl9jb3JlKF9fc2VjdGlvbiwgX19jb3JlLCBfX25hbWUsIF9fbGV2ZWwsIF9fZmxhZ3MpCVwKKwlf X3N0cmluZ2lmeShfX3NldF9zZWN0aW9uX2NvcmVfdHlwZShfX3NlY3Rpb24sIF9fY29yZSwgX19u YW1lLAlcCisJCQkJCSAgICBfX2xldmVsLCBfX3N0cmluZ2lmeShfX2ZsYWdzKSkpIFwKKwlBU01f Q01EX1NFUAorIyBlbmRpZgorCisvKgorICogU29tZSBhcmNoaXRlY3R1cmVzIChhcm0sIGFuZCBh dnIzMiBhcmUgdHdvIGV4YW1wbGVzIG9uIGtwcm9iZXMpIHNlZW0KKyAqIGN1cnJlbnRseSBleHBs aWNpdGx5IHNwZWNpZnkgdGhlIHR5cGUgWzBdIC0tIHRoaXMgY2FuIGJlIGFueSBvZiB0aGUKKyAq IG9wdGlvbmFsIGNvbnN0YW50cyBvbiBFTEY6CisgKgorICogQHByb2diaXRzIC0gc2VjdGlvbiBj b250YWlucyBkYXRhCisgKiBAbm9iaXRzIC0gc2VjdGlvbiBkb2VzIG5vdCBjb250YWluIGRhdGEg KGkuZS4sIHNlY3Rpb24gb25seSBvY2N1cGllcyBzcGFjZSkKKyAqIEBub3RlIC0gc2VjdGlvbiBj b250YWlucyBkYXRhIHdoaWNoIGlzIHVzZWQgYnkgdGhpbmdzIG90aGVyIHRoYW4gdGhlIHByb2dy YW0KKyAqIEBpbml0X2FycmF5IC0gc2VjdGlvbiBjb250YWlucyBhbiBhcnJheSBvZiBwb2ludGVy cyB0byBpbml0IGZ1bmN0aW9ucworICogQGZpbmlfYXJyYXkgLSBzZWN0aW9uIGNvbnRhaW5zIGFu IGFycmF5IG9mIHBvaW50ZXJzIHRvIGZpbmlzaCBmdW5jdGlvbnMKKyAqIEBwcmVpbml0X2FycmF5 IC0gc2VjdGlvbiBjb250YWlucyBhbiBhcnJheSBvZiBwb2ludGVycyB0byBwcmUtaW5pdCBmdW5j dGlvbnMKKyAqCisgKiBBUk0gcmVxdWlyZXMgJSBpbnN0ZWFkIG9mIEAuCisgKgorICogQXQgbGVh c3QgYXMgcGVyIG5hc20gKHg4Ni94ODZfNjQgb25seSksIGluIHRoZSBhYnNlbmNlIG9mIHF1YWxp ZmllcnMgdGhlCisgKiBkZWZhdWx0cyBhcmUgYXMgZm9sbG93czoKKyAqCisgKiBzZWN0aW9uIC50 ZXh0ICAgIHByb2diaXRzICBhbGxvYyAgIGV4ZWMgICAgbm93cml0ZSAgYWxpZ249MTYKKyAqIHNl Y3Rpb24gLnJvZGF0YSAgcHJvZ2JpdHMgIGFsbG9jICAgbm9leGVjICBub3dyaXRlICBhbGlnbj00 CisgKiBzZWN0aW9uIC5scm9kYXRhIHByb2diaXRzICBhbGxvYyAgIG5vZXhlYyAgbm93cml0ZSAg YWxpZ249NAorICogc2VjdGlvbiAuZGF0YSAgICBwcm9nYml0cyAgYWxsb2MgICBub2V4ZWMgIHdy aXRlICAgIGFsaWduPTQKKyAqIHNlY3Rpb24gLmxkYXRhICAgcHJvZ2JpdHMgIGFsbG9jICAgbm9l eGVjICB3cml0ZSAgICBhbGlnbj00CisgKiBzZWN0aW9uIC5ic3MgICAgIG5vYml0cyAgICBhbGxv YyAgIG5vZXhlYyAgd3JpdGUgICAgYWxpZ249NAorICogc2VjdGlvbiAubGJzcyAgICBub2JpdHMg ICAgYWxsb2MgICBub2V4ZWMgIHdyaXRlICAgIGFsaWduPTQKKyAqIHNlY3Rpb24gLnRkYXRhICAg cHJvZ2JpdHMgIGFsbG9jICAgbm9leGVjICB3cml0ZSAgICBhbGlnbj00ICAgIHRscworICogc2Vj dGlvbiAudGJzcyAgICBub2JpdHMgICAgYWxsb2MgICBub2V4ZWMgIHdyaXRlICAgIGFsaWduPTQg ICAgdGxzCisgKiBzZWN0aW9uIC5jb21tZW50IHByb2diaXRzICBub2FsbG9jIG5vZXhlYyAgbm93 cml0ZSAgYWxpZ249MQorICogc2VjdGlvbiBvdGhlciAgICBwcm9nYml0cyAgYWxsb2MgICBub2V4 ZWMgIG5vd3JpdGUgIGFsaWduPTEKKyAqCisgKiBnYXMgc2hvdWxkIGhhdmUgc2Vuc2libGUgZGVm YXVsdHMgZm9yIGFyY2hpdGVjdHVyZXMuLi4KKyAqCisgKiBbMF0gaHR0cDovL3d3dy5uYXNtLnVz L2RvYy9uYXNtZG9jNy5odG1sCisgKi8KKyMgaWZuZGVmIHNldF9zZWN0aW9uX2NvcmVfdHlwZQor IyAgZGVmaW5lIHNldF9zZWN0aW9uX2NvcmVfdHlwZShfX3NlY3Rpb24sIF9fY29yZSwgX19uYW1l LCBfX2xldmVsLAlcCisJCQkJX19mbGFncywgX190eXBlKQkJCVwKKwlfX3N0cmluZ2lmeShfX3Nl dF9zZWN0aW9uX2NvcmVfdHlwZShfX3NlY3Rpb24sIF9fY29yZSwJCVwKKwkJCQkJICAgIF9fbmFt ZSwgX19sZXZlbCwJCVwKKwkJCQkJICAgIF9fc3RyaW5naWZ5KF9fZmxhZ3MpLAlcCisJCQkJCSAg ICBfX3R5cGUpKQkJCVwKKwlBU01fQ01EX1NFUAorIyBlbmRpZgorCisjIGlmbmRlZiBwdXNoX3Nl Y3Rpb25fY29yZQorIyAgZGVmaW5lIHB1c2hfc2VjdGlvbl9jb3JlKF9fc2VjdGlvbiwgX19jb3Jl LCBfX25hbWUsCQkJXAorCQkJICAgIF9fbGV2ZWwsIF9fZmxhZ3MpCQkJCVwKKwlfX3N0cmluZ2lm eShfX3B1c2hfc2VjdGlvbl9jb3JlKF9fc2VjdGlvbiwgX19jb3JlLAkJXAorCQkJCQlfX25hbWUs CV9fbGV2ZWwsCQlcCisJCQkJCV9fc3RyaW5naWZ5KF9fZmxhZ3MpKSkJCVwKKwlBU01fQ01EX1NF UAorIyBlbmRpZgorCisjZW5kaWYgLyogZGVmaW5lZChfX0FTU0VNQkxFUl9fKSB8fCBkZWZpbmVk KF9fQVNTRU1CTFlfXykgKi8KKyNlbmRpZiAvKiBfQVNNX0dFTkVSSUNfU0VDVElPTl9DT1JFX0hf ICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FzbS1nZW5lcmljL3NlY3Rpb25zLmggYi9pbmNsdWRl L2FzbS1nZW5lcmljL3NlY3Rpb25zLmgKaW5kZXggNGRmNjRhMWZjMDllLi5iMTQ1YWU4ZDljYmUg MTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvc2VjdGlvbnMuaAorKysgYi9pbmNsdWRl L2FzbS1nZW5lcmljL3NlY3Rpb25zLmgKQEAgLTEsNiArMSw4IEBACiAjaWZuZGVmIF9BU01fR0VO RVJJQ19TRUNUSU9OU19IXwogI2RlZmluZSBfQVNNX0dFTkVSSUNfU0VDVElPTlNfSF8KIAorI2lu Y2x1ZGUgPGFzbS9zZWN0aW9uLWNvcmUuaD4KKwogLyogUmVmZXJlbmNlcyB0byBzZWN0aW9uIGJv dW5kYXJpZXMgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2NvbXBpbGVyLmg+CmRpZmYgLS1naXQgYS9p bmNsdWRlL2FzbS1nZW5lcmljL3ZtbGludXgubGRzLmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL3Zt bGludXgubGRzLmgKaW5kZXggMDk2OGQxM2IzODg1Li40ODNmNjBjNDUxZjkgMTAwNjQ0Ci0tLSBh L2luY2x1ZGUvYXNtLWdlbmVyaWMvdm1saW51eC5sZHMuaAorKysgYi9pbmNsdWRlL2FzbS1nZW5l cmljL3ZtbGludXgubGRzLmgKQEAgLTU1LDYgKzU1LDcgQEAKICNlbmRpZgogCiAjaW5jbHVkZSA8 bGludXgvZXhwb3J0Lmg+CisjaW5jbHVkZSA8YXNtL3NlY3Rpb24tY29yZS5oPgogCiAvKiBBbGln biAuIHRvIGEgOCBieXRlIGJvdW5kYXJ5IGVxdWFscyB0byBtYXhpbXVtIGZ1bmN0aW9uIGFsaWdu bWVudC4gKi8KICNkZWZpbmUgQUxJR05fRlVOQ1RJT04oKSAgLiA9IEFMSUdOKDgpCmRpZmYgLS1n aXQgYS9pbmNsdWRlL2xpbnV4L2luaXQuaCBiL2luY2x1ZGUvbGludXgvaW5pdC5oCmluZGV4IDg4 NWMzZTZkMGY5ZC4uMTE2ZTMyNjIzMzJhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2luaXQu aAorKysgYi9pbmNsdWRlL2xpbnV4L2luaXQuaApAQCAtMTMwLDYgKzEzMCwyNCBAQCBpbnQgX19p bml0IGluaXRfcm9vdGZzKHZvaWQpOwogZXh0ZXJuIGJvb2wgcm9kYXRhX2VuYWJsZWQ7CiAjZW5k aWYKICNpZmRlZiBDT05GSUdfREVCVUdfUk9EQVRBCisvKioKKyAqIG1hcmtfcm9kYXRhX3JvIC0g aW1wbGVtZW1lbnQgbWVtb3J5IHByb3RlY3Rpb24gZm9yIEVMRiBzZWN0aW9ucworICoKKyAqIEFy Y2hpdGVjdHVyZXMgd2hpY2ggc3VwcG9ydCBtZW1vcnkgcHJvdGVjdGlvbiBkZWZpbmUgYSBrZXJu ZWwgY29uZmlndXJhdGlvbgorICogZW50cnkgZm9yIENPTkZJR19ERUJVR19ST0RBVEEsIGVuYWJs ZSBpdCBpbiBhbmQgaW1wbGVtZW50IG1hcmtfcm9kYXRhX3JvKCkuCisgKiBtYXJrX3JvZGF0YV9y bygpIHNob3VsZCBzdHJpdmUgdG8gYWRqdXN0IHRoZSAucm9kYXRhIGFuZCAudGV4dCBFTEYgc2Vj dGlvbnMKKyAqIHdpdGggcmVhZC1vbmx5IG1lbW9yeSBwcm90ZWN0aW9uIHRvIHByZXZlbnQgbW9k aWZpY2F0aW9ucyBvZiB0aGVzZSBzZWN0aW9ucworICogYWZ0ZXIgYm9vdHVwLiBJdCBjYW4gYWxz byB0cnkgdG8gdXNlIG1lbW9yeSBwcm90ZWN0aW9uIHRvIHByZXZlbnQgZXhlY3V0aW9uCisgKiBv biB0aGUgLnJvZGF0YSBFTEYgc2VjdGlvbi4KKyAqCisgKiBJbiBvcmRlciB0byBoZWxwIGFyY2hp dGVjdHVyZXMgc2V0IGJvdGggLnRleHQgYW5kIC5yb2RhdGEgYXMgcmVhZC1vbmx5IHdpdGgKKyAq IG1lbW9yeSBwcm90ZWN0aW9ucyBpbiBvbmUgc2hvdCBMaW51eCBoYXMgdHlwaWNhbGx5IGZvbGxv d2VkIHRoZSBjb252ZW50aW9uCisgKiB0byBoYXZlIHRoZSAucm9kYXRhIEVMRiBzZWN0aW9uIGZv bGxvdyB0aGUgLnRleHQgRUxGIHNlY3Rpb24gb24gdGhlIHZtbGludXgKKyAqIGxpbmtlciBzY3Jp cHQuCisgKgorICogTGludXggY2FsbHMgbWFya19yb2RhdGFfcm8oKSBhZnRlciBmcmVlaW5nIC5p bml0IGNvZGUgYW5kIHByaW9yIHRvIGNhbGxpbmcKKyAqIHRoZSBmaXJzdCBpbml0IHVzZXJzcGFj ZSBwcm9jZXNzLgorICovCiB2b2lkIG1hcmtfcm9kYXRhX3JvKHZvaWQpOwogI2VuZGlmCiAKQEAg LTE0MCwyNSArMTU4LDcwIEBAIGV4dGVybiBib29sIGluaXRjYWxsX2RlYnVnOwogI2VuZGlmCiAg IAogI2lmbmRlZiBNT0RVTEUKKy8qKgorICogRE9DOiBJbml0Y2FsbCBsZXZlbHMKKyAqCisgKiBX aGVuIExpbnV4IGJvb3RzIHRoZSBrZXJuZWwgZG9faW5pdGNhbGxzKCkgaXRlcmF0ZXMgb3ZlciBl YWNoIExpbnV4CisgKiBpbml0aWFsaXphdGlvbiBsZXZlbCBJRCBhbmQgY2FsbHMgYWxsIHJvdXRp bmVzIGVtYmVkZGVkIG9uIGVhY2ggbGV2ZWwgSUQuCisgKiBQcmlvciB0byB2Mi41LjIuMyBMaW51 eCBoYWQgb25seSBvbmUgaW5pdCBsZXZlbCBvbnRvIHdoaWNoIGFsbCBpbml0CisgKiBmdW5jdGlv bnMgZm9sZGVkIG9udG8gdXNpbmcgX19pbml0Y2FsbCgpLiBBZnRlciB2Mi41LjIuNCBMaW51eCBz cGxpdCB1cAorICogaW5pdGNhbGxzIGludG8gNyBzZXBhcmF0ZSBpbml0Y2FsbCBzdWJzZWN0aW9u IGxldmVscywgZWFjaCBsZXZlbCBkZXNjcmliaW5nCisgKiBkaWZmZXJlbnQgZnVuY3Rpb25hbGl0 eSBwYXJ0IG9mIHRoZSBrZXJuZWwgKGNvbW1pdCBgOWQ2YmExMjFiN2UxNzA4NWBfCisgKiAodjIu NS4yLjMgLT4gdjIuNS4yLjQpKS4gSW4gb3JkZXIgdG8gcmVtYWluIGJhY2t3YXJkIGNvbXBhdGli bGUgX19pbml0Y2FsbCgpCisgKiBjYWxscyB3ZXJlIGxlZnQgbWFwcGVkIHRvIGRldmljZV9pbml0 Y2FsbCgpLgorICoKKyAqIEVhY2ggaW5pdCBsZXZlbCBjb25zaXN0cyBvZiBhIGRlZGljYXRlZCBF TEYgc2VjdGlvbiwgaW5pdCBmdW5jdGlvbnMgYXJlCisgKiBhc3NvY2lhdGVkIHRvIGFuIGluaXQg bGV2ZWwgYnkgbGlua2luZyBpdCBpbnRvIHRoZSByZXNwZWN0aXZlIGxldmVsJ3MKKyAqIEVMRiBz ZWN0aW9uLgorICoKKyAqIExvd2VyIG9yZGVyIGluaXQgbGV2ZWxzIHJ1biBwcmlvciB0byBoaWdo ZXIgb3JkZXIgaW5pdCBsZXZlbHMuIE9yZGVyaW5nCisgKiBpbnNpZGUgZWFjaCBpbml0Y2FsbCBs ZXZlbCBpcyBkZXRlcm1pbmVkIGJ5IHJlc3BlY3RpdmUgbGluayBvcmRlci4KKyAqCisgKiAuLiBf OWQ2YmExMjFiN2UxNzA4NTogaHR0cHM6Ly9naXQua2VybmVsLm9yZy9jZ2l0L2xpbnV4L2tlcm5l bC9naXQvaGlzdG9yeS9oaXN0b3J5LmdpdC9jb21taXQvP2lkPTlkNmJhMTIxYjdlMTcwODVjOTUx MzkyMzM2ODZiMjdhNGQ0YzY1MGUKKyAqLwogCiAjaWZuZGVmIF9fQVNTRU1CTFlfXwogCi0vKgot ICogaW5pdGNhbGxzIGFyZSBub3cgZ3JvdXBlZCBieSBmdW5jdGlvbmFsaXR5IGludG8gc2VwYXJh dGUKLSAqIHN1YnNlY3Rpb25zLiBPcmRlcmluZyBpbnNpZGUgdGhlIHN1YnNlY3Rpb25zIGlzIGRl dGVybWluZWQKLSAqIGJ5IGxpbmsgb3JkZXIuIAotICogRm9yIGJhY2t3YXJkcyBjb21wYXRpYmls aXR5LCBpbml0Y2FsbCgpIHB1dHMgdGhlIGNhbGwgaW4gCi0gKiB0aGUgZGV2aWNlIGluaXQgc3Vi c2VjdGlvbi4KKy8qKgorICogX19kZWZpbmVfaW5pdGNhbGwgLSB3cmFwcGVyIGZvciBkZWZpbml0 aW5nIGluaXQgbGV2ZWxzCiAgKgotICogVGhlIGBpZCcgYXJnIHRvIF9fZGVmaW5lX2luaXRjYWxs KCkgaXMgbmVlZGVkIHNvIHRoYXQgbXVsdGlwbGUgaW5pdGNhbGxzCi0gKiBjYW4gcG9pbnQgYXQg dGhlIHNhbWUgaGFuZGxlciB3aXRob3V0IGNhdXNpbmcgZHVwbGljYXRlLXN5bWJvbCBidWlsZCBl cnJvcnMuCisgKiBAZm46IGluaXQgcm91dGluZQorICogQGlkOiBpbml0IGxldmVsCiAgKgotICog SW5pdGNhbGxzIGFyZSBydW4gYnkgcGxhY2luZyBwb2ludGVycyBpbiBpbml0Y2FsbCBzZWN0aW9u cyB0aGF0IHRoZQotICoga2VybmVsIGl0ZXJhdGVzIGF0IHJ1bnRpbWUuIFRoZSBsaW5rZXIgY2Fu IGRvIGRlYWQgY29kZSAvIGRhdGEgZWxpbWluYXRpb24KLSAqIGFuZCByZW1vdmUgdGhhdCBjb21w bGV0ZWx5LCBzbyB0aGUgaW5pdGNhbGwgc2VjdGlvbnMgaGF2ZSB0byBiZSBtYXJrZWQKLSAqIGFz IEtFRVAoKSBpbiB0aGUgbGlua2VyIHNjcmlwdC4KKyAqIERlZmluZXMgYSBrZXJuZWwgaW5pdGlh bGl6YXRpb24gbGV2ZWwuIEEgcmVzcGVjdGl2ZSBsaW5rZXIgc2NyaXB0IGVudHJ5CisgKiBpcyBy ZXF1aXJlZCB0byBlbnN1cmUgdGhlIGluaXQgbGV2ZWwgaXMgYWNjb3VudGVkIGZvciBhbmQgdG8g ZW5zdXJlIHN5bWJvbHMKKyAqIGV4aXN0IGZvciBpdGVyYXRpbmcgb3ZlciBhbGwgZnVuY3Rpb25z IGluIHRoZSBpbml0IGxldmVsLiBBIGluaXQgbGV2ZWwKKyAqIHJlcHJlc2VudHMgYSBzZXJpZXMg b2YgZnVuY3Rpb25hbGl0eSBpbiB0aGUga2VybmVsLgorICoKKyAqIE9yZGVyaW5nIHdpdGhpbiBh biBpbml0aWFsaXphdGlvbiBsZXZlbCBpcyBkZXRlcm1pbmVkIGJ5IGxpbmsgb3JkZXIsIHNvCisg KiBmb3IgaW5zdGFuY2UgaWYgYSBNYWtlZmlsZSBoYWQ6OgorICoKKyAqCW9iai15ICs9IGZvby5v CisgKglvYmoteSArPSBiYXIubworICoKKyAqIEFuZCBmb28uYzo6CisgKgorICoJc3Vic3lzX2lu aXRjYWxsKGZvb19pbml0KTsKKyAqCisgKiBBbmQgYmFyLmMgaGFkOjoKKyAqCisgKglzdWJzeXNf aW5pdGNhbGwoYmFyX2luaXQpOworICoKKyAqIGZvb19pbml0KCkgd291bGQgYmUgY2FsbGVkIHBy aW9yIHRvIGJhcl9pbml0KCkuCisgKgorICogTm90ZSB0aGF0IEBpZCBpbiBfX2RlZmluZV9pbml0 Y2FsbCgpIGFsc28gZW5hYmxlcyBtdWx0aXBsZSBpbml0Y2FsbHMKKyAqIHRvIGJlIGNyZWF0ZWQg dXNpbmcgdGhlIHNhbWUgaGFuZGxlciBmb3IgZGlmZmVyZW50IGluaXQgbGV2ZWxzIHdpdGhvdXQK KyAqIGNhdXNpbmcgZHVwbGljYXRlLXN5bWJvbCBidWlsZCBlcnJvcnMuCisgKgorICogSW5pdGNh bGxzIGFyZSBydW4gYnkgcGxhY2luZyBzdGFydCBzeW1ib2xzIHRvIGluaXRjYWxsIGxldmVscyBp bnNpZGUgRUxGCisgKiBzZWN0aW9ucywgdGhlIGtlcm5lbCBpbiB0dXJuIHVzZXMgdGhlc2Ugc3lt Ym9scyB0byBpdGVyYXRlIG92ZXIgZWFjaCBpbml0CisgKiBsZXZlbCBhdCBydW50aW1lIHdpdGgg ZG9faW5pdGNhbGxfbGV2ZWwoKS4gVGhlIGVuZCBvZiBlYWNoIGluaXQgbGV2ZWwgaXMKKyAqIG1h cmtlZCBieSB0aGUgc3Vic2VxdWVudCdzIHN5bWJvbCdzIHN0YXJ0IGFkZHJlc3MgdW50aWwgd2Ug cmVhY2ggdGhlIHN5bWJvbAorICogYGBfX2luaXRjYWxsX2VuZGBgLiBUaGUgbGlua2VyIGNhbiBk byBkZWFkIGNvZGUgLyBkYXRhIGVsaW1pbmF0aW9uIGFuZCBlYWNoCisgKiBpbml0IGxldmVsIHN0 YXJ0IHN5bWJvbCBjb3VsZCBiZSByZW1vdmVkIGNvbXBsZXRlbHkgaW4gdGhpcyBwcm9jZXNzLCB0 bworICogYXZvaWQgdGhpcyBlYWNoIGluaXQgbGV2ZWwgc3RhcnQgc3ltYm9scyBtdXN0IGJlIG1h cmtlZCBhcyAnS0VFUCgpJyBpbiB0aGUKKyAqIGxpbmtlciBzY3JpcHQgdG8gYXZvaWQgYW55IGxp bmtlciBvcHRpbWl6YXRpb24gaGV1cmlzdGljIG9uIGluaXRjYWxscy4KICAqLwotCiAjZGVmaW5l IF9fZGVmaW5lX2luaXRjYWxsKGZuLCBpZCkgXAogCXN0YXRpYyBpbml0Y2FsbF90IF9faW5pdGNh bGxfIyNmbiMjaWQgX191c2VkIFwKIAlfX2F0dHJpYnV0ZV9fKChfX3NlY3Rpb25fXygiLmluaXRj YWxsIiAjaWQgIi5pbml0IikpKSA9IGZuOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9zZWN0 aW9ucy5oIGIvaW5jbHVkZS9saW51eC9zZWN0aW9ucy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uNjc3MWM3MjdiY2QxCi0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVk ZS9saW51eC9zZWN0aW9ucy5oCkBAIC0wLDAgKzEsODcgQEAKKyNpZm5kZWYgX0xJTlVYX1NFQ1RJ T05TX0gKKyNkZWZpbmUgX0xJTlVYX1NFQ1RJT05TX0gKKy8qCisgKiBMaW51eCBkZS1mYWN0byBz ZWN0aW9ucworICoKKyAqIENvcHlyaWdodCAoQykgMjAxNiBMdWlzIFIuIFJvZHJpZ3VleiA8bWNn cm9mQGtlcm5lbC5vcmc+CisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlv dSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJt cyBvZiBjb3B5bGVmdC1uZXh0ICh2ZXJzaW9uIDAuMy4xIG9yIGxhdGVyKSBhcyBwdWJsaXNoZWQK KyAqIGF0IGh0dHA6Ly9jb3B5bGVmdC1uZXh0Lm9yZy8uCisgKi8KKworI2luY2x1ZGUgPGFzbS9z ZWN0aW9uLWNvcmUuaD4KKyNpbmNsdWRlIDxsaW51eC9leHBvcnQuaD4KKworI2lmbmRlZiBfX0FT U0VNQkxZX18KKworLyoqCisgKiBET0M6IEludHJvZHVjdGlvbgorICoKKyAqIExpbnV4IGRlZmlu ZXMgYSBzZXQgb2YgY29tbW9uIGhlbHBlcnMgd2hpY2ggY2FuIGJlIHVzZWQgdG8gYWdhaW5zdCBp dHMgdXNlCisgKiBvZiBzdGFuZGFyZCBvciBjdXN0b20gTGludXggc2VjdGlvbnMsIHRoaXMgc2Vj dGlvbiBpcyBkZWRpY2F0ZWQgdG8gdGhlc2UKKyAqIGhlbHBlcnMuCisgKi8KKworLyoqCisgKiBM SU5VWF9TRUNUSU9OX0FMSUdOTUVOVCAtIGdldCBzZWN0aW9uIGFsaWdubWVudAorICoKKyAqIEBu YW1lOiBzZWN0aW9uIG5hbWUKKyAqCisgKiBHaXZlcyB5b3UgdGhlIGFsaWdubWVudCBmb3IgdGhl IHNlY3Rpb24uCisgKi8KKyNkZWZpbmUgTElOVVhfU0VDVElPTl9BTElHTk1FTlQobmFtZSkJX19h bGlnbm9mX18oKlZNTElOVVhfU1lNQk9MKG5hbWUpKQorCisvKioKKyAqIExJTlVYX1NFQ1RJT05f U1RBUlQgLSBnZXQgYWRkcmVzcyBvZiBzdGFydCBvZiBzZWN0aW9uCisgKgorICogQG5hbWU6IHNl Y3Rpb24gbmFtZQorICoKKyAqIFRoaXMgZ2l2ZXMgeW91IHRoZSBzdGFydCBhZGRyZXNzIG9mIHRo ZSBzZWN0aW9uLgorICogVGhpcyBzaG91bGQgZ2l2ZSB5b3UgdGhlIGFkZHJlc3Mgb2YgdGhlIGZp cnN0IGVudHJ5LgorICoKKyAqLworI2RlZmluZSBMSU5VWF9TRUNUSU9OX1NUQVJUKG5hbWUpCVZN TElOVVhfU1lNQk9MKG5hbWUpCisKKy8qKgorICogTElOVVhfU0VDVElPTl9FTkQgLSBnZXQgYWRk cmVzcyBvZiBlbmQgb2YgdGhlIHNlY3Rpb24KKyAqCisgKiBAbmFtZTogc2VjdGlvbiBuYW1lCisg KgorICogVGhpcyBnaXZlcyB5b3UgdGhlIGVuZCBhZGRyZXNzIG9mIHRoZSBzZWN0aW9uLgorICog VGhpcyBzaG91bGQgZ2l2ZSB5b3UgdGhlIGFkZHJlc3Mgb2YgdGhlIGVuZCBvZiB0aGUKKyAqIHNl Y3Rpb24uIFRoaXMgd2lsbCBtYXRjaCB0aGUgc3RhcnQgYWRkcmVzcyBpZiB0aGUKKyAqIHNlY3Rp b24gaXMgZW1wdHkuCisgKi8KKyNkZWZpbmUgTElOVVhfU0VDVElPTl9FTkQobmFtZSkJVk1MSU5V WF9TWU1CT0wobmFtZSMjX19lbmQpCisKKy8qKgorICogREVDTEFSRV9MSU5VWF9TRUNUSU9OIC0g RGVjbGFyZXMgYSBjdXN0b20gTGludXggc2VjdGlvbgorICoKKyAqIEB0eXBlOiB0eXBlIG9mIGN1 c3RvbSBMaW51eCBzZWN0aW9uCisgKiBAbmFtZTogY3VzdG9tIHNlY3Rpb24gbmFtZQorICoKKyAq IERlY2xhcmVzIGEgcmVhZC13cml0ZSBjdXN0b20gTGludXggc2VjdGlvbgorICovCisjZGVmaW5l IERFQ0xBUkVfTElOVVhfU0VDVElPTih0eXBlLCBuYW1lKQkJCQlcCisJIGV4dGVybiB0eXBlIFZN TElOVVhfU1lNQk9MKG5hbWUpW10sIFwKKwkJICAgICBWTUxJTlVYX1NZTUJPTChuYW1lIyNfX2Vu ZClbXQorCisvKioKKyAqIERFQ0xBUkVfTElOVVhfU0VDVElPTl9STyAtIERlY2xhcmVzIGEgcmVh ZC1vbmx5IGN1c3RvbSBMaW51eCBzZWN0aW9uCisgKgorICogQHR5cGU6IHR5cGUgb2YgY3VzdG9t IExpbnV4IHNlY3Rpb24KKyAqIEBuYW1lOiBjdXN0b20gc2VjdGlvbiBuYW1lCisgKgorICogRGVj bGFyZXMgYSByZWFkLW9ubHkgY3VzdG9tIExpbnV4IHNlY3Rpb24KKyAqLworI2RlZmluZSBERUNM QVJFX0xJTlVYX1NFQ1RJT05fUk8odHlwZSwgbmFtZSkJCQkJXAorCSBleHRlcm4gY29uc3QgdHlw ZSBWTUxJTlVYX1NZTUJPTChuYW1lKVtdLAkJCVwKKwkJCSAgIFZNTElOVVhfU1lNQk9MKG5hbWUj I19fZW5kKVtdCisKKyNkZWZpbmUgX19TRUNUSU9OX0NPUkUoc2VjdGlvbiwgY29yZSwgbmFtZSwg bGV2ZWwpCQkJXAorCSNzZWN0aW9uICIuLiIgI2NvcmUgIi4iICNuYW1lICIuIiAjbGV2ZWwKKwor I2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLworCisjZW5kaWYgLyogX0xJTlVYX1NFQ1RJT05TX0gg Ki8KLS0gCjIuMTEuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0 cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:51856 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S967985AbdAIO6u (ORCPT ); Mon, 9 Jan 2017 09:58:50 -0500 From: "Luis R. Rodriguez" Subject: [PATCH v6 01/14] generic-sections: add section core helpers Date: Mon, 9 Jan 2017 06:58:19 -0800 Message-ID: <20170109145833.11502-2-mcgrof@kernel.org> In-Reply-To: <20170109145833.11502-1-mcgrof@kernel.org> References: <20161222023811.21246-1-mcgrof@kernel.org> <20170109145833.11502-1-mcgrof@kernel.org> Sender: linux-arch-owner@vger.kernel.org List-ID: To: hpa@zytor.com, acme@redhat.com, tglx@linutronix.de, mingo@redhat.com, jpoimboe@redhat.com, bp@alien8.de, npiggin@gmail.com, mhiramat@kernel.org, masami.hiramatsu.pt@hitachi.com, jbaron@akamai.com, heiko.carstens@de.ibm.com, ananth@linux.vnet.ibm.com, anil.s.keshavamurthy@intel.com, davem@davemloft.net, realmz6@gmail.com, dalias@libc.org, linux@arm.linux.org.uk Cc: x86@kernel.org, luto@amacapital.net, keescook@chromium.org, linux@roeck-us.net, torvalds@linux-foundation.org, gregkh@linuxfoundation.org, rusty@rustcorp.com.au, gnomes@lxorguk.ukuu.org.uk, alan@linux.intel.com, dwmw2@infradead.org, arnd@arndb.de, ming.lei@canonical.com, linux-arch@vger.kernel.org, benh@kernel.crashing.org, pebolle@tiscali.nl, fontana@sharpeleven.org, david.vrabel@citrix.com, konrad.wilk@oracle.com, mcb30@ipxe.org, jgross@suse.com, andrew.cooper3@citrix.com, andriy.shevchenko@linux.intel.com, paul.gortmaker@windriver.com, xen-devel@lists.xensource.com, ak@linux.intel.com, pali.rohar@gmail.com, dvhart@infradead.org, platform-driver-x86@vger.kernel.org, mmarek@suse.com, linux@rasmusvillemoes.dk, jkosina@suse.cz, korea.drzix@gmail.com, linux-kbuild@vger.kernel.org, tony.luck@intel.com, akpm@linux-foundation.org, linux-ia64@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sh@vger.kernel.org, sparclinux@vger.kernel.org, catalin.marinas@arm.com, will.deacon@arm.com, rostedt@goodmis.org, jani.nikula@intel.com, mchehab@osg.samsung.com, markus.heiser@darmarit.de, jolsa@kernel.org, msalter@redhat.com, chris@zankel.net, jcmvbkbc@gmail.com, linux-xtensa@linux-xtensa.org, adrian.hunter@intel.com, dsahern@gmail.com, namhyung@kernel.org, wangnan0@huawei.com, dmitry.torokhov@gmail.com, joro@8bytes.org, paulus@samba.org, mpe@ellerman.id.au, James.Bottomley@HansenPartnership.com, "Luis R. Rodriguez" Message-ID: <20170109145819.0fJzDMsCbbJosxdh6Rlkquc_2mNNjb-dn0jyG_Ta5Po@z> 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. v5: o Huge documentation revamp based on a careful review of the ELF specifications. Includes documentation now also about usage of two dots (..) when prefixing ELF program specific sections. o Replace macros for sections names in favor of just using the section names explicitly in the linker script. This is perhaps more work to grep but this is what folks seem to currently prefer. o Fix .text and .rodata documentation to explain memory protection strategies which architectures can embrace upon initialization (documents CONFIG_DEBUG_RODATA and mark_rodata_ro()) o Skip the 'Linux section ordering' documentation section, we'll instead add this on subsequent patch which will expand on it considerably o Dropped tree on MAINTAINERS -- as per discussions with Arnd, hpa and Josh, its easier to just let changes for sections go in through the respective tree that needs the changes. o Fix typos on documentation o Dropped SECTION_ALL(), __SECTION_CORE(), SECTION_CORE_ALL() macros since we are favoring using explicit section names. These are useless if we are being explicit. o Drop LINUX_SECTION_SIZE(), LINUX_SECTION_EMPTY() in favor of having section ranges and linker tables define their own, to avoid confusion and make code more readable. o Add __define_initcall() documentation and a small section describing our current initcall levels. This should help also clarify what was meant about keeping backward compatiblity. 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/background.rst | 105 ++++++++++ Documentation/sections/conf.py | 4 + Documentation/sections/index.rst | 17 ++ Documentation/sections/section-core.rst | 148 ++++++++++++++ MAINTAINERS | 12 ++ 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 | 307 ++++++++++++++++++++++++++++++ include/asm-generic/sections.h | 2 + include/asm-generic/vmlinux.lds.h | 1 + include/linux/init.h | 89 +++++++-- include/linux/sections.h | 87 +++++++++ 42 files changed, 809 insertions(+), 13 deletions(-) create mode 100644 Documentation/sections/background.rst 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 cb5d77699c60..71e0305c036d 100644 --- a/Documentation/index.rst +++ b/Documentation/index.rst @@ -57,6 +57,7 @@ needed). media/index gpu/index security/index + sections/index sound/index crypto/index diff --git a/Documentation/sections/background.rst b/Documentation/sections/background.rst new file mode 100644 index 000000000000..0ecf9104aaa2 --- /dev/null +++ b/Documentation/sections/background.rst @@ -0,0 +1,105 @@ +====================== +ELF section background +====================== + +About +===== + +The purpose of this chapter is to help those not familiar with ELF to brush up +the latest ELF specifications in order to help understand how Linux uses and +defines its own ELF sections. + +Standardized ELF +================ + +The first publication documenting ELF was UNIX System Laboratories' (USL) +*System V Release 4 Application Binary Interface* (`SRV4 ABI`_) specification. +Originally ELF was only a small part of the SRV4 ABI, with time however new +specifications only put focus on ELF, such was the case of the *TIS Portable +Formats Specification version 1.2* (`TIS 1.2`_). As of TIS 1.2, ELF was +supplemented with processor specific ELF addendums, available on the *Linux +Foundation referenced specification page* (`LF ref page`_). The latest ELF +specification is the *System V Application Binary Interface - DRAFT - 24 April +2001* (`gabi4`_). + +.. _SRV4 ABI: http://www.sco.com/developers/devspecs/gabi41.pdf +.. _TIS 1.2: https://refspecs.linuxbase.org/elf/elf.pdf +.. _LF ref page: https://refspecs.linuxbase.org/ +.. _gabi4: https://refspecs.linuxbase.org/elf/gabi4+/contents.html + +ELF views on Linux +================== + +There are two views which can be used for inspecting data in an ELF file, a +Linking view, and an Execution view. A Section Header Table enables one to +describe an object using the Linking view while a Program Header Table enables +one to describe an object using the Execution view. The views are not mutually +exclusive. For intance, vmlinux can be viewed under both views, ``readelf -S +vmlinux`` for the Linking view, and ``readelf -l vmlinux`` for the Execution +view. In Linux only the vmlinux file will have an Execution view, even modules +lack an Execution view given that vmlinux is the only file that describes how +the the kernel runs from the start. All other Linux kernel object files have +an available Linking view. + +Under the Linking view, the Section Header Table describes all available +sections. The Section Header Table is an array of ELF section header data +structures. If on a 32-bit system this is ``struct elf32_shd``, if on a 64-bit +this is ``struct elf64_shdr``. Sections are only visible on object files that +have a Linking view, since all Linux kernel files have Linking view, all kernel +objects have ELF sections. + +Limitations on ELF sections +=========================== + +We provide a summary on the limitations of ELF sections. Refer to the public +ELF specifications for details. Note that 64-bit limitations may depend +on processor specific section attributes to be used, refer to your processsor +specification if unsure. + +Its worth ellaborating on the limitations on the name of an ELF section: +ELF section names are stored as strings as per the ELF specification, and +as can be expected, these don't have explicit limitations. The implicit +limitation then depends on the size of an ELF object file and ELF section. + +If using really large kernels or objects with large amounts of sections one +would still need to be sure that ELF loader in charge of loading the Linux +kernel is properly updated to handle coping with the latest ELF extensions. + + .. flat-table:: Limitations on ELF Sections + + * - Section attribute + - 32-bit + - 64-bit + + * - ELF section name + - Size of an ELF section + - Size of an ELF section + + * - Size of an ELF section + - 4 GiB + - 16 EiB + + * - Max number of sections in an object file + - 4 GiEntries (4294967296) + - 16 EiEntries (18446744073709551616) + +Program specific ELF sections +============================= + +The ELF specification allows for a section type to be specified as +*Program specific section*, defined as ``SHT_PROGBITS``. This sections type +enables programs to customize sections for their own use. In assembly this +specified ``@progbits`` on most architectures, on ARM this is ``%progbits``. + +``SHT_PROGBITS`` is used by Linux for defining and using Linux ELF sections. + +Special ELF Sections +==================== + +The ELF specification defines *Special ELF Sections* on chapter 4 (`gabi4 +ch4`_). These are defined as sections which hold program and control +information. Of these sections, a few have the section type as +``SHT_PROGBITS``. This enables Linux to *further customize* use of the section +beyond what the ELF specification suggests. + +.. _gabi4 ch4: https://refspecs.linuxbase.org/elf/gabi4+/ch4.sheader.html#special_sections 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..f37511ef05e7 --- /dev/null +++ b/Documentation/sections/index.rst @@ -0,0 +1,17 @@ +========================= +Linux Kernel ELF sections +========================= + +This book documents the different ELF sections used on the Linux kernel. +We start off by providing references to how ELF was standardized, references +to the standards on ELF sections, review limitations of ELF sections, and +finally how Linux uses ELF sections in the Linux kernel. Certain important +Linux ELF sections are documented carefully: we describe the goal of the +ELF section, and address concurrency considerations when applicable. A few +common a set of Linux helpers for ELF sections are also documented. + +.. toctree:: + :maxdepth: 4 + + background + section-core diff --git a/Documentation/sections/section-core.rst b/Documentation/sections/section-core.rst new file mode 100644 index 000000000000..ac5815a0d9b3 --- /dev/null +++ b/Documentation/sections/section-core.rst @@ -0,0 +1,148 @@ +=================================== +Linux ELF program specific sections +=================================== + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux ELF program specific sections + +Linux linker script +=================== + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux linker script + +Memory protection +----------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Memory protection + +mark_rodata_ro +----------------------- +.. kernel-doc:: include/linux/init.h + :functions: mark_rodata_ro + +.rodata +------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .rodata + +.text +----- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .text + +.data +------------ +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .data + +Linux .init\* sections +====================== + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux init sections + +.init.text +---------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .init.text + +.init.data +---------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .init.data + +.init.rodata +------------ +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .init.rodata + +Initcall levels +--------------- +.. kernel-doc:: include/linux/init.h + :doc: Initcall levels + +.initcall +----------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .initcall + +__define_initcall +----------------- +.. kernel-doc:: include/linux/init.h + :functions: __define_initcall + +Linux .exit\* sections +====================== + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux exit sections + +.exit.text +---------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .exit.text + +.exit.data +---------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .exit.data + +.exitcall.exit +-------------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .exitcall.exit + +Linux .ref\* sections +===================== + +.. kernel-doc:: include/asm-generic/section-core.h + :doc: Linux references to init sections + +.ref.text +--------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .ref.text + +.ref.data +--------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .ref.data + +.ref.rodata +----------- +.. kernel-doc:: include/asm-generic/section-core.h + :doc: .ref.rodata + +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_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 c68a6bb17966..ae86136f4b9a 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5424,6 +5424,18 @@ 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 +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 c332604606dd..7b2cb3dea5fc 100644 --- a/arch/arc/include/asm/Kbuild +++ b/arch/arc/include/asm/Kbuild @@ -51,3 +51,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 efb21757d41f..9b69a22a9ae1 100644 --- a/arch/arm/include/asm/Kbuild +++ b/arch/arm/include/asm/Kbuild @@ -41,3 +41,4 @@ generic-y += unaligned.h generated-y += mach-types.h generated-y += unistd-nr.h +generic-y += section-core.h diff --git a/arch/arm64/include/asm/Kbuild b/arch/arm64/include/asm/Kbuild index 8365a84c2640..00ace5e826f1 100644 --- a/arch/arm64/include/asm/Kbuild +++ b/arch/arm64/include/asm/Kbuild @@ -45,3 +45,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 2fb67b59d188..bf20541bcf21 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -47,3 +47,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 1f2e5d31cb24..1277b45bf4f9 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -34,3 +34,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 167150c701d1..b1011375cd7a 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -55,3 +55,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 ed07179fe26a..7a932b4a5531 100644 --- a/arch/mips/include/asm/Kbuild +++ b/arch/mips/include/asm/Kbuild @@ -21,3 +21,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/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 91f53c07f410..18a9d4c5ead7 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -28,3 +28,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 5c4fbc80dc6c..4322d9746cdb 100644 --- a/arch/powerpc/include/asm/Kbuild +++ b/arch/powerpc/include/asm/Kbuild @@ -8,3 +8,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 8aea32fe8bd2..63a1c2924b91 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 0569bfac4afb..438f86573dc5 100644 --- a/arch/sparc/include/asm/Kbuild +++ b/arch/sparc/include/asm/Kbuild @@ -21,3 +21,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 2d1f5638974c..fb6b831c1fba 100644 --- a/arch/tile/include/asm/Kbuild +++ b/arch/tile/include/asm/Kbuild @@ -40,3 +40,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 052f7f6d0551..580bd5ff828f 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -26,3 +26,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..0b9c68429a1a --- /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 2b892e2313a9..af975f21eeee 100644 --- a/arch/x86/include/asm/Kbuild +++ b/arch/x86/include/asm/Kbuild @@ -12,3 +12,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 b7fbaa56b51a..7879c31e66a7 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -32,3 +32,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..bb16befc4251 --- /dev/null +++ b/include/asm-generic/section-core.h @@ -0,0 +1,307 @@ +#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: Linux ELF program specific sections + * + * Linux makes extensive use of ``SHT_PROGBITS`` to both extend use and + * definition of *Special ELF Sections* (`gabi4 ch4`_) and to define its own + * sections. This chaper is dedicated to documenting Linux program specific + * sections and helpers available to make use of these easier to implement and + * use. + * + * .. _gabi4 ch4: https://refspecs.linuxbase.org/elf/gabi4+/ch4.sheader.html#special_sections + */ + +/** + * DOC: Linux linker script + * + * Linux uses a custom linker script to build the vmlinux binary, it uses it to + * strategically place and define Linux ELF sections. Each architecture needs + * to implement its own linker script, it is expected to reside in + * ``arch/$(ARCH)/kernel/vmlinux.lds.S``. Architecture Linux linker scripts in + * turn include and use definitions from ``include/asm-generic/vmlinux.lds.h``, + * as well as some helpers documented in this chapter. + * + * In assembly it is common practice to use dots (``.``) in labels to avoid + * clashes with C symbols. Similarly, a dot (``.``) can be part of a section + * name but not a C symbol. Historically then, two dots are used (``..``) + * have been used in linker scripts when adding program specific sections + * when there are concerns to avoid clashes with compiler generated sections. + */ + +/** + * DOC: Memory protection + * + * Linux allows architectures which support memory protection features to + * take advantage of them by letting architectures define and enable + * ``CONFIG_DEBUG_RODATA`` and implement a mark_rodata_ro() call. + * mark_rodata_ro() can be used for instance to mark specific sections as + * read-only or non-executable. + * + * Linux typically follows a convention to have the .rodata ELF section follow + * after the .text ELF section, it does this to help architectures which + * support memory protection to mark both .text and .rodata as read-only in + * one shot. + * + * For more details refer to mark_rodata_ro(). + */ + +/** + * DOC: .rodata + * + * ELF section used for data which must be protected from write access. + */ + +/** + * DOC: .text + * + * ELF section name used for code (functions) used during regular + * kernel run time. + */ + +/** + * DOC: .data + * + * ELF section used for read-write 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: .init.text + * + * ELF section for code (functions) used only during boot or driver + * initialization. + * + */ + +/** + * DOC: .init.data + * + * ELF section used for data structures used only during boot or driver + * initialization. + */ + +/** + * DOC: .init.rodata + * + * ELF section used for read-only code (functions) used only during boot + * or driver initialization. + */ + +/** + * DOC: .initcall + * + * ELF section used for subsystem init calls. There are init levels + * representing different functionality in the kernel. For more details + * refer to __define_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: .exit.text + * + * ELF section used to for code (functions) used only during module unload. + */ + +/** + * DOC: .exit.data + * + * ELF section used to for data structures used only during module + * unload. + */ + +/** + * DOC: .exitcall.exit + * + * ELF section used for exit routines, order is important and maintained by + * link order. + */ + +/** + * 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: .ref.text + * + * ELF section used to annotate code (functions) which has been vetteed as + * valid for its reference or use of other code (functions) or data structures + * which are part of the init sections. + */ + +/** + * DOC: .ref.data + * + * ELF section used for data structures which have been vetteed for its + * reference or use of other code (functions) or data structures part of the + * init sections. + */ + +/** + * DOC: .ref.rodata + * + * ELF section 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. + */ + +/* 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__) + +# ifndef LINKER_SCRIPT + +# 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__) */ + +/* + * 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 4df64a1fc09e..b145ae8d9cbe 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 0968d13b3885..483f60c451f9 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) diff --git a/include/linux/init.h b/include/linux/init.h index 885c3e6d0f9d..116e3262332a 100644 --- a/include/linux/init.h +++ b/include/linux/init.h @@ -130,6 +130,24 @@ int __init init_rootfs(void); extern bool rodata_enabled; #endif #ifdef CONFIG_DEBUG_RODATA +/** + * mark_rodata_ro - implemement memory protection for ELF sections + * + * Architectures which support memory protection define a kernel configuration + * entry for CONFIG_DEBUG_RODATA, enable it in and implement mark_rodata_ro(). + * mark_rodata_ro() should strive to adjust the .rodata and .text ELF sections + * with read-only memory protection to prevent modifications of these sections + * after bootup. It can also try to use memory protection to prevent execution + * on the .rodata ELF section. + * + * In order to help architectures set both .text and .rodata as read-only with + * memory protections in one shot Linux has typically followed the convention + * to have the .rodata ELF section follow the .text ELF section on the vmlinux + * linker script. + * + * Linux calls mark_rodata_ro() after freeing .init code and prior to calling + * the first init userspace process. + */ void mark_rodata_ro(void); #endif @@ -140,25 +158,70 @@ extern bool initcall_debug; #endif #ifndef MODULE +/** + * DOC: Initcall levels + * + * When Linux boots the kernel do_initcalls() iterates over each Linux + * initialization level ID and calls all routines embedded on each level ID. + * Prior to v2.5.2.3 Linux had only one init level onto which all init + * functions folded onto using __initcall(). After v2.5.2.4 Linux split up + * initcalls into 7 separate initcall subsection levels, each level describing + * different functionality part of the kernel (commit `9d6ba121b7e17085`_ + * (v2.5.2.3 -> v2.5.2.4)). In order to remain backward compatible __initcall() + * calls were left mapped to device_initcall(). + * + * Each init level consists of a dedicated ELF section, init functions are + * associated to an init level by linking it into the respective level's + * ELF section. + * + * Lower order init levels run prior to higher order init levels. Ordering + * inside each initcall level is determined by respective link order. + * + * .. _9d6ba121b7e17085: https://git.kernel.org/cgit/linux/kernel/git/history/history.git/commit/?id=9d6ba121b7e17085c95139233686b27a4d4c650e + */ #ifndef __ASSEMBLY__ -/* - * initcalls are now grouped by functionality into separate - * subsections. Ordering inside the subsections is determined - * by link order. - * For backwards compatibility, initcall() puts the call in - * the device init subsection. +/** + * __define_initcall - wrapper for definiting init levels * - * The `id' arg to __define_initcall() is needed so that multiple initcalls - * can point at the same handler without causing duplicate-symbol build errors. + * @fn: init routine + * @id: init level * - * Initcalls are run by placing pointers in initcall sections that the - * kernel iterates at runtime. The linker can do dead code / data elimination - * and remove that completely, so the initcall sections have to be marked - * as KEEP() in the linker script. + * Defines a kernel initialization level. A respective linker script entry + * is required to ensure the init level is accounted for and to ensure symbols + * exist for iterating over all functions in the init level. A init level + * represents a series of functionality in the kernel. + * + * Ordering within an initialization level is determined by link order, so + * for instance if a Makefile had:: + * + * obj-y += foo.o + * obj-y += bar.o + * + * And foo.c:: + * + * subsys_initcall(foo_init); + * + * And bar.c had:: + * + * subsys_initcall(bar_init); + * + * foo_init() would be called prior to bar_init(). + * + * Note that @id in __define_initcall() also enables multiple initcalls + * to be created using the same handler for different init levels without + * causing duplicate-symbol build errors. + * + * Initcalls are run by placing start symbols to initcall levels inside ELF + * sections, the kernel in turn uses these symbols to iterate over each init + * level at runtime with do_initcall_level(). The end of each init level is + * marked by the subsequent's symbol's start address until we reach the symbol + * ``__initcall_end``. The linker can do dead code / data elimination and each + * init level start symbol could be removed completely in this process, to + * avoid this each init level start symbols must be marked as 'KEEP()' in the + * linker script to avoid any linker optimization heuristic on initcalls. */ - #define __define_initcall(fn, id) \ static initcall_t __initcall_##fn##id __used \ __attribute__((__section__(".initcall" #id ".init"))) = fn; diff --git a/include/linux/sections.h b/include/linux/sections.h new file mode 100644 index 000000000000..6771c727bcd1 --- /dev/null +++ b/include/linux/sections.h @@ -0,0 +1,87 @@ +#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_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_CORE(section, core, name, level) \ + #section ".." #core "." #name "." #level + +#endif /* __ASSEMBLY__ */ + +#endif /* _LINUX_SECTIONS_H */ -- 2.11.0