1 /**
2  * Functions for generating pseudo-random CPER ARM processor sections.
3  *
4  * Author: Lawrence.Tang@arm.com
5  **/
6 
7 #include <stdlib.h>
8 #include <string.h>
9 #include "../../edk/BaseTypes.h"
10 #include "../gen-utils.h"
11 #include "gen-section.h"
12 #define ARM_ERROR_INFO_SIZE 32
13 
14 void *generate_arm_error_info();
15 size_t generate_arm_context_info(void **location);
16 
17 //Generates a single pseudo-random ARM processor section, saving the resulting address to the given
18 //location. Returns the size of the newly created section.
19 size_t generate_section_arm(void **location)
20 {
21 	//Set up for generation of error/context structures.
22 	UINT16 error_structure_num = rand() % 4 + 1; //Must be at least 1.
23 	UINT16 context_structure_num = rand() % 3 + 1;
24 	void *error_structures[error_structure_num];
25 	void *context_structures[context_structure_num];
26 	size_t context_structure_lengths[context_structure_num];
27 
28 	//Generate the structures.
29 	for (int i = 0; i < error_structure_num; i++) {
30 		error_structures[i] = generate_arm_error_info();
31 	}
32 	for (int i = 0; i < context_structure_num; i++) {
33 		context_structure_lengths[i] =
34 			generate_arm_context_info(context_structures + i);
35 	}
36 
37 	//Determine a random amount of vendor specific info.
38 	int vendor_info_len = rand() % 16;
39 
40 	//Create the section as a whole.
41 	size_t total_len = 40 + (error_structure_num * ARM_ERROR_INFO_SIZE);
42 	for (int i = 0; i < context_structure_num; i++) {
43 		total_len += context_structure_lengths[i];
44 	}
45 	total_len += vendor_info_len;
46 	UINT8 *section = generate_random_bytes(total_len);
47 
48 	//Set header information.
49 	UINT16 *info_nums = (UINT16 *)(section + 4);
50 	*info_nums = error_structure_num;
51 	*(info_nums + 1) = context_structure_num;
52 	UINT32 *section_length = (UINT32 *)(section + 8);
53 	*section_length = total_len;
54 
55 	//Error affinity.
56 	*(section + 12) = rand() % 4;
57 
58 	//Reserved zero bytes.
59 	UINT64 *validation = (UINT64 *)section;
60 	*validation &= 0x7;
61 	UINT32 *running_state = (UINT32 *)(section + 32);
62 	*running_state &= 0x1;
63 	memset(section + 13, 0, 3);
64 
65 	//Copy in the sections/context structures, free resources.
66 	UINT8 *cur_pos = section + 40;
67 	for (int i = 0; i < error_structure_num; i++) {
68 		memcpy(cur_pos, error_structures[i], ARM_ERROR_INFO_SIZE);
69 		free(error_structures[i]);
70 		cur_pos += ARM_ERROR_INFO_SIZE;
71 	}
72 	for (int i = 0; i < context_structure_num; i++) {
73 		memcpy(cur_pos, context_structures[i],
74 		       context_structure_lengths[i]);
75 		free(context_structures[i]);
76 		cur_pos += context_structure_lengths[i];
77 	}
78 
79 	//Set return values and exit.
80 	*location = section;
81 	return total_len;
82 }
83 
84 //Generates a single pseudo-random ARM error info structure. Must be later freed.
85 void *generate_arm_error_info()
86 {
87 	UINT8 *error_info = generate_random_bytes(ARM_ERROR_INFO_SIZE);
88 
89 	//Version (zero for revision of table referenced), length.
90 	*error_info = 0;
91 	*(error_info + 1) = ARM_ERROR_INFO_SIZE;
92 
93 	//Type of error.
94 	UINT8 error_type = rand() % 4;
95 	*(error_info + 4) = error_type;
96 
97 	//Reserved bits for error information.
98 	UINT16 *validation = (UINT16 *)(error_info + 2);
99 	*validation &= 0x1F;
100 
101 	//Make sure reserved bits are zero according with the type.
102 	UINT64 *error_subinfo = (UINT64 *)(error_info + 8);
103 	switch (error_type) {
104 	//Cache/TLB
105 	case 0:
106 	case 1:
107 		*error_subinfo &= 0xFFFFFFF;
108 		break;
109 
110 	//Bus
111 	case 2:
112 		*error_subinfo &= 0xFFFFFFFFFFF;
113 		break;
114 
115 	//Microarch/other.
116 	default:
117 		break;
118 	}
119 
120 	return error_info;
121 }
122 
123 //Generates a single pseudo-random ARM context info structure. Must be later freed.
124 size_t generate_arm_context_info(void **location)
125 {
126 	//Initial length is 8 bytes. Add extra based on type.
127 	UINT16 reg_type = rand() % 9;
128 	UINT32 reg_size = 0;
129 
130 	//Set register size.
131 	switch (reg_type) {
132 	//AARCH32 GPR, AARCH32 EL2
133 	case 0:
134 	case 2:
135 		reg_size = 64;
136 		break;
137 
138 	//AARCH32 EL1
139 	case 1:
140 		reg_size = 96;
141 		break;
142 
143 	//AARCH32 EL3
144 	case 3:
145 		reg_size = 8;
146 		break;
147 
148 	//AARCH64 GPR
149 	case 4:
150 		reg_size = 256;
151 		break;
152 
153 	//AARCH64 EL1
154 	case 5:
155 		reg_size = 136;
156 		break;
157 
158 	//AARCH64 EL2
159 	case 6:
160 		reg_size = 120;
161 		break;
162 
163 	//AARCH64 EL3
164 	case 7:
165 		reg_size = 80;
166 		break;
167 
168 	//Misc. single register.
169 	case 8:
170 		reg_size = 10;
171 		break;
172 	}
173 
174 	//Create context structure randomly.
175 	int total_size = 8 + reg_size;
176 	UINT16 *context_info = (UINT16 *)generate_random_bytes(total_size);
177 
178 	//Set header information.
179 	*(context_info + 1) = reg_type;
180 	*((UINT32 *)(context_info + 2)) = reg_size;
181 
182 	//Set return values and exit.
183 	*location = context_info;
184 	return total_size;
185 }
186