From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexandru Gagniuc Subject: [RFC PATCH v2 2/4] acpi: apei: Split GHES handlers outside of ghes_do_proc Date: Mon, 16 Apr 2018 16:59:01 -0500 Message-ID: <20180416215903.7318-3-mr.nuke.me@gmail.com> References: <20180416215903.7318-1-mr.nuke.me@gmail.com> Return-path: In-Reply-To: <20180416215903.7318-1-mr.nuke.me@gmail.com> Sender: linux-kernel-owner@vger.kernel.org To: linux-acpi@vger.kernel.org, linux-edac@vger.kernel.org Cc: rjw@rjwysocki.net, lenb@kernel.org, tony.luck@intel.com, bp@alien8.de, tbaicar@codeaurora.org, will.deacon@arm.com, james.morse@arm.com, shiju.jose@huawei.com, zjzhang@codeaurora.org, gengdongjiu@huawei.com, linux-kernel@vger.kernel.org, alex_gagniuc@dellteam.com, austin_bolen@dell.com, shyam_iyer@dell.com, devel@acpica.org, mchehab@kernel.org, robert.moore@intel.com, erik.schmauss@intel.com, Alexandru Gagniuc List-Id: linux-acpi@vger.kernel.org Use a mapping from CPER UUID to get the correct handler for a given GHES error. This is in preparation of splitting some handlers into irq safe and regular parts. Signed-off-by: Alexandru Gagniuc --- drivers/acpi/apei/ghes.c | 78 ++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 63 insertions(+), 15 deletions(-) diff --git a/drivers/acpi/apei/ghes.c b/drivers/acpi/apei/ghes.c index f9b53a6f55f3..2119c51b4a9e 100644 --- a/drivers/acpi/apei/ghes.c +++ b/drivers/acpi/apei/ghes.c @@ -414,6 +414,25 @@ static void ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, int #endif } +static int ghes_handle_arm(struct acpi_hest_generic_data *gdata, int sev) +{ + struct cper_sec_proc_arm *err = acpi_hest_get_payload(gdata); + + log_arm_hw_error(err); + return ghes_severity(gdata->error_severity); +} + +static int ghes_handle_mem(struct acpi_hest_generic_data *gdata, int sev) +{ + struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata); + + ghes_edac_report_mem_error(sev, mem_err); + arch_apei_report_mem_error(sev, mem_err); + ghes_handle_memory_failure(gdata, sev); + + return ghes_severity(gdata->error_severity); +} + /* * PCIe AER errors need to be sent to the AER driver for reporting and * recovery. The GHES severities map to the following AER severities and @@ -428,7 +447,7 @@ static void ghes_handle_memory_failure(struct acpi_hest_generic_data *gdata, int * GHES_SEV_PANIC does not make it to this handling since the kernel must * panic. */ -static void ghes_handle_aer(struct acpi_hest_generic_data *gdata) +static int ghes_handle_aer(struct acpi_hest_generic_data *gdata, int sev) { #ifdef CONFIG_ACPI_APEI_PCIEAER struct cper_sec_pcie *pcie_err = acpi_hest_get_payload(gdata); @@ -456,14 +475,54 @@ static void ghes_handle_aer(struct acpi_hest_generic_data *gdata) (struct aer_capability_regs *) pcie_err->aer_info); } + + return GHES_SEV_CORRECTED; #endif + return ghes_severity(gdata->error_severity); } +/** + * ghes_handler - handler for ACPI APEI errors + * @error_uuid: UUID describing the error entry (See ACPI/EFI CPER for details) + * @handle: Handler for the GHES entry of type 'error_uuid'. The handler + * returns the severity of the error after handling. A handler is allowed + * to demote errors to correctable or corrected, as appropriate. + */ +static const struct ghes_handler { + const guid_t *error_uuid; + int (*handle_irqsafe)(struct acpi_hest_generic_data *gdata, int sev); + int (*handle)(struct acpi_hest_generic_data *gdata, int sev); +} ghes_handlers[] = { + { + .error_uuid = &CPER_SEC_PLATFORM_MEM, + .handle = ghes_handle_mem, + }, { + .error_uuid = &CPER_SEC_PCIE, + .handle = ghes_handle_aer, + }, { + .error_uuid = &CPER_SEC_PROC_ARM, + .handle = ghes_handle_arm, + } +}; + +static const struct ghes_handler *get_handler(const guid_t *type) +{ + size_t i; + + for (i = 0; i < ARRAY_SIZE(ghes_handlers); i++) { + if (guid_equal(type, ghes_handlers[i].error_uuid)) + return &ghes_handlers[i]; + } + return NULL; +} + + static void ghes_do_proc(struct ghes *ghes, const struct acpi_hest_generic_status *estatus) { int sev, sec_sev; struct acpi_hest_generic_data *gdata; + const struct ghes_handler *handler; guid_t *sec_type; guid_t *fru_id = &NULL_UUID_LE; char *fru_text = ""; @@ -478,21 +537,10 @@ static void ghes_do_proc(struct ghes *ghes, if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT) fru_text = gdata->fru_text; - if (guid_equal(sec_type, &CPER_SEC_PLATFORM_MEM)) { - struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata); - - ghes_edac_report_mem_error(sev, mem_err); - - arch_apei_report_mem_error(sev, mem_err); - ghes_handle_memory_failure(gdata, sev); - } - else if (guid_equal(sec_type, &CPER_SEC_PCIE)) { - ghes_handle_aer(gdata); - } - else if (guid_equal(sec_type, &CPER_SEC_PROC_ARM)) { - struct cper_sec_proc_arm *err = acpi_hest_get_payload(gdata); - log_arm_hw_error(err); + handler = get_handler(sec_type); + if (handler) { + sec_sev = handler->handle(gdata, sev); } else { void *err = acpi_hest_get_payload(gdata); -- 2.14.3 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: [RFC,v2,2/4] acpi: apei: Split GHES handlers outside of ghes_do_proc From: Alexandru Gagniuc Message-Id: <20180416215903.7318-3-mr.nuke.me@gmail.com> Date: Mon, 16 Apr 2018 16:59:01 -0500 To: linux-acpi@vger.kernel.org, linux-edac@vger.kernel.org Cc: rjw@rjwysocki.net, lenb@kernel.org, tony.luck@intel.com, bp@alien8.de, tbaicar@codeaurora.org, will.deacon@arm.com, james.morse@arm.com, shiju.jose@huawei.com, zjzhang@codeaurora.org, gengdongjiu@huawei.com, linux-kernel@vger.kernel.org, alex_gagniuc@dellteam.com, austin_bolen@dell.com, shyam_iyer@dell.com, devel@acpica.org, mchehab@kernel.org, robert.moore@intel.com, erik.schmauss@intel.com, Alexandru Gagniuc List-ID: VXNlIGEgbWFwcGluZyBmcm9tIENQRVIgVVVJRCB0byBnZXQgdGhlIGNvcnJlY3QgaGFuZGxlciBm b3IgYSBnaXZlbgpHSEVTIGVycm9yLiBUaGlzIGlzIGluIHByZXBhcmF0aW9uIG9mIHNwbGl0dGlu ZyBzb21lIGhhbmRsZXJzIGludG8KaXJxIHNhZmUgYW5kIHJlZ3VsYXIgcGFydHMuCgpTaWduZWQt b2ZmLWJ5OiBBbGV4YW5kcnUgR2Fnbml1YyA8bXIubnVrZS5tZUBnbWFpbC5jb20+Ci0tLQogZHJp dmVycy9hY3BpL2FwZWkvZ2hlcy5jIHwgNzggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKystLS0tLS0tLS0tCiAxIGZpbGUgY2hhbmdlZCwgNjMgaW5zZXJ0aW9ucygrKSwgMTUg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FwZWkvZ2hlcy5jIGIvZHJp dmVycy9hY3BpL2FwZWkvZ2hlcy5jCmluZGV4IGY5YjUzYTZmNTVmMy4uMjExOWM1MWI0YTllIDEw MDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYXBlaS9naGVzLmMKKysrIGIvZHJpdmVycy9hY3BpL2Fw ZWkvZ2hlcy5jCkBAIC00MTQsNiArNDE0LDI1IEBAIHN0YXRpYyB2b2lkIGdoZXNfaGFuZGxlX21l bW9yeV9mYWlsdXJlKHN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19kYXRhICpnZGF0YSwgaW50CiAj ZW5kaWYKIH0KIAorc3RhdGljIGludCBnaGVzX2hhbmRsZV9hcm0oc3RydWN0IGFjcGlfaGVzdF9n ZW5lcmljX2RhdGEgKmdkYXRhLCBpbnQgc2V2KQoreworCXN0cnVjdCBjcGVyX3NlY19wcm9jX2Fy bSAqZXJyID0gYWNwaV9oZXN0X2dldF9wYXlsb2FkKGdkYXRhKTsKKworCWxvZ19hcm1faHdfZXJy b3IoZXJyKTsKKwlyZXR1cm4gZ2hlc19zZXZlcml0eShnZGF0YS0+ZXJyb3Jfc2V2ZXJpdHkpOwor fQorCitzdGF0aWMgaW50IGdoZXNfaGFuZGxlX21lbShzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNf ZGF0YSAqZ2RhdGEsIGludCBzZXYpCit7CisJc3RydWN0IGNwZXJfc2VjX21lbV9lcnIgKm1lbV9l cnIgPSBhY3BpX2hlc3RfZ2V0X3BheWxvYWQoZ2RhdGEpOworCisJZ2hlc19lZGFjX3JlcG9ydF9t ZW1fZXJyb3Ioc2V2LCBtZW1fZXJyKTsKKwlhcmNoX2FwZWlfcmVwb3J0X21lbV9lcnJvcihzZXYs IG1lbV9lcnIpOworCWdoZXNfaGFuZGxlX21lbW9yeV9mYWlsdXJlKGdkYXRhLCBzZXYpOworCisJ cmV0dXJuIGdoZXNfc2V2ZXJpdHkoZ2RhdGEtPmVycm9yX3NldmVyaXR5KTsKK30KKwogLyoKICAq IFBDSWUgQUVSIGVycm9ycyBuZWVkIHRvIGJlIHNlbnQgdG8gdGhlIEFFUiBkcml2ZXIgZm9yIHJl cG9ydGluZyBhbmQKICAqIHJlY292ZXJ5LiBUaGUgR0hFUyBzZXZlcml0aWVzIG1hcCB0byB0aGUg Zm9sbG93aW5nIEFFUiBzZXZlcml0aWVzIGFuZApAQCAtNDI4LDcgKzQ0Nyw3IEBAIHN0YXRpYyB2 b2lkIGdoZXNfaGFuZGxlX21lbW9yeV9mYWlsdXJlKHN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19k YXRhICpnZGF0YSwgaW50CiAgKiBHSEVTX1NFVl9QQU5JQyBkb2VzIG5vdCBtYWtlIGl0IHRvIHRo aXMgaGFuZGxpbmcgc2luY2UgdGhlIGtlcm5lbCBtdXN0CiAgKiAgICAgcGFuaWMuCiAgKi8KLXN0 YXRpYyB2b2lkIGdoZXNfaGFuZGxlX2FlcihzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfZGF0YSAq Z2RhdGEpCitzdGF0aWMgaW50IGdoZXNfaGFuZGxlX2FlcihzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVy aWNfZGF0YSAqZ2RhdGEsIGludCBzZXYpCiB7CiAjaWZkZWYgQ09ORklHX0FDUElfQVBFSV9QQ0lF QUVSCiAJc3RydWN0IGNwZXJfc2VjX3BjaWUgKnBjaWVfZXJyID0gYWNwaV9oZXN0X2dldF9wYXls b2FkKGdkYXRhKTsKQEAgLTQ1NiwxNCArNDc1LDU0IEBAIHN0YXRpYyB2b2lkIGdoZXNfaGFuZGxl X2FlcihzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfZGF0YSAqZ2RhdGEpCiAJCQkJICAoc3RydWN0 IGFlcl9jYXBhYmlsaXR5X3JlZ3MgKikKIAkJCQkgIHBjaWVfZXJyLT5hZXJfaW5mbyk7CiAJfQor CisJcmV0dXJuIEdIRVNfU0VWX0NPUlJFQ1RFRDsKICNlbmRpZgorCXJldHVybiBnaGVzX3NldmVy aXR5KGdkYXRhLT5lcnJvcl9zZXZlcml0eSk7CiB9CiAKKy8qKgorICogZ2hlc19oYW5kbGVyIC0g aGFuZGxlciBmb3IgQUNQSSBBUEVJIGVycm9ycworICogQGVycm9yX3V1aWQ6IFVVSUQgZGVzY3Jp YmluZyB0aGUgZXJyb3IgZW50cnkgKFNlZSBBQ1BJL0VGSSBDUEVSIGZvciBkZXRhaWxzKQorICog QGhhbmRsZTogSGFuZGxlciBmb3IgdGhlIEdIRVMgZW50cnkgb2YgdHlwZSAnZXJyb3JfdXVpZCcu IFRoZSBoYW5kbGVyCisgKglyZXR1cm5zIHRoZSBzZXZlcml0eSBvZiB0aGUgZXJyb3IgYWZ0ZXIg aGFuZGxpbmcuIEEgaGFuZGxlciBpcyBhbGxvd2VkCisgKgl0byBkZW1vdGUgZXJyb3JzIHRvIGNv cnJlY3RhYmxlIG9yIGNvcnJlY3RlZCwgYXMgYXBwcm9wcmlhdGUuCisgKi8KK3N0YXRpYyBjb25z dCBzdHJ1Y3QgZ2hlc19oYW5kbGVyIHsKKwljb25zdCBndWlkX3QgKmVycm9yX3V1aWQ7CisJaW50 ICgqaGFuZGxlX2lycXNhZmUpKHN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19kYXRhICpnZGF0YSwg aW50IHNldik7CisJaW50ICgqaGFuZGxlKShzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfZGF0YSAq Z2RhdGEsIGludCBzZXYpOworfSBnaGVzX2hhbmRsZXJzW10gPSB7CisJeworCQkuZXJyb3JfdXVp ZCA9ICZDUEVSX1NFQ19QTEFURk9STV9NRU0sCisJCS5oYW5kbGUgPSBnaGVzX2hhbmRsZV9tZW0s CisJfSwgeworCQkuZXJyb3JfdXVpZCA9ICZDUEVSX1NFQ19QQ0lFLAorCQkuaGFuZGxlID0gZ2hl c19oYW5kbGVfYWVyLAorCX0sIHsKKwkJLmVycm9yX3V1aWQgPSAmQ1BFUl9TRUNfUFJPQ19BUk0s CisJCS5oYW5kbGUgPSBnaGVzX2hhbmRsZV9hcm0sCisJfQorfTsKKworc3RhdGljIGNvbnN0IHN0 cnVjdCBnaGVzX2hhbmRsZXIgKmdldF9oYW5kbGVyKGNvbnN0IGd1aWRfdCAqdHlwZSkKK3sKKwlz aXplX3QgaTsKKworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKGdoZXNfaGFuZGxlcnMpOyBp KyspIHsKKwkJaWYgKGd1aWRfZXF1YWwodHlwZSwgZ2hlc19oYW5kbGVyc1tpXS5lcnJvcl91dWlk KSkKKwkJCXJldHVybiAmZ2hlc19oYW5kbGVyc1tpXTsKKwl9CisJcmV0dXJuIE5VTEw7Cit9CisK Kwogc3RhdGljIHZvaWQgZ2hlc19kb19wcm9jKHN0cnVjdCBnaGVzICpnaGVzLAogCQkJIGNvbnN0 IHN0cnVjdCBhY3BpX2hlc3RfZ2VuZXJpY19zdGF0dXMgKmVzdGF0dXMpCiB7CiAJaW50IHNldiwg c2VjX3NldjsKIAlzdHJ1Y3QgYWNwaV9oZXN0X2dlbmVyaWNfZGF0YSAqZ2RhdGE7CisJY29uc3Qg c3RydWN0IGdoZXNfaGFuZGxlciAqaGFuZGxlcjsKIAlndWlkX3QgKnNlY190eXBlOwogCWd1aWRf dCAqZnJ1X2lkID0gJk5VTExfVVVJRF9MRTsKIAljaGFyICpmcnVfdGV4dCA9ICIiOwpAQCAtNDc4 LDIxICs1MzcsMTAgQEAgc3RhdGljIHZvaWQgZ2hlc19kb19wcm9jKHN0cnVjdCBnaGVzICpnaGVz LAogCQlpZiAoZ2RhdGEtPnZhbGlkYXRpb25fYml0cyAmIENQRVJfU0VDX1ZBTElEX0ZSVV9URVhU KQogCQkJZnJ1X3RleHQgPSBnZGF0YS0+ZnJ1X3RleHQ7CiAKLQkJaWYgKGd1aWRfZXF1YWwoc2Vj X3R5cGUsICZDUEVSX1NFQ19QTEFURk9STV9NRU0pKSB7Ci0JCQlzdHJ1Y3QgY3Blcl9zZWNfbWVt X2VyciAqbWVtX2VyciA9IGFjcGlfaGVzdF9nZXRfcGF5bG9hZChnZGF0YSk7Ci0KLQkJCWdoZXNf ZWRhY19yZXBvcnRfbWVtX2Vycm9yKHNldiwgbWVtX2Vycik7Ci0KLQkJCWFyY2hfYXBlaV9yZXBv cnRfbWVtX2Vycm9yKHNldiwgbWVtX2Vycik7Ci0JCQlnaGVzX2hhbmRsZV9tZW1vcnlfZmFpbHVy ZShnZGF0YSwgc2V2KTsKLQkJfQotCQllbHNlIGlmIChndWlkX2VxdWFsKHNlY190eXBlLCAmQ1BF Ul9TRUNfUENJRSkpIHsKLQkJCWdoZXNfaGFuZGxlX2FlcihnZGF0YSk7Ci0JCX0KLQkJZWxzZSBp ZiAoZ3VpZF9lcXVhbChzZWNfdHlwZSwgJkNQRVJfU0VDX1BST0NfQVJNKSkgewotCQkJc3RydWN0 IGNwZXJfc2VjX3Byb2NfYXJtICplcnIgPSBhY3BpX2hlc3RfZ2V0X3BheWxvYWQoZ2RhdGEpOwog Ci0JCQlsb2dfYXJtX2h3X2Vycm9yKGVycik7CisJCWhhbmRsZXIgPSBnZXRfaGFuZGxlcihzZWNf dHlwZSk7CisJCWlmIChoYW5kbGVyKSB7CisJCQlzZWNfc2V2ID0gaGFuZGxlci0+aGFuZGxlKGdk YXRhLCBzZXYpOwogCQl9IGVsc2UgewogCQkJdm9pZCAqZXJyID0gYWNwaV9oZXN0X2dldF9wYXls b2FkKGdkYXRhKTsKIAo=