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


#include <config.h>

#include "qemu_hotplug.h"
28
#include "qemu_hotplugpriv.h"
29
#include "qemu_alias.h"
30 31
#include "qemu_capabilities.h"
#include "qemu_domain.h"
32
#include "qemu_domain_address.h"
33 34
#include "qemu_command.h"
#include "qemu_hostdev.h"
35
#include "qemu_interface.h"
36
#include "qemu_process.h"
37
#include "domain_audit.h"
38
#include "netdev_bandwidth_conf.h"
39
#include "domain_nwfilter.h"
40
#include "virlog.h"
41
#include "datatypes.h"
42
#include "virerror.h"
43
#include "viralloc.h"
44
#include "virpci.h"
E
Eric Blake 已提交
45
#include "virfile.h"
46
#include "virprocess.h"
47
#include "qemu_cgroup.h"
48
#include "locking/domain_lock.h"
49
#include "network/bridge_driver.h"
50 51
#include "virnetdev.h"
#include "virnetdevbridge.h"
A
Ansis Atteka 已提交
52
#include "virnetdevtap.h"
53
#include "virnetdevopenvswitch.h"
54
#include "virnetdevmidonet.h"
55
#include "device_conf.h"
56
#include "virstoragefile.h"
57
#include "virstring.h"
58
#include "virtime.h"
59
#include "storage/storage_driver.h"
60 61

#define VIR_FROM_THIS VIR_FROM_QEMU
62 63 64

VIR_LOG_INIT("qemu.qemu_hotplug");

65
#define CHANGE_MEDIA_TIMEOUT 5000
66

67 68 69 70
/* Wait up to 5 seconds for device removal to finish. */
unsigned long long qemuDomainRemoveDeviceWaitTime = 1000ull * 5;


71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
/**
 * qemuDomainPrepareDisk:
 * @driver: qemu driver struct
 * @vm: domain object
 * @disk: disk to prepare
 * @overridesrc: Source different than @disk->src when necessary
 * @teardown: Teardown the disk instead of adding it to a vm
 *
 * Setup the locks, cgroups and security permissions on a disk of a VM.
 * If @overridesrc is specified the source struct is used instead of the
 * one present in @disk. If @teardown is true, then the labels and cgroups
 * are removed instead.
 *
 * Returns 0 on success and -1 on error. Reports libvirt error.
 */
static int
qemuDomainPrepareDisk(virQEMUDriverPtr driver,
                      virDomainObjPtr vm,
                      virDomainDiskDefPtr disk,
                      virStorageSourcePtr overridesrc,
                      bool teardown)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = -1;
    virStorageSourcePtr origsrc = NULL;

    if (overridesrc) {
        origsrc = disk->src;
        disk->src = overridesrc;
    }

    /* just tear down the disk access */
    if (teardown) {
        ret = 0;
        goto rollback_cgroup;
    }

    if (virDomainLockDiskAttach(driver->lockManager, cfg->uri,
                                vm, disk) < 0)
        goto cleanup;

    if (virSecurityManagerSetDiskLabel(driver->securityManager,
                                       vm->def, disk) < 0)
        goto rollback_lock;

    if (qemuSetupDiskCgroup(vm, disk) < 0)
        goto rollback_label;

    ret = 0;
    goto cleanup;

 rollback_cgroup:
    if (qemuTeardownDiskCgroup(vm, disk) < 0)
        VIR_WARN("Unable to tear down cgroup access on %s",
                 virDomainDiskGetSource(disk));

 rollback_label:
    if (virSecurityManagerRestoreDiskLabel(driver->securityManager,
                                           vm->def, disk) < 0)
        VIR_WARN("Unable to restore security label on %s",
                 virDomainDiskGetSource(disk));

 rollback_lock:
    if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
        VIR_WARN("Unable to release lock on %s",
                 virDomainDiskGetSource(disk));

 cleanup:
    if (origsrc)
        disk->src = origsrc;

    virObjectUnref(cfg);

    return ret;
}


148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
static int
qemuHotplugWaitForTrayEject(virQEMUDriverPtr driver,
                            virDomainObjPtr vm,
                            virDomainDiskDefPtr disk,
                            const char *driveAlias,
                            bool force)
{
    unsigned long long now;
    int rc;

    if (virTimeMillisNow(&now) < 0)
        return -1;

    while (disk->tray_status != VIR_DOMAIN_DISK_TRAY_OPEN) {
        if ((rc = virDomainObjWaitUntil(vm, now + CHANGE_MEDIA_TIMEOUT)) < 0)
            return -1;

        if (rc > 0) {
166 167 168 169 170 171
            /* the caller called qemuMonitorEjectMedia which usually reports an
             * error. Report the failure in an off-chance that it didn't. */
            if (!virGetLastError()) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("timed out waiting for disk tray status update"));
            }
172 173 174 175 176 177 178 179 180 181 182 183 184 185
            return -1;
        }
    }

    /* re-issue ejection command to pop out the media */
    qemuDomainObjEnterMonitor(driver, vm);
    rc = qemuMonitorEjectMedia(qemuDomainGetMonitor(vm), driveAlias, force);
    if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
        return -1;

    return 0;
}


186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
/**
 * qemuDomainChangeEjectableMedia:
 * @driver: qemu driver structure
 * @vm: domain definition
 * @disk: disk definition to change the source of
 * @newsrc: new disk source to change to
 * @force: force the change of media
 *
 * Change the media in an ejectable device to the one described by
 * @newsrc. This function also removes the old source from the
 * shared device table if appropriate. Note that newsrc is consumed
 * on success and the old source is freed on success.
 *
 * Returns 0 on success, -1 on error and reports libvirt error
 */
int
qemuDomainChangeEjectableMedia(virQEMUDriverPtr driver,
                               virDomainObjPtr vm,
                               virDomainDiskDefPtr disk,
                               virStorageSourcePtr newsrc,
                               bool force)
207
{
208
    int ret = -1, rc;
209
    char *driveAlias = NULL;
210
    qemuDomainObjPrivatePtr priv = vm->privateData;
211
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
212
    const char *format = NULL;
213
    char *sourcestr = NULL;
214

215
    if (!disk->info.alias) {
216
        virReportError(VIR_ERR_INTERNAL_ERROR,
217
                       _("missing disk device alias name for %s"), disk->dst);
218
        goto cleanup;
219 220
    }

221 222
    if (disk->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
        disk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) {
223 224
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Removable media not supported for %s device"),
225
                       virDomainDiskDeviceTypeToString(disk->device));
226
        goto cleanup;
227 228
    }

229
    if (qemuDomainPrepareDisk(driver, vm, disk, newsrc, false) < 0)
230
        goto cleanup;
231

232
    if (!(driveAlias = qemuAliasFromDisk(disk)))
233 234
        goto error;

235 236 237 238
    qemuDomainObjEnterMonitor(driver, vm);
    rc = qemuMonitorEjectMedia(priv->mon, driveAlias, force);
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
239

240 241 242
    /* If the tray is present and tray change event is supported wait for it to open. */
    if (diskPriv->tray &&
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE_TRAY_MOVED)) {
243 244
        rc = qemuHotplugWaitForTrayEject(driver, vm, disk, driveAlias, force);
        if (rc < 0)
245
            goto error;
246 247 248 249 250
    } else  {
        /* otherwise report possible errors from the attempt to eject the media*/
        if (rc < 0)
            goto error;
    }
251

252
    if (!virStorageSourceIsEmpty(newsrc)) {
253
        if (qemuGetDriveSourceString(newsrc, diskPriv->secinfo, &sourcestr) < 0)
254 255
            goto error;

256 257 258
        if (virStorageSourceGetActualType(newsrc) != VIR_STORAGE_TYPE_DIR) {
            if (newsrc->format > 0) {
                format = virStorageFileFormatTypeToString(newsrc->format);
259
            } else {
260 261
                if (disk->src->format > 0)
                    format = virStorageFileFormatTypeToString(disk->src->format);
262
            }
263
        }
264
        qemuDomainObjEnterMonitor(driver, vm);
265 266 267 268 269
        rc = qemuMonitorChangeMedia(priv->mon,
                                    driveAlias,
                                    sourcestr,
                                    format);
        if (qemuDomainObjExitMonitor(driver, vm) < 0)
270
            goto cleanup;
271
    }
272

273
    virDomainAuditDisk(vm, disk->src, newsrc, "update", rc >= 0);
274

275
    if (rc < 0)
276 277
        goto error;

278 279
    /* remove the old source from shared device list */
    ignore_value(qemuRemoveSharedDisk(driver, disk, vm->def->name));
280
    ignore_value(qemuDomainPrepareDisk(driver, vm, disk, NULL, true));
281

282 283 284
    virStorageSourceFree(disk->src);
    disk->src = newsrc;
    newsrc = NULL;
285
    ret = 0;
286

287
 cleanup:
288
    VIR_FREE(driveAlias);
289
    VIR_FREE(sourcestr);
290 291
    return ret;

292
 error:
293 294
    virDomainAuditDisk(vm, disk->src, newsrc, "update", false);
    ignore_value(qemuDomainPrepareDisk(driver, vm, disk, newsrc, true));
295
    goto cleanup;
296 297
}

298

299 300 301 302 303
static int
qemuDomainAttachVirtioDiskDevice(virConnectPtr conn,
                                 virQEMUDriverPtr driver,
                                 virDomainObjPtr vm,
                                 virDomainDiskDefPtr disk)
304
{
305
    int ret = -1;
306
    int rv;
307
    qemuDomainObjPrivatePtr priv = vm->privateData;
308
    virErrorPtr orig_err;
309 310
    char *devstr = NULL;
    char *drivestr = NULL;
311
    char *drivealias = NULL;
312
    bool releaseaddr = false;
313
    bool driveAdded = false;
314
    bool secobjAdded = false;
315
    bool encobjAdded = false;
316
    virDomainCCWAddressSetPtr ccwaddrs = NULL;
317
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
318
    const char *src = virDomainDiskGetSource(disk);
319
    virJSONValuePtr secobjProps = NULL;
320
    virJSONValuePtr encobjProps = NULL;
321 322
    qemuDomainDiskPrivatePtr diskPriv;
    qemuDomainSecretInfoPtr secinfo;
323
    qemuDomainSecretInfoPtr encinfo;
324

325
    if (!disk->info.type) {
326
        if (qemuDomainMachineIsS390CCW(vm->def) &&
327 328 329 330
            virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_CCW))
            disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW;
        else if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_S390))
            disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390;
331 332 333 334
    } else {
        if (!qemuCheckCCWS390AddressSupport(vm->def, disk->info, priv->qemuCaps,
                                            disk->dst))
            goto cleanup;
335 336
    }

337
    if (qemuDomainPrepareDisk(driver, vm, disk, NULL, false) < 0)
338
        goto cleanup;
339

340
    if (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
341 342 343
        if (!(ccwaddrs = qemuDomainCCWAddrSetCreateFromDomain(vm->def)))
            goto error;
        if (virDomainCCWAddressAssign(&disk->info, ccwaddrs,
344
                                      !disk->info.addr.ccw.assigned) < 0)
345
            goto error;
346 347 348
    } else if (!disk->info.type ||
                disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
        if (virDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0)
349
            goto error;
350 351 352 353
    }
    releaseaddr = true;
    if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
        goto error;
354

J
John Ferlan 已提交
355
    if (qemuDomainSecretDiskPrepare(conn, priv, disk) < 0)
356 357
        goto error;

358 359 360 361 362 363 364
    diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
    secinfo = diskPriv->secinfo;
    if (secinfo && secinfo->type == VIR_DOMAIN_SECRET_INFO_TYPE_AES) {
        if (qemuBuildSecretInfoProps(secinfo, &secobjProps) < 0)
            goto error;
    }

365 366 367 368
    encinfo = diskPriv->encinfo;
    if (encinfo && qemuBuildSecretInfoProps(encinfo, &encobjProps) < 0)
        goto error;

369
    if (!(drivestr = qemuBuildDriveStr(disk, false, priv->qemuCaps)))
370
        goto error;
371

372
    if (!(drivealias = qemuAliasFromDisk(disk)))
373 374 375 376
        goto error;

    if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->qemuCaps)))
        goto error;
377

378
    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0)
379 380
        goto error;

381
    qemuDomainObjEnterMonitor(driver, vm);
382

383 384 385 386 387
    if (secobjProps) {
        rv = qemuMonitorAddObject(priv->mon, "secret", secinfo->s.aes.alias,
                                  secobjProps);
        secobjProps = NULL; /* qemuMonitorAddObject consumes */
        if (rv < 0)
388
            goto exit_monitor;
389
        secobjAdded = true;
390 391
    }

392 393 394 395 396 397
    if (encobjProps) {
        rv = qemuMonitorAddObject(priv->mon, "secret", encinfo->s.aes.alias,
                                  encobjProps);
        encobjProps = NULL; /* qemuMonitorAddObject consumes */
        if (rv < 0)
            goto exit_monitor;
398
        encobjAdded = true;
399 400
    }

401
    if (qemuMonitorAddDrive(priv->mon, drivestr) < 0)
402 403
        goto exit_monitor;
    driveAdded = true;
404 405

    if (qemuMonitorAddDevice(priv->mon, devstr) < 0)
406
        goto exit_monitor;
407

408 409
    if (qemuDomainObjExitMonitor(driver, vm) < 0) {
        releaseaddr = false;
410
        goto error;
411
    }
412

413
    virDomainAuditDisk(vm, NULL, disk->src, "attach", true);
414 415

    virDomainDiskInsertPreAlloced(vm->def, disk);
416
    ret = 0;
417

418
 cleanup:
419
    virJSONValueFree(secobjProps);
420
    virJSONValueFree(encobjProps);
421
    qemuDomainSecretDiskDestroy(disk);
422
    virDomainCCWAddressSetFree(ccwaddrs);
423 424
    VIR_FREE(devstr);
    VIR_FREE(drivestr);
425
    VIR_FREE(drivealias);
426 427
    virObjectUnref(cfg);
    return ret;
428

429
 exit_monitor:
430
    orig_err = virSaveLastError();
431
    if (driveAdded && qemuMonitorDriveDel(priv->mon, drivealias) < 0) {
432 433 434
        VIR_WARN("Unable to remove drive %s (%s) after failed "
                 "qemuMonitorAddDevice", drivealias, drivestr);
    }
435 436
    if (secobjAdded)
        ignore_value(qemuMonitorDelObject(priv->mon, secinfo->s.aes.alias));
437 438
    if (encobjAdded)
        ignore_value(qemuMonitorDelObject(priv->mon, encinfo->s.aes.alias));
439 440 441 442
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
    }
443

444 445 446 447 448
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        releaseaddr = false;

    virDomainAuditDisk(vm, NULL, disk->src, "attach", false);

449
 error:
450
    if (releaseaddr)
451
        qemuDomainReleaseDeviceAddress(vm, &disk->info, src);
452

453
    ignore_value(qemuDomainPrepareDisk(driver, vm, disk, NULL, true));
454
    goto cleanup;
455 456 457
}


458 459 460
int qemuDomainAttachControllerDevice(virQEMUDriverPtr driver,
                                     virDomainObjPtr vm,
                                     virDomainControllerDefPtr controller)
461 462 463 464 465
{
    int ret = -1;
    const char* type = virDomainControllerTypeToString(controller->type);
    char *devstr = NULL;
    qemuDomainObjPrivatePtr priv = vm->privateData;
466
    virDomainCCWAddressSetPtr ccwaddrs = NULL;
467
    bool releaseaddr = false;
468

469 470 471 472 473 474 475
    if (controller->type != VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("'%s' controller cannot be hot plugged."),
                       virDomainControllerTypeToString(controller->type));
        return -1;
    }

476 477 478 479 480 481 482 483
    /* default idx would normally be set by virDomainDefPostParse(),
     * which isn't called in the case of live attach of a single
     * device.
     */
    if (controller->idx == -1)
       controller->idx = virDomainControllerFindUnusedIndex(vm->def,
                                                            controller->type);

484
    if (virDomainControllerFind(vm->def, controller->type, controller->idx) >= 0) {
485 486 487 488
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("target %s:%d already exists"),
                       type, controller->idx);
        return -1;
489 490
    }

491 492 493 494 495 496 497 498 499
    if (controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
        if (qemuDomainMachineIsS390CCW(vm->def) &&
            virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_CCW))
            controller->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW;
        else if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_S390))
            controller->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390;
    } else {
        if (!qemuCheckCCWS390AddressSupport(vm->def, controller->info,
                                            priv->qemuCaps, "controller"))
500
            goto cleanup;
501
    }
502

503 504 505 506 507
    if (controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE ||
        controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
        if (virDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0)
            goto cleanup;
    } else if (controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
508 509 510
        if (!(ccwaddrs = qemuDomainCCWAddrSetCreateFromDomain(vm->def)))
            goto cleanup;
        if (virDomainCCWAddressAssign(&controller->info, ccwaddrs,
511
                                      !controller->info.addr.ccw.assigned) < 0)
512 513
            goto cleanup;
    }
514 515 516 517 518 519
    releaseaddr = true;
    if (qemuAssignDeviceControllerAlias(vm->def, priv->qemuCaps, controller) < 0)
        goto cleanup;

    if (!(devstr = qemuBuildControllerDevStr(vm->def, controller, priv->qemuCaps, NULL)))
        goto cleanup;
520

521
    if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers+1) < 0)
522 523
        goto cleanup;

524
    qemuDomainObjEnterMonitor(driver, vm);
525
    ret = qemuMonitorAddDevice(priv->mon, devstr);
526 527 528 529 530
    if (qemuDomainObjExitMonitor(driver, vm) < 0) {
        releaseaddr = false;
        ret = -1;
        goto cleanup;
    }
531 532

    if (ret == 0) {
533 534
        if (controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
            controller->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
535 536 537
        virDomainControllerInsertPreAlloced(vm->def, controller);
    }

538
 cleanup:
539 540
    if (ret != 0 && releaseaddr)
        qemuDomainReleaseDeviceAddress(vm, &controller->info, NULL);
541 542

    VIR_FREE(devstr);
543
    virDomainCCWAddressSetFree(ccwaddrs);
544 545 546 547
    return ret;
}

static virDomainControllerDefPtr
548
qemuDomainFindOrCreateSCSIDiskController(virQEMUDriverPtr driver,
549
                                         virDomainObjPtr vm,
550
                                         int controller)
551
{
552
    size_t i;
553
    virDomainControllerDefPtr cont;
554

555
    for (i = 0; i < vm->def->ncontrollers; i++) {
556 557 558 559 560 561 562 563 564 565 566
        cont = vm->def->controllers[i];

        if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_SCSI)
            continue;

        if (cont->idx == controller)
            return cont;
    }

    /* No SCSI controller present, for backward compatibility we
     * now hotplug a controller */
567
    if (VIR_ALLOC(cont) < 0)
568 569
        return NULL;
    cont->type = VIR_DOMAIN_CONTROLLER_TYPE_SCSI;
570
    cont->idx = controller;
571 572
    cont->model = -1;

573
    VIR_INFO("No SCSI controller present, hotplugging one");
574 575
    if (qemuDomainAttachControllerDevice(driver,
                                         vm, cont) < 0) {
576 577 578 579 580
        VIR_FREE(cont);
        return NULL;
    }

    if (!virDomainObjIsActive(vm)) {
581 582
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("guest unexpectedly quit"));
583 584 585 586 587 588 589 590 591
        /* cont doesn't need freeing here, since the reference
         * now held in def->controllers */
        return NULL;
    }

    return cont;
}


592 593 594 595 596
static int
qemuDomainAttachSCSIDisk(virConnectPtr conn,
                         virQEMUDriverPtr driver,
                         virDomainObjPtr vm,
                         virDomainDiskDefPtr disk)
597
{
598
    size_t i;
599
    qemuDomainObjPrivatePtr priv = vm->privateData;
600
    virErrorPtr orig_err;
601 602
    char *drivestr = NULL;
    char *devstr = NULL;
603
    bool driveAdded = false;
604
    bool encobjAdded = false;
605
    char *drivealias = NULL;
606
    int ret = -1;
607
    int rv;
608
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
609 610 611
    virJSONValuePtr encobjProps = NULL;
    qemuDomainDiskPrivatePtr diskPriv;
    qemuDomainSecretInfoPtr encinfo;
612

613
    if (qemuDomainPrepareDisk(driver, vm, disk, NULL, false) < 0)
614
        goto cleanup;
615 616 617

    /* We should have an address already, so make sure */
    if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
618 619 620
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unexpected disk address type %s"),
                       virDomainDeviceAddressTypeToString(disk->info.type));
621 622 623
        goto error;
    }

624 625 626 627 628 629 630 631 632 633 634 635
    /* Let's make sure the disk has a controller defined and loaded before
     * trying to add it. The controller used by the disk must exist before a
     * qemu command line string is generated.
     *
     * Ensure that the given controller and all controllers with a smaller index
     * exist; there must not be any missing index in between.
     */
    for (i = 0; i <= disk->info.addr.drive.controller; i++) {
        if (!qemuDomainFindOrCreateSCSIDiskController(driver, vm, i))
            goto error;
    }

636 637
    if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
        goto error;
638

