qemu_capabilities.c 101.4 KB
Newer Older
1 2 3
/*
 * qemu_capabilities.c: QEMU capabilities generation
 *
4
 * Copyright (C) 2006-2014 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (C) 2006 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library.  If not, see
O
Osier Yang 已提交
19
 * <http://www.gnu.org/licenses/>.
20 21 22 23 24 25 26
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#include <config.h>

#include "qemu_capabilities.h"
27
#include "viralloc.h"
28
#include "vircrypto.h"
29
#include "virlog.h"
30
#include "virerror.h"
E
Eric Blake 已提交
31
#include "virfile.h"
32 33
#include "virpidfile.h"
#include "virprocess.h"
34 35 36
#include "nodeinfo.h"
#include "cpu/cpu.h"
#include "domain_conf.h"
37
#include "vircommand.h"
38
#include "virbitmap.h"
39
#include "virnodesuspend.h"
40
#include "qemu_monitor.h"
41
#include "virstring.h"
42

43
#include <fcntl.h>
44 45 46
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>
47
#include <stdarg.h>
48 49 50

#define VIR_FROM_THIS VIR_FROM_QEMU

51 52
VIR_LOG_INIT("qemu.qemu_capabilities");

53 54 55 56
/* While not public, these strings must not change. They
 * are used in domain status files which are read on
 * daemon restarts
 */
57
VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST,
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
              "kqemu",  /* 0 */
              "vnc-colon",
              "no-reboot",
              "drive",
              "drive-boot",

              "name", /* 5 */
              "uuid",
              "domid",
              "vnet-hdr",
              "migrate-kvm-stdio",

              "migrate-qemu-tcp", /* 10 */
              "migrate-qemu-exec",
              "drive-cache-v2",
              "kvm",
              "drive-format",

              "vga", /* 15 */
              "0.10",
              "pci-device",
              "mem-path",
              "drive-serial",

              "xen-domid", /* 20 */
              "migrate-qemu-unix",
              "chardev",
              "enable-kvm",
              "monitor-json",

              "balloon", /* 25 */
              "device",
              "sdl",
              "smp-topology",
              "netdev",

              "rtc", /* 30 */
95
              "vhost-net",
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
              "rtc-td-hack",
              "no-hpet",
              "no-kvm-pit",

              "tdf", /* 35 */
              "pci-configfd",
              "nodefconfig",
              "boot-menu",
              "enable-kqemu",

              "fsdev", /* 40 */
              "nesting",
              "name-process",
              "drive-readonly",
              "smbios-type",

              "vga-qxl", /* 45 */
              "spice",
              "vga-none",
              "migrate-qemu-fd",
              "boot-index",

              "hda-duplex", /* 50 */
              "drive-aio",
              "pci-multibus",
              "pci-bootindex",
              "ccid-emulated",

              "ccid-passthru", /* 55 */
              "chardev-spicevmc",
              "device-spicevmc",
              "virtio-tx-alg",
              "device-qxl-vga",
129 130

              "pci-multifunction", /* 60 */
131
              "virtio-blk-pci.ioeventfd",
M
Michal Privoznik 已提交
132
              "sga",
133 134
              "virtio-blk-pci.event_idx",
              "virtio-net-pci.event_idx",
135 136 137 138 139 140 141 142 143 144

              "cache-directsync", /* 65 */
              "piix3-usb-uhci",
              "piix4-usb-uhci",
              "usb-ehci",
              "ich9-usb-ehci1",

              "vt82c686b-usb-uhci", /* 70 */
              "pci-ohci",
              "usb-redir",
M
Marc-André Lureau 已提交
145
              "usb-hub",
146
              "no-shutdown",
147 148

              "cache-unsafe", /* 75 */
149
              "rombar",
J
Jim Fehlig 已提交
150
              "ich9-ahci",
151
              "no-acpi",
152
              "fsdev-readonly",
153

154
              "virtio-blk-pci.scsi", /* 80 */
155
              "blk-sg-io",
O
Osier Yang 已提交
156
              "drive-copy-on-read",
157
              "cpu-host",
158
              "fsdev-writeout",
159 160

              "drive-iotune", /* 85 */
161
              "system_wakeup",
162
              "scsi-disk.channel",
163
              "scsi-block",
164
              "transaction",
165 166 167

              "block-job-sync", /* 90 */
              "block-job-async",
168
              "scsi-cd",
169
              "ide-cd",
170
              "no-user-config",
M
Marc-André Lureau 已提交
171 172

              "hda-micro", /* 95 */
173
              "dump-guest-memory",
G
Gerd Hoffmann 已提交
174
              "nec-usb-xhci",
175
              "virtio-s390",
176
              "balloon-event",
M
Marc-André Lureau 已提交
177

R
Richa Marwaha 已提交
178
              "bridge", /* 100 */
179 180
              "lsi",
              "virtio-scsi-pci",
V
Viktor Mihajlovski 已提交
181
              "blockio",
182
              "disable-s3",
R
Richa Marwaha 已提交
183

184
              "disable-s4", /* 105 */
185
              "usb-redir.filter",
186 187
              "ide-drive.wwn",
              "scsi-disk.wwn",
188
              "seccomp-sandbox",
189 190

              "reboot-timeout", /* 110 */
191
              "dump-guest-core",
192
              "seamless-migration",
193
              "block-commit",
194
              "vnc",
195 196

              "drive-mirror", /* 115 */
197 198
              "usb-redir.bootindex",
              "usb-host.bootindex",
199
              "blockdev-snapshot-sync",
200 201 202 203 204 205
              "qxl",

              "VGA", /* 120 */
              "cirrus-vga",
              "vmware-svga",
              "device-video-primary",
206
              "s390-sclp",
207 208

              "usb-serial", /* 125 */
G
Guannan Ren 已提交
209
              "usb-net",
210
              "add-fd",
211
              "nbd-server",
212 213 214
              "virtio-rng",

              "rng-random", /* 130 */
215
              "rng-egd",
O
Olivia Yin 已提交
216 217
              "virtio-ccw",
              "dtb",
218
              "megasas",
J
Ján Tomko 已提交
219 220

              "ipv6-migration", /* 135 */
221
              "machine-opt",
L
Li Zhang 已提交
222
              "machine-usb-opt",
S
Stefan Berger 已提交
223 224
              "tpm-passthrough",
              "tpm-tis",
225 226

              "nvram",  /* 140 */
H
Han Cheng 已提交
227 228 229 230 231 232
              "pci-bridge",
              "vfio-pci",
              "vfio-pci.bootindex",
              "scsi-generic",

              "scsi-generic.bootindex", /* 145 */
233
              "mem-merge",
234
              "vnc-websocket",
O
Osier Yang 已提交
235
              "drive-discard",
236
              "mlock",
237 238

              "vnc-share-policy", /* 150 */
239
              "device-del-event",
240
              "dmi-to-pci-bridge",
241 242
              "i440fx-pci-hole64-size",
              "q35-pci-hole64-size",
243 244

              "usb-storage", /* 155 */
245
              "usb-storage.removable",
246
              "virtio-mmio",
247
              "ich9-intel-hda",
248
              "kvm-pit-lost-tick-policy",
249 250

              "boot-strict", /* 160 */
251 252
              "pvpanic",
              "enable-fips",
253 254
              "spice-file-xfer-disable",
              "spiceport",
L
Li Zhang 已提交
255 256

              "usb-kbd", /* 165 */
257 258
    );

259 260 261 262 263 264 265 266

/*
 * Update the XML parser/formatter when adding more
 * information to this struct so that it gets cached
 * correctly. It does not have to be ABI-stable, as
 * the cache will be discarded & repopulated if the
 * timestamp on the libvirtd binary changes.
 */
267
struct _virQEMUCaps {
268 269
    virObject object;

270 271
    bool usedQMP;

272
    char *binary;
273
    time_t ctime;
274

275
    virBitmapPtr flags;
276 277 278 279

    unsigned int version;
    unsigned int kvmVersion;

280
    virArch arch;
281 282 283 284 285 286 287

    size_t ncpuDefinitions;
    char **cpuDefinitions;

    size_t nmachineTypes;
    char **machineTypes;
    char **machineAliases;
288
    unsigned int *machineMaxCpus;
289 290
};

291
struct _virQEMUCapsCache {
292 293
    virMutex lock;
    virHashTablePtr binaries;
294
    char *libDir;
295
    char *cacheDir;
296 297
    uid_t runUid;
    gid_t runGid;
298 299
};

300

301 302
static virClassPtr virQEMUCapsClass;
static void virQEMUCapsDispose(void *obj);
303

304
static int virQEMUCapsOnceInit(void)
305
{
306 307 308 309
    if (!(virQEMUCapsClass = virClassNew(virClassForObject(),
                                         "virQEMUCaps",
                                         sizeof(virQEMUCaps),
                                         virQEMUCapsDispose)))
310 311 312 313 314
        return -1;

    return 0;
}

315
VIR_ONCE_GLOBAL_INIT(virQEMUCaps)
316

317
static virArch virQEMUCapsArchFromString(const char *arch)
318 319 320 321 322 323 324 325 326 327
{
    if (STREQ(arch, "i386"))
        return VIR_ARCH_I686;
    if (STREQ(arch, "arm"))
        return VIR_ARCH_ARMV7L;

    return virArchFromString(arch);
}


328
static const char *virQEMUCapsArchToString(virArch arch)
329 330 331 332 333 334 335 336 337 338
{
    if (arch == VIR_ARCH_I686)
        return "i386";
    else if (arch == VIR_ARCH_ARMV7L)
        return "arm";

    return virArchToString(arch);
}


339
static virCommandPtr
340 341
virQEMUCapsProbeCommand(const char *qemu,
                        virQEMUCapsPtr qemuCaps,
342
                        uid_t runUid, gid_t runGid)
343 344 345
{
    virCommandPtr cmd = virCommandNew(qemu);

346 347
    if (qemuCaps) {
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
348
            virCommandAddArg(cmd, "-no-user-config");
349
        else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
350 351 352 353 354
            virCommandAddArg(cmd, "-nodefconfig");
    }

    virCommandAddEnvPassCommon(cmd);
    virCommandClearCaps(cmd);
355 356
    virCommandSetGID(cmd, runGid);
    virCommandSetUID(cmd, runUid);
357 358 359 360 361

    return cmd;
}


362
static void
363 364
virQEMUCapsSetDefaultMachine(virQEMUCapsPtr qemuCaps,
                             size_t defIdx)
365
{
366 367
    char *name = qemuCaps->machineTypes[defIdx];
    char *alias = qemuCaps->machineAliases[defIdx];
368
    unsigned int maxCpus = qemuCaps->machineMaxCpus[defIdx];
369 370 371 372 373 374 375

    memmove(qemuCaps->machineTypes + 1,
            qemuCaps->machineTypes,
            sizeof(qemuCaps->machineTypes[0]) * defIdx);
    memmove(qemuCaps->machineAliases + 1,
            qemuCaps->machineAliases,
            sizeof(qemuCaps->machineAliases[0]) * defIdx);
376 377 378
    memmove(qemuCaps->machineMaxCpus + 1,
            qemuCaps->machineMaxCpus,
            sizeof(qemuCaps->machineMaxCpus[0]) * defIdx);
379 380
    qemuCaps->machineTypes[0] = name;
    qemuCaps->machineAliases[0] = alias;
381
    qemuCaps->machineMaxCpus[0] = maxCpus;
382 383
}

384 385 386 387
/* Format is:
 * <machine> <desc> [(default)|(alias of <canonical>)]
 */
static int
388 389
virQEMUCapsParseMachineTypesStr(const char *output,
                                virQEMUCapsPtr qemuCaps)
390 391 392
{
    const char *p = output;
    const char *next;
393
    size_t defIdx = 0;
394 395 396

    do {
        const char *t;
397 398
        char *name;
        char *canonical = NULL;
399 400 401 402 403 404 405 406 407 408

        if ((next = strchr(p, '\n')))
            ++next;

        if (STRPREFIX(p, "Supported machines are:"))
            continue;

        if (!(t = strchr(p, ' ')) || (next && t >= next))
            continue;

409 410
        if (VIR_STRNDUP(name, p, t - p) < 0)
            return -1;
411 412

        p = t;
413
        if ((t = strstr(p, "(default)")) && (!next || t < next))
414
            defIdx = qemuCaps->nmachineTypes;
415 416 417 418 419 420

        if ((t = strstr(p, "(alias of ")) && (!next || t < next)) {
            p = t + strlen("(alias of ");
            if (!(t = strchr(p, ')')) || (next && t >= next))
                continue;

421
            if (VIR_STRNDUP(canonical, p, t - p) < 0) {
422
                VIR_FREE(name);
423
                return -1;
424 425 426
            }
        }

427
        if (VIR_REALLOC_N(qemuCaps->machineTypes, qemuCaps->nmachineTypes + 1) < 0 ||
428 429
            VIR_REALLOC_N(qemuCaps->machineAliases, qemuCaps->nmachineTypes + 1) < 0 ||
            VIR_REALLOC_N(qemuCaps->machineMaxCpus, qemuCaps->nmachineTypes + 1) < 0) {
430 431
            VIR_FREE(name);
            VIR_FREE(canonical);
432
            return -1;
433
        }
434
        qemuCaps->nmachineTypes++;
435
        if (canonical) {
436 437
            qemuCaps->machineTypes[qemuCaps->nmachineTypes-1] = canonical;
            qemuCaps->machineAliases[qemuCaps->nmachineTypes-1] = name;
438
        } else {
439 440
            qemuCaps->machineTypes[qemuCaps->nmachineTypes-1] = name;
            qemuCaps->machineAliases[qemuCaps->nmachineTypes-1] = NULL;
441
        }
442 443
        /* When parsing from command line we don't have information about maxCpus */
        qemuCaps->machineMaxCpus[qemuCaps->nmachineTypes-1] = 0;
444 445
    } while ((p = next));

446

447
    if (defIdx)
448
        virQEMUCapsSetDefaultMachine(qemuCaps, defIdx);
449 450 451 452

    return 0;
}

453
static int
454 455
virQEMUCapsProbeMachineTypes(virQEMUCapsPtr qemuCaps,
                             uid_t runUid, gid_t runGid)
456 457
{
    char *output;
458 459
    int ret = -1;
    virCommandPtr cmd;
460
    int status;
461

462 463 464 465
    /* Make sure the binary we are about to try exec'ing exists.
     * Technically we could catch the exec() failure, but that's
     * in a sub-process so it's hard to feed back a useful error.
     */
466
    if (!virFileIsExecutable(qemuCaps->binary)) {
467
        virReportSystemError(errno, _("Cannot find QEMU binary %s"),
468
                             qemuCaps->binary);
469 470 471
        return -1;
    }

472
    cmd = virQEMUCapsProbeCommand(qemuCaps->binary, qemuCaps, runUid, runGid);
473
    virCommandAddArgList(cmd, "-M", "?", NULL);
474
    virCommandSetOutputBuffer(cmd, &output);
475

476 477
    /* Ignore failure from older qemu that did not understand '-M ?'.  */
    if (virCommandRun(cmd, &status) < 0)
478 479
        goto cleanup;

480
    if (virQEMUCapsParseMachineTypesStr(output, qemuCaps) < 0)
481
        goto cleanup;
482 483 484

    ret = 0;

485
 cleanup:
486 487
    VIR_FREE(output);
    virCommandFree(cmd);
488 489 490 491 492 493

    return ret;
}


