Add an IPMI device to qemu

135 lines not on this page · raw message

215 lines not on this page · raw message

144 lines not on this page · raw message

index 56e1ed7..217d1e4 100644
@@ -38,7 +38,16 @@
 
 #define FW_CFG_FILE_FIRST       0x20
 #define FW_CFG_FILE_SLOTS       0x10
-#define FW_CFG_MAX_ENTRY        (FW_CFG_FILE_FIRST+FW_CFG_FILE_SLOTS)
+
+#define FW_CFG_IPMI_INTERFACE   0x30
+#define FW_CFG_IPMI_BASE_ADDR   0x31
+#define FW_CFG_IPMI_REG_SPACE   0x32
+#define FW_CFG_IPMI_REG_SPACING 0x33
+#define FW_CFG_IPMI_SLAVE_ADDR  0x34
+#define FW_CFG_IPMI_IRQ         0x35
+#define FW_CFG_IPMI_VERSION     0x36
+
+#define FW_CFG_MAX_ENTRY        (FW_CFG_IPMI_VERSION + 1)
 
 #define FW_CFG_WRITE_CHANNEL    0x4000
 #define FW_CFG_ARCH_LOCAL       0x8000

337 lines not on this page · raw message

374 lines not on this page · raw message

1,728 lines not on this page · raw message

457 lines not on this page · raw message

440 lines not on this page · raw message

294 lines not on this page · raw message

index b046517..f3e5e9e 100644
@@ -118,6 +118,23 @@ void ipmi_bmc_init(IPMIBmc *s, Error **errp)
     }
 }
 
+const VMStateDescription vmstate_IPMIInterface = {
+    .name = TYPE_IPMI_INTERFACE,
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .fields      = (VMStateField[]) {
+        VMSTATE_BOOL(obf_irq_set, IPMIInterface),
+        VMSTATE_BOOL(atn_irq_set, IPMIInterface),
+        VMSTATE_BOOL(use_irq, IPMIInterface),
+        VMSTATE_BOOL(irqs_enabled, IPMIInterface),
+        VMSTATE_UINT32(outpos, IPMIInterface),
+        VMSTATE_UINT32(outlen, IPMIInterface),
+        VMSTATE_VBUFFER_UINT32(inmsg, IPMIInterface, 1, NULL, 0, inlen),
+        VMSTATE_BOOL(write_end, IPMIInterface),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
 static TypeInfo ipmi_bmc_type_info = {
     .name = TYPE_IPMI_BMC,
     .parent = TYPE_OBJECT,

index 6b2a3e9..56cb423 100644
@@ -153,6 +153,8 @@ typedef struct IPMIInterfaceClass {
                        unsigned char *rsp, unsigned int rsp_len);
 } IPMIInterfaceClass;
 
+extern const VMStateDescription vmstate_IPMIInterface;
+
 void ipmi_interface_init(IPMIInterface *s, Error **errp);
 void ipmi_interface_reset(IPMIInterface *s);
 

index 95beb71..105b978 100644
@@ -335,6 +335,19 @@ static void ipmi_bt_handle_reset(IPMIInterface *s, bool is_cold)
     }
 }
 
+static const VMStateDescription vmstate_ipmi_bt = {
+    .name = TYPE_IPMI_INTERFACE_BT,
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .fields      = (VMStateField[]) {
+        VMSTATE_UINT8(control_reg, IPMIBtInterface),
+        VMSTATE_UINT8(mask_reg, IPMIBtInterface),
+        VMSTATE_UINT8(waiting_rsp, IPMIBtInterface),
+        VMSTATE_UINT8(waiting_seq, IPMIBtInterface),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
 static void ipmi_bt_init(IPMIInterface *s, Error **errp)
 {
     IPMIBtInterface *bt = IPMI_INTERFACE_BT(s);

@@ -345,6 +358,7 @@ static void ipmi_bt_init(IPMIInterface *s, Error **errp)
     s->io_length = 3;
 
     memory_region_init_io(&s->io, NULL, &ipmi_bt_io_ops, bt, "ipmi-bt", 3);
+    vmstate_register(NULL, 0, &vmstate_ipmi_bt, bt);
 }
 
 static void ipmi_bt_class_init(ObjectClass *klass, void *data)

60 lines not on this page · raw message

index 411799e..e3af39e 100644
@@ -299,6 +299,20 @@ static void ipmi_kcs_set_atn(IPMIInterface *s, int val, int irq)
     }
 }
 
