qemu_driver.c 259.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, 2010 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
#include <sys/types.h>
#include <sys/poll.h>
28
#include <sys/time.h>
D
Daniel P. Berrange 已提交
29 30 31
#include <dirent.h>
#include <limits.h>
#include <string.h>
32
#include <stdbool.h>
D
Daniel P. Berrange 已提交
33 34 35 36 37 38
#include <stdio.h>
#include <strings.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
39
#include <sys/utsname.h>
40 41 42 43
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <paths.h>
44 45
#include <pwd.h>
#include <stdio.h>
46
#include <sys/wait.h>
47
#include <sys/ioctl.h>
48
#include <sys/un.h>
D
Daniel P. Berrange 已提交
49

50
#include "virterror_internal.h"
51
#include "logging.h"
52
#include "datatypes.h"
53 54
#include "qemu_driver.h"
#include "qemu_conf.h"
55
#include "qemu_monitor.h"
56
#include "qemu_monitor_text.h"
57
#include "qemu_bridge_filter.h"
J
Jim Meyering 已提交
58
#include "c-ctype.h"
59
#include "event.h"
60
#include "buf.h"
61
#include "util.h"
62
#include "nodeinfo.h"
63
#include "stats_linux.h"
64
#include "capabilities.h"
65
#include "memory.h"
66
#include "uuid.h"
67
#include "domain_conf.h"
68 69
#include "node_device_conf.h"
#include "pci.h"
70
#include "hostusb.h"
71
#include "processinfo.h"
72 73
#include "qemu_security_stacked.h"
#include "qemu_security_dac.h"
74
#include "cgroup.h"
C
Chris Lalancette 已提交
75
#include "libvirt_internal.h"
76
#include "xml.h"
77
#include "cpu/cpu.h"
78

79

80 81
#define VIR_FROM_THIS VIR_FROM_QEMU

82 83 84
typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate;
typedef qemuDomainObjPrivate *qemuDomainObjPrivatePtr;
struct _qemuDomainObjPrivate {
85 86 87 88 89
    virCond jobCond; /* Use in conjunction with main virDomainObjPtr lock */
    int jobActive; /* Non-zero if a job is active. Only 1 job is allowed at any time
                    * A job includes *all* monitor commands, even those just querying
                    * information, not merely actions */

90
    qemuMonitorPtr mon;
91
    virDomainChrDefPtr monConfig;
D
Daniel P. Berrange 已提交
92
    int monJSON;
93 94 95

    int nvcpupids;
    int *vcpupids;
96 97
};

98 99
static int qemudShutdown(void);

100 101
static void qemuDriverLock(struct qemud_driver *driver)
{
102
    virMutexLock(&driver->lock);
103 104 105
}
static void qemuDriverUnlock(struct qemud_driver *driver)
{
106
    virMutexUnlock(&driver->lock);
107 108
}

109 110 111
static void qemuDomainEventFlush(int timer, void *opaque);
static void qemuDomainEventQueue(struct qemud_driver *driver,
                                 virDomainEventPtr event);
112

113 114
static int qemudStartVMDaemon(virConnectPtr conn,
                              struct qemud_driver *driver,
115
                              virDomainObjPtr vm,
116 117
                              const char *migrateFrom,
                              int stdin_fd);
118

119 120
static void qemudShutdownVMDaemon(virConnectPtr conn,
                                  struct qemud_driver *driver,
121
                                  virDomainObjPtr vm);
122

123
static int qemudDomainGetMaxVcpus(virDomainPtr dom);
124

125
static int qemuDetectVcpuPIDs(virConnectPtr conn,
126
                              struct qemud_driver *driver,
127
                              virDomainObjPtr vm);
128

129 130 131
static int qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
                                       virDomainDefPtr def);

J
Jim Meyering 已提交
132
static struct qemud_driver *qemu_driver = NULL;
133

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148

static void *qemuDomainObjPrivateAlloc(void)
{
    qemuDomainObjPrivatePtr priv;

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

    return priv;
}

static void qemuDomainObjPrivateFree(void *data)
{
    qemuDomainObjPrivatePtr priv = data;

149 150 151
    virDomainChrDefFree(priv->monConfig);
    VIR_FREE(priv->vcpupids);

152 153 154 155 156 157 158 159 160
    /* This should never be non-NULL if we get here, but just in case... */
    if (priv->mon) {
        VIR_ERROR0("Unexpected QEMU monitor still active during domain deletion");
        qemuMonitorClose(priv->mon);
    }
    VIR_FREE(priv);
}


161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
static int qemuDomainObjPrivateXMLFormat(virBufferPtr buf, void *data)
{
    qemuDomainObjPrivatePtr priv = data;
    const char *monitorpath;

    /* priv->monitor_chr is set only for qemu */
    if (priv->monConfig) {
        switch (priv->monConfig->type) {
        case VIR_DOMAIN_CHR_TYPE_UNIX:
            monitorpath = priv->monConfig->data.nix.path;
            break;
        default:
        case VIR_DOMAIN_CHR_TYPE_PTY:
            monitorpath = priv->monConfig->data.file.path;
            break;
        }

        virBufferEscapeString(buf, "  <monitor path='%s'", monitorpath);
D
Daniel P. Berrange 已提交
179 180
        if (priv->monJSON)
            virBufferAddLit(buf, " json='1'");
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
        virBufferVSprintf(buf, " type='%s'/>\n",
                          virDomainChrTypeToString(priv->monConfig->type));
    }


    if (priv->nvcpupids) {
        int i;
        virBufferAddLit(buf, "  <vcpus>\n");
        for (i = 0 ; i < priv->nvcpupids ; i++) {
            virBufferVSprintf(buf, "    <vcpu pid='%d'/>\n", priv->vcpupids[i]);
        }
        virBufferAddLit(buf, "  </vcpus>\n");
    }

    return 0;
}

static int qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt, void *data)
{
    qemuDomainObjPrivatePtr priv = data;
    char *monitorpath;
    char *tmp;
    int n, i;
    xmlNodePtr *nodes = NULL;

    if (VIR_ALLOC(priv->monConfig) < 0) {
        virReportOOMError(NULL);
        goto error;
    }

211 212 213 214 215
    if (!(priv->monConfig->info.alias = strdup("monitor"))) {
        virReportOOMError(NULL);
        goto error;
    }

216 217 218 219 220 221 222 223 224 225 226 227 228 229
    if (!(monitorpath =
          virXPathString(NULL, "string(./monitor[1]/@path)", ctxt))) {
        qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("no monitor path"));
        goto error;
    }

    tmp = virXPathString(NULL, "string(./monitor[1]/@type)", ctxt);
    if (tmp)
        priv->monConfig->type = virDomainChrTypeFromString(tmp);
    else
        priv->monConfig->type = VIR_DOMAIN_CHR_TYPE_PTY;
    VIR_FREE(tmp);

230
    if (virXPathBoolean(NULL, "count(./monitor[@json = '1']) > 0", ctxt)) {
D
Daniel P. Berrange 已提交
231
        priv->monJSON = 1;
232 233 234
    } else {
        priv->monJSON = 0;
    }
D
Daniel P. Berrange 已提交
235

236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
    switch (priv->monConfig->type) {
    case VIR_DOMAIN_CHR_TYPE_PTY:
        priv->monConfig->data.file.path = monitorpath;
        break;
    case VIR_DOMAIN_CHR_TYPE_UNIX:
        priv->monConfig->data.nix.path = monitorpath;
        break;
    default:
        VIR_FREE(monitorpath);
        qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("unsupported monitor type '%s'"),
                         virDomainChrTypeToString(priv->monConfig->type));
        goto error;
    }

    n = virXPathNodeSet(NULL, "./vcpus/vcpu", ctxt, &nodes);
    if (n < 0)
        goto error;
    if (n) {
        priv->nvcpupids = n;
        if (VIR_REALLOC_N(priv->vcpupids, priv->nvcpupids) < 0) {
            virReportOOMError(NULL);
            goto error;
        }

        for (i = 0 ; i < n ; i++) {
            char *pidstr = virXMLPropString(nodes[i], "pid");
            if (!pidstr)
                goto error;

            if (virStrToLong_i(pidstr, NULL, 10, &(priv->vcpupids[i])) < 0) {
                VIR_FREE(pidstr);
                goto error;
            }
            VIR_FREE(pidstr);
        }
        VIR_FREE(nodes);
    }

    return 0;

error:
278 279
    virDomainChrDefFree(priv->monConfig);
    priv->monConfig = NULL;
280 281 282 283 284 285
    VIR_FREE(nodes);
    return -1;
}



286 287 288 289 290 291 292 293 294
/*
 * obj must be locked before calling, qemud_driver must NOT be locked
 *
 * This must be called by anything that will change the VM state
 * in any way, or anything that will use the QEMU monitor.
 *
 * Upon successful return, the object will have its ref count increased,
 * successful calls must be followed by EndJob eventually
 */
295 296 297 298

/* Give up waiting for mutex after 30 seconds */
#define QEMU_JOB_WAIT_TIME (1000ull * 30)

299 300 301 302
static int qemuDomainObjBeginJob(virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
static int qemuDomainObjBeginJob(virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
303 304 305 306 307 308 309 310 311 312
    struct timeval now;
    unsigned long long then;

    if (gettimeofday(&now, NULL) < 0) {
        virReportSystemError(NULL, errno, "%s",
                             _("cannot get time of day"));
        return -1;
    }
    then = (now.tv_sec * 1000ull) + (now.tv_usec / 1000);
    then += QEMU_JOB_WAIT_TIME;
313 314 315 316

    virDomainObjRef(obj);

    while (priv->jobActive) {
317
        if (virCondWaitUntil(&priv->jobCond, &obj->lock, then) < 0) {
318
            virDomainObjUnref(obj);
319 320 321 322 323 324
            if (errno == ETIMEDOUT)
                qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_TIMEOUT,
                                 "%s", _("cannot acquire state change lock"));
            else
                virReportSystemError(NULL, errno,
                                     "%s", _("cannot acquire job mutex"));
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
            return -1;
        }
    }
    priv->jobActive = 1;

    return 0;
}

/*
 * obj must be locked before calling, qemud_driver must be locked
 *
 * This must be called by anything that will change the VM state
 * in any way, or anything that will use the QEMU monitor.
 */
static int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
                                           virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
static int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
                                           virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
345 346 347 348 349 350 351 352 353 354
    struct timeval now;
    unsigned long long then;

    if (gettimeofday(&now, NULL) < 0) {
        virReportSystemError(NULL, errno, "%s",
                             _("cannot get time of day"));
        return -1;
    }
    then = (now.tv_sec * 1000ull) + (now.tv_usec / 1000);
    then += QEMU_JOB_WAIT_TIME;
355 356 357 358 359

    virDomainObjRef(obj);
    qemuDriverUnlock(driver);

    while (priv->jobActive) {
360
        if (virCondWaitUntil(&priv->jobCond, &obj->lock, then) < 0) {
361
            virDomainObjUnref(obj);
362 363 364 365 366 367
            if (errno == ETIMEDOUT)
                qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_TIMEOUT,
                                 "%s", _("cannot acquire state change lock"));
            else
                virReportSystemError(NULL, errno,
                                     "%s", _("cannot acquire job mutex"));
M
Matthias Bolte 已提交
368
            qemuDriverLock(driver);
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
            return -1;
        }
    }
    priv->jobActive = 1;

    virDomainObjUnlock(obj);
    qemuDriverLock(driver);
    virDomainObjLock(obj);

    return 0;
}

/*
 * obj must be locked before calling, qemud_driver does not matter
 *
 * To be called after completing the work associated with the
 * earlier  qemuDomainBeginJob() call
386 387 388
 *
 * Returns remaining refcount on 'obj', maybe 0 to indicated it
 * was deleted
389
 */
390
static int ATTRIBUTE_RETURN_CHECK qemuDomainObjEndJob(virDomainObjPtr obj)
391 392 393 394 395 396
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    priv->jobActive = 0;
    virCondSignal(&priv->jobCond);

397
    return virDomainObjUnref(obj);
398 399 400 401 402 403 404 405 406 407 408
}


/*
 * obj must be locked before calling, qemud_driver must be unlocked
 *
 * To be called immediately before any QEMU monitor API call
 * Must have alrady called qemuDomainObjBeginJob().
 *
 * To be followed with qemuDomainObjExitMonitor() once complete
 */
409 410 411 412 413
static void qemuDomainObjEnterMonitor(virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    qemuMonitorLock(priv->mon);
414
    qemuMonitorRef(priv->mon);
415
    virDomainObjUnlock(obj);
416 417 418
}


419 420 421 422
/* obj must NOT be locked before calling, qemud_driver must be unlocked
 *
 * Should be paired with an earlier  qemuDomainObjEnterMonitor() call
 */
423 424 425
static void qemuDomainObjExitMonitor(virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
426 427 428 429 430 431
    int refs;

    refs = qemuMonitorUnref(priv->mon);

    if (refs > 0)
        qemuMonitorUnlock(priv->mon);
432

433
    virDomainObjLock(obj);
434 435 436 437 438

    if (refs == 0) {
        virDomainObjUnref(obj);
        priv->mon = NULL;
    }
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
}


/*
 * obj must be locked before calling, qemud_driver must be locked
 *
 * To be called immediately before any QEMU monitor API call
 * Must have alrady called qemuDomainObjBeginJob().
 *
 * To be followed with qemuDomainObjExitMonitorWithDriver() once complete
 */
static void qemuDomainObjEnterMonitorWithDriver(struct qemud_driver *driver, virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    qemuMonitorLock(priv->mon);
455
    qemuMonitorRef(priv->mon);
456 457 458 459 460 461 462 463 464 465 466 467 468
    virDomainObjUnlock(obj);
    qemuDriverUnlock(driver);
}


/* obj must NOT be locked before calling, qemud_driver must be unlocked,
 * and will be locked after returning
 *
 * Should be paired with an earlier  qemuDomainObjEnterMonitor() call
 */
static void qemuDomainObjExitMonitorWithDriver(struct qemud_driver *driver, virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
469 470 471 472 473 474
    int refs;

    refs = qemuMonitorUnref(priv->mon);

    if (refs > 0)
        qemuMonitorUnlock(priv->mon);
475 476 477

    qemuDriverLock(driver);
    virDomainObjLock(obj);
478 479 480 481 482

    if (refs == 0) {
        virDomainObjUnref(obj);
        priv->mon = NULL;
    }
483 484 485
}


486 487 488 489 490 491 492 493 494
static int qemuCgroupControllerActive(struct qemud_driver *driver,
                                      int controller)
{
    if (driver->cgroup == NULL)
        return 0;
    if (driver->cgroupControllers & (1 << controller))
        return 1;
    return 0;
}
495

496
static int
497
qemudLogFD(virConnectPtr conn, struct qemud_driver *driver, const char* name)
498 499 500
{
    char logfile[PATH_MAX];
    mode_t logmode;
G
Guido Günther 已提交
501
    int ret, fd = -1;
502

503 504
    if ((ret = snprintf(logfile, sizeof(logfile), "%s/%s.log",
                        driver->logDir, name))
G
Guido Günther 已提交
505
        < 0 || ret >= sizeof(logfile)) {
506
        virReportOOMError(conn);
507 508 509 510
        return -1;
    }

    logmode = O_CREAT | O_WRONLY;
511 512
    /* Only logrotate files in /var/log, so only append if running privileged */
    if (driver->privileged)
513
        logmode |= O_APPEND;
514 515 516
    else
        logmode |= O_TRUNC;

517
    if ((fd = open(logfile, logmode, S_IRUSR | S_IWUSR)) < 0) {
518 519 520
        virReportSystemError(conn, errno,
                             _("failed to create logfile %s"),
                             logfile);
521 522
        return -1;
    }
523
    if (virSetCloseExec(fd) < 0) {
524 525
        virReportSystemError(conn, errno, "%s",
                             _("Unable to set VM logfile close-on-exec flag"));
526 527 528 529 530 531 532
        close(fd);
        return -1;
    }
    return fd;
}


533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
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) {
550 551 552
        virReportSystemError(conn, errno,
                             _("failed to create logfile %s"),
                             logfile);
553 554
        return -1;
    }
555
    if (virSetCloseExec(fd) < 0) {
556 557
        virReportSystemError(conn, errno, "%s",
                             _("Unable to set VM logfile close-on-exec flag"));
558 559 560 561
        close(fd);
        return -1;
    }
    if (lseek(fd, pos, SEEK_SET) < 0) {
562 563 564
        virReportSystemError(conn, errno,
                             _("Unable to seek to %lld in %s"),
                             (long long) pos, logfile);
565 566 567 568 569 570
        close(fd);
    }
    return fd;
}


571 572 573 574 575 576 577 578 579 580 581 582
struct qemuAutostartData {
    struct qemud_driver *driver;
    virConnectPtr conn;
};
static void
qemuAutostartDomain(void *payload, const char *name ATTRIBUTE_UNUSED, void *opaque)
{
    virDomainObjPtr vm = payload;
    struct qemuAutostartData *data = opaque;

    virDomainObjLock(vm);
    if (vm->autostart &&
D
Daniel P. Berrange 已提交
583
        !virDomainObjIsActive(vm)) {
584 585 586 587 588 589
        int ret;

        virResetLastError();
        ret = qemudStartVMDaemon(data->conn, data->driver, vm, NULL, -1);
        if (ret < 0) {
            virErrorPtr err = virGetLastError();
590
            VIR_ERROR(_("Failed to autostart VM '%s': %s"),
591 592 593 594 595 596 597 598 599 600 601 602 603 604
                      vm->def->name,
                      err ? err->message : "");
        } else {
            virDomainEventPtr event =
                virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STARTED,
                                         VIR_DOMAIN_EVENT_STARTED_BOOTED);
            if (event)
                qemuDomainEventQueue(data->driver, event);
        }
    }
    virDomainObjUnlock(vm);
}

605 606
static void
qemudAutostartConfigs(struct qemud_driver *driver) {
607 608 609 610 611
    /* 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
     */
612 613 614
    virConnectPtr conn = virConnectOpen(driver->privileged ?
                                        "qemu:///system" :
                                        "qemu:///session");
615
    /* Ignoring NULL conn which is mostly harmless here */
616
    struct qemuAutostartData data = { driver, conn };
617

618
    qemuDriverLock(driver);
619
    virHashForEach(driver->domains.objs, qemuAutostartDomain, &data);
620
    qemuDriverUnlock(driver);
621

622 623
    if (conn)
        virConnectClose(conn);
624 625
}

626 627 628 629 630 631 632 633 634 635 636 637 638

/**
 * 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)
{
639
    char ebuf[1024];
640 641 642
    char *file = NULL;

    if (virAsprintf(&file, "%s/%s.xml", driver->stateDir, vm->def->name) < 0) {
643
        virReportOOMError(conn);
D
Daniel Veillard 已提交
644
        return(-1);
645 646
    }

647 648
    if (unlink(file) < 0 && errno != ENOENT && errno != ENOTDIR)
        VIR_WARN(_("Failed to remove domain XML for %s: %s"),
D
Daniel Veillard 已提交
649 650 651
                 vm->def->name, virStrerror(errno, ebuf, sizeof(ebuf)));
    VIR_FREE(file);

652 653 654
    if (virFileDeletePid(driver->stateDir, vm->def->name) != 0)
        VIR_WARN(_("Failed to remove PID file for %s: %s"),
                 vm->def->name, virStrerror(errno, ebuf, sizeof(ebuf)));
655

D
Daniel Veillard 已提交
656

657
    return 0;
658 659
}

660 661 662 663 664 665 666 667 668 669 670 671 672 673

/*
 * This is a callback registered with a qemuMonitorPtr  instance,
 * and to be invoked when the monitor console hits an end of file
 * condition, or error, thus indicating VM shutdown should be
 * performed
 */
static void
qemuHandleMonitorEOF(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                     virDomainObjPtr vm,
                     int hasError) {
    struct qemud_driver *driver = qemu_driver;
    virDomainEventPtr event = NULL;

674
    VIR_DEBUG("Received EOF on %p '%s'", vm, vm->def->name);
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
    virDomainObjLock(vm);

    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     hasError ?
                                     VIR_DOMAIN_EVENT_STOPPED_FAILED :
                                     VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN);

    qemudShutdownVMDaemon(NULL, driver, vm);
    if (!vm->persistent)
        virDomainRemoveInactive(&driver->domains, vm);
    else
        virDomainObjUnlock(vm);

    if (event) {
        qemuDriverLock(driver);
        qemuDomainEventQueue(driver, event);
        qemuDriverUnlock(driver);
    }
}


697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
static virStorageEncryptionPtr
findDomainDiskEncryption(virConnectPtr conn, virDomainObjPtr vm,
                         const char *path)
{
    bool seen_volume;
    int i;

    seen_volume = false;
    for (i = 0; i < vm->def->ndisks; i++) {
        virDomainDiskDefPtr disk;

        disk = vm->def->disks[i];
        if (disk->src != NULL && STREQ(disk->src, path)) {
            seen_volume = true;
            if (disk->encryption != NULL)
                return disk->encryption;
        }
    }
    if (seen_volume)
        qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_DOMAIN,
                         _("missing <encryption> for volume %s"), path);
    else
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("unexpected passphrase request for volume %s"),
                         path);
    return NULL;
}


static int
findVolumeQcowPassphrase(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                         virConnectPtr conn,
                         virDomainObjPtr vm,
                         const char *path,
                         char **secretRet,
                         size_t *secretLen)
{
    virStorageEncryptionPtr enc;
    virSecretPtr secret;
    char *passphrase;
    unsigned char *data;
    size_t size;
739 740
    int ret = -1;

741
    virDomainObjLock(vm);
742 743 744 745

    if (!conn) {
        qemudReportError(NULL, NULL, NULL, VIR_ERR_NO_SUPPORT,
                         "%s", _("cannot find secrets without a connection"));
746
        goto cleanup;
747 748 749 750 751 752 753
    }

    if (conn->secretDriver == NULL ||
        conn->secretDriver->lookupByUUID == NULL ||
        conn->secretDriver->getValue == NULL) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SUPPORT, "%s",
                         _("secret storage not supported"));
754
        goto cleanup;
755 756 757 758 759 760 761 762 763 764 765 766
    }

    enc = findDomainDiskEncryption(conn, vm, path);
    if (enc == NULL)
        return -1;

    if (enc->format != VIR_STORAGE_ENCRYPTION_FORMAT_QCOW ||
        enc->nsecrets != 1 ||
        enc->secrets[0]->type !=
        VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_DOMAIN,
                         _("invalid <encryption> for volume %s"), path);
767
        goto cleanup;
768 769 770 771 772
    }

    secret = conn->secretDriver->lookupByUUID(conn,
                                              enc->secrets[0]->uuid);
    if (secret == NULL)
773
        goto cleanup;
774 775 776 777
    data = conn->secretDriver->getValue(secret, &size,
                                        VIR_SECRET_GET_VALUE_INTERNAL_CALL);
    virUnrefSecret(secret);
    if (data == NULL)
778
        goto cleanup;
779 780 781 782 783 784 785

    if (memchr(data, '\0', size) != NULL) {
        memset(data, 0, size);
        VIR_FREE(data);
        qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_SECRET,
                         _("format='qcow' passphrase for %s must not contain a "
                           "'\\0'"), path);
786
        goto cleanup;
787 788 789 790 791 792
    }

    if (VIR_ALLOC_N(passphrase, size + 1) < 0) {
        memset(data, 0, size);
        VIR_FREE(data);
        virReportOOMError(conn);
793
        goto cleanup;
794 795 796 797 798 799 800 801 802 803
    }
    memcpy(passphrase, data, size);
    passphrase[size] = '\0';

    memset(data, 0, size);
    VIR_FREE(data);

    *secretRet = passphrase;
    *secretLen = size;

804 805 806
    ret = 0;

cleanup:
807 808
    virDomainObjUnlock(vm);

809
    return ret;
810 811
}

812 813 814 815 816
static qemuMonitorCallbacks monitorCallbacks = {
    .eofNotify = qemuHandleMonitorEOF,
    .diskSecretLookup = findVolumeQcowPassphrase,
};

817
static int
818
qemuConnectMonitor(virDomainObjPtr vm)
819
{
820
    qemuDomainObjPrivatePtr priv = vm->privateData;
821

822 823 824 825
    /* Hold an extra reference because we can't allow 'vm' to be
     * deleted while the monitor is active */
    virDomainObjRef(vm);

826 827
    if ((priv->mon = qemuMonitorOpen(vm,
                                     priv->monConfig,
D
Daniel P. Berrange 已提交
828
                                     priv->monJSON,
829
                                     &monitorCallbacks)) == NULL) {
830
        VIR_ERROR(_("Failed to connect monitor for %s"), vm->def->name);
831
        return -1;
832
    }
833

834 835
    return 0;
}
836 837 838 839

/*
 * Open an existing VM's monitor, re-detect VCPU threads
 * and re-reserve the security labels in use
840
 */
841 842
static void
qemuReconnectDomain(void *payload, const char *name ATTRIBUTE_UNUSED, void *opaque)
843
{
844 845 846 847
    virDomainObjPtr obj = payload;
    struct qemud_driver *driver = opaque;

    virDomainObjLock(obj);
848

849 850 851 852
    VIR_DEBUG("Reconnect monitor to %p '%s'", obj, obj->def->name);

    /* XXX check PID liveliness & EXE path */
    if (qemuConnectMonitor(obj) < 0)
853
        goto error;
854

855 856 857 858
    if (qemuUpdateActivePciHostdevs(driver, obj->def) < 0) {
        goto error;
    }

859
    if (driver->securityDriver &&
860 861
        driver->securityDriver->domainReserveSecurityLabel &&
        driver->securityDriver->domainReserveSecurityLabel(NULL, obj) < 0)
862
        goto error;
863

864 865
    if (obj->def->id >= driver->nextvmid)
        driver->nextvmid = obj->def->id + 1;
866

867 868
    virDomainObjUnlock(obj);
    return;
869

870
error:
871 872 873 874
    /* We can't get the monitor back, so must kill the VM
     * to remove danger of it ending up running twice if
     * user tries to start it again later */
    qemudShutdownVMDaemon(NULL, driver, obj);
875 876 877 878
    if (!obj->persistent)
        virDomainRemoveInactive(&driver->domains, obj);
    else
        virDomainObjUnlock(obj);
879
}
880

881
/**
882
 * qemudReconnectDomains
883 884 885 886 887 888 889
 *
 * Try to re-open the resources for live VMs that we care
 * about.
 */
static void
qemuReconnectDomains(struct qemud_driver *driver)
{
890
    virHashForEach(driver->domains.objs, qemuReconnectDomain, driver);
891 892
}

893

894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
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;
    }

912 913 914 915 916 917
    qemuSecurityStackedSetDriver(qemud_drv);
    qemuSecurityDACSetDriver(qemud_drv);

    qemud_drv->securityPrimaryDriver = security_drv;
    qemud_drv->securitySecondaryDriver = &qemuDACSecurityDriver;
    qemud_drv->securityDriver = &qemuStackedSecurityDriver;
918

919
    VIR_INFO("Initialized security driver %s", security_drv->name);
920
    return 0;
921
}
922 923


924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
static virCapsPtr
qemuCreateCapabilities(virCapsPtr oldcaps,
                       virSecurityDriverPtr secDriver)
{
    virCapsPtr caps;

    /* Basic host arch / guest machine capabilities */
    if (!(caps = qemudCapsInit(oldcaps))) {
        virReportOOMError(NULL);
        return NULL;
    }

    /* Domain XML parser hooks */
    caps->privateDataAllocFunc = qemuDomainObjPrivateAlloc;
    caps->privateDataFreeFunc = qemuDomainObjPrivateFree;
    caps->privateDataXMLFormat = qemuDomainObjPrivateXMLFormat;
    caps->privateDataXMLParse = qemuDomainObjPrivateXMLParse;


    /* Security driver data */
    if (secDriver) {
        const char *doi, *model;

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

        if (!(caps->host.secModel.model = strdup(model)))
            goto no_memory;
        if (!(caps->host.secModel.doi = strdup(doi)))
            goto no_memory;

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

    return caps;

no_memory:
    virReportOOMError(NULL);
    virCapabilitiesFree(caps);
    return NULL;
}
966

967 968 969 970 971 972
/**
 * qemudStartup:
 *
 * Initialization function for the QEmu daemon
 */
static int
973
qemudStartup(int privileged) {
974
    char *base = NULL;
D
Daniel P. Berrange 已提交
975
    char driverConf[PATH_MAX];
976
    int rc;
977

978
    if (VIR_ALLOC(qemu_driver) < 0)
979 980
        return -1;

981
    if (virMutexInit(&qemu_driver->lock) < 0) {
982
        VIR_ERROR("%s", _("cannot initialize mutex"));
983 984 985
        VIR_FREE(qemu_driver);
        return -1;
    }
986
    qemuDriverLock(qemu_driver);
987
    qemu_driver->privileged = privileged;
988

989 990 991
    /* Don't have a dom0 so start from 1 */
    qemu_driver->nextvmid = 1;

992 993 994
    if (virDomainObjListInit(&qemu_driver->domains) < 0)
        goto out_of_memory;

995
    /* Init callback list */
996
    if (VIR_ALLOC(qemu_driver->domainEventCallbacks) < 0)
997
        goto out_of_memory;
998 999 1000 1001 1002 1003
    if (!(qemu_driver->domainEventQueue = virDomainEventQueueNew()))
        goto out_of_memory;

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

1005
    if (privileged) {
1006 1007
        if (virAsprintf(&qemu_driver->logDir,
                        "%s/log/libvirt/qemu", LOCAL_STATE_DIR) == -1)
1008
            goto out_of_memory;
1009

D
Daniel P. Berrange 已提交
1010
        if ((base = strdup (SYSCONF_DIR "/libvirt")) == NULL)
1011
            goto out_of_memory;
1012 1013

        if (virAsprintf(&qemu_driver->stateDir,
1014
                      "%s/run/libvirt/qemu", LOCAL_STATE_DIR) == -1)
1015
            goto out_of_memory;
1016 1017 1018 1019 1020 1021 1022 1023

        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;
1024
    } else {
1025
        uid_t uid = geteuid();
1026 1027
        char *userdir = virGetUserDirectory(NULL, uid);
        if (!userdir)
1028
            goto error;
1029

1030
        if (virAsprintf(&qemu_driver->logDir,
1031 1032
                        "%s/.libvirt/qemu/log", userdir) == -1) {
            VIR_FREE(userdir);
1033
            goto out_of_memory;
1034
        }
1035

1036 1037
        if (virAsprintf(&base, "%s/.libvirt", userdir) == -1) {
            VIR_FREE(userdir);
1038
            goto out_of_memory;
1039 1040
        }
        VIR_FREE(userdir);
1041 1042 1043

        if (virAsprintf(&qemu_driver->stateDir, "%s/qemu/run", base) == -1)
            goto out_of_memory;
1044 1045 1046 1047
        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;
1048 1049
    }

L
Laine Stump 已提交
1050
    if (virFileMakePath(qemu_driver->stateDir) != 0) {
1051
        char ebuf[1024];
1052
        VIR_ERROR(_("Failed to create state dir '%s': %s"),
1053
                  qemu_driver->stateDir, virStrerror(errno, ebuf, sizeof ebuf));
1054
        goto error;
1055
    }
L
Laine Stump 已提交
1056
    if (virFileMakePath(qemu_driver->libDir) != 0) {
1057
        char ebuf[1024];
1058
        VIR_ERROR(_("Failed to create lib dir '%s': %s"),
1059 1060 1061
                  qemu_driver->libDir, virStrerror(errno, ebuf, sizeof ebuf));
        goto error;
    }
L
Laine Stump 已提交
1062
    if (virFileMakePath(qemu_driver->cacheDir) != 0) {
1063
        char ebuf[1024];
1064
        VIR_ERROR(_("Failed to create cache dir '%s': %s"),
1065 1066 1067
                  qemu_driver->cacheDir, virStrerror(errno, ebuf, sizeof ebuf));
        goto error;
    }
1068 1069 1070 1071

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

1076
    if (virAsprintf(&qemu_driver->configDir, "%s/qemu", base) == -1)
1077 1078
        goto out_of_memory;

1079
    if (virAsprintf(&qemu_driver->autostartDir, "%s/qemu/autostart", base) == -1)
1080 1081
        goto out_of_memory;

1082
    VIR_FREE(base);
1083

1084 1085 1086 1087 1088 1089 1090
    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)));
    }

