Split the Grace CPER processing into a separate decode step and a print step so the parser can be exercised by KUnit without a live ACPI device. Introduce ghes-nvidia.h to hold shared types that the Vera decoder added in the next commit will also reference.
Parse the Grace wire payload with __packed structs and get_unaligned_le*() for multi-byte fields, matching the Vera decoder style. Reject nvidia_ghes_grace_reg_pair() calls with a non-zero register count and a NULL grace_regs pointer, and rate-limit Grace decoder diagnostics. Signed-off-by: Kai-Heng Feng <[email protected]> --- v3: - Use __packed + get_unaligned_le*() for Grace multi-byte fields, including register pairs (Shuai Xue). - Keep __counted_by / struct_size; reject NULL grace_regs when number_regs != 0; document the helper contract. - Rate-limit Grace decoder and notify error messages. v2: - No change. --- MAINTAINERS | 2 +- drivers/acpi/apei/ghes-nvidia.c | 160 ++++++++++++++++++++++---------- drivers/acpi/apei/ghes-nvidia.h | 50 ++++++++++ 3 files changed, 160 insertions(+), 52 deletions(-) create mode 100644 drivers/acpi/apei/ghes-nvidia.h diff --git a/MAINTAINERS b/MAINTAINERS index 5114e6db7307..aa9c2ae58ac5 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -19348,7 +19348,7 @@ NVIDIA GHES VENDOR CPER RECORD HANDLER M: Kai-Heng Feng <[email protected]> L: [email protected] S: Maintained -F: drivers/acpi/apei/ghes-nvidia.c +F: drivers/acpi/apei/ghes-nvidia* NVIDIA VRS RTC DRIVER M: Shubhi Garg <[email protected]> diff --git a/drivers/acpi/apei/ghes-nvidia.c b/drivers/acpi/apei/ghes-nvidia.c index 597275d81de8..e7cc912344fd 100644 --- a/drivers/acpi/apei/ghes-nvidia.c +++ b/drivers/acpi/apei/ghes-nvidia.c @@ -9,13 +9,18 @@ #include <linux/module.h> #include <linux/platform_device.h> #include <linux/types.h> +#include <linux/unaligned.h> #include <linux/uuid.h> #include <acpi/ghes.h> -static const guid_t nvidia_sec_guid = +#include <kunit/visibility.h> +#include "ghes-nvidia.h" + +static const guid_t nvidia_grace_sec_guid = GUID_INIT(0x6d5244f2, 0x2712, 0x11ec, 0xbe, 0xa7, 0xcb, 0x3f, 0xdb, 0x95, 0xc7, 0x86); +/* Grace CPER section wire layout (header without flexible register array). */ struct cper_sec_nvidia { char signature[16]; __le16 error_type; @@ -25,84 +30,137 @@ struct cper_sec_nvidia { u8 number_regs; u8 reserved; __le64 instance_base; - struct { - __le64 addr; - __le64 val; - } regs[] __counted_by(number_regs); -}; + struct nvidia_ghes_grace_reg regs[] __counted_by(number_regs); +} __packed; + +static_assert(sizeof(struct cper_sec_nvidia) == 32); struct nvidia_ghes_private { struct notifier_block nb; struct device *dev; }; -static void nvidia_ghes_print_error(struct device *dev, - const struct cper_sec_nvidia *nvidia_err, - size_t error_data_length, bool fatal) +VISIBLE_IF_KUNIT +int nvidia_ghes_decode_grace(struct device *dev, const void *buf, + size_t len, + struct nvidia_ghes_decoded *decoded) { - const char *level = fatal ? KERN_ERR : KERN_INFO; + const struct cper_sec_nvidia *nvidia_err = buf; size_t min_size; + u8 number_regs; + + if (!buf || !decoded) + return -EINVAL; + if (len < sizeof(*nvidia_err)) { + if (dev) + dev_err_ratelimited(dev, "Section too small (%zu < %zu)\n", + len, sizeof(*nvidia_err)); + return -ENODATA; + } - dev_printk(level, dev, "signature: %.16s\n", nvidia_err->signature); - dev_printk(level, dev, "error_type: %u\n", le16_to_cpu(nvidia_err->error_type)); - dev_printk(level, dev, "error_instance: %u\n", le16_to_cpu(nvidia_err->error_instance)); - dev_printk(level, dev, "severity: %u\n", nvidia_err->severity); - dev_printk(level, dev, "socket: %u\n", nvidia_err->socket); - dev_printk(level, dev, "number_regs: %u\n", nvidia_err->number_regs); - dev_printk(level, dev, "instance_base: 0x%016llx\n", - le64_to_cpu(nvidia_err->instance_base)); - - if (nvidia_err->number_regs == 0) - return; - - /* - * Validate that all registers fit within error_data_length. - * Each register pair is two little-endian u64s. - */ - min_size = struct_size(nvidia_err, regs, nvidia_err->number_regs); - if (error_data_length < min_size) { - dev_err(dev, "Invalid number_regs %u (section size %zu, need %zu)\n", - nvidia_err->number_regs, error_data_length, min_size); - return; + number_regs = nvidia_err->number_regs; + min_size = struct_size(nvidia_err, regs, number_regs); + if (len < min_size) { + if (dev) + dev_err_ratelimited(dev, + "Invalid number_regs %u (section size %zu, need %zu)\n", + number_regs, len, min_size); + return -ENODATA; } - for (int i = 0; i < nvidia_err->number_regs; i++) + memset(decoded, 0, sizeof(*decoded)); + decoded->format = NVIDIA_GHES_FORMAT_GRACE; + memcpy(decoded->signature, nvidia_err->signature, sizeof(nvidia_err->signature)); + decoded->signature[sizeof(nvidia_err->signature)] = '\0'; + decoded->error_type = get_unaligned_le16(&nvidia_err->error_type); + decoded->error_instance = get_unaligned_le16(&nvidia_err->error_instance); + decoded->severity = nvidia_err->severity; + decoded->socket = nvidia_err->socket; + decoded->number_regs = number_regs; + decoded->instance_base = get_unaligned_le64(&nvidia_err->instance_base); + if (number_regs) + decoded->grace_regs = nvidia_err->regs; + + return 0; +} +EXPORT_SYMBOL_IF_KUNIT(nvidia_ghes_decode_grace); + +VISIBLE_IF_KUNIT +int nvidia_ghes_grace_reg_pair(const struct nvidia_ghes_decoded *decoded, + unsigned int index, u64 *addr, u64 *val) +{ + const struct nvidia_ghes_grace_reg *regs; + + if (!decoded || decoded->format != NVIDIA_GHES_FORMAT_GRACE || !addr || !val) + return -EINVAL; + if (decoded->number_regs && !decoded->grace_regs) + return -EINVAL; + if (index >= decoded->number_regs) + return -ERANGE; + + regs = decoded->grace_regs; + *addr = get_unaligned_le64(®s[index].addr); + *val = get_unaligned_le64(®s[index].val); + + return 0; +} +EXPORT_SYMBOL_IF_KUNIT(nvidia_ghes_grace_reg_pair); + +static void nvidia_ghes_print_grace(struct device *dev, + const struct nvidia_ghes_decoded *decoded, + bool fatal) +{ + const char *level = fatal ? KERN_ERR : KERN_INFO; + u64 addr, val; + + dev_printk(level, dev, "signature: %s\n", decoded->signature); + dev_printk(level, dev, "error_type: %u\n", decoded->error_type); + dev_printk(level, dev, "error_instance: %u\n", decoded->error_instance); + dev_printk(level, dev, "severity: %u\n", decoded->severity); + dev_printk(level, dev, "socket: %u\n", decoded->socket); + dev_printk(level, dev, "number_regs: %u\n", decoded->number_regs); + dev_printk(level, dev, "instance_base: 0x%016llx\n", decoded->instance_base); + + for (int i = 0; i < decoded->number_regs; i++) { + if (nvidia_ghes_grace_reg_pair(decoded, i, &addr, &val)) + break; dev_printk(level, dev, "register[%d]: address=0x%016llx value=0x%016llx\n", - i, le64_to_cpu(nvidia_err->regs[i].addr), - le64_to_cpu(nvidia_err->regs[i].val)); + i, addr, val); + } } static int nvidia_ghes_notify(struct notifier_block *nb, unsigned long event, void *data) { struct acpi_hest_generic_data *gdata = data; + struct nvidia_ghes_decoded decoded = {}; struct nvidia_ghes_private *priv; - const struct cper_sec_nvidia *nvidia_err; + const void *payload; guid_t sec_guid; + u32 len; + int ret; + bool fatal; import_guid(&sec_guid, gdata->section_type); - if (!guid_equal(&sec_guid, &nvidia_sec_guid)) + if (!guid_equal(&sec_guid, &nvidia_grace_sec_guid)) return NOTIFY_DONE; priv = container_of(nb, struct nvidia_ghes_private, nb); - - if (acpi_hest_get_error_length(gdata) < sizeof(*nvidia_err)) { - dev_err(priv->dev, "Section too small (%d < %zu)\n", - acpi_hest_get_error_length(gdata), sizeof(*nvidia_err)); + len = acpi_hest_get_error_length(gdata); + payload = acpi_hest_get_payload(gdata); + fatal = event >= GHES_SEV_RECOVERABLE; + + ret = nvidia_ghes_decode_grace(priv->dev, payload, len, &decoded); + if (ret) { + dev_err_ratelimited(priv->dev, + "Malformed NVIDIA CPER section, error_data_length: %u, ret: %d\n", + len, ret); return NOTIFY_OK; } - nvidia_err = acpi_hest_get_payload(gdata); - - if (event >= GHES_SEV_RECOVERABLE) - dev_err(priv->dev, "NVIDIA CPER section, error_data_length: %u\n", - acpi_hest_get_error_length(gdata)); - else - dev_info(priv->dev, "NVIDIA CPER section, error_data_length: %u\n", - acpi_hest_get_error_length(gdata)); - - nvidia_ghes_print_error(priv->dev, nvidia_err, acpi_hest_get_error_length(gdata), - event >= GHES_SEV_RECOVERABLE); + dev_printk(fatal ? KERN_ERR : KERN_INFO, priv->dev, + "NVIDIA CPER section, error_data_length: %u\n", len); + nvidia_ghes_print_grace(priv->dev, &decoded, fatal); return NOTIFY_OK; } diff --git a/drivers/acpi/apei/ghes-nvidia.h b/drivers/acpi/apei/ghes-nvidia.h new file mode 100644 index 000000000000..965abe3d5c49 --- /dev/null +++ b/drivers/acpi/apei/ghes-nvidia.h @@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef GHES_NVIDIA_H +#define GHES_NVIDIA_H + +#include <linux/build_bug.h> +#include <linux/types.h> +#include <kunit/visibility.h> + +struct device; + +enum nvidia_ghes_format { + NVIDIA_GHES_FORMAT_UNKNOWN, + NVIDIA_GHES_FORMAT_GRACE, +}; + +struct nvidia_ghes_grace_reg { + __le64 addr; + __le64 val; +} __packed; + +struct nvidia_ghes_decoded { + enum nvidia_ghes_format format; + char signature[17]; + u16 error_type; + u16 error_instance; + u8 severity; + u8 socket; + u8 number_regs; + u64 instance_base; + const struct nvidia_ghes_grace_reg *grace_regs; +}; + +/** + * nvidia_ghes_grace_reg_pair() - Read one Grace register address/value pair + * @decoded: Decoded Grace section; format must be NVIDIA_GHES_FORMAT_GRACE + * @index: Register index in [0, number_regs) + * @addr: Output register address + * @val: Output register value + * + * When number_regs is non-zero, decoded->grace_regs must be non-NULL. + * Returns -EINVAL for bad arguments / missing grace_regs, -ERANGE for + * index >= number_regs, and 0 on success. + */ +VISIBLE_IF_KUNIT int nvidia_ghes_decode_grace(struct device *dev, const void *buf, + size_t len, + struct nvidia_ghes_decoded *decoded); +VISIBLE_IF_KUNIT int nvidia_ghes_grace_reg_pair(const struct nvidia_ghes_decoded *decoded, + unsigned int index, u64 *addr, u64 *val); + +#endif -- 2.50.1 (Apple Git-155)
