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 "../edk/Cper.h" 11 #include "gen-utils.h" 12 #include "sections/gen-section.h" 13 #include "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. 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. 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. 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. 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