1091 1092
    if (qemudSecurityInit(qemu_driver) < 0)
        goto error;
D
Daniel P. Berrange 已提交
1093

1094 1095 1096
    if ((qemu_driver->caps = qemuCreateCapabilities(NULL,
                                                    qemu_driver->securityDriver)) == NULL)
        goto error;
1097

1098 1099 1100
    if ((qemu_driver->activePciHostdevs = pciDeviceListNew(NULL)) == NULL)
        goto error;

1101
    if (qemudLoadDriverConfig(qemu_driver, driverConf) < 0) {
1102 1103 1104
        goto error;
    }

1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
    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;
        }
    }

1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
    /* 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;
    }

1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
    /* 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 */
1163 1164 1165 1166
    if (virDomainLoadAllConfigs(NULL,
                                qemu_driver->caps,
                                &qemu_driver->domains,
                                qemu_driver->configDir,
1167
                                qemu_driver->autostartDir,
1168
                                0, NULL, NULL) < 0)
1169
        goto error;
1170 1171
    qemuDriverUnlock(qemu_driver);

1172 1173
    qemudAutostartConfigs(qemu_driver);

1174

1175 1176
    return 0;

1177
out_of_memory:
1178
    virReportOOMError(NULL);
1179 1180 1181
error:
    if (qemu_driver)
        qemuDriverUnlock(qemu_driver);
1182
    VIR_FREE(base);
1183
    qemudShutdown();
1184 1185 1186
    return -1;
}

1187 1188 1189 1190
static void qemudNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
{
    struct qemud_driver *driver = opaque;

1191 1192 1193 1194 1195 1196 1197 1198
    if (newVM) {
        virDomainEventPtr event =
            virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_DEFINED,
                                     VIR_DOMAIN_EVENT_DEFINED_ADDED);
        if (event)
            qemuDomainEventQueue(driver, event);
    }
1199 1200
}

1201 1202 1203 1204 1205 1206 1207 1208
/**
 * qemudReload:
 *
 * Function to restart the QEmu daemon, it will recheck the configuration
 * files and update its state and the networking
 */
static int
qemudReload(void) {
1209 1210 1211
    if (!qemu_driver)
        return 0;

1212
    qemuDriverLock(qemu_driver);
1213 1214 1215 1216
    virDomainLoadAllConfigs(NULL,
                            qemu_driver->caps,
                            &qemu_driver->domains,
                            qemu_driver->configDir,
1217
                            qemu_driver->autostartDir,
1218
                            0, qemudNotifyLoadDomain, qemu_driver);
1219
    qemuDriverUnlock(qemu_driver);
1220

1221
    qemudAutostartConfigs(qemu_driver);
1222 1223

    return 0;
1224 1225
}

1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
/**
 * 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) {
1236
    int active = 0;
1237

1238 1239 1240
    if (!qemu_driver)
        return 0;

1241
    /* XXX having to iterate here is not great because it requires many locks */
1242
    qemuDriverLock(qemu_driver);
1243
    active = virDomainObjListNumOfDomains(&qemu_driver->domains, 1);
1244 1245
    qemuDriverUnlock(qemu_driver);
    return active;
1246 1247
}

1248 1249 1250 1251 1252 1253 1254
/**
 * qemudShutdown:
 *
 * Shutdown the QEmu daemon, it will stop all active domains and networks
 */
static int
qemudShutdown(void) {
1255
    int i;
1256

1257
    if (!qemu_driver)
1258
        return -1;
1259

1260
    qemuDriverLock(qemu_driver);
1261
    pciDeviceListFree(NULL, qemu_driver->activePciHostdevs);
1262 1263
    virCapabilitiesFree(qemu_driver->caps);

1264
    virDomainObjListDeinit(&qemu_driver->domains);
1265

1266
    VIR_FREE(qemu_driver->securityDriverName);
1267
    VIR_FREE(qemu_driver->logDir);
1268 1269
    VIR_FREE(qemu_driver->configDir);
    VIR_FREE(qemu_driver->autostartDir);
1270
    VIR_FREE(qemu_driver->stateDir);
1271 1272
    VIR_FREE(qemu_driver->libDir);
    VIR_FREE(qemu_driver->cacheDir);
1273
    VIR_FREE(qemu_driver->vncTLSx509certdir);
J
Jim Meyering 已提交
1274
    VIR_FREE(qemu_driver->vncListen);
1275
    VIR_FREE(qemu_driver->vncPassword);
1276
    VIR_FREE(qemu_driver->vncSASLdir);
1277
    VIR_FREE(qemu_driver->saveImageFormat);
1278 1279
    VIR_FREE(qemu_driver->hugetlbfs_mount);
    VIR_FREE(qemu_driver->hugepage_path);
D
Daniel P. Berrange 已提交
1280

1281 1282 1283 1284 1285 1286
    if (qemu_driver->cgroupDeviceACL) {
        for (i = 0 ; qemu_driver->cgroupDeviceACL[i] != NULL ; i++)
            VIR_FREE(qemu_driver->cgroupDeviceACL[i]);
        VIR_FREE(qemu_driver->cgroupDeviceACL);
    }

1287 1288
    /* Free domain callback list */
    virDomainEventCallbackListFree(qemu_driver->domainEventCallbacks);
1289 1290 1291 1292
    virDomainEventQueueFree(qemu_driver->domainEventQueue);

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

1294 1295 1296
    if (qemu_driver->brctl)
        brShutdown(qemu_driver->brctl);

1297 1298
    virCgroupFree(&qemu_driver->cgroup);

1299
    qemuDriverUnlock(qemu_driver);
1300
    virMutexDestroy(&qemu_driver->lock);
1301
    VIR_FREE(qemu_driver);
1302 1303

    return 0;
1304 1305
}

1306 1307 1308 1309
typedef int qemuLogHandleOutput(virConnectPtr conn,
                                virDomainObjPtr vm,
                                const char *output,
                                int fd);
1310 1311 1312 1313 1314 1315 1316 1317 1318

/*
 * Returns -1 for error, 0 on success
 */
static int
qemudReadLogOutput(virConnectPtr conn,
                   virDomainObjPtr vm,
                   int fd,
                   char *buf,
G
Guido Günther 已提交
1319
                   size_t buflen,
1320
                   qemuLogHandleOutput func,
1321 1322 1323
                   const char *what,
                   int timeout)
{
1324
    int retries = (timeout*10);
1325
    int got = 0;
1326 1327 1328
    buf[0] = '\0';

    while (retries) {
1329
        ssize_t func_ret, ret;
1330
        int isdead = 0;
G
Guido Günther 已提交
1331

1332 1333
        func_ret = func(conn, vm, buf, fd);

1334 1335
        if (kill(vm->pid, 0) == -1 && errno == ESRCH)
            isdead = 1;
1336

1337 1338
        /* Any failures should be detected before we read the log, so we
         * always have something useful to report on failure. */
1339 1340
        ret = saferead(fd, buf+got, buflen-got-1);
        if (ret < 0) {
1341 1342 1343 1344 1345 1346
            virReportSystemError(conn, errno,
                                 _("Failure while reading %s log output"),
                                 what);
            return -1;
        }

1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
        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;
        }

1363 1364
        if (func_ret <= 0)
            return func_ret;
1365 1366 1367 1368

        usleep(100*1000);
        retries--;
    }
1369 1370 1371

    qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                     _("Timed out while reading %s log output"), what);
1372 1373 1374
    return -1;
}

1375

1376 1377 1378 1379 1380 1381 1382 1383
/*
 * Look at a chunk of data from the QEMU stdout logs and try to
 * find a TTY device, as indicated by a line like
 *
 * char device redirected to /dev/pts/3
 *
 * Returns -1 for error, 0 success, 1 continue reading
 */
1384
static int
1385 1386 1387 1388
qemudExtractTTYPath(virConnectPtr conn,
                    const char *haystack,
                    size_t *offset,
                    char **path)
1389
{
1390
    static const char needle[] = "char device redirected to";
1391
    char *tmp, *dev;
1392

1393
    VIR_FREE(*path);
1394
    /* First look for our magic string */
1395 1396 1397 1398 1399
    if (!(tmp = strstr(haystack + *offset, needle))) {
        return 1;
    }
    tmp += sizeof(needle);
    dev = tmp;
1400

1401 1402 1403 1404 1405
    /*
     * And look for first whitespace character and nul terminate
     * to mark end of the pty path
     */
    while (*tmp) {
1406
        if (c_isspace(*tmp)) {
1407 1408
            *path = strndup(dev, tmp-dev);
            if (*path == NULL) {
1409
                virReportOOMError(conn);
1410 1411
                return -1;
            }
1412

1413
            /* ... now further update offset till we get EOL */
1414
            *offset = tmp - haystack;
1415 1416
            return 0;
        }
1417
        tmp++;
1418 1419 1420 1421 1422
    }

    /*
     * We found a path, but didn't find any whitespace,
     * so it must be still incomplete - we should at
1423 1424
     * least see a \n - indicate that we want to carry
     * on trying again
1425
     */
1426
    return 1;
1427 1428
}

1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
static int
qemudFindCharDevicePTYsMonitor(virConnectPtr conn,
                               virDomainObjPtr vm,
                               virHashTablePtr paths)
{
    int i;

#define LOOKUP_PTYS(array, arraylen, idprefix)                            \
    for (i = 0 ; i < (arraylen) ; i++) {                                  \
        virDomainChrDefPtr chr = (array)[i];                              \
        if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {                       \
            char id[16];                                                  \
                                                                          \
            if (snprintf(id, sizeof(id), idprefix "%i", i) >= sizeof(id)) \
                return -1;                                                \
                                                                          \
            const char *path = (const char *) virHashLookup(paths, id);   \
            if (path == NULL) {                                           \
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
                if (chr->data.file.path == NULL) {                        \
                    /* neither the log output nor 'info chardev' had a */ \
                    /* pty path for this chardev, report an error */      \
                    qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, \
                                     _("no assigned pty for device %s"), id);  \
                    return -1;                                                 \
                } else {                                                  \
                    /* 'info chardev' had no pty path for this chardev, */\
                    /* but the log output had, so we're fine */           \
                    continue;                                             \
                }                                                         \
1458 1459
            }                                                             \
                                                                          \
1460
            VIR_FREE(chr->data.file.path);                                \
1461
            chr->data.file.path = strdup(path);                           \
1462 1463 1464 1465 1466
                                                                          \
            if (chr->data.file.path == NULL) {                            \
                virReportOOMError(conn);                                  \
                return -1;                                                \
            }                                                             \
1467 1468 1469 1470 1471 1472
        }                                                                 \
    }

    LOOKUP_PTYS(vm->def->serials,   vm->def->nserials,   "serial");
    LOOKUP_PTYS(vm->def->parallels, vm->def->nparallels, "parallel");
    LOOKUP_PTYS(vm->def->channels,  vm->def->nchannels,  "channel");
1473
#undef LOOKUP_PTYS
1474 1475 1476 1477

    return 0;
}

1478
static int
1479
qemudFindCharDevicePTYs(virConnectPtr conn,
1480
                        virDomainObjPtr vm,
1481 1482
                        const char *output,
                        int fd ATTRIBUTE_UNUSED)
1483
{
1484
    size_t offset = 0;
1485
    int ret, i;
1486 1487

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

1491
    /* first comes the serial devices */
1492 1493
    for (i = 0 ; i < vm->def->nserials ; i++) {
        virDomainChrDefPtr chr = vm->def->serials[i];
1494
        if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
1495 1496
            if ((ret = qemudExtractTTYPath(conn, output, &offset,
                                           &chr->data.file.path)) != 0)
1497
                return ret;
1498 1499 1500
        }
    }

1501
    /* then the parallel devices */
1502 1503
    for (i = 0 ; i < vm->def->nparallels ; i++) {
        virDomainChrDefPtr chr = vm->def->parallels[i];
1504
        if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
1505 1506
            if ((ret = qemudExtractTTYPath(conn, output, &offset,
                                           &chr->data.file.path)) != 0)
1507
                return ret;
1508 1509 1510
        }
    }

1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
    /* then the channel devices */
    for (i = 0 ; i < vm->def->nchannels ; i++) {
        virDomainChrDefPtr chr = vm->def->channels[i];
        if (chr->type == VIR_DOMAIN_CHR_TYPE_PTY) {
            if ((ret = qemudExtractTTYPath(conn, output, &offset,
                                           &chr->data.file.path)) != 0)
                return ret;
        }
    }

1521
    return 0;
1522 1523
}

1524 1525 1526 1527 1528
static void qemudFreePtyPath(void *payload, const char *name ATTRIBUTE_UNUSED)
{
    VIR_FREE(payload);
}

1529 1530 1531 1532
static int
qemudWaitForMonitor(virConnectPtr conn,
                    struct qemud_driver* driver,
                    virDomainObjPtr vm, off_t pos)
1533
{
1534
    char buf[4096]; /* Plenty of space to get startup greeting */
1535
    int logfd;
1536
    int ret = -1;
1537 1538 1539

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

1542 1543 1544
    ret = qemudReadLogOutput(conn, vm, logfd, buf, sizeof(buf),
                             qemudFindCharDevicePTYs,
                             "console", 3);
1545
    if (close(logfd) < 0) {
1546
        char ebuf[4096];
1547
        VIR_WARN(_("Unable to close logfile: %s"),
1548 1549
                 virStrerror(errno, ebuf, sizeof ebuf));
    }
1550

1551 1552 1553 1554 1555 1556
    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;
    }
1557

1558 1559
    VIR_DEBUG("Connect monitor to %p '%s'", vm, vm->def->name);
    if (qemuConnectMonitor(vm) < 0)
1560 1561
        return -1;

1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
    /* Try to get the pty path mappings again via the monitor. This is much more
     * reliable if it's available.
     * Note that the monitor itself can be on a pty, so we still need to try the
     * log output method. */
    virHashTablePtr paths = virHashCreate(0);
    if (paths == NULL) {
        virReportOOMError(NULL);
        goto cleanup;
    }

1572
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
1573 1574
    qemuDomainObjPrivatePtr priv = vm->privateData;
    ret = qemuMonitorGetPtyPaths(priv->mon, paths);
1575
    qemuDomainObjExitMonitorWithDriver(driver, vm);
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587

    VIR_DEBUG("qemuMonitorGetPtyPaths returned %i", ret);
    if (ret == 0) {
        ret = qemudFindCharDevicePTYsMonitor(conn, vm, paths);
    }

cleanup:
    if (paths) {
        virHashFree(paths, qemudFreePtyPath);
    }

    return ret;
1588 1589
}

1590
static int
1591
qemuDetectVcpuPIDs(virConnectPtr conn,
1592
                   struct qemud_driver *driver,
1593 1594 1595
                   virDomainObjPtr vm) {
    pid_t *cpupids = NULL;
    int ncpupids;
1596
    qemuDomainObjPrivatePtr priv = vm->privateData;
1597

1598
    if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM) {
1599 1600
        priv->nvcpupids = 1;
        if (VIR_ALLOC_N(priv->vcpupids, priv->nvcpupids) < 0) {
1601 1602 1603
            virReportOOMError(conn);
            return -1;
        }
1604
        priv->vcpupids[0] = vm->pid;
1605 1606 1607
        return 0;
    }

1608
    /* What follows is now all KVM specific */
1609

1610
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
1611
    if ((ncpupids = qemuMonitorGetCPUInfo(priv->mon, &cpupids)) < 0) {
1612
        qemuDomainObjExitMonitorWithDriver(driver, vm);
1613
        return -1;
1614
    }
1615
    qemuDomainObjExitMonitorWithDriver(driver, vm);
1616

1617 1618 1619
    /* Treat failure to get VCPU<->PID mapping as non-fatal */
    if (ncpupids == 0)
        return 0;
1620

1621 1622 1623 1624 1625 1626 1627
    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;
    }
1628

1629 1630
    priv->nvcpupids = ncpupids;
    priv->vcpupids = cpupids;
1631 1632 1633
    return 0;
}

1634
static int
1635 1636
qemudInitCpuAffinity(virConnectPtr conn,
                     virDomainObjPtr vm) {
1637
    int i, hostcpus, maxcpu = QEMUD_CPUMASK_LEN;
1638
    virNodeInfo nodeinfo;
1639 1640
    unsigned char *cpumap;
    int cpumaplen;
1641
    qemuDomainObjPrivatePtr priv = vm->privateData;
1642

1643
    if (nodeGetInfo(conn, &nodeinfo) < 0)
1644 1645 1646 1647
        return -1;

    /* setaffinity fails if you set bits for CPUs which
     * aren't present, so we have to limit ourselves */
1648 1649 1650
    hostcpus = VIR_NODEINFO_MAXCPUS(nodeinfo);
    if (maxcpu > hostcpus)
        maxcpu = hostcpus;
1651

1652 1653 1654 1655 1656 1657
    cpumaplen = VIR_CPU_MAPLEN(maxcpu);
    if (VIR_ALLOC_N(cpumap, cpumaplen) < 0) {
        virReportOOMError(conn);
        return -1;
    }

D
Daniel P. Berrange 已提交
1658
    if (vm->def->cpumask) {
1659 1660 1661
        /* XXX why don't we keep 'cpumask' in the libvirt cpumap
         * format to start with ?!?! */
        for (i = 0 ; i < maxcpu && i < vm->def->cpumasklen ; i++)
D
Daniel P. Berrange 已提交
1662
            if (vm->def->cpumask[i])
1663
                VIR_USE_CPU(cpumap, i);
D
Daniel P. Berrange 已提交
1664
    } else {
1665 1666 1667 1668
        /* You may think this is redundant, but we can't assume libvirtd
         * itself is running on all pCPUs, so we need to explicitly set
         * the spawned QEMU instance to all pCPUs if no map is given in
         * its config file */
D
Daniel P. Berrange 已提交
1669
        for (i = 0 ; i < maxcpu ; i++)
1670
            VIR_USE_CPU(cpumap, i);
D
Daniel P. Berrange 已提交
1671
    }
1672

1673 1674
    /* The XML config only gives a per-VM affinity, so we apply
     * the same mapping to all vCPUs */
1675 1676
    for (i = 0 ; i < priv->nvcpupids ; i++) {
        if (virProcessInfoSetAffinity(priv->vcpupids[i],
1677 1678
                                      cpumap, cpumaplen, maxcpu) < 0) {
            VIR_FREE(cpumap);
1679 1680 1681
            return -1;
        }
    }
1682
    VIR_FREE(cpumap);
1683 1684 1685 1686 1687

    return 0;
}


1688
static int
1689 1690
qemuInitPasswords(struct qemud_driver *driver,
                  virDomainObjPtr vm) {
1691
    int ret = 0;
1692
    qemuDomainObjPrivatePtr priv = vm->privateData;
1693

1694 1695 1696
    if ((vm->def->ngraphics == 1) &&
        vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
        (vm->def->graphics[0]->data.vnc.passwd || driver->vncPassword)) {
1697

1698
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
1699
        ret = qemuMonitorSetVNCPassword(priv->mon,
1700 1701 1702
                                        vm->def->graphics[0]->data.vnc.passwd ?
                                        vm->def->graphics[0]->data.vnc.passwd :
                                        driver->vncPassword);
1703
        qemuDomainObjExitMonitorWithDriver(driver, vm);
1704 1705
    }

1706
    return ret;
1707 1708 1709
}


1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
#define QEMU_PCI_VENDOR_INTEL     0x8086
#define QEMU_PCI_VENDOR_LSI_LOGIC 0x1000
#define QEMU_PCI_VENDOR_REDHAT    0x1af4
#define QEMU_PCI_VENDOR_CIRRUS    0x1013
#define QEMU_PCI_VENDOR_REALTEK   0x10ec
#define QEMU_PCI_VENDOR_AMD       0x1022
#define QEMU_PCI_VENDOR_ENSONIQ   0x1274
#define QEMU_PCI_VENDOR_VMWARE    0x15ad
#define QEMU_PCI_VENDOR_QEMU      0x1234

#define QEMU_PCI_PRODUCT_DISK_VIRTIO 0x1001

#define QEMU_PCI_PRODUCT_NIC_NE2K     0x8029
#define QEMU_PCI_PRODUCT_NIC_PCNET    0x2000
#define QEMU_PCI_PRODUCT_NIC_RTL8139  0x8139
#define QEMU_PCI_PRODUCT_NIC_E1000    0x100E
#define QEMU_PCI_PRODUCT_NIC_VIRTIO   0x1000

#define QEMU_PCI_PRODUCT_VGA_CIRRUS 0x00b8
#define QEMU_PCI_PRODUCT_VGA_VMWARE 0x0405
#define QEMU_PCI_PRODUCT_VGA_STDVGA 0x1111

#define QEMU_PCI_PRODUCT_AUDIO_AC97    0x2415
#define QEMU_PCI_PRODUCT_AUDIO_ES1370  0x5000

#define QEMU_PCI_PRODUCT_CONTROLLER_PIIX 0x7010
#define QEMU_PCI_PRODUCT_CONTROLLER_LSI  0x0012

#define QEMU_PCI_PRODUCT_WATCHDOG_I63000ESB 0x25ab

static int
qemuAssignNextPCIAddress(virDomainDeviceInfo *info,
                         int vendor,
                         int product,
                         qemuMonitorPCIAddress *addrs,
                         int naddrs)
{
    int found = 0;
    int i;

    VIR_DEBUG("Look for %x:%x out of %d", vendor, product, naddrs);

    for (i = 0 ; (i < naddrs) && !found; i++) {
        VIR_DEBUG("Maybe %x:%x", addrs[i].vendor, addrs[i].product);
        if (addrs[i].vendor == vendor &&
            addrs[i].product == product) {
            VIR_DEBUG("Match %d", i);
            found = 1;
            break;
        }
    }
    if (!found) {
        return -1;
    }

    /* Blank it out so this device isn't matched again */
    addrs[i].vendor = 0;
    addrs[i].product = 0;

    if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
        info->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;

    if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
        info->addr.pci.domain = addrs[i].addr.domain;
        info->addr.pci.bus = addrs[i].addr.bus;
        info->addr.pci.slot = addrs[i].addr.slot;
        info->addr.pci.function = addrs[i].addr.function;
    }

    return 0;
}

static int
qemuGetPCIDiskVendorProduct(virDomainDiskDefPtr def,
                            unsigned *vendor,
                            unsigned *product)
{
    switch (def->bus) {
    case VIR_DOMAIN_DISK_BUS_VIRTIO:
        *vendor = QEMU_PCI_VENDOR_REDHAT;
        *product = QEMU_PCI_PRODUCT_DISK_VIRTIO;
        break;

    default:
        return -1;
    }

    return 0;
}

static int
qemuGetPCINetVendorProduct(virDomainNetDefPtr def,
                            unsigned *vendor,
                            unsigned *product)
{
    if (!def->model)
        return -1;

    if (STREQ(def->model, "ne2k_pci")) {
        *vendor = QEMU_PCI_VENDOR_REALTEK;
        *product = QEMU_PCI_PRODUCT_NIC_NE2K;
    } else if (STREQ(def->model, "pcnet")) {
        *vendor = QEMU_PCI_VENDOR_AMD;
        *product = QEMU_PCI_PRODUCT_NIC_PCNET;
    } else if (STREQ(def->model, "rtl8139")) {
        *vendor = QEMU_PCI_VENDOR_REALTEK;
        *product = QEMU_PCI_PRODUCT_NIC_RTL8139;
    } else if (STREQ(def->model, "e1000")) {
        *vendor = QEMU_PCI_VENDOR_INTEL;
        *product = QEMU_PCI_PRODUCT_NIC_E1000;
    } else if (STREQ(def->model, "virtio")) {
        *vendor = QEMU_PCI_VENDOR_REDHAT;
        *product = QEMU_PCI_PRODUCT_NIC_VIRTIO;
    } else {
        VIR_INFO("Unexpected NIC model %s, cannot get PCI address",
                 def->model);
        return -1;
    }
    return 0;
}

static int
qemuGetPCIControllerVendorProduct(virDomainControllerDefPtr def,
                                  unsigned *vendor,
                                  unsigned *product)
{
    switch (def->type) {
    case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
        *vendor = QEMU_PCI_VENDOR_LSI_LOGIC;
        *product = QEMU_PCI_PRODUCT_CONTROLLER_LSI;
        break;

    case VIR_DOMAIN_CONTROLLER_TYPE_FDC:
        /* XXX we could put in the ISA bridge address, but
           that's not technically the FDC's address */
        return -1;

    case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
        *vendor = QEMU_PCI_VENDOR_INTEL;
        *product = QEMU_PCI_PRODUCT_CONTROLLER_PIIX;
        break;

    default:
        VIR_INFO("Unexpected controller type %s, cannot get PCI address",
                 virDomainControllerTypeToString(def->type));
        return -1;
    }

    return 0;
}

static int
qemuGetPCIVideoVendorProduct(virDomainVideoDefPtr def,
                             unsigned *vendor,
                             unsigned *product)
{
    switch (def->type) {
    case VIR_DOMAIN_VIDEO_TYPE_CIRRUS:
        *vendor = QEMU_PCI_VENDOR_CIRRUS;
        *product = QEMU_PCI_PRODUCT_VGA_CIRRUS;
        break;

    case VIR_DOMAIN_VIDEO_TYPE_VGA:
        *vendor = QEMU_PCI_VENDOR_QEMU;
        *product = QEMU_PCI_PRODUCT_VGA_STDVGA;
        break;

    case VIR_DOMAIN_VIDEO_TYPE_VMVGA:
        *vendor = QEMU_PCI_VENDOR_VMWARE;
        *product = QEMU_PCI_PRODUCT_VGA_VMWARE;
        break;

    default:
        return -1;
    }
    return 0;
}

static int
qemuGetPCISoundVendorProduct(virDomainSoundDefPtr def,
                             unsigned *vendor,
                             unsigned *product)
{
    switch (def->model) {
    case VIR_DOMAIN_SOUND_MODEL_ES1370:
        *vendor = QEMU_PCI_VENDOR_ENSONIQ;
        *product = QEMU_PCI_PRODUCT_AUDIO_ES1370;
        break;

    case VIR_DOMAIN_SOUND_MODEL_AC97:
        *vendor = QEMU_PCI_VENDOR_INTEL;
        *product = QEMU_PCI_PRODUCT_AUDIO_AC97;
        break;

    default:
        return -1;
    }

    return 0;
}

static int
qemuGetPCIWatchdogVendorProduct(virDomainWatchdogDefPtr def,
                                unsigned *vendor,
                                unsigned *product)
{
    switch (def->model) {
    case VIR_DOMAIN_WATCHDOG_MODEL_I6300ESB:
        *vendor = QEMU_PCI_VENDOR_INTEL;
        *product = QEMU_PCI_PRODUCT_WATCHDOG_I63000ESB;
        break;

    default:
        return -1;
    }

    return 0;
}


/*
 * This entire method assumes that PCI devices in 'info pci'
 * match ordering of devices specified on the command line
 * wrt to devices of matching vendor+product
 *
 * XXXX this might not be a valid assumption if we assign
 * some static addrs on CLI. Have to check that...
 */
static int
qemuAssignPCIAddresses(virDomainObjPtr vm,
                       qemuMonitorPCIAddress *addrs,
                       int naddrs)
{
    unsigned int vendor = 0, product = 0;
    int i;

    /* XXX should all these vendor/product IDs be kept in the
     * actual device data structure instead ?
     */

    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (qemuGetPCIDiskVendorProduct(vm->def->disks[i], &vendor, &product) < 0)
            continue;

        if (qemuAssignNextPCIAddress(&(vm->def->disks[i]->info),
                                     vendor, product,
                                     addrs, naddrs) < 0) {
            qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("cannot find PCI address for VirtIO disk %s"),
                             vm->def->disks[i]->dst);
            return -1;
        }
    }

    for (i = 0 ; i < vm->def->nnets ; i++) {
        if (qemuGetPCINetVendorProduct(vm->def->nets[i], &vendor, &product) < 0)
            continue;

        if (qemuAssignNextPCIAddress(&(vm->def->nets[i]->info),
                                     vendor, product,
                                     addrs,  naddrs) < 0) {
            qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("cannot find PCI address for %s NIC"),
                             vm->def->nets[i]->model);
            return -1;
        }
    }

    for (i = 0 ; i < vm->def->ncontrollers ; i++) {
        if (qemuGetPCIControllerVendorProduct(vm->def->controllers[i], &vendor, &product) < 0)
            continue;

        if (qemuAssignNextPCIAddress(&(vm->def->controllers[i]->info),
                                     vendor, product,
                                     addrs,  naddrs) < 0) {
            qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("cannot find PCI address for controller %s"),
                             virDomainControllerTypeToString(vm->def->controllers[i]->type));
            return -1;
        }
    }

    for (i = 0 ; i < vm->def->nvideos ; i++) {
        if (qemuGetPCIVideoVendorProduct(vm->def->videos[i], &vendor, &product) < 0)
            continue;

        if (qemuAssignNextPCIAddress(&(vm->def->videos[i]->info),
                                     vendor, product,
                                     addrs,  naddrs) < 0) {
            qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("cannot find PCI address for video adapter %s"),
                             virDomainVideoTypeToString(vm->def->videos[i]->type));
            return -1;
        }
    }

    for (i = 0 ; i < vm->def->nsounds ; i++) {
        if (qemuGetPCISoundVendorProduct(vm->def->sounds[i], &vendor, &product) < 0)
            continue;

        if (qemuAssignNextPCIAddress(&(vm->def->sounds[i]->info),
                                     vendor, product,
                                     addrs,  naddrs) < 0) {
            qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("cannot find PCI address for sound adapter %s"),
                             virDomainSoundModelTypeToString(vm->def->sounds[i]->model));
            return -1;
        }
    }


    if (vm->def->watchdog &&
        qemuGetPCIWatchdogVendorProduct(vm->def->watchdog, &vendor, &product) == 0) {
        if (qemuAssignNextPCIAddress(&(vm->def->watchdog->info),
                                     vendor, product,
                                     addrs,  naddrs) < 0) {
            qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("cannot find PCI address for watchdog %s"),
                             virDomainWatchdogModelTypeToString(vm->def->watchdog->model));
            return -1;
        }
    }

    /* XXX console (virtio) */


    /* ... and now things we don't have in our xml */

    /* XXX USB controller ? */

    /* XXXX virtio balloon ? */

    /* XXX what about other PCI devices (ie bridges) */

    return 0;
}

