From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Subject: [PATCH 3/3] xen blkback: add fault injection facility From: Stanislav Kinsburskii CC: , , , , , , , , , , , , , , , , , , , , , , , , Date: Fri, 20 Apr 2018 10:47:36 +0000 Message-ID: <20180420104736.17823.42983.stgit@dev-dsk-staskins-1a-ca5afbf2.eu-west-1.amazon.com> In-Reply-To: <20180420104603.17823.31095.stgit@dev-dsk-staskins-1a-ca5afbf2.eu-west-1.amazon.com> References: <20180420104603.17823.31095.stgit@dev-dsk-staskins-1a-ca5afbf2.eu-west-1.amazon.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" List-ID: VGhpcyBwYXRjaCBhZGRzIHdyYXBwZXIgaGVscGVycyBhcm91bmQgZ2VuZXJpYyBYZW4gZmF1bHQg aW5qZWN0CmZhY2lsaXR5LgpUaGUgbWFqb3IgcmVhc29uIGlzIHRvIGtlZXAgYWxsIHRoZSBtb2R1 bGUgZmF1bHQgaW5qZWN0aW9uIGRpcmVjdG9yaWVzCmluIGEgZGVkaWNhdGVkIHN1YmRpcmVjdG9y eSBpbnN0ZWFkIG9mIFhlbiBmYXVsdCBpbmplY3Qgcm9vdC4KCklPVywgd2hlbiB1c2luZyB0aGVz ZSBoZWxwZXJzLCBwZXItZGV2aWNlIGFuZCBuYW1lZCBieSBkZXZpY2UgbmFtZQpmYXVsdCBpbmpl Y3Rpb24gY29udHJvbCBkaXJlY3RvcmllcyB3aWxsIGFwcGVhciB1bmRlciB0aGUgZm9sbG93aW5n CmRpcmVjdG9yeToKLSAvc3lzL2tlcm5lbC9kZWJ1Zy94ZW4vZmF1bHRfaW5qZWN0L3hlbi1ibGti YWNrLwppbnN0ZWFkIG9mOgotIC9zeXMva2VybmVsL2RlYnVnL3hlbi9mYXVsdF9pbmplY3QvCgpT aWduZWQtb2ZmLWJ5OiBTdGFuaXNsYXYgS2luc2J1cnNraWkgPHN0YXNraW5zQGFtYXpvbi5jb20+ CkNDOiBKZW5zIEF4Ym9lIDxheGJvZUBrZXJuZWwuZGs+CkNDOiBLb25yYWQgUnplc3p1dGVrIFdp bGsgPGtvbnJhZC53aWxrQG9yYWNsZS5jb20+CkNDOiAiUm9nZXIgUGF1IE1vbm7DqSIgPHJvZ2Vy LnBhdUBjaXRyaXguY29tPgpDQzogbGludXgta2VybmVsQHZnZXIua2VybmVsLm9yZwpDQzogbGlu dXgtYmxvY2tAdmdlci5rZXJuZWwub3JnCkNDOiB4ZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5v cmcKQ0M6IFN0YW5pc2xhdiBLaW5zYnVyc2tpaSA8c3Rhc2tpbnNAYW1hem9uLmNvbT4KQ0M6IERh dmlkIFdvb2Rob3VzZSA8ZHdtd0BhbWF6b24uY28udWs+Ci0tLQogZHJpdmVycy9ibG9jay9LY29u ZmlnICAgICAgICAgICAgICAgICAgfCAgICA3ICsrCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNr L01ha2VmaWxlICAgICB8ICAgIDEgCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL2Jsa2JhY2su YyAgICB8ICAgIDkgKysKIGRyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2svYmxrYmFja19maS5jIHwg IDExNiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogZHJpdmVycy9ibG9jay94ZW4t YmxrYmFjay9ibGtiYWNrX2ZpLmggfCAgIDM3ICsrKysrKysrKysKIGRyaXZlcnMvYmxvY2sveGVu LWJsa2JhY2svY29tbW9uLmggICAgIHwgICAgMyArCiBkcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNr L3hlbmJ1cy5jICAgICB8ICAgIDUgKwogNyBmaWxlcyBjaGFuZ2VkLCAxNzggaW5zZXJ0aW9ucygr KQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2svYmxrYmFja19m aS5jCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ibG9jay94ZW4tYmxrYmFjay9ibGtiYWNr X2ZpLmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL0tjb25maWcgYi9kcml2ZXJzL2Jsb2Nr L0tjb25maWcKaW5kZXggYWQ5YjY4Ny4uMGNlMDVmZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ibG9j ay9LY29uZmlnCisrKyBiL2RyaXZlcnMvYmxvY2svS2NvbmZpZwpAQCAtNDM2LDYgKzQzNiwxMyBA QCBjb25maWcgWEVOX0JMS0RFVl9CQUNLRU5ECiAJICBjb21waWxlIHRoaXMgZHJpdmVyIGFzIGEg bW9kdWxlLCBjaG9zZSBNIGhlcmU6IHRoZSBtb2R1bGUKIAkgIHdpbGwgYmUgY2FsbGVkIHhlbi1i bGtiYWNrLgogCitjb25maWcgWEVOX0JMS0RFVl9CQUNLRU5EX0ZBVUxUX0lOSkVDVElPTgorCSAg Ym9vbCAiWGVuIGJsb2NrLWRldmljZSBiYWNrZW5kIGRyaXZlciBmYXVsdCBpbmplY3Rpb24iCisJ ICBkZXBlbmRzIG9uIFhFTl9CTEtERVZfQkFDS0VORAorCSAgZGVwZW5kcyBvbiBYRU5fRkFVTFRf SU5KRUNUSU9OCisJICBkZWZhdWx0IG4KKwkgIGhlbHAKKwkgICAgQWxsb3cgdG8gaW5qZWN0IGVy cm9ycyB0byBYZW4gYmFja2VuZCBibG9jayBkcml2ZXIKIAogY29uZmlnIFZJUlRJT19CTEsKIAl0 cmlzdGF0ZSAiVmlydGlvIGJsb2NrIGRyaXZlciIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2sv eGVuLWJsa2JhY2svTWFrZWZpbGUgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL01ha2VmaWxl CmluZGV4IGU0OTFjMWIuLjAzNWQxMzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2sveGVuLWJs a2JhY2svTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ibG9jay94ZW4tYmxrYmFjay9NYWtlZmlsZQpA QCAtMSwzICsxLDQgQEAKIG9iai0kKENPTkZJR19YRU5fQkxLREVWX0JBQ0tFTkQpIDo9IHhlbi1i bGtiYWNrLm8KIAogeGVuLWJsa2JhY2steQk6PSBibGtiYWNrLm8geGVuYnVzLm8KK3hlbi1ibGti YWNrLSQoQ09ORklHX1hFTl9CTEtERVZfQkFDS0VORF9GQVVMVF9JTkpFQ1RJT04pICs9IGJsa2Jh Y2tfZmkubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4tYmxrYmFjay9ibGtiYWNrLmMg Yi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL2Jsa2JhY2suYwppbmRleCA5ODdkNjY1Li4yOTMz YmVjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL2Jsa2JhY2suYworKysg Yi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL2Jsa2JhY2suYwpAQCAtNTEsNiArNTEsNyBAQAog I2luY2x1ZGUgPHhlbi9iYWxsb29uLmg+CiAjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxlLmg+CiAj aW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAiYmxrYmFja19maS5oIgogCiAvKgogICogTWF4 aW11bSBudW1iZXIgb2YgdW51c2VkIGZyZWUgcGFnZXMgdG8ga2VlcCBpbiB0aGUgaW50ZXJuYWwg YnVmZmVyLgpAQCAtMTQ5MSwxMSArMTQ5MiwxOSBAQCBzdGF0aWMgaW50IF9faW5pdCB4ZW5fYmxr aWZfaW5pdCh2b2lkKQogCWlmIChyYykKIAkJZ290byBmYWlsZWRfaW5pdDsKIAorCSh2b2lkKSB4 ZW5fYmxrYmtfZmlfaW5pdCgpOwogIGZhaWxlZF9pbml0OgogCXJldHVybiByYzsKIH0KIAogbW9k dWxlX2luaXQoeGVuX2Jsa2lmX2luaXQpOwogCitzdGF0aWMgdm9pZCBfX2V4aXQgeGVuX2Jsa2lm X2Zpbmkodm9pZCkKK3sKKwl4ZW5fYmxrYmtfZmlfZmluaSgpOworfQorCittb2R1bGVfZXhpdCh4 ZW5fYmxraWZfZmluaSk7CisKIE1PRFVMRV9MSUNFTlNFKCJEdWFsIEJTRC9HUEwiKTsKIE1PRFVM RV9BTElBUygieGVuLWJhY2tlbmQ6dmJkIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3hl bi1ibGtiYWNrL2Jsa2JhY2tfZmkuYyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2svYmxrYmFj a19maS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI3YWJhZWEKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL2Jsa2JhY2tfZmkuYwpAQCAt MCwwICsxLDExNiBAQAorLyoKKyAqIEZhdWx0IGluamVjdGlvbiBpbnRlcmZhY2UgZm9yIFhlbiB2 aXJ0dWFsIGJsb2NrIGRldmljZXMKKyAqCisgKiBDb3B5cmlnaHQgMjAxOCBBbWF6b24uY29tLCBJ bmMuIG9yIGl0cyBhZmZpbGlhdGVzLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFRoaXMg cHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IK KyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIHZlcnNpb24gMgorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb247IG9yLCB3aGVuIGRpc3RyaWJ1dGVkCisgKiBzZXBhcmF0ZWx5IGZyb20gdGhlIExp bnV4IGtlcm5lbCBvciBpbmNvcnBvcmF0ZWQgaW50byBvdGhlcgorICogc29mdHdhcmUgcGFja2Fn ZXMsIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBsaWNlbnNlOgorICoKKyAqIFBlcm1pc3Npb24g aXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmlu ZyBhIGNvcHkKKyAqIG9mIHRoaXMgc291cmNlIGZpbGUgKHRoZSAiU29mdHdhcmUiKSwgdG8gZGVh bCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dAorICogcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRo b3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwKKyAqIG1lcmdl LCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbCBjb3BpZXMgb2Yg dGhlIFNvZnR3YXJlLAorICogYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3 YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0bworICogdGhlIGZvbGxvd2luZyBj b25kaXRpb25zOgorICoKKyAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBl cm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluCisgKiBhbGwgY29waWVzIG9yIHN1 YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KKyAqCisgKiBUSEUgU09GVFdBUkUg SVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVT UyBPUgorICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFO VElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVS UE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUKKyAqIEFVVEhP UlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMg T1IgT1RIRVIKKyAqIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1Qs IFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HCisgKiBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVD VElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJTkdTCisgKiBJ TiBUSEUgU09GVFdBUkUuCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRl IDxsaW51eC9kZWJ1Z2ZzLmg+CisKKyNpbmNsdWRlIDx4ZW4vZmF1bHRfaW5qZWN0Lmg+CisKKyNp bmNsdWRlICJibGtiYWNrX2ZpLmgiCisjaW5jbHVkZSAiY29tbW9uLmgiCisKK3N0YXRpYyBzdHJ1 Y3QgZGVudHJ5ICpibGtpZl9maV9kaXI7CisKK3N0YXRpYyBjb25zdCBjaGFyICp4ZW5fYmxraWZf ZmlfbmFtZXNbWEVOQkxLSUZfRklfTUFYXSA9IHsKK307CisKK3N0cnVjdCB4ZW5fYmxraWZfZmkg eworCXN0cnVjdCBkZW50cnkgKmRpcjsKKwlzdHJ1Y3QgeGVuX2ZpICpmYXVsdHNbWEVOQkxLSUZf RklfTUFYXTsKK307CisKK2ludCB4ZW5fYmxrYmtfZmlfaW5pdCh2b2lkKQoreworCWJsa2lmX2Zp X2RpciA9IHhlbl9maV9kaXJfY3JlYXRlKCJ4ZW4tYmxrYmFjayIpOworCWlmICghYmxraWZfZmlf ZGlyKQorCQlyZXR1cm4gLUVOT01FTTsKKwlyZXR1cm4gMDsKK30KKwordm9pZCB4ZW5fYmxrYmtf ZmlfZmluaSh2b2lkKQoreworCWRlYnVnZnNfcmVtb3ZlX3JlY3Vyc2l2ZShibGtpZl9maV9kaXIp OworfQorCit2b2lkIHhlbl9ibGtpZl9maV9maW5pKHN0cnVjdCB4ZW5fYmxraWYgKmJsa2lmKQor eworCXN0cnVjdCB4ZW5fYmxraWZfZmkgKmJmaSA9IGJsa2lmLT5maV9pbmZvOworCWludCBmaTsK KworCWlmICghYmxraWYtPmZpX2luZm8pCisJCXJldHVybjsKKworCWJsa2lmLT5maV9pbmZvID0g TlVMTDsKKworCWZvciAoZmkgPSAwOyBmaSA8IFhFTkJMS0lGX0ZJX01BWDsgZmkrKykKKwkJeGVu X2ZpX2RlbChiZmktPmZhdWx0c1tmaV0pOworCWRlYnVnZnNfcmVtb3ZlX3JlY3Vyc2l2ZShiZmkt PmRpcik7CisJa2ZyZWUoYmZpKTsKK30KKworaW50IHhlbl9ibGtpZl9maV9pbml0KHN0cnVjdCB4 ZW5fYmxraWYgKmJsa2lmKQoreworCXN0cnVjdCB4ZW5fYmxraWZfZmkgKmJmaTsKKwlpbnQgZmks IGVyciA9IC1FTk9NRU07CisKKwliZmkgPSBrbWFsbG9jKHNpemVvZigqYmZpKSwgR0ZQX0tFUk5F TCk7CisJaWYgKCFiZmkpCisJCXJldHVybiAtRU5PTUVNOworCisJYmZpLT5kaXIgPSBkZWJ1Z2Zz X2NyZWF0ZV9kaXIoZGV2X25hbWUoJmJsa2lmLT5iZS0+ZGV2LT5kZXYpLAorCQkJCSAgICAgIGJs a2lmX2ZpX2Rpcik7CisJaWYgKCFiZmktPmRpcikKKwkJZ290byBlcnJfZGlyOworCisJZm9yIChm aSA9IDA7IGZpIDwgWEVOQkxLSUZfRklfTUFYOyBmaSsrKSB7CisJCWJmaS0+ZmF1bHRzW2ZpXSA9 IHhlbl9maV9kaXJfYWRkKGJmaS0+ZGlyLAorCQkJCQkJIHhlbl9ibGtpZl9maV9uYW1lc1tmaV0p OworCQlpZiAoIWJmaS0+ZmF1bHRzW2ZpXSkKKwkJCWdvdG8gZXJyX2ZhdWx0OworCX0KKworCWJs a2lmLT5maV9pbmZvID0gYmZpOworCXJldHVybiAwOworCitlcnJfZmF1bHQ6CisJZm9yICg7IGZp ID4gMDsgZmktLSkKKwkJeGVuX2ZpX2RlbChiZmktPmZhdWx0c1tmaV0pOworCWRlYnVnZnNfcmVt b3ZlX3JlY3Vyc2l2ZShiZmktPmRpcik7CitlcnJfZGlyOgorCWtmcmVlKGJmaSk7CisJcmV0dXJu IGVycjsKK30KKworYm9vbCB4ZW5ibGtpZl9zaG91bGRfZmFpbChzdHJ1Y3QgeGVuX2Jsa2lmICpi bGtpZiwgeGVuX2Jsa2JrX2ZpX3QgdHlwZSkKK3sKKwlzdHJ1Y3QgeGVuX2Jsa2lmX2ZpICpiZmkg PSBibGtpZi0+ZmlfaW5mbzsKKworCXJldHVybiB4ZW5fc2hvdWxkX2ZhaWwoYmZpLT5mYXVsdHNb dHlwZV0pOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay94ZW4tYmxrYmFjay9ibGtiYWNr X2ZpLmggYi9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL2Jsa2JhY2tfZmkuaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40ZTI5ODUwCi0tLSAvZGV2L251bGwKKysrIGIvZHJp dmVycy9ibG9jay94ZW4tYmxrYmFjay9ibGtiYWNrX2ZpLmgKQEAgLTAsMCArMSwzNyBAQAorI2lm bmRlZiBfWEVOX0JMS0JBQ0tfRklfSAorI2RlZmluZSBfWEVOX0JMS0JBQ0tfRklfSAorCitzdHJ1 Y3QgeGVuX2ZpOworc3RydWN0IHhlbl9ibGtpZjsKKwordHlwZWRlZiBlbnVtIHsKKwlYRU5CTEtJ Rl9GSV9NQVgKK30geGVuX2Jsa2JrX2ZpX3Q7CisKKyNpZmRlZiBDT05GSUdfWEVOX0JMS0RFVl9C QUNLRU5EX0ZBVUxUX0lOSkVDVElPTgorCit2b2lkIHhlbl9ibGtia19maV9maW5pKHZvaWQpOwor aW50IHhlbl9ibGtia19maV9pbml0KHZvaWQpOworCit2b2lkIHhlbl9ibGtpZl9maV9maW5pKHN0 cnVjdCB4ZW5fYmxraWYgKmJsa2lmKTsKK2ludCB4ZW5fYmxraWZfZmlfaW5pdChzdHJ1Y3QgeGVu X2Jsa2lmICpibGtpZik7CisKK2Jvb2wgeGVuYmxraWZfc2hvdWxkX2ZhaWwoc3RydWN0IHhlbl9i bGtpZiAqYmxraWYsIHhlbl9ibGtia19maV90IHR5cGUpOworCisjZWxzZQorCitzdGF0aWMgaW5s aW5lIHZvaWQgeGVuX2Jsa2JrX2ZpX2Zpbmkodm9pZCkgeyB9CitzdGF0aWMgaW5saW5lIGludCB4 ZW5fYmxrYmtfZmlfaW5pdCh2b2lkKSB7IHJldHVybiAwOyB9CisKK3N0YXRpYyBpbmxpbmUgdm9p ZCB4ZW5fYmxraWZfZmlfZmluaShzdHJ1Y3QgeGVuX2Jsa2lmICpibGtpZikgeyB9CitzdGF0aWMg aW5saW5lIGludCB4ZW5fYmxraWZfZmlfaW5pdChzdHJ1Y3QgeGVuX2Jsa2lmICpibGtpZikgeyBy ZXR1cm4gMDsgfQorCitzdGF0aWMgaW5saW5lIGJvb2wgeGVuYmxraWZfc2hvdWxkX2ZhaWwoc3Ry dWN0IHhlbl9ibGtpZiAqYmxraWYsIHhlbl9ibGtia19maV90IHR5cGUpCit7CisJcmV0dXJuIGZh bHNlOworfQorCisjZW5kaWYgLyogQ09ORklHX1hFTl9CTEtERVZfQkFDS0VORF9GQVVMVF9JTkpF Q1RJT04gKi8KKworI2VuZGlmIC8qIF9YRU5fQkxLQkFDS19GSV9IICovCisKZGlmZiAtLWdpdCBh L2RyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2svY29tbW9uLmggYi9kcml2ZXJzL2Jsb2NrL3hlbi1i bGtiYWNrL2NvbW1vbi5oCmluZGV4IGVjYjM1ZmUuLjZkMTJkNGQgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvYmxvY2sveGVuLWJsa2JhY2svY29tbW9uLmgKKysrIGIvZHJpdmVycy9ibG9jay94ZW4tYmxr YmFjay9jb21tb24uaApAQCAtMzI5LDYgKzMyOSw5IEBAIHN0cnVjdCB4ZW5fYmxraWYgewogCS8q IEFsbCByaW5ncyBmb3IgdGhpcyBkZXZpY2UuICovCiAJc3RydWN0IHhlbl9ibGtpZl9yaW5nCSpy aW5nczsKIAl1bnNpZ25lZCBpbnQJCW5yX3JpbmdzOworI2lmZGVmIENPTkZJR19YRU5fQkxLREVW X0JBQ0tFTkRfRkFVTFRfSU5KRUNUSU9OCisJdm9pZAkJCSpmaV9pbmZvOworI2VuZGlmCiB9Owog CiBzdHJ1Y3Qgc2VnX2J1ZiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNr L3hlbmJ1cy5jIGIvZHJpdmVycy9ibG9jay94ZW4tYmxrYmFjay94ZW5idXMuYwppbmRleCAyMWMx YmUxLi45OTMxZmM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3hlbi1ibGtiYWNrL3hlbmJ1 cy5jCisrKyBiL2RyaXZlcnMvYmxvY2sveGVuLWJsa2JhY2sveGVuYnVzLmMKQEAgLTIyLDYgKzIy LDcgQEAKICNpbmNsdWRlIDx4ZW4vZXZlbnRzLmg+CiAjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxl Lmg+CiAjaW5jbHVkZSAiY29tbW9uLmgiCisjaW5jbHVkZSAiYmxrYmFja19maS5oIgogCiAvKiBP biB0aGUgWGVuQnVzIHRoZSBtYXggbGVuZ3RoIG9mICdyaW5nLXJlZiV1Jy4gKi8KICNkZWZpbmUg UklOR1JFRl9OQU1FX0xFTiAoMjApCkBAIC0yNDYsNiArMjQ3LDggQEAgc3RhdGljIGludCB4ZW5f YmxraWZfZGlzY29ubmVjdChzdHJ1Y3QgeGVuX2Jsa2lmICpibGtpZikKIAl1bnNpZ25lZCBpbnQg aiwgcjsKIAlib29sIGJ1c3kgPSBmYWxzZTsKIAorCXhlbl9ibGtpZl9maV9maW5pKGJsa2lmKTsK KwogCWZvciAociA9IDA7IHIgPCBibGtpZi0+bnJfcmluZ3M7IHIrKykgewogCQlzdHJ1Y3QgeGVu X2Jsa2lmX3JpbmcgKnJpbmcgPSAmYmxraWYtPnJpbmdzW3JdOwogCQl1bnNpZ25lZCBpbnQgaSA9 IDA7CkBAIC05OTgsNiArMTAwMSw4IEBAIHN0YXRpYyBpbnQgcmVhZF9wZXJfcmluZ19yZWZzKHN0 cnVjdCB4ZW5fYmxraWZfcmluZyAqcmluZywgY29uc3QgY2hhciAqZGlyKQogCQlyZXR1cm4gZXJy OwogCX0KIAorCSh2b2lkKSB4ZW5fYmxraWZfZmlfaW5pdChibGtpZik7CisKIAlyZXR1cm4gMDsK IAogZmFpbDoKCkFtYXpvbiBEZXZlbG9wbWVudCBDZW50ZXIgR2VybWFueSBHbWJICkJlcmxpbiAt IERyZXNkZW4gLSBBYWNoZW4KbWFpbiBvZmZpY2U6IEtyYXVzZW5zdHIuIDM4LCAxMDExNyBCZXJs aW4KR2VzY2hhZWZ0c2Z1ZWhyZXI6IERyLiBSYWxmIEhlcmJyaWNoLCBDaHJpc3RpYW4gU2NobGFl Z2VyClVzdC1JRDogREUyODkyMzc4NzkKRWluZ2V0cmFnZW4gYW0gQW10c2dlcmljaHQgQ2hhcmxv dHRlbmJ1cmcgSFJCIDE0OTE3MyBCCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754721AbeDTKr5 (ORCPT ); Fri, 20 Apr 2018 06:47:57 -0400 Received: from smtp-fw-9102.amazon.com ([207.171.184.29]:43906 "EHLO smtp-fw-9102.amazon.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754639AbeDTKry (ORCPT ); Fri, 20 Apr 2018 06:47:54 -0400 X-IronPort-AV: E=Sophos;i="5.49,301,1520899200"; d="scan'208";a="607906235" Subject: [PATCH 3/3] xen blkback: add fault injection facility From: Stanislav Kinsburskii CC: , , , , , , , , , , , , , , , , , , , , , , , , Date: Fri, 20 Apr 2018 10:47:36 +0000 Message-ID: <20180420104736.17823.42983.stgit@dev-dsk-staskins-1a-ca5afbf2.eu-west-1.amazon.com> In-Reply-To: <20180420104603.17823.31095.stgit@dev-dsk-staskins-1a-ca5afbf2.eu-west-1.amazon.com> References: <20180420104603.17823.31095.stgit@dev-dsk-staskins-1a-ca5afbf2.eu-west-1.amazon.com> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" To: unlisted-recipients:; (no To-header on input) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by mail.home.local id w3KAm4Qk016970 This patch adds wrapper helpers around generic Xen fault inject facility. The major reason is to keep all the module fault injection directories in a dedicated subdirectory instead of Xen fault inject root. IOW, when using these helpers, per-device and named by device name fault injection control directories will appear under the following directory: - /sys/kernel/debug/xen/fault_inject/xen-blkback/ instead of: - /sys/kernel/debug/xen/fault_inject/ Signed-off-by: Stanislav Kinsburskii CC: Jens Axboe CC: Konrad Rzeszutek Wilk CC: "Roger Pau Monné" CC: linux-kernel@vger.kernel.org CC: linux-block@vger.kernel.org CC: xen-devel@lists.xenproject.org CC: Stanislav Kinsburskii CC: David Woodhouse --- drivers/block/Kconfig | 7 ++ drivers/block/xen-blkback/Makefile | 1 drivers/block/xen-blkback/blkback.c | 9 ++ drivers/block/xen-blkback/blkback_fi.c | 116 ++++++++++++++++++++++++++++++++ drivers/block/xen-blkback/blkback_fi.h | 37 ++++++++++ drivers/block/xen-blkback/common.h | 3 + drivers/block/xen-blkback/xenbus.c | 5 + 7 files changed, 178 insertions(+) create mode 100644 drivers/block/xen-blkback/blkback_fi.c create mode 100644 drivers/block/xen-blkback/blkback_fi.h diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig index ad9b687..0ce05fe 100644 --- a/drivers/block/Kconfig +++ b/drivers/block/Kconfig @@ -436,6 +436,13 @@ config XEN_BLKDEV_BACKEND compile this driver as a module, chose M here: the module will be called xen-blkback. +config XEN_BLKDEV_BACKEND_FAULT_INJECTION + bool "Xen block-device backend driver fault injection" + depends on XEN_BLKDEV_BACKEND + depends on XEN_FAULT_INJECTION + default n + help + Allow to inject errors to Xen backend block driver config VIRTIO_BLK tristate "Virtio block driver" diff --git a/drivers/block/xen-blkback/Makefile b/drivers/block/xen-blkback/Makefile index e491c1b..035d134 100644 --- a/drivers/block/xen-blkback/Makefile +++ b/drivers/block/xen-blkback/Makefile @@ -1,3 +1,4 @@ obj-$(CONFIG_XEN_BLKDEV_BACKEND) := xen-blkback.o xen-blkback-y := blkback.o xenbus.o +xen-blkback-$(CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION) += blkback_fi.o diff --git a/drivers/block/xen-blkback/blkback.c b/drivers/block/xen-blkback/blkback.c index 987d665..2933bec 100644 --- a/drivers/block/xen-blkback/blkback.c +++ b/drivers/block/xen-blkback/blkback.c @@ -51,6 +51,7 @@ #include #include #include "common.h" +#include "blkback_fi.h" /* * Maximum number of unused free pages to keep in the internal buffer. @@ -1491,11 +1492,19 @@ static int __init xen_blkif_init(void) if (rc) goto failed_init; + (void) xen_blkbk_fi_init(); failed_init: return rc; } module_init(xen_blkif_init); +static void __exit xen_blkif_fini(void) +{ + xen_blkbk_fi_fini(); +} + +module_exit(xen_blkif_fini); + MODULE_LICENSE("Dual BSD/GPL"); MODULE_ALIAS("xen-backend:vbd"); diff --git a/drivers/block/xen-blkback/blkback_fi.c b/drivers/block/xen-blkback/blkback_fi.c new file mode 100644 index 0000000..b7abaea --- /dev/null +++ b/drivers/block/xen-blkback/blkback_fi.c @@ -0,0 +1,116 @@ +/* + * Fault injection interface for Xen virtual block devices + * + * Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation; or, when distributed + * separately from the Linux kernel or incorporated into other + * software packages, subject to the following license: + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this source file (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, + * merge, publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include +#include + +#include + +#include "blkback_fi.h" +#include "common.h" + +static struct dentry *blkif_fi_dir; + +static const char *xen_blkif_fi_names[XENBLKIF_FI_MAX] = { +}; + +struct xen_blkif_fi { + struct dentry *dir; + struct xen_fi *faults[XENBLKIF_FI_MAX]; +}; + +int xen_blkbk_fi_init(void) +{ + blkif_fi_dir = xen_fi_dir_create("xen-blkback"); + if (!blkif_fi_dir) + return -ENOMEM; + return 0; +} + +void xen_blkbk_fi_fini(void) +{ + debugfs_remove_recursive(blkif_fi_dir); +} + +void xen_blkif_fi_fini(struct xen_blkif *blkif) +{ + struct xen_blkif_fi *bfi = blkif->fi_info; + int fi; + + if (!blkif->fi_info) + return; + + blkif->fi_info = NULL; + + for (fi = 0; fi < XENBLKIF_FI_MAX; fi++) + xen_fi_del(bfi->faults[fi]); + debugfs_remove_recursive(bfi->dir); + kfree(bfi); +} + +int xen_blkif_fi_init(struct xen_blkif *blkif) +{ + struct xen_blkif_fi *bfi; + int fi, err = -ENOMEM; + + bfi = kmalloc(sizeof(*bfi), GFP_KERNEL); + if (!bfi) + return -ENOMEM; + + bfi->dir = debugfs_create_dir(dev_name(&blkif->be->dev->dev), + blkif_fi_dir); + if (!bfi->dir) + goto err_dir; + + for (fi = 0; fi < XENBLKIF_FI_MAX; fi++) { + bfi->faults[fi] = xen_fi_dir_add(bfi->dir, + xen_blkif_fi_names[fi]); + if (!bfi->faults[fi]) + goto err_fault; + } + + blkif->fi_info = bfi; + return 0; + +err_fault: + for (; fi > 0; fi--) + xen_fi_del(bfi->faults[fi]); + debugfs_remove_recursive(bfi->dir); +err_dir: + kfree(bfi); + return err; +} + +bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type) +{ + struct xen_blkif_fi *bfi = blkif->fi_info; + + return xen_should_fail(bfi->faults[type]); +} diff --git a/drivers/block/xen-blkback/blkback_fi.h b/drivers/block/xen-blkback/blkback_fi.h new file mode 100644 index 0000000..4e29850 --- /dev/null +++ b/drivers/block/xen-blkback/blkback_fi.h @@ -0,0 +1,37 @@ +#ifndef _XEN_BLKBACK_FI_H +#define _XEN_BLKBACK_FI_H + +struct xen_fi; +struct xen_blkif; + +typedef enum { + XENBLKIF_FI_MAX +} xen_blkbk_fi_t; + +#ifdef CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION + +void xen_blkbk_fi_fini(void); +int xen_blkbk_fi_init(void); + +void xen_blkif_fi_fini(struct xen_blkif *blkif); +int xen_blkif_fi_init(struct xen_blkif *blkif); + +bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type); + +#else + +static inline void xen_blkbk_fi_fini(void) { } +static inline int xen_blkbk_fi_init(void) { return 0; } + +static inline void xen_blkif_fi_fini(struct xen_blkif *blkif) { } +static inline int xen_blkif_fi_init(struct xen_blkif *blkif) { return 0; } + +static inline bool xenblkif_should_fail(struct xen_blkif *blkif, xen_blkbk_fi_t type) +{ + return false; +} + +#endif /* CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION */ + +#endif /* _XEN_BLKBACK_FI_H */ + diff --git a/drivers/block/xen-blkback/common.h b/drivers/block/xen-blkback/common.h index ecb35fe..6d12d4d 100644 --- a/drivers/block/xen-blkback/common.h +++ b/drivers/block/xen-blkback/common.h @@ -329,6 +329,9 @@ struct xen_blkif { /* All rings for this device. */ struct xen_blkif_ring *rings; unsigned int nr_rings; +#ifdef CONFIG_XEN_BLKDEV_BACKEND_FAULT_INJECTION + void *fi_info; +#endif }; struct seg_buf { diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c index 21c1be1..9931fc8 100644 --- a/drivers/block/xen-blkback/xenbus.c +++ b/drivers/block/xen-blkback/xenbus.c @@ -22,6 +22,7 @@ #include #include #include "common.h" +#include "blkback_fi.h" /* On the XenBus the max length of 'ring-ref%u'. */ #define RINGREF_NAME_LEN (20) @@ -246,6 +247,8 @@ static int xen_blkif_disconnect(struct xen_blkif *blkif) unsigned int j, r; bool busy = false; + xen_blkif_fi_fini(blkif); + for (r = 0; r < blkif->nr_rings; r++) { struct xen_blkif_ring *ring = &blkif->rings[r]; unsigned int i = 0; @@ -998,6 +1001,8 @@ static int read_per_ring_refs(struct xen_blkif_ring *ring, const char *dir) return err; } + (void) xen_blkif_fi_init(blkif); + return 0; fail: Amazon Development Center Germany GmbH Berlin - Dresden - Aachen main office: Krausenstr. 38, 10117 Berlin Geschaeftsfuehrer: Dr. Ralf Herbrich, Christian Schlaeger Ust-ID: DE289237879 Eingetragen am Amtsgericht Charlottenburg HRB 149173 B