qemu_driver.c 217.3 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 112
static int qemudDomainSetMemoryBalloon(virConnectPtr conn,
                                       virDomainObjPtr vm,
                                       unsigned long newmem);
113 114
static int qemuDetectVcpuPIDs(virConnectPtr conn,
                              virDomainObjPtr vm);
115

116 117 118
static int qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
                                       virDomainDefPtr def);

J
Jim Meyering 已提交
119
static struct qemud_driver *qemu_driver = NULL;
120

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

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

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

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

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


168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
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) {
185 186 187
        virReportSystemError(conn, errno,
                             _("failed to create logfile %s"),
                             logfile);
188 189
        return -1;
    }
190
    if (virSetCloseExec(fd) < 0) {
191 192
        virReportSystemError(conn, errno, "%s",
                             _("Unable to set VM logfile close-on-exec flag"));
193 194 195 196
        close(fd);
        return -1;
    }
    if (lseek(fd, pos, SEEK_SET) < 0) {
197 198 199
        virReportSystemError(conn, errno,
                             _("Unable to seek to %lld in %s"),
                             (long long) pos, logfile);
200 201 202 203 204 205
        close(fd);
    }
    return fd;
}


206 207 208
static void
qemudAutostartConfigs(struct qemud_driver *driver) {
    unsigned int i;
209 210 211 212 213
    /* 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
     */
214 215 216
    virConnectPtr conn = virConnectOpen(driver->privileged ?
                                        "qemu:///system" :
                                        "qemu:///session");
217
    /* Ignoring NULL conn which is mostly harmless here */
218

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

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

247 248
    if (conn)
        virConnectClose(conn);
249 250
}

251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267

/**
 * 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) {
268
        virReportOOMError(conn);
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
        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;
}


288 289 290 291 292
static int qemudOpenMonitor(virConnectPtr conn,
                            struct qemud_driver* driver,
                            virDomainObjPtr vm,
                            int reconnect);

293 294 295 296

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

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

310 311 312 313
    if (qemuUpdateActivePciHostdevs(driver, obj->def) < 0) {
        goto error;
    }

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

320 321
    if (obj->def->id >= driver->nextvmid)
        driver->nextvmid = obj->def->id + 1;
322

323
    return 0;
324

325 326 327
error:
    return -1;
}
328

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

340 341 342 343 344 345 346 347 348
    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);
349
        }
350
        virDomainObjUnlock(obj);
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 384 385 386

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


387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
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;

407
    VIR_INFO("Initialized security driver %s", security_drv->name);
408 409 410 411 412

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


417

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

429
    if (VIR_ALLOC(qemu_driver) < 0)
430 431
        return -1;

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

440 441 442
    /* Don't have a dom0 so start from 1 */
    qemu_driver->nextvmid = 1;

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

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

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

D
Daniel P. Berrange 已提交
458
        if ((base = strdup (SYSCONF_DIR "/libvirt")) == NULL)
459
            goto out_of_memory;
460 461

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

        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;
472
    } else {
473
        uid_t uid = geteuid();
474 475
        char *userdir = virGetUserDirectory(NULL, uid);
        if (!userdir)
476
            goto error;
477

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

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

        if (virAsprintf(&qemu_driver->stateDir, "%s/qemu/run", base) == -1)
            goto out_of_memory;
492 493 494 495
        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;
496 497 498
    }

    if (virFileMakePath(qemu_driver->stateDir) < 0) {
499
        char ebuf[1024];
500 501
        VIR_ERROR(_("Failed to create state dir '%s': %s\n"),
                  qemu_driver->stateDir, virStrerror(errno, ebuf, sizeof ebuf));
502
        goto error;
503
    }
504 505 506 507 508 509 510 511 512 513 514 515
    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;
    }
516 517 518 519

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

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

527
    if (virAsprintf(&qemu_driver->autostartDir, "%s/qemu/autostart", base) == -1)
528 529
        goto out_of_memory;

530
    VIR_FREE(base);
531

532 533 534 535 536 537 538
    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)));
    }

539
    if ((qemu_driver->caps = qemudCapsInit(NULL)) == NULL)
540
        goto out_of_memory;
D
Daniel P. Berrange 已提交
541

542 543 544
    if ((qemu_driver->activePciHostdevs = pciDeviceListNew(NULL)) == NULL)
        goto error;

545
    if (qemudLoadDriverConfig(qemu_driver, driverConf) < 0) {
546 547 548
        goto error;
    }

549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
    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;
        }
    }

564
    if (qemudSecurityInit(qemu_driver) < 0) {
565
        goto error;
D
Daniel P. Berrange 已提交
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 596 597 598
    /* 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;
    }

599 600 601 602 603 604 605 606 607 608 609 610
    /* 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 */
611 612 613 614
    if (virDomainLoadAllConfigs(NULL,
                                qemu_driver->caps,
                                &qemu_driver->domains,
                                qemu_driver->configDir,
615
                                qemu_driver->autostartDir,
616
                                0, NULL, NULL) < 0)
617
        goto error;
618 619
    qemuDriverUnlock(qemu_driver);

620 621
    qemudAutostartConfigs(qemu_driver);

622

623 624
    return 0;

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

635 636 637 638
static void qemudNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
{
    struct qemud_driver *driver = opaque;

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

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

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

669
    qemudAutostartConfigs(qemu_driver);
670 671

    return 0;
672 673
}

674 675 676 677 678 679 680 681 682 683
/**
 * 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) {
684
    unsigned int i;
685
    int active = 0;
686

687 688 689
    if (!qemu_driver)
        return 0;

690 691 692 693 694 695 696 697
    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);
    }
698

699 700
    qemuDriverUnlock(qemu_driver);
    return active;
701 702
}

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

711
    if (!qemu_driver)
712
        return -1;
713

714
    qemuDriverLock(qemu_driver);
715
    pciDeviceListFree(NULL, qemu_driver->activePciHostdevs);
716 717
    virCapabilitiesFree(qemu_driver->caps);

718
    virDomainObjListFree(&qemu_driver->domains);
719

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

735 736
    /* Free domain callback list */
    virDomainEventCallbackListFree(qemu_driver->domainEventCallbacks);
737 738 739 740
    virDomainEventQueueFree(qemu_driver->domainEventQueue);

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

742 743 744
    if (qemu_driver->brctl)
        brShutdown(qemu_driver->brctl);

745 746
    virCgroupFree(&qemu_driver->cgroup);

747
    qemuDriverUnlock(qemu_driver);
748
    virMutexDestroy(&qemu_driver->lock);
749
    VIR_FREE(qemu_driver);
750 751

    return 0;
752 753 754
}

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

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

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

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

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

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

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

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

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

}

837 838 839 840 841 842 843 844 845

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

    while (retries) {
856
        ssize_t func_ret, ret;
857
        int isdead = 0;
G
Guido Günther 已提交
858

859 860
        func_ret = func(conn, vm, buf, fd);

861 862
        if (kill(vm->pid, 0) == -1 && errno == ESRCH)
            isdead = 1;
863

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

874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
        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;
        }

890 891
        if (func_ret <= 0)
            return func_ret;
892 893 894 895 896 897 898 899 900 901

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

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

    vm->monitor = fd;

    return 0;
}

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

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

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

    if (ret != 0)
952
        return ret;
953

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

960 961
    return 0;
}
962

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

    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 已提交
983 984 985 986 987
    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;
    }
988

989 990 991 992 993 994
    do {
        ret = connect(monfd, (struct sockaddr *) &addr, sizeof(addr));

        if (ret == 0)
            break;

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

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

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

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

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

    return 0;

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

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

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
    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:
1044
    close(monfd);
1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
    return -1;
}

static int
qemudOpenMonitor(virConnectPtr conn,
                 struct qemud_driver *driver,
                 virDomainObjPtr vm,
                 int reconnect)
{
    switch (vm->monitor_chr->type) {
1055 1056 1057 1058
    case VIR_DOMAIN_CHR_TYPE_UNIX:
        return qemudOpenMonitorUnix(conn, driver, vm,
                                    vm->monitor_chr->data.nix.path,
                                    reconnect);
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
    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;
    }
1069 1070
}

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

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

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

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

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

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

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

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

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

1150
    return 0;
1151 1152
}

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

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

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

1175 1176 1177 1178 1179 1180
    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;
    }
1181

1182 1183 1184 1185
    if (qemudOpenMonitor(conn, driver, vm, 0) < 0)
        return -1;

    return 0;
1186 1187
}

1188
static int
1189 1190 1191 1192
qemuDetectVcpuPIDs(virConnectPtr conn,
                   virDomainObjPtr vm) {
    pid_t *cpupids = NULL;
    int ncpupids;
1193

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

1204
    /* What follows is now all KVM specific */
1205

1206 1207
    if ((ncpupids = qemuMonitorGetCPUInfo(vm, &cpupids)) < 0)
        return -1;
1208

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

1213 1214 1215 1216 1217 1218 1219
    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;
    }
1220

1221 1222
    vm->nvcpupids = ncpupids;
    vm->vcpupids = cpupids;
1223 1224 1225
    return 0;
}

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

1235
    if (nodeGetInfo(conn, &nodeinfo) < 0)
1236 1237 1238 1239 1240 1241 1242 1243
        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 已提交
1244 1245 1246 1247 1248 1249
    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++)
1250
            CPU_SET(i, &mask);
D
Daniel P. Berrange 已提交
1251
    }
1252 1253 1254 1255

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

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

    return 0;
}


1277
static int
1278 1279
qemuInitPasswords(struct qemud_driver *driver,
                  virDomainObjPtr vm) {
1280
    int ret = 0;
1281

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

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

1292
    return ret;
1293 1294 1295
}


1296
static int qemudNextFreeVNCPort(struct qemud_driver *driver ATTRIBUTE_UNUSED) {
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 1329 1330 1331
    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;
}

1332 1333 1334 1335 1336
static pciDeviceList *
qemuGetPciHostDeviceList(virConnectPtr conn,
                         virDomainDefPtr def)
{
    pciDeviceList *list;
1337 1338
    int i;

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

    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);
1356 1357 1358 1359
        if (!dev) {
            pciDeviceListFree(conn, list);
            return NULL;
        }
1360

1361
        if (pciDeviceListAdd(conn, list, dev) < 0) {
1362
            pciFreeDevice(conn, dev);
1363 1364
            pciDeviceListFree(conn, list);
            return NULL;
1365 1366
        }

1367
        pciDeviceSetManaged(dev, hostdev->managed);
1368 1369
    }

1370 1371 1372 1373
    return list;
}

static int
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 1403 1404 1405
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)
1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
{
    pciDeviceList *pcidevs;
    int i;

    if (!def->nhostdevs)
        return 0;

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

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

    /* 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++)
1436 1437
        if (pciResetDevice(conn, pcidevs->devs[i],
                           driver->activePciHostdevs) < 0)
1438 1439
            goto error;

1440 1441 1442 1443 1444 1445 1446 1447 1448
    /* 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;
    }

1449
    pciDeviceListFree(conn, pcidevs);
1450 1451 1452
    return 0;

error:
1453
    pciDeviceListFree(conn, pcidevs);
1454 1455 1456
    return -1;
}

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

1465 1466
    if (!def->nhostdevs)
        return;
1467

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

1476 1477
    /* Again 3 loops; mark all devices as inactive before reset
     * them and reset all the devices before re-attach */
1478

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

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

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

1500
    pciDeviceListFree(conn, pcidevs);
1501 1502
}

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
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

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

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

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

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

1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
        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;
            }
        }
1563

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

1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
        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;
            }
1590 1591 1592 1593
        }
    }

done:
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 1660 1661 1662
    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;
}


1663 1664 1665 1666 1667 1668 1669 1670 1671
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;
}

1672 1673

#ifdef __linux__
1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684
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;

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

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

    return 0;
}

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

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

1707 1708 1709 1710 1711 1712 1713 1714 1715
    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);
1716

1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
    usbFreeDevice(conn, dev);
cleanup:
    return ret;
}

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

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

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

    return 0;
}

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

1745 1746 1747 1748 1749
    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);
1750

1751
    if (!dev)
1752 1753
        goto cleanup;

1754 1755
    ret = pciDeviceFileIterate(conn, dev,
                               qemuDomainSetHostdevPCIOwnershipActor, &owner);
1756

1757
    pciFreeDevice(conn, dev);
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 1786 1787 1788
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

}

1789 1790
static int qemuDomainSetFileOwnership(virConnectPtr conn,
                                      const char *path,
1791 1792 1793
                                      uid_t uid, gid_t gid)
{

1794
    if (!path)
1795 1796
        return 0;

1797 1798
    VIR_DEBUG("Setting ownership on %s to %d:%d", path, uid, gid);
    if (chown(path, uid, gid) < 0) {
1799
        virReportSystemError(conn, errno, _("cannot set ownership on %s"),
1800
                             path);
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 1827 1828 1829
        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;

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

    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;

1858 1859 1860 1861
    if (qemuDomainSetFileOwnership(conn, def->os.kernel, uid, gid) < 0 ||
        qemuDomainSetFileOwnership(conn, def->os.initrd, uid, gid) < 0)
        return -1;

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

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

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

    return 0;
}

1879 1880 1881
static virDomainPtr qemudDomainLookupByName(virConnectPtr conn,
                                            const char *name);

1882 1883 1884 1885
struct qemudHookData {
    virConnectPtr conn;
    virDomainObjPtr vm;
    struct qemud_driver *driver;
1886 1887 1888
};

static int qemudSecurityHook(void *data) {
1889 1890 1891 1892
    struct qemudHookData *h = data;

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

1894
    if (qemudDomainSetSecurityLabel(h->conn, h->driver, h->vm) < 0)
1895 1896 1897 1898 1899
        return -1;

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

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

1903 1904 1905 1906 1907
        if (h->driver->group) {
            if (setregid(h->driver->group, h->driver->group) < 0) {
                virReportSystemError(NULL, errno,
                                     _("cannot change to '%d' group"),
                                     h->driver->group);
1908
                return -1;
1909
            }
1910
        }
1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
        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;
1922 1923
}

1924 1925 1926 1927 1928 1929 1930 1931 1932 1933
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",
1934
                    driver->libDir, vm) < 0) {
1935 1936 1937 1938 1939 1940 1941
        virReportOOMError(conn);
        return -1;
    }

    return 0;
}

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

1962
    struct qemudHookData hookData;
1963 1964 1965 1966
    hookData.conn = conn;
    hookData.vm = vm;
    hookData.driver = driver;

1967
    FD_ZERO(&keepfd);
1968

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

1975 1976 1977 1978 1979 1980 1981 1982
    /* 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;

1983 1984 1985
    /* Ensure no historical cgroup for this VM is lieing around bogus settings */
    qemuRemoveCgroup(conn, driver, vm);

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

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

2005
    if ((logfile = qemudLogFD(conn, driver, vm->def->name)) < 0)
2006
        goto cleanup;
2007

2008 2009
    emulator = vm->def->emulator;

2010 2011 2012 2013
    /* 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
     */
2014
    if (stat(emulator, &sb) < 0) {
2015 2016 2017
        virReportSystemError(conn, errno,
                             _("Cannot find QEMU binary %s"),
                             emulator);
2018
        goto cleanup;
2019 2020
    }

2021
    if (qemudExtractVersionInfo(emulator,
2022
                                NULL,
2023
                                &qemuCmdFlags) < 0)
2024
        goto cleanup;
2025

2026 2027 2028
    if (qemuSetupCgroup(conn, driver, vm) < 0)
        goto cleanup;

2029
    if (qemuPrepareHostDevices(conn, driver, vm->def) < 0)
2030
        goto cleanup;
2031

2032 2033 2034 2035 2036
    if (VIR_ALLOC(vm->monitor_chr) < 0) {
        virReportOOMError(conn);
        goto cleanup;
    }

2037 2038
    if (qemuPrepareMonitorChr(conn, driver, vm->monitor_chr, vm->def->name) < 0)
        goto cleanup;
2039

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

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

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

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

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