static int
qemuInitPCIAddresses(struct qemud_driver *driver,
                     virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int naddrs;
    int ret;
    qemuMonitorPCIAddress *addrs = NULL;

    qemuDomainObjEnterMonitorWithDriver(driver, vm);
    naddrs = qemuMonitorGetAllPCIAddresses(priv->mon,
                                           &addrs);
    qemuDomainObjExitMonitorWithDriver(driver, vm);

    ret = qemuAssignPCIAddresses(vm, addrs, naddrs);

    VIR_FREE(addrs);

    return ret;
}

2068
static int qemudNextFreeVNCPort(struct qemud_driver *driver ATTRIBUTE_UNUSED) {
2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
    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;
}

2104 2105 2106 2107 2108
static pciDeviceList *
qemuGetPciHostDeviceList(virConnectPtr conn,
                         virDomainDefPtr def)
{
    pciDeviceList *list;
2109 2110
    int i;

2111 2112
    if (!(list = pciDeviceListNew(conn)))
        return NULL;
2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127

    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);
2128 2129 2130 2131
        if (!dev) {
            pciDeviceListFree(conn, list);
            return NULL;
        }
2132

2133
        if (pciDeviceListAdd(conn, list, dev) < 0) {
2134
            pciFreeDevice(conn, dev);
2135 2136
            pciDeviceListFree(conn, list);
            return NULL;
2137 2138
        }

2139
        pciDeviceSetManaged(dev, hostdev->managed);
2140 2141
    }

2142 2143 2144 2145
    return list;
}

static int
2146 2147 2148 2149
qemuUpdateActivePciHostdevs(struct qemud_driver *driver,
                            virDomainDefPtr def)
{
    pciDeviceList *pcidevs;
2150
    int i;
2151
    int ret = -1;
2152 2153 2154 2155 2156 2157 2158

    if (!def->nhostdevs)
        return 0;

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

2159 2160 2161
    for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
        pciDevice *dev = pciDeviceListGet(pcidevs, i);
        pciDeviceListSteal(NULL, pcidevs, dev);
2162 2163
        if (pciDeviceListAdd(NULL,
                             driver->activePciHostdevs,
2164 2165 2166
                             dev) < 0) {
            pciFreeDevice(NULL, dev);
            goto cleanup;
2167 2168 2169
        }
    }

2170 2171 2172
    ret = 0;

cleanup:
2173 2174 2175 2176 2177 2178 2179 2180
    pciDeviceListFree(NULL, pcidevs);
    return ret;
}

static int
qemuPrepareHostDevices(virConnectPtr conn,
                       struct qemud_driver *driver,
                       virDomainDefPtr def)
2181 2182 2183
{
    pciDeviceList *pcidevs;
    int i;
2184
    int ret = -1;
2185 2186 2187 2188 2189 2190 2191

    if (!def->nhostdevs)
        return 0;

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

2192
    /* We have to use 3 loops here. *All* devices must
2193 2194
     * be detached before we reset any of them, because
     * in some cases you have to reset the whole PCI,
2195 2196
     * which impacts all devices on it. Also, all devices
     * must be reset before being marked as active.
2197 2198 2199 2200 2201 2202 2203
     */

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

2204 2205
    for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
        pciDevice *dev = pciDeviceListGet(pcidevs, i);
2206 2207 2208
        if (!pciDeviceIsAssignable(conn, dev, !driver->relaxedACS))
            goto cleanup;

2209 2210 2211 2212
        if (pciDeviceGetManaged(dev) &&
            pciDettachDevice(conn, dev) < 0)
            goto cleanup;
    }
2213 2214 2215

    /* Now that all the PCI hostdevs have be dettached, we can safely
     * reset them */
2216 2217 2218
    for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
        pciDevice *dev = pciDeviceListGet(pcidevs, i);
        if (pciResetDevice(conn, dev,
2219
                           driver->activePciHostdevs) < 0)
2220 2221
            goto cleanup;
    }
2222

2223
    /* Now mark all the devices as active */
2224 2225 2226
    for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
        pciDevice *dev = pciDeviceListGet(pcidevs, i);
        pciDeviceListSteal(NULL, pcidevs, dev);
2227 2228
        if (pciDeviceListAdd(conn,
                             driver->activePciHostdevs,
2229 2230 2231 2232
                             dev) < 0) {
            pciFreeDevice(NULL, dev);
            goto cleanup;
        }
2233 2234
    }

2235
    ret = 0;
2236

2237
cleanup:
2238
    pciDeviceListFree(conn, pcidevs);
2239
    return ret;
2240 2241
}

2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261
static void
qemudReattachManagedDevice(pciDevice *dev)
{
    int retries = 100;

    if (pciDeviceGetManaged(dev)) {
        while (pciWaitForDeviceCleanup(dev, "kvm_assigned_device")
               && retries) {
            usleep(100*1000);
            retries--;
        }
        if (pciReAttachDevice(NULL, dev) < 0) {
            virErrorPtr err = virGetLastError();
            VIR_ERROR(_("Failed to re-attach PCI device: %s"),
                      err ? err->message : "");
            virResetError(err);
        }
    }
}

2262
static void
2263 2264 2265
qemuDomainReAttachHostDevices(virConnectPtr conn,
                              struct qemud_driver *driver,
                              virDomainDefPtr def)
2266
{
2267
    pciDeviceList *pcidevs;
2268 2269
    int i;

2270 2271
    if (!def->nhostdevs)
        return;
2272

2273 2274
    if (!(pcidevs = qemuGetPciHostDeviceList(conn, def))) {
        virErrorPtr err = virGetLastError();
2275
        VIR_ERROR(_("Failed to allocate pciDeviceList: %s"),
2276 2277 2278
                  err ? err->message : "");
        virResetError(err);
        return;
2279 2280
    }

2281 2282
    /* Again 3 loops; mark all devices as inactive before reset
     * them and reset all the devices before re-attach */
2283

2284 2285 2286 2287
    for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
        pciDevice *dev = pciDeviceListGet(pcidevs, i);
        pciDeviceListDel(conn, driver->activePciHostdevs, dev);
    }
2288

2289 2290 2291
    for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
        pciDevice *dev = pciDeviceListGet(pcidevs, i);
        if (pciResetDevice(conn, dev,
2292
                           driver->activePciHostdevs) < 0) {
2293
            virErrorPtr err = virGetLastError();
2294
            VIR_ERROR(_("Failed to reset PCI device: %s"),
2295 2296 2297
                      err ? err->message : "");
            virResetError(err);
        }
2298
    }
2299

2300 2301
    for (i = 0; i < pciDeviceListCount(pcidevs); i++) {
        pciDevice *dev = pciDeviceListGet(pcidevs, i);
2302
        qemudReattachManagedDevice(dev);
2303
    }
2304

2305
    pciDeviceListFree(conn, pcidevs);
2306 2307
}

2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
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

2318 2319 2320 2321 2322 2323
static int qemuSetupCgroup(virConnectPtr conn,
                           struct qemud_driver *driver,
                           virDomainObjPtr vm)
{
    virCgroupPtr cgroup = NULL;
    int rc;
2324
    unsigned int i;
2325 2326 2327 2328
    const char *const *deviceACL =
        driver->cgroupDeviceACL ?
        (const char *const *)driver->cgroupDeviceACL :
        defaultDeviceACL;
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340

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

2341 2342
    if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
        rc = virCgroupDenyAllDevices(cgroup);
2343
        if (rc != 0) {
2344 2345 2346 2347 2348
            if (rc == -EPERM) {
                VIR_WARN0("Group devices ACL is not accessible, disabling whitelisting");
                goto done;
            }

2349
            virReportSystemError(conn, -rc,
2350
                                 _("Unable to deny all devices for %s"), vm->def->name);
2351 2352 2353
            goto cleanup;
        }

2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367
        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;
            }
        }
2368

2369
        rc = virCgroupAllowDeviceMajor(cgroup, 'c', DEVICE_PTY_MAJOR);
2370 2371
        if (rc != 0) {
            virReportSystemError(conn, -rc, "%s",
2372
                                 _("unable to allow /dev/pts/ devices"));
2373 2374 2375
            goto cleanup;
        }

2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394
        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;
            }
2395 2396 2397 2398
        }
    }

done:
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412
    virCgroupFree(&cgroup);
    return 0;

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


static int qemuRemoveCgroup(virConnectPtr conn,
                            struct qemud_driver *driver,
2413 2414
                            virDomainObjPtr vm,
                            int quiet)
2415 2416 2417 2418 2419 2420 2421 2422 2423
{
    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) {
2424 2425 2426 2427
        if (!quiet)
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("Unable to find cgroup for %s\n"),
                             vm->def->name);
2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473
        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;
}


struct qemudHookData {
    virConnectPtr conn;
    virDomainObjPtr vm;
    struct qemud_driver *driver;
2474 2475 2476
};

static int qemudSecurityHook(void *data) {
2477 2478 2479 2480
    struct qemudHookData *h = data;

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

2482 2483 2484
    if (h->driver->securityDriver &&
        h->driver->securityDriver->domainSetSecurityProcessLabel &&
        h->driver->securityDriver->domainSetSecurityProcessLabel(h->conn, h->driver->securityDriver, h->vm) < 0)
2485 2486 2487
        return -1;

    return 0;
2488 2489
}

2490 2491 2492
static int
qemuPrepareMonitorChr(virConnectPtr conn,
                      struct qemud_driver *driver,
2493
                      virDomainChrDefPtr monConfig,
2494 2495
                      const char *vm)
{
2496
    monConfig->targetType = VIR_DOMAIN_CHR_TARGET_TYPE_MONITOR;
2497

2498 2499
    monConfig->type = VIR_DOMAIN_CHR_TYPE_UNIX;
    monConfig->data.nix.listen = 1;
2500

D
Daniel P. Berrange 已提交
2501 2502 2503 2504 2505
    if (!(monConfig->info.alias = strdup("monitor"))) {
        virReportOOMError(conn);
        return -1;
    }

2506
    if (virAsprintf(&monConfig->data.nix.path, "%s/%s.monitor",
2507
                    driver->libDir, vm) < 0) {
2508 2509 2510 2511 2512 2513 2514
        virReportOOMError(conn);
        return -1;
    }

    return 0;
}

2515 2516
static int qemudStartVMDaemon(virConnectPtr conn,
                              struct qemud_driver *driver,
2517
                              virDomainObjPtr vm,
2518 2519
                              const char *migrateFrom,
                              int stdin_fd) {
2520
    const char **argv = NULL, **tmp;
2521
    const char **progenv = NULL;
2522
    int i, ret;
2523
    struct stat sb;
2524 2525
    int *tapfds = NULL;
    int ntapfds = 0;
2526
    unsigned int qemuCmdFlags;
2527
    fd_set keepfd;
2528
    const char *emulator;
G
Guido Günther 已提交
2529
    pid_t child;
2530
    int pos = -1;
2531
    char ebuf[1024];
2532
    char *pidfile = NULL;
2533
    int logfile;
2534
    qemuDomainObjPrivatePtr priv = vm->privateData;
2535

2536
    struct qemudHookData hookData;
2537 2538 2539 2540
    hookData.conn = conn;
    hookData.vm = vm;
    hookData.driver = driver;

2541
    FD_ZERO(&keepfd);
2542

D
Daniel P. Berrange 已提交
2543
    if (virDomainObjIsActive(vm)) {
2544
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_INVALID,
2545
                         "%s", _("VM is already active"));
2546 2547 2548
        return -1;
    }

2549 2550
    /* If you are using a SecurityDriver with dynamic labelling,
       then generate a security label for isolation */
2551
    if (driver->securityDriver &&
2552 2553 2554 2555
        driver->securityDriver->domainGenSecurityLabel &&
        driver->securityDriver->domainGenSecurityLabel(conn, vm) < 0)
        return -1;

2556 2557 2558 2559 2560
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityAllLabel &&
        driver->securityDriver->domainSetSecurityAllLabel(conn, vm) < 0)
        goto cleanup;

2561
    /* Ensure no historical cgroup for this VM is lieing around bogus settings */
2562
    qemuRemoveCgroup(conn, driver, vm, 1);
2563

2564 2565 2566
    if ((vm->def->ngraphics == 1) &&
        vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
        vm->def->graphics[0]->data.vnc.autoport) {
2567
        int port = qemudNextFreeVNCPort(driver);
2568
        if (port < 0) {
2569
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
2570
                             "%s", _("Unable to find an unused VNC port"));
2571
            goto cleanup;
2572
        }
2573
        vm->def->graphics[0]->data.vnc.port = port;
2574
    }
2575

L
Laine Stump 已提交
2576
    if (virFileMakePath(driver->logDir) != 0) {
2577 2578 2579
        virReportSystemError(conn, errno,
                             _("cannot create log directory %s"),
                             driver->logDir);
2580
        goto cleanup;
2581 2582
    }

2583
    if ((logfile = qemudLogFD(conn, driver, vm->def->name)) < 0)
2584
        goto cleanup;
2585

2586 2587
    emulator = vm->def->emulator;

2588 2589 2590 2591
    /* 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
     */
2592
    if (stat(emulator, &sb) < 0) {
2593 2594 2595
        virReportSystemError(conn, errno,
                             _("Cannot find QEMU binary %s"),
                             emulator);
2596
        goto cleanup;
2597 2598
    }

2599
    if (qemudExtractVersionInfo(emulator,
2600
                                NULL,
2601
                                &qemuCmdFlags) < 0)
2602
        goto cleanup;
2603

2604 2605 2606
    if (qemuSetupCgroup(conn, driver, vm) < 0)
        goto cleanup;

2607
    if (qemuPrepareHostDevices(conn, driver, vm->def) < 0)
2608
        goto cleanup;
2609

2610
    if (VIR_ALLOC(priv->monConfig) < 0) {
2611 2612 2613 2614
        virReportOOMError(conn);
        goto cleanup;
    }

2615
    if (qemuPrepareMonitorChr(conn, driver, priv->monConfig, vm->def->name) < 0)
2616
        goto cleanup;
2617

D
Daniel P. Berrange 已提交
2618 2619 2620
#if HAVE_YAJL
    if (qemuCmdFlags & QEMUD_CMD_FLAG_MONITOR_JSON)
        priv->monJSON = 1;
2621
    else
D
Daniel P. Berrange 已提交
2622
#endif
2623
        priv->monJSON = 0;
D
Daniel P. Berrange 已提交
2624

D
Daniel P. Berrange 已提交
2625 2626 2627 2628 2629 2630 2631
    if ((ret = virFileDeletePid(driver->stateDir, vm->def->name)) != 0) {
        virReportSystemError(conn, ret,
                             _("Cannot remove stale PID file for %s"),
                             vm->def->name);
        goto cleanup;
    }

2632 2633 2634 2635 2636
    if (!(pidfile = virFilePid(driver->stateDir, vm->def->name))) {
        virReportSystemError(conn, errno,
                             "%s", _("Failed to build pidfile path."));
        goto cleanup;
    }
D
Daniel P. Berrange 已提交
2637

2638
    vm->def->id = driver->nextvmid++;
2639
    if (qemudBuildCommandLine(conn, driver, vm->def, priv->monConfig,
D
Daniel P. Berrange 已提交
2640
                              priv->monJSON, qemuCmdFlags, &argv, &progenv,
2641 2642
                              &tapfds, &ntapfds, migrateFrom) < 0)
        goto cleanup;
2643

2644 2645
    tmp = progenv;
    while (*tmp) {
2646
        if (safewrite(logfile, *tmp, strlen(*tmp)) < 0)
2647
            VIR_WARN(_("Unable to write envv to logfile: %s"),
2648
                     virStrerror(errno, ebuf, sizeof ebuf));
2649
        if (safewrite(logfile, " ", 1) < 0)
2650
            VIR_WARN(_("Unable to write envv to logfile: %s"),
2651
                     virStrerror(errno, ebuf, sizeof ebuf));
2652 2653
        tmp++;
    }
2654 2655
    tmp = argv;
    while (*tmp) {
2656
        if (safewrite(logfile, *tmp, strlen(*tmp)) < 0)
2657
            VIR_WARN(_("Unable to write argv to logfile: %s"),
2658
                     virStrerror(errno, ebuf, sizeof ebuf));
2659
        if (safewrite(logfile, " ", 1) < 0)
2660
            VIR_WARN(_("Unable to write argv to logfile: %s"),
2661
                     virStrerror(errno, ebuf, sizeof ebuf));
2662 2663
        tmp++;
    }
2664
    if (safewrite(logfile, "\n", 1) < 0)
2665
        VIR_WARN(_("Unable to write argv to logfile: %s"),
2666
                 virStrerror(errno, ebuf, sizeof ebuf));
2667

2668
    if ((pos = lseek(logfile, 0, SEEK_END)) < 0)
2669
        VIR_WARN(_("Unable to seek to end of logfile: %s"),
2670
                 virStrerror(errno, ebuf, sizeof ebuf));
2671

2672 2673 2674
    for (i = 0 ; i < ntapfds ; i++)
        FD_SET(tapfds[i], &keepfd);

2675
    ret = virExecDaemonize(conn, argv, progenv, &keepfd, &child,
2676
                           stdin_fd, &logfile, &logfile,
2677
                           VIR_EXEC_NONBLOCK | VIR_EXEC_CLEAR_CAPS,
2678 2679 2680
                           qemudSecurityHook, &hookData,
                           pidfile);
    VIR_FREE(pidfile);
G
Guido Günther 已提交
2681 2682 2683

    /* wait for qemu process to to show up */
    if (ret == 0) {
2684
        if (virFileReadPid(driver->stateDir, vm->def->name, &vm->pid)) {
2685
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
2686
                             _("Domain %s didn't show up\n"), vm->def->name);
2687
            ret = -1;
G
Guido Günther 已提交
2688
        }
2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699
    } 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;
    }
2700 2701

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

2703
    for (i = 0 ; argv[i] ; i++)
2704 2705
        VIR_FREE(argv[i]);
    VIR_FREE(argv);
2706

2707 2708 2709 2710
    for (i = 0 ; progenv[i] ; i++)
        VIR_FREE(progenv[i]);
    VIR_FREE(progenv);

2711 2712 2713
    if (tapfds) {
        for (i = 0 ; i < ntapfds ; i++) {
            close(tapfds[i]);
2714
        }
2715
        VIR_FREE(tapfds);
2716 2717
    }

2718
    if (ret == -1) /* The VM failed to start */
2719 2720
        goto cleanup;

2721 2722 2723
    if (qemudWaitForMonitor(conn, driver, vm, pos) < 0)
        goto abort;

2724
    if (qemuDetectVcpuPIDs(conn, driver, vm) < 0)
2725 2726
        goto abort;

2727
    if (qemudInitCpuAffinity(conn, vm) < 0)
2728 2729 2730 2731 2732
        goto abort;

    if (qemuInitPasswords(driver, vm) < 0)
        goto abort;

D
Daniel P. Berrange 已提交
2733 2734 2735 2736 2737 2738
    /* If we have -device, then addresses are assigned explicitly.
     * If not, then we have to detect dynamic ones here */
    if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) {
        if (qemuInitPCIAddresses(driver, vm) < 0)
            goto abort;
    }
2739

2740
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
2741
    if (qemuMonitorSetBalloon(priv->mon, vm->def->memory) < 0) {
2742
        qemuDomainObjExitMonitorWithDriver(driver, vm);
2743
        goto abort;
2744
    }
2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755

    if (migrateFrom == NULL) {
        /* Allow the CPUS to start executing */
        if (qemuMonitorStartCPUs(priv->mon, conn) < 0) {
            if (virGetLastError() == NULL)
                qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                 "%s", _("resume operation failed"));
            qemuDomainObjExitMonitorWithDriver(driver, vm);
            goto abort;
        }
    }
2756
    qemuDomainObjExitMonitorWithDriver(driver, vm);
2757

2758

2759
    if (virDomainSaveStatus(conn, driver->caps, driver->stateDir, vm) < 0)
2760
        goto abort;
2761

2762
    return 0;
2763 2764

cleanup:
2765 2766 2767
    /* We jump here if we failed to start the VM for any reason
     * XXX investigate if we can kill this block and safely call
     * qemudShutdownVMDaemon even though no PID is running */
2768 2769
    qemuDomainReAttachHostDevices(conn, driver, vm->def);

2770 2771 2772
    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSecurityAllLabel)
        driver->securityDriver->domainRestoreSecurityAllLabel(conn, vm);
2773 2774 2775
    if (driver->securityDriver &&
        driver->securityDriver->domainReleaseSecurityLabel)
        driver->securityDriver->domainReleaseSecurityLabel(conn, vm);
2776
    qemuRemoveCgroup(conn, driver, vm, 0);
2777 2778 2779 2780
    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;
2781 2782
    if (logfile != -1)
        close(logfile);
2783 2784
    vm->def->id = -1;
    return -1;
2785 2786 2787 2788 2789 2790 2791 2792 2793 2794

abort:
    /* We jump here if we failed to initialize the now running VM
     * killing it off and pretend we never started it */
    qemudShutdownVMDaemon(conn, driver, vm);

    if (logfile != -1)
        close(logfile);

    return -1;
2795 2796 2797
}


2798
static void qemudShutdownVMDaemon(virConnectPtr conn,
2799 2800
                                  struct qemud_driver *driver,
                                  virDomainObjPtr vm) {
D
Daniel P. Berrange 已提交
2801
    int ret;
2802
    int retries = 0;
2803
    qemuDomainObjPrivatePtr priv = vm->privateData;
2804
    virErrorPtr orig_err;
D
Daniel P. Berrange 已提交
2805

D
Daniel P. Berrange 已提交
2806
    if (!virDomainObjIsActive(vm))
2807
        return;
2808

2809
    VIR_DEBUG("Shutting down VM '%s'", vm->def->name);
2810

2811 2812 2813 2814
    /* This method is routinely used in clean up paths. Disable error
     * reporting so we don't squash a legit error. */
    orig_err = virSaveLastError();

2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830
    if (driver->macFilter) {
        int i;
        virDomainDefPtr def = vm->def;
        for (i = 0 ; i < def->nnets ; i++) {
            virDomainNetDefPtr net = def->nets[i];
            if (net->ifname == NULL)
                continue;
            if ((errno = networkDisallowMacOnPort(conn, driver, net->ifname,
                                                  net->mac))) {
                virReportSystemError(conn, errno,
             _("failed to remove ebtables rule to allow MAC address on  '%s'"),
                                     net->ifname);
            }
        }
    }

G
Guido Günther 已提交
2831 2832
    if (virKillProcess(vm->pid, 0) == 0 &&
        virKillProcess(vm->pid, SIGTERM) < 0)
2833 2834 2835
        virReportSystemError(conn, errno,
                             _("Failed to send SIGTERM to %s (%d)"),
                             vm->def->name, vm->pid);
2836

2837 2838 2839
    if (priv->mon &&
        qemuMonitorClose(priv->mon) == 0) {
        virDomainObjUnref(vm);
2840
        priv->mon = NULL;
2841
    }
2842

2843 2844 2845 2846 2847
    if (priv->monConfig) {
        if (priv->monConfig->type == VIR_DOMAIN_CHR_TYPE_UNIX)
            unlink(priv->monConfig->data.nix.path);
        virDomainChrDefFree(priv->monConfig);
        priv->monConfig = NULL;
2848 2849
    }

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

2853
    /* Reset Security Labels */
2854
    if (driver->securityDriver &&
2855 2856 2857 2858 2859
        driver->securityDriver->domainRestoreSecurityAllLabel)
        driver->securityDriver->domainRestoreSecurityAllLabel(conn, vm);
    if (driver->securityDriver &&
        driver->securityDriver->domainReleaseSecurityLabel)
        driver->securityDriver->domainReleaseSecurityLabel(conn, vm);
2860

2861 2862 2863 2864 2865 2866 2867
    /* 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);
    }

2868
    virDomainDefClearPCIAddresses(vm->def);
D
Daniel P. Berrange 已提交
2869
    virDomainDefClearDeviceAliases(vm->def);
2870

2871
    qemuDomainReAttachHostDevices(conn, driver, vm->def);
2872

2873
retry:
2874
    if ((ret = qemuRemoveCgroup(conn, driver, vm, 0)) < 0) {
2875 2876 2877 2878 2879 2880 2881 2882
        if (ret == -EBUSY && (retries++ < 5)) {
            usleep(200*1000);
            goto retry;
        }
        VIR_WARN("Failed to remove cgroup for %s",
                 vm->def->name);
    }

2883
    qemudRemoveDomainStatus(conn, driver, vm);
D
Daniel P. Berrange 已提交
2884

2885
    vm->pid = -1;
2886
    vm->def->id = -1;
2887
    vm->state = VIR_DOMAIN_SHUTOFF;
2888 2889
    VIR_FREE(priv->vcpupids);
    priv->nvcpupids = 0;
2890 2891

    if (vm->newDef) {
2892
        virDomainDefFree(vm->def);
2893
        vm->def = vm->newDef;
2894
        vm->def->id = -1;
2895 2896
        vm->newDef = NULL;
    }
2897 2898 2899 2900 2901

    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
    }
2902 2903 2904
}


2905
static virDrvOpenStatus qemudOpen(virConnectPtr conn,
2906
                                  virConnectAuthPtr auth ATTRIBUTE_UNUSED,
2907
                                  int flags ATTRIBUTE_UNUSED) {
2908
    if (conn->uri == NULL) {
2909 2910 2911
        if (qemu_driver == NULL)
            return VIR_DRV_OPEN_DECLINED;

2912
        conn->uri = xmlParseURI(qemu_driver->privileged ?
2913 2914
                                "qemu:///system" :
                                "qemu:///session");
2915
        if (!conn->uri) {
2916
            virReportOOMError(conn);
2917 2918
            return VIR_DRV_OPEN_ERROR;
        }
2919 2920 2921 2922 2923 2924 2925 2926 2927 2928
    } 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;

2929 2930 2931 2932 2933 2934
        if (qemu_driver == NULL) {
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
                             _("qemu state driver is not active"));
            return VIR_DRV_OPEN_ERROR;
        }

2935 2936 2937 2938 2939 2940 2941 2942 2943
        if (conn->uri->path == NULL) {
            qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                             _("no QEMU URI path given, try %s"),
                             qemu_driver->privileged
                               ? "qemu:///system"
                               : "qemu:///session");
                return VIR_DRV_OPEN_ERROR;
        }

2944
        if (qemu_driver->privileged) {
2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959
            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;
            }
        }
2960 2961 2962 2963 2964 2965 2966
    }
    conn->privateData = qemu_driver;

    return VIR_DRV_OPEN_SUCCESS;
}

static int qemudClose(virConnectPtr conn) {
2967
    struct qemud_driver *driver = conn->privateData;
2968 2969

    /* Get rid of callbacks registered for this conn */
2970
    qemuDriverLock(driver);
2971
    virDomainEventCallbackListRemoveConn(conn, driver->domainEventCallbacks);
2972
    qemuDriverUnlock(driver);
2973 2974 2975 2976 2977 2978

    conn->privateData = NULL;

    return 0;
}

D
Daniel Veillard 已提交
2979 2980 2981 2982 2983
/* Which features are supported by this driver? */
static int
qemudSupportsFeature (virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
{
    switch (feature) {
2984 2985 2986 2987 2988
    case VIR_DRV_FEATURE_MIGRATION_V2:
    case VIR_DRV_FEATURE_MIGRATION_P2P:
        return 1;
    default:
        return 0;
D
Daniel Veillard 已提交
2989 2990 2991
    }
}

2992
static const char *qemudGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
2993
    return "QEMU";
2994 2995
}

2996

2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009
static int qemuIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    /* Trivially secure, since always inside the daemon */
    return 1;
}

static int qemuIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    /* Not encrypted, but remote driver takes care of that */
    return 0;
}


3010 3011 3012 3013
static int kvmGetMaxVCPUs(void) {
    int maxvcpus = 1;

    int r, fd;
3014

3015 3016
    fd = open(KVM_DEVICE, O_RDONLY);
    if (fd < 0) {
3017 3018
        virReportSystemError(NULL, errno, _("Unable to open %s"), KVM_DEVICE);
        return -1;
3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029
    }

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

    close(fd);
    return maxvcpus;
}


3030
static int qemudGetMaxVCPUs(virConnectPtr conn, const char *type) {
3031 3032 3033
    if (!type)
        return 16;

3034
    if (STRCASEEQ(type, "qemu"))
3035 3036
        return 16;

3037
    if (STRCASEEQ(type, "kvm"))
3038
        return kvmGetMaxVCPUs();
3039

3040
    if (STRCASEEQ(type, "kqemu"))
3041
        return 1;
3042 3043 3044

    qemudReportError(conn, NULL, NULL, VIR_ERR_INVALID_ARG,
                     _("unknown type '%s'"), type);
3045 3046 3047
    return -1;
}

3048

3049
static char *qemudGetCapabilities(virConnectPtr conn) {
3050
    struct qemud_driver *driver = conn->privateData;
3051
    virCapsPtr caps = NULL;
3052
    char *xml = NULL;
3053

3054
    qemuDriverLock(driver);
3055

3056 3057 3058 3059 3060
    if ((caps = qemuCreateCapabilities(qemu_driver->caps,
                                       qemu_driver->securityDriver)) == NULL) {
        virCapabilitiesFree(caps);
        goto cleanup;
    }
3061

3062
    virCapabilitiesFree(qemu_driver->caps);
3063 3064 3065
    qemu_driver->caps = caps;

    if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
3066
        virReportOOMError(conn);
3067 3068

cleanup:
3069
    qemuDriverUnlock(driver);
3070

3071
    return xml;
3072 3073 3074
}


