diff --git a/usr.sbin/bhyve/acpi_device.c b/usr.sbin/bhyve/acpi_device.c
index 51603e138fba..e37fc50b8c91 100644
--- a/usr.sbin/bhyve/acpi_device.c
+++ b/usr.sbin/bhyve/acpi_device.c
@@ -1,202 +1,213 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright (c) 2021 Beckhoff Automation GmbH & Co. KG
* Author: Corvin Köhne <c.koehne@beckhoff.com>
*/
#include <sys/param.h>
#include <sys/queue.h>
#include <machine/vmm.h>
#include <assert.h>
#include <err.h>
#include <errno.h>
#include <vmmapi.h>
#include "acpi.h"
#include "acpi_device.h"
#include "basl.h"
/**
* List entry to enumerate all resources used by an ACPI device.
*
* @param chain Used to chain multiple elements together.
* @param type Type of the ACPI resource.
* @param data Data of the ACPI resource.
*/
struct acpi_resource_list_entry {
SLIST_ENTRY(acpi_resource_list_entry) chain;
UINT32 type;
ACPI_RESOURCE_DATA data;
};
/**
* Holds information about an ACPI device.
*
* @param vm_ctx VM context the ACPI device was created in.
+ * @param softc A pointer to the software context of the ACPI device.
* @param emul Device emulation struct. It contains some information like the
name of the ACPI device and some device specific functions.
* @param crs Current resources used by the ACPI device.
*/
struct acpi_device {
struct vmctx *vm_ctx;
+ void *softc;
const struct acpi_device_emul *emul;
SLIST_HEAD(acpi_resource_list, acpi_resource_list_entry) crs;
};
int
-acpi_device_create(struct acpi_device **const new_dev,
+acpi_device_create(struct acpi_device **const new_dev, void *const softc,
struct vmctx *const vm_ctx, const struct acpi_device_emul *const emul)
{
assert(new_dev != NULL);
assert(vm_ctx != NULL);
assert(emul != NULL);
struct acpi_device *const dev = calloc(1, sizeof(*dev));
if (dev == NULL) {
return (ENOMEM);
}
dev->vm_ctx = vm_ctx;
+ dev->softc = softc;
dev->emul = emul;
SLIST_INIT(&dev->crs);
const int error = acpi_tables_add_device(dev);
if (error) {
acpi_device_destroy(dev);
return (error);
}
*new_dev = dev;
return (0);
}
void
acpi_device_destroy(struct acpi_device *const dev)
{
if (dev == NULL) {
return;
}
struct acpi_resource_list_entry *res;
while (!SLIST_EMPTY(&dev->crs)) {
res = SLIST_FIRST(&dev->crs);
SLIST_REMOVE_HEAD(&dev->crs, chain);
free(res);
}
free(dev);
}
int
acpi_device_add_res_fixed_ioport(struct acpi_device *const dev,
const UINT16 port, const UINT8 length)
{
if (dev == NULL) {
return (EINVAL);
}
struct acpi_resource_list_entry *const res = calloc(1, sizeof(*res));
if (res == NULL) {
return (ENOMEM);
}
res->type = ACPI_RESOURCE_TYPE_FIXED_IO;
res->data.FixedIo.Address = port;
res->data.FixedIo.AddressLength = length;
SLIST_INSERT_HEAD(&dev->crs, res, chain);
return (0);
}
int
acpi_device_add_res_fixed_memory32(struct acpi_device *const dev,
const UINT8 write_protected, const UINT32 address, const UINT32 length)
{
if (dev == NULL) {
return (EINVAL);
}
struct acpi_resource_list_entry *const res = calloc(1, sizeof(*res));
if (res == NULL) {
return (ENOMEM);
}
res->type = ACPI_RESOURCE_TYPE_FIXED_MEMORY32;
res->data.FixedMemory32.WriteProtect = write_protected;
res->data.FixedMemory32.Address = address;
res->data.FixedMemory32.AddressLength = length;
SLIST_INSERT_HEAD(&dev->crs, res, chain);
return (0);
}
+void *
+acpi_device_get_softc(const struct acpi_device *const dev)
+{
+ assert(dev != NULL);
+
+ return (dev->softc);
+}
+
int
acpi_device_build_table(const struct acpi_device *const dev)
{
assert(dev != NULL);
assert(dev->emul != NULL);
if (dev->emul->build_table != NULL) {
return (dev->emul->build_table(dev));
}
return (0);
}
static int
acpi_device_write_dsdt_crs(const struct acpi_device *const dev)
{
const struct acpi_resource_list_entry *res;
SLIST_FOREACH(res, &dev->crs, chain) {
switch (res->type) {
case ACPI_RESOURCE_TYPE_FIXED_IO:
dsdt_fixed_ioport(res->data.FixedIo.Address,
res->data.FixedIo.AddressLength);
break;
case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
dsdt_fixed_mem32(res->data.FixedMemory32.Address,
res->data.FixedMemory32.AddressLength);
break;
default:
assert(0);
break;
}
}
return (0);
}
int
acpi_device_write_dsdt(const struct acpi_device *const dev)
{
assert(dev != NULL);
dsdt_line("");
dsdt_line(" Scope (\\_SB)");
dsdt_line(" {");
dsdt_line(" Device (%s)", dev->emul->name);
dsdt_line(" {");
dsdt_line(" Name (_HID, \"%s\")", dev->emul->hid);
dsdt_line(" Name (_STA, 0x0F)");
dsdt_line(" Name (_CRS, ResourceTemplate ()");
dsdt_line(" {");
dsdt_indent(4);
BASL_EXEC(acpi_device_write_dsdt_crs(dev));
dsdt_unindent(4);
dsdt_line(" })");
if (dev->emul->write_dsdt != NULL) {
dsdt_indent(3);
BASL_EXEC(dev->emul->write_dsdt(dev));
dsdt_unindent(3);
}
dsdt_line(" }");
dsdt_line(" }");
return (0);
}
diff --git a/usr.sbin/bhyve/acpi_device.h b/usr.sbin/bhyve/acpi_device.h
index 4d734b422ec5..32e299f2da86 100644
--- a/usr.sbin/bhyve/acpi_device.h
+++ b/usr.sbin/bhyve/acpi_device.h
@@ -1,56 +1,59 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright (c) 2021 Beckhoff Automation GmbH & Co. KG
* Author: Corvin Köhne <c.koehne@beckhoff.com>
*/
#pragma once
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#include <contrib/dev/acpica/include/acpi.h>
#pragma GCC diagnostic pop
struct vmctx;
struct acpi_device;
/**
* Device specific information and emulation.
*
* @param name Used as device name in the DSDT.
* @param hid Used as _HID in the DSDT.
* @param build_table Called to build a device specific ACPI table like the TPM2
* table.
* @param write_dsdt Called to append the DSDT with device specific
* information.
*/
struct acpi_device_emul {
const char *name;
const char *hid;
int (*build_table)(const struct acpi_device *dev);
int (*write_dsdt)(const struct acpi_device *dev);
};
/**
* Creates an ACPI device.
*
* @param[out] new_dev Returns the newly create ACPI device.
+ * @param[in] softc Pointer to the software context of the ACPI device.
* @param[in] vm_ctx VM context the ACPI device is created in.
* @param[in] emul Device emulation struct. It contains some information
* like the name of the ACPI device and some device specific
* functions.
*/
-int acpi_device_create(struct acpi_device **new_dev, struct vmctx *vm_ctx,
- const struct acpi_device_emul *emul);
+int acpi_device_create(struct acpi_device **new_dev, void *softc,
+ struct vmctx *vm_ctx, const struct acpi_device_emul *emul);
void acpi_device_destroy(struct acpi_device *dev);
int acpi_device_add_res_fixed_ioport(struct acpi_device *dev, UINT16 port,
UINT8 length);
int acpi_device_add_res_fixed_memory32(struct acpi_device *dev,
UINT8 write_protected, UINT32 address, UINT32 length);
+void *acpi_device_get_softc(const struct acpi_device *dev);
+
int acpi_device_build_table(const struct acpi_device *dev);
int acpi_device_write_dsdt(const struct acpi_device *dev);
diff --git a/usr.sbin/bhyve/qemu_fwcfg.c b/usr.sbin/bhyve/qemu_fwcfg.c
index e35d63d09795..e76ff3620586 100644
--- a/usr.sbin/bhyve/qemu_fwcfg.c
+++ b/usr.sbin/bhyve/qemu_fwcfg.c
@@ -1,445 +1,445 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright (c) 2021 Beckhoff Automation GmbH & Co. KG
* Author: Corvin Köhne <c.koehne@beckhoff.com>
*/
#include <sys/param.h>
#include <sys/endian.h>
#include <machine/vmm.h>
#include <err.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "acpi_device.h"
#include "bhyverun.h"
#include "inout.h"
#include "pci_lpc.h"
#include "qemu_fwcfg.h"
#define QEMU_FWCFG_ACPI_DEVICE_NAME "FWCF"
#define QEMU_FWCFG_ACPI_HARDWARE_ID "QEMU0002"
#define QEMU_FWCFG_SELECTOR_PORT_NUMBER 0x510
#define QEMU_FWCFG_SELECTOR_PORT_SIZE 1
#define QEMU_FWCFG_SELECTOR_PORT_FLAGS IOPORT_F_INOUT
#define QEMU_FWCFG_DATA_PORT_NUMBER 0x511
#define QEMU_FWCFG_DATA_PORT_SIZE 1
#define QEMU_FWCFG_DATA_PORT_FLAGS \
IOPORT_F_INOUT /* QEMU v2.4+ ignores writes */
#define QEMU_FWCFG_ARCHITECTURE_MASK 0x0001
#define QEMU_FWCFG_INDEX_MASK 0x3FFF
#define QEMU_FWCFG_SELECT_READ 0
#define QEMU_FWCFG_SELECT_WRITE 1
#define QEMU_FWCFG_ARCHITECTURE_GENERIC 0
#define QEMU_FWCFG_ARCHITECTURE_SPECIFIC 1
#define QEMU_FWCFG_INDEX_SIGNATURE 0x00
#define QEMU_FWCFG_INDEX_ID 0x01
#define QEMU_FWCFG_INDEX_NB_CPUS 0x05
#define QEMU_FWCFG_INDEX_FILE_DIR 0x19
#define QEMU_FWCFG_FIRST_FILE_INDEX 0x20
#define QEMU_FWCFG_MIN_FILES 10
#pragma pack(1)
union qemu_fwcfg_selector {
struct {
uint16_t index : 14;
uint16_t writeable : 1;
uint16_t architecture : 1;
};
uint16_t bits;
};
struct qemu_fwcfg_signature {
uint8_t signature[4];
};
struct qemu_fwcfg_id {
uint32_t interface : 1; /* always set */
uint32_t DMA : 1;
uint32_t reserved : 30;
};
struct qemu_fwcfg_file {
uint32_t be_size;
uint16_t be_selector;
uint16_t reserved;
uint8_t name[QEMU_FWCFG_MAX_NAME];
};
struct qemu_fwcfg_directory {
uint32_t be_count;
struct qemu_fwcfg_file files[0];
};
#pragma pack()
struct qemu_fwcfg_softc {
struct acpi_device *acpi_dev;
uint32_t data_offset;
union qemu_fwcfg_selector selector;
struct qemu_fwcfg_item items[QEMU_FWCFG_MAX_ARCHS]
[QEMU_FWCFG_MAX_ENTRIES];
struct qemu_fwcfg_directory *directory;
};
static struct qemu_fwcfg_softc fwcfg_sc;
static int
qemu_fwcfg_selector_port_handler(struct vmctx *const ctx __unused, const int in,
const int port __unused, const int bytes, uint32_t *const eax,
void *const arg __unused)
{
if (bytes != sizeof(uint16_t)) {
warnx("%s: invalid size (%d) of IO port access", __func__,
bytes);
return (-1);
}
if (in) {
*eax = htole16(fwcfg_sc.selector.bits);
return (0);
}
fwcfg_sc.data_offset = 0;
fwcfg_sc.selector.bits = le16toh(*eax);
return (0);
}
static int
qemu_fwcfg_data_port_handler(struct vmctx *const ctx __unused, const int in,
const int port __unused, const int bytes, uint32_t *const eax,
void *const arg __unused)
{
if (bytes != sizeof(uint8_t)) {
warnx("%s: invalid size (%d) of IO port access", __func__,
bytes);
return (-1);
}
if (!in) {
warnx("%s: Writes to qemu fwcfg data port aren't allowed",
__func__);
return (-1);
}
/* get fwcfg item */
struct qemu_fwcfg_item *const item =
&fwcfg_sc.items[fwcfg_sc.selector.architecture]
[fwcfg_sc.selector.index];
if (item->data == NULL) {
warnx(
"%s: qemu fwcfg item doesn't exist (architecture %s index 0x%x)",
__func__,
fwcfg_sc.selector.architecture ? "specific" : "generic",
fwcfg_sc.selector.index);
*eax = 0x00;
return (0);
} else if (fwcfg_sc.data_offset >= item->size) {
warnx(
"%s: qemu fwcfg item read exceeds size (architecture %s index 0x%x size 0x%x offset 0x%x)",
__func__,
fwcfg_sc.selector.architecture ? "specific" : "generic",
fwcfg_sc.selector.index, item->size, fwcfg_sc.data_offset);
*eax = 0x00;
return (0);
}
/* return item data */
*eax = item->data[fwcfg_sc.data_offset];
fwcfg_sc.data_offset++;
return (0);
}
static int
qemu_fwcfg_add_item(const uint16_t architecture, const uint16_t index,
const uint32_t size, void *const data)
{
/* truncate architecture and index to their desired size */
const uint16_t arch = architecture & QEMU_FWCFG_ARCHITECTURE_MASK;
const uint16_t idx = index & QEMU_FWCFG_INDEX_MASK;
/* get pointer to item specified by selector */
struct qemu_fwcfg_item *const fwcfg_item = &fwcfg_sc.items[arch][idx];
/* check if item is already used */
if (fwcfg_item->data != NULL) {
warnx("%s: qemu fwcfg item exists (architecture %s index 0x%x)",
__func__, arch ? "specific" : "generic", idx);
return (EEXIST);
}
/* save data of the item */
fwcfg_item->size = size;
fwcfg_item->data = data;
return (0);
}
static int
qemu_fwcfg_add_item_file_dir(void)
{
const size_t size = sizeof(struct qemu_fwcfg_directory) +
QEMU_FWCFG_MIN_FILES * sizeof(struct qemu_fwcfg_file);
struct qemu_fwcfg_directory *const fwcfg_directory = calloc(1, size);
if (fwcfg_directory == NULL) {
return (ENOMEM);
}
fwcfg_sc.directory = fwcfg_directory;
return (qemu_fwcfg_add_item(QEMU_FWCFG_ARCHITECTURE_GENERIC,
QEMU_FWCFG_INDEX_FILE_DIR, sizeof(struct qemu_fwcfg_directory),
(uint8_t *)fwcfg_sc.directory));
}
static int
qemu_fwcfg_add_item_id(void)
{
struct qemu_fwcfg_id *const fwcfg_id = calloc(1,
sizeof(struct qemu_fwcfg_id));
if (fwcfg_id == NULL) {
return (ENOMEM);
}
fwcfg_id->interface = 1;
fwcfg_id->DMA = 0;
uint32_t *const le_fwcfg_id_ptr = (uint32_t *)fwcfg_id;
*le_fwcfg_id_ptr = htole32(*le_fwcfg_id_ptr);
return (qemu_fwcfg_add_item(QEMU_FWCFG_ARCHITECTURE_GENERIC,
QEMU_FWCFG_INDEX_ID, sizeof(struct qemu_fwcfg_id),
(uint8_t *)fwcfg_id));
}
static int
qemu_fwcfg_add_item_nb_cpus(void)
{
uint16_t *fwcfg_max_cpus = calloc(1, sizeof(uint16_t));
if (fwcfg_max_cpus == NULL) {
return (ENOMEM);
}
*fwcfg_max_cpus = htole16(guest_ncpus);
return (qemu_fwcfg_add_item(QEMU_FWCFG_ARCHITECTURE_GENERIC,
QEMU_FWCFG_INDEX_NB_CPUS, sizeof(uint16_t), fwcfg_max_cpus));
}
static int
qemu_fwcfg_add_item_signature(void)
{
struct qemu_fwcfg_signature *const fwcfg_signature = calloc(1,
sizeof(struct qemu_fwcfg_signature));
if (fwcfg_signature == NULL) {
return (ENOMEM);
}
fwcfg_signature->signature[0] = 'Q';
fwcfg_signature->signature[1] = 'E';
fwcfg_signature->signature[2] = 'M';
fwcfg_signature->signature[3] = 'U';
return (qemu_fwcfg_add_item(QEMU_FWCFG_ARCHITECTURE_GENERIC,
QEMU_FWCFG_INDEX_SIGNATURE, sizeof(struct qemu_fwcfg_signature),
(uint8_t *)fwcfg_signature));
}
static int
qemu_fwcfg_register_port(const char *const name, const int port, const int size,
const int flags, const inout_func_t handler)
{
struct inout_port iop;
bzero(&iop, sizeof(iop));
iop.name = name;
iop.port = port;
iop.size = size;
iop.flags = flags;
iop.handler = handler;
return (register_inout(&iop));
}
int
qemu_fwcfg_add_file(const uint8_t name[QEMU_FWCFG_MAX_NAME],
const uint32_t size, void *const data)
{
/*
* QEMU specifies count as big endian.
* Convert it to host endian to work with it.
*/
const uint32_t count = be32toh(fwcfg_sc.directory->be_count) + 1;
/* add file to items list */
const uint32_t index = QEMU_FWCFG_FIRST_FILE_INDEX + count - 1;
const int error = qemu_fwcfg_add_item(QEMU_FWCFG_ARCHITECTURE_GENERIC,
index, size, data);
if (error != 0) {
return (error);
}
/*
* files should be sorted alphabetical, get index for new file
*/
uint32_t file_index;
for (file_index = 0; file_index < count - 1; ++file_index) {
if (strcmp(name, fwcfg_sc.directory->files[file_index].name) <
0)
break;
}
if (count > QEMU_FWCFG_MIN_FILES) {
/* alloc new file directory */
const uint64_t new_size = sizeof(struct qemu_fwcfg_directory) +
count * sizeof(struct qemu_fwcfg_file);
struct qemu_fwcfg_directory *const new_directory = calloc(1,
new_size);
if (new_directory == NULL) {
warnx(
"%s: Unable to allocate a new qemu fwcfg files directory (count %d)",
__func__, count);
return (-ENOMEM);
}
/* copy files below file_index to new directory */
memcpy(new_directory->files, fwcfg_sc.directory->files,
file_index * sizeof(struct qemu_fwcfg_file));
/* copy files above file_index to directory */
memcpy(&new_directory->files[file_index + 1],
&fwcfg_sc.directory->files[file_index],
(count - file_index) * sizeof(struct qemu_fwcfg_file));
/* free old directory */
free(fwcfg_sc.directory);
/* set directory pointer to new directory */
fwcfg_sc.directory = new_directory;
/* adjust directory pointer */
fwcfg_sc.items[0][QEMU_FWCFG_INDEX_FILE_DIR].data =
(uint8_t *)fwcfg_sc.directory;
} else {
/* shift files behind file_index */
for (uint32_t i = QEMU_FWCFG_MIN_FILES - 1; i > file_index;
--i) {
memcpy(&fwcfg_sc.directory->files[i],
&fwcfg_sc.directory->files[i - 1],
sizeof(struct qemu_fwcfg_file));
}
}
/*
* QEMU specifies count, size and index as big endian.
* Save these values in big endian to simplify guest reads of these
* values.
*/
fwcfg_sc.directory->be_count = htobe32(count);
fwcfg_sc.directory->files[file_index].be_size = htobe32(size);
fwcfg_sc.directory->files[file_index].be_selector = htobe16(index);
strcpy(fwcfg_sc.directory->files[file_index].name, name);
/* set new size for the fwcfg_file_directory */
fwcfg_sc.items[0][QEMU_FWCFG_INDEX_FILE_DIR].size =
sizeof(struct qemu_fwcfg_directory) +
count * sizeof(struct qemu_fwcfg_file);
return (0);
}
static const struct acpi_device_emul qemu_fwcfg_acpi_device_emul = {
.name = QEMU_FWCFG_ACPI_DEVICE_NAME,
.hid = QEMU_FWCFG_ACPI_HARDWARE_ID,
};
int
qemu_fwcfg_init(struct vmctx *const ctx)
{
int error;
/*
* Bhyve supports fwctl (bhyve) and fwcfg (qemu) as firmware interfaces.
* Both are using the same ports. So, it's not possible to provide both
* interfaces at the same time to the guest. Therefore, only create acpi
* tables and register io ports for fwcfg, if it's used.
*/
if (strcmp(lpc_fwcfg(), "qemu") == 0) {
- error = acpi_device_create(&fwcfg_sc.acpi_dev, ctx,
+ error = acpi_device_create(&fwcfg_sc.acpi_dev, &fwcfg_sc, ctx,
&qemu_fwcfg_acpi_device_emul);
if (error) {
warnx("%s: failed to create ACPI device for QEMU FwCfg",
__func__);
goto done;
}
error = acpi_device_add_res_fixed_ioport(fwcfg_sc.acpi_dev,
QEMU_FWCFG_SELECTOR_PORT_NUMBER, 2);
if (error) {
warnx("%s: failed to add fixed IO port for QEMU FwCfg",
__func__);
goto done;
}
/* add handlers for fwcfg ports */
if ((error = qemu_fwcfg_register_port("qemu_fwcfg_selector",
QEMU_FWCFG_SELECTOR_PORT_NUMBER,
QEMU_FWCFG_SELECTOR_PORT_SIZE,
QEMU_FWCFG_SELECTOR_PORT_FLAGS,
qemu_fwcfg_selector_port_handler)) != 0) {
warnx(
"%s: Unable to register qemu fwcfg selector port 0x%x",
__func__, QEMU_FWCFG_SELECTOR_PORT_NUMBER);
goto done;
}
if ((error = qemu_fwcfg_register_port("qemu_fwcfg_data",
QEMU_FWCFG_DATA_PORT_NUMBER, QEMU_FWCFG_DATA_PORT_SIZE,
QEMU_FWCFG_DATA_PORT_FLAGS,
qemu_fwcfg_data_port_handler)) != 0) {
warnx(
"%s: Unable to register qemu fwcfg data port 0x%x",
__func__, QEMU_FWCFG_DATA_PORT_NUMBER);
goto done;
}
}
/* add common fwcfg items */
if ((error = qemu_fwcfg_add_item_signature()) != 0) {
warnx("%s: Unable to add signature item", __func__);
goto done;
}
if ((error = qemu_fwcfg_add_item_id()) != 0) {
warnx("%s: Unable to add id item", __func__);
goto done;
}
if ((error = qemu_fwcfg_add_item_nb_cpus()) != 0) {
warnx("%s: Unable to add nb_cpus item", __func__);
goto done;
}
if ((error = qemu_fwcfg_add_item_file_dir()) != 0) {
warnx("%s: Unable to add file_dir item", __func__);
goto done;
}
done:
if (error) {
acpi_device_destroy(fwcfg_sc.acpi_dev);
}
return (error);
}