2087 2088 2089
    for (i = 0 ; i < ntapfds ; i++)
        FD_SET(tapfds[i], &keepfd);

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

    /* wait for qemu process to to show up */
    if (ret == 0) {
2099
        if (virFileReadPid(driver->stateDir, vm->def->name, &vm->pid)) {
2100
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
2101
                             _("Domain %s didn't show up\n"), vm->def->name);
2102
            ret = -1;
G
Guido Günther 已提交
2103
        }
2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
    } 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;
    }
2115 2116

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

2118
    for (i = 0 ; argv[i] ; i++)
2119 2120
        VIR_FREE(argv[i]);
    VIR_FREE(argv);
2121

2122 2123 2124 2125
    for (i = 0 ; progenv[i] ; i++)
        VIR_FREE(progenv[i]);
    VIR_FREE(progenv);

2126 2127 2128
    if (tapfds) {
        for (i = 0 ; i < ntapfds ; i++) {
            close(tapfds[i]);
2129
        }
2130
        VIR_FREE(tapfds);
2131 2132
    }

2133 2134 2135 2136
    if (ret == -1)
        goto cleanup;

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

2147 2148 2149
    if (logfile != -1)
        close(logfile);

2150
    return ret;
2151 2152 2153 2154 2155 2156 2157

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);
    }
2158
    qemuRemoveCgroup(conn, driver, vm);
2159 2160 2161 2162
    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;
2163 2164
    if (logfile != -1)
        close(logfile);
2165 2166
    vm->def->id = -1;
    return -1;
2167 2168 2169
}


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

2176
    if (!virDomainIsActive(vm))
2177
        return;
2178

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

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

2187 2188 2189
    if (vm->monitorWatch != -1) {
        virEventRemoveHandle(vm->monitorWatch);
        vm->monitorWatch = -1;
2190
    }
2191 2192 2193 2194 2195

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

2196 2197 2198 2199 2200 2201 2202
    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 已提交
2203 2204
    /* shut it off for sure */
    virKillProcess(vm->pid, SIGKILL);
2205

2206 2207 2208 2209
    /* Reset Security Labels */
    if (driver->securityDriver)
        driver->securityDriver->domainRestoreSecurityLabel(conn, vm);

2210 2211 2212 2213 2214 2215 2216
    /* 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);
    }

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

2221
    qemuDomainReAttachHostDevices(conn, driver, vm->def);
2222

2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
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);
    }

2233
    if (qemudRemoveDomainStatus(conn, driver, vm) < 0) {
2234
        VIR_WARN(_("Failed to remove domain status for %s"),
2235 2236
                 vm->def->name);
    }
D
Daniel P. Berrange 已提交
2237 2238 2239 2240 2241 2242
    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));
    }

2243
    vm->pid = -1;
2244
    vm->def->id = -1;
2245
    vm->state = VIR_DOMAIN_SHUTOFF;
2246
    VIR_FREE(vm->vcpupids);
2247
    vm->nvcpupids = 0;
2248 2249

    if (vm->newDef) {
2250
        virDomainDefFree(vm->def);
2251
        vm->def = vm->newDef;
2252
        vm->def->id = -1;
2253 2254 2255 2256 2257
        vm->newDef = NULL;
    }
}


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

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

    if (!vm)
2279
        goto cleanup;
2280

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

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

cleanup:
    if (vm)
        virDomainObjUnlock(vm);
2310 2311
    if (event)
        qemuDomainEventQueue(driver, event);
2312
    qemuDriverUnlock(driver);
2313 2314
}

2315

2316

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

2324
        conn->uri = xmlParseURI(qemu_driver->privileged ?
2325 2326
                                "qemu:///system" :
                                "qemu:///session");
2327
        if (!conn->uri) {
2328
            virReportOOMError(conn);
2329 2330
            return VIR_DRV_OPEN_ERROR;
        }
2331 2332 2333 2334 2335 2336 2337 2338 2339 2340
    } 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;

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

2347
        if (qemu_driver->privileged) {
2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
            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;
            }
        }
2363 2364 2365 2366 2367 2368 2369
    }
    conn->privateData = qemu_driver;

    return VIR_DRV_OPEN_SUCCESS;
}

static int qemudClose(virConnectPtr conn) {
2370
    struct qemud_driver *driver = conn->privateData;
2371 2372

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

    conn->privateData = NULL;

    return 0;
}

D
Daniel Veillard 已提交
2382 2383 2384 2385 2386 2387 2388 2389 2390 2391
/* 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;
    }
}

2392
static const char *qemudGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
2393
    return "QEMU";
2394 2395
}

2396 2397 2398 2399 2400

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

    int r, fd;
2401

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

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

    close(fd);
    return maxvcpus;
}


2417
static int qemudGetMaxVCPUs(virConnectPtr conn, const char *type) {
2418 2419 2420
    if (!type)
        return 16;

2421
    if (STRCASEEQ(type, "qemu"))
2422 2423
        return 16;

2424
    if (STRCASEEQ(type, "kvm"))
2425
        return kvmGetMaxVCPUs();
2426

2427
    if (STRCASEEQ(type, "kqemu"))
2428
        return 1;
2429 2430 2431

    qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_ARG,
                     _("unknown type '%s'"), type);
2432 2433 2434
    return -1;
}

2435

2436
static char *qemudGetCapabilities(virConnectPtr conn) {
2437
    struct qemud_driver *driver = conn->privateData;
2438
    virCapsPtr caps;
2439
    char *xml = NULL;
2440

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

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

2454
    virCapabilitiesFree(qemu_driver->caps);
2455 2456 2457
    qemu_driver->caps = caps;

    if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
2458
        virReportOOMError(conn);
2459 2460

cleanup:
2461
    qemuDriverUnlock(driver);
2462

2463
    return xml;
2464 2465 2466
}


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

2474 2475 2476 2477 2478 2479
    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 已提交
2480 2481 2482 2483
        return -1;
    }

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

2493 2494 2495 2496 2497 2498 2499 2500 2501 2502
    /* 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) {
2503
        fclose(pidinfo);
2504 2505
        VIR_WARN0("cannot parse process status data");
        errno = -EINVAL;
D
Daniel P. Berrange 已提交
2506 2507 2508 2509 2510 2511 2512 2513
        return -1;
    }

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

D
Daniel P. Berrange 已提交
2519

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

    fclose(pidinfo);

    return 0;
}


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

2535
    qemuDriverLock(driver);
2536
    vm  = virDomainFindByID(&driver->domains, id);
2537
    qemuDriverUnlock(driver);
2538 2539

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

2545
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
2546
    if (dom) dom->id = vm->def->id;
2547 2548

cleanup:
2549 2550
    if (vm)
        virDomainObjUnlock(vm);
2551 2552
    return dom;
}
2553

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

2560
    qemuDriverLock(driver);
2561
    vm = virDomainFindByUUID(&driver->domains, uuid);
2562 2563
    qemuDriverUnlock(driver);

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

2572
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
2573
    if (dom) dom->id = vm->def->id;
2574 2575

cleanup:
2576 2577
    if (vm)
        virDomainObjUnlock(vm);
2578 2579
    return dom;
}
2580

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

2587
    qemuDriverLock(driver);
2588
    vm = virDomainFindByName(&driver->domains, name);
2589 2590
    qemuDriverUnlock(driver);

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

2597
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
2598
    if (dom) dom->id = vm->def->id;
2599 2600

cleanup:
2601 2602
    if (vm)
        virDomainObjUnlock(vm);
2603 2604 2605
    return dom;
}

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

2610
    qemuDriverLock(driver);
2611
    if (qemudExtractVersion(conn, driver) < 0)
2612
        goto cleanup;
2613

2614
    *version = qemu_driver->qemuVersion;
2615 2616 2617
    ret = 0;

cleanup:
2618
    qemuDriverUnlock(driver);
2619
    return ret;
D
Daniel P. Berrange 已提交
2620 2621
}

2622 2623 2624
static char *
qemudGetHostname (virConnectPtr conn)
{
2625
    char *result;
2626

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

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

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

D
Daniel P. Berrange 已提交
2650 2651
    return got;
}
2652

2653
static int qemudNumDomains(virConnectPtr conn) {
2654
    struct qemud_driver *driver = conn->privateData;
2655 2656
    int n = 0, i;

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

2666
    return n;
D
Daniel P. Berrange 已提交
2667
}
2668

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

2677
    qemuDriverLock(driver);
2678 2679
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE)))
2680
        goto cleanup;
2681

2682 2683 2684
    if (virSecurityDriverVerify(conn, def) < 0)
        goto cleanup;

2685
    /* See if a VM with matching UUID already exists */
2686
    vm = virDomainFindByUUID(&driver->domains, def->uuid);
2687
    if (vm) {
2688 2689 2690 2691 2692 2693 2694 2695 2696
        /* 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;
        }
2697

2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
        /* 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;
        }
2716
    }
2717

2718 2719
    if (!(vm = virDomainAssignDef(conn,
                                  &driver->domains,
2720 2721 2722 2723
                                  def)))
        goto cleanup;

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

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

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

2736
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
2737
    if (dom) dom->id = vm->def->id;
2738 2739 2740

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


2750
static int qemudDomainSuspend(virDomainPtr dom) {
2751
    struct qemud_driver *driver = dom->conn->privateData;
D
Daniel P. Berrange 已提交
2752
    char *info;
2753 2754
    virDomainObjPtr vm;
    int ret = -1;
2755
    virDomainEventPtr event = NULL;
2756

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

D
Daniel P. Berrange 已提交
2760
    if (!vm) {
2761 2762 2763 2764
        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);
2765
        goto cleanup;
D
Daniel P. Berrange 已提交
2766
    }
2767
    if (!virDomainIsActive(vm)) {
2768
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
2769
                         "%s", _("domain is not running"));
2770
        goto cleanup;
D
Daniel P. Berrange 已提交
2771
    }
2772
    if (vm->state != VIR_DOMAIN_PAUSED) {
2773
        if (qemudMonitorCommand(vm, "stop", &info) < 0) {
2774 2775 2776 2777 2778 2779
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                             "%s", _("suspend operation failed"));
            goto cleanup;
        }
        vm->state = VIR_DOMAIN_PAUSED;
        qemudDebug("Reply %s", info);
2780 2781 2782
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_SUSPENDED,
                                         VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
2783
        VIR_FREE(info);
D
Daniel P. Berrange 已提交
2784
    }
2785
    if (virDomainSaveStatus(dom->conn, driver->stateDir, vm) < 0)
2786
        goto cleanup;
2787 2788 2789
    ret = 0;

cleanup:
2790 2791
    if (vm)
        virDomainObjUnlock(vm);
2792

2793
    if (event)
2794
        qemuDomainEventQueue(driver, event);
2795
    qemuDriverUnlock(driver);
2796
    return ret;
D
Daniel P. Berrange 已提交
2797 2798 2799
}


2800
static int qemudDomainResume(virDomainPtr dom) {
2801 2802 2803
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2804
    virDomainEventPtr event = NULL;
2805

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

D
Daniel P. Berrange 已提交
2809
    if (!vm) {
2810 2811 2812 2813
        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);
2814
        goto cleanup;
D
Daniel P. Berrange 已提交
2815
    }
2816
    if (!virDomainIsActive(vm)) {
2817
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
2818
                         "%s", _("domain is not running"));
2819
        goto cleanup;
D
Daniel P. Berrange 已提交
2820
    }
2821
    if (vm->state == VIR_DOMAIN_PAUSED) {
2822
        if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
2823 2824 2825
            if (virGetLastError() == NULL)
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("resume operation failed"));
2826 2827 2828
            goto cleanup;
        }
        vm->state = VIR_DOMAIN_RUNNING;
2829 2830 2831
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);
D
Daniel P. Berrange 已提交
2832
    }
2833
    if (virDomainSaveStatus(dom->conn, driver->stateDir, vm) < 0)
2834
        goto cleanup;
2835 2836 2837
    ret = 0;

cleanup:
2838 2839
    if (vm)
        virDomainObjUnlock(vm);
2840
    if (event)
2841
        qemuDomainEventQueue(driver, event);
2842
    qemuDriverUnlock(driver);
2843
    return ret;
D
Daniel P. Berrange 已提交
2844 2845 2846
}


2847
static int qemudDomainShutdown(virDomainPtr dom) {
2848 2849
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
2850
    char* info;
2851
    int ret = -1;
2852

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

2857
    if (!vm) {
2858 2859 2860 2861
        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);
2862
        goto cleanup;
2863 2864
    }

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

2871
    if (qemudMonitorCommand(vm, "system_powerdown", &info) < 0) {
2872
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
2873
                         "%s", _("shutdown operation failed"));
2874
        goto cleanup;
2875
    }
D
Daniel Veillard 已提交
2876
    VIR_FREE(info);
2877 2878 2879
    ret = 0;

cleanup:
2880 2881
    if (vm)
        virDomainObjUnlock(vm);
2882
    return ret;
2883 2884 2885
}


2886
static int qemudDomainDestroy(virDomainPtr dom) {
2887 2888 2889
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2890
    virDomainEventPtr event = NULL;
2891

2892
    qemuDriverLock(driver);
2893
    vm  = virDomainFindByUUID(&driver->domains, dom->uuid);
D
Daniel P. Berrange 已提交
2894
    if (!vm) {
2895 2896 2897 2898
        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);
2899
        goto cleanup;
D
Daniel P. Berrange 已提交
2900
    }
2901
    if (!virDomainIsActive(vm)) {
2902
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
2903 2904 2905
                         "%s", _("domain is not running"));
        goto cleanup;
    }
2906

2907
    qemudShutdownVMDaemon(dom->conn, driver, vm);
2908 2909 2910
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
2911
    if (!vm->persistent) {
2912 2913
        virDomainRemoveInactive(&driver->domains,
                                vm);
2914 2915
        vm = NULL;
    }
2916 2917 2918
    ret = 0;

cleanup:
2919 2920
    if (vm)
        virDomainObjUnlock(vm);
2921 2922
    if (event)
        qemuDomainEventQueue(driver, event);
2923
    qemuDriverUnlock(driver);
2924
    return ret;
D
Daniel P. Berrange 已提交
2925 2926 2927
}


2928
static char *qemudDomainGetOSType(virDomainPtr dom) {
2929 2930 2931
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *type = NULL;
2932

2933
    qemuDriverLock(driver);
2934
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2935
    qemuDriverUnlock(driver);
2936
    if (!vm) {
2937 2938 2939 2940
        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);
2941
        goto cleanup;
2942 2943
    }

2944
    if (!(type = strdup(vm->def->os.type)))
2945
        virReportOOMError(dom->conn);
2946 2947

cleanup:
2948 2949
    if (vm)
        virDomainObjUnlock(vm);
2950 2951 2952
    return type;
}

2953 2954
/* Returns max memory in kb, 0 if error */
static unsigned long qemudDomainGetMaxMemory(virDomainPtr dom) {
2955 2956 2957
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    unsigned long ret = 0;
2958

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

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

2971 2972 2973
    ret = vm->def->maxmem;

cleanup:
2974 2975
    if (vm)
        virDomainObjUnlock(vm);
2976
    return ret;
2977 2978 2979
}

static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long newmax) {
2980 2981 2982
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2983

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

2988
    if (!vm) {
2989 2990
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
2991
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
2992
                         _("no domain with matching uuid '%s'"), uuidstr);
2993
        goto cleanup;
2994 2995 2996 2997
    }

    if (newmax < vm->def->memory) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
2998
                         "%s", _("cannot set max memory lower than current memory"));
2999
        goto cleanup;;
3000 3001 3002
    }

    vm->def->maxmem = newmax;
3003 3004 3005
    ret = 0;

cleanup:
3006 3007
    if (vm)
        virDomainObjUnlock(vm);
3008
    return ret;
3009 3010
}

3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025

/* The reply from QEMU contains 'ballon: actual=421' where value is in MB */
#define BALLOON_PREFIX "balloon: actual="

/*
 * Returns: 0 if balloon not supported, +1 if balloon query worked
 * or -1 on failure
 */
