1 /** 2 * Describes functions for converting ARM CPER sections from binary and JSON format 3 * into an intermediate format. 4 * 5 * Author: Lawrence.Tang@arm.com 6 **/ 7 8 #include <stdio.h> 9 #include "json.h" 10 #include "b64.h" 11 #include "../edk/Cper.h" 12 #include "../cper-utils.h" 13 #include "cper-section-arm.h" 14 15 //Private pre-definitions. 16 json_object* cper_arm_error_info_to_ir(EFI_ARM_ERROR_INFORMATION_ENTRY* error_info); 17 json_object* cper_arm_processor_context_to_ir(EFI_ARM_CONTEXT_INFORMATION_HEADER* header, void** cur_pos); 18 json_object* cper_arm_cache_tlb_error_to_ir(EFI_ARM_CACHE_ERROR_STRUCTURE* cache_tlb_error, EFI_ARM_ERROR_INFORMATION_ENTRY* error_info); 19 json_object* cper_arm_bus_error_to_ir(EFI_ARM_BUS_ERROR_STRUCTURE* bus_error); 20 json_object* cper_arm_misc_register_array_to_ir(EFI_ARM_MISC_CONTEXT_REGISTER* misc_register); 21 22 //Converts the given processor-generic CPER section into JSON IR. 23 json_object* cper_section_arm_to_ir(void* section, EFI_ERROR_SECTION_DESCRIPTOR* descriptor) 24 { 25 EFI_ARM_ERROR_RECORD* record = (EFI_ARM_ERROR_RECORD*)section; 26 json_object* section_ir = json_object_new_object(); 27 28 //Validation bits. 29 json_object* validation = bitfield_to_ir(record->ValidFields, 4, ARM_ERROR_VALID_BITFIELD_NAMES); 30 json_object_object_add(section_ir, "validationBits", validation); 31 32 //Number of error info and context info structures, and length. 33 json_object_object_add(section_ir, "errorInfoNum", json_object_new_int(record->ErrInfoNum)); 34 json_object_object_add(section_ir, "contextInfoNum", json_object_new_int(record->ContextInfoNum)); 35 json_object_object_add(section_ir, "sectionLength", json_object_new_int(record->SectionLength)); 36 37 //Error affinity. 38 json_object* error_affinity = json_object_new_object(); 39 json_object_object_add(error_affinity, "value", json_object_new_int(record->ErrorAffinityLevel)); 40 json_object_object_add(error_affinity, "type", 41 json_object_new_string(record->ErrorAffinityLevel < 4 ? "Vendor Defined" : "Reserved")); 42 json_object_object_add(section_ir, "errorAffinity", error_affinity); 43 44 //Processor ID (MPIDR_EL1) and chip ID (MIDR_EL1). 45 json_object_object_add(section_ir, "mpidrEl1", json_object_new_uint64(record->MPIDR_EL1)); 46 json_object_object_add(section_ir, "midrEl1", json_object_new_uint64(record->MIDR_EL1)); 47 48 //Whether the processor is running, and the state of it if so. 49 json_object_object_add(section_ir, "running", json_object_new_boolean(record->RunningState)); 50 if (record->RunningState >> 31) 51 { 52 //Bit 32 of running state is on, so PSCI state information is included. 53 //This can't be made human readable, as it is unknown whether this will be the pre-PSCI 1.0 format 54 //or the newer Extended StateID format. 55 json_object_object_add(section_ir, "psciState", json_object_new_int(record->PsciState)); 56 } 57 58 //Processor error structures. 59 json_object* error_info_array = json_object_new_array(); 60 EFI_ARM_ERROR_INFORMATION_ENTRY* cur_error = (EFI_ARM_ERROR_INFORMATION_ENTRY*)(record + 1); 61 for (int i=0; i<record->ErrInfoNum; i++) 62 { 63 json_object_array_add(error_info_array, cper_arm_error_info_to_ir(cur_error)); 64 cur_error++; 65 } 66 json_object_object_add(section_ir, "errorInfo", error_info_array); 67 68 //Processor context structures. 69 //The current position is moved within the processing, as it is a dynamic size structure. 70 void* cur_pos = (void*)cur_error; 71 EFI_ARM_CONTEXT_INFORMATION_HEADER* header = (EFI_ARM_CONTEXT_INFORMATION_HEADER*)cur_error; 72 json_object* processor_context = cper_arm_processor_context_to_ir(header, &cur_pos); 73 74 //Is there any vendor-specific information following? 75 if (cur_pos < section + record->SectionLength) 76 { 77 json_object* vendor_specific = json_object_new_object(); 78 char* encoded = b64_encode((unsigned char*)cur_pos, section + record->SectionLength - cur_pos); 79 json_object_object_add(vendor_specific, "data", json_object_new_string(encoded)); 80 free(encoded); 81 82 json_object_object_add(section_ir, "vendorSpecificInfo", vendor_specific); 83 } 84 85 return section_ir; 86 } 87 88 //Converts a single ARM Process Error Information structure into JSON IR. 89 json_object* cper_arm_error_info_to_ir(EFI_ARM_ERROR_INFORMATION_ENTRY* error_info) 90 { 91 json_object* error_info_ir = json_object_new_object(); 92 93 //Version, length. 94 json_object_object_add(error_info_ir, "version", json_object_new_int(error_info->Version)); 95 json_object_object_add(error_info_ir, "length", json_object_new_int(error_info->Length)); 96 97 //Validation bitfield. 98 json_object* validation = bitfield_to_ir(error_info->ValidationBits, 5, ARM_ERROR_INFO_ENTRY_VALID_BITFIELD_NAMES); 99 json_object_object_add(error_info_ir, "validationBits", validation); 100 101 //The type of error information in this log. 102 //todo: The UEFI spec is ambiguous, what are the values for these?? 103 json_object* error_type = integer_to_readable_pair(error_info->Type, 4, 104 ARM_ERROR_INFO_ENTRY_INFO_TYPES_KEYS, 105 ARM_ERROR_INFO_ENTRY_INFO_TYPES_VALUES, 106 "Unknown (Reserved)"); 107 json_object_object_add(error_info_ir, "errorType", error_type); 108 109 //Multiple error count. 110 json_object* multiple_error = json_object_new_object(); 111 json_object_object_add(multiple_error, "value", json_object_new_int(error_info->MultipleError)); 112 json_object_object_add(multiple_error, "type", 113 json_object_new_string(error_info->MultipleError < 1 ? "Single Error" : "Multiple Errors")); 114 json_object_object_add(error_info_ir, "multipleError", multiple_error); 115 116 //Flags. 117 json_object* flags = bitfield_to_ir(error_info->Flags, 4, ARM_ERROR_INFO_ENTRY_FLAGS_NAMES); 118 json_object_object_add(error_info_ir, "flags", flags); 119 120 //Error information, split by type. 121 json_object* error_subinfo = NULL; 122 switch (error_info->Type) 123 { 124 case 0: //Cache 125 case 1: //TLB 126 error_subinfo = cper_arm_cache_tlb_error_to_ir((EFI_ARM_CACHE_ERROR_STRUCTURE*)&error_info->ErrorInformation, error_info); 127 break; 128 case 2: //Bus 129 error_subinfo = cper_arm_bus_error_to_ir((EFI_ARM_BUS_ERROR_STRUCTURE*)&error_info->ErrorInformation); 130 break; 131 } 132 json_object_object_add(error_info_ir, "errorInformation", error_subinfo); 133 134 //Virtual fault address, physical fault address. 135 json_object_object_add(error_info_ir, "virtualFaultAddress", json_object_new_uint64(error_info->VirtualFaultAddress)); 136 json_object_object_add(error_info_ir, "physicalFaultAddress", json_object_new_uint64(error_info->PhysicalFaultAddress)); 137 138 return error_info_ir; 139 } 140 141 //Converts a single ARM cache/TLB error information structure into JSON IR format. 142 json_object* cper_arm_cache_tlb_error_to_ir(EFI_ARM_CACHE_ERROR_STRUCTURE* cache_tlb_error, EFI_ARM_ERROR_INFORMATION_ENTRY* error_info) 143 { 144 json_object* cache_tlb_error_ir = json_object_new_object(); 145 146 //Validation bitfield. 147 json_object* validation = bitfield_to_ir(cache_tlb_error->ValidationBits, 7, ARM_CACHE_TLB_ERROR_VALID_BITFIELD_NAMES); 148 json_object_object_add(cache_tlb_error_ir, "validationBits", validation); 149 150 //Transaction type. 151 json_object* transaction_type = integer_to_readable_pair(cache_tlb_error->TransactionType, 3, 152 ARM_ERROR_TRANSACTION_TYPES_KEYS, 153 ARM_ERROR_TRANSACTION_TYPES_VALUES, 154 "Unknown (Reserved)"); 155 json_object_object_add(cache_tlb_error_ir, "transactionType", transaction_type); 156 157 //Operation. 158 //todo: What are the types' numeric values? UEFI spec is ambiguous 159 json_object* operation; 160 if (error_info->Type == 0) 161 { 162 //Cache operation. 163 operation = integer_to_readable_pair(cache_tlb_error->Operation, 11, 164 ARM_CACHE_BUS_OPERATION_TYPES_KEYS, 165 ARM_CACHE_BUS_OPERATION_TYPES_VALUES, 166 "Unknown (Reserved)"); 167 } 168 else 169 { 170 //TLB operation. 171 operation = integer_to_readable_pair(cache_tlb_error->Operation, 9, 172 ARM_TLB_OPERATION_TYPES_KEYS, 173 ARM_TLB_OPERATION_TYPES_VALUES, 174 "Unknown (Reserved)"); 175 } 176 json_object_object_add(cache_tlb_error_ir, "operation", operation); 177 178 //Miscellaneous remaining fields. 179 json_object_object_add(cache_tlb_error_ir, "level", json_object_new_int(cache_tlb_error->Level)); 180 json_object_object_add(cache_tlb_error_ir, "processorContextCorrupt", json_object_new_boolean(cache_tlb_error->ProcessorContextCorrupt)); 181 json_object_object_add(cache_tlb_error_ir, "corrected", json_object_new_boolean(cache_tlb_error->Corrected)); 182 json_object_object_add(cache_tlb_error_ir, "precisePC", json_object_new_boolean(cache_tlb_error->PrecisePC)); 183 json_object_object_add(cache_tlb_error_ir, "restartablePC", json_object_new_boolean(cache_tlb_error->RestartablePC)); 184 return cache_tlb_error_ir; 185 } 186 187 //Converts a single ARM bus error information structure into JSON IR format. 188 json_object* cper_arm_bus_error_to_ir(EFI_ARM_BUS_ERROR_STRUCTURE* bus_error) 189 { 190 json_object* bus_error_ir = json_object_new_object(); 191 192 //Validation bits. 193 json_object* validation = bitfield_to_ir(bus_error->ValidationBits, 7, ARM_BUS_ERROR_VALID_BITFIELD_NAMES); 194 json_object_object_add(bus_error_ir, "validationBits", validation); 195 196 //Transaction type. 197 json_object* transaction_type = integer_to_readable_pair(bus_error->TransactionType, 3, 198 ARM_ERROR_TRANSACTION_TYPES_KEYS, 199 ARM_ERROR_TRANSACTION_TYPES_VALUES, 200 "Unknown (Reserved)"); 201 json_object_object_add(bus_error_ir, "transactionType", transaction_type); 202 203 //Operation. 204 json_object* operation = integer_to_readable_pair(bus_error->Operation, 7, 205 ARM_CACHE_BUS_OPERATION_TYPES_KEYS, 206 ARM_CACHE_BUS_OPERATION_TYPES_VALUES, 207 "Unknown (Reserved)"); 208 json_object_object_add(bus_error_ir, "operation", operation); 209 210 //Affinity level of bus error, + miscellaneous fields. 211 json_object_object_add(bus_error_ir, "level", json_object_new_int(bus_error->Level)); 212 json_object_object_add(bus_error_ir, "processorContextCorrupt", json_object_new_boolean(bus_error->ProcessorContextCorrupt)); 213 json_object_object_add(bus_error_ir, "corrected", json_object_new_boolean(bus_error->Corrected)); 214 json_object_object_add(bus_error_ir, "precisePC", json_object_new_boolean(bus_error->PrecisePC)); 215 json_object_object_add(bus_error_ir, "restartablePC", json_object_new_boolean(bus_error->RestartablePC)); 216 json_object_object_add(bus_error_ir, "timedOut", json_object_new_boolean(bus_error->TimeOut)); 217 218 //Participation type. 219 json_object* participation_type = integer_to_readable_pair(bus_error->ParticipationType, 4, 220 ARM_BUS_PARTICIPATION_TYPES_KEYS, 221 ARM_BUS_PARTICIPATION_TYPES_VALUES, 222 "Unknown"); 223 json_object_object_add(bus_error_ir, "participationType", participation_type); 224 225 //Address space. 226 json_object* address_space = integer_to_readable_pair(bus_error->AddressSpace, 3, 227 ARM_BUS_ADDRESS_SPACE_TYPES_KEYS, 228 ARM_BUS_ADDRESS_SPACE_TYPES_VALUES, 229 "Unknown"); 230 json_object_object_add(bus_error_ir, "addressSpace", address_space); 231 232 //Memory access attributes. 233 //todo: find the specification of these in the ARM ARM 234 //... 235 236 //Access Mode 237 json_object* access_mode = json_object_new_object(); 238 json_object_object_add(access_mode, "value", json_object_new_int(bus_error->AccessMode)); 239 json_object_object_add(access_mode, "name", json_object_new_string(bus_error->AccessMode == 0 ? "Secure" : "Normal")); 240 json_object_object_add(bus_error_ir, "accessMode", access_mode); 241 242 return bus_error_ir; 243 } 244 245 //Converts a single ARM processor context block into JSON IR. 246 json_object* cper_arm_processor_context_to_ir(EFI_ARM_CONTEXT_INFORMATION_HEADER* header, void** cur_pos) 247 { 248 json_object* context_ir = json_object_new_object(); 249 250 //Add the context type. 251 json_object* context_type = integer_to_readable_pair(header->RegisterContextType, 9, 252 ARM_PROCESSOR_INFO_REGISTER_CONTEXT_TYPES_KEYS, 253 ARM_PROCESSOR_INFO_REGISTER_CONTEXT_TYPES_VALUES, 254 "Unknown (Reserved)"); 255 json_object_object_add(context_ir, "registerContextType", context_type); 256 257 //Register array size (bytes). 258 json_object_object_add(context_ir, "registerArraySize", json_object_new_uint64(header->RegisterArraySize)); 259 260 //The register array itself. 261 *cur_pos = (void*)(header + 1); 262 json_object* register_array = NULL; 263 switch (header->RegisterContextType) 264 { 265 case EFI_ARM_CONTEXT_TYPE_AARCH32_GPR: 266 register_array = uniform_struct_to_ir((UINT32*)cur_pos, 267 sizeof(EFI_ARM_V8_AARCH32_GPR) / sizeof(UINT32), ARM_AARCH32_GPR_NAMES); 268 break; 269 case EFI_ARM_CONTEXT_TYPE_AARCH32_EL1: 270 register_array = uniform_struct_to_ir((UINT32*)cur_pos, 271 sizeof(EFI_ARM_AARCH32_EL1_CONTEXT_REGISTERS) / sizeof(UINT32), ARM_AARCH32_EL1_REGISTER_NAMES); 272 break; 273 case EFI_ARM_CONTEXT_TYPE_AARCH32_EL2: 274 register_array = uniform_struct_to_ir((UINT32*)cur_pos, 275 sizeof(EFI_ARM_AARCH32_EL2_CONTEXT_REGISTERS) / sizeof(UINT32), ARM_AARCH32_EL2_REGISTER_NAMES); 276 break; 277 case EFI_ARM_CONTEXT_TYPE_AARCH32_SECURE: 278 register_array = uniform_struct_to_ir((UINT32*)cur_pos, 279 sizeof(EFI_ARM_AARCH32_SECURE_CONTEXT_REGISTERS) / sizeof(UINT32), ARM_AARCH32_SECURE_REGISTER_NAMES); 280 break; 281 case EFI_ARM_CONTEXT_TYPE_AARCH64_GPR: 282 register_array = uniform_struct64_to_ir((UINT64*)cur_pos, 283 sizeof(EFI_ARM_V8_AARCH64_GPR) / sizeof(UINT64), ARM_AARCH64_GPR_NAMES); 284 break; 285 case EFI_ARM_CONTEXT_TYPE_AARCH64_EL1: 286 register_array = uniform_struct64_to_ir((UINT64*)cur_pos, 287 sizeof(EFI_ARM_AARCH64_EL1_CONTEXT_REGISTERS) / sizeof(UINT64), ARM_AARCH64_EL1_REGISTER_NAMES); 288 break; 289 case EFI_ARM_CONTEXT_TYPE_AARCH64_EL2: 290 register_array = uniform_struct64_to_ir((UINT64*)cur_pos, 291 sizeof(EFI_ARM_AARCH64_EL2_CONTEXT_REGISTERS) / sizeof(UINT64), ARM_AARCH64_EL2_REGISTER_NAMES); 292 break; 293 case EFI_ARM_CONTEXT_TYPE_AARCH64_EL3: 294 register_array = uniform_struct64_to_ir((UINT64*)cur_pos, 295 sizeof(EFI_ARM_AARCH64_EL3_CONTEXT_REGISTERS) / sizeof(UINT64), ARM_AARCH64_EL3_REGISTER_NAMES); 296 break; 297 case EFI_ARM_CONTEXT_TYPE_MISC: 298 register_array = cper_arm_misc_register_array_to_ir((EFI_ARM_MISC_CONTEXT_REGISTER*)cur_pos); 299 break; 300 default: 301 //Unknown register array type, add as base64 data instead. 302 register_array = json_object_new_object(); 303 char* encoded = b64_encode((unsigned char*)cur_pos, header->RegisterArraySize); 304 json_object_object_add(register_array, "data", json_object_new_string(encoded)); 305 free(encoded); 306 break; 307 } 308 309 //Set the current position to after the processor context structure. 310 *cur_pos = (UINT8*)(*cur_pos) + header->RegisterArraySize; 311 312 return context_ir; 313 } 314 315 //Converts a single CPER ARM miscellaneous register array to JSON IR format. 316 json_object* cper_arm_misc_register_array_to_ir(EFI_ARM_MISC_CONTEXT_REGISTER* misc_register) 317 { 318 json_object* register_array = json_object_new_object(); 319 json_object* mrs_encoding = json_object_new_object(); 320 json_object_object_add(mrs_encoding, "op2", json_object_new_int(misc_register->MrsOp2)); 321 json_object_object_add(mrs_encoding, "crm", json_object_new_int(misc_register->MrsOp2)); 322 json_object_object_add(mrs_encoding, "crn", json_object_new_int(misc_register->MrsOp2)); 323 json_object_object_add(mrs_encoding, "op1", json_object_new_int(misc_register->MrsOp2)); 324 json_object_object_add(mrs_encoding, "o0", json_object_new_int(misc_register->MrsOp2)); 325 json_object_object_add(register_array, "mrsEncoding", mrs_encoding); 326 json_object_object_add(register_array, "value", json_object_new_uint64(misc_register->Value)); 327 328 return register_array; 329 }