typedef int
494 495
(*virQEMUCapsParseCPUModels)(const char *output,
                             virQEMUCapsPtr qemuCaps);
496 497 498 499 500 501 502

/* Format:
 *      <arch> <model>
 * qemu-0.13 encloses some model names in []:
 *      <arch> [<model>]
 */
static int
503 504
virQEMUCapsParseX86Models(const char *output,
                          virQEMUCapsPtr qemuCaps)
505 506 507
{
    const char *p = output;
    const char *next;
508
    int ret = -1;
509 510 511

    do {
        const char *t;
512
        size_t len;
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529

        if ((next = strchr(p, '\n')))
            next++;

        if (!(t = strchr(p, ' ')) || (next && t >= next))
            continue;

        if (!STRPREFIX(p, "x86"))
            continue;

        p = t;
        while (*p == ' ')
            p++;

        if (*p == '\0' || *p == '\n')
            continue;

530
        if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0)
531
            goto cleanup;
532

533 534 535 536
        if (next)
            len = next - p - 1;
        else
            len = strlen(p);
537

538 539 540 541
        if (len > 2 && *p == '[' && p[len - 1] == ']') {
            p++;
            len -= 2;
        }
542

543
        if (VIR_STRNDUP(qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions - 1], p, len) < 0)
544
            goto cleanup;
545 546
    } while ((p = next));

547
    ret = 0;
548

549
 cleanup:
550
    return ret;
551 552
}

P
Prerna Saxena 已提交
553 554 555 556
/* ppc64 parser.
 * Format : PowerPC <machine> <description>
 */
static int
557 558
virQEMUCapsParsePPCModels(const char *output,
                          virQEMUCapsPtr qemuCaps)
P
Prerna Saxena 已提交
559 560 561
{
    const char *p = output;
    const char *next;
562
    int ret = -1;
P
Prerna Saxena 已提交
563 564 565

    do {
        const char *t;
566
        size_t len;
P
Prerna Saxena 已提交
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586

        if ((next = strchr(p, '\n')))
            next++;

        if (!STRPREFIX(p, "PowerPC "))
            continue;

        /* Skip the preceding sub-string "PowerPC " */
        p += 8;

        /*Malformed string, does not obey the format 'PowerPC <model> <desc>'*/
        if (!(t = strchr(p, ' ')) || (next && t >= next))
            continue;

        if (*p == '\0')
            break;

        if (*p == '\n')
            continue;

587
        if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0)
588
            goto cleanup;
P
Prerna Saxena 已提交
589

590
        len = t - p - 1;
P
Prerna Saxena 已提交
591

592
        if (VIR_STRNDUP(qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions - 1], p, len) < 0)
593
            goto cleanup;
P
Prerna Saxena 已提交
594 595
    } while ((p = next));

596
    ret = 0;
P
Prerna Saxena 已提交
597

598
 cleanup:
599
    return ret;
P
Prerna Saxena 已提交
600
}
601

602
static int
603
virQEMUCapsProbeCPUModels(virQEMUCapsPtr qemuCaps, uid_t runUid, gid_t runGid)
604 605 606
{
    char *output = NULL;
    int ret = -1;
607
    virQEMUCapsParseCPUModels parse;
608
    virCommandPtr cmd;
609

610 611 612 613 614
    if (qemuCaps->arch == VIR_ARCH_I686 ||
        qemuCaps->arch == VIR_ARCH_X86_64)
        parse = virQEMUCapsParseX86Models;
    else if (qemuCaps->arch == VIR_ARCH_PPC64)
        parse = virQEMUCapsParsePPCModels;
615
    else {
616
        VIR_DEBUG("don't know how to parse %s CPU models",
617
                  virArchToString(qemuCaps->arch));
618 619 620
        return 0;
    }

621
    cmd = virQEMUCapsProbeCommand(qemuCaps->binary, qemuCaps, runUid, runGid);
622
    virCommandAddArgList(cmd, "-cpu", "?", NULL);
623
    virCommandSetOutputBuffer(cmd, &output);
624

625
    if (virCommandRun(cmd, NULL) < 0)
626 627
        goto cleanup;

628
    if (parse(output, qemuCaps) < 0)
629 630 631 632
        goto cleanup;

    ret = 0;

633
 cleanup:
634
    VIR_FREE(output);
635
    virCommandFree(cmd);
636 637 638 639 640

    return ret;
}


641
static char *
642 643
virQEMUCapsFindBinaryForArch(virArch hostarch,
                             virArch guestarch)
644 645
{
    char *ret;
646
    const char *archstr = virQEMUCapsArchToString(guestarch);
647
    char *binary;
648

649
    if (virAsprintf(&binary, "qemu-system-%s", archstr) < 0)
650 651 652 653 654 655 656 657 658 659 660
        return NULL;

    ret = virFindFileInPath(binary);
    VIR_FREE(binary);
    if (ret && !virFileIsExecutable(ret))
        VIR_FREE(ret);

    if (guestarch == VIR_ARCH_I686 &&
        !ret &&
        hostarch == VIR_ARCH_X86_64) {
        ret = virFindFileInPath("qemu-system-x86_64");
661 662
        if (ret && !virFileIsExecutable(ret))
            VIR_FREE(ret);
663
    }
664

665 666 667 668 669
    if (guestarch == VIR_ARCH_I686 &&
        !ret) {
        ret = virFindFileInPath("qemu");
        if (ret && !virFileIsExecutable(ret))
            VIR_FREE(ret);
670
    }
671

672 673 674 675 676
    return ret;
}


static bool
677 678
virQEMUCapsIsValidForKVM(virArch hostarch,
                         virArch guestarch)
679
{
680
    if (hostarch == guestarch)
681
        return true;
682 683
    if (hostarch == VIR_ARCH_X86_64 &&
        guestarch == VIR_ARCH_I686)
684 685 686 687
        return true;
    return false;
}

688
static int
689 690 691 692
virQEMUCapsInitGuest(virCapsPtr caps,
                     virQEMUCapsCachePtr cache,
                     virArch hostarch,
                     virArch guestarch)
693
{
694
    size_t i;
695 696
    char *kvmbin = NULL;
    char *binary = NULL;
697 698
    virQEMUCapsPtr qemubinCaps = NULL;
    virQEMUCapsPtr kvmbinCaps = NULL;
699 700
    int ret = -1;

J
Ján Tomko 已提交
701
    /* Check for existence of base emulator, or alternate base
702 703
     * which can be used with magic cpu choice
     */
704
    binary = virQEMUCapsFindBinaryForArch(hostarch, guestarch);
705

706
    /* Ignore binary if extracting version info fails */
707
    if (binary) {
708
        if (!(qemubinCaps = virQEMUCapsCacheLookup(cache, binary))) {
709 710 711 712
            virResetLastError();
            VIR_FREE(binary);
        }
    }
713 714

    /* qemu-kvm/kvm binaries can only be used if
715 716 717 718 719
     *  - host & guest arches match
     * Or
     *  - hostarch is x86_64 and guest arch is i686
     * The latter simply needs "-cpu qemu32"
     */
720
    if (virQEMUCapsIsValidForKVM(hostarch, guestarch)) {
721 722 723
        const char *const kvmbins[] = { "/usr/libexec/qemu-kvm", /* RHEL */
                                        "qemu-kvm", /* Fedora */
                                        "kvm" }; /* Upstream .spec */
724

725 726
        for (i = 0; i < ARRAY_CARDINALITY(kvmbins); ++i) {
            kvmbin = virFindFileInPath(kvmbins[i]);
727

728 729
            if (!kvmbin)
                continue;
730

731
            if (!(kvmbinCaps = virQEMUCapsCacheLookup(cache, kvmbin))) {
732
                virResetLastError();
733 734 735
                VIR_FREE(kvmbin);
                continue;
            }
736

737 738
            if (!binary) {
                binary = kvmbin;
739
                qemubinCaps = kvmbinCaps;
740
                kvmbin = NULL;
741
                kvmbinCaps = NULL;
742
            }
743
            break;
744 745 746
        }
    }

747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
    ret = virQEMUCapsInitGuestFromBinary(caps,
                                         binary, qemubinCaps,
                                         kvmbin, kvmbinCaps,
                                         guestarch);

    VIR_FREE(binary);
    VIR_FREE(kvmbin);
    virObjectUnref(qemubinCaps);
    virObjectUnref(kvmbinCaps);

    return ret;
}

int
virQEMUCapsInitGuestFromBinary(virCapsPtr caps,
                               const char *binary,
                               virQEMUCapsPtr qemubinCaps,
                               const char *kvmbin,
                               virQEMUCapsPtr kvmbinCaps,
                               virArch guestarch)
{
    virCapsGuestPtr guest;
    bool haskvm = false;
    bool haskqemu = false;
    virCapsGuestMachinePtr *machines = NULL;
    size_t nmachines = 0;
    int ret = -1;
    bool hasdisksnapshot = false;

776 777 778
    if (!binary)
        return 0;

779
    if (virFileExists("/dev/kvm") &&
780 781
        (virQEMUCapsGet(qemubinCaps, QEMU_CAPS_KVM) ||
         virQEMUCapsGet(qemubinCaps, QEMU_CAPS_ENABLE_KVM) ||
782
         kvmbin))
783
        haskvm = true;
784

785
    if (virFileExists("/dev/kqemu") &&
786
        virQEMUCapsGet(qemubinCaps, QEMU_CAPS_KQEMU))
787
        haskqemu = true;
J
Jiri Denemark 已提交
788

789
    if (virQEMUCapsGetMachineTypesCaps(qemubinCaps, &nmachines, &machines) < 0)
790
        goto cleanup;
791 792 793 794

    /* We register kvm as the base emulator too, since we can
     * just give -no-kvm to disable acceleration if required */
    if ((guest = virCapabilitiesAddGuest(caps,
D
Daniel P. Berrange 已提交
795
                                         "hvm",
796
                                         guestarch,
797 798 799 800
                                         binary,
                                         NULL,
                                         nmachines,
                                         machines)) == NULL)
801
        goto cleanup;
802 803 804 805 806

    machines = NULL;
    nmachines = 0;

    if (caps->host.cpu &&
J
Jiri Denemark 已提交
807
        caps->host.cpu->model &&
808
        virQEMUCapsGetCPUDefinitions(qemubinCaps, NULL) > 0 &&
809
        !virCapabilitiesAddGuestFeature(guest, "cpuselection", 1, 0))
810
        goto cleanup;
811

812
    if (virQEMUCapsGet(qemubinCaps, QEMU_CAPS_BOOTINDEX) &&
J
Jiri Denemark 已提交
813
        !virCapabilitiesAddGuestFeature(guest, "deviceboot", 1, 0))
814
        goto cleanup;
815

816 817 818 819
    if (virQEMUCapsGet(qemubinCaps, QEMU_CAPS_DISK_SNAPSHOT))
        hasdisksnapshot = true;

    if (!virCapabilitiesAddGuestFeature(guest, "disksnapshot", hasdisksnapshot, 0))
820
        goto cleanup;
821

D
Daniel P. Berrange 已提交
822 823 824 825 826 827
    if (virCapabilitiesAddGuestDomain(guest,
                                      "qemu",
                                      NULL,
                                      NULL,
                                      0,
                                      NULL) == NULL)
828
        goto cleanup;
829

D
Daniel P. Berrange 已提交
830 831 832 833 834 835 836
    if (haskqemu &&
        virCapabilitiesAddGuestDomain(guest,
                                      "kqemu",
                                      NULL,
                                      NULL,
                                      0,
                                      NULL) == NULL)
837
        goto cleanup;
838

D
Daniel P. Berrange 已提交
839 840
    if (haskvm) {
        virCapsGuestDomainPtr dom;
841

D
Daniel P. Berrange 已提交
842
        if (kvmbin &&
843
            virQEMUCapsGetMachineTypesCaps(kvmbinCaps, &nmachines, &machines) < 0)
844
            goto cleanup;
845

D
Daniel P. Berrange 已提交
846 847 848 849 850 851
        if ((dom = virCapabilitiesAddGuestDomain(guest,
                                                 "kvm",
                                                 kvmbin ? kvmbin : binary,
                                                 NULL,
                                                 nmachines,
                                                 machines)) == NULL) {
852
            goto cleanup;
D
Daniel P. Berrange 已提交
853
        }
854

D
Daniel P. Berrange 已提交
855 856
        machines = NULL;
        nmachines = 0;
857 858 859

    }

860 861
    if (((guestarch == VIR_ARCH_I686) ||
         (guestarch == VIR_ARCH_X86_64)) &&
862 863
        (virCapabilitiesAddGuestFeature(guest, "acpi", 1, 1) == NULL ||
         virCapabilitiesAddGuestFeature(guest, "apic", 1, 0) == NULL))
864
        goto cleanup;
865

866
    if ((guestarch == VIR_ARCH_I686) &&
867 868
        (virCapabilitiesAddGuestFeature(guest, "pae", 1, 0) == NULL ||
         virCapabilitiesAddGuestFeature(guest, "nonpae", 1, 0) == NULL))
869
        goto cleanup;
870 871 872

    ret = 0;

873
 cleanup:
874 875 876

    virCapabilitiesFreeMachines(machines, nmachines);

877
    return ret;
878 879 880 881
}


static int
882 883
virQEMUCapsInitCPU(virCapsPtr caps,
                   virArch arch)
884 885
{
    virCPUDefPtr cpu = NULL;
886
    virCPUDataPtr data = NULL;
887 888 889
    virNodeInfo nodeinfo;
    int ret = -1;

890
    if (VIR_ALLOC(cpu) < 0)
891 892
        goto error;

893 894
    cpu->arch = arch;

895
    if (nodeGetInfo(&nodeinfo))
896 897 898 899 900 901
        goto error;

    cpu->type = VIR_CPU_TYPE_HOST;
    cpu->sockets = nodeinfo.sockets;
    cpu->cores = nodeinfo.cores;
    cpu->threads = nodeinfo.threads;
J
Jiri Denemark 已提交
902
    caps->host.cpu = cpu;
903

904
    if (!(data = cpuNodeData(arch))
905
        || cpuDecode(cpu, data, NULL, 0, NULL) < 0)
J
Jiri Denemark 已提交
906
        goto cleanup;
907 908 909

    ret = 0;

910
 cleanup:
J
Jiri Denemark 已提交
911
    cpuDataFree(data);
912 913 914

    return ret;

915
 error:
916 917 918 919 920
    virCPUDefFree(cpu);
    goto cleanup;
}


