From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Subject: [PATCH v6 11/14] kprobes: move kprobe declarations to asm-generic/kprobes.h Date: Mon, 9 Jan 2017 06:58:29 -0800 Message-ID: <20170109145833.11502-12-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 T2Z0ZW4gYWxsIGlzIG5lZWRlZCBpcyB0aGVzZSBzbWFsbCBoZWxwZXJzLCBpbnN0ZWFkIG9mIGNv bXBpbGVyLmgKb3IgYSBmdWxsIGtwcm9iZXMuaC4gVGhpcyBpcyBpbXBvcnRhbnQgZm9yIGFzbSBo ZWxwZXJzLCBpbiBmYWN0IGV2ZW4Kc29tZSBhc20va3Byb2Jlcy5oIG1ha2UgdXNlIG9mIHRoZXNl IGhlbHBlcnMuLi4gaW5zdGVhZCBqdXN0IGtlZXAgYQpnZW5lcmljIGFzbSBmaWxlIHdpdGggaGVs cGVycyB1c2VmdWwgZm9yIGFzbSBjb2RlIHdpdGggdGhlIGxlYXN0IGFtb3VudApvZiBjbHV0dGVy IGFzIHBvc3NpYmxlLgoKTGlrZXdpc2Ugd2UgbmVlZCBub3cgdG8gYWxzbyBhZGRyZXNzIHdoYXQg dG8gZG8gYWJvdXQgdGhpcyBmaWxlIGZvciBib3RoCndoZW4gYXJjaGl0ZWN0dXJlcyBoYXZlIENP TkZJR19IQVZFX0tQUk9CRVMsIGFuZCB3aGVuIHRoZXkgZG8gbm90LiBUaGVuCmZvciB3aGVuIGFy Y2hpdGVjdHVyZXMgaGF2ZSBDT05GSUdfSEFWRV9LUFJPQkVTIGJ1dCBoYXZlIGRpc2FibGVkCkNP TkZJR19LUFJPQkVTLgoKUmlnaHQgbm93IG1vc3QgYXNtL2twcm9iZXMuaCBkbyBub3QgaGF2ZSBn dWFyZHMgYWdhaW5zdCBDT05GSUdfS1BST0JFUywKdGhpcyBtZWFucyBtb3N0IGFyY2hpdGVjdHVy ZSBjb2RlIGNhbm5vdCBpbmNsdWRlIGFzbS9rcHJvYmVzLmggc2FmZWx5LgpDb3JyZWN0IHRoaXMg YW5kIGFkZCBndWFyZHMgZm9yIGFyY2hpdGVjdHVyZXMgbWlzc2luZyB0aGVtLiBBZGRpdGlvbmFs bHkKcHJvdmlkZSBhcmNoaXRlY3R1cmVzIHRoYXQgbm90IGhhdmUga3Byb2JlcyBzdXBwb3J0IHdp dGggdGhlIGRlZmF1bHQKYXNtLWdlbmVyaWMgc29sdXRpb24uIFRoaXMgbGV0cyB1cyBmb3JjZSBh c20va3Byb2Jlcy5oIG9uIHRoZSBoZWFkZXIKaW5jbHVkZS9saW51eC9rcHJvYmVzLmggYWx3YXlz LCBidXQgbW9zdCBpbXBvcnRhbnRseSB3ZSBjYW4gbm93IHNhZmVseQppbmNsdWRlIGp1c3QgYXNt L2twcm9iZXMuaCBvbiBhcmNoaXRlY3R1cmUgY29kZSB3aXRob3V0IGJyaW5naW5nCnRoZSBmdWxs IGtpdGNoZW4gc2luayBvZiBoZWFkZXIgZmlsZXMuCgpUd28gYXJjaGl0ZWN0dXJlcyBhbHJlYWR5 IHByb3ZpZGVkIGEgZ3VhcmQgYWdhaW5zdCBDT05GSUdfS1BST0JFUyBvbgppdHMga3Byb2Jlcy5o OiBzaCwgYXJjaC4gVGhlIHJlc3Qgb2YgdGhlIGFyY2hpdGVjdHVyZXMgbmVlZGVkIGdhdXJkcwph ZGRlZC4gV2UgYXZvaWQgaW5jbHVkaW5nIGFueSBub3QtbmVlZGVkIGhlYWRlcnMgb24gYXNtL2tw cm9iZXMuaAp1bmxlc3Mga3Byb2JlcyBoYXZlIGJlZW4gZW5hYmxlZC4KCkluIGEgc3Vic2VxdWVu dCBhdG9taWMgY2hhbmdlIHdlIGNhbiB0cnkgbm93IHRvIHJlbW92ZSBjb21waWxlci5oIGZyb20K aW5jbHVkZS9saW51eC9rcHJvYmVzLmguCgpEdXJpbmcgdGhpcyBzd2VlcCBJJ3ZlIGFsc28gaWRl bnRpZmllZCBhIGZldyBhcmNoaXRlY3R1cmVzIGRlZmluaW5nCmEgY29tbW9uIG1hY3JvIG5lZWRl ZCBmb3IgYm90aCBrcHJvYmVzIGFuZCBmdHJhY2UsIHRoYXQgb2YgdGhlCmRlZmluaXRpb24gb2Yg dGhlIGJyZWFrcHV0IGluc3RydWN0aW9uIHVwLiBTb21lIHJlZmVyIHRvIHRoaXMgYXMKQlJFQUtQ T0lOVF9JTlNUUlVDVElPTi4gVGhpcyBtdXN0IGJlIGtlcHQgb3V0c2lkZSBvZiB0aGUgI2lmZGVm CkNPTkZJR19LUFJPQkVTIGd1YXJkLgoKdjU6CgpvIGZpeCBCUkVBS1BPSU5UX0lOU1RSVUNUSU9O IGRlcGVuZGVuY3kgd2l0aCBrZXJuZWwgYXJjaGl0ZWN0dXJlCiAgZnRyYWNlIGltcGxlbWVudGF0 aW9uczogIEFsdGhvdWdoIGl0cyBjb3JyZWN0IHRvICNpZmRlZiBDT05GSUdfS1BST0JFUwogIG9u IHRoZSBhcmNoaXRlY3R1cmUgYXJjaC8kKEFSQ0gpL2luY2x1ZGUvYXNtL2twcm9iZXMuaCB3aGVu CiAgYXJjaGl0ZWN0dXJlcyBzdXBwb3J0IGZ0cmFjZSB0aGV5IHdpbGwgcmVseSBvbiB0aGUKICBC UkVBS1BPSU5UX0lOU1RSVUNUSU9OIGRlZmluaXRpb24sIHRoaXMgbmVlZHMgdG8gYmUga2VwdCBv dXQgZnJvbQogIENPTkZJR19LUFJPQkVTIGFzIGZ0cmFjZSBjYW4gYmUgZW5hYmxlZCB3aXRob3V0 IGtwcm9iZXMuIFRoaXMKICBmaXhlcyBjb21waWxhdGlvbiBvbiB4ODYgd2hlcmUga3Byb2JlcyBp cyBkaXNhYmxlZCBidXQgZnRyYWNlIGlzCiAgbGVmdCBlbmFibGVkLgoKbyBpbmNsdWRlIDxhc20v a3Byb2Jlcy5oPiBvbiBhcmNoL2FybTY0L2tlcm5lbC9wcm9iZXMvZGVjb2RlLWluc24uaAoKdjQ6 IGludHJvZHVjZWQgdGhpcyBwYXRjaCBpbnRvIHRoZSBzZXJpZXMKClNpZ25lZC1vZmYtYnk6IEx1 aXMgUi4gUm9kcmlndWV6IDxtY2dyb2ZAa2VybmVsLm9yZz4KLS0tCiBhcmNoL2FscGhhL2luY2x1 ZGUvYXNtL0tidWlsZCAgICAgICAgICB8ICAxICsKIGFyY2gvYXJjL2luY2x1ZGUvYXNtL2twcm9i ZXMuaCAgICAgICAgIHwgIDYgKysrKy0tCiBhcmNoL2FybS9pbmNsdWRlL2FzbS9rcHJvYmVzLmgg ICAgICAgICB8ICA0ICsrKysKIGFyY2gvYXJtL3Byb2Jlcy9kZWNvZGUuaCAgICAgICAgICAgICAg IHwgIDEgKwogYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rcHJvYmVzLmggICAgICAgfCAgNCArKysr CiBhcmNoL2FybTY0L2tlcm5lbC9pbnNuLmMgICAgICAgICAgICAgICB8ICAxICsKIGFyY2gvYXJt NjQva2VybmVsL3Byb2Jlcy9kZWNvZGUtaW5zbi5oIHwgIDIgKysKIGFyY2gvYXZyMzIvaW5jbHVk ZS9hc20va3Byb2Jlcy5oICAgICAgIHwgIDcgKysrKysrLQogYXJjaC9ibGFja2Zpbi9pbmNsdWRl L2FzbS9LYnVpbGQgICAgICAgfCAgMSArCiBhcmNoL2M2eC9pbmNsdWRlL2FzbS9LYnVpbGQgICAg ICAgICAgICB8ICAxICsKIGFyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgIHwg IDEgKwogYXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkICAgICAgICAgICAgfCAgMSArCiBhcmNo L2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICB8ICAxICsKIGFyY2gvaGV4YWdvbi9p bmNsdWRlL2FzbS9LYnVpbGQgICAgICAgIHwgIDEgKwogYXJjaC9pYTY0L2luY2x1ZGUvYXNtL2tw cm9iZXMuaCAgICAgICAgfCAxMiArKysrKysrKystLS0KIGFyY2gvbTMyci9pbmNsdWRlL2FzbS9L YnVpbGQgICAgICAgICAgIHwgIDEgKwogYXJjaC9tNjhrL2luY2x1ZGUvYXNtL0tidWlsZCAgICAg ICAgICAgfCAgMSArCiBhcmNoL21ldGFnL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgICB8ICAx ICsKIGFyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgIHwgIDEgKwogYXJjaC9t aXBzL2luY2x1ZGUvYXNtL2twcm9iZXMuaCAgICAgICAgfCAgNiArKysrKy0KIGFyY2gvbW4xMDMw MC9pbmNsdWRlL2FzbS9rcHJvYmVzLmggICAgIHwgIDcgKysrKysrLQogYXJjaC9uaW9zMi9pbmNs dWRlL2FzbS9LYnVpbGQgICAgICAgICAgfCAgMSArCiBhcmNoL29wZW5yaXNjL2luY2x1ZGUvYXNt L0tidWlsZCAgICAgICB8ICAxICsKIGFyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL0tidWlsZCAgICAg ICAgIHwgIDEgKwogYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2twcm9iZXMuaCAgICAgfCAgMyAr KysKIGFyY2gvczM5MC9pbmNsdWRlL2FzbS9rcHJvYmVzLmggICAgICAgIHwgIDcgKysrKysrLQog YXJjaC9zY29yZS9pbmNsdWRlL2FzbS9LYnVpbGQgICAgICAgICAgfCAgMSArCiBhcmNoL3NoL2lu Y2x1ZGUvYXNtL2twcm9iZXMuaCAgICAgICAgICB8ICA1ICsrKystCiBhcmNoL3NwYXJjL2luY2x1 ZGUvYXNtL2twcm9iZXMuaCAgICAgICB8IDEwICsrKysrKysrLS0KIGFyY2gvdGlsZS9pbmNsdWRl L2FzbS9rcHJvYmVzLmggICAgICAgIHwgIDYgKysrKystCiBhcmNoL3VtL2luY2x1ZGUvYXNtL0ti dWlsZCAgICAgICAgICAgICB8ICAxICsKIGFyY2gvdW5pY29yZTMyL2luY2x1ZGUvYXNtL0tidWls ZCAgICAgIHwgIDEgKwogYXJjaC94ODYvaW5jbHVkZS9hc20va3Byb2Jlcy5oICAgICAgICAgfCAg OSArKysrKysrKy0KIGFyY2gveHRlbnNhL2luY2x1ZGUvYXNtL0tidWlsZCAgICAgICAgIHwgIDEg KwogaW5jbHVkZS9hc20tZ2VuZXJpYy9rcHJvYmVzLmggICAgICAgICAgfCAyNSArKysrKysrKysr KysrKysrKysrKysrKysrCiBpbmNsdWRlL2xpbnV4L2NvbXBpbGVyLmggICAgICAgICAgICAgICB8 ICA4IC0tLS0tLS0tCiBpbmNsdWRlL2xpbnV4L2twcm9iZXMuaCAgICAgICAgICAgICAgICB8IDE5 ICsrKy0tLS0tLS0tLS0tLS0tLS0KIDM3IGZpbGVzIGNoYW5nZWQsIDEyMiBpbnNlcnRpb25zKCsp LCAzOCBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2FzbS1nZW5lcmlj L2twcm9iZXMuaAoKZGlmZiAtLWdpdCBhL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkIGIv YXJjaC9hbHBoYS9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggZjNiZGMzMWQzYzk3Li41NGQzODhm ZDAyNmYgMTAwNjQ0Ci0tLSBhL2FyY2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2Fy Y2gvYWxwaGEvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0xMywzICsxMyw0IEBAIGdlbmVyaWMteSAr PSB0cmFjZV9jbG9jay5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSAr PSByYW5nZXMuaAogZ2VuZXJpYy15ICs9IHRhYmxlcy5oCitnZW5lcmljLXkgKz0ga3Byb2Jlcy5o CmRpZmYgLS1naXQgYS9hcmNoL2FyYy9pbmNsdWRlL2FzbS9rcHJvYmVzLmggYi9hcmNoL2FyYy9p bmNsdWRlL2FzbS9rcHJvYmVzLmgKaW5kZXggOTQ0ZGJlZGIzOGI1Li4wMGJkYmUxNjc2MTUgMTAw NjQ0Ci0tLSBhL2FyY2gvYXJjL2luY2x1ZGUvYXNtL2twcm9iZXMuaAorKysgYi9hcmNoL2FyYy9p bmNsdWRlL2FzbS9rcHJvYmVzLmgKQEAgLTksNiArOSw4IEBACiAjaWZuZGVmIF9BUkNfS1BST0JF U19ICiAjZGVmaW5lIF9BUkNfS1BST0JFU19ICiAKKyNpbmNsdWRlIDxhc20tZ2VuZXJpYy9rcHJv YmVzLmg+CisKICNpZmRlZiBDT05GSUdfS1BST0JFUwogCiB0eXBlZGVmIHUxNiBrcHJvYmVfb3Bj b2RlX3Q7CkBAIC01NSw2ICs1Nyw2IEBAIHZvaWQgdHJhcF9pc19rcHJvYmUodW5zaWduZWQgbG9u ZyBhZGRyZXNzLCBzdHJ1Y3QgcHRfcmVncyAqcmVncyk7CiBzdGF0aWMgdm9pZCB0cmFwX2lzX2tw cm9iZSh1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHN0cnVjdCBwdF9yZWdzICpyZWdzKQogewogfQot I2VuZGlmCisjZW5kaWYgLyogQ09ORklHX0tQUk9CRVMgKi8KIAotI2VuZGlmCisjZW5kaWYgLyog X0FSQ19LUFJPQkVTX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2twcm9i ZXMuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2twcm9iZXMuaAppbmRleCAzZWE5YmU1NTk3MjYu LjU5NjU1NDU5ZGE1OSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vaW5jbHVkZS9hc20va3Byb2Jlcy5o CisrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2twcm9iZXMuaApAQCAtMTYsNiArMTYsOSBAQAog I2lmbmRlZiBfQVJNX0tQUk9CRVNfSAogI2RlZmluZSBfQVJNX0tQUk9CRVNfSAogCisjaW5jbHVk ZSA8YXNtLWdlbmVyaWMva3Byb2Jlcy5oPgorCisjaWZkZWYgQ09ORklHX0tQUk9CRVMKICNpbmNs dWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgogI2luY2x1ZGUg PGxpbnV4L25vdGlmaWVyLmg+CkBAIC04Myw0ICs4Niw1IEBAIHN0cnVjdCBhcmNoX29wdGltaXpl ZF9pbnNuIHsKIAkgKi8KIH07CiAKKyNlbmRpZiAvKiBDT05GSUdfS1BST0JFUyAqLwogI2VuZGlm IC8qIF9BUk1fS1BST0JFU19IICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9wcm9iZXMvZGVjb2Rl LmggYi9hcmNoL2FybS9wcm9iZXMvZGVjb2RlLmgKaW5kZXggZjliMDhiYTdmZTczLi41NDhkNjIy YTMxNTkgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3Byb2Jlcy9kZWNvZGUuaAorKysgYi9hcmNoL2Fy bS9wcm9iZXMvZGVjb2RlLmgKQEAgLTIyLDYgKzIyLDcgQEAKICNpbmNsdWRlIDxsaW51eC90eXBl cy5oPgogI2luY2x1ZGUgPGxpbnV4L3N0ZGRlZi5oPgogI2luY2x1ZGUgPGFzbS9wcm9iZXMuaD4K KyNpbmNsdWRlIDxhc20va3Byb2Jlcy5oPgogCiB2b2lkIF9faW5pdCBhcm1fcHJvYmVzX2RlY29k ZV9pbml0KHZvaWQpOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2twcm9i ZXMuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3Byb2Jlcy5oCmluZGV4IDE3MzdhZWNmY2M1 ZS4uNmRlYjhkNzI2MDQxIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2twcm9i ZXMuaAorKysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2twcm9iZXMuaApAQCAtMTYsNiArMTYs OSBAQAogI2lmbmRlZiBfQVJNX0tQUk9CRVNfSAogI2RlZmluZSBfQVJNX0tQUk9CRVNfSAogCisj aW5jbHVkZSA8YXNtLWdlbmVyaWMva3Byb2Jlcy5oPgorCisjaWZkZWYgQ09ORklHX0tQUk9CRVMK ICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgogI2lu Y2x1ZGUgPGxpbnV4L3BlcmNwdS5oPgpAQCAtNTcsNCArNjAsNSBAQCBpbnQga3Byb2JlX3Npbmds ZV9zdGVwX2hhbmRsZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsIHVuc2lnbmVkIGludCBlc3IpOwog dm9pZCBrcmV0cHJvYmVfdHJhbXBvbGluZSh2b2lkKTsKIHZvaWQgX19rcHJvYmVzICp0cmFtcG9s aW5lX3Byb2JlX2hhbmRsZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpOwogCisjZW5kaWYgLyogQ09O RklHX0tQUk9CRVMgKi8KICNlbmRpZiAvKiBfQVJNX0tQUk9CRVNfSCAqLwpkaWZmIC0tZ2l0IGEv YXJjaC9hcm02NC9rZXJuZWwvaW5zbi5jIGIvYXJjaC9hcm02NC9rZXJuZWwvaW5zbi5jCmluZGV4 IDk0YjYyYzFmYTRkZi4uYWU5MTIzMDRlZDg0IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2tlcm5l bC9pbnNuLmMKKysrIGIvYXJjaC9hcm02NC9rZXJuZWwvaW5zbi5jCkBAIC0zMSw2ICszMSw3IEBA CiAjaW5jbHVkZSA8YXNtL2RlYnVnLW1vbml0b3JzLmg+CiAjaW5jbHVkZSA8YXNtL2ZpeG1hcC5o PgogI2luY2x1ZGUgPGFzbS9pbnNuLmg+CisjaW5jbHVkZSA8YXNtL2twcm9iZXMuaD4KIAogI2Rl ZmluZSBBQVJDSDY0X0lOU05fU0ZfQklUCUJJVCgzMSkKICNkZWZpbmUgQUFSQ0g2NF9JTlNOX05f QklUCUJJVCgyMikKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva2VybmVsL3Byb2Jlcy9kZWNvZGUt aW5zbi5oIGIvYXJjaC9hcm02NC9rZXJuZWwvcHJvYmVzL2RlY29kZS1pbnNuLmgKaW5kZXggNzZk M2YzMTU0MDdmLi4xOTJhYjAwN2JhY2IgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQva2VybmVsL3By b2Jlcy9kZWNvZGUtaW5zbi5oCisrKyBiL2FyY2gvYXJtNjQva2VybmVsL3Byb2Jlcy9kZWNvZGUt aW5zbi5oCkBAIC0xNiw2ICsxNiw4IEBACiAjaWZuZGVmIF9BUk1fS0VSTkVMX0tQUk9CRVNfQVJN NjRfSAogI2RlZmluZSBfQVJNX0tFUk5FTF9LUFJPQkVTX0FSTTY0X0gKIAorI2luY2x1ZGUgPGFz bS9rcHJvYmVzLmg+CisKIC8qCiAgKiBBUk0gc3Ryb25nbHkgcmVjb21tZW5kcyBhIGxpbWl0IG9m IDEyOCBieXRlcyBiZXR3ZWVuIExvYWRFeGNsIGFuZAogICogU3RvcmVFeGNsIGluc3RydWN0aW9u cyBpbiBhIHNpbmdsZSB0aHJlYWQgb2YgZXhlY3V0aW9uLiBTbyBrZWVwIHRoZQpkaWZmIC0tZ2l0 IGEvYXJjaC9hdnIzMi9pbmNsdWRlL2FzbS9rcHJvYmVzLmggYi9hcmNoL2F2cjMyL2luY2x1ZGUv YXNtL2twcm9iZXMuaAppbmRleCA0NWY1NjNlZDczZmQuLjI4ZGZjNjFhZDM4NCAxMDA2NDQKLS0t IGEvYXJjaC9hdnIzMi9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKKysrIGIvYXJjaC9hdnIzMi9pbmNs dWRlL2FzbS9rcHJvYmVzLmgKQEAgLTExLDEwICsxMSwxNCBAQAogI2lmbmRlZiBfX0FTTV9BVlIz Ml9LUFJPQkVTX0gKICNkZWZpbmUgX19BU01fQVZSMzJfS1BST0JFU19ICiAKKyNpbmNsdWRlIDxh c20tZ2VuZXJpYy9rcHJvYmVzLmg+CisKKyNkZWZpbmUgQlJFQUtQT0lOVF9JTlNUUlVDVElPTgkw eGQ2NzMJLyogYnJlYWtwb2ludCAqLworCisjaWZkZWYgQ09ORklHX0tQUk9CRVMKICNpbmNsdWRl IDxsaW51eC90eXBlcy5oPgogCiB0eXBlZGVmIHUxNglrcHJvYmVfb3Bjb2RlX3Q7Ci0jZGVmaW5l IEJSRUFLUE9JTlRfSU5TVFJVQ1RJT04JMHhkNjczCS8qIGJyZWFrcG9pbnQgKi8KICNkZWZpbmUg TUFYX0lOU05fU0laRQkJMgogI2RlZmluZSBNQVhfU1RBQ0tfU0laRQkJNjQJLyogMzIgd291bGQg cHJvYmFibHkgYmUgT0sgKi8KIApAQCAtNDYsNCArNTAsNSBAQCBleHRlcm4gaW50IGtwcm9iZV9l eGNlcHRpb25zX25vdGlmeShzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnNlbGYsCiAKICNkZWZpbmUg Zmx1c2hfaW5zbl9zbG90KHApCWRvIHsgfSB3aGlsZSAoMCkKIAorI2VuZGlmIC8qIENPTkZJR19L UFJPQkVTICovCiAjZW5kaWYgLyogX19BU01fQVZSMzJfS1BST0JFU19IICovCmRpZmYgLS1naXQg YS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVk ZS9hc20vS2J1aWxkCmluZGV4IDkxMTViMjE1ZmM3ZS4uNTIzNTFkM2ZkMzZlIDEwMDY0NAotLS0g YS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL2JsYWNrZmluL2lu Y2x1ZGUvYXNtL0tidWlsZApAQCAtNTAsMyArNTAsNCBAQCBnZW5lcmljLXkgKz0geG9yLmgKIGdl bmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCiBnZW5lcmlj LXkgKz0gdGFibGVzLmgKK2dlbmVyaWMteSArPSBrcHJvYmVzLmgKZGlmZiAtLWdpdCBhL2FyY2gv YzZ4L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvYzZ4L2luY2x1ZGUvYXNtL0tidWlsZAppbmRl eCBjZWRlMmE5NTBmYmYuLmM1NGY3Y2MxZjYzZSAxMDA2NDQKLS0tIGEvYXJjaC9jNngvaW5jbHVk ZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvYzZ4L2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNjQsMyAr NjQsNCBAQCBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2VuZXJpYy15ICs9IHhvci5o CiBnZW5lcmljLXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAorZ2Vu ZXJpYy15ICs9IGtwcm9iZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9jcmlzL2luY2x1ZGUvYXNtL0ti dWlsZCBiL2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQKaW5kZXggNzA2MmMxYmU3OTEzLi4w NTFkMzU1ZmVhZTMgMTAwNjQ0Ci0tLSBhL2FyY2gvY3Jpcy9pbmNsdWRlL2FzbS9LYnVpbGQKKysr IGIvYXJjaC9jcmlzL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNDgsMyArNDgsNCBAQCBnZW5lcmlj LXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJh bmdlcy5oCiBnZW5lcmljLXkgKz0gdGFibGVzLmgKK2dlbmVyaWMteSArPSBrcHJvYmVzLmgKZGlm ZiAtLWdpdCBhL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvZnJ2L2luY2x1ZGUv YXNtL0tidWlsZAppbmRleCA0YTU5Y2JkYTUwOTEuLmI1OGI5ZmM0OTM4MyAxMDA2NDQKLS0tIGEv YXJjaC9mcnYvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvZnJ2L2luY2x1ZGUvYXNtL0ti dWlsZApAQCAtMTEsMyArMTEsNCBAQCBnZW5lcmljLXkgKz0gd29yZC1hdC1hLXRpbWUuaAogZ2Vu ZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKIGdlbmVyaWMt eSArPSB0YWJsZXMuaAorZ2VuZXJpYy15ICs9IGtwcm9iZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9o ODMwMC9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL2g4MzAwL2luY2x1ZGUvYXNtL0tidWlsZApp bmRleCBkNzk5NjhkOTNjMTIuLmNmY2E3ZGU1MmIzNyAxMDA2NDQKLS0tIGEvYXJjaC9oODMwMC9p bmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9oODMwMC9pbmNsdWRlL2FzbS9LYnVpbGQKQEAg LTc4LDMgKzc4LDQgQEAgZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkgKz0gc2VjdGlvbi1j b3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAogZ2VuZXJpYy15ICs9IHRhYmxlcy5oCitnZW5l cmljLXkgKz0ga3Byb2Jlcy5oCmRpZmYgLS1naXQgYS9hcmNoL2hleGFnb24vaW5jbHVkZS9hc20v S2J1aWxkIGIvYXJjaC9oZXhhZ29uL2luY2x1ZGUvYXNtL0tidWlsZAppbmRleCBkNTlhYzFjMTg1 OGIuLmQ3Y2MzNTQ1MWYzMCAxMDA2NDQKLS0tIGEvYXJjaC9oZXhhZ29uL2luY2x1ZGUvYXNtL0ti dWlsZAorKysgYi9hcmNoL2hleGFnb24vaW5jbHVkZS9hc20vS2J1aWxkCkBAIC02MywzICs2Myw0 IEBAIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBnZW5l cmljLXkgKz0gcmFuZ2VzLmgKIGdlbmVyaWMteSArPSB0YWJsZXMuaAorZ2VuZXJpYy15ICs9IGtw cm9iZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9pYTY0L2luY2x1ZGUvYXNtL2twcm9iZXMuaCBiL2Fy Y2gvaWE2NC9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKaW5kZXggZDU1MDVkNmYyMzgyLi4wMzAyYjM2 NjQ3ODkgMTAwNjQ0Ci0tLSBhL2FyY2gvaWE2NC9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKKysrIGIv YXJjaC9pYTY0L2luY2x1ZGUvYXNtL2twcm9iZXMuaApAQCAtMjMsMTQgKzIzLDE5IEBACiAgKiAy MDA1LUFwciAgICAgUnVzdHkgTHluY2ggPHJ1c3R5Lmx5bmNoQGludGVsLmNvbT4gYW5kIEFuaWwg UyBLZXNoYXZhbXVydGh5CiAgKiAgICAgICAgICAgICAgPGFuaWwucy5rZXNoYXZhbXVydGh5QGlu dGVsLmNvbT4gYWRhcHRlZCBmcm9tIGkzODYKICAqLworI2luY2x1ZGUgPGFzbS1nZW5lcmljL2tw cm9iZXMuaD4KKyNpbmNsdWRlIDxhc20vYnJlYWsuaD4KKworI2RlZmluZSBCUkVBS19JTlNUCShs b25nKShfX0lBNjRfQlJFQUtfS1BST0JFIDw8IDYpCisKKyNpZmRlZiBDT05GSUdfS1BST0JFUwor CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9wdHJhY2UuaD4KICNp bmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KLSNpbmNsdWRlIDxhc20vYnJlYWsuaD4KIAogI2RlZmlu ZSBfX0FSQ0hfV0FOVF9LUFJPQkVTX0lOU05fU0xPVAogI2RlZmluZSBNQVhfSU5TTl9TSVpFICAg MgkvKiBsYXN0IGhhbGYgaXMgZm9yIGtwcm9iZS1ib29zdGVyICovCi0jZGVmaW5lIEJSRUFLX0lO U1QJKGxvbmcpKF9fSUE2NF9CUkVBS19LUFJPQkUgPDwgNikKICNkZWZpbmUgTk9QX01fSU5TVAko bG9uZykoMTw8MjcpCiAjZGVmaW5lIEJSTF9JTlNUKGkxLCBpMikgKChsb25nKSgoMHhjTCA8PCAz NykgfAkvKiBicmwgKi8gXAogCQkJCSgweDFMIDw8IDEyKSB8CS8qIG1hbnkgKi8gXApAQCAtMTI0 LDQgKzEyOSw1IEBAIGV4dGVybiB2b2lkIGludmFsaWRhdGVfc3RhY2tlZF9yZWdzKHZvaWQpOwog ZXh0ZXJuIHZvaWQgZmx1c2hfcmVnaXN0ZXJfc3RhY2sodm9pZCk7CiBleHRlcm4gdm9pZCBhcmNo X3JlbW92ZV9rcHJvYmUoc3RydWN0IGtwcm9iZSAqcCk7CiAKLSNlbmRpZgkJCQkvKiBfQVNNX0tQ Uk9CRVNfSCAqLworI2VuZGlmIC8qIENPTkZJR19LUFJPQkVTICovCisjZW5kaWYgLyogX0FTTV9L UFJPQkVTX0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9pbmNsdWRlL2FzbS9LYnVpbGQgYi9h cmNoL20zMnIvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDI0MDg4ZjNjNzMzYy4uMTk4YWQ1OTFh YjQxIDEwMDY0NAotLS0gYS9hcmNoL20zMnIvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gv bTMyci9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTE0LDMgKzE0LDQgQEAgZ2VuZXJpYy15ICs9IHdv cmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9 IHJhbmdlcy5oCiBnZW5lcmljLXkgKz0gdGFibGVzLmgKK2dlbmVyaWMteSArPSBrcHJvYmVzLmgK ZGlmZiAtLWdpdCBhL2FyY2gvbTY4ay9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL202OGsvaW5j bHVkZS9hc20vS2J1aWxkCmluZGV4IGMyOGJjZGVjYzc2NC4uNDEyZGQyM2FiOTQ2IDEwMDY0NAot LS0gYS9hcmNoL202OGsvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvbTY4ay9pbmNsdWRl L2FzbS9LYnVpbGQKQEAgLTM3LDMgKzM3LDQgQEAgZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmlj LXkgKz0gc2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAogZ2VuZXJpYy15ICs9 IHRhYmxlcy5oCitnZW5lcmljLXkgKz0ga3Byb2Jlcy5oCmRpZmYgLS1naXQgYS9hcmNoL21ldGFn L2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbWV0YWcvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4 IGM4MzZmN2UyYTVlNy4uODM3MWNjOWIxYjNjIDEwMDY0NAotLS0gYS9hcmNoL21ldGFnL2luY2x1 ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL21ldGFnL2luY2x1ZGUvYXNtL0tidWlsZApAQCAtNTgs MyArNTgsNCBAQCBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUu aAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCiBnZW5lcmljLXkgKz0gdGFibGVzLmgKK2dlbmVyaWMt eSArPSBrcHJvYmVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9L YnVpbGQgYi9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IDAxYWZiMWI0 MjBmNS4uODY1Y2UzZDk2NDQzIDEwMDY0NAotLS0gYS9hcmNoL21pY3JvYmxhemUvaW5jbHVkZS9h c20vS2J1aWxkCisrKyBiL2FyY2gvbWljcm9ibGF6ZS9pbmNsdWRlL2FzbS9LYnVpbGQKQEAgLTE0 LDMgKzE0LDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVyaWMteSArPSBz ZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCiBnZW5lcmljLXkgKz0gdGFibGVz LmgKK2dlbmVyaWMteSArPSBrcHJvYmVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvbWlwcy9pbmNsdWRl L2FzbS9rcHJvYmVzLmggYi9hcmNoL21pcHMvaW5jbHVkZS9hc20va3Byb2Jlcy5oCmluZGV4IGRh YmExZjlhNGY3OS4uMjkxODQ2ZDliYTgzIDEwMDY0NAotLS0gYS9hcmNoL21pcHMvaW5jbHVkZS9h c20va3Byb2Jlcy5oCisrKyBiL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKQEAgLTIy LDYgKzIyLDkgQEAKICNpZm5kZWYgX0FTTV9LUFJPQkVTX0gKICNkZWZpbmUgX0FTTV9LUFJPQkVT X0gKIAorI2luY2x1ZGUgPGFzbS1nZW5lcmljL2twcm9iZXMuaD4KKworI2lmZGVmIENPTkZJR19L UFJPQkVTCiAjaW5jbHVkZSA8bGludXgvcHRyYWNlLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMu aD4KIApAQCAtOTQsNCArOTcsNSBAQCBzdHJ1Y3Qga3Byb2JlX2N0bGJsayB7CiBleHRlcm4gaW50 IGtwcm9iZV9leGNlcHRpb25zX25vdGlmeShzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKnNlbGYsCiAJ CQkJICAgIHVuc2lnbmVkIGxvbmcgdmFsLCB2b2lkICpkYXRhKTsKIAotI2VuZGlmCQkJCS8qIF9B U01fS1BST0JFU19IICovCisjZW5kaWYgLyogQ09ORklHX0tQUk9CRVMgKi8KKyNlbmRpZiAvKiBf QVNNX0tQUk9CRVNfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL2tw cm9iZXMuaCBiL2FyY2gvbW4xMDMwMC9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKaW5kZXggYzgwMGI1 OTAxODNhLi43YWJlYTBiZGI1NDkgMTAwNjQ0Ci0tLSBhL2FyY2gvbW4xMDMwMC9pbmNsdWRlL2Fz bS9rcHJvYmVzLmgKKysrIGIvYXJjaC9tbjEwMzAwL2luY2x1ZGUvYXNtL2twcm9iZXMuaApAQCAt MjEsMTMgKzIxLDE3IEBACiAjaWZuZGVmIF9BU01fS1BST0JFU19ICiAjZGVmaW5lIF9BU01fS1BS T0JFU19ICiAKKyNpbmNsdWRlIDxhc20tZ2VuZXJpYy9rcHJvYmVzLmg+CisKKyNkZWZpbmUgQlJF QUtQT0lOVF9JTlNUUlVDVElPTgkweGZmCisKKyNpZmRlZiBDT05GSUdfS1BST0JFUwogI2luY2x1 ZGUgPGxpbnV4L3R5cGVzLmg+CiAjaW5jbHVkZSA8bGludXgvcHRyYWNlLmg+CiAKIHN0cnVjdCBr cHJvYmU7CiAKIHR5cGVkZWYgdW5zaWduZWQgY2hhciBrcHJvYmVfb3Bjb2RlX3Q7Ci0jZGVmaW5l IEJSRUFLUE9JTlRfSU5TVFJVQ1RJT04JMHhmZgogI2RlZmluZSBNQVhfSU5TTl9TSVpFIDgKICNk ZWZpbmUgTUFYX1NUQUNLX1NJWkUgMTI4CiAKQEAgLTQ3LDQgKzUxLDUgQEAgZXh0ZXJuIGludCBr cHJvYmVfZXhjZXB0aW9uc19ub3RpZnkoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpzZWxmLAogCiBl eHRlcm4gdm9pZCBhcmNoX3JlbW92ZV9rcHJvYmUoc3RydWN0IGtwcm9iZSAqcCk7CiAKKyNlbmRp ZiAvKiBDT05GSUdfS1BST0JFUyAqLwogI2VuZGlmIC8qIF9BU01fS1BST0JFU19IICovCmRpZmYg LS1naXQgYS9hcmNoL25pb3MyL2luY2x1ZGUvYXNtL0tidWlsZCBiL2FyY2gvbmlvczIvaW5jbHVk ZS9hc20vS2J1aWxkCmluZGV4IGVlNjIyMGRhYzFlOC4uZDZjZTdlZGVlN2UwIDEwMDY0NAotLS0g YS9hcmNoL25pb3MyL2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL25pb3MyL2luY2x1ZGUv YXNtL0tidWlsZApAQCAtNjYsMyArNjYsNCBAQCBnZW5lcmljLXkgKz0geG9yLmgKIGdlbmVyaWMt eSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCiBnZW5lcmljLXkgKz0g dGFibGVzLmgKK2dlbmVyaWMteSArPSBrcHJvYmVzLmgKZGlmZiAtLWdpdCBhL2FyY2gvb3BlbnJp c2MvaW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC9vcGVucmlzYy9pbmNsdWRlL2FzbS9LYnVpbGQK aW5kZXggY2VhZmU0NThlMjk1Li4xYmY4OWE2NzMxN2MgMTAwNjQ0Ci0tLSBhL2FyY2gvb3BlbnJp c2MvaW5jbHVkZS9hc20vS2J1aWxkCisrKyBiL2FyY2gvb3BlbnJpc2MvaW5jbHVkZS9hc20vS2J1 aWxkCkBAIC03NCwzICs3NCw0IEBAIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNl Y3Rpb24tY29yZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKIGdlbmVyaWMteSArPSB0YWJsZXMu aAorZ2VuZXJpYy15ICs9IGtwcm9iZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9wYXJpc2MvaW5jbHVk ZS9hc20vS2J1aWxkIGIvYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4IGFhYWU4 YTlmNjA5OS4uMTlkNWI3ZTEyZWNmIDEwMDY0NAotLS0gYS9hcmNoL3BhcmlzYy9pbmNsdWRlL2Fz bS9LYnVpbGQKKysrIGIvYXJjaC9wYXJpc2MvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0zMSwzICsz MSw0IEBAIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29yZS5oCiBn ZW5lcmljLXkgKz0gcmFuZ2VzLmgKIGdlbmVyaWMteSArPSB0YWJsZXMuaAorZ2VuZXJpYy15ICs9 IGtwcm9iZXMuaApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2twcm9iZXMu aCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKaW5kZXggOTdiOGMxZjgzNDUz Li5jN2VlM2ZjYmQ2ZTIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9rcHJv YmVzLmgKKysrIGIvYXJjaC9wb3dlcnBjL2luY2x1ZGUvYXNtL2twcm9iZXMuaApAQCAtMSw1ICsx LDggQEAKICNpZm5kZWYgX0FTTV9QT1dFUlBDX0tQUk9CRVNfSAogI2RlZmluZSBfQVNNX1BPV0VS UENfS1BST0JFU19ICisKKyNpbmNsdWRlIDxhc20tZ2VuZXJpYy9rcHJvYmVzLmg+CisKICNpZmRl ZiBfX0tFUk5FTF9fCiAvKgogICogIEtlcm5lbCBQcm9iZXMgKEtQcm9iZXMpCmRpZmYgLS1naXQg YS9hcmNoL3MzOTAvaW5jbHVkZS9hc20va3Byb2Jlcy5oIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNt L2twcm9iZXMuaAppbmRleCA1OTFlNWE1Mjc5YjAuLjg0YzBmOTA4NjQ4MyAxMDA2NDQKLS0tIGEv YXJjaC9zMzkwL2luY2x1ZGUvYXNtL2twcm9iZXMuaAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9h c20va3Byb2Jlcy5oCkBAIC0yNyw2ICsyNywxMSBAQAogICogMjAwNS1EZWMJVXNlZCBhcyBhIHRl bXBsYXRlIGZvciBzMzkwIGJ5IE1pa2UgR3J1bmR5CiAgKgkJPGdydW5keW1AdXMuaWJtLmNvbT4K ICAqLworI2luY2x1ZGUgPGFzbS1nZW5lcmljL2twcm9iZXMuaD4KKworI2RlZmluZSBCUkVBS1BP SU5UX0lOU1RSVUNUSU9OCTB4MDAwMgorCisjaWZkZWYgQ09ORklHX0tQUk9CRVMKICNpbmNsdWRl IDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5oPgogI2luY2x1ZGUgPGxp bnV4L3BlcmNwdS5oPgpAQCAtMzcsNyArNDIsNiBAQCBzdHJ1Y3QgcHRfcmVnczsKIHN0cnVjdCBr cHJvYmU7CiAKIHR5cGVkZWYgdTE2IGtwcm9iZV9vcGNvZGVfdDsKLSNkZWZpbmUgQlJFQUtQT0lO VF9JTlNUUlVDVElPTgkweDAwMDIKIAogLyogTWF4aW11bSBpbnN0cnVjdGlvbiBzaXplIGlzIDMg KDE2Yml0KSBoYWxmd29yZHM6ICovCiAjZGVmaW5lIE1BWF9JTlNOX1NJWkUJCTB4MDAwMwpAQCAt OTEsNCArOTUsNSBAQCBpbnQgcHJvYmVfaXNfaW5zbl9yZWxhdGl2ZV9sb25nKHUxNiAqaW5zbik7 CiAKICNkZWZpbmUgZmx1c2hfaW5zbl9zbG90KHApCWRvIHsgfSB3aGlsZSAoMCkKIAorI2VuZGlm IC8qIENPTkZJR19LUFJPQkVTICovCiAjZW5kaWYJLyogX0FTTV9TMzkwX0tQUk9CRVNfSCAqLwpk aWZmIC0tZ2l0IGEvYXJjaC9zY29yZS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3Njb3JlL2lu Y2x1ZGUvYXNtL0tidWlsZAppbmRleCAxNmVhMTVhM2U0MzIuLjZhYzhhN2Y1Yzc2OCAxMDA2NDQK LS0tIGEvYXJjaC9zY29yZS9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC9zY29yZS9pbmNs dWRlL2FzbS9LYnVpbGQKQEAgLTE3LDMgKzE3LDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10 aW1lLmgKIGdlbmVyaWMteSArPSBzZWN0aW9uLWNvcmUuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5o CiBnZW5lcmljLXkgKz0gdGFibGVzLmgKK2dlbmVyaWMteSArPSBrcHJvYmVzLmgKZGlmZiAtLWdp dCBhL2FyY2gvc2gvaW5jbHVkZS9hc20va3Byb2Jlcy5oIGIvYXJjaC9zaC9pbmNsdWRlL2FzbS9r cHJvYmVzLmgKaW5kZXggMTM0ZjM5ODBlNDRhLi5mMDk4NmY5YjM4NDQgMTAwNjQ0Ci0tLSBhL2Fy Y2gvc2gvaW5jbHVkZS9hc20va3Byb2Jlcy5oCisrKyBiL2FyY2gvc2gvaW5jbHVkZS9hc20va3By b2Jlcy5oCkBAIC0xLDEzICsxLDE2IEBACiAjaWZuZGVmIF9fQVNNX1NIX0tQUk9CRVNfSAogI2Rl ZmluZSBfX0FTTV9TSF9LUFJPQkVTX0gKIAorI2luY2x1ZGUgPGFzbS1nZW5lcmljL2twcm9iZXMu aD4KKworI2RlZmluZSBCUkVBS1BPSU5UX0lOU1RSVUNUSU9OCTB4YzMzYQorCiAjaWZkZWYgQ09O RklHX0tQUk9CRVMKIAogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiAjaW5jbHVkZSA8bGludXgv cHRyYWNlLmg+CiAKIHR5cGVkZWYgaW5zbl9zaXplX3Qga3Byb2JlX29wY29kZV90OwotI2RlZmlu ZSBCUkVBS1BPSU5UX0lOU1RSVUNUSU9OCTB4YzMzYQogCiAjZGVmaW5lIE1BWF9JTlNOX1NJWkUg MTYKICNkZWZpbmUgTUFYX1NUQUNLX1NJWkUgNjQKZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMvaW5j bHVkZS9hc20va3Byb2Jlcy5oIGIvYXJjaC9zcGFyYy9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKaW5k ZXggYTE0NWQ3OThlMTEyLi40OWY4NDAyMDM1ZDcgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMvaW5j bHVkZS9hc20va3Byb2Jlcy5oCisrKyBiL2FyY2gvc3BhcmMvaW5jbHVkZS9hc20va3Byb2Jlcy5o CkBAIC0xLDEzICsxLDE3IEBACiAjaWZuZGVmIF9TUEFSQzY0X0tQUk9CRVNfSAogI2RlZmluZSBf U1BBUkM2NF9LUFJPQkVTX0gKIAorI2luY2x1ZGUgPGFzbS1nZW5lcmljL2twcm9iZXMuaD4KKwor I2RlZmluZSBCUkVBS1BPSU5UX0lOU1RSVUNUSU9OICAgMHg5MWQwMjA3MCAvKiB0YSAweDcwICov CisjZGVmaW5lIEJSRUFLUE9JTlRfSU5TVFJVQ1RJT05fMiAweDkxZDAyMDcxIC8qIHRhIDB4NzEg Ki8KKworI2lmZGVmIENPTkZJR19LUFJPQkVTCiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KICNp bmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KIAogdHlwZWRlZiB1MzIga3Byb2JlX29wY29kZV90Owog Ci0jZGVmaW5lIEJSRUFLUE9JTlRfSU5TVFJVQ1RJT04gICAweDkxZDAyMDcwIC8qIHRhIDB4NzAg Ki8KLSNkZWZpbmUgQlJFQUtQT0lOVF9JTlNUUlVDVElPTl8yIDB4OTFkMDIwNzEgLyogdGEgMHg3 MSAqLwogI2RlZmluZSBNQVhfSU5TTl9TSVpFIDIKIAogI2RlZmluZSBrcmV0cHJvYmVfYmxhY2ts aXN0X3NpemUgMApAQCAtNDgsNCArNTIsNiBAQCBpbnQga3Byb2JlX2V4Y2VwdGlvbnNfbm90aWZ5 KHN0cnVjdCBub3RpZmllcl9ibG9jayAqc2VsZiwKIGludCBrcHJvYmVfZmF1bHRfaGFuZGxlcihz dHJ1Y3QgcHRfcmVncyAqcmVncywgaW50IHRyYXBucik7CiBhc21saW5rYWdlIHZvaWQgX19rcHJv YmVzIGtwcm9iZV90cmFwKHVuc2lnbmVkIGxvbmcgdHJhcF9sZXZlbCwKIAkJCQkgICAgICBzdHJ1 Y3QgcHRfcmVncyAqcmVncyk7CisKKyNlbmRpZiAvKiBDT05GSUdfS1BST0JFUyAqLwogI2VuZGlm IC8qIF9TUEFSQzY0X0tQUk9CRVNfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC90aWxlL2luY2x1ZGUv YXNtL2twcm9iZXMuaCBiL2FyY2gvdGlsZS9pbmNsdWRlL2FzbS9rcHJvYmVzLmgKaW5kZXggZDhm OWE4Mzk0M2IxLi40YThiMWNhZGNhMjQgMTAwNjQ0Ci0tLSBhL2FyY2gvdGlsZS9pbmNsdWRlL2Fz bS9rcHJvYmVzLmgKKysrIGIvYXJjaC90aWxlL2luY2x1ZGUvYXNtL2twcm9iZXMuaApAQCAtMTcs MTAgKzE3LDEzIEBACiAjaWZuZGVmIF9BU01fVElMRV9LUFJPQkVTX0gKICNkZWZpbmUgX0FTTV9U SUxFX0tQUk9CRVNfSAogCisjaW5jbHVkZSA8YXNtLWdlbmVyaWMva3Byb2Jlcy5oPgorCisjaWZk ZWYgQ09ORklHX0tQUk9CRVMKKwogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CiAjaW5jbHVkZSA8 bGludXgvcHRyYWNlLmg+CiAjaW5jbHVkZSA8bGludXgvcGVyY3B1Lmg+Ci0KICNpbmNsdWRlIDxh cmNoL29wY29kZS5oPgogCiAjZGVmaW5lIF9fQVJDSF9XQU5UX0tQUk9CRVNfSU5TTl9TTE9UCkBA IC03Niw0ICs3OSw1IEBAIHZvaWQgYXJjaF9yZW1vdmVfa3Byb2JlKHN0cnVjdCBrcHJvYmUgKik7 CiBleHRlcm4gaW50IGtwcm9iZV9leGNlcHRpb25zX25vdGlmeShzdHJ1Y3Qgbm90aWZpZXJfYmxv Y2sgKnNlbGYsCiAJCQkgICAgIHVuc2lnbmVkIGxvbmcgdmFsLCB2b2lkICpkYXRhKTsKIAorI2Vu ZGlmIC8qIENPTkZJR19LUFJPQkVTICovCiAjZW5kaWYgLyogX0FTTV9USUxFX0tQUk9CRVNfSCAq LwpkaWZmIC0tZ2l0IGEvYXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3VtL2luY2x1 ZGUvYXNtL0tidWlsZAppbmRleCBkMjg2N2FhMDllMjMuLmNjYzVmZmVhZWVmNSAxMDA2NDQKLS0t IGEvYXJjaC91bS9pbmNsdWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC91bS9pbmNsdWRlL2FzbS9L YnVpbGQKQEAgLTI5LDMgKzI5LDQgQEAgZ2VuZXJpYy15ICs9IHhvci5oCiBnZW5lcmljLXkgKz0g c2VjdGlvbi1jb3JlLmgKIGdlbmVyaWMteSArPSByYW5nZXMuaAogZ2VuZXJpYy15ICs9IHRhYmxl cy5oCitnZW5lcmljLXkgKz0ga3Byb2Jlcy5oCmRpZmYgLS1naXQgYS9hcmNoL3VuaWNvcmUzMi9p bmNsdWRlL2FzbS9LYnVpbGQgYi9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9LYnVpbGQKaW5k ZXggNjY3MWExZjA4ZWFkLi41YWFjYWZiNmQzODUgMTAwNjQ0Ci0tLSBhL2FyY2gvdW5pY29yZTMy L2luY2x1ZGUvYXNtL0tidWlsZAorKysgYi9hcmNoL3VuaWNvcmUzMi9pbmNsdWRlL2FzbS9LYnVp bGQKQEAgLTYzLDMgKzYzLDQgQEAgZ2VuZXJpYy15ICs9IHdvcmQtYXQtYS10aW1lLmgKIGdlbmVy aWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHJhbmdlcy5oCiBnZW5lcmljLXkgKz0gdGFibGVz LmgKK2dlbmVyaWMteSArPSBrcHJvYmVzLmgKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUv YXNtL2twcm9iZXMuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2twcm9iZXMuaAppbmRleCBkMWQx ZTUwOTRjMjguLjIwMDU4MTY5MWM2ZSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20v a3Byb2Jlcy5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL2twcm9iZXMuaApAQCAtMjEsNiAr MjEsMTIgQEAKICAqCiAgKiBTZWUgYXJjaC94ODYva2VybmVsL2twcm9iZXMuYyBmb3IgeDg2IGtw cm9iZXMgaGlzdG9yeS4KICAqLworCisjaW5jbHVkZSA8YXNtLWdlbmVyaWMva3Byb2Jlcy5oPgor CisjZGVmaW5lIEJSRUFLUE9JTlRfSU5TVFJVQ1RJT04JMHhjYworCisjaWZkZWYgQ09ORklHX0tQ Uk9CRVMKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L3B0cmFjZS5o PgogI2luY2x1ZGUgPGxpbnV4L3BlcmNwdS5oPgpAQCAtMzIsNyArMzgsNiBAQCBzdHJ1Y3QgcHRf cmVnczsKIHN0cnVjdCBrcHJvYmU7CiAKIHR5cGVkZWYgdTgga3Byb2JlX29wY29kZV90OwotI2Rl ZmluZSBCUkVBS1BPSU5UX0lOU1RSVUNUSU9OCTB4Y2MKICNkZWZpbmUgUkVMQVRJVkVKVU1QX09Q Q09ERSAweGU5CiAjZGVmaW5lIFJFTEFUSVZFSlVNUF9TSVpFIDUKICNkZWZpbmUgUkVMQVRJVkVD QUxMX09QQ09ERSAweGU4CkBAIC0xMTYsNCArMTIxLDYgQEAgZXh0ZXJuIGludCBrcHJvYmVfZXhj ZXB0aW9uc19ub3RpZnkoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpzZWxmLAogCQkJCSAgICB1bnNp Z25lZCBsb25nIHZhbCwgdm9pZCAqZGF0YSk7CiBleHRlcm4gaW50IGtwcm9iZV9pbnQzX2hhbmRs ZXIoc3RydWN0IHB0X3JlZ3MgKnJlZ3MpOwogZXh0ZXJuIGludCBrcHJvYmVfZGVidWdfaGFuZGxl cihzdHJ1Y3QgcHRfcmVncyAqcmVncyk7CisKKyNlbmRpZiAvKiBDT05GSUdfS1BST0JFUyAqLwog I2VuZGlmIC8qIF9BU01fWDg2X0tQUk9CRVNfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC94dGVuc2Ev aW5jbHVkZS9hc20vS2J1aWxkIGIvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vS2J1aWxkCmluZGV4 IDdiNDFmMzJhMmJhMC4uMjBmNTI0ZGVkMDBlIDEwMDY0NAotLS0gYS9hcmNoL3h0ZW5zYS9pbmNs dWRlL2FzbS9LYnVpbGQKKysrIGIvYXJjaC94dGVuc2EvaW5jbHVkZS9hc20vS2J1aWxkCkBAIC0z NSwzICszNSw0IEBAIGdlbmVyaWMteSArPSB4b3IuaAogZ2VuZXJpYy15ICs9IHNlY3Rpb24tY29y ZS5oCiBnZW5lcmljLXkgKz0gcmFuZ2VzLmgKIGdlbmVyaWMteSArPSB0YWJsZXMuaAorZ2VuZXJp Yy15ICs9IGtwcm9iZXMuaApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9hc20tZ2VuZXJpYy9rcHJvYmVz LmggYi9pbmNsdWRlL2FzbS1nZW5lcmljL2twcm9iZXMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAuLjU3YWY5ZjIxZDE0OAotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1 ZGUvYXNtLWdlbmVyaWMva3Byb2Jlcy5oCkBAIC0wLDAgKzEsMjUgQEAKKyNpZm5kZWYgX0FTTV9H RU5FUklDX0tQUk9CRVNfSAorI2RlZmluZSBfQVNNX0dFTkVSSUNfS1BST0JFU19ICisKKyNpZiBk ZWZpbmVkKF9fS0VSTkVMX18pICYmICFkZWZpbmVkKF9fQVNTRU1CTFlfXykKKyNpZmRlZiBDT05G SUdfS1BST0JFUworLyoKKyAqIEJsYWNrbGlzdCBnYW5lcmF0aW5nIG1hY3JvLiBTcGVjaWZ5IGZ1 bmN0aW9ucyB3aGljaCBpcyBub3QgcHJvYmVkCisgKiBieSB1c2luZyB0aGlzIG1hY3JvLgorICov CisjIGRlZmluZSBfX05PS1BST0JFX1NZTUJPTChmbmFtZSkJCQkJXAorc3RhdGljIHVuc2lnbmVk IGxvbmcgX191c2VkCQkJCQlcCisJX19hdHRyaWJ1dGVfXygoX19zZWN0aW9uX18oIl9rcHJvYmVf YmxhY2tsaXN0IikpKQlcCisJX2tibF9hZGRyXyMjZm5hbWUgPSAodW5zaWduZWQgbG9uZylmbmFt ZTsKKyMgZGVmaW5lIE5PS1BST0JFX1NZTUJPTChmbmFtZSkJX19OT0tQUk9CRV9TWU1CT0woZm5h bWUpCisvKiBVc2UgdGhpcyB0byBmb3JiaWQgYSBrcHJvYmVzIGF0dGFjaCBvbiB2ZXJ5IGxvdyBs ZXZlbCBmdW5jdGlvbnMgKi8KKyMgZGVmaW5lIF9fa3Byb2JlcwlfX2F0dHJpYnV0ZV9fKChfX3Nl Y3Rpb25fXygiLmtwcm9iZXMudGV4dCIpKSkKKyMgZGVmaW5lIG5va3Byb2JlX2lubGluZQlfX2Fs d2F5c19pbmxpbmUKKyNlbHNlCisjIGRlZmluZSBOT0tQUk9CRV9TWU1CT0woZm5hbWUpCisjIGRl ZmluZSBfX2twcm9iZXMKKyMgZGVmaW5lIG5va3Byb2JlX2lubGluZQlpbmxpbmUKKyNlbmRpZgor I2VuZGlmIC8qIGRlZmluZWQoX19LRVJORUxfXykgJiYgIWRlZmluZWQoX19BU1NFTUJMWV9fKSAq LworCisjZW5kaWYgLyogX0FTTV9HRU5FUklDX0tQUk9CRVNfSCAqLwpkaWZmIC0tZ2l0IGEvaW5j bHVkZS9saW51eC9jb21waWxlci5oIGIvaW5jbHVkZS9saW51eC9jb21waWxlci5oCmluZGV4IGNm MGZhNWQ4NjA1OS4uZGNhNDliNDA5OWRhIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2NvbXBp bGVyLmgKKysrIGIvaW5jbHVkZS9saW51eC9jb21waWxlci5oCkBAIC01NjYsMTIgKzU2Niw0IEBA IHN0YXRpYyBfX2Fsd2F5c19pbmxpbmUgdm9pZCBfX3dyaXRlX29uY2Vfc2l6ZSh2b2xhdGlsZSB2 b2lkICpwLCB2b2lkICpyZXMsIGludCBzCiAJKF9fX19fX19fX3AxKTsgXAogfSkKIAotLyogSWdu b3JlL2ZvcmJpZCBrcHJvYmVzIGF0dGFjaCBvbiB2ZXJ5IGxvdyBsZXZlbCBmdW5jdGlvbnMgbWFy a2VkIGJ5IHRoaXMgYXR0cmlidXRlOiAqLwotI2lmZGVmIENPTkZJR19LUFJPQkVTCi0jIGRlZmlu ZSBfX2twcm9iZXMJX19hdHRyaWJ1dGVfXygoX19zZWN0aW9uX18oIi5rcHJvYmVzLnRleHQiKSkp Ci0jIGRlZmluZSBub2twcm9iZV9pbmxpbmUJX19hbHdheXNfaW5saW5lCi0jZWxzZQotIyBkZWZp bmUgX19rcHJvYmVzCi0jIGRlZmluZSBub2twcm9iZV9pbmxpbmUJaW5saW5lCi0jZW5kaWYKICNl bmRpZiAvKiBfX0xJTlVYX0NPTVBJTEVSX0ggKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgv a3Byb2Jlcy5oIGIvaW5jbHVkZS9saW51eC9rcHJvYmVzLmgKaW5kZXggOGY2ODQ5MDg0MjQ4Li45 ODVlZDc5ZWY0MzEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgva3Byb2Jlcy5oCisrKyBiL2lu Y2x1ZGUvbGludXgva3Byb2Jlcy5oCkBAIC0yOSw3ICsyOSw3IEBACiAgKgkJPGprZW5pc3RvQHVz LmlibS5jb20+ICBhbmQgUHJhc2FubmEgUyBQYW5jaGFtdWtoaQogICoJCTxwcmFzYW5uYUBpbi5p Ym0uY29tPiBhZGRlZCBmdW5jdGlvbi1yZXR1cm4gcHJvYmVzLgogICovCi0jaW5jbHVkZSA8bGlu dXgvY29tcGlsZXIuaD4JLyogZm9yIF9fa3Byb2JlcyAqLworI2luY2x1ZGUgPGxpbnV4L2NvbXBp bGVyLmg+CiAjaW5jbHVkZSA8bGludXgvbGlua2FnZS5oPgogI2luY2x1ZGUgPGxpbnV4L2xpc3Qu aD4KICNpbmNsdWRlIDxsaW51eC9ub3RpZmllci5oPgpAQCAtNDAsOSArNDAsOSBAQAogI2luY2x1 ZGUgPGxpbnV4L3JjdXBkYXRlLmg+CiAjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KICNpbmNsdWRl IDxsaW51eC9mdHJhY2UuaD4KKyNpbmNsdWRlIDxhc20va3Byb2Jlcy5oPgogCiAjaWZkZWYgQ09O RklHX0tQUk9CRVMKLSNpbmNsdWRlIDxhc20va3Byb2Jlcy5oPgogCiAvKiBrcHJvYmVfc3RhdHVz IHNldHRpbmdzICovCiAjZGVmaW5lIEtQUk9CRV9ISVRfQUNUSVZFCTB4MDAwMDAwMDEKQEAgLTUx LDYgKzUxLDcgQEAKICNkZWZpbmUgS1BST0JFX0hJVF9TU0RPTkUJMHgwMDAwMDAwOAogCiAjZWxz ZSAvKiBDT05GSUdfS1BST0JFUyAqLworI2luY2x1ZGUgPGFzbS1nZW5lcmljL2twcm9iZXMuaD4K IHR5cGVkZWYgaW50IGtwcm9iZV9vcGNvZGVfdDsKIHN0cnVjdCBhcmNoX3NwZWNpZmljX2luc24g ewogCWludCBkdW1teTsKQEAgLTQ4MSwxOCArNDgyLDQgQEAgc3RhdGljIGlubGluZSBpbnQgZW5h YmxlX2pwcm9iZShzdHJ1Y3QganByb2JlICpqcCkKIAlyZXR1cm4gZW5hYmxlX2twcm9iZSgmanAt PmtwKTsKIH0KIAotI2lmZGVmIENPTkZJR19LUFJPQkVTCi0vKgotICogQmxhY2tsaXN0IGdhbmVy YXRpbmcgbWFjcm8uIFNwZWNpZnkgZnVuY3Rpb25zIHdoaWNoIGlzIG5vdCBwcm9iZWQKLSAqIGJ5 IHVzaW5nIHRoaXMgbWFjcm8uCi0gKi8KLSNkZWZpbmUgX19OT0tQUk9CRV9TWU1CT0woZm5hbWUp CQkJXAotc3RhdGljIHVuc2lnbmVkIGxvbmcgX191c2VkCQkJCVwKLQlfX2F0dHJpYnV0ZV9fKChz ZWN0aW9uKCJfa3Byb2JlX2JsYWNrbGlzdCIpKSkJXAotCV9rYmxfYWRkcl8jI2ZuYW1lID0gKHVu c2lnbmVkIGxvbmcpZm5hbWU7Ci0jZGVmaW5lIE5PS1BST0JFX1NZTUJPTChmbmFtZSkJX19OT0tQ Uk9CRV9TWU1CT0woZm5hbWUpCi0jZWxzZQotI2RlZmluZSBOT0tQUk9CRV9TWU1CT0woZm5hbWUp Ci0jZW5kaWYKLQogI2VuZGlmIC8qIF9MSU5VWF9LUFJPQkVTX0ggKi8KLS0gCjIuMTEuMAoKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBt YWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cHM6Ly9saXN0cy54ZW4ub3Jn L3hlbi1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:53492 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S933426AbdAIO7j (ORCPT ); Mon, 9 Jan 2017 09:59:39 -0500 From: "Luis R. Rodriguez" Subject: [PATCH v6 11/14] kprobes: move kprobe declarations to asm-generic/kprobes.h Date: Mon, 9 Jan 2017 06:58:29 -0800 Message-ID: <20170109145833.11502-12-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: <20170109145829.o3dOmdnPn3cVBLZ6ts6EMZoSvuZa8KsBx8iA8BHq0P8@z> Often all is needed is these small helpers, instead of compiler.h or a full kprobes.h. This is important for asm helpers, in fact even some asm/kprobes.h make use of these helpers... instead just keep a generic asm file with helpers useful for asm code with the least amount of clutter as possible. Likewise we need now to also address what to do about this file for both when architectures have CONFIG_HAVE_KPROBES, and when they do not. Then for when architectures have CONFIG_HAVE_KPROBES but have disabled CONFIG_KPROBES. Right now most asm/kprobes.h do not have guards against CONFIG_KPROBES, this means most architecture code cannot include asm/kprobes.h safely. Correct this and add guards for architectures missing them. Additionally provide architectures that not have kprobes support with the default asm-generic solution. This lets us force asm/kprobes.h on the header include/linux/kprobes.h always, but most importantly we can now safely include just asm/kprobes.h on architecture code without bringing the full kitchen sink of header files. Two architectures already provided a guard against CONFIG_KPROBES on its kprobes.h: sh, arch. The rest of the architectures needed gaurds added. We avoid including any not-needed headers on asm/kprobes.h unless kprobes have been enabled. In a subsequent atomic change we can try now to remove compiler.h from include/linux/kprobes.h. During this sweep I've also identified a few architectures defining a common macro needed for both kprobes and ftrace, that of the definition of the breakput instruction up. Some refer to this as BREAKPOINT_INSTRUCTION. This must be kept outside of the #ifdef CONFIG_KPROBES guard. v5: o fix BREAKPOINT_INSTRUCTION dependency with kernel architecture ftrace implementations: Although its correct to #ifdef CONFIG_KPROBES on the architecture arch/$(ARCH)/include/asm/kprobes.h when architectures support ftrace they will rely on the BREAKPOINT_INSTRUCTION definition, this needs to be kept out from CONFIG_KPROBES as ftrace can be enabled without kprobes. This fixes compilation on x86 where kprobes is disabled but ftrace is left enabled. o include on arch/arm64/kernel/probes/decode-insn.h v4: introduced this patch into the series Signed-off-by: Luis R. Rodriguez --- arch/alpha/include/asm/Kbuild | 1 + arch/arc/include/asm/kprobes.h | 6 ++++-- arch/arm/include/asm/kprobes.h | 4 ++++ arch/arm/probes/decode.h | 1 + arch/arm64/include/asm/kprobes.h | 4 ++++ arch/arm64/kernel/insn.c | 1 + arch/arm64/kernel/probes/decode-insn.h | 2 ++ arch/avr32/include/asm/kprobes.h | 7 ++++++- 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/kprobes.h | 12 +++++++++--- 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/kprobes.h | 6 +++++- arch/mn10300/include/asm/kprobes.h | 7 ++++++- arch/nios2/include/asm/Kbuild | 1 + arch/openrisc/include/asm/Kbuild | 1 + arch/parisc/include/asm/Kbuild | 1 + arch/powerpc/include/asm/kprobes.h | 3 +++ arch/s390/include/asm/kprobes.h | 7 ++++++- arch/score/include/asm/Kbuild | 1 + arch/sh/include/asm/kprobes.h | 5 ++++- arch/sparc/include/asm/kprobes.h | 10 ++++++++-- arch/tile/include/asm/kprobes.h | 6 +++++- arch/um/include/asm/Kbuild | 1 + arch/unicore32/include/asm/Kbuild | 1 + arch/x86/include/asm/kprobes.h | 9 ++++++++- arch/xtensa/include/asm/Kbuild | 1 + include/asm-generic/kprobes.h | 25 +++++++++++++++++++++++++ include/linux/compiler.h | 8 -------- include/linux/kprobes.h | 19 +++---------------- 37 files changed, 122 insertions(+), 38 deletions(-) create mode 100644 include/asm-generic/kprobes.h diff --git a/arch/alpha/include/asm/Kbuild b/arch/alpha/include/asm/Kbuild index f3bdc31d3c97..54d388fd026f 100644 --- a/arch/alpha/include/asm/Kbuild +++ b/arch/alpha/include/asm/Kbuild @@ -13,3 +13,4 @@ generic-y += trace_clock.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/arc/include/asm/kprobes.h b/arch/arc/include/asm/kprobes.h index 944dbedb38b5..00bdbe167615 100644 --- a/arch/arc/include/asm/kprobes.h +++ b/arch/arc/include/asm/kprobes.h @@ -9,6 +9,8 @@ #ifndef _ARC_KPROBES_H #define _ARC_KPROBES_H +#include + #ifdef CONFIG_KPROBES typedef u16 kprobe_opcode_t; @@ -55,6 +57,6 @@ void trap_is_kprobe(unsigned long address, struct pt_regs *regs); static void trap_is_kprobe(unsigned long address, struct pt_regs *regs) { } -#endif +#endif /* CONFIG_KPROBES */ -#endif +#endif /* _ARC_KPROBES_H */ diff --git a/arch/arm/include/asm/kprobes.h b/arch/arm/include/asm/kprobes.h index 3ea9be559726..59655459da59 100644 --- a/arch/arm/include/asm/kprobes.h +++ b/arch/arm/include/asm/kprobes.h @@ -16,6 +16,9 @@ #ifndef _ARM_KPROBES_H #define _ARM_KPROBES_H +#include + +#ifdef CONFIG_KPROBES #include #include #include @@ -83,4 +86,5 @@ struct arch_optimized_insn { */ }; +#endif /* CONFIG_KPROBES */ #endif /* _ARM_KPROBES_H */ diff --git a/arch/arm/probes/decode.h b/arch/arm/probes/decode.h index f9b08ba7fe73..548d622a3159 100644 --- a/arch/arm/probes/decode.h +++ b/arch/arm/probes/decode.h @@ -22,6 +22,7 @@ #include #include #include +#include void __init arm_probes_decode_init(void); diff --git a/arch/arm64/include/asm/kprobes.h b/arch/arm64/include/asm/kprobes.h index 1737aecfcc5e..6deb8d726041 100644 --- a/arch/arm64/include/asm/kprobes.h +++ b/arch/arm64/include/asm/kprobes.h @@ -16,6 +16,9 @@ #ifndef _ARM_KPROBES_H #define _ARM_KPROBES_H +#include + +#ifdef CONFIG_KPROBES #include #include #include @@ -57,4 +60,5 @@ int kprobe_single_step_handler(struct pt_regs *regs, unsigned int esr); void kretprobe_trampoline(void); void __kprobes *trampoline_probe_handler(struct pt_regs *regs); +#endif /* CONFIG_KPROBES */ #endif /* _ARM_KPROBES_H */ diff --git a/arch/arm64/kernel/insn.c b/arch/arm64/kernel/insn.c index 94b62c1fa4df..ae912304ed84 100644 --- a/arch/arm64/kernel/insn.c +++ b/arch/arm64/kernel/insn.c @@ -31,6 +31,7 @@ #include #include #include +#include #define AARCH64_INSN_SF_BIT BIT(31) #define AARCH64_INSN_N_BIT BIT(22) diff --git a/arch/arm64/kernel/probes/decode-insn.h b/arch/arm64/kernel/probes/decode-insn.h index 76d3f315407f..192ab007bacb 100644 --- a/arch/arm64/kernel/probes/decode-insn.h +++ b/arch/arm64/kernel/probes/decode-insn.h @@ -16,6 +16,8 @@ #ifndef _ARM_KERNEL_KPROBES_ARM64_H #define _ARM_KERNEL_KPROBES_ARM64_H +#include + /* * ARM strongly recommends a limit of 128 bytes between LoadExcl and * StoreExcl instructions in a single thread of execution. So keep the diff --git a/arch/avr32/include/asm/kprobes.h b/arch/avr32/include/asm/kprobes.h index 45f563ed73fd..28dfc61ad384 100644 --- a/arch/avr32/include/asm/kprobes.h +++ b/arch/avr32/include/asm/kprobes.h @@ -11,10 +11,14 @@ #ifndef __ASM_AVR32_KPROBES_H #define __ASM_AVR32_KPROBES_H +#include + +#define BREAKPOINT_INSTRUCTION 0xd673 /* breakpoint */ + +#ifdef CONFIG_KPROBES #include typedef u16 kprobe_opcode_t; -#define BREAKPOINT_INSTRUCTION 0xd673 /* breakpoint */ #define MAX_INSN_SIZE 2 #define MAX_STACK_SIZE 64 /* 32 would probably be OK */ @@ -46,4 +50,5 @@ extern int kprobe_exceptions_notify(struct notifier_block *self, #define flush_insn_slot(p) do { } while (0) +#endif /* CONFIG_KPROBES */ #endif /* __ASM_AVR32_KPROBES_H */ diff --git a/arch/blackfin/include/asm/Kbuild b/arch/blackfin/include/asm/Kbuild index 9115b215fc7e..52351d3fd36e 100644 --- a/arch/blackfin/include/asm/Kbuild +++ b/arch/blackfin/include/asm/Kbuild @@ -50,3 +50,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/c6x/include/asm/Kbuild b/arch/c6x/include/asm/Kbuild index cede2a950fbf..c54f7cc1f63e 100644 --- a/arch/c6x/include/asm/Kbuild +++ b/arch/c6x/include/asm/Kbuild @@ -64,3 +64,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += section-core.h generic-y += ranges.h +generic-y += kprobes.h diff --git a/arch/cris/include/asm/Kbuild b/arch/cris/include/asm/Kbuild index 7062c1be7913..051d355feae3 100644 --- a/arch/cris/include/asm/Kbuild +++ b/arch/cris/include/asm/Kbuild @@ -48,3 +48,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/frv/include/asm/Kbuild b/arch/frv/include/asm/Kbuild index 4a59cbda5091..b58b9fc49383 100644 --- a/arch/frv/include/asm/Kbuild +++ b/arch/frv/include/asm/Kbuild @@ -11,3 +11,4 @@ generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/h8300/include/asm/Kbuild b/arch/h8300/include/asm/Kbuild index d79968d93c12..cfca7de52b37 100644 --- a/arch/h8300/include/asm/Kbuild +++ b/arch/h8300/include/asm/Kbuild @@ -78,3 +78,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/hexagon/include/asm/Kbuild b/arch/hexagon/include/asm/Kbuild index d59ac1c1858b..d7cc35451f30 100644 --- a/arch/hexagon/include/asm/Kbuild +++ b/arch/hexagon/include/asm/Kbuild @@ -63,3 +63,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/ia64/include/asm/kprobes.h b/arch/ia64/include/asm/kprobes.h index d5505d6f2382..0302b3664789 100644 --- a/arch/ia64/include/asm/kprobes.h +++ b/arch/ia64/include/asm/kprobes.h @@ -23,14 +23,19 @@ * 2005-Apr Rusty Lynch and Anil S Keshavamurthy * adapted from i386 */ +#include +#include + +#define BREAK_INST (long)(__IA64_BREAK_KPROBE << 6) + +#ifdef CONFIG_KPROBES + #include #include #include -#include #define __ARCH_WANT_KPROBES_INSN_SLOT #define MAX_INSN_SIZE 2 /* last half is for kprobe-booster */ -#define BREAK_INST (long)(__IA64_BREAK_KPROBE << 6) #define NOP_M_INST (long)(1<<27) #define BRL_INST(i1, i2) ((long)((0xcL << 37) | /* brl */ \ (0x1L << 12) | /* many */ \ @@ -124,4 +129,5 @@ extern void invalidate_stacked_regs(void); extern void flush_register_stack(void); extern void arch_remove_kprobe(struct kprobe *p); -#endif /* _ASM_KPROBES_H */ +#endif /* CONFIG_KPROBES */ +#endif /* _ASM_KPROBES_H */ diff --git a/arch/m32r/include/asm/Kbuild b/arch/m32r/include/asm/Kbuild index 24088f3c733c..198ad591ab41 100644 --- a/arch/m32r/include/asm/Kbuild +++ b/arch/m32r/include/asm/Kbuild @@ -14,3 +14,4 @@ generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/m68k/include/asm/Kbuild b/arch/m68k/include/asm/Kbuild index c28bcdecc764..412dd23ab946 100644 --- a/arch/m68k/include/asm/Kbuild +++ b/arch/m68k/include/asm/Kbuild @@ -37,3 +37,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/metag/include/asm/Kbuild b/arch/metag/include/asm/Kbuild index c836f7e2a5e7..8371cc9b1b3c 100644 --- a/arch/metag/include/asm/Kbuild +++ b/arch/metag/include/asm/Kbuild @@ -58,3 +58,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/microblaze/include/asm/Kbuild b/arch/microblaze/include/asm/Kbuild index 01afb1b420f5..865ce3d96443 100644 --- a/arch/microblaze/include/asm/Kbuild +++ b/arch/microblaze/include/asm/Kbuild @@ -14,3 +14,4 @@ generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/mips/include/asm/kprobes.h b/arch/mips/include/asm/kprobes.h index daba1f9a4f79..291846d9ba83 100644 --- a/arch/mips/include/asm/kprobes.h +++ b/arch/mips/include/asm/kprobes.h @@ -22,6 +22,9 @@ #ifndef _ASM_KPROBES_H #define _ASM_KPROBES_H +#include + +#ifdef CONFIG_KPROBES #include #include @@ -94,4 +97,5 @@ struct kprobe_ctlblk { extern int kprobe_exceptions_notify(struct notifier_block *self, unsigned long val, void *data); -#endif /* _ASM_KPROBES_H */ +#endif /* CONFIG_KPROBES */ +#endif /* _ASM_KPROBES_H */ diff --git a/arch/mn10300/include/asm/kprobes.h b/arch/mn10300/include/asm/kprobes.h index c800b590183a..7abea0bdb549 100644 --- a/arch/mn10300/include/asm/kprobes.h +++ b/arch/mn10300/include/asm/kprobes.h @@ -21,13 +21,17 @@ #ifndef _ASM_KPROBES_H #define _ASM_KPROBES_H +#include + +#define BREAKPOINT_INSTRUCTION 0xff + +#ifdef CONFIG_KPROBES #include #include struct kprobe; typedef unsigned char kprobe_opcode_t; -#define BREAKPOINT_INSTRUCTION 0xff #define MAX_INSN_SIZE 8 #define MAX_STACK_SIZE 128 @@ -47,4 +51,5 @@ extern int kprobe_exceptions_notify(struct notifier_block *self, extern void arch_remove_kprobe(struct kprobe *p); +#endif /* CONFIG_KPROBES */ #endif /* _ASM_KPROBES_H */ diff --git a/arch/nios2/include/asm/Kbuild b/arch/nios2/include/asm/Kbuild index ee6220dac1e8..d6ce7edee7e0 100644 --- a/arch/nios2/include/asm/Kbuild +++ b/arch/nios2/include/asm/Kbuild @@ -66,3 +66,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/openrisc/include/asm/Kbuild b/arch/openrisc/include/asm/Kbuild index ceafe458e295..1bf89a67317c 100644 --- a/arch/openrisc/include/asm/Kbuild +++ b/arch/openrisc/include/asm/Kbuild @@ -74,3 +74,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/parisc/include/asm/Kbuild b/arch/parisc/include/asm/Kbuild index aaae8a9f6099..19d5b7e12ecf 100644 --- a/arch/parisc/include/asm/Kbuild +++ b/arch/parisc/include/asm/Kbuild @@ -31,3 +31,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/powerpc/include/asm/kprobes.h b/arch/powerpc/include/asm/kprobes.h index 97b8c1f83453..c7ee3fcbd6e2 100644 --- a/arch/powerpc/include/asm/kprobes.h +++ b/arch/powerpc/include/asm/kprobes.h @@ -1,5 +1,8 @@ #ifndef _ASM_POWERPC_KPROBES_H #define _ASM_POWERPC_KPROBES_H + +#include + #ifdef __KERNEL__ /* * Kernel Probes (KProbes) diff --git a/arch/s390/include/asm/kprobes.h b/arch/s390/include/asm/kprobes.h index 591e5a5279b0..84c0f9086483 100644 --- a/arch/s390/include/asm/kprobes.h +++ b/arch/s390/include/asm/kprobes.h @@ -27,6 +27,11 @@ * 2005-Dec Used as a template for s390 by Mike Grundy * */ +#include + +#define BREAKPOINT_INSTRUCTION 0x0002 + +#ifdef CONFIG_KPROBES #include #include #include @@ -37,7 +42,6 @@ struct pt_regs; struct kprobe; typedef u16 kprobe_opcode_t; -#define BREAKPOINT_INSTRUCTION 0x0002 /* Maximum instruction size is 3 (16bit) halfwords: */ #define MAX_INSN_SIZE 0x0003 @@ -91,4 +95,5 @@ int probe_is_insn_relative_long(u16 *insn); #define flush_insn_slot(p) do { } while (0) +#endif /* CONFIG_KPROBES */ #endif /* _ASM_S390_KPROBES_H */ diff --git a/arch/score/include/asm/Kbuild b/arch/score/include/asm/Kbuild index 16ea15a3e432..6ac8a7f5c768 100644 --- a/arch/score/include/asm/Kbuild +++ b/arch/score/include/asm/Kbuild @@ -17,3 +17,4 @@ generic-y += word-at-a-time.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/sh/include/asm/kprobes.h b/arch/sh/include/asm/kprobes.h index 134f3980e44a..f0986f9b3844 100644 --- a/arch/sh/include/asm/kprobes.h +++ b/arch/sh/include/asm/kprobes.h @@ -1,13 +1,16 @@ #ifndef __ASM_SH_KPROBES_H #define __ASM_SH_KPROBES_H +#include + +#define BREAKPOINT_INSTRUCTION 0xc33a + #ifdef CONFIG_KPROBES #include #include typedef insn_size_t kprobe_opcode_t; -#define BREAKPOINT_INSTRUCTION 0xc33a #define MAX_INSN_SIZE 16 #define MAX_STACK_SIZE 64 diff --git a/arch/sparc/include/asm/kprobes.h b/arch/sparc/include/asm/kprobes.h index a145d798e112..49f8402035d7 100644 --- a/arch/sparc/include/asm/kprobes.h +++ b/arch/sparc/include/asm/kprobes.h @@ -1,13 +1,17 @@ #ifndef _SPARC64_KPROBES_H #define _SPARC64_KPROBES_H +#include + +#define BREAKPOINT_INSTRUCTION 0x91d02070 /* ta 0x70 */ +#define BREAKPOINT_INSTRUCTION_2 0x91d02071 /* ta 0x71 */ + +#ifdef CONFIG_KPROBES #include #include typedef u32 kprobe_opcode_t; -#define BREAKPOINT_INSTRUCTION 0x91d02070 /* ta 0x70 */ -#define BREAKPOINT_INSTRUCTION_2 0x91d02071 /* ta 0x71 */ #define MAX_INSN_SIZE 2 #define kretprobe_blacklist_size 0 @@ -48,4 +52,6 @@ int kprobe_exceptions_notify(struct notifier_block *self, int kprobe_fault_handler(struct pt_regs *regs, int trapnr); asmlinkage void __kprobes kprobe_trap(unsigned long trap_level, struct pt_regs *regs); + +#endif /* CONFIG_KPROBES */ #endif /* _SPARC64_KPROBES_H */ diff --git a/arch/tile/include/asm/kprobes.h b/arch/tile/include/asm/kprobes.h index d8f9a83943b1..4a8b1cadca24 100644 --- a/arch/tile/include/asm/kprobes.h +++ b/arch/tile/include/asm/kprobes.h @@ -17,10 +17,13 @@ #ifndef _ASM_TILE_KPROBES_H #define _ASM_TILE_KPROBES_H +#include + +#ifdef CONFIG_KPROBES + #include #include #include - #include #define __ARCH_WANT_KPROBES_INSN_SLOT @@ -76,4 +79,5 @@ void arch_remove_kprobe(struct kprobe *); extern int kprobe_exceptions_notify(struct notifier_block *self, unsigned long val, void *data); +#endif /* CONFIG_KPROBES */ #endif /* _ASM_TILE_KPROBES_H */ diff --git a/arch/um/include/asm/Kbuild b/arch/um/include/asm/Kbuild index d2867aa09e23..ccc5ffeaeef5 100644 --- a/arch/um/include/asm/Kbuild +++ b/arch/um/include/asm/Kbuild @@ -29,3 +29,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/unicore32/include/asm/Kbuild b/arch/unicore32/include/asm/Kbuild index 6671a1f08ead..5aacafb6d385 100644 --- a/arch/unicore32/include/asm/Kbuild +++ b/arch/unicore32/include/asm/Kbuild @@ -63,3 +63,4 @@ generic-y += word-at-a-time.h generic-y += xor.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/arch/x86/include/asm/kprobes.h b/arch/x86/include/asm/kprobes.h index d1d1e5094c28..200581691c6e 100644 --- a/arch/x86/include/asm/kprobes.h +++ b/arch/x86/include/asm/kprobes.h @@ -21,6 +21,12 @@ * * See arch/x86/kernel/kprobes.c for x86 kprobes history. */ + +#include + +#define BREAKPOINT_INSTRUCTION 0xcc + +#ifdef CONFIG_KPROBES #include #include #include @@ -32,7 +38,6 @@ struct pt_regs; struct kprobe; typedef u8 kprobe_opcode_t; -#define BREAKPOINT_INSTRUCTION 0xcc #define RELATIVEJUMP_OPCODE 0xe9 #define RELATIVEJUMP_SIZE 5 #define RELATIVECALL_OPCODE 0xe8 @@ -116,4 +121,6 @@ extern int kprobe_exceptions_notify(struct notifier_block *self, unsigned long val, void *data); extern int kprobe_int3_handler(struct pt_regs *regs); extern int kprobe_debug_handler(struct pt_regs *regs); + +#endif /* CONFIG_KPROBES */ #endif /* _ASM_X86_KPROBES_H */ diff --git a/arch/xtensa/include/asm/Kbuild b/arch/xtensa/include/asm/Kbuild index 7b41f32a2ba0..20f524ded00e 100644 --- a/arch/xtensa/include/asm/Kbuild +++ b/arch/xtensa/include/asm/Kbuild @@ -35,3 +35,4 @@ generic-y += xor.h generic-y += section-core.h generic-y += ranges.h generic-y += tables.h +generic-y += kprobes.h diff --git a/include/asm-generic/kprobes.h b/include/asm-generic/kprobes.h new file mode 100644 index 000000000000..57af9f21d148 --- /dev/null +++ b/include/asm-generic/kprobes.h @@ -0,0 +1,25 @@ +#ifndef _ASM_GENERIC_KPROBES_H +#define _ASM_GENERIC_KPROBES_H + +#if defined(__KERNEL__) && !defined(__ASSEMBLY__) +#ifdef CONFIG_KPROBES +/* + * Blacklist ganerating macro. Specify functions which is not probed + * by using this macro. + */ +# define __NOKPROBE_SYMBOL(fname) \ +static unsigned long __used \ + __attribute__((__section__("_kprobe_blacklist"))) \ + _kbl_addr_##fname = (unsigned long)fname; +# define NOKPROBE_SYMBOL(fname) __NOKPROBE_SYMBOL(fname) +/* Use this to forbid a kprobes attach on very low level functions */ +# define __kprobes __attribute__((__section__(".kprobes.text"))) +# define nokprobe_inline __always_inline +#else +# define NOKPROBE_SYMBOL(fname) +# define __kprobes +# define nokprobe_inline inline +#endif +#endif /* defined(__KERNEL__) && !defined(__ASSEMBLY__) */ + +#endif /* _ASM_GENERIC_KPROBES_H */ diff --git a/include/linux/compiler.h b/include/linux/compiler.h index cf0fa5d86059..dca49b4099da 100644 --- a/include/linux/compiler.h +++ b/include/linux/compiler.h @@ -566,12 +566,4 @@ static __always_inline void __write_once_size(volatile void *p, void *res, int s (_________p1); \ }) -/* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */ -#ifdef CONFIG_KPROBES -# define __kprobes __attribute__((__section__(".kprobes.text"))) -# define nokprobe_inline __always_inline -#else -# define __kprobes -# define nokprobe_inline inline -#endif #endif /* __LINUX_COMPILER_H */ diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h index 8f6849084248..985ed79ef431 100644 --- a/include/linux/kprobes.h +++ b/include/linux/kprobes.h @@ -29,7 +29,7 @@ * and Prasanna S Panchamukhi * added function-return probes. */ -#include /* for __kprobes */ +#include #include #include #include @@ -40,9 +40,9 @@ #include #include #include +#include #ifdef CONFIG_KPROBES -#include /* kprobe_status settings */ #define KPROBE_HIT_ACTIVE 0x00000001 @@ -51,6 +51,7 @@ #define KPROBE_HIT_SSDONE 0x00000008 #else /* CONFIG_KPROBES */ +#include typedef int kprobe_opcode_t; struct arch_specific_insn { int dummy; @@ -481,18 +482,4 @@ static inline int enable_jprobe(struct jprobe *jp) return enable_kprobe(&jp->kp); } -#ifdef CONFIG_KPROBES -/* - * Blacklist ganerating macro. Specify functions which is not probed - * by using this macro. - */ -#define __NOKPROBE_SYMBOL(fname) \ -static unsigned long __used \ - __attribute__((section("_kprobe_blacklist"))) \ - _kbl_addr_##fname = (unsigned long)fname; -#define NOKPROBE_SYMBOL(fname) __NOKPROBE_SYMBOL(fname) -#else -#define NOKPROBE_SYMBOL(fname) -#endif - #endif /* _LINUX_KPROBES_H */ -- 2.11.0