qemu_capabilities.c 173.0 KB
Newer Older
1 2 3
/*
 * qemu_capabilities.c: QEMU capabilities generation
 *
4
 * Copyright (C) 2006-2016 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
 */

#include <config.h>

#include "qemu_capabilities.h"
25
#include "viralloc.h"
26
#include "vircrypto.h"
27
#include "virlog.h"
28
#include "virerror.h"
E
Eric Blake 已提交
29
#include "virfile.h"
30
#include "virfilecache.h"
31 32
#include "virpidfile.h"
#include "virprocess.h"
33
#include "cpu/cpu.h"
34
#include "cpu/cpu_x86.h"
35
#include "domain_conf.h"
36
#include "vircommand.h"
37
#include "virbitmap.h"
38
#include "virnodesuspend.h"
39
#include "virnuma.h"
40
#include "virhostcpu.h"
41
#include "qemu_monitor.h"
42
#include "virstring.h"
43
#include "qemu_hostdev.h"
44
#include "qemu_domain.h"
45
#define LIBVIRT_QEMU_CAPSPRIV_H_ALLOW
46
#include "qemu_capspriv.h"
47
#include "qemu_qapi.h"
48
#include "qemu_process.h"
49
#include "qemu_firmware.h"
50

51
#include <fcntl.h>
52 53 54
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>
55
#include <stdarg.h>
56
#include <sys/utsname.h>
57 58 59

#define VIR_FROM_THIS VIR_FROM_QEMU

60 61
VIR_LOG_INIT("qemu.qemu_capabilities");

62 63 64 65
/* While not public, these strings must not change. They
 * are used in domain status files which are read on
 * daemon restarts
 */
66 67
VIR_ENUM_IMPL(virQEMUCaps,
              QEMU_CAPS_LAST, /* virQEMUCaps grouping marker */
68
              /* 0 */
69 70 71 72
              "vnc-colon",
              "no-reboot",
              "drive",
              "drive-boot",
73
              "name",
74

75
              /* 5 */
76 77 78 79
              "uuid",
              "domid",
              "vnet-hdr",
              "migrate-kvm-stdio",
80
              "migrate-qemu-tcp",
81

82
              /* 10 */
83 84 85 86
              "migrate-qemu-exec",
              "drive-cache-v2",
              "kvm",
              "drive-format",
87
              "vga",
88

89
              /* 15 */
90 91 92 93
              "0.10",
              "pci-device",
              "mem-path",
              "drive-serial",
94
              "xen-domid",
95

96
              /* 20 */
97 98 99 100
              "migrate-qemu-unix",
              "chardev",
              "enable-kvm",
              "monitor-json",
101
              "balloon",
102

103
              /* 25 */
104 105 106 107
              "device",
              "sdl",
              "smp-topology",
              "netdev",
108
              "rtc",
109

110
              /* 30 */
111
              "vhost-net",
112 113 114
              "rtc-td-hack",
              "no-hpet",
              "no-kvm-pit",
115
              "tdf",
116

117
              /* 35 */
118 119 120
              "pci-configfd",
              "nodefconfig",
              "boot-menu",
121
              "fsdev",
122
              "nesting",
123 124

              /* 40 */
125 126 127
              "name-process",
              "drive-readonly",
              "smbios-type",
128
              "vga-qxl",
129
              "spice",
130 131

              /* 45 */
132 133 134
              "vga-none",
              "migrate-qemu-fd",
              "boot-index",
135
              "hda-duplex",
136
              "drive-aio",
137 138

              /* 50 */
139 140 141
              "pci-multibus",
              "pci-bootindex",
              "ccid-emulated",
142
              "ccid-passthru",
143
              "chardev-spicevmc",
144 145

              /* 55 */
146 147 148
              "device-spicevmc",
              "virtio-tx-alg",
              "device-qxl-vga",
149
              "pci-multifunction",
150
              "virtio-blk-pci.ioeventfd",
151 152

              /* 60 */
M
Michal Privoznik 已提交
153
              "sga",
154 155
              "virtio-blk-pci.event_idx",
              "virtio-net-pci.event_idx",
156
              "cache-directsync",
157
              "piix3-usb-uhci",
158 159

              /* 65 */
160 161 162
              "piix4-usb-uhci",
              "usb-ehci",
              "ich9-usb-ehci1",
163
              "vt82c686b-usb-uhci",
164
              "pci-ohci",
165 166

              /* 70 */
167
              "usb-redir",
M
Marc-André Lureau 已提交
168
              "usb-hub",
169
              "no-shutdown",
170
              "cache-unsafe",
171
              "rombar",
172 173

              /* 75 */
J
Jim Fehlig 已提交
174
              "ich9-ahci",
175
              "no-acpi",
176
              "fsdev-readonly",
177
              "virtio-blk-pci.scsi",
178
              "blk-sg-io",
179 180

              /* 80 */
O
Osier Yang 已提交
181
              "drive-copy-on-read",
182
              "cpu-host",
183
              "fsdev-writeout",
184
              "drive-iotune",
185
              "system_wakeup",
186 187

              /* 85 */
188
              "scsi-disk.channel",
189
              "scsi-block",
190
              "transaction",
191
              "block-job-sync",
192
              "block-job-async",
193 194

              /* 90 */
195
              "scsi-cd",
196
              "ide-cd",
197
              "no-user-config",
198
              "hda-micro",
199
              "dump-guest-memory",
200 201

              /* 95 */
G
Gerd Hoffmann 已提交
202
              "nec-usb-xhci",
203
              "virtio-s390",
204
              "balloon-event",
205
              "bridge",
206
              "lsi",
207 208

              /* 100 */
209
              "virtio-scsi-pci",
V
Viktor Mihajlovski 已提交
210
              "blockio",
211
              "disable-s3",
212
              "disable-s4",
213
              "usb-redir.filter",
214 215

              /* 105 */
216 217
              "ide-drive.wwn",
              "scsi-disk.wwn",
218
              "seccomp-sandbox",
219
              "reboot-timeout",
220
              "dump-guest-core",
221 222

              /* 110 */
223
              "seamless-migration",
224
              "block-commit",
225
              "vnc",
226
              "drive-mirror",
227
              "usb-redir.bootindex",
228 229

              /* 115 */
230
              "usb-host.bootindex",
231
              "blockdev-snapshot-sync",
232
              "qxl",
233
              "VGA",
234
              "cirrus-vga",
235 236

              /* 120 */
237 238
              "vmware-svga",
              "device-video-primary",
239
              "s390-sclp",
240
              "usb-serial",
G
Guannan Ren 已提交
241
              "usb-net",
242 243

              /* 125 */
244
              "add-fd",
245
              "nbd-server",
246
              "virtio-rng",
247
              "rng-random",
248
              "rng-egd",
249 250

              /* 130 */
O
Olivia Yin 已提交
251 252
              "virtio-ccw",
              "dtb",
253
              "megasas",
254
              "ipv6-migration",
255
              "machine-opt",
256 257

              /* 135 */
L
Li Zhang 已提交
258
              "machine-usb-opt",
S
Stefan Berger 已提交
259 260
              "tpm-passthrough",
              "tpm-tis",
261
              "nvram",
H
Han Cheng 已提交
262
              "pci-bridge",
263 264

              /* 140 */
H
Han Cheng 已提交
265 266 267
              "vfio-pci",
              "vfio-pci.bootindex",
              "scsi-generic",
268
              "scsi-generic.bootindex",
269
              "mem-merge",
270 271

              /* 145 */
272
              "vnc-websocket",
O
Osier Yang 已提交
273
              "drive-discard",
274
              "mlock",
275
              "vnc-share-policy",
276
              "device-del-event",
277 278

              /* 150 */
279
              "dmi-to-pci-bridge",
280 281
              "i440fx-pci-hole64-size",
              "q35-pci-hole64-size",
282
              "usb-storage",
283
              "usb-storage.removable",
284 285

              /* 155 */
286
              "virtio-mmio",
287
              "ich9-intel-hda",
288
              "kvm-pit-lost-tick-policy",
289
              "boot-strict",
290
              "pvpanic",
291 292

              /* 160 */
293
              "enable-fips",
294 295
              "spice-file-xfer-disable",
              "spiceport",
296
              "usb-kbd",
297
              "host-pci-multidomain",
298 299

              /* 165 */
300
              "msg-timestamp",
301
              "active-commit",
302
              "change-backing-file",
303
              "memory-backend-ram",
304
              "numa",
305 306

              /* 170 */
307
              "memory-backend-file",
308
              "usb-audio",
309
              "rtc-reset-reinjection",
310
              "splash-timeout",
J
John Ferlan 已提交
311
              "iothread",
312 313

              /* 175 */
314
              "migrate-rdma",
315
              "ivshmem",
316
              "drive-iotune-max",
317
              "VGA.vgamem_mb",
318
              "vmware-svga.vgamem_mb",
319 320

              /* 180 */
321 322
              "qxl.vgamem_mb",
              "qxl-vga.vgamem_mb",
323
              "pc-dimm",
324
              "machine-vmport-opt",
325
              "aes-key-wrap",
326 327

              /* 185 */
328
              "dea-key-wrap",
M
Michal Privoznik 已提交
329
              "pci-serial",
330
              "aarch64-off",
331
              "vhost-user-multiqueue",
332
              "migration-event",
333 334

              /* 190 */
335
              "gpex-pcihost",
336
              "ioh3420",
337
              "x3130-upstream",
338
              "xio3130-downstream",
339
              "rtl8139",
340 341

              /* 195 */
342
              "e1000",
343
              "virtio-net",
344
              "gic-version",
345
              "incoming-defer",
M
Marc-André Lureau 已提交
346
              "virtio-gpu",
347 348

              /* 200 */
349
              "virtio-gpu.virgl",
350 351
              "virtio-keyboard",
              "virtio-mouse",
352
              "virtio-tablet",
353
              "virtio-input-host",
354 355

              /* 205 */
356
              "chardev-file-append",
357 358
              "ich9-disable-s3",
              "ich9-disable-s4",
359
              "vserport-change-event",
360
              "virtio-balloon-pci.deflate-on-oom",
361 362

              /* 210 */
363
              "mptsas1068",
364
              "spice-gl",
365
              "qxl.vram64_size_mb",
366
              "qxl-vga.vram64_size_mb",
367
              "chardev-logfile",
368 369

              /* 215 */
370
              "debug-threads",
371
              "secret",
372
              "pxb",
373
              "pxb-pcie",
374
              "device-tray-moved-event",
375 376

              /* 220 */
377
              "nec-usb-xhci-ports",
378
              "virtio-scsi-pci.iothread",
379
              "name-guest",
380
              "qxl.max_outputs",
381
              "qxl-vga.max_outputs",
382 383

              /* 225 */
384
              "spice-unix",
385
              "drive-detect-zeroes",
B
Boris Fiuczynski 已提交
386
              "tls-creds-x509",
387
              "display",
J
Ján Tomko 已提交
388
              "intel-iommu",
389 390

              /* 230 */
M
Michal Privoznik 已提交
391
              "smm",
392
              "virtio-pci-disable-legacy",
393
              "query-hotpluggable-cpus",
394
              "virtio-net.rx_queue_size",
395
              "machine-iommu",
396 397

              /* 235 */
398
              "virtio-vga",
399
              "drive-iotune-max-length",
400
              "ivshmem-plain",
401
              "ivshmem-doorbell",
402
              "query-qmp-schema",
403 404

              /* 240 */
405
              "gluster.debug_level",
406
              "vhost-scsi",
407
              "drive-iotune-group",
408
              "query-cpu-model-expansion",
409
              "virtio-net.host_mtu",
410 411

              /* 245 */
412
              "spice-rendernode",
413
              "nvdimm",
414
              "pcie-root-port",
415
              "query-cpu-definitions",
416
              "block-write-threshold",
417 418

              /* 250 */
419
              "query-named-block-nodes",
420
              "cpu-cache",
421
              "qemu-xhci",
422
              "kernel-irqchip",
423
              "kernel-irqchip.split",
424 425

              /* 255 */
426
              "intel-iommu.intremap",
427
              "intel-iommu.caching-mode",
428
              "intel-iommu.eim",
429
              "intel-iommu.device-iotlb",
430
              "virtio.iommu_platform",
431 432

              /* 260 */
433
              "virtio.ats",
434
              "loadparm",
435
              "spapr-pci-host-bridge",
436
              "spapr-pci-host-bridge.numa_node",
437
              "vnc-multi-servers",
438 439

              /* 265 */
440
              "virtio-net.tx_queue_size",
441
              "chardev-reconnect",
442
              "virtio-gpu.max_outputs",
J
John Ferlan 已提交
443
              "vxhs",
444
              "virtio-blk.num-queues",
445 446

              /* 270 */
447
              "machine.pseries.resize-hpt",
M
Marc-André Lureau 已提交
448
              "vmcoreinfo",
449
              "spapr-vty",
450
              "sclplmconsole",
451
              "numa.dist",
452 453

              /* 275 */
454
              "disk-share-rw",
455
              "iscsi.password-secret",
456
              "isa-serial",
457
              "pl011",
458
              "machine.pseries.max-cpu-compat",
459 460

              /* 280 */
461
              "dump-completed",
462
              "virtio-gpu-ccw",
463 464 465
              "virtio-keyboard-ccw",
              "virtio-mouse-ccw",
              "virtio-tablet-ccw",
466 467

              /* 285 */
468
              "qcow2-luks",
469
              "pcie-pci-bridge",
470
              "seccomp-blacklist",
471
              "query-cpus-fast",
472
              "disk-write-cache",
473 474

              /* 290 */
475
              "nbd-tls",
476
              "tpm-crb",
477
              "pr-manager-helper",
478
              "qom-list-properties",
479
              "memory-backend-file.discard-data",
480 481

              /* 295 */
482
              "virtual-css-bridge",
483 484
              "virtual-css-bridge.cssid-unrestricted",
              "vfio-ccw",
485
              "sdl-gl",
486
              "screendump_device",
487 488

              /* 300 */
489
              "hda-output",
490
              "blockdev-del",
491
              "vmgenid",
492
              "vhost-vsock",
493
              "chardev-fd-pass",
494 495

              /* 305 */
496
              "tpm-emulator",
497 498
              "mch",
              "mch.extended-tseg-mbytes",
499
              "sev-guest",
500
              "machine.pseries.cap-hpt-max-page-size",
501 502

              /* 310 */
503
              "machine.pseries.cap-htm",
504
              "usb-storage.werror",
505
              "egl-headless",
506
              "vfio-pci.display",
507
              "blockdev",
508 509

              /* 315 */
B
Boris Fiuczynski 已提交
510
              "vfio-ap",
Y
Yi Min Zhao 已提交
511
              "zpci",
512
              "memory-backend-memfd",
513
              "memory-backend-memfd.hugetlb",
514
              "iothread.poll-max-ns",
515 516

              /* 320 */
517
              "machine.pseries.cap-nested-hv",
518 519
              "egl-headless.rendernode",
              "memory-backend-file.align",
520
              "memory-backend-file.pmem",
521
              "nvdimm.unarmed",
522 523

              /* 325 */
524
              "scsi-disk.device_id",
525
              "virtio-pci-non-transitional",
526
              "overcommit",
527
              "query-current-machine",
528
              "machine.virt.iommu",
529 530 531 532

              /* 330 */
              "bitmap-merge",
              "nbd-bitmap",
533
              "x86-max-cpu",
534
              "cpu-unavailable-features",
535
              "canonical-cpu-features",
536 537 538

              /* 335 */
              "bochs-display",
539
              "migration-file-drop-cache",
540
              "dbus-vmstate",
541 542
              "vhost-user-gpu",
              "vhost-user-vga",
543 544 545

              /* 340 */
              "incremental-backup",
546
              "query-cpu-model-baseline",
547
              "query-cpu-model-comparison",
J
Jonathon Jongsma 已提交
548
              "ramfb",
549
              "machine.pseries.cap-ccf-assist",
550 551
    );

552

553 554 555 556
struct virQEMUCapsMachineType {
    char *name;
    char *alias;
    unsigned int maxCpus;
557
    bool hotplugCpus;
558
    bool qemuDefault;
559
};
560 561 562 563 564 565 566 567 568 569 570

typedef struct _virQEMUCapsHostCPUData virQEMUCapsHostCPUData;
typedef virQEMUCapsHostCPUData *virQEMUCapsHostCPUDataPtr;
struct _virQEMUCapsHostCPUData {
    /* Only the "info" part is stored in the capabilities cache, the rest is
     * re-computed from other fields and external data sources everytime we
     * probe QEMU or load the cache.
     */
    qemuMonitorCPUModelInfoPtr info;
    /* Host CPU definition reported in domain capabilities. */
    virCPUDefPtr reported;
571 572
    /* Migratable host CPU definition used for updating guest CPU. */
    virCPUDefPtr migratable;
573 574 575 576
    /* CPU definition with features detected by libvirt using virCPUGetHost
     * combined with features reported by QEMU. This is used for backward
     * compatible comparison between a guest CPU and a host CPU. */
    virCPUDefPtr full;
577 578
};

579 580 581 582 583 584
/*
 * 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.
585 586
 *
 * And don't forget to update virQEMUCapsNewCopy.
587
 */
588
struct _virQEMUCaps {
589
    virObject parent;
590

591
    bool usedQMP;
592
    bool kvmSupportsNesting;
593

594
    char *binary;
595
    time_t ctime;
596
    time_t libvirtCtime;
597

598
    virBitmapPtr flags;
599 600 601

    unsigned int version;
    unsigned int kvmVersion;
602
    unsigned int libvirtVersion;
603
    unsigned int microcodeVersion;
604
    char *package;
605
    char *kernelVersion;
606

607
    virArch arch;
608

609
    virHashTablePtr domCapsCache;
610 611
    virDomainCapsCPUModelsPtr kvmCPUModels;
    virDomainCapsCPUModelsPtr tcgCPUModels;
612 613

    size_t nmachineTypes;
614
    struct virQEMUCapsMachineType *machineTypes;
A
Andrea Bolognani 已提交
615 616 617

    size_t ngicCapabilities;
    virGICCapability *gicCapabilities;
618

619 620
    virSEVCapability *sevCapabilities;

621 622
    virQEMUCapsHostCPUData kvmCPU;
    virQEMUCapsHostCPUData tcgCPU;
623 624
};

625 626
struct virQEMUCapsSearchData {
    virArch arch;
627
    const char *binaryFilter;
628 629
};

630

631 632
static virClassPtr virQEMUCapsClass;
static void virQEMUCapsDispose(void *obj);
633

634
static int virQEMUCapsOnceInit(void)
635
{
636
    if (!VIR_CLASS_NEW(virQEMUCaps, virClassForObject()))
637 638 639 640 641
        return -1;

    return 0;
}

642
VIR_ONCE_GLOBAL_INIT(virQEMUCaps);
643

644
virArch virQEMUCapsArchFromString(const char *arch)
645 646 647 648 649
{
    if (STREQ(arch, "i386"))
        return VIR_ARCH_I686;
    if (STREQ(arch, "arm"))
        return VIR_ARCH_ARMV7L;
650 651
    if (STREQ(arch, "or32"))
        return VIR_ARCH_OR32;
652 653 654 655 656

    return virArchFromString(arch);
}


657
const char *virQEMUCapsArchToString(virArch arch)
658 659 660
{
    if (arch == VIR_ARCH_I686)
        return "i386";
S
Stefan Schallenberg 已提交
661
    else if (arch == VIR_ARCH_ARMV6L || arch == VIR_ARCH_ARMV7L)
662
        return "arm";
663 664
    else if (arch == VIR_ARCH_OR32)
        return "or32";
665 666 667 668

    return virArchToString(arch);
}

669 670 671

/* Checks whether a domain with @guest arch can run natively on @host.
 */
672
bool
673 674 675
virQEMUCapsGuestIsNative(virArch host,
                         virArch guest)
{
676
    /* host & guest arches match */
677 678 679
    if (host == guest)
        return true;

680
    /* hostarch is x86_64 and guest arch is i686 (needs -cpu qemu32) */
681 682 683
    if (host == VIR_ARCH_X86_64 && guest == VIR_ARCH_I686)
        return true;

684
    /* hostarch is aarch64 and guest arch is armv7l (needs -cpu aarch64=off) */
685 686 687
    if (host == VIR_ARCH_AARCH64 && guest == VIR_ARCH_ARMV7L)
        return true;

688
    /* hostarch and guestarch are both ppc64 */
689 690 691 692 693 694 695
    if (ARCH_IS_PPC64(host) && ARCH_IS_PPC64(guest))
        return true;

    return false;
}


696 697 698 699 700 701 702 703 704
/* Given a host and guest architectures, find a suitable QEMU target.
 *
 * This is meant to be used as a second attempt if qemu-system-$guestarch
 * can't be found, eg. on a x86_64 host you want to use qemu-system-i386,
 * if available, instead of qemu-system-x86_64 to run i686 guests */
static virArch
virQEMUCapsFindTarget(virArch hostarch,
                      virArch guestarch)
{
705 706 707
    if (virQEMUCapsGuestIsNative(hostarch, guestarch))
        guestarch = hostarch;

708 709 710 711 712 713
    /* Both ppc64 and ppc64le guests can use the ppc64 target */
    if (ARCH_IS_PPC64(guestarch))
        guestarch = VIR_ARCH_PPC64;

    return guestarch;
}
714

715

716
static void
717 718
virQEMUCapsSetDefaultMachine(virQEMUCapsPtr qemuCaps,
                             size_t defIdx)
719
{
720
    struct virQEMUCapsMachineType tmp = qemuCaps->machineTypes[defIdx];
721 722 723 724

    memmove(qemuCaps->machineTypes + 1,
            qemuCaps->machineTypes,
            sizeof(qemuCaps->machineTypes[0]) * defIdx);
725 726

    qemuCaps->machineTypes[0] = tmp;
727 728
}

729

730
static char *
731 732
virQEMUCapsFindBinary(const char *format,
                      const char *archstr)
733
{
734 735
    char *ret = NULL;
    char *binary = NULL;
736

737
    if (virAsprintf(&binary, format, archstr) < 0)
738
        return NULL;
739 740 741

    ret = virFindFileInPath(binary);
    VIR_FREE(binary);
742 743 744 745 746 747 748 749 750 751 752
    return ret;
}

static char *
virQEMUCapsFindBinaryForArch(virArch hostarch,
                             virArch guestarch)
{
    char *ret = NULL;
    const char *archstr;
    virArch target;

753 754 755 756 757 758 759 760 761
    /* armv7l guests can only take advantage of KVM on aarch64 hosts by
     * using the qemu-system-aarch64 binary, so look for that one first
     * to avoid using qemu-system-arm (and thus TCG) instead */
    if (hostarch == VIR_ARCH_AARCH64 && guestarch == VIR_ARCH_ARMV7L) {
        archstr = virQEMUCapsArchToString(hostarch);
        if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
            goto out;
    }

762 763 764 765 766 767 768 769 770 771 772
    /* First attempt: try the guest architecture as it is */
    archstr = virQEMUCapsArchToString(guestarch);
    if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
        goto out;

    /* Second attempt: try looking up by target instead */
    target = virQEMUCapsFindTarget(hostarch, guestarch);
    if (target != guestarch) {
        archstr = virQEMUCapsArchToString(target);
        if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
            goto out;
773
    }
774

775
 out:
776 777 778
    return ret;
}

779
static int
780
virQEMUCapsInitGuest(virCapsPtr caps,
781
                     virFileCachePtr cache,
782 783
                     virArch hostarch,
                     virArch guestarch)
784 785
{
    char *binary = NULL;
786
    virQEMUCapsPtr qemuCaps = NULL;
787 788
    int ret = -1;

J
Ján Tomko 已提交
789
    /* Check for existence of base emulator, or alternate base
790 791
     * which can be used with magic cpu choice
     */
792
    binary = virQEMUCapsFindBinaryForArch(hostarch, guestarch);
793

794 795 796 797 798 799 800
    /* RHEL doesn't follow the usual naming for QEMU binaries and ships
     * a single binary named qemu-kvm outside of $PATH instead */
    if (virQEMUCapsGuestIsNative(hostarch, guestarch) && !binary) {
        if (VIR_STRDUP(binary, "/usr/libexec/qemu-kvm") < 0)
            return -1;
    }

801
    /* Ignore binary if extracting version info fails */
802
    if (binary) {
803
        if (!(qemuCaps = virQEMUCapsCacheLookup(cache, binary))) {
804 805 806 807
            virResetLastError();
            VIR_FREE(binary);
        }
    }
808

809
    ret = virQEMUCapsInitGuestFromBinary(caps,
810
                                         binary, qemuCaps,
811 812 813
                                         guestarch);

    VIR_FREE(binary);
814
    virObjectUnref(qemuCaps);
815 816 817 818 819 820 821

    return ret;
}

int
virQEMUCapsInitGuestFromBinary(virCapsPtr caps,
                               const char *binary,
822
                               virQEMUCapsPtr qemuCaps,
823 824 825 826 827 828 829
                               virArch guestarch)
{
    virCapsGuestPtr guest;
    virCapsGuestMachinePtr *machines = NULL;
    size_t nmachines = 0;
    int ret = -1;

830 831 832
    if (!binary)
        return 0;

833
    if (virQEMUCapsGetMachineTypesCaps(qemuCaps, &nmachines, &machines) < 0)
834
        goto cleanup;
835 836 837 838

    /* We register kvm as the base emulator too, since we can
     * just give -no-kvm to disable acceleration if required */
    if ((guest = virCapabilitiesAddGuest(caps,
839
                                         VIR_DOMAIN_OSTYPE_HVM,
840
                                         guestarch,
841 842 843 844
                                         binary,
                                         NULL,
                                         nmachines,
                                         machines)) == NULL)
845
        goto cleanup;
846 847 848 849

    machines = NULL;
    nmachines = 0;

A
Andrea Bolognani 已提交
850 851 852
    /* CPU selection is always available, because all QEMU versions
     * we support can use at least '-cpu host' */
    if (!virCapabilitiesAddGuestFeature(guest, "cpuselection", true, false))
853
        goto cleanup;
854

855
    if (!virCapabilitiesAddGuestFeature(guest, "deviceboot", true, false))
856
        goto cleanup;
857

858
    if (!virCapabilitiesAddGuestFeature(guest, "disksnapshot", true, false))
859
        goto cleanup;
860

D
Daniel P. Berrange 已提交
861
    if (virCapabilitiesAddGuestDomain(guest,
862
                                      VIR_DOMAIN_VIRT_QEMU,
D
Daniel P. Berrange 已提交
863 864 865 866
                                      NULL,
                                      NULL,
                                      0,
                                      NULL) == NULL)
867
        goto cleanup;
868

869
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
870 871 872 873 874 875
        if (virCapabilitiesAddGuestDomain(guest,
                                          VIR_DOMAIN_VIRT_KVM,
                                          NULL,
                                          NULL,
                                          0,
                                          NULL) == NULL) {
876
            goto cleanup;
D
Daniel P. Berrange 已提交
877
        }
878
    }