J
John Ferlan 已提交
639
    if (qemuDomainSecretDiskPrepare(conn, priv, disk) < 0)
640 641
        goto error;

642 643 644 645 646
    diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
    encinfo = diskPriv->encinfo;
    if (encinfo && qemuBuildSecretInfoProps(encinfo, &encobjProps) < 0)
        goto error;

647 648
    if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->qemuCaps)))
        goto error;
649

650
    if (!(drivestr = qemuBuildDriveStr(disk, false, priv->qemuCaps)))
651 652
        goto error;

653 654 655
    if (!(drivealias = qemuAliasFromDisk(disk)))
        goto error;

656
    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0)
657 658
        goto error;

659
    qemuDomainObjEnterMonitor(driver, vm);
660

661 662 663 664 665 666
    if (encobjProps) {
        rv = qemuMonitorAddObject(priv->mon, "secret", encinfo->s.aes.alias,
                                  encobjProps);
        encobjProps = NULL; /* qemuMonitorAddObject consumes */
        if (rv < 0)
            goto exit_monitor;
667
        encobjAdded = true;
668 669
    }

670
    if (qemuMonitorAddDrive(priv->mon, drivestr) < 0)
671 672
        goto exit_monitor;
    driveAdded = true;
673

674
    if (qemuMonitorAddDevice(priv->mon, devstr) < 0)
675
        goto exit_monitor;
676

677
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
678
        goto error;
679

680
    virDomainAuditDisk(vm, NULL, disk->src, "attach", true);
681 682

    virDomainDiskInsertPreAlloced(vm->def, disk);
683
    ret = 0;
684

685
 cleanup:
686
    virJSONValueFree(encobjProps);
687
    qemuDomainSecretDiskDestroy(disk);
688 689
    VIR_FREE(devstr);
    VIR_FREE(drivestr);
690
    VIR_FREE(drivealias);
691 692
    virObjectUnref(cfg);
    return ret;
693

694
 exit_monitor:
695
    orig_err = virSaveLastError();
696 697 698 699
    if (driveAdded && qemuMonitorDriveDel(priv->mon, drivealias) < 0) {
        VIR_WARN("Unable to remove drive %s (%s) after failed "
                 "qemuMonitorAddDevice", drivealias, drivestr);
    }
700 701 702 703 704 705 706
    if (encobjAdded)
        ignore_value(qemuMonitorDelObject(priv->mon, encinfo->s.aes.alias));
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
    }

707 708 709 710
    ignore_value(qemuDomainObjExitMonitor(driver, vm));

    virDomainAuditDisk(vm, NULL, disk->src, "attach", false);

711
 error:
712
    ignore_value(qemuDomainPrepareDisk(driver, vm, disk, NULL, true));
713
    goto cleanup;
714 715 716
}


717
static int
718
qemuDomainAttachUSBMassStorageDevice(virQEMUDriverPtr driver,
719 720
                                     virDomainObjPtr vm,
                                     virDomainDiskDefPtr disk)
721 722
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
723
    virErrorPtr orig_err;
724
    int ret = -1;
725
    char *drivealias = NULL;
726 727
    char *drivestr = NULL;
    char *devstr = NULL;
728
    bool driveAdded = false;
729
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
730
    const char *src = virDomainDiskGetSource(disk);
731 732 733 734 735 736 737
    bool releaseaddr = false;

    if (priv->usbaddrs) {
        if (virDomainUSBAddressEnsure(priv->usbaddrs, &disk->info) < 0)
            goto cleanup;
        releaseaddr = true;
    }
738

739
    if (qemuDomainPrepareDisk(driver, vm, disk, NULL, false) < 0)
740
        goto cleanup;
741

742
    /* XXX not correct once we allow attaching a USB CDROM */
743
    if (!src) {
744 745
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("disk source path is missing"));
746 747 748
        goto error;
    }

749 750
    if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
        goto error;
751

752
    if (!(drivestr = qemuBuildDriveStr(disk, false, priv->qemuCaps)))
753
        goto error;
754 755 756 757

    if (!(drivealias = qemuAliasFromDisk(disk)))
        goto error;

758 759
    if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->qemuCaps)))
        goto error;
760

761
    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0)
762 763
        goto error;

764
    qemuDomainObjEnterMonitor(driver, vm);
765

766 767 768 769 770 771
    if (qemuMonitorAddDrive(priv->mon, drivestr) < 0)
        goto exit_monitor;
    driveAdded = true;

    if (qemuMonitorAddDevice(priv->mon, devstr) < 0)
        goto exit_monitor;
772

773
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
774 775
        goto error;

776 777
    virDomainAuditDisk(vm, NULL, disk->src, "attach", true);

778
    virDomainDiskInsertPreAlloced(vm->def, disk);
779
    ret = 0;
780

781
 cleanup:
782 783
    if (ret < 0 && releaseaddr)
        virDomainUSBAddressRelease(priv->usbaddrs, &disk->info);
784
    VIR_FREE(devstr);
785
    VIR_FREE(drivealias);
786
    VIR_FREE(drivestr);
787 788
    virObjectUnref(cfg);
    return ret;
789

790
 exit_monitor:
791 792 793 794 795 796 797 798
    orig_err = virSaveLastError();
    if (driveAdded && qemuMonitorDriveDel(priv->mon, drivealias) < 0) {
        VIR_WARN("Unable to remove drive %s (%s) after failed "
                 "qemuMonitorAddDevice", drivealias, drivestr);
    }
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
799 800 801 802 803
    }

    ignore_value(qemuDomainObjExitMonitor(driver, vm));
    virDomainAuditDisk(vm, NULL, disk->src, "attach", false);

804
 error:
805
    ignore_value(qemuDomainPrepareDisk(driver, vm, disk, NULL, true));
806
    goto cleanup;
807 808 809
}


810 811 812 813 814 815
int
qemuDomainAttachDeviceDiskLive(virConnectPtr conn,
                               virQEMUDriverPtr driver,
                               virDomainObjPtr vm,
                               virDomainDeviceDefPtr dev)
{
816
    size_t i;
817 818 819
    virDomainDiskDefPtr disk = dev->data.disk;
    virDomainDiskDefPtr orig_disk = NULL;
    int ret = -1;
820
    const char *src = virDomainDiskGetSource(disk);
821

822
    if (STRNEQ_NULLABLE(virDomainDiskGetDriver(disk), "qemu")) {
823 824
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("unsupported driver name '%s' for disk '%s'"),
825
                       virDomainDiskGetDriver(disk), src);
826
        goto cleanup;
827 828
    }

829
    if (virStorageTranslateDiskSourcePool(conn, disk) < 0)
830
        goto cleanup;
831 832

    if (qemuAddSharedDevice(driver, dev, vm->def->name) < 0)
833
        goto cleanup;
834 835

    if (qemuSetUnprivSGIO(dev) < 0)
836
        goto cleanup;
837

838
    if (qemuDomainDetermineDiskChain(driver, vm, disk, false, true) < 0)
839
        goto cleanup;
840

841
    switch ((virDomainDiskDevice) disk->device)  {
842 843 844 845 846
    case VIR_DOMAIN_DISK_DEVICE_CDROM:
    case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
        if (!(orig_disk = virDomainDiskFindByBusAndDst(vm->def,
                                                       disk->bus, disk->dst))) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
847 848 849
                           _("No device with bus '%s' and target '%s'. "
                             "cdrom and floppy device hotplug isn't supported "
                             "by libvirt"),
850 851
                           virDomainDiskBusTypeToString(disk->bus),
                           disk->dst);
852
            goto cleanup;
853 854
        }

855
        if (qemuDomainChangeEjectableMedia(driver, vm, orig_disk,
856
                                           disk->src, false) < 0)
857
            goto cleanup;
858

859
        disk->src = NULL;
860
        ret = 0;
861
        break;
862

863 864
    case VIR_DOMAIN_DISK_DEVICE_DISK:
    case VIR_DOMAIN_DISK_DEVICE_LUN:
865
        for (i = 0; i < vm->def->ndisks; i++) {
866 867
            if (virDomainDiskDefCheckDuplicateInfo(vm->def->disks[i], disk) < 0)
                goto cleanup;
868 869
        }

870 871
        switch ((virDomainDiskBus) disk->bus) {
        case VIR_DOMAIN_DISK_BUS_USB:
872 873 874 875 876
            if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("disk device='lun' is not supported for usb bus"));
                break;
            }
877
            ret = qemuDomainAttachUSBMassStorageDevice(driver, vm, disk);
878 879 880
            break;

        case VIR_DOMAIN_DISK_BUS_VIRTIO:
881
            ret = qemuDomainAttachVirtioDiskDevice(conn, driver, vm, disk);
882 883 884
            break;

        case VIR_DOMAIN_DISK_BUS_SCSI:
885
            ret = qemuDomainAttachSCSIDisk(conn, driver, vm, disk);
886 887 888 889 890 891 892 893 894
            break;

        case VIR_DOMAIN_DISK_BUS_IDE:
        case VIR_DOMAIN_DISK_BUS_FDC:
        case VIR_DOMAIN_DISK_BUS_XEN:
        case VIR_DOMAIN_DISK_BUS_UML:
        case VIR_DOMAIN_DISK_BUS_SATA:
        case VIR_DOMAIN_DISK_BUS_SD:
        case VIR_DOMAIN_DISK_BUS_LAST:
895 896 897 898 899
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                           _("disk bus '%s' cannot be hotplugged."),
                           virDomainDiskBusTypeToString(disk->bus));
        }
        break;
900 901

    case VIR_DOMAIN_DISK_DEVICE_LAST:
902 903 904
        break;
    }

905
 cleanup:
906 907 908 909 910 911
    if (ret != 0)
        ignore_value(qemuRemoveSharedDevice(driver, dev, vm->def->name));
    return ret;
}


912 913 914 915
int
qemuDomainAttachNetDevice(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
                          virDomainNetDefPtr net)
916 917
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
918 919
    char **tapfdName = NULL;
    int *tapfd = NULL;
920
    size_t tapfdSize = 0;
921 922
    char **vhostfdName = NULL;
    int *vhostfd = NULL;
923
    size_t vhostfdSize = 0;
924 925
    char *nicstr = NULL;
    char *netstr = NULL;
A
Ansis Atteka 已提交
926
    virNetDevVPortProfilePtr vport = NULL;
927 928
    int ret = -1;
    int vlan;
929
    bool releaseaddr = false;
930 931
    bool iface_connected = false;
    int actualType;
932
    virNetDevBandwidthPtr actualBandwidth;
933
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
934
    virDomainCCWAddressSetPtr ccwaddrs = NULL;
935
    size_t i;
936

937
    /* preallocate new slot for device */
938
    if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets + 1) < 0)
939
        goto cleanup;
940

941 942 943 944
    /* 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.
     */
945
    if (networkAllocateActualDevice(vm->def, net) < 0)
946
        goto cleanup;
947 948

    actualType = virDomainNetGetActualType(net);
949 950 951 952 953 954

    if (actualType == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
        /* This is really a "smart hostdev", so it should be attached
         * as a hostdev (the hostdev code will reach over into the
         * netdev-specific code as appropriate), then also added to
         * the nets list (see cleanup:) if successful.
955 956 957
         *
         * qemuDomainAttachHostDevice uses a connection to resolve
         * a SCSI hostdev secret, which is not this case, so pass NULL.
958
         */
959
        ret = qemuDomainAttachHostDevice(NULL, driver, vm,
960 961 962 963
                                         virDomainNetGetActualHostdev(net));
        goto cleanup;
    }

964
    /* Currently only TAP/macvtap devices supports multiqueue. */
965 966
    if (net->driver.virtio.queues > 0 &&
        !(actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
967
          actualType == VIR_DOMAIN_NET_TYPE_BRIDGE ||
968 969
          actualType == VIR_DOMAIN_NET_TYPE_DIRECT ||
          actualType == VIR_DOMAIN_NET_TYPE_ETHERNET)) {
970 971 972 973 974 975
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("Multiqueue network is not supported for: %s"),
                       virDomainNetTypeToString(actualType));
        return -1;
    }

976 977 978
    /* and only TAP devices support nwfilter rules */
    if (net->filter &&
        !(actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
979 980
          actualType == VIR_DOMAIN_NET_TYPE_BRIDGE ||
          actualType == VIR_DOMAIN_NET_TYPE_ETHERNET)) {
981 982 983 984 985 986 987
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("filterref is not supported for "
                         "network interfaces of type %s"),
                       virDomainNetTypeToString(actualType));
        return -1;
    }

988 989
    if (actualType == VIR_DOMAIN_NET_TYPE_BRIDGE ||
        actualType == VIR_DOMAIN_NET_TYPE_NETWORK) {
990 991 992
        tapfdSize = vhostfdSize = net->driver.virtio.queues;
        if (!tapfdSize)
            tapfdSize = vhostfdSize = 1;
993
        if (VIR_ALLOC_N(tapfd, tapfdSize) < 0)
994
            goto cleanup;
995 996 997 998
        memset(tapfd, -1, sizeof(*tapfd) * tapfdSize);
        if (VIR_ALLOC_N(vhostfd, vhostfdSize) < 0)
            goto cleanup;
        memset(vhostfd, -1, sizeof(*vhostfd) * vhostfdSize);
999 1000
        if (qemuInterfaceBridgeConnect(vm->def, driver, net,
                                       tapfd, &tapfdSize) < 0)
1001 1002
            goto cleanup;
        iface_connected = true;
1003 1004
        if (qemuInterfaceOpenVhostNet(vm->def, net, priv->qemuCaps,
                                      vhostfd, &vhostfdSize) < 0)
1005
            goto cleanup;
1006
    } else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
1007 1008 1009 1010
        tapfdSize = vhostfdSize = net->driver.virtio.queues;
        if (!tapfdSize)
            tapfdSize = vhostfdSize = 1;
        if (VIR_ALLOC_N(tapfd, tapfdSize) < 0)
1011
            goto cleanup;
1012 1013
        memset(tapfd, -1, sizeof(*tapfd) * tapfdSize);
        if (VIR_ALLOC_N(vhostfd, vhostfdSize) < 0)
1014
            goto cleanup;
1015
        memset(vhostfd, -1, sizeof(*vhostfd) * vhostfdSize);
1016 1017 1018
        if (qemuInterfaceDirectConnect(vm->def, driver, net,
                                       tapfd, tapfdSize,
                                       VIR_NETDEV_VPORT_PROFILE_OP_CREATE) < 0)
1019 1020
            goto cleanup;
        iface_connected = true;
1021 1022
        if (qemuInterfaceOpenVhostNet(vm->def, net, priv->qemuCaps,
                                      vhostfd, &vhostfdSize) < 0)
1023
            goto cleanup;
1024
    } else if (actualType == VIR_DOMAIN_NET_TYPE_ETHERNET) {
1025 1026 1027 1028
        tapfdSize = vhostfdSize = net->driver.virtio.queues;
        if (!tapfdSize)
            tapfdSize = vhostfdSize = 1;
        if (VIR_ALLOC_N(tapfd, tapfdSize) < 0)
1029
            goto cleanup;
1030 1031 1032 1033 1034 1035 1036 1037
        memset(tapfd, -1, sizeof(*tapfd) * tapfdSize);
        if (VIR_ALLOC_N(vhostfd, vhostfdSize) < 0)
            goto cleanup;
        memset(vhostfd, -1, sizeof(*vhostfd) * vhostfdSize);
        if (qemuInterfaceEthernetConnect(vm->def, driver, net,
                                       tapfd, tapfdSize) < 0)
            goto cleanup;
        iface_connected = true;
1038 1039
        if (qemuInterfaceOpenVhostNet(vm->def, net, priv->qemuCaps,
                                      vhostfd, &vhostfdSize) < 0)
1040
            goto cleanup;
1041 1042
    }

1043 1044
    /* Set device online immediately */
    if (qemuInterfaceStartDevice(net) < 0)
1045
        goto cleanup;
1046

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
    /* Set bandwidth or warn if requested and not supported. */
    actualBandwidth = virDomainNetGetActualBandwidth(net);
    if (actualBandwidth) {
        if (virNetDevSupportBandwidth(actualType)) {
            if (virNetDevBandwidthSet(net->ifname, actualBandwidth, false) < 0)
                goto cleanup;
        } else {
            VIR_WARN("setting bandwidth on interfaces of "
                     "type '%s' is not implemented yet",
                     virDomainNetTypeToString(actualType));
        }
    }
1059

M
Michal Privoznik 已提交
1060 1061 1062 1063 1064 1065
    for (i = 0; i < tapfdSize; i++) {
        if (virSecurityManagerSetTapFDLabel(driver->securityManager,
                                            vm->def, tapfd[i]) < 0)
            goto cleanup;
    }

1066 1067
    if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0)
        goto cleanup;
1068

1069
    if (qemuDomainMachineIsS390CCW(vm->def) &&
1070 1071
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_CCW)) {
        net->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW;
1072 1073 1074
        if (!(ccwaddrs = qemuDomainCCWAddrSetCreateFromDomain(vm->def)))
            goto cleanup;
        if (virDomainCCWAddressAssign(&net->info, ccwaddrs,
J
Ján Tomko 已提交
1075
                                      !net->info.addr.ccw.assigned) < 0)
1076
            goto cleanup;
1077
    } else if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_S390)) {
1078
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
1079 1080
                       _("virtio-s390 net device cannot be hotplugged."));
        goto cleanup;
1081
    } else if (virDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0) {
1082 1083
        goto cleanup;
    }
1084

1085 1086
    releaseaddr = true;

1087
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
1088 1089 1090 1091 1092
        vlan = -1;
    } else {
        vlan = qemuDomainNetVLAN(net);

        if (vlan < 0) {
1093 1094
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Unable to attach network devices without vlan"));
1095 1096 1097 1098
            goto cleanup;
        }
    }

1099
    if (VIR_ALLOC_N(tapfdName, tapfdSize) < 0 ||
1100
        VIR_ALLOC_N(vhostfdName, vhostfdSize) < 0)
1101 1102 1103
        goto cleanup;

    for (i = 0; i < tapfdSize; i++) {
1104
        if (virAsprintf(&tapfdName[i], "fd-%s%zu", net->info.alias, i) < 0)
1105
            goto cleanup;
1106 1107
    }

1108
    for (i = 0; i < vhostfdSize; i++) {
1109
        if (virAsprintf(&vhostfdName[i], "vhostfd-%s%zu", net->info.alias, i) < 0)
1110
            goto cleanup;
1111 1112
    }

1113
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
1114
        if (!(netstr = qemuBuildHostNetStr(net, driver,
1115 1116 1117
                                           ',', -1,
                                           tapfdName, tapfdSize,
                                           vhostfdName, vhostfdSize)))
1118
            goto cleanup;
1119
    } else {
1120
        if (!(netstr = qemuBuildHostNetStr(net, driver,
1121 1122 1123
                                           ' ', vlan,
                                           tapfdName, tapfdSize,
                                           vhostfdName, vhostfdSize)))
1124
            goto cleanup;
1125 1126
    }

1127
    qemuDomainObjEnterMonitor(driver, vm);
1128
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
1129 1130 1131
        if (qemuMonitorAddNetdev(priv->mon, netstr,
                                 tapfd, tapfdName, tapfdSize,
                                 vhostfd, vhostfdName, vhostfdSize) < 0) {
1132
            ignore_value(qemuDomainObjExitMonitor(driver, vm));
1133
            virDomainAuditNet(vm, NULL, net, "attach", false);
1134
            goto cleanup;
1135 1136
        }
    } else {
1137 1138 1139
        if (qemuMonitorAddHostNetwork(priv->mon, netstr,
                                      tapfd, tapfdName, tapfdSize,
                                      vhostfd, vhostfdName, vhostfdSize) < 0) {
1140
            ignore_value(qemuDomainObjExitMonitor(driver, vm));
1141
            virDomainAuditNet(vm, NULL, net, "attach", false);
1142
            goto cleanup;
1143 1144
        }
    }
1145 1146
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
1147

1148 1149 1150 1151
    for (i = 0; i < tapfdSize; i++)
        VIR_FORCE_CLOSE(tapfd[i]);
    for (i = 0; i < vhostfdSize; i++)
        VIR_FORCE_CLOSE(vhostfd[i]);
1152

1153 1154 1155
    if (!(nicstr = qemuBuildNicDevStr(vm->def, net, vlan, 0,
                                      vhostfdSize, priv->qemuCaps)))
        goto try_remove;
1156

1157
    qemuDomainObjEnterMonitor(driver, vm);
1158 1159 1160 1161
    if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
        ignore_value(qemuDomainObjExitMonitor(driver, vm));
        virDomainAuditNet(vm, NULL, net, "attach", false);
        goto try_remove;
1162
    }
1163 1164
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
1165

1166 1167 1168
    /* set link state */
    if (net->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) {
        if (!net->info.alias) {
1169 1170
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("device alias not found: cannot set link state to down"));
1171
        } else {
1172
            qemuDomainObjEnterMonitor(driver, vm);
1173

1174
            if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
1175
                if (qemuMonitorSetLink(priv->mon, net->info.alias, VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) < 0) {
1176
                    ignore_value(qemuDomainObjExitMonitor(driver, vm));
1177 1178 1179 1180
                    virDomainAuditNet(vm, NULL, net, "attach", false);
                    goto try_remove;
                }
            } else {
1181
                virReportError(VIR_ERR_OPERATION_FAILED, "%s",
1182
                               _("setting of link state not supported: Link is up"));
1183 1184
            }

