qemuxml2xmltest.c 45.6 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
    virBitmapPtr activeVcpus;
37
    bool blockjobs;
38

39
    virQEMUCapsPtr qemuCaps;
40 41
};

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

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

53 54 55 56 57 58 59 60 61 62
    info->blockjobs = false;

    /* remember whether we have mirror jobs */
    for (i = 0; i < def->ndisks; i++) {
        if (def->disks[i]->mirror) {
            info->blockjobs = true;
            break;
        }
    }

63 64 65
    return 0;
}

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

71
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt,
72
                                      info->inName, info->outActiveName, true,
73 74
                                      qemuXML2XMLActivePreFormatCallback,
                                      opaque, 0,
75
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
76 77
}

78

79
static int
80
testXML2XMLInactive(const void *opaque)
81
{
82 83
    const struct testInfo *info = opaque;

84
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt, info->inName,
85
                                      info->outInactiveName, false,
86
                                      NULL, opaque, 0,
87
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
88
}
89

90

91
static const char testStatusXMLPrefixHeader[] =
92 93
"<domstatus state='running' reason='booted' pid='3803518'>\n"
"  <taint flag='high-privileges'/>\n"
94 95
"  <monitor path='/var/lib/libvirt/qemu/test.monitor' json='1' type='unix'/>\n";

96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
static const char testStatusXMLPrefixBodyStatic[] =
"<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"
"</devices>\n"
"<numad nodeset='0-2' cpuset='1,3'/>\n"
"<libDir path='/tmp'/>\n"
112 113
"<channelTargetDir path='/tmp/channel'/>\n"
"<allowReboot value='yes'/>\n";
114 115 116 117 118

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


119 120 121 122 123 124 125 126 127
static void
testGetStatuXMLPrefixVcpus(virBufferPtr buf,
                           const struct testInfo *data)
{
    ssize_t vcpuid = -1;

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

128 129 130 131 132 133
    /* 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);
    }
134 135 136 137 138 139

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


140 141 142 143 144 145 146 147 148
static void
testGetStatusXMLAddBlockjobs(virBufferPtr buf,
                             const struct testInfo *data)
{
    virBufferAsprintf(buf, "<blockjobs active='%s'/>\n",
                      virTristateBoolTypeToString(virTristateBoolFromBool(data->blockjobs)));
}


149 150 151 152 153 154 155 156 157 158
static char *
testGetStatusXMLPrefix(const struct testInfo *data)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

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

    testGetStatuXMLPrefixVcpus(&buf, data);

159 160
    virBufferAddStr(&buf, testStatusXMLPrefixBodyStatic);

161 162
    testGetStatusXMLAddBlockjobs(&buf, data);

163 164 165 166 167 168
    virBufferAdjustIndent(&buf, -2);

    return virBufferContentAndReset(&buf);
}


169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
static int
testProcessStatusXML(virDomainObjPtr vm)
{
    size_t i;

    /* fix the private 'blockjob' flag for disks */
    for (i = 0; i < vm->def->ndisks; i++) {
        virDomainDiskDefPtr disk = vm->def->disks[i];
        qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

        diskPriv->blockjob = !!disk->mirror;
    }

    return 0;
}


186 187 188 189 190 191 192 193 194 195
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;
196
    char *header = NULL;
197
    char *inFile = NULL, *outActiveFile = NULL;
198 199 200
    int ret = -1;
    int keepBlanksDefault = xmlKeepBlanksDefault(0);

201
    if (virTestLoadFile(data->inName, &inFile) < 0)
202
        goto cleanup;
203
    if (virTestLoadFile(data->outActiveName, &outActiveFile) < 0)
204 205
        goto cleanup;

206 207 208
    if (!(header = testGetStatusXMLPrefix(data)))
        goto cleanup;

209
    /* construct faked source status XML */
210
    virBufferAdd(&buf, header, -1);
211
    virBufferAdjustIndent(&buf, 2);
212
    virBufferAddStr(&buf, inFile);
213 214 215 216
    virBufferAdjustIndent(&buf, -2);
    virBufferAdd(&buf, testStatusXMLSuffix, -1);

    if (!(source = virBufferContentAndReset(&buf))) {
217
        VIR_TEST_DEBUG("Failed to create the source XML");
218 219 220 221
        goto cleanup;
    }

    /* construct the expect string */
222
    virBufferAdd(&buf, header, -1);
223
    virBufferAdjustIndent(&buf, 2);