879

880 881 882
    if ((ARCH_IS_X86(guestarch) || guestarch == VIR_ARCH_AARCH64) &&
        virCapabilitiesAddGuestFeature(guest, "acpi", true, true) == NULL) {
        goto cleanup;
883 884
    }

A
Andrea Bolognani 已提交
885
    if (ARCH_IS_X86(guestarch) &&
886
        virCapabilitiesAddGuestFeature(guest, "apic", true, false) == NULL) {
887
        goto cleanup;
888
    }
889

890
    if ((guestarch == VIR_ARCH_I686) &&
891 892
        (virCapabilitiesAddGuestFeature(guest, "pae", true, false) == NULL ||
         virCapabilitiesAddGuestFeature(guest, "nonpae", true, false) == NULL))
893
        goto cleanup;
894 895 896

    ret = 0;

897
 cleanup:
898 899 900

    virCapabilitiesFreeMachines(machines, nmachines);

901
    return ret;
902 903 904
}


905
virCPUDefPtr
906 907
virQEMUCapsProbeHostCPU(virArch hostArch,
                        virDomainCapsCPUModelsPtr models)
908
{
909
    return virCPUGetHost(hostArch, VIR_CPU_TYPE_GUEST, NULL, models);
910 911 912
}


913 914
virCapsPtr
virQEMUCapsInit(virFileCachePtr cache)
915 916
{
    virCapsPtr caps;
917
    size_t i;
T
Tal Kain 已提交
918
    virArch hostarch = virArchFromHost();
919

T
Tal Kain 已提交
920
    if ((caps = virCapabilitiesNew(hostarch,
921
                                   true, true)) == NULL)
922
        goto error;
923

924
    /* Some machines have problematic NUMA topology causing
925 926 927
     * unexpected failures. We don't want to break the QEMU
     * driver in this scenario, so log errors & carry on
     */
M
Martin Kletzander 已提交
928
    if (virCapabilitiesInitNUMA(caps) < 0) {
929
        virCapabilitiesFreeNUMAInfo(caps);
930
        VIR_WARN("Failed to query host NUMA topology, disabling NUMA capabilities");
931 932
    }

933 934 935
    if (virCapabilitiesInitCaches(caps) < 0)
        VIR_WARN("Failed to get host CPU cache info");

M
Martin Kletzander 已提交
936
    if (!(caps->host.cpu = virCPUProbeHost(caps->host.arch)))
937
        VIR_WARN("Failed to get host CPU");
938

939
    /* Add the power management features of the host */
940
    if (virNodeSuspendGetTargetMask(&caps->host.powerMgmt) < 0)
941 942
        VIR_WARN("Failed to get host power management capabilities");

943 944 945
    /* Add IOMMU info */
    virCapabilitiesHostInitIOMMU(caps);

M
Michal Privoznik 已提交
946
    /* Add huge pages info */
947
    if (virCapabilitiesInitPages(caps) < 0)
M
Michal Privoznik 已提交
948 949
        VIR_WARN("Failed to get pages info");

950 951 952
    /* Add domain migration transport URIs */
    virCapabilitiesAddHostMigrateTransport(caps, "tcp");
    virCapabilitiesAddHostMigrateTransport(caps, "rdma");
953

954 955 956 957
    /* 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
     */
958
    for (i = 0; i < VIR_ARCH_LAST; i++)
959
        if (virQEMUCapsInitGuest(caps, cache,
T
Tal Kain 已提交
960
                                 hostarch,
961
                                 i) < 0)
962
            goto error;
963 964 965

    return caps;

966
 error:
967
    virObjectUnref(caps);
968 969 970 971
    return NULL;
}


972
struct virQEMUCapsStringFlags {
973 974 975 976 977
    const char *value;
    int flag;
};


978 979 980 981 982
struct virQEMUCapsStringFlags virQEMUCapsCommands[] = {
    { "dump-guest-memory", QEMU_CAPS_DUMP_GUEST_MEMORY },
    { "query-spice", QEMU_CAPS_SPICE },
    { "query-vnc", QEMU_CAPS_VNC },
    { "nbd-server-start", QEMU_CAPS_NBD_SERVER },
983
    { "change-backing-file", QEMU_CAPS_CHANGE_BACKING_FILE },
984
    { "rtc-reset-reinjection", QEMU_CAPS_RTC_RESET_REINJECTION },
985
    { "migrate-incoming", QEMU_CAPS_INCOMING_DEFER },
986
    { "query-hotpluggable-cpus", QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS },
987
    { "query-qmp-schema", QEMU_CAPS_QUERY_QMP_SCHEMA },
988 989 990
    { "query-cpu-model-expansion", QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION },
    { "query-cpu-definitions", QEMU_CAPS_QUERY_CPU_DEFINITIONS },
    { "query-named-block-nodes", QEMU_CAPS_QUERY_NAMED_BLOCK_NODES },
991
    { "query-cpus-fast", QEMU_CAPS_QUERY_CPUS_FAST },
992
    { "qom-list-properties", QEMU_CAPS_QOM_LIST_PROPERTIES },
993
    { "blockdev-del", QEMU_CAPS_BLOCKDEV_DEL },
994
    { "query-current-machine", QEMU_CAPS_QUERY_CURRENT_MACHINE },
995
    { "block-dirty-bitmap-merge", QEMU_CAPS_BITMAP_MERGE },
996
    { "query-cpu-model-baseline", QEMU_CAPS_QUERY_CPU_MODEL_BASELINE },
997
    { "query-cpu-model-comparison", QEMU_CAPS_QUERY_CPU_MODEL_COMPARISON },
998 999
};

1000 1001 1002 1003
struct virQEMUCapsStringFlags virQEMUCapsMigration[] = {
    { "rdma-pin-all", QEMU_CAPS_MIGRATE_RDMA },
};

1004
/* Use virQEMUCapsQMPSchemaQueries for querying parameters of events */
1005
struct virQEMUCapsStringFlags virQEMUCapsEvents[] = {
1006
    { "MIGRATION", QEMU_CAPS_MIGRATION_EVENT },
1007
    { "VSERPORT_CHANGE", QEMU_CAPS_VSERPORT_CHANGE },
1008
    { "BLOCK_WRITE_THRESHOLD", QEMU_CAPS_BLOCK_WRITE_THRESHOLD },
1009
    { "DUMP_COMPLETED", QEMU_CAPS_DUMP_COMPLETED },
1010 1011
};

1012
struct virQEMUCapsStringFlags virQEMUCapsObjectTypes[] = {
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
    { "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 },
1028
    { "virtio-blk-ccw", QEMU_CAPS_VIRTIO_CCW },
1029
    { "sclpconsole", QEMU_CAPS_DEVICE_SCLPCONSOLE },
1030
    { "lsi53c895a", QEMU_CAPS_SCSI_LSI },
1031
    { "virtio-scsi-pci", QEMU_CAPS_VIRTIO_SCSI },
1032 1033
    { "virtio-scsi-s390", QEMU_CAPS_VIRTIO_SCSI },
    { "virtio-scsi-ccw", QEMU_CAPS_VIRTIO_SCSI },
1034
    { "virtio-scsi-device", QEMU_CAPS_VIRTIO_SCSI },
1035
    { "megasas", QEMU_CAPS_SCSI_MEGASAS },
1036
    { "qxl", QEMU_CAPS_DEVICE_QXL },
1037 1038
    { "sga", QEMU_CAPS_SGA },
    { "scsi-block", QEMU_CAPS_SCSI_BLOCK },
1039 1040 1041
    { "VGA", QEMU_CAPS_DEVICE_VGA },
    { "cirrus-vga", QEMU_CAPS_DEVICE_CIRRUS_VGA },
    { "vmware-svga", QEMU_CAPS_DEVICE_VMWARE_SVGA },
H
Han Cheng 已提交
1042
    { "usb-serial", QEMU_CAPS_DEVICE_USB_SERIAL },
1043
    { "virtio-rng-pci", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1044 1045
    { "virtio-rng-s390", QEMU_CAPS_DEVICE_VIRTIO_RNG },
    { "virtio-rng-ccw", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1046
    { "virtio-rng-device", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1047
    { "rng-random", QEMU_CAPS_OBJECT_RNG_RANDOM },
1048
    { "rng-egd", QEMU_CAPS_OBJECT_RNG_EGD },
1049
    { "spapr-nvram", QEMU_CAPS_DEVICE_NVRAM },
1050
    { "pci-bridge", QEMU_CAPS_DEVICE_PCI_BRIDGE },
1051
    { "vfio-pci", QEMU_CAPS_DEVICE_VFIO_PCI },
1052
    { "i82801b11-bridge", QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE },
1053
    { "usb-storage", QEMU_CAPS_DEVICE_USB_STORAGE },
1054
    { "virtio-mmio", QEMU_CAPS_DEVICE_VIRTIO_MMIO },
1055
    { "ich9-intel-hda", QEMU_CAPS_DEVICE_ICH9_INTEL_HDA },
H
Hu Tao 已提交
1056
    { "pvpanic", QEMU_CAPS_DEVICE_PANIC },
L
Li Zhang 已提交
1057
    { "usb-kbd", QEMU_CAPS_DEVICE_USB_KBD },
1058
    { "memory-backend-ram", QEMU_CAPS_OBJECT_MEMORY_RAM },
1059
    { "memory-backend-file", QEMU_CAPS_OBJECT_MEMORY_FILE },
1060
    { "usb-audio", QEMU_CAPS_OBJECT_USB_AUDIO },
J
John Ferlan 已提交
1061
    { "iothread", QEMU_CAPS_OBJECT_IOTHREAD},
1062
    { "ivshmem", QEMU_CAPS_DEVICE_IVSHMEM },
1063
    { "pc-dimm", QEMU_CAPS_DEVICE_PC_DIMM },
M
Michal Privoznik 已提交
1064
    { "pci-serial", QEMU_CAPS_DEVICE_PCI_SERIAL },
1065
    { "gpex-pcihost", QEMU_CAPS_OBJECT_GPEX},
1066
    { "ioh3420", QEMU_CAPS_DEVICE_IOH3420 },
1067
    { "x3130-upstream", QEMU_CAPS_DEVICE_X3130_UPSTREAM },
1068
    { "xio3130-downstream", QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM },
1069
    { "rtl8139", QEMU_CAPS_DEVICE_RTL8139 },
1070
    { "e1000", QEMU_CAPS_DEVICE_E1000 },
1071 1072 1073 1074
    { "virtio-net-pci", QEMU_CAPS_DEVICE_VIRTIO_NET },
    { "virtio-net-ccw", QEMU_CAPS_DEVICE_VIRTIO_NET },
    { "virtio-net-s390", QEMU_CAPS_DEVICE_VIRTIO_NET },
    { "virtio-net-device", QEMU_CAPS_DEVICE_VIRTIO_NET },
M
Marc-André Lureau 已提交
1075 1076
    { "virtio-gpu-pci", QEMU_CAPS_DEVICE_VIRTIO_GPU },
    { "virtio-gpu-device", QEMU_CAPS_DEVICE_VIRTIO_GPU },
1077
    { "virtio-vga", QEMU_CAPS_DEVICE_VIRTIO_VGA },
1078 1079 1080 1081 1082 1083
    { "virtio-keyboard-device", QEMU_CAPS_VIRTIO_KEYBOARD },
    { "virtio-keyboard-pci", QEMU_CAPS_VIRTIO_KEYBOARD },
    { "virtio-mouse-device", QEMU_CAPS_VIRTIO_MOUSE },
    { "virtio-mouse-pci", QEMU_CAPS_VIRTIO_MOUSE },
    { "virtio-tablet-device", QEMU_CAPS_VIRTIO_TABLET },
    { "virtio-tablet-pci", QEMU_CAPS_VIRTIO_TABLET },
1084 1085
    { "virtio-input-host-device", QEMU_CAPS_VIRTIO_INPUT_HOST },
    { "virtio-input-host-pci", QEMU_CAPS_VIRTIO_INPUT_HOST },
1086
    { "mptsas1068", QEMU_CAPS_SCSI_MPTSAS1068 },
1087
    { "secret", QEMU_CAPS_OBJECT_SECRET },
1088
    { "pxb", QEMU_CAPS_DEVICE_PXB },
1089
    { "pxb-pcie", QEMU_CAPS_DEVICE_PXB_PCIE },
1090
    { "tls-creds-x509", QEMU_CAPS_OBJECT_TLS_CREDS_X509 },
J
Ján Tomko 已提交
1091
    { "intel-iommu", QEMU_CAPS_DEVICE_INTEL_IOMMU },
1092 1093
    { "ivshmem-plain", QEMU_CAPS_DEVICE_IVSHMEM_PLAIN },
    { "ivshmem-doorbell", QEMU_CAPS_DEVICE_IVSHMEM_DOORBELL },
1094
    { "vhost-scsi", QEMU_CAPS_DEVICE_VHOST_SCSI },
1095
    { "nvdimm", QEMU_CAPS_DEVICE_NVDIMM },
1096
    { "pcie-root-port", QEMU_CAPS_DEVICE_PCIE_ROOT_PORT },
1097
    { "qemu-xhci", QEMU_CAPS_DEVICE_QEMU_XHCI },
1098
    { "spapr-pci-host-bridge", QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE },
M
Marc-André Lureau 已提交
1099
    { "vmcoreinfo", QEMU_CAPS_DEVICE_VMCOREINFO },
1100
    { "spapr-vty", QEMU_CAPS_DEVICE_SPAPR_VTY },
1101
    { "sclplmconsole", QEMU_CAPS_DEVICE_SCLPLMCONSOLE },
1102
    { "isa-serial", QEMU_CAPS_DEVICE_ISA_SERIAL },
1103
    { "pl011", QEMU_CAPS_DEVICE_PL011 },
1104
    { "virtio-gpu-ccw", QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW },
1105 1106 1107
    { "virtio-keyboard-ccw", QEMU_CAPS_DEVICE_VIRTIO_KEYBOARD_CCW },
    { "virtio-mouse-ccw", QEMU_CAPS_DEVICE_VIRTIO_MOUSE_CCW },
    { "virtio-tablet-ccw", QEMU_CAPS_DEVICE_VIRTIO_TABLET_CCW },
1108
    { "pcie-pci-bridge", QEMU_CAPS_DEVICE_PCIE_PCI_BRIDGE },
1109
    { "pr-manager-helper", QEMU_CAPS_PR_MANAGER_HELPER },
1110
    { "virtual-css-bridge", QEMU_CAPS_CCW },
1111
    { "vfio-ccw", QEMU_CAPS_DEVICE_VFIO_CCW },
1112
    { "hda-output", QEMU_CAPS_HDA_OUTPUT },
1113
    { "vmgenid", QEMU_CAPS_DEVICE_VMGENID },
1114
    { "vhost-vsock-device", QEMU_CAPS_DEVICE_VHOST_VSOCK },
1115
    { "mch", QEMU_CAPS_DEVICE_MCH },
1116
    { "sev-guest", QEMU_CAPS_SEV_GUEST },
B
Boris Fiuczynski 已提交
1117
    { "vfio-ap", QEMU_CAPS_DEVICE_VFIO_AP },
Y
Yi Min Zhao 已提交
1118
    { "zpci", QEMU_CAPS_DEVICE_ZPCI },
1119
    { "memory-backend-memfd", QEMU_CAPS_OBJECT_MEMORY_MEMFD },
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
    { "virtio-blk-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-blk-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-net-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-net-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "vhost-scsi-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "vhost-scsi-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-rng-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-rng-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-9p-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-9p-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-balloon-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-balloon-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "vhost-vsock-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "vhost-vsock-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-input-host-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-input-host-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-scsi-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-scsi-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-serial-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
    { "virtio-serial-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1140
    { "max-x86_64-cpu", QEMU_CAPS_X86_MAX_CPU },
1141
    { "bochs-display", QEMU_CAPS_DEVICE_BOCHS_DISPLAY },
1142
    { "dbus-vmstate", QEMU_CAPS_DBUS_VMSTATE },
1143 1144
    { "vhost-user-gpu", QEMU_CAPS_DEVICE_VHOST_USER_GPU },
    { "vhost-user-vga", QEMU_CAPS_DEVICE_VHOST_USER_VGA },
J
Jonathon Jongsma 已提交
1145
    { "ramfb", QEMU_CAPS_DEVICE_RAMFB },
1146 1147
};

1148
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsVirtioBalloon[] = {
1149
    { "deflate-on-oom", QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE },
1150 1151 1152
    { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY },
    { "iommu_platform", QEMU_CAPS_VIRTIO_PCI_IOMMU_PLATFORM },
    { "ats", QEMU_CAPS_VIRTIO_PCI_ATS },
1153 1154
};

1155
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsVirtioBlk[] = {
1156 1157 1158 1159
    { "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 },
1160
    { "num-queues", QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES },
1161
    { "share-rw", QEMU_CAPS_DISK_SHARE_RW },
1162 1163 1164
    { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY },
    { "iommu_platform", QEMU_CAPS_VIRTIO_PCI_IOMMU_PLATFORM },
    { "ats", QEMU_CAPS_VIRTIO_PCI_ATS },
1165
    { "write-cache", QEMU_CAPS_DISK_WRITE_CACHE },
1166 1167
};

1168
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsVirtioNet[] = {
1169 1170
    { "tx", QEMU_CAPS_VIRTIO_TX_ALG },
    { "event_idx", QEMU_CAPS_VIRTIO_NET_EVENT_IDX },
1171
    { "rx_queue_size", QEMU_CAPS_VIRTIO_NET_RX_QUEUE_SIZE },
1172
    { "tx_queue_size", QEMU_CAPS_VIRTIO_NET_TX_QUEUE_SIZE },
1173
    { "host_mtu", QEMU_CAPS_VIRTIO_NET_HOST_MTU },
1174 1175 1176
    { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY },
    { "iommu_platform", QEMU_CAPS_VIRTIO_PCI_IOMMU_PLATFORM },
    { "ats", QEMU_CAPS_VIRTIO_PCI_ATS },
1177 1178
};

1179
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsSpaprPCIHostBridge[] = {
1180 1181 1182
    { "numa_node", QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE },
};

1183
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsVirtioSCSI[] = {
1184
    { "iothread", QEMU_CAPS_VIRTIO_SCSI_IOTHREAD },
1185 1186 1187
    { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY },
    { "iommu_platform", QEMU_CAPS_VIRTIO_PCI_IOMMU_PLATFORM },
    { "ats", QEMU_CAPS_VIRTIO_PCI_ATS },
1188 1189
};

1190
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsVfioPCI[] = {
1191
    { "display", QEMU_CAPS_VFIO_PCI_DISPLAY },
1192 1193
};

1194
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsSCSIDisk[] = {
1195 1196
    { "channel", QEMU_CAPS_SCSI_DISK_CHANNEL },
    { "wwn", QEMU_CAPS_SCSI_DISK_WWN },
1197
    { "share-rw", QEMU_CAPS_DISK_SHARE_RW },
1198
    { "write-cache", QEMU_CAPS_DISK_WRITE_CACHE },
1199
    { "device_id", QEMU_CAPS_SCSI_DISK_DEVICE_ID },
1200 1201
};

1202
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsIDEDrive[] = {
1203
    { "wwn", QEMU_CAPS_IDE_DRIVE_WWN },
1204
    { "share-rw", QEMU_CAPS_DISK_SHARE_RW },
1205
    { "write-cache", QEMU_CAPS_DISK_WRITE_CACHE },
1206 1207
};

1208
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsPiix4PM[] = {
1209 1210
    { "disable_s3", QEMU_CAPS_PIIX_DISABLE_S3 },
    { "disable_s4", QEMU_CAPS_PIIX_DISABLE_S4 },
1211 1212
};

1213
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsUSBRedir[] = {
1214
    { "filter", QEMU_CAPS_USB_REDIR_FILTER },
1215 1216
};

1217
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsI440FXPCIHost[] = {
1218 1219 1220
    { "pci-hole64-size", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE },
};

1221
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsQ35PCIHost[] = {
1222 1223 1224
    { "pci-hole64-size", QEMU_CAPS_Q35_PCI_HOLE64_SIZE },
};

1225
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsUSBStorage[] = {
1226
    { "removable", QEMU_CAPS_USB_STORAGE_REMOVABLE },
1227
    { "share-rw", QEMU_CAPS_DISK_SHARE_RW },
1228
    { "write-cache", QEMU_CAPS_DISK_WRITE_CACHE },
1229
    { "werror", QEMU_CAPS_USB_STORAGE_WERROR },
1230 1231
};

1232
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsKVMPit[] = {
1233 1234 1235
    { "lost_tick_policy", QEMU_CAPS_KVM_PIT_TICK_POLICY },
};

1236
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsVGA[] = {
1237 1238 1239
    { "vgamem_mb", QEMU_CAPS_VGA_VGAMEM },
};

1240
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsVmwareSvga[] = {
1241 1242 1243
    { "vgamem_mb", QEMU_CAPS_VMWARE_SVGA_VGAMEM },
};

1244
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsQxl[] = {
1245
    { "vgamem_mb", QEMU_CAPS_QXL_VGAMEM },
1246
    { "vram64_size_mb", QEMU_CAPS_QXL_VRAM64 },
1247
    { "max_outputs", QEMU_CAPS_QXL_MAX_OUTPUTS },
1248 1249
};

1250
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsVirtioGpu[] = {
1251
    { "virgl", QEMU_CAPS_VIRTIO_GPU_VIRGL },
1252
    { "max_outputs", QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS },
1253 1254 1255
    { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY },
    { "iommu_platform", QEMU_CAPS_VIRTIO_PCI_IOMMU_PLATFORM },
    { "ats", QEMU_CAPS_VIRTIO_PCI_ATS },
1256 1257
};

1258
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsICH9[] = {
1259 1260 1261 1262
    { "disable_s3", QEMU_CAPS_ICH9_DISABLE_S3 },
    { "disable_s4", QEMU_CAPS_ICH9_DISABLE_S4 },
};

1263
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsUSBNECXHCI[] = {
1264 1265 1266
    { "p3", QEMU_CAPS_NEC_USB_XHCI_PORTS },
};

1267
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsIntelIOMMU[] = {
1268
    { "intremap", QEMU_CAPS_INTEL_IOMMU_INTREMAP },
1269
    { "caching-mode", QEMU_CAPS_INTEL_IOMMU_CACHING_MODE },
1270
    { "eim", QEMU_CAPS_INTEL_IOMMU_EIM },
1271
    { "device-iotlb", QEMU_CAPS_INTEL_IOMMU_DEVICE_IOTLB },
1272 1273
};

1274 1275 1276 1277
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtualCSSBridge[] = {
    { "cssid-unrestricted", QEMU_CAPS_CCW_CSSID_UNRESTRICTED },
};

1278 1279 1280 1281
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsMCH[] = {
    { "extended-tseg-mbytes", QEMU_CAPS_MCH_EXTENDED_TSEG_MBYTES },
};

1282 1283 1284 1285
static struct virQEMUCapsStringFlags virQEMUCapsDevicePropsNVDIMM[] = {
    { "unarmed", QEMU_CAPS_DEVICE_NVDIMM_UNARMED },
};

1286
/* see documentation for virQEMUQAPISchemaPathGet for the query format */
1287
static struct virQEMUCapsStringFlags virQEMUCapsQMPSchemaQueries[] = {
1288
    { "blockdev-add/arg-type/options/+gluster/debug-level", QEMU_CAPS_GLUSTER_DEBUG_LEVEL},
1289
    { "blockdev-add/arg-type/+gluster/debug", QEMU_CAPS_GLUSTER_DEBUG_LEVEL},
J
John Ferlan 已提交
1290
    { "blockdev-add/arg-type/+vxhs", QEMU_CAPS_VXHS},
1291
    { "blockdev-add/arg-type/+iscsi/password-secret", QEMU_CAPS_ISCSI_PASSWORD_SECRET },
1292
    { "blockdev-add/arg-type/+qcow2/encrypt/+luks/key-secret", QEMU_CAPS_QCOW2_LUKS },
1293
    { "nbd-server-start/arg-type/tls-creds", QEMU_CAPS_NBD_TLS },
1294
    { "screendump/arg-type/device", QEMU_CAPS_SCREENDUMP_DEVICE },
1295
    { "block-commit/arg-type/*top",  QEMU_CAPS_ACTIVE_COMMIT },
1296
    { "query-iothreads/ret-type/poll-max-ns", QEMU_CAPS_IOTHREAD_POLLING },
1297
    { "query-display-options/ret-type/+egl-headless/rendernode", QEMU_CAPS_EGL_HEADLESS_RENDERNODE },
1298
    { "nbd-server-add/arg-type/bitmap", QEMU_CAPS_NBD_BITMAP },
1299
    { "blockdev-add/arg-type/+file/drop-cache", QEMU_CAPS_MIGRATION_FILE_DROP_CACHE },
1300 1301
};

1302 1303
typedef struct _virQEMUCapsObjectTypeProps virQEMUCapsObjectTypeProps;
struct _virQEMUCapsObjectTypeProps {
1304
    const char *type;
1305
    struct virQEMUCapsStringFlags *props;
1306
    size_t nprops;
1307
    int capsCondition;
1308 1309
};

1310 1311 1312 1313 1314
typedef int (*virQEMUCapsObjectTypePropsCB)(qemuMonitorPtr mon,
                                            const char *type,
                                            char ***props);

static virQEMUCapsObjectTypeProps virQEMUCapsDeviceProps[] = {
1315
    { "virtio-blk-pci", virQEMUCapsDevicePropsVirtioBlk,
1316
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBlk),
1317
      -1 },
1318
    { "virtio-net-pci", virQEMUCapsDevicePropsVirtioNet,
1319
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioNet),
1320
      QEMU_CAPS_DEVICE_VIRTIO_NET },
1321
    { "virtio-scsi-pci", virQEMUCapsDevicePropsVirtioSCSI,
1322
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioSCSI),
1323
      QEMU_CAPS_VIRTIO_SCSI },
1324
    { "virtio-blk-ccw", virQEMUCapsDevicePropsVirtioBlk,
1325
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBlk),
1326
      QEMU_CAPS_VIRTIO_CCW },
1327
    { "virtio-net-ccw", virQEMUCapsDevicePropsVirtioNet,
1328
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioNet),
1329
      QEMU_CAPS_DEVICE_VIRTIO_NET },
1330
    { "virtio-scsi-ccw", virQEMUCapsDevicePropsVirtioSCSI,
1331
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioSCSI),
1332
      QEMU_CAPS_VIRTIO_SCSI },
1333
    { "virtio-blk-s390", virQEMUCapsDevicePropsVirtioBlk,
1334
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBlk),
1335
      QEMU_CAPS_VIRTIO_S390 },
1336
    { "virtio-net-s390", virQEMUCapsDevicePropsVirtioNet,
1337
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioNet),
1338
      QEMU_CAPS_DEVICE_VIRTIO_NET },