+static const VMStateDescription vmstate_ipmi_kcs = {
+    .name = TYPE_IPMI_INTERFACE_KCS,
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .fields      = (VMStateField[]) {
+        VMSTATE_UINT8(status_reg, IPMIKcsInterface),
+        VMSTATE_UINT8(data_out_reg, IPMIKcsInterface),
+        VMSTATE_INT16(data_in_reg, IPMIKcsInterface),
+        VMSTATE_INT16(cmd_reg, IPMIKcsInterface),
+        VMSTATE_UINT8(waiting_rsp, IPMIKcsInterface),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
 static void ipmi_kcs_init(IPMIInterface *s, Error **errp)
 {
     IPMIKcsInterface *kcs = IPMI_INTERFACE_KCS(s);

@@ -309,6 +323,7 @@ static void ipmi_kcs_init(IPMIInterface *s, Error **errp)
     s->io_length = 2;
 
     memory_region_init_io(&s->io, NULL, &ipmi_kcs_io_ops, kcs, "ipmi-kcs", 2);
+    vmstate_register(NULL, 0, &vmstate_ipmi_kcs, kcs);
 }
 
 static void ipmi_kcs_class_init(ObjectClass *class, void *data)

index 8028f40..7480d00 100644
@@ -1657,6 +1657,34 @@ static const uint8_t init_sdrs[] = {
     0xff, 0xff, 0x00, 0x00, 0x00
 };
 
+static const VMStateDescription vmstate_ipmi_sim = {
+    .name = TYPE_IPMI_BMC_SIMULATOR,
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .fields      = (VMStateField[]) {
+        VMSTATE_UINT8(bmc_global_enables, IPMISimBmc),
+        VMSTATE_UINT8(msg_flags, IPMISimBmc),
+        VMSTATE_BOOL(watchdog_initialized, IPMISimBmc),
+        VMSTATE_UINT8(watchdog_use, IPMISimBmc),
+        VMSTATE_UINT8(watchdog_action, IPMISimBmc),
+        VMSTATE_UINT8(watchdog_pretimeout, IPMISimBmc),
+        VMSTATE_BOOL(watchdog_expired, IPMISimBmc),
+        VMSTATE_UINT16(watchdog_timeout, IPMISimBmc),
+        VMSTATE_BOOL(watchdog_running, IPMISimBmc),
+        VMSTATE_BOOL(watchdog_preaction_ran, IPMISimBmc),
+        VMSTATE_INT64(watchdog_expiry, IPMISimBmc),
+        VMSTATE_UINT8_ARRAY(evtbuf, IPMISimBmc, 16),
+        VMSTATE_UINT8(sensors[IPMI_WATCHDOG_SENSOR].status, IPMISimBmc),
+        VMSTATE_UINT8(sensors[IPMI_WATCHDOG_SENSOR].reading, IPMISimBmc),
+        VMSTATE_UINT16(sensors[IPMI_WATCHDOG_SENSOR].states, IPMISimBmc),
+        VMSTATE_UINT16(sensors[IPMI_WATCHDOG_SENSOR].assert_states, IPMISimBmc),
+        VMSTATE_UINT16(sensors[IPMI_WATCHDOG_SENSOR].deassert_states,
+                       IPMISimBmc),
+        VMSTATE_UINT16(sensors[IPMI_WATCHDOG_SENSOR].assert_enable, IPMISimBmc),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
 static void ipmi_sim_init(IPMIBmc *b, Error **errp)
 {
     unsigned int i;

@@ -1703,6 +1731,8 @@ static void ipmi_sim_init(IPMIBmc *b, Error **errp)
     register_cmds(ss);
 
     ss->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ipmi_timeout, ss);
+
+    vmstate_register(NULL, 0, &vmstate_ipmi_sim, ss);
 }
 
 static void ipmi_sim_class_init(ObjectClass *klass, void *data)

index 1c1ab8d..e62f744 100644
@@ -121,11 +121,23 @@ static Property ipmi_isa_properties[] = {
     DEFINE_PROP_END_OF_LIST(),
 };
 
+static const VMStateDescription vmstate_isa_ipmi = {
+    .name = TYPE_ISA_IPMI,
+    .version_id = 1,
+    .minimum_version_id = 1,
+    .fields      = (VMStateField[]) {
+        VMSTATE_STRUCT_POINTER(intf, ISAIPMIDevice, vmstate_IPMIInterface,
+                               IPMIInterface),
+        VMSTATE_END_OF_LIST()
+    }
+};
+
 static void ipmi_isa_class_initfn(ObjectClass *klass, void *data)
 {
     DeviceClass *dc = DEVICE_CLASS(klass);
     dc->realize = ipmi_isa_realizefn;
     dc->reset = ipmi_isa_reset;
+    dc->vmsd = &vmstate_isa_ipmi;
     dc->props = ipmi_isa_properties;
 }
 

index f31d55e..831d421 100644
@@ -639,11 +639,45 @@ static unsigned int pc_apic_id_limit(unsigned int max_cpus)
     return x86_cpu_apic_id_from_index(max_cpus - 1) + 1;
 }
 
-static FWCfgState *bochs_bios_init(void)
+struct pc_bios_post_init {
+    Notifier post_init;
+    void *fw_cfg;
+};
+static struct pc_bios_post_init post_init;
+
+/* Add the ACPI and SMBIOS tables after all the hardware has been initialized.
+ * This gives devices a chance to add to those tables.
+ */
+static void pc_bios_post_initfn(Notifier *n, void *opaque)
 {
-    FWCfgState *fw_cfg;
+    struct pc_bios_post_init *p = container_of(n, struct pc_bios_post_init,
+                                               post_init);
     uint8_t *smbios_tables, *smbios_anchor;
     size_t smbios_tables_len, smbios_anchor_len;
+    FWCfgState *fw_cfg = p->fw_cfg;
+
+    smbios_tables = smbios_get_table_legacy(&smbios_tables_len);
+    if (smbios_tables) {
+        fw_cfg_add_bytes(fw_cfg, FW_CFG_SMBIOS_ENTRIES,
+                         smbios_tables, smbios_tables_len);
+    }
+
+    smbios_get_tables(&smbios_tables, &smbios_tables_len,
+                      &smbios_anchor, &smbios_anchor_len);
+    if (smbios_anchor) {
+        fw_cfg_add_file(fw_cfg, "etc/smbios/smbios-tables",
+                        smbios_tables, smbios_tables_len);
+        fw_cfg_add_file(fw_cfg, "etc/smbios/smbios-anchor",
+                        smbios_anchor, smbios_anchor_len);
+    }
+
+    fw_cfg_add_bytes(fw_cfg, FW_CFG_ACPI_TABLES,
+                     acpi_tables, acpi_tables_len);
+}
+
+static FWCfgState *bochs_bios_init(void)
+{
+    FWCfgState *fw_cfg;
     uint64_t *numa_fw_cfg;
     int i, j;
     unsigned int apic_id_limit = pc_apic_id_limit(max_cpus);

@@ -666,24 +700,8 @@ static FWCfgState *bochs_bios_init(void)
     fw_cfg_add_i16(fw_cfg, FW_CFG_MAX_CPUS, (uint16_t)apic_id_limit);
     fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
     fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
-    fw_cfg_add_bytes(fw_cfg, FW_CFG_ACPI_TABLES,
-                     acpi_tables, acpi_tables_len);
     fw_cfg_add_i32(fw_cfg, FW_CFG_IRQ0_OVERRIDE, kvm_allows_irq0_override());
 
-    smbios_tables = smbios_get_table_legacy(&smbios_tables_len);
-    if (smbios_tables) {
-        fw_cfg_add_bytes(fw_cfg, FW_CFG_SMBIOS_ENTRIES,
-                         smbios_tables, smbios_tables_len);
-    }
-
-    smbios_get_tables(&smbios_tables, &smbios_tables_len,
-                      &smbios_anchor, &smbios_anchor_len);
-    if (smbios_anchor) {
-        fw_cfg_add_file(fw_cfg, "etc/smbios/smbios-tables",
-                        smbios_tables, smbios_tables_len);
-        fw_cfg_add_file(fw_cfg, "etc/smbios/smbios-anchor",
-                        smbios_anchor, smbios_anchor_len);
-    }
 
     fw_cfg_add_bytes(fw_cfg, FW_CFG_E820_TABLE,
                      &e820_reserve, sizeof(e820_reserve));

@@ -714,6 +732,10 @@ static FWCfgState *bochs_bios_init(void)
                      (1 + apic_id_limit + nb_numa_nodes) *
                      sizeof(*numa_fw_cfg));
 
+    post_init.fw_cfg = fw_cfg;
+    post_init.post_init.notify = pc_bios_post_initfn;
+    qemu_add_machine_init_done_notifier(&post_init.post_init);
+
     return fw_cfg;
 }
 

index 024e594..1081d3c 100644
@@ -825,6 +825,25 @@ static void smbios_entry_point_setup(void)
     ep.structure_table_address = cpu_to_le32(0);
 }
 
