qemuxml2xmltest.c 43.5 KB
Newer Older
1
#include <config.h>
2

3
#include <stdio.h>
4 5
#include <stdlib.h>
#include <unistd.h>
6 7 8 9 10
#include <string.h>

#include <sys/types.h>
#include <fcntl.h>

11 12
#include "testutils.h"

13 14
#ifdef WITH_QEMU

15
# include "internal.h"
J
Ján Tomko 已提交
16
# include "qemu/qemu_domain_address.h"
M
Matthias Bolte 已提交
17
# include "qemu/qemu_domain.h"
18
# include "testutilsqemu.h"
19
# include "virstring.h"
20

21 22
# define VIR_FROM_THIS VIR_FROM_NONE

23
static virQEMUDriver driver;
24

25 26 27 28 29 30 31 32 33 34
enum {
    WHEN_INACTIVE = 1,
    WHEN_ACTIVE = 2,
    WHEN_BOTH = 3,
};

struct testInfo {
    char *inName;
    char *outActiveName;
    char *outInactiveName;
35

36 37
    virBitmapPtr activeVcpus;

38
    virQEMUCapsPtr qemuCaps;
39 40
};

41
static int
42 43
qemuXML2XMLActivePreFormatCallback(virDomainDefPtr def,
                                   const void *opaque)
44
{
45 46 47 48 49 50
    struct testInfo *info = (struct testInfo *) opaque;

    /* store vCPU bitmap so that the status XML can be created faithfully */
    if (!info->activeVcpus)
        info->activeVcpus = virDomainDefGetOnlineVcpumap(def);

51 52 53
    return 0;
}

54 55 56 57 58
static int
testXML2XMLActive(const void *opaque)
{
    const struct testInfo *info = opaque;

59
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt,
60
                                      info->inName, info->outActiveName, true,
61 62
                                      qemuXML2XMLActivePreFormatCallback,
                                      opaque, 0,
63
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
64 65
}

66

67
static int
68
testXML2XMLInactive(const void *opaque)
69
{
70 71
    const struct testInfo *info = opaque;

72
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt, info->inName,
73
                                      info->outInactiveName, false,
74
                                      NULL, opaque, 0,
75
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
76
}
77

78

79
static const char testStatusXMLPrefixHeader[] =
80 81
"<domstatus state='running' reason='booted' pid='3803518'>\n"
"  <taint flag='high-privileges'/>\n"
82 83 84
"  <monitor path='/var/lib/libvirt/qemu/test.monitor' json='1' type='unix'/>\n";

static const char testStatusXMLPrefixFooter[] =
85 86 87 88 89 90 91 92 93 94 95 96
"  <qemuCaps>\n"
"    <flag name='vnet-hdr'/>\n"
"    <flag name='qxl.vgamem_mb'/>\n"
"    <flag name='qxl-vga.vgamem_mb'/>\n"
"    <flag name='pc-dimm'/>\n"
"  </qemuCaps>\n"
"  <devices>\n"
"    <device alias='balloon0'/>\n"
"    <device alias='video0'/>\n"
"    <device alias='serial0'/>\n"
"    <device alias='net0'/>\n"
"    <device alias='usb'/>\n"
97
"  </devices>\n"
98
"  <numad nodeset='0-2' cpuset='1,3'/>\n"
99 100
"  <libDir path='/tmp'/>\n"
"  <channelTargetDir path='/tmp/channel'/>\n";
101 102 103 104 105

static const char testStatusXMLSuffix[] =
"</domstatus>\n";


106 107 108 109 110 111 112 113 114
static void
testGetStatuXMLPrefixVcpus(virBufferPtr buf,
                           const struct testInfo *data)
{
    ssize_t vcpuid = -1;

    virBufferAddLit(buf, "<vcpus>\n");
    virBufferAdjustIndent(buf, 2);

115 116 117 118 119 120
    /* Make sure we can format the fake vcpu list. The test will fail regardles. */
    if (data->activeVcpus) {
        while ((vcpuid = virBitmapNextSetBit(data->activeVcpus, vcpuid)) >= 0)
            virBufferAsprintf(buf, "<vcpu id='%zd' pid='%zd'/>\n",
                              vcpuid, vcpuid + 3803519);
    }
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143

    virBufferAdjustIndent(buf, -2);
    virBufferAddLit(buf, "</vcpus>\n");
}


static char *
testGetStatusXMLPrefix(const struct testInfo *data)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    virBufferAdd(&buf, testStatusXMLPrefixHeader, -1);
    virBufferAdjustIndent(&buf, 2);

    testGetStatuXMLPrefixVcpus(&buf, data);

    virBufferAdjustIndent(&buf, -2);
    virBufferAdd(&buf, testStatusXMLPrefixFooter, -1);

    return virBufferContentAndReset(&buf);
}