1339
    { "vfio-pci", virQEMUCapsDevicePropsVfioPCI,
1340
      G_N_ELEMENTS(virQEMUCapsDevicePropsVfioPCI),
1341
      QEMU_CAPS_DEVICE_VFIO_PCI },
1342
    { "scsi-hd", virQEMUCapsDevicePropsSCSIDisk,
1343
      G_N_ELEMENTS(virQEMUCapsDevicePropsSCSIDisk),
1344
      -1 },
1345
    { "ide-hd", virQEMUCapsDevicePropsIDEDrive,
1346
      G_N_ELEMENTS(virQEMUCapsDevicePropsIDEDrive),
1347
      -1 },
1348
    { "PIIX4_PM", virQEMUCapsDevicePropsPiix4PM,
1349
      G_N_ELEMENTS(virQEMUCapsDevicePropsPiix4PM),
1350
      -1 },
1351
    { "usb-redir", virQEMUCapsDevicePropsUSBRedir,
1352
      G_N_ELEMENTS(virQEMUCapsDevicePropsUSBRedir),
1353
      QEMU_CAPS_USB_REDIR },
1354
    { "i440FX-pcihost", virQEMUCapsDevicePropsI440FXPCIHost,
1355
      G_N_ELEMENTS(virQEMUCapsDevicePropsI440FXPCIHost),
1356
      -1 },
1357
    { "q35-pcihost", virQEMUCapsDevicePropsQ35PCIHost,
1358
      G_N_ELEMENTS(virQEMUCapsDevicePropsQ35PCIHost),
1359
      -1 },
1360
    { "usb-storage", virQEMUCapsDevicePropsUSBStorage,
1361
      G_N_ELEMENTS(virQEMUCapsDevicePropsUSBStorage),
1362
      QEMU_CAPS_DEVICE_USB_STORAGE },
1363
    { "kvm-pit", virQEMUCapsDevicePropsKVMPit,
1364
      G_N_ELEMENTS(virQEMUCapsDevicePropsKVMPit),
1365
      -1 },
1366
    { "VGA", virQEMUCapsDevicePropsVGA,
1367
      G_N_ELEMENTS(virQEMUCapsDevicePropsVGA),
1368
      QEMU_CAPS_DEVICE_VGA },
1369
    { "vmware-svga", virQEMUCapsDevicePropsVmwareSvga,
1370
      G_N_ELEMENTS(virQEMUCapsDevicePropsVmwareSvga),
1371
      QEMU_CAPS_DEVICE_VMWARE_SVGA },
1372
    { "qxl", virQEMUCapsDevicePropsQxl,
1373
      G_N_ELEMENTS(virQEMUCapsDevicePropsQxl),
1374
      QEMU_CAPS_DEVICE_QXL },
1375
    { "virtio-gpu-pci", virQEMUCapsDevicePropsVirtioGpu,
1376
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
1377
      QEMU_CAPS_DEVICE_VIRTIO_GPU },
1378
    { "virtio-gpu-device", virQEMUCapsDevicePropsVirtioGpu,
1379
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
1380
      QEMU_CAPS_DEVICE_VIRTIO_GPU },
1381
    { "ICH9-LPC", virQEMUCapsDevicePropsICH9,
1382
      G_N_ELEMENTS(virQEMUCapsDevicePropsICH9),
1383
      -1 },
1384
    { "virtio-balloon-pci", virQEMUCapsDevicePropsVirtioBalloon,
1385
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
1386
      -1 },
1387
    { "virtio-balloon-ccw", virQEMUCapsDevicePropsVirtioBalloon,
1388
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
1389
      -1 },
1390
    { "virtio-balloon-device", virQEMUCapsDevicePropsVirtioBalloon,
1391
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
1392
      -1 },
1393
    { "nec-usb-xhci", virQEMUCapsDevicePropsUSBNECXHCI,
1394
      G_N_ELEMENTS(virQEMUCapsDevicePropsUSBNECXHCI),
1395
      QEMU_CAPS_NEC_USB_XHCI },
1396
    { "intel-iommu", virQEMUCapsDevicePropsIntelIOMMU,
1397
      G_N_ELEMENTS(virQEMUCapsDevicePropsIntelIOMMU),
1398
      QEMU_CAPS_DEVICE_INTEL_IOMMU },
1399
    { "spapr-pci-host-bridge", virQEMUCapsDevicePropsSpaprPCIHostBridge,
1400
      G_N_ELEMENTS(virQEMUCapsDevicePropsSpaprPCIHostBridge),
1401
      QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE },
1402
    { "virtio-gpu-ccw", virQEMUCapsDevicePropsVirtioGpu,
1403
      G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
1404
      QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW },
1405
    { "virtual-css-bridge", virQEMUCapsObjectPropsVirtualCSSBridge,
1406
      G_N_ELEMENTS(virQEMUCapsObjectPropsVirtualCSSBridge),
1407
      QEMU_CAPS_CCW },
1408
    { "mch", virQEMUCapsDevicePropsMCH,
1409
      G_N_ELEMENTS(virQEMUCapsDevicePropsMCH),
1410
      QEMU_CAPS_DEVICE_MCH },
1411
    { "nvdimm", virQEMUCapsDevicePropsNVDIMM,
1412
      G_N_ELEMENTS(virQEMUCapsDevicePropsNVDIMM),
1413
      QEMU_CAPS_DEVICE_NVDIMM },
1414 1415
};

1416 1417
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsMemoryBackendFile[] = {
    { "discard-data", QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD },
1418
    { "align", QEMU_CAPS_OBJECT_MEMORY_FILE_ALIGN },
1419
    { "pmem", QEMU_CAPS_OBJECT_MEMORY_FILE_PMEM },
1420 1421
};

1422 1423 1424 1425
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsMemoryBackendMemfd[] = {
    { "hugetlb", QEMU_CAPS_OBJECT_MEMORY_MEMFD_HUGETLB },
};

1426 1427 1428 1429
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsMaxX86CPU[] = {
    { "unavailable-features", QEMU_CAPS_CPU_UNAVAILABLE_FEATURES },
};

1430 1431
static virQEMUCapsObjectTypeProps virQEMUCapsObjectProps[] = {
    { "memory-backend-file", virQEMUCapsObjectPropsMemoryBackendFile,
1432
      G_N_ELEMENTS(virQEMUCapsObjectPropsMemoryBackendFile),
1433
      QEMU_CAPS_OBJECT_MEMORY_FILE },
1434
    { "memory-backend-memfd", virQEMUCapsObjectPropsMemoryBackendMemfd,
1435
      G_N_ELEMENTS(virQEMUCapsObjectPropsMemoryBackendMemfd),
1436
      QEMU_CAPS_OBJECT_MEMORY_MEMFD },
1437
    { "max-x86_64-cpu", virQEMUCapsObjectPropsMaxX86CPU,
1438
      G_N_ELEMENTS(virQEMUCapsObjectPropsMaxX86CPU),
1439
      QEMU_CAPS_X86_MAX_CPU },
1440 1441
};

1442
static struct virQEMUCapsStringFlags virQEMUCapsMachinePropsPSeries[] = {
1443 1444 1445
    { "cap-hpt-max-page-size", QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE },
    { "cap-htm", QEMU_CAPS_MACHINE_PSERIES_CAP_HTM },
    { "cap-nested-hv", QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV },
1446
    { "cap-ccf-assist", QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST },
1447 1448
};

1449 1450 1451 1452
static struct virQEMUCapsStringFlags virQEMUCapsMachinePropsVirt[] = {
    { "iommu", QEMU_CAPS_MACHINE_VIRT_IOMMU },
};

1453
static virQEMUCapsObjectTypeProps virQEMUCapsMachineProps[] = {
1454
    { "pseries", virQEMUCapsMachinePropsPSeries,
1455
      G_N_ELEMENTS(virQEMUCapsMachinePropsPSeries),
1456
      -1 },
1457
    { "virt", virQEMUCapsMachinePropsVirt,
1458
      G_N_ELEMENTS(virQEMUCapsMachinePropsVirt),
1459
      -1 },
1460
};
1461 1462

static void
1463 1464 1465 1466 1467
virQEMUCapsProcessStringFlags(virQEMUCapsPtr qemuCaps,
                              size_t nflags,
                              struct virQEMUCapsStringFlags *flags,
                              size_t nvalues,
                              char *const*values)
1468 1469
{
    size_t i, j;
1470
    for (i = 0; i < nflags; i++) {
1471 1472 1473
        if (virQEMUCapsGet(qemuCaps, flags[i].flag))
            continue;

1474
        for (j = 0; j < nvalues; j++) {
1475
            if (STREQ(values[j], flags[i].value)) {
1476
                virQEMUCapsSet(qemuCaps, flags[i].flag);
1477 1478 1479 1480 1481 1482 1483
                break;
            }
        }
    }
}


1484
int virQEMUCapsGetDefaultVersion(virCapsPtr caps,
1485
                                 virFileCachePtr capsCache,
1486
                                 unsigned int *version)
1487
{
1488
    virQEMUCapsPtr qemucaps;
T
Tal Kain 已提交
1489
    virArch hostarch;
1490
    virCapsDomainDataPtr capsdata;
1491 1492 1493 1494

    if (*version > 0)
        return 0;

T
Tal Kain 已提交
1495
    hostarch = virArchFromHost();
1496 1497 1498
    if (!(capsdata = virCapabilitiesDomainDataLookup(caps,
            VIR_DOMAIN_OSTYPE_HVM, hostarch, VIR_DOMAIN_VIRT_QEMU,
            NULL, NULL))) {
1499
        virReportError(VIR_ERR_INTERNAL_ERROR,
1500
                       _("Cannot find suitable emulator for %s"),
T
Tal Kain 已提交
1501
                       virArchToString(hostarch));
1502 1503 1504
        return -1;
    }

1505
    qemucaps = virQEMUCapsCacheLookup(capsCache, capsdata->emulator);
1506 1507
    VIR_FREE(capsdata);
    if (!qemucaps)
1508 1509
        return -1;

1510
    *version = virQEMUCapsGetVersion(qemucaps);
1511
    virObjectUnref(qemucaps);
1512 1513
    return 0;
}
1514 1515


1516 1517


1518 1519
virQEMUCapsPtr
virQEMUCapsNew(void)
1520
{
1521
    virQEMUCapsPtr qemuCaps;
1522

1523
    if (virQEMUCapsInitialize() < 0)
1524 1525
        return NULL;

1526
    if (!(qemuCaps = virObjectNew(virQEMUCapsClass)))
1527 1528
        return NULL;

1529
    if (!(qemuCaps->flags = virBitmapNew(QEMU_CAPS_LAST)))
1530
        goto error;
1531

1532 1533 1534
    if (!(qemuCaps->domCapsCache = virHashCreate(5, virObjectFreeHashData)))
        goto error;

1535
    return qemuCaps;
1536

1537
 error:
1538
    virObjectUnref(qemuCaps);
1539
    return NULL;
1540 1541 1542
}


1543
static int
1544 1545
virQEMUCapsHostCPUDataCopy(virQEMUCapsHostCPUDataPtr dst,
                           virQEMUCapsHostCPUDataPtr src)
1546
{
1547 1548
    if (src->info &&
        !(dst->info = qemuMonitorCPUModelInfoCopy(src->info)))
1549 1550
        return -1;

1551 1552
    if (src->reported &&
        !(dst->reported = virCPUDefCopy(src->reported)))
1553 1554
        return -1;

1555 1556 1557 1558
    if (src->migratable &&
        !(dst->migratable = virCPUDefCopy(src->migratable)))
        return -1;

1559 1560 1561 1562
    if (src->full &&
        !(dst->full = virCPUDefCopy(src->full)))
        return -1;

1563 1564 1565 1566
    return 0;
}


1567
static void
1568
virQEMUCapsHostCPUDataClear(virQEMUCapsHostCPUDataPtr cpuData)
1569
{
1570
    qemuMonitorCPUModelInfoFree(cpuData->info);
1571
    virCPUDefFree(cpuData->reported);
1572
    virCPUDefFree(cpuData->migratable);
1573
    virCPUDefFree(cpuData->full);
1574 1575

    memset(cpuData, 0, sizeof(*cpuData));
1576 1577 1578
}


1579 1580 1581 1582
static int
virQEMUCapsSEVInfoCopy(virSEVCapabilityPtr *dst,
                       virSEVCapabilityPtr src)
{
J
Ján Tomko 已提交
1583
    g_autoptr(virSEVCapability) tmp = NULL;
1584 1585 1586 1587 1588 1589 1590 1591 1592

    if (VIR_ALLOC(tmp) < 0 ||
        VIR_STRDUP(tmp->pdh, src->pdh) < 0 ||
        VIR_STRDUP(tmp->cert_chain, src->cert_chain) < 0)
        return -1;

    tmp->cbitpos = src->cbitpos;
    tmp->reduced_phys_bits = src->reduced_phys_bits;

1593
    *dst = g_steal_pointer(&tmp);
1594 1595 1596 1597
    return 0;
}


1598
virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps)
1599
{
1600
    virQEMUCapsPtr ret = virQEMUCapsNew();
1601 1602 1603 1604 1605
    size_t i;

    if (!ret)
        return NULL;

1606
    ret->usedQMP = qemuCaps->usedQMP;
1607
    ret->kvmSupportsNesting = qemuCaps->kvmSupportsNesting;
1608

1609 1610 1611 1612 1613
    if (VIR_STRDUP(ret->binary, qemuCaps->binary) < 0)
        goto error;

    ret->ctime = qemuCaps->ctime;

1614
    virBitmapCopy(ret->flags, qemuCaps->flags);
1615

1616 1617
    ret->version = qemuCaps->version;
    ret->kvmVersion = qemuCaps->kvmVersion;
1618
    ret->microcodeVersion = qemuCaps->microcodeVersion;
1619 1620 1621 1622

    if (VIR_STRDUP(ret->package, qemuCaps->package) < 0)
        goto error;

1623 1624 1625
    if (VIR_STRDUP(ret->kernelVersion, qemuCaps->kernelVersion) < 0)
        goto error;

1626
    ret->arch = qemuCaps->arch;
1627

1628 1629 1630 1631 1632 1633 1634 1635 1636
    if (qemuCaps->kvmCPUModels) {
        ret->kvmCPUModels = virDomainCapsCPUModelsCopy(qemuCaps->kvmCPUModels);
        if (!ret->kvmCPUModels)
            goto error;
    }

    if (qemuCaps->tcgCPUModels) {
        ret->tcgCPUModels = virDomainCapsCPUModelsCopy(qemuCaps->tcgCPUModels);
        if (!ret->tcgCPUModels)
1637
            goto error;
1638 1639
    }

1640 1641
    if (virQEMUCapsHostCPUDataCopy(&ret->kvmCPU, &qemuCaps->kvmCPU) < 0 ||
        virQEMUCapsHostCPUDataCopy(&ret->tcgCPU, &qemuCaps->tcgCPU) < 0)
1642 1643
        goto error;

1644
    if (VIR_ALLOC_N(ret->machineTypes, qemuCaps->nmachineTypes) < 0)
1645
        goto error;
1646
    ret->nmachineTypes = qemuCaps->nmachineTypes;
1647
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
1648 1649
        if (VIR_STRDUP(ret->machineTypes[i].name, qemuCaps->machineTypes[i].name) < 0 ||
            VIR_STRDUP(ret->machineTypes[i].alias, qemuCaps->machineTypes[i].alias) < 0)
1650
            goto error;
1651
        ret->machineTypes[i].maxCpus = qemuCaps->machineTypes[i].maxCpus;
1652
        ret->machineTypes[i].hotplugCpus = qemuCaps->machineTypes[i].hotplugCpus;
1653 1654
        ret->machineTypes[i].qemuDefault = qemuCaps->machineTypes[i].qemuDefault;

1655 1656
    }

1657 1658 1659 1660 1661 1662
    if (VIR_ALLOC_N(ret->gicCapabilities, qemuCaps->ngicCapabilities) < 0)
        goto error;
    ret->ngicCapabilities = qemuCaps->ngicCapabilities;
    for (i = 0; i < qemuCaps->ngicCapabilities; i++)
        ret->gicCapabilities[i] = qemuCaps->gicCapabilities[i];

1663 1664 1665 1666 1667
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEV_GUEST) &&
        virQEMUCapsSEVInfoCopy(&ret->sevCapabilities,
                               qemuCaps->sevCapabilities) < 0)
        goto error;

1668 1669
    return ret;

1670
 error:
1671 1672 1673 1674 1675
    virObjectUnref(ret);
    return NULL;
}


1676
void virQEMUCapsDispose(void *obj)
1677
{
1678
    virQEMUCapsPtr qemuCaps = obj;
1679 1680
    size_t i;

1681
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
1682 1683
        VIR_FREE(qemuCaps->machineTypes[i].name);
        VIR_FREE(qemuCaps->machineTypes[i].alias);
1684
    }
1685
    VIR_FREE(qemuCaps->machineTypes);
1686

1687
    virHashFree(qemuCaps->domCapsCache);
1688 1689
    virObjectUnref(qemuCaps->kvmCPUModels);
    virObjectUnref(qemuCaps->tcgCPUModels);
1690

1691
    virBitmapFree(qemuCaps->flags);
1692

1693
    VIR_FREE(qemuCaps->package);
1694
    VIR_FREE(qemuCaps->kernelVersion);
1695
    VIR_FREE(qemuCaps->binary);
A
Andrea Bolognani 已提交
1696 1697

    VIR_FREE(qemuCaps->gicCapabilities);
1698

1699 1700
    virSEVCapabilitiesFree(qemuCaps->sevCapabilities);

1701 1702
    virQEMUCapsHostCPUDataClear(&qemuCaps->kvmCPU);
    virQEMUCapsHostCPUDataClear(&qemuCaps->tcgCPU);
1703 1704
}

1705
void
1706
virQEMUCapsSet(virQEMUCapsPtr qemuCaps,
1707
               virQEMUCapsFlags flag)
1708
{
1709
    ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
1710 1711 1712
}


C
Cole Robinson 已提交
1713 1714 1715 1716
void
virQEMUCapsSetList(virQEMUCapsPtr qemuCaps, ...)
{
    va_list list;
1717
    int flag;
C
Cole Robinson 已提交
1718 1719

    va_start(list, qemuCaps);
1720 1721
    while ((flag = va_arg(list, int)) < QEMU_CAPS_LAST)
        virQEMUCapsSet(qemuCaps, flag);
1722
    va_end(list);
1723 1724 1725 1726
}


void
1727
virQEMUCapsClear(virQEMUCapsPtr qemuCaps,
1728
                 virQEMUCapsFlags flag)
1729
{
1730
    ignore_value(virBitmapClearBit(qemuCaps->flags, flag));
1731 1732 1733
}


1734
char *virQEMUCapsFlagsString(virQEMUCapsPtr qemuCaps)
1735
{
1736
    return virBitmapToString(qemuCaps->flags, true, false);
1737 1738 1739 1740
}


bool
1741
virQEMUCapsGet(virQEMUCapsPtr qemuCaps,
1742
               virQEMUCapsFlags flag)
1743
{
J
Ján Tomko 已提交
1744
    return qemuCaps && virBitmapIsBitSet(qemuCaps->flags, flag);
1745
}
1746 1747


D
Daniel P. Berrange 已提交
1748
bool virQEMUCapsHasPCIMultiBus(virQEMUCapsPtr qemuCaps,
1749
                               const virDomainDef *def)
D
Daniel P. Berrange 已提交
1750
{
1751 1752
    /* x86_64 and i686 support PCI-multibus on all machine types
     * since forever */
1753
    if (ARCH_IS_X86(def->os.arch))
D
Daniel P. Berrange 已提交
1754 1755 1756
        return true;

    if (def->os.arch == VIR_ARCH_PPC ||
1757
        ARCH_IS_PPC64(def->os.arch)) {
D
Daniel P. Berrange 已提交
1758 1759 1760 1761 1762
        /*
         * Usage of pci.0 naming:
         *
         *    ref405ep: no pci
         *       taihu: no pci
1763
         *      bamboo: 1.1.0 (<= 1.5.0, so basically forever)
D
Daniel P. Berrange 已提交
1764 1765
         *       mac99: 2.0.0
         *     g3beige: 2.0.0
1766
         *        prep: 1.4.0 (<= 1.5.0, so basically forever)
D
Daniel P. Berrange 已提交
1767 1768 1769 1770 1771 1772
         *     pseries: 2.0.0
         *   mpc8544ds: forever
         * virtex-m507: no pci
         *     ppce500: 1.6.0
         */

1773 1774 1775 1776 1777 1778 1779 1780
        /* We do not store the qemu version in domain status XML.
         * Hope the user is using a QEMU new enough to use 'pci.0',
         * otherwise the results of this function will be wrong
         * for domains already running at the time of daemon
         * restart */
        if (qemuCaps->version == 0)
            return true;

D
Daniel P. Berrange 已提交
1781 1782 1783 1784 1785 1786 1787
        if (qemuCaps->version >= 2000000)
            return true;

        if (qemuCaps->version >= 1006000 &&
            STREQ(def->os.machine, "ppce500"))
            return true;

1788 1789 1790
        if (STREQ(def->os.machine, "bamboo") ||
            STREQ(def->os.machine, "mpc8544ds") ||
            STREQ(def->os.machine, "prep")) {
D
Daniel P. Berrange 已提交
1791
            return true;
1792
        }
D
Daniel P. Berrange 已提交
1793 1794 1795 1796

        return false;
    }

1797 1798 1799 1800
    /* S390 supports PCI-multibus. */
    if (ARCH_IS_S390(def->os.arch))
        return true;

1801 1802 1803 1804
    /* If the virt machine, both on ARM and RISC-V, supports PCI,
     * then it also supports multibus */
    if (qemuDomainIsARMVirt(def) ||
        qemuDomainIsRISCVVirt(def)) {
1805
        return true;
1806
    }
1807

D
Daniel P. Berrange 已提交
1808 1809 1810 1811
    return false;
}


1812
const char *virQEMUCapsGetBinary(virQEMUCapsPtr qemuCaps)
1813
{
1814
    return qemuCaps->binary;
1815 1816
}

1817 1818 1819 1820 1821 1822 1823 1824 1825

void
virQEMUCapsSetArch(virQEMUCapsPtr qemuCaps,
                   virArch arch)
{
    qemuCaps->arch = arch;
}


1826
virArch virQEMUCapsGetArch(virQEMUCapsPtr qemuCaps)
1827
{
1828
    return qemuCaps->arch;
1829 1830 1831
}


1832
unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr qemuCaps)
1833
{
1834
    return qemuCaps->version;
1835 1836 1837
}


1838
unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr qemuCaps)
1839
{
1840
    return qemuCaps->kvmVersion;
1841 1842 1843
}


1844 1845 1846 1847 1848 1849
const char *virQEMUCapsGetPackage(virQEMUCapsPtr qemuCaps)
{
    return qemuCaps->package;
}


1850 1851 1852 1853 1854 1855
virHashTablePtr virQEMUCapsGetDomainCapsCache(virQEMUCapsPtr qemuCaps)
{
    return qemuCaps->domCapsCache;
}


1856 1857
int
virQEMUCapsAddCPUDefinitions(virQEMUCapsPtr qemuCaps,
1858
                             virDomainVirtType type,
1859
                             const char **name,
1860 1861
                             size_t count,
                             virDomainCapsCPUUsable usable)
1862
{
1863
    size_t i;
1864
    virDomainCapsCPUModelsPtr cpus = NULL;
1865

1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879
    if (type == VIR_DOMAIN_VIRT_KVM && qemuCaps->kvmCPUModels)
        cpus = qemuCaps->kvmCPUModels;
    else if (type == VIR_DOMAIN_VIRT_QEMU && qemuCaps->tcgCPUModels)
        cpus = qemuCaps->tcgCPUModels;

    if (!cpus) {
        if (!(cpus = virDomainCapsCPUModelsNew(count)))
            return -1;

        if (type == VIR_DOMAIN_VIRT_KVM)
            qemuCaps->kvmCPUModels = cpus;
        else
            qemuCaps->tcgCPUModels = cpus;
    }
1880 1881

    for (i = 0; i < count; i++) {
1882
        if (virDomainCapsCPUModelsAdd(cpus, name[i], -1, usable, NULL) < 0)
1883
            return -1;
1884
    }
1885

1886 1887 1888 1889
    return 0;
}


1890
virDomainCapsCPUModelsPtr
1891
virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr qemuCaps,
1892
                             virDomainVirtType type)
1893
{
1894
    if (type == VIR_DOMAIN_VIRT_KVM)
1895
        return qemuCaps->kvmCPUModels;
1896
    else
1897
        return qemuCaps->tcgCPUModels;
1898 1899 1900
}


1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
static virQEMUCapsHostCPUDataPtr
virQEMUCapsGetHostCPUData(virQEMUCapsPtr qemuCaps,
                          virDomainVirtType type)
{
    if (type == VIR_DOMAIN_VIRT_KVM)
        return &qemuCaps->kvmCPU;
    else
        return &qemuCaps->tcgCPU;
}


1912
virCPUDefPtr
1913
virQEMUCapsGetHostModel(virQEMUCapsPtr qemuCaps,
1914 1915
                        virDomainVirtType type,
                        virQEMUCapsHostCPUType cpuType)
1916
{
1917 1918
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);

1919 1920 1921
    switch (cpuType) {
    case VIR_QEMU_CAPS_HOST_CPU_REPORTED:
        return cpuData->reported;
1922 1923 1924

    case VIR_QEMU_CAPS_HOST_CPU_MIGRATABLE:
        return cpuData->migratable;
1925 1926 1927 1928 1929

    case VIR_QEMU_CAPS_HOST_CPU_FULL:
        /* 'full' is non-NULL only if we have data from both QEMU and
         * virCPUGetHost */
        return cpuData->full ? cpuData->full : cpuData->reported;
1930 1931 1932
    }

    return NULL;
1933 1934 1935
}


1936 1937 1938
static void
virQEMUCapsSetHostModel(virQEMUCapsPtr qemuCaps,
                        virDomainVirtType type,
1939
                        virCPUDefPtr reported,
1940 1941
                        virCPUDefPtr migratable,
                        virCPUDefPtr full)
1942
{
1943 1944
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);

1945 1946
    cpuData->reported = reported;
    cpuData->migratable = migratable;
1947
    cpuData->full = full;
1948 1949 1950
}