921
virCapsPtr virQEMUCapsInit(virQEMUCapsCachePtr cache)
922 923
{
    virCapsPtr caps;
924
    size_t i;
T
Tal Kain 已提交
925
    virArch hostarch = virArchFromHost();
926

T
Tal Kain 已提交
927
    if ((caps = virCapabilitiesNew(hostarch,
928
                                   1, 1)) == NULL)
929
        goto error;
930 931 932 933 934 935 936

    /* Some machines have problematic NUMA toplogy causing
     * unexpected failures. We don't want to break the QEMU
     * driver in this scenario, so log errors & carry on
     */
    if (nodeCapsInitNUMA(caps) < 0) {
        virCapabilitiesFreeNUMAInfo(caps);
937
        VIR_WARN("Failed to query host NUMA topology, disabling NUMA capabilities");
938 939
    }

T
Tal Kain 已提交
940
    if (virQEMUCapsInitCPU(caps, hostarch) < 0)
941
        VIR_WARN("Failed to get host CPU");
942

943 944
    /* Add the power management features of the host */

945
    if (virNodeSuspendGetTargetMask(&caps->host.powerMgmt) < 0)
946 947
        VIR_WARN("Failed to get host power management capabilities");

948 949 950
    virCapabilitiesAddHostMigrateTransport(caps,
                                           "tcp");

951 952 953 954
    /* QEMU can support pretty much every arch that exists,
     * so just probe for them all - we gracefully fail
     * if a qemu-system-$ARCH binary can't be found
     */
955
    for (i = 0; i < VIR_ARCH_LAST; i++)
956
        if (virQEMUCapsInitGuest(caps, cache,
T
Tal Kain 已提交
957
                                 hostarch,
958
                                 i) < 0)
959
            goto error;
960 961 962

    return caps;

963
 error:
964
    virObjectUnref(caps);
965 966 967 968
    return NULL;
}


969
static int
970 971
virQEMUCapsComputeCmdFlags(const char *help,
                           unsigned int version,
972
                           bool is_kvm,
973 974 975
                           unsigned int kvm_version,
                           virQEMUCapsPtr qemuCaps,
                           bool check_yajl ATTRIBUTE_UNUSED)
976 977
{
    const char *p;
R
Richa Marwaha 已提交
978
    const char *fsdev, *netdev;
979 980

    if (strstr(help, "-no-kqemu"))
981
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_KQEMU);
982
    if (strstr(help, "-enable-kqemu"))
983
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU);
984
    if (strstr(help, "-no-kvm"))
985
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM);
986
    if (strstr(help, "-enable-kvm"))
987
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KVM);
988
    if (strstr(help, "-no-reboot"))
989
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_REBOOT);
990
    if (strstr(help, "-name")) {
991
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME);
992
        if (strstr(help, ",process="))
993
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME_PROCESS);
994 995
    }
    if (strstr(help, "-uuid"))
996
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_UUID);
997
    if (strstr(help, "-xen-domid"))
998
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_XEN_DOMID);
999
    else if (strstr(help, "-domid"))
1000
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DOMID);
1001
    if (strstr(help, "-drive")) {
1002 1003
        const char *cache = strstr(help, "cache=");

1004
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE);
1005 1006
        if (cache && (p = strchr(cache, ']'))) {
            if (memmem(cache, p - cache, "on|off", sizeof("on|off") - 1) == NULL)
1007
                virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2);
1008
            if (memmem(cache, p - cache, "directsync", sizeof("directsync") - 1))
1009
                virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
1010
            if (memmem(cache, p - cache, "unsafe", sizeof("unsafe") - 1))
1011
                virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
1012
        }
1013
        if (strstr(help, "format="))
1014
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT);
1015
        if (strstr(help, "readonly="))
1016
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY);
1017
        if (strstr(help, "aio=threads|native"))
1018
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_AIO);
O
Osier Yang 已提交
1019
        if (strstr(help, "copy-on-read=on|off"))
1020
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ);
1021
        if (strstr(help, "bps="))
1022
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE);
1023 1024 1025 1026
    }
    if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) {
        const char *nl = strstr(p, "\n");

1027
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA);
1028 1029

        if (strstr(p, "|qxl"))
1030
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_QXL);
1031
        if ((p = strstr(p, "|none")) && p < nl)
1032
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_NONE);
1033 1034
    }
    if (strstr(help, "-spice"))
1035
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SPICE);
1036
    if (strstr(help, "-vnc"))
1037
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC);
1038
    if (strstr(help, "seamless-migration="))
1039
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION);
1040
    if (strstr(help, "boot=on"))
1041
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_BOOT);
1042
    if (strstr(help, "serial=s"))
1043
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL);
1044
    if (strstr(help, "-pcidevice"))
1045
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCIDEVICE);
1046
    if (strstr(help, "-mem-path"))
1047
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MEM_PATH);
1048
    if (strstr(help, "-chardev")) {
1049
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV);
1050
        if (strstr(help, "-chardev spicevmc"))
1051
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC);
1052 1053
        if (strstr(help, "-chardev spiceport"))
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEPORT);
1054
    }
1055
    if (strstr(help, "-balloon"))
1056
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_BALLOON);
1057
    if (strstr(help, "-device")) {
1058
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
1059 1060 1061 1062
        /*
         * When -device was introduced, qemu already supported drive's
         * readonly option but didn't advertise that.
         */
1063
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY);
1064 1065
    }
    if (strstr(help, "-nodefconfig"))
1066
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NODEFCONFIG);
1067
    if (strstr(help, "-no-user-config"))
1068
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG);
1069 1070
    /* The trailing ' ' is important to avoid a bogus match */
    if (strstr(help, "-rtc "))
1071
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC);
1072 1073
    /* to wit */
    if (strstr(help, "-rtc-td-hack"))
1074
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC_TD_HACK);
1075
    if (strstr(help, "-no-hpet"))
1076
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET);
1077
    if (strstr(help, "-no-acpi"))
1078
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
1079
    if (strstr(help, "-no-kvm-pit-reinjection"))
1080
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_KVM_PIT);
1081
    if (strstr(help, "-tdf"))
1082
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_TDF);
1083
    if (strstr(help, "-enable-nesting"))
1084
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NESTING);
1085
    if (strstr(help, ",menu=on"))
1086
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_BOOT_MENU);
1087
    if (strstr(help, ",reboot-timeout=rb_time"))
1088
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_REBOOT_TIMEOUT);
1089
    if ((fsdev = strstr(help, "-fsdev"))) {
1090
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV);
1091
        if (strstr(fsdev, "readonly"))
1092
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_READONLY);
1093
        if (strstr(fsdev, "writeout"))
1094
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT);
1095
    }
1096
    if (strstr(help, "-smbios type"))
1097
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE);
1098
    if (strstr(help, "-sandbox"))
1099
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX);
1100

R
Richa Marwaha 已提交
1101
    if ((netdev = strstr(help, "-netdev"))) {
1102 1103
        /* Disable -netdev on 0.12 since although it exists,
         * the corresponding netdev_add/remove monitor commands
1104 1105
         * do not, and we need them to be able to do hotplug.
         * But see below about RHEL build. */
R
Richa Marwaha 已提交
1106 1107
        if (version >= 13000) {
            if (strstr(netdev, "bridge"))
1108 1109
                virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE);
           virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
R
Richa Marwaha 已提交
1110
        }
1111 1112 1113
    }

    if (strstr(help, "-sdl"))
1114
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL);
1115 1116 1117
    if (strstr(help, "cores=") &&
        strstr(help, "threads=") &&
        strstr(help, "sockets="))
1118
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY);
1119 1120

    if (version >= 9000)
1121
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_COLON);
1122 1123

    if (is_kvm && (version >= 10000 || kvm_version >= 74))
1124
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNET_HDR);
1125

1126
    if (strstr(help, ",vhost=")) {
1127
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOST_NET);
1128 1129
    }

1130 1131
    /* Do not use -no-shutdown if qemu doesn't support it or SIGTERM handling
     * is most likely buggy when used with -no-shutdown (which applies for qemu
1132
     * 0.14.* and 0.15.0)
1133
     */
1134
    if (strstr(help, "-no-shutdown") && (version < 14000 || version > 15000))
1135
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN);
1136

1137
    if (strstr(help, "dump-guest-core=on|off"))
1138
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_CORE);
1139

O
Olivia Yin 已提交
1140 1141 1142
    if (strstr(help, "-dtb"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DTB);

1143 1144 1145
    if (strstr(help, "-machine"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_OPT);

L
Li Zhang 已提交
1146 1147 1148 1149
     /* USB option is supported v1.3.0 onwards */
    if (qemuCaps->version >= 1003000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_USB_OPT);

1150 1151 1152 1153
    /*
     * Handling of -incoming arg with varying features
     *  -incoming tcp    (kvm >= 79, qemu >= 0.10.0)
     *  -incoming exec   (kvm >= 80, qemu >= 0.10.0)
1154 1155
     *  -incoming unix   (qemu >= 0.12.0)
     *  -incoming fd     (qemu >= 0.12.0)
1156 1157 1158 1159 1160 1161 1162
     *  -incoming stdio  (all earlier kvm)
     *
     * NB, there was a pre-kvm-79 'tcp' support, but it
     * was broken, because it blocked the monitor console
     * while waiting for data, so pretend it doesn't exist
     */
    if (version >= 10000) {
1163 1164
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
1165
        if (version >= 12000) {
1166 1167
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX);
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD);
1168
        }
1169
    } else if (kvm_version >= 79) {
1170
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP);
1171
        if (kvm_version >= 80)
1172
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
1173
    } else if (kvm_version > 0) {
1174
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_KVM_STDIO);
1175 1176 1177
    }

    if (version >= 10000)
1178
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_0_10);
1179

1180
    if (version >= 11000)
1181
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO);
1182

1183 1184 1185
    /* While JSON mode was available in 0.12.0, it was too
     * incomplete to contemplate using. The 0.13.0 release
     * is good enough to use, even though it lacks one or
1186 1187 1188 1189 1190
     * two features. This is also true of versions of qemu
     * built for RHEL, labeled 0.12.1, but with extra text
     * in the help output that mentions that features were
     * backported for libvirt. The benefits of JSON mode now
     * outweigh the downside.
1191
     */
1192
#if WITH_YAJL
1193
    if (version >= 13000) {
1194
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
1195 1196
    } else if (version >= 12000 &&
               strstr(help, "libvirt")) {
1197 1198
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
1199
    }
1200 1201 1202 1203 1204 1205 1206
#else
    /* Starting with qemu 0.15 and newer, upstream qemu no longer
     * promises to keep the human interface stable, but requests that
     * we use QMP (the JSON interface) for everything.  If the user
     * forgot to include YAJL libraries when building their own
     * libvirt but is targetting a newer qemu, we are better off
     * telling them to recompile (the spec file includes the
1207
     * dependency, so distros won't hit this).  This check is
1208
     * also in m4/virt-yajl.m4 (see $with_yajl).  */
1209 1210 1211
    if (version >= 15000 ||
        (version >= 12000 && strstr(help, "libvirt"))) {
        if (check_yajl) {
1212 1213 1214
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("this qemu binary requires libvirt to be "
                             "compiled with yajl"));
1215 1216
            return -1;
        }
1217
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
1218
    }
E
Eric Blake 已提交
1219
#endif
1220 1221

    if (version >= 13000)
1222
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION);
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234

    /* Although very new versions of qemu advertise the presence of
     * the rombar option in the output of "qemu -device pci-assign,?",
     * this advertisement was added to the code long after the option
     * itself. According to qemu developers, though, rombar is
     * available in all qemu binaries from release 0.12 onward.
     * Setting the capability this way makes it available in more
     * cases where it might be needed, and shouldn't cause any false
     * positives (in the case that it did, qemu would produce an error
     * log and refuse to start, so it would be immediately obvious).
     */
    if (version >= 12000)
1235
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_ROMBAR);
1236 1237

    if (version >= 11000)
1238
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_HOST);
1239

1240
    if (version >= 1001000) {
J
Ján Tomko 已提交
1241
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_IPV6_MIGRATION);
1242 1243
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_SHARE_POLICY);
    }
J
Ján Tomko 已提交
1244

1245
    return 0;
1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
}

/* We parse the output of 'qemu -help' to get the QEMU
 * version number. The first bit is easy, just parse
 * 'QEMU PC emulator version x.y.z'
 * or
 * 'QEMU emulator version x.y.z'.
 *
 * With qemu-kvm, however, that is followed by a string
 * in parenthesis as follows:
 *  - qemu-kvm-x.y.z in stable releases
 *  - kvm-XX for kvm versions up to kvm-85
 *  - qemu-kvm-devel-XX for kvm version kvm-86 and later
 *
 * For qemu-kvm versions before 0.10.z, we need to detect
 * the KVM version number for some features. With 0.10.z
 * and later, we just need the QEMU version number and
 * whether it is KVM QEMU or mainline QEMU.
 */
#define QEMU_VERSION_STR_1  "QEMU emulator version"
#define QEMU_VERSION_STR_2  "QEMU PC emulator version"
#define QEMU_KVM_VER_PREFIX "(qemu-kvm-"
#define KVM_VER_PREFIX      "(kvm-"

#define SKIP_BLANKS(p) do { while ((*(p) == ' ') || (*(p) == '\t')) (p)++; } while (0)

1272 1273 1274 1275
int virQEMUCapsParseHelpStr(const char *qemu,
                            const char *help,
                            virQEMUCapsPtr qemuCaps,
                            unsigned int *version,
1276
                            bool *is_kvm,
1277 1278
                            unsigned int *kvm_version,
                            bool check_yajl)
1279 1280 1281
{
    unsigned major, minor, micro;
    const char *p = help;
1282
    char *strflags;
1283

1284 1285
    *version = *kvm_version = 0;
    *is_kvm = false;
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302

    if (STRPREFIX(p, QEMU_VERSION_STR_1))
        p += strlen(QEMU_VERSION_STR_1);
    else if (STRPREFIX(p, QEMU_VERSION_STR_2))
        p += strlen(QEMU_VERSION_STR_2);
    else
        goto fail;

    SKIP_BLANKS(p);

    major = virParseNumber(&p);
    if (major == -1 || *p != '.')
        goto fail;

    ++p;

    minor = virParseNumber(&p);
J
Jiri Denemark 已提交
1303
    if (minor == -1)
1304 1305
        goto fail;

J
Jiri Denemark 已提交
1306 1307 1308 1309 1310 1311 1312 1313
    if (*p != '.') {
        micro = 0;
    } else {
        ++p;
        micro = virParseNumber(&p);
        if (micro == -1)
            goto fail;
    }
1314 1315 1316 1317

    SKIP_BLANKS(p);

    if (STRPREFIX(p, QEMU_KVM_VER_PREFIX)) {
1318
        *is_kvm = true;
1319 1320 1321 1322
        p += strlen(QEMU_KVM_VER_PREFIX);
    } else if (STRPREFIX(p, KVM_VER_PREFIX)) {
        int ret;

1323
        *is_kvm = true;
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
        p += strlen(KVM_VER_PREFIX);

        ret = virParseNumber(&p);
        if (ret == -1)
            goto fail;

        *kvm_version = ret;
    }

    *version = (major * 1000 * 1000) + (minor * 1000) + micro;

1335 1336
    if (virQEMUCapsComputeCmdFlags(help, *version, *is_kvm, *kvm_version,
                                   qemuCaps, check_yajl) < 0)
1337
        goto cleanup;
1338

1339
    strflags = virBitmapString(qemuCaps->flags);
1340 1341 1342
    VIR_DEBUG("Version %u.%u.%u, cooked version %u, flags %s",
              major, minor, micro, *version, NULLSTR(strflags));
    VIR_FREE(strflags);
1343 1344 1345 1346 1347 1348 1349 1350

    if (*kvm_version)
        VIR_DEBUG("KVM version %d detected", *kvm_version);
    else if (*is_kvm)
        VIR_DEBUG("qemu-kvm version %u.%u.%u detected", major, minor, micro);

    return 0;

1351
 fail:
1352
    p = strchr(help, '\n');
1353 1354
    if (!p)
        p = strchr(help, '\0');
1355

1356 1357 1358
    virReportError(VIR_ERR_INTERNAL_ERROR,
                   _("cannot parse %s version number in '%.*s'"),
                   qemu, (int) (p - help), help);
1359

1360
 cleanup:
1361 1362 1363
    return -1;
}