static int qemudDomainGetMemoryBalloon(virConnectPtr conn,
                                       virDomainObjPtr vm,
                                       unsigned long *currmem) {
    char *reply = NULL;
    int ret = -1;
    char *offset;

3026 3027 3028
    if (!virDomainIsActive(vm))
        return 0;

3029 3030 3031 3032 3033 3034
    if (qemudMonitorCommand(vm, "info balloon", &reply) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("could not query memory balloon allocation"));
        goto cleanup;
    }

3035
    DEBUG ("%s: balloon reply: '%s'", vm->def->name, reply);
3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088
    if ((offset = strstr(reply, BALLOON_PREFIX)) != NULL) {
        unsigned int memMB;
        char *end;
        offset += strlen(BALLOON_PREFIX);
        if (virStrToLong_ui(offset, &end, 10, &memMB) < 0) {
            qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                             "%s", _("could not parse memory balloon allocation"));
            goto cleanup;
        }
        *currmem = memMB * 1024;
        ret = 1;
    } else {
        /* We don't raise an error here, since its to be expected that
         * many QEMU's don't support ballooning
         */
        ret = 0;
    }

cleanup:
    VIR_FREE(reply);
    return ret;
}

/*
 * Returns: 0 if balloon not supported, +1 if balloon query worked
 * or -1 on failure
 */
static int qemudDomainSetMemoryBalloon(virConnectPtr conn,
                                       virDomainObjPtr vm,
                                       unsigned long newmem) {
    char *cmd;
    char *reply = NULL;
    int ret = -1;

    /*
     * 'newmem' is in KB, QEMU monitor works in MB, and we all wish
     * we just worked in bytes with unsigned long long everywhere.
     */
    if (virAsprintf(&cmd, "balloon %lu", (newmem / 1024)) < 0) {
        virReportOOMError(conn);
        goto cleanup;
    }

    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("could not balloon memory allocation"));
        VIR_FREE(cmd);
        goto cleanup;
    }
    VIR_FREE(cmd);

    /* If the command failed qemu prints: 'unknown command'
     * No message is printed on success it seems */
3089
    DEBUG ("%s: balloon reply: %s",vm->def->name,  reply);
3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102
    if (strstr(reply, "\nunknown command:")) {
        /* Don't set error - it is expected memory balloon fails on many qemu */
        ret = 0;
    } else {
        ret = 1;
    }

cleanup:
    VIR_FREE(reply);
    return ret;
}


3103
static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem) {
3104 3105 3106
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3107

3108
    qemuDriverLock(driver);
3109
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3110
    qemuDriverUnlock(driver);
3111
    if (!vm) {
3112 3113
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
3114
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
3115
                         _("no domain with matching uuid '%s'"), uuidstr);
3116
        goto cleanup;
3117 3118 3119 3120
    }

    if (newmem > vm->def->maxmem) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
3121
                         "%s", _("cannot set memory higher than max memory"));
3122
        goto cleanup;
3123 3124
    }

3125 3126 3127 3128 3129 3130 3131 3132 3133
    if (virDomainIsActive(vm)) {
        ret = qemudDomainSetMemoryBalloon(dom->conn, vm, newmem);
        if (ret == 0)
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                             "%s", _("cannot set memory of an active domain"));
    } else {
        vm->def->memory = newmem;
        ret = 0;
    }
3134 3135

cleanup:
3136 3137
    if (vm)
        virDomainObjUnlock(vm);
3138
    return ret;
3139 3140
}

3141
static int qemudDomainGetInfo(virDomainPtr dom,
3142
                              virDomainInfoPtr info) {
3143 3144 3145
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3146 3147
    int err;
    unsigned long balloon;
3148

3149
    qemuDriverLock(driver);
3150
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3151
    qemuDriverUnlock(driver);
D
Daniel P. Berrange 已提交
3152
    if (!vm) {
3153 3154 3155 3156
        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);
3157
        goto cleanup;
D
Daniel P. Berrange 已提交
3158 3159
    }

3160
    info->state = vm->state;
D
Daniel P. Berrange 已提交
3161

3162
    if (!virDomainIsActive(vm)) {
3163
        info->cpuTime = 0;
D
Daniel P. Berrange 已提交
3164
    } else {
3165
        if (qemudGetProcessInfo(&(info->cpuTime), NULL, vm->pid, 0) < 0) {
3166
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, ("cannot read cputime for domain"));
3167
            goto cleanup;
D
Daniel P. Berrange 已提交
3168 3169 3170
        }
    }

3171
    info->maxMem = vm->def->maxmem;
3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186

    if (virDomainIsActive(vm)) {
        err = qemudDomainGetMemoryBalloon(dom->conn, vm, &balloon);
        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;
    }

3187
    info->nrVirtCpu = vm->def->vcpus;
3188 3189 3190
    ret = 0;

cleanup:
3191 3192
    if (vm)
        virDomainObjUnlock(vm);
3193
    return ret;
D
Daniel P. Berrange 已提交
3194 3195 3196
}


D
Daniel P. Berrange 已提交
3197
static char *qemudEscape(const char *in, int shell)
3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218
{
    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 已提交
3219 3220 3221 3222
            if (shell)
                len += 5;
            else
                len += 1;
3223 3224 3225 3226 3227 3228 3229
            break;
        default:
            len += 1;
            break;
        }
    }

3230
    if (VIR_ALLOC_N(out, len + 1) < 0)
3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248
        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 已提交
3249 3250 3251 3252 3253 3254 3255 3256 3257
            if (shell) {
                out[j++] = '\'';
                out[j++] = '\\';
                out[j++] = '\\';
                out[j++] = '\'';
                out[j++] = '\'';
            } else {
                out[j++] = in[i];
            }
3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268
            break;
        default:
            out[j++] = in[i];
            break;
        }
    }
    out[j] = '\0';

    return out;
}

3269 3270 3271 3272 3273
static char *qemudEscapeMonitorArg(const char *in)
{
    return qemudEscape(in, 0);
}

D
Daniel P. Berrange 已提交
3274 3275 3276 3277
static char *qemudEscapeShellArg(const char *in)
{
    return qemudEscape(in, 1);
}
3278

3279
#define QEMUD_SAVE_MAGIC "LibvirtQemudSave"
3280 3281 3282
#define QEMUD_SAVE_VERSION 2

enum qemud_save_formats {
3283 3284 3285
    QEMUD_SAVE_FORMAT_RAW = 0,
    QEMUD_SAVE_FORMAT_GZIP = 1,
    QEMUD_SAVE_FORMAT_BZIP2 = 2,
3286 3287
    /*
     * Deprecated by xz and never used as part of a release
3288
     * QEMUD_SAVE_FORMAT_LZMA
3289 3290
     */
    QEMUD_SAVE_FORMAT_XZ = 3,
3291
    QEMUD_SAVE_FORMAT_LZOP = 4,
3292 3293 3294
    /* Note: add new members only at the end.
       These values are used in the on-disk format.
       Do not change or re-use numbers. */
3295 3296

    QEMUD_SAVE_FORMAT_LAST
3297
};
3298

3299 3300 3301 3302 3303
VIR_ENUM_DECL(qemudSaveCompression)
VIR_ENUM_IMPL(qemudSaveCompression, QEMUD_SAVE_FORMAT_LAST,
              "raw",
              "gzip",
              "bzip2",
3304 3305
              "xz",
              "lzop")
3306

3307 3308 3309 3310 3311
struct qemud_save_header {
    char magic[sizeof(QEMUD_SAVE_MAGIC)-1];
    int version;
    int xml_len;
    int was_running;
3312 3313
    int compressed;
    int unused[15];
3314 3315
};

3316
static int qemudDomainSave(virDomainPtr dom,
3317 3318
                           const char *path)
{
3319
    struct qemud_driver *driver = dom->conn->privateData;
3320
    virDomainObjPtr vm = NULL;
3321 3322 3323 3324 3325
    char *command = NULL;
    char *info = NULL;
    int fd = -1;
    char *safe_path = NULL;
    char *xml = NULL;
3326
    struct qemud_save_header header;
3327
    int ret = -1;
3328
    virDomainEventPtr event = NULL;
3329
    int internalret;
3330 3331 3332 3333 3334

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

3335
    qemuDriverLock(driver);
3336 3337 3338
    if (driver->saveImageFormat == NULL)
        header.compressed = QEMUD_SAVE_FORMAT_RAW;
    else {
3339 3340 3341 3342 3343 3344
        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"));
3345
            goto cleanup;
3346
        }
3347 3348
    }

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

D
Daniel P. Berrange 已提交
3351
    if (!vm) {
3352 3353 3354 3355
        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);
3356
        goto cleanup;
D
Daniel P. Berrange 已提交
3357
    }
3358

3359
    if (!virDomainIsActive(vm)) {
3360
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3361
                         "%s", _("domain is not running"));
3362
        goto cleanup;
D
Daniel P. Berrange 已提交
3363
    }
3364 3365 3366 3367

    /* Pause */
    if (vm->state == VIR_DOMAIN_RUNNING) {
        header.was_running = 1;
3368
        if (qemudMonitorCommand(vm, "stop", &info) < 0) {
3369
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3370
                             "%s", _("suspend operation failed"));
3371
            goto cleanup;
3372
        }
3373 3374 3375
        vm->state = VIR_DOMAIN_PAUSED;
        qemudDebug("Reply %s", info);
        VIR_FREE(info);
3376 3377 3378
    }

    /* Get XML for the domain */
3379
    xml = virDomainDefFormat(dom->conn, vm->def, VIR_DOMAIN_XML_SECURE);
3380 3381
    if (!xml) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3382
                         "%s", _("failed to get domain xml"));
3383
        goto cleanup;
3384 3385 3386 3387 3388 3389
    }
    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,
3390
                         _("failed to create '%s'"), path);
3391
        goto cleanup;
3392 3393 3394 3395
    }

    if (safewrite(fd, &header, sizeof(header)) != sizeof(header)) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3396
                         "%s", _("failed to write save header"));
3397
        goto cleanup;
3398 3399 3400 3401
    }

    if (safewrite(fd, xml, header.xml_len) != header.xml_len) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3402
                         "%s", _("failed to write xml"));
3403
        goto cleanup;
3404 3405
    }

3406
    if (close(fd) < 0) {
3407 3408 3409
        virReportSystemError(dom->conn, errno,
                             _("unable to save file %s"),
                             path);
3410 3411 3412
        goto cleanup;
    }
    fd = -1;
3413 3414 3415 3416

    /* Migrate to file */
    safe_path = qemudEscapeShellArg(path);
    if (!safe_path) {
3417
        virReportOOMError(dom->conn);
3418
        goto cleanup;
3419
    }
3420

3421 3422 3423 3424 3425 3426 3427 3428 3429
    {
        const char *prog = qemudSaveCompressionTypeToString(header.compressed);
        const char *args;

        if (prog == NULL) {
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("Invalid compress format %d"), header.compressed);
            goto cleanup;
        }
3430

3431 3432 3433 3434 3435 3436 3437 3438 3439 3440
        if (STREQ (prog, "raw")) {
            prog = "cat";
            args = "";
        } else {
            args = "-c";
        }
        internalret = virAsprintf(&command, "migrate \"exec:"
                                  "%s %s >> '%s' 2>/dev/null\"", prog, args,
                                  safe_path);
    }
3441

3442
    if (internalret < 0) {
3443
        virReportOOMError(dom->conn);
3444
        goto cleanup;
3445 3446
    }

3447
    if (qemudMonitorCommand(vm, command, &info) < 0) {
3448
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3449
                         "%s", _("migrate operation failed"));
3450
        goto cleanup;
3451 3452
    }

3453
    DEBUG ("%s: migrate reply: %s", vm->def->name, info);
3454 3455 3456 3457 3458 3459 3460

    /* If the command isn't supported then qemu prints:
     * unknown command: migrate" */
    if (strstr(info, "unknown command:")) {
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                          "%s",
                          _("'migrate' not supported by this qemu"));
3461
        goto cleanup;
3462 3463
    }

3464 3465
    /* Shut it down */
    qemudShutdownVMDaemon(dom->conn, driver, vm);
3466 3467 3468
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_SAVED);
3469
    if (!vm->persistent) {
3470 3471
        virDomainRemoveInactive(&driver->domains,
                                vm);
3472 3473
        vm = NULL;
    }
3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484
    ret = 0;

cleanup:
    if (fd != -1)
        close(fd);
    VIR_FREE(xml);
    VIR_FREE(safe_path);
    VIR_FREE(command);
    VIR_FREE(info);
    if (ret != 0)
        unlink(path);
3485 3486
    if (vm)
        virDomainObjUnlock(vm);
3487 3488
    if (event)
        qemuDomainEventQueue(driver, event);
3489
    qemuDriverUnlock(driver);
3490
    return ret;
D
Daniel P. Berrange 已提交
3491 3492 3493
}


P
Paolo Bonzini 已提交
3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581
static int qemudDomainCoreDump(virDomainPtr dom,
                               const char *path,
                               int flags ATTRIBUTE_UNUSED) {
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *command = NULL;
    char *info = NULL;
    char *safe_path = NULL;
    int resume = 0, paused = 0;
    int ret = -1;

    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) {
        if (qemudMonitorCommand (vm, "stop", &info) < 0) {
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                             "%s", _("suspending before dump failed"));
            goto cleanup;
        }
        DEBUG ("%s: stop reply: %s", vm->def->name, info);
        VIR_FREE(info);
        paused = 1;
    }

    /* Migrate to file */
    safe_path = qemudEscapeShellArg(path);
    if (!safe_path) {
        virReportOOMError(dom->conn);
        goto cleanup;
    }
    if (virAsprintf(&command, "migrate \"exec:"
                  "dd of='%s' 2>/dev/null"
                  "\"", safe_path) == -1) {
        virReportOOMError(dom->conn);
        command = NULL;
        goto cleanup;
    }

    if (qemudMonitorCommand(vm, command, &info) < 0) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("migrate operation failed"));
        goto cleanup;
    }

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

    /* If the command isn't supported then qemu prints:
     * unknown command: migrate" */
    if (strstr(info, "unknown command:")) {
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                          "%s",
                          _("'migrate' not supported by this qemu"));
        goto cleanup;
    }

    paused = 1;
    ret = 0;