1185 1186
            if (qemuDomainObjExitMonitor(driver, vm) < 0)
                goto cleanup;
1187 1188 1189 1190
        }
        /* link set to down */
    }

1191
    virDomainAuditNet(vm, NULL, net, "attach", true);
1192 1193 1194

    ret = 0;

1195
 cleanup:
1196 1197 1198
    if (!ret) {
        vm->def->nets[vm->def->nnets++] = net;
    } else {
1199 1200
        if (releaseaddr)
            qemuDomainReleaseDeviceAddress(vm, &net->info, NULL);
1201

1202
        if (iface_connected) {
1203
            virDomainConfNWFilterTeardown(net);
1204

1205 1206 1207 1208 1209 1210 1211 1212 1213
            if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_DIRECT) {
                ignore_value(virNetDevMacVLanDeleteWithVPortProfile(
                                 net->ifname, &net->mac,
                                 virDomainNetGetActualDirectDev(net),
                                 virDomainNetGetActualDirectMode(net),
                                 virDomainNetGetActualVirtPortProfile(net),
                                 cfg->stateDir));
            }

1214
            vport = virDomainNetGetActualVirtPortProfile(net);
1215 1216 1217 1218 1219 1220 1221 1222 1223
            if (vport) {
                if (vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_MIDONET) {
                    ignore_value(virNetDevMidonetUnbindPort(vport));
                } else if (vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH) {
                    ignore_value(virNetDevOpenvswitchRemovePort(
                                     virDomainNetGetActualBridgeName(net),
                                     net->ifname));
                }
            }
1224
        }
A
Ansis Atteka 已提交
1225

1226 1227
        virDomainNetRemoveHostdev(vm->def, net);

1228
        networkReleaseActualDevice(vm->def, net);
1229
    }
1230 1231 1232

    VIR_FREE(nicstr);
    VIR_FREE(netstr);
1233
    for (i = 0; tapfd && i < tapfdSize; i++) {
1234
        VIR_FORCE_CLOSE(tapfd[i]);
1235 1236
        if (tapfdName)
            VIR_FREE(tapfdName[i]);
1237 1238 1239
    }
    VIR_FREE(tapfd);
    VIR_FREE(tapfdName);
1240
    for (i = 0; vhostfd && i < vhostfdSize; i++) {
1241
        VIR_FORCE_CLOSE(vhostfd[i]);
1242 1243
        if (vhostfdName)
            VIR_FREE(vhostfdName[i]);
1244 1245 1246
    }
    VIR_FREE(vhostfd);
    VIR_FREE(vhostfdName);
1247
    virObjectUnref(cfg);
1248
    virDomainCCWAddressSetFree(ccwaddrs);
1249 1250 1251

    return ret;

1252
 try_remove:
1253 1254 1255 1256
    if (!virDomainObjIsActive(vm))
        goto cleanup;

    if (vlan < 0) {
1257
        if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
1258 1259
            char *netdev_name;
            if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
1260
                goto cleanup;
1261
            qemuDomainObjEnterMonitor(driver, vm);
1262 1263 1264
            if (qemuMonitorRemoveNetdev(priv->mon, netdev_name) < 0)
                VIR_WARN("Failed to remove network backend for netdev %s",
                         netdev_name);
1265
            ignore_value(qemuDomainObjExitMonitor(driver, vm));
1266 1267
            VIR_FREE(netdev_name);
        } else {
1268
            VIR_WARN("Unable to remove network backend");
1269 1270 1271 1272
        }
    } else {
        char *hostnet_name;
        if (virAsprintf(&hostnet_name, "host%s", net->info.alias) < 0)
1273
            goto cleanup;
1274
        qemuDomainObjEnterMonitor(driver, vm);
1275 1276 1277
        if (qemuMonitorRemoveHostNetwork(priv->mon, vlan, hostnet_name) < 0)
            VIR_WARN("Failed to remove network backend for vlan %d, net %s",
                     vlan, hostnet_name);
1278
        ignore_value(qemuDomainObjExitMonitor(driver, vm));
1279 1280 1281 1282 1283 1284
        VIR_FREE(hostnet_name);
    }
    goto cleanup;
}


1285
static int
1286
qemuDomainAttachHostPCIDevice(virQEMUDriverPtr driver,
1287 1288
                              virDomainObjPtr vm,
                              virDomainHostdevDefPtr hostdev)
1289 1290 1291 1292 1293 1294
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int ret;
    char *devstr = NULL;
    int configfd = -1;
    char *configfd_name = NULL;
1295
    bool releaseaddr = false;
1296
    bool teardowncgroup = false;
1297
    bool teardownlabel = false;
1298
    int backend;
1299 1300
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    unsigned int flags = 0;
1301

1302
    if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs + 1) < 0)
1303
        goto cleanup;
1304

1305 1306
    if (!cfg->relaxedACS)
        flags |= VIR_HOSTDEV_STRICT_ACS_CHECK;
1307
    if (qemuHostdevPreparePCIDevices(driver, vm->def->name, vm->def->uuid,
1308 1309
                                     &hostdev, 1, priv->qemuCaps, flags) < 0)
        goto cleanup;
1310

1311
    /* this could have been changed by qemuHostdevPreparePCIDevices */
1312 1313
    backend = hostdev->source.subsys.u.pci.backend;

1314
    switch ((virDomainHostdevSubsysPCIBackendType) backend) {
1315
    case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO:
1316 1317 1318 1319 1320 1321
        if (!virQEMUCapsGet(priv->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;
        }
1322 1323
        break;

1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
    case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT:
    case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_KVM:
        break;

    case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_XEN:
    case VIR_DOMAIN_HOSTDEV_PCI_BACKEND_TYPE_LAST:
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("QEMU does not support device assignment mode '%s'"),
                       virDomainHostdevSubsysPCIBackendTypeToString(backend));
        goto error;
1334
        break;
1335 1336
    }

1337
    /* Temporarily add the hostdev to the domain definition. This is needed
1338 1339 1340 1341
     * because qemuDomainAdjustMaxMemLock() requires the hostdev to be already
     * part of the domain definition, but other functions like
     * qemuAssignDeviceHostdevAlias() used below expect it *not* to be there.
     * A better way to handle this would be nice */
1342
    vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
1343 1344 1345
    if (qemuDomainAdjustMaxMemLock(vm) < 0) {
        vm->def->hostdevs[--(vm->def->nhostdevs)] = NULL;
        goto error;
1346 1347 1348
    }
    vm->def->hostdevs[--(vm->def->nhostdevs)] = NULL;

1349
    if (qemuSetupHostdevCgroup(vm, hostdev) < 0)
1350 1351 1352
        goto error;
    teardowncgroup = true;

1353 1354 1355
    if (virSecurityManagerSetHostdevLabel(driver->securityManager,
                                          vm->def, hostdev, NULL) < 0)
        goto error;
1356 1357
    if (backend != VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO)
        teardownlabel = true;
1358

1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
    if (qemuAssignDeviceHostdevAlias(vm->def, &hostdev->info->alias, -1) < 0)
        goto error;
    if (virDomainPCIAddressEnsureAddr(priv->pciaddrs, hostdev->info) < 0)
        goto error;
    releaseaddr = true;
    if (backend != VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO &&
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
        configfd = qemuOpenPCIConfig(hostdev);
        if (configfd >= 0) {
            if (virAsprintf(&configfd_name, "fd-%s",
                            hostdev->info->alias) < 0)
                goto error;
1371
        }
1372
    }
1373

1374 1375 1376 1377 1378
    if (!virDomainObjIsActive(vm)) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("guest unexpectedly quit during hotplug"));
        goto error;
    }
1379

1380 1381 1382
    if (!(devstr = qemuBuildPCIHostdevDevStr(vm->def, hostdev, 0,
                                             configfd_name, priv->qemuCaps)))
        goto error;
1383

1384 1385 1386 1387 1388
    qemuDomainObjEnterMonitor(driver, vm);
    ret = qemuMonitorAddDeviceWithFd(priv->mon, devstr,
                                     configfd, configfd_name);
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto error;
1389

1390
    virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
1391 1392 1393 1394 1395 1396 1397 1398
    if (ret < 0)
        goto error;

    vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;

    VIR_FREE(devstr);
    VIR_FREE(configfd_name);
    VIR_FORCE_CLOSE(configfd);
1399
    virObjectUnref(cfg);
1400 1401 1402

    return 0;

1403
 error:
1404 1405
    if (teardowncgroup && qemuTeardownHostdevCgroup(vm, hostdev) < 0)
        VIR_WARN("Unable to remove host device cgroup ACL on hotplug fail");
1406 1407 1408 1409
    if (teardownlabel &&
        virSecurityManagerRestoreHostdevLabel(driver->securityManager,
                                              vm->def, hostdev, NULL) < 0)
        VIR_WARN("Unable to restore host device labelling on hotplug fail");
1410

1411 1412
    if (releaseaddr)
        qemuDomainReleaseDeviceAddress(vm, hostdev->info, NULL);
1413

1414
    qemuHostdevReAttachPCIDevices(driver, vm->def->name, &hostdev, 1);
1415 1416 1417 1418 1419

    VIR_FREE(devstr);
    VIR_FREE(configfd_name);
    VIR_FORCE_CLOSE(configfd);

1420
 cleanup:
1421
    virObjectUnref(cfg);
1422 1423 1424 1425
    return -1;
}


1426
int qemuDomainAttachRedirdevDevice(virQEMUDriverPtr driver,
1427 1428 1429
                                   virDomainObjPtr vm,
                                   virDomainRedirdevDefPtr redirdev)
{
1430
    int ret = -1;
1431
    qemuDomainObjPrivatePtr priv = vm->privateData;
1432
    virDomainDefPtr def = vm->def;
1433
    char *charAlias = NULL;
1434 1435
    char *devstr = NULL;

1436
    if (qemuAssignDeviceRedirdevAlias(def, redirdev, -1) < 0)
1437 1438 1439 1440 1441
        goto cleanup;

    if (virAsprintf(&charAlias, "char%s", redirdev->info.alias) < 0)
        goto cleanup;

1442
    if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, priv->qemuCaps)))
1443
        goto cleanup;
1444

1445
    if (VIR_REALLOC_N(def->redirdevs, def->nredirdevs+1) < 0)
1446
        goto cleanup;
1447

1448
    qemuDomainObjEnterMonitor(driver, vm);
1449 1450 1451 1452 1453 1454
    if (qemuMonitorAttachCharDev(priv->mon,
                                 charAlias,
                                 &(redirdev->source.chr)) < 0) {
        ignore_value(qemuDomainObjExitMonitor(driver, vm));
        goto audit;
    }
1455

1456 1457 1458 1459 1460 1461
    if (qemuMonitorAddDevice(priv->mon, devstr) < 0) {
        /* detach associated chardev on error */
        qemuMonitorDetachCharDev(priv->mon, charAlias);
        ignore_value(qemuDomainObjExitMonitor(driver, vm));
        goto audit;
    }
1462

1463 1464
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto audit;
1465

1466
    def->redirdevs[def->nredirdevs++] = redirdev;
1467 1468 1469 1470 1471
    ret = 0;
 audit:
    virDomainAuditRedirdev(vm, redirdev, "attach", ret == 0);
 cleanup:
    VIR_FREE(charAlias);
1472
    VIR_FREE(devstr);
1473
    return ret;
1474 1475
}

1476 1477 1478
static int
qemuDomainChrPreInsert(virDomainDefPtr vmdef,
                       virDomainChrDefPtr chr)
1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492
{
    if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
        chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
                       _("attaching serial console is not supported"));
        return -1;
    }

    if (virDomainChrFind(vmdef, chr)) {
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("chardev already exists"));
        return -1;
    }

1493
    if (virDomainChrPreAlloc(vmdef, chr) < 0)
1494 1495 1496 1497 1498
        return -1;

    /* Due to some crazy backcompat stuff, the first serial device is an alias
     * to the first console too. If this is the case, the definition must be
     * duplicated as first console device. */
1499 1500 1501 1502 1503 1504 1505
    if (vmdef->nserials == 0 && vmdef->nconsoles == 0 &&
        chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL) {
        if (!vmdef->consoles && VIR_ALLOC(vmdef->consoles) < 0)
            return -1;

        if (VIR_ALLOC(vmdef->consoles[0]) < 0) {
            VIR_FREE(vmdef->consoles);
1506 1507
            return -1;
        }
1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
        vmdef->nconsoles++;
    }
    return 0;
}

static void
qemuDomainChrInsertPreAlloced(virDomainDefPtr vmdef,
                              virDomainChrDefPtr chr)
{
    virDomainChrInsertPreAlloced(vmdef, chr);
    if (vmdef->nserials == 1 && vmdef->nconsoles == 0 &&
        chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL) {
1520 1521 1522 1523 1524 1525
        vmdef->nconsoles = 1;

        /* Create an console alias for the serial port */
        vmdef->consoles[0]->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE;
        vmdef->consoles[0]->targetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL;
    }
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
}

static void
qemuDomainChrInsertPreAllocCleanup(virDomainDefPtr vmdef,
                                   virDomainChrDefPtr chr)
{
    /* Remove the stub console added by qemuDomainChrPreInsert */
    if (vmdef->nserials == 0 && vmdef->nconsoles == 1 &&
        chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL) {
        VIR_FREE(vmdef->consoles[0]);
        VIR_FREE(vmdef->consoles);
        vmdef->nconsoles = 0;
    }
}
1540

1541 1542 1543 1544 1545 1546 1547 1548 1549
int
qemuDomainChrInsert(virDomainDefPtr vmdef,
                    virDomainChrDefPtr chr)
{
    if (qemuDomainChrPreInsert(vmdef, chr) < 0) {
        qemuDomainChrInsertPreAllocCleanup(vmdef, chr);
        return -1;
    }
    qemuDomainChrInsertPreAlloced(vmdef, chr);
1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
    return 0;
}

virDomainChrDefPtr
qemuDomainChrRemove(virDomainDefPtr vmdef,
                    virDomainChrDefPtr chr)
{
    virDomainChrDefPtr ret;
    bool removeCompat;

    if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
        chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL) {
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("detaching serial console is not supported"));
        return NULL;
    }

    /* Due to some crazy backcompat stuff, the first serial device is an alias
     * to the first console too. If this is the case, the definition must be
     * duplicated as first console device. */
    removeCompat = vmdef->nserials && vmdef->nconsoles &&
        vmdef->consoles[0]->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
        vmdef->consoles[0]->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL &&
        virDomainChrEquals(vmdef->serials[0], chr);

    if (!(ret = virDomainChrRemove(vmdef, chr))) {
        virReportError(VIR_ERR_INVALID_ARG, "%s",
                       _("device not present in domain configuration"));
            return NULL;
    }

    if (removeCompat)
        VIR_DELETE_ELEMENT(vmdef->consoles, 0, vmdef->nconsoles);

    return ret;
}
1586

1587
static int
1588 1589
qemuDomainAttachChrDeviceAssignAddr(virDomainDefPtr def,
                                    qemuDomainObjPrivatePtr priv,
1590 1591
                                    virDomainChrDefPtr chr)
{
1592 1593 1594 1595 1596 1597
    int ret = -1;
    virDomainVirtioSerialAddrSetPtr vioaddrs = NULL;

    if (!(vioaddrs = virDomainVirtioSerialAddrSetCreateFromDomain(def)))
        goto cleanup;

1598 1599
    if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
        chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO) {
1600
        if (virDomainVirtioSerialAddrAutoAssign(NULL, vioaddrs,
1601
                                                &chr->info, true) < 0)
1602 1603
            goto cleanup;
        ret = 1;
1604 1605 1606 1607

    } else if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL &&
               chr->targetType == VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_PCI) {
        if (virDomainPCIAddressEnsureAddr(priv->pciaddrs, &chr->info) < 0)
1608 1609
            goto cleanup;
        ret = 1;
1610

1611 1612 1613
    } else if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL &&
               chr->targetType == VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_USB) {
        if (virDomainUSBAddressEnsure(priv->usbaddrs, &chr->info) < 0)
1614 1615
            goto cleanup;
        ret = 1;
1616

1617 1618
    } else if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
               chr->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO) {
1619
        if (virDomainVirtioSerialAddrAutoAssign(NULL, vioaddrs,
1620
                                                &chr->info, false) < 0)
1621 1622
            goto cleanup;
        ret = 1;
1623 1624
    }

1625 1626 1627
    if (ret == 1)
        goto cleanup;

1628 1629 1630 1631
    if (chr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL ||
        chr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Unsupported address type for character device"));
1632
        goto cleanup;
1633 1634
    }

1635 1636 1637 1638 1639
    ret = 0;

 cleanup:
    virDomainVirtioSerialAddrSetFree(vioaddrs);
    return ret;
1640 1641
}

1642 1643 1644 1645
int qemuDomainAttachChrDevice(virQEMUDriverPtr driver,
                              virDomainObjPtr vm,
                              virDomainChrDefPtr chr)
{
1646
    int ret = -1, rc;
1647
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
1648
    qemuDomainObjPrivatePtr priv = vm->privateData;
1649
    virErrorPtr orig_err;
1650 1651
    virDomainDefPtr vmdef = vm->def;
    char *devstr = NULL;
1652
    virDomainChrSourceDefPtr dev = &chr->source;
1653
    char *charAlias = NULL;
1654
    bool chardevAttached = false;
1655 1656 1657
    bool tlsobjAdded = false;
    virJSONValuePtr tlsProps = NULL;
    char *tlsAlias = NULL;
1658
    bool need_release = false;
1659

1660 1661 1662 1663
    if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
        qemuDomainPrepareChannel(chr, priv->channelTargetDir) < 0)
        goto cleanup;

1664
    if (qemuAssignDeviceChrAlias(vmdef, chr, -1) < 0)
1665
        goto cleanup;
1666

1667
    if ((rc = qemuDomainAttachChrDeviceAssignAddr(vm->def, priv, chr)) < 0)
1668 1669 1670
        goto cleanup;
    if (rc == 1)
        need_release = true;
1671

1672
    if (qemuBuildChrDeviceStr(&devstr, vmdef, chr, priv->qemuCaps) < 0)
1673
        goto cleanup;
1674

J
Ján Tomko 已提交
1675
    if (virAsprintf(&charAlias, "char%s", chr->info.alias) < 0)
1676 1677
        goto cleanup;

1678
    if (qemuDomainChrPreInsert(vmdef, chr) < 0)
1679 1680
        goto cleanup;

1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
    if (cfg->chardevTLS) {
        if (qemuBuildTLSx509BackendProps(cfg->chardevTLSx509certdir,
                                         dev->data.tcp.listen,
                                         cfg->chardevTLSx509verify,
                                         priv->qemuCaps,
                                         &tlsProps) < 0)
            goto cleanup;

        if (!(tlsAlias = qemuAliasTLSObjFromChardevAlias(chr->info.alias)))
            goto cleanup;
        dev->data.tcp.tlscreds = true;
    }

1694
    qemuDomainObjEnterMonitor(driver, vm);
1695 1696 1697 1698 1699 1700 1701 1702 1703
    if (tlsAlias) {
        rc = qemuMonitorAddObject(priv->mon, "tls-creds-x509",
                                  tlsAlias, tlsProps);
        tlsProps = NULL; /* qemuMonitorAddObject consumes */
        if (rc < 0)
            goto exit_monitor;
        tlsobjAdded = true;
    }

1704
    if (qemuMonitorAttachCharDev(priv->mon, charAlias, &chr->source) < 0)
1705 1706
        goto exit_monitor;
    chardevAttached = true;
1707 1708

    if (qemuMonitorAddDevice(priv->mon, devstr) < 0)
1709
        goto exit_monitor;
1710

1711 1712
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto audit;
1713

1714
    qemuDomainChrInsertPreAlloced(vmdef, chr);
1715
    ret = 0;
1716 1717
 audit:
    virDomainAuditChardev(vm, NULL, chr, "attach", ret == 0);
1718
 cleanup:
1719
    if (ret < 0 && virDomainObjIsActive(vm))
1720
        qemuDomainChrInsertPreAllocCleanup(vmdef, chr);
1721 1722
    if (ret < 0 && need_release)
        qemuDomainReleaseDeviceAddress(vm, &chr->info, NULL);
1723 1724
    VIR_FREE(tlsAlias);
    virJSONValueFree(tlsProps);
1725 1726
    VIR_FREE(charAlias);
    VIR_FREE(devstr);
1727
    virObjectUnref(cfg);
1728
    return ret;
1729

1730 1731
 exit_monitor:
    orig_err = virSaveLastError();
1732 1733
    if (tlsobjAdded)
        ignore_value(qemuMonitorDelObject(priv->mon, tlsAlias));
1734
    /* detach associated chardev on error */
1735 1736 1737 1738 1739 1740 1741
    if (chardevAttached)
        qemuMonitorDetachCharDev(priv->mon, charAlias);
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
    }

1742 1743
    ignore_value(qemuDomainObjExitMonitor(driver, vm));
    goto audit;
1744 1745
}

1746 1747 1748 1749 1750 1751 1752