144 145 146 147 148 149 150 151 152 153
static int
testCompareStatusXMLToXMLFiles(const void *opaque)
{
    const struct testInfo *data = opaque;
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    xmlDocPtr xml = NULL;
    virDomainObjPtr obj = NULL;
    char *expect = NULL;
    char *actual = NULL;
    char *source = NULL;
154
    char *header = NULL;
155
    char *inFile = NULL, *outActiveFile = NULL;
156 157 158
    int ret = -1;
    int keepBlanksDefault = xmlKeepBlanksDefault(0);

159
    if (virTestLoadFile(data->inName, &inFile) < 0)
160
        goto cleanup;
161
    if (virTestLoadFile(data->outActiveName, &outActiveFile) < 0)
162 163
        goto cleanup;

164 165 166
    if (!(header = testGetStatusXMLPrefix(data)))
        goto cleanup;

167
    /* construct faked source status XML */
168
    virBufferAdd(&buf, header, -1);
169
    virBufferAdjustIndent(&buf, 2);
170
    virBufferAddStr(&buf, inFile);
171 172 173 174
    virBufferAdjustIndent(&buf, -2);
    virBufferAdd(&buf, testStatusXMLSuffix, -1);

    if (!(source = virBufferContentAndReset(&buf))) {
175
        VIR_TEST_DEBUG("Failed to create the source XML");
176 177 178 179
        goto cleanup;
    }

    /* construct the expect string */
180
    virBufferAdd(&buf, header, -1);
181
    virBufferAdjustIndent(&buf, 2);
182
    virBufferAddStr(&buf, outActiveFile);
183 184 185 186
    virBufferAdjustIndent(&buf, -2);
    virBufferAdd(&buf, testStatusXMLSuffix, -1);

    if (!(expect = virBufferContentAndReset(&buf))) {
187
        VIR_TEST_DEBUG("Failed to create the expect XML");
188 189 190 191 192 193 194 195 196
        goto cleanup;
    }

    /* parse the fake source status XML */
    if (!(xml = virXMLParseString(source, "(domain_status_test_XML)")) ||
        !(obj = virDomainObjParseNode(xml, xmlDocGetRootElement(xml),
                                      driver.caps, driver.xmlopt,
                                      VIR_DOMAIN_DEF_PARSE_STATUS |
                                      VIR_DOMAIN_DEF_PARSE_ACTUAL_NET |
197
                                      VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES))) {
198
        VIR_TEST_DEBUG("Failed to parse domain status XML:\n%s", source);
199 200 201 202
        goto cleanup;
    }

    /* format it back */
203
    if (!(actual = virDomainObjFormat(driver.xmlopt, obj, NULL,
204
                                      VIR_DOMAIN_DEF_FORMAT_SECURE))) {
205
        VIR_TEST_DEBUG("Failed to format domain status XML");
206 207 208 209
        goto cleanup;
    }

    if (STRNEQ(actual, expect)) {
210 211
        /* For status test we don't want to regenerate output to not
         * add the status data.*/
212 213 214
        virTestDifferenceFullNoRegenerate(stderr,
                                          expect, data->outActiveName,
                                          actual, data->inName);
215 216 217 218 219 220 221 222 223 224 225 226
        goto cleanup;
    }

    ret = 0;

 cleanup:
    xmlKeepBlanksDefault(keepBlanksDefault);
    xmlFreeDoc(xml);
    virObjectUnref(obj);
    VIR_FREE(expect);
    VIR_FREE(actual);
    VIR_FREE(source);
227
    VIR_FREE(inFile);
228
    VIR_FREE(header);
229
    VIR_FREE(outActiveFile);
230 231 232 233
    return ret;
}


234 235 236 237 238 239
static void
testInfoFree(struct testInfo *info)
{
    VIR_FREE(info->inName);
    VIR_FREE(info->outActiveName);
    VIR_FREE(info->outInactiveName);
240

241 242 243
    virBitmapFree(info->activeVcpus);
    info->activeVcpus = NULL;

244
    virObjectUnref(info->qemuCaps);
245 246 247 248 249 250
}


static int
testInfoSet(struct testInfo *info,
            const char *name,
251 252
            int when,
            int gic)
253
{
254 255 256
    if (!(info->qemuCaps = virQEMUCapsNew()))
        goto error;

257 258 259
    if (testQemuCapsSetGIC(info->qemuCaps, gic) < 0)
        goto error;

260
    if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
261 262
        goto error;

263 264 265 266 267
    if (virAsprintf(&info->inName, "%s/qemuxml2argvdata/qemuxml2argv-%s.xml",
                    abs_srcdir, name) < 0)
        goto error;

    if (when & WHEN_INACTIVE) {
268 269 270 271
        if (virAsprintf(&info->outInactiveName,
                        "%s/qemuxml2xmloutdata/qemuxml2xmlout-%s-inactive.xml",
                        abs_srcdir, name) < 0)
            goto error;
272

273 274
        if (!virFileExists(info->outInactiveName)) {
            VIR_FREE(info->outInactiveName);
275

276 277 278
            if (virAsprintf(&info->outInactiveName,
                            "%s/qemuxml2xmloutdata/qemuxml2xmlout-%s.xml",
                            abs_srcdir, name) < 0)
279 280
                goto error;
        }
281
    }
282

283
    if (when & WHEN_ACTIVE) {
284 285 286 287
        if (virAsprintf(&info->outActiveName,
                        "%s/qemuxml2xmloutdata/qemuxml2xmlout-%s-active.xml",
                        abs_srcdir, name) < 0)
            goto error;
288

289 290
        if (!virFileExists(info->outActiveName)) {
            VIR_FREE(info->outActiveName);
291

292 293 294
            if (virAsprintf(&info->outActiveName,
                            "%s/qemuxml2xmloutdata/qemuxml2xmlout-%s.xml",
                            abs_srcdir, name) < 0)
295 296
                goto error;
        }
297
    }
298

299
    return 0;
300

301 302 303
 error:
    testInfoFree(info);
    return -1;
304 305
}

A
Andrea Bolognani 已提交
306
# define FAKEROOTDIRTEMPLATE abs_builddir "/fakerootdir-XXXXXX"
307

