Commit e85c5771 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2018-12-17' into staging 



- Replace global_qtest in some tests
- Exit boot-serial-test loop if child dies
- Sanitize verbose output in biot-tables-test

# gpg: Signature made Mon 17 Dec 2018 16:08:07 GMT
# gpg:                using RSA key 2ED9D774FE702DB5
# gpg: Good signature from "Thomas Huth <th.huth@gmx.de>"
# gpg:                 aka "Thomas Huth <thuth@redhat.com>"
# gpg:                 aka "Thomas Huth <huth@tuxfamily.org>"
# gpg:                 aka "Thomas Huth <th.huth@posteo.de>"
# Primary key fingerprint: 27B8 8847 EEE0 2501 18F3  EAB9 2ED9 D774 FE70 2DB5

* remotes/huth-gitlab/tags/pull-request-2018-12-17:
  tests/bios-tables-test: Sanitize test verbose output
  tests: acpi: remove not used ACPI_READ_GENERIC_ADDRESS macro
  tests: Exit boot-serial-test loop if child dies
  tests/pxe: Make test independent of global_qtest
  tests/prom-env: Make test independent of global_qtest
  tests/machine-none: Make test independent of global_qtest
  tests/test-filter: Make tests independent of global_qtest
  tests/boot-serial: Get rid of global_qtest variable
  tests/pvpanic: Make the pvpanic test independent of global_qtest
  tests/vmgenid: Make test independent of global_qtest
  tests/acpi-utils: Drop dependence on global_qtest
  ivshmem-test: Drop dependence on global_qtest
  tests/libqos/pci: Make PCI access functions independent of global_qtest

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents ec3c927f fe17cca6

tests/acpi-utils.c

+10 −9
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ uint8_t acpi_calc_checksum(const uint8_t *data, int len) 
    return sum;

}



uint32_t acpi_find_rsdp_address(void)

uint32_t acpi_find_rsdp_address(QTestState *qts)