224
    virBufferAddStr(&buf, outActiveFile);
225 226 227 228
    virBufferAdjustIndent(&buf, -2);
    virBufferAdd(&buf, testStatusXMLSuffix, -1);

    if (!(expect = virBufferContentAndReset(&buf))) {
229
        VIR_TEST_DEBUG("Failed to create the expect XML");
230 231 232 233 234 235 236 237 238
        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 |
239
                                      VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES))) {
240
        VIR_TEST_DEBUG("Failed to parse domain status XML:\n%s", source);
241 242 243
        goto cleanup;
    }

244 245 246 247
    /* process the definition if necessary */
    if (testProcessStatusXML(obj) < 0)
        goto cleanup;

248
    /* format it back */
249
    if (!(actual = virDomainObjFormat(driver.xmlopt, obj, NULL,
250
                                      VIR_DOMAIN_DEF_FORMAT_SECURE))) {
251
        VIR_TEST_DEBUG("Failed to format domain status XML");
252 253 254 255
        goto cleanup;
    }

    if (STRNEQ(actual, expect)) {
256 257
        /* For status test we don't want to regenerate output to not
         * add the status data.*/
258 259 260
        virTestDifferenceFullNoRegenerate(stderr,
                                          expect, data->outActiveName,
                                          actual, data->inName);
261 262 263 264 265 266 267 268 269 270 271 272
        goto cleanup;
    }

    ret = 0;

 cleanup:
    xmlKeepBlanksDefault(keepBlanksDefault);
    xmlFreeDoc(xml);
    virObjectUnref(obj);
    VIR_FREE(expect);
    VIR_FREE(actual);
    VIR_FREE(source);
273
    VIR_FREE(inFile);
274
    VIR_FREE(header);
275
    VIR_FREE(outActiveFile);
276 277 278 279
    return ret;
}


280 281 282 283 284 285
static void
testInfoFree(struct testInfo *info)
{
    VIR_FREE(info->inName);
    VIR_FREE(info->outActiveName);
    VIR_FREE(info->outInactiveName);
286

287 288 289
    virBitmapFree(info->activeVcpus);
    info->activeVcpus = NULL;

290
    virObjectUnref(info->qemuCaps);
291 292 293 294 295 296
}


static int
testInfoSet(struct testInfo *info,
            const char *name,
297 298
            int when,
            int gic)
299
{
300 301 302
    if (!(info->qemuCaps = virQEMUCapsNew()))
        goto error;

303 304 305
    if (testQemuCapsSetGIC(info->qemuCaps, gic) < 0)
        goto error;

306
    if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
307 308
        goto error;

309 310 311 312 313
    if (virAsprintf(&info->inName, "%s/qemuxml2argvdata/qemuxml2argv-%s.xml",
                    abs_srcdir, name) < 0)
        goto error;

    if (when & WHEN_INACTIVE) {
314 315 316 317
        if (virAsprintf(&info->outInactiveName,
                        "%s/qemuxml2xmloutdata/qemuxml2xmlout-%s-inactive.xml",
                        abs_srcdir, name) < 0)
            goto error;
318

319 320
        if (!virFileExists(info->outInactiveName)) {
            VIR_FREE(info->outInactiveName);
321

322 323 324
            if (virAsprintf(&info->outInactiveName,
                            "%s/qemuxml2xmloutdata/qemuxml2xmlout-%s.xml",
                            abs_srcdir, name) < 0)
325 326
                goto error;
        }
327
    }
328

329
    if (when & WHEN_ACTIVE) {
330 331 332 333
        if (virAsprintf(&info->outActiveName,
                        "%s/qemuxml2xmloutdata/qemuxml2xmlout-%s-active.xml",
                        abs_srcdir, name) < 0)
            goto error;
334

335 336
        if (!virFileExists(info->outActiveName)) {
            VIR_FREE(info->outActiveName);
337

338 339 340
            if (virAsprintf(&info->outActiveName,
                            "%s/qemuxml2xmloutdata/qemuxml2xmlout-%s.xml",
                            abs_srcdir, name) < 0)
341 342
                goto error;
        }
343
    }
344

345
    return 0;
346

347 348 349
 error:
    testInfoFree(info);
    return -1;
350 351
}

A
Andrea Bolognani 已提交
352
# define FAKEROOTDIRTEMPLATE abs_builddir "/fakerootdir-XXXXXX"
353