1951 1952 1953 1954 1955 1956
bool
virQEMUCapsIsCPUModeSupported(virQEMUCapsPtr qemuCaps,
                              virCapsPtr caps,
                              virDomainVirtType type,
                              virCPUMode mode)
{
1957 1958
    virDomainCapsCPUModelsPtr cpus;

1959 1960 1961 1962 1963 1964
    switch (mode) {
    case VIR_CPU_MODE_HOST_PASSTHROUGH:
        return type == VIR_DOMAIN_VIRT_KVM &&
               virQEMUCapsGuestIsNative(caps->host.arch, qemuCaps->arch);

    case VIR_CPU_MODE_HOST_MODEL:
1965 1966
        return !!virQEMUCapsGetHostModel(qemuCaps, type,
                                         VIR_QEMU_CAPS_HOST_CPU_REPORTED);
1967 1968

    case VIR_CPU_MODE_CUSTOM:
1969 1970 1971 1972 1973
        if (type == VIR_DOMAIN_VIRT_KVM)
            cpus = qemuCaps->kvmCPUModels;
        else
            cpus = qemuCaps->tcgCPUModels;
        return cpus && cpus->nmodels > 0;
1974 1975 1976 1977 1978 1979 1980 1981 1982

    case VIR_CPU_MODE_LAST:
        break;
    }

    return false;
}


1983 1984 1985
int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr qemuCaps,
                                   size_t *nmachines,
                                   virCapsGuestMachinePtr **machines)
1986 1987 1988 1989
{
    size_t i;

    *machines = NULL;
1990
    *nmachines = qemuCaps->nmachineTypes;
1991

1992 1993 1994 1995
    if (*nmachines &&
        VIR_ALLOC_N(*machines, qemuCaps->nmachineTypes) < 0)
        goto error;

1996
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
1997 1998
        virCapsGuestMachinePtr mach;
        if (VIR_ALLOC(mach) < 0)
1999
            goto error;
2000
        (*machines)[i] = mach;
2001 2002 2003
        if (qemuCaps->machineTypes[i].alias) {
            if (VIR_STRDUP(mach->name, qemuCaps->machineTypes[i].alias) < 0 ||
                VIR_STRDUP(mach->canonical, qemuCaps->machineTypes[i].name) < 0)
2004
                goto error;
2005
        } else {
2006
            if (VIR_STRDUP(mach->name, qemuCaps->machineTypes[i].name) < 0)
2007
                goto error;
2008
        }
2009
        mach->maxCpus = qemuCaps->machineTypes[i].maxCpus;
2010 2011
    }

2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
    /* Make sure all canonical machine types also have their own entry so that
     * /capabilities/guest/arch[@name='...']/machine/text() XPath selects all
     * supported machine types.
     */
    i = 0;
    while (i < *nmachines) {
        size_t j;
        bool found = false;
        virCapsGuestMachinePtr machine = (*machines)[i];

        if (!machine->canonical) {
            i++;
            continue;
        }

        for (j = 0; j < *nmachines; j++) {
            if (STREQ(machine->canonical, (*machines)[j]->name)) {
                found = true;
                break;
            }
        }

        if (!found) {
            virCapsGuestMachinePtr mach;
            if (VIR_ALLOC(mach) < 0)
                goto error;
            if (VIR_INSERT_ELEMENT_COPY(*machines, i, *nmachines, mach) < 0) {
                VIR_FREE(mach);
                goto error;
            }
            if (VIR_STRDUP(mach->name, machine->canonical) < 0)
                goto error;
            mach->maxCpus = machine->maxCpus;
            i++;
        }
        i++;
    }

2050 2051
    return 0;

2052
 error:
2053 2054 2055 2056 2057 2058 2059
    virCapabilitiesFreeMachines(*machines, *nmachines);
    *nmachines = 0;
    *machines = NULL;
    return -1;
}


2060 2061 2062 2063 2064 2065 2066 2067
/**
 * virQEMUCapsGetCanonicalMachine:
 * @qemuCaps: qemu capabilities object
 * @name: machine name
 *
 * Resolves aliased machine names to the actual machine name. If qemuCaps isn't
 * present @name is returned.
 */
2068 2069
const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps,
                                           const char *name)
2070 2071 2072
{
    size_t i;

2073 2074
    if (!name || !qemuCaps)
        return name;
2075

2076
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2077
        if (!qemuCaps->machineTypes[i].alias)
2078
            continue;
2079 2080
        if (STREQ(qemuCaps->machineTypes[i].alias, name))
            return qemuCaps->machineTypes[i].name;
2081 2082 2083 2084
    }

    return name;
}
2085

2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
const char *
virQEMUCapsGetDefaultMachine(virQEMUCapsPtr qemuCaps)
{
    size_t i;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
        if (qemuCaps->machineTypes[i].qemuDefault)
            return qemuCaps->machineTypes[i].name;
    }

    return NULL;
}
2098

2099 2100 2101 2102 2103 2104 2105 2106 2107
int virQEMUCapsGetMachineMaxCpus(virQEMUCapsPtr qemuCaps,
                                 const char *name)
{
    size_t i;

    if (!name)
        return 0;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2108
        if (!qemuCaps->machineTypes[i].maxCpus)
2109
            continue;
2110 2111
        if (STREQ(qemuCaps->machineTypes[i].name, name))
            return qemuCaps->machineTypes[i].maxCpus;
2112 2113 2114 2115 2116 2117
    }

    return 0;
}


2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
bool virQEMUCapsGetMachineHotplugCpus(virQEMUCapsPtr qemuCaps,
                                      const char *name)
{
    size_t i;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
        if (STREQ_NULLABLE(qemuCaps->machineTypes[i].name, name))
            return qemuCaps->machineTypes[i].hotplugCpus;
    }

    return false;
}


2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155
/**
 * virQEMUCapsSetGICCapabilities:
 * @qemuCaps: QEMU capabilities
 * @capabilities: GIC capabilities
 * @ncapabilities: number of GIC capabilities
 *
 * Set the GIC capabilities for @qemuCaps.
 *
 * The ownership of @capabilities is taken away from the caller, ie. this
 * function will not make a copy of @capabilities, so releasing that memory
 * after it's been called is a bug.
 */
void
virQEMUCapsSetGICCapabilities(virQEMUCapsPtr qemuCaps,
                              virGICCapability *capabilities,
                              size_t ncapabilities)
{
    VIR_FREE(qemuCaps->gicCapabilities);

    qemuCaps->gicCapabilities = capabilities;
    qemuCaps->ngicCapabilities = ncapabilities;
}


2156 2157 2158 2159 2160 2161 2162
virSEVCapabilityPtr
virQEMUCapsGetSEVCapabilities(virQEMUCapsPtr qemuCaps)
{
    return qemuCaps->sevCapabilities;
}


2163
static int
2164 2165
virQEMUCapsProbeQMPCommands(virQEMUCapsPtr qemuCaps,
                            qemuMonitorPtr mon)
2166 2167 2168 2169 2170 2171 2172
{
    char **commands = NULL;
    int ncommands;

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

2173
    virQEMUCapsProcessStringFlags(qemuCaps,
2174
                                  G_N_ELEMENTS(virQEMUCapsCommands),
2175 2176
                                  virQEMUCapsCommands,
                                  ncommands, commands);
2177
    virStringListFreeCount(commands, ncommands);
2178

2179 2180 2181
    /* Probe for active commit of qemu 2.1. We don't need to query directly
     * if we have QMP schema support */
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_QMP_SCHEMA) &&
2182 2183 2184
        qemuMonitorSupportsActiveCommit(mon))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_ACTIVE_COMMIT);

2185 2186 2187 2188 2189
    return 0;
}


static int
2190 2191
virQEMUCapsProbeQMPEvents(virQEMUCapsPtr qemuCaps,
                          qemuMonitorPtr mon)
2192 2193 2194 2195
{
    char **events = NULL;
    int nevents;

2196
    /* we can probe events also from the QMP schema so we can skip this here */
2197
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_QMP_SCHEMA))
2198
        return 0;
2199 2200 2201

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

2203
    virQEMUCapsProcessStringFlags(qemuCaps,
2204
                                  G_N_ELEMENTS(virQEMUCapsEvents),
2205 2206
                                  virQEMUCapsEvents,
                                  nevents, events);
2207
    virStringListFreeCount(events, nevents);
2208 2209 2210 2211

    return 0;
}

2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
static int
virQEMUCapsProbeQMPGenericProps(virQEMUCapsPtr qemuCaps,
                                qemuMonitorPtr mon,
                                virQEMUCapsObjectTypeProps *props,
                                size_t nprops,
                                virQEMUCapsObjectTypePropsCB propsGetCB)
{
    int nvalues;
    char **values;
    size_t i;

    for (i = 0; i < nprops; i++) {
        const char *type = props[i].type;
        int cap = props[i].capsCondition;

        if (cap >= 0 && !virQEMUCapsGet(qemuCaps, cap))
            continue;

        if ((nvalues = propsGetCB(mon, type, &values)) < 0)
            return -1;
        virQEMUCapsProcessStringFlags(qemuCaps,
                                      props[i].nprops,
                                      props[i].props,
                                      nvalues, values);
        virStringListFreeCount(values, nvalues);
    }

    return 0;
}
2241

2242
static int
2243
virQEMUCapsProbeQMPDevices(virQEMUCapsPtr qemuCaps,
2244
                           qemuMonitorPtr mon)
2245 2246 2247 2248 2249 2250
{
    int nvalues;
    char **values;

    if ((nvalues = qemuMonitorGetObjectTypes(mon, &values)) < 0)
        return -1;
2251
    virQEMUCapsProcessStringFlags(qemuCaps,
2252
                                  G_N_ELEMENTS(virQEMUCapsObjectTypes),
2253 2254
                                  virQEMUCapsObjectTypes,
                                  nvalues, values);
2255
    virStringListFreeCount(values, nvalues);
2256

2257 2258 2259
    if (virQEMUCapsProbeQMPGenericProps(qemuCaps,
                                        mon,
                                        virQEMUCapsDeviceProps,
2260
                                        G_N_ELEMENTS(virQEMUCapsDeviceProps),
2261 2262
                                        qemuMonitorGetDeviceProps) < 0)
        return -1;
2263

2264 2265 2266 2267
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_QOM_LIST_PROPERTIES) &&
        virQEMUCapsProbeQMPGenericProps(qemuCaps,
                                        mon,
                                        virQEMUCapsObjectProps,
2268
                                        G_N_ELEMENTS(virQEMUCapsObjectProps),
2269 2270 2271
                                        qemuMonitorGetObjectProps) < 0)
        return -1;

2272 2273 2274 2275
    return 0;
}


2276 2277 2278 2279 2280 2281 2282 2283 2284 2285
/* Historically QEMU x86 targets defaulted to 'pc' machine type but
 * in future x86_64 might switch to 'q35'. Such a change is considered
 * an ABI break from libvirt's POV. Other QEMU targets may not declare
 * a default machine at all, causing libvirt to use the first reported
 * machine in the list.
 *
 * Here we record a preferred default machine for all arches, so
 * that we're not vulnerable to changes in QEMU defaults or machine
 * list ordering.
 */
2286
static const char *preferredMachines[] =
2287
{
2288 2289
    NULL, /* VIR_ARCH_NONE (not a real arch :) */
    "clipper", /* VIR_ARCH_ALPHA */
S
Stefan Schallenberg 已提交
2290
    "integratorcp", /* VIR_ARCH_ARMV6L */
2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
    "integratorcp", /* VIR_ARCH_ARMV7L */
    "integratorcp", /* VIR_ARCH_ARMV7B */

    "integratorcp", /* VIR_ARCH_AARCH64 */
    "axis-dev88", /* VIR_ARCH_CRIS */
    "pc", /* VIR_ARCH_I686 */
    NULL, /* VIR_ARCH_ITANIUM (doesn't exist in QEMU any more) */
    "lm32-evr", /* VIR_ARCH_LM32 */

    "mcf5208evb", /* VIR_ARCH_M68K */
    "petalogix-s3adsp1800", /* VIR_ARCH_MICROBLAZE */
    "petalogix-s3adsp1800", /* VIR_ARCH_MICROBLAZEEL */
    "malta", /* VIR_ARCH_MIPS */
    "malta", /* VIR_ARCH_MIPSEL */

    "malta", /* VIR_ARCH_MIPS64 */
    "malta", /* VIR_ARCH_MIPS64EL */
    "or1k-sim", /* VIR_ARCH_OR32 */
    NULL, /* VIR_ARCH_PARISC (no QEMU impl) */
    NULL, /* VIR_ARCH_PARISC64 (no QEMU impl) */

    "g3beige", /* VIR_ARCH_PPC */
    "g3beige", /* VIR_ARCH_PPCLE */
    "pseries", /* VIR_ARCH_PPC64 */
    "pseries", /* VIR_ARCH_PPC64LE */
    "bamboo", /* VIR_ARCH_PPCEMB */

L
Lubomir Rintel 已提交
2318 2319
    "spike_v1.10", /* VIR_ARCH_RISCV32 */
    "spike_v1.10", /* VIR_ARCH_RISCV64 */
2320 2321 2322
    NULL, /* VIR_ARCH_S390 (no QEMU impl) */
    "s390-ccw-virtio", /* VIR_ARCH_S390X */
    "shix", /* VIR_ARCH_SH4 */
L
Lubomir Rintel 已提交
2323

2324 2325 2326 2327 2328
    "shix", /* VIR_ARCH_SH4EB */
    "SS-5", /* VIR_ARCH_SPARC */
    "sun4u", /* VIR_ARCH_SPARC64 */
    "puv3", /* VIR_ARCH_UNICORE32 */
    "pc", /* VIR_ARCH_X86_64 */
L
Lubomir Rintel 已提交
2329

2330 2331
    "sim", /* VIR_ARCH_XTENSA */
    "sim", /* VIR_ARCH_XTENSAEB */
2332
};
2333
verify(G_N_ELEMENTS(preferredMachines) == VIR_ARCH_LAST);
2334 2335


2336
static int
2337 2338
virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr qemuCaps,
                                qemuMonitorPtr mon)
2339 2340 2341 2342 2343
{
    qemuMonitorMachineInfoPtr *machines = NULL;
    int nmachines = 0;
    int ret = -1;
    size_t i;
2344 2345 2346
    ssize_t defIdx = -1;
    ssize_t preferredIdx = -1;
    const char *preferredMachine = preferredMachines[qemuCaps->arch];
2347 2348

    if ((nmachines = qemuMonitorGetMachines(mon, &machines)) < 0)
2349
        return -1;
2350

2351
    if (VIR_ALLOC_N(qemuCaps->machineTypes, nmachines) < 0)
2352 2353
        goto cleanup;

2354
    for (i = 0; i < nmachines; i++) {
2355
        struct virQEMUCapsMachineType *mach;
2356 2357
        if (STREQ(machines[i]->name, "none"))
            continue;
2358 2359 2360 2361 2362

        mach = &(qemuCaps->machineTypes[qemuCaps->nmachineTypes++]);

        if (VIR_STRDUP(mach->alias, machines[i]->alias) < 0 ||
            VIR_STRDUP(mach->name, machines[i]->name) < 0)
2363
            goto cleanup;
2364 2365

        mach->maxCpus = machines[i]->maxCpus;
2366
        mach->hotplugCpus = machines[i]->hotplugCpus;
2367

2368 2369 2370 2371 2372 2373
        if (preferredMachine &&
            (STREQ_NULLABLE(mach->alias, preferredMachine) ||
             STREQ(mach->name, preferredMachine))) {
            preferredIdx = qemuCaps->nmachineTypes - 1;
        }

2374 2375
        if (machines[i]->isDefault) {
            mach->qemuDefault = true;
2376
            defIdx = qemuCaps->nmachineTypes - 1;
2377
        }
2378
    }
2379

2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392
    /*
     * We'll prefer to use our own historical default machine
     * to avoid mgmt apps seeing semantics changes when QEMU
     * alters its defaults.
     *
     * Our preferred machine might have been compiled out of
     * QEMU at build time though, so we still fallback to honouring
     * QEMU's reported default in that case
     */
    if (preferredIdx == -1)
        preferredIdx = defIdx;
    if (preferredIdx != -1)
        virQEMUCapsSetDefaultMachine(qemuCaps, preferredIdx);
2393 2394 2395

    ret = 0;

2396
 cleanup:
2397
    for (i = 0; i < nmachines; i++)
2398 2399 2400 2401 2402 2403
        qemuMonitorMachineInfoFree(machines[i]);
    VIR_FREE(machines);
    return ret;
}


2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414
static int
virQEMUCapsProbeQMPMachineProps(virQEMUCapsPtr qemuCaps,
                                qemuMonitorPtr mon)
{
    char **values;
    int nvalues;
    size_t i;

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QOM_LIST_PROPERTIES))
        return 0;

2415
    for (i = 0; i < G_N_ELEMENTS(virQEMUCapsMachineProps); i++) {
2416
        virQEMUCapsObjectTypeProps props = virQEMUCapsMachineProps[i];
2417
        const char *canon = virQEMUCapsGetCanonicalMachine(qemuCaps, props.type);
2418
        g_autofree char *type = NULL;
2419

2420 2421 2422
        if (!virQEMUCapsIsMachineSupported(qemuCaps, canon))
            continue;

2423 2424
        /* The QOM type for machine types is the machine type name
         * followed by the -machine suffix */
2425
        if (virAsprintf(&type, "%s-machine", canon) < 0)
2426
            return -1;
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442

        if ((nvalues = qemuMonitorGetObjectProps(mon, type, &values)) < 0)
            return -1;

        virQEMUCapsProcessStringFlags(qemuCaps,
                                      props.nprops,
                                      props.props,
                                      nvalues, values);

        virStringListFreeCount(values, nvalues);
    }

    return 0;
}


2443
virDomainCapsCPUModelsPtr
2444 2445
virQEMUCapsFetchCPUDefinitions(qemuMonitorPtr mon,
                               virArch arch)
2446
{
2447 2448 2449
    virDomainCapsCPUModelsPtr models = NULL;
    qemuMonitorCPUDefInfoPtr *cpus = NULL;
    int ncpus = 0;
2450
    size_t i;
2451

2452
    if ((ncpus = qemuMonitorGetCPUDefinitions(mon, &cpus)) < 0)
2453
        return NULL;
2454

2455 2456
    /* QEMU 2.11 for Power renamed all CPU models to lower case, we need to
     * translate them back to libvirt's upper case model names. */
2457
    if (ARCH_IS_PPC64(arch)) {
2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475
        VIR_AUTOSTRINGLIST libvirtModels = NULL;
        char **name;

        if (virCPUGetModels(arch, &libvirtModels) < 0)
            goto error;

        for (name = libvirtModels; name && *name; name++) {
            for (i = 0; i < ncpus; i++) {
                if (STRCASENEQ(cpus[i]->name, *name))
                    continue;

                VIR_FREE(cpus[i]->name);
                if (VIR_STRDUP(cpus[i]->name, *name) < 0)
                    goto error;
            }
        }
    }

2476
    if (!(models = virDomainCapsCPUModelsNew(ncpus)))
2477
        goto error;
2478

2479
    for (i = 0; i < ncpus; i++) {
2480 2481 2482 2483 2484 2485 2486
        virDomainCapsCPUUsable usable = VIR_DOMCAPS_CPU_USABLE_UNKNOWN;

        if (cpus[i]->usable == VIR_TRISTATE_BOOL_YES)
            usable = VIR_DOMCAPS_CPU_USABLE_YES;
        else if (cpus[i]->usable == VIR_TRISTATE_BOOL_NO)
            usable = VIR_DOMCAPS_CPU_USABLE_NO;

2487
        if (virDomainCapsCPUModelsAddSteal(models, &cpus[i]->name, usable,
2488
                                           &cpus[i]->blockers) < 0)
2489
            goto error;
2490 2491 2492 2493 2494 2495
    }

 cleanup:
    for (i = 0; i < ncpus; i++)
        qemuMonitorCPUDefInfoFree(cpus[i]);
    VIR_FREE(cpus);
2496 2497 2498 2499 2500 2501
    return models;

 error:
    virObjectUnref(models);
    models = NULL;
    goto cleanup;
2502 2503
}

2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514

int
virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr qemuCaps,
                                  qemuMonitorPtr mon,
                                  bool tcg)
{
    virDomainCapsCPUModelsPtr models = NULL;

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_DEFINITIONS))
        return 0;

2515
    if (!(models = virQEMUCapsFetchCPUDefinitions(mon, qemuCaps->arch)))
2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526
        return -1;

    if (tcg || !virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
        qemuCaps->tcgCPUModels = models;
    else
        qemuCaps->kvmCPUModels = models;

    return 0;
}


2527 2528
static int
virQEMUCapsProbeQMPHostCPU(virQEMUCapsPtr qemuCaps,
2529 2530
                           qemuMonitorPtr mon,
                           bool tcg)
2531
{
2532
    qemuMonitorCPUModelInfoPtr modelInfo = NULL;
2533 2534
    qemuMonitorCPUModelInfoPtr nonMigratable = NULL;
    virHashTablePtr hash = NULL;
2535
    const char *model;
2536
    virCPUDefPtr cpu;
2537
    qemuMonitorCPUModelExpansionType type;
2538
    virDomainVirtType virtType;
2539
    bool fail_no_props = true;
2540
    int ret = -1;
2541 2542

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION))
2543 2544
        return 0;

2545
    if (tcg || !virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
2546
        virtType = VIR_DOMAIN_VIRT_QEMU;
2547 2548
        model = "max";
    } else {
2549
        virtType = VIR_DOMAIN_VIRT_KVM;
2550 2551 2552
        model = "host";
    }

2553 2554 2555
    if (VIR_ALLOC(cpu) < 0 || VIR_STRDUP(cpu->model, model) < 0)
        goto cleanup;

2556 2557
    /* Some x86_64 features defined in cpu_map.xml use spelling which differ
     * from the one preferred by QEMU. Static expansion would give us only the
2558 2559 2560 2561
     * preferred spelling. With new QEMU we always use the QEMU's canonical
     * names of all features and translate between them and our names. But for
     * older version of QEMU we need to do a full expansion on the result of
     * the initial static expansion to get all variants of feature names.
2562
     */
2563 2564
    if (ARCH_IS_X86(qemuCaps->arch) &&
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CANONICAL_CPU_FEATURES))
2565 2566 2567 2568
        type = QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC_FULL;
    else
        type = QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC;

2569 2570 2571 2572 2573 2574
    /* Older s390 models do not report a feature set */
    if (ARCH_IS_S390(qemuCaps->arch))
        fail_no_props = false;

    if (qemuMonitorGetCPUModelExpansion(mon, type, cpu, true, fail_no_props,
                                        &modelInfo) < 0)
2575
        goto cleanup;
2576 2577

    /* Try to check migratability of each feature. */
2578
    if (modelInfo &&
2579
        qemuMonitorGetCPUModelExpansion(mon, type, cpu, false, fail_no_props,
2580
                                        &nonMigratable) < 0)
2581
        goto cleanup;
2582 2583 2584 2585 2586 2587 2588

    if (nonMigratable) {
        qemuMonitorCPUPropertyPtr prop;
        qemuMonitorCPUPropertyPtr nmProp;
        size_t i;

        if (!(hash = virHashCreate(0, NULL)))
2589
            goto cleanup;
2590

2591 2592
        for (i = 0; i < modelInfo->nprops; i++) {
            prop = modelInfo->props + i;
2593
            if (virHashAddEntry(hash, prop->name, prop) < 0)
2594
                goto cleanup;
2595 2596 2597 2598 2599 2600 2601 2602 2603
        }

        for (i = 0; i < nonMigratable->nprops; i++) {
            nmProp = nonMigratable->props + i;
            if (!(prop = virHashLookup(hash, nmProp->name)) ||
                prop->type != QEMU_MONITOR_CPU_PROPERTY_BOOLEAN ||
                prop->type != nmProp->type)
                continue;

2604
            if (prop->value.boolean) {
2605
                prop->migratable = VIR_TRISTATE_BOOL_YES;
2606 2607 2608 2609
            } else if (nmProp->value.boolean) {
                prop->value.boolean = true;
                prop->migratable = VIR_TRISTATE_BOOL_NO;
            }
2610 2611
        }

2612
        modelInfo->migratability = true;
2613 2614
    }

2615 2616
    virQEMUCapsSetCPUModelInfo(qemuCaps, virtType, modelInfo);
    modelInfo = NULL;
2617 2618 2619 2620 2621
    ret = 0;

 cleanup:
    virHashFree(hash);
    qemuMonitorCPUModelInfoFree(nonMigratable);
2622
    qemuMonitorCPUModelInfoFree(modelInfo);
2623
    virCPUDefFree(cpu);
2624 2625

    return ret;
2626 2627
}

2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641

/**
 * Get NULL terminated list of features supported by QEMU.
 *
 * Returns -1 on error,
 *          0 on success (@features will be NULL if QEMU does not support this),
 *          1 when @features is filled in, but migratability info is not available.
 */
int
virQEMUCapsGetCPUFeatures(virQEMUCapsPtr qemuCaps,
                          virDomainVirtType virtType,
                          bool migratable,
                          char ***features)
{
2642
    qemuMonitorCPUModelInfoPtr modelInfo;
2643 2644 2645 2646 2647 2648
    char **list;
    size_t i;
    size_t n;
    int ret = -1;

    *features = NULL;
2649
    modelInfo = virQEMUCapsGetCPUModelInfo(qemuCaps, virtType);
2650

2651
    if (!modelInfo)
2652 2653
        return 0;

2654
    if (VIR_ALLOC_N(list, modelInfo->nprops + 1) < 0)
2655 2656 2657
        return -1;

    n = 0;
2658 2659
    for (i = 0; i < modelInfo->nprops; i++) {
        qemuMonitorCPUPropertyPtr prop = modelInfo->props + i;
2660 2661 2662 2663

        if (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO)
            continue;

2664 2665
        if (VIR_STRDUP(list[n++],
                       virQEMUCapsCPUFeatureFromQEMU(qemuCaps, prop->name)) < 0)
2666 2667 2668
            goto cleanup;
    }

2669
    *features = g_steal_pointer(&list);
2670
    if (migratable && !modelInfo->migratability)
2671 2672 2673 2674 2675 2676 2677 2678 2679 2680
        ret = 1;
    else
        ret = 0;

 cleanup:
    virStringListFree(list);
    return ret;
}


2681 2682
struct tpmTypeToCaps {
    int type;
2683
    virQEMUCapsFlags caps;
2684 2685 2686 2687 2688 2689 2690
};

static const struct tpmTypeToCaps virQEMUCapsTPMTypesToCaps[] = {
    {
        .type = VIR_DOMAIN_TPM_TYPE_PASSTHROUGH,
        .caps = QEMU_CAPS_DEVICE_TPM_PASSTHROUGH,
    },
2691 2692 2693 2694
    {
        .type = VIR_DOMAIN_TPM_TYPE_EMULATOR,
        .caps = QEMU_CAPS_DEVICE_TPM_EMULATOR,
    },
2695 2696 2697 2698 2699 2700 2701
};

