2 * Boot order test cases.
4 * Copyright (c) 2013 Red Hat Inc.
7 * Michael S. Tsirkin <mst@redhat.com>,
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.
16 #include <glib/gstdio.h>
17 #include "qemu-common.h"
19 #include "qemu/compiler.h"
20 #include "hw/i386/acpi-defs.h"
22 #define MACHINE_PC "pc"
23 #define MACHINE_Q35 "q35"
25 #define ACPI_REBUILD_EXPECTED_AML "TEST_ACPI_REBUILD_AML"
26 #define ACPI_SSDT_SIGNATURE 0x54445353 /* SSDT */
28 /* DSDT and SSDTs format */
30 AcpiTableHeader header
;
31 gchar
*aml
; /* aml bytecode from guest */
34 gchar
*asl
; /* asl code generated from aml */
37 bool tmp_files_retain
; /* do not delete the temp asl/aml */
38 } QEMU_PACKED AcpiSdtTable
;
43 AcpiRsdpDescriptor rsdp_table
;
44 AcpiRsdtDescriptorRev1 rsdt_table
;
45 AcpiFadtDescriptorRev1 fadt_table
;
46 AcpiFacsDescriptorRev1 facs_table
;
47 uint32_t *rsdt_tables_addr
;
52 #define LOW(x) ((x) & 0xff)
53 #define HIGH(x) ((x) >> 8)
55 #define SIGNATURE 0xdead
56 #define SIGNATURE_OFFSET 0x10
57 #define BOOT_SECTOR_ADDRESS 0x7c00
59 #define ACPI_READ_FIELD(field, addr) \
61 switch (sizeof(field)) { \
63 field = readb(addr); \
66 field = readw(addr); \
69 field = readl(addr); \
72 field = readq(addr); \
77 addr += sizeof(field); \
80 #define ACPI_READ_ARRAY_PTR(arr, length, addr) \
83 for (idx = 0; idx < length; ++idx) { \
84 ACPI_READ_FIELD(arr[idx], addr); \
88 #define ACPI_READ_ARRAY(arr, addr) \
89 ACPI_READ_ARRAY_PTR(arr, sizeof(arr)/sizeof(arr[0]), addr)
91 #define ACPI_READ_TABLE_HEADER(table, addr) \
93 ACPI_READ_FIELD((table)->signature, addr); \
94 ACPI_READ_FIELD((table)->length, addr); \
95 ACPI_READ_FIELD((table)->revision, addr); \
96 ACPI_READ_FIELD((table)->checksum, addr); \
97 ACPI_READ_ARRAY((table)->oem_id, addr); \
98 ACPI_READ_ARRAY((table)->oem_table_id, addr); \
99 ACPI_READ_FIELD((table)->oem_revision, addr); \
100 ACPI_READ_ARRAY((table)->asl_compiler_id, addr); \
101 ACPI_READ_FIELD((table)->asl_compiler_revision, addr); \
104 /* Boot sector code: write SIGNATURE into memory,
106 * Q35 machine requires a minimum 0x7e000 bytes disk.
109 static uint8_t boot_sector
[0x7e000] = {
110 /* 7c00: mov $0xdead,%ax */
112 [0x01] = LOW(SIGNATURE
),
113 [0x02] = HIGH(SIGNATURE
),
114 /* 7c03: mov %ax,0x7c10 */
116 [0x04] = LOW(BOOT_SECTOR_ADDRESS
+ SIGNATURE_OFFSET
),
117 [0x05] = HIGH(BOOT_SECTOR_ADDRESS
+ SIGNATURE_OFFSET
),
122 /* 7c08: jmp 0x7c07=0x7c0a-3 */
125 /* We mov 0xdead here: set value to make debugging easier */
126 [SIGNATURE_OFFSET
] = LOW(0xface),
127 [SIGNATURE_OFFSET
+ 1] = HIGH(0xface),
128 /* End of boot sector marker */
133 static const char *disk
= "tests/acpi-test-disk.raw";
134 static const char *data_dir
= "tests/acpi-test-data";
136 static const char *iasl
= stringify(CONFIG_IASL
);
138 static const char *iasl
;
141 static void free_test_data(test_data
*data
)
146 if (data
->rsdt_tables_addr
) {
147 g_free(data
->rsdt_tables_addr
);
150 for (i
= 0; i
< data
->tables
->len
; ++i
) {
151 temp
= &g_array_index(data
->tables
, AcpiSdtTable
, i
);
155 if (temp
->aml_file
) {
156 if (!temp
->tmp_files_retain
&&
157 g_strstr_len(temp
->aml_file
, -1, "aml-")) {
158 unlink(temp
->aml_file
);
160 g_free(temp
->aml_file
);
165 if (temp
->asl_file
) {
166 if (!temp
->tmp_files_retain
) {
167 unlink(temp
->asl_file
);
169 g_free(temp
->asl_file
);
173 g_array_free(data
->tables
, false);
176 static uint8_t acpi_checksum(const uint8_t *data
, int len
)
181 for (i
= 0; i
< len
; i
++) {
188 static void test_acpi_rsdp_address(test_data
*data
)
192 /* OK, now find RSDP */
193 for (off
= 0xf0000; off
< 0x100000; off
+= 0x10) {
194 uint8_t sig
[] = "RSD PTR ";
197 for (i
= 0; i
< sizeof sig
- 1; ++i
) {
198 sig
[i
] = readb(off
+ i
);
201 if (!memcmp(sig
, "RSD PTR ", sizeof sig
)) {
206 g_assert_cmphex(off
, <, 0x100000);
207 data
->rsdp_addr
= off
;
210 static void test_acpi_rsdp_table(test_data
*data
)
212 AcpiRsdpDescriptor
*rsdp_table
= &data
->rsdp_table
;
213 uint32_t addr
= data
->rsdp_addr
;
215 ACPI_READ_FIELD(rsdp_table
->signature
, addr
);
216 g_assert_cmphex(rsdp_table
->signature
, ==, ACPI_RSDP_SIGNATURE
);
218 ACPI_READ_FIELD(rsdp_table
->checksum
, addr
);
219 ACPI_READ_ARRAY(rsdp_table
->oem_id
, addr
);
220 ACPI_READ_FIELD(rsdp_table
->revision
, addr
);
221 ACPI_READ_FIELD(rsdp_table
->rsdt_physical_address
, addr
);
222 ACPI_READ_FIELD(rsdp_table
->length
, addr
);
224 /* rsdp checksum is not for the whole table, but for the first 20 bytes */
225 g_assert(!acpi_checksum((uint8_t *)rsdp_table
, 20));
228 static void test_acpi_rsdt_table(test_data
*data
)
230 AcpiRsdtDescriptorRev1
*rsdt_table
= &data
->rsdt_table
;
231 uint32_t addr
= data
->rsdp_table
.rsdt_physical_address
;
236 /* read the header */
237 ACPI_READ_TABLE_HEADER(rsdt_table
, addr
);
238 g_assert_cmphex(rsdt_table
->signature
, ==, ACPI_RSDT_SIGNATURE
);
240 /* compute the table entries in rsdt */
241 tables_nr
= (rsdt_table
->length
- sizeof(AcpiRsdtDescriptorRev1
)) /
243 g_assert_cmpint(tables_nr
, >, 0);
245 /* get the addresses of the tables pointed by rsdt */
246 tables
= g_new0(uint32_t, tables_nr
);
247 ACPI_READ_ARRAY_PTR(tables
, tables_nr
, addr
);
249 checksum
= acpi_checksum((uint8_t *)rsdt_table
, rsdt_table
->length
) +
250 acpi_checksum((uint8_t *)tables
, tables_nr
* sizeof(uint32_t));
253 /* SSDT tables after FADT */
254 data
->rsdt_tables_addr
= tables
;
255 data
->rsdt_tables_nr
= tables_nr
;
258 static void test_acpi_fadt_table(test_data
*data
)
260 AcpiFadtDescriptorRev1
*fadt_table
= &data
->fadt_table
;
263 /* FADT table comes first */
264 addr
= data
->rsdt_tables_addr
[0];
265 ACPI_READ_TABLE_HEADER(fadt_table
, addr
);
267 ACPI_READ_FIELD(fadt_table
->firmware_ctrl
, addr
);
268 ACPI_READ_FIELD(fadt_table
->dsdt
, addr
);
269 ACPI_READ_FIELD(fadt_table
->model
, addr
);
270 ACPI_READ_FIELD(fadt_table
->reserved1
, addr
);
271 ACPI_READ_FIELD(fadt_table
->sci_int
, addr
);
272 ACPI_READ_FIELD(fadt_table
->smi_cmd
, addr
);
273 ACPI_READ_FIELD(fadt_table
->acpi_enable
, addr
);
274 ACPI_READ_FIELD(fadt_table
->acpi_disable
, addr
);
275 ACPI_READ_FIELD(fadt_table
->S4bios_req
, addr
);
276 ACPI_READ_FIELD(fadt_table
->reserved2
, addr
);
277 ACPI_READ_FIELD(fadt_table
->pm1a_evt_blk
, addr
);
278 ACPI_READ_FIELD(fadt_table
->pm1b_evt_blk
, addr
);
279 ACPI_READ_FIELD(fadt_table
->pm1a_cnt_blk
, addr
);
280 ACPI_READ_FIELD(fadt_table
->pm1b_cnt_blk
, addr
);
281 ACPI_READ_FIELD(fadt_table
->pm2_cnt_blk
, addr
);
282 ACPI_READ_FIELD(fadt_table
->pm_tmr_blk
, addr
);
283 ACPI_READ_FIELD(fadt_table
->gpe0_blk
, addr
);
284 ACPI_READ_FIELD(fadt_table
->gpe1_blk
, addr
);
285 ACPI_READ_FIELD(fadt_table
->pm1_evt_len
, addr
);
286 ACPI_READ_FIELD(fadt_table
->pm1_cnt_len
, addr
);
287 ACPI_READ_FIELD(fadt_table
->pm2_cnt_len
, addr
);
288 ACPI_READ_FIELD(fadt_table
->pm_tmr_len
, addr
);
289 ACPI_READ_FIELD(fadt_table
->gpe0_blk_len
, addr
);
290 ACPI_READ_FIELD(fadt_table
->gpe1_blk_len
, addr
);
291 ACPI_READ_FIELD(fadt_table
->gpe1_base
, addr
);
292 ACPI_READ_FIELD(fadt_table
->reserved3
, addr
);
293 ACPI_READ_FIELD(fadt_table
->plvl2_lat
, addr
);
294 ACPI_READ_FIELD(fadt_table
->plvl3_lat
, addr
);
295 ACPI_READ_FIELD(fadt_table
->flush_size
, addr
);
296 ACPI_READ_FIELD(fadt_table
->flush_stride
, addr
);
297 ACPI_READ_FIELD(fadt_table
->duty_offset
, addr
);
298 ACPI_READ_FIELD(fadt_table
->duty_width
, addr
);
299 ACPI_READ_FIELD(fadt_table
->day_alrm
, addr
);
300 ACPI_READ_FIELD(fadt_table
->mon_alrm
, addr
);
301 ACPI_READ_FIELD(fadt_table
->century
, addr
);
302 ACPI_READ_FIELD(fadt_table
->reserved4
, addr
);
303 ACPI_READ_FIELD(fadt_table
->reserved4a
, addr
);
304 ACPI_READ_FIELD(fadt_table
->reserved4b
, addr
);
305 ACPI_READ_FIELD(fadt_table
->flags
, addr
);
307 g_assert_cmphex(fadt_table
->signature
, ==, ACPI_FACP_SIGNATURE
);
308 g_assert(!acpi_checksum((uint8_t *)fadt_table
, fadt_table
->length
));
311 static void test_acpi_facs_table(test_data
*data
)
313 AcpiFacsDescriptorRev1
*facs_table
= &data
->facs_table
;
314 uint32_t addr
= data
->fadt_table
.firmware_ctrl
;
316 ACPI_READ_FIELD(facs_table
->signature
, addr
);
317 ACPI_READ_FIELD(facs_table
->length
, addr
);
318 ACPI_READ_FIELD(facs_table
->hardware_signature
, addr
);
319 ACPI_READ_FIELD(facs_table
->firmware_waking_vector
, addr
);
320 ACPI_READ_FIELD(facs_table
->global_lock
, addr
);
321 ACPI_READ_FIELD(facs_table
->flags
, addr
);
322 ACPI_READ_ARRAY(facs_table
->resverved3
, addr
);
324 g_assert_cmphex(facs_table
->signature
, ==, ACPI_FACS_SIGNATURE
);
327 static void test_dst_table(AcpiSdtTable
*sdt_table
, uint32_t addr
)
331 ACPI_READ_TABLE_HEADER(&sdt_table
->header
, addr
);
333 sdt_table
->aml_len
= sdt_table
->header
.length
- sizeof(AcpiTableHeader
);
334 sdt_table
->aml
= g_malloc0(sdt_table
->aml_len
);
335 ACPI_READ_ARRAY_PTR(sdt_table
->aml
, sdt_table
->aml_len
, addr
);
337 checksum
= acpi_checksum((uint8_t *)sdt_table
, sizeof(AcpiTableHeader
)) +
338 acpi_checksum((uint8_t *)sdt_table
->aml
, sdt_table
->aml_len
);
342 static void test_acpi_dsdt_table(test_data
*data
)
344 AcpiSdtTable dsdt_table
;
345 uint32_t addr
= data
->fadt_table
.dsdt
;
347 memset(&dsdt_table
, 0, sizeof(dsdt_table
));
348 data
->tables
= g_array_new(false, true, sizeof(AcpiSdtTable
));
350 test_dst_table(&dsdt_table
, addr
);
351 g_assert_cmphex(dsdt_table
.header
.signature
, ==, ACPI_DSDT_SIGNATURE
);
353 /* Place DSDT first */
354 g_array_append_val(data
->tables
, dsdt_table
);
357 static void test_acpi_tables(test_data
*data
)
359 int tables_nr
= data
->rsdt_tables_nr
- 1; /* fadt is first */
362 for (i
= 0; i
< tables_nr
; i
++) {
363 AcpiSdtTable ssdt_table
;
365 memset(&ssdt_table
, 0 , sizeof(ssdt_table
));
366 uint32_t addr
= data
->rsdt_tables_addr
[i
+ 1]; /* fadt is first */
367 test_dst_table(&ssdt_table
, addr
);
368 g_array_append_val(data
->tables
, ssdt_table
);
372 static void dump_aml_files(test_data
*data
, bool rebuild
)
375 GError
*error
= NULL
;
376 gchar
*aml_file
= NULL
;
381 for (i
= 0; i
< data
->tables
->len
; ++i
) {
382 sdt
= &g_array_index(data
->tables
, AcpiSdtTable
, i
);
386 aml_file
= g_strdup_printf("%s/%s/%.4s", data_dir
, data
->machine
,
387 (gchar
*)&sdt
->header
.signature
);
388 fd
= g_open(aml_file
, O_WRONLY
|O_TRUNC
|O_CREAT
,
389 S_IRUSR
|S_IWUSR
|S_IRGRP
|S_IWGRP
|S_IROTH
);
391 fd
= g_file_open_tmp("aml-XXXXXX", &sdt
->aml_file
, &error
);
392 g_assert_no_error(error
);
396 ret
= qemu_write_full(fd
, sdt
, sizeof(AcpiTableHeader
));
397 g_assert(ret
== sizeof(AcpiTableHeader
));
398 ret
= qemu_write_full(fd
, sdt
->aml
, sdt
->aml_len
);
399 g_assert(ret
== sdt
->aml_len
);
409 static bool compare_signature(AcpiSdtTable
*sdt
, uint32_t signature
)
411 return sdt
->header
.signature
== signature
;
414 static bool load_asl(GArray
*sdts
, AcpiSdtTable
*sdt
)
417 GError
*error
= NULL
;
418 GString
*command_line
= g_string_new(iasl
);
420 gchar
*out
, *out_err
;
424 fd
= g_file_open_tmp("asl-XXXXXX.dsl", &sdt
->asl_file
, &error
);
425 g_assert_no_error(error
);
428 /* build command line */
429 g_string_append_printf(command_line
, " -p %s ", sdt
->asl_file
);
430 if (compare_signature(sdt
, ACPI_DSDT_SIGNATURE
) ||
431 compare_signature(sdt
, ACPI_SSDT_SIGNATURE
)) {
432 for (i
= 0; i
< sdts
->len
; ++i
) {
433 temp
= &g_array_index(sdts
, AcpiSdtTable
, i
);
434 if (compare_signature(temp
, ACPI_DSDT_SIGNATURE
) ||
435 compare_signature(temp
, ACPI_SSDT_SIGNATURE
)) {
436 g_string_append_printf(command_line
, "-e %s ", temp
->aml_file
);
440 g_string_append_printf(command_line
, "-d %s", sdt
->aml_file
);
442 /* pass 'out' and 'out_err' in order to be redirected */
443 ret
= g_spawn_command_line_sync(command_line
->str
, &out
, &out_err
, NULL
, &error
);
444 g_assert_no_error(error
);
447 ret
= g_file_get_contents(sdt
->asl_file
, (gchar
**)&sdt
->asl
,
448 &sdt
->asl_len
, &error
);
450 g_assert_no_error(error
);
451 g_assert(sdt
->asl_len
);
456 g_string_free(command_line
, true);
461 #define COMMENT_END "*/"
462 #define DEF_BLOCK "DefinitionBlock ("
463 #define BLOCK_NAME_END ".aml"
465 static GString
*normalize_asl(gchar
*asl_code
)
467 GString
*asl
= g_string_new(asl_code
);
468 gchar
*comment
, *block_name
;
470 /* strip comments (different generation days) */
471 comment
= g_strstr_len(asl
->str
, asl
->len
, COMMENT_END
);
473 asl
= g_string_erase(asl
, 0, comment
+ sizeof(COMMENT_END
) - asl
->str
);
476 /* strip def block name (it has file path in it) */
477 if (g_str_has_prefix(asl
->str
, DEF_BLOCK
)) {
478 block_name
= g_strstr_len(asl
->str
, asl
->len
, BLOCK_NAME_END
);
479 g_assert(block_name
);
480 asl
= g_string_erase(asl
, 0,
481 block_name
+ sizeof(BLOCK_NAME_END
) - asl
->str
);
487 static GArray
*load_expected_aml(test_data
*data
)
492 GError
*error
= NULL
;
495 GArray
*exp_tables
= g_array_new(false, true, sizeof(AcpiSdtTable
));
496 for (i
= 0; i
< data
->tables
->len
; ++i
) {
497 AcpiSdtTable exp_sdt
;
498 sdt
= &g_array_index(data
->tables
, AcpiSdtTable
, i
);
500 memset(&exp_sdt
, 0, sizeof(exp_sdt
));
501 exp_sdt
.header
.signature
= sdt
->header
.signature
;
503 aml_file
= g_strdup_printf("%s/%s/%.4s", data_dir
, data
->machine
,
504 (gchar
*)&exp_sdt
.header
.signature
);
505 exp_sdt
.aml_file
= aml_file
;
506 g_assert(g_file_test(aml_file
, G_FILE_TEST_EXISTS
));
507 ret
= g_file_get_contents(aml_file
, &exp_sdt
.aml
,
508 &exp_sdt
.aml_len
, &error
);
510 g_assert_no_error(error
);
511 g_assert(exp_sdt
.aml
);
512 g_assert(exp_sdt
.aml_len
);
514 g_array_append_val(exp_tables
, exp_sdt
);
520 static void test_acpi_asl(test_data
*data
)
523 AcpiSdtTable
*sdt
, *exp_sdt
;
525 gboolean exp_err
, err
;
527 memset(&exp_data
, 0, sizeof(exp_data
));
528 exp_data
.tables
= load_expected_aml(data
);
529 dump_aml_files(data
, false);
530 for (i
= 0; i
< data
->tables
->len
; ++i
) {
531 GString
*asl
, *exp_asl
;
533 sdt
= &g_array_index(data
->tables
, AcpiSdtTable
, i
);
534 exp_sdt
= &g_array_index(exp_data
.tables
, AcpiSdtTable
, i
);
536 err
= load_asl(data
->tables
, sdt
);
537 asl
= normalize_asl(sdt
->asl
);
539 exp_err
= load_asl(exp_data
.tables
, exp_sdt
);
540 exp_asl
= normalize_asl(exp_sdt
->asl
);
542 /* TODO: check for warnings */
543 g_assert(!err
|| exp_err
);
545 if (g_strcmp0(asl
->str
, exp_asl
->str
)) {
546 sdt
->tmp_files_retain
= true;
547 exp_sdt
->tmp_files_retain
= true;
549 "acpi-test: Warning! %.4s mismatch. "
550 "Actual [asl:%s, aml:%s], Expected [asl:%s, aml:%s].\n",
551 (gchar
*)&exp_sdt
->header
.signature
,
552 sdt
->asl_file
, sdt
->aml_file
,
553 exp_sdt
->asl_file
, exp_sdt
->aml_file
);
555 g_string_free(asl
, true);
556 g_string_free(exp_asl
, true);
559 free_test_data(&exp_data
);
562 static void test_acpi_one(const char *params
, test_data
*data
)
565 uint8_t signature_low
;
566 uint8_t signature_high
;
569 const char *device
= "";
571 if (!g_strcmp0(data
->machine
, MACHINE_Q35
)) {
572 device
= ",id=hd -device ide-hd,drive=hd";
575 args
= g_strdup_printf("-net none -display none %s -drive file=%s%s,",
576 params
? params
: "", disk
, device
);
579 /* Wait at most 1 minute */
580 #define TEST_DELAY (1 * G_USEC_PER_SEC / 10)
581 #define TEST_CYCLES MAX((60 * G_USEC_PER_SEC / TEST_DELAY), 1)
583 /* Poll until code has run and modified memory. Once it has we know BIOS
584 * initialization is done. TODO: check that IP reached the halt
587 for (i
= 0; i
< TEST_CYCLES
; ++i
) {
588 signature_low
= readb(BOOT_SECTOR_ADDRESS
+ SIGNATURE_OFFSET
);
589 signature_high
= readb(BOOT_SECTOR_ADDRESS
+ SIGNATURE_OFFSET
+ 1);
590 signature
= (signature_high
<< 8) | signature_low
;
591 if (signature
== SIGNATURE
) {
594 g_usleep(TEST_DELAY
);
596 g_assert_cmphex(signature
, ==, SIGNATURE
);
598 test_acpi_rsdp_address(data
);
599 test_acpi_rsdp_table(data
);
600 test_acpi_rsdt_table(data
);
601 test_acpi_fadt_table(data
);
602 test_acpi_facs_table(data
);
603 test_acpi_dsdt_table(data
);
604 test_acpi_tables(data
);
607 if (getenv(ACPI_REBUILD_EXPECTED_AML
)) {
608 dump_aml_files(data
, true);
614 qtest_quit(global_qtest
);
618 static void test_acpi_tcg(void)
622 /* Supplying -machine accel argument overrides the default (qtest).
623 * This is to make guest actually run.
625 memset(&data
, 0, sizeof(data
));
626 data
.machine
= MACHINE_PC
;
627 test_acpi_one("-machine accel=tcg", &data
);
628 free_test_data(&data
);
630 memset(&data
, 0, sizeof(data
));
631 data
.machine
= MACHINE_Q35
;
632 test_acpi_one("-machine q35,accel=tcg", &data
);
633 free_test_data(&data
);
636 int main(int argc
, char *argv
[])
638 const char *arch
= qtest_get_arch();
639 FILE *f
= fopen(disk
, "w");
641 fwrite(boot_sector
, 1, sizeof boot_sector
, f
);
644 g_test_init(&argc
, &argv
, NULL
);
646 if (strcmp(arch
, "i386") == 0 || strcmp(arch
, "x86_64") == 0) {
647 qtest_add_func("acpi/tcg", test_acpi_tcg
);