cleanup:
    VIR_FREE(safe_path);
    VIR_FREE(command);
    VIR_FREE(info);

    /* 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) {
3582
        if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
3583 3584 3585
            if (virGetLastError() == NULL)
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("resuming after dump failed"));
P
Paolo Bonzini 已提交
3586 3587 3588 3589 3590 3591 3592 3593
        }
    }
    if (vm)
        virDomainObjUnlock(vm);
    return ret;
}


3594
static int qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) {
3595 3596
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
3597
    int max;
3598
    int ret = -1;
3599
    const char *type;
3600

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

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

3613
    if (virDomainIsActive(vm)) {
3614
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID, "%s",
3615
                         _("cannot change vcpu count of an active domain"));
3616
        goto cleanup;
3617 3618
    }

3619 3620 3621 3622 3623 3624 3625 3626
    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) {
3627 3628
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
                         _("could not determine max vcpus for the domain"));
3629
        goto cleanup;
3630 3631 3632 3633 3634 3635
    }

    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);
3636
        goto cleanup;
3637 3638 3639
    }

    vm->def->vcpus = nvcpus;
3640 3641 3642
    ret = 0;

cleanup:
3643 3644
    if (vm)
        virDomainObjUnlock(vm);
3645
    return ret;
3646 3647
}

3648 3649 3650 3651 3652 3653 3654

#if HAVE_SCHED_GETAFFINITY
static int
qemudDomainPinVcpu(virDomainPtr dom,
                   unsigned int vcpu,
                   unsigned char *cpumap,
                   int maplen) {
3655 3656
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
3657 3658 3659
    cpu_set_t mask;
    int i, maxcpu;
    virNodeInfo nodeinfo;
3660
    int ret = -1;
3661

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

3666 3667 3668 3669 3670 3671 3672 3673
    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;
    }

3674
    if (!virDomainIsActive(vm)) {
3675
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3676
                         "%s",_("cannot pin vcpus on an inactive domain"));
3677
        goto cleanup;
3678 3679 3680 3681 3682 3683
    }

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

3687
    if (nodeGetInfo(dom->conn, &nodeinfo) < 0)
3688
        goto cleanup;
3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701

    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) {
3702 3703
            virReportSystemError(dom->conn, errno, "%s",
                                 _("cannot set affinity"));
3704
            goto cleanup;
3705 3706 3707 3708
        }
    } else {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         "%s", _("cpu affinity is not supported"));
3709
        goto cleanup;
3710
    }
3711
    ret = 0;
3712

3713
cleanup:
3714 3715
    if (vm)
        virDomainObjUnlock(vm);
3716
    return ret;
3717 3718 3719 3720 3721 3722 3723 3724
}

static int
qemudDomainGetVcpus(virDomainPtr dom,
                    virVcpuInfoPtr info,
                    int maxinfo,
                    unsigned char *cpumaps,
                    int maplen) {
3725 3726
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
3727 3728
    virNodeInfo nodeinfo;
    int i, v, maxcpu;
3729
    int ret = -1;
3730

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

3735 3736 3737 3738 3739 3740 3741 3742
    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;
    }

3743
    if (!virDomainIsActive(vm)) {
3744
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3745
                         "%s",_("cannot pin vcpus on an inactive domain"));
3746
        goto cleanup;
3747 3748
    }

3749
    if (nodeGetInfo(dom->conn, &nodeinfo) < 0)
3750
        goto cleanup;
3751 3752 3753 3754 3755 3756 3757 3758 3759

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

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

3760 3761 3762 3763 3764 3765
    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;
3766 3767 3768 3769 3770 3771 3772 3773 3774 3775

                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;
                }
3776
            }
3777 3778
        }

3779 3780 3781 3782 3783 3784 3785 3786 3787
        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) {
3788 3789
                        virReportSystemError(dom->conn, errno, "%s",
                                             _("cannot get affinity"));
3790 3791 3792 3793 3794 3795
                        goto cleanup;
                    }

                    for (i = 0 ; i < maxcpu ; i++)
                        if (CPU_ISSET(i, &mask))
                            VIR_USE_CPU(cpumap, i);
3796
                }
3797 3798 3799 3800
            } else {
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                                 "%s", _("cpu affinity is not available"));
                goto cleanup;
3801 3802 3803
            }
        }
    }
3804
    ret = maxinfo;
3805

3806
cleanup:
3807 3808
    if (vm)
        virDomainObjUnlock(vm);
3809
    return ret;
3810 3811 3812 3813
}
#endif /* HAVE_SCHED_GETAFFINITY */


3814
static int qemudDomainGetMaxVcpus(virDomainPtr dom) {
3815 3816
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
3817
    const char *type;
3818
    int ret = -1;
3819

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

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

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

3839
    ret = qemudGetMaxVCPUs(dom->conn, type);
3840

3841
cleanup:
3842 3843
    if (vm)
        virDomainObjUnlock(vm);
3844 3845 3846
    return ret;
}

3847 3848 3849 3850 3851 3852 3853 3854 3855 3856
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);

3857 3858
    memset(seclabel, 0, sizeof(*seclabel));

3859 3860 3861
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
3862
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891
                         _("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,
3892
                                 "%s", _("Failed to get security label"));
3893 3894 3895 3896 3897 3898 3899 3900 3901 3902
                goto cleanup;
            }
        }
    }

    ret = 0;

cleanup:
    if (vm)
        virDomainObjUnlock(vm);
3903
    qemuDriverUnlock(driver);
3904 3905 3906
    return ret;
}

3907 3908
static int qemudNodeGetSecurityModel(virConnectPtr conn,
                                     virSecurityModelPtr secmodel)
3909 3910 3911
{
    struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
    char *p;
3912
    int ret = 0;
3913

3914 3915
    qemuDriverLock(driver);
    if (!driver->securityDriver) {
3916
        memset(secmodel, 0, sizeof (*secmodel));
3917 3918
        goto cleanup;
    }
3919

3920 3921 3922 3923 3924
    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);
3925 3926
        ret = -1;
        goto cleanup;
3927 3928 3929 3930 3931 3932 3933 3934
    }
    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);
3935 3936
        ret = -1;
        goto cleanup;
3937 3938
    }
    strcpy(secmodel->doi, p);
3939 3940 3941 3942

cleanup:
    qemuDriverUnlock(driver);
    return ret;
3943 3944 3945
}

/* TODO: check seclabel restore */
3946
static int qemudDomainRestore(virConnectPtr conn,
3947 3948 3949
                              const char *path) {
    struct qemud_driver *driver = conn->privateData;
    virDomainDefPtr def = NULL;
3950
    virDomainObjPtr vm = NULL;
3951 3952 3953
    int fd = -1;
    int ret = -1;
    char *xml = NULL;
3954
    struct qemud_save_header header;
3955
    virDomainEventPtr event = NULL;
3956 3957 3958
    int intermediatefd = -1;
    pid_t intermediate_pid = -1;
    int childstat;
3959

3960
    qemuDriverLock(driver);
3961 3962 3963
    /* Verify the header and read the XML */
    if ((fd = open(path, O_RDONLY)) < 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3964
                         "%s", _("cannot read domain image"));
3965
        goto cleanup;
3966 3967 3968 3969
    }

    if (saferead(fd, &header, sizeof(header)) != sizeof(header)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3970
                         "%s", _("failed to read qemu header"));
3971
        goto cleanup;
3972 3973 3974 3975
    }

    if (memcmp(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic)) != 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3976
                         "%s", _("image magic is incorrect"));
3977
        goto cleanup;
3978 3979 3980 3981
    }

    if (header.version > QEMUD_SAVE_VERSION) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3982
                         _("image version is not supported (%d > %d)"),
3983
                         header.version, QEMUD_SAVE_VERSION);
3984
        goto cleanup;
3985 3986
    }

3987
    if (VIR_ALLOC_N(xml, header.xml_len) < 0) {
3988
        virReportOOMError(conn);
3989
        goto cleanup;
3990 3991 3992 3993
    }

    if (saferead(fd, xml, header.xml_len) != header.xml_len) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
3994
                         "%s", _("failed to read XML"));
3995
        goto cleanup;
3996 3997 3998
    }

    /* Create a domain from this XML */
3999 4000
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE))) {
4001
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4002
                         "%s", _("failed to parse XML"));
4003
        goto cleanup;
4004 4005
    }

4006
    /* See if a VM with matching UUID already exists */
4007
    vm = virDomainFindByUUID(&driver->domains, def->uuid);
4008
    if (vm) {
4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019
        /* 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 */
4020
        if (virDomainIsActive(vm)) {
4021
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_INVALID,
4022 4023
                             _("domain is already active as '%s'"), vm->def->name);
            goto cleanup;
4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035
        }
        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;
4036
        }
4037 4038
    }

4039 4040 4041
    if (!(vm = virDomainAssignDef(conn,
                                  &driver->domains,
                                  def))) {
4042
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4043
                         "%s", _("failed to assign new VM"));
4044
        goto cleanup;
4045
    }
4046
    def = NULL;
4047

4048 4049
    if (header.version == 2) {
        const char *intermediate_argv[3] = { NULL, "-dc", NULL };
4050 4051
        const char *prog = qemudSaveCompressionTypeToString(header.compressed);
        if (prog == NULL) {
4052
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4053
                             _("Invalid compressed save format %d"),
4054 4055 4056
                             header.compressed);
            goto cleanup;
        }
4057 4058 4059 4060

        if (header.compressed != QEMUD_SAVE_FORMAT_RAW)
            intermediate_argv[0] = prog;
        else {
4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071
            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;
            }
        }
    }
4072
    /* Set the migration source and start it up. */
4073
    ret = qemudStartVMDaemon(conn, driver, vm, "stdio", fd);
4074 4075 4076 4077 4078 4079 4080
    if (intermediate_pid != -1) {
        /* Wait for intermediate process to exit */
        while (waitpid(intermediate_pid, &childstat, 0) == -1 &&
               errno == EINTR);
    }
    if (intermediatefd != -1)
        close(intermediatefd);
4081
    close(fd);
4082
    fd = -1;
4083
    if (ret < 0) {
4084
        if (!vm->persistent) {
4085 4086
            virDomainRemoveInactive(&driver->domains,
                                    vm);
4087 4088
            vm = NULL;
        }
4089
        goto cleanup;
4090 4091
    }

4092 4093 4094
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_RESTORED);
4095

4096 4097
    /* If it was running before, resume it now. */
    if (header.was_running) {
4098
        if (qemuMonitorStartCPUs(conn, vm) < 0) {
4099 4100 4101
            if (virGetLastError() == NULL)
                qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("failed to resume domain"));
4102
            goto cleanup;
4103 4104
        }
        vm->state = VIR_DOMAIN_RUNNING;
4105
        virDomainSaveStatus(conn, driver->stateDir, vm);
4106
    }
4107
    ret = 0;
4108

4109 4110 4111 4112 4113
cleanup:
    virDomainDefFree(def);
    VIR_FREE(xml);
    if (fd != -1)
        close(fd);
4114 4115
    if (vm)
        virDomainObjUnlock(vm);
4116 4117
    if (event)
        qemuDomainEventQueue(driver, event);
4118
    qemuDriverUnlock(driver);
4119
    return ret;
D
Daniel P. Berrange 已提交
4120 4121 4122
}


4123
static char *qemudDomainDumpXML(virDomainPtr dom,
4124
                                int flags) {
4125 4126 4127
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *ret = NULL;
4128 4129
    unsigned long balloon;
    int err;
4130

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

D
Daniel P. Berrange 已提交
4135
    if (!vm) {
4136 4137 4138 4139
        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);
4140
        goto cleanup;
D
Daniel P. Berrange 已提交
4141 4142
    }

4143 4144 4145 4146 4147 4148 4149
    /* Refresh current memory based on balloon info */
    err = qemudDomainGetMemoryBalloon(dom->conn, vm, &balloon);
    if (err < 0)
        goto cleanup;
    if (err > 0)
        vm->def->memory = balloon;

4150 4151 4152 4153 4154 4155
    ret = virDomainDefFormat(dom->conn,
                             (flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ?
                             vm->newDef : vm->def,
                             flags);

cleanup:
4156 4157
    if (vm)
        virDomainObjUnlock(vm);
4158
    return ret;
D
Daniel P. Berrange 已提交
4159 4160 4161
}


4162 4163 4164 4165
static char *qemuDomainXMLFromNative(virConnectPtr conn,
                                     const char *format,
                                     const char *config,
                                     unsigned int flags ATTRIBUTE_UNUSED) {
4166
    struct qemud_driver *driver = conn->privateData;
4167 4168 4169 4170 4171 4172 4173 4174 4175
    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;
    }

4176
    qemuDriverLock(driver);
4177
    def = qemuParseCommandLineString(conn, driver->caps, config);
4178
    qemuDriverUnlock(driver);
4179 4180 4181 4182 4183 4184 4185 4186 4187 4188
    if (!def)
        goto cleanup;

    xml = virDomainDefFormat(conn, def, VIR_DOMAIN_XML_INACTIVE);

cleanup:
    virDomainDefFree(def);
    return xml;
}

4189 4190 4191 4192 4193 4194
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;
4195
    virDomainChrDef monitor_chr;
4196 4197 4198 4199 4200 4201 4202 4203 4204 4205
    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;

4206 4207
    qemuDriverLock(driver);

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 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 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273
    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;
    }

4274 4275
    if (qemuPrepareMonitorChr(conn, driver, &monitor_chr, def->name) < 0)
        goto cleanup;
4276 4277

    if (qemudBuildCommandLine(conn, driver, def,
4278
                              &monitor_chr, qemuCmdFlags,
4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303
                              &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:
4304
    qemuDriverUnlock(driver);
4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317
    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;
}


4318
static int qemudListDefinedDomains(virConnectPtr conn,
4319
                            char **const names, int nnames) {
4320
    struct qemud_driver *driver = conn->privateData;
4321
    int got = 0, i;
4322

4323
    qemuDriverLock(driver);
4324
    for (i = 0 ; i < driver->domains.count && got < nnames ; i++) {
4325
        virDomainObjLock(driver->domains.objs[i]);
4326 4327
        if (!virDomainIsActive(driver->domains.objs[i])) {
            if (!(names[got++] = strdup(driver->domains.objs[i]->def->name))) {
4328
                virReportOOMError(conn);
4329
                virDomainObjUnlock(driver->domains.objs[i]);
4330 4331
                goto cleanup;
            }
4332
        }
4333
        virDomainObjUnlock(driver->domains.objs[i]);
D
Daniel P. Berrange 已提交
4334
    }
4335

4336
    qemuDriverUnlock(driver);
D
Daniel P. Berrange 已提交
4337
    return got;
4338 4339 4340

 cleanup:
    for (i = 0 ; i < got ; i++)
4341
        VIR_FREE(names[i]);
4342
    qemuDriverUnlock(driver);
4343
    return -1;
D
Daniel P. Berrange 已提交
4344 4345
}

4346
static int qemudNumDefinedDomains(virConnectPtr conn) {
4347
    struct qemud_driver *driver = conn->privateData;
4348 4349
    int n = 0, i;

4350
    qemuDriverLock(driver);
4351 4352
    for (i = 0 ; i < driver->domains.count ; i++)
        if (!virDomainIsActive(driver->domains.objs[i]))
4353
            n++;
4354
    qemuDriverUnlock(driver);
4355

4356
    return n;
D
Daniel P. Berrange 已提交
4357 4358 4359
}


4360
static int qemudDomainStart(virDomainPtr dom) {
4361 4362 4363
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
4364
    virDomainEventPtr event = NULL;
4365

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

4369
    if (!vm) {
4370 4371 4372 4373
        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);
4374
        goto cleanup;
4375 4376
    }

4377
    ret = qemudStartVMDaemon(dom->conn, driver, vm, NULL, -1);
4378
    if (ret != -1)
4379 4380 4381
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STARTED,
                                         VIR_DOMAIN_EVENT_STARTED_BOOTED);
4382 4383

cleanup:
4384 4385
    if (vm)
        virDomainObjUnlock(vm);
4386
    if (event)
4387
        qemuDomainEventQueue(driver, event);
4388
    qemuDriverUnlock(driver);
4389
    return ret;
D
Daniel P. Berrange 已提交
4390 4391
}

4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420
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;
}

4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448
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;
}

4449 4450
int
qemudCanonicalizeMachine(struct qemud_driver *driver, virDomainDefPtr def)
4451 4452 4453 4454 4455 4456
{
    char *canonical = NULL;
    int i;

    for (i = 0; i < driver->caps->nguests; i++) {
        virCapsGuestPtr guest = driver->caps->guests[i];
4457
        virCapsGuestDomainInfoPtr info;
4458 4459 4460
        int j;

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

4463 4464 4465 4466 4467 4468 4469 4470 4471
            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;
4472 4473
        }

4474 4475 4476 4477
        info = &guest->arch.defaultInfo;

        if (info->emulator && STREQ(info->emulator, def->emulator)) {
            if (qemudCanonicalizeMachineFromInfo(def, info, &canonical) < 0)
4478 4479 4480 4481
                return -1;
            goto out;
        }
    }
4482 4483 4484 4485

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

4486 4487 4488 4489 4490 4491 4492
out:
    if (canonical) {
        VIR_FREE(def->os.machine);
        def->os.machine = canonical;
    }
    return 0;
}
D
Daniel P. Berrange 已提交
4493

4494
static virDomainPtr qemudDomainDefine(virConnectPtr conn, const char *xml) {
4495
    struct qemud_driver *driver = conn->privateData;
4496
    virDomainDefPtr def;
4497
    virDomainObjPtr vm = NULL;
4498
    virDomainPtr dom = NULL;
4499
    virDomainEventPtr event = NULL;
4500
    int newVM = 1;
4501

4502
    qemuDriverLock(driver);
4503 4504
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE)))
4505
        goto cleanup;
4506

4507 4508 4509
    if (virSecurityDriverVerify(conn, def) < 0)
        goto cleanup;

4510 4511
    /* See if a VM with matching UUID already exists */
    vm = virDomainFindByUUID(&driver->domains, def->uuid);