const struct tpmTypeToCaps virQEMUCapsTPMModelsToCaps[] = {
    {
        .type = VIR_DOMAIN_TPM_MODEL_TIS,
        .caps = QEMU_CAPS_DEVICE_TPM_TIS,
    },
2702 2703 2704 2705
    {
        .type = VIR_DOMAIN_TPM_MODEL_CRB,
        .caps = QEMU_CAPS_DEVICE_TPM_CRB,
    },
2706 2707 2708 2709 2710 2711
};

static int
virQEMUCapsProbeQMPTPM(virQEMUCapsPtr qemuCaps,
                       qemuMonitorPtr mon)
{
2712 2713
    int nentries;
    size_t i;
2714
    char **entries = NULL;
S
Stefan Berger 已提交
2715

2716 2717 2718 2719
    if ((nentries = qemuMonitorGetTPMModels(mon, &entries)) < 0)
        return -1;

    if (nentries > 0) {
2720
        for (i = 0; i < G_N_ELEMENTS(virQEMUCapsTPMModelsToCaps); i++) {
2721 2722
            const char *needle = virDomainTPMModelTypeToString(
                virQEMUCapsTPMModelsToCaps[i].type);
2723
            if (virStringListHasString((const char **)entries, needle))
2724 2725 2726 2727
                virQEMUCapsSet(qemuCaps,
                               virQEMUCapsTPMModelsToCaps[i].caps);
        }
    }
2728
    virStringListFree(entries);
2729 2730 2731 2732 2733

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

    if (nentries > 0) {
2734
        for (i = 0; i < G_N_ELEMENTS(virQEMUCapsTPMTypesToCaps); i++) {
2735 2736
            const char *needle = virDomainTPMBackendTypeToString(
                virQEMUCapsTPMTypesToCaps[i].type);
2737
            if (virStringListHasString((const char **)entries, needle))
2738 2739 2740
                virQEMUCapsSet(qemuCaps, virQEMUCapsTPMTypesToCaps[i].caps);
        }
    }
2741
    virStringListFree(entries);
2742 2743 2744 2745

    return 0;
}

2746

2747
static int
2748 2749
virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr qemuCaps,
                            qemuMonitorPtr mon)
2750 2751 2752 2753 2754 2755 2756
{
    bool enabled = false;
    bool present = false;

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

A
Andrea Bolognani 已提交
2757 2758
    if (present && enabled)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM);
2759 2760 2761 2762

    return 0;
}

2763 2764 2765 2766 2767 2768 2769 2770
struct virQEMUCapsCommandLineProps {
    const char *option;
    const char *param;
    int flag;
};

static struct virQEMUCapsCommandLineProps virQEMUCapsCommandLine[] = {
    { "machine", "mem-merge", QEMU_CAPS_MEM_MERGE },
2771
    { "machine", "vmport", QEMU_CAPS_MACHINE_VMPORT_OPT },
O
Osier Yang 已提交
2772
    { "drive", "discard", QEMU_CAPS_DRIVE_DISCARD },
2773
    { "drive", "detect-zeroes", QEMU_CAPS_DRIVE_DETECT_ZEROES },
2774
    { "boot-opts", "strict", QEMU_CAPS_BOOT_STRICT },
2775
    { "boot-opts", "reboot-timeout", QEMU_CAPS_REBOOT_TIMEOUT },
2776
    { "boot-opts", "splash-time", QEMU_CAPS_SPLASH_TIMEOUT },
2777
    { "spice", "disable-agent-file-xfer", QEMU_CAPS_SPICE_FILE_XFER_DISABLE },
2778
    { "msg", "timestamp", QEMU_CAPS_MSG_TIMESTAMP },
2779
    { "numa", NULL, QEMU_CAPS_NUMA },
2780
    { "drive", "throttling.bps-total-max", QEMU_CAPS_DRIVE_IOTUNE_MAX},
2781 2782
    { "machine", "aes-key-wrap", QEMU_CAPS_AES_KEY_WRAP },
    { "machine", "dea-key-wrap", QEMU_CAPS_DEA_KEY_WRAP },
2783
    { "chardev", "append", QEMU_CAPS_CHARDEV_FILE_APPEND },
2784
    { "spice", "gl", QEMU_CAPS_SPICE_GL },
2785
    { "chardev", "logfile", QEMU_CAPS_CHARDEV_LOGFILE },
2786
    { "name", "debug-threads", QEMU_CAPS_NAME_DEBUG_THREADS },
2787
    { "name", "guest", QEMU_CAPS_NAME_GUEST },
2788
    { "spice", "unix", QEMU_CAPS_SPICE_UNIX },
2789
    { "drive", "throttling.bps-total-max-length", QEMU_CAPS_DRIVE_IOTUNE_MAX_LENGTH },
2790
    { "drive", "throttling.group", QEMU_CAPS_DRIVE_IOTUNE_GROUP },
2791
    { "spice", "rendernode", QEMU_CAPS_SPICE_RENDERNODE },
2792
    { "machine", "kernel_irqchip", QEMU_CAPS_MACHINE_KERNEL_IRQCHIP },
2793
    { "machine", "loadparm", QEMU_CAPS_LOADPARM },
2794
    { "vnc", "vnc", QEMU_CAPS_VNC_MULTI_SERVERS },
2795
    { "chardev", "reconnect", QEMU_CAPS_CHARDEV_RECONNECT },
2796
    { "sandbox", "enable", QEMU_CAPS_SECCOMP_SANDBOX },
2797
    { "sandbox", "elevateprivileges", QEMU_CAPS_SECCOMP_BLACKLIST },
2798
    { "chardev", "fd", QEMU_CAPS_CHARDEV_FD_PASS },
2799
    { "overcommit", NULL, QEMU_CAPS_OVERCOMMIT },
2800 2801 2802 2803 2804 2805
};

static int
virQEMUCapsProbeQMPCommandLine(virQEMUCapsPtr qemuCaps,
                               qemuMonitorPtr mon)
{
2806
    bool found = false;
2807 2808 2809 2810
    int nvalues;
    char **values;
    size_t i, j;

2811
    for (i = 0; i < G_N_ELEMENTS(virQEMUCapsCommandLine); i++) {
2812 2813
        if ((nvalues = qemuMonitorGetCommandLineOptionParameters(mon,
                                                                 virQEMUCapsCommandLine[i].option,
2814 2815
                                                                 &values,
                                                                 &found)) < 0)
2816
            return -1;
2817 2818 2819 2820

        if (found && !virQEMUCapsCommandLine[i].param)
            virQEMUCapsSet(qemuCaps, virQEMUCapsCommandLine[i].flag);

2821
        for (j = 0; j < nvalues; j++) {
2822
            if (STREQ_NULLABLE(virQEMUCapsCommandLine[i].param, values[j])) {
2823 2824 2825 2826
                virQEMUCapsSet(qemuCaps, virQEMUCapsCommandLine[i].flag);
                break;
            }
        }
2827
        virStringListFree(values);
2828 2829 2830 2831
    }

    return 0;
}
2832

2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843
static int
virQEMUCapsProbeQMPMigrationCapabilities(virQEMUCapsPtr qemuCaps,
                                         qemuMonitorPtr mon)
{
    char **caps = NULL;
    int ncaps;

    if ((ncaps = qemuMonitorGetMigrationCapabilities(mon, &caps)) < 0)
        return -1;

    virQEMUCapsProcessStringFlags(qemuCaps,
2844
                                  G_N_ELEMENTS(virQEMUCapsMigration),
2845 2846
                                  virQEMUCapsMigration,
                                  ncaps, caps);
2847
    virStringListFreeCount(caps, ncaps);
2848 2849 2850 2851

    return 0;
}

A
Andrea Bolognani 已提交
2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
/**
 * virQEMUCapsProbeQMPGICCapabilities:
 * @qemuCaps: QEMU binary capabilities
 * @mon: QEMU monitor
 *
 * Use @mon to obtain information about the GIC capabilities for the
 * corresponding QEMU binary, and store them in @qemuCaps.
 *
 * Returns: 0 on success, <0 on failure
 */
static int
virQEMUCapsProbeQMPGICCapabilities(virQEMUCapsPtr qemuCaps,
                                   qemuMonitorPtr mon)
{
    virGICCapability *caps = NULL;
    int ncaps;

2869 2870 2871 2872 2873
    if (!(qemuCaps->arch == VIR_ARCH_AARCH64 ||
          qemuCaps->arch == VIR_ARCH_ARMV6L ||
          qemuCaps->arch == VIR_ARCH_ARMV7L))
        return 0;

A
Andrea Bolognani 已提交
2874 2875 2876
    if ((ncaps = qemuMonitorGetGICCapabilities(mon, &caps)) < 0)
        return -1;

2877
    virQEMUCapsSetGICCapabilities(qemuCaps, caps, ncaps);
A
Andrea Bolognani 已提交
2878 2879 2880 2881

    return 0;
}

2882

2883 2884 2885 2886
static int
virQEMUCapsProbeQMPSEVCapabilities(virQEMUCapsPtr qemuCaps,
                                   qemuMonitorPtr mon)
{
2887
    int rc = -1;
2888 2889
    virSEVCapability *caps = NULL;

2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEV_GUEST))
        return 0;

    if ((rc = qemuMonitorGetSEVCapabilities(mon, &caps)) < 0)
        return -1;

    /* SEV isn't actually supported */
    if (rc == 0) {
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_SEV_GUEST);
        return 0;
    }
2901

2902 2903
    virSEVCapabilitiesFree(qemuCaps->sevCapabilities);
    qemuCaps->sevCapabilities = caps;
2904
    return 0;
2905 2906 2907
}


J
Jiri Denemark 已提交
2908 2909 2910 2911 2912
/*
 * Filter for features which should never be passed to QEMU. Either because
 * QEMU never supported them or they were dropped as they never did anything
 * useful.
 */
2913
bool
2914
virQEMUCapsCPUFilterFeatures(const char *name,
2915
                             void *opaque)
2916
{
2917
    virArch *arch = opaque;
2918

2919
    if (!ARCH_IS_X86(*arch))
2920 2921
        return true;

2922 2923
    if (STREQ(name, "cmt") ||
        STREQ(name, "mbm_total") ||
J
Jiri Denemark 已提交
2924 2925 2926
        STREQ(name, "mbm_local") ||
        STREQ(name, "osxsave") ||
        STREQ(name, "ospke"))
2927 2928 2929 2930 2931 2932
        return false;

    return true;
}


2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966
typedef struct _virQEMUCapsCPUFeatureTranslationTable virQEMUCapsCPUFeatureTranslationTable;
typedef virQEMUCapsCPUFeatureTranslationTable *virQEMUCapsCPUFeatureTranslationTablePtr;
struct _virQEMUCapsCPUFeatureTranslationTable {
    const char *libvirt;
    const char *qemu;
};

virQEMUCapsCPUFeatureTranslationTable virQEMUCapsCPUFeaturesX86[] = {
    {"cmp_legacy", "cmp-legacy"},
    {"ds_cpl", "ds-cpl"},
    {"fxsr_opt", "fxsr-opt"},
    {"kvm_pv_eoi", "kvm-pv-eoi"},
    {"kvm_pv_unhalt", "kvm-pv-unhalt"},
    {"lahf_lm", "lahf-lm"},
    {"nodeid_msr", "nodeid-msr"},
    {"pclmuldq", "pclmulqdq"},
    {"perfctr_core", "perfctr-core"},
    {"perfctr_nb", "perfctr-nb"},
    {"tsc_adjust", "tsc-adjust"},
    {NULL, NULL}
};


static const char *
virQEMUCapsCPUFeatureTranslate(virQEMUCapsPtr qemuCaps,
                               const char *feature,
                               bool reversed)
{
    virQEMUCapsCPUFeatureTranslationTablePtr table = NULL;
    virQEMUCapsCPUFeatureTranslationTablePtr entry;

    if (ARCH_IS_X86(qemuCaps->arch))
        table = virQEMUCapsCPUFeaturesX86;

2967 2968 2969
    if (!table ||
        !feature ||
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CANONICAL_CPU_FEATURES))
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
        return feature;

    for (entry = table; entry->libvirt; entry++) {
        const char *key = reversed ? entry->qemu : entry->libvirt;

        if (STREQ(feature, key))
            return reversed ? entry->libvirt : entry->qemu;
    }

    return feature;
}


const char *
virQEMUCapsCPUFeatureToQEMU(virQEMUCapsPtr qemuCaps,
                            const char *feature)
{
    return virQEMUCapsCPUFeatureTranslate(qemuCaps, feature, false);
}


const char *
virQEMUCapsCPUFeatureFromQEMU(virQEMUCapsPtr qemuCaps,
                              const char *feature)
{
    return virQEMUCapsCPUFeatureTranslate(qemuCaps, feature, true);
}


2999 3000 3001
/**
 * Returns  0 when host CPU model provided by QEMU was filled in qemuCaps,
 *          1 when the caller should fall back to using virCapsPtr->host.cpu,
3002
 *          2 when cpu model info is not supported for this configuration,
3003 3004 3005 3006
 *         -1 on error.
 */
static int
virQEMUCapsInitCPUModelS390(virQEMUCapsPtr qemuCaps,
3007
                            virDomainVirtType type,
3008
                            qemuMonitorCPUModelInfoPtr modelInfo,
3009 3010
                            virCPUDefPtr cpu,
                            bool migratable)
3011
{
3012
    size_t i;
3013

3014
    if (!modelInfo) {
3015 3016 3017 3018 3019 3020 3021 3022
        if (type == VIR_DOMAIN_VIRT_KVM) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("missing host CPU model info from QEMU "
                             "capabilities for binary %s"),
                           qemuCaps->binary);
            return -1;
        }
        return 2;
3023
    }
J
Jiri Denemark 已提交
3024

3025 3026
    if (VIR_STRDUP(cpu->model, modelInfo->name) < 0 ||
        VIR_ALLOC_N(cpu->features, modelInfo->nprops) < 0)
3027
        return -1;
3028 3029 3030 3031 3032

    cpu->nfeatures_max = modelInfo->nprops;
    cpu->nfeatures = 0;

    for (i = 0; i < modelInfo->nprops; i++) {
3033 3034
        virCPUFeatureDefPtr feature = cpu->features + cpu->nfeatures;
        qemuMonitorCPUPropertyPtr prop = modelInfo->props + i;
3035
        const char *name = virQEMUCapsCPUFeatureFromQEMU(qemuCaps, prop->name);
3036

3037 3038
        if (prop->type != QEMU_MONITOR_CPU_PROPERTY_BOOLEAN)
            continue;
3039

3040
        if (VIR_STRDUP(feature->name, name) < 0)
3041
            return -1;
3042 3043 3044 3045 3046 3047

        if (!prop->value.boolean ||
            (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO))
            feature->policy = VIR_CPU_FEATURE_DISABLE;
        else
            feature->policy = VIR_CPU_FEATURE_REQUIRE;
3048 3049 3050
        cpu->nfeatures++;
    }

3051 3052
    return 0;
}
3053

3054

3055
virCPUDataPtr
3056 3057
virQEMUCapsGetCPUModelX86Data(virQEMUCapsPtr qemuCaps,
                              qemuMonitorCPUModelInfoPtr model,
3058
                              bool migratable)
3059 3060 3061
{
    unsigned long long sigFamily = 0;
    unsigned long long sigModel = 0;
3062
    unsigned long long sigStepping = 0;
3063 3064
    virCPUDataPtr data = NULL;
    virCPUDataPtr ret = NULL;
3065 3066 3067 3068 3069 3070 3071
    size_t i;

    if (!(data = virCPUDataNew(VIR_ARCH_X86_64)))
        goto cleanup;

    for (i = 0; i < model->nprops; i++) {
        qemuMonitorCPUPropertyPtr prop = model->props + i;
3072
        const char *name = virQEMUCapsCPUFeatureFromQEMU(qemuCaps, prop->name);
3073 3074 3075

        switch (prop->type) {
        case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
3076 3077 3078 3079
            if (!prop->value.boolean ||
                (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO))
                continue;

3080
            if (virCPUDataAddFeature(data, name) < 0)
3081
                goto cleanup;
3082

3083 3084 3085
            break;

        case QEMU_MONITOR_CPU_PROPERTY_STRING:
3086
            if (STREQ(name, "vendor") &&
3087 3088 3089 3090 3091
                virCPUx86DataSetVendor(data, prop->value.string) < 0)
                goto cleanup;
            break;

        case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
3092
            if (STREQ(name, "family"))
3093
                sigFamily = prop->value.number;
3094
            else if (STREQ(name, "model"))
3095
                sigModel = prop->value.number;
3096
            else if (STREQ(name, "stepping"))
3097
                sigStepping = prop->value.number;
3098 3099 3100 3101 3102 3103 3104
            break;

        case QEMU_MONITOR_CPU_PROPERTY_LAST:
            break;
        }
    }

3105
    if (virCPUx86DataSetSignature(data, sigFamily, sigModel, sigStepping) < 0)
3106 3107
        goto cleanup;

3108
    ret = g_steal_pointer(&data);
3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133

 cleanup:
    virCPUDataFree(data);
    return ret;
}


/**
 * Returns  0 when host CPU model provided by QEMU was filled in qemuCaps,
 *          1 when the caller should fall back to using virCapsPtr->host.cpu,
 *         -1 on error.
 */
static int
virQEMUCapsInitCPUModelX86(virQEMUCapsPtr qemuCaps,
                           virDomainVirtType type,
                           qemuMonitorCPUModelInfoPtr model,
                           virCPUDefPtr cpu,
                           bool migratable)
{
    virCPUDataPtr data = NULL;
    int ret = -1;

    if (!model)
        return 1;

3134
    if (!(data = virQEMUCapsGetCPUModelX86Data(qemuCaps, model, migratable)))
3135 3136
        goto cleanup;

3137
    if (cpuDecode(cpu, data, virQEMUCapsGetCPUDefinitions(qemuCaps, type)) < 0)
3138 3139 3140 3141 3142 3143 3144 3145 3146 3147
        goto cleanup;

    ret = 0;

 cleanup:
    virCPUDataFree(data);
    return ret;
}


3148 3149
/**
 * Returns  0 when host CPU model provided by QEMU was filled in qemuCaps,
3150 3151
 *          1 when the caller should fall back to other methods,
 *          2 when cpu model info is not supported for this configuration,
3152 3153
 *         -1 on error.
 */
3154
int
3155
virQEMUCapsInitCPUModel(virQEMUCapsPtr qemuCaps,
3156
                        virDomainVirtType type,
3157 3158
                        virCPUDefPtr cpu,
                        bool migratable)
3159
{
3160
    qemuMonitorCPUModelInfoPtr modelInfo = virQEMUCapsGetCPUModelInfo(qemuCaps, type);
3161 3162
    int ret = 1;

3163
    if (migratable && modelInfo && !modelInfo->migratability)
3164 3165
        return 1;

3166
    if (ARCH_IS_S390(qemuCaps->arch)) {
3167
        ret = virQEMUCapsInitCPUModelS390(qemuCaps, type, modelInfo,
3168 3169
                                          cpu, migratable);
    } else if (ARCH_IS_X86(qemuCaps->arch)) {
3170
        ret = virQEMUCapsInitCPUModelX86(qemuCaps, type, modelInfo,
3171 3172
                                         cpu, migratable);
    }
3173

3174 3175 3176
    if (ret == 0)
        cpu->fallback = VIR_CPU_FALLBACK_FORBID;

3177
    return ret;
3178 3179 3180
}


3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197
static virCPUDefPtr
virQEMUCapsNewHostCPUModel(void)
{
    virCPUDefPtr cpu;

    if (VIR_ALLOC(cpu) < 0)
        return NULL;

    cpu->type = VIR_CPU_TYPE_GUEST;
    cpu->mode = VIR_CPU_MODE_CUSTOM;
    cpu->match = VIR_CPU_MATCH_EXACT;
    cpu->fallback = VIR_CPU_FALLBACK_ALLOW;

    return cpu;
}


3198 3199
void
virQEMUCapsInitHostCPUModel(virQEMUCapsPtr qemuCaps,
3200
                            virArch hostArch,
3201
                            virDomainVirtType type)
3202 3203
{
    virCPUDefPtr cpu = NULL;
3204
    virCPUDefPtr cpuExpanded = NULL;
3205
    virCPUDefPtr migCPU = NULL;
3206
    virCPUDefPtr hostCPU = NULL;
3207 3208
    virCPUDefPtr fullCPU = NULL;
    size_t i;
3209
    int rc;
3210

3211
    if (!virQEMUCapsGuestIsNative(hostArch, qemuCaps->arch))
3212 3213
        return;

3214
    if (!(cpu = virQEMUCapsNewHostCPUModel()))
3215 3216
        goto error;

3217
    if ((rc = virQEMUCapsInitCPUModel(qemuCaps, type, cpu, false)) < 0) {
3218 3219
        goto error;
    } else if (rc == 1) {
3220
        VIR_DEBUG("No host CPU model info from QEMU; probing host CPU directly");
3221

3222 3223
        hostCPU = virQEMUCapsProbeHostCPU(hostArch,
                                          virQEMUCapsGetCPUDefinitions(qemuCaps, type));
3224 3225
        if (!hostCPU ||
            virCPUDefCopyModelFilter(cpu, hostCPU, true,
3226
                                     virQEMUCapsCPUFilterFeatures,
3227
                                     &qemuCaps->arch) < 0)
3228
            goto error;
3229 3230 3231 3232 3233
    } else if (rc == 2) {
        VIR_DEBUG("QEMU does not provide CPU model for arch=%s virttype=%s",
                  virArchToString(qemuCaps->arch),
                  virDomainVirtTypeToString(type));
        goto error;
3234 3235
    } else if (type == VIR_DOMAIN_VIRT_KVM &&
               virCPUGetHostIsSupported(qemuCaps->arch)) {
3236
        if (!(fullCPU = virQEMUCapsProbeHostCPU(qemuCaps->arch, NULL)))
3237 3238
            goto error;

3239 3240 3241 3242 3243 3244 3245
        if (!(cpuExpanded = virCPUDefCopy(cpu)) ||
            virCPUExpandFeatures(qemuCaps->arch, cpuExpanded) < 0)
            goto error;

        for (i = 0; i < cpuExpanded->nfeatures; i++) {
            if (cpuExpanded->features[i].policy == VIR_CPU_FEATURE_REQUIRE &&
                virCPUDefUpdateFeature(fullCPU, cpuExpanded->features[i].name,
3246 3247 3248
                                       VIR_CPU_FEATURE_REQUIRE) < 0)
                goto error;
        }
3249 3250
    }

3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263
    if (!(migCPU = virQEMUCapsNewHostCPUModel()))
        goto error;

    if ((rc = virQEMUCapsInitCPUModel(qemuCaps, type, migCPU, true)) < 0) {
        goto error;
    } else if (rc == 1) {
        VIR_DEBUG("CPU migratability not provided by QEMU");

        virCPUDefFree(migCPU);
        if (!(migCPU = virCPUCopyMigratable(qemuCaps->arch, cpu)))
            goto error;
    }

3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278
    if (ARCH_IS_X86(qemuCaps->arch) &&
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_UNAVAILABLE_FEATURES)) {
        if (cpu &&
            virCPUDefFilterFeatures(cpu, virCPUx86FeatureFilterDropMSR, NULL) < 0)
            goto error;

        if (migCPU &&
            virCPUDefFilterFeatures(migCPU, virCPUx86FeatureFilterDropMSR, NULL) < 0)
            goto error;

        if (fullCPU &&
            virCPUDefFilterFeatures(fullCPU, virCPUx86FeatureFilterDropMSR, NULL) < 0)
            goto error;
    }

3279
    virQEMUCapsSetHostModel(qemuCaps, type, cpu, migCPU, fullCPU);
3280

3281
 cleanup:
3282
    virCPUDefFree(cpuExpanded);
3283
    virCPUDefFree(hostCPU);
3284 3285 3286 3287
    return;

 error:
    virCPUDefFree(cpu);
3288
    virCPUDefFree(migCPU);
3289
    virCPUDefFree(fullCPU);
3290
    virResetLastError();
3291
    goto cleanup;
3292 3293 3294
}


3295 3296 3297 3298 3299 3300 3301 3302 3303 3304
qemuMonitorCPUModelInfoPtr
virQEMUCapsGetCPUModelInfo(virQEMUCapsPtr qemuCaps,
                           virDomainVirtType type)
{
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);

    return cpuData->info;
}


3305 3306 3307 3308 3309
void
virQEMUCapsSetCPUModelInfo(virQEMUCapsPtr qemuCaps,
                           virDomainVirtType type,
                           qemuMonitorCPUModelInfoPtr modelInfo)
{
3310 3311 3312
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);

    cpuData->info = modelInfo;
3313 3314 3315
}


3316 3317
static int
virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsPtr qemuCaps,
3318 3319
                                xmlXPathContextPtr ctxt,
                                virDomainVirtType virtType)
3320 3321 3322
{
    char *str = NULL;
    xmlNodePtr hostCPUNode;
3323
    xmlNodePtr *nodes = NULL;
3324
    VIR_XPATH_NODE_AUTORESTORE(ctxt);
3325 3326 3327 3328
    qemuMonitorCPUModelInfoPtr hostCPU = NULL;
    int ret = -1;
    size_t i;
    int n;
3329
    int val;
3330

3331 3332 3333 3334 3335 3336
    if (virtType == VIR_DOMAIN_VIRT_KVM)
        hostCPUNode = virXPathNode("./hostCPU[@type='kvm']", ctxt);
    else
        hostCPUNode = virXPathNode("./hostCPU[@type='tcg']", ctxt);

    if (!hostCPUNode) {
3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350
        ret = 0;
        goto cleanup;
    }

    if (VIR_ALLOC(hostCPU) < 0)
        goto cleanup;

    if (!(hostCPU->name = virXMLPropString(hostCPUNode, "model"))) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing host CPU model name in QEMU "
                         "capabilities cache"));
        goto cleanup;
    }

3351 3352 3353 3354 3355 3356 3357 3358 3359
    if (!(str = virXMLPropString(hostCPUNode, "migratability")) ||
        (val = virTristateBoolTypeFromString(str)) <= 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("invalid migratability value for host CPU model"));
        goto cleanup;
    }
    hostCPU->migratability = val == VIR_TRISTATE_BOOL_YES;
    VIR_FREE(str);

3360 3361
    ctxt->node = hostCPUNode;

