From 90f4b8c43d5821ab34b50f980df2be849130ef12 Mon Sep 17 00:00:00 2001 From: "Saeed, Oosman" Date: Mon, 27 Oct 2025 14:10:00 -0500 Subject: [PATCH] Sync with latest ras-decode @bc6b43c (#770) Signed-off-by: Oosman Saeed --- include/ras-decode/aca_decode.h | 40 +- include/ras-decode/aca_fields.h | 99 ++- include/ras-decode/aca_tables.h | 47 +- include/ras-decode/aca_version.h | 82 +- include/ras-decode/boot_decode.h | 101 ++- include/ras-decode/error_map.h | 13 +- include/ras-decode/json_util.h | 55 +- include/ras-decode/ras_decode_api.h | 50 +- src/CMakeLists.txt | 55 +- src/ras-decode/aca_decode.c | 528 ++++++------ src/ras-decode/aca_fields.c | 104 ++- src/ras-decode/aca_tables.c | 454 +++++------ src/ras-decode/aca_version.c | 47 +- src/ras-decode/boot_decode.c | 1150 ++++++++++++--------------- src/ras-decode/error_map.c | 140 ++-- src/ras-decode/json_printer.c | 87 +- src/ras-decode/json_util.c | 291 +++---- src/ras-decode/main.c | 323 ++++---- src/ras-decode/ras_decode_api.c | 311 ++++---- 19 files changed, 1871 insertions(+), 2106 deletions(-) diff --git a/include/ras-decode/aca_decode.h b/include/ras-decode/aca_decode.h index f61d8bbb01..96b857fc19 100644 --- a/include/ras-decode/aca_decode.h +++ b/include/ras-decode/aca_decode.h @@ -27,38 +27,36 @@ #ifndef RAS_DECODE_DECODE_H #define RAS_DECODE_DECODE_H -#include "ras_decode_api.h" #include "aca_fields.h" #include "json_util.h" +#include "ras_decode_api.h" /** * @brief Internal decoder structure with parsed register fields */ -typedef struct -{ - uint64_t aca_status; /**< Raw status register value */ - uint64_t aca_addr; /**< Raw address register value */ - uint64_t aca_ipid; /**< Raw IPID register value */ - uint64_t aca_synd; /**< Raw syndrome register value */ - uint32_t flags; /**< Decoder flags */ - uint16_t hw_revision; /**< Hardware hw_revision */ +typedef struct { + uint64_t aca_status; /**< Raw status register value */ + uint64_t aca_addr; /**< Raw address register value */ + uint64_t aca_ipid; /**< Raw IPID register value */ + uint64_t aca_synd; /**< Raw syndrome register value */ + uint32_t flags; /**< Decoder flags */ + uint16_t hw_revision; /**< Hardware hw_revision */ - aca_status_fields_t status; /**< Parsed status fields */ - aca_ipid_fields_t ipid; /**< Parsed IPID fields */ - aca_synd_fields_t synd; /**< Parsed syndrome fields */ + aca_status_fields_t status; /**< Parsed status fields */ + aca_ipid_fields_t ipid; /**< Parsed IPID fields */ + aca_synd_fields_t synd; /**< Parsed syndrome fields */ } aca_decoder_t; /** * @brief Structure containing raw ACA error data from hardware */ -typedef struct -{ - uint64_t aca_status; /**< Raw status register value */ - uint64_t aca_addr; /**< Raw address register value */ - uint64_t aca_ipid; /**< Raw IPID register value */ - uint64_t aca_synd; /**< Raw syndrome register value */ - uint32_t flags; /**< Flags from descriptor */ - uint16_t hw_revision; /**< Hardware hw_revision number */ +typedef struct { + uint64_t aca_status; /**< Raw status register value */ + uint64_t aca_addr; /**< Raw address register value */ + uint64_t aca_ipid; /**< Raw IPID register value */ + uint64_t aca_synd; /**< Raw syndrome register value */ + uint32_t flags; /**< Flags from descriptor */ + uint16_t hw_revision; /**< Hardware hw_revision number */ } aca_raw_data_t; /** @@ -66,6 +64,6 @@ typedef struct * @param[in] raw_data Pointer to structure containing raw ACA error data * @return JsonValue* containing the decoded error information, or NULL on failure */ -JsonValue* aca_decode(const aca_raw_data_t *raw_data); +JsonValue* aca_decode(const aca_raw_data_t* raw_data); #endif /* RAS_DECODE_DECODE_H */ diff --git a/include/ras-decode/aca_fields.h b/include/ras-decode/aca_fields.h index 9055586a37..e715e21a43 100644 --- a/include/ras-decode/aca_fields.h +++ b/include/ras-decode/aca_fields.h @@ -37,78 +37,73 @@ /** * @brief Base structure for ACA fields containing raw register value */ -typedef struct -{ - uint64_t raw_value; /**< Raw 64-bit register value */ +typedef struct { + uint64_t raw_value; /**< Raw 64-bit register value */ } aca_fields_t; /** * @brief Structure containing decoded ACA status register fields */ -typedef struct -{ - aca_fields_t base; - uint16_t error_code; - uint8_t error_code_ext; - uint8_t reserv22; - uint8_t addr_lsb; - uint8_t reserv30; - uint8_t err_core_id; - uint8_t reserv38; - uint8_t scrub; - uint8_t reserv41; - uint8_t poison; - uint8_t deferred; - uint8_t uecc; - uint8_t cecc; - uint8_t reserv47; - uint8_t synd_v; - uint8_t reserv54; - uint8_t tcc; - uint8_t err_core_id_val; - uint8_t pcc; - uint8_t addr_v; - uint8_t misc_v; - uint8_t en; - uint8_t uc; - uint8_t overflow; - uint8_t val; +typedef struct { + aca_fields_t base; + uint16_t error_code; + uint8_t error_code_ext; + uint8_t reserv22; + uint8_t addr_lsb; + uint8_t reserv30; + uint8_t err_core_id; + uint8_t reserv38; + uint8_t scrub; + uint8_t reserv41; + uint8_t poison; + uint8_t deferred; + uint8_t uecc; + uint8_t cecc; + uint8_t reserv47; + uint8_t synd_v; + uint8_t reserv54; + uint8_t tcc; + uint8_t err_core_id_val; + uint8_t pcc; + uint8_t addr_v; + uint8_t misc_v; + uint8_t en; + uint8_t uc; + uint8_t overflow; + uint8_t val; } aca_status_fields_t; /** * @brief Structure containing decoded ACA IPID register fields */ -typedef struct -{ - aca_fields_t base; - uint32_t instance_id_lo; - uint16_t hardware_id; - uint16_t aca_type; - uint8_t instance_id_hi; +typedef struct { + aca_fields_t base; + uint32_t instance_id_lo; + uint16_t hardware_id; + uint16_t aca_type; + uint8_t instance_id_hi; } aca_ipid_fields_t; /** * @brief Structure containing decoded ACA syndrome register fields */ -typedef struct -{ - aca_fields_t base; - uint32_t error_information; - uint8_t length; - uint8_t error_priority; - uint8_t reserved27; - uint16_t syndrome; - uint32_t reserved39; +typedef struct { + aca_fields_t base; + uint32_t error_information; + uint8_t length; + uint8_t error_priority; + uint8_t reserved27; + uint16_t syndrome; + uint32_t reserved39; } aca_synd_fields_t; /** * @brief Structure containing decoded ACA address register fields */ -typedef struct -{ - aca_fields_t base; - uint64_t error_addr; - uint64_t reserved; +typedef struct { + aca_fields_t base; + uint64_t error_addr; + uint64_t reserved; } aca_addr_fields_t; /** diff --git a/include/ras-decode/aca_tables.h b/include/ras-decode/aca_tables.h index 499637cb49..7cd18914ec 100644 --- a/include/ras-decode/aca_tables.h +++ b/include/ras-decode/aca_tables.h @@ -30,55 +30,50 @@ #ifndef RAS_DECODE_TABLES_H #define RAS_DECODE_TABLES_H -#include #include +#include /** * @brief Structure mapping hardware ID and ACA type to bank names */ -typedef struct -{ - uint16_t hw_id; /**< Hardware ID value */ - uint16_t aca_type; /**< ACA type identifier */ - const char *name; /**< Bank name string */ +typedef struct { + uint16_t hw_id; /**< Hardware ID value */ + uint16_t aca_type; /**< ACA type identifier */ + const char *name; /**< Bank name string */ } aca_bank_entry_t; /** * @brief Structure mapping bank-specific error codes to error types */ -typedef struct -{ - const char *bank; /**< Bank name string */ - uint32_t error_code; /**< Error code value */ - const char *type; /**< Error type string */ +typedef struct { + const char *bank; /**< Bank name string */ + uint32_t error_code; /**< Error code value */ + const char *type; /**< Error type string */ } aca_error_type_t; /** * @brief Structure for generic error code to error type mapping */ -typedef struct -{ - uint32_t error_code; /**< Error code value */ - const char *type; /**< Error type string */ +typedef struct { + uint32_t error_code; /**< Error code value */ + const char *type; /**< Error type string */ } aca_error_entry_t; /** * @brief Structure mapping instance_id_hi to OAM and AID values */ -typedef struct -{ - uint8_t oam; /**< OAM value */ - uint8_t aid; /**< AID value */ +typedef struct { + uint8_t oam; /**< OAM value */ + uint8_t aid; /**< AID value */ } oam_aid_map_t; /** * @brief Structure for mapping bank and instance ID LO to instance name */ -typedef struct -{ - const char *bank; /**< Bank name */ - uint32_t instance_id_lo; /**< Instance ID Lo (masked with 0xFFFFFFFC) */ - const char *name; /**< Instance name */ +typedef struct { + const char *bank; /**< Bank name */ + uint32_t instance_id_lo; /**< Instance ID Lo (masked with 0xFFFFFFFC) */ + const char *name; /**< Instance name */ } aca_instance_entry_t; // External table declarations @@ -119,8 +114,8 @@ int find_error_type_by_bank(const char *bank, uint32_t error_code, const char ** * @param[out] error_type Pointer to store result string * @return 0 on success, 1 if not found, -1 on parameter error */ -int find_error_in_table(const aca_error_entry_t *table, size_t table_size, - uint32_t error_code, const char **error_type); +int find_error_in_table(const aca_error_entry_t *table, size_t table_size, uint32_t error_code, + const char **error_type); /** * @brief Find OAM and AID values based on instance_id_hi diff --git a/include/ras-decode/aca_version.h b/include/ras-decode/aca_version.h index aafc55f276..38ad673c18 100644 --- a/include/ras-decode/aca_version.h +++ b/include/ras-decode/aca_version.h @@ -24,8 +24,7 @@ #define RAS_DECODE_VERSION_H #ifdef __cplusplus -extern "C" -{ +extern "C" { #endif /** @@ -36,7 +35,7 @@ extern "C" * * - MAJOR: Incremented for incompatible API changes * - MINOR: Incremented for backward-compatible functionality additions - * - PATCH: Incremented for backward-compatible bug fixes + * - PATCH: Incremented for backward-compatible fixes */ /* Version Components */ @@ -49,51 +48,50 @@ extern "C" #define RAS_DECODE_TOSTRING(x) RAS_DECODE_STRINGIFY(x) /* Version String - dynamically constructed from components */ -#define RAS_DECODE_VERSION_STRING \ - RAS_DECODE_TOSTRING(RAS_DECODE_VERSION_MAJOR) "." \ - RAS_DECODE_TOSTRING(RAS_DECODE_VERSION_MINOR) "." \ - RAS_DECODE_TOSTRING(RAS_DECODE_VERSION_PATCH) +#define RAS_DECODE_VERSION_STRING \ + RAS_DECODE_TOSTRING(RAS_DECODE_VERSION_MAJOR) \ + "." RAS_DECODE_TOSTRING(RAS_DECODE_VERSION_MINOR) "." RAS_DECODE_TOSTRING( \ + RAS_DECODE_VERSION_PATCH) - /** - * @brief Structure containing version information - */ - typedef struct - { - int major; /**< Major version number */ - int minor; /**< Minor version number */ - int patch; /**< Patch version number */ - const char *string; /**< Version string (e.g., "1.0.0") */ - } aca_version_info_t; +/** + * @brief Structure containing version information + */ +typedef struct { + int major; /**< Major version number */ + int minor; /**< Minor version number */ + int patch; /**< Patch version number */ + const char *string; /**< Version string (e.g., "1.0.0") */ +} aca_version_info_t; - /** - * @brief Get the major version number - * @return Major version number - */ - int aca_get_version_major(void); +/** + * @brief Get the major version number + * @return Major version number + */ +int aca_get_version_major(void); - /** - * @brief Get the minor version number - * @return Minor version number - */ - int aca_get_version_minor(void); +/** + * @brief Get the minor version number + * @return Minor version number + */ +int aca_get_version_minor(void); - /** - * @brief Get the patch version number - * @return Patch version number - */ - int aca_get_version_patch(void); +/** + * @brief Get the patch version number + * @return Patch version number + */ +int aca_get_version_patch(void); - /** - * @brief Get the version string - * @return Pointer to version string (e.g., "1.0.0") - */ - const char *aca_get_version_string(void); +/** + * @brief Get the version string + * @return Pointer to version string (e.g., "1.0.0") + */ +const char *aca_get_version_string(void); - /** - * @brief Get complete version information - * @return Structure containing all version information - */ - aca_version_info_t aca_get_version_info(void); +/** + * @brief Get complete version information + * @return Structure containing all version information + */ +aca_version_info_t aca_get_version_info(void); #ifdef __cplusplus } diff --git a/include/ras-decode/boot_decode.h b/include/ras-decode/boot_decode.h index 6add864e53..5dec624336 100644 --- a/include/ras-decode/boot_decode.h +++ b/include/ras-decode/boot_decode.h @@ -23,9 +23,10 @@ #ifndef BOOT_DECODE_H #define BOOT_DECODE_H -#include #include #include +#include + #include "json_util.h" #ifdef __cplusplus @@ -36,7 +37,7 @@ extern "C" { * @brief Boot message structure representing OAM boot message */ typedef struct { - uint64_t value; ///< 64-bit boot message value + uint64_t value; ///< 64-bit boot message value } OamBootMsg; /** @@ -44,44 +45,44 @@ typedef struct { * @param msg Boot message to decode * @return JsonValue containing decoded information or NULL on failure */ -typedef JsonValue* (*boot_decoder_func_t)(OamBootMsg *msg); +typedef JsonValue *(*boot_decoder_func_t)(OamBootMsg *msg); /** * @brief Decoder mapping entry */ typedef struct { - uint8_t encoding; ///< Error encoding value - boot_decoder_func_t decoder; ///< Decoder function + uint8_t encoding; ///< Error encoding value + boot_decoder_func_t decoder; ///< Decoder function } boot_decoder_entry_t; /** * @brief Boot message constants */ -#define BOOT_ERROR_PRESENT_MARKER 0xA4 -#define BOOT_IN_BOOT_MARKER 0xBA -#define BOOT_SUCCESS_ENCODING 0xBA +#define BOOT_ERROR_PRESENT_MARKER 0xA4 +#define BOOT_IN_BOOT_MARKER 0xBA +#define BOOT_SUCCESS_ENCODING 0xBA /** * @brief Error encoding constants */ -#define BOOT_ENCODING_HBM_TRAINING 0x01 -#define BOOT_ENCODING_FW_LOAD 0x04 -#define BOOT_ENCODING_WAFL_LINK 0x05 -#define BOOT_ENCODING_XGMI_LINK 0x06 -#define BOOT_ENCODING_USR_CP_LINK 0x07 -#define BOOT_ENCODING_USR_DP_LINK 0x08 -#define BOOT_ENCODING_HBM_MEM_TEST 0x09 -#define BOOT_ENCODING_HBM_BIST_TEST 0x0A -#define BOOT_ENCODING_BOOT_CTRL_GEN_V0 0x0B -#define BOOT_ENCODING_BOOT_CTRL_GEN_V1 0x0C -#define BOOT_ENCODING_DATA_ABORT 0x0D +#define BOOT_ENCODING_HBM_TRAINING 0x01 +#define BOOT_ENCODING_FW_LOAD 0x04 +#define BOOT_ENCODING_WAFL_LINK 0x05 +#define BOOT_ENCODING_XGMI_LINK 0x06 +#define BOOT_ENCODING_USR_CP_LINK 0x07 +#define BOOT_ENCODING_USR_DP_LINK 0x08 +#define BOOT_ENCODING_HBM_MEM_TEST 0x09 +#define BOOT_ENCODING_HBM_BIST_TEST 0x0A +#define BOOT_ENCODING_BOOT_CTRL_GEN_V0 0x0B +#define BOOT_ENCODING_BOOT_CTRL_GEN_V1 0x0C +#define BOOT_ENCODING_DATA_ABORT 0x0D /** * @brief HBM stack decoder constants */ -#define HBM_STACK_0 0x01 -#define HBM_STACK_1 0x02 -#define HBM_STACK_UNKNOWN -1 +#define HBM_STACK_0 0x01 +#define HBM_STACK_1 0x02 +#define HBM_STACK_UNKNOWN -1 /** * @brief Extract specific byte from 64-bit value @@ -90,7 +91,7 @@ typedef struct { * @return Extracted byte value */ static inline uint8_t extract_byte(uint64_t value, int byte_index) { - return (uint8_t)((value >> (byte_index * 8)) & 0xFF); + return (uint8_t)((value >> (byte_index * 8)) & 0xFF); } /** @@ -98,9 +99,7 @@ static inline uint8_t extract_byte(uint64_t value, int byte_index) { * @param num_bits Number of bits to extract * @return Bit mask */ -static inline uint32_t extract_bits(int num_bits) { - return (1U << num_bits) - 1; -} +static inline uint32_t extract_bits(int num_bits) { return (1U << num_bits) - 1; } /** * @brief Get boot version from boot message @@ -159,7 +158,7 @@ int decode_hbm_stack(uint8_t stack); * @param max_links Maximum number of links to check * @return JsonValue array or NULL on failure */ -JsonValue* create_failed_links_array(uint8_t byte_value, int max_links); +JsonValue *create_failed_links_array(uint8_t byte_value, int max_links); /** * @brief Create hex string representation @@ -167,35 +166,35 @@ JsonValue* create_failed_links_array(uint8_t byte_value, int max_links); * @param width Width of hex string (with padding) * @return Dynamically allocated hex string or NULL on failure */ -char* create_hex_string(uint64_t value, int width); +char *create_hex_string(uint64_t value, int width); // Decoder functions for Version 0 -JsonValue* decode_hbm_training_v0(OamBootMsg *msg); -JsonValue* decode_fw_load_v0(OamBootMsg *msg); -JsonValue* decode_wafl_link_training_v0(OamBootMsg *msg); -JsonValue* decode_xgmi_link_training_v0(OamBootMsg *msg); -JsonValue* decode_usr_cp_link_training_v0(OamBootMsg *msg); -JsonValue* decode_usr_dp_link_training_v0(OamBootMsg *msg); -JsonValue* decode_hbm_mem_test_v0(OamBootMsg *msg); -JsonValue* decode_hbm_bist_test_v0(OamBootMsg *msg); -JsonValue* decode_boot_controller_generic_v0(OamBootMsg *msg); +JsonValue *decode_hbm_training_v0(OamBootMsg *msg); +JsonValue *decode_fw_load_v0(OamBootMsg *msg); +JsonValue *decode_wafl_link_training_v0(OamBootMsg *msg); +JsonValue *decode_xgmi_link_training_v0(OamBootMsg *msg); +JsonValue *decode_usr_cp_link_training_v0(OamBootMsg *msg); +JsonValue *decode_usr_dp_link_training_v0(OamBootMsg *msg); +JsonValue *decode_hbm_mem_test_v0(OamBootMsg *msg); +JsonValue *decode_hbm_bist_test_v0(OamBootMsg *msg); +JsonValue *decode_boot_controller_generic_v0(OamBootMsg *msg); // Decoder functions for Version 1 -JsonValue* decode_hbm_training_v1(OamBootMsg *msg); -JsonValue* decode_fw_load_v1(OamBootMsg *msg); -JsonValue* decode_wafl_link_training_v1(OamBootMsg *msg); -JsonValue* decode_xgmi_link_training_v1(OamBootMsg *msg); -JsonValue* decode_usr_cp_link_training_v1(OamBootMsg *msg); -JsonValue* decode_usr_dp_link_training_v1(OamBootMsg *msg); -JsonValue* decode_hbm_mem_test_v1(OamBootMsg *msg); -JsonValue* decode_hbm_bist_test_v1(OamBootMsg *msg); -JsonValue* decode_boot_controller_generic_v1(OamBootMsg *msg); -JsonValue* decode_data_abort_v1(OamBootMsg *msg); -JsonValue* decode_boot_success_v1(OamBootMsg *msg); +JsonValue *decode_hbm_training_v1(OamBootMsg *msg); +JsonValue *decode_fw_load_v1(OamBootMsg *msg); +JsonValue *decode_wafl_link_training_v1(OamBootMsg *msg); +JsonValue *decode_xgmi_link_training_v1(OamBootMsg *msg); +JsonValue *decode_usr_cp_link_training_v1(OamBootMsg *msg); +JsonValue *decode_usr_dp_link_training_v1(OamBootMsg *msg); +JsonValue *decode_hbm_mem_test_v1(OamBootMsg *msg); +JsonValue *decode_hbm_bist_test_v1(OamBootMsg *msg); +JsonValue *decode_boot_controller_generic_v1(OamBootMsg *msg); +JsonValue *decode_data_abort_v1(OamBootMsg *msg); +JsonValue *decode_boot_success_v1(OamBootMsg *msg); // Unhandled error decoders -JsonValue* decode_unhandled_error_v0(OamBootMsg *msg); -JsonValue* decode_unhandled_error_v1(OamBootMsg *msg); +JsonValue *decode_unhandled_error_v0(OamBootMsg *msg); +JsonValue *decode_unhandled_error_v1(OamBootMsg *msg); /** * @brief Get appropriate decoder function for boot message @@ -210,7 +209,7 @@ boot_decoder_func_t get_decoder_function(OamBootMsg *msg); * @param count Number of boot messages * @return JsonValue object containing decoded results or NULL on failure */ -JsonValue* boot_decode_orchestrator(uint64_t *oam_boot_msgs, size_t count); +JsonValue *boot_decode_orchestrator(const uint64_t *oam_boot_msgs, size_t count); #ifdef __cplusplus } diff --git a/include/ras-decode/error_map.h b/include/ras-decode/error_map.h index 0c8c555390..6a5b97bb27 100644 --- a/include/ras-decode/error_map.h +++ b/include/ras-decode/error_map.h @@ -28,13 +28,12 @@ /** * @brief Structure representing an error mapping entry */ -typedef struct -{ - uint32_t id; - const char *error_category; - const char *error_type; - const char *method; - const char *error_severity; +typedef struct { + uint32_t id; + const char *error_category; + const char *error_type; + const char *method; + const char *error_severity; } error_map_entry_t; /** diff --git a/include/ras-decode/json_util.h b/include/ras-decode/json_util.h index 24e358262f..06711342a6 100644 --- a/include/ras-decode/json_util.h +++ b/include/ras-decode/json_util.h @@ -33,14 +33,7 @@ extern "C" { /** * @brief JSON value types enumeration */ -typedef enum { - JSON_NULL, - JSON_BOOL, - JSON_NUMBER, - JSON_STRING, - JSON_OBJECT, - JSON_ARRAY -} JsonType; +typedef enum { JSON_NULL, JSON_BOOL, JSON_NUMBER, JSON_STRING, JSON_OBJECT, JSON_ARRAY } JsonType; typedef struct JsonValue JsonValue; typedef struct JsonPair JsonPair; @@ -49,67 +42,67 @@ typedef struct JsonPair JsonPair; * @brief JSON key-value pair structure for objects */ struct JsonPair { - char *key; - JsonValue *value; - JsonPair *next; + char *key; + JsonValue *value; + JsonPair *next; }; /** * @brief JSON value structure */ struct JsonValue { - JsonType type; - union { - bool boolean; - double number; - char *string; - JsonPair *object; // Linked list of key-value pairs - struct { - JsonValue **items; - size_t count; - size_t capacity; - } array; - } data; + JsonType type; + union { + bool boolean; + double number; + char *string; + JsonPair *object; // Linked list of key-value pairs + struct { + JsonValue **items; + size_t count; + size_t capacity; + } array; + } data; }; /** * @brief Create a null JSON value * @return Pointer to new JsonValue or NULL on failure */ -JsonValue* json_create_null(void); +JsonValue *json_create_null(void); /** * @brief Create a boolean JSON value * @param b Boolean value * @return Pointer to new JsonValue or NULL on failure */ -JsonValue* json_create_bool(bool b); +JsonValue *json_create_bool(bool b); /** * @brief Create a number JSON value * @param num Numeric value * @return Pointer to new JsonValue or NULL on failure */ -JsonValue* json_create_number(double num); +JsonValue *json_create_number(double num); /** * @brief Create a string JSON value * @param str String value (will be copied) * @return Pointer to new JsonValue or NULL on failure */ -JsonValue* json_create_string(const char *str); +JsonValue *json_create_string(const char *str); /** * @brief Create an empty JSON object * @return Pointer to new JsonValue or NULL on failure */ -JsonValue* json_create_object(void); +JsonValue *json_create_object(void); /** * @brief Create an empty JSON array * @return Pointer to new JsonValue or NULL on failure */ -JsonValue* json_create_array(void); +JsonValue *json_create_array(void); /** * @brief Add a key-value pair to a JSON object @@ -125,7 +118,7 @@ void json_object_set(JsonValue *obj, const char *key, JsonValue *value); * @param key Key to search for * @return Pointer to JsonValue or NULL if not found */ -JsonValue* json_object_get(JsonValue *obj, const char *key); +JsonValue *json_object_get(JsonValue *obj, const char *key); /** * @brief Check if a key exists in a JSON object @@ -149,7 +142,7 @@ bool json_array_push(JsonValue *arr, JsonValue *value); * @param index Array index * @return Pointer to JsonValue or NULL if index out of bounds */ -JsonValue* json_array_get(JsonValue *arr, size_t index); +JsonValue *json_array_get(JsonValue *arr, size_t index); /** * @brief Get the size of a JSON array diff --git a/include/ras-decode/ras_decode_api.h b/include/ras-decode/ras_decode_api.h index 8477a60772..4170f5c162 100644 --- a/include/ras-decode/ras_decode_api.h +++ b/include/ras-decode/ras_decode_api.h @@ -23,31 +23,31 @@ #ifndef RAS_DECODE_API_H #define RAS_DECODE_API_H -#include #include +#include + #include "aca_version.h" #include "json_util.h" /** * @brief Structure containing decoded error information */ -typedef struct -{ - const char *bank_ref; /**< Reference to bank name string */ - const char *error_type_ref; /**< Reference to error type string */ - const char *severity_ref; /**< Reference to error severity string */ - const char *category_ref; /**< Reference to error category string */ - const char *instance_ref; /**< Reference to instance name string */ - int oam; /**< OAM value */ - int aid; /**< AID value */ - uint64_t raw_status; /**< Raw status register value */ - uint64_t raw_addr; /**< Raw address register value */ - uint64_t raw_ipid; /**< Raw IPID register value */ - uint64_t raw_synd; /**< Raw syndrome register value */ - uint8_t scrub; /**< Scrub bit from status */ - uint8_t poison; /**< Poison bit from status */ - uint8_t deferred; /**< Deferred bit from status */ - uint8_t error_code_ext; /**< Extended error code from status */ +typedef struct { + const char *bank_ref; /**< Reference to bank name string */ + const char *error_type_ref; /**< Reference to error type string */ + const char *severity_ref; /**< Reference to error severity string */ + const char *category_ref; /**< Reference to error category string */ + const char *instance_ref; /**< Reference to instance name string */ + int oam; /**< OAM value */ + int aid; /**< AID value */ + uint64_t raw_status; /**< Raw status register value */ + uint64_t raw_addr; /**< Raw address register value */ + uint64_t raw_ipid; /**< Raw IPID register value */ + uint64_t raw_synd; /**< Raw syndrome register value */ + uint8_t scrub; /**< Scrub bit from status */ + uint8_t poison; /**< Poison bit from status */ + uint8_t deferred; /**< Deferred bit from status */ + uint8_t error_code_ext; /**< Extended error code from status */ } aca_error_info_t; /** @@ -56,10 +56,12 @@ typedef struct * @param[in] array_len Size of register array in elements * @param[in] flag Decoder flags * @param[in] hw_revision Hardware revision number - * @param[in] register_context_type Register context type (16-bit): 1 for ACA decode, 9 for boot decode + * @param[in] register_context_type Register context type (16-bit): 1 for ACA decode, 9 for boot + * decode * @return AFID value or -1 if decoding fails */ -int decode_afid(const uint64_t *register_array, size_t array_len, uint32_t flag, uint16_t hw_revision, uint16_t register_context_type); +int decode_afid(const uint64_t *register_array, size_t array_len, uint32_t flag, + uint16_t hw_revision, uint16_t register_context_type); /** * @brief Decodes and returns complete error information from a register array as JSON @@ -67,10 +69,12 @@ int decode_afid(const uint64_t *register_array, size_t array_len, uint32_t flag, * @param[in] array_len Size of register array in elements * @param[in] flag Decoder flags * @param[in] hw_revision Hardware revision number - * @param[in] register_context_type Register context type (16-bit): 1 for ACA decode, 9 for boot decode + * @param[in] register_context_type Register context type (16-bit): 1 for ACA decode, 9 for boot + * decode * @return JsonValue* containing complete error information, or NULL on failure */ -JsonValue* decode_error_info(const uint64_t *register_array, size_t array_len, uint32_t flag, uint16_t hw_revision, uint16_t register_context_type); +JsonValue *decode_error_info(const uint64_t *register_array, size_t array_len, uint32_t flag, + uint16_t hw_revision, uint16_t register_context_type); /** * @brief Decodes the AFID from a JSON error object based on error category, type, and severity @@ -79,4 +83,4 @@ JsonValue* decode_error_info(const uint64_t *register_array, size_t array_len, u */ int decode_error_info_afid(JsonValue *error_json); -#endif // RAS_DECODE_API_H +#endif // RAS_DECODE_API_H diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 21e1c331e2..17f21925a1 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -45,32 +45,33 @@ set(INC_LIST "${PROJECT_SOURCE_DIR}/rocm_smi/include/rocm_smi/rocm_smi_utils.h") set(RAS_DECODE "ras-decode") -set(ACA_SRC_DIR "${PROJECT_SOURCE_DIR}/src/${RAS_DECODE}") -set(SRC_LIST ${SRC_LIST} - ${ACA_SRC_DIR}/aca_decode.c - ${ACA_SRC_DIR}/aca_fields.c - ${ACA_SRC_DIR}/aca_tables.c - ${ACA_SRC_DIR}/aca_version.c - ${ACA_SRC_DIR}/boot_decode.c - ${ACA_SRC_DIR}/error_map.c - ${ACA_SRC_DIR}/json_printer.c - ${ACA_SRC_DIR}/json_util.c - # ${ACA_SRC_DIR}/main.c - ${ACA_SRC_DIR}/ras_decode_api.c -) -set(ACA_INC_DIR "${PROJECT_SOURCE_DIR}/include/${RAS_DECODE}") -set(INC_LIST ${INC_LIST} - ${ACA_INC_DIR}/aca_decode.h - ${ACA_INC_DIR}/aca_fields.h - ${ACA_INC_DIR}/aca_tables.h - ${ACA_INC_DIR}/aca_version.h - ${ACA_INC_DIR}/boot_decode.h - ${ACA_INC_DIR}/error_map.h - ${ACA_INC_DIR}/json_printer.h - ${ACA_INC_DIR}/json_util.h - ${ACA_INC_DIR}/ras_decode_api.h - ${ACA_INC_DIR}/ras_decode_constants.h -) +set(RAS_DECODE_REPO "git@github.amd.com:dctools/ras-decode-instinct-staging.git") +set(RAS_DECODE_SRC_DIR "${PROJECT_SOURCE_DIR}/src/${RAS_DECODE}") +set(RAS_DECODE_INC_DIR "${PROJECT_SOURCE_DIR}/include/${RAS_DECODE}") +find_package(Git QUIET) +if(GIT_FOUND) + add_custom_target( + ${RAS_DECODE} + COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_CURRENT_BINARY_DIR}/${RAS_DECODE} + COMMAND ${GIT_EXECUTABLE} clone ${RAS_DECODE_REPO} -b main ${CMAKE_CURRENT_BINARY_DIR}/${RAS_DECODE} + COMMAND ${CMAKE_COMMAND} -E remove_directory ${RAS_DECODE_SRC_DIR} + COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_BINARY_DIR}/${RAS_DECODE}/src ${RAS_DECODE_SRC_DIR} + COMMAND ${CMAKE_COMMAND} -E remove_directory ${RAS_DECODE_INC_DIR} + COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_BINARY_DIR}/${RAS_DECODE}/include ${RAS_DECODE_INC_DIR} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Cloning ${RAS_DECODE_REPO} from GitHub" + VERBATIM + ) +else() + message(WARNING "Git not found, cannot clone ${RAS_DECODE_REPO}.") +endif() +file(GLOB RAS_DECODE_INCLUDES "${RAS_DECODE_INC_DIR}/*.h") +file(GLOB RAS_DECODE_SOURCES "${RAS_DECODE_SRC_DIR}/*.c") +list(REMOVE_ITEM RAS_DECODE_SOURCES "main.c") + +set(SRC_LIST ${SRC_LIST} ${RAS_DECODE_SOURCES}) +set(INC_LIST ${INC_LIST} ${RAS_DECODE_INCLUDES}) + if(ENABLE_ESMI_LIB) list(APPEND INC_LIST ${ESMI_INC_DIR}/e_smi/e_smi.h) list(APPEND INC_LIST ${ESMI_INC_DIR}/e_smi/e_smi_monitor.h) @@ -92,7 +93,7 @@ target_include_directories(${AMD_SMI} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${PROJECT_SOURCE_DIR}/rocm_smi/include ${PROJECT_SOURCE_DIR}/common/shared_mutex - ${ACA_INC_DIR} + ${RAS_DECODE_INC_DIR} ${DRM_INCLUDE_DIRS} ${DRM_AMDGPU_INCLUDE_DIRS} ) diff --git a/src/ras-decode/aca_decode.c b/src/ras-decode/aca_decode.c index a7d91ea919..9254e38ee8 100644 --- a/src/ras-decode/aca_decode.c +++ b/src/ras-decode/aca_decode.c @@ -30,13 +30,15 @@ */ #include "aca_decode.h" + +#include +#include +#include + #include "aca_tables.h" #include "error_map.h" -#include "ras_decode_constants.h" #include "json_util.h" -#include -#include -#include +#include "ras_decode_constants.h" /** * @brief Gets the bank name based on hardware ID and ACA type @@ -44,75 +46,63 @@ * @param[out] bank_name Pointer to a string containing the bank name * @return 0 on success, -1 on failure */ -static int -aca_decoder_get_bank(const aca_decoder_t *decoder, const char **bank_name) -{ - if (!decoder || !bank_name) - { - return -1; - } +static int aca_decoder_get_bank(const aca_decoder_t *decoder, const char **bank_name) { + if (!decoder || !bank_name) { + return -1; + } - const aca_ipid_fields_t *ipid = &decoder->ipid; - return find_bank_name(ipid->hardware_id, ipid->aca_type, bank_name); + const aca_ipid_fields_t *ipid = &decoder->ipid; + return find_bank_name(ipid->hardware_id, ipid->aca_type, bank_name); } /** * @brief Determines the error severity based on status fields * @param[in] status Pointer to the ACA status fields structure - * @return String indicating error severity: "Fatal", "Uncorrected, Non-fatal", "Corrected", or "UNKNOWN" + * @return String indicating error severity: "Fatal", "Uncorrected, Non-fatal", "Corrected", or + * "UNKNOWN" */ -static const char *get_error_severity(const aca_status_fields_t *status) -{ - if (status->poison) - return RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL; - if (status->pcc) - return RAS_DECODE_SEVERITY_FATAL; - if (!status->pcc && status->uc && status->tcc) - return RAS_DECODE_SEVERITY_FATAL; - if (!status->pcc && status->uc && !status->tcc) - return RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL; - if (!status->pcc && !status->uc && !status->tcc && status->deferred) - return RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL; - if (!status->pcc && !status->uc && !status->tcc && !status->deferred) - return RAS_DECODE_SEVERITY_CORRECTED; - return RAS_DECODE_SEVERITY_UNKNOWN; +static const char *get_error_severity(const aca_status_fields_t *status) { + if (status->poison) return RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL; + if (status->pcc) return RAS_DECODE_SEVERITY_FATAL; + if (!status->pcc && status->uc && status->tcc) return RAS_DECODE_SEVERITY_FATAL; + if (!status->pcc && status->uc && !status->tcc) return RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL; + if (!status->pcc && !status->uc && !status->tcc && status->deferred) + return RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL; + if (!status->pcc && !status->uc && !status->tcc && !status->deferred) + return RAS_DECODE_SEVERITY_CORRECTED; + return RAS_DECODE_SEVERITY_UNKNOWN; } /** * @brief Determines the error category based on bank and error type * @param[in] bank Pointer to the bank name * @param[in] error_type Pointer to the error type - * @return String indicating error category: "HBM Errors", "Off-Package Link Errors", or "Device Internal Errors" + * @return String indicating error category: "HBM Errors", "Off-Package Link Errors", or "Device + * Internal Errors" */ -static const char *get_error_category(const char *bank, const char *error_type) -{ - if (!bank || !error_type) - { - return RAS_DECODE_SEVERITY_UNKNOWN; - } +static const char *get_error_category(const char *bank, const char *error_type) { + if (!bank || !error_type) { + return RAS_DECODE_SEVERITY_UNKNOWN; + } - if (strcmp(bank, RAS_DECODE_BANK_UMC) == 0) - { - if (strcmp(error_type, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC) == 0 || - strcmp(error_type, "WriteDataPoisonErr") == 0 || - strcmp(error_type, "AddressCommandParityErr") == 0 || - strcmp(error_type, "WriteDataCrcErr") == 0 || - strcmp(error_type, "EcsErr") == 0 || - strcmp(error_type, "RdCrcErr") == 0 || - strcmp(error_type, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC) == 0) - { - return RAS_DECODE_CATEGORY_HBM_ERRORS; - } + if (strcmp(bank, RAS_DECODE_BANK_UMC) == 0) { + if (strcmp(error_type, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC) == 0 || + strcmp(error_type, "WriteDataPoisonErr") == 0 || + strcmp(error_type, "AddressCommandParityErr") == 0 || + strcmp(error_type, "WriteDataCrcErr") == 0 || strcmp(error_type, "EcsErr") == 0 || + strcmp(error_type, "RdCrcErr") == 0 || + strcmp(error_type, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC) == 0) { + return RAS_DECODE_CATEGORY_HBM_ERRORS; } - else if (strcmp(bank, RAS_DECODE_BANK_PCS_XGMI) == 0 || + } else if (strcmp(bank, RAS_DECODE_BANK_PCS_XGMI) == 0 || strcmp(bank, RAS_DECODE_BANK_KPX_SERDES) == 0 || strcmp(bank, RAS_DECODE_BANK_KPX_WAFL) == 0 || - (strcmp(bank, RAS_DECODE_BANK_PSP) == 0 && strcmp(error_type, RAS_DECODE_ERROR_TYPE_WAFL) == 0)) - { - return RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS; - } + (strcmp(bank, RAS_DECODE_BANK_PSP) == 0 && + strcmp(error_type, RAS_DECODE_ERROR_TYPE_WAFL) == 0)) { + return RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS; + } - return RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS; + return RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS; } /** @@ -124,64 +114,57 @@ static const char *get_error_category(const char *bank, const char *error_type) * @param[out] service_error_type Pointer to store the resulting service error type string * @return 0 on success, non-zero on failure */ -static int get_service_error_type(const char *error_category, const char *error_bank, const char *error_type, - const char *error_severity, const char **service_error_type) -{ - if (!error_category || !error_type || !error_severity || !service_error_type || - strcmp(error_category, RAS_DECODE_SEVERITY_UNKNOWN) == 0 || - strcmp(error_type, RAS_DECODE_SEVERITY_UNKNOWN) == 0 || - strcmp(error_severity, RAS_DECODE_SEVERITY_UNKNOWN) == 0) - { - return -1; - } - if (strcmp(error_type, RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD) == 0) - { - *service_error_type = RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD; - return 0; - } - if ((strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0) && (strcmp(error_severity, RAS_DECODE_SEVERITY_CORRECTED) == 0)) - { - *service_error_type = RAS_DECODE_ERROR_TYPE_ALL; - return 0; - } - if (strcmp(error_type, "RdCrcErr") == 0) - { - *service_error_type = RAS_DECODE_ERROR_TYPE_END_TO_END_CRC; - return 0; - } - if ((strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0) && (strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0) && - (strcmp(error_type, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC) != 0) && (strcmp(error_type, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC) != 0)) - { - *service_error_type = RAS_DECODE_ERROR_TYPE_ALL_OTHERS; - return 0; - } - if (strcmp(error_category, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS) == 0) - { - if ((strcmp(error_severity, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL) == 0 || - strcmp(error_severity, RAS_DECODE_SEVERITY_CORRECTED) == 0 || - strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0) && - strcmp(error_type, RAS_DECODE_ERROR_TYPE_HARDWARE_ASSERTION) != 0 && - strcmp(error_type, RAS_DECODE_ERROR_TYPE_WATCHDOG_TIMEOUT) != 0) - { - *service_error_type = RAS_DECODE_ERROR_TYPE_ALL_OTHERS; - return 0; - } - } - if (strcmp(error_category, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS) == 0) - { - if (strcmp(error_bank, RAS_DECODE_BANK_PCS_XGMI) == 0) - { - *service_error_type = RAS_DECODE_ERROR_TYPE_XGMI; - return 0; - } - if (strcmp(error_bank, RAS_DECODE_BANK_KPX_WAFL) == 0) - { - *service_error_type = RAS_DECODE_ERROR_TYPE_WAFL; - return 0; - } - } - +static int get_service_error_type(const char *error_category, const char *error_bank, + const char *error_type, const char *error_severity, + const char **service_error_type) { + if (!error_category || !error_type || !error_severity || !service_error_type || + strcmp(error_category, RAS_DECODE_SEVERITY_UNKNOWN) == 0 || + strcmp(error_type, RAS_DECODE_SEVERITY_UNKNOWN) == 0 || + strcmp(error_severity, RAS_DECODE_SEVERITY_UNKNOWN) == 0) { return -1; + } + if (strcmp(error_type, RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD) == 0) { + *service_error_type = RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD; + return 0; + } + if ((strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0) && + (strcmp(error_severity, RAS_DECODE_SEVERITY_CORRECTED) == 0)) { + *service_error_type = RAS_DECODE_ERROR_TYPE_ALL; + return 0; + } + if (strcmp(error_type, "RdCrcErr") == 0) { + *service_error_type = RAS_DECODE_ERROR_TYPE_END_TO_END_CRC; + return 0; + } + if ((strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0) && + (strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0) && + (strcmp(error_type, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC) != 0) && + (strcmp(error_type, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC) != 0)) { + *service_error_type = RAS_DECODE_ERROR_TYPE_ALL_OTHERS; + return 0; + } + if (strcmp(error_category, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS) == 0) { + if ((strcmp(error_severity, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL) == 0 || + strcmp(error_severity, RAS_DECODE_SEVERITY_CORRECTED) == 0 || + strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0) && + strcmp(error_type, RAS_DECODE_ERROR_TYPE_HARDWARE_ASSERTION) != 0 && + strcmp(error_type, RAS_DECODE_ERROR_TYPE_WATCHDOG_TIMEOUT) != 0) { + *service_error_type = RAS_DECODE_ERROR_TYPE_ALL_OTHERS; + return 0; + } + } + if (strcmp(error_category, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS) == 0) { + if (strcmp(error_bank, RAS_DECODE_BANK_PCS_XGMI) == 0) { + *service_error_type = RAS_DECODE_ERROR_TYPE_XGMI; + return 0; + } + if (strcmp(error_bank, RAS_DECODE_BANK_KPX_WAFL) == 0) { + *service_error_type = RAS_DECODE_ERROR_TYPE_WAFL; + return 0; + } + } + + return -1; } /** @@ -189,117 +172,94 @@ static int get_service_error_type(const char *error_category, const char *error_ * @param[in] decoder Pointer to the ACA decoder structure * @param[out] info Pointer to the error info structure to be populated */ -static void aca_decoder_get_error_info(const aca_decoder_t *decoder, aca_error_info_t *info) -{ - const char *bank; - const char *error_type; - const char *instance_name; - int result; - - info->raw_status = decoder->aca_status; - info->raw_addr = decoder->aca_addr; - info->raw_ipid = decoder->aca_ipid; - info->raw_synd = decoder->aca_synd; - - info->scrub = decoder->status.scrub; - info->poison = decoder->status.poison; - info->deferred = decoder->status.deferred; - info->error_code_ext = decoder->status.error_code_ext; +static void aca_decoder_get_error_info(const aca_decoder_t *decoder, aca_error_info_t *info) { + const char *bank; + const char *error_type; + const char *instance_name; + int result; + info->raw_status = decoder->aca_status; + info->raw_addr = decoder->aca_addr; + info->raw_ipid = decoder->aca_ipid; + info->raw_synd = decoder->aca_synd; - result = aca_decoder_get_bank(decoder, &bank); - if (result < 0) - { - bank = RAS_DECODE_SEVERITY_UNKNOWN; - } - info->bank_ref = bank; + info->scrub = decoder->status.scrub; + info->poison = decoder->status.poison; + info->deferred = decoder->status.deferred; + info->error_code_ext = decoder->status.error_code_ext; - if (find_instance_name(bank, decoder->ipid.instance_id_lo, &instance_name) == 0) - { - info->instance_ref = instance_name; - } - else - { - info->instance_ref = RAS_DECODE_ERROR_TYPE_DECODE_INAPPLICABLE; - } + result = aca_decoder_get_bank(decoder, &bank); + if (result < 0) { + bank = RAS_DECODE_SEVERITY_UNKNOWN; + } + info->bank_ref = bank; - // 0b1000 indicate error threshold has been exceeded, and is always fatal - if (decoder->flags & RAS_DECODE_FLAG_THRESHOLD_EXCEEDED) - { - info->severity_ref = RAS_DECODE_SEVERITY_FATAL; - } - else - { - info->severity_ref = get_error_severity(&decoder->status); - } + if (find_instance_name(bank, decoder->ipid.instance_id_lo, &instance_name) == 0) { + info->instance_ref = instance_name; + } else { + info->instance_ref = RAS_DECODE_ERROR_TYPE_DECODE_INAPPLICABLE; + } - // Decode OAM and AID from instance_id_lo - oam_aid_map_t oam_aid = {0}; - uint8_t instance_id_lo = decoder->ipid.instance_id_lo & 0xFF; // Get lower 8 bits - if (find_oam_aid(instance_id_lo, &oam_aid) == 0) - { - info->oam = oam_aid.oam; - info->aid = oam_aid.aid; - } - else - { - info->oam = -1; // Invalid value - info->aid = -1; // Invalid value - } + // 0b1000 indicate error threshold has been exceeded, and is always fatal + if (decoder->flags & RAS_DECODE_FLAG_THRESHOLD_EXCEEDED) { + info->severity_ref = RAS_DECODE_SEVERITY_FATAL; + } else { + info->severity_ref = get_error_severity(&decoder->status); + } - if (decoder->status.error_code_ext >= RAS_DECODE_ERROR_CODE_EXT_MIN && decoder->status.error_code_ext <= RAS_DECODE_ERROR_CODE_EXT_MAX) - { - uint32_t instance_id = decoder->ipid.instance_id_lo; - uint32_t error_info = decoder->synd.error_information & 0xFF; + // Decode OAM and AID from instance_id_lo + oam_aid_map_t oam_aid = {0}; + uint8_t instance_id_lo = decoder->ipid.instance_id_lo & 0xFF; // Get lower 8 bits + if (find_oam_aid(instance_id_lo, &oam_aid) == 0) { + info->oam = oam_aid.oam; + info->aid = oam_aid.aid; + } else { + info->oam = -1; // Invalid value + info->aid = -1; // Invalid value + } - if ((instance_id == RAS_DECODE_INSTANCE_ID_XCD0_400 || instance_id == RAS_DECODE_INSTANCE_ID_XCD1_400 || - instance_id == RAS_DECODE_INSTANCE_ID_XCD0_401 || instance_id == RAS_DECODE_INSTANCE_ID_XCD1_401) && - find_error_in_table(xcd_error_table, NUM_XCD_ERRORS, error_info, &error_type) == 0) - { - info->error_type_ref = error_type; - } - else if ((instance_id == RAS_DECODE_INSTANCE_ID_AID_400 || instance_id == RAS_DECODE_INSTANCE_ID_AID_401) && - find_error_in_table(aid_error_table, NUM_AID_ERRORS, error_info, &error_type) == 0) - { - info->error_type_ref = error_type; - } - else - { - info->error_type_ref = RAS_DECODE_SEVERITY_UNKNOWN; - } - } - // 0b1000 indicate error threshold has been exceeded - else if (decoder->flags & RAS_DECODE_FLAG_THRESHOLD_EXCEEDED) - { - info->error_type_ref = RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD; - } - else - { - if (find_error_type_by_bank(bank, decoder->status.error_code_ext, &error_type) == 0) - { - info->error_type_ref = error_type; - } - else - { - info->error_type_ref = RAS_DECODE_SEVERITY_UNKNOWN; - } - } + if (decoder->status.error_code_ext >= RAS_DECODE_ERROR_CODE_EXT_MIN && + decoder->status.error_code_ext <= RAS_DECODE_ERROR_CODE_EXT_MAX) { + uint32_t instance_id = decoder->ipid.instance_id_lo; + uint32_t error_info = decoder->synd.error_information & 0xFF; - // 0b1000 indicate error threshold has been exceeded, and is always a HBM error - if (decoder->flags & RAS_DECODE_FLAG_THRESHOLD_EXCEEDED) - { - info->category_ref = RAS_DECODE_CATEGORY_HBM_ERRORS; + if ((instance_id == RAS_DECODE_INSTANCE_ID_XCD0_400 || + instance_id == RAS_DECODE_INSTANCE_ID_XCD1_400 || + instance_id == RAS_DECODE_INSTANCE_ID_XCD0_401 || + instance_id == RAS_DECODE_INSTANCE_ID_XCD1_401) && + find_error_in_table(xcd_error_table, NUM_XCD_ERRORS, error_info, &error_type) == 0) { + info->error_type_ref = error_type; + } else if ((instance_id == RAS_DECODE_INSTANCE_ID_AID_400 || + instance_id == RAS_DECODE_INSTANCE_ID_AID_401) && + find_error_in_table(aid_error_table, NUM_AID_ERRORS, error_info, &error_type) == 0) { + info->error_type_ref = error_type; + } else { + info->error_type_ref = RAS_DECODE_SEVERITY_UNKNOWN; } - else - { - info->category_ref = get_error_category(bank, info->error_type_ref); + } + // 0b1000 indicate error threshold has been exceeded + else if (decoder->flags & RAS_DECODE_FLAG_THRESHOLD_EXCEEDED) { + info->error_type_ref = RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD; + } else { + if (find_error_type_by_bank(bank, decoder->status.error_code_ext, &error_type) == 0) { + info->error_type_ref = error_type; + } else { + info->error_type_ref = RAS_DECODE_SEVERITY_UNKNOWN; } + } - const char *service_error; - if (get_service_error_type(info->category_ref, info->bank_ref, info->error_type_ref, info->severity_ref, &service_error) != 0) - { - service_error = info->error_type_ref; - } + // 0b1000 indicate error threshold has been exceeded, and is always a HBM error + if (decoder->flags & RAS_DECODE_FLAG_THRESHOLD_EXCEEDED) { + info->category_ref = RAS_DECODE_CATEGORY_HBM_ERRORS; + } else { + info->category_ref = get_error_category(bank, info->error_type_ref); + } + + const char *service_error; + if (get_service_error_type(info->category_ref, info->bank_ref, info->error_type_ref, + info->severity_ref, &service_error) != 0) { + service_error = info->error_type_ref; + } } /** @@ -312,19 +272,18 @@ static void aca_decoder_get_error_info(const aca_decoder_t *decoder, aca_error_i * @param[in] synd_reg Raw syndrome register value */ static void aca_decoder_init(aca_decoder_t *decoder, uint16_t hw_revision, uint32_t flags, - uint64_t status_reg, uint64_t ipid_reg, uint64_t synd_reg) -{ - memset(decoder, 0, sizeof(aca_decoder_t)); + uint64_t status_reg, uint64_t ipid_reg, uint64_t synd_reg) { + memset(decoder, 0, sizeof(aca_decoder_t)); - decoder->hw_revision = hw_revision; - decoder->flags = flags; - decoder->aca_status = status_reg; - decoder->aca_ipid = ipid_reg; - decoder->aca_synd = synd_reg; + decoder->hw_revision = hw_revision; + decoder->flags = flags; + decoder->aca_status = status_reg; + decoder->aca_ipid = ipid_reg; + decoder->aca_synd = synd_reg; - aca_status_init(&decoder->status, status_reg); - aca_ipid_init(&decoder->ipid, ipid_reg); - aca_synd_init(&decoder->synd, synd_reg); + aca_status_init(&decoder->status, status_reg); + aca_ipid_init(&decoder->ipid, ipid_reg); + aca_synd_init(&decoder->synd, synd_reg); } /** @@ -332,85 +291,80 @@ static void aca_decoder_init(aca_decoder_t *decoder, uint16_t hw_revision, uint3 * @param[in] raw_data Pointer to structure containing raw ACA error data * @return JsonValue* containing the decoded error information, or NULL on failure */ -JsonValue* aca_decode(const aca_raw_data_t *raw_data) -{ - if (!raw_data) { - return NULL; - } +JsonValue *aca_decode(const aca_raw_data_t *raw_data) { + if (!raw_data) { + return NULL; + } - aca_decoder_t decoder = {0}; - aca_error_info_t info = {0}; + aca_decoder_t decoder = {0}; + aca_error_info_t info = {0}; - aca_decoder_init(&decoder, - raw_data->hw_revision, - raw_data->flags, - raw_data->aca_status, - raw_data->aca_ipid, - raw_data->aca_synd); + aca_decoder_init(&decoder, raw_data->hw_revision, raw_data->flags, raw_data->aca_status, + raw_data->aca_ipid, raw_data->aca_synd); - aca_decoder_get_error_info(&decoder, &info); + aca_decoder_get_error_info(&decoder, &info); - // Create the main JSON object - JsonValue *json_obj = json_create_object(); - if (!json_obj) { - return NULL; - } + // Create the main JSON object + JsonValue *json_obj = json_create_object(); + if (!json_obj) { + return NULL; + } - // Add bank - json_object_set(json_obj, "bank", json_create_string(info.bank_ref)); + // Add bank + json_object_set(json_obj, "bank", json_create_string(info.bank_ref)); - // Create error_location object - JsonValue *error_location = json_create_object(); - if (error_location) { - char oam_str[16], aid_str[16]; - snprintf(oam_str, sizeof(oam_str), "%d", info.oam); - snprintf(aid_str, sizeof(aid_str), "%d", info.aid); - - json_object_set(error_location, "oam", json_create_string(oam_str)); - json_object_set(error_location, "aid", json_create_string(aid_str)); - json_object_set(error_location, "instance", json_create_string(info.instance_ref)); - - json_object_set(json_obj, "error_location", error_location); - } + // Create error_location object + JsonValue *error_location = json_create_object(); + if (error_location) { + char oam_str[16], aid_str[16]; + snprintf(oam_str, sizeof(oam_str), "%d", info.oam); + snprintf(aid_str, sizeof(aid_str), "%d", info.aid); - // Add severity - json_object_set(json_obj, "severity", json_create_string(info.severity_ref)); + json_object_set(error_location, "oam", json_create_string(oam_str)); + json_object_set(error_location, "aid", json_create_string(aid_str)); + json_object_set(error_location, "instance", json_create_string(info.instance_ref)); - // Add scrub as string - char scrub_str[16]; - snprintf(scrub_str, sizeof(scrub_str), "%u", info.scrub); - json_object_set(json_obj, "scrub", json_create_string(scrub_str)); + json_object_set(json_obj, "error_location", error_location); + } - // Add poison as string - char poison_str[16]; - snprintf(poison_str, sizeof(poison_str), "%u", info.poison); - json_object_set(json_obj, "poison", json_create_string(poison_str)); + // Add severity + json_object_set(json_obj, "severity", json_create_string(info.severity_ref)); - // Add deferred as string - char deferred_str[16]; - snprintf(deferred_str, sizeof(deferred_str), "%u", info.deferred); - json_object_set(json_obj, "deferred", json_create_string(deferred_str)); + // Add scrub as string + char scrub_str[16]; + snprintf(scrub_str, sizeof(scrub_str), "%u", info.scrub); + json_object_set(json_obj, "scrub", json_create_string(scrub_str)); - // Add err_ext as string - char err_ext_str[16]; - snprintf(err_ext_str, sizeof(err_ext_str), "%u", info.error_code_ext); - json_object_set(json_obj, "err_ext", json_create_string(err_ext_str)); + // Add poison as string + char poison_str[16]; + snprintf(poison_str, sizeof(poison_str), "%u", info.poison); + json_object_set(json_obj, "poison", json_create_string(poison_str)); - // Add error_category - json_object_set(json_obj, "error_category", json_create_string(info.category_ref)); + // Add deferred as string + char deferred_str[16]; + snprintf(deferred_str, sizeof(deferred_str), "%u", info.deferred); + json_object_set(json_obj, "deferred", json_create_string(deferred_str)); - // Add error_type - json_object_set(json_obj, "error_type", json_create_string(info.error_type_ref)); + // Add err_ext as string + char err_ext_str[16]; + snprintf(err_ext_str, sizeof(err_ext_str), "%u", info.error_code_ext); + json_object_set(json_obj, "err_ext", json_create_string(err_ext_str)); - // Add address as hex string - char address_str[32]; - snprintf(address_str, sizeof(address_str), "0x%" PRIx64, info.raw_addr); - json_object_set(json_obj, "address", json_create_string(address_str)); + // Add error_category + json_object_set(json_obj, "error_category", json_create_string(info.category_ref)); - // Add syndrome as hex string - char syndrome_str[32]; - snprintf(syndrome_str, sizeof(syndrome_str), "0x%" PRIx64, info.raw_synd); - json_object_set(json_obj, "syndrome", json_create_string(syndrome_str)); + // Add error_type + json_object_set(json_obj, "error_type", json_create_string(info.error_type_ref)); - return json_obj; + // Add address as hex string + char address_str[32]; + snprintf(address_str, sizeof(address_str), "0x%" PRIx64, info.raw_addr); + json_object_set(json_obj, "address", json_create_string(address_str)); + + // Add syndrome as hex string + char syndrome_str[32]; + snprintf(syndrome_str, sizeof(syndrome_str), "0x%" PRIx64, info.raw_synd); + json_object_set(json_obj, "syndrome", json_create_string(syndrome_str)); + + return json_obj; } diff --git a/src/ras-decode/aca_fields.c b/src/ras-decode/aca_fields.c index bff878df0e..863be41034 100644 --- a/src/ras-decode/aca_fields.c +++ b/src/ras-decode/aca_fields.c @@ -40,66 +40,60 @@ * @param[in] type The type to cast the extracted bits to * @return The extracted bits as a value of the specified type */ -#define EXTRACT_BITS(value, start, count, type) ((type)(((value) >> (start)) & ((1ULL << (count)) - 1))) +#define EXTRACT_BITS(value, start, count, type) \ + ((type)(((value) >> (start)) & ((1ULL << (count)) - 1))) -uint64_t aca_fields_read(const aca_fields_t *fields) -{ - return fields->raw_value; +uint64_t aca_fields_read(const aca_fields_t *fields) { return fields->raw_value; } + +void aca_status_init(aca_status_fields_t *fields, uint64_t status_reg) { + fields->base.raw_value = status_reg; + fields->error_code = EXTRACT_BITS(status_reg, 0, 16, uint16_t); + fields->error_code_ext = EXTRACT_BITS(status_reg, 16, 6, uint8_t); + fields->reserv22 = EXTRACT_BITS(status_reg, 22, 2, uint8_t); + fields->addr_lsb = EXTRACT_BITS(status_reg, 24, 6, uint8_t); + fields->reserv30 = EXTRACT_BITS(status_reg, 30, 2, uint8_t); + fields->err_core_id = EXTRACT_BITS(status_reg, 32, 6, uint8_t); + fields->reserv38 = EXTRACT_BITS(status_reg, 38, 2, uint8_t); + fields->scrub = EXTRACT_BITS(status_reg, 40, 1, uint8_t); + fields->reserv41 = EXTRACT_BITS(status_reg, 41, 2, uint8_t); + fields->poison = EXTRACT_BITS(status_reg, 43, 1, uint8_t); + fields->deferred = EXTRACT_BITS(status_reg, 44, 1, uint8_t); + fields->uecc = EXTRACT_BITS(status_reg, 45, 1, uint8_t); + fields->cecc = EXTRACT_BITS(status_reg, 46, 1, uint8_t); + fields->reserv47 = EXTRACT_BITS(status_reg, 47, 5, uint8_t); + fields->synd_v = EXTRACT_BITS(status_reg, 53, 1, uint8_t); + fields->reserv54 = EXTRACT_BITS(status_reg, 54, 1, uint8_t); + fields->tcc = EXTRACT_BITS(status_reg, 55, 1, uint8_t); + fields->err_core_id_val = EXTRACT_BITS(status_reg, 56, 1, uint8_t); + fields->pcc = EXTRACT_BITS(status_reg, 57, 1, uint8_t); + fields->addr_v = EXTRACT_BITS(status_reg, 58, 1, uint8_t); + fields->misc_v = EXTRACT_BITS(status_reg, 59, 1, uint8_t); + fields->en = EXTRACT_BITS(status_reg, 60, 1, uint8_t); + fields->uc = EXTRACT_BITS(status_reg, 61, 1, uint8_t); + fields->overflow = EXTRACT_BITS(status_reg, 62, 1, uint8_t); + fields->val = EXTRACT_BITS(status_reg, 63, 1, uint8_t); } -void aca_status_init(aca_status_fields_t *fields, uint64_t status_reg) -{ - fields->base.raw_value = status_reg; - fields->error_code = EXTRACT_BITS(status_reg, 0, 16, uint16_t); - fields->error_code_ext = EXTRACT_BITS(status_reg, 16, 6, uint8_t); - fields->reserv22 = EXTRACT_BITS(status_reg, 22, 2, uint8_t); - fields->addr_lsb = EXTRACT_BITS(status_reg, 24, 6, uint8_t); - fields->reserv30 = EXTRACT_BITS(status_reg, 30, 2, uint8_t); - fields->err_core_id = EXTRACT_BITS(status_reg, 32, 6, uint8_t); - fields->reserv38 = EXTRACT_BITS(status_reg, 38, 2, uint8_t); - fields->scrub = EXTRACT_BITS(status_reg, 40, 1, uint8_t); - fields->reserv41 = EXTRACT_BITS(status_reg, 41, 2, uint8_t); - fields->poison = EXTRACT_BITS(status_reg, 43, 1, uint8_t); - fields->deferred = EXTRACT_BITS(status_reg, 44, 1, uint8_t); - fields->uecc = EXTRACT_BITS(status_reg, 45, 1, uint8_t); - fields->cecc = EXTRACT_BITS(status_reg, 46, 1, uint8_t); - fields->reserv47 = EXTRACT_BITS(status_reg, 47, 5, uint8_t); - fields->synd_v = EXTRACT_BITS(status_reg, 53, 1, uint8_t); - fields->reserv54 = EXTRACT_BITS(status_reg, 54, 1, uint8_t); - fields->tcc = EXTRACT_BITS(status_reg, 55, 1, uint8_t); - fields->err_core_id_val = EXTRACT_BITS(status_reg, 56, 1, uint8_t); - fields->pcc = EXTRACT_BITS(status_reg, 57, 1, uint8_t); - fields->addr_v = EXTRACT_BITS(status_reg, 58, 1, uint8_t); - fields->misc_v = EXTRACT_BITS(status_reg, 59, 1, uint8_t); - fields->en = EXTRACT_BITS(status_reg, 60, 1, uint8_t); - fields->uc = EXTRACT_BITS(status_reg, 61, 1, uint8_t); - fields->overflow = EXTRACT_BITS(status_reg, 62, 1, uint8_t); - fields->val = EXTRACT_BITS(status_reg, 63, 1, uint8_t); +void aca_ipid_init(aca_ipid_fields_t *fields, uint64_t ipid_reg) { + fields->base.raw_value = ipid_reg; + fields->instance_id_lo = EXTRACT_BITS(ipid_reg, 0, 32, uint32_t); + fields->hardware_id = EXTRACT_BITS(ipid_reg, 32, 12, uint16_t); + fields->instance_id_hi = EXTRACT_BITS(ipid_reg, 44, 4, uint8_t); + fields->aca_type = EXTRACT_BITS(ipid_reg, 48, 16, uint16_t); } -void aca_ipid_init(aca_ipid_fields_t *fields, uint64_t ipid_reg) -{ - fields->base.raw_value = ipid_reg; - fields->instance_id_lo = EXTRACT_BITS(ipid_reg, 0, 32, uint32_t); - fields->hardware_id = EXTRACT_BITS(ipid_reg, 32, 12, uint16_t); - fields->instance_id_hi = EXTRACT_BITS(ipid_reg, 44, 4, uint8_t); - fields->aca_type = EXTRACT_BITS(ipid_reg, 48, 16, uint16_t); +void aca_synd_init(aca_synd_fields_t *fields, uint64_t synd_reg) { + fields->base.raw_value = synd_reg; + fields->error_information = EXTRACT_BITS(synd_reg, 0, 18, uint32_t); + fields->length = EXTRACT_BITS(synd_reg, 18, 6, uint8_t); + fields->error_priority = EXTRACT_BITS(synd_reg, 24, 3, uint8_t); + fields->reserved27 = EXTRACT_BITS(synd_reg, 27, 5, uint8_t); + fields->syndrome = EXTRACT_BITS(synd_reg, 32, 7, uint16_t); + fields->reserved39 = EXTRACT_BITS(synd_reg, 39, 25, uint32_t); } -void aca_synd_init(aca_synd_fields_t *fields, uint64_t synd_reg) -{ - fields->base.raw_value = synd_reg; - fields->error_information = EXTRACT_BITS(synd_reg, 0, 18, uint32_t); - fields->length = EXTRACT_BITS(synd_reg, 18, 6, uint8_t); - fields->error_priority = EXTRACT_BITS(synd_reg, 24, 3, uint8_t); - fields->reserved27 = EXTRACT_BITS(synd_reg, 27, 5, uint8_t); - fields->syndrome = EXTRACT_BITS(synd_reg, 32, 7, uint16_t); - fields->reserved39 = EXTRACT_BITS(synd_reg, 39, 25, uint32_t); -} - -void aca_addr_init(aca_addr_fields_t *fields, uint64_t addr_reg) -{ - fields->base.raw_value = addr_reg; - fields->error_addr = EXTRACT_BITS(addr_reg, 0, 56, uint64_t); - fields->reserved = EXTRACT_BITS(addr_reg, 56, 8, uint8_t); +void aca_addr_init(aca_addr_fields_t *fields, uint64_t addr_reg) { + fields->base.raw_value = addr_reg; + fields->error_addr = EXTRACT_BITS(addr_reg, 0, 56, uint64_t); + fields->reserved = EXTRACT_BITS(addr_reg, 56, 8, uint8_t); } diff --git a/src/ras-decode/aca_tables.c b/src/ras-decode/aca_tables.c index 3ea4f84e3f..8c49c49dc4 100644 --- a/src/ras-decode/aca_tables.c +++ b/src/ras-decode/aca_tables.c @@ -33,30 +33,22 @@ */ #include "aca_tables.h" -#include "ras_decode_constants.h" -#include + #include +#include #include +#include "ras_decode_constants.h" + /** * @brief Mapping table for hardware IDs and ACA types to bank names */ const aca_bank_entry_t bank_table[] = { - {0x2E, 0x02, "cs"}, - {0x2E, 0x01, "pie"}, - {0x96, 0x00, "umc"}, - {0xFF, 0x01, "psp"}, - {0x01, 0x01, "smu"}, - {0x18, 0x00, "nbio"}, - {0x46, 0x01, "pcie"}, - {0x05, 0x00, "pb"}, - {0x259, 0x00, "kpx_serdes"}, - {0x2E, 0x04, "mall"}, - {0x267, 0x00, "kpx_wafl"}, - {0x50, 0x00, "pcs_xgmi"}, - {0x6C, 0x00, "nbif"}, - {0x80, 0x00, "shub"}, - {0x170, 0x00, "usr_dp"}, + {0x2E, 0x02, "cs"}, {0x2E, 0x01, "pie"}, {0x96, 0x00, "umc"}, + {0xFF, 0x01, "psp"}, {0x01, 0x01, "smu"}, {0x18, 0x00, "nbio"}, + {0x46, 0x01, "pcie"}, {0x05, 0x00, "pb"}, {0x259, 0x00, "kpx_serdes"}, + {0x2E, 0x04, "mall"}, {0x267, 0x00, "kpx_wafl"}, {0x50, 0x00, "pcs_xgmi"}, + {0x6C, 0x00, "nbif"}, {0x80, 0x00, "shub"}, {0x170, 0x00, "usr_dp"}, {0x180, 0x00, "usr_cp"}}; /** @@ -253,74 +245,27 @@ const aca_error_type_t error_table[] = { * @brief Error GFX mapping table for XCD errors */ const aca_error_entry_t xcd_error_table[] = { - {0x0, "GfxGcError"}, - {0x1, "GfxGcError"}, - {0x2, "GfxGcError"}, - {0x3, "GfxGcError"}, - {0x4, "GfxGcError"}, - {0x5, "GfxGcError"}, - {0x6, "GfxGcError"}, - {0x7, "GfxGcError"}, - {0x8, "GfxGcError"}, - {0x9, "GfxGcError"}, - {0xa, "GfxGcError"}, - {0xb, "GfxGcError"}, - {0xc, "GfxGcError"}, - {0xd, "GfxGcError"}, - {0xe, "GfxGcError"}, - {0xf, "GfxGcError"}, - {0x10, "GfxGcError"}, - {0x28, "Reserved"}, - {0x2a, "Reserved"}}; + {0x0, "GfxGcError"}, {0x1, "GfxGcError"}, {0x2, "GfxGcError"}, {0x3, "GfxGcError"}, + {0x4, "GfxGcError"}, {0x5, "GfxGcError"}, {0x6, "GfxGcError"}, {0x7, "GfxGcError"}, + {0x8, "GfxGcError"}, {0x9, "GfxGcError"}, {0xa, "GfxGcError"}, {0xb, "GfxGcError"}, + {0xc, "GfxGcError"}, {0xd, "GfxGcError"}, {0xe, "GfxGcError"}, {0xf, "GfxGcError"}, + {0x10, "GfxGcError"}, {0x28, "Reserved"}, {0x2a, "Reserved"}}; /** * @brief Error GFX mapping table for AID errors */ const aca_error_entry_t aid_error_table[] = { - {0x0, "GfxGcError"}, - {0x1, "GfxGcError"}, - {0x2, "GfxGcError"}, - {0x3, "GfxGcError"}, - {0x4, "GfxGcError"}, - {0x5, "GfxMmhubError"}, - {0x6, "GfxMmhubError"}, - {0x7, "GfxMmhubError"}, - {0x8, "GfxMmhubError"}, - {0x9, "GfxMmhubError"}, - {0xa, "GfxMmhubError"}, - {0xb, "GfxMmhubError"}, - {0xc, "GfxMmhubError"}, - {0xd, "GfxGcError"}, - {0xe, "GfxVcnError"}, - {0xf, "GfxVcnError"}, - {0x10, "GfxVcnError"}, - {0x11, "GfxVcnError"}, - {0x12, "GfxVcnError"}, - {0x13, "GfxVcnError"}, - {0x14, "GfxVcnError"}, - {0x15, "GfxVcnError"}, - {0x16, "GfxVcnError"}, - {0x17, "GfxVcnError"}, - {0x18, "GfxVcnError"}, - {0x19, "GfxVcnError"}, - {0x1a, "GfxVcnError"}, - {0x1b, "GfxVcnError"}, - {0x1c, "GfxVcnError"}, - {0x1d, "GfxVcnError"}, - {0x1e, "GfxVcnError"}, - {0x1f, "GfxVcnError"}, - {0x20, "GfxVcnError"}, - {0x21, "GfxSdmaError"}, - {0x22, "GfxSdmaError"}, - {0x23, "GfxSdmaError"}, - {0x24, "GfxSdmaError"}, - {0x25, "GfxHdpError"}, - {0x26, "GfxAthubError"}, - {0x27, "GfxGcError"}, - {0x28, "Reserved"}, - {0x29, "Reserved"}, - {0x2a, "Reserved"}, - {0x2b, "Reserved"}}; + {0x0, "GfxGcError"}, {0x1, "GfxGcError"}, {0x2, "GfxGcError"}, {0x3, "GfxGcError"}, + {0x4, "GfxGcError"}, {0x5, "GfxMmhubError"}, {0x6, "GfxMmhubError"}, {0x7, "GfxMmhubError"}, + {0x8, "GfxMmhubError"}, {0x9, "GfxMmhubError"}, {0xa, "GfxMmhubError"}, {0xb, "GfxMmhubError"}, + {0xc, "GfxMmhubError"}, {0xd, "GfxGcError"}, {0xe, "GfxVcnError"}, {0xf, "GfxVcnError"}, + {0x10, "GfxVcnError"}, {0x11, "GfxVcnError"}, {0x12, "GfxVcnError"}, {0x13, "GfxVcnError"}, + {0x14, "GfxVcnError"}, {0x15, "GfxVcnError"}, {0x16, "GfxVcnError"}, {0x17, "GfxVcnError"}, + {0x18, "GfxVcnError"}, {0x19, "GfxVcnError"}, {0x1a, "GfxVcnError"}, {0x1b, "GfxVcnError"}, + {0x1c, "GfxVcnError"}, {0x1d, "GfxVcnError"}, {0x1e, "GfxVcnError"}, {0x1f, "GfxVcnError"}, + {0x20, "GfxVcnError"}, {0x21, "GfxSdmaError"}, {0x22, "GfxSdmaError"}, {0x23, "GfxSdmaError"}, + {0x24, "GfxSdmaError"}, {0x25, "GfxHdpError"}, {0x26, "GfxAthubError"}, {0x27, "GfxGcError"}, + {0x28, "Reserved"}, {0x29, "Reserved"}, {0x2a, "Reserved"}, {0x2b, "Reserved"}}; /** * @brief Table mapping instance_id_hi to OAM and AID values @@ -349,114 +294,113 @@ static const oam_aid_map_t oam_aid_table[] = { /** * @brief Table mapping bank and instance ID to instance names */ -static const aca_instance_entry_t instance_table[] = { - {"cs", 0x1F002000, "cmp0"}, - {"cs", 0x1F000000, "cs0"}, - {"cs", 0x1F000A00, "cs10"}, - {"cs", 0x1F000B00, "cs11"}, - {"cs", 0x1F000C00, "cs12"}, - {"cs", 0x1F000D00, "cs13"}, - {"cs", 0x1F000E00, "cs14"}, - {"cs", 0x1F000F00, "cs15"}, - {"cs", 0x1F001000, "cs16"}, - {"cs", 0x1F001100, "cs17"}, - {"cs", 0x1F001200, "cs18"}, - {"cs", 0x1F001300, "cs19"}, - {"cs", 0x1F000100, "cs1"}, - {"cs", 0x1F001400, "cs20"}, - {"cs", 0x1F001500, "cs21"}, - {"cs", 0x1F001600, "cs22"}, - {"cs", 0x1F001700, "cs23"}, - {"cs", 0x1F001800, "cs24"}, - {"cs", 0x1F001900, "cs25"}, - {"cs", 0x1F001A00, "cs26"}, - {"cs", 0x1F001B00, "cs27"}, - {"cs", 0x1F001C00, "cs28"}, - {"cs", 0x1F001D00, "cs29"}, - {"cs", 0x1F000200, "cs2"}, - {"cs", 0x1F001E00, "cs30"}, - {"cs", 0x1F001F00, "cs31"}, - {"cs", 0x1F000300, "cs3"}, - {"cs", 0x1F000400, "cs4"}, - {"cs", 0x1F000500, "cs5"}, - {"cs", 0x1F000600, "cs6"}, - {"cs", 0x1F000700, "cs7"}, - {"cs", 0x1F000800, "cs8"}, - {"cs", 0x1F000900, "cs9"}, - {"mall", 0x1F005900, "mall0"}, - {"mall", 0x1F006300, "mall10"}, - {"mall", 0x1F006400, "mall11"}, - {"mall", 0x1F006500, "mall12"}, - {"mall", 0x1F006600, "mall13"}, - {"mall", 0x1F006700, "mall14"}, - {"mall", 0x1F006800, "mall15"}, - {"mall", 0x1F006900, "mall16"}, - {"mall", 0x1F006A00, "mall17"}, - {"mall", 0x1F006B00, "mall18"}, - {"mall", 0x1F006C00, "mall19"}, - {"mall", 0x1F005A00, "mall1"}, - {"mall", 0x1F006D00, "mall20"}, - {"mall", 0x1F006E00, "mall21"}, - {"mall", 0x1F006F00, "mall22"}, - {"mall", 0x1F007000, "mall23"}, - {"mall", 0x1F007100, "mall24"}, - {"mall", 0x1F007200, "mall25"}, - {"mall", 0x1F007300, "mall26"}, - {"mall", 0x1F007400, "mall27"}, - {"mall", 0x1F007500, "mall28"}, - {"mall", 0x1F007600, "mall29"}, - {"mall", 0x1F005B00, "mall2"}, - {"mall", 0x1F007700, "mall30"}, - {"mall", 0x1F007800, "mall31"}, - {"mall", 0x1F005C00, "mall3"}, - {"mall", 0x1F005D00, "mall4"}, - {"mall", 0x1F005E00, "mall5"}, - {"mall", 0x1F005F00, "mall6"}, - {"mall", 0x1F006000, "mall7"}, - {"mall", 0x1F006100, "mall8"}, - {"mall", 0x1F006200, "mall9"}, - {"pb", 0x5EA00, "pb"}, - {"pb", 0x30082900, "ccd0 pbccd"}, - {"pb", 0x32082900, "ccd1 pbccd"}, - {"pb", 0x34082900, "ccd2 pbccd"}, - {"pb", 0x36082900, "xcd0 pbccd"}, - {"pb", 0x38082900, "xcd1 pbccd"}, - {"umc", 0x90F00, "ch0 umc0"}, - {"umc", 0x290F00, "ch0 umc1"}, - {"umc", 0x490F00, "ch0 umc2"}, - {"umc", 0x690F00, "ch0 umc3"}, - {"umc", 0x91F00, "ch1 umc0"}, - {"umc", 0x291F00, "ch1 umc1"}, - {"umc", 0x491F00, "ch1 umc2"}, - {"umc", 0x691F00, "ch1 umc3"}, - {"umc", 0x92F00, "ch2 umc0"}, - {"umc", 0x292F00, "ch2 umc1"}, - {"umc", 0x492F00, "ch2 umc2"}, - {"umc", 0x692F00, "ch2 umc3"}, - {"umc", 0x93F00, "ch3 umc0"}, - {"umc", 0x293F00, "ch3 umc1"}, - {"umc", 0x493F00, "ch3 umc2"}, - {"umc", 0x693F00, "ch3 umc3"}, - {"umc", 0x190F00, "ch4 umc0"}, - {"umc", 0x390F00, "ch4 umc1"}, - {"umc", 0x590F00, "ch4 umc2"}, - {"umc", 0x790F00, "ch4 umc3"}, - {"umc", 0x191F00, "ch5 umc0"}, - {"umc", 0x391F00, "ch5 umc1"}, - {"umc", 0x591F00, "ch5 umc2"}, - {"umc", 0x791F00, "ch5 umc3"}, - {"umc", 0x192F00, "ch6 umc0"}, - {"umc", 0x392F00, "ch6 umc1"}, - {"umc", 0x592F00, "ch6 umc2"}, - {"umc", 0x792F00, "ch6 umc3"}, - {"umc", 0x193F00, "ch7 umc0"}, - {"umc", 0x393F00, "ch7 umc1"}, - {"umc", 0x593F00, "ch7 umc2"}, - {"umc", 0x793F00, "ch7 umc3"}, - {"pcs_xgmi", 0x11A09200, "serdes a pcs0"}, - {"pcs_xgmi", 0x12109200, "serdes b pcs7"}, - {"pcs_xgmi", 0x12209200, "serdes b pcs8"}, - {"pcs_xgmi", 0x11B09200, "xgmi pcs"}}; +static const aca_instance_entry_t instance_table[] = {{"cs", 0x1F002000, "cmp0"}, + {"cs", 0x1F000000, "cs0"}, + {"cs", 0x1F000A00, "cs10"}, + {"cs", 0x1F000B00, "cs11"}, + {"cs", 0x1F000C00, "cs12"}, + {"cs", 0x1F000D00, "cs13"}, + {"cs", 0x1F000E00, "cs14"}, + {"cs", 0x1F000F00, "cs15"}, + {"cs", 0x1F001000, "cs16"}, + {"cs", 0x1F001100, "cs17"}, + {"cs", 0x1F001200, "cs18"}, + {"cs", 0x1F001300, "cs19"}, + {"cs", 0x1F000100, "cs1"}, + {"cs", 0x1F001400, "cs20"}, + {"cs", 0x1F001500, "cs21"}, + {"cs", 0x1F001600, "cs22"}, + {"cs", 0x1F001700, "cs23"}, + {"cs", 0x1F001800, "cs24"}, + {"cs", 0x1F001900, "cs25"}, + {"cs", 0x1F001A00, "cs26"}, + {"cs", 0x1F001B00, "cs27"}, + {"cs", 0x1F001C00, "cs28"}, + {"cs", 0x1F001D00, "cs29"}, + {"cs", 0x1F000200, "cs2"}, + {"cs", 0x1F001E00, "cs30"}, + {"cs", 0x1F001F00, "cs31"}, + {"cs", 0x1F000300, "cs3"}, + {"cs", 0x1F000400, "cs4"}, + {"cs", 0x1F000500, "cs5"}, + {"cs", 0x1F000600, "cs6"}, + {"cs", 0x1F000700, "cs7"}, + {"cs", 0x1F000800, "cs8"}, + {"cs", 0x1F000900, "cs9"}, + {"mall", 0x1F005900, "mall0"}, + {"mall", 0x1F006300, "mall10"}, + {"mall", 0x1F006400, "mall11"}, + {"mall", 0x1F006500, "mall12"}, + {"mall", 0x1F006600, "mall13"}, + {"mall", 0x1F006700, "mall14"}, + {"mall", 0x1F006800, "mall15"}, + {"mall", 0x1F006900, "mall16"}, + {"mall", 0x1F006A00, "mall17"}, + {"mall", 0x1F006B00, "mall18"}, + {"mall", 0x1F006C00, "mall19"}, + {"mall", 0x1F005A00, "mall1"}, + {"mall", 0x1F006D00, "mall20"}, + {"mall", 0x1F006E00, "mall21"}, + {"mall", 0x1F006F00, "mall22"}, + {"mall", 0x1F007000, "mall23"}, + {"mall", 0x1F007100, "mall24"}, + {"mall", 0x1F007200, "mall25"}, + {"mall", 0x1F007300, "mall26"}, + {"mall", 0x1F007400, "mall27"}, + {"mall", 0x1F007500, "mall28"}, + {"mall", 0x1F007600, "mall29"}, + {"mall", 0x1F005B00, "mall2"}, + {"mall", 0x1F007700, "mall30"}, + {"mall", 0x1F007800, "mall31"}, + {"mall", 0x1F005C00, "mall3"}, + {"mall", 0x1F005D00, "mall4"}, + {"mall", 0x1F005E00, "mall5"}, + {"mall", 0x1F005F00, "mall6"}, + {"mall", 0x1F006000, "mall7"}, + {"mall", 0x1F006100, "mall8"}, + {"mall", 0x1F006200, "mall9"}, + {"pb", 0x5EA00, "pb"}, + {"pb", 0x30082900, "ccd0 pbccd"}, + {"pb", 0x32082900, "ccd1 pbccd"}, + {"pb", 0x34082900, "ccd2 pbccd"}, + {"pb", 0x36082900, "xcd0 pbccd"}, + {"pb", 0x38082900, "xcd1 pbccd"}, + {"umc", 0x90F00, "ch0 umc0"}, + {"umc", 0x290F00, "ch0 umc1"}, + {"umc", 0x490F00, "ch0 umc2"}, + {"umc", 0x690F00, "ch0 umc3"}, + {"umc", 0x91F00, "ch1 umc0"}, + {"umc", 0x291F00, "ch1 umc1"}, + {"umc", 0x491F00, "ch1 umc2"}, + {"umc", 0x691F00, "ch1 umc3"}, + {"umc", 0x92F00, "ch2 umc0"}, + {"umc", 0x292F00, "ch2 umc1"}, + {"umc", 0x492F00, "ch2 umc2"}, + {"umc", 0x692F00, "ch2 umc3"}, + {"umc", 0x93F00, "ch3 umc0"}, + {"umc", 0x293F00, "ch3 umc1"}, + {"umc", 0x493F00, "ch3 umc2"}, + {"umc", 0x693F00, "ch3 umc3"}, + {"umc", 0x190F00, "ch4 umc0"}, + {"umc", 0x390F00, "ch4 umc1"}, + {"umc", 0x590F00, "ch4 umc2"}, + {"umc", 0x790F00, "ch4 umc3"}, + {"umc", 0x191F00, "ch5 umc0"}, + {"umc", 0x391F00, "ch5 umc1"}, + {"umc", 0x591F00, "ch5 umc2"}, + {"umc", 0x791F00, "ch5 umc3"}, + {"umc", 0x192F00, "ch6 umc0"}, + {"umc", 0x392F00, "ch6 umc1"}, + {"umc", 0x592F00, "ch6 umc2"}, + {"umc", 0x792F00, "ch6 umc3"}, + {"umc", 0x193F00, "ch7 umc0"}, + {"umc", 0x393F00, "ch7 umc1"}, + {"umc", 0x593F00, "ch7 umc2"}, + {"umc", 0x793F00, "ch7 umc3"}, + {"pcs_xgmi", 0x11A09200, "serdes a pcs0"}, + {"pcs_xgmi", 0x12109200, "serdes b pcs7"}, + {"pcs_xgmi", 0x12209200, "serdes b pcs8"}, + {"pcs_xgmi", 0x11B09200, "xgmi pcs"}}; const size_t NUM_OAM_AID_ENTRIES = sizeof(oam_aid_table) / sizeof(oam_aid_table[0]); const size_t NUM_BANKS = sizeof(bank_table) / sizeof(bank_table[0]); @@ -465,101 +409,81 @@ const size_t NUM_XCD_ERRORS = sizeof(xcd_error_table) / sizeof(xcd_error_table[0 const size_t NUM_AID_ERRORS = sizeof(aid_error_table) / sizeof(aid_error_table[0]); const size_t NUM_INSTANCES = sizeof(instance_table) / sizeof(instance_table[0]); -int find_bank_name(uint16_t hw_id, uint16_t aca_type, const char **bank_name) -{ - if (!bank_name) - { - return -1; - } +int find_bank_name(uint16_t hw_id, uint16_t aca_type, const char **bank_name) { + if (!bank_name) { + return -1; + } - for (size_t i = 0; i < NUM_BANKS; i++) - { - if (bank_table[i].hw_id == hw_id && - bank_table[i].aca_type == aca_type) - { - *bank_name = bank_table[i].name; - return 0; - } + for (size_t i = 0; i < NUM_BANKS; i++) { + if (bank_table[i].hw_id == hw_id && bank_table[i].aca_type == aca_type) { + *bank_name = bank_table[i].name; + return 0; } + } - *bank_name = RAS_DECODE_SEVERITY_UNKNOWN; - return 1; + *bank_name = RAS_DECODE_SEVERITY_UNKNOWN; + return 1; } -int find_error_type_by_bank(const char *bank, uint32_t error_code, const char **error_type) -{ - if (!bank || !error_type) - { - return -1; - } +int find_error_type_by_bank(const char *bank, uint32_t error_code, const char **error_type) { + if (!bank || !error_type) { + return -1; + } - for (size_t i = 0; i < NUM_ERRORS; i++) - { - if (error_code == error_table[i].error_code && - strcmp(bank, error_table[i].bank) == 0) - { - *error_type = error_table[i].type; - return 0; - } + for (size_t i = 0; i < NUM_ERRORS; i++) { + if (error_code == error_table[i].error_code && strcmp(bank, error_table[i].bank) == 0) { + *error_type = error_table[i].type; + return 0; } + } - *error_type = RAS_DECODE_SEVERITY_UNKNOWN; - return 1; + *error_type = RAS_DECODE_SEVERITY_UNKNOWN; + return 1; } -int find_error_in_table(const aca_error_entry_t *table, size_t table_size, - uint32_t error_code, const char **error_type) -{ - if (!table || !error_type) - { - return -1; - } +int find_error_in_table(const aca_error_entry_t *table, size_t table_size, uint32_t error_code, + const char **error_type) { + if (!table || !error_type) { + return -1; + } - for (size_t i = 0; i < table_size; i++) - { - if (table[i].error_code == error_code) - { - *error_type = table[i].type; - return 0; - } + for (size_t i = 0; i < table_size; i++) { + if (table[i].error_code == error_code) { + *error_type = table[i].type; + return 0; } + } - *error_type = RAS_DECODE_SEVERITY_UNKNOWN; - return 1; + *error_type = RAS_DECODE_SEVERITY_UNKNOWN; + return 1; } -int find_oam_aid(uint8_t instance_id_hi, oam_aid_map_t *oam_aid) -{ - if (!oam_aid || instance_id_hi >= NUM_OAM_AID_ENTRIES) - { - return -1; - } +int find_oam_aid(uint8_t instance_id_hi, oam_aid_map_t *oam_aid) { + if (!oam_aid || instance_id_hi >= NUM_OAM_AID_ENTRIES) { + return -1; + } - oam_aid->oam = oam_aid_table[instance_id_hi].oam; - oam_aid->aid = oam_aid_table[instance_id_hi].aid; - return 0; + oam_aid->oam = oam_aid_table[instance_id_hi].oam; + oam_aid->aid = oam_aid_table[instance_id_hi].aid; + return 0; } -int find_instance_name(const char *bank, uint32_t instance_id_lo, const char **instance_name) -{ - if (!bank || !instance_name) - { - return -1; +int find_instance_name(const char *bank, uint32_t instance_id_lo, const char **instance_name) { + if (!bank || !instance_name) { + return -1; + } + + // Mask off the lower 2 bits as specified + uint32_t masked_id = instance_id_lo & 0xFFFFFFFC; + + for (size_t i = 0; i < NUM_INSTANCES; i++) { + if (instance_table[i].instance_id_lo == masked_id && + strcmp(bank, instance_table[i].bank) == 0) { + *instance_name = instance_table[i].name; + return 0; } + } - // Mask off the lower 2 bits as specified - uint32_t masked_id = instance_id_lo & 0xFFFFFFFC; - - for (size_t i = 0; i < NUM_INSTANCES; i++) - { - if (instance_table[i].instance_id_lo == masked_id && - strcmp(bank, instance_table[i].bank) == 0) - { - *instance_name = instance_table[i].name; - return 0; - } - } - - *instance_name = RAS_DECODE_SEVERITY_UNKNOWN; - return 1; + *instance_name = RAS_DECODE_SEVERITY_UNKNOWN; + return 1; } diff --git a/src/ras-decode/aca_version.c b/src/ras-decode/aca_version.c index db9ae72925..765d94ed97 100644 --- a/src/ras-decode/aca_version.c +++ b/src/ras-decode/aca_version.c @@ -24,34 +24,21 @@ /* Implementation of version functions */ -int aca_get_version_major(void) -{ - return RAS_DECODE_VERSION_MAJOR; -} - -int aca_get_version_minor(void) -{ - return RAS_DECODE_VERSION_MINOR; -} - -int aca_get_version_patch(void) -{ - return RAS_DECODE_VERSION_PATCH; -} - -const char *aca_get_version_string(void) -{ - return RAS_DECODE_VERSION_STRING; -} - -aca_version_info_t aca_get_version_info(void) -{ - aca_version_info_t info; - - info.major = RAS_DECODE_VERSION_MAJOR; - info.minor = RAS_DECODE_VERSION_MINOR; - info.patch = RAS_DECODE_VERSION_PATCH; - info.string = RAS_DECODE_VERSION_STRING; - - return info; +int aca_get_version_major(void) { return RAS_DECODE_VERSION_MAJOR; } + +int aca_get_version_minor(void) { return RAS_DECODE_VERSION_MINOR; } + +int aca_get_version_patch(void) { return RAS_DECODE_VERSION_PATCH; } + +const char *aca_get_version_string(void) { return RAS_DECODE_VERSION_STRING; } + +aca_version_info_t aca_get_version_info(void) { + aca_version_info_t info; + + info.major = RAS_DECODE_VERSION_MAJOR; + info.minor = RAS_DECODE_VERSION_MINOR; + info.patch = RAS_DECODE_VERSION_PATCH; + info.string = RAS_DECODE_VERSION_STRING; + + return info; } diff --git a/src/ras-decode/boot_decode.c b/src/ras-decode/boot_decode.c index b5f51a1b47..42b8a61eab 100644 --- a/src/ras-decode/boot_decode.c +++ b/src/ras-decode/boot_decode.c @@ -21,11 +21,13 @@ */ #include "boot_decode.h" -#include "ras_decode_constants.h" + #include #include #include +#include "ras_decode_constants.h" + // Boot decoder mapping tables static const boot_decoder_entry_t boot_decoder_map_v0[] = { {BOOT_ENCODING_HBM_TRAINING, decode_hbm_training_v0}, @@ -37,7 +39,7 @@ static const boot_decoder_entry_t boot_decoder_map_v0[] = { {BOOT_ENCODING_HBM_MEM_TEST, decode_hbm_mem_test_v0}, {BOOT_ENCODING_HBM_BIST_TEST, decode_hbm_bist_test_v0}, {BOOT_ENCODING_BOOT_CTRL_GEN_V0, decode_boot_controller_generic_v0}, - {0, NULL} // Sentinel + {0, NULL} // Sentinel }; static const boot_decoder_entry_t boot_decoder_map_v1[] = { @@ -52,811 +54,699 @@ static const boot_decoder_entry_t boot_decoder_map_v1[] = { {BOOT_ENCODING_BOOT_CTRL_GEN_V1, decode_boot_controller_generic_v1}, {BOOT_ENCODING_DATA_ABORT, decode_data_abort_v1}, {BOOT_SUCCESS_ENCODING, decode_boot_success_v1}, - {0, NULL} // Sentinel + {0, NULL} // Sentinel }; -int get_boot_version(OamBootMsg *msg) -{ - if (!msg) - return 0; - return extract_byte(msg->value, 1) >> 5; +int get_boot_version(OamBootMsg *msg) { + if (!msg) return 0; + return extract_byte(msg->value, 1) >> 5; } -int get_error_encoding(OamBootMsg *msg) -{ - if (!msg) - return 0; - return (int)(extract_byte(msg->value, 1) & extract_bits(5)); +int get_error_encoding(OamBootMsg *msg) { + if (!msg) return 0; + return (int)(extract_byte(msg->value, 1) & extract_bits(5)); } -bool error_present(OamBootMsg *msg) -{ - if (!msg) - return false; - return extract_byte(msg->value, 0) == BOOT_ERROR_PRESENT_MARKER; +bool error_present(OamBootMsg *msg) { + if (!msg) return false; + return extract_byte(msg->value, 0) == BOOT_ERROR_PRESENT_MARKER; } -bool in_boot(OamBootMsg *msg) -{ - if (!msg) - return false; - return extract_byte(msg->value, 0) == BOOT_IN_BOOT_MARKER; +bool in_boot(OamBootMsg *msg) { + if (!msg) return false; + return extract_byte(msg->value, 0) == BOOT_IN_BOOT_MARKER; } -int get_socket(OamBootMsg *msg, int version) -{ - if (!msg) - return 0; +int get_socket(OamBootMsg *msg, int version) { + if (!msg) return 0; - if (version == 0) - { - return extract_byte(msg->value, 4); - } - else - { - return (int)((extract_byte(msg->value, 2) >> 4) & extract_bits(4)); - } + if (version == 0) { + return extract_byte(msg->value, 4); + } else { + return (int)((extract_byte(msg->value, 2) >> 4) & extract_bits(4)); + } } -int get_aid(OamBootMsg *msg, int version) -{ - if (!msg) - return 0; +int get_aid(OamBootMsg *msg, int version) { + if (!msg) return 0; - if (version == 0) - { - return extract_byte(msg->value, 5); - } - else - { - return (int)(extract_byte(msg->value, 2) & extract_bits(4)); - } + if (version == 0) { + return extract_byte(msg->value, 5); + } else { + return (int)(extract_byte(msg->value, 2) & extract_bits(4)); + } } -int decode_hbm_stack(uint8_t stack) -{ - switch (stack) - { +int decode_hbm_stack(uint8_t stack) { + switch (stack) { case HBM_STACK_0: - return 0; + return 0; case HBM_STACK_1: - return 1; + return 1; default: - return HBM_STACK_UNKNOWN; - } + return HBM_STACK_UNKNOWN; + } } -JsonValue *create_failed_links_array(uint8_t byte_value, int max_links) -{ - JsonValue *array = json_create_array(); - if (!array) - return NULL; +JsonValue *create_failed_links_array(uint8_t byte_value, int max_links) { + JsonValue *array = json_create_array(); + if (!array) return NULL; - for (int i = 0; i < max_links; i++) - { - if ((byte_value >> i) & 0x1) - { - JsonValue *link_num = json_create_number(i); - if (link_num) - { - json_array_push(array, link_num); - } - } + for (int i = 0; i < max_links; i++) { + if ((byte_value >> i) & 0x1) { + JsonValue *link_num = json_create_number(i); + if (link_num) { + json_array_push(array, link_num); + } } + } - return array; + return array; } -char *create_hex_string(uint64_t value, int width) -{ - if (width < 0) - return NULL; - size_t buffer_size = (size_t)width + 3U; // "0x" + digits + null terminator - char *hex_str = malloc(buffer_size); - if (!hex_str) - return NULL; +char *create_hex_string(uint64_t value, int width) { + if (width < 0) return NULL; + size_t buffer_size = (size_t)width + 3U; // '0' + 'x' + width digits + '\0' + char *hex_str = malloc(buffer_size); + if (!hex_str) return NULL; - snprintf(hex_str, buffer_size, "0x%0*llX", width, (unsigned long long)value); - return hex_str; + snprintf(hex_str, buffer_size, "0x%0*llX", width, (unsigned long long)value); + return hex_str; } // Version 0 decoder implementations -JsonValue *decode_hbm_training_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_hbm_training_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte3 = extract_byte(msg->value, 3); - uint8_t byte2 = extract_byte(msg->value, 2); + int version = get_boot_version(msg); + uint8_t byte3 = extract_byte(msg->value, 3); + uint8_t byte2 = extract_byte(msg->value, 2); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte3))); - json_object_set(result, "hbm_channel", json_create_number(byte2)); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte3))); + json_object_set(result, "hbm_channel", json_create_number(byte2)); - return result; + return result; } -JsonValue *decode_fw_load_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_fw_load_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte3 = extract_byte(msg->value, 3); - uint8_t byte2 = extract_byte(msg->value, 2); - uint16_t fw_id = (byte3 << 8) | byte2; + int version = get_boot_version(msg); + uint8_t byte3 = extract_byte(msg->value, 3); + uint8_t byte2 = extract_byte(msg->value, 2); + uint16_t fw_id = (uint16_t)((byte3 << 8) | byte2); - char *fw_id_str = create_hex_string(fw_id, 4); + char *fw_id_str = create_hex_string(fw_id, 4); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_FW_LOAD)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "fw_id", json_create_string(fw_id_str ? fw_id_str : "0x0000")); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_FW_LOAD)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "fw_id", json_create_string(fw_id_str ? fw_id_str : "0x0000")); - free(fw_id_str); - return result; + free(fw_id_str); + return result; } -JsonValue *decode_wafl_link_training_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_wafl_link_training_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte2 = extract_byte(msg->value, 2); - JsonValue *failed_links = create_failed_links_array(byte2, 2); + int version = get_boot_version(msg); + uint8_t byte2 = extract_byte(msg->value, 2); + JsonValue *failed_links = create_failed_links_array(byte2, 2); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_WAFL_LINK_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_WAFL_LINK_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); - return result; + return result; } -JsonValue *decode_xgmi_link_training_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_xgmi_link_training_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte2 = extract_byte(msg->value, 2); - JsonValue *failed_links = create_failed_links_array(byte2, 8); + int version = get_boot_version(msg); + uint8_t byte2 = extract_byte(msg->value, 2); + JsonValue *failed_links = create_failed_links_array(byte2, 8); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_XGMI_LINK_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_XGMI_LINK_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); - return result; + return result; } -JsonValue *decode_usr_cp_link_training_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_usr_cp_link_training_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte2 = extract_byte(msg->value, 2); - JsonValue *failed_links = create_failed_links_array(byte2, 2); + int version = get_boot_version(msg); + uint8_t byte2 = extract_byte(msg->value, 2); + JsonValue *failed_links = create_failed_links_array(byte2, 2); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_USR_CP_LINK_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_USR_CP_LINK_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); - return result; + return result; } -JsonValue *decode_usr_dp_link_training_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_usr_dp_link_training_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte2 = extract_byte(msg->value, 2); - JsonValue *failed_links = create_failed_links_array(byte2, 4); + int version = get_boot_version(msg); + uint8_t byte2 = extract_byte(msg->value, 2); + JsonValue *failed_links = create_failed_links_array(byte2, 4); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_USR_DP_LINK_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_USR_DP_LINK_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); - return result; + return result; } -JsonValue *decode_hbm_mem_test_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_hbm_mem_test_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte3 = extract_byte(msg->value, 3); - uint8_t byte2 = extract_byte(msg->value, 2); + int version = get_boot_version(msg); + uint8_t byte3 = extract_byte(msg->value, 3); + uint8_t byte2 = extract_byte(msg->value, 2); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_MEMORY_TEST)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte3))); - json_object_set(result, "hbm_channel", json_create_number(byte2)); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_MEMORY_TEST)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte3))); + json_object_set(result, "hbm_channel", json_create_number(byte2)); - return result; + return result; } -JsonValue *decode_hbm_bist_test_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_hbm_bist_test_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte3 = extract_byte(msg->value, 3); - uint8_t byte2 = extract_byte(msg->value, 2); + int version = get_boot_version(msg); + uint8_t byte3 = extract_byte(msg->value, 3); + uint8_t byte2 = extract_byte(msg->value, 2); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_BIST_TEST)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte3))); - json_object_set(result, "hbm_channel", json_create_number(byte2)); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_BIST_TEST)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte3))); + json_object_set(result, "hbm_channel", json_create_number(byte2)); - return result; + return result; } -JsonValue *decode_boot_controller_generic_v0(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_boot_controller_generic_v0(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); + int version = get_boot_version(msg); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_GENERIC)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_GENERIC)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - return result; + return result; } // Version 1 decoder implementations -JsonValue *decode_hbm_training_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_hbm_training_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte5 = extract_byte(msg->value, 5); - uint8_t byte4 = extract_byte(msg->value, 4); + int version = get_boot_version(msg); + uint8_t byte5 = extract_byte(msg->value, 5); + uint8_t byte4 = extract_byte(msg->value, 4); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte5))); - json_object_set(result, "hbm_channel", json_create_number(byte4)); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte5))); + json_object_set(result, "hbm_channel", json_create_number(byte4)); - return result; + return result; } -JsonValue *decode_fw_load_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_fw_load_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte5 = extract_byte(msg->value, 5); - uint8_t byte4 = extract_byte(msg->value, 4); - uint16_t fw_id = (byte5 << 8) | byte4; + int version = get_boot_version(msg); + uint8_t byte5 = extract_byte(msg->value, 5); + uint8_t byte4 = extract_byte(msg->value, 4); + uint16_t fw_id = (uint16_t)((byte5 << 8) | byte4); - char *fw_id_str = create_hex_string(fw_id, 4); + char *fw_id_str = create_hex_string(fw_id, 4); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_FW_LOAD)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "fw_id", json_create_string(fw_id_str ? fw_id_str : "0x0000")); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_FW_LOAD)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "fw_id", json_create_string(fw_id_str ? fw_id_str : "0x0000")); - free(fw_id_str); - return result; + free(fw_id_str); + return result; } -JsonValue *decode_wafl_link_training_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_wafl_link_training_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte4 = extract_byte(msg->value, 4); - JsonValue *failed_links = create_failed_links_array(byte4, 2); + int version = get_boot_version(msg); + uint8_t byte4 = extract_byte(msg->value, 4); + JsonValue *failed_links = create_failed_links_array(byte4, 2); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_WAFL_LINK_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_WAFL_LINK_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); - return result; + return result; } -JsonValue *decode_xgmi_link_training_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_xgmi_link_training_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte4 = extract_byte(msg->value, 4); - JsonValue *failed_links = create_failed_links_array(byte4, 8); + int version = get_boot_version(msg); + uint8_t byte4 = extract_byte(msg->value, 4); + JsonValue *failed_links = create_failed_links_array(byte4, 8); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_XGMI_LINK_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_XGMI_LINK_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); - return result; + return result; } -JsonValue *decode_usr_cp_link_training_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_usr_cp_link_training_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte4 = extract_byte(msg->value, 4); - JsonValue *failed_links = create_failed_links_array(byte4, 2); + int version = get_boot_version(msg); + uint8_t byte4 = extract_byte(msg->value, 4); + JsonValue *failed_links = create_failed_links_array(byte4, 2); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_USR_CP_LINK_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_USR_CP_LINK_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); - return result; + return result; } -JsonValue *decode_usr_dp_link_training_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_usr_dp_link_training_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte4 = extract_byte(msg->value, 4); - JsonValue *failed_links = create_failed_links_array(byte4, 4); + int version = get_boot_version(msg); + uint8_t byte4 = extract_byte(msg->value, 4); + JsonValue *failed_links = create_failed_links_array(byte4, 4); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_USR_DP_LINK_TRAINING)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_USR_DP_LINK_TRAINING)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "failed_links", failed_links ? failed_links : json_create_array()); - return result; + return result; } -JsonValue *decode_hbm_mem_test_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_hbm_mem_test_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte5 = extract_byte(msg->value, 5); - uint8_t byte4 = extract_byte(msg->value, 4); + int version = get_boot_version(msg); + uint8_t byte5 = extract_byte(msg->value, 5); + uint8_t byte4 = extract_byte(msg->value, 4); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_MEMORY_TEST)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte5))); - json_object_set(result, "hbm_channel", json_create_number(byte4)); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_MEMORY_TEST)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte5))); + json_object_set(result, "hbm_channel", json_create_number(byte4)); - return result; + return result; } -JsonValue *decode_hbm_bist_test_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_hbm_bist_test_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte5 = extract_byte(msg->value, 5); - uint8_t byte4 = extract_byte(msg->value, 4); + int version = get_boot_version(msg); + uint8_t byte5 = extract_byte(msg->value, 5); + uint8_t byte4 = extract_byte(msg->value, 4); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_BIST_TEST)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte5))); - json_object_set(result, "hbm_channel", json_create_number(byte4)); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_HBM_BIST_TEST)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "hbm_stack", json_create_number(decode_hbm_stack(byte5))); + json_object_set(result, "hbm_channel", json_create_number(byte4)); - return result; + return result; } -JsonValue *decode_boot_controller_generic_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_boot_controller_generic_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte4 = extract_byte(msg->value, 4); - uint8_t byte0 = extract_byte(msg->value, 0); - uint8_t byte5 = extract_byte(msg->value, 5); - uint8_t byte6 = extract_byte(msg->value, 6); - uint8_t byte7 = extract_byte(msg->value, 7); + int version = get_boot_version(msg); + uint8_t byte4 = extract_byte(msg->value, 4); + uint8_t byte0 = extract_byte(msg->value, 0); + uint8_t byte5 = extract_byte(msg->value, 5); + uint8_t byte6 = extract_byte(msg->value, 6); + uint8_t byte7 = extract_byte(msg->value, 7); - char *boot_step_str = create_hex_string(byte4, 2); - uint32_t boot_status = (byte7 << 24) | (byte6 << 16) | (byte5 << 8) | byte0; - char *boot_status_str = create_hex_string(boot_status, 8); + char *boot_step_str = create_hex_string(byte4, 2); + uint32_t boot_status = (uint32_t)((byte7 << 24) | (byte6 << 16) | (byte5 << 8) | byte0); + char *boot_status_str = create_hex_string(boot_status, 8); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_GENERIC)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "last_successful_boot_step_number", - json_create_string(boot_step_str ? boot_step_str : "0x00")); - json_object_set(result, "fw_boot_status", - json_create_string(boot_status_str ? boot_status_str : "0x00000000")); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_GENERIC)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "last_successful_boot_step_number", + json_create_string(boot_step_str ? boot_step_str : "0x00")); + json_object_set(result, "fw_boot_status", + json_create_string(boot_status_str ? boot_status_str : "0x00000000")); - free(boot_step_str); - free(boot_status_str); - return result; + free(boot_step_str); + free(boot_status_str); + return result; } -JsonValue *decode_data_abort_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_data_abort_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - int version = get_boot_version(msg); - uint8_t byte3 = extract_byte(msg->value, 3); - uint8_t byte4 = extract_byte(msg->value, 4); - uint8_t byte5 = extract_byte(msg->value, 5); - uint8_t byte6 = extract_byte(msg->value, 6); - uint8_t byte7 = extract_byte(msg->value, 7); + int version = get_boot_version(msg); + uint8_t byte3 = extract_byte(msg->value, 3); + uint8_t byte4 = extract_byte(msg->value, 4); + uint8_t byte5 = extract_byte(msg->value, 5); + uint8_t byte6 = extract_byte(msg->value, 6); + uint8_t byte7 = extract_byte(msg->value, 7); - char *boot_step_str = create_hex_string(byte3, 2); - uint32_t exception_addr = (byte7 << 24) | (byte6 << 16) | (byte5 << 8) | byte4; - char *exception_addr_str = create_hex_string(exception_addr, 8); + char *boot_step_str = create_hex_string(byte3, 2); + uint32_t exception_addr = (uint32_t)((byte7 << 24) | (byte6 << 16) | (byte5 << 8) | byte4); + char *exception_addr_str = create_hex_string(exception_addr, 8); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_DATA_ABORT)); - json_object_set(result, "socket", json_create_number(get_socket(msg, version))); - json_object_set(result, "aid", json_create_number(get_aid(msg, version))); - json_object_set(result, "last_successful_boot_step_number", - json_create_string(boot_step_str ? boot_step_str : "0x00")); - json_object_set(result, "exception_address", - json_create_string(exception_addr_str ? exception_addr_str : "0x00000000")); + json_object_set(result, "error_type", + json_create_string(RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_DATA_ABORT)); + json_object_set(result, "socket", json_create_number(get_socket(msg, version))); + json_object_set(result, "aid", json_create_number(get_aid(msg, version))); + json_object_set(result, "last_successful_boot_step_number", + json_create_string(boot_step_str ? boot_step_str : "0x00")); + json_object_set(result, "exception_address", + json_create_string(exception_addr_str ? exception_addr_str : "0x00000000")); - free(boot_step_str); - free(exception_addr_str); - return result; + free(boot_step_str); + free(exception_addr_str); + return result; } -JsonValue *decode_boot_success_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_boot_success_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - uint8_t byte4 = extract_byte(msg->value, 4); - uint8_t byte0 = extract_byte(msg->value, 0); - uint8_t byte5 = extract_byte(msg->value, 5); - uint8_t byte6 = extract_byte(msg->value, 6); - uint8_t byte7 = extract_byte(msg->value, 7); + uint8_t byte4 = extract_byte(msg->value, 4); + uint8_t byte0 = extract_byte(msg->value, 0); + uint8_t byte5 = extract_byte(msg->value, 5); + uint8_t byte6 = extract_byte(msg->value, 6); + uint8_t byte7 = extract_byte(msg->value, 7); - char *boot_step_str = create_hex_string(byte4, 2); - uint32_t boot_status = (byte7 << 24) | (byte6 << 16) | (byte5 << 8) | byte0; - char *boot_status_str = create_hex_string(boot_status, 8); + char *boot_step_str = create_hex_string(byte4, 2); + uint32_t boot_status = (uint32_t)((byte7 << 24) | (byte6 << 16) | (byte5 << 8) | byte0); + char *boot_status_str = create_hex_string(boot_status, 8); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_BOOT_SUCCESS)); - json_object_set(result, "last_successful_boot_step_number", - json_create_string(boot_step_str ? boot_step_str : "0x00")); - json_object_set(result, "fw_boot_status", - json_create_string(boot_status_str ? boot_status_str : "0x00000000")); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_BOOT_SUCCESS)); + json_object_set(result, "last_successful_boot_step_number", + json_create_string(boot_step_str ? boot_step_str : "0x00")); + json_object_set(result, "fw_boot_status", + json_create_string(boot_status_str ? boot_status_str : "0x00000000")); - free(boot_step_str); - free(boot_status_str); - return result; + free(boot_step_str); + free(boot_status_str); + return result; } // Unhandled error decoders -JsonValue *decode_unhandled_error_v0(OamBootMsg *msg) -{ - (void)msg; // Suppress unused parameter warning - JsonValue *result = json_create_object(); - if (!result) - return NULL; +JsonValue *decode_unhandled_error_v0(OamBootMsg *msg) { + (void)msg; // Suppress unused parameter warning + JsonValue *result = json_create_object(); + if (!result) return NULL; - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_UNHANDLED)); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_UNHANDLED)); - return result; + return result; } -JsonValue *decode_unhandled_error_v1(OamBootMsg *msg) -{ - if (!msg) - return NULL; +JsonValue *decode_unhandled_error_v1(OamBootMsg *msg) { + if (!msg) return NULL; - JsonValue *result = json_create_object(); - if (!result) - return NULL; + JsonValue *result = json_create_object(); + if (!result) return NULL; - uint8_t byte4 = extract_byte(msg->value, 4); - uint8_t byte0 = extract_byte(msg->value, 0); - uint8_t byte5 = extract_byte(msg->value, 5); - uint8_t byte6 = extract_byte(msg->value, 6); - uint8_t byte7 = extract_byte(msg->value, 7); + uint8_t byte4 = extract_byte(msg->value, 4); + uint8_t byte0 = extract_byte(msg->value, 0); + uint8_t byte5 = extract_byte(msg->value, 5); + uint8_t byte6 = extract_byte(msg->value, 6); + uint8_t byte7 = extract_byte(msg->value, 7); - char *boot_step_str = create_hex_string(byte4, 2); - uint32_t boot_status = (byte7 << 24) | (byte6 << 16) | (byte5 << 8) | byte0; - char *boot_status_str = create_hex_string(boot_status, 8); + char *boot_step_str = create_hex_string(byte4, 2); + uint32_t boot_status = (uint32_t)((byte7 << 24) | (byte6 << 16) | (byte5 << 8) | byte0); + char *boot_status_str = create_hex_string(boot_status, 8); - json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_UNHANDLED)); - json_object_set(result, "last_successful_boot_step_number", - json_create_string(boot_step_str ? boot_step_str : "0x00")); - json_object_set(result, "fw_boot_status", - json_create_string(boot_status_str ? boot_status_str : "0x00000000")); + json_object_set(result, "error_type", json_create_string(RAS_DECODE_ERROR_TYPE_UNHANDLED)); + json_object_set(result, "last_successful_boot_step_number", + json_create_string(boot_step_str ? boot_step_str : "0x00")); + json_object_set(result, "fw_boot_status", + json_create_string(boot_status_str ? boot_status_str : "0x00000000")); - free(boot_step_str); - free(boot_status_str); - return result; + free(boot_step_str); + free(boot_status_str); + return result; } -boot_decoder_func_t get_decoder_function(OamBootMsg *msg) -{ - if (!msg) - return NULL; - - uint8_t byte0 = extract_byte(msg->value, 0); - if (byte0 == BOOT_IN_BOOT_MARKER) - { - int version = get_boot_version(msg); - if (version == 1) - { - return decode_boot_success_v1; - } - } +boot_decoder_func_t get_decoder_function(OamBootMsg *msg) { + if (!msg) return NULL; + uint8_t byte0 = extract_byte(msg->value, 0); + if (byte0 == BOOT_IN_BOOT_MARKER) { int version = get_boot_version(msg); - int encoding = get_error_encoding(msg); - - const boot_decoder_entry_t *decoder_map = (version == 0) ? boot_decoder_map_v0 : boot_decoder_map_v1; - - for (int i = 0; decoder_map[i].decoder != NULL; i++) - { - if (decoder_map[i].encoding == encoding) - { - return decoder_map[i].decoder; - } + if (version == 1) { + return decode_boot_success_v1; } + } - return NULL; // No decoder found + int version = get_boot_version(msg); + int encoding = get_error_encoding(msg); + + const boot_decoder_entry_t *decoder_map = + (version == 0) ? boot_decoder_map_v0 : boot_decoder_map_v1; + + for (int i = 0; decoder_map[i].decoder != NULL; i++) { + if (decoder_map[i].encoding == encoding) { + return decoder_map[i].decoder; + } + } + + return NULL; // No decoder found } -JsonValue *boot_decode_orchestrator(uint64_t *oam_boot_msgs, size_t count) -{ - if (!oam_boot_msgs || count == 0) - return NULL; +JsonValue *boot_decode_orchestrator(const uint64_t *oam_boot_msgs, size_t count) { + if (!oam_boot_msgs || count == 0) return NULL; - JsonValue *results = json_create_object(); - if (!results) - return NULL; + JsonValue *results = json_create_object(); + if (!results) return NULL; - // Convert to OamBootMsg structures - OamBootMsg *msgs = malloc(count * sizeof(OamBootMsg)); - if (!msgs) - { - json_free(results); - return NULL; - } + // Convert to OamBootMsg structures + OamBootMsg *msgs = malloc(count * sizeof(OamBootMsg)); + if (!msgs) { + json_free(results); + return NULL; + } - for (size_t i = 0; i < count; i++) - { - msgs[i].value = oam_boot_msgs[i]; - } - - // Check error markers across all messages - size_t messages_with_markers = 0; - bool *has_marker = malloc(count * sizeof(bool)); - if (!has_marker) { - free(msgs); - json_free(results); - return NULL; - } - - // Count messages with error markers (0xA4) or boot markers (0xBA) - for (size_t i = 0; i < count; i++) - { - has_marker[i] = error_present(&msgs[i]) || in_boot(&msgs[i]); - if (has_marker[i]) { - messages_with_markers++; - } - } - - // Determine decoding strategy based on the presence of error markers - bool decode_all_as_unhandled = (messages_with_markers == 0); - bool decode_only_marked = (messages_with_markers > 0 && messages_with_markers < count); - bool decode_all_normally = (messages_with_markers == count); - - // Check if all decoders are NULL (for unhandled error handling) - bool all_decoders_none = true; - if (!decode_all_as_unhandled) { - for (size_t i = 0; i < count; i++) - { - if (has_marker[i] && get_decoder_function(&msgs[i]) != NULL) - { - all_decoders_none = false; - break; - } - } - } - - // Process each message - for (size_t i = 0; i < count; i++) - { - char msg_key[32]; - snprintf(msg_key, sizeof(msg_key), "msg%zu", i); - - // Skip messages without markers if we're in selective decode mode - if (decode_only_marked && !has_marker[i]) { - continue; - } - - JsonValue *msg_result = json_create_object(); - if (!msg_result) - continue; - - boot_decoder_func_t decoder_func = NULL; - - if (decode_all_as_unhandled) - { - // Rule 3: No messages have markers, decode all as UNHANDLED - decoder_func = decode_unhandled_error_v1; - } - else if (has_marker[i] || decode_all_normally) - { - // Rule 1 & 2: Decode messages with markers (or all if all have markers) - if (all_decoders_none) - { - // Use unhandled error decoders - int encoding = get_error_encoding(&msgs[i]); - decoder_func = (encoding == 0) ? decode_unhandled_error_v0 : decode_unhandled_error_v1; - } - else - { - decoder_func = get_decoder_function(&msgs[i]); - } - } - // If no decoder function is found, skip this message - - if (decoder_func) - { - JsonValue *decoded = decoder_func(&msgs[i]); - if (decoded) - { - // Copy all fields from decoded result to msg_result - for (JsonPair *pair = decoded->data.object; pair != NULL; pair = pair->next) - { - // Create a copy of the value for the new object - JsonValue *value_copy = NULL; - switch (pair->value->type) - { - case JSON_STRING: - value_copy = json_create_string(pair->value->data.string); - break; - case JSON_NUMBER: - value_copy = json_create_number(pair->value->data.number); - break; - case JSON_BOOL: - value_copy = json_create_bool(pair->value->data.boolean); - break; - case JSON_NULL: - value_copy = json_create_null(); - break; - case JSON_ARRAY: - // For arrays, we need to copy each element - value_copy = json_create_array(); - if (value_copy) - { - for (size_t j = 0; j < pair->value->data.array.count; j++) - { - JsonValue *elem = pair->value->data.array.items[j]; - JsonValue *elem_copy = NULL; - if (elem->type == JSON_NUMBER) - { - elem_copy = json_create_number(elem->data.number); - } - if (elem_copy) - { - json_array_push(value_copy, elem_copy); - } - } - } - break; - default: - break; - } - - if (value_copy) - { - json_object_set(msg_result, pair->key, value_copy); - } - } - json_free(decoded); - } - } - - json_object_set(results, msg_key, msg_result); - } + for (size_t i = 0; i < count; i++) { + msgs[i].value = oam_boot_msgs[i]; + } + // Check error markers across all messages + size_t messages_with_markers = 0; + bool *has_marker = malloc(count * sizeof(bool)); + if (!has_marker) { free(msgs); - free(has_marker); - return results; + json_free(results); + return NULL; + } + + // Count messages with error markers (0xA4) or boot markers (0xBA) + for (size_t i = 0; i < count; i++) { + has_marker[i] = error_present(&msgs[i]) || in_boot(&msgs[i]); + if (has_marker[i]) { + messages_with_markers++; + } + } + + // Determine decoding strategy based on the presence of error markers + bool decode_all_as_unhandled = (messages_with_markers == 0); + bool decode_only_marked = (messages_with_markers > 0 && messages_with_markers < count); + bool decode_all_normally = (messages_with_markers == count); + + // Check if all decoders are NULL (for unhandled error handling) + bool all_decoders_none = true; + if (!decode_all_as_unhandled) { + for (size_t i = 0; i < count; i++) { + if (has_marker[i] && get_decoder_function(&msgs[i]) != NULL) { + all_decoders_none = false; + break; + } + } + } + + // Process each message + for (size_t i = 0; i < count; i++) { + char msg_key[32]; + snprintf(msg_key, sizeof(msg_key), "msg%zu", i); + + // Skip messages without markers if we're in selective decode mode + if (decode_only_marked && !has_marker[i]) { + continue; + } + + JsonValue *msg_result = json_create_object(); + if (!msg_result) continue; + + boot_decoder_func_t decoder_func = NULL; + + if (decode_all_as_unhandled) { + // Rule 3: No messages have markers, decode all as UNHANDLED + decoder_func = decode_unhandled_error_v1; + } else if (has_marker[i] || decode_all_normally) { + // Rule 1 & 2: Decode messages with markers (or all if all have markers) + if (all_decoders_none) { + // Use unhandled error decoders + int encoding = get_error_encoding(&msgs[i]); + decoder_func = (encoding == 0) ? decode_unhandled_error_v0 : decode_unhandled_error_v1; + } else { + decoder_func = get_decoder_function(&msgs[i]); + } + } + // If no decoder function is found, skip this message + + if (decoder_func) { + JsonValue *decoded = decoder_func(&msgs[i]); + if (decoded) { + // Copy all fields from decoded result to msg_result + for (JsonPair *pair = decoded->data.object; pair != NULL; pair = pair->next) { + // Create a copy of the value for the new object + JsonValue *value_copy = NULL; + switch (pair->value->type) { + case JSON_STRING: + value_copy = json_create_string(pair->value->data.string); + break; + case JSON_NUMBER: + value_copy = json_create_number(pair->value->data.number); + break; + case JSON_BOOL: + value_copy = json_create_bool(pair->value->data.boolean); + break; + case JSON_NULL: + value_copy = json_create_null(); + break; + case JSON_ARRAY: + // For arrays, we need to copy each element + value_copy = json_create_array(); + if (value_copy) { + for (size_t j = 0; j < pair->value->data.array.count; j++) { + JsonValue *elem = pair->value->data.array.items[j]; + JsonValue *elem_copy = NULL; + if (elem->type == JSON_NUMBER) { + elem_copy = json_create_number(elem->data.number); + } + if (elem_copy) { + json_array_push(value_copy, elem_copy); + } + } + } + break; + default: + break; + } + + if (value_copy) { + json_object_set(msg_result, pair->key, value_copy); + } + } + json_free(decoded); + } + } + + json_object_set(results, msg_key, msg_result); + } + + free(msgs); + free(has_marker); + return results; } diff --git a/src/ras-decode/error_map.c b/src/ras-decode/error_map.c index 4acc9fb11a..4aea545507 100644 --- a/src/ras-decode/error_map.c +++ b/src/ras-decode/error_map.c @@ -21,68 +21,102 @@ */ #include "error_map.h" -#include "ras_decode_constants.h" + #include +#include "ras_decode_constants.h" + #define AFID_VERSION "0.7" static const error_map_entry_t error_map[] = { - {1, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_FW_LOAD, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {2, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_HBM_BIST_TEST, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {3, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_HBM_MEMORY_TEST, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {4, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_HBM_TRAINING, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {5, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_UNHANDLED, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {6, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_UNKNOWN_ERROR, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {7, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_USR_CP_LINK_TRAINING, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {8, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_USR_DP_LINK_TRAINING, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {9, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_WAFL_LINK_TRAINING, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {10, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_XGMI_LINK_TRAINING, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {11, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_DATA_ABORT, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {12, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_GENERIC, RAS_DECODE_PROTOCOL_CPER_WITH_SPACE, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, - {13, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_PCIE_AER, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, - {14, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_PCIE_AER, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {15, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_WAFL, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, - {16, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_WAFL, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {17, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_XGMI, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, - {18, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_XGMI, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {19, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {20, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {21, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {22, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL}, - {23, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL}, - {24, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_ALL, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, - {25, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_ALL_OTHERS, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {26, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_HARDWARE_ASSERTION, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {27, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_WATCHDOG_TIMEOUT, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {28, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_ALL_OTHERS, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL}, - {29, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_ALL_OTHERS, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, - {30, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_ALL_OTHERS, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, - {31, RAS_DECODE_CATEGORY_CPER_FORMAT, RAS_DECODE_ERROR_TYPE_MALFORMED_CPER, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_ALL_CAPS}, - {32, RAS_DECODE_CATEGORY_CPER_FORMAT, RAS_DECODE_ERROR_TYPE_INCOMPLETE_RAS_DECODE_DATA, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_ALL_CAPS}, - {33, RAS_DECODE_CATEGORY_CPER_FORMAT, RAS_DECODE_ERROR_TYPE_INVALID_RAS_DECODE_DATA, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_ALL_CAPS}, - {34, RAS_DECODE_CATEGORY_UNIDENTIFIED_ERRORS, RAS_DECODE_ERROR_TYPE_UNIDENTIFIED_ERROR, RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_ALL_CAPS}}; + {1, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_FW_LOAD, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {2, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_HBM_BIST_TEST, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {3, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_HBM_MEMORY_TEST, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {4, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_HBM_TRAINING, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {5, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_UNHANDLED, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {6, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_UNKNOWN_ERROR, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {7, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_USR_CP_LINK_TRAINING, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {8, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_USR_DP_LINK_TRAINING, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {9, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_WAFL_LINK_TRAINING, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {10, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_XGMI_LINK_TRAINING, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {11, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_DATA_ABORT, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {12, RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, RAS_DECODE_ERROR_TYPE_BOOT_CONTROLLER_GENERIC, + RAS_DECODE_PROTOCOL_CPER_WITH_SPACE, RAS_DECODE_SEVERITY_FAIL_TO_INIT}, + {13, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_PCIE_AER, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, + {14, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_PCIE_AER, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, + {15, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_WAFL, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, + {16, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_WAFL, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, + {17, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_XGMI, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, + {18, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS, RAS_DECODE_ERROR_TYPE_XGMI, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, + {19, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, + {20, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC, RAS_DECODE_PROTOCOL_CPER, + RAS_DECODE_SEVERITY_FATAL}, + {21, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, + {22, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC, RAS_DECODE_PROTOCOL_CPER, + RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL}, + {23, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL}, + {24, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_ALL, RAS_DECODE_PROTOCOL_CPER, + RAS_DECODE_SEVERITY_CORRECTED}, + {25, RAS_DECODE_CATEGORY_HBM_ERRORS, RAS_DECODE_ERROR_TYPE_ALL_OTHERS, RAS_DECODE_PROTOCOL_CPER, + RAS_DECODE_SEVERITY_FATAL}, + {26, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_HARDWARE_ASSERTION, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, + {27, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_WATCHDOG_TIMEOUT, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, + {28, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_ALL_OTHERS, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL}, + {29, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_ALL_OTHERS, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_CORRECTED}, + {30, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS, RAS_DECODE_ERROR_TYPE_ALL_OTHERS, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_FATAL}, + {31, RAS_DECODE_CATEGORY_CPER_FORMAT, RAS_DECODE_ERROR_TYPE_MALFORMED_CPER, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_ALL_CAPS}, + {32, RAS_DECODE_CATEGORY_CPER_FORMAT, RAS_DECODE_ERROR_TYPE_INCOMPLETE_RAS_DECODE_DATA, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_ALL_CAPS}, + {33, RAS_DECODE_CATEGORY_CPER_FORMAT, RAS_DECODE_ERROR_TYPE_INVALID_RAS_DECODE_DATA, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_ALL_CAPS}, + {34, RAS_DECODE_CATEGORY_UNIDENTIFIED_ERRORS, RAS_DECODE_ERROR_TYPE_UNIDENTIFIED_ERROR, + RAS_DECODE_PROTOCOL_CPER, RAS_DECODE_SEVERITY_ALL_CAPS}}; static const size_t NUM_ERROR_ENTRIES = sizeof(error_map) / sizeof(error_map[0]); -int get_error_id(const char *error_category, const char *error_type, const char *error_severity) -{ - if (!error_category || !error_type || !error_severity || - strcmp(error_category, RAS_DECODE_SEVERITY_UNKNOWN) == 0 || - strcmp(error_type, RAS_DECODE_SEVERITY_UNKNOWN) == 0 || - strcmp(error_severity, RAS_DECODE_SEVERITY_UNKNOWN) == 0) - { - return RAS_DECODE_ERROR_INVALID_RAS_DECODE_DATA_ID; // Return ID for "Invalid Error" if any input is "UNKNOWN" or NULL - } +int get_error_id(const char *error_category, const char *error_type, const char *error_severity) { + if (!error_category || !error_type || !error_severity || + strcmp(error_category, RAS_DECODE_SEVERITY_UNKNOWN) == 0 || + strcmp(error_type, RAS_DECODE_SEVERITY_UNKNOWN) == 0 || + strcmp(error_severity, RAS_DECODE_SEVERITY_UNKNOWN) == 0) { + return RAS_DECODE_ERROR_INVALID_RAS_DECODE_DATA_ID; // Return ID for "Invalid Error" if any + // input is "UNKNOWN" or NULL + } - for (size_t i = 0; i < NUM_ERROR_ENTRIES; i++) - { - if (strcmp(error_map[i].error_category, error_category) == 0 && - strcmp(error_map[i].error_type, error_type) == 0 && - strcmp(error_map[i].error_severity, error_severity) == 0) - { - return (int)error_map[i].id; - } + for (size_t i = 0; i < NUM_ERROR_ENTRIES; i++) { + if (strcmp(error_map[i].error_category, error_category) == 0 && + strcmp(error_map[i].error_type, error_type) == 0 && + strcmp(error_map[i].error_severity, error_severity) == 0) { + return (int)error_map[i].id; } + } - return RAS_DECODE_ERROR_UNIDENTIFIED_ERROR_ID; // Return ID for "Unidentified Errors" if no match found + return RAS_DECODE_ERROR_UNIDENTIFIED_ERROR_ID; // Return ID for "Unidentified Errors" if no match + // found } diff --git a/src/ras-decode/json_printer.c b/src/ras-decode/json_printer.c index a63c72d30d..4074ba1607 100644 --- a/src/ras-decode/json_printer.c +++ b/src/ras-decode/json_printer.c @@ -21,54 +21,55 @@ */ #include "json_printer.h" + #include static void print_json_value_internal(JsonValue *value, int indent) { - if (!value) return; - - switch (value->type) { - case JSON_NULL: - printf("null"); - break; - case JSON_BOOL: - printf("%s", value->data.boolean ? "true" : "false"); - break; - case JSON_NUMBER: - printf("%.0f", value->data.number); - break; - case JSON_STRING: - printf("\"%s\"", value->data.string ? value->data.string : ""); - break; - case JSON_OBJECT: { - printf("{\n"); - JsonPair *pair = value->data.object; - bool first = true; - while (pair) { - if (!first) printf(",\n"); - for (int i = 0; i < indent + 3; i++) printf(" "); - printf("\"%s\": ", pair->key); - print_json_value_internal(pair->value, indent + 3); - pair = pair->next; - first = false; - } - printf("\n"); - for (int i = 0; i < indent; i++) printf(" "); - printf("}"); - break; - } - case JSON_ARRAY: { - printf("["); - for (size_t i = 0; i < value->data.array.count; i++) { - if (i > 0) printf(", "); - print_json_value_internal(value->data.array.items[i], indent); - } - printf("]"); - break; - } + if (!value) return; + + switch (value->type) { + case JSON_NULL: + printf("null"); + break; + case JSON_BOOL: + printf("%s", value->data.boolean ? "true" : "false"); + break; + case JSON_NUMBER: + printf("%.0f", value->data.number); + break; + case JSON_STRING: + printf("\"%s\"", value->data.string ? value->data.string : ""); + break; + case JSON_OBJECT: { + printf("{\n"); + JsonPair *pair = value->data.object; + bool first = true; + while (pair) { + if (!first) printf(",\n"); + for (int i = 0; i < indent + 3; i++) printf(" "); + printf("\"%s\": ", pair->key); + print_json_value_internal(pair->value, indent + 3); + pair = pair->next; + first = false; + } + printf("\n"); + for (int i = 0; i < indent; i++) printf(" "); + printf("}"); + break; } + case JSON_ARRAY: { + printf("["); + for (size_t i = 0; i < value->data.array.count; i++) { + if (i > 0) printf(", "); + print_json_value_internal(value->data.array.items[i], indent); + } + printf("]"); + break; + } + } } void print_json_value(JsonValue *value) { - print_json_value_internal(value, 0); - printf("\n"); + print_json_value_internal(value, 0); + printf("\n"); } diff --git a/src/ras-decode/json_util.c b/src/ras-decode/json_util.c index 3e57a0d11a..fbad8870ce 100644 --- a/src/ras-decode/json_util.c +++ b/src/ras-decode/json_util.c @@ -21,185 +21,192 @@ */ #include "json_util.h" + #include #include #include #define JSON_ARRAY_INITIAL_CAPACITY 16 -JsonValue* json_create_null(void) { - JsonValue *val = calloc(1, sizeof(JsonValue)); - if (!val) return NULL; - val->type = JSON_NULL; - return val; +JsonValue *json_create_null(void) { + JsonValue *val = calloc(1, sizeof(JsonValue)); + if (!val) return NULL; + val->type = JSON_NULL; + return val; } -JsonValue* json_create_bool(bool b) { - JsonValue *val = calloc(1, sizeof(JsonValue)); - if (!val) return NULL; - val->type = JSON_BOOL; - val->data.boolean = b; - return val; +JsonValue *json_create_bool(bool b) { + JsonValue *val = calloc(1, sizeof(JsonValue)); + if (!val) return NULL; + val->type = JSON_BOOL; + val->data.boolean = b; + return val; } -JsonValue* json_create_number(double num) { - JsonValue *val = calloc(1, sizeof(JsonValue)); - if (!val) return NULL; - val->type = JSON_NUMBER; - val->data.number = num; - return val; +JsonValue *json_create_number(double num) { + JsonValue *val = calloc(1, sizeof(JsonValue)); + if (!val) return NULL; + val->type = JSON_NUMBER; + val->data.number = num; + return val; } -JsonValue* json_create_string(const char *str) { - if (!str) return NULL; - - JsonValue *val = calloc(1, sizeof(JsonValue)); - if (!val) return NULL; - - val->type = JSON_STRING; - val->data.string = strdup(str); - if (!val->data.string) { - free(val); - return NULL; - } - return val; +JsonValue *json_create_string(const char *str) { + if (!str) return NULL; + + JsonValue *val = calloc(1, sizeof(JsonValue)); + if (!val) return NULL; + + val->type = JSON_STRING; + val->data.string = strdup(str); + if (!val->data.string) { + free(val); + return NULL; + } + return val; } -JsonValue* json_create_object(void) { - JsonValue *val = calloc(1, sizeof(JsonValue)); - if (!val) return NULL; - val->type = JSON_OBJECT; - val->data.object = NULL; - return val; +JsonValue *json_create_object(void) { + JsonValue *val = calloc(1, sizeof(JsonValue)); + if (!val) return NULL; + val->type = JSON_OBJECT; + val->data.object = NULL; + return val; } -JsonValue* json_create_array(void) { - JsonValue *val = calloc(1, sizeof(JsonValue)); - if (!val) return NULL; - - val->type = JSON_ARRAY; - val->data.array.items = malloc(sizeof(JsonValue*) * JSON_ARRAY_INITIAL_CAPACITY); - if (!val->data.array.items) { - free(val); - return NULL; - } - val->data.array.count = 0; - val->data.array.capacity = JSON_ARRAY_INITIAL_CAPACITY; - return val; +JsonValue *json_create_array(void) { + JsonValue *val = calloc(1, sizeof(JsonValue)); + if (!val) return NULL; + + val->type = JSON_ARRAY; + val->data.array.items = malloc(sizeof(JsonValue *) * JSON_ARRAY_INITIAL_CAPACITY); + if (!val->data.array.items) { + free(val); + return NULL; + } + val->data.array.count = 0; + val->data.array.capacity = JSON_ARRAY_INITIAL_CAPACITY; + return val; } void json_object_set(JsonValue *obj, const char *key, JsonValue *value) { - if (!obj || obj->type != JSON_OBJECT || !key || !value) return; - - // Check if key already exists and update it - JsonPair *current = obj->data.object; - while (current) { - if (strcmp(current->key, key) == 0) { - json_free(current->value); - current->value = value; - return; - } - current = current->next; + if (!obj || obj->type != JSON_OBJECT || !key || !value) { + json_free(value); + return; + } + + // Check if key already exists and update it + JsonPair *current = obj->data.object; + while (current) { + if (strcmp(current->key, key) == 0) { + json_free(current->value); + current->value = value; + return; } - - // Key doesn't exist, create new pair - JsonPair *pair = malloc(sizeof(JsonPair)); - if (!pair) return; - - pair->key = strdup(key); - if (!pair->key) { - free(pair); - return; - } - - pair->value = value; - pair->next = NULL; - - if (!obj->data.object) { - obj->data.object = pair; - } else { - JsonPair *last = obj->data.object; - while (last->next) { - last = last->next; - } - last->next = pair; + current = current->next; + } + + // Key doesn't exist, create new pair + JsonPair *pair = malloc(sizeof(JsonPair)); + if (!pair) { + json_free(value); + return; + } + + pair->key = strdup(key); + if (!pair->key) { + free(pair); + json_free(value); + return; + } + + pair->value = value; + pair->next = NULL; + + if (!obj->data.object) { + obj->data.object = pair; + } else { + JsonPair *last = obj->data.object; + while (last->next) { + last = last->next; } + last->next = pair; + } } -JsonValue* json_object_get(JsonValue *obj, const char *key) { - if (!obj || obj->type != JSON_OBJECT || !key) return NULL; - - JsonPair *current = obj->data.object; - while (current) { - if (strcmp(current->key, key) == 0) { - return current->value; - } - current = current->next; +JsonValue *json_object_get(JsonValue *obj, const char *key) { + if (!obj || obj->type != JSON_OBJECT || !key) return NULL; + + JsonPair *current = obj->data.object; + while (current) { + if (strcmp(current->key, key) == 0) { + return current->value; } - return NULL; + current = current->next; + } + return NULL; } bool json_object_has_key(JsonValue *obj, const char *key) { - return json_object_get(obj, key) != NULL; + return json_object_get(obj, key) != NULL; } bool json_array_push(JsonValue *arr, JsonValue *value) { - if (!arr || arr->type != JSON_ARRAY || !value) return false; - - // Resize array if needed - if (arr->data.array.count >= arr->data.array.capacity) { - size_t new_capacity = arr->data.array.capacity * 2; - JsonValue **new_items = realloc(arr->data.array.items, - sizeof(JsonValue*) * new_capacity); - if (!new_items) return false; - - arr->data.array.items = new_items; - arr->data.array.capacity = new_capacity; - } - - arr->data.array.items[arr->data.array.count] = value; - arr->data.array.count++; - return true; + if (!arr || arr->type != JSON_ARRAY || !value) return false; + + // Resize array if needed + if (arr->data.array.count >= arr->data.array.capacity) { + size_t new_capacity = arr->data.array.capacity * 2; + JsonValue **new_items = realloc(arr->data.array.items, sizeof(JsonValue *) * new_capacity); + if (!new_items) return false; + + arr->data.array.items = new_items; + arr->data.array.capacity = new_capacity; + } + + arr->data.array.items[arr->data.array.count] = value; + arr->data.array.count++; + return true; } -JsonValue* json_array_get(JsonValue *arr, size_t index) { - if (!arr || arr->type != JSON_ARRAY || index >= arr->data.array.count) { - return NULL; - } - return arr->data.array.items[index]; +JsonValue *json_array_get(JsonValue *arr, size_t index) { + if (!arr || arr->type != JSON_ARRAY || index >= arr->data.array.count) { + return NULL; + } + return arr->data.array.items[index]; } size_t json_array_size(JsonValue *arr) { - if (!arr || arr->type != JSON_ARRAY) return 0; - return arr->data.array.count; + if (!arr || arr->type != JSON_ARRAY) return 0; + return arr->data.array.count; } void json_free(JsonValue *val) { - if (!val) return; - - switch (val->type) { - case JSON_STRING: - free(val->data.string); - break; - case JSON_OBJECT: { - JsonPair *current = val->data.object; - while (current) { - JsonPair *next = current->next; - free(current->key); - json_free(current->value); - free(current); - current = next; - } - break; - } - case JSON_ARRAY: - for (size_t i = 0; i < val->data.array.count; i++) { - json_free(val->data.array.items[i]); - } - free(val->data.array.items); - break; - default: - break; + if (!val) return; + + switch (val->type) { + case JSON_STRING: + free(val->data.string); + break; + case JSON_OBJECT: { + JsonPair *current = val->data.object; + while (current) { + JsonPair *next = current->next; + free(current->key); + json_free(current->value); + free(current); + current = next; + } + break; } - free(val); + case JSON_ARRAY: + for (size_t i = 0; i < val->data.array.count; i++) { + json_free(val->data.array.items[i]); + } + free(val->data.array.items); + break; + default: + break; + } + free(val); } diff --git a/src/ras-decode/main.c b/src/ras-decode/main.c index c0b007f859..1effe59d53 100644 --- a/src/ras-decode/main.c +++ b/src/ras-decode/main.c @@ -28,180 +28,183 @@ * with sample raw data to decode ACA error information. */ -#include -#include -#include -#include #include -#include -#include +#include #include +#include +#include +#include +#include +#include // Function prototype void print_version_info(void); void demonstrate_json_decoding(void); -void print_version_info(void) -{ - printf("=== ACA Decoder Library Version Information ===\n"); - printf("Version: %s\n", aca_get_version_string()); - printf("Major: %d\n", aca_get_version_major()); - printf("Minor: %d\n", aca_get_version_minor()); - printf("Patch: %d\n", aca_get_version_patch()); +void print_version_info(void) { + printf("=== ACA Decoder Library Version Information ===\n"); + printf("Version: %s\n", aca_get_version_string()); + printf("Major: %d\n", aca_get_version_major()); + printf("Minor: %d\n", aca_get_version_minor()); + printf("Patch: %d\n", aca_get_version_patch()); - aca_version_info_t version_info = aca_get_version_info(); - printf("Complete version info:\n"); - printf(" Major: %d\n", version_info.major); - printf(" Minor: %d\n", version_info.minor); - printf(" Patch: %d\n", version_info.patch); - printf(" String: %s\n", version_info.string); - printf("===============================================\n\n"); + aca_version_info_t version_info = aca_get_version_info(); + printf("Complete version info:\n"); + printf(" Major: %d\n", version_info.major); + printf(" Minor: %d\n", version_info.minor); + printf(" Patch: %d\n", version_info.patch); + printf(" String: %s\n", version_info.string); + printf("===============================================\n\n"); } // Function to demonstrate JSON decoding functionality -void demonstrate_json_decoding(void) -{ - printf("=== ACA Decoder - JSON Output Examples ===\n"); - - // Example 1: HBM FATAL ERROR (32-byte array) - uint64_t register_array_32[RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES] = {0xbaa000000004081b, 0x0, 0x209600090f00, 0x5d000000}; - printf("\n--- HBM FATAL ERROR (32-byte array) ---\n"); - printf("Decoded AFID: %d\n", decode_afid(register_array_32, RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES, 0, 1, 1)); - - JsonValue *json_result_32 = decode_error_info(register_array_32, RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES, 0, 1, 1); - if (json_result_32) { - print_json_value(json_result_32); - json_free(json_result_32); - } - - // Example 2: GC FATAL ERROR - uint64_t register_array_test[RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES] = {0xbea00000003b0000, 0x100000029, 0x1200136430400, 0x20b}; - printf("\n--- GC FATAL ERROR ---\n"); - printf("Decoded AFID: %d\n", decode_afid(register_array_test, RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES, 0, 1, 1)); - - JsonValue *json_result_test = decode_error_info(register_array_test, RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES, 0, 1, 1); - if (json_result_test) { - print_json_value(json_result_test); - json_free(json_result_test); - } - - // Example 3: HBM CORRECTED ERROR (128-byte array) - uint64_t register_array_128[RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES] = { - 0xffff, - 0xdc2040000000011b, - 0x0, - 0xd008000801000000, - 0x25000001ff, - 0x209600191f00, - 0xa000000, - 0x0, - 0x0, - 0x0, - 0xd008000801000000, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0}; - - printf("\n--- HBM CORRECTED ERROR (128-byte array) ---\n"); - printf("Decoded AFID: %d\n", decode_afid(register_array_128, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, 0, 1, 1)); - - JsonValue *json_result_128 = decode_error_info(register_array_128, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, 0, 1, 1); - if (json_result_128) { - print_json_value(json_result_128); - json_free(json_result_128); - } - - // Example 4: PCS XGMI Error - uint64_t register_array_pcs_xgmi[RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES] = { - 0xffffffff, - 0x9820000000060150, - 0x0, - 0xd008000200000000, - 0x27000001f9, - 0xe05012109201, - 0xaf812d4a000000, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0}; - - printf("\n--- PCS XGMI Error ---\n"); - printf("Decoded AFID: %d\n", decode_afid(register_array_pcs_xgmi, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, 0, 1, 1)); - - JsonValue *json_result_pcs = decode_error_info(register_array_pcs_xgmi, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, 0, 1, 1); - if (json_result_pcs) { - print_json_value(json_result_pcs); - json_free(json_result_pcs); - } - - // Example 5: Bad page (threshold exceeded flag) - uint64_t register_array_bad_page[RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES] = { - 0x1, - 0xb000000000000137, - 0x0, - 0x0, - 0x1ff00000002, - 0x9600000000, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0, - 0x0}; - - printf("\n--- Bad Page (Threshold Exceeded) ---\n"); - printf("Decoded AFID: %d\n", decode_afid(register_array_bad_page, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, RAS_DECODE_FLAG_THRESHOLD_EXCEEDED, 1, 1)); - - JsonValue *json_result_bad_page = decode_error_info(register_array_bad_page, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, RAS_DECODE_FLAG_THRESHOLD_EXCEEDED, 1, 1); - if (json_result_bad_page) { - print_json_value(json_result_bad_page); - json_free(json_result_bad_page); - } +void demonstrate_json_decoding(void) { + printf("=== ACA Decoder - JSON Output Examples ===\n"); - // Example 6: Boot Error Demo - uint64_t boot_messages[8] = { - 0x3c000228a4, // Oam0bootmsg - 0x3c001228a4, // Oam1bootmsg - 0x3c002228a4, // Oam2bootmsg - 0x3c003128a4, // Oam3bootmsg - 0x3c004328a4, // Oam4bootmsg - 0x3c005228a4, // Oam5bootmsg - 0x3c006228a4, // Oam6bootmsg - 0x3c007228a4 // Oam7bootmsg - }; - - printf("\n--- Boot Error Demo ---\n"); - printf("Decoded AFID: %d\n", decode_afid(boot_messages, sizeof(boot_messages)/sizeof(boot_messages[0]), 0, 1, 9)); - - JsonValue *json_result_boot = decode_error_info(boot_messages, sizeof(boot_messages)/sizeof(boot_messages[0]), 0, 1, 9); - if (json_result_boot) { - print_json_value(json_result_boot); - json_free(json_result_boot); - } else { - printf("Failed to decode boot messages\n"); - } - - printf("\n===========================================\n"); + // Example 1: HBM FATAL ERROR (32-byte array) + uint64_t register_array_32[RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES] = { + 0xbaa000000004081b, 0x0, 0x209600090f00, 0x5d000000}; + printf("\n--- HBM FATAL ERROR (32-byte array) ---\n"); + printf("Decoded AFID: %d\n", + decode_afid(register_array_32, RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES, 0, 1, 1)); + + JsonValue *json_result_32 = + decode_error_info(register_array_32, RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES, 0, 1, 1); + if (json_result_32) { + print_json_value(json_result_32); + json_free(json_result_32); + } + + // Example 2: GC FATAL ERROR + uint64_t register_array_test[RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES] = { + 0xbea00000003b0000, 0x100000029, 0x1200136430400, 0x20b}; + printf("\n--- GC FATAL ERROR ---\n"); + printf("Decoded AFID: %d\n", + decode_afid(register_array_test, RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES, 0, 1, 1)); + + JsonValue *json_result_test = + decode_error_info(register_array_test, RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES, 0, 1, 1); + if (json_result_test) { + print_json_value(json_result_test); + json_free(json_result_test); + } + + // Example 3: HBM CORRECTED ERROR (128-byte array) + uint64_t register_array_128[RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES] = {0xffff, + 0xdc2040000000011b, + 0x0, + 0xd008000801000000, + 0x25000001ff, + 0x209600191f00, + 0xa000000, + 0x0, + 0x0, + 0x0, + 0xd008000801000000, + 0x0, + 0x0, + 0x0, + 0x0, + 0x0}; + + printf("\n--- HBM CORRECTED ERROR (128-byte array) ---\n"); + printf("Decoded AFID: %d\n", + decode_afid(register_array_128, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, 0, 1, 1)); + + JsonValue *json_result_128 = + decode_error_info(register_array_128, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, 0, 1, 1); + if (json_result_128) { + print_json_value(json_result_128); + json_free(json_result_128); + } + + // Example 4: PCS XGMI Error + uint64_t register_array_pcs_xgmi[RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES] = {0xffffffff, + 0x9820000000060150, + 0x0, + 0xd008000200000000, + 0x27000001f9, + 0xe05012109201, + 0xaf812d4a000000, + 0x0, + 0x0, + 0x0, + 0x0, + 0x0, + 0x0, + 0x0, + 0x0, + 0x0}; + + printf("\n--- PCS XGMI Error ---\n"); + printf("Decoded AFID: %d\n", + decode_afid(register_array_pcs_xgmi, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, 0, 1, 1)); + + JsonValue *json_result_pcs = + decode_error_info(register_array_pcs_xgmi, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, 0, 1, 1); + if (json_result_pcs) { + print_json_value(json_result_pcs); + json_free(json_result_pcs); + } + + // Example 5: Bad page (threshold exceeded flag) + uint64_t register_array_bad_page[RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES] = { + 0x1, 0xb000000000000137, + 0x0, 0x0, + 0x1ff00000002, 0x9600000000, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0, + 0x0, 0x0}; + + printf("\n--- Bad Page (Threshold Exceeded) ---\n"); + printf("Decoded AFID: %d\n", + decode_afid(register_array_bad_page, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, + RAS_DECODE_FLAG_THRESHOLD_EXCEEDED, 1, 1)); + + JsonValue *json_result_bad_page = + decode_error_info(register_array_bad_page, RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES, + RAS_DECODE_FLAG_THRESHOLD_EXCEEDED, 1, 1); + if (json_result_bad_page) { + print_json_value(json_result_bad_page); + json_free(json_result_bad_page); + } + + // Example 6: Boot Error Demo + uint64_t boot_messages[8] = { + 0x3c000228a4, // Oam0bootmsg + 0x3c001228a4, // Oam1bootmsg + 0x3c002228a4, // Oam2bootmsg + 0x3c003128a4, // Oam3bootmsg + 0x3c004328a4, // Oam4bootmsg + 0x3c005228a4, // Oam5bootmsg + 0x3c006228a4, // Oam6bootmsg + 0x3c007228a4 // Oam7bootmsg + }; + + printf("\n--- Boot Error Demo ---\n"); + printf("Decoded AFID: %d\n", + decode_afid(boot_messages, sizeof(boot_messages) / sizeof(boot_messages[0]), 0, 1, 9)); + + JsonValue *json_result_boot = + decode_error_info(boot_messages, sizeof(boot_messages) / sizeof(boot_messages[0]), 0, 1, 9); + if (json_result_boot) { + print_json_value(json_result_boot); + json_free(json_result_boot); + } else { + printf("Failed to decode boot messages\n"); + } + + printf("\n===========================================\n"); } -int main() -{ - // Display version information - print_version_info(); +int main() { + // Display version information + print_version_info(); - // Demonstrate the new JSON-based ACA decoding functionality - demonstrate_json_decoding(); + // Demonstrate the new JSON-based ACA decoding functionality + demonstrate_json_decoding(); - return 0; + return 0; } diff --git a/src/ras-decode/ras_decode_api.c b/src/ras-decode/ras_decode_api.c index 3078dbb4fa..0530af149f 100644 --- a/src/ras-decode/ras_decode_api.c +++ b/src/ras-decode/ras_decode_api.c @@ -20,185 +20,174 @@ * THE SOFTWARE. */ -#include "aca_decode.h" -#include "ras_decode_constants.h" -#include "boot_decode.h" -#include "error_map.h" -#include "json_util.h" #include #include #include -int decode_afid(const uint64_t *register_array, size_t array_len, uint32_t flag, uint16_t hw_revision, uint16_t register_context_type) -{ - if (!register_array) - { - return -1; - } +#include "aca_decode.h" +#include "boot_decode.h" +#include "error_map.h" +#include "json_util.h" +#include "ras_decode_constants.h" - // Use decode_error_info to get the JSON result - JsonValue *json_result = decode_error_info(register_array, array_len, flag, hw_revision, register_context_type); - if (!json_result) { - return -1; - } - - // Use the decode_error_info_afid function to extract AFID - int afid = decode_error_info_afid(json_result); - - json_free(json_result); - return afid; +int decode_afid(const uint64_t *register_array, size_t array_len, uint32_t flag, + uint16_t hw_revision, uint16_t register_context_type) { + if (!register_array) { + return -1; + } + + // Use decode_error_info to get the JSON result + JsonValue *json_result = + decode_error_info(register_array, array_len, flag, hw_revision, register_context_type); + if (!json_result) { + return -1; + } + + // Use the decode_error_info_afid function to extract AFID + int afid = decode_error_info_afid(json_result); + + json_free(json_result); + return afid; } -JsonValue* decode_error_info(const uint64_t *register_array, size_t array_len, uint32_t flag, uint16_t hw_revision, uint16_t register_context_type) -{ - if (!register_array) - { - return NULL; - } - - // Check register context type parameter - if (register_context_type == 9) - { - // For boot decode, use boot_decode_orchestrator with register_array and array_len - // Flag is not used in boot decode - return boot_decode_orchestrator((uint64_t*)register_array, array_len); - } - else if (register_context_type == 1) - { - // For ACA decode, use existing logic - aca_raw_data_t raw_data = {0}; - - if (array_len == RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES) // 32 bytes - { - raw_data.aca_status = register_array[0]; - raw_data.aca_addr = register_array[1]; - raw_data.aca_ipid = register_array[2]; - raw_data.aca_synd = register_array[3]; - } - else if (array_len == RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES) // 128 bytes - { - raw_data.aca_status = register_array[1]; - raw_data.aca_addr = register_array[2]; - raw_data.aca_ipid = register_array[5]; - raw_data.aca_synd = register_array[6]; - } - else - { - return NULL; // Unsupported size - } +JsonValue *decode_error_info(const uint64_t *register_array, size_t array_len, uint32_t flag, + uint16_t hw_revision, uint16_t register_context_type) { + if (!register_array) { + return NULL; + } - raw_data.flags = flag; - raw_data.hw_revision = hw_revision; + // Check register context type parameter + if (register_context_type == 9) { + // For boot decode, use boot_decode_orchestrator with register_array and array_len + // Flag is not used in boot decode + return boot_decode_orchestrator(register_array, array_len); + } else if (register_context_type == 1) { + // For ACA decode, use existing logic + aca_raw_data_t raw_data = {0}; - return aca_decode(&raw_data); - } - else + if (array_len == RAS_DECODE_REGISTER_ARRAY_SIZE_32_BYTES) // 32 bytes { - return NULL; // Invalid register context type + raw_data.aca_status = register_array[0]; + raw_data.aca_addr = register_array[1]; + raw_data.aca_ipid = register_array[2]; + raw_data.aca_synd = register_array[3]; + } else if (array_len == RAS_DECODE_REGISTER_ARRAY_SIZE_128_BYTES) // 128 bytes + { + raw_data.aca_status = register_array[1]; + raw_data.aca_addr = register_array[2]; + raw_data.aca_ipid = register_array[5]; + raw_data.aca_synd = register_array[6]; + } else { + return NULL; // Unsupported size } + + raw_data.flags = flag; + raw_data.hw_revision = hw_revision; + + return aca_decode(&raw_data); + } else { + return NULL; // Invalid register context type + } } -int decode_error_info_afid(JsonValue *error_json) -{ - if (!error_json || error_json->type != JSON_OBJECT) { - return -1; // Invalid AFID for null or invalid JSON +int decode_error_info_afid(JsonValue *error_json) { + if (!error_json || error_json->type != JSON_OBJECT) { + return -1; // Invalid AFID for null or invalid JSON + } + + // Check if this is MCA error + JsonValue *category_value = json_object_get(error_json, "error_category"); + JsonValue *type_value = json_object_get(error_json, "error_type"); + JsonValue *severity_value = json_object_get(error_json, "severity"); + + if (category_value && type_value && severity_value && category_value->type == JSON_STRING && + type_value->type == JSON_STRING && severity_value->type == JSON_STRING) { + const char *error_category = category_value->data.string; + const char *error_type = type_value->data.string; + const char *error_severity = severity_value->data.string; + + // Check for the specific case: HBM Errors + Bad Page Retirement Threshold + Fatal + if (strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0 && + strcmp(error_type, RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD) == 0 && + strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0) { + // Use the error_type directly as service_error for this case + return get_error_id(error_category, error_type, error_severity); } - // Check if this is MCA error - JsonValue *category_value = json_object_get(error_json, "error_category"); - JsonValue *type_value = json_object_get(error_json, "error_type"); - JsonValue *severity_value = json_object_get(error_json, "severity"); + // For other cases, we need to determine the service_error_type based on the logic + // from get_service_error_type function + const char *service_error = NULL; - if (category_value && type_value && severity_value && - category_value->type == JSON_STRING && type_value->type == JSON_STRING && severity_value->type == JSON_STRING) { - const char *error_category = category_value->data.string; - const char *error_type = type_value->data.string; - const char *error_severity = severity_value->data.string; + // Extract bank if needed for service error type determination + JsonValue *bank_value = json_object_get(error_json, "bank"); + const char *error_bank = + (bank_value && bank_value->type == JSON_STRING) ? bank_value->data.string : ""; - // Check for the specific case: HBM Errors + Bad Page Retirement Threshold + Fatal - if (strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0 && - strcmp(error_type, RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD) == 0 && - strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0) { - - // Use the error_type directly as service_error for this case - return get_error_id(error_category, error_type, error_severity); - } - - // For other cases, we need to determine the service_error_type based on the logic - // from get_service_error_type function - const char *service_error = NULL; - - // Extract bank if needed for service error type determination - JsonValue *bank_value = json_object_get(error_json, "bank"); - const char *error_bank = (bank_value && bank_value->type == JSON_STRING) ? bank_value->data.string : ""; - - if (strcmp(error_type, RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD) == 0) { - service_error = RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD; - } - else if (strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0 && strcmp(error_severity, RAS_DECODE_SEVERITY_CORRECTED) == 0) { - service_error = RAS_DECODE_ERROR_TYPE_ALL; - } - else if (strcmp(error_type, "RdCrcErr") == 0) { - service_error = RAS_DECODE_ERROR_TYPE_END_TO_END_CRC; - } - else if (strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0 && strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0 && - strcmp(error_type, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC) != 0 && strcmp(error_type, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC) != 0) { - service_error = RAS_DECODE_ERROR_TYPE_ALL_OTHERS; - } - else if (strcmp(error_category, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS) == 0) { - if ((strcmp(error_severity, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL) == 0 || - strcmp(error_severity, RAS_DECODE_SEVERITY_CORRECTED) == 0 || - strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0) && - strcmp(error_type, RAS_DECODE_ERROR_TYPE_HARDWARE_ASSERTION) != 0 && - strcmp(error_type, RAS_DECODE_ERROR_TYPE_WATCHDOG_TIMEOUT) != 0) { - service_error = RAS_DECODE_ERROR_TYPE_ALL_OTHERS; - } - } - else if (strcmp(error_category, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS) == 0) { - if (strcmp(error_bank, RAS_DECODE_BANK_PCS_XGMI) == 0) { - service_error = RAS_DECODE_ERROR_TYPE_XGMI; - } - else if (strcmp(error_bank, RAS_DECODE_BANK_KPX_WAFL) == 0) { - service_error = RAS_DECODE_ERROR_TYPE_WAFL; - } - } - - if (!service_error) { - service_error = error_type; // Fallback to error_type - } - - return get_error_id(error_category, service_error, error_severity); + if (strcmp(error_type, RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD) == 0) { + service_error = RAS_DECODE_ERROR_TYPE_BAD_PAGE_RETIREMENT_THRESHOLD; + } else if (strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0 && + strcmp(error_severity, RAS_DECODE_SEVERITY_CORRECTED) == 0) { + service_error = RAS_DECODE_ERROR_TYPE_ALL; + } else if (strcmp(error_type, "RdCrcErr") == 0) { + service_error = RAS_DECODE_ERROR_TYPE_END_TO_END_CRC; + } else if (strcmp(error_category, RAS_DECODE_CATEGORY_HBM_ERRORS) == 0 && + strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0 && + strcmp(error_type, RAS_DECODE_ERROR_TYPE_ON_DIE_ECC) != 0 && + strcmp(error_type, RAS_DECODE_ERROR_TYPE_END_TO_END_CRC) != 0) { + service_error = RAS_DECODE_ERROR_TYPE_ALL_OTHERS; + } else if (strcmp(error_category, RAS_DECODE_CATEGORY_DEVICE_INTERNAL_ERRORS) == 0) { + if ((strcmp(error_severity, RAS_DECODE_SEVERITY_UNCORRECTED_NON_FATAL) == 0 || + strcmp(error_severity, RAS_DECODE_SEVERITY_CORRECTED) == 0 || + strcmp(error_severity, RAS_DECODE_SEVERITY_FATAL) == 0) && + strcmp(error_type, RAS_DECODE_ERROR_TYPE_HARDWARE_ASSERTION) != 0 && + strcmp(error_type, RAS_DECODE_ERROR_TYPE_WATCHDOG_TIMEOUT) != 0) { + service_error = RAS_DECODE_ERROR_TYPE_ALL_OTHERS; + } + } else if (strcmp(error_category, RAS_DECODE_CATEGORY_OFF_PACKAGE_LINK_ERRORS) == 0) { + if (strcmp(error_bank, RAS_DECODE_BANK_PCS_XGMI) == 0) { + service_error = RAS_DECODE_ERROR_TYPE_XGMI; + } else if (strcmp(error_bank, RAS_DECODE_BANK_KPX_WAFL) == 0) { + service_error = RAS_DECODE_ERROR_TYPE_WAFL; + } } - - // Check if this is a boot error - // Find the first msg key to get the error_type - JsonPair *current_pair = error_json->data.object; - JsonValue *first_msg = NULL; - int lowest_msg_index = INT_MAX; - - while (current_pair) { - if (strncmp(current_pair->key, "msg", 3) == 0) { - // Extract the message index - int msg_index = atoi(current_pair->key + 3); - if (msg_index < lowest_msg_index) { - lowest_msg_index = msg_index; - first_msg = current_pair->value; - } - } - current_pair = current_pair->next; + + if (!service_error) { + service_error = error_type; // Fallback to error_type } - - if (first_msg && first_msg->type == JSON_OBJECT) { - // This is a boot error - extract error_type from the first message - JsonValue *boot_error_type = json_object_get(first_msg, "error_type"); - if (boot_error_type && boot_error_type->type == JSON_STRING) { - const char *service_error = NULL; - service_error = boot_error_type->data.string; - - // For boot errors, always use Boot-Time Errors category and Fail-to-init severity - return get_error_id(RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, service_error, RAS_DECODE_SEVERITY_FAIL_TO_INIT); - } + + return get_error_id(error_category, service_error, error_severity); + } + + // Check if this is a boot error + // Find the first msg key to get the error_type + JsonPair *current_pair = error_json->data.object; + JsonValue *first_msg = NULL; + int lowest_msg_index = INT_MAX; + + while (current_pair) { + if (strncmp(current_pair->key, "msg", 3) == 0) { + // Extract the message index + int msg_index = atoi(current_pair->key + 3); + if (msg_index < lowest_msg_index) { + lowest_msg_index = msg_index; + first_msg = current_pair->value; + } } - - return -1; // Invalid AFID if neither MCA nor boot error format + current_pair = current_pair->next; + } + + if (first_msg && first_msg->type == JSON_OBJECT) { + // This is a boot error - extract error_type from the first message + JsonValue *boot_error_type = json_object_get(first_msg, "error_type"); + if (boot_error_type && boot_error_type->type == JSON_STRING) { + const char *service_error = NULL; + service_error = boot_error_type->data.string; + + // For boot errors, always use Boot-Time Errors category and Fail-to-init severity + return get_error_id(RAS_DECODE_CATEGORY_BOOT_TIME_ERRORS, service_error, + RAS_DECODE_SEVERITY_FAIL_TO_INIT); + } + } + + return -1; // Invalid AFID if neither MCA nor boot error format }