3075
static int qemudGetProcessInfo(unsigned long long *cpuTime, int *lastCpu, int pid, int tid) {
D
Daniel P. Berrange 已提交
3076 3077
    char proc[PATH_MAX];
    FILE *pidinfo;
3078
    unsigned long long usertime, systime;
3079 3080
    int cpu;
    int ret;
D
Daniel P. Berrange 已提交
3081

3082 3083 3084 3085 3086 3087
    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 已提交
3088 3089 3090 3091
        return -1;
    }

    if (!(pidinfo = fopen(proc, "r"))) {
3092
        /*printf("cannot read pid info");*/
D
Daniel P. Berrange 已提交
3093
        /* VM probably shut down, so fake 0 */
3094 3095 3096 3097
        if (cpuTime)
            *cpuTime = 0;
        if (lastCpu)
            *lastCpu = 0;
D
Daniel P. Berrange 已提交
3098 3099 3100
        return 0;
    }

3101 3102 3103 3104 3105 3106 3107 3108 3109 3110
    /* 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) {
3111
        fclose(pidinfo);
3112 3113
        VIR_WARN0("cannot parse process status data");
        errno = -EINVAL;
D
Daniel P. Berrange 已提交
3114 3115 3116 3117 3118 3119 3120 3121
        return -1;
    }

    /* We got jiffies
     * We want nanoseconds
     * _SC_CLK_TCK is jiffies per second
     * So calulate thus....
     */
3122 3123 3124 3125 3126
    if (cpuTime)
        *cpuTime = 1000ull * 1000ull * 1000ull * (usertime + systime) / (unsigned long long)sysconf(_SC_CLK_TCK);
    if (lastCpu)
        *lastCpu = cpu;

D
Daniel P. Berrange 已提交
3127

3128 3129
    VIR_DEBUG("Got status for %d/%d user=%llu sys=%llu cpu=%d",
              pid, tid, usertime, systime, cpu);
D
Daniel P. Berrange 已提交
3130 3131 3132 3133 3134 3135 3136

    fclose(pidinfo);

    return 0;
}


3137
static virDomainPtr qemudDomainLookupByID(virConnectPtr conn,
3138
                                          int id) {
3139 3140 3141 3142
    struct qemud_driver *driver = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;

3143
    qemuDriverLock(driver);
3144
    vm  = virDomainFindByID(&driver->domains, id);
3145
    qemuDriverUnlock(driver);
3146 3147

    if (!vm) {
3148 3149
        qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching id %d"), id);
3150
        goto cleanup;
3151 3152
    }

3153
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
3154
    if (dom) dom->id = vm->def->id;
3155 3156

cleanup:
3157 3158
    if (vm)
        virDomainObjUnlock(vm);
3159 3160
    return dom;
}
3161

3162
static virDomainPtr qemudDomainLookupByUUID(virConnectPtr conn,
3163
                                            const unsigned char *uuid) {
3164 3165 3166
    struct qemud_driver *driver = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
3167

3168
    qemuDriverLock(driver);
3169
    vm = virDomainFindByUUID(&driver->domains, uuid);
3170 3171
    qemuDriverUnlock(driver);

3172
    if (!vm) {
3173 3174 3175
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(uuid, uuidstr);
        qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
3176
                         _("no domain with matching uuid '%s'"), uuidstr);
3177
        goto cleanup;
3178 3179
    }

3180
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
3181
    if (dom) dom->id = vm->def->id;
3182 3183

cleanup:
3184 3185
    if (vm)
        virDomainObjUnlock(vm);
3186 3187
    return dom;
}
3188

3189
static virDomainPtr qemudDomainLookupByName(virConnectPtr conn,
3190
                                            const char *name) {
3191 3192 3193
    struct qemud_driver *driver = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
3194

3195
    qemuDriverLock(driver);
3196
    vm = virDomainFindByName(&driver->domains, name);
3197 3198
    qemuDriverUnlock(driver);

3199
    if (!vm) {
3200 3201
        qemudReportError(conn, NULL, NULL, VIR_ERR_NO_DOMAIN,
                         _("no domain with matching name '%s'"), name);
3202
        goto cleanup;
3203 3204
    }

3205
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
3206
    if (dom) dom->id = vm->def->id;
3207 3208

cleanup:
3209 3210
    if (vm)
        virDomainObjUnlock(vm);
3211 3212 3213
    return dom;
}

3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257

static int qemuDomainIsActive(virDomainPtr dom)
{
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr obj;
    int ret = -1;

    qemuDriverLock(driver);
    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
    qemuDriverUnlock(driver);
    if (!obj) {
        qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
        goto cleanup;
    }
    ret = virDomainObjIsActive(obj);

cleanup:
    if (obj)
        virDomainObjUnlock(obj);
    return ret;
}

static int qemuDomainIsPersistent(virDomainPtr dom)
{
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr obj;
    int ret = -1;

    qemuDriverLock(driver);
    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
    qemuDriverUnlock(driver);
    if (!obj) {
        qemudReportError(dom->conn, NULL, NULL, VIR_ERR_NO_DOMAIN, NULL);
        goto cleanup;
    }
    ret = obj->persistent;

cleanup:
    if (obj)
        virDomainObjUnlock(obj);
    return ret;
}


3258
static int qemudGetVersion(virConnectPtr conn, unsigned long *version) {
3259 3260 3261
    struct qemud_driver *driver = conn->privateData;
    int ret = -1;

3262
    qemuDriverLock(driver);
3263
    if (qemudExtractVersion(conn, driver) < 0)
3264
        goto cleanup;
3265

3266
    *version = qemu_driver->qemuVersion;
3267 3268 3269
    ret = 0;

cleanup:
3270
    qemuDriverUnlock(driver);
3271
    return ret;
D
Daniel P. Berrange 已提交
3272 3273
}

3274
static int qemudListDomains(virConnectPtr conn, int *ids, int nids) {
3275
    struct qemud_driver *driver = conn->privateData;
3276
    int n;
3277

3278
    qemuDriverLock(driver);
3279
    n = virDomainObjListGetActiveIDs(&driver->domains, ids, nids);
3280
    qemuDriverUnlock(driver);
3281

3282
    return n;
D
Daniel P. Berrange 已提交
3283
}
3284

3285
static int qemudNumDomains(virConnectPtr conn) {
3286
    struct qemud_driver *driver = conn->privateData;
3287
    int n;
3288

3289
    qemuDriverLock(driver);
3290
    n = virDomainObjListNumOfDomains(&driver->domains, 1);
3291
    qemuDriverUnlock(driver);
3292

3293
    return n;
D
Daniel P. Berrange 已提交
3294
}
3295

3296
static virDomainPtr qemudDomainCreate(virConnectPtr conn, const char *xml,
3297
                                      unsigned int flags ATTRIBUTE_UNUSED) {
3298
    struct qemud_driver *driver = conn->privateData;
3299
    virDomainDefPtr def;
3300
    virDomainObjPtr vm = NULL;
3301
    virDomainPtr dom = NULL;
3302
    virDomainEventPtr event = NULL;
D
Daniel P. Berrange 已提交
3303

3304
    qemuDriverLock(driver);
3305 3306
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE)))
3307
        goto cleanup;
3308

3309 3310 3311
    if (virSecurityDriverVerify(conn, def) < 0)
        goto cleanup;

3312 3313
    if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
        goto cleanup;
3314

3315
    if (!(vm = virDomainAssignDef(conn,
3316
                                  driver->caps,
3317
                                  &driver->domains,
3318 3319 3320 3321
                                  def)))
        goto cleanup;

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

3323 3324 3325
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup; /* XXXX free the 'vm' we created ? */

3326
    if (qemudStartVMDaemon(conn, driver, vm, NULL, -1) < 0) {
3327 3328 3329
        if (qemuDomainObjEndJob(vm) > 0)
            virDomainRemoveInactive(&driver->domains,
                                    vm);
3330
        vm = NULL;
3331
        goto endjob;
D
Daniel P. Berrange 已提交
3332
    }
3333 3334 3335 3336

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

3338
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
3339
    if (dom) dom->id = vm->def->id;
3340

3341
endjob:
3342 3343 3344
    if (vm &&
        qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
3345

3346 3347
cleanup:
    virDomainDefFree(def);
3348 3349
    if (vm)
        virDomainObjUnlock(vm);
3350 3351
    if (event)
        qemuDomainEventQueue(driver, event);
3352
    qemuDriverUnlock(driver);
3353
    return dom;
D
Daniel P. Berrange 已提交
3354 3355 3356
}


3357
static int qemudDomainSuspend(virDomainPtr dom) {
3358 3359 3360
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3361
    virDomainEventPtr event = NULL;
3362

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

D
Daniel P. Berrange 已提交
3366
    if (!vm) {
3367 3368 3369 3370
        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);
3371
        goto cleanup;
D
Daniel P. Berrange 已提交
3372
    }
3373 3374 3375
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
3376
    if (!virDomainObjIsActive(vm)) {
3377
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3378
                         "%s", _("domain is not running"));
3379
        goto endjob;
D
Daniel P. Berrange 已提交
3380
    }
3381
    if (vm->state != VIR_DOMAIN_PAUSED) {
3382
        qemuDomainObjPrivatePtr priv = vm->privateData;
3383
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
3384
        if (qemuMonitorStopCPUs(priv->mon) < 0) {
3385 3386
            qemuDomainObjExitMonitorWithDriver(driver, vm);
            goto endjob;
3387
        }
3388
        qemuDomainObjExitMonitorWithDriver(driver, vm);
3389
        vm->state = VIR_DOMAIN_PAUSED;
3390 3391 3392
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_SUSPENDED,
                                         VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
D
Daniel P. Berrange 已提交
3393
    }
3394
    if (virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0)
3395
        goto endjob;
3396 3397
    ret = 0;

3398
endjob:
3399 3400
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
3401

3402
cleanup:
3403 3404
    if (vm)
        virDomainObjUnlock(vm);
3405

3406
    if (event)
3407
        qemuDomainEventQueue(driver, event);
3408
    qemuDriverUnlock(driver);
3409
    return ret;
D
Daniel P. Berrange 已提交
3410 3411 3412
}


3413
static int qemudDomainResume(virDomainPtr dom) {
3414 3415 3416
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3417
    virDomainEventPtr event = NULL;
3418

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

D
Daniel P. Berrange 已提交
3422
    if (!vm) {
3423 3424 3425 3426
        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);
3427
        goto cleanup;
D
Daniel P. Berrange 已提交
3428
    }
3429 3430 3431 3432

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

D
Daniel P. Berrange 已提交
3433
    if (!virDomainObjIsActive(vm)) {
3434
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3435
                         "%s", _("domain is not running"));
3436
        goto endjob;
D
Daniel P. Berrange 已提交
3437
    }
3438
    if (vm->state == VIR_DOMAIN_PAUSED) {
3439
        qemuDomainObjPrivatePtr priv = vm->privateData;
3440
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
3441
        if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
3442
            qemuDomainObjExitMonitorWithDriver(driver, vm);
3443 3444 3445
            if (virGetLastError() == NULL)
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("resume operation failed"));
3446
            goto endjob;
3447
        }
3448
        qemuDomainObjExitMonitorWithDriver(driver, vm);
3449
        vm->state = VIR_DOMAIN_RUNNING;
3450 3451 3452
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);
D
Daniel P. Berrange 已提交
3453
    }
3454
    if (virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0)
3455
        goto endjob;
3456 3457
    ret = 0;

3458
endjob:
3459 3460
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
3461

3462
cleanup:
3463 3464
    if (vm)
        virDomainObjUnlock(vm);
3465
    if (event)
3466
        qemuDomainEventQueue(driver, event);
3467
    qemuDriverUnlock(driver);
3468
    return ret;
D
Daniel P. Berrange 已提交
3469 3470 3471
}


3472
static int qemudDomainShutdown(virDomainPtr dom) {
3473 3474 3475
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3476

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

3481
    if (!vm) {
3482 3483 3484 3485
        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);
3486
        goto cleanup;
3487 3488
    }

3489 3490 3491
    if (qemuDomainObjBeginJob(vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
3492
    if (!virDomainObjIsActive(vm)) {
3493 3494
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is not running"));
3495
        goto endjob;
3496 3497
    }

3498
    qemuDomainObjPrivatePtr priv = vm->privateData;
3499 3500 3501
    qemuDomainObjEnterMonitor(vm);
    ret = qemuMonitorSystemPowerdown(priv->mon);
    qemuDomainObjExitMonitor(vm);
3502

3503
endjob:
3504 3505
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
3506

3507
cleanup:
3508 3509
    if (vm)
        virDomainObjUnlock(vm);
3510
    return ret;
3511 3512 3513
}


3514
static int qemudDomainDestroy(virDomainPtr dom) {
3515 3516 3517
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3518
    virDomainEventPtr event = NULL;
3519

3520
    qemuDriverLock(driver);
3521
    vm  = virDomainFindByUUID(&driver->domains, dom->uuid);
D
Daniel P. Berrange 已提交
3522
    if (!vm) {
3523 3524 3525 3526
        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);
3527
        goto cleanup;
D
Daniel P. Berrange 已提交
3528
    }
3529 3530 3531 3532

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

D
Daniel P. Berrange 已提交
3533
    if (!virDomainObjIsActive(vm)) {
3534
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3535
                         "%s", _("domain is not running"));
3536
        goto endjob;
3537
    }
3538

3539
    qemudShutdownVMDaemon(dom->conn, driver, vm);
3540 3541 3542
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
3543
    if (!vm->persistent) {
3544 3545 3546
        if (qemuDomainObjEndJob(vm) > 0)
            virDomainRemoveInactive(&driver->domains,
                                    vm);
3547 3548
        vm = NULL;
    }
3549 3550
    ret = 0;

3551
endjob:
3552 3553 3554
    if (vm &&
        qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
3555

3556
cleanup:
3557 3558
    if (vm)
        virDomainObjUnlock(vm);
3559 3560
    if (event)
        qemuDomainEventQueue(driver, event);
3561
    qemuDriverUnlock(driver);
3562
    return ret;
D
Daniel P. Berrange 已提交
3563 3564 3565
}


3566
static char *qemudDomainGetOSType(virDomainPtr dom) {
3567 3568 3569
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *type = NULL;
3570

3571
    qemuDriverLock(driver);
3572
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3573
    qemuDriverUnlock(driver);
3574
    if (!vm) {
3575 3576 3577 3578
        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);
3579
        goto cleanup;
3580 3581
    }

3582
    if (!(type = strdup(vm->def->os.type)))
3583
        virReportOOMError(dom->conn);
3584 3585

cleanup:
3586 3587
    if (vm)
        virDomainObjUnlock(vm);
3588 3589 3590
    return type;
}

3591 3592
/* Returns max memory in kb, 0 if error */
static unsigned long qemudDomainGetMaxMemory(virDomainPtr dom) {
3593 3594 3595
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    unsigned long ret = 0;
3596

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

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

3609 3610 3611
    ret = vm->def->maxmem;

cleanup:
3612 3613
    if (vm)
        virDomainObjUnlock(vm);
3614
    return ret;
3615 3616 3617
}

static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long newmax) {
3618 3619 3620
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3621

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

3626
    if (!vm) {
3627 3628
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
3629
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
3630
                         _("no domain with matching uuid '%s'"), uuidstr);
3631
        goto cleanup;
3632 3633 3634 3635
    }

    if (newmax < vm->def->memory) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
3636
                         "%s", _("cannot set max memory lower than current memory"));
3637
        goto cleanup;;
3638 3639 3640
    }

    vm->def->maxmem = newmax;
3641 3642 3643
    ret = 0;

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

3649

3650
static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem) {
3651 3652 3653
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3654

3655
    qemuDriverLock(driver);
3656
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3657
    qemuDriverUnlock(driver);
3658
    if (!vm) {
3659 3660
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
3661
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
3662
                         _("no domain with matching uuid '%s'"), uuidstr);
3663
        goto cleanup;
3664 3665 3666 3667
    }

    if (newmem > vm->def->maxmem) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
3668
                         "%s", _("cannot set memory higher than max memory"));
3669
        goto cleanup;
3670 3671
    }

3672 3673 3674
    if (qemuDomainObjBeginJob(vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
3675
    if (virDomainObjIsActive(vm)) {
3676
        qemuDomainObjPrivatePtr priv = vm->privateData;
3677
        qemuDomainObjEnterMonitor(vm);
3678
        int r = qemuMonitorSetBalloon(priv->mon, newmem);
3679
        qemuDomainObjExitMonitor(vm);
3680
        if (r < 0)
3681
            goto endjob;
3682 3683 3684

        /* Lack of balloon support is a fatal error */
        if (r == 0) {
3685 3686
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                             "%s", _("cannot set memory of an active domain"));
3687
            goto endjob;
3688
        }
3689 3690 3691
    } else {
        vm->def->memory = newmem;
    }
3692
    ret = 0;
3693

3694
endjob:
3695 3696
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
3697

3698
cleanup:
3699 3700
    if (vm)
        virDomainObjUnlock(vm);
3701
    return ret;
3702 3703
}

3704
static int qemudDomainGetInfo(virDomainPtr dom,
3705
                              virDomainInfoPtr info) {
3706 3707 3708
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
3709 3710
    int err;
    unsigned long balloon;
3711

3712
    qemuDriverLock(driver);
3713
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
3714
    qemuDriverUnlock(driver);
D
Daniel P. Berrange 已提交
3715
    if (!vm) {
3716 3717 3718 3719
        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);
3720
        goto cleanup;
D
Daniel P. Berrange 已提交
3721 3722
    }

3723
    info->state = vm->state;
D
Daniel P. Berrange 已提交
3724

D
Daniel P. Berrange 已提交
3725
    if (!virDomainObjIsActive(vm)) {
3726
        info->cpuTime = 0;
D
Daniel P. Berrange 已提交
3727
    } else {
3728
        if (qemudGetProcessInfo(&(info->cpuTime), NULL, vm->pid, 0) < 0) {
3729
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, ("cannot read cputime for domain"));
3730
            goto cleanup;
D
Daniel P. Berrange 已提交
3731 3732 3733
        }
    }

3734
    info->maxMem = vm->def->maxmem;
3735

D
Daniel P. Berrange 已提交
3736
    if (virDomainObjIsActive(vm)) {
3737
        qemuDomainObjPrivatePtr priv = vm->privateData;
3738 3739 3740
        if (!priv->jobActive) {
            if (qemuDomainObjBeginJob(vm) < 0)
                goto cleanup;
3741

3742 3743 3744 3745
            qemuDomainObjEnterMonitor(vm);
            err = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
            qemuDomainObjExitMonitor(vm);
            if (err < 0) {
3746 3747
                if (qemuDomainObjEndJob(vm) == 0)
                    vm = NULL;
3748 3749 3750 3751 3752 3753 3754 3755 3756
                goto cleanup;
            }

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

3757 3758 3759 3760
            if (qemuDomainObjEndJob(vm) == 0) {
                vm = NULL;
                goto cleanup;
            }
3761 3762 3763
        } else {
            info->memory = vm->def->memory;
        }
3764 3765 3766 3767
    } else {
        info->memory = vm->def->memory;
    }

3768
    info->nrVirtCpu = vm->def->vcpus;
3769 3770 3771
    ret = 0;

cleanup:
3772 3773
    if (vm)
        virDomainObjUnlock(vm);
3774
    return ret;
D
Daniel P. Berrange 已提交
3775 3776 3777
}


3778
#define QEMUD_SAVE_MAGIC "LibvirtQemudSave"
3779 3780 3781
#define QEMUD_SAVE_VERSION 2

enum qemud_save_formats {
3782 3783 3784
    QEMUD_SAVE_FORMAT_RAW = 0,
    QEMUD_SAVE_FORMAT_GZIP = 1,
    QEMUD_SAVE_FORMAT_BZIP2 = 2,
3785 3786
    /*
     * Deprecated by xz and never used as part of a release
3787
     * QEMUD_SAVE_FORMAT_LZMA
3788 3789
     */
    QEMUD_SAVE_FORMAT_XZ = 3,
3790
    QEMUD_SAVE_FORMAT_LZOP = 4,
3791 3792 3793
    /* Note: add new members only at the end.
       These values are used in the on-disk format.
       Do not change or re-use numbers. */
3794 3795

    QEMUD_SAVE_FORMAT_LAST
3796
};
3797

3798 3799 3800 3801 3802
VIR_ENUM_DECL(qemudSaveCompression)
VIR_ENUM_IMPL(qemudSaveCompression, QEMUD_SAVE_FORMAT_LAST,
              "raw",
              "gzip",
              "bzip2",
3803 3804
              "xz",
              "lzop")
3805

3806 3807 3808 3809 3810
struct qemud_save_header {
    char magic[sizeof(QEMUD_SAVE_MAGIC)-1];
    int version;
    int xml_len;
    int was_running;
3811 3812
    int compressed;
    int unused[15];
3813 3814
};

3815
static int qemudDomainSave(virDomainPtr dom,
3816 3817
                           const char *path)
{
3818
    struct qemud_driver *driver = dom->conn->privateData;
3819
    virDomainObjPtr vm = NULL;
3820 3821
    int fd = -1;
    char *xml = NULL;
3822
    struct qemud_save_header header;
3823
    int ret = -1;
3824
    int rc;
3825
    virDomainEventPtr event = NULL;
3826 3827 3828 3829 3830

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

3831
    qemuDriverLock(driver);
3832 3833 3834
    if (driver->saveImageFormat == NULL)
        header.compressed = QEMUD_SAVE_FORMAT_RAW;
    else {
3835 3836 3837 3838 3839 3840
        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"));
3841
            goto cleanup;
3842
        }
3843 3844
    }

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

D
Daniel P. Berrange 已提交
3847
    if (!vm) {
3848 3849 3850 3851
        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);
3852
        goto cleanup;
D
Daniel P. Berrange 已提交
3853
    }
3854

3855 3856 3857
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
3858
    if (!virDomainObjIsActive(vm)) {
3859
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
3860
                         "%s", _("domain is not running"));
3861
        goto endjob;
D
Daniel P. Berrange 已提交
3862
    }
3863 3864 3865

    /* Pause */
    if (vm->state == VIR_DOMAIN_RUNNING) {
3866
        qemuDomainObjPrivatePtr priv = vm->privateData;
3867
        header.was_running = 1;
3868
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
3869
        if (qemuMonitorStopCPUs(priv->mon) < 0) {
3870 3871
            qemuDomainObjExitMonitorWithDriver(driver, vm);
            goto endjob;
3872
        }
3873
        qemuDomainObjExitMonitorWithDriver(driver, vm);
3874
        vm->state = VIR_DOMAIN_PAUSED;
3875 3876 3877
    }

    /* Get XML for the domain */
3878
    xml = virDomainDefFormat(dom->conn, vm->def, VIR_DOMAIN_XML_SECURE);
3879 3880
    if (!xml) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3881
                         "%s", _("failed to get domain xml"));
3882
        goto endjob;
3883 3884 3885 3886 3887 3888
    }
    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,
3889
                         _("failed to create '%s'"), path);
3890
        goto endjob;
3891 3892 3893 3894
    }

    if (safewrite(fd, &header, sizeof(header)) != sizeof(header)) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3895
                         "%s", _("failed to write save header"));
3896
        goto endjob;
3897 3898 3899 3900
    }

    if (safewrite(fd, xml, header.xml_len) != header.xml_len) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
3901
                         "%s", _("failed to write xml"));
3902
        goto endjob;
3903 3904
    }

3905
    if (close(fd) < 0) {
3906 3907 3908
        virReportSystemError(dom->conn, errno,
                             _("unable to save file %s"),
                             path);
3909
        goto endjob;
3910 3911
    }
    fd = -1;
3912

3913 3914 3915 3916 3917
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSavedStateLabel &&
        driver->securityDriver->domainSetSavedStateLabel(dom->conn, vm, path) == -1)
        goto endjob;

3918 3919
    if (header.compressed == QEMUD_SAVE_FORMAT_RAW) {
        const char *args[] = { "cat", NULL };
3920
        qemuDomainObjPrivatePtr priv = vm->privateData;
M
Matthias Bolte 已提交
3921
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
3922
        rc = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
M
Matthias Bolte 已提交
3923
        qemuDomainObjExitMonitorWithDriver(driver, vm);
3924
    } else {
3925
        const char *prog = qemudSaveCompressionTypeToString(header.compressed);
3926
        qemuDomainObjPrivatePtr priv = vm->privateData;
3927 3928 3929 3930 3931
        const char *args[] = {
            prog,
            "-c",
            NULL
        };
M
Matthias Bolte 已提交
3932
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
3933
        rc = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
M
Matthias Bolte 已提交
3934
        qemuDomainObjExitMonitorWithDriver(driver, vm);
3935 3936
    }

3937
    if (rc < 0)
3938
        goto endjob;
3939

3940 3941
    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSavedStateLabel &&
3942
        driver->securityDriver->domainRestoreSavedStateLabel(dom->conn, vm, path) == -1)
3943 3944 3945 3946
        goto endjob;

    ret = 0;

3947 3948
    /* Shut it down */
    qemudShutdownVMDaemon(dom->conn, driver, vm);
3949 3950 3951
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_SAVED);
3952
    if (!vm->persistent) {
3953 3954 3955
        if (qemuDomainObjEndJob(vm) > 0)
            virDomainRemoveInactive(&driver->domains,
                                    vm);
3956 3957
        vm = NULL;
    }
3958

3959
endjob:
3960 3961 3962
    if (vm &&
        qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
3963

3964 3965 3966 3967 3968 3969
cleanup:
    if (fd != -1)
        close(fd);
    VIR_FREE(xml);
    if (ret != 0)
        unlink(path);
3970 3971
    if (vm)
        virDomainObjUnlock(vm);
3972 3973
    if (event)
        qemuDomainEventQueue(driver, event);
3974
    qemuDriverUnlock(driver);
3975
    return ret;
D
Daniel P. Berrange 已提交
3976 3977 3978
}


P
Paolo Bonzini 已提交
3979 3980 3981 3982 3983 3984
static int qemudDomainCoreDump(virDomainPtr dom,
                               const char *path,
                               int flags ATTRIBUTE_UNUSED) {
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int resume = 0, paused = 0;
3985
    int ret = -1, fd = -1;
3986
    virDomainEventPtr event = NULL;
3987 3988 3989 3990
    const char *args[] = {
        "cat",
        NULL,
    };
P
Paolo Bonzini 已提交
3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003

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

4004 4005 4006
    if (qemuDomainObjBeginJob(vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
4007
    if (!virDomainObjIsActive(vm)) {
P
Paolo Bonzini 已提交
4008 4009
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is not running"));
4010
        goto endjob;
P
Paolo Bonzini 已提交
4011 4012
    }

4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031
    /* Create an empty file with appropriate ownership.  */
    if ((fd = open(path, O_CREAT|O_TRUNC|O_WRONLY, S_IRUSR|S_IWUSR)) < 0) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         _("failed to create '%s'"), path);
        goto endjob;
    }

    if (close(fd) < 0) {
        virReportSystemError(dom->conn, errno,
                             _("unable to save file %s"),
                             path);
        goto endjob;
    }

    if (driver->securityDriver &&
        driver->securityDriver->domainSetSavedStateLabel &&
        driver->securityDriver->domainSetSavedStateLabel(dom->conn, vm, path) == -1)
        goto endjob;

P
Paolo Bonzini 已提交
4032 4033
    /* Migrate will always stop the VM, so the resume condition is
       independent of whether the stop command is issued.  */
P
Paolo Bonzini 已提交
4034 4035
    resume = (vm->state == VIR_DOMAIN_RUNNING);

4036 4037
    qemuDomainObjPrivatePtr priv = vm->privateData;

P
Paolo Bonzini 已提交
4038
    /* Pause domain for non-live dump */
P
Paolo Bonzini 已提交
4039
    if (!(flags & VIR_DUMP_LIVE) && vm->state == VIR_DOMAIN_RUNNING) {
4040 4041 4042
        qemuDomainObjEnterMonitor(vm);
        if (qemuMonitorStopCPUs(priv->mon) < 0) {
            qemuDomainObjExitMonitor(vm);
4043
            goto endjob;
4044 4045
        }
        qemuDomainObjExitMonitor(vm);
P
Paolo Bonzini 已提交
4046 4047 4048
        paused = 1;
    }

4049
    qemuDomainObjEnterMonitor(vm);
4050
    ret = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
4051
    qemuDomainObjExitMonitor(vm);
4052 4053 4054 4055
    paused |= (ret == 0);

    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSavedStateLabel &&
4056
        driver->securityDriver->domainRestoreSavedStateLabel(dom->conn, vm, path) == -1)
4057 4058 4059
        goto endjob;

endjob:
4060 4061 4062 4063 4064 4065 4066
    if ((ret == 0) && (flags & VIR_DUMP_CRASH)) {
        qemudShutdownVMDaemon(dom->conn, driver, vm);
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STOPPED,
                                         VIR_DOMAIN_EVENT_STOPPED_CRASHED);
    }

P
Paolo Bonzini 已提交
4067 4068 4069
    /* 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.  */
4070
    else if (resume && paused) {
4071
        qemuDomainObjEnterMonitor(vm);
4072
        if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
4073 4074 4075
            if (virGetLastError() == NULL)
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("resuming after dump failed"));
P
Paolo Bonzini 已提交
4076
        }
4077
        qemuDomainObjExitMonitor(vm);
P
Paolo Bonzini 已提交
4078
    }
4079

4080 4081
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
4082
    else if ((ret == 0) && (flags & VIR_DUMP_CRASH) && !vm->persistent) {
4083 4084 4085 4086
        virDomainRemoveInactive(&driver->domains,
                                vm);
        vm = NULL;
    }
4087 4088

cleanup:
4089 4090
    if (ret != 0)
        unlink(path);
P
Paolo Bonzini 已提交
4091 4092
    if (vm)
        virDomainObjUnlock(vm);
4093 4094
    if (event)
        qemuDomainEventQueue(driver, event);
P
Paolo Bonzini 已提交
4095 4096 4097 4098
    return ret;
}


4099
static int qemudDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus) {
4100 4101
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
4102
    int max;
4103
    int ret = -1;
4104
    const char *type;
4105

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

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

4118 4119 4120
    if (qemuDomainObjBeginJob(vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
4121
    if (virDomainObjIsActive(vm)) {
4122
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID, "%s",
4123
                         _("cannot change vcpu count of an active domain"));
4124
        goto endjob;
4125 4126
    }

4127 4128 4129 4130
    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);
4131
        goto endjob;
4132 4133 4134
    }

    if ((max = qemudGetMaxVCPUs(dom->conn, type)) < 0) {
4135 4136
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
                         _("could not determine max vcpus for the domain"));
