]>
Commit | Line | Data |
---|---|---|
ad6423a7 MT |
1 | /* |
2 | * Boot order test cases. | |
3 | * | |
4 | * Copyright (c) 2013 Red Hat Inc. | |
5 | * | |
6 | * Authors: | |
7 | * Michael S. Tsirkin <mst@redhat.com>, | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
10 | * See the COPYING file in the top-level directory. | |
11 | */ | |
12 | ||
681c28a3 | 13 | #include "qemu/osdep.h" |
4500bc98 | 14 | #include <glib/gstdio.h> |
53333801 | 15 | #include "qemu-common.h" |
a2eb5c0c | 16 | #include "hw/firmware/smbios.h" |
eb386aac | 17 | #include "qemu/bitmap.h" |
3248f1b4 | 18 | #include "acpi-utils.h" |
4e082566 | 19 | #include "boot-sector.h" |
ad6423a7 | 20 | |
9e8458c0 MA |
21 | #define MACHINE_PC "pc" |
22 | #define MACHINE_Q35 "q35" | |
23 | ||
4500bc98 MA |
24 | #define ACPI_REBUILD_EXPECTED_AML "TEST_ACPI_REBUILD_AML" |
25 | ||
53333801 | 26 | typedef struct { |
9e8458c0 | 27 | const char *machine; |
3a9c86df | 28 | const char *variant; |
53333801 | 29 | uint32_t rsdp_addr; |
d6caf363 | 30 | uint8_t rsdp_table[36 /* ACPI 2.0+ RSDP size */]; |
53333801 | 31 | AcpiRsdtDescriptorRev1 rsdt_table; |
89d47c19 IM |
32 | uint32_t dsdt_addr; |
33 | uint32_t facs_addr; | |
15650602 | 34 | AcpiFacsDescriptorRev1 facs_table; |
53333801 MA |
35 | uint32_t *rsdt_tables_addr; |
36 | int rsdt_tables_nr; | |
a3a74ab9 | 37 | GArray *tables; |
eb386aac | 38 | uint32_t smbios_ep_addr; |
86299120 | 39 | struct smbios_21_entry_point smbios_ep_table; |
f4eda2d4 CM |
40 | uint8_t *required_struct_types; |
41 | int required_struct_types_len; | |
273e3d92 | 42 | QTestState *qts; |
53333801 | 43 | } test_data; |
ad6423a7 | 44 | |
3e353773 | 45 | static char disk[] = "tests/acpi-test-disk-XXXXXX"; |
438c78da | 46 | static const char *data_dir = "tests/data/acpi"; |
cc8fa0e8 MA |
47 | #ifdef CONFIG_IASL |
48 | static const char *iasl = stringify(CONFIG_IASL); | |
49 | #else | |
50 | static const char *iasl; | |
51 | #endif | |
ad6423a7 | 52 | |
8ac2adf7 MA |
53 | static void free_test_data(test_data *data) |
54 | { | |
9e8458c0 | 55 | AcpiSdtTable *temp; |
8ac2adf7 MA |
56 | int i; |
57 | ||
ef1e1e07 | 58 | g_free(data->rsdt_tables_addr); |
9e8458c0 | 59 | |
a3a74ab9 MA |
60 | for (i = 0; i < data->tables->len; ++i) { |
61 | temp = &g_array_index(data->tables, AcpiSdtTable, i); | |
ef1e1e07 DB |
62 | g_free(temp->aml); |
63 | if (temp->aml_file && | |
64 | !temp->tmp_files_retain && | |
65 | g_strstr_len(temp->aml_file, -1, "aml-")) { | |
66 | unlink(temp->aml_file); | |
9e8458c0 | 67 | } |
ef1e1e07 DB |
68 | g_free(temp->aml_file); |
69 | g_free(temp->asl); | |
70 | if (temp->asl_file && | |
71 | !temp->tmp_files_retain) { | |
72 | unlink(temp->asl_file); | |
9e8458c0 | 73 | } |
ef1e1e07 | 74 | g_free(temp->asl_file); |
8ac2adf7 | 75 | } |
9e8458c0 | 76 | |
f11dc27b | 77 | g_array_free(data->tables, true); |
8ac2adf7 MA |
78 | } |
79 | ||
53333801 MA |
80 | static void test_acpi_rsdp_address(test_data *data) |
81 | { | |
273e3d92 | 82 | uint32_t off = acpi_find_rsdp_address(data->qts); |
53333801 MA |
83 | g_assert_cmphex(off, <, 0x100000); |
84 | data->rsdp_addr = off; | |
85 | } | |
86 | ||
87 | static void test_acpi_rsdp_table(test_data *data) | |
88 | { | |
d6caf363 | 89 | uint8_t *rsdp_table = data->rsdp_table, revision; |
53333801 MA |
90 | uint32_t addr = data->rsdp_addr; |
91 | ||
273e3d92 | 92 | acpi_parse_rsdp_table(data->qts, addr, rsdp_table); |
d6caf363 SO |
93 | revision = rsdp_table[15 /* Revision offset */]; |
94 | ||
95 | switch (revision) { | |
96 | case 0: /* ACPI 1.0 RSDP */ | |
97 | /* With rev 1, checksum is only for the first 20 bytes */ | |
98 | g_assert(!acpi_calc_checksum(rsdp_table, 20)); | |
99 | break; | |
100 | case 2: /* ACPI 2.0+ RSDP */ | |
101 | /* With revision 2, we have 2 checksums */ | |
102 | g_assert(!acpi_calc_checksum(rsdp_table, 20)); | |
103 | g_assert(!acpi_calc_checksum(rsdp_table, 36)); | |
104 | break; | |
105 | default: | |
106 | g_assert_not_reached(); | |
107 | } | |
53333801 MA |
108 | } |
109 | ||
110 | static void test_acpi_rsdt_table(test_data *data) | |
111 | { | |
112 | AcpiRsdtDescriptorRev1 *rsdt_table = &data->rsdt_table; | |
d6caf363 | 113 | uint32_t addr = acpi_get_rsdt_address(data->rsdp_table); |
53333801 MA |
114 | uint32_t *tables; |
115 | int tables_nr; | |
116 | uint8_t checksum; | |
3831c07b | 117 | uint32_t rsdt_table_length; |
53333801 MA |
118 | |
119 | /* read the header */ | |
273e3d92 | 120 | ACPI_READ_TABLE_HEADER(data->qts, rsdt_table, addr); |
c225aa3c | 121 | ACPI_ASSERT_CMP(rsdt_table->signature, "RSDT"); |
53333801 | 122 | |
3831c07b TH |
123 | rsdt_table_length = le32_to_cpu(rsdt_table->length); |
124 | ||
53333801 | 125 | /* compute the table entries in rsdt */ |
3831c07b | 126 | tables_nr = (rsdt_table_length - sizeof(AcpiRsdtDescriptorRev1)) / |
53333801 | 127 | sizeof(uint32_t); |
91c38e08 | 128 | g_assert(tables_nr > 0); |
53333801 MA |
129 | |
130 | /* get the addresses of the tables pointed by rsdt */ | |
131 | tables = g_new0(uint32_t, tables_nr); | |
273e3d92 | 132 | ACPI_READ_ARRAY_PTR(data->qts, tables, tables_nr, addr); |
53333801 | 133 | |
3831c07b | 134 | checksum = acpi_calc_checksum((uint8_t *)rsdt_table, rsdt_table_length) + |
3248f1b4 BW |
135 | acpi_calc_checksum((uint8_t *)tables, |
136 | tables_nr * sizeof(uint32_t)); | |
53333801 MA |
137 | g_assert(!checksum); |
138 | ||
139 | /* SSDT tables after FADT */ | |
140 | data->rsdt_tables_addr = tables; | |
141 | data->rsdt_tables_nr = tables_nr; | |
142 | } | |
143 | ||
89d47c19 | 144 | static void fadt_fetch_facs_and_dsdt_ptrs(test_data *data) |
53333801 | 145 | { |
53333801 | 146 | uint32_t addr; |
89d47c19 | 147 | AcpiTableHeader hdr; |
53333801 MA |
148 | |
149 | /* FADT table comes first */ | |
3831c07b | 150 | addr = le32_to_cpu(data->rsdt_tables_addr[0]); |
273e3d92 | 151 | ACPI_READ_TABLE_HEADER(data->qts, &hdr, addr); |
89d47c19 IM |
152 | ACPI_ASSERT_CMP(hdr.signature, "FACP"); |
153 | ||
273e3d92 EB |
154 | ACPI_READ_FIELD(data->qts, data->facs_addr, addr); |
155 | ACPI_READ_FIELD(data->qts, data->dsdt_addr, addr); | |
53333801 MA |
156 | } |
157 | ||
92146b7a IM |
158 | static void sanitize_fadt_ptrs(test_data *data) |
159 | { | |
160 | /* fixup pointers in FADT */ | |
161 | int i; | |
162 | ||
163 | for (i = 0; i < data->tables->len; i++) { | |
164 | AcpiSdtTable *sdt = &g_array_index(data->tables, AcpiSdtTable, i); | |
165 | ||
166 | if (memcmp(&sdt->header.signature, "FACP", 4)) { | |
167 | continue; | |
168 | } | |
169 | ||
89d47c19 IM |
170 | /* check original FADT checksum before sanitizing table */ |
171 | g_assert(!(uint8_t)( | |
172 | acpi_calc_checksum((uint8_t *)sdt, sizeof(AcpiTableHeader)) + | |
173 | acpi_calc_checksum((uint8_t *)sdt->aml, sdt->aml_len) | |
174 | )); | |
175 | ||
92146b7a IM |
176 | /* sdt->aml field offset := spec offset - header size */ |
177 | memset(sdt->aml + 0, 0, 4); /* sanitize FIRMWARE_CTRL(36) ptr */ | |
178 | memset(sdt->aml + 4, 0, 4); /* sanitize DSDT(40) ptr */ | |
179 | if (sdt->header.revision >= 3) { | |
180 | memset(sdt->aml + 96, 0, 8); /* sanitize X_FIRMWARE_CTRL(132) ptr */ | |
181 | memset(sdt->aml + 104, 0, 8); /* sanitize X_DSDT(140) ptr */ | |
182 | } | |
183 | ||
184 | /* update checksum */ | |
185 | sdt->header.checksum = 0; | |
186 | sdt->header.checksum -= | |
187 | acpi_calc_checksum((uint8_t *)sdt, sizeof(AcpiTableHeader)) + | |
188 | acpi_calc_checksum((uint8_t *)sdt->aml, sdt->aml_len); | |
189 | break; | |
190 | } | |
191 | } | |
192 | ||
15650602 MA |
193 | static void test_acpi_facs_table(test_data *data) |
194 | { | |
195 | AcpiFacsDescriptorRev1 *facs_table = &data->facs_table; | |
89d47c19 | 196 | uint32_t addr = le32_to_cpu(data->facs_addr); |
15650602 | 197 | |
273e3d92 EB |
198 | ACPI_READ_FIELD(data->qts, facs_table->signature, addr); |
199 | ACPI_READ_FIELD(data->qts, facs_table->length, addr); | |
200 | ACPI_READ_FIELD(data->qts, facs_table->hardware_signature, addr); | |
201 | ACPI_READ_FIELD(data->qts, facs_table->firmware_waking_vector, addr); | |
202 | ACPI_READ_FIELD(data->qts, facs_table->global_lock, addr); | |
203 | ACPI_READ_FIELD(data->qts, facs_table->flags, addr); | |
204 | ACPI_READ_ARRAY(data->qts, facs_table->resverved3, addr); | |
15650602 | 205 | |
c225aa3c | 206 | ACPI_ASSERT_CMP(facs_table->signature, "FACS"); |
15650602 MA |
207 | } |
208 | ||
03010579 IM |
209 | /** fetch_table |
210 | * load ACPI table at @addr into table descriptor @sdt_table | |
211 | * and check that header checksum matches actual one. | |
212 | */ | |
273e3d92 | 213 | static void fetch_table(QTestState *qts, AcpiSdtTable *sdt_table, uint32_t addr) |
53333801 MA |
214 | { |
215 | uint8_t checksum; | |
216 | ||
dabc7f21 | 217 | memset(sdt_table, 0, sizeof(*sdt_table)); |
273e3d92 | 218 | ACPI_READ_TABLE_HEADER(qts, &sdt_table->header, addr); |
53333801 | 219 | |
3831c07b TH |
220 | sdt_table->aml_len = le32_to_cpu(sdt_table->header.length) |
221 | - sizeof(AcpiTableHeader); | |
53333801 | 222 | sdt_table->aml = g_malloc0(sdt_table->aml_len); |
273e3d92 | 223 | ACPI_READ_ARRAY_PTR(qts, sdt_table->aml, sdt_table->aml_len, addr); |
53333801 | 224 | |
3248f1b4 BW |
225 | checksum = acpi_calc_checksum((uint8_t *)sdt_table, |
226 | sizeof(AcpiTableHeader)) + | |
227 | acpi_calc_checksum((uint8_t *)sdt_table->aml, | |
228 | sdt_table->aml_len); | |
53333801 MA |
229 | g_assert(!checksum); |
230 | } | |
231 | ||
232 | static void test_acpi_dsdt_table(test_data *data) | |
233 | { | |
9e8458c0 | 234 | AcpiSdtTable dsdt_table; |
89d47c19 | 235 | uint32_t addr = le32_to_cpu(data->dsdt_addr); |
53333801 | 236 | |
273e3d92 | 237 | fetch_table(data->qts, &dsdt_table, addr); |
c225aa3c | 238 | ACPI_ASSERT_CMP(dsdt_table.header.signature, "DSDT"); |
9e8458c0 | 239 | |
b24b9d94 | 240 | /* Since DSDT isn't in RSDT, add DSDT to ASL test tables list manually */ |
a3a74ab9 | 241 | g_array_append_val(data->tables, dsdt_table); |
53333801 MA |
242 | } |
243 | ||
03010579 IM |
244 | /* Load all tables and add to test list directly RSDT referenced tables */ |
245 | static void fetch_rsdt_referenced_tables(test_data *data) | |
53333801 | 246 | { |
92146b7a | 247 | int tables_nr = data->rsdt_tables_nr; |
53333801 MA |
248 | int i; |
249 | ||
a3a74ab9 | 250 | for (i = 0; i < tables_nr; i++) { |
8ac2adf7 | 251 | AcpiSdtTable ssdt_table; |
3831c07b | 252 | uint32_t addr; |
9e8458c0 | 253 | |
92146b7a | 254 | addr = le32_to_cpu(data->rsdt_tables_addr[i]); |
273e3d92 | 255 | fetch_table(data->qts, &ssdt_table, addr); |
ab20bbd2 IM |
256 | |
257 | /* Add table to ASL test tables list */ | |
a3a74ab9 | 258 | g_array_append_val(data->tables, ssdt_table); |
53333801 | 259 | } |
9e8458c0 MA |
260 | } |
261 | ||
4500bc98 | 262 | static void dump_aml_files(test_data *data, bool rebuild) |
9e8458c0 MA |
263 | { |
264 | AcpiSdtTable *sdt; | |
265 | GError *error = NULL; | |
4500bc98 | 266 | gchar *aml_file = NULL; |
9e8458c0 MA |
267 | gint fd; |
268 | ssize_t ret; | |
269 | int i; | |
270 | ||
a3a74ab9 | 271 | for (i = 0; i < data->tables->len; ++i) { |
3a9c86df | 272 | const char *ext = data->variant ? data->variant : ""; |
a3a74ab9 | 273 | sdt = &g_array_index(data->tables, AcpiSdtTable, i); |
9e8458c0 MA |
274 | g_assert(sdt->aml); |
275 | ||
4500bc98 | 276 | if (rebuild) { |
3a9c86df | 277 | aml_file = g_strdup_printf("%s/%s/%.4s%s", data_dir, data->machine, |
3831c07b | 278 | (gchar *)&sdt->header.signature, ext); |
4500bc98 MA |
279 | fd = g_open(aml_file, O_WRONLY|O_TRUNC|O_CREAT, |
280 | S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH); | |
281 | } else { | |
282 | fd = g_file_open_tmp("aml-XXXXXX", &sdt->aml_file, &error); | |
283 | g_assert_no_error(error); | |
284 | } | |
285 | g_assert(fd >= 0); | |
9e8458c0 MA |
286 | |
287 | ret = qemu_write_full(fd, sdt, sizeof(AcpiTableHeader)); | |
288 | g_assert(ret == sizeof(AcpiTableHeader)); | |
289 | ret = qemu_write_full(fd, sdt->aml, sdt->aml_len); | |
290 | g_assert(ret == sdt->aml_len); | |
291 | ||
292 | close(fd); | |
4500bc98 | 293 | |
ef1e1e07 | 294 | g_free(aml_file); |
9e8458c0 MA |
295 | } |
296 | } | |
297 | ||
c225aa3c | 298 | static bool compare_signature(AcpiSdtTable *sdt, const char *signature) |
69d09245 | 299 | { |
c225aa3c | 300 | return !memcmp(&sdt->header.signature, signature, 4); |
69d09245 MA |
301 | } |
302 | ||
15d914b1 | 303 | static bool load_asl(GArray *sdts, AcpiSdtTable *sdt) |
9e8458c0 MA |
304 | { |
305 | AcpiSdtTable *temp; | |
306 | GError *error = NULL; | |
cc8fa0e8 | 307 | GString *command_line = g_string_new(iasl); |
9e8458c0 MA |
308 | gint fd; |
309 | gchar *out, *out_err; | |
310 | gboolean ret; | |
311 | int i; | |
312 | ||
313 | fd = g_file_open_tmp("asl-XXXXXX.dsl", &sdt->asl_file, &error); | |
314 | g_assert_no_error(error); | |
315 | close(fd); | |
316 | ||
317 | /* build command line */ | |
cc8fa0e8 | 318 | g_string_append_printf(command_line, " -p %s ", sdt->asl_file); |
c225aa3c MT |
319 | if (compare_signature(sdt, "DSDT") || |
320 | compare_signature(sdt, "SSDT")) { | |
69d09245 MA |
321 | for (i = 0; i < sdts->len; ++i) { |
322 | temp = &g_array_index(sdts, AcpiSdtTable, i); | |
c225aa3c MT |
323 | if (compare_signature(temp, "DSDT") || |
324 | compare_signature(temp, "SSDT")) { | |
69d09245 MA |
325 | g_string_append_printf(command_line, "-e %s ", temp->aml_file); |
326 | } | |
327 | } | |
9e8458c0 MA |
328 | } |
329 | g_string_append_printf(command_line, "-d %s", sdt->aml_file); | |
330 | ||
331 | /* pass 'out' and 'out_err' in order to be redirected */ | |
15d914b1 | 332 | ret = g_spawn_command_line_sync(command_line->str, &out, &out_err, NULL, &error); |
9e8458c0 | 333 | g_assert_no_error(error); |
15d914b1 | 334 | if (ret) { |
cc80b01a | 335 | ret = g_file_get_contents(sdt->asl_file, &sdt->asl, |
15d914b1 MA |
336 | &sdt->asl_len, &error); |
337 | g_assert(ret); | |
338 | g_assert_no_error(error); | |
dac23a6c | 339 | ret = (sdt->asl_len > 0); |
15d914b1 | 340 | } |
9e8458c0 MA |
341 | |
342 | g_free(out); | |
343 | g_free(out_err); | |
344 | g_string_free(command_line, true); | |
15d914b1 MA |
345 | |
346 | return !ret; | |
9e8458c0 MA |
347 | } |
348 | ||
349 | #define COMMENT_END "*/" | |
350 | #define DEF_BLOCK "DefinitionBlock (" | |
a3973f55 | 351 | #define BLOCK_NAME_END "," |
9e8458c0 MA |
352 | |
353 | static GString *normalize_asl(gchar *asl_code) | |
354 | { | |
355 | GString *asl = g_string_new(asl_code); | |
356 | gchar *comment, *block_name; | |
357 | ||
358 | /* strip comments (different generation days) */ | |
359 | comment = g_strstr_len(asl->str, asl->len, COMMENT_END); | |
360 | if (comment) { | |
cb348985 PB |
361 | comment += strlen(COMMENT_END); |
362 | while (*comment == '\n') { | |
363 | comment++; | |
364 | } | |
365 | asl = g_string_erase(asl, 0, comment - asl->str); | |
9e8458c0 MA |
366 | } |
367 | ||
368 | /* strip def block name (it has file path in it) */ | |
369 | if (g_str_has_prefix(asl->str, DEF_BLOCK)) { | |
370 | block_name = g_strstr_len(asl->str, asl->len, BLOCK_NAME_END); | |
371 | g_assert(block_name); | |
372 | asl = g_string_erase(asl, 0, | |
373 | block_name + sizeof(BLOCK_NAME_END) - asl->str); | |
374 | } | |
375 | ||
376 | return asl; | |
377 | } | |
378 | ||
379 | static GArray *load_expected_aml(test_data *data) | |
380 | { | |
381 | int i; | |
382 | AcpiSdtTable *sdt; | |
9e8458c0 MA |
383 | GError *error = NULL; |
384 | gboolean ret; | |
385 | ||
a3a74ab9 | 386 | GArray *exp_tables = g_array_new(false, true, sizeof(AcpiSdtTable)); |
fe17cca6 PMD |
387 | if (getenv("V")) { |
388 | fputc('\n', stderr); | |
389 | } | |
a3a74ab9 | 390 | for (i = 0; i < data->tables->len; ++i) { |
9e8458c0 | 391 | AcpiSdtTable exp_sdt; |
d19587db | 392 | gchar *aml_file = NULL; |
3a9c86df | 393 | const char *ext = data->variant ? data->variant : ""; |
c225aa3c | 394 | |
a3a74ab9 | 395 | sdt = &g_array_index(data->tables, AcpiSdtTable, i); |
9e8458c0 MA |
396 | |
397 | memset(&exp_sdt, 0, sizeof(exp_sdt)); | |
398 | exp_sdt.header.signature = sdt->header.signature; | |
399 | ||
3a9c86df IM |
400 | try_again: |
401 | aml_file = g_strdup_printf("%s/%s/%.4s%s", data_dir, data->machine, | |
3831c07b | 402 | (gchar *)&sdt->header.signature, ext); |
d19587db | 403 | if (getenv("V")) { |
fe17cca6 | 404 | fprintf(stderr, "Looking for expected file '%s'\n", aml_file); |
d19587db IM |
405 | } |
406 | if (g_file_test(aml_file, G_FILE_TEST_EXISTS)) { | |
407 | exp_sdt.aml_file = aml_file; | |
408 | } else if (*ext != '\0') { | |
e50a6121 | 409 | /* try fallback to generic (extension less) expected file */ |
3a9c86df | 410 | ext = ""; |
d19587db | 411 | g_free(aml_file); |
3a9c86df IM |
412 | goto try_again; |
413 | } | |
d19587db IM |
414 | g_assert(exp_sdt.aml_file); |
415 | if (getenv("V")) { | |
fe17cca6 | 416 | fprintf(stderr, "Using expected file '%s'\n", aml_file); |
d19587db | 417 | } |
9e8458c0 MA |
418 | ret = g_file_get_contents(aml_file, &exp_sdt.aml, |
419 | &exp_sdt.aml_len, &error); | |
420 | g_assert(ret); | |
421 | g_assert_no_error(error); | |
422 | g_assert(exp_sdt.aml); | |
423 | g_assert(exp_sdt.aml_len); | |
424 | ||
a3a74ab9 | 425 | g_array_append_val(exp_tables, exp_sdt); |
9e8458c0 MA |
426 | } |
427 | ||
a3a74ab9 | 428 | return exp_tables; |
9e8458c0 MA |
429 | } |
430 | ||
ab20bbd2 | 431 | /* test the list of tables in @data->tables against reference tables */ |
9e8458c0 MA |
432 | static void test_acpi_asl(test_data *data) |
433 | { | |
434 | int i; | |
435 | AcpiSdtTable *sdt, *exp_sdt; | |
436 | test_data exp_data; | |
15d914b1 | 437 | gboolean exp_err, err; |
9e8458c0 MA |
438 | |
439 | memset(&exp_data, 0, sizeof(exp_data)); | |
a3a74ab9 | 440 | exp_data.tables = load_expected_aml(data); |
4500bc98 | 441 | dump_aml_files(data, false); |
a3a74ab9 | 442 | for (i = 0; i < data->tables->len; ++i) { |
9e8458c0 MA |
443 | GString *asl, *exp_asl; |
444 | ||
a3a74ab9 MA |
445 | sdt = &g_array_index(data->tables, AcpiSdtTable, i); |
446 | exp_sdt = &g_array_index(exp_data.tables, AcpiSdtTable, i); | |
9e8458c0 | 447 | |
15d914b1 | 448 | err = load_asl(data->tables, sdt); |
9e8458c0 MA |
449 | asl = normalize_asl(sdt->asl); |
450 | ||
15d914b1 | 451 | exp_err = load_asl(exp_data.tables, exp_sdt); |
9e8458c0 MA |
452 | exp_asl = normalize_asl(exp_sdt->asl); |
453 | ||
15d914b1 MA |
454 | /* TODO: check for warnings */ |
455 | g_assert(!err || exp_err); | |
456 | ||
0651596c | 457 | if (g_strcmp0(asl->str, exp_asl->str)) { |
dac23a6c MA |
458 | if (exp_err) { |
459 | fprintf(stderr, | |
460 | "Warning! iasl couldn't parse the expected aml\n"); | |
461 | } else { | |
462 | uint32_t signature = cpu_to_le32(exp_sdt->header.signature); | |
463 | sdt->tmp_files_retain = true; | |
464 | exp_sdt->tmp_files_retain = true; | |
465 | fprintf(stderr, | |
466 | "acpi-test: Warning! %.4s mismatch. " | |
467 | "Actual [asl:%s, aml:%s], Expected [asl:%s, aml:%s].\n", | |
468 | (gchar *)&signature, | |
469 | sdt->asl_file, sdt->aml_file, | |
470 | exp_sdt->asl_file, exp_sdt->aml_file); | |
7cb08cb2 IM |
471 | if (getenv("V")) { |
472 | const char *diff_cmd = getenv("DIFF"); | |
473 | if (diff_cmd) { | |
474 | int ret G_GNUC_UNUSED; | |
475 | char *diff = g_strdup_printf("%s %s %s", diff_cmd, | |
476 | exp_sdt->asl_file, sdt->asl_file); | |
477 | ret = system(diff) ; | |
478 | g_free(diff); | |
479 | } else { | |
480 | fprintf(stderr, "acpi-test: Warning. not showing " | |
481 | "difference since no diff utility is specified. " | |
482 | "Set 'DIFF' environment variable to a preferred " | |
483 | "diff utility and run 'make V=1 check' again to " | |
484 | "see ASL difference."); | |
485 | } | |
486 | } | |
dac23a6c | 487 | } |
0651596c | 488 | } |
9e8458c0 MA |
489 | g_string_free(asl, true); |
490 | g_string_free(exp_asl, true); | |
491 | } | |
492 | ||
493 | free_test_data(&exp_data); | |
53333801 MA |
494 | } |
495 | ||
5efed5a1 | 496 | static bool smbios_ep_table_ok(test_data *data) |
eb386aac | 497 | { |
86299120 | 498 | struct smbios_21_entry_point *ep_table = &data->smbios_ep_table; |
eb386aac GS |
499 | uint32_t addr = data->smbios_ep_addr; |
500 | ||
273e3d92 | 501 | ACPI_READ_ARRAY(data->qts, ep_table->anchor_string, addr); |
5efed5a1 GS |
502 | if (memcmp(ep_table->anchor_string, "_SM_", 4)) { |
503 | return false; | |
504 | } | |
273e3d92 EB |
505 | ACPI_READ_FIELD(data->qts, ep_table->checksum, addr); |
506 | ACPI_READ_FIELD(data->qts, ep_table->length, addr); | |
507 | ACPI_READ_FIELD(data->qts, ep_table->smbios_major_version, addr); | |
508 | ACPI_READ_FIELD(data->qts, ep_table->smbios_minor_version, addr); | |
509 | ACPI_READ_FIELD(data->qts, ep_table->max_structure_size, addr); | |
510 | ACPI_READ_FIELD(data->qts, ep_table->entry_point_revision, addr); | |
511 | ACPI_READ_ARRAY(data->qts, ep_table->formatted_area, addr); | |
512 | ACPI_READ_ARRAY(data->qts, ep_table->intermediate_anchor_string, addr); | |
5efed5a1 GS |
513 | if (memcmp(ep_table->intermediate_anchor_string, "_DMI_", 5)) { |
514 | return false; | |
515 | } | |
273e3d92 EB |
516 | ACPI_READ_FIELD(data->qts, ep_table->intermediate_checksum, addr); |
517 | ACPI_READ_FIELD(data->qts, ep_table->structure_table_length, addr); | |
5efed5a1 GS |
518 | if (ep_table->structure_table_length == 0) { |
519 | return false; | |
520 | } | |
273e3d92 EB |
521 | ACPI_READ_FIELD(data->qts, ep_table->structure_table_address, addr); |
522 | ACPI_READ_FIELD(data->qts, ep_table->number_of_structures, addr); | |
5efed5a1 GS |
523 | if (ep_table->number_of_structures == 0) { |
524 | return false; | |
525 | } | |
273e3d92 | 526 | ACPI_READ_FIELD(data->qts, ep_table->smbios_bcd_revision, addr); |
3248f1b4 BW |
527 | if (acpi_calc_checksum((uint8_t *)ep_table, sizeof *ep_table) || |
528 | acpi_calc_checksum((uint8_t *)ep_table + 0x10, | |
529 | sizeof *ep_table - 0x10)) { | |
5efed5a1 GS |
530 | return false; |
531 | } | |
532 | return true; | |
533 | } | |
534 | ||
535 | static void test_smbios_entry_point(test_data *data) | |
536 | { | |
537 | uint32_t off; | |
538 | ||
539 | /* find smbios entry point structure */ | |
540 | for (off = 0xf0000; off < 0x100000; off += 0x10) { | |
541 | uint8_t sig[] = "_SM_"; | |
542 | int i; | |
543 | ||
544 | for (i = 0; i < sizeof sig - 1; ++i) { | |
273e3d92 | 545 | sig[i] = qtest_readb(data->qts, off + i); |
5efed5a1 GS |
546 | } |
547 | ||
548 | if (!memcmp(sig, "_SM_", sizeof sig)) { | |
549 | /* signature match, but is this a valid entry point? */ | |
550 | data->smbios_ep_addr = off; | |
551 | if (smbios_ep_table_ok(data)) { | |
552 | break; | |
553 | } | |
554 | } | |
555 | } | |
556 | ||
557 | g_assert_cmphex(off, <, 0x100000); | |
eb386aac GS |
558 | } |
559 | ||
560 | static inline bool smbios_single_instance(uint8_t type) | |
561 | { | |
562 | switch (type) { | |
563 | case 0: | |
564 | case 1: | |
565 | case 2: | |
566 | case 3: | |
567 | case 16: | |
568 | case 32: | |
569 | case 127: | |
570 | return true; | |
571 | default: | |
572 | return false; | |
573 | } | |
574 | } | |
575 | ||
576 | static void test_smbios_structs(test_data *data) | |
577 | { | |
578 | DECLARE_BITMAP(struct_bitmap, SMBIOS_MAX_TYPE+1) = { 0 }; | |
86299120 | 579 | struct smbios_21_entry_point *ep_table = &data->smbios_ep_table; |
3831c07b | 580 | uint32_t addr = le32_to_cpu(ep_table->structure_table_address); |
eb386aac GS |
581 | int i, len, max_len = 0; |
582 | uint8_t type, prv, crt; | |
eb386aac GS |
583 | |
584 | /* walk the smbios tables */ | |
3831c07b | 585 | for (i = 0; i < le16_to_cpu(ep_table->number_of_structures); i++) { |
eb386aac GS |
586 | |
587 | /* grab type and formatted area length from struct header */ | |
273e3d92 | 588 | type = qtest_readb(data->qts, addr); |
eb386aac | 589 | g_assert_cmpuint(type, <=, SMBIOS_MAX_TYPE); |
273e3d92 | 590 | len = qtest_readb(data->qts, addr + 1); |
eb386aac GS |
591 | |
592 | /* single-instance structs must not have been encountered before */ | |
593 | if (smbios_single_instance(type)) { | |
594 | g_assert(!test_bit(type, struct_bitmap)); | |
595 | } | |
596 | set_bit(type, struct_bitmap); | |
597 | ||
598 | /* seek to end of unformatted string area of this struct ("\0\0") */ | |
599 | prv = crt = 1; | |
600 | while (prv || crt) { | |
601 | prv = crt; | |
273e3d92 | 602 | crt = qtest_readb(data->qts, addr + len); |
eb386aac GS |
603 | len++; |
604 | } | |
605 | ||
606 | /* keep track of max. struct size */ | |
607 | if (max_len < len) { | |
608 | max_len = len; | |
609 | g_assert_cmpuint(max_len, <=, ep_table->max_structure_size); | |
610 | } | |
611 | ||
612 | /* start of next structure */ | |
613 | addr += len; | |
614 | } | |
615 | ||
616 | /* total table length and max struct size must match entry point values */ | |
3831c07b TH |
617 | g_assert_cmpuint(le16_to_cpu(ep_table->structure_table_length), ==, |
618 | addr - le32_to_cpu(ep_table->structure_table_address)); | |
619 | g_assert_cmpuint(le16_to_cpu(ep_table->max_structure_size), ==, max_len); | |
eb386aac GS |
620 | |
621 | /* required struct types must all be present */ | |
f4eda2d4 CM |
622 | for (i = 0; i < data->required_struct_types_len; i++) { |
623 | g_assert(test_bit(data->required_struct_types[i], struct_bitmap)); | |
eb386aac GS |
624 | } |
625 | } | |
626 | ||
8ac2adf7 | 627 | static void test_acpi_one(const char *params, test_data *data) |
ad6423a7 MT |
628 | { |
629 | char *args; | |
ad6423a7 | 630 | |
947b205f MA |
631 | /* Disable kernel irqchip to be able to override apic irq0. */ |
632 | args = g_strdup_printf("-machine %s,accel=%s,kernel-irqchip=off " | |
633 | "-net none -display none %s " | |
b8e665e4 | 634 | "-drive id=hd0,if=none,file=%s,format=raw " |
6b9e03a4 | 635 | "-device ide-hd,drive=hd0 ", |
947b205f | 636 | data->machine, "kvm:tcg", |
6b9e03a4 | 637 | params ? params : "", disk); |
9e8458c0 | 638 | |
273e3d92 | 639 | data->qts = qtest_init(args); |
ad6423a7 | 640 | |
273e3d92 | 641 | boot_sector_test(data->qts); |
ad6423a7 | 642 | |
b24b9d94 | 643 | data->tables = g_array_new(false, true, sizeof(AcpiSdtTable)); |
8ac2adf7 MA |
644 | test_acpi_rsdp_address(data); |
645 | test_acpi_rsdp_table(data); | |
646 | test_acpi_rsdt_table(data); | |
89d47c19 | 647 | fadt_fetch_facs_and_dsdt_ptrs(data); |
15650602 | 648 | test_acpi_facs_table(data); |
8ac2adf7 | 649 | test_acpi_dsdt_table(data); |
03010579 | 650 | fetch_rsdt_referenced_tables(data); |
ad6423a7 | 651 | |
92146b7a IM |
652 | sanitize_fadt_ptrs(data); |
653 | ||
cc8fa0e8 | 654 | if (iasl) { |
4500bc98 MA |
655 | if (getenv(ACPI_REBUILD_EXPECTED_AML)) { |
656 | dump_aml_files(data, true); | |
657 | } else { | |
658 | test_acpi_asl(data); | |
659 | } | |
9e8458c0 MA |
660 | } |
661 | ||
5efed5a1 | 662 | test_smbios_entry_point(data); |
eb386aac GS |
663 | test_smbios_structs(data); |
664 | ||
273e3d92 EB |
665 | assert(!global_qtest); |
666 | qtest_quit(data->qts); | |
ad6423a7 MT |
667 | g_free(args); |
668 | } | |
669 | ||
f4eda2d4 CM |
670 | static uint8_t base_required_struct_types[] = { |
671 | 0, 1, 3, 4, 16, 17, 19, 32, 127 | |
672 | }; | |
673 | ||
71f4be25 | 674 | static void test_acpi_piix4_tcg(void) |
ad6423a7 | 675 | { |
8ac2adf7 MA |
676 | test_data data; |
677 | ||
ad6423a7 MT |
678 | /* Supplying -machine accel argument overrides the default (qtest). |
679 | * This is to make guest actually run. | |
680 | */ | |
9e8458c0 MA |
681 | memset(&data, 0, sizeof(data)); |
682 | data.machine = MACHINE_PC; | |
f4eda2d4 CM |
683 | data.required_struct_types = base_required_struct_types; |
684 | data.required_struct_types_len = ARRAY_SIZE(base_required_struct_types); | |
947b205f | 685 | test_acpi_one(NULL, &data); |
9e8458c0 | 686 | free_test_data(&data); |
71f4be25 PB |
687 | } |
688 | ||
3a9c86df IM |
689 | static void test_acpi_piix4_tcg_bridge(void) |
690 | { | |
691 | test_data data; | |
692 | ||
693 | memset(&data, 0, sizeof(data)); | |
694 | data.machine = MACHINE_PC; | |
695 | data.variant = ".bridge"; | |
f4eda2d4 CM |
696 | data.required_struct_types = base_required_struct_types; |
697 | data.required_struct_types_len = ARRAY_SIZE(base_required_struct_types); | |
947b205f | 698 | test_acpi_one("-device pci-bridge,chassis_nr=1", &data); |
3a9c86df IM |
699 | free_test_data(&data); |
700 | } | |
701 | ||
71f4be25 PB |
702 | static void test_acpi_q35_tcg(void) |
703 | { | |
704 | test_data data; | |
8ac2adf7 | 705 | |
9e8458c0 MA |
706 | memset(&data, 0, sizeof(data)); |
707 | data.machine = MACHINE_Q35; | |
f4eda2d4 CM |
708 | data.required_struct_types = base_required_struct_types; |
709 | data.required_struct_types_len = ARRAY_SIZE(base_required_struct_types); | |
947b205f | 710 | test_acpi_one(NULL, &data); |
8ac2adf7 | 711 | free_test_data(&data); |
ad6423a7 MT |
712 | } |
713 | ||
3a9c86df IM |
714 | static void test_acpi_q35_tcg_bridge(void) |
715 | { | |
716 | test_data data; | |
717 | ||
718 | memset(&data, 0, sizeof(data)); | |
719 | data.machine = MACHINE_Q35; | |
720 | data.variant = ".bridge"; | |
f4eda2d4 CM |
721 | data.required_struct_types = base_required_struct_types; |
722 | data.required_struct_types_len = ARRAY_SIZE(base_required_struct_types); | |
947b205f | 723 | test_acpi_one("-device pci-bridge,chassis_nr=1", |
3a9c86df IM |
724 | &data); |
725 | free_test_data(&data); | |
726 | } | |
727 | ||
0259e966 LE |
728 | static void test_acpi_q35_tcg_mmio64(void) |
729 | { | |
730 | test_data data = { | |
731 | .machine = MACHINE_Q35, | |
732 | .variant = ".mmio64", | |
733 | .required_struct_types = base_required_struct_types, | |
734 | .required_struct_types_len = ARRAY_SIZE(base_required_struct_types) | |
735 | }; | |
736 | ||
737 | test_acpi_one("-m 128M,slots=1,maxmem=2G " | |
738 | "-device pci-testdev,membar=2G", | |
739 | &data); | |
740 | free_test_data(&data); | |
741 | } | |
742 | ||
6b9c1dd2 IM |
743 | static void test_acpi_piix4_tcg_cphp(void) |
744 | { | |
745 | test_data data; | |
746 | ||
747 | memset(&data, 0, sizeof(data)); | |
748 | data.machine = MACHINE_PC; | |
749 | data.variant = ".cphp"; | |
d6309c17 | 750 | test_acpi_one("-smp 2,cores=3,sockets=2,maxcpus=6" |
fda4096f HC |
751 | " -numa node -numa node" |
752 | " -numa dist,src=0,dst=1,val=21", | |
6b9c1dd2 IM |
753 | &data); |
754 | free_test_data(&data); | |
755 | } | |
756 | ||
757 | static void test_acpi_q35_tcg_cphp(void) | |
758 | { | |
759 | test_data data; | |
760 | ||
761 | memset(&data, 0, sizeof(data)); | |
762 | data.machine = MACHINE_Q35; | |
763 | data.variant = ".cphp"; | |
d6309c17 | 764 | test_acpi_one(" -smp 2,cores=3,sockets=2,maxcpus=6" |
fda4096f HC |
765 | " -numa node -numa node" |
766 | " -numa dist,src=0,dst=1,val=21", | |
6b9c1dd2 IM |
767 | &data); |
768 | free_test_data(&data); | |
769 | } | |
770 | ||
f4eda2d4 CM |
771 | static uint8_t ipmi_required_struct_types[] = { |
772 | 0, 1, 3, 4, 16, 17, 19, 32, 38, 127 | |
773 | }; | |
774 | ||
775 | static void test_acpi_q35_tcg_ipmi(void) | |
776 | { | |
777 | test_data data; | |
778 | ||
779 | memset(&data, 0, sizeof(data)); | |
780 | data.machine = MACHINE_Q35; | |
781 | data.variant = ".ipmibt"; | |
782 | data.required_struct_types = ipmi_required_struct_types; | |
783 | data.required_struct_types_len = ARRAY_SIZE(ipmi_required_struct_types); | |
947b205f | 784 | test_acpi_one("-device ipmi-bmc-sim,id=bmc0" |
f4eda2d4 CM |
785 | " -device isa-ipmi-bt,bmc=bmc0", |
786 | &data); | |
787 | free_test_data(&data); | |
788 | } | |
789 | ||
790 | static void test_acpi_piix4_tcg_ipmi(void) | |
791 | { | |
792 | test_data data; | |
793 | ||
794 | /* Supplying -machine accel argument overrides the default (qtest). | |
795 | * This is to make guest actually run. | |
796 | */ | |
797 | memset(&data, 0, sizeof(data)); | |
798 | data.machine = MACHINE_PC; | |
799 | data.variant = ".ipmikcs"; | |
800 | data.required_struct_types = ipmi_required_struct_types; | |
801 | data.required_struct_types_len = ARRAY_SIZE(ipmi_required_struct_types); | |
947b205f | 802 | test_acpi_one("-device ipmi-bmc-sim,id=bmc0" |
f4eda2d4 CM |
803 | " -device isa-ipmi-kcs,irq=0,bmc=bmc0", |
804 | &data); | |
805 | free_test_data(&data); | |
806 | } | |
807 | ||
4462fc60 IM |
808 | static void test_acpi_q35_tcg_memhp(void) |
809 | { | |
810 | test_data data; | |
811 | ||
812 | memset(&data, 0, sizeof(data)); | |
813 | data.machine = MACHINE_Q35; | |
814 | data.variant = ".memhp"; | |
fda4096f HC |
815 | test_acpi_one(" -m 128,slots=3,maxmem=1G" |
816 | " -numa node -numa node" | |
817 | " -numa dist,src=0,dst=1,val=21", | |
818 | &data); | |
4462fc60 IM |
819 | free_test_data(&data); |
820 | } | |
821 | ||
822 | static void test_acpi_piix4_tcg_memhp(void) | |
823 | { | |
824 | test_data data; | |
825 | ||
826 | memset(&data, 0, sizeof(data)); | |
827 | data.machine = MACHINE_PC; | |
828 | data.variant = ".memhp"; | |
fda4096f HC |
829 | test_acpi_one(" -m 128,slots=3,maxmem=1G" |
830 | " -numa node -numa node" | |
831 | " -numa dist,src=0,dst=1,val=21", | |
832 | &data); | |
4462fc60 IM |
833 | free_test_data(&data); |
834 | } | |
835 | ||
d82c4f82 DL |
836 | static void test_acpi_q35_tcg_numamem(void) |
837 | { | |
838 | test_data data; | |
839 | ||
840 | memset(&data, 0, sizeof(data)); | |
841 | data.machine = MACHINE_Q35; | |
842 | data.variant = ".numamem"; | |
843 | test_acpi_one(" -numa node -numa node,mem=128", &data); | |
844 | free_test_data(&data); | |
845 | } | |
846 | ||
847 | static void test_acpi_piix4_tcg_numamem(void) | |
848 | { | |
849 | test_data data; | |
850 | ||
851 | memset(&data, 0, sizeof(data)); | |
852 | data.machine = MACHINE_PC; | |
853 | data.variant = ".numamem"; | |
854 | test_acpi_one(" -numa node -numa node,mem=128", &data); | |
855 | free_test_data(&data); | |
856 | } | |
857 | ||
adae91ce HZ |
858 | static void test_acpi_tcg_dimm_pxm(const char *machine) |
859 | { | |
860 | test_data data; | |
861 | ||
862 | memset(&data, 0, sizeof(data)); | |
863 | data.machine = machine; | |
864 | data.variant = ".dimmpxm"; | |
11c39b5c | 865 | test_acpi_one(" -machine nvdimm=on,nvdimm-persistence=cpu" |
adae91ce HZ |
866 | " -smp 4,sockets=4" |
867 | " -m 128M,slots=3,maxmem=1G" | |
868 | " -numa node,mem=32M,nodeid=0" | |
869 | " -numa node,mem=32M,nodeid=1" | |
870 | " -numa node,mem=32M,nodeid=2" | |
871 | " -numa node,mem=32M,nodeid=3" | |
872 | " -numa cpu,node-id=0,socket-id=0" | |
873 | " -numa cpu,node-id=1,socket-id=1" | |
874 | " -numa cpu,node-id=2,socket-id=2" | |
875 | " -numa cpu,node-id=3,socket-id=3" | |
876 | " -object memory-backend-ram,id=ram0,size=128M" | |
877 | " -object memory-backend-ram,id=nvm0,size=128M" | |
878 | " -device pc-dimm,id=dimm0,memdev=ram0,node=1" | |
879 | " -device nvdimm,id=dimm1,memdev=nvm0,node=2", | |
880 | &data); | |
881 | free_test_data(&data); | |
882 | } | |
883 | ||
884 | static void test_acpi_q35_tcg_dimm_pxm(void) | |
885 | { | |
886 | test_acpi_tcg_dimm_pxm(MACHINE_Q35); | |
887 | } | |
888 | ||
889 | static void test_acpi_piix4_tcg_dimm_pxm(void) | |
890 | { | |
891 | test_acpi_tcg_dimm_pxm(MACHINE_PC); | |
892 | } | |
893 | ||
ad6423a7 MT |
894 | int main(int argc, char *argv[]) |
895 | { | |
896 | const char *arch = qtest_get_arch(); | |
5862ad0f | 897 | int ret; |
c39a28a4 | 898 | |
4e082566 VK |
899 | ret = boot_sector_init(disk); |
900 | if(ret) | |
901 | return ret; | |
ad6423a7 MT |
902 | |
903 | g_test_init(&argc, &argv, NULL); | |
904 | ||
905 | if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) { | |
947b205f MA |
906 | qtest_add_func("acpi/piix4", test_acpi_piix4_tcg); |
907 | qtest_add_func("acpi/piix4/bridge", test_acpi_piix4_tcg_bridge); | |
908 | qtest_add_func("acpi/q35", test_acpi_q35_tcg); | |
909 | qtest_add_func("acpi/q35/bridge", test_acpi_q35_tcg_bridge); | |
0259e966 | 910 | qtest_add_func("acpi/q35/mmio64", test_acpi_q35_tcg_mmio64); |
947b205f MA |
911 | qtest_add_func("acpi/piix4/ipmi", test_acpi_piix4_tcg_ipmi); |
912 | qtest_add_func("acpi/q35/ipmi", test_acpi_q35_tcg_ipmi); | |
913 | qtest_add_func("acpi/piix4/cpuhp", test_acpi_piix4_tcg_cphp); | |
914 | qtest_add_func("acpi/q35/cpuhp", test_acpi_q35_tcg_cphp); | |
4462fc60 IM |
915 | qtest_add_func("acpi/piix4/memhp", test_acpi_piix4_tcg_memhp); |
916 | qtest_add_func("acpi/q35/memhp", test_acpi_q35_tcg_memhp); | |
d82c4f82 DL |
917 | qtest_add_func("acpi/piix4/numamem", test_acpi_piix4_tcg_numamem); |
918 | qtest_add_func("acpi/q35/numamem", test_acpi_q35_tcg_numamem); | |
adae91ce HZ |
919 | qtest_add_func("acpi/piix4/dimmpxm", test_acpi_piix4_tcg_dimm_pxm); |
920 | qtest_add_func("acpi/q35/dimmpxm", test_acpi_q35_tcg_dimm_pxm); | |
ad6423a7 | 921 | } |
5862ad0f | 922 | ret = g_test_run(); |
4e082566 | 923 | boot_sector_cleanup(disk); |
5862ad0f | 924 | return ret; |
ad6423a7 | 925 | } |