Commit eb322b81 authored by Anthony Liguori's avatar Anthony Liguori
Browse files

Merge remote-tracking branch 'mst/tags/for_anthony' into staging 



pc,pci,virtio fixes and cleanups

This includes pc and pci cleanups and enhancements,
and a virtio-net bugfix related to softmac programming.

Signed-off-by: default avatarMichael S. Tsirkin <mst@redhat.com>

# gpg: Signature made Sun 29 Sep 2013 01:51:16 AM CDT using RSA key ID D28D5469
# gpg: Can't check signature: public key not found

# By Michael S. Tsirkin (8) and others
# Via Michael S. Tsirkin
* mst/tags/for_anthony:
  smbios: Factor out smbios_maybe_add_str()
  smbios: Make multiple -smbios type= accumulate sanely
  smbios: Improve diagnostics for conflicting entries
  smbios: Convert to QemuOpts
  smbios: Normalize smbios_entry_add()'s error handling to exit(1)
  virtio-net: fix up HMP NIC info string on reset
  pci: remove explicit check to 64K ioport size
  piix4: disable io on reset
  piix: use 64 bit window programmed by guest
  q35: use 64 bit window programmed by guest
  pci: add helper to retrieve the 64-bit range
  range: add min/max operations on ranges
  range: add Range to typedefs
  q35: make pci window address/size match guest cfg

Message-id: 1380437951-21788-1-git-send-email-mst@redhat.com
parents 4235d773 e26d3e73

arch_init.c

+2 −7
Original line number Diff line number Diff line
@@ -1118,9 +1118,6 @@ int qemu_uuid_parse(const char *str, uint8_t *uuid) 
    if (ret != 16) {

        return -1;

    }

#ifdef TARGET_I386

    smbios_add_field(1, offsetof(struct smbios_type_1, uuid), uuid, 16);

#endif

    return 0;

}
@@ -1139,12 +1136,10 @@ void do_acpitable_option(const QemuOpts *opts) 
#endif

}



void do_smbios_option(const char *optarg)

void do_smbios_option(QemuOpts *opts)

{

#ifdef TARGET_I386

    if (smbios_entry_add(optarg) < 0) {

        exit(1);

    }

    smbios_entry_add(opts);

#endif

}

hw/acpi/piix4.c

+1 −0
Original line number Diff line number Diff line
@@ -380,6 +380,7 @@ static void piix4_reset(void *opaque) 
        /* Mark SMM as already inited (until KVM supports SMM). */

        pci_conf[0x5B] = 0x02;

    }

    pm_io_space_update(s);

    piix4_update_hotplug(s);

}

hw/i386/smbios.c

+241 −98
Original line number Diff line number Diff line
@@ -2,9 +2,11 @@ 
 * SMBIOS Support

 *

 * Copyright (C) 2009 Hewlett-Packard Development Company, L.P.

 * Copyright (C) 2013 Red Hat, Inc.

 *

 * Authors:

 *  Alex Williamson <alex.williamson@hp.com>

 *  Markus Armbruster <armbru@redhat.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2.  See

 * the COPYING file in the top-level directory.
@@ -13,6 +15,7 @@ 
 * GNU GPL, version 2 or (at your option) any later version.

 */



#include "qemu/config-file.h"

#include "qemu/error-report.h"

#include "sysemu/sysemu.h"