{

    uint32_t off;
@@ -42,7 +42,7 @@ uint32_t acpi_find_rsdp_address(void) 
        int i;



        for (i = 0; i < sizeof sig - 1; ++i) {

            sig[i] = readb(off + i);

            sig[i] = qtest_readb(qts, off + i);

        }



        if (!memcmp(sig, "RSD PTR ", sizeof sig)) {
@@ -52,14 +52,15 @@ uint32_t acpi_find_rsdp_address(void) 
    return off;

}



void acpi_parse_rsdp_table(uint32_t addr, AcpiRsdpDescriptor *rsdp_table)

void acpi_parse_rsdp_table(QTestState *qts, uint32_t addr,

                           AcpiRsdpDescriptor *rsdp_table)

{

    ACPI_READ_FIELD(rsdp_table->signature, addr);

    ACPI_READ_FIELD(qts, rsdp_table->signature, addr);

    ACPI_ASSERT_CMP64(rsdp_table->signature, "RSD PTR ");



    ACPI_READ_FIELD(rsdp_table->checksum, addr);

    ACPI_READ_ARRAY(rsdp_table->oem_id, addr);

    ACPI_READ_FIELD(rsdp_table->revision, addr);

    ACPI_READ_FIELD(rsdp_table->rsdt_physical_address, addr);

    ACPI_READ_FIELD(rsdp_table->length, addr);

    ACPI_READ_FIELD(qts, rsdp_table->checksum, addr);

    ACPI_READ_ARRAY(qts, rsdp_table->oem_id, addr);

    ACPI_READ_FIELD(qts, rsdp_table->revision, addr);

    ACPI_READ_FIELD(qts, rsdp_table->rsdt_physical_address, addr);

    ACPI_READ_FIELD(qts, rsdp_table->length, addr);

}

tests/acpi-utils.h

+25 −32
Original line number Diff line number Diff line
@@ -28,34 +28,34 @@ typedef struct { 
    bool tmp_files_retain;   /* do not delete the temp asl/aml */

} AcpiSdtTable;



#define ACPI_READ_FIELD(field, addr)            \

#define ACPI_READ_FIELD(qts, field, addr)                \

    do {                                                 \

        memread(addr, &field, sizeof(field));   \

        qtest_memread(qts, addr, &field, sizeof(field)); \

        addr += sizeof(field);                           \

    } while (0)



#define ACPI_READ_ARRAY_PTR(arr, length, addr)  \

#define ACPI_READ_ARRAY_PTR(qts, arr, length, addr)      \

    do {                                                 \

        int idx;                                         \

        for (idx = 0; idx < length; ++idx) {             \

            ACPI_READ_FIELD(arr[idx], addr);    \

            ACPI_READ_FIELD(qts, arr[idx], addr);        \

        }                                                \

    } while (0)



#define ACPI_READ_ARRAY(arr, addr)                               \

    ACPI_READ_ARRAY_PTR(arr, sizeof(arr) / sizeof(arr[0]), addr)

#define ACPI_READ_ARRAY(qts, arr, addr)                                 \

    ACPI_READ_ARRAY_PTR(qts, arr, sizeof(arr) / sizeof(arr[0]), addr)



#define ACPI_READ_TABLE_HEADER(table, addr)                      \

#define ACPI_READ_TABLE_HEADER(qts, table, addr)                 \

    do {                                                         \

        ACPI_READ_FIELD((table)->signature, addr);               \

        ACPI_READ_FIELD((table)->length, addr);                  \

        ACPI_READ_FIELD((table)->revision, addr);                \

        ACPI_READ_FIELD((table)->checksum, addr);                \

        ACPI_READ_ARRAY((table)->oem_id, addr);                  \

        ACPI_READ_ARRAY((table)->oem_table_id, addr);            \

        ACPI_READ_FIELD((table)->oem_revision, addr);            \

        ACPI_READ_ARRAY((table)->asl_compiler_id, addr);         \

        ACPI_READ_FIELD((table)->asl_compiler_revision, addr);   \

        ACPI_READ_FIELD(qts, (table)->signature, addr);          \

        ACPI_READ_FIELD(qts, (table)->length, addr);             \

        ACPI_READ_FIELD(qts, (table)->revision, addr);           \

        ACPI_READ_FIELD(qts, (table)->checksum, addr);           \

        ACPI_READ_ARRAY(qts, (table)->oem_id, addr);             \

        ACPI_READ_ARRAY(qts, (table)->oem_table_id, addr);       \

        ACPI_READ_FIELD(qts, (table)->oem_revision, addr);       \

        ACPI_READ_ARRAY(qts, (table)->asl_compiler_id, addr);    \

        ACPI_READ_FIELD(qts, (table)->asl_compiler_revision, addr);     \

    } while (0)



#define ACPI_ASSERT_CMP(actual, expected) do { \
@@ -70,18 +70,11 @@ typedef struct { 
    g_assert_cmpstr(ACPI_ASSERT_CMP_str, ==, expected); \

} while (0)



#define ACPI_READ_GENERIC_ADDRESS(field, addr)       \

    do {                                             \

        ACPI_READ_FIELD((field).space_id, addr);     \

        ACPI_READ_FIELD((field).bit_width, addr);    \

        ACPI_READ_FIELD((field).bit_offset, addr);   \

        ACPI_READ_FIELD((field).access_width, addr); \

        ACPI_READ_FIELD((field).address, addr);      \

    } while (0)





uint8_t acpi_calc_checksum(const uint8_t *data, int len);

uint32_t acpi_find_rsdp_address(void);

void acpi_parse_rsdp_table(uint32_t addr, AcpiRsdpDescriptor *rsdp_table);

uint32_t acpi_find_rsdp_address(QTestState *qts);

void acpi_parse_rsdp_table(QTestState *qts, uint32_t addr,

                           AcpiRsdpDescriptor *rsdp_table);



#endif  /* TEST_ACPI_UTILS_H */

tests/bios-tables-test.c

+47 −42
Original line number Diff line number Diff line
@@ -39,6 +39,7 @@ typedef struct { 
    struct smbios_21_entry_point smbios_ep_table;

    uint8_t *required_struct_types;

    int required_struct_types_len;

    QTestState *qts;

} test_data;



static char disk[] = "tests/acpi-test-disk-XXXXXX";
@@ -78,7 +79,7 @@ static void free_test_data(test_data *data) 


static void test_acpi_rsdp_address(test_data *data)

{

    uint32_t off = acpi_find_rsdp_address();

    uint32_t off = acpi_find_rsdp_address(data->qts);

    g_assert_cmphex(off, <, 0x100000);

    data->rsdp_addr = off;

}
@@ -88,7 +89,7 @@ static void test_acpi_rsdp_table(test_data *data) 
    AcpiRsdpDescriptor *rsdp_table = &data->rsdp_table;

    uint32_t addr = data->rsdp_addr;



    acpi_parse_rsdp_table(addr, rsdp_table);

    acpi_parse_rsdp_table(data->qts, addr, rsdp_table);



    /* rsdp checksum is not for the whole table, but for the first 20 bytes */

    g_assert(!acpi_calc_checksum((uint8_t *)rsdp_table, 20));
@@ -104,7 +105,7 @@ static void test_acpi_rsdt_table(test_data *data) 
    uint32_t rsdt_table_length;



    /* read the header */

    ACPI_READ_TABLE_HEADER(rsdt_table, addr);

    ACPI_READ_TABLE_HEADER(data->qts, rsdt_table, addr);

    ACPI_ASSERT_CMP(rsdt_table->signature, "RSDT");



    rsdt_table_length = le32_to_cpu(rsdt_table->length);
@@ -116,7 +117,7 @@ static void test_acpi_rsdt_table(test_data *data) 


    /* get the addresses of the tables pointed by rsdt */

    tables = g_new0(uint32_t, tables_nr);

    ACPI_READ_ARRAY_PTR(tables, tables_nr, addr);

    ACPI_READ_ARRAY_PTR(data->qts, tables, tables_nr, addr);



    checksum = acpi_calc_checksum((uint8_t *)rsdt_table, rsdt_table_length) +

               acpi_calc_checksum((uint8_t *)tables,
@@ -135,11 +136,11 @@ static void fadt_fetch_facs_and_dsdt_ptrs(test_data *data) 


    /* FADT table comes first */

    addr = le32_to_cpu(data->rsdt_tables_addr[0]);

    ACPI_READ_TABLE_HEADER(&hdr, addr);

    ACPI_READ_TABLE_HEADER(data->qts, &hdr, addr);

    ACPI_ASSERT_CMP(hdr.signature, "FACP");



    ACPI_READ_FIELD(data->facs_addr, addr);

    ACPI_READ_FIELD(data->dsdt_addr, addr);

    ACPI_READ_FIELD(data->qts, data->facs_addr, addr);

    ACPI_READ_FIELD(data->qts, data->dsdt_addr, addr);

}



static void sanitize_fadt_ptrs(test_data *data)
@@ -182,13 +183,13 @@ static void test_acpi_facs_table(test_data *data) 
    AcpiFacsDescriptorRev1 *facs_table = &data->facs_table;

    uint32_t addr = le32_to_cpu(data->facs_addr);



    ACPI_READ_FIELD(facs_table->signature, addr);

    ACPI_READ_FIELD(facs_table->length, addr);

    ACPI_READ_FIELD(facs_table->hardware_signature, addr);

    ACPI_READ_FIELD(facs_table->firmware_waking_vector, addr);

    ACPI_READ_FIELD(facs_table->global_lock, addr);

    ACPI_READ_FIELD(facs_table->flags, addr);

    ACPI_READ_ARRAY(facs_table->resverved3, addr);

    ACPI_READ_FIELD(data->qts, facs_table->signature, addr);

    ACPI_READ_FIELD(data->qts, facs_table->length, addr);

    ACPI_READ_FIELD(data->qts, facs_table->hardware_signature, addr);

    ACPI_READ_FIELD(data->qts, facs_table->firmware_waking_vector, addr);

    ACPI_READ_FIELD(data->qts, facs_table->global_lock, addr);

    ACPI_READ_FIELD(data->qts, facs_table->flags, addr);

    ACPI_READ_ARRAY(data->qts, facs_table->resverved3, addr);



    ACPI_ASSERT_CMP(facs_table->signature, "FACS");

}
@@ -197,17 +198,17 @@ static void test_acpi_facs_table(test_data *data) 
 *   load ACPI table at @addr into table descriptor @sdt_table

 *   and check that header checksum matches actual one.

 */