int
qemuDomainAttachRNGDevice(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
                          virDomainRNGDefPtr rng)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
1753
    virErrorPtr orig_err;
1754 1755 1756
    char *devstr = NULL;
    char *charAlias = NULL;
    char *objAlias = NULL;
1757 1758 1759
    bool releaseaddr = false;
    bool chardevAdded = false;
    bool objAdded = false;
1760
    virJSONValuePtr props = NULL;
1761
    virDomainCCWAddressSetPtr ccwaddrs = NULL;
1762 1763
    const char *type;
    int ret = -1;
1764
    int rv;
1765

1766
    if (qemuAssignDeviceRNGAlias(vm->def, rng) < 0)
1767 1768 1769 1770 1771 1772 1773
        return -1;

    /* preallocate space for the device definition */
    if (VIR_REALLOC_N(vm->def->rngs, vm->def->nrngs + 1) < 0)
        return -1;

    if (rng->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
1774
        if (qemuDomainMachineIsS390CCW(vm->def) &&
1775 1776 1777 1778 1779
            virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_CCW)) {
            rng->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW;
        } else if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_S390)) {
            rng->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390;
        }
1780 1781 1782 1783
    } else {
        if (!qemuCheckCCWS390AddressSupport(vm->def, rng->info, priv->qemuCaps,
                                            rng->source.file))
            return -1;
1784
    }
1785
    releaseaddr = true;
1786 1787 1788 1789 1790 1791

    if (rng->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE ||
        rng->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
        if (virDomainPCIAddressEnsureAddr(priv->pciaddrs, &rng->info) < 0)
            return -1;
    } else if (rng->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
1792 1793 1794
        if (!(ccwaddrs = qemuDomainCCWAddrSetCreateFromDomain(vm->def)))
            goto cleanup;
        if (virDomainCCWAddressAssign(&rng->info, ccwaddrs,
1795
                                      !rng->info.addr.ccw.assigned) < 0)
1796
            goto cleanup;
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
    }

    /* build required metadata */
    if (!(devstr = qemuBuildRNGDevStr(vm->def, rng, priv->qemuCaps)))
        goto cleanup;

    if (qemuBuildRNGBackendProps(rng, priv->qemuCaps, &type, &props) < 0)
        goto cleanup;

    if (virAsprintf(&objAlias, "obj%s", rng->info.alias) < 0)
        goto cleanup;

    if (virAsprintf(&charAlias, "char%s", rng->info.alias) < 0)
        goto cleanup;

    qemuDomainObjEnterMonitor(driver, vm);

    if (rng->backend == VIR_DOMAIN_RNG_BACKEND_EGD &&
        qemuMonitorAttachCharDev(priv->mon, charAlias,
                                 rng->source.chardev) < 0)
1817 1818
        goto exit_monitor;
    chardevAdded = true;
1819

1820 1821 1822 1823 1824
    rv = qemuMonitorAddObject(priv->mon, type, objAlias, props);
    props = NULL; /* qemuMonitorAddObject consumes */
    if (rv < 0)
        goto exit_monitor;
    objAdded = true;
1825 1826

    if (qemuMonitorAddDevice(priv->mon, devstr) < 0)
1827
        goto exit_monitor;
1828 1829

    if (qemuDomainObjExitMonitor(driver, vm) < 0) {
1830
        releaseaddr = false;
1831 1832 1833
        goto cleanup;
    }

1834
    VIR_APPEND_ELEMENT_INPLACE(vm->def->rngs, vm->def->nrngs, rng);
1835 1836 1837 1838 1839 1840

    ret = 0;

 audit:
    virDomainAuditRNG(vm, NULL, rng, "attach", ret == 0);
 cleanup:
1841
    virJSONValueFree(props);
1842
    if (ret < 0 && releaseaddr)
1843 1844 1845 1846
        qemuDomainReleaseDeviceAddress(vm, &rng->info, NULL);
    VIR_FREE(charAlias);
    VIR_FREE(objAlias);
    VIR_FREE(devstr);
1847
    virDomainCCWAddressSetFree(ccwaddrs);
1848 1849
    return ret;

1850 1851 1852 1853 1854
 exit_monitor:
    orig_err = virSaveLastError();
    if (objAdded)
        ignore_value(qemuMonitorDelObject(priv->mon, objAlias));
    if (rng->backend == VIR_DOMAIN_RNG_BACKEND_EGD && chardevAdded)
1855
        ignore_value(qemuMonitorDetachCharDev(priv->mon, charAlias));
1856 1857 1858
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
1859 1860
    }

1861 1862
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        releaseaddr = false;
1863 1864 1865 1866
    goto audit;
}


1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
/**
 * qemuDomainAttachMemory:
 * @driver: qemu driver data
 * @vm: VM object
 * @mem: Definition of the memory device to be attached. @mem is always consumed
 *
 * Attaches memory device described by @mem to domain @vm.
 *
 * Returns 0 on success -1 on error.
 */
int
qemuDomainAttachMemory(virQEMUDriverPtr driver,
                       virDomainObjPtr vm,
                       virDomainMemoryDefPtr mem)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
1883
    virErrorPtr orig_err;
1884
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
1885
    unsigned long long oldmem = virDomainDefGetMemoryTotal(vm->def);
1886
    unsigned long long newmem = oldmem + mem->size;
1887 1888 1889
    char *devstr = NULL;
    char *objalias = NULL;
    const char *backendType;
1890
    bool objAdded = false;
1891
    virJSONValuePtr props = NULL;
1892
    virObjectEventPtr event;
1893 1894
    int id;
    int ret = -1;
1895
    int rv;
1896

1897 1898 1899
    qemuDomainMemoryDeviceAlignSize(vm->def, mem);

    if (qemuDomainDefValidateMemoryHotplug(vm->def, priv->qemuCaps, mem) < 0)
1900 1901
        goto cleanup;

1902
    if (qemuAssignDeviceMemoryAlias(vm->def, mem) < 0)
1903 1904 1905 1906 1907
        goto cleanup;

    if (virAsprintf(&objalias, "mem%s", mem->info.alias) < 0)
        goto cleanup;

1908
    if (!(devstr = qemuBuildMemoryDeviceStr(mem)))
1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
        goto cleanup;

    if (qemuBuildMemoryBackendStr(mem->size, mem->pagesize,
                                  mem->targetNode, mem->sourceNodes, NULL,
                                  vm->def, priv->qemuCaps, cfg,
                                  &backendType, &props, true) < 0)
        goto cleanup;

    if (virDomainMemoryInsert(vm->def, mem) < 0) {
        virJSONValueFree(props);
        goto cleanup;
    }

1922
    if (qemuDomainAdjustMaxMemLock(vm) < 0) {
1923 1924 1925 1926
        virJSONValueFree(props);
        goto removedef;
    }

1927
    qemuDomainObjEnterMonitor(driver, vm);
1928 1929 1930
    rv = qemuMonitorAddObject(priv->mon, backendType, objalias, props);
    props = NULL; /* qemuMonitorAddObject consumes */
    if (rv < 0)
1931
        goto exit_monitor;
1932
    objAdded = true;
1933

1934
    if (qemuMonitorAddDevice(priv->mon, devstr) < 0)
1935
        goto exit_monitor;
1936 1937 1938 1939

    if (qemuDomainObjExitMonitor(driver, vm) < 0) {
        /* we shouldn't touch mem now, as the def might be freed */
        mem = NULL;
1940
        goto audit;
1941 1942
    }

1943
    event = virDomainEventDeviceAddedNewFromObj(vm, objalias);
1944
    qemuDomainEventQueue(driver, event);
1945

1946 1947
    /* fix the balloon size */
    ignore_value(qemuProcessRefreshBalloonState(driver, vm, QEMU_ASYNC_JOB_NONE));
1948

1949 1950 1951 1952 1953 1954 1955 1956 1957
    /* mem is consumed by vm->def */
    mem = NULL;

    /* this step is best effort, removing the device would be so much trouble */
    ignore_value(qemuDomainUpdateMemoryDeviceInfo(driver, vm,
                                                  QEMU_ASYNC_JOB_NONE));

    ret = 0;

1958 1959
 audit:
    virDomainAuditMemory(vm, oldmem, newmem, "update", ret == 0);
1960 1961 1962 1963 1964 1965 1966
 cleanup:
    virObjectUnref(cfg);
    VIR_FREE(devstr);
    VIR_FREE(objalias);
    virDomainMemoryDefFree(mem);
    return ret;

1967
 exit_monitor:
1968 1969 1970 1971 1972 1973 1974
    orig_err = virSaveLastError();
    if (objAdded)
        ignore_value(qemuMonitorDelObject(priv->mon, objalias));
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
    }
1975 1976
    if (qemuDomainObjExitMonitor(driver, vm) < 0) {
        mem = NULL;
1977
        goto audit;
1978 1979
    }

1980
 removedef:
1981 1982 1983 1984 1985
    if ((id = virDomainMemoryFindByDef(vm->def, mem)) >= 0)
        mem = virDomainMemoryRemove(vm->def, id);
    else
        mem = NULL;

1986
    /* reset the mlock limit */
1987
    orig_err = virSaveLastError();
1988
    ignore_value(qemuDomainAdjustMaxMemLock(vm));
1989 1990
    virSetError(orig_err);
    virFreeError(orig_err);
1991

1992
    goto audit;
1993 1994 1995
}


1996
static int
1997
qemuDomainAttachHostUSBDevice(virQEMUDriverPtr driver,
1998 1999
                              virDomainObjPtr vm,
                              virDomainHostdevDefPtr hostdev)
2000 2001 2002
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    char *devstr = NULL;
2003
    bool releaseaddr = false;
2004
    bool added = false;
2005
    bool teardowncgroup = false;
2006
    bool teardownlabel = false;
2007 2008
    int ret = -1;

2009 2010 2011 2012 2013 2014
    if (priv->usbaddrs) {
        if (virDomainUSBAddressEnsure(priv->usbaddrs, hostdev->info) < 0)
            goto cleanup;
        releaseaddr = true;
    }

2015
    if (qemuHostdevPrepareUSBDevices(driver, vm->def->name, &hostdev, 1, 0) < 0)
2016 2017 2018
        goto cleanup;

    added = true;
2019

2020
    if (qemuSetupHostdevCgroup(vm, hostdev) < 0)
2021 2022 2023
        goto cleanup;
    teardowncgroup = true;

2024 2025 2026 2027 2028
    if (virSecurityManagerSetHostdevLabel(driver->securityManager,
                                          vm->def, hostdev, NULL) < 0)
        goto cleanup;
    teardownlabel = true;

2029 2030 2031 2032
    if (qemuAssignDeviceHostdevAlias(vm->def, &hostdev->info->alias, -1) < 0)
        goto cleanup;
    if (!(devstr = qemuBuildUSBHostdevDevStr(vm->def, hostdev, priv->qemuCaps)))
        goto cleanup;
2033

2034
    if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0)
2035
        goto cleanup;
2036

2037
    qemuDomainObjEnterMonitor(driver, vm);
2038
    ret = qemuMonitorAddDevice(priv->mon, devstr);
2039 2040 2041 2042
    if (qemuDomainObjExitMonitor(driver, vm) < 0) {
        ret = -1;
        goto cleanup;
    }
2043
    virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
2044
    if (ret < 0)
2045
        goto cleanup;
2046 2047 2048

    vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;

2049
    ret = 0;
2050
 cleanup:
2051 2052 2053 2054 2055 2056 2057
    if (ret < 0) {
        if (teardowncgroup && qemuTeardownHostdevCgroup(vm, hostdev) < 0)
            VIR_WARN("Unable to remove host device cgroup ACL on hotplug fail");
        if (teardownlabel &&
            virSecurityManagerRestoreHostdevLabel(driver->securityManager,
                                                  vm->def, hostdev, NULL) < 0)
            VIR_WARN("Unable to restore host device labelling on hotplug fail");
2058
        if (added)
2059
            qemuHostdevReAttachUSBDevices(driver, vm->def->name, &hostdev, 1);
2060 2061
        if (releaseaddr)
            virDomainUSBAddressRelease(priv->usbaddrs, hostdev->info);
2062
    }
2063
    VIR_FREE(devstr);
2064
    return ret;
2065 2066
}

2067

2068
static int
2069 2070
qemuDomainAttachHostSCSIDevice(virConnectPtr conn,
                               virQEMUDriverPtr driver,
2071 2072 2073
                               virDomainObjPtr vm,
                               virDomainHostdevDefPtr hostdev)
{
2074
    size_t i;
2075 2076
    int ret = -1;
    qemuDomainObjPrivatePtr priv = vm->privateData;
2077
    virErrorPtr orig_err;
2078 2079
    char *devstr = NULL;
    char *drvstr = NULL;
2080
    char *drivealias = NULL;
2081
    bool teardowncgroup = false;
2082
    bool teardownlabel = false;
2083
    bool driveAdded = false;
2084

2085
    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE_SCSI_GENERIC)) {
2086 2087 2088 2089 2090
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("SCSI passthrough is not supported by this version of qemu"));
        return -1;
    }

2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101
    /* Let's make sure the disk has a controller defined and loaded before
     * trying to add it. The controller used by the disk must exist before a
     * qemu command line string is generated.
     *
     * Ensure that the given controller and all controllers with a smaller index
     * exist; there must not be any missing index in between.
     */
    for (i = 0; i <= hostdev->info->addr.drive.controller; i++) {
        if (!qemuDomainFindOrCreateSCSIDiskController(driver, vm, i))
            return -1;
    }
2102

2103
    if (qemuHostdevPrepareSCSIDevices(driver, vm->def->name,
2104
                                      &hostdev, 1)) {
2105
        virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
2106 2107 2108 2109 2110 2111 2112 2113
        if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
            virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unable to prepare scsi hostdev for iSCSI: %s"),
                           iscsisrc->path);
        } else {
            virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
            virReportError(VIR_ERR_INTERNAL_ERROR,
2114
                           _("Unable to prepare scsi hostdev: %s:%u:%u:%llu"),
2115 2116 2117
                           scsihostsrc->adapter, scsihostsrc->bus,
                           scsihostsrc->target, scsihostsrc->unit);
        }
2118 2119 2120
        return -1;
    }

2121
    if (qemuSetupHostdevCgroup(vm, hostdev) < 0)
2122 2123 2124
        goto cleanup;
    teardowncgroup = true;

2125 2126 2127 2128 2129
    if (virSecurityManagerSetHostdevLabel(driver->securityManager,
                                          vm->def, hostdev, NULL) < 0)
        goto cleanup;
    teardownlabel = true;

2130
    if (qemuAssignDeviceHostdevAlias(vm->def, &hostdev->info->alias, -1) < 0)
2131 2132
        goto cleanup;

J
John Ferlan 已提交
2133
    if (qemuDomainSecretHostdevPrepare(conn, priv, hostdev) < 0)
2134 2135
        goto cleanup;

2136
    if (!(drvstr = qemuBuildSCSIHostdevDrvStr(hostdev)))
2137 2138
        goto cleanup;

2139 2140 2141
    if (!(drivealias = qemuAliasFromHostdev(hostdev)))
        goto cleanup;

2142 2143 2144
    if (!(devstr = qemuBuildSCSIHostdevDevStr(vm->def, hostdev, priv->qemuCaps)))
        goto cleanup;

2145
    if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs + 1) < 0)
2146 2147 2148 2149
        goto cleanup;

    qemuDomainObjEnterMonitor(driver, vm);

2150
    if (qemuMonitorAddDrive(priv->mon, drvstr) < 0)
2151 2152
        goto exit_monitor;
    driveAdded = true;
2153 2154

    if (qemuMonitorAddDevice(priv->mon, devstr) < 0)
2155
        goto exit_monitor;
2156 2157

    if (qemuDomainObjExitMonitor(driver, vm) < 0)
2158
        goto cleanup;
2159 2160

    virDomainAuditHostdev(vm, hostdev, "attach", true);
2161 2162 2163 2164

    vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;

    ret = 0;
2165

2166
 cleanup:
2167
    qemuDomainSecretHostdevDestroy(hostdev);
2168
    if (ret < 0) {
2169
        qemuHostdevReAttachSCSIDevices(driver, vm->def->name, &hostdev, 1);
2170 2171
        if (teardowncgroup && qemuTeardownHostdevCgroup(vm, hostdev) < 0)
            VIR_WARN("Unable to remove host device cgroup ACL on hotplug fail");
2172 2173 2174 2175
        if (teardownlabel &&
            virSecurityManagerRestoreHostdevLabel(driver->securityManager,
                                                  vm->def, hostdev, NULL) < 0)
            VIR_WARN("Unable to restore host device labelling on hotplug fail");
2176
    }
2177
    VIR_FREE(drivealias);
2178 2179 2180
    VIR_FREE(drvstr);
    VIR_FREE(devstr);
    return ret;
2181

2182
 exit_monitor:
2183
    orig_err = virSaveLastError();
2184
    if (driveAdded && qemuMonitorDriveDel(priv->mon, drivealias) < 0) {
2185 2186 2187
        VIR_WARN("Unable to remove drive %s (%s) after failed "
                 "qemuMonitorAddDevice",
                 drvstr, devstr);
2188
    }
2189 2190 2191 2192 2193 2194 2195 2196 2197
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
    }

    ignore_value(qemuDomainObjExitMonitor(driver, vm));
    virDomainAuditHostdev(vm, hostdev, "attach", false);

    goto cleanup;
2198 2199
}

2200 2201 2202 2203 2204 2205

int
qemuDomainAttachHostDevice(virConnectPtr conn,
                           virQEMUDriverPtr driver,
                           virDomainObjPtr vm,
                           virDomainHostdevDefPtr hostdev)
2206 2207
{
    if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
2208 2209 2210
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("hostdev mode '%s' not supported"),
                       virDomainHostdevModeTypeToString(hostdev->mode));
2211 2212 2213 2214 2215
        return -1;
    }

    switch (hostdev->source.subsys.type) {
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
2216
        if (qemuDomainAttachHostPCIDevice(driver, vm,
2217
                                          hostdev) < 0)
2218 2219 2220 2221
            goto error;
        break;

    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
2222
        if (qemuDomainAttachHostUSBDevice(driver, vm,
2223
                                          hostdev) < 0)
2224 2225 2226
            goto error;
        break;

2227
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI:
2228
        if (qemuDomainAttachHostSCSIDevice(conn, driver, vm,
2229 2230 2231 2232
                                           hostdev) < 0)
            goto error;
        break;

2233
    default:
2234 2235 2236
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("hostdev subsys type '%s' not supported"),
                       virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
2237 2238 2239 2240 2241
        goto error;
    }

    return 0;

2242
 error:
2243 2244 2245
    return -1;
}

2246
static int
2247
qemuDomainChangeNetBridge(virDomainObjPtr vm,
2248 2249
                          virDomainNetDefPtr olddev,
                          virDomainNetDefPtr newdev)
2250 2251
{
    int ret = -1;
2252 2253
    const char *oldbridge = virDomainNetGetActualBridgeName(olddev);
    const char *newbridge = virDomainNetGetActualBridgeName(newdev);
2254

2255 2256
    if (!oldbridge || !newbridge) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Missing bridge name"));
2257
        goto cleanup;
2258
    }
2259 2260 2261 2262 2263

    VIR_DEBUG("Change bridge for interface %s: %s -> %s",
              olddev->ifname, oldbridge, newbridge);

    if (virNetDevExists(newbridge) != 1) {
2264 2265
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("bridge %s doesn't exist"), newbridge);
2266
        goto cleanup;
2267 2268 2269 2270 2271
    }

    if (oldbridge) {
        ret = virNetDevBridgeRemovePort(oldbridge, olddev->ifname);
        virDomainAuditNet(vm, olddev, NULL, "detach", ret == 0);
2272 2273 2274 2275 2276 2277 2278 2279
        if (ret < 0) {
            /* warn but continue - possibly the old network
             * had been destroyed and reconstructed, leaving the
             * tap device orphaned.
             */
            VIR_WARN("Unable to detach device %s from bridge %s",
                     olddev->ifname, oldbridge);
        }
2280 2281 2282
    }

    ret = virNetDevBridgeAddPort(newbridge, olddev->ifname);
2283
    virDomainAuditNet(vm, NULL, newdev, "attach", ret == 0);
2284 2285 2286 2287
    if (ret < 0) {
        ret = virNetDevBridgeAddPort(oldbridge, olddev->ifname);
        virDomainAuditNet(vm, NULL, olddev, "attach", ret == 0);
        if (ret < 0) {
2288
            virReportError(VIR_ERR_OPERATION_FAILED,
2289
                           _("unable to recover former state by adding port "
2290
                             "to bridge %s"), oldbridge);
2291
        }
2292
        goto cleanup;
2293
    }
2294 2295
    /* caller will replace entire olddev with newdev in domain nets list */
    ret = 0;
2296
 cleanup:
2297
    return ret;
2298 2299
}

2300
static int
2301
qemuDomainChangeNetFilter(virDomainObjPtr vm,
2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319
                          virDomainNetDefPtr olddev,
                          virDomainNetDefPtr newdev)
{
    /* make sure this type of device supports filters. */
    switch (virDomainNetGetActualType(newdev)) {
    case VIR_DOMAIN_NET_TYPE_ETHERNET:
    case VIR_DOMAIN_NET_TYPE_BRIDGE:
    case VIR_DOMAIN_NET_TYPE_NETWORK:
        break;
    default:
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("filters not supported on interfaces of type %s"),
                       virDomainNetTypeToString(virDomainNetGetActualType(newdev)));
        return -1;
    }

    virDomainConfNWFilterTeardown(olddev);