4512
    if (vm) {
4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523
        /* 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 */
4524
        virDomainObjUnlock(vm);
4525
        newVM = 0;
4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536
    } 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;
        }
4537
    }
4538

4539
    if (qemudCanonicalizeMachine(driver, def) < 0)
4540 4541
        goto cleanup;

4542 4543 4544
    if (!(vm = virDomainAssignDef(conn,
                                  &driver->domains,
                                  def))) {
4545
        goto cleanup;
4546
    }
4547
    def = NULL;
4548
    vm->persistent = 1;
4549

4550 4551
    if (virDomainSaveConfig(conn,
                            driver->configDir,
4552
                            vm->newDef ? vm->newDef : vm->def) < 0) {
4553 4554
        virDomainRemoveInactive(&driver->domains,
                                vm);
4555
        vm = NULL;
4556
        goto cleanup;
4557 4558
    }

4559 4560 4561 4562 4563
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_DEFINED,
                                     newVM ?
                                     VIR_DOMAIN_EVENT_DEFINED_ADDED :
                                     VIR_DOMAIN_EVENT_DEFINED_UPDATED);
4564

4565
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
4566
    if (dom) dom->id = vm->def->id;
4567 4568

cleanup:
4569
    virDomainDefFree(def);
4570 4571
    if (vm)
        virDomainObjUnlock(vm);
4572 4573
    if (event)
        qemuDomainEventQueue(driver, event);
4574
    qemuDriverUnlock(driver);
4575
    return dom;
D
Daniel P. Berrange 已提交
4576 4577
}

4578
static int qemudDomainUndefine(virDomainPtr dom) {
4579 4580
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
4581
    virDomainEventPtr event = NULL;
4582
    int ret = -1;
D
Daniel P. Berrange 已提交
4583

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

D
Daniel P. Berrange 已提交
4587
    if (!vm) {
4588 4589 4590 4591
        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);
4592
        goto cleanup;
D
Daniel P. Berrange 已提交
4593 4594
    }

4595
    if (virDomainIsActive(vm)) {
4596
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
4597
                         "%s", _("cannot delete active domain"));
4598
        goto cleanup;
D
Daniel P. Berrange 已提交
4599 4600
    }

4601 4602 4603
    if (!vm->persistent) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("cannot undefine transient domain"));
4604
        goto cleanup;
4605 4606 4607
    }

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

4610 4611 4612
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_UNDEFINED,
                                     VIR_DOMAIN_EVENT_UNDEFINED_REMOVED);
4613

4614 4615
    virDomainRemoveInactive(&driver->domains,
                            vm);
4616
    vm = NULL;
4617
    ret = 0;
D
Daniel P. Berrange 已提交
4618

4619
cleanup:
4620 4621
    if (vm)
        virDomainObjUnlock(vm);
4622 4623
    if (event)
        qemuDomainEventQueue(driver, event);
4624
    qemuDriverUnlock(driver);
4625
    return ret;
D
Daniel P. Berrange 已提交
4626 4627
}

4628
/* Return the disks name for use in monitor commands */
4629
static char *qemudDiskDeviceName(const virConnectPtr conn,
4630
                                 const virDomainDiskDefPtr disk) {
4631 4632 4633 4634 4635 4636

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

    if (virDiskNameToBusDeviceIndex(disk, &busid, &devid) < 0) {
4637
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
4638 4639 4640 4641 4642 4643 4644
                         _("cannot convert disk '%s' to bus/device index"),
                         disk->dst);
        return NULL;
    }

    switch (disk->bus) {
        case VIR_DOMAIN_DISK_BUS_IDE:
4645
            if (disk->device== VIR_DOMAIN_DISK_DEVICE_DISK)
4646
                ret = virAsprintf(&devname, "ide%d-hd%d", busid, devid);
4647
            else
4648
                ret = virAsprintf(&devname, "ide%d-cd%d", busid, devid);
4649 4650
            break;
        case VIR_DOMAIN_DISK_BUS_SCSI:
4651
            if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK)
4652
                ret = virAsprintf(&devname, "scsi%d-hd%d", busid, devid);
4653
            else
4654
                ret = virAsprintf(&devname, "scsi%d-cd%d", busid, devid);
4655 4656
            break;
        case VIR_DOMAIN_DISK_BUS_FDC:
4657
            ret = virAsprintf(&devname, "floppy%d", devid);
4658 4659
            break;
        case VIR_DOMAIN_DISK_BUS_VIRTIO:
4660
            ret = virAsprintf(&devname, "virtio%d", devid);
4661 4662
            break;
        default:
4663
            qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SUPPORT,
4664 4665 4666 4667 4668 4669
                             _("Unsupported disk name mapping for bus '%s'"),
                             virDomainDiskBusTypeToString(disk->bus));
            return NULL;
    }

    if (ret == -1) {
4670
        virReportOOMError(conn);
4671 4672 4673 4674 4675 4676
        return NULL;
    }

    return devname;
}

4677 4678
static int qemudDomainChangeEjectableMedia(virConnectPtr conn,
                                           virDomainObjPtr vm,
4679 4680
                                           virDomainDeviceDefPtr dev,
                                           unsigned int qemuCmdFlags)
4681
{
4682
    virDomainDiskDefPtr origdisk = NULL, newdisk;
4683
    char *cmd, *reply, *safe_path;
4684
    char *devname = NULL;
4685
    int i;
4686

4687
    origdisk = NULL;
4688
    newdisk = dev->data.disk;
4689 4690 4691 4692
    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];
4693
            break;
4694
        }
4695 4696 4697
    }

    if (!origdisk) {
4698
        qemudReportError(conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
4699 4700 4701 4702 4703 4704 4705
                         _("No device with bus '%s' and target '%s'"),
                         virDomainDiskBusTypeToString(newdisk->bus),
                         newdisk->dst);
        return -1;
    }

    if (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE) {
4706
        if (!(devname = qemudDiskDeviceName(conn, newdisk)))
4707 4708 4709 4710 4711 4712 4713 4714 4715
            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 {
4716
            qemudReportError(conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
4717 4718 4719 4720 4721 4722 4723 4724
                             _("Emulator version does not support removable "
                               "media for device '%s' and target '%s'"),
                               virDomainDiskDeviceTypeToString(newdisk->device),
                               newdisk->dst);
            return -1;
        }

        if (!devname) {
4725
            virReportOOMError(conn);
4726 4727 4728
            return -1;
        }
    }
4729

4730
    if (newdisk->src) {
4731 4732
        safe_path = qemudEscapeMonitorArg(newdisk->src);
        if (!safe_path) {
4733
            virReportOOMError(conn);
4734
            VIR_FREE(devname);
4735 4736
            return -1;
        }
4737
        if (virAsprintf(&cmd, "change %s \"%s\"", devname, safe_path) == -1) {
4738
            virReportOOMError(conn);
4739
            VIR_FREE(safe_path);
4740
            VIR_FREE(devname);
4741 4742
            return -1;
        }
4743
        VIR_FREE(safe_path);
4744

4745
    } else if (virAsprintf(&cmd, "eject %s", devname) == -1) {
4746
        virReportOOMError(conn);
4747
        VIR_FREE(devname);
4748 4749
        return -1;
    }
4750
    VIR_FREE(devname);
4751

4752
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
4753
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
C
Cole Robinson 已提交
4754
                         "%s", _("could not change cdrom media"));
4755
        VIR_FREE(cmd);
4756 4757
        return -1;
    }
4758 4759 4760 4761

    /* If the command failed qemu prints:
     * device not found, device is locked ...
     * No message is printed on success it seems */
4762
    DEBUG ("%s: ejectable media change reply: %s", vm->def->name, reply);
4763
    if (strstr(reply, "\ndevice ")) {
4764
        qemudReportError (conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
C
Cole Robinson 已提交
4765
                          _("changing cdrom media failed: %s"), reply);
4766 4767 4768 4769
        VIR_FREE(reply);
        VIR_FREE(cmd);
        return -1;
    }
4770 4771
    VIR_FREE(reply);
    VIR_FREE(cmd);
4772

4773 4774
    VIR_FREE(origdisk->src);
    origdisk->src = newdisk->src;
4775
    newdisk->src = NULL;
4776
    origdisk->type = newdisk->type;
4777 4778 4779
    return 0;
}

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 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846
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;
}

4847 4848 4849
static int qemudDomainAttachPciDiskDevice(virConnectPtr conn,
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
4850 4851
{
    int ret, i;
4852
    char *cmd, *reply;
4853 4854
    char *safe_path;
    const char* type = virDomainDiskBusTypeToString(dev->data.disk->bus);
4855
    int tryOldSyntax = 0;
4856
    unsigned domain, bus, slot;
4857 4858 4859

    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(vm->def->disks[i]->dst, dev->data.disk->dst)) {
4860
            qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4861 4862 4863 4864 4865 4866
                           _("target %s already exists"), dev->data.disk->dst);
            return -1;
        }
    }

    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
4867
        virReportOOMError(conn);
4868 4869 4870
        return -1;
    }

4871
try_command:
4872 4873
    safe_path = qemudEscapeMonitorArg(dev->data.disk->src);
    if (!safe_path) {
4874
        virReportOOMError(conn);
4875 4876 4877
        return -1;
    }

4878 4879
    ret = virAsprintf(&cmd, "pci_add %s storage file=%s,if=%s",
                      (tryOldSyntax ? "0": "pci_addr=auto"), safe_path, type);
4880 4881
    VIR_FREE(safe_path);
    if (ret == -1) {
4882
        virReportOOMError(conn);
4883 4884 4885
        return ret;
    }

4886
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
4887
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4888 4889 4890 4891 4892
                         _("cannot attach %s disk"), type);
        VIR_FREE(cmd);
        return -1;
    }

4893 4894
    VIR_FREE(cmd);

4895 4896 4897 4898 4899 4900
    if (qemudParsePciAddReply(vm, reply, &domain, &bus, &slot) < 0) {
        if (!tryOldSyntax && strstr(reply, "invalid char in expression")) {
            VIR_FREE(reply);
            tryOldSyntax = 1;
            goto try_command;
        }
4901

4902
        qemudReportError (conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4903
                          _("adding %s disk failed: %s"), type, reply);
4904 4905 4906 4907
        VIR_FREE(reply);
        return -1;
    }

4908 4909 4910 4911 4912 4913
    VIR_FREE(reply);

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

4914
    virDomainDiskInsertPreAlloced(vm->def, dev->data.disk);
4915 4916 4917

    return 0;
}
4918

4919 4920 4921
static int qemudDomainAttachUsbMassstorageDevice(virConnectPtr conn,
                                                 virDomainObjPtr vm,
                                                 virDomainDeviceDefPtr dev)
4922
{
4923 4924
    int ret, i;
    char *safe_path;
4925 4926
    char *cmd, *reply;

4927 4928
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(vm->def->disks[i]->dst, dev->data.disk->dst)) {
4929
            qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4930 4931 4932 4933 4934
                           _("target %s already exists"), dev->data.disk->dst);
            return -1;
        }
    }

4935
    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
4936
        virReportOOMError(conn);
4937
        return -1;
4938 4939
    }

4940 4941
    safe_path = qemudEscapeMonitorArg(dev->data.disk->src);
    if (!safe_path) {
4942
        virReportOOMError(conn);
4943 4944 4945
        return -1;
    }

4946
    ret = virAsprintf(&cmd, "usb_add disk:%s", safe_path);
4947
    VIR_FREE(safe_path);
4948
    if (ret == -1) {
4949
        virReportOOMError(conn);
4950 4951 4952
        return ret;
    }

4953
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
4954
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4955
                         "%s", _("cannot attach usb disk"));
4956 4957 4958 4959
        VIR_FREE(cmd);
        return -1;
    }

4960
    DEBUG ("%s: attach_usb reply: %s",vm->def->name,  reply);
4961 4962 4963
    /* If the command failed qemu prints:
     * Could not add ... */
    if (strstr(reply, "Could not add ")) {
4964
        qemudReportError (conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
4965
                          "%s",
4966
                          _("adding usb disk failed"));
4967 4968 4969 4970
        VIR_FREE(reply);
        VIR_FREE(cmd);
        return -1;
    }
4971

4972
    virDomainDiskInsertPreAlloced(vm->def, dev->data.disk);
4973

4974 4975 4976 4977 4978
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return 0;
}

M
Mark McLoughlin 已提交
4979
static int qemudDomainAttachNetDevice(virConnectPtr conn,
4980
                                      struct qemud_driver *driver,
M
Mark McLoughlin 已提交
4981 4982 4983 4984 4985
                                      virDomainObjPtr vm,
                                      virDomainDeviceDefPtr dev,
                                      unsigned int qemuCmdFlags)
{
    virDomainNetDefPtr net = dev->data.net;
4986
    char *cmd = NULL, *reply = NULL, *remove_cmd = NULL;
4987 4988
    char *tapfd_name = NULL, *tapfd_close = NULL;
    int i, tapfd = -1;
4989
    unsigned domain, bus, slot;
M
Mark McLoughlin 已提交
4990 4991 4992 4993 4994 4995 4996 4997 4998

    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) {
4999 5000 5001 5002 5003 5004 5005 5006 5007 5008
        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 已提交
5009 5010
    }

5011 5012
    if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
        goto no_memory;
M
Mark McLoughlin 已提交
5013 5014

    if ((qemuCmdFlags & QEMUD_CMD_FLAG_NET_NAME) &&
5015 5016
        qemuAssignNetNames(vm->def, net) < 0)
        goto no_memory;
M
Mark McLoughlin 已提交
5017 5018 5019 5020 5021 5022 5023 5024 5025

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

5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060
    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 已提交
5061

5062 5063 5064 5065
    remove_cmd = NULL;
    if (net->vlan >= 0 && net->hostnet_name &&
        virAsprintf(&remove_cmd, "host_net_remove %d %s",
                    net->vlan, net->hostnet_name) < 0) {
5066 5067
        virReportOOMError(conn);
        goto try_tapfd_close;
5068 5069
    }

M
Mark McLoughlin 已提交
5070 5071 5072
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         _("failed to add network backend with '%s'"), cmd);
5073
        goto try_tapfd_close;
M
Mark McLoughlin 已提交
5074 5075 5076 5077 5078 5079
    }

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

    VIR_FREE(reply);
    VIR_FREE(cmd);
5080 5081 5082 5083 5084
    VIR_FREE(tapfd_name);
    VIR_FREE(tapfd_close);
    if (tapfd != -1)
        close(tapfd);
    tapfd = -1;
M
Mark McLoughlin 已提交
5085 5086

    if (qemuBuildNicStr(conn, net,
5087 5088
                        "pci_add pci_addr=auto ", ' ', net->vlan, &cmd) < 0)
        goto try_remove;
M
Mark McLoughlin 已提交
5089 5090 5091 5092

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

5096 5097 5098 5099 5100 5101
    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;
    }

5102
    VIR_FREE(cmd);
5103
    VIR_FREE(reply);
5104
    VIR_FREE(remove_cmd);
M
Mark McLoughlin 已提交
5105

5106 5107 5108 5109
    net->pci_addr.domain = domain;
    net->pci_addr.bus    = bus;
    net->pci_addr.slot   = slot;

M
Mark McLoughlin 已提交
5110 5111 5112
    vm->def->nets[vm->def->nnets++] = net;

    return 0;
5113 5114

try_remove:
5115
    VIR_FREE(reply);
5116 5117 5118 5119 5120 5121 5122

    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);
5123
    goto cleanup;
5124

5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135
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;

5136 5137 5138 5139
no_memory:
    virReportOOMError(conn);
cleanup:
    VIR_FREE(cmd);
5140 5141
    VIR_FREE(reply);
    VIR_FREE(remove_cmd);
5142 5143 5144 5145
    VIR_FREE(tapfd_close);
    VIR_FREE(tapfd_name);
    if (tapfd != -1)
        close(tapfd);
5146
    return -1;
M
Mark McLoughlin 已提交
5147 5148
}