4137
        goto endjob;
4138 4139 4140 4141 4142 4143
    }

    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);
4144
        goto endjob;
4145 4146 4147
    }

    vm->def->vcpus = nvcpus;
4148 4149
    ret = 0;

4150
endjob:
4151 4152
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
4153

4154
cleanup:
4155 4156
    if (vm)
        virDomainObjUnlock(vm);
4157
    return ret;
4158 4159
}

4160 4161 4162 4163 4164 4165

static int
qemudDomainPinVcpu(virDomainPtr dom,
                   unsigned int vcpu,
                   unsigned char *cpumap,
                   int maplen) {
4166 4167
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
4168
    int maxcpu, hostcpus;
4169
    virNodeInfo nodeinfo;
4170
    int ret = -1;
4171
    qemuDomainObjPrivatePtr priv;
4172

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

4177 4178 4179 4180 4181 4182 4183 4184
    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;
    }

D
Daniel P. Berrange 已提交
4185
    if (!virDomainObjIsActive(vm)) {
4186
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
4187
                         "%s",_("cannot pin vcpus on an inactive domain"));
4188
        goto cleanup;
4189 4190
    }

4191 4192 4193
    priv = vm->privateData;

    if (vcpu > (priv->nvcpupids-1)) {
4194 4195
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                         _("vcpu number out of range %d > %d"),
4196
                         vcpu, priv->nvcpupids);
4197
        goto cleanup;
4198 4199
    }

4200
    if (nodeGetInfo(dom->conn, &nodeinfo) < 0)
4201
        goto cleanup;
4202

4203
    hostcpus = VIR_NODEINFO_MAXCPUS(nodeinfo);
4204
    maxcpu = maplen * 8;
4205 4206
    if (maxcpu > hostcpus)
        maxcpu = hostcpus;
4207

4208 4209
    if (priv->vcpupids != NULL) {
        if (virProcessInfoSetAffinity(priv->vcpupids[vcpu],
4210
                                      cpumap, maplen, maxcpu) < 0)
4211
            goto cleanup;
4212 4213 4214
    } else {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         "%s", _("cpu affinity is not supported"));
4215
        goto cleanup;
4216
    }
4217
    ret = 0;
4218

4219
cleanup:
4220 4221
    if (vm)
        virDomainObjUnlock(vm);
4222
    return ret;
4223 4224 4225 4226 4227 4228 4229 4230
}

static int
qemudDomainGetVcpus(virDomainPtr dom,
                    virVcpuInfoPtr info,
                    int maxinfo,
                    unsigned char *cpumaps,
                    int maplen) {
4231 4232
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
4233
    virNodeInfo nodeinfo;
4234
    int i, v, maxcpu, hostcpus;
4235
    int ret = -1;
4236
    qemuDomainObjPrivatePtr priv;
4237

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

4242 4243 4244 4245 4246 4247 4248 4249
    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;
    }

D
Daniel P. Berrange 已提交
4250
    if (!virDomainObjIsActive(vm)) {
4251
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
4252 4253
                         "%s",
                         _("cannot list vcpu pinning for an inactive domain"));
4254
        goto cleanup;
4255 4256
    }

4257 4258
    priv = vm->privateData;

4259
    if (nodeGetInfo(dom->conn, &nodeinfo) < 0)
4260
        goto cleanup;
4261

4262
    hostcpus = VIR_NODEINFO_MAXCPUS(nodeinfo);
4263
    maxcpu = maplen * 8;
4264 4265
    if (maxcpu > hostcpus)
        maxcpu = hostcpus;
4266 4267

    /* Clamp to actual number of vcpus */
4268 4269
    if (maxinfo > priv->nvcpupids)
        maxinfo = priv->nvcpupids;
4270

4271 4272 4273 4274 4275 4276
    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;
4277

4278
                if (priv->vcpupids != NULL &&
4279 4280 4281
                    qemudGetProcessInfo(&(info[i].cpuTime),
                                        &(info[i].cpu),
                                        vm->pid,
4282
                                        priv->vcpupids[i]) < 0) {
4283 4284 4285 4286
                    virReportSystemError(dom->conn, errno, "%s",
                                         _("cannot get vCPU placement & pCPU time"));
                    goto cleanup;
                }
4287
            }
4288 4289
        }

4290 4291
        if (cpumaps != NULL) {
            memset(cpumaps, 0, maplen * maxinfo);
4292
            if (priv->vcpupids != NULL) {
4293 4294 4295
                for (v = 0 ; v < maxinfo ; v++) {
                    unsigned char *cpumap = VIR_GET_CPUMAP(cpumaps, maplen, v);

4296
                    if (virProcessInfoGetAffinity(priv->vcpupids[v],
4297
                                                  cpumap, maplen, maxcpu) < 0)
4298
                        goto cleanup;
4299
                }
4300 4301 4302 4303
            } else {
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                                 "%s", _("cpu affinity is not available"));
                goto cleanup;
4304 4305 4306
            }
        }
    }
4307
    ret = maxinfo;
4308

4309
cleanup:
4310 4311
    if (vm)
        virDomainObjUnlock(vm);
4312
    return ret;
4313 4314 4315
}


4316
static int qemudDomainGetMaxVcpus(virDomainPtr dom) {
4317 4318
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
4319
    const char *type;
4320
    int ret = -1;
4321

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

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

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

4341
    ret = qemudGetMaxVCPUs(dom->conn, type);
4342

4343
cleanup:
4344 4345
    if (vm)
        virDomainObjUnlock(vm);
4346 4347 4348
    return ret;
}

4349 4350 4351 4352 4353 4354 4355 4356 4357 4358
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);

4359 4360
    memset(seclabel, 0, sizeof(*seclabel));

4361 4362 4363
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
4364
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389
                         _("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().
     */
D
Daniel P. Berrange 已提交
4390
    if (virDomainObjIsActive(vm)) {
4391 4392
        if (driver->securityDriver && driver->securityDriver->domainGetSecurityProcessLabel) {
            if (driver->securityDriver->domainGetSecurityProcessLabel(dom->conn, vm, seclabel) == -1) {
4393
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
4394
                                 "%s", _("Failed to get security label"));
4395 4396 4397 4398 4399 4400 4401 4402 4403 4404
                goto cleanup;
            }
        }
    }

    ret = 0;

cleanup:
    if (vm)
        virDomainObjUnlock(vm);
4405
    qemuDriverUnlock(driver);
4406 4407 4408
    return ret;
}

4409 4410
static int qemudNodeGetSecurityModel(virConnectPtr conn,
                                     virSecurityModelPtr secmodel)
4411 4412 4413
{
    struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
    char *p;
4414
    int ret = 0;
4415

4416 4417
    qemuDriverLock(driver);
    if (!driver->securityDriver) {
4418
        memset(secmodel, 0, sizeof (*secmodel));
4419 4420
        goto cleanup;
    }
4421

4422 4423 4424 4425 4426
    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);
4427 4428
        ret = -1;
        goto cleanup;
4429 4430 4431 4432 4433 4434 4435 4436
    }
    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);
4437 4438
        ret = -1;
        goto cleanup;
4439 4440
    }
    strcpy(secmodel->doi, p);
4441 4442 4443 4444

cleanup:
    qemuDriverUnlock(driver);
    return ret;
4445 4446 4447
}

/* TODO: check seclabel restore */
4448
static int qemudDomainRestore(virConnectPtr conn,
4449 4450 4451
                              const char *path) {
    struct qemud_driver *driver = conn->privateData;
    virDomainDefPtr def = NULL;
4452
    virDomainObjPtr vm = NULL;
4453 4454 4455
    int fd = -1;
    int ret = -1;
    char *xml = NULL;
4456
    struct qemud_save_header header;
4457
    virDomainEventPtr event = NULL;
4458 4459 4460
    int intermediatefd = -1;
    pid_t intermediate_pid = -1;
    int childstat;
4461

4462
    qemuDriverLock(driver);
4463 4464 4465
    /* Verify the header and read the XML */
    if ((fd = open(path, O_RDONLY)) < 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4466
                         "%s", _("cannot read domain image"));
4467
        goto cleanup;
4468 4469 4470 4471
    }

    if (saferead(fd, &header, sizeof(header)) != sizeof(header)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4472
                         "%s", _("failed to read qemu header"));
4473
        goto cleanup;
4474 4475 4476 4477
    }

    if (memcmp(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic)) != 0) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4478
                         "%s", _("image magic is incorrect"));
4479
        goto cleanup;
4480 4481 4482 4483
    }

    if (header.version > QEMUD_SAVE_VERSION) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4484
                         _("image version is not supported (%d > %d)"),
4485
                         header.version, QEMUD_SAVE_VERSION);
4486
        goto cleanup;
4487 4488
    }

4489
    if (VIR_ALLOC_N(xml, header.xml_len) < 0) {
4490
        virReportOOMError(conn);
4491
        goto cleanup;
4492 4493 4494 4495
    }

    if (saferead(fd, xml, header.xml_len) != header.xml_len) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4496
                         "%s", _("failed to read XML"));
4497
        goto cleanup;
4498 4499 4500
    }

    /* Create a domain from this XML */
4501 4502
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE))) {
4503
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4504
                         "%s", _("failed to parse XML"));
4505
        goto cleanup;
4506 4507
    }

4508 4509
    if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
        goto cleanup;
4510

4511
    if (!(vm = virDomainAssignDef(conn,
4512
                                  driver->caps,
4513 4514
                                  &driver->domains,
                                  def))) {
4515
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4516
                         "%s", _("failed to assign new VM"));
4517
        goto cleanup;
4518
    }
4519
    def = NULL;
4520

4521 4522 4523
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

4524 4525
    if (header.version == 2) {
        const char *intermediate_argv[3] = { NULL, "-dc", NULL };
4526 4527
        const char *prog = qemudSaveCompressionTypeToString(header.compressed);
        if (prog == NULL) {
4528
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
4529
                             _("Invalid compressed save format %d"),
4530
                             header.compressed);
4531
            goto endjob;
4532
        }
4533

4534
        if (header.compressed != QEMUD_SAVE_FORMAT_RAW) {
4535
            intermediate_argv[0] = prog;
4536 4537 4538 4539 4540 4541 4542
            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]);
4543
                goto endjob;
4544 4545 4546
            }
        }
    }
4547
    /* Set the migration source and start it up. */
4548
    ret = qemudStartVMDaemon(conn, driver, vm, "stdio", fd);
4549 4550 4551 4552 4553 4554 4555
    if (intermediate_pid != -1) {
        /* Wait for intermediate process to exit */
        while (waitpid(intermediate_pid, &childstat, 0) == -1 &&
               errno == EINTR);
    }
    if (intermediatefd != -1)
        close(intermediatefd);
4556
    close(fd);
4557
    fd = -1;
4558
    if (ret < 0) {
4559
        if (!vm->persistent) {
4560 4561 4562
            if (qemuDomainObjEndJob(vm) > 0)
                virDomainRemoveInactive(&driver->domains,
                                        vm);
4563 4564
            vm = NULL;
        }
4565
        goto endjob;
4566 4567
    }

4568 4569 4570
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_RESTORED);
4571

4572 4573
    /* If it was running before, resume it now. */
    if (header.was_running) {
4574
        qemuDomainObjPrivatePtr priv = vm->privateData;
4575
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
4576
        if (qemuMonitorStartCPUs(priv->mon, conn) < 0) {
4577 4578 4579
            if (virGetLastError() == NULL)
                qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                                 "%s", _("failed to resume domain"));
4580 4581
            qemuDomainObjExitMonitorWithDriver(driver,vm);
            goto endjob;
4582
        }
4583
        qemuDomainObjExitMonitorWithDriver(driver, vm);
4584
        vm->state = VIR_DOMAIN_RUNNING;
4585
        virDomainSaveStatus(conn, driver->caps, driver->stateDir, vm);
4586
    }
4587
    ret = 0;
4588

4589
endjob:
4590 4591 4592
    if (vm &&
        qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
4593

4594 4595 4596 4597 4598
cleanup:
    virDomainDefFree(def);
    VIR_FREE(xml);
    if (fd != -1)
        close(fd);
4599 4600
    if (vm)
        virDomainObjUnlock(vm);
4601 4602
    if (event)
        qemuDomainEventQueue(driver, event);
4603
    qemuDriverUnlock(driver);
4604
    return ret;
D
Daniel P. Berrange 已提交
4605 4606 4607
}


4608
static char *qemudDomainDumpXML(virDomainPtr dom,
4609
                                int flags) {
4610 4611 4612
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *ret = NULL;
4613 4614
    unsigned long balloon;
    int err;
4615

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

D
Daniel P. Berrange 已提交
4620
    if (!vm) {
4621 4622 4623 4624
        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);
4625
        goto cleanup;
D
Daniel P. Berrange 已提交
4626 4627
    }

4628
    /* Refresh current memory based on balloon info */
D
Daniel P. Berrange 已提交
4629
    if (virDomainObjIsActive(vm)) {
4630
        qemuDomainObjPrivatePtr priv = vm->privateData;
4631 4632 4633 4634 4635 4636 4637 4638 4639
        /* Don't delay if someone's using the monitor, just use
         * existing most recent data instead */
        if (!priv->jobActive) {
            if (qemuDomainObjBeginJob(vm) < 0)
                goto cleanup;

            qemuDomainObjEnterMonitor(vm);
            err = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
            qemuDomainObjExitMonitor(vm);
4640 4641 4642 4643
            if (qemuDomainObjEndJob(vm) == 0) {
                vm = NULL;
                goto cleanup;
            }
4644 4645 4646 4647 4648 4649
            if (err < 0)
                goto cleanup;
            if (err > 0)
                vm->def->memory = balloon;
            /* err == 0 indicates no balloon support, so ignore it */
        }
4650
    }
4651

4652 4653 4654 4655 4656 4657
    ret = virDomainDefFormat(dom->conn,
                             (flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ?
                             vm->newDef : vm->def,
                             flags);

cleanup:
4658 4659
    if (vm)
        virDomainObjUnlock(vm);
4660
    return ret;
D
Daniel P. Berrange 已提交
4661 4662 4663
}


4664 4665 4666 4667
static char *qemuDomainXMLFromNative(virConnectPtr conn,
                                     const char *format,
                                     const char *config,
                                     unsigned int flags ATTRIBUTE_UNUSED) {
4668
    struct qemud_driver *driver = conn->privateData;
4669 4670 4671 4672 4673 4674 4675 4676 4677
    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;
    }

4678
    qemuDriverLock(driver);
4679
    def = qemuParseCommandLineString(conn, driver->caps, config);
4680
    qemuDriverUnlock(driver);
4681 4682 4683 4684 4685 4686 4687 4688 4689 4690
    if (!def)
        goto cleanup;

    xml = virDomainDefFormat(conn, def, VIR_DOMAIN_XML_INACTIVE);

cleanup:
    virDomainDefFree(def);
    return xml;
}

4691 4692 4693 4694 4695 4696
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;
4697
    virDomainChrDef monConfig;
4698 4699 4700 4701 4702 4703 4704 4705 4706 4707
    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;

4708 4709
    qemuDriverLock(driver);

4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775
    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;
    }

4776
    if (qemuPrepareMonitorChr(conn, driver, &monConfig, def->name) < 0)
4777
        goto cleanup;
4778 4779

    if (qemudBuildCommandLine(conn, driver, def,
D
Daniel P. Berrange 已提交
4780
                              &monConfig, 0, qemuCmdFlags,
4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799
                              &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++;
    }

4800 4801 4802
    if (virBufferError(&buf)) {
        virBufferFreeAndReset(&buf);
        virReportOOMError(conn);
4803
        goto cleanup;
4804
    }
4805 4806 4807 4808

    ret = virBufferContentAndReset(&buf);

cleanup:
4809
    qemuDriverUnlock(driver);
4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822
    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;
}


4823
static int qemudListDefinedDomains(virConnectPtr conn,
4824
                            char **const names, int nnames) {
4825
    struct qemud_driver *driver = conn->privateData;
4826
    int n;
4827

4828
    qemuDriverLock(driver);
4829
    n = virDomainObjListGetInactiveNames(&driver->domains, names, nnames);
4830
    qemuDriverUnlock(driver);
4831
    return n;
D
Daniel P. Berrange 已提交
4832 4833
}

4834
static int qemudNumDefinedDomains(virConnectPtr conn) {
4835
    struct qemud_driver *driver = conn->privateData;
4836
    int n;
4837

4838
    qemuDriverLock(driver);
4839
    n = virDomainObjListNumOfDomains(&driver->domains, 0);
4840
    qemuDriverUnlock(driver);
4841

4842
    return n;
D
Daniel P. Berrange 已提交
4843 4844 4845
}


4846
static int qemudDomainStart(virDomainPtr dom) {
4847 4848 4849
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
4850
    virDomainEventPtr event = NULL;
4851

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

4855
    if (!vm) {
4856 4857 4858 4859
        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);
4860
        goto cleanup;
4861 4862
    }

4863 4864 4865 4866 4867 4868 4869 4870 4871
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

    if (virDomainObjIsActive(vm)) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is already running"));
        goto endjob;
    }

4872
    ret = qemudStartVMDaemon(dom->conn, driver, vm, NULL, -1);
4873
    if (ret != -1)
4874 4875 4876
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STARTED,
                                         VIR_DOMAIN_EVENT_STARTED_BOOTED);
4877

4878
endjob:
4879 4880
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
4881

4882
cleanup:
4883 4884
    if (vm)
        virDomainObjUnlock(vm);
4885
    if (event)
4886
        qemuDomainEventQueue(driver, event);
4887
    qemuDriverUnlock(driver);
4888
    return ret;
D
Daniel P. Berrange 已提交
4889 4890
}

4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904 4905
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;

4906
        if (STRNEQ(def->os.machine, machine->name))
4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919
            continue;

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

        break;
    }

    return 0;
}

4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934
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;

4935
        if (STRNEQ(def->os.machine, machines[i]->name))
4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947
            continue;

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

    virCapabilitiesFreeMachines(machines, nmachines);

    return 0;
}

4948 4949
int
qemudCanonicalizeMachine(struct qemud_driver *driver, virDomainDefPtr def)
4950 4951 4952 4953 4954 4955
{
    char *canonical = NULL;
    int i;

    for (i = 0; i < driver->caps->nguests; i++) {
        virCapsGuestPtr guest = driver->caps->guests[i];
4956
        virCapsGuestDomainInfoPtr info;
4957 4958 4959
        int j;

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

4962 4963 4964 4965 4966 4967 4968 4969 4970
            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;
4971 4972
        }

4973 4974 4975 4976
        info = &guest->arch.defaultInfo;

        if (info->emulator && STREQ(info->emulator, def->emulator)) {
            if (qemudCanonicalizeMachineFromInfo(def, info, &canonical) < 0)
4977 4978 4979 4980
                return -1;
            goto out;
        }
    }
4981 4982 4983 4984

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

4985 4986 4987 4988 4989 4990 4991
out:
    if (canonical) {
        VIR_FREE(def->os.machine);
        def->os.machine = canonical;
    }
    return 0;
}
D
Daniel P. Berrange 已提交
4992

4993
static virDomainPtr qemudDomainDefine(virConnectPtr conn, const char *xml) {
4994
    struct qemud_driver *driver = conn->privateData;
4995
    virDomainDefPtr def;
4996
    virDomainObjPtr vm = NULL;
4997
    virDomainPtr dom = NULL;
4998
    virDomainEventPtr event = NULL;
4999
    int dupVM;
5000

5001
    qemuDriverLock(driver);
5002 5003
    if (!(def = virDomainDefParseString(conn, driver->caps, xml,
                                        VIR_DOMAIN_XML_INACTIVE)))
5004
        goto cleanup;
5005

5006 5007 5008
    if (virSecurityDriverVerify(conn, def) < 0)
        goto cleanup;

5009 5010
    if ((dupVM = virDomainObjIsDuplicate(&driver->domains, def, 0)) < 0)
        goto cleanup;
5011

5012
    if (qemudCanonicalizeMachine(driver, def) < 0)
5013 5014
        goto cleanup;

5015
    if (!(vm = virDomainAssignDef(conn,
5016
                                  driver->caps,
5017 5018
                                  &driver->domains,
                                  def))) {
5019
        goto cleanup;
5020
    }
5021
    def = NULL;
5022
    vm->persistent = 1;
5023

5024 5025
    if (virDomainSaveConfig(conn,
                            driver->configDir,
5026
                            vm->newDef ? vm->newDef : vm->def) < 0) {
5027 5028
        virDomainRemoveInactive(&driver->domains,
                                vm);
5029
        vm = NULL;
5030
        goto cleanup;
5031 5032
    }

5033 5034
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_DEFINED,
5035
                                     !dupVM ?
5036 5037
                                     VIR_DOMAIN_EVENT_DEFINED_ADDED :
                                     VIR_DOMAIN_EVENT_DEFINED_UPDATED);
5038

5039
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
5040
    if (dom) dom->id = vm->def->id;
5041 5042

cleanup:
5043
    virDomainDefFree(def);
5044 5045
    if (vm)
        virDomainObjUnlock(vm);
5046 5047
    if (event)
        qemuDomainEventQueue(driver, event);
5048
    qemuDriverUnlock(driver);
5049
    return dom;
D
Daniel P. Berrange 已提交
5050 5051
}

5052
static int qemudDomainUndefine(virDomainPtr dom) {
5053 5054
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
5055
    virDomainEventPtr event = NULL;
5056
    int ret = -1;
D
Daniel P. Berrange 已提交
5057

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

D
Daniel P. Berrange 已提交
5061
    if (!vm) {
5062 5063 5064 5065
        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);
5066
        goto cleanup;
D
Daniel P. Berrange 已提交
5067 5068
    }

D
Daniel P. Berrange 已提交
5069
    if (virDomainObjIsActive(vm)) {
5070
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
5071
                         "%s", _("cannot delete active domain"));
5072
        goto cleanup;
D
Daniel P. Berrange 已提交
5073 5074
    }

5075 5076 5077
    if (!vm->persistent) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("cannot undefine transient domain"));
5078
        goto cleanup;
5079 5080 5081
    }

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

5084 5085 5086
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_UNDEFINED,
                                     VIR_DOMAIN_EVENT_UNDEFINED_REMOVED);
5087

5088 5089
    virDomainRemoveInactive(&driver->domains,
                            vm);
5090
    vm = NULL;
5091
    ret = 0;
D
Daniel P. Berrange 已提交
5092

5093
cleanup:
5094 5095
    if (vm)
        virDomainObjUnlock(vm);
5096 5097
    if (event)
        qemuDomainEventQueue(driver, event);
5098
    qemuDriverUnlock(driver);
5099
    return ret;
D
Daniel P. Berrange 已提交
5100 5101
}

5102

5103
static int qemudDomainChangeEjectableMedia(virConnectPtr conn,
5104
                                           struct qemud_driver *driver,
5105
                                           virDomainObjPtr vm,
5106
                                           virDomainDiskDefPtr disk)
5107
{
5108
    virDomainDiskDefPtr origdisk = NULL;
5109
    int i;
5110
    int ret;
5111

5112
    origdisk = NULL;
5113
    for (i = 0 ; i < vm->def->ndisks ; i++) {
5114 5115
        if (vm->def->disks[i]->bus == disk->bus &&
            STREQ(vm->def->disks[i]->dst, disk->dst)) {
5116
            origdisk = vm->def->disks[i];
5117
            break;
5118
        }
5119 5120 5121
    }

    if (!origdisk) {
5122
        qemudReportError(conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
5123
                         _("No device with bus '%s' and target '%s'"),
5124 5125
                         virDomainDiskBusTypeToString(disk->bus),
                         disk->dst);
5126 5127 5128
        return -1;
    }

5129 5130 5131 5132 5133
    if (!origdisk->info.alias) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("missing disk device alias name for %s"), origdisk->dst);
        return -1;
    }
5134

5135 5136 5137 5138
    if (origdisk->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
        origdisk->device != VIR_DOMAIN_DISK_DEVICE_CDROM) {
        qemudReportError(conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Removable media not supported for %s device"),
5139
                         virDomainDiskDeviceTypeToString(disk->device));
5140
        return -1;
5141
    }
5142

5143 5144
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityImageLabel &&
5145
        driver->securityDriver->domainSetSecurityImageLabel(conn, vm, disk) < 0)
5146 5147
        return -1;

5148
    qemuDomainObjPrivatePtr priv = vm->privateData;
5149
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
5150
    if (disk->src) {
5151
        const char *format = NULL;
5152 5153 5154
        if (disk->type != VIR_DOMAIN_DISK_TYPE_DIR) {
            if (disk->driverType)
                format = disk->driverType;
5155 5156 5157
            else if (origdisk->driverType)
                format = origdisk->driverType;
        }
5158 5159
        ret = qemuMonitorChangeMedia(priv->mon,
                                     origdisk->info.alias,
5160
                                     disk->src, format);
5161
    } else {
5162
        ret = qemuMonitorEjectMedia(priv->mon, origdisk->info.alias);
5163
    }
5164
    qemuDomainObjExitMonitorWithDriver(driver, vm);
5165

5166 5167 5168 5169 5170 5171 5172 5173 5174
    if (ret < 0)
        goto error;

    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSecurityImageLabel &&
        driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, origdisk) < 0)
        VIR_WARN("Unable to restore security label on ejected image %s", origdisk->src);

    VIR_FREE(origdisk->src);
5175 5176 5177 5178 5179
    origdisk->src = disk->src;
    disk->src = NULL;
    origdisk->type = disk->type;

    virDomainDiskDefFree(disk);
5180

5181
    return ret;
5182 5183 5184 5185

error:
    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSecurityImageLabel &&
5186 5187
        driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, disk) < 0)
        VIR_WARN("Unable to restore security label on new media %s", disk->src);
5188
    return -1;
5189 5190
}

5191

5192
static int qemudDomainAttachPciDiskDevice(virConnectPtr conn,
5193
                                          struct qemud_driver *driver,
5194
                                          virDomainObjPtr vm,
5195
                                          virDomainDiskDefPtr disk)
5196
{
5197
    int i, ret;
5198
    const char* type = virDomainDiskBusTypeToString(disk->bus);
5199
    qemuDomainObjPrivatePtr priv = vm->privateData;
5200
    virDomainDevicePCIAddress guestAddr;
5201 5202

    for (i = 0 ; i < vm->def->ndisks ; i++) {
5203
        if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
5204
            qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
5205
                           _("target %s already exists"), disk->dst);
5206 5207 5208 5209
            return -1;
        }
    }

5210 5211
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityImageLabel &&
5212
        driver->securityDriver->domainSetSecurityImageLabel(conn, vm, disk) < 0)
5213 5214
        return -1;

5215
    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
5216
        virReportOOMError(conn);
5217
        goto error;
5218 5219
    }

5220
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
5221
    ret = qemuMonitorAddPCIDisk(priv->mon,
5222
                                disk->src,
5223
                                type,
5224
                                &guestAddr);
5225
    qemuDomainObjExitMonitorWithDriver(driver, vm);
5226

5227 5228
    if (ret < 0)
        goto error;
5229

5230 5231 5232
    disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
    memcpy(&disk->info.addr.pci, &guestAddr, sizeof(guestAddr));
    virDomainDiskInsertPreAlloced(vm->def, disk);
5233 5234 5235 5236 5237 5238

    return 0;

error:
    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSecurityImageLabel &&
5239 5240
        driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, disk) < 0)
        VIR_WARN("Unable to restore security label on %s", disk->src);
5241 5242

    return -1;
5243
}
5244

5245

5246 5247 5248
static int qemudDomainAttachPciControllerDevice(virConnectPtr conn,
                                                struct qemud_driver *driver,
                                                virDomainObjPtr vm,
5249
                                                virDomainControllerDefPtr controller)
5250 5251
{
    int i, ret;
5252
    const char* type = virDomainControllerTypeToString(controller->type);
5253 5254 5255
    qemuDomainObjPrivatePtr priv = vm->privateData;

    for (i = 0 ; i < vm->def->ncontrollers ; i++) {
5256 5257
        if ((vm->def->controllers[i]->type == controller->type) &&
            (vm->def->controllers[i]->idx == controller->idx)) {
5258 5259
            qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                             _("target %s:%d already exists"),
5260
                             type, controller->idx);
5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272
            return -1;
        }
    }

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

    qemuDomainObjEnterMonitorWithDriver(driver, vm);
    ret = qemuMonitorAttachPCIDiskController(priv->mon,
                                             type,
5273
                                             &controller->info.addr.pci);
5274 5275 5276
    qemuDomainObjExitMonitorWithDriver(driver, vm);

    if (ret == 0) {
5277 5278
        controller->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
        virDomainControllerInsertPreAlloced(vm->def, controller);
5279 5280 5281 5282 5283
    }

    return ret;
}

5284

5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320
static virDomainControllerDefPtr
qemuDomainFindOrCreateSCSIDiskController(virConnectPtr conn,
                                         struct qemud_driver *driver,
                                         virDomainObjPtr vm,
                                         int controller)
{
    int i;
    virDomainControllerDefPtr cont;
    for (i = 0 ; i < vm->def->ncontrollers ; i++) {
        cont = vm->def->controllers[i];

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

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

    /* No SCSI controller present, for back compatability we
     * now hotplug a controller */
    if (VIR_ALLOC(cont) < 0) {
        virReportOOMError(conn);
        return NULL;
    }
    cont->type = VIR_DOMAIN_CONTROLLER_TYPE_SCSI;
    cont->idx = 0;

    VIR_INFO0("No SCSI controller present, hotplugging one");
    if (qemudDomainAttachPciControllerDevice(conn, driver,
                                             vm, cont) < 0) {
        VIR_FREE(cont);
        return NULL;
    }
    return cont;
}

5321

5322 5323 5324
static int qemudDomainAttachSCSIDisk(virConnectPtr conn,
                                     struct qemud_driver *driver,
                                     virDomainObjPtr vm,
5325
                                     virDomainDiskDefPtr disk,
5326 5327 5328 5329 5330 5331 5332 5333 5334 5335
                                     int qemuCmdFlags)
{
    int i;
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainDeviceDriveAddress driveAddr;
    virDomainControllerDefPtr cont;
    char *drivestr = NULL;
    int ret = -1;

    for (i = 0 ; i < vm->def->ndisks ; i++) {
5336
        if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
5337
            qemudReportError(conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
5338
                           _("target %s already exists"), disk->dst);
5339
            return -1;
5340 5341 5342
        }
    }

5343 5344 5345

    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityImageLabel &&
5346
        driver->securityDriver->domainSetSecurityImageLabel(conn, vm, disk) < 0)