#include "hw/i386/smbios.h"
@@ -41,10 +44,117 @@ struct smbios_table { 
#define SMBIOS_FIELD_ENTRY 0

#define SMBIOS_TABLE_ENTRY 1





static uint8_t *smbios_entries;

static size_t smbios_entries_len;

static int smbios_type4_count = 0;

static bool smbios_immutable;



static struct {

    bool seen;

    int headertype;

    Location loc;

} first_opt[2];



static struct {

    const char *vendor, *version, *date;

    bool have_major_minor;

    uint8_t major, minor;

} type0;



static struct {

    const char *manufacturer, *product, *version, *serial, *sku, *family;

    /* uuid is in qemu_uuid[] */

} type1;



static QemuOptsList qemu_smbios_opts = {

    .name = "smbios",

    .head = QTAILQ_HEAD_INITIALIZER(qemu_smbios_opts.head),

    .desc = {

        /*

         * no elements => accept any params

         * validation will happen later

         */

        { /* end of list */ }

    }

};



static const QemuOptDesc qemu_smbios_file_opts[] = {

    {

        .name = "file",

        .type = QEMU_OPT_STRING,

        .help = "binary file containing an SMBIOS element",

    },

    { /* end of list */ }

};



static const QemuOptDesc qemu_smbios_type0_opts[] = {

    {

        .name = "type",

        .type = QEMU_OPT_NUMBER,

        .help = "SMBIOS element type",

    },{

        .name = "vendor",

        .type = QEMU_OPT_STRING,

        .help = "vendor name",

    },{

        .name = "version",

        .type = QEMU_OPT_STRING,

        .help = "version number",

    },{

        .name = "date",

        .type = QEMU_OPT_STRING,

        .help = "release date",

    },{

        .name = "release",

        .type = QEMU_OPT_STRING,

        .help = "revision number",

    },

    { /* end of list */ }

};



static const QemuOptDesc qemu_smbios_type1_opts[] = {

    {

        .name = "type",

        .type = QEMU_OPT_NUMBER,

        .help = "SMBIOS element type",

    },{

        .name = "manufacturer",

        .type = QEMU_OPT_STRING,

        .help = "manufacturer name",

    },{

        .name = "product",

        .type = QEMU_OPT_STRING,

        .help = "product name",

    },{

        .name = "version",

        .type = QEMU_OPT_STRING,

        .help = "version number",

    },{

        .name = "serial",

        .type = QEMU_OPT_STRING,

        .help = "serial number",

    },{

        .name = "uuid",

        .type = QEMU_OPT_STRING,

        .help = "UUID",

    },{

        .name = "sku",

        .type = QEMU_OPT_STRING,

        .help = "SKU number",

    },{

        .name = "family",

        .type = QEMU_OPT_STRING,

        .help = "family name",

    },

    { /* end of list */ }

};



static void smbios_register_config(void)

{

    qemu_add_opts(&qemu_smbios_opts);

}



machine_init(smbios_register_config);



static void smbios_validate_table(void)

{
@@ -54,57 +164,33 @@ static void smbios_validate_table(void) 
    }

}



uint8_t *smbios_get_table(size_t *length)

{

    smbios_validate_table();

    *length = smbios_entries_len;

    return smbios_entries;

}



/*

 * To avoid unresolvable overlaps in data, don't allow both

 * tables and fields for the same smbios type.

 */

static void smbios_check_collision(int type, int entry)