308
static int
E
Eric Blake 已提交
309
mymain(void)
310 311
{
    int ret = 0;
A
Andrea Bolognani 已提交
312
    char *fakerootdir;
313
    struct testInfo info;
314
    virQEMUDriverConfigPtr cfg = NULL;
315

A
Andrea Bolognani 已提交
316 317 318 319 320 321 322 323 324 325 326 327
    if (VIR_STRDUP_QUIET(fakerootdir, FAKEROOTDIRTEMPLATE) < 0) {
        fprintf(stderr, "Out of memory\n");
        abort();
    }

    if (!mkdtemp(fakerootdir)) {
        fprintf(stderr, "Cannot create fakerootdir");
        abort();
    }

    setenv("LIBVIRT_FAKE_ROOT_DIR", fakerootdir, 1);

328 329
    memset(&info, 0, sizeof(info));

330
    if (qemuTestDriverInit(&driver) < 0)
331
        return EXIT_FAILURE;
332

333 334
    cfg = virQEMUDriverGetConfig(&driver);

335 336
    /* TODO: test with format probing disabled too */
    driver.config->allowDiskFormatProbing = true;
337

338
# define DO_TEST_FULL(name, when, gic, ...)                                    \
339
    do {                                                                       \
340
        if (testInfoSet(&info, name, when, gic) < 0) {                         \
341
            VIR_TEST_DEBUG("Failed to generate test data for '%s'", name);     \
342 343
            return -1;                                                         \
        }                                                                      \
344
        virQEMUCapsSetList(info.qemuCaps, __VA_ARGS__, QEMU_CAPS_LAST);        \
345 346
                                                                               \
        if (info.outInactiveName) {                                            \
347
            if (virTestRun("QEMU XML-2-XML-inactive " name,                    \
348 349 350 351 352
                            testXML2XMLInactive, &info) < 0)                   \
                ret = -1;                                                      \
        }                                                                      \
                                                                               \
        if (info.outActiveName) {                                              \
353
            if (virTestRun("QEMU XML-2-XML-active " name,                      \
354
                            testXML2XMLActive, &info) < 0)                     \
355 356
                ret = -1;                                                      \
                                                                               \
357
            if (virTestRun("QEMU XML-2-XML-status " name,                      \
358
                            testCompareStatusXMLToXMLFiles, &info) < 0)        \
359 360 361
                ret = -1;                                                      \
        }                                                                      \
        testInfoFree(&info);                                                   \
362 363
    } while (0)

364 365
# define NONE QEMU_CAPS_LAST

366 367
# define DO_TEST(name, ...) \
    DO_TEST_FULL(name, WHEN_BOTH, GIC_NONE, __VA_ARGS__)
368 369


370 371 372 373 374

    /* Unset or set all envvars here that are copied in qemudBuildCommandLine
     * using ADD_ENV_COPY, otherwise these tests may fail due to unexpected
     * values for these envvars */
    setenv("PATH", "/bin", 1);
375

376 377 378
    DO_TEST("minimal", NONE);
    DO_TEST("machine-core-on", NONE);
    DO_TEST("machine-core-off", NONE);
379
    DO_TEST("machine-loadparm-multiple-disks-nets-s390", NONE);
380 381 382 383 384
    DO_TEST("default-kvm-host-arch", NONE);
    DO_TEST("default-qemu-host-arch", NONE);
    DO_TEST("boot-cdrom", NONE);
    DO_TEST("boot-network", NONE);
    DO_TEST("boot-floppy", NONE);
385 386 387 388 389 390 391
    DO_TEST("boot-floppy-q35",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI);
    DO_TEST("bootindex-floppy-q35",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI, QEMU_CAPS_BOOT_MENU,
            QEMU_CAPS_BOOTINDEX);
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
    DO_TEST("boot-multi", NONE);
    DO_TEST("boot-menu-enable-with-timeout", NONE);
    DO_TEST("boot-menu-disable", NONE);
    DO_TEST("boot-menu-disable-with-timeout", NONE);
    DO_TEST("boot-order", NONE);

    DO_TEST("reboot-timeout-enabled", NONE);
    DO_TEST("reboot-timeout-disabled", NONE);

    DO_TEST("clock-utc", NONE);
    DO_TEST("clock-localtime", NONE);
    DO_TEST("cpu-empty", NONE);
    DO_TEST("cpu-kvmclock", NONE);
    DO_TEST("cpu-host-kvmclock", NONE);
    DO_TEST("cpu-host-passthrough-features", NONE);
    DO_TEST("cpu-host-model-features", NONE);
    DO_TEST("clock-catchup", NONE);
    DO_TEST("kvmclock", NONE);
    DO_TEST("clock-timer-hyperv-rtc", NONE);

    DO_TEST("cpu-eoi-disabled", NONE);
    DO_TEST("cpu-eoi-enabled", NONE);
    DO_TEST("eoi-disabled", NONE);
    DO_TEST("eoi-enabled", NONE);
    DO_TEST("pv-spinlock-disabled", NONE);
    DO_TEST("pv-spinlock-enabled", NONE);

    DO_TEST("hyperv", NONE);
    DO_TEST("hyperv-off", NONE);
    DO_TEST("hyperv-panic", NONE);

    DO_TEST("kvm-features", NONE);
    DO_TEST("kvm-features-off", NONE);

    DO_TEST("pmu-feature", NONE);
    DO_TEST("pmu-feature-off", NONE);

    DO_TEST("hugepages", NONE);
    DO_TEST("hugepages-pages", NONE);
    DO_TEST("hugepages-pages2", NONE);
    DO_TEST("hugepages-pages3", NONE);
433 434 435
    DO_TEST("hugepages-pages4", NONE);
    DO_TEST("hugepages-pages5", NONE);
    DO_TEST("hugepages-pages6", NONE);
436
    DO_TEST("hugepages-shared", NONE);
437
    DO_TEST("hugepages-memaccess", NONE);
438
    DO_TEST("hugepages-memaccess2", NONE);
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
    DO_TEST("nosharepages", NONE);
    DO_TEST("restore-v2", NONE);
    DO_TEST("migrate", NONE);
    DO_TEST("qemu-ns-no-env", NONE);
    DO_TEST("disk-aio", NONE);
    DO_TEST("disk-cdrom", NONE);
    DO_TEST("disk-cdrom-empty", NONE);
    DO_TEST("disk-floppy", NONE);
    DO_TEST("disk-many", NONE);
    DO_TEST("disk-usb-device", NONE);
    DO_TEST("disk-virtio", NONE);
    DO_TEST("floppy-drive-fat", NONE);
    DO_TEST("disk-drive-boot-disk", NONE);
    DO_TEST("disk-drive-boot-cdrom", NONE);
    DO_TEST("disk-drive-error-policy-stop", NONE);
    DO_TEST("disk-drive-error-policy-enospace", NONE);
    DO_TEST("disk-drive-error-policy-wreport-rignore", NONE);
    DO_TEST("disk-drive-fmt-qcow", NONE);
    DO_TEST("disk-drive-copy-on-read", NONE);
    DO_TEST("disk-drive-cache-v2-wt", NONE);
    DO_TEST("disk-drive-cache-v2-wb", NONE);
    DO_TEST("disk-drive-cache-v2-none", NONE);
    DO_TEST("disk-drive-cache-directsync", NONE);
    DO_TEST("disk-drive-cache-unsafe", NONE);
    DO_TEST("disk-drive-network-nbd", NONE);
    DO_TEST("disk-drive-network-nbd-export", NONE);
    DO_TEST("disk-drive-network-nbd-ipv6", NONE);
    DO_TEST("disk-drive-network-nbd-ipv6-export", NONE);
    DO_TEST("disk-drive-network-nbd-unix", NONE);
    DO_TEST("disk-drive-network-iscsi", NONE);
    DO_TEST("disk-drive-network-iscsi-auth", NONE);
    DO_TEST("disk-drive-network-gluster", NONE);
    DO_TEST("disk-drive-network-rbd", NONE);
    DO_TEST("disk-drive-network-rbd-auth", NONE);
    DO_TEST("disk-drive-network-rbd-ipv6", NONE);
    DO_TEST("disk-drive-network-rbd-ceph-env", NONE);
    DO_TEST("disk-drive-network-sheepdog", NONE);
476 477
    DO_TEST("disk-scsi-device",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_SCSI_LSI);
478
    DO_TEST("disk-scsi-vscsi", NONE);
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
    DO_TEST("disk-scsi-virtio-scsi",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("disk-virtio-scsi-num_queues",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("disk-virtio-scsi-cmd_per_lun",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("disk-virtio-scsi-max_sectors",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("disk-virtio-scsi-ioeventfd",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("disk-scsi-megasas",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_SCSI_MEGASAS);
    DO_TEST("disk-scsi-mptsas1068",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_SCSI_MPTSAS1068,
            QEMU_CAPS_SCSI_DISK_WWN);
494
    DO_TEST("disk-mirror-old", NONE);
495
    DO_TEST("disk-mirror", NONE);
496
    DO_TEST_FULL("disk-active-commit", WHEN_ACTIVE, GIC_NONE, NONE);
497 498 499 500 501 502 503
    DO_TEST("graphics-listen-network", NONE);
    DO_TEST("graphics-vnc", NONE);
    DO_TEST("graphics-vnc-websocket", NONE);
    DO_TEST("graphics-vnc-sasl", NONE);
    DO_TEST("graphics-vnc-tls", NONE);
    DO_TEST("graphics-vnc-no-listen-attr", NONE);
    DO_TEST("graphics-vnc-remove-generated-socket", NONE);
504
    cfg->vncAutoUnixSocket = true;
505
    DO_TEST("graphics-vnc-auto-socket-cfg", NONE);
506
    cfg->vncAutoUnixSocket = false;
507 508 509 510 511 512 513 514 515 516
    DO_TEST("graphics-vnc-socket", NONE);
    DO_TEST("graphics-vnc-auto-socket", NONE);

    DO_TEST("graphics-sdl", NONE);
    DO_TEST("graphics-sdl-fullscreen", NONE);
    DO_TEST("graphics-spice", NONE);
    DO_TEST("graphics-spice-compression", NONE);
    DO_TEST("graphics-spice-qxl-vga", NONE);
    DO_TEST("graphics-spice-socket", NONE);
    DO_TEST("graphics-spice-auto-socket", NONE);
517
    cfg->spiceAutoUnixSocket = true;
518
    DO_TEST("graphics-spice-auto-socket-cfg", NONE);
519 520
    cfg->spiceAutoUnixSocket = false;

521 522
    DO_TEST("nographics-vga",
            QEMU_CAPS_DISPLAY);
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
    DO_TEST("input-usbmouse", NONE);
    DO_TEST("input-usbtablet", NONE);
    DO_TEST("misc-acpi", NONE);
    DO_TEST("misc-disable-s3", NONE);
    DO_TEST("misc-disable-suspends", NONE);
    DO_TEST("misc-enable-s4", NONE);
    DO_TEST("misc-no-reboot", NONE);
    DO_TEST("misc-uuid", NONE);
    DO_TEST("net-vhostuser", NONE);
    DO_TEST("net-user", NONE);
    DO_TEST("net-virtio", NONE);
    DO_TEST("net-virtio-device", NONE);
    DO_TEST("net-virtio-disable-offloads", NONE);
    DO_TEST("net-eth", NONE);
    DO_TEST("net-eth-ifname", NONE);
    DO_TEST("net-eth-hostip", NONE);
    DO_TEST("net-virtio-network-portgroup", NONE);
540
    DO_TEST("net-virtio-rxqueuesize", NONE);
541 542 543 544 545 546 547 548 549
    DO_TEST("net-hostdev", NONE);
    DO_TEST("net-hostdev-vfio", NONE);
    DO_TEST("net-midonet", NONE);
    DO_TEST("net-openvswitch", NONE);
    DO_TEST("sound", NONE);
    DO_TEST("sound-device", NONE);
    DO_TEST("watchdog", NONE);
    DO_TEST("net-bandwidth", NONE);
    DO_TEST("net-bandwidth2", NONE);
550
    DO_TEST("net-mtu", NONE);
551
    DO_TEST("net-coalesce", NONE);
552

553
    DO_TEST("serial-tcp-tlsx509-chardev", NONE);
554
    DO_TEST("serial-tcp-tlsx509-chardev-notls", NONE);
555 556 557 558 559 560 561 562 563
    DO_TEST("serial-spiceport", NONE);
    DO_TEST("serial-spiceport-nospice", NONE);
    DO_TEST("console-compat", NONE);
    DO_TEST("console-compat2", NONE);
    DO_TEST("console-virtio-many", NONE);
    DO_TEST("channel-guestfwd", NONE);
    DO_TEST("channel-virtio", NONE);
    DO_TEST("channel-virtio-state", NONE);

564 565
    DO_TEST_FULL("channel-unix-source-path", WHEN_INACTIVE, GIC_NONE, NONE);

566 567 568
    DO_TEST("hostdev-usb-address", NONE);
    DO_TEST("hostdev-pci-address", NONE);
    DO_TEST("hostdev-vfio", NONE);
569
    DO_TEST("hostdev-mdev-precreated", NONE);
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
    DO_TEST("pci-rom", NONE);
    DO_TEST("pci-serial-dev-chardev", NONE);

    DO_TEST("encrypted-disk", NONE);
    DO_TEST("encrypted-disk-usage", NONE);
    DO_TEST("luks-disks", NONE);
    DO_TEST("memtune", NONE);
    DO_TEST("memtune-unlimited", NONE);
    DO_TEST("blkiotune", NONE);
    DO_TEST("blkiotune-device", NONE);
    DO_TEST("cputune", NONE);
    DO_TEST("cputune-zero-shares", NONE);
    DO_TEST("cputune-iothreadsched", NONE);
    DO_TEST("cputune-iothreadsched-zeropriority", NONE);
    DO_TEST("cputune-numatune", NONE);
585
    DO_TEST("vcpu-placement-static",
586 587
            QEMU_CAPS_KVM,
            QEMU_CAPS_OBJECT_IOTHREAD);
588

589 590 591 592 593 594
    DO_TEST("smp", NONE);
    DO_TEST("iothreads", NONE);
    DO_TEST("iothreads-ids", NONE);
    DO_TEST("iothreads-ids-partial", NONE);
    DO_TEST("cputune-iothreads", NONE);
    DO_TEST("iothreads-disk", NONE);
595 596 597 598 599 600 601
    DO_TEST("iothreads-disk-virtio-ccw",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("iothreads-virtio-scsi-pci",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("iothreads-virtio-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_VIRTIO_CCW,
            QEMU_CAPS_VIRTIO_S390);
602 603 604 605 606 607 608
    DO_TEST("lease", NONE);
    DO_TEST("event_idx", NONE);
    DO_TEST("vhost_queues", NONE);
    DO_TEST("interface-driver", NONE);
    DO_TEST("interface-server", NONE);
    DO_TEST("virtio-lun", NONE);

609 610 611 612 613
    DO_TEST("usb-none", NONE);
    DO_TEST("usb-controller", NONE);
    DO_TEST("usb-piix3-controller",
            QEMU_CAPS_PIIX3_USB_UHCI);
    DO_TEST("usb-controller-default-q35",
614
            QEMU_CAPS_DEVICE_IOH3420,
615 616
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
617 618
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("usb-controller-explicit-q35",
619
            QEMU_CAPS_DEVICE_IOH3420,
620 621
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
622 623 624 625 626
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("ppc64-usb-controller",
            QEMU_CAPS_PCI_OHCI);
    DO_TEST("ppc64-usb-controller-legacy",
            QEMU_CAPS_PIIX3_USB_UHCI);
627 628 629 630 631
    DO_TEST("usb-port-missing", NONE);
    DO_TEST("usb-redir", NONE);
    DO_TEST("usb-redir-filter", NONE);
    DO_TEST("usb-redir-filter-version", NONE);
    DO_TEST("blkdeviotune", NONE);
632
    DO_TEST("blkdeviotune-max", NONE);
633
    DO_TEST("blkdeviotune-group-num", NONE);
634
    DO_TEST("blkdeviotune-max-length", NONE);
635
    DO_TEST("controller-usb-order", NONE);
636

637 638 639 640
    DO_TEST_FULL("seclabel-dynamic-baselabel", WHEN_INACTIVE, GIC_NONE, NONE);
    DO_TEST_FULL("seclabel-dynamic-override", WHEN_INACTIVE, GIC_NONE, NONE);
    DO_TEST_FULL("seclabel-dynamic-labelskip", WHEN_INACTIVE, GIC_NONE, NONE);
    DO_TEST_FULL("seclabel-dynamic-relabel", WHEN_INACTIVE, GIC_NONE, NONE);
641
    DO_TEST("seclabel-static", NONE);
642
    DO_TEST_FULL("seclabel-static-labelskip", WHEN_ACTIVE, GIC_NONE, NONE);
643 644 645 646
    DO_TEST("seclabel-none", NONE);
    DO_TEST("seclabel-dac-none", NONE);
    DO_TEST("seclabel-dynamic-none", NONE);
    DO_TEST("seclabel-device-multiple", NONE);
647
    DO_TEST_FULL("seclabel-dynamic-none-relabel", WHEN_INACTIVE, GIC_NONE, NONE);
648
    DO_TEST("numad-static-vcpu-no-numatune", NONE);
649

650 651 652 653 654 655
    DO_TEST("disk-scsi-lun-passthrough-sgio",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
    DO_TEST("disk-scsi-disk-vpd",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
656 657
    DO_TEST("disk-source-pool", NONE);
    DO_TEST("disk-source-pool-mode", NONE);
658

659 660
    DO_TEST("disk-drive-discard", NONE);
    DO_TEST("disk-drive-detect-zeroes", NONE);
O
Osier Yang 已提交
661

662 663
    DO_TEST("virtio-rng-random", NONE);
    DO_TEST("virtio-rng-egd", NONE);
664

665 666 667
    DO_TEST("pseries-nvram", NONE);
    DO_TEST("pseries-panic-missing", NONE);
    DO_TEST("pseries-panic-no-address", NONE);
668

669 670 671 672 673 674
    DO_TEST("pseries-phb-simple",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
    DO_TEST("pseries-phb-default-missing",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
675 676 677 678
    DO_TEST("pseries-phb-numa-node",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE);
679

680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
    DO_TEST("pseries-many-devices",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-many-buses-1",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-many-buses-2",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-hostdevs-1",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_HOST_PCI_MULTIDOMAIN,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("pseries-hostdevs-2",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_HOST_PCI_MULTIDOMAIN,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("pseries-hostdevs-3",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_HOST_PCI_MULTIDOMAIN,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);

711 712 713 714
    DO_TEST("balloon-device-auto", NONE);
    DO_TEST("balloon-device-period", NONE);
    DO_TEST("channel-virtio-auto", NONE);
    DO_TEST("console-compat-auto", NONE);
715 716
    DO_TEST("disk-scsi-device-auto",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_SCSI_LSI);
717 718 719 720 721 722 723 724 725 726 727 728 729
    DO_TEST("console-virtio", NONE);
    DO_TEST("serial-target-port-auto", NONE);
    DO_TEST("graphics-listen-network2", NONE);
    DO_TEST("graphics-spice-timeout", NONE);
    DO_TEST("numad-auto-vcpu-no-numatune", NONE);
    DO_TEST("numad-auto-memory-vcpu-no-cpuset-and-placement", NONE);
    DO_TEST("numad-auto-memory-vcpu-cpuset", NONE);
    DO_TEST("usb-ich9-ehci-addr", NONE);
    DO_TEST("disk-copy_on_read", NONE);
    DO_TEST("tpm-passthrough", NONE);

    DO_TEST("metadata", NONE);
    DO_TEST("metadata-duplicate", NONE);
730

731
    DO_TEST("pci-bridge",
732 733 734 735 736
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-many",
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
737 738 739
    DO_TEST("pci-bridge-many-disks",
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
    DO_TEST("pci-autoadd-addr",
740 741
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
742
    DO_TEST("pci-autoadd-idx",
743 744
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
745
    DO_TEST("pci-autofill-addr", NONE);
746

747
    DO_TEST("q35",
748 749
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
750
            QEMU_CAPS_DEVICE_IOH3420,
751 752 753 754
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
755
            QEMU_CAPS_DEVICE_QXL);
756 757 758
    DO_TEST("q35-usb2",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
759
            QEMU_CAPS_DEVICE_IOH3420,
760
            QEMU_CAPS_ICH9_AHCI,
761 762
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
763
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
764
            QEMU_CAPS_DEVICE_QXL);
765
    DO_TEST("q35-usb2-multi",
766 767
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
768
            QEMU_CAPS_DEVICE_IOH3420,
769 770 771 772
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
773
            QEMU_CAPS_DEVICE_QXL);
774
    DO_TEST("q35-usb2-reorder",
775 776
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
777
            QEMU_CAPS_DEVICE_IOH3420,
778 779 780 781
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
782
            QEMU_CAPS_DEVICE_QXL);
783 784 785 786
    DO_TEST("q35-pcie",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
787
            QEMU_CAPS_NETDEV,
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_FSDEV,
            QEMU_CAPS_FSDEV_WRITEOUT,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
804
            QEMU_CAPS_NEC_USB_XHCI,
805 806 807 808 809 810
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    /* same XML as q35-pcie, but don't set
       QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY */
    DO_TEST("q35-virtio-pci",
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
811
            QEMU_CAPS_NETDEV,
812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_FSDEV,
            QEMU_CAPS_FSDEV_WRITEOUT,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
828
            QEMU_CAPS_NEC_USB_XHCI,
829
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
830 831 832 833 834 835 836 837 838 839
    /* same as q35-pcie, but all PCI controllers are added automatically */
    DO_TEST("q35-pcie-autoadd",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_NETDEV,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_FSDEV,
            QEMU_CAPS_FSDEV_WRITEOUT,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    DO_TEST("q35-default-devices-only",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_NETDEV,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
863 864 865 866 867 868 869 870 871 872 873 874 875
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_FSDEV,
            QEMU_CAPS_FSDEV_WRITEOUT,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    DO_TEST("q35-multifunction",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_NETDEV,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_FSDEV,
            QEMU_CAPS_FSDEV_WRITEOUT,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
899
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
900
    DO_TEST("q35-virt-manager-basic",
901 902 903 904 905
            QEMU_CAPS_KVM,
            QEMU_CAPS_RTC,
            QEMU_CAPS_NO_KVM_PIT,
            QEMU_CAPS_ICH9_DISABLE_S3,
            QEMU_CAPS_ICH9_DISABLE_S4,
906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_NETDEV,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_FSDEV,
            QEMU_CAPS_FSDEV_WRITEOUT,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_ICH9_INTEL_HDA,
928 929 930 931 932 933
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_CHARDEV_SPICEVMC,
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_HDA_DUPLEX,
            QEMU_CAPS_USB_REDIR);
934
    DO_TEST("pcie-root",
935 936
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
937
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
938
            QEMU_CAPS_DEVICE_QXL);
939 940

    /* Test automatic and manual setting of pcie-root-port attributes */
941
    DO_TEST("pcie-root-port",
942 943
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
944
            QEMU_CAPS_PCI_MULTIFUNCTION,
945
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
946
            QEMU_CAPS_DEVICE_QXL);
947 948 949 950 951 952 953 954 955 956 957 958

    /* Make sure the default model for PCIe Root Ports is picked correctly
     * based on QEMU binary capabilities. We use x86/q35 for the test, but
     * any PCIe machine type (such as aarch64/virt) will behave the same */
    DO_TEST("pcie-root-port-model-generic",
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_PCI_MULTIFUNCTION);
    DO_TEST("pcie-root-port-model-ioh3420",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_PCI_MULTIFUNCTION);

959
    DO_TEST("pcie-switch-upstream-port",
960 961 962
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_ICH9_AHCI,
963
            QEMU_CAPS_PCI_MULTIFUNCTION,
964
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
965
            QEMU_CAPS_DEVICE_QXL);
966
    DO_TEST("pcie-switch-downstream-port",
967 968 969 970
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_ICH9_AHCI,
971
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
972
            QEMU_CAPS_DEVICE_QXL);
973
    DO_TEST("pci-expander-bus",
974
            QEMU_CAPS_DEVICE_PXB);
975
    DO_TEST("pcie-expander-bus",
976 977 978 979
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_DEVICE_PXB_PCIE);
980
    DO_TEST("autoindex",
981 982 983 984 985 986 987 988
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
989
            QEMU_CAPS_NEC_USB_XHCI);
990 991 992 993 994 995 996
    /* Make sure the user can always override libvirt's default device
     * placement policy by providing an explicit PCI address */
    DO_TEST("q35-pci-force-address",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_HDA_DUPLEX);
997

998 999 1000 1001 1002 1003
    DO_TEST("hostdev-scsi-vhost-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC, QEMU_CAPS_VIRTIO_CCW);
    DO_TEST("hostdev-scsi-vhost-scsi-pci",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
    DO_TEST("hostdev-scsi-lsi",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-virtio-scsi",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-readonly",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);

    DO_TEST("hostdev-scsi-shareable",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-sgio",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-rawio",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);

    DO_TEST("hostdev-scsi-autogen-address",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-large-unit",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);

    DO_TEST("hostdev-scsi-lsi-iscsi",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-lsi-iscsi-auth",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-virtio-iscsi",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-virtio-iscsi-auth",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);

    DO_TEST("s390-defaultconsole",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("s390-panic",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("s390-panic-missing",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("s390-panic-no-address",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
1052

1053 1054 1055
    DO_TEST("pcihole64", NONE);
    DO_TEST("pcihole64-gib", NONE);
    DO_TEST("pcihole64-none", NONE);
1056
    DO_TEST("pcihole64-q35",
1057
            QEMU_CAPS_DEVICE_IOH3420,
1058 1059
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1060
            QEMU_CAPS_DEVICE_QXL,
1061
            QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
1062

1063 1064 1065 1066 1067
    DO_TEST("panic", NONE);
    DO_TEST("panic-isa", NONE);
    DO_TEST("panic-pseries", NONE);
    DO_TEST("panic-double", NONE);
    DO_TEST("panic-no-address", NONE);
H
Hu Tao 已提交
1068

1069
    DO_TEST("disk-backing-chains", NONE);
1070

1071
    DO_TEST("chardev-label", NONE);
J
Ján Tomko 已提交
1072

1073 1074 1075 1076 1077 1078
    DO_TEST("cpu-numa1", NONE);
    DO_TEST("cpu-numa2", NONE);
    DO_TEST("cpu-numa-no-memory-element", NONE);
    DO_TEST("cpu-numa-disordered", NONE);
    DO_TEST("cpu-numa-disjoint", NONE);
    DO_TEST("cpu-numa-memshared", NONE);
1079

1080 1081 1082
    DO_TEST("numatune-auto-prefer", NONE);
    DO_TEST("numatune-memnode", NONE);
    DO_TEST("numatune-memnode-no-memory", NONE);
1083

1084 1085
    DO_TEST("bios-nvram", NONE);
    DO_TEST("bios-nvram-os-interleave", NONE);
1086

1087 1088 1089
    DO_TEST("tap-vhost", NONE);
    DO_TEST("tap-vhost-incorrect", NONE);
    DO_TEST("shmem", NONE);
1090
    DO_TEST("shmem-plain-doorbell", NONE);
1091 1092
    DO_TEST("smbios", NONE);
    DO_TEST("smbios-multiple-type2", NONE);
1093

1094
    DO_TEST("aarch64-aavmf-virtio-mmio",
1095 1096 1097
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1098
    DO_TEST("aarch64-virtio-pci-default",
1099
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
1100
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
1101 1102 1103
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1104
            QEMU_CAPS_PCI_MULTIFUNCTION,
1105 1106 1107
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
1108
    DO_TEST("aarch64-virtio-pci-manual-addresses",
1109 1110 1111 1112
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1113
            QEMU_CAPS_PCI_MULTIFUNCTION,
1114 1115 1116
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
1117 1118 1119 1120 1121
    DO_TEST("aarch64-video-virtio-gpu-pci",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCI_BRIDGE, QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_VIRTIO_GPU, QEMU_CAPS_BOOTINDEX);
1122 1123 1124 1125 1126 1127 1128 1129
    DO_TEST("aarch64-pci-serial",
            QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_DEVICE_PCI_SERIAL,
            QEMU_CAPS_CHARDEV_LOGFILE,
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT);
1130

1131 1132 1133 1134
    DO_TEST_FULL("aarch64-gic-none", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-none-v2", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-none-v3", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-none-both", WHEN_BOTH, GIC_BOTH, NONE);
1135
    DO_TEST_FULL("aarch64-gic-none-tcg", WHEN_BOTH, GIC_BOTH, NONE);
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
    DO_TEST_FULL("aarch64-gic-default", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-default", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-default", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-default", WHEN_BOTH, GIC_BOTH, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH, GIC_BOTH, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH, GIC_BOTH, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH, GIC_BOTH, NONE);
1152

1153 1154 1155
    DO_TEST("memory-hotplug", NONE);
    DO_TEST("memory-hotplug-nonuma", NONE);
    DO_TEST("memory-hotplug-dimm", NONE);
M
Michal Privoznik 已提交
1156
    DO_TEST("memory-hotplug-nvdimm", NONE);
1157
    DO_TEST("memory-hotplug-nvdimm-access", NONE);
1158
    DO_TEST("memory-hotplug-nvdimm-label", NONE);
1159
    DO_TEST("net-udp", NONE);
1160

1161 1162 1163 1164 1165
    DO_TEST("video-virtio-gpu-device", NONE);
    DO_TEST("video-virtio-gpu-virgl", NONE);
    DO_TEST("video-virtio-gpu-spice-gl", NONE);
    DO_TEST("virtio-input", NONE);
    DO_TEST("virtio-input-passthrough", NONE);
M
Marc-André Lureau 已提交
1166

1167 1168
    DO_TEST("memorybacking-set", NONE);
    DO_TEST("memorybacking-unset", NONE);
1169
    DO_TEST("virtio-options", QEMU_CAPS_VIRTIO_SCSI);
1170

1171
    virObjectUnref(cfg);
J
Ján Tomko 已提交
1172

1173
    DO_TEST("acpi-table", NONE);
J
Ján Tomko 已提交
1174

1175 1176 1177 1178 1179
    DO_TEST("video-device-pciaddr-default",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL);
1180 1181
    DO_TEST("video-qxl-heads", NONE);
    DO_TEST("video-qxl-noheads", NONE);
1182
    DO_TEST("video-virtio-gpu-secondary", NONE);
1183

1184
    DO_TEST("intel-iommu",
1185 1186 1187 1188
            QEMU_CAPS_DEVICE_INTEL_IOMMU);
    DO_TEST("intel-iommu-machine",
            QEMU_CAPS_MACHINE_OPT,
            QEMU_CAPS_MACHINE_IOMMU);
1189
    DO_TEST("intel-iommu-ioapic", NONE);
1190
    DO_TEST("intel-iommu-caching-mode", NONE);
1191
    DO_TEST("intel-iommu-eim", NONE);
J
Ján Tomko 已提交
1192
    DO_TEST("intel-iommu-device-iotlb", NONE);
J
Ján Tomko 已提交
1193

1194 1195 1196 1197 1198 1199 1200 1201
    DO_TEST("cpu-check-none", NONE);
    DO_TEST("cpu-check-partial", NONE);
    DO_TEST("cpu-check-full", NONE);
    DO_TEST("cpu-check-default-none", NONE);
    DO_TEST("cpu-check-default-none2", NONE);
    DO_TEST("cpu-check-default-partial", NONE);
    DO_TEST("cpu-check-default-partial2", NONE);

A
Andrea Bolognani 已提交
1202 1203 1204
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

1205
    qemuTestDriverFree(&driver);
A
Andrea Bolognani 已提交
1206
    VIR_FREE(fakerootdir);
1207

1208
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1209 1210
}

A
Andrea Bolognani 已提交
1211 1212
VIR_TEST_MAIN_PRELOAD(mymain,
                      abs_builddir "/.libs/virpcimock.so")
1213

1214 1215
#else

1216 1217 1218 1219 1220
int
main(void)
{
    return EXIT_AM_SKIP;
}
1221 1222

#endif /* WITH_QEMU */