From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [5/7] EDAC, mce_amd: Convert to seq_buf From: Borislav Petkov Message-Id: <20170825102411.8682-6-bp@alien8.de> Date: Fri, 25 Aug 2017 12:24:09 +0200 To: linux-edac Cc: Steven Rostedt , Tony Luck , Yazen Ghannam , X86 ML , LKML List-ID: RnJvbTogQm9yaXNsYXYgUGV0a292IDxicEBzdXNlLmRlPgoKQ29udmVydCB0aGUgcGFydCB3aGlj aCBkZWNvZGVzIHRoZSBlcnJvciBkZXNjcmlwdGlvbiB0byB0aGUgc2VxdWVuY2UKYnVmZmVyIGZh Y2lsaXR5IGFuZCB0aHVzIHNhdmUgb3Vyc2VsdmVzIHRoZSBtYW55IHByaW50aygpIGludm9jYXRp b25zCmJ1aWxkaW5nIHRoZSBkZWNvZGVkIHN0cmluZy4KCkFsc28sIHVzZSBhIGdlbnBvb2wgZm9y IHRoZSBzdHJpbmcgYnVmZmVycyB0byBoYW5kbGUgY29uY3VycmVudAppbnZvY2F0aW9ucyAoYW5k IGF0b21pYyBjb250ZXh0KS4KClNpZ25lZC1vZmYtYnk6IEJvcmlzbGF2IFBldGtvdiA8YnBAc3Vz ZS5kZT4KLS0tCiBkcml2ZXJzL2VkYWMvbWNlX2FtZC5jIHwgMjE1ICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAxMjcgaW5z ZXJ0aW9ucygrKSwgODggZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL21j ZV9hbWQuYyBiL2RyaXZlcnMvZWRhYy9tY2VfYW1kLmMKaW5kZXggYTExYTY3MWM3YTM4Li5iN2Mx ZjhmN2U4NzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9tY2VfYW1kLmMKKysrIGIvZHJpdmVy cy9lZGFjL21jZV9hbWQuYwpAQCAtMSwzICsxLDUgQEAKKyNpbmNsdWRlIDxsaW51eC9nZW5hbGxv Yy5oPgorI2luY2x1ZGUgPGxpbnV4L3NlcV9idWYuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUu aD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAKQEAgLTM0LDYgKzM2LDE2IEBAIHZvaWQgYW1k X3VucmVnaXN0ZXJfZWNjX2RlY29kZXIodm9pZCAoKmYpKGludCwgc3RydWN0IG1jZSAqKSkKIH0K IEVYUE9SVF9TWU1CT0xfR1BMKGFtZF91bnJlZ2lzdGVyX2VjY19kZWNvZGVyKTsKIAorLyogMTI4 IGJlY2F1c2UsIHdlbGwsIG5pY2UgYW5kIHJvdW5kIC0gdHdvIGNhY2hlbGluZXMuICovCisjZGVm aW5lIEVMRU1fT1JERVIJNworI2RlZmluZSBFTEVNX1NJWkUJKDEgPDwgNykKKyNkZWZpbmUgREVD X1BPT0xfU0laRQkoMiAqIFBBR0VfU0laRSkKKworc3RhdGljIGNoYXIgX19lcnJfYnVmW0RFQ19Q T09MX1NJWkVdOworc3RhdGljIHN0cnVjdCBnZW5fcG9vbCAqZGVjX3Bvb2w7CisKK3N0YXRpYyBz dHJ1Y3Qgc2VxX2J1ZiBzYjsKKwogLyoKICAqIHN0cmluZyByZXByZXNlbnRhdGlvbiBmb3IgdGhl IGRpZmZlcmVudCBNQ0EgcmVwb3J0ZWQgZXJyb3IgdHlwZXMsIHNlZSBGM3g0OAogICogb3IgTVNS MDAwMF8wNDExLgpAQCAtMzE1LDkgKzMyNyw5IEBAIHN0YXRpYyBib29sIGYxMmhfbWMwX21jZSh1 MTYgZWMsIHU4IHhlYykKIAkJcmV0ID0gdHJ1ZTsKIAogCQlpZiAobGwgPT0gTExfTDIpCi0JCQlw cl9jb250KCJkdXJpbmcgTDEgbGluZWZpbGwgZnJvbSBMMi5cbiIpOworCQkJc2VxX2J1Zl9wcmlu dGYoJnNiLCAiZHVyaW5nIEwxIGxpbmVmaWxsIGZyb20gTDIuXG4iKTsKIAkJZWxzZSBpZiAobGwg PT0gTExfTDEpCi0JCQlwcl9jb250KCJEYXRhL1RhZyAlcyBlcnJvci5cbiIsIFI0X01TRyhlYykp OworCQkJc2VxX2J1Zl9wcmludGYoJnNiLCAiRGF0YS9UYWcgJXMgZXJyb3IuXG4iLCBSNF9NU0co ZWMpKTsKIAkJZWxzZQogCQkJcmV0ID0gZmFsc2U7CiAJfQpAQCAtMzI3LDcgKzMzOSw3IEBAIHN0 YXRpYyBib29sIGYxMmhfbWMwX21jZSh1MTYgZWMsIHU4IHhlYykKIHN0YXRpYyBib29sIGYxMGhf bWMwX21jZSh1MTYgZWMsIHU4IHhlYykKIHsKIAlpZiAoUjQoZWMpID09IFI0X0dFTiAmJiBMTChl YykgPT0gTExfTDEpIHsKLQkJcHJfY29udCgiZHVyaW5nIGRhdGEgc2NydWIuXG4iKTsKKwkJc2Vx X2J1Zl9wcmludGYoJnNiLCAiZHVyaW5nIGRhdGEgc2NydWIuXG4iKTsKIAkJcmV0dXJuIHRydWU7 CiAJfQogCXJldHVybiBmMTJoX21jMF9tY2UoZWMsIHhlYyk7CkBAIC0zMzYsNyArMzQ4LDcgQEAg c3RhdGljIGJvb2wgZjEwaF9tYzBfbWNlKHUxNiBlYywgdTggeGVjKQogc3RhdGljIGJvb2wgazhf bWMwX21jZSh1MTYgZWMsIHU4IHhlYykKIHsKIAlpZiAoQlVTX0VSUk9SKGVjKSkgewotCQlwcl9j b250KCJkdXJpbmcgc3lzdGVtIGxpbmVmaWxsLlxuIik7CisJCXNlcV9idWZfcHJpbnRmKCZzYiwg ImR1cmluZyBzeXN0ZW0gbGluZWZpbGwuXG4iKTsKIAkJcmV0dXJuIHRydWU7CiAJfQogCkBAIC0z NTYsMTQgKzM2OCwxNCBAQCBzdGF0aWMgYm9vbCBjYXRfbWMwX21jZSh1MTYgZWMsIHU4IHhlYykK IAkJc3dpdGNoIChyNCkgewogCQljYXNlIFI0X0RSRDoKIAkJY2FzZSBSNF9EV1I6Ci0JCQlwcl9j b250KCJEYXRhL1RhZyBwYXJpdHkgZXJyb3IgZHVlIHRvICVzLlxuIiwKLQkJCQkocjQgPT0gUjRf RFJEID8gImxvYWQvaHcgcHJmIiA6ICJzdG9yZSIpKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwg IkRhdGEvVGFnIHBhcml0eSBlcnJvciBkdWUgdG8gJXMuXG4iLAorCQkJCQkocjQgPT0gUjRfRFJE ID8gImxvYWQvaHcgcHJmIiA6ICJzdG9yZSIpKTsKIAkJCWJyZWFrOwogCQljYXNlIFI0X0VWSUNU OgotCQkJcHJfY29udCgiQ29weWJhY2sgcGFyaXR5IGVycm9yIG9uIGEgdGFnIG1pc3MuXG4iKTsK KwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgIkNvcHliYWNrIHBhcml0eSBlcnJvciBvbiBhIHRhZyBt aXNzLlxuIik7CiAJCQlicmVhazsKIAkJY2FzZSBSNF9TTk9PUDoKLQkJCXByX2NvbnQoIlRhZyBw YXJpdHkgZXJyb3IgZHVyaW5nIHNub29wLlxuIik7CisJCQlzZXFfYnVmX3ByaW50Zigmc2IsICJU YWcgcGFyaXR5IGVycm9yIGR1cmluZyBzbm9vcC5cbiIpOwogCQkJYnJlYWs7CiAJCWRlZmF1bHQ6 CiAJCQlyZXQgPSBmYWxzZTsKQEAgLTM3MywxNyArMzg1LDE3IEBAIHN0YXRpYyBib29sIGNhdF9t YzBfbWNlKHUxNiBlYywgdTggeGVjKQogCQlpZiAoKElJKGVjKSAhPSBJSV9NRU0gJiYgSUkoZWMp ICE9IElJX0lPKSB8fCBMTChlYykgIT0gTExfTEcpCiAJCQlyZXR1cm4gZmFsc2U7CiAKLQkJcHJf Y29udCgiU3lzdGVtIHJlYWQgZGF0YSBlcnJvciBvbiBhICIpOworCQlzZXFfYnVmX3ByaW50Zigm c2IsICJTeXN0ZW0gcmVhZCBkYXRhIGVycm9yIG9uIGEgIik7CiAKIAkJc3dpdGNoIChyNCkgewog CQljYXNlIFI0X1JEOgotCQkJcHJfY29udCgiVExCIHJlbG9hZC5cbiIpOworCQkJc2VxX2J1Zl9w cmludGYoJnNiLCAiVExCIHJlbG9hZC5cbiIpOwogCQkJYnJlYWs7CiAJCWNhc2UgUjRfRFdSOgot CQkJcHJfY29udCgic3RvcmUuXG4iKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgInN0b3JlLlxu Iik7CiAJCQlicmVhazsKIAkJY2FzZSBSNF9EUkQ6Ci0JCQlwcl9jb250KCJsb2FkLlxuIik7CisJ CQlzZXFfYnVmX3ByaW50Zigmc2IsICJsb2FkLlxuIik7CiAJCQlicmVhazsKIAkJZGVmYXVsdDoK IAkJCXJldCA9IGZhbHNlOwpAQCAtNDAzLDI4ICs0MTUsMjggQEAgc3RhdGljIGJvb2wgZjE1aF9t YzBfbWNlKHUxNiBlYywgdTggeGVjKQogCiAJCXN3aXRjaCAoeGVjKSB7CiAJCWNhc2UgMHgwOgot CQkJcHJfY29udCgiRGF0YSBBcnJheSBhY2Nlc3MgZXJyb3IuXG4iKTsKKwkJCXNlcV9idWZfcHJp bnRmKCZzYiwgIkRhdGEgQXJyYXkgYWNjZXNzIGVycm9yLlxuIik7CiAJCQlicmVhazsKIAogCQlj YXNlIDB4MToKLQkJCXByX2NvbnQoIlVDIGVycm9yIGR1cmluZyBhIGxpbmVmaWxsIGZyb20gTDIv TkIuXG4iKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgIlVDIGVycm9yIGR1cmluZyBhIGxpbmVm aWxsIGZyb20gTDIvTkIuXG4iKTsKIAkJCWJyZWFrOwogCiAJCWNhc2UgMHgyOgogCQljYXNlIDB4 MTE6Ci0JCQlwcl9jb250KCJTVFEgYWNjZXNzIGVycm9yLlxuIik7CisJCQlzZXFfYnVmX3ByaW50 Zigmc2IsICJTVFEgYWNjZXNzIGVycm9yLlxuIik7CiAJCQlicmVhazsKIAogCQljYXNlIDB4MzoK LQkJCXByX2NvbnQoIlNDQiBhY2Nlc3MgZXJyb3IuXG4iKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZz YiwgIlNDQiBhY2Nlc3MgZXJyb3IuXG4iKTsKIAkJCWJyZWFrOwogCiAJCWNhc2UgMHgxMDoKLQkJ CXByX2NvbnQoIlRhZyBlcnJvci5cbiIpOworCQkJc2VxX2J1Zl9wcmludGYoJnNiLCAiVGFnIGVy cm9yLlxuIik7CiAJCQlicmVhazsKIAogCQljYXNlIDB4MTI6Ci0JCQlwcl9jb250KCJMRFEgYWNj ZXNzIGVycm9yLlxuIik7CisJCQlzZXFfYnVmX3ByaW50Zigmc2IsICJMRFEgYWNjZXNzIGVycm9y LlxuIik7CiAJCQlicmVhazsKIAogCQlkZWZhdWx0OgpAQCAtNDMzLDEyICs0NDUsMTIgQEAgc3Rh dGljIGJvb2wgZjE1aF9tYzBfbWNlKHUxNiBlYywgdTggeGVjKQogCX0gZWxzZSBpZiAoQlVTX0VS Uk9SKGVjKSkgewogCiAJCWlmICgheGVjKQotCQkJcHJfY29udCgiU3lzdGVtIFJlYWQgRGF0YSBF cnJvci5cbiIpOworCQkJc2VxX2J1Zl9wcmludGYoJnNiLCAiU3lzdGVtIFJlYWQgRGF0YSBFcnJv ci5cbiIpOwogCQllbHNlCi0JCQlwcl9jb250KCIgSW50ZXJuYWwgZXJyb3IgY29uZGl0aW9uIHR5 cGUgJWQuXG4iLCB4ZWMpOworCQkJc2VxX2J1Zl9wcmludGYoJnNiLCAiIEludGVybmFsIGVycm9y IGNvbmRpdGlvbiB0eXBlICVkLlxuIiwgeGVjKTsKIAl9IGVsc2UgaWYgKElOVF9FUlJPUihlYykp IHsKIAkJaWYgKHhlYyA8PSAweDFmKQotCQkJcHJfY29udCgiSGFyZHdhcmUgQXNzZXJ0LlxuIik7 CisJCQlzZXFfYnVmX3ByaW50Zigmc2IsICJIYXJkd2FyZSBBc3NlcnQuXG4iKTsKIAkJZWxzZQog CQkJcmV0ID0gZmFsc2U7CiAKQEAgLTQ1MywxMyArNDY1LDEzIEBAIHN0YXRpYyB2b2lkIGRlY29k ZV9tYzBfbWNlKHN0cnVjdCBtY2UgKm0pCiAJdTE2IGVjID0gRUMobS0+c3RhdHVzKTsKIAl1OCB4 ZWMgPSBYRUMobS0+c3RhdHVzLCB4ZWNfbWFzayk7CiAKLQlwcl9lbWVyZyhIV19FUlIgIk1DMCBF cnJvcjogIik7CisJc2VxX2J1Zl9wcmludGYoJnNiLCBIV19FUlIgIk1DMCBFcnJvcjogIik7CiAK IAkvKiBUTEIgZXJyb3Igc2lnbmF0dXJlcyBhcmUgdGhlIHNhbWUgYWNyb3NzIGZhbWlsaWVzICov CiAJaWYgKFRMQl9FUlJPUihlYykpIHsKIAkJaWYgKFRUKGVjKSA9PSBUVF9EQVRBKSB7Ci0JCQlw cl9jb250KCIlcyBUTEIgJXMuXG4iLCBMTF9NU0coZWMpLAotCQkJCSgoeGVjID09IDIpID8gImxv Y2tlZCBtaXNzIgorCQkJc2VxX2J1Zl9wcmludGYoJnNiLCAiJXMgVExCICVzLlxuIiwgTExfTVNH KGVjKSwKKwkJCQkJKCh4ZWMgPT0gMikgPyAibG9ja2VkIG1pc3MiCiAJCQkJCSAgICA6ICh4ZWMg PyAibXVsdGltYXRjaCIgOiAicGFyaXR5IikpKTsKIAkJCXJldHVybjsKIAkJfQpAQCAtNDc4LDE5 ICs0OTAsMTkgQEAgc3RhdGljIGJvb2wgazhfbWMxX21jZSh1MTYgZWMsIHU4IHhlYykKIAkJcmV0 dXJuIGZhbHNlOwogCiAJaWYgKGxsID09IDB4MikKLQkJcHJfY29udCgiZHVyaW5nIGEgbGluZWZp bGwgZnJvbSBMMi5cbiIpOworCQlzZXFfYnVmX3ByaW50Zigmc2IsICJkdXJpbmcgYSBsaW5lZmls bCBmcm9tIEwyLlxuIik7CiAJZWxzZSBpZiAobGwgPT0gMHgxKSB7CiAJCXN3aXRjaCAoUjQoZWMp KSB7CiAJCWNhc2UgUjRfSVJEOgotCQkJcHJfY29udCgiUGFyaXR5IGVycm9yIGR1cmluZyBkYXRh IGxvYWQuXG4iKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgIlBhcml0eSBlcnJvciBkdXJpbmcg ZGF0YSBsb2FkLlxuIik7CiAJCQlicmVhazsKIAogCQljYXNlIFI0X0VWSUNUOgotCQkJcHJfY29u dCgiQ29weWJhY2sgUGFyaXR5L1ZpY3RpbSBlcnJvci5cbiIpOworCQkJc2VxX2J1Zl9wcmludGYo JnNiLCAiQ29weWJhY2sgUGFyaXR5L1ZpY3RpbSBlcnJvci5cbiIpOwogCQkJYnJlYWs7CiAKIAkJ Y2FzZSBSNF9TTk9PUDoKLQkJCXByX2NvbnQoIlRhZyBTbm9vcCBlcnJvci5cbiIpOworCQkJc2Vx X2J1Zl9wcmludGYoJnNiLCAiVGFnIFNub29wIGVycm9yLlxuIik7CiAJCQlicmVhazsKIAogCQlk ZWZhdWx0OgpAQCAtNTE1LDEzICs1MjcsMTMgQEAgc3RhdGljIGJvb2wgY2F0X21jMV9tY2UodTE2 IGVjLCB1OCB4ZWMpCiAJCXJldHVybiBmYWxzZTsKIAogCWlmIChyNCA9PSBSNF9JUkQpCi0JCXBy X2NvbnQoIkRhdGEvdGFnIGFycmF5IHBhcml0eSBlcnJvciBmb3IgYSB0YWcgaGl0LlxuIik7CisJ CXNlcV9idWZfcHJpbnRmKCZzYiwgIkRhdGEvdGFnIGFycmF5IHBhcml0eSBlcnJvciBmb3IgYSB0 YWcgaGl0LlxuIik7CiAJZWxzZSBpZiAocjQgPT0gUjRfU05PT1ApCi0JCXByX2NvbnQoIlRhZyBl cnJvciBkdXJpbmcgc25vb3AvdmljdGltaXphdGlvbi5cbiIpOworCQlzZXFfYnVmX3ByaW50Zigm c2IsICJUYWcgZXJyb3IgZHVyaW5nIHNub29wL3ZpY3RpbWl6YXRpb24uXG4iKTsKIAllbHNlIGlm ICh4ZWMgPT0gMHgwKQotCQlwcl9jb250KCJUYWcgcGFyaXR5IGVycm9yIGZyb20gdmljdGltIGNh c3RvdXQuXG4iKTsKKwkJc2VxX2J1Zl9wcmludGYoJnNiLCAiVGFnIHBhcml0eSBlcnJvciBmcm9t IHZpY3RpbSBjYXN0b3V0LlxuIik7CiAJZWxzZSBpZiAoeGVjID09IDB4MikKLQkJcHJfY29udCgi TWljcm9jb2RlIHBhdGNoIFJBTSBwYXJpdHkgZXJyb3IuXG4iKTsKKwkJc2VxX2J1Zl9wcmludGYo JnNiLCAiTWljcm9jb2RlIHBhdGNoIFJBTSBwYXJpdHkgZXJyb3IuXG4iKTsKIAllbHNlCiAJCXJl dCA9IGZhbHNlOwogCkBAIC01MzcsMTkgKzU0OSwxOSBAQCBzdGF0aWMgYm9vbCBmMTVoX21jMV9t Y2UodTE2IGVjLCB1OCB4ZWMpCiAKIAlzd2l0Y2ggKHhlYykgewogCWNhc2UgMHgwIC4uLiAweGE6 Ci0JCXByX2NvbnQoIiVzLlxuIiwgZjE1aF9tYzFfbWNlX2Rlc2NbeGVjXSk7CisJCXNlcV9idWZf cHJpbnRmKCZzYiwgIiVzLlxuIiwgZjE1aF9tYzFfbWNlX2Rlc2NbeGVjXSk7CiAJCWJyZWFrOwog CiAJY2FzZSAweGQ6Ci0JCXByX2NvbnQoIiVzLlxuIiwgZjE1aF9tYzFfbWNlX2Rlc2NbeGVjLTJd KTsKKwkJc2VxX2J1Zl9wcmludGYoJnNiLCAiJXMuXG4iLCBmMTVoX21jMV9tY2VfZGVzY1t4ZWMt Ml0pOwogCQlicmVhazsKIAogCWNhc2UgMHgxMDoKLQkJcHJfY29udCgiJXMuXG4iLCBmMTVoX21j MV9tY2VfZGVzY1t4ZWMtNF0pOworCQlzZXFfYnVmX3ByaW50Zigmc2IsICIlcy5cbiIsIGYxNWhf bWMxX21jZV9kZXNjW3hlYy00XSk7CiAJCWJyZWFrOwogCiAJY2FzZSAweDExIC4uLiAweDE1Ogot CQlwcl9jb250KCJEZWNvZGVyICVzIHBhcml0eSBlcnJvci5cbiIsIGYxNWhfbWMxX21jZV9kZXNj W3hlYy00XSk7CisJCXNlcV9idWZfcHJpbnRmKCZzYiwgIkRlY29kZXIgJXMgcGFyaXR5IGVycm9y LlxuIiwgZjE1aF9tYzFfbWNlX2Rlc2NbeGVjLTRdKTsKIAkJYnJlYWs7CiAKIAlkZWZhdWx0OgpA QCAtNTYzLDE4ICs1NzUsMTggQEAgc3RhdGljIHZvaWQgZGVjb2RlX21jMV9tY2Uoc3RydWN0IG1j ZSAqbSkKIAl1MTYgZWMgPSBFQyhtLT5zdGF0dXMpOwogCXU4IHhlYyA9IFhFQyhtLT5zdGF0dXMs IHhlY19tYXNrKTsKIAotCXByX2VtZXJnKEhXX0VSUiAiTUMxIEVycm9yOiAiKTsKKwlzZXFfYnVm X3ByaW50Zigmc2IsIEhXX0VSUiAiTUMxIEVycm9yOiAiKTsKIAogCWlmIChUTEJfRVJST1IoZWMp KQotCQlwcl9jb250KCIlcyBUTEIgJXMuXG4iLCBMTF9NU0coZWMpLAotCQkJKHhlYyA/ICJtdWx0 aW1hdGNoIiA6ICJwYXJpdHkgZXJyb3IiKSk7CisJCXNlcV9idWZfcHJpbnRmKCZzYiwgIiVzIFRM QiAlcy5cbiIsIExMX01TRyhlYyksCisJCQkJKHhlYyA/ICJtdWx0aW1hdGNoIiA6ICJwYXJpdHkg ZXJyb3IiKSk7CiAJZWxzZSBpZiAoQlVTX0VSUk9SKGVjKSkgewogCQlib29sIGs4ID0gKGJvb3Rf Y3B1X2RhdGEueDg2ID09IDB4ZiAmJiAobS0+c3RhdHVzICYgQklUXzY0KDU4KSkpOwogCi0JCXBy X2NvbnQoImR1cmluZyAlcy5cbiIsIChrOCA/ICJzeXN0ZW0gbGluZWZpbGwiIDogIk5CIGRhdGEg cmVhZCIpKTsKKwkJc2VxX2J1Zl9wcmludGYoJnNiLCAiZHVyaW5nICVzLlxuIiwgKGs4ID8gInN5 c3RlbSBsaW5lZmlsbCIgOiAiTkIgZGF0YSByZWFkIikpOwogCX0gZWxzZSBpZiAoSU5UX0VSUk9S KGVjKSkgewogCQlpZiAoeGVjIDw9IDB4M2YpCi0JCQlwcl9jb250KCJIYXJkd2FyZSBBc3NlcnQu XG4iKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgIkhhcmR3YXJlIEFzc2VydC5cbiIpOwogCQll bHNlCiAJCQlnb3RvIHdyb25nX21jMV9tY2U7CiAJfSBlbHNlIGlmIChmYW1fb3BzLT5tYzFfbWNl KGVjLCB4ZWMpKQpAQCAtNTkzLDI3ICs2MDUsMjcgQEAgc3RhdGljIGJvb2wgazhfbWMyX21jZSh1 MTYgZWMsIHU4IHhlYykKIAlib29sIHJldCA9IHRydWU7CiAKIAlpZiAoeGVjID09IDB4MSkKLQkJ cHJfY29udCgiIGluIHRoZSB3cml0ZSBkYXRhIGJ1ZmZlcnMuXG4iKTsKKwkJc2VxX2J1Zl9wcmlu dGYoJnNiLCAiIGluIHRoZSB3cml0ZSBkYXRhIGJ1ZmZlcnMuXG4iKTsKIAllbHNlIGlmICh4ZWMg PT0gMHgzKQotCQlwcl9jb250KCIgaW4gdGhlIHZpY3RpbSBkYXRhIGJ1ZmZlcnMuXG4iKTsKKwkJ c2VxX2J1Zl9wcmludGYoJnNiLCAiIGluIHRoZSB2aWN0aW0gZGF0YSBidWZmZXJzLlxuIik7CiAJ ZWxzZSBpZiAoeGVjID09IDB4MiAmJiBNRU1fRVJST1IoZWMpKQotCQlwcl9jb250KCI6ICVzIGVy cm9yIGluIHRoZSBMMiBjYWNoZSB0YWdzLlxuIiwgUjRfTVNHKGVjKSk7CisJCXNlcV9idWZfcHJp bnRmKCZzYiwgIjogJXMgZXJyb3IgaW4gdGhlIEwyIGNhY2hlIHRhZ3MuXG4iLCBSNF9NU0coZWMp KTsKIAllbHNlIGlmICh4ZWMgPT0gMHgwKSB7CiAJCWlmIChUTEJfRVJST1IoZWMpKQotCQkJcHJf Y29udCgiJXMgZXJyb3IgaW4gYSBQYWdlIERlc2NyaXB0b3IgQ2FjaGUgb3IgR3Vlc3QgVExCLlxu IiwKLQkJCQlUVF9NU0coZWMpKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgIiVzIGVycm9yIGlu IGEgUGFnZSBEZXNjcmlwdG9yIENhY2hlIG9yIEd1ZXN0IFRMQi5cbiIsCisJCQkJCVRUX01TRyhl YykpOwogCQllbHNlIGlmIChCVVNfRVJST1IoZWMpKQotCQkJcHJfY29udCgiOiAlcy9FQ0MgZXJy b3IgaW4gZGF0YSByZWFkIGZyb20gTkI6ICVzLlxuIiwKLQkJCQlSNF9NU0coZWMpLCBQUF9NU0co ZWMpKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgIjogJXMvRUNDIGVycm9yIGluIGRhdGEgcmVh ZCBmcm9tIE5COiAlcy5cbiIsCisJCQkJCVI0X01TRyhlYyksIFBQX01TRyhlYykpOwogCQllbHNl IGlmIChNRU1fRVJST1IoZWMpKSB7CiAJCQl1OCByNCA9IFI0KGVjKTsKIAogCQkJaWYgKHI0ID49 IDB4NykKLQkJCQlwcl9jb250KCI6ICVzIGVycm9yIGR1cmluZyBkYXRhIGNvcHliYWNrLlxuIiwK LQkJCQkJUjRfTVNHKGVjKSk7CisJCQkJc2VxX2J1Zl9wcmludGYoJnNiLCAiOiAlcyBlcnJvciBk dXJpbmcgZGF0YSBjb3B5YmFjay5cbiIsCisJCQkJCQlSNF9NU0coZWMpKTsKIAkJCWVsc2UgaWYg KHI0IDw9IDB4MSkKLQkJCQlwcl9jb250KCI6ICVzIHBhcml0eS9FQ0MgZXJyb3IgZHVyaW5nIGRh dGEgIgotCQkJCQkiYWNjZXNzIGZyb20gTDIuXG4iLCBSNF9NU0coZWMpKTsKKwkJCQlzZXFfYnVm X3ByaW50Zigmc2IsCisiOiAlcyBwYXJpdHkvRUNDIGVycm9yIGR1cmluZyBkYXRhIGFjY2VzcyBm cm9tIEwyLlxuIiwgUjRfTVNHKGVjKSk7CiAJCQllbHNlCiAJCQkJcmV0ID0gZmFsc2U7CiAJCX0g ZWxzZQpAQCAtNjMwLDI0ICs2NDIsMjQgQEAgc3RhdGljIGJvb2wgZjE1aF9tYzJfbWNlKHUxNiBl YywgdTggeGVjKQogCiAJaWYgKFRMQl9FUlJPUihlYykpIHsKIAkJaWYgKHhlYyA9PSAweDApCi0J CQlwcl9jb250KCJEYXRhIHBhcml0eSBUTEIgcmVhZCBlcnJvci5cbiIpOworCQkJc2VxX2J1Zl9w cmludGYoJnNiLCAiRGF0YSBwYXJpdHkgVExCIHJlYWQgZXJyb3IuXG4iKTsKIAkJZWxzZSBpZiAo eGVjID09IDB4MSkKLQkJCXByX2NvbnQoIlBvaXNvbiBkYXRhIHByb3ZpZGVkIGZvciBUTEIgZmls bC5cbiIpOworCQkJc2VxX2J1Zl9wcmludGYoJnNiLCAiUG9pc29uIGRhdGEgcHJvdmlkZWQgZm9y IFRMQiBmaWxsLlxuIik7CiAJCWVsc2UKIAkJCXJldCA9IGZhbHNlOwogCX0gZWxzZSBpZiAoQlVT X0VSUk9SKGVjKSkgewogCQlpZiAoeGVjID4gMikKIAkJCXJldCA9IGZhbHNlOwogCi0JCXByX2Nv bnQoIkVycm9yIGR1cmluZyBhdHRlbXB0ZWQgTkIgZGF0YSByZWFkLlxuIik7CisJCXNlcV9idWZf cHJpbnRmKCZzYiwgIkVycm9yIGR1cmluZyBhdHRlbXB0ZWQgTkIgZGF0YSByZWFkLlxuIik7CiAJ fSBlbHNlIGlmIChNRU1fRVJST1IoZWMpKSB7CiAJCXN3aXRjaCAoeGVjKSB7CiAJCWNhc2UgMHg0 IC4uLiAweGM6Ci0JCQlwcl9jb250KCIlcy5cbiIsIGYxNWhfbWMyX21jZV9kZXNjW3hlYyAtIDB4 NF0pOworCQkJc2VxX2J1Zl9wcmludGYoJnNiLCAiJXMuXG4iLCBmMTVoX21jMl9tY2VfZGVzY1t4 ZWMgLSAweDRdKTsKIAkJCWJyZWFrOwogCiAJCWNhc2UgMHgxMCAuLi4gMHgxNDoKLQkJCXByX2Nv bnQoIiVzLlxuIiwgZjE1aF9tYzJfbWNlX2Rlc2NbeGVjIC0gMHg3XSk7CisJCQlzZXFfYnVmX3By aW50Zigmc2IsICIlcy5cbiIsIGYxNWhfbWMyX21jZV9kZXNjW3hlYyAtIDB4N10pOwogCQkJYnJl YWs7CiAKIAkJZGVmYXVsdDoKQEAgLTY1NSw3ICs2NjcsNyBAQCBzdGF0aWMgYm9vbCBmMTVoX21j Ml9tY2UodTE2IGVjLCB1OCB4ZWMpCiAJCX0KIAl9IGVsc2UgaWYgKElOVF9FUlJPUihlYykpIHsK IAkJaWYgKHhlYyA8PSAweDNmKQotCQkJcHJfY29udCgiSGFyZHdhcmUgQXNzZXJ0LlxuIik7CisJ CQlzZXFfYnVmX3ByaW50Zigmc2IsICJIYXJkd2FyZSBBc3NlcnQuXG4iKTsKIAkJZWxzZQogCQkJ cmV0ID0gZmFsc2U7CiAJfQpAQCAtNjcyLDI5ICs2ODQsMjkgQEAgc3RhdGljIGJvb2wgZjE2aF9t YzJfbWNlKHUxNiBlYywgdTggeGVjKQogCiAJc3dpdGNoICh4ZWMpIHsKIAljYXNlIDB4MDQgLi4u IDB4MDU6Ci0JCXByX2NvbnQoIiVjQlVGRiBwYXJpdHkgZXJyb3IuXG4iLCAocjQgPT0gUjRfUkQp ID8gJ0knIDogJ08nKTsKKwkJc2VxX2J1Zl9wcmludGYoJnNiLCAiJWNCVUZGIHBhcml0eSBlcnJv ci5cbiIsIChyNCA9PSBSNF9SRCkgPyAnSScgOiAnTycpOwogCQlicmVhazsKIAogCWNhc2UgMHgw OSAuLi4gMHgwYjoKIAljYXNlIDB4MGQgLi4uIDB4MGY6Ci0JCXByX2NvbnQoIkVDQyBlcnJvciBp biBMMiB0YWcgKCVzKS5cbiIsCi0JCQkoKHI0ID09IFI0X0dFTikgICA/ICJCYW5rUmVxIiA6Ci0J CQkoKHI0ID09IFI0X1NOT09QKSA/ICJQcmIiICAgICA6ICJGaWxsIikpKTsKKwkJc2VxX2J1Zl9w cmludGYoJnNiLCAiRUNDIGVycm9yIGluIEwyIHRhZyAoJXMpLlxuIiwKKwkJCQkoKHI0ID09IFI0 X0dFTikgICA/ICJCYW5rUmVxIiA6CisJCQkJKChyNCA9PSBSNF9TTk9PUCkgPyAiUHJiIiAgICAg OiAiRmlsbCIpKSk7CiAJCWJyZWFrOwogCiAJY2FzZSAweDEwIC4uLiAweDE5OgogCWNhc2UgMHgx YjoKLQkJcHJfY29udCgiRUNDIGVycm9yIGluIEwyIGRhdGEgYXJyYXkgKCVzKS5cbiIsCi0JCQko KChyNCA9PSBSNF9SRCkgJiYgISh4ZWMgJiAweDMpKSA/ICJIaXQiICA6Ci0JCQkoKHI0ID09IFI0 X0dFTikgICA/ICJBdHRyIiA6Ci0JCQkoKHI0ID09IFI0X0VWSUNUKSA/ICJWaWN0IiA6ICJGaWxs IikpKSk7CisJCXNlcV9idWZfcHJpbnRmKCZzYiwgIkVDQyBlcnJvciBpbiBMMiBkYXRhIGFycmF5 ICglcykuXG4iLAorCQkJCSgoKHI0ID09IFI0X1JEKSAmJiAhKHhlYyAmIDB4MykpID8gIkhpdCIg IDoKKwkJCQkoKHI0ID09IFI0X0dFTikgICA/ICJBdHRyIiA6CisJCQkJKChyNCA9PSBSNF9FVklD VCkgPyAiVmljdCIgOiAiRmlsbCIpKSkpOwogCQlicmVhazsKIAogCWNhc2UgMHgxYyAuLi4gMHgx ZDoKIAljYXNlIDB4MWY6Ci0JCXByX2NvbnQoIlBhcml0eSBlcnJvciBpbiBMMiBhdHRyaWJ1dGUg Yml0cyAoJXMpLlxuIiwKLQkJCSgocjQgPT0gUjRfUkQpICA/ICJIaXQiICA6Ci0JCQkoKHI0ID09 IFI0X0dFTikgPyAiQXR0ciIgOiAiRmlsbCIpKSk7CisJCXNlcV9idWZfcHJpbnRmKCZzYiwgIlBh cml0eSBlcnJvciBpbiBMMiBhdHRyaWJ1dGUgYml0cyAoJXMpLlxuIiwKKwkJCQkoKHI0ID09IFI0 X1JEKSAgPyAiSGl0IiAgOgorCQkJCSgocjQgPT0gUjRfR0VOKSA/ICJBdHRyIiA6ICJGaWxsIikp KTsKIAkJYnJlYWs7CiAKIAlkZWZhdWx0OgpAQCAtNzA5LDEwICs3MjEsMTAgQEAgc3RhdGljIHZv aWQgZGVjb2RlX21jMl9tY2Uoc3RydWN0IG1jZSAqbSkKIAl1MTYgZWMgPSBFQyhtLT5zdGF0dXMp OwogCXU4IHhlYyA9IFhFQyhtLT5zdGF0dXMsIHhlY19tYXNrKTsKIAotCXByX2VtZXJnKEhXX0VS UiAiTUMyIEVycm9yOiAiKTsKKwlzZXFfYnVmX3ByaW50Zigmc2IsIEhXX0VSUiAiTUMyIEVycm9y OiAiKTsKIAogCWlmICghZmFtX29wcy0+bWMyX21jZShlYywgeGVjKSkKLQkJcHJfY29udChIV19F UlIgIkNvcnJ1cHRlZCBNQzIgTUNFIGluZm8/XG4iKTsKKwkJcHJfZW1lcmcoSFdfRVJSICJDb3Jy dXB0ZWQgTUMyIE1DRSBpbmZvP1xuIik7CiB9CiAKIHN0YXRpYyB2b2lkIGRlY29kZV9tYzNfbWNl KHN0cnVjdCBtY2UgKm0pCkBAIC03MjYsNyArNzM4LDcgQEAgc3RhdGljIHZvaWQgZGVjb2RlX21j M19tY2Uoc3RydWN0IG1jZSAqbSkKIAkJcmV0dXJuOwogCX0KIAotCXByX2VtZXJnKEhXX0VSUiAi TUMzIEVycm9yIik7CisJc2VxX2J1Zl9wcmludGYoJnNiLCBIV19FUlIgIk1DMyBFcnJvciIpOwog CiAJaWYgKHhlYyA9PSAweDApIHsKIAkJdTggcjQgPSBSNChlYyk7CkBAIC03MzQsNyArNzQ2LDcg QEAgc3RhdGljIHZvaWQgZGVjb2RlX21jM19tY2Uoc3RydWN0IG1jZSAqbSkKIAkJaWYgKCFCVVNf RVJST1IoZWMpIHx8IChyNCAhPSBSNF9EUkQgJiYgcjQgIT0gUjRfRFdSKSkKIAkJCWdvdG8gd3Jv bmdfbWMzX21jZTsKIAotCQlwcl9jb250KCIgZHVyaW5nICVzLlxuIiwgUjRfTVNHKGVjKSk7CisJ CXNlcV9idWZfcHJpbnRmKCZzYiwgIiBkdXJpbmcgJXMuXG4iLCBSNF9NU0coZWMpKTsKIAl9IGVs c2UKIAkJZ290byB3cm9uZ19tYzNfbWNlOwogCkBAIC03NTIsNyArNzY0LDcgQEAgc3RhdGljIHZv aWQgZGVjb2RlX21jNF9tY2Uoc3RydWN0IG1jZSAqbSkKIAl1OCB4ZWMgPSBYRUMobS0+c3RhdHVz LCAweDFmKTsKIAl1OCBvZmZzZXQgPSAwOwogCi0JcHJfZW1lcmcoSFdfRVJSICJNQzQgRXJyb3Ig KG5vZGUgJWQpOiAiLCBub2RlX2lkKTsKKwlzZXFfYnVmX3ByaW50Zigmc2IsIEhXX0VSUiAiTUM0 IEVycm9yIChub2RlICVkKTogIiwgbm9kZV9pZCk7CiAKIAlzd2l0Y2ggKHhlYykgewogCWNhc2Ug MHgwIC4uLiAweGU6CkBAIC03NjMsNyArNzc1LDcgQEAgc3RhdGljIHZvaWQgZGVjb2RlX21jNF9t Y2Uoc3RydWN0IG1jZSAqbSkKIAkJCWlmIChmYW0gPT0gMHgxMSkKIAkJCQlnb3RvIHdyb25nX21j NF9tY2U7CiAKLQkJCXByX2NvbnQoIiVzLlxuIiwgbWM0X21jZV9kZXNjW3hlY10pOworCQkJc2Vx X2J1Zl9wcmludGYoJnNiLCAiJXMuXG4iLCBtYzRfbWNlX2Rlc2NbeGVjXSk7CiAKIAkJCWlmIChk ZWNvZGVfZHJhbV9lY2MpCiAJCQkJZGVjb2RlX2RyYW1fZWNjKG5vZGVfaWQsIG0pOwpAQCAtNzcz LDE2ICs3ODUsMTYgQEAgc3RhdGljIHZvaWQgZGVjb2RlX21jNF9tY2Uoc3RydWN0IG1jZSAqbSkK IAogCWNhc2UgMHhmOgogCQlpZiAoVExCX0VSUk9SKGVjKSkKLQkJCXByX2NvbnQoIkdBUlQgVGFi bGUgV2FsayBkYXRhIGVycm9yLlxuIik7CisJCQlzZXFfYnVmX3ByaW50Zigmc2IsICJHQVJUIFRh YmxlIFdhbGsgZGF0YSBlcnJvci5cbiIpOwogCQllbHNlIGlmIChCVVNfRVJST1IoZWMpKQotCQkJ cHJfY29udCgiRE1BIEV4Y2x1c2lvbiBWZWN0b3IgVGFibGUgV2FsayBlcnJvci5cbiIpOworCQkJ c2VxX2J1Zl9wcmludGYoJnNiLCAiRE1BIEV4Y2x1c2lvbiBWZWN0b3IgVGFibGUgV2FsayBlcnJv ci5cbiIpOwogCQllbHNlCiAJCQlnb3RvIHdyb25nX21jNF9tY2U7CiAJCXJldHVybjsKIAogCWNh c2UgMHgxOToKIAkJaWYgKGZhbSA9PSAweDE1IHx8IGZhbSA9PSAweDE2KQotCQkJcHJfY29udCgi Q29tcHV0ZSBVbml0IERhdGEgRXJyb3IuXG4iKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgIkNv bXB1dGUgVW5pdCBEYXRhIEVycm9yLlxuIik7CiAJCWVsc2UKIAkJCWdvdG8gd3JvbmdfbWM0X21j ZTsKIAkJcmV0dXJuOwpAQCAtNzk1LDcgKzgwNyw3IEBAIHN0YXRpYyB2b2lkIGRlY29kZV9tYzRf bWNlKHN0cnVjdCBtY2UgKm0pCiAJCWdvdG8gd3JvbmdfbWM0X21jZTsKIAl9CiAKLQlwcl9jb250 KCIlcy5cbiIsIG1jNF9tY2VfZGVzY1t4ZWMgLSBvZmZzZXRdKTsKKwlzZXFfYnVmX3ByaW50Zigm c2IsICIlcy5cbiIsIG1jNF9tY2VfZGVzY1t4ZWMgLSBvZmZzZXRdKTsKIAlyZXR1cm47CiAKICB3 cm9uZ19tYzRfbWNlOgpAQCAtODExLDIwICs4MjMsMjAgQEAgc3RhdGljIHZvaWQgZGVjb2RlX21j NV9tY2Uoc3RydWN0IG1jZSAqbSkKIAlpZiAoZmFtID09IDB4ZiB8fCBmYW0gPT0gMHgxMSkKIAkJ Z290byB3cm9uZ19tYzVfbWNlOwogCi0JcHJfZW1lcmcoSFdfRVJSICJNQzUgRXJyb3I6ICIpOwor CXNlcV9idWZfcHJpbnRmKCZzYiwgSFdfRVJSICJNQzUgRXJyb3I6ICIpOwogCiAJaWYgKElOVF9F UlJPUihlYykpIHsKIAkJaWYgKHhlYyA8PSAweDFmKSB7Ci0JCQlwcl9jb250KCJIYXJkd2FyZSBB c3NlcnQuXG4iKTsKKwkJCXNlcV9idWZfcHJpbnRmKCZzYiwgIkhhcmR3YXJlIEFzc2VydC5cbiIp OwogCQkJcmV0dXJuOwogCQl9IGVsc2UKIAkJCWdvdG8gd3JvbmdfbWM1X21jZTsKIAl9CiAKIAlp ZiAoeGVjID09IDB4MCB8fCB4ZWMgPT0gMHhjKQotCQlwcl9jb250KCIlcy5cbiIsIG1jNV9tY2Vf ZGVzY1t4ZWNdKTsKKwkJc2VxX2J1Zl9wcmludGYoJnNiLCAiJXMuXG4iLCBtYzVfbWNlX2Rlc2Nb eGVjXSk7CiAJZWxzZSBpZiAoeGVjIDw9IDB4ZCkKLQkJcHJfY29udCgiJXMgcGFyaXR5IGVycm9y LlxuIiwgbWM1X21jZV9kZXNjW3hlY10pOworCQlzZXFfYnVmX3ByaW50Zigmc2IsICIlcyBwYXJp dHkgZXJyb3IuXG4iLCBtYzVfbWNlX2Rlc2NbeGVjXSk7CiAJZWxzZQogCQlnb3RvIHdyb25nX21j NV9tY2U7CiAKQEAgLTgzOCwxMiArODUwLDEyIEBAIHN0YXRpYyB2b2lkIGRlY29kZV9tYzZfbWNl KHN0cnVjdCBtY2UgKm0pCiB7CiAJdTggeGVjID0gWEVDKG0tPnN0YXR1cywgeGVjX21hc2spOwog Ci0JcHJfZW1lcmcoSFdfRVJSICJNQzYgRXJyb3I6ICIpOworCXNlcV9idWZfcHJpbnRmKCZzYiwg SFdfRVJSICJNQzYgRXJyb3I6ICIpOwogCiAJaWYgKHhlYyA+IDB4NSkKIAkJZ290byB3cm9uZ19t YzZfbWNlOwogCi0JcHJfY29udCgiJXMgcGFyaXR5IGVycm9yLlxuIiwgbWM2X21jZV9kZXNjW3hl Y10pOworCXNlcV9idWZfcHJpbnRmKCZzYiwgIiVzIHBhcml0eSBlcnJvci5cbiIsIG1jNl9tY2Vf ZGVzY1t4ZWNdKTsKIAlyZXR1cm47CiAKICB3cm9uZ19tYzZfbWNlOgpAQCAtODcxLDEzICs4ODMs MTMgQEAgc3RhdGljIHZvaWQgZGVjb2RlX3NtY2FfZXJyb3Ioc3RydWN0IG1jZSAqbSkKIAliYW5r X3R5cGUgPSBod2lkLT5iYW5rX3R5cGU7CiAJaXBfbmFtZSA9IHNtY2FfZ2V0X2xvbmdfbmFtZShi YW5rX3R5cGUpOwogCi0JcHJfZW1lcmcoSFdfRVJSICIlcyBFeHRlbmRlZCBFcnJvciBDb2RlOiAl ZFxuIiwgaXBfbmFtZSwgeGVjKTsKKwlzZXFfYnVmX3ByaW50Zigmc2IsIEhXX0VSUiAiJXMgRXh0 ZW5kZWQgRXJyb3IgQ29kZTogJWRcbiIsIGlwX25hbWUsIHhlYyk7CiAKIAkvKiBPbmx5IHByaW50 IHRoZSBkZWNvZGUgb2YgdmFsaWQgZXJyb3IgY29kZXMgKi8KIAlpZiAoeGVjIDwgc21jYV9tY2Vf ZGVzY3NbYmFua190eXBlXS5udW1fZGVzY3MgJiYKIAkJCShod2lkLT54ZWNfYml0bWFwICYgQklU X1VMTCh4ZWMpKSkgewotCQlwcl9lbWVyZyhIV19FUlIgIiVzIEVycm9yOiAiLCBpcF9uYW1lKTsK LQkJcHJfY29udCgiJXMuXG4iLCBzbWNhX21jZV9kZXNjc1tiYW5rX3R5cGVdLmRlc2NzW3hlY10p OworCQlzZXFfYnVmX3ByaW50Zigmc2IsIEhXX0VSUiAiJXMgRXJyb3I6ICIsIGlwX25hbWUpOwor CQlzZXFfYnVmX3ByaW50Zigmc2IsICIlcy5cbiIsIHNtY2FfbWNlX2Rlc2NzW2JhbmtfdHlwZV0u ZGVzY3NbeGVjXSk7CiAJfQogCiAJaWYgKGJhbmtfdHlwZSA9PSBTTUNBX1VNQyAmJiB4ZWMgPT0g MCAmJiBkZWNvZGVfZHJhbV9lY2MpCkBAIC05NDQsMTAgKzk1NiwyMSBAQCBhbWRfZGVjb2RlX21j ZShzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iLCB1bnNpZ25lZCBsb25nIHZhbCwgdm9pZCAqZGF0 YSkKIAlzdHJ1Y3QgbWNlICptID0gKHN0cnVjdCBtY2UgKilkYXRhOwogCXVuc2lnbmVkIGludCBm YW0gPSB4ODZfZmFtaWx5KG0tPmNwdWlkKTsKIAlpbnQgZWNjOworCWNoYXIgKmRlY19idWY7CiAK IAlpZiAoYW1kX2ZpbHRlcl9tY2UobSkpCiAJCXJldHVybiBOT1RJRllfU1RPUDsKIAorCWRlY19i dWYgPSAodm9pZCAqKWdlbl9wb29sX2FsbG9jKGRlY19wb29sLCBFTEVNX1NJWkUpOworCWlmICgh ZGVjX2J1ZikgeworCQlwcl93YXJuKCJEZWNvZGUgYnVmZmVyIGZ1bGwhXG4iKTsKKwkJcmV0dXJu IE5PVElGWV9TVE9QOworCX0KKworCS8qIFwwIHRlcm1pbmF0ZWQgKi8KKwlzZXFfYnVmX2luaXQo JnNiLCBkZWNfYnVmLCBFTEVNX1NJWkUpOworCXNlcV9idWZfY2xlYXJfYnVmKCZzYik7CisKIAlw cl9lbWVyZyhIV19FUlIgIiVzXG4iLCBkZWNvZGVfZXJyb3Jfc3RhdHVzKG0pKTsKIAogCXByX2Vt ZXJnKEhXX0VSUiAiQ1BVOiVkICgleDoleDoleCkgTUMlZF9TVEFUVVNbJXN8JXN8JXN8JXN8JXMi LApAQCAtMTA0NCw2ICsxMDY3LDEwIEBAIGFtZF9kZWNvZGVfbWNlKHN0cnVjdCBub3RpZmllcl9i bG9jayAqbmIsIHVuc2lnbmVkIGxvbmcgdmFsLCB2b2lkICpkYXRhKQogIGVycl9jb2RlOgogCWFt ZF9kZWNvZGVfZXJyX2NvZGUobS0+c3RhdHVzICYgMHhmZmZmKTsKIAorCXByX2VtZXJnKCIlLipz XG4iLCAoaW50KXNiLmxlbiwgc2IuYnVmZmVyKTsKKworCWdlbl9wb29sX2ZyZWUoZGVjX3Bvb2ws ICh1bnNpZ25lZCBsb25nKWRlY19idWYsIEVMRU1fU0laRSk7CisKIAlyZXR1cm4gTk9USUZZX1NU T1A7CiB9CiAKQEAgLTEwNTUsNiArMTA4Miw3IEBAIHN0YXRpYyBzdHJ1Y3Qgbm90aWZpZXJfYmxv Y2sgYW1kX21jZV9kZWNfbmIgPSB7CiBzdGF0aWMgaW50IF9faW5pdCBtY2VfYW1kX2luaXQodm9p ZCkKIHsKIAlzdHJ1Y3QgY3B1aW5mb194ODYgKmMgPSAmYm9vdF9jcHVfZGF0YTsKKwlpbnQgcmV0 OwogCiAJaWYgKGMtPng4Nl92ZW5kb3IgIT0gWDg2X1ZFTkRPUl9BTUQpCiAJCXJldHVybiAtRU5P REVWOwpAQCAtMTEyMiw2ICsxMTUwLDE2IEBAIHN0YXRpYyBpbnQgX19pbml0IG1jZV9hbWRfaW5p dCh2b2lkKQogCQlnb3RvIGVycl9vdXQ7CiAJfQogCisJZGVjX3Bvb2wgPSBnZW5fcG9vbF9jcmVh dGUoRUxFTV9PUkRFUiwgLTEpOworCWlmICghZGVjX3Bvb2wpCisJCWdvdG8gZXJyX291dDsKKwor CXJldCA9IGdlbl9wb29sX2FkZChkZWNfcG9vbCwgKHVuc2lnbmVkIGxvbmcpX19lcnJfYnVmLCBE RUNfUE9PTF9TSVpFLCAtMSk7CisJaWYgKHJldCkgeworCQlnZW5fcG9vbF9kZXN0cm95KGRlY19w b29sKTsKKwkJZ290byBlcnJfb3V0OworCX0KKwogCXByX2luZm8oIk1DRTogSW4ta2VybmVsIE1D RSBkZWNvZGluZyBlbmFibGVkLlxuIik7CiAKIAltY2VfcmVnaXN0ZXJfZGVjb2RlX2NoYWluKCZh bWRfbWNlX2RlY19uYik7CkBAIC0xMTQwLDYgKzExNzgsNyBAQCBzdGF0aWMgdm9pZCBfX2V4aXQg bWNlX2FtZF9leGl0KHZvaWQpCiB7CiAJbWNlX3VucmVnaXN0ZXJfZGVjb2RlX2NoYWluKCZhbWRf bWNlX2RlY19uYik7CiAJa2ZyZWUoZmFtX29wcyk7CisJZ2VuX3Bvb2xfZGVzdHJveShkZWNfcG9v bCk7CiB9CiAKIE1PRFVMRV9ERVNDUklQVElPTigiQU1EIE1DRSBkZWNvZGVyIik7Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755513AbdHYKYz (ORCPT ); Fri, 25 Aug 2017 06:24:55 -0400 Received: from mail.skyhub.de ([5.9.137.197]:55644 "EHLO mail.skyhub.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754960AbdHYKYZ (ORCPT ); Fri, 25 Aug 2017 06:24:25 -0400 From: Borislav Petkov To: linux-edac Cc: Steven Rostedt , Tony Luck , Yazen Ghannam , X86 ML , LKML Subject: [PATCH 5/7] EDAC, mce_amd: Convert to seq_buf Date: Fri, 25 Aug 2017 12:24:09 +0200 Message-Id: <20170825102411.8682-6-bp@alien8.de> X-Mailer: git-send-email 2.13.0 In-Reply-To: <20170825102411.8682-1-bp@alien8.de> References: <20170825102411.8682-1-bp@alien8.de> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Borislav Petkov Convert the part which decodes the error description to the sequence buffer facility and thus save ourselves the many printk() invocations building the decoded string. Also, use a genpool for the string buffers to handle concurrent invocations (and atomic context). Signed-off-by: Borislav Petkov --- drivers/edac/mce_amd.c | 215 +++++++++++++++++++++++++++++-------------------- 1 file changed, 127 insertions(+), 88 deletions(-) diff --git a/drivers/edac/mce_amd.c b/drivers/edac/mce_amd.c index a11a671c7a38..b7c1f8f7e871 100644 --- a/drivers/edac/mce_amd.c +++ b/drivers/edac/mce_amd.c @@ -1,3 +1,5 @@ +#include +#include #include #include @@ -34,6 +36,16 @@ void amd_unregister_ecc_decoder(void (*f)(int, struct mce *)) } EXPORT_SYMBOL_GPL(amd_unregister_ecc_decoder); +/* 128 because, well, nice and round - two cachelines. */ +#define ELEM_ORDER 7 +#define ELEM_SIZE (1 << 7) +#define DEC_POOL_SIZE (2 * PAGE_SIZE) + +static char __err_buf[DEC_POOL_SIZE]; +static struct gen_pool *dec_pool; + +static struct seq_buf sb; + /* * string representation for the different MCA reported error types, see F3x48 * or MSR0000_0411. @@ -315,9 +327,9 @@ static bool f12h_mc0_mce(u16 ec, u8 xec) ret = true; if (ll == LL_L2) - pr_cont("during L1 linefill from L2.\n"); + seq_buf_printf(&sb, "during L1 linefill from L2.\n"); else if (ll == LL_L1) - pr_cont("Data/Tag %s error.\n", R4_MSG(ec)); + seq_buf_printf(&sb, "Data/Tag %s error.\n", R4_MSG(ec)); else ret = false; } @@ -327,7 +339,7 @@ static bool f12h_mc0_mce(u16 ec, u8 xec) static bool f10h_mc0_mce(u16 ec, u8 xec) { if (R4(ec) == R4_GEN && LL(ec) == LL_L1) { - pr_cont("during data scrub.\n"); + seq_buf_printf(&sb, "during data scrub.\n"); return true; } return f12h_mc0_mce(ec, xec); @@ -336,7 +348,7 @@ static bool f10h_mc0_mce(u16 ec, u8 xec) static bool k8_mc0_mce(u16 ec, u8 xec) { if (BUS_ERROR(ec)) { - pr_cont("during system linefill.\n"); + seq_buf_printf(&sb, "during system linefill.\n"); return true; } @@ -356,14 +368,14 @@ static bool cat_mc0_mce(u16 ec, u8 xec) switch (r4) { case R4_DRD: case R4_DWR: - pr_cont("Data/Tag parity error due to %s.\n", - (r4 == R4_DRD ? "load/hw prf" : "store")); + seq_buf_printf(&sb, "Data/Tag parity error due to %s.\n", + (r4 == R4_DRD ? "load/hw prf" : "store")); break; case R4_EVICT: - pr_cont("Copyback parity error on a tag miss.\n"); + seq_buf_printf(&sb, "Copyback parity error on a tag miss.\n"); break; case R4_SNOOP: - pr_cont("Tag parity error during snoop.\n"); + seq_buf_printf(&sb, "Tag parity error during snoop.\n"); break; default: ret = false; @@ -373,17 +385,17 @@ static bool cat_mc0_mce(u16 ec, u8 xec) if ((II(ec) != II_MEM && II(ec) != II_IO) || LL(ec) != LL_LG) return false; - pr_cont("System read data error on a "); + seq_buf_printf(&sb, "System read data error on a "); switch (r4) { case R4_RD: - pr_cont("TLB reload.\n"); + seq_buf_printf(&sb, "TLB reload.\n"); break; case R4_DWR: - pr_cont("store.\n"); + seq_buf_printf(&sb, "store.\n"); break; case R4_DRD: - pr_cont("load.\n"); + seq_buf_printf(&sb, "load.\n"); break; default: ret = false; @@ -403,28 +415,28 @@ static bool f15h_mc0_mce(u16 ec, u8 xec) switch (xec) { case 0x0: - pr_cont("Data Array access error.\n"); + seq_buf_printf(&sb, "Data Array access error.\n"); break; case 0x1: - pr_cont("UC error during a linefill from L2/NB.\n"); + seq_buf_printf(&sb, "UC error during a linefill from L2/NB.\n"); break; case 0x2: case 0x11: - pr_cont("STQ access error.\n"); + seq_buf_printf(&sb, "STQ access error.\n"); break; case 0x3: - pr_cont("SCB access error.\n"); + seq_buf_printf(&sb, "SCB access error.\n"); break; case 0x10: - pr_cont("Tag error.\n"); + seq_buf_printf(&sb, "Tag error.\n"); break; case 0x12: - pr_cont("LDQ access error.\n"); + seq_buf_printf(&sb, "LDQ access error.\n"); break; default: @@ -433,12 +445,12 @@ static bool f15h_mc0_mce(u16 ec, u8 xec) } else if (BUS_ERROR(ec)) { if (!xec) - pr_cont("System Read Data Error.\n"); + seq_buf_printf(&sb, "System Read Data Error.\n"); else - pr_cont(" Internal error condition type %d.\n", xec); + seq_buf_printf(&sb, " Internal error condition type %d.\n", xec); } else if (INT_ERROR(ec)) { if (xec <= 0x1f) - pr_cont("Hardware Assert.\n"); + seq_buf_printf(&sb, "Hardware Assert.\n"); else ret = false; @@ -453,13 +465,13 @@ static void decode_mc0_mce(struct mce *m) u16 ec = EC(m->status); u8 xec = XEC(m->status, xec_mask); - pr_emerg(HW_ERR "MC0 Error: "); + seq_buf_printf(&sb, HW_ERR "MC0 Error: "); /* TLB error signatures are the same across families */ if (TLB_ERROR(ec)) { if (TT(ec) == TT_DATA) { - pr_cont("%s TLB %s.\n", LL_MSG(ec), - ((xec == 2) ? "locked miss" + seq_buf_printf(&sb, "%s TLB %s.\n", LL_MSG(ec), + ((xec == 2) ? "locked miss" : (xec ? "multimatch" : "parity"))); return; } @@ -478,19 +490,19 @@ static bool k8_mc1_mce(u16 ec, u8 xec) return false; if (ll == 0x2) - pr_cont("during a linefill from L2.\n"); + seq_buf_printf(&sb, "during a linefill from L2.\n"); else if (ll == 0x1) { switch (R4(ec)) { case R4_IRD: - pr_cont("Parity error during data load.\n"); + seq_buf_printf(&sb, "Parity error during data load.\n"); break; case R4_EVICT: - pr_cont("Copyback Parity/Victim error.\n"); + seq_buf_printf(&sb, "Copyback Parity/Victim error.\n"); break; case R4_SNOOP: - pr_cont("Tag Snoop error.\n"); + seq_buf_printf(&sb, "Tag Snoop error.\n"); break; default: @@ -515,13 +527,13 @@ static bool cat_mc1_mce(u16 ec, u8 xec) return false; if (r4 == R4_IRD) - pr_cont("Data/tag array parity error for a tag hit.\n"); + seq_buf_printf(&sb, "Data/tag array parity error for a tag hit.\n"); else if (r4 == R4_SNOOP) - pr_cont("Tag error during snoop/victimization.\n"); + seq_buf_printf(&sb, "Tag error during snoop/victimization.\n"); else if (xec == 0x0) - pr_cont("Tag parity error from victim castout.\n"); + seq_buf_printf(&sb, "Tag parity error from victim castout.\n"); else if (xec == 0x2) - pr_cont("Microcode patch RAM parity error.\n"); + seq_buf_printf(&sb, "Microcode patch RAM parity error.\n"); else ret = false; @@ -537,19 +549,19 @@ static bool f15h_mc1_mce(u16 ec, u8 xec) switch (xec) { case 0x0 ... 0xa: - pr_cont("%s.\n", f15h_mc1_mce_desc[xec]); + seq_buf_printf(&sb, "%s.\n", f15h_mc1_mce_desc[xec]); break; case 0xd: - pr_cont("%s.\n", f15h_mc1_mce_desc[xec-2]); + seq_buf_printf(&sb, "%s.\n", f15h_mc1_mce_desc[xec-2]); break; case 0x10: - pr_cont("%s.\n", f15h_mc1_mce_desc[xec-4]); + seq_buf_printf(&sb, "%s.\n", f15h_mc1_mce_desc[xec-4]); break; case 0x11 ... 0x15: - pr_cont("Decoder %s parity error.\n", f15h_mc1_mce_desc[xec-4]); + seq_buf_printf(&sb, "Decoder %s parity error.\n", f15h_mc1_mce_desc[xec-4]); break; default: @@ -563,18 +575,18 @@ static void decode_mc1_mce(struct mce *m) u16 ec = EC(m->status); u8 xec = XEC(m->status, xec_mask); - pr_emerg(HW_ERR "MC1 Error: "); + seq_buf_printf(&sb, HW_ERR "MC1 Error: "); if (TLB_ERROR(ec)) - pr_cont("%s TLB %s.\n", LL_MSG(ec), - (xec ? "multimatch" : "parity error")); + seq_buf_printf(&sb, "%s TLB %s.\n", LL_MSG(ec), + (xec ? "multimatch" : "parity error")); else if (BUS_ERROR(ec)) { bool k8 = (boot_cpu_data.x86 == 0xf && (m->status & BIT_64(58))); - pr_cont("during %s.\n", (k8 ? "system linefill" : "NB data read")); + seq_buf_printf(&sb, "during %s.\n", (k8 ? "system linefill" : "NB data read")); } else if (INT_ERROR(ec)) { if (xec <= 0x3f) - pr_cont("Hardware Assert.\n"); + seq_buf_printf(&sb, "Hardware Assert.\n"); else goto wrong_mc1_mce; } else if (fam_ops->mc1_mce(ec, xec)) @@ -593,27 +605,27 @@ static bool k8_mc2_mce(u16 ec, u8 xec) bool ret = true; if (xec == 0x1) - pr_cont(" in the write data buffers.\n"); + seq_buf_printf(&sb, " in the write data buffers.\n"); else if (xec == 0x3) - pr_cont(" in the victim data buffers.\n"); + seq_buf_printf(&sb, " in the victim data buffers.\n"); else if (xec == 0x2 && MEM_ERROR(ec)) - pr_cont(": %s error in the L2 cache tags.\n", R4_MSG(ec)); + seq_buf_printf(&sb, ": %s error in the L2 cache tags.\n", R4_MSG(ec)); else if (xec == 0x0) { if (TLB_ERROR(ec)) - pr_cont("%s error in a Page Descriptor Cache or Guest TLB.\n", - TT_MSG(ec)); + seq_buf_printf(&sb, "%s error in a Page Descriptor Cache or Guest TLB.\n", + TT_MSG(ec)); else if (BUS_ERROR(ec)) - pr_cont(": %s/ECC error in data read from NB: %s.\n", - R4_MSG(ec), PP_MSG(ec)); + seq_buf_printf(&sb, ": %s/ECC error in data read from NB: %s.\n", + R4_MSG(ec), PP_MSG(ec)); else if (MEM_ERROR(ec)) { u8 r4 = R4(ec); if (r4 >= 0x7) - pr_cont(": %s error during data copyback.\n", - R4_MSG(ec)); + seq_buf_printf(&sb, ": %s error during data copyback.\n", + R4_MSG(ec)); else if (r4 <= 0x1) - pr_cont(": %s parity/ECC error during data " - "access from L2.\n", R4_MSG(ec)); + seq_buf_printf(&sb, +": %s parity/ECC error during data access from L2.\n", R4_MSG(ec)); else ret = false; } else @@ -630,24 +642,24 @@ static bool f15h_mc2_mce(u16 ec, u8 xec) if (TLB_ERROR(ec)) { if (xec == 0x0) - pr_cont("Data parity TLB read error.\n"); + seq_buf_printf(&sb, "Data parity TLB read error.\n"); else if (xec == 0x1) - pr_cont("Poison data provided for TLB fill.\n"); + seq_buf_printf(&sb, "Poison data provided for TLB fill.\n"); else ret = false; } else if (BUS_ERROR(ec)) { if (xec > 2) ret = false; - pr_cont("Error during attempted NB data read.\n"); + seq_buf_printf(&sb, "Error during attempted NB data read.\n"); } else if (MEM_ERROR(ec)) { switch (xec) { case 0x4 ... 0xc: - pr_cont("%s.\n", f15h_mc2_mce_desc[xec - 0x4]); + seq_buf_printf(&sb, "%s.\n", f15h_mc2_mce_desc[xec - 0x4]); break; case 0x10 ... 0x14: - pr_cont("%s.\n", f15h_mc2_mce_desc[xec - 0x7]); + seq_buf_printf(&sb, "%s.\n", f15h_mc2_mce_desc[xec - 0x7]); break; default: @@ -655,7 +667,7 @@ static bool f15h_mc2_mce(u16 ec, u8 xec) } } else if (INT_ERROR(ec)) { if (xec <= 0x3f) - pr_cont("Hardware Assert.\n"); + seq_buf_printf(&sb, "Hardware Assert.\n"); else ret = false; } @@ -672,29 +684,29 @@ static bool f16h_mc2_mce(u16 ec, u8 xec) switch (xec) { case 0x04 ... 0x05: - pr_cont("%cBUFF parity error.\n", (r4 == R4_RD) ? 'I' : 'O'); + seq_buf_printf(&sb, "%cBUFF parity error.\n", (r4 == R4_RD) ? 'I' : 'O'); break; case 0x09 ... 0x0b: case 0x0d ... 0x0f: - pr_cont("ECC error in L2 tag (%s).\n", - ((r4 == R4_GEN) ? "BankReq" : - ((r4 == R4_SNOOP) ? "Prb" : "Fill"))); + seq_buf_printf(&sb, "ECC error in L2 tag (%s).\n", + ((r4 == R4_GEN) ? "BankReq" : + ((r4 == R4_SNOOP) ? "Prb" : "Fill"))); break; case 0x10 ... 0x19: case 0x1b: - pr_cont("ECC error in L2 data array (%s).\n", - (((r4 == R4_RD) && !(xec & 0x3)) ? "Hit" : - ((r4 == R4_GEN) ? "Attr" : - ((r4 == R4_EVICT) ? "Vict" : "Fill")))); + seq_buf_printf(&sb, "ECC error in L2 data array (%s).\n", + (((r4 == R4_RD) && !(xec & 0x3)) ? "Hit" : + ((r4 == R4_GEN) ? "Attr" : + ((r4 == R4_EVICT) ? "Vict" : "Fill")))); break; case 0x1c ... 0x1d: case 0x1f: - pr_cont("Parity error in L2 attribute bits (%s).\n", - ((r4 == R4_RD) ? "Hit" : - ((r4 == R4_GEN) ? "Attr" : "Fill"))); + seq_buf_printf(&sb, "Parity error in L2 attribute bits (%s).\n", + ((r4 == R4_RD) ? "Hit" : + ((r4 == R4_GEN) ? "Attr" : "Fill"))); break; default: @@ -709,10 +721,10 @@ static void decode_mc2_mce(struct mce *m) u16 ec = EC(m->status); u8 xec = XEC(m->status, xec_mask); - pr_emerg(HW_ERR "MC2 Error: "); + seq_buf_printf(&sb, HW_ERR "MC2 Error: "); if (!fam_ops->mc2_mce(ec, xec)) - pr_cont(HW_ERR "Corrupted MC2 MCE info?\n"); + pr_emerg(HW_ERR "Corrupted MC2 MCE info?\n"); } static void decode_mc3_mce(struct mce *m) @@ -726,7 +738,7 @@ static void decode_mc3_mce(struct mce *m) return; } - pr_emerg(HW_ERR "MC3 Error"); + seq_buf_printf(&sb, HW_ERR "MC3 Error"); if (xec == 0x0) { u8 r4 = R4(ec); @@ -734,7 +746,7 @@ static void decode_mc3_mce(struct mce *m) if (!BUS_ERROR(ec) || (r4 != R4_DRD && r4 != R4_DWR)) goto wrong_mc3_mce; - pr_cont(" during %s.\n", R4_MSG(ec)); + seq_buf_printf(&sb, " during %s.\n", R4_MSG(ec)); } else goto wrong_mc3_mce; @@ -752,7 +764,7 @@ static void decode_mc4_mce(struct mce *m) u8 xec = XEC(m->status, 0x1f); u8 offset = 0; - pr_emerg(HW_ERR "MC4 Error (node %d): ", node_id); + seq_buf_printf(&sb, HW_ERR "MC4 Error (node %d): ", node_id); switch (xec) { case 0x0 ... 0xe: @@ -763,7 +775,7 @@ static void decode_mc4_mce(struct mce *m) if (fam == 0x11) goto wrong_mc4_mce; - pr_cont("%s.\n", mc4_mce_desc[xec]); + seq_buf_printf(&sb, "%s.\n", mc4_mce_desc[xec]); if (decode_dram_ecc) decode_dram_ecc(node_id, m); @@ -773,16 +785,16 @@ static void decode_mc4_mce(struct mce *m) case 0xf: if (TLB_ERROR(ec)) - pr_cont("GART Table Walk data error.\n"); + seq_buf_printf(&sb, "GART Table Walk data error.\n"); else if (BUS_ERROR(ec)) - pr_cont("DMA Exclusion Vector Table Walk error.\n"); + seq_buf_printf(&sb, "DMA Exclusion Vector Table Walk error.\n"); else goto wrong_mc4_mce; return; case 0x19: if (fam == 0x15 || fam == 0x16) - pr_cont("Compute Unit Data Error.\n"); + seq_buf_printf(&sb, "Compute Unit Data Error.\n"); else goto wrong_mc4_mce; return; @@ -795,7 +807,7 @@ static void decode_mc4_mce(struct mce *m) goto wrong_mc4_mce; } - pr_cont("%s.\n", mc4_mce_desc[xec - offset]); + seq_buf_printf(&sb, "%s.\n", mc4_mce_desc[xec - offset]); return; wrong_mc4_mce: @@ -811,20 +823,20 @@ static void decode_mc5_mce(struct mce *m) if (fam == 0xf || fam == 0x11) goto wrong_mc5_mce; - pr_emerg(HW_ERR "MC5 Error: "); + seq_buf_printf(&sb, HW_ERR "MC5 Error: "); if (INT_ERROR(ec)) { if (xec <= 0x1f) { - pr_cont("Hardware Assert.\n"); + seq_buf_printf(&sb, "Hardware Assert.\n"); return; } else goto wrong_mc5_mce; } if (xec == 0x0 || xec == 0xc) - pr_cont("%s.\n", mc5_mce_desc[xec]); + seq_buf_printf(&sb, "%s.\n", mc5_mce_desc[xec]); else if (xec <= 0xd) - pr_cont("%s parity error.\n", mc5_mce_desc[xec]); + seq_buf_printf(&sb, "%s parity error.\n", mc5_mce_desc[xec]); else goto wrong_mc5_mce; @@ -838,12 +850,12 @@ static void decode_mc6_mce(struct mce *m) { u8 xec = XEC(m->status, xec_mask); - pr_emerg(HW_ERR "MC6 Error: "); + seq_buf_printf(&sb, HW_ERR "MC6 Error: "); if (xec > 0x5) goto wrong_mc6_mce; - pr_cont("%s parity error.\n", mc6_mce_desc[xec]); + seq_buf_printf(&sb, "%s parity error.\n", mc6_mce_desc[xec]); return; wrong_mc6_mce: @@ -871,13 +883,13 @@ static void decode_smca_error(struct mce *m) bank_type = hwid->bank_type; ip_name = smca_get_long_name(bank_type); - pr_emerg(HW_ERR "%s Extended Error Code: %d\n", ip_name, xec); + seq_buf_printf(&sb, HW_ERR "%s Extended Error Code: %d\n", ip_name, xec); /* Only print the decode of valid error codes */ if (xec < smca_mce_descs[bank_type].num_descs && (hwid->xec_bitmap & BIT_ULL(xec))) { - pr_emerg(HW_ERR "%s Error: ", ip_name); - pr_cont("%s.\n", smca_mce_descs[bank_type].descs[xec]); + seq_buf_printf(&sb, HW_ERR "%s Error: ", ip_name); + seq_buf_printf(&sb, "%s.\n", smca_mce_descs[bank_type].descs[xec]); } if (bank_type == SMCA_UMC && xec == 0 && decode_dram_ecc) @@ -944,10 +956,21 @@ amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data) struct mce *m = (struct mce *)data; unsigned int fam = x86_family(m->cpuid); int ecc; + char *dec_buf; if (amd_filter_mce(m)) return NOTIFY_STOP; + dec_buf = (void *)gen_pool_alloc(dec_pool, ELEM_SIZE); + if (!dec_buf) { + pr_warn("Decode buffer full!\n"); + return NOTIFY_STOP; + } + + /* \0 terminated */ + seq_buf_init(&sb, dec_buf, ELEM_SIZE); + seq_buf_clear_buf(&sb); + pr_emerg(HW_ERR "%s\n", decode_error_status(m)); pr_emerg(HW_ERR "CPU:%d (%x:%x:%x) MC%d_STATUS[%s|%s|%s|%s|%s", @@ -1044,6 +1067,10 @@ amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data) err_code: amd_decode_err_code(m->status & 0xffff); + pr_emerg("%.*s\n", (int)sb.len, sb.buffer); + + gen_pool_free(dec_pool, (unsigned long)dec_buf, ELEM_SIZE); + return NOTIFY_STOP; } @@ -1055,6 +1082,7 @@ static struct notifier_block amd_mce_dec_nb = { static int __init mce_amd_init(void) { struct cpuinfo_x86 *c = &boot_cpu_data; + int ret; if (c->x86_vendor != X86_VENDOR_AMD) return -ENODEV; @@ -1122,6 +1150,16 @@ static int __init mce_amd_init(void) goto err_out; } + dec_pool = gen_pool_create(ELEM_ORDER, -1); + if (!dec_pool) + goto err_out; + + ret = gen_pool_add(dec_pool, (unsigned long)__err_buf, DEC_POOL_SIZE, -1); + if (ret) { + gen_pool_destroy(dec_pool); + goto err_out; + } + pr_info("MCE: In-kernel MCE decoding enabled.\n"); mce_register_decode_chain(&amd_mce_dec_nb); @@ -1140,6 +1178,7 @@ static void __exit mce_amd_exit(void) { mce_unregister_decode_chain(&amd_mce_dec_nb); kfree(fam_ops); + gen_pool_destroy(dec_pool); } MODULE_DESCRIPTION("AMD MCE decoder"); -- 2.13.0