qemu_driver.c 206.0 KB
Newer Older
D
Daniel P. Berrange 已提交
1 2 3
/*
 * driver.c: core driver methods for managing qemu guests
 *
4
 * Copyright (C) 2006, 2007, 2008, 2009 Red Hat, Inc.
D
Daniel P. Berrange 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * 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
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

24
#include <config.h>
25

D
Daniel P. Berrange 已提交
26 27 28 29 30
#include <sys/types.h>
#include <sys/poll.h>
#include <dirent.h>
#include <limits.h>
#include <string.h>
31
#include <stdbool.h>
D
Daniel P. Berrange 已提交
32 33 34 35 36 37
#include <stdio.h>
#include <strings.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
38
#include <sys/utsname.h>
39 40 41 42
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <paths.h>
43 44
#include <pwd.h>
#include <stdio.h>
45
#include <sys/wait.h>
46
#include <sys/ioctl.h>
47
#include <sys/un.h>
D
Daniel P. Berrange 已提交
48

49 50 51 52
#if HAVE_SCHED_H
#include <sched.h>
#endif

53
#include "virterror_internal.h"
54
#include "logging.h"
55
#include "datatypes.h"
56 57
#include "qemu_driver.h"
#include "qemu_conf.h"
58
#include "qemu_monitor_text.h"
J
Jim Meyering 已提交
59
#include "c-ctype.h"
60
#include "event.h"
61
#include "buf.h"
62
#include "util.h"
63
#include "nodeinfo.h"
64
#include "stats_linux.h"
65
#include "capabilities.h"
66
#include "memory.h"
67
#include "uuid.h"
68
#include "domain_conf.h"
69 70
#include "node_device_conf.h"
#include "pci.h"
71
#include "hostusb.h"
72
#include "security/security_driver.h"
73
#include "cgroup.h"
74

75

76 77
#define VIR_FROM_THIS VIR_FROM_QEMU

78 79
static int qemudShutdown(void);

80 81
static void qemuDriverLock(struct qemud_driver *driver)
{
82
    virMutexLock(&driver->lock);
83 84 85
}
static void qemuDriverUnlock(struct qemud_driver *driver)
{
86
    virMutexUnlock(&driver->lock);
87 88
}

89 90 91
static void qemuDomainEventFlush(int timer, void *opaque);
static void qemuDomainEventQueue(struct qemud_driver *driver,
                                 virDomainEventPtr event);
92

93 94
static void qemudDispatchVMEvent(int watch,
                                 int fd,
95 96 97
                                 int events,
                                 void *opaque);

98 99
static int qemudStartVMDaemon(virConnectPtr conn,
                              struct qemud_driver *driver,
100
                              virDomainObjPtr vm,
101 102
                              const char *migrateFrom,
                              int stdin_fd);
103

104 105
static void qemudShutdownVMDaemon(virConnectPtr conn,
                                  struct qemud_driver *driver,
106
                                  virDomainObjPtr vm);
107

108
static int qemudDomainGetMaxVcpus(virDomainPtr dom);
109

110 111
static int qemuDetectVcpuPIDs(virConnectPtr conn,
                              virDomainObjPtr vm);
112

113 114 115
static int qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
                                       virDomainDefPtr def);

J
Jim Meyering 已提交
116
static struct qemud_driver *qemu_driver = NULL;
117

118 119 120 121 122 123 124 125 126
static int qemuCgroupControllerActive(struct qemud_driver *driver,
                                      int controller)
{
    if (driver->cgroup == NULL)
        return 0;
    if (driver->cgroupControllers & (1 << controller))
        return 1;
    return 0;
}
127

128
static int
129
qemudLogFD(virConnectPtr conn, struct qemud_driver *driver, const char* name)
130 131 132
{
    char logfile[PATH_MAX];
    mode_t logmode;
G
Guido Günther 已提交
133
    int ret, fd = -1;
134

135 136
    if ((ret = snprintf(logfile, sizeof(logfile), "%s/%s.log",
                        driver->logDir, name))
G
Guido Günther 已提交
137
        < 0 || ret >= sizeof(logfile)) {
138
        virReportOOMError(conn);
139 140 141 142
        return -1;
    }

    logmode = O_CREAT | O_WRONLY;
143 144
    /* Only logrotate files in /var/log, so only append if running privileged */
    if (driver->privileged)
145
        logmode |= O_APPEND;
146 147 148
    else
        logmode |= O_TRUNC;

149
    if ((fd = open(logfile, logmode, S_IRUSR | S_IWUSR)) < 0) {
150 151 152
        virReportSystemError(conn, errno,
                             _("failed to create logfile %s"),
                             logfile);
153 154
        return -1;
    }
155
    if (virSetCloseExec(fd) < 0) {
156 157
        virReportSystemError(conn, errno, "%s",
                             _("Unable to set VM logfile close-on-exec flag"));
158 159 160 161 162 163 164
        close(fd);
        return -1;
    }
    return fd;
}


165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
static int
qemudLogReadFD(virConnectPtr conn, const char* logDir, const char* name, off_t pos)
{
    char logfile[PATH_MAX];
    mode_t logmode = O_RDONLY;
    int ret, fd = -1;

    if ((ret = snprintf(logfile, sizeof(logfile), "%s/%s.log", logDir, name))
        < 0 || ret >= sizeof(logfile)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("failed to build logfile name %s/%s.log"),
                         logDir, name);
        return -1;
    }


    if ((fd = open(logfile, logmode)) < 0) {
182 183 184
        virReportSystemError(conn, errno,
                             _("failed to create logfile %s"),
                             logfile);
185 186
        return -1;
    }
187
    if (virSetCloseExec(fd) < 0) {
188 189
        virReportSystemError(conn, errno, "%s",
                             _("Unable to set VM logfile close-on-exec flag"));
190 191 192 193
        close(fd);
        return -1;
    }
    if (lseek(fd, pos, SEEK_SET) < 0) {
194 195 196
        virReportSystemError(conn, errno,
                             _("Unable to seek to %lld in %s"),
                             (long long) pos, logfile);
197 198 199 200 201 202
        close(fd);
    }
    return fd;
}


203 204 205
static void
qemudAutostartConfigs(struct qemud_driver *driver) {
    unsigned int i;
206 207 208 209 210
    /* XXX: Figure out a better way todo this. The domain
     * startup code needs a connection handle in order
     * to lookup the bridge associated with a virtual
     * network
     */
211 212 213
    virConnectPtr conn = virConnectOpen(driver->privileged ?
                                        "qemu:///system" :
                                        "qemu:///session");
214
    /* Ignoring NULL conn which is mostly harmless here */
215

216
    qemuDriverLock(driver);
217
    for (i = 0 ; i < driver->domains.count ; i++) {
218
        virDomainObjPtr vm = driver->domains.objs[i];
219
        virDomainObjLock(vm);
220 221
        if (vm->autostart &&
            !virDomainIsActive(vm)) {
222 223 224 225
            int ret;

            virResetLastError();
            ret = qemudStartVMDaemon(conn, driver, vm, NULL, -1);
226 227
            if (ret < 0) {
                virErrorPtr err = virGetLastError();
228 229
                VIR_ERROR(_("Failed to autostart VM '%s': %s\n"),
                          vm->def->name,
230
                          err ? err->message : "");
231
            } else {
232 233 234 235 236 237
                virDomainEventPtr event =
                    virDomainEventNewFromObj(vm,
                                             VIR_DOMAIN_EVENT_STARTED,
                                             VIR_DOMAIN_EVENT_STARTED_BOOTED);
                if (event)
                    qemuDomainEventQueue(driver, event);
238
            }
239
        }
240
        virDomainObjUnlock(vm);
241
    }
242
    qemuDriverUnlock(driver);
243

244 245
    if (conn)
        virConnectClose(conn);
246 247
}

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264

/**
 * qemudRemoveDomainStatus
 *
 * remove all state files of a domain from statedir
 *
 * Returns 0 on success
 */
static int
qemudRemoveDomainStatus(virConnectPtr conn,
                        struct qemud_driver *driver,
                        virDomainObjPtr vm)
{
    int rc = -1;
    char *file = NULL;

    if (virAsprintf(&file, "%s/%s.xml", driver->stateDir, vm->def->name) < 0) {
265
        virReportOOMError(conn);
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
        goto cleanup;
    }

    if (unlink(file) < 0 && errno != ENOENT && errno != ENOTDIR) {
        qemudReportError(conn, vm, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Failed to unlink status file %s"), file);
        goto cleanup;
    }

    if(virFileDeletePid(driver->stateDir, vm->def->name))
        goto cleanup;

    rc = 0;
cleanup:
    VIR_FREE(file);
    return rc;
}


285 286 287 288 289
static int qemudOpenMonitor(virConnectPtr conn,
                            struct qemud_driver* driver,
                            virDomainObjPtr vm,
                            int reconnect);

290 291 292 293

/*
 * Open an existing VM's monitor, re-detect VCPU threads
 * and re-reserve the security labels in use
294 295
 */
static int
296 297
qemuReconnectDomain(struct qemud_driver *driver,
                    virDomainObjPtr obj)
298
{
299
    int rc;
300

301
    if ((rc = qemudOpenMonitor(NULL, driver, obj, 1)) != 0) {
302 303 304 305
        VIR_ERROR(_("Failed to reconnect monitor for %s: %d\n"),
                  obj->def->name, rc);
        goto error;
    }
306

307 308 309 310
    if (qemuUpdateActivePciHostdevs(driver, obj->def) < 0) {
        goto error;
    }

311 312 313 314 315
    if (obj->def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC &&
        driver->securityDriver &&
        driver->securityDriver->domainReserveSecurityLabel &&
        driver->securityDriver->domainReserveSecurityLabel(NULL, obj) < 0)
        return -1;
316

317 318
    if (obj->def->id >= driver->nextvmid)
        driver->nextvmid = obj->def->id + 1;
319

320
    return 0;
321

322 323 324
error:
    return -1;
}
325

326 327 328 329 330 331 332 333 334 335
/**
 * qemudReconnectVMs
 *
 * Try to re-open the resources for live VMs that we care
 * about.
 */
static void
qemuReconnectDomains(struct qemud_driver *driver)
{
    int i;
336

337 338 339 340 341 342 343 344 345
    for (i = 0 ; i < driver->domains.count ; i++) {
        virDomainObjPtr obj = driver->domains.objs[i];

        virDomainObjLock(obj);
        if (qemuReconnectDomain(driver, obj) < 0) {
            /* If we can't get the monitor back, then kill the VM
             * so user has ability to start it again later without
             * danger of ending up running twice */
            qemudShutdownVMDaemon(NULL, driver, obj);
346
        }
347
        virDomainObjUnlock(obj);
348 349 350
    }
}

351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383

static int
qemudSecurityCapsInit(virSecurityDriverPtr secdrv,
                      virCapsPtr caps)
{
    const char *doi, *model;

    doi = virSecurityDriverGetDOI(secdrv);
    model = virSecurityDriverGetModel(secdrv);

    caps->host.secModel.model = strdup(model);
    if (!caps->host.secModel.model) {
        char ebuf[1024];
        VIR_ERROR(_("Failed to copy secModel model: %s"),
                  virStrerror(errno, ebuf, sizeof ebuf));
        return -1;
    }

    caps->host.secModel.doi = strdup(doi);
    if (!caps->host.secModel.doi) {
        char ebuf[1024];
        VIR_ERROR(_("Failed to copy secModel DOI: %s"),
                  virStrerror(errno, ebuf, sizeof ebuf));
        return -1;
    }

    VIR_DEBUG("Initialized caps for security driver \"%s\" with "
              "DOI \"%s\"", model, doi);

    return 0;
}


384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
static int
qemudSecurityInit(struct qemud_driver *qemud_drv)
{
    int ret;
    virSecurityDriverPtr security_drv;

    ret = virSecurityDriverStartup(&security_drv,
                                   qemud_drv->securityDriverName);
    if (ret == -1) {
        VIR_ERROR0(_("Failed to start security driver"));
        return -1;
    }
    /* No security driver wanted to be enabled: just return */
    if (ret == -2) {
        VIR_INFO0(_("No security driver available"));
        return 0;
    }

    qemud_drv->securityDriver = security_drv;

404
    VIR_INFO("Initialized security driver %s", security_drv->name);
405 406 407 408 409

    /*
     * Add security policy host caps now that the security driver is
     * initialized.
     */
410 411
    return qemudSecurityCapsInit(security_drv, qemud_drv->caps);
}
412 413


414

415 416 417 418 419 420
/**
 * qemudStartup:
 *
 * Initialization function for the QEmu daemon
 */
static int
421
qemudStartup(int privileged) {
422
    char *base = NULL;
D
Daniel P. Berrange 已提交
423
    char driverConf[PATH_MAX];
424
    int rc;
425

426
    if (VIR_ALLOC(qemu_driver) < 0)
427 428
        return -1;

429
    if (virMutexInit(&qemu_driver->lock) < 0) {
430
        VIR_ERROR("%s", _("cannot initialize mutex"));
431 432 433
        VIR_FREE(qemu_driver);
        return -1;
    }
434
    qemuDriverLock(qemu_driver);
435
    qemu_driver->privileged = privileged;
436

437 438 439
    /* Don't have a dom0 so start from 1 */
    qemu_driver->nextvmid = 1;

440 441
    /* Init callback list */
    if(VIR_ALLOC(qemu_driver->domainEventCallbacks) < 0)
442
        goto out_of_memory;
443 444 445 446 447 448
    if (!(qemu_driver->domainEventQueue = virDomainEventQueueNew()))
        goto out_of_memory;

    if ((qemu_driver->domainEventTimer =
         virEventAddTimeout(-1, qemuDomainEventFlush, qemu_driver, NULL)) < 0)
        goto error;
449

450
    if (privileged) {
451 452
        if (virAsprintf(&qemu_driver->logDir,
                        "%s/log/libvirt/qemu", LOCAL_STATE_DIR) == -1)
453
            goto out_of_memory;
454

D
Daniel P. Berrange 已提交
455
        if ((base = strdup (SYSCONF_DIR "/libvirt")) == NULL)
456
            goto out_of_memory;
457 458

        if (virAsprintf(&qemu_driver->stateDir,
459
                      "%s/run/libvirt/qemu", LOCAL_STATE_DIR) == -1)
460
            goto out_of_memory;
461 462 463 464 465 466 467 468

        if (virAsprintf(&qemu_driver->libDir,
                      "%s/lib/libvirt/qemu", LOCAL_STATE_DIR) == -1)
            goto out_of_memory;

        if (virAsprintf(&qemu_driver->cacheDir,
                      "%s/cache/libvirt/qemu", LOCAL_STATE_DIR) == -1)
            goto out_of_memory;
469
    } else {
470
        uid_t uid = geteuid();
471 472
        char *userdir = virGetUserDirectory(NULL, uid);
        if (!userdir)
473
            goto error;
474

475
        if (virAsprintf(&qemu_driver->logDir,
476 477
                        "%s/.libvirt/qemu/log", userdir) == -1) {
            VIR_FREE(userdir);
478
            goto out_of_memory;
479
        }
480

481 482
        if (virAsprintf(&base, "%s/.libvirt", userdir) == -1) {
            VIR_FREE(userdir);
483
            goto out_of_memory;
484 485
        }
        VIR_FREE(userdir);
486 487 488

        if (virAsprintf(&qemu_driver->stateDir, "%s/qemu/run", base) == -1)
            goto out_of_memory;
489 490 491 492
        if (virAsprintf(&qemu_driver->libDir, "%s/qemu/lib", base) == -1)
            goto out_of_memory;
        if (virAsprintf(&qemu_driver->cacheDir, "%s/qemu/cache", base) == -1)
            goto out_of_memory;
493 494 495
    }

    if (virFileMakePath(qemu_driver->stateDir) < 0) {
496
        char ebuf[1024];
497 498
        VIR_ERROR(_("Failed to create state dir '%s': %s\n"),
                  qemu_driver->stateDir, virStrerror(errno, ebuf, sizeof ebuf));
499
        goto error;
500
    }
501 502 503 504 505 506 507 508 509 510 511 512
    if (virFileMakePath(qemu_driver->libDir) < 0) {
        char ebuf[1024];
        VIR_ERROR(_("Failed to create lib dir '%s': %s\n"),
                  qemu_driver->libDir, virStrerror(errno, ebuf, sizeof ebuf));
        goto error;
    }
    if (virFileMakePath(qemu_driver->cacheDir) < 0) {
        char ebuf[1024];
        VIR_ERROR(_("Failed to create cache dir '%s': %s\n"),
                  qemu_driver->cacheDir, virStrerror(errno, ebuf, sizeof ebuf));
        goto error;
    }
513 514 515 516

    /* Configuration paths are either ~/.libvirt/qemu/... (session) or
     * /etc/libvirt/qemu/... (system).
     */
D
Daniel P. Berrange 已提交
517
    if (snprintf (driverConf, sizeof(driverConf), "%s/qemu.conf", base) == -1)
518
        goto out_of_memory;
D
Daniel P. Berrange 已提交
519
    driverConf[sizeof(driverConf)-1] = '\0';
520

521
    if (virAsprintf(&qemu_driver->configDir, "%s/qemu", base) == -1)
522 523
        goto out_of_memory;

524
    if (virAsprintf(&qemu_driver->autostartDir, "%s/qemu/autostart", base) == -1)
525 526
        goto out_of_memory;

527
    VIR_FREE(base);
528

529 530 531 532 533 534 535
    rc = virCgroupForDriver("qemu", &qemu_driver->cgroup, privileged, 1);
    if (rc < 0) {
        char buf[1024];
        VIR_WARN("Unable to create cgroup for driver: %s",
                 virStrerror(-rc, buf, sizeof(buf)));
    }

536
    if ((qemu_driver->caps = qemudCapsInit(NULL)) == NULL)
537
        goto out_of_memory;
D
Daniel P. Berrange 已提交
538

539 540 541
    if ((qemu_driver->activePciHostdevs = pciDeviceListNew(NULL)) == NULL)
        goto error;

542
    if (qemudLoadDriverConfig(qemu_driver, driverConf) < 0) {
543 544 545
        goto error;
    }

546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
    if (privileged) {
        if (chown(qemu_driver->libDir, qemu_driver->user, qemu_driver->group) < 0) {
            virReportSystemError(NULL, errno,
                                 _("unable to set ownership of '%s' to user %d:%d"),
                                 qemu_driver->libDir, qemu_driver->user, qemu_driver->group);
            goto error;
        }
        if (chown(qemu_driver->cacheDir, qemu_driver->user, qemu_driver->group) < 0) {
            virReportSystemError(NULL, errno,
                                 _("unable to set ownership of '%s' to %d:%d"),
                                 qemu_driver->cacheDir, qemu_driver->user, qemu_driver->group);
            goto error;
        }
    }

561
    if (qemudSecurityInit(qemu_driver) < 0) {
562
        goto error;
D
Daniel P. Berrange 已提交
563 564
    }

565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
    /* If hugetlbfs is present, then we need to create a sub-directory within
     * it, since we can't assume the root mount point has permissions that
     * will let our spawned QEMU instances use it.
     *
     * NB the check for '/', since user may config "" to disable hugepages
     * even when mounted
     */
    if (qemu_driver->hugetlbfs_mount &&
        qemu_driver->hugetlbfs_mount[0] == '/') {
        char *mempath = NULL;
        if (virAsprintf(&mempath, "%s/libvirt/qemu", qemu_driver->hugetlbfs_mount) < 0)
            goto out_of_memory;

        if ((rc = virFileMakePath(mempath)) != 0) {
            virReportSystemError(NULL, rc,
                                 _("unable to create hugepage path %s"), mempath);
            VIR_FREE(mempath);
            goto error;
        }
        if (qemu_driver->privileged &&
            chown(mempath, qemu_driver->user, qemu_driver->group) < 0) {
            virReportSystemError(NULL, errno,
                                 _("unable to set ownership on %s to %d:%d"),
                                 mempath, qemu_driver->user, qemu_driver->group);
            VIR_FREE(mempath);
            goto error;
        }

        qemu_driver->hugepage_path = mempath;
    }

596 597 598 599 600 601 602 603 604 605 606 607
    /* Get all the running persistent or transient configs first */
    if (virDomainLoadAllConfigs(NULL,
                                qemu_driver->caps,
                                &qemu_driver->domains,
                                qemu_driver->stateDir,
                                NULL,
                                1, NULL, NULL) < 0)
        goto error;

    qemuReconnectDomains(qemu_driver);

    /* Then inactive persistent configs */
608 609 610 611
    if (virDomainLoadAllConfigs(NULL,
                                qemu_driver->caps,
                                &qemu_driver->domains,
                                qemu_driver->configDir,
612
                                qemu_driver->autostartDir,
613
                                0, NULL, NULL) < 0)
614
        goto error;
615 616
    qemuDriverUnlock(qemu_driver);

617 618
    qemudAutostartConfigs(qemu_driver);

619

620 621
    return 0;

622
out_of_memory:
623
    virReportOOMError(NULL);
624 625 626
error:
    if (qemu_driver)
        qemuDriverUnlock(qemu_driver);
627
    VIR_FREE(base);
628
    qemudShutdown();
629 630 631
    return -1;
}

632 633 634 635
static void qemudNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
{
    struct qemud_driver *driver = opaque;

636 637 638 639 640 641 642 643
    if (newVM) {
        virDomainEventPtr event =
            virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_DEFINED,
                                     VIR_DOMAIN_EVENT_DEFINED_ADDED);
        if (event)
            qemuDomainEventQueue(driver, event);
    }
644 645
}

646 647 648 649 650 651 652 653
/**
 * qemudReload:
 *
 * Function to restart the QEmu daemon, it will recheck the configuration
 * files and update its state and the networking
 */
static int
qemudReload(void) {
654 655 656
    if (!qemu_driver)
        return 0;

657
    qemuDriverLock(qemu_driver);
658 659 660 661
    virDomainLoadAllConfigs(NULL,
                            qemu_driver->caps,
                            &qemu_driver->domains,
                            qemu_driver->configDir,
662
                            qemu_driver->autostartDir,
663
                            0, qemudNotifyLoadDomain, qemu_driver);
664
    qemuDriverUnlock(qemu_driver);
665

666
    qemudAutostartConfigs(qemu_driver);
667 668

    return 0;
669 670
}

671 672 673 674 675 676 677 678 679 680
/**
 * qemudActive:
 *
 * Checks if the QEmu daemon is active, i.e. has an active domain or
 * an active network
 *
 * Returns 1 if active, 0 otherwise
 */
static int
qemudActive(void) {
681
    unsigned int i;
682
    int active = 0;
683

684 685 686
    if (!qemu_driver)
        return 0;

687 688 689 690 691 692 693 694
    qemuDriverLock(qemu_driver);
    for (i = 0 ; i < qemu_driver->domains.count ; i++) {
        virDomainObjPtr vm = qemu_driver->domains.objs[i];
        virDomainObjLock(vm);
        if (virDomainIsActive(vm))
            active = 1;
        virDomainObjUnlock(vm);
    }
695

696 697
    qemuDriverUnlock(qemu_driver);
    return active;
698 699
}

700 701 702 703 704 705 706
/**
 * qemudShutdown:
 *
 * Shutdown the QEmu daemon, it will stop all active domains and networks
 */
static int
qemudShutdown(void) {
707

708
    if (!qemu_driver)
709
        return -1;
710

711
    qemuDriverLock(qemu_driver);
712
    pciDeviceListFree(NULL, qemu_driver->activePciHostdevs);
713 714
    virCapabilitiesFree(qemu_driver->caps);

715
    virDomainObjListFree(&qemu_driver->domains);
716

717
    VIR_FREE(qemu_driver->securityDriverName);
718
    VIR_FREE(qemu_driver->logDir);
719 720
    VIR_FREE(qemu_driver->configDir);
    VIR_FREE(qemu_driver->autostartDir);
721
    VIR_FREE(qemu_driver->stateDir);
722 723
    VIR_FREE(qemu_driver->libDir);
    VIR_FREE(qemu_driver->cacheDir);
724
    VIR_FREE(qemu_driver->vncTLSx509certdir);
J
Jim Meyering 已提交
725
    VIR_FREE(qemu_driver->vncListen);
726
    VIR_FREE(qemu_driver->vncPassword);
727
    VIR_FREE(qemu_driver->vncSASLdir);
728
    VIR_FREE(qemu_driver->saveImageFormat);
729 730
    VIR_FREE(qemu_driver->hugetlbfs_mount);
    VIR_FREE(qemu_driver->hugepage_path);
D
Daniel P. Berrange 已提交
731

732 733
    /* Free domain callback list */
    virDomainEventCallbackListFree(qemu_driver->domainEventCallbacks);
734 735 736 737
    virDomainEventQueueFree(qemu_driver->domainEventQueue);

    if (qemu_driver->domainEventTimer != -1)
        virEventRemoveTimeout(qemu_driver->domainEventTimer);
738

739 740 741
    if (qemu_driver->brctl)
        brShutdown(qemu_driver->brctl);

742 743
    virCgroupFree(&qemu_driver->cgroup);

744
    qemuDriverUnlock(qemu_driver);
745
    virMutexDestroy(&qemu_driver->lock);
746
    VIR_FREE(qemu_driver);
747 748

    return 0;
749 750 751
}

/* Return -1 for error, 1 to continue reading and 0 for success */
752
typedef int qemudHandlerMonitorOutput(virConnectPtr conn,
753
                                      virDomainObjPtr vm,
754 755 756
                                      const char *output,
                                      int fd);

757 758 759
/*
 * Returns -1 for error, 0 on end-of-file, 1 for success
 */
760
static int
761
qemudReadMonitorOutput(virConnectPtr conn,
762
                       virDomainObjPtr vm,
763 764
                       int fd,
                       char *buf,
G
Guido Günther 已提交
765
                       size_t buflen,
766
                       qemudHandlerMonitorOutput func,
767 768
                       const char *what,
                       int timeout)
769
{
G
Guido Günther 已提交
770
    size_t got = 0;
771
    buf[0] = '\0';
772
    timeout *= 1000; /* poll wants milli seconds */
773

774
    /* Consume & discard the initial greeting */
775
    while (got < (buflen-1)) {
G
Guido Günther 已提交
776
        ssize_t ret;
777 778

        ret = read(fd, buf+got, buflen-got-1);
779

780 781 782 783 784 785
        if (ret < 0) {
            struct pollfd pfd = { .fd = fd, .events = POLLIN };
            if (errno == EINTR)
                continue;

            if (errno != EAGAIN) {
786 787 788
                virReportSystemError(conn, errno,
                                     _("Failure while reading %s startup output"),
                                     what);
789 790 791
                return -1;
            }

792
            ret = poll(&pfd, 1, timeout);
793
            if (ret == 0) {
794
                qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
795
                                 _("Timed out while reading %s startup output"), what);
796 797 798
                return -1;
            } else if (ret == -1) {
                if (errno != EINTR) {
799 800 801
                    virReportSystemError(conn, errno,
                                         _("Failure while reading %s startup output"),
                                         what);
802 803 804 805 806 807 808 809
                    return -1;
                }
            } else {
                /* Make sure we continue loop & read any further data
                   available before dealing with EOF */
                if (pfd.revents & (POLLIN | POLLHUP))
                    continue;

810
                qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
811
                                 _("Failure while reading %s startup output"), what);
812 813
                return -1;
            }
814 815
        } else if (ret == 0) {
            return 0;
816 817 818
        } else {
            got += ret;
            buf[got] = '\0';
819 820 821 822 823 824
            ret = func(conn, vm, buf, fd);
            if (ret == -1)
                return -1;
            if (ret == 1)
                continue;
            return 1;
825 826 827
        }
    }

828
    qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
829
                     _("Out of space while reading %s startup output"), what);
830 831 832 833
    return -1;

}

834 835 836 837 838 839 840 841 842

/*
 * Returns -1 for error, 0 on success
 */