{

    uint16_t *num_entries = (uint16_t *)smbios_entries;

    struct smbios_header *header;

    char *p;

    int i;



    if (!num_entries)

        return;



    p = (char *)(num_entries + 1);



    for (i = 0; i < *num_entries; i++) {

        header = (struct smbios_header *)p;

        if (entry == SMBIOS_TABLE_ENTRY && header->type == SMBIOS_FIELD_ENTRY) {

            struct smbios_field *field = (void *)header;

            if (type == field->type) {

                error_report("SMBIOS type %d field already defined, "

                             "cannot add table", type);

    if (type < ARRAY_SIZE(first_opt)) {

        if (first_opt[type].seen) {

            if (first_opt[type].headertype != entry) {

                error_report("Can't mix file= and type= for same type");

                loc_push_restore(&first_opt[type].loc);

                error_report("This is the conflicting setting");

                loc_pop(&first_opt[type].loc);

                exit(1);

            }

        } else if (entry == SMBIOS_FIELD_ENTRY &&

                   header->type == SMBIOS_TABLE_ENTRY) {

            struct smbios_structure_header *table = (void *)(header + 1);

            if (type == table->type) {

                error_report("SMBIOS type %d table already defined, "

                             "cannot add field", type);

                exit(1);

        } else {

            first_opt[type].seen = true;

            first_opt[type].headertype = entry;

            loc_save(&first_opt[type].loc);

        }

    }

        p += le16_to_cpu(header->length);

    }

}



void smbios_add_field(int type, int offset, const void *data, size_t len)

static void smbios_add_field(int type, int offset, const void *data, size_t len)

{

    struct smbios_field *field;



    smbios_check_collision(type, SMBIOS_FIELD_ENTRY);



    if (!smbios_entries) {

        smbios_entries_len = sizeof(uint16_t);

        smbios_entries = g_malloc0(smbios_entries_len);
@@ -124,76 +210,94 @@ void smbios_add_field(int type, int offset, const void *data, size_t len) 
            cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1);

}



static void smbios_build_type_0_fields(const char *t)

static void smbios_maybe_add_str(int type, int offset, const char *data)

{

    char buf[1024];

    unsigned char major, minor;



    if (get_param_value(buf, sizeof(buf), "vendor", t))

        smbios_add_field(0, offsetof(struct smbios_type_0, vendor_str),

                         buf, strlen(buf) + 1);

    if (get_param_value(buf, sizeof(buf), "version", t))

        smbios_add_field(0, offsetof(struct smbios_type_0, bios_version_str),

                         buf, strlen(buf) + 1);

    if (get_param_value(buf, sizeof(buf), "date", t))

        smbios_add_field(0, offsetof(struct smbios_type_0,

                                     bios_release_date_str),

                         buf, strlen(buf) + 1);

    if (get_param_value(buf, sizeof(buf), "release", t)) {

        if (sscanf(buf, "%hhu.%hhu", &major, &minor) != 2) {

            error_report("Invalid release");

            exit(1);

    if (data) {

        smbios_add_field(type, offset, data, strlen(data) + 1);

    }

}



static void smbios_build_type_0_fields(void)

{

    smbios_maybe_add_str(0, offsetof(struct smbios_type_0, vendor_str),

                         type0.vendor);

    smbios_maybe_add_str(0, offsetof(struct smbios_type_0, bios_version_str),

                         type0.version);

    smbios_maybe_add_str(0, offsetof(struct smbios_type_0,

                                     bios_release_date_str),

                         type0.date);

    if (type0.have_major_minor) {

        smbios_add_field(0, offsetof(struct smbios_type_0,

                                     system_bios_major_release),

                         &major, 1);

                         &type0.major, 1);

        smbios_add_field(0, offsetof(struct smbios_type_0,

                                     system_bios_minor_release),

                         &minor, 1);

                         &type0.minor, 1);

    }

}



static void smbios_build_type_1_fields(const char *t)

static void smbios_build_type_1_fields(void)

{

    char buf[1024];



    if (get_param_value(buf, sizeof(buf), "manufacturer", t))

        smbios_add_field(1, offsetof(struct smbios_type_1, manufacturer_str),

                         buf, strlen(buf) + 1);

    if (get_param_value(buf, sizeof(buf), "product", t))

        smbios_add_field(1, offsetof(struct smbios_type_1, product_name_str),

                         buf, strlen(buf) + 1);

    if (get_param_value(buf, sizeof(buf), "version", t))

        smbios_add_field(1, offsetof(struct smbios_type_1, version_str),

                         buf, strlen(buf) + 1);

    if (get_param_value(buf, sizeof(buf), "serial", t))

        smbios_add_field(1, offsetof(struct smbios_type_1, serial_number_str),

                         buf, strlen(buf) + 1);

    if (get_param_value(buf, sizeof(buf), "uuid", t)) {

        if (qemu_uuid_parse(buf, qemu_uuid) != 0) {

            error_report("Invalid UUID");

            exit(1);

    smbios_maybe_add_str(1, offsetof(struct smbios_type_1, manufacturer_str),

                         type1.manufacturer);

    smbios_maybe_add_str(1, offsetof(struct smbios_type_1, product_name_str),

                         type1.product);

    smbios_maybe_add_str(1, offsetof(struct smbios_type_1, version_str),

                         type1.version);

    smbios_maybe_add_str(1, offsetof(struct smbios_type_1, serial_number_str),

                         type1.serial);

    smbios_maybe_add_str(1, offsetof(struct smbios_type_1, sku_number_str),

                         type1.sku);

    smbios_maybe_add_str(1, offsetof(struct smbios_type_1, family_str),

                         type1.family);

    if (qemu_uuid_set) {

        smbios_add_field(1, offsetof(struct smbios_type_1, uuid),

                         qemu_uuid, 16);

    }

}

    if (get_param_value(buf, sizeof(buf), "sku", t))

        smbios_add_field(1, offsetof(struct smbios_type_1, sku_number_str),

                         buf, strlen(buf) + 1);

    if (get_param_value(buf, sizeof(buf), "family", t))

        smbios_add_field(1, offsetof(struct smbios_type_1, family_str),

                         buf, strlen(buf) + 1);



uint8_t *smbios_get_table(size_t *length)

{

    if (!smbios_immutable) {

        smbios_build_type_0_fields();

        smbios_build_type_1_fields();

        smbios_validate_table();

        smbios_immutable = true;

    }

    *length = smbios_entries_len;

    return smbios_entries;

}



static void save_opt(const char **dest, QemuOpts *opts, const char *name)

{

    const char *val = qemu_opt_get(opts, name);



    if (val) {

        *dest = val;

    }

}



int smbios_entry_add(const char *t)

void smbios_entry_add(QemuOpts *opts)

{

    char buf[1024];

    Error *local_err = NULL;

    const char *val;



    if (get_param_value(buf, sizeof(buf), "file", t)) {

    assert(!smbios_immutable);

    val = qemu_opt_get(opts, "file");

    if (val) {

        struct smbios_structure_header *header;

        struct smbios_table *table;

        int size = get_image_size(buf);

        int size;



        qemu_opts_validate(opts, qemu_smbios_file_opts, &local_err);

        if (local_err) {

            error_report("%s", error_get_pretty(local_err));

            exit(1);

        }



        size = get_image_size(val);

        if (size == -1 || size < sizeof(struct smbios_structure_header)) {

            error_report("Cannot read SMBIOS file %s", buf);

            error_report("Cannot read SMBIOS file %s", val);

            exit(1);

        }
@@ -208,8 +312,8 @@ int smbios_entry_add(const char *t) 
        table->header.type = SMBIOS_TABLE_ENTRY;

        table->header.length = cpu_to_le16(sizeof(*table) + size);



        if (load_image(buf, table->data) != size) {

            error_report("Failed to load SMBIOS file %s", buf);

        if (load_image(val, table->data) != size) {

            error_report("Failed to load SMBIOS file %s", val);

            exit(1);

        }
@@ -222,18 +326,57 @@ int smbios_entry_add(const char *t) 
        smbios_entries_len += sizeof(*table) + size;

        (*(uint16_t *)smbios_entries) =

                cpu_to_le16(le16_to_cpu(*(uint16_t *)smbios_entries) + 1);

        return 0;

        return;

    }



    if (get_param_value(buf, sizeof(buf), "type", t)) {

        unsigned long type = strtoul(buf, NULL, 0);

    val = qemu_opt_get(opts, "type");

    if (val) {

        unsigned long type = strtoul(val, NULL, 0);



        smbios_check_collision(type, SMBIOS_FIELD_ENTRY);



        switch (type) {

        case 0:

            smbios_build_type_0_fields(t);

            return 0;

            qemu_opts_validate(opts, qemu_smbios_type0_opts, &local_err);

            if (local_err) {

                error_report("%s", error_get_pretty(local_err));

                exit(1);

            }

            save_opt(&type0.vendor, opts, "vendor");

            save_opt(&type0.version, opts, "version");

            save_opt(&type0.date, opts, "date");



            val = qemu_opt_get(opts, "release");

            if (val) {

                if (sscanf(val, "%hhu.%hhu", &type0.major, &type0.minor) != 2) {

                    error_report("Invalid release");

                    exit(1);

                }

                type0.have_major_minor = true;

            }

            return;

        case 1:

            smbios_build_type_1_fields(t);

            return 0;

            qemu_opts_validate(opts, qemu_smbios_type1_opts, &local_err);

            if (local_err) {

                error_report("%s", error_get_pretty(local_err));

                exit(1);

            }

            save_opt(&type1.manufacturer, opts, "manufacturer");

            save_opt(&type1.product, opts, "product");

            save_opt(&type1.version, opts, "version");

            save_opt(&type1.serial, opts, "serial");

            save_opt(&type1.sku, opts, "sku");

            save_opt(&type1.family, opts, "family");



            val = qemu_opt_get(opts, "uuid");

            if (val) {

                if (qemu_uuid_parse(val, qemu_uuid) != 0) {

                    error_report("Invalid UUID");

                    exit(1);

                }

                qemu_uuid_set = true;

            }

            return;

        default:

            error_report("Don't know how to build fields for SMBIOS type %ld",

                         type);
@@ -242,5 +385,5 @@ int smbios_entry_add(const char *t) 
    }



    error_report("Must specify type= or file=");

    return -1;

    exit(1);

}

hw/net/virtio-net.c

+1 −0
Original line number Diff line number Diff line
@@ -314,6 +314,7 @@ static void virtio_net_reset(VirtIODevice *vdev) 
    n->mac_table.uni_overflow = 0;

    memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);

    memcpy(&n->mac[0], &n->nic->conf->macaddr, sizeof(n->mac));

    qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);

    memset(n->vlans, 0, MAX_VLAN >> 3);

}

hw/pci-host/piix.c

+10 −4
Original line number Diff line number Diff line
@@ -235,18 +235,24 @@ static void i440fx_pcihost_get_pci_hole64_start(Object *obj, Visitor *v, 
                                                void *opaque, const char *name,

                                                Error **errp)

{

    I440FXState *s = I440FX_PCI_HOST_BRIDGE(obj);

    PCIHostState *h = PCI_HOST_BRIDGE(obj);

    Range w64;



    pci_bus_get_w64_range(h->bus, &w64);



    visit_type_uint64(v, &s->pci_info.w64.begin, name, errp);

    visit_type_uint64(v, &w64.begin, name, errp);

}



static void i440fx_pcihost_get_pci_hole64_end(Object *obj, Visitor *v,

                                              void *opaque, const char *name,

                                              Error **errp)

{

    I440FXState *s = I440FX_PCI_HOST_BRIDGE(obj);

    PCIHostState *h = PCI_HOST_BRIDGE(obj);

    Range w64;



    pci_bus_get_w64_range(h->bus, &w64);



    visit_type_uint64(v, &s->pci_info.w64.end, name, errp);

    visit_type_uint64(v, &w64.end, name, errp);

}



static void i440fx_pcihost_initfn(Object *obj)