From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Luis R. Rodriguez" Subject: [PATCH v6 14/14] lib: add linker tables test driver Date: Mon, 9 Jan 2017 06:58:32 -0800 Message-ID: <20170109145833.11502-15-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 QWRkIGEgdGVzdCBkcml2ZXJzIGZvciBsaW5rZXIgdGFibGVzLgoKdjY6IHJlbmFtZSB0YWJsZSBt YWNybyBhcyBzdWdnZXN0ZWQgYnkgQW5keSBTaGV2Y2hlbmtvCnY1OiBhZGRlZCB0aGlzIGNvbW1p dCBmb3IgdGhlIGZpcnN0IHRpbWUgaW4gdGhpcyBzZXJpZXMuCgpTaWduZWQtb2ZmLWJ5OiBMdWlz IFIuIFJvZHJpZ3VleiA8bWNncm9mQGtlcm5lbC5vcmc+Ci0tLQogbGliL0tjb25maWcuZGVidWcg ICAgICAgICAgICAgICAgICAgICAgICB8ICAgNiArCiBsaWIvTWFrZWZpbGUgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAxICsKIGxpYi90ZXN0X2xpbmt0YWJsZXMvTWFrZWZpbGUgICAg ICAgICAgICAgfCAgMTMgKwogbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDAu YyB8ICAyNyArKwogbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDEuYyB8ICAy NyArKwogbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDIuYyB8ICAyNyArKwog bGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDMuYyB8ICAyNyArKwogbGliL3Rl c3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDQuYyB8ICAyNyArKwogbGliL3Rlc3RfbGlu a3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMuYyAgICB8IDgwMSArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrCiBsaWIvdGVzdF9saW5rdGFibGVzL3Rlc3QtbGlua3RhYmxlcy5oICAgIHwgIDQ4 ICsrCiAxMCBmaWxlcyBjaGFuZ2VkLCAxMDA0IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEw MDY0NCBsaWIvdGVzdF9saW5rdGFibGVzL01ha2VmaWxlCiBjcmVhdGUgbW9kZSAxMDA2NDQgbGli L3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDAuYwogY3JlYXRlIG1vZGUgMTAwNjQ0 IGxpYi90ZXN0X2xpbmt0YWJsZXMvdGVzdC1saW5rdGFibGVzLTAxLmMKIGNyZWF0ZSBtb2RlIDEw MDY0NCBsaWIvdGVzdF9saW5rdGFibGVzL3Rlc3QtbGlua3RhYmxlcy0wMi5jCiBjcmVhdGUgbW9k ZSAxMDA2NDQgbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDMuYwogY3JlYXRl IG1vZGUgMTAwNjQ0IGxpYi90ZXN0X2xpbmt0YWJsZXMvdGVzdC1saW5rdGFibGVzLTA0LmMKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBsaWIvdGVzdF9saW5rdGFibGVzL3Rlc3QtbGlua3RhYmxlcy5jCiBj cmVhdGUgbW9kZSAxMDA2NDQgbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMuaAoK ZGlmZiAtLWdpdCBhL2xpYi9LY29uZmlnLmRlYnVnIGIvbGliL0tjb25maWcuZGVidWcKaW5kZXgg NTY1NWJkOTU5MTlhLi44Yzk5ZWUzYzlmZDcgMTAwNjQ0Ci0tLSBhL2xpYi9LY29uZmlnLmRlYnVn CisrKyBiL2xpYi9LY29uZmlnLmRlYnVnCkBAIC0xODI3LDYgKzE4MjcsMTIgQEAgY29uZmlnIFRF U1RfSEFTSAogCSAgVGhpcyBpcyBpbnRlbmRlZCB0byBoZWxwIHBlb3BsZSB3cml0aW5nIGFyY2hp dGVjdHVyZS1zcGVjaWZpYwogCSAgb3B0aW1pemVkIHZlcnNpb25zLiAgSWYgdW5zdXJlLCBzYXkg Ti4KIAorY29uZmlnIFRFU1RfTElOS1RBQkxFUworCWJvb2wgIlRlc3QgbGlua2VyIHRhYmxlIGZ1 bmN0aW9uYWxpdHkiCisJZGVmYXVsdCBuCisJaGVscAorCSAgRW5hYmxlIHRoaXMgb3B0aW9uIHRv IHRlc3QgdGhlIGtlcm5lbCdzIGxpbmtlciB0YWJsZSBmdW5jdGlvbmFsaXR5LgorCiBlbmRtZW51 ICMgcnVudGltZSB0ZXN0cwogCiBjb25maWcgUFJPVklERV9PSENJMTM5NF9ETUFfSU5JVApkaWZm IC0tZ2l0IGEvbGliL01ha2VmaWxlIGIvbGliL01ha2VmaWxlCmluZGV4IDk0ZWQ1Y2M0ZTg5Yy4u YjVjNWE3YTkxNDZjIDEwMDY0NAotLS0gYS9saWIvTWFrZWZpbGUKKysrIGIvbGliL01ha2VmaWxl CkBAIC01NSw2ICs1NSw3IEBAIG9iai0kKENPTkZJR19URVNUX1NUQVRJQ19LRVlTKSArPSB0ZXN0 X3N0YXRpY19rZXlfYmFzZS5vCiBvYmotJChDT05GSUdfVEVTVF9QUklOVEYpICs9IHRlc3RfcHJp bnRmLm8KIG9iai0kKENPTkZJR19URVNUX0JJVE1BUCkgKz0gdGVzdF9iaXRtYXAubwogb2JqLSQo Q09ORklHX1RFU1RfVVVJRCkgKz0gdGVzdF91dWlkLm8KK29iai0kKENPTkZJR19URVNUX0xJTktU QUJMRVMpICs9IHRlc3RfbGlua3RhYmxlcy8KIAogaWZlcSAoJChDT05GSUdfREVCVUdfS09CSkVD VCkseSkKIENGTEFHU19rb2JqZWN0Lm8gKz0gLURERUJVRwpkaWZmIC0tZ2l0IGEvbGliL3Rlc3Rf bGlua3RhYmxlcy9NYWtlZmlsZSBiL2xpYi90ZXN0X2xpbmt0YWJsZXMvTWFrZWZpbGUKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5hMWE2N2Q3ZmQ1N2EKLS0tIC9kZXYv bnVsbAorKysgYi9saWIvdGVzdF9saW5rdGFibGVzL01ha2VmaWxlCkBAIC0wLDAgKzEsMTMgQEAK K19fTElOS1RBQkxFX1RFU1RTIDo9ICQoc2hlbGwgZmluZCAuLyAtbmFtZSB0ZXN0LWxpbmt0YWJs ZXMtXCouYyB8IHdjIC1sKQorY2NmbGFncy15ICs9IC1EX19MSU5LVEFCTEVfVEVTVFM9JChfX0xJ TktUQUJMRV9URVNUUykKKworIyBLZWVwIHRoZXNlIGRpc29yZ2FuaXplZCwgaWYgbGlua2VyIHRh YmxlcyBkaWQgbm90IHdvcmsgdGhlbgorIyB0aGluZ3Mgd291bGQgbm90IGJlIG9yZGVyZWQgZm9y IHVzIGF1dG9tYXRpY2FsbHkgYXQgbGluayB0aW1lLgorIyBMaW5rZXIgdGFibGVzIGdyYW50cyB1 cyB0aGUgYWJpbGl0eSB0byBiZSBleHBsaWNpdCBhYm91dAorIyBvcmRlci4KK29iai0kKENPTkZJ R19URVNUX0xJTktUQUJMRVMpICs9IHRlc3QtbGlua3RhYmxlcy0wNC5vCitvYmotJChDT05GSUdf VEVTVF9MSU5LVEFCTEVTKSArPSB0ZXN0LWxpbmt0YWJsZXMtMDIubworb2JqLSQoQ09ORklHX1RF U1RfTElOS1RBQkxFUykgKz0gdGVzdC1saW5rdGFibGVzLTAxLm8KK29iai0kKENPTkZJR19URVNU X0xJTktUQUJMRVMpICs9IHRlc3QtbGlua3RhYmxlcy0wMy5vCitvYmotJChDT05GSUdfVEVTVF9M SU5LVEFCTEVTKSArPSB0ZXN0LWxpbmt0YWJsZXMtMDAubworb2JqLSQoQ09ORklHX1RFU1RfTElO S1RBQkxFUykgKz0gdGVzdC1saW5rdGFibGVzLm8KZGlmZiAtLWdpdCBhL2xpYi90ZXN0X2xpbmt0 YWJsZXMvdGVzdC1saW5rdGFibGVzLTAwLmMgYi9saWIvdGVzdF9saW5rdGFibGVzL3Rlc3QtbGlu a3RhYmxlcy0wMC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZWEx NjJiZDY5MTc5Ci0tLSAvZGV2L251bGwKKysrIGIvbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxp bmt0YWJsZXMtMDAuYwpAQCAtMCwwICsxLDI3IEBACisjZGVmaW5lIHByX2ZtdChmbXQpIEtCVUlM RF9NT0ROQU1FICI6ICIgZm10CisKKyNpbmNsdWRlIDxsaW51eC90YWJsZXMuaD4KKyNpbmNsdWRl IDxsaW51eC9wcmludGsuaD4KKworI2luY2x1ZGUgInRlc3QtbGlua3RhYmxlcy5oIgorCitzdGF0 aWMgaW50IF9faW5pdCB0ZXN0X2xpbmt0YWJsZV8wMF9pbml0KGludCBpbnB1dCkKK3sKKwlyZXR1 cm4gMCAqIGlucHV0OworfQorCitzdGF0aWMgaW50IF9faW5pdGRhdGEgdGVzdF9saW5rdGFibGVf MDBfaW5pdF9kYXRhKGludCBpbnB1dCkKK3sKKwlyZXR1cm4gMCAqIGlucHV0OworfQorCitzdGF0 aWMgaW50IHRlc3RfbGlua3RhYmxlXzAwKGludCBpbnB1dCkKK3sKKwlyZXR1cm4gMCAqIGlucHV0 OworfQorCit0ZXN0X2xpbmt0YWJsZV9pbml0X2RhdGEoMDAsIHRlc3RfbGlua3RhYmxlXzAwX2lu aXRfZGF0YSk7IC8qIC5pbml0LmRhdGEgKi8KK3Rlc3RfbGlua3RhYmxlX2luaXRfdGV4dCgwMCwg dGVzdF9saW5rdGFibGVfMDBfaW5pdCk7IC8qIC5pbml0LnRleHQgKi8KK3Rlc3RfbGlua3RhYmxl KDAwLCB0ZXN0X2xpbmt0YWJsZV8wMCk7IC8qIC5kYXRhICovCit0ZXN0X2xpbmt0YWJsZV90ZXh0 KDAwLCB0ZXN0X2xpbmt0YWJsZV8wMCk7IC8qIC50ZXh0ICovCit0ZXN0X2xpbmt0YWJsZV9yb2Rh dGEoMDAsIHRlc3RfbGlua3RhYmxlXzAwKTsgLyogLnJvZGF0YSAqLwpkaWZmIC0tZ2l0IGEvbGli L3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDEuYyBiL2xpYi90ZXN0X2xpbmt0YWJs ZXMvdGVzdC1saW5rdGFibGVzLTAxLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwLi4zOTU3ODk5MGZkNTkKLS0tIC9kZXYvbnVsbAorKysgYi9saWIvdGVzdF9saW5rdGFi bGVzL3Rlc3QtbGlua3RhYmxlcy0wMS5jCkBAIC0wLDAgKzEsMjcgQEAKKyNkZWZpbmUgcHJfZm10 KGZtdCkgS0JVSUxEX01PRE5BTUUgIjogIiBmbXQKKworI2luY2x1ZGUgPGxpbnV4L3RhYmxlcy5o PgorI2luY2x1ZGUgPGxpbnV4L3ByaW50ay5oPgorCisjaW5jbHVkZSAidGVzdC1saW5rdGFibGVz LmgiCisKK3N0YXRpYyBpbnQgX19pbml0IHRlc3RfbGlua3RhYmxlXzAxX2luaXQoaW50IGlucHV0 KQoreworCXJldHVybiAxICogaW5wdXQ7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0ZGF0YSB0ZXN0 X2xpbmt0YWJsZV8wMV9pbml0X2RhdGEoaW50IGlucHV0KQoreworCXJldHVybiAxICogaW5wdXQ7 Cit9CisKK3N0YXRpYyBpbnQgdGVzdF9saW5rdGFibGVfMDEoaW50IGlucHV0KQoreworCXJldHVy biAxICogaW5wdXQ7Cit9CisKK3Rlc3RfbGlua3RhYmxlX2luaXRfZGF0YSgwMSwgdGVzdF9saW5r dGFibGVfMDFfaW5pdF9kYXRhKTsgLyogLmluaXQuZGF0YSAqLwordGVzdF9saW5rdGFibGVfaW5p dF90ZXh0KDAxLCB0ZXN0X2xpbmt0YWJsZV8wMV9pbml0KTsgLyogLmluaXQudGV4dCAqLwordGVz dF9saW5rdGFibGUoMDEsIHRlc3RfbGlua3RhYmxlXzAxKTsgLyogLmRhdGEgKi8KK3Rlc3RfbGlu a3RhYmxlX3RleHQoMDEsIHRlc3RfbGlua3RhYmxlXzAxKTsgLyogLnRleHQgKi8KK3Rlc3RfbGlu a3RhYmxlX3JvZGF0YSgwMSwgdGVzdF9saW5rdGFibGVfMDEpOyAvKiAucm9kYXRhICovCmRpZmYg LS1naXQgYS9saWIvdGVzdF9saW5rdGFibGVzL3Rlc3QtbGlua3RhYmxlcy0wMi5jIGIvbGliL3Rl c3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAuLjdmNGIzNDI0MGVjYgotLS0gL2Rldi9udWxsCisrKyBiL2xpYi90 ZXN0X2xpbmt0YWJsZXMvdGVzdC1saW5rdGFibGVzLTAyLmMKQEAgLTAsMCArMSwyNyBAQAorI2Rl ZmluZSBwcl9mbXQoZm10KSBLQlVJTERfTU9ETkFNRSAiOiAiIGZtdAorCisjaW5jbHVkZSA8bGlu dXgvdGFibGVzLmg+CisjaW5jbHVkZSA8bGludXgvcHJpbnRrLmg+CisKKyNpbmNsdWRlICJ0ZXN0 LWxpbmt0YWJsZXMuaCIKKworc3RhdGljIGludCBfX2luaXQgdGVzdF9saW5rdGFibGVfMDJfaW5p dChpbnQgaW5wdXQpCit7CisJcmV0dXJuIDIgKiBpbnB1dDsKK30KKworc3RhdGljIGludCBfX2lu aXRkYXRhIHRlc3RfbGlua3RhYmxlXzAyX2luaXRfZGF0YShpbnQgaW5wdXQpCit7CisJcmV0dXJu IDIgKiBpbnB1dDsKK30KKworc3RhdGljIGludCB0ZXN0X2xpbmt0YWJsZV8wMihpbnQgaW5wdXQp Cit7CisJcmV0dXJuIDIgKiBpbnB1dDsKK30KKwordGVzdF9saW5rdGFibGVfaW5pdF9kYXRhKDAy LCB0ZXN0X2xpbmt0YWJsZV8wMl9pbml0X2RhdGEpOyAvKiAuaW5pdC5kYXRhICovCit0ZXN0X2xp bmt0YWJsZV9pbml0X3RleHQoMDIsIHRlc3RfbGlua3RhYmxlXzAyX2luaXQpOyAvKiAuaW5pdC50 ZXh0ICovCit0ZXN0X2xpbmt0YWJsZSgwMiwgdGVzdF9saW5rdGFibGVfMDIpOyAvKiAuZGF0YSAq LwordGVzdF9saW5rdGFibGVfdGV4dCgwMiwgdGVzdF9saW5rdGFibGVfMDIpOyAvKiAudGV4dCAq LwordGVzdF9saW5rdGFibGVfcm9kYXRhKDAyLCB0ZXN0X2xpbmt0YWJsZV8wMik7IC8qIC5yb2Rh dGEgKi8KZGlmZiAtLWdpdCBhL2xpYi90ZXN0X2xpbmt0YWJsZXMvdGVzdC1saW5rdGFibGVzLTAz LmMgYi9saWIvdGVzdF9saW5rdGFibGVzL3Rlc3QtbGlua3RhYmxlcy0wMy5jCm5ldyBmaWxlIG1v ZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNDdjYTc3ZTMwYzI0Ci0tLSAvZGV2L251bGwK KysrIGIvbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJsZXMtMDMuYwpAQCAtMCwwICsx LDI3IEBACisjZGVmaW5lIHByX2ZtdChmbXQpIEtCVUlMRF9NT0ROQU1FICI6ICIgZm10CisKKyNp bmNsdWRlIDxsaW51eC90YWJsZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9wcmludGsuaD4KKworI2lu Y2x1ZGUgInRlc3QtbGlua3RhYmxlcy5oIgorCitzdGF0aWMgaW50IF9faW5pdCB0ZXN0X2xpbmt0 YWJsZV8wM19pbml0KGludCBpbnB1dCkKK3sKKwlyZXR1cm4gMyAqIGlucHV0OworfQorCitzdGF0 aWMgaW50IF9faW5pdGRhdGEgdGVzdF9saW5rdGFibGVfMDNfaW5pdF9kYXRhKGludCBpbnB1dCkK K3sKKwlyZXR1cm4gMyAqIGlucHV0OworfQorCitzdGF0aWMgaW50IHRlc3RfbGlua3RhYmxlXzAz KGludCBpbnB1dCkKK3sKKwlyZXR1cm4gMyAqIGlucHV0OworfQorCit0ZXN0X2xpbmt0YWJsZV9p bml0X2RhdGEoMDMsIHRlc3RfbGlua3RhYmxlXzAzX2luaXRfZGF0YSk7IC8qIC5pbml0LmRhdGEg Ki8KK3Rlc3RfbGlua3RhYmxlX2luaXRfdGV4dCgwMywgdGVzdF9saW5rdGFibGVfMDNfaW5pdCk7 IC8qIC5pbml0LnRleHQgKi8KK3Rlc3RfbGlua3RhYmxlKDAzLCB0ZXN0X2xpbmt0YWJsZV8wMyk7 IC8qIC5kYXRhICovCit0ZXN0X2xpbmt0YWJsZV90ZXh0KDAzLCB0ZXN0X2xpbmt0YWJsZV8wMyk7 IC8qIC50ZXh0ICovCit0ZXN0X2xpbmt0YWJsZV9yb2RhdGEoMDMsIHRlc3RfbGlua3RhYmxlXzAz KTsgLyogLnJvZGF0YSAqLwpkaWZmIC0tZ2l0IGEvbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxp bmt0YWJsZXMtMDQuYyBiL2xpYi90ZXN0X2xpbmt0YWJsZXMvdGVzdC1saW5rdGFibGVzLTA0LmMK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi40MTIzZTBlMTY3MTUKLS0t IC9kZXYvbnVsbAorKysgYi9saWIvdGVzdF9saW5rdGFibGVzL3Rlc3QtbGlua3RhYmxlcy0wNC5j CkBAIC0wLDAgKzEsMjcgQEAKKyNkZWZpbmUgcHJfZm10KGZtdCkgS0JVSUxEX01PRE5BTUUgIjog IiBmbXQKKworI2luY2x1ZGUgPGxpbnV4L3RhYmxlcy5oPgorI2luY2x1ZGUgPGxpbnV4L3ByaW50 ay5oPgorCisjaW5jbHVkZSAidGVzdC1saW5rdGFibGVzLmgiCisKK3N0YXRpYyBpbnQgX19pbml0 IHRlc3RfbGlua3RhYmxlXzA0X2luaXQoaW50IGlucHV0KQoreworCXJldHVybiA0ICogaW5wdXQ7 Cit9CisKK3N0YXRpYyBpbnQgX19pbml0ZGF0YSB0ZXN0X2xpbmt0YWJsZV8wNF9pbml0X2RhdGEo aW50IGlucHV0KQoreworCXJldHVybiA0ICogaW5wdXQ7Cit9CisKK3N0YXRpYyBpbnQgdGVzdF9s aW5rdGFibGVfMDQoaW50IGlucHV0KQoreworCXJldHVybiA0ICogaW5wdXQ7Cit9CisKK3Rlc3Rf bGlua3RhYmxlX2luaXRfZGF0YSgwNCwgdGVzdF9saW5rdGFibGVfMDRfaW5pdF9kYXRhKTsgLyog LmluaXQuZGF0YSAqLwordGVzdF9saW5rdGFibGVfaW5pdF90ZXh0KDA0LCB0ZXN0X2xpbmt0YWJs ZV8wNF9pbml0KTsgLyogLmluaXQudGV4dCAqLwordGVzdF9saW5rdGFibGUoMDQsIHRlc3RfbGlu a3RhYmxlXzA0KTsgLyogLmRhdGEgKi8KK3Rlc3RfbGlua3RhYmxlX3RleHQoMDQsIHRlc3RfbGlu a3RhYmxlXzA0KTsgLyogLnRleHQgKi8KK3Rlc3RfbGlua3RhYmxlX3JvZGF0YSgwNCwgdGVzdF9s aW5rdGFibGVfMDQpOyAvKiAucm9kYXRhICovCmRpZmYgLS1naXQgYS9saWIvdGVzdF9saW5rdGFi bGVzL3Rlc3QtbGlua3RhYmxlcy5jIGIvbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJs ZXMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmI3OGZiNWI1NTRj YgotLS0gL2Rldi9udWxsCisrKyBiL2xpYi90ZXN0X2xpbmt0YWJsZXMvdGVzdC1saW5rdGFibGVz LmMKQEAgLTAsMCArMSw4MDEgQEAKKy8qCisgKiBMaW5rZXIgdGFibGUgdGVzdCBkcml2ZXIKKyAq CisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgTHVpcyBSLiBSb2RyaWd1ZXogPG1jZ3JvZkBrZXJuZWwu b3JnPgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgY29weWxl ZnQtbmV4dCAodmVyc2lvbiAwLjMuMSBvciBsYXRlcikgYXMgcHVibGlzaGVkCisgKiBhdCBodHRw Oi8vY29weWxlZnQtbmV4dC5vcmcvLgorICovCisKKy8qCisgKiBUaGlzIGRyaXZlciBwcm92aWRl cyBhbiBpbnRlcmZhY2UgdG8gdHJpZ2dlciBhbmQgdGVzdCB0aGUgbGlua2VyIHRhYmxlIEFQSQor ICogdGhyb3VnaCBhIHNlcmllcyBvZiBjb25maWd1cmF0aW9ucyBhbmQgYSBmZXcgdHJpZ2dlcnMu IFRoaXMgZHJpdmVyCisgKiBtdXN0IGJlIGJ1aWx0LWluIGFzIGxpbmtlciB0YWJsZXMgY3VycmVu dGx5IGxhY2sgZ2VuZXJhbGl6ZWQgbW9kdWxhcgorICogc3VwcG9ydCAtLSBhZGRpdGlvbmFsIHdv cmsgaXMgcmVxdWlyZWQgb24gZWFjaCBtb2R1bGUgcmlnaHQgbm93IGlmIHlvdQorICogd2FudCB0 byB1c2UgbGlua2VyIHRhYmxlcywgaW4gdGhlIGZ1dHVyZSB3ZSBtYXkgbWFrZSB0aGlzIG11Y2gg ZWFzaWVyLgorICogRm9yIG5vdyBqdXN0IGJ1aWxkIHRoaXMgaW50byB5b3VyIGtlcm5lbC4KKyAq CisgKiBlY2hvIC1uIC50ZXh0ID4gL3N5cy9kZXZpY2VzL3ZpcnR1YWwvbWlzYy90ZXN0X2xpbmt0 YWJsZS9jb25maWdfc2VjdGlvbl9uYW1lCisgKiBlY2hvIC1uIDMgPiAvc3lzL2RldmljZXMvdmly dHVhbC9taXNjL3Rlc3RfbGlua3RhYmxlL2NvbmZpZ19pbnB1dAorICogZWNobyAxID4gL3N5cy9k ZXZpY2VzL3ZpcnR1YWwvbWlzYy90ZXN0X2xpbmt0YWJsZS90cmlnZ2VyX2NvbmZpZworICogY2F0 IC9zeXMvZGV2aWNlcy92aXJ0dWFsL21pc2MvdGVzdF9saW5rdGFibGUvdGVzdF9yZXN1bHQKKyAq IDMwCisgKgorICogZWNobyAtbiAuZGF0YSA+IC9zeXMvZGV2aWNlcy92aXJ0dWFsL21pc2MvdGVz dF9saW5rdGFibGUvY29uZmlnX3NlY3Rpb25fbmFtZQorICogZWNobyAtbiAudGV4dCA+IC9zeXMv ZGV2aWNlcy92aXJ0dWFsL21pc2MvdGVzdF9saW5rdGFibGUvY29uZmlnX3NlY3Rpb25fbmFtZQor ICogZWNobyAtbiAucm9kYXRhID4gL3N5cy9kZXZpY2VzL3ZpcnR1YWwvbWlzYy90ZXN0X2xpbmt0 YWJsZS9jb25maWdfc2VjdGlvbl9uYW1lCisgKgorICogVG8gY2hlY2sgdGhlIGNvbmZpZ3VyYXRp b246CisgKgorICogY2F0IC9zeXMvZGV2aWNlcy92aXJ0dWFsL21pc2MvdGVzdF9saW5rdGFibGUv Y29uZmlnCisgKgorICogTlVNX1RFU1RTCisgKiAgICDiiJEgICAgICAgIHRlc3QobiwgaW5wdXQp CisgKiAgIG49MAorICoKKyAqIEVhY2ggbGlua2VyIHRhYmxlIGVudHJ5IG9uIGVhY2ggc2VjdGlv biBoYXMgYSBzZXJpZXMgb2YgZW50cmllcy4gRWFjaCBlbnRyeQorICogaGFzIGEgZnVuY3Rpb24g d2hpY2gganVzdCBtdWx0aXBsaWVzIHRoZSB0ZXN0IGNhc2UgbnVtYmVyIGJ5IGlucHV0IHZhbHVl LgorICoKKyAqIC4uLgorICogdGVzdC1saW5rdGFibGVzLTAzLmMgbXVsdGlwbGllcyAoMyAqIGlu cHV0KQorICogdGVzdC1saW5rdGFibGVzLTA0LmMgbXVsdGlwbGllcyAoNCAqIGlucHV0KQorICog Li4uCisgKgorICogQSBmdWxsIHJ1biBvbiBhIHNlY3Rpb24gcHJvZHVjZXMgdGhlIHN1bSBvZiB0 aGVzZSB2YWx1ZXMuIFNvIHdpdGggaW5wdXQgc2V0CisgKiB0byAzIHdlIGhhdmU6CisgKgorICog KDAgKiAzKSArICgxICogMykgKyAoMiAqIDMpICsgKDMgKiAzKSArICg0ICogMykKKyAqICAgIDAg ICAgKyAgICAzICAgICsgICAgNiAgICArICAgOSAgICAgKyAgMTIKKyAqICAgICAgICAgICAgICAg ICAgICAzMAorICoKKyAqIFRoaXMgaXMgbm90aGluZyBpbXBvcnRhbnQsIGl0cyBqdXN0IGEgYmFz aWMgdGVzdC4gV2UgaGFkIHRvIHBpY2sgc29tZXRoaW5nLgorICogT3RoZXIgdGhhbiB0aGUgYWJv dmUgdGVzdHMsIHRoaXMgYWxzbyBkZW1vcyBhbmQgc2hvd3MgcHJvcGVyIGNvbnN0IHVzZSBvbgor ICogYWxsIHNlY3Rpb25zIHdoaWNoIHdlIG5lZWQgYXMgcmVhZC1vbmx5OiAudGV4dCwgLmluaXQu dGV4dCwgLnJvZGF0YS4KKyAqIEZ1cnRoZXJtb3JlIGl0IGRvZXMgYSBzaWxseSB3cml0ZSB0ZXN0 IHRvIGVuc3VyZSB3cml0ZSB3b3JrcyBvbiAuZGF0YSBhbmQKKyAqIGluaXQuZGF0YS4gU2luY2Ug dGhlIHJlYWQtb25seSBzZWN0aW9ucyB1c2UgY29uc3Qgd2Ugb2J2aW91c2x5IGFyZSBmb3JjZWQK KyAqIGJ5IHRoZSBjb21waWxlciB0byBub3QgYmUgYWJsZSB0byB3cml0ZSB0byB0aGVzZSBzZWN0 aW9ucy4KKyAqCisgKiBPbmUgb2YgdGhlIG1vcmUgaW1wb3J0YW50IGl0ZW1zLCB0aGUgb3JkZXIs IGlzIHRlc3RlZC4gV2UgY291bGQgZGV2ZWxvcAorICogYSBmYW5jeSBzaW1wbGUgbWF0aCBhbGdv cml0aG0gdGhhdCBkZXBlbmRzIG9uIG9yZGVyIGZvciBjb3JyZWN0bmVzcyBidXQKKyAqIGluc3Rl YWQgd2UganVzdCBhbm5vdGF0ZSB0aGUgZXhwZWN0ZWQgb3JkZXIgYXMgd2UgcnVuLiBJZiB0aGUg b3JkZXIgbGlzdGVkCisgKiBvbiB0ZXN0LT5leHBlY3RlZCBkb2VzIG5vdCBtYXRjaCB3aXRoIHRo ZSBhY3R1YWwgb3JkZXIgYSByb3V0aW5lIHdhcyBydW4KKyAqIGluIHRoZW4gd2UgZmFpbCBhbmQg Y29tcGxhaW4uCisgKi8KKyNkZWZpbmUgcHJfZm10KGZtdCkgS0JVSUxEX01PRE5BTUUgIjogIiBm bXQKKworI2luY2x1ZGUgPGxpbnV4L3RhYmxlcy5oPgorI2luY2x1ZGUgPGxpbnV4L3ByaW50ay5o PgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L21pc2NkZXZpY2Uu aD4KKyNpbmNsdWRlIDxsaW51eC92bWFsbG9jLmg+CisjaW5jbHVkZSA8bGludXgvc2xhYi5oPgor CisjaW5jbHVkZSAidGVzdC1saW5rdGFibGVzLmgiCisKKyNkZWZpbmUgTlVNX1RFU1RTIF9fTElO S1RBQkxFX1RFU1RTCisKK3N0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKl9fdGVzdF9kZXYg PSBOVUxMOworc3RhdGljIGJvb2wgaW5pdF9jb21wbGV0ZWQgPSBmYWxzZTsKKworc3RhdGljIGNv bnN0IGNoYXIgKnRlc3RfZGV2X25hbWUgPSAidGVzdF9saW5rdGFibGUiOworCisvKgorICogVXNl ZCBmb3IgdGhlIGRlZmF1bHQgdGVzdCB0byBzdGFydCBjb25maWd1cmF0aW9uIHdpdGggaWYgd2Ug cmVzZXQgdGhlCisgKiB0ZXN0IGZyb20gc2NyYXRjaC4gRG9uJ3QgdXNlIC5pbml0Liogc2VjdGlv bnMgZ2l2ZW4gd2UgY2FuIG9ubHkgdGVzdAorICogdGhlc2Ugb24gaW5pdCwgd2hlbiBpbml0X2Nv bXBsZXRlZCBpcyB0cnVlIHdlIGNhbid0IC5pbml0Liogc2VjdGlvbgorICogY29kZSBhbnltb3Jl LgorICovCisjZGVmaW5lIFRFU1RfU0VDVElPTl9TVEFSVCAiLmRhdGEiCisKK0RFRklORV9MSU5L VEFCTEUoc3RydWN0IHRlc3RfbGlua3RhYmxlLCB0ZXN0X2Zuc19kYXRhKTsKK0RFRklORV9MSU5L VEFCTEVfVEVYVChzdHJ1Y3QgdGVzdF9saW5rdGFibGUsIHRlc3RfZm5zX3RleHQpOworREVGSU5F X0xJTktUQUJMRV9STyhzdHJ1Y3QgdGVzdF9saW5rdGFibGUsIHRlc3RfZm5zX3JvZGF0YSk7CitE RUZJTkVfTElOS1RBQkxFX0lOSVQoc3RydWN0IHRlc3RfbGlua3RhYmxlLCB0ZXN0X2Zuc19pbml0 X3RleHQpOworREVGSU5FX0xJTktUQUJMRV9JTklUX0RBVEEoc3RydWN0IHRlc3RfbGlua3RhYmxl LCB0ZXN0X2Zuc19pbml0X2RhdGEpOworCitzdHJ1Y3QgdGVzdF9jb25maWcgeworCWNoYXIgKnNl Y3Rpb25fbmFtZTsKKwlpbnQgaW5wdXQ7CisJaW50IHRlc3RfcmVzdWx0OworfTsKKworLyoqCisg KiBsaW5rdGFibGVfdGVzdF9kZXZpY2UgLSB0ZXN0IGRldmljZSB0byBoZWxwIHRlc3QgbGlua2Vy IHRhYmxlcworICoKKyAqIEBkZXZfaWR4OiB1bmlxdWUgSUQgZm9yIHRlc3QgZGV2aWNlCisgKiBA bWlzY19kZXY6IHdlIHVzZSBhIG1pc2MgZGV2aWNlIHVuZGVyIHRoZSBob29kCisgKiBAZGV2OiBw b2ludGVyIHRvIG1pc2NfZGV2J3Mgb3duIHN0cnVjdCBkZXZpY2UKKyAqIEBjb25maWdfbXV0ZXg6 IHByb3RlY3RzIGNvbmZpZ3VyYXRpb24gb2YgdGVzdAorICogQHRyaWdnZXJfbXV0ZXg6IHRoZSB0 ZXN0IHRyaWdnZXIgY2FuIG9ubHkgYmUgZmlyZWQgb25jZSBhdCBhIHRpbWUKKyAqLworc3RydWN0 IGxpbmt0YWJsZV90ZXN0X2RldmljZSB7CisJc3RydWN0IHRlc3RfY29uZmlnIGNvbmZpZzsKKwlz dHJ1Y3QgbWlzY2RldmljZSBtaXNjX2RldjsKKwlzdHJ1Y3QgZGV2aWNlICpkZXY7CisJc3RydWN0 IG11dGV4IGNvbmZpZ19tdXRleDsKKwlzdHJ1Y3QgbXV0ZXggdHJpZ2dlcl9tdXRleDsKKwl1bnNp Z25lZCBpbnQgbnVtX2NhbGxlZDsKK307CisKKy8qKgorICogZW51bSBsaW5rdGFibGVfdGVzdF9j YXNlIC0gbGlua2VyIHRhYmxlIHRlc3QgY2FzZQorICoKKyAqIEBURVNUX0xJTktUQUJMRV9JTklU OiB0ZXN0cyAuaW5pdC50ZXh0ICh0aGlzIGlzIGFsbCBjb25zdCkKKyAqIEBURVNUX0xJTktUQUJM RV9JTklUX0RBVEE6IHRlc3RzIC5pbml0LmRhdGEKKyAqIEBURVNUX0xJTktUQUJMRTogdGVzdHMg LmRhdGEKKyAqIEBURVNUX0xJTktUQUJMRV9URVhUOiB0ZXN0cyAudGV4dCAodGhpcyBpcyBhbGwg Y29uc3QpCisgKiBAVEVTVF9MSU5LVEFCTEVfUk86IHRlc3RzIC5yb2RhdGEgKHRoaXMgaXMgYWxs IGNvbnN0KQorICovCitlbnVtIGxpbmt0YWJsZV90ZXN0X2Nhc2UgeworCV9fVEVTVF9MSU5LVEFC TEVfSU5WQUxJRCA9IDAsCisKKwlURVNUX0xJTktUQUJMRV9JTklULAorCVRFU1RfTElOS1RBQkxF X0lOSVRfREFUQSwKKwlURVNUX0xJTktUQUJMRSwKKwlURVNUX0xJTktUQUJMRV9URVhULAorCVRF U1RfTElOS1RBQkxFX1JPLAorfTsKKworc3RhdGljIHN0cnVjdCBtaXNjZGV2aWNlICpkZXZfdG9f bWlzY19kZXYoc3RydWN0IGRldmljZSAqZGV2KQoreworCXJldHVybiBkZXZfZ2V0X2RydmRhdGEo ZGV2KTsKK30KKworc3RhdGljCitzdHJ1Y3QgbGlua3RhYmxlX3Rlc3RfZGV2aWNlICptaXNjX2Rl dl90b190ZXN0X2RldihzdHJ1Y3QgbWlzY2RldmljZSAqbWlzY19kZXYpCit7CisJcmV0dXJuIGNv bnRhaW5lcl9vZihtaXNjX2Rldiwgc3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSwgbWlzY19k ZXYpOworfQorCitzdGF0aWMgc3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqZGV2X3RvX3Rl c3RfZGV2KHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3QgbWlzY2RldmljZSAqbWlzY19k ZXY7CisKKwltaXNjX2RldiA9IGRldl90b19taXNjX2RldihkZXYpOworCisJcmV0dXJuIG1pc2Nf ZGV2X3RvX3Rlc3RfZGV2KG1pc2NfZGV2KTsKK30KKworc3RhdGljIHNzaXplX3QgY29uZmlnX3No b3coc3RydWN0IGRldmljZSAqZGV2LAorCQkJICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0 dHIsCisJCQkgICBjaGFyICpidWYpCit7CisJc3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAq dGVzdF9kZXYgPSBkZXZfdG9fdGVzdF9kZXYoZGV2KTsKKwlzdHJ1Y3QgdGVzdF9jb25maWcgKmNv bmZpZyA9ICZ0ZXN0X2Rldi0+Y29uZmlnOworCWludCBsZW4gPSAwOworCisJbXV0ZXhfbG9jaygm dGVzdF9kZXYtPmNvbmZpZ19tdXRleCk7CisKKwlsZW4gKz0gc25wcmludGYoYnVmLCBQQUdFX1NJ WkUsCisJCQkiQ3VzdG9tIHRyaWdnZXIgY29uZmlndXJhdGlvbiBmb3I6ICVzXG4iLAorCQkJZGV2 X25hbWUoZGV2KSk7CisKKwlpZiAoY29uZmlnLT5zZWN0aW9uX25hbWUpCisJCWxlbiArPSBzbnBy aW50ZihidWYrbGVuLCBQQUdFX1NJWkUsCisJCQkJInNlY3Rpb24gbmFtZTpcdCVzXG4iLAorCQkJ CWNvbmZpZy0+c2VjdGlvbl9uYW1lKTsKKwllbHNlCisJCWxlbiArPSBzbnByaW50ZihidWYrbGVu LCBQQUdFX1NJWkUsCisJCQkJImRlZmF1bHQgbmFtZTpcdEVNVFBZXG4iKTsKKworCW11dGV4X3Vu bG9jaygmdGVzdF9kZXYtPmNvbmZpZ19tdXRleCk7CisKKwlyZXR1cm4gbGVuOworfQorc3RhdGlj IERFVklDRV9BVFRSX1JPKGNvbmZpZyk7CisKK3N0YXRpYyBpbnQgd3JpdGVfdGVzdChzdHJ1Y3Qg dGVzdF9saW5rdGFibGUgKnRlc3QsIGludCB3cml0ZV92YWwpCit7CisJdGVzdC0+d3JpdGVfdGVz dCA9IHdyaXRlX3ZhbDsKKwlpZiAodGVzdC0+d3JpdGVfdGVzdCAhPSB3cml0ZV92YWwpIHsKKwkJ cHJfd2FybigiV3JpdGUgdGVzdCBmYWlsZWRcbiIpOworCQlyZXR1cm4gLUVQRVJNOworCX0KKwly ZXR1cm4gMDsKK30KKworc3RhdGljIGludCBfX3Rlc3RfbGlua3RhYmxlKHN0cnVjdCBsaW5rdGFi bGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2LAorCQkJICAgIHN0cnVjdCB0ZXN0X2xpbmt0YWJsZSAq dGVzdCkKK3sKKwlzdHJ1Y3QgdGVzdF9jb25maWcgKmNvbmZpZyA9ICZ0ZXN0X2Rldi0+Y29uZmln OworCWludCByYzsKKworCWlmICh0ZXN0LT5leHBlY3RlZCAhPSB0ZXN0X2Rldi0+bnVtX2NhbGxl ZCkgeworCQlwcl93YXJuKCJ0ZXN0IHJvdXRpbmUgSUQgJWQgY2FsbGVkIG9uIG9yZGVyICVkXG4i LAorCQkJdGVzdC0+ZXhwZWN0ZWQsIHRlc3RfZGV2LT5udW1fY2FsbGVkKTsKKwkJcmV0dXJuIC1F SU5WQUw7CisJfQorCisJcmMgPSB3cml0ZV90ZXN0KHRlc3QsIHRlc3QtPmV4cGVjdGVkKzEpOwor CWlmIChyYykKKwkJcmV0dXJuIHJjOworCisJcmMgPSB0ZXN0LT5vcChjb25maWctPmlucHV0KTsK Kwl0ZXN0X2Rldi0+bnVtX2NhbGxlZCsrOworCisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgaW50 IF9fdGVzdF9saW5rdGFibGVfcm8oc3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqdGVzdF9k ZXYsCisJCQkgICAgICAgY29uc3Qgc3RydWN0IHRlc3RfbGlua3RhYmxlICp0ZXN0KQoreworCXN0 cnVjdCB0ZXN0X2NvbmZpZyAqY29uZmlnID0gJnRlc3RfZGV2LT5jb25maWc7CisJaW50IHJjOwor CisJaWYgKHRlc3QtPmV4cGVjdGVkICE9IHRlc3RfZGV2LT5udW1fY2FsbGVkKSB7CisJCXByX2lu Zm8oInRlc3Qgcm91dGluZSBJRCAlZCBjYWxsZWQgb24gb3JkZXIgJWRcbiIsCisJCQl0ZXN0LT5l eHBlY3RlZCwgdGVzdF9kZXYtPm51bV9jYWxsZWQpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisK KwkvKgorCSAqIE5vdGUsIGNvbXBpbGVyIHdvdWxkIGNvbXBsYWluIGlmIHdlIHRyaWVkIHdyaXRl X3Rlc3QoKSBzbworCSAqIG5vIG5lZWQgdG8gdGVzdCB0aGF0LgorCSAqLworCisJcmMgPSB0ZXN0 LT5vcChjb25maWctPmlucHV0KTsKKwl0ZXN0X2Rldi0+bnVtX2NhbGxlZCsrOworCisJcmV0dXJu IHJjOworfQorCitzdGF0aWMgZW51bSBsaW5rdGFibGVfdGVzdF9jYXNlIGdldF90ZXN0X2Nhc2Uo Y29uc3QgY2hhciAqc2VjdGlvbl9uYW1lKQoreworCWlmIChzdHJjbXAoIi5pbml0LnRleHQiLCBz ZWN0aW9uX25hbWUpID09IDApCisJCXJldHVybiBURVNUX0xJTktUQUJMRV9JTklUOworCWlmIChz dHJjbXAoIi5pbml0LmRhdGEiLCBzZWN0aW9uX25hbWUpID09IDApCisJCXJldHVybiBURVNUX0xJ TktUQUJMRV9JTklUX0RBVEE7CisJaWYgKHN0cmNtcCgiLmRhdGEiLCBzZWN0aW9uX25hbWUpID09 IDApCisJCXJldHVybiBURVNUX0xJTktUQUJMRTsKKwlpZiAoc3RyY21wKCIudGV4dCIsIHNlY3Rp b25fbmFtZSkgPT0gMCkKKwkJcmV0dXJuIFRFU1RfTElOS1RBQkxFX1RFWFQ7CisJaWYgKHN0cmNt cCgiLnJvZGF0YSIsIHNlY3Rpb25fbmFtZSkgPT0gMCkKKwkJcmV0dXJuIFRFU1RfTElOS1RBQkxF X1RFWFQ7CisKKwlyZXR1cm4gX19URVNUX0xJTktUQUJMRV9JTlZBTElEOworfQorCitzdGF0aWMg aW50IF9fcnVuX3Nhbml0eV90ZXN0KHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3Rf ZGV2LAorCQkJICAgICBpbnQgbnVtX2VudHJpZXMpCit7CisJaWYgKCFudW1fZW50cmllcykgewor CQlwcl93YXJuKCJubyB0ZXN0cyAtLSB0aGlzIGlzIGludmFsaWRcbiIpOworCQlyZXR1cm4gLUVJ TlZBTDsKKwl9CisKKwlwcl9kZWJ1ZygibnVtYmVyIG9mIHRlc3RzOiAlZFxuIiwgbnVtX2VudHJp ZXMpOworCisJaWYgKG51bV9lbnRyaWVzICE9IE5VTV9URVNUUykgeworCQlwcl93YXJuKCJleHBl Y3RlZDogJWQgdGVzdFxuIiwgTlVNX1RFU1RTKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJ cmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0IHJ1bl9pbml0X3RleHRfdGVzdChzdHJ1 Y3QgbGlua3RhYmxlX3Rlc3RfZGV2aWNlICp0ZXN0X2RldikKK3sKKwlpbnQgcmV0LCB0b3RhbCA9 IDA7CisJY29uc3Qgc3RydWN0IHRlc3RfbGlua3RhYmxlICp0ZXN0OworCXVuc2lnbmVkIGludCBu dW1fZW50cmllcyA9IExJTktUQUJMRV9TSVpFKHRlc3RfZm5zX2luaXRfdGV4dCk7CisKKwlyZXQg PSBfX3J1bl9zYW5pdHlfdGVzdCh0ZXN0X2RldiwgbnVtX2VudHJpZXMpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKKwlsaW5rdGFibGVfZm9yX2VhY2godGVzdCwgdGVzdF9mbnNfaW5pdF90 ZXh0KQorCQl0b3RhbCArPSBfX3Rlc3RfbGlua3RhYmxlX3JvKHRlc3RfZGV2LCB0ZXN0KTsKKwor CXJldHVybiB0b3RhbDsKK30KKworc3RhdGljIGludCBfX2luaXQgcnVuX2luaXRfZGF0YV90ZXN0 KHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2KQoreworCWludCByZXQsIHRv dGFsID0gMDsKKwlzdHJ1Y3QgdGVzdF9saW5rdGFibGUgKnRlc3Q7CisJdW5zaWduZWQgaW50IG51 bV9lbnRyaWVzID0gTElOS1RBQkxFX1NJWkUodGVzdF9mbnNfaW5pdF9kYXRhKTsKKworCXJldCA9 IF9fcnVuX3Nhbml0eV90ZXN0KHRlc3RfZGV2LCBudW1fZW50cmllcyk7CisJaWYgKHJldCkKKwkJ cmV0dXJuIHJldDsKKworCWxpbmt0YWJsZV9mb3JfZWFjaCh0ZXN0LCB0ZXN0X2Zuc19pbml0X2Rh dGEpCisJCXRvdGFsICs9IF9fdGVzdF9saW5rdGFibGUodGVzdF9kZXYsIHRlc3QpOworCisJcmV0 dXJuIHRvdGFsOworfQorCitzdGF0aWMgaW50IHJ1bl9kYXRhX3Rlc3Qoc3RydWN0IGxpbmt0YWJs ZV90ZXN0X2RldmljZSAqdGVzdF9kZXYpCit7CisJaW50IHJldCwgdG90YWwgPSAwOworCXN0cnVj dCB0ZXN0X2xpbmt0YWJsZSAqdGVzdDsKKwl1bnNpZ25lZCBpbnQgbnVtX2VudHJpZXMgPSBMSU5L VEFCTEVfU0laRSh0ZXN0X2Zuc19kYXRhKTsKKworCXJldCA9IF9fcnVuX3Nhbml0eV90ZXN0KHRl c3RfZGV2LCBudW1fZW50cmllcyk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCWxpbmt0 YWJsZV9mb3JfZWFjaCh0ZXN0LCB0ZXN0X2Zuc19kYXRhKQorCQl0b3RhbCArPSBfX3Rlc3RfbGlu a3RhYmxlKHRlc3RfZGV2LCB0ZXN0KTsKKworCXJldHVybiB0b3RhbDsKK30KKworc3RhdGljIGlu dCBydW5fdGV4dF90ZXN0KHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2KQor eworCWludCByZXQsIHRvdGFsID0gMDsKKwljb25zdCBzdHJ1Y3QgdGVzdF9saW5rdGFibGUgKnRl c3Q7CisJdW5zaWduZWQgaW50IG51bV9lbnRyaWVzID0gTElOS1RBQkxFX1NJWkUodGVzdF9mbnNf dGV4dCk7CisKKwlyZXQgPSBfX3J1bl9zYW5pdHlfdGVzdCh0ZXN0X2RldiwgbnVtX2VudHJpZXMp OworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlsaW5rdGFibGVfZm9yX2VhY2godGVzdCwg dGVzdF9mbnNfdGV4dCkKKwkJdG90YWwgKz0gX190ZXN0X2xpbmt0YWJsZV9ybyh0ZXN0X2Rldiwg dGVzdCk7CisKKwlyZXR1cm4gdG90YWw7Cit9CisKK3N0YXRpYyBpbnQgcnVuX3JvZGF0YV90ZXN0 KHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2KQoreworCWludCByZXQsIHRv dGFsID0gMDsKKwljb25zdCBzdHJ1Y3QgdGVzdF9saW5rdGFibGUgKnRlc3Q7CisJdW5zaWduZWQg aW50IG51bV9lbnRyaWVzID0gTElOS1RBQkxFX1NJWkUodGVzdF9mbnNfcm9kYXRhKTsKKworCXJl dCA9IF9fcnVuX3Nhbml0eV90ZXN0KHRlc3RfZGV2LCBudW1fZW50cmllcyk7CisJaWYgKHJldCkK KwkJcmV0dXJuIHJldDsKKworCWxpbmt0YWJsZV9mb3JfZWFjaCh0ZXN0LCB0ZXN0X2Zuc19yb2Rh dGEpCisJCXRvdGFsICs9IF9fdGVzdF9saW5rdGFibGVfcm8odGVzdF9kZXYsIHRlc3QpOworCisJ cmV0dXJuIHRvdGFsOworfQorCitzdGF0aWMgaW50IF9fcmVmIF9fdHJpZ2dlcl9jb25maWdfcnVu KHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2KQoreworCWVudW0gbGlua3Rh YmxlX3Rlc3RfY2FzZSB0ZXN0X2Nhc2U7CisJc3RydWN0IHRlc3RfY29uZmlnICpjb25maWcgPSAm dGVzdF9kZXYtPmNvbmZpZzsKKworCXRlc3RfZGV2LT5udW1fY2FsbGVkID0gMDsKKwl0ZXN0X2Nh c2UgPSBnZXRfdGVzdF9jYXNlKGNvbmZpZy0+c2VjdGlvbl9uYW1lKTsKKworCXN3aXRjaCAodGVz dF9jYXNlKSB7CisJY2FzZSBURVNUX0xJTktUQUJMRV9JTklUOgorCQlpZiAoIWluaXRfY29tcGxl dGVkKQorCQkJcmV0dXJuIHJ1bl9pbml0X3RleHRfdGVzdCh0ZXN0X2Rldik7CisJCWVsc2UKKwkJ CXJldHVybiAtRUFDQ0VTOworCWNhc2UgVEVTVF9MSU5LVEFCTEVfSU5JVF9EQVRBOgorCQlpZiAo IWluaXRfY29tcGxldGVkKQorCQkJcmV0dXJuIHJ1bl9pbml0X2RhdGFfdGVzdCh0ZXN0X2Rldik7 CisJCWVsc2UKKwkJCXJldHVybiAtRUFDQ0VTOworCWNhc2UgVEVTVF9MSU5LVEFCTEU6CisJCXJl dHVybiBydW5fZGF0YV90ZXN0KHRlc3RfZGV2KTsKKwljYXNlIFRFU1RfTElOS1RBQkxFX1RFWFQ6 CisJCXJldHVybiBydW5fdGV4dF90ZXN0KHRlc3RfZGV2KTsKKwljYXNlIFRFU1RfTElOS1RBQkxF X1JPOgorCQlyZXR1cm4gcnVuX3JvZGF0YV90ZXN0KHRlc3RfZGV2KTsKKwlkZWZhdWx0OgorCQlw cl93YXJuKCJJbnZhbGlkIHRlc3QgY2FzZSByZXF1ZXN0ZWQ6ICVzXG4iLAorCQkJY29uZmlnLT5z ZWN0aW9uX25hbWUpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9Cit9CisKK3N0YXRpYyBpbnQgdHJp Z2dlcl9jb25maWdfcnVuKHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2KQor eworCXN0cnVjdCB0ZXN0X2NvbmZpZyAqY29uZmlnID0gJnRlc3RfZGV2LT5jb25maWc7CisJaW50 IHJjOworCisJbXV0ZXhfbG9jaygmdGVzdF9kZXYtPnRyaWdnZXJfbXV0ZXgpOworCW11dGV4X2xv Y2soJnRlc3RfZGV2LT5jb25maWdfbXV0ZXgpOworCisJcHJfZGVidWcoInJ1bm5pbmcgdGVzdCBv biAnJXMnXG4iLCBjb25maWctPnNlY3Rpb25fbmFtZSk7CisKKwlyYyA9IF9fdHJpZ2dlcl9jb25m aWdfcnVuKHRlc3RfZGV2KTsKKworCWNvbmZpZy0+dGVzdF9yZXN1bHQgPSByYzsKKwlwcl9kZWJ1 ZygicmVzdWx0OiAlZFxuIiwgcmMpOworCisJaWYgKHJjIDwgMCkgeworCQlyYyA9IC1FSU5WQUw7 CisJCWdvdG8gb3V0OworCX0KKworCXJjID0gMDsKKworb3V0OgorCW11dGV4X3VubG9jaygmdGVz dF9kZXYtPmNvbmZpZ19tdXRleCk7CisJbXV0ZXhfdW5sb2NrKCZ0ZXN0X2Rldi0+dHJpZ2dlcl9t dXRleCk7CisKKwlyZXR1cm4gcmM7Cit9CisKK3N0YXRpYyBzc2l6ZV90Cit0cmlnZ2VyX2NvbmZp Z19zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCSAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1 dGUgKmF0dHIsCisJCSAgICAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJc3Ry dWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqdGVzdF9kZXYgPSBkZXZfdG9fdGVzdF9kZXYoZGV2 KTsKKwlpbnQgcmM7CisKKwlyYyA9IHRyaWdnZXJfY29uZmlnX3J1bih0ZXN0X2Rldik7CisJaWYg KHJjKQorCQlnb3RvIG91dDsKKworCXJjID0gY291bnQ7CitvdXQ6CisJcmV0dXJuIHJjOworfQor c3RhdGljIERFVklDRV9BVFRSX1dPKHRyaWdnZXJfY29uZmlnKTsKKworLyoKKyAqIFhYWDogbW92 ZSB0byBrc3RybmNweSgpIG9uY2UgbWVyZ2VkLgorICoKKyAqIFVzZXJzIHNob3VsZCB1c2Uga2Zy ZWVfY29uc3QoKSB3aGVuIGZyZWVpbmcgdGhlc2UuCisgKi8KK3N0YXRpYyBpbnQgX19rc3RybmNw eShjaGFyICoqZHN0LCBjb25zdCBjaGFyICpuYW1lLCBzaXplX3QgY291bnQsIGdmcF90IGdmcCkK K3sKKwkqZHN0ID0ga3N0cm5kdXAobmFtZSwgY291bnQsIGdmcCk7CisJaWYgKCEqZHN0KQorCQly ZXR1cm4gLUVOT1NQQzsKKwlyZXR1cm4gY291bnQ7Cit9CisKK3N0YXRpYyBpbnQgY29uZmlnX2Nv cHlfc2VjdGlvbl9uYW1lKHN0cnVjdCB0ZXN0X2NvbmZpZyAqY29uZmlnLAorCQkJCSAgICBjb25z dCBjaGFyICpuYW1lLAorCQkJCSAgICBzaXplX3QgY291bnQpCit7CisJcmV0dXJuIF9fa3N0cm5j cHkoJmNvbmZpZy0+c2VjdGlvbl9uYW1lLCBuYW1lLCBjb3VudCwgR0ZQX0tFUk5FTCk7Cit9CisK K3N0YXRpYyB2b2lkIF9fbGlua3RhYmxlX2NvbmZpZ19mcmVlKHN0cnVjdCB0ZXN0X2NvbmZpZyAq Y29uZmlnKQoreworCWtmcmVlX2NvbnN0KGNvbmZpZy0+c2VjdGlvbl9uYW1lKTsKKwljb25maWct PnNlY3Rpb25fbmFtZSA9IE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIGxpbmt0YWJsZV9jb25maWdf ZnJlZShzdHJ1Y3QgbGlua3RhYmxlX3Rlc3RfZGV2aWNlICp0ZXN0X2RldikKK3sKKwlzdHJ1Y3Qg dGVzdF9jb25maWcgKmNvbmZpZyA9ICZ0ZXN0X2Rldi0+Y29uZmlnOworCisJbXV0ZXhfbG9jaygm dGVzdF9kZXYtPmNvbmZpZ19tdXRleCk7CisJX19saW5rdGFibGVfY29uZmlnX2ZyZWUoY29uZmln KTsKKwltdXRleF91bmxvY2soJnRlc3RfZGV2LT5jb25maWdfbXV0ZXgpOworfQorCitzdGF0aWMg c3NpemVfdCBjb25maWdfc2VjdGlvbl9uYW1lX3N0b3JlKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJ CQkJIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJCQkgY29uc3QgY2hhciAqYnVm LCBzaXplX3QgY291bnQpCit7CisJc3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqdGVzdF9k ZXYgPSBkZXZfdG9fdGVzdF9kZXYoZGV2KTsKKwlzdHJ1Y3QgdGVzdF9jb25maWcgKmNvbmZpZyA9 ICZ0ZXN0X2Rldi0+Y29uZmlnOworCWludCByYzsKKworCW11dGV4X2xvY2soJnRlc3RfZGV2LT5j b25maWdfbXV0ZXgpOworCXJjID0gY29uZmlnX2NvcHlfc2VjdGlvbl9uYW1lKGNvbmZpZywgYnVm LCBjb3VudCk7CisJbXV0ZXhfdW5sb2NrKCZ0ZXN0X2Rldi0+Y29uZmlnX211dGV4KTsKKworCXJl dHVybiByYzsKK30KKworLyoKKyAqIEFzIHBlciBzeXNmc19rZl9zZXFfc2hvdygpIHRoZSBidWYg aXMgbWF4IFBBR0VfU0laRS4KKyAqLworc3RhdGljIHNzaXplX3QgY29uZmlnX3Rlc3Rfc2hvd19z dHIoc3RydWN0IG11dGV4ICpjb25maWdfbXV0ZXgsCisJCQkJICAgIGNoYXIgKmRzdCwKKwkJCQkg ICAgY2hhciAqc3JjKQoreworCWludCBsZW47CisKKwltdXRleF9sb2NrKGNvbmZpZ19tdXRleCk7 CisJbGVuID0gc25wcmludGYoZHN0LCBQQUdFX1NJWkUsICIlc1xuIiwgc3JjKTsKKwltdXRleF91 bmxvY2soY29uZmlnX211dGV4KTsKKworCXJldHVybiBsZW47Cit9CisKK3N0YXRpYyBzc2l6ZV90 IGNvbmZpZ19zZWN0aW9uX25hbWVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkJCXN0cnVj dCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJCQljaGFyICpidWYpCit7CisJc3RydWN0IGxp bmt0YWJsZV90ZXN0X2RldmljZSAqdGVzdF9kZXYgPSBkZXZfdG9fdGVzdF9kZXYoZGV2KTsKKwlz dHJ1Y3QgdGVzdF9jb25maWcgKmNvbmZpZyA9ICZ0ZXN0X2Rldi0+Y29uZmlnOworCisJcmV0dXJu IGNvbmZpZ190ZXN0X3Nob3dfc3RyKCZ0ZXN0X2Rldi0+Y29uZmlnX211dGV4LCBidWYsCisJCQkJ ICAgIGNvbmZpZy0+c2VjdGlvbl9uYW1lKTsKK30KK3N0YXRpYyBERVZJQ0VfQVRUUihjb25maWdf c2VjdGlvbl9uYW1lLCAwNjQ0LCBjb25maWdfc2VjdGlvbl9uYW1lX3Nob3csCisJCSAgIGNvbmZp Z19zZWN0aW9uX25hbWVfc3RvcmUpOworCitzdGF0aWMgaW50IHRyaWdnZXJfY29uZmlnX3J1bl9u YW1lZChzdHJ1Y3QgbGlua3RhYmxlX3Rlc3RfZGV2aWNlICp0ZXN0X2RldiwKKwkJCQkgICAgY29u c3QgY2hhciAqc2VjdGlvbl9uYW1lKQoreworCWludCBjb3BpZWQ7CisJc3RydWN0IHRlc3RfY29u ZmlnICpjb25maWcgPSAmdGVzdF9kZXYtPmNvbmZpZzsKKworCW11dGV4X2xvY2soJnRlc3RfZGV2 LT5jb25maWdfbXV0ZXgpOworCWNvcGllZCA9IGNvbmZpZ19jb3B5X3NlY3Rpb25fbmFtZShjb25m aWcsIHNlY3Rpb25fbmFtZSwKKwkJCQkJICBzdHJsZW4oc2VjdGlvbl9uYW1lKSk7CisJbXV0ZXhf dW5sb2NrKCZ0ZXN0X2Rldi0+Y29uZmlnX211dGV4KTsKKworCWlmIChjb3BpZWQgPD0wIHx8IGNv cGllZCAhPSBzdHJsZW4oc2VjdGlvbl9uYW1lKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlyZXR1 cm4gdHJpZ2dlcl9jb25maWdfcnVuKHRlc3RfZGV2KTsKK30KKworc3RhdGljIGludCBfX2xpbmt0 YWJsZV9jb25maWdfaW5pdChzdHJ1Y3QgdGVzdF9jb25maWcgKmNvbmZpZykKK3sKKwlpbnQgcmV0 OworCisJcmV0ID0gY29uZmlnX2NvcHlfc2VjdGlvbl9uYW1lKGNvbmZpZywgVEVTVF9TRUNUSU9O X1NUQVJULAorCQkJCSAgICAgICBzdHJsZW4oVEVTVF9TRUNUSU9OX1NUQVJUKSk7CisJaWYgKHJl dCA8IDApCisJCWdvdG8gb3V0OworCisJY29uZmlnLT5pbnB1dCA9IDM7CisJY29uZmlnLT50ZXN0 X3Jlc3VsdCA9IDA7CisKK291dDoKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgc3NpemVfdCBy ZXNldF9zdG9yZShzdHJ1Y3QgZGV2aWNlICpkZXYsCisJCQkgICBzdHJ1Y3QgZGV2aWNlX2F0dHJp YnV0ZSAqYXR0ciwKKwkJCSAgIGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQoreworCXN0 cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2ID0gZGV2X3RvX3Rlc3RfZGV2KGRl dik7CisJc3RydWN0IHRlc3RfY29uZmlnICpjb25maWcgPSAmdGVzdF9kZXYtPmNvbmZpZzsKKwlp bnQgcmV0OworCisJbXV0ZXhfbG9jaygmdGVzdF9kZXYtPnRyaWdnZXJfbXV0ZXgpOworCW11dGV4 X2xvY2soJnRlc3RfZGV2LT5jb25maWdfbXV0ZXgpOworCisJX19saW5rdGFibGVfY29uZmlnX2Zy ZWUoY29uZmlnKTsKKworCXJldCA9IF9fbGlua3RhYmxlX2NvbmZpZ19pbml0KGNvbmZpZyk7CisJ aWYgKHJldCA8IDApIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZGV2X2VycihkZXYsICJjb3VsZCBu b3QgYWxsb2Mgc2V0dGluZ3MgZm9yIGNvbmZpZyB0cmlnZ2VyOiAlZFxuIiwKKwkJICAgICAgIHJl dCk7CisJCWdvdG8gb3V0OworCX0KKworCWRldl9pbmZvKGRldiwgInJlc2V0XG4iKTsKKwlyZXQg PSBjb3VudDsKKworb3V0OgorCW11dGV4X3VubG9jaygmdGVzdF9kZXYtPmNvbmZpZ19tdXRleCk7 CisJbXV0ZXhfdW5sb2NrKCZ0ZXN0X2Rldi0+dHJpZ2dlcl9tdXRleCk7CisKKwlyZXR1cm4gcmV0 OworfQorc3RhdGljIERFVklDRV9BVFRSX1dPKHJlc2V0KTsKKworc3RhdGljIGludCB0ZXN0X2Rl dl9jb25maWdfdXBkYXRlX2ludChzdHJ1Y3QgbGlua3RhYmxlX3Rlc3RfZGV2aWNlICp0ZXN0X2Rl diwKKwkJCQkgICAgICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBzaXplLAorCQkJCSAgICAgIGlu dCAqY29uZmlnKQoreworCWNoYXIgKmVuZDsKKwlsb25nIG5ldyA9IHNpbXBsZV9zdHJ0b2woYnVm LCAmZW5kLCAwKTsKKwlpZiAoZW5kID09IGJ1ZiB8fCBuZXcgPiBJTlRfTUFYIHx8IG5ldyA8IElO VF9NSU4pCisJCXJldHVybiAtRUlOVkFMOworCW11dGV4X2xvY2soJnRlc3RfZGV2LT5jb25maWdf bXV0ZXgpOworCSpjb25maWcgPSBuZXc7CisJbXV0ZXhfdW5sb2NrKCZ0ZXN0X2Rldi0+Y29uZmln X211dGV4KTsKKwkvKiBBbHdheXMgcmV0dXJuIGZ1bGwgd3JpdGUgc2l6ZSBldmVuIGlmIHdlIGRp ZG4ndCBjb25zdW1lIGFsbCAqLworCXJldHVybiBzaXplOworfQorCitzdGF0aWMgc3NpemVfdCB0 ZXN0X2Rldl9jb25maWdfc2hvd19pbnQoc3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqdGVz dF9kZXYsCisJCQkJCWNoYXIgKmJ1ZiwKKwkJCQkJaW50IGNvbmZpZykKK3sKKwlpbnQgdmFsOwor CisJbXV0ZXhfbG9jaygmdGVzdF9kZXYtPmNvbmZpZ19tdXRleCk7CisJdmFsID0gY29uZmlnOwor CW11dGV4X3VubG9jaygmdGVzdF9kZXYtPmNvbmZpZ19tdXRleCk7CisKKwlyZXR1cm4gc25wcmlu dGYoYnVmLCBQQUdFX1NJWkUsICIlZFxuIiwgdmFsKTsKK30KKworc3RhdGljIHNzaXplX3QgdGVz dF9yZXN1bHRfc3RvcmUoc3RydWN0IGRldmljZSAqZGV2LAorCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0 dHJpYnV0ZSAqYXR0ciwKKwkJCQkgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7CisJ c3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqdGVzdF9kZXYgPSBkZXZfdG9fdGVzdF9kZXYo ZGV2KTsKKwlzdHJ1Y3QgdGVzdF9jb25maWcgKmNvbmZpZyA9ICZ0ZXN0X2Rldi0+Y29uZmlnOwor CisJcmV0dXJuIHRlc3RfZGV2X2NvbmZpZ191cGRhdGVfaW50KHRlc3RfZGV2LCBidWYsIGNvdW50 LAorCQkJCQkgICZjb25maWctPnRlc3RfcmVzdWx0KTsKK30KKworc3RhdGljIHNzaXplX3QgY29u ZmlnX2lucHV0X3N0b3JlKHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCQkgIHN0cnVjdCBkZXZpY2Vf YXR0cmlidXRlICphdHRyLAorCQkJCSAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgY291bnQpCit7 CisJc3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqdGVzdF9kZXYgPSBkZXZfdG9fdGVzdF9k ZXYoZGV2KTsKKwlzdHJ1Y3QgdGVzdF9jb25maWcgKmNvbmZpZyA9ICZ0ZXN0X2Rldi0+Y29uZmln OworCisJcmV0dXJuIHRlc3RfZGV2X2NvbmZpZ191cGRhdGVfaW50KHRlc3RfZGV2LCBidWYsIGNv dW50LAorCQkJCQkgICZjb25maWctPmlucHV0KTsKK30KKworc3RhdGljIHNzaXplX3QgY29uZmln X2lucHV0X3Nob3coc3RydWN0IGRldmljZSAqZGV2LAorCQkJCSBzdHJ1Y3QgZGV2aWNlX2F0dHJp YnV0ZSAqYXR0ciwKKwkJCQkgY2hhciAqYnVmKQoreworCXN0cnVjdCBsaW5rdGFibGVfdGVzdF9k ZXZpY2UgKnRlc3RfZGV2ID0gZGV2X3RvX3Rlc3RfZGV2KGRldik7CisJc3RydWN0IHRlc3RfY29u ZmlnICpjb25maWcgPSAmdGVzdF9kZXYtPmNvbmZpZzsKKworCXJldHVybiB0ZXN0X2Rldl9jb25m aWdfc2hvd19pbnQodGVzdF9kZXYsIGJ1ZiwgY29uZmlnLT5pbnB1dCk7Cit9CitzdGF0aWMgREVW SUNFX0FUVFIoY29uZmlnX2lucHV0LCAwNjQ0LCBjb25maWdfaW5wdXRfc2hvdywgY29uZmlnX2lu cHV0X3N0b3JlKTsKKworc3RhdGljIHNzaXplX3QgdGVzdF9yZXN1bHRfc2hvdyhzdHJ1Y3QgZGV2 aWNlICpkZXYsCisJCQkJc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCisJCQkJY2hhciAq YnVmKQoreworCXN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2ID0gZGV2X3Rv X3Rlc3RfZGV2KGRldik7CisJc3RydWN0IHRlc3RfY29uZmlnICpjb25maWcgPSAmdGVzdF9kZXYt PmNvbmZpZzsKKworCXJldHVybiB0ZXN0X2Rldl9jb25maWdfc2hvd19pbnQodGVzdF9kZXYsIGJ1 ZiwgY29uZmlnLT50ZXN0X3Jlc3VsdCk7Cit9CitzdGF0aWMgREVWSUNFX0FUVFIodGVzdF9yZXN1 bHQsIDA2NDQsIHRlc3RfcmVzdWx0X3Nob3csIHRlc3RfcmVzdWx0X3N0b3JlKTsKKworI2RlZmlu ZSBMSU5LVEFCTEVfREVWX0FUVFIobmFtZSkJCSZkZXZfYXR0cl8jI25hbWUuYXR0cgorCitzdGF0 aWMgc3RydWN0IGF0dHJpYnV0ZSAqdGVzdF9kZXZfYXR0cnNbXSA9IHsKKwlMSU5LVEFCTEVfREVW X0FUVFIodHJpZ2dlcl9jb25maWcpLAorCUxJTktUQUJMRV9ERVZfQVRUUihjb25maWcpLAorCUxJ TktUQUJMRV9ERVZfQVRUUihyZXNldCksCisKKwlMSU5LVEFCTEVfREVWX0FUVFIoY29uZmlnX3Nl Y3Rpb25fbmFtZSksCisJTElOS1RBQkxFX0RFVl9BVFRSKGNvbmZpZ19pbnB1dCksCisJTElOS1RB QkxFX0RFVl9BVFRSKHRlc3RfcmVzdWx0KSwKKworCU5VTEwsCit9OworCitBVFRSSUJVVEVfR1JP VVBTKHRlc3RfZGV2KTsKKworc3RhdGljIGludCBsaW5rdGFibGVfY29uZmlnX2luaXQoc3RydWN0 IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqdGVzdF9kZXYpCit7CisJc3RydWN0IHRlc3RfY29uZmln ICpjb25maWcgPSAmdGVzdF9kZXYtPmNvbmZpZzsKKwlpbnQgcmV0OworCisJbXV0ZXhfbG9jaygm dGVzdF9kZXYtPmNvbmZpZ19tdXRleCk7CisJcmV0ID0gX19saW5rdGFibGVfY29uZmlnX2luaXQo Y29uZmlnKTsKKwltdXRleF91bmxvY2soJnRlc3RfZGV2LT5jb25maWdfbXV0ZXgpOworCisJcmV0 dXJuIHJldDsKK30KKworc3RhdGljIHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKmFsbG9j X3Rlc3RfZGV2X2xpbmt0YWJsZSh2b2lkKQoreworCWludCByYzsKKwlzdHJ1Y3QgbGlua3RhYmxl X3Rlc3RfZGV2aWNlICp0ZXN0X2RldjsKKwlzdHJ1Y3QgbWlzY2RldmljZSAqbWlzY19kZXY7CisK Kwl0ZXN0X2RldiA9IHZtYWxsb2Moc2l6ZW9mKHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2Up KTsKKwlpZiAoIXRlc3RfZGV2KSB7CisJCXByX2VycigiQ2Fubm90IGFsbG9jIHRlc3RfZGV2XG4i KTsKKwkJZ290byBlcnJfb3V0OworCX0KKworCW1lbXNldCh0ZXN0X2RldiwgMCwgc2l6ZW9mKHN0 cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UpKTsKKworCW11dGV4X2luaXQoJnRlc3RfZGV2LT5j b25maWdfbXV0ZXgpOworCW11dGV4X2luaXQoJnRlc3RfZGV2LT50cmlnZ2VyX211dGV4KTsKKwor CXJjID0gbGlua3RhYmxlX2NvbmZpZ19pbml0KHRlc3RfZGV2KTsKKwlpZiAocmMgPCAwKSB7CisJ CXByX2VycigiQ2Fubm90IGFsbG9jIGxpbmt0YWJsZV9jb25maWdfaW5pdCgpXG4iKTsKKwkJZ290 byBlcnJfb3V0X2ZyZWU7CisJfQorCisJbWlzY19kZXYgPSAmdGVzdF9kZXYtPm1pc2NfZGV2Owor CisJbWlzY19kZXYtPm1pbm9yID0gTUlTQ19EWU5BTUlDX01JTk9SOworCW1pc2NfZGV2LT5uYW1l ID0gdGVzdF9kZXZfbmFtZTsKKwltaXNjX2Rldi0+Z3JvdXBzID0gdGVzdF9kZXZfZ3JvdXBzOwor CisJcmV0dXJuIHRlc3RfZGV2OworCitlcnJfb3V0X2ZyZWU6CisJa2ZyZWUodGVzdF9kZXYpOwor ZXJyX291dDoKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHZvaWQgZnJlZV90ZXN0X2Rldl9s aW5rdGFibGUoc3RydWN0IGxpbmt0YWJsZV90ZXN0X2RldmljZSAqdGVzdF9kZXYpCit7CisJdGVz dF9kZXYtPm1pc2NfZGV2Lm5hbWUgPSBOVUxMOworCXZmcmVlKHRlc3RfZGV2KTsKKwl0ZXN0X2Rl diA9IE5VTEw7CisJbGlua3RhYmxlX2NvbmZpZ19mcmVlKHRlc3RfZGV2KTsKK30KKworc3RhdGlj IHN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnJlZ2lzdGVyX3Rlc3RfZGV2X2xpbmt0YWJs ZSh2b2lkKQoreworCXN0cnVjdCBsaW5rdGFibGVfdGVzdF9kZXZpY2UgKnRlc3RfZGV2ID0gTlVM TDsKKwlpbnQgcmM7CisKKwl0ZXN0X2RldiA9IGFsbG9jX3Rlc3RfZGV2X2xpbmt0YWJsZSgpOwor CWlmICghdGVzdF9kZXYpIHsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJcmMgPSBtaXNjX3JlZ2lz dGVyKCZ0ZXN0X2Rldi0+bWlzY19kZXYpOworCWlmIChyYykgeworCQlwcl9lcnIoImNvdWxkIG5v dCByZWdpc3RlciBtaXNjIGRldmljZTogJWRcbiIsIHJjKTsKKwkJZnJlZV90ZXN0X2Rldl9saW5r dGFibGUodGVzdF9kZXYpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwl0ZXN0X2Rldi0+ZGV2ID0g dGVzdF9kZXYtPm1pc2NfZGV2LnRoaXNfZGV2aWNlOworCWRldl9kYmcodGVzdF9kZXYtPmRldiwg ImludGVyZmFjZSByZWFkeVxuIik7CisKKwlyZXR1cm4gdGVzdF9kZXY7Cit9CisKK3N0YXRpYyBp bnQgX19pbml0IHRlc3RfbGlua3RhYmxlX2luaXQodm9pZCkKK3sKKwlzdHJ1Y3QgbGlua3RhYmxl X3Rlc3RfZGV2aWNlICp0ZXN0X2RldjsKKwlpbnQgcmM7CisKKwl0ZXN0X2RldiA9IHJlZ2lzdGVy X3Rlc3RfZGV2X2xpbmt0YWJsZSgpOworCWlmICghdGVzdF9kZXYpIHsKKwkJcHJfZXJyKCJDYW5u b3QgYWRkIHRlc3QgbGlua3RhYmxlIGRldmljZVxuIik7CisJCXJldHVybiAtRU5PREVWOworCX0K KworCXJjID0gdHJpZ2dlcl9jb25maWdfcnVuX25hbWVkKHRlc3RfZGV2LCAiLmluaXQudGV4dCIp OworCWlmIChXQVJOX09OKHJjKSkKKwkJcmV0dXJuIHJjOworCXJjID0gdHJpZ2dlcl9jb25maWdf cnVuX25hbWVkKHRlc3RfZGV2LCAiLmluaXQuZGF0YSIpOworCWlmIChXQVJOX09OKHJjKSkKKwkJ cmV0dXJuIHJjOworCisJaW5pdF9jb21wbGV0ZWQgPSB0cnVlOworCisJcmMgPSB0cmlnZ2VyX2Nv bmZpZ19ydW5fbmFtZWQodGVzdF9kZXYsICIuZGF0YSIpOworCWlmIChXQVJOX09OKHJjKSkKKwkJ cmV0dXJuIHJjOworCXJjID0gdHJpZ2dlcl9jb25maWdfcnVuX25hbWVkKHRlc3RfZGV2LCAiLnRl eHQiKTsKKwlpZiAoV0FSTl9PTihyYykpCisJCXJldHVybiByYzsKKwlyYyA9IHRyaWdnZXJfY29u ZmlnX3J1bl9uYW1lZCh0ZXN0X2RldiwgIi5yb2RhdGEiKTsKKwlpZiAoV0FSTl9PTihyYykpCisJ CXJldHVybiByYzsKKworCXByX2luZm8oImxpbmtlciB0YWJsZSB0ZXN0czogT0shXG4iKTsKKwor CXJldHVybiAwOworfQorbGF0ZV9pbml0Y2FsbCh0ZXN0X2xpbmt0YWJsZV9pbml0KTsKKworc3Rh dGljCit2b2lkIHVucmVnaXN0ZXJfdGVzdF9kZXZfbGlua3RhYmxlKHN0cnVjdCBsaW5rdGFibGVf dGVzdF9kZXZpY2UgKnRlc3RfZGV2KQoreworCWRldl9pbmZvKHRlc3RfZGV2LT5kZXYsICJyZW1v dmluZyBpbnRlcmZhY2VcbiIpOworCW1pc2NfZGVyZWdpc3RlcigmdGVzdF9kZXYtPm1pc2NfZGV2 KTsKKwlmcmVlX3Rlc3RfZGV2X2xpbmt0YWJsZSh0ZXN0X2Rldik7Cit9CisKK3N0YXRpYyB2b2lk IF9fZXhpdCB0ZXN0X2xpbmt0YWJsZV9leGl0KHZvaWQpCit7CisJc3RydWN0IGxpbmt0YWJsZV90 ZXN0X2RldmljZSAqdGVzdF9kZXYgPSBfX3Rlc3RfZGV2OworCisJdW5yZWdpc3Rlcl90ZXN0X2Rl dl9saW5rdGFibGUodGVzdF9kZXYpOworfQorbW9kdWxlX2V4aXQodGVzdF9saW5rdGFibGVfZXhp dCk7CisKK01PRFVMRV9BVVRIT1IoIkx1aXMgUi4gUm9kcmlndWV6IDxtY2dyb2ZAa2VybmVsLm9y Zz4iKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKZGlmZiAtLWdpdCBhL2xpYi90ZXN0X2xpbmt0 YWJsZXMvdGVzdC1saW5rdGFibGVzLmggYi9saWIvdGVzdF9saW5rdGFibGVzL3Rlc3QtbGlua3Rh Ymxlcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYzljOWQ1Yzg3 MjYzCi0tLSAvZGV2L251bGwKKysrIGIvbGliL3Rlc3RfbGlua3RhYmxlcy90ZXN0LWxpbmt0YWJs ZXMuaApAQCAtMCwwICsxLDQ4IEBACisjaW5jbHVkZSA8bGludXgvdGFibGVzLmg+CisKK3N0cnVj dCB0ZXN0X2xpbmt0YWJsZSB7CisJaW50IGV4cGVjdGVkOworCWludCB3cml0ZV90ZXN0OworCWlu dCAoKm9wKShpbnQgaW5wdXRfZGlnaXQpOworfTsKKworI2RlZmluZSB0ZXN0X2xpbmt0YWJsZV9p bml0X3RleHQoX19sZXZlbCwgX19vcCkJCQkJXAorCXN0YXRpYyBMSU5LVEFCTEVfSU5JVCh0ZXN0 X2Zuc19pbml0X3RleHQsIF9fbGV2ZWwpCQlcCisJX190ZXN0X2ZuX2luaXRfdGV4dF8jI19fb3Ag PSB7CQkJCQlcCisJCS5leHBlY3RlZCA9IF9fbGV2ZWwsCQkJCQlcCisJCS5vcCA9IF9fb3AsCQkJ CQkJXAorfTsKKworI2RlZmluZSB0ZXN0X2xpbmt0YWJsZV9pbml0X2RhdGEoX19sZXZlbCwgX19v cCkJCQkJXAorCXN0YXRpYyBMSU5LVEFCTEVfSU5JVF9EQVRBKHRlc3RfZm5zX2luaXRfZGF0YSwg X19sZXZlbCkJCVwKKwlfX3Rlc3RfZm5faW5pdF9kYXRhXyMjX19vcCA9IHsJCQkJCVwKKwkJLmV4 cGVjdGVkID0gX19sZXZlbCwJCQkJCVwKKwkJLm9wID0gX19vcCwJCQkJCQlcCit9OworCisjZGVm aW5lIHRlc3RfbGlua3RhYmxlKF9fbGV2ZWwsIF9fb3ApCQkJCQlcCisJc3RhdGljIExJTktUQUJM RSh0ZXN0X2Zuc19kYXRhLCBfX2xldmVsKQkJCVwKKwlfX3Rlc3RfZm5fZGF0YV8jI19fb3AgPSB7 CQkJCQlcCisJCS5leHBlY3RlZCA9IF9fbGV2ZWwsCQkJCQlcCisJCS5vcCA9IF9fb3AsCQkJCQkJ XAorfTsKKworI2RlZmluZSB0ZXN0X2xpbmt0YWJsZV90ZXh0KF9fbGV2ZWwsIF9fb3ApCQkJCVwK KwlzdGF0aWMgTElOS1RBQkxFX1RFWFQodGVzdF9mbnNfdGV4dCwgX19sZXZlbCkJCQlcCisJX190 ZXN0X2ZuX3RleHRfIyNfX29wID0gewkJCQkJXAorCQkuZXhwZWN0ZWQgPSBfX2xldmVsLAkJCQkJ XAorCQkub3AgPSBfX29wLAkJCQkJCVwKK307CisKKyNkZWZpbmUgdGVzdF9saW5rdGFibGVfcm9k YXRhKF9fbGV2ZWwsIF9fb3ApCQkJCVwKKwlzdGF0aWMgTElOS1RBQkxFX1JPKHRlc3RfZm5zX3Jv ZGF0YSwgX19sZXZlbCkJCQlcCisJX190ZXN0X2ZuX3JvZGF0YV8jI19fb3AgPSB7CQkJCQlcCisJ CS5leHBlY3RlZCA9IF9fbGV2ZWwsCQkJCQlcCisJCS5vcCA9IF9fb3AsCQkJCQkJXAorfTsKKwor REVDTEFSRV9MSU5LVEFCTEVfUk8oc3RydWN0IHRlc3RfbGlua3RhYmxlLCB0ZXN0X2Zuc19pbml0 X3RleHQpOworREVDTEFSRV9MSU5LVEFCTEUoc3RydWN0IHRlc3RfbGlua3RhYmxlLCB0ZXN0X2Zu c19pbml0X2RhdGEpOworREVDTEFSRV9MSU5LVEFCTEUoc3RydWN0IHRlc3RfbGlua3RhYmxlLCB0 ZXN0X2Zuc19kYXRhKTsKK0RFQ0xBUkVfTElOS1RBQkxFX1JPKHN0cnVjdCB0ZXN0X2xpbmt0YWJs ZSwgdGVzdF9mbnNfdGV4dCk7CitERUNMQVJFX0xJTktUQUJMRV9STyhzdHJ1Y3QgdGVzdF9saW5r dGFibGUsIHRlc3RfZm5zX3JvZGF0YSk7Ci0tIAoyLjExLjAKCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1k ZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail.kernel.org ([198.145.29.136]:53892 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S938456AbdAIO7x (ORCPT ); Mon, 9 Jan 2017 09:59:53 -0500 From: "Luis R. Rodriguez" Subject: [PATCH v6 14/14] lib: add linker tables test driver Date: Mon, 9 Jan 2017 06:58:32 -0800 Message-ID: <20170109145833.11502-15-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> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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: <20170109145832.ezRHfaCQtRL_P2oPN10pe_R20WjjeUNnVEq6Zv9S4Ek@z> Add a test drivers for linker tables. v6: rename table macro as suggested by Andy Shevchenko v5: added this commit for the first time in this series. Signed-off-by: Luis R. Rodriguez --- lib/Kconfig.debug | 6 + lib/Makefile | 1 + lib/test_linktables/Makefile | 13 + lib/test_linktables/test-linktables-00.c | 27 ++ lib/test_linktables/test-linktables-01.c | 27 ++ lib/test_linktables/test-linktables-02.c | 27 ++ lib/test_linktables/test-linktables-03.c | 27 ++ lib/test_linktables/test-linktables-04.c | 27 ++ lib/test_linktables/test-linktables.c | 801 +++++++++++++++++++++++++++++++ lib/test_linktables/test-linktables.h | 48 ++ 10 files changed, 1004 insertions(+) create mode 100644 lib/test_linktables/Makefile create mode 100644 lib/test_linktables/test-linktables-00.c create mode 100644 lib/test_linktables/test-linktables-01.c create mode 100644 lib/test_linktables/test-linktables-02.c create mode 100644 lib/test_linktables/test-linktables-03.c create mode 100644 lib/test_linktables/test-linktables-04.c create mode 100644 lib/test_linktables/test-linktables.c create mode 100644 lib/test_linktables/test-linktables.h diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 5655bd95919a..8c99ee3c9fd7 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -1827,6 +1827,12 @@ config TEST_HASH This is intended to help people writing architecture-specific optimized versions. If unsure, say N. +config TEST_LINKTABLES + bool "Test linker table functionality" + default n + help + Enable this option to test the kernel's linker table functionality. + endmenu # runtime tests config PROVIDE_OHCI1394_DMA_INIT diff --git a/lib/Makefile b/lib/Makefile index 94ed5cc4e89c..b5c5a7a9146c 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -55,6 +55,7 @@ obj-$(CONFIG_TEST_STATIC_KEYS) += test_static_key_base.o obj-$(CONFIG_TEST_PRINTF) += test_printf.o obj-$(CONFIG_TEST_BITMAP) += test_bitmap.o obj-$(CONFIG_TEST_UUID) += test_uuid.o +obj-$(CONFIG_TEST_LINKTABLES) += test_linktables/ ifeq ($(CONFIG_DEBUG_KOBJECT),y) CFLAGS_kobject.o += -DDEBUG diff --git a/lib/test_linktables/Makefile b/lib/test_linktables/Makefile new file mode 100644 index 000000000000..a1a67d7fd57a --- /dev/null +++ b/lib/test_linktables/Makefile @@ -0,0 +1,13 @@ +__LINKTABLE_TESTS := $(shell find ./ -name test-linktables-\*.c | wc -l) +ccflags-y += -D__LINKTABLE_TESTS=$(__LINKTABLE_TESTS) + +# Keep these disorganized, if linker tables did not work then +# things would not be ordered for us automatically at link time. +# Linker tables grants us the ability to be explicit about +# order. +obj-$(CONFIG_TEST_LINKTABLES) += test-linktables-04.o +obj-$(CONFIG_TEST_LINKTABLES) += test-linktables-02.o +obj-$(CONFIG_TEST_LINKTABLES) += test-linktables-01.o +obj-$(CONFIG_TEST_LINKTABLES) += test-linktables-03.o +obj-$(CONFIG_TEST_LINKTABLES) += test-linktables-00.o +obj-$(CONFIG_TEST_LINKTABLES) += test-linktables.o diff --git a/lib/test_linktables/test-linktables-00.c b/lib/test_linktables/test-linktables-00.c new file mode 100644 index 000000000000..ea162bd69179 --- /dev/null +++ b/lib/test_linktables/test-linktables-00.c @@ -0,0 +1,27 @@ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include + +#include "test-linktables.h" + +static int __init test_linktable_00_init(int input) +{ + return 0 * input; +} + +static int __initdata test_linktable_00_init_data(int input) +{ + return 0 * input; +} + +static int test_linktable_00(int input) +{ + return 0 * input; +} + +test_linktable_init_data(00, test_linktable_00_init_data); /* .init.data */ +test_linktable_init_text(00, test_linktable_00_init); /* .init.text */ +test_linktable(00, test_linktable_00); /* .data */ +test_linktable_text(00, test_linktable_00); /* .text */ +test_linktable_rodata(00, test_linktable_00); /* .rodata */ diff --git a/lib/test_linktables/test-linktables-01.c b/lib/test_linktables/test-linktables-01.c new file mode 100644 index 000000000000..39578990fd59 --- /dev/null +++ b/lib/test_linktables/test-linktables-01.c @@ -0,0 +1,27 @@ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include + +#include "test-linktables.h" + +static int __init test_linktable_01_init(int input) +{ + return 1 * input; +} + +static int __initdata test_linktable_01_init_data(int input) +{ + return 1 * input; +} + +static int test_linktable_01(int input) +{ + return 1 * input; +} + +test_linktable_init_data(01, test_linktable_01_init_data); /* .init.data */ +test_linktable_init_text(01, test_linktable_01_init); /* .init.text */ +test_linktable(01, test_linktable_01); /* .data */ +test_linktable_text(01, test_linktable_01); /* .text */ +test_linktable_rodata(01, test_linktable_01); /* .rodata */ diff --git a/lib/test_linktables/test-linktables-02.c b/lib/test_linktables/test-linktables-02.c new file mode 100644 index 000000000000..7f4b34240ecb --- /dev/null +++ b/lib/test_linktables/test-linktables-02.c @@ -0,0 +1,27 @@ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include + +#include "test-linktables.h" + +static int __init test_linktable_02_init(int input) +{ + return 2 * input; +} + +static int __initdata test_linktable_02_init_data(int input) +{ + return 2 * input; +} + +static int test_linktable_02(int input) +{ + return 2 * input; +} + +test_linktable_init_data(02, test_linktable_02_init_data); /* .init.data */ +test_linktable_init_text(02, test_linktable_02_init); /* .init.text */ +test_linktable(02, test_linktable_02); /* .data */ +test_linktable_text(02, test_linktable_02); /* .text */ +test_linktable_rodata(02, test_linktable_02); /* .rodata */ diff --git a/lib/test_linktables/test-linktables-03.c b/lib/test_linktables/test-linktables-03.c new file mode 100644 index 000000000000..47ca77e30c24 --- /dev/null +++ b/lib/test_linktables/test-linktables-03.c @@ -0,0 +1,27 @@ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include + +#include "test-linktables.h" + +static int __init test_linktable_03_init(int input) +{ + return 3 * input; +} + +static int __initdata test_linktable_03_init_data(int input) +{ + return 3 * input; +} + +static int test_linktable_03(int input) +{ + return 3 * input; +} + +test_linktable_init_data(03, test_linktable_03_init_data); /* .init.data */ +test_linktable_init_text(03, test_linktable_03_init); /* .init.text */ +test_linktable(03, test_linktable_03); /* .data */ +test_linktable_text(03, test_linktable_03); /* .text */ +test_linktable_rodata(03, test_linktable_03); /* .rodata */ diff --git a/lib/test_linktables/test-linktables-04.c b/lib/test_linktables/test-linktables-04.c new file mode 100644 index 000000000000..4123e0e16715 --- /dev/null +++ b/lib/test_linktables/test-linktables-04.c @@ -0,0 +1,27 @@ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include + +#include "test-linktables.h" + +static int __init test_linktable_04_init(int input) +{ + return 4 * input; +} + +static int __initdata test_linktable_04_init_data(int input) +{ + return 4 * input; +} + +static int test_linktable_04(int input) +{ + return 4 * input; +} + +test_linktable_init_data(04, test_linktable_04_init_data); /* .init.data */ +test_linktable_init_text(04, test_linktable_04_init); /* .init.text */ +test_linktable(04, test_linktable_04); /* .data */ +test_linktable_text(04, test_linktable_04); /* .text */ +test_linktable_rodata(04, test_linktable_04); /* .rodata */ diff --git a/lib/test_linktables/test-linktables.c b/lib/test_linktables/test-linktables.c new file mode 100644 index 000000000000..b78fb5b554cb --- /dev/null +++ b/lib/test_linktables/test-linktables.c @@ -0,0 +1,801 @@ +/* + * Linker table test driver + * + * 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/. + */ + +/* + * This driver provides an interface to trigger and test the linker table API + * through a series of configurations and a few triggers. This driver + * must be built-in as linker tables currently lack generalized modular + * support -- additional work is required on each module right now if you + * want to use linker tables, in the future we may make this much easier. + * For now just build this into your kernel. + * + * echo -n .text > /sys/devices/virtual/misc/test_linktable/config_section_name + * echo -n 3 > /sys/devices/virtual/misc/test_linktable/config_input + * echo 1 > /sys/devices/virtual/misc/test_linktable/trigger_config + * cat /sys/devices/virtual/misc/test_linktable/test_result + * 30 + * + * echo -n .data > /sys/devices/virtual/misc/test_linktable/config_section_name + * echo -n .text > /sys/devices/virtual/misc/test_linktable/config_section_name + * echo -n .rodata > /sys/devices/virtual/misc/test_linktable/config_section_name + * + * To check the configuration: + * + * cat /sys/devices/virtual/misc/test_linktable/config + * + * NUM_TESTS + * ∑ test(n, input) + * n=0 + * + * Each linker table entry on each section has a series of entries. Each entry + * has a function which just multiplies the test case number by input value. + * + * ... + * test-linktables-03.c multiplies (3 * input) + * test-linktables-04.c multiplies (4 * input) + * ... + * + * A full run on a section produces the sum of these values. So with input set + * to 3 we have: + * + * (0 * 3) + (1 * 3) + (2 * 3) + (3 * 3) + (4 * 3) + * 0 + 3 + 6 + 9 + 12 + * 30 + * + * This is nothing important, its just a basic test. We had to pick something. + * Other than the above tests, this also demos and shows proper const use on + * all sections which we need as read-only: .text, .init.text, .rodata. + * Furthermore it does a silly write test to ensure write works on .data and + * init.data. Since the read-only sections use const we obviously are forced + * by the compiler to not be able to write to these sections. + * + * One of the more important items, the order, is tested. We could develop + * a fancy simple math algorithm that depends on order for correctness but + * instead we just annotate the expected order as we run. If the order listed + * on test->expected does not match with the actual order a routine was run + * in then we fail and complain. + */ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include +#include +#include +#include +#include +#include + +#include "test-linktables.h" + +#define NUM_TESTS __LINKTABLE_TESTS + +struct linktable_test_device *__test_dev = NULL; +static bool init_completed = false; + +static const char *test_dev_name = "test_linktable"; + +/* + * Used for the default test to start configuration with if we reset the + * test from scratch. Don't use .init.* sections given we can only test + * these on init, when init_completed is true we can't .init.* section + * code anymore. + */ +#define TEST_SECTION_START ".data" + +DEFINE_LINKTABLE(struct test_linktable, test_fns_data); +DEFINE_LINKTABLE_TEXT(struct test_linktable, test_fns_text); +DEFINE_LINKTABLE_RO(struct test_linktable, test_fns_rodata); +DEFINE_LINKTABLE_INIT(struct test_linktable, test_fns_init_text); +DEFINE_LINKTABLE_INIT_DATA(struct test_linktable, test_fns_init_data); + +struct test_config { + char *section_name; + int input; + int test_result; +}; + +/** + * linktable_test_device - test device to help test linker tables + * + * @dev_idx: unique ID for test device + * @misc_dev: we use a misc device under the hood + * @dev: pointer to misc_dev's own struct device + * @config_mutex: protects configuration of test + * @trigger_mutex: the test trigger can only be fired once at a time + */ +struct linktable_test_device { + struct test_config config; + struct miscdevice misc_dev; + struct device *dev; + struct mutex config_mutex; + struct mutex trigger_mutex; + unsigned int num_called; +}; + +/** + * enum linktable_test_case - linker table test case + * + * @TEST_LINKTABLE_INIT: tests .init.text (this is all const) + * @TEST_LINKTABLE_INIT_DATA: tests .init.data + * @TEST_LINKTABLE: tests .data + * @TEST_LINKTABLE_TEXT: tests .text (this is all const) + * @TEST_LINKTABLE_RO: tests .rodata (this is all const) + */ +enum linktable_test_case { + __TEST_LINKTABLE_INVALID = 0, + + TEST_LINKTABLE_INIT, + TEST_LINKTABLE_INIT_DATA, + TEST_LINKTABLE, + TEST_LINKTABLE_TEXT, + TEST_LINKTABLE_RO, +}; + +static struct miscdevice *dev_to_misc_dev(struct device *dev) +{ + return dev_get_drvdata(dev); +} + +static +struct linktable_test_device *misc_dev_to_test_dev(struct miscdevice *misc_dev) +{ + return container_of(misc_dev, struct linktable_test_device, misc_dev); +} + +static struct linktable_test_device *dev_to_test_dev(struct device *dev) +{ + struct miscdevice *misc_dev; + + misc_dev = dev_to_misc_dev(dev); + + return misc_dev_to_test_dev(misc_dev); +} + +static ssize_t config_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + struct test_config *config = &test_dev->config; + int len = 0; + + mutex_lock(&test_dev->config_mutex); + + len += snprintf(buf, PAGE_SIZE, + "Custom trigger configuration for: %s\n", + dev_name(dev)); + + if (config->section_name) + len += snprintf(buf+len, PAGE_SIZE, + "section name:\t%s\n", + config->section_name); + else + len += snprintf(buf+len, PAGE_SIZE, + "default name:\tEMTPY\n"); + + mutex_unlock(&test_dev->config_mutex); + + return len; +} +static DEVICE_ATTR_RO(config); + +static int write_test(struct test_linktable *test, int write_val) +{ + test->write_test = write_val; + if (test->write_test != write_val) { + pr_warn("Write test failed\n"); + return -EPERM; + } + return 0; +} + +static int __test_linktable(struct linktable_test_device *test_dev, + struct test_linktable *test) +{ + struct test_config *config = &test_dev->config; + int rc; + + if (test->expected != test_dev->num_called) { + pr_warn("test routine ID %d called on order %d\n", + test->expected, test_dev->num_called); + return -EINVAL; + } + + rc = write_test(test, test->expected+1); + if (rc) + return rc; + + rc = test->op(config->input); + test_dev->num_called++; + + return rc; +} + +static int __test_linktable_ro(struct linktable_test_device *test_dev, + const struct test_linktable *test) +{ + struct test_config *config = &test_dev->config; + int rc; + + if (test->expected != test_dev->num_called) { + pr_info("test routine ID %d called on order %d\n", + test->expected, test_dev->num_called); + return -EINVAL; + } + + /* + * Note, compiler would complain if we tried write_test() so + * no need to test that. + */ + + rc = test->op(config->input); + test_dev->num_called++; + + return rc; +} + +static enum linktable_test_case get_test_case(const char *section_name) +{ + if (strcmp(".init.text", section_name) == 0) + return TEST_LINKTABLE_INIT; + if (strcmp(".init.data", section_name) == 0) + return TEST_LINKTABLE_INIT_DATA; + if (strcmp(".data", section_name) == 0) + return TEST_LINKTABLE; + if (strcmp(".text", section_name) == 0) + return TEST_LINKTABLE_TEXT; + if (strcmp(".rodata", section_name) == 0) + return TEST_LINKTABLE_TEXT; + + return __TEST_LINKTABLE_INVALID; +} + +static int __run_sanity_test(struct linktable_test_device *test_dev, + int num_entries) +{ + if (!num_entries) { + pr_warn("no tests -- this is invalid\n"); + return -EINVAL; + } + + pr_debug("number of tests: %d\n", num_entries); + + if (num_entries != NUM_TESTS) { + pr_warn("expected: %d test\n", NUM_TESTS); + return -EINVAL; + } + + return 0; +} + +static int __init run_init_text_test(struct linktable_test_device *test_dev) +{ + int ret, total = 0; + const struct test_linktable *test; + unsigned int num_entries = LINKTABLE_SIZE(test_fns_init_text); + + ret = __run_sanity_test(test_dev, num_entries); + if (ret) + return ret; + + linktable_for_each(test, test_fns_init_text) + total += __test_linktable_ro(test_dev, test); + + return total; +} + +static int __init run_init_data_test(struct linktable_test_device *test_dev) +{ + int ret, total = 0; + struct test_linktable *test; + unsigned int num_entries = LINKTABLE_SIZE(test_fns_init_data); + + ret = __run_sanity_test(test_dev, num_entries); + if (ret) + return ret; + + linktable_for_each(test, test_fns_init_data) + total += __test_linktable(test_dev, test); + + return total; +} + +static int run_data_test(struct linktable_test_device *test_dev) +{ + int ret, total = 0; + struct test_linktable *test; + unsigned int num_entries = LINKTABLE_SIZE(test_fns_data); + + ret = __run_sanity_test(test_dev, num_entries); + if (ret) + return ret; + + linktable_for_each(test, test_fns_data) + total += __test_linktable(test_dev, test); + + return total; +} + +static int run_text_test(struct linktable_test_device *test_dev) +{ + int ret, total = 0; + const struct test_linktable *test; + unsigned int num_entries = LINKTABLE_SIZE(test_fns_text); + + ret = __run_sanity_test(test_dev, num_entries); + if (ret) + return ret; + + linktable_for_each(test, test_fns_text) + total += __test_linktable_ro(test_dev, test); + + return total; +} + +static int run_rodata_test(struct linktable_test_device *test_dev) +{ + int ret, total = 0; + const struct test_linktable *test; + unsigned int num_entries = LINKTABLE_SIZE(test_fns_rodata); + + ret = __run_sanity_test(test_dev, num_entries); + if (ret) + return ret; + + linktable_for_each(test, test_fns_rodata) + total += __test_linktable_ro(test_dev, test); + + return total; +} + +static int __ref __trigger_config_run(struct linktable_test_device *test_dev) +{ + enum linktable_test_case test_case; + struct test_config *config = &test_dev->config; + + test_dev->num_called = 0; + test_case = get_test_case(config->section_name); + + switch (test_case) { + case TEST_LINKTABLE_INIT: + if (!init_completed) + return run_init_text_test(test_dev); + else + return -EACCES; + case TEST_LINKTABLE_INIT_DATA: + if (!init_completed) + return run_init_data_test(test_dev); + else + return -EACCES; + case TEST_LINKTABLE: + return run_data_test(test_dev); + case TEST_LINKTABLE_TEXT: + return run_text_test(test_dev); + case TEST_LINKTABLE_RO: + return run_rodata_test(test_dev); + default: + pr_warn("Invalid test case requested: %s\n", + config->section_name); + return -EINVAL; + } +} + +static int trigger_config_run(struct linktable_test_device *test_dev) +{ + struct test_config *config = &test_dev->config; + int rc; + + mutex_lock(&test_dev->trigger_mutex); + mutex_lock(&test_dev->config_mutex); + + pr_debug("running test on '%s'\n", config->section_name); + + rc = __trigger_config_run(test_dev); + + config->test_result = rc; + pr_debug("result: %d\n", rc); + + if (rc < 0) { + rc = -EINVAL; + goto out; + } + + rc = 0; + +out: + mutex_unlock(&test_dev->config_mutex); + mutex_unlock(&test_dev->trigger_mutex); + + return rc; +} + +static ssize_t +trigger_config_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + int rc; + + rc = trigger_config_run(test_dev); + if (rc) + goto out; + + rc = count; +out: + return rc; +} +static DEVICE_ATTR_WO(trigger_config); + +/* + * XXX: move to kstrncpy() once merged. + * + * Users should use kfree_const() when freeing these. + */ +static int __kstrncpy(char **dst, const char *name, size_t count, gfp_t gfp) +{ + *dst = kstrndup(name, count, gfp); + if (!*dst) + return -ENOSPC; + return count; +} + +static int config_copy_section_name(struct test_config *config, + const char *name, + size_t count) +{ + return __kstrncpy(&config->section_name, name, count, GFP_KERNEL); +} + +static void __linktable_config_free(struct test_config *config) +{ + kfree_const(config->section_name); + config->section_name = NULL; +} + +static void linktable_config_free(struct linktable_test_device *test_dev) +{ + struct test_config *config = &test_dev->config; + + mutex_lock(&test_dev->config_mutex); + __linktable_config_free(config); + mutex_unlock(&test_dev->config_mutex); +} + +static ssize_t config_section_name_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + struct test_config *config = &test_dev->config; + int rc; + + mutex_lock(&test_dev->config_mutex); + rc = config_copy_section_name(config, buf, count); + mutex_unlock(&test_dev->config_mutex); + + return rc; +} + +/* + * As per sysfs_kf_seq_show() the buf is max PAGE_SIZE. + */ +static ssize_t config_test_show_str(struct mutex *config_mutex, + char *dst, + char *src) +{ + int len; + + mutex_lock(config_mutex); + len = snprintf(dst, PAGE_SIZE, "%s\n", src); + mutex_unlock(config_mutex); + + return len; +} + +static ssize_t config_section_name_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + struct test_config *config = &test_dev->config; + + return config_test_show_str(&test_dev->config_mutex, buf, + config->section_name); +} +static DEVICE_ATTR(config_section_name, 0644, config_section_name_show, + config_section_name_store); + +static int trigger_config_run_named(struct linktable_test_device *test_dev, + const char *section_name) +{ + int copied; + struct test_config *config = &test_dev->config; + + mutex_lock(&test_dev->config_mutex); + copied = config_copy_section_name(config, section_name, + strlen(section_name)); + mutex_unlock(&test_dev->config_mutex); + + if (copied <=0 || copied != strlen(section_name)) + return -EINVAL; + + return trigger_config_run(test_dev); +} + +static int __linktable_config_init(struct test_config *config) +{ + int ret; + + ret = config_copy_section_name(config, TEST_SECTION_START, + strlen(TEST_SECTION_START)); + if (ret < 0) + goto out; + + config->input = 3; + config->test_result = 0; + +out: + return ret; +} + +static ssize_t reset_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + struct test_config *config = &test_dev->config; + int ret; + + mutex_lock(&test_dev->trigger_mutex); + mutex_lock(&test_dev->config_mutex); + + __linktable_config_free(config); + + ret = __linktable_config_init(config); + if (ret < 0) { + ret = -ENOMEM; + dev_err(dev, "could not alloc settings for config trigger: %d\n", + ret); + goto out; + } + + dev_info(dev, "reset\n"); + ret = count; + +out: + mutex_unlock(&test_dev->config_mutex); + mutex_unlock(&test_dev->trigger_mutex); + + return ret; +} +static DEVICE_ATTR_WO(reset); + +static int test_dev_config_update_int(struct linktable_test_device *test_dev, + const char *buf, size_t size, + int *config) +{ + char *end; + long new = simple_strtol(buf, &end, 0); + if (end == buf || new > INT_MAX || new < INT_MIN) + return -EINVAL; + mutex_lock(&test_dev->config_mutex); + *config = new; + mutex_unlock(&test_dev->config_mutex); + /* Always return full write size even if we didn't consume all */ + return size; +} + +static ssize_t test_dev_config_show_int(struct linktable_test_device *test_dev, + char *buf, + int config) +{ + int val; + + mutex_lock(&test_dev->config_mutex); + val = config; + mutex_unlock(&test_dev->config_mutex); + + return snprintf(buf, PAGE_SIZE, "%d\n", val); +} + +static ssize_t test_result_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + struct test_config *config = &test_dev->config; + + return test_dev_config_update_int(test_dev, buf, count, + &config->test_result); +} + +static ssize_t config_input_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + struct test_config *config = &test_dev->config; + + return test_dev_config_update_int(test_dev, buf, count, + &config->input); +} + +static ssize_t config_input_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + struct test_config *config = &test_dev->config; + + return test_dev_config_show_int(test_dev, buf, config->input); +} +static DEVICE_ATTR(config_input, 0644, config_input_show, config_input_store); + +static ssize_t test_result_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct linktable_test_device *test_dev = dev_to_test_dev(dev); + struct test_config *config = &test_dev->config; + + return test_dev_config_show_int(test_dev, buf, config->test_result); +} +static DEVICE_ATTR(test_result, 0644, test_result_show, test_result_store); + +#define LINKTABLE_DEV_ATTR(name) &dev_attr_##name.attr + +static struct attribute *test_dev_attrs[] = { + LINKTABLE_DEV_ATTR(trigger_config), + LINKTABLE_DEV_ATTR(config), + LINKTABLE_DEV_ATTR(reset), + + LINKTABLE_DEV_ATTR(config_section_name), + LINKTABLE_DEV_ATTR(config_input), + LINKTABLE_DEV_ATTR(test_result), + + NULL, +}; + +ATTRIBUTE_GROUPS(test_dev); + +static int linktable_config_init(struct linktable_test_device *test_dev) +{ + struct test_config *config = &test_dev->config; + int ret; + + mutex_lock(&test_dev->config_mutex); + ret = __linktable_config_init(config); + mutex_unlock(&test_dev->config_mutex); + + return ret; +} + +static struct linktable_test_device *alloc_test_dev_linktable(void) +{ + int rc; + struct linktable_test_device *test_dev; + struct miscdevice *misc_dev; + + test_dev = vmalloc(sizeof(struct linktable_test_device)); + if (!test_dev) { + pr_err("Cannot alloc test_dev\n"); + goto err_out; + } + + memset(test_dev, 0, sizeof(struct linktable_test_device)); + + mutex_init(&test_dev->config_mutex); + mutex_init(&test_dev->trigger_mutex); + + rc = linktable_config_init(test_dev); + if (rc < 0) { + pr_err("Cannot alloc linktable_config_init()\n"); + goto err_out_free; + } + + misc_dev = &test_dev->misc_dev; + + misc_dev->minor = MISC_DYNAMIC_MINOR; + misc_dev->name = test_dev_name; + misc_dev->groups = test_dev_groups; + + return test_dev; + +err_out_free: + kfree(test_dev); +err_out: + return NULL; +} + +static void free_test_dev_linktable(struct linktable_test_device *test_dev) +{ + test_dev->misc_dev.name = NULL; + vfree(test_dev); + test_dev = NULL; + linktable_config_free(test_dev); +} + +static struct linktable_test_device *register_test_dev_linktable(void) +{ + struct linktable_test_device *test_dev = NULL; + int rc; + + test_dev = alloc_test_dev_linktable(); + if (!test_dev) { + return NULL; + } + + rc = misc_register(&test_dev->misc_dev); + if (rc) { + pr_err("could not register misc device: %d\n", rc); + free_test_dev_linktable(test_dev); + return NULL; + } + + test_dev->dev = test_dev->misc_dev.this_device; + dev_dbg(test_dev->dev, "interface ready\n"); + + return test_dev; +} + +static int __init test_linktable_init(void) +{ + struct linktable_test_device *test_dev; + int rc; + + test_dev = register_test_dev_linktable(); + if (!test_dev) { + pr_err("Cannot add test linktable device\n"); + return -ENODEV; + } + + rc = trigger_config_run_named(test_dev, ".init.text"); + if (WARN_ON(rc)) + return rc; + rc = trigger_config_run_named(test_dev, ".init.data"); + if (WARN_ON(rc)) + return rc; + + init_completed = true; + + rc = trigger_config_run_named(test_dev, ".data"); + if (WARN_ON(rc)) + return rc; + rc = trigger_config_run_named(test_dev, ".text"); + if (WARN_ON(rc)) + return rc; + rc = trigger_config_run_named(test_dev, ".rodata"); + if (WARN_ON(rc)) + return rc; + + pr_info("linker table tests: OK!\n"); + + return 0; +} +late_initcall(test_linktable_init); + +static +void unregister_test_dev_linktable(struct linktable_test_device *test_dev) +{ + dev_info(test_dev->dev, "removing interface\n"); + misc_deregister(&test_dev->misc_dev); + free_test_dev_linktable(test_dev); +} + +static void __exit test_linktable_exit(void) +{ + struct linktable_test_device *test_dev = __test_dev; + + unregister_test_dev_linktable(test_dev); +} +module_exit(test_linktable_exit); + +MODULE_AUTHOR("Luis R. Rodriguez "); +MODULE_LICENSE("GPL"); diff --git a/lib/test_linktables/test-linktables.h b/lib/test_linktables/test-linktables.h new file mode 100644 index 000000000000..c9c9d5c87263 --- /dev/null +++ b/lib/test_linktables/test-linktables.h @@ -0,0 +1,48 @@ +#include + +struct test_linktable { + int expected; + int write_test; + int (*op)(int input_digit); +}; + +#define test_linktable_init_text(__level, __op) \ + static LINKTABLE_INIT(test_fns_init_text, __level) \ + __test_fn_init_text_##__op = { \ + .expected = __level, \ + .op = __op, \ +}; + +#define test_linktable_init_data(__level, __op) \ + static LINKTABLE_INIT_DATA(test_fns_init_data, __level) \ + __test_fn_init_data_##__op = { \ + .expected = __level, \ + .op = __op, \ +}; + +#define test_linktable(__level, __op) \ + static LINKTABLE(test_fns_data, __level) \ + __test_fn_data_##__op = { \ + .expected = __level, \ + .op = __op, \ +}; + +#define test_linktable_text(__level, __op) \ + static LINKTABLE_TEXT(test_fns_text, __level) \ + __test_fn_text_##__op = { \ + .expected = __level, \ + .op = __op, \ +}; + +#define test_linktable_rodata(__level, __op) \ + static LINKTABLE_RO(test_fns_rodata, __level) \ + __test_fn_rodata_##__op = { \ + .expected = __level, \ + .op = __op, \ +}; + +DECLARE_LINKTABLE_RO(struct test_linktable, test_fns_init_text); +DECLARE_LINKTABLE(struct test_linktable, test_fns_init_data); +DECLARE_LINKTABLE(struct test_linktable, test_fns_data); +DECLARE_LINKTABLE_RO(struct test_linktable, test_fns_text); +DECLARE_LINKTABLE_RO(struct test_linktable, test_fns_rodata); -- 2.11.0