2 * SPDX-License-Identifier: BSD-2-Clause
4 * Copyright (c) 2022 Beckhoff Automation GmbH & Co. KG
8 #include <sys/endian.h>
10 #include <sys/queue.h>
13 #include <machine/vmm.h>
23 #include "qemu_loader.h"
25 struct basl_table_checksum {
26 STAILQ_ENTRY(basl_table_checksum) chain;
32 struct basl_table_length {
33 STAILQ_ENTRY(basl_table_length) chain;
38 struct basl_table_pointer {
39 STAILQ_ENTRY(basl_table_pointer) chain;
40 uint8_t src_signature[ACPI_NAMESEG_SIZE];
46 STAILQ_ENTRY(basl_table) chain;
48 uint8_t fwcfg_name[QEMU_FWCFG_MAX_NAME];
53 STAILQ_HEAD(basl_table_checksum_list, basl_table_checksum) checksums;
54 STAILQ_HEAD(basl_table_length_list, basl_table_length) lengths;
55 STAILQ_HEAD(basl_table_pointer_list, basl_table_pointer) pointers;
57 static STAILQ_HEAD(basl_table_list, basl_table) basl_tables = STAILQ_HEAD_INITIALIZER(
60 static struct qemu_loader *basl_loader;
61 static struct basl_table *rsdt;
62 static struct basl_table *xsdt;
64 static __inline uint64_t
65 basl_le_dec(void *pp, size_t len)
71 return ((uint8_t *)pp)[0];
84 basl_le_enc(void *pp, uint64_t val, size_t len)
95 basl_dump_table(const struct basl_table *const table, const bool mem)
97 const ACPI_TABLE_HEADER *const header = table->data;
103 data = vm_map_gpa(table->ctx, BHYVE_ACPI_BASE + table->off,
110 printf("%.4s @ %8x (%s)\n", header->Signature,
111 BHYVE_ACPI_BASE + table->off, mem ? "Memory" : "FwCfg");
112 hexdump(data, table->len, NULL, 0);
118 basl_dump(const bool mem)
120 struct basl_table *table;
122 STAILQ_FOREACH(table, &basl_tables, chain) {
123 BASL_EXEC(basl_dump_table(table, mem));
130 basl_fill_gas(ACPI_GENERIC_ADDRESS *const gas, const uint8_t space_id,
131 const uint8_t bit_width, const uint8_t bit_offset,
132 const uint8_t access_width, const uint64_t address)
136 gas->SpaceId = space_id;
137 gas->BitWidth = bit_width;
138 gas->BitOffset = bit_offset;
139 gas->AccessWidth = access_width;
140 gas->Address = htole64(address);
144 basl_finish_install_guest_tables(struct basl_table *const table, uint32_t *const off)
148 table->off = roundup2(*off, table->alignment);
149 *off = table->off + table->len;
150 if (*off <= table->off) {
151 warnx("%s: invalid table length 0x%8x @ offset 0x%8x", __func__,
152 table->len, table->off);
157 * Install ACPI tables directly in guest memory for use by guests which
158 * do not boot via EFI. EFI ROMs provide a pointer to the firmware
159 * generated ACPI tables instead, but it doesn't hurt to install the
162 gva = vm_map_gpa(table->ctx, BHYVE_ACPI_BASE + table->off, table->len);
164 warnx("%s: could not map gpa [ 0x%16lx, 0x%16lx ]", __func__,
165 (uint64_t)BHYVE_ACPI_BASE + table->off,
166 (uint64_t)BHYVE_ACPI_BASE + table->off + table->len);
169 memcpy(gva, table->data, table->len);
171 /* Cause guest bios to copy the ACPI table into guest memory. */
173 qemu_fwcfg_add_file(table->fwcfg_name, table->len, table->data));
174 BASL_EXEC(qemu_loader_alloc(basl_loader, table->fwcfg_name,
175 table->alignment, QEMU_LOADER_ALLOC_HIGH));
181 basl_finish_patch_checksums(struct basl_table *const table)
183 struct basl_table_checksum *checksum;
185 STAILQ_FOREACH(checksum, &table->checksums, chain) {
186 uint8_t *gva, *checksum_gva;
192 if (len == BASL_TABLE_CHECKSUM_LEN_FULL_TABLE) {
196 assert(checksum->off < table->len);
197 assert(checksum->start < table->len);
198 assert(checksum->start + len <= table->len);
201 * Install ACPI tables directly in guest memory for use by
202 * guests which do not boot via EFI. EFI ROMs provide a pointer
203 * to the firmware generated ACPI tables instead, but it doesn't
204 * hurt to install the tables always.
206 gpa = BHYVE_ACPI_BASE + table->off + checksum->start;
207 if ((gpa < BHYVE_ACPI_BASE) ||
208 (gpa < BHYVE_ACPI_BASE + table->off)) {
209 warnx("%s: invalid gpa (off 0x%8x start 0x%8x)",
210 __func__, table->off, checksum->start);
214 gva = vm_map_gpa(table->ctx, gpa, len);
216 warnx("%s: could not map gpa [ 0x%16lx, 0x%16lx ]",
217 __func__, gpa, gpa + len);
221 checksum_gva = gva + checksum->off;
222 if (checksum_gva < gva) {
223 warnx("%s: invalid checksum offset 0x%8x", __func__,
229 for (uint32_t i = 0; i < len; ++i) {
232 *checksum_gva = -sum;
234 /* Cause guest bios to patch the checksum. */
235 BASL_EXEC(qemu_loader_add_checksum(basl_loader,
236 table->fwcfg_name, checksum->off, checksum->start, len));
242 static struct basl_table *
243 basl_get_table_by_signature(const uint8_t signature[ACPI_NAMESEG_SIZE])
245 struct basl_table *table;
247 STAILQ_FOREACH(table, &basl_tables, chain) {
248 const ACPI_TABLE_HEADER *const header =
249 (const ACPI_TABLE_HEADER *)table->data;
251 if (strncmp(header->Signature, signature,
252 sizeof(header->Signature)) == 0) {
257 warnx("%s: %.4s not found", __func__, signature);
262 basl_finish_patch_pointers(struct basl_table *const table)
264 struct basl_table_pointer *pointer;
266 STAILQ_FOREACH(pointer, &table->pointers, chain) {
267 const struct basl_table *src_table;
271 assert(pointer->off < table->len);
272 assert(pointer->off + pointer->size <= table->len);
274 src_table = basl_get_table_by_signature(pointer->src_signature);
275 if (src_table == NULL) {
276 warnx("%s: could not find ACPI table %.4s", __func__,
277 pointer->src_signature);
282 * Install ACPI tables directly in guest memory for use by
283 * guests which do not boot via EFI. EFI ROMs provide a pointer
284 * to the firmware generated ACPI tables instead, but it doesn't
285 * hurt to install the tables always.
287 gpa = BHYVE_ACPI_BASE + table->off;
288 if (gpa < BHYVE_ACPI_BASE) {
289 warnx("%s: table offset of 0x%8x is too large",
290 __func__, table->off);
294 gva = vm_map_gpa(table->ctx, gpa, table->len);
296 warnx("%s: could not map gpa [ 0x%16lx, 0x%16lx ]",
297 __func__, gpa, gpa + table->len);
301 val = basl_le_dec(gva + pointer->off, pointer->size);
302 val += BHYVE_ACPI_BASE + src_table->off;
303 basl_le_enc(gva + pointer->off, val, pointer->size);
305 /* Cause guest bios to patch the pointer. */
307 qemu_loader_add_pointer(basl_loader, table->fwcfg_name,
308 src_table->fwcfg_name, pointer->off, pointer->size));
315 basl_finish_set_length(struct basl_table *const table)
317 struct basl_table_length *length;
319 STAILQ_FOREACH(length, &table->lengths, chain) {
320 assert(length->off < table->len);
321 assert(length->off + length->size <= table->len);
323 basl_le_enc((uint8_t *)table->data + length->off, table->len,
333 struct basl_table *table;
336 if (STAILQ_EMPTY(&basl_tables)) {
337 warnx("%s: no ACPI tables found", __func__);
342 * We have to install all tables before we can patch them. Therefore,
343 * use two loops. The first one installs all tables and the second one
346 STAILQ_FOREACH(table, &basl_tables, chain) {
347 BASL_EXEC(basl_finish_set_length(table));
348 BASL_EXEC(basl_finish_install_guest_tables(table, &off));
350 STAILQ_FOREACH(table, &basl_tables, chain) {
351 BASL_EXEC(basl_finish_patch_pointers(table));
354 * Calculate the checksum as last step!
356 BASL_EXEC(basl_finish_patch_checksums(table));
358 BASL_EXEC(qemu_loader_finish(basl_loader));
364 basl_init_rsdt(struct vmctx *const ctx)
367 basl_table_create(&rsdt, ctx, ACPI_SIG_RSDT, BASL_TABLE_ALIGNMENT));
370 BASL_EXEC(basl_table_append_header(rsdt, ACPI_SIG_RSDT, 1, 1));
371 /* Pointers (added by basl_table_register_to_rsdt) */
377 basl_init_xsdt(struct vmctx *const ctx)
380 basl_table_create(&xsdt, ctx, ACPI_SIG_XSDT, BASL_TABLE_ALIGNMENT));
383 BASL_EXEC(basl_table_append_header(xsdt, ACPI_SIG_XSDT, 1, 1));
384 /* Pointers (added by basl_table_register_to_rsdt) */
390 basl_init(struct vmctx *const ctx)
392 BASL_EXEC(basl_init_rsdt(ctx));
393 BASL_EXEC(basl_init_xsdt(ctx));
395 qemu_loader_create(&basl_loader, QEMU_FWCFG_FILE_TABLE_LOADER));
401 basl_table_add_checksum(struct basl_table *const table, const uint32_t off,
402 const uint32_t start, const uint32_t len)
404 struct basl_table_checksum *checksum;
406 assert(table != NULL);
408 checksum = calloc(1, sizeof(struct basl_table_checksum));
409 if (checksum == NULL) {
410 warnx("%s: failed to allocate checksum", __func__);
415 checksum->start = start;
418 STAILQ_INSERT_TAIL(&table->checksums, checksum, chain);
424 basl_table_add_length(struct basl_table *const table, const uint32_t off,
427 struct basl_table_length *length;
429 assert(table != NULL);
430 assert(size == 4 || size == 8);
432 length = calloc(1, sizeof(struct basl_table_length));
433 if (length == NULL) {
434 warnx("%s: failed to allocate length", __func__);
441 STAILQ_INSERT_TAIL(&table->lengths, length, chain);
447 basl_table_add_pointer(struct basl_table *const table,
448 const uint8_t src_signature[ACPI_NAMESEG_SIZE], const uint32_t off,
451 struct basl_table_pointer *pointer;
453 assert(table != NULL);
454 assert(size == 4 || size == 8);
456 pointer = calloc(1, sizeof(struct basl_table_pointer));
457 if (pointer == NULL) {
458 warnx("%s: failed to allocate pointer", __func__);
462 memcpy(pointer->src_signature, src_signature,
463 sizeof(pointer->src_signature));
465 pointer->size = size;
467 STAILQ_INSERT_TAIL(&table->pointers, pointer, chain);
473 basl_table_append_bytes(struct basl_table *const table, const void *const bytes,
478 assert(table != NULL);
479 assert(bytes != NULL);
481 if (table->len + len <= table->len) {
482 warnx("%s: table too large (table->len 0x%8x len 0x%8x)",
483 __func__, table->len, len);
487 table->data = reallocf(table->data, table->len + len);
488 if (table->data == NULL) {
489 warnx("%s: failed to realloc table to length 0x%8x", __func__,
495 end = (uint8_t *)table->data + table->len;
498 memcpy(end, bytes, len);
504 basl_table_append_checksum(struct basl_table *const table, const uint32_t start,
507 assert(table != NULL);
509 BASL_EXEC(basl_table_add_checksum(table, table->len, start, len));
510 BASL_EXEC(basl_table_append_int(table, 0, 1));
516 basl_table_append_content(struct basl_table *table, void *data, uint32_t len)
518 assert(data != NULL);
519 assert(len >= sizeof(ACPI_TABLE_HEADER));
521 return (basl_table_append_bytes(table,
522 (void *)((uintptr_t)(data) + sizeof(ACPI_TABLE_HEADER)),
523 len - sizeof(ACPI_TABLE_HEADER)));
527 basl_table_append_fwcfg(struct basl_table *const table,
528 const uint8_t *fwcfg_name, const uint32_t alignment, const uint8_t size)
530 assert(table != NULL);
531 assert(fwcfg_name != NULL);
532 assert(size <= sizeof(uint64_t));
534 BASL_EXEC(qemu_loader_alloc(basl_loader, fwcfg_name, alignment,
535 QEMU_LOADER_ALLOC_HIGH));
536 BASL_EXEC(qemu_loader_add_pointer(basl_loader, table->fwcfg_name,
537 fwcfg_name, table->len, size));
538 BASL_EXEC(basl_table_append_int(table, 0, size));
544 basl_table_append_gas(struct basl_table *const table, const uint8_t space_id,
545 const uint8_t bit_width, const uint8_t bit_offset,
546 const uint8_t access_width, const uint64_t address)
548 ACPI_GENERIC_ADDRESS gas_le = {
550 .BitWidth = bit_width,
551 .BitOffset = bit_offset,
552 .AccessWidth = access_width,
553 .Address = htole64(address),
556 return (basl_table_append_bytes(table, &gas_le, sizeof(gas_le)));
560 basl_table_append_header(struct basl_table *const table,
561 const uint8_t signature[ACPI_NAMESEG_SIZE], const uint8_t revision,
562 const uint32_t oem_revision)
564 ACPI_TABLE_HEADER header_le;
565 /* + 1 is required for the null terminator */
566 char oem_table_id[ACPI_OEM_TABLE_ID_SIZE + 1];
568 assert(table != NULL);
569 assert(table->len == 0);
571 memcpy(header_le.Signature, signature, ACPI_NAMESEG_SIZE);
572 header_le.Length = 0; /* patched by basl_finish */
573 header_le.Revision = revision;
574 header_le.Checksum = 0; /* patched by basl_finish */
575 memcpy(header_le.OemId, "BHYVE ", ACPI_OEM_ID_SIZE);
576 snprintf(oem_table_id, ACPI_OEM_TABLE_ID_SIZE, "BV%.4s ", signature);
577 memcpy(header_le.OemTableId, oem_table_id,
578 sizeof(header_le.OemTableId));
579 header_le.OemRevision = htole32(oem_revision);
580 memcpy(header_le.AslCompilerId, "BASL", ACPI_NAMESEG_SIZE);
581 header_le.AslCompilerRevision = htole32(0x20220504);
584 basl_table_append_bytes(table, &header_le, sizeof(header_le)));
586 BASL_EXEC(basl_table_add_length(table,
587 offsetof(ACPI_TABLE_HEADER, Length), sizeof(header_le.Length)));
588 BASL_EXEC(basl_table_add_checksum(table,
589 offsetof(ACPI_TABLE_HEADER, Checksum), 0,
590 BASL_TABLE_CHECKSUM_LEN_FULL_TABLE));
596 basl_table_append_int(struct basl_table *const table, const uint64_t val,
601 assert(size <= sizeof(val));
603 basl_le_enc(buf, val, size);
604 return (basl_table_append_bytes(table, buf, size));
608 basl_table_append_length(struct basl_table *const table, const uint8_t size)
610 assert(table != NULL);
611 assert(size <= sizeof(table->len));
613 BASL_EXEC(basl_table_add_length(table, table->len, size));
614 BASL_EXEC(basl_table_append_int(table, 0, size));
620 basl_table_append_pointer(struct basl_table *const table,
621 const uint8_t src_signature[ACPI_NAMESEG_SIZE], const uint8_t size)
623 assert(table != NULL);
624 assert(size == 4 || size == 8);
626 BASL_EXEC(basl_table_add_pointer(table, src_signature, table->len, size));
627 BASL_EXEC(basl_table_append_int(table, 0, size));
633 basl_table_create(struct basl_table **const table, struct vmctx *ctx,
634 const uint8_t *const name, const uint32_t alignment)
636 struct basl_table *new_table;
638 assert(table != NULL);
640 new_table = calloc(1, sizeof(struct basl_table));
641 if (new_table == NULL) {
642 warnx("%s: failed to allocate table", __func__);
646 new_table->ctx = ctx;
648 snprintf(new_table->fwcfg_name, sizeof(new_table->fwcfg_name),
649 "etc/acpi/%s", name);
651 new_table->alignment = alignment;
653 STAILQ_INIT(&new_table->checksums);
654 STAILQ_INIT(&new_table->lengths);
655 STAILQ_INIT(&new_table->pointers);
657 STAILQ_INSERT_TAIL(&basl_tables, new_table, chain);
665 basl_table_register_to_rsdt(struct basl_table *table)
667 const ACPI_TABLE_HEADER *header;
669 assert(table != NULL);
671 header = (const ACPI_TABLE_HEADER *)table->data;
673 BASL_EXEC(basl_table_append_pointer(rsdt, header->Signature,
674 ACPI_RSDT_ENTRY_SIZE));
675 BASL_EXEC(basl_table_append_pointer(xsdt, header->Signature,
676 ACPI_XSDT_ENTRY_SIZE));