5347 5348
        return -1;

5349 5350 5351
    /* This func allocates the bus/unit IDs so must be before
     * we search for controller
     */
5352
    if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCmdFlags)))
5353
        goto error;
5354 5355 5356


    /* We should have an adddress now, so make sure */
5357
    if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
5358 5359
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("unexpected disk address type %s"),
5360
                         virDomainDeviceAddressTypeToString(disk->info.type));
5361
        goto error;
5362 5363
    }

5364
    for (i = 0 ; i <= disk->info.addr.drive.controller ; i++) {
5365 5366
        cont = qemuDomainFindOrCreateSCSIDiskController(conn, driver, vm, i);
        if (!cont)
5367
            goto error;
5368 5369 5370 5371 5372
    }

    if (cont->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("SCSI controller %d was missing its PCI address"), cont->idx);
5373
        goto error;
5374 5375 5376 5377
    }

    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
        virReportOOMError(conn);
5378
        goto error;
5379 5380 5381 5382 5383 5384 5385 5386 5387
    }

    qemuDomainObjEnterMonitorWithDriver(driver, vm);
    ret = qemuMonitorAttachDrive(priv->mon,
                                 drivestr,
                                 &cont->info.addr.pci,
                                 &driveAddr);
    qemuDomainObjExitMonitorWithDriver(driver, vm);

5388 5389
    if (ret < 0)
        goto error;
5390

5391 5392
    /* XXX we should probably validate that the addr matches
     * our existing defined addr instead of overwriting */
5393 5394 5395
    disk->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE;
    memcpy(&disk->info.addr.drive, &driveAddr, sizeof(driveAddr));
    virDomainDiskInsertPreAlloced(vm->def, disk);
5396
    VIR_FREE(drivestr);
5397 5398 5399 5400 5401 5402 5403

    return 0;

error:
    VIR_FREE(drivestr);
    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSecurityImageLabel &&
5404 5405
        driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, disk) < 0)
        VIR_WARN("Unable to restore security label on %s", disk->src);
5406 5407

    return -1;
5408 5409
}

5410

5411
static int qemudDomainAttachUsbMassstorageDevice(virConnectPtr conn,
5412
                                                 struct qemud_driver *driver,
5413
                                                 virDomainObjPtr vm,
5414
                                                 virDomainDiskDefPtr disk)
5415
{
5416
    qemuDomainObjPrivatePtr priv = vm->privateData;
5417
    int i, ret;
5418

5419
    for (i = 0 ; i < vm->def->ndisks ; i++) {
5420
        if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
5421
            qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5422
                           _("target %s already exists"), disk->dst);
5423 5424 5425 5426
            return -1;
        }
    }

5427 5428
    if (driver->securityDriver &&
        driver->securityDriver->domainSetSecurityImageLabel &&
5429
        driver->securityDriver->domainSetSecurityImageLabel(conn, vm, disk) < 0)
5430 5431
        return -1;

5432
    if (!disk->src) {
5433 5434
        qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("disk source path is missing"));
5435
        goto error;
5436 5437
    }

5438
    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
5439
        virReportOOMError(conn);
5440
        goto error;
5441 5442
    }

5443
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
5444
    ret = qemuMonitorAddUSBDisk(priv->mon, disk->src);
5445
    qemuDomainObjExitMonitorWithDriver(driver, vm);
5446

5447 5448 5449
    if (ret < 0)
        goto error;

5450
    virDomainDiskInsertPreAlloced(vm->def, disk);
5451

5452 5453 5454 5455 5456
    return 0;

error:
    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSecurityImageLabel &&
5457 5458
        driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, disk) < 0)
        VIR_WARN("Unable to restore security label on %s", disk->src);
5459 5460

    return -1;
5461 5462
}

5463

M
Mark McLoughlin 已提交
5464
static int qemudDomainAttachNetDevice(virConnectPtr conn,
5465
                                      struct qemud_driver *driver,
M
Mark McLoughlin 已提交
5466
                                      virDomainObjPtr vm,
5467
                                      virDomainNetDefPtr net,
M
Mark McLoughlin 已提交
5468 5469
                                      unsigned int qemuCmdFlags)
{
5470
    qemuDomainObjPrivatePtr priv = vm->privateData;
5471
    char *tapfd_name = NULL;
5472
    int i, tapfd = -1;
5473
    char *nicstr = NULL;
5474
    char *netstr = NULL;
5475
    int ret = -1;
5476
    virDomainDevicePCIAddress guestAddr;
M
Mark McLoughlin 已提交
5477 5478 5479 5480 5481 5482 5483 5484 5485

    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) {
5486
        if (priv->monConfig->type != VIR_DOMAIN_CHR_TYPE_UNIX) {
5487 5488 5489 5490 5491 5492 5493 5494 5495
            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 已提交
5496 5497
    }

5498 5499
    if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
        goto no_memory;
M
Mark McLoughlin 已提交
5500 5501

    if ((qemuCmdFlags & QEMUD_CMD_FLAG_NET_NAME) &&
5502 5503
        qemuAssignNetNames(vm->def, net) < 0)
        goto no_memory;
M
Mark McLoughlin 已提交
5504 5505 5506 5507 5508 5509 5510 5511 5512

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

5513 5514 5515 5516
    if (tapfd != -1) {
        if (virAsprintf(&tapfd_name, "fd-%s", net->hostnet_name) < 0)
            goto no_memory;

5517
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
5518
        if (qemuMonitorSendFileHandle(priv->mon, tapfd_name, tapfd) < 0) {
5519
            qemuDomainObjExitMonitorWithDriver(driver, vm);
5520
            goto cleanup;
5521
        }
5522
        qemuDomainObjExitMonitorWithDriver(driver, vm);
5523 5524
    }

5525 5526
    if (qemuBuildHostNetStr(conn, net, ' ',
                            net->vlan, tapfd_name, &netstr) < 0)
5527
        goto try_tapfd_close;
M
Mark McLoughlin 已提交
5528

5529
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
5530
    if (qemuMonitorAddHostNetwork(priv->mon, netstr) < 0) {
5531
        qemuDomainObjExitMonitorWithDriver(driver, vm);
5532
        goto try_tapfd_close;
5533
    }
5534
    qemuDomainObjExitMonitorWithDriver(driver, vm);
M
Mark McLoughlin 已提交
5535

5536 5537 5538
    if (tapfd != -1)
        close(tapfd);
    tapfd = -1;
M
Mark McLoughlin 已提交
5539

5540
    if (qemuBuildNicStr(conn, net, NULL, net->vlan, &nicstr) < 0)
5541
        goto try_remove;
M
Mark McLoughlin 已提交
5542

5543
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
5544
    if (qemuMonitorAddPCINetwork(priv->mon, nicstr,
5545
                                 &guestAddr) < 0) {
5546
        qemuDomainObjExitMonitorWithDriver(driver, vm);
5547
        goto try_remove;
5548
    }
5549
    net->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
5550
    memcpy(&net->info.addr.pci, &guestAddr, sizeof(guestAddr));
5551
    qemuDomainObjExitMonitorWithDriver(driver, vm);
5552

5553
    ret = 0;
M
Mark McLoughlin 已提交
5554 5555 5556

    vm->def->nets[vm->def->nnets++] = net;

5557 5558 5559 5560 5561 5562
cleanup:
    VIR_FREE(nicstr);
    VIR_FREE(netstr);
    VIR_FREE(tapfd_name);
    if (tapfd != -1)
        close(tapfd);
5563

5564
    return ret;
5565

5566 5567
try_remove:
    if (!net->hostnet_name || net->vlan == 0)
5568
        VIR_WARN0(_("Unable to remove network backend"));
5569
    else {
5570
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
5571 5572 5573
        if (qemuMonitorRemoveHostNetwork(priv->mon, net->vlan, net->hostnet_name) < 0)
            VIR_WARN(_("Failed to remove network backend for vlan %d, net %s"),
                     net->vlan, net->hostnet_name);
5574
        qemuDomainObjExitMonitorWithDriver(driver, vm);
5575
    }
5576
    goto cleanup;
5577

5578
try_tapfd_close:
5579
    if (tapfd_name) {
5580
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
5581
        if (qemuMonitorCloseFileHandle(priv->mon, tapfd_name) < 0)
5582
            VIR_WARN(_("Failed to close tapfd with '%s'"), tapfd_name);
5583
        qemuDomainObjExitMonitorWithDriver(driver, vm);
5584
    }
5585

5586 5587
    goto cleanup;

5588 5589
no_memory:
    virReportOOMError(conn);
5590
    goto cleanup;
M
Mark McLoughlin 已提交
5591 5592
}

5593

5594
static int qemudDomainAttachHostPciDevice(virConnectPtr conn,
5595
                                          struct qemud_driver *driver,
5596
                                          virDomainObjPtr vm,
5597
                                          virDomainHostdevDefPtr hostdev)
5598
{
5599
    qemuDomainObjPrivatePtr priv = vm->privateData;
5600
    pciDevice *pci;
5601
    int ret;
5602
    virDomainDevicePCIAddress guestAddr;
5603 5604 5605 5606 5607 5608

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

5609 5610 5611 5612 5613
    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);
5614
    if (!pci)
5615
        return -1;
5616

5617 5618
    if (!pciDeviceIsAssignable(conn, pci, !driver->relaxedACS) ||
        (hostdev->managed && pciDettachDevice(conn, pci) < 0) ||
5619 5620 5621 5622 5623 5624
        pciResetDevice(conn, pci, driver->activePciHostdevs) < 0) {
        pciFreeDevice(conn, pci);
        return -1;
    }

    if (pciDeviceListAdd(conn, driver->activePciHostdevs, pci) < 0) {
5625
        pciFreeDevice(conn, pci);
5626
        return -1;
5627 5628
    }

5629
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
5630
    ret = qemuMonitorAddPCIHostDevice(priv->mon,
5631 5632
                                      &hostdev->source.subsys.u.pci,
                                      &guestAddr);
5633
    qemuDomainObjExitMonitorWithDriver(driver, vm);
5634
    if (ret < 0)
5635
        goto error;
5636
    hostdev->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
5637
    memcpy(&hostdev->info.addr.pci, &guestAddr, sizeof(guestAddr));
5638 5639 5640 5641

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

    return 0;
5642 5643 5644 5645 5646

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

    return -1;
5647 5648
}

5649

M
Mark McLoughlin 已提交
5650
static int qemudDomainAttachHostUsbDevice(virConnectPtr conn,
5651
                                          struct qemud_driver *driver,
M
Mark McLoughlin 已提交
5652
                                          virDomainObjPtr vm,
5653
                                          virDomainHostdevDefPtr hostdev)
5654 5655
{
    int ret;
5656
    qemuDomainObjPrivatePtr priv = vm->privateData;
5657

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

5663
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
5664
    if (hostdev->source.subsys.u.usb.vendor) {
5665
        ret = qemuMonitorAddUSBDeviceMatch(priv->mon,
5666 5667
                                           hostdev->source.subsys.u.usb.vendor,
                                           hostdev->source.subsys.u.usb.product);
5668
    } else {
5669
        ret = qemuMonitorAddUSBDeviceExact(priv->mon,
5670 5671
                                           hostdev->source.subsys.u.usb.bus,
                                           hostdev->source.subsys.u.usb.device);
5672
    }
5673
    qemuDomainObjExitMonitorWithDriver(driver, vm);
5674

5675 5676
    if (ret == 0)
        vm->def->hostdevs[vm->def->nhostdevs++] = hostdev;
5677

5678
    return ret;
5679 5680
}

5681

M
Mark McLoughlin 已提交
5682 5683 5684
static int qemudDomainAttachHostDevice(virConnectPtr conn,
                                       struct qemud_driver *driver,
                                       virDomainObjPtr vm,
5685
                                       virDomainHostdevDefPtr hostdev)
M
Mark McLoughlin 已提交
5686 5687 5688 5689 5690 5691 5692 5693
{
    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;
    }

5694
    if (driver->securityDriver &&
5695
        driver->securityDriver->domainSetSecurityHostdevLabel &&
5696
        driver->securityDriver->domainSetSecurityHostdevLabel(conn, vm, hostdev) < 0)
5697
        return -1;
M
Mark McLoughlin 已提交
5698 5699

    switch (hostdev->source.subsys.type) {
5700
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
5701
        if (qemudDomainAttachHostPciDevice(conn, driver, vm, hostdev) < 0)
5702 5703 5704
            goto error;
        break;

M
Mark McLoughlin 已提交
5705
    case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
5706
        if (qemudDomainAttachHostUsbDevice(conn, driver, vm, hostdev) < 0)
5707 5708 5709
            goto error;
        break;

M
Mark McLoughlin 已提交
5710 5711 5712 5713
    default:
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         _("hostdev subsys type '%s' not supported"),
                         virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
5714
        goto error;
M
Mark McLoughlin 已提交
5715
    }
5716 5717 5718 5719 5720 5721

    return 0;

error:
    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSecurityHostdevLabel &&
5722
        driver->securityDriver->domainRestoreSecurityHostdevLabel(conn, vm, hostdev) < 0)
5723 5724 5725
        VIR_WARN0("Unable to restore host device labelling on hotplug fail");

    return -1;
M
Mark McLoughlin 已提交
5726 5727
}

5728

5729
static int qemudDomainAttachDevice(virDomainPtr dom,
5730 5731
                                   const char *xml)
{
5732 5733 5734
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr dev = NULL;
5735
    unsigned int qemuCmdFlags;
5736
    virCgroupPtr cgroup = NULL;
5737
    int ret = -1;
5738

5739
    qemuDriverLock(driver);
5740
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
5741
    if (!vm) {
5742 5743 5744 5745
        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);
5746
        goto cleanup;
5747 5748
    }

5749 5750 5751
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
5752
    if (!virDomainObjIsActive(vm)) {
5753
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
5754
                         "%s", _("cannot attach device on inactive domain"));
5755
        goto endjob;
5756 5757
    }

5758 5759
    dev = virDomainDeviceDefParse(dom->conn, driver->caps, vm->def, xml,
                                  VIR_DOMAIN_XML_INACTIVE);
5760
    if (dev == NULL)
5761
        goto endjob;
5762

5763 5764 5765
    if (qemudExtractVersionInfo(vm->def->emulator,
                                NULL,
                                &qemuCmdFlags) < 0)
5766
        goto endjob;
5767

5768
    if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
5769
        if (qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_DEVICES)) {
5770 5771 5772 5773
            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);
5774
                goto endjob;
5775 5776 5777 5778 5779 5780 5781 5782
            }
            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);
5783
                goto endjob;
5784 5785 5786
            }
        }

5787
        switch (dev->data.disk->device) {
5788 5789
        case VIR_DOMAIN_DISK_DEVICE_CDROM:
        case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
5790 5791 5792
            ret = qemudDomainChangeEjectableMedia(dom->conn, driver, vm, dev->data.disk);
            if (ret == 0)
                dev->data.disk = NULL;
5793
            break;
5794

5795 5796
        case VIR_DOMAIN_DISK_DEVICE_DISK:
            if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
5797 5798 5799
                ret = qemudDomainAttachUsbMassstorageDevice(dom->conn, driver, vm, dev->data.disk);
                if (ret == 0)
                    dev->data.disk = NULL;
5800
            } else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) {
5801 5802 5803
                ret = qemudDomainAttachPciDiskDevice(dom->conn, driver, vm, dev->data.disk);
                if (ret == 0)
                    dev->data.disk = NULL;
5804 5805
            } else if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
                ret = qemudDomainAttachSCSIDisk(dom->conn, driver, vm, dev->data.disk, qemuCmdFlags);
5806 5807
                if (ret == 0)
                    dev->data.disk = NULL;
5808 5809 5810 5811
            } else {
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                                 _("disk bus '%s' cannot be hotplugged."),
                                 virDomainDiskBusTypeToString(dev->data.disk->bus));
5812
                /* fallthrough */
5813 5814
            }
            break;
5815

5816 5817
        default:
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
5818 5819
                             _("disk device type '%s' cannot be hotplugged"),
                             virDomainDiskDeviceTypeToString(dev->data.disk->device));
5820 5821
            /* Fallthrough */
        }
5822
        if (ret != 0 && cgroup) {
5823 5824
            virCgroupDenyDevicePath(cgroup,
                                    dev->data.disk->src);
5825
        }
5826 5827 5828 5829 5830 5831 5832 5833 5834
    } else if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) {
        if (dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
            ret = qemudDomainAttachPciControllerDevice(dom->conn, driver, vm, dev->data.controller);
        } else {
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                             _("disk controller bus '%s' cannot be hotplugged."),
                             virDomainControllerTypeToString(dev->data.controller->type));
            /* fallthrough */
        }
M
Mark McLoughlin 已提交
5835
    } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
5836 5837 5838
        ret = qemudDomainAttachNetDevice(dom->conn, driver, vm, dev->data.net, qemuCmdFlags);
        if (ret == 0)
            dev->data.net = NULL;
M
Mark McLoughlin 已提交
5839
    } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
5840 5841 5842
        ret = qemudDomainAttachHostDevice(dom->conn, driver, vm, dev->data.hostdev);
        if (ret == 0)
            dev->data.hostdev = NULL;
5843
    } else {
5844
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
5845 5846
                         _("device type '%s' cannot be attached"),
                         virDomainDeviceTypeToString(dev->type));
5847
        goto endjob;
5848 5849
    }

5850
    if (!ret && virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0)
5851 5852
        ret = -1;

5853
endjob:
5854 5855
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
5856

5857
cleanup:
5858 5859 5860
    if (cgroup)
        virCgroupFree(&cgroup);

5861
    virDomainDeviceDefFree(dev);
5862 5863
    if (vm)
        virDomainObjUnlock(vm);
5864
    qemuDriverUnlock(driver);
5865 5866 5867
    return ret;
}

5868
static int qemudDomainDetachPciDiskDevice(virConnectPtr conn,
5869 5870 5871
                                          struct qemud_driver *driver,
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
5872 5873 5874
{
    int i, ret = -1;
    virDomainDiskDefPtr detach = NULL;
5875
    qemuDomainObjPrivatePtr priv = vm->privateData;
5876 5877 5878 5879 5880 5881 5882 5883 5884

    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) {
5885
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
5886
                         _("disk %s not found"), dev->data.disk->dst);
5887
        goto cleanup;
5888 5889
    }

5890 5891 5892 5893
    if (!virDomainDeviceAddressIsValid(&detach->info,
                                       VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s",
                         _("device cannot be detached without a PCI address"));
5894
        goto cleanup;
5895 5896
    }

5897
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
5898
    if (qemuMonitorRemovePCIDevice(priv->mon,
5899
                                   &detach->info.addr.pci) < 0) {
5900
        qemuDomainObjExitMonitor(vm);
5901
        goto cleanup;
5902
    }
5903
    qemuDomainObjExitMonitorWithDriver(driver, vm);
5904

5905 5906 5907 5908 5909 5910 5911 5912 5913 5914
    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 {
5915
        VIR_FREE(vm->def->disks);
5916
        vm->def->ndisks = 0;
5917
    }
5918
    virDomainDiskDefFree(detach);
5919

5920 5921 5922 5923 5924
    if (driver->securityDriver &&
        driver->securityDriver->domainRestoreSecurityImageLabel &&
        driver->securityDriver->domainRestoreSecurityImageLabel(conn, vm, dev->data.disk) < 0)
        VIR_WARN("Unable to restore security label on %s", dev->data.disk->src);

5925
    ret = 0;
5926 5927

cleanup:
5928 5929 5930
    return ret;
}

5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991
static int qemudDomainDetachPciControllerDevice(virConnectPtr conn,
                                                struct qemud_driver *driver,
                                                virDomainObjPtr vm,
                                                virDomainDeviceDefPtr dev)
{
    int i, ret = -1;
    virDomainControllerDefPtr detach = NULL;
    qemuDomainObjPrivatePtr priv = vm->privateData;

    for (i = 0 ; i < vm->def->ncontrollers ; i++) {
        if ((vm->def->controllers[i]->type == dev->data.controller->type) &&
            (vm->def->controllers[i]->idx == dev->data.controller->idx)) {
            detach = vm->def->controllers[i];
            break;
        }
    }

    if (!detach) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         _("disk controller %s:%d not found"),
                         virDomainControllerTypeToString(dev->data.controller->type),
                         dev->data.controller->idx);
        goto cleanup;
    }

    if (!virDomainDeviceAddressIsValid(&detach->info,
                                       VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED, "%s",
                         _("device cannot be detached without a PCI address"));
        goto cleanup;
    }

    qemuDomainObjEnterMonitorWithDriver(driver, vm);
    if (qemuMonitorRemovePCIDevice(priv->mon,
                                   &detach->info.addr.pci) < 0) {
        qemuDomainObjExitMonitor(vm);
        goto cleanup;
    }
    qemuDomainObjExitMonitorWithDriver(driver, vm);

    if (vm->def->ncontrollers > 1) {
        memmove(vm->def->controllers + i,
                vm->def->controllers + i + 1,
                sizeof(*vm->def->controllers) *
                (vm->def->ncontrollers - (i + 1)));
        vm->def->ncontrollers--;
        if (VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers) < 0) {
            /* ignore, harmless */
        }
    } else {
        VIR_FREE(vm->def->controllers);
        vm->def->ncontrollers = 0;
    }
    virDomainControllerDefFree(detach);

    ret = 0;

cleanup:
    return ret;
}

5992 5993
static int
qemudDomainDetachNetDevice(virConnectPtr conn,
5994
                           struct qemud_driver *driver,
5995 5996 5997 5998 5999
                           virDomainObjPtr vm,
                           virDomainDeviceDefPtr dev)
{
    int i, ret = -1;
    virDomainNetDefPtr detach = NULL;
6000
    qemuDomainObjPrivatePtr priv = vm->privateData;
6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019

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

6020 6021 6022 6023 6024 6025 6026 6027
    if (!virDomainDeviceAddressIsValid(&detach->info,
                                       VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("device cannot be detached without a PCI address"));
        goto cleanup;
    }

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

6033
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
6034
    if (qemuMonitorRemovePCIDevice(priv->mon,
6035
                                   &detach->info.addr.pci) < 0) {
6036
        qemuDomainObjExitMonitorWithDriver(driver, vm);
6037
        goto cleanup;
6038
    }
6039

6040
    if (qemuMonitorRemoveHostNetwork(priv->mon, detach->vlan, detach->hostnet_name) < 0) {
6041
        qemuDomainObjExitMonitorWithDriver(driver, vm);
6042
        goto cleanup;
6043
    }
6044
    qemuDomainObjExitMonitorWithDriver(driver, vm);
6045

6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056
    if ((driver->macFilter) && (detach->ifname != NULL)) {
        if ((errno = networkDisallowMacOnPort(conn,
                                              driver,
                                              detach->ifname,
                                              detach->mac))) {
            virReportSystemError(conn, errno,
             _("failed to remove ebtables rule on  '%s'"),
                                 detach->ifname);
        }
    }

6057 6058 6059 6060 6061 6062 6063 6064 6065 6066
    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 {
6067
        VIR_FREE(vm->def->nets);
6068
        vm->def->nnets = 0;
6069
    }
6070
    virDomainNetDefFree(detach);
6071

6072 6073 6074 6075 6076 6077
    ret = 0;

cleanup:
    return ret;
}

6078
static int qemudDomainDetachHostPciDevice(virConnectPtr conn,
6079
                                          struct qemud_driver *driver,
6080 6081 6082
                                          virDomainObjPtr vm,
                                          virDomainDeviceDefPtr dev)
{
6083
    virDomainHostdevDefPtr detach = NULL;
6084
    qemuDomainObjPrivatePtr priv = vm->privateData;
6085
    int i, ret;
6086
    pciDevice *pci;
6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112

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

6113 6114
    if (!virDomainDeviceAddressIsValid(&detach->info,
                                       VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)) {
6115
        qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
6116
                         "%s", _("device cannot be detached without a PCI address"));
6117 6118 6119
        return -1;
    }

6120
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
6121
    if (qemuMonitorRemovePCIDevice(priv->mon,
6122
                                   &detach->info.addr.pci) < 0) {
6123
        qemuDomainObjExitMonitorWithDriver(driver, vm);
6124
        return -1;
6125
    }
6126
    qemuDomainObjExitMonitorWithDriver(driver, vm);
6127 6128 6129

    ret = 0;

6130 6131 6132 6133 6134 6135 6136 6137
    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 {
6138
        pciDeviceSetManaged(pci, detach->managed);
6139 6140
        pciDeviceListDel(conn, driver->activePciHostdevs, pci);
        if (pciResetDevice(conn, pci, driver->activePciHostdevs) < 0)
6141
            ret = -1;
6142
        qemudReattachManagedDevice(pci);
6143
        pciFreeDevice(conn, pci);
6144 6145
    }

6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157
    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;
6158
    }
6159
    virDomainHostdevDefFree(detach);
6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180

    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:
6181
        ret = qemudDomainDetachHostPciDevice(conn, driver, vm, dev);
6182
        break;
6183 6184 6185 6186 6187 6188 6189
    default:
        qemudReportError(conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         _("hostdev subsys type '%s' not supported"),
                         virDomainHostdevSubsysTypeToString(hostdev->source.subsys.type));
        return -1;
    }

6190
    if (driver->securityDriver &&
6191 6192 6193
        driver->securityDriver->domainRestoreSecurityHostdevLabel &&
        driver->securityDriver->domainRestoreSecurityHostdevLabel(conn, vm, dev->data.hostdev) < 0)
        VIR_WARN0("Failed to restore host device labelling");
6194

6195 6196 6197
    return ret;
}

6198 6199
static int qemudDomainDetachDevice(virDomainPtr dom,
                                   const char *xml) {
6200 6201 6202 6203
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr dev = NULL;
    int ret = -1;
6204

6205
    qemuDriverLock(driver);
6206
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
6207
    if (!vm) {
6208 6209 6210 6211
        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);
6212
        goto cleanup;
6213 6214
    }

6215 6216 6217
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
6218
    if (!virDomainObjIsActive(vm)) {
6219
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
G
Guido Günther 已提交
6220
                         "%s", _("cannot detach device on inactive domain"));
6221
        goto endjob;
6222 6223
    }

6224 6225
    dev = virDomainDeviceDefParse(dom->conn, driver->caps, vm->def, xml,
                                  VIR_DOMAIN_XML_INACTIVE);
6226
    if (dev == NULL)
6227
        goto endjob;
6228

6229 6230 6231

    if (dev->type == VIR_DOMAIN_DEVICE_DISK &&
        dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
6232
        dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) {
6233
        ret = qemudDomainDetachPciDiskDevice(dom->conn, driver, vm, dev);
6234
    } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
6235
        ret = qemudDomainDetachNetDevice(dom->conn, driver, vm, dev);
6236 6237 6238 6239 6240 6241 6242 6243 6244
    } else if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) {
        if (dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
            ret = qemudDomainDetachPciControllerDevice(dom->conn, driver, vm, dev);
        } else {
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                             _("disk controller bus '%s' cannot be hotunplugged."),
                             virDomainControllerTypeToString(dev->data.controller->type));
            /* fallthrough */
        }
6245 6246
    } else if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
        ret = qemudDomainDetachHostDevice(dom->conn, driver, vm, dev);
6247
    } else {
6248
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
6249 6250
                         "%s", _("This type of device cannot be hot unplugged"));
    }
6251

6252
    if (!ret && virDomainSaveStatus(dom->conn, driver->caps, driver->stateDir, vm) < 0)
6253 6254
        ret = -1;

6255
endjob:
6256 6257
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
6258

6259 6260
cleanup:
    virDomainDeviceDefFree(dev);
6261 6262
    if (vm)
        virDomainObjUnlock(vm);
6263
    qemuDriverUnlock(driver);
6264 6265 6266
    return ret;
}

6267
static int qemudDomainGetAutostart(virDomainPtr dom,
6268
                                   int *autostart) {
6269 6270 6271
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
6272

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

6277
    if (!vm) {
6278 6279 6280 6281
        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);
6282
        goto cleanup;
6283 6284 6285
    }

    *autostart = vm->autostart;
6286
    ret = 0;
6287

6288
cleanup:
6289 6290
    if (vm)
        virDomainObjUnlock(vm);
6291
    return ret;
6292 6293
}

6294
static int qemudDomainSetAutostart(virDomainPtr dom,
6295
                                   int autostart) {
6296 6297
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
6298 6299
    char *configFile = NULL, *autostartLink = NULL;
    int ret = -1;
6300

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

6304
    if (!vm) {
6305 6306 6307 6308
        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);
6309
        goto cleanup;
6310 6311
    }

6312 6313 6314
    if (!vm->persistent) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("cannot set autostart for transient domain"));
6315
        goto cleanup;
6316 6317
    }

6318 6319
    autostart = (autostart != 0);

6320 6321 6322 6323 6324
    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;
6325

6326 6327
        if (autostart) {
            int err;
6328

6329
            if ((err = virFileMakePath(driver->autostartDir))) {
6330 6331 6332
                virReportSystemError(dom->conn, err,
                                     _("cannot create autostart directory %s"),
                                     driver->autostartDir);
6333 6334
                goto cleanup;
            }
6335

6336
            if (symlink(configFile, autostartLink) < 0) {
6337 6338 6339
                virReportSystemError(dom->conn, errno,
                                     _("Failed to create symlink '%s to '%s'"),
                                     autostartLink, configFile);
6340 6341 6342 6343
                goto cleanup;
            }
        } else {
            if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
6344 6345 6346
                virReportSystemError(dom->conn, errno,
                                     _("Failed to delete symlink '%s'"),
                                     autostartLink);
6347 6348
                goto cleanup;
            }
6349 6350
        }

6351
        vm->autostart = autostart;
6352
    }
6353
    ret = 0;
6354

6355 6356 6357
cleanup:
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
6358 6359
    if (vm)
        virDomainObjUnlock(vm);
6360
    qemuDriverUnlock(driver);
6361
    return ret;
6362 6363
}

6364 6365 6366 6367 6368

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

6371
    qemuDriverLock(driver);
6372
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
6373 6374
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
6375
        goto cleanup;
6376 6377 6378 6379 6380 6381 6382 6383
    }

    if (nparams)
        *nparams = 1;

    ret = strdup("posix");
    if (!ret)
        virReportOOMError(dom->conn);
6384 6385 6386

cleanup:
    qemuDriverUnlock(driver);
6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399
    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;

6400
    qemuDriverLock(driver);
6401
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
6402 6403
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
6404
        goto cleanup;