1364

1365
struct virQEMUCapsStringFlags {
1366 1367 1368 1369 1370
    const char *value;
    int flag;
};


1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
struct virQEMUCapsStringFlags virQEMUCapsCommands[] = {
    { "system_wakeup", QEMU_CAPS_WAKEUP },
    { "transaction", QEMU_CAPS_TRANSACTION },
    { "block_job_cancel", QEMU_CAPS_BLOCKJOB_SYNC },
    { "block-job-cancel", QEMU_CAPS_BLOCKJOB_ASYNC },
    { "dump-guest-memory", QEMU_CAPS_DUMP_GUEST_MEMORY },
    { "query-spice", QEMU_CAPS_SPICE },
    { "query-kvm", QEMU_CAPS_KVM },
    { "block-commit", QEMU_CAPS_BLOCK_COMMIT },
    { "query-vnc", QEMU_CAPS_VNC },
    { "drive-mirror", QEMU_CAPS_DRIVE_MIRROR },
    { "blockdev-snapshot-sync", QEMU_CAPS_DISK_SNAPSHOT },
    { "add-fd", QEMU_CAPS_ADD_FD },
    { "nbd-server-start", QEMU_CAPS_NBD_SERVER },
};

1387 1388 1389
struct virQEMUCapsStringFlags virQEMUCapsEvents[] = {
    { "BALLOON_CHANGE", QEMU_CAPS_BALLOON_EVENT },
    { "SPICE_MIGRATE_COMPLETED", QEMU_CAPS_SEAMLESS_MIGRATION },
1390
    { "DEVICE_DELETED", QEMU_CAPS_DEVICE_DEL_EVENT },
1391 1392
};

1393
struct virQEMUCapsStringFlags virQEMUCapsObjectTypes[] = {
1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
    { "hda-duplex", QEMU_CAPS_HDA_DUPLEX },
    { "hda-micro", QEMU_CAPS_HDA_MICRO },
    { "ccid-card-emulated", QEMU_CAPS_CCID_EMULATED },
    { "ccid-card-passthru", QEMU_CAPS_CCID_PASSTHRU },
    { "piix3-usb-uhci", QEMU_CAPS_PIIX3_USB_UHCI },
    { "piix4-usb-uhci", QEMU_CAPS_PIIX4_USB_UHCI },
    { "usb-ehci", QEMU_CAPS_USB_EHCI },
    { "ich9-usb-ehci1", QEMU_CAPS_ICH9_USB_EHCI1 },
    { "vt82c686b-usb-uhci", QEMU_CAPS_VT82C686B_USB_UHCI },
    { "pci-ohci", QEMU_CAPS_PCI_OHCI },
    { "nec-usb-xhci", QEMU_CAPS_NEC_USB_XHCI },
    { "usb-redir", QEMU_CAPS_USB_REDIR },
    { "usb-hub", QEMU_CAPS_USB_HUB },
    { "ich9-ahci", QEMU_CAPS_ICH9_AHCI },
    { "virtio-blk-s390", QEMU_CAPS_VIRTIO_S390 },
1409
    { "virtio-blk-ccw", QEMU_CAPS_VIRTIO_CCW },
1410
    { "sclpconsole", QEMU_CAPS_SCLP_S390 },
1411
    { "lsi53c895a", QEMU_CAPS_SCSI_LSI },
1412
    { "virtio-scsi-pci", QEMU_CAPS_VIRTIO_SCSI },
1413 1414
    { "virtio-scsi-s390", QEMU_CAPS_VIRTIO_SCSI },
    { "virtio-scsi-ccw", QEMU_CAPS_VIRTIO_SCSI },
1415
    { "megasas", QEMU_CAPS_SCSI_MEGASAS },
1416 1417
    { "spicevmc", QEMU_CAPS_DEVICE_SPICEVMC },
    { "qxl-vga", QEMU_CAPS_DEVICE_QXL_VGA },
1418
    { "qxl", QEMU_CAPS_DEVICE_QXL },
1419 1420 1421 1422
    { "sga", QEMU_CAPS_SGA },
    { "scsi-block", QEMU_CAPS_SCSI_BLOCK },
    { "scsi-cd", QEMU_CAPS_SCSI_CD },
    { "ide-cd", QEMU_CAPS_IDE_CD },
1423 1424 1425
    { "VGA", QEMU_CAPS_DEVICE_VGA },
    { "cirrus-vga", QEMU_CAPS_DEVICE_CIRRUS_VGA },
    { "vmware-svga", QEMU_CAPS_DEVICE_VMWARE_SVGA },
H
Han Cheng 已提交
1426 1427
    { "usb-serial", QEMU_CAPS_DEVICE_USB_SERIAL },
    { "usb-net", QEMU_CAPS_DEVICE_USB_NET },
1428
    { "virtio-rng-pci", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1429 1430
    { "virtio-rng-s390", QEMU_CAPS_DEVICE_VIRTIO_RNG },
    { "virtio-rng-ccw", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1431
    { "rng-random", QEMU_CAPS_OBJECT_RNG_RANDOM },
1432
    { "rng-egd", QEMU_CAPS_OBJECT_RNG_EGD },
1433
    { "spapr-nvram", QEMU_CAPS_DEVICE_NVRAM },
1434
    { "pci-bridge", QEMU_CAPS_DEVICE_PCI_BRIDGE },
1435
    { "vfio-pci", QEMU_CAPS_DEVICE_VFIO_PCI },
H
Han Cheng 已提交
1436
    { "scsi-generic", QEMU_CAPS_DEVICE_SCSI_GENERIC },
1437
    { "i82801b11-bridge", QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE },
1438
    { "usb-storage", QEMU_CAPS_DEVICE_USB_STORAGE },
1439
    { "virtio-mmio", QEMU_CAPS_DEVICE_VIRTIO_MMIO },
1440
    { "ich9-intel-hda", QEMU_CAPS_DEVICE_ICH9_INTEL_HDA },
H
Hu Tao 已提交
1441
    { "pvpanic", QEMU_CAPS_DEVICE_PANIC },
L
Li Zhang 已提交
1442
    { "usb-kbd", QEMU_CAPS_DEVICE_USB_KBD },
1443 1444
};

1445
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioBlk[] = {
1446 1447 1448 1449 1450 1451 1452 1453
    { "multifunction", QEMU_CAPS_PCI_MULTIFUNCTION },
    { "bootindex", QEMU_CAPS_BOOTINDEX },
    { "ioeventfd", QEMU_CAPS_VIRTIO_IOEVENTFD },
    { "event_idx", QEMU_CAPS_VIRTIO_BLK_EVENT_IDX },
    { "scsi", QEMU_CAPS_VIRTIO_BLK_SCSI },
    { "logical_block_size", QEMU_CAPS_BLOCKIO },
};

1454
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioNet[] = {
1455 1456 1457 1458
    { "tx", QEMU_CAPS_VIRTIO_TX_ALG },
    { "event_idx", QEMU_CAPS_VIRTIO_NET_EVENT_IDX },
};

1459
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsPciAssign[] = {
1460
    { "rombar", QEMU_CAPS_PCI_ROMBAR },
1461 1462 1463 1464
    { "configfd", QEMU_CAPS_PCI_CONFIGFD },
    { "bootindex", QEMU_CAPS_PCI_BOOTINDEX },
};

1465 1466 1467 1468
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVfioPci[] = {
    { "bootindex", QEMU_CAPS_VFIO_PCI_BOOTINDEX },
};

1469
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsScsiDisk[] = {
1470 1471 1472 1473
    { "channel", QEMU_CAPS_SCSI_DISK_CHANNEL },
    { "wwn", QEMU_CAPS_SCSI_DISK_WWN },
};

1474
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsIDEDrive[] = {
1475 1476 1477
    { "wwn", QEMU_CAPS_IDE_DRIVE_WWN },
};

1478
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsPixx4PM[] = {
1479 1480 1481 1482
    { "disable_s3", QEMU_CAPS_DISABLE_S3 },
    { "disable_s4", QEMU_CAPS_DISABLE_S4 },
};

1483
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUsbRedir[] = {
1484
    { "filter", QEMU_CAPS_USB_REDIR_FILTER },
1485 1486 1487
    { "bootindex", QEMU_CAPS_USB_REDIR_BOOTINDEX },
};

1488
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUsbHost[] = {
1489
    { "bootindex", QEMU_CAPS_USB_HOST_BOOTINDEX },
1490 1491
};

H
Han Cheng 已提交
1492 1493 1494 1495
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsScsiGeneric[] = {
    { "bootindex", QEMU_CAPS_DEVICE_SCSI_GENERIC_BOOTINDEX },
};

1496 1497 1498 1499 1500 1501 1502 1503
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsI440FXPciHost[] = {
    { "pci-hole64-size", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE },
};

static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsQ35PciHost[] = {
    { "pci-hole64-size", QEMU_CAPS_Q35_PCI_HOLE64_SIZE },
};

1504 1505 1506 1507
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUsbStorage[] = {
    { "removable", QEMU_CAPS_USB_STORAGE_REMOVABLE },
};

1508 1509 1510 1511
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsKVMPit[] = {
    { "lost_tick_policy", QEMU_CAPS_KVM_PIT_TICK_POLICY },
};

1512
struct virQEMUCapsObjectTypeProps {
1513
    const char *type;
1514
    struct virQEMUCapsStringFlags *props;
1515 1516 1517
    size_t nprops;
};

1518 1519 1520 1521
static struct virQEMUCapsObjectTypeProps virQEMUCapsObjectProps[] = {
    { "virtio-blk-pci", virQEMUCapsObjectPropsVirtioBlk,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk) },
    { "virtio-net-pci", virQEMUCapsObjectPropsVirtioNet,
1522 1523 1524 1525
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet) },
    { "virtio-blk-ccw", virQEMUCapsObjectPropsVirtioBlk,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk) },
    { "virtio-net-ccw", virQEMUCapsObjectPropsVirtioNet,
1526 1527 1528 1529 1530 1531 1532 1533 1534
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet) },
    { "virtio-blk-s390", virQEMUCapsObjectPropsVirtioBlk,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk) },
    { "virtio-net-s390", virQEMUCapsObjectPropsVirtioNet,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet) },
    { "pci-assign", virQEMUCapsObjectPropsPciAssign,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsPciAssign) },
    { "kvm-pci-assign", virQEMUCapsObjectPropsPciAssign,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsPciAssign) },
1535 1536
    { "vfio-pci", virQEMUCapsObjectPropsVfioPci,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVfioPci) },
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
    { "scsi-disk", virQEMUCapsObjectPropsScsiDisk,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsScsiDisk) },
    { "ide-drive", virQEMUCapsObjectPropsIDEDrive,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsIDEDrive) },
    { "PIIX4_PM", virQEMUCapsObjectPropsPixx4PM,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsPixx4PM) },
    { "usb-redir", virQEMUCapsObjectPropsUsbRedir,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsUsbRedir) },
    { "usb-host", virQEMUCapsObjectPropsUsbHost,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsUsbHost) },
H
Han Cheng 已提交
1547 1548
    { "scsi-generic", virQEMUCapsObjectPropsScsiGeneric,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsScsiGeneric) },
1549 1550 1551 1552
    { "i440FX-pcihost", virQEMUCapsObjectPropsI440FXPciHost,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsI440FXPciHost) },
    { "q35-pcihost", virQEMUCapsObjectPropsQ35PciHost,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsQ35PciHost) },
1553 1554
    { "usb-storage", virQEMUCapsObjectPropsUsbStorage,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsUsbStorage) },
1555 1556
    { "kvm-pit", virQEMUCapsObjectPropsKVMPit,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsKVMPit) },
1557 1558 1559 1560
};


static void
1561 1562 1563 1564 1565
virQEMUCapsProcessStringFlags(virQEMUCapsPtr qemuCaps,
                              size_t nflags,
                              struct virQEMUCapsStringFlags *flags,
                              size_t nvalues,
                              char *const*values)
1566 1567
{
    size_t i, j;
1568 1569
    for (i = 0; i < nflags; i++) {
        for (j = 0; j < nvalues; j++) {
1570
            if (STREQ(values[j], flags[i].value)) {
1571
                virQEMUCapsSet(qemuCaps, flags[i].flag);
1572 1573 1574 1575 1576 1577 1578 1579
                break;
            }
        }
    }
}


static void
1580 1581
virQEMUCapsFreeStringList(size_t len,
                          char **values)
1582 1583
{
    size_t i;
1584
    for (i = 0; i < len; i++)
1585 1586 1587 1588 1589 1590 1591 1592
        VIR_FREE(values[i]);
    VIR_FREE(values);
}


#define OBJECT_TYPE_PREFIX "name \""

static int
1593 1594
virQEMUCapsParseDeviceStrObjectTypes(const char *str,
                                     char ***types)
1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
{
    const char *tmp = str;
    int ret = -1;
    size_t ntypelist = 0;
    char **typelist = NULL;

    *types = NULL;

    while ((tmp = strstr(tmp, OBJECT_TYPE_PREFIX))) {
        char *end;
        tmp += strlen(OBJECT_TYPE_PREFIX);
        end = strstr(tmp, "\"");
        if (!end) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Malformed QEMU device list string, missing quote"));
            goto cleanup;
        }

1613
        if (VIR_EXPAND_N(typelist, ntypelist, 1) < 0)
1614
            goto cleanup;
1615
        if (VIR_STRNDUP(typelist[ntypelist - 1], tmp, end-tmp) < 0)
1616 1617 1618 1619 1620 1621
            goto cleanup;
    }

    *types = typelist;
    ret = ntypelist;

1622
 cleanup:
1623
    if (ret < 0)
1624
        virQEMUCapsFreeStringList(ntypelist, typelist);
1625 1626 1627 1628 1629
    return ret;
}


static int
1630 1631 1632
virQEMUCapsParseDeviceStrObjectProps(const char *str,
                                     const char *type,
                                     char ***props)