2320
    if (newdev->filter &&
2321
        virDomainConfNWFilterInstantiate(vm->def->uuid, newdev) < 0) {
2322 2323 2324 2325 2326 2327 2328
        virErrorPtr errobj;

        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("failed to add new filter rules to '%s' "
                         "- attempting to restore old rules"),
                       olddev->ifname);
        errobj = virSaveLastError();
2329
        ignore_value(virDomainConfNWFilterInstantiate(vm->def->uuid, olddev));
2330 2331 2332 2333 2334 2335 2336
        virSetError(errobj);
        virFreeError(errobj);
        return -1;
    }
    return 0;
}

2337
int qemuDomainChangeNetLinkState(virQEMUDriverPtr driver,
2338 2339 2340 2341 2342 2343 2344 2345
                                 virDomainObjPtr vm,
                                 virDomainNetDefPtr dev,
                                 int linkstate)
{
    int ret = -1;
    qemuDomainObjPrivatePtr priv = vm->privateData;

    if (!dev->info.alias) {
2346 2347
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("can't change link state: device alias not found"));
2348 2349 2350
        return -1;
    }

2351 2352
    VIR_DEBUG("dev: %s, state: %d", dev->info.alias, linkstate);

2353
    qemuDomainObjEnterMonitor(driver, vm);
2354 2355 2356 2357 2358 2359 2360 2361

    ret = qemuMonitorSetLink(priv->mon, dev->info.alias, linkstate);
    if (ret < 0)
        goto cleanup;

    /* modify the device configuration */
    dev->linkstate = linkstate;

2362
 cleanup:
2363 2364
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
2365 2366 2367 2368

    return ret;
}

2369
int
2370
qemuDomainChangeNet(virQEMUDriverPtr driver,
2371 2372
                    virDomainObjPtr vm,
                    virDomainDeviceDefPtr dev)
2373
{
2374
    virDomainNetDefPtr newdev = dev->data.net;
2375
    virDomainNetDefPtr *devslot = NULL;
2376 2377 2378 2379
    virDomainNetDefPtr olddev;
    int oldType, newType;
    bool needReconnect = false;
    bool needBridgeChange = false;
2380
    bool needFilterChange = false;
2381 2382
    bool needLinkStateChange = false;
    bool needReplaceDevDef = false;
2383
    bool needBandwidthSet = false;
2384
    int ret = -1;
2385 2386 2387 2388 2389
    int changeidx = -1;

    if ((changeidx = virDomainNetFindIdx(vm->def, newdev)) < 0)
        goto cleanup;
    devslot = &vm->def->nets[changeidx];
2390

2391
    if (!(olddev = *devslot)) {
2392
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
2393
                       _("cannot find existing network device to modify"));
2394 2395 2396 2397 2398 2399
        goto cleanup;
    }

    oldType = virDomainNetGetActualType(olddev);
    if (oldType == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
        /* no changes are possible to a type='hostdev' interface */
2400
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422
                       _("cannot change config of '%s' network type"),
                       virDomainNetTypeToString(oldType));
        goto cleanup;
    }

    /* Check individual attributes for changes that can't be done to a
     * live netdev. These checks *mostly* go in order of the
     * declarations in virDomainNetDef in order to assure nothing is
     * omitted. (exceptiong where noted in comments - in particular,
     * some things require that a new "actual device" be allocated
     * from the network driver first, but we delay doing that until
     * after we've made as many other checks as possible)
     */

    /* type: this can change (with some restrictions), but the actual
     * type of the new device connection isn't known until after we
     * allocate the "actual" device.
     */

    if (virMacAddrCmp(&olddev->mac, &newdev->mac)) {
        char oldmac[VIR_MAC_STRING_BUFLEN], newmac[VIR_MAC_STRING_BUFLEN];

2423
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
2424 2425 2426 2427 2428 2429 2430 2431
                       _("cannot change network interface mac address "
                         "from %s to %s"),
                       virMacAddrFormat(&olddev->mac, oldmac),
                       virMacAddrFormat(&newdev->mac, newmac));
        goto cleanup;
    }

    if (STRNEQ_NULLABLE(olddev->model, newdev->model)) {
2432
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
2433 2434 2435 2436
                       _("cannot modify network device model from %s to %s"),
                       olddev->model ? olddev->model : "(default)",
                       newdev->model ? newdev->model : "(default)");
        goto cleanup;
2437 2438
    }

2439 2440 2441 2442
    if (olddev->model && STREQ(olddev->model, "virtio") &&
        (olddev->driver.virtio.name != newdev->driver.virtio.name ||
         olddev->driver.virtio.txmode != newdev->driver.virtio.txmode ||
         olddev->driver.virtio.ioeventfd != newdev->driver.virtio.ioeventfd ||
2443
         olddev->driver.virtio.event_idx != newdev->driver.virtio.event_idx ||
2444 2445 2446 2447 2448 2449 2450
         olddev->driver.virtio.queues != newdev->driver.virtio.queues ||
         olddev->driver.virtio.host.csum != newdev->driver.virtio.host.csum ||
         olddev->driver.virtio.host.gso != newdev->driver.virtio.host.gso ||
         olddev->driver.virtio.host.tso4 != newdev->driver.virtio.host.tso4 ||
         olddev->driver.virtio.host.tso6 != newdev->driver.virtio.host.tso6 ||
         olddev->driver.virtio.host.ecn != newdev->driver.virtio.host.ecn ||
         olddev->driver.virtio.host.ufo != newdev->driver.virtio.host.ufo ||
J
Ján Tomko 已提交
2451
         olddev->driver.virtio.host.mrg_rxbuf != newdev->driver.virtio.host.mrg_rxbuf ||
2452 2453 2454 2455 2456
         olddev->driver.virtio.guest.csum != newdev->driver.virtio.guest.csum ||
         olddev->driver.virtio.guest.tso4 != newdev->driver.virtio.guest.tso4 ||
         olddev->driver.virtio.guest.tso6 != newdev->driver.virtio.guest.tso6 ||
         olddev->driver.virtio.guest.ecn != newdev->driver.virtio.guest.ecn ||
         olddev->driver.virtio.guest.ufo != newdev->driver.virtio.guest.ufo)) {
2457
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
                       _("cannot modify virtio network device driver attributes"));
        goto cleanup;
    }

    /* data: this union will be examined later, after allocating new actualdev */
    /* virtPortProfile: will be examined later, after allocating new actualdev */

    if (olddev->tune.sndbuf_specified != newdev->tune.sndbuf_specified ||
        olddev->tune.sndbuf != newdev->tune.sndbuf) {
        needReconnect = true;
2468 2469
    }

2470
    if (STRNEQ_NULLABLE(olddev->script, newdev->script)) {
2471
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2472 2473
                       _("cannot modify network device script attribute"));
        goto cleanup;
2474 2475
    }

2476
    /* ifname: check if it's set in newdev. If not, retain the autogenerated one */
2477
    if (!newdev->ifname && VIR_STRDUP(newdev->ifname, olddev->ifname) < 0)
2478 2479
        goto cleanup;
    if (STRNEQ_NULLABLE(olddev->ifname, newdev->ifname)) {
2480
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2481 2482 2483
                       _("cannot modify network device tap name"));
        goto cleanup;
    }
2484

2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495
    /* info: if newdev->info is empty, fill it in from olddev,
     * otherwise verify that it matches - nothing is allowed to
     * change. (There is no helper function to do this, so
     * individually check the few feidls of virDomainDeviceInfo that
     * are relevant in this case).
     */
    if (!virDomainDeviceAddressIsValid(&newdev->info,
                                       VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
        virDomainDeviceInfoCopy(&newdev->info, &olddev->info) < 0) {
        goto cleanup;
    }
2496
    if (!virPCIDeviceAddressEqual(&olddev->info.addr.pci,
2497
                                  &newdev->info.addr.pci)) {
2498
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2499 2500 2501 2502
                       _("cannot modify network device guest PCI address"));
        goto cleanup;
    }
    /* grab alias from olddev if not set in newdev */
2503 2504
    if (!newdev->info.alias &&
        VIR_STRDUP(newdev->info.alias, olddev->info.alias) < 0)
2505 2506
        goto cleanup;
    if (STRNEQ_NULLABLE(olddev->info.alias, newdev->info.alias)) {
2507
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2508 2509 2510 2511
                       _("cannot modify network device alias"));
        goto cleanup;
    }
    if (olddev->info.rombar != newdev->info.rombar) {
2512
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2513 2514 2515 2516
                       _("cannot modify network device rom bar setting"));
        goto cleanup;
    }
    if (STRNEQ_NULLABLE(olddev->info.romfile, newdev->info.romfile)) {
2517
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2518 2519 2520 2521
                       _("cannot modify network rom file"));
        goto cleanup;
    }
    if (olddev->info.bootIndex != newdev->info.bootIndex) {
2522
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2523 2524 2525 2526
                       _("cannot modify network device boot index setting"));
        goto cleanup;
    }
    /* (end of device info checks) */
2527

2528 2529 2530 2531
    if (STRNEQ_NULLABLE(olddev->filter, newdev->filter) ||
        !virNWFilterHashTableEqual(olddev->filterparams, newdev->filterparams)) {
        needFilterChange = true;
    }
2532

2533 2534 2535 2536 2537 2538 2539 2540
    /* bandwidth can be modified, and will be checked later */
    /* vlan can be modified, and will be checked later */
    /* linkstate can be modified */

    /* allocate new actual device to compare to old - we will need to
     * free it if we fail for any reason
     */
    if (newdev->type == VIR_DOMAIN_NET_TYPE_NETWORK &&
2541
        networkAllocateActualDevice(vm->def, newdev) < 0) {
2542 2543 2544 2545 2546 2547 2548
        goto cleanup;
    }

    newType = virDomainNetGetActualType(newdev);

    if (newType == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
        /* can't turn it into a type='hostdev' interface */
2549
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
2550 2551 2552 2553 2554 2555
                       _("cannot change network interface type to '%s'"),
                       virDomainNetTypeToString(newType));
        goto cleanup;
    }

    if (olddev->type == newdev->type && oldType == newType) {
2556

2557 2558 2559 2560 2561 2562
        /* if type hasn't changed, check the relevant fields for the type */
        switch (newdev->type) {
        case VIR_DOMAIN_NET_TYPE_USER:
            break;

        case VIR_DOMAIN_NET_TYPE_ETHERNET:
2563
            break;
2564

2565 2566 2567
        case VIR_DOMAIN_NET_TYPE_SERVER:
        case VIR_DOMAIN_NET_TYPE_CLIENT:
        case VIR_DOMAIN_NET_TYPE_MCAST:
2568
        case VIR_DOMAIN_NET_TYPE_UDP:
2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601
            if (STRNEQ_NULLABLE(olddev->data.socket.address,
                                newdev->data.socket.address) ||
                olddev->data.socket.port != newdev->data.socket.port) {
                needReconnect = true;
            }
            break;

        case VIR_DOMAIN_NET_TYPE_NETWORK:
            if (STRNEQ(olddev->data.network.name, newdev->data.network.name)) {
                if (virDomainNetGetActualVirtPortProfile(newdev))
                    needReconnect = true;
                else
                    needBridgeChange = true;
            }
            /* other things handled in common code directly below this switch */
            break;

        case VIR_DOMAIN_NET_TYPE_BRIDGE:
            /* all handled in bridge name checked in common code below */
            break;

        case VIR_DOMAIN_NET_TYPE_INTERNAL:
            if (STRNEQ_NULLABLE(olddev->data.internal.name,
                                newdev->data.internal.name)) {
                needReconnect = true;
            }
            break;

        case VIR_DOMAIN_NET_TYPE_DIRECT:
            /* all handled in common code directly below this switch */
            break;

        default:
2602
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
2603 2604 2605
                           _("unable to change config on '%s' network type"),
                           virDomainNetTypeToString(newdev->type));
            break;
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 2637 2638
    } else {
        /* interface type has changed. There are a few special cases
         * where this can only require a minor (or even no) change,
         * but in most cases we need to do a full reconnection.
         *
         * If we switch (in either direction) between type='bridge'
         * and type='network' (for a traditional managed virtual
         * network that uses a host bridge, i.e. forward
         * mode='route|nat'), we just need to change the bridge.
         */
        if ((oldType == VIR_DOMAIN_NET_TYPE_NETWORK &&
             newType == VIR_DOMAIN_NET_TYPE_BRIDGE) ||
            (oldType == VIR_DOMAIN_NET_TYPE_BRIDGE &&
             newType == VIR_DOMAIN_NET_TYPE_NETWORK)) {

            needBridgeChange = true;

        } else if (oldType == VIR_DOMAIN_NET_TYPE_DIRECT &&
                   newType == VIR_DOMAIN_NET_TYPE_DIRECT) {

            /* this is the case of switching from type='direct' to
             * type='network' for a network that itself uses direct
             * (macvtap) devices. If the physical device and mode are
             * the same, this doesn't require any actual setup
             * change. If the physical device or mode *does* change,
             * that will be caught in the common section below */

        } else {

            /* for all other combinations, we'll need a full reconnect */
            needReconnect = true;
2639 2640

        }
2641
    }
2642

2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
    /* now several things that are in multiple (but not all)
     * different types, and can be safely compared even for those
     * cases where they don't apply to a particular type.
     */
    if (STRNEQ_NULLABLE(virDomainNetGetActualBridgeName(olddev),
                        virDomainNetGetActualBridgeName(newdev))) {
        if (virDomainNetGetActualVirtPortProfile(newdev))
            needReconnect = true;
        else
            needBridgeChange = true;
    }
2654

2655 2656 2657 2658 2659 2660 2661 2662
    if (STRNEQ_NULLABLE(virDomainNetGetActualDirectDev(olddev),
                        virDomainNetGetActualDirectDev(newdev)) ||
        virDomainNetGetActualDirectMode(olddev) != virDomainNetGetActualDirectMode(olddev) ||
        !virNetDevVPortProfileEqual(virDomainNetGetActualVirtPortProfile(olddev),
                                    virDomainNetGetActualVirtPortProfile(newdev)) ||
        !virNetDevVlanEqual(virDomainNetGetActualVlan(olddev),
                            virDomainNetGetActualVlan(newdev))) {
        needReconnect = true;
2663 2664
    }

2665 2666 2667
    if (olddev->linkstate != newdev->linkstate)
        needLinkStateChange = true;

2668 2669 2670 2671
    if (!virNetDevBandwidthEqual(virDomainNetGetActualBandwidth(olddev),
                                 virDomainNetGetActualBandwidth(newdev)))
        needBandwidthSet = true;

2672 2673 2674
    /* FINALLY - actually perform the required actions */

    if (needReconnect) {
2675
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
2676 2677 2678
                       _("unable to change config on '%s' network type"),
                       virDomainNetTypeToString(newdev->type));
        goto cleanup;
2679 2680
    }

2681 2682 2683
    if (needBandwidthSet) {
        if (virNetDevBandwidthSet(newdev->ifname,
                                  virDomainNetGetActualBandwidth(newdev),
2684
                                  false) < 0)
2685 2686 2687 2688
            goto cleanup;
        needReplaceDevDef = true;
    }

2689
    if (needBridgeChange) {
2690
        if (qemuDomainChangeNetBridge(vm, olddev, newdev) < 0)
2691 2692 2693
            goto cleanup;
        /* we successfully switched to the new bridge, and we've
         * determined that the rest of newdev is equivalent to olddev,
2694 2695 2696 2697 2698
         * so move newdev into place */
        needReplaceDevDef = true;
    }

    if (needFilterChange) {
2699
        if (qemuDomainChangeNetFilter(vm, olddev, newdev) < 0)
2700 2701 2702 2703
            goto cleanup;
        /* we successfully switched to the new filter, and we've
         * determined that the rest of newdev is equivalent to olddev,
         * so move newdev into place */
2704
        needReplaceDevDef = true;
2705 2706
    }

2707 2708 2709
    if (needLinkStateChange &&
        qemuDomainChangeNetLinkState(driver, vm, olddev, newdev->linkstate) < 0) {
        goto cleanup;
2710 2711
    }

2712 2713 2714 2715
    if (needReplaceDevDef) {
        /* the changes above warrant replacing olddev with newdev in
         * the domain's nets list.
         */
2716 2717 2718

        /* this function doesn't work with HOSTDEV networks yet, thus
         * no need to change the pointer in the hostdev structure */
2719
        networkReleaseActualDevice(vm->def, olddev);
2720 2721 2722 2723 2724 2725 2726 2727
        virDomainNetDefFree(olddev);
        /* move newdev into the nets list, and NULL it out from the
         * virDomainDeviceDef that we were given so that the caller
         * won't delete it on return.
         */
        *devslot = newdev;
        newdev = dev->data.net = NULL;
        dev->type = VIR_DOMAIN_DEVICE_NONE;
2728 2729
    }

2730
    ret = 0;
2731
 cleanup:
2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750
    /* When we get here, we will be in one of these two states:
     *
     * 1) newdev has been moved into the domain's list of nets and
     *    newdev set to NULL, and dev->data.net will be NULL (and
     *    dev->type is NONE). olddev will have been completely
     *    released and freed. (aka success) In this case no extra
     *    cleanup is needed.
     *
     * 2) newdev has *not* been moved into the domain's list of nets,
     *    and dev->data.net == newdev (and dev->type == NET). In this *
     *    case, we need to at least release the "actual device" from *
     *    newdev (the caller will free dev->data.net a.k.a. newdev, and
     *    the original olddev is still in used)
     *
     * Note that case (2) isn't necessarily a failure. It may just be
     * that the changes were minor enough that we didn't need to
     * replace the entire device object.
     */
    if (newdev)
2751
        networkReleaseActualDevice(vm->def, newdev);
2752

2753 2754 2755
    return ret;
}

2756 2757 2758
static virDomainGraphicsDefPtr
qemuDomainFindGraphics(virDomainObjPtr vm,
                       virDomainGraphicsDefPtr dev)
2759
{
2760
    size_t i;
2761

2762
    for (i = 0; i < vm->def->ngraphics; i++) {
2763 2764 2765 2766 2767 2768 2769
        if (vm->def->graphics[i]->type == dev->type)
            return vm->def->graphics[i];
    }

    return NULL;
}

2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783
int
qemuDomainFindGraphicsIndex(virDomainDefPtr def,
                            virDomainGraphicsDefPtr dev)
{
    size_t i;

    for (i = 0; i < def->ngraphics; i++) {
        if (def->graphics[i]->type == dev->type)
            return i;
    }

    return -1;
}

2784
int
2785
qemuDomainChangeGraphics(virQEMUDriverPtr driver,
2786 2787 2788 2789
                         virDomainObjPtr vm,
                         virDomainGraphicsDefPtr dev)
{
    virDomainGraphicsDefPtr olddev = qemuDomainFindGraphics(vm, dev);
2790
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2791
    const char *type = virDomainGraphicsTypeToString(dev->type);
2792
    size_t i;
2793
    int ret = -1;
2794 2795

    if (!olddev) {
2796 2797
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("cannot find existing graphics device to modify"));
2798
        goto cleanup;
2799 2800
    }

2801
    if (dev->nListens != olddev->nListens) {
2802 2803 2804
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot change the number of listen addresses "
                         "on '%s' graphics"), type);
2805 2806 2807 2808
        goto cleanup;
    }

    for (i = 0; i < dev->nListens; i++) {
J
Jim Fehlig 已提交
2809
        virDomainGraphicsListenDefPtr newlisten = &dev->listens[i];
2810 2811
        virDomainGraphicsListenDefPtr oldlisten = &olddev->listens[i];

J
Jim Fehlig 已提交
2812
        if (newlisten->type != oldlisten->type) {
2813 2814 2815
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                           _("cannot change the type of listen address "
                             "on '%s' graphics"), type);
2816 2817 2818
            goto cleanup;
        }

2819
        switch (newlisten->type) {
2820
        case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS:
J
Jim Fehlig 已提交
2821
            if (STRNEQ_NULLABLE(newlisten->address, oldlisten->address)) {
2822 2823 2824
                virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                               _("cannot change listen address setting "
                                 "on '%s' graphics"), type);
2825 2826
                goto cleanup;
            }
2827

2828 2829 2830
            break;

        case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK:
J
Jim Fehlig 已提交
2831
            if (STRNEQ_NULLABLE(newlisten->network, oldlisten->network)) {
2832 2833 2834
                virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                               _("cannot change listen address setting "
                                 "on '%s' graphics"), type);
2835 2836
                goto cleanup;
            }
2837

2838 2839
            break;

2840 2841 2842 2843 2844 2845 2846 2847 2848
        case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_SOCKET:
            if (STRNEQ_NULLABLE(newlisten->socket, oldlisten->socket)) {
                virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                               _("cannot change listen socket setting "
                                 "on '%s' graphics"), type);
                goto cleanup;
            }
            break;

2849 2850 2851 2852 2853 2854
        case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NONE:
        case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_LAST:
            /* nada */
            break;
        }
    }