static int
qemudReadLogOutput(virConnectPtr conn,
                   virDomainObjPtr vm,
                   int fd,
                   char *buf,
G
Guido Günther 已提交
843
                   size_t buflen,
844 845 846 847
                   qemudHandlerMonitorOutput func,
                   const char *what,
                   int timeout)
{
848
    int retries = (timeout*10);
849
    int got = 0;
850 851 852
    buf[0] = '\0';

    while (retries) {
853
        ssize_t func_ret, ret;
854
        int isdead = 0;
G
Guido Günther 已提交
855

856 857
        func_ret = func(conn, vm, buf, fd);

858 859
        if (kill(vm->pid, 0) == -1 && errno == ESRCH)
            isdead = 1;
860

861 862
        /* Any failures should be detected before we read the log, so we
         * always have something useful to report on failure. */
863 864
        ret = saferead(fd, buf+got, buflen-got-1);
        if (ret < 0) {
865 866 867 868 869 870
            virReportSystemError(conn, errno,
                                 _("Failure while reading %s log output"),
                                 what);
            return -1;
        }

871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
        got += ret;
        buf[got] = '\0';
        if (got == buflen-1) {
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("Out of space while reading %s log output"),
                             what);
            return -1;
        }

        if (isdead) {
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("Process exited while reading %s log output"),
                             what);
            return -1;
        }

887 888
        if (func_ret <= 0)
            return func_ret;
889 890 891 892 893 894 895 896 897 898

        usleep(100*1000);
        retries--;
    }
    if (retries == 0)
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Timed out while reading %s log output"), what);
    return -1;
}

899
static int
900
qemudCheckMonitorPrompt(virConnectPtr conn ATTRIBUTE_UNUSED,
901
                        virDomainObjPtr vm,
902 903 904 905 906 907 908 909 910 911 912
                        const char *output,
                        int fd)
{
    if (strstr(output, "(qemu) ") == NULL)
        return 1; /* keep reading */

    vm->monitor = fd;

    return 0;
}

913
static int
914 915 916 917 918
qemudOpenMonitorCommon(virConnectPtr conn,
                       struct qemud_driver* driver,
                       virDomainObjPtr vm,
                       int monfd,
                       int reconnect)
919
{
920
    char buf[1024];
921
    int ret;
922

923
    if (virSetCloseExec(monfd) < 0) {
924
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
925
                         "%s", _("Unable to set monitor close-on-exec flag"));
926
        return -1;
927
    }
928
    if (virSetNonBlock(monfd) < 0) {
929
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
930
                         "%s", _("Unable to put monitor into non-blocking mode"));
931
        return -1;
932 933
    }

934
    if (!reconnect) {
935 936 937 938
        if (qemudReadMonitorOutput(conn,
                                   vm, monfd,
                                   buf, sizeof(buf),
                                   qemudCheckMonitorPrompt,
939
                                   "monitor", 10) <= 0)
940 941 942
            ret = -1;
        else
            ret = 0;
943 944 945 946 947 948
    } else {
        vm->monitor = monfd;
        ret = 0;
    }

    if (ret != 0)
949
        return ret;
950

951 952
    if ((vm->monitorWatch = virEventAddHandle(vm->monitor,
                                              VIR_EVENT_HANDLE_HANGUP | VIR_EVENT_HANDLE_ERROR,
953 954
                                              qemudDispatchVMEvent,
                                              driver, NULL)) < 0)
955
        return -1;
956

957 958
    return 0;
}
959

960 961 962 963 964 965 966 967 968
static int
qemudOpenMonitorUnix(virConnectPtr conn,
                     struct qemud_driver* driver,
                     virDomainObjPtr vm,
                     const char *monitor,
                     int reconnect)
{
    struct sockaddr_un addr;
    int monfd;
969
    int timeout = 3; /* In seconds */
970
    int ret, i = 0;
971 972 973 974 975 976 977 978 979

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

    memset(&addr, 0, sizeof(addr));
    addr.sun_family = AF_UNIX;
C
Chris Lalancette 已提交
980 981 982 983 984
    if (virStrcpyStatic(addr.sun_path, monitor) == NULL) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Monitor path %s too big for destination"), monitor);
        goto error;
    }
985

986 987 988 989 990 991
    do {
        ret = connect(monfd, (struct sockaddr *) &addr, sizeof(addr));

        if (ret == 0)
            break;

992 993
        if (errno == ENOENT || errno == ECONNREFUSED) {
            /* ENOENT       : Socket may not have shown up yet
994 995 996 997
             * ECONNREFUSED : Leftover socket hasn't been removed yet */
            continue;
        }

998 999 1000
        virReportSystemError(conn, errno, "%s",
                             _("failed to connect to monitor socket"));
        goto error;
1001 1002 1003 1004 1005 1006 1007

    } while ((++i <= timeout*5) && (usleep(.2 * 1000000) <= 0));

    if (ret != 0) {
        virReportSystemError(conn, errno, "%s",
                             _("monitor socket did not show up."));
        goto error;
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
    }

    if (qemudOpenMonitorCommon(conn, driver, vm, monfd, reconnect) < 0)
        goto error;

    return 0;

error:
    close(monfd);
    return -1;
}

1020 1021 1022 1023 1024 1025 1026 1027
static int
qemudOpenMonitorPty(virConnectPtr conn,
                    struct qemud_driver* driver,
                    virDomainObjPtr vm,
                    const char *monitor,
                    int reconnect)
{
    int monfd;
1028

1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
    if ((monfd = open(monitor, O_RDWR)) < 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Unable to open monitor path %s"), monitor);
        return -1;
    }

    if (qemudOpenMonitorCommon(conn, driver, vm, monfd, reconnect) < 0)
        goto error;

    return 0;

error:
1041
    close(monfd);
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
    return -1;
}

static int
qemudOpenMonitor(virConnectPtr conn,
                 struct qemud_driver *driver,
                 virDomainObjPtr vm,
                 int reconnect)
{
    switch (vm->monitor_chr->type) {
1052 1053 1054 1055
    case VIR_DOMAIN_CHR_TYPE_UNIX:
        return qemudOpenMonitorUnix(conn, driver, vm,
                                    vm->monitor_chr->data.nix.path,
                                    reconnect);
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
    case VIR_DOMAIN_CHR_TYPE_PTY:
        return qemudOpenMonitorPty(conn, driver, vm,
                                   vm->monitor_chr->data.file.path,
                                   reconnect);
    default:
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("unable to handle monitor type: %s"),
                         virDomainChrTypeToString(vm->monitor_chr->type));
        return -1;
    }
1066 1067
}

1068
/* Returns -1 for error, 0 success, 1 continue reading */
1069 1070 1071 1072 1073 1074
static int
qemudExtractMonitorPath(virConnectPtr conn,
                        const char *haystack,
                        size_t *offset,
                        char **path)
{
1075
    static const char needle[] = "char device redirected to";
1076
    char *tmp, *dev;
1077

1078
    VIR_FREE(*path);
1079
    /* First look for our magic string */
1080 1081 1082 1083 1084
    if (!(tmp = strstr(haystack + *offset, needle))) {
        return 1;
    }
    tmp += sizeof(needle);
    dev = tmp;
1085

1086 1087 1088 1089 1090
    /*
     * And look for first whitespace character and nul terminate
     * to mark end of the pty path
     */
    while (*tmp) {
1091
        if (c_isspace(*tmp)) {
1092 1093
            *path = strndup(dev, tmp-dev);
            if (*path == NULL) {
1094
                virReportOOMError(conn);
1095 1096
                return -1;
            }
1097

1098
            /* ... now further update offset till we get EOL */
1099
            *offset = tmp - haystack;
1100 1101
            return 0;
        }
1102
        tmp++;
1103 1104 1105 1106 1107
    }

    /*
     * We found a path, but didn't find any whitespace,
     * so it must be still incomplete - we should at
1108 1109
     * least see a \n - indicate that we want to carry
     * on trying again
1110
     */
1111
    return 1;
1112 1113 1114
}

static int
1115
qemudFindCharDevicePTYs(virConnectPtr conn,
1116
                        virDomainObjPtr vm,
1117 1118
                        const char *output,
                        int fd ATTRIBUTE_UNUSED)
1119
{
1120
    size_t offset = 0;
1121
    int ret, i;
1122 1123

    /* The order in which QEMU prints out the PTY paths is
1124 1125
       the order in which it procsses its serial and parallel
       device args. This code must match that ordering.... */
1126

1127
    /* first comes the serial devices */
1128 1129
    for (i = 0 ; i < vm->def->nserials ; i++) {
        virDomainChrDefPtr chr = vm->def->serials[i];
1130 1131 1132
        if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
            if ((ret = qemudExtractMonitorPath(conn, output, &offset,
                                               &chr->data.file.path)) != 0)
1133
                return ret;
1134 1135 1136
        }
    }

1137
    /* then the parallel devices */
1138 1139
    for (i = 0 ; i < vm->def->nparallels ; i++) {
        virDomainChrDefPtr chr = vm->def->parallels[i];
1140 1141 1142
        if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
            if ((ret = qemudExtractMonitorPath(conn, output, &offset,
                                               &chr->data.file.path)) != 0)
1143
                return ret;
1144 1145 1146
        }
    }

1147
    return 0;
1148 1149
}

1150 1151 1152 1153
static int
qemudWaitForMonitor(virConnectPtr conn,
                    struct qemud_driver* driver,
                    virDomainObjPtr vm, off_t pos)
1154
{
1155
    char buf[4096]; /* Plenty of space to get startup greeting */
1156 1157 1158 1159 1160
    int logfd;
    int ret;

    if ((logfd = qemudLogReadFD(conn, driver->logDir, vm->def->name, pos))
        < 0)
1161
        return -1;
1162

1163 1164 1165
    ret = qemudReadLogOutput(conn, vm, logfd, buf, sizeof(buf),
                             qemudFindCharDevicePTYs,
                             "console", 3);
1166
    if (close(logfd) < 0) {
1167
        char ebuf[4096];
1168
        VIR_WARN(_("Unable to close logfile: %s\n"),
1169 1170
                 virStrerror(errno, ebuf, sizeof ebuf));
    }
1171

1172 1173 1174 1175 1176 1177
    if (ret < 0) {
        /* Unexpected end of file - inform user of QEMU log data */
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("unable to start guest: %s"), buf);
        return -1;
    }
1178

1179 1180 1181 1182
    if (qemudOpenMonitor(conn, driver, vm, 0) < 0)
        return -1;

    return 0;
1183 1184
}

1185
static int
1186 1187 1188 1189
qemuDetectVcpuPIDs(virConnectPtr conn,
                   virDomainObjPtr vm) {
    pid_t *cpupids = NULL;
    int ncpupids;
1190

1191
    if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM) {
1192 1193 1194 1195 1196
        vm->nvcpupids = 1;
        if (VIR_ALLOC_N(vm->vcpupids, vm->nvcpupids) < 0) {
            virReportOOMError(conn);
            return -1;
        }
1197 1198 1199 1200
        vm->vcpupids[0] = vm->pid;
        return 0;
    }

1201
    /* What follows is now all KVM specific */
1202

1203 1204
    if ((ncpupids = qemuMonitorGetCPUInfo(vm, &cpupids)) < 0)
        return -1;
1205

1206 1207 1208
    /* Treat failure to get VCPU<->PID mapping as non-fatal */
    if (ncpupids == 0)
        return 0;
1209

1210 1211 1212 1213 1214 1215 1216
    if (ncpupids != vm->def->vcpus) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("got wrong number of vCPU pids from QEMU monitor. got %d, wanted %d"),
                         ncpupids, (int)vm->def->vcpus);
        VIR_FREE(cpupids);
        return -1;
    }
1217

1218 1219
    vm->nvcpupids = ncpupids;
    vm->vcpupids = cpupids;
1220 1221 1222
    return 0;
}

1223 1224
static int
qemudInitCpus(virConnectPtr conn,
D
Daniel Veillard 已提交
1225 1226
              virDomainObjPtr vm,
              const char *migrateFrom) {
1227 1228 1229 1230 1231
#if HAVE_SCHED_GETAFFINITY
    cpu_set_t mask;
    int i, maxcpu = QEMUD_CPUMASK_LEN;
    virNodeInfo nodeinfo;

1232
    if (nodeGetInfo(conn, &nodeinfo) < 0)
1233 1234 1235 1236 1237 1238 1239 1240
        return -1;

    /* setaffinity fails if you set bits for CPUs which
     * aren't present, so we have to limit ourselves */
    if (maxcpu > nodeinfo.cpus)
        maxcpu = nodeinfo.cpus;

    CPU_ZERO(&mask);
D
Daniel P. Berrange 已提交
1241 1242 1243 1244 1245 1246
    if (vm->def->cpumask) {
        for (i = 0 ; i < maxcpu ; i++)
            if (vm->def->cpumask[i])
                CPU_SET(i, &mask);
    } else {
        for (i = 0 ; i < maxcpu ; i++)
1247
            CPU_SET(i, &mask);
D
Daniel P. Berrange 已提交
1248
    }
1249 1250 1251 1252

    for (i = 0 ; i < vm->nvcpupids ; i++) {
        if (sched_setaffinity(vm->vcpupids[i],
                              sizeof(mask), &mask) < 0) {
1253 1254
            virReportSystemError(conn, errno, "%s",
                                 _("failed to set CPU affinity"));
1255 1256 1257 1258 1259
            return -1;
        }
    }
#endif /* HAVE_SCHED_GETAFFINITY */

D
Daniel Veillard 已提交
1260 1261
    if (migrateFrom == NULL) {
        /* Allow the CPUS to start executing */
1262
        if (qemuMonitorStartCPUs(conn, vm) < 0) {
1263 1264 1265
            if (virGetLastError() == NULL)
                qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 "%s", _("resume operation failed"));
D
Daniel Veillard 已提交
1266 1267
            return -1;
        }
1268 1269 1270 1271 1272 1273
    }

    return 0;
}


1274
static int
1275 1276
qemuInitPasswords(struct qemud_driver *driver,
                  virDomainObjPtr vm) {
1277
    int ret = 0;
1278

1279 1280 1281
    if ((vm->def->ngraphics == 1) &&
        vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
        (vm->def->graphics[0]->data.vnc.passwd || driver->vncPassword)) {
1282

1283 1284 1285 1286
        ret = qemuMonitorSetVNCPassword(vm,
                                        vm->def->graphics[0]->data.vnc.passwd ?
                                        vm->def->graphics[0]->data.vnc.passwd :
                                        driver->vncPassword);
1287 1288
    }

1289
    return ret;
1290 1291 1292
}


1293
static int qemudNextFreeVNCPort(struct qemud_driver *driver ATTRIBUTE_UNUSED) {
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
    int i;

    for (i = 5900 ; i < 6000 ; i++) {
        int fd;
        int reuse = 1;
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(i);
        addr.sin_addr.s_addr = htonl(INADDR_ANY);
        fd = socket(PF_INET, SOCK_STREAM, 0);
        if (fd < 0)
            return -1;

        if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*)&reuse, sizeof(reuse)) < 0) {
            close(fd);
            break;
        }

        if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == 0) {
            /* Not in use, lets grab it */
            close(fd);
            return i;
        }
        close(fd);

        if (errno == EADDRINUSE) {
            /* In use, try next */
            continue;
        }
        /* Some other bad failure, get out.. */
        break;
    }
    return -1;
}

1329 1330 1331 1332 1333
static pciDeviceList *
qemuGetPciHostDeviceList(virConnectPtr conn,
                         virDomainDefPtr def)
{
    pciDeviceList *list;
1334 1335
    int i;

1336 1337
    if (!(list = pciDeviceListNew(conn)))
        return NULL;
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352

    for (i = 0 ; i < def->nhostdevs ; i++) {
        virDomainHostdevDefPtr hostdev = def->hostdevs[i];
        pciDevice *dev;

        if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
            continue;
        if (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
            continue;

        dev = pciGetDevice(conn,
                           hostdev->source.subsys.u.pci.domain,
                           hostdev->source.subsys.u.pci.bus,
                           hostdev->source.subsys.u.pci.slot,
                           hostdev->source.subsys.u.pci.function);
1353 1354 1355 1356
        if (!dev) {
            pciDeviceListFree(conn, list);
            return NULL;
        }
1357

1358
        if (pciDeviceListAdd(conn, list, dev) < 0) {
1359
            pciFreeDevice(conn, dev);
1360 1361
            pciDeviceListFree(conn, list);
            return NULL;
1362 1363
        }

1364
        pciDeviceSetManaged(dev, hostdev->managed);
1365 1366
    }

1367 1368 1369 1370
    return list;
}

static int
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
                            virDomainDefPtr def)
{
    pciDeviceList *pcidevs;
    int i, ret;

    if (!def->nhostdevs)
        return 0;

    if (!(pcidevs = qemuGetPciHostDeviceList(NULL, def)))
        return -1;

    ret = 0;

    for (i = 0; i < pcidevs->count; i++) {
        if (pciDeviceListAdd(NULL,
                             driver->activePciHostdevs,
                             pcidevs->devs[i]) < 0) {
            ret = -1;
            break;
        }
        pcidevs->devs[i] = NULL;
    }

    pciDeviceListFree(NULL, pcidevs);
    return ret;
}

static int
qemuPrepareHostDevices(virConnectPtr conn,
                       struct qemud_driver *driver,
                       virDomainDefPtr def)
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
{
    pciDeviceList *pcidevs;
    int i;

    if (!def->nhostdevs)
        return 0;

    if (!(pcidevs = qemuGetPciHostDeviceList(conn, def)))
        return -1;

1413
    /* We have to use 3 loops here. *All* devices must
1414 1415
     * be detached before we reset any of them, because
     * in some cases you have to reset the whole PCI,
1416 1417
     * which impacts all devices on it. Also, all devices
     * must be reset before being marked as active.
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
     */

    /* XXX validate that non-managed device isn't in use, eg
     * by checking that device is either un-bound, or bound
     * to pci-stub.ko
     */

    for (i = 0; i < pcidevs->count; i++)
        if (pciDeviceGetManaged(pcidevs->devs[i]) &&
            pciDettachDevice(conn, pcidevs->devs[i]) < 0)
            goto error;

    /* Now that all the PCI hostdevs have be dettached, we can safely
     * reset them */
    for (i = 0; i < pcidevs->count; i++)
1433 1434
        if (pciResetDevice(conn, pcidevs->devs[i],
                           driver->activePciHostdevs) < 0)
1435 1436
            goto error;

1437 1438 1439 1440 1441 1442 1443 1444 1445
    /* Now mark all the devices as active */
    for (i = 0; i < pcidevs->count; i++) {
        if (pciDeviceListAdd(conn,
                             driver->activePciHostdevs,
                             pcidevs->devs[i]) < 0)
            goto error;
        pcidevs->devs[i] = NULL;
    }

1446
    pciDeviceListFree(conn, pcidevs);
1447 1448 1449
    return 0;

error:
1450
    pciDeviceListFree(conn, pcidevs);
1451 1452 1453
    return -1;
}

1454
static void
1455 1456 1457
qemuDomainReAttachHostDevices(virConnectPtr conn,
                              struct qemud_driver *driver,
                              virDomainDefPtr def)
1458
{
1459
    pciDeviceList *pcidevs;
1460 1461
    int i;

1462 1463
    if (!def->nhostdevs)
        return;
1464

1465 1466 1467 1468 1469 1470
    if (!(pcidevs = qemuGetPciHostDeviceList(conn, def))) {
        virErrorPtr err = virGetLastError();
        VIR_ERROR(_("Failed to allocate pciDeviceList: %s\n"),
                  err ? err->message : "");
        virResetError(err);
        return;
1471 1472
    }

1473 1474
    /* Again 3 loops; mark all devices as inactive before reset
     * them and reset all the devices before re-attach */
1475

1476
    for (i = 0; i < pcidevs->count; i++)
1477 1478 1479 1480 1481
        pciDeviceListDel(conn, driver->activePciHostdevs, pcidevs->devs[i]);

    for (i = 0; i < pcidevs->count; i++)
        if (pciResetDevice(conn, pcidevs->devs[i],
                           driver->activePciHostdevs) < 0) {
1482
            virErrorPtr err = virGetLastError();
1483
            VIR_ERROR(_("Failed to reset PCI device: %s\n"),
1484 1485 1486 1487
                      err ? err->message : "");
            virResetError(err);
        }

1488 1489 1490
    for (i = 0; i < pcidevs->count; i++)
        if (pciDeviceGetManaged(pcidevs->devs[i]) &&
            pciReAttachDevice(conn, pcidevs->devs[i]) < 0) {
1491
            virErrorPtr err = virGetLastError();
1492
            VIR_ERROR(_("Failed to re-attach PCI device: %s\n"),
1493 1494 1495 1496
                      err ? err->message : "");
            virResetError(err);
        }

1497
    pciDeviceListFree(conn, pcidevs);
1498 1499
}

1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
static const char *const defaultDeviceACL[] = {
    "/dev/null", "/dev/full", "/dev/zero",
    "/dev/random", "/dev/urandom",
    "/dev/ptmx", "/dev/kvm", "/dev/kqemu",
    "/dev/rtc", "/dev/hpet", "/dev/net/tun",
    NULL,
};
#define DEVICE_PTY_MAJOR 136
#define DEVICE_SND_MAJOR 116

1510 1511 1512 1513 1514 1515
static int qemuSetupCgroup(virConnectPtr conn,
                           struct qemud_driver *driver,
                           virDomainObjPtr vm)
{
    virCgroupPtr cgroup = NULL;
    int rc;
1516
    unsigned int i;
1517 1518 1519 1520
    const char *const *deviceACL =
        driver->cgroupDeviceACL ?
        (const char *const *)driver->cgroupDeviceACL :
        defaultDeviceACL;
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532

    if (driver->cgroup == NULL)
        return 0; /* Not supported, so claim success */

    rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 1);
    if (rc != 0) {
        virReportSystemError(conn, -rc,
                             _("Unable to create cgroup for %s"),
                             vm->def->name);
        goto cleanup;
    }

1533 1534
    if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
        rc = virCgroupDenyAllDevices(cgroup);
1535
        if (rc != 0) {
1536 1537 1538 1539 1540
            if (rc == -EPERM) {
                VIR_WARN0("Group devices ACL is not accessible, disabling whitelisting");
                goto done;
            }

1541
            virReportSystemError(conn, -rc,
1542
                                 _("Unable to deny all devices for %s"), vm->def->name);
1543 1544 1545
            goto cleanup;
        }

1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559
        for (i = 0; i < vm->def->ndisks ; i++) {
            if (vm->def->disks[i]->type != VIR_DOMAIN_DISK_TYPE_BLOCK ||
                vm->def->disks[i]->src == NULL)
                continue;

            rc = virCgroupAllowDevicePath(cgroup,
                                          vm->def->disks[i]->src);
            if (rc != 0) {
                virReportSystemError(conn, -rc,
                                     _("Unable to allow device %s for %s"),
                                     vm->def->disks[i]->src, vm->def->name);
                goto cleanup;
            }
        }
1560

1561
        rc = virCgroupAllowDeviceMajor(cgroup, 'c', DEVICE_PTY_MAJOR);
1562 1563
        if (rc != 0) {
            virReportSystemError(conn, -rc, "%s",
1564
                                 _("unable to allow /dev/pts/ devices"));
1565 1566 1567
            goto cleanup;
        }

1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
        if (vm->def->nsounds) {
            rc = virCgroupAllowDeviceMajor(cgroup, 'c', DEVICE_SND_MAJOR);
            if (rc != 0) {
                virReportSystemError(conn, -rc, "%s",
                                     _("unable to allow /dev/snd/ devices"));
                goto cleanup;
            }
        }

        for (i = 0; deviceACL[i] != NULL ; i++) {
            rc = virCgroupAllowDevicePath(cgroup,
                                          deviceACL[i]);
            if (rc < 0 &&
                rc != -ENOENT) {
                virReportSystemError(conn, -rc,
                                     _("unable to allow device %s"),
                                     deviceACL[i]);
                goto cleanup;
            }
1587 1588 1589 1590
        }
    }

done:
1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659
    virCgroupFree(&cgroup);
    return 0;

cleanup:
    if (cgroup) {
        virCgroupRemove(cgroup);
        virCgroupFree(&cgroup);
    }
    return -1;
}


static int qemuRemoveCgroup(virConnectPtr conn,
                            struct qemud_driver *driver,
                            virDomainObjPtr vm)
{
    virCgroupPtr cgroup;
    int rc;

    if (driver->cgroup == NULL)
        return 0; /* Not supported, so claim success */

    rc = virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0);
    if (rc != 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Unable to find cgroup for %s\n"),
                         vm->def->name);
        return rc;
    }

    rc = virCgroupRemove(cgroup);
    virCgroupFree(&cgroup);
    return rc;
}

static int qemuAddToCgroup(struct qemud_driver *driver,
                           virDomainDefPtr def)
{
    virCgroupPtr cgroup = NULL;
    int ret = -1;
    int rc;

    if (driver->cgroup == NULL)
        return 0; /* Not supported, so claim success */

    rc = virCgroupForDomain(driver->cgroup, def->name, &cgroup, 0);
    if (rc != 0) {
        virReportSystemError(NULL, -rc,
                             _("unable to find cgroup for domain %s"),
                             def->name);
        goto cleanup;
    }

    rc = virCgroupAddTask(cgroup, getpid());
    if (rc != 0) {
        virReportSystemError(NULL, -rc,
                             _("unable to add domain %s task %d to cgroup"),
                             def->name, getpid());
        goto cleanup;
    }

    ret = 0;

cleanup:
    virCgroupFree(&cgroup);
    return ret;
}


1660 1661 1662 1663 1664 1665 1666 1667 1668
static int qemudDomainSetSecurityLabel(virConnectPtr conn, struct qemud_driver *driver, virDomainObjPtr vm)
{
    if (vm->def->seclabel.label != NULL)
        if (driver->securityDriver && driver->securityDriver->domainSetSecurityLabel)
            return driver->securityDriver->domainSetSecurityLabel(conn, driver->securityDriver,
                                                                 vm);
    return 0;
}

1669 1670

#ifdef __linux__
1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681
struct qemuFileOwner {
    uid_t uid;
    gid_t gid;
};

static int qemuDomainSetHostdevUSBOwnershipActor(virConnectPtr conn,
                                                 usbDevice *dev ATTRIBUTE_UNUSED,
                                                 const char *file, void *opaque)
{
    struct qemuFileOwner *owner = opaque;

1682 1683
    VIR_DEBUG("Setting ownership on %s to %d:%d", file, owner->uid, owner->gid);

1684 1685 1686 1687 1688 1689 1690 1691
    if (chown(file, owner->uid, owner->gid) < 0) {
        virReportSystemError(conn, errno, _("cannot set ownership on %s"), file);
        return -1;
    }

    return 0;
}

1692 1693 1694 1695
static int qemuDomainSetHostdevUSBOwnership(virConnectPtr conn,
                                            virDomainHostdevDefPtr def,
                                            uid_t uid, gid_t gid)
{
1696 1697
    struct qemuFileOwner owner = { uid, gid };
    int ret = -1;
1698 1699 1700 1701 1702 1703

    /* XXX what todo for USB devs assigned based on product/vendor ? Doom :-( */
    if (!def->source.subsys.u.usb.bus ||
        !def->source.subsys.u.usb.device)
        return 0;

1704 1705 1706 1707 1708 1709 1710 1711 1712
    usbDevice *dev = usbGetDevice(conn,
                                  def->source.subsys.u.usb.bus,
                                  def->source.subsys.u.usb.device);

    if (!dev)
        goto cleanup;

    ret = usbDeviceFileIterate(conn, dev,
                               qemuDomainSetHostdevUSBOwnershipActor, &owner);
1713

1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724
    usbFreeDevice(conn, dev);
cleanup:
    return ret;
}

static int qemuDomainSetHostdevPCIOwnershipActor(virConnectPtr conn,
                                                 pciDevice *dev ATTRIBUTE_UNUSED,
                                                 const char *file, void *opaque)
{
    struct qemuFileOwner *owner = opaque;

1725 1726
    VIR_DEBUG("Setting ownership on %s to %d:%d", file, owner->uid, owner->gid);

1727 1728
    if (chown(file, owner->uid, owner->gid) < 0) {
        virReportSystemError(conn, errno, _("cannot set ownership on %s"), file);
1729 1730 1731 1732 1733 1734 1735 1736 1737 1738
        return -1;
    }

    return 0;
}

static int qemuDomainSetHostdevPCIOwnership(virConnectPtr conn,
                                            virDomainHostdevDefPtr def,
                                            uid_t uid, gid_t gid)
{
1739
    struct qemuFileOwner owner = { uid, gid };
1740 1741
    int ret = -1;

1742 1743 1744 1745 1746
    pciDevice *dev = pciGetDevice(conn,
                                  def->source.subsys.u.pci.domain,
                                  def->source.subsys.u.pci.bus,
                                  def->source.subsys.u.pci.slot,
                                  def->source.subsys.u.pci.function);
1747

1748
    if (!dev)
1749 1750
        goto cleanup;

1751 1752
    ret = pciDeviceFileIterate(conn, dev,
                               qemuDomainSetHostdevPCIOwnershipActor, &owner);
1753

1754
    pciFreeDevice(conn, dev);
1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785
cleanup:
    return ret;
}
#endif