354
static int
E
Eric Blake 已提交
355
mymain(void)
356 357
{
    int ret = 0;
A
Andrea Bolognani 已提交
358
    char *fakerootdir;
359
    struct testInfo info;
360
    virQEMUDriverConfigPtr cfg = NULL;
361

A
Andrea Bolognani 已提交
362 363 364 365 366 367 368 369 370 371 372 373
    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);

374 375
    memset(&info, 0, sizeof(info));

376
    if (qemuTestDriverInit(&driver) < 0)
377
        return EXIT_FAILURE;
378

379 380
    cfg = virQEMUDriverGetConfig(&driver);

381 382
    /* TODO: test with format probing disabled too */
    driver.config->allowDiskFormatProbing = true;
383

384
# define DO_TEST_FULL(name, when, gic, ...)                                    \
385
    do {                                                                       \
386
        if (testInfoSet(&info, name, when, gic) < 0) {                         \
387
            VIR_TEST_DEBUG("Failed to generate test data for '%s'", name);     \
388 389
            return -1;                                                         \
        }                                                                      \
390
        virQEMUCapsSetList(info.qemuCaps, __VA_ARGS__, QEMU_CAPS_LAST);        \
391 392
                                                                               \
        if (info.outInactiveName) {                                            \
393
            if (virTestRun("QEMU XML-2-XML-inactive " name,                    \
394 395 396 397 398
                            testXML2XMLInactive, &info) < 0)                   \
                ret = -1;                                                      \
        }                                                                      \
                                                                               \
        if (info.outActiveName) {                                              \
399
            if (virTestRun("QEMU XML-2-XML-active " name,                      \
400
                            testXML2XMLActive, &info) < 0)                     \
401 402
                ret = -1;                                                      \
                                                                               \
403
            if (virTestRun("QEMU XML-2-XML-status " name,                      \
404
                            testCompareStatusXMLToXMLFiles, &info) < 0)        \
405 406 407
                ret = -1;                                                      \
        }                                                                      \
        testInfoFree(&info);                                                   \
408 409
    } while (0)

410 411
# define NONE QEMU_CAPS_LAST

412 413
# define DO_TEST(name, ...) \
    DO_TEST_FULL(name, WHEN_BOTH, GIC_NONE, __VA_ARGS__)
414 415