2855

2856 2857
    switch (dev->type) {
    case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
2858 2859 2860
        if ((olddev->data.vnc.autoport != dev->data.vnc.autoport) ||
            (!dev->data.vnc.autoport &&
             (olddev->data.vnc.port != dev->data.vnc.port))) {
2861
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2862
                           _("cannot change port settings on vnc graphics"));
2863
            goto cleanup;
2864 2865
        }
        if (STRNEQ_NULLABLE(olddev->data.vnc.keymap, dev->data.vnc.keymap)) {
2866
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2867
                           _("cannot change keymap setting on vnc graphics"));
2868
            goto cleanup;
2869 2870
        }

2871 2872 2873
        /* If a password lifetime was, or is set, or action if connected has
         * changed, then we must always run, even if new password matches
         * old password */
2874 2875
        if (olddev->data.vnc.auth.expires ||
            dev->data.vnc.auth.expires ||
2876
            olddev->data.vnc.auth.connected != dev->data.vnc.auth.connected ||
E
Eric Blake 已提交
2877 2878 2879
            STRNEQ_NULLABLE(olddev->data.vnc.auth.passwd,
                            dev->data.vnc.auth.passwd)) {
            VIR_DEBUG("Updating password on VNC server %p %p",
2880
                      dev->data.vnc.auth.passwd, cfg->vncPassword);
E
Eric Blake 已提交
2881 2882 2883
            ret = qemuDomainChangeGraphicsPasswords(driver, vm,
                                                    VIR_DOMAIN_GRAPHICS_TYPE_VNC,
                                                    &dev->data.vnc.auth,
2884 2885
                                                    cfg->vncPassword,
                                                    QEMU_ASYNC_JOB_NONE);
2886
            if (ret < 0)
2887
                goto cleanup;
2888 2889 2890 2891 2892

            /* Steal the new dev's  char * reference */
            VIR_FREE(olddev->data.vnc.auth.passwd);
            olddev->data.vnc.auth.passwd = dev->data.vnc.auth.passwd;
            dev->data.vnc.auth.passwd = NULL;
2893 2894
            olddev->data.vnc.auth.validTo = dev->data.vnc.auth.validTo;
            olddev->data.vnc.auth.expires = dev->data.vnc.auth.expires;
2895
            olddev->data.vnc.auth.connected = dev->data.vnc.auth.connected;
2896 2897 2898 2899 2900
        } else {
            ret = 0;
        }
        break;

2901
    case VIR_DOMAIN_GRAPHICS_TYPE_SPICE:
2902 2903 2904 2905 2906
        if ((olddev->data.spice.autoport != dev->data.spice.autoport) ||
            (!dev->data.spice.autoport &&
             (olddev->data.spice.port != dev->data.spice.port)) ||
            (!dev->data.spice.autoport &&
             (olddev->data.spice.tlsPort != dev->data.spice.tlsPort))) {
2907
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2908
                           _("cannot change port settings on spice graphics"));
2909
            goto cleanup;
2910
        }
E
Eric Blake 已提交
2911 2912
        if (STRNEQ_NULLABLE(olddev->data.spice.keymap,
                            dev->data.spice.keymap)) {
2913
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2914
                            _("cannot change keymap setting on spice graphics"));
2915
            goto cleanup;
2916 2917
        }

2918 2919 2920 2921 2922
        /* We must reset the password if it has changed but also if:
         * - password lifetime is or was set
         * - the requested action has changed
         * - the action is "disconnect"
         */
2923 2924
        if (olddev->data.spice.auth.expires ||
            dev->data.spice.auth.expires ||
2925
            olddev->data.spice.auth.connected != dev->data.spice.auth.connected ||
2926 2927
            dev->data.spice.auth.connected ==
            VIR_DOMAIN_GRAPHICS_AUTH_CONNECTED_DISCONNECT ||
E
Eric Blake 已提交
2928 2929 2930
            STRNEQ_NULLABLE(olddev->data.spice.auth.passwd,
                            dev->data.spice.auth.passwd)) {
            VIR_DEBUG("Updating password on SPICE server %p %p",
2931
                      dev->data.spice.auth.passwd, cfg->spicePassword);
E
Eric Blake 已提交
2932 2933 2934
            ret = qemuDomainChangeGraphicsPasswords(driver, vm,
                                                    VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
                                                    &dev->data.spice.auth,
2935 2936
                                                    cfg->spicePassword,
                                                    QEMU_ASYNC_JOB_NONE);
E
Eric Blake 已提交
2937

2938
            if (ret < 0)
2939
                goto cleanup;
2940

E
Eric Blake 已提交
2941
            /* Steal the new dev's char * reference */
2942 2943 2944 2945 2946
            VIR_FREE(olddev->data.spice.auth.passwd);
            olddev->data.spice.auth.passwd = dev->data.spice.auth.passwd;
            dev->data.spice.auth.passwd = NULL;
            olddev->data.spice.auth.validTo = dev->data.spice.auth.validTo;
            olddev->data.spice.auth.expires = dev->data.spice.auth.expires;
2947
            olddev->data.spice.auth.connected = dev->data.spice.auth.connected;
2948
        } else {
2949
            VIR_DEBUG("Not updating since password didn't change");
2950 2951
            ret = 0;
        }
E
Eric Blake 已提交
2952
        break;
2953

2954
    default:
2955
        virReportError(VIR_ERR_INTERNAL_ERROR,
2956
                       _("unable to change config on '%s' graphics type"), type);
2957 2958 2959
        break;
    }

2960
 cleanup:
2961
    virObjectUnref(cfg);
2962 2963 2964 2965
    return ret;
}


2966
static int qemuComparePCIDevice(virDomainDefPtr def ATTRIBUTE_UNUSED,
2967
                                virDomainDeviceDefPtr device ATTRIBUTE_UNUSED,
2968
                                virDomainDeviceInfoPtr info1,
2969 2970
                                void *opaque)
{
2971
    virDomainDeviceInfoPtr info2 = opaque;
2972

2973 2974
    if (info1->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI ||
        info2->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
2975 2976
        return 0;

2977 2978 2979
    if (info1->addr.pci.domain == info2->addr.pci.domain &&
        info1->addr.pci.bus == info2->addr.pci.bus &&
        info1->addr.pci.slot == info2->addr.pci.slot &&
2980
        info1->addr.pci.function != info2->addr.pci.function)
2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992
        return -1;
    return 0;
}

static bool qemuIsMultiFunctionDevice(virDomainDefPtr def,
                                      virDomainDeviceInfoPtr dev)
{
    if (virDomainDeviceInfoIterate(def, qemuComparePCIDevice, dev) < 0)
        return true;
    return false;
}

2993

2994
static int
2995 2996 2997 2998 2999
qemuDomainRemoveDiskDevice(virQEMUDriverPtr driver,
                           virDomainObjPtr vm,
                           virDomainDiskDefPtr disk)
{
    virDomainDeviceDef dev;
3000
    virObjectEventPtr event;
3001
    size_t i;
3002
    const char *src = virDomainDiskGetSource(disk);
3003 3004
    qemuDomainObjPrivatePtr priv = vm->privateData;
    char *drivestr;
3005
    char *objAlias = NULL;
3006
    char *encAlias = NULL;
3007 3008 3009 3010

    VIR_DEBUG("Removing disk %s from domain %p %s",
              disk->info.alias, vm, vm->def->name);

3011 3012
    /* build the actual drive id string as the disk->info.alias doesn't
     * contain the QEMU_DRIVE_HOST_PREFIX that is passed to qemu */
3013
    if (!(drivestr = qemuAliasFromDisk(disk)))
3014 3015
        return -1;

3016 3017 3018 3019 3020 3021 3022 3023
    /* Let's look for some markers for a secret object and create an alias
     * object to be used to attempt to delete the object that was created.
     * We cannot just use the disk private secret info since it would have
     * been removed during cleanup of qemuProcessLaunch. Likewise, libvirtd
     * restart wouldn't have them, so no assumption can be made. */
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET) &&
        qemuDomainSecretDiskCapable(disk->src)) {

3024 3025
        if (!(objAlias =
              qemuDomainGetSecretAESAlias(disk->info.alias, false))) {
3026 3027 3028 3029 3030
            VIR_FREE(drivestr);
            return -1;
        }
    }

3031 3032 3033 3034
    /* Similarly, if this is possible a device using LUKS encryption, we
     * can remove the luks object password too
     */
    if (!virStorageSourceIsEmpty(disk->src) && disk->src->encryption &&
3035
        disk->src->encryption->format == VIR_STORAGE_ENCRYPTION_FORMAT_LUKS) {
3036 3037 3038 3039 3040 3041 3042 3043 3044

        if (!(encAlias =
              qemuDomainGetSecretAESAlias(disk->info.alias, true))) {
            VIR_FREE(objAlias);
            VIR_FREE(drivestr);
            return -1;
        }
    }

3045
    qemuDomainObjEnterMonitor(driver, vm);
3046 3047 3048 3049 3050 3051

    /* If it fails, then so be it - it was a best shot */
    if (objAlias)
        ignore_value(qemuMonitorDelObject(priv->mon, objAlias));
    VIR_FREE(objAlias);

3052 3053 3054 3055 3056
    /* If it fails, then so be it - it was a best shot */
    if (encAlias)
        ignore_value(qemuMonitorDelObject(priv->mon, encAlias));
    VIR_FREE(encAlias);

3057 3058
    qemuMonitorDriveDel(priv->mon, drivestr);
    VIR_FREE(drivestr);
3059 3060
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
3061

3062
    virDomainAuditDisk(vm, disk->src, NULL, "detach", true);
3063

3064
    event = virDomainEventDeviceRemovedNewFromObj(vm, disk->info.alias);
3065
    qemuDomainEventQueue(driver, event);
3066

3067 3068 3069 3070 3071 3072 3073
    for (i = 0; i < vm->def->ndisks; i++) {
        if (vm->def->disks[i] == disk) {
            virDomainDiskRemove(vm->def, i);
            break;
        }
    }

3074
    qemuDomainReleaseDeviceAddress(vm, &disk->info, src);
3075

3076 3077
    if (virSecurityManagerRestoreDiskLabel(driver->securityManager,
                                           vm->def, disk) < 0)
3078
        VIR_WARN("Unable to restore security label on %s", src);
3079 3080

    if (qemuTeardownDiskCgroup(vm, disk) < 0)
3081
        VIR_WARN("Failed to tear down cgroup for disk path %s", src);
3082 3083

    if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
3084
        VIR_WARN("Unable to release lock on %s", src);
3085 3086 3087 3088

    dev.type = VIR_DOMAIN_DEVICE_DISK;
    dev.data.disk = disk;
    ignore_value(qemuRemoveSharedDevice(driver, &dev, vm->def->name));
3089 3090
    if (priv->usbaddrs)
        virDomainUSBAddressRelease(priv->usbaddrs, &disk->info);
3091 3092

    virDomainDiskDefFree(disk);
3093
    return 0;
3094 3095 3096
}


3097
static int
3098
qemuDomainRemoveControllerDevice(virQEMUDriverPtr driver,
3099 3100 3101
                                 virDomainObjPtr vm,
                                 virDomainControllerDefPtr controller)
{
3102
    virObjectEventPtr event;
3103 3104 3105 3106 3107
    size_t i;

    VIR_DEBUG("Removing controller %s from domain %p %s",
              controller->info.alias, vm, vm->def->name);

3108
    event = virDomainEventDeviceRemovedNewFromObj(vm, controller->info.alias);
3109
    qemuDomainEventQueue(driver, event);
3110

3111 3112 3113 3114 3115 3116 3117 3118 3119
    for (i = 0; i < vm->def->ncontrollers; i++) {
        if (vm->def->controllers[i] == controller) {
            virDomainControllerRemove(vm->def, i);
            break;
        }
    }

    qemuDomainReleaseDeviceAddress(vm, &controller->info, NULL);
    virDomainControllerDefFree(controller);
3120
    return 0;
3121 3122 3123
}


3124 3125 3126 3127 3128 3129
static int
qemuDomainRemoveMemoryDevice(virQEMUDriverPtr driver,
                             virDomainObjPtr vm,
                             virDomainMemoryDefPtr mem)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
3130
    unsigned long long oldmem = virDomainDefGetMemoryTotal(vm->def);
3131
    unsigned long long newmem = oldmem - mem->size;
3132 3133 3134 3135 3136 3137 3138 3139
    virObjectEventPtr event;
    char *backendAlias = NULL;
    int rc;
    int idx;

    VIR_DEBUG("Removing memory device %s from domain %p %s",
              mem->info.alias, vm, vm->def->name);

3140 3141
    event = virDomainEventDeviceRemovedNewFromObj(vm, mem->info.alias);
    qemuDomainEventQueue(driver, event);
3142 3143

    if (virAsprintf(&backendAlias, "mem%s", mem->info.alias) < 0)
3144
        return -1;
3145 3146 3147

    qemuDomainObjEnterMonitor(driver, vm);
    rc = qemuMonitorDelObject(priv->mon, backendAlias);
3148 3149 3150 3151 3152 3153 3154 3155
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        rc = -1;

    VIR_FREE(backendAlias);

    virDomainAuditMemory(vm, oldmem, newmem, "update", rc == 0);
    if (rc < 0)
        return -1;
3156 3157 3158 3159 3160

    if ((idx = virDomainMemoryFindByDef(vm->def, mem)) >= 0)
        virDomainMemoryRemove(vm->def, idx);

    virDomainMemoryDefFree(mem);
3161

3162 3163 3164
    /* fix the balloon size */
    ignore_value(qemuProcessRefreshBalloonState(driver, vm, QEMU_ASYNC_JOB_NONE));

3165
    /* decrease the mlock limit after memory unplug if necessary */
3166
    ignore_value(qemuDomainAdjustMaxMemLock(vm));
3167

3168
    return 0;
3169 3170 3171
}


3172 3173 3174 3175 3176
static void
qemuDomainRemovePCIHostDevice(virQEMUDriverPtr driver,
                              virDomainObjPtr vm,
                              virDomainHostdevDefPtr hostdev)
{
3177
    qemuHostdevReAttachPCIDevices(driver, vm->def->name, &hostdev, 1);
3178 3179 3180 3181 3182
    qemuDomainReleaseDeviceAddress(vm, hostdev->info, NULL);
}

static void
qemuDomainRemoveUSBHostDevice(virQEMUDriverPtr driver,
3183
                              virDomainObjPtr vm,
3184 3185
                              virDomainHostdevDefPtr hostdev)
{
3186
    qemuHostdevReAttachUSBDevices(driver, vm->def->name, &hostdev, 1);
3187
    qemuDomainReleaseDeviceAddress(vm, hostdev->info, NULL);
3188 3189 3190 3191 3192 3193 3194
}

static void
qemuDomainRemoveSCSIHostDevice(virQEMUDriverPtr driver,
                               virDomainObjPtr vm,
                               virDomainHostdevDefPtr hostdev)
{
3195
    qemuHostdevReAttachSCSIDevices(driver, vm->def->name, &hostdev, 1);
3196 3197
}

3198
static int
3199 3200 3201 3202
qemuDomainRemoveHostDevice(virQEMUDriverPtr driver,
                           virDomainObjPtr vm,
                           virDomainHostdevDefPtr hostdev)
{
3203
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3204
    virDomainNetDefPtr net = NULL;
3205
    virObjectEventPtr event;
3206
    size_t i;
3207 3208
    int ret = -1;
    qemuDomainObjPrivatePtr priv = vm->privateData;
J
John Ferlan 已提交
3209
    char *drivealias = NULL;
3210
    bool is_vfio = false;
3211 3212 3213 3214

    VIR_DEBUG("Removing host device %s from domain %p %s",
              hostdev->info->alias, vm, vm->def->name);

3215 3216 3217 3218 3219
    if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
        int backend = hostdev->source.subsys.u.pci.backend;
        is_vfio = backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO;
    }

3220
    if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI) {
J
John Ferlan 已提交
3221
        if (!(drivealias = qemuAliasFromHostdev(hostdev)))
3222 3223 3224
            goto cleanup;

        qemuDomainObjEnterMonitor(driver, vm);
J
John Ferlan 已提交
3225
        qemuMonitorDriveDel(priv->mon, drivealias);
3226 3227
        if (qemuDomainObjExitMonitor(driver, vm) < 0)
            goto cleanup;
3228 3229
    }

3230
    event = virDomainEventDeviceRemovedNewFromObj(vm, hostdev->info->alias);
3231
    qemuDomainEventQueue(driver, event);
3232

3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252
    if (hostdev->parent.type == VIR_DOMAIN_DEVICE_NET) {
        net = hostdev->parent.data.net;

        for (i = 0; i < vm->def->nnets; i++) {
            if (vm->def->nets[i] == net) {
                virDomainNetRemove(vm->def, i);
                break;
            }
        }
    }

    for (i = 0; i < vm->def->nhostdevs; i++) {
        if (vm->def->hostdevs[i] == hostdev) {
            virDomainHostdevRemove(vm->def, i);
            break;
        }
    }

    virDomainAuditHostdev(vm, hostdev, "detach", true);

3253 3254 3255 3256
    if (!is_vfio &&
        virSecurityManagerRestoreHostdevLabel(driver->securityManager,
                                              vm->def, hostdev, NULL) < 0)
        VIR_WARN("Failed to restore host device labelling");
3257

3258 3259 3260
    if (qemuTeardownHostdevCgroup(vm, hostdev) < 0)
        VIR_WARN("Failed to remove host device cgroup ACL");

3261
    switch ((virDomainHostdevSubsysType) hostdev->source.subsys.type) {
3262 3263
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
        qemuDomainRemovePCIHostDevice(driver, vm, hostdev);
3264 3265 3266 3267
        /* QEMU might no longer need to lock as much memory, eg. we just
         * detached the last VFIO device, so adjust the limit here */
        if (qemuDomainAdjustMaxMemLock(vm) < 0)
            VIR_WARN("Failed to adjust locked memory limit");
3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281
        break;
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
        qemuDomainRemoveUSBHostDevice(driver, vm, hostdev);
        break;
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI:
        qemuDomainRemoveSCSIHostDevice(driver, vm, hostdev);
        break;
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_LAST:
        break;
    }

    virDomainHostdevDefFree(hostdev);

    if (net) {
3282
        networkReleaseActualDevice(vm->def, net);
3283 3284
        virDomainNetDefFree(net);
    }
3285

3286 3287 3288
    ret = 0;

 cleanup:
J
John Ferlan 已提交
3289
    VIR_FREE(drivealias);
3290
    virObjectUnref(cfg);
3291
    return ret;
3292 3293 3294
}


3295
static int
3296 3297 3298 3299 3300
qemuDomainRemoveNetDevice(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
                          virDomainNetDefPtr net)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3301
    qemuDomainObjPrivatePtr priv = vm->privateData;
3302
    virNetDevVPortProfilePtr vport;
3303
    virObjectEventPtr event;
3304
    char *hostnet_name = NULL;
3305
    size_t i;
3306
    int ret = -1;
3307

3308 3309
    if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
        /* this function handles all hostdev and netdev cleanup */
3310 3311
        ret = qemuDomainRemoveHostDevice(driver, vm,
                                         virDomainNetGetActualHostdev(net));
3312
        goto cleanup;
3313 3314
    }

3315 3316 3317
    VIR_DEBUG("Removing network interface %s from domain %p %s",
              net->info.alias, vm, vm->def->name);

3318 3319 3320 3321
    if (virAsprintf(&hostnet_name, "host%s", net->info.alias) < 0)
        goto cleanup;

    qemuDomainObjEnterMonitor(driver, vm);
3322
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
3323
        if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
3324 3325
            if (qemuDomainObjExitMonitor(driver, vm) < 0)
                goto cleanup;
3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336
            virDomainAuditNet(vm, net, NULL, "detach", false);
            goto cleanup;
        }
    } else {
        int vlan;
        if ((vlan = qemuDomainNetVLAN(net)) < 0 ||
            qemuMonitorRemoveHostNetwork(priv->mon, vlan, hostnet_name) < 0) {
            if (vlan < 0) {
                virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                               _("unable to determine original VLAN"));
            }
3337 3338
            if (qemuDomainObjExitMonitor(driver, vm) < 0)
                goto cleanup;
3339 3340 3341 3342
            virDomainAuditNet(vm, net, NULL, "detach", false);
            goto cleanup;
        }
    }
3343 3344
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
3345

3346 3347 3348
    virDomainAuditNet(vm, net, NULL, "detach", true);

    event = virDomainEventDeviceRemovedNewFromObj(vm, net->info.alias);
3349
    qemuDomainEventQueue(driver, event);
3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360

    for (i = 0; i < vm->def->nnets; i++) {
        if (vm->def->nets[i] == net) {
            virDomainNetRemove(vm->def, i);
            break;
        }
    }

    qemuDomainReleaseDeviceAddress(vm, &net->info, NULL);
    virDomainConfNWFilterTeardown(net);

3361 3362 3363 3364 3365 3366
    if (cfg->macFilter && (net->ifname != NULL)) {
        ignore_value(ebtablesRemoveForwardAllowIn(driver->ebtables,
                                                  net->ifname,
                                                  &net->mac));
    }