static int qemuDomainSetHostdevOwnership(virConnectPtr conn,
                                         virDomainHostdevDefPtr def,
                                         uid_t uid, gid_t gid)
{
    if (def->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
        return 0;

#ifdef __linux__
    switch (def->source.subsys.type) {
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
        return qemuDomainSetHostdevUSBOwnership(conn, def, uid, gid);

    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
        return qemuDomainSetHostdevPCIOwnership(conn, def, uid, gid);

    }
    return 0;
#else
    qemudReportError(conn, NULL, NULL, "%s",
                     _("unable to set host device ownership on this platform"));
    return -1;
#endif

}

1786 1787
static int qemuDomainSetFileOwnership(virConnectPtr conn,
                                      const char *path,
1788 1789 1790
                                      uid_t uid, gid_t gid)
{

1791
    if (!path)
1792 1793
        return 0;

1794 1795
    VIR_DEBUG("Setting ownership on %s to %d:%d", path, uid, gid);
    if (chown(path, uid, gid) < 0) {
1796
        virReportSystemError(conn, errno, _("cannot set ownership on %s"),
1797
                             path);
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
        return -1;
    }
    return 0;
}

static int qemuDomainSetDeviceOwnership(virConnectPtr conn,
                                        struct qemud_driver *driver,
                                        virDomainDeviceDefPtr def,
                                        int restore)
{
    uid_t uid;
    gid_t gid;

    if (!driver->privileged)
        return 0;

    /* short circuit case of root:root */
    if (!driver->user && !driver->group)
        return 0;

    uid = restore ? 0 : driver->user;
    gid = restore ? 0 : driver->group;

    switch (def->type) {
    case VIR_DOMAIN_DEVICE_DISK:
        if (restore &&
            (def->data.disk->readonly || def->data.disk->shared))
            return 0;

1827
        return qemuDomainSetFileOwnership(conn, def->data.disk->src, uid, gid);
1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854

    case VIR_DOMAIN_DEVICE_HOSTDEV:
        return qemuDomainSetHostdevOwnership(conn, def->data.hostdev, uid, gid);
    }

    return 0;
}

static int qemuDomainSetAllDeviceOwnership(virConnectPtr conn,
                                           struct qemud_driver *driver,
                                           virDomainDefPtr def,
                                           int restore)
{
    int i;
    uid_t uid;
    gid_t gid;

    if (!driver->privileged)
        return 0;

    /* short circuit case of root:root */
    if (!driver->user && !driver->group)
        return 0;

    uid = restore ? 0 : driver->user;
    gid = restore ? 0 : driver->group;

1855 1856 1857 1858
    if (qemuDomainSetFileOwnership(conn, def->os.kernel, uid, gid) < 0 ||
        qemuDomainSetFileOwnership(conn, def->os.initrd, uid, gid) < 0)
        return -1;

1859 1860 1861 1862 1863
    for (i = 0 ; i < def->ndisks ; i++) {
        if (restore &&
            (def->disks[i]->readonly || def->disks[i]->shared))
            continue;

1864
        if (qemuDomainSetFileOwnership(conn, def->disks[i]->src, uid, gid) < 0)
1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
            return -1;
    }

    for (i = 0 ; i < def->nhostdevs ; i++) {
        if (qemuDomainSetHostdevOwnership(conn, def->hostdevs[i], uid, gid) < 0)
            return -1;
    }

    return 0;
}

1876 1877 1878
static virDomainPtr qemudDomainLookupByName(virConnectPtr conn,
                                            const char *name);

1879 1880 1881 1882
struct qemudHookData {
    virConnectPtr conn;
    virDomainObjPtr vm;
    struct qemud_driver *driver;
1883 1884 1885
};

static int qemudSecurityHook(void *data) {
1886 1887 1888 1889
    struct qemudHookData *h = data;

    if (qemuAddToCgroup(h->driver, h->vm->def) < 0)
        return -1;
1890

1891
    if (qemudDomainSetSecurityLabel(h->conn, h->driver, h->vm) < 0)
1892 1893 1894 1895 1896
        return -1;

    if (h->driver->privileged) {
        if (qemuDomainSetAllDeviceOwnership(h->conn, h->driver, h->vm->def, 0) < 0)
            return -1;
1897

1898 1899
        DEBUG("Dropping privileges of VM to %d:%d", h->driver->user, h->driver->group);

1900 1901 1902 1903 1904
        if (h->driver->group) {
            if (setregid(h->driver->group, h->driver->group) < 0) {
                virReportSystemError(NULL, errno,
                                     _("cannot change to '%d' group"),
                                     h->driver->group);
1905
                return -1;
1906
            }
1907
        }
1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
        if (h->driver->user) {
            if (setreuid(h->driver->user, h->driver->user) < 0) {
                virReportSystemError(NULL, errno,
                                     _("cannot change to '%d' user"),
                                     h->driver->user);
                return -1;
            }
        }
    }

    return 0;
1919 1920
}

1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
static int
qemuPrepareMonitorChr(virConnectPtr conn,
                      struct qemud_driver *driver,
                      virDomainChrDefPtr monitor_chr,
                      const char *vm)
{
    monitor_chr->type = VIR_DOMAIN_CHR_TYPE_UNIX;
    monitor_chr->data.nix.listen = 1;

    if (virAsprintf(&monitor_chr->data.nix.path, "%s/%s.monitor",
1931
                    driver->libDir, vm) < 0) {
1932 1933 1934 1935 1936 1937 1938
        virReportOOMError(conn);
        return -1;
    }

    return 0;
}

1939 1940
static int qemudStartVMDaemon(virConnectPtr conn,
                              struct qemud_driver *driver,
1941
                              virDomainObjPtr vm,
1942 1943
                              const char *migrateFrom,
                              int stdin_fd) {
1944
    const char **argv = NULL, **tmp;
1945
    const char **progenv = NULL;
1946
    int i, ret;
1947
    struct stat sb;
1948 1949
    int *tapfds = NULL;
    int ntapfds = 0;
1950
    unsigned int qemuCmdFlags;
1951
    fd_set keepfd;
1952
    const char *emulator;
G
Guido Günther 已提交
1953
    pid_t child;
1954
    int pos = -1;
1955
    char ebuf[1024];
1956
    char *pidfile = NULL;
1957
    int logfile;
1958

1959
    struct qemudHookData hookData;
1960 1961 1962 1963
    hookData.conn = conn;
    hookData.vm = vm;
    hookData.driver = driver;

1964
    FD_ZERO(&keepfd);
1965

1966
    if (virDomainIsActive(vm)) {
1967
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_INVALID,
1968
                         "%s", _("VM is already active"));
1969 1970 1971
        return -1;
    }

1972 1973 1974 1975 1976 1977 1978 1979
    /* If you are using a SecurityDriver with dynamic labelling,
       then generate a security label for isolation */
    if (vm->def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC &&
        driver->securityDriver &&
        driver->securityDriver->domainGenSecurityLabel &&
        driver->securityDriver->domainGenSecurityLabel(conn, vm) < 0)
        return -1;

1980 1981 1982
    /* Ensure no historical cgroup for this VM is lieing around bogus settings */
    qemuRemoveCgroup(conn, driver, vm);

1983 1984 1985
    if ((vm->def->ngraphics == 1) &&
        vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
        vm->def->graphics[0]->data.vnc.autoport) {
1986
        int port = qemudNextFreeVNCPort(driver);
1987
        if (port < 0) {
1988
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
1989
                             "%s", _("Unable to find an unused VNC port"));
1990
            goto cleanup;
1991
        }
1992
        vm->def->graphics[0]->data.vnc.port = port;
1993
    }
1994

1995
    if (virFileMakePath(driver->logDir) < 0) {
1996 1997 1998
        virReportSystemError(conn, errno,
                             _("cannot create log directory %s"),
                             driver->logDir);
1999
        goto cleanup;
2000 2001
    }

2002
    if ((logfile = qemudLogFD(conn, driver, vm->def->name)) < 0)
2003
        goto cleanup;
2004

2005 2006
    emulator = vm->def->emulator;

2007 2008 2009 2010
    /* Make sure the binary we are about to try exec'ing exists.
     * Technically we could catch the exec() failure, but that's
     * in a sub-process so its hard to feed back a useful error
     */
2011
    if (stat(emulator, &sb) < 0) {
2012 2013 2014
        virReportSystemError(conn, errno,
                             _("Cannot find QEMU binary %s"),
                             emulator);
2015
        goto cleanup;
2016 2017
    }

2018
    if (qemudExtractVersionInfo(emulator,
2019
                                NULL,
2020
                                &qemuCmdFlags) < 0)
2021
        goto cleanup;
2022

2023 2024 2025
    if (qemuSetupCgroup(conn, driver, vm) < 0)
        goto cleanup;

2026
    if (qemuPrepareHostDevices(conn, driver, vm->def) < 0)
2027
        goto cleanup;
2028

2029 2030 2031 2032 2033
    if (VIR_ALLOC(vm->monitor_chr) < 0) {
        virReportOOMError(conn);
        goto cleanup;
    }

2034 2035
    if (qemuPrepareMonitorChr(conn, driver, vm->monitor_chr, vm->def->name) < 0)
        goto cleanup;
2036

D
Daniel P. Berrange 已提交
2037 2038 2039 2040 2041 2042 2043
    if ((ret = virFileDeletePid(driver->stateDir, vm->def->name)) != 0) {
        virReportSystemError(conn, ret,
                             _("Cannot remove stale PID file for %s"),
                             vm->def->name);
        goto cleanup;
    }

2044 2045 2046 2047 2048
    if (!(pidfile = virFilePid(driver->stateDir, vm->def->name))) {
        virReportSystemError(conn, errno,
                             "%s", _("Failed to build pidfile path."));
        goto cleanup;
    }
D
Daniel P. Berrange 已提交
2049

2050
    vm->def->id = driver->nextvmid++;
2051
    if (qemudBuildCommandLine(conn, driver, vm->def, vm->monitor_chr,
2052
                              qemuCmdFlags, &argv, &progenv,
2053 2054
                              &tapfds, &ntapfds, migrateFrom) < 0)
        goto cleanup;
2055

2056 2057
    tmp = progenv;
    while (*tmp) {
2058
        if (safewrite(logfile, *tmp, strlen(*tmp)) < 0)
2059
            VIR_WARN(_("Unable to write envv to logfile: %s\n"),
2060
                     virStrerror(errno, ebuf, sizeof ebuf));
2061
        if (safewrite(logfile, " ", 1) < 0)
2062
            VIR_WARN(_("Unable to write envv to logfile: %s\n"),
2063
                     virStrerror(errno, ebuf, sizeof ebuf));
2064 2065
        tmp++;
    }
2066 2067
    tmp = argv;
    while (*tmp) {
2068
        if (safewrite(logfile, *tmp, strlen(*tmp)) < 0)
2069
            VIR_WARN(_("Unable to write argv to logfile: %s\n"),
2070
                     virStrerror(errno, ebuf, sizeof ebuf));
2071
        if (safewrite(logfile, " ", 1) < 0)
2072
            VIR_WARN(_("Unable to write argv to logfile: %s\n"),
2073
                     virStrerror(errno, ebuf, sizeof ebuf));
2074 2075
        tmp++;
    }
2076
    if (safewrite(logfile, "\n", 1) < 0)
2077
        VIR_WARN(_("Unable to write argv to logfile: %s\n"),
2078
                 virStrerror(errno, ebuf, sizeof ebuf));
2079

2080
    if ((pos = lseek(logfile, 0, SEEK_END)) < 0)
2081
        VIR_WARN(_("Unable to seek to end of logfile: %s\n"),
2082
                 virStrerror(errno, ebuf, sizeof ebuf));
2083

2084 2085 2086
    for (i = 0 ; i < ntapfds ; i++)
        FD_SET(tapfds[i], &keepfd);

2087
    ret = virExecDaemonize(conn, argv, progenv, &keepfd, &child,
2088
                           stdin_fd, &logfile, &logfile,
2089
                           VIR_EXEC_NONBLOCK | VIR_EXEC_CLEAR_CAPS,
2090 2091 2092
                           qemudSecurityHook, &hookData,
                           pidfile);
    VIR_FREE(pidfile);
G
Guido Günther 已提交
2093 2094 2095

    /* wait for qemu process to to show up */
    if (ret == 0) {
2096
        if (virFileReadPid(driver->stateDir, vm->def->name, &vm->pid)) {
2097
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
2098
                             _("Domain %s didn't show up\n"), vm->def->name);
2099
            ret = -1;
G
Guido Günther 已提交
2100
        }
2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
    } else if (ret == -2) {
        /* The virExec process that launches the daemon failed. Pending on
         * when it failed (we can't determine for sure), there may be
         * extra info in the domain log (if the hook failed for example).
         *
         * Pretend like things succeeded, and let 'WaitForMonitor' report
         * the log contents for us.
         */
        vm->pid = child;
        ret = 0;
    }
2112 2113

    vm->state = migrateFrom ? VIR_DOMAIN_PAUSED : VIR_DOMAIN_RUNNING;
2114

2115
    for (i = 0 ; argv[i] ; i++)
2116 2117
        VIR_FREE(argv[i]);
    VIR_FREE(argv);
2118

2119 2120 2121 2122
    for (i = 0 ; progenv[i] ; i++)
        VIR_FREE(progenv[i]);
    VIR_FREE(progenv);

2123 2124 2125
    if (tapfds) {
        for (i = 0 ; i < ntapfds ; i++) {
            close(tapfds[i]);
2126
        }
2127
        VIR_FREE(tapfds);
2128 2129
    }

2130 2131 2132 2133
    if (ret == -1)
        goto cleanup;

    if ((qemudWaitForMonitor(conn, driver, vm, pos) < 0) ||
2134
        (qemuDetectVcpuPIDs(conn, vm) < 0) ||
2135
        (qemudInitCpus(conn, vm, migrateFrom) < 0) ||
2136
        (qemuInitPasswords(driver, vm) < 0) ||
2137
        (qemuMonitorSetBalloon(vm, vm->def->memory) < 0) ||
2138
        (virDomainSaveStatus(conn, driver->stateDir, vm) < 0)) {
2139 2140 2141
        qemudShutdownVMDaemon(conn, driver, vm);
        ret = -1;
        /* No need for 'goto cleanup' now since qemudShutdownVMDaemon does enough */
2142 2143
    }

2144 2145 2146
    if (logfile != -1)
        close(logfile);

2147
    return ret;
2148 2149 2150 2151 2152 2153 2154

cleanup:
    if (vm->def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC) {
        VIR_FREE(vm->def->seclabel.model);
        VIR_FREE(vm->def->seclabel.label);
        VIR_FREE(vm->def->seclabel.imagelabel);
    }
2155
    qemuRemoveCgroup(conn, driver, vm);
2156 2157 2158 2159
    if ((vm->def->ngraphics == 1) &&
        vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
        vm->def->graphics[0]->data.vnc.autoport)
        vm->def->graphics[0]->data.vnc.port = -1;
2160 2161
    if (logfile != -1)
        close(logfile);
2162 2163
    vm->def->id = -1;
    return -1;
2164 2165 2166
}


2167
static void qemudShutdownVMDaemon(virConnectPtr conn,
2168 2169
                                  struct qemud_driver *driver,
                                  virDomainObjPtr vm) {
D
Daniel P. Berrange 已提交
2170
    int ret;
2171
    int retries = 0;
D
Daniel P. Berrange 已提交
2172

2173
    if (!virDomainIsActive(vm))
2174
        return;
2175

2176
    VIR_DEBUG(_("Shutting down VM '%s'\n"), vm->def->name);
2177

G
Guido Günther 已提交
2178 2179
    if (virKillProcess(vm->pid, 0) == 0 &&
        virKillProcess(vm->pid, SIGTERM) < 0)
2180 2181 2182
        virReportSystemError(conn, errno,
                             _("Failed to send SIGTERM to %s (%d)"),
                             vm->def->name, vm->pid);
2183

2184 2185 2186
    if (vm->monitorWatch != -1) {
        virEventRemoveHandle(vm->monitorWatch);
        vm->monitorWatch = -1;
2187
    }
2188 2189 2190 2191 2192

    if (vm->monitor != -1)
        close(vm->monitor);
    vm->monitor = -1;

2193 2194 2195 2196 2197 2198 2199
    if (vm->monitor_chr) {
        if (vm->monitor_chr->type == VIR_DOMAIN_CHR_TYPE_UNIX)
            unlink(vm->monitor_chr->data.nix.path);
        virDomainChrDefFree(vm->monitor_chr);
        vm->monitor_chr = NULL;
    }

G
Guido Günther 已提交
2200 2201
    /* shut it off for sure */
    virKillProcess(vm->pid, SIGKILL);
2202

2203 2204 2205 2206
    /* Reset Security Labels */
    if (driver->securityDriver)
        driver->securityDriver->domainRestoreSecurityLabel(conn, vm);

2207 2208 2209 2210 2211 2212 2213
    /* Clear out dynamically assigned labels */
    if (vm->def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC) {
        VIR_FREE(vm->def->seclabel.model);
        VIR_FREE(vm->def->seclabel.label);
        VIR_FREE(vm->def->seclabel.imagelabel);
    }

2214 2215 2216 2217
    if (qemuDomainSetAllDeviceOwnership(conn, driver, vm->def, 1) < 0)
        VIR_WARN("Failed to restore all device ownership for %s",
                 vm->def->name);

2218
    qemuDomainReAttachHostDevices(conn, driver, vm->def);
2219

2220 2221 2222 2223 2224 2225 2226 2227 2228 2229
retry:
    if ((ret = qemuRemoveCgroup(conn, driver, vm)) < 0) {
        if (ret == -EBUSY && (retries++ < 5)) {
            usleep(200*1000);
            goto retry;
        }
        VIR_WARN("Failed to remove cgroup for %s",
                 vm->def->name);
    }

2230
    if (qemudRemoveDomainStatus(conn, driver, vm) < 0) {
2231
        VIR_WARN(_("Failed to remove domain status for %s"),
2232 2233
                 vm->def->name);
    }
D
Daniel P. Berrange 已提交
2234 2235 2236 2237 2238 2239
    if ((ret = virFileDeletePid(driver->stateDir, vm->def->name)) != 0) {
        char ebuf[1024];
        VIR_WARN(_("Failed to remove PID file for %s: %s"),
                 vm->def->name, virStrerror(errno, ebuf, sizeof ebuf));
    }

2240
    vm->pid = -1;
2241
    vm->def->id = -1;
2242
    vm->state = VIR_DOMAIN_SHUTOFF;
2243
    VIR_FREE(vm->vcpupids);
2244
    vm->nvcpupids = 0;
2245 2246

    if (vm->newDef) {
2247
        virDomainDefFree(vm->def);
2248
        vm->def = vm->newDef;
2249
        vm->def->id = -1;
2250 2251 2252 2253 2254
        vm->newDef = NULL;
    }
}


2255
static void
2256
qemudDispatchVMEvent(int watch, int fd, int events, void *opaque) {
2257
    struct qemud_driver *driver = opaque;
2258
    virDomainObjPtr vm = NULL;
2259
    virDomainEventPtr event = NULL;
2260
    unsigned int i;
2261
    int quit = 0, failed = 0;
2262

2263
    qemuDriverLock(driver);
2264
    for (i = 0 ; i < driver->domains.count ; i++) {
2265 2266 2267
        virDomainObjPtr tmpvm = driver->domains.objs[i];
        virDomainObjLock(tmpvm);
        if (virDomainIsActive(tmpvm) &&
2268
            tmpvm->monitorWatch == watch) {
2269
            vm = tmpvm;
2270
            break;
2271
        }
2272
        virDomainObjUnlock(tmpvm);
2273 2274 2275
    }

    if (!vm)
2276
        goto cleanup;
2277

2278
    if (vm->monitor != fd) {
2279 2280
        failed = 1;
    } else {
2281
        if (events & (VIR_EVENT_HANDLE_HANGUP | VIR_EVENT_HANDLE_ERROR))
2282
            quit = 1;
2283
        else {
2284 2285
            VIR_ERROR(_("unhandled fd event %d for %s"),
                      events, vm->def->name);
2286
            failed = 1;
2287
        }
2288 2289
    }

2290
    if (failed || quit) {
2291 2292 2293 2294 2295
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STOPPED,
                                         quit ?
                                         VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN :
                                         VIR_DOMAIN_EVENT_STOPPED_FAILED);
2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306
        qemudShutdownVMDaemon(NULL, driver, vm);
        if (!vm->persistent) {
            virDomainRemoveInactive(&driver->domains,
                                    vm);
            vm = NULL;
        }
    }

cleanup:
    if (vm)
        virDomainObjUnlock(vm);
2307 2308
    if (event)
        qemuDomainEventQueue(driver, event);
2309
    qemuDriverUnlock(driver);
2310 2311
}

2312

2313

2314
static virDrvOpenStatus qemudOpen(virConnectPtr conn,
2315
                                  virConnectAuthPtr auth ATTRIBUTE_UNUSED,
2316
                                  int flags ATTRIBUTE_UNUSED) {
2317
    if (conn->uri == NULL) {
2318 2319 2320
        if (qemu_driver == NULL)
            return VIR_DRV_OPEN_DECLINED;

2321
        conn->uri = xmlParseURI(qemu_driver->privileged ?
2322 2323
                                "qemu:///system" :
                                "qemu:///session");
2324
        if (!conn->uri) {
2325
            virReportOOMError(conn);
2326 2327
            return VIR_DRV_OPEN_ERROR;
        }
2328 2329 2330 2331 2332 2333 2334 2335 2336 2337
    } else {
        /* If URI isn't 'qemu' its definitely not for us */
        if (conn->uri->scheme == NULL ||
            STRNEQ(conn->uri->scheme, "qemu"))
            return VIR_DRV_OPEN_DECLINED;

        /* Allow remote driver to deal with URIs with hostname server */
        if (conn->uri->server != NULL)
            return VIR_DRV_OPEN_DECLINED;

2338 2339 2340 2341 2342 2343
        if (qemu_driver == NULL) {
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
                             _("qemu state driver is not active"));
            return VIR_DRV_OPEN_ERROR;
        }

2344
        if (qemu_driver->privileged) {
2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359
            if (STRNEQ (conn->uri->path, "/system") &&
                STRNEQ (conn->uri->path, "/session")) {
                qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 _("unexpected QEMU URI path '%s', try qemu:///system"),
                                 conn->uri->path);
                return VIR_DRV_OPEN_ERROR;
            }
        } else {
            if (STRNEQ (conn->uri->path, "/session")) {
                qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 _("unexpected QEMU URI path '%s', try qemu:///session"),
                                 conn->uri->path);
                return VIR_DRV_OPEN_ERROR;
            }
        }
2360 2361 2362 2363 2364 2365 2366
    }
    conn->privateData = qemu_driver;

    return VIR_DRV_OPEN_SUCCESS;
}

static int qemudClose(virConnectPtr conn) {
2367
    struct qemud_driver *driver = conn->privateData;
2368 2369

    /* Get rid of callbacks registered for this conn */
2370
    qemuDriverLock(driver);
2371
    virDomainEventCallbackListRemoveConn(conn, driver->domainEventCallbacks);
2372
    qemuDriverUnlock(driver);
2373 2374 2375 2376 2377 2378

    conn->privateData = NULL;

    return 0;
}

D
Daniel Veillard 已提交
2379 2380 2381 2382 2383 2384 2385 2386 2387 2388
/* Which features are supported by this driver? */
static int
qemudSupportsFeature (virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
{
    switch (feature) {
    case VIR_DRV_FEATURE_MIGRATION_V2: return 1;
    default: return 0;
    }
}

2389
static const char *qemudGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
2390
    return "QEMU";
2391 2392
}

2393 2394 2395 2396 2397

static int kvmGetMaxVCPUs(void) {
    int maxvcpus = 1;

    int r, fd;
2398

2399 2400
    fd = open(KVM_DEVICE, O_RDONLY);
    if (fd < 0) {
2401 2402
        virReportSystemError(NULL, errno, _("Unable to open %s"), KVM_DEVICE);
        return -1;
2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
    }

    r = ioctl(fd, KVM_CHECK_EXTENSION, KVM_CAP_NR_VCPUS);
    if (r > 0)
        maxvcpus = r;

    close(fd);
    return maxvcpus;
}


2414
static int qemudGetMaxVCPUs(virConnectPtr conn, const char *type) {
2415 2416 2417
    if (!type)
        return 16;

2418
    if (STRCASEEQ(type, "qemu"))
2419 2420
        return 16;

2421
    if (STRCASEEQ(type, "kvm"))
2422
        return kvmGetMaxVCPUs();
2423

2424
    if (STRCASEEQ(type, "kqemu"))
2425
        return 1;
2426 2427 2428

    qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_ARG,
                     _("unknown type '%s'"), type);
2429 2430 2431
    return -1;
}

2432

2433
static char *qemudGetCapabilities(virConnectPtr conn) {
2434
    struct qemud_driver *driver = conn->privateData;
2435
    virCapsPtr caps;
2436
    char *xml = NULL;
2437

2438
    qemuDriverLock(driver);
2439
    if ((caps = qemudCapsInit(qemu_driver->caps)) == NULL) {
2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450
        virReportOOMError(conn);
        goto cleanup;
    }

    if (qemu_driver->securityDriver &&
        qemudSecurityCapsInit(qemu_driver->securityDriver, caps) < 0) {
        virCapabilitiesFree(caps);
        virReportOOMError(conn);
        goto cleanup;
    }

2451
    virCapabilitiesFree(qemu_driver->caps);
2452 2453 2454
    qemu_driver->caps = caps;

    if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
2455
        virReportOOMError(conn);
2456 2457

cleanup:
2458
    qemuDriverUnlock(driver);
2459

2460
    return xml;
2461 2462 2463
}


2464
static int qemudGetProcessInfo(unsigned long long *cpuTime, int *lastCpu, int pid, int tid) {
D
Daniel P. Berrange 已提交
2465 2466
    char proc[PATH_MAX];
    FILE *pidinfo;
2467
    unsigned long long usertime, systime;
2468 2469
    int cpu;
    int ret;
D
Daniel P. Berrange 已提交
2470

2471 2472 2473 2474 2475 2476
    if (tid)
        ret = snprintf(proc, sizeof(proc), "/proc/%d/task/%d/stat", pid, tid);
    else
        ret = snprintf(proc, sizeof(proc), "/proc/%d/stat", pid);
    if (ret >= (int)sizeof(proc)) {
        errno = E2BIG;
D
Daniel P. Berrange 已提交
2477 2478 2479 2480
        return -1;
    }

    if (!(pidinfo = fopen(proc, "r"))) {
2481
        /*printf("cannot read pid info");*/
D
Daniel P. Berrange 已提交
2482
        /* VM probably shut down, so fake 0 */
2483 2484 2485 2486
        if (cpuTime)
            *cpuTime = 0;
        if (lastCpu)
            *lastCpu = 0;
D
Daniel P. Berrange 已提交
2487 2488 2489
        return 0;
    }

2490 2491 2492 2493 2494 2495 2496 2497 2498 2499
    /* See 'man proc' for information about what all these fields are. We're
     * only interested in a very few of them */
    if (fscanf(pidinfo,
               /* pid -> stime */
               "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %llu %llu"
               /* cutime -> endcode */
               "%*d %*d %*d %*d %*d %*u %*u %*d %*u %*u %*u %*u"
               /* startstack -> processor */
               "%*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*d %d",
               &usertime, &systime, &cpu) != 3) {
2500
        fclose(pidinfo);
2501 2502
        VIR_WARN0("cannot parse process status data");
        errno = -EINVAL;
D
Daniel P. Berrange 已提交
2503 2504 2505 2506 2507 2508 2509 2510
        return -1;
    }

    /* We got jiffies
     * We want nanoseconds
     * _SC_CLK_TCK is jiffies per second
     * So calulate thus....
     */
2511 2512 2513 2514 2515
    if (cpuTime)
        *cpuTime = 1000ull * 1000ull * 1000ull * (usertime + systime) / (unsigned long long)sysconf(_SC_CLK_TCK);
    if (lastCpu)
        *lastCpu = cpu;

D
Daniel P. Berrange 已提交
2516

2517 2518
    VIR_DEBUG("Got status for %d/%d user=%llu sys=%llu cpu=%d",
              pid, tid, usertime, systime, cpu);
D
Daniel P. Berrange 已提交
2519 2520 2521 2522 2523 2524 2525

    fclose(pidinfo);

    return 0;
}


