1 /**
2 * Describes functions for generating pseudo-random specification compliant CPER records.
3 *
4 * Author: Lawrence.Tang@arm.com
5 **/
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <libcper/Cper.h>
11 #include <libcper/generator/gen-utils.h>
12 #include <libcper/generator/sections/gen-section.h>
13 #include <libcper/generator/cper-generate.h>
14
15 EFI_ERROR_SECTION_DESCRIPTOR *generate_section_descriptor(char *type,
16 const size_t *lengths,
17 int index,
18 int num_sections);
19 size_t generate_section(void **location, char *type);
20
21 //Generates a CPER record with the given section types, outputting to the given stream.
generate_cper_record(char ** types,UINT16 num_sections,FILE * out)22 void generate_cper_record(char **types, UINT16 num_sections, FILE *out)
23 {
24 //Initialise randomiser.
25 init_random();
26
27 //Generate the sections.
28 void *sections[num_sections];
29 size_t section_lengths[num_sections];
30 for (int i = 0; i < num_sections; i++) {
31 section_lengths[i] = generate_section(sections + i, types[i]);
32 if (section_lengths[i] == 0) {
33 //Error encountered, exit.
34 printf("Error encountered generating section %d of type '%s', length returned zero.\n",
35 i + 1, types[i]);
36 return;
37 }
38 }
39
40 //Generate the header given the number of sections.
41 EFI_COMMON_ERROR_RECORD_HEADER *header =
42 (EFI_COMMON_ERROR_RECORD_HEADER *)calloc(
43 1, sizeof(EFI_COMMON_ERROR_RECORD_HEADER));
44 header->SignatureStart = 0x52455043; //CPER
45 header->SectionCount = num_sections;
46 header->SignatureEnd = 0xFFFFFFFF;
47 header->Flags = 4; //HW_ERROR_FLAGS_SIMULATED
48 header->RecordID = (UINT64)rand();
49 header->ErrorSeverity = rand() % 4;
50
51 //Generate a valid timestamp.
52 header->TimeStamp.Century = int_to_bcd(rand() % 100);
53 header->TimeStamp.Year = int_to_bcd(rand() % 100);
54 header->TimeStamp.Month = int_to_bcd(rand() % 12 + 1);
55 header->TimeStamp.Day = int_to_bcd(rand() % 31 + 1);
56 header->TimeStamp.Hours = int_to_bcd(rand() % 24 + 1);
57 header->TimeStamp.Seconds = int_to_bcd(rand() % 60);
58
59 //Turn all validation bits on.
60 header->ValidationBits = 0x3;
61
62 //Generate the section descriptors given the number of sections.
63 EFI_ERROR_SECTION_DESCRIPTOR *section_descriptors[num_sections];
64 for (int i = 0; i < num_sections; i++) {
65 section_descriptors[i] = generate_section_descriptor(
66 types[i], section_lengths, i, num_sections);
67 }
68
69 //Calculate total length of structure, set in header.
70 size_t total_len = sizeof(EFI_COMMON_ERROR_RECORD_HEADER);
71 for (int i = 0; i < num_sections; i++) {
72 total_len += section_lengths[i];
73 }
74 total_len += num_sections * sizeof(EFI_ERROR_SECTION_DESCRIPTOR);
75 header->RecordLength = (UINT32)total_len;
76
77 //Write to stream in order, free all resources.
78 fwrite(header, sizeof(EFI_COMMON_ERROR_RECORD_HEADER), 1, out);
79 fflush(out);
80 free(header);
81 for (int i = 0; i < num_sections; i++) {
82 fwrite(section_descriptors[i],
83 sizeof(EFI_ERROR_SECTION_DESCRIPTOR), 1, out);
84 fflush(out);
85 free(section_descriptors[i]);
86 }
87 for (int i = 0; i < num_sections; i++) {
88 fwrite(sections[i], section_lengths[i], 1, out);
89 fflush(out);
90 free(sections[i]);
91 }
92 }
93
94 //Generates a single section record for the given section, and outputs to file.
generate_single_section_record(char * type,FILE * out)95 void generate_single_section_record(char *type, FILE *out)
96 {
97 //Generate a section.
98 void *section = NULL;
99 size_t section_len = generate_section(§ion, type);
100
101 //Generate a descriptor, correct the offset.
102 EFI_ERROR_SECTION_DESCRIPTOR *section_descriptor =
103 generate_section_descriptor(type, §ion_len, 0, 1);
104 section_descriptor->SectionOffset =
105 sizeof(EFI_ERROR_SECTION_DESCRIPTOR);
106
107 //Write all to file.
108 fwrite(section_descriptor, sizeof(EFI_ERROR_SECTION_DESCRIPTOR), 1,
109 out);
110 fwrite(section, section_len, 1, out);
111 fflush(out);
112
113 //Free remaining resources.
114 free(section_descriptor);
115 free(section);
116 }
117
118 //Generates a single section descriptor for a section with the given properties.
generate_section_descriptor(char * type,const size_t * lengths,int index,int num_sections)119 EFI_ERROR_SECTION_DESCRIPTOR *generate_section_descriptor(char *type,
120 const size_t *lengths,
121 int index,
122 int num_sections)
123 {
124 EFI_ERROR_SECTION_DESCRIPTOR *descriptor =
125 (EFI_ERROR_SECTION_DESCRIPTOR *)generate_random_bytes(
126 sizeof(EFI_ERROR_SECTION_DESCRIPTOR));
127
128 //Set reserved bits to zero.
129 descriptor->Resv1 = 0;
130 descriptor->SectionFlags &= 0xFF;
131
132 //Validation bits all set to 'on'.
133 descriptor->SecValidMask = 0x3;
134
135 //Set severity.
136 descriptor->Severity = rand() % 4;
137
138 //Set length, offset from base record.
139 descriptor->SectionLength = (UINT32)lengths[index];
140 descriptor->SectionOffset =
141 sizeof(EFI_COMMON_ERROR_RECORD_HEADER) +
142 (num_sections * sizeof(EFI_ERROR_SECTION_DESCRIPTOR));
143 for (int i = 0; i < index; i++) {
144 descriptor->SectionOffset += lengths[i];
145 }
146
147 //Ensure the FRU text is not null terminated early.
148 for (int i = 0; i < 20; i++) {
149 if (descriptor->FruString[i] == 0x0) {
150 descriptor->FruString[i] = rand() % 127 + 1;
151 }
152
153 //Null terminate last byte.
154 if (i == 19) {
155 descriptor->FruString[i] = 0x0;
156 }
157 }
158
159 //If section type is not "unknown", set section type GUID based on type name.
160 int section_guid_found = 0;
161 if (strcmp(type, "unknown") == 0) {
162 section_guid_found = 1;
163 } else {
164 //Find the appropriate GUID for this section name.
165 for (size_t i = 0; i < generator_definitions_len; i++) {
166 if (strcmp(type, generator_definitions[i].ShortName) ==
167 0) {
168 memcpy(&descriptor->SectionType,
169 generator_definitions[i].Guid,
170 sizeof(EFI_GUID));
171 section_guid_found = 1;
172 break;
173 }
174 }
175 }
176
177 //Undefined section, show error.
178 if (!section_guid_found) {
179 //Undefined section, show error.
180 printf("Undefined section type '%s' provided. See 'cper-generate --help' for command information.\n",
181 type);
182 return 0;
183 }
184
185 return descriptor;
186 }
187
188 //Generates a single CPER section given the string type.
generate_section(void ** location,char * type)189 size_t generate_section(void **location, char *type)
190 {
191 //The length of the section.
192 size_t length = 0;
193
194 //If the section name is "unknown", simply generate a random bytes section.
195 int section_generated = 0;
196 if (strcmp(type, "unknown") == 0) {
197 length = generate_random_section(location, rand() % 256);
198 section_generated = 1;
199 } else {
200 //Function defined section, switch on the type, generate accordingly.
201 for (size_t i = 0; i < generator_definitions_len; i++) {
202 if (strcmp(type, generator_definitions[i].ShortName) ==
203 0) {
204 length = generator_definitions[i].Generate(
205 location);
206 section_generated = 1;
207 break;
208 }
209 }
210 }
211
212 //If we didn't find a section generator for the given name, error out.
213 if (!section_generated) {
214 printf("Undefined section type '%s' given to generate. See 'cper-generate --help' for command information.\n",
215 type);
216 return 0;
217 }
218
219 return length;
220 }
221