3362
    if ((n = virXPathNodeSet("./property", ctxt, &nodes)) > 0) {
3363 3364 3365 3366 3367 3368
        if (VIR_ALLOC_N(hostCPU->props, n) < 0)
            goto cleanup;

        hostCPU->nprops = n;

        for (i = 0; i < n; i++) {
3369 3370 3371 3372 3373
            qemuMonitorCPUPropertyPtr prop = hostCPU->props + i;

            ctxt->node = nodes[i];

            if (!(prop->name = virXMLPropString(ctxt->node, "name"))) {
3374 3375
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing 'name' attribute for a host CPU"
3376
                                 " model property in QEMU capabilities cache"));
3377 3378 3379
                goto cleanup;
            }

3380
            if (!(str = virXMLPropString(ctxt->node, "type")) ||
3381
                (val = qemuMonitorCPUPropertyTypeFromString(str)) < 0) {
3382
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3383 3384
                               _("missing or invalid CPU model property type "
                                 "in QEMU capabilities cache"));
3385 3386 3387
                goto cleanup;
            }
            VIR_FREE(str);
3388

3389
            prop->type = val;
3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420
            switch (prop->type) {
            case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
                if (virXPathBoolean("./@value='true'", ctxt))
                    prop->value.boolean = true;
                break;

            case QEMU_MONITOR_CPU_PROPERTY_STRING:
                prop->value.string = virXMLPropString(ctxt->node, "value");
                if (!prop->value.string) {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("invalid string value for '%s' host CPU "
                                     "model property in QEMU capabilities cache"),
                                   prop->name);
                    goto cleanup;
                }
                break;

            case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
                if (virXPathLongLong("string(./@value)", ctxt,
                                     &prop->value.number) < 0) {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("invalid number value for '%s' host CPU "
                                     "model property in QEMU capabilities cache"),
                                   prop->name);
                    goto cleanup;
                }
                break;

            case QEMU_MONITOR_CPU_PROPERTY_LAST:
                break;
            }
3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433

            if ((str = virXMLPropString(ctxt->node, "migratable"))) {
                if ((val = virTristateBoolTypeFromString(str)) <= 0) {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("unknown migratable value for '%s' host "
                                     "CPU model property"),
                                   prop->name);
                    goto cleanup;
                }

                prop->migratable = val;
                VIR_FREE(str);
            }
3434 3435 3436
        }
    }

3437
    virQEMUCapsSetCPUModelInfo(qemuCaps, virtType, hostCPU);
3438 3439 3440 3441 3442
    hostCPU = NULL;
    ret = 0;

 cleanup:
    VIR_FREE(str);
3443
    VIR_FREE(nodes);
3444 3445 3446 3447 3448
    qemuMonitorCPUModelInfoFree(hostCPU);
    return ret;
}


3449 3450
static int
virQEMUCapsLoadCPUModels(virQEMUCapsPtr qemuCaps,
3451 3452
                         xmlXPathContextPtr ctxt,
                         virDomainVirtType type)
3453
{
3454
    virDomainCapsCPUModelsPtr cpus = NULL;
3455 3456 3457 3458 3459
    xmlNodePtr *nodes = NULL;
    char *str = NULL;
    size_t i;
    int n;
    int ret = -1;
3460 3461 3462 3463
    xmlNodePtr node;
    xmlNodePtr *blockerNodes = NULL;
    char **blockers = NULL;
    int nblockers;
3464

3465 3466 3467 3468 3469 3470
    if (type == VIR_DOMAIN_VIRT_KVM)
        n = virXPathNodeSet("./cpu[@type='kvm']", ctxt, &nodes);
    else
        n = virXPathNodeSet("./cpu[@type='tcg']", ctxt, &nodes);

    if (n < 0) {
3471 3472 3473 3474 3475 3476 3477 3478 3479 3480
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities cpus"));
        goto cleanup;
    }

    if (n == 0) {
        ret = 0;
        goto cleanup;
    }

3481
    if (!(cpus = virDomainCapsCPUModelsNew(n)))
3482 3483
        goto cleanup;

3484 3485 3486 3487 3488
    if (type == VIR_DOMAIN_VIRT_KVM)
        qemuCaps->kvmCPUModels = cpus;
    else
        qemuCaps->tcgCPUModels = cpus;

3489
    for (i = 0; i < n; i++) {
3490 3491 3492 3493 3494 3495 3496 3497 3498 3499
        int usable = VIR_DOMCAPS_CPU_USABLE_UNKNOWN;

        if ((str = virXMLPropString(nodes[i], "usable")) &&
            (usable = virDomainCapsCPUUsableTypeFromString(str)) < 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unknown value '%s' in attribute 'usable'"), str);
            goto cleanup;
        }
        VIR_FREE(str);

3500 3501 3502 3503 3504 3505
        if (!(str = virXMLPropString(nodes[i], "name"))) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("missing cpu name in QEMU capabilities cache"));
            goto cleanup;
        }

3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530
        node = ctxt->node;
        ctxt->node = nodes[i];
        nblockers = virXPathNodeSet("./blocker", ctxt, &blockerNodes);
        ctxt->node = node;

        if (nblockers < 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("failed to parse CPU blockers in QEMU capabilities"));
            goto cleanup;
        }

        if (nblockers > 0) {
            size_t j;

            if (VIR_ALLOC_N(blockers, nblockers + 1) < 0)
                goto cleanup;

            for (j = 0; j < nblockers; j++) {
                if (!(blockers[j] = virXMLPropString(blockerNodes[j], "name"))) {
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("missing blocker name in QEMU "
                                     "capabilities cache"));
                    goto cleanup;
                }
            }
3531
            VIR_FREE(blockerNodes);
3532 3533 3534
        }

        if (virDomainCapsCPUModelsAddSteal(cpus, &str, usable, &blockers) < 0)
3535 3536 3537 3538 3539 3540 3541 3542
            goto cleanup;
    }

    ret = 0;

 cleanup:
    VIR_FREE(nodes);
    VIR_FREE(str);
3543 3544
    VIR_FREE(blockerNodes);
    virStringListFree(blockers);
3545 3546 3547 3548
    return ret;
}


3549 3550 3551 3552 3553
struct _virQEMUCapsCachePriv {
    char *libDir;
    uid_t runUid;
    gid_t runGid;
    virArch hostArch;
3554
    unsigned int microcodeVersion;
3555
    char *kernelVersion;
3556 3557 3558 3559

    /* cache whether /dev/kvm is usable as runUid:runGuid */
    virTristateBool kvmUsable;
    time_t kvmCtime;
3560 3561 3562 3563 3564
};
typedef struct _virQEMUCapsCachePriv virQEMUCapsCachePriv;
typedef virQEMUCapsCachePriv *virQEMUCapsCachePrivPtr;


3565
static void
3566
virQEMUCapsCachePrivFree(void *privData)
3567
{
3568 3569
    virQEMUCapsCachePrivPtr priv = privData;

3570
    VIR_FREE(priv->libDir);
3571
    VIR_FREE(priv->kernelVersion);
3572 3573 3574 3575
    VIR_FREE(priv);
}


3576 3577 3578
static int
virQEMUCapsParseSEVInfo(virQEMUCapsPtr qemuCaps, xmlXPathContextPtr ctxt)
{
J
Ján Tomko 已提交
3579
    g_autoptr(virSEVCapability) sev = NULL;
3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEV_GUEST))
        return 0;

    if (virXPathBoolean("boolean(./sev)", ctxt) == 0) {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing SEV platform data in QEMU "
                         "capabilities cache"));
        return -1;
    }

    if (VIR_ALLOC(sev) < 0)
        return -1;

    if (virXPathUInt("string(./sev/cbitpos)", ctxt, &sev->cbitpos) < 0) {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing or malformed SEV cbitpos information "
                         "in QEMU capabilities cache"));
        return -1;
    }

    if (virXPathUInt("string(./sev/reducedPhysBits)", ctxt,
                     &sev->reduced_phys_bits) < 0) {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing or malformed SEV reducedPhysBits information "
                         "in QEMU capabilities cache"));
        return -1;
    }

    if (!(sev->pdh = virXPathString("string(./sev/pdh)", ctxt)))  {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing SEV pdh information "
                         "in QEMU capabilities cache"));
        return -1;
    }

    if (!(sev->cert_chain = virXPathString("string(./sev/certChain)", ctxt))) {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing SEV certChain information "
                         "in QEMU capabilities cache"));
        return -1;
    }

3623
    qemuCaps->sevCapabilities = g_steal_pointer(&sev);
3624 3625 3626 3627
    return 0;
}


3628 3629 3630 3631 3632 3633
/*
 * Parsing a doc that looks like
 *
 * <qemuCaps>
 *   <qemuctime>234235253</qemuctime>
 *   <selfctime>234235253</selfctime>
3634
 *   <selfvers>1002016</selfvers>
3635 3636 3637 3638 3639
 *   <flag name='foo'/>
 *   <flag name='bar'/>
 *   ...
 *   <cpu name="pentium3"/>
 *   ...
3640
 *   <machine name="pc-1.0" alias="pc" hotplugCpus='yes' maxCpus="4" default="yes"/>
3641 3642 3643
 *   ...
 * </qemuCaps>
 */
3644
int
3645
virQEMUCapsLoadCache(virArch hostArch,
3646
                     virQEMUCapsPtr qemuCaps,
3647
                     const char *filename)
3648 3649 3650 3651 3652 3653 3654
{
    xmlDocPtr doc = NULL;
    int ret = -1;
    size_t i;
    int n;
    xmlNodePtr *nodes = NULL;
    xmlXPathContextPtr ctxt = NULL;
J
Ján Tomko 已提交
3655
    char *str = NULL;
3656
    long long int l;
3657
    unsigned long lu;
3658 3659 3660 3661

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

3662
    if (!(ctxt = virXMLXPathContextNew(doc)))
3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679
        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;
    }
3680
    qemuCaps->ctime = (time_t)l;
3681 3682 3683 3684 3685 3686

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

3689
    qemuCaps->libvirtVersion = 0;
3690
    if (virXPathULong("string(./selfvers)", ctxt, &lu) == 0)
3691
        qemuCaps->libvirtVersion = lu;
3692

3693 3694 3695 3696 3697 3698
    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);
3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710
    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;
3711
        }
3712 3713
        VIR_FREE(str);
        virQEMUCapsSet(qemuCaps, flag);
3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728
    }
    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;
    }

3729 3730 3731 3732 3733 3734 3735
    if (virXPathUInt("string(./microcodeVersion)", ctxt,
                     &qemuCaps->microcodeVersion) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing microcode version in QEMU capabilities cache"));
        goto cleanup;
    }

3736 3737
    if (virXPathBoolean("boolean(./package)", ctxt) > 0) {
        qemuCaps->package = virXPathString("string(./package)", ctxt);
3738 3739
        if (!qemuCaps->package)
            qemuCaps->package = g_strdup("");
3740
    }
3741

3742 3743 3744 3745 3746 3747
    if (virXPathBoolean("boolean(./kernelVersion)", ctxt) > 0) {
        qemuCaps->kernelVersion = virXPathString("string(./kernelVersion)", ctxt);
        if (!qemuCaps->kernelVersion)
            goto cleanup;
    }

3748 3749 3750 3751 3752 3753 3754 3755 3756 3757
    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 已提交
3758
    VIR_FREE(str);
3759

3760 3761
    if (virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
        virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
3762 3763
        goto cleanup;

3764 3765
    if (virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
        virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
3766 3767 3768 3769 3770 3771 3772 3773 3774
        goto cleanup;

    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;
3775
        if (VIR_ALLOC_N(qemuCaps->machineTypes, qemuCaps->nmachineTypes) < 0)
3776 3777 3778
            goto cleanup;

        for (i = 0; i < n; i++) {
3779
            if (!(qemuCaps->machineTypes[i].name = virXMLPropString(nodes[i], "name"))) {
3780 3781 3782 3783
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing machine name in QEMU capabilities cache"));
                goto cleanup;
            }
3784
            qemuCaps->machineTypes[i].alias = virXMLPropString(nodes[i], "alias");
3785 3786 3787

            str = virXMLPropString(nodes[i], "maxCpus");
            if (str &&
3788
                virStrToLong_ui(str, NULL, 10, &(qemuCaps->machineTypes[i].maxCpus)) < 0) {
3789 3790 3791 3792
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed machine cpu count in QEMU capabilities cache"));
                goto cleanup;
            }
J
Ján Tomko 已提交
3793
            VIR_FREE(str);
3794 3795 3796 3797 3798

            str = virXMLPropString(nodes[i], "hotplugCpus");
            if (STREQ_NULLABLE(str, "yes"))
                qemuCaps->machineTypes[i].hotplugCpus = true;
            VIR_FREE(str);
3799 3800 3801 3802 3803

            str = virXMLPropString(nodes[i], "default");
            if (STREQ_NULLABLE(str, "yes"))
                qemuCaps->machineTypes[i].qemuDefault = true;
            VIR_FREE(str);
3804 3805 3806 3807
        }
    }
    VIR_FREE(nodes);

A
Andrea Bolognani 已提交
3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873
    if ((n = virXPathNodeSet("./gic", ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities gic"));
        goto cleanup;
    }
    if (n > 0) {
        unsigned int uintValue;
        bool boolValue;

        qemuCaps->ngicCapabilities = n;
        if (VIR_ALLOC_N(qemuCaps->gicCapabilities, n) < 0)
            goto cleanup;

        for (i = 0; i < n; i++) {
            virGICCapabilityPtr cap = &qemuCaps->gicCapabilities[i];

            if (!(str = virXMLPropString(nodes[i], "version"))) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing GIC version "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (virStrToLong_ui(str, NULL, 10, &uintValue) < 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed GIC version "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            cap->version = uintValue;
            VIR_FREE(str);

            if (!(str = virXMLPropString(nodes[i], "kernel"))) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing in-kernel GIC information "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (!(boolValue = STREQ(str, "yes")) && STRNEQ(str, "no")) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed in-kernel GIC information "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (boolValue)
                cap->implementation |= VIR_GIC_IMPLEMENTATION_KERNEL;
            VIR_FREE(str);

            if (!(str = virXMLPropString(nodes[i], "emulated"))) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing emulated GIC information "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (!(boolValue = STREQ(str, "yes")) && STRNEQ(str, "no")) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed emulated GIC information "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (boolValue)
                cap->implementation |= VIR_GIC_IMPLEMENTATION_EMULATED;
            VIR_FREE(str);
        }
    }
    VIR_FREE(nodes);

3874 3875 3876
    if (virQEMUCapsParseSEVInfo(qemuCaps, ctxt) < 0)
        goto cleanup;

3877 3878
    virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
    virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);
3879

3880 3881 3882
    if (virXPathBoolean("boolean(./kvmSupportsNesting)", ctxt) > 0)
        qemuCaps->kvmSupportsNesting = true;

3883
    ret = 0;
3884
 cleanup:
J
Ján Tomko 已提交
3885
    VIR_FREE(str);
3886 3887 3888 3889 3890 3891 3892
    VIR_FREE(nodes);
    xmlXPathFreeContext(ctxt);
    xmlFreeDoc(doc);
    return ret;
}


3893 3894
static void
virQEMUCapsFormatHostCPUModelInfo(virQEMUCapsPtr qemuCaps,
3895 3896
                                  virBufferPtr buf,
                                  virDomainVirtType type)
3897
{
3898
    qemuMonitorCPUModelInfoPtr model = virQEMUCapsGetCPUModelInfo(qemuCaps, type);
3899
    const char *typeStr = type == VIR_DOMAIN_VIRT_KVM ? "kvm" : "tcg";
3900 3901
    size_t i;

3902 3903 3904
    if (!model)
        return;

3905 3906 3907 3908
    virBufferAsprintf(buf,
                      "<hostCPU type='%s' model='%s' migratability='%s'>\n",
                      typeStr, model->name,
                      model->migratability ? "yes" : "no");
3909 3910 3911
    virBufferAdjustIndent(buf, 2);

    for (i = 0; i < model->nprops; i++) {
3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934
        qemuMonitorCPUPropertyPtr prop = model->props + i;

        virBufferAsprintf(buf, "<property name='%s' type='%s' ",
                          prop->name,
                          qemuMonitorCPUPropertyTypeToString(prop->type));

        switch (prop->type) {
        case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
            virBufferAsprintf(buf, "value='%s'",
                              prop->value.boolean ? "true" : "false");
            break;

        case QEMU_MONITOR_CPU_PROPERTY_STRING:
            virBufferEscapeString(buf, "value='%s'", prop->value.string);
            break;

        case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
            virBufferAsprintf(buf, "value='%lld'", prop->value.number);
            break;

        case QEMU_MONITOR_CPU_PROPERTY_LAST:
            break;
        }
3935 3936 3937 3938 3939

        if (prop->migratable > 0)
            virBufferAsprintf(buf, " migratable='%s'",
                              virTristateBoolTypeToString(prop->migratable));

3940
        virBufferAddLit(buf, "/>\n");
3941 3942 3943 3944 3945 3946 3947
    }

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


3948 3949
static void
virQEMUCapsFormatCPUModels(virQEMUCapsPtr qemuCaps,
3950 3951
                           virBufferPtr buf,
                           virDomainVirtType type)
3952
{
3953 3954
    virDomainCapsCPUModelsPtr cpus;
    const char *typeStr;
3955 3956
    size_t i;

3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968
    if (type == VIR_DOMAIN_VIRT_KVM) {
        typeStr = "kvm";
        cpus = qemuCaps->kvmCPUModels;
    } else {
        typeStr = "tcg";
        cpus = qemuCaps->tcgCPUModels;
    }

    if (!cpus)
        return;

    for (i = 0; i < cpus->nmodels; i++) {
3969 3970
        virDomainCapsCPUModelPtr cpu = cpus->models + i;

3971
        virBufferAsprintf(buf, "<cpu type='%s' ", typeStr);
3972 3973 3974 3975 3976
        virBufferEscapeString(buf, "name='%s'", cpu->name);
        if (cpu->usable) {
            virBufferAsprintf(buf, " usable='%s'",
                              virDomainCapsCPUUsableTypeToString(cpu->usable));
        }
3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991

        if (cpu->blockers) {
            size_t j;

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

            for (j = 0; cpu->blockers[j]; j++)
                virBufferAsprintf(buf, "<blocker name='%s'/>\n", cpu->blockers[j]);

            virBufferAdjustIndent(buf, -2);
            virBufferAddLit(buf, "</cpu>\n");
        } else {
            virBufferAddLit(buf, "/>\n");
        }
3992 3993 3994 3995
    }
}


3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013
static void
virQEMUCapsFormatSEVInfo(virQEMUCapsPtr qemuCaps, virBufferPtr buf)
{
    virSEVCapabilityPtr sev = virQEMUCapsGetSEVCapabilities(qemuCaps);

    virBufferAddLit(buf, "<sev>\n");
    virBufferAdjustIndent(buf, 2);
    virBufferAsprintf(buf, "<cbitpos>%u</cbitpos>\n", sev->cbitpos);
    virBufferAsprintf(buf, "<reducedPhysBits>%u</reducedPhysBits>\n",
                      sev->reduced_phys_bits);
    virBufferEscapeString(buf, "<pdh>%s</pdh>\n", sev->pdh);
    virBufferEscapeString(buf, "<certChain>%s</certChain>\n",
                          sev->cert_chain);
    virBufferAdjustIndent(buf, -2);
    virBufferAddLit(buf, "</sev>\n");
}


4014
char *
4015
virQEMUCapsFormatCache(virQEMUCapsPtr qemuCaps)
4016 4017
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
4018
    char *ret = NULL;
4019 4020 4021
    size_t i;

    virBufferAddLit(&buf, "<qemuCaps>\n");
4022
    virBufferAdjustIndent(&buf, 2);
4023

4024
    virBufferAsprintf(&buf, "<qemuctime>%llu</qemuctime>\n",
4025
                      (long long)qemuCaps->ctime);
4026
    virBufferAsprintf(&buf, "<selfctime>%llu</selfctime>\n",
4027
                      (long long)qemuCaps->libvirtCtime);
4028
    virBufferAsprintf(&buf, "<selfvers>%lu</selfvers>\n",
4029
                      (unsigned long)qemuCaps->libvirtVersion);
4030 4031 4032

    for (i = 0; i < QEMU_CAPS_LAST; i++) {
        if (virQEMUCapsGet(qemuCaps, i)) {
4033
            virBufferAsprintf(&buf, "<flag name='%s'/>\n",
4034 4035 4036 4037
                              virQEMUCapsTypeToString(i));
        }
    }

4038
    virBufferAsprintf(&buf, "<version>%d</version>\n",
4039 4040
                      qemuCaps->version);

4041
    virBufferAsprintf(&buf, "<kvmVersion>%d</kvmVersion>\n",
4042 4043
                      qemuCaps->kvmVersion);

4044 4045 4046
    virBufferAsprintf(&buf, "<microcodeVersion>%u</microcodeVersion>\n",
                      qemuCaps->microcodeVersion);

4047 4048 4049 4050
    if (qemuCaps->package)
        virBufferAsprintf(&buf, "<package>%s</package>\n",
                          qemuCaps->package);

4051 4052 4053 4054
    if (qemuCaps->kernelVersion)
        virBufferAsprintf(&buf, "<kernelVersion>%s</kernelVersion>\n",
                          qemuCaps->kernelVersion);

4055
    virBufferAsprintf(&buf, "<arch>%s</arch>\n",
4056 4057
                      virArchToString(qemuCaps->arch));

4058 4059
    virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
    virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);
4060

4061 4062
    virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
    virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);
4063 4064

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
4065
        virBufferEscapeString(&buf, "<machine name='%s'",
4066 4067
                              qemuCaps->machineTypes[i].name);
        if (qemuCaps->machineTypes[i].alias)
4068
            virBufferEscapeString(&buf, " alias='%s'",
4069
                              qemuCaps->machineTypes[i].alias);
4070 4071
        if (qemuCaps->machineTypes[i].hotplugCpus)
            virBufferAddLit(&buf, " hotplugCpus='yes'");
4072
        virBufferAsprintf(&buf, " maxCpus='%u'",
4073
                          qemuCaps->machineTypes[i].maxCpus);
4074 4075 4076
        if (qemuCaps->machineTypes[i].qemuDefault)
            virBufferAddLit(&buf, " default='yes'");
        virBufferAddLit(&buf, "/>\n");
4077 4078
    }

A
Andrea Bolognani 已提交
4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094
    for (i = 0; i < qemuCaps->ngicCapabilities; i++) {
        virGICCapabilityPtr cap;
        bool kernel;
        bool emulated;

        cap = &qemuCaps->gicCapabilities[i];
        kernel = (cap->implementation & VIR_GIC_IMPLEMENTATION_KERNEL);
        emulated = (cap->implementation & VIR_GIC_IMPLEMENTATION_EMULATED);

        virBufferAsprintf(&buf,
                          "<gic version='%d' kernel='%s' emulated='%s'/>\n",
                          cap->version,
                          kernel ? "yes" : "no",
                          emulated ? "yes" : "no");
    }

4095 4096 4097
    if (qemuCaps->sevCapabilities)
        virQEMUCapsFormatSEVInfo(qemuCaps, &buf);

4098 4099 4100
    if (qemuCaps->kvmSupportsNesting)
        virBufferAddLit(&buf, "<kvmSupportsNesting/>\n");

4101
    virBufferAdjustIndent(&buf, -2);
4102 4103
    virBufferAddLit(&buf, "</qemuCaps>\n");

4104 4105 4106 4107 4108 4109 4110 4111
    if (virBufferCheckError(&buf) == 0)
        ret = virBufferContentAndReset(&buf);

    return ret;
}


static int
4112 4113
virQEMUCapsSaveFile(void *data,
                    const char *filename,
J
Ján Tomko 已提交
4114
                    void *privData G_GNUC_UNUSED)
4115
{
4116
    virQEMUCapsPtr qemuCaps = data;
4117 4118
    char *xml = NULL;
    int ret = -1;
4119

4120
    xml = virQEMUCapsFormatCache(qemuCaps);
4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131

    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,
4132
              (long long)qemuCaps->libvirtCtime);
4133 4134 4135 4136 4137 4138 4139 4140

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


4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152
/* Check the kernel module parameters 'nested' file to determine if enabled
 *
 *   Intel: 'kvm_intel' uses 'Y'
 *   AMD:   'kvm_amd' uses '1'
 *   PPC64: 'kvm_hv' uses 'Y'
 *   S390:  'kvm' uses '1'
 */
static bool
virQEMUCapsKVMSupportsNesting(void)
{
    static char const * const kmod[] = {"kvm_intel", "kvm_amd",
                                        "kvm_hv", "kvm"};
4153
    g_autofree char *value = NULL;
4154 4155 4156
    int rc;
    size_t i;

4157
    for (i = 0; i < G_N_ELEMENTS(kmod); i++) {
4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175
        VIR_FREE(value);
        rc = virFileReadValueString(&value, "/sys/module/%s/parameters/nested",
                                    kmod[i]);
        if (rc == -2)
            continue;
        if (rc < 0) {
            virResetLastError();
            return false;
        }

        if (value[0] == 'Y' || value[0] == 'y' || value[0] == '1')
            return true;
    }

    return false;
}


4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223
/* Determine whether '/dev/kvm' is usable as QEMU user:QEMU group. */
static bool
virQEMUCapsKVMUsable(virQEMUCapsCachePrivPtr priv)
{
    struct stat sb;
    static const char *kvm_device = "/dev/kvm";
    virTristateBool value;
    virTristateBool cached_value = priv->kvmUsable;
    time_t kvm_ctime;
    time_t cached_kvm_ctime = priv->kvmCtime;

    if (stat(kvm_device, &sb) < 0) {
        if (errno != ENOENT) {
            virReportSystemError(errno,
                                 _("Failed to stat %s"), kvm_device);
        }
        return false;
    }
    kvm_ctime = sb.st_ctime;

    if (kvm_ctime != cached_kvm_ctime) {
        VIR_DEBUG("%s has changed (%lld vs %lld)", kvm_device,
                  (long long)kvm_ctime, (long long)cached_kvm_ctime);
        cached_value = VIR_TRISTATE_BOOL_ABSENT;
    }

    if (cached_value != VIR_TRISTATE_BOOL_ABSENT)
        return cached_value == VIR_TRISTATE_BOOL_YES;

    if (virFileAccessibleAs(kvm_device, R_OK | W_OK,
                            priv->runUid, priv->runGid) == 0) {
        value = VIR_TRISTATE_BOOL_YES;
    } else {
        value = VIR_TRISTATE_BOOL_NO;
    }

    /* There is a race window between 'stat' and
     * 'virFileAccessibleAs'. However, since we're only interested in
     * detecting changes *after* the virFileAccessibleAs check, we can
     * neglect this here.
     */
    priv->kvmCtime = kvm_ctime;
    priv->kvmUsable = value;

    return value == VIR_TRISTATE_BOOL_YES;
}


4224
static bool
4225 4226
virQEMUCapsIsValid(void *data,
                   void *privData)