2526
static virDomainPtr qemudDomainLookupByID(virConnectPtr conn,
2527
                                          int id) {
2528 2529 2530 2531
    struct qemud_driver *driver = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;

2532
    qemuDriverLock(driver);
2533
    vm  = virDomainFindByID(&driver->domains, id);
2534
    qemuDriverUnlock(driver);
2535 2536

    if (!vm) {
2537 2538
        qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching id %d"), id);
2539
        goto cleanup;
2540 2541
    }

2542
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
2543
    if (dom) dom->id = vm->def->id;
2544 2545

cleanup:
2546 2547
    if (vm)
        virDomainObjUnlock(vm);
2548 2549
    return dom;
}
2550

2551
static virDomainPtr qemudDomainLookupByUUID(virConnectPtr conn,
2552
                                            const unsigned char *uuid) {
2553 2554 2555
    struct qemud_driver *driver = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
2556

2557
    qemuDriverLock(driver);
2558
    vm = virDomainFindByUUID(&driver->domains, uuid);
2559 2560
    qemuDriverUnlock(driver);

2561
    if (!vm) {
2562 2563 2564
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(uuid, uuidstr);
        qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
2565
                         _("no domain with matching uuid '%s'"), uuidstr);
2566
        goto cleanup;
2567 2568
    }

2569
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
2570
    if (dom) dom->id = vm->def->id;
2571 2572

cleanup:
2573 2574
    if (vm)
        virDomainObjUnlock(vm);
2575 2576
    return dom;
}
2577

2578
static virDomainPtr qemudDomainLookupByName(virConnectPtr conn,
2579
                                            const char *name) {
2580 2581 2582
    struct qemud_driver *driver = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
2583

2584
    qemuDriverLock(driver);
2585
    vm = virDomainFindByName(&driver->domains, name);
2586 2587
    qemuDriverUnlock(driver);

2588
    if (!vm) {
2589 2590
        qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching name '%s'"), name);
2591
        goto cleanup;
2592 2593
    }

2594
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
2595
    if (dom) dom->id = vm->def->id;
2596 2597

cleanup:
2598 2599
    if (vm)
        virDomainObjUnlock(vm);
2600 2601 2602
    return dom;
}

2603
static int qemudGetVersion(virConnectPtr conn, unsigned long *version) {
2604 2605 2606
    struct qemud_driver *driver = conn->privateData;
    int ret = -1;

2607
    qemuDriverLock(driver);
2608
    if (qemudExtractVersion(conn, driver) < 0)
2609
        goto cleanup;
2610

2611
    *version = qemu_driver->qemuVersion;
2612 2613 2614
    ret = 0;

cleanup:
2615
    qemuDriverUnlock(driver);
2616
    return ret;
D
Daniel P. Berrange 已提交
2617 2618
}

2619 2620 2621
static char *
qemudGetHostname (virConnectPtr conn)
{
2622
    char *result;
2623

2624 2625
    result = virGetHostname();
    if (result == NULL) {
2626 2627
        virReportSystemError (conn, errno,
                              "%s", _("failed to determine host name"));
2628 2629 2630
        return NULL;
    }
    /* Caller frees this string. */
2631
    return result;
2632 2633
}

2634
static int qemudListDomains(virConnectPtr conn, int *ids, int nids) {
2635
    struct qemud_driver *driver = conn->privateData;
2636 2637
    int got = 0, i;

2638 2639 2640
    qemuDriverLock(driver);
    for (i = 0 ; i < driver->domains.count && got < nids ; i++) {
        virDomainObjLock(driver->domains.objs[i]);
2641 2642
        if (virDomainIsActive(driver->domains.objs[i]))
            ids[got++] = driver->domains.objs[i]->def->id;
2643 2644 2645
        virDomainObjUnlock(driver->domains.objs[i]);
    }
    qemuDriverUnlock(driver);
2646

D
Daniel P. Berrange 已提交
2647 2648
    return got;
}
2649

2650
static int qemudNumDomains(virConnectPtr conn) {
2651
    struct qemud_driver *driver = conn->privateData;
2652 2653
    int n = 0, i;

2654 2655 2656
    qemuDriverLock(driver);
    for (i = 0 ; i < driver->domains.count ; i++) {
        virDomainObjLock(driver->domains.objs[i]);
2657
        if (virDomainIsActive(driver->domains.objs[i]))
2658
            n++;
2659 2660 2661
        virDomainObjUnlock(driver->domains.objs[i]);
    }
    qemuDriverUnlock(driver);
2662

2663
    return n;
D
Daniel P. Berrange 已提交
2664
}
2665

2666
static virDomainPtr qemudDomainCreate(virConnectPtr conn, const char *xml,
2667
                                      unsigned int flags ATTRIBUTE_UNUSED) {
2668
    struct qemud_driver *driver = conn->privateData;
2669
    virDomainDefPtr def;
2670
    virDomainObjPtr vm = NULL;
2671
    virDomainPtr dom = NULL;
2672
    virDomainEventPtr event = NULL;
D
Daniel P. Berrange 已提交
2673

2674
    qemuDriverLock(driver);
2675 2676
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE)))
2677
        goto cleanup;
2678

2679 2680 2681
    if (virSecurityDriverVerify(conn, def) < 0)
        goto cleanup;

2682
    /* See if a VM with matching UUID already exists */
2683
    vm = virDomainFindByUUID(&driver->domains, def->uuid);
2684
    if (vm) {
2685 2686 2687 2688 2689 2690 2691 2692 2693
        /* UUID matches, but if names don't match, refuse it */
        if (STRNEQ(vm->def->name, def->name)) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(vm->def->uuid, uuidstr);
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                             _("domain '%s' is already defined with uuid %s"),
                             vm->def->name, uuidstr);
            goto cleanup;
        }
2694

2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712
        /* UUID & name match, but if VM is already active, refuse it */
        if (virDomainIsActive(vm)) {
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                             _("domain is already active as '%s'"), vm->def->name);
            goto cleanup;
        }
        virDomainObjUnlock(vm);
    } else {
        /* UUID does not match, but if a name matches, refuse it */
        vm = virDomainFindByName(&driver->domains, def->name);
        if (vm) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(vm->def->uuid, uuidstr);
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                             _("domain '%s' is already defined with uuid %s"),
                             def->name, uuidstr);
            goto cleanup;
        }
2713
    }
2714

2715 2716
    if (!(vm = virDomainAssignDef(conn,
                                  &driver->domains,
2717 2718 2719 2720
                                  def)))
        goto cleanup;

    def = NULL;
D
Daniel P. Berrange 已提交
2721

2722
    if (qemudStartVMDaemon(conn, driver, vm, NULL, -1) < 0) {
2723 2724
        virDomainRemoveInactive(&driver->domains,
                                vm);
2725
        vm = NULL;
2726
        goto cleanup;
D
Daniel P. Berrange 已提交
2727
    }
2728 2729 2730 2731

    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_BOOTED);
D
Daniel P. Berrange 已提交
2732

2733
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
2734
    if (dom) dom->id = vm->def->id;
2735 2736 2737

cleanup:
    virDomainDefFree(def);
2738 2739
    if (vm)
        virDomainObjUnlock(vm);
2740 2741
    if (event)
        qemuDomainEventQueue(driver, event);
2742
    qemuDriverUnlock(driver);
2743
    return dom;
D
Daniel P. Berrange 已提交
2744 2745 2746
}


2747
static int qemudDomainSuspend(virDomainPtr dom) {
2748 2749 2750
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2751
    virDomainEventPtr event = NULL;
2752

2753
    qemuDriverLock(driver);
2754
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2755

D
Daniel P. Berrange 已提交
2756
    if (!vm) {
2757 2758 2759 2760
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
2761
        goto cleanup;
D
Daniel P. Berrange 已提交
2762
    }
2763
    if (!virDomainIsActive(vm)) {
2764
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
2765
                         "%s", _("domain is not running"));
2766
        goto cleanup;
D
Daniel P. Berrange 已提交
2767
    }
2768
    if (vm->state != VIR_DOMAIN_PAUSED) {
2769
        if (qemuMonitorStopCPUs(vm) < 0)
2770 2771
            goto cleanup;
        vm->state = VIR_DOMAIN_PAUSED;
2772 2773 2774
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_SUSPENDED,
                                         VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
D
Daniel P. Berrange 已提交
2775
    }
2776
    if (virDomainSaveStatus(dom->conn, driver->stateDir, vm) < 0)
2777
        goto cleanup;
2778 2779 2780
    ret = 0;

cleanup:
2781 2782
    if (vm)
        virDomainObjUnlock(vm);
2783

2784
    if (event)
2785
        qemuDomainEventQueue(driver, event);
2786
    qemuDriverUnlock(driver);
2787
    return ret;
D
Daniel P. Berrange 已提交
2788 2789 2790
}


2791
static int qemudDomainResume(virDomainPtr dom) {
2792 2793 2794
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2795
    virDomainEventPtr event = NULL;
2796

2797
    qemuDriverLock(driver);
2798
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2799

D
Daniel P. Berrange 已提交
2800
    if (!vm) {
2801 2802 2803 2804
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
2805
        goto cleanup;
D
Daniel P. Berrange 已提交
2806
    }
2807
    if (!virDomainIsActive(vm)) {
2808
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
2809
                         "%s", _("domain is not running"));
2810
        goto cleanup;
D
Daniel P. Berrange 已提交
2811
    }
2812
    if (vm->state == VIR_DOMAIN_PAUSED) {
2813
        if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
2814 2815 2816
            if (virGetLastError() == NULL)
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("resume operation failed"));
2817 2818 2819
            goto cleanup;
        }
        vm->state = VIR_DOMAIN_RUNNING;
2820 2821 2822
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);
D
Daniel P. Berrange 已提交
2823
    }
2824
    if (virDomainSaveStatus(dom->conn, driver->stateDir, vm) < 0)
2825
        goto cleanup;
2826 2827 2828
    ret = 0;

cleanup:
2829 2830
    if (vm)
        virDomainObjUnlock(vm);
2831
    if (event)
2832
        qemuDomainEventQueue(driver, event);
2833
    qemuDriverUnlock(driver);
2834
    return ret;
D
Daniel P. Berrange 已提交
2835 2836 2837
}


2838
static int qemudDomainShutdown(virDomainPtr dom) {
2839 2840 2841
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2842

2843
    qemuDriverLock(driver);
2844
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2845 2846
    qemuDriverUnlock(driver);

2847
    if (!vm) {
2848 2849 2850 2851
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
2852
        goto cleanup;
2853 2854
    }

2855 2856 2857 2858 2859 2860
    if (!virDomainIsActive(vm)) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is not running"));
        goto cleanup;
    }

2861
    if (qemuMonitorSystemPowerdown(vm) < 0)
2862
        goto cleanup;
2863

2864 2865 2866
    ret = 0;

cleanup:
2867 2868
    if (vm)
        virDomainObjUnlock(vm);
2869
    return ret;
2870 2871 2872
}


2873
static int qemudDomainDestroy(virDomainPtr dom) {
2874 2875 2876
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2877
    virDomainEventPtr event = NULL;
2878

2879
    qemuDriverLock(driver);
2880
    vm  = virDomainFindByUUID(&driver->domains, dom->uuid);
D
Daniel P. Berrange 已提交
2881
    if (!vm) {
2882 2883 2884 2885
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
2886
        goto cleanup;
D
Daniel P. Berrange 已提交
2887
    }
2888
    if (!virDomainIsActive(vm)) {
2889
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
2890 2891 2892
                         "%s", _("domain is not running"));
        goto cleanup;
    }
2893

2894
    qemudShutdownVMDaemon(dom->conn, driver, vm);
2895 2896 2897
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
2898
    if (!vm->persistent) {
2899 2900
        virDomainRemoveInactive(&driver->domains,
                                vm);
2901 2902
        vm = NULL;
    }
2903 2904 2905
    ret = 0;

cleanup:
2906 2907
    if (vm)
        virDomainObjUnlock(vm);
2908 2909
    if (event)
        qemuDomainEventQueue(driver, event);
2910
    qemuDriverUnlock(driver);
2911
    return ret;
D
Daniel P. Berrange 已提交
2912 2913 2914
}


2915
static char *qemudDomainGetOSType(virDomainPtr dom) {
2916 2917 2918
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *type = NULL;
2919

2920
    qemuDriverLock(driver);
2921
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2922
    qemuDriverUnlock(driver);
2923
    if (!vm) {
2924 2925 2926 2927
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
2928
        goto cleanup;
2929 2930
    }

2931
    if (!(type = strdup(vm->def->os.type)))
2932
        virReportOOMError(dom->conn);
2933 2934

cleanup:
2935 2936
    if (vm)
        virDomainObjUnlock(vm);
2937 2938 2939
    return type;
}

2940 2941
/* Returns max memory in kb, 0 if error */
static unsigned long qemudDomainGetMaxMemory(virDomainPtr dom) {
2942 2943 2944
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    unsigned long ret = 0;
2945

2946
    qemuDriverLock(driver);
2947
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2948 2949
    qemuDriverUnlock(driver);

2950
    if (!vm) {
2951 2952
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
2953
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
2954
                         _("no domain with matching uuid '%s'"), uuidstr);
2955
        goto cleanup;
2956 2957
    }

2958 2959 2960
    ret = vm->def->maxmem;

cleanup:
2961 2962
    if (vm)
        virDomainObjUnlock(vm);
2963
    return ret;
2964 2965 2966
}

static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long newmax) {
2967 2968 2969
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2970

2971
    qemuDriverLock(driver);
2972
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2973 2974
    qemuDriverUnlock(driver);

2975
    if (!vm) {
2976 2977
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
2978
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
2979
                         _("no domain with matching uuid '%s'"), uuidstr);
2980
        goto cleanup;
2981 2982 2983 2984
    }

    if (newmax < vm->def->memory) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
2985
                         "%s", _("cannot set max memory lower than current memory"));
2986
        goto cleanup;;
2987 2988 2989
    }

    vm->def->maxmem = newmax;
2990 2991 2992
    ret = 0;

cleanup:
2993 2994
    if (vm)
        virDomainObjUnlock(vm);
2995
    return ret;
2996 2997
}

2998

2999
static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem) {
3000 3001 3002
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3003

3004
    qemuDriverLock(driver);
3005
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3006
    qemuDriverUnlock(driver);
3007
    if (!vm) {
3008 3009
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
3010
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
3011
                         _("no domain with matching uuid '%s'"), uuidstr);
3012
        goto cleanup;
3013 3014 3015 3016
    }

    if (newmem > vm->def->maxmem) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
3017
                         "%s", _("cannot set memory higher than max memory"));
3018
        goto cleanup;
3019 3020
    }

3021
    if (virDomainIsActive(vm)) {
3022 3023 3024
        ret = qemuMonitorSetBalloon(vm, newmem);
        /* Turn lack of balloon support into a fatal error */
        if (ret == 0) {
3025 3026
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                             "%s", _("cannot set memory of an active domain"));
3027 3028
            ret = -1;
        }
3029 3030 3031 3032
    } else {
        vm->def->memory = newmem;
        ret = 0;
    }
3033 3034

cleanup:
3035 3036
    if (vm)
        virDomainObjUnlock(vm);
3037
    return ret;
3038 3039
}

3040
static int qemudDomainGetInfo(virDomainPtr dom,
3041
                              virDomainInfoPtr info) {
3042 3043 3044
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3045 3046
    int err;
    unsigned long balloon;
3047

3048
    qemuDriverLock(driver);
3049
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3050
    qemuDriverUnlock(driver);
D
Daniel P. Berrange 已提交
3051
    if (!vm) {
3052 3053 3054 3055
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
3056
        goto cleanup;
D
Daniel P. Berrange 已提交
3057 3058
    }

3059
    info->state = vm->state;
D
Daniel P. Berrange 已提交
3060

3061
    if (!virDomainIsActive(vm)) {
3062
        info->cpuTime = 0;
D
Daniel P. Berrange 已提交
3063
    } else {
3064
        if (qemudGetProcessInfo(&(info->cpuTime), NULL, vm->pid, 0) < 0) {
3065
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, ("cannot read cputime for domain"));
3066
            goto cleanup;
D
Daniel P. Berrange 已提交
3067 3068 3069
        }
    }

3070
    info->maxMem = vm->def->maxmem;
3071 3072

    if (virDomainIsActive(vm)) {
3073
        err = qemuMonitorGetBalloonInfo(vm, &balloon);
3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085
        if (err < 0)
            goto cleanup;

        if (err == 0)
            /* Balloon not supported, so maxmem is always the allocation */
            info->memory = vm->def->maxmem;
        else
            info->memory = balloon;
    } else {
        info->memory = vm->def->memory;
    }

3086
    info->nrVirtCpu = vm->def->vcpus;
3087 3088 3089
    ret = 0;

cleanup:
3090 3091
    if (vm)
        virDomainObjUnlock(vm);
3092
    return ret;
D
Daniel P. Berrange 已提交
3093 3094 3095
}


D
Daniel P. Berrange 已提交
3096
static char *qemudEscape(const char *in, int shell)
3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117
{
    int len = 0;
    int i, j;
    char *out;

    /* To pass through the QEMU monitor, we need to use escape
       sequences: \r, \n, \", \\

       To pass through both QEMU + the shell, we need to escape
       the single character ' as the five characters '\\''
    */

    for (i = 0; in[i] != '\0'; i++) {
        switch(in[i]) {
        case '\r':
        case '\n':
        case '"':
        case '\\':
            len += 2;
            break;
        case '\'':
D
Daniel P. Berrange 已提交
3118 3119 3120 3121
            if (shell)
                len += 5;
            else
                len += 1;
3122 3123 3124 3125 3126 3127 3128
            break;
        default:
            len += 1;
            break;
        }
    }

3129
    if (VIR_ALLOC_N(out, len + 1) < 0)
3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147
        return NULL;

    for (i = j = 0; in[i] != '\0'; i++) {
        switch(in[i]) {
        case '\r':
            out[j++] = '\\';
            out[j++] = 'r';
            break;
        case '\n':
            out[j++] = '\\';
            out[j++] = 'n';
            break;
        case '"':
        case '\\':
            out[j++] = '\\';
            out[j++] = in[i];
            break;
        case '\'':
D
Daniel P. Berrange 已提交
3148 3149 3150 3151 3152 3153 3154 3155 3156
            if (shell) {
                out[j++] = '\'';
                out[j++] = '\\';
                out[j++] = '\\';
                out[j++] = '\'';
                out[j++] = '\'';
            } else {
                out[j++] = in[i];
            }
3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167
            break;
        default:
            out[j++] = in[i];
            break;
        }
    }
    out[j] = '\0';

    return out;
}

3168 3169 3170 3171 3172
static char *qemudEscapeMonitorArg(const char *in)
{
    return qemudEscape(in, 0);
}

3173
#define QEMUD_SAVE_MAGIC "LibvirtQemudSave"
3174 3175 3176
#define QEMUD_SAVE_VERSION 2

enum qemud_save_formats {
3177 3178 3179
    QEMUD_SAVE_FORMAT_RAW = 0,
    QEMUD_SAVE_FORMAT_GZIP = 1,
    QEMUD_SAVE_FORMAT_BZIP2 = 2,
3180 3181
    /*
     * Deprecated by xz and never used as part of a release
3182
     * QEMUD_SAVE_FORMAT_LZMA
3183 3184
     */
    QEMUD_SAVE_FORMAT_XZ = 3,
3185
    QEMUD_SAVE_FORMAT_LZOP = 4,
3186 3187 3188
    /* Note: add new members only at the end.
       These values are used in the on-disk format.
       Do not change or re-use numbers. */
3189 3190

    QEMUD_SAVE_FORMAT_LAST
3191
};
3192

3193 3194 3195 3196 3197
VIR_ENUM_DECL(qemudSaveCompression)
VIR_ENUM_IMPL(qemudSaveCompression, QEMUD_SAVE_FORMAT_LAST,
              "raw",
              "gzip",
              "bzip2",
3198 3199
              "xz",
              "lzop")
3200

3201 3202 3203 3204 3205
struct qemud_save_header {
    char magic[sizeof(QEMUD_SAVE_MAGIC)-1];
    int version;
    int xml_len;
    int was_running;
3206 3207
    int compressed;
    int unused[15];
3208 3209
};

3210
static int qemudDomainSave(virDomainPtr dom,
3211 3212
                           const char *path)
{
3213
    struct qemud_driver *driver = dom->conn->privateData;
3214
    virDomainObjPtr vm = NULL;
3215 3216
    int fd = -1;
    char *xml = NULL;
3217
    struct qemud_save_header header;
3218
    int ret = -1;
3219
    virDomainEventPtr event = NULL;
3220 3221 3222 3223 3224

    memset(&header, 0, sizeof(header));
    memcpy(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic));
    header.version = QEMUD_SAVE_VERSION;

3225
    qemuDriverLock(driver);
3226 3227 3228
    if (driver->saveImageFormat == NULL)
        header.compressed = QEMUD_SAVE_FORMAT_RAW;
    else {
3229 3230 3231 3232 3233 3234
        header.compressed =
            qemudSaveCompressionTypeFromString(driver->saveImageFormat);
        if (header.compressed < 0) {
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                             "%s", _("Invalid save image format specified "
                                     "in configuration file"));
3235
            goto cleanup;
3236
        }
3237 3238
    }

3239
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3240

D
Daniel P. Berrange 已提交
3241
    if (!vm) {
3242 3243 3244 3245
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
3246
        goto cleanup;
D
Daniel P. Berrange 已提交
3247
    }
3248

3249
    if (!virDomainIsActive(vm)) {
3250
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3251
                         "%s", _("domain is not running"));
3252
        goto cleanup;
D
Daniel P. Berrange 已提交
3253
    }
3254 3255 3256 3257

    /* Pause */
    if (vm->state == VIR_DOMAIN_RUNNING) {
        header.was_running = 1;
3258
        if (qemuMonitorStopCPUs(vm) < 0)
3259
            goto cleanup;
3260
        vm->state = VIR_DOMAIN_PAUSED;
3261 3262 3263
    }

    /* Get XML for the domain */
3264
    xml = virDomainDefFormat(dom->conn, vm->def, VIR_DOMAIN_XML_SECURE);
3265 3266
    if (!xml) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3267
                         "%s", _("failed to get domain xml"));
3268
        goto cleanup;
3269 3270 3271 3272 3273 3274
    }
    header.xml_len = strlen(xml) + 1;

    /* Write header to file, followed by XML */
    if ((fd = open(path, O_CREAT|O_TRUNC|O_WRONLY, S_IRUSR|S_IWUSR)) < 0) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3275
                         _("failed to create '%s'"), path);
3276
        goto cleanup;
3277 3278 3279 3280
    }

    if (safewrite(fd, &header, sizeof(header)) != sizeof(header)) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3281
                         "%s", _("failed to write save header"));
3282
        goto cleanup;
3283 3284 3285 3286
    }

    if (safewrite(fd, xml, header.xml_len) != header.xml_len) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3287
                         "%s", _("failed to write xml"));
3288
        goto cleanup;
3289 3290
    }

3291
    if (close(fd) < 0) {
3292 3293 3294
        virReportSystemError(dom->conn, errno,
                             _("unable to save file %s"),
                             path);
3295 3296 3297
        goto cleanup;
    }
    fd = -1;
3298

3299 3300 3301 3302
    if (header.compressed == QEMUD_SAVE_FORMAT_RAW) {
        const char *args[] = { "cat", NULL };
        ret = qemuMonitorMigrateToCommand(vm, args, path);
    } else {
3303
        const char *prog = qemudSaveCompressionTypeToString(header.compressed);
3304 3305 3306 3307 3308 3309
        const char *args[] = {
            prog,
            "-c",
            NULL
        };
        ret = qemuMonitorMigrateToCommand(vm, args, path);
3310 3311
    }

3312
    if (ret < 0)
3313
        goto cleanup;
3314

3315 3316
    /* Shut it down */
    qemudShutdownVMDaemon(dom->conn, driver, vm);
3317 3318 3319
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_SAVED);
3320
    if (!vm->persistent) {
3321 3322
        virDomainRemoveInactive(&driver->domains,
                                vm);
3323 3324
        vm = NULL;
    }
3325 3326 3327 3328 3329 3330 3331

cleanup:
    if (fd != -1)
        close(fd);
    VIR_FREE(xml);
    if (ret != 0)
        unlink(path);
3332 3333
    if (vm)
        virDomainObjUnlock(vm);
3334 3335
    if (event)
        qemuDomainEventQueue(driver, event);
3336
    qemuDriverUnlock(driver);
3337
    return ret;
D
Daniel P. Berrange 已提交
3338 3339 3340
}


P
Paolo Bonzini 已提交
3341 3342 3343 3344 3345 3346 3347
static int qemudDomainCoreDump(virDomainPtr dom,
                               const char *path,
                               int flags ATTRIBUTE_UNUSED) {
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int resume = 0, paused = 0;
    int ret = -1;
3348 3349 3350 3351
    const char *args[] = {
        "cat",
        NULL,
    };
P
Paolo Bonzini 已提交
3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377

    qemuDriverLock(driver);
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
    qemuDriverUnlock(driver);

    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
    }

    if (!virDomainIsActive(vm)) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is not running"));
        goto cleanup;
    }

    /* Migrate will always stop the VM, so once we support live dumping
       the resume condition will stay the same, independent of whether
       the stop command is issued.  */
    resume = (vm->state == VIR_DOMAIN_RUNNING);

    /* Pause domain for non-live dump */
    if (vm->state == VIR_DOMAIN_RUNNING) {
3378
        if (qemuMonitorStopCPUs(vm) < 0)
P
Paolo Bonzini 已提交
3379 3380 3381 3382
            goto cleanup;
        paused = 1;
    }

3383
    ret = qemuMonitorMigrateToCommand(vm, args, path);
P
Paolo Bonzini 已提交
3384 3385 3386 3387 3388 3389 3390
    paused = 1;
cleanup:

    /* Since the monitor is always attached to a pty for libvirt, it
       will support synchronous operations so we always get here after
       the migration is complete.  */
    if (resume && paused) {
3391
        if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
3392 3393 3394
            if (virGetLastError() == NULL)
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("resuming after dump failed"));
P
Paolo Bonzini 已提交
3395 3396 3397 3398 3399 3400 3401 3402
        }
    }
    if (vm)
        virDomainObjUnlock(vm);
    return ret;
}


3403
static int qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) {
3404 3405
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
3406
    int max;
3407
    int ret = -1;
3408
    const char *type;
3409

3410
    qemuDriverLock(driver);
3411
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3412 3413
    qemuDriverUnlock(driver);

3414
    if (!vm) {
3415 3416
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
3417
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
3418
                         _("no domain with matching uuid '%s'"), uuidstr);
3419
        goto cleanup;
3420 3421
    }

3422
    if (virDomainIsActive(vm)) {
3423
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID, "%s",
3424
                         _("cannot change vcpu count of an active domain"));
3425
        goto cleanup;
3426 3427
    }

3428 3429 3430 3431 3432 3433 3434 3435
    if (!(type = virDomainVirtTypeToString(vm->def->virtType))) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("unknown virt type in domain definition '%d'"),
                         vm->def->virtType);
        goto cleanup;
    }

    if ((max = qemudGetMaxVCPUs(dom->conn, type)) < 0) {
3436 3437
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
                         _("could not determine max vcpus for the domain"));
3438
        goto cleanup;
3439 3440 3441 3442 3443 3444
    }

    if (nvcpus > max) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                         _("requested vcpus is greater than max allowable"
                           " vcpus for the domain: %d > %d"), nvcpus, max);
3445
        goto cleanup;
3446 3447 3448
    }

    vm->def->vcpus = nvcpus;
3449 3450 3451
    ret = 0;

cleanup:
3452 3453
    if (vm)
        virDomainObjUnlock(vm);
3454
    return ret;
3455 3456
}

3457 3458 3459 3460 3461 3462 3463