1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
{
    const char *tmp = str;
    int ret = -1;
    size_t nproplist = 0;
    char **proplist = NULL;

    VIR_DEBUG("Extract type %s", type);
    *props = NULL;

    while ((tmp = strchr(tmp, '\n'))) {
        char *end;
        tmp += 1;

        if (*tmp == '\0')
            break;

        if (STRPREFIX(tmp, OBJECT_TYPE_PREFIX))
            continue;

        if (!STRPREFIX(tmp, type))
            continue;

        tmp += strlen(type);
        if (*tmp != '.')
            continue;
        tmp++;

        end = strstr(tmp, "=");
        if (!end) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Malformed QEMU device list string, missing '='"));
            goto cleanup;
        }
1666
        if (VIR_EXPAND_N(proplist, nproplist, 1) < 0)
1667
            goto cleanup;
1668
        if (VIR_STRNDUP(proplist[nproplist - 1], tmp, end-tmp) < 0)
1669 1670 1671 1672 1673 1674
            goto cleanup;
    }

    *props = proplist;
    ret = nproplist;

1675
 cleanup:
1676
    if (ret < 0)
1677
        virQEMUCapsFreeStringList(nproplist, proplist);
1678 1679 1680 1681 1682
    return ret;
}


int
1683
virQEMUCapsParseDeviceStr(virQEMUCapsPtr qemuCaps, const char *str)
1684 1685 1686 1687 1688
{
    int nvalues;
    char **values;
    size_t i;

1689
    if ((nvalues = virQEMUCapsParseDeviceStrObjectTypes(str, &values)) < 0)
1690
        return -1;
1691 1692 1693 1694 1695 1696
    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsObjectTypes),
                                  virQEMUCapsObjectTypes,
                                  nvalues, values);
    virQEMUCapsFreeStringList(nvalues, values);

1697
    for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsObjectProps); i++) {
1698 1699 1700 1701
        const char *type = virQEMUCapsObjectProps[i].type;
        if ((nvalues = virQEMUCapsParseDeviceStrObjectProps(str,
                                                            type,
                                                            &values)) < 0)
1702
            return -1;
1703 1704 1705 1706 1707
        virQEMUCapsProcessStringFlags(qemuCaps,
                                      virQEMUCapsObjectProps[i].nprops,
                                      virQEMUCapsObjectProps[i].props,
                                      nvalues, values);
        virQEMUCapsFreeStringList(nvalues, values);
1708 1709 1710
    }

    /* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
1711 1712
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC);
1713 1714 1715 1716 1717

    return 0;
}


E
Eric Blake 已提交
1718
static int
1719 1720
virQEMUCapsExtractDeviceStr(const char *qemu,
                            virQEMUCapsPtr qemuCaps,
1721
                            uid_t runUid, gid_t runGid)
1722
{
E
Eric Blake 已提交
1723
    char *output = NULL;
1724
    virCommandPtr cmd;
E
Eric Blake 已提交
1725
    int ret = -1;
1726

E
Eric Blake 已提交
1727 1728
    /* Cram together all device-related queries into one invocation;
     * the output format makes it possible to distinguish what we
1729 1730
     * need.  With qemu 0.13.0 and later, unrecognized '-device
     * bogus,?' cause an error in isolation, but are silently ignored
1731
     * in combination with '-device ?'.  Upstream qemu 0.12.x doesn't
1732 1733
     * understand '-device name,?', and always exits with status 1 for
     * the simpler '-device ?', so this function is really only useful
1734
     * if -help includes "device driver,?".  */
1735
    cmd = virQEMUCapsProbeCommand(qemu, qemuCaps, runUid, runGid);
1736 1737 1738 1739 1740 1741
    virCommandAddArgList(cmd,
                         "-device", "?",
                         "-device", "pci-assign,?",
                         "-device", "virtio-blk-pci,?",
                         "-device", "virtio-net-pci,?",
                         "-device", "scsi-disk,?",
1742
                         "-device", "PIIX4_PM,?",
1743
                         "-device", "usb-redir,?",
1744
                         "-device", "ide-drive,?",
1745
                         "-device", "usb-host,?",
H
Han Cheng 已提交
1746
                         "-device", "scsi-generic,?",
1747
                         "-device", "usb-storage,?",
1748
                         NULL);
1749
    /* qemu -help goes to stdout, but qemu -device ? goes to stderr.  */
E
Eric Blake 已提交
1750
    virCommandSetErrorBuffer(cmd, &output);
1751

1752
    if (virCommandRun(cmd, NULL) < 0)
1753 1754
        goto cleanup;

1755
    ret = virQEMUCapsParseDeviceStr(qemuCaps, output);
1756

1757
 cleanup:
E
Eric Blake 已提交
1758
    VIR_FREE(output);
1759
    virCommandFree(cmd);
E
Eric Blake 已提交
1760 1761 1762
    return ret;
}

1763

1764 1765 1766
int virQEMUCapsGetDefaultVersion(virCapsPtr caps,
                                 virQEMUCapsCachePtr capsCache,
                                 unsigned int *version)
1767 1768
{
    const char *binary;
1769
    virQEMUCapsPtr qemucaps;
T
Tal Kain 已提交
1770
    virArch hostarch;
1771 1772 1773 1774

    if (*version > 0)
        return 0;

T
Tal Kain 已提交
1775
    hostarch = virArchFromHost();
1776 1777
    if ((binary = virCapabilitiesDefaultGuestEmulator(caps,
                                                      "hvm",
T
Tal Kain 已提交
1778
                                                      hostarch,
1779
                                                      "qemu")) == NULL) {
1780
        virReportError(VIR_ERR_INTERNAL_ERROR,
1781
                       _("Cannot find suitable emulator for %s"),
T
Tal Kain 已提交
1782
                       virArchToString(hostarch));
1783 1784 1785
        return -1;
    }

1786
    if (!(qemucaps = virQEMUCapsCacheLookup(capsCache, binary)))
1787 1788
        return -1;

1789
    *version = virQEMUCapsGetVersion(qemucaps);
1790
    virObjectUnref(qemucaps);
1791 1792
    return 0;
}
1793 1794


1795 1796


1797 1798
virQEMUCapsPtr
virQEMUCapsNew(void)
1799
{
1800
    virQEMUCapsPtr qemuCaps;
1801

1802
    if (virQEMUCapsInitialize() < 0)
1803 1804
        return NULL;

1805
    if (!(qemuCaps = virObjectNew(virQEMUCapsClass)))
1806 1807
        return NULL;

1808
    if (!(qemuCaps->flags = virBitmapNew(QEMU_CAPS_LAST)))
1809
        goto error;
1810

1811
    return qemuCaps;
1812

1813
 error:
1814
    virObjectUnref(qemuCaps);
1815
    return NULL;
1816 1817 1818
}


1819
virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps)
1820
{
1821
    virQEMUCapsPtr ret = virQEMUCapsNew();
1822 1823 1824 1825 1826
    size_t i;

    if (!ret)
        return NULL;

1827
    virBitmapCopy(ret->flags, qemuCaps->flags);
1828

1829 1830 1831 1832
    ret->usedQMP = qemuCaps->usedQMP;
    ret->version = qemuCaps->version;
    ret->kvmVersion = qemuCaps->kvmVersion;
    ret->arch = qemuCaps->arch;
1833

1834
    if (VIR_ALLOC_N(ret->cpuDefinitions, qemuCaps->ncpuDefinitions) < 0)
1835
        goto error;
1836
    ret->ncpuDefinitions = qemuCaps->ncpuDefinitions;
1837
    for (i = 0; i < qemuCaps->ncpuDefinitions; i++) {
1838 1839
        if (VIR_STRDUP(ret->cpuDefinitions[i], qemuCaps->cpuDefinitions[i]) < 0)
            goto error;
1840 1841
    }

1842
    if (VIR_ALLOC_N(ret->machineTypes, qemuCaps->nmachineTypes) < 0)
1843
        goto error;
1844
    if (VIR_ALLOC_N(ret->machineAliases, qemuCaps->nmachineTypes) < 0)
1845
        goto error;
1846
    if (VIR_ALLOC_N(ret->machineMaxCpus, qemuCaps->nmachineTypes) < 0)
1847
        goto error;
1848
    ret->nmachineTypes = qemuCaps->nmachineTypes;
1849
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
1850 1851 1852
        if (VIR_STRDUP(ret->machineTypes[i], qemuCaps->machineTypes[i]) < 0 ||
            VIR_STRDUP(ret->machineAliases[i], qemuCaps->machineAliases[i]) < 0)
            goto error;
1853
        ret->machineMaxCpus[i] = qemuCaps->machineMaxCpus[i];
1854 1855 1856 1857
    }

    return ret;

1858
 error:
1859 1860 1861 1862 1863
    virObjectUnref(ret);
    return NULL;
}


1864
void virQEMUCapsDispose(void *obj)
1865
{
1866
    virQEMUCapsPtr qemuCaps = obj;
1867 1868
    size_t i;

1869
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
1870 1871
        VIR_FREE(qemuCaps->machineTypes[i]);
        VIR_FREE(qemuCaps->machineAliases[i]);
1872
    }
1873 1874
    VIR_FREE(qemuCaps->machineTypes);
    VIR_FREE(qemuCaps->machineAliases);
1875
    VIR_FREE(qemuCaps->machineMaxCpus);
1876

1877
    for (i = 0; i < qemuCaps->ncpuDefinitions; i++) {
1878
        VIR_FREE(qemuCaps->cpuDefinitions[i]);
1879
    }
1880
    VIR_FREE(qemuCaps->cpuDefinitions);
1881

1882
    virBitmapFree(qemuCaps->flags);
1883

1884
    VIR_FREE(qemuCaps->binary);
1885 1886
}

1887
void
1888 1889
virQEMUCapsSet(virQEMUCapsPtr qemuCaps,
               enum virQEMUCapsFlags flag)
1890
{
1891
    ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
1892 1893 1894 1895
}


void
1896
virQEMUCapsSetList(virQEMUCapsPtr qemuCaps, ...)
1897 1898 1899 1900
{
    va_list list;
    int flag;

1901
    va_start(list, qemuCaps);
1902
    while ((flag = va_arg(list, int)) < QEMU_CAPS_LAST)
1903
        ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
1904
    va_end(list);
1905 1906 1907 1908
}


void
1909 1910
virQEMUCapsClear(virQEMUCapsPtr qemuCaps,
                 enum virQEMUCapsFlags flag)
1911
{
1912
    ignore_value(virBitmapClearBit(qemuCaps->flags, flag));
1913 1914 1915
}


1916
char *virQEMUCapsFlagsString(virQEMUCapsPtr qemuCaps)
1917
{
1918
    return virBitmapString(qemuCaps->flags);
1919 1920 1921 1922
}


bool
1923 1924
virQEMUCapsGet(virQEMUCapsPtr qemuCaps,
               enum virQEMUCapsFlags flag)
1925
{
1926 1927
    bool b;

1928
    if (!qemuCaps || virBitmapGetBit(qemuCaps->flags, flag, &b) < 0)
1929 1930 1931
        return false;
    else
        return b;
1932
}
1933 1934


1935
const char *virQEMUCapsGetBinary(virQEMUCapsPtr qemuCaps)
1936
{
1937
    return qemuCaps->binary;
1938 1939
}

1940
virArch virQEMUCapsGetArch(virQEMUCapsPtr qemuCaps)
1941
{
1942
    return qemuCaps->arch;
1943 1944 1945
}


1946
unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr qemuCaps)
1947
{
1948
    return qemuCaps->version;
1949 1950 1951
}


1952
unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr qemuCaps)
1953
{
1954
    return qemuCaps->kvmVersion;
1955 1956 1957
}


1958 1959
int virQEMUCapsAddCPUDefinition(virQEMUCapsPtr qemuCaps,
                                const char *name)
1960
{
1961 1962 1963
    char *tmp;

    if (VIR_STRDUP(tmp, name) < 0)
1964
        return -1;
1965
    if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0) {
1966 1967 1968
        VIR_FREE(tmp);
        return -1;
    }
1969
    qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions-1] = tmp;
1970 1971 1972 1973
    return 0;
}


1974 1975
size_t virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr qemuCaps,
                                    char ***names)
1976
{
1977
    if (names)
1978 1979
        *names = qemuCaps->cpuDefinitions;
    return qemuCaps->ncpuDefinitions;
1980 1981 1982
}


1983 1984
size_t virQEMUCapsGetMachineTypes(virQEMUCapsPtr qemuCaps,
                                  char ***names)
1985
{
1986
    if (names)
1987 1988
        *names = qemuCaps->machineTypes;
    return qemuCaps->nmachineTypes;
1989 1990
}

1991 1992 1993
int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr qemuCaps,
                                   size_t *nmachines,
                                   virCapsGuestMachinePtr **machines)
1994 1995 1996 1997 1998
{
    size_t i;

    *nmachines = 0;
    *machines = NULL;
1999
    if (VIR_ALLOC_N(*machines, qemuCaps->nmachineTypes) < 0)
2000
        goto error;
2001
    *nmachines = qemuCaps->nmachineTypes;
2002

2003
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2004 2005
        virCapsGuestMachinePtr mach;
        if (VIR_ALLOC(mach) < 0)
2006
            goto error;
2007
        if (qemuCaps->machineAliases[i]) {
2008 2009 2010
            if (VIR_STRDUP(mach->name, qemuCaps->machineAliases[i]) < 0 ||
                VIR_STRDUP(mach->canonical, qemuCaps->machineTypes[i]) < 0)
                goto error;
2011
        } else {
2012 2013
            if (VIR_STRDUP(mach->name, qemuCaps->machineTypes[i]) < 0)
                goto error;
2014
        }
2015
        mach->maxCpus = qemuCaps->machineMaxCpus[i];
2016 2017 2018 2019 2020
        (*machines)[i] = mach;
    }

    return 0;

2021
 error:
2022 2023 2024 2025 2026 2027 2028 2029
    virCapabilitiesFreeMachines(*machines, *nmachines);
    *nmachines = 0;
    *machines = NULL;
    return -1;
}



2030

2031 2032
const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps,
                                           const char *name)
2033 2034 2035
{
    size_t i;

2036 2037 2038
    if (!name)
        return NULL;

2039
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2040
        if (!qemuCaps->machineAliases[i])
2041
            continue;
2042 2043
        if (STREQ(qemuCaps->machineAliases[i], name))
            return qemuCaps->machineTypes[i];
2044 2045 2046 2047
    }

    return name;
}
2048 2049


2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
int virQEMUCapsGetMachineMaxCpus(virQEMUCapsPtr qemuCaps,
                                 const char *name)
{
    size_t i;

    if (!name)
        return 0;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
        if (!qemuCaps->machineMaxCpus[i])
            continue;
        if (STREQ(qemuCaps->machineTypes[i], name))
            return qemuCaps->machineMaxCpus[i];
    }

    return 0;
}


2069
static int
2070 2071
virQEMUCapsProbeQMPCommands(virQEMUCapsPtr qemuCaps,
                            qemuMonitorPtr mon)
2072 2073 2074 2075 2076 2077 2078
{
    char **commands = NULL;
    int ncommands;

    if ((ncommands = qemuMonitorGetCommands(mon, &commands)) < 0)
        return -1;

2079 2080 2081 2082 2083
    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsCommands),
                                  virQEMUCapsCommands,
                                  ncommands, commands);
    virQEMUCapsFreeStringList(ncommands, commands);