static void fetch_table(AcpiSdtTable *sdt_table, uint32_t addr)

static void fetch_table(QTestState *qts, AcpiSdtTable *sdt_table, uint32_t addr)

{

    uint8_t checksum;



    memset(sdt_table, 0, sizeof(*sdt_table));

    ACPI_READ_TABLE_HEADER(&sdt_table->header, addr);

    ACPI_READ_TABLE_HEADER(qts, &sdt_table->header, addr);



    sdt_table->aml_len = le32_to_cpu(sdt_table->header.length)

                         - sizeof(AcpiTableHeader);

    sdt_table->aml = g_malloc0(sdt_table->aml_len);

    ACPI_READ_ARRAY_PTR(sdt_table->aml, sdt_table->aml_len, addr);

    ACPI_READ_ARRAY_PTR(qts, sdt_table->aml, sdt_table->aml_len, addr);



    checksum = acpi_calc_checksum((uint8_t *)sdt_table,

                                  sizeof(AcpiTableHeader)) +
@@ -221,7 +222,7 @@ static void test_acpi_dsdt_table(test_data *data) 
    AcpiSdtTable dsdt_table;

    uint32_t addr = le32_to_cpu(data->dsdt_addr);



    fetch_table(&dsdt_table, addr);

    fetch_table(data->qts, &dsdt_table, addr);

    ACPI_ASSERT_CMP(dsdt_table.header.signature, "DSDT");



    /* Since DSDT isn't in RSDT, add DSDT to ASL test tables list manually */
@@ -239,7 +240,7 @@ static void fetch_rsdt_referenced_tables(test_data *data) 
        uint32_t addr;



        addr = le32_to_cpu(data->rsdt_tables_addr[i]);

        fetch_table(&ssdt_table, addr);

        fetch_table(data->qts, &ssdt_table, addr);



        /* Add table to ASL test tables list */

        g_array_append_val(data->tables, ssdt_table);
@@ -371,6 +372,9 @@ static GArray *load_expected_aml(test_data *data) 
    gboolean ret;



    GArray *exp_tables = g_array_new(false, true, sizeof(AcpiSdtTable));

    if (getenv("V")) {

        fputc('\n', stderr);

    }

    for (i = 0; i < data->tables->len; ++i) {

        AcpiSdtTable exp_sdt;

        gchar *aml_file = NULL;
@@ -385,7 +389,7 @@ try_again: 
        aml_file = g_strdup_printf("%s/%s/%.4s%s", data_dir, data->machine,

                                   (gchar *)&sdt->header.signature, ext);

        if (getenv("V")) {

            fprintf(stderr, "\nLooking for expected file '%s'\n", aml_file);

            fprintf(stderr, "Looking for expected file '%s'\n", aml_file);

        }

        if (g_file_test(aml_file, G_FILE_TEST_EXISTS)) {

            exp_sdt.aml_file = aml_file;
@@ -397,7 +401,7 @@ try_again: 
        }

        g_assert(exp_sdt.aml_file);

        if (getenv("V")) {

            fprintf(stderr, "\nUsing expected file '%s'\n", aml_file);

            fprintf(stderr, "Using expected file '%s'\n", aml_file);

        }

        ret = g_file_get_contents(aml_file, &exp_sdt.aml,

                                  &exp_sdt.aml_len, &error);
@@ -482,32 +486,32 @@ static bool smbios_ep_table_ok(test_data *data) 
    struct smbios_21_entry_point *ep_table = &data->smbios_ep_table;

    uint32_t addr = data->smbios_ep_addr;



    ACPI_READ_ARRAY(ep_table->anchor_string, addr);

    ACPI_READ_ARRAY(data->qts, ep_table->anchor_string, addr);

    if (memcmp(ep_table->anchor_string, "_SM_", 4)) {

        return false;

    }

    ACPI_READ_FIELD(ep_table->checksum, addr);

    ACPI_READ_FIELD(ep_table->length, addr);

    ACPI_READ_FIELD(ep_table->smbios_major_version, addr);

    ACPI_READ_FIELD(ep_table->smbios_minor_version, addr);

    ACPI_READ_FIELD(ep_table->max_structure_size, addr);

    ACPI_READ_FIELD(ep_table->entry_point_revision, addr);

    ACPI_READ_ARRAY(ep_table->formatted_area, addr);

    ACPI_READ_ARRAY(ep_table->intermediate_anchor_string, addr);

    ACPI_READ_FIELD(data->qts, ep_table->checksum, addr);

    ACPI_READ_FIELD(data->qts, ep_table->length, addr);

    ACPI_READ_FIELD(data->qts, ep_table->smbios_major_version, addr);

    ACPI_READ_FIELD(data->qts, ep_table->smbios_minor_version, addr);

    ACPI_READ_FIELD(data->qts, ep_table->max_structure_size, addr);

    ACPI_READ_FIELD(data->qts, ep_table->entry_point_revision, addr);

    ACPI_READ_ARRAY(data->qts, ep_table->formatted_area, addr);

    ACPI_READ_ARRAY(data->qts, ep_table->intermediate_anchor_string, addr);

    if (memcmp(ep_table->intermediate_anchor_string, "_DMI_", 5)) {

        return false;

    }

    ACPI_READ_FIELD(ep_table->intermediate_checksum, addr);

    ACPI_READ_FIELD(ep_table->structure_table_length, addr);

    ACPI_READ_FIELD(data->qts, ep_table->intermediate_checksum, addr);

    ACPI_READ_FIELD(data->qts, ep_table->structure_table_length, addr);

    if (ep_table->structure_table_length == 0) {

        return false;

    }

    ACPI_READ_FIELD(ep_table->structure_table_address, addr);

    ACPI_READ_FIELD(ep_table->number_of_structures, addr);

    ACPI_READ_FIELD(data->qts, ep_table->structure_table_address, addr);

    ACPI_READ_FIELD(data->qts, ep_table->number_of_structures, addr);

    if (ep_table->number_of_structures == 0) {

        return false;

    }

    ACPI_READ_FIELD(ep_table->smbios_bcd_revision, addr);

    ACPI_READ_FIELD(data->qts, ep_table->smbios_bcd_revision, addr);

    if (acpi_calc_checksum((uint8_t *)ep_table, sizeof *ep_table) ||

        acpi_calc_checksum((uint8_t *)ep_table + 0x10,

                           sizeof *ep_table - 0x10)) {
@@ -526,7 +530,7 @@ static void test_smbios_entry_point(test_data *data) 
        int i;



        for (i = 0; i < sizeof sig - 1; ++i) {

            sig[i] = readb(off + i);

            sig[i] = qtest_readb(data->qts, off + i);

        }



        if (!memcmp(sig, "_SM_", sizeof sig)) {
@@ -569,9 +573,9 @@ static void test_smbios_structs(test_data *data) 
    for (i = 0; i < le16_to_cpu(ep_table->number_of_structures); i++) {



        /* grab type and formatted area length from struct header */

        type = readb(addr);

        type = qtest_readb(data->qts, addr);

        g_assert_cmpuint(type, <=, SMBIOS_MAX_TYPE);

        len = readb(addr + 1);

        len = qtest_readb(data->qts, addr + 1);



        /* single-instance structs must not have been encountered before */

        if (smbios_single_instance(type)) {
@@ -583,7 +587,7 @@ static void test_smbios_structs(test_data *data) 
        prv = crt = 1;

        while (prv || crt) {

            prv = crt;

            crt = readb(addr + len);

            crt = qtest_readb(data->qts, addr + len);

            len++;

        }
@@ -620,9 +624,9 @@ static void test_acpi_one(const char *params, test_data *data) 
                           data->machine, "kvm:tcg",

                           params ? params : "", disk);



    qtest_start(args);

    data->qts = qtest_init(args);



    boot_sector_test(global_qtest);

    boot_sector_test(data->qts);



    data->tables = g_array_new(false, true, sizeof(AcpiSdtTable));

    test_acpi_rsdp_address(data);
@@ -646,7 +650,8 @@ static void test_acpi_one(const char *params, test_data *data) 
    test_smbios_entry_point(data);

    test_smbios_structs(data);



    qtest_quit(global_qtest);

    assert(!global_qtest);

    qtest_quit(data->qts);

    g_free(args);

}

tests/boot-serial-test.c

+22 −11
Original line number Diff line number Diff line
@@ -128,13 +128,14 @@ static testdef_t tests[] = { 
    { NULL }

};



static bool check_guest_output(const testdef_t *test, int fd)

static bool check_guest_output(QTestState *qts, const testdef_t *test, int fd)

{

    int i, nbr = 0, pos = 0, ccnt;

    int nbr = 0, pos = 0, ccnt;

    time_t now, start = time(NULL);

    char ch;



    /* Poll serial output... Wait at most 360 seconds */

    for (i = 0; i < 36000; ++i) {

    /* Poll serial output... */

    while (1) {

        ccnt = 0;

        while (ccnt++ < 512 && (nbr = read(fd, &ch, 1)) == 1) {

            if (ch == test->expect[pos]) {
@@ -148,6 +149,15 @@ static bool check_guest_output(const testdef_t *test, int fd) 
            }

        }

        g_assert(nbr >= 0);

        /* Wait only if the child is still alive.  */

        if (!qtest_probe_child(qts)) {

            break;

        }

        /* Wait at most 360 seconds.  */

        now = time(NULL);

        if (now - start >= 360) {

            break;

        }

        g_usleep(10000);

    }
@@ -161,6 +171,7 @@ static void test_machine(const void *data) 
    char codetmp[] = "/tmp/qtest-boot-serial-cXXXXXX";

    const char *codeparam = "";

    const uint8_t *code = NULL;

    QTestState *qts;

    int ser_fd;



    ser_fd = mkstemp(serialtmp);
@@ -189,22 +200,22 @@ static void test_machine(const void *data) 
     * Make sure that this test uses tcg if available: It is used as a

     * fast-enough smoketest for that.

     */

    global_qtest = qtest_initf("%s %s -M %s,accel=tcg:kvm "

    qts = qtest_initf("%s %s -M %s,accel=tcg:kvm -no-shutdown "

                      "-chardev file,id=serial0,path=%s "

                               "-no-shutdown -serial chardev:serial0 %s",

                               codeparam, code ? codetmp : "",

                               test->machine, serialtmp, test->extra);

                      "-serial chardev:serial0 %s",

                      codeparam, code ? codetmp : "", test->machine,

                      serialtmp, test->extra);

    if (code) {

        unlink(codetmp);

    }



    if (!check_guest_output(test, ser_fd)) {

    if (!check_guest_output(qts, test, ser_fd)) {

        g_error("Failed to find expected string. Please check '%s'",

                serialtmp);

    }

    unlink(serialtmp);



    qtest_quit(global_qtest);

    qtest_quit(qts);



    close(ser_fd);

}

tests/ivshmem-test.c

+1 −17
Original line number Diff line number Diff line
@@ -71,13 +71,10 @@ static const char* reg2str(enum Reg reg) { 
static inline unsigned in_reg(IVState *s, enum Reg reg)

{

    const char *name = reg2str(reg);

    QTestState *qtest = global_qtest;

    unsigned res;



    global_qtest = s->qs->qts;

    res = qpci_io_readl(s->dev, s->reg_bar, reg);

    g_test_message("*%s -> %x\n", name, res);

    global_qtest = qtest;



    return res;

}
@@ -85,35 +82,25 @@ static inline unsigned in_reg(IVState *s, enum Reg reg) 
static inline void out_reg(IVState *s, enum Reg reg, unsigned v)

{

    const char *name = reg2str(reg);

    QTestState *qtest = global_qtest;



    global_qtest = s->qs->qts;

    g_test_message("%x -> *%s\n", v, name);

    qpci_io_writel(s->dev, s->reg_bar, reg, v);

    global_qtest = qtest;

}



static inline void read_mem(IVState *s, uint64_t off, void *buf, size_t len)

{

    QTestState *qtest = global_qtest;



    global_qtest = s->qs->qts;

    qpci_memread(s->dev, s->mem_bar, off, buf, len);

    global_qtest = qtest;

}



static inline void write_mem(IVState *s, uint64_t off,

                             const void *buf, size_t len)

{

    QTestState *qtest = global_qtest;



    global_qtest = s->qs->qts;

    qpci_memwrite(s->dev, s->mem_bar, off, buf, len);

    global_qtest = qtest;

}



static void cleanup_vm(IVState *s)

{

    assert(!global_qtest);

    g_free(s->dev);

    qtest_shutdown(s->qs);

}
@@ -131,7 +118,6 @@ static void setup_vm_cmd(IVState *s, const char *cmd, bool msix) 
        g_printerr("ivshmem-test tests are only available on x86 or ppc64\n");

        exit(EXIT_FAILURE);

    }

    global_qtest = s->qs->qts;

    s->dev = get_device(s->qs->pcibus);



    s->reg_bar = qpci_iomap(s->dev, 0, &barsize);
@@ -354,7 +340,6 @@ static void test_ivshmem_server(bool msi) 
    g_assert_cmpint(vm1, !=, vm2);



    /* check number of MSI-X vectors */

    global_qtest = s1->qs->qts;

    if (msi) {

        ret = qpci_msix_table_size(s1->dev);

        g_assert_cmpuint(ret, ==, nvectors);
@@ -377,7 +362,6 @@ static void test_ivshmem_server(bool msi) 
    g_assert_cmpuint(ret, !=, 0);



    /* ping vm1 -> vm2 on vector 1 */

    global_qtest = s2->qs->qts;

    if (msi) {

        ret = qpci_msix_pending(s2->dev, 1);

        g_assert_cmpuint(ret, ==, 0);