#if HAVE_SCHED_GETAFFINITY
static int
qemudDomainPinVcpu(virDomainPtr dom,
                   unsigned int vcpu,
                   unsigned char *cpumap,
                   int maplen) {
3464 3465
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
3466 3467 3468
    cpu_set_t mask;
    int i, maxcpu;
    virNodeInfo nodeinfo;
3469
    int ret = -1;
3470

3471
    qemuDriverLock(driver);
3472
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3473 3474
    qemuDriverUnlock(driver);

3475 3476 3477 3478 3479 3480 3481 3482
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
    }

3483
    if (!virDomainIsActive(vm)) {
3484
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3485
                         "%s",_("cannot pin vcpus on an inactive domain"));
3486
        goto cleanup;
3487 3488 3489 3490 3491 3492
    }

    if (vcpu > (vm->nvcpupids-1)) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                         _("vcpu number out of range %d > %d"),
                         vcpu, vm->nvcpupids);
3493
        goto cleanup;
3494 3495
    }

3496
    if (nodeGetInfo(dom->conn, &nodeinfo) < 0)
3497
        goto cleanup;
3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510

    maxcpu = maplen * 8;
    if (maxcpu > nodeinfo.cpus)
        maxcpu = nodeinfo.cpus;

    CPU_ZERO(&mask);
    for (i = 0 ; i < maxcpu ; i++) {
        if ((cpumap[i/8] >> (i % 8)) & 1)
            CPU_SET(i, &mask);
    }

    if (vm->vcpupids != NULL) {
        if (sched_setaffinity(vm->vcpupids[vcpu], sizeof(mask), &mask) < 0) {
3511 3512
            virReportSystemError(dom->conn, errno, "%s",
                                 _("cannot set affinity"));
3513
            goto cleanup;
3514 3515 3516 3517
        }
    } else {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         "%s", _("cpu affinity is not supported"));
3518
        goto cleanup;
3519
    }
3520
    ret = 0;
3521

3522
cleanup:
3523 3524
    if (vm)
        virDomainObjUnlock(vm);
3525
    return ret;
3526 3527 3528 3529 3530 3531 3532 3533
}

static int
qemudDomainGetVcpus(virDomainPtr dom,
                    virVcpuInfoPtr info,
                    int maxinfo,
                    unsigned char *cpumaps,
                    int maplen) {
3534 3535
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
3536 3537
    virNodeInfo nodeinfo;
    int i, v, maxcpu;
3538
    int ret = -1;
3539

3540
    qemuDriverLock(driver);
3541
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3542 3543
    qemuDriverUnlock(driver);

3544 3545 3546 3547 3548 3549 3550 3551
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
    }

3552
    if (!virDomainIsActive(vm)) {
3553
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3554
                         "%s",_("cannot pin vcpus on an inactive domain"));
3555
        goto cleanup;
3556 3557
    }

3558
    if (nodeGetInfo(dom->conn, &nodeinfo) < 0)
3559
        goto cleanup;
3560 3561 3562 3563 3564 3565 3566 3567 3568

    maxcpu = maplen * 8;
    if (maxcpu > nodeinfo.cpus)
        maxcpu = nodeinfo.cpus;

    /* Clamp to actual number of vcpus */
    if (maxinfo > vm->nvcpupids)
        maxinfo = vm->nvcpupids;

3569 3570 3571 3572 3573 3574
    if (maxinfo >= 1) {
        if (info != NULL) {
            memset(info, 0, sizeof(*info) * maxinfo);
            for (i = 0 ; i < maxinfo ; i++) {
                info[i].number = i;
                info[i].state = VIR_VCPU_RUNNING;
3575 3576 3577 3578 3579 3580 3581 3582 3583 3584

                if (vm->vcpupids != NULL &&
                    qemudGetProcessInfo(&(info[i].cpuTime),
                                        &(info[i].cpu),
                                        vm->pid,
                                        vm->vcpupids[i]) < 0) {
                    virReportSystemError(dom->conn, errno, "%s",
                                         _("cannot get vCPU placement & pCPU time"));
                    goto cleanup;
                }
3585
            }
3586 3587
        }

3588 3589 3590 3591 3592 3593 3594 3595 3596
        if (cpumaps != NULL) {
            memset(cpumaps, 0, maplen * maxinfo);
            if (vm->vcpupids != NULL) {
                for (v = 0 ; v < maxinfo ; v++) {
                    cpu_set_t mask;
                    unsigned char *cpumap = VIR_GET_CPUMAP(cpumaps, maplen, v);
                    CPU_ZERO(&mask);

                    if (sched_getaffinity(vm->vcpupids[v], sizeof(mask), &mask) < 0) {
3597 3598
                        virReportSystemError(dom->conn, errno, "%s",
                                             _("cannot get affinity"));
3599 3600 3601 3602 3603 3604
                        goto cleanup;
                    }

                    for (i = 0 ; i < maxcpu ; i++)
                        if (CPU_ISSET(i, &mask))
                            VIR_USE_CPU(cpumap, i);
3605
                }
3606 3607 3608 3609
            } else {
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                                 "%s", _("cpu affinity is not available"));
                goto cleanup;
3610 3611 3612
            }
        }
    }
3613
    ret = maxinfo;
3614

3615
cleanup:
3616 3617
    if (vm)
        virDomainObjUnlock(vm);
3618
    return ret;
3619 3620 3621 3622
}
#endif /* HAVE_SCHED_GETAFFINITY */


3623
static int qemudDomainGetMaxVcpus(virDomainPtr dom) {
3624 3625
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
3626
    const char *type;
3627
    int ret = -1;
3628

3629
    qemuDriverLock(driver);
3630
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3631 3632
    qemuDriverUnlock(driver);

3633
    if (!vm) {
3634 3635
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
3636
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
3637
                         _("no domain with matching uuid '%s'"), uuidstr);
3638
        goto cleanup;
3639 3640
    }

3641
    if (!(type = virDomainVirtTypeToString(vm->def->virtType))) {
3642 3643 3644
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("unknown virt type in domain definition '%d'"),
                         vm->def->virtType);
3645
        goto cleanup;
3646 3647
    }

3648
    ret = qemudGetMaxVCPUs(dom->conn, type);
3649

3650
cleanup:
3651 3652
    if (vm)
        virDomainObjUnlock(vm);
3653 3654 3655
    return ret;
}

3656 3657 3658 3659 3660 3661 3662 3663 3664 3665
static int qemudDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel)
{
    struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
    virDomainObjPtr vm;
    const char *type;
    int ret = -1;

    qemuDriverLock(driver);
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);

3666 3667
    memset(seclabel, 0, sizeof(*seclabel));

3668 3669 3670
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
3671
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700
                         _("no domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
    }

    if (!(type = virDomainVirtTypeToString(vm->def->virtType))) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("unknown virt type in domain definition '%d'"),
                         vm->def->virtType);
        goto cleanup;
    }

    /*
     * Theoretically, the pid can be replaced during this operation and
     * return the label of a different process.  If atomicity is needed,
     * further validation will be required.
     *
     * Comment from Dan Berrange:
     *
     *   Well the PID as stored in the virDomainObjPtr can't be changed
     *   because you've got a locked object.  The OS level PID could have
     *   exited, though and in extreme circumstances have cycled through all
     *   PIDs back to ours. We could sanity check that our PID still exists
     *   after reading the label, by checking that our FD connecting to the
     *   QEMU monitor hasn't seen SIGHUP/ERR on poll().
     */
    if (virDomainIsActive(vm)) {
        if (driver->securityDriver && driver->securityDriver->domainGetSecurityLabel) {
            if (driver->securityDriver->domainGetSecurityLabel(dom->conn, vm, seclabel) == -1) {
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
3701
                                 "%s", _("Failed to get security label"));
3702 3703 3704 3705 3706 3707 3708 3709 3710 3711
                goto cleanup;
            }
        }
    }

    ret = 0;

cleanup:
    if (vm)
        virDomainObjUnlock(vm);
3712
    qemuDriverUnlock(driver);
3713 3714 3715
    return ret;
}

3716 3717
static int qemudNodeGetSecurityModel(virConnectPtr conn,
                                     virSecurityModelPtr secmodel)
3718 3719 3720
{
    struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
    char *p;
3721
    int ret = 0;
3722

3723 3724
    qemuDriverLock(driver);
    if (!driver->securityDriver) {
3725
        memset(secmodel, 0, sizeof (*secmodel));
3726 3727
        goto cleanup;
    }
3728

3729 3730 3731 3732 3733
    p = driver->caps->host.secModel.model;
    if (strlen(p) >= VIR_SECURITY_MODEL_BUFLEN-1) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("security model string exceeds max %d bytes"),
                         VIR_SECURITY_MODEL_BUFLEN-1);
3734 3735
        ret = -1;
        goto cleanup;
3736 3737 3738 3739 3740 3741 3742 3743
    }
    strcpy(secmodel->model, p);

    p = driver->caps->host.secModel.doi;
    if (strlen(p) >= VIR_SECURITY_DOI_BUFLEN-1) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("security DOI string exceeds max %d bytes"),
                         VIR_SECURITY_DOI_BUFLEN-1);
3744 3745
        ret = -1;
        goto cleanup;
3746 3747
    }
    strcpy(secmodel->doi, p);
3748 3749 3750 3751

cleanup:
    qemuDriverUnlock(driver);
    return ret;
3752 3753 3754
}

/* TODO: check seclabel restore */
3755
static int qemudDomainRestore(virConnectPtr conn,
3756 3757 3758
                              const char *path) {
    struct qemud_driver *driver = conn->privateData;
    virDomainDefPtr def = NULL;
3759
    virDomainObjPtr vm = NULL;
3760 3761 3762
    int fd = -1;
    int ret = -1;
    char *xml = NULL;
3763
    struct qemud_save_header header;
3764
    virDomainEventPtr event = NULL;
3765 3766 3767
    int intermediatefd = -1;
    pid_t intermediate_pid = -1;
    int childstat;
3768

3769
    qemuDriverLock(driver);
3770 3771 3772
    /* Verify the header and read the XML */
    if ((fd = open(path, O_RDONLY)) < 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3773
                         "%s", _("cannot read domain image"));
3774
        goto cleanup;
3775 3776 3777 3778
    }

    if (saferead(fd, &header, sizeof(header)) != sizeof(header)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3779
                         "%s", _("failed to read qemu header"));
3780
        goto cleanup;
3781 3782 3783 3784
    }

    if (memcmp(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic)) != 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3785
                         "%s", _("image magic is incorrect"));
3786
        goto cleanup;
3787 3788 3789 3790
    }

    if (header.version > QEMUD_SAVE_VERSION) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3791
                         _("image version is not supported (%d > %d)"),
3792
                         header.version, QEMUD_SAVE_VERSION);
3793
        goto cleanup;
3794 3795
    }

3796
    if (VIR_ALLOC_N(xml, header.xml_len) < 0) {
3797
        virReportOOMError(conn);
3798
        goto cleanup;
3799 3800 3801 3802
    }

    if (saferead(fd, xml, header.xml_len) != header.xml_len) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3803
                         "%s", _("failed to read XML"));
3804
        goto cleanup;
3805 3806 3807
    }

    /* Create a domain from this XML */
3808 3809
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE))) {
3810
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3811
                         "%s", _("failed to parse XML"));
3812
        goto cleanup;
3813 3814
    }

3815
    /* See if a VM with matching UUID already exists */
3816
    vm = virDomainFindByUUID(&driver->domains, def->uuid);
3817
    if (vm) {
3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828
        /* UUID matches, but if names don't match, refuse it */
        if (STRNEQ(vm->def->name, def->name)) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(vm->def->uuid, uuidstr);
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                             _("domain '%s' is already defined with uuid %s"),
                             vm->def->name, uuidstr);
            goto cleanup;
        }

        /* UUID & name match, but if VM is already active, refuse it */
3829
        if (virDomainIsActive(vm)) {
3830
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_INVALID,
3831 3832
                             _("domain is already active as '%s'"), vm->def->name);
            goto cleanup;
3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844
        }
        virDomainObjUnlock(vm);
    } else {
        /* UUID does not match, but if a name matches, refuse it */
        vm = virDomainFindByName(&driver->domains, def->name);
        if (vm) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(vm->def->uuid, uuidstr);
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                             _("domain '%s' is already defined with uuid %s"),
                             def->name, uuidstr);
            goto cleanup;
3845
        }
3846 3847
    }

3848 3849 3850
    if (!(vm = virDomainAssignDef(conn,
                                  &driver->domains,
                                  def))) {
3851
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3852
                         "%s", _("failed to assign new VM"));
3853
        goto cleanup;
3854
    }
3855
    def = NULL;
3856

3857 3858
    if (header.version == 2) {
        const char *intermediate_argv[3] = { NULL, "-dc", NULL };
3859 3860
        const char *prog = qemudSaveCompressionTypeToString(header.compressed);
        if (prog == NULL) {
3861
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3862
                             _("Invalid compressed save format %d"),
3863 3864 3865
                             header.compressed);
            goto cleanup;
        }
3866 3867 3868 3869

        if (header.compressed != QEMUD_SAVE_FORMAT_RAW)
            intermediate_argv[0] = prog;
        else {
3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880
            intermediatefd = fd;
            fd = -1;
            if (virExec(conn, intermediate_argv, NULL, NULL,
                        &intermediate_pid, intermediatefd, &fd, NULL, 0) < 0) {
                qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 _("Failed to start decompression binary %s"),
                                 intermediate_argv[0]);
                goto cleanup;
            }
        }
    }
3881
    /* Set the migration source and start it up. */
3882
    ret = qemudStartVMDaemon(conn, driver, vm, "stdio", fd);
3883 3884 3885 3886 3887 3888 3889
    if (intermediate_pid != -1) {
        /* Wait for intermediate process to exit */
        while (waitpid(intermediate_pid, &childstat, 0) == -1 &&
               errno == EINTR);
    }
    if (intermediatefd != -1)
        close(intermediatefd);
3890
    close(fd);
3891
    fd = -1;
3892
    if (ret < 0) {
3893
        if (!vm->persistent) {
3894 3895
            virDomainRemoveInactive(&driver->domains,
                                    vm);
3896 3897
            vm = NULL;
        }
3898
        goto cleanup;
3899 3900
    }

3901 3902 3903
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_RESTORED);
3904

3905 3906
    /* If it was running before, resume it now. */
    if (header.was_running) {
3907
        if (qemuMonitorStartCPUs(conn, vm) < 0) {
3908 3909 3910
            if (virGetLastError() == NULL)
                qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("failed to resume domain"));
3911
            goto cleanup;
3912 3913
        }
        vm->state = VIR_DOMAIN_RUNNING;
3914
        virDomainSaveStatus(conn, driver->stateDir, vm);
3915
    }
3916
    ret = 0;
3917

3918 3919 3920 3921 3922
cleanup:
    virDomainDefFree(def);
    VIR_FREE(xml);
    if (fd != -1)
        close(fd);
3923 3924
    if (vm)
        virDomainObjUnlock(vm);
3925 3926
    if (event)
        qemuDomainEventQueue(driver, event);
3927
    qemuDriverUnlock(driver);
3928
    return ret;
D
Daniel P. Berrange 已提交
3929 3930 3931
}


3932
static char *qemudDomainDumpXML(virDomainPtr dom,
3933
                                int flags) {
3934 3935 3936
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *ret = NULL;
3937 3938
    unsigned long balloon;
    int err;
3939

3940
    qemuDriverLock(driver);
3941
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3942 3943
    qemuDriverUnlock(driver);

D
Daniel P. Berrange 已提交
3944
    if (!vm) {
3945 3946 3947 3948
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
3949
        goto cleanup;
D
Daniel P. Berrange 已提交
3950 3951
    }

3952
    /* Refresh current memory based on balloon info */
3953 3954 3955 3956 3957 3958 3959 3960
    if (virDomainIsActive(vm)) {
        err = qemuMonitorGetBalloonInfo(vm, &balloon);
        if (err < 0)
            goto cleanup;
        if (err > 0)
            vm->def->memory = balloon;
        /* err == 0 indicates no balloon support, so ignore it */
    }
3961

3962 3963 3964 3965 3966 3967
    ret = virDomainDefFormat(dom->conn,
                             (flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ?
                             vm->newDef : vm->def,
                             flags);

cleanup:
3968 3969
    if (vm)
        virDomainObjUnlock(vm);
3970
    return ret;
D
Daniel P. Berrange 已提交
3971 3972 3973
}


3974 3975 3976 3977
static char *qemuDomainXMLFromNative(virConnectPtr conn,
                                     const char *format,
                                     const char *config,
                                     unsigned int flags ATTRIBUTE_UNUSED) {
3978
    struct qemud_driver *driver = conn->privateData;
3979 3980 3981 3982 3983 3984 3985 3986 3987
    virDomainDefPtr def = NULL;
    char *xml = NULL;

    if (STRNEQ(format, QEMU_CONFIG_FORMAT_ARGV)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_ARG,
                         _("unsupported config type %s"), format);
        goto cleanup;
    }

3988
    qemuDriverLock(driver);
3989
    def = qemuParseCommandLineString(conn, driver->caps, config);
3990
    qemuDriverUnlock(driver);
3991 3992 3993 3994 3995 3996 3997 3998 3999 4000
    if (!def)
        goto cleanup;

    xml = virDomainDefFormat(conn, def, VIR_DOMAIN_XML_INACTIVE);

cleanup:
    virDomainDefFree(def);
    return xml;
}

4001 4002 4003 4004 4005 4006
static char *qemuDomainXMLToNative(virConnectPtr conn,
                                   const char *format,
                                   const char *xmlData,
                                   unsigned int flags ATTRIBUTE_UNUSED) {
    struct qemud_driver *driver = conn->privateData;
    virDomainDefPtr def = NULL;
4007
    virDomainChrDef monitor_chr;
4008 4009 4010 4011 4012 4013 4014 4015 4016 4017
    const char *emulator;
    unsigned int qemuCmdFlags;
    struct stat sb;
    const char **retargv = NULL;
    const char **retenv = NULL;
    const char **tmp;
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    char *ret = NULL;
    int i;

4018 4019
    qemuDriverLock(driver);

4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085
    if (STRNEQ(format, QEMU_CONFIG_FORMAT_ARGV)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_ARG,
                         _("unsupported config type %s"), format);
        goto cleanup;
    }

    def = virDomainDefParseString(conn, driver->caps, xmlData, 0);
    if (!def)
        goto cleanup;

    /* Since we're just exporting args, we can't do bridge/network
     * setups, since libvirt will normally create TAP devices
     * directly. We convert those configs into generic 'ethernet'
     * config and assume the user has suitable 'ifup-qemu' scripts
     */
    for (i = 0 ; i < def->nnets ; i++) {
        virDomainNetDefPtr net = def->nets[i];
        if (net->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
            VIR_FREE(net->data.network.name);

            memset(net, 0, sizeof *net);

            net->type = VIR_DOMAIN_NET_TYPE_ETHERNET;
            net->data.ethernet.dev = NULL;
            net->data.ethernet.script = NULL;
            net->data.ethernet.ipaddr = NULL;
        } else if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE) {
            char *brname = net->data.bridge.brname;
            char *script = net->data.bridge.script;
            char *ipaddr = net->data.bridge.ipaddr;

            memset(net, 0, sizeof *net);

            net->type = VIR_DOMAIN_NET_TYPE_ETHERNET;
            net->data.ethernet.dev = brname;
            net->data.ethernet.script = script;
            net->data.ethernet.ipaddr = ipaddr;
        }
    }
    for (i = 0 ; i < def->ngraphics ; i++) {
        if (def->graphics[i]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
            def->graphics[i]->data.vnc.autoport)
            def->graphics[i]->data.vnc.port = 5900;
    }
    emulator = def->emulator;

    /* Make sure the binary we are about to try exec'ing exists.
     * Technically we could catch the exec() failure, but that's
     * in a sub-process so its hard to feed back a useful error
     */
    if (stat(emulator, &sb) < 0) {
        virReportSystemError(conn, errno,
                             _("Cannot find QEMU binary %s"),
                             emulator);
        goto cleanup;
    }

    if (qemudExtractVersionInfo(emulator,
                                NULL,
                                &qemuCmdFlags) < 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Cannot determine QEMU argv syntax %s"),
                         emulator);
        goto cleanup;
    }

4086 4087
    if (qemuPrepareMonitorChr(conn, driver, &monitor_chr, def->name) < 0)
        goto cleanup;
4088 4089

    if (qemudBuildCommandLine(conn, driver, def,
4090
                              &monitor_chr, qemuCmdFlags,
4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115
                              &retargv, &retenv,
                              NULL, NULL, /* Don't want it to create TAP devices */
                              NULL) < 0) {
        goto cleanup;
    }

    tmp = retenv;
    while (*tmp) {
        virBufferAdd(&buf, *tmp, strlen(*tmp));
        virBufferAddLit(&buf, " ");
        tmp++;
    }
    tmp = retargv;
    while (*tmp) {
        virBufferAdd(&buf, *tmp, strlen(*tmp));
        virBufferAddLit(&buf, " ");
        tmp++;
    }

    if (virBufferError(&buf))
        goto cleanup;

    ret = virBufferContentAndReset(&buf);

cleanup:
4116
    qemuDriverUnlock(driver);
4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129
    for (tmp = retargv ; tmp && *tmp ; tmp++)
        VIR_FREE(*tmp);
    VIR_FREE(retargv);

    for (tmp = retenv ; tmp && *tmp ; tmp++)
        VIR_FREE(*tmp);
    VIR_FREE(retenv);

    virDomainDefFree(def);
    return ret;
}


4130
static int qemudListDefinedDomains(virConnectPtr conn,
4131
                            char **const names, int nnames) {
4132
    struct qemud_driver *driver = conn->privateData;
4133
    int got = 0, i;
4134

4135
    qemuDriverLock(driver);
4136
    for (i = 0 ; i < driver->domains.count && got < nnames ; i++) {
4137
        virDomainObjLock(driver->domains.objs[i]);
4138 4139
        if (!virDomainIsActive(driver->domains.objs[i])) {
            if (!(names[got++] = strdup(driver->domains.objs[i]->def->name))) {
4140
                virReportOOMError(conn);
4141
                virDomainObjUnlock(driver->domains.objs[i]);
4142 4143
                goto cleanup;
            }
4144
        }
4145
        virDomainObjUnlock(driver->domains.objs[i]);
D
Daniel P. Berrange 已提交
4146
    }
4147

4148
    qemuDriverUnlock(driver);
D
Daniel P. Berrange 已提交
4149
    return got;
4150 4151 4152

 cleanup:
    for (i = 0 ; i < got ; i++)
4153
        VIR_FREE(names[i]);
4154
    qemuDriverUnlock(driver);
4155
    return -1;
D
Daniel P. Berrange 已提交
4156 4157
}

4158
static int qemudNumDefinedDomains(virConnectPtr conn) {
4159
    struct qemud_driver *driver = conn->privateData;
4160 4161
    int n = 0, i;

4162
    qemuDriverLock(driver);
4163 4164
    for (i = 0 ; i < driver->domains.count ; i++)
        if (!virDomainIsActive(driver->domains.objs[i]))
4165
            n++;
4166
    qemuDriverUnlock(driver);
4167

4168
    return n;
D
Daniel P. Berrange 已提交
4169 4170 4171
}


4172
static int qemudDomainStart(virDomainPtr dom) {
4173 4174 4175
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
4176
    virDomainEventPtr event = NULL;
4177

4178
    qemuDriverLock(driver);
4179
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
4180

4181
    if (!vm) {
4182 4183 4184 4185
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
4186
        goto cleanup;
4187 4188
    }

4189
    ret = qemudStartVMDaemon(dom->conn, driver, vm, NULL, -1);
4190
    if (ret != -1)
4191 4192 4193
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STARTED,
                                         VIR_DOMAIN_EVENT_STARTED_BOOTED);
4194 4195

cleanup:
4196 4197
    if (vm)
        virDomainObjUnlock(vm);
4198
    if (event)
4199
        qemuDomainEventQueue(driver, event);
4200
    qemuDriverUnlock(driver);
4201
    return ret;
D
Daniel P. Berrange 已提交
4202 4203
}

4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232
static int
qemudCanonicalizeMachineFromInfo(virDomainDefPtr def,
                                 virCapsGuestDomainInfoPtr info,
                                 char **canonical)
{
    int i;

    *canonical = NULL;

    for (i = 0; i < info->nmachines; i++) {
        virCapsGuestMachinePtr machine = info->machines[i];

        if (!machine->canonical)
            continue;

        if (strcmp(def->os.machine, machine->name) != 0)
            continue;

        if (!(*canonical = strdup(machine->canonical))) {
            virReportOOMError(NULL);
            return -1;
        }

        break;
    }

    return 0;
}

4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260
static int
qemudCanonicalizeMachineDirect(virDomainDefPtr def, char **canonical)
{
    virCapsGuestMachinePtr *machines = NULL;
    int i, nmachines = 0;

    if (qemudProbeMachineTypes(def->emulator, &machines, &nmachines) < 0) {
        virReportOOMError(NULL);
        return -1;
    }

    for (i = 0; i < nmachines; i++) {
        if (!machines[i]->canonical)
            continue;

        if (strcmp(def->os.machine, machines[i]->name) != 0)
            continue;

        *canonical = machines[i]->canonical;
        machines[i]->canonical = NULL;
        break;
    }

    virCapabilitiesFreeMachines(machines, nmachines);

    return 0;
}

4261 4262
int
qemudCanonicalizeMachine(struct qemud_driver *driver, virDomainDefPtr def)
4263 4264 4265 4266 4267 4268
{
    char *canonical = NULL;
    int i;

    for (i = 0; i < driver->caps->nguests; i++) {
        virCapsGuestPtr guest = driver->caps->guests[i];
4269
        virCapsGuestDomainInfoPtr info;
4270 4271 4272
        int j;

        for (j = 0; j < guest->arch.ndomains; j++) {
4273
            info = &guest->arch.domains[j]->info;
4274

4275 4276 4277 4278 4279 4280 4281 4282 4283
            if (!info->emulator || !STREQ(info->emulator, def->emulator))
                continue;

            if (!info->nmachines)
                info = &guest->arch.defaultInfo;

            if (qemudCanonicalizeMachineFromInfo(def, info, &canonical) < 0)
                return -1;
            goto out;
4284 4285
        }

4286 4287 4288 4289
        info = &guest->arch.defaultInfo;

        if (info->emulator && STREQ(info->emulator, def->emulator)) {
            if (qemudCanonicalizeMachineFromInfo(def, info, &canonical) < 0)
4290 4291 4292 4293
                return -1;
            goto out;
        }
    }
4294 4295 4296 4297

    if (qemudCanonicalizeMachineDirect(def, &canonical) < 0)
        return -1;

4298 4299 4300 4301 4302 4303 4304
out:
    if (canonical) {
        VIR_FREE(def->os.machine);
        def->os.machine = canonical;
    }
    return 0;
}
D
Daniel P. Berrange 已提交
4305

4306
static virDomainPtr qemudDomainDefine(virConnectPtr conn, const char *xml) {
4307
    struct qemud_driver *driver = conn->privateData;
4308
    virDomainDefPtr def;
4309
    virDomainObjPtr vm = NULL;
4310
    virDomainPtr dom = NULL;
4311
    virDomainEventPtr event = NULL;
4312
    int newVM = 1;
4313

4314
    qemuDriverLock(driver);
4315 4316
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE)))
4317
        goto cleanup;
4318

4319 4320 4321
    if (virSecurityDriverVerify(conn, def) < 0)
        goto cleanup;

4322 4323
    /* See if a VM with matching UUID already exists */
    vm = virDomainFindByUUID(&driver->domains, def->uuid);
4324
    if (vm) {
4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335
        /* UUID matches, but if names don't match, refuse it */
        if (STRNEQ(vm->def->name, def->name)) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(vm->def->uuid, uuidstr);
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                             _("domain '%s' is already defined with uuid %s"),
                             vm->def->name, uuidstr);
            goto cleanup;
        }

        /* UUID & name match */
4336
        virDomainObjUnlock(vm);
4337
        newVM = 0;
4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348
    } else {
        /* UUID does not match, but if a name matches, refuse it */
        vm = virDomainFindByName(&driver->domains, def->name);
        if (vm) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(vm->def->uuid, uuidstr);
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                             _("domain '%s' is already defined with uuid %s"),
                             def->name, uuidstr);
            goto cleanup;
        }