2084

2085 2086 2087 2088
    /* QMP add-fd was introduced in 1.2, but did not support
     * management control of set numbering, and did not have a
     * counterpart -add-fd command line option.  We require the
     * add-fd features from 1.3 or later.  */
2089
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ADD_FD)) {
2090 2091 2092 2093 2094 2095 2096
        int fd = open("/dev/null", O_RDONLY);
        if (fd < 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("unable to probe for add-fd"));
            return -1;
        }
        if (qemuMonitorAddFd(mon, 0, fd, "/dev/null") < 0)
2097
            virQEMUCapsClear(qemuCaps, QEMU_CAPS_ADD_FD);
2098 2099 2100
        VIR_FORCE_CLOSE(fd);
    }

2101 2102 2103 2104 2105
    return 0;
}


static int
2106 2107
virQEMUCapsProbeQMPEvents(virQEMUCapsPtr qemuCaps,
                          qemuMonitorPtr mon)
2108 2109 2110 2111 2112 2113 2114
{
    char **events = NULL;
    int nevents;

    if ((nevents = qemuMonitorGetEvents(mon, &events)) < 0)
        return -1;

2115 2116 2117 2118 2119
    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsEvents),
                                  virQEMUCapsEvents,
                                  nevents, events);
    virQEMUCapsFreeStringList(nevents, events);
2120 2121 2122 2123 2124

    return 0;
}


2125
static int
2126 2127
virQEMUCapsProbeQMPObjects(virQEMUCapsPtr qemuCaps,
                           qemuMonitorPtr mon)
2128 2129 2130 2131 2132 2133 2134
{
    int nvalues;
    char **values;
    size_t i;

    if ((nvalues = qemuMonitorGetObjectTypes(mon, &values)) < 0)
        return -1;
2135 2136 2137 2138 2139 2140
    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsObjectTypes),
                                  virQEMUCapsObjectTypes,
                                  nvalues, values);
    virQEMUCapsFreeStringList(nvalues, values);

2141
    for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsObjectProps); i++) {
2142
        const char *type = virQEMUCapsObjectProps[i].type;
2143 2144 2145 2146
        if ((nvalues = qemuMonitorGetObjectProps(mon,
                                                 type,
                                                 &values)) < 0)
            return -1;
2147 2148 2149 2150 2151
        virQEMUCapsProcessStringFlags(qemuCaps,
                                      virQEMUCapsObjectProps[i].nprops,
                                      virQEMUCapsObjectProps[i].props,
                                      nvalues, values);
        virQEMUCapsFreeStringList(nvalues, values);
2152 2153 2154
    }

    /* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
2155 2156
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC);
2157
    /* If qemu supports newer -device qxl it supports -vga qxl as well */
2158 2159
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_QXL);
2160 2161 2162 2163 2164 2165

    return 0;
}


static int
2166 2167
virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr qemuCaps,
                                qemuMonitorPtr mon)
2168 2169 2170 2171 2172
{
    qemuMonitorMachineInfoPtr *machines = NULL;
    int nmachines = 0;
    int ret = -1;
    size_t i;
2173
    size_t defIdx = 0;
2174 2175 2176 2177

    if ((nmachines = qemuMonitorGetMachines(mon, &machines)) < 0)
        goto cleanup;

2178
    if (VIR_ALLOC_N(qemuCaps->machineTypes, nmachines) < 0)
2179
        goto cleanup;
2180
    if (VIR_ALLOC_N(qemuCaps->machineAliases, nmachines) < 0)
2181
        goto cleanup;
2182
    if (VIR_ALLOC_N(qemuCaps->machineMaxCpus, nmachines) < 0)
2183
        goto cleanup;
2184

2185
    for (i = 0; i < nmachines; i++) {
2186 2187
        if (STREQ(machines[i]->name, "none"))
            continue;
2188 2189 2190 2191 2192
        qemuCaps->nmachineTypes++;
        if (VIR_STRDUP(qemuCaps->machineAliases[qemuCaps->nmachineTypes -1],
                       machines[i]->alias) < 0 ||
            VIR_STRDUP(qemuCaps->machineTypes[qemuCaps->nmachineTypes - 1],
                       machines[i]->name) < 0)
2193
            goto cleanup;
2194
        if (machines[i]->isDefault)
2195
            defIdx = qemuCaps->nmachineTypes - 1;
2196 2197
        qemuCaps->machineMaxCpus[qemuCaps->nmachineTypes - 1] =
            machines[i]->maxCpus;
2198
    }
2199 2200

    if (defIdx)
2201
        virQEMUCapsSetDefaultMachine(qemuCaps, defIdx);
2202 2203 2204

    ret = 0;

2205
 cleanup:
2206
    for (i = 0; i < nmachines; i++)
2207 2208 2209 2210 2211 2212 2213
        qemuMonitorMachineInfoFree(machines[i]);
    VIR_FREE(machines);
    return ret;
}


static int
2214 2215
virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr qemuCaps,
                                  qemuMonitorPtr mon)
2216 2217 2218 2219 2220 2221 2222
{
    int ncpuDefinitions;
    char **cpuDefinitions;

    if ((ncpuDefinitions = qemuMonitorGetCPUDefinitions(mon, &cpuDefinitions)) < 0)
        return -1;

2223 2224
    qemuCaps->ncpuDefinitions = ncpuDefinitions;
    qemuCaps->cpuDefinitions = cpuDefinitions;
2225 2226 2227 2228

    return 0;
}

2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251
struct tpmTypeToCaps {
    int type;
    enum virQEMUCapsFlags caps;
};

static const struct tpmTypeToCaps virQEMUCapsTPMTypesToCaps[] = {
    {
        .type = VIR_DOMAIN_TPM_TYPE_PASSTHROUGH,
        .caps = QEMU_CAPS_DEVICE_TPM_PASSTHROUGH,
    },
};

const struct tpmTypeToCaps virQEMUCapsTPMModelsToCaps[] = {
    {
        .type = VIR_DOMAIN_TPM_MODEL_TIS,
        .caps = QEMU_CAPS_DEVICE_TPM_TIS,
    },
};

static int
virQEMUCapsProbeQMPTPM(virQEMUCapsPtr qemuCaps,
                       qemuMonitorPtr mon)
{
2252 2253
    int nentries;
    size_t i;
2254
    char **entries = NULL;
S
Stefan Berger 已提交
2255

2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285
    if ((nentries = qemuMonitorGetTPMModels(mon, &entries)) < 0)
        return -1;

    if (nentries > 0) {
        for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsTPMModelsToCaps); i++) {
            const char *needle = virDomainTPMModelTypeToString(
                virQEMUCapsTPMModelsToCaps[i].type);
            if (virStringArrayHasString(entries, needle))
                virQEMUCapsSet(qemuCaps,
                               virQEMUCapsTPMModelsToCaps[i].caps);
        }
    }
    virStringFreeList(entries);

    if ((nentries = qemuMonitorGetTPMTypes(mon, &entries)) < 0)
        return -1;

    if (nentries > 0) {
        for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsTPMTypesToCaps); i++) {
            const char *needle = virDomainTPMBackendTypeToString(
                virQEMUCapsTPMTypesToCaps[i].type);
            if (virStringArrayHasString(entries, needle))
                virQEMUCapsSet(qemuCaps, virQEMUCapsTPMTypesToCaps[i].caps);
        }
    }
    virStringFreeList(entries);

    return 0;
}

2286

2287
static int
2288 2289
virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr qemuCaps,
                            qemuMonitorPtr mon)
2290 2291 2292 2293
{
    bool enabled = false;
    bool present = false;

2294
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
2295 2296 2297 2298 2299 2300
        return 0;

    if (qemuMonitorGetKVMState(mon, &enabled, &present) < 0)
        return -1;

    /* The QEMU_CAPS_KVM flag was initially set according to the QEMU
2301 2302 2303 2304 2305 2306 2307 2308
     * reporting the recognition of 'query-kvm' QMP command. That merely
     * indicates existance of the command though, not whether KVM support
     * is actually available, nor whether it is enabled by default.
     *
     * If it is not present we need to clear the flag, and if it is
     * not enabled by default we need to change the flag.
     */
    if (!present) {
2309
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_KVM);
2310
    } else if (!enabled) {
2311 2312
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_KVM);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KVM);
2313 2314 2315 2316 2317
    }

    return 0;
}

2318 2319 2320 2321 2322 2323 2324 2325
struct virQEMUCapsCommandLineProps {
    const char *option;
    const char *param;
    int flag;
};

static struct virQEMUCapsCommandLineProps virQEMUCapsCommandLine[] = {
    { "machine", "mem-merge", QEMU_CAPS_MEM_MERGE },
O
Osier Yang 已提交
2326
    { "drive", "discard", QEMU_CAPS_DRIVE_DISCARD },
2327
    { "realtime", "mlock", QEMU_CAPS_MLOCK },
2328
    { "boot-opts", "strict", QEMU_CAPS_BOOT_STRICT },
2329
    { "boot-opts", "reboot-timeout", QEMU_CAPS_REBOOT_TIMEOUT },
2330
    { "spice", "disable-agent-file-xfer", QEMU_CAPS_SPICE_FILE_XFER_DISABLE },
2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
};

static int
virQEMUCapsProbeQMPCommandLine(virQEMUCapsPtr qemuCaps,
                               qemuMonitorPtr mon)
{
    int nvalues;
    char **values;
    size_t i, j;

    for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsCommandLine); i++) {
        if ((nvalues = qemuMonitorGetCommandLineOptionParameters(mon,
                                                                 virQEMUCapsCommandLine[i].option,
                                                                 &values)) < 0)
            return -1;
        for (j = 0; j < nvalues; j++) {
            if (STREQ(virQEMUCapsCommandLine[i].param, values[j])) {
                virQEMUCapsSet(qemuCaps, virQEMUCapsCommandLine[i].flag);
                break;
            }
        }
        virStringFreeList(values);
    }

    return 0;
}
2357

2358 2359
int virQEMUCapsProbeQMP(virQEMUCapsPtr qemuCaps,
                        qemuMonitorPtr mon)
2360
{
2361
    VIR_DEBUG("qemuCaps=%p mon=%p", qemuCaps, mon);
2362

2363
    if (qemuCaps->usedQMP)
2364 2365
        return 0;

2366
    if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0)
2367 2368
        return -1;

2369
    if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0)
2370 2371 2372 2373 2374 2375
        return -1;

    return 0;
}


2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401
/*
 * Parsing a doc that looks like
 *
 * <qemuCaps>
 *   <qemuctime>234235253</qemuctime>
 *   <selfctime>234235253</selfctime>
 *   <usedQMP/>
 *   <flag name='foo'/>
 *   <flag name='bar'/>
 *   ...
 *   <cpu name="pentium3"/>
 *   ...
 *   <machine name="pc-1.0" alias="pc" maxCpus="4"/>
 *   ...
 * </qemuCaps>
 */
static int
virQEMUCapsLoadCache(virQEMUCapsPtr qemuCaps, const char *filename,
                     time_t *qemuctime, time_t *selfctime)
{
    xmlDocPtr doc = NULL;
    int ret = -1;
    size_t i;
    int n;
    xmlNodePtr *nodes = NULL;
    xmlXPathContextPtr ctxt = NULL;
J
Ján Tomko 已提交
2402
    char *str = NULL;
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
    long long int l;

    if (!(doc = virXMLParseFile(filename)))
        goto cleanup;

    if (!(ctxt = xmlXPathNewContext(doc))) {
        virReportOOMError();
        goto cleanup;
    }

    ctxt->node = xmlDocGetRootElement(doc);

    if (STRNEQ((const char *)ctxt->node->name, "qemuCaps")) {
        virReportError(VIR_ERR_XML_ERROR,
                       _("unexpected root element <%s>, "
                         "expecting <qemuCaps>"),
                       ctxt->node->name);
        goto cleanup;
    }

    if (virXPathLongLong("string(./qemuctime)", ctxt, &l) < 0) {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing qemuctime in QEMU capabilities XML"));
        goto cleanup;
    }
    *qemuctime = (time_t)l;

    if (virXPathLongLong("string(./selfctime)", ctxt, &l) < 0) {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing selfctime in QEMU capabilities XML"));
        goto cleanup;
    }
    *selfctime = (time_t)l;

    qemuCaps->usedQMP = virXPathBoolean("count(./usedQMP) > 0",
                                        ctxt) > 0;

    if ((n = virXPathNodeSet("./flag", ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities flags"));
        goto cleanup;
    }
    VIR_DEBUG("Got flags %d", n);
    if (n > 0) {
        for (i = 0; i < n; i++) {
            int flag;
            if (!(str = virXMLPropString(nodes[i], "name"))) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing flag name in QEMU capabilities cache"));
                goto cleanup;
            }
            flag = virQEMUCapsTypeFromString(str);
            if (flag < 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Unknown qemu capabilities flag %s"), str);
                goto cleanup;
            }
            VIR_FREE(str);
            virQEMUCapsSet(qemuCaps, flag);
        }
    }
    VIR_FREE(nodes);

    if (virXPathUInt("string(./version)", ctxt, &qemuCaps->version) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing version in QEMU capabilities cache"));
        goto cleanup;
    }

    if (virXPathUInt("string(./kvmVersion)", ctxt, &qemuCaps->kvmVersion) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing version in QEMU capabilities cache"));
        goto cleanup;
    }

    if (!(str = virXPathString("string(./arch)", ctxt))) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing arch in QEMU capabilities cache"));
        goto cleanup;
    }
    if (!(qemuCaps->arch = virArchFromString(str))) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unknown arch %s in QEMU capabilities cache"), str);
        goto cleanup;
    }
J
Ján Tomko 已提交
2488
    VIR_FREE(str);