+struct smbios_device_handler {
+    void (*handle_device_table)(void *opaque);
+    void *opaque;
+    struct smbios_device_handler *prev;
+};
+static struct smbios_device_handler *device_handlers;
+
+void smbios_register_device_table_handler(void (*handle_device_table)
+                                                (void *opaque),
+                                          void *opaque)
+{
+    struct smbios_device_handler *handler = g_malloc(sizeof(*handler));
+
+    handler->handle_device_table = handle_device_table;
+    handler->opaque = opaque;
+    handler->prev = device_handlers;
+    device_handlers = handler;
+}
+
 void smbios_get_tables(uint8_t **tables, size_t *tables_len,
                        uint8_t **anchor, size_t *anchor_len)
 {

@@ -868,6 +887,14 @@ void smbios_get_tables(uint8_t **tables, size_t *tables_len,
         }
 
         smbios_build_type_32_table();
+
+        while (device_handlers) {
+            struct smbios_device_handler *handler = device_handlers;
+            device_handlers = handler->prev;
+            handler->handle_device_table(handler->opaque);
+            g_free(handler);
+        }
+
         smbios_build_type_127_table();
 
         smbios_validate_table();

@@ -891,6 +918,71 @@ static void save_opt(const char **dest, QemuOpts *opts, const char *name)
     }
 }
 