5149
static int qemudDomainAttachHostPciDevice(virConnectPtr conn,
5150
                                          struct qemud_driver *driver,
5151 5152 5153 5154 5155 5156
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
{
    virDomainHostdevDefPtr hostdev = dev->data.hostdev;
    char *cmd, *reply;
    unsigned domain, bus, slot;
5157
    pciDevice *pci;
5158 5159 5160 5161 5162 5163

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

5164 5165 5166 5167 5168 5169 5170
    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;
5171

5172
    if ((hostdev->managed && pciDettachDevice(conn, pci) < 0) ||
5173 5174 5175 5176 5177 5178
        pciResetDevice(conn, pci, driver->activePciHostdevs) < 0) {
        pciFreeDevice(conn, pci);
        return -1;
    }

    if (pciDeviceListAdd(conn, driver->activePciHostdevs, pci) < 0) {
5179
        pciFreeDevice(conn, pci);
5180
        return -1;
5181 5182
    }

5183
    cmd = reply = NULL;
5184

5185
    if (virAsprintf(&cmd, "pci_add pci_addr=auto host host=%.2x:%.2x.%.1x",
5186 5187 5188 5189
                    hostdev->source.subsys.u.pci.bus,
                    hostdev->source.subsys.u.pci.slot,
                    hostdev->source.subsys.u.pci.function) < 0) {
        virReportOOMError(conn);
5190
        goto error;
5191 5192 5193 5194 5195
    }

    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("cannot attach host pci device"));
5196
        goto error;
5197 5198 5199 5200 5201
    }

    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"));
5202
        goto error;
5203 5204 5205 5206 5207
    }

    if (qemudParsePciAddReply(vm, reply, &domain, &bus, &slot) < 0) {
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         _("parsing pci_add reply failed: %s"), reply);
5208
        goto error;
5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220
    }

    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;
5221 5222 5223 5224 5225 5226 5227 5228

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

    VIR_FREE(reply);
    VIR_FREE(cmd);

    return -1;
5229 5230
}

M
Mark McLoughlin 已提交
5231 5232 5233
static int qemudDomainAttachHostUsbDevice(virConnectPtr conn,
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
5234 5235 5236 5237
{
    int ret;
    char *cmd, *reply;

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

5243
    if (dev->data.hostdev->source.subsys.u.usb.vendor) {
5244 5245 5246
        ret = virAsprintf(&cmd, "usb_add host:%.4x:%.4x",
                          dev->data.hostdev->source.subsys.u.usb.vendor,
                          dev->data.hostdev->source.subsys.u.usb.product);
5247
    } else {
5248 5249 5250
        ret = virAsprintf(&cmd, "usb_add host:%.3d.%.3d",
                          dev->data.hostdev->source.subsys.u.usb.bus,
                          dev->data.hostdev->source.subsys.u.usb.device);
5251 5252
    }
    if (ret == -1) {
5253
        virReportOOMError(conn);
5254 5255 5256
        return -1;
    }

5257
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
5258
        qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
5259 5260 5261 5262 5263
                         "%s", _("cannot attach usb device"));
        VIR_FREE(cmd);
        return -1;
    }

5264
    DEBUG ("%s: attach_usb reply: %s", vm->def->name, reply);
5265 5266 5267
    /* If the command failed qemu prints:
     * Could not add ... */
    if (strstr(reply, "Could not add ")) {
5268
        qemudReportError (conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
5269 5270 5271 5272 5273 5274
                          "%s",
                          _("adding usb device failed"));
        VIR_FREE(reply);
        VIR_FREE(cmd);
        return -1;
    }
5275

5276
    vm->def->hostdevs[vm->def->nhostdevs++] = dev->data.hostdev;
5277

5278 5279
    VIR_FREE(reply);
    VIR_FREE(cmd);
5280 5281 5282
    return 0;
}

M
Mark McLoughlin 已提交
5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298
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;
5299 5300 5301
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityHostdevLabel(conn, vm, dev->data.hostdev) < 0)
        return -1;
M
Mark McLoughlin 已提交
5302 5303

    switch (hostdev->source.subsys.type) {
5304
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
5305
        return qemudDomainAttachHostPciDevice(conn, driver, vm, dev);
M
Mark McLoughlin 已提交
5306 5307 5308 5309 5310 5311 5312 5313 5314 5315
    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;
    }
}

5316 5317
static int qemudDomainAttachDevice(virDomainPtr dom,
                                   const char *xml) {
5318 5319 5320
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr dev = NULL;
5321
    unsigned int qemuCmdFlags;
5322
    virCgroupPtr cgroup = NULL;
5323
    int ret = -1;
5324

5325
    qemuDriverLock(driver);
5326
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5327
    if (!vm) {
5328 5329 5330 5331
        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);
5332
        goto cleanup;
5333 5334 5335
    }

    if (!virDomainIsActive(vm)) {
5336
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
5337
                         "%s", _("cannot attach device on inactive domain"));
5338
        goto cleanup;
5339 5340
    }

5341 5342
    dev = virDomainDeviceDefParse(dom->conn, driver->caps, vm->def, xml,
                                  VIR_DOMAIN_XML_INACTIVE);
5343 5344 5345
    if (dev == NULL)
        goto cleanup;

5346 5347 5348 5349
    if (qemudExtractVersionInfo(vm->def->emulator,
                                NULL,
                                &qemuCmdFlags) < 0)
        goto cleanup;
5350

5351
    if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
5352
        if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369
            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;
            }
        }

5370
        switch (dev->data.disk->device) {
5371 5372
        case VIR_DOMAIN_DISK_DEVICE_CDROM:
        case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
5373 5374
            if (driver->securityDriver)
                driver->securityDriver->domainSetSecurityImageLabel(dom->conn, vm, dev->data.disk);
5375 5376 5377 5378

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

5379
            ret = qemudDomainChangeEjectableMedia(dom->conn, vm, dev, qemuCmdFlags);
5380
            break;
5381

5382
        case VIR_DOMAIN_DISK_DEVICE_DISK:
5383 5384
            if (driver->securityDriver)
                driver->securityDriver->domainSetSecurityImageLabel(dom->conn, vm, dev->data.disk);
5385 5386 5387 5388

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

5389
            if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
5390
                ret = qemudDomainAttachUsbMassstorageDevice(dom->conn, vm, dev);
5391 5392
            } else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_SCSI ||
                       dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) {
5393
                ret = qemudDomainAttachPciDiskDevice(dom->conn, vm, dev);
5394 5395 5396 5397
            } else {
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                                 _("disk bus '%s' cannot be hotplugged."),
                                 virDomainDiskBusTypeToString(dev->data.disk->bus));
5398
                /* fallthrough */
5399 5400
            }
            break;
5401

5402 5403
        default:
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
5404 5405
                             _("disk device type '%s' cannot be hotplugged"),
                             virDomainDiskDeviceTypeToString(dev->data.disk->device));
5406 5407 5408 5409 5410
            /* Fallthrough */
        }
        if (ret != 0) {
            virCgroupDenyDevicePath(cgroup,
                                    dev->data.disk->src);
5411
        }
M
Mark McLoughlin 已提交
5412
    } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
5413
        ret = qemudDomainAttachNetDevice(dom->conn, driver, vm, dev, qemuCmdFlags);
M
Mark McLoughlin 已提交
5414 5415
    } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
        ret = qemudDomainAttachHostDevice(dom->conn, driver, vm, dev);
5416
    } else {
5417
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
5418 5419
                         _("device type '%s' cannot be attached"),
                         virDomainDeviceTypeToString(dev->type));
5420
        goto cleanup;
5421 5422
    }

5423
    if (!ret && virDomainSaveStatus(dom->conn, driver->stateDir, vm) < 0)
5424 5425
        ret = -1;

5426
cleanup:
5427 5428 5429
    if (cgroup)
        virCgroupFree(&cgroup);

5430 5431 5432
    if (ret < 0) {
        if (qemuDomainSetDeviceOwnership(dom->conn, driver, dev, 1) < 0)
            VIR_WARN0("Fail to restore disk device ownership");
G
Guido Günther 已提交
5433
        virDomainDeviceDefFree(dev);
5434
    }
5435 5436
    if (vm)
        virDomainObjUnlock(vm);
5437
    qemuDriverUnlock(driver);
5438 5439 5440
    return ret;
}

5441 5442
static int qemudDomainDetachPciDiskDevice(virConnectPtr conn,
                                          virDomainObjPtr vm, virDomainDeviceDefPtr dev)
5443 5444
{
    int i, ret = -1;
5445 5446
    char *cmd = NULL;
    char *reply = NULL;
5447
    virDomainDiskDefPtr detach = NULL;
5448
    int tryOldSyntax = 0;
5449 5450 5451 5452 5453 5454 5455 5456 5457

    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) {
5458
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5459
                         _("disk %s not found"), dev->data.disk->dst);
5460
        goto cleanup;
5461 5462
    }

5463
    if (!virDiskHasValidPciAddr(detach)) {
5464
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5465 5466
                         _("disk %s cannot be detached - no PCI address for device"),
                           detach->dst);
5467
        goto cleanup;
5468 5469
    }

5470 5471
try_command:
    if (tryOldSyntax) {
5472
        if (virAsprintf(&cmd, "pci_del 0 %.2x", detach->pci_addr.slot) < 0) {
5473 5474 5475 5476
            virReportOOMError(conn);
            goto cleanup;
        }
    } else {
5477 5478 5479 5480
        if (virAsprintf(&cmd, "pci_del pci_addr=%.4x:%.2x:%.2x",
                        detach->pci_addr.domain,
                        detach->pci_addr.bus,
                        detach->pci_addr.slot) < 0) {
5481 5482 5483
            virReportOOMError(conn);
            goto cleanup;
        }
5484 5485
    }

5486
    if (qemudMonitorCommand(vm, cmd, &reply) < 0) {
5487
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5488
                          _("failed to execute detach disk %s command"), detach->dst);
5489
        goto cleanup;
5490 5491
    }

5492
    DEBUG ("%s: pci_del reply: %s",vm->def->name,  reply);
5493 5494 5495 5496 5497 5498

    if (!tryOldSyntax &&
        strstr(reply, "extraneous characters")) {
        tryOldSyntax = 1;
        goto try_command;
    }
5499 5500
    /* If the command fails due to a wrong slot qemu prints: invalid slot,
     * nothing is printed on success */
5501 5502
    if (strstr(reply, "invalid slot") ||
        strstr(reply, "Invalid pci address")) {
5503
        qemudReportError (conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5504 5505 5506 5507 5508 5509
                          _("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);
5510
        goto cleanup;
5511 5512
    }

5513 5514 5515 5516 5517 5518 5519 5520 5521 5522
    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 {
5523
        VIR_FREE(vm->def->disks);
5524
        vm->def->ndisks = 0;
5525
    }
5526
    virDomainDiskDefFree(detach);
5527

5528
    ret = 0;
5529 5530

cleanup:
5531 5532 5533 5534 5535
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}

5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614
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);

5615 5616 5617 5618 5619 5620 5621 5622 5623 5624
    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 {
5625
        VIR_FREE(vm->def->nets);
5626
        vm->def->nnets = 0;
5627
    }
5628
    virDomainNetDefFree(detach);
5629

5630 5631 5632 5633 5634 5635 5636 5637
    ret = 0;

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

5638
static int qemudDomainDetachHostPciDevice(virConnectPtr conn,
5639
                                          struct qemud_driver *driver,
5640 5641 5642
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
{
5643
    virDomainHostdevDefPtr detach = NULL;
5644 5645
    char *cmd, *reply;
    int i, ret;
5646
    pciDevice *pci;
5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714

    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;

5715 5716 5717 5718 5719 5720 5721 5722
    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 {
5723 5724
        pciDeviceListDel(conn, driver->activePciHostdevs, pci);
        if (pciResetDevice(conn, pci, driver->activePciHostdevs) < 0)
5725 5726
            ret = -1;
        if (detach->managed && pciReAttachDevice(conn, pci) < 0)
5727
            ret = -1;
5728
        pciFreeDevice(conn, pci);
5729 5730
    }

5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742
    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;
5743
    }
5744
    virDomainHostdevDefFree(detach);
5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765

    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:
5766
        ret = qemudDomainDetachHostPciDevice(conn, driver, vm, dev);
5767
        break;
5768 5769 5770 5771 5772 5773 5774
    default:
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         _("hostdev subsys type '%s' not supported"),
                         virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
        return -1;
    }

5775 5776 5777 5778
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityHostdevLabel(conn, vm, dev->data.hostdev) < 0)
        VIR_WARN0("Failed to restore device labelling");

5779
    if (qemuDomainSetDeviceOwnership(conn, driver, dev, 1) < 0)
5780
        VIR_WARN0("Failed to restore device ownership");
5781 5782 5783 5784

    return ret;
}

5785 5786
static int qemudDomainDetachDevice(virDomainPtr dom,
                                   const char *xml) {
5787 5788 5789 5790
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr dev = NULL;
    int ret = -1;
5791

5792
    qemuDriverLock(driver);
5793
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5794
    if (!vm) {
5795 5796 5797 5798
        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);
5799
        goto cleanup;
5800 5801 5802
    }

    if (!virDomainIsActive(vm)) {
5803
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
G
Guido Günther 已提交
5804
                         "%s", _("cannot detach device on inactive domain"));
5805
        goto cleanup;
5806 5807
    }

5808 5809
    dev = virDomainDeviceDefParse(dom->conn, driver->caps, vm->def, xml,
                                  VIR_DOMAIN_XML_INACTIVE);
5810 5811 5812
    if (dev == NULL)
        goto cleanup;

5813 5814 5815 5816

    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 ||
5817
         dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)) {
5818
        ret = qemudDomainDetachPciDiskDevice(dom->conn, vm, dev);
5819
        if (driver->securityDriver)
5820
            driver->securityDriver->domainRestoreSecurityImageLabel(dom->conn, dev->data.disk);
5821 5822
        if (qemuDomainSetDeviceOwnership(dom->conn, driver, dev, 1) < 0)
            VIR_WARN0("Fail to restore disk device ownership");
5823 5824
    } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
        ret = qemudDomainDetachNetDevice(dom->conn, vm, dev);
5825 5826
    } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
        ret = qemudDomainDetachHostDevice(dom->conn, driver, vm, dev);
5827
    } else
5828 5829 5830
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         "%s", _("only SCSI or virtio disk device can be detached dynamically"));

5831
    if (!ret && virDomainSaveStatus(dom->conn, driver->stateDir, vm) < 0)
5832 5833
        ret = -1;

5834 5835
cleanup:
    virDomainDeviceDefFree(dev);
5836 5837
    if (vm)
        virDomainObjUnlock(vm);
5838
    qemuDriverUnlock(driver);
5839 5840 5841
    return ret;
}

5842
static int qemudDomainGetAutostart(virDomainPtr dom,
5843
                                   int *autostart) {
5844 5845 5846
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
5847

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

5852
    if (!vm) {
5853 5854 5855 5856
        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);
5857
        goto cleanup;
5858 5859 5860
    }

    *autostart = vm->autostart;
5861
    ret = 0;
5862

5863
cleanup:
5864 5865
    if (vm)
        virDomainObjUnlock(vm);
5866
    return ret;
5867 5868
}

5869
static int qemudDomainSetAutostart(virDomainPtr dom,
5870
                                   int autostart) {
5871 5872
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
5873 5874
    char *configFile = NULL, *autostartLink = NULL;
    int ret = -1;
5875

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

5879
    if (!vm) {
5880 5881 5882 5883
        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);
5884
        goto cleanup;
5885 5886
    }

5887 5888 5889
    if (!vm->persistent) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("cannot set autostart for transient domain"));
5890
        goto cleanup;
5891 5892
    }

5893 5894
    autostart = (autostart != 0);

5895 5896 5897 5898 5899
    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;
5900