4349
    }
4350

4351
    if (qemudCanonicalizeMachine(driver, def) < 0)
4352 4353
        goto cleanup;

4354 4355 4356
    if (!(vm = virDomainAssignDef(conn,
                                  &driver->domains,
                                  def))) {
4357
        goto cleanup;
4358
    }
4359
    def = NULL;
4360
    vm->persistent = 1;
4361

4362 4363
    if (virDomainSaveConfig(conn,
                            driver->configDir,
4364
                            vm->newDef ? vm->newDef : vm->def) < 0) {
4365 4366
        virDomainRemoveInactive(&driver->domains,
                                vm);
4367
        vm = NULL;
4368
        goto cleanup;
4369 4370
    }

4371 4372 4373 4374 4375
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_DEFINED,
                                     newVM ?
                                     VIR_DOMAIN_EVENT_DEFINED_ADDED :
                                     VIR_DOMAIN_EVENT_DEFINED_UPDATED);
4376

4377
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
4378
    if (dom) dom->id = vm->def->id;
4379 4380

cleanup:
4381
    virDomainDefFree(def);
4382 4383
    if (vm)
        virDomainObjUnlock(vm);
4384 4385
    if (event)
        qemuDomainEventQueue(driver, event);
4386
    qemuDriverUnlock(driver);
4387
    return dom;
D
Daniel P. Berrange 已提交
4388 4389
}

4390
static int qemudDomainUndefine(virDomainPtr dom) {
4391 4392
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
4393
    virDomainEventPtr event = NULL;
4394
    int ret = -1;
D
Daniel P. Berrange 已提交
4395

4396
    qemuDriverLock(driver);
4397
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
4398

D
Daniel P. Berrange 已提交
4399
    if (!vm) {
4400 4401 4402 4403
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
4404
        goto cleanup;
D
Daniel P. Berrange 已提交
4405 4406
    }

4407
    if (virDomainIsActive(vm)) {
4408
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
4409
                         "%s", _("cannot delete active domain"));
4410
        goto cleanup;
D
Daniel P. Berrange 已提交
4411 4412
    }

4413 4414 4415
    if (!vm->persistent) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("cannot undefine transient domain"));
4416
        goto cleanup;
4417 4418 4419
    }

    if (virDomainDeleteConfig(dom->conn, driver->configDir, driver->autostartDir, vm) < 0)
4420
        goto cleanup;
D
Daniel P. Berrange 已提交
4421

4422 4423 4424
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_UNDEFINED,
                                     VIR_DOMAIN_EVENT_UNDEFINED_REMOVED);
4425

4426 4427
    virDomainRemoveInactive(&driver->domains,
                            vm);
4428
    vm = NULL;
4429
    ret = 0;
D
Daniel P. Berrange 已提交
4430

4431
cleanup:
4432 4433
    if (vm)
        virDomainObjUnlock(vm);
4434 4435
    if (event)
        qemuDomainEventQueue(driver, event);
4436
    qemuDriverUnlock(driver);
4437
    return ret;
D
Daniel P. Berrange 已提交
4438 4439
}

4440
/* Return the disks name for use in monitor commands */
4441
static char *qemudDiskDeviceName(const virConnectPtr conn,
4442
                                 const virDomainDiskDefPtr disk) {
4443 4444 4445 4446 4447 4448

    int busid, devid;
    int ret;
    char *devname;

    if (virDiskNameToBusDeviceIndex(disk, &busid, &devid) < 0) {
4449
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
4450 4451 4452 4453 4454 4455 4456
                         _("cannot convert disk '%s' to bus/device index"),
                         disk->dst);
        return NULL;
    }

    switch (disk->bus) {
        case VIR_DOMAIN_DISK_BUS_IDE:
4457
            if (disk->device== VIR_DOMAIN_DISK_DEVICE_DISK)
4458
                ret = virAsprintf(&devname, "ide%d-hd%d", busid, devid);
4459
            else
4460
                ret = virAsprintf(&devname, "ide%d-cd%d", busid, devid);
4461 4462
            break;
        case VIR_DOMAIN_DISK_BUS_SCSI:
4463
            if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK)
4464
                ret = virAsprintf(&devname, "scsi%d-hd%d", busid, devid);
4465
            else
4466
                ret = virAsprintf(&devname, "scsi%d-cd%d", busid, devid);
4467 4468
            break;
        case VIR_DOMAIN_DISK_BUS_FDC:
4469
            ret = virAsprintf(&devname, "floppy%d", devid);
4470 4471
            break;
        case VIR_DOMAIN_DISK_BUS_VIRTIO:
4472
            ret = virAsprintf(&devname, "virtio%d", devid);
4473 4474
            break;
        default:
4475
            qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SUPPORT,
4476 4477 4478 4479 4480 4481
                             _("Unsupported disk name mapping for bus '%s'"),
                             virDomainDiskBusTypeToString(disk->bus));
            return NULL;
    }

    if (ret == -1) {
4482
        virReportOOMError(conn);
4483 4484 4485 4486 4487 4488
        return NULL;
    }

    return devname;
}

4489 4490
static int qemudDomainChangeEjectableMedia(virConnectPtr conn,
                                           virDomainObjPtr vm,
4491 4492
                                           virDomainDeviceDefPtr dev,
                                           unsigned int qemuCmdFlags)
4493
{
4494
    virDomainDiskDefPtr origdisk = NULL, newdisk;
4495
    char *devname = NULL;
4496
    int i;
4497
    int ret;
4498

4499
    origdisk = NULL;
4500
    newdisk = dev->data.disk;
4501 4502 4503 4504
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (vm->def->disks[i]->bus == newdisk->bus &&
            STREQ(vm->def->disks[i]->dst, newdisk->dst)) {
            origdisk = vm->def->disks[i];
4505
            break;
4506
        }
4507 4508 4509
    }

    if (!origdisk) {
4510
        qemudReportError(conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
4511 4512 4513 4514 4515 4516 4517
                         _("No device with bus '%s' and target '%s'"),
                         virDomainDiskBusTypeToString(newdisk->bus),
                         newdisk->dst);
        return -1;
    }

    if (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE) {
4518
        if (!(devname = qemudDiskDeviceName(conn, newdisk)))
4519 4520 4521 4522 4523 4524 4525 4526 4527
            return -1;
    } else {
        /* Back compat for no -drive option */
        if (newdisk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)
            devname = strdup(newdisk->dst);
        else if (newdisk->device == VIR_DOMAIN_DISK_DEVICE_CDROM &&
                 STREQ(newdisk->dst, "hdc"))
            devname = strdup("cdrom");
        else {
4528
            qemudReportError(conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
4529 4530 4531 4532 4533 4534 4535 4536
                             _("Emulator version does not support removable "
                               "media for device '%s' and target '%s'"),
                               virDomainDiskDeviceTypeToString(newdisk->device),
                               newdisk->dst);
            return -1;
        }

        if (!devname) {
4537
            virReportOOMError(conn);
4538 4539 4540
            return -1;
        }
    }
4541

4542
    if (newdisk->src) {
4543 4544 4545
        ret = qemuMonitorChangeMedia(vm, devname, newdisk->src);
    } else {
        ret = qemuMonitorEjectMedia(vm, devname);
4546
    }
4547

4548 4549 4550 4551 4552
    if (ret == 0) {
        VIR_FREE(origdisk->src);
        origdisk->src = newdisk->src;
        newdisk->src = NULL;
        origdisk->type = newdisk->type;
4553
    }
4554

4555
    return ret;
4556 4557
}

4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624
static int
qemudParsePciAddReply(virDomainObjPtr vm,
                      const char *reply,
                      unsigned *domain,
                      unsigned *bus,
                      unsigned *slot)
{
    char *s, *e;

    DEBUG("%s: pci_add reply: %s", vm->def->name, reply);

    /* If the command succeeds qemu prints:
     * OK bus 0, slot XXX...
     * or
     * OK domain 0, bus 0, slot XXX
     */
    if (!(s = strstr(reply, "OK ")))
        return -1;

    s += 3;

    if (STRPREFIX(s, "domain ")) {
        s += strlen("domain ");

        if (virStrToLong_ui(s, &e, 10, domain) == -1) {
            VIR_WARN(_("Unable to parse domain number '%s'\n"), s);
            return -1;
        }

        if (!STRPREFIX(e, ", ")) {
            VIR_WARN(_("Expected ', ' parsing pci_add reply '%s'\n"), s);
            return -1;
        }
        s = e + 2;
    }

    if (!STRPREFIX(s, "bus ")) {
        VIR_WARN(_("Expected 'bus ' parsing pci_add reply '%s'\n"), s);
        return -1;
    }
    s += strlen("bus ");

    if (virStrToLong_ui(s, &e, 10, bus) == -1) {
        VIR_WARN(_("Unable to parse bus number '%s'\n"), s);
        return -1;
    }

    if (!STRPREFIX(e, ", ")) {
        VIR_WARN(_("Expected ', ' parsing pci_add reply '%s'\n"), s);
        return -1;
    }
    s = e + 2;

    if (!STRPREFIX(s, "slot ")) {
        VIR_WARN(_("Expected 'slot ' parsing pci_add reply '%s'\n"), s);
        return -1;
    }
    s += strlen("slot ");

    if (virStrToLong_ui(s, &e, 10, slot) == -1) {
        VIR_WARN(_("Unable to parse slot number '%s'\n"), s);
        return -1;
    }

    return 0;
}

4625 4626 4627
static int qemudDomainAttachPciDiskDevice(virConnectPtr conn,
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
4628 4629
{
    int ret, i;
4630
    char *cmd, *reply;
4631 4632
    char *safe_path;
    const char* type = virDomainDiskBusTypeToString(dev->data.disk->bus);
4633
    int tryOldSyntax = 0;
4634
    unsigned domain, bus, slot;
4635 4636 4637

    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(vm->def->disks[i]->dst, dev->data.disk->dst)) {
4638
            qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4639 4640 4641 4642 4643 4644
                           _("target %s already exists"), dev->data.disk->dst);
            return -1;
        }
    }

    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
4645
        virReportOOMError(conn);
4646 4647 4648
        return -1;
    }

4649
try_command:
4650 4651
    safe_path = qemudEscapeMonitorArg(dev->data.disk->src);
    if (!safe_path) {
4652
        virReportOOMError(conn);
4653 4654 4655
        return -1;
    }

4656 4657
    ret = virAsprintf(&cmd, "pci_add %s storage file=%s,if=%s",
                      (tryOldSyntax ? "0": "pci_addr=auto"), safe_path, type);
4658 4659
    VIR_FREE(safe_path);
    if (ret == -1) {
4660
        virReportOOMError(conn);
4661 4662 4663
        return ret;
    }

4664
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
4665
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4666 4667 4668 4669 4670
                         _("cannot attach %s disk"), type);
        VIR_FREE(cmd);
        return -1;
    }

4671 4672
    VIR_FREE(cmd);

4673 4674 4675 4676 4677 4678
    if (qemudParsePciAddReply(vm, reply, &domain, &bus, &slot) < 0) {
        if (!tryOldSyntax && strstr(reply, "invalid char in expression")) {
            VIR_FREE(reply);
            tryOldSyntax = 1;
            goto try_command;
        }
4679

4680
        qemudReportError (conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4681
                          _("adding %s disk failed: %s"), type, reply);
4682 4683 4684 4685
        VIR_FREE(reply);
        return -1;
    }

4686 4687 4688 4689 4690 4691
    VIR_FREE(reply);

    dev->data.disk->pci_addr.domain = domain;
    dev->data.disk->pci_addr.bus    = bus;
    dev->data.disk->pci_addr.slot   = slot;

4692
    virDomainDiskInsertPreAlloced(vm->def, dev->data.disk);
4693 4694 4695

    return 0;
}
4696

4697 4698 4699
static int qemudDomainAttachUsbMassstorageDevice(virConnectPtr conn,
                                                 virDomainObjPtr vm,
                                                 virDomainDeviceDefPtr dev)
4700
{
4701
    int i;
4702

4703 4704
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(vm->def->disks[i]->dst, dev->data.disk->dst)) {
4705
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4706 4707 4708 4709 4710
                           _("target %s already exists"), dev->data.disk->dst);
            return -1;
        }
    }

4711 4712 4713
    if (!dev->data.disk->src) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("disk source path is missing"));
4714 4715 4716
        return -1;
    }

4717
    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
4718
        virReportOOMError(conn);
4719 4720 4721
        return -1;
    }

4722
    if (qemuMonitorAddUSBDisk(vm, dev->data.disk->src) < 0)
4723
        return -1;
4724

4725
    virDomainDiskInsertPreAlloced(vm->def, dev->data.disk);
4726

4727 4728 4729
    return 0;
}

M
Mark McLoughlin 已提交
4730
static int qemudDomainAttachNetDevice(virConnectPtr conn,
4731
                                      struct qemud_driver *driver,
M
Mark McLoughlin 已提交
4732 4733 4734 4735 4736
                                      virDomainObjPtr vm,
                                      virDomainDeviceDefPtr dev,
                                      unsigned int qemuCmdFlags)
{
    virDomainNetDefPtr net = dev->data.net;
4737
    char *cmd = NULL, *reply = NULL, *remove_cmd = NULL;
4738 4739
    char *tapfd_name = NULL, *tapfd_close = NULL;
    int i, tapfd = -1;
4740
    unsigned domain, bus, slot;
M
Mark McLoughlin 已提交
4741 4742 4743 4744 4745 4746 4747 4748 4749

    if (!(qemuCmdFlags & QEMUD_CMD_FLAG_HOST_NET_ADD)) {
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT, "%s",
                         _("installed qemu version does not support host_net_add"));
        return -1;
    }

    if (net->type == VIR_DOMAIN_NET_TYPE_BRIDGE ||
        net->type == VIR_DOMAIN_NET_TYPE_NETWORK) {
4750 4751 4752 4753 4754 4755 4756 4757 4758 4759
        if (vm->monitor_chr->type != VIR_DOMAIN_CHR_TYPE_UNIX) {
            qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                             _("network device type '%s' cannot be attached: "
                               "qemu is not using a unix socket monitor"),
                             virDomainNetTypeToString(net->type));
            return -1;
        }

        if ((tapfd = qemudNetworkIfaceConnect(conn, driver, net, qemuCmdFlags)) < 0)
            return -1;
M
Mark McLoughlin 已提交
4760 4761
    }

4762 4763
    if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
        goto no_memory;
M
Mark McLoughlin 已提交
4764 4765

    if ((qemuCmdFlags & QEMUD_CMD_FLAG_NET_NAME) &&
4766 4767
        qemuAssignNetNames(vm->def, net) < 0)
        goto no_memory;
M
Mark McLoughlin 已提交
4768 4769 4770 4771 4772 4773 4774 4775 4776

    /* Choose a vlan value greater than all other values since
     * older versions did not store the value in the state file.
     */
    net->vlan = vm->def->nnets;
    for (i = 0; i < vm->def->nnets; i++)
        if (vm->def->nets[i]->vlan >= net->vlan)
            net->vlan = vm->def->nets[i]->vlan;

4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811
    if (tapfd != -1) {
        if (virAsprintf(&tapfd_name, "fd-%s", net->hostnet_name) < 0)
            goto no_memory;

        if (virAsprintf(&tapfd_close, "closefd %s", tapfd_name) < 0)
            goto no_memory;

        if (virAsprintf(&cmd, "getfd %s", tapfd_name) < 0)
            goto no_memory;

        if (qemudMonitorCommandWithFd(vm, cmd, tapfd, &reply) < 0) {
            qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                             _("failed to pass fd to qemu with '%s'"), cmd);
            goto cleanup;
        }

        DEBUG("%s: getfd reply: %s", vm->def->name, reply);

        /* If the command isn't supported then qemu prints:
         * unknown command: getfd" */
        if (strstr(reply, "unknown command:")) {
            qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                             "%s",
                             _("bridge/network interface attach not supported: "
                               "qemu 'getfd' monitor command not available"));
            goto cleanup;
        }

        VIR_FREE(reply);
        VIR_FREE(cmd);
    }

    if (qemuBuildHostNetStr(conn, net, "host_net_add ", ' ',
                            net->vlan, tapfd_name, &cmd) < 0)
        goto try_tapfd_close;
M
Mark McLoughlin 已提交
4812

4813 4814 4815 4816
    remove_cmd = NULL;
    if (net->vlan >= 0 && net->hostnet_name &&
        virAsprintf(&remove_cmd, "host_net_remove %d %s",
                    net->vlan, net->hostnet_name) < 0) {
4817 4818
        virReportOOMError(conn);
        goto try_tapfd_close;
4819 4820
    }

M
Mark McLoughlin 已提交
4821 4822 4823
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         _("failed to add network backend with '%s'"), cmd);
4824
        goto try_tapfd_close;
M
Mark McLoughlin 已提交
4825 4826 4827 4828 4829 4830
    }

    DEBUG("%s: host_net_add reply: %s", vm->def->name, reply);

    VIR_FREE(reply);
    VIR_FREE(cmd);
4831 4832 4833 4834 4835
    VIR_FREE(tapfd_name);
    VIR_FREE(tapfd_close);
    if (tapfd != -1)
        close(tapfd);
    tapfd = -1;
M
Mark McLoughlin 已提交
4836 4837

    if (qemuBuildNicStr(conn, net,
4838 4839
                        "pci_add pci_addr=auto ", ' ', net->vlan, &cmd) < 0)
        goto try_remove;
M
Mark McLoughlin 已提交
4840 4841 4842 4843

    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         _("failed to add NIC with '%s'"), cmd);
4844
        goto try_remove;
M
Mark McLoughlin 已提交
4845 4846
    }

4847 4848 4849 4850 4851 4852
    if (qemudParsePciAddReply(vm, reply, &domain, &bus, &slot) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         _("parsing pci_add reply failed: %s"), reply);
        goto try_remove;
    }

4853
    VIR_FREE(cmd);
4854
    VIR_FREE(reply);
4855
    VIR_FREE(remove_cmd);
M
Mark McLoughlin 已提交
4856

4857 4858 4859 4860
    net->pci_addr.domain = domain;
    net->pci_addr.bus    = bus;
    net->pci_addr.slot   = slot;

M
Mark McLoughlin 已提交
4861 4862 4863
    vm->def->nets[vm->def->nnets++] = net;

    return 0;
4864 4865

try_remove:
4866
    VIR_FREE(reply);
4867 4868 4869 4870 4871 4872 4873

    if (!remove_cmd)
        VIR_WARN0(_("Unable to remove network backend\n"));
    else if (qemudMonitorCommand(vm, remove_cmd, &reply) < 0)
        VIR_WARN(_("Failed to remove network backend with '%s'\n"), remove_cmd);
    else
        VIR_DEBUG("%s: host_net_remove reply: %s\n", vm->def->name, reply);
4874
    goto cleanup;
4875

4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886
try_tapfd_close:
    VIR_FREE(reply);

    if (tapfd_close) {
        if (qemudMonitorCommand(vm, tapfd_close, &reply) < 0)
            VIR_WARN(_("Failed to close tapfd with '%s'\n"), tapfd_close);
        else
            VIR_DEBUG("%s: closefd: %s\n", vm->def->name, reply);
    }
    goto cleanup;

4887 4888 4889 4890
no_memory:
    virReportOOMError(conn);
cleanup:
    VIR_FREE(cmd);
4891 4892
    VIR_FREE(reply);
    VIR_FREE(remove_cmd);
4893 4894 4895 4896
    VIR_FREE(tapfd_close);
    VIR_FREE(tapfd_name);
    if (tapfd != -1)
        close(tapfd);
4897
    return -1;
M
Mark McLoughlin 已提交
4898 4899
}

4900
static int qemudDomainAttachHostPciDevice(virConnectPtr conn,
4901
                                          struct qemud_driver *driver,
4902 4903 4904 4905 4906 4907
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
{
    virDomainHostdevDefPtr hostdev = dev->data.hostdev;
    char *cmd, *reply;
    unsigned domain, bus, slot;
4908
    pciDevice *pci;
4909 4910 4911 4912 4913 4914

    if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
        virReportOOMError(conn);
        return -1;
    }

4915 4916 4917 4918 4919 4920 4921
    pci = pciGetDevice(conn,
                       hostdev->source.subsys.u.pci.domain,
                       hostdev->source.subsys.u.pci.bus,
                       hostdev->source.subsys.u.pci.slot,
                       hostdev->source.subsys.u.pci.function);
    if (!dev)
        return -1;
4922

4923
    if ((hostdev->managed && pciDettachDevice(conn, pci) < 0) ||
4924 4925 4926 4927 4928 4929
        pciResetDevice(conn, pci, driver->activePciHostdevs) < 0) {
        pciFreeDevice(conn, pci);
        return -1;
    }

    if (pciDeviceListAdd(conn, driver->activePciHostdevs, pci) < 0) {
4930
        pciFreeDevice(conn, pci);
4931
        return -1;
4932 4933
    }

4934
    cmd = reply = NULL;
4935

4936
    if (virAsprintf(&cmd, "pci_add pci_addr=auto host host=%.2x:%.2x.%.1x",
4937 4938 4939 4940
                    hostdev->source.subsys.u.pci.bus,
                    hostdev->source.subsys.u.pci.slot,
                    hostdev->source.subsys.u.pci.function) < 0) {
        virReportOOMError(conn);
4941
        goto error;
4942 4943 4944 4945 4946
    }

    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("cannot attach host pci device"));
4947
        goto error;
4948 4949 4950 4951 4952
    }

    if (strstr(reply, "invalid type: host")) {
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT, "%s",
                         _("PCI device assignment is not supported by this version of qemu"));
4953
        goto error;
4954 4955 4956 4957 4958
    }

    if (qemudParsePciAddReply(vm, reply, &domain, &bus, &slot) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         _("parsing pci_add reply failed: %s"), reply);
4959
        goto error;
4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971
    }

    hostdev->source.subsys.u.pci.guest_addr.domain = domain;
    hostdev->source.subsys.u.pci.guest_addr.bus    = bus;
    hostdev->source.subsys.u.pci.guest_addr.slot   = slot;

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

    VIR_FREE(reply);
    VIR_FREE(cmd);

    return 0;
4972 4973 4974 4975 4976 4977 4978 4979

error:
    pciDeviceListDel(conn, driver->activePciHostdevs, pci);

    VIR_FREE(reply);
    VIR_FREE(cmd);

    return -1;
4980 4981
}

M
Mark McLoughlin 已提交
4982 4983 4984
static int qemudDomainAttachHostUsbDevice(virConnectPtr conn,
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
4985 4986 4987 4988
{
    int ret;
    char *cmd, *reply;

4989
    if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
4990
        virReportOOMError(conn);
4991 4992
        return -1;
    }
4993

4994
    if (dev->data.hostdev->source.subsys.u.usb.vendor) {
4995 4996 4997
        ret = virAsprintf(&cmd, "usb_add host:%.4x:%.4x",
                          dev->data.hostdev->source.subsys.u.usb.vendor,
                          dev->data.hostdev->source.subsys.u.usb.product);
4998
    } else {
4999 5000 5001
        ret = virAsprintf(&cmd, "usb_add host:%.3d.%.3d",
                          dev->data.hostdev->source.subsys.u.usb.bus,
                          dev->data.hostdev->source.subsys.u.usb.device);
5002 5003
    }
    if (ret == -1) {
5004
        virReportOOMError(conn);
5005 5006 5007
        return -1;
    }

5008
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
5009
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
5010 5011 5012 5013 5014
                         "%s", _("cannot attach usb device"));
        VIR_FREE(cmd);
        return -1;
    }

5015
    DEBUG ("%s: attach_usb reply: %s", vm->def->name, reply);
5016 5017 5018
    /* If the command failed qemu prints:
     * Could not add ... */
    if (strstr(reply, "Could not add ")) {
5019
        qemudReportError (conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
5020 5021 5022 5023 5024 5025
                          "%s",
                          _("adding usb device failed"));
        VIR_FREE(reply);
        VIR_FREE(cmd);
        return -1;
    }
5026

5027
    vm->def->hostdevs[vm->def->nhostdevs++] = dev->data.hostdev;
5028

5029 5030
    VIR_FREE(reply);
    VIR_FREE(cmd);
5031 5032 5033
    return 0;
}

M
Mark McLoughlin 已提交
5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049
static int qemudDomainAttachHostDevice(virConnectPtr conn,
                                       struct qemud_driver *driver,
                                       virDomainObjPtr vm,
                                       virDomainDeviceDefPtr dev)
{
    virDomainHostdevDefPtr hostdev = dev->data.hostdev;

    if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         _("hostdev mode '%s' not supported"),
                         virDomainHostdevModeTypeToString(hostdev->mode));
        return -1;
    }

    if (qemuDomainSetDeviceOwnership(conn, driver, dev, 0) < 0)
        return -1;
5050 5051 5052
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityHostdevLabel(conn, vm, dev->data.hostdev) < 0)
        return -1;
M
Mark McLoughlin 已提交
5053 5054

    switch (hostdev->source.subsys.type) {
5055
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
5056
        return qemudDomainAttachHostPciDevice(conn, driver, vm, dev);
M
Mark McLoughlin 已提交
5057 5058 5059 5060 5061 5062 5063 5064 5065 5066
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
        return qemudDomainAttachHostUsbDevice(conn, vm, dev);
    default:
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         _("hostdev subsys type '%s' not supported"),
                         virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
        return -1;
    }
}

5067 5068
static int qemudDomainAttachDevice(virDomainPtr dom,
                                   const char *xml) {
5069 5070 5071
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr dev = NULL;
5072
    unsigned int qemuCmdFlags;
5073
    virCgroupPtr cgroup = NULL;
5074
    int ret = -1;
5075

5076
    qemuDriverLock(driver);
5077
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5078
    if (!vm) {
5079 5080 5081 5082
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
5083
        goto cleanup;
5084 5085 5086
    }

    if (!virDomainIsActive(vm)) {
5087
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
5088
                         "%s", _("cannot attach device on inactive domain"));
5089
        goto cleanup;
5090 5091
    }

5092 5093
    dev = virDomainDeviceDefParse(dom->conn, driver->caps, vm->def, xml,
                                  VIR_DOMAIN_XML_INACTIVE);
5094 5095 5096
    if (dev == NULL)
        goto cleanup;

5097 5098 5099 5100
    if (qemudExtractVersionInfo(vm->def->emulator,
                                NULL,
                                &qemuCmdFlags) < 0)
        goto cleanup;
5101

5102
    if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
5103
        if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120
            if (virCgroupForDomain(driver->cgroup, vm->def->name, &cgroup, 0) !=0 ) {
                qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 _("Unable to find cgroup for %s\n"),
                                 vm->def->name);
                goto cleanup;
            }
            if (dev->data.disk->src != NULL &&
                dev->data.disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK &&
                virCgroupAllowDevicePath(cgroup,
                                         dev->data.disk->src) < 0) {
                qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 _("unable to allow device %s"),
                                 dev->data.disk->src);
                goto cleanup;
            }
        }

5121
        switch (dev->data.disk->device) {
5122 5123
        case VIR_DOMAIN_DISK_DEVICE_CDROM:
        case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
5124 5125
            if (driver->securityDriver)
                driver->securityDriver->domainSetSecurityImageLabel(dom->conn, vm, dev->data.disk);
5126 5127 5128 5129

            if (qemuDomainSetDeviceOwnership(dom->conn, driver, dev, 0) < 0)
                goto cleanup;

5130
            ret = qemudDomainChangeEjectableMedia(dom->conn, vm, dev, qemuCmdFlags);
5131
            break;
5132

5133
        case VIR_DOMAIN_DISK_DEVICE_DISK:
5134 5135
            if (driver->securityDriver)
                driver->securityDriver->domainSetSecurityImageLabel(dom->conn, vm, dev->data.disk);
5136 5137 5138 5139

            if (qemuDomainSetDeviceOwnership(dom->conn, driver, dev, 0) < 0)
                goto cleanup;

5140
            if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
5141
                ret = qemudDomainAttachUsbMassstorageDevice(dom->conn, vm, dev);
5142 5143
            } else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_SCSI ||
                       dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) {
5144
                ret = qemudDomainAttachPciDiskDevice(dom->conn, vm, dev);
5145 5146 5147 5148
            } else {
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                                 _("disk bus '%s' cannot be hotplugged."),
                                 virDomainDiskBusTypeToString(dev->data.disk->bus));
5149
                /* fallthrough */