416 417 418 419 420

    /* 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);
421

422 423 424
    DO_TEST("minimal", NONE);
    DO_TEST("machine-core-on", NONE);
    DO_TEST("machine-core-off", NONE);
425
    DO_TEST("machine-loadparm-multiple-disks-nets-s390", NONE);
426 427 428 429 430
    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);
431 432 433 434 435 436 437
    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);
438 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 476 477 478
    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);
479 480 481
    DO_TEST("hugepages-pages4", NONE);
    DO_TEST("hugepages-pages5", NONE);
    DO_TEST("hugepages-pages6", NONE);
482
    DO_TEST("hugepages-pages7", NONE);
483
    DO_TEST("hugepages-shared", NONE);
484
    DO_TEST("hugepages-memaccess", NONE);
485
    DO_TEST("hugepages-memaccess2", NONE);
486 487 488 489 490 491 492 493 494 495 496 497
    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);
L
Lin Ma 已提交
498
    DO_TEST("disk-virtio-drive-queues", QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES);
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
    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);
523
    DO_TEST("disk-drive-network-source-auth", NONE);
524
    DO_TEST("disk-drive-network-sheepdog", NONE);
525
    DO_TEST("disk-drive-network-vxhs", NONE);
526
    DO_TEST("disk-drive-network-tlsx509-vxhs", NONE);
527 528
    DO_TEST("disk-scsi-device",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_SCSI_LSI);
529
    DO_TEST("disk-scsi-vscsi", NONE);
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
    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);
545
    DO_TEST("disk-mirror-old", NONE);
546
    DO_TEST("disk-mirror", NONE);
547
    DO_TEST_FULL("disk-active-commit", WHEN_ACTIVE, GIC_NONE, NONE);
548 549 550 551 552 553 554
    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);
555
    cfg->vncAutoUnixSocket = true;
556
    DO_TEST("graphics-vnc-auto-socket-cfg", NONE);
557
    cfg->vncAutoUnixSocket = false;
558 559 560 561 562 563 564 565 566 567
    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);
568
    cfg->spiceAutoUnixSocket = true;
569
    DO_TEST("graphics-spice-auto-socket-cfg", NONE);
570 571
    cfg->spiceAutoUnixSocket = false;

572 573
    DO_TEST("nographics-vga",
            QEMU_CAPS_DISPLAY);
574 575 576 577 578 579 580 581 582 583
    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);
584
    DO_TEST("net-user-addr", QEMU_CAPS_NETDEV);
585 586 587 588 589 590 591
    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);
592
    DO_TEST("net-virtio-rxtxqueuesize", NONE);
593 594 595 596 597 598 599 600 601
    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);
602
    DO_TEST("net-mtu", NONE);
603
    DO_TEST("net-coalesce", NONE);
604

605
    DO_TEST("serial-tcp-tlsx509-chardev", NONE);
606
    DO_TEST("serial-tcp-tlsx509-chardev-notls", NONE);
607 608 609 610 611 612 613 614 615
    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);

616 617
    DO_TEST_FULL("channel-unix-source-path", WHEN_INACTIVE, GIC_NONE, NONE);

618 619 620
    DO_TEST("hostdev-usb-address", NONE);
    DO_TEST("hostdev-pci-address", NONE);
    DO_TEST("hostdev-vfio", NONE);
621
    DO_TEST("hostdev-mdev-precreated", NONE);
622 623 624 625 626 627
    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);
628
    DO_TEST("luks-disks-source", NONE);
629 630 631 632 633 634 635 636 637
    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);
638
    DO_TEST("vcpu-placement-static",
639 640
            QEMU_CAPS_KVM,
            QEMU_CAPS_OBJECT_IOTHREAD);
641

642 643 644 645 646 647
    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);
648 649 650 651 652 653 654
    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);
655 656 657 658 659 660 661
    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);

662 663 664 665 666
    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",
667
            QEMU_CAPS_DEVICE_IOH3420,
668 669
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
670 671
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("usb-controller-explicit-q35",
672
            QEMU_CAPS_DEVICE_IOH3420,
673 674
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
675 676 677 678 679
            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);
680 681 682 683 684
    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);
685
    DO_TEST("blkdeviotune-max", NONE);
686
    DO_TEST("blkdeviotune-group-num", NONE);
687
    DO_TEST("blkdeviotune-max-length", NONE);
688
    DO_TEST("controller-usb-order", NONE);
689

690 691 692 693
    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);
694
    DO_TEST("seclabel-static", NONE);
695
    DO_TEST_FULL("seclabel-static-labelskip", WHEN_ACTIVE, GIC_NONE, NONE);
696 697 698 699
    DO_TEST("seclabel-none", NONE);
    DO_TEST("seclabel-dac-none", NONE);
    DO_TEST("seclabel-dynamic-none", NONE);
    DO_TEST("seclabel-device-multiple", NONE);
700
    DO_TEST_FULL("seclabel-dynamic-none-relabel", WHEN_INACTIVE, GIC_NONE, NONE);
701
    DO_TEST("numad-static-vcpu-no-numatune", NONE);
702

703 704 705 706 707 708
    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);
709 710
    DO_TEST("disk-source-pool", NONE);
    DO_TEST("disk-source-pool-mode", NONE);
711

712 713
    DO_TEST("disk-drive-discard", NONE);
    DO_TEST("disk-drive-detect-zeroes", NONE);
O
Osier Yang 已提交
714

715 716
    DO_TEST("virtio-rng-random", NONE);
    DO_TEST("virtio-rng-egd", NONE);
717

718 719 720
    DO_TEST("pseries-nvram", NONE);
    DO_TEST("pseries-panic-missing", NONE);
    DO_TEST("pseries-panic-no-address", NONE);
721

722 723 724 725 726 727
    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);
728 729 730 731
    DO_TEST("pseries-phb-numa-node",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE);
732

733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
    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);

764 765 766 767
    DO_TEST("balloon-device-auto", NONE);
    DO_TEST("balloon-device-period", NONE);
    DO_TEST("channel-virtio-auto", NONE);
    DO_TEST("console-compat-auto", NONE);
768 769
    DO_TEST("disk-scsi-device-auto",
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_SCSI_LSI);
770 771 772 773 774 775 776 777 778 779 780 781 782
    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);
783

784
    DO_TEST("pci-bridge",
785 786 787 788 789
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-many",
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
790 791 792
    DO_TEST("pci-bridge-many-disks",
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
    DO_TEST("pci-autoadd-addr",
793 794
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
795
    DO_TEST("pci-autoadd-idx",
796 797
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
798
    DO_TEST("pci-autofill-addr", NONE);
799

800
    DO_TEST("q35",
801 802
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
803
            QEMU_CAPS_DEVICE_IOH3420,
804 805 806 807
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
808
            QEMU_CAPS_DEVICE_QXL);
809 810 811
    DO_TEST("q35-usb2",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
812
            QEMU_CAPS_DEVICE_IOH3420,
813
            QEMU_CAPS_ICH9_AHCI,
814 815
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
816
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
817
            QEMU_CAPS_DEVICE_QXL);
818
    DO_TEST("q35-usb2-multi",
819 820
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
821
            QEMU_CAPS_DEVICE_IOH3420,
822 823 824 825
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
826
            QEMU_CAPS_DEVICE_QXL);
827
    DO_TEST("q35-usb2-reorder",
828 829
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
830
            QEMU_CAPS_DEVICE_IOH3420,
831 832 833 834
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_PCI_MULTIFUNCTION,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
835
            QEMU_CAPS_DEVICE_QXL);
836 837 838 839
    DO_TEST("q35-pcie",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
840
            QEMU_CAPS_NETDEV,
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
            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,
857
            QEMU_CAPS_NEC_USB_XHCI,
858 859 860 861 862 863
            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,
864
            QEMU_CAPS_NETDEV,
865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880
            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,
881
            QEMU_CAPS_NEC_USB_XHCI,
882
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
883 884 885 886 887 888 889 890 891 892
    /* 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,
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
            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,
916 917 918 919 920 921 922 923 924 925 926 927 928
            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,
929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
            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,
952
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
953
    DO_TEST("q35-virt-manager-basic",
954 955 956 957 958
            QEMU_CAPS_KVM,
            QEMU_CAPS_RTC,
            QEMU_CAPS_NO_KVM_PIT,
            QEMU_CAPS_ICH9_DISABLE_S3,
            QEMU_CAPS_ICH9_DISABLE_S4,
959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
            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,
981 982 983 984 985 986
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_CHARDEV_SPICEVMC,
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_HDA_DUPLEX,
            QEMU_CAPS_USB_REDIR);
987
    DO_TEST("pcie-root",
988 989
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
990
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
991
            QEMU_CAPS_DEVICE_QXL);
992 993

    /* Test automatic and manual setting of pcie-root-port attributes */
