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