6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426
    }

    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) {
C
Chris Lalancette 已提交
6427
                qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG, "%s",
6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449
                                 _("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);
6450
    qemuDriverUnlock(driver);
6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464
    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;

6465
    qemuDriverLock(driver);
6466
    if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
6467 6468
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                         __FUNCTION__);
6469
        goto cleanup;
6470 6471 6472 6473 6474
    }

    if ((*nparams) != 1) {
        qemudReportError(dom->conn, domain, NULL, VIR_ERR_INVALID_ARG,
                         "%s", _("Invalid parameter count"));
6475
        goto cleanup;
6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499
    }

    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 已提交
6500 6501 6502 6503 6504
    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;
    }
6505 6506 6507 6508 6509 6510 6511

    ret = 0;

cleanup:
    virCgroupFree(&group);
    if (vm)
        virDomainObjUnlock(vm);
6512
    qemuDriverUnlock(driver);
6513 6514 6515 6516
    return ret;
}


6517 6518 6519 6520 6521 6522 6523 6524 6525
/* 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)
{
6526
    struct qemud_driver *driver = dom->conn->privateData;
6527
    int i, ret = -1;
6528
    virDomainObjPtr vm;
6529
    virDomainDiskDefPtr disk = NULL;
6530

6531
    qemuDriverLock(driver);
6532
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
6533
    qemuDriverUnlock(driver);
6534
    if (!vm) {
6535 6536 6537 6538
        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);
6539
        goto cleanup;
6540
    }
6541 6542 6543 6544

    if (qemuDomainObjBeginJob(vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
6545
    if (!virDomainObjIsActive (vm)) {
6546
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
6547
                          "%s", _("domain is not running"));
6548
        goto endjob;
6549 6550
    }

6551 6552 6553 6554 6555 6556 6557 6558
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(path, vm->def->disks[i]->dst)) {
            disk = vm->def->disks[i];
            break;
        }
    }

    if (!disk) {
6559 6560
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
                          _("invalid path: %s"), path);
6561
        goto endjob;
6562 6563
    }

6564 6565 6566
    if (!disk->info.alias) {
        qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("missing disk device alias name for %s"), disk->dst);
6567
        goto endjob;
6568
    }
6569

6570
    qemuDomainObjPrivatePtr priv = vm->privateData;
6571 6572
    qemuDomainObjEnterMonitor(vm);
    ret = qemuMonitorGetBlockStatsInfo(priv->mon,
6573
                                       disk->info.alias,
6574 6575 6576 6577 6578 6579
                                       &stats->rd_req,
                                       &stats->rd_bytes,
                                       &stats->wr_req,
                                       &stats->wr_bytes,
                                       &stats->errs);
    qemuDomainObjExitMonitor(vm);
6580

6581
endjob:
6582 6583
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
6584

6585
cleanup:
6586 6587
    if (vm)
        virDomainObjUnlock(vm);
6588
    return ret;
6589 6590
}

6591
#ifdef __linux__
6592 6593 6594 6595 6596
static int
qemudDomainInterfaceStats (virDomainPtr dom,
                           const char *path,
                           struct _virDomainInterfaceStats *stats)
{
6597 6598
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
6599
    int i;
6600
    int ret = -1;
6601

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

6606
    if (!vm) {
6607 6608 6609 6610
        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);
6611
        goto cleanup;
6612 6613
    }

D
Daniel P. Berrange 已提交
6614
    if (!virDomainObjIsActive(vm)) {
6615
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
6616
                         "%s", _("domain is not running"));
6617
        goto cleanup;
6618 6619 6620
    }

    /* Check the path is one of the domain's network interfaces. */
6621 6622
    for (i = 0 ; i < vm->def->nnets ; i++) {
        if (vm->def->nets[i]->ifname &&
6623 6624 6625 6626
            STREQ (vm->def->nets[i]->ifname, path)) {
            ret = 0;
            break;
        }
6627 6628
    }

6629 6630 6631 6632 6633
    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);
6634

6635
cleanup:
6636 6637
    if (vm)
        virDomainObjUnlock(vm);
6638 6639
    return ret;
}
6640
#else
6641 6642 6643 6644
static int
qemudDomainInterfaceStats (virDomainPtr dom,
                           const char *path ATTRIBUTE_UNUSED,
                           struct _virDomainInterfaceStats *stats ATTRIBUTE_UNUSED)
6645 6646 6647 6648
    qemudReportError (dom->conn, dom, NULL, VIR_ERR_NO_SUPPORT,
                      "%s", __FUNCTION__);
    return -1;
}
6649
#endif
6650

6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687
static int
qemudDomainMemoryStats (virDomainPtr dom,
                        struct _virDomainMemoryStat *stats,
                        unsigned int nr_stats)
{
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    unsigned 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 (virDomainObjIsActive(vm)) {
        qemuDomainObjPrivatePtr priv = vm->privateData;
        qemuDomainObjEnterMonitor(vm);
        ret = qemuMonitorTextGetMemoryStats(priv->mon, stats, nr_stats);
        qemuDomainObjExitMonitor(vm);
    } else {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is not running"));
    }

cleanup:
    if (vm)
        virDomainObjUnlock(vm);
    return ret;
}

6688 6689 6690 6691 6692 6693 6694
static int
qemudDomainBlockPeek (virDomainPtr dom,
                      const char *path,
                      unsigned long long offset, size_t size,
                      void *buffer,
                      unsigned int flags ATTRIBUTE_UNUSED)
{
6695 6696 6697
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int fd = -1, ret = -1, i;
6698

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

6703
    if (!vm) {
6704 6705 6706 6707
        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);
6708
        goto cleanup;
6709 6710 6711 6712
    }

    if (!path || path[0] == '\0') {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
J
Jim Meyering 已提交
6713
                         "%s", _("NULL or empty path"));
6714
        goto cleanup;
6715 6716 6717
    }

    /* Check the path belongs to this domain. */
6718 6719
    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (vm->def->disks[i]->src != NULL &&
6720 6721 6722 6723
            STREQ (vm->def->disks[i]->src, path)) {
            ret = 0;
            break;
        }
6724 6725
    }

6726 6727 6728 6729 6730
    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) {
6731 6732
            virReportSystemError (dom->conn, errno,
                                  _("%s: failed to open"), path);
6733 6734
            goto cleanup;
        }
6735

6736 6737 6738 6739 6740 6741
        /* 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) {
6742 6743
            virReportSystemError (dom->conn, errno,
                                  _("%s: failed to seek or read"), path);
6744 6745 6746 6747 6748 6749 6750
            goto cleanup;
        }

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

6753 6754 6755
cleanup:
    if (fd >= 0)
        close (fd);
6756 6757
    if (vm)
        virDomainObjUnlock(vm);
6758 6759 6760
    return ret;
}

R
Richard W.M. Jones 已提交
6761 6762 6763 6764 6765 6766
static int
qemudDomainMemoryPeek (virDomainPtr dom,
                       unsigned long long offset, size_t size,
                       void *buffer,
                       unsigned int flags)
{
6767 6768
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
6769
    char *tmp = NULL;
R
Richard W.M. Jones 已提交
6770 6771
    int fd = -1, ret = -1;

6772
    qemuDriverLock(driver);
6773
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
6774
    qemuDriverUnlock(driver);
R
Richard W.M. Jones 已提交
6775 6776

    if (!vm) {
6777 6778 6779 6780
        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);
6781 6782 6783
        goto cleanup;
    }

6784
    if (flags != VIR_MEMORY_VIRTUAL && flags != VIR_MEMORY_PHYSICAL) {
6785
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_INVALID_ARG,
6786
                     "%s", _("flags parameter must be VIR_MEMORY_VIRTUAL or VIR_MEMORY_PHYSICAL"));
6787
        goto cleanup;
R
Richard W.M. Jones 已提交
6788 6789
    }

6790 6791 6792
    if (qemuDomainObjBeginJob(vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
6793
    if (!virDomainObjIsActive(vm)) {
6794
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
R
Richard W.M. Jones 已提交
6795
                         "%s", _("domain is not running"));
6796
        goto endjob;
R
Richard W.M. Jones 已提交
6797 6798
    }

6799 6800
    if (virAsprintf(&tmp, driver->cacheDir,  "/qemu.mem.XXXXXX") < 0) {
        virReportOOMError(dom->conn);
6801
        goto endjob;
6802 6803
    }

R
Richard W.M. Jones 已提交
6804 6805
    /* Create a temporary filename. */
    if ((fd = mkstemp (tmp)) == -1) {
6806 6807
        virReportSystemError (dom->conn, errno,
                              _("mkstemp(\"%s\") failed"), tmp);
6808
        goto endjob;
R
Richard W.M. Jones 已提交
6809 6810
    }

6811
    qemuDomainObjPrivatePtr priv = vm->privateData;
6812
    qemuDomainObjEnterMonitor(vm);
6813
    if (flags == VIR_MEMORY_VIRTUAL) {
6814 6815
        if (qemuMonitorSaveVirtualMemory(priv->mon, offset, size, tmp) < 0) {
            qemuDomainObjExitMonitor(vm);
6816
            goto endjob;
6817
        }
6818
    } else {
6819 6820
        if (qemuMonitorSavePhysicalMemory(priv->mon, offset, size, tmp) < 0) {
            qemuDomainObjExitMonitor(vm);
6821
            goto endjob;
6822
        }
R
Richard W.M. Jones 已提交
6823
    }
6824
    qemuDomainObjExitMonitor(vm);
R
Richard W.M. Jones 已提交
6825 6826 6827

    /* Read the memory file into buffer. */
    if (saferead (fd, buffer, size) == (ssize_t) -1) {
6828 6829 6830
        virReportSystemError (dom->conn, errno,
                              _("failed to read temporary file "
                                "created with template %s"), tmp);
6831
        goto endjob;
R
Richard W.M. Jones 已提交
6832 6833 6834
    }

    ret = 0;
6835

6836
endjob:
6837 6838
    if (qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
6839

6840
cleanup:
6841
    VIR_FREE(tmp);
R
Richard W.M. Jones 已提交
6842 6843
    if (fd >= 0) close (fd);
    unlink (tmp);
6844 6845
    if (vm)
        virDomainObjUnlock(vm);
R
Richard W.M. Jones 已提交
6846 6847 6848
    return ret;
}

6849

6850 6851
static int
qemudDomainEventRegister (virConnectPtr conn,
6852
                          virConnectDomainEventCallback callback,
6853 6854
                          void *opaque,
                          virFreeCallback freecb)
6855
{
6856 6857 6858
    struct qemud_driver *driver = conn->privateData;
    int ret;

6859
    qemuDriverLock(driver);
6860 6861
    ret = virDomainEventCallbackListAdd(conn, driver->domainEventCallbacks,
                                        callback, opaque, freecb);
6862
    qemuDriverUnlock(driver);
6863

6864
    return ret;
6865 6866 6867 6868
}

static int
qemudDomainEventDeregister (virConnectPtr conn,
6869
                            virConnectDomainEventCallback callback)
6870
{
6871 6872 6873
    struct qemud_driver *driver = conn->privateData;
    int ret;

6874
    qemuDriverLock(driver);
6875 6876 6877 6878 6879 6880
    if (driver->domainEventDispatching)
        ret = virDomainEventCallbackListMarkDelete(conn, driver->domainEventCallbacks,
                                                   callback);
    else
        ret = virDomainEventCallbackListRemove(conn, driver->domainEventCallbacks,
                                               callback);
6881
    qemuDriverUnlock(driver);
6882

6883
    return ret;
6884 6885
}

6886 6887 6888 6889 6890
static void qemuDomainEventDispatchFunc(virConnectPtr conn,
                                        virDomainEventPtr event,
                                        virConnectDomainEventCallback cb,
                                        void *cbopaque,
                                        void *opaque)
6891
{
6892
    struct qemud_driver *driver = opaque;
6893

6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937
    /* 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);
6938 6939
}

D
Daniel Veillard 已提交
6940 6941
/* Migration support. */

C
Chris Lalancette 已提交
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 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114
/* Tunnelled migration stream support */
struct qemuStreamMigFile {
    int fd;

    int watch;
    unsigned int cbRemoved;
    unsigned int dispatching;
    virStreamEventCallback cb;
    void *opaque;
    virFreeCallback ff;
};

static int qemuStreamMigRemoveCallback(virStreamPtr stream)
{
    struct qemud_driver *driver = stream->conn->privateData;
    struct qemuStreamMigFile *qemust = stream->privateData;
    int ret = -1;

    if (!qemust) {
        qemudReportError(stream->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("stream is not open"));
        return -1;
    }

    qemuDriverLock(driver);
    if (qemust->watch == 0) {
        qemudReportError(stream->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("stream does not have a callback registered"));
        goto cleanup;
    }

    virEventRemoveHandle(qemust->watch);
    if (qemust->dispatching)
        qemust->cbRemoved = 1;
    else if (qemust->ff)
        (qemust->ff)(qemust->opaque);

    qemust->watch = 0;
    qemust->ff = NULL;
    qemust->cb = NULL;
    qemust->opaque = NULL;

    ret = 0;

cleanup:
    qemuDriverUnlock(driver);
    return ret;
}

static int qemuStreamMigUpdateCallback(virStreamPtr stream, int events)
{
    struct qemud_driver *driver = stream->conn->privateData;
    struct qemuStreamMigFile *qemust = stream->privateData;
    int ret = -1;

    if (!qemust) {
        qemudReportError(stream->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("stream is not open"));
        return -1;
    }

    qemuDriverLock(driver);
    if (qemust->watch == 0) {
        qemudReportError(stream->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("stream does not have a callback registered"));
        goto cleanup;
    }

    virEventUpdateHandle(qemust->watch, events);

    ret = 0;

cleanup:
    qemuDriverUnlock(driver);
    return ret;
}

static void qemuStreamMigEvent(int watch ATTRIBUTE_UNUSED,
                               int fd ATTRIBUTE_UNUSED,
                               int events,
                               void *opaque)
{
    virStreamPtr stream = opaque;
    struct qemud_driver *driver = stream->conn->privateData;
    struct qemuStreamMigFile *qemust = stream->privateData;
    virStreamEventCallback cb;
    void *cbopaque;
    virFreeCallback ff;

    qemuDriverLock(driver);
    if (!qemust || !qemust->cb) {
        qemuDriverUnlock(driver);
        return;
    }

    cb = qemust->cb;
    cbopaque = qemust->opaque;
    ff = qemust->ff;
    qemust->dispatching = 1;
    qemuDriverUnlock(driver);

    cb(stream, events, cbopaque);

    qemuDriverLock(driver);
    qemust->dispatching = 0;
    if (qemust->cbRemoved && ff)
        (ff)(cbopaque);
    qemuDriverUnlock(driver);
}

static int
qemuStreamMigAddCallback(virStreamPtr st,
                         int events,
                         virStreamEventCallback cb,
                         void *opaque,
                         virFreeCallback ff)
{
    struct qemud_driver *driver = st->conn->privateData;
    struct qemuStreamMigFile *qemust = st->privateData;
    int ret = -1;

    if (!qemust) {
        qemudReportError(st->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("stream is not open"));
        return -1;
    }

    qemuDriverLock(driver);
    if (qemust->watch != 0) {
        qemudReportError(st->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("stream already has a callback registered"));
        goto cleanup;
    }

    if ((qemust->watch = virEventAddHandle(qemust->fd,
                                           events,
                                           qemuStreamMigEvent,
                                           st,
                                           NULL)) < 0) {
        qemudReportError(st->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("cannot register file watch on stream"));
        goto cleanup;
    }

    qemust->cbRemoved = 0;
    qemust->cb = cb;
    qemust->opaque = opaque;
    qemust->ff = ff;
    virStreamRef(st);

    ret = 0;

cleanup:
    qemuDriverUnlock(driver);
    return ret;
}

static void qemuStreamMigFree(struct qemuStreamMigFile *qemust)
{
    if (qemust->fd != -1)
        close(qemust->fd);
    VIR_FREE(qemust);
}

static struct qemuStreamMigFile *qemuStreamMigOpen(virStreamPtr st,
                                                   const char *unixfile)
{
    struct qemuStreamMigFile *qemust = NULL;
    struct sockaddr_un sa_qemu;
    int i = 0;
    int timeout = 3;
    int ret;

7115 7116
    if (VIR_ALLOC(qemust) < 0) {
        virReportOOMError(st->conn);
C
Chris Lalancette 已提交
7117
        return NULL;
7118
    }
C
Chris Lalancette 已提交
7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259 7260 7261 7262 7263 7264 7265

    qemust->fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (qemust->fd < 0)
        goto cleanup;

    memset(&sa_qemu, 0, sizeof(sa_qemu));
    sa_qemu.sun_family = AF_UNIX;
    if (virStrcpy(sa_qemu.sun_path, unixfile, sizeof(sa_qemu.sun_path)) == NULL)
        goto cleanup;

    do {
        ret = connect(qemust->fd, (struct sockaddr *)&sa_qemu, sizeof(sa_qemu));
        if (ret == 0)
            break;

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

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

    if ((st->flags & VIR_STREAM_NONBLOCK) && virSetNonBlock(qemust->fd) < 0)
        goto cleanup;

    return qemust;

cleanup:
    qemuStreamMigFree(qemust);
    return NULL;
}

static int
qemuStreamMigClose(virStreamPtr st)
{
    struct qemud_driver *driver = st->conn->privateData;
    struct qemuStreamMigFile *qemust = st->privateData;

    if (!qemust)
        return 0;

    qemuDriverLock(driver);

    qemuStreamMigFree(qemust);

    st->privateData = NULL;

    qemuDriverUnlock(driver);

    return 0;
}

static int qemuStreamMigWrite(virStreamPtr st, const char *bytes, size_t nbytes)
{
    struct qemud_driver *driver = st->conn->privateData;
    struct qemuStreamMigFile *qemust = st->privateData;
    int ret;

    if (!qemust) {
        qemudReportError(st->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("stream is not open"));
        return -1;
    }

    qemuDriverLock(driver);

retry:
    ret = write(qemust->fd, bytes, nbytes);
    if (ret < 0) {
        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            ret = -2;
        } else if (errno == EINTR) {
            goto retry;
        } else {
            ret = -1;
            virReportSystemError(st->conn, errno, "%s",
                                 _("cannot write to stream"));
        }
    }

    qemuDriverUnlock(driver);
    return ret;
}

static virStreamDriver qemuStreamMigDrv = {
    .streamSend = qemuStreamMigWrite,
    .streamFinish = qemuStreamMigClose,
    .streamAbort = qemuStreamMigClose,
    .streamAddCallback = qemuStreamMigAddCallback,
    .streamUpdateCallback = qemuStreamMigUpdateCallback,
    .streamRemoveCallback = qemuStreamMigRemoveCallback
};

/* Prepare is the first step, and it runs on the destination host.
 *
 * This version starts an empty VM listening on a localhost TCP port, and
 * sets up the corresponding virStream to handle the incoming data.
 */
static int
qemudDomainMigratePrepareTunnel(virConnectPtr dconn,
                                virStreamPtr st,
                                unsigned long flags,
                                const char *dname,
                                unsigned long resource ATTRIBUTE_UNUSED,
                                const char *dom_xml)
{
    struct qemud_driver *driver = dconn->privateData;
    virDomainDefPtr def = NULL;
    virDomainObjPtr vm = NULL;
    char *migrateFrom;
    virDomainEventPtr event = NULL;
    int ret = -1;
    int internalret;
    char *unixfile = NULL;
    unsigned int qemuCmdFlags;
    struct qemuStreamMigFile *qemust = NULL;

    qemuDriverLock(driver);
    if (!dom_xml) {
        qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("no domain XML passed"));
        goto cleanup;
    }
    if (!(flags & VIR_MIGRATE_TUNNELLED)) {
        qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("PrepareTunnel called but no TUNNELLED flag set"));
        goto cleanup;
    }
    if (st == NULL) {
        qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("tunnelled migration requested but NULL stream passed"));
        goto cleanup;
    }

    /* Parse the domain XML. */
    if (!(def = virDomainDefParseString(dconn, driver->caps, dom_xml,
                                        VIR_DOMAIN_XML_INACTIVE))) {
        qemudReportError(dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("failed to parse XML"));
        goto cleanup;
    }

    /* Target domain name, maybe renamed. */
    dname = dname ? dname : def->name;

7266 7267
    if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
        goto cleanup;
C
Chris Lalancette 已提交
7268 7269

    if (!(vm = virDomainAssignDef(dconn,
7270
                                  driver->caps,
C
Chris Lalancette 已提交
7271 7272 7273 7274 7275 7276 7277 7278
                                  &driver->domains,
                                  def))) {
        qemudReportError(dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("failed to assign new VM"));
        goto cleanup;
    }
    def = NULL;

7279 7280 7281
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

C
Chris Lalancette 已提交
7282 7283 7284 7285 7286 7287
    /* Domain starts inactive, even if the domain XML had an id field. */
    vm->def->id = -1;

    if (virAsprintf(&unixfile, "%s/qemu.tunnelmigrate.dest.%s",
                    driver->stateDir, vm->def->name) < 0) {
        virReportOOMError (dconn);
7288
        goto endjob;
C
Chris Lalancette 已提交
7289 7290 7291 7292 7293 7294 7295 7296
    }
    unlink(unixfile);

    /* check that this qemu version supports the interactive exec */
    if (qemudExtractVersionInfo(vm->def->emulator, NULL, &qemuCmdFlags) < 0) {
        qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Cannot determine QEMU argv syntax %s"),
                         vm->def->emulator);
7297
        goto endjob;
C
Chris Lalancette 已提交
7298 7299 7300 7301 7302 7303 7304 7305
    }
    if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX)
        internalret = virAsprintf(&migrateFrom, "unix:%s", unixfile);
    else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC)
        internalret = virAsprintf(&migrateFrom, "exec:nc -U -l %s", unixfile);
    else {
        qemudReportError(dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("Destination qemu is too old to support tunnelled migration"));
7306
        goto endjob;
C
Chris Lalancette 已提交
7307 7308 7309
    }
    if (internalret < 0) {
        virReportOOMError(dconn);
7310
        goto endjob;
C
Chris Lalancette 已提交
7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324
    }
    /* Start the QEMU daemon, with the same command-line arguments plus
     * -incoming unix:/path/to/file or exec:nc -U /path/to/file
     */
    internalret = qemudStartVMDaemon(dconn, driver, vm, migrateFrom, -1);
    VIR_FREE(migrateFrom);
    if (internalret < 0) {
        /* Note that we don't set an error here because qemudStartVMDaemon
         * should have already done that.
         */
        if (!vm->persistent) {
            virDomainRemoveInactive(&driver->domains, vm);
            vm = NULL;
        }
7325
        goto endjob;
C
Chris Lalancette 已提交
7326 7327 7328 7329 7330
    }

    qemust = qemuStreamMigOpen(st, unixfile);
    if (qemust == NULL) {
        qemudShutdownVMDaemon(NULL, driver, vm);
7331
        if (!vm->persistent) {
7332 7333
            if (qemuDomainObjEndJob(vm) > 0)
                virDomainRemoveInactive(&driver->domains, vm);
7334 7335
            vm = NULL;
        }
C
Chris Lalancette 已提交
7336 7337 7338
        virReportSystemError(dconn, errno,
                             _("cannot open unix socket '%s' for tunnelled migration"),
                             unixfile);
7339
        goto endjob;
C
Chris Lalancette 已提交
7340 7341 7342 7343 7344 7345 7346 7347 7348 7349
    }

    st->driver = &qemuStreamMigDrv;
    st->privateData = qemust;

    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_MIGRATED);
    ret = 0;

7350
endjob:
7351 7352 7353
    if (vm &&
        qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
7354

C
Chris Lalancette 已提交
7355 7356
cleanup:
    virDomainDefFree(def);
7357 7358
    if (unixfile)
        unlink(unixfile);
C
Chris Lalancette 已提交
7359 7360 7361 7362 7363 7364 7365 7366 7367
    VIR_FREE(unixfile);
    if (vm)
        virDomainObjUnlock(vm);
    if (event)
        qemuDomainEventQueue(driver, event);
    qemuDriverUnlock(driver);
    return ret;
}

D
Daniel Veillard 已提交
7368 7369 7370 7371
/* Prepare is the first step, and it runs on the destination host.
 *
 * This starts an empty VM listening on a TCP port.
 */
7372
static int ATTRIBUTE_NONNULL (5)
D
Daniel Veillard 已提交
7373 7374 7375 7376 7377
qemudDomainMigratePrepare2 (virConnectPtr dconn,
                            char **cookie ATTRIBUTE_UNUSED,
                            int *cookielen ATTRIBUTE_UNUSED,
                            const char *uri_in,
                            char **uri_out,
C
Chris Lalancette 已提交
7378
                            unsigned long flags,
D
Daniel Veillard 已提交
7379 7380 7381 7382 7383
                            const char *dname,
                            unsigned long resource ATTRIBUTE_UNUSED,
                            const char *dom_xml)
{
    static int port = 0;
7384 7385
    struct qemud_driver *driver = dconn->privateData;
    virDomainDefPtr def = NULL;
D
Daniel Veillard 已提交
7386 7387
    virDomainObjPtr vm = NULL;
    int this_port;
7388
    char *hostname;
D
Daniel Veillard 已提交
7389 7390
    char migrateFrom [64];
    const char *p;
7391
    virDomainEventPtr event = NULL;
7392
    int ret = -1;
7393
    int internalret;
7394 7395

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

7397
    qemuDriverLock(driver);
C
Chris Lalancette 已提交
7398 7399 7400 7401 7402 7403 7404 7405 7406
    if (flags & VIR_MIGRATE_TUNNELLED) {
        /* this is a logical error; we never should have gotten here with
         * VIR_MIGRATE_TUNNELLED set
         */
        qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         "%s", _("Tunnelled migration requested but invalid RPC method called"));
        goto cleanup;
    }

D
Daniel Veillard 已提交
7407 7408 7409
    if (!dom_xml) {
        qemudReportError (dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                          "%s", _("no domain XML passed"));
7410
        goto cleanup;
D
Daniel Veillard 已提交
7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427
    }

    /* 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 */
7428
        if ((hostname = virGetHostname(dconn)) == NULL)
7429
            goto cleanup;
D
Daniel Veillard 已提交
7430

7431 7432 7433 7434 7435
        /* XXX this really should have been a properly well-formed
         * URI, but we can't add in tcp:// now without breaking
         * compatability with old targets. We at least make the
         * new targets accept both syntaxes though.
         */
D
Daniel Veillard 已提交
7436
        /* Caller frees */
7437 7438 7439
        internalret = virAsprintf(uri_out, "tcp:%s:%d", hostname, this_port);
        VIR_FREE(hostname);
        if (internalret < 0) {
7440
            virReportOOMError (dconn);
7441
            goto cleanup;
D
Daniel Veillard 已提交
7442 7443 7444 7445 7446 7447
        }
    } 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.
         */
7448
        if (!STRPREFIX (uri_in, "tcp:")) {
D
Daniel Veillard 已提交
7449
            qemudReportError (dconn, NULL, NULL, VIR_ERR_INVALID_ARG,
7450
                  "%s", _("only tcp URIs are supported for KVM/QEMU migrations"));
7451
            goto cleanup;
D
Daniel Veillard 已提交
7452 7453 7454 7455
        }

        /* Get the port number. */
        p = strrchr (uri_in, ':');
7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475
        if (p == strchr(uri_in, ':')) {
            /* Generate a port */
            this_port = QEMUD_MIGRATION_FIRST_PORT + port++;
            if (port == QEMUD_MIGRATION_NUM_PORTS)
                port = 0;

            /* Caller frees */
            if (virAsprintf(uri_out, "%s:%d", uri_in, this_port) < 0) {
                virReportOOMError (dconn);
                goto cleanup;
            }

        } else {
            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 ended with incorrect ':port'"));
                goto cleanup;
            }
D
Daniel Veillard 已提交
7476 7477 7478
        }
    }

7479
    if (*uri_out)
7480 7481
        VIR_DEBUG("Generated uri_out=%s", *uri_out);

D
Daniel Veillard 已提交
7482
    /* Parse the domain XML. */
7483 7484
    if (!(def = virDomainDefParseString(dconn, driver->caps, dom_xml,
                                        VIR_DOMAIN_XML_INACTIVE))) {
D
Daniel Veillard 已提交
7485 7486
        qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("failed to parse XML"));
7487
        goto cleanup;
D
Daniel Veillard 已提交
7488 7489 7490 7491 7492
    }

    /* Target domain name, maybe renamed. */
    dname = dname ? dname : def->name;

7493 7494
    if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
        goto cleanup;
D
Daniel Veillard 已提交
7495 7496

    if (!(vm = virDomainAssignDef(dconn,
7497
                                  driver->caps,
D
Daniel Veillard 已提交
7498 7499 7500 7501
                                  &driver->domains,
                                  def))) {
        qemudReportError (dconn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("failed to assign new VM"));
7502
        goto cleanup;
D
Daniel Veillard 已提交
7503
    }
7504
    def = NULL;
D
Daniel Veillard 已提交
7505

7506 7507 7508
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

D
Daniel Veillard 已提交
7509 7510 7511 7512 7513 7514 7515
    /* 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);
7516
    if (qemudStartVMDaemon (dconn, driver, vm, migrateFrom, -1) < 0) {
7517 7518 7519
        /* Note that we don't set an error here because qemudStartVMDaemon
         * should have already done that.
         */
7520
        if (!vm->persistent) {
7521 7522
            if (qemuDomainObjEndJob(vm) > 0)
                virDomainRemoveInactive(&driver->domains, vm);
7523 7524
            vm = NULL;
        }
7525
        goto endjob;
D
Daniel Veillard 已提交
7526
    }
7527 7528 7529 7530

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

7533
endjob:
7534 7535 7536
    if (vm &&
        qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
7537

7538 7539 7540 7541 7542
cleanup:
    virDomainDefFree(def);
    if (ret != 0) {
        VIR_FREE(*uri_out);
    }
7543 7544
    if (vm)
        virDomainObjUnlock(vm);
7545 7546
    if (event)
        qemuDomainEventQueue(driver, event);
7547
    qemuDriverUnlock(driver);
7548
    return ret;
C
Chris Lalancette 已提交
7549 7550 7551

}

7552 7553 7554 7555 7556

/* Perform migration using QEMU's native TCP migrate support,
 * not encrypted obviously
 */