5901 5902
        if (autostart) {
            int err;
5903

5904
            if ((err = virFileMakePath(driver->autostartDir))) {
5905 5906 5907
                virReportSystemError(dom->conn, err,
                                     _("cannot create autostart directory %s"),
                                     driver->autostartDir);
5908 5909
                goto cleanup;
            }
5910

5911
            if (symlink(configFile, autostartLink) < 0) {
5912 5913 5914
                virReportSystemError(dom->conn, errno,
                                     _("Failed to create symlink '%s to '%s'"),
                                     autostartLink, configFile);
5915 5916 5917 5918
                goto cleanup;
            }
        } else {
            if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
5919 5920 5921
                virReportSystemError(dom->conn, errno,
                                     _("Failed to delete symlink '%s'"),
                                     autostartLink);
5922 5923
                goto cleanup;
            }
5924 5925
        }

5926
        vm->autostart = autostart;
5927
    }
5928
    ret = 0;
5929

5930 5931 5932
cleanup:
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
5933 5934
    if (vm)
        virDomainObjUnlock(vm);
5935
    qemuDriverUnlock(driver);
5936
    return ret;
5937 5938
}

5939 5940 5941 5942 5943

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

5946
    qemuDriverLock(driver);
5947
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
5948 5949
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
5950
        goto cleanup;
5951 5952 5953 5954 5955 5956 5957 5958
    }

    if (nparams)
        *nparams = 1;

    ret = strdup("posix");
    if (!ret)
        virReportOOMError(dom->conn);
5959 5960 5961

cleanup:
    qemuDriverUnlock(driver);
5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974
    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;

5975
    qemuDriverLock(driver);
5976
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
5977 5978
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
5979
        goto cleanup;
5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024
    }

    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);
6025
    qemuDriverUnlock(driver);
6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039
    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;

6040
    qemuDriverLock(driver);
6041
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
6042 6043
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
6044
        goto cleanup;
6045 6046 6047 6048 6049
    }

    if ((*nparams) != 1) {
        qemudReportError(dom->conn, domain, NULL, VIR_ERR_INVALID_ARG,
                         "%s", _("Invalid parameter count"));
6050
        goto cleanup;
6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074
    }

    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 已提交
6075 6076 6077 6078 6079
    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;
    }
6080 6081 6082 6083 6084 6085 6086

    ret = 0;

cleanup:
    virCgroupFree(&group);
    if (vm)
        virDomainObjUnlock(vm);
6087
    qemuDriverUnlock(driver);
6088 6089 6090 6091
    return ret;
}


6092 6093 6094 6095 6096 6097 6098 6099 6100
/* 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)
{
6101
    struct qemud_driver *driver = dom->conn->privateData;
6102
    char *dummy, *info = NULL;
6103
    const char *p, *eol;
6104
    const char *qemu_dev_name = NULL;
6105
    size_t len;
6106
    int i, ret = -1;
6107
    virDomainObjPtr vm;
6108
    virDomainDiskDefPtr disk = NULL;
6109

6110
    qemuDriverLock(driver);
6111
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
6112
    qemuDriverUnlock(driver);
6113
    if (!vm) {
6114 6115 6116 6117
        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);
6118
        goto cleanup;
6119
    }
6120
    if (!virDomainIsActive (vm)) {
6121
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
6122
                          "%s", _("domain is not running"));
6123
        goto cleanup;
6124 6125
    }

6126 6127 6128 6129 6130 6131 6132 6133
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(path, vm->def->disks[i]->dst)) {
            disk = vm->def->disks[i];
            break;
        }
    }

    if (!disk) {
6134 6135
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                          _("invalid path: %s"), path);
6136
        goto cleanup;
6137 6138
    }

6139
    qemu_dev_name = qemudDiskDeviceName(dom->conn, disk);
6140
    if (!qemu_dev_name)
6141
        goto cleanup;
6142 6143
    len = strlen (qemu_dev_name);

6144
    if (qemudMonitorCommand (vm, "info blockstats", &info) < 0) {
6145 6146
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("'info blockstats' command failed"));
6147
        goto cleanup;
6148
    }
6149
    DEBUG ("%s: info blockstats reply: %s", vm->def->name, info);
6150 6151 6152 6153 6154 6155

    /* If the command isn't supported then qemu prints the supported
     * info commands, so the output starts "info ".  Since this is
     * unlikely to be the name of a block device, we can use this
     * to detect if qemu supports the command.
     */
C
Cole Robinson 已提交
6156
    if (strstr(info, "\ninfo ")) {
6157 6158 6159
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                          "%s",
                          _("'info blockstats' not supported by this qemu"));
6160
        goto cleanup;
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
    }

    stats->rd_req = -1;
    stats->rd_bytes = -1;
    stats->wr_req = -1;
    stats->wr_bytes = -1;
    stats->errs = -1;

    /* The output format for both qemu & KVM is:
     *   blockdevice: rd_bytes=% wr_bytes=% rd_operations=% wr_operations=%
     *   (repeated for each block device)
     * where '%' is a 64 bit number.
     */
    p = info;

    while (*p) {
        if (STREQLEN (p, qemu_dev_name, len)
            && p[len] == ':' && p[len+1] == ' ') {

            eol = strchr (p, '\n');
            if (!eol)
                eol = p + strlen (p);

            p += len+2;         /* Skip to first label. */

            while (*p) {
6187
                if (STRPREFIX (p, "rd_bytes=")) {
6188 6189
                    p += 9;
                    if (virStrToLong_ll (p, &dummy, 10, &stats->rd_bytes) == -1)
6190 6191
                        DEBUG ("%s: error reading rd_bytes: %s",
                               vm->def->name, p);
6192
                } else if (STRPREFIX (p, "wr_bytes=")) {
6193 6194
                    p += 9;
                    if (virStrToLong_ll (p, &dummy, 10, &stats->wr_bytes) == -1)
6195 6196
                        DEBUG ("%s: error reading wr_bytes: %s",
                               vm->def->name, p);
6197
                } else if (STRPREFIX (p, "rd_operations=")) {
6198 6199
                    p += 14;
                    if (virStrToLong_ll (p, &dummy, 10, &stats->rd_req) == -1)
6200 6201
                        DEBUG ("%s: error reading rd_req: %s",
                               vm->def->name, p);
6202
                } else if (STRPREFIX (p, "wr_operations=")) {
6203 6204
                    p += 14;
                    if (virStrToLong_ll (p, &dummy, 10, &stats->wr_req) == -1)
6205 6206
                        DEBUG ("%s: error reading wr_req: %s",
                               vm->def->name, p);
6207
                } else
6208
                    DEBUG ("%s: unknown block stat near %s", vm->def->name, p);
6209 6210 6211 6212 6213 6214

                /* Skip to next label. */
                p = strchr (p, ' ');
                if (!p || p >= eol) break;
                p++;
            }
6215
            ret = 0;
6216
            goto cleanup;
6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227
        }

        /* Skip to next line. */
        p = strchr (p, '\n');
        if (!p) break;
        p++;
    }

    /* If we reach here then the device was not found. */
    qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                      _("device not found: %s (%s)"), path, qemu_dev_name);
6228
 cleanup:
6229 6230
    VIR_FREE(qemu_dev_name);
    VIR_FREE(info);
6231 6232
    if (vm)
        virDomainObjUnlock(vm);
6233
    return ret;
6234 6235
}

6236
#ifdef __linux__
6237 6238 6239 6240 6241
static int
qemudDomainInterfaceStats (virDomainPtr dom,
                           const char *path,
                           struct _virDomainInterfaceStats *stats)
{
6242 6243
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
6244
    int i;
6245
    int ret = -1;
6246

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

6251
    if (!vm) {
6252 6253 6254 6255
        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);
6256
        goto cleanup;
6257 6258
    }

6259
    if (!virDomainIsActive(vm)) {
6260
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
6261
                         "%s", _("domain is not running"));
6262
        goto cleanup;
6263 6264 6265
    }

    /* Check the path is one of the domain's network interfaces. */
6266 6267
    for (i = 0 ; i < vm->def->nnets ; i++) {
        if (vm->def->nets[i]->ifname &&
6268 6269 6270 6271
            STREQ (vm->def->nets[i]->ifname, path)) {
            ret = 0;
            break;
        }
6272 6273
    }

6274 6275 6276 6277 6278
    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);
6279

6280
cleanup:
6281 6282
    if (vm)
        virDomainObjUnlock(vm);
6283 6284
    return ret;
}
6285
#else
6286 6287 6288 6289
static int
qemudDomainInterfaceStats (virDomainPtr dom,
                           const char *path ATTRIBUTE_UNUSED,
                           struct _virDomainInterfaceStats *stats ATTRIBUTE_UNUSED)
6290 6291 6292 6293
    qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                      "%s", __FUNCTION__);
    return -1;
}
6294
#endif
6295

6296 6297 6298 6299 6300 6301 6302
static int
qemudDomainBlockPeek (virDomainPtr dom,
                      const char *path,
                      unsigned long long offset, size_t size,
                      void *buffer,
                      unsigned int flags ATTRIBUTE_UNUSED)
{
6303 6304 6305
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int fd = -1, ret = -1, i;
6306

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

6311
    if (!vm) {
6312 6313 6314 6315
        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);
6316
        goto cleanup;
6317 6318 6319 6320
    }

    if (!path || path[0] == '\0') {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
J
Jim Meyering 已提交
6321
                         "%s", _("NULL or empty path"));
6322
        goto cleanup;
6323 6324 6325
    }

    /* Check the path belongs to this domain. */
6326 6327
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (vm->def->disks[i]->src != NULL &&
6328 6329 6330 6331
            STREQ (vm->def->disks[i]->src, path)) {
            ret = 0;
            break;
        }
6332 6333
    }

6334 6335 6336 6337 6338
    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) {
6339 6340
            virReportSystemError (dom->conn, errno,
                                  _("%s: failed to open"), path);
6341 6342
            goto cleanup;
        }
6343

6344 6345 6346 6347 6348 6349
        /* 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) {
6350 6351
            virReportSystemError (dom->conn, errno,
                                  _("%s: failed to seek or read"), path);
6352 6353 6354 6355 6356 6357 6358
            goto cleanup;
        }

        ret = 0;
    } else {
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                          "%s", _("invalid path"));
6359 6360
    }

6361 6362 6363
cleanup:
    if (fd >= 0)
        close (fd);
6364 6365
    if (vm)
        virDomainObjUnlock(vm);
6366 6367 6368
    return ret;
}

R
Richard W.M. Jones 已提交
6369 6370 6371 6372 6373 6374
static int
qemudDomainMemoryPeek (virDomainPtr dom,
                       unsigned long long offset, size_t size,
                       void *buffer,
                       unsigned int flags)
{
6375 6376 6377
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char cmd[256], *info = NULL;
6378
    char *tmp = NULL;
R
Richard W.M. Jones 已提交
6379 6380
    int fd = -1, ret = -1;

6381
    qemuDriverLock(driver);
6382
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
6383
    qemuDriverUnlock(driver);
R
Richard W.M. Jones 已提交
6384 6385

    if (!vm) {
6386 6387 6388 6389
        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);
6390 6391 6392
        goto cleanup;
    }

6393
    if (flags != VIR_MEMORY_VIRTUAL && flags != VIR_MEMORY_PHYSICAL) {
6394
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
6395
                     "%s", _("flags parameter must be VIR_MEMORY_VIRTUAL or VIR_MEMORY_PHYSICAL"));
6396
        goto cleanup;
R
Richard W.M. Jones 已提交
6397 6398
    }

6399
    if (!virDomainIsActive(vm)) {
6400
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
R
Richard W.M. Jones 已提交
6401
                         "%s", _("domain is not running"));
6402
        goto cleanup;
R
Richard W.M. Jones 已提交
6403 6404
    }

6405 6406 6407 6408 6409
    if (virAsprintf(&tmp, driver->cacheDir,  "/qemu.mem.XXXXXX") < 0) {
        virReportOOMError(dom->conn);
        goto cleanup;
    }

R
Richard W.M. Jones 已提交
6410 6411
    /* Create a temporary filename. */
    if ((fd = mkstemp (tmp)) == -1) {
6412 6413
        virReportSystemError (dom->conn, errno,
                              _("mkstemp(\"%s\") failed"), tmp);
6414
        goto cleanup;
R
Richard W.M. Jones 已提交
6415 6416
    }

6417 6418 6419 6420 6421 6422 6423
    if (flags == VIR_MEMORY_VIRTUAL)
        /* Issue the memsave command. */
        snprintf (cmd, sizeof cmd, "memsave %llu %zi \"%s\"", offset, size, tmp);
    else
        /* Issue the pmemsave command. */
        snprintf (cmd, sizeof cmd, "pmemsave %llu %zi \"%s\"", offset, size, tmp);

6424
    if (qemudMonitorCommand (vm, cmd, &info) < 0) {
R
Richard W.M. Jones 已提交
6425
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
6426
                          "%s", _("'memsave' command failed"));
6427
        goto cleanup;
R
Richard W.M. Jones 已提交
6428 6429
    }

6430
    DEBUG ("%s: (p)memsave reply: %s", vm->def->name, info);
R
Richard W.M. Jones 已提交
6431 6432 6433

    /* Read the memory file into buffer. */
    if (saferead (fd, buffer, size) == (ssize_t) -1) {
6434 6435 6436
        virReportSystemError (dom->conn, errno,
                              _("failed to read temporary file "
                                "created with template %s"), tmp);
6437
        goto cleanup;
R
Richard W.M. Jones 已提交
6438 6439 6440
    }

    ret = 0;
6441 6442

cleanup:
6443
    VIR_FREE(tmp);
6444
    VIR_FREE(info);
R
Richard W.M. Jones 已提交
6445 6446
    if (fd >= 0) close (fd);
    unlink (tmp);
6447 6448
    if (vm)
        virDomainObjUnlock(vm);
R
Richard W.M. Jones 已提交
6449 6450 6451
    return ret;
}

6452

6453 6454
static int
qemudDomainEventRegister (virConnectPtr conn,
6455
                          virConnectDomainEventCallback callback,
6456 6457
                          void *opaque,
                          virFreeCallback freecb)
6458
{
6459 6460 6461
    struct qemud_driver *driver = conn->privateData;
    int ret;

6462
    qemuDriverLock(driver);
6463 6464
    ret = virDomainEventCallbackListAdd(conn, driver->domainEventCallbacks,
                                        callback, opaque, freecb);
6465
    qemuDriverUnlock(driver);
6466

6467
    return ret;
6468 6469 6470 6471
}

static int
qemudDomainEventDeregister (virConnectPtr conn,
6472
                            virConnectDomainEventCallback callback)
6473
{
6474 6475 6476
    struct qemud_driver *driver = conn->privateData;
    int ret;

6477
    qemuDriverLock(driver);
6478 6479 6480 6481 6482 6483
    if (driver->domainEventDispatching)
        ret = virDomainEventCallbackListMarkDelete(conn, driver->domainEventCallbacks,
                                                   callback);
    else
        ret = virDomainEventCallbackListRemove(conn, driver->domainEventCallbacks,
                                               callback);
6484
    qemuDriverUnlock(driver);
6485

6486
    return ret;
6487 6488
}

6489 6490 6491 6492 6493
static void qemuDomainEventDispatchFunc(virConnectPtr conn,
                                        virDomainEventPtr event,
                                        virConnectDomainEventCallback cb,
                                        void *cbopaque,
                                        void *opaque)
6494
{
6495
    struct qemud_driver *driver = opaque;
6496

6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540
    /* 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);
6541 6542
}

D
Daniel Veillard 已提交
6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560
/* 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;
6561 6562
    struct qemud_driver *driver = dconn->privateData;
    virDomainDefPtr def = NULL;
D
Daniel Veillard 已提交
6563 6564
    virDomainObjPtr vm = NULL;
    int this_port;
6565
    char *hostname;
D
Daniel Veillard 已提交
6566 6567
    char migrateFrom [64];
    const char *p;
6568
    virDomainEventPtr event = NULL;
6569
    int ret = -1;
6570
    int internalret;
6571 6572

    *uri_out = NULL;
D
Daniel Veillard 已提交
6573

6574
    qemuDriverLock(driver);
D
Daniel Veillard 已提交
6575 6576 6577
    if (!dom_xml) {
        qemudReportError (dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                          "%s", _("no domain XML passed"));
6578
        goto cleanup;
D
Daniel Veillard 已提交
6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595
    }

    /* 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 */
6596
        if ((hostname = virGetHostname()) == NULL) {
6597 6598
            virReportSystemError (dconn, errno,
                                  "%s", _("failed to determine host name"));
6599
            goto cleanup;
D
Daniel Veillard 已提交
6600 6601 6602
        }

        /* Caller frees */
6603 6604 6605
        internalret = virAsprintf(uri_out, "tcp:%s:%d", hostname, this_port);
        VIR_FREE(hostname);
        if (internalret < 0) {
6606
            virReportOOMError (dconn);
6607
            goto cleanup;
D
Daniel Veillard 已提交
6608 6609 6610 6611 6612 6613
        }
    } 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.
         */