2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501

    if ((n = virXPathNodeSet("./cpu", ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities cpus"));
        goto cleanup;
    }
    if (n > 0) {
        qemuCaps->ncpuDefinitions = n;
        if (VIR_ALLOC_N(qemuCaps->cpuDefinitions,
                        qemuCaps->ncpuDefinitions) < 0)
            goto cleanup;

        for (i = 0; i < n; i++) {
J
Ján Tomko 已提交
2502
            if (!(qemuCaps->cpuDefinitions[i] = virXMLPropString(nodes[i], "name"))) {
2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing cpu name in QEMU capabilities cache"));
                goto cleanup;
            }
        }
    }
    VIR_FREE(nodes);


    if ((n = virXPathNodeSet("./machine", ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities machines"));
        goto cleanup;
    }
    if (n > 0) {
        qemuCaps->nmachineTypes = n;
        if (VIR_ALLOC_N(qemuCaps->machineTypes,
                        qemuCaps->nmachineTypes) < 0 ||
            VIR_ALLOC_N(qemuCaps->machineAliases,
                        qemuCaps->nmachineTypes) < 0 ||
            VIR_ALLOC_N(qemuCaps->machineMaxCpus,
                        qemuCaps->nmachineTypes) < 0)
            goto cleanup;

        for (i = 0; i < n; i++) {
J
Ján Tomko 已提交
2528
            if (!(qemuCaps->machineTypes[i] = virXMLPropString(nodes[i], "name"))) {
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing machine name in QEMU capabilities cache"));
                goto cleanup;
            }
            qemuCaps->machineAliases[i] = virXMLPropString(nodes[i], "alias");

            str = virXMLPropString(nodes[i], "maxCpus");
            if (str &&
                virStrToLong_ui(str, NULL, 10, &(qemuCaps->machineMaxCpus[i])) < 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed machine cpu count in QEMU capabilities cache"));
                goto cleanup;
            }
J
Ján Tomko 已提交
2542
            VIR_FREE(str);
2543 2544 2545 2546 2547
        }
    }
    VIR_FREE(nodes);

    ret = 0;
2548
 cleanup:
J
Ján Tomko 已提交
2549
    VIR_FREE(str);
2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565
    VIR_FREE(nodes);
    xmlXPathFreeContext(ctxt);
    xmlFreeDoc(doc);
    return ret;
}


static int
virQEMUCapsSaveCache(virQEMUCapsPtr qemuCaps, const char *filename)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    const char *xml = NULL;
    int ret = -1;
    size_t i;

    virBufferAddLit(&buf, "<qemuCaps>\n");
2566
    virBufferAdjustIndent(&buf, 2);
2567

2568
    virBufferAsprintf(&buf, "<qemuctime>%llu</qemuctime>\n",
2569
                      (long long)qemuCaps->ctime);
2570
    virBufferAsprintf(&buf, "<selfctime>%llu</selfctime>\n",
2571 2572 2573
                      (long long)virGetSelfLastChanged());

    if (qemuCaps->usedQMP)
2574
        virBufferAddLit(&buf, "<usedQMP/>\n");
2575 2576 2577

    for (i = 0; i < QEMU_CAPS_LAST; i++) {
        if (virQEMUCapsGet(qemuCaps, i)) {
2578
            virBufferAsprintf(&buf, "<flag name='%s'/>\n",
2579 2580 2581 2582
                              virQEMUCapsTypeToString(i));
        }
    }

2583
    virBufferAsprintf(&buf, "<version>%d</version>\n",
2584 2585
                      qemuCaps->version);

2586
    virBufferAsprintf(&buf, "<kvmVersion>%d</kvmVersion>\n",
2587 2588
                      qemuCaps->kvmVersion);

2589
    virBufferAsprintf(&buf, "<arch>%s</arch>\n",
2590 2591 2592
                      virArchToString(qemuCaps->arch));

    for (i = 0; i < qemuCaps->ncpuDefinitions; i++) {
2593
        virBufferEscapeString(&buf, "<cpu name='%s'/>\n",
2594 2595 2596 2597
                              qemuCaps->cpuDefinitions[i]);
    }

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2598
        virBufferEscapeString(&buf, "<machine name='%s'",
2599 2600 2601 2602 2603 2604 2605 2606
                              qemuCaps->machineTypes[i]);
        if (qemuCaps->machineAliases[i])
            virBufferEscapeString(&buf, " alias='%s'",
                              qemuCaps->machineAliases[i]);
        virBufferAsprintf(&buf, " maxCpus='%u'/>\n",
                          qemuCaps->machineMaxCpus[i]);
    }

2607
    virBufferAdjustIndent(&buf, -2);
2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692
    virBufferAddLit(&buf, "</qemuCaps>\n");

    if (virBufferError(&buf))
        goto cleanup;

    xml = virBufferContentAndReset(&buf);

    if (virFileWriteStr(filename, xml, 0600) < 0) {
        virReportSystemError(errno,
                             _("Failed to save '%s' for '%s'"),
                             filename, qemuCaps->binary);
        goto cleanup;
    }

    VIR_DEBUG("Saved caps '%s' for '%s' with (%lld, %lld)",
              filename, qemuCaps->binary,
              (long long)qemuCaps->ctime,
              (long long)virGetSelfLastChanged());

    ret = 0;
 cleanup:
    VIR_FREE(xml);
    return ret;
}

static int
virQEMUCapsRememberCached(virQEMUCapsPtr qemuCaps, const char *cacheDir)
{
    char *capsdir = NULL;
    char *capsfile = NULL;
    int ret = -1;
    char *binaryhash = NULL;

    if (virAsprintf(&capsdir, "%s/capabilities", cacheDir) < 0)
        goto cleanup;

    if (virCryptoHashString(VIR_CRYPTO_HASH_SHA256,
                            qemuCaps->binary,
                            &binaryhash) < 0)
        goto cleanup;

    if (virAsprintf(&capsfile, "%s/%s.xml", capsdir, binaryhash) < 0)
        goto cleanup;

    if (virFileMakePath(capsdir) < 0) {
        virReportSystemError(errno,
                             _("Unable to create directory '%s'"),
                             capsdir);
        goto cleanup;
    }

    if (virQEMUCapsSaveCache(qemuCaps, capsfile) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    VIR_FREE(binaryhash);
    VIR_FREE(capsfile);
    VIR_FREE(capsdir);
    return ret;
}


static void
virQEMUCapsReset(virQEMUCapsPtr qemuCaps)
{
    size_t i;

    virBitmapClearAll(qemuCaps->flags);
    qemuCaps->version = qemuCaps->kvmVersion = 0;
    qemuCaps->arch = VIR_ARCH_NONE;
    qemuCaps->usedQMP = false;

    for (i = 0; i < qemuCaps->ncpuDefinitions; i++) {
        VIR_FREE(qemuCaps->cpuDefinitions[i]);
    }
    VIR_FREE(qemuCaps->cpuDefinitions);
    qemuCaps->ncpuDefinitions = 0;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
        VIR_FREE(qemuCaps->machineTypes[i]);
        VIR_FREE(qemuCaps->machineAliases[i]);
    }
    VIR_FREE(qemuCaps->machineTypes);
    VIR_FREE(qemuCaps->machineAliases);
J
Ján Tomko 已提交
2693
    VIR_FREE(qemuCaps->machineMaxCpus);
2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777
    qemuCaps->nmachineTypes = 0;
}


static int
virQEMUCapsInitCached(virQEMUCapsPtr qemuCaps, const char *cacheDir)
{
    char *capsdir = NULL;
    char *capsfile = NULL;
    int ret = -1;
    char *binaryhash = NULL;
    struct stat sb;
    time_t qemuctime;
    time_t selfctime;

    if (virAsprintf(&capsdir, "%s/capabilities", cacheDir) < 0)
        goto cleanup;

    if (virCryptoHashString(VIR_CRYPTO_HASH_SHA256,
                            qemuCaps->binary,
                            &binaryhash) < 0)
        goto cleanup;

    if (virAsprintf(&capsfile, "%s/%s.xml", capsdir, binaryhash) < 0)
        goto cleanup;

    if (virFileMakePath(capsdir) < 0) {
        virReportSystemError(errno,
                             _("Unable to create directory '%s'"),
                             capsdir);
        goto cleanup;
    }

    if (stat(capsfile, &sb) < 0) {
        if (errno == ENOENT) {
            VIR_DEBUG("No cached capabilities '%s' for '%s'",
                      capsfile, qemuCaps->binary);
            ret = 0;
            goto cleanup;
        }
        virReportSystemError(errno,
                             _("Unable to access cache '%s' for '%s'"),
                             capsfile, qemuCaps->binary);
        goto cleanup;
    }

    if (virQEMUCapsLoadCache(qemuCaps, capsfile, &qemuctime, &selfctime) < 0) {
        virErrorPtr err = virGetLastError();
        VIR_WARN("Failed to load cached caps from '%s' for '%s': %s",
                 capsfile, qemuCaps->binary, err ? NULLSTR(err->message) :
                 _("unknown error"));
        virResetLastError();
        ret = 0;
        virQEMUCapsReset(qemuCaps);
        goto cleanup;
    }

    /* Discard if cache is older that QEMU binary */
    if (qemuctime != qemuCaps->ctime ||
        selfctime < virGetSelfLastChanged()) {
        VIR_DEBUG("Outdated cached capabilities '%s' for '%s' "
                  "(%lld vs %lld, %lld vs %lld)",
                  capsfile, qemuCaps->binary,
                  (long long)qemuctime, (long long)qemuCaps->ctime,
                  (long long)selfctime, (long long)virGetSelfLastChanged());
        ignore_value(unlink(capsfile));
        virQEMUCapsReset(qemuCaps);
        ret = 0;
        goto cleanup;
    }

    VIR_DEBUG("Loaded '%s' for '%s' ctime %lld usedQMP=%d",
              capsfile, qemuCaps->binary,
              (long long)qemuCaps->ctime, qemuCaps->usedQMP);

    ret = 1;
 cleanup:
    VIR_FREE(binaryhash);
    VIR_FREE(capsfile);
    VIR_FREE(capsdir);
    return ret;
}


2778 2779
#define QEMU_SYSTEM_PREFIX "qemu-system-"

2780
static int
2781
virQEMUCapsInitHelp(virQEMUCapsPtr qemuCaps, uid_t runUid, gid_t runGid)
2782
{
2783
    virCommandPtr cmd = NULL;
2784
    bool is_kvm;
2785
    char *help = NULL;
2786 2787
    int ret = -1;
    const char *tmp;
2788

2789
    VIR_DEBUG("qemuCaps=%p", qemuCaps);
2790

2791
    tmp = strstr(qemuCaps->binary, QEMU_SYSTEM_PREFIX);
2792 2793
    if (tmp) {
        tmp += strlen(QEMU_SYSTEM_PREFIX);
2794

2795
        qemuCaps->arch = virQEMUCapsArchFromString(tmp);
2796
    } else {
2797
        qemuCaps->arch = virArchFromHost();
2798 2799
    }

2800
    cmd = virQEMUCapsProbeCommand(qemuCaps->binary, NULL, runUid, runGid);
2801 2802 2803 2804
    virCommandAddArgList(cmd, "-help", NULL);
    virCommandSetOutputBuffer(cmd, &help);

    if (virCommandRun(cmd, NULL) < 0)
2805
        goto cleanup;
2806

2807 2808 2809 2810 2811 2812
    if (virQEMUCapsParseHelpStr(qemuCaps->binary,
                                help, qemuCaps,
                                &qemuCaps->version,
                                &is_kvm,
                                &qemuCaps->kvmVersion,
                                false) < 0)
2813
        goto cleanup;
2814 2815

    /* Currently only x86_64 and i686 support PCI-multibus. */
2816 2817 2818
    if (qemuCaps->arch == VIR_ARCH_X86_64 ||
        qemuCaps->arch == VIR_ARCH_I686) {
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS);
2819 2820 2821
    } else {
        /* -no-acpi is not supported on other archs
         * even if qemu reports it in -help */
2822
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_NO_ACPI);
2823
    }
2824

2825
    /* virQEMUCapsExtractDeviceStr will only set additional caps if qemu
2826
     * understands the 0.13.0+ notion of "-device driver,".  */
2827
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE) &&
2828
        strstr(help, "-device driver,?") &&
2829 2830
        virQEMUCapsExtractDeviceStr(qemuCaps->binary,
                                    qemuCaps, runUid, runGid) < 0) {
2831
        goto cleanup;
2832
    }
2833

2834
    if (virQEMUCapsProbeCPUModels(qemuCaps, runUid, runGid) < 0)
2835
        goto cleanup;
2836

2837
    if (virQEMUCapsProbeMachineTypes(qemuCaps, runUid, runGid) < 0)
2838
        goto cleanup;
2839

2840
    ret = 0;
2841
 cleanup:
2842
    virCommandFree(cmd);
2843
    VIR_FREE(help);
2844 2845 2846 2847
    return ret;
}


2848
static void virQEMUCapsMonitorNotify(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
2849 2850
                                     virDomainObjPtr vm ATTRIBUTE_UNUSED,
                                     void *opaque ATTRIBUTE_UNUSED)
2851 2852 2853 2854
{
}

static qemuMonitorCallbacks callbacks = {
2855 2856
    .eofNotify = virQEMUCapsMonitorNotify,
    .errorNotify = virQEMUCapsMonitorNotify,
2857 2858 2859 2860 2861 2862 2863
};


/* Capabilities that we assume are always enabled
 * for QEMU >= 1.2.0
 */
static void
2864
virQEMUCapsInitQMPBasic(virQEMUCapsPtr qemuCaps)
2865
{
2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_COLON);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_REBOOT);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_UUID);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNET_HDR);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_0_10);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MEM_PATH);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_BALLOON);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOST_NET);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NODEFCONFIG);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_BOOT_MENU);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME_PROCESS);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_NONE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_AIO);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_READONLY);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_HOST);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_WAKEUP);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX);
O
Olivia Yin 已提交
2915
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DTB);
J
Ján Tomko 已提交
2916
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_IPV6_MIGRATION);
2917 2918
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_OPT);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_CORE);
2919
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_SHARE_POLICY);
2920 2921
}

2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953
/* Capabilities that are architecture depending
 * initialized for QEMU.
 */
static int
virQEMUCapsInitArchQMPBasic(virQEMUCapsPtr qemuCaps,
                            qemuMonitorPtr mon)
{
    char *archstr = NULL;
    int ret = -1;

    if (!(archstr = qemuMonitorGetTargetArch(mon)))
        return -1;

    if ((qemuCaps->arch = virQEMUCapsArchFromString(archstr)) == VIR_ARCH_NONE) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Unknown QEMU arch %s"), archstr);
        goto cleanup;
    }

    /*
     * Currently only x86_64 and i686 support PCI-multibus,
     * -no-acpi and -no-kvm-pit-reinjection.
     */
    if (qemuCaps->arch == VIR_ARCH_X86_64 ||
        qemuCaps->arch == VIR_ARCH_I686) {
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_KVM_PIT);
    }

    ret = 0;

2954
 cleanup:
2955 2956 2957
    VIR_FREE(archstr);
    return ret;
}
2958

2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
int
virQEMUCapsInitQMPMonitor(virQEMUCapsPtr qemuCaps,
                          qemuMonitorPtr mon)
{
    int ret = -1;
    int major, minor, micro;
    char *package = NULL;

    /* @mon is supposed to be locked by callee */

    if (qemuMonitorSetCapabilities(mon) < 0) {
        virErrorPtr err = virGetLastError();
        VIR_DEBUG("Failed to set monitor capabilities %s",
                  err ? err->message : "<unknown problem>");
        ret = 0;
        goto cleanup;
    }

    if (qemuMonitorGetVersion(mon,
                              &major, &minor, &micro,
                              &package) < 0) {
        virErrorPtr err = virGetLastError();
        VIR_DEBUG("Failed to query monitor version %s",
                  err ? err->message : "<unknown problem>");
        ret = 0;
        goto cleanup;
    }

    VIR_DEBUG("Got version %d.%d.%d (%s)",
              major, minor, micro, NULLSTR(package));

    if (major < 1 || (major == 1 && minor < 2)) {
        VIR_DEBUG("Not new enough for QMP capabilities detection");
        ret = 0;
        goto cleanup;
    }

    qemuCaps->version = major * 1000000 + minor * 1000 + micro;
    qemuCaps->usedQMP = true;

    virQEMUCapsInitQMPBasic(qemuCaps);

    if (virQEMUCapsInitArchQMPBasic(qemuCaps, mon) < 0)
        goto cleanup;

    /* USB option is supported v1.3.0 onwards */
    if (qemuCaps->version >= 1003000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_USB_OPT);

    /* WebSockets were introduced between 1.3.0 and 1.3.1 */
    if (qemuCaps->version >= 1003001)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_WEBSOCKET);