994
    DO_TEST("pcie-root-port",
995 996
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
997
            QEMU_CAPS_PCI_MULTIFUNCTION,
998
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
999
            QEMU_CAPS_DEVICE_QXL);
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011

    /* 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);

1012
    DO_TEST("pcie-switch-upstream-port",
1013 1014 1015
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_ICH9_AHCI,
1016
            QEMU_CAPS_PCI_MULTIFUNCTION,
1017
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1018
            QEMU_CAPS_DEVICE_QXL);
1019
    DO_TEST("pcie-switch-downstream-port",
1020 1021 1022 1023
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_ICH9_AHCI,
1024
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1025
            QEMU_CAPS_DEVICE_QXL);
1026
    DO_TEST("pci-expander-bus",
1027
            QEMU_CAPS_DEVICE_PXB);
1028
    DO_TEST("pcie-expander-bus",
1029 1030 1031 1032
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_DEVICE_PXB_PCIE);
1033
    DO_TEST("autoindex",
1034 1035 1036 1037 1038 1039 1040 1041
            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,
1042
            QEMU_CAPS_NEC_USB_XHCI);
1043 1044 1045 1046 1047 1048 1049
    /* 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);
1050

1051 1052 1053 1054 1055 1056
    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);
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
    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);
1105

1106 1107 1108
    DO_TEST("pcihole64", NONE);
    DO_TEST("pcihole64-gib", NONE);
    DO_TEST("pcihole64-none", NONE);
1109
    DO_TEST("pcihole64-q35",
1110
            QEMU_CAPS_DEVICE_IOH3420,
1111 1112
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1113
            QEMU_CAPS_DEVICE_QXL,
1114
            QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
1115

1116 1117 1118 1119 1120
    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 已提交
1121

1122
    DO_TEST("disk-backing-chains", NONE);
1123

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

1126 1127 1128 1129 1130 1131
    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);
1132

1133 1134 1135
    DO_TEST("numatune-auto-prefer", NONE);
    DO_TEST("numatune-memnode", NONE);
    DO_TEST("numatune-memnode-no-memory", NONE);
1136

1137 1138
    DO_TEST("bios-nvram", NONE);
    DO_TEST("bios-nvram-os-interleave", NONE);
1139

1140 1141 1142
    DO_TEST("tap-vhost", NONE);
    DO_TEST("tap-vhost-incorrect", NONE);
    DO_TEST("shmem", NONE);
1143
    DO_TEST("shmem-plain-doorbell", NONE);
1144 1145
    DO_TEST("smbios", NONE);
    DO_TEST("smbios-multiple-type2", NONE);
1146

1147
    DO_TEST("aarch64-aavmf-virtio-mmio",
1148 1149 1150
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1151
    DO_TEST("aarch64-virtio-pci-default",
1152
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_DTB,
1153
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
1154 1155 1156
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1157
            QEMU_CAPS_PCI_MULTIFUNCTION,
1158 1159 1160
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
1161
    DO_TEST("aarch64-virtio-pci-manual-addresses",
1162 1163 1164 1165
            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,
1166
            QEMU_CAPS_PCI_MULTIFUNCTION,
1167 1168 1169
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
1170 1171 1172 1173 1174
    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);
1175 1176 1177 1178 1179 1180 1181 1182
    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);
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
    DO_TEST("aarch64-video-default",
            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_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_VNC);
1193

1194 1195 1196 1197
    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);
1198
    DO_TEST_FULL("aarch64-gic-none-tcg", WHEN_BOTH, GIC_BOTH, NONE);
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
    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);
1215

1216 1217 1218
    DO_TEST("memory-hotplug", NONE);
    DO_TEST("memory-hotplug-nonuma", NONE);
    DO_TEST("memory-hotplug-dimm", NONE);
M
Michal Privoznik 已提交
1219
    DO_TEST("memory-hotplug-nvdimm", NONE);
1220
    DO_TEST("memory-hotplug-nvdimm-access", NONE);
1221
    DO_TEST("memory-hotplug-nvdimm-label", NONE);
1222
    DO_TEST("net-udp", NONE);
1223

1224 1225 1226 1227 1228
    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 已提交
1229

1230 1231
    DO_TEST("memorybacking-set", NONE);
    DO_TEST("memorybacking-unset", NONE);
1232
    DO_TEST("virtio-options", QEMU_CAPS_VIRTIO_SCSI);
1233

1234
    virObjectUnref(cfg);
J
Ján Tomko 已提交
1235

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

1238 1239 1240 1241 1242
    DO_TEST("video-device-pciaddr-default",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL);
1243 1244
    DO_TEST("video-qxl-heads", NONE);
    DO_TEST("video-qxl-noheads", NONE);
1245
    DO_TEST("video-virtio-gpu-secondary", NONE);
1246

1247
    DO_TEST("intel-iommu",
1248 1249 1250 1251
            QEMU_CAPS_DEVICE_INTEL_IOMMU);
    DO_TEST("intel-iommu-machine",
            QEMU_CAPS_MACHINE_OPT,
            QEMU_CAPS_MACHINE_IOMMU);
1252
    DO_TEST("intel-iommu-caching-mode", NONE);
1253
    DO_TEST("intel-iommu-eim", NONE);
J
Ján Tomko 已提交
1254
    DO_TEST("intel-iommu-device-iotlb", NONE);
J
Ján Tomko 已提交
1255

1256 1257 1258 1259 1260 1261 1262 1263
    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);

1264 1265 1266 1267 1268 1269
    DO_TEST("smartcard-host", NONE);
    DO_TEST("smartcard-host-certificates", NONE);
    DO_TEST("smartcard-passthrough-tcp", NONE);
    DO_TEST("smartcard-passthrough-spicevmc", NONE);
    DO_TEST("smartcard-controller", NONE);

1270 1271 1272 1273
    DO_TEST("pseries-cpu-compat-power9", NONE);
    DO_TEST("pseries-cpu-compat", NONE);
    DO_TEST("pseries-cpu-exact", NONE);

1274 1275
    DO_TEST("user-aliases", NONE);

A
Andrea Bolognani 已提交
1276 1277 1278
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

1279
    qemuTestDriverFree(&driver);
A
Andrea Bolognani 已提交
1280
    VIR_FREE(fakerootdir);
1281

1282
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1283 1284
}

A
Andrea Bolognani 已提交
1285 1286
VIR_TEST_MAIN_PRELOAD(mymain,
                      abs_builddir "/.libs/virpcimock.so")
1287

1288 1289
#else

1290 1291 1292 1293 1294
int
main(void)
{
    return EXIT_AM_SKIP;
}
1295 1296

#endif /* WITH_QEMU */