static int doNativeMigrate(virDomainPtr dom,
7557
                           struct qemud_driver *driver,
7558 7559 7560 7561 7562 7563 7564
                           virDomainObjPtr vm,
                           const char *uri,
                           unsigned long flags ATTRIBUTE_UNUSED,
                           const char *dname ATTRIBUTE_UNUSED,
                           unsigned long resource)
{
    int ret = -1;
7565
    xmlURIPtr uribits = NULL;
7566 7567
    int status;
    unsigned long long transferred, remaining, total;
7568
    qemuDomainObjPrivatePtr priv = vm->privateData;
7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588

    /* Issue the migrate command. */
    if (STRPREFIX(uri, "tcp:") && !STRPREFIX(uri, "tcp://")) {
        /* HACK: source host generates bogus URIs, so fix them up */
        char *tmpuri;
        if (virAsprintf(&tmpuri, "tcp://%s", uri + strlen("tcp:")) < 0) {
            virReportOOMError(dom->conn);
            goto cleanup;
        }
        uribits = xmlParseURI(tmpuri);
        VIR_FREE(tmpuri);
    } else {
        uribits = xmlParseURI(uri);
    }
    if (!uribits) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("cannot parse URI %s"), uri);
        goto cleanup;
    }

7589
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
7590
    if (resource > 0 &&
7591
        qemuMonitorSetMigrationSpeed(priv->mon, resource) < 0) {
7592
        qemuDomainObjExitMonitorWithDriver(driver, vm);
7593
        goto cleanup;
7594
    }
7595

7596
    if (qemuMonitorMigrateToHost(priv->mon, 0, uribits->server, uribits->port) < 0) {
7597
        qemuDomainObjExitMonitorWithDriver(driver, vm);
7598
        goto cleanup;
7599
    }
7600 7601 7602 7603

    /* it is also possible that the migrate didn't fail initially, but
     * rather failed later on.  Check the output of "info migrate"
     */
7604 7605
    if (qemuMonitorGetMigrationStatus(priv->mon,
                                      &status,
7606 7607 7608
                                      &transferred,
                                      &remaining,
                                      &total) < 0) {
7609
        qemuDomainObjExitMonitorWithDriver(driver, vm);
7610 7611
        goto cleanup;
    }
7612
    qemuDomainObjExitMonitorWithDriver(driver, vm);
7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627

    if (status != QEMU_MONITOR_MIGRATION_STATUS_COMPLETED) {
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                          "%s", _("migrate did not successfully complete"));
        goto cleanup;
    }

    ret = 0;

cleanup:
    xmlFreeURI(uribits);
    return ret;
}


7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648
static int doTunnelSendAll(virDomainPtr dom,
                           virStreamPtr st,
                           int sock)
{
    char buffer[65536];
    int nbytes = sizeof(buffer);

    /* XXX should honour the 'resource' parameter here */
    for (;;) {
        nbytes = saferead(sock, buffer, nbytes);
        if (nbytes < 0) {
            virStreamAbort(st);
            virReportSystemError(dom->conn, errno, "%s",
                                 _("tunnelled migration failed to read from qemu"));
            return -1;
        }
        else if (nbytes == 0)
            /* EOF; get out of here */
            break;

        if (virStreamSend(st, buffer, nbytes) < 0) {
C
Chris Lalancette 已提交
7649
            qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s",
7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661
                             _("Failed to write migration data to remote libvirtd"));
            return -1;
        }
    }

    if (virStreamFinish(st) < 0)
        /* virStreamFinish set the error for us */
        return -1;

    return 0;
}

C
Chris Lalancette 已提交
7662
static int doTunnelMigrate(virDomainPtr dom,
7663
                           struct qemud_driver *driver,
7664
                           virConnectPtr dconn,
C
Chris Lalancette 已提交
7665
                           virDomainObjPtr vm,
7666
                           const char *dom_xml,
C
Chris Lalancette 已提交
7667 7668 7669 7670 7671
                           const char *uri,
                           unsigned long flags,
                           const char *dname,
                           unsigned long resource)
{
7672
    qemuDomainObjPrivatePtr priv = vm->privateData;
7673 7674
    int client_sock = -1;
    int qemu_sock = -1;
C
Chris Lalancette 已提交
7675 7676
    struct sockaddr_un sa_qemu, sa_client;
    socklen_t addrlen;
7677
    virDomainPtr ddomain = NULL;
C
Chris Lalancette 已提交
7678
    int retval = -1;
7679
    virStreamPtr st = NULL;
C
Chris Lalancette 已提交
7680 7681 7682 7683 7684 7685
    char *unixfile = NULL;
    int internalret;
    unsigned int qemuCmdFlags;
    int status;
    unsigned long long transferred, remaining, total;

7686 7687 7688 7689 7690 7691 7692 7693
    /*
     * The order of operations is important here to avoid touching
     * the source VM until we are very sure we can successfully
     * start the migration operation.
     *
     *   1. setup local support infrastructure (eg sockets)
     *   2. setup destination fully
     *   3. start migration on source
C
Chris Lalancette 已提交
7694 7695
     */

7696

7697
    /* Stage 1. setup local support infrastructure */
C
Chris Lalancette 已提交
7698 7699 7700 7701

    if (virAsprintf(&unixfile, "%s/qemu.tunnelmigrate.src.%s",
                    driver->stateDir, vm->def->name) < 0) {
        virReportOOMError(dom->conn);
7702
        goto cleanup;
C
Chris Lalancette 已提交
7703 7704 7705 7706 7707 7708
    }

    qemu_sock = socket(AF_UNIX, SOCK_STREAM, 0);
    if (qemu_sock < 0) {
        virReportSystemError(dom->conn, errno, "%s",
                             _("cannot open tunnelled migration socket"));
7709
        goto cleanup;
C
Chris Lalancette 已提交
7710 7711 7712 7713 7714 7715 7716 7717
    }
    memset(&sa_qemu, 0, sizeof(sa_qemu));
    sa_qemu.sun_family = AF_UNIX;
    if (virStrcpy(sa_qemu.sun_path, unixfile,
                  sizeof(sa_qemu.sun_path)) == NULL) {
        qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Unix socket '%s' too big for destination"),
                         unixfile);
7718
        goto cleanup;
C
Chris Lalancette 已提交
7719 7720 7721 7722 7723 7724
    }
    unlink(unixfile);
    if (bind(qemu_sock, (struct sockaddr *)&sa_qemu, sizeof(sa_qemu)) < 0) {
        virReportSystemError(dom->conn, errno,
                             _("Cannot bind to unix socket '%s' for tunnelled migration"),
                             unixfile);
7725
        goto cleanup;
C
Chris Lalancette 已提交
7726 7727 7728 7729 7730
    }
    if (listen(qemu_sock, 1) < 0) {
        virReportSystemError(dom->conn, errno,
                             _("Cannot listen on unix socket '%s' for tunnelled migration"),
                             unixfile);
7731
        goto cleanup;
C
Chris Lalancette 已提交
7732 7733 7734 7735 7736 7737 7738
    }

    /* check that this qemu version supports the unix migration */
    if (qemudExtractVersionInfo(vm->def->emulator, NULL, &qemuCmdFlags) < 0) {
        qemudReportError(dom->conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                         _("Cannot extract Qemu version from '%s'"),
                         vm->def->emulator);
7739 7740 7741 7742 7743 7744 7745 7746
        goto cleanup;
    }

    if (!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX) &&
        !(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC)) {
        qemudReportError(dom->conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("Source qemu is too old to support tunnelled migration"));
        goto cleanup;
C
Chris Lalancette 已提交
7747
    }
7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758 7759 7760 7761 7762 7763 7764 7765 7766 7767 7768


    /* Stage 2. setup destination fully
     *
     * Once stage 2 has completed successfully, we *must* call finish
     * to cleanup the target whether we succeed or fail
     */
    st = virStreamNew(dconn, 0);
    if (st == NULL)
        /* virStreamNew only fails on OOM, and it reports the error itself */
        goto cleanup;

    internalret = dconn->driver->domainMigratePrepareTunnel(dconn, st,
                                                            flags, dname,
                                                            resource, dom_xml);

    if (internalret < 0)
        /* domainMigratePrepareTunnel sets the error for us */
        goto cleanup;

    /*   3. start migration on source */
7769
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
C
Chris Lalancette 已提交
7770
    if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX)
7771
        internalret = qemuMonitorMigrateToUnix(priv->mon, 1, unixfile);
C
Chris Lalancette 已提交
7772 7773
    else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC) {
        const char *args[] = { "nc", "-U", unixfile, NULL };
7774
        internalret = qemuMonitorMigrateToCommand(priv->mon, 1, args, "/dev/null");
7775 7776
    } else {
        internalret = -1;
C
Chris Lalancette 已提交
7777
    }
7778
    qemuDomainObjExitMonitorWithDriver(driver, vm);
C
Chris Lalancette 已提交
7779 7780 7781
    if (internalret < 0) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("tunnelled migration monitor command failed"));
7782
        goto finish;
C
Chris Lalancette 已提交
7783 7784
    }

7785 7786 7787
    /* From this point onwards we *must* call cancel to abort the
     * migration on source if anything goes wrong */

C
Chris Lalancette 已提交
7788 7789 7790
    /* it is also possible that the migrate didn't fail initially, but
     * rather failed later on.  Check the output of "info migrate"
     */
7791
    qemuDomainObjEnterMonitorWithDriver(driver, vm);
7792 7793
    if (qemuMonitorGetMigrationStatus(priv->mon,
                                      &status,
C
Chris Lalancette 已提交
7794 7795 7796
                                      &transferred,
                                      &remaining,
                                      &total) < 0) {
7797
        qemuDomainObjExitMonitorWithDriver(driver, vm);
7798
        goto cancel;
C
Chris Lalancette 已提交
7799
    }
7800
    qemuDomainObjExitMonitorWithDriver(driver, vm);
C
Chris Lalancette 已提交
7801 7802 7803 7804

    if (status == QEMU_MONITOR_MIGRATION_STATUS_ERROR) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s",_("migrate failed"));
7805
        goto cancel;
C
Chris Lalancette 已提交
7806 7807 7808 7809 7810 7811 7812 7813
    }

    addrlen = sizeof(sa_client);
    while ((client_sock = accept(qemu_sock, (struct sockaddr *)&sa_client, &addrlen)) < 0) {
        if (errno == EAGAIN || errno == EINTR)
            continue;
        virReportSystemError(dom->conn, errno, "%s",
                             _("tunnelled migration failed to accept from qemu"));
7814
        goto cancel;
C
Chris Lalancette 已提交
7815 7816
    }

7817
    retval = doTunnelSendAll(dom, st, client_sock);
7818

7819
cancel:
7820
    if (retval != 0) {
7821
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
7822
        qemuMonitorMigrateCancel(priv->mon);
7823
        qemuDomainObjExitMonitorWithDriver(driver, vm);
7824
    }
C
Chris Lalancette 已提交
7825

7826
finish:
C
Chris Lalancette 已提交
7827 7828 7829
    dname = dname ? dname : dom->name;
    ddomain = dconn->driver->domainMigrateFinish2
        (dconn, dname, NULL, 0, uri, flags, retval);
7830 7831 7832 7833 7834 7835 7836

cleanup:
    if (client_sock != -1)
        close(client_sock);
    if (qemu_sock != -1)
        close(qemu_sock);

C
Chris Lalancette 已提交
7837 7838 7839
    if (ddomain)
        virUnrefDomain(ddomain);

7840 7841 7842 7843
    if (unixfile) {
        unlink(unixfile);
        VIR_FREE(unixfile);
    }
C
Chris Lalancette 已提交
7844

7845 7846 7847
    if (st)
        /* don't call virStreamFree(), because that resets any pending errors */
        virUnrefStream(st);
7848 7849 7850 7851
    return retval;
}


7852 7853 7854 7855
/* This is essentially a simplified re-impl of
 * virDomainMigrateVersion2 from libvirt.c, but running in source
 * libvirtd context, instead of client app context */
static int doNonTunnelMigrate(virDomainPtr dom,
7856
                              struct qemud_driver *driver,
7857 7858 7859 7860 7861 7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881
                              virConnectPtr dconn,
                              virDomainObjPtr vm,
                              const char *dom_xml,
                              const char *uri ATTRIBUTE_UNUSED,
                              unsigned long flags,
                              const char *dname,
                              unsigned long resource)
{
    virDomainPtr ddomain = NULL;
    int retval = -1;
    char *uri_out = NULL;

    /* NB we don't pass 'uri' into this, since that's the libvirtd
     * URI in this context - so we let dest pick it */
    if (dconn->driver->domainMigratePrepare2(dconn,
                                             NULL, /* cookie */
                                             0, /* cookielen */
                                             NULL, /* uri */
                                             &uri_out,
                                             flags, dname,
                                             resource, dom_xml) < 0)
        /* domainMigratePrepare2 sets the error for us */
        goto cleanup;

    if (uri_out == NULL) {
C
Chris Lalancette 已提交
7882
        qemudReportError(NULL, NULL, NULL, VIR_ERR_INTERNAL_ERROR, "%s",
7883
                         _("domainMigratePrepare2 did not set uri"));
7884
        goto cleanup;
7885 7886
    }

7887
    if (doNativeMigrate(dom, driver, vm, uri_out, flags, dname, resource) < 0)
7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904
        goto finish;

    retval = 0;

finish:
    dname = dname ? dname : dom->name;
    ddomain = dconn->driver->domainMigrateFinish2
        (dconn, dname, NULL, 0, uri_out, flags, retval);

    if (ddomain)
        virUnrefDomain(ddomain);

cleanup:
    return retval;
}


7905
static int doPeer2PeerMigrate(virDomainPtr dom,
7906
                              struct qemud_driver *driver,
7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927
                              virDomainObjPtr vm,
                              const char *uri,
                              unsigned long flags,
                              const char *dname,
                              unsigned long resource)
{
    int ret = -1;
    virConnectPtr dconn = NULL;
    char *dom_xml;

    /* the order of operations is important here; we make sure the
     * destination side is completely setup before we touch the source
     */

    dconn = virConnectOpen(uri);
    if (dconn == NULL) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         _("Failed to connect to remote libvirt URI %s"), uri);
        return -1;
    }
    if (!VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn,
7928
                                  VIR_DRV_FEATURE_MIGRATION_P2P)) {
7929
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED, "%s",
7930
                         _("Destination libvirt does not support peer-to-peer migration protocol"));
7931 7932 7933 7934 7935 7936 7937 7938 7939 7940
        goto cleanup;
    }

    dom_xml = virDomainDefFormat(dom->conn, vm->def, VIR_DOMAIN_XML_SECURE);
    if (!dom_xml) {
        qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
                         "%s", _("failed to get domain xml"));
        goto cleanup;
    }

7941
    if (flags & VIR_MIGRATE_TUNNELLED)
7942
        ret = doTunnelMigrate(dom, driver, dconn, vm, dom_xml, uri, flags, dname, resource);
7943
    else
7944
        ret = doNonTunnelMigrate(dom, driver, dconn, vm, dom_xml, uri, flags, dname, resource);
7945 7946 7947

cleanup:
    VIR_FREE(dom_xml);
C
Chris Lalancette 已提交
7948 7949 7950
    /* don't call virConnectClose(), because that resets any pending errors */
    virUnrefConnect(dconn);

7951
    return ret;
D
Daniel Veillard 已提交
7952 7953
}

7954

D
Daniel Veillard 已提交
7955 7956 7957 7958 7959 7960
/* 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,
7961
                           unsigned long flags,
7962
                           const char *dname,
D
Daniel Veillard 已提交
7963 7964
                           unsigned long resource)
{
7965 7966
    struct qemud_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
7967
    virDomainEventPtr event = NULL;
7968
    int ret = -1;
7969
    int paused = 0;
D
Daniel Veillard 已提交
7970

7971
    qemuDriverLock(driver);
7972
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
D
Daniel Veillard 已提交
7973
    if (!vm) {
7974 7975 7976 7977
        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);
7978
        goto cleanup;
D
Daniel Veillard 已提交
7979 7980
    }

7981 7982 7983
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

D
Daniel P. Berrange 已提交
7984
    if (!virDomainObjIsActive(vm)) {
7985
        qemudReportError (dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
D
Daniel Veillard 已提交
7986
                          "%s", _("domain is not running"));
7987
        goto endjob;
D
Daniel Veillard 已提交
7988 7989
    }

7990
    if (!(flags & VIR_MIGRATE_LIVE) && vm->state == VIR_DOMAIN_RUNNING) {
7991
        qemuDomainObjPrivatePtr priv = vm->privateData;
7992
        /* Pause domain for non-live migration */
7993
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
7994
        if (qemuMonitorStopCPUs(priv->mon) < 0) {
7995 7996
            qemuDomainObjExitMonitorWithDriver(driver, vm);
            goto endjob;
7997
        }
7998
        qemuDomainObjExitMonitorWithDriver(driver, vm);
7999
        paused = 1;
8000

8001
        vm->state = VIR_DOMAIN_PAUSED;
8002 8003 8004 8005 8006 8007
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_SUSPENDED,
                                         VIR_DOMAIN_EVENT_SUSPENDED_MIGRATED);
        if (event)
            qemuDomainEventQueue(driver, event);
        event = NULL;
8008 8009
    }

8010
    if ((flags & (VIR_MIGRATE_TUNNELLED | VIR_MIGRATE_PEER2PEER))) {
8011
        if (doPeer2PeerMigrate(dom, driver, vm, uri, flags, dname, resource) < 0)
8012
            /* doPeer2PeerMigrate already set the error, so just get out */
8013
            goto endjob;
8014
    } else {
8015 8016
        if (doNativeMigrate(dom, driver, vm, uri, flags, dname, resource) < 0)
            goto endjob;
8017 8018
    }

D
Daniel Veillard 已提交
8019 8020
    /* Clean up the source domain. */
    qemudShutdownVMDaemon (dom->conn, driver, vm);
8021
    paused = 0;
8022 8023 8024 8025

    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_MIGRATED);
C
Chris Lalancette 已提交
8026 8027
    if (!vm->persistent || (flags & VIR_MIGRATE_UNDEFINE_SOURCE)) {
        virDomainDeleteConfig(dom->conn, driver->configDir, driver->autostartDir, vm);
8028 8029
        if (qemuDomainObjEndJob(vm) > 0)
            virDomainRemoveInactive(&driver->domains, vm);
8030 8031
        vm = NULL;
    }
8032
    ret = 0;
D
Daniel Veillard 已提交
8033

8034
endjob:
8035
    if (paused) {
8036
        qemuDomainObjPrivatePtr priv = vm->privateData;
8037
        /* we got here through some sort of failure; start the domain again */
8038
        qemuDomainObjEnterMonitorWithDriver(driver, vm);
8039
        if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
8040 8041 8042 8043
            /* 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
             */
8044
            VIR_ERROR(_("Failed to resume guest %s after failure"),
8045
                      vm->def->name);
8046
        }
8047
        qemuDomainObjExitMonitorWithDriver(driver, vm);
8048

8049
        vm->state = VIR_DOMAIN_RUNNING;
8050 8051 8052 8053
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
    }
8054 8055 8056
    if (vm &&
        qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
8057

8058
cleanup:
8059 8060
    if (vm)
        virDomainObjUnlock(vm);
8061 8062
    if (event)
        qemuDomainEventQueue(driver, event);
8063
    qemuDriverUnlock(driver);
8064
    return ret;
D
Daniel Veillard 已提交
8065 8066 8067 8068 8069 8070 8071 8072 8073
}

/* 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,
C
Chris Lalancette 已提交
8074
                           unsigned long flags,
D
Daniel Veillard 已提交
8075 8076
                           int retcode)
{
8077 8078 8079
    struct qemud_driver *driver = dconn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
8080
    virDomainEventPtr event = NULL;
8081
    virErrorPtr orig_err;
C
Chris Lalancette 已提交
8082
    int newVM = 1;
D
Daniel Veillard 已提交
8083

8084 8085 8086
    /* Migration failed. Save the current error so nothing squashes it */
    orig_err = virSaveLastError();

8087
    qemuDriverLock(driver);
8088
    vm = virDomainFindByName(&driver->domains, dname);
D
Daniel Veillard 已提交
8089
    if (!vm) {
8090 8091
        qemudReportError (dconn, NULL, NULL, VIR_ERR_NO_DOMAIN,
                          _("no domain with matching name '%s'"), dname);
8092
        goto cleanup;
D
Daniel Veillard 已提交
8093 8094
    }

8095 8096 8097
    if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
        goto cleanup;

D
Daniel Veillard 已提交
8098 8099 8100 8101
    /* Did the migration go as planned?  If yes, return the domain
     * object, but if no, clean up the empty qemu process.
     */
    if (retcode == 0) {
C
Chris Lalancette 已提交
8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114 8115 8116 8117
        if (flags & VIR_MIGRATE_PERSIST_DEST) {
            if (vm->persistent)
                newVM = 0;
            vm->persistent = 1;

            if (virDomainSaveConfig(dconn, driver->configDir, vm->def) < 0) {
                /* Hmpf.  Migration was successful, but making it persistent
                 * was not.  If we report successful, then when this domain
                 * shuts down, management tools are in for a surprise.  On the
                 * other hand, if we report failure, then the management tools
                 * might try to restart the domain on the source side, even
                 * though the domain is actually running on the destination.
                 * Return a NULL dom pointer, and hope that this is a rare
                 * situation and management tools are smart.
                 */
                vm = NULL;
8118
                goto endjob;
C
Chris Lalancette 已提交
8119 8120 8121 8122 8123 8124 8125 8126 8127
            }

            event = virDomainEventNewFromObj(vm,
                                             VIR_DOMAIN_EVENT_DEFINED,
                                             newVM ?
                                             VIR_DOMAIN_EVENT_DEFINED_ADDED :
                                             VIR_DOMAIN_EVENT_DEFINED_UPDATED);
            if (event)
                qemuDomainEventQueue(driver, event);
8128
            event = NULL;
C
Chris Lalancette 已提交
8129 8130

        }
8131
        qemuDomainObjPrivatePtr priv = vm->privateData;
D
Daniel Veillard 已提交
8132
        dom = virGetDomain (dconn, vm->def->name, vm->def->uuid);
8133

8134 8135 8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146
        if (!(flags & VIR_MIGRATE_PAUSED)) {
            /* 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
             */
            qemuDomainObjEnterMonitorWithDriver(driver, vm);
            if (qemuMonitorStartCPUs(priv->mon, dconn) < 0) {
                if (virGetLastError() == NULL)
                    qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
                                     "%s", _("resume operation failed"));
                qemuDomainObjExitMonitorWithDriver(driver, vm);
                goto endjob;
            }
8147
            qemuDomainObjExitMonitorWithDriver(driver, vm);
8148 8149

            vm->state = VIR_DOMAIN_RUNNING;
8150 8151
        }

8152 8153 8154
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_MIGRATED);
8155 8156 8157 8158 8159 8160
        if (vm->state == VIR_DOMAIN_PAUSED) {
            qemuDomainEventQueue(driver, event);
            event = virDomainEventNewFromObj(vm,
                                             VIR_DOMAIN_EVENT_SUSPENDED,
                                             VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);
        }
8161
        virDomainSaveStatus(dconn, driver->caps, driver->stateDir, vm);
D
Daniel Veillard 已提交
8162 8163
    } else {
        qemudShutdownVMDaemon (dconn, driver, vm);
8164 8165 8166
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STOPPED,
                                         VIR_DOMAIN_EVENT_STOPPED_FAILED);
8167
        if (!vm->persistent) {
8168 8169
            if (qemuDomainObjEndJob(vm) > 0)
                virDomainRemoveInactive(&driver->domains, vm);
8170 8171
            vm = NULL;
        }
D
Daniel Veillard 已提交
8172
    }
8173

8174
endjob:
8175 8176 8177
    if (vm &&
        qemuDomainObjEndJob(vm) == 0)
        vm = NULL;
8178

8179
cleanup:
8180 8181 8182 8183
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
    }
8184 8185
    if (vm)
        virDomainObjUnlock(vm);
8186 8187
    if (event)
        qemuDomainEventQueue(driver, event);
8188
    qemuDriverUnlock(driver);
8189
    return dom;
D
Daniel Veillard 已提交
8190 8191
}

8192 8193 8194 8195 8196 8197 8198 8199 8200 8201 8202 8203 8204 8205 8206 8207
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;

8208
    def = virNodeDeviceDefParseString(dev->conn, xml, EXISTING_DEVICE);
8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227 8228 8229 8230 8231 8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243 8244 8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259 8260 8261 8262 8263 8264 8265 8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286
    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)
{
8287
    struct qemud_driver *driver = dev->conn->privateData;
8288 8289 8290 8291 8292 8293 8294 8295 8296 8297 8298
    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;

8299 8300 8301
    qemuDriverLock(driver);

    if (pciResetDevice(dev->conn, pci, driver->activePciHostdevs) < 0)
8302 8303 8304 8305
        goto out;

    ret = 0;
out:
8306
    qemuDriverUnlock(driver);
8307 8308 8309 8310
    pciFreeDevice(dev->conn, pci);
    return ret;
}

8311 8312 8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329 8330 8331 8332
static int
qemuCPUCompare(virConnectPtr conn,
               const char *xmlDesc,
               unsigned int flags ATTRIBUTE_UNUSED)
{
    struct qemud_driver *driver = conn->privateData;
    int ret = VIR_CPU_COMPARE_ERROR;

    qemuDriverLock(driver);

    if (!driver->caps || !driver->caps->host.cpu) {
        qemudReportError(conn, NULL, NULL, VIR_ERR_NO_SUPPORT,
                         "%s", _("cannot get host CPU capabilities"));
    }
    else
        ret = cpuCompareXML(conn, driver->caps->host.cpu, xmlDesc);

    qemuDriverUnlock(driver);

    return ret;
}

8333 8334 8335 8336 8337
static virDriver qemuDriver = {
    VIR_DRV_QEMU,
    "QEMU",
    qemudOpen, /* open */
    qemudClose, /* close */
D
Daniel Veillard 已提交
8338
    qemudSupportsFeature, /* supports_feature */
8339 8340
    qemudGetType, /* type */
    qemudGetVersion, /* version */
8341
    NULL, /* libvirtVersion (impl. in libvirt.c) */
8342
    virGetHostname, /* getHostname */
8343
    qemudGetMaxVCPUs, /* getMaxVcpus */
8344
    nodeGetInfo, /* nodeGetInfo */
8345 8346 8347
    qemudGetCapabilities, /* getCapabilities */
    qemudListDomains, /* listDomains */
    qemudNumDomains, /* numOfDomains */
8348
    qemudDomainCreate, /* domainCreateXML */
8349 8350 8351 8352 8353
    qemudDomainLookupByID, /* domainLookupByID */
    qemudDomainLookupByUUID, /* domainLookupByUUID */
    qemudDomainLookupByName, /* domainLookupByName */
    qemudDomainSuspend, /* domainSuspend */
    qemudDomainResume, /* domainResume */
8354
    qemudDomainShutdown, /* domainShutdown */
8355 8356 8357
    NULL, /* domainReboot */
    qemudDomainDestroy, /* domainDestroy */
    qemudDomainGetOSType, /* domainGetOSType */
8358 8359 8360
    qemudDomainGetMaxMemory, /* domainGetMaxMemory */
    qemudDomainSetMaxMemory, /* domainSetMaxMemory */
    qemudDomainSetMemory, /* domainSetMemory */
8361 8362 8363
    qemudDomainGetInfo, /* domainGetInfo */
    qemudDomainSave, /* domainSave */
    qemudDomainRestore, /* domainRestore */
P
Paolo Bonzini 已提交
8364
    qemudDomainCoreDump, /* domainCoreDump */
8365
    qemudDomainSetVcpus, /* domainSetVcpus */
8366 8367
    qemudDomainPinVcpu, /* domainPinVcpu */
    qemudDomainGetVcpus, /* domainGetVcpus */
8368
    qemudDomainGetMaxVcpus, /* domainGetMaxVcpus */
8369 8370
    qemudDomainGetSecurityLabel, /* domainGetSecurityLabel */
    qemudNodeGetSecurityModel, /* nodeGetSecurityModel */
8371
    qemudDomainDumpXML, /* domainDumpXML */
8372
    qemuDomainXMLFromNative, /* domainXmlFromNative */
8373
    qemuDomainXMLToNative, /* domainXMLToNative */
8374 8375
    qemudListDefinedDomains, /* listDefinedDomains */
    qemudNumDefinedDomains, /* numOfDefinedDomains */
8376 8377 8378
    qemudDomainStart, /* domainCreate */
    qemudDomainDefine, /* domainDefineXML */
    qemudDomainUndefine, /* domainUndefine */
8379
    qemudDomainAttachDevice, /* domainAttachDevice */
8380
    qemudDomainDetachDevice, /* domainDetachDevice */
8381 8382
    qemudDomainGetAutostart, /* domainGetAutostart */
    qemudDomainSetAutostart, /* domainSetAutostart */
8383 8384 8385
    qemuGetSchedulerType, /* domainGetSchedulerType */
    qemuGetSchedulerParameters, /* domainGetSchedulerParameters */
    qemuSetSchedulerParameters, /* domainSetSchedulerParameters */
D
Daniel Veillard 已提交
8386 8387
    NULL, /* domainMigratePrepare (v1) */
    qemudDomainMigratePerform, /* domainMigratePerform */
8388
    NULL, /* domainMigrateFinish */
8389
    qemudDomainBlockStats, /* domainBlockStats */
8390
    qemudDomainInterfaceStats, /* domainInterfaceStats */
8391
    qemudDomainMemoryStats, /* domainMemoryStats */
8392
    qemudDomainBlockPeek, /* domainBlockPeek */
R
Richard W.M. Jones 已提交
8393
    qemudDomainMemoryPeek, /* domainMemoryPeek */
8394 8395
    nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
    nodeGetFreeMemory,  /* getFreeMemory */
8396 8397
    qemudDomainEventRegister, /* domainEventRegister */
    qemudDomainEventDeregister, /* domainEventDeregister */
D
Daniel Veillard 已提交
8398 8399
    qemudDomainMigratePrepare2, /* domainMigratePrepare2 */
    qemudDomainMigrateFinish2, /* domainMigrateFinish2 */
8400 8401 8402
    qemudNodeDeviceDettach, /* nodeDeviceDettach */
    qemudNodeDeviceReAttach, /* nodeDeviceReAttach */
    qemudNodeDeviceReset, /* nodeDeviceReset */
C
Chris Lalancette 已提交
8403
    qemudDomainMigratePrepareTunnel, /* domainMigratePrepareTunnel */
8404 8405 8406 8407
    qemuIsEncrypted,
    qemuIsSecure,
    qemuDomainIsActive,
    qemuDomainIsPersistent,
8408
    qemuCPUCompare, /* cpuCompare */
8409 8410 8411
};


8412
static virStateDriver qemuStateDriver = {
8413
    .name = "QEMU",
8414 8415 8416 8417
    .initialize = qemudStartup,
    .cleanup = qemudShutdown,
    .reload = qemudReload,
    .active = qemudActive,
8418
};
8419

8420
int qemuRegister(void) {
8421 8422 8423 8424
    virRegisterDriver(&qemuDriver);
    virRegisterStateDriver(&qemuStateDriver);
    return 0;
}