+int smbios_table_entry_add(void *data, int size, bool append_zeros)
+{
+    struct smbios_structure_header *header;
+    struct smbios_table *table; /* legacy mode only */
+
+    /*
+     * NOTE: standard double '\0' terminator expected, per smbios spec.
+     * (except in legacy mode, where the second '\0' is implicit and
+     *  will be inserted by the BIOS).
+     */
+    if (append_zeros) {
+        size += 2;
+    }
+    smbios_tables = g_realloc(smbios_tables, smbios_tables_len + size);
+    header = (struct smbios_structure_header *)(smbios_tables +
+                                                smbios_tables_len);
+
+    memcpy(header, data, size);
+
+    if (test_bit(header->type, have_fields_bitmap)) {
+        error_report("can't load type %d struct, fields already specified!",
+                     header->type);
+        exit(1);
+    }
+    set_bit(header->type, have_binfile_bitmap);
+
+    if (header->type == 4) {
+        smbios_type4_count++;
+    }
+
+    smbios_tables_len += size;
+    if (size > smbios_table_max) {
+        smbios_table_max = size;
+    }
+    smbios_table_cnt++;
+
+    /* add a copy of the newly loaded blob to legacy smbios_entries */
+    /* NOTE: This code runs before smbios_set_defaults(), so we don't
+     *       yet know which mode (legacy vs. aggregate-table) will be
+     *       required. We therefore add the binary blob to both legacy
+     *       (smbios_entries) and aggregate (smbios_tables) tables, and
+     *       delete the one we don't need from smbios_set_defaults(),
+     *       once we know which machine version has been requested.
+     */
+    if (!smbios_entries) {
+        smbios_entries_len = sizeof(uint16_t);
+        smbios_entries = g_malloc0(smbios_entries_len);
+    }
+    if (append_zeros) {
+        size -= 1; /* The BIOS adds the second zero in legacy mode. */
+    }
+    smbios_entries = g_realloc(smbios_entries, smbios_entries_len +
+                               size + sizeof(*table));
+    table = (struct smbios_table *)(smbios_entries + smbios_entries_len);
+    table->header.type = SMBIOS_TABLE_ENTRY;
+    table->header.length = cpu_to_le16(sizeof(*table) + size);
+    memcpy(table->data, header, size);
+    smbios_entries_len += sizeof(*table) + size;
+    (*(uint16_t *)smbios_entries) =
+                cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1);
+    /* end: add a copy of the newly loaded blob to legacy smbios_entries */
+
+    return 0;
+}
+
 void smbios_entry_add(QemuOpts *opts)
 {
     Error *local_err = NULL;

@@ -900,9 +992,8 @@ void smbios_entry_add(QemuOpts *opts)
 
     val = qemu_opt_get(opts, "file");
     if (val) {
-        struct smbios_structure_header *header;
         int size;
-        struct smbios_table *table; /* legacy mode only */
+        uint8_t *data;
 
         qemu_opts_validate(opts, qemu_smbios_file_opts, &local_err);
         if (local_err) {

@@ -916,60 +1007,14 @@ void smbios_entry_add(QemuOpts *opts)
             exit(1);
         }
 
-        /*
-         * NOTE: standard double '\0' terminator expected, per smbios spec.
-         * (except in legacy mode, where the second '\0' is implicit and
-         *  will be inserted by the BIOS).
-         */
-        smbios_tables = g_realloc(smbios_tables, smbios_tables_len + size);
-        header = (struct smbios_structure_header *)(smbios_tables +
-                                                    smbios_tables_len);
-
-        if (load_image(val, (uint8_t *)header) != size) {
+        data = g_malloc(size);
+        if (load_image(val, data) != size) {
             error_report("Failed to load SMBIOS file %s", val);
             exit(1);
         }
 
-        if (test_bit(header->type, have_fields_bitmap)) {
-            error_report("can't load type %d struct, fields already specified!",
-                         header->type);
-            exit(1);
-        }
-        set_bit(header->type, have_binfile_bitmap);
-
-        if (header->type == 4) {
-            smbios_type4_count++;
-        }
-
-        smbios_tables_len += size;
-        if (size > smbios_table_max) {
-            smbios_table_max = size;
-        }
-        smbios_table_cnt++;
-
-        /* add a copy of the newly loaded blob to legacy smbios_entries */
-        /* NOTE: This code runs before smbios_set_defaults(), so we don't
-         *       yet know which mode (legacy vs. aggregate-table) will be
-         *       required. We therefore add the binary blob to both legacy
-         *       (smbios_entries) and aggregate (smbios_tables) tables, and
-         *       delete the one we don't need from smbios_set_defaults(),
-         *       once we know which machine version has been requested.
-         */
-        if (!smbios_entries) {
-            smbios_entries_len = sizeof(uint16_t);
-            smbios_entries = g_malloc0(smbios_entries_len);
-        }
-        smbios_entries = g_realloc(smbios_entries, smbios_entries_len +
-                                                   size + sizeof(*table));
-        table = (struct smbios_table *)(smbios_entries + smbios_entries_len);
-        table->header.type = SMBIOS_TABLE_ENTRY;
-        table->header.length = cpu_to_le16(sizeof(*table) + size);
-        memcpy(table->data, header, size);
-        smbios_entries_len += sizeof(*table) + size;
-        (*(uint16_t *)smbios_entries) =
-                cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1);
-        /* end: add a copy of the newly loaded blob to legacy smbios_entries */
-
+        smbios_table_entry_add(data, size, false);
+        g_free(data);
         return;
     }
 

index d2850be..656327d 100644
@@ -27,6 +27,19 @@ void smbios_get_tables(uint8_t **tables, size_t *tables_len,
                        uint8_t **anchor, size_t *anchor_len);
 
 /*
+ * Add an external entry to the SMBIOS table.  Can only be called
+ * from a registered device table handler.
+ */
+int smbios_table_entry_add(void *data, int size, bool append_zeros);
+
+/*
+ * When constructing SMBIOS tables, call a function at the end of the
+ * add process to allow devices to add their own SMBIOS table entries.
+ */
+void smbios_register_device_table_handler(void (*handle_device_table)
+                                                (void *opaque),
+                                          void *opaque);
+/*
  * SMBIOS spec defined tables
  */
 

index e62f744..83ea706 100644
@@ -27,6 +27,7 @@
 #include "qemu/timer.h"
 #include "sysemu/char.h"
 #include "sysemu/sysemu.h"
+#include "hw/i386/smbios.h"
 #include "ipmi.h"
 
 /* This is the type the user specifies on the -device command line */

@@ -36,13 +37,50 @@
 typedef struct ISAIPMIDevice {
     ISADevice dev;
     char *interface;
+    int intftype;
     uint32_t iobase;
     int32 isairq;
     uint8_t slave_addr;
+    uint8_t version;
     CharDriverState *chr;
     IPMIInterface *intf;
 } ISAIPMIDevice;
 
+/* SMBIOS type 38 - IPMI */
+struct smbios_type_38 {
+    struct smbios_structure_header header;
+    uint8_t interface_type;
+    uint8_t ipmi_spec_revision;
+    uint8_t i2c_slave_address;
+    uint8_t nv_storage_device_address;
+    uint64_t base_address;
+    uint8_t base_address_modifier;
+    uint8_t interrupt_number;
+} QEMU_PACKED;
+
+static void ipmi_encode_smbios(void *opaque)
+{
+    ISAIPMIDevice *info = opaque;
+    struct smbios_type_38 smb38;
+
+    smb38.header.type = 38;
+    smb38.header.length = sizeof(smb38);
+    smb38.header.handle = cpu_to_le16(0x3000);
+    smb38.interface_type = info->intftype;
+    smb38.ipmi_spec_revision = info->version;
+    smb38.i2c_slave_address = info->slave_addr;
+    smb38.nv_storage_device_address = 0;
+
+    /* or 1 to set it to I/O space */
+    smb38.base_address = cpu_to_le64(info->iobase | 1);
+
+     /* 1-byte boundaries, addr bit0=0, level triggered irq */
+    smb38.base_address_modifier = 1;
+    smb38.interrupt_number = info->isairq;
+    smbios_table_entry_add((struct smbios_structure_header *) &smb38,
+                           sizeof(smb38), true);
+}
+
 static void ipmi_isa_realizefn(DeviceState *dev, Error **errp)
 {
     ISADevice *isadev = ISA_DEVICE(dev);

@@ -50,6 +88,7 @@ static void ipmi_isa_realizefn(DeviceState *dev, Error **errp)
     char typename[20];
     Object *intfobj;
     IPMIInterface *intf;
+    IPMIInterfaceClass *intfk;
     Object *bmcobj;
     IPMIBmc *bmc;
 

@@ -68,10 +107,13 @@ static void ipmi_isa_realizefn(DeviceState *dev, Error **errp)
              TYPE_IPMI_INTERFACE_PREFIX "%s", ipmi->interface);
     intfobj = object_new(typename);
     intf = IPMI_INTERFACE(intfobj);
+    intfk = IPMI_INTERFACE_GET_CLASS(intf);
     bmc->intf = intf;
     intf->bmc = bmc;
     intf->io_base = ipmi->iobase;
     intf->slave_addr = ipmi->slave_addr;
+    ipmi->intftype = intfk->smbios_type;
+    ipmi->version = 0x20; /* Version 2.0 */
     ipmi_interface_init(intf, errp);
     if (*errp) {
         return;

@@ -103,6 +145,7 @@ static void ipmi_isa_realizefn(DeviceState *dev, Error **errp)
     qdev_set_legacy_instance_id(dev, intf->io_base, intf->io_length);
 
     isa_register_ioport(isadev, &intf->io, intf->io_base);
+    smbios_register_device_table_handler(ipmi_encode_smbios, ipmi);
 }
 
 static void ipmi_isa_reset(DeviceState *qdev)

index 51913d6..a4cb485 100644
@@ -78,33 +78,16 @@ static int acpi_checksum(const uint8_t *data, int len)
     return (-sum) & 0xff;
 }
 