3367 3368 3369 3370 3371 3372 3373 3374 3375 3376
    if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_DIRECT) {
        ignore_value(virNetDevMacVLanDeleteWithVPortProfile(
                         net->ifname, &net->mac,
                         virDomainNetGetActualDirectDev(net),
                         virDomainNetGetActualDirectMode(net),
                         virDomainNetGetActualVirtPortProfile(net),
                         cfg->stateDir));
    }

    vport = virDomainNetGetActualVirtPortProfile(net);
3377 3378 3379 3380 3381 3382 3383 3384 3385
    if (vport) {
        if (vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_MIDONET) {
            ignore_value(virNetDevMidonetUnbindPort(vport));
        } else if (vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH) {
            ignore_value(virNetDevOpenvswitchRemovePort(
                             virDomainNetGetActualBridgeName(net),
                             net->ifname));
        }
    }
3386

3387
    networkReleaseActualDevice(vm->def, net);
3388
    virDomainNetDefFree(net);
3389
    ret = 0;
3390 3391

 cleanup:
3392
    virObjectUnref(cfg);
3393 3394
    VIR_FREE(hostnet_name);
    return ret;
3395 3396 3397
}


3398
static int
3399
qemuDomainRemoveChrDevice(virQEMUDriverPtr driver,
3400 3401 3402
                          virDomainObjPtr vm,
                          virDomainChrDefPtr chr)
{
3403
    virObjectEventPtr event;
3404 3405 3406
    char *charAlias = NULL;
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int ret = -1;
3407
    int rc;
3408

3409 3410 3411
    VIR_DEBUG("Removing character device %s from domain %p %s",
              chr->info.alias, vm, vm->def->name);

3412 3413 3414 3415
    if (virAsprintf(&charAlias, "char%s", chr->info.alias) < 0)
        goto cleanup;

    qemuDomainObjEnterMonitor(driver, vm);
3416
    rc = qemuMonitorDetachCharDev(priv->mon, charAlias);
3417 3418
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
3419

3420 3421 3422 3423 3424
    virDomainAuditChardev(vm, chr, NULL, "detach", rc == 0);

    if (rc < 0)
        goto cleanup;

3425
    event = virDomainEventDeviceRemovedNewFromObj(vm, chr->info.alias);
3426
    qemuDomainEventQueue(driver, event);
3427

3428 3429
    qemuDomainChrRemove(vm->def, chr);
    virDomainChrDefFree(chr);
3430 3431 3432 3433 3434
    ret = 0;

 cleanup:
    VIR_FREE(charAlias);
    return ret;
3435 3436 3437
}


3438 3439 3440 3441 3442 3443 3444 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 3470 3471 3472 3473
static int
qemuDomainRemoveRNGDevice(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
                          virDomainRNGDefPtr rng)
{
    virObjectEventPtr event;
    char *charAlias = NULL;
    char *objAlias = NULL;
    qemuDomainObjPrivatePtr priv = vm->privateData;
    ssize_t idx;
    int ret = -1;
    int rc;

    VIR_DEBUG("Removing RNG device %s from domain %p %s",
              rng->info.alias, vm, vm->def->name);

    if (virAsprintf(&objAlias, "obj%s", rng->info.alias) < 0)
        goto cleanup;

    if (virAsprintf(&charAlias, "char%s", rng->info.alias) < 0)
        goto cleanup;

    qemuDomainObjEnterMonitor(driver, vm);
    rc = qemuMonitorDelObject(priv->mon, objAlias);

    if (rc == 0 && rng->backend == VIR_DOMAIN_RNG_BACKEND_EGD)
        ignore_value(qemuMonitorDetachCharDev(priv->mon, charAlias));

    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;

    virDomainAuditRNG(vm, rng, NULL, "detach", rc == 0);

    if (rc < 0)
        goto cleanup;

3474 3475
    event = virDomainEventDeviceRemovedNewFromObj(vm, rng->info.alias);
    qemuDomainEventQueue(driver, event);
3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489

    if ((idx = virDomainRNGFind(vm->def, rng)) >= 0)
        virDomainRNGRemove(vm->def, idx);
    qemuDomainReleaseDeviceAddress(vm, &rng->info, NULL);
    virDomainRNGDefFree(rng);
    ret = 0;

 cleanup:
    VIR_FREE(charAlias);
    VIR_FREE(objAlias);
    return ret;
}


3490
int
3491 3492 3493 3494
qemuDomainRemoveDevice(virQEMUDriverPtr driver,
                       virDomainObjPtr vm,
                       virDomainDeviceDefPtr dev)
{
3495
    int ret = -1;
3496 3497
    switch ((virDomainDeviceType) dev->type) {
    case VIR_DOMAIN_DEVICE_DISK:
3498
        ret = qemuDomainRemoveDiskDevice(driver, vm, dev->data.disk);
3499 3500
        break;
    case VIR_DOMAIN_DEVICE_CONTROLLER:
3501
        ret = qemuDomainRemoveControllerDevice(driver, vm, dev->data.controller);
3502 3503
        break;
    case VIR_DOMAIN_DEVICE_NET:
3504
        ret = qemuDomainRemoveNetDevice(driver, vm, dev->data.net);
3505 3506
        break;
    case VIR_DOMAIN_DEVICE_HOSTDEV:
3507
        ret = qemuDomainRemoveHostDevice(driver, vm, dev->data.hostdev);
3508 3509 3510
        break;

    case VIR_DOMAIN_DEVICE_CHR:
3511
        ret = qemuDomainRemoveChrDevice(driver, vm, dev->data.chr);
3512
        break;
3513
    case VIR_DOMAIN_DEVICE_RNG:
3514
        ret = qemuDomainRemoveRNGDevice(driver, vm, dev->data.rng);
3515
        break;
3516

3517
    case VIR_DOMAIN_DEVICE_MEMORY:
3518 3519
        ret = qemuDomainRemoveMemoryDevice(driver, vm, dev->data.memory);
        break;
3520

3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533
    case VIR_DOMAIN_DEVICE_NONE:
    case VIR_DOMAIN_DEVICE_LEASE:
    case VIR_DOMAIN_DEVICE_FS:
    case VIR_DOMAIN_DEVICE_INPUT:
    case VIR_DOMAIN_DEVICE_SOUND:
    case VIR_DOMAIN_DEVICE_VIDEO:
    case VIR_DOMAIN_DEVICE_WATCHDOG:
    case VIR_DOMAIN_DEVICE_GRAPHICS:
    case VIR_DOMAIN_DEVICE_HUB:
    case VIR_DOMAIN_DEVICE_REDIRDEV:
    case VIR_DOMAIN_DEVICE_SMARTCARD:
    case VIR_DOMAIN_DEVICE_MEMBALLOON:
    case VIR_DOMAIN_DEVICE_NVRAM:
3534
    case VIR_DOMAIN_DEVICE_SHMEM:
3535
    case VIR_DOMAIN_DEVICE_TPM:
3536
    case VIR_DOMAIN_DEVICE_PANIC:
J
Ján Tomko 已提交
3537
    case VIR_DOMAIN_DEVICE_IOMMU:
3538 3539 3540 3541 3542 3543
    case VIR_DOMAIN_DEVICE_LAST:
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("don't know how to remove a %s device"),
                       virDomainDeviceTypeToString(dev->type));
        break;
    }
3544
    return ret;
3545 3546 3547 3548
}


static void
3549 3550
qemuDomainMarkDeviceAliasForRemoval(virDomainObjPtr vm,
                                    const char *alias)
3551 3552 3553
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

3554 3555 3556 3557 3558
    memset(&priv->unplug, 0, sizeof(priv->unplug));

    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE_DEL_EVENT))
        return;

3559
    priv->unplug.alias = alias;
3560 3561
}

3562 3563 3564 3565 3566 3567 3568 3569 3570 3571

static void
qemuDomainMarkDeviceForRemoval(virDomainObjPtr vm,
                               virDomainDeviceInfoPtr info)

{
    qemuDomainMarkDeviceAliasForRemoval(vm, info->alias);
}


3572 3573 3574 3575
static void
qemuDomainResetDeviceRemoval(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
3576
    priv->unplug.alias = NULL;
3577 3578 3579
}

/* Returns:
3580 3581
 *  -1 Unplug of the device failed
 *
3582 3583 3584 3585 3586 3587 3588
 *   0 DEVICE_DELETED event is supported and removal of the device did not
 *     finish in qemuDomainRemoveDeviceWaitTime
 *
 *   1 when the caller is responsible for finishing the device removal:
 *      - DEVICE_DELETED event is unsupported
 *      - DEVICE_DELETED event arrived before the timeout time
 *      - we failed to reliably wait for the event and thus use fallback behavior
3589 3590 3591 3592 3593 3594
 */
static int
qemuDomainWaitForDeviceRemoval(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    unsigned long long until;
3595
    int rc;
3596 3597

    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE_DEL_EVENT))
3598
        return 1;
3599 3600

    if (virTimeMillisNow(&until) < 0)
3601
        return 1;
3602
    until += qemuDomainRemoveDeviceWaitTime;
3603

3604
    while (priv->unplug.alias) {
3605 3606 3607 3608 3609
        if ((rc = virDomainObjWaitUntil(vm, until)) == 1)
            return 0;

        if (rc < 0) {
            VIR_WARN("Failed to wait on unplug condition for domain '%s' "
3610
                     "device '%s'", vm->def->name, priv->unplug.alias);
3611
            return 1;
3612 3613 3614
        }
    }

3615 3616 3617 3618 3619 3620
    if (priv->unplug.status == QEMU_DOMAIN_UNPLUGGING_DEVICE_STATUS_GUEST_REJECTED) {
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("unplug of device was rejected by the guest"));
        return -1;
    }

3621 3622 3623
    return 1;
}

3624 3625 3626 3627 3628 3629 3630
/* Returns:
 *  true    there was a thread waiting for devAlias to be removed and this
 *          thread will take care of finishing the removal
 *  false   the thread that started the removal is already gone and delegate
 *          finishing the removal to a new thread
 */
bool
3631
qemuDomainSignalDeviceRemoval(virDomainObjPtr vm,
3632 3633
                              const char *devAlias,
                              qemuDomainUnpluggingDeviceStatus status)
3634 3635 3636
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

3637
    if (STREQ_NULLABLE(priv->unplug.alias, devAlias)) {
3638
        qemuDomainResetDeviceRemoval(vm);
3639
        priv->unplug.status = status;
3640
        virDomainObjBroadcast(vm);
3641
        return true;
3642
    }
3643
    return false;
3644 3645 3646
}


3647 3648 3649 3650
static int
qemuDomainDetachVirtioDiskDevice(virQEMUDriverPtr driver,
                                 virDomainObjPtr vm,
                                 virDomainDiskDefPtr detach)
3651
{
3652
    int ret = -1;
3653 3654
    qemuDomainObjPrivatePtr priv = vm->privateData;

3655
    if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
3656 3657
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("cannot hot unplug multifunction PCI device: %s"),
3658
                       detach->dst);
3659 3660 3661
        goto cleanup;
    }

3662
    if (qemuDomainMachineIsS390CCW(vm->def) &&
3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_CCW)) {
        if (!virDomainDeviceAddressIsValid(&detach->info,
                                           VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW)) {
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("device cannot be detached without a valid CCW address"));
            goto cleanup;
        }
    } else {
        if (!virDomainDeviceAddressIsValid(&detach->info,
                                           VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("device cannot be detached without a valid PCI address"));
            goto cleanup;
        }
3677 3678
    }

3679
    if (!detach->info.alias) {
3680 3681 3682 3683
        if (qemuAssignDeviceDiskAlias(vm->def, detach, priv->qemuCaps) < 0)
            goto cleanup;
    }

3684 3685
    qemuDomainMarkDeviceForRemoval(vm, &detach->info);

3686
    qemuDomainObjEnterMonitor(driver, vm);
3687 3688
    if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
        if (qemuDomainObjExitMonitor(driver, vm) < 0)
3689
            goto cleanup;
3690 3691
        virDomainAuditDisk(vm, detach->src, NULL, "detach", false);
        goto cleanup;
3692
    }
3693 3694
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
3695

3696
    if ((ret = qemuDomainWaitForDeviceRemoval(vm)) == 1)
3697
        ret = qemuDomainRemoveDiskDevice(driver, vm, detach);
3698

3699
 cleanup:
3700
    qemuDomainResetDeviceRemoval(vm);
3701 3702 3703
    return ret;
}

3704 3705 3706 3707
static int
qemuDomainDetachDiskDevice(virQEMUDriverPtr driver,
                           virDomainObjPtr vm,
                           virDomainDiskDefPtr detach)
3708
{
3709
    int ret = -1;
3710 3711
    qemuDomainObjPrivatePtr priv = vm->privateData;

3712
    if (qemuDomainDiskBlockJobIsActive(detach))
E
Eric Blake 已提交
3713 3714
        goto cleanup;

3715 3716
    qemuDomainMarkDeviceForRemoval(vm, &detach->info);

3717
    qemuDomainObjEnterMonitor(driver, vm);
3718
    if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
3719 3720
        if (qemuDomainObjExitMonitor(driver, vm) < 0)
            goto cleanup;
3721
        virDomainAuditDisk(vm, detach->src, NULL, "detach", false);
3722 3723
        goto cleanup;
    }
3724 3725
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
3726

3727
    if ((ret = qemuDomainWaitForDeviceRemoval(vm)) == 1)
3728
        ret = qemuDomainRemoveDiskDevice(driver, vm, detach);
3729

3730
 cleanup:
3731
    qemuDomainResetDeviceRemoval(vm);
3732 3733 3734
    return ret;
}

3735 3736 3737 3738 3739 3740
static int
qemuFindDisk(virDomainDefPtr def, const char *dst)
{
    size_t i;

    for (i = 0; i < def->ndisks; i++) {
3741
        if (STREQ(def->disks[i]->dst, dst))
3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786
            return i;
    }

    return -1;
}

int
qemuDomainDetachDeviceDiskLive(virQEMUDriverPtr driver,
                               virDomainObjPtr vm,
                               virDomainDeviceDefPtr dev)
{
    virDomainDiskDefPtr disk;
    int ret = -1;
    int idx;

    if ((idx = qemuFindDisk(vm->def, dev->data.disk->dst)) < 0) {
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("disk %s not found"), dev->data.disk->dst);
        return -1;
    }
    disk = vm->def->disks[idx];

    switch (disk->device) {
    case VIR_DOMAIN_DISK_DEVICE_DISK:
    case VIR_DOMAIN_DISK_DEVICE_LUN:
        if (disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)
            ret = qemuDomainDetachVirtioDiskDevice(driver, vm, disk);
        else if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI ||
                 disk->bus == VIR_DOMAIN_DISK_BUS_USB)
            ret = qemuDomainDetachDiskDevice(driver, vm, disk);
        else
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
                           _("This type of disk cannot be hot unplugged"));
        break;
    default:
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("disk device type '%s' cannot be detached"),
                       virDomainDiskDeviceTypeToString(disk->device));
        break;
    }

    return ret;
}


3787 3788 3789
static bool qemuDomainDiskControllerIsBusy(virDomainObjPtr vm,
                                           virDomainControllerDefPtr detach)
{
3790
    size_t i;
3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836
    virDomainDiskDefPtr disk;

    for (i = 0; i < vm->def->ndisks; i++) {
        disk = vm->def->disks[i];
        if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE)
            /* the disk does not use disk controller */
            continue;

        /* check whether the disk uses this type controller */
        if (disk->bus == VIR_DOMAIN_DISK_BUS_IDE &&
            detach->type != VIR_DOMAIN_CONTROLLER_TYPE_IDE)
            continue;
        if (disk->bus == VIR_DOMAIN_DISK_BUS_FDC &&
            detach->type != VIR_DOMAIN_CONTROLLER_TYPE_FDC)
            continue;
        if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI &&
            detach->type != VIR_DOMAIN_CONTROLLER_TYPE_SCSI)
            continue;

        if (disk->info.addr.drive.controller == detach->idx)
            return true;
    }

    return false;
}

static bool qemuDomainControllerIsBusy(virDomainObjPtr vm,
                                       virDomainControllerDefPtr detach)
{
    switch (detach->type) {
    case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
    case VIR_DOMAIN_CONTROLLER_TYPE_FDC:
    case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
        return qemuDomainDiskControllerIsBusy(vm, detach);

    case VIR_DOMAIN_CONTROLLER_TYPE_SATA:
    case VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL:
    case VIR_DOMAIN_CONTROLLER_TYPE_CCID:
    default:
        /* libvirt does not support sata controller, and does not support to
         * detach virtio and smart card controller.
         */
        return true;
    }
}

3837 3838 3839
int qemuDomainDetachControllerDevice(virQEMUDriverPtr driver,
                                     virDomainObjPtr vm,
                                     virDomainDeviceDefPtr dev)
3840
{
3841
    int idx, ret = -1;
3842 3843 3844
    virDomainControllerDefPtr detach = NULL;
    qemuDomainObjPrivatePtr priv = vm->privateData;

3845 3846 3847
    if ((idx = virDomainControllerFind(vm->def,
                                       dev->data.controller->type,
                                       dev->data.controller->idx)) < 0) {
3848
        virReportError(VIR_ERR_OPERATION_FAILED,
3849
                       _("controller %s:%d not found"),
3850 3851
                       virDomainControllerTypeToString(dev->data.controller->type),
                       dev->data.controller->idx);
3852 3853 3854
        goto cleanup;
    }

3855 3856
    detach = vm->def->controllers[idx];

3857 3858 3859 3860 3861 3862
    if (detach->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI &&
        detach->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW &&
        detach->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390) {
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("device with '%s' address cannot be detached"),
                       virDomainDeviceAddressTypeToString(detach->info.type));
3863 3864 3865
        goto cleanup;
    }

3866 3867 3868 3869 3870 3871 3872 3873 3874
    if (!virDomainDeviceAddressIsValid(&detach->info, detach->info.type)) {
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("device with invalid '%s' address cannot be detached"),
                       virDomainDeviceAddressTypeToString(detach->info.type));
        goto cleanup;
    }

    if (detach->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI &&
        qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
3875 3876 3877
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("cannot hot unplug multifunction PCI device: %s"),
                       dev->data.disk->dst);
3878 3879 3880
        goto cleanup;
    }

3881
    if (qemuDomainControllerIsBusy(vm, detach)) {
3882 3883
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("device cannot be detached: device is busy"));
3884 3885 3886
        goto cleanup;
    }

3887
    if (!detach->info.alias) {
3888
        if (qemuAssignDeviceControllerAlias(vm->def, priv->qemuCaps, detach) < 0)
3889 3890 3891
            goto cleanup;
    }

3892 3893
    qemuDomainMarkDeviceForRemoval(vm, &detach->info);

3894
    qemuDomainObjEnterMonitor(driver, vm);
3895 3896 3897
    if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
        ignore_value(qemuDomainObjExitMonitor(driver, vm));
        goto cleanup;
3898
    }
3899 3900
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
3901

3902
    if ((ret = qemuDomainWaitForDeviceRemoval(vm)) == 1)
3903
        ret = qemuDomainRemoveControllerDevice(driver, vm, detach);
3904

3905
 cleanup:
3906
    qemuDomainResetDeviceRemoval(vm);
3907 3908 3909
    return ret;
}

3910
static int
3911
qemuDomainDetachHostPCIDevice(virQEMUDriverPtr driver,
3912
                              virDomainObjPtr vm,
3913
                              virDomainHostdevDefPtr detach)
3914 3915
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
3916
    virDomainHostdevSubsysPCIPtr pcisrc = &detach->source.subsys.u.pci;
3917
    int ret;
3918

3919
    if (qemuIsMultiFunctionDevice(vm->def, detach->info)) {
3920 3921
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("cannot hot unplug multifunction PCI device: %.4x:%.2x:%.2x.%.1x"),
3922 3923
                       pcisrc->addr.domain, pcisrc->addr.bus,
                       pcisrc->addr.slot, pcisrc->addr.function);
3924
        return -1;
3925 3926
    }

3927
    if (!virDomainDeviceAddressIsValid(detach->info,
3928
                                       VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
3929 3930
        virReportError(VIR_ERR_OPERATION_FAILED,
                       "%s", _("device cannot be detached without a PCI address"));
3931
        return -1;
3932 3933
    }

3934 3935
    qemuDomainMarkDeviceForRemoval(vm, detach->info);

3936
    qemuDomainObjEnterMonitor(driver, vm);
3937
    ret = qemuMonitorDelDevice(priv->mon, detach->info->alias);
3938 3939
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        ret = -1;
3940 3941 3942 3943

    return ret;
}

3944
static int
3945
qemuDomainDetachHostUSBDevice(virQEMUDriverPtr driver,
3946
                              virDomainObjPtr vm,
3947
                              virDomainHostdevDefPtr detach)
3948 3949
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
3950
    int ret;
3951

3952
    if (!detach->info->alias) {
3953 3954
        virReportError(VIR_ERR_OPERATION_FAILED,
                       "%s", _("device cannot be detached without a device alias"));
3955 3956 3957
        return -1;
    }

3958 3959
    qemuDomainMarkDeviceForRemoval(vm, detach->info);

3960
    qemuDomainObjEnterMonitor(driver, vm);
3961
    ret = qemuMonitorDelDevice(priv->mon, detach->info->alias);
