1 /**
2 * Describes high level functions for converting an entire CPER log, and functions for parsing
3 * CPER headers and section descriptions into an intermediate JSON format.
4 *
5 * Author: Lawrence.Tang@arm.com
6 **/
7
8 #include <stdio.h>
9 #include <string.h>
10 #include <json.h>
11 #include <libcper/base64.h>
12 #include <libcper/Cper.h>
13 #include <libcper/cper-parse.h>
14 #include <libcper/cper-parse-str.h>
15 #include <libcper/cper-utils.h>
16 #include <libcper/sections/cper-section.h>
17
18 //Private pre-definitions.
19 json_object *cper_header_to_ir(EFI_COMMON_ERROR_RECORD_HEADER *header);
20 json_object *
21 cper_section_descriptor_to_ir(EFI_ERROR_SECTION_DESCRIPTOR *section_descriptor);
22 json_object *cper_section_to_ir(FILE *handle, long base_pos,
23 EFI_ERROR_SECTION_DESCRIPTOR *descriptor);
24
25 //Reads a CPER log file at the given file location, and returns an intermediate
26 //JSON representation of this CPER record.
cper_to_ir(FILE * cper_file)27 json_object *cper_to_ir(FILE *cper_file)
28 {
29 //Read the current file pointer location as the base of the record.
30 long base_pos = ftell(cper_file);
31
32 //Ensure this is really a CPER log.
33 EFI_COMMON_ERROR_RECORD_HEADER header;
34 if (fread(&header, sizeof(EFI_COMMON_ERROR_RECORD_HEADER), 1,
35 cper_file) != 1) {
36 printf("Invalid CPER file: Invalid length (log too short).\n");
37 return NULL;
38 }
39
40 //Check if the header contains the magic bytes ("CPER").
41 if (header.SignatureStart != EFI_ERROR_RECORD_SIGNATURE_START) {
42 printf("Invalid CPER file: Invalid header (incorrect signature).\n");
43 return NULL;
44 }
45
46 //Create the header JSON object from the read bytes.
47 json_object *header_ir = cper_header_to_ir(&header);
48
49 //Read the appropriate number of section descriptors & sections, and convert them into IR format.
50 json_object *section_descriptors_ir = json_object_new_array();
51 json_object *sections_ir = json_object_new_array();
52 for (int i = 0; i < header.SectionCount; i++) {
53 //Create the section descriptor.
54 EFI_ERROR_SECTION_DESCRIPTOR section_descriptor;
55 if (fread(§ion_descriptor,
56 sizeof(EFI_ERROR_SECTION_DESCRIPTOR), 1,
57 cper_file) != 1) {
58 printf("Invalid number of section headers: Header states %d sections, could not read section %d.\n",
59 header.SectionCount, i + 1);
60 // Free json objects
61 json_object_put(sections_ir);
62 json_object_put(section_descriptors_ir);
63 json_object_put(header_ir);
64 return NULL;
65 }
66 json_object_array_add(
67 section_descriptors_ir,
68 cper_section_descriptor_to_ir(§ion_descriptor));
69
70 //Read the section itself.
71
72 json_object_array_add(sections_ir,
73 cper_section_to_ir(cper_file, base_pos,
74 §ion_descriptor));
75 }
76
77 //Add the header, section descriptors, and sections to a parent object.
78 json_object *parent = json_object_new_object();
79 json_object_object_add(parent, "header", header_ir);
80 json_object_object_add(parent, "sectionDescriptors",
81 section_descriptors_ir);
82 json_object_object_add(parent, "sections", sections_ir);
83
84 return parent;
85 }
86
cper_to_str_ir(FILE * cper_file)87 char *cper_to_str_ir(FILE *cper_file)
88 {
89 json_object *jobj = cper_to_ir(cper_file);
90 char *str = jobj ? strdup(json_object_to_json_string(jobj)) : NULL;
91
92 json_object_put(jobj);
93 return str;
94 }
95
cperbuf_to_str_ir(const unsigned char * cper,size_t size)96 char *cperbuf_to_str_ir(const unsigned char *cper, size_t size)
97 {
98 FILE *cper_file = fmemopen((void *)cper, size, "r");
99
100 return cper_file ? cper_to_str_ir(cper_file) : NULL;
101 }
102
103 //Converts a parsed CPER record header into intermediate JSON object format.
cper_header_to_ir(EFI_COMMON_ERROR_RECORD_HEADER * header)104 json_object *cper_header_to_ir(EFI_COMMON_ERROR_RECORD_HEADER *header)
105 {
106 json_object *header_ir = json_object_new_object();
107
108 //Revision/version information.
109 json_object_object_add(header_ir, "revision",
110 revision_to_ir(header->Revision));
111
112 //Section count.
113 json_object_object_add(header_ir, "sectionCount",
114 json_object_new_int(header->SectionCount));
115
116 //Error severity (with interpreted string version).
117 json_object *error_severity = json_object_new_object();
118 json_object_object_add(error_severity, "code",
119 json_object_new_uint64(header->ErrorSeverity));
120 json_object_object_add(error_severity, "name",
121 json_object_new_string(severity_to_string(
122 header->ErrorSeverity)));
123 json_object_object_add(header_ir, "severity", error_severity);
124
125 //Total length of the record (including headers) in bytes.
126 json_object_object_add(header_ir, "recordLength",
127 json_object_new_uint64(header->RecordLength));
128
129 //If a timestamp exists according to validation bits, then add it.
130 if (header->ValidationBits & 0x2) {
131 char timestamp_string[TIMESTAMP_LENGTH];
132 timestamp_to_string(timestamp_string, TIMESTAMP_LENGTH,
133 &header->TimeStamp);
134
135 json_object_object_add(
136 header_ir, "timestamp",
137 json_object_new_string(timestamp_string));
138 json_object_object_add(
139 header_ir, "timestampIsPrecise",
140 json_object_new_boolean(header->TimeStamp.Flag));
141 }
142
143 //If a platform ID exists according to the validation bits, then add it.
144 if (header->ValidationBits & 0x1) {
145 char platform_string[GUID_STRING_LENGTH];
146 guid_to_string(platform_string, &header->PlatformID);
147 json_object_object_add(header_ir, "platformID",
148 json_object_new_string(platform_string));
149 }
150
151 //If a partition ID exists according to the validation bits, then add it.
152 if (header->ValidationBits & 0x4) {
153 char partition_string[GUID_STRING_LENGTH];
154 guid_to_string(partition_string, &header->PartitionID);
155 json_object_object_add(
156 header_ir, "partitionID",
157 json_object_new_string(partition_string));
158 }
159
160 //Creator ID of the header.
161 char creator_string[GUID_STRING_LENGTH];
162 guid_to_string(creator_string, &header->CreatorID);
163 json_object_object_add(header_ir, "creatorID",
164 json_object_new_string(creator_string));
165
166 //Notification type for the header. Some defined types are available.
167 json_object *notification_type = json_object_new_object();
168 char notification_type_string[GUID_STRING_LENGTH];
169 guid_to_string(notification_type_string, &header->NotificationType);
170 json_object_object_add(
171 notification_type, "guid",
172 json_object_new_string(notification_type_string));
173
174 //Add the human readable notification type if possible.
175 char *notification_type_readable = "Unknown";
176 if (guid_equal(&header->NotificationType,
177 &gEfiEventNotificationTypeCmcGuid)) {
178 notification_type_readable = "CMC";
179 } else if (guid_equal(&header->NotificationType,
180 &gEfiEventNotificationTypeCpeGuid)) {
181 notification_type_readable = "CPE";
182 } else if (guid_equal(&header->NotificationType,
183 &gEfiEventNotificationTypeMceGuid)) {
184 notification_type_readable = "MCE";
185 } else if (guid_equal(&header->NotificationType,
186 &gEfiEventNotificationTypePcieGuid)) {
187 notification_type_readable = "PCIe";
188 } else if (guid_equal(&header->NotificationType,
189 &gEfiEventNotificationTypeInitGuid)) {
190 notification_type_readable = "INIT";
191 } else if (guid_equal(&header->NotificationType,
192 &gEfiEventNotificationTypeNmiGuid)) {
193 notification_type_readable = "NMI";
194 } else if (guid_equal(&header->NotificationType,
195 &gEfiEventNotificationTypeBootGuid)) {
196 notification_type_readable = "Boot";
197 } else if (guid_equal(&header->NotificationType,
198 &gEfiEventNotificationTypeDmarGuid)) {
199 notification_type_readable = "DMAr";
200 } else if (guid_equal(&header->NotificationType,
201 &gEfiEventNotificationTypeSeaGuid)) {
202 notification_type_readable = "SEA";
203 } else if (guid_equal(&header->NotificationType,
204 &gEfiEventNotificationTypeSeiGuid)) {
205 notification_type_readable = "SEI";
206 } else if (guid_equal(&header->NotificationType,
207 &gEfiEventNotificationTypePeiGuid)) {
208 notification_type_readable = "PEI";
209 } else if (guid_equal(&header->NotificationType,
210 &gEfiEventNotificationTypeCxlGuid)) {
211 notification_type_readable = "CXL Component";
212 }
213 json_object_object_add(
214 notification_type, "type",
215 json_object_new_string(notification_type_readable));
216 json_object_object_add(header_ir, "notificationType",
217 notification_type);
218
219 //The record ID for this record, unique on a given system.
220 json_object_object_add(header_ir, "recordID",
221 json_object_new_uint64(header->RecordID));
222
223 //Flag for the record, and a human readable form.
224 json_object *flags = integer_to_readable_pair(
225 header->Flags,
226 sizeof(CPER_HEADER_FLAG_TYPES_KEYS) / sizeof(int),
227 CPER_HEADER_FLAG_TYPES_KEYS, CPER_HEADER_FLAG_TYPES_VALUES,
228 "Unknown");
229 json_object_object_add(header_ir, "flags", flags);
230
231 //Persistence information. Outside the scope of specification, so just a uint32 here.
232 json_object_object_add(header_ir, "persistenceInfo",
233 json_object_new_uint64(header->PersistenceInfo));
234 return header_ir;
235 }
236
237 //Converts the given EFI section descriptor into JSON IR format.
238 json_object *
cper_section_descriptor_to_ir(EFI_ERROR_SECTION_DESCRIPTOR * section_descriptor)239 cper_section_descriptor_to_ir(EFI_ERROR_SECTION_DESCRIPTOR *section_descriptor)
240 {
241 json_object *section_descriptor_ir = json_object_new_object();
242
243 //The offset of the section from the base of the record header, length.
244 json_object_object_add(
245 section_descriptor_ir, "sectionOffset",
246 json_object_new_uint64(section_descriptor->SectionOffset));
247 json_object_object_add(
248 section_descriptor_ir, "sectionLength",
249 json_object_new_uint64(section_descriptor->SectionLength));
250
251 //Revision.
252 json_object_object_add(section_descriptor_ir, "revision",
253 revision_to_ir(section_descriptor->Revision));
254
255 //Flag bits.
256 json_object *flags =
257 bitfield_to_ir(section_descriptor->SectionFlags, 8,
258 CPER_SECTION_DESCRIPTOR_FLAGS_BITFIELD_NAMES);
259 json_object_object_add(section_descriptor_ir, "flags", flags);
260
261 //Section type (GUID).
262 json_object *section_type = json_object_new_object();
263 char section_type_string[GUID_STRING_LENGTH];
264 guid_to_string(section_type_string, §ion_descriptor->SectionType);
265 json_object_object_add(section_type, "data",
266 json_object_new_string(section_type_string));
267
268 //Readable section type, if possible.
269 const char *section_type_readable = "Unknown";
270 for (size_t i = 0; i < section_definitions_len; i++) {
271 if (guid_equal(section_definitions[i].Guid,
272 §ion_descriptor->SectionType)) {
273 section_type_readable =
274 section_definitions[i].ReadableName;
275 break;
276 }
277 }
278
279 json_object_object_add(section_type, "type",
280 json_object_new_string(section_type_readable));
281 json_object_object_add(section_descriptor_ir, "sectionType",
282 section_type);
283
284 //If validation bits indicate it exists, add FRU ID.
285 if (section_descriptor->SecValidMask & 0x1) {
286 char fru_id_string[GUID_STRING_LENGTH];
287 guid_to_string(fru_id_string, §ion_descriptor->FruId);
288 json_object_object_add(section_descriptor_ir, "fruID",
289 json_object_new_string(fru_id_string));
290 }
291
292 //If validation bits indicate it exists, add FRU text.
293 if ((section_descriptor->SecValidMask & 0x2) >> 1) {
294 json_object_object_add(
295 section_descriptor_ir, "fruText",
296 json_object_new_string(section_descriptor->FruString));
297 }
298
299 //Section severity.
300 json_object *section_severity = json_object_new_object();
301 json_object_object_add(
302 section_severity, "code",
303 json_object_new_uint64(section_descriptor->Severity));
304 json_object_object_add(section_severity, "name",
305 json_object_new_string(severity_to_string(
306 section_descriptor->Severity)));
307 json_object_object_add(section_descriptor_ir, "severity",
308 section_severity);
309
310 return section_descriptor_ir;
311 }
312
313 //Converts the section described by a single given section descriptor.
cper_section_to_ir(FILE * handle,long base_pos,EFI_ERROR_SECTION_DESCRIPTOR * descriptor)314 json_object *cper_section_to_ir(FILE *handle, long base_pos,
315 EFI_ERROR_SECTION_DESCRIPTOR *descriptor)
316 {
317 //Save our current position in the stream.
318 long position = ftell(handle);
319
320 //Read section as described by the section descriptor.
321 fseek(handle, base_pos + descriptor->SectionOffset, SEEK_SET);
322 void *section = malloc(descriptor->SectionLength);
323 if (fread(section, descriptor->SectionLength, 1, handle) != 1) {
324 printf("Section read failed: Could not read %u bytes from global offset %d.\n",
325 descriptor->SectionLength, descriptor->SectionOffset);
326 free(section);
327 return NULL;
328 }
329
330 //Seek back to our original position.
331 fseek(handle, position, SEEK_SET);
332
333 //Parse section to IR based on GUID.
334 json_object *result = NULL;
335
336 json_object *section_ir = NULL;
337 int section_converted = 0;
338 for (size_t i = 0; i < section_definitions_len; i++) {
339 if (guid_equal(section_definitions[i].Guid,
340 &descriptor->SectionType) &&
341 section_definitions[i].ToIR != NULL) {
342 section_ir = section_definitions[i].ToIR(section);
343
344 result = json_object_new_object();
345 json_object_object_add(result,
346 section_definitions[i].ShortName,
347 section_ir);
348
349 section_converted = 1;
350 break;
351 }
352 }
353
354 //Was it an unknown GUID/failed read?
355 if (!section_converted) {
356 //Output the data as formatted base64.
357 int32_t encoded_len = 0;
358 char *encoded = base64_encode(
359 section, descriptor->SectionLength, &encoded_len);
360 if (encoded == NULL) {
361 printf("Failed to allocate encode output buffer. \n");
362 } else {
363 section_ir = json_object_new_object();
364 json_object_object_add(section_ir, "data",
365 json_object_new_string_len(
366 encoded, encoded_len));
367 free(encoded);
368
369 result = json_object_new_object();
370 json_object_object_add(result, "Unknown", section_ir);
371 }
372 }
373
374 //Free section memory, return result.
375 free(section);
376 return result;
377 }
378
379 //Converts a single CPER section, without a header but with a section descriptor, to JSON.
cper_single_section_to_ir(FILE * cper_section_file)380 json_object *cper_single_section_to_ir(FILE *cper_section_file)
381 {
382 json_object *ir = json_object_new_object();
383
384 //Read the current file pointer location as base record position.
385 long base_pos = ftell(cper_section_file);
386
387 //Read the section descriptor out.
388 EFI_ERROR_SECTION_DESCRIPTOR section_descriptor;
389 if (fread(§ion_descriptor, sizeof(EFI_ERROR_SECTION_DESCRIPTOR), 1,
390 cper_section_file) != 1) {
391 printf("Failed to read section descriptor for CPER single section (fread() returned an unexpected value).\n");
392 return NULL;
393 }
394
395 //Convert the section descriptor to IR.
396 json_object *section_descriptor_ir =
397 cper_section_descriptor_to_ir(§ion_descriptor);
398 json_object_object_add(ir, "sectionDescriptor", section_descriptor_ir);
399
400 //Parse the single section.
401 json_object *section_ir = cper_section_to_ir(
402 cper_section_file, base_pos, §ion_descriptor);
403 json_object_object_add(ir, "section", section_ir);
404
405 return ir;
406 }
407
cper_single_section_to_str_ir(FILE * cper_section_file)408 char *cper_single_section_to_str_ir(FILE *cper_section_file)
409 {
410 json_object *jobj = cper_single_section_to_ir(cper_section_file);
411 char *str = jobj ? strdup(json_object_to_json_string(jobj)) : NULL;
412
413 json_object_put(jobj);
414 return str;
415 }
416
cperbuf_single_section_to_str_ir(const unsigned char * cper_section,size_t size)417 char *cperbuf_single_section_to_str_ir(const unsigned char *cper_section,
418 size_t size)
419 {
420 FILE *cper_section_file = fmemopen((void *)cper_section, size, "r");
421
422 return cper_section_file ?
423 cper_single_section_to_str_ir(cper_section_file) :
424 NULL;
425 }
426