3012 3013 3014 3015 3016 3017
    /* -chardev spiceport is supported from 1.4.0, but usable through
     * qapi only since 1.5.0, however, it still cannot be queried
     * for as a capability */
    if (qemuCaps->version >= 1005000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEPORT);

3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038
    if (qemuCaps->version >= 1006000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);

    if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPObjects(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPMachineTypes(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPKVMState(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPTPM(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPCommandLine(qemuCaps, mon) < 0)
        goto cleanup;

    ret = 0;
3039
 cleanup:
3040 3041 3042 3043
    VIR_FREE(package);
    return ret;
}

3044
static int
3045 3046 3047 3048
virQEMUCapsInitQMP(virQEMUCapsPtr qemuCaps,
                   const char *libDir,
                   uid_t runUid,
                   gid_t runGid)
3049 3050 3051 3052 3053 3054 3055 3056
{
    int ret = -1;
    virCommandPtr cmd = NULL;
    qemuMonitorPtr mon = NULL;
    int status = 0;
    virDomainChrSourceDef config;
    char *monarg = NULL;
    char *monpath = NULL;
3057
    char *pidfile = NULL;
3058
    pid_t pid = 0;
3059 3060
    virDomainObjPtr vm = NULL;
    virDomainXMLOptionPtr xmlopt = NULL;
3061

3062 3063 3064
    /* the ".sock" sufix is important to avoid a possible clash with a qemu
     * domain called "capabilities"
     */
3065
    if (virAsprintf(&monpath, "%s/%s", libDir, "capabilities.monitor.sock") < 0)
3066
        goto cleanup;
3067
    if (virAsprintf(&monarg, "unix:%s,server,nowait", monpath) < 0)
3068 3069
        goto cleanup;

3070 3071
    /* ".pidfile" suffix is used rather than ".pid" to avoid a possible clash
     * with a qemu domain called "capabilities"
3072 3073 3074
     * Normally we'd use runDir for pid files, but because we're using
     * -daemonize we need QEMU to be allowed to create them, rather
     * than libvirtd. So we're using libDir which QEMU can write to
3075
     */
3076
    if (virAsprintf(&pidfile, "%s/%s", libDir, "capabilities.pidfile") < 0)
3077 3078
        goto cleanup;

3079 3080 3081 3082 3083
    memset(&config, 0, sizeof(config));
    config.type = VIR_DOMAIN_CHR_TYPE_UNIX;
    config.data.nix.path = monpath;
    config.data.nix.listen = false;

3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107
    /* Qemu 1.2 and later have a binary flag -enable-fips that must be
     * used for VNC auth to obey FIPS settings; but the flag only
     * exists on Linux, and with no way to probe for it via QMP.  Our
     * solution: if FIPS mode is required, then unconditionally use
     * the flag, regardless of qemu version, for the following matrix:
     *
     *                          old QEMU            new QEMU
     * FIPS enabled             doesn't start       VNC auth disabled
     * FIPS disabled/missing    VNC auth enabled    VNC auth enabled
     *
     * Setting the flag here instead of in virQEMUCapsInitQMPMonitor
     * or virQEMUCapsInitHelp also allows the testsuite to be
     * independent of FIPS setting.
     */
    if (virFileExists("/proc/sys/crypto/fips_enabled")) {
        char *buf = NULL;

        if (virFileReadAll("/proc/sys/crypto/fips_enabled", 10, &buf) < 0)
            goto cleanup;
        if (STREQ(buf, "1\n"))
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_FIPS);
        VIR_FREE(buf);
    }

3108
    VIR_DEBUG("Try to get caps via QMP qemuCaps=%p", qemuCaps);
3109

3110 3111 3112 3113 3114 3115 3116
    /*
     * We explicitly need to use -daemonize here, rather than
     * virCommandDaemonize, because we need to synchronize
     * with QEMU creating its monitor socket API. Using
     * daemonize guarantees control won't return to libvirt
     * until the socket is present.
     */
3117
    cmd = virCommandNewArgList(qemuCaps->binary,
3118 3119 3120 3121 3122 3123
                               "-S",
                               "-no-user-config",
                               "-nodefaults",
                               "-nographic",
                               "-M", "none",
                               "-qmp", monarg,
3124 3125
                               "-pidfile", pidfile,
                               "-daemonize",
3126 3127 3128
                               NULL);
    virCommandAddEnvPassCommon(cmd);
    virCommandClearCaps(cmd);
3129 3130
    virCommandSetGID(cmd, runGid);
    virCommandSetUID(cmd, runUid);
3131

3132
    /* Log, but otherwise ignore, non-zero status.  */
3133 3134 3135 3136 3137
    if (virCommandRun(cmd, &status) < 0)
        goto cleanup;

    if (status != 0) {
        ret = 0;
3138
        VIR_DEBUG("QEMU %s exited with status %d", qemuCaps->binary, status);
3139 3140 3141
        goto cleanup;
    }

3142 3143 3144 3145 3146 3147
    if (virPidFileReadPath(pidfile, &pid) < 0) {
        VIR_DEBUG("Failed to read pidfile %s", pidfile);
        ret = 0;
        goto cleanup;
    }

3148 3149 3150 3151 3152
    if (!(xmlopt = virDomainXMLOptionNew(NULL, NULL, NULL)) ||
        !(vm = virDomainObjNew(xmlopt)))
        goto cleanup;

    vm->pid = pid;
3153

3154
    if (!(mon = qemuMonitorOpen(vm, &config, true, &callbacks, NULL))) {
3155
        ret = 0;
3156
        goto cleanup;
3157
    }
3158

3159
    virObjectLock(mon);
3160

3161
    if (virQEMUCapsInitQMPMonitor(qemuCaps, mon) < 0)
3162
        goto cleanup;
3163 3164 3165

    ret = 0;

3166
 cleanup:
3167
    if (mon)
3168
        virObjectUnlock(mon);
3169 3170
    qemuMonitorClose(mon);
    virCommandAbort(cmd);
3171
    virCommandFree(cmd);
3172 3173
    VIR_FREE(monarg);
    VIR_FREE(monpath);
3174 3175
    virObjectUnref(vm);
    virObjectUnref(xmlopt);
3176

3177
    if (pid != 0) {
3178 3179
        char ebuf[1024];

3180 3181 3182 3183 3184 3185 3186
        VIR_DEBUG("Killing QMP caps process %lld", (long long) pid);
        if (virProcessKill(pid, SIGKILL) < 0 && errno != ESRCH)
            VIR_ERROR(_("Failed to kill process %lld: %s"),
                      (long long) pid,
                      virStrerror(errno, ebuf, sizeof(ebuf)));
    }
    if (pidfile) {
3187 3188 3189
        unlink(pidfile);
        VIR_FREE(pidfile);
    }
3190 3191 3192 3193
    return ret;
}


3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205
#define MESSAGE_ID_CAPS_PROBE_FAILURE "8ae2f3fb-2dbe-498e-8fbd-012d40afa361"

static void
virQEMUCapsLogProbeFailure(const char *binary)
{
    virLogMetadata meta[] = {
        { .key = "MESSAGE_ID", .s = MESSAGE_ID_CAPS_PROBE_FAILURE, .iv = 0 },
        { .key = "LIBVIRT_QEMU_BINARY", .s = binary, .iv = 0 },
        { .key = NULL },
    };
    virErrorPtr err = virGetLastError();

3206
    virLogMessage(&virLogSelf,
3207 3208 3209 3210 3211 3212 3213 3214 3215
                  VIR_LOG_WARN,
                  __FILE__, __LINE__, __func__,
                  meta,
                  _("Failed to probe capabilities for %s: %s"),
                  binary, err && err->message ? err->message :
                  _("unknown failure"));
}


3216 3217
virQEMUCapsPtr virQEMUCapsNewForBinary(const char *binary,
                                       const char *libDir,
3218
                                       const char *cacheDir,
3219 3220
                                       uid_t runUid,
                                       gid_t runGid)
3221
{
3222
    virQEMUCapsPtr qemuCaps = virQEMUCapsNew();
3223 3224 3225
    struct stat sb;
    int rv;

3226 3227
    if (VIR_STRDUP(qemuCaps->binary, binary) < 0)
        goto error;
3228 3229 3230 3231 3232 3233 3234 3235

    /* We would also want to check faccessat if we cared about ACLs,
     * but we don't.  */
    if (stat(binary, &sb) < 0) {
        virReportSystemError(errno, _("Cannot check QEMU binary %s"),
                             binary);
        goto error;
    }
3236
    qemuCaps->ctime = sb.st_ctime;
3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247

    /* Make sure the binary we are about to try exec'ing exists.
     * Technically we could catch the exec() failure, but that's
     * in a sub-process so it's hard to feed back a useful error.
     */
    if (!virFileIsExecutable(binary)) {
        virReportSystemError(errno, _("QEMU binary %s is not executable"),
                             binary);
        goto error;
    }

3248
    if ((rv = virQEMUCapsInitCached(qemuCaps, cacheDir)) < 0)
3249 3250
        goto error;

3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
    if (rv == 0) {
        if (virQEMUCapsInitQMP(qemuCaps, libDir, runUid, runGid) < 0) {
            virQEMUCapsLogProbeFailure(binary);
            goto error;
        }

        if (!qemuCaps->usedQMP &&
            virQEMUCapsInitHelp(qemuCaps, runUid, runGid) < 0) {
            virQEMUCapsLogProbeFailure(binary);
            goto error;
        }

        if (virQEMUCapsRememberCached(qemuCaps, cacheDir) < 0)
            goto error;
3265
    }
3266

3267
    return qemuCaps;
3268

3269
 error:
3270 3271
    virObjectUnref(qemuCaps);
    qemuCaps = NULL;
3272
    return NULL;
3273 3274 3275
}


3276
bool virQEMUCapsIsValid(virQEMUCapsPtr qemuCaps)
3277 3278 3279
{
    struct stat sb;

3280
    if (!qemuCaps->binary)
3281 3282
        return true;

3283
    if (stat(qemuCaps->binary, &sb) < 0)
3284 3285
        return false;

3286
    return sb.st_ctime == qemuCaps->ctime;
3287
}
3288 3289 3290


static void
3291
virQEMUCapsHashDataFree(void *payload, const void *key ATTRIBUTE_UNUSED)
3292 3293 3294 3295 3296
{
    virObjectUnref(payload);
}


3297 3298
virQEMUCapsCachePtr
virQEMUCapsCacheNew(const char *libDir,
3299
                    const char *cacheDir,
3300 3301
                    uid_t runUid,
                    gid_t runGid)
3302
{
3303
    virQEMUCapsCachePtr cache;
3304

3305
    if (VIR_ALLOC(cache) < 0)
3306 3307 3308 3309 3310 3311 3312 3313 3314
        return NULL;

    if (virMutexInit(&cache->lock) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Unable to initialize mutex"));
        VIR_FREE(cache);
        return NULL;
    }

3315
    if (!(cache->binaries = virHashCreate(10, virQEMUCapsHashDataFree)))
3316
        goto error;
3317
    if (VIR_STRDUP(cache->libDir, libDir) < 0)
3318
        goto error;
3319 3320
    if (VIR_STRDUP(cache->cacheDir, cacheDir) < 0)
        goto error;
3321

3322 3323 3324
    cache->runUid = runUid;
    cache->runGid = runGid;

3325 3326
    return cache;

3327
 error:
3328
    virQEMUCapsCacheFree(cache);
3329 3330 3331 3332
    return NULL;
}


3333 3334
virQEMUCapsPtr
virQEMUCapsCacheLookup(virQEMUCapsCachePtr cache, const char *binary)
3335
{
3336
    virQEMUCapsPtr ret = NULL;
3337 3338 3339
    virMutexLock(&cache->lock);
    ret = virHashLookup(cache->binaries, binary);
    if (ret &&
3340
        !virQEMUCapsIsValid(ret)) {
3341 3342 3343 3344 3345 3346 3347 3348
        VIR_DEBUG("Cached capabilities %p no longer valid for %s",
                  ret, binary);
        virHashRemoveEntry(cache->binaries, binary);
        ret = NULL;
    }
    if (!ret) {
        VIR_DEBUG("Creating capabilities for %s",
                  binary);
3349
        ret = virQEMUCapsNewForBinary(binary, cache->libDir,
3350
                                      cache->cacheDir,
3351
                                      cache->runUid, cache->runGid);
3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367
        if (ret) {
            VIR_DEBUG("Caching capabilities %p for %s",
                      ret, binary);
            if (virHashAddEntry(cache->binaries, binary, ret) < 0) {
                virObjectUnref(ret);
                ret = NULL;
            }
        }
    }
    VIR_DEBUG("Returning caps %p for %s", ret, binary);
    virObjectRef(ret);
    virMutexUnlock(&cache->lock);
    return ret;
}


3368 3369
virQEMUCapsPtr
virQEMUCapsCacheLookupCopy(virQEMUCapsCachePtr cache, const char *binary)
3370
{
3371 3372
    virQEMUCapsPtr qemuCaps = virQEMUCapsCacheLookup(cache, binary);
    virQEMUCapsPtr ret;
3373

3374
    if (!qemuCaps)
3375 3376
        return NULL;

3377 3378
    ret = virQEMUCapsNewCopy(qemuCaps);
    virObjectUnref(qemuCaps);
3379 3380 3381 3382 3383
    return ret;
}


void
3384
virQEMUCapsCacheFree(virQEMUCapsCachePtr cache)
3385 3386 3387 3388
{
    if (!cache)
        return;

3389
    VIR_FREE(cache->libDir);
3390
    VIR_FREE(cache->cacheDir);
3391 3392 3393 3394
    virHashFree(cache->binaries);
    virMutexDestroy(&cache->lock);
    VIR_FREE(cache);
}
3395 3396

bool
3397
virQEMUCapsUsedQMP(virQEMUCapsPtr qemuCaps)
3398
{
3399
    return qemuCaps->usedQMP;
3400
}
3401 3402 3403 3404

bool
virQEMUCapsSupportsChardev(virDomainDefPtr def,
                           virQEMUCapsPtr qemuCaps,
3405
                           virDomainChrDefPtr chr)
3406 3407 3408 3409 3410
{
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
        return false;

3411
    if ((def->os.arch != VIR_ARCH_ARMV7L) && (def->os.arch != VIR_ARCH_AARCH64))
3412
        return true;
3413

3414 3415 3416 3417 3418 3419
    /* This may not be true for all ARM machine types, but at least
     * the only supported non-virtio serial devices of vexpress and versatile
     * don't have the -chardev property wired up. */
    return (chr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO ||
            (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
             chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO));
3420
}