6614
        if (!STRPREFIX (uri_in, "tcp:")) {
D
Daniel Veillard 已提交
6615
            qemudReportError (dconn, NULL, NULL, VIR_ERR_INVALID_ARG,
6616
                  "%s", _("only tcp URIs are supported for KVM/QEMU migrations"));
6617
            goto cleanup;
D
Daniel Veillard 已提交
6618 6619 6620 6621 6622 6623 6624 6625 6626
        }

        /* 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"));
6627
            goto cleanup;
D
Daniel Veillard 已提交
6628 6629 6630 6631
        }
    }

    /* Parse the domain XML. */
6632 6633
    if (!(def = virDomainDefParseString(dconn, driver->caps, dom_xml,
                                        VIR_DOMAIN_XML_INACTIVE))) {
D
Daniel Veillard 已提交
6634 6635
        qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("failed to parse XML"));
6636
        goto cleanup;
D
Daniel Veillard 已提交
6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652
    }

    /* 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"));
6653
        goto cleanup;
D
Daniel Veillard 已提交
6654 6655 6656 6657 6658 6659 6660 6661 6662
    }
#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);
6663
            goto cleanup;
D
Daniel Veillard 已提交
6664
        }
6665
        virDomainObjUnlock(vm);
D
Daniel Veillard 已提交
6666 6667 6668 6669 6670 6671 6672
    }

    if (!(vm = virDomainAssignDef(dconn,
                                  &driver->domains,
                                  def))) {
        qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("failed to assign new VM"));
6673
        goto cleanup;
D
Daniel Veillard 已提交
6674
    }
6675
    def = NULL;
D
Daniel Veillard 已提交
6676 6677 6678 6679 6680 6681 6682 6683

    /* 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);
6684
    if (qemudStartVMDaemon (dconn, driver, vm, migrateFrom, -1) < 0) {
6685 6686 6687
        /* Note that we don't set an error here because qemudStartVMDaemon
         * should have already done that.
         */
6688
        if (!vm->persistent) {
D
Daniel Veillard 已提交
6689
            virDomainRemoveInactive(&driver->domains, vm);
6690 6691
            vm = NULL;
        }
6692
        goto cleanup;
D
Daniel Veillard 已提交
6693
    }
6694 6695 6696 6697

    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_MIGRATED);
6698
    ret = 0;
D
Daniel Veillard 已提交
6699

6700 6701 6702 6703 6704
cleanup:
    virDomainDefFree(def);
    if (ret != 0) {
        VIR_FREE(*uri_out);
    }
6705 6706
    if (vm)
        virDomainObjUnlock(vm);
6707 6708
    if (event)
        qemuDomainEventQueue(driver, event);
6709
    qemuDriverUnlock(driver);
6710
    return ret;
D
Daniel Veillard 已提交
6711 6712 6713 6714 6715 6716 6717 6718
}

/* 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,
6719
                           unsigned long flags,
D
Daniel Veillard 已提交
6720 6721 6722
                           const char *dname ATTRIBUTE_UNUSED,
                           unsigned long resource)
{
6723 6724
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
6725
    virDomainEventPtr event = NULL;
D
Daniel Veillard 已提交
6726 6727
    char *safe_uri;
    char cmd[HOST_NAME_MAX+50];
6728 6729
    char *info = NULL;
    int ret = -1;
6730
    int paused = 0;
D
Daniel Veillard 已提交
6731

6732
    qemuDriverLock(driver);
6733
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
D
Daniel Veillard 已提交
6734
    if (!vm) {
6735 6736 6737 6738
        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);
6739
        goto cleanup;
D
Daniel Veillard 已提交
6740 6741 6742
    }

    if (!virDomainIsActive(vm)) {
6743
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
D
Daniel Veillard 已提交
6744
                          "%s", _("domain is not running"));
6745
        goto cleanup;
D
Daniel Veillard 已提交
6746 6747
    }

6748 6749
    if (!(flags & VIR_MIGRATE_LIVE)) {
        /* Pause domain for non-live migration */
6750 6751 6752 6753 6754
        if (qemudMonitorCommand (vm, "stop", &info) < 0) {
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                             "%s", _("off-line migration specified, but suspend operation failed"));
            goto cleanup;
        }
6755
        DEBUG ("%s: stop reply: %s", vm->def->name, info);
6756
        VIR_FREE(info);
6757
        paused = 1;
6758

6759 6760 6761 6762 6763 6764
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_SUSPENDED,
                                         VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED);
        if (event)
            qemuDomainEventQueue(driver, event);
        event = NULL;
6765 6766
    }

D
Daniel Veillard 已提交
6767 6768 6769
    if (resource > 0) {
        /* Issue migrate_set_speed command.  Don't worry if it fails. */
        snprintf (cmd, sizeof cmd, "migrate_set_speed %lum", resource);
6770
        qemudMonitorCommand (vm, cmd, &info);
D
Daniel Veillard 已提交
6771

6772
        DEBUG ("%s: migrate_set_speed reply: %s", vm->def->name, info);
D
Daniel Veillard 已提交
6773 6774 6775 6776 6777 6778
        VIR_FREE (info);
    }

    /* Issue the migrate command. */
    safe_uri = qemudEscapeMonitorArg (uri);
    if (!safe_uri) {
6779
        virReportOOMError (dom->conn);
6780
        goto cleanup;
D
Daniel Veillard 已提交
6781 6782 6783 6784
    }
    snprintf (cmd, sizeof cmd, "migrate \"%s\"", safe_uri);
    VIR_FREE (safe_uri);

6785
    if (qemudMonitorCommand (vm, cmd, &info) < 0) {
D
Daniel Veillard 已提交
6786 6787
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("migrate operation failed"));
6788
        goto cleanup;
D
Daniel Veillard 已提交
6789 6790
    }

6791
    DEBUG ("%s: migrate reply: %s", vm->def->name, info);
D
Daniel Veillard 已提交
6792 6793 6794 6795 6796

    /* Now check for "fail" in the output string */
    if (strstr(info, "fail") != NULL) {
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                          _("migrate failed: %s"), info);
6797
        goto cleanup;
D
Daniel Veillard 已提交
6798 6799
    }

6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814
    /* it is also possible that the migrate didn't fail initially, but
     * rather failed later on.  Check the output of "info migrate"
     */
    VIR_FREE(info);
    if (qemudMonitorCommand(vm, "info migrate", &info) < 0) {
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("could not get info about migration"));
        goto cleanup;
    }
    if (strstr(info, "fail") != NULL) {
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                          _("migrate failed: %s"), info);
        goto cleanup;
    }

D
Daniel Veillard 已提交
6815 6816
    /* Clean up the source domain. */
    qemudShutdownVMDaemon (dom->conn, driver, vm);
6817
    paused = 0;
6818 6819 6820 6821

    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_MIGRATED);
6822
    if (!vm->persistent) {
D
Daniel Veillard 已提交
6823
        virDomainRemoveInactive(&driver->domains, vm);
6824 6825
        vm = NULL;
    }
6826
    ret = 0;
D
Daniel Veillard 已提交
6827

6828
cleanup:
6829 6830
    if (paused) {
        /* we got here through some sort of failure; start the domain again */
6831
        if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
6832 6833 6834 6835
            /* 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
             */
6836 6837
            VIR_ERROR(_("Failed to resume guest %s after failure\n"),
                      vm->def->name);
6838 6839 6840 6841 6842 6843 6844
        }

        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
    }

6845
    VIR_FREE(info);
6846 6847
    if (vm)
        virDomainObjUnlock(vm);
6848 6849
    if (event)
        qemuDomainEventQueue(driver, event);
6850
    qemuDriverUnlock(driver);
6851
    return ret;
D
Daniel Veillard 已提交
6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863
}

/* 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)
{
6864 6865 6866
    struct qemud_driver *driver = dconn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
6867
    virDomainEventPtr event = NULL;
D
Daniel Veillard 已提交
6868

6869
    qemuDriverLock(driver);
6870
    vm = virDomainFindByName(&driver->domains, dname);
D
Daniel Veillard 已提交
6871
    if (!vm) {
6872 6873
        qemudReportError (dconn, NULL, NULL, VIR_ERR_NO_DOMAIN,
                          _("no domain with matching name '%s'"), dname);
6874
        goto cleanup;
D
Daniel Veillard 已提交
6875 6876 6877 6878 6879 6880 6881
    }

    /* 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);
6882 6883 6884 6885 6886

        /* 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
         */
6887
        if (qemuMonitorStartCPUs(dconn, vm) < 0) {
6888 6889 6890
            if (virGetLastError() == NULL)
                qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 "%s", _("resume operation failed"));
6891 6892 6893
            goto cleanup;
        }

D
Daniel Veillard 已提交
6894
        vm->state = VIR_DOMAIN_RUNNING;
6895 6896 6897
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
D
Daniel Veillard 已提交
6898
        virDomainSaveStatus(dconn, driver->stateDir, vm);
D
Daniel Veillard 已提交
6899 6900
    } else {
        qemudShutdownVMDaemon (dconn, driver, vm);
6901 6902 6903
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STOPPED,
                                         VIR_DOMAIN_EVENT_STOPPED_FAILED);
6904
        if (!vm->persistent) {
D
Daniel Veillard 已提交
6905
            virDomainRemoveInactive(&driver->domains, vm);
6906 6907
            vm = NULL;
        }
D
Daniel Veillard 已提交
6908
    }
6909 6910

cleanup:
6911 6912
    if (vm)
        virDomainObjUnlock(vm);
6913 6914
    if (event)
        qemuDomainEventQueue(driver, event);
6915
    qemuDriverUnlock(driver);
6916
    return dom;
D
Daniel Veillard 已提交
6917 6918
}

6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934
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;

6935
    def = virNodeDeviceDefParseString(dev->conn, xml, EXISTING_DEVICE);
6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013
    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)
{
7014
    struct qemud_driver *driver = dev->conn->privateData;
7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025
    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;

7026 7027 7028
    qemuDriverLock(driver);

    if (pciResetDevice(dev->conn, pci, driver->activePciHostdevs) < 0)
7029 7030 7031 7032
        goto out;

    ret = 0;
out:
7033
    qemuDriverUnlock(driver);
7034 7035 7036 7037
    pciFreeDevice(dev->conn, pci);
    return ret;
}

7038 7039 7040 7041 7042
static virDriver qemuDriver = {
    VIR_DRV_QEMU,
    "QEMU",
    qemudOpen, /* open */
    qemudClose, /* close */
D
Daniel Veillard 已提交
7043
    qemudSupportsFeature, /* supports_feature */
7044 7045
    qemudGetType, /* type */
    qemudGetVersion, /* version */
7046
    qemudGetHostname, /* getHostname */
7047
    qemudGetMaxVCPUs, /* getMaxVcpus */
7048
    nodeGetInfo, /* nodeGetInfo */
7049 7050 7051
    qemudGetCapabilities, /* getCapabilities */
    qemudListDomains, /* listDomains */
    qemudNumDomains, /* numOfDomains */
7052
    qemudDomainCreate, /* domainCreateXML */
7053 7054 7055 7056 7057
    qemudDomainLookupByID, /* domainLookupByID */
    qemudDomainLookupByUUID, /* domainLookupByUUID */
    qemudDomainLookupByName, /* domainLookupByName */
    qemudDomainSuspend, /* domainSuspend */
    qemudDomainResume, /* domainResume */
7058
    qemudDomainShutdown, /* domainShutdown */
7059 7060 7061
    NULL, /* domainReboot */
    qemudDomainDestroy, /* domainDestroy */
    qemudDomainGetOSType, /* domainGetOSType */
7062 7063 7064
    qemudDomainGetMaxMemory, /* domainGetMaxMemory */
    qemudDomainSetMaxMemory, /* domainSetMaxMemory */
    qemudDomainSetMemory, /* domainSetMemory */
7065 7066 7067
    qemudDomainGetInfo, /* domainGetInfo */
    qemudDomainSave, /* domainSave */
    qemudDomainRestore, /* domainRestore */
P
Paolo Bonzini 已提交
7068
    qemudDomainCoreDump, /* domainCoreDump */
7069
    qemudDomainSetVcpus, /* domainSetVcpus */
7070 7071 7072 7073
#if HAVE_SCHED_GETAFFINITY
    qemudDomainPinVcpu, /* domainPinVcpu */
    qemudDomainGetVcpus, /* domainGetVcpus */
#else
7074 7075
    NULL, /* domainPinVcpu */
    NULL, /* domainGetVcpus */
7076
#endif
7077
    qemudDomainGetMaxVcpus, /* domainGetMaxVcpus */
7078 7079
    qemudDomainGetSecurityLabel, /* domainGetSecurityLabel */
    qemudNodeGetSecurityModel, /* nodeGetSecurityModel */
7080
    qemudDomainDumpXML, /* domainDumpXML */
7081
    qemuDomainXMLFromNative, /* domainXmlFromNative */
7082
    qemuDomainXMLToNative, /* domainXMLToNative */
7083 7084
    qemudListDefinedDomains, /* listDefinedDomains */
    qemudNumDefinedDomains, /* numOfDefinedDomains */
7085 7086 7087
    qemudDomainStart, /* domainCreate */
    qemudDomainDefine, /* domainDefineXML */
    qemudDomainUndefine, /* domainUndefine */
7088
    qemudDomainAttachDevice, /* domainAttachDevice */
7089
    qemudDomainDetachDevice, /* domainDetachDevice */
7090 7091
    qemudDomainGetAutostart, /* domainGetAutostart */
    qemudDomainSetAutostart, /* domainSetAutostart */
7092 7093 7094
    qemuGetSchedulerType, /* domainGetSchedulerType */
    qemuGetSchedulerParameters, /* domainGetSchedulerParameters */
    qemuSetSchedulerParameters, /* domainSetSchedulerParameters */
D
Daniel Veillard 已提交
7095 7096
    NULL, /* domainMigratePrepare (v1) */
    qemudDomainMigratePerform, /* domainMigratePerform */
7097
    NULL, /* domainMigrateFinish */
7098
    qemudDomainBlockStats, /* domainBlockStats */
7099
    qemudDomainInterfaceStats, /* domainInterfaceStats */
7100
    qemudDomainBlockPeek, /* domainBlockPeek */
R
Richard W.M. Jones 已提交
7101
    qemudDomainMemoryPeek, /* domainMemoryPeek */
7102 7103
    nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
    nodeGetFreeMemory,  /* getFreeMemory */
7104 7105
    qemudDomainEventRegister, /* domainEventRegister */
    qemudDomainEventDeregister, /* domainEventDeregister */
D
Daniel Veillard 已提交
7106 7107
    qemudDomainMigratePrepare2, /* domainMigratePrepare2 */
    qemudDomainMigrateFinish2, /* domainMigrateFinish2 */
7108 7109 7110
    qemudNodeDeviceDettach, /* nodeDeviceDettach */
    qemudNodeDeviceReAttach, /* nodeDeviceReAttach */
    qemudNodeDeviceReset, /* nodeDeviceReset */
7111 7112 7113
};


7114
static virStateDriver qemuStateDriver = {
7115 7116 7117 7118
    .initialize = qemudStartup,
    .cleanup = qemudShutdown,
    .reload = qemudReload,
    .active = qemudActive,
7119
};
7120

7121
int qemuRegister(void) {
7122 7123 7124 7125
    virRegisterDriver(&qemuDriver);
    virRegisterStateDriver(&qemuStateDriver);
    return 0;
}