-
-/* Install a copy of the ACPI table specified in @blob.
- *
- * If @has_header is set, @blob starts with the System Description Table Header
- * structure. Otherwise, "dfl_hdr" is prepended. In any case, each header field
- * is optionally overwritten from @hdrs.
- *
- * It is valid to call this function with
- * (@blob == NULL && bloblen == 0 && !has_header).
- *
- * @hdrs->file and @hdrs->data are ignored.
- *
- * SIZE_MAX is considered "infinity" in this function.
- *
- * The number of tables that can be installed is not limited, but the 16-bit
- * counter at the beginning of "acpi_tables" wraps around after UINT16_MAX.
- */
-static void acpi_table_install(const char unsigned *blob, size_t bloblen,
-                               bool has_header,
-                               const struct AcpiTableOptions *hdrs,
-                               Error **errp)
+static struct acpi_table_header *acpi_new_table(const unsigned char *blob,
+                                                size_t bloblen,
+                                                bool has_header,
+                                                size_t *rpayload_size,
+                                                Error **errp)
 {
     size_t body_start;
-    const char unsigned *hdr_src;
+    const unsigned char *hdr_src;
     size_t body_size, acpi_payload_size;
     struct acpi_table_header *ext_hdr;
-    unsigned changed_fields;
 
     /* Calculate where the ACPI table body starts within the blob, plus where
      * to copy the ACPI table header from.

@@ -124,7 +107,7 @@ static void acpi_table_install(const char unsigned *blob, size_t bloblen,
             error_setg(errp, "ACPI table claiming to have header is too "
                        "short, available: %zu, expected: %zu", bloblen,
                        body_start);
-            return;
+            return NULL;
         }
         hdr_src = blob;
     } else {

@@ -145,7 +128,7 @@ static void acpi_table_install(const char unsigned *blob, size_t bloblen,
     if (acpi_payload_size > UINT16_MAX) {
         error_setg(errp, "ACPI table too big, requested: %zu, max: %u",
                    acpi_payload_size, (unsigned)UINT16_MAX);
-        return;
+        return NULL;
     }
 
     /* We won't fail from here on. Initialize / extend the globals. */

@@ -173,29 +156,63 @@ static void acpi_table_install(const char unsigned *blob, size_t bloblen,
     stw_le_p(acpi_tables, lduw_le_p(acpi_tables) + 1u);
 
     /* Update the header fields. The strings need not be NUL-terminated. */
-    changed_fields = 0;
     ext_hdr->_length = cpu_to_le16(acpi_payload_size);
 
-    if (hdrs->has_sig) {
-        strncpy(ext_hdr->sig, hdrs->sig, sizeof ext_hdr->sig);
-        ++changed_fields;
-    }
-
     if (has_header && le32_to_cpu(ext_hdr->length) != acpi_payload_size) {
         fprintf(stderr,
                 "warning: ACPI table has wrong length, header says "
                 "%" PRIu32 ", actual size %zu bytes\n",
                 le32_to_cpu(ext_hdr->length), acpi_payload_size);
     }
+
     ext_hdr->length = cpu_to_le32(acpi_payload_size);
+    *rpayload_size = acpi_payload_size;
+
+    return ext_hdr;
+}
+
+/* Install a copy of the ACPI table specified in @blob.
+ *
+ * If @has_header is set, @blob starts with the System Description Table Header
+ * structure. Otherwise, "dfl_hdr" is prepended. In any case, each header field
+ * is optionally overwritten from @hdrs.
+ *
+ * It is valid to call this function with
+ * (@blob == NULL && bloblen == 0 && !has_header).
+ *
+ * @hdrs->file and @hdrs->data are ignored.
+ *
+ * SIZE_MAX is considered "infinity" in this function.
+ *
+ * The number of tables that can be installed is not limited, but the 16-bit
+ * counter at the beginning of "acpi_tables" wraps around after UINT16_MAX.
+ */
+static void acpi_table_install(const char unsigned *blob, size_t bloblen,
+                               bool has_header,
+                               const struct AcpiTableOptions *hdrs,
+                               Error **errp)
+{
+    struct acpi_table_header *ext_hdr;
+    size_t payload_size = 0;
+    unsigned changed_fields = 0;
+
+    ext_hdr = acpi_new_table(blob, bloblen, has_header, &payload_size, errp);
+    if (errp && !*errp) {
+        return;
+    }
+
+    ext_hdr->checksum = 0;
+
+    if (hdrs->has_sig) {
+        strncpy(ext_hdr->sig, hdrs->sig, sizeof ext_hdr->sig);
+        ++changed_fields;
+    }
 
     if (hdrs->has_rev) {
         ext_hdr->revision = hdrs->rev;
         ++changed_fields;
     }
 
-    ext_hdr->checksum = 0;
-
     if (hdrs->has_oem_id) {
         strncpy(ext_hdr->oem_id, hdrs->oem_id, sizeof ext_hdr->oem_id);
         ++changed_fields;

@@ -225,7 +242,28 @@ static void acpi_table_install(const char unsigned *blob, size_t bloblen,
 
     /* recalculate checksum */
     ext_hdr->checksum = acpi_checksum((const char unsigned *)ext_hdr +
-                                      ACPI_TABLE_PFX_SIZE, acpi_payload_size);
+                                      ACPI_TABLE_PFX_SIZE, payload_size);
+}
+
+/*
+ * Add a table from an internal driver.
+ */
+void acpi_append_to_table(const char *sig, void *blob, size_t bloblen,
+                          Error **errp)
+{
+    struct acpi_table_header *ext_hdr;
+    size_t payload_size = 0;
+
+    ext_hdr = acpi_new_table(blob, bloblen, false, &payload_size, errp);
+    if (errp && *errp) {
+        return;
+    }
+
+    strncpy(ext_hdr->sig, sig, sizeof ext_hdr->sig);
+
+    /* recalculate checksum */
+    ext_hdr->checksum = acpi_checksum((const char unsigned *)ext_hdr +
+                                      ACPI_TABLE_PFX_SIZE, payload_size);
 }
 
 void acpi_table_add(const QemuOpts *opts, Error **errp)

index 1f678b4..acdd432 100644
@@ -184,5 +184,7 @@ uint8_t *acpi_table_next(uint8_t *current);
 unsigned acpi_table_len(void *current);
 void acpi_table_add(const QemuOpts *opts, Error **errp);
 void acpi_table_add_builtin(const QemuOpts *opts, Error **errp);
+void acpi_append_to_table(const char *sig, void *blob, size_t bloblen,
+                          Error **errp);
 
 #endif /* !QEMU_HW_ACPI_H */

470 lines not on this page · raw message

80 lines not on this page · raw message

index 83ea706..1652166 100644
@@ -23,6 +23,8 @@
  */
 #include "hw/hw.h"
 #include "hw/isa/isa.h"
+#include "hw/acpi/acpi-elements.h"
+#include "hw/acpi/acpi.h"
 #include "hw/i386/pc.h"
 #include "qemu/timer.h"
 #include "sysemu/char.h"

@@ -39,6 +41,8 @@ typedef struct ISAIPMIDevice {
     char *interface;
     int intftype;
     uint32_t iobase;
+    uint32_t iolength;
+    uint8_t regspacing;
     int32 isairq;
     uint8_t slave_addr;
     uint8_t version;

@@ -58,6 +62,143 @@ struct smbios_type_38 {
     uint8_t interrupt_number;
 } QEMU_PACKED;
 
+static int
+acpi_ipmi_crs_ops(char **data, int dlen, void *opaque)
+{
+    ISAIPMIDevice *info = opaque;
+    int len, rv;
+    uint8_t regspacing = info->regspacing;
+
+    if (regspacing == 1) {
+        regspacing = 0;
+    }
+
+    /* IO(Decode16, x, y, z, c) */
+    len = acpi_add_IO16(data, dlen, info->iobase,
+                        info->iobase + info->iolength - 1,
+                        regspacing, info->iolength);
+    if (len < 0) {
+        return len;
+    }
+
+    if (info->isairq) {
+        /* Interrupt(ResourceConsumer,Level,ActiveHigh,Exclusive) {n} */
+        rv = acpi_add_Interrupt(data, dlen, info->isairq,
+                                ACPI_RESOURCE_CONSUMER,
+                                ACPI_INTERRUPT_MODE_LEVEL,
+                                ACPI_INTERRUPT_POLARITY_ACTIVE_HIGH,
+                                ACPI_INTERRUPT_EXCLUSIVE);
+        if (rv < 0) {
+            return rv;
+        }
+        len += rv;
+    }
+    rv = acpi_add_EndResource(data, dlen);
+    if (rv < 0) {
+        return rv;
+    }
+    len += rv;
+    return len;
+}
+
+static int
+acpi_ipmi_crs(char **data, int dlen, void *opaque)
+{
+    ISAIPMIDevice *info = opaque;
+    int len;
+
+    len = acpi_add_BufferOp(NULL, 0, acpi_ipmi_crs_ops, info);
+    if (len < 0) {
+        return len;
+    }
+    if (len <= dlen) {
+        acpi_add_BufferOp(data, dlen, acpi_ipmi_crs_ops, info);
+    }
+    return len;
+}
+
+static int
+acpi_ipmi_dev(char **data, int dlen, void *opaque)
+{
+    ISAIPMIDevice *info = opaque;
+    int len, rv;
+    char *name;
+    uint64_t val;
+
+    name = g_strdup_printf("ipmi_%s", info->interface);
+
+    /* Name(_HID, EISAID("IPI0001")) */
+    len = acpi_add_Name(data, dlen, "_HID", acpi_add_EISAID,
+                        (void *) "IPI0001");
+    if (len < 0) {
+        return len;
+    }
+    /* Name(_STR, Unicode("ipmi_xxx")) */
+    rv = acpi_add_Name(data, dlen, "_STR", acpi_add_Unicode, name);
+    if (rv < 0) {
+        return rv;
+    }
+    len += rv;
+    val = 0;
+    /* Name(_UID, 0) */
+    rv = acpi_add_Name(data, dlen, "_UID", acpi_add_Integer, &val);
+    if (rv < 0) {
+        return rv;
+    }
+    len += rv;
+    /* Name(_CRS, ResourceTemplate() { */
+    rv = acpi_add_Name(data, dlen, "_CRS", acpi_ipmi_crs, info);
+    if (rv < 0) {
+        return rv;
+    }
+    len += rv;
+    val = info->intftype;
+    /* Method(_IFT) { Return(i) } */
+    rv = acpi_add_Method(data, dlen, "_IFT", 0, acpi_add_Return, &val);
+    if (rv < 0) {
+        return rv;
+    }
+    len += rv;
+    val = ((info->version & 0xf0) << 4) | (info->version & 0x0f);
+    /* Method(_SRV) { Return(version) } */
+    rv = acpi_add_Method(data, dlen, "_SRV", 0, acpi_add_Return, &val);
+    if (rv < 0) {
+        return rv;
+    }
+    len += rv;
+    return len;
+}
+
+static int
+acpi_ipmi_scope(char **data, int dlen, void *opaque)
+{
+    ISAIPMIDevice *info = opaque;
+
+    /* Device(MI0) { */
+    return acpi_add_Device(data, dlen, "MI0", acpi_ipmi_dev, info);
+    /* } */
+}
+
+static void
+ipmi_encode_acpi(ISAIPMIDevice *info)
+{
+    char ipmitable[200];
+    char *tblptr = ipmitable;
+    int rc;
+    Error *err = NULL;
+
+    /* Scope(\_SB.PCI0.ISA) { */
+    rc = acpi_add_Scope(&tblptr, sizeof(ipmitable), "\\_SB.PCI0.ISA",
+                         acpi_ipmi_scope, info);
+    /* } */
+    if (rc < 0) {
+        fprintf(stderr, "Unable to format IPMI ACPI table entry\n");
+        return;
+    }
+
+    acpi_append_to_table("SSDT", ipmitable, rc, &err);
+}
+
 static void ipmi_encode_smbios(void *opaque)
 {
     ISAIPMIDevice *info = opaque;

@@ -79,6 +220,8 @@ static void ipmi_encode_smbios(void *opaque)
     smb38.interrupt_number = info->isairq;
     smbios_table_entry_add((struct smbios_structure_header *) &smb38,
                            sizeof(smb38), true);
+
+    ipmi_encode_acpi(info);
 }
 
 static void ipmi_isa_realizefn(DeviceState *dev, Error **errp)

@@ -110,6 +253,7 @@ static void ipmi_isa_realizefn(DeviceState *dev, Error **errp)
     intfk = IPMI_INTERFACE_GET_CLASS(intf);
     bmc->intf = intf;
     intf->bmc = bmc;
+    ipmi->regspacing = 1;
     intf->io_base = ipmi->iobase;
     intf->slave_addr = ipmi->slave_addr;
     ipmi->intftype = intfk->smbios_type;

@@ -118,6 +262,7 @@ static void ipmi_isa_realizefn(DeviceState *dev, Error **errp)
     if (*errp) {
         return;
     }
+    ipmi->iolength = intf->io_length;
     ipmi_bmc_init(bmc, errp);
     if (*errp) {
         return;

index f3e5e9e..27cf888 100644
@@ -27,6 +27,27 @@
 #include "sysemu/sysemu.h"
 #include "qmp-commands.h"
 
+/*
+ * Create a separate thread for the IPMI interface itself.  This is a
+ * better simulation and lets the IPMI interface do things asynchronously
+ * if necessary.
+ */
+static void *ipmi_thread(void *opaque)
+{
+    IPMIInterface *s = opaque;
+
+    qemu_mutex_lock(&s->lock);
+    for (;;) {
+        qemu_cond_wait(&s->waker, &s->lock);
+        while (s->do_wake) {
+            s->do_wake = 0;
+            (IPMI_INTERFACE_GET_CLASS(s))->handle_if_event(s);
+        }
+    }
+    qemu_mutex_unlock(&s->lock);
+    return NULL;
+}
+
 static int ipmi_do_hw_op(IPMIInterface *s, enum ipmi_op op, int checkonly)
 {
     switch (op) {

@@ -90,6 +111,18 @@ void ipmi_interface_init(IPMIInterface *s, Error **errp)
     if (!s->slave_addr) {
         s->slave_addr = 0x20;
     }
+
+    if (s->threaded_bmc) {
+        qemu_mutex_init(&s->lock);
+        qemu_cond_init(&s->waker);
+        qemu_thread_create(&s->thread, "ipmi-bmc", ipmi_thread, s, 0);
+    }
+
+    if (s->threaded_bmc) {
+        qemu_mutex_init(&s->lock);
+        qemu_cond_init(&s->waker);
+        qemu_thread_create(&s->thread, "ipmi-bmc", ipmi_thread, s, 0);
+    }
 }
 
 static void ipmi_interface_class_init(ObjectClass *class, void *data)

85 lines not on this page · raw message

index 105b978..aecf6c9 100644
@@ -107,6 +107,7 @@ static void ipmi_bt_handle_event(IPMIInterface *s)
 {
     IPMIBtInterface *bt = IPMI_INTERFACE_BT(s);
 
+    /* ipmi_lock is already claimed. */
     if (s->inlen < 4) {
         goto out;
     }

@@ -165,6 +166,7 @@ static void ipmi_bt_handle_rsp(IPMIInterface *s, uint8_t msg_id,
 {
     IPMIBtInterface *bt = IPMI_INTERFACE_BT(s);
 
+    /* ipmi_lock is already claimed. */
     if (bt->waiting_rsp == msg_id) {
         bt->waiting_rsp++;
         if (rsp_len > (sizeof(s->outmsg) - 2)) {

@@ -199,6 +201,7 @@ static uint64_t ipmi_bt_ioport_read(void *opaque, hwaddr addr, unsigned size)
     IPMIInterface *s = &bt->intf;
     uint32_t ret = 0xff;
 
+    ipmi_lock(s);
     switch (addr & 3) {
     case 0:
         ret = bt->control_reg;

@@ -219,6 +222,7 @@ static uint64_t ipmi_bt_ioport_read(void *opaque, hwaddr addr, unsigned size)
         ret = bt->mask_reg;
         break;
     }
+    ipmi_unlock(s);
     return ret;
 }
 

@@ -228,6 +232,7 @@ static void ipmi_bt_ioport_write(void *opaque, hwaddr addr, uint64_t val,
     IPMIBtInterface *bt = opaque;
     IPMIInterface *s = &bt->intf;
 
+    ipmi_lock(s);
     switch (addr & 3) {
     case 0:
         if (IPMI_BT_GET_CLR_WR(val)) {

@@ -284,6 +289,7 @@ static void ipmi_bt_ioport_write(void *opaque, hwaddr addr, uint64_t val,
         }
         break;
     }
+    ipmi_unlock(s);
 }
 
 static const MemoryRegionOps ipmi_bt_io_ops = {

index aace0b3..981a97b 100644
@@ -140,6 +140,7 @@ static void extern_timeout(void *opaque)
     IPMIExternBmc *es = opaque;
     IPMIInterface *s = es->parent.intf;
 
+    ipmi_lock(s);
     if (es->connected) {
         if (es->waiting_rsp && (es->outlen == 0)) {
             IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s);

@@ -153,6 +154,7 @@ static void extern_timeout(void *opaque)
             continue_send(es);
         }
     }
+    ipmi_unlock(s);
 }
 
 static void addchar(IPMIExternBmc *es, unsigned char ch)

@@ -182,6 +184,7 @@ static void ipmi_extern_handle_command(IPMIBmc *b,
     uint8_t err = 0, csum;
     unsigned int i;
 
+    ipmi_lock(s);
     if (es->outlen) {
         /* We already have a command queued.  Shouldn't ever happen. */
         fprintf(stderr, "IPMI KCS: Got command when not finished with the"

@@ -222,6 +225,7 @@ static void ipmi_extern_handle_command(IPMIBmc *b,
     continue_send(es);
 
  out:
+    ipmi_unlock(s);
     return;
 }
 

@@ -304,9 +308,11 @@ static int can_receive(void *opaque)
 static void receive(void *opaque, const uint8_t *buf, int size)
 {
     IPMIExternBmc *es = opaque;
+    IPMIInterface *s = es->parent.intf;
     int i;
     unsigned char hw_op;
 
+    ipmi_lock(s);
     for (i = 0; i < size; i++) {
         unsigned char ch = buf[i];
 

@@ -361,9 +367,15 @@ static void receive(void *opaque, const uint8_t *buf, int size)
             break;
         }
     }
+    ipmi_unlock(s);
     return;
 
  out_hw_op:
+    ipmi_unlock(s);
+    /*
+     * We don't want to handle hardware operations while holding the
+     * lock, that may call back into this code to report a reset.
+     */
     handle_hw_op(es, hw_op);
 }
 

@@ -374,6 +386,7 @@ static void chr_event(void *opaque, int event)
     IPMIInterfaceClass *k = IPMI_INTERFACE_GET_CLASS(s);
     unsigned char v;
 
+    ipmi_lock(s);
     switch (event) {
     case CHR_EVENT_OPENED:
         es->connected = 1;

@@ -415,14 +428,18 @@ static void chr_event(void *opaque, int event)
         }
         break;
     }
+    ipmi_unlock(s);
 }
 
 static void ipmi_extern_handle_reset(IPMIBmc *b)
 {
     IPMIExternBmc *es = IPMI_BMC_EXTERN(b);
+    IPMIInterface *s = es->parent.intf;
 
+    ipmi_lock(s);
     es->send_reset = 1;
     continue_send(es);
+    ipmi_unlock(s);
 }
 
 static int ipmi_extern_post_migrate(void *opaque, int version_id)

index e3af39e..ef50b83 100644
@@ -197,6 +197,7 @@ static void ipmi_kcs_handle_rsp(IPMIInterface *s, uint8_t msg_id,
 {
     IPMIKcsInterface *kcs = IPMI_INTERFACE_KCS(s);
 
+    /* ipmi_lock is already claimed. */
     if (kcs->waiting_rsp == msg_id) {
         kcs->waiting_rsp++;
         if (rsp_len > sizeof(s->outmsg)) {

@@ -220,6 +221,7 @@ static uint64_t ipmi_kcs_ioport_read(void *opaque, hwaddr addr, unsigned size)
     IPMIKcsInterface *kcs = opaque;
     uint32_t ret;
 
+    ipmi_lock(&kcs->intf);
     switch (addr & 1) {
     case 0:
         ret = kcs->data_out_reg;

@@ -241,6 +243,7 @@ static uint64_t ipmi_kcs_ioport_read(void *opaque, hwaddr addr, unsigned size)
         }
         break;
     }
+    ipmi_unlock(&kcs->intf);
     return ret;
 }
 

@@ -254,6 +257,7 @@ static void ipmi_kcs_ioport_write(void *opaque, hwaddr addr, uint64_t val,
         return;
     }
 
+    ipmi_lock(s);
     switch (addr & 1) {
     case 0:
         kcs->data_in_reg = val;

@@ -265,6 +269,7 @@ static void ipmi_kcs_ioport_write(void *opaque, hwaddr addr, uint64_t val,
     }
     IPMI_KCS_SET_IBF(kcs->status_reg, 1);
     ipmi_signal(s);
+    ipmi_unlock(s);
 }
 
 const MemoryRegionOps ipmi_kcs_io_ops = {

index 1652166..aa4bb3c 100644
@@ -46,6 +46,7 @@ typedef struct ISAIPMIDevice {
     int32 isairq;
     uint8_t slave_addr;
     uint8_t version;
+    bool threaded_bmc;
     CharDriverState *chr;
     IPMIInterface *intf;
 } ISAIPMIDevice;

@@ -258,6 +259,7 @@ static void ipmi_isa_realizefn(DeviceState *dev, Error **errp)
     intf->slave_addr = ipmi->slave_addr;
     ipmi->intftype = intfk->smbios_type;
     ipmi->version = 0x20; /* Version 2.0 */
+    intf->threaded_bmc = ipmi->threaded_bmc;
     ipmi_interface_init(intf, errp);
     if (*errp) {
         return;

@@ -306,6 +308,7 @@ static Property ipmi_isa_properties[] = {
     DEFINE_PROP_INT32("irq",   ISAIPMIDevice, isairq,  5),
     DEFINE_PROP_UINT8("slave_addr", ISAIPMIDevice, slave_addr,  0),
     DEFINE_PROP_CHR("chardev",  ISAIPMIDevice, chr),
+    DEFINE_PROP_BOOL("threadbmc",  ISAIPMIDevice, threaded_bmc, false),
     DEFINE_PROP_END_OF_LIST(),
 };