4227
{
4228 4229
    virQEMUCapsPtr qemuCaps = data;
    virQEMUCapsCachePrivPtr priv = privData;
4230
    bool kvmUsable;
4231
    struct stat sb;
4232
    bool kvmSupportsNesting;
4233 4234 4235 4236

    if (!qemuCaps->binary)
        return true;

4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248
    if (qemuCaps->libvirtCtime != virGetSelfLastChanged() ||
        qemuCaps->libvirtVersion != LIBVIR_VERSION_NUMBER) {
        VIR_DEBUG("Outdated capabilities for '%s': libvirt changed "
                  "(%lld vs %lld, %lu vs %lu)",
                  qemuCaps->binary,
                  (long long)qemuCaps->libvirtCtime,
                  (long long)virGetSelfLastChanged(),
                  (unsigned long)qemuCaps->libvirtVersion,
                  (unsigned long)LIBVIR_VERSION_NUMBER);
        return false;
    }

4249 4250 4251 4252 4253 4254
    if (stat(qemuCaps->binary, &sb) < 0) {
        char ebuf[1024];
        VIR_DEBUG("Failed to stat QEMU binary '%s': %s",
                  qemuCaps->binary,
                  virStrerror(errno, ebuf, sizeof(ebuf)));
        return false;
4255 4256
    }

4257
    if (sb.st_ctime != qemuCaps->ctime) {
4258 4259 4260
        VIR_DEBUG("Outdated capabilities for '%s': QEMU binary changed "
                  "(%lld vs %lld)",
                  qemuCaps->binary,
4261
                  (long long)sb.st_ctime, (long long)qemuCaps->ctime);
4262 4263 4264
        return false;
    }

4265 4266 4267 4268 4269 4270 4271 4272
    if (!virQEMUCapsGuestIsNative(priv->hostArch, qemuCaps->arch)) {
        VIR_DEBUG("Guest arch (%s) is not native to host arch (%s), "
                  "skipping KVM-related checks",
                  virArchToString(qemuCaps->arch),
                  virArchToString(priv->hostArch));
        return true;
    }

4273
    kvmUsable = virQEMUCapsKVMUsable(priv);
4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
        kvmUsable) {
        VIR_DEBUG("KVM was not enabled when probing '%s', "
                  "but it should be usable now",
                  qemuCaps->binary);
        return false;
    }

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
        !kvmUsable) {
        VIR_DEBUG("KVM was enabled when probing '%s', "
                  "but it is not available now",
                  qemuCaps->binary);
        return false;
    }

4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
        if (priv->microcodeVersion != qemuCaps->microcodeVersion) {
            VIR_DEBUG("Outdated capabilities for '%s': microcode version "
                      "changed (%u vs %u)",
                      qemuCaps->binary,
                      priv->microcodeVersion,
                      qemuCaps->microcodeVersion);
            return false;
        }

        if (STRNEQ_NULLABLE(priv->kernelVersion, qemuCaps->kernelVersion)) {
            VIR_DEBUG("Outdated capabilities for '%s': kernel version changed "
                      "('%s' vs '%s')",
                      qemuCaps->binary,
                      priv->kernelVersion,
                      qemuCaps->kernelVersion);
            return false;
        }
4309 4310 4311 4312 4313 4314 4315 4316

        kvmSupportsNesting = virQEMUCapsKVMSupportsNesting();
        if (kvmSupportsNesting != qemuCaps->kvmSupportsNesting) {
            VIR_DEBUG("Outdated capabilities for '%s': kvm kernel nested "
                      "value changed from %d",
                     qemuCaps->binary, qemuCaps->kvmSupportsNesting);
            return false;
        }
4317 4318
    }

4319 4320 4321 4322
    return true;
}


4323 4324 4325 4326 4327 4328 4329 4330
/**
 * virQEMUCapsInitQMPArch:
 * @qemuCaps: QEMU capabilities
 * @mon: QEMU monitor
 *
 * Initialize the architecture for @qemuCaps by asking @mon.
 *
 * Returns: 0 on success, <0 on failure
4331 4332
 */
static int
4333
virQEMUCapsInitQMPArch(virQEMUCapsPtr qemuCaps,
4334 4335 4336 4337 4338 4339
                            qemuMonitorPtr mon)
{
    char *archstr = NULL;
    int ret = -1;

    if (!(archstr = qemuMonitorGetTargetArch(mon)))
4340
        goto cleanup;
4341 4342 4343 4344 4345 4346 4347

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

4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361
    ret = 0;

 cleanup:
    VIR_FREE(archstr);
    return ret;
}


/**
 * virQEMUCapsInitQMPBasicArch:
 * @qemuCaps: QEMU capabilities
 *
 * Initialize @qemuCaps with basic architecture-dependent capabilities.
 */
4362
void
4363 4364
virQEMUCapsInitQMPBasicArch(virQEMUCapsPtr qemuCaps)
{
4365 4366 4367
    /* ACPI only works on x86 and aarch64 */
    if (ARCH_IS_X86(qemuCaps->arch) ||
        qemuCaps->arch == VIR_ARCH_AARCH64) {
4368
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
4369 4370
    }

J
Ján Tomko 已提交
4371 4372
    /* HPET is x86 specific */
    if (ARCH_IS_X86(qemuCaps->arch))
J
Ján Tomko 已提交
4373
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET);
4374
}
4375

4376

4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443
/**
 * virQEMUCapsInitQMPVersionCaps:
 * @qemuCaps: QEMU capabilities
 *
 * Add all QEMU capabilities based on version of QEMU.
 */
static void
virQEMUCapsInitQMPVersionCaps(virQEMUCapsPtr qemuCaps)
{
    if (qemuCaps->version >= 1006000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);

    /* vmport option is supported v2.2.0 onwards */
    if (qemuCaps->version >= 2002000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_VMPORT_OPT);

    /* -cpu ...,aarch64=off supported in v2.3.0 and onwards. But it
       isn't detectable via qmp at this point */
    if (qemuCaps->arch == VIR_ARCH_AARCH64 &&
        qemuCaps->version >= 2003000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_AARCH64_OFF);

    /* vhost-user supports multi-queue from v2.4.0 onwards,
     * but there is no way to query for that capability */
    if (qemuCaps->version >= 2004000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOSTUSER_MULTIQUEUE);

    /* smm option is supported from v2.4.0 */
    if (qemuCaps->version >= 2004000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_SMM_OPT);

    /* sdl -gl option is supported from v2.4.0 (qemu commit id 0b71a5d5) */
    if (qemuCaps->version >= 2004000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL_GL);

    /* Since 2.4.50 ARM virt machine supports gic-version option */
    if (qemuCaps->version >= 2004050)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACH_VIRT_GIC_VERSION);

    /* no way to query if -machine kernel_irqchip supports split */
    if (qemuCaps->version >= 2006000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_KERNEL_IRQCHIP_SPLIT);

    /* HPT resizing is supported since QEMU 2.10 on ppc64; unfortunately
     * there's no sane way to probe for it */
    if (qemuCaps->version >= 2010000 &&
        ARCH_IS_PPC64(qemuCaps->arch)) {
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);
    }

    /* '-display egl-headless' cmdline option is supported since QEMU 2.10, but
     * there's no way to probe it */
    if (qemuCaps->version >= 2010000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_EGL_HEADLESS);

    /* no way to query for -numa dist */
    if (qemuCaps->version >= 2010000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NUMA_DIST);

    /* no way to query max-cpu-compat */
    if (qemuCaps->version >= 2010000 &&
        ARCH_IS_PPC64(qemuCaps->arch)) {
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_PSERIES_MAX_CPU_COMPAT);
    }
}


4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489
/**
 * virQEMUCapsInitProcessCaps:
 * @qemuCaps: QEMU capabilities
 *
 * Some capability bits are enabled or disabled according to specific logic.
 * This function collects all capability processing after the capabilities
 * are detected.
 */
static void
virQEMUCapsInitProcessCaps(virQEMUCapsPtr qemuCaps)
{
    /* 'intel-iommu' shows up as a device since 2.2.0, but can
     * not be used with -device until 2.7.0. Before that it
     * requires -machine iommu=on. So we must clear the device
     * capability we detected on older QEMUs
     */
    if (qemuCaps->version < 2007000 &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_INTEL_IOMMU)) {
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_INTEL_IOMMU);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_IOMMU);
    }

    /* Prealloc on NVDIMMs is broken on older QEMUs leading to
     * user data corruption. If we are dealing with such version
     * of QEMU pretend we don't know how to NVDIMM. */
    if (qemuCaps->version < 2009000 &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_NVDIMM))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_NVDIMM);

    if (ARCH_IS_X86(qemuCaps->arch) &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_CACHE);

    if (ARCH_IS_S390(qemuCaps->arch)) {
        /* Legacy assurance for QEMU_CAPS_CCW */
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCW) &&
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_CCW))
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_CCW);
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCW_CSSID_UNRESTRICTED))
            virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_VFIO_CCW);
    }

    /* To avoid guest ABI regression, blockdev shall be enabled only when
     * we are able to pass the custom 'device_id' for SCSI disks and cdroms. */
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_DEVICE_ID))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_BLOCKDEV);
4490 4491 4492

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_UNAVAILABLE_FEATURES))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CANONICAL_CPU_FEATURES);
4493 4494 4495
}


4496 4497 4498 4499 4500
static int
virQEMUCapsProbeQMPSchemaCapabilities(virQEMUCapsPtr qemuCaps,
                                      qemuMonitorPtr mon)
{
    struct virQEMUCapsStringFlags *entry;
4501 4502
    virJSONValuePtr schemareply;
    virHashTablePtr schema = NULL;
4503 4504
    size_t i;

4505 4506 4507
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_QMP_SCHEMA))
        return 0;

4508
    if (!(schemareply = qemuMonitorQueryQMPSchema(mon)))
4509 4510
        return -1;

4511 4512 4513 4514
    if (!(schema = virQEMUQAPISchemaConvert(schemareply)))
        return -1;
    schemareply = NULL;

4515
    for (i = 0; i < G_N_ELEMENTS(virQEMUCapsQMPSchemaQueries); i++) {
4516 4517
        entry = virQEMUCapsQMPSchemaQueries + i;

4518
        if (virQEMUQAPISchemaPathExists(entry->value, schema))
4519 4520 4521
            virQEMUCapsSet(qemuCaps, entry->flag);
    }

4522
    /* probe also for basic event support */
4523
    for (i = 0; i < G_N_ELEMENTS(virQEMUCapsEvents); i++) {
4524 4525 4526 4527 4528 4529
        entry = virQEMUCapsEvents + i;

        if (virQEMUQAPISchemaPathExists(entry->value, schema))
            virQEMUCapsSet(qemuCaps, entry->flag);
    }

4530 4531 4532 4533
    virHashFree(schema);
    return 0;
}

J
Ján Tomko 已提交
4534
#define QEMU_MIN_MAJOR 1
J
Ján Tomko 已提交
4535
#define QEMU_MIN_MINOR 5
J
Ján Tomko 已提交
4536
#define QEMU_MIN_MICRO 0
4537

4538 4539 4540 4541 4542
int
virQEMUCapsInitQMPMonitor(virQEMUCapsPtr qemuCaps,
                          qemuMonitorPtr mon)
{
    int major, minor, micro;
4543
    g_autofree char *package = NULL;
4544 4545 4546

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

4547
    if (qemuMonitorGetVersion(mon, &major, &minor, &micro, &package) < 0)
4548
        return -1;
4549 4550 4551 4552

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

J
Ján Tomko 已提交
4553 4554 4555 4556 4557 4558
    if (major < QEMU_MIN_MAJOR ||
        (major == QEMU_MIN_MAJOR && minor < QEMU_MIN_MINOR)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("QEMU version >= %d.%d.%d is required, but %d.%d.%d found"),
                       QEMU_MIN_MAJOR, QEMU_MIN_MINOR, QEMU_MIN_MICRO,
                       major, minor, micro);
4559
        return -1;
4560 4561 4562
    }

    qemuCaps->version = major * 1000000 + minor * 1000 + micro;
4563
    qemuCaps->package = g_steal_pointer(&package);
4564 4565
    qemuCaps->usedQMP = true;

4566
    if (virQEMUCapsInitQMPArch(qemuCaps, mon) < 0)
4567
        return -1;
4568

4569 4570
    virQEMUCapsInitQMPBasicArch(qemuCaps);

4571 4572
    /* initiate all capapbilities based on qemu version */
    virQEMUCapsInitQMPVersionCaps(qemuCaps);
4573

4574
    if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0)
4575
        return -1;
J
Jiri Denemark 已提交
4576 4577 4578

    /* Some capabilities may differ depending on KVM state */
    if (virQEMUCapsProbeQMPKVMState(qemuCaps, mon) < 0)
4579
        return -1;
J
Jiri Denemark 已提交
4580

4581
    if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0)
4582
        return -1;
4583
    if (virQEMUCapsProbeQMPDevices(qemuCaps, mon) < 0)
4584
        return -1;
4585
    if (virQEMUCapsProbeQMPMachineTypes(qemuCaps, mon) < 0)
4586
        return -1;
4587 4588
    if (virQEMUCapsProbeQMPMachineProps(qemuCaps, mon) < 0)
        return -1;
4589
    if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, mon, false) < 0)
4590
        return -1;
4591
    if (virQEMUCapsProbeQMPTPM(qemuCaps, mon) < 0)
4592
        return -1;
4593
    if (virQEMUCapsProbeQMPCommandLine(qemuCaps, mon) < 0)
4594
        return -1;
4595
    if (virQEMUCapsProbeQMPMigrationCapabilities(qemuCaps, mon) < 0)
4596
        return -1;
4597
    if (virQEMUCapsProbeQMPSchemaCapabilities(qemuCaps, mon) < 0)
4598
        return -1;
4599
    if (virQEMUCapsProbeQMPGICCapabilities(qemuCaps, mon) < 0)
4600
        return -1;
4601
    if (virQEMUCapsProbeQMPSEVCapabilities(qemuCaps, mon) < 0)
4602
        return -1;
4603

4604
    virQEMUCapsInitProcessCaps(qemuCaps);
4605

4606 4607 4608 4609 4610 4611
    /* The following probes rely on other previously probed capabilities.
     * No capabilities bits should be set below this point. */

    if (virQEMUCapsProbeQMPHostCPU(qemuCaps, mon, false) < 0)
        return -1;

4612
    return 0;
4613 4614
}

4615

4616
int
4617
virQEMUCapsInitQMPMonitorTCG(virQEMUCapsPtr qemuCaps,
4618 4619
                             qemuMonitorPtr mon)
{
4620
    if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, mon, true) < 0)
4621
        return -1;
4622

4623
    if (virQEMUCapsProbeQMPHostCPU(qemuCaps, mon, true) < 0)
4624
        return -1;
4625

4626
    return 0;
4627 4628 4629
}


4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649
#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 },
    };

    virLogMessage(&virLogSelf,
                  VIR_LOG_WARN,
                  __FILE__, __LINE__, __func__,
                  meta,
                  _("Failed to probe capabilities for %s: %s"),
                  binary, virGetLastErrorMessage());
}


4650
static int
4651 4652 4653 4654 4655
virQEMUCapsInitQMPSingle(virQEMUCapsPtr qemuCaps,
                         const char *libDir,
                         uid_t runUid,
                         gid_t runGid,
                         bool onlyTCG)
4656
{
4657
    qemuProcessQMPPtr proc = NULL;
4658 4659
    int ret = -1;

4660
    if (!(proc = qemuProcessQMPNew(qemuCaps->binary, libDir,
4661
                                   runUid, runGid, onlyTCG)))
4662 4663
        goto cleanup;

4664
    if (qemuProcessQMPStart(proc) < 0)
4665 4666
        goto cleanup;

4667 4668 4669 4670
    if (onlyTCG)
        ret = virQEMUCapsInitQMPMonitorTCG(qemuCaps, proc->mon);
    else
        ret = virQEMUCapsInitQMPMonitor(qemuCaps, proc->mon);
4671 4672

 cleanup:
4673 4674 4675
    if (ret < 0)
        virQEMUCapsLogProbeFailure(qemuCaps->binary);

4676
    qemuProcessQMPFree(proc);
4677 4678 4679 4680
    return ret;
}


4681 4682 4683 4684
static int
virQEMUCapsInitQMP(virQEMUCapsPtr qemuCaps,
                   const char *libDir,
                   uid_t runUid,
4685
                   gid_t runGid)
4686
{
4687
    if (virQEMUCapsInitQMPSingle(qemuCaps, libDir, runUid, runGid, false) < 0)
4688 4689 4690 4691 4692 4693 4694 4695
        return -1;

    /*
     * If KVM was enabled during the first probe, we need to explicitly probe
     * for TCG capabilities by asking the same binary again and turning KVM
     * off.
     */
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
4696
        virQEMUCapsInitQMPSingle(qemuCaps, libDir, runUid, runGid, true) < 0)
4697 4698 4699 4700 4701 4702
        return -1;

    return 0;
}


4703
virQEMUCapsPtr
4704
virQEMUCapsNewForBinaryInternal(virArch hostArch,
4705
                                const char *binary,
4706 4707 4708
                                const char *libDir,
                                uid_t runUid,
                                gid_t runGid,
4709
                                unsigned int microcodeVersion,
J
Ján Tomko 已提交
4710
                                const char *kernelVersion)
4711
{
4712
    virQEMUCapsPtr qemuCaps;
4713 4714
    struct stat sb;

4715 4716 4717
    if (!(qemuCaps = virQEMUCapsNew()))
        goto error;

4718 4719
    if (VIR_STRDUP(qemuCaps->binary, binary) < 0)
        goto error;
4720 4721 4722 4723 4724 4725 4726 4727

    /* 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;
    }
4728
    qemuCaps->ctime = sb.st_ctime;
4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739

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

4740
    if (virQEMUCapsInitQMP(qemuCaps, libDir, runUid, runGid) < 0)
4741 4742
        goto error;

4743 4744
    qemuCaps->libvirtCtime = virGetSelfLastChanged();
    qemuCaps->libvirtVersion = LIBVIR_VERSION_NUMBER;
4745

4746 4747
    virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
    virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);
4748

4749
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
4750 4751
        qemuCaps->microcodeVersion = microcodeVersion;

4752 4753
        if (VIR_STRDUP(qemuCaps->kernelVersion, kernelVersion) < 0)
            goto error;
4754 4755

        qemuCaps->kvmSupportsNesting = virQEMUCapsKVMSupportsNesting();
4756 4757
    }

4758
 cleanup:
4759
    return qemuCaps;
4760

4761
 error:
4762 4763
    virObjectUnref(qemuCaps);
    qemuCaps = NULL;
4764
    goto cleanup;
4765 4766
}

4767 4768 4769
static void *
virQEMUCapsNewData(const char *binary,
                   void *privData)
4770
{
4771 4772 4773 4774 4775 4776 4777
    virQEMUCapsCachePrivPtr priv = privData;

    return virQEMUCapsNewForBinaryInternal(priv->hostArch,
                                           binary,
                                           priv->libDir,
                                           priv->runUid,
                                           priv->runGid,
4778
                                           virHostCPUGetMicrocodeVersion(),
J
Ján Tomko 已提交
4779
                                           priv->kernelVersion);
4780
}
4781 4782


4783 4784 4785 4786 4787 4788 4789
static void *
virQEMUCapsLoadFile(const char *filename,
                    const char *binary,
                    void *privData)
{
    virQEMUCapsPtr qemuCaps = virQEMUCapsNew();
    virQEMUCapsCachePrivPtr priv = privData;
4790

4791 4792
    if (!qemuCaps)
        return NULL;
4793

4794 4795 4796 4797 4798 4799 4800
    if (VIR_STRDUP(qemuCaps->binary, binary) < 0)
        goto error;

    if (virQEMUCapsLoadCache(priv->hostArch, qemuCaps, filename) < 0)
        goto error;

 cleanup:
4801 4802 4803 4804
    return qemuCaps;

 error:
    virObjectUnref(qemuCaps);
4805 4806
    qemuCaps = NULL;
    goto cleanup;
4807 4808
}

4809

4810 4811 4812 4813 4814 4815 4816 4817
struct virQEMUCapsMachineTypeFilter {
    const char *machineType;
    virQEMUCapsFlags *flags;
    size_t nflags;
};

static const struct virQEMUCapsMachineTypeFilter virQEMUCapsMachineFilter[] = {
    /* { "blah", virQEMUCapsMachineBLAHFilter,
4818
         G_N_ELEMENTS(virQEMUCapsMachineBLAHFilter) }, */
4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831
    { "", NULL, 0 },
};


void
virQEMUCapsFilterByMachineType(virQEMUCapsPtr qemuCaps,
                               const char *machineType)
{
    size_t i;

    if (!machineType)
        return;

4832
    for (i = 0; i < G_N_ELEMENTS(virQEMUCapsMachineFilter); i++) {
4833 4834 4835 4836 4837 4838 4839 4840 4841 4842
        const struct virQEMUCapsMachineTypeFilter *filter = &virQEMUCapsMachineFilter[i];
        size_t j;

        if (STRNEQ(filter->machineType, machineType))
            continue;

        for (j = 0; j < filter->nflags; j++)
            virQEMUCapsClear(qemuCaps, filter->flags[j]);
    }

4843 4844
    if (!virQEMUCapsGetMachineHotplugCpus(qemuCaps, machineType))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
4845 4846 4847
}


4848 4849 4850 4851 4852 4853 4854 4855 4856 4857
virFileCacheHandlers qemuCapsCacheHandlers = {
    .isValid = virQEMUCapsIsValid,
    .newData = virQEMUCapsNewData,
    .loadFile = virQEMUCapsLoadFile,
    .saveFile = virQEMUCapsSaveFile,
    .privFree = virQEMUCapsCachePrivFree,
};


virFileCachePtr
4858
virQEMUCapsCacheNew(const char *libDir,
4859
                    const char *cacheDir,
4860
                    uid_t runUid,
4861
                    gid_t runGid)
4862
{
4863 4864 4865
    char *capsCacheDir = NULL;
    virFileCachePtr cache = NULL;
    virQEMUCapsCachePrivPtr priv = NULL;
4866
    struct utsname uts;
4867

4868
    if (virAsprintf(&capsCacheDir, "%s/capabilities", cacheDir) < 0)
4869
        goto error;
4870 4871

    if (!(cache = virFileCacheNew(capsCacheDir, "xml", &qemuCapsCacheHandlers)))
4872
        goto error;
4873

4874
    if (VIR_ALLOC(priv) < 0)
4875
        goto error;
4876
    virFileCacheSetPriv(cache, priv);
4877

4878
    if (VIR_STRDUP(priv->libDir, libDir) < 0)
4879 4880
        goto error;

4881
    priv->hostArch = virArchFromHost();
4882

4883 4884
    priv->runUid = runUid;
    priv->runGid = runGid;
4885
    priv->kvmUsable = VIR_TRISTATE_BOOL_ABSENT;
4886

4887 4888 4889 4890
    if (uname(&uts) == 0 &&
        virAsprintf(&priv->kernelVersion, "%s %s", uts.release, uts.version) < 0)
        goto error;

4891 4892
 cleanup:
    VIR_FREE(capsCacheDir);
4893 4894
    return cache;

4895
 error:
4896 4897 4898
    virObjectUnref(cache);
    cache = NULL;
    goto cleanup;
4899 4900 4901
}


4902
virQEMUCapsPtr
4903
virQEMUCapsCacheLookup(virFileCachePtr cache,
4904
                       const char *binary)
4905
{
4906
    virQEMUCapsCachePrivPtr priv = virFileCacheGetPriv(cache);
4907
    virQEMUCapsPtr ret = NULL;
4908

4909 4910
    priv->microcodeVersion = virHostCPUGetMicrocodeVersion();

4911
    ret = virFileCacheLookup(cache, binary);
4912 4913

    VIR_DEBUG("Returning caps %p for %s", ret, binary);
4914 4915 4916 4917
    return ret;
}


4918
virQEMUCapsPtr
4919
virQEMUCapsCacheLookupCopy(virFileCachePtr cache,
4920
                           const char *binary,
4921
                           const char *machineType)
4922
{
4923
    virQEMUCapsPtr qemuCaps = virQEMUCapsCacheLookup(cache, binary);
4924
    virQEMUCapsPtr ret;
4925

4926
    if (!qemuCaps)
4927 4928
        return NULL;

4929 4930
    ret = virQEMUCapsNewCopy(qemuCaps);
    virObjectUnref(qemuCaps);
4931 4932 4933 4934

    if (!ret)
        return NULL;

4935
    virQEMUCapsFilterByMachineType(ret, machineType);
4936 4937 4938 4939
    return ret;
}


4940 4941
static int
virQEMUCapsCompareArch(const void *payload,
J
Ján Tomko 已提交
4942
                       const void *name G_GNUC_UNUSED,
4943 4944
                       const void *opaque)
{
4945
    struct virQEMUCapsSearchData *data = (struct virQEMUCapsSearchData *)opaque;
4946 4947
    const virQEMUCaps *qemuCaps = payload;

4948 4949 4950 4951 4952 4953 4954 4955 4956
    if (qemuCaps->arch != data->arch)
        return false;

    if (data->binaryFilter &&
        !strstr(qemuCaps->binary, data->binaryFilter)) {
        return false;
    }

    return true;
4957 4958 4959 4960
}


virQEMUCapsPtr
4961
virQEMUCapsCacheLookupByArch(virFileCachePtr cache,
4962 4963
                             virArch arch)
{
4964
    virQEMUCapsCachePrivPtr priv = virFileCacheGetPriv(cache);
4965
    virQEMUCapsPtr ret = NULL;
4966 4967 4968 4969
    const char *binaryFilters[] = {
        "qemu-system-",
        NULL,
    };
4970 4971 4972 4973
    virArch archs[] = {
        arch,
        virQEMUCapsFindTarget(virArchFromHost(), arch),
    };
4974
    size_t i;
4975 4976
    size_t j;

4977 4978
    priv->microcodeVersion = virHostCPUGetMicrocodeVersion();

4979 4980
    for (i = 0; i < G_N_ELEMENTS(binaryFilters); i++) {
        for (j = 0; j < G_N_ELEMENTS(archs); j++) {
4981 4982 4983 4984
            struct virQEMUCapsSearchData data = {
                .arch = archs[j],
                .binaryFilter = binaryFilters[i],
            };
4985

4986 4987 4988 4989
            ret = virFileCacheLookupByFunc(cache, virQEMUCapsCompareArch, &data);
            if (ret)
                goto done;
        }
4990 4991
    }

4992 4993 4994 4995 4996
    virReportError(VIR_ERR_INVALID_ARG,
                   _("unable to find any emulator to serve '%s' "
                     "architecture"), virArchToString(arch));

 done:
4997 4998
    VIR_DEBUG("Returning caps %p for arch %s", ret, virArchToString(arch));

4999 5000 5001 5002
    return ret;
}