5150 5151
            }
            break;
5152

5153 5154
        default:
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
5155 5156
                             _("disk device type '%s' cannot be hotplugged"),
                             virDomainDiskDeviceTypeToString(dev->data.disk->device));
5157 5158 5159 5160 5161
            /* Fallthrough */
        }
        if (ret != 0) {
            virCgroupDenyDevicePath(cgroup,
                                    dev->data.disk->src);
5162
        }
M
Mark McLoughlin 已提交
5163
    } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
5164
        ret = qemudDomainAttachNetDevice(dom->conn, driver, vm, dev, qemuCmdFlags);
M
Mark McLoughlin 已提交
5165 5166
    } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
        ret = qemudDomainAttachHostDevice(dom->conn, driver, vm, dev);
5167
    } else {
5168
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
5169 5170
                         _("device type '%s' cannot be attached"),
                         virDomainDeviceTypeToString(dev->type));
5171
        goto cleanup;
5172 5173
    }

5174
    if (!ret && virDomainSaveStatus(dom->conn, driver->stateDir, vm) < 0)
5175 5176
        ret = -1;

5177
cleanup:
5178 5179 5180
    if (cgroup)
        virCgroupFree(&cgroup);

5181 5182 5183
    if (ret < 0) {
        if (qemuDomainSetDeviceOwnership(dom->conn, driver, dev, 1) < 0)
            VIR_WARN0("Fail to restore disk device ownership");
G
Guido Günther 已提交
5184
        virDomainDeviceDefFree(dev);
5185
    }
5186 5187
    if (vm)
        virDomainObjUnlock(vm);
5188
    qemuDriverUnlock(driver);
5189 5190 5191
    return ret;
}

5192 5193
static int qemudDomainDetachPciDiskDevice(virConnectPtr conn,
                                          virDomainObjPtr vm, virDomainDeviceDefPtr dev)
5194 5195
{
    int i, ret = -1;
5196 5197
    char *cmd = NULL;
    char *reply = NULL;
5198
    virDomainDiskDefPtr detach = NULL;
5199
    int tryOldSyntax = 0;
5200 5201 5202 5203 5204 5205 5206 5207 5208

    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(vm->def->disks[i]->dst, dev->data.disk->dst)) {
            detach = vm->def->disks[i];
            break;
        }
    }

    if (!detach) {
5209
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5210
                         _("disk %s not found"), dev->data.disk->dst);
5211
        goto cleanup;
5212 5213
    }

5214
    if (!virDiskHasValidPciAddr(detach)) {
5215
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5216 5217
                         _("disk %s cannot be detached - no PCI address for device"),
                           detach->dst);
5218
        goto cleanup;
5219 5220
    }

5221 5222
try_command:
    if (tryOldSyntax) {
5223
        if (virAsprintf(&cmd, "pci_del 0 %.2x", detach->pci_addr.slot) < 0) {
5224 5225 5226 5227
            virReportOOMError(conn);
            goto cleanup;
        }
    } else {
5228 5229 5230 5231
        if (virAsprintf(&cmd, "pci_del pci_addr=%.4x:%.2x:%.2x",
                        detach->pci_addr.domain,
                        detach->pci_addr.bus,
                        detach->pci_addr.slot) < 0) {
5232 5233 5234
            virReportOOMError(conn);
            goto cleanup;
        }
5235 5236
    }

5237
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
5238
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5239
                          _("failed to execute detach disk %s command"), detach->dst);
5240
        goto cleanup;
5241 5242
    }

5243
    DEBUG ("%s: pci_del reply: %s",vm->def->name,  reply);
5244 5245 5246 5247 5248 5249

    if (!tryOldSyntax &&
        strstr(reply, "extraneous characters")) {
        tryOldSyntax = 1;
        goto try_command;
    }
5250 5251
    /* If the command fails due to a wrong slot qemu prints: invalid slot,
     * nothing is printed on success */
5252 5253
    if (strstr(reply, "invalid slot") ||
        strstr(reply, "Invalid pci address")) {
5254
        qemudReportError (conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5255 5256 5257 5258 5259 5260
                          _("failed to detach disk %s: invalid PCI address %.4x:%.2x:%.2x: %s"),
                          detach->dst,
                          detach->pci_addr.domain,
                          detach->pci_addr.bus,
                          detach->pci_addr.slot,
                          reply);
5261
        goto cleanup;
5262 5263
    }

5264 5265 5266 5267 5268 5269 5270 5271 5272 5273
    if (vm->def->ndisks > 1) {
        memmove(vm->def->disks + i,
                vm->def->disks + i + 1,
                sizeof(*vm->def->disks) *
                (vm->def->ndisks - (i + 1)));
        vm->def->ndisks--;
        if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks) < 0) {
            /* ignore, harmless */
        }
    } else {
5274
        VIR_FREE(vm->def->disks);
5275
        vm->def->ndisks = 0;
5276
    }
5277
    virDomainDiskDefFree(detach);
5278

5279
    ret = 0;
5280 5281

cleanup:
5282 5283 5284 5285 5286
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}

5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365
static int
qemudDomainDetachNetDevice(virConnectPtr conn,
                           virDomainObjPtr vm,
                           virDomainDeviceDefPtr dev)
{
    int i, ret = -1;
    char *cmd = NULL;
    char *reply = NULL;
    virDomainNetDefPtr detach = NULL;

    for (i = 0 ; i < vm->def->nnets ; i++) {
        virDomainNetDefPtr net = vm->def->nets[i];

        if (!memcmp(net->mac, dev->data.net->mac,  sizeof(net->mac))) {
            detach = net;
            break;
        }
    }

    if (!detach) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         _("network device %02x:%02x:%02x:%02x:%02x:%02x not found"),
                         dev->data.net->mac[0], dev->data.net->mac[1],
                         dev->data.net->mac[2], dev->data.net->mac[3],
                         dev->data.net->mac[4], dev->data.net->mac[5]);
        goto cleanup;
    }

    if (!virNetHasValidPciAddr(detach) || detach->vlan < 0 || !detach->hostnet_name) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("network device cannot be detached - device state missing"));
        goto cleanup;
    }

    if (virAsprintf(&cmd, "pci_del pci_addr=%.4x:%.2x:%.2x",
                    detach->pci_addr.domain,
                    detach->pci_addr.bus,
                    detach->pci_addr.slot) < 0) {
        virReportOOMError(conn);
        goto cleanup;
    }

    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                          _("network device dettach command '%s' failed"), cmd);
        goto cleanup;
    }

    DEBUG("%s: pci_del reply: %s", vm->def->name,  reply);

    /* If the command fails due to a wrong PCI address qemu prints
     * 'invalid pci address'; nothing is printed on success */
    if (strstr(reply, "Invalid pci address")) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         _("failed to detach network device: invalid PCI address %.4x:%.2x:%.2x: %s"),
                         detach->pci_addr.domain,
                         detach->pci_addr.bus,
                         detach->pci_addr.slot,
                         reply);
        goto cleanup;
    }

    VIR_FREE(reply);
    VIR_FREE(cmd);

    if (virAsprintf(&cmd, "host_net_remove %d %s",
                    detach->vlan, detach->hostnet_name) < 0) {
        virReportOOMError(conn);
        goto cleanup;
    }

    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                          _("network device dettach command '%s' failed"), cmd);
        goto cleanup;
    }

    DEBUG("%s: host_net_remove reply: %s", vm->def->name,  reply);

5366 5367 5368 5369 5370 5371 5372 5373 5374 5375
    if (vm->def->nnets > 1) {
        memmove(vm->def->nets + i,
                vm->def->nets + i + 1,
                sizeof(*vm->def->nets) *
                (vm->def->nnets - (i + 1)));
        vm->def->nnets--;
        if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets) < 0) {
            /* ignore, harmless */
        }
    } else {
5376
        VIR_FREE(vm->def->nets);
5377
        vm->def->nnets = 0;
5378
    }
5379
    virDomainNetDefFree(detach);
5380

5381 5382 5383 5384 5385 5386 5387 5388
    ret = 0;

cleanup:
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}

5389
static int qemudDomainDetachHostPciDevice(virConnectPtr conn,
5390
                                          struct qemud_driver *driver,
5391 5392 5393
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
{
5394
    virDomainHostdevDefPtr detach = NULL;
5395 5396
    char *cmd, *reply;
    int i, ret;
5397
    pciDevice *pci;
5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465

    for (i = 0 ; i < vm->def->nhostdevs ; i++) {
        unsigned domain   = vm->def->hostdevs[i]->source.subsys.u.pci.domain;
        unsigned bus      = vm->def->hostdevs[i]->source.subsys.u.pci.bus;
        unsigned slot     = vm->def->hostdevs[i]->source.subsys.u.pci.slot;
        unsigned function = vm->def->hostdevs[i]->source.subsys.u.pci.function;

        if (dev->data.hostdev->source.subsys.u.pci.domain   == domain &&
            dev->data.hostdev->source.subsys.u.pci.bus      == bus &&
            dev->data.hostdev->source.subsys.u.pci.slot     == slot &&
            dev->data.hostdev->source.subsys.u.pci.function == function) {
            detach = vm->def->hostdevs[i];
            break;
        }
    }

    if (!detach) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         _("host pci device %.4x:%.2x:%.2x.%.1x not found"),
                         dev->data.hostdev->source.subsys.u.pci.domain,
                         dev->data.hostdev->source.subsys.u.pci.bus,
                         dev->data.hostdev->source.subsys.u.pci.slot,
                         dev->data.hostdev->source.subsys.u.pci.function);
        return -1;
    }

    if (!virHostdevHasValidGuestAddr(detach)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("hostdev cannot be detached - device state missing"));
        return -1;
    }

    if (virAsprintf(&cmd, "pci_del pci_addr=%.4x:%.2x:%.2x",
                    detach->source.subsys.u.pci.guest_addr.domain,
                    detach->source.subsys.u.pci.guest_addr.bus,
                    detach->source.subsys.u.pci.guest_addr.slot) < 0) {
        virReportOOMError(conn);
        return -1;
    }

    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("cannot detach host pci device"));
        VIR_FREE(cmd);
        return -1;
    }

    DEBUG("%s: pci_del reply: %s", vm->def->name,  reply);

    /* If the command fails due to a wrong PCI address qemu prints
     * 'invalid pci address'; nothing is printed on success */
    if (strstr(reply, "Invalid pci address")) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         _("failed to detach host pci device: invalid PCI address %.4x:%.2x:%.2x: %s"),
                         detach->source.subsys.u.pci.guest_addr.domain,
                         detach->source.subsys.u.pci.guest_addr.bus,
                         detach->source.subsys.u.pci.guest_addr.slot,
                         reply);
        VIR_FREE(reply);
        VIR_FREE(cmd);
        return -1;
    }

    VIR_FREE(reply);
    VIR_FREE(cmd);

    ret = 0;

5466 5467 5468 5469 5470 5471 5472 5473
    pci = pciGetDevice(conn,
                       detach->source.subsys.u.pci.domain,
                       detach->source.subsys.u.pci.bus,
                       detach->source.subsys.u.pci.slot,
                       detach->source.subsys.u.pci.function);
    if (!pci)
        ret = -1;
    else {
5474 5475
        pciDeviceListDel(conn, driver->activePciHostdevs, pci);
        if (pciResetDevice(conn, pci, driver->activePciHostdevs) < 0)
5476 5477
            ret = -1;
        if (detach->managed && pciReAttachDevice(conn, pci) < 0)
5478
            ret = -1;
5479
        pciFreeDevice(conn, pci);
5480 5481
    }

5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493
    if (vm->def->nhostdevs > 1) {
        memmove(vm->def->hostdevs + i,
                vm->def->hostdevs + i + 1,
                sizeof(*vm->def->hostdevs) *
                (vm->def->nhostdevs - (i + 1)));
        vm->def->nhostdevs--;
        if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs) < 0) {
            /* ignore, harmless */
        }
    } else {
        VIR_FREE(vm->def->hostdevs);
        vm->def->nhostdevs = 0;
5494
    }
5495
    virDomainHostdevDefFree(detach);
5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516

    return ret;
}

static int qemudDomainDetachHostDevice(virConnectPtr conn,
                                       struct qemud_driver *driver,
                                       virDomainObjPtr vm,
                                       virDomainDeviceDefPtr dev)
{
    virDomainHostdevDefPtr hostdev = dev->data.hostdev;
    int ret;

    if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         _("hostdev mode '%s' not supported"),
                         virDomainHostdevModeTypeToString(hostdev->mode));
        return -1;
    }

    switch (hostdev->source.subsys.type) {
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
5517
        ret = qemudDomainDetachHostPciDevice(conn, driver, vm, dev);
5518
        break;
5519 5520 5521 5522 5523 5524 5525
    default:
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         _("hostdev subsys type '%s' not supported"),
                         virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
        return -1;
    }

5526 5527 5528 5529
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityHostdevLabel(conn, vm, dev->data.hostdev) < 0)
        VIR_WARN0("Failed to restore device labelling");

5530
    if (qemuDomainSetDeviceOwnership(conn, driver, dev, 1) < 0)
5531
        VIR_WARN0("Failed to restore device ownership");
5532 5533 5534 5535

    return ret;
}

5536 5537
static int qemudDomainDetachDevice(virDomainPtr dom,
                                   const char *xml) {
5538 5539 5540 5541
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr dev = NULL;
    int ret = -1;
5542

5543
    qemuDriverLock(driver);
5544
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5545
    if (!vm) {
5546 5547 5548 5549
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
5550
        goto cleanup;
5551 5552 5553
    }

    if (!virDomainIsActive(vm)) {
5554
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
G
Guido Günther 已提交
5555
                         "%s", _("cannot detach device on inactive domain"));
5556
        goto cleanup;
5557 5558
    }

5559 5560
    dev = virDomainDeviceDefParse(dom->conn, driver->caps, vm->def, xml,
                                  VIR_DOMAIN_XML_INACTIVE);
5561 5562 5563
    if (dev == NULL)
        goto cleanup;

5564 5565 5566 5567

    if (dev->type == VIR_DOMAIN_DEVICE_DISK &&
        dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
        (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_SCSI ||
5568
         dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)) {
5569
        ret = qemudDomainDetachPciDiskDevice(dom->conn, vm, dev);
5570
        if (driver->securityDriver)
5571
            driver->securityDriver->domainRestoreSecurityImageLabel(dom->conn, dev->data.disk);
5572 5573
        if (qemuDomainSetDeviceOwnership(dom->conn, driver, dev, 1) < 0)
            VIR_WARN0("Fail to restore disk device ownership");
5574 5575
    } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
        ret = qemudDomainDetachNetDevice(dom->conn, vm, dev);
5576 5577
    } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
        ret = qemudDomainDetachHostDevice(dom->conn, driver, vm, dev);
5578
    } else
5579 5580 5581
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         "%s", _("only SCSI or virtio disk device can be detached dynamically"));

5582
    if (!ret && virDomainSaveStatus(dom->conn, driver->stateDir, vm) < 0)
5583 5584
        ret = -1;

5585 5586
cleanup:
    virDomainDeviceDefFree(dev);
5587 5588
    if (vm)
        virDomainObjUnlock(vm);
5589
    qemuDriverUnlock(driver);
5590 5591 5592
    return ret;
}

5593
static int qemudDomainGetAutostart(virDomainPtr dom,
5594
                                   int *autostart) {
5595 5596 5597
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
5598

5599
    qemuDriverLock(driver);
5600
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5601 5602
    qemuDriverUnlock(driver);

5603
    if (!vm) {
5604 5605 5606 5607
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
5608
        goto cleanup;
5609 5610 5611
    }

    *autostart = vm->autostart;
5612
    ret = 0;
5613

5614
cleanup:
5615 5616
    if (vm)
        virDomainObjUnlock(vm);
5617
    return ret;
5618 5619
}

5620
static int qemudDomainSetAutostart(virDomainPtr dom,
5621
                                   int autostart) {
5622 5623
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
5624 5625
    char *configFile = NULL, *autostartLink = NULL;
    int ret = -1;
5626

5627
    qemuDriverLock(driver);
5628
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5629

5630
    if (!vm) {
5631 5632 5633 5634
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
5635
        goto cleanup;
5636 5637
    }

5638 5639 5640
    if (!vm->persistent) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("cannot set autostart for transient domain"));
5641
        goto cleanup;
5642 5643
    }

5644 5645
    autostart = (autostart != 0);

5646 5647 5648 5649 5650
    if (vm->autostart != autostart) {
        if ((configFile = virDomainConfigFile(dom->conn, driver->configDir, vm->def->name)) == NULL)
            goto cleanup;
        if ((autostartLink = virDomainConfigFile(dom->conn, driver->autostartDir, vm->def->name)) == NULL)
            goto cleanup;
5651

5652 5653
        if (autostart) {
            int err;
5654

5655
            if ((err = virFileMakePath(driver->autostartDir))) {
5656 5657 5658
                virReportSystemError(dom->conn, err,
                                     _("cannot create autostart directory %s"),
                                     driver->autostartDir);
5659 5660
                goto cleanup;
            }
5661

5662
            if (symlink(configFile, autostartLink) < 0) {
5663 5664 5665
                virReportSystemError(dom->conn, errno,
                                     _("Failed to create symlink '%s to '%s'"),
                                     autostartLink, configFile);
5666 5667 5668 5669
                goto cleanup;
            }
        } else {
            if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
5670 5671 5672
                virReportSystemError(dom->conn, errno,
                                     _("Failed to delete symlink '%s'"),
                                     autostartLink);
5673 5674
                goto cleanup;
            }
5675 5676
        }

5677
        vm->autostart = autostart;
5678
    }
5679
    ret = 0;
5680

5681 5682 5683
cleanup:
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
5684 5685
    if (vm)
        virDomainObjUnlock(vm);
5686
    qemuDriverUnlock(driver);
5687
    return ret;
5688 5689
}

5690 5691 5692 5693 5694

static char *qemuGetSchedulerType(virDomainPtr dom,
                                  int *nparams)
{
    struct qemud_driver *driver = dom->conn->privateData;
5695
    char *ret = NULL;
5696

5697
    qemuDriverLock(driver);
5698
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
5699 5700
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
5701
        goto cleanup;
5702 5703 5704 5705 5706 5707 5708 5709
    }

    if (nparams)
        *nparams = 1;

    ret = strdup("posix");
    if (!ret)
        virReportOOMError(dom->conn);
5710 5711 5712

cleanup:
    qemuDriverUnlock(driver);
5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725
    return ret;
}

static int qemuSetSchedulerParameters(virDomainPtr dom,
                                      virSchedParameterPtr params,
                                      int nparams)
{
    struct qemud_driver *driver = dom->conn->privateData;
    int i;
    virCgroupPtr group = NULL;
    virDomainObjPtr vm = NULL;
    int ret = -1;

5726
    qemuDriverLock(driver);
5727
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
5728 5729
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
5730
        goto cleanup;
5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775
    }

    vm = virDomainFindByUUID(&driver->domains, dom->uuid);

    if (vm == NULL) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("No such domain %s"), dom->uuid);
        goto cleanup;
    }

    if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("cannot find cgroup for domain %s"), vm->def->name);
        goto cleanup;
    }

    for (i = 0; i < nparams; i++) {
        virSchedParameterPtr param = &params[i];

        if (STREQ(param->field, "cpu_shares")) {
            int rc;
            if (param->type != VIR_DOMAIN_SCHED_FIELD_ULLONG) {
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                                 _("invalid type for cpu_shares tunable, expected a 'ullong'"));
                goto cleanup;
            }

            rc = virCgroupSetCpuShares(group, params[i].value.ul);
            if (rc != 0) {
                virReportSystemError(dom->conn, -rc, "%s",
                                     _("unable to set cpu shares tunable"));
                goto cleanup;
            }
        } else {
            qemudReportError(dom->conn, domain, NULL, VIR_ERR_INVALID_ARG,
                             _("Invalid parameter `%s'"), param->field);
            goto cleanup;
        }
    }
    ret = 0;

cleanup:
    virCgroupFree(&group);
    if (vm)
        virDomainObjUnlock(vm);
5776
    qemuDriverUnlock(driver);
5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790
    return ret;
}

static int qemuGetSchedulerParameters(virDomainPtr dom,
                                      virSchedParameterPtr params,
                                      int *nparams)
{
    struct qemud_driver *driver = dom->conn->privateData;
    virCgroupPtr group = NULL;
    virDomainObjPtr vm = NULL;
    unsigned long long val;
    int ret = -1;
    int rc;

5791
    qemuDriverLock(driver);
5792
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
5793 5794
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
5795
        goto cleanup;
5796 5797 5798 5799 5800
    }

    if ((*nparams) != 1) {
        qemudReportError(dom->conn, domain, NULL, VIR_ERR_INVALID_ARG,
                         "%s", _("Invalid parameter count"));
5801
        goto cleanup;
5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825
    }

    vm = virDomainFindByUUID(&driver->domains, dom->uuid);

    if (vm == NULL) {
        qemudReportError(dom->conn, domain, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("No such domain %s"), dom->uuid);
        goto cleanup;
    }

    if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("cannot find cgroup for domain %s"), vm->def->name);
        goto cleanup;
    }

    rc = virCgroupGetCpuShares(group, &val);
    if (rc != 0) {
        virReportSystemError(dom->conn, -rc, "%s",
                             _("unable to get cpu shares tunable"));
        goto cleanup;
    }
    params[0].value.ul = val;
    params[0].type = VIR_DOMAIN_SCHED_FIELD_ULLONG;
C
Chris Lalancette 已提交
5826 5827 5828 5829 5830
    if (virStrcpyStatic(params[0].field, "cpu_shares") == NULL) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("Field cpu_shares too long for destination"));
        goto cleanup;
    }
5831 5832 5833 5834 5835 5836 5837

    ret = 0;

cleanup:
    virCgroupFree(&group);
    if (vm)
        virDomainObjUnlock(vm);
5838
    qemuDriverUnlock(driver);
5839 5840 5841 5842
    return ret;
}


5843 5844 5845 5846 5847 5848 5849 5850 5851
/* This uses the 'info blockstats' monitor command which was
 * integrated into both qemu & kvm in late 2007.  If the command is
 * not supported we detect this and return the appropriate error.
 */
static int
qemudDomainBlockStats (virDomainPtr dom,
                       const char *path,
                       struct _virDomainBlockStats *stats)
{
5852
    struct qemud_driver *driver = dom->conn->privateData;
5853 5854
    const char *qemu_dev_name = NULL;
    int i, ret = -1;
5855
    virDomainObjPtr vm;
5856
    virDomainDiskDefPtr disk = NULL;
5857

5858
    qemuDriverLock(driver);
5859
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5860
    qemuDriverUnlock(driver);
5861
    if (!vm) {
5862 5863 5864 5865
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
5866
        goto cleanup;
5867
    }
5868
    if (!virDomainIsActive (vm)) {
5869
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
5870
                          "%s", _("domain is not running"));
5871
        goto cleanup;
5872 5873
    }

5874 5875 5876 5877 5878 5879 5880 5881
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(path, vm->def->disks[i]->dst)) {
            disk = vm->def->disks[i];
            break;
        }
    }

    if (!disk) {
5882 5883
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                          _("invalid path: %s"), path);
5884
        goto cleanup;
5885 5886
    }

5887
    qemu_dev_name = qemudDiskDeviceName(dom->conn, disk);
5888
    if (!qemu_dev_name)
5889
        goto cleanup;
5890

5891 5892 5893 5894 5895 5896
    if (qemuMonitorGetBlockStatsInfo(vm, qemu_dev_name,
                                     &stats->rd_req,
                                     &stats->rd_bytes,
                                     &stats->wr_req,
                                     &stats->wr_bytes,
                                     &stats->errs) < 0)
5897
        goto cleanup;
5898

5899
    ret = 0;
5900

5901
cleanup:
5902
    VIR_FREE(qemu_dev_name);
5903 5904
    if (vm)
        virDomainObjUnlock(vm);
5905
    return ret;
5906 5907
}

5908
#ifdef __linux__
5909 5910 5911 5912 5913
static int
qemudDomainInterfaceStats (virDomainPtr dom,
                           const char *path,
                           struct _virDomainInterfaceStats *stats)
{
5914 5915
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
5916
    int i;
5917
    int ret = -1;
5918

5919
    qemuDriverLock(driver);
5920
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5921 5922
    qemuDriverUnlock(driver);

5923
    if (!vm) {
5924 5925 5926 5927
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
5928
        goto cleanup;
5929 5930
    }

5931
    if (!virDomainIsActive(vm)) {
5932
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
5933
                         "%s", _("domain is not running"));
5934
        goto cleanup;
5935 5936 5937
    }

    /* Check the path is one of the domain's network interfaces. */
5938 5939
    for (i = 0 ; i < vm->def->nnets ; i++) {
        if (vm->def->nets[i]->ifname &&
5940 5941 5942 5943
            STREQ (vm->def->nets[i]->ifname, path)) {
            ret = 0;
            break;
        }
5944 5945
    }

5946 5947 5948 5949 5950
    if (ret == 0)
        ret = linuxDomainInterfaceStats (dom->conn, path, stats);
    else
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                          _("invalid path, '%s' is not a known interface"), path);
5951

5952
cleanup:
5953 5954
    if (vm)
        virDomainObjUnlock(vm);
5955 5956
    return ret;
}
5957
#else
5958 5959 5960 5961
static int
qemudDomainInterfaceStats (virDomainPtr dom,
                           const char *path ATTRIBUTE_UNUSED,
                           struct _virDomainInterfaceStats *stats ATTRIBUTE_UNUSED)
5962 5963 5964 5965
    qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                      "%s", __FUNCTION__);
    return -1;
}
5966
#endif
5967

5968 5969 5970 5971 5972 5973 5974
static int
qemudDomainBlockPeek (virDomainPtr dom,
                      const char *path,
                      unsigned long long offset, size_t size,
                      void *buffer,
                      unsigned int flags ATTRIBUTE_UNUSED)
{
5975 5976 5977
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int fd = -1, ret = -1, i;
5978

5979
    qemuDriverLock(driver);
5980
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5981 5982
    qemuDriverUnlock(driver);

5983
    if (!vm) {
5984 5985 5986 5987
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
5988
        goto cleanup;
5989 5990 5991 5992
    }

    if (!path || path[0] == '\0') {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
J
Jim Meyering 已提交
5993
                         "%s", _("NULL or empty path"));
5994
        goto cleanup;
5995 5996 5997
    }

    /* Check the path belongs to this domain. */
5998 5999
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (vm->def->disks[i]->src != NULL &&
6000 6001 6002 6003
            STREQ (vm->def->disks[i]->src, path)) {
            ret = 0;
            break;
        }
6004 6005
    }

6006 6007 6008 6009 6010
    if (ret == 0) {
        ret = -1;
        /* The path is correct, now try to open it and get its size. */
        fd = open (path, O_RDONLY);
        if (fd == -1) {
6011 6012
            virReportSystemError (dom->conn, errno,
                                  _("%s: failed to open"), path);
6013 6014
            goto cleanup;
        }
6015

6016 6017 6018 6019 6020 6021
        /* Seek and read. */
        /* NB. Because we configure with AC_SYS_LARGEFILE, off_t should
         * be 64 bits on all platforms.
         */
        if (lseek (fd, offset, SEEK_SET) == (off_t) -1 ||
            saferead (fd, buffer, size) == (ssize_t) -1) {
6022 6023
            virReportSystemError (dom->conn, errno,
                                  _("%s: failed to seek or read"), path);
6024 6025 6026 6027 6028 6029 6030
            goto cleanup;
        }

        ret = 0;
    } else {
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                          "%s", _("invalid path"));
6031 6032
    }

6033 6034 6035
cleanup:
    if (fd >= 0)
        close (fd);
6036 6037
    if (vm)
        virDomainObjUnlock(vm);
6038 6039 6040
    return ret;
}

R
Richard W.M. Jones 已提交
6041 6042 6043 6044 6045 6046
static int
qemudDomainMemoryPeek (virDomainPtr dom,
                       unsigned long long offset, size_t size,
                       void *buffer,
                       unsigned int flags)
{
6047 6048
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
6049
    char *tmp = NULL;
R
Richard W.M. Jones 已提交
6050 6051
    int fd = -1, ret = -1;

6052
    qemuDriverLock(driver);
6053
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
6054
    qemuDriverUnlock(driver);
R
Richard W.M. Jones 已提交
6055 6056

    if (!vm) {
6057 6058 6059 6060
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
6061 6062 6063
        goto cleanup;
    }

6064
    if (flags != VIR_MEMORY_VIRTUAL && flags != VIR_MEMORY_PHYSICAL) {
6065
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
6066
                     "%s", _("flags parameter must be VIR_MEMORY_VIRTUAL or VIR_MEMORY_PHYSICAL"));
6067
        goto cleanup;
R
Richard W.M. Jones 已提交
6068 6069
    }

