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

#include <config.h>

#include "qemu_command.h"
27
#include "qemu_hostdev.h"
28 29 30
#include "qemu_capabilities.h"
#include "qemu_bridge_filter.h"
#include "cpu/cpu.h"
31
#include "dirname.h"
32
#include "passfd.h"
33
#include "viralloc.h"
34
#include "virlog.h"
35
#include "virarch.h"
36
#include "virerror.h"
E
Eric Blake 已提交
37
#include "virfile.h"
38
#include "virnetdev.h"
39
#include "virstring.h"
40
#include "viruuid.h"
41 42
#include "c-ctype.h"
#include "domain_nwfilter.h"
43
#include "domain_audit.h"
M
Michal Novotny 已提交
44
#include "domain_conf.h"
45
#include "snapshot_conf.h"
46
#include "storage_conf.h"
47
#include "network/bridge_driver.h"
48
#include "virnetdevtap.h"
49
#include "base64.h"
50
#include "device_conf.h"
51
#include "virstoragefile.h"
52
#include "virtpm.h"
53
#include "virscsi.h"
54 55 56
#if defined(__linux__)
# include <linux/capability.h>
#endif
57 58 59 60 61 62

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

#define VIR_FROM_THIS VIR_FROM_QEMU

63 64 65 66
#define VIO_ADDR_NET 0x1000ul
#define VIO_ADDR_SCSI 0x2000ul
#define VIO_ADDR_SERIAL 0x30000000ul
#define VIO_ADDR_NVRAM 0x3000ul
67 68 69 70 71 72 73 74 75 76

VIR_ENUM_DECL(virDomainDiskQEMUBus)
VIR_ENUM_IMPL(virDomainDiskQEMUBus, VIR_DOMAIN_DISK_BUS_LAST,
              "ide",
              "floppy",
              "scsi",
              "virtio",
              "xen",
              "usb",
              "uml",
77 78
              "sata",
              "sd")
79 80 81 82 83 84 85 86


VIR_ENUM_DECL(qemuDiskCacheV1)
VIR_ENUM_DECL(qemuDiskCacheV2)

VIR_ENUM_IMPL(qemuDiskCacheV1, VIR_DOMAIN_DISK_CACHE_LAST,
              "default",
              "off",
87 88
              "off",  /* writethrough not supported, so for safety, disable */
              "on",   /* Old 'on' was equivalent to 'writeback' */
89 90
              "off",  /* directsync not supported, for safety, disable */
              "off"); /* unsafe not supported, for safety, disable */
91 92 93 94 95

VIR_ENUM_IMPL(qemuDiskCacheV2, VIR_DOMAIN_DISK_CACHE_LAST,
              "default",
              "none",
              "writethrough",
96
              "writeback",
97 98
              "directsync",
              "unsafe");
99 100 101 102 103 104 105 106 107 108 109

VIR_ENUM_DECL(qemuVideo)

VIR_ENUM_IMPL(qemuVideo, VIR_DOMAIN_VIDEO_TYPE_LAST,
              "std",
              "cirrus",
              "vmware",
              "", /* no arg needed for xen */
              "", /* don't support vbox */
              "qxl");

110 111 112 113 114 115 116 117 118 119
VIR_ENUM_DECL(qemuDeviceVideo)

VIR_ENUM_IMPL(qemuDeviceVideo, VIR_DOMAIN_VIDEO_TYPE_LAST,
              "VGA",
              "cirrus-vga",
              "vmware-svga",
              "", /* no device for xen */
              "", /* don't support vbox */
              "qxl-vga");

120 121 122 123 124 125
VIR_ENUM_DECL(qemuSoundCodec)

VIR_ENUM_IMPL(qemuSoundCodec, VIR_DOMAIN_SOUND_CODEC_TYPE_LAST,
              "hda-duplex",
              "hda-micro");

126 127 128 129 130 131 132 133 134 135 136
VIR_ENUM_DECL(qemuControllerModelUSB)

VIR_ENUM_IMPL(qemuControllerModelUSB, VIR_DOMAIN_CONTROLLER_MODEL_USB_LAST,
              "piix3-usb-uhci",
              "piix4-usb-uhci",
              "usb-ehci",
              "ich9-usb-ehci1",
              "ich9-usb-uhci1",
              "ich9-usb-uhci2",
              "ich9-usb-uhci3",
              "vt82c686b-usb-uhci",
G
Gerd Hoffmann 已提交
137
              "pci-ohci",
138 139
              "nec-usb-xhci",
              "none");
140

141 142 143 144
VIR_ENUM_DECL(qemuDomainFSDriver)
VIR_ENUM_IMPL(qemuDomainFSDriver, VIR_DOMAIN_FS_DRIVER_TYPE_LAST,
              "local",
              "local",
145
              "handle",
146
              NULL,
147
              NULL);
148

149

150 151
/**
 * qemuPhysIfaceConnect:
152
 * @def: the definition of the VM (needed by 802.1Qbh and audit)
153
 * @driver: pointer to the driver instance
154
 * @net: pointer to he VM's interface description with direct device type
155
 * @qemuCaps: flags for qemu
M
Michael Wood 已提交
156
 * @vmop: VM operation type
157 158 159 160
 *
 * Returns a filedescriptor on success or -1 in case of error.
 */
int
161
qemuPhysIfaceConnect(virDomainDefPtr def,
162
                     virQEMUDriverPtr driver,
163
                     virDomainNetDefPtr net,
164
                     virQEMUCapsPtr qemuCaps,
165
                     enum virNetDevVPortProfileOp vmop)
166 167 168 169
{
    int rc;
    char *res_ifname = NULL;
    int vnet_hdr = 0;
170
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
171

172
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
173 174 175
        net->model && STREQ(net->model, "virtio"))
        vnet_hdr = 1;

176
    rc = virNetDevMacVLanCreateWithVPortProfile(
177
        net->ifname, &net->mac,
178 179
        virDomainNetGetActualDirectDev(net),
        virDomainNetGetActualDirectMode(net),
180
        true, vnet_hdr, def->uuid,
181
        virDomainNetGetActualVirtPortProfile(net),
182
        &res_ifname,
183
        vmop, cfg->stateDir,
184
        virDomainNetGetActualBandwidth(net));
185
    if (rc >= 0) {
186 187 188 189
        if (virSecurityManagerSetTapFDLabel(driver->securityManager,
                                            def, rc) < 0)
            goto error;

190
        virDomainAuditNetDevice(def, net, res_ifname, true);
191 192 193 194
        VIR_FREE(net->ifname);
        net->ifname = res_ifname;
    }

195
    virObjectUnref(cfg);
196
    return rc;
197 198 199 200 201 202 203

error:
    ignore_value(virNetDevMacVLanDeleteWithVPortProfile(
                     res_ifname, &net->mac,
                     virDomainNetGetActualDirectDev(net),
                     virDomainNetGetActualDirectMode(net),
                     virDomainNetGetActualVirtPortProfile(net),
204
                     cfg->stateDir));
205
    VIR_FREE(res_ifname);
206
    virObjectUnref(cfg);
207
    return -1;
208 209 210
}


211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
/**
 * qemuCreateInBridgePortWithHelper:
 * @cfg: the configuration object in which the helper name is looked up
 * @brname: the bridge name
 * @ifname: the returned interface name
 * @macaddr: the returned MAC address
 * @tapfd: file descriptor return value for the new tap device
 * @flags: OR of virNetDevTapCreateFlags:

 *   VIR_NETDEV_TAP_CREATE_VNET_HDR
 *     - Enable IFF_VNET_HDR on the tap device
 *
 * This function creates a new tap device on a bridge using an external
 * helper.  The final name for the bridge will be stored in @ifname.
 *
 * Returns 0 in case of success or -1 on failure
 */
static int qemuCreateInBridgePortWithHelper(virQEMUDriverConfigPtr cfg,
                                            const char *brname,
                                            char **ifname,
                                            int *tapfd,
                                            unsigned int flags)
{
    virCommandPtr cmd;
    int status;
    int pair[2] = { -1, -1 };

    if ((flags & ~VIR_NETDEV_TAP_CREATE_VNET_HDR) != VIR_NETDEV_TAP_CREATE_IFUP)
        return -1;

    if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) < 0) {
        virReportSystemError(errno, "%s", _("failed to create socket"));
        return -1;
    }

    cmd = virCommandNew(cfg->bridgeHelperName);
    if (flags & VIR_NETDEV_TAP_CREATE_VNET_HDR)
        virCommandAddArgFormat(cmd, "--use-vnet");
    virCommandAddArgFormat(cmd, "--br=%s", brname);
    virCommandAddArgFormat(cmd, "--fd=%d", pair[1]);
251 252
    virCommandPassFD(cmd, pair[1],
                     VIR_COMMAND_PASS_FD_CLOSE_PARENT);
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
    virCommandClearCaps(cmd);
#ifdef CAP_NET_ADMIN
    virCommandAllowCap(cmd, CAP_NET_ADMIN);
#endif
    if (virCommandRunAsync(cmd, NULL) < 0) {
        *tapfd = -1;
        goto cleanup;
    }

    do {
        *tapfd = recvfd(pair[0], 0);
    } while (*tapfd < 0 && errno == EINTR);
    if (*tapfd < 0) {
        virReportSystemError(errno, "%s",
                             _("failed to retrieve file descriptor for interface"));
        goto cleanup;
    }

    if (virNetDevTapGetName(*tapfd, ifname) < 0 ||
        virCommandWait(cmd, &status) < 0) {
        VIR_FORCE_CLOSE(*tapfd);
        *tapfd = -1;
    }

cleanup:
    virCommandFree(cmd);
    VIR_FORCE_CLOSE(pair[0]);
    return *tapfd < 0 ? -1 : 0;
}

283
int
284 285
qemuNetworkIfaceConnect(virDomainDefPtr def,
                        virConnectPtr conn,
286
                        virQEMUDriverPtr driver,
287
                        virDomainNetDefPtr net,
288 289 290
                        virQEMUCapsPtr qemuCaps,
                        int *tapfd,
                        int *tapfdSize)
291 292
{
    char *brname = NULL;
293
    int ret = -1;
294
    unsigned int tap_create_flags = VIR_NETDEV_TAP_CREATE_IFUP;
E
Eric Blake 已提交
295
    bool template_ifname = false;
296
    int actualType = virDomainNetGetActualType(net);
297
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
298

299
    if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK) {
300 301
        int active;
        bool fail = false;
302 303 304 305
        virErrorPtr errobj;
        virNetworkPtr network = virNetworkLookupByName(conn,
                                                       net->data.network.name);
        if (!network)
306
            return ret;
307 308 309

        active = virNetworkIsActive(network);
        if (active != 1) {
310
            fail = true;
311 312

            if (active == 0)
313 314 315
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Network '%s' is not active."),
                               net->data.network.name);
316 317 318 319 320
        }

        if (!fail) {
            brname = virNetworkGetBridgeName(network);
            if (brname == NULL)
321
                fail = true;
322 323 324 325 326 327 328 329 330
        }

        /* Make sure any above failure is preserved */
        errobj = virSaveLastError();
        virNetworkFree(network);
        virSetError(errobj);
        virFreeError(errobj);

        if (fail)
331
            return ret;
332

333
    } else if (actualType == VIR_DOMAIN_NET_TYPE_BRIDGE) {
334
        if (VIR_STRDUP(brname, virDomainNetGetActualBridgeName(net)) < 0)
335
            return ret;
336
    } else {
337 338 339
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Network type %d is not supported"),
                       virDomainNetGetActualType(net));
340
        return ret;
341 342 343
    }

    if (!net->ifname ||
E
Eric Blake 已提交
344
        STRPREFIX(net->ifname, VIR_NET_GENERATED_PREFIX) ||
345 346
        strchr(net->ifname, '%')) {
        VIR_FREE(net->ifname);
347
        if (VIR_STRDUP(net->ifname, VIR_NET_GENERATED_PREFIX "%d") < 0)
348
            goto cleanup;
349
        /* avoid exposing vnet%d in getXMLDesc or error outputs */
E
Eric Blake 已提交
350
        template_ifname = true;
351 352
    }

353
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
354 355 356
        net->model && STREQ(net->model, "virtio")) {
        tap_create_flags |= VIR_NETDEV_TAP_CREATE_VNET_HDR;
    }
357

358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
    if (cfg->privileged) {
        if (virNetDevTapCreateInBridgePort(brname, &net->ifname, &net->mac,
                                           def->uuid, tapfd, *tapfdSize,
                                           virDomainNetGetActualVirtPortProfile(net),
                                           virDomainNetGetActualVlan(net),
                                           tap_create_flags) < 0) {
            virDomainAuditNetDevice(def, net, "/dev/net/tun", false);
            goto cleanup;
        }
    } else {
        if (qemuCreateInBridgePortWithHelper(cfg, brname,
                                             &net->ifname,
                                             tapfd, tap_create_flags) < 0) {
            virDomainAuditNetDevice(def, net, "/dev/net/tun", false);
            goto cleanup;
        }
        /* qemuCreateInBridgePortWithHelper can only create a single FD */
        if (*tapfdSize > 1) {
            VIR_WARN("Ignoring multiqueue network request");
            *tapfdSize = 1;
        }
379 380
    }

381 382 383 384 385 386 387 388
    virDomainAuditNetDevice(def, net, "/dev/net/tun", true);

    if (cfg->macFilter &&
        (ret = networkAllowMacOnPort(driver, net->ifname, &net->mac)) < 0) {
        virReportSystemError(ret,
                             _("failed to add ebtables rule "
                               "to allow MAC address on '%s'"),
                             net->ifname);
389 390
    }

391
    if (virNetDevBandwidthSet(net->ifname,
392 393
                              virDomainNetGetActualBandwidth(net),
                              false) < 0) {
394 395 396
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("cannot set bandwidth limits on %s"),
                       net->ifname);
397 398 399
        goto cleanup;
    }

400 401 402
    if (net->filter && net->ifname &&
        virDomainConfNWFilterInstantiate(conn, def->uuid, net) < 0) {
        goto cleanup;
403 404
    }

405 406
    ret = 0;

407
cleanup:
408
    if (ret < 0) {
409
        size_t i;
410
        for (i = 0; i < *tapfdSize && tapfd[i] >= 0; i++)
411 412 413 414
            VIR_FORCE_CLOSE(tapfd[i]);
        if (template_ifname)
            VIR_FREE(net->ifname);
    }
415
    VIR_FREE(brname);
416
    virObjectUnref(cfg);
417

418
    return ret;
419 420
}

421
static bool
422 423 424
qemuDomainSupportsNicdev(virDomainDefPtr def,
                         virQEMUCapsPtr qemuCaps,
                         virDomainNetDefPtr net)
425 426 427 428
{
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
        return false;

429 430 431
    /* non-virtio ARM nics require legacy -net nic */
    if (def->os.arch == VIR_ARCH_ARMV7L &&
        net->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO)
432 433 434 435 436 437
        return false;

    return true;
}

static bool
438 439 440
qemuDomainSupportsNetdev(virDomainDefPtr def,
                         virQEMUCapsPtr qemuCaps,
                         virDomainNetDefPtr net)
441
{
442
    if (!qemuDomainSupportsNicdev(def, qemuCaps, net))
443 444 445
        return false;
    return virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV);
}
446

447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
/**
 * qemuOpenVhostNet:
 * @def: domain definition
 * @net: network definition
 * @qemuCaps: qemu binary capabilities
 * @vhostfd: array of opened vhost-net device
 * @vhostfdSize: number of file descriptors in @vhostfd array
 *
 * Open vhost-net, multiple times - if requested.
 * In case, no vhost-net is needed, @vhostfdSize is set to 0
 * and 0 is returned.
 *
 * Returns: 0 on success
 *         -1 on failure
 */
462
int
463 464
qemuOpenVhostNet(virDomainDefPtr def,
                 virDomainNetDefPtr net,
465
                 virQEMUCapsPtr qemuCaps,
466 467
                 int *vhostfd,
                 int *vhostfdSize)
468
{
469
    size_t i;
470

471 472 473 474
    /* If running a plain QEMU guest, or
     * if the config says explicitly to not use vhost, return now*/
    if (def->virtType != VIR_DOMAIN_VIRT_KVM ||
        net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_QEMU) {
475 476
        *vhostfdSize = 0;
        return 0;
477 478 479 480 481
    }

    /* If qemu doesn't support vhost-net mode (including the -netdev command
     * option), don't try to open the device.
     */
482
    if (!(virQEMUCapsGet(qemuCaps, QEMU_CAPS_VHOST_NET) &&
483
          qemuDomainSupportsNetdev(def, qemuCaps, net))) {
484
        if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
485 486 487
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("vhost-net is not supported with "
                                   "this QEMU binary"));
488 489
            return -1;
        }
490
        *vhostfdSize = 0;
491 492
        return 0;
    }
493

494 495
    /* If the nic model isn't virtio, don't try to open. */
    if (!(net->model && STREQ(net->model, "virtio"))) {
496
        if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
497 498 499
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("vhost-net is only supported for "
                                   "virtio network interfaces"));
500 501
            return -1;
        }
502
        *vhostfdSize = 0;
503 504 505
        return 0;
    }

506 507
    for (i = 0; i < *vhostfdSize; i++) {
        vhostfd[i] = open("/dev/vhost-net", O_RDWR);
508

509 510 511 512 513 514 515 516 517 518 519
        /* If the config says explicitly to use vhost and we couldn't open it,
         * report an error.
         */
        if (vhostfd[i] < 0) {
            virDomainAuditNetDevice(def, net, "/dev/vhost-net", false);
            if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("vhost-net was requested for an interface, "
                                       "but is unavailable"));
                goto error;
            }
520
            VIR_WARN("Unable to open vhost-net. Opened so far %zu, requested %d",
521 522 523
                     i, *vhostfdSize);
            *vhostfdSize = i;
            break;
524
        }
525
    }
526
    virDomainAuditNetDevice(def, net, "/dev/vhost-net", *vhostfdSize);
527
    return 0;
528 529 530 531 532 533

error:
    while (i--)
        VIR_FORCE_CLOSE(vhostfd[i]);

    return -1;
534 535
}

536 537 538 539
int
qemuNetworkPrepareDevices(virDomainDefPtr def)
{
    int ret = -1;
540
    size_t i;
541

542 543
    for (i = 0; i < def->nnets; i++) {
        virDomainNetDefPtr net = def->nets[i];
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
        int actualType;

        /* If appropriate, grab a physical device from the configured
         * network's pool of devices, or resolve bridge device name
         * to the one defined in the network definition.
         */
        if (networkAllocateActualDevice(net) < 0)
            goto cleanup;

        actualType = virDomainNetGetActualType(net);
        if (actualType == VIR_DOMAIN_NET_TYPE_HOSTDEV &&
            net->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
            /* Each type='hostdev' network device must also have a
             * corresponding entry in the hostdevs array. For netdevs
             * that are hardcoded as type='hostdev', this is already
             * done by the parser, but for those allocated from a
             * network / determined at runtime, we need to do it
             * separately.
             */
            virDomainHostdevDefPtr hostdev = virDomainNetGetActualHostdev(net);

            if (virDomainHostdevFind(def, hostdev, NULL) >= 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("PCI device %04x:%02x:%02x.%x "
                                 "allocated from network %s is already "
                                 "in use by domain %s"),
                               hostdev->source.subsys.u.pci.addr.domain,
                               hostdev->source.subsys.u.pci.addr.bus,
                               hostdev->source.subsys.u.pci.addr.slot,
                               hostdev->source.subsys.u.pci.addr.function,
                               net->data.network.name,
                               def->name);
                goto cleanup;
            }
578
            if (virDomainHostdevInsert(def, hostdev) < 0)
579 580 581 582 583 584 585
                goto cleanup;
        }
    }
    ret = 0;
cleanup:
    return ret;
}
586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612

static int qemuDomainDeviceAliasIndex(virDomainDeviceInfoPtr info,
                                      const char *prefix)
{
    int idx;

    if (!info->alias)
        return -1;
    if (!STRPREFIX(info->alias, prefix))
        return -1;

    if (virStrToLong_i(info->alias + strlen(prefix), NULL, 10, &idx) < 0)
        return -1;

    return idx;
}


int qemuDomainNetVLAN(virDomainNetDefPtr def)
{
    return qemuDomainDeviceAliasIndex(&def->info, "net");
}


/* Names used before -drive existed */
static int qemuAssignDeviceDiskAliasLegacy(virDomainDiskDefPtr disk)
{
613
    char *dev_name;
614

615 616 617
    if (VIR_STRDUP(dev_name,
                   disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM &&
                   STREQ(disk->dst, "hdc") ? "cdrom" : disk->dst) < 0)
618
        return -1;
619
    disk->info.alias = dev_name;
620 621 622 623 624
    return 0;
}


char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
625
                               virQEMUCapsPtr qemuCaps)
626 627 628
{
    char *ret;

629
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
630 631
        ignore_value(virAsprintf(&ret, "%s%s", QEMU_DRIVE_HOST_PREFIX,
                                 disk->info.alias));
632
    } else {
633
        ignore_value(VIR_STRDUP(ret, disk->info.alias));
634 635 636 637 638 639 640 641 642 643
    }
    return ret;
}


/* Names used before -drive supported the id= option */
static int qemuAssignDeviceDiskAliasFixed(virDomainDiskDefPtr disk)
{
    int busid, devid;
    int ret;
644
    char *dev_name;
645 646

    if (virDiskNameToBusDeviceIndex(disk, &busid, &devid) < 0) {
647 648 649
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("cannot convert disk '%s' to bus/device index"),
                       disk->dst);
650 651 652 653 654 655
        return -1;
    }

    switch (disk->bus) {
    case VIR_DOMAIN_DISK_BUS_IDE:
        if (disk->device== VIR_DOMAIN_DISK_DEVICE_DISK)
656
            ret = virAsprintf(&dev_name, "ide%d-hd%d", busid, devid);
657
        else
658
            ret = virAsprintf(&dev_name, "ide%d-cd%d", busid, devid);
659 660 661
        break;
    case VIR_DOMAIN_DISK_BUS_SCSI:
        if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK)
662
            ret = virAsprintf(&dev_name, "scsi%d-hd%d", busid, devid);
663
        else
664
            ret = virAsprintf(&dev_name, "scsi%d-cd%d", busid, devid);
665 666
        break;
    case VIR_DOMAIN_DISK_BUS_FDC:
667
        ret = virAsprintf(&dev_name, "floppy%d", devid);
668 669
        break;
    case VIR_DOMAIN_DISK_BUS_VIRTIO:
670
        ret = virAsprintf(&dev_name, "virtio%d", devid);
671 672
        break;
    case VIR_DOMAIN_DISK_BUS_XEN:
673
        ret = virAsprintf(&dev_name, "xenblk%d", devid);
674
        break;
675 676 677
    case VIR_DOMAIN_DISK_BUS_SD:
        ret = virAsprintf(&dev_name, "sd%d", devid);
        break;
678
    default:
679 680 681
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("Unsupported disk name mapping for bus '%s'"),
                       virDomainDiskBusTypeToString(disk->bus));
682 683 684
        return -1;
    }

685
    if (ret == -1)
686 687
        return -1;

688
    disk->info.alias = dev_name;
689 690 691 692

    return 0;
}

693
static int
694
qemuSetScsiControllerModel(virDomainDefPtr def,
695
                           virQEMUCapsPtr qemuCaps,
696
                           int *model)
697 698 699 700
{
    if (*model > 0) {
        switch (*model) {
        case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC:
701
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
702 703
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("This QEMU doesn't support "
704
                                 "the LSI 53C895A SCSI controller"));
705 706 707 708
                return -1;
            }
            break;
        case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI:
709
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_SCSI)) {
710 711 712 713 714 715 716 717 718
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("This QEMU doesn't support "
                                 "virtio scsi controller"));
                return -1;
            }
            break;
        case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI:
            /*TODO: need checking work here if necessary */
            break;
719 720 721 722 723 724 725 726
        case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSISAS1078:
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_MEGASAS)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("This QEMU doesn't support "
                                 "the LSI SAS1078 controller"));
                return -1;
            }
            break;
727 728 729 730 731 732
        default:
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("Unsupported controller model: %s"),
                           virDomainControllerModelSCSITypeToString(*model));
            return -1;
        }
733
    } else {
734
        if ((def->os.arch == VIR_ARCH_PPC64) &&
735 736
            STREQ(def->os.machine, "pseries")) {
            *model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI;
737
        } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
738
            *model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC;
739 740
        } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_SCSI)) {
            *model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI;
741 742 743 744 745
        } else {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Unable to determine model for scsi controller"));
            return -1;
        }
746
    }
747 748

    return 0;
749
}
750 751

/* Our custom -drive naming scheme used with id= */
752 753
static int
qemuAssignDeviceDiskAliasCustom(virDomainDefPtr def,
754
                                virDomainDiskDefPtr disk,
755
                                virQEMUCapsPtr qemuCaps)
756 757
{
    const char *prefix = virDomainDiskBusTypeToString(disk->bus);
758 759
    int controllerModel = -1;

760
    if (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
761 762
        if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
            controllerModel =
H
Han Cheng 已提交
763 764
                virDomainDeviceFindControllerModel(def, &disk->info,
                                                   VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
765

766
            if ((qemuSetScsiControllerModel(def, qemuCaps, &controllerModel)) < 0)
767 768
                return -1;
        }
769 770 771 772 773 774 775

        if (disk->bus != VIR_DOMAIN_DISK_BUS_SCSI ||
            controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
            if (virAsprintf(&disk->info.alias, "%s%d-%d-%d", prefix,
                            disk->info.addr.drive.controller,
                            disk->info.addr.drive.bus,
                            disk->info.addr.drive.unit) < 0)
776
                return -1;
777 778 779 780 781 782
        } else {
            if (virAsprintf(&disk->info.alias, "%s%d-%d-%d-%d", prefix,
                            disk->info.addr.drive.controller,
                            disk->info.addr.drive.bus,
                            disk->info.addr.drive.target,
                            disk->info.addr.drive.unit) < 0)
783
                return -1;
784
        }
785 786 787
    } else {
        int idx = virDiskNameToIndex(disk->dst);
        if (virAsprintf(&disk->info.alias, "%s-disk%d", prefix, idx) < 0)
788
            return -1;
789 790 791 792 793 794 795
    }

    return 0;
}


int
796 797
qemuAssignDeviceDiskAlias(virDomainDefPtr vmdef,
                          virDomainDiskDefPtr def,
798
                          virQEMUCapsPtr qemuCaps)
799
{
800 801 802
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
            return qemuAssignDeviceDiskAliasCustom(vmdef, def, qemuCaps);
803 804 805 806 807 808 809 810 811 812 813 814
        else
            return qemuAssignDeviceDiskAliasFixed(def);
    } else {
        return qemuAssignDeviceDiskAliasLegacy(def);
    }
}


int
qemuAssignDeviceNetAlias(virDomainDefPtr def, virDomainNetDefPtr net, int idx)
{
    if (idx == -1) {
815
        size_t i;
816
        idx = 0;
817
        for (i = 0; i < def->nnets; i++) {
818
            int thisidx;
819 820 821 822 823

            if (def->nets[i]->type == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
                /* type='hostdev' interfaces have a hostdev%d alias */
               continue;
            }
824
            if ((thisidx = qemuDomainDeviceAliasIndex(&def->nets[i]->info, "net")) < 0) {
825 826
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("Unable to determine device index for network device"));
827 828 829 830 831 832 833
                return -1;
            }
            if (thisidx >= idx)
                idx = thisidx + 1;
        }
    }

834 835 836
    if (virAsprintf(&net->info.alias, "net%d", idx) < 0)
        return -1;
    return 0;
837 838 839 840 841 842 843
}


int
qemuAssignDeviceHostdevAlias(virDomainDefPtr def, virDomainHostdevDefPtr hostdev, int idx)
{
    if (idx == -1) {
844
        size_t i;
845
        idx = 0;
846
        for (i = 0; i < def->nhostdevs; i++) {
847
            int thisidx;
848
            if ((thisidx = qemuDomainDeviceAliasIndex(def->hostdevs[i]->info, "hostdev")) < 0) {
849 850
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("Unable to determine device index for hostdev device"));
851 852 853 854 855 856 857
                return -1;
            }
            if (thisidx >= idx)
                idx = thisidx + 1;
        }
    }

858
    if (virAsprintf(&hostdev->info->alias, "hostdev%d", idx) < 0)
859 860 861 862 863 864
        return -1;

    return 0;
}


865 866 867 868
int
qemuAssignDeviceRedirdevAlias(virDomainDefPtr def, virDomainRedirdevDefPtr redirdev, int idx)
{
    if (idx == -1) {
869
        size_t i;
870
        idx = 0;
871
        for (i = 0; i < def->nredirdevs; i++) {
872 873
            int thisidx;
            if ((thisidx = qemuDomainDeviceAliasIndex(&def->redirdevs[i]->info, "redir")) < 0) {
874 875
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("Unable to determine device index for redirected device"));
876 877 878 879 880 881 882
                return -1;
            }
            if (thisidx >= idx)
                idx = thisidx + 1;
        }
    }

883 884 885
    if (virAsprintf(&redirdev->info.alias, "redir%d", idx) < 0)
        return -1;
    return 0;
886 887 888
}


889 890 891 892 893
int
qemuAssignDeviceControllerAlias(virDomainControllerDefPtr controller)
{
    const char *prefix = virDomainControllerTypeToString(controller->type);

894 895 896 897 898 899 900 901 902 903 904 905
    if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
        /* only pcie-root uses a different naming convention
         * ("pcie.0"), because it is hardcoded that way in qemu. All
         * other buses use the consistent "pci.%u".
         */
        if (controller->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT)
            return virAsprintf(&controller->info.alias, "pcie.%d", controller->idx);
        else
            return virAsprintf(&controller->info.alias, "pci.%d", controller->idx);
    }

    return virAsprintf(&controller->info.alias, "%s%d", prefix, controller->idx);
906 907
}

908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
static ssize_t
qemuGetNextChrDevIndex(virDomainDefPtr def,
                       virDomainChrDefPtr chr,
                       const char *prefix)
{
    virDomainChrDefPtr **arrPtr;
    size_t *cntPtr;
    size_t i;
    ssize_t idx = 0;
    const char *prefix2 = NULL;

    if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE)
        prefix2 = "serial";

    virDomainChrGetDomainPtrs(def, chr, &arrPtr, &cntPtr);

    for (i = 0; i < *cntPtr; i++) {
        ssize_t thisidx;
        if (((thisidx = qemuDomainDeviceAliasIndex(&(*arrPtr)[i]->info, prefix)) < 0) &&
            (prefix2 &&
             (thisidx = qemuDomainDeviceAliasIndex(&(*arrPtr)[i]->info, prefix2)) < 0)) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Unable to determine device index for character device"));
            return -1;
        }
        if (thisidx >= idx)
            idx = thisidx + 1;
    }

    return idx;
}


941
int
942
qemuAssignDeviceChrAlias(virDomainDefPtr def,
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968
                         virDomainChrDefPtr chr,
                         ssize_t idx)
{
    const char *prefix = NULL;

    switch ((enum virDomainChrDeviceType) chr->deviceType) {
    case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
        prefix = "parallel";
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL:
        prefix = "serial";
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
        prefix = "console";
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
        prefix = "channel";
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_LAST:
        return -1;
    }

969 970 971
    if (idx == -1 && (idx = qemuGetNextChrDevIndex(def, chr, prefix)) < 0)
        return -1;

972 973
    return virAsprintf(&chr->info.alias, "%s%zd", prefix, idx);
}
974

975
int
976
qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
977
{
978
    size_t i;
979

980
    for (i = 0; i < def->ndisks; i++) {
981
        if (qemuAssignDeviceDiskAlias(def, def->disks[i], qemuCaps) < 0)
982 983
            return -1;
    }
984 985
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NET_NAME) ||
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
986
        for (i = 0; i < def->nnets; i++) {
987 988 989 990 991
            /* type='hostdev' interfaces are also on the hostdevs list,
             * and will have their alias assigned with other hostdevs.
             */
            if ((def->nets[i]->type != VIR_DOMAIN_NET_TYPE_HOSTDEV) &&
                (qemuAssignDeviceNetAlias(def, def->nets[i], i) < 0)) {
992
                return -1;
993
            }
994 995 996
        }
    }

997
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
998 999
        return 0;

1000
    for (i = 0; i < def->nfss; i++) {
1001
        if (virAsprintf(&def->fss[i]->info.alias, "fs%zu", i) < 0)
1002
            return -1;
1003
    }
1004
    for (i = 0; i < def->nsounds; i++) {
1005
        if (virAsprintf(&def->sounds[i]->info.alias, "sound%zu", i) < 0)
1006
            return -1;
1007
    }
1008
    for (i = 0; i < def->nhostdevs; i++) {
1009 1010 1011
        if (qemuAssignDeviceHostdevAlias(def, def->hostdevs[i], i) < 0)
            return -1;
    }
1012
    for (i = 0; i < def->nredirdevs; i++) {
1013 1014 1015
        if (qemuAssignDeviceRedirdevAlias(def, def->redirdevs[i], i) < 0)
            return -1;
    }
1016
    for (i = 0; i < def->nvideos; i++) {
1017
        if (virAsprintf(&def->videos[i]->info.alias, "video%zu", i) < 0)
1018
            return -1;
1019
    }
1020
    for (i = 0; i < def->ncontrollers; i++) {
1021 1022 1023
        if (qemuAssignDeviceControllerAlias(def->controllers[i]) < 0)
            return -1;
    }
1024
    for (i = 0; i < def->ninputs; i++) {
1025
        if (virAsprintf(&def->inputs[i]->info.alias, "input%zu", i) < 0)
1026
            return -1;
1027
    }
1028
    for (i = 0; i < def->nparallels; i++) {
1029
        if (qemuAssignDeviceChrAlias(def, def->parallels[i], i) < 0)
1030
            return -1;
1031
    }
1032
    for (i = 0; i < def->nserials; i++) {
1033
        if (qemuAssignDeviceChrAlias(def, def->serials[i], i) < 0)
1034
            return -1;
1035
    }
1036
    for (i = 0; i < def->nchannels; i++) {
1037
        if (qemuAssignDeviceChrAlias(def, def->channels[i], i) < 0)
1038
            return -1;
1039
    }
1040
    for (i = 0; i < def->nconsoles; i++) {
1041
        if (qemuAssignDeviceChrAlias(def, def->consoles[i], i) < 0)
1042
            return -1;
E
Eric Blake 已提交
1043
    }
1044
    for (i = 0; i < def->nhubs; i++) {
1045
        if (virAsprintf(&def->hubs[i]->info.alias, "hub%zu", i) < 0)
1046
            return -1;
M
Marc-André Lureau 已提交
1047
    }
1048
    for (i = 0; i < def->nsmartcards; i++) {
1049
        if (virAsprintf(&def->smartcards[i]->info.alias, "smartcard%zu", i) < 0)
1050
            return -1;
1051 1052 1053
    }
    if (def->watchdog) {
        if (virAsprintf(&def->watchdog->info.alias, "watchdog%d", 0) < 0)
1054
            return -1;
1055 1056 1057
    }
    if (def->memballoon) {
        if (virAsprintf(&def->memballoon->info.alias, "balloon%d", 0) < 0)
1058
            return -1;
1059
    }
1060 1061
    if (def->rng) {
        if (virAsprintf(&def->rng->info.alias, "rng%d", 0) < 0)
1062
            return -1;
1063
    }
1064 1065
    if (def->tpm) {
        if (virAsprintf(&def->tpm->info.alias, "tpm%d", 0) < 0)
1066
            return -1;
1067
    }
1068 1069 1070 1071

    return 0;
}

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
/* S390 ccw bus support */

struct _qemuDomainCCWAddressSet {
    virHashTablePtr defined;
    virDomainDeviceCCWAddress next;
};

static char*
qemuCCWAddressAsString(virDomainDeviceCCWAddressPtr addr)
{
    char *addrstr = NULL;

1084 1085 1086 1087
    ignore_value(virAsprintf(&addrstr, "%x.%x.%04x",
                             addr->cssid,
                             addr->ssid,
                             addr->devno));
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
    return addrstr;
}

static int
qemuCCWAdressIncrement(virDomainDeviceCCWAddressPtr addr)
{
    virDomainDeviceCCWAddress ccwaddr = *addr;

    /* We are not touching subchannel sets and channel subsystems */
    if (++ccwaddr.devno > VIR_DOMAIN_DEVICE_CCW_MAX_DEVNO)
        return -1;

    *addr = ccwaddr;
    return 0;
}

static void
qemuDomainCCWAddressSetFreeEntry(void *payload,
                                 const void *name ATTRIBUTE_UNUSED)
{
    VIR_FREE(payload);
}

int qemuDomainCCWAddressAssign(virDomainDeviceInfoPtr dev,
                               qemuDomainCCWAddressSetPtr addrs,
                               bool autoassign)
{
    int ret = -1;
    char *addr = NULL;

    if (dev->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW)
        return 0;

    if (!autoassign && dev->addr.ccw.assigned) {
        if (!(addr = qemuCCWAddressAsString(&dev->addr.ccw)))
            goto cleanup;

        if (virHashLookup(addrs->defined, addr)) {
            virReportError(VIR_ERR_XML_ERROR,
                           _("The CCW devno '%s' is in use already "),
                           addr);
            goto cleanup;
        }
    } else if (autoassign && !dev->addr.ccw.assigned) {
        if (!(addr = qemuCCWAddressAsString(&addrs->next)) < 0)
            goto cleanup;

        while (virHashLookup(addrs->defined, addr)) {
            if (qemuCCWAdressIncrement(&addrs->next) < 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("There are no more free CCW devnos."));
                goto cleanup;
            }
            VIR_FREE(addr);
            addr = qemuCCWAddressAsString(&addrs->next);
        }
        dev->addr.ccw = addrs->next;
        dev->addr.ccw.assigned = true;
    } else {
        return 0;
    }

    if (virHashAddEntry(addrs->defined,addr,addr) < 0)
        goto cleanup;
    else
        addr = NULL; /* memory will be freed by hash table */

    ret = 0;

cleanup:
    VIR_FREE(addr);
    return ret;
}

1162
static void
1163 1164
qemuDomainPrimeVirtioDeviceAddresses(virDomainDefPtr def,
                                     enum virDomainDeviceAddressType type)
1165 1166 1167
{
    /*
       declare address-less virtio devices to be of address type 'type'
1168 1169
       disks, networks, consoles, controllers, memballoon and rng in this
       order
1170
    */
1171
    size_t i;
1172

1173
    for (i = 0; i < def->ndisks; i++) {
1174 1175 1176 1177 1178
        if (def->disks[i]->bus == VIR_DOMAIN_DISK_BUS_VIRTIO &&
            def->disks[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
            def->disks[i]->info.type = type;
    }

1179
    for (i = 0; i < def->nnets; i++) {
1180
        if (STREQ(def->nets[i]->model,"virtio") &&
1181
            def->nets[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
1182
            def->nets[i]->info.type = type;
1183
        }
1184 1185
    }

1186
    for (i = 0; i < def->ncontrollers; i++) {
1187 1188 1189 1190
        if ((def->controllers[i]->type ==
             VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL ||
             def->controllers[i]->type ==
             VIR_DOMAIN_CONTROLLER_TYPE_SCSI) &&
1191 1192 1193 1194 1195
            def->controllers[i]->info.type ==
            VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
            def->controllers[i]->info.type = type;
    }

1196 1197 1198 1199
    if (def->memballoon &&
        def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO &&
        def->memballoon->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
        def->memballoon->info.type = type;
1200 1201 1202 1203 1204

    if (def->rng &&
        def->rng->model == VIR_DOMAIN_RNG_MODEL_VIRTIO &&
        def->rng->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
        def->rng->info.type = type;
1205 1206
}

1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
static int
qemuDomainCCWAddressAllocate(virDomainDefPtr def ATTRIBUTE_UNUSED,
                             virDomainDeviceDefPtr dev ATTRIBUTE_UNUSED,
                             virDomainDeviceInfoPtr info,
                             void *data)
{
    return qemuDomainCCWAddressAssign(info, data, true);
}

static int
qemuDomainCCWAddressValidate(virDomainDefPtr def ATTRIBUTE_UNUSED,
                             virDomainDeviceDefPtr dev ATTRIBUTE_UNUSED,
                             virDomainDeviceInfoPtr info,
                             void *data)
{
    return qemuDomainCCWAddressAssign(info, data, false);
}

1225 1226 1227
static int
qemuDomainCCWAddressReleaseAddr(qemuDomainCCWAddressSetPtr addrs,
                                virDomainDeviceInfoPtr dev)
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
{
    char *addr;
    int ret;

    addr = qemuCCWAddressAsString(&(dev->addr.ccw));
    if (!addr)
        return -1;

    if ((ret = virHashRemoveEntry(addrs->defined, addr)) == 0 &&
        dev->addr.ccw.cssid == addrs->next.cssid &&
        dev->addr.ccw.ssid == addrs->next.ssid &&
        dev->addr.ccw.devno < addrs->next.devno) {
        addrs->next.devno = dev->addr.ccw.devno;
        addrs->next.assigned = false;
    }

    VIR_FREE(addr);

    return ret;
}

void qemuDomainCCWAddressSetFree(qemuDomainCCWAddressSetPtr addrs)
{
    if (!addrs)
        return;

    virHashFree(addrs->defined);
    VIR_FREE(addrs);
}

static qemuDomainCCWAddressSetPtr
qemuDomainCCWAddressSetCreate(void)
{
     qemuDomainCCWAddressSetPtr addrs = NULL;

    if (VIR_ALLOC(addrs) < 0)
1264
        goto cleanup;
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290

    if (!(addrs->defined = virHashCreate(10, qemuDomainCCWAddressSetFreeEntry)))
        goto cleanup;

    /* must use cssid = 0xfe (254) for virtio-ccw devices */
    addrs->next.cssid = 254;
    addrs->next.ssid = 0;
    addrs->next.devno = 0;
    addrs->next.assigned = 0;
    return addrs;

cleanup:
    qemuDomainCCWAddressSetFree(addrs);
    return addrs;
}

/*
 * Three steps populating CCW devnos
 * 1. Allocate empty address set
 * 2. Gather addresses with explicit devno
 * 3. Assign defaults to the rest
 */
static int
qemuDomainAssignS390Addresses(virDomainDefPtr def,
                              virQEMUCapsPtr qemuCaps,
                              virDomainObjPtr obj)
1291
{
1292 1293 1294 1295 1296 1297
    int ret = -1;
    qemuDomainCCWAddressSetPtr addrs = NULL;
    qemuDomainObjPrivatePtr priv = NULL;

    if (STREQLEN(def->os.machine, "s390-ccw", 8) &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_CCW)) {
1298
        qemuDomainPrimeVirtioDeviceAddresses(
1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
            def, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW);

        if (!(addrs = qemuDomainCCWAddressSetCreate()))
            goto cleanup;

        if (virDomainDeviceInfoIterate(def, qemuDomainCCWAddressValidate,
                                       addrs) < 0)
            goto cleanup;

        if (virDomainDeviceInfoIterate(def, qemuDomainCCWAddressAllocate,
                                       addrs) < 0)
            goto cleanup;
    } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390)) {
        /* deal with legacy virtio-s390 */
1313
        qemuDomainPrimeVirtioDeviceAddresses(
1314
            def, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390);
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
    }

    if (obj && obj->privateData) {
        priv = obj->privateData;
        if (addrs) {
            /* if this is the live domain object, we persist the CCW addresses*/
            qemuDomainCCWAddressSetFree(priv->ccwaddrs);
            priv->persistentAddrs = 1;
            priv->ccwaddrs = addrs;
            addrs = NULL;
        } else {
            priv->persistentAddrs = 0;
        }
    }
    ret = 0;

cleanup:
    qemuDomainCCWAddressSetFree(addrs);

    return ret;
1335
}
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
static int
qemuDomainAssignARMVirtioMMIOAddresses(virDomainDefPtr def,
                                       virQEMUCapsPtr qemuCaps)
{
    if (def->os.arch == VIR_ARCH_ARMV7L &&
        STRPREFIX(def->os.machine, "vexpress-") &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_MMIO)) {
        qemuDomainPrimeVirtioDeviceAddresses(
            def, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO);
    }
    return 0;
}
1348

1349 1350
static int
qemuSpaprVIOFindByReg(virDomainDefPtr def ATTRIBUTE_UNUSED,
1351
                      virDomainDeviceDefPtr device ATTRIBUTE_UNUSED,
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372
                      virDomainDeviceInfoPtr info, void *opaque)
{
    virDomainDeviceInfoPtr target = opaque;

    if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO)
        return 0;

    /* Match a dev that has a reg, is not us, and has a matching reg */
    if (info->addr.spaprvio.has_reg && info != target &&
        info->addr.spaprvio.reg == target->addr.spaprvio.reg)
        /* Has to be < 0 so virDomainDeviceInfoIterate() will exit */
        return -1;

    return 0;
}

static int
qemuAssignSpaprVIOAddress(virDomainDefPtr def, virDomainDeviceInfoPtr info,
                          unsigned long long default_reg)
{
    bool user_reg;
1373
    int ret;
1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384

    if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO)
        return 0;

    /* Check if the user has assigned the reg already, if so use it */
    user_reg = info->addr.spaprvio.has_reg;
    if (!user_reg) {
        info->addr.spaprvio.reg = default_reg;
        info->addr.spaprvio.has_reg = true;
    }

1385 1386
    ret = virDomainDeviceInfoIterate(def, qemuSpaprVIOFindByReg, info);
    while (ret != 0) {
1387
        if (user_reg) {
1388 1389 1390
            virReportError(VIR_ERR_XML_ERROR,
                           _("spapr-vio address %#llx already in use"),
                           info->addr.spaprvio.reg);
1391 1392 1393 1394 1395
            return -EEXIST;
        }

        /* We assigned the reg, so try a new value */
        info->addr.spaprvio.reg += 0x1000;
1396
        ret = virDomainDeviceInfoIterate(def, qemuSpaprVIOFindByReg, info);
1397 1398 1399 1400 1401
    }

    return 0;
}

1402
int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
1403
                                      virQEMUCapsPtr qemuCaps)
1404
{
1405 1406
    size_t i;
    int ret = -1;
1407
    int model;
1408 1409 1410

    /* Default values match QEMU. See spapr_(llan|vscsi|vty).c */

1411
    for (i = 0; i < def->nnets; i++) {
1412 1413 1414
        if (def->nets[i]->model &&
            STREQ(def->nets[i]->model, "spapr-vlan"))
            def->nets[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
1415
        if (qemuAssignSpaprVIOAddress(def, &def->nets[i]->info,
1416
                                      VIO_ADDR_NET) < 0)
1417
            goto cleanup;
1418 1419
    }

1420
    for (i = 0; i < def->ncontrollers; i++) {
1421
        model = def->controllers[i]->model;
1422
        if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
1423
            if (qemuSetScsiControllerModel(def, qemuCaps, &model) < 0)
1424 1425 1426
                goto cleanup;
        }

1427
        if (model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI &&
1428
            def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI)
1429
            def->controllers[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
1430
        if (qemuAssignSpaprVIOAddress(def, &def->controllers[i]->info,
1431
                                      VIO_ADDR_SCSI) < 0)
1432
            goto cleanup;
1433 1434
    }

1435
    for (i = 0; i < def->nserials; i++) {
1436
        if (def->serials[i]->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL &&
1437
            (def->os.arch == VIR_ARCH_PPC64) &&
1438 1439
            STREQ(def->os.machine, "pseries"))
            def->serials[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
1440
        if (qemuAssignSpaprVIOAddress(def, &def->serials[i]->info,
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
                                      VIO_ADDR_SERIAL) < 0)
            goto cleanup;
    }

    if (def->nvram) {
        if (def->os.arch == VIR_ARCH_PPC64 &&
            STREQ(def->os.machine, "pseries"))
            def->nvram->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
        if (qemuAssignSpaprVIOAddress(def, &def->nvram->info,
                                      VIO_ADDR_NVRAM) < 0)
1451
            goto cleanup;
1452 1453 1454 1455
    }

    /* No other devices are currently supported on spapr-vio */

1456
    ret = 0;
1457 1458

cleanup:
1459
    return ret;
1460
}
1461

1462 1463
#define QEMU_PCI_ADDRESS_SLOT_LAST 31
#define QEMU_PCI_ADDRESS_FUNCTION_LAST 7
1464

1465
typedef struct {
1466 1467 1468 1469 1470 1471 1472 1473 1474
    virDomainControllerModelPCI model;
    /* flags an min/max can be computed from model, but
     * having them ready makes life easier.
     */
    qemuDomainPCIConnectFlags flags;
    size_t minSlot, maxSlot; /* usually 0,0 or 1,31 */
    /* Each bit in a slot represents one function on that slot. If the
     * bit is set, that function is in use by a device.
     */
1475
    uint8_t slots[QEMU_PCI_ADDRESS_SLOT_LAST + 1];
1476 1477 1478
} qemuDomainPCIAddressBus;
typedef qemuDomainPCIAddressBus *qemuDomainPCIAddressBusPtr;

1479
struct _qemuDomainPCIAddressSet {
1480 1481
    qemuDomainPCIAddressBus *buses;
    size_t nbuses;
1482
    virDevicePCIAddress lastaddr;
1483
    qemuDomainPCIConnectFlags lastFlags;
1484 1485
    bool dryRun;          /* on a dry run, new buses are auto-added
                             and addresses aren't saved in device infos */
1486 1487 1488
};


1489 1490
static bool
qemuDomainPCIAddressFlagsCompatible(virDevicePCIAddressPtr addr,
1491
                                    const char *addrStr,
1492 1493
                                    qemuDomainPCIConnectFlags busFlags,
                                    qemuDomainPCIConnectFlags devFlags,
1494 1495
                                    bool reportError,
                                    bool fromConfig)
1496
{
1497 1498 1499
    virErrorNumber errType = (fromConfig
                              ? VIR_ERR_XML_ERROR : VIR_ERR_INTERNAL_ERROR);

1500 1501 1502 1503 1504 1505 1506
    /* If this bus doesn't allow the type of connection (PCI
     * vs. PCIe) required by the device, or if the device requires
     * hot-plug and this bus doesn't have it, return false.
     */
    if (!(devFlags & busFlags & QEMU_PCI_CONNECT_TYPES_MASK)) {
        if (reportError) {
            if (devFlags & QEMU_PCI_CONNECT_TYPE_PCI) {
1507 1508 1509 1510 1511
                virReportError(errType,
                               _("PCI bus is not compatible with the device "
                                 "at %s. Device requires a standard PCI slot, "
                                 "which is not provided by bus %.4x:%.2x"),
                               addrStr, addr->domain, addr->bus);
L
Laine Stump 已提交
1512
            } else if (devFlags & QEMU_PCI_CONNECT_TYPE_PCIE) {
1513 1514 1515 1516 1517
                virReportError(errType,
                               _("PCI bus is not compatible with the device "
                                 "at %s. Device requires a PCI Express slot, "
                                 "which is not provided by bus %.4x:%.2x"),
                               addrStr, addr->domain, addr->bus);
1518 1519 1520 1521
            } else {
                /* this should never happen. If it does, there is a
                 * bug in the code that sets the flag bits for devices.
                 */
1522 1523 1524
                virReportError(errType,
                           _("The device information for %s has no PCI "
                             "connection types listed"), addrStr);
1525 1526 1527 1528 1529 1530 1531
            }
        }
        return false;
    }
    if ((devFlags & QEMU_PCI_CONNECT_HOTPLUGGABLE) &&
        !(busFlags & QEMU_PCI_CONNECT_HOTPLUGGABLE)) {
        if (reportError) {
1532 1533 1534 1535 1536
            virReportError(errType,
                           _("PCI bus is not compatible with the device "
                             "at %s. Device requires hot-plug capability, "
                             "which is not provided by bus %.4x:%.2x"),
                           addrStr, addr->domain, addr->bus);
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
        }
        return false;
    }
    return true;
}


/* Verify that the address is in bounds for the chosen bus, and
 * that the bus is of the correct type for the device (via
 * comparing the flags).
1547
 */
1548
static bool
1549 1550
qemuDomainPCIAddressValidate(qemuDomainPCIAddressSetPtr addrs,
                             virDevicePCIAddressPtr addr,
1551 1552 1553
                             const char *addrStr,
                             qemuDomainPCIConnectFlags flags,
                             bool fromConfig)
1554
{
1555
    qemuDomainPCIAddressBusPtr bus;
1556 1557
    virErrorNumber errType = (fromConfig
                              ? VIR_ERR_XML_ERROR : VIR_ERR_INTERNAL_ERROR);
1558

1559
    if (addrs->nbuses == 0) {
1560
        virReportError(errType, "%s", _("No PCI buses available"));
1561 1562
        return false;
    }
1563
    if (addr->domain != 0) {
1564 1565 1566 1567
        virReportError(errType,
                       _("Invalid PCI address %s. "
                         "Only PCI domain 0 is available"),
                       addrStr);
1568 1569
        return false;
    }
1570
    if (addr->bus >= addrs->nbuses) {
1571 1572 1573 1574
        virReportError(errType,
                       _("Invalid PCI address %s. "
                         "Only PCI buses up to %zu are available"),
                       addrStr, addrs->nbuses - 1);
1575 1576
        return false;
    }
1577 1578 1579 1580 1581 1582

    bus = &addrs->buses[addr->bus];

    /* assure that at least one of the requested connection types is
     * provided by this bus
     */
1583 1584
    if (!qemuDomainPCIAddressFlagsCompatible(addr, addrStr, bus->flags,
                                             flags, true, fromConfig))
1585
        return false;
1586

1587 1588
    /* some "buses" are really just a single port */
    if (bus->minSlot && addr->slot < bus->minSlot) {
1589 1590 1591
        virReportError(errType,
                       _("Invalid PCI address %s. slot must be >= %zu"),
                       addrStr, bus->minSlot);
1592 1593 1594
        return false;
    }
    if (addr->slot > bus->maxSlot) {
1595 1596 1597
        virReportError(errType,
                       _("Invalid PCI address %s. slot must be <= %zu"),
                       addrStr, bus->maxSlot);
1598 1599 1600
        return false;
    }
    if (addr->function > QEMU_PCI_ADDRESS_FUNCTION_LAST) {
1601 1602 1603
        virReportError(errType,
                       _("Invalid PCI address %s. function must be <= %u"),
                       addrStr, QEMU_PCI_ADDRESS_FUNCTION_LAST);
1604 1605
        return false;
    }
1606 1607 1608
    return true;
}

1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621

static int
qemuDomainPCIAddressBusSetModel(qemuDomainPCIAddressBusPtr bus,
                                virDomainControllerModelPCI model)
{
    switch (model) {
    case VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE:
    case VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT:
        bus->flags = (QEMU_PCI_CONNECT_HOTPLUGGABLE |
                      QEMU_PCI_CONNECT_TYPE_PCI);
        bus->minSlot = 1;
        bus->maxSlot = QEMU_PCI_ADDRESS_SLOT_LAST;
        break;
L
Laine Stump 已提交
1622 1623 1624 1625 1626 1627
    case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT:
        /* slots 1 - 31, PCIe devices only, no hotplug */
        bus->flags = QEMU_PCI_CONNECT_TYPE_PCIE;
        bus->minSlot = 1;
        bus->maxSlot = QEMU_PCI_ADDRESS_SLOT_LAST;
        break;
1628 1629 1630 1631 1632 1633 1634
    case VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE:
        /* slots 1 - 31, standard PCI slots,
         * but *not* hot-pluggable */
        bus->flags = QEMU_PCI_CONNECT_TYPE_PCI;
        bus->minSlot = 1;
        bus->maxSlot = QEMU_PCI_ADDRESS_SLOT_LAST;
        break;
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
    default:
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Invalid PCI controller model %d"), model);
        return -1;
    }

    bus->model = model;
    return 0;
}


1646
/* Ensure addr fits in the address set, by expanding it if needed.
1647 1648 1649 1650
 * This will only grow if the flags say that we need a normal
 * hot-pluggable PCI slot. If we need a different type of slot, it
 * will fail.
 *
1651 1652 1653 1654 1655 1656 1657
 * Return value:
 * -1 = OOM
 *  0 = no action performed
 * >0 = number of buses added
 */
static int
qemuDomainPCIAddressSetGrow(qemuDomainPCIAddressSetPtr addrs,
1658 1659
                            virDevicePCIAddressPtr addr,
                            qemuDomainPCIConnectFlags flags)
1660
{
1661 1662
    int add;
    size_t i;
1663 1664 1665 1666 1667

    add = addr->bus - addrs->nbuses + 1;
    i = addrs->nbuses;
    if (add <= 0)
        return 0;
1668 1669 1670 1671 1672 1673 1674 1675 1676

    /* auto-grow only works when we're adding plain PCI devices */
    if (!(flags & QEMU_PCI_CONNECT_TYPE_PCI)) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Cannot automatically add a new PCI bus for a "
                         "device requiring a slot other than standard PCI."));
        return -1;
    }

1677
    if (VIR_EXPAND_N(addrs->buses, addrs->nbuses, add) < 0)
1678
        return -1;
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688

    for (; i < addrs->nbuses; i++) {
        /* Any time we auto-add a bus, we will want a multi-slot
         * bus. Currently the only type of bus we will auto-add is a
         * pci-bridge, which is hot-pluggable and provides standard
         * PCI slots.
         */
        qemuDomainPCIAddressBusSetModel(&addrs->buses[i],
                                        VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE);
    }
1689 1690 1691
    return add;
}

1692

1693
static char *
1694
qemuDomainPCIAddressAsString(virDevicePCIAddressPtr addr)
1695
{
1696
    char *str;
1697

1698 1699 1700 1701 1702
    ignore_value(virAsprintf(&str, "%.4x:%.2x:%.2x.%.1x",
                             addr->domain,
                             addr->bus,
                             addr->slot,
                             addr->function));
1703
    return str;
1704 1705 1706
}


1707 1708 1709 1710 1711
static int
qemuCollectPCIAddress(virDomainDefPtr def ATTRIBUTE_UNUSED,
                      virDomainDeviceDefPtr device,
                      virDomainDeviceInfoPtr info,
                      void *opaque)
1712
{
1713
    qemuDomainPCIAddressSetPtr addrs = opaque;
1714
    int ret = -1;
1715
    virDevicePCIAddressPtr addr = &info->addr.pci;
1716
    bool entireSlot;
1717
    /* flags may be changed from default below */
1718 1719
    qemuDomainPCIConnectFlags flags = (QEMU_PCI_CONNECT_HOTPLUGGABLE |
                                       QEMU_PCI_CONNECT_TYPE_PCI);
1720

1721 1722 1723 1724 1725 1726 1727
    if ((info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
        || ((device->type == VIR_DOMAIN_DEVICE_HOSTDEV) &&
            (device->data.hostdev->parent.type != VIR_DOMAIN_DEVICE_NONE))) {
        /* If a hostdev has a parent, its info will be a part of the
         * parent, and will have its address collected during the scan
         * of the parent's device type.
        */
1728
        return 0;
1729
    }
1730

1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742
    /* Change flags according to differing requirements of different
     * devices.
     */
    if (device->type == VIR_DOMAIN_DEVICE_CONTROLLER &&
        device->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
        switch (device->data.controller->model) {
        case VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE:
            /* pci-bridge needs a PCI slot, but it isn't
             * hot-pluggable, so it doesn't need a hot-pluggable slot.
             */
            flags = QEMU_PCI_CONNECT_TYPE_PCI;
            break;
1743 1744 1745 1746 1747 1748
        case VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE:
            /* pci-bridge needs a PCIe slot, but it isn't
             * hot-pluggable, so it doesn't need a hot-pluggable slot.
             */
            flags = QEMU_PCI_CONNECT_TYPE_PCIE;
            break;
1749 1750 1751 1752
        default:
            break;
        }
    }
1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764
    /* SATA controllers aren't hot-plugged, and can be put in either a
     * PCI or PCIe slot
     */
    if (device->type == VIR_DOMAIN_DEVICE_CONTROLLER &&
        device->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA)
        flags = QEMU_PCI_CONNECT_TYPE_PCI | QEMU_PCI_CONNECT_TYPE_PCIE;

    /* video cards aren't hot-plugged, and can be put in either a PCI
     * or PCIe slot
     */
    if (device->type == VIR_DOMAIN_DEVICE_VIDEO)
        flags = QEMU_PCI_CONNECT_TYPE_PCI | QEMU_PCI_CONNECT_TYPE_PCIE;
1765

1766 1767 1768 1769 1770 1771
    /* Ignore implicit controllers on slot 0:0:1.0:
     * implicit IDE controller on 0:0:1.1 (no qemu command line)
     * implicit USB controller on 0:0:1.2 (-usb)
     *
     * If the machine does have a PCI bus, they will get reserved
     * in qemuAssignDevicePCISlots().
1772 1773 1774 1775 1776
     */

    /* These are the IDE and USB controllers in the PIIX3, hardcoded
     * to bus 0 slot 1.  They cannot be attached to a PCIe slot, only
     * PCI.
1777 1778 1779 1780
     */
    if (device->type == VIR_DOMAIN_DEVICE_CONTROLLER && addr->domain == 0 &&
        addr->bus == 0 && addr->slot == 1) {
        virDomainControllerDefPtr cont = device->data.controller;
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802

        if ((cont->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE && cont->idx == 0 &&
             addr->function == 1) ||
            (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB && cont->idx == 0 &&
             (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI ||
              cont->model == -1) && addr->function == 2)) {
            /* Note the check for nbuses > 0 - if there are no PCI
             * buses, we skip this check. This is a quirk required for
             * some machinetypes such as s390, which pretend to have a
             * PCI bus for long enough to generate the "-usb" on the
             * commandline, but that don't really care if a PCI bus
             * actually exists. */
            if (addrs->nbuses > 0 &&
                !(addrs->buses[0].flags & QEMU_PCI_CONNECT_TYPE_PCI)) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("Bus 0 must be PCI for integrated PIIX3 "
                                 "USB or IDE controllers"));
                return -1;
            } else {
                return 0;
            }
        }
1803 1804
    }

1805 1806
    entireSlot = (addr->function == 0 &&
                  addr->multi != VIR_DEVICE_ADDRESS_PCI_MULTI_ON);
1807

1808 1809
    if (qemuDomainPCIAddressReserveAddr(addrs, addr, flags,
                                        entireSlot, true) < 0)
1810
        goto cleanup;
1811

1812 1813 1814
    ret = 0;
cleanup:
    return ret;
1815 1816
}

1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
static bool
qemuDomainSupportsPCI(virDomainDefPtr def) {
    if (def->os.arch != VIR_ARCH_ARMV7L)
        return true;

    if (STREQ(def->os.machine, "versatilepb"))
        return true;

    return false;
}
1827

1828
int
1829
qemuDomainAssignPCIAddresses(virDomainDefPtr def,
1830
                             virQEMUCapsPtr qemuCaps,
1831
                             virDomainObjPtr obj)
1832 1833 1834
{
    int ret = -1;
    qemuDomainPCIAddressSetPtr addrs = NULL;
1835
    qemuDomainObjPrivatePtr priv = NULL;
1836

1837
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
1838
        int max_idx = -1;
1839
        int nbuses = 0;
1840
        size_t i;
1841
        int rv;
1842
        qemuDomainPCIConnectFlags flags = QEMU_PCI_CONNECT_TYPE_PCI;
1843 1844

        for (i = 0; i < def->ncontrollers; i++) {
1845
            if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
1846
                if ((int) def->controllers[i]->idx > max_idx)
1847 1848 1849 1850 1851 1852 1853 1854 1855
                    max_idx = def->controllers[i]->idx;
            }
        }

        nbuses = max_idx + 1;

        if (nbuses > 0 &&
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_PCI_BRIDGE)) {
            virDomainDeviceInfo info;
1856

1857 1858 1859 1860 1861 1862
            /* 1st pass to figure out how many PCI bridges we need */
            if (!(addrs = qemuDomainPCIAddressSetCreate(def, nbuses, true)))
                goto cleanup;
            if (qemuAssignDevicePCISlots(def, qemuCaps, addrs) < 0)
                goto cleanup;
            /* Reserve 1 extra slot for a (potential) bridge */
1863
            if (qemuDomainPCIAddressReserveNextSlot(addrs, &info, flags) < 0)
1864 1865 1866
                goto cleanup;

            for (i = 1; i < addrs->nbuses; i++) {
1867 1868
                qemuDomainPCIAddressBusPtr bus = &addrs->buses[i];

1869
                if ((rv = virDomainDefMaybeAddController(
1870 1871
                         def, VIR_DOMAIN_CONTROLLER_TYPE_PCI,
                         i, bus->model)) < 0)
1872 1873
                    goto cleanup;
                /* If we added a new bridge, we will need one more address */
1874 1875
                if (rv > 0 && qemuDomainPCIAddressReserveNextSlot(addrs, &info,
                                                                  flags) < 0)
1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
                        goto cleanup;
            }
            nbuses = addrs->nbuses;
            qemuDomainPCIAddressSetFree(addrs);
            addrs = NULL;

        } else if (max_idx > 0) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("PCI bridges are not supported "
                             "by this QEMU binary"));
            goto cleanup;
1887 1888
        }

1889
        if (!(addrs = qemuDomainPCIAddressSetCreate(def, nbuses, false)))
1890 1891
            goto cleanup;

1892 1893 1894 1895
        if (qemuDomainSupportsPCI(def)) {
            if (qemuAssignDevicePCISlots(def, qemuCaps, addrs) < 0)
                goto cleanup;
        }
1896 1897
    }

1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910
    if (obj && obj->privateData) {
        priv = obj->privateData;
        if (addrs) {
            /* if this is the live domain object, we persist the PCI addresses*/
            qemuDomainPCIAddressSetFree(priv->pciaddrs);
            priv->persistentAddrs = 1;
            priv->pciaddrs = addrs;
            addrs = NULL;
        } else {
            priv->persistentAddrs = 0;
        }
    }

1911 1912 1913 1914 1915 1916 1917 1918
    ret = 0;

cleanup:
    qemuDomainPCIAddressSetFree(addrs);

    return ret;
}

1919
int qemuDomainAssignAddresses(virDomainDefPtr def,
1920
                              virQEMUCapsPtr qemuCaps,
1921
                              virDomainObjPtr obj)
1922
{
1923 1924
    int rc;

1925
    rc = qemuDomainAssignSpaprVIOAddresses(def, qemuCaps);
1926 1927 1928
    if (rc)
        return rc;

1929 1930 1931
    rc = qemuDomainAssignS390Addresses(def, qemuCaps, obj);
    if (rc)
        return rc;
1932

1933 1934 1935 1936
    rc = qemuDomainAssignARMVirtioMMIOAddresses(def, qemuCaps);
    if (rc)
        return rc;

1937
    return qemuDomainAssignPCIAddresses(def, qemuCaps, obj);
1938
}
1939

1940 1941 1942 1943 1944

qemuDomainPCIAddressSetPtr
qemuDomainPCIAddressSetCreate(virDomainDefPtr def,
                              unsigned int nbuses,
                              bool dryRun)
1945 1946
{
    qemuDomainPCIAddressSetPtr addrs;
1947
    size_t i;
1948 1949

    if (VIR_ALLOC(addrs) < 0)
1950
        goto error;
1951

1952
    if (VIR_ALLOC_N(addrs->buses, nbuses) < 0)
1953
        goto error;
1954

1955
    addrs->nbuses = nbuses;
1956
    addrs->dryRun = dryRun;
1957

1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989
    /* As a safety measure, set default model='pci-root' for first pci
     * controller and 'pci-bridge' for all subsequent. After setting
     * those defaults, then scan the config and set the actual model
     * for all addrs[idx]->bus that already have a corresponding
     * controller in the config.
     *
     */
    if (nbuses > 0)
       qemuDomainPCIAddressBusSetModel(&addrs->buses[0],
                                       VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT);
    for (i = 1; i < nbuses; i++) {
        qemuDomainPCIAddressBusSetModel(&addrs->buses[i],
                                        VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE);
    }

    for (i = 0; i < def->ncontrollers; i++) {
        size_t idx = def->controllers[i]->idx;

        if (def->controllers[i]->type != VIR_DOMAIN_CONTROLLER_TYPE_PCI)
            continue;

        if (idx >= addrs->nbuses) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Inappropriate new pci controller index %zu "
                             "not found in addrs"), idx);
            goto error;
        }

        if (qemuDomainPCIAddressBusSetModel(&addrs->buses[idx],
                                            def->controllers[i]->model) < 0)
            goto error;
        }
1990

1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
    if (virDomainDeviceInfoIterate(def, qemuCollectPCIAddress, addrs) < 0)
        goto error;

    return addrs;

error:
    qemuDomainPCIAddressSetFree(addrs);
    return NULL;
}

J
Ján Tomko 已提交
2001 2002
/*
 * Check if the PCI slot is used by another device.
2003
 */
J
Ján Tomko 已提交
2004 2005
static bool qemuDomainPCIAddressSlotInUse(qemuDomainPCIAddressSetPtr addrs,
                                          virDevicePCIAddressPtr addr)
2006
{
2007
    return !!addrs->buses[addr->bus].slots[addr->slot];
2008 2009
}

2010

2011 2012 2013 2014 2015 2016 2017 2018 2019
/*
 * Reserve a slot (or just one function) for a device. If
 * reserveEntireSlot is true, all functions for the slot are reserved,
 * otherwise only one. If fromConfig is true, the address being
 * requested came directly from the config and errors should be worded
 * appropriately. If fromConfig is false, the address was
 * automatically created by libvirt, so it is an internal error (not
 * XML).
 */
2020 2021 2022
int
qemuDomainPCIAddressReserveAddr(qemuDomainPCIAddressSetPtr addrs,
                                virDevicePCIAddressPtr addr,
2023 2024 2025
                                qemuDomainPCIConnectFlags flags,
                                bool reserveEntireSlot,
                                bool fromConfig)
2026
{
2027
    int ret = -1;
2028
    char *addrStr = NULL;
2029
    qemuDomainPCIAddressBusPtr bus;
2030 2031
    virErrorNumber errType = (fromConfig
                              ? VIR_ERR_XML_ERROR : VIR_ERR_INTERNAL_ERROR);
2032

2033
    if (!(addrStr = qemuDomainPCIAddressAsString(addr)))
2034
        goto cleanup;
2035

2036 2037 2038 2039 2040 2041
    /* Add an extra bus if necessary */
    if (addrs->dryRun && qemuDomainPCIAddressSetGrow(addrs, addr, flags) < 0)
        goto cleanup;
    /* Check that the requested bus exists, is the correct type, and we
     * are asking for a valid slot
     */
2042
    if (!qemuDomainPCIAddressValidate(addrs, addr, addrStr, flags, fromConfig))
2043
        goto cleanup;
2044

2045 2046
    bus = &addrs->buses[addr->bus];

2047 2048 2049 2050 2051
    if (reserveEntireSlot) {
        if (bus->slots[addr->slot]) {
            virReportError(errType,
                           _("Attempted double use of PCI slot %s "
                             "(may need \"multifunction='on'\" for "
2052
                             "device on function 0)"), addrStr);
2053 2054 2055
            goto cleanup;
        }
        bus->slots[addr->slot] = 0xFF; /* reserve all functions of slot */
2056
        VIR_DEBUG("Reserving PCI slot %s (multifunction='off')", addrStr);
2057 2058 2059 2060
    } else {
        if (bus->slots[addr->slot] & (1 << addr->function)) {
            if (addr->function == 0) {
                virReportError(errType,
2061 2062
                               _("Attempted double use of PCI Address %s"),
                               addrStr);
2063 2064 2065 2066
            } else {
                virReportError(errType,
                               _("Attempted double use of PCI Address %s "
                                 "(may need \"multifunction='on'\" "
2067
                                 "for device on function 0)"), addrStr);
2068 2069 2070 2071
            }
            goto cleanup;
        }
        bus->slots[addr->slot] |= (1 << addr->function);
2072
        VIR_DEBUG("Reserving PCI address %s", addrStr);
2073 2074
    }

2075 2076
    ret = 0;
cleanup:
2077
    VIR_FREE(addrStr);
2078
    return ret;
2079 2080
}

2081 2082 2083 2084 2085

int
qemuDomainPCIAddressReserveSlot(qemuDomainPCIAddressSetPtr addrs,
                                virDevicePCIAddressPtr addr,
                                qemuDomainPCIConnectFlags flags)
2086
{
2087
    return qemuDomainPCIAddressReserveAddr(addrs, addr, flags, true, false);
2088
}
2089 2090

int qemuDomainPCIAddressEnsureAddr(qemuDomainPCIAddressSetPtr addrs,
O
Osier Yang 已提交
2091
                                   virDomainDeviceInfoPtr dev)
2092
{
2093 2094
    int ret = -1;
    char *addrStr = NULL;
2095 2096 2097 2098 2099
    /* Flags should be set according to the particular device,
     * but only the caller knows the type of device. Currently this
     * function is only used for hot-plug, though, and hot-plug is
     * only supported for standard PCI devices, so we can safely use
     * the setting below */
2100 2101 2102
    qemuDomainPCIConnectFlags flags = (QEMU_PCI_CONNECT_HOTPLUGGABLE |
                                       QEMU_PCI_CONNECT_TYPE_PCI);

2103 2104 2105
    if (!(addrStr = qemuDomainPCIAddressAsString(&dev->addr.pci)))
        goto cleanup;

2106 2107 2108 2109 2110
    if (dev->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
        /* We do not support hotplug multi-function PCI device now, so we should
         * reserve the whole slot. The function of the PCI device must be 0.
         */
        if (dev->addr.pci.function != 0) {
2111 2112 2113
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Only PCI device addresses with function=0"
                             " are supported"));
2114
            goto cleanup;
2115 2116
        }

2117 2118 2119
        if (!qemuDomainPCIAddressValidate(addrs, &dev->addr.pci,
                                          addrStr, flags, true))
            goto cleanup;
2120

2121
        ret = qemuDomainPCIAddressReserveSlot(addrs, &dev->addr.pci, flags);
2122
    } else {
2123
        ret = qemuDomainPCIAddressReserveNextSlot(addrs, dev, flags);
2124
    }
2125 2126 2127

cleanup:
    VIR_FREE(addrStr);
2128 2129 2130 2131 2132
    return ret;
}


int qemuDomainPCIAddressReleaseAddr(qemuDomainPCIAddressSetPtr addrs,
2133
                                    virDevicePCIAddressPtr addr)
2134
{
2135
    addrs->buses[addr->bus].slots[addr->slot] &= ~(1 << addr->function);
2136
    return 0;
2137 2138
}

2139 2140 2141
static int
qemuDomainPCIAddressReleaseSlot(qemuDomainPCIAddressSetPtr addrs,
                                virDevicePCIAddressPtr addr)
2142
{
2143 2144 2145 2146
    /* permit any kind of connection type in validation, since we
     * already had it, and are giving it back.
     */
    qemuDomainPCIConnectFlags flags = QEMU_PCI_CONNECT_TYPES_MASK;
2147 2148
    int ret = -1;
    char *addrStr = NULL;
2149

2150 2151 2152 2153 2154
    if (!(addrStr = qemuDomainPCIAddressAsString(addr)))
        goto cleanup;

    if (!qemuDomainPCIAddressValidate(addrs, addr, addrStr, flags, false))
        goto cleanup;
2155

2156
    addrs->buses[addr->bus].slots[addr->slot] = 0;
2157 2158 2159 2160
    ret = 0;
cleanup:
    VIR_FREE(addrStr);
    return ret;
2161 2162
}

2163 2164 2165 2166 2167
void qemuDomainPCIAddressSetFree(qemuDomainPCIAddressSetPtr addrs)
{
    if (!addrs)
        return;

2168
    VIR_FREE(addrs->buses);
2169 2170 2171 2172
    VIR_FREE(addrs);
}


2173 2174
static int
qemuDomainPCIAddressGetNextSlot(qemuDomainPCIAddressSetPtr addrs,
2175 2176
                                virDevicePCIAddressPtr next_addr,
                                qemuDomainPCIConnectFlags flags)
2177
{
2178 2179 2180 2181
    /* default to starting the search for a free slot from
     * 0000:00:00.0
     */
    virDevicePCIAddress a = { 0, 0, 0, 0, false };
2182
    char *addrStr = NULL;
2183 2184 2185 2186 2187 2188

    /* except if this search is for the exact same type of device as
     * last time, continue the search from the previous match
     */
    if (flags == addrs->lastFlags)
        a = addrs->lastaddr;
2189

2190 2191
    if (addrs->nbuses == 0) {
        virReportError(VIR_ERR_XML_ERROR, "%s", _("No PCI buses available"));
2192
        goto error;
2193
    }
2194

2195 2196
    /* Start the search at the last used bus and slot */
    for (a.slot++; a.bus < addrs->nbuses; a.bus++) {
2197 2198 2199 2200 2201 2202
        addrStr = NULL;
        if (!(addrStr = qemuDomainPCIAddressAsString(&a)))
            goto error;
        if (!qemuDomainPCIAddressFlagsCompatible(&a, addrStr,
                                                 addrs->buses[a.bus].flags,
                                                 flags, false, false)) {
2203 2204 2205 2206
            VIR_DEBUG("PCI bus %.4x:%.2x is not compatible with the device",
                      a.domain, a.bus);
            continue;
        }
2207
        for (; a.slot <= QEMU_PCI_ADDRESS_SLOT_LAST; a.slot++) {
2208 2209
            if (!qemuDomainPCIAddressSlotInUse(addrs, &a))
                goto success;
2210

2211 2212
            VIR_DEBUG("PCI slot %.4x:%.2x:%.2x already in use",
                      a.domain, a.bus, a.slot);
2213
        }
2214 2215
        a.slot = 1;
    }
2216

2217 2218 2219
    /* There were no free slots after the last used one */
    if (addrs->dryRun) {
        /* a is already set to the first new bus and slot 1 */
2220
        if (qemuDomainPCIAddressSetGrow(addrs, &a, flags) < 0)
2221
            goto error;
2222
        goto success;
2223
    } else if (flags == addrs->lastFlags) {
2224 2225
        /* Check the buses from 0 up to the last used one */
        for (a.bus = 0; a.bus <= addrs->lastaddr.bus; a.bus++) {
2226 2227 2228 2229 2230 2231
            addrStr = NULL;
            if (!(addrStr = qemuDomainPCIAddressAsString(&a)))
                goto error;
            if (!qemuDomainPCIAddressFlagsCompatible(&a, addrStr,
                                                     addrs->buses[a.bus].flags,
                                                     flags, false, false)) {
2232 2233 2234 2235
                VIR_DEBUG("PCI bus %.4x:%.2x is not compatible with the device",
                          a.domain, a.bus);
                continue;
            }
2236
            for (a.slot = 1; a.slot <= QEMU_PCI_ADDRESS_SLOT_LAST; a.slot++) {
2237 2238 2239 2240 2241 2242 2243
                if (!qemuDomainPCIAddressSlotInUse(addrs, &a))
                    goto success;

                VIR_DEBUG("PCI slot %.4x:%.2x:%.2x already in use",
                          a.domain, a.bus, a.slot);
            }
        }
2244 2245
    }

2246
    virReportError(VIR_ERR_INTERNAL_ERROR,
2247
                   "%s", _("No more available PCI slots"));
2248 2249
error:
    VIR_FREE(addrStr);
2250
    return -1;
2251 2252 2253 2254 2255

success:
    VIR_DEBUG("Found free PCI slot %.4x:%.2x:%.2x",
              a.domain, a.bus, a.slot);
    *next_addr = a;
2256
    VIR_FREE(addrStr);
2257
    return 0;
2258 2259
}

2260
int
2261 2262 2263
qemuDomainPCIAddressReserveNextSlot(qemuDomainPCIAddressSetPtr addrs,
                                    virDomainDeviceInfoPtr dev,
                                    qemuDomainPCIConnectFlags flags)
2264
{
2265
    virDevicePCIAddress addr;
2266
    if (qemuDomainPCIAddressGetNextSlot(addrs, &addr, flags) < 0)
2267 2268
        return -1;

2269
    if (qemuDomainPCIAddressReserveSlot(addrs, &addr, flags) < 0)
2270 2271
        return -1;

2272 2273 2274 2275
    if (!addrs->dryRun) {
        dev->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
        dev->addr.pci = addr;
    }
2276

2277
    addrs->lastaddr = addr;
2278
    addrs->lastFlags = flags;
2279 2280 2281 2282
    return 0;
}


2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
void
qemuDomainReleaseDeviceAddress(virDomainObjPtr vm,
                               virDomainDeviceInfoPtr info,
                               const char *devstr)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

    if (!devstr)
        devstr = info->alias;

    if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW &&
        STREQLEN(vm->def->os.machine, "s390-ccw", 8) &&
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_CCW) &&
        qemuDomainCCWAddressReleaseAddr(priv->ccwaddrs, info) < 0)
        VIR_WARN("Unable to release CCW address on %s",
                 NULLSTR(devstr));
    else if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI &&
             virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
             qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
                                             &info->addr.pci) < 0)
        VIR_WARN("Unable to release PCI address on %s",
                 NULLSTR(devstr));
}


2308 2309 2310 2311 2312 2313 2314
#define IS_USB2_CONTROLLER(ctrl) \
    (((ctrl)->type == VIR_DOMAIN_CONTROLLER_TYPE_USB) && \
     ((ctrl)->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1 || \
      (ctrl)->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI1 || \
      (ctrl)->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI2 || \
      (ctrl)->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI3))

2315 2316 2317 2318 2319

static int
qemuValidateDevicePCISlotsPIIX3(virDomainDefPtr def,
                                virQEMUCapsPtr qemuCaps,
                                qemuDomainPCIAddressSetPtr addrs)
2320
{
2321
    int ret = -1;
2322
    size_t i;
2323
    virDevicePCIAddress tmp_addr;
2324
    bool qemuDeviceVideoUsable = virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
2325
    virDevicePCIAddressPtr addrptr;
2326
    char *addrStr = NULL;
2327
    qemuDomainPCIConnectFlags flags = QEMU_PCI_CONNECT_HOTPLUGGABLE | QEMU_PCI_CONNECT_TYPE_PCI;
2328

2329
    /* Verify that first IDE and USB controllers (if any) is on the PIIX3, fn 1 */
2330
    for (i = 0; i < def->ncontrollers; i++) {
2331 2332 2333 2334 2335 2336 2337 2338
        /* First IDE controller lives on the PIIX3 at slot=1, function=1 */
        if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE &&
            def->controllers[i]->idx == 0) {
            if (def->controllers[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
                if (def->controllers[i]->info.addr.pci.domain != 0 ||
                    def->controllers[i]->info.addr.pci.bus != 0 ||
                    def->controllers[i]->info.addr.pci.slot != 1 ||
                    def->controllers[i]->info.addr.pci.function != 1) {
2339 2340
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("Primary IDE controller must have PCI address 0:0:1.1"));
2341
                    goto cleanup;
2342 2343 2344 2345 2346 2347 2348 2349
                }
            } else {
                def->controllers[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
                def->controllers[i]->info.addr.pci.domain = 0;
                def->controllers[i]->info.addr.pci.bus = 0;
                def->controllers[i]->info.addr.pci.slot = 1;
                def->controllers[i]->info.addr.pci.function = 1;
            }
2350 2351
        } else if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
                   def->controllers[i]->idx == 0 &&
2352 2353
                   (def->controllers[i]->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI ||
                    def->controllers[i]->model == -1)) {
2354 2355 2356 2357 2358
            if (def->controllers[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
                if (def->controllers[i]->info.addr.pci.domain != 0 ||
                    def->controllers[i]->info.addr.pci.bus != 0 ||
                    def->controllers[i]->info.addr.pci.slot != 1 ||
                    def->controllers[i]->info.addr.pci.function != 2) {
2359 2360
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("PIIX3 USB controller must have PCI address 0:0:1.2"));
2361
                    goto cleanup;
2362 2363 2364 2365 2366 2367 2368 2369
                }
            } else {
                def->controllers[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
                def->controllers[i]->info.addr.pci.domain = 0;
                def->controllers[i]->info.addr.pci.bus = 0;
                def->controllers[i]->info.addr.pci.slot = 1;
                def->controllers[i]->info.addr.pci.function = 2;
            }
2370 2371 2372 2373 2374 2375
        }
    }

    /* PIIX3 (ISA bridge, IDE controller, something else unknown, USB controller)
     * hardcoded slot=1, multifunction device
     */
2376 2377 2378
    if (addrs->nbuses) {
        memset(&tmp_addr, 0, sizeof(tmp_addr));
        tmp_addr.slot = 1;
2379
        if (qemuDomainPCIAddressReserveSlot(addrs, &tmp_addr, flags) < 0)
2380
            goto cleanup;
W
Wen Congyang 已提交
2381
    }
2382 2383

    if (def->nvideos > 0) {
2384 2385 2386 2387 2388 2389
        /* Because the PIIX3 integrated IDE/USB controllers are
         * already at slot 1, when qemu looks for the first free slot
         * to place the VGA controller (which is always the first
         * device added after integrated devices), it *always* ends up
         * at slot 2.
         */
2390 2391 2392 2393 2394 2395 2396
        virDomainVideoDefPtr primaryVideo = def->videos[0];
        if (primaryVideo->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
            primaryVideo->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
            primaryVideo->info.addr.pci.domain = 0;
            primaryVideo->info.addr.pci.bus = 0;
            primaryVideo->info.addr.pci.slot = 2;
            primaryVideo->info.addr.pci.function = 0;
2397
            addrptr = &primaryVideo->info.addr.pci;
2398

2399 2400 2401 2402 2403
            if (!(addrStr = qemuDomainPCIAddressAsString(addrptr)))
                goto cleanup;
            if (!qemuDomainPCIAddressValidate(addrs, addrptr,
                                              addrStr, flags, false))
                goto cleanup;
2404

J
Ján Tomko 已提交
2405
            if (qemuDomainPCIAddressSlotInUse(addrs, addrptr)) {
2406 2407
                if (qemuDeviceVideoUsable) {
                    virResetLastError();
2408 2409 2410
                    if (qemuDomainPCIAddressReserveNextSlot(addrs,
                                                            &primaryVideo->info,
                                                            flags) < 0)
2411
                        goto cleanup;
2412 2413 2414 2415
                } else {
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("PCI address 0:0:2.0 is in use, "
                                     "QEMU needs it for primary video"));
2416
                    goto cleanup;
2417
                }
2418
            } else if (qemuDomainPCIAddressReserveSlot(addrs, addrptr, flags) < 0) {
2419
                goto cleanup;
2420 2421 2422 2423 2424 2425
            }
        } else if (!qemuDeviceVideoUsable) {
            if (primaryVideo->info.addr.pci.domain != 0 ||
                primaryVideo->info.addr.pci.bus != 0 ||
                primaryVideo->info.addr.pci.slot != 2 ||
                primaryVideo->info.addr.pci.function != 0) {
2426 2427
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("Primary video card must have PCI address 0:0:2.0"));
2428
                goto cleanup;
2429
            }
2430 2431
            /* If TYPE==PCI, then qemuCollectPCIAddress() function
             * has already reserved the address, so we must skip */
2432
        }
2433
    } else if (addrs->nbuses && !qemuDeviceVideoUsable) {
2434 2435
        memset(&tmp_addr, 0, sizeof(tmp_addr));
        tmp_addr.slot = 2;
2436

J
Ján Tomko 已提交
2437
        if (qemuDomainPCIAddressSlotInUse(addrs, &tmp_addr)) {
2438 2439 2440 2441
            VIR_DEBUG("PCI address 0:0:2.0 in use, future addition of a video"
                      " device will not be possible without manual"
                      " intervention");
            virResetLastError();
2442
        } else if (qemuDomainPCIAddressReserveSlot(addrs, &tmp_addr, flags) < 0) {
2443
            goto cleanup;
2444 2445
        }
    }
2446 2447 2448 2449
    ret = 0;
cleanup:
    VIR_FREE(addrStr);
    return ret;
2450 2451 2452
}


2453 2454 2455 2456 2457 2458 2459 2460
static bool
qemuDomainMachineIsQ35(virDomainDefPtr def)
{
    return (STRPREFIX(def->os.machine, "pc-q35") ||
            STREQ(def->os.machine, "q35"));
}


2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
static bool
qemuDomainMachineIsI440FX(virDomainDefPtr def)
{
    return (STREQ(def->os.machine, "pc") ||
            STRPREFIX(def->os.machine, "pc-0.") ||
            STRPREFIX(def->os.machine, "pc-1.") ||
            STRPREFIX(def->os.machine, "pc-i440") ||
            STRPREFIX(def->os.machine, "rhel"));
}


2472 2473 2474 2475 2476
static int
qemuDomainValidateDevicePCISlotsQ35(virDomainDefPtr def,
                                    virQEMUCapsPtr qemuCaps,
                                    qemuDomainPCIAddressSetPtr addrs)
{
2477
    int ret = -1;
2478 2479 2480 2481
    size_t i;
    virDevicePCIAddress tmp_addr;
    bool qemuDeviceVideoUsable = virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    virDevicePCIAddressPtr addrptr;
2482
    char *addrStr = NULL;
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496
    qemuDomainPCIConnectFlags flags = QEMU_PCI_CONNECT_TYPE_PCIE;

    /* Verify that the first SATA controller is at 00:1F.2 */
    /* the q35 machine type *always* has a SATA controller at this address */
    for (i = 0; i < def->ncontrollers; i++) {
        if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA &&
            def->controllers[i]->idx == 0) {
            if (def->controllers[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
                if (def->controllers[i]->info.addr.pci.domain != 0 ||
                    def->controllers[i]->info.addr.pci.bus != 0 ||
                    def->controllers[i]->info.addr.pci.slot != 0x1F ||
                    def->controllers[i]->info.addr.pci.function != 2) {
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("Primary SATA controller must have PCI address 0:0:1f.2"));
2497
                    goto cleanup;
2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
                }
            } else {
                def->controllers[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
                def->controllers[i]->info.addr.pci.domain = 0;
                def->controllers[i]->info.addr.pci.bus = 0;
                def->controllers[i]->info.addr.pci.slot = 0x1F;
                def->controllers[i]->info.addr.pci.function = 2;
            }
        }
    }

    /* Reserve slot 0x1F function 0 (ISA bridge, not in config model)
     * and function 3 (SMBus, also not (yet) in config model). As with
     * the SATA controller, these devices are always present in a q35
     * machine; there is no way to not have them.
     */
    if (addrs->nbuses) {
        memset(&tmp_addr, 0, sizeof(tmp_addr));
        tmp_addr.slot = 0x1F;
        tmp_addr.function = 0;
        tmp_addr.multi = 1;
        if (qemuDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags,
                                            false, false) < 0)
2521
           goto cleanup;
2522 2523 2524 2525
        tmp_addr.function = 3;
        tmp_addr.multi = 0;
        if (qemuDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags,
                                            false, false) < 0)
2526
           goto cleanup;
2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544
    }

    if (def->nvideos > 0) {
        /* NB: unlike the pc machinetypes, on q35 machinetypes the
         * integrated devices are at slot 0x1f, so when qemu looks for
         * the first free lot for the first VGA, it will always be at
         * slot 1 (which was used up by the integrated PIIX3 devices
         * on pc machinetypes).
         */
        virDomainVideoDefPtr primaryVideo = def->videos[0];
        if (primaryVideo->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
            primaryVideo->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
            primaryVideo->info.addr.pci.domain = 0;
            primaryVideo->info.addr.pci.bus = 0;
            primaryVideo->info.addr.pci.slot = 1;
            primaryVideo->info.addr.pci.function = 0;
            addrptr = &primaryVideo->info.addr.pci;

2545 2546 2547 2548 2549
            if (!(addrStr = qemuDomainPCIAddressAsString(addrptr)))
                goto cleanup;
            if (!qemuDomainPCIAddressValidate(addrs, addrptr,
                                              addrStr, flags, false))
                goto cleanup;
2550 2551 2552 2553 2554 2555 2556

            if (qemuDomainPCIAddressSlotInUse(addrs, addrptr)) {
                if (qemuDeviceVideoUsable) {
                    virResetLastError();
                    if (qemuDomainPCIAddressReserveNextSlot(addrs,
                                                            &primaryVideo->info,
                                                            flags) < 0)
2557
                        goto cleanup;
2558 2559 2560 2561
                } else {
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("PCI address 0:0:1.0 is in use, "
                                     "QEMU needs it for primary video"));
2562
                    goto cleanup;
2563 2564
                }
            } else if (qemuDomainPCIAddressReserveSlot(addrs, addrptr, flags) < 0) {
2565
                goto cleanup;
2566 2567 2568 2569 2570 2571 2572 2573
            }
        } else if (!qemuDeviceVideoUsable) {
            if (primaryVideo->info.addr.pci.domain != 0 ||
                primaryVideo->info.addr.pci.bus != 0 ||
                primaryVideo->info.addr.pci.slot != 1 ||
                primaryVideo->info.addr.pci.function != 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("Primary video card must have PCI address 0:0:1.0"));
2574
                goto cleanup;
2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588
            }
            /* If TYPE==PCI, then qemuCollectPCIAddress() function
             * has already reserved the address, so we must skip */
        }
    } else if (addrs->nbuses && !qemuDeviceVideoUsable) {
        memset(&tmp_addr, 0, sizeof(tmp_addr));
        tmp_addr.slot = 1;

        if (qemuDomainPCIAddressSlotInUse(addrs, &tmp_addr)) {
            VIR_DEBUG("PCI address 0:0:1.0 in use, future addition of a video"
                      " device will not be possible without manual"
                      " intervention");
            virResetLastError();
        } else if (qemuDomainPCIAddressReserveSlot(addrs, &tmp_addr, flags) < 0) {
2589
            goto cleanup;
2590 2591
        }
    }
2592 2593 2594 2595
    ret = 0;
cleanup:
    VIR_FREE(addrStr);
    return ret;
2596 2597 2598
}


2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636
/*
 * This assigns static PCI slots to all configured devices.
 * The ordering here is chosen to match the ordering used
 * with old QEMU < 0.12, so that if a user updates a QEMU
 * host from old QEMU to QEMU >= 0.12, their guests should
 * get PCI addresses in the same order as before.
 *
 * NB, if they previously hotplugged devices then all bets
 * are off. Hotplug for old QEMU was unfixably broken wrt
 * to stable PCI addressing.
 *
 * Order is:
 *
 *  - Host bridge (slot 0)
 *  - PIIX3 ISA bridge, IDE controller, something else unknown, USB controller (slot 1)
 *  - Video (slot 2)
 *
 * Incrementally assign slots from 3 onwards:
 *
 *  - Net
 *  - Sound
 *  - SCSI controllers
 *  - VirtIO block
 *  - VirtIO balloon
 *  - Host device passthrough
 *  - Watchdog (not IB700)
 *
 * Prior to this function being invoked, qemuCollectPCIAddress() will have
 * added all existing PCI addresses from the 'def' to 'addrs'. Thus this
 * function must only try to reserve addresses if info.type == NONE and
 * skip over info.type == PCI
 */
int
qemuAssignDevicePCISlots(virDomainDefPtr def,
                         virQEMUCapsPtr qemuCaps,
                         qemuDomainPCIAddressSetPtr addrs)
{
    size_t i, j;
2637
    qemuDomainPCIConnectFlags flags;
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647
    virDevicePCIAddress tmp_addr;

    if ((STRPREFIX(def->os.machine, "pc-0.") ||
        STRPREFIX(def->os.machine, "pc-1.") ||
        STRPREFIX(def->os.machine, "pc-i440") ||
        STREQ(def->os.machine, "pc") ||
        STRPREFIX(def->os.machine, "rhel")) &&
        qemuValidateDevicePCISlotsPIIX3(def, qemuCaps, addrs) < 0) {
        goto error;
    }
2648

2649 2650 2651 2652 2653
    if (qemuDomainMachineIsQ35(def) &&
        qemuDomainValidateDevicePCISlotsQ35(def, qemuCaps, addrs) < 0) {
        goto error;
    }

2654 2655 2656 2657 2658
    /* PCI controllers */
    for (i = 0; i < def->ncontrollers; i++) {
        if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
            if (def->controllers[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
                continue;
2659 2660
            switch (def->controllers[i]->model) {
            case VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT:
L
Laine Stump 已提交
2661 2662
            case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT:
                /* pci-root and pcie-root are implicit in the machine,
2663 2664 2665 2666 2667 2668 2669 2670
                 * and needs no address */
                continue;
            case VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE:
                /* pci-bridge doesn't require hot-plug
                 * (although it does provide hot-plug in its slots)
                 */
                flags = QEMU_PCI_CONNECT_TYPE_PCI;
                break;
2671 2672 2673 2674 2675 2676
            case VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE:
                /* dmi-to-pci-bridge requires a non-hotplug PCIe
                 * slot
                 */
                flags = QEMU_PCI_CONNECT_TYPE_PCIE;
                break;
2677 2678 2679 2680
            default:
                flags = QEMU_PCI_CONNECT_HOTPLUGGABLE | QEMU_PCI_CONNECT_TYPE_PCI;
                break;
            }
2681 2682 2683
            if (qemuDomainPCIAddressReserveNextSlot(addrs,
                                                    &def->controllers[i]->info,
                                                    flags) < 0)
2684 2685 2686 2687
                goto error;
        }
    }

2688 2689
    flags = QEMU_PCI_CONNECT_HOTPLUGGABLE | QEMU_PCI_CONNECT_TYPE_PCI;

2690
    for (i = 0; i < def->nfss; i++) {
2691 2692 2693 2694 2695
        if (def->fss[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
            continue;

        /* Only support VirtIO-9p-pci so far. If that changes,
         * we might need to skip devices here */
2696 2697
        if (qemuDomainPCIAddressReserveNextSlot(addrs, &def->fss[i]->info,
                                                flags) < 0)
2698 2699 2700 2701
            goto error;
    }

    /* Network interfaces */
2702
    for (i = 0; i < def->nnets; i++) {
2703 2704 2705 2706 2707 2708
        /* type='hostdev' network devices might be USB, and are also
         * in hostdevs list anyway, so handle them with other hostdevs
         * instead of here.
         */
        if ((def->nets[i]->type == VIR_DOMAIN_NET_TYPE_HOSTDEV) ||
            (def->nets[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)) {
2709
            continue;
2710
        }
2711 2712
        if (qemuDomainPCIAddressReserveNextSlot(addrs, &def->nets[i]->info,
                                                flags) < 0)
2713 2714 2715 2716
            goto error;
    }

    /* Sound cards */
2717
    for (i = 0; i < def->nsounds; i++) {
2718 2719 2720 2721 2722 2723 2724
        if (def->sounds[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
            continue;
        /* Skip ISA sound card, and PCSPK */
        if (def->sounds[i]->model == VIR_DOMAIN_SOUND_MODEL_SB16 ||
            def->sounds[i]->model == VIR_DOMAIN_SOUND_MODEL_PCSPK)
            continue;

2725 2726
        if (qemuDomainPCIAddressReserveNextSlot(addrs, &def->sounds[i]->info,
                                                flags) < 0)
2727 2728 2729
            goto error;
    }

2730
    /* Device controllers (SCSI, USB, but not IDE, FDC or CCID) */
2731
    for (i = 0; i < def->ncontrollers; i++) {
2732
        /* PCI controllers have been dealt with earlier */
2733 2734
        if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI)
            continue;
2735

2736 2737 2738 2739 2740
        /* USB controller model 'none' doesn't need a PCI address */
        if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
            def->controllers[i]->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE)
            continue;

E
Eric Blake 已提交
2741 2742 2743
        /* FDC lives behind the ISA bridge; CCID is a usb device */
        if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_FDC ||
            def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_CCID)
2744 2745 2746 2747 2748 2749 2750 2751
            continue;

        /* First IDE controller lives on the PIIX3 at slot=1, function=1,
           dealt with earlier on*/
        if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE &&
            def->controllers[i]->idx == 0)
            continue;

2752 2753
        if (def->controllers[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO)
            continue;
2754 2755
        if (def->controllers[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
            continue;
2756 2757 2758

        /* USB2 needs special handling to put all companions in the same slot */
        if (IS_USB2_CONTROLLER(def->controllers[i])) {
2759
            virDevicePCIAddress addr = { 0, 0, 0, 0, false };
2760
            memset(&tmp_addr, 0, sizeof(tmp_addr));
2761
            for (j = 0; j < i; j++) {
2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774
                if (IS_USB2_CONTROLLER(def->controllers[j]) &&
                    def->controllers[j]->idx == def->controllers[i]->idx) {
                    addr = def->controllers[j]->info.addr.pci;
                    break;
                }
            }

            switch (def->controllers[i]->model) {
            case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1:
                addr.function = 7;
                break;
            case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI1:
                addr.function = 0;
2775
                addr.multi = VIR_DEVICE_ADDRESS_PCI_MULTI_ON;
2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787
                break;
            case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI2:
                addr.function = 1;
                break;
            case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI3:
                addr.function = 2;
                break;
            }

            if (addr.slot == 0) {
                /* This is the first part of the controller, so need
                 * to find a free slot & then reserve a function */
2788
                if (qemuDomainPCIAddressGetNextSlot(addrs, &tmp_addr, flags) < 0)
2789 2790
                    goto error;

2791 2792
                addr.bus = tmp_addr.bus;
                addr.slot = tmp_addr.slot;
2793 2794 2795 2796

                addrs->lastaddr = addr;
                addrs->lastaddr.function = 0;
                addrs->lastaddr.multi = 0;
2797 2798
            }
            /* Finally we can reserve the slot+function */
2799 2800
            if (qemuDomainPCIAddressReserveAddr(addrs, &addr, flags,
                                                false, false) < 0)
2801 2802 2803 2804 2805
                goto error;

            def->controllers[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
            def->controllers[i]->info.addr.pci = addr;
        } else {
2806 2807 2808
            if (qemuDomainPCIAddressReserveNextSlot(addrs,
                                                    &def->controllers[i]->info,
                                                    flags) < 0)
2809 2810
                goto error;
        }
2811 2812
    }

2813
    /* Disks (VirtIO only for now) */
2814
    for (i = 0; i < def->ndisks; i++) {
2815 2816 2817 2818
        /* Only VirtIO disks use PCI addrs */
        if (def->disks[i]->bus != VIR_DOMAIN_DISK_BUS_VIRTIO)
            continue;

2819 2820 2821
        /* don't touch s390 devices */
        if (def->disks[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ||
            def->disks[i]->info.type ==
2822 2823 2824
            VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390 ||
            def->disks[i]->info.type ==
            VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW)
2825 2826 2827
            continue;

        if (def->disks[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
2828 2829
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("virtio only support device address type 'PCI'"));
2830 2831 2832
            goto error;
        }

2833 2834
        if (qemuDomainPCIAddressReserveNextSlot(addrs, &def->disks[i]->info,
                                                flags) < 0)
2835 2836 2837 2838
            goto error;
    }

    /* Host PCI devices */
2839
    for (i = 0; i < def->nhostdevs; i++) {
2840
        if (def->hostdevs[i]->info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
2841 2842 2843 2844 2845
            continue;
        if (def->hostdevs[i]->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
            def->hostdevs[i]->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
            continue;

2846 2847 2848
        if (qemuDomainPCIAddressReserveNextSlot(addrs,
                                                def->hostdevs[i]->info,
                                                flags) < 0)
2849 2850 2851 2852 2853 2854 2855
            goto error;
    }

    /* VirtIO balloon */
    if (def->memballoon &&
        def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO &&
        def->memballoon->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
2856 2857 2858
        if (qemuDomainPCIAddressReserveNextSlot(addrs,
                                                &def->memballoon->info,
                                                flags) < 0)
2859 2860 2861
            goto error;
    }

2862 2863 2864 2865
    /* VirtIO RNG */
    if (def->rng &&
        def->rng->model == VIR_DOMAIN_RNG_MODEL_VIRTIO &&
        def->rng->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
2866 2867
        if (qemuDomainPCIAddressReserveNextSlot(addrs,
                                                &def->rng->info, flags) < 0)
2868 2869 2870
            goto error;
    }

2871
    /* A watchdog - skip IB700, it is not a PCI device */
2872
    if (def->watchdog &&
2873
        def->watchdog->model != VIR_DOMAIN_WATCHDOG_MODEL_IB700 &&
2874
        def->watchdog->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
2875 2876
        if (qemuDomainPCIAddressReserveNextSlot(addrs, &def->watchdog->info,
                                                flags) < 0)
2877 2878 2879
            goto error;
    }

2880
    /* Further non-primary video cards which have to be qxl type */
2881
    for (i = 1; i < def->nvideos; i++) {
2882 2883 2884 2885 2886
        if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("non-primary video device must be type of 'qxl'"));
            goto error;
        }
2887 2888
        if (def->videos[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
            continue;
2889 2890
        if (qemuDomainPCIAddressReserveNextSlot(addrs, &def->videos[i]->info,
                                                flags) < 0)
2891 2892
            goto error;
    }
2893
    for (i = 0; i < def->ninputs; i++) {
2894 2895
        /* Nada - none are PCI based (yet) */
    }
2896
    for (i = 0; i < def->nparallels; i++) {
2897 2898
        /* Nada - none are PCI based (yet) */
    }
2899
    for (i = 0; i < def->nserials; i++) {
2900 2901
        /* Nada - none are PCI based (yet) */
    }
2902
    for (i = 0; i < def->nchannels; i++) {
2903 2904
        /* Nada - none are PCI based (yet) */
    }
2905
    for (i = 0; i < def->nhubs; i++) {
M
Marc-André Lureau 已提交
2906 2907
        /* Nada - none are PCI based (yet) */
    }
2908 2909 2910 2911 2912 2913 2914

    return 0;

error:
    return -1;
}

2915 2916 2917 2918
static void
qemuUsbId(virBufferPtr buf, int idx)
{
    if (idx == 0)
2919
        virBufferAddLit(buf, "usb");
2920 2921 2922
    else
        virBufferAsprintf(buf, "usb%d", idx);
}
2923 2924 2925

static int
qemuBuildDeviceAddressStr(virBufferPtr buf,
2926
                          virDomainDefPtr domainDef,
2927
                          virDomainDeviceInfoPtr info,
2928
                          virQEMUCapsPtr qemuCaps)
2929
{
2930 2931 2932
    int ret = -1;
    char *devStr = NULL;

2933
    if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
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
        const char *contAlias = NULL;
        size_t i;

        if (!(devStr = qemuDomainPCIAddressAsString(&info->addr.pci)))
            goto cleanup;
        for (i = 0; i < domainDef->ncontrollers; i++) {
            virDomainControllerDefPtr cont = domainDef->controllers[i];

            if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI &&
                cont->idx == info->addr.pci.bus) {
                contAlias = cont->info.alias;
                if (!contAlias) {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("Device alias was not set for PCI "
                                     "controller with index %u required "
                                     "for device at address %s"),
                                   info->addr.pci.bus, devStr);
                    goto cleanup;
                }
                break;
            }
        }
        if (!contAlias) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Could not find PCI "
                             "controller with index %u required "
                             "for device at address %s"),
                           info->addr.pci.bus, devStr);
            goto cleanup;
        }

2965
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
W
Wen Congyang 已提交
2966
            if (info->addr.pci.function != 0) {
2967 2968 2969
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("Only PCI device addresses with function=0 "
                                 "are supported with this QEMU binary"));
2970
                goto cleanup;
2971
            }
2972
            if (info->addr.pci.multi == VIR_DEVICE_ADDRESS_PCI_MULTI_ON) {
2973 2974 2975
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("'multifunction=on' is not supported with "
                                 "this QEMU binary"));
2976
                goto cleanup;
W
Wen Congyang 已提交
2977
            }
2978 2979
        }

2980 2981 2982 2983 2984 2985 2986
        /*
         * PCI bridge support is required for multiple buses
         * 'pci.%u' is the ID of the bridge as specified in
         * qemuBuildControllerDevStr
         *
         * PCI_MULTIBUS capability indicates that the implicit
         * PCI bus is named 'pci.0' instead of 'pci'.
2987
         */
2988 2989
        if (info->addr.pci.bus != 0) {
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_PCI_BRIDGE)) {
2990
                virBufferAsprintf(buf, ",bus=%s", contAlias);
2991 2992 2993 2994
            } else {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("Multiple PCI buses are not supported "
                                 "with this QEMU binary"));
2995
                goto cleanup;
2996 2997
            }
        } else {
2998 2999 3000
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS)) {
                virBufferAsprintf(buf, ",bus=%s", contAlias);
            } else {
3001
                virBufferAddLit(buf, ",bus=pci");
3002
            }
3003
        }
3004
        if (info->addr.pci.multi == VIR_DEVICE_ADDRESS_PCI_MULTI_ON)
3005
            virBufferAddLit(buf, ",multifunction=on");
3006
        else if (info->addr.pci.multi == VIR_DEVICE_ADDRESS_PCI_MULTI_OFF)
3007 3008 3009 3010
            virBufferAddLit(buf, ",multifunction=off");
        virBufferAsprintf(buf, ",addr=0x%x", info->addr.pci.slot);
        if (info->addr.pci.function != 0)
           virBufferAsprintf(buf, ".0x%x", info->addr.pci.function);
3011
    } else if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB) {
3012
        virBufferAddLit(buf, ",bus=");
3013 3014
        qemuUsbId(buf, info->addr.usb.bus);
        virBufferAsprintf(buf, ".0,port=%s", info->addr.usb.port);
3015 3016 3017
    } else if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO) {
        if (info->addr.spaprvio.has_reg)
            virBufferAsprintf(buf, ",reg=0x%llx", info->addr.spaprvio.reg);
3018 3019 3020 3021 3022 3023
    } else if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
        if (info->addr.ccw.assigned)
            virBufferAsprintf(buf, ",devno=%x.%x.%04x",
                              info->addr.ccw.cssid,
                              info->addr.ccw.ssid,
                              info->addr.ccw.devno);
3024
    }
3025

3026 3027 3028 3029
    ret = 0;
cleanup:
    VIR_FREE(devStr);
    return ret;
3030 3031
}

3032 3033 3034
static int
qemuBuildRomStr(virBufferPtr buf,
                virDomainDeviceInfoPtr info,
3035
                virQEMUCapsPtr qemuCaps)
3036
{
3037
    if (info->rombar || info->romfile) {
3038
        if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
3039 3040
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("rombar and romfile are supported only for PCI devices"));
3041 3042
            return -1;
        }
3043
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_ROMBAR)) {
3044 3045
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("rombar and romfile not supported in this QEMU binary"));
3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058
            return -1;
        }

        switch (info->rombar) {
        case VIR_DOMAIN_PCI_ROMBAR_OFF:
            virBufferAddLit(buf, ",rombar=0");
            break;
        case VIR_DOMAIN_PCI_ROMBAR_ON:
            virBufferAddLit(buf, ",rombar=1");
            break;
        default:
            break;
        }
3059 3060
        if (info->romfile)
           virBufferAsprintf(buf, ",romfile=%s", info->romfile);
3061 3062 3063 3064
    }
    return 0;
}

3065 3066 3067
static int
qemuBuildIoEventFdStr(virBufferPtr buf,
                      enum virDomainIoEventFd use,
3068
                      virQEMUCapsPtr qemuCaps)
3069
{
3070
    if (use && virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_IOEVENTFD))
3071 3072 3073 3074
        virBufferAsprintf(buf, ",ioeventfd=%s",
                          virDomainIoEventFdTypeToString(use));
    return 0;
}
3075 3076 3077 3078 3079 3080 3081

#define QEMU_SERIAL_PARAM_ACCEPTED_CHARS \
  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"

static int
qemuSafeSerialParamValue(const char *value)
{
3082
    if (strspn(value, QEMU_SERIAL_PARAM_ACCEPTED_CHARS) != strlen(value)) {
3083 3084 3085
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("driver serial '%s' contains unsafe characters"),
                       value);
3086 3087 3088 3089 3090 3091
        return -1;
    }

    return 0;
}

3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
static char *
qemuGetSecretString(virConnectPtr conn,
                    const char *scheme,
                    bool encoded,
                    int diskSecretType,
                    char *username,
                    unsigned char *uuid, char *usage,
                    virSecretUsageType secretUsageType)
{
    size_t secret_size;
    virSecretPtr sec = NULL;
    char *secret = NULL;

    /* look up secret */
    switch (diskSecretType) {
    case VIR_DOMAIN_DISK_SECRET_TYPE_UUID:
        sec = virSecretLookupByUUID(conn, uuid);
        break;
    case VIR_DOMAIN_DISK_SECRET_TYPE_USAGE:
        sec = virSecretLookupByUsage(conn, secretUsageType, usage);
        break;
    }

    if (!sec) {
3116 3117 3118 3119 3120 3121 3122 3123 3124
        if (diskSecretType == VIR_DOMAIN_DISK_SECRET_TYPE_UUID) {
            virReportError(VIR_ERR_NO_SECRET,
                           _("%s no secret matches uuid '%s'"),
                           scheme, uuid);
        } else {
            virReportError(VIR_ERR_NO_SECRET,
                           _("%s no secret matches usage value '%s'"),
                           scheme, usage);
        }
3125 3126 3127 3128 3129 3130
        goto cleanup;
    }

    secret = (char *)conn->secretDriver->secretGetValue(sec, &secret_size, 0,
                                                        VIR_SECRET_GET_VALUE_INTERNAL_CALL);
    if (!secret) {
3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141
        if (diskSecretType == VIR_DOMAIN_DISK_SECRET_TYPE_UUID) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("could not get value of the secret for "
                             "username '%s' using uuid '%s'"),
                           username, uuid);
        } else {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("could not get value of the secret for "
                             "username '%s' using usage value '%s'"),
                           username, usage);
        }
3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160
        goto cleanup;
    }

    if (encoded) {
        char *base64 = NULL;

        base64_encode_alloc(secret, secret_size, &base64);
        VIR_FREE(secret);
        if (!base64) {
            virReportOOMError();
            goto cleanup;
        }
        secret = base64;
    }

cleanup:
    virObjectUnref(sec);
    return secret;
}
3161

3162 3163 3164 3165 3166
static int
qemuBuildRBDString(virConnectPtr conn,
                   virDomainDiskDefPtr disk,
                   virBufferPtr opt)
{
3167 3168
    size_t i;
    int ret = 0;
3169 3170
    char *secret = NULL;

3171 3172 3173 3174 3175 3176 3177
    if (strchr(disk->src, ':')) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("':' not allowed in RBD source volume name '%s'"),
                       disk->src);
        return -1;
    }

3178
    virBufferEscape(opt, ',', ",", "rbd:%s", disk->src);
3179
    if (disk->auth.username) {
3180
        virBufferEscape(opt, '\\', ":", ":id=%s", disk->auth.username);
3181 3182 3183 3184 3185 3186 3187 3188 3189 3190
        /* Get the secret string using the virDomainDiskDef
         * NOTE: qemu/librbd wants it base64 encoded
         */
        if (!(secret = qemuGetSecretString(conn, "rbd", true,
                                           disk->auth.secretType,
                                           disk->auth.username,
                                           disk->auth.secret.uuid,
                                           disk->auth.secret.usage,
                                           VIR_SECRET_USAGE_TYPE_CEPH)))
            goto error;
3191 3192


3193 3194 3195
        virBufferEscape(opt, '\\', ":",
                        ":key=%s:auth_supported=cephx\\;none",
                        secret);
3196 3197
    } else {
        virBufferAddLit(opt, ":auth_supported=none");
3198 3199 3200 3201 3202 3203 3204 3205
    }

    if (disk->nhosts > 0) {
        virBufferAddLit(opt, ":mon_host=");
        for (i = 0; i < disk->nhosts; ++i) {
            if (i) {
                virBufferAddLit(opt, "\\;");
            }
3206 3207 3208 3209

            /* assume host containing : is ipv6 */
            if (strchr(disk->hosts[i].name, ':')) {
                virBufferEscape(opt, '\\', ":", "[%s]", disk->hosts[i].name);
3210 3211 3212
            } else {
                virBufferAsprintf(opt, "%s", disk->hosts[i].name);
            }
3213 3214 3215
            if (disk->hosts[i].port) {
                virBufferAsprintf(opt, "\\:%s", disk->hosts[i].port);
            }
3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231
        }
    }

cleanup:
    VIR_FREE(secret);

    return ret;

error:
    ret = -1;
    goto cleanup;
}

static int qemuAddRBDHost(virDomainDiskDefPtr disk, char *hostport)
{
    char *port;
3232 3233
    size_t skip;
    char **parts;
3234 3235 3236

    disk->nhosts++;
    if (VIR_REALLOC_N(disk->hosts, disk->nhosts) < 0)
3237
        goto error;
3238

3239 3240 3241 3242 3243 3244 3245 3246 3247
    if ((port = strchr(hostport, ']'))) {
        /* ipv6, strip brackets */
        hostport += 1;
        skip = 3;
    } else {
        port = strstr(hostport, "\\:");
        skip = 2;
    }

3248 3249
    if (port) {
        *port = '\0';
3250
        port += skip;
3251 3252
        if (VIR_STRDUP(disk->hosts[disk->nhosts - 1].port, port) < 0)
            goto error;
3253
    } else {
3254 3255
        if (VIR_STRDUP(disk->hosts[disk->nhosts - 1].port, "6789") < 0)
            goto error;
3256
    }
3257 3258 3259

    parts = virStringSplit(hostport, "\\:", 0);
    if (!parts)
3260
        goto error;
3261 3262
    disk->hosts[disk->nhosts-1].name = virStringJoin((const char **)parts, ":");
    virStringFreeList(parts);
3263
    if (!disk->hosts[disk->nhosts-1].name)
3264
        goto error;
3265 3266 3267 3268

    disk->hosts[disk->nhosts-1].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
    disk->hosts[disk->nhosts-1].socket = NULL;

3269 3270
    return 0;

3271
error:
3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284
    VIR_FREE(disk->hosts[disk->nhosts-1].port);
    VIR_FREE(disk->hosts[disk->nhosts-1].name);
    return -1;
}

/* disk->src initially has everything after the rbd: prefix */
static int qemuParseRBDString(virDomainDiskDefPtr disk)
{
    char *options = NULL;
    char *p, *e, *next;

    p = strchr(disk->src, ':');
    if (p) {
3285 3286
        if (VIR_STRDUP(options, p + 1) < 0)
            goto error;
3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310
        *p = '\0';
    }

    /* options */
    if (!options)
        return 0; /* all done */

    p = options;
    while (*p) {
        /* find : delimiter or end of string */
        for (e = p; *e && *e != ':'; ++e) {
            if (*e == '\\') {
                e++;
                if (*e == '\0')
                    break;
            }
        }
        if (*e == '\0') {
            next = e;    /* last kv pair */
        } else {
            next = e + 1;
            *e = '\0';
        }

3311 3312 3313
        if (STRPREFIX(p, "id=") &&
            VIR_STRDUP(disk->auth.username, p + strlen("id=")) < 0)
            goto error;
3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336
        if (STRPREFIX(p, "mon_host=")) {
            char *h, *sep;

            h = p + strlen("mon_host=");
            while (h < e) {
                for (sep = h; sep < e; ++sep) {
                    if (*sep == '\\' && (sep[1] == ',' ||
                                         sep[1] == ';' ||
                                         sep[1] == ' ')) {
                        *sep = '\0';
                        sep += 2;
                        break;
                    }
                }
                if (qemuAddRBDHost(disk, h) < 0) {
                    return -1;
                }
                h = sep;
            }
        }

        p = next;
    }
3337
    VIR_FREE(options);
3338 3339
    return 0;

3340
error:
3341
    VIR_FREE(options);
3342 3343
    return -1;
}
3344

3345
static int
P
Paolo Bonzini 已提交
3346 3347
qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
                        const char *scheme)
3348 3349 3350 3351 3352
{
    int ret = -1;
    char *transp = NULL;
    char *sock = NULL;
    char *volimg = NULL;
3353
    char *secret = NULL;
3354 3355

    if (VIR_ALLOC(def->hosts) < 0)
3356
        goto error;
3357

P
Paolo Bonzini 已提交
3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368
    transp = strchr(uri->scheme, '+');
    if (transp)
        *transp++ = 0;

    if (!STREQ(uri->scheme, scheme)) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Invalid transport/scheme '%s'"), uri->scheme);
        goto error;
    }

    if (!transp) {
3369
        def->hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
P
Paolo Bonzini 已提交
3370
    } else {
3371 3372 3373
        def->hosts->transport = virDomainDiskProtocolTransportTypeFromString(transp);
        if (def->hosts->transport < 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
P
Paolo Bonzini 已提交
3374
                           _("Invalid %s transport type '%s'"), scheme, transp);
3375 3376 3377 3378 3379 3380
            goto error;
        }
    }
    def->nhosts = 0; /* set to 1 once everything succeeds */

    if (def->hosts->transport != VIR_DOMAIN_DISK_PROTO_TRANS_UNIX) {
3381 3382
        if (VIR_STRDUP(def->hosts->name, uri->server) < 0)
            goto error;
3383 3384

        if (virAsprintf(&def->hosts->port, "%d", uri->port) < 0)
3385
            goto error;
3386 3387 3388 3389 3390 3391
    } else {
        def->hosts->name = NULL;
        def->hosts->port = 0;
        if (uri->query) {
            if (STRPREFIX(uri->query, "socket=")) {
                sock = strchr(uri->query, '=') + 1;
3392 3393
                if (VIR_STRDUP(def->hosts->socket, sock) < 0)
                    goto error;
3394 3395 3396 3397 3398 3399 3400
            } else {
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Invalid query parameter '%s'"), uri->query);
                goto error;
            }
        }
    }
P
Paolo Bonzini 已提交
3401 3402 3403
    if (uri->path) {
        volimg = uri->path + 1; /* skip the prefix slash */
        VIR_FREE(def->src);
3404 3405
        if (VIR_STRDUP(def->src, volimg) < 0)
            goto error;
P
Paolo Bonzini 已提交
3406 3407 3408 3409
    } else {
        VIR_FREE(def->src);
        def->src = NULL;
    }
3410

3411 3412 3413 3414 3415
    if (uri->user) {
        secret = strchr(uri->user, ':');
        if (secret)
            *secret = '\0';

3416 3417
        if (VIR_STRDUP(def->auth.username, uri->user) < 0)
            goto error;
3418 3419
    }

3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433
    def->nhosts = 1;
    ret = 0;

cleanup:
    virURIFree(uri);

    return ret;

error:
    virDomainDiskHostDefFree(def->hosts);
    VIR_FREE(def->hosts);
    goto cleanup;
}

P
Paolo Bonzini 已提交
3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444
static int
qemuParseGlusterString(virDomainDiskDefPtr def)
{
    virURIPtr uri = NULL;

    if (!(uri = virURIParse(def->src)))
        return -1;

    return qemuParseDriveURIString(def, uri, "gluster");
}

P
Paolo Bonzini 已提交
3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469
static int
qemuParseISCSIString(virDomainDiskDefPtr def)
{
    virURIPtr uri = NULL;
    char *slash;
    unsigned lun;

    if (!(uri = virURIParse(def->src)))
        return -1;

    if (uri->path &&
        (slash = strchr(uri->path + 1, '/')) != NULL) {

        if (slash[1] == '\0')
            *slash = '\0';
        else if (virStrToLong_ui(slash + 1, NULL, 10, &lun) == -1) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("invalid name '%s' for iSCSI disk"), def->src);
            return -1;
        }
    }

    return qemuParseDriveURIString(def, uri, "iscsi");
}

3470 3471 3472 3473 3474
static int
qemuParseNBDString(virDomainDiskDefPtr disk)
{
    virDomainDiskHostDefPtr h = NULL;
    char *host, *port;
P
Paolo Bonzini 已提交
3475
    char *src;
3476

P
Paolo Bonzini 已提交
3477 3478 3479 3480 3481 3482 3483 3484
    virURIPtr uri = NULL;

    if (strstr(disk->src, "://")) {
        uri = virURIParse(disk->src);
        if (uri)
            return qemuParseDriveURIString(disk, uri, "nbd");
    }

3485
    if (VIR_ALLOC(h) < 0)
3486
        goto error;
3487 3488

    host = disk->src + strlen("nbd:");
3489 3490 3491 3492
    if (STRPREFIX(host, "unix:/")) {
        src = strchr(host + strlen("unix:"), ':');
        if (src)
            *src++ = '\0';
3493

3494
        h->transport = VIR_DOMAIN_DISK_PROTO_TRANS_UNIX;
3495 3496
        if (VIR_STRDUP(h->socket, host + strlen("unix:")) < 0)
            goto error;
3497 3498 3499 3500 3501 3502 3503
    } else {
        port = strchr(host, ':');
        if (!port) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot parse nbd filename '%s'"), disk->src);
            goto error;
        }
3504

3505
        *port++ = '\0';
3506 3507
        if (VIR_STRDUP(h->name, host) < 0)
            goto error;
P
Paolo Bonzini 已提交
3508

3509 3510 3511 3512
        src = strchr(port, ':');
        if (src)
            *src++ = '\0';

3513 3514
        if (VIR_STRDUP(h->port, port) < 0)
            goto error;
3515
    }
3516

P
Paolo Bonzini 已提交
3517
    if (src && STRPREFIX(src, "exportname=")) {
3518 3519
        if (VIR_STRDUP(src, strchr(src, '=') + 1) < 0)
            goto error;
P
Paolo Bonzini 已提交
3520 3521 3522 3523
    } else {
        src = NULL;
    }

3524
    VIR_FREE(disk->src);
P
Paolo Bonzini 已提交
3525
    disk->src = src;
3526 3527 3528 3529 3530 3531 3532 3533 3534 3535
    disk->nhosts = 1;
    disk->hosts = h;
    return 0;

error:
    virDomainDiskHostDefFree(h);
    VIR_FREE(h);
    return -1;
}

3536
static int
3537 3538
qemuBuildDriveURIString(virConnectPtr conn,
                        virDomainDiskDefPtr disk, virBufferPtr opt,
3539
                        const char *scheme, virSecretUsageType secretUsageType)
3540 3541 3542
{
    int ret = -1;
    int port = 0;
3543 3544
    char *secret = NULL;

3545 3546 3547
    char *tmpscheme = NULL;
    char *volimg = NULL;
    char *sock = NULL;
3548
    char *user = NULL;
3549 3550 3551 3552 3553 3554 3555
    char *builturi = NULL;
    const char *transp = NULL;
    virURI uri = {
        .port = port /* just to clear rest of bits */
    };

    if (disk->nhosts != 1) {
P
Paolo Bonzini 已提交
3556 3557
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("%s accepts only one host"), scheme);
3558 3559 3560 3561 3562 3563
        return -1;
    }

    virBufferAddLit(opt, "file=");
    transp = virDomainDiskProtocolTransportTypeToString(disk->hosts->transport);

P
Paolo Bonzini 已提交
3564
    if (disk->hosts->transport == VIR_DOMAIN_DISK_PROTO_TRANS_TCP) {
3565 3566
        if (VIR_STRDUP(tmpscheme, scheme) < 0)
            goto cleanup;
P
Paolo Bonzini 已提交
3567 3568
    } else {
        if (virAsprintf(&tmpscheme, "%s+%s", scheme, transp) < 0)
3569
            goto cleanup;
P
Paolo Bonzini 已提交
3570
    }
3571

P
Paolo Bonzini 已提交
3572
    if (disk->src && virAsprintf(&volimg, "/%s", disk->src) < 0)
3573
        goto cleanup;
3574 3575 3576 3577 3578 3579 3580

    if (disk->hosts->port) {
        port = atoi(disk->hosts->port);
    }

    if (disk->hosts->socket &&
        virAsprintf(&sock, "socket=%s", disk->hosts->socket) < 0)
3581
        goto cleanup;
3582

3583 3584 3585 3586 3587 3588 3589 3590 3591 3592
    if (disk->auth.username && secretUsageType != VIR_SECRET_USAGE_TYPE_NONE) {
        /* Get the secret string using the virDomainDiskDef */
        if (!(secret = qemuGetSecretString(conn, scheme, false,
                                           disk->auth.secretType,
                                           disk->auth.username,
                                           disk->auth.secret.uuid,
                                           disk->auth.secret.usage,
                                           secretUsageType)))
            goto cleanup;
        if (virAsprintf(&user, "%s:%s", disk->auth.username, secret) < 0)
3593 3594
            goto cleanup;
    }
3595

3596 3597
    uri.scheme = tmpscheme; /* gluster+<transport> */
    uri.server = disk->hosts->name;
3598
    uri.user = user;
3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612
    uri.port = port;
    uri.path = volimg;
    uri.query = sock;

    builturi = virURIFormat(&uri);
    virBufferEscape(opt, ',', ",", "%s", builturi);

    ret = 0;

cleanup:
    VIR_FREE(builturi);
    VIR_FREE(tmpscheme);
    VIR_FREE(volimg);
    VIR_FREE(sock);
J
John Ferlan 已提交
3613 3614
    VIR_FREE(secret);
    VIR_FREE(user);
3615 3616 3617 3618

    return ret;
}

P
Paolo Bonzini 已提交
3619
static int
3620
qemuBuildGlusterString(virConnectPtr conn, virDomainDiskDefPtr disk, virBufferPtr opt)
P
Paolo Bonzini 已提交
3621
{
3622 3623
    return qemuBuildDriveURIString(conn, disk, opt, "gluster",
                                   VIR_SECRET_USAGE_TYPE_NONE);
P
Paolo Bonzini 已提交
3624 3625
}

3626 3627
#define QEMU_DEFAULT_NBD_PORT "10809"

P
Paolo Bonzini 已提交
3628
static int
3629
qemuBuildISCSIString(virConnectPtr conn, virDomainDiskDefPtr disk, virBufferPtr opt)
P
Paolo Bonzini 已提交
3630
{
3631 3632
    return qemuBuildDriveURIString(conn, disk, opt, "iscsi",
                                   VIR_SECRET_USAGE_TYPE_ISCSI);
P
Paolo Bonzini 已提交
3633 3634
}

3635
static int
3636
qemuBuildNBDString(virConnectPtr conn, virDomainDiskDefPtr disk, virBufferPtr opt)
3637 3638 3639 3640 3641 3642 3643 3644 3645
{
    const char *transp;

    if (disk->nhosts != 1) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("nbd accepts only one host"));
        return -1;
    }

P
Paolo Bonzini 已提交
3646 3647 3648 3649 3650
    if ((disk->hosts->name && strchr(disk->hosts->name, ':'))
        || (disk->hosts->transport == VIR_DOMAIN_DISK_PROTO_TRANS_TCP
            && !disk->hosts->name)
        || (disk->hosts->transport == VIR_DOMAIN_DISK_PROTO_TRANS_UNIX
            && disk->hosts->socket && disk->hosts->socket[0] != '/'))
3651 3652
        return qemuBuildDriveURIString(conn, disk, opt, "nbd",
                                       VIR_SECRET_USAGE_TYPE_NONE);
P
Paolo Bonzini 已提交
3653

3654 3655 3656 3657 3658 3659 3660 3661 3662 3663
    virBufferAddLit(opt, "file=nbd:");

    switch (disk->hosts->transport) {
    case VIR_DOMAIN_DISK_PROTO_TRANS_TCP:
        if (disk->hosts->name)
            virBufferEscape(opt, ',', ",", "%s", disk->hosts->name);
        virBufferEscape(opt, ',', ",", ":%s",
                        disk->hosts->port ? disk->hosts->port :
                        QEMU_DEFAULT_NBD_PORT);
        break;
3664 3665 3666 3667 3668 3669 3670 3671
    case VIR_DOMAIN_DISK_PROTO_TRANS_UNIX:
        if (!disk->hosts->socket) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("socket attribute required for unix transport"));
            return -1;
        }
        virBufferEscape(opt, ',', ",", "unix:%s", disk->hosts->socket);
        break;
3672 3673 3674 3675 3676 3677 3678
    default:
        transp = virDomainDiskProtocolTransportTypeToString(disk->hosts->transport);
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("nbd does not support transport '%s'"), transp);
        break;
    }

P
Paolo Bonzini 已提交
3679 3680 3681
    if (disk->src)
        virBufferEscape(opt, ',', ",", ":exportname=%s", disk->src);

3682 3683 3684
    return 0;
}

3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746
static int
qemuBuildVolumeString(virConnectPtr conn,
                      virDomainDiskDefPtr disk,
                      virBufferPtr opt)
{
    int ret = -1;

    switch (disk->srcpool->voltype) {
    case VIR_STORAGE_VOL_DIR:
        if (!disk->readonly) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("cannot create virtual FAT disks in read-write mode"));
            goto cleanup;
        }
        if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)
            virBufferEscape(opt, ',', ",", "file=fat:floppy:%s,", disk->src);
        else
            virBufferEscape(opt, ',', ",", "file=fat:%s,", disk->src);
        break;
    case VIR_STORAGE_VOL_BLOCK:
        if (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("tray status 'open' is invalid for "
                             "block type volume"));
            goto cleanup;
        }
        if (disk->srcpool->pooltype == VIR_STORAGE_POOL_ISCSI) {
            if (disk->srcpool->mode ==
                VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT) {
                if (qemuBuildISCSIString(conn, disk, opt) < 0)
                    goto cleanup;
                virBufferAddChar(opt, ',');
            } else if (disk->srcpool->mode ==
                       VIR_DOMAIN_DISK_SOURCE_POOL_MODE_HOST) {
                virBufferEscape(opt, ',', ",", "file=%s,", disk->src);
            }
        } else {
            virBufferEscape(opt, ',', ",", "file=%s,", disk->src);
        }
        break;
    case VIR_STORAGE_VOL_FILE:
        if (disk->auth.username) {
            if (qemuBuildISCSIString(conn, disk, opt) < 0)
                goto cleanup;
            virBufferAddChar(opt, ',');
        } else {
            virBufferEscape(opt, ',', ",", "file=%s,", disk->src);
        }
        break;
    case VIR_STORAGE_VOL_NETWORK:
        /* Keep the compiler quite, qemuTranslateDiskSourcePool already
         * reported the unsupported error.
         */
        break;
    }

    ret = 0;

cleanup:
    return ret;
}

3747
char *
3748 3749
qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
                  virDomainDiskDefPtr disk,
3750
                  bool bootable,
3751
                  virQEMUCapsPtr qemuCaps)
3752 3753 3754
{
    virBuffer opt = VIR_BUFFER_INITIALIZER;
    const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
3755 3756
    const char *trans =
        virDomainDiskGeometryTransTypeToString(disk->geometry.trans);
3757 3758 3759 3760
    int idx = virDiskNameToIndex(disk->dst);
    int busid = -1, unitid = -1;

    if (idx < 0) {
3761 3762
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unsupported disk type '%s'"), disk->dst);
3763 3764 3765 3766 3767 3768
        goto error;
    }

    switch (disk->bus) {
    case VIR_DOMAIN_DISK_BUS_SCSI:
        if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
3769 3770
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("unexpected address type for scsi disk"));
3771 3772 3773 3774 3775 3776 3777
            goto error;
        }

        /* Setting bus= attr for SCSI drives, causes a controller
         * to be created. Yes this is slightly odd. It is not possible
         * to have > 1 bus on a SCSI controller (yet). */
        if (disk->info.addr.drive.bus != 0) {
3778 3779
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("SCSI controller only supports 1 bus"));
3780 3781 3782 3783 3784 3785 3786 3787
            goto error;
        }
        busid = disk->info.addr.drive.controller;
        unitid = disk->info.addr.drive.unit;
        break;

    case VIR_DOMAIN_DISK_BUS_IDE:
        if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
3788 3789
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("unexpected address type for ide disk"));
3790 3791 3792 3793
            goto error;
        }
        /* We can only have 1 IDE controller (currently) */
        if (disk->info.addr.drive.controller != 0) {
3794 3795
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Only 1 %s controller is supported"), bus);
3796 3797 3798 3799 3800 3801 3802 3803
            goto error;
        }
        busid = disk->info.addr.drive.bus;
        unitid = disk->info.addr.drive.unit;
        break;

    case VIR_DOMAIN_DISK_BUS_FDC:
        if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
3804 3805
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("unexpected address type for fdc disk"));
3806 3807 3808 3809
            goto error;
        }
        /* We can only have 1 FDC controller (currently) */
        if (disk->info.addr.drive.controller != 0) {
3810 3811
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Only 1 %s controller is supported"), bus);
3812 3813 3814 3815
            goto error;
        }
        /* We can only have 1 FDC bus (currently) */
        if (disk->info.addr.drive.bus != 0) {
3816 3817
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Only 1 %s bus is supported"), bus);
3818 3819
            goto error;
        }
3820
        if (disk->info.addr.drive.target != 0) {
3821 3822
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("target must be 0 for controller fdc"));
3823 3824
            goto error;
        }
3825 3826 3827 3828 3829 3830 3831 3832 3833
        unitid = disk->info.addr.drive.unit;

        break;

    case VIR_DOMAIN_DISK_BUS_VIRTIO:
        idx = -1;
        break;

    case VIR_DOMAIN_DISK_BUS_XEN:
3834 3835 3836
    case VIR_DOMAIN_DISK_BUS_SD:
        /* Xen and SD have no address type currently, so assign
         * based on index */
3837 3838 3839 3840
        break;
    }

    /* disk->src is NULL when we use nbd disks */
3841 3842 3843 3844 3845 3846
    if ((disk->src ||
        (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
         disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_NBD)) &&
        !((disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY ||
           disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) &&
          disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN)) {
3847 3848
        if (disk->type == VIR_DOMAIN_DISK_TYPE_DIR) {
            /* QEMU only supports magic FAT format for now */
3849
            if (disk->format > 0 && disk->format != VIR_STORAGE_FILE_FAT) {
3850 3851
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("unsupported disk driver type for '%s'"),
3852
                               virStorageFileFormatTypeToString(disk->format));
3853 3854 3855
                goto error;
            }
            if (!disk->readonly) {
3856 3857
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("cannot create virtual FAT disks in read-write mode"));
3858 3859 3860
                goto error;
            }
            if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)
3861 3862
                virBufferEscape(&opt, ',', ",", "file=fat:floppy:%s,",
                                disk->src);
3863
            else
3864
                virBufferEscape(&opt, ',', ",", "file=fat:%s,", disk->src);
3865 3866 3867
        } else if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
            switch (disk->protocol) {
            case VIR_DOMAIN_DISK_PROTOCOL_NBD:
3868
                if (qemuBuildNBDString(conn, disk, &opt) < 0)
3869
                    goto error;
3870
                virBufferAddChar(&opt, ',');
3871 3872
                break;
            case VIR_DOMAIN_DISK_PROTOCOL_RBD:
3873 3874 3875 3876
                virBufferAddLit(&opt, "file=");
                if (qemuBuildRBDString(conn, disk, &opt) < 0)
                    goto error;
                virBufferAddChar(&opt, ',');
3877
                break;
3878
            case VIR_DOMAIN_DISK_PROTOCOL_GLUSTER:
3879
                if (qemuBuildGlusterString(conn, disk, &opt) < 0)
3880 3881 3882
                    goto error;
                virBufferAddChar(&opt, ',');
                break;
P
Paolo Bonzini 已提交
3883
            case VIR_DOMAIN_DISK_PROTOCOL_ISCSI:
3884
                if (qemuBuildISCSIString(conn, disk, &opt) < 0)
P
Paolo Bonzini 已提交
3885 3886 3887
                    goto error;
                virBufferAddChar(&opt, ',');
                break;
3888

3889
            case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
3890 3891 3892 3893
                if (disk->nhosts == 0) {
                    virBufferEscape(&opt, ',', ",", "file=sheepdog:%s,",
                                    disk->src);
                } else {
3894
                    /* only one host is supported now */
3895
                    virBufferAsprintf(&opt, "file=sheepdog:%s:%s:",
3896 3897
                                      disk->hosts->name,
                                      disk->hosts->port ? disk->hosts->port : "7000");
3898 3899
                    virBufferEscape(&opt, ',', ",", "%s,", disk->src);
                }
3900
                break;
3901 3902 3903 3904 3905 3906

            case VIR_DOMAIN_DISK_PROTOCOL_HTTP:
                virBufferAsprintf(&opt, "file=http://%s:%s",
                                  disk->hosts->name,
                                  disk->hosts->port ? disk->hosts->port : "80");
                virBufferEscape(&opt, ',', ",", "%s,", disk->src);
3907 3908 3909 3910 3911 3912
                break;
            case VIR_DOMAIN_DISK_PROTOCOL_HTTPS:
                virBufferAsprintf(&opt, "file=https://%s:%s",
                                  disk->hosts->name,
                                  disk->hosts->port ? disk->hosts->port : "443");
                virBufferEscape(&opt, ',', ",", "%s,", disk->src);
3913
                break;
3914 3915 3916 3917 3918 3919
            case VIR_DOMAIN_DISK_PROTOCOL_FTP:
                virBufferAsprintf(&opt, "file=ftp://%s:%s",
                                  disk->hosts->name,
                                  disk->hosts->port ? disk->hosts->port : "21");
                virBufferEscape(&opt, ',', ",", "%s,", disk->src);
                break;
3920 3921 3922 3923 3924 3925
            case VIR_DOMAIN_DISK_PROTOCOL_FTPS:
                virBufferAsprintf(&opt, "file=ftps://%s:%s",
                                  disk->hosts->name,
                                  disk->hosts->port ? disk->hosts->port : "990");
                virBufferEscape(&opt, ',', ",", "%s,", disk->src);
                break;
3926
            }
3927
        } else if (disk->type == VIR_DOMAIN_DISK_TYPE_VOLUME) {
3928 3929
            if (qemuBuildVolumeString(conn, disk, &opt) < 0)
                goto error;
3930
        } else {
3931 3932
            if ((disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) &&
                (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN)) {
3933 3934 3935
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("tray status 'open' is invalid for "
                                 "block type disk"));
3936 3937
                goto error;
            }
3938
            virBufferEscape(&opt, ',', ",", "file=%s,", disk->src);
3939 3940
        }
    }
3941
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
3942 3943
        virBufferAddLit(&opt, "if=none");
    else
3944
        virBufferAsprintf(&opt, "if=%s", bus);
3945

3946
    if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
3947
        if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
3948
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD))
3949
                virBufferAddLit(&opt, ",media=cdrom");
3950
        } else if (disk->bus == VIR_DOMAIN_DISK_BUS_IDE) {
3951
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_IDE_CD))
3952
                virBufferAddLit(&opt, ",media=cdrom");
3953 3954 3955 3956
        } else {
            virBufferAddLit(&opt, ",media=cdrom");
        }
    }
3957

3958
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
3959
        virBufferAsprintf(&opt, ",id=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
3960 3961 3962
    } else {
        if (busid == -1 && unitid == -1) {
            if (idx != -1)
3963
                virBufferAsprintf(&opt, ",index=%d", idx);
3964 3965
        } else {
            if (busid != -1)
3966
                virBufferAsprintf(&opt, ",bus=%d", busid);
3967
            if (unitid != -1)
3968
                virBufferAsprintf(&opt, ",unit=%d", unitid);
3969 3970 3971
        }
    }
    if (bootable &&
3972
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) &&
3973 3974
        (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK ||
         disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) &&
3975 3976 3977
        disk->bus != VIR_DOMAIN_DISK_BUS_IDE)
        virBufferAddLit(&opt, ",boot=on");
    if (disk->readonly &&
3978
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_READONLY))
3979
        virBufferAddLit(&opt, ",readonly=on");
3980
    if (disk->transient) {
3981 3982
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("transient disks not supported yet"));
3983 3984
        goto error;
    }
3985
    if (disk->format > 0 &&
3986
        disk->type != VIR_DOMAIN_DISK_TYPE_DIR &&
3987
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
3988 3989
        virBufferAsprintf(&opt, ",format=%s",
                          virStorageFileFormatTypeToString(disk->format));
3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004

    /* generate geometry command string */
    if (disk->geometry.cylinders > 0 &&
        disk->geometry.heads > 0 &&
        disk->geometry.sectors > 0) {

        virBufferAsprintf(&opt, ",cyls=%u,heads=%u,secs=%u",
                          disk->geometry.cylinders,
                          disk->geometry.heads,
                          disk->geometry.sectors);

        if (disk->geometry.trans != VIR_DOMAIN_DISK_TRANS_DEFAULT)
            virBufferEscapeString(&opt, ",trans=%s", trans);
    }

4005
    if (disk->serial &&
4006
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL)) {
4007 4008
        if (qemuSafeSerialParamValue(disk->serial) < 0)
            goto error;
4009
        virBufferAsprintf(&opt, ",serial=%s", disk->serial);
4010 4011 4012
    }

    if (disk->cachemode) {
4013 4014
        const char *mode = NULL;

4015
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2)) {
4016 4017 4018
            mode = qemuDiskCacheV2TypeToString(disk->cachemode);

            if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_DIRECTSYNC &&
4019
                !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
4020 4021 4022
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("disk cache mode 'directsync' is not "
                                 "supported by this QEMU"));
4023
                goto error;
4024
            } else if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_UNSAFE &&
4025
                !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
4026 4027 4028
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("disk cache mode 'unsafe' is not "
                                 "supported by this QEMU"));
4029
                goto error;
4030 4031 4032 4033
            }
        } else {
            mode = qemuDiskCacheV1TypeToString(disk->cachemode);
        }
4034

4035
        virBufferAsprintf(&opt, ",cache=%s", mode);
4036 4037 4038 4039
    } else if (disk->shared && !disk->readonly) {
        virBufferAddLit(&opt, ",cache=off");
    }

O
Osier Yang 已提交
4040
    if (disk->copy_on_read) {
4041
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ)) {
O
Osier Yang 已提交
4042 4043 4044
            virBufferAsprintf(&opt, ",copy-on-read=%s",
                              virDomainDiskCopyOnReadTypeToString(disk->copy_on_read));
        } else {
4045 4046
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("copy_on_read is not supported by this QEMU binary"));
O
Osier Yang 已提交
4047 4048 4049 4050
            goto error;
        }
    }

O
Osier Yang 已提交
4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061
    if (disk->discard) {
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_DISCARD)) {
            virBufferAsprintf(&opt, ",discard=%s",
                              virDomainDiskDiscardTypeToString(disk->discard));
        } else {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("discard is not supported by this QEMU binary"));
            goto error;
        }
    }

4062
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
4063 4064 4065 4066
        const char *wpolicy = NULL, *rpolicy = NULL;

        if (disk->error_policy)
            wpolicy = virDomainDiskErrorPolicyTypeToString(disk->error_policy);
4067 4068
        if (disk->rerror_policy)
            rpolicy = virDomainDiskErrorPolicyTypeToString(disk->rerror_policy);
4069 4070

        if (disk->error_policy == VIR_DOMAIN_DISK_ERROR_POLICY_ENOSPACE) {
4071 4072 4073
            /* in the case of enospace, the option is spelled
             * differently in qemu, and it's only valid for werror,
             * not for rerror, so leave leave rerror NULL.
4074
             */
4075 4076 4077 4078
            wpolicy = "enospc";
        } else if (!rpolicy) {
            /* for other policies, rpolicy can match wpolicy */
            rpolicy = wpolicy;
4079
        }
4080 4081 4082 4083 4084

        if (wpolicy)
            virBufferAsprintf(&opt, ",werror=%s", wpolicy);
        if (rpolicy)
            virBufferAsprintf(&opt, ",rerror=%s", rpolicy);
4085 4086
    }

E
Eric Blake 已提交
4087
    if (disk->iomode) {
4088
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_AIO)) {
4089
            virBufferAsprintf(&opt, ",aio=%s",
E
Eric Blake 已提交
4090 4091
                              virDomainDiskIoTypeToString(disk->iomode));
        } else {
4092 4093 4094
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("disk aio mode not supported with this "
                             "QEMU binary"));
E
Eric Blake 已提交
4095 4096 4097 4098
            goto error;
        }
    }

4099
    /* block I/O throttling */
4100 4101 4102 4103 4104 4105
    if ((disk->blkdeviotune.total_bytes_sec ||
         disk->blkdeviotune.read_bytes_sec ||
         disk->blkdeviotune.write_bytes_sec ||
         disk->blkdeviotune.total_iops_sec ||
         disk->blkdeviotune.read_iops_sec ||
         disk->blkdeviotune.write_iops_sec) &&
4106
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
4107 4108 4109
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("block I/O throttling not supported with this "
                         "QEMU binary"));
4110 4111 4112
        goto error;
    }

4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142
    if (disk->blkdeviotune.total_bytes_sec) {
        virBufferAsprintf(&opt, ",bps=%llu",
                          disk->blkdeviotune.total_bytes_sec);
    }

    if (disk->blkdeviotune.read_bytes_sec) {
        virBufferAsprintf(&opt, ",bps_rd=%llu",
                          disk->blkdeviotune.read_bytes_sec);
    }

    if (disk->blkdeviotune.write_bytes_sec) {
        virBufferAsprintf(&opt, ",bps_wr=%llu",
                          disk->blkdeviotune.write_bytes_sec);
    }

    if (disk->blkdeviotune.total_iops_sec) {
        virBufferAsprintf(&opt, ",iops=%llu",
                          disk->blkdeviotune.total_iops_sec);
    }

    if (disk->blkdeviotune.read_iops_sec) {
        virBufferAsprintf(&opt, ",iops_rd=%llu",
                          disk->blkdeviotune.read_iops_sec);
    }

    if (disk->blkdeviotune.write_iops_sec) {
        virBufferAsprintf(&opt, ",iops_wr=%llu",
                          disk->blkdeviotune.write_iops_sec);
    }

4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155
    if (virBufferError(&opt)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&opt);

error:
    virBufferFreeAndReset(&opt);
    return NULL;
}

char *
4156 4157
qemuBuildDriveDevStr(virDomainDefPtr def,
                     virDomainDiskDefPtr disk,
4158
                     int bootindex,
4159
                     virQEMUCapsPtr qemuCaps)
4160 4161 4162 4163
{
    virBuffer opt = VIR_BUFFER_INITIALIZER;
    const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
    int idx = virDiskNameToIndex(disk->dst);
4164
    int controllerModel;
4165 4166

    if (idx < 0) {
4167 4168
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unsupported disk type '%s'"), disk->dst);
4169 4170 4171
        goto error;
    }

4172 4173 4174 4175 4176 4177 4178 4179 4180
    if (disk->wwn) {
        if ((disk->bus != VIR_DOMAIN_DISK_BUS_IDE) &&
            (disk->bus != VIR_DOMAIN_DISK_BUS_SCSI)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Only ide and scsi disk support wwn"));
            goto error;
        }
    }

4181 4182 4183 4184 4185 4186 4187
    if ((disk->vendor || disk->product) &&
        disk->bus != VIR_DOMAIN_DISK_BUS_SCSI) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Only scsi disk supports vendor and product"));
            goto error;
    }

4188 4189 4190 4191
    if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
        /* make sure that both the bus and the qemu binary support
         *  type='lun' (SG_IO).
         */
4192 4193
        if (disk->bus != VIR_DOMAIN_DISK_BUS_VIRTIO &&
            disk->bus != VIR_DOMAIN_DISK_BUS_SCSI) {
4194 4195 4196
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("disk device='lun' is not supported for bus='%s'"),
                           bus);
4197 4198
            goto error;
        }
4199 4200 4201 4202 4203 4204 4205
        if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
            if (disk->protocol != VIR_DOMAIN_DISK_PROTOCOL_ISCSI) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("disk device='lun' is not supported for protocol='%s'"),
                               virDomainDiskProtocolTypeToString(disk->protocol));
                goto error;
            }
4206
        } else if (!virDomainDiskSourceIsBlockType(disk)) {
4207 4208
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("disk device='lun' is only valid for block type disk source"));
4209 4210
            goto error;
        }
4211
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO)) {
4212 4213
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("disk device='lun' is not supported by this QEMU"));
4214 4215
            goto error;
        }
4216 4217 4218 4219 4220
        if (disk->wwn) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Setting wwn is not supported for lun device"));
            goto error;
        }
4221 4222 4223 4224 4225 4226
        if (disk->vendor || disk->product) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Setting vendor or product is not supported "
                             "for lun device"));
            goto error;
        }
4227 4228
    }

4229 4230
    switch (disk->bus) {
    case VIR_DOMAIN_DISK_BUS_IDE:
4231
        if (disk->info.addr.drive.target != 0) {
4232 4233
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("target must be 0 for ide controller"));
4234 4235
            goto error;
        }
4236

4237
        if (disk->wwn &&
4238
            !virQEMUCapsGet(qemuCaps, QEMU_CAPS_IDE_DRIVE_WWN)) {
4239 4240 4241 4242 4243 4244
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Setting wwn for ide disk is not supported "
                             "by this QEMU"));
            goto error;
        }

4245
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_IDE_CD)) {
4246 4247 4248 4249 4250 4251 4252 4253
            if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
                virBufferAddLit(&opt, "ide-cd");
            else
                virBufferAddLit(&opt, "ide-hd");
        } else {
            virBufferAddLit(&opt, "ide-drive");
        }

4254
        virBufferAsprintf(&opt, ",bus=ide.%d,unit=%d",
4255 4256 4257 4258
                          disk->info.addr.drive.bus,
                          disk->info.addr.drive.unit);
        break;
    case VIR_DOMAIN_DISK_BUS_SCSI:
4259
        if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
4260
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_BLOCK)) {
4261 4262 4263
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("This QEMU doesn't support scsi-block for "
                                 "lun passthrough"));
4264 4265 4266 4267
                goto error;
            }
        }

4268
        if (disk->wwn &&
4269
            !virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_WWN)) {
4270 4271 4272 4273 4274 4275
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Setting wwn for scsi disk is not supported "
                             "by this QEMU"));
            goto error;
        }

4276 4277 4278 4279
        /* Properties wwn, vendor and product were introduced in the
         * same QEMU release (1.2.0).
         */
        if ((disk->vendor || disk->product) &&
4280
            !virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_WWN)) {
4281 4282 4283 4284 4285 4286
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Setting vendor or product for scsi disk is not "
                             "supported by this QEMU"));
            goto error;
        }

4287
        controllerModel =
H
Han Cheng 已提交
4288 4289
            virDomainDeviceFindControllerModel(def, &disk->info,
                                               VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
4290
        if ((qemuSetScsiControllerModel(def, qemuCaps, &controllerModel)) < 0)
4291
            goto error;
4292 4293 4294

        if (controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
            if (disk->info.addr.drive.target != 0) {
4295 4296 4297
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("target must be 0 for controller "
                                 "model 'lsilogic'"));
4298 4299 4300
                goto error;
            }

4301
            if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
4302
                virBufferAddLit(&opt, "scsi-block");
4303
            } else {
4304
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD)) {
4305 4306 4307 4308 4309 4310 4311 4312 4313
                    if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
                        virBufferAddLit(&opt, "scsi-cd");
                    else
                        virBufferAddLit(&opt, "scsi-hd");
                } else {
                    virBufferAddLit(&opt, "scsi-disk");
                }
            }

4314 4315 4316 4317 4318
            virBufferAsprintf(&opt, ",bus=scsi%d.%d,scsi-id=%d",
                              disk->info.addr.drive.controller,
                              disk->info.addr.drive.bus,
                              disk->info.addr.drive.unit);
        } else {
4319
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_CHANNEL)) {
4320
                if (disk->info.addr.drive.target > 7) {
4321 4322 4323
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("This QEMU doesn't support target "
                                     "greater than 7"));
4324 4325 4326 4327 4328
                    goto error;
                }

                if ((disk->info.addr.drive.bus != disk->info.addr.drive.unit) &&
                    (disk->info.addr.drive.bus != 0)) {
4329 4330 4331
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("This QEMU only supports both bus and "
                                     "unit equal to 0"));
4332 4333 4334 4335
                    goto error;
                }
            }

4336
            if (disk->device != VIR_DOMAIN_DISK_DEVICE_LUN) {
4337
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD)) {
4338 4339 4340 4341 4342 4343 4344 4345
                    if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
                        virBufferAddLit(&opt, "scsi-cd");
                    else
                        virBufferAddLit(&opt, "scsi-hd");
                } else {
                    virBufferAddLit(&opt, "scsi-disk");
                }
            } else {
4346
                virBufferAddLit(&opt, "scsi-block");
4347
            }
4348

4349 4350 4351 4352 4353 4354
            virBufferAsprintf(&opt, ",bus=scsi%d.0,channel=%d,scsi-id=%d,lun=%d",
                              disk->info.addr.drive.controller,
                              disk->info.addr.drive.bus,
                              disk->info.addr.drive.target,
                              disk->info.addr.drive.unit);
        }
4355
        break;
J
Jim Fehlig 已提交
4356
    case VIR_DOMAIN_DISK_BUS_SATA:
4357
        if (disk->info.addr.drive.bus != 0) {
4358 4359
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("bus must be 0 for ide controller"));
4360 4361 4362
            goto error;
        }
        if (disk->info.addr.drive.target != 0) {
4363 4364
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("target must be 0 for ide controller"));
4365 4366
            goto error;
        }
4367

4368
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_IDE_CD)) {
4369 4370 4371 4372 4373 4374 4375 4376
            if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
                virBufferAddLit(&opt, "ide-cd");
            else
                virBufferAddLit(&opt, "ide-hd");
        } else {
            virBufferAddLit(&opt, "ide-drive");
        }

4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396
        if (qemuDomainMachineIsQ35(def) &&
            disk->info.addr.drive.controller == 0) {
            /* Q35 machines have an implicit ahci (sata) controller at
             * 00:1F.2 which has no "id" associated with it. For this
             * reason, we can't refer to it as "ahci0". Instead, we
             * don't give an id, which qemu interprets as "use the
             * first ahci controller". We then need to specify the
             * unit with "unit=%d" rather than adding it onto the bus
             * arg.
             */
            virBufferAsprintf(&opt, ",unit=%d", disk->info.addr.drive.unit);
        } else {
            /* All other ahci controllers have been created by
             * libvirt, so they *do* have an id, and we can identify
             * them that way.
             */
            virBufferAsprintf(&opt, ",bus=ahci%d.%d",
                              disk->info.addr.drive.controller,
                              disk->info.addr.drive.unit);
        }
J
Jim Fehlig 已提交
4397
        break;
4398
    case VIR_DOMAIN_DISK_BUS_VIRTIO:
4399 4400 4401 4402
        if (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
            virBufferAddLit(&opt, "virtio-blk-ccw");
        } else if (disk->info.type ==
                   VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390) {
4403
            virBufferAddLit(&opt, "virtio-blk-s390");
4404 4405 4406
        } else if (disk->info.type ==
                   VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO) {
            virBufferAddLit(&opt, "virtio-blk-device");
4407 4408 4409
        } else {
            virBufferAddLit(&opt, "virtio-blk-pci");
        }
4410
        qemuBuildIoEventFdStr(&opt, disk->ioeventfd, qemuCaps);
4411
        if (disk->event_idx &&
4412
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX)) {
4413 4414 4415
            virBufferAsprintf(&opt, ",event_idx=%s",
                              virDomainVirtioEventIdxTypeToString(disk->event_idx));
        }
4416
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SCSI)) {
4417 4418 4419 4420 4421 4422 4423
            /* if sg_io is true but the scsi option isn't supported,
             * that means it's just always on in this version of qemu.
             */
            virBufferAsprintf(&opt, ",scsi=%s",
                              (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN)
                              ? "on" : "off");
        }
4424
        if (qemuBuildDeviceAddressStr(&opt, def, &disk->info, qemuCaps) < 0)
A
Alex Jia 已提交
4425
            goto error;
4426 4427
        break;
    case VIR_DOMAIN_DISK_BUS_USB:
4428 4429 4430 4431 4432 4433 4434
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("This QEMU doesn't support '-device "
                             "usb-storage'"));
            goto error;

        }
4435
        virBufferAddLit(&opt, "usb-storage");
4436

4437
        if (qemuBuildDeviceAddressStr(&opt, def, &disk->info, qemuCaps) < 0)
4438
            goto error;
4439 4440
        break;
    default:
4441 4442
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unsupported disk bus '%s' with device setup"), bus);
4443 4444
        goto error;
    }
4445 4446
    virBufferAsprintf(&opt, ",drive=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
    virBufferAsprintf(&opt, ",id=%s", disk->info.alias);
4447
    if (bootindex && virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
4448
        virBufferAsprintf(&opt, ",bootindex=%d", bootindex);
4449
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKIO)) {
V
Viktor Mihajlovski 已提交
4450
        if (disk->blockio.logical_block_size > 0)
4451
            virBufferAsprintf(&opt, ",logical_block_size=%u",
V
Viktor Mihajlovski 已提交
4452 4453
                              disk->blockio.logical_block_size);
        if (disk->blockio.physical_block_size > 0)
4454
            virBufferAsprintf(&opt, ",physical_block_size=%u",
V
Viktor Mihajlovski 已提交
4455
                              disk->blockio.physical_block_size);
4456
    }
4457

4458 4459 4460 4461 4462 4463
    if (disk->wwn) {
        if (STRPREFIX(disk->wwn, "0x"))
            virBufferAsprintf(&opt, ",wwn=%s", disk->wwn);
        else
            virBufferAsprintf(&opt, ",wwn=0x%s", disk->wwn);
    }
4464

4465 4466 4467 4468 4469 4470
    if (disk->vendor)
        virBufferAsprintf(&opt, ",vendor=%s", disk->vendor);

    if (disk->product)
        virBufferAsprintf(&opt, ",product=%s", disk->product);

4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486
    if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_STORAGE_REMOVABLE)) {
            if (disk->removable == VIR_DOMAIN_FEATURE_STATE_ON)
                virBufferAddLit(&opt, ",removable=on");
            else
                virBufferAddLit(&opt, ",removable=off");
        } else {
            if (disk->removable != VIR_DOMAIN_FEATURE_STATE_DEFAULT) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("This QEMU doesn't support setting the "
                                 "removable flag of USB storage devices"));
                goto error;
            }
        }
    }

4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500
    if (virBufferError(&opt)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&opt);

error:
    virBufferFreeAndReset(&opt);
    return NULL;
}


char *qemuBuildFSStr(virDomainFSDefPtr fs,
4501
                     virQEMUCapsPtr qemuCaps ATTRIBUTE_UNUSED)
4502 4503
{
    virBuffer opt = VIR_BUFFER_INITIALIZER;
4504
    const char *driver = qemuDomainFSDriverTypeToString(fs->fsdriver);
4505
    const char *wrpolicy = virDomainFSWrpolicyTypeToString(fs->wrpolicy);
4506 4507

    if (fs->type != VIR_DOMAIN_FS_TYPE_MOUNT) {
4508 4509
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("only supports mount filesystem type"));
4510 4511 4512
        goto error;
    }

4513
    if (!driver) {
4514 4515
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Filesystem driver type not supported"));
4516 4517 4518 4519
        goto error;
    }
    virBufferAdd(&opt, driver, -1);

4520 4521 4522 4523
    if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_PATH ||
        fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_DEFAULT) {
        if (fs->accessmode == VIR_DOMAIN_FS_ACCESSMODE_MAPPED) {
            virBufferAddLit(&opt, ",security_model=mapped");
4524
        } else if (fs->accessmode == VIR_DOMAIN_FS_ACCESSMODE_PASSTHROUGH) {
4525
            virBufferAddLit(&opt, ",security_model=passthrough");
4526
        } else if (fs->accessmode == VIR_DOMAIN_FS_ACCESSMODE_SQUASH) {
4527 4528 4529 4530 4531 4532
            virBufferAddLit(&opt, ",security_model=none");
        }
    } else {
        /* For other fs drivers, default(passthru) should always
         * be supported */
        if (fs->accessmode != VIR_DOMAIN_FS_ACCESSMODE_PASSTHROUGH) {
4533 4534
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("only supports passthrough accessmode"));
4535 4536
            goto error;
        }
4537
    }
4538 4539

    if (fs->wrpolicy) {
4540
       if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT)) {
4541 4542
           virBufferAsprintf(&opt, ",writeout=%s", wrpolicy);
       } else {
4543
           virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4544 4545 4546 4547 4548
                          _("filesystem writeout not supported"));
           goto error;
       }
    }

4549 4550
    virBufferAsprintf(&opt, ",id=%s%s", QEMU_FSDEV_HOST_PREFIX, fs->info.alias);
    virBufferAsprintf(&opt, ",path=%s", fs->src);
4551

4552
    if (fs->readonly) {
4553
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_FSDEV_READONLY)) {
4554 4555
            virBufferAddLit(&opt, ",readonly");
        } else {
4556 4557 4558
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("readonly filesystem is not supported by this "
                             "QEMU binary"));
4559 4560 4561 4562
            goto error;
        }
    }

4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576
    if (virBufferError(&opt)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&opt);

error:
    virBufferFreeAndReset(&opt);
    return NULL;
}


char *
4577 4578
qemuBuildFSDevStr(virDomainDefPtr def,
                  virDomainFSDefPtr fs,
4579
                  virQEMUCapsPtr qemuCaps)
4580 4581 4582 4583
{
    virBuffer opt = VIR_BUFFER_INITIALIZER;

    if (fs->type != VIR_DOMAIN_FS_TYPE_MOUNT) {
4584 4585
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("can only passthrough directories"));
4586 4587 4588 4589
        goto error;
    }

    virBufferAddLit(&opt, "virtio-9p-pci");
4590 4591 4592
    virBufferAsprintf(&opt, ",id=%s", fs->info.alias);
    virBufferAsprintf(&opt, ",fsdev=%s%s", QEMU_FSDEV_HOST_PREFIX, fs->info.alias);
    virBufferAsprintf(&opt, ",mount_tag=%s", fs->dst);
A
Alex Jia 已提交
4593

4594
    if (qemuBuildDeviceAddressStr(&opt, def, &fs->info, qemuCaps) < 0)
A
Alex Jia 已提交
4595
        goto error;
4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609

    if (virBufferError(&opt)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&opt);

error:
    virBufferFreeAndReset(&opt);
    return NULL;
}


4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628
static int
qemuControllerModelUSBToCaps(int model)
{
    switch (model) {
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI:
        return QEMU_CAPS_PIIX3_USB_UHCI;
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX4_UHCI:
        return QEMU_CAPS_PIIX4_USB_UHCI;
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_EHCI:
        return QEMU_CAPS_USB_EHCI;
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1:
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI1:
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI2:
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI3:
        return QEMU_CAPS_ICH9_USB_EHCI1;
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_VT82C686B_UHCI:
        return QEMU_CAPS_VT82C686B_USB_UHCI;
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_PCI_OHCI:
        return QEMU_CAPS_PCI_OHCI;
G
Gerd Hoffmann 已提交
4629 4630
    case VIR_DOMAIN_CONTROLLER_MODEL_USB_NEC_XHCI:
        return QEMU_CAPS_NEC_USB_XHCI;
4631 4632 4633 4634 4635 4636 4637
    default:
        return -1;
    }
}


static int
4638 4639
qemuBuildUSBControllerDevStr(virDomainDefPtr domainDef,
                             virDomainControllerDefPtr def,
4640
                             virQEMUCapsPtr qemuCaps,
4641 4642 4643
                             virBuffer *buf)
{
    const char *smodel;
4644
    int model, flags;
4645 4646

    model = def->model;
4647

4648
    if (model == -1) {
4649
        if (domainDef->os.arch == VIR_ARCH_PPC64)
4650 4651 4652 4653
            model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PCI_OHCI;
        else
            model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI;
    }
4654 4655

    smodel = qemuControllerModelUSBTypeToString(model);
4656
    flags = qemuControllerModelUSBToCaps(model);
4657

4658
    if (flags == -1 || !virQEMUCapsGet(qemuCaps, flags)) {
4659 4660
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("%s not supported in this QEMU binary"), smodel);
4661 4662 4663
        return -1;
    }

4664 4665 4666
    virBufferAsprintf(buf, "%s", smodel);

    if (def->info.mastertype == VIR_DOMAIN_CONTROLLER_MASTER_USB) {
4667
        virBufferAddLit(buf, ",masterbus=");
4668 4669
        qemuUsbId(buf, def->idx);
        virBufferAsprintf(buf, ".0,firstport=%d", def->info.master.usb.startport);
4670
    } else {
4671
        virBufferAddLit(buf, ",id=");
4672
        qemuUsbId(buf, def->idx);
4673 4674
    }

4675 4676 4677
    return 0;
}

4678
char *
4679 4680
qemuBuildControllerDevStr(virDomainDefPtr domainDef,
                          virDomainControllerDefPtr def,
4681
                          virQEMUCapsPtr qemuCaps,
4682
                          int *nusbcontroller)
4683 4684
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
4685
    int model;
4686

4687
    if (def->queues &&
4688 4689 4690
        !(def->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI &&
          def->model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4691
                       _("'queues' is only supported by virtio-scsi controller"));
4692 4693 4694
        return NULL;
    }

4695 4696
    switch (def->type) {
    case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
4697
        model = def->model;
4698
        if ((qemuSetScsiControllerModel(domainDef, qemuCaps, &model)) < 0)
4699 4700
            return NULL;

4701
        switch (model) {
4702
        case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI:
4703 4704 4705 4706 4707
            if (def->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW)
                virBufferAddLit(&buf, "virtio-scsi-ccw");
            else if (def->info.type ==
                     VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390)
                virBufferAddLit(&buf, "virtio-scsi-s390");
4708 4709 4710
            else if (def->info.type ==
                     VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO)
                virBufferAddLit(&buf, "virtio-scsi-device");
4711 4712
            else
                virBufferAddLit(&buf, "virtio-scsi-pci");
4713
            break;
4714
        case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC:
4715
            virBufferAddLit(&buf, "lsi");
4716 4717 4718 4719
            break;
        case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI:
            virBufferAddLit(&buf, "spapr-vscsi");
            break;
4720 4721 4722
        case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSISAS1078:
            virBufferAddLit(&buf, "megasas");
            break;
4723
        default:
4724 4725 4726
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("Unsupported controller model: %s"),
                           virDomainControllerModelSCSITypeToString(def->model));
4727
        }
4728
        virBufferAsprintf(&buf, ",id=scsi%d", def->idx);
4729 4730 4731 4732 4733
        break;

    case VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL:
        if (def->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
            virBufferAddLit(&buf, "virtio-serial-pci");
4734 4735 4736
        } else if (def->info.type ==
                   VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
            virBufferAddLit(&buf, "virtio-serial-ccw");
4737 4738 4739
        } else if (def->info.type ==
                   VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390) {
            virBufferAddLit(&buf, "virtio-serial-s390");
4740 4741 4742
        } else if (def->info.type ==
                   VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO) {
            virBufferAddLit(&buf, "virtio-serial-device");
4743 4744 4745
        } else {
            virBufferAddLit(&buf, "virtio-serial");
        }
4746
        virBufferAsprintf(&buf, ",id=" QEMU_VIRTIO_SERIAL_PREFIX "%d",
4747 4748
                          def->idx);
        if (def->opts.vioserial.ports != -1) {
4749
            virBufferAsprintf(&buf, ",max_ports=%d",
4750 4751 4752
                              def->opts.vioserial.ports);
        }
        if (def->opts.vioserial.vectors != -1) {
4753
            virBufferAsprintf(&buf, ",vectors=%d",
4754 4755 4756 4757
                              def->opts.vioserial.vectors);
        }
        break;

E
Eric Blake 已提交
4758
    case VIR_DOMAIN_CONTROLLER_TYPE_CCID:
4759
        virBufferAsprintf(&buf, "usb-ccid,id=ccid%d", def->idx);
E
Eric Blake 已提交
4760 4761
        break;

J
Jim Fehlig 已提交
4762 4763 4764 4765
    case VIR_DOMAIN_CONTROLLER_TYPE_SATA:
        virBufferAsprintf(&buf, "ahci,id=ahci%d", def->idx);
        break;

4766
    case VIR_DOMAIN_CONTROLLER_TYPE_USB:
4767
        if (qemuBuildUSBControllerDevStr(domainDef, def, qemuCaps, &buf) == -1)
4768 4769 4770 4771 4772 4773 4774
            goto error;

        if (nusbcontroller)
            *nusbcontroller += 1;

        break;

4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785
    case VIR_DOMAIN_CONTROLLER_TYPE_PCI:
        switch (def->model) {
        case VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE:
            if (def->idx == 0) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("PCI bridge index should be > 0"));
                goto error;
            }
            virBufferAsprintf(&buf, "pci-bridge,chassis_nr=%d,id=pci.%d",
                              def->idx, def->idx);
            break;
4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799
        case VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE:
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("The dmi-to-pci-bridge (i82801b11-bridge) "
                                 "controller is not supported in this QEMU binary"));
                goto error;
            }
            if (def->idx == 0) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("dmi-to-pci-bridge index should be > 0"));
                goto error;
            }
            virBufferAsprintf(&buf, "i82801b11-bridge,id=pci.%d", def->idx);
            break;
4800
        case VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT:
L
Laine Stump 已提交
4801
        case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT:
4802
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
L
Laine Stump 已提交
4803
                           _("wrong function called for pci-root/pcie-root"));
4804 4805 4806 4807
            return NULL;
        }
        break;

4808 4809 4810
    /* We always get an IDE controller, whether we want it or not. */
    case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
    default:
4811 4812 4813
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("Unknown controller type: %s"),
                       virDomainControllerTypeToString(def->type));
4814 4815 4816
        goto error;
    }

4817 4818
    if (def->queues)
        virBufferAsprintf(&buf, ",num_queues=%u", def->queues);
4819

4820
    if (qemuBuildDeviceAddressStr(&buf, domainDef, &def->info, qemuCaps) < 0)
4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841
        goto error;

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


char *
qemuBuildNicStr(virDomainNetDefPtr net,
                const char *prefix,
                int vlan)
{
    char *str;
4842 4843
    char macaddr[VIR_MAC_STRING_BUFLEN];

4844 4845 4846 4847 4848 4849 4850 4851 4852
    ignore_value(virAsprintf(&str,
                             "%smacaddr=%s,vlan=%d%s%s%s%s",
                             prefix ? prefix : "",
                             virMacAddrFormat(&net->mac, macaddr),
                             vlan,
                             (net->model ? ",model=" : ""),
                             (net->model ? net->model : ""),
                             (net->info.alias ? ",name=" : ""),
                             (net->info.alias ? net->info.alias : "")));
4853 4854 4855 4856 4857
    return str;
}


char *
4858 4859
qemuBuildNicDevStr(virDomainDefPtr def,
                   virDomainNetDefPtr net,
4860
                   int vlan,
4861
                   int bootindex,
4862
                   bool multiqueue,
4863
                   virQEMUCapsPtr qemuCaps)
4864 4865
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
4866
    const char *nic = net->model;
4867
    bool usingVirtio = false;
4868
    char macaddr[VIR_MAC_STRING_BUFLEN];
4869

4870 4871
    if (STREQ(net->model, "virtio")) {
        if (net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW)
4872
            nic = "virtio-net-ccw";
4873
        else if (net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390)
4874
            nic = "virtio-net-s390";
4875 4876
        else if (net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO)
            nic = "virtio-net-device";
4877
        else
4878
            nic = "virtio-net-pci";
4879

4880
        usingVirtio = true;
4881 4882
    }

4883
    virBufferAdd(&buf, nic, -1);
4884
    if (usingVirtio && net->driver.virtio.txmode) {
4885
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_TX_ALG)) {
4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898
            virBufferAddLit(&buf, ",tx=");
            switch (net->driver.virtio.txmode) {
                case VIR_DOMAIN_NET_VIRTIO_TX_MODE_IOTHREAD:
                    virBufferAddLit(&buf, "bh");
                    break;

                case VIR_DOMAIN_NET_VIRTIO_TX_MODE_TIMER:
                    virBufferAddLit(&buf, "timer");
                    break;
                default:
                    /* this should never happen, if it does, we need
                     * to add another case to this switch.
                     */
4899 4900
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("unrecognized virtio-net-pci 'tx' option"));
4901 4902 4903
                    goto error;
            }
        } else {
4904 4905
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("virtio-net-pci 'tx' option not supported in this QEMU binary"));
4906 4907 4908
            goto error;
        }
    }
4909
    if (usingVirtio) {
4910
        qemuBuildIoEventFdStr(&buf, net->driver.virtio.ioeventfd, qemuCaps);
4911
        if (net->driver.virtio.event_idx &&
4912
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX)) {
4913 4914 4915 4916
            virBufferAsprintf(&buf, ",event_idx=%s",
                              virDomainVirtioEventIdxTypeToString(net->driver.virtio.event_idx));
        }
    }
4917 4918
    if (usingVirtio && multiqueue)
        virBufferAddLit(&buf, ",mq=on");
4919
    if (vlan == -1)
4920
        virBufferAsprintf(&buf, ",netdev=host%s", net->info.alias);
4921
    else
4922 4923
        virBufferAsprintf(&buf, ",vlan=%d", vlan);
    virBufferAsprintf(&buf, ",id=%s", net->info.alias);
4924 4925
    virBufferAsprintf(&buf, ",mac=%s",
                      virMacAddrFormat(&net->mac, macaddr));
4926
    if (qemuBuildDeviceAddressStr(&buf, def, &net->info, qemuCaps) < 0)
4927
        goto error;
4928
    if (qemuBuildRomStr(&buf, &net->info, qemuCaps) < 0)
4929
       goto error;
4930
    if (bootindex && virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
4931
        virBufferAsprintf(&buf, ",bootindex=%d", bootindex);
4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


char *
qemuBuildHostNetStr(virDomainNetDefPtr net,
4948
                    virQEMUDriverPtr driver,
4949 4950
                    char type_sep,
                    int vlan,
4951 4952 4953 4954
                    char **tapfd,
                    int tapfdSize,
                    char **vhostfd,
                    int vhostfdSize)
4955
{
4956
    bool is_tap = false;
4957
    virBuffer buf = VIR_BUFFER_INITIALIZER;
4958
    enum virDomainNetType netType = virDomainNetGetActualType(net);
4959
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4960
    size_t i;
4961

4962
    if (net->script && netType != VIR_DOMAIN_NET_TYPE_ETHERNET) {
4963 4964 4965
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("scripts are not supported on interfaces of type %s"),
                       virDomainNetTypeToString(netType));
4966
        virObjectUnref(cfg);
4967 4968 4969 4970
        return NULL;
    }

    switch (netType) {
R
Richa Marwaha 已提交
4971 4972 4973 4974 4975
    /*
     * If type='bridge', and we're running as privileged user
     * or -netdev bridge is not supported then it will fall
     * through, -net tap,fd
     */
4976
    case VIR_DOMAIN_NET_TYPE_BRIDGE:
R
Richa Marwaha 已提交
4977
    case VIR_DOMAIN_NET_TYPE_NETWORK:
4978
    case VIR_DOMAIN_NET_TYPE_DIRECT:
4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991
        virBufferAsprintf(&buf, "tap%c", type_sep);
        /* for one tapfd 'fd=' shall be used,
         * for more than one 'fds=' is the right choice */
        if (tapfdSize == 1) {
            virBufferAsprintf(&buf, "fd=%s", tapfd[0]);
        } else {
            virBufferAddLit(&buf, "fds=");
            for (i = 0; i < tapfdSize; i++) {
                if (i)
                    virBufferAddChar(&buf, ':');
                virBufferAdd(&buf, tapfd[i], -1);
            }
        }
4992
        type_sep = ',';
4993
        is_tap = true;
4994 4995 4996 4997 4998
        break;

    case VIR_DOMAIN_NET_TYPE_ETHERNET:
        virBufferAddLit(&buf, "tap");
        if (net->ifname) {
4999
            virBufferAsprintf(&buf, "%cifname=%s", type_sep, net->ifname);
5000 5001
            type_sep = ',';
        }
5002
        if (net->script) {
5003
            virBufferAsprintf(&buf, "%cscript=%s", type_sep,
5004
                              net->script);
5005 5006
            type_sep = ',';
        }
5007
        is_tap = true;
5008 5009 5010
        break;

    case VIR_DOMAIN_NET_TYPE_CLIENT:
5011 5012 5013 5014 5015 5016 5017
       virBufferAsprintf(&buf, "socket%cconnect=%s:%d",
                         type_sep,
                         net->data.socket.address,
                         net->data.socket.port);
       type_sep = ',';
       break;

5018
    case VIR_DOMAIN_NET_TYPE_SERVER:
5019 5020 5021 5022 5023 5024 5025
       virBufferAsprintf(&buf, "socket%clisten=%s:%d",
                         type_sep,
                         net->data.socket.address,
                         net->data.socket.port);
       type_sep = ',';
       break;

5026
    case VIR_DOMAIN_NET_TYPE_MCAST:
5027 5028 5029 5030 5031 5032
       virBufferAsprintf(&buf, "socket%cmcast=%s:%d",
                         type_sep,
                         net->data.socket.address,
                         net->data.socket.port);
       type_sep = ',';
       break;
5033 5034 5035 5036 5037 5038 5039 5040

    case VIR_DOMAIN_NET_TYPE_USER:
    default:
        virBufferAddLit(&buf, "user");
        break;
    }

    if (vlan >= 0) {
5041
        virBufferAsprintf(&buf, "%cvlan=%d", type_sep, vlan);
5042
        if (net->info.alias)
5043
            virBufferAsprintf(&buf, ",name=host%s",
5044 5045
                              net->info.alias);
    } else {
5046
        virBufferAsprintf(&buf, "%cid=host%s",
5047 5048 5049
                          type_sep, net->info.alias);
    }

5050
    if (is_tap) {
5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063
        if (vhostfdSize) {
            virBufferAddLit(&buf, ",vhost=on,");
            if (vhostfdSize == 1) {
                virBufferAsprintf(&buf, "vhostfd=%s", vhostfd[0]);
            } else {
                virBufferAddLit(&buf, "vhostfds=");
                for (i = 0; i < vhostfdSize; i++) {
                    if (i)
                        virBufferAddChar(&buf, ':');
                    virBufferAdd(&buf, vhostfd[i], -1);
                }
            }
        }
5064
        if (net->tune.sndbuf_specified)
5065
            virBufferAsprintf(&buf, ",sndbuf=%lu", net->tune.sndbuf);
5066 5067
    }

5068 5069
    virObjectUnref(cfg);

5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080
    if (virBufferError(&buf)) {
        virBufferFreeAndReset(&buf);
        virReportOOMError();
        return NULL;
    }

    return virBufferContentAndReset(&buf);
}


char *
5081 5082
qemuBuildWatchdogDevStr(virDomainDefPtr def,
                        virDomainWatchdogDefPtr dev,
5083
                        virQEMUCapsPtr qemuCaps)
5084 5085 5086 5087 5088
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    const char *model = virDomainWatchdogModelTypeToString(dev->model);
    if (!model) {
5089 5090
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("missing watchdog model"));
5091 5092 5093
        goto error;
    }

5094
    virBufferAsprintf(&buf, "%s,id=%s", model, dev->info.alias);
5095
    if (qemuBuildDeviceAddressStr(&buf, def, &dev->info, qemuCaps) < 0)
5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111
        goto error;

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


char *
5112 5113
qemuBuildMemballoonDevStr(virDomainDefPtr def,
                          virDomainMemballoonDefPtr dev,
5114
                          virQEMUCapsPtr qemuCaps)
5115 5116 5117
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

5118 5119 5120 5121 5122 5123 5124
    switch (dev->info.type) {
        case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI:
            virBufferAddLit(&buf, "virtio-balloon-pci");
            break;
        case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW:
            virBufferAddLit(&buf, "virtio-balloon-ccw");
            break;
5125 5126 5127
        case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO:
            virBufferAddLit(&buf, "virtio-balloon-device");
            break;
5128
        default:
5129 5130 5131
            virReportError(VIR_ERR_XML_ERROR,
                           _("memballoon unsupported with address type '%s'"),
                           virDomainDeviceAddressTypeToString(dev->info.type));
5132 5133 5134
            goto error;
    }

5135
    virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
5136
    if (qemuBuildDeviceAddressStr(&buf, def, &dev->info, qemuCaps) < 0)
5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150
        goto error;

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}

5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176
static char *
qemuBuildNVRAMDevStr(virDomainNVRAMDefPtr dev)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    if (dev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO &&
        dev->info.addr.spaprvio.has_reg) {
        virBufferAsprintf(&buf, "spapr-nvram.reg=0x%llx",
                          dev->info.addr.spaprvio.reg);
    } else {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("nvram address type must be spaprvio"));
        goto error;
    }

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}
5177 5178

char *
5179 5180
qemuBuildUSBInputDevStr(virDomainDefPtr def,
                        virDomainInputDefPtr dev,
5181
                        virQEMUCapsPtr qemuCaps)
5182 5183 5184
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

5185
    virBufferAsprintf(&buf, "%s,id=%s",
5186
                      dev->type == VIR_DOMAIN_INPUT_TYPE_MOUSE ?
5187
                      "usb-mouse" : "usb-tablet", dev->info.alias);
5188

5189
    if (qemuBuildDeviceAddressStr(&buf, def, &dev->info, qemuCaps) < 0)
5190 5191
        goto error;

5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205
    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


char *
5206 5207
qemuBuildSoundDevStr(virDomainDefPtr def,
                     virDomainSoundDefPtr sound,
5208
                     virQEMUCapsPtr qemuCaps)
5209 5210 5211 5212 5213
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    const char *model = virDomainSoundModelTypeToString(sound->model);

    if (!model) {
5214 5215
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("invalid sound model"));
5216 5217 5218
        goto error;
    }

5219
    /* Hack for weirdly unusual devices name in QEMU */
5220 5221 5222 5223
    if (STREQ(model, "es1370"))
        model = "ES1370";
    else if (STREQ(model, "ac97"))
        model = "AC97";
5224 5225
    else if (STREQ(model, "ich6"))
        model = "intel-hda";
5226

5227
    virBufferAsprintf(&buf, "%s,id=%s", model, sound->info.alias);
5228
    if (qemuBuildDeviceAddressStr(&buf, def, &sound->info, qemuCaps) < 0)
5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242
        goto error;

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}

5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257

static int
qemuSoundCodecTypeToCaps(int type)
{
    switch (type) {
    case VIR_DOMAIN_SOUND_CODEC_TYPE_DUPLEX:
        return QEMU_CAPS_HDA_DUPLEX;
    case VIR_DOMAIN_SOUND_CODEC_TYPE_MICRO:
        return QEMU_CAPS_HDA_MICRO;
    default:
        return -1;
    }
}


5258 5259
static char *
qemuBuildSoundCodecStr(virDomainSoundDefPtr sound,
5260
                       virDomainSoundCodecDefPtr codec,
5261
                       virQEMUCapsPtr qemuCaps)
5262 5263
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
5264
    const char *stype;
5265
    int type, flags;
5266

5267 5268
    type = codec->type;
    stype = qemuSoundCodecTypeToString(type);
5269
    flags = qemuSoundCodecTypeToCaps(type);
5270

5271
    if (flags == -1 || !virQEMUCapsGet(qemuCaps, flags)) {
5272 5273
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("%s not supported in this QEMU binary"), stype);
5274 5275 5276
        goto error;
    }

5277 5278 5279
    virBufferAsprintf(&buf, "%s,id=%s-codec%d,bus=%s.0,cad=%d",
                      stype, sound->info.alias, codec->cad, sound->info.alias, codec->cad);

5280 5281 5282 5283 5284 5285
    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}
5286 5287

static char *
5288 5289
qemuBuildDeviceVideoStr(virDomainDefPtr def,
                        virDomainVideoDefPtr video,
5290
                        virQEMUCapsPtr qemuCaps,
5291
                        bool primary)
5292 5293
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
5294
    const char *model;
5295

5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310
    if (primary) {
        model = qemuDeviceVideoTypeToString(video->type);
        if (!model || STREQ(model, "")) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("video type %s is not supported with QEMU"),
                           virDomainVideoTypeToString(video->type));
            goto error;
        }
    } else {
        if (video->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("non-primary video device must be type of 'qxl'"));
            goto error;
        }

5311
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL)) {
5312 5313 5314 5315 5316 5317
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("only one video card is currently supported"));
            goto error;
        }

        model = "qxl";
5318 5319
    }

5320
    virBufferAsprintf(&buf, "%s,id=%s", model, video->info.alias);
5321 5322

    if (video->type == VIR_DOMAIN_VIDEO_TYPE_QXL) {
5323
        if (video->vram > (UINT_MAX / 1024)) {
5324
            virReportError(VIR_ERR_OVERFLOW,
5325 5326
                           _("value for 'vram' must be less than '%u'"),
                           UINT_MAX / 1024);
5327 5328
            goto error;
        }
5329 5330 5331 5332 5333 5334 5335 5336 5337
        if (video->ram > (UINT_MAX / 1024)) {
            virReportError(VIR_ERR_OVERFLOW,
                           _("value for 'ram' must be less than '%u'"),
                           UINT_MAX / 1024);
            goto error;
        }

        /* QEMU accepts bytes for ram_size. */
        virBufferAsprintf(&buf, ",ram_size=%u", video->ram * 1024);
5338

5339
        /* QEMU accepts bytes for vram_size. */
5340
        virBufferAsprintf(&buf, ",vram_size=%u", video->vram * 1024);
5341 5342
    }

5343
    if (qemuBuildDeviceAddressStr(&buf, def, &video->info, qemuCaps) < 0)
5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365
        goto error;

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


int
qemuOpenPCIConfig(virDomainHostdevDefPtr dev)
{
    char *path = NULL;
    int configfd = -1;

    if (virAsprintf(&path, "/sys/bus/pci/devices/%04x:%02x:%02x.%01x/config",
5366 5367 5368
                    dev->source.subsys.u.pci.addr.domain,
                    dev->source.subsys.u.pci.addr.bus,
                    dev->source.subsys.u.pci.addr.slot,
5369
                    dev->source.subsys.u.pci.addr.function) < 0)
5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382
        return -1;

    configfd = open(path, O_RDWR, 0);

    if (configfd < 0)
        virReportSystemError(errno, _("Failed opening %s"), path);

    VIR_FREE(path);

    return configfd;
}

char *
5383 5384 5385
qemuBuildPCIHostdevDevStr(virDomainDefPtr def,
                          virDomainHostdevDefPtr dev,
                          const char *configfd,
5386
                          virQEMUCapsPtr qemuCaps)
5387 5388 5389
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

5390
    if (dev->source.subsys.u.pci.backend
5391
        == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO) {
5392 5393 5394 5395 5396 5397
        virBufferAddLit(&buf, "vfio-pci");
    } else {
        virBufferAddLit(&buf, "pci-assign");
        if (configfd && *configfd)
            virBufferAsprintf(&buf, ",configfd=%s", configfd);
    }
5398
    virBufferAsprintf(&buf, ",host=%.2x:%.2x.%.1x",
5399 5400 5401
                      dev->source.subsys.u.pci.addr.bus,
                      dev->source.subsys.u.pci.addr.slot,
                      dev->source.subsys.u.pci.addr.function);
5402 5403 5404
    virBufferAsprintf(&buf, ",id=%s", dev->info->alias);
    if (dev->info->bootIndex)
        virBufferAsprintf(&buf, ",bootindex=%d", dev->info->bootIndex);
5405
    if (qemuBuildDeviceAddressStr(&buf, def, dev->info, qemuCaps) < 0)
5406
        goto error;
5407
    if (qemuBuildRomStr(&buf, dev->info, qemuCaps) < 0)
5408
       goto error;
5409

5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427
    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


char *
qemuBuildPCIHostdevPCIDevStr(virDomainHostdevDefPtr dev)
{
    char *ret = NULL;

5428 5429 5430 5431
    ignore_value(virAsprintf(&ret, "host=%.2x:%.2x.%.1x",
                             dev->source.subsys.u.pci.addr.bus,
                             dev->source.subsys.u.pci.addr.slot,
                             dev->source.subsys.u.pci.addr.function));
5432 5433 5434 5435
    return ret;
}


5436
char *
5437 5438
qemuBuildRedirdevDevStr(virDomainDefPtr def,
                        virDomainRedirdevDefPtr dev,
5439
                        virQEMUCapsPtr qemuCaps)
5440
{
5441
    size_t i;
5442
    virBuffer buf = VIR_BUFFER_INITIALIZER;
5443
    virDomainRedirFilterDefPtr redirfilter = def->redirfilter;
5444 5445

    if (dev->bus != VIR_DOMAIN_REDIRDEV_BUS_USB) {
5446 5447 5448
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("Redirection bus %s is not supported by QEMU"),
                       virDomainRedirdevBusTypeToString(dev->bus));
5449 5450 5451
        goto error;
    }

5452
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR)) {
5453 5454 5455
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("USB redirection is not supported "
                         "by this version of QEMU"));
5456 5457 5458 5459 5460 5461 5462
        goto error;
    }

    virBufferAsprintf(&buf, "usb-redir,chardev=char%s,id=%s",
                      dev->info.alias,
                      dev->info.alias);

5463
    if (redirfilter && redirfilter->nusbdevs) {
5464
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR_FILTER)) {
5465 5466 5467 5468 5469 5470
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("USB redirection filter is not "
                             "supported by this version of QEMU"));
            goto error;
        }

5471
        virBufferAddLit(&buf, ",filter=");
5472 5473 5474 5475 5476 5477

        for (i = 0; i < redirfilter->nusbdevs; i++) {
            virDomainRedirFilterUsbDevDefPtr usbdev = redirfilter->usbdevs[i];
            if (usbdev->usbClass >= 0)
                virBufferAsprintf(&buf, "0x%02X:", usbdev->usbClass);
            else
5478
                virBufferAddLit(&buf, "-1:");
5479 5480 5481 5482

            if (usbdev->vendor >= 0)
                virBufferAsprintf(&buf, "0x%04X:", usbdev->vendor);
            else
5483
                virBufferAddLit(&buf, "-1:");
5484 5485 5486 5487

            if (usbdev->product >= 0)
                virBufferAsprintf(&buf, "0x%04X:", usbdev->product);
            else
5488
                virBufferAddLit(&buf, "-1:");
5489 5490 5491 5492

            if (usbdev->version >= 0)
                virBufferAsprintf(&buf, "0x%04X:", usbdev->version);
            else
5493
                virBufferAddLit(&buf, "-1:");
5494 5495 5496

            virBufferAsprintf(&buf, "%u", usbdev->allow);
            if (i < redirfilter->nusbdevs -1)
5497
                virBufferAddLit(&buf, "|");
5498 5499 5500
        }
    }

5501
    if (dev->info.bootIndex) {
5502
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR_BOOTINDEX)) {
5503 5504 5505 5506 5507 5508 5509 5510
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("USB redirection booting is not "
                             "supported by this version of QEMU"));
            goto error;
        }
        virBufferAsprintf(&buf, ",bootindex=%d", dev->info.bootIndex);
    }

5511
    if (qemuBuildDeviceAddressStr(&buf, def, &dev->info, qemuCaps) < 0)
5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525
        goto error;

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}

5526
char *
5527 5528
qemuBuildUSBHostdevDevStr(virDomainDefPtr def,
                          virDomainHostdevDefPtr dev,
5529
                          virQEMUCapsPtr qemuCaps)
5530
{
5531
    virBuffer buf = VIR_BUFFER_INITIALIZER;
5532

5533 5534
    if (!dev->missing &&
        !dev->source.subsys.u.usb.bus &&
5535
        !dev->source.subsys.u.usb.device) {
5536 5537
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("USB host device is missing bus/device information"));
5538 5539 5540
        return NULL;
    }

5541 5542 5543 5544 5545 5546 5547
    virBufferAddLit(&buf, "usb-host");
    if (!dev->missing) {
        virBufferAsprintf(&buf, ",hostbus=%d,hostaddr=%d",
                          dev->source.subsys.u.usb.bus,
                          dev->source.subsys.u.usb.device);
    }
    virBufferAsprintf(&buf, ",id=%s", dev->info->alias);
5548 5549
    if (dev->info->bootIndex)
        virBufferAsprintf(&buf, ",bootindex=%d", dev->info->bootIndex);
5550

5551
    if (qemuBuildDeviceAddressStr(&buf, def, dev->info, qemuCaps) < 0)
5552 5553 5554
        goto error;

    if (virBufferError(&buf)) {
5555
        virReportOOMError();
5556 5557
        goto error;
    }
5558

5559 5560 5561 5562 5563
    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
5564 5565 5566
}


M
Marc-André Lureau 已提交
5567
char *
5568 5569
qemuBuildHubDevStr(virDomainDefPtr def,
                   virDomainHubDefPtr dev,
5570
                   virQEMUCapsPtr qemuCaps)
M
Marc-André Lureau 已提交
5571 5572 5573 5574
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    if (dev->type != VIR_DOMAIN_HUB_TYPE_USB) {
5575 5576 5577
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("hub type %s not supported"),
                       virDomainHubTypeToString(dev->type));
M
Marc-André Lureau 已提交
5578 5579 5580
        goto error;
    }

5581
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_HUB)) {
5582
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
5583
                       _("usb-hub not supported by QEMU binary"));
M
Marc-André Lureau 已提交
5584 5585 5586 5587 5588
        goto error;
    }

    virBufferAddLit(&buf, "usb-hub");
    virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
5589
    if (qemuBuildDeviceAddressStr(&buf, def, &dev->info, qemuCaps) < 0)
M
Marc-André Lureau 已提交
5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604
        goto error;

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


5605 5606 5607 5608 5609
char *
qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev)
{
    char *ret = NULL;

5610 5611 5612 5613 5614 5615
    if (dev->missing) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("This QEMU doesn't not support missing USB devices"));
        return NULL;
    }

5616 5617
    if (!dev->source.subsys.u.usb.bus &&
        !dev->source.subsys.u.usb.device) {
5618 5619
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("USB host device is missing bus/device information"));
5620 5621 5622
        return NULL;
    }

5623 5624 5625
    ignore_value(virAsprintf(&ret, "host:%d.%d",
                             dev->source.subsys.u.usb.bus,
                             dev->source.subsys.u.usb.device));
5626 5627 5628
    return ret;
}

5629 5630
char *
qemuBuildSCSIHostdevDrvStr(virDomainHostdevDefPtr dev,
5631 5632
                           virQEMUCapsPtr qemuCaps ATTRIBUTE_UNUSED,
                           qemuBuildCommandLineCallbacksPtr callbacks)
5633 5634 5635 5636
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    char *sg = NULL;

5637 5638 5639 5640 5641
    sg = (callbacks->qemuGetSCSIDeviceSgName)(dev->source.subsys.u.scsi.adapter,
                                              dev->source.subsys.u.scsi.bus,
                                              dev->source.subsys.u.scsi.target,
                                              dev->source.subsys.u.scsi.unit);
    if (!sg)
5642 5643 5644 5645 5646 5647 5648
        goto error;

    virBufferAsprintf(&buf, "file=/dev/%s,if=none", sg);
    virBufferAsprintf(&buf, ",id=%s-%s",
                      virDomainDeviceAddressTypeToString(dev->info->type),
                      dev->info->alias);

O
Osier Yang 已提交
5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659
    if (dev->readonly) {
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_READONLY)) {
            virBufferAddLit(&buf, ",readonly=on");
        } else {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("this qemu doesn't support 'readonly' "
                             "for -drive"));
            goto error;
        }
    }

5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716
    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    VIR_FREE(sg);
    return virBufferContentAndReset(&buf);
error:
    VIR_FREE(sg);
    virBufferFreeAndReset(&buf);
    return NULL;
}

char *
qemuBuildSCSIHostdevDevStr(virDomainDefPtr def,
                           virDomainHostdevDefPtr dev,
                           virQEMUCapsPtr qemuCaps)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    int model = -1;

    model = virDomainDeviceFindControllerModel(def, dev->info,
                                               VIR_DOMAIN_CONTROLLER_TYPE_SCSI);

    if (qemuSetScsiControllerModel(def, qemuCaps, &model) < 0)
        goto error;

    if (model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
        if (dev->info->addr.drive.target != 0) {
           virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("target must be 0 for scsi host device "
                             "if its controller model is 'lsilogic'"));
            goto error;
        }

        if (dev->info->addr.drive.unit > 7) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("unit must be not more than 7 for scsi host "
                             "device if its controller model is 'lsilogic'"));
            goto error;
        }
    }

    virBufferAddLit(&buf, "scsi-generic");

    if (model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
        virBufferAsprintf(&buf, ",bus=scsi%d.%d,scsi-id=%d",
                          dev->info->addr.drive.controller,
                          dev->info->addr.drive.bus,
                          dev->info->addr.drive.unit);
    } else {
        virBufferAsprintf(&buf, ",bus=scsi%d.0,channel=%d,scsi-id=%d,lun=%d",
                          dev->info->addr.drive.controller,
                          dev->info->addr.drive.bus,
                          dev->info->addr.drive.target,
                          dev->info->addr.drive.unit);
    }
5717

5718 5719 5720 5721
    virBufferAsprintf(&buf, ",drive=%s-%s,id=%s",
                      virDomainDeviceAddressTypeToString(dev->info->type),
                      dev->info->alias, dev->info->alias);

5722 5723 5724
    if (dev->info->bootIndex)
        virBufferAsprintf(&buf, ",bootindex=%d", dev->info->bootIndex);

5725 5726 5727 5728 5729 5730 5731 5732 5733 5734
    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);
error:
    virBufferFreeAndReset(&buf);
    return NULL;
}
5735 5736 5737

/* This function outputs a -chardev command line option which describes only the
 * host side of the character device */
5738
static char *
5739
qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
5740
                       virQEMUCapsPtr qemuCaps)
5741 5742 5743 5744
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    bool telnet;

5745
    switch (dev->type) {
5746
    case VIR_DOMAIN_CHR_TYPE_NULL:
5747
        virBufferAsprintf(&buf, "null,id=char%s", alias);
5748 5749 5750
        break;

    case VIR_DOMAIN_CHR_TYPE_VC:
5751
        virBufferAsprintf(&buf, "vc,id=char%s", alias);
5752 5753 5754
        break;

    case VIR_DOMAIN_CHR_TYPE_PTY:
5755
        virBufferAsprintf(&buf, "pty,id=char%s", alias);
5756 5757 5758
        break;

    case VIR_DOMAIN_CHR_TYPE_DEV:
5759 5760 5761
        virBufferAsprintf(&buf, "%s,id=char%s,path=%s",
                          STRPREFIX(alias, "parallel") ? "parport" : "tty",
                          alias, dev->data.file.path);
5762 5763 5764
        break;

    case VIR_DOMAIN_CHR_TYPE_FILE:
5765
        virBufferAsprintf(&buf, "file,id=char%s,path=%s", alias,
5766
                          dev->data.file.path);
5767 5768 5769
        break;

    case VIR_DOMAIN_CHR_TYPE_PIPE:
5770
        virBufferAsprintf(&buf, "pipe,id=char%s,path=%s", alias,
5771
                          dev->data.file.path);
5772 5773 5774
        break;

    case VIR_DOMAIN_CHR_TYPE_STDIO:
5775
        virBufferAsprintf(&buf, "stdio,id=char%s", alias);
5776 5777
        break;

5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789
    case VIR_DOMAIN_CHR_TYPE_UDP: {
        const char *connectHost = dev->data.udp.connectHost;
        const char *bindHost = dev->data.udp.bindHost;
        const char *bindService = dev->data.udp.bindService;

        if (connectHost == NULL)
            connectHost = "";
        if (bindHost == NULL)
            bindHost = "";
        if (bindService == NULL)
            bindService = "0";

5790
        virBufferAsprintf(&buf,
5791 5792
                          "udp,id=char%s,host=%s,port=%s,localaddr=%s,"
                          "localport=%s",
5793
                          alias,
5794
                          connectHost,
5795
                          dev->data.udp.connectService,
5796
                          bindHost, bindService);
5797
        break;
5798
    }
5799 5800
    case VIR_DOMAIN_CHR_TYPE_TCP:
        telnet = dev->data.tcp.protocol == VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET;
5801
        virBufferAsprintf(&buf,
5802
                          "socket,id=char%s,host=%s,port=%s%s%s",
5803
                          alias,
5804 5805 5806 5807 5808 5809 5810
                          dev->data.tcp.host,
                          dev->data.tcp.service,
                          telnet ? ",telnet" : "",
                          dev->data.tcp.listen ? ",server,nowait" : "");
        break;

    case VIR_DOMAIN_CHR_TYPE_UNIX:
5811
        virBufferAsprintf(&buf,
5812
                          "socket,id=char%s,path=%s%s",
5813
                          alias,
5814 5815 5816
                          dev->data.nix.path,
                          dev->data.nix.listen ? ",server,nowait" : "");
        break;
5817 5818

    case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
5819
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
5820
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
5821
                           _("spicevmc not supported in this QEMU binary"));
5822 5823
            goto error;
        }
5824
        virBufferAsprintf(&buf, "spicevmc,id=char%s,name=%s", alias,
E
Eric Blake 已提交
5825
                          virDomainChrSpicevmcTypeToString(dev->data.spicevmc));
5826 5827 5828
        break;

    default:
5829 5830 5831
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("unsupported chardev '%s'"),
                       virDomainChrTypeToString(dev->type));
5832
        goto error;
5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847
    }

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


5848 5849
static char *
qemuBuildChrArgStr(virDomainChrSourceDefPtr dev, const char *prefix)
5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    if (prefix)
        virBufferAdd(&buf, prefix, strlen(prefix));

    switch (dev->type) {
    case VIR_DOMAIN_CHR_TYPE_NULL:
        virBufferAddLit(&buf, "null");
        break;

    case VIR_DOMAIN_CHR_TYPE_VC:
        virBufferAddLit(&buf, "vc");
        break;

    case VIR_DOMAIN_CHR_TYPE_PTY:
        virBufferAddLit(&buf, "pty");
        break;

    case VIR_DOMAIN_CHR_TYPE_DEV:
        virBufferStrcat(&buf, dev->data.file.path, NULL);
        break;

    case VIR_DOMAIN_CHR_TYPE_FILE:
5874
        virBufferAsprintf(&buf, "file:%s", dev->data.file.path);
5875 5876 5877
        break;

    case VIR_DOMAIN_CHR_TYPE_PIPE:
5878
        virBufferAsprintf(&buf, "pipe:%s", dev->data.file.path);
5879 5880 5881 5882 5883 5884
        break;

    case VIR_DOMAIN_CHR_TYPE_STDIO:
        virBufferAddLit(&buf, "stdio");
        break;

5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896
    case VIR_DOMAIN_CHR_TYPE_UDP: {
        const char *connectHost = dev->data.udp.connectHost;
        const char *bindHost = dev->data.udp.bindHost;
        const char *bindService  = dev->data.udp.bindService;

        if (connectHost == NULL)
            connectHost = "";
        if (bindHost == NULL)
            bindHost = "";
        if (bindService == NULL)
            bindService = "0";

5897
        virBufferAsprintf(&buf, "udp:%s:%s@%s:%s",
5898
                          connectHost,
5899
                          dev->data.udp.connectService,
5900 5901
                          bindHost,
                          bindService);
5902
        break;
5903
    }
5904 5905
    case VIR_DOMAIN_CHR_TYPE_TCP:
        if (dev->data.tcp.protocol == VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET) {
5906
            virBufferAsprintf(&buf, "telnet:%s:%s%s",
5907 5908 5909 5910
                              dev->data.tcp.host,
                              dev->data.tcp.service,
                              dev->data.tcp.listen ? ",server,nowait" : "");
        } else {
5911
            virBufferAsprintf(&buf, "tcp:%s:%s%s",
5912 5913 5914 5915 5916 5917 5918
                              dev->data.tcp.host,
                              dev->data.tcp.service,
                              dev->data.tcp.listen ? ",server,nowait" : "");
        }
        break;

    case VIR_DOMAIN_CHR_TYPE_UNIX:
5919
        virBufferAsprintf(&buf, "unix:%s%s",
5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937
                          dev->data.nix.path,
                          dev->data.nix.listen ? ",server,nowait" : "");
        break;
    }

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


5938 5939
static char *
qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
5940
                                virQEMUCapsPtr qemuCaps)
5941 5942
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
5943 5944
    switch (dev->deviceType) {
    case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
5945
        virBufferAddLit(&buf, "virtconsole");
5946 5947 5948 5949
        break;
    case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
        /* Legacy syntax  '-device spicevmc' */
        if (dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
5950
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC)) {
5951 5952 5953 5954 5955 5956
            virBufferAddLit(&buf, "spicevmc");
        } else {
            virBufferAddLit(&buf, "virtserialport");
        }
        break;
    default:
5957 5958
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Cannot use virtio serial for parallel/serial devices"));
5959 5960
        return NULL;
    }
5961

5962
    if (dev->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
5963
        dev->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW &&
5964
        dev->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390) {
5965 5966 5967 5968
        /* Check it's a virtio-serial address */
        if (dev->info.type !=
            VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL)
        {
5969 5970
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("virtio serial device has invalid address type"));
5971 5972 5973
            goto error;
        }

5974
        virBufferAsprintf(&buf,
5975 5976 5977
                          ",bus=" QEMU_VIRTIO_SERIAL_PREFIX "%d.%d",
                          dev->info.addr.vioserial.controller,
                          dev->info.addr.vioserial.bus);
5978
        virBufferAsprintf(&buf,
5979 5980 5981 5982
                          ",nr=%d",
                          dev->info.addr.vioserial.port);
    }

5983 5984
    if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
        dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
5985
        STRNEQ_NULLABLE(dev->target.name, "com.redhat.spice.0")) {
5986 5987 5988
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("Unsupported spicevmc target name '%s'"),
                       dev->target.name);
5989 5990
        goto error;
    }
5991 5992 5993

    if (!(dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
          dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
5994
          virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC))) {
5995
        virBufferAsprintf(&buf, ",chardev=char%s,id=%s",
5996
                          dev->info.alias, dev->info.alias);
5997 5998 5999
        if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL) {
            virBufferAsprintf(&buf, ",name=%s", dev->target.name
                              ? dev->target.name : "com.redhat.spice.0");
6000
        }
6001 6002
    } else {
        virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015
    }
    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}

6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047
static char *
qemuBuildSclpDevStr(virDomainChrDefPtr dev)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE) {
        switch (dev->targetType) {
        case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLP:
            virBufferAddLit(&buf, "sclpconsole");
            break;
        case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLPLM:
            virBufferAddLit(&buf, "sclplmconsole");
            break;
        }
    } else {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Cannot use slcp with devices other than console"));
        goto error;
    }
    virBufferAsprintf(&buf, ",chardev=char%s,id=%s",
                      dev->info.alias, dev->info.alias);
    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}

6048 6049 6050 6051 6052 6053 6054

static int
qemuBuildRNGBackendArgs(virCommandPtr cmd,
                        virDomainRNGDefPtr dev,
                        virQEMUCapsPtr qemuCaps)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
6055
    char *backend = NULL;
6056 6057 6058 6059 6060 6061 6062
    int ret = -1;

    switch ((enum virDomainRNGBackend) dev->backend) {
    case VIR_DOMAIN_RNG_BACKEND_RANDOM:
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_RANDOM)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("this qemu doesn't support the rng-random "
6063
                             "backend"));
6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075
            goto cleanup;
        }

        virBufferAsprintf(&buf, "rng-random,id=%s", dev->info.alias);
        if (dev->source.file)
            virBufferAsprintf(&buf, ",filename=%s", dev->source.file);

        virCommandAddArg(cmd, "-object");
        virCommandAddArgBuffer(cmd, &buf);
        break;

    case VIR_DOMAIN_RNG_BACKEND_EGD:
6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092

        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_EGD)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("this qemu doesn't support the rng-egd "
                             "backend"));
            goto cleanup;
        }

        if (!(backend = qemuBuildChrChardevStr(dev->source.chardev,
                                               dev->info.alias, qemuCaps)))
            goto cleanup;

        virCommandAddArgList(cmd, "-chardev", backend, NULL);

        virCommandAddArg(cmd, "-object");
        virCommandAddArgFormat(cmd, "rng-egd,chardev=char%s,id=%s",
                               dev->info.alias, dev->info.alias);
6093 6094 6095 6096 6097 6098 6099 6100 6101 6102
        break;

    case VIR_DOMAIN_RNG_BACKEND_LAST:
        break;
    }

    ret = 0;

cleanup:
    virBufferFreeAndReset(&buf);
6103
    VIR_FREE(backend);
6104 6105 6106 6107 6108 6109
    return ret;
}


static int
qemuBuildRNGDeviceArgs(virCommandPtr cmd,
6110
                       virDomainDefPtr def,
6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124
                       virDomainRNGDefPtr dev,
                       virQEMUCapsPtr qemuCaps)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    int ret = -1;

    if (dev->model != VIR_DOMAIN_RNG_MODEL_VIRTIO ||
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_RNG)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("this qemu doesn't support RNG device type '%s'"),
                       virDomainRNGModelTypeToString(dev->model));
        goto cleanup;
    }

6125 6126 6127 6128
    if (dev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW)
        virBufferAsprintf(&buf, "virtio-rng-ccw,rng=%s", dev->info.alias);
    else if (dev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390)
        virBufferAsprintf(&buf, "virtio-rng-s390,rng=%s", dev->info.alias);
6129 6130
    else if (dev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO)
        virBufferAsprintf(&buf, "virtio-rng-device,rng=%s", dev->info.alias);
6131 6132
    else
        virBufferAsprintf(&buf, "virtio-rng-pci,rng=%s", dev->info.alias);
6133

6134 6135 6136 6137 6138 6139 6140 6141
    if (dev->rate > 0) {
        virBufferAsprintf(&buf, ",max-bytes=%u", dev->rate);
        if (dev->period)
            virBufferAsprintf(&buf, ",period=%u", dev->period);
        else
            virBufferAddLit(&buf, ",period=1000");
    }

6142
    if (qemuBuildDeviceAddressStr(&buf, def, &dev->info, qemuCaps) < 0)
6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155
        goto cleanup;

    virCommandAddArg(cmd, "-device");
    virCommandAddArgBuffer(cmd, &buf);

    ret = 0;

cleanup:
    virBufferFreeAndReset(&buf);
    return ret;
}


6156 6157 6158 6159 6160 6161 6162
static char *qemuBuildTPMBackendStr(const virDomainDefPtr def,
                                    virQEMUCapsPtr qemuCaps,
                                    const char *emulator)
{
    const virDomainTPMDefPtr tpm = def->tpm;
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    const char *type = virDomainTPMBackendTypeToString(tpm->type);
6163 6164
    char *cancel_path;
    const char *tpmdev;
6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239

    virBufferAsprintf(&buf, "%s,id=tpm-%s", type, tpm->info.alias);

    switch (tpm->type) {
    case VIR_DOMAIN_TPM_TYPE_PASSTHROUGH:
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_TPM_PASSTHROUGH))
            goto no_support;

        tpmdev = tpm->data.passthrough.source.data.file.path;
        if (!(cancel_path = virTPMCreateCancelPath(tpmdev)))
            goto error;

        virBufferAddLit(&buf, ",path=");
        virBufferEscape(&buf, ',', ",", "%s", tpmdev);

        virBufferAddLit(&buf, ",cancel-path=");
        virBufferEscape(&buf, ',', ",", "%s", cancel_path);
        VIR_FREE(cancel_path);

        break;
    case VIR_DOMAIN_TPM_TYPE_LAST:
        goto error;
    }

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

 no_support:
    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                   _("The QEMU executable %s does not support TPM "
                     "backend type %s"),
                   emulator, type);

 error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


static char *qemuBuildTPMDevStr(const virDomainDefPtr def,
                                virQEMUCapsPtr qemuCaps,
                                const char *emulator)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    const virDomainTPMDefPtr tpm = def->tpm;
    const char *model = virDomainTPMModelTypeToString(tpm->model);

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_TPM_TIS)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("The QEMU executable %s does not support TPM "
                       "model %s"),
                       emulator, model);
        goto error;
    }

    virBufferAsprintf(&buf, "%s,tpmdev=tpm-%s,id=%s",
                      model, tpm->info.alias, tpm->info.alias);

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

 error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


6240 6241 6242 6243 6244 6245
static char *qemuBuildSmbiosBiosStr(virSysinfoDefPtr def)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    if ((def->bios_vendor == NULL) && (def->bios_version == NULL) &&
        (def->bios_date == NULL) && (def->bios_release == NULL))
6246
        return NULL;
6247 6248 6249 6250 6251

    virBufferAddLit(&buf, "type=0");

    /* 0:Vendor */
    if (def->bios_vendor)
6252
        virBufferAsprintf(&buf, ",vendor=%s", def->bios_vendor);
6253 6254
    /* 0:BIOS Version */
    if (def->bios_version)
6255
        virBufferAsprintf(&buf, ",version=%s", def->bios_version);
6256 6257
    /* 0:BIOS Release Date */
    if (def->bios_date)
6258
        virBufferAsprintf(&buf, ",date=%s", def->bios_date);
6259 6260
    /* 0:System BIOS Major Release and 0:System BIOS Minor Release */
    if (def->bios_release)
6261
        virBufferAsprintf(&buf, ",release=%s", def->bios_release);
6262 6263 6264 6265 6266 6267 6268 6269 6270 6271

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
6272
    return NULL;
6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288
}

static char *qemuBuildSmbiosSystemStr(virSysinfoDefPtr def, bool skip_uuid)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    if ((def->system_manufacturer == NULL) && (def->system_sku == NULL) &&
        (def->system_product == NULL) && (def->system_version == NULL) &&
        (def->system_serial == NULL) && (def->system_family == NULL) &&
        (def->system_uuid == NULL || skip_uuid))
        return NULL;

    virBufferAddLit(&buf, "type=1");

    /* 1:Manufacturer */
    if (def->system_manufacturer)
6289
        virBufferAsprintf(&buf, ",manufacturer=%s",
6290 6291 6292
                          def->system_manufacturer);
     /* 1:Product Name */
    if (def->system_product)
6293
        virBufferAsprintf(&buf, ",product=%s", def->system_product);
6294 6295
    /* 1:Version */
    if (def->system_version)
6296
        virBufferAsprintf(&buf, ",version=%s", def->system_version);
6297 6298
    /* 1:Serial Number */
    if (def->system_serial)
6299
        virBufferAsprintf(&buf, ",serial=%s", def->system_serial);
6300 6301
    /* 1:UUID */
    if (def->system_uuid && !skip_uuid)
6302
        virBufferAsprintf(&buf, ",uuid=%s", def->system_uuid);
6303 6304
    /* 1:SKU Number */
    if (def->system_sku)
6305
        virBufferAsprintf(&buf, ",sku=%s", def->system_sku);
6306 6307
    /* 1:Family */
    if (def->system_family)
6308
        virBufferAsprintf(&buf, ",family=%s", def->system_family);
6309 6310 6311 6312 6313 6314 6315 6316 6317 6318

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
6319
    return NULL;
6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340
}

static char *
qemuBuildClockArgStr(virDomainClockDefPtr def)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    switch (def->offset) {
    case VIR_DOMAIN_CLOCK_OFFSET_UTC:
        virBufferAddLit(&buf, "base=utc");
        break;

    case VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME:
    case VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE:
        virBufferAddLit(&buf, "base=localtime");
        break;

    case VIR_DOMAIN_CLOCK_OFFSET_VARIABLE: {
        time_t now = time(NULL);
        struct tm nowbits;

6341
        if (def->data.variable.basis != VIR_DOMAIN_CLOCK_BASIS_UTC) {
6342 6343 6344
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("unsupported clock basis '%s'"),
                           virDomainClockBasisTypeToString(def->data.variable.basis));
6345 6346 6347
            goto error;
        }
        now += def->data.variable.adjustment;
6348 6349
        gmtime_r(&now, &nowbits);

6350 6351 6352
        /* Store the guest's basedate */
        def->data.variable.basedate = now;

6353
        virBufferAsprintf(&buf, "base=%d-%02d-%02dT%02d:%02d:%02d",
6354 6355 6356 6357 6358 6359 6360 6361 6362
                          nowbits.tm_year + 1900,
                          nowbits.tm_mon + 1,
                          nowbits.tm_mday,
                          nowbits.tm_hour,
                          nowbits.tm_min,
                          nowbits.tm_sec);
    }   break;

    default:
6363 6364 6365
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("unsupported clock offset '%s'"),
                       virDomainClockOffsetTypeToString(def->offset));
6366 6367 6368 6369
        goto error;
    }

    /* Look for an 'rtc' timer element, and add in appropriate clock= and driftfix= */
6370
    size_t i;
6371 6372 6373 6374 6375 6376
    for (i = 0; i < def->ntimers; i++) {
        if (def->timers[i]->name == VIR_DOMAIN_TIMER_NAME_RTC) {
            switch (def->timers[i]->track) {
            case -1: /* unspecified - use hypervisor default */
                break;
            case VIR_DOMAIN_TIMER_TRACK_BOOT:
6377 6378 6379
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("unsupported rtc timer track '%s'"),
                               virDomainTimerTrackTypeToString(def->timers[i]->track));
6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400
                goto error;
            case VIR_DOMAIN_TIMER_TRACK_GUEST:
                virBufferAddLit(&buf, ",clock=vm");
                break;
            case VIR_DOMAIN_TIMER_TRACK_WALL:
                virBufferAddLit(&buf, ",clock=host");
                break;
            }

            switch (def->timers[i]->tickpolicy) {
            case -1:
            case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
                /* This is the default - missed ticks delivered when
                   next scheduled, at normal rate */
                break;
            case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
                /* deliver ticks at a faster rate until caught up */
                virBufferAddLit(&buf, ",driftfix=slew");
                break;
            case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
            case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
6401 6402 6403
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("unsupported rtc timer tickpolicy '%s'"),
                               virDomainTimerTickpolicyTypeToString(def->timers[i]->tickpolicy));
6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423
                goto error;
            }
            break; /* no need to check other timers - there is only one rtc */
        }
    }

    if (virBufferError(&buf)) {
        virReportOOMError();
        goto error;
    }

    return virBufferContentAndReset(&buf);

error:
    virBufferFreeAndReset(&buf);
    return NULL;
}


static int
6424
qemuBuildCpuArgStr(const virQEMUDriverPtr driver,
6425 6426
                   const virDomainDefPtr def,
                   const char *emulator,
6427
                   virQEMUCapsPtr qemuCaps,
6428
                   virArch hostarch,
6429
                   char **opt,
6430 6431
                   bool *hasHwVirt,
                   bool migrating)
6432
{
6433
    virCPUDefPtr host = NULL;
6434
    virCPUDefPtr guest = NULL;
6435
    virCPUDefPtr cpu = NULL;
6436
    size_t ncpus = 0;
6437
    char **cpus = NULL;
6438
    const char *default_model;
6439
    virCPUDataPtr data = NULL;
6440
    bool have_cpu = false;
6441
    char *compare_msg = NULL;
6442 6443
    int ret = -1;
    virBuffer buf = VIR_BUFFER_INITIALIZER;
6444
    size_t i;
6445
    virCapsPtr caps = NULL;
6446 6447 6448

    *hasHwVirt = false;

6449 6450 6451 6452 6453
    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
        goto cleanup;

    host = caps->host.cpu;

6454
    if (def->os.arch == VIR_ARCH_I686)
6455 6456 6457 6458
        default_model = "qemu32";
    else
        default_model = "qemu64";

6459 6460
    if (def->cpu &&
        (def->cpu->mode != VIR_CPU_MODE_CUSTOM || def->cpu->model)) {
6461 6462 6463
        virCPUCompareResult cmp;
        const char *preferred;

6464
        if (!host ||
J
Jiri Denemark 已提交
6465
            !host->model ||
6466
            (ncpus = virQEMUCapsGetCPUDefinitions(qemuCaps, &cpus)) == 0) {
6467 6468
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("CPU specification not supported by hypervisor"));
6469 6470 6471
            goto cleanup;
        }

6472 6473 6474 6475 6476 6477 6478 6479
        if (!(cpu = virCPUDefCopy(def->cpu)))
            goto cleanup;

        if (cpu->mode != VIR_CPU_MODE_CUSTOM &&
            !migrating &&
            cpuUpdate(cpu, host) < 0)
            goto cleanup;

6480
        cmp = cpuGuestData(host, cpu, &data, &compare_msg);
6481 6482
        switch (cmp) {
        case VIR_CPU_COMPARE_INCOMPATIBLE:
6483
            if (compare_msg) {
6484 6485 6486
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("guest and host CPU are not compatible: %s"),
                               compare_msg);
6487
            } else {
6488 6489
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("guest CPU is not compatible with host CPU"));
6490
            }
6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501
            /* fall through */
        case VIR_CPU_COMPARE_ERROR:
            goto cleanup;

        default:
            break;
        }

        /* Only 'svm' requires --enable-nesting. The nested
         * 'vmx' patches now simply hook off the CPU features
         */
6502 6503 6504 6505 6506 6507 6508
        if (def->os.arch == VIR_ARCH_X86_64 ||
            def->os.arch == VIR_ARCH_I686) {
            int hasSVM = cpuHasFeature(data, "svm");
            if (hasSVM < 0)
                goto cleanup;
            *hasHwVirt = hasSVM > 0 ? true : false;
        }
6509

6510 6511
        if (cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH) {
            const char *mode = virCPUModeTypeToString(cpu->mode);
6512
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_HOST)) {
6513 6514 6515
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("CPU mode '%s' is not supported by QEMU"
                                 " binary"), mode);
6516 6517 6518
                goto cleanup;
            }
            if (def->virtType != VIR_DOMAIN_VIRT_KVM) {
6519 6520 6521
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("CPU mode '%s' is only supported with kvm"),
                               mode);
6522 6523 6524 6525
                goto cleanup;
            }
            virBufferAddLit(&buf, "host");
        } else {
6526
            if (VIR_ALLOC(guest) < 0)
6527 6528 6529
                goto cleanup;
            if (VIR_STRDUP(guest->vendor_id, cpu->vendor_id) < 0)
                goto cleanup;
6530

6531
            guest->arch = host->arch;
6532 6533
            if (cpu->match == VIR_CPU_MATCH_MINIMUM)
                preferred = host->model;
6534
            else
6535
                preferred = cpu->model;
6536

6537 6538
            guest->type = VIR_CPU_TYPE_GUEST;
            guest->fallback = cpu->fallback;
6539
            if (cpuDecode(guest, data, (const char **)cpus, ncpus, preferred) < 0)
6540 6541 6542
                goto cleanup;

            virBufferAdd(&buf, guest->model, -1);
6543 6544
            if (guest->vendor_id)
                virBufferAsprintf(&buf, ",vendor=%s", guest->vendor_id);
6545 6546 6547 6548 6549 6550 6551 6552 6553
            for (i = 0; i < guest->nfeatures; i++) {
                char sign;
                if (guest->features[i].policy == VIR_CPU_FEATURE_DISABLE)
                    sign = '-';
                else
                    sign = '+';

                virBufferAsprintf(&buf, ",%c%s", sign, guest->features[i].name);
            }
6554
        }
6555
        have_cpu = true;
6556
    } else {
6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568
        /*
         * Need to force a 32-bit guest CPU type if
         *
         *  1. guest OS is i686
         *  2. host OS is x86_64
         *  3. emulator is qemu-kvm or kvm
         *
         * Or
         *
         *  1. guest OS is i686
         *  2. emulator is qemu-system-x86_64
         */
6569
        if (def->os.arch == VIR_ARCH_I686 &&
6570
            ((hostarch == VIR_ARCH_X86_64 &&
6571
              strstr(emulator, "kvm")) ||
6572 6573 6574 6575 6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589
             strstr(emulator, "x86_64"))) {
            virBufferAdd(&buf, default_model, -1);
            have_cpu = true;
        }
    }

    /* Now force kvmclock on/off based on the corresponding <timer> element.  */
    for (i = 0; i < def->clock.ntimers; i++) {
        if (def->clock.timers[i]->name == VIR_DOMAIN_TIMER_NAME_KVMCLOCK &&
            def->clock.timers[i]->present != -1) {
            char sign;
            if (def->clock.timers[i]->present)
                sign = '+';
            else
                sign = '-';
            virBufferAsprintf(&buf, "%s,%ckvmclock",
                              have_cpu ? "" : default_model,
                              sign);
M
Martin Kletzander 已提交
6590
            have_cpu = true;
6591 6592
            break;
        }
6593 6594
    }

6595 6596
    if (def->apic_eoi) {
        char sign;
6597
        if (def->apic_eoi == VIR_DOMAIN_FEATURE_STATE_ON)
6598 6599 6600 6601 6602 6603 6604
            sign = '+';
        else
            sign = '-';

        virBufferAsprintf(&buf, "%s,%ckvm_pv_eoi",
                          have_cpu ? "" : default_model,
                          sign);
M
Martin Kletzander 已提交
6605
        have_cpu = true;
6606 6607
    }

6608 6609 6610 6611 6612 6613 6614 6615 6616
    if (def->features & (1 << VIR_DOMAIN_FEATURE_HYPERV)) {
        if (!have_cpu) {
            virBufferAdd(&buf, default_model, -1);
            have_cpu = true;
        }

        for (i = 0; i < VIR_DOMAIN_HYPERV_LAST; i++) {
            switch ((enum virDomainHyperv) i) {
            case VIR_DOMAIN_HYPERV_RELAXED:
6617
            case VIR_DOMAIN_HYPERV_VAPIC:
6618 6619 6620 6621 6622
                if (def->hyperv_features[i] == VIR_DOMAIN_FEATURE_STATE_ON)
                    virBufferAsprintf(&buf, ",hv_%s",
                                      virDomainHypervTypeToString(i));
                break;

6623
            case VIR_DOMAIN_HYPERV_SPINLOCKS:
6624 6625 6626
                if (def->hyperv_features[i] == VIR_DOMAIN_FEATURE_STATE_ON)
                    virBufferAsprintf(&buf, ",hv_spinlocks=0x%x",
                                      def->hyperv_spinlocks);
6627 6628
                break;

6629 6630 6631 6632 6633 6634
            case VIR_DOMAIN_HYPERV_LAST:
                break;
            }
        }
    }

6635 6636 6637 6638
    if (virBufferError(&buf)) {
        virReportOOMError();
        goto cleanup;
    }
6639 6640 6641 6642 6643 6644

    *opt = virBufferContentAndReset(&buf);

    ret = 0;

cleanup:
6645
    VIR_FREE(compare_msg);
J
Jiri Denemark 已提交
6646
    cpuDataFree(data);
6647
    virCPUDefFree(guest);
6648
    virCPUDefFree(cpu);
6649
    virObjectUnref(caps);
6650 6651 6652
    return ret;
}

6653 6654 6655 6656 6657
static int
qemuBuildObsoleteAccelArg(virCommandPtr cmd,
                          const virDomainDefPtr def,
                          virQEMUCapsPtr qemuCaps)
{
6658 6659 6660 6661
    bool disableKQEMU = false;
    bool enableKQEMU = false;
    bool disableKVM = false;
    bool enableKVM = false;
6662 6663 6664 6665

    switch (def->virtType) {
    case VIR_DOMAIN_VIRT_QEMU:
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
6666
            disableKQEMU = true;
6667
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
6668
            disableKVM = true;
6669 6670 6671 6672
        break;

    case VIR_DOMAIN_VIRT_KQEMU:
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
6673
            disableKVM = true;
6674 6675

        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU)) {
6676
            enableKQEMU = true;
6677 6678 6679 6680 6681 6682 6683 6684 6685
        } else if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KQEMU)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("the QEMU binary does not support kqemu"));
            return -1;
        }
        break;

    case VIR_DOMAIN_VIRT_KVM:
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
6686
            disableKQEMU = true;
6687 6688

        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM)) {
6689
            enableKVM = true;
6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719
        } else if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("the QEMU binary does not support kvm"));
            return -1;
        }
        break;

    case VIR_DOMAIN_VIRT_XEN:
        /* XXX better check for xenner */
        break;

    default:
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("the QEMU binary does not support %s"),
                       virDomainVirtTypeToString(def->virtType));
        return -1;
    }

    if (disableKQEMU)
        virCommandAddArg(cmd, "-no-kqemu");
    else if (enableKQEMU)
        virCommandAddArgList(cmd, "-enable-kqemu", "-kernel-kqemu", NULL);
    if (disableKVM)
        virCommandAddArg(cmd, "-no-kvm");
    if (enableKVM)
        virCommandAddArg(cmd, "-enable-kvm");

    return 0;
}

6720 6721 6722
static int
qemuBuildMachineArgStr(virCommandPtr cmd,
                       const virDomainDefPtr def,
6723
                       virQEMUCapsPtr qemuCaps)
6724
{
6725 6726
    bool obsoleteAccel = false;

6727 6728 6729 6730 6731 6732 6733
    /* This should *never* be NULL, since we always provide
     * a machine in the capabilities data for QEMU. So this
     * check is just here as a safety in case the unexpected
     * happens */
    if (!def->os.machine)
        return 0;

6734
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MACHINE_OPT)) {
6735 6736 6737 6738
        /* if no parameter to the machine type is needed, we still use
         * '-M' to keep the most of the compatibility with older versions.
         */
        virCommandAddArgList(cmd, "-M", def->os.machine, NULL);
6739 6740 6741 6742
        if (def->mem.dump_core) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("dump-guest-core is not available "
                             "with this QEMU binary"));
6743 6744
            return -1;
        }
6745 6746 6747 6748 6749 6750 6751 6752

        if (def->mem.nosharepages) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("disable shared memory is not available "
                             "with this QEMU binary"));
             return -1;
        }

6753
        obsoleteAccel = true;
6754 6755
    } else {
        virBuffer buf = VIR_BUFFER_INITIALIZER;
6756 6757

        virCommandAddArg(cmd, "-machine");
6758 6759
        virBufferAdd(&buf, def->os.machine, -1);

6760 6761 6762 6763 6764 6765 6766
        if (def->virtType == VIR_DOMAIN_VIRT_QEMU)
            virBufferAddLit(&buf, ",accel=tcg");
        else if (def->virtType == VIR_DOMAIN_VIRT_KVM)
            virBufferAddLit(&buf, ",accel=kvm");
        else
            obsoleteAccel = true;

L
Li Zhang 已提交
6767 6768 6769 6770
        /* To avoid the collision of creating USB controllers when calling
         * machine->init in QEMU, it needs to set usb=off
         */
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MACHINE_USB_OPT))
6771
            virBufferAddLit(&buf, ",usb=off");
L
Li Zhang 已提交
6772

6773 6774 6775 6776 6777
        if (def->mem.dump_core) {
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DUMP_GUEST_CORE)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("dump-guest-core is not available "
                                 "with this QEMU binary"));
6778
                virBufferFreeAndReset(&buf);
6779 6780 6781 6782 6783 6784 6785
                return -1;
            }

            virBufferAsprintf(&buf, ",dump-guest-core=%s",
                              virDomainMemDumpTypeToString(def->mem.dump_core));
        }

6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797
        if (def->mem.nosharepages) {
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MEM_MERGE)) {
                virBufferAddLit(&buf, ",mem-merge=off");
            } else {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("disable shared memory is not available "
                                 "with this QEMU binary"));
                virBufferFreeAndReset(&buf);
                return -1;
            }
        }

6798
        virCommandAddArgBuffer(cmd, &buf);
6799 6800
    }

6801 6802 6803 6804
    if (obsoleteAccel &&
        qemuBuildObsoleteAccelArg(cmd, def, qemuCaps) < 0)
        return -1;

6805 6806 6807
    return 0;
}

6808 6809
static char *
qemuBuildSmpArgStr(const virDomainDefPtr def,
6810
                   virQEMUCapsPtr qemuCaps)
6811 6812 6813
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

6814
    virBufferAsprintf(&buf, "%u", def->vcpus);
6815

6816
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY)) {
6817
        if (def->vcpus != def->maxvcpus)
6818
            virBufferAsprintf(&buf, ",maxcpus=%u", def->maxvcpus);
6819 6820 6821
        /* sockets, cores, and threads are either all zero
         * or all non-zero, thus checking one of them is enough */
        if (def->cpu && def->cpu->sockets) {
6822 6823 6824
            virBufferAsprintf(&buf, ",sockets=%u", def->cpu->sockets);
            virBufferAsprintf(&buf, ",cores=%u", def->cpu->cores);
            virBufferAsprintf(&buf, ",threads=%u", def->cpu->threads);
6825 6826
        }
        else {
6827 6828 6829
            virBufferAsprintf(&buf, ",sockets=%u", def->maxvcpus);
            virBufferAsprintf(&buf, ",cores=%u", 1);
            virBufferAsprintf(&buf, ",threads=%u", 1);
6830 6831 6832 6833
        }
    } else if (def->vcpus != def->maxvcpus) {
        virBufferFreeAndReset(&buf);
        /* FIXME - consider hot-unplugging cpus after boot for older qemu */
6834 6835 6836
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("setting current vcpu count less than maximum is "
                         "not supported with this QEMU binary"));
6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848
        return NULL;
    }

    if (virBufferError(&buf)) {
        virBufferFreeAndReset(&buf);
        virReportOOMError();
        return NULL;
    }

    return virBufferContentAndReset(&buf);
}

B
Bharata B Rao 已提交
6849 6850 6851
static int
qemuBuildNumaArgStr(const virDomainDefPtr def, virCommandPtr cmd)
{
6852
    size_t i;
B
Bharata B Rao 已提交
6853
    virBuffer buf = VIR_BUFFER_INITIALIZER;
6854 6855
    char *cpumask = NULL;
    int ret = -1;
B
Bharata B Rao 已提交
6856 6857

    for (i = 0; i < def->cpu->ncells; i++) {
6858
        VIR_FREE(cpumask);
B
Bharata B Rao 已提交
6859 6860 6861
        virCommandAddArg(cmd, "-numa");
        virBufferAsprintf(&buf, "node,nodeid=%d", def->cpu->cells[i].cellid);
        virBufferAddLit(&buf, ",cpus=");
6862 6863
        cpumask = virBitmapFormat(def->cpu->cells[i].cpumask);
        if (cpumask) {
6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876
            /* Up through qemu 1.4, -numa does not accept a cpus
             * argument any more complex than start-stop.
             *
             * XXX For qemu 1.5, the syntax has not yet been decided;
             * but when it is, we need a capability bit and
             * translation of our cpumask into the qemu syntax.  */
            if (strchr(cpumask, ',')) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("disjoint NUMA cpu ranges are not supported "
                                 "with this QEMU"));
                goto cleanup;
            }
            virBufferAdd(&buf, cpumask, -1);
6877
        }
6878 6879
        def->cpu->cells[i].mem = VIR_DIV_UP(def->cpu->cells[i].mem,
                                            1024) * 1024;
6880
        virBufferAsprintf(&buf, ",mem=%d", def->cpu->cells[i].mem / 1024);
B
Bharata B Rao 已提交
6881

6882 6883 6884 6885
        if (virBufferError(&buf)) {
            virReportOOMError();
            goto cleanup;
        }
B
Bharata B Rao 已提交
6886 6887 6888

        virCommandAddArgBuffer(cmd, &buf);
    }
6889
    ret = 0;
B
Bharata B Rao 已提交
6890

6891 6892
cleanup:
    VIR_FREE(cpumask);
B
Bharata B Rao 已提交
6893
    virBufferFreeAndReset(&buf);
6894
    return ret;
B
Bharata B Rao 已提交
6895
}
6896

6897

6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921
static int
qemuBuildGraphicsVNCCommandLine(virQEMUDriverConfigPtr cfg,
                                virCommandPtr cmd,
                                virDomainDefPtr def,
                                virQEMUCapsPtr qemuCaps,
                                virDomainGraphicsDefPtr graphics)
{
    virBuffer opt = VIR_BUFFER_INITIALIZER;
    const char *listenNetwork;
    const char *listenAddr = NULL;
    char *netAddr = NULL;
    bool escapeAddr;
    int ret;

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("vnc graphics are not supported with this QEMU"));
        goto error;
    }

    if (graphics->data.vnc.socket || cfg->vncAutoUnixSocket) {
        if (!graphics->data.vnc.socket &&
            virAsprintf(&graphics->data.vnc.socket,
                        "%s/%s.vnc", cfg->libDir, def->name) == -1)
6922
            goto error;
6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975

        virBufferAsprintf(&opt, "unix:%s", graphics->data.vnc.socket);

    } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
        switch (virDomainGraphicsListenGetType(graphics, 0)) {
        case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS:
            listenAddr = virDomainGraphicsListenGetAddress(graphics, 0);
            break;

        case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK:
            listenNetwork = virDomainGraphicsListenGetNetwork(graphics, 0);
            if (!listenNetwork)
                break;
            ret = networkGetNetworkAddress(listenNetwork, &netAddr);
            if (ret <= -2) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("network-based listen not possible, "
                                       "network driver not present"));
                goto error;
            }
            if (ret < 0) {
                virReportError(VIR_ERR_XML_ERROR,
                               _("listen network '%s' had no usable address"),
                               listenNetwork);
                goto error;
            }
            listenAddr = netAddr;
            /* store the address we found in the <graphics> element so it will
             * show up in status. */
            if (virDomainGraphicsListenSetAddress(graphics, 0,
                                                  listenAddr, -1, false) < 0)
               goto error;
            break;
        }

        if (!listenAddr)
            listenAddr = cfg->vncListen;

        escapeAddr = strchr(listenAddr, ':') != NULL;
        if (escapeAddr)
            virBufferAsprintf(&opt, "[%s]", listenAddr);
        else
            virBufferAdd(&opt, listenAddr, -1);
        virBufferAsprintf(&opt, ":%d",
                          graphics->data.vnc.port - 5900);

        VIR_FREE(netAddr);
    } else {
        virBufferAsprintf(&opt, "%d",
                          graphics->data.vnc.port - 5900);
    }

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986
        if (!graphics->data.vnc.socket &&
            graphics->data.vnc.websocket) {
                if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC_WEBSOCKET)) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("VNC WebSockets are not supported "
                                     "with this QEMU binary"));
                    goto error;
                }
                virBufferAsprintf(&opt, ",websocket=%d", graphics->data.vnc.websocket);
            }

6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999
        if (graphics->data.vnc.sharePolicy) {
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC_SHARE_POLICY)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("vnc display sharing policy is not "
                                 "supported with this QEMU"));
                goto error;
            }

            virBufferAsprintf(&opt, ",share=%s",
                              virDomainGraphicsVNCSharePolicyTypeToString(
                              graphics->data.vnc.sharePolicy));
        }

7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043
        if (graphics->data.vnc.auth.passwd || cfg->vncPassword)
            virBufferAddLit(&opt, ",password");

        if (cfg->vncTLS) {
            virBufferAddLit(&opt, ",tls");
            if (cfg->vncTLSx509verify)
                virBufferAsprintf(&opt, ",x509verify=%s", cfg->vncTLSx509certdir);
            else
                virBufferAsprintf(&opt, ",x509=%s", cfg->vncTLSx509certdir);
        }

        if (cfg->vncSASL) {
            virBufferAddLit(&opt, ",sasl");

            if (cfg->vncSASLdir)
                virCommandAddEnvPair(cmd, "SASL_CONF_DIR", cfg->vncSASLdir);

            /* TODO: Support ACLs later */
        }
    }

    virCommandAddArg(cmd, "-vnc");
    virCommandAddArgBuffer(cmd, &opt);
    if (graphics->data.vnc.keymap)
        virCommandAddArgList(cmd, "-k", graphics->data.vnc.keymap, NULL);

    /* Unless user requested it, set the audio backend to none, to
     * prevent it opening the host OS audio devices, since that causes
     * security issues and might not work when using VNC.
     */
    if (cfg->vncAllowHostAudio)
        virCommandAddEnvPass(cmd, "QEMU_AUDIO_DRV");
    else
        virCommandAddEnvString(cmd, "QEMU_AUDIO_DRV=none");

    return 0;

error:
    VIR_FREE(netAddr);
    virBufferFreeAndReset(&opt);
    return -1;
}


7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057
static int
qemuBuildGraphicsSPICECommandLine(virQEMUDriverConfigPtr cfg,
                                  virCommandPtr cmd,
                                  virQEMUCapsPtr qemuCaps,
                                  virDomainGraphicsDefPtr graphics)
{
    virBuffer opt = VIR_BUFFER_INITIALIZER;
    const char *listenNetwork;
    const char *listenAddr = NULL;
    char *netAddr = NULL;
    int ret;
    int defaultMode = graphics->data.spice.defaultMode;
    int port = graphics->data.spice.port;
    int tlsPort = graphics->data.spice.tlsPort;
7058
    size_t i;
7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SPICE)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("spice graphics are not supported with this QEMU"));
        goto error;
    }

    if (port > 0 || tlsPort <= 0)
        virBufferAsprintf(&opt, "port=%u", port);

    if (tlsPort > 0) {
        if (!cfg->spiceTLS) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("spice TLS port set in XML configuration,"
                             " but TLS is disabled in qemu.conf"));
            goto error;
        }
        if (port > 0)
            virBufferAddChar(&opt, ',');
        virBufferAsprintf(&opt, "tls-port=%u", tlsPort);
    }

    switch (virDomainGraphicsListenGetType(graphics, 0)) {
    case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS:
        listenAddr = virDomainGraphicsListenGetAddress(graphics, 0);
        break;

    case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK:
        listenNetwork = virDomainGraphicsListenGetNetwork(graphics, 0);
        if (!listenNetwork)
            break;
        ret = networkGetNetworkAddress(listenNetwork, &netAddr);
        if (ret <= -2) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("network-based listen not possible, "
                                   "network driver not present"));
            goto error;
        }
        if (ret < 0) {
            virReportError(VIR_ERR_XML_ERROR,
                           _("listen network '%s' had no usable address"),
                           listenNetwork);
            goto error;
        }
        listenAddr = netAddr;
        /* store the address we found in the <graphics> element so it will
         * show up in status. */
        if (virDomainGraphicsListenSetAddress(graphics, 0,
                                              listenAddr, -1, false) < 0)
           goto error;
        break;
    }

    if (!listenAddr)
        listenAddr = cfg->spiceListen;
    if (listenAddr)
        virBufferAsprintf(&opt, ",addr=%s", listenAddr);

    VIR_FREE(netAddr);

    if (graphics->data.spice.mousemode) {
        switch (graphics->data.spice.mousemode) {
        case VIR_DOMAIN_GRAPHICS_SPICE_MOUSE_MODE_SERVER:
7122
            virBufferAddLit(&opt, ",agent-mouse=off");
7123 7124
            break;
        case VIR_DOMAIN_GRAPHICS_SPICE_MOUSE_MODE_CLIENT:
7125
            virBufferAddLit(&opt, ",agent-mouse=on");
7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138
            break;
        default:
            break;
        }
    }

    /* In the password case we set it via monitor command, to avoid
     * making it visible on CLI, so there's no use of password=XXX
     * in this bit of the code */
    if (!graphics->data.spice.auth.passwd &&
        !cfg->spicePassword)
        virBufferAddLit(&opt, ",disable-ticketing");

7139 7140
    if (tlsPort > 0)
        virBufferAsprintf(&opt, ",x509-dir=%s", cfg->spiceTLSx509certdir);
7141 7142 7143

    switch (defaultMode) {
    case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
7144
        virBufferAddLit(&opt, ",tls-channel=default");
7145 7146
        break;
    case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE:
7147
        virBufferAddLit(&opt, ",plaintext-channel=default");
7148 7149 7150 7151 7152 7153
        break;
    case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_ANY:
        /* nothing */
        break;
    }

7154
    for (i = 0; i < VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_LAST; i++) {
7155
        switch (graphics->data.spice.channels[i]) {
7156
        case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
7157
            if (tlsPort <= 0) {
7158 7159
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("spice secure channels set in XML configuration, "
7160
                                 "but TLS port is not provided"));
7161 7162 7163 7164 7165
                goto error;
            }
            virBufferAsprintf(&opt, ",tls-channel=%s",
                              virDomainGraphicsSpiceChannelNameTypeToString(i));
            break;
7166

7167
        case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE:
7168 7169 7170 7171 7172 7173
            if (port <= 0) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("spice insecure channels set in XML "
                                 "configuration, but plain port is not provided"));
                goto error;
            }
7174 7175 7176
            virBufferAsprintf(&opt, ",plaintext-channel=%s",
                              virDomainGraphicsSpiceChannelNameTypeToString(i));
            break;
7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201

        case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_ANY:
            switch (defaultMode) {
            case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
                if (tlsPort <= 0) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("spice defaultMode secure requested in XML "
                                     "configuration but TLS port not provided"));
                    goto error;
                }
                break;

            case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE:
                if (port <= 0) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("spice defaultMode insecure requested in XML "
                                     "configuration but plain port not provided"));
                    goto error;
                }
                break;

            case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_ANY:
                /* don't care */
            break;
            }
7202 7203
        }
    }
7204

7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248
    if (graphics->data.spice.image)
        virBufferAsprintf(&opt, ",image-compression=%s",
                          virDomainGraphicsSpiceImageCompressionTypeToString(graphics->data.spice.image));
    if (graphics->data.spice.jpeg)
        virBufferAsprintf(&opt, ",jpeg-wan-compression=%s",
                          virDomainGraphicsSpiceJpegCompressionTypeToString(graphics->data.spice.jpeg));
    if (graphics->data.spice.zlib)
        virBufferAsprintf(&opt, ",zlib-glz-wan-compression=%s",
                          virDomainGraphicsSpiceZlibCompressionTypeToString(graphics->data.spice.zlib));
    if (graphics->data.spice.playback)
        virBufferAsprintf(&opt, ",playback-compression=%s",
                          virDomainGraphicsSpicePlaybackCompressionTypeToString(graphics->data.spice.playback));
    if (graphics->data.spice.streaming)
        virBufferAsprintf(&opt, ",streaming-video=%s",
                          virDomainGraphicsSpiceStreamingModeTypeToString(graphics->data.spice.streaming));
    if (graphics->data.spice.copypaste == VIR_DOMAIN_GRAPHICS_SPICE_CLIPBOARD_COPYPASTE_NO)
        virBufferAddLit(&opt, ",disable-copy-paste");

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION)) {
        /* If qemu supports seamless migration turn it
         * unconditionally on. If migration destination
         * doesn't support it, it fallbacks to previous
         * migration algorithm silently. */
        virBufferAddLit(&opt, ",seamless-migration=on");
    }

    virCommandAddArg(cmd, "-spice");
    virCommandAddArgBuffer(cmd, &opt);
    if (graphics->data.spice.keymap)
        virCommandAddArgList(cmd, "-k",
                             graphics->data.spice.keymap, NULL);
    /* SPICE includes native support for tunnelling audio, so we
     * set the audio backend to point at SPICE's own driver
     */
    virCommandAddEnvString(cmd, "QEMU_AUDIO_DRV=spice");

    return 0;

error:
    VIR_FREE(netAddr);
    virBufferFreeAndReset(&opt);
    return -1;
}

7249
static int
7250
qemuBuildGraphicsCommandLine(virQEMUDriverConfigPtr cfg,
7251 7252
                             virCommandPtr cmd,
                             virDomainDefPtr def,
7253
                             virQEMUCapsPtr qemuCaps,
7254
                             virDomainGraphicsDefPtr graphics)
7255
{
7256 7257
    switch ((enum virDomainGraphicsType) graphics->type) {
    case VIR_DOMAIN_GRAPHICS_TYPE_SDL:
7258 7259
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_0_10) &&
            !virQEMUCapsGet(qemuCaps, QEMU_CAPS_SDL)) {
7260
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
7261 7262
                           _("sdl not supported by '%s'"), def->emulator);
            return -1;
7263 7264
        }

7265
        if (graphics->data.sdl.xauth)
7266
            virCommandAddEnvPair(cmd, "XAUTHORITY", graphics->data.sdl.xauth);
7267
        if (graphics->data.sdl.display)
7268
            virCommandAddEnvPair(cmd, "DISPLAY", graphics->data.sdl.display);
7269 7270
        if (graphics->data.sdl.fullscreen)
            virCommandAddArg(cmd, "-full-screen");
7271

7272 7273 7274 7275 7276 7277
        /* If using SDL for video, then we should just let it
         * use QEMU's host audio drivers, possibly SDL too
         * User can set these two before starting libvirtd
         */
        virCommandAddEnvPass(cmd, "QEMU_AUDIO_DRV");
        virCommandAddEnvPass(cmd, "SDL_AUDIODRIVER");
B
Bharata B Rao 已提交
7278

7279 7280 7281
        /* New QEMU has this flag to let us explicitly ask for
         * SDL graphics. This is better than relying on the
         * default, since the default changes :-( */
7282
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SDL))
7283
            virCommandAddArg(cmd, "-sdl");
7284

7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295
        break;

    case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
        return qemuBuildGraphicsVNCCommandLine(cfg, cmd, def, qemuCaps, graphics);

    case VIR_DOMAIN_GRAPHICS_TYPE_SPICE:
        return qemuBuildGraphicsSPICECommandLine(cfg, cmd, qemuCaps, graphics);

    case VIR_DOMAIN_GRAPHICS_TYPE_RDP:
    case VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP:
    case VIR_DOMAIN_GRAPHICS_TYPE_LAST:
7296 7297 7298
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("unsupported graphics type '%s'"),
                       virDomainGraphicsTypeToString(graphics->type));
7299
        return -1;
7300
    }
7301

7302 7303
    return 0;
}
7304

7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317
static int
qemuBuildInterfaceCommandLine(virCommandPtr cmd,
                              virQEMUDriverPtr driver,
                              virConnectPtr conn,
                              virDomainDefPtr def,
                              virDomainNetDefPtr net,
                              virQEMUCapsPtr qemuCaps,
                              int vlan,
                              int bootindex,
                              enum virNetDevVPortProfileOp vmop)
{
    int ret = -1;
    char *nic = NULL, *host = NULL;
7318 7319 7320 7321 7322 7323
    int *tapfd = NULL;
    int tapfdSize = 0;
    int *vhostfd = NULL;
    int vhostfdSize = 0;
    char **tapfdName = NULL;
    char **vhostfdName = NULL;
7324
    int actualType = virDomainNetGetActualType(net);
7325
    size_t i;
7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336

    if (actualType == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
        /* NET_TYPE_HOSTDEV devices are really hostdev devices, so
         * their commandlines are constructed with other hostdevs.
         */
        return 0;
    }

    if (!bootindex)
        bootindex = net->info.bootIndex;

7337 7338 7339 7340 7341 7342 7343 7344 7345 7346
    /* Currently nothing besides TAP devices supports multiqueue. */
    if (net->driver.virtio.queues > 0 &&
        !(actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
          actualType == VIR_DOMAIN_NET_TYPE_BRIDGE)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("Multiqueue network is not supported for: %s"),
                       virDomainNetTypeToString(actualType));
        return -1;
    }

7347 7348
    if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
        actualType == VIR_DOMAIN_NET_TYPE_BRIDGE) {
7349 7350 7351 7352 7353
        tapfdSize = net->driver.virtio.queues;
        if (!tapfdSize)
            tapfdSize = 1;

        if (VIR_ALLOC_N(tapfd, tapfdSize) < 0 ||
7354
            VIR_ALLOC_N(tapfdName, tapfdSize) < 0)
7355 7356
            goto cleanup;

7357 7358
        memset(tapfd, -1, tapfdSize * sizeof(tapfd[0]));

7359 7360
        if (qemuNetworkIfaceConnect(def, conn, driver, net,
                                    qemuCaps, tapfd, &tapfdSize) < 0)
7361 7362
            goto cleanup;
    } else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
7363
        if (VIR_ALLOC(tapfd) < 0 || VIR_ALLOC(tapfdName) < 0)
7364 7365 7366 7367 7368
            goto cleanup;
        tapfdSize = 1;
        tapfd[0] = qemuPhysIfaceConnect(def, driver, net,
                                        qemuCaps, vmop);
        if (tapfd[0] < 0)
7369 7370 7371 7372 7373 7374 7375 7376 7377
            goto cleanup;
    }

    if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
        actualType == VIR_DOMAIN_NET_TYPE_BRIDGE ||
        actualType == VIR_DOMAIN_NET_TYPE_ETHERNET ||
        actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
        /* Attempt to use vhost-net mode for these types of
           network device */
7378 7379 7380 7381 7382
        vhostfdSize = net->driver.virtio.queues;
        if (!vhostfdSize)
            vhostfdSize = 1;

        if (VIR_ALLOC_N(vhostfd, vhostfdSize) < 0 ||
7383
            VIR_ALLOC_N(vhostfdName, vhostfdSize))
7384 7385
            goto cleanup;

7386 7387
        memset(vhostfd, -1, vhostfdSize * sizeof(vhostfd[0]));

7388
        if (qemuOpenVhostNet(def, net, qemuCaps, vhostfd, &vhostfdSize) < 0)
7389 7390 7391
            goto cleanup;
    }

7392
    for (i = 0; i < tapfdSize; i++) {
7393 7394
        virCommandPassFD(cmd, tapfd[i],
                         VIR_COMMAND_PASS_FD_CLOSE_PARENT);
7395
        if (virAsprintf(&tapfdName[i], "%d", tapfd[i]) < 0)
7396 7397 7398
            goto cleanup;
    }

7399
    for (i = 0; i < vhostfdSize; i++) {
7400 7401
        virCommandPassFD(cmd, vhostfd[i],
                         VIR_COMMAND_PASS_FD_CLOSE_PARENT);
7402
        if (virAsprintf(&vhostfdName[i], "%d", vhostfd[i]) < 0)
7403
            goto cleanup;
7404 7405 7406 7407 7408 7409 7410 7411 7412 7413
    }

    /* Possible combinations:
     *
     *  1. Old way:   -net nic,model=e1000,vlan=1 -net tap,vlan=1
     *  2. Semi-new:  -device e1000,vlan=1        -net tap,vlan=1
     *  3. Best way:  -netdev type=tap,id=netdev1 -device e1000,id=netdev1
     *
     * NB, no support for -netdev without use of -device
     */
7414
    if (qemuDomainSupportsNetdev(def, qemuCaps, net)) {
7415
        if (!(host = qemuBuildHostNetStr(net, driver,
7416 7417 7418
                                         ',', vlan,
                                         tapfdName, tapfdSize,
                                         vhostfdName, vhostfdSize)))
7419 7420 7421
            goto cleanup;
        virCommandAddArgList(cmd, "-netdev", host, NULL);
    }
7422
    if (qemuDomainSupportsNicdev(def, qemuCaps, net)) {
7423 7424 7425 7426
        bool multiqueue = tapfdSize > 1 || vhostfdSize > 1;

        if (!(nic = qemuBuildNicDevStr(def, net, vlan, bootindex,
                                       multiqueue, qemuCaps)))
7427 7428 7429 7430 7431 7432 7433
            goto cleanup;
        virCommandAddArgList(cmd, "-device", nic, NULL);
    } else {
        if (!(nic = qemuBuildNicStr(net, "nic,", vlan)))
            goto cleanup;
        virCommandAddArgList(cmd, "-net", nic, NULL);
    }
7434
    if (!qemuDomainSupportsNetdev(def, qemuCaps, net)) {
7435
        if (!(host = qemuBuildHostNetStr(net, driver,
7436 7437 7438
                                         ',', vlan,
                                         tapfdName, tapfdSize,
                                         vhostfdName, vhostfdSize)))
7439 7440 7441 7442 7443 7444 7445 7446
            goto cleanup;
        virCommandAddArgList(cmd, "-net", host, NULL);
    }

    ret = 0;
cleanup:
    if (ret < 0)
        virDomainConfNWFilterTeardown(net);
7447
    for (i = 0; tapfd && i < tapfdSize && tapfd[i] >= 0; i++) {
7448 7449
        if (ret < 0)
            VIR_FORCE_CLOSE(tapfd[i]);
7450 7451
        if (tapfdName)
            VIR_FREE(tapfdName[i]);
7452
    }
7453
    for (i = 0; vhostfd && i < vhostfdSize && vhostfd[i] >= 0; i++) {
7454 7455
        if (ret < 0)
            VIR_FORCE_CLOSE(vhostfd[i]);
7456 7457
        if (vhostfdName)
            VIR_FREE(vhostfdName[i]);
7458 7459 7460
    }
    VIR_FREE(tapfd);
    VIR_FREE(vhostfd);
7461 7462 7463 7464 7465 7466 7467
    VIR_FREE(nic);
    VIR_FREE(host);
    VIR_FREE(tapfdName);
    VIR_FREE(vhostfdName);
    return ret;
}

7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479
static int
qemuBuildChrDeviceCommandLine(virCommandPtr cmd,
                              virDomainDefPtr def,
                              virDomainChrDefPtr chr,
                              virQEMUCapsPtr qemuCaps)
{
    char *devstr = NULL;

    if (qemuBuildChrDeviceStr(&devstr, def, chr, qemuCaps) < 0)
        return -1;

    virCommandAddArgList(cmd, "-device", devstr, NULL);
7480
    VIR_FREE(devstr);
7481 7482 7483
    return 0;
}

7484 7485 7486 7487
qemuBuildCommandLineCallbacks buildCommandLineCallbacks = {
    .qemuGetSCSIDeviceSgName = virSCSIDeviceGetSgName,
};

7488 7489 7490 7491 7492 7493 7494 7495 7496
/*
 * Constructs a argv suitable for launching qemu with config defined
 * for a given virtual machine.
 *
 * XXX 'conn' is only required to resolve network -> bridge name
 * figure out how to remove this requirement some day
 */
virCommandPtr
qemuBuildCommandLine(virConnectPtr conn,
7497
                     virQEMUDriverPtr driver,
7498 7499 7500
                     virDomainDefPtr def,
                     virDomainChrSourceDefPtr monitor_chr,
                     bool monitor_json,
7501
                     virQEMUCapsPtr qemuCaps,
7502 7503 7504
                     const char *migrateFrom,
                     int migrateFd,
                     virDomainSnapshotObjPtr snapshot,
7505 7506
                     enum virNetDevVPortProfileOp vmop,
                     qemuBuildCommandLineCallbacksPtr callbacks)
7507
{
7508
    virErrorPtr originalError = NULL;
7509
    size_t i, j;
7510 7511 7512 7513 7514 7515 7516
    const char *emulator;
    char uuid[VIR_UUID_STRING_BUFLEN];
    char *cpu;
    char *smp;
    int last_good_net = -1;
    bool hasHwVirt = false;
    virCommandPtr cmd = NULL;
7517
    bool allowReboot = true;
7518
    bool emitBootindex = false;
7519 7520 7521
    int sdl = 0;
    int vnc = 0;
    int spice = 0;
7522 7523
    int usbcontroller = 0;
    bool usblegacy = false;
7524
    bool mlock = false;
7525 7526 7527
    int contOrder[] = {
        /* We don't add an explicit IDE or FD controller because the
         * provided PIIX4 device already includes one. It isn't possible to
7528 7529 7530 7531 7532
         * remove the PIIX4.
         *
         * We don't add PCI root controller either, because it's implicit,
         * but we do add PCI bridges. */
        VIR_DOMAIN_CONTROLLER_TYPE_PCI,
7533 7534 7535 7536 7537 7538
        VIR_DOMAIN_CONTROLLER_TYPE_USB,
        VIR_DOMAIN_CONTROLLER_TYPE_SCSI,
        VIR_DOMAIN_CONTROLLER_TYPE_SATA,
        VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL,
        VIR_DOMAIN_CONTROLLER_TYPE_CCID,
    };
7539
    virArch hostarch = virArchFromHost();
7540
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
7541

7542
    VIR_DEBUG("conn=%p driver=%p def=%p mon=%p json=%d "
7543
              "qemuCaps=%p migrateFrom=%s migrateFD=%d "
7544 7545
              "snapshot=%p vmop=%d",
              conn, driver, def, monitor_chr, monitor_json,
7546
              qemuCaps, migrateFrom, migrateFd, snapshot, vmop);
7547

7548 7549 7550 7551 7552 7553 7554 7555
    virUUIDFormat(def->uuid, uuid);

    emulator = def->emulator;

    /*
     * do not use boot=on for drives when not using KVM since this
     * is not supported at all in upstream QEmu.
     */
7556
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
7557
        (def->virtType == VIR_DOMAIN_VIRT_QEMU))
7558
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DRIVE_BOOT);
7559 7560

    cmd = virCommandNew(emulator);
7561

7562
    virCommandAddEnvPassCommon(cmd);
7563

7564
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NAME)) {
7565
        virCommandAddArg(cmd, "-name");
7566
        if (cfg->setProcessName &&
7567
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_NAME_PROCESS)) {
7568 7569 7570 7571
            virCommandAddArgFormat(cmd, "%s,process=qemu:%s",
                                   def->name, def->name);
        } else {
            virCommandAddArg(cmd, def->name);
7572 7573
        }
    }
7574
    virCommandAddArg(cmd, "-S"); /* freeze CPU */
7575

7576
    if (qemuBuildMachineArgStr(cmd, def, qemuCaps) < 0)
7577
        goto error;
7578

7579
    if (qemuBuildCpuArgStr(driver, def, emulator, qemuCaps,
7580
                           hostarch, &cpu, &hasHwVirt, !!migrateFrom) < 0)
7581
        goto error;
7582

7583 7584 7585 7586
    if (cpu) {
        virCommandAddArgList(cmd, "-cpu", cpu, NULL);
        VIR_FREE(cpu);

7587
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NESTING) &&
7588 7589
            hasHwVirt)
            virCommandAddArg(cmd, "-enable-nesting");
7590
    }
7591

7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605
    if (def->os.loader) {
        virCommandAddArg(cmd, "-bios");
        virCommandAddArg(cmd, def->os.loader);
    }

    /* Set '-m MB' based on maxmem, because the lower 'memory' limit
     * is set post-startup using the balloon driver. If balloon driver
     * is not supported, then they're out of luck anyway.  Update the
     * XML to reflect our rounding.
     */
    virCommandAddArg(cmd, "-m");
    def->mem.max_balloon = VIR_DIV_UP(def->mem.max_balloon, 1024) * 1024;
    virCommandAddArgFormat(cmd, "%llu", def->mem.max_balloon / 1024);
    if (def->mem.hugepage_backed) {
7606
        if (!cfg->hugetlbfsMount) {
7607 7608 7609 7610
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("hugetlbfs filesystem is not mounted"));
            goto error;
        }
7611
        if (!cfg->hugepagePath) {
7612 7613 7614 7615
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("hugepages are disabled by administrator config"));
            goto error;
        }
7616
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MEM_PATH)) {
7617 7618 7619 7620 7621 7622
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("hugepage backing not supported by '%s'"),
                           def->emulator);
            goto error;
        }
        virCommandAddArgList(cmd, "-mem-prealloc", "-mem-path",
7623
                             cfg->hugepagePath, NULL);
7624 7625
    }

7626 7627 7628 7629 7630 7631 7632 7633 7634 7635
    if (def->mem.locked && !virQEMUCapsGet(qemuCaps, QEMU_CAPS_MLOCK)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("memory locking not supported by QEMU binary"));
        goto error;
    }
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MLOCK)) {
        virCommandAddArg(cmd, "-realtime");
        virCommandAddArgFormat(cmd, "mlock=%s",
                               def->mem.locked ? "on" : "off");
    }
7636
    mlock = def->mem.locked;
7637

7638
    virCommandAddArg(cmd, "-smp");
7639
    if (!(smp = qemuBuildSmpArgStr(def, qemuCaps)))
7640 7641 7642 7643 7644 7645 7646 7647
        goto error;
    virCommandAddArg(cmd, smp);
    VIR_FREE(smp);

    if (def->cpu && def->cpu->ncells)
        if (qemuBuildNumaArgStr(def, cmd) < 0)
            goto error;

7648
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_UUID))
7649 7650 7651 7652
        virCommandAddArgList(cmd, "-uuid", uuid, NULL);
    if (def->virtType == VIR_DOMAIN_VIRT_XEN ||
        STREQ(def->os.type, "xen") ||
        STREQ(def->os.type, "linux")) {
7653
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DOMID)) {
7654 7655
            virCommandAddArg(cmd, "-domid");
            virCommandAddArgFormat(cmd, "%d", def->id);
7656
        } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_XEN_DOMID)) {
7657 7658 7659 7660 7661 7662 7663
            virCommandAddArg(cmd, "-xen-attach");
            virCommandAddArg(cmd, "-xen-domid");
            virCommandAddArgFormat(cmd, "%d", def->id);
        } else {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("qemu emulator '%s' does not support xen"),
                           def->emulator);
7664 7665 7666 7667
            goto error;
        }
    }

7668 7669 7670 7671 7672
    if ((def->os.smbios_mode != VIR_DOMAIN_SMBIOS_NONE) &&
        (def->os.smbios_mode != VIR_DOMAIN_SMBIOS_EMULATE)) {
        virSysinfoDefPtr source = NULL;
        bool skip_uuid = false;

7673
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE)) {
7674 7675 7676
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("the QEMU binary %s does not support smbios settings"),
                           emulator);
7677 7678 7679
            goto error;
        }

7680 7681 7682
        /* should we really error out or just warn in those cases ? */
        if (def->os.smbios_mode == VIR_DOMAIN_SMBIOS_HOST) {
            if (driver->hostsysinfo == NULL) {
7683
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
7684
                               _("Host SMBIOS information is not available"));
7685
                goto error;
7686
            }
7687 7688 7689 7690 7691 7692 7693 7694 7695
            source = driver->hostsysinfo;
            /* Host and guest uuid must differ, by definition of UUID. */
            skip_uuid = true;
        } else if (def->os.smbios_mode == VIR_DOMAIN_SMBIOS_SYSINFO) {
            if (def->sysinfo == NULL) {
                virReportError(VIR_ERR_XML_ERROR,
                               _("Domain '%s' sysinfo are not available"),
                               def->name);
                goto error;
7696
            }
7697 7698
            source = def->sysinfo;
            /* domain_conf guaranteed that system_uuid matches guest uuid. */
7699
        }
7700 7701
        if (source != NULL) {
            char *smbioscmd;
7702

7703 7704 7705 7706
            smbioscmd = qemuBuildSmbiosBiosStr(source);
            if (smbioscmd != NULL) {
                virCommandAddArgList(cmd, "-smbios", smbioscmd, NULL);
                VIR_FREE(smbioscmd);
7707
            }
7708 7709 7710 7711
            smbioscmd = qemuBuildSmbiosSystemStr(source, skip_uuid);
            if (smbioscmd != NULL) {
                virCommandAddArgList(cmd, "-smbios", smbioscmd, NULL);
                VIR_FREE(smbioscmd);
7712
            }
7713
        }
7714
    }
7715

7716 7717 7718 7719 7720 7721 7722
    /*
     * NB, -nographic *MUST* come before any serial, or monitor
     * or parallel port flags due to QEMU craziness, where it
     * decides to change the serial port & monitor to be on stdout
     * if you ask for nographic. So we have to make sure we override
     * these defaults ourselves...
     */
7723
    if (!def->graphics) {
7724
        virCommandAddArg(cmd, "-nographic");
7725

7726 7727 7728 7729 7730 7731
        if (cfg->nogfxAllowHostAudio)
            virCommandAddEnvPass(cmd, "QEMU_AUDIO_DRV");
        else
            virCommandAddEnvString(cmd, "QEMU_AUDIO_DRV=none");
    }

7732
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
7733
        /* Disable global config files and default devices */
7734
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
7735
            virCommandAddArg(cmd, "-no-user-config");
7736
        else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
7737 7738
            virCommandAddArg(cmd, "-nodefconfig");
        virCommandAddArg(cmd, "-nodefaults");
7739 7740
    }

7741 7742
    /* Serial graphics adapter */
    if (def->os.bios.useserial == VIR_DOMAIN_BIOS_USESERIAL_YES) {
7743
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
7744 7745 7746 7747
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("qemu does not support -device"));
            goto error;
        }
7748
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SGA)) {
7749 7750 7751 7752 7753 7754 7755
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("qemu does not support SGA"));
            goto error;
        }
        if (!def->nserials) {
            virReportError(VIR_ERR_XML_ERROR, "%s",
                           _("need at least one serial port to use SGA"));
7756 7757
            goto error;
        }
7758
        virCommandAddArgList(cmd, "-device", "sga", NULL);
7759 7760
    }

7761 7762 7763
    if (monitor_chr) {
        char *chrdev;
        /* Use -chardev if it's available */
7764
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV)) {
J
Jim Fehlig 已提交
7765

7766 7767
            virCommandAddArg(cmd, "-chardev");
            if (!(chrdev = qemuBuildChrChardevStr(monitor_chr, "monitor",
7768
                                                  qemuCaps)))
7769 7770 7771
                goto error;
            virCommandAddArg(cmd, chrdev);
            VIR_FREE(chrdev);
7772

7773 7774 7775 7776 7777 7778 7779 7780
            virCommandAddArg(cmd, "-mon");
            virCommandAddArgFormat(cmd,
                                   "chardev=charmonitor,id=monitor,mode=%s",
                                   monitor_json ? "control" : "readline");
        } else {
            const char *prefix = NULL;
            if (monitor_json)
                prefix = "control,";
7781

7782 7783 7784 7785 7786
            virCommandAddArg(cmd, "-monitor");
            if (!(chrdev = qemuBuildChrArgStr(monitor_chr, prefix)))
                goto error;
            virCommandAddArg(cmd, chrdev);
            VIR_FREE(chrdev);
7787 7788 7789
        }
    }

7790
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_RTC)) {
7791
        char *rtcopt;
7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802
        virCommandAddArg(cmd, "-rtc");
        if (!(rtcopt = qemuBuildClockArgStr(&def->clock)))
            goto error;
        virCommandAddArg(cmd, rtcopt);
        VIR_FREE(rtcopt);
    } else {
        switch (def->clock.offset) {
        case VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME:
        case VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE:
            virCommandAddArg(cmd, "-localtime");
            break;
7803

7804 7805 7806
        case VIR_DOMAIN_CLOCK_OFFSET_UTC:
            /* Nothing, its the default */
            break;
7807

7808 7809 7810 7811
        default:
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("unsupported clock offset '%s'"),
                           virDomainClockOffsetTypeToString(def->clock.offset));
7812
            goto error;
7813 7814 7815 7816 7817
        }
    }
    if (def->clock.offset == VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE &&
        def->clock.data.timezone) {
        virCommandAddEnvPair(cmd, "TZ", def->clock.data.timezone);
7818 7819
    }

7820 7821 7822 7823 7824 7825 7826 7827 7828
    for (i = 0; i < def->clock.ntimers; i++) {
        switch (def->clock.timers[i]->name) {
        default:
        case VIR_DOMAIN_TIMER_NAME_PLATFORM:
        case VIR_DOMAIN_TIMER_NAME_TSC:
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("unsupported timer type (name) '%s'"),
                           virDomainTimerNameTypeToString(def->clock.timers[i]->name));
            goto error;
7829

7830 7831 7832 7833 7834 7835 7836 7837
        case VIR_DOMAIN_TIMER_NAME_KVMCLOCK:
            /* This is handled when building -cpu.  */
            break;

        case VIR_DOMAIN_TIMER_NAME_RTC:
            /* This has already been taken care of (in qemuBuildClockArgStr)
               if QEMU_CAPS_RTC is set (mutually exclusive with
               QEMUD_FLAG_RTC_TD_HACK) */
7838
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_RTC_TD_HACK)) {
7839 7840 7841 7842
                switch (def->clock.timers[i]->tickpolicy) {
                case -1:
                case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
                    /* the default - do nothing */
7843
                    break;
7844 7845
                case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
                    virCommandAddArg(cmd, "-rtc-td-hack");
7846
                    break;
7847 7848 7849 7850 7851
                case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
                case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                                   _("unsupported rtc tickpolicy '%s'"),
                                   virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
J
Ján Tomko 已提交
7852
                    goto error;
7853
                }
7854
            } else if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_RTC)
7855 7856 7857 7858 7859 7860 7861 7862 7863
                       && (def->clock.timers[i]->tickpolicy
                           != VIR_DOMAIN_TIMER_TICKPOLICY_DELAY)
                       && (def->clock.timers[i]->tickpolicy != -1)) {
                /* a non-default rtc policy was given, but there is no
                   way to implement it in this version of qemu */
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("unsupported rtc tickpolicy '%s'"),
                               virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
                goto error;
7864
            }
7865
            break;
7866

7867 7868 7869 7870 7871 7872
        case VIR_DOMAIN_TIMER_NAME_PIT:
            switch (def->clock.timers[i]->tickpolicy) {
            case -1:
            case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
                /* delay is the default if we don't have kernel
                   (-no-kvm-pit), otherwise, the default is catchup. */
7873
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT))
7874 7875 7876
                    virCommandAddArg(cmd, "-no-kvm-pit-reinjection");
                break;
            case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
7877
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT)) {
7878
                    /* do nothing - this is default for kvm-pit */
7879
                } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_TDF)) {
7880 7881
                    /* -tdf switches to 'catchup' with userspace pit. */
                    virCommandAddArg(cmd, "-tdf");
7882
                } else {
7883 7884 7885 7886
                    /* can't catchup if we have neither pit mode */
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                                   _("unsupported pit tickpolicy '%s'"),
                                   virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
7887 7888 7889
                    goto error;
                }
                break;
7890 7891 7892 7893 7894 7895 7896
            case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
            case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
                /* no way to support these modes for pit in qemu */
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("unsupported pit tickpolicy '%s'"),
                               virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
                goto error;
7897
            }
7898
            break;
7899

7900 7901 7902 7903 7904 7905 7906
        case VIR_DOMAIN_TIMER_NAME_HPET:
            /* the only meaningful attribute for hpet is "present". If
             * present is -1, that means it wasn't specified, and
             * should be left at the default for the
             * hypervisor. "default" when -no-hpet exists is "yes",
             * and when -no-hpet doesn't exist is "no". "confusing"?
             * "yes"! */
7907

7908
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_HPET)) {
7909 7910 7911 7912 7913 7914 7915 7916
                if (def->clock.timers[i]->present == 0)
                    virCommandAddArg(cmd, "-no-hpet");
            } else {
                /* no hpet timer available. The only possible action
                   is to raise an error if present="yes" */
                if (def->clock.timers[i]->present == 1) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                                   "%s", _("pit timer is not supported"));
7917 7918
                }
            }
7919 7920 7921
            break;
        }
    }
7922

7923 7924 7925 7926 7927 7928 7929 7930 7931
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_REBOOT)) {
        /* Only add -no-reboot option if each event destroys domain */
        if (def->onReboot == VIR_DOMAIN_LIFECYCLE_DESTROY &&
            def->onPoweroff == VIR_DOMAIN_LIFECYCLE_DESTROY &&
            def->onCrash == VIR_DOMAIN_LIFECYCLE_DESTROY) {
            allowReboot = false;
            virCommandAddArg(cmd, "-no-reboot");
        }
    }
7932

7933 7934 7935 7936
    /* If JSON monitor is enabled, we can receive an event
     * when QEMU stops. If we use no-shutdown, then we can
     * watch for this event and do a soft/warm reboot.
     */
7937 7938
    if (monitor_json && allowReboot &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
7939
        virCommandAddArg(cmd, "-no-shutdown");
7940
    }
7941

7942
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_ACPI)) {
7943 7944 7945
        if (!(def->features & (1 << VIR_DOMAIN_FEATURE_ACPI)))
            virCommandAddArg(cmd, "-no-acpi");
    }
7946

7947
    if (def->pm.s3) {
7948
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DISABLE_S3)) {
7949 7950 7951
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("setting ACPI S3 not supported"));
            goto error;
7952
        }
7953 7954 7955 7956 7957 7958
        virCommandAddArg(cmd, "-global");
        virCommandAddArgFormat(cmd, "PIIX4_PM.disable_s3=%d",
                               def->pm.s3 == VIR_DOMAIN_PM_STATE_DISABLED);
    }

    if (def->pm.s4) {
7959
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DISABLE_S4)) {
7960 7961 7962 7963 7964 7965 7966 7967
         virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           "%s", _("setting ACPI S4 not supported"));
            goto error;
        }
        virCommandAddArg(cmd, "-global");
        virCommandAddArgFormat(cmd, "PIIX4_PM.disable_s4=%d",
                               def->pm.s4 == VIR_DOMAIN_PM_STATE_DISABLED);
    }
7968

7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980
    if (!def->os.bootloader) {
        int boot_nparams = 0;
        virBuffer boot_buf = VIR_BUFFER_INITIALIZER;
        /*
         * We prefer using explicit bootindex=N parameters for predictable
         * results even though domain XML doesn't use per device boot elements.
         * However, we can't use bootindex if boot menu was requested.
         */
        if (!def->os.nBootDevs) {
            /* def->os.nBootDevs is guaranteed to be > 0 unless per-device boot
             * configuration is used
             */
7981
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX)) {
7982
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
7983
                               _("hypervisor lacks deviceboot feature"));
7984 7985
                goto error;
            }
7986
            emitBootindex = true;
7987
        } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX) &&
7988
                   (def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_ENABLED ||
7989
                    !virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU))) {
7990 7991
            emitBootindex = true;
        }
7992

7993 7994
        if (!emitBootindex) {
            char boot[VIR_DOMAIN_BOOT_LAST+1];
7995

7996
            for (i = 0; i < def->os.nBootDevs; i++) {
7997 7998 7999
                switch (def->os.bootDevs[i]) {
                case VIR_DOMAIN_BOOT_CDROM:
                    boot[i] = 'd';
8000
                    break;
8001 8002
                case VIR_DOMAIN_BOOT_FLOPPY:
                    boot[i] = 'a';
8003
                    break;
8004 8005 8006 8007 8008 8009 8010 8011
                case VIR_DOMAIN_BOOT_DISK:
                    boot[i] = 'c';
                    break;
                case VIR_DOMAIN_BOOT_NET:
                    boot[i] = 'n';
                    break;
                default:
                    boot[i] = 'c';
8012
                    break;
8013
                }
8014
            }
8015
            boot[def->os.nBootDevs] = '\0';
8016

8017 8018
            virBufferAsprintf(&boot_buf, "%s", boot);
            boot_nparams++;
8019 8020
        }

8021
        if (def->os.bootmenu) {
8022
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU)) {
8023 8024
                if (boot_nparams++)
                    virBufferAddChar(&boot_buf, ',');
8025

8026
                if (def->os.bootmenu == VIR_DOMAIN_BOOT_MENU_ENABLED)
8027
                    virBufferAddLit(&boot_buf, "menu=on");
8028
                else
8029
                    virBufferAddLit(&boot_buf, "menu=off");
8030 8031 8032 8033 8034 8035 8036
            } else {
                /* We cannot emit an error when bootmenu is enabled but
                 * unsupported because of backward compatibility */
                VIR_WARN("bootmenu is enabled but not "
                         "supported by this QEMU binary");
            }
        }
8037

8038
        if (def->os.bios.rt_set) {
8039
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_REBOOT_TIMEOUT)) {
8040 8041 8042
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("reboot timeout is not supported "
                                 "by this QEMU binary"));
8043
                virBufferFreeAndReset(&boot_buf);
8044
                goto error;
8045 8046 8047 8048 8049 8050 8051 8052
            }

            if (boot_nparams++)
                virBufferAddChar(&boot_buf, ',');

            virBufferAsprintf(&boot_buf,
                              "reboot-timeout=%d",
                              def->os.bios.rt_delay);
8053 8054
        }

8055 8056
        if (boot_nparams > 0) {
            virCommandAddArg(cmd, "-boot");
8057

8058 8059
            if (boot_nparams < 2 || emitBootindex) {
                virCommandAddArgBuffer(cmd, &boot_buf);
8060
                virBufferFreeAndReset(&boot_buf);
8061
            } else {
8062
                char *str = virBufferContentAndReset(&boot_buf);
8063 8064
                virCommandAddArgFormat(cmd,
                                       "order=%s",
8065 8066
                                       str);
                VIR_FREE(str);
8067 8068 8069
            }
        }

8070 8071 8072 8073 8074 8075
        if (def->os.kernel)
            virCommandAddArgList(cmd, "-kernel", def->os.kernel, NULL);
        if (def->os.initrd)
            virCommandAddArgList(cmd, "-initrd", def->os.initrd, NULL);
        if (def->os.cmdline)
            virCommandAddArgList(cmd, "-append", def->os.cmdline, NULL);
O
Olivia Yin 已提交
8076 8077 8078 8079 8080 8081 8082 8083 8084
        if (def->os.dtb) {
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DTB)) {
                virCommandAddArgList(cmd, "-dtb", def->os.dtb, NULL);
            } else {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("dtb is not supported with this QEMU binary"));
                goto error;
            }
        }
8085 8086 8087
    } else {
        virCommandAddArgList(cmd, "-bootloader", def->os.bootloader, NULL);
    }
8088

8089 8090 8091 8092 8093 8094 8095 8096 8097 8098 8099 8100 8101 8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125 8126 8127 8128 8129 8130 8131 8132 8133 8134 8135
    for (i = 0; i < def->ncontrollers; i++) {
        virDomainControllerDefPtr cont = def->controllers[i];
        if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI &&
            cont->opts.pciopts.pcihole64) {
            const char *hoststr = NULL;
            bool cap = false;
            bool machine = false;

            switch (cont->model) {
            case VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT:
                hoststr = "i440FX-pcihost";
                cap = virQEMUCapsGet(qemuCaps, QEMU_CAPS_I440FX_PCI_HOLE64_SIZE);
                machine = qemuDomainMachineIsI440FX(def);
                break;

            case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT:
                hoststr = "q35-pcihost";
                cap = virQEMUCapsGet(qemuCaps, QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
                machine = qemuDomainMachineIsQ35(def);
                break;

            default:
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("64-bit PCI hole setting is only for root"
                                 " PCI controllers"));
                goto error;
            }

            if (!machine) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                             _("Setting the 64-bit PCI hole size is not "
                             "supported for machine '%s'"), def->os.machine);
                goto error;
            }
            if (!cap) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("64-bit PCI hole size setting is not supported "
                                 "with this QEMU binary"));
                goto error;
            }

            virCommandAddArg(cmd, "-global");
            virCommandAddArgFormat(cmd, "%s.pci-hole64-size=%luK", hoststr,
                                   cont->opts.pciopts.pcihole64size);
        }
    }

8136
    for (i = 0; i < def->ndisks; i++) {
8137
        virDomainDiskDefPtr disk = def->disks[i];
8138

8139 8140 8141 8142 8143 8144 8145 8146 8147
        if (disk->driverName != NULL &&
            !STREQ(disk->driverName, "qemu")) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("unsupported driver name '%s' for disk '%s'"),
                           disk->driverName, disk->src);
            goto error;
        }
    }

8148
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8149 8150 8151
        for (j = 0; j < ARRAY_CARDINALITY(contOrder); j++) {
            for (i = 0; i < def->ncontrollers; i++) {
                virDomainControllerDefPtr cont = def->controllers[i];
8152

8153 8154
                if (cont->type != contOrder[j])
                    continue;
8155

8156 8157 8158 8159 8160 8161 8162
                /* Also, skip USB controllers with type none.*/
                if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
                    cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE) {
                    usbcontroller = -1; /* mark we don't want a controller */
                    continue;
                }

L
Laine Stump 已提交
8163
                /* Skip pci-root/pcie-root */
8164
                if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI &&
L
Laine Stump 已提交
8165 8166
                    (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT ||
                     cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT)) {
8167 8168 8169
                    continue;
                }

8170 8171
                /* Only recent QEMU implements a SATA (AHCI) controller */
                if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA) {
8172
                    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI)) {
8173 8174 8175
                        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                       _("SATA is not supported with this "
                                         "QEMU binary"));
8176
                        goto error;
8177 8178 8179
                    } else if (cont->idx == 0 && qemuDomainMachineIsQ35(def)) {
                        /* first SATA controller on Q35 machines is implicit */
                        continue;
8180 8181
                    } else {
                        char *devstr;
8182

8183 8184
                        virCommandAddArg(cmd, "-device");
                        if (!(devstr = qemuBuildControllerDevStr(def, cont,
8185
                                                                 qemuCaps, NULL)))
8186
                            goto error;
8187 8188 8189

                        virCommandAddArg(cmd, devstr);
                        VIR_FREE(devstr);
8190
                    }
8191 8192
                } else if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
                           cont->model == -1 &&
8193
                           !qemuDomainMachineIsQ35(def) &&
8194 8195
                           (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI) ||
                            def->os.arch == VIR_ARCH_PPC64)) {
8196 8197 8198 8199
                    if (usblegacy) {
                        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                       _("Multiple legacy USB controllers are "
                                         "not supported"));
8200 8201
                        goto error;
                    }
8202 8203 8204 8205 8206
                    usblegacy = true;
                } else {
                    virCommandAddArg(cmd, "-device");

                    char *devstr;
8207
                    if (!(devstr = qemuBuildControllerDevStr(def, cont, qemuCaps,
8208 8209 8210 8211 8212
                                                             &usbcontroller)))
                        goto error;

                    virCommandAddArg(cmd, devstr);
                    VIR_FREE(devstr);
8213
                }
8214
            }
8215 8216
        }
    }
8217

8218
    if (usbcontroller == 0 && !qemuDomainMachineIsQ35(def))
8219
        virCommandAddArg(cmd, "-usb");
8220

8221
    for (i = 0; i < def->nhubs; i++) {
8222 8223
        virDomainHubDefPtr hub = def->hubs[i];
        char *optstr;
8224

8225
        virCommandAddArg(cmd, "-device");
8226
        if (!(optstr = qemuBuildHubDevStr(def, hub, qemuCaps)))
8227 8228 8229 8230
            goto error;
        virCommandAddArg(cmd, optstr);
        VIR_FREE(optstr);
    }
8231

8232
    /* If QEMU supports -drive param instead of old -hda, -hdb, -cdrom .. */
8233
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
8234
        int bootCD = 0, bootFloppy = 0, bootDisk = 0;
8235

8236
        if ((virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) || emitBootindex)) {
8237 8238
            /* bootDevs will get translated into either bootindex=N or boot=on
             * depending on what qemu supports */
8239
            for (i = 0; i < def->os.nBootDevs; i++) {
8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250
                switch (def->os.bootDevs[i]) {
                case VIR_DOMAIN_BOOT_CDROM:
                    bootCD = i + 1;
                    break;
                case VIR_DOMAIN_BOOT_FLOPPY:
                    bootFloppy = i + 1;
                    break;
                case VIR_DOMAIN_BOOT_DISK:
                    bootDisk = i + 1;
                    break;
                }
8251
            }
8252
        }
8253

8254
        for (i = 0; i < def->ndisks; i++) {
8255 8256 8257
            char *optstr;
            int bootindex = 0;
            virDomainDiskDefPtr disk = def->disks[i];
8258
            bool withDeviceArg = false;
8259
            bool deviceFlagMasked = false;
8260

8261 8262 8263
            /* Unless we have -device, then USB disks need special
               handling */
            if ((disk->bus == VIR_DOMAIN_DISK_BUS_USB) &&
8264
                !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8265 8266 8267 8268 8269 8270 8271
                if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
                    virCommandAddArg(cmd, "-usbdevice");
                    virCommandAddArgFormat(cmd, "disk:%s", disk->src);
                } else {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("unsupported usb disk type for '%s'"),
                                   disk->src);
8272
                    goto error;
8273
                }
8274
                continue;
8275
            }
8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289 8290

            switch (disk->device) {
            case VIR_DOMAIN_DISK_DEVICE_CDROM:
                bootindex = bootCD;
                bootCD = 0;
                break;
            case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
                bootindex = bootFloppy;
                bootFloppy = 0;
                break;
            case VIR_DOMAIN_DISK_DEVICE_DISK:
            case VIR_DOMAIN_DISK_DEVICE_LUN:
                bootindex = bootDisk;
                bootDisk = 0;
                break;
8291
            }
8292 8293 8294 8295

            virCommandAddArg(cmd, "-drive");

            /* Unfortunately it is not possible to use
8296
               -device for floppies, xen PV, or SD
8297 8298 8299
               devices. Fortunately, those don't need
               static PCI addresses, so we don't really
               care that we can't use -device */
8300
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8301 8302
                if (disk->bus != VIR_DOMAIN_DISK_BUS_XEN &&
                    disk->bus != VIR_DOMAIN_DISK_BUS_SD) {
8303
                    withDeviceArg = true;
8304
                } else {
8305
                    virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE);
8306 8307
                    deviceFlagMasked = true;
                }
8308
            }
8309 8310
            optstr = qemuBuildDriveStr(conn, disk,
                                       emitBootindex ? false : !!bootindex,
8311
                                       qemuCaps);
8312
            if (deviceFlagMasked)
8313
                virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
8314 8315 8316 8317 8318 8319 8320 8321 8322
            if (!optstr)
                goto error;
            virCommandAddArg(cmd, optstr);
            VIR_FREE(optstr);

            if (!emitBootindex)
                bootindex = 0;
            else if (disk->info.bootIndex)
                bootindex = disk->info.bootIndex;
8323

8324 8325 8326 8327 8328 8329 8330
            if (withDeviceArg) {
                if (disk->bus == VIR_DOMAIN_DISK_BUS_FDC) {
                    virCommandAddArg(cmd, "-global");
                    virCommandAddArgFormat(cmd, "isa-fdc.drive%c=drive-%s",
                                           disk->info.addr.drive.unit
                                           ? 'B' : 'A',
                                           disk->info.alias);
E
Eric Blake 已提交
8331

8332 8333 8334 8335 8336 8337 8338 8339 8340
                    if (bootindex) {
                        virCommandAddArg(cmd, "-global");
                        virCommandAddArgFormat(cmd, "isa-fdc.bootindex%c=%d",
                                               disk->info.addr.drive.unit
                                               ? 'B' : 'A',
                                               bootindex);
                    }
                } else {
                    virCommandAddArg(cmd, "-device");
E
Eric Blake 已提交
8341

8342
                    if (!(optstr = qemuBuildDriveDevStr(def, disk, bootindex,
8343
                                                        qemuCaps)))
8344 8345 8346 8347
                        goto error;
                    virCommandAddArg(cmd, optstr);
                    VIR_FREE(optstr);
                }
E
Eric Blake 已提交
8348
            }
8349 8350
        }
    } else {
8351
        for (i = 0; i < def->ndisks; i++) {
8352 8353 8354 8355
            char dev[NAME_MAX];
            char *file;
            const char *fmt;
            virDomainDiskDefPtr disk = def->disks[i];
E
Eric Blake 已提交
8356

8357 8358
            if ((disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) &&
                (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN)) {
8359
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
8360 8361
                               _("tray status 'open' is invalid for "
                                 "block type disk"));
E
Eric Blake 已提交
8362 8363 8364
                goto error;
            }

8365 8366 8367 8368 8369 8370 8371 8372
            if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
                if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
                    virCommandAddArg(cmd, "-usbdevice");
                    virCommandAddArgFormat(cmd, "disk:%s", disk->src);
                } else {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("unsupported usb disk type for '%s'"),
                                   disk->src);
E
Eric Blake 已提交
8373 8374
                    goto error;
                }
8375
                continue;
E
Eric Blake 已提交
8376
            }
8377 8378 8379 8380 8381 8382 8383

            if (STREQ(disk->dst, "hdc") &&
                disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
                if (disk->src) {
                    snprintf(dev, NAME_MAX, "-%s", "cdrom");
                } else {
                    continue;
E
Eric Blake 已提交
8384 8385
                }
            } else {
8386 8387 8388 8389 8390 8391 8392 8393
                if (STRPREFIX(disk->dst, "hd") ||
                    STRPREFIX(disk->dst, "fd")) {
                    snprintf(dev, NAME_MAX, "-%s", disk->dst);
                } else {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("unsupported disk type '%s'"), disk->dst);
                    goto error;
                }
E
Eric Blake 已提交
8394 8395
            }

8396 8397 8398 8399 8400 8401 8402 8403 8404 8405 8406 8407 8408 8409 8410 8411 8412
            if (disk->type == VIR_DOMAIN_DISK_TYPE_DIR) {
                /* QEMU only supports magic FAT format for now */
                if (disk->format > 0 && disk->format != VIR_STORAGE_FILE_FAT) {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("unsupported disk driver type for '%s'"),
                                   virStorageFileFormatTypeToString(disk->format));
                    goto error;
                }
                if (!disk->readonly) {
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("cannot create virtual FAT disks in read-write mode"));
                    goto error;
                }
                if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)
                    fmt = "fat:floppy:%s";
                else
                    fmt = "fat:%s";
E
Eric Blake 已提交
8413

8414
                if (virAsprintf(&file, fmt, disk->src) < 0)
8415
                    goto error;
8416
            } else if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
8417 8418
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("network disks are only supported with -drive"));
8419
            } else {
8420 8421
                if (VIR_STRDUP(file, disk->src) < 0) {
                    goto error;
8422
                }
E
Eric Blake 已提交
8423 8424
            }

8425 8426 8427 8428 8429 8430 8431 8432
            /* Don't start with source if the tray is open for
             * CDROM and Floppy device.
             */
            if (!((disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY ||
                   disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) &&
                  disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN))
                virCommandAddArgList(cmd, dev, file, NULL);
            VIR_FREE(file);
E
Eric Blake 已提交
8433 8434 8435
        }
    }

8436
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_FSDEV)) {
8437
        for (i = 0; i < def->nfss; i++) {
8438 8439
            char *optstr;
            virDomainFSDefPtr fs = def->fss[i];
8440

8441
            virCommandAddArg(cmd, "-fsdev");
8442
            if (!(optstr = qemuBuildFSStr(fs, qemuCaps)))
8443 8444 8445
                goto error;
            virCommandAddArg(cmd, optstr);
            VIR_FREE(optstr);
8446

8447
            virCommandAddArg(cmd, "-device");
8448
            if (!(optstr = qemuBuildFSDevStr(def, fs, qemuCaps)))
8449 8450 8451 8452 8453 8454 8455 8456 8457
                goto error;
            virCommandAddArg(cmd, optstr);
            VIR_FREE(optstr);
        }
    } else {
        if (def->nfss) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("filesystem passthrough not supported by this QEMU"));
            goto error;
8458 8459 8460
        }
    }

8461
    if (!def->nnets) {
8462
        /* If we have -device, then we set -nodefault already */
8463
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
8464
            virCommandAddArgList(cmd, "-net", "none", NULL);
8465
    } else {
8466
        int bootNet = 0;
8467

8468 8469 8470 8471
        if (emitBootindex) {
            /* convert <boot dev='network'/> to bootindex since we didn't emit
             * -boot n
             */
8472
            for (i = 0; i < def->os.nBootDevs; i++) {
8473 8474 8475 8476
                if (def->os.bootDevs[i] == VIR_DOMAIN_BOOT_NET) {
                    bootNet = i + 1;
                    break;
                }
8477 8478 8479
            }
        }

8480
        for (i = 0; i < def->nnets; i++) {
8481
            virDomainNetDefPtr net = def->nets[i];
8482
            int vlan;
8483

8484
            /* VLANs are not used with -netdev, so don't record them */
8485
            if (qemuDomainSupportsNetdev(def, qemuCaps, net))
8486
                vlan = -1;
8487 8488
            else
                vlan = i;
8489

8490 8491 8492 8493 8494
            if (qemuBuildInterfaceCommandLine(cmd, driver, conn, def, net,
                                              qemuCaps, vlan, bootNet, vmop) < 0)
                goto error;
            last_good_net = i;
            bootNet = 0;
8495 8496 8497
        }
    }

8498 8499 8500 8501 8502
    if (def->nsmartcards) {
        /* -device usb-ccid was already emitted along with other
         * controllers.  For now, qemu handles only one smartcard.  */
        virDomainSmartcardDefPtr smartcard = def->smartcards[0];
        char *devstr;
8503
        virBuffer opt = VIR_BUFFER_INITIALIZER;
8504
        const char *database;
8505

8506 8507 8508 8509
        if (def->nsmartcards > 1 ||
            smartcard->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCID ||
            smartcard->info.addr.ccid.controller != 0 ||
            smartcard->info.addr.ccid.slot != 0) {
8510
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
8511 8512 8513
                           _("this QEMU binary lacks multiple smartcard "
                             "support"));
            virBufferFreeAndReset(&opt);
8514 8515 8516
            goto error;
        }

8517 8518
        switch (smartcard->type) {
        case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
8519 8520
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
                !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
8521 8522 8523 8524
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("this QEMU binary lacks smartcard host "
                                 "mode support"));
                goto error;
8525 8526
            }

8527 8528
            virBufferAddLit(&opt, "ccid-card-emulated,backend=nss-emulated");
            break;
8529

8530
        case VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES:
8531 8532
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
                !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
8533 8534 8535 8536 8537
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("this QEMU binary lacks smartcard host "
                                 "mode support"));
                goto error;
            }
8538

8539 8540 8541 8542
            virBufferAddLit(&opt, "ccid-card-emulated,backend=certificates");
            for (j = 0; j < VIR_DOMAIN_SMARTCARD_NUM_CERTIFICATES; j++) {
                if (strchr(smartcard->data.cert.file[j], ',')) {
                    virBufferFreeAndReset(&opt);
8543
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
8544 8545
                                   _("invalid certificate name: %s"),
                                   smartcard->data.cert.file[j]);
8546 8547
                    goto error;
                }
8548
                virBufferAsprintf(&opt, ",cert%zu=%s", j + 1,
8549 8550 8551 8552 8553 8554 8555 8556
                                  smartcard->data.cert.file[j]);
            }
            if (smartcard->data.cert.database) {
                if (strchr(smartcard->data.cert.database, ',')) {
                    virBufferFreeAndReset(&opt);
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                                   _("invalid database name: %s"),
                                   smartcard->data.cert.database);
8557 8558
                    goto error;
                }
8559 8560 8561
                database = smartcard->data.cert.database;
            } else {
                database = VIR_DOMAIN_SMARTCARD_DEFAULT_DATABASE;
8562
            }
8563
            virBufferAsprintf(&opt, ",db=%s", database);
8564
            break;
8565

8566
        case VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH:
8567 8568
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
                !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCID_PASSTHRU)) {
8569 8570 8571 8572
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("this QEMU binary lacks smartcard "
                                 "passthrough mode support"));
                goto error;
8573 8574
            }

8575 8576 8577
            virCommandAddArg(cmd, "-chardev");
            if (!(devstr = qemuBuildChrChardevStr(&smartcard->data.passthru,
                                                  smartcard->info.alias,
8578
                                                  qemuCaps))) {
8579 8580
                virBufferFreeAndReset(&opt);
                goto error;
8581
            }
8582 8583
            virCommandAddArg(cmd, devstr);
            VIR_FREE(devstr);
8584

8585 8586 8587
            virBufferAsprintf(&opt, "ccid-card-passthru,chardev=char%s",
                              smartcard->info.alias);
            break;
8588

8589 8590 8591 8592 8593
        default:
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unexpected smartcard type %d"),
                           smartcard->type);
            virBufferFreeAndReset(&opt);
8594 8595
            goto error;
        }
8596 8597 8598 8599
        virCommandAddArg(cmd, "-device");
        virBufferAsprintf(&opt, ",id=%s,bus=ccid0.0", smartcard->info.alias);
        virCommandAddArgBuffer(cmd, &opt);
    }
8600

8601 8602
    if (!def->nserials) {
        /* If we have -device, then we set -nodefault already */
8603
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
8604 8605
            virCommandAddArgList(cmd, "-serial", "none", NULL);
    } else {
8606
        for (i = 0; i < def->nserials; i++) {
8607 8608
            virDomainChrDefPtr serial = def->serials[i];
            char *devstr;
8609

8610
            /* Use -chardev with -device if they are available */
8611
            if (virQEMUCapsSupportsChardev(def, qemuCaps, serial)) {
8612 8613 8614
                virCommandAddArg(cmd, "-chardev");
                if (!(devstr = qemuBuildChrChardevStr(&serial->source,
                                                      serial->info.alias,
8615
                                                      qemuCaps)))
8616 8617 8618 8619
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);

8620
                if (qemuBuildChrDeviceCommandLine(cmd, def, serial, qemuCaps) < 0)
8621 8622 8623 8624 8625 8626 8627 8628 8629 8630
                   goto error;
            } else {
                virCommandAddArg(cmd, "-serial");
                if (!(devstr = qemuBuildChrArgStr(&serial->source, NULL)))
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
            }
        }
    }
8631

8632 8633
    if (!def->nparallels) {
        /* If we have -device, then we set -nodefault already */
8634
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
8635 8636
            virCommandAddArgList(cmd, "-parallel", "none", NULL);
    } else {
8637
        for (i = 0; i < def->nparallels; i++) {
8638 8639
            virDomainChrDefPtr parallel = def->parallels[i];
            char *devstr;
8640

8641
            /* Use -chardev with -device if they are available */
8642 8643
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
                virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8644 8645 8646
                virCommandAddArg(cmd, "-chardev");
                if (!(devstr = qemuBuildChrChardevStr(&parallel->source,
                                                      parallel->info.alias,
8647
                                                      qemuCaps)))
8648 8649 8650
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
8651

8652 8653
                if (qemuBuildChrDeviceCommandLine(cmd, def, parallel, qemuCaps) < 0)
                    goto error;
8654 8655 8656 8657 8658 8659 8660
            } else {
                virCommandAddArg(cmd, "-parallel");
                if (!(devstr = qemuBuildChrArgStr(&parallel->source, NULL)))
                      goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
            }
8661
        }
8662
    }
8663

8664
    for (i = 0; i < def->nchannels; i++) {
8665 8666
        virDomainChrDefPtr channel = def->channels[i];
        char *devstr;
8667

8668 8669
        switch (channel->targetType) {
        case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
8670 8671
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
                !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8672 8673
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("guestfwd requires QEMU to support -chardev & -device"));
8674 8675
                goto error;
            }
8676

8677 8678 8679
            virCommandAddArg(cmd, "-chardev");
            if (!(devstr = qemuBuildChrChardevStr(&channel->source,
                                                  channel->info.alias,
8680
                                                  qemuCaps)))
8681 8682 8683 8684
                goto error;
            virCommandAddArg(cmd, devstr);
            VIR_FREE(devstr);

8685
            if (qemuBuildChrDeviceStr(&devstr, def, channel, qemuCaps) < 0)
8686
                goto error;
8687 8688
            virCommandAddArgList(cmd, "-netdev", devstr, NULL);
            VIR_FREE(devstr);
8689 8690
            break;

8691
        case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
8692
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8693 8694
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("virtio channel requires QEMU to support -device"));
8695 8696
                goto error;
            }
8697

8698
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC) &&
8699 8700 8701 8702 8703 8704 8705 8706 8707
                channel->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) {
                /* spicevmc was originally introduced via a -device
                 * with a backend internal to qemu; although we prefer
                 * the newer -chardev interface.  */
                ;
            } else {
                virCommandAddArg(cmd, "-chardev");
                if (!(devstr = qemuBuildChrChardevStr(&channel->source,
                                                      channel->info.alias,
8708
                                                      qemuCaps)))
8709 8710 8711
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
8712
            }
8713

8714
            if (qemuBuildChrDeviceCommandLine(cmd, def, channel, qemuCaps) < 0)
8715
                goto error;
8716 8717
            break;
        }
8718
    }
8719

8720
    /* Explicit console devices */
8721
    for (i = 0; i < def->nconsoles; i++) {
8722 8723
        virDomainChrDefPtr console = def->consoles[i];
        char *devstr;
8724

8725
        switch (console->targetType) {
8726 8727
        case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLP:
        case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLPLM:
8728
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8729 8730 8731 8732
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("sclp console requires QEMU to support -device"));
                goto error;
            }
8733
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCLP_S390)) {
8734 8735 8736 8737 8738 8739 8740 8741
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("sclp console requires QEMU to support s390-sclp"));
                goto error;
            }

            virCommandAddArg(cmd, "-chardev");
            if (!(devstr = qemuBuildChrChardevStr(&console->source,
                                                  console->info.alias,
8742
                                                  qemuCaps)))
8743 8744 8745 8746
                goto error;
            virCommandAddArg(cmd, devstr);
            VIR_FREE(devstr);

8747
            if (qemuBuildChrDeviceCommandLine(cmd, def, console, qemuCaps) < 0)
8748 8749 8750
                goto error;
            break;

8751
        case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
8752
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8753 8754 8755
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("virtio channel requires QEMU to support -device"));
                goto error;
P
Peng Zhou 已提交
8756 8757
            }

8758 8759 8760
            virCommandAddArg(cmd, "-chardev");
            if (!(devstr = qemuBuildChrChardevStr(&console->source,
                                                  console->info.alias,
8761
                                                  qemuCaps)))
8762 8763 8764
                goto error;
            virCommandAddArg(cmd, devstr);
            VIR_FREE(devstr);
8765

8766
            if (qemuBuildChrDeviceCommandLine(cmd, def, console, qemuCaps) < 0)
8767
                goto error;
8768
            break;
8769 8770

        case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL:
8771
            break;
8772 8773 8774 8775 8776 8777

        default:
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("unsupported console target type %s"),
                           NULLSTR(virDomainChrConsoleTargetTypeToString(console->targetType)));
            goto error;
8778
        }
8779
    }
8780

8781 8782 8783 8784 8785 8786 8787 8788 8789 8790 8791 8792 8793 8794 8795 8796
    if (def->tpm) {
        char *optstr;

        if (!(optstr = qemuBuildTPMBackendStr(def, qemuCaps, emulator)))
            goto error;

        virCommandAddArgList(cmd, "-tpmdev", optstr, NULL);
        VIR_FREE(optstr);

        if (!(optstr = qemuBuildTPMDevStr(def, qemuCaps, emulator)))
            goto error;

        virCommandAddArgList(cmd, "-device", optstr, NULL);
        VIR_FREE(optstr);
    }

8797
    for (i = 0; i < def->ninputs; i++) {
8798 8799 8800
        virDomainInputDefPtr input = def->inputs[i];

        if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) {
8801
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8802 8803
                char *optstr;
                virCommandAddArg(cmd, "-device");
8804
                if (!(optstr = qemuBuildUSBInputDevStr(def, input, qemuCaps)))
8805
                    goto error;
8806 8807 8808 8809 8810 8811
                virCommandAddArg(cmd, optstr);
                VIR_FREE(optstr);
            } else {
                virCommandAddArgList(cmd, "-usbdevice",
                                     input->type == VIR_DOMAIN_INPUT_TYPE_MOUSE
                                     ? "mouse" : "tablet", NULL);
8812 8813
            }
        }
8814
    }
8815

8816
    for (i = 0; i < def->ngraphics; ++i) {
8817 8818 8819 8820 8821 8822 8823 8824 8825 8826 8827 8828
        switch (def->graphics[i]->type) {
        case VIR_DOMAIN_GRAPHICS_TYPE_SDL:
            ++sdl;
            break;
        case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
            ++vnc;
            break;
        case VIR_DOMAIN_GRAPHICS_TYPE_SPICE:
            ++spice;
            break;
        }
    }
8829
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_0_10) && sdl + vnc + spice > 1) {
8830 8831 8832 8833 8834 8835 8836 8837
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("only 1 graphics device is supported"));
        goto error;
    }
    if (sdl > 1 || vnc > 1 || spice > 1) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("only 1 graphics device of each type "
                         "(sdl, vnc, spice) is supported"));
8838 8839 8840
        goto error;
    }

8841
    for (i = 0; i < def->ngraphics; ++i) {
8842
        if (qemuBuildGraphicsCommandLine(cfg, cmd, def, qemuCaps,
8843 8844 8845
                                         def->graphics[i]) < 0)
            goto error;
    }
8846

8847
    if (def->nvideos > 0) {
8848
        int primaryVideoType = def->videos[0]->type;
8849
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY) &&
8850
             ((primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_VGA &&
8851
                 virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VGA)) ||
8852
             (primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_CIRRUS &&
8853
                 virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_CIRRUS_VGA)) ||
8854
             (primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_VMVGA &&
8855
                 virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VMWARE_SVGA)) ||
8856
             (primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_QXL &&
8857
                 virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA)))
8858
           ) {
8859
            for (i = 0; i < def->nvideos; i++) {
8860 8861
                char *str;
                virCommandAddArg(cmd, "-device");
8862
                if (!(str = qemuBuildDeviceVideoStr(def, def->videos[i], qemuCaps, !i)))
8863 8864 8865 8866 8867
                    goto error;

                virCommandAddArg(cmd, str);
                VIR_FREE(str);
            }
8868
        } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VGA)) {
8869
            if (primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_XEN) {
8870 8871
                /* nothing - vga has no effect on Xen pvfb */
            } else {
8872
                if ((primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_QXL) &&
8873
                    !virQEMUCapsGet(qemuCaps, QEMU_CAPS_VGA_QXL)) {
8874 8875
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("This QEMU does not support QXL graphics adapters"));
8876 8877 8878
                    goto error;
                }

8879
                const char *vgastr = qemuVideoTypeToString(primaryVideoType);
8880
                if (!vgastr || STREQ(vgastr, "")) {
8881 8882
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                                   _("video type %s is not supported with QEMU"),
8883
                                   virDomainVideoTypeToString(primaryVideoType));
8884 8885 8886 8887
                    goto error;
                }

                virCommandAddArgList(cmd, "-vga", vgastr, NULL);
8888

8889 8890
                if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL &&
                    (def->videos[0]->vram || def->videos[0]->ram) &&
8891 8892
                    virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
                    const char *dev = (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA)
8893 8894 8895 8896 8897 8898 8899 8900 8901 8902 8903 8904 8905 8906 8907 8908
                                       ? "qxl-vga" : "qxl");
                    int ram = def->videos[0]->ram;
                    int vram = def->videos[0]->vram;

                    if (vram > (UINT_MAX / 1024)) {
                        virReportError(VIR_ERR_OVERFLOW,
                               _("value for 'vram' must be less than '%u'"),
                                       UINT_MAX / 1024);
                        goto error;
                    }
                    if (ram > (UINT_MAX / 1024)) {
                        virReportError(VIR_ERR_OVERFLOW,
                           _("value for 'ram' must be less than '%u'"),
                                       UINT_MAX / 1024);
                        goto error;
                    }
8909

8910
                    if (ram) {
E
Eric Blake 已提交
8911
                        virCommandAddArg(cmd, "-global");
8912 8913 8914 8915 8916 8917 8918
                        virCommandAddArgFormat(cmd, "%s.ram_size=%u",
                                               dev, ram * 1024);
                    }
                    if (vram) {
                        virCommandAddArg(cmd, "-global");
                        virCommandAddArgFormat(cmd, "%s.vram_size=%u",
                                               dev, vram * 1024);
8919 8920
                    }
                }
8921
            }
8922 8923

            if (def->nvideos > 1) {
8924
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8925
                    for (i = 1; i < def->nvideos; i++) {
8926 8927 8928 8929 8930 8931 8932 8933 8934 8935
                        char *str;
                        if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
                            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                                           _("video type %s is only valid as primary video card"),
                                           virDomainVideoTypeToString(def->videos[0]->type));
                            goto error;
                        }

                        virCommandAddArg(cmd, "-device");

8936
                        if (!(str = qemuBuildDeviceVideoStr(def, def->videos[i], qemuCaps, false)))
8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947
                            goto error;

                        virCommandAddArg(cmd, str);
                        VIR_FREE(str);
                    }
                } else {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                                   "%s", _("only one video card is currently supported"));
                    goto error;
                }
            }
8948 8949 8950 8951 8952 8953 8954 8955 8956 8957 8958 8959 8960 8961 8962 8963 8964
        } else {

            switch (def->videos[0]->type) {
            case VIR_DOMAIN_VIDEO_TYPE_VGA:
                virCommandAddArg(cmd, "-std-vga");
                break;

            case VIR_DOMAIN_VIDEO_TYPE_VMVGA:
                virCommandAddArg(cmd, "-vmwarevga");
                break;

            case VIR_DOMAIN_VIDEO_TYPE_XEN:
            case VIR_DOMAIN_VIDEO_TYPE_CIRRUS:
                /* No special args - this is the default */
                break;

            default:
8965 8966 8967
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("video type %s is not supported with this QEMU"),
                               virDomainVideoTypeToString(def->videos[0]->type));
8968 8969 8970
                goto error;
            }

8971
            if (def->nvideos > 1) {
8972 8973
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("only one video card is currently supported"));
8974 8975 8976 8977 8978 8979
                goto error;
            }
        }

    } else {
        /* If we have -device, then we set -nodefault already */
8980 8981 8982
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE) &&
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_VGA) &&
            virQEMUCapsGet(qemuCaps, QEMU_CAPS_VGA_NONE))
8983 8984 8985 8986 8987
            virCommandAddArgList(cmd, "-vga", "none", NULL);
    }

    /* Add sound hardware */
    if (def->nsounds) {
8988
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
8989
            for (i = 0; i < def->nsounds; i++) {
8990 8991 8992 8993 8994 8995 8996 8997 8998 8999
                virDomainSoundDefPtr sound = def->sounds[i];
                char *str = NULL;

                /* Sadly pcspk device doesn't use -device syntax. Fortunately
                 * we don't need to set any PCI address on it, so we don't
                 * mind too much */
                if (sound->model == VIR_DOMAIN_SOUND_MODEL_PCSPK) {
                    virCommandAddArgList(cmd, "-soundhw", "pcspk", NULL);
                } else {
                    virCommandAddArg(cmd, "-device");
9000
                    if (!(str = qemuBuildSoundDevStr(def, sound, qemuCaps)))
9001 9002 9003
                        goto error;

                    virCommandAddArg(cmd, str);
9004 9005 9006 9007

                    if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6) {
                        char *codecstr = NULL;

9008
                        for (j = 0; j < sound->ncodecs; j++) {
9009
                            virCommandAddArg(cmd, "-device");
9010
                            if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[j], qemuCaps))) {
9011
                                goto error;
9012

9013 9014 9015 9016
                            }
                            virCommandAddArg(cmd, codecstr);
                            VIR_FREE(codecstr);
                        }
9017
                        if (j == 0) {
9018 9019 9020 9021 9022
                            virDomainSoundCodecDef codec = {
                                VIR_DOMAIN_SOUND_CODEC_TYPE_DUPLEX,
                                0
                            };
                            virCommandAddArg(cmd, "-device");
9023
                            if (!(codecstr = qemuBuildSoundCodecStr(sound, &codec, qemuCaps))) {
9024 9025 9026 9027 9028 9029
                                goto error;

                            }
                            virCommandAddArg(cmd, codecstr);
                            VIR_FREE(codecstr);
                        }
9030 9031
                    }

9032 9033 9034 9035 9036 9037
                    VIR_FREE(str);
                }
            }
        } else {
            int size = 100;
            char *modstr;
9038
            if (VIR_ALLOC_N(modstr, size+1) < 0)
9039
                goto error;
9040

9041
            for (i = 0; i < def->nsounds && size > 0; i++) {
9042 9043 9044 9045
                virDomainSoundDefPtr sound = def->sounds[i];
                const char *model = virDomainSoundModelTypeToString(sound->model);
                if (!model) {
                    VIR_FREE(modstr);
9046 9047
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   "%s", _("invalid sound model"));
9048 9049
                    goto error;
                }
9050 9051

                if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6) {
A
Alex Jia 已提交
9052
                    VIR_FREE(modstr);
9053 9054
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("this QEMU binary lacks hda support"));
9055 9056 9057
                    goto error;
                }

9058 9059 9060 9061 9062 9063 9064 9065 9066 9067 9068 9069 9070 9071 9072
                strncat(modstr, model, size);
                size -= strlen(model);
                if (i < (def->nsounds - 1))
                    strncat(modstr, ",", size--);
            }
            virCommandAddArgList(cmd, "-soundhw", modstr, NULL);
            VIR_FREE(modstr);
        }
    }

    /* Add watchdog hardware */
    if (def->watchdog) {
        virDomainWatchdogDefPtr watchdog = def->watchdog;
        char *optstr;

9073
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
9074 9075
            virCommandAddArg(cmd, "-device");

9076
            optstr = qemuBuildWatchdogDevStr(def, watchdog, qemuCaps);
9077 9078 9079 9080 9081 9082 9083
            if (!optstr)
                goto error;
        } else {
            virCommandAddArg(cmd, "-watchdog");

            const char *model = virDomainWatchdogModelTypeToString(watchdog->model);
            if (!model) {
9084 9085
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("missing watchdog model"));
9086 9087 9088
                goto error;
            }

9089 9090
            if (VIR_STRDUP(optstr, model) < 0)
                goto error;
9091 9092 9093 9094 9095 9096 9097 9098 9099
        }
        virCommandAddArg(cmd, optstr);
        VIR_FREE(optstr);

        int act = watchdog->action;
        if (act == VIR_DOMAIN_WATCHDOG_ACTION_DUMP)
            act = VIR_DOMAIN_WATCHDOG_ACTION_PAUSE;
        const char *action = virDomainWatchdogActionTypeToString(act);
        if (!action) {
9100 9101
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("invalid watchdog action"));
9102 9103 9104 9105 9106
            goto error;
        }
        virCommandAddArgList(cmd, "-watchdog-action", action, NULL);
    }

9107
    /* Add redirected devices */
9108
    for (i = 0; i < def->nredirdevs; i++) {
9109 9110 9111 9112 9113 9114
        virDomainRedirdevDefPtr redirdev = def->redirdevs[i];
        char *devstr;

        virCommandAddArg(cmd, "-chardev");
        if (!(devstr = qemuBuildChrChardevStr(&redirdev->source.chr,
                                              redirdev->info.alias,
9115
                                              qemuCaps))) {
9116 9117 9118 9119 9120 9121
            goto error;
        }

        virCommandAddArg(cmd, devstr);
        VIR_FREE(devstr);

9122
        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
9123 9124 9125
            goto error;

        virCommandAddArg(cmd, "-device");
9126
        if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, qemuCaps)))
9127 9128 9129 9130 9131 9132
            goto error;
        virCommandAddArg(cmd, devstr);
        VIR_FREE(devstr);
    }


9133
    /* Add host passthrough hardware */
9134
    for (i = 0; i < def->nhostdevs; i++) {
9135 9136 9137
        virDomainHostdevDefPtr hostdev = def->hostdevs[i];
        char *devstr;

9138
        if (hostdev->info->bootIndex) {
9139
            if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
9140
                (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
9141 9142
                 hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB &&
                 hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI)) {
9143
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
9144
                               _("booting from assigned devices is only "
9145
                                 "supported for PCI, USB and SCSI devices"));
9146
                goto error;
9147
            } else {
9148 9149
                if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
                    if (hostdev->source.subsys.u.pci.backend
9150
                        == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO) {
9151 9152 9153 9154 9155 9156 9157 9158 9159 9160 9161 9162 9163 9164
                        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VFIO_PCI_BOOTINDEX)) {
                            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                           _("booting from PCI devices assigned with VFIO "
                                             "is not supported with this version of qemu"));
                            goto error;
                        }
                    } else {
                        if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_BOOTINDEX)) {
                            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                           _("booting from assigned PCI devices is not "
                                             "supported with this version of qemu"));
                            goto error;
                        }
                    }
9165 9166
                }
                if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB &&
9167
                    !virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_HOST_BOOTINDEX)) {
9168
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
9169 9170
                                   _("booting from assigned USB devices is not "
                                     "supported with this version of qemu"));
9171 9172
                    goto error;
                }
9173 9174 9175 9176 9177 9178 9179
                if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI &&
                    !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SCSI_GENERIC_BOOTINDEX)) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("booting from assigned SCSI devices is not"
                                     " supported with this version of qemu"));
                    goto error;
                }
9180 9181 9182
            }
        }

9183 9184 9185 9186
        /* USB */
        if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
            hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {

9187
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
9188
                virCommandAddArg(cmd, "-device");
9189
                if (!(devstr = qemuBuildUSBHostdevDevStr(def, hostdev, qemuCaps)))
9190 9191 9192 9193 9194 9195 9196 9197 9198 9199 9200 9201 9202 9203 9204
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
            } else {
                virCommandAddArg(cmd, "-usbdevice");
                if (!(devstr = qemuBuildUSBHostdevUsbDevStr(hostdev)))
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
            }
        }

        /* PCI */
        if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
            hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
9205

9206
            if (hostdev->source.subsys.u.pci.backend
9207
                == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO) {
9208 9209 9210 9211 9212 9213
                if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_PCI)) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("VFIO PCI device assignment is not "
                                     "supported by this version of qemu"));
                    goto error;
                }
9214 9215 9216
                /* VFIO requires all of the guest's memory to be locked
                 * resident */
                mlock = true;
9217 9218
            }

9219
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
9220
                char *configfd_name = NULL;
9221
                if ((hostdev->source.subsys.u.pci.backend
9222
                     != VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO) &&
9223
                    virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
9224 9225 9226 9227 9228
                    int configfd = qemuOpenPCIConfig(hostdev);

                    if (configfd >= 0) {
                        if (virAsprintf(&configfd_name, "%d", configfd) < 0) {
                            VIR_FORCE_CLOSE(configfd);
9229
                            goto error;
9230 9231
                        }

9232 9233
                        virCommandPassFD(cmd, configfd,
                                         VIR_COMMAND_PASS_FD_CLOSE_PARENT);
9234 9235 9236
                    }
                }
                virCommandAddArg(cmd, "-device");
9237
                devstr = qemuBuildPCIHostdevDevStr(def, hostdev, configfd_name, qemuCaps);
9238 9239 9240 9241 9242
                VIR_FREE(configfd_name);
                if (!devstr)
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
9243
            } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCIDEVICE)) {
9244 9245 9246 9247 9248 9249
                virCommandAddArg(cmd, "-pcidevice");
                if (!(devstr = qemuBuildPCIHostdevPCIDevStr(hostdev)))
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
            } else {
9250 9251
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("PCI device assignment is not supported by this version of qemu"));
9252 9253 9254
                goto error;
            }
        }
9255 9256 9257 9258 9259 9260 9261 9262 9263 9264

        /* SCSI */
        if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
            hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI) {
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE) &&
                virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE) &&
                virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SCSI_GENERIC)) {
                char *drvstr;

                virCommandAddArg(cmd, "-drive");
9265
                if (!(drvstr = qemuBuildSCSIHostdevDrvStr(hostdev, qemuCaps, callbacks)))
9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280
                    goto error;
                virCommandAddArg(cmd, drvstr);
                VIR_FREE(drvstr);

                virCommandAddArg(cmd, "-device");
                if (!(devstr = qemuBuildSCSIHostdevDevStr(def, hostdev, qemuCaps)))
                    goto error;
                virCommandAddArg(cmd, devstr);
                VIR_FREE(devstr);
            } else {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("SCSI passthrough is not supported by this version of qemu"));
                goto error;
            }
        }
9281 9282
    }

9283 9284 9285 9286 9287 9288
    /* Migration is very annoying due to wildly varying syntax &
     * capabilities over time of KVM / QEMU codebases.
     */
    if (migrateFrom) {
        virCommandAddArg(cmd, "-incoming");
        if (STRPREFIX(migrateFrom, "tcp")) {
9289
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
9290 9291 9292
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("TCP migration is not supported with "
                                       "this QEMU binary"));
9293 9294 9295 9296
                goto error;
            }
            virCommandAddArg(cmd, migrateFrom);
        } else if (STREQ(migrateFrom, "stdio")) {
9297
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
9298
                virCommandAddArgFormat(cmd, "fd:%d", migrateFd);
9299
                virCommandPassFD(cmd, migrateFd, 0);
9300
            } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
9301 9302
                virCommandAddArg(cmd, "exec:cat");
                virCommandSetInputFD(cmd, migrateFd);
9303
            } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_KVM_STDIO)) {
9304 9305 9306
                virCommandAddArg(cmd, migrateFrom);
                virCommandSetInputFD(cmd, migrateFd);
            } else {
9307 9308 9309
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("STDIO migration is not supported "
                                       "with this QEMU binary"));
9310 9311 9312
                goto error;
            }
        } else if (STRPREFIX(migrateFrom, "exec")) {
9313
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
9314 9315 9316
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("EXEC migration is not supported "
                                       "with this QEMU binary"));
9317 9318 9319 9320
                goto error;
            }
            virCommandAddArg(cmd, migrateFrom);
        } else if (STRPREFIX(migrateFrom, "fd")) {
9321
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
9322 9323 9324
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("FD migration is not supported "
                                       "with this QEMU binary"));
9325 9326 9327
                goto error;
            }
            virCommandAddArg(cmd, migrateFrom);
9328
            virCommandPassFD(cmd, migrateFd, 0);
9329
        } else if (STRPREFIX(migrateFrom, "unix")) {
9330
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
9331 9332 9333
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("UNIX migration is not supported "
                                       "with this QEMU binary"));
9334 9335 9336
                goto error;
            }
            virCommandAddArg(cmd, migrateFrom);
9337
        } else {
9338 9339
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("unknown migration protocol"));
9340 9341 9342
            goto error;
        }
    }
9343 9344 9345 9346 9347 9348 9349

    /* QEMU changed its default behavior to not include the virtio balloon
     * device.  Explicitly request it to ensure it will be present.
     *
     * NB: Earlier we declared that VirtIO balloon will always be in
     * slot 0x3 on bus 0x0
     */
9350 9351
    if (STREQLEN(def->os.machine, "s390-virtio", 10) &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390) && def->memballoon)
9352 9353 9354 9355
        def->memballoon->model = VIR_DOMAIN_MEMBALLOON_MODEL_NONE;

    if (def->memballoon &&
        def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE) {
9356
        if (def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO) {
9357 9358 9359
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("Memory balloon device type '%s' is not supported by this version of qemu"),
                           virDomainMemballoonModelTypeToString(def->memballoon->model));
9360 9361
            goto error;
        }
9362
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
9363 9364 9365
            char *optstr;
            virCommandAddArg(cmd, "-device");

9366
            optstr = qemuBuildMemballoonDevStr(def, def->memballoon, qemuCaps);
9367 9368 9369 9370
            if (!optstr)
                goto error;
            virCommandAddArg(cmd, optstr);
            VIR_FREE(optstr);
9371
        } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BALLOON)) {
9372 9373 9374 9375
            virCommandAddArgList(cmd, "-balloon", "virtio", NULL);
        }
    }

9376 9377 9378 9379 9380 9381
    if (def->rng) {
        /* add the RNG source backend */
        if (qemuBuildRNGBackendArgs(cmd, def->rng, qemuCaps) < 0)
            goto error;

        /* add the device */
9382
        if (qemuBuildRNGDeviceArgs(cmd, def, def->rng, qemuCaps) < 0)
9383 9384 9385
            goto error;
    }

9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 9404 9405 9406 9407 9408 9409
    if (def->nvram) {
        if (def->os.arch == VIR_ARCH_PPC64 &&
            STREQ(def->os.machine, "pseries")) {
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_NVRAM)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("nvram device is not supported by "
                                 "this QEMU binary"));
                goto error;
            }

            char *optstr;
            virCommandAddArg(cmd, "-global");
            optstr = qemuBuildNVRAMDevStr(def->nvram);
            if (!optstr)
                goto error;
            if (optstr)
                virCommandAddArg(cmd, optstr);
            VIR_FREE(optstr);
        } else {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                          _("nvram device is only supported for PPC64"));
            goto error;
        }
    }
9410 9411
    if (snapshot)
        virCommandAddArgList(cmd, "-loadvm", snapshot->def->name, NULL);
9412 9413 9414 9415 9416 9417 9418 9419 9420 9421 9422 9423 9424

    if (def->namespaceData) {
        qemuDomainCmdlineDefPtr qemucmd;

        qemucmd = def->namespaceData;
        for (i = 0; i < qemucmd->num_args; i++)
            virCommandAddArg(cmd, qemucmd->args[i]);
        for (i = 0; i < qemucmd->num_env; i++)
            virCommandAddEnvPair(cmd, qemucmd->env_name[i],
                                 qemucmd->env_value[i]
                                 ? qemucmd->env_value[i] : "");
    }

9425
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX)) {
9426
        if (cfg->seccompSandbox == 0)
9427
            virCommandAddArgList(cmd, "-sandbox", "off", NULL);
9428
        else if (cfg->seccompSandbox > 0)
9429
            virCommandAddArgList(cmd, "-sandbox", "on", NULL);
9430
    } else if (cfg->seccompSandbox > 0) {
9431 9432 9433 9434 9435
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("QEMU does not support seccomp sandboxes"));
        goto error;
    }

9436 9437 9438 9439 9440 9441 9442 9443 9444 9445 9446 9447 9448
    if (mlock) {
        unsigned long long memKB;

        /* VFIO requires all of the guest's memory to be
         * locked resident, plus some amount for IO
         * space. Alex Williamson suggested adding 1GiB for IO
         * space just to be safe (some finer tuning might be
         * nice, though).
         */
        memKB = def->mem.hard_limit ?
            def->mem.hard_limit : def->mem.max_balloon + 1024 * 1024;
        virCommandSetMaxMemLock(cmd, memKB * 1024);
    }
9449

9450
    virObjectUnref(cfg);
9451 9452
    return cmd;

9453
error:
9454
    virObjectUnref(cfg);
9455 9456 9457
    /* free up any resources in the network driver
     * but don't overwrite the original error */
    originalError = virSaveLastError();
9458
    for (i = 0; last_good_net != -1 && i <= last_good_net; i++)
9459
        virDomainConfNWFilterTeardown(def->nets[i]);
9460
    virSetError(originalError);
J
John Ferlan 已提交
9461
    virFreeError(originalError);
9462 9463 9464 9465
    virCommandFree(cmd);
    return NULL;
}

9466 9467 9468
/* This function generates the correct '-device' string for character
 * devices of each architecture.
 */
9469 9470
static int
qemuBuildSerialChrDeviceStr(char **deviceStr,
9471
                            virDomainDefPtr def,
9472 9473 9474 9475
                            virDomainChrDefPtr serial,
                            virQEMUCapsPtr qemuCaps,
                            virArch arch,
                            char *machine)
9476 9477 9478
{
    virBuffer cmd = VIR_BUFFER_INITIALIZER;

9479
    if ((arch == VIR_ARCH_PPC64) && STREQ(machine, "pseries")) {
9480 9481 9482 9483
        if (serial->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL &&
            serial->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO) {
            virBufferAsprintf(&cmd, "spapr-vty,chardev=char%s",
                              serial->info.alias);
9484
            if (qemuBuildDeviceAddressStr(&cmd, def, &serial->info, qemuCaps) < 0)
9485 9486
                goto error;
        }
G
Guannan Ren 已提交
9487 9488 9489
    } else {
        virBufferAsprintf(&cmd, "%s,chardev=char%s,id=%s",
                          virDomainChrSerialTargetTypeToString(serial->targetType),
9490 9491
                          serial->info.alias, serial->info.alias);

G
Guannan Ren 已提交
9492
        if (serial->targetType == VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_USB) {
9493
            if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_SERIAL)) {
G
Guannan Ren 已提交
9494 9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("usb-serial is not supported in this QEMU binary"));
                goto error;
            }

            if (serial->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
                serial->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("usb-serial requires address of usb type"));
                goto error;
            }

9506
            if (qemuBuildDeviceAddressStr(&cmd, def, &serial->info, qemuCaps) < 0)
9507
                goto error;
G
Guannan Ren 已提交
9508 9509 9510
        }
    }

9511 9512 9513 9514 9515
    if (virBufferError(&cmd)) {
        virReportOOMError();
        goto error;
    }

9516 9517
    *deviceStr = virBufferContentAndReset(&cmd);
    return 0;
9518

9519
error:
9520
    virBufferFreeAndReset(&cmd);
9521 9522 9523 9524 9525 9526 9527 9528 9529 9530 9531 9532 9533
    return -1;
}

static int
qemuBuildParallelChrDeviceStr(char **deviceStr,
                              virDomainChrDefPtr chr)
{
    if (virAsprintf(deviceStr, "isa-parallel,chardev=char%s,id=%s",
                    chr->info.alias, chr->info.alias) < 0) {
        virReportOOMError();
        return -1;
    }
    return 0;
9534
}
9535

9536 9537 9538 9539 9540 9541 9542 9543 9544 9545 9546 9547 9548 9549 9550 9551 9552 9553 9554 9555 9556 9557 9558 9559 9560 9561 9562 9563 9564 9565 9566 9567 9568 9569 9570 9571 9572 9573 9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585 9586 9587 9588 9589 9590 9591 9592 9593 9594 9595 9596 9597 9598 9599 9600 9601 9602 9603 9604 9605 9606 9607 9608 9609 9610 9611 9612 9613 9614 9615 9616 9617 9618 9619 9620
static int
qemuBuildChannelChrDeviceStr(char **deviceStr,
                             virDomainChrDefPtr chr,
                             virQEMUCapsPtr qemuCaps)
{
    int ret = -1;
    char *addr = NULL;
    int port;

    switch ((enum virDomainChrChannelTargetType) chr->targetType) {
    case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:

        addr = virSocketAddrFormat(chr->target.addr);
        if (!addr)
            return ret;
        port = virSocketAddrGetPort(chr->target.addr);

        if (virAsprintf(deviceStr,
                        "user,guestfwd=tcp:%s:%i,chardev=char%s,id=user-%s",
                        addr, port, chr->info.alias, chr->info.alias) < 0) {
            virReportOOMError();
            goto cleanup;
        }
        break;

    case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
        if (!(*deviceStr = qemuBuildVirtioSerialPortDevStr(chr, qemuCaps)))
                goto cleanup;
        break;

    case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_NONE:
    case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_LAST:
        return ret;
    }

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

static int
qemuBuildConsoleChrDeviceStr(char **deviceStr,
                             virDomainChrDefPtr chr,
                             virQEMUCapsPtr qemuCaps)
{
    int ret = -1;

    switch ((enum virDomainChrConsoleTargetType) chr->targetType) {
    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLP:
    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLPLM:
        if (!(*deviceStr = qemuBuildSclpDevStr(chr)))
            goto cleanup;
        break;

    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
        if (!(*deviceStr = qemuBuildVirtioSerialPortDevStr(chr, qemuCaps)))
            goto cleanup;
        break;

    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL:
    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_NONE:
    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_XEN:
    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_UML:
    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_LXC:
    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_OPENVZ:
    case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_LAST:
        break;
    }

    ret = 0;
cleanup:
    return ret;
}

int
qemuBuildChrDeviceStr(char **deviceStr,
                      virDomainDefPtr vmdef,
                      virDomainChrDefPtr chr,
                      virQEMUCapsPtr qemuCaps)
{
    int ret = -1;

    switch ((enum virDomainChrDeviceType) chr->deviceType) {
    case VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL:
9621
        ret = qemuBuildSerialChrDeviceStr(deviceStr, vmdef, chr, qemuCaps,
9622 9623 9624 9625 9626 9627 9628 9629 9630 9631 9632 9633 9634 9635 9636 9637 9638 9639 9640 9641 9642 9643 9644 9645
                                          vmdef->os.arch,
                                          vmdef->os.machine);
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
        ret = qemuBuildParallelChrDeviceStr(deviceStr, chr);
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
        ret = qemuBuildChannelChrDeviceStr(deviceStr, chr, qemuCaps);
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
        ret = qemuBuildConsoleChrDeviceStr(deviceStr, chr, qemuCaps);
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_LAST:
        return ret;
    }

    return ret;
}


9646 9647 9648 9649 9650 9651 9652
/*
 * This method takes a string representing a QEMU command line ARGV set
 * optionally prefixed by a list of environment variables. It then tries
 * to split it up into a NULL terminated list of env & argv, splitting
 * on space
 */
static int qemuStringToArgvEnv(const char *args,
E
Eric Blake 已提交
9653 9654
                               char ***retenv,
                               char ***retargv)
9655 9656 9657 9658 9659
{
    char **arglist = NULL;
    int argcount = 0;
    int argalloc = 0;
    int envend;
9660
    size_t i;
9661 9662
    const char *curr = args;
    const char *start;
E
Eric Blake 已提交
9663 9664
    char **progenv = NULL;
    char **progargv = NULL;
9665 9666 9667 9668 9669 9670 9671 9672 9673 9674 9675 9676 9677 9678 9679 9680 9681 9682 9683 9684 9685 9686 9687 9688 9689

    /* Iterate over string, splitting on sequences of ' ' */
    while (curr && *curr != '\0') {
        char *arg;
        const char *next;

        start = curr;
        /* accept a space in CEPH_ARGS */
        if (STRPREFIX(curr, "CEPH_ARGS=-m ")) {
            start += strlen("CEPH_ARGS=-m ");
        }
        if (*start == '\'') {
            if (start == curr)
                curr++;
            next = strchr(start + 1, '\'');
        } else if (*start == '"') {
            if (start == curr)
                curr++;
            next = strchr(start + 1, '"');
        } else {
            next = strchr(start, ' ');
        }
        if (!next)
            next = strchr(curr, '\n');

9690
        if (VIR_STRNDUP(arg, curr, next ? next - curr : -1) < 0)
9691
            goto error;
9692

9693 9694
        if (next && (*next == '\'' || *next == '"'))
            next++;
9695 9696 9697 9698

        if (argalloc == argcount) {
            if (VIR_REALLOC_N(arglist, argalloc+10) < 0) {
                VIR_FREE(arg);
9699
                goto error;
9700 9701 9702 9703 9704 9705 9706 9707 9708 9709 9710 9711 9712 9713
            }
            argalloc+=10;
        }

        arglist[argcount++] = arg;

        while (next && c_isspace(*next))
            next++;

        curr = next;
    }

    /* Iterate over list of args, finding first arg not containing
     * the '=' character (eg, skip over env vars FOO=bar) */
9714
    for (envend = 0; ((envend < argcount) &&
9715 9716 9717 9718 9719 9720 9721
                       (strchr(arglist[envend], '=') != NULL));
         envend++)
        ; /* nada */

    /* Copy the list of env vars */
    if (envend > 0) {
        if (VIR_REALLOC_N(progenv, envend+1) < 0)
9722
            goto error;
9723
        for (i = 0; i < envend; i++) {
9724 9725 9726 9727 9728 9729 9730 9731
            progenv[i] = arglist[i];
            arglist[i] = NULL;
        }
        progenv[i] = NULL;
    }

    /* Copy the list of argv */
    if (VIR_REALLOC_N(progargv, argcount-envend + 1) < 0)
9732
        goto error;
9733
    for (i = envend; i < argcount; i++)
9734 9735 9736 9737 9738 9739 9740 9741 9742 9743
        progargv[i-envend] = arglist[i];
    progargv[i-envend] = NULL;

    VIR_FREE(arglist);

    *retenv = progenv;
    *retargv = progargv;

    return 0;

9744
error:
E
Eric Blake 已提交
9745 9746
    virStringFreeList(progenv);
    virStringFreeList(arglist);
9747 9748 9749 9750 9751 9752 9753
    return -1;
}


/*
 * Search for a named env variable, and return the value part
 */
E
Eric Blake 已提交
9754
static const char *qemuFindEnv(char **progenv,
9755 9756
                               const char *name)
{
9757
    size_t i;
9758 9759
    int len = strlen(name);

9760
    for (i = 0; progenv && progenv[i]; i++) {
9761 9762 9763 9764 9765 9766 9767 9768 9769 9770 9771 9772 9773 9774 9775 9776 9777 9778 9779 9780 9781 9782 9783 9784 9785 9786
        if (STREQLEN(progenv[i], name, len) &&
            progenv[i][len] == '=')
            return progenv[i] + len + 1;
    }
    return NULL;
}

/*
 * Takes a string containing a set of key=value,key=value,key...
 * parameters and splits them up, returning two arrays with
 * the individual keys and values. If allowEmptyValue is nonzero,
 * the "=value" part is optional and if a key with no value is found,
 * NULL is be placed into corresponding place in retvalues.
 */
int
qemuParseKeywords(const char *str,
                  char ***retkeywords,
                  char ***retvalues,
                  int allowEmptyValue)
{
    int keywordCount = 0;
    int keywordAlloc = 0;
    char **keywords = NULL;
    char **values = NULL;
    const char *start = str;
    const char *end;
9787
    size_t i;
9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798

    *retkeywords = NULL;
    *retvalues = NULL;
    end = start + strlen(str);

    while (start) {
        const char *separator;
        const char *endmark;
        char *keyword;
        char *value = NULL;

9799 9800 9801 9802 9803 9804 9805 9806
        endmark = start;
        do {
            /* Qemu accepts ',,' as an escape for a literal comma;
             * skip past those here while searching for the end of the
             * value, then strip them down below */
            endmark = strchr(endmark, ',');
        } while (endmark && endmark[1] == ',' && (endmark += 2));
        if (!endmark)
9807 9808 9809 9810 9811 9812
            endmark = end;
        if (!(separator = strchr(start, '=')))
            separator = end;

        if (separator >= endmark) {
            if (!allowEmptyValue) {
9813 9814
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("malformed keyword arguments in '%s'"), str);
9815 9816 9817 9818 9819
                goto error;
            }
            separator = endmark;
        }

9820 9821
        if (VIR_STRNDUP(keyword, start, separator - start) < 0)
            goto error;
9822 9823 9824

        if (separator < endmark) {
            separator++;
9825
            if (VIR_STRNDUP(value, separator, endmark - separator) < 0) {
9826
                VIR_FREE(keyword);
9827
                goto error;
9828
            }
9829 9830 9831 9832 9833 9834 9835 9836 9837 9838
            if (strchr(value, ',')) {
                char *p = strchr(value, ',') + 1;
                char *q = p + 1;
                while (*q) {
                    if (*q == ',')
                        q++;
                    *p++ = *q++;
                }
                *p = '\0';
            }
9839 9840 9841 9842 9843 9844 9845
        }

        if (keywordAlloc == keywordCount) {
            if (VIR_REALLOC_N(keywords, keywordAlloc + 10) < 0 ||
                VIR_REALLOC_N(values, keywordAlloc + 10) < 0) {
                VIR_FREE(keyword);
                VIR_FREE(value);
9846
                goto error;
9847 9848 9849 9850 9851 9852 9853 9854 9855 9856 9857 9858 9859 9860 9861 9862 9863
            }
            keywordAlloc += 10;
        }

        keywords[keywordCount] = keyword;
        values[keywordCount] = value;
        keywordCount++;

        start = endmark < end ? endmark + 1 : NULL;
    }

    *retkeywords = keywords;
    *retvalues = values;

    return keywordCount;

error:
9864
    for (i = 0; i < keywordCount; i++) {
9865 9866 9867 9868 9869 9870 9871 9872 9873 9874 9875 9876 9877 9878 9879 9880
        VIR_FREE(keywords[i]);
        VIR_FREE(values[i]);
    }
    VIR_FREE(keywords);
    VIR_FREE(values);
    return -1;
}

/*
 * Tries to parse new style QEMU -drive  args.
 *
 * eg -drive file=/dev/HostVG/VirtData1,if=ide,index=1
 *
 * Will fail if not using the 'index' keyword
 */
static virDomainDiskDefPtr
9881
qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
9882
                         const char *val,
9883 9884
                         int nvirtiodisk,
                         bool old_style_ceph_args)
9885 9886 9887 9888 9889
{
    virDomainDiskDefPtr def = NULL;
    char **keywords;
    char **values;
    int nkeywords;
9890
    size_t i;
9891 9892 9893
    int idx = -1;
    int busid = -1;
    int unitid = -1;
9894
    int trans = VIR_DOMAIN_DISK_TRANS_DEFAULT;
9895 9896 9897 9898 9899 9900

    if ((nkeywords = qemuParseKeywords(val,
                                       &keywords,
                                       &values, 0)) < 0)
        return NULL;

9901
    if (VIR_ALLOC(def) < 0)
9902 9903 9904 9905 9906 9907
        goto cleanup;

    def->bus = VIR_DOMAIN_DISK_BUS_IDE;
    def->device = VIR_DOMAIN_DISK_DEVICE_DISK;
    def->type = VIR_DOMAIN_DISK_TYPE_FILE;

9908
    for (i = 0; i < nkeywords; i++) {
9909 9910 9911 9912 9913 9914
        if (STREQ(keywords[i], "file")) {
            if (values[i] && STRNEQ(values[i], "")) {
                def->src = values[i];
                values[i] = NULL;
                if (STRPREFIX(def->src, "/dev/"))
                    def->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
P
Paolo Bonzini 已提交
9915 9916
                else if (STRPREFIX(def->src, "nbd:") ||
                         STRPREFIX(def->src, "nbd+")) {
9917 9918 9919
                    def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                    def->protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;

9920 9921
                    if (qemuParseNBDString(def) < 0)
                        goto error;
9922 9923 9924 9925 9926
                } else if (STRPREFIX(def->src, "rbd:")) {
                    char *p = def->src;

                    def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                    def->protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
9927
                    if (VIR_STRDUP(def->src, p + strlen("rbd:")) < 0)
9928
                        goto error;
9929 9930 9931
                    /* old-style CEPH_ARGS env variable is parsed later */
                    if (!old_style_ceph_args && qemuParseRBDString(def) < 0)
                        goto cleanup;
9932 9933

                    VIR_FREE(p);
P
Paolo Bonzini 已提交
9934 9935
                } else if (STRPREFIX(def->src, "gluster:") ||
                           STRPREFIX(def->src, "gluster+")) {
9936 9937 9938 9939
                    def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                    def->protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;

                    if (qemuParseGlusterString(def) < 0)
9940
                        goto error;
P
Paolo Bonzini 已提交
9941 9942 9943 9944 9945 9946
                } else if (STRPREFIX(def->src, "iscsi:")) {
                    def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                    def->protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;

                    if (qemuParseISCSIString(def) < 0)
                        goto error;
9947 9948 9949 9950 9951 9952
                } else if (STRPREFIX(def->src, "sheepdog:")) {
                    char *p = def->src;
                    char *port, *vdi;

                    def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                    def->protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
9953
                    if (VIR_STRDUP(def->src, p + strlen("sheepdog:")) < 0)
9954
                        goto error;
9955 9956 9957 9958 9959 9960 9961

                    /* def->src must be [vdiname] or [host]:[port]:[vdiname] */
                    port = strchr(def->src, ':');
                    if (port) {
                        *port++ = '\0';
                        vdi = strchr(port, ':');
                        if (!vdi) {
9962 9963
                            virReportError(VIR_ERR_INTERNAL_ERROR,
                                           _("cannot parse sheepdog filename '%s'"), p);
9964
                            goto error;
9965 9966
                        }
                        *vdi++ = '\0';
9967
                        if (VIR_ALLOC(def->hosts) < 0)
9968
                            goto error;
9969 9970
                        def->nhosts = 1;
                        def->hosts->name = def->src;
9971
                        if (VIR_STRDUP(def->hosts->port, port) < 0)
9972
                            goto error;
9973 9974
                        def->hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
                        def->hosts->socket = NULL;
9975
                        if (VIR_STRDUP(def->src, vdi) < 0)
9976
                            goto error;
9977 9978 9979 9980 9981 9982 9983 9984 9985 9986 9987 9988 9989 9990 9991 9992 9993
                    }

                    VIR_FREE(p);
                } else
                    def->type = VIR_DOMAIN_DISK_TYPE_FILE;
            } else {
                def->type = VIR_DOMAIN_DISK_TYPE_FILE;
            }
        } else if (STREQ(keywords[i], "if")) {
            if (STREQ(values[i], "ide"))
                def->bus = VIR_DOMAIN_DISK_BUS_IDE;
            else if (STREQ(values[i], "scsi"))
                def->bus = VIR_DOMAIN_DISK_BUS_SCSI;
            else if (STREQ(values[i], "virtio"))
                def->bus = VIR_DOMAIN_DISK_BUS_VIRTIO;
            else if (STREQ(values[i], "xen"))
                def->bus = VIR_DOMAIN_DISK_BUS_XEN;
9994 9995
            else if (STREQ(values[i], "sd"))
                def->bus = VIR_DOMAIN_DISK_BUS_SD;
9996 9997 9998
        } else if (STREQ(keywords[i], "media")) {
            if (STREQ(values[i], "cdrom")) {
                def->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
9999
                def->readonly = true;
10000 10001 10002
            } else if (STREQ(values[i], "floppy"))
                def->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
        } else if (STREQ(keywords[i], "format")) {
10003
            if (VIR_STRDUP(def->driverName, "qemu") < 0)
10004
                goto error;
10005
            def->format = virStorageFileFormatTypeFromString(values[i]);
10006 10007 10008 10009 10010 10011 10012 10013 10014
        } else if (STREQ(keywords[i], "cache")) {
            if (STREQ(values[i], "off") ||
                STREQ(values[i], "none"))
                def->cachemode = VIR_DOMAIN_DISK_CACHE_DISABLE;
            else if (STREQ(values[i], "writeback") ||
                     STREQ(values[i], "on"))
                def->cachemode = VIR_DOMAIN_DISK_CACHE_WRITEBACK;
            else if (STREQ(values[i], "writethrough"))
                def->cachemode = VIR_DOMAIN_DISK_CACHE_WRITETHRU;
10015 10016
            else if (STREQ(values[i], "directsync"))
                def->cachemode = VIR_DOMAIN_DISK_CACHE_DIRECTSYNC;
10017 10018
            else if (STREQ(values[i], "unsafe"))
                def->cachemode = VIR_DOMAIN_DISK_CACHE_UNSAFE;
10019
        } else if (STREQ(keywords[i], "werror")) {
10020 10021
            if (STREQ(values[i], "stop"))
                def->error_policy = VIR_DOMAIN_DISK_ERROR_POLICY_STOP;
10022 10023
            else if (STREQ(values[i], "report"))
                def->error_policy = VIR_DOMAIN_DISK_ERROR_POLICY_REPORT;
10024 10025
            else if (STREQ(values[i], "ignore"))
                def->error_policy = VIR_DOMAIN_DISK_ERROR_POLICY_IGNORE;
10026
            else if (STREQ(values[i], "enospc"))
10027
                def->error_policy = VIR_DOMAIN_DISK_ERROR_POLICY_ENOSPACE;
10028 10029 10030 10031 10032 10033 10034
        } else if (STREQ(keywords[i], "rerror")) {
            if (STREQ(values[i], "stop"))
                def->rerror_policy = VIR_DOMAIN_DISK_ERROR_POLICY_STOP;
            else if (STREQ(values[i], "report"))
                def->rerror_policy = VIR_DOMAIN_DISK_ERROR_POLICY_REPORT;
            else if (STREQ(values[i], "ignore"))
                def->rerror_policy = VIR_DOMAIN_DISK_ERROR_POLICY_IGNORE;
10035 10036
        } else if (STREQ(keywords[i], "index")) {
            if (virStrToLong_i(values[i], NULL, 10, &idx) < 0) {
10037 10038
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse drive index '%s'"), val);
10039
                goto error;
10040 10041 10042
            }
        } else if (STREQ(keywords[i], "bus")) {
            if (virStrToLong_i(values[i], NULL, 10, &busid) < 0) {
10043 10044
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse drive bus '%s'"), val);
10045
                goto error;
10046 10047 10048
            }
        } else if (STREQ(keywords[i], "unit")) {
            if (virStrToLong_i(values[i], NULL, 10, &unitid) < 0) {
10049 10050
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse drive unit '%s'"), val);
10051
                goto error;
10052 10053 10054
            }
        } else if (STREQ(keywords[i], "readonly")) {
            if ((values[i] == NULL) || STREQ(values[i], "on"))
10055
                def->readonly = true;
E
Eric Blake 已提交
10056 10057
        } else if (STREQ(keywords[i], "aio")) {
            if ((def->iomode = virDomainDiskIoTypeFromString(values[i])) < 0) {
10058 10059
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse io mode '%s'"), values[i]);
E
Eric Blake 已提交
10060
            }
10061 10062 10063 10064 10065 10066 10067 10068 10069 10070 10071 10072 10073 10074 10075 10076 10077 10078 10079 10080 10081 10082 10083 10084 10085 10086 10087 10088 10089 10090 10091 10092 10093 10094 10095 10096 10097 10098
        } else if (STREQ(keywords[i], "cyls")) {
            if (virStrToLong_ui(values[i], NULL, 10,
                                &(def->geometry.cylinders)) < 0) {
                virDomainDiskDefFree(def);
                def = NULL;
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse cylinders value'%s'"),
                               values[i]);
            }
        } else if (STREQ(keywords[i], "heads")) {
            if (virStrToLong_ui(values[i], NULL, 10,
                                &(def->geometry.heads)) < 0) {
                virDomainDiskDefFree(def);
                def = NULL;
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse heads value'%s'"),
                               values[i]);
            }
        } else if (STREQ(keywords[i], "secs")) {
            if (virStrToLong_ui(values[i], NULL, 10,
                                &(def->geometry.sectors)) < 0) {
                virDomainDiskDefFree(def);
                def = NULL;
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse sectors value'%s'"),
                               values[i]);
            }
        } else if (STREQ(keywords[i], "trans")) {
            def->geometry.trans =
                virDomainDiskGeometryTransTypeFromString(values[i]);
            if ((trans < VIR_DOMAIN_DISK_TRANS_DEFAULT) ||
                (trans >= VIR_DOMAIN_DISK_TRANS_LAST)) {
                virDomainDiskDefFree(def);
                def = NULL;
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse translation value'%s'"),
                               values[i]);
            }
10099 10100 10101
        }
    }

10102 10103 10104
    if (def->rerror_policy == def->error_policy)
        def->rerror_policy = 0;

10105 10106 10107
    if (!def->src &&
        def->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
        def->type != VIR_DOMAIN_DISK_TYPE_NETWORK) {
10108 10109
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("missing file parameter in drive '%s'"), val);
10110
        goto error;
10111 10112 10113 10114 10115 10116 10117 10118
    }
    if (idx == -1 &&
        def->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)
        idx = nvirtiodisk;

    if (idx == -1 &&
        unitid == -1 &&
        busid == -1) {
10119
        virReportError(VIR_ERR_INTERNAL_ERROR,
10120 10121 10122
                       _("missing index/unit/bus parameter in drive '%s'"),
                       val);
        goto error;
10123 10124 10125 10126 10127 10128 10129 10130 10131 10132 10133 10134 10135 10136 10137 10138 10139 10140 10141 10142 10143
    }

    if (idx == -1) {
        if (unitid == -1)
            unitid = 0;
        if (busid == -1)
            busid = 0;
        switch (def->bus) {
        case VIR_DOMAIN_DISK_BUS_IDE:
            idx = (busid * 2) + unitid;
            break;
        case VIR_DOMAIN_DISK_BUS_SCSI:
            idx = (busid * 7) + unitid;
            break;
        default:
            idx = unitid;
            break;
        }
    }

    if (def->bus == VIR_DOMAIN_DISK_BUS_IDE) {
10144
        ignore_value(VIR_STRDUP(def->dst, "hda"));
10145 10146
    } else if (def->bus == VIR_DOMAIN_DISK_BUS_SCSI ||
               def->bus == VIR_DOMAIN_DISK_BUS_SD) {
10147
        ignore_value(VIR_STRDUP(def->dst, "sda"));
10148
    } else if (def->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) {
10149
        ignore_value(VIR_STRDUP(def->dst, "vda"));
10150
    } else if (def->bus == VIR_DOMAIN_DISK_BUS_XEN) {
10151
        ignore_value(VIR_STRDUP(def->dst, "xvda"));
10152
    } else {
10153
        ignore_value(VIR_STRDUP(def->dst, "hda"));
10154 10155
    }

10156
    if (!def->dst)
10157
        goto error;
10158 10159 10160 10161 10162
    if (STREQ(def->dst, "xvda"))
        def->dst[3] = 'a' + idx;
    else
        def->dst[2] = 'a' + idx;

10163
    if (virDomainDiskDefAssignAddress(xmlopt, def) < 0) {
10164 10165
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("invalid device name '%s'"), def->dst);
10166 10167 10168 10169 10170 10171
        virDomainDiskDefFree(def);
        def = NULL;
        /* fall through to "cleanup" */
    }

cleanup:
10172
    for (i = 0; i < nkeywords; i++) {
10173 10174 10175 10176 10177 10178
        VIR_FREE(keywords[i]);
        VIR_FREE(values[i]);
    }
    VIR_FREE(keywords);
    VIR_FREE(values);
    return def;
10179 10180 10181 10182 10183

error:
    virDomainDiskDefFree(def);
    def = NULL;
    goto cleanup;
10184 10185 10186 10187 10188 10189 10190 10191 10192 10193
}

/*
 * Tries to find a NIC definition matching a vlan we want
 */
static const char *
qemuFindNICForVLAN(int nnics,
                   const char **nics,
                   int wantvlan)
{
10194
    size_t i;
10195
    for (i = 0; i < nnics; i++) {
10196 10197 10198 10199 10200 10201 10202 10203 10204
        int gotvlan;
        const char *tmp = strstr(nics[i], "vlan=");
        char *end;
        if (!tmp)
            continue;

        tmp += strlen("vlan=");

        if (virStrToLong_i(tmp, &end, 10, &gotvlan) < 0) {
10205 10206
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot parse NIC vlan in '%s'"), nics[i]);
10207 10208 10209 10210 10211 10212 10213 10214 10215 10216
            return NULL;
        }

        if (gotvlan == wantvlan)
            return nics[i];
    }

    if (wantvlan == 0 && nnics > 0)
        return nics[0];

10217 10218
    virReportError(VIR_ERR_INTERNAL_ERROR,
                   _("cannot find NIC definition for vlan %d"), wantvlan);
10219 10220 10221 10222 10223 10224 10225 10226 10227 10228
    return NULL;
}


/*
 * Tries to parse a QEMU -net backend argument. Gets given
 * a list of all known -net frontend arguments to try and
 * match up against. Horribly complicated stuff
 */
static virDomainNetDefPtr
10229
qemuParseCommandLineNet(virDomainXMLOptionPtr xmlopt,
10230 10231 10232 10233 10234 10235 10236 10237 10238 10239 10240
                        const char *val,
                        int nnics,
                        const char **nics)
{
    virDomainNetDefPtr def = NULL;
    char **keywords = NULL;
    char **values = NULL;
    int nkeywords;
    const char *nic;
    int wantvlan = 0;
    const char *tmp;
10241
    bool genmac = true;
10242
    size_t i;
10243 10244 10245 10246 10247 10248 10249 10250 10251 10252 10253 10254

    tmp = strchr(val, ',');

    if (tmp) {
        if ((nkeywords = qemuParseKeywords(tmp+1,
                                           &keywords,
                                           &values, 0)) < 0)
            return NULL;
    } else {
        nkeywords = 0;
    }

10255
    if (VIR_ALLOC(def) < 0)
10256 10257 10258 10259 10260 10261 10262 10263 10264 10265 10266 10267 10268
        goto cleanup;

    /* 'tap' could turn into libvirt type=ethernet, type=bridge or
     * type=network, but we can't tell, so use the generic config */
    if (STRPREFIX(val, "tap,"))
        def->type = VIR_DOMAIN_NET_TYPE_ETHERNET;
    else if (STRPREFIX(val, "socket"))
        def->type = VIR_DOMAIN_NET_TYPE_CLIENT;
    else if (STRPREFIX(val, "user"))
        def->type = VIR_DOMAIN_NET_TYPE_USER;
    else
        def->type = VIR_DOMAIN_NET_TYPE_ETHERNET;

10269
    for (i = 0; i < nkeywords; i++) {
10270 10271
        if (STREQ(keywords[i], "vlan")) {
            if (virStrToLong_i(values[i], NULL, 10, &wantvlan) < 0) {
10272 10273
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse vlan in '%s'"), val);
10274 10275 10276 10277 10278 10279
                virDomainNetDefFree(def);
                def = NULL;
                goto cleanup;
            }
        } else if (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET &&
                   STREQ(keywords[i], "script") && STRNEQ(values[i], "")) {
10280
            def->script = values[i];
10281 10282 10283 10284 10285 10286 10287 10288 10289 10290 10291 10292 10293 10294 10295 10296 10297 10298 10299 10300 10301
            values[i] = NULL;
        } else if (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET &&
                   STREQ(keywords[i], "ifname")) {
            def->ifname = values[i];
            values[i] = NULL;
        }
    }


    /* Done parsing the nic backend. Now to try and find corresponding
     * frontend, based off vlan number. NB this assumes a 1-1 mapping
     */

    nic = qemuFindNICForVLAN(nnics, nics, wantvlan);
    if (!nic) {
        virDomainNetDefFree(def);
        def = NULL;
        goto cleanup;
    }

    if (!STRPREFIX(nic, "nic")) {
10302 10303
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("cannot parse NIC definition '%s'"), nic);
10304 10305 10306 10307 10308
        virDomainNetDefFree(def);
        def = NULL;
        goto cleanup;
    }

10309
    for (i = 0; i < nkeywords; i++) {
10310 10311 10312 10313 10314 10315 10316 10317 10318 10319 10320 10321 10322 10323 10324 10325 10326 10327
        VIR_FREE(keywords[i]);
        VIR_FREE(values[i]);
    }
    VIR_FREE(keywords);
    VIR_FREE(values);

    if (STRPREFIX(nic, "nic,")) {
        if ((nkeywords = qemuParseKeywords(nic + strlen("nic,"),
                                           &keywords,
                                           &values, 0)) < 0) {
            virDomainNetDefFree(def);
            def = NULL;
            goto cleanup;
        }
    } else {
        nkeywords = 0;
    }

10328
    for (i = 0; i < nkeywords; i++) {
10329
        if (STREQ(keywords[i], "macaddr")) {
10330
            genmac = false;
10331
            if (virMacAddrParse(values[i], &def->mac) < 0) {
10332 10333 10334
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("unable to parse mac address '%s'"),
                               values[i]);
10335 10336 10337 10338 10339 10340 10341
                virDomainNetDefFree(def);
                def = NULL;
                goto cleanup;
            }
        } else if (STREQ(keywords[i], "model")) {
            def->model = values[i];
            values[i] = NULL;
10342 10343
        } else if (STREQ(keywords[i], "vhost")) {
            if ((values[i] == NULL) || STREQ(values[i], "on")) {
10344
                def->driver.virtio.name = VIR_DOMAIN_NET_BACKEND_TYPE_VHOST;
10345
            } else if (STREQ(keywords[i], "off")) {
10346
                def->driver.virtio.name = VIR_DOMAIN_NET_BACKEND_TYPE_QEMU;
10347
            }
10348 10349
        } else if (STREQ(keywords[i], "sndbuf") && values[i]) {
            if (virStrToLong_ul(values[i], NULL, 10, &def->tune.sndbuf) < 0) {
10350 10351
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse sndbuf size in '%s'"), val);
10352 10353 10354 10355 10356
                virDomainNetDefFree(def);
                def = NULL;
                goto cleanup;
            }
            def->tune.sndbuf_specified = true;
10357 10358 10359 10360
        }
    }

    if (genmac)
10361
        virDomainNetGenerateMAC(xmlopt, &def->mac);
10362 10363

cleanup:
10364
    for (i = 0; i < nkeywords; i++) {
10365 10366 10367 10368 10369 10370 10371 10372 10373 10374 10375 10376 10377 10378 10379 10380 10381 10382
        VIR_FREE(keywords[i]);
        VIR_FREE(values[i]);
    }
    VIR_FREE(keywords);
    VIR_FREE(values);
    return def;
}


/*
 * Tries to parse a QEMU PCI device
 */
static virDomainHostdevDefPtr
qemuParseCommandLinePCI(const char *val)
{
    int bus = 0, slot = 0, func = 0;
    const char *start;
    char *end;
10383 10384 10385 10386
    virDomainHostdevDefPtr def = virDomainHostdevDefAlloc();

    if (!def)
       goto error;
10387 10388

    if (!STRPREFIX(val, "host=")) {
10389 10390
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unknown PCI device syntax '%s'"), val);
10391
        goto error;
10392 10393 10394 10395
    }

    start = val + strlen("host=");
    if (virStrToLong_i(start, &end, 16, &bus) < 0 || *end != ':') {
10396 10397
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("cannot extract PCI device bus '%s'"), val);
10398
        goto error;
10399 10400 10401
    }
    start = end + 1;
    if (virStrToLong_i(start, &end, 16, &slot) < 0 || *end != '.') {
10402 10403
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("cannot extract PCI device slot '%s'"), val);
10404
        goto error;
10405 10406 10407
    }
    start = end + 1;
    if (virStrToLong_i(start, NULL, 16, &func) < 0) {
10408 10409
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("cannot extract PCI device function '%s'"), val);
10410
        goto error;
10411 10412 10413
    }

    def->mode = VIR_DOMAIN_HOSTDEV_MODE_SUBSYS;
10414
    def->managed = true;
10415
    def->source.subsys.type = VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI;
10416 10417 10418
    def->source.subsys.u.pci.addr.bus = bus;
    def->source.subsys.u.pci.addr.slot = slot;
    def->source.subsys.u.pci.addr.function = func;
10419
    return def;
10420 10421 10422 10423

 error:
    virDomainHostdevDefFree(def);
    return NULL;
10424 10425 10426 10427 10428 10429 10430 10431 10432
}


/*
 * Tries to parse a QEMU USB device
 */
static virDomainHostdevDefPtr
qemuParseCommandLineUSB(const char *val)
{
10433
    virDomainHostdevDefPtr def = virDomainHostdevDefAlloc();
10434 10435 10436 10437
    int first = 0, second = 0;
    const char *start;
    char *end;

10438 10439 10440
    if (!def)
       goto error;

10441
    if (!STRPREFIX(val, "host:")) {
10442 10443
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unknown USB device syntax '%s'"), val);
10444
        goto error;
10445 10446 10447 10448 10449
    }

    start = val + strlen("host:");
    if (strchr(start, ':')) {
        if (virStrToLong_i(start, &end, 16, &first) < 0 || *end != ':') {
10450 10451
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot extract USB device vendor '%s'"), val);
10452
            goto error;
10453 10454 10455
        }
        start = end + 1;
        if (virStrToLong_i(start, NULL, 16, &second) < 0) {
10456 10457
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot extract USB device product '%s'"), val);
10458
            goto error;
10459 10460 10461
        }
    } else {
        if (virStrToLong_i(start, &end, 10, &first) < 0 || *end != '.') {
10462 10463
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot extract USB device bus '%s'"), val);
10464
            goto error;
10465 10466 10467
        }
        start = end + 1;
        if (virStrToLong_i(start, NULL, 10, &second) < 0) {
10468 10469
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot extract USB device address '%s'"), val);
10470
            goto error;
10471 10472 10473 10474
        }
    }

    def->mode = VIR_DOMAIN_HOSTDEV_MODE_SUBSYS;
10475
    def->managed = false;
10476 10477 10478 10479 10480 10481 10482 10483 10484
    def->source.subsys.type = VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB;
    if (*end == '.') {
        def->source.subsys.u.usb.bus = first;
        def->source.subsys.u.usb.device = second;
    } else {
        def->source.subsys.u.usb.vendor = first;
        def->source.subsys.u.usb.product = second;
    }
    return def;
10485 10486 10487 10488

 error:
    virDomainHostdevDefFree(def);
    return NULL;
10489 10490 10491 10492 10493 10494
}


/*
 * Tries to parse a QEMU serial/parallel device
 */
10495 10496 10497
static int
qemuParseCommandLineChr(virDomainChrSourceDefPtr source,
                        const char *val)
10498 10499
{
    if (STREQ(val, "null")) {
10500
        source->type = VIR_DOMAIN_CHR_TYPE_NULL;
10501
    } else if (STREQ(val, "vc")) {
10502
        source->type = VIR_DOMAIN_CHR_TYPE_VC;
10503
    } else if (STREQ(val, "pty")) {
10504
        source->type = VIR_DOMAIN_CHR_TYPE_PTY;
10505
    } else if (STRPREFIX(val, "file:")) {
10506
        source->type = VIR_DOMAIN_CHR_TYPE_FILE;
10507 10508
        if (VIR_STRDUP(source->data.file.path, val + strlen("file:")) < 0)
            goto error;
10509
    } else if (STRPREFIX(val, "pipe:")) {
10510
        source->type = VIR_DOMAIN_CHR_TYPE_PIPE;
10511 10512
        if (VIR_STRDUP(source->data.file.path, val + strlen("pipe:")) < 0)
            goto error;
10513
    } else if (STREQ(val, "stdio")) {
10514
        source->type = VIR_DOMAIN_CHR_TYPE_STDIO;
10515 10516
    } else if (STRPREFIX(val, "udp:")) {
        const char *svc1, *host2, *svc2;
10517
        source->type = VIR_DOMAIN_CHR_TYPE_UDP;
10518 10519 10520 10521 10522
        val += strlen("udp:");
        svc1 = strchr(val, ':');
        host2 = svc1 ? strchr(svc1, '@') : NULL;
        svc2 = host2 ? strchr(host2, ':') : NULL;

10523 10524 10525
        if (svc1 && svc1 != val &&
            VIR_STRNDUP(source->data.udp.connectHost, val, svc1 - val) < 0)
            goto error;
10526 10527 10528

        if (svc1) {
            svc1++;
10529 10530 10531
            if (VIR_STRNDUP(source->data.udp.connectService, svc1,
                            host2 ? host2 - svc1 : strlen(svc1)) < 0)
                goto error;
10532 10533 10534 10535
        }

        if (host2) {
            host2++;
10536 10537
            if (svc2 && svc2 != host2 &&
                VIR_STRNDUP(source->data.udp.bindHost, host2, svc2 - host2) < 0)
10538
                goto error;
10539
        }
10540

10541 10542
        if (svc2) {
            svc2++;
10543
            if (STRNEQ(svc2, "0")) {
10544 10545
                if (VIR_STRDUP(source->data.udp.bindService, svc2) < 0)
                    goto error;
10546
            }
10547 10548 10549 10550
        }
    } else if (STRPREFIX(val, "tcp:") ||
               STRPREFIX(val, "telnet:")) {
        const char *opt, *svc;
10551
        source->type = VIR_DOMAIN_CHR_TYPE_TCP;
10552 10553 10554 10555
        if (STRPREFIX(val, "tcp:")) {
            val += strlen("tcp:");
        } else {
            val += strlen("telnet:");
10556
            source->data.tcp.protocol = VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET;
10557 10558 10559
        }
        svc = strchr(val, ':');
        if (!svc) {
10560 10561
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot find port number in character device %s"), val);
10562 10563 10564 10565
            goto error;
        }
        opt = strchr(svc, ',');
        if (opt && strstr(opt, "server"))
10566
            source->data.tcp.listen = true;
10567

10568 10569
        if (VIR_STRNDUP(source->data.tcp.host, val, svc - val) < 0)
            goto error;
10570
        svc++;
10571
        if (VIR_STRNDUP(source->data.tcp.service, svc, opt ? opt - svc : -1) < 0)
10572
            goto error;
10573 10574 10575 10576
    } else if (STRPREFIX(val, "unix:")) {
        const char *opt;
        val += strlen("unix:");
        opt = strchr(val, ',');
10577
        source->type = VIR_DOMAIN_CHR_TYPE_UNIX;
10578
        if (VIR_STRNDUP(source->data.nix.path, val, opt ? opt - val : -1) < 0)
10579
            goto error;
10580 10581

    } else if (STRPREFIX(val, "/dev")) {
10582
        source->type = VIR_DOMAIN_CHR_TYPE_DEV;
10583 10584
        if (VIR_STRDUP(source->data.file.path, val) < 0)
            goto error;
10585
    } else {
10586 10587
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unknown character device syntax %s"), val);
10588 10589 10590
        goto error;
    }

10591
    return 0;
10592 10593

error:
10594
    return -1;
10595 10596 10597 10598 10599 10600 10601 10602 10603
}


static virCPUDefPtr
qemuInitGuestCPU(virDomainDefPtr dom)
{
    if (!dom->cpu) {
        virCPUDefPtr cpu;

10604
        if (VIR_ALLOC(cpu) < 0)
10605 10606 10607 10608 10609 10610 10611 10612 10613 10614 10615 10616 10617 10618 10619
            return NULL;

        cpu->type = VIR_CPU_TYPE_GUEST;
        cpu->match = VIR_CPU_MATCH_EXACT;
        dom->cpu = cpu;
    }

    return dom->cpu;
}


static int
qemuParseCommandLineCPU(virDomainDefPtr dom,
                        const char *val)
{
10620
    virCPUDefPtr cpu = NULL;
10621
    char **tokens;
10622
    char **hv_tokens = NULL;
10623
    char *model = NULL;
10624
    int ret = -1;
10625
    size_t i;
10626

10627 10628
    if (!(tokens = virStringSplit(val, ",", 0)))
        goto cleanup;
10629

10630 10631
    if (tokens[0] == NULL)
        goto syntax;
10632

10633 10634 10635 10636 10637 10638 10639
    for (i = 0; tokens[i] != NULL; i++) {
        if (*tokens[i] == '\0')
            goto syntax;

        if (i == 0) {
            if (VIR_STRDUP(model, tokens[i]) < 0)
                goto cleanup;
10640 10641 10642

            if (!STREQ(model, "qemu32") && !STREQ(model, "qemu64")) {
                if (!(cpu = qemuInitGuestCPU(dom)))
10643
                    goto cleanup;
10644 10645 10646 10647

                cpu->model = model;
                model = NULL;
            }
10648 10649
        } else if (*tokens[i] == '+' || *tokens[i] == '-') {
            const char *feature = tokens[i] + 1; /* '+' or '-' */
10650 10651
            int policy;

10652
            if (*tokens[i] == '+')
10653 10654 10655 10656
                policy = VIR_CPU_FEATURE_REQUIRE;
            else
                policy = VIR_CPU_FEATURE_DISABLE;

10657
            if (*feature == '\0')
10658 10659
                goto syntax;

10660 10661 10662 10663 10664 10665 10666 10667
            if (dom->os.arch != VIR_ARCH_X86_64 &&
                dom->os.arch != VIR_ARCH_I686) {
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("%s platform doesn't support CPU features'"),
                               virArchToString(dom->os.arch));
                goto cleanup;
             }

10668 10669
            if (STREQ(feature, "kvmclock")) {
                bool present = (policy == VIR_CPU_FEATURE_REQUIRE);
10670
                size_t j;
10671

10672 10673
                for (j = 0; j < dom->clock.ntimers; j++) {
                    if (dom->clock.timers[j]->name == VIR_DOMAIN_TIMER_NAME_KVMCLOCK)
10674 10675 10676
                        break;
                }

10677 10678 10679
                if (j == dom->clock.ntimers) {
                    if (VIR_REALLOC_N(dom->clock.timers, j + 1) < 0 ||
                        VIR_ALLOC(dom->clock.timers[j]) < 0)
10680
                        goto cleanup;
10681 10682 10683 10684
                    dom->clock.timers[j]->name = VIR_DOMAIN_TIMER_NAME_KVMCLOCK;
                    dom->clock.timers[j]->present = present;
                    dom->clock.timers[j]->tickpolicy = -1;
                    dom->clock.timers[j]->track = -1;
10685
                    dom->clock.ntimers++;
10686 10687
                } else if (dom->clock.timers[j]->present != -1 &&
                    dom->clock.timers[j]->present != present) {
10688 10689
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("conflicting occurrences of kvmclock feature"));
10690
                    goto cleanup;
10691
                }
10692 10693
            } else if (STREQ(feature, "kvm_pv_eoi")) {
                if (policy == VIR_CPU_FEATURE_REQUIRE)
10694
                    dom->apic_eoi = VIR_DOMAIN_FEATURE_STATE_ON;
10695
                else
10696
                    dom->apic_eoi = VIR_DOMAIN_FEATURE_STATE_OFF;
10697 10698 10699
            } else {
                if (!cpu) {
                    if (!(cpu = qemuInitGuestCPU(dom)))
10700
                        goto cleanup;
10701

10702 10703 10704 10705
                    cpu->model = model;
                    model = NULL;
                }

10706 10707
                if (virCPUDefAddFeature(cpu, feature, policy) < 0)
                    goto cleanup;
10708
            }
10709
        } else if (STRPREFIX(tokens[i], "hv_")) {
10710 10711
            const char *token = tokens[i] + 3; /* "hv_" */
            const char *feature, *value;
10712 10713
            int f;

10714 10715 10716 10717 10718 10719 10720 10721 10722
            if (*token == '\0')
                goto syntax;

            if (!(hv_tokens = virStringSplit(token, "=", 2)))
                goto cleanup;

            feature = hv_tokens[0];
            value = hv_tokens[1];

10723
            if (*feature == '\0')
10724 10725 10726 10727 10728 10729 10730 10731
                goto syntax;

            dom->features |= (1 << VIR_DOMAIN_FEATURE_HYPERV);

            if ((f = virDomainHypervTypeFromString(feature)) < 0) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("unsupported HyperV Enlightenment feature "
                                 "'%s'"), feature);
10732
                goto cleanup;
10733 10734 10735 10736
            }

            switch ((enum virDomainHyperv) f) {
            case VIR_DOMAIN_HYPERV_RELAXED:
10737 10738 10739 10740 10741 10742 10743
            case VIR_DOMAIN_HYPERV_VAPIC:
                if (value) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                                   _("HyperV feature '%s' should not "
                                     "have a value"), feature);
                    goto cleanup;
                }
10744 10745 10746
                dom->hyperv_features[f] = VIR_DOMAIN_FEATURE_STATE_ON;
                break;

10747
            case VIR_DOMAIN_HYPERV_SPINLOCKS:
10748 10749 10750 10751 10752 10753 10754 10755 10756 10757 10758 10759 10760 10761 10762
                dom->hyperv_features[f] = VIR_DOMAIN_FEATURE_STATE_ON;
                if (!value) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("missing HyperV spinlock retry count"));
                    goto cleanup;
                }

                if (virStrToLong_ui(value, NULL, 0, &dom->hyperv_spinlocks) < 0) {
                    virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                                   _("cannot parse HyperV spinlock retry count"));
                    goto cleanup;
                }

                if (dom->hyperv_spinlocks < 0xFFF)
                    dom->hyperv_spinlocks = 0xFFF;
10763 10764
                break;

10765 10766 10767
            case VIR_DOMAIN_HYPERV_LAST:
                break;
            }
10768 10769
            virStringFreeList(hv_tokens);
            hv_tokens = NULL;
10770
        }
10771
    }
10772

10773
    if (dom->os.arch == VIR_ARCH_X86_64) {
10774
        bool is_32bit = false;
10775
        if (cpu) {
10776
            virCPUDataPtr cpuData = NULL;
10777

10778 10779 10780
            if (cpuEncode(VIR_ARCH_X86_64, cpu, NULL, &cpuData,
                          NULL, NULL, NULL, NULL) < 0)
                goto cleanup;
10781

J
Jiri Denemark 已提交
10782 10783
            is_32bit = (cpuHasFeature(cpuData, "lm") != 1);
            cpuDataFree(cpuData);
10784 10785 10786
        } else if (model) {
            is_32bit = STREQ(model, "qemu32");
        }
10787

10788
        if (is_32bit)
10789
            dom->os.arch = VIR_ARCH_I686;
10790
    }
10791 10792 10793 10794

    ret = 0;

cleanup:
10795
    VIR_FREE(model);
10796
    virStringFreeList(tokens);
10797
    virStringFreeList(hv_tokens);
10798
    return ret;
10799 10800

syntax:
10801 10802
    virReportError(VIR_ERR_INTERNAL_ERROR,
                   _("unknown CPU syntax '%s'"), val);
10803
    goto cleanup;
10804 10805 10806 10807 10808 10809 10810 10811 10812 10813 10814
}


static int
qemuParseCommandLineSmp(virDomainDefPtr dom,
                        const char *val)
{
    unsigned int sockets = 0;
    unsigned int cores = 0;
    unsigned int threads = 0;
    unsigned int maxcpus = 0;
10815
    size_t i;
10816 10817 10818 10819 10820 10821 10822 10823 10824 10825 10826 10827 10828 10829 10830 10831 10832 10833 10834 10835 10836 10837 10838 10839 10840 10841 10842 10843 10844 10845 10846 10847 10848 10849 10850 10851 10852 10853 10854 10855 10856 10857 10858 10859 10860 10861 10862 10863 10864 10865 10866 10867 10868 10869 10870 10871 10872 10873 10874
    int nkws;
    char **kws;
    char **vals;
    int n;
    char *end;
    int ret;

    nkws = qemuParseKeywords(val, &kws, &vals, 1);
    if (nkws < 0)
        return -1;

    for (i = 0; i < nkws; i++) {
        if (vals[i] == NULL) {
            if (i > 0 ||
                virStrToLong_i(kws[i], &end, 10, &n) < 0 || *end != '\0')
                goto syntax;
            dom->vcpus = n;
        } else {
            if (virStrToLong_i(vals[i], &end, 10, &n) < 0 || *end != '\0')
                goto syntax;
            if (STREQ(kws[i], "sockets"))
                sockets = n;
            else if (STREQ(kws[i], "cores"))
                cores = n;
            else if (STREQ(kws[i], "threads"))
                threads = n;
            else if (STREQ(kws[i], "maxcpus"))
                maxcpus = n;
            else
                goto syntax;
        }
    }

    dom->maxvcpus = maxcpus ? maxcpus : dom->vcpus;

    if (sockets && cores && threads) {
        virCPUDefPtr cpu;

        if (!(cpu = qemuInitGuestCPU(dom)))
            goto error;
        cpu->sockets = sockets;
        cpu->cores = cores;
        cpu->threads = threads;
    } else if (sockets || cores || threads)
        goto syntax;

    ret = 0;

cleanup:
    for (i = 0; i < nkws; i++) {
        VIR_FREE(kws[i]);
        VIR_FREE(vals[i]);
    }
    VIR_FREE(kws);
    VIR_FREE(vals);

    return ret;

syntax:
10875 10876
    virReportError(VIR_ERR_INTERNAL_ERROR,
                   _("cannot parse CPU topology '%s'"), val);
10877 10878 10879 10880 10881 10882
error:
    ret = -1;
    goto cleanup;
}


10883 10884 10885 10886
static void
qemuParseCommandLineBootDevs(virDomainDefPtr def, const char *str) {
    int n, b = 0;

10887
    for (n = 0; str[n] && b < VIR_DOMAIN_BOOT_LAST; n++) {
10888 10889 10890 10891 10892 10893 10894 10895 10896 10897 10898 10899 10900 10901 10902
        if (str[n] == 'a')
            def->os.bootDevs[b++] = VIR_DOMAIN_BOOT_FLOPPY;
        else if (str[n] == 'c')
            def->os.bootDevs[b++] = VIR_DOMAIN_BOOT_DISK;
        else if (str[n] == 'd')
            def->os.bootDevs[b++] = VIR_DOMAIN_BOOT_CDROM;
        else if (str[n] == 'n')
            def->os.bootDevs[b++] = VIR_DOMAIN_BOOT_NET;
        else if (str[n] == ',')
            break;
    }
    def->os.nBootDevs = b;
}


10903 10904 10905 10906 10907
/*
 * Analyse the env and argv settings and reconstruct a
 * virDomainDefPtr representing these settings as closely
 * as is practical. This is not an exact science....
 */
E
Eric Blake 已提交
10908 10909 10910 10911 10912 10913 10914 10915
static virDomainDefPtr
qemuParseCommandLine(virCapsPtr qemuCaps,
                     virDomainXMLOptionPtr xmlopt,
                     char **progenv,
                     char **progargv,
                     char **pidfile,
                     virDomainChrSourceDefPtr *monConfig,
                     bool *monJSON)
10916 10917
{
    virDomainDefPtr def;
10918
    size_t i;
10919
    bool nographics = false;
10920
    bool fullscreen = false;
10921 10922 10923 10924 10925
    char *path;
    int nnics = 0;
    const char **nics = NULL;
    int video = VIR_DOMAIN_VIDEO_TYPE_CIRRUS;
    int nvirtiodisk = 0;
W
Wen Congyang 已提交
10926
    qemuDomainCmdlineDefPtr cmd = NULL;
E
Eric Blake 已提交
10927
    virDomainDiskDefPtr disk = NULL;
10928
    const char *ceph_args = qemuFindEnv(progenv, "CEPH_ARGS");
10929

10930 10931 10932 10933 10934 10935 10936
    if (pidfile)
        *pidfile = NULL;
    if (monConfig)
        *monConfig = NULL;
    if (monJSON)
        *monJSON = false;

10937
    if (!progargv[0]) {
10938 10939
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("no emulator path found"));
10940 10941 10942 10943
        return NULL;
    }

    if (VIR_ALLOC(def) < 0)
10944
        goto error;
10945 10946 10947

    /* allocate the cmdlinedef up-front; if it's unused, we'll free it later */
    if (VIR_ALLOC(cmd) < 0)
10948
        goto error;
10949

E
Eric Blake 已提交
10950
    if (virUUIDGenerate(def->uuid) < 0) {
10951 10952
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to generate uuid"));
E
Eric Blake 已提交
10953 10954
        goto error;
    }
10955 10956 10957 10958 10959 10960

    def->id = -1;
    def->mem.cur_balloon = def->mem.max_balloon = 64 * 1024;
    def->maxvcpus = 1;
    def->vcpus = 1;
    def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_UTC;
10961

10962 10963 10964 10965
    def->onReboot = VIR_DOMAIN_LIFECYCLE_RESTART;
    def->onCrash = VIR_DOMAIN_LIFECYCLE_DESTROY;
    def->onPoweroff = VIR_DOMAIN_LIFECYCLE_DESTROY;
    def->virtType = VIR_DOMAIN_VIRT_QEMU;
10966 10967
    if (VIR_STRDUP(def->emulator, progargv[0]) < 0)
        goto error;
10968

10969 10970
    if (!(path = last_component(def->emulator)))
        goto error;
10971

10972
    if (strstr(path, "xenner")) {
10973
        def->virtType = VIR_DOMAIN_VIRT_KVM;
10974 10975
        if (VIR_STRDUP(def->os.type, "xen") < 0)
            goto error;
10976
    } else {
10977 10978
        if (VIR_STRDUP(def->os.type, "hvm") < 0)
            goto error;
10979 10980 10981 10982
        if (strstr(path, "kvm")) {
            def->virtType = VIR_DOMAIN_VIRT_KVM;
            def->features |= (1 << VIR_DOMAIN_FEATURE_PAE);
        }
10983 10984
    }

10985
    if (def->virtType == VIR_DOMAIN_VIRT_KVM)
10986
        def->os.arch = qemuCaps->host.arch;
10987
    else if (STRPREFIX(path, "qemu-system-"))
10988
        def->os.arch = virArchFromString(path + strlen("qemu-system-"));
10989
    else
10990
        def->os.arch = VIR_ARCH_I686;
10991

10992 10993
    if ((def->os.arch == VIR_ARCH_I686) ||
        (def->os.arch == VIR_ARCH_X86_64))
10994
        def->features |= (1 << VIR_DOMAIN_FEATURE_ACPI)
10995
        /*| (1 << VIR_DOMAIN_FEATURE_APIC)*/;
10996

10997 10998 10999
#define WANT_VALUE()                                                   \
    const char *val = progargv[++i];                                   \
    if (!val) {                                                        \
11000 11001
        virReportError(VIR_ERR_INTERNAL_ERROR,                        \
                       _("missing value for %s argument"), arg);       \
11002 11003 11004 11005 11006
        goto error;                                                    \
    }

    /* One initial loop to get list of NICs, so we
     * can correlate them later */
11007
    for (i = 1; progargv[i]; i++) {
11008 11009 11010 11011 11012 11013 11014 11015 11016 11017
        const char *arg = progargv[i];
        /* Make sure we have a single - for all options to
           simplify next logic */
        if (STRPREFIX(arg, "--"))
            arg++;

        if (STREQ(arg, "-net")) {
            WANT_VALUE();
            if (STRPREFIX(val, "nic")) {
                if (VIR_REALLOC_N(nics, nnics+1) < 0)
11018
                    goto error;
11019 11020 11021 11022 11023 11024
                nics[nnics++] = val;
            }
        }
    }

    /* Now the real processing loop */
11025
    for (i = 1; progargv[i]; i++) {
11026 11027 11028 11029 11030 11031 11032 11033 11034 11035 11036
        const char *arg = progargv[i];
        /* Make sure we have a single - for all options to
           simplify next logic */
        if (STRPREFIX(arg, "--"))
            arg++;

        if (STREQ(arg, "-vnc")) {
            virDomainGraphicsDefPtr vnc;
            char *tmp;
            WANT_VALUE();
            if (VIR_ALLOC(vnc) < 0)
11037
                goto error;
11038 11039
            vnc->type = VIR_DOMAIN_GRAPHICS_TYPE_VNC;

11040
            if (STRPREFIX(val, "unix:")) {
11041
                /* -vnc unix:/some/big/path */
11042
                if (VIR_STRDUP(vnc->data.vnc.socket, val + 5) < 0) {
11043
                    virDomainGraphicsDefFree(vnc);
11044
                    goto error;
11045 11046
                }
            } else {
11047 11048 11049 11050 11051 11052
                /*
                 * -vnc 127.0.0.1:4
                 * -vnc [2001:1:2:3:4:5:1234:1234]:4
                 * -vnc some.host.name:4
                 */
                char *opts;
11053
                char *port;
11054 11055 11056 11057 11058
                const char *sep = ":";
                if (val[0] == '[')
                    sep = "]:";
                tmp = strstr(val, sep);
                if (!tmp) {
11059
                    virDomainGraphicsDefFree(vnc);
11060 11061
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("missing VNC port number in '%s'"), val);
11062 11063
                    goto error;
                }
11064 11065
                port = tmp + strlen(sep);
                if (virStrToLong_i(port, &opts, 10,
11066
                                   &vnc->data.vnc.port) < 0) {
11067
                    virDomainGraphicsDefFree(vnc);
11068
                    virReportError(VIR_ERR_INTERNAL_ERROR,
11069
                                   _("cannot parse VNC port '%s'"), port);
11070 11071 11072
                    goto error;
                }
                if (val[0] == '[')
11073 11074
                    virDomainGraphicsListenSetAddress(vnc, 0,
                                                      val+1, tmp-(val+1), true);
11075
                else
11076 11077 11078 11079
                    virDomainGraphicsListenSetAddress(vnc, 0,
                                                      val, tmp-val, true);
                if (!virDomainGraphicsListenGetAddress(vnc, 0)) {
                    virDomainGraphicsDefFree(vnc);
11080
                    goto error;
11081
                }
11082 11083

                if (*opts == ',') {
11084 11085 11086
                    char *orig_opts;

                    if (VIR_STRDUP(orig_opts, opts + 1) < 0) {
11087
                        virDomainGraphicsDefFree(vnc);
11088
                        goto error;
11089 11090 11091 11092 11093 11094 11095 11096 11097 11098 11099 11100 11101 11102 11103 11104 11105 11106 11107 11108 11109 11110 11111 11112 11113 11114 11115 11116 11117 11118 11119 11120
                    }
                    opts = orig_opts;

                    while (opts && *opts) {
                        char *nextopt = strchr(opts, ',');
                        if (nextopt)
                            *(nextopt++) = '\0';

                        if (STRPREFIX(opts, "websocket")) {
                            char *websocket = opts + strlen("websocket");
                            if (*(websocket++) == '=' &&
                                *websocket) {
                                /* If the websocket continues with
                                 * '=<something>', we'll parse it */
                                if (virStrToLong_i(websocket,
                                                   NULL, 0,
                                                   &vnc->data.vnc.websocket) < 0) {
                                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                                   _("cannot parse VNC "
                                                     "WebSocket port '%s'"),
                                                   websocket);
                                    virDomainGraphicsDefFree(vnc);
                                    VIR_FREE(orig_opts);
                                    goto error;
                                }
                            } else {
                                /* Otherwise, we'll compute the port the same
                                 * way QEMU does, by adding a 5700 to the
                                 * display value. */
                                vnc->data.vnc.websocket =
                                    vnc->data.vnc.port + 5700;
                            }
11121 11122 11123 11124 11125 11126 11127 11128 11129 11130 11131 11132 11133 11134 11135 11136 11137 11138 11139 11140 11141 11142 11143
                        } else if (STRPREFIX(opts, "share=")) {
                            char *sharePolicy = opts + strlen("share=");
                            if (sharePolicy && *sharePolicy) {
                                int policy =
                                    virDomainGraphicsVNCSharePolicyTypeFromString(sharePolicy);

                                if (policy < 0) {
                                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                                   _("unknown vnc display sharing policy '%s'"),
                                                     sharePolicy);
                                    virDomainGraphicsDefFree(vnc);
                                    VIR_FREE(orig_opts);
                                    goto error;
                                } else {
                                    vnc->data.vnc.sharePolicy = policy;
                                }
                            } else {
                                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                               _("missing vnc sharing policy"));
                                virDomainGraphicsDefFree(vnc);
                                VIR_FREE(orig_opts);
                                goto error;
                            }
11144 11145 11146 11147 11148 11149
                        }

                        opts = nextopt;
                    }
                    VIR_FREE(orig_opts);
                }
11150
                vnc->data.vnc.port += 5900;
11151
                vnc->data.vnc.autoport = false;
11152 11153 11154 11155
            }

            if (VIR_REALLOC_N(def->graphics, def->ngraphics+1) < 0) {
                virDomainGraphicsDefFree(vnc);
11156
                goto error;
11157 11158 11159 11160 11161 11162
            }
            def->graphics[def->ngraphics++] = vnc;
        } else if (STREQ(arg, "-m")) {
            int mem;
            WANT_VALUE();
            if (virStrToLong_i(val, NULL, 10, &mem) < 0) {
11163 11164
                virReportError(VIR_ERR_INTERNAL_ERROR, \
                               _("cannot parse memory level '%s'"), val);
11165 11166 11167 11168 11169 11170 11171 11172 11173 11174
                goto error;
            }
            def->mem.cur_balloon = def->mem.max_balloon = mem * 1024;
        } else if (STREQ(arg, "-smp")) {
            WANT_VALUE();
            if (qemuParseCommandLineSmp(def, val) < 0)
                goto error;
        } else if (STREQ(arg, "-uuid")) {
            WANT_VALUE();
            if (virUUIDParse(val, def->uuid) < 0) {
11175 11176
                virReportError(VIR_ERR_INTERNAL_ERROR, \
                               _("cannot parse UUID '%s'"), val);
11177 11178 11179 11180 11181 11182 11183 11184
                goto error;
            }
        } else if (STRPREFIX(arg, "-hd") ||
                   STRPREFIX(arg, "-sd") ||
                   STRPREFIX(arg, "-fd") ||
                   STREQ(arg, "-cdrom")) {
            WANT_VALUE();
            if (VIR_ALLOC(disk) < 0)
11185
                goto error;
11186 11187 11188 11189 11190 11191 11192 11193 11194 11195

            if (STRPREFIX(val, "/dev/"))
                disk->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
            else if (STRPREFIX(val, "nbd:")) {
                disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
            } else if (STRPREFIX(val, "rbd:")) {
                disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
                val += strlen("rbd:");
11196 11197 11198
            } else if (STRPREFIX(val, "gluster")) {
                disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
11199 11200 11201 11202 11203 11204 11205 11206
            } else if (STRPREFIX(val, "sheepdog:")) {
                disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
                disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
                val += strlen("sheepdog:");
            } else
                disk->type = VIR_DOMAIN_DISK_TYPE_FILE;
            if (STREQ(arg, "-cdrom")) {
                disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
11207 11208
                if (VIR_STRDUP(disk->dst, "hdc") < 0)
                    goto error;
11209
                disk->readonly = true;
11210 11211 11212 11213 11214 11215 11216 11217 11218 11219 11220
            } else {
                if (STRPREFIX(arg, "-fd")) {
                    disk->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
                    disk->bus = VIR_DOMAIN_DISK_BUS_FDC;
                } else {
                    disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
                    if (STRPREFIX(arg, "-hd"))
                        disk->bus = VIR_DOMAIN_DISK_BUS_IDE;
                    else
                        disk->bus = VIR_DOMAIN_DISK_BUS_SCSI;
                }
11221 11222
                if (VIR_STRDUP(disk->dst, arg + 1) < 0)
                    goto error;
11223
            }
11224 11225
            if (VIR_STRDUP(disk->src, val) < 0)
                goto error;
11226 11227

            if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
11228
                char *port;
11229 11230 11231

                switch (disk->protocol) {
                case VIR_DOMAIN_DISK_PROTOCOL_NBD:
11232
                    if (qemuParseNBDString(disk) < 0)
11233 11234 11235
                        goto error;
                    break;
                case VIR_DOMAIN_DISK_PROTOCOL_RBD:
11236 11237 11238
                    /* old-style CEPH_ARGS env variable is parsed later */
                    if (!ceph_args && qemuParseRBDString(disk) < 0)
                        goto error;
11239 11240 11241 11242 11243 11244 11245 11246 11247 11248
                    break;
                case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
                    /* disk->src must be [vdiname] or [host]:[port]:[vdiname] */
                    port = strchr(disk->src, ':');
                    if (port) {
                        char *vdi;

                        *port++ = '\0';
                        vdi = strchr(port, ':');
                        if (!vdi) {
11249 11250
                            virReportError(VIR_ERR_INTERNAL_ERROR,
                                           _("cannot parse sheepdog filename '%s'"), val);
11251 11252 11253
                            goto error;
                        }
                        *vdi++ = '\0';
M
Michael Santos 已提交
11254
                        if (VIR_ALLOC(disk->hosts) < 0)
11255
                            goto error;
11256 11257
                        disk->nhosts = 1;
                        disk->hosts->name = disk->src;
11258 11259 11260 11261
                        if (VIR_STRDUP(disk->hosts->port, port) < 0)
                            goto error;
                        if (VIR_STRDUP(disk->src, vdi) < 0)
                            goto error;
11262 11263
                    }
                    break;
11264 11265 11266 11267
                case VIR_DOMAIN_DISK_PROTOCOL_GLUSTER:
                    if (qemuParseGlusterString(disk) < 0)
                        goto error;

P
Paolo Bonzini 已提交
11268 11269 11270 11271 11272
                    break;
                case VIR_DOMAIN_DISK_PROTOCOL_ISCSI:
                    if (qemuParseISCSIString(disk) < 0)
                        goto error;

11273
                    break;
11274 11275 11276
                }
            }

11277
            if (virDomainDiskDefAssignAddress(xmlopt, disk) < 0) {
11278 11279 11280
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Cannot assign address for device name '%s'"),
                               disk->dst);
11281
                goto error;
11282
            }
11283

E
Eric Blake 已提交
11284
            if (VIR_REALLOC_N(def->disks, def->ndisks+1) < 0)
11285
                goto error;
11286
            def->disks[def->ndisks++] = disk;
E
Eric Blake 已提交
11287
            disk = NULL;
11288 11289 11290 11291 11292 11293
        } else if (STREQ(arg, "-no-acpi")) {
            def->features &= ~(1 << VIR_DOMAIN_FEATURE_ACPI);
        } else if (STREQ(arg, "-no-reboot")) {
            def->onReboot = VIR_DOMAIN_LIFECYCLE_DESTROY;
        } else if (STREQ(arg, "-no-kvm")) {
            def->virtType = VIR_DOMAIN_VIRT_QEMU;
P
Paolo Bonzini 已提交
11294 11295
        } else if (STREQ(arg, "-enable-kvm")) {
            def->virtType = VIR_DOMAIN_VIRT_KVM;
11296
        } else if (STREQ(arg, "-nographic")) {
11297
            nographics = true;
11298
        } else if (STREQ(arg, "-full-screen")) {
11299
            fullscreen = true;
11300 11301 11302 11303
        } else if (STREQ(arg, "-localtime")) {
            def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME;
        } else if (STREQ(arg, "-kernel")) {
            WANT_VALUE();
11304 11305
            if (VIR_STRDUP(def->os.kernel, val) < 0)
                goto error;
11306 11307
        } else if (STREQ(arg, "-bios")) {
            WANT_VALUE();
11308 11309
            if (VIR_STRDUP(def->os.loader, val) < 0)
                goto error;
11310 11311
        } else if (STREQ(arg, "-initrd")) {
            WANT_VALUE();
11312 11313
            if (VIR_STRDUP(def->os.initrd, val) < 0)
                goto error;
11314 11315
        } else if (STREQ(arg, "-append")) {
            WANT_VALUE();
11316 11317
            if (VIR_STRDUP(def->os.cmdline, val) < 0)
                goto error;
O
Olivia Yin 已提交
11318 11319
        } else if (STREQ(arg, "-dtb")) {
            WANT_VALUE();
11320 11321
            if (VIR_STRDUP(def->os.dtb, val) < 0)
                goto error;
11322
        } else if (STREQ(arg, "-boot")) {
11323
            const char *token = NULL;
11324 11325
            WANT_VALUE();

11326 11327 11328 11329 11330 11331 11332 11333 11334 11335
            if (!strchr(val, ','))
                qemuParseCommandLineBootDevs(def, val);
            else {
                token = val;
                while (token && *token) {
                    if (STRPREFIX(token, "order=")) {
                        token += strlen("order=");
                        qemuParseCommandLineBootDevs(def, token);
                    } else if (STRPREFIX(token, "menu=on")) {
                        def->os.bootmenu = 1;
11336 11337 11338 11339 11340 11341 11342 11343 11344 11345 11346 11347 11348 11349 11350 11351
                    } else if (STRPREFIX(token, "reboot-timeout=")) {
                        int num;
                        char *endptr;
                        if (virStrToLong_i(token + strlen("reboot-timeout="),
                                           &endptr, 10, &num) < 0 ||
                            (*endptr != '\0' && endptr != strchr(token, ','))) {
                            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                           _("cannot parse reboot-timeout value"));
                            goto error;
                        }
                        if (num > 65535)
                            num = 65535;
                        else if (num < -1)
                            num = -1;
                        def->os.bios.rt_delay = num;
                        def->os.bios.rt_set = true;
11352 11353 11354 11355 11356 11357 11358 11359
                    }
                    token = strchr(token, ',');
                    /* This incrementation has to be done here in order to make it
                     * possible to pass the token pointer properly into the loop */
                    if (token)
                        token++;
                }
            }
11360 11361 11362 11363 11364
        } else if (STREQ(arg, "-name")) {
            char *process;
            WANT_VALUE();
            process = strstr(val, ",process=");
            if (process == NULL) {
11365 11366
                if (VIR_STRDUP(def->name, val) < 0)
                    goto error;
11367
            } else {
11368 11369
                if (VIR_STRNDUP(def->name, val, process - val) < 0)
                    goto error;
11370
            }
11371 11372
            if (STREQ(def->name, ""))
                VIR_FREE(def->name);
11373 11374
        } else if (STREQ(arg, "-M") ||
                   STREQ(arg, "-machine")) {
11375 11376 11377 11378 11379 11380 11381
            char **list;
            char *param;
            size_t j = 0;

            /* -machine [type=]name[,prop[=value][,...]]
             * Set os.machine only if first parameter lacks '=' or
             * contains explicit type='...' */
11382
            WANT_VALUE();
11383 11384 11385 11386 11387 11388 11389 11390
            list = virStringSplit(val, ",", 0);
            param = list[0];

            if (STRPREFIX(param, "type="))
                param += strlen("type=");
            if (!strchr(param, '=')) {
                if (VIR_STRDUP(def->os.machine, param) < 0) {
                    virStringFreeList(list);
11391
                    goto error;
11392 11393 11394 11395 11396 11397 11398 11399 11400 11401 11402 11403 11404 11405 11406 11407
                }
                j++;
            }

            /* handle all remaining "-machine" parameters */
            while ((param = list[j++])) {
                if (STRPREFIX(param, "dump-guest-core=")) {
                    param += strlen("dump-guest-core=");
                    def->mem.dump_core = virDomainMemDumpTypeFromString(param);
                    if (def->mem.dump_core <= 0)
                        def->mem.dump_core = VIR_DOMAIN_MEM_DUMP_DEFAULT;
                } else if (STRPREFIX(param, "mem-merge=off")) {
                    def->mem.nosharepages = true;
                } else if (STRPREFIX(param, "accel=kvm")) {
                    def->virtType = VIR_DOMAIN_VIRT_KVM;
                    def->features |= (1 << VIR_DOMAIN_FEATURE_PAE);
11408 11409
                }
            }
11410
            virStringFreeList(list);
11411 11412 11413 11414
        } else if (STREQ(arg, "-serial")) {
            WANT_VALUE();
            if (STRNEQ(val, "none")) {
                virDomainChrDefPtr chr;
11415 11416 11417 11418

                if (!(chr = virDomainChrDefNew()))
                    goto error;

E
Eric Blake 已提交
11419 11420
                if (qemuParseCommandLineChr(&chr->source, val) < 0) {
                    virDomainChrDefFree(chr);
11421
                    goto error;
E
Eric Blake 已提交
11422
                }
11423 11424
                if (VIR_REALLOC_N(def->serials, def->nserials+1) < 0) {
                    virDomainChrDefFree(chr);
11425
                    goto error;
11426 11427 11428 11429 11430 11431 11432 11433 11434
                }
                chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
                chr->target.port = def->nserials;
                def->serials[def->nserials++] = chr;
            }
        } else if (STREQ(arg, "-parallel")) {
            WANT_VALUE();
            if (STRNEQ(val, "none")) {
                virDomainChrDefPtr chr;
11435 11436 11437 11438

                if (!(chr = virDomainChrDefNew()))
                    goto error;

E
Eric Blake 已提交
11439 11440
                if (qemuParseCommandLineChr(&chr->source, val) < 0) {
                    virDomainChrDefFree(chr);
11441
                    goto error;
E
Eric Blake 已提交
11442
                }
11443 11444
                if (VIR_REALLOC_N(def->parallels, def->nparallels+1) < 0) {
                    virDomainChrDefFree(chr);
11445
                    goto error;
11446 11447 11448 11449 11450 11451 11452 11453 11454 11455 11456
                }
                chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL;
                chr->target.port = def->nparallels;
                def->parallels[def->nparallels++] = chr;
            }
        } else if (STREQ(arg, "-usbdevice")) {
            WANT_VALUE();
            if (STREQ(val, "tablet") ||
                STREQ(val, "mouse")) {
                virDomainInputDefPtr input;
                if (VIR_ALLOC(input) < 0)
11457
                    goto error;
11458 11459 11460 11461 11462 11463 11464
                input->bus = VIR_DOMAIN_INPUT_BUS_USB;
                if (STREQ(val, "tablet"))
                    input->type = VIR_DOMAIN_INPUT_TYPE_TABLET;
                else
                    input->type = VIR_DOMAIN_INPUT_TYPE_MOUSE;
                if (VIR_REALLOC_N(def->inputs, def->ninputs+1) < 0) {
                    virDomainInputDefFree(input);
11465
                    goto error;
11466 11467 11468 11469
                }
                def->inputs[def->ninputs++] = input;
            } else if (STRPREFIX(val, "disk:")) {
                if (VIR_ALLOC(disk) < 0)
11470
                    goto error;
11471 11472
                if (VIR_STRDUP(disk->src, val + strlen("disk:")) < 0)
                    goto error;
11473 11474 11475 11476 11477 11478
                if (STRPREFIX(disk->src, "/dev/"))
                    disk->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
                else
                    disk->type = VIR_DOMAIN_DISK_TYPE_FILE;
                disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
                disk->bus = VIR_DOMAIN_DISK_BUS_USB;
11479
                disk->removable = VIR_DOMAIN_FEATURE_STATE_DEFAULT;
11480 11481 11482
                if (VIR_STRDUP(disk->dst, "sda") < 0)
                    goto error;
                if (VIR_REALLOC_N(def->disks, def->ndisks+1) < 0)
11483
                    goto error;
11484
                def->disks[def->ndisks++] = disk;
E
Eric Blake 已提交
11485
                disk = NULL;
11486 11487 11488 11489 11490 11491
            } else {
                virDomainHostdevDefPtr hostdev;
                if (!(hostdev = qemuParseCommandLineUSB(val)))
                    goto error;
                if (VIR_REALLOC_N(def->hostdevs, def->nhostdevs+1) < 0) {
                    virDomainHostdevDefFree(hostdev);
11492
                    goto error;
11493 11494 11495 11496 11497 11498 11499
                }
                def->hostdevs[def->nhostdevs++] = hostdev;
            }
        } else if (STREQ(arg, "-net")) {
            WANT_VALUE();
            if (!STRPREFIX(val, "nic") && STRNEQ(val, "none")) {
                virDomainNetDefPtr net;
11500
                if (!(net = qemuParseCommandLineNet(xmlopt, val, nnics, nics)))
11501 11502 11503
                    goto error;
                if (VIR_REALLOC_N(def->nets, def->nnets+1) < 0) {
                    virDomainNetDefFree(net);
11504
                    goto error;
11505 11506 11507 11508 11509
                }
                def->nets[def->nnets++] = net;
            }
        } else if (STREQ(arg, "-drive")) {
            WANT_VALUE();
11510 11511
            if (!(disk = qemuParseCommandLineDisk(xmlopt, val,
                                                  nvirtiodisk,
11512
                                                  ceph_args != NULL)))
11513
                goto error;
E
Eric Blake 已提交
11514
            if (VIR_REALLOC_N(def->disks, def->ndisks+1) < 0)
11515
                goto error;
11516 11517
            if (disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)
                nvirtiodisk++;
E
Eric Blake 已提交
11518 11519 11520

            def->disks[def->ndisks++] = disk;
            disk = NULL;
11521 11522 11523 11524 11525 11526 11527
        } else if (STREQ(arg, "-pcidevice")) {
            virDomainHostdevDefPtr hostdev;
            WANT_VALUE();
            if (!(hostdev = qemuParseCommandLinePCI(val)))
                goto error;
            if (VIR_REALLOC_N(def->hostdevs, def->nhostdevs+1) < 0) {
                virDomainHostdevDefFree(hostdev);
11528
                goto error;
11529 11530 11531 11532 11533 11534 11535 11536 11537 11538 11539 11540 11541 11542 11543 11544 11545
            }
            def->hostdevs[def->nhostdevs++] = hostdev;
        } else if (STREQ(arg, "-soundhw")) {
            const char *start;
            WANT_VALUE();
            start = val;
            while (start) {
                const char *tmp = strchr(start, ',');
                int type = -1;
                if (STRPREFIX(start, "pcspk")) {
                    type = VIR_DOMAIN_SOUND_MODEL_PCSPK;
                } else if (STRPREFIX(start, "sb16")) {
                    type = VIR_DOMAIN_SOUND_MODEL_SB16;
                } else if (STRPREFIX(start, "es1370")) {
                    type = VIR_DOMAIN_SOUND_MODEL_ES1370;
                } else if (STRPREFIX(start, "ac97")) {
                    type = VIR_DOMAIN_SOUND_MODEL_AC97;
11546 11547
                } else if (STRPREFIX(start, "hda")) {
                    type = VIR_DOMAIN_SOUND_MODEL_ICH6;
11548 11549 11550 11551 11552
                }

                if (type != -1) {
                    virDomainSoundDefPtr snd;
                    if (VIR_ALLOC(snd) < 0)
11553
                        goto error;
11554 11555 11556
                    snd->model = type;
                    if (VIR_REALLOC_N(def->sounds, def->nsounds+1) < 0) {
                        VIR_FREE(snd);
11557
                        goto error;
11558 11559 11560 11561 11562 11563 11564 11565
                    }
                    def->sounds[def->nsounds++] = snd;
                }

                start = tmp ? tmp + 1 : NULL;
            }
        } else if (STREQ(arg, "-watchdog")) {
            WANT_VALUE();
11566
            int model = virDomainWatchdogModelTypeFromString(val);
11567 11568 11569 11570

            if (model != -1) {
                virDomainWatchdogDefPtr wd;
                if (VIR_ALLOC(wd) < 0)
11571
                    goto error;
11572 11573 11574 11575 11576 11577
                wd->model = model;
                wd->action = VIR_DOMAIN_WATCHDOG_ACTION_RESET;
                def->watchdog = wd;
            }
        } else if (STREQ(arg, "-watchdog-action") && def->watchdog) {
            WANT_VALUE();
11578
            int action = virDomainWatchdogActionTypeFromString(val);
11579 11580 11581 11582 11583

            if (action != -1)
                def->watchdog->action = action;
        } else if (STREQ(arg, "-bootloader")) {
            WANT_VALUE();
11584 11585
            if (VIR_STRDUP(def->os.bootloader, val) < 0)
                goto error;
11586 11587 11588 11589 11590 11591 11592 11593 11594
        } else if (STREQ(arg, "-vmwarevga")) {
            video = VIR_DOMAIN_VIDEO_TYPE_VMVGA;
        } else if (STREQ(arg, "-std-vga")) {
            video = VIR_DOMAIN_VIDEO_TYPE_VGA;
        } else if (STREQ(arg, "-vga")) {
            WANT_VALUE();
            if (STRNEQ(val, "none")) {
                video = qemuVideoTypeFromString(val);
                if (video < 0) {
11595 11596
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("unknown video adapter type '%s'"), val);
11597 11598 11599 11600 11601 11602 11603 11604 11605 11606 11607
                    goto error;
                }
            }
        } else if (STREQ(arg, "-cpu")) {
            WANT_VALUE();
            if (qemuParseCommandLineCPU(def, val) < 0)
                goto error;
        } else if (STREQ(arg, "-domid")) {
            WANT_VALUE();
            /* ignore, generted on the fly */
        } else if (STREQ(arg, "-usb")) {
11608 11609
            virDomainControllerDefPtr ctldef;
            if (VIR_ALLOC(ctldef) < 0)
11610
                goto error;
11611 11612 11613 11614
            ctldef->type = VIR_DOMAIN_CONTROLLER_TYPE_USB;
            ctldef->idx = 0;
            ctldef->model = -1;
            virDomainControllerInsert(def, ctldef);
11615 11616
        } else if (STREQ(arg, "-pidfile")) {
            WANT_VALUE();
11617
            if (pidfile)
11618 11619
                if (VIR_STRDUP(*pidfile, val) < 0)
                    goto error;
11620 11621 11622 11623 11624
        } else if (STREQ(arg, "-incoming")) {
            WANT_VALUE();
            /* ignore, used via restore/migrate APIs */
        } else if (STREQ(arg, "-monitor")) {
            WANT_VALUE();
11625 11626 11627 11628
            if (monConfig) {
                virDomainChrSourceDefPtr chr;

                if (VIR_ALLOC(chr) < 0)
11629
                    goto error;
11630

E
Eric Blake 已提交
11631 11632
                if (qemuParseCommandLineChr(chr, val) < 0) {
                    virDomainChrSourceDefFree(chr);
11633
                    goto error;
E
Eric Blake 已提交
11634
                }
11635 11636 11637

                *monConfig = chr;
            }
11638 11639 11640 11641 11642 11643 11644 11645 11646 11647 11648 11649 11650 11651 11652 11653 11654 11655 11656 11657 11658 11659 11660 11661 11662 11663 11664 11665 11666 11667 11668 11669 11670 11671 11672 11673
        } else if (STREQ(arg, "-global") &&
                   STRPREFIX(progargv[i + 1], "PIIX4_PM.disable_s3=")) {
            /* We want to parse only the known "-global" parameters,
             * so the ones that we don't know are still added to the
             * namespace */
            WANT_VALUE();

            val += strlen("PIIX4_PM.disable_s3=");
            if (STREQ(val, "0"))
                def->pm.s3 = VIR_DOMAIN_PM_STATE_ENABLED;
            else if (STREQ(val, "1"))
                def->pm.s3 = VIR_DOMAIN_PM_STATE_DISABLED;
            else {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("invalid value for disable_s3 parameter: "
                                 "'%s'"), val);
                goto error;
            }

        } else if (STREQ(arg, "-global") &&
                   STRPREFIX(progargv[i + 1], "PIIX4_PM.disable_s4=")) {

            WANT_VALUE();

            val += strlen("PIIX4_PM.disable_s4=");
            if (STREQ(val, "0"))
                def->pm.s4 = VIR_DOMAIN_PM_STATE_ENABLED;
            else if (STREQ(val, "1"))
                def->pm.s4 = VIR_DOMAIN_PM_STATE_DISABLED;
            else {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("invalid value for disable_s4 parameter: "
                                 "'%s'"), val);
                goto error;
            }

11674 11675 11676 11677 11678
        } else if (STREQ(arg, "-global") &&
                   STRPREFIX(progargv[i + 1], "spapr-nvram.reg=")) {
            WANT_VALUE();

            if (VIR_ALLOC(def->nvram) < 0)
11679
                goto error;
11680 11681 11682 11683 11684 11685 11686 11687 11688 11689 11690

            def->nvram->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
            def->nvram->info.addr.spaprvio.has_reg = true;

            val += strlen("spapr-nvram.reg=");
            if (virStrToLong_ull(val, NULL, 16,
                                 &def->nvram->info.addr.spaprvio.reg) < 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse nvram's address '%s'"), val);
                goto error;
            }
11691 11692 11693 11694 11695 11696 11697 11698 11699
        } else if (STREQ(arg, "-S")) {
            /* ignore, always added by libvirt */
        } else {
            /* something we can't yet parse.  Add it to the qemu namespace
             * cmdline/environment advanced options and hope for the best
             */
            VIR_WARN("unknown QEMU argument '%s', adding to the qemu namespace",
                     arg);
            if (VIR_REALLOC_N(cmd->args, cmd->num_args+1) < 0)
11700
                goto error;
11701 11702
            if (VIR_STRDUP(cmd->args[cmd->num_args], arg) < 0)
                goto error;
11703 11704 11705 11706 11707
            cmd->num_args++;
        }
    }

#undef WANT_VALUE
11708 11709 11710
    if (def->ndisks > 0 && ceph_args) {
        char *hosts, *port, *saveptr = NULL, *token;
        virDomainDiskDefPtr first_rbd_disk = NULL;
11711
        for (i = 0; i < def->ndisks; i++) {
11712 11713 11714 11715
            if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
                def->disks[i]->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
                first_rbd_disk = def->disks[i];
                break;
11716
            }
11717
        }
11718

11719
        if (!first_rbd_disk) {
11720 11721
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("CEPH_ARGS was set without an rbd disk"));
11722 11723
            goto error;
        }
11724

11725 11726
        /* CEPH_ARGS should be: -m host1[:port1][,host2[:port2]]... */
        if (!STRPREFIX(ceph_args, "-m ")) {
11727 11728
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("could not parse CEPH_ARGS '%s'"), ceph_args);
11729 11730
            goto error;
        }
11731 11732
        if (VIR_STRDUP(hosts, strchr(ceph_args, ' ') + 1) < 0)
            goto error;
11733 11734 11735 11736 11737
        first_rbd_disk->nhosts = 0;
        token = strtok_r(hosts, ",", &saveptr);
        while (token != NULL) {
            if (VIR_REALLOC_N(first_rbd_disk->hosts, first_rbd_disk->nhosts + 1) < 0) {
                VIR_FREE(hosts);
11738
                goto error;
11739 11740 11741 11742
            }
            port = strchr(token, ':');
            if (port) {
                *port++ = '\0';
11743
                if (VIR_STRDUP(port, port) < 0) {
11744
                    VIR_FREE(hosts);
11745
                    goto error;
11746 11747
                }
            }
11748
            first_rbd_disk->hosts[first_rbd_disk->nhosts].port = port;
11749 11750
            if (VIR_STRDUP(first_rbd_disk->hosts[first_rbd_disk->nhosts].name,
                           token) < 0) {
11751
                VIR_FREE(hosts);
11752
                goto error;
11753
            }
11754 11755 11756
            first_rbd_disk->hosts[first_rbd_disk->nhosts].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
            first_rbd_disk->hosts[first_rbd_disk->nhosts].socket = NULL;

11757 11758 11759 11760 11761 11762
            first_rbd_disk->nhosts++;
            token = strtok_r(NULL, ",", &saveptr);
        }
        VIR_FREE(hosts);

        if (first_rbd_disk->nhosts == 0) {
11763 11764
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("found no rbd hosts in CEPH_ARGS '%s'"), ceph_args);
11765
            goto error;
11766 11767 11768
        }
    }

11769 11770
    if (!def->os.machine) {
        const char *defaultMachine =
11771
                        virCapabilitiesDefaultGuestMachine(qemuCaps,
11772 11773 11774 11775
                                                           def->os.type,
                                                           def->os.arch,
                                                           virDomainVirtTypeToString(def->virtType));
        if (defaultMachine != NULL)
11776 11777
            if (VIR_STRDUP(def->os.machine, defaultMachine) < 0)
                goto error;
11778 11779
    }

11780 11781 11782 11783 11784
    if (!nographics && def->ngraphics == 0) {
        virDomainGraphicsDefPtr sdl;
        const char *display = qemuFindEnv(progenv, "DISPLAY");
        const char *xauth = qemuFindEnv(progenv, "XAUTHORITY");
        if (VIR_ALLOC(sdl) < 0)
11785
            goto error;
11786 11787
        sdl->type = VIR_DOMAIN_GRAPHICS_TYPE_SDL;
        sdl->data.sdl.fullscreen = fullscreen;
11788
        if (VIR_STRDUP(sdl->data.sdl.display, display) < 0) {
11789
            VIR_FREE(sdl);
11790
            goto error;
11791
        }
11792
        if (VIR_STRDUP(sdl->data.sdl.xauth, xauth) < 0) {
11793
            VIR_FREE(sdl);
11794
            goto error;
11795 11796 11797 11798
        }

        if (VIR_REALLOC_N(def->graphics, def->ngraphics+1) < 0) {
            virDomainGraphicsDefFree(sdl);
11799
            goto error;
11800 11801 11802 11803 11804 11805 11806
        }
        def->graphics[def->ngraphics++] = sdl;
    }

    if (def->ngraphics) {
        virDomainVideoDefPtr vid;
        if (VIR_ALLOC(vid) < 0)
11807
            goto error;
11808 11809 11810 11811 11812
        if (def->virtType == VIR_DOMAIN_VIRT_XEN)
            vid->type = VIR_DOMAIN_VIDEO_TYPE_XEN;
        else
            vid->type = video;
        vid->vram = virDomainVideoDefaultRAM(def, vid->type);
11813 11814
        vid->ram = vid->type == VIR_DOMAIN_VIDEO_TYPE_QXL ?
                       virDomainVideoDefaultRAM(def, vid->type) : 0;
11815 11816 11817 11818
        vid->heads = 1;

        if (VIR_REALLOC_N(def->videos, def->nvideos+1) < 0) {
            virDomainVideoDefFree(vid);
11819
            goto error;
11820 11821 11822 11823 11824 11825 11826 11827 11828 11829
        }
        def->videos[def->nvideos++] = vid;
    }

    /*
     * having a balloon is the default, define one with type="none" to avoid it
     */
    if (!def->memballoon) {
        virDomainMemballoonDefPtr memballoon;
        if (VIR_ALLOC(memballoon) < 0)
11830
            goto error;
11831 11832 11833 11834 11835 11836 11837 11838 11839 11840
        memballoon->model = VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO;

        def->memballoon = memballoon;
    }

    VIR_FREE(nics);

    if (virDomainDefAddImplicitControllers(def) < 0)
        goto error;

11841 11842 11843
    if (virDomainDefPostParse(def, qemuCaps, xmlopt) < 0)
        goto error;

11844
    if (cmd->num_args || cmd->num_env) {
11845
        def->ns = *virDomainXMLOptionGetNamespace(xmlopt);
11846 11847 11848 11849 11850 11851 11852 11853
        def->namespaceData = cmd;
    }
    else
        VIR_FREE(cmd);

    return def;

error:
E
Eric Blake 已提交
11854
    virDomainDiskDefFree(disk);
11855 11856 11857
    VIR_FREE(cmd);
    virDomainDefFree(def);
    VIR_FREE(nics);
11858 11859 11860 11861 11862 11863
    if (monConfig) {
        virDomainChrSourceDefFree(*monConfig);
        *monConfig = NULL;
    }
    if (pidfile)
        VIR_FREE(*pidfile);
11864 11865 11866 11867
    return NULL;
}


11868
virDomainDefPtr qemuParseCommandLineString(virCapsPtr qemuCaps,
11869
                                           virDomainXMLOptionPtr xmlopt,
11870 11871 11872 11873
                                           const char *args,
                                           char **pidfile,
                                           virDomainChrSourceDefPtr *monConfig,
                                           bool *monJSON)
11874
{
E
Eric Blake 已提交
11875 11876
    char **progenv = NULL;
    char **progargv = NULL;
11877 11878 11879 11880 11881
    virDomainDefPtr def = NULL;

    if (qemuStringToArgvEnv(args, &progenv, &progargv) < 0)
        goto cleanup;

11882
    def = qemuParseCommandLine(qemuCaps, xmlopt, progenv, progargv,
11883
                               pidfile, monConfig, monJSON);
11884 11885

cleanup:
E
Eric Blake 已提交
11886 11887
    virStringFreeList(progargv);
    virStringFreeList(progenv);
11888 11889 11890

    return def;
}
11891 11892


11893
static int qemuParseProcFileStrings(int pid_value,
11894
                                    const char *name,
E
Eric Blake 已提交
11895
                                    char ***list)
11896 11897 11898 11899 11900 11901 11902
{
    char *path = NULL;
    int ret = -1;
    char *data = NULL;
    ssize_t len;
    char *tmp;
    size_t nstr = 0;
11903
    char **str = NULL;
11904

11905
    if (virAsprintf(&path, "/proc/%d/%s", pid_value, name) < 0)
11906 11907 11908 11909 11910 11911 11912
        goto cleanup;

    if ((len = virFileReadAll(path, 1024*128, &data)) < 0)
        goto cleanup;

    tmp = data;
    while (tmp < (data + len)) {
11913
        if (VIR_EXPAND_N(str, nstr, 1) < 0)
11914 11915
            goto cleanup;

11916
        if (VIR_STRDUP(str[nstr-1], tmp) < 0)
11917 11918 11919 11920 11921 11922 11923
            goto cleanup;
        /* Skip arg */
        tmp += strlen(tmp);
        /* Skip \0 separator */
        tmp++;
    }

11924
    if (VIR_EXPAND_N(str, nstr, 1) < 0)
11925 11926 11927 11928 11929
        goto cleanup;

    str[nstr-1] = NULL;

    ret = nstr-1;
E
Eric Blake 已提交
11930
    *list = str;
11931 11932

cleanup:
E
Eric Blake 已提交
11933 11934
    if (ret < 0)
        virStringFreeList(str);
11935 11936 11937 11938 11939
    VIR_FREE(data);
    VIR_FREE(path);
    return ret;
}

11940
virDomainDefPtr qemuParseCommandLinePid(virCapsPtr qemuCaps,
11941
                                        virDomainXMLOptionPtr xmlopt,
11942
                                        pid_t pid,
11943 11944 11945 11946 11947
                                        char **pidfile,
                                        virDomainChrSourceDefPtr *monConfig,
                                        bool *monJSON)
{
    virDomainDefPtr def = NULL;
E
Eric Blake 已提交
11948 11949
    char **progargv = NULL;
    char **progenv = NULL;
11950 11951 11952
    char *exepath = NULL;
    char *emulator;

11953 11954 11955 11956
    /* The parser requires /proc/pid, which only exists on platforms
     * like Linux where pid_t fits in int.  */
    if ((int) pid != pid ||
        qemuParseProcFileStrings(pid, "cmdline", &progargv) < 0 ||
11957 11958 11959
        qemuParseProcFileStrings(pid, "environ", &progenv) < 0)
        goto cleanup;

11960
    if (!(def = qemuParseCommandLine(qemuCaps, xmlopt, progenv, progargv,
11961 11962 11963
                                     pidfile, monConfig, monJSON)))
        goto cleanup;

11964
    if (virAsprintf(&exepath, "/proc/%d/exe", (int) pid) < 0)
11965 11966 11967 11968 11969
        goto cleanup;

    if (virFileResolveLink(exepath, &emulator) < 0) {
        virReportSystemError(errno,
                             _("Unable to resolve %s for pid %u"),
11970
                             exepath, (int) pid);
11971 11972 11973 11974 11975 11976 11977
        goto cleanup;
    }
    VIR_FREE(def->emulator);
    def->emulator = emulator;

cleanup:
    VIR_FREE(exepath);
E
Eric Blake 已提交
11978 11979
    virStringFreeList(progargv);
    virStringFreeList(progenv);
11980 11981
    return def;
}