5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088
/**
 * virQEMUCapsCacheLookupDefault:
 * @cache: QEMU capabilities cache
 * @binary: optional path to QEMU binary
 * @archStr: optional guest architecture
 * @virttypeStr: optional virt type
 * @machine: optional machine type
 * @retArch: if non-NULL, guest architecture will be returned here
 * @retVirttype: if non-NULL, domain virt type will be returned here
 * @retMachine: if non-NULL, canonical machine type will be returned here
 *
 * Looks up the QEMU binary specified by @binary and @archStr, checks it can
 * provide the required @virttypeStr and @machine and returns its capabilities.
 * Sensible defaults are used for any argument which is NULL (the function can
 * even be called with all NULL arguments).
 *
 * Returns QEMU capabilities matching the requirements, NULL on error.
 */
virQEMUCapsPtr
virQEMUCapsCacheLookupDefault(virFileCachePtr cache,
                              const char *binary,
                              const char *archStr,
                              const char *virttypeStr,
                              const char *machine,
                              virArch *retArch,
                              virDomainVirtType *retVirttype,
                              const char **retMachine)
{
    int virttype = VIR_DOMAIN_VIRT_NONE;
    int arch = virArchFromHost();
    virDomainVirtType capsType;
    virQEMUCapsPtr qemuCaps = NULL;
    virQEMUCapsPtr ret = NULL;

    if (virttypeStr &&
        (virttype = virDomainVirtTypeFromString(virttypeStr)) < 0) {
        virReportError(VIR_ERR_INVALID_ARG,
                       _("unknown virttype: %s"), virttypeStr);
        goto cleanup;
    }

    if (archStr &&
        (arch = virArchFromString(archStr)) == VIR_ARCH_NONE) {
        virReportError(VIR_ERR_INVALID_ARG,
                       _("unknown architecture: %s"), archStr);
        goto cleanup;
    }

    if (binary) {
        virArch arch_from_caps;

        if (!(qemuCaps = virQEMUCapsCacheLookup(cache, binary)))
            goto cleanup;

        arch_from_caps = virQEMUCapsGetArch(qemuCaps);

        if (arch_from_caps != arch &&
            !((ARCH_IS_X86(arch) && ARCH_IS_X86(arch_from_caps)) ||
              (ARCH_IS_PPC(arch) && ARCH_IS_PPC(arch_from_caps)) ||
              (ARCH_IS_ARM(arch) && ARCH_IS_ARM(arch_from_caps)) ||
              (ARCH_IS_S390(arch) && ARCH_IS_S390(arch_from_caps)))) {
            virReportError(VIR_ERR_INVALID_ARG,
                           _("architecture from emulator '%s' doesn't "
                             "match given architecture '%s'"),
                           virArchToString(arch_from_caps),
                           virArchToString(arch));
            goto cleanup;
        }
    } else {
        if (!(qemuCaps = virQEMUCapsCacheLookupByArch(cache, arch)))
            goto cleanup;

        binary = virQEMUCapsGetBinary(qemuCaps);
    }

    if (machine) {
        /* Turn @machine into canonical name */
        machine = virQEMUCapsGetCanonicalMachine(qemuCaps, machine);

        if (!virQEMUCapsIsMachineSupported(qemuCaps, machine)) {
            virReportError(VIR_ERR_INVALID_ARG,
                           _("the machine '%s' is not supported by emulator '%s'"),
                           machine, binary);
            goto cleanup;
        }
    } else {
5089
        machine = virQEMUCapsGetPreferredMachine(qemuCaps);
5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113
    }

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
        capsType = VIR_DOMAIN_VIRT_KVM;
    else
        capsType = VIR_DOMAIN_VIRT_QEMU;

    if (virttype == VIR_DOMAIN_VIRT_NONE)
        virttype = capsType;

    if (virttype == VIR_DOMAIN_VIRT_KVM && capsType == VIR_DOMAIN_VIRT_QEMU) {
        virReportError(VIR_ERR_INVALID_ARG,
                       _("KVM is not supported by '%s' on this host"),
                       binary);
        goto cleanup;
    }

    if (retArch)
        *retArch = arch;
    if (retVirttype)
        *retVirttype = virttype;
    if (retMachine)
        *retMachine = machine;

5114
    ret = g_steal_pointer(&qemuCaps);
5115 5116 5117 5118 5119 5120

 cleanup:
    virObjectUnref(qemuCaps);
    return ret;
}

5121 5122 5123 5124 5125 5126 5127
bool
virQEMUCapsSupportsVmport(virQEMUCapsPtr qemuCaps,
                          const virDomainDef *def)
{
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MACHINE_VMPORT_OPT))
        return false;

5128 5129
    return qemuDomainIsI440FX(def) ||
        qemuDomainIsQ35(def) ||
5130 5131 5132 5133
        STREQ(def->os.machine, "isapc");
}


5134 5135 5136 5137 5138 5139 5140
bool
virQEMUCapsIsMachineSupported(virQEMUCapsPtr qemuCaps,
                              const char *canonical_machine)
{
    size_t i;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
5141
        if (STREQ(canonical_machine, qemuCaps->machineTypes[i].name))
5142 5143 5144 5145
            return true;
    }
    return false;
}
5146 5147


5148 5149 5150 5151
/*
 * The preferred machine to use if none is listed explicitly
 * Note that this may differ from QEMU's own default machine
 */
5152
const char *
5153
virQEMUCapsGetPreferredMachine(virQEMUCapsPtr qemuCaps)
5154 5155 5156
{
    if (!qemuCaps->nmachineTypes)
        return NULL;
5157
    return qemuCaps->machineTypes[0].name;
5158
}
5159 5160


5161
static int
5162
virQEMUCapsFillDomainLoaderCaps(virDomainCapsLoaderPtr capsLoader,
5163
                                bool secure,
5164 5165
                                virFirmwarePtr *firmwares,
                                size_t nfirmwares)
5166
{
5167 5168
    size_t i;

5169
    capsLoader->supported = VIR_TRISTATE_BOOL_YES;
5170 5171
    capsLoader->type.report = true;
    capsLoader->readonly.report = true;
5172
    capsLoader->secure.report = true;
5173

5174
    if (VIR_ALLOC_N(capsLoader->values.values, nfirmwares) < 0)
5175 5176
        return -1;

5177 5178
    for (i = 0; i < nfirmwares; i++) {
        const char *filename = firmwares[i]->name;
5179
        size_t j;
5180 5181 5182 5183 5184 5185

        if (!virFileExists(filename)) {
            VIR_DEBUG("loader filename=%s does not exist", filename);
            continue;
        }

5186 5187 5188 5189 5190 5191 5192 5193 5194
        /* Put only unique FW images onto the list */
        for (j = 0; j < capsLoader->values.nvalues; j++) {
            if (STREQ(filename, capsLoader->values.values[j]))
                break;
        }

        if (j != capsLoader->values.nvalues)
            continue;

5195
        if (VIR_STRDUP(capsLoader->values.values[capsLoader->values.nvalues],
5196 5197
                       filename) < 0)
            return -1;
5198
        capsLoader->values.nvalues++;
5199 5200
    }

5201
    VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->type,
5202 5203
                             VIR_DOMAIN_LOADER_TYPE_ROM);

5204 5205
    VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->type,
                             VIR_DOMAIN_LOADER_TYPE_PFLASH);
5206 5207


5208 5209 5210
    VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->readonly,
                             VIR_TRISTATE_BOOL_YES,
                             VIR_TRISTATE_BOOL_NO);
5211 5212 5213 5214 5215 5216 5217 5218

    VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->secure,
                             VIR_TRISTATE_BOOL_NO);

    if (secure)
        VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->secure,
                                 VIR_TRISTATE_BOOL_YES);

5219
    return 0;
5220 5221 5222
}


5223
static int
5224
virQEMUCapsFillDomainOSCaps(virDomainCapsOSPtr os,
5225 5226 5227
                            const char *machine,
                            virArch arch,
                            bool privileged,
5228 5229
                            virFirmwarePtr *firmwares,
                            size_t nfirmwares)
5230
{
5231
    virDomainCapsLoaderPtr capsLoader = &os->loader;
5232 5233
    uint64_t autoFirmwares = 0;
    bool secure = false;
5234 5235 5236
    virFirmwarePtr *firmwaresAlt = NULL;
    size_t nfirmwaresAlt = 0;
    int ret = -1;
5237

5238
    os->supported = VIR_TRISTATE_BOOL_YES;
5239 5240
    os->firmware.report = true;

5241
    if (qemuFirmwareGetSupported(machine, arch, privileged,
5242 5243
                                 &autoFirmwares, &secure,
                                 &firmwaresAlt, &nfirmwaresAlt) < 0)
5244 5245 5246 5247 5248 5249 5250
        return -1;

    if (autoFirmwares & (1ULL << VIR_DOMAIN_OS_DEF_FIRMWARE_BIOS))
        VIR_DOMAIN_CAPS_ENUM_SET(os->firmware, VIR_DOMAIN_OS_DEF_FIRMWARE_BIOS);
    if (autoFirmwares & (1ULL << VIR_DOMAIN_OS_DEF_FIRMWARE_EFI))
        VIR_DOMAIN_CAPS_ENUM_SET(os->firmware, VIR_DOMAIN_OS_DEF_FIRMWARE_EFI);

5251 5252 5253 5254 5255 5256 5257 5258 5259
    if (virQEMUCapsFillDomainLoaderCaps(capsLoader, secure,
                                        firmwaresAlt ? firmwaresAlt : firmwares,
                                        firmwaresAlt ? nfirmwaresAlt : nfirmwares) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    virFirmwareFreeList(firmwaresAlt, nfirmwaresAlt);
    return ret;
5260 5261 5262
}


5263 5264 5265 5266 5267
static int
virQEMUCapsFillDomainCPUCaps(virCapsPtr caps,
                             virQEMUCapsPtr qemuCaps,
                             virDomainCapsPtr domCaps)
{
5268 5269
    if (virQEMUCapsIsCPUModeSupported(qemuCaps, caps, domCaps->virttype,
                                      VIR_CPU_MODE_HOST_PASSTHROUGH))
5270 5271
        domCaps->cpu.hostPassthrough = true;

5272
    if (virQEMUCapsIsCPUModeSupported(qemuCaps, caps, domCaps->virttype,
5273
                                      VIR_CPU_MODE_HOST_MODEL)) {
5274 5275
        virCPUDefPtr cpu = virQEMUCapsGetHostModel(qemuCaps, domCaps->virttype,
                                                   VIR_QEMU_CAPS_HOST_CPU_REPORTED);
5276 5277
        domCaps->cpu.hostModel = virCPUDefCopy(cpu);
    }
5278 5279 5280 5281 5282

    if (virQEMUCapsIsCPUModeSupported(qemuCaps, caps, domCaps->virttype,
                                      VIR_CPU_MODE_CUSTOM)) {
        virDomainCapsCPUModelsPtr filtered = NULL;
        char **models = NULL;
5283
        const char *blacklist[] = { "host", NULL };
5284

J
Jiri Denemark 已提交
5285
        if (virCPUGetModels(domCaps->arch, &models) >= 0) {
5286 5287 5288 5289 5290 5291 5292 5293
            virDomainCapsCPUModelsPtr cpus;

            if (domCaps->virttype == VIR_DOMAIN_VIRT_KVM)
                cpus = qemuCaps->kvmCPUModels;
            else
                cpus = qemuCaps->tcgCPUModels;

            filtered = virDomainCapsCPUModelsFilter(cpus,
5294
                                                    (const char **)models,
5295
                                                    blacklist);
5296
            virStringListFree(models);
5297 5298
        }
        domCaps->cpu.custom = filtered;
5299
    }
5300 5301 5302 5303 5304

    return 0;
}


5305 5306 5307 5308
static int
virQEMUCapsFillDomainIOThreadCaps(virQEMUCapsPtr qemuCaps,
                                  virDomainCapsPtr domCaps)
{
5309 5310
    domCaps->iothreads = virTristateBoolFromBool(
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_IOTHREAD));
5311 5312 5313 5314 5315

    return 0;
}


5316
static int
5317
virQEMUCapsFillDomainDeviceDiskCaps(virQEMUCapsPtr qemuCaps,
5318
                                    const char *machine,
5319 5320
                                    virDomainCapsDeviceDiskPtr disk)
{
5321
    disk->supported = VIR_TRISTATE_BOOL_YES;
5322 5323 5324 5325
    disk->diskDevice.report = true;
    disk->bus.report = true;
    disk->model.report = true;

5326 5327 5328
    /* QEMU supports all of these */
    VIR_DOMAIN_CAPS_ENUM_SET(disk->diskDevice,
                             VIR_DOMAIN_DISK_DEVICE_DISK,
5329 5330
                             VIR_DOMAIN_DISK_DEVICE_CDROM,
                             VIR_DOMAIN_DISK_DEVICE_LUN);
5331 5332

    /* PowerPC pseries based VMs do not support floppy device */
5333
    if (!qemuDomainMachineIsPSeries(machine, qemuCaps->arch)) {
5334
        VIR_DOMAIN_CAPS_ENUM_SET(disk->diskDevice, VIR_DOMAIN_DISK_DEVICE_FLOPPY);
5335 5336
        VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_FDC);
    }
5337

5338
    if (qemuDomainMachineHasBuiltinIDE(machine, qemuCaps->arch))
5339 5340
        VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_IDE);

5341 5342 5343 5344 5345 5346 5347
    VIR_DOMAIN_CAPS_ENUM_SET(disk->bus,
                             VIR_DOMAIN_DISK_BUS_SCSI,
                             VIR_DOMAIN_DISK_BUS_VIRTIO,
                             /* VIR_DOMAIN_DISK_BUS_SD */);

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE))
        VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_USB);
5348 5349 5350 5351

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI))
        VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_SATA);

5352 5353 5354 5355 5356 5357 5358 5359 5360 5361
    /* disk->model values */
    VIR_DOMAIN_CAPS_ENUM_SET(disk->model, VIR_DOMAIN_DISK_MODEL_VIRTIO);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY) ||
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL)) {
        VIR_DOMAIN_CAPS_ENUM_SET(disk->model,
                                 VIR_DOMAIN_DISK_MODEL_VIRTIO_TRANSITIONAL);
        VIR_DOMAIN_CAPS_ENUM_SET(disk->model,
                                 VIR_DOMAIN_DISK_MODEL_VIRTIO_NON_TRANSITIONAL);
    }

5362
    return 0;
5363 5364 5365
}


5366 5367 5368 5369
static int
virQEMUCapsFillDomainDeviceGraphicsCaps(virQEMUCapsPtr qemuCaps,
                                        virDomainCapsDeviceGraphicsPtr dev)
{
5370
    dev->supported = VIR_TRISTATE_BOOL_YES;
5371
    dev->type.report = true;
5372

J
Ján Tomko 已提交
5373
    VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_SDL);
5374 5375 5376 5377 5378 5379 5380 5381 5382
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_VNC);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SPICE))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_SPICE);

    return 0;
}


5383 5384 5385 5386
static int
virQEMUCapsFillDomainDeviceVideoCaps(virQEMUCapsPtr qemuCaps,
                                     virDomainCapsDeviceVideoPtr dev)
{
5387
    dev->supported = VIR_TRISTATE_BOOL_YES;
5388
    dev->modelType.report = true;
5389 5390 5391 5392 5393 5394 5395

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VGA))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VGA);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_CIRRUS_VGA))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_CIRRUS);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VMWARE_SVGA))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VMVGA);
5396
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL))
5397 5398 5399
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_QXL);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_GPU))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VIRTIO);
5400 5401
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_BOCHS_DISPLAY))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_BOCHS);
5402 5403 5404 5405 5406

    return 0;
}


5407
static int
5408 5409 5410 5411 5412
virQEMUCapsFillDomainDeviceHostdevCaps(virQEMUCapsPtr qemuCaps,
                                       virDomainCapsDeviceHostdevPtr hostdev)
{
    bool supportsPassthroughVFIO = qemuHostdevHostSupportsPassthroughVFIO();

5413
    hostdev->supported = VIR_TRISTATE_BOOL_YES;
5414 5415 5416 5417 5418 5419
    hostdev->mode.report = true;
    hostdev->startupPolicy.report = true;
    hostdev->subsysType.report = true;
    hostdev->capsType.report = true;
    hostdev->pciBackend.report = true;

5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431
    /* VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES is for containers only */
    VIR_DOMAIN_CAPS_ENUM_SET(hostdev->mode,
                             VIR_DOMAIN_HOSTDEV_MODE_SUBSYS);

    VIR_DOMAIN_CAPS_ENUM_SET(hostdev->startupPolicy,
                             VIR_DOMAIN_STARTUP_POLICY_DEFAULT,
                             VIR_DOMAIN_STARTUP_POLICY_MANDATORY,
                             VIR_DOMAIN_STARTUP_POLICY_REQUISITE,
                             VIR_DOMAIN_STARTUP_POLICY_OPTIONAL);

    VIR_DOMAIN_CAPS_ENUM_SET(hostdev->subsysType,
                             VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB,
5432 5433
                             VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI,
                             VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI);
5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445

    /* No virDomainHostdevCapsType for QEMU */
    virDomainCapsEnumClear(&hostdev->capsType);

    virDomainCapsEnumClear(&hostdev->pciBackend);
    if (supportsPassthroughVFIO &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_PCI)) {
        VIR_DOMAIN_CAPS_ENUM_SET(hostdev->pciBackend,
                                 VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT,
                                 VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO);
    }

5446
    return 0;
5447 5448 5449
}


5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477
static int
virQEMUCapsFillDomainDeviceRNGCaps(virQEMUCapsPtr qemuCaps,
                                   virDomainCapsDeviceRNGPtr rng)
{
    rng->supported = VIR_TRISTATE_BOOL_YES;
    rng->model.report = true;
    rng->backendModel.report = true;

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_RNG)) {
        VIR_DOMAIN_CAPS_ENUM_SET(rng->model, VIR_DOMAIN_RNG_MODEL_VIRTIO);

        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL) ||
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY)) {
            VIR_DOMAIN_CAPS_ENUM_SET(rng->model,
                                     VIR_DOMAIN_RNG_MODEL_VIRTIO_TRANSITIONAL,
                                     VIR_DOMAIN_RNG_MODEL_VIRTIO_NON_TRANSITIONAL);
        }
    }

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_EGD))
        VIR_DOMAIN_CAPS_ENUM_SET(rng->backendModel, VIR_DOMAIN_RNG_BACKEND_EGD);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_RANDOM))
        VIR_DOMAIN_CAPS_ENUM_SET(rng->backendModel, VIR_DOMAIN_RNG_BACKEND_RANDOM);

    return 0;
}


5478 5479 5480 5481 5482 5483 5484
/**
 * virQEMUCapsSupportsGICVersion:
 * @qemuCaps: QEMU capabilities
 * @virtType: domain type
 * @version: GIC version
 *
 * Checks the QEMU binary with capabilities @qemuCaps supports a specific
5485 5486
 * GIC version for a domain of type @virtType. If @qemuCaps is NULL, the GIC
 * @version is considered unsupported.
5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497
 *
 * Returns: true if the binary supports the requested GIC version, false
 *          otherwise
 */
bool
virQEMUCapsSupportsGICVersion(virQEMUCapsPtr qemuCaps,
                              virDomainVirtType virtType,
                              virGICVersion version)
{
    size_t i;

5498 5499 5500
    if (!qemuCaps)
        return false;

5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519
    for (i = 0; i < qemuCaps->ngicCapabilities; i++) {
        virGICCapabilityPtr cap = &(qemuCaps->gicCapabilities[i]);

        if (cap->version != version)
            continue;

        if (virtType == VIR_DOMAIN_VIRT_KVM &&
            cap->implementation & VIR_GIC_IMPLEMENTATION_KERNEL)
            return true;

        if (virtType == VIR_DOMAIN_VIRT_QEMU &&
            cap->implementation & VIR_GIC_IMPLEMENTATION_EMULATED)
            return true;
    }

    return false;
}


5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543
/**
 * virQEMUCapsFillDomainFeatureGICCaps:
 * @qemuCaps: QEMU capabilities
 * @domCaps: domain capabilities
 *
 * Take the information about GIC capabilities that has been obtained
 * using the 'query-gic-capabilities' QMP command and stored in @qemuCaps
 * and convert it to a form suitable for @domCaps.
 *
 * @qemuCaps contains complete information about the GIC capabilities for
 * the corresponding QEMU binary, stored as custom objects; @domCaps, on
 * the other hand, should only contain information about the GIC versions
 * available for the specific combination of architecture, machine type
 * and virtualization type. Moreover, a common format is used to store
 * information about enumerations in @domCaps, so further processing is
 * required.
 *
 * Returns: 0 on success, <0 on failure
 */
static int
virQEMUCapsFillDomainFeatureGICCaps(virQEMUCapsPtr qemuCaps,
                                    virDomainCapsPtr domCaps)
{
    virDomainCapsFeatureGICPtr gic = &domCaps->gic;
5544
    virGICVersion version;
5545

5546 5547
    gic->supported = VIR_TRISTATE_BOOL_NO;

5548
    if (!qemuDomainMachineIsARMVirt(domCaps->machine, domCaps->arch))
5549 5550
        return 0;

5551 5552 5553 5554 5555 5556
    for (version = VIR_GIC_VERSION_LAST - 1;
         version > VIR_GIC_VERSION_NONE;
         version--) {
        if (!virQEMUCapsSupportsGICVersion(qemuCaps,
                                           domCaps->virttype,
                                           version))
5557 5558
            continue;

5559
        gic->supported = VIR_TRISTATE_BOOL_YES;
5560
        gic->version.report = true;
5561
        VIR_DOMAIN_CAPS_ENUM_SET(gic->version,
5562
                                 version);
5563 5564 5565 5566 5567 5568
    }

    return 0;
}


5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584
/**
 * virQEMUCapsFillDomainFeatureSEVCaps:
 * @qemuCaps: QEMU capabilities
 * @domCaps: domain capabilities
 *
 * Take the information about SEV capabilities that has been obtained
 * using the 'query-sev-capabilities' QMP command and stored in @qemuCaps
 * and convert it to a form suitable for @domCaps.
 *
 * Returns: 0 on success, -1 on failure
 */
static int
virQEMUCapsFillDomainFeatureSEVCaps(virQEMUCapsPtr qemuCaps,
                                    virDomainCapsPtr domCaps)
{
    virSEVCapability *cap = qemuCaps->sevCapabilities;
J
Ján Tomko 已提交
5585
    g_autoptr(virSEVCapability) sev = NULL;
5586 5587 5588 5589 5590 5591 5592 5593

    if (!cap)
        return 0;

    if (VIR_ALLOC(sev) < 0)
        return -1;

    if (VIR_STRDUP(sev->pdh, cap->pdh) < 0)
5594
        return -1;
5595 5596

    if (VIR_STRDUP(sev->cert_chain, cap->cert_chain) < 0)
5597
        return -1;
5598 5599 5600

    sev->cbitpos = cap->cbitpos;
    sev->reduced_phys_bits = cap->reduced_phys_bits;
5601
    domCaps->sev = g_steal_pointer(&sev);
5602

5603
    return 0;
5604 5605 5606
}


5607
int
5608 5609
virQEMUCapsFillDomainCaps(virCapsPtr caps,
                          virDomainCapsPtr domCaps,
5610
                          virQEMUCapsPtr qemuCaps,
5611
                          bool privileged,
5612
                          virFirmwarePtr *firmwares,
5613
                          size_t nfirmwares)
5614
{
5615
    virDomainCapsOSPtr os = &domCaps->os;
5616 5617
    virDomainCapsDeviceDiskPtr disk = &domCaps->disk;
    virDomainCapsDeviceHostdevPtr hostdev = &domCaps->hostdev;
5618
    virDomainCapsDeviceGraphicsPtr graphics = &domCaps->graphics;
5619
    virDomainCapsDeviceVideoPtr video = &domCaps->video;
5620
    virDomainCapsDeviceRNGPtr rng = &domCaps->rng;
5621

5622 5623
    domCaps->maxvcpus = virQEMUCapsGetMachineMaxCpus(qemuCaps,
                                                     domCaps->machine);
5624
    if (domCaps->virttype == VIR_DOMAIN_VIRT_KVM) {
5625 5626 5627 5628 5629 5630
        int hostmaxvcpus;

        if ((hostmaxvcpus = virHostCPUGetKVMMaxVCPUs()) < 0)
            return -1;

        domCaps->maxvcpus = MIN(domCaps->maxvcpus, hostmaxvcpus);
5631
    }
5632

5633 5634
    domCaps->vmcoreinfo = virTristateBoolFromBool(
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VMCOREINFO));
5635

5636 5637
    domCaps->genid = virTristateBoolFromBool(
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VMGENID));
5638

5639 5640 5641 5642 5643
    if (virQEMUCapsFillDomainOSCaps(os,
                                    domCaps->machine,
                                    domCaps->arch,
                                    privileged,
                                    firmwares, nfirmwares) < 0 ||
5644
        virQEMUCapsFillDomainCPUCaps(caps, qemuCaps, domCaps) < 0 ||
5645
        virQEMUCapsFillDomainIOThreadCaps(qemuCaps, domCaps) < 0 ||
5646 5647 5648
        virQEMUCapsFillDomainDeviceDiskCaps(qemuCaps,
                                            domCaps->machine, disk) < 0 ||
        virQEMUCapsFillDomainDeviceGraphicsCaps(qemuCaps, graphics) < 0 ||
5649
        virQEMUCapsFillDomainDeviceVideoCaps(qemuCaps, video) < 0 ||
5650
        virQEMUCapsFillDomainDeviceHostdevCaps(qemuCaps, hostdev) < 0 ||
5651
        virQEMUCapsFillDomainDeviceRNGCaps(qemuCaps, rng) < 0 ||
5652 5653
        virQEMUCapsFillDomainFeatureGICCaps(qemuCaps, domCaps) < 0 ||
        virQEMUCapsFillDomainFeatureSEVCaps(qemuCaps, domCaps) < 0)
5654
        return -1;
5655

5656
    return 0;
5657
}
5658 5659 5660 5661 5662 5663 5664 5665


void
virQEMUCapsSetMicrocodeVersion(virQEMUCapsPtr qemuCaps,
                               unsigned int microcodeVersion)
{
    qemuCaps->microcodeVersion = microcodeVersion;
}
5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682


/**
 * virQEMUCapsStripMachineAliases:
 * @qemuCaps: capabilities object to process
 *
 * Remove all aliases so that the tests depending on the latest capabilities
 * file can be stable when new files are added.
 */
void
virQEMUCapsStripMachineAliases(virQEMUCapsPtr qemuCaps)
{
    size_t i;

    for (i = 0; i < qemuCaps->nmachineTypes; i++)
        VIR_FREE(qemuCaps->machineTypes[i].alias);
}