Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 1 | /** |
| 2 | * Describes functions for converting PCI/PCI-X device CPER sections from binary and JSON format |
| 3 | * into an intermediate format. |
Ed Tanous | fedd457 | 2024-07-12 13:56:00 -0700 | [diff] [blame] | 4 | * |
Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 5 | * Author: Lawrence.Tang@arm.com |
| 6 | **/ |
| 7 | #include <stdio.h> |
Lawrence Tang | 5202bbb | 2022-08-12 14:54:36 +0100 | [diff] [blame] | 8 | #include <json.h> |
Thu Nguyen | e42fb48 | 2024-10-15 14:43:11 +0000 | [diff] [blame] | 9 | #include <libcper/Cper.h> |
| 10 | #include <libcper/cper-utils.h> |
| 11 | #include <libcper/sections/cper-section-pci-dev.h> |
Ed Tanous | 50b966f | 2025-03-11 09:06:19 -0700 | [diff] [blame] | 12 | #include <libcper/log.h> |
Aushim Nagarkatti | ad6c880 | 2025-06-18 16:45:28 -0700 | [diff] [blame^] | 13 | #include <string.h> |
Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 14 | |
| 15 | //Converts a single PCI/PCI-X device CPER section into JSON IR. |
Aushim Nagarkatti | ad6c880 | 2025-06-18 16:45:28 -0700 | [diff] [blame^] | 16 | json_object *cper_section_pci_dev_to_ir(const UINT8 *section, UINT32 size, |
| 17 | char **desc_string) |
Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 18 | { |
Aushim Nagarkatti | ad6c880 | 2025-06-18 16:45:28 -0700 | [diff] [blame^] | 19 | int outstr_len = 0; |
| 20 | *desc_string = malloc(SECTION_DESC_STRING_SIZE); |
| 21 | outstr_len = snprintf(*desc_string, SECTION_DESC_STRING_SIZE, |
| 22 | "A PCI/PCI-X Device Error occurred"); |
| 23 | if (outstr_len < 0) { |
| 24 | cper_print_log( |
| 25 | "Error: Could not write to PCI/PCI-X Device description string\n"); |
| 26 | } else if (outstr_len > SECTION_DESC_STRING_SIZE) { |
| 27 | cper_print_log( |
| 28 | "Error: PCI/PCI-X Device description string truncated\n"); |
| 29 | } |
| 30 | |
Ed Tanous | 12dbd4f | 2025-03-08 19:05:01 -0800 | [diff] [blame] | 31 | if (size < sizeof(EFI_PCI_PCIX_DEVICE_ERROR_DATA)) { |
| 32 | return NULL; |
| 33 | } |
| 34 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 35 | EFI_PCI_PCIX_DEVICE_ERROR_DATA *dev_error = |
| 36 | (EFI_PCI_PCIX_DEVICE_ERROR_DATA *)section; |
Ed Tanous | 12dbd4f | 2025-03-08 19:05:01 -0800 | [diff] [blame] | 37 | |
| 38 | if (size < sizeof(EFI_PCI_PCIX_DEVICE_ERROR_DATA) + |
| 39 | ((dev_error->MemoryNumber + dev_error->IoNumber) * |
| 40 | sizeof(EFI_PCI_PCIX_DEVICE_ERROR_DATA_REGISTER))) { |
| 41 | return NULL; |
| 42 | } |
| 43 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 44 | json_object *section_ir = json_object_new_object(); |
Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 45 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 46 | //Validation bits. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 47 | ValidationTypes ui64Type = { UINT_64T, |
| 48 | .value.ui64 = dev_error->ValidFields }; |
Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 49 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 50 | //Error status. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 51 | if (isvalid_prop_to_ir(&ui64Type, 0)) { |
| 52 | json_object *error_status = cper_generic_error_status_to_ir( |
| 53 | &dev_error->ErrorStatus); |
| 54 | json_object_object_add(section_ir, "errorStatus", error_status); |
| 55 | } |
Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 56 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 57 | //ID information. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 58 | if (isvalid_prop_to_ir(&ui64Type, 1)) { |
| 59 | json_object *id_info = json_object_new_object(); |
| 60 | json_object_object_add( |
| 61 | id_info, "vendorID", |
| 62 | json_object_new_uint64(dev_error->IdInfo.VendorId)); |
| 63 | json_object_object_add( |
| 64 | id_info, "deviceID", |
| 65 | json_object_new_uint64(dev_error->IdInfo.DeviceId)); |
| 66 | json_object_object_add( |
| 67 | id_info, "classCode", |
| 68 | json_object_new_uint64(dev_error->IdInfo.ClassCode)); |
| 69 | json_object_object_add( |
| 70 | id_info, "functionNumber", |
| 71 | json_object_new_uint64( |
| 72 | dev_error->IdInfo.FunctionNumber)); |
| 73 | json_object_object_add( |
| 74 | id_info, "deviceNumber", |
| 75 | json_object_new_uint64(dev_error->IdInfo.DeviceNumber)); |
| 76 | json_object_object_add( |
| 77 | id_info, "busNumber", |
| 78 | json_object_new_uint64(dev_error->IdInfo.BusNumber)); |
| 79 | json_object_object_add( |
| 80 | id_info, "segmentNumber", |
| 81 | json_object_new_uint64( |
| 82 | dev_error->IdInfo.SegmentNumber)); |
| 83 | json_object_object_add(section_ir, "idInfo", id_info); |
| 84 | } |
Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 85 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 86 | //Number of following register data pairs. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 87 | if (isvalid_prop_to_ir(&ui64Type, 2)) { |
| 88 | json_object_object_add( |
| 89 | section_ir, "memoryNumber", |
| 90 | json_object_new_uint64(dev_error->MemoryNumber)); |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 91 | } |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 92 | if (isvalid_prop_to_ir(&ui64Type, 3)) { |
| 93 | json_object_object_add( |
| 94 | section_ir, "ioNumber", |
| 95 | json_object_new_uint64(dev_error->IoNumber)); |
| 96 | } |
| 97 | |
| 98 | if (isvalid_prop_to_ir(&ui64Type, 4)) { |
| 99 | int num_data_pairs = |
| 100 | dev_error->MemoryNumber + dev_error->IoNumber; |
| 101 | |
| 102 | //Register pairs, described by the numeric fields. |
| 103 | //The actual "pairs" of address and data aren't necessarily 8 bytes long, so can't assume the contents. |
| 104 | //Hence the naming "firstHalf" and "secondHalf" rather than "address" and "data". |
| 105 | json_object *register_data_pair_array = json_object_new_array(); |
| 106 | UINT64 *cur_pos = (UINT64 *)(dev_error + 1); |
| 107 | for (int i = 0; i < num_data_pairs; i++) { |
| 108 | //Save current pair to array. |
| 109 | json_object *register_data_pair = |
| 110 | json_object_new_object(); |
| 111 | json_object_object_add( |
| 112 | register_data_pair, "firstHalf", |
| 113 | json_object_new_uint64(*cur_pos)); |
| 114 | json_object_object_add( |
| 115 | register_data_pair, "secondHalf", |
| 116 | json_object_new_uint64(*(cur_pos + 1))); |
| 117 | json_object_array_add(register_data_pair_array, |
| 118 | register_data_pair); |
| 119 | |
| 120 | //Move to next pair. |
| 121 | cur_pos += 2; |
| 122 | } |
| 123 | json_object_object_add(section_ir, "registerDataPairs", |
| 124 | register_data_pair_array); |
| 125 | } |
Lawrence Tang | a416ec9 | 2022-07-06 14:34:40 +0100 | [diff] [blame] | 126 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 127 | return section_ir; |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 128 | } |
| 129 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 130 | void ir_section_pci_dev_to_cper(json_object *section, FILE *out) |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 131 | { |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 132 | EFI_PCI_PCIX_DEVICE_ERROR_DATA *section_cper = |
| 133 | (EFI_PCI_PCIX_DEVICE_ERROR_DATA *)calloc( |
| 134 | 1, sizeof(EFI_PCI_PCIX_DEVICE_ERROR_DATA)); |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 135 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 136 | //Validation bits. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 137 | ValidationTypes ui64Type = { UINT_64T, .value.ui64 = 0 }; |
| 138 | struct json_object *obj = NULL; |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 139 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 140 | //Error status. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 141 | if (json_object_object_get_ex(section, "errorStatus", &obj)) { |
| 142 | ir_generic_error_status_to_cper(obj, |
| 143 | §ion_cper->ErrorStatus); |
| 144 | add_to_valid_bitfield(&ui64Type, 0); |
| 145 | } |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 146 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 147 | //Device ID information. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 148 | if (json_object_object_get_ex(section, "idInfo", &obj)) { |
| 149 | json_object *id_info = obj; |
| 150 | section_cper->IdInfo.VendorId = json_object_get_uint64( |
| 151 | json_object_object_get(id_info, "vendorID")); |
| 152 | section_cper->IdInfo.DeviceId = json_object_get_uint64( |
| 153 | json_object_object_get(id_info, "deviceID")); |
| 154 | section_cper->IdInfo.ClassCode = json_object_get_uint64( |
| 155 | json_object_object_get(id_info, "classCode")); |
| 156 | section_cper->IdInfo.FunctionNumber = json_object_get_uint64( |
| 157 | json_object_object_get(id_info, "functionNumber")); |
| 158 | section_cper->IdInfo.DeviceNumber = json_object_get_uint64( |
| 159 | json_object_object_get(id_info, "deviceNumber")); |
| 160 | section_cper->IdInfo.BusNumber = json_object_get_uint64( |
| 161 | json_object_object_get(id_info, "busNumber")); |
| 162 | section_cper->IdInfo.SegmentNumber = json_object_get_uint64( |
| 163 | json_object_object_get(id_info, "segmentNumber")); |
| 164 | add_to_valid_bitfield(&ui64Type, 1); |
| 165 | } |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 166 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 167 | //Amount of following data pairs. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 168 | if (json_object_object_get_ex(section, "memoryNumber", &obj)) { |
| 169 | section_cper->MemoryNumber = |
| 170 | (UINT32)json_object_get_uint64(obj); |
| 171 | add_to_valid_bitfield(&ui64Type, 2); |
| 172 | } |
| 173 | if (json_object_object_get_ex(section, "ioNumber", &obj)) { |
| 174 | section_cper->IoNumber = (UINT32)json_object_get_uint64(obj); |
| 175 | add_to_valid_bitfield(&ui64Type, 3); |
| 176 | } |
| 177 | json_object *register_pairs = NULL; |
| 178 | if (json_object_object_get_ex(section, "registerDataPairs", &obj)) { |
| 179 | register_pairs = obj; |
| 180 | add_to_valid_bitfield(&ui64Type, 4); |
| 181 | } |
| 182 | |
| 183 | section_cper->ValidFields = ui64Type.value.ui64; |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 184 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 185 | //Write header out to stream, free it. |
| 186 | fwrite(section_cper, sizeof(EFI_PCI_PCIX_DEVICE_ERROR_DATA), 1, out); |
| 187 | fflush(out); |
| 188 | free(section_cper); |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 189 | |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 190 | //Begin writing register pairs. |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 191 | if (register_pairs != NULL) { |
| 192 | int num_pairs = json_object_array_length(register_pairs); |
| 193 | for (int i = 0; i < num_pairs; i++) { |
| 194 | //Get the pair array item out. |
| 195 | json_object *register_pair = |
| 196 | json_object_array_get_idx(register_pairs, i); |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 197 | |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 198 | //Create the pair array. |
| 199 | UINT64 pair[2]; |
| 200 | pair[0] = json_object_get_uint64(json_object_object_get( |
| 201 | register_pair, "firstHalf")); |
| 202 | pair[1] = json_object_get_uint64(json_object_object_get( |
| 203 | register_pair, "secondHalf")); |
Lawrence Tang | 205dd1d | 2022-07-14 16:23:38 +0100 | [diff] [blame] | 204 | |
Aushim Nagarkatti | ae8f6d9 | 2025-01-29 17:34:44 -0800 | [diff] [blame] | 205 | //Push to stream. |
| 206 | fwrite(pair, sizeof(UINT64), 2, out); |
| 207 | fflush(out); |
| 208 | } |
Lawrence Tang | e407b4c | 2022-07-21 13:54:01 +0100 | [diff] [blame] | 209 | } |
John Chung | f8fc705 | 2024-05-03 20:05:29 +0800 | [diff] [blame] | 210 | } |