6070
    if (!virDomainIsActive(vm)) {
6071
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
R
Richard W.M. Jones 已提交
6072
                         "%s", _("domain is not running"));
6073
        goto cleanup;
R
Richard W.M. Jones 已提交
6074 6075
    }

6076 6077 6078 6079 6080
    if (virAsprintf(&tmp, driver->cacheDir,  "/qemu.mem.XXXXXX") < 0) {
        virReportOOMError(dom->conn);
        goto cleanup;
    }

R
Richard W.M. Jones 已提交
6081 6082
    /* Create a temporary filename. */
    if ((fd = mkstemp (tmp)) == -1) {
6083 6084
        virReportSystemError (dom->conn, errno,
                              _("mkstemp(\"%s\") failed"), tmp);
6085
        goto cleanup;
R
Richard W.M. Jones 已提交
6086 6087
    }

6088 6089 6090 6091 6092 6093
    if (flags == VIR_MEMORY_VIRTUAL) {
        if (qemuMonitorSaveVirtualMemory(vm, offset, size, tmp) < 0)
            goto cleanup;
    } else {
        if (qemuMonitorSavePhysicalMemory(vm, offset, size, tmp) < 0)
            goto cleanup;
R
Richard W.M. Jones 已提交
6094 6095 6096 6097
    }

    /* Read the memory file into buffer. */
    if (saferead (fd, buffer, size) == (ssize_t) -1) {
6098 6099 6100
        virReportSystemError (dom->conn, errno,
                              _("failed to read temporary file "
                                "created with template %s"), tmp);
6101
        goto cleanup;
R
Richard W.M. Jones 已提交
6102 6103 6104
    }

    ret = 0;
6105 6106

cleanup:
6107
    VIR_FREE(tmp);
R
Richard W.M. Jones 已提交
6108 6109
    if (fd >= 0) close (fd);
    unlink (tmp);
6110 6111
    if (vm)
        virDomainObjUnlock(vm);
R
Richard W.M. Jones 已提交
6112 6113 6114
    return ret;
}

6115

6116 6117
static int
qemudDomainEventRegister (virConnectPtr conn,
6118
                          virConnectDomainEventCallback callback,
6119 6120
                          void *opaque,
                          virFreeCallback freecb)
6121
{
6122 6123 6124
    struct qemud_driver *driver = conn->privateData;
    int ret;

6125
    qemuDriverLock(driver);
6126 6127
    ret = virDomainEventCallbackListAdd(conn, driver->domainEventCallbacks,
                                        callback, opaque, freecb);
6128
    qemuDriverUnlock(driver);
6129

6130
    return ret;
6131 6132 6133 6134
}

static int
qemudDomainEventDeregister (virConnectPtr conn,
6135
                            virConnectDomainEventCallback callback)
6136
{
6137 6138 6139
    struct qemud_driver *driver = conn->privateData;
    int ret;

6140
    qemuDriverLock(driver);
6141 6142 6143 6144 6145 6146
    if (driver->domainEventDispatching)
        ret = virDomainEventCallbackListMarkDelete(conn, driver->domainEventCallbacks,
                                                   callback);
    else
        ret = virDomainEventCallbackListRemove(conn, driver->domainEventCallbacks,
                                               callback);
6147
    qemuDriverUnlock(driver);
6148

6149
    return ret;
6150 6151
}

6152 6153 6154 6155 6156
static void qemuDomainEventDispatchFunc(virConnectPtr conn,
                                        virDomainEventPtr event,
                                        virConnectDomainEventCallback cb,
                                        void *cbopaque,
                                        void *opaque)
6157
{
6158
    struct qemud_driver *driver = opaque;
6159

6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203
    /* Drop the lock whle dispatching, for sake of re-entrancy */
    qemuDriverUnlock(driver);
    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
    qemuDriverLock(driver);
}

static void qemuDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
{
    struct qemud_driver *driver = opaque;
    virDomainEventQueue tempQueue;

    qemuDriverLock(driver);

    driver->domainEventDispatching = 1;

    /* Copy the queue, so we're reentrant safe */
    tempQueue.count = driver->domainEventQueue->count;
    tempQueue.events = driver->domainEventQueue->events;
    driver->domainEventQueue->count = 0;
    driver->domainEventQueue->events = NULL;

    virEventUpdateTimeout(driver->domainEventTimer, -1);
    virDomainEventQueueDispatch(&tempQueue,
                                driver->domainEventCallbacks,
                                qemuDomainEventDispatchFunc,
                                driver);

    /* Purge any deleted callbacks */
    virDomainEventCallbackListPurgeMarked(driver->domainEventCallbacks);

    driver->domainEventDispatching = 0;
    qemuDriverUnlock(driver);
}


/* driver must be locked before calling */
static void qemuDomainEventQueue(struct qemud_driver *driver,
                                 virDomainEventPtr event)
{
    if (virDomainEventQueuePush(driver->domainEventQueue,
                                event) < 0)
        virDomainEventFree(event);
    if (qemu_driver->domainEventQueue->count == 1)
        virEventUpdateTimeout(driver->domainEventTimer, 0);
6204 6205
}

D
Daniel Veillard 已提交
6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223
/* Migration support. */

/* Prepare is the first step, and it runs on the destination host.
 *
 * This starts an empty VM listening on a TCP port.
 */
static int
qemudDomainMigratePrepare2 (virConnectPtr dconn,
                            char **cookie ATTRIBUTE_UNUSED,
                            int *cookielen ATTRIBUTE_UNUSED,
                            const char *uri_in,
                            char **uri_out,
                            unsigned long flags ATTRIBUTE_UNUSED,
                            const char *dname,
                            unsigned long resource ATTRIBUTE_UNUSED,
                            const char *dom_xml)
{
    static int port = 0;
6224 6225
    struct qemud_driver *driver = dconn->privateData;
    virDomainDefPtr def = NULL;
D
Daniel Veillard 已提交
6226 6227
    virDomainObjPtr vm = NULL;
    int this_port;
6228
    char *hostname;
D
Daniel Veillard 已提交
6229 6230
    char migrateFrom [64];
    const char *p;
6231
    virDomainEventPtr event = NULL;
6232
    int ret = -1;
6233
    int internalret;
6234 6235

    *uri_out = NULL;
D
Daniel Veillard 已提交
6236

6237
    qemuDriverLock(driver);
D
Daniel Veillard 已提交
6238 6239 6240
    if (!dom_xml) {
        qemudReportError (dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                          "%s", _("no domain XML passed"));
6241
        goto cleanup;
D
Daniel Veillard 已提交
6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258
    }

    /* The URI passed in may be NULL or a string "tcp://somehostname:port".
     *
     * If the URI passed in is NULL then we allocate a port number
     * from our pool of port numbers and return a URI of
     * "tcp://ourhostname:port".
     *
     * If the URI passed in is not NULL then we try to parse out the
     * port number and use that (note that the hostname is assumed
     * to be a correct hostname which refers to the target machine).
     */
    if (uri_in == NULL) {
        this_port = QEMUD_MIGRATION_FIRST_PORT + port++;
        if (port == QEMUD_MIGRATION_NUM_PORTS) port = 0;

        /* Get hostname */
6259
        if ((hostname = virGetHostname()) == NULL) {
6260 6261
            virReportSystemError (dconn, errno,
                                  "%s", _("failed to determine host name"));
6262
            goto cleanup;
D
Daniel Veillard 已提交
6263 6264
        }

6265 6266 6267 6268 6269
        /* XXX this really should have been a properly well-formed
         * URI, but we can't add in tcp:// now without breaking
         * compatability with old targets. We at least make the
         * new targets accept both syntaxes though.
         */
D
Daniel Veillard 已提交
6270
        /* Caller frees */
6271 6272 6273
        internalret = virAsprintf(uri_out, "tcp:%s:%d", hostname, this_port);
        VIR_FREE(hostname);
        if (internalret < 0) {
6274
            virReportOOMError (dconn);
6275
            goto cleanup;
D
Daniel Veillard 已提交
6276 6277 6278 6279 6280 6281
        }
    } else {
        /* Check the URI starts with "tcp:".  We will escape the
         * URI when passing it to the qemu monitor, so bad
         * characters in hostname part don't matter.
         */
6282
        if (!STRPREFIX (uri_in, "tcp:")) {
D
Daniel Veillard 已提交
6283
            qemudReportError (dconn, NULL, NULL, VIR_ERR_INVALID_ARG,
6284
                  "%s", _("only tcp URIs are supported for KVM/QEMU migrations"));
6285
            goto cleanup;
D
Daniel Veillard 已提交
6286 6287 6288 6289 6290 6291 6292 6293 6294
        }

        /* Get the port number. */
        p = strrchr (uri_in, ':');
        p++; /* definitely has a ':' in it, see above */
        this_port = virParseNumber (&p);
        if (this_port == -1 || p-uri_in != strlen (uri_in)) {
            qemudReportError (dconn, NULL, NULL, VIR_ERR_INVALID_ARG,
                              "%s", _("URI did not have ':port' at the end"));
6295
            goto cleanup;
D
Daniel Veillard 已提交
6296 6297 6298 6299
        }
    }

    /* Parse the domain XML. */
6300 6301
    if (!(def = virDomainDefParseString(dconn, driver->caps, dom_xml,
                                        VIR_DOMAIN_XML_INACTIVE))) {
D
Daniel Veillard 已提交
6302 6303
        qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("failed to parse XML"));
6304
        goto cleanup;
D
Daniel Veillard 已提交
6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320
    }

    /* Target domain name, maybe renamed. */
    dname = dname ? dname : def->name;

#if 1
    /* Ensure the name and UUID don't already exist in an active VM */
    vm = virDomainFindByUUID(&driver->domains, def->uuid);
#else
    /* For TESTING ONLY you can change #if 1 -> #if 0 above and use
     * this code which lets you do localhost migrations.  You must still
     * supply a fresh 'dname' but this code assigns a random UUID.
     */
    if (virUUIDGenerate (def->uuid) == -1) {
        qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
            _("could not generate random UUID"));
6321
        goto cleanup;
D
Daniel Veillard 已提交
6322 6323 6324 6325 6326 6327 6328 6329 6330
    }
#endif

    if (!vm) vm = virDomainFindByName(&driver->domains, dname);
    if (vm) {
        if (virDomainIsActive(vm)) {
            qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                              _("domain with the same name or UUID already exists as '%s'"),
                              vm->def->name);
6331
            goto cleanup;
D
Daniel Veillard 已提交
6332
        }
6333
        virDomainObjUnlock(vm);
D
Daniel Veillard 已提交
6334 6335 6336 6337 6338 6339 6340
    }

    if (!(vm = virDomainAssignDef(dconn,
                                  &driver->domains,
                                  def))) {
        qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("failed to assign new VM"));
6341
        goto cleanup;
D
Daniel Veillard 已提交
6342
    }
6343
    def = NULL;
D
Daniel Veillard 已提交
6344 6345 6346 6347 6348 6349 6350 6351

    /* Domain starts inactive, even if the domain XML had an id field. */
    vm->def->id = -1;

    /* Start the QEMU daemon, with the same command-line arguments plus
     * -incoming tcp:0.0.0.0:port
     */
    snprintf (migrateFrom, sizeof (migrateFrom), "tcp:0.0.0.0:%d", this_port);
6352
    if (qemudStartVMDaemon (dconn, driver, vm, migrateFrom, -1) < 0) {
6353 6354 6355
        /* Note that we don't set an error here because qemudStartVMDaemon
         * should have already done that.
         */
6356
        if (!vm->persistent) {
D
Daniel Veillard 已提交
6357
            virDomainRemoveInactive(&driver->domains, vm);
6358 6359
            vm = NULL;
        }
6360
        goto cleanup;
D
Daniel Veillard 已提交
6361
    }
6362 6363 6364 6365

    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_MIGRATED);
6366
    ret = 0;
D
Daniel Veillard 已提交
6367

6368 6369 6370 6371 6372
cleanup:
    virDomainDefFree(def);
    if (ret != 0) {
        VIR_FREE(*uri_out);
    }
6373 6374
    if (vm)
        virDomainObjUnlock(vm);
6375 6376
    if (event)
        qemuDomainEventQueue(driver, event);
6377
    qemuDriverUnlock(driver);
6378
    return ret;
D
Daniel Veillard 已提交
6379 6380 6381 6382 6383 6384 6385 6386
}

/* Perform is the second step, and it runs on the source host. */
static int
qemudDomainMigratePerform (virDomainPtr dom,
                           const char *cookie ATTRIBUTE_UNUSED,
                           int cookielen ATTRIBUTE_UNUSED,
                           const char *uri,
6387
                           unsigned long flags,
D
Daniel Veillard 已提交
6388 6389 6390
                           const char *dname ATTRIBUTE_UNUSED,
                           unsigned long resource)
{
6391 6392
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
6393
    virDomainEventPtr event = NULL;
6394
    int ret = -1;
6395
    int paused = 0;
6396
    int status;
6397
    xmlURIPtr uribits = NULL;
6398
    unsigned long long transferred, remaining, total;
D
Daniel Veillard 已提交
6399

6400
    qemuDriverLock(driver);
6401
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
D
Daniel Veillard 已提交
6402
    if (!vm) {
6403 6404 6405 6406
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching uuid '%s'"), uuidstr);
6407
        goto cleanup;
D
Daniel Veillard 已提交
6408 6409 6410
    }

    if (!virDomainIsActive(vm)) {
6411
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
D
Daniel Veillard 已提交
6412
                          "%s", _("domain is not running"));
6413
        goto cleanup;
D
Daniel Veillard 已提交
6414 6415
    }

6416 6417
    if (!(flags & VIR_MIGRATE_LIVE)) {
        /* Pause domain for non-live migration */
6418
        if (qemuMonitorStopCPUs(vm) < 0)
6419 6420
            goto cleanup;
        paused = 1;
6421

6422 6423 6424 6425 6426 6427
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_SUSPENDED,
                                         VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED);
        if (event)
            qemuDomainEventQueue(driver, event);
        event = NULL;
6428 6429
    }

6430 6431 6432
    if (resource > 0 &&
        qemuMonitorSetMigrationSpeed(vm, resource) < 0)
        goto cleanup;
D
Daniel Veillard 已提交
6433 6434

    /* Issue the migrate command. */
6435
    if (STRPREFIX(uri, "tcp:") && !STRPREFIX(uri, "tcp://")) {
6436
        /* HACK: source host generates bogus URIs, so fix them up */
6437 6438 6439 6440 6441 6442 6443 6444 6445
        char *tmpuri;
        if (virAsprintf(&tmpuri, "tcp://%s", uri + strlen("tcp:")) < 0) {
            virReportOOMError(dom->conn);
            goto cleanup;
        }
        uribits = xmlParseURI(tmpuri);
        VIR_FREE(tmpuri);
    } else {
        uribits = xmlParseURI(uri);
D
Daniel Veillard 已提交
6446
    }
6447 6448 6449
    if (!uribits) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("cannot parse URI %s"), uri);
6450
        goto cleanup;
D
Daniel Veillard 已提交
6451 6452
    }

6453
    if (qemuMonitorMigrateToHost(vm, uribits->server, uribits->port) < 0)
6454
        goto cleanup;
D
Daniel Veillard 已提交
6455

6456 6457 6458
    /* it is also possible that the migrate didn't fail initially, but
     * rather failed later on.  Check the output of "info migrate"
     */
6459 6460 6461 6462
    if (qemuMonitorGetMigrationStatus(vm, &status,
                                      &transferred,
                                      &remaining,
                                      &total) < 0) {
6463 6464
        goto cleanup;
    }
6465 6466

    if (status != QEMU_MONITOR_MIGRATION_STATUS_COMPLETED) {
6467
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
6468
                          "%s", _("migrate did not successfully complete"));
6469 6470 6471
        goto cleanup;
    }

D
Daniel Veillard 已提交
6472 6473
    /* Clean up the source domain. */
    qemudShutdownVMDaemon (dom->conn, driver, vm);
6474
    paused = 0;
6475 6476 6477 6478

    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_MIGRATED);
6479
    if (!vm->persistent) {
D
Daniel Veillard 已提交
6480
        virDomainRemoveInactive(&driver->domains, vm);
6481 6482
        vm = NULL;
    }
6483
    ret = 0;
D
Daniel Veillard 已提交
6484

6485
cleanup:
6486 6487
    if (paused) {
        /* we got here through some sort of failure; start the domain again */
6488
        if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
6489 6490 6491 6492
            /* Hm, we already know we are in error here.  We don't want to
             * overwrite the previous error, though, so we just throw something
             * to the logs and hope for the best
             */
6493 6494
            VIR_ERROR(_("Failed to resume guest %s after failure\n"),
                      vm->def->name);
6495 6496 6497 6498 6499 6500 6501
        }

        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
    }

6502 6503
    if (uribits)
        xmlFreeURI(uribits);
6504 6505
    if (vm)
        virDomainObjUnlock(vm);
6506 6507
    if (event)
        qemuDomainEventQueue(driver, event);
6508
    qemuDriverUnlock(driver);
6509
    return ret;
D
Daniel Veillard 已提交
6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521
}

/* Finish is the third and final step, and it runs on the destination host. */
static virDomainPtr
qemudDomainMigrateFinish2 (virConnectPtr dconn,
                           const char *dname,
                           const char *cookie ATTRIBUTE_UNUSED,
                           int cookielen ATTRIBUTE_UNUSED,
                           const char *uri ATTRIBUTE_UNUSED,
                           unsigned long flags ATTRIBUTE_UNUSED,
                           int retcode)
{
6522 6523 6524
    struct qemud_driver *driver = dconn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
6525
    virDomainEventPtr event = NULL;
D
Daniel Veillard 已提交
6526

6527
    qemuDriverLock(driver);
6528
    vm = virDomainFindByName(&driver->domains, dname);
D
Daniel Veillard 已提交
6529
    if (!vm) {
6530 6531
        qemudReportError (dconn, NULL, NULL, VIR_ERR_NO_DOMAIN,
                          _("no domain with matching name '%s'"), dname);
6532
        goto cleanup;
D
Daniel Veillard 已提交
6533 6534 6535 6536 6537 6538 6539
    }

    /* Did the migration go as planned?  If yes, return the domain
     * object, but if no, clean up the empty qemu process.
     */
    if (retcode == 0) {
        dom = virGetDomain (dconn, vm->def->name, vm->def->uuid);
6540 6541 6542 6543 6544

        /* run 'cont' on the destination, which allows migration on qemu
         * >= 0.10.6 to work properly.  This isn't strictly necessary on
         * older qemu's, but it also doesn't hurt anything there
         */
6545
        if (qemuMonitorStartCPUs(dconn, vm) < 0) {
6546 6547 6548
            if (virGetLastError() == NULL)
                qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 "%s", _("resume operation failed"));
6549 6550 6551
            goto cleanup;
        }

D
Daniel Veillard 已提交
6552
        vm->state = VIR_DOMAIN_RUNNING;
6553 6554 6555
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
D
Daniel Veillard 已提交
6556
        virDomainSaveStatus(dconn, driver->stateDir, vm);
D
Daniel Veillard 已提交
6557 6558
    } else {
        qemudShutdownVMDaemon (dconn, driver, vm);
6559 6560 6561
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STOPPED,
                                         VIR_DOMAIN_EVENT_STOPPED_FAILED);
6562
        if (!vm->persistent) {
D
Daniel Veillard 已提交
6563
            virDomainRemoveInactive(&driver->domains, vm);
6564 6565
            vm = NULL;
        }
D
Daniel Veillard 已提交
6566
    }
6567 6568

cleanup:
6569 6570
    if (vm)
        virDomainObjUnlock(vm);
6571 6572
    if (event)
        qemuDomainEventQueue(driver, event);
6573
    qemuDriverUnlock(driver);
6574
    return dom;
D
Daniel Veillard 已提交
6575 6576
}

6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592
static int
qemudNodeDeviceGetPciInfo (virNodeDevicePtr dev,
                           unsigned *domain,
                           unsigned *bus,
                           unsigned *slot,
                           unsigned *function)
{
    virNodeDeviceDefPtr def = NULL;
    virNodeDevCapsDefPtr cap;
    char *xml = NULL;
    int ret = -1;

    xml = virNodeDeviceGetXMLDesc(dev, 0);
    if (!xml)
        goto out;

6593
    def = virNodeDeviceDefParseString(dev->conn, xml, EXISTING_DEVICE);
6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671
    if (!def)
        goto out;

    cap = def->caps;
    while (cap) {
        if (cap->type == VIR_NODE_DEV_CAP_PCI_DEV) {
            *domain   = cap->data.pci_dev.domain;
            *bus      = cap->data.pci_dev.bus;
            *slot     = cap->data.pci_dev.slot;
            *function = cap->data.pci_dev.function;
            break;
        }

        cap = cap->next;
    }

    if (!cap) {
        qemudReportError(dev->conn, NULL, NULL, VIR_ERR_INVALID_ARG,
                         _("device %s is not a PCI device"), dev->name);
        goto out;
    }

    ret = 0;
out:
    virNodeDeviceDefFree(def);
    VIR_FREE(xml);
    return ret;
}

static int
qemudNodeDeviceDettach (virNodeDevicePtr dev)
{
    pciDevice *pci;
    unsigned domain, bus, slot, function;
    int ret = -1;

    if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
        return -1;

    pci = pciGetDevice(dev->conn, domain, bus, slot, function);
    if (!pci)
        return -1;

    if (pciDettachDevice(dev->conn, pci) < 0)
        goto out;

    ret = 0;
out:
    pciFreeDevice(dev->conn, pci);
    return ret;
}

static int
qemudNodeDeviceReAttach (virNodeDevicePtr dev)
{
    pciDevice *pci;
    unsigned domain, bus, slot, function;
    int ret = -1;

    if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
        return -1;

    pci = pciGetDevice(dev->conn, domain, bus, slot, function);
    if (!pci)
        return -1;

    if (pciReAttachDevice(dev->conn, pci) < 0)
        goto out;

    ret = 0;
out:
    pciFreeDevice(dev->conn, pci);
    return ret;
}

static int
qemudNodeDeviceReset (virNodeDevicePtr dev)
{
6672
    struct qemud_driver *driver = dev->conn->privateData;
6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683
    pciDevice *pci;
    unsigned domain, bus, slot, function;
    int ret = -1;

    if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
        return -1;

    pci = pciGetDevice(dev->conn, domain, bus, slot, function);
    if (!pci)
        return -1;

6684 6685 6686
    qemuDriverLock(driver);

    if (pciResetDevice(dev->conn, pci, driver->activePciHostdevs) < 0)
6687 6688 6689 6690
        goto out;

    ret = 0;
out:
6691
    qemuDriverUnlock(driver);
6692 6693 6694 6695
    pciFreeDevice(dev->conn, pci);
    return ret;
}

6696 6697 6698 6699 6700
static virDriver qemuDriver = {
    VIR_DRV_QEMU,
    "QEMU",
    qemudOpen, /* open */
    qemudClose, /* close */
D
Daniel Veillard 已提交
6701
    qemudSupportsFeature, /* supports_feature */
6702 6703
    qemudGetType, /* type */
    qemudGetVersion, /* version */
6704
    qemudGetHostname, /* getHostname */
6705
    qemudGetMaxVCPUs, /* getMaxVcpus */
6706
    nodeGetInfo, /* nodeGetInfo */
6707 6708 6709
    qemudGetCapabilities, /* getCapabilities */
    qemudListDomains, /* listDomains */
    qemudNumDomains, /* numOfDomains */
6710
    qemudDomainCreate, /* domainCreateXML */
6711 6712 6713 6714 6715
    qemudDomainLookupByID, /* domainLookupByID */
    qemudDomainLookupByUUID, /* domainLookupByUUID */
    qemudDomainLookupByName, /* domainLookupByName */
    qemudDomainSuspend, /* domainSuspend */
    qemudDomainResume, /* domainResume */
6716
    qemudDomainShutdown, /* domainShutdown */
6717 6718 6719
    NULL, /* domainReboot */
    qemudDomainDestroy, /* domainDestroy */
    qemudDomainGetOSType, /* domainGetOSType */
6720 6721 6722
    qemudDomainGetMaxMemory, /* domainGetMaxMemory */
    qemudDomainSetMaxMemory, /* domainSetMaxMemory */
    qemudDomainSetMemory, /* domainSetMemory */
6723 6724 6725
    qemudDomainGetInfo, /* domainGetInfo */
    qemudDomainSave, /* domainSave */
    qemudDomainRestore, /* domainRestore */
P
Paolo Bonzini 已提交
6726
    qemudDomainCoreDump, /* domainCoreDump */
6727
    qemudDomainSetVcpus, /* domainSetVcpus */
6728 6729 6730 6731
#if HAVE_SCHED_GETAFFINITY
    qemudDomainPinVcpu, /* domainPinVcpu */
    qemudDomainGetVcpus, /* domainGetVcpus */
#else
6732 6733
    NULL, /* domainPinVcpu */
    NULL, /* domainGetVcpus */
6734
#endif
6735
    qemudDomainGetMaxVcpus, /* domainGetMaxVcpus */
6736 6737
    qemudDomainGetSecurityLabel, /* domainGetSecurityLabel */
    qemudNodeGetSecurityModel, /* nodeGetSecurityModel */
6738
    qemudDomainDumpXML, /* domainDumpXML */
6739
    qemuDomainXMLFromNative, /* domainXmlFromNative */
6740
    qemuDomainXMLToNative, /* domainXMLToNative */
6741 6742
    qemudListDefinedDomains, /* listDefinedDomains */
    qemudNumDefinedDomains, /* numOfDefinedDomains */
6743 6744 6745
    qemudDomainStart, /* domainCreate */
    qemudDomainDefine, /* domainDefineXML */
    qemudDomainUndefine, /* domainUndefine */
6746
    qemudDomainAttachDevice, /* domainAttachDevice */
6747
    qemudDomainDetachDevice, /* domainDetachDevice */
6748 6749
    qemudDomainGetAutostart, /* domainGetAutostart */
    qemudDomainSetAutostart, /* domainSetAutostart */
6750 6751 6752
    qemuGetSchedulerType, /* domainGetSchedulerType */
    qemuGetSchedulerParameters, /* domainGetSchedulerParameters */
    qemuSetSchedulerParameters, /* domainSetSchedulerParameters */
D
Daniel Veillard 已提交
6753 6754
    NULL, /* domainMigratePrepare (v1) */
    qemudDomainMigratePerform, /* domainMigratePerform */
6755
    NULL, /* domainMigrateFinish */
6756
    qemudDomainBlockStats, /* domainBlockStats */
6757
    qemudDomainInterfaceStats, /* domainInterfaceStats */
6758
    qemudDomainBlockPeek, /* domainBlockPeek */
R
Richard W.M. Jones 已提交
6759
    qemudDomainMemoryPeek, /* domainMemoryPeek */
6760 6761
    nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
    nodeGetFreeMemory,  /* getFreeMemory */
6762 6763
    qemudDomainEventRegister, /* domainEventRegister */
    qemudDomainEventDeregister, /* domainEventDeregister */
D
Daniel Veillard 已提交
6764 6765
    qemudDomainMigratePrepare2, /* domainMigratePrepare2 */
    qemudDomainMigrateFinish2, /* domainMigrateFinish2 */
6766 6767 6768
    qemudNodeDeviceDettach, /* nodeDeviceDettach */
    qemudNodeDeviceReAttach, /* nodeDeviceReAttach */
    qemudNodeDeviceReset, /* nodeDeviceReset */
6769 6770 6771
};


6772
static virStateDriver qemuStateDriver = {
6773 6774 6775 6776
    .initialize = qemudStartup,
    .cleanup = qemudShutdown,
    .reload = qemudReload,
    .active = qemudActive,
6777
};
6778

6779
int qemuRegister(void) {
6780 6781 6782 6783
    virRegisterDriver(&qemuDriver);
    virRegisterStateDriver(&qemuStateDriver);
    return 0;
}