3962 3963
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        ret = -1;
3964 3965 3966 3967

    return ret;
}

3968
static int
3969
qemuDomainDetachHostSCSIDevice(virQEMUDriverPtr driver,
3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981
                               virDomainObjPtr vm,
                               virDomainHostdevDefPtr detach)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int ret = -1;

    if (!detach->info->alias) {
        virReportError(VIR_ERR_OPERATION_FAILED,
                       "%s", _("device cannot be detached without a device alias"));
        return -1;
    }

3982 3983
    qemuDomainMarkDeviceForRemoval(vm, detach->info);

3984
    qemuDomainObjEnterMonitor(driver, vm);
3985 3986 3987 3988
    ret = qemuMonitorDelDevice(priv->mon, detach->info->alias);

    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
3989 3990 3991 3992 3993

    return ret;
}

static int
3994
qemuDomainDetachThisHostDevice(virQEMUDriverPtr driver,
3995
                               virDomainObjPtr vm,
3996
                               virDomainHostdevDefPtr detach)
3997
{
3998
    int ret = -1;
3999

4000
    if (!detach->info->alias) {
4001
        if (qemuAssignDeviceHostdevAlias(vm->def, &detach->info->alias, -1) < 0)
4002 4003 4004
            return -1;
    }

4005
    switch (detach->source.subsys.type) {
4006
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
4007
        ret = qemuDomainDetachHostPCIDevice(driver, vm, detach);
4008
        break;
4009
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
4010
        ret = qemuDomainDetachHostUSBDevice(driver, vm, detach);
4011
        break;
4012
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI:
4013
        ret = qemuDomainDetachHostSCSIDevice(driver, vm, detach);
4014
        break;
4015
    default:
4016 4017 4018
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("hostdev subsys type '%s' not supported"),
                       virDomainHostdevSubsysTypeToString(detach->source.subsys.type));
4019 4020 4021
        return -1;
    }

4022
    if (ret < 0) {
4023 4024
        if (virDomainObjIsActive(vm))
            virDomainAuditHostdev(vm, detach, "detach", false);
4025 4026
    } else if ((ret = qemuDomainWaitForDeviceRemoval(vm)) == 1) {
        ret = qemuDomainRemoveHostDevice(driver, vm, detach);
4027
    }
4028

4029 4030
    qemuDomainResetDeviceRemoval(vm);

4031 4032
    return ret;
}
4033

4034
/* search for a hostdev matching dev and detach it */
4035
int qemuDomainDetachHostDevice(virQEMUDriverPtr driver,
4036 4037 4038 4039 4040
                               virDomainObjPtr vm,
                               virDomainDeviceDefPtr dev)
{
    virDomainHostdevDefPtr hostdev = dev->data.hostdev;
    virDomainHostdevSubsysPtr subsys = &hostdev->source.subsys;
4041
    virDomainHostdevSubsysUSBPtr usbsrc = &subsys->u.usb;
4042
    virDomainHostdevSubsysPCIPtr pcisrc = &subsys->u.pci;
4043
    virDomainHostdevSubsysSCSIPtr scsisrc = &subsys->u.scsi;
4044 4045 4046 4047
    virDomainHostdevDefPtr detach = NULL;
    int idx;

    if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
4048 4049 4050
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("hostdev mode '%s' not supported"),
                       virDomainHostdevModeTypeToString(hostdev->mode));
4051 4052 4053 4054 4055 4056
        return -1;
    }

    idx = virDomainHostdevFind(vm->def, hostdev, &detach);

    if (idx < 0) {
4057
        switch (subsys->type) {
4058
        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
4059 4060
            virReportError(VIR_ERR_OPERATION_FAILED,
                           _("host pci device %.4x:%.2x:%.2x.%.1x not found"),
4061 4062
                           pcisrc->addr.domain, pcisrc->addr.bus,
                           pcisrc->addr.slot, pcisrc->addr.function);
4063 4064
            break;
        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
4065
            if (usbsrc->bus && usbsrc->device) {
4066 4067
                virReportError(VIR_ERR_OPERATION_FAILED,
                               _("host usb device %03d.%03d not found"),
4068
                               usbsrc->bus, usbsrc->device);
4069
            } else {
4070 4071
                virReportError(VIR_ERR_OPERATION_FAILED,
                               _("host usb device vendor=0x%.4x product=0x%.4x not found"),
4072
                               usbsrc->vendor, usbsrc->product);
4073 4074
            }
            break;
4075
        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI: {
4076 4077 4078 4079 4080 4081 4082 4083 4084 4085
            if (scsisrc->protocol ==
                VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
                virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
                virReportError(VIR_ERR_OPERATION_FAILED,
                               _("host scsi iSCSI path %s not found"),
                               iscsisrc->path);
            } else {
                 virDomainHostdevSubsysSCSIHostPtr scsihostsrc =
                     &scsisrc->u.host;
                 virReportError(VIR_ERR_OPERATION_FAILED,
4086
                                _("host scsi device %s:%u:%u.%llu not found"),
4087 4088 4089
                                scsihostsrc->adapter, scsihostsrc->bus,
                                scsihostsrc->target, scsihostsrc->unit);
            }
4090
            break;
4091
        }
4092
        default:
4093 4094
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unexpected hostdev type %d"), subsys->type);
4095 4096 4097 4098 4099
            break;
        }
        return -1;
    }

4100 4101 4102 4103
    /* If this is a network hostdev, we need to use the higher-level detach
     * function so that mac address / virtualport are reset
     */
    if (detach->parent.type == VIR_DOMAIN_DEVICE_NET)
4104
        return qemuDomainDetachNetDevice(driver, vm, &detach->parent);
4105
    else
4106
        return qemuDomainDetachThisHostDevice(driver, vm, detach);
4107 4108
}

4109
int
4110
qemuDomainDetachNetDevice(virQEMUDriverPtr driver,
4111 4112 4113
                          virDomainObjPtr vm,
                          virDomainDeviceDefPtr dev)
{
4114
    int detachidx, ret = -1;
4115 4116 4117
    virDomainNetDefPtr detach = NULL;
    qemuDomainObjPrivatePtr priv = vm->privateData;

4118
    if ((detachidx = virDomainNetFindIdx(vm->def, dev->data.net)) < 0)
4119
        goto cleanup;
4120

4121
    detach = vm->def->nets[detachidx];
4122

4123
    if (virDomainNetGetActualType(detach) == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
4124
        /* coverity[negative_returns] */
4125
        ret = qemuDomainDetachThisHostDevice(driver, vm,
4126
                                             virDomainNetGetActualHostdev(detach));
4127 4128
        goto cleanup;
    }
4129
    if (qemuDomainMachineIsS390CCW(vm->def) &&
4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VIRTIO_CCW)) {
        if (!virDomainDeviceAddressIsValid(&detach->info,
                                           VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW)) {
            virReportError(VIR_ERR_OPERATION_FAILED,
                            "%s", _("device cannot be detached without a CCW address"));
            goto cleanup;
        }
    } else {
        if (!virDomainDeviceAddressIsValid(&detach->info,
                                           VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
            virReportError(VIR_ERR_OPERATION_FAILED,
                            "%s", _("device cannot be detached without a PCI address"));
            goto cleanup;
        }
4144

4145 4146 4147 4148 4149 4150
        if (qemuIsMultiFunctionDevice(vm->def, &detach->info)) {
            virReportError(VIR_ERR_OPERATION_FAILED,
                            _("cannot hot unplug multifunction PCI device :%s"),
                            dev->data.disk->dst);
            goto cleanup;
        }
4151 4152
    }

4153
    if (!detach->info.alias) {
4154 4155 4156 4157
        if (qemuAssignDeviceNetAlias(vm->def, detach, -1) < 0)
            goto cleanup;
    }

4158 4159
    if (virDomainNetGetActualBandwidth(detach) &&
        virNetDevSupportBandwidth(virDomainNetGetActualType(detach)) &&
4160 4161 4162 4163
        virNetDevBandwidthClear(detach->ifname) < 0)
        VIR_WARN("cannot clear bandwidth setting for device : %s",
                 detach->ifname);

4164 4165 4166
    /* deactivate the tap/macvtap device on the host, which could also
     * affect the parent device (e.g. macvtap passthrough mode sets
     * the parent device offline)
4167 4168 4169
     */
    ignore_value(qemuInterfaceStopDevice(detach));

4170 4171
    qemuDomainMarkDeviceForRemoval(vm, &detach->info);

4172
    qemuDomainObjEnterMonitor(driver, vm);
4173 4174
    if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
        if (qemuDomainObjExitMonitor(driver, vm) < 0)
4175
            goto cleanup;
4176 4177
        virDomainAuditNet(vm, detach, NULL, "detach", false);
        goto cleanup;
4178
    }
4179 4180
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
4181

4182
    if ((ret = qemuDomainWaitForDeviceRemoval(vm)) == 1)
4183
        ret = qemuDomainRemoveNetDevice(driver, vm, detach);
4184

4185
 cleanup:
4186
    qemuDomainResetDeviceRemoval(vm);
4187 4188 4189
    return ret;
}

4190
int
4191
qemuDomainChangeGraphicsPasswords(virQEMUDriverPtr driver,
4192 4193 4194
                                  virDomainObjPtr vm,
                                  int type,
                                  virDomainGraphicsAuthDefPtr auth,
4195 4196
                                  const char *defaultPasswd,
                                  int asyncJob)
4197 4198 4199
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    time_t now = time(NULL);
4200 4201
    const char *expire;
    char *validTo = NULL;
4202
    const char *connected = NULL;
4203
    const char *password;
4204 4205
    int ret = -1;
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4206

4207
    if (!auth->passwd && !defaultPasswd) {
4208 4209 4210
        ret = 0;
        goto cleanup;
    }
4211
    password = auth->passwd ? auth->passwd : defaultPasswd;
4212

4213 4214 4215
    if (auth->connected)
        connected = virDomainGraphicsAuthConnectedTypeToString(auth->connected);

4216 4217
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        goto cleanup;
4218
    ret = qemuMonitorSetPassword(priv->mon, type, password, connected);
4219 4220 4221

    if (ret == -2) {
        if (type != VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
4222 4223
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Graphics password only supported for VNC"));
4224 4225
            ret = -1;
        } else {
4226
            ret = qemuMonitorSetVNCPassword(priv->mon, password);
4227 4228
        }
    }
4229
    if (ret != 0)
4230
        goto end_job;
4231

4232 4233 4234
    if (password[0] == '\0' ||
        (auth->expires && auth->validTo <= now)) {
        expire = "now";
4235
    } else if (auth->expires) {
4236 4237 4238
        if (virAsprintf(&validTo, "%lu", (unsigned long) auth->validTo) < 0)
            goto end_job;
        expire = validTo;
4239
    } else {
4240
        expire = "never";
4241 4242
    }

4243
    ret = qemuMonitorExpirePassword(priv->mon, type, expire);
4244 4245 4246 4247

    if (ret == -2) {
        /* XXX we could fake this with a timer */
        if (auth->expires) {
4248 4249
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Expiry of passwords is not supported"));
4250
            ret = -1;
4251 4252
        } else {
            ret = 0;
4253 4254 4255
        }
    }

4256
 end_job:
4257 4258
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        ret = -1;
4259
 cleanup:
4260
    VIR_FREE(validTo);
4261
    virObjectUnref(cfg);
4262 4263
    return ret;
}
4264

4265
int qemuDomainAttachLease(virQEMUDriverPtr driver,
4266 4267 4268
                          virDomainObjPtr vm,
                          virDomainLeaseDefPtr lease)
{
4269 4270 4271
    int ret = -1;
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);

4272
    if (virDomainLeaseInsertPreAlloc(vm->def) < 0)
4273
        goto cleanup;
4274

4275
    if (virDomainLockLeaseAttach(driver->lockManager, cfg->uri,
4276
                                 vm, lease) < 0) {
4277
        virDomainLeaseInsertPreAlloced(vm->def, NULL);
4278
        goto cleanup;
4279 4280 4281
    }

    virDomainLeaseInsertPreAlloced(vm->def, lease);
4282 4283
    ret = 0;

4284
 cleanup:
4285 4286
    virObjectUnref(cfg);
    return ret;
4287 4288
}

4289
int qemuDomainDetachLease(virQEMUDriverPtr driver,
4290 4291 4292
                          virDomainObjPtr vm,
                          virDomainLeaseDefPtr lease)
{
4293
    virDomainLeaseDefPtr det_lease;
4294
    int idx;
4295

4296
    if ((idx = virDomainLeaseIndex(vm->def, lease)) < 0) {
4297 4298 4299
        virReportError(VIR_ERR_INVALID_ARG,
                       _("Lease %s in lockspace %s does not exist"),
                       lease->key, NULLSTR(lease->lockspace));
4300 4301 4302 4303 4304 4305
        return -1;
    }

    if (virDomainLockLeaseDetach(driver->lockManager, vm, lease) < 0)
        return -1;

4306
    det_lease = virDomainLeaseRemoveAt(vm->def, idx);
4307
    virDomainLeaseDefFree(det_lease);
4308 4309
    return 0;
}
4310 4311 4312 4313 4314 4315

int qemuDomainDetachChrDevice(virQEMUDriverPtr driver,
                              virDomainObjPtr vm,
                              virDomainChrDefPtr chr)
{
    int ret = -1;
4316
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4317 4318 4319
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainDefPtr vmdef = vm->def;
    virDomainChrDefPtr tmpChr;
4320
    char *objAlias = NULL;
4321 4322 4323 4324 4325
    char *devstr = NULL;

    if (!(tmpChr = virDomainChrFind(vmdef, chr))) {
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("device not present in domain configuration"));
4326
        goto cleanup;
4327 4328
    }

P
Pavel Hrdina 已提交
4329
    if (!tmpChr->info.alias && qemuAssignDeviceChrAlias(vmdef, tmpChr, -1) < 0)
4330
        goto cleanup;
P
Pavel Hrdina 已提交
4331 4332 4333

    sa_assert(tmpChr->info.alias);

4334 4335 4336 4337
    if (cfg->chardevTLS &&
        !(objAlias = qemuAliasTLSObjFromChardevAlias(tmpChr->info.alias)))
        goto cleanup;

4338
    if (qemuBuildChrDeviceStr(&devstr, vmdef, chr, priv->qemuCaps) < 0)
4339
        goto cleanup;
4340

4341 4342
    qemuDomainMarkDeviceForRemoval(vm, &tmpChr->info);

4343
    qemuDomainObjEnterMonitor(driver, vm);
4344 4345 4346 4347 4348 4349
    if (devstr && qemuMonitorDelDevice(priv->mon, tmpChr->info.alias) < 0)
        goto exit_monitor;

    if (objAlias && qemuMonitorDelObject(priv->mon, objAlias) < 0)
        goto exit_monitor;

4350 4351
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
4352

4353
    if ((ret = qemuDomainWaitForDeviceRemoval(vm)) == 1) {
4354
        qemuDomainReleaseDeviceAddress(vm, &tmpChr->info, NULL);
4355
        ret = qemuDomainRemoveChrDevice(driver, vm, tmpChr);
4356 4357
    }

4358
 cleanup:
4359
    qemuDomainResetDeviceRemoval(vm);
4360
    VIR_FREE(devstr);
4361
    virObjectUnref(cfg);
4362
    return ret;
4363 4364 4365 4366

 exit_monitor:
    ignore_value(qemuDomainObjExitMonitor(driver, vm));
    goto cleanup;
4367
}
4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401


int
qemuDomainDetachRNGDevice(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
                          virDomainRNGDefPtr rng)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    ssize_t idx;
    virDomainRNGDefPtr tmpRNG;
    int rc;
    int ret = -1;

    if ((idx = virDomainRNGFind(vm->def, rng) < 0)) {
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("device not present in domain configuration"));
        return -1;
    }

    tmpRNG = vm->def->rngs[idx];

    if (!tmpRNG->info.alias) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("alias not set for RNG device"));
        return -1;
    }

    qemuDomainMarkDeviceForRemoval(vm, &tmpRNG->info);

    qemuDomainObjEnterMonitor(driver, vm);
    rc = qemuMonitorDelDevice(priv->mon, tmpRNG->info.alias);
    if (qemuDomainObjExitMonitor(driver, vm) || rc < 0)
        goto cleanup;

4402
    if ((ret = qemuDomainWaitForDeviceRemoval(vm)) == 1)
4403 4404 4405 4406 4407 4408
        ret = qemuDomainRemoveRNGDevice(driver, vm, tmpRNG);

 cleanup:
    qemuDomainResetDeviceRemoval(vm);
    return ret;
}
4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421


int
qemuDomainDetachMemoryDevice(virQEMUDriverPtr driver,
                             virDomainObjPtr vm,
                             virDomainMemoryDefPtr memdef)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainMemoryDefPtr mem;
    int idx;
    int rc;
    int ret = -1;

4422
    qemuDomainMemoryDeviceAlignSize(vm->def, memdef);
4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444

    if ((idx = virDomainMemoryFindByDef(vm->def, memdef)) < 0) {
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("device not present in domain configuration"));
        return -1;
    }

    mem = vm->def->mems[idx];

    if (!mem->info.alias) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("alias for the memory device was not found"));
        return -1;
    }

    qemuDomainMarkDeviceForRemoval(vm, &mem->info);

    qemuDomainObjEnterMonitor(driver, vm);
    rc = qemuMonitorDelDevice(priv->mon, mem->info.alias);
    if (qemuDomainObjExitMonitor(driver, vm) < 0 || rc < 0)
        goto cleanup;

4445
    if ((ret = qemuDomainWaitForDeviceRemoval(vm)) == 1)
4446 4447 4448 4449 4450 4451
        ret = qemuDomainRemoveMemoryDevice(driver, vm, mem);

 cleanup:
    qemuDomainResetDeviceRemoval(vm);
    return ret;
}
4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559


static int
qemuDomainRemoveVcpu(virQEMUDriverPtr driver,
                     virDomainObjPtr vm,
                     unsigned int vcpu)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainVcpuDefPtr vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu);
    qemuDomainVcpuPrivatePtr vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo);
    int oldvcpus = virDomainDefGetVcpus(vm->def);
    unsigned int nvcpus = vcpupriv->vcpus;
    size_t i;

    if (qemuDomainRefreshVcpuInfo(driver, vm, QEMU_ASYNC_JOB_NONE, false) < 0)
        return -1;

    /* validation requires us to set the expected state prior to calling it */
    for (i = vcpu; i < vcpu + nvcpus; i++) {
        vcpuinfo = virDomainDefGetVcpu(vm->def, i);
        vcpuinfo->online = false;
    }

    if (qemuDomainValidateVcpuInfo(vm) < 0) {
        /* rollback vcpu count if the setting has failed */
        virDomainAuditVcpu(vm, oldvcpus, oldvcpus - nvcpus, "update", false);

        for (i = vcpu; i < vcpu + nvcpus; i++) {
            vcpuinfo = virDomainDefGetVcpu(vm->def, i);
            vcpuinfo->online = true;
        }
        return -1;
    }

    virDomainAuditVcpu(vm, oldvcpus, oldvcpus - nvcpus, "update", true);

    for (i = vcpu; i < vcpu + nvcpus; i++) {
        vcpuinfo = virDomainDefGetVcpu(vm->def, i);
        if (virCgroupDelThread(priv->cgroup, VIR_CGROUP_THREAD_VCPU, i) < 0)
            return -1;
    }

    return 0;
}


void
qemuDomainRemoveVcpuAlias(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
                          const char *alias)
{
    virDomainVcpuDefPtr vcpu;
    qemuDomainVcpuPrivatePtr vcpupriv;
    size_t i;

    for (i = 0; i < virDomainDefGetVcpusMax(vm->def); i++) {
        vcpu = virDomainDefGetVcpu(vm->def, i);
        vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);

        if (STREQ_NULLABLE(alias, vcpupriv->alias)) {
            qemuDomainRemoveVcpu(driver, vm, i);
            return;
        }
    }
}


int
qemuDomainHotplugDelVcpu(virQEMUDriverPtr driver,
                         virDomainObjPtr vm,
                         unsigned int vcpu)
{
    virDomainVcpuDefPtr vcpuinfo = virDomainDefGetVcpu(vm->def, vcpu);
    qemuDomainVcpuPrivatePtr vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpuinfo);
    int oldvcpus = virDomainDefGetVcpus(vm->def);
    unsigned int nvcpus = vcpupriv->vcpus;
    int rc;

    if (!vcpupriv->alias) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("vcpu '%u' can't be unplugged"), vcpu);
        return -1;
    }

    qemuDomainMarkDeviceAliasForRemoval(vm, vcpupriv->alias);

    qemuDomainObjEnterMonitor(driver, vm);

    rc = qemuMonitorDelDevice(qemuDomainGetMonitor(vm), vcpupriv->alias);

    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;

    if (rc < 0) {
        virDomainAuditVcpu(vm, oldvcpus, oldvcpus - nvcpus, "update", false);
        return -1;
    }

    if ((rc = qemuDomainWaitForDeviceRemoval(vm)) <= 0) {
        if (rc == 0)
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("vcpu unplug request timed out"));

        return -1;
    }

    return qemuDomainRemoveVcpu(driver, vm, vcpu);
}