*gpe->sts = *gpe->sts | ACPI_CPU_HOTPLUG_STATUS;
cpu_id = k->get_arch_id(CPU(cpu));
+ g_assert((cpu_id / 8) < ACPI_GPE_PROC_LEN);
g->sts[cpu_id / 8] |= (1 << (cpu_id % 8));
}
#include "qom/qom-qobject.h"
typedef struct AcpiCpuInfo {
- DECLARE_BITMAP(found_cpus, MAX_CPUMASK_BITS + 1);
+ DECLARE_BITMAP(found_cpus, ACPI_CPU_HOTPLUG_ID_LIMIT);
} AcpiCpuInfo;
typedef struct AcpiMcfgInfo {
if (object_dynamic_cast(o, TYPE_CPU)) {
apic_id = object_property_get_int(o, "apic-id", NULL);
- assert(apic_id <= MAX_CPUMASK_BITS);
+ assert(apic_id < ACPI_CPU_HOTPLUG_ID_LIMIT);
set_bit(apic_id, cpu->found_cpus);
}
static void
build_header(GArray *linker, GArray *table_data,
- AcpiTableHeader *h, uint32_t sig, int len, uint8_t rev)
+ AcpiTableHeader *h, const char *sig, int len, uint8_t rev)
{
- h->signature = cpu_to_le32(sig);
+ memcpy(&h->signature, sig, 4);
h->length = cpu_to_le32(len);
h->revision = rev;
memcpy(h->oem_id, ACPI_BUILD_APPNAME6, 6);
memcpy(h->oem_table_id, ACPI_BUILD_APPNAME4, 4);
- memcpy(h->oem_table_id + 4, (void *)&sig, 4);
+ memcpy(h->oem_table_id + 4, sig, 4);
h->oem_revision = cpu_to_le32(1);
memcpy(h->asl_compiler_id, ACPI_BUILD_APPNAME4, 4);
h->asl_compiler_revision = cpu_to_le32(1);
build_facs(GArray *table_data, GArray *linker, PcGuestInfo *guest_info)
{
AcpiFacsDescriptorRev1 *facs = acpi_data_push(table_data, sizeof *facs);
- facs->signature = cpu_to_le32(ACPI_FACS_SIGNATURE);
+ memcpy(&facs->signature, "FACS", 4);
facs->length = cpu_to_le32(sizeof(*facs));
}
fadt_setup(fadt, pm);
build_header(linker, table_data,
- (void *)fadt, ACPI_FACP_SIGNATURE, sizeof(*fadt), 1);
+ (void *)fadt, "FACP", sizeof(*fadt), 1);
}
static void
local_nmi->lint = 1; /* ACPI_LINT1 */
build_header(linker, table_data,
- (void *)(table_data->data + madt_start), ACPI_APIC_SIGNATURE,
+ (void *)(table_data->data + madt_start), "APIC",
table_data->len - madt_start, 1);
}
AcpiCpuInfo *cpu, AcpiPmInfo *pm, AcpiMiscInfo *misc,
PcPciInfo *pci, PcGuestInfo *guest_info)
{
- int acpi_cpus = MIN(0xff, guest_info->apic_id_limit);
+ unsigned acpi_cpus = guest_info->apic_id_limit;
int ssdt_start = table_data->len;
uint8_t *ssdt_ptr;
int i;
+ /* The current AML generator can cover the APIC ID range [0..255],
+ * inclusive, for VCPU hotplug. */
+ QEMU_BUILD_BUG_ON(ACPI_CPU_HOTPLUG_ID_LIMIT > 256);
+ g_assert(acpi_cpus <= ACPI_CPU_HOTPLUG_ID_LIMIT);
+
/* Copy header and patch values in the S3_ / S4_ / S5_ packages */
ssdt_ptr = acpi_data_push(table_data, sizeof(ssdp_misc_aml));
memcpy(ssdt_ptr, ssdp_misc_aml, sizeof(ssdp_misc_aml));
patch_pci_windows(pci, ssdt_ptr, sizeof(ssdp_misc_aml));
- *(uint16_t *)(ssdt_ptr + *ssdt_isa_pest) =
- cpu_to_le16(misc->pvpanic_port);
+ ACPI_BUILD_SET_LE(ssdt_ptr, sizeof(ssdp_misc_aml),
+ ssdt_isa_pest[0], 16, misc->pvpanic_port);
{
GArray *sb_scope = build_alloc_array();
{
GArray *package = build_alloc_array();
- uint8_t op = 0x12; /* PackageOp */
+ uint8_t op = 0x13; /* VarPackageOp */
- build_append_byte(package, acpi_cpus); /* NumElements */
+ build_append_int(package, acpi_cpus); /* VarNumElements */
for (i = 0; i < acpi_cpus; i++) {
uint8_t b = test_bit(i, cpu->found_cpus) ? 0x01 : 0x00;
build_append_byte(package, b);
build_header(linker, table_data,
(void *)(table_data->data + ssdt_start),
- ACPI_SSDT_SIGNATURE, table_data->len - ssdt_start, 1);
+ "SSDT", table_data->len - ssdt_start, 1);
}
static void
hpet->timer_block_id = cpu_to_le32(0x8086a201);
hpet->addr.address = cpu_to_le64(HPET_BASE);
build_header(linker, table_data,
- (void *)hpet, ACPI_HPET_SIGNATURE, sizeof(*hpet), 1);
+ (void *)hpet, "HPET", sizeof(*hpet), 1);
}
static void
build_header(linker, table_data,
(void *)(table_data->data + srat_start),
- ACPI_SRAT_SIGNATURE,
+ "SRAT",
table_data->len - srat_start, 1);
}
build_mcfg_q35(GArray *table_data, GArray *linker, AcpiMcfgInfo *info)
{
AcpiTableMcfg *mcfg;
- uint32_t sig;
+ const char *sig;
int len = sizeof(*mcfg) + 1 * sizeof(mcfg->allocation[0]);
mcfg = acpi_data_push(table_data, len);
* ACPI spec requires OSPMs to ignore such tables.
*/
if (info->mcfg_base == PCIE_BASE_ADDR_UNMAPPED) {
- sig = ACPI_RSRV_SIGNATURE;
+ /* Reserved signature: ignored by OSPM */
+ sig = "QEMU";
} else {
- sig = ACPI_MCFG_SIGNATURE;
+ sig = "MCFG";
}
build_header(linker, table_data, (void *)mcfg, sig, len, 1);
}
memcpy(dsdt, misc->dsdt_code, misc->dsdt_size);
memset(dsdt, 0, sizeof *dsdt);
- build_header(linker, table_data, dsdt, ACPI_DSDT_SIGNATURE,
+ build_header(linker, table_data, dsdt, "DSDT",
misc->dsdt_size, 1);
}
sizeof(uint32_t));
}
build_header(linker, table_data,
- (void *)rsdt, ACPI_RSDT_SIGNATURE, rsdt_len, 1);
+ (void *)rsdt, "RSDT", rsdt_len, 1);
}
static GArray *
bios_linker_loader_alloc(linker, ACPI_BUILD_RSDP_FILE, 1,
true /* fseg memory */);
- rsdp->signature = cpu_to_le64(ACPI_RSDP_SIGNATURE);
+ memcpy(&rsdp->signature, "RSD PTR ", 8);
memcpy(rsdp->oem_id, ACPI_BUILD_APPNAME6, 6);
rsdp->rsdt_physical_address = cpu_to_le32(rsdt);
/* Address to be filled by Guest linker */
} QEMU_PACKED;
typedef struct Acpi20GenericAddress Acpi20GenericAddress;
-#define ACPI_RSDP_SIGNATURE 0x2052545020445352LL // "RSD PTR "
-
struct AcpiRsdpDescriptor { /* Root System Descriptor Pointer */
uint64_t signature; /* ACPI signature, contains "RSD PTR " */
uint8_t checksum; /* To make sum of struct == 0 */
/*
* ACPI 1.0 Fixed ACPI Description Table (FADT)
*/
-#define ACPI_FACP_SIGNATURE 0x50434146 // FACP
struct AcpiFadtDescriptorRev1
{
ACPI_TABLE_HEADER_DEF /* ACPI common table header */
/*
* ACPI 1.0 Root System Description Table (RSDT)
*/
-#define ACPI_RSDT_SIGNATURE 0x54445352 // RSDT
struct AcpiRsdtDescriptorRev1
{
ACPI_TABLE_HEADER_DEF /* ACPI common table header */
/*
* ACPI 1.0 Firmware ACPI Control Structure (FACS)
*/
-#define ACPI_FACS_SIGNATURE 0x53434146 // FACS
struct AcpiFacsDescriptorRev1
{
uint32_t signature; /* ACPI Signature */
/*
* Differentiated System Description Table (DSDT)
*/
-#define ACPI_DSDT_SIGNATURE 0x54445344 // DSDT
/*
* MADT values and structures
/* Master MADT */
-#define ACPI_APIC_SIGNATURE 0x43495041 // APIC
struct AcpiMultipleApicTable
{
ACPI_TABLE_HEADER_DEF /* ACPI common table header */
/*
* HPET Description Table
*/
-#define ACPI_HPET_SIGNATURE 0x54455048 // HPET
struct Acpi20Hpet {
ACPI_TABLE_HEADER_DEF /* ACPI common table header */
uint32_t timer_block_id;
* SRAT (NUMA topology description) table
*/
-#define ACPI_SRAT_SIGNATURE 0x54415253 // SRAT
struct AcpiSystemResourceAffinityTable
{
ACPI_TABLE_HEADER_DEF
} QEMU_PACKED;
typedef struct AcpiMcfgAllocation AcpiMcfgAllocation;
-#define ACPI_MCFG_SIGNATURE 0x4746434d // MCFG
-
-/* Reserved signature: ignored by OSPM */
-#define ACPI_RSRV_SIGNATURE 0x554d4551 // QEMU
-
struct AcpiTableMcfg {
ACPI_TABLE_HEADER_DEF;
uint8_t reserved[8];
#include "qemu/bitmap.h"
#include "qemu/config-file.h"
#include "hw/acpi/acpi.h"
+#include "hw/acpi/cpu_hotplug.h"
#include "hw/cpu/icc_bus.h"
#include "hw/boards.h"
#include "hw/pci/pci_host.h"
return;
}
+ if (apic_id >= ACPI_CPU_HOTPLUG_ID_LIMIT) {
+ error_setg(errp, "Unable to add CPU: %" PRIi64
+ ", resulting APIC ID (%" PRIi64 ") is too large",
+ id, apic_id);
+ return;
+ }
+
icc_bridge = DEVICE(object_resolve_path_type("icc-bridge",
TYPE_ICC_BRIDGE, NULL));
pc_new_cpu(current_cpu_model, apic_id, icc_bridge, errp);
int i;
X86CPU *cpu = NULL;
Error *error = NULL;
+ unsigned long apic_id_limit;
/* init CPUs */
if (cpu_model == NULL) {
}
current_cpu_model = cpu_model;
+ apic_id_limit = pc_apic_id_limit(max_cpus);
+ if (apic_id_limit > ACPI_CPU_HOTPLUG_ID_LIMIT) {
+ error_report("max_cpus is too large. APIC ID of last CPU is %lu",
+ apic_id_limit - 1);
+ exit(1);
+ }
+
for (i = 0; i < smp_cpus; i++) {
cpu = pc_new_cpu(cpu_model, x86_cpu_apic_id_from_index(i),
icc_bridge, &error);
* between C and ASL code.
*/
#define ACPI_CPU_HOTPLUG_STATUS 4
+
+/* Limit for CPU arch IDs for CPU hotplug. All hotpluggable CPUs should
+ * have CPUClass.get_arch_id() < ACPI_CPU_HOTPLUG_ID_LIMIT.
+ */
+#define ACPI_CPU_HOTPLUG_ID_LIMIT 256
+
+/* 256 CPU IDs, 8 bits per entry: */
#define ACPI_GPE_PROC_LEN 32
+
#define ICH9_CPU_HOTPLUG_IO_BASE 0x0CD8
#define PIIX4_CPU_HOTPLUG_IO_BASE 0xaf00
extern QEMUClockType rtc_clock;
#define MAX_NODES 64
+
+/* The following shall be true for all CPUs:
+ * cpu->cpu_index < max_cpus <= MAX_CPUMASK_BITS
+ *
+ * Note that cpu->get_arch_id() may be larger than MAX_CPUMASK_BITS.
+ */
#define MAX_CPUMASK_BITS 255
+
extern int nb_numa_nodes;
extern uint64_t node_mem[MAX_NODES];
extern unsigned long *node_cpumask[MAX_NODES];
#define MACHINE_Q35 "q35"
#define ACPI_REBUILD_EXPECTED_AML "TEST_ACPI_REBUILD_AML"
-#define ACPI_SSDT_SIGNATURE 0x54445353 /* SSDT */
/* DSDT and SSDTs format */
typedef struct {
ACPI_READ_FIELD((table)->asl_compiler_revision, addr); \
} while (0);
+#define ACPI_ASSERT_CMP(actual, expected) do { \
+ uint32_t ACPI_ASSERT_CMP_le = cpu_to_le32(actual); \
+ char ACPI_ASSERT_CMP_str[5] = {}; \
+ memcpy(ACPI_ASSERT_CMP_str, &ACPI_ASSERT_CMP_le, 4); \
+ g_assert_cmpstr(ACPI_ASSERT_CMP_str, ==, expected); \
+} while (0)
+
+#define ACPI_ASSERT_CMP64(actual, expected) do { \
+ uint64_t ACPI_ASSERT_CMP_le = cpu_to_le64(actual); \
+ char ACPI_ASSERT_CMP_str[9] = {}; \
+ memcpy(ACPI_ASSERT_CMP_str, &ACPI_ASSERT_CMP_le, 8); \
+ g_assert_cmpstr(ACPI_ASSERT_CMP_str, ==, expected); \
+} while (0)
+
/* Boot sector code: write SIGNATURE into memory,
* then halt.
* Q35 machine requires a minimum 0x7e000 bytes disk.
uint32_t addr = data->rsdp_addr;
ACPI_READ_FIELD(rsdp_table->signature, addr);
- g_assert_cmphex(rsdp_table->signature, ==, ACPI_RSDP_SIGNATURE);
+ ACPI_ASSERT_CMP64(rsdp_table->signature, "RSD PTR ");
ACPI_READ_FIELD(rsdp_table->checksum, addr);
ACPI_READ_ARRAY(rsdp_table->oem_id, addr);
/* read the header */
ACPI_READ_TABLE_HEADER(rsdt_table, addr);
- g_assert_cmphex(rsdt_table->signature, ==, ACPI_RSDT_SIGNATURE);
+ ACPI_ASSERT_CMP(rsdt_table->signature, "RSDT");
/* compute the table entries in rsdt */
tables_nr = (rsdt_table->length - sizeof(AcpiRsdtDescriptorRev1)) /
ACPI_READ_FIELD(fadt_table->reserved4b, addr);
ACPI_READ_FIELD(fadt_table->flags, addr);
- g_assert_cmphex(fadt_table->signature, ==, ACPI_FACP_SIGNATURE);
+ ACPI_ASSERT_CMP(fadt_table->signature, "FACP");
g_assert(!acpi_checksum((uint8_t *)fadt_table, fadt_table->length));
}
ACPI_READ_FIELD(facs_table->flags, addr);
ACPI_READ_ARRAY(facs_table->resverved3, addr);
- g_assert_cmphex(facs_table->signature, ==, ACPI_FACS_SIGNATURE);
+ ACPI_ASSERT_CMP(facs_table->signature, "FACS");
}
static void test_dst_table(AcpiSdtTable *sdt_table, uint32_t addr)
data->tables = g_array_new(false, true, sizeof(AcpiSdtTable));
test_dst_table(&dsdt_table, addr);
- g_assert_cmphex(dsdt_table.header.signature, ==, ACPI_DSDT_SIGNATURE);
+ ACPI_ASSERT_CMP(dsdt_table.header.signature, "DSDT");
/* Place DSDT first */
g_array_append_val(data->tables, dsdt_table);
g_assert(sdt->aml);
if (rebuild) {
+ uint32_t signature = cpu_to_le32(sdt->header.signature);
aml_file = g_strdup_printf("%s/%s/%.4s", data_dir, data->machine,
- (gchar *)&sdt->header.signature);
+ (gchar *)&signature);
fd = g_open(aml_file, O_WRONLY|O_TRUNC|O_CREAT,
S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH);
} else {
}
}
-static bool compare_signature(AcpiSdtTable *sdt, uint32_t signature)
+static bool compare_signature(AcpiSdtTable *sdt, const char *signature)
{
- return sdt->header.signature == signature;
+ return !memcmp(&sdt->header.signature, signature, 4);
}
static bool load_asl(GArray *sdts, AcpiSdtTable *sdt)
/* build command line */
g_string_append_printf(command_line, " -p %s ", sdt->asl_file);
- if (compare_signature(sdt, ACPI_DSDT_SIGNATURE) ||
- compare_signature(sdt, ACPI_SSDT_SIGNATURE)) {
+ if (compare_signature(sdt, "DSDT") ||
+ compare_signature(sdt, "SSDT")) {
for (i = 0; i < sdts->len; ++i) {
temp = &g_array_index(sdts, AcpiSdtTable, i);
- if (compare_signature(temp, ACPI_DSDT_SIGNATURE) ||
- compare_signature(temp, ACPI_SSDT_SIGNATURE)) {
+ if (compare_signature(temp, "DSDT") ||
+ compare_signature(temp, "SSDT")) {
g_string_append_printf(command_line, "-e %s ", temp->aml_file);
}
}
/* pass 'out' and 'out_err' in order to be redirected */
ret = g_spawn_command_line_sync(command_line->str, &out, &out_err, NULL, &error);
g_assert_no_error(error);
-
if (ret) {
ret = g_file_get_contents(sdt->asl_file, (gchar **)&sdt->asl,
&sdt->asl_len, &error);
g_assert(ret);
g_assert_no_error(error);
- g_assert(sdt->asl_len);
+ ret = (sdt->asl_len > 0);
}
g_free(out);
GArray *exp_tables = g_array_new(false, true, sizeof(AcpiSdtTable));
for (i = 0; i < data->tables->len; ++i) {
AcpiSdtTable exp_sdt;
+ uint32_t signature;
+
sdt = &g_array_index(data->tables, AcpiSdtTable, i);
memset(&exp_sdt, 0, sizeof(exp_sdt));
exp_sdt.header.signature = sdt->header.signature;
+ signature = cpu_to_le32(sdt->header.signature);
aml_file = g_strdup_printf("%s/%s/%.4s", data_dir, data->machine,
- (gchar *)&exp_sdt.header.signature);
+ (gchar *)&signature);
exp_sdt.aml_file = aml_file;
g_assert(g_file_test(aml_file, G_FILE_TEST_EXISTS));
ret = g_file_get_contents(aml_file, &exp_sdt.aml,
g_assert(!err || exp_err);
if (g_strcmp0(asl->str, exp_asl->str)) {
- sdt->tmp_files_retain = true;
- exp_sdt->tmp_files_retain = true;
- fprintf(stderr,
- "acpi-test: Warning! %.4s mismatch. "
- "Actual [asl:%s, aml:%s], Expected [asl:%s, aml:%s].\n",
- (gchar *)&exp_sdt->header.signature,
- sdt->asl_file, sdt->aml_file,
- exp_sdt->asl_file, exp_sdt->aml_file);
+ if (exp_err) {
+ fprintf(stderr,
+ "Warning! iasl couldn't parse the expected aml\n");
+ } else {
+ uint32_t signature = cpu_to_le32(exp_sdt->header.signature);
+ sdt->tmp_files_retain = true;
+ exp_sdt->tmp_files_retain = true;
+ fprintf(stderr,
+ "acpi-test: Warning! %.4s mismatch. "
+ "Actual [asl:%s, aml:%s], Expected [asl:%s, aml:%s].\n",
+ (gchar *)&signature,
+ sdt->asl_file, sdt->aml_file,
+ exp_sdt->asl_file, exp_sdt->aml_file);
+ }
}
g_string_free(asl, true);
g_string_free(exp_asl, true);
max_cpus = smp_cpus;
}
- if (max_cpus > 255) {
+ if (max_cpus > MAX_CPUMASK_BITS) {
fprintf(stderr, "Unsupported number of maxcpus\n");
exit(1);
}
projects / sdk / emulator / qemu.git / commitdiff