qemu_process.c 183.2 KB
Newer Older
1
/*
2
 * qemu_process.c: QEMU process management
3
 *
4
 * Copyright (C) 2006-2015 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16
 *
 * 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
17
 * License along with this library.  If not, see
O
Osier Yang 已提交
18
 * <http://www.gnu.org/licenses/>.
19 20 21 22 23 24 25 26 27
 *
 */

#include <config.h>

#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <sys/stat.h>
R
Roman Bogorodskiy 已提交
28 29 30 31 32 33
#if defined(__linux__)
# include <linux/capability.h>
#elif defined(__FreeBSD__)
# include <sys/param.h>
# include <sys/cpuset.h>
#endif
34 35

#include "qemu_process.h"
36
#include "qemu_processpriv.h"
37 38 39 40 41 42 43
#include "qemu_domain.h"
#include "qemu_cgroup.h"
#include "qemu_capabilities.h"
#include "qemu_monitor.h"
#include "qemu_command.h"
#include "qemu_hostdev.h"
#include "qemu_hotplug.h"
44
#include "qemu_migration.h"
45
#include "qemu_interface.h"
46

47
#include "cpu/cpu.h"
48
#include "datatypes.h"
49
#include "virlog.h"
50
#include "virerror.h"
51
#include "viralloc.h"
52
#include "virhook.h"
E
Eric Blake 已提交
53
#include "virfile.h"
54
#include "virpidfile.h"
55 56
#include "c-ctype.h"
#include "nodeinfo.h"
57
#include "domain_audit.h"
58
#include "domain_nwfilter.h"
59
#include "locking/domain_lock.h"
60
#include "network/bridge_driver.h"
61
#include "viruuid.h"
62
#include "virprocess.h"
63
#include "virtime.h"
A
Ansis Atteka 已提交
64
#include "virnetdevtap.h"
65
#include "virnetdevopenvswitch.h"
66
#include "virnetdevmidonet.h"
67
#include "virbitmap.h"
68
#include "viratomic.h"
69
#include "virnuma.h"
70
#include "virstring.h"
71
#include "virhostdev.h"
72
#include "storage/storage_driver.h"
73
#include "configmake.h"
74
#include "nwfilter_conf.h"
75
#include "netdev_bandwidth_conf.h"
76 77 78

#define VIR_FROM_THIS VIR_FROM_QEMU

79 80
VIR_LOG_INIT("qemu.qemu_process");

81
#define ATTACH_POSTFIX ": attaching\n"
82 83 84
#define SHUTDOWN_POSTFIX ": shutting down\n"

/**
85
 * qemuProcessRemoveDomainStatus
86 87 88 89 90 91
 *
 * remove all state files of a domain from statedir
 *
 * Returns 0 on success
 */
static int
92
qemuProcessRemoveDomainStatus(virQEMUDriverPtr driver,
93 94 95 96
                              virDomainObjPtr vm)
{
    char ebuf[1024];
    char *file = NULL;
97
    qemuDomainObjPrivatePtr priv = vm->privateData;
98 99
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = -1;
100

101
    if (virAsprintf(&file, "%s/%s.xml", cfg->stateDir, vm->def->name) < 0)
102
        goto cleanup;
103 104 105 106 107 108

    if (unlink(file) < 0 && errno != ENOENT && errno != ENOTDIR)
        VIR_WARN("Failed to remove domain XML for %s: %s",
                 vm->def->name, virStrerror(errno, ebuf, sizeof(ebuf)));
    VIR_FREE(file);

109 110 111
    if (priv->pidfile &&
        unlink(priv->pidfile) < 0 &&
        errno != ENOENT)
112 113 114
        VIR_WARN("Failed to remove PID file for %s: %s",
                 vm->def->name, virStrerror(errno, ebuf, sizeof(ebuf)));

115
    ret = 0;
116
 cleanup:
117 118
    virObjectUnref(cfg);
    return ret;
119 120 121 122
}


/* XXX figure out how to remove this */
123
extern virQEMUDriverPtr qemu_driver;
124

D
Daniel P. Berrange 已提交
125 126 127 128 129 130 131
/*
 * This is a callback registered with a qemuAgentPtr instance,
 * and to be invoked when the agent console hits an end of file
 * condition, or error, thus indicating VM shutdown should be
 * performed
 */
static void
132
qemuProcessHandleAgentEOF(qemuAgentPtr agent,
D
Daniel P. Berrange 已提交
133 134 135 136 137 138
                          virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv;

    VIR_DEBUG("Received EOF from agent on %p '%s'", vm, vm->def->name);

139
    virObjectLock(vm);
D
Daniel P. Berrange 已提交
140 141

    priv = vm->privateData;
142 143 144 145 146 147 148 149 150 151 152 153

    if (!priv->agent) {
        VIR_DEBUG("Agent freed already");
        goto unlock;
    }

    if (priv->beingDestroyed) {
        VIR_DEBUG("Domain is being destroyed, agent EOF is expected");
        goto unlock;
    }

    priv->agent = NULL;
D
Daniel P. Berrange 已提交
154

155
    virObjectUnlock(vm);
156 157

    qemuAgentClose(agent);
158 159
    return;

160
 unlock:
161 162
    virObjectUnlock(vm);
    return;
D
Daniel P. Berrange 已提交
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
}


/*
 * This is invoked when there is some kind of error
 * parsing data to/from the agent. The VM can continue
 * to run, but no further agent commands will be
 * allowed
 */
static void
qemuProcessHandleAgentError(qemuAgentPtr agent ATTRIBUTE_UNUSED,
                            virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv;

    VIR_DEBUG("Received error from agent on %p '%s'", vm, vm->def->name);

180
    virObjectLock(vm);
D
Daniel P. Berrange 已提交
181 182 183 184 185

    priv = vm->privateData;

    priv->agentError = true;

186
    virObjectUnlock(vm);
D
Daniel P. Berrange 已提交
187 188 189 190 191
}

static void qemuProcessHandleAgentDestroy(qemuAgentPtr agent,
                                          virDomainObjPtr vm)
{
192 193
    VIR_DEBUG("Received destroy agent=%p vm=%p", agent, vm);

194
    virObjectUnref(vm);
D
Daniel P. Berrange 已提交
195 196 197 198 199 200 201 202 203 204
}


static qemuAgentCallbacks agentCallbacks = {
    .destroy = qemuProcessHandleAgentDestroy,
    .eofNotify = qemuProcessHandleAgentEOF,
    .errorNotify = qemuProcessHandleAgentError,
};


205
int
206
qemuConnectAgent(virQEMUDriverPtr driver, virDomainObjPtr vm)
D
Daniel P. Berrange 已提交
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int ret = -1;
    qemuAgentPtr agent = NULL;
    virDomainChrSourceDefPtr config = qemuFindAgentConfig(vm->def);

    if (!config)
        return 0;

    if (virSecurityManagerSetDaemonSocketLabel(driver->securityManager,
                                               vm->def) < 0) {
        VIR_ERROR(_("Failed to set security context for agent for %s"),
                  vm->def->name);
        goto cleanup;
    }

    /* Hold an extra reference because we can't allow 'vm' to be
     * deleted while the agent is active */
225
    virObjectRef(vm);
D
Daniel P. Berrange 已提交
226 227

    ignore_value(virTimeMillisNow(&priv->agentStart));
228
    virObjectUnlock(vm);
D
Daniel P. Berrange 已提交
229 230 231 232 233

    agent = qemuAgentOpen(vm,
                          config,
                          &agentCallbacks);

234
    virObjectLock(vm);
D
Daniel P. Berrange 已提交
235 236
    priv->agentStart = 0;

237 238 239 240 241 242 243 244 245 246 247
    if (agent == NULL)
        virObjectUnref(vm);

    if (!virDomainObjIsActive(vm)) {
        qemuAgentClose(agent);
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("guest crashed while connecting to the guest agent"));
        ret = -2;
        goto cleanup;
    }

D
Daniel P. Berrange 已提交
248 249 250 251
    if (virSecurityManagerClearSocketLabel(driver->securityManager,
                                           vm->def) < 0) {
        VIR_ERROR(_("Failed to clear security context for agent for %s"),
                  vm->def->name);
252
        qemuAgentClose(agent);
D
Daniel P. Berrange 已提交
253 254 255 256 257 258 259 260 261 262 263 264 265
        goto cleanup;
    }


    priv->agent = agent;

    if (priv->agent == NULL) {
        VIR_INFO("Failed to connect agent for %s", vm->def->name);
        goto cleanup;
    }

    ret = 0;

266
 cleanup:
D
Daniel P. Berrange 已提交
267 268 269 270
    return ret;
}


271
/*
272
 * This is a callback registered with a qemuMonitorPtr instance,
273 274 275 276 277 278
 * 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
qemuProcessHandleMonitorEOF(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
279 280
                            virDomainObjPtr vm,
                            void *opaque)
281
{
282
    virQEMUDriverPtr driver = opaque;
283
    virObjectEventPtr event = NULL;
284
    qemuDomainObjPrivatePtr priv;
285 286 287
    int eventReason = VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN;
    int stopReason = VIR_DOMAIN_SHUTOFF_SHUTDOWN;
    const char *auditReason = "shutdown";
288
    unsigned int stopFlags = 0;
289 290 291

    VIR_DEBUG("Received EOF on %p '%s'", vm, vm->def->name);

292
    virObjectLock(vm);
293

294 295 296 297
    priv = vm->privateData;

    if (priv->beingDestroyed) {
        VIR_DEBUG("Domain is being destroyed, EOF is expected");
298
        goto cleanup;
299 300
    }

301 302
    if (!virDomainObjIsActive(vm)) {
        VIR_DEBUG("Domain %p is not active, ignoring EOF", vm);
303
        goto cleanup;
304 305
    }

306
    if (priv->monJSON && !priv->gotShutdown) {
307 308
        VIR_DEBUG("Monitor connection to '%s' closed without SHUTDOWN event; "
                  "assuming the domain crashed", vm->def->name);
309
        eventReason = VIR_DOMAIN_EVENT_STOPPED_FAILED;
310
        stopReason = VIR_DOMAIN_SHUTOFF_CRASHED;
311
        auditReason = "failed";
312 313
    }

314 315
    if (priv->job.asyncJob == QEMU_ASYNC_JOB_MIGRATION_IN) {
        stopFlags |= VIR_QEMU_PROCESS_STOP_MIGRATED;
316 317
        qemuMigrationErrorSave(driver, vm->def->name,
                               qemuMonitorLastError(priv->mon));
318
    }
319

320
    event = virDomainEventLifecycleNewFromObj(vm,
321
                                     VIR_DOMAIN_EVENT_STOPPED,
322
                                     eventReason);
323
    qemuProcessStop(driver, vm, stopReason, stopFlags);
324
    virDomainAuditStop(vm, auditReason);
325

326
    if (!vm->persistent)
327
        qemuDomainRemoveInactive(driver, vm);
328

329
 cleanup:
330
    virObjectUnlock(vm);
331
    if (event)
332
        qemuDomainEventQueue(driver, event);
333 334 335 336 337 338 339 340 341 342 343
}


/*
 * This is invoked when there is some kind of error
 * parsing data to/from the monitor. The VM can continue
 * to run, but no further monitor commands will be
 * allowed
 */
static void
qemuProcessHandleMonitorError(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
344 345
                              virDomainObjPtr vm,
                              void *opaque)
346
{
347
    virQEMUDriverPtr driver = opaque;
348
    virObjectEventPtr event = NULL;
349 350 351

    VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name);

352
    virObjectLock(vm);
353

354
    ((qemuDomainObjPrivatePtr) vm->privateData)->monError = true;
355 356 357 358
    event = virDomainEventControlErrorNewFromObj(vm);
    if (event)
        qemuDomainEventQueue(driver, event);

359
    virObjectUnlock(vm);
360 361 362
}


363
virDomainDiskDefPtr
364 365 366
qemuProcessFindDomainDiskByAlias(virDomainObjPtr vm,
                                 const char *alias)
{
367
    size_t i;
368 369 370 371 372 373 374 375 376 377 378 379

    if (STRPREFIX(alias, QEMU_DRIVE_HOST_PREFIX))
        alias += strlen(QEMU_DRIVE_HOST_PREFIX);

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

        disk = vm->def->disks[i];
        if (disk->info.alias != NULL && STREQ(disk->info.alias, alias))
            return disk;
    }

380 381 382
    virReportError(VIR_ERR_INTERNAL_ERROR,
                   _("no disk found with alias %s"),
                   alias);
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
    return NULL;
}

static int
qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
                                   virDomainDiskDefPtr disk,
                                   char **secretRet,
                                   size_t *secretLen)
{
    virSecretPtr secret;
    char *passphrase;
    unsigned char *data;
    size_t size;
    int ret = -1;
    virStorageEncryptionPtr enc;

399
    if (!disk->src->encryption) {
400 401
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("disk %s does not have any encryption information"),
402
                       disk->src->path);
403 404
        return -1;
    }
405
    enc = disk->src->encryption;
406 407

    if (!conn) {
408 409
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("cannot find secrets without a connection"));
410 411 412 413
        goto cleanup;
    }

    if (conn->secretDriver == NULL ||
414 415
        conn->secretDriver->secretLookupByUUID == NULL ||
        conn->secretDriver->secretGetValue == NULL) {
416 417
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("secret storage not supported"));
418 419 420 421 422 423 424
        goto cleanup;
    }

    if (enc->format != VIR_STORAGE_ENCRYPTION_FORMAT_QCOW ||
        enc->nsecrets != 1 ||
        enc->secrets[0]->type !=
        VIR_STORAGE_ENCRYPTION_SECRET_TYPE_PASSPHRASE) {
425
        virReportError(VIR_ERR_XML_ERROR,
426 427
                       _("invalid <encryption> for volume %s"),
                       virDomainDiskGetSource(disk));
428 429 430
        goto cleanup;
    }

431 432
    secret = conn->secretDriver->secretLookupByUUID(conn,
                                                    enc->secrets[0]->uuid);
433 434
    if (secret == NULL)
        goto cleanup;
435 436
    data = conn->secretDriver->secretGetValue(secret, &size, 0,
                                              VIR_SECRET_GET_VALUE_INTERNAL_CALL);
437
    virObjectUnref(secret);
438 439 440 441 442 443
    if (data == NULL)
        goto cleanup;

    if (memchr(data, '\0', size) != NULL) {
        memset(data, 0, size);
        VIR_FREE(data);
444 445
        virReportError(VIR_ERR_XML_ERROR,
                       _("format='qcow' passphrase for %s must not contain a "
446
                         "'\\0'"), virDomainDiskGetSource(disk));
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
        goto cleanup;
    }

    if (VIR_ALLOC_N(passphrase, size + 1) < 0) {
        memset(data, 0, size);
        VIR_FREE(data);
        goto cleanup;
    }
    memcpy(passphrase, data, size);
    passphrase[size] = '\0';

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

    *secretRet = passphrase;
    *secretLen = size;

    ret = 0;

466
 cleanup:
467 468 469 470 471 472 473 474 475
    return ret;
}

static int
qemuProcessFindVolumeQcowPassphrase(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                    virConnectPtr conn,
                                    virDomainObjPtr vm,
                                    const char *path,
                                    char **secretRet,
476 477
                                    size_t *secretLen,
                                    void *opaque ATTRIBUTE_UNUSED)
478 479 480 481
{
    virDomainDiskDefPtr disk;
    int ret = -1;

482
    virObjectLock(vm);
483 484 485 486
    if (!(disk = virDomainDiskByName(vm->def, path, true))) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("no disk found with path %s"),
                       path);
487
        goto cleanup;
488
    }
489 490 491

    ret = qemuProcessGetVolumeQcowPassphrase(conn, disk, secretRet, secretLen);

492
 cleanup:
493
    virObjectUnlock(vm);
494 495 496 497 498 499
    return ret;
}


static int
qemuProcessHandleReset(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
500 501
                       virDomainObjPtr vm,
                       void *opaque)
502
{
503
    virQEMUDriverPtr driver = opaque;
504
    virObjectEventPtr event;
505
    qemuDomainObjPrivatePtr priv;
506
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
507

508
    virObjectLock(vm);
509

510
    event = virDomainEventRebootNewFromObj(vm);
511 512 513
    priv = vm->privateData;
    if (priv->agent)
        qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_RESET);
514 515 516

    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
        VIR_WARN("Failed to save status on vm %s", vm->def->name);
517

518
    virObjectUnlock(vm);
519

520
    if (event)
521 522
        qemuDomainEventQueue(driver, event);

523
    virObjectUnref(cfg);
524 525 526 527
    return 0;
}


528 529 530 531 532 533 534 535 536 537 538
/*
 * Since we have the '-no-shutdown' flag set, the
 * QEMU process will currently have guest OS shutdown
 * and the CPUS stopped. To fake the reboot, we thus
 * want todo a reset of the virtual hardware, followed
 * by restart of the CPUs. This should result in the
 * guest OS booting up again
 */
static void
qemuProcessFakeReboot(void *opaque)
{
539
    virQEMUDriverPtr driver = qemu_driver;
540 541
    virDomainObjPtr vm = opaque;
    qemuDomainObjPrivatePtr priv = vm->privateData;
542
    virObjectEventPtr event = NULL;
543
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
544
    virDomainRunningReason reason = VIR_DOMAIN_RUNNING_BOOTED;
545
    int ret = -1, rc;
546

547
    VIR_DEBUG("vm=%p", vm);
548
    virObjectLock(vm);
549
    if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
550 551 552
        goto cleanup;

    if (!virDomainObjIsActive(vm)) {
553 554
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("guest unexpectedly quit"));
555 556 557
        goto endjob;
    }

558
    qemuDomainObjEnterMonitor(driver, vm);
559 560 561
    rc = qemuMonitorSystemReset(priv->mon);

    if (qemuDomainObjExitMonitor(driver, vm) < 0)
562 563
        goto endjob;

564
    if (rc < 0)
565 566
        goto endjob;

567 568 569
    if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_CRASHED)
        reason = VIR_DOMAIN_RUNNING_CRASHED;

570
    if (qemuProcessStartCPUs(driver, vm, NULL,
571
                             reason,
572
                             QEMU_ASYNC_JOB_NONE) < 0) {
573
        if (virGetLastError() == NULL)
574 575
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("resume operation failed"));
576 577
        goto endjob;
    }
578
    priv->gotShutdown = false;
579
    event = virDomainEventLifecycleNewFromObj(vm,
580 581 582
                                     VIR_DOMAIN_EVENT_RESUMED,
                                     VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);

583 584 585 586 587
    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
        VIR_WARN("Unable to save status on vm %s after state change",
                 vm->def->name);
    }

588 589
    ret = 0;

590
 endjob:
591
    qemuDomainObjEndJob(driver, vm);
592

593
 cleanup:
594 595
    if (ret == -1)
        ignore_value(qemuProcessKill(vm, VIR_QEMU_PROCESS_KILL_FORCE));
M
Michal Privoznik 已提交
596
    virDomainObjEndAPI(&vm);
597 598
    if (event)
        qemuDomainEventQueue(driver, event);
599
    virObjectUnref(cfg);
600 601 602
}


603
void
604
qemuProcessShutdownOrReboot(virQEMUDriverPtr driver,
605
                            virDomainObjPtr vm)
606
{
607 608 609
    qemuDomainObjPrivatePtr priv = vm->privateData;

    if (priv->fakeReboot) {
610
        qemuDomainSetFakeReboot(driver, vm, false);
611
        virObjectRef(vm);
612 613 614 615 616
        virThread th;
        if (virThreadCreate(&th,
                            false,
                            qemuProcessFakeReboot,
                            vm) < 0) {
617
            VIR_ERROR(_("Failed to create reboot thread, killing domain"));
618
            ignore_value(qemuProcessKill(vm, VIR_QEMU_PROCESS_KILL_NOWAIT));
619
            virObjectUnref(vm);
620 621
        }
    } else {
622
        ignore_value(qemuProcessKill(vm, VIR_QEMU_PROCESS_KILL_NOWAIT));
623
    }
624
}
625

626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653

static int
qemuProcessHandleEvent(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                       virDomainObjPtr vm,
                       const char *eventName,
                       long long seconds,
                       unsigned int micros,
                       const char *details,
                       void *opaque)
{
    virQEMUDriverPtr driver = opaque;
    virObjectEventPtr event = NULL;

    VIR_DEBUG("vm=%p", vm);

    virObjectLock(vm);
    event = virDomainQemuMonitorEventNew(vm->def->id, vm->def->name,
                                         vm->def->uuid, eventName,
                                         seconds, micros, details);

    virObjectUnlock(vm);
    if (event)
        qemuDomainEventQueue(driver, event);

    return 0;
}


654 655
static int
qemuProcessHandleShutdown(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
656 657
                          virDomainObjPtr vm,
                          void *opaque)
658
{
659
    virQEMUDriverPtr driver = opaque;
660
    qemuDomainObjPrivatePtr priv;
661
    virObjectEventPtr event = NULL;
662
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
663

664 665
    VIR_DEBUG("vm=%p", vm);

666
    virObjectLock(vm);
667 668 669 670 671 672

    priv = vm->privateData;
    if (priv->gotShutdown) {
        VIR_DEBUG("Ignoring repeated SHUTDOWN event from domain %s",
                  vm->def->name);
        goto unlock;
673 674 675 676
    } else if (!virDomainObjIsActive(vm)) {
        VIR_DEBUG("Ignoring SHUTDOWN event from inactive domain %s",
                  vm->def->name);
        goto unlock;
677 678 679 680 681 682 683 684
    }
    priv->gotShutdown = true;

    VIR_DEBUG("Transitioned guest %s to shutdown state",
              vm->def->name);
    virDomainObjSetState(vm,
                         VIR_DOMAIN_SHUTDOWN,
                         VIR_DOMAIN_SHUTDOWN_UNKNOWN);
685
    event = virDomainEventLifecycleNewFromObj(vm,
686 687 688
                                     VIR_DOMAIN_EVENT_SHUTDOWN,
                                     VIR_DOMAIN_EVENT_SHUTDOWN_FINISHED);

689
    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
690 691 692 693
        VIR_WARN("Unable to save status on vm %s after state change",
                 vm->def->name);
    }

694 695 696
    if (priv->agent)
        qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_SHUTDOWN);

697 698
    qemuProcessShutdownOrReboot(driver, vm);

699
 unlock:
700
    virObjectUnlock(vm);
701
    if (event)
702
        qemuDomainEventQueue(driver, event);
703
    virObjectUnref(cfg);
704

705 706 707 708 709 710
    return 0;
}


static int
qemuProcessHandleStop(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
711 712
                      virDomainObjPtr vm,
                      void *opaque)
713
{
714
    virQEMUDriverPtr driver = opaque;
715
    virObjectEventPtr event = NULL;
716
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
717

718
    virObjectLock(vm);
J
Jiri Denemark 已提交
719
    if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
720
        qemuDomainObjPrivatePtr priv = vm->privateData;
721

722
        if (priv->gotShutdown) {
723 724
            VIR_DEBUG("Ignoring STOP event after SHUTDOWN");
            goto unlock;
725 726
        }

727 728
        VIR_DEBUG("Transitioned guest %s to paused state",
                  vm->def->name);
729

730 731 732
        if (priv->job.current)
            ignore_value(virTimeMillisNow(&priv->job.current->stopped));

733
        virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_UNKNOWN);
734
        event = virDomainEventLifecycleNewFromObj(vm,
735 736 737
                                         VIR_DOMAIN_EVENT_SUSPENDED,
                                         VIR_DOMAIN_EVENT_SUSPENDED_PAUSED);

738 739 740 741 742
        VIR_FREE(priv->lockState);
        if (virDomainLockProcessPause(driver->lockManager, vm, &priv->lockState) < 0)
            VIR_WARN("Unable to release lease on %s", vm->def->name);
        VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));

743
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
744 745 746
            VIR_WARN("Unable to save status on vm %s after state change",
                     vm->def->name);
        }
747
    }
748

749
 unlock:
750
    virObjectUnlock(vm);
751
    if (event)
752
        qemuDomainEventQueue(driver, event);
753
    virObjectUnref(cfg);
754 755 756 757 758

    return 0;
}


759 760
static int
qemuProcessHandleResume(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
761 762
                        virDomainObjPtr vm,
                        void *opaque)
763
{
764
    virQEMUDriverPtr driver = opaque;
765
    virObjectEventPtr event = NULL;
766
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
767

768
    virObjectLock(vm);
769 770 771 772 773 774 775 776 777 778 779 780 781
    if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PAUSED) {
        qemuDomainObjPrivatePtr priv = vm->privateData;

        if (priv->gotShutdown) {
            VIR_DEBUG("Ignoring RESUME event after SHUTDOWN");
            goto unlock;
        }

        VIR_DEBUG("Transitioned guest %s out of paused into resumed state",
                  vm->def->name);

        virDomainObjSetState(vm, VIR_DOMAIN_RUNNING,
                                 VIR_DOMAIN_RUNNING_UNPAUSED);
782
        event = virDomainEventLifecycleNewFromObj(vm,
783 784 785 786
                                         VIR_DOMAIN_EVENT_RESUMED,
                                         VIR_DOMAIN_EVENT_RESUMED_UNPAUSED);

        VIR_DEBUG("Using lock state '%s' on resume event", NULLSTR(priv->lockState));
787
        if (virDomainLockProcessResume(driver->lockManager, cfg->uri,
788 789 790 791 792 793 794 795 796
                                       vm, priv->lockState) < 0) {
            /* Don't free priv->lockState on error, because we need
             * to make sure we have state still present if the user
             * tries to resume again
             */
            goto unlock;
        }
        VIR_FREE(priv->lockState);

797
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
798 799 800 801 802
            VIR_WARN("Unable to save status on vm %s after state change",
                     vm->def->name);
        }
    }

803
 unlock:
804
    virObjectUnlock(vm);
805
    if (event)
806
        qemuDomainEventQueue(driver, event);
807
    virObjectUnref(cfg);
808 809 810
    return 0;
}

811 812 813
static int
qemuProcessHandleRTCChange(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                           virDomainObjPtr vm,
814 815
                           long long offset,
                           void *opaque)
816
{
817
    virQEMUDriverPtr driver = opaque;
818
    virObjectEventPtr event = NULL;
819
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
820

821
    virObjectLock(vm);
822

823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839
    if (vm->def->clock.offset == VIR_DOMAIN_CLOCK_OFFSET_VARIABLE) {
        /* when a basedate is manually given on the qemu commandline
         * rather than simply "-rtc base=utc", the offset sent by qemu
         * in this event is *not* the new offset from UTC, but is
         * instead the new offset from the *original basedate* +
         * uptime. For example, if the original offset was 3600 and
         * the guest clock has been advanced by 10 seconds, qemu will
         * send "10" in the event - this means that the new offset
         * from UTC is 3610, *not* 10. If the guest clock is advanced
         * by another 10 seconds, qemu will now send "20" - i.e. each
         * event is the sum of the most recent change and all previous
         * changes since the domain was started. Fortunately, we have
         * saved the initial offset in "adjustment0", so to arrive at
         * the proper new "adjustment", we just add the most recent
         * offset to adjustment0.
         */
        offset += vm->def->clock.data.variable.adjustment0;
840
        vm->def->clock.data.variable.adjustment = offset;
841

842 843 844 845 846
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
           VIR_WARN("unable to save domain status with RTC change");
    }

    event = virDomainEventRTCChangeNewFromObj(vm, offset);
847

848
    virObjectUnlock(vm);
849

850
    if (event)
851
        qemuDomainEventQueue(driver, event);
852
    virObjectUnref(cfg);
853 854 855 856 857 858 859
    return 0;
}


static int
qemuProcessHandleWatchdog(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                          virDomainObjPtr vm,
860 861
                          int action,
                          void *opaque)
862
{
863
    virQEMUDriverPtr driver = opaque;
864 865
    virObjectEventPtr watchdogEvent = NULL;
    virObjectEventPtr lifecycleEvent = NULL;
866
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
867

868
    virObjectLock(vm);
869 870 871
    watchdogEvent = virDomainEventWatchdogNewFromObj(vm, action);

    if (action == VIR_DOMAIN_EVENT_WATCHDOG_PAUSE &&
J
Jiri Denemark 已提交
872
        virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
873
        qemuDomainObjPrivatePtr priv = vm->privateData;
874 875
        VIR_DEBUG("Transitioned guest %s to paused state due to watchdog", vm->def->name);

J
Jiri Denemark 已提交
876
        virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_WATCHDOG);
877
        lifecycleEvent = virDomainEventLifecycleNewFromObj(vm,
878 879 880
                                                  VIR_DOMAIN_EVENT_SUSPENDED,
                                                  VIR_DOMAIN_EVENT_SUSPENDED_WATCHDOG);

881 882 883 884 885
        VIR_FREE(priv->lockState);
        if (virDomainLockProcessPause(driver->lockManager, vm, &priv->lockState) < 0)
            VIR_WARN("Unable to release lease on %s", vm->def->name);
        VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));

886
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
887 888 889
            VIR_WARN("Unable to save status on vm %s after watchdog event",
                     vm->def->name);
        }
890 891 892
    }

    if (vm->def->watchdog->action == VIR_DOMAIN_WATCHDOG_ACTION_DUMP) {
C
Chen Fan 已提交
893 894 895 896 897
        struct qemuProcessEvent *processEvent;
        if (VIR_ALLOC(processEvent) == 0) {
            processEvent->eventType = QEMU_PROCESS_EVENT_WATCHDOG;
            processEvent->action = VIR_DOMAIN_WATCHDOG_ACTION_DUMP;
            processEvent->vm = vm;
W
Wen Congyang 已提交
898 899 900
            /* Hold an extra reference because we can't allow 'vm' to be
             * deleted before handling watchdog event is finished.
             */
901
            virObjectRef(vm);
C
Chen Fan 已提交
902
            if (virThreadPoolSendJob(driver->workerPool, 0, processEvent) < 0) {
903
                if (!virObjectUnref(vm))
904
                    vm = NULL;
C
Chen Fan 已提交
905
                VIR_FREE(processEvent);
W
Wen Congyang 已提交
906
            }
907
        }
908 909
    }

910
    if (vm)
911
        virObjectUnlock(vm);
912 913 914 915
    if (watchdogEvent)
        qemuDomainEventQueue(driver, watchdogEvent);
    if (lifecycleEvent)
        qemuDomainEventQueue(driver, lifecycleEvent);
916

917
    virObjectUnref(cfg);
918 919 920 921 922 923 924 925 926
    return 0;
}


static int
qemuProcessHandleIOError(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                         virDomainObjPtr vm,
                         const char *diskAlias,
                         int action,
927 928
                         const char *reason,
                         void *opaque)
929
{
930
    virQEMUDriverPtr driver = opaque;
931 932 933
    virObjectEventPtr ioErrorEvent = NULL;
    virObjectEventPtr ioErrorEvent2 = NULL;
    virObjectEventPtr lifecycleEvent = NULL;
934 935 936
    const char *srcPath;
    const char *devAlias;
    virDomainDiskDefPtr disk;
937
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
938

939
    virObjectLock(vm);
940 941 942
    disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias);

    if (disk) {
943
        srcPath = virDomainDiskGetSource(disk);
944 945 946 947 948 949 950 951 952 953
        devAlias = disk->info.alias;
    } else {
        srcPath = "";
        devAlias = "";
    }

    ioErrorEvent = virDomainEventIOErrorNewFromObj(vm, srcPath, devAlias, action);
    ioErrorEvent2 = virDomainEventIOErrorReasonNewFromObj(vm, srcPath, devAlias, action, reason);

    if (action == VIR_DOMAIN_EVENT_IO_ERROR_PAUSE &&
J
Jiri Denemark 已提交
954
        virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
955
        qemuDomainObjPrivatePtr priv = vm->privateData;
956 957
        VIR_DEBUG("Transitioned guest %s to paused state due to IO error", vm->def->name);

958 959 960
        if (priv->signalIOError)
            virDomainObjBroadcast(vm);

J
Jiri Denemark 已提交
961
        virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_IOERROR);
962
        lifecycleEvent = virDomainEventLifecycleNewFromObj(vm,
963 964 965
                                                  VIR_DOMAIN_EVENT_SUSPENDED,
                                                  VIR_DOMAIN_EVENT_SUSPENDED_IOERROR);

966 967 968 969 970
        VIR_FREE(priv->lockState);
        if (virDomainLockProcessPause(driver->lockManager, vm, &priv->lockState) < 0)
            VIR_WARN("Unable to release lease on %s", vm->def->name);
        VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));

971
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
972 973
            VIR_WARN("Unable to save status on vm %s after IO error", vm->def->name);
    }
974
    virObjectUnlock(vm);
975

976 977 978 979 980 981
    if (ioErrorEvent)
        qemuDomainEventQueue(driver, ioErrorEvent);
    if (ioErrorEvent2)
        qemuDomainEventQueue(driver, ioErrorEvent2);
    if (lifecycleEvent)
        qemuDomainEventQueue(driver, lifecycleEvent);
982
    virObjectUnref(cfg);
983 984 985
    return 0;
}

986 987 988 989 990
static int
qemuProcessHandleBlockJob(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                          virDomainObjPtr vm,
                          const char *diskAlias,
                          int type,
991 992
                          int status,
                          void *opaque)
993
{
994
    virQEMUDriverPtr driver = opaque;
995
    struct qemuProcessEvent *processEvent = NULL;
996
    virDomainDiskDefPtr disk;
997
    qemuDomainDiskPrivatePtr diskPriv;
998
    char *data = NULL;
999

1000
    virObjectLock(vm);
1001

1002 1003
    VIR_DEBUG("Block job for device %s (domain: %p,%s) type %d status %d",
              diskAlias, vm, vm->def->name, type, status);
1004

1005
    if (!(disk = qemuProcessFindDomainDiskByAlias(vm, diskAlias)))
1006
        goto error;
1007
    diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
1008

1009
    if (diskPriv->blockJobSync) {
1010
        /* We have a SYNC API waiting for this event, dispatch it back */
1011 1012
        diskPriv->blockJobType = type;
        diskPriv->blockJobStatus = status;
1013
        virDomainObjBroadcast(vm);
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
    } else {
        /* there is no waiting SYNC API, dispatch the update to a thread */
        if (VIR_ALLOC(processEvent) < 0)
            goto error;

        processEvent->eventType = QEMU_PROCESS_EVENT_BLOCK_JOB;
        if (VIR_STRDUP(data, diskAlias) < 0)
            goto error;
        processEvent->data = data;
        processEvent->vm = vm;
        processEvent->action = type;
        processEvent->status = status;
1026

1027 1028 1029 1030 1031
        virObjectRef(vm);
        if (virThreadPoolSendJob(driver->workerPool, 0, processEvent) < 0) {
            ignore_value(virObjectUnref(vm));
            goto error;
        }
1032 1033
    }

1034
 cleanup:
1035
    virObjectUnlock(vm);
1036
    return 0;
1037 1038 1039 1040 1041
 error:
    if (processEvent)
        VIR_FREE(processEvent->data);
    VIR_FREE(processEvent);
    goto cleanup;
1042
}
1043

1044

1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
static int
qemuProcessHandleGraphics(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                          virDomainObjPtr vm,
                          int phase,
                          int localFamily,
                          const char *localNode,
                          const char *localService,
                          int remoteFamily,
                          const char *remoteNode,
                          const char *remoteService,
                          const char *authScheme,
                          const char *x509dname,
1057 1058
                          const char *saslUsername,
                          void *opaque)
1059
{
1060
    virQEMUDriverPtr driver = opaque;
1061
    virObjectEventPtr event;
1062 1063 1064
    virDomainEventGraphicsAddressPtr localAddr = NULL;
    virDomainEventGraphicsAddressPtr remoteAddr = NULL;
    virDomainEventGraphicsSubjectPtr subject = NULL;
1065
    size_t i;
1066 1067

    if (VIR_ALLOC(localAddr) < 0)
1068
        goto error;
1069
    localAddr->family = localFamily;
1070 1071 1072
    if (VIR_STRDUP(localAddr->service, localService) < 0 ||
        VIR_STRDUP(localAddr->node, localNode) < 0)
        goto error;
1073 1074

    if (VIR_ALLOC(remoteAddr) < 0)
1075
        goto error;
1076
    remoteAddr->family = remoteFamily;
1077 1078 1079
    if (VIR_STRDUP(remoteAddr->service, remoteService) < 0 ||
        VIR_STRDUP(remoteAddr->node, remoteNode) < 0)
        goto error;
1080 1081

    if (VIR_ALLOC(subject) < 0)
1082
        goto error;
1083 1084
    if (x509dname) {
        if (VIR_REALLOC_N(subject->identities, subject->nidentity+1) < 0)
1085
            goto error;
1086
        subject->nidentity++;
1087 1088 1089
        if (VIR_STRDUP(subject->identities[subject->nidentity-1].type, "x509dname") < 0 ||
            VIR_STRDUP(subject->identities[subject->nidentity-1].name, x509dname) < 0)
            goto error;
1090 1091 1092
    }
    if (saslUsername) {
        if (VIR_REALLOC_N(subject->identities, subject->nidentity+1) < 0)
1093
            goto error;
1094
        subject->nidentity++;
1095 1096 1097
        if (VIR_STRDUP(subject->identities[subject->nidentity-1].type, "saslUsername") < 0 ||
            VIR_STRDUP(subject->identities[subject->nidentity-1].name, saslUsername) < 0)
            goto error;
1098 1099
    }

1100
    virObjectLock(vm);
1101
    event = virDomainEventGraphicsNewFromObj(vm, phase, localAddr, remoteAddr, authScheme, subject);
1102
    virObjectUnlock(vm);
1103

1104
    if (event)
1105 1106 1107 1108
        qemuDomainEventQueue(driver, event);

    return 0;

1109
 error:
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
    if (localAddr) {
        VIR_FREE(localAddr->service);
        VIR_FREE(localAddr->node);
        VIR_FREE(localAddr);
    }
    if (remoteAddr) {
        VIR_FREE(remoteAddr->service);
        VIR_FREE(remoteAddr->node);
        VIR_FREE(remoteAddr);
    }
    if (subject) {
1121
        for (i = 0; i < subject->nidentity; i++) {
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
            VIR_FREE(subject->identities[i].type);
            VIR_FREE(subject->identities[i].name);
        }
        VIR_FREE(subject->identities);
        VIR_FREE(subject);
    }

    return -1;
}

1132 1133 1134 1135
static int
qemuProcessHandleTrayChange(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                            virDomainObjPtr vm,
                            const char *devAlias,
1136 1137
                            int reason,
                            void *opaque)
1138
{
1139
    virQEMUDriverPtr driver = opaque;
1140
    virObjectEventPtr event = NULL;
1141
    virDomainDiskDefPtr disk;
1142
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
1143

1144
    virObjectLock(vm);
1145 1146 1147 1148 1149 1150
    disk = qemuProcessFindDomainDiskByAlias(vm, devAlias);

    if (disk) {
        event = virDomainEventTrayChangeNewFromObj(vm,
                                                   devAlias,
                                                   reason);
1151 1152 1153 1154 1155 1156
        /* Update disk tray status */
        if (reason == VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN)
            disk->tray_status = VIR_DOMAIN_DISK_TRAY_OPEN;
        else if (reason == VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE)
            disk->tray_status = VIR_DOMAIN_DISK_TRAY_CLOSED;

1157
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
1158 1159 1160
            VIR_WARN("Unable to save status on vm %s after tray moved event",
                     vm->def->name);
        }
1161 1162

        virDomainObjBroadcast(vm);
1163 1164
    }

1165
    virObjectUnlock(vm);
1166
    if (event)
1167
        qemuDomainEventQueue(driver, event);
1168
    virObjectUnref(cfg);
1169 1170 1171
    return 0;
}

O
Osier Yang 已提交
1172 1173
static int
qemuProcessHandlePMWakeup(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
1174 1175
                          virDomainObjPtr vm,
                          void *opaque)
O
Osier Yang 已提交
1176
{
1177
    virQEMUDriverPtr driver = opaque;
1178 1179
    virObjectEventPtr event = NULL;
    virObjectEventPtr lifecycleEvent = NULL;
1180
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
O
Osier Yang 已提交
1181

1182
    virObjectLock(vm);
O
Osier Yang 已提交
1183 1184
    event = virDomainEventPMWakeupNewFromObj(vm);

1185 1186 1187 1188 1189 1190 1191 1192 1193
    /* Don't set domain status back to running if it wasn't paused
     * from guest side, otherwise it can just cause confusion.
     */
    if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_PMSUSPENDED) {
        VIR_DEBUG("Transitioned guest %s from pmsuspended to running "
                  "state due to QMP wakeup event", vm->def->name);

        virDomainObjSetState(vm, VIR_DOMAIN_RUNNING,
                             VIR_DOMAIN_RUNNING_WAKEUP);
1194
        lifecycleEvent = virDomainEventLifecycleNewFromObj(vm,
1195 1196 1197
                                                  VIR_DOMAIN_EVENT_STARTED,
                                                  VIR_DOMAIN_EVENT_STARTED_WAKEUP);

1198
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
1199 1200 1201 1202 1203
            VIR_WARN("Unable to save status on vm %s after wakeup event",
                     vm->def->name);
        }
    }

1204
    virObjectUnlock(vm);
1205 1206 1207 1208
    if (event)
        qemuDomainEventQueue(driver, event);
    if (lifecycleEvent)
        qemuDomainEventQueue(driver, lifecycleEvent);
1209
    virObjectUnref(cfg);
O
Osier Yang 已提交
1210 1211
    return 0;
}
1212

O
Osier Yang 已提交
1213 1214
static int
qemuProcessHandlePMSuspend(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
1215 1216
                           virDomainObjPtr vm,
                           void *opaque)
O
Osier Yang 已提交
1217
{
1218
    virQEMUDriverPtr driver = opaque;
1219 1220
    virObjectEventPtr event = NULL;
    virObjectEventPtr lifecycleEvent = NULL;
1221
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
O
Osier Yang 已提交
1222

1223
    virObjectLock(vm);
O
Osier Yang 已提交
1224 1225
    event = virDomainEventPMSuspendNewFromObj(vm);

1226
    if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
1227
        qemuDomainObjPrivatePtr priv = vm->privateData;
1228 1229 1230 1231 1232
        VIR_DEBUG("Transitioned guest %s to pmsuspended state due to "
                  "QMP suspend event", vm->def->name);

        virDomainObjSetState(vm, VIR_DOMAIN_PMSUSPENDED,
                             VIR_DOMAIN_PMSUSPENDED_UNKNOWN);
J
Jiri Denemark 已提交
1233
        lifecycleEvent =
1234
            virDomainEventLifecycleNewFromObj(vm,
J
Jiri Denemark 已提交
1235 1236
                                     VIR_DOMAIN_EVENT_PMSUSPENDED,
                                     VIR_DOMAIN_EVENT_PMSUSPENDED_MEMORY);
1237

1238
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
1239 1240 1241
            VIR_WARN("Unable to save status on vm %s after suspend event",
                     vm->def->name);
        }
1242 1243 1244

        if (priv->agent)
            qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_SUSPEND);
1245 1246
    }

1247
    virObjectUnlock(vm);
O
Osier Yang 已提交
1248

1249 1250 1251 1252
    if (event)
        qemuDomainEventQueue(driver, event);
    if (lifecycleEvent)
        qemuDomainEventQueue(driver, lifecycleEvent);
1253
    virObjectUnref(cfg);
O
Osier Yang 已提交
1254 1255 1256
    return 0;
}

1257 1258 1259
static int
qemuProcessHandleBalloonChange(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                               virDomainObjPtr vm,
1260 1261
                               unsigned long long actual,
                               void *opaque)
1262
{
1263
    virQEMUDriverPtr driver = opaque;
1264
    virObjectEventPtr event = NULL;
1265
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
1266

1267
    virObjectLock(vm);
1268 1269 1270 1271 1272 1273
    event = virDomainEventBalloonChangeNewFromObj(vm, actual);

    VIR_DEBUG("Updating balloon from %lld to %lld kb",
              vm->def->mem.cur_balloon, actual);
    vm->def->mem.cur_balloon = actual;

1274
    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
1275 1276
        VIR_WARN("unable to save domain status with balloon change");

1277
    virObjectUnlock(vm);
1278

1279
    if (event)
1280
        qemuDomainEventQueue(driver, event);
1281
    virObjectUnref(cfg);
1282 1283 1284
    return 0;
}

1285 1286
static int
qemuProcessHandlePMSuspendDisk(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
1287 1288
                               virDomainObjPtr vm,
                               void *opaque)
1289
{
1290
    virQEMUDriverPtr driver = opaque;
1291 1292
    virObjectEventPtr event = NULL;
    virObjectEventPtr lifecycleEvent = NULL;
1293
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
1294

1295
    virObjectLock(vm);
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305
    event = virDomainEventPMSuspendDiskNewFromObj(vm);

    if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
        qemuDomainObjPrivatePtr priv = vm->privateData;
        VIR_DEBUG("Transitioned guest %s to pmsuspended state due to "
                  "QMP suspend_disk event", vm->def->name);

        virDomainObjSetState(vm, VIR_DOMAIN_PMSUSPENDED,
                             VIR_DOMAIN_PMSUSPENDED_UNKNOWN);
        lifecycleEvent =
1306
            virDomainEventLifecycleNewFromObj(vm,
1307 1308 1309
                                     VIR_DOMAIN_EVENT_PMSUSPENDED,
                                     VIR_DOMAIN_EVENT_PMSUSPENDED_DISK);

1310
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0) {
1311 1312 1313 1314 1315 1316 1317 1318
            VIR_WARN("Unable to save status on vm %s after suspend event",
                     vm->def->name);
        }

        if (priv->agent)
            qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_SUSPEND);
    }

1319
    virObjectUnlock(vm);
1320

1321 1322 1323 1324
    if (event)
        qemuDomainEventQueue(driver, event);
    if (lifecycleEvent)
        qemuDomainEventQueue(driver, lifecycleEvent);
1325 1326
    virObjectUnref(cfg);

1327 1328 1329
    return 0;
}

1330

1331 1332
static int
qemuProcessHandleGuestPanic(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
1333 1334
                            virDomainObjPtr vm,
                            void *opaque)
1335
{
1336
    virQEMUDriverPtr driver = opaque;
1337 1338 1339
    struct qemuProcessEvent *processEvent;

    virObjectLock(vm);
1340
    if (VIR_ALLOC(processEvent) < 0)
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
        goto cleanup;

    processEvent->eventType = QEMU_PROCESS_EVENT_GUESTPANIC;
    processEvent->action = vm->def->onCrash;
    processEvent->vm = vm;
    /* Hold an extra reference because we can't allow 'vm' to be
     * deleted before handling guest panic event is finished.
     */
    virObjectRef(vm);
    if (virThreadPoolSendJob(driver->workerPool, 0, processEvent) < 0) {
        if (!virObjectUnref(vm))
            vm = NULL;
        VIR_FREE(processEvent);
    }

1356
 cleanup:
1357
    if (vm)
1358
        virObjectUnlock(vm);
1359 1360 1361 1362 1363

    return 0;
}


1364
int
1365 1366
qemuProcessHandleDeviceDeleted(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                               virDomainObjPtr vm,
1367 1368
                               const char *devAlias,
                               void *opaque)
1369
{
1370
    virQEMUDriverPtr driver = opaque;
1371 1372
    struct qemuProcessEvent *processEvent = NULL;
    char *data;
1373 1374 1375 1376 1377 1378

    virObjectLock(vm);

    VIR_DEBUG("Device %s removed from domain %p %s",
              devAlias, vm, vm->def->name);

1379 1380
    if (qemuDomainSignalDeviceRemoval(vm, devAlias))
        goto cleanup;
1381

1382 1383
    if (VIR_ALLOC(processEvent) < 0)
        goto error;
1384

1385 1386 1387 1388 1389
    processEvent->eventType = QEMU_PROCESS_EVENT_DEVICE_DELETED;
    if (VIR_STRDUP(data, devAlias) < 0)
        goto error;
    processEvent->data = data;
    processEvent->vm = vm;
1390

1391 1392 1393 1394 1395
    virObjectRef(vm);
    if (virThreadPoolSendJob(driver->workerPool, 0, processEvent) < 0) {
        ignore_value(virObjectUnref(vm));
        goto error;
    }
1396

1397
 cleanup:
1398 1399
    virObjectUnlock(vm);
    return 0;
1400 1401 1402 1403 1404
 error:
    if (processEvent)
        VIR_FREE(processEvent->data);
    VIR_FREE(processEvent);
    goto cleanup;
1405 1406 1407
}


1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
static int
qemuProcessHandleNicRxFilterChanged(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                    virDomainObjPtr vm,
                                    const char *devAlias,
                                    void *opaque)
{
    virQEMUDriverPtr driver = opaque;
    struct qemuProcessEvent *processEvent = NULL;
    char *data;

    virObjectLock(vm);

    VIR_DEBUG("Device %s RX Filter changed in domain %p %s",
              devAlias, vm, vm->def->name);

    if (VIR_ALLOC(processEvent) < 0)
        goto error;

    processEvent->eventType = QEMU_PROCESS_EVENT_NIC_RX_FILTER_CHANGED;
    if (VIR_STRDUP(data, devAlias) < 0)
        goto error;
    processEvent->data = data;
    processEvent->vm = vm;

    virObjectRef(vm);
    if (virThreadPoolSendJob(driver->workerPool, 0, processEvent) < 0) {
        ignore_value(virObjectUnref(vm));
        goto error;
    }

 cleanup:
    virObjectUnlock(vm);
    return 0;
 error:
    if (processEvent)
        VIR_FREE(processEvent->data);
    VIR_FREE(processEvent);
    goto cleanup;
}


1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
static int
qemuProcessHandleSerialChanged(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                               virDomainObjPtr vm,
                               const char *devAlias,
                               bool connected,
                               void *opaque)
{
    virQEMUDriverPtr driver = opaque;
    struct qemuProcessEvent *processEvent = NULL;
    char *data;

    virObjectLock(vm);

    VIR_DEBUG("Serial port %s state changed to '%d' in domain %p %s",
              devAlias, connected, vm, vm->def->name);

    if (VIR_ALLOC(processEvent) < 0)
        goto error;

    processEvent->eventType = QEMU_PROCESS_EVENT_SERIAL_CHANGED;
    if (VIR_STRDUP(data, devAlias) < 0)
        goto error;
    processEvent->data = data;
    processEvent->action = connected;
    processEvent->vm = vm;

    virObjectRef(vm);
    if (virThreadPoolSendJob(driver->workerPool, 0, processEvent) < 0) {
        ignore_value(virObjectUnref(vm));
        goto error;
    }

 cleanup:
    virObjectUnlock(vm);
    return 0;
 error:
    if (processEvent)
        VIR_FREE(processEvent->data);
    VIR_FREE(processEvent);
    goto cleanup;
}


1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
static int
qemuProcessHandleSpiceMigrated(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                               virDomainObjPtr vm,
                               void *opaque ATTRIBUTE_UNUSED)
{
    qemuDomainObjPrivatePtr priv;

    virObjectLock(vm);

    VIR_DEBUG("Spice migration completed for domain %p %s",
              vm, vm->def->name);

    priv = vm->privateData;
    if (priv->job.asyncJob != QEMU_ASYNC_JOB_MIGRATION_OUT) {
        VIR_DEBUG("got SPICE_MIGRATE_COMPLETED event without a migration job");
        goto cleanup;
    }

    priv->job.spiceMigrated = true;
1511
    virDomainObjBroadcast(vm);
1512 1513 1514 1515 1516 1517 1518

 cleanup:
    virObjectUnlock(vm);
    return 0;
}


1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
static int
qemuProcessHandleMigrationStatus(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                                 virDomainObjPtr vm,
                                 int status,
                                 void *opaque ATTRIBUTE_UNUSED)
{
    qemuDomainObjPrivatePtr priv;

    virObjectLock(vm);

    VIR_DEBUG("Migration of domain %p %s changed state to %s",
              vm, vm->def->name,
              qemuMonitorMigrationStatusTypeToString(status));

    priv = vm->privateData;
1534
    if (priv->job.asyncJob == QEMU_ASYNC_JOB_NONE) {
1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547
        VIR_DEBUG("got MIGRATION event without a migration job");
        goto cleanup;
    }

    priv->job.current->status.status = status;
    virDomainObjBroadcast(vm);

 cleanup:
    virObjectUnlock(vm);
    return 0;
}


1548 1549
static qemuMonitorCallbacks monitorCallbacks = {
    .eofNotify = qemuProcessHandleMonitorEOF,
1550
    .errorNotify = qemuProcessHandleMonitorError,
1551
    .diskSecretLookup = qemuProcessFindVolumeQcowPassphrase,
1552
    .domainEvent = qemuProcessHandleEvent,
1553 1554
    .domainShutdown = qemuProcessHandleShutdown,
    .domainStop = qemuProcessHandleStop,
1555
    .domainResume = qemuProcessHandleResume,
1556 1557 1558 1559 1560
    .domainReset = qemuProcessHandleReset,
    .domainRTCChange = qemuProcessHandleRTCChange,
    .domainWatchdog = qemuProcessHandleWatchdog,
    .domainIOError = qemuProcessHandleIOError,
    .domainGraphics = qemuProcessHandleGraphics,
1561
    .domainBlockJob = qemuProcessHandleBlockJob,
1562
    .domainTrayChange = qemuProcessHandleTrayChange,
O
Osier Yang 已提交
1563
    .domainPMWakeup = qemuProcessHandlePMWakeup,
O
Osier Yang 已提交
1564
    .domainPMSuspend = qemuProcessHandlePMSuspend,
1565
    .domainBalloonChange = qemuProcessHandleBalloonChange,
1566
    .domainPMSuspendDisk = qemuProcessHandlePMSuspendDisk,
1567
    .domainGuestPanic = qemuProcessHandleGuestPanic,
1568
    .domainDeviceDeleted = qemuProcessHandleDeviceDeleted,
1569
    .domainNicRxFilterChanged = qemuProcessHandleNicRxFilterChanged,
1570
    .domainSerialChange = qemuProcessHandleSerialChanged,
1571
    .domainSpiceMigrated = qemuProcessHandleSpiceMigrated,
1572
    .domainMigrationStatus = qemuProcessHandleMigrationStatus,
1573 1574 1575
};

static int
1576 1577
qemuConnectMonitor(virQEMUDriverPtr driver, virDomainObjPtr vm, int asyncJob,
                   int logfd)
1578 1579 1580
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int ret = -1;
1581
    qemuMonitorPtr mon = NULL;
1582

1583
    if (virSecurityManagerSetDaemonSocketLabel(driver->securityManager,
1584
                                               vm->def) < 0) {
1585 1586
        VIR_ERROR(_("Failed to set security context for monitor for %s"),
                  vm->def->name);
1587
        return -1;
1588 1589 1590
    }

    /* Hold an extra reference because we can't allow 'vm' to be
M
Michal Privoznik 已提交
1591
     * deleted unitl the monitor gets its own reference. */
1592
    virObjectRef(vm);
1593

1594
    ignore_value(virTimeMillisNow(&priv->monStart));
1595
    virObjectUnlock(vm);
1596 1597 1598 1599

    mon = qemuMonitorOpen(vm,
                          priv->monConfig,
                          priv->monJSON,
1600 1601
                          &monitorCallbacks,
                          driver);
1602

1603 1604 1605
    if (mon)
        ignore_value(qemuMonitorSetDomainLog(mon, logfd));

1606
    virObjectLock(vm);
M
Michal Privoznik 已提交
1607
    virObjectUnref(vm);
1608
    priv->monStart = 0;
1609

M
Michal Privoznik 已提交
1610
    if (!virDomainObjIsActive(vm)) {
1611
        qemuMonitorClose(mon);
1612
        mon = NULL;
1613 1614 1615
    }
    priv->mon = mon;

1616
    if (virSecurityManagerClearSocketLabel(driver->securityManager, vm->def) < 0) {
1617 1618
        VIR_ERROR(_("Failed to clear security context for monitor for %s"),
                  vm->def->name);
1619
        return -1;
1620 1621 1622 1623
    }

    if (priv->mon == NULL) {
        VIR_INFO("Failed to connect monitor for %s", vm->def->name);
1624
        return -1;
1625 1626 1627
    }


1628
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
1629
        return -1;
1630

1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
    if (qemuMonitorSetCapabilities(priv->mon) < 0)
        goto cleanup;

    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON) &&
        virQEMUCapsProbeQMP(priv->qemuCaps, priv->mon) < 0)
        goto cleanup;

    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT) &&
        qemuMonitorSetMigrationCapability(priv->mon,
                                          QEMU_MONITOR_MIGRATION_CAPS_EVENTS,
                                          true) < 0) {
        VIR_DEBUG("Cannot enable migration events; clearing capability");
        virQEMUCapsClear(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT);
    }
1645

1646 1647 1648 1649 1650
    ret = 0;

 cleanup:
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        ret = -1;
1651 1652 1653
    return ret;
}

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667

/**
 * qemuProcessReadLog: Read log file of a qemu VM
 * @fd: File descriptor of the log file
 * @buf: buffer to store the read messages
 * @buflen: allocated space available in @buf
 * @off: Offset to start reading from
 * @skipchar: Skip messages about created character devices
 *
 * Reads log of a qemu VM. Skips messages not produced by qemu or irrelevant
 * messages. Returns length of the message stored in @buf, or -1 on error.
 */
int
qemuProcessReadLog(int fd, char *buf, int buflen, int off, bool skipchar)
1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
{
    char *filter_next = buf;
    ssize_t bytes;
    char *eol;

    while (off < buflen - 1) {
        bytes = saferead(fd, buf + off, buflen - off - 1);
        if (bytes < 0)
            return -1;

        off += bytes;
        buf[off] = '\0';

1681 1682 1683
        if (bytes == 0)
            break;

1684 1685 1686
        /* Filter out debug messages from intermediate libvirt process */
        while ((eol = strchr(filter_next, '\n'))) {
            *eol = '\0';
1687 1688 1689
            if (virLogProbablyLogMessage(filter_next) ||
                (skipchar &&
                 STRPREFIX(filter_next, "char device redirected to"))) {
1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
                memmove(filter_next, eol + 1, off - (eol - buf));
                off -= eol + 1 - filter_next;
            } else {
                filter_next = eol + 1;
                *eol = '\n';
            }
        }
    }

    return off;
}

1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
typedef int qemuProcessLogHandleOutput(virDomainObjPtr vm,
                                       const char *output,
                                       int fd);

/*
 * Returns -1 for error, 0 on success
 */
static int
qemuProcessReadLogOutput(virDomainObjPtr vm,
                         int fd,
                         char *buf,
                         size_t buflen,
                         qemuProcessLogHandleOutput func,
                         const char *what,
                         int timeout)
{
    int retries = (timeout*10);
    int got = 0;
1720 1721
    int ret = -1;

1722 1723 1724
    buf[0] = '\0';

    while (retries) {
1725
        ssize_t func_ret;
1726
        bool isdead;
1727 1728 1729

        func_ret = func(vm, buf, fd);

1730
        isdead = kill(vm->pid, 0) == -1 && errno == ESRCH;
1731

1732
        got = qemuProcessReadLog(fd, buf, buflen, got, false);
1733
        if (got < 0) {
1734 1735 1736
            virReportSystemError(errno,
                                 _("Failure while reading %s log output"),
                                 what);
1737
            goto cleanup;
1738 1739 1740
        }

        if (got == buflen-1) {
1741 1742 1743
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Out of space while reading %s log output: %s"),
                           what, buf);
1744
            goto cleanup;
1745 1746 1747
        }

        if (isdead) {
1748 1749 1750
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Process exited while reading %s log output: %s"),
                           what, buf);
1751
            goto cleanup;
1752 1753
        }

1754 1755 1756 1757
        if (func_ret <= 0) {
            ret = func_ret;
            goto cleanup;
        }
1758 1759 1760 1761 1762

        usleep(100*1000);
        retries--;
    }

1763 1764 1765
    virReportError(VIR_ERR_INTERNAL_ERROR,
                   _("Timed out while reading %s log output: %s"),
                   what, buf);
1766

1767
 cleanup:
1768
    return ret;
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
/*
 * Read domain log and probably overwrite error if there's one in
 * the domain log file. This function exists to cover the small
 * window between fork() and exec() during which child may fail
 * by libvirt's hand, e.g. placing onto a NUMA node failed.
 */
static int
qemuProcessReadChildErrors(virQEMUDriverPtr driver,
                           virDomainObjPtr vm,
                           off_t originalOff)
{
    int ret = -1;
    int logfd;
    off_t off = 0;
    ssize_t bytes;
    char buf[1024] = {0};
    char *eol, *filter_next = buf;

    if ((logfd = qemuDomainOpenLog(driver, vm, originalOff)) < 0)
        goto cleanup;

    while (off < sizeof(buf) - 1) {
        bytes = saferead(logfd, buf + off, sizeof(buf) - off - 1);
        if (bytes < 0) {
            VIR_WARN("unable to read from log file: %s",
                     virStrerror(errno, buf, sizeof(buf)));
            goto cleanup;
        }

        off += bytes;
        buf[off] = '\0';

        if (bytes == 0)
            break;

        while ((eol = strchr(filter_next, '\n'))) {
            *eol = '\0';
            if (STRPREFIX(filter_next, "libvirt: ")) {
                filter_next = eol + 1;
                *eol = '\n';
                break;
            } else {
                memmove(filter_next, eol + 1, off - (eol - buf));
                off -= eol + 1 - filter_next;
            }
        }
    }

    if (off > 0) {
        /* Found an error in the log. Report it */
        virResetLastError();
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Process exited prior to exec: %s"),
                       buf);
    }

    ret = 0;

1830
 cleanup:
1831 1832 1833 1834 1835
    VIR_FORCE_CLOSE(logfd);
    return ret;
}


1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
/*
 * 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
 */
static int
qemuProcessExtractTTYPath(const char *haystack,
                          size_t *offset,
                          char **path)
{
1849 1850
    static const char needle[] = "char device redirected to";
    char *tmp, *dev;
1851 1852 1853

    VIR_FREE(*path);
    /* First look for our magic string */
1854
    if (!(tmp = strstr(haystack + *offset, needle)))
1855
        return 1;
1856
    tmp += sizeof(needle);
1857 1858 1859 1860 1861 1862 1863 1864
    dev = tmp;

    /*
     * And look for first whitespace character and nul terminate
     * to mark end of the pty path
     */
    while (*tmp) {
        if (c_isspace(*tmp)) {
1865
            if (VIR_STRNDUP(*path, dev, tmp - dev) < 0)
1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883
                return -1;

            /* ... now further update offset till we get EOL */
            *offset = tmp - haystack;
            return 0;
        }
        tmp++;
    }

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

1884
static int
1885 1886 1887
qemuProcessLookupPTYs(virDomainDefPtr def,
                      virQEMUCapsPtr qemuCaps,
                      virDomainChrDefPtr *devices,
1888
                      int count,
1889
                      virHashTablePtr info)
1890
{
1891
    size_t i;
1892

1893
    for (i = 0; i < count; i++) {
1894
        virDomainChrDefPtr chr = devices[i];
1895 1896
        bool chardevfmt = virQEMUCapsSupportsChardev(def, qemuCaps, chr);

1897
        if (chr->source.type == VIR_DOMAIN_CHR_TYPE_PTY) {
C
Cole Robinson 已提交
1898
            char id[32];
1899
            qemuMonitorChardevInfoPtr entry;
1900

C
Cole Robinson 已提交
1901
            if (snprintf(id, sizeof(id), "%s%s",
1902
                         chardevfmt ? "char" : "",
1903 1904 1905 1906
                         chr->info.alias) >= sizeof(id)) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("failed to format device alias "
                                 "for PTY retrieval"));
1907
                return -1;
1908
            }
1909

1910 1911
            entry = virHashLookup(info, id);
            if (!entry || !entry->ptyPath) {
1912 1913 1914 1915
                if (chr->source.data.file.path == NULL) {
                    /* neither the log output nor 'info chardev' had a
                     * pty path for this chardev, report an error
                     */
1916 1917
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("no assigned pty for device %s"), id);
1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
                    return -1;
                } else {
                    /* 'info chardev' had no pty path for this chardev,
                     * but the log output had, so we're fine
                     */
                    continue;
                }
            }

            VIR_FREE(chr->source.data.file.path);
1928
            if (VIR_STRDUP(chr->source.data.file.path, entry->ptyPath) < 0)
1929 1930 1931 1932 1933 1934 1935
                return -1;
        }
    }

    return 0;
}

1936 1937
static int
qemuProcessFindCharDevicePTYsMonitor(virDomainObjPtr vm,
1938
                                     virQEMUCapsPtr qemuCaps,
1939
                                     virHashTablePtr info)
1940
{
1941
    size_t i = 0;
C
Cole Robinson 已提交
1942

1943 1944
    if (qemuProcessLookupPTYs(vm->def, qemuCaps,
                              vm->def->serials, vm->def->nserials,
1945
                              info) < 0)
1946 1947
        return -1;

1948 1949
    if (qemuProcessLookupPTYs(vm->def, qemuCaps,
                              vm->def->parallels, vm->def->nparallels,
1950
                              info) < 0)
1951
        return -1;
1952

1953 1954
    if (qemuProcessLookupPTYs(vm->def, qemuCaps,
                              vm->def->channels, vm->def->nchannels,
1955
                              info) < 0)
1956
        return -1;
1957 1958 1959 1960
    /* For historical reasons, console[0] can be just an alias
     * for serial[0]. That's why we need to update it as well. */
    if (vm->def->nconsoles) {
        virDomainChrDefPtr chr = vm->def->consoles[0];
1961

1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972
        if (vm->def->nserials &&
            chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
            chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL) {
            /* yes, the first console is just an alias for serials[0] */
            i = 1;
            if (virDomainChrSourceDefCopy(&chr->source,
                                          &((vm->def->serials[0])->source)) < 0)
                return -1;
        }
    }

1973 1974
    if (qemuProcessLookupPTYs(vm->def, qemuCaps,
                              vm->def->consoles + i, vm->def->nconsoles - i,
1975
                              info) < 0)
1976
        return -1;
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986

    return 0;
}

static int
qemuProcessFindCharDevicePTYs(virDomainObjPtr vm,
                              const char *output,
                              int fd ATTRIBUTE_UNUSED)
{
    size_t offset = 0;
1987 1988
    int ret;
    size_t i;
1989 1990 1991 1992 1993 1994

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

    /* first comes the serial devices */
1995
    for (i = 0; i < vm->def->nserials; i++) {
1996 1997 1998 1999 2000 2001 2002 2003 2004
        virDomainChrDefPtr chr = vm->def->serials[i];
        if (chr->source.type == VIR_DOMAIN_CHR_TYPE_PTY) {
            if ((ret = qemuProcessExtractTTYPath(output, &offset,
                                                 &chr->source.data.file.path)) != 0)
                return ret;
        }
    }

    /* then the parallel devices */
2005
    for (i = 0; i < vm->def->nparallels; i++) {
2006 2007 2008 2009 2010 2011 2012 2013 2014
        virDomainChrDefPtr chr = vm->def->parallels[i];
        if (chr->source.type == VIR_DOMAIN_CHR_TYPE_PTY) {
            if ((ret = qemuProcessExtractTTYPath(output, &offset,
                                                 &chr->source.data.file.path)) != 0)
                return ret;
        }
    }

    /* then the channel devices */
2015
    for (i = 0; i < vm->def->nchannels; i++) {
2016 2017 2018 2019 2020 2021 2022 2023
        virDomainChrDefPtr chr = vm->def->channels[i];
        if (chr->source.type == VIR_DOMAIN_CHR_TYPE_PTY) {
            if ((ret = qemuProcessExtractTTYPath(output, &offset,
                                                 &chr->source.data.file.path)) != 0)
                return ret;
        }
    }

2024
    for (i = 0; i < vm->def->nconsoles; i++) {
2025
        virDomainChrDefPtr chr = vm->def->consoles[i];
2026 2027 2028 2029 2030 2031 2032
        /* For historical reasons, console[0] can be just an alias
         * for serial[0]; That's why we need to update it as well */
        if (i == 0 && vm->def->nserials &&
            chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
            chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL) {
            if ((ret = virDomainChrSourceDefCopy(&chr->source,
                                                 &((vm->def->serials[0])->source))) != 0)
2033
                return ret;
2034 2035 2036 2037 2038 2039 2040
        } else {
            if (chr->source.type == VIR_DOMAIN_CHR_TYPE_PTY &&
                chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO) {
                if ((ret = qemuProcessExtractTTYPath(output, &offset,
                                                     &chr->source.data.file.path)) != 0)
                    return ret;
            }
2041 2042 2043
        }
    }

2044 2045 2046 2047
    return 0;
}


2048
static int
2049 2050 2051 2052
qemuProcessRefreshChannelVirtioState(virQEMUDriverPtr driver,
                                     virDomainObjPtr vm,
                                     virHashTablePtr info,
                                     int booted)
2053 2054
{
    size_t i;
2055
    int agentReason = VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL;
2056
    qemuMonitorChardevInfoPtr entry;
2057
    virObjectEventPtr event = NULL;
2058 2059
    char id[32];

2060 2061 2062
    if (booted)
        agentReason = VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED;

2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078
    for (i = 0; i < vm->def->nchannels; i++) {
        virDomainChrDefPtr chr = vm->def->channels[i];
        if (chr->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO) {
            if (snprintf(id, sizeof(id), "char%s",
                         chr->info.alias) >= sizeof(id)) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("failed to format device alias "
                                 "for PTY retrieval"));
                return -1;
            }

            /* port state not reported */
            if (!(entry = virHashLookup(info, id)) ||
                !entry->state)
                continue;

2079 2080 2081 2082 2083 2084
            if (entry->state != VIR_DOMAIN_CHR_DEVICE_STATE_DEFAULT &&
                STREQ_NULLABLE(chr->target.name, "org.qemu.guest_agent.0") &&
                (event = virDomainEventAgentLifecycleNewFromObj(vm, entry->state,
                                                                agentReason)))
                qemuDomainEventQueue(driver, event);

2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
            chr->state = entry->state;
        }
    }

    return 0;
}


static int
qemuProcessReconnectRefreshChannelVirtioState(virQEMUDriverPtr driver,
                                              virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virHashTablePtr info = NULL;
    int ret = -1;

    qemuDomainObjEnterMonitor(driver, vm);
    ret = qemuMonitorGetChardevInfo(priv->mon, &info);
2103 2104
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        ret = -1;
2105 2106 2107 2108

    if (ret < 0)
        goto cleanup;

2109
    ret = qemuProcessRefreshChannelVirtioState(driver, vm, info, false);
2110 2111 2112 2113 2114 2115 2116

 cleanup:
    virHashFree(info);
    return ret;
}


2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
static int
qemuProcessRefreshBalloonState(virQEMUDriverPtr driver,
                               virDomainObjPtr vm,
                               int asyncJob)
{
    unsigned long long balloon;
    int rc;

    /* if no ballooning is available, the current size equals to the current
     * full memory size */
    if (!vm->def->memballoon ||
        vm->def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_NONE) {
        vm->def->mem.cur_balloon = virDomainDefGetMemoryActual(vm->def);
        return 0;
    }

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

    rc = qemuMonitorGetBalloonInfo(qemuDomainGetMonitor(vm), &balloon);
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        rc = -1;

    if (rc < 0)
        return -1;

    vm->def->mem.cur_balloon = balloon;

    return 0;
}


2149
static int
2150
qemuProcessWaitForMonitor(virQEMUDriverPtr driver,
C
Cole Robinson 已提交
2151
                          virDomainObjPtr vm,
2152
                          int asyncJob,
2153
                          virQEMUCapsPtr qemuCaps,
C
Cole Robinson 已提交
2154
                          off_t pos)
2155
{
2156
    char *buf = NULL;
2157
    size_t buf_size = 4096; /* Plenty of space to get startup greeting */
2158
    int logfd = -1;
2159
    int ret = -1;
2160
    virHashTablePtr info = NULL;
2161
    qemuDomainObjPrivatePtr priv;
2162

2163 2164 2165
    if (pos != -1 &&
        (logfd = qemuDomainOpenLog(driver, vm, pos)) < 0)
        return -1;
2166

2167
    if (logfd != -1 && !virQEMUCapsUsedQMP(qemuCaps)) {
2168
        if (VIR_ALLOC_N(buf, buf_size) < 0)
2169
            goto closelog;
2170

2171 2172 2173 2174 2175
        if (qemuProcessReadLogOutput(vm, logfd, buf, buf_size,
                                     qemuProcessFindCharDevicePTYs,
                                     "console", 30) < 0)
            goto closelog;
    }
2176 2177

    VIR_DEBUG("Connect monitor to %p '%s'", vm, vm->def->name);
2178
    if (qemuConnectMonitor(driver, vm, asyncJob, logfd) < 0)
2179 2180 2181 2182 2183 2184
        goto cleanup;

    /* 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. */
2185
    priv = vm->privateData;
2186 2187
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        goto cleanup;
2188 2189
    ret = qemuMonitorGetChardevInfo(priv->mon, &info);
    VIR_DEBUG("qemuMonitorGetChardevInfo returned %i", ret);
2190 2191 2192
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        ret = -1;

2193 2194 2195 2196 2197
    if (ret == 0) {
        if ((ret = qemuProcessFindCharDevicePTYsMonitor(vm, qemuCaps,
                                                        info)) < 0)
            goto cleanup;

2198 2199
        if ((ret = qemuProcessRefreshChannelVirtioState(driver, vm, info,
                                                        true)) < 0)
2200 2201
            goto cleanup;
    }
2202

2203
 cleanup:
2204
    virHashFree(info);
2205

E
Eric Blake 已提交
2206
    if (pos != -1 && kill(vm->pid, 0) == -1 && errno == ESRCH) {
2207
        int len;
2208 2209
        /* VM is dead, any other error raised in the interim is probably
         * not as important as the qemu cmdline output */
2210
        if (virQEMUCapsUsedQMP(qemuCaps)) {
2211
            if (VIR_ALLOC_N(buf, buf_size) < 0)
2212 2213
                goto closelog;
        }
2214 2215

        len = strlen(buf);
2216
        /* best effort seek - we need to reset to the original position, so that
2217 2218
         * a possible read of the fd in the monitor code doesn't influence this
         * error delivery option */
2219
        ignore_value(lseek(logfd, pos, SEEK_SET));
2220
        qemuProcessReadLog(logfd, buf + len, buf_size - len - 1, 0, true);
2221 2222 2223
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("process exited while connecting to monitor: %s"),
                       buf);
2224 2225 2226
        ret = -1;
    }

2227
 closelog:
2228
    if (VIR_CLOSE(logfd) < 0) {
2229
        char ebuf[1024];
2230
        VIR_WARN("Unable to close logfile: %s",
2231
                 virStrerror(errno, ebuf, sizeof(ebuf)));
2232 2233
    }

2234 2235
    VIR_FREE(buf);

2236 2237 2238 2239
    return ret;
}

static int
2240
qemuProcessDetectVcpuPIDs(virQEMUDriverPtr driver,
2241
                          virDomainObjPtr vm, int asyncJob)
2242 2243 2244 2245 2246
{
    pid_t *cpupids = NULL;
    int ncpupids;
    qemuDomainObjPrivatePtr priv = vm->privateData;

2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280
    /*
     * Current QEMU *can* report info about host threads mapped
     * to vCPUs, but it is not in a manner we can correctly
     * deal with. The TCG CPU emulation does have a separate vCPU
     * thread, but it runs every vCPU in that same thread. So it
     * is impossible to setup different affinity per thread.
     *
     * What's more the 'query-cpus' command returns bizarre
     * data for the threads. It gives the TCG thread for the
     * vCPU 0, but for vCPUs 1-> N, it actually replies with
     * the main process thread ID.
     *
     * The result is that when we try to set affinity for
     * vCPU 1, it will actually change the affinity of the
     * emulator thread :-( When you try to set affinity for
     * vCPUs 2, 3.... it will fail if the affinity was
     * different from vCPU 1.
     *
     * We *could* allow vcpu pinning with TCG, if we made the
     * restriction that all vCPUs had the same mask. This would
     * at least let us separate emulator from vCPUs threads, as
     * we do for KVM. It would need some changes to our cgroups
     * CPU layout though, and error reporting for the config
     * restrictions.
     *
     * Just disable CPU pinning with TCG until someone wants
     * to try to do this hard work.
     */
    if (vm->def->virtType == VIR_DOMAIN_VIRT_QEMU) {
        priv->nvcpupids = 0;
        priv->vcpupids = NULL;
        return 0;
    }

2281 2282
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;
2283 2284 2285
    ncpupids = qemuMonitorGetCPUInfo(priv->mon, &cpupids);
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
2286 2287 2288
    /* failure to get the VCPU<-> PID mapping or to execute the query
     * command will not be treated fatal as some versions of qemu don't
     * support this command */
2289
    if (ncpupids <= 0) {
2290 2291
        virResetLastError();

2292 2293
        priv->nvcpupids = 0;
        priv->vcpupids = NULL;
2294 2295 2296 2297
        return 0;
    }

    if (ncpupids != vm->def->vcpus) {
2298 2299 2300 2301
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("got wrong number of vCPU pids from QEMU monitor. "
                         "got %d, wanted %d"),
                       ncpupids, vm->def->vcpus);
2302 2303 2304 2305 2306 2307 2308 2309 2310
        VIR_FREE(cpupids);
        return -1;
    }

    priv->nvcpupids = ncpupids;
    priv->vcpupids = cpupids;
    return 0;
}

2311

2312 2313 2314 2315 2316 2317
static int
qemuProcessDetectIOThreadPIDs(virQEMUDriverPtr driver,
                              virDomainObjPtr vm,
                              int asyncJob)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
2318
    qemuMonitorIOThreadInfoPtr *iothreads = NULL;
2319 2320 2321 2322
    int niothreads = 0;
    int ret = -1;
    size_t i;

2323 2324 2325
    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_IOTHREAD))
        return 0;

2326 2327 2328 2329
    /* Get the list of IOThreads from qemu */
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        goto cleanup;
    niothreads = qemuMonitorGetIOThreads(priv->mon, &iothreads);
2330 2331
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
J
John Ferlan 已提交
2332
    if (niothreads < 0)
2333 2334 2335 2336 2337 2338 2339 2340 2341 2342
        goto cleanup;

    if (niothreads != vm->def->iothreads) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("got wrong number of IOThread pids from QEMU monitor. "
                         "got %d, wanted %d"),
                       niothreads, vm->def->iothreads);
        goto cleanup;
    }

2343 2344 2345 2346 2347 2348
    /* Nothing to do */
    if (niothreads == 0) {
        ret = 0;
        goto cleanup;
    }

2349 2350 2351
    for (i = 0; i < niothreads; i++) {
        virDomainIOThreadIDDefPtr iothrid;

2352 2353
        if (!(iothrid = virDomainIOThreadIDFind(vm->def,
                                                iothreads[i]->iothread_id))) {
2354
            virReportError(VIR_ERR_INTERNAL_ERROR,
2355 2356
                           _("iothread %d not found"),
                           iothreads[i]->iothread_id);
2357 2358 2359 2360
            goto cleanup;
        }
        iothrid->thread_id = iothreads[i]->thread_id;
    }
2361 2362 2363 2364 2365 2366

    ret = 0;

 cleanup:
    if (iothreads) {
        for (i = 0; i < niothreads; i++)
2367
            VIR_FREE(iothreads[i]);
2368 2369 2370 2371 2372
        VIR_FREE(iothreads);
    }
    return ret;
}

2373 2374 2375 2376 2377

/*
 * To be run between fork/exec of QEMU only
 */
static int
2378
qemuProcessInitCpuAffinity(virDomainObjPtr vm)
2379 2380 2381 2382
{
    int ret = -1;
    virBitmapPtr cpumap = NULL;
    virBitmapPtr cpumapToSet = NULL;
2383
    qemuDomainObjPrivatePtr priv = vm->privateData;
2384

2385 2386 2387 2388 2389 2390
    if (!vm->pid) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Cannot setup CPU affinity until process is started"));
        return -1;
    }

2391 2392
    if (vm->def->placement_mode == VIR_DOMAIN_CPU_PLACEMENT_MODE_AUTO) {
        VIR_DEBUG("Set CPU affinity with advisory nodeset from numad");
2393
        cpumapToSet = priv->autoCpuset;
2394
    } else {
2395
        VIR_DEBUG("Set CPU affinity with specified cpuset");
O
Osier Yang 已提交
2396
        if (vm->def->cpumask) {
H
Hu Tao 已提交
2397
            cpumapToSet = vm->def->cpumask;
O
Osier Yang 已提交
2398 2399 2400 2401 2402
        } else {
            /* 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 */
2403 2404 2405 2406
            int hostcpus;

            /* setaffinity fails if you set bits for CPUs which
             * aren't present, so we have to limit ourselves */
2407
            if ((hostcpus = nodeGetCPUCount(NULL)) < 0)
2408 2409 2410 2411 2412 2413 2414 2415
                goto cleanup;

            if (hostcpus > QEMUD_CPUMASK_LEN)
                hostcpus = QEMUD_CPUMASK_LEN;

            if (!(cpumap = virBitmapNew(hostcpus)))
                goto cleanup;

2416
            virBitmapSetAll(cpumap);
2417 2418

            cpumapToSet = cpumap;
O
Osier Yang 已提交
2419
        }
2420 2421
    }

2422
    if (virProcessSetAffinity(vm->pid, cpumapToSet) < 0)
2423
        goto cleanup;
2424

2425 2426
    ret = 0;

2427
 cleanup:
2428
    virBitmapFree(cpumap);
2429
    return ret;
2430 2431
}

2432 2433 2434 2435 2436 2437
/* set link states to down on interfaces at qemu start */
static int
qemuProcessSetLinkStates(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainDefPtr def = vm->def;
2438
    size_t i;
2439 2440 2441 2442
    int ret = 0;

    for (i = 0; i < def->nnets; i++) {
        if (def->nets[i]->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) {
2443 2444 2445 2446 2447 2448
            if (!def->nets[i]->info.alias) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing alias for network device"));
                return -1;
            }

2449 2450
            VIR_DEBUG("Setting link state: %s", def->nets[i]->info.alias);

2451
            if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
2452
                virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
2453
                               _("Setting of link state is not supported by this qemu"));
2454 2455 2456 2457 2458 2459 2460
                return -1;
            }

            ret = qemuMonitorSetLink(priv->mon,
                                     def->nets[i]->info.alias,
                                     VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN);
            if (ret != 0) {
2461
                virReportError(VIR_ERR_OPERATION_FAILED,
2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
                               _("Couldn't set link state on interface: %s"), def->nets[i]->info.alias);
                break;
            }
        }
    }

    return ret;
}

/* Set CPU affinities for vcpus if vcpupin xml provided. */
2472
static int
2473
qemuProcessSetVcpuAffinities(virDomainObjPtr vm)
2474 2475 2476
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainDefPtr def = vm->def;
2477
    virDomainPinDefPtr pininfo;
2478
    int n;
E
Eric Blake 已提交
2479
    int ret = -1;
2480 2481
    VIR_DEBUG("Setting affinity on CPUs nvcpupin=%zu nvcpus=%d nvcpupids=%d",
              def->cputune.nvcpupin, def->vcpus, priv->nvcpupids);
2482 2483 2484 2485
    if (!def->cputune.nvcpupin)
        return 0;

    if (priv->vcpupids == NULL) {
2486 2487 2488
        /* If any CPU has custom affinity that differs from the
         * VM default affinity, we must reject it
         */
2489
        for (n = 0; n < def->cputune.nvcpupin; n++) {
2490 2491 2492 2493 2494 2495 2496 2497
            if (!virBitmapEqual(def->cpumask,
                                def->cputune.vcpupin[n]->cpumask)) {
                virReportError(VIR_ERR_OPERATION_INVALID,
                               "%s", _("cpu affinity is not supported"));
                return -1;
            }
        }
        return 0;
2498 2499
    }

2500 2501
    for (n = 0; n < def->vcpus; n++) {
        /* set affinity only for existing vcpus */
2502 2503 2504
        if (!(pininfo = virDomainPinFind(def->cputune.vcpupin,
                                         def->cputune.nvcpupin,
                                         n)))
2505
            continue;
2506

2507 2508
        if (virProcessSetAffinity(priv->vcpupids[n],
                                  pininfo->cpumask) < 0) {
E
Eric Blake 已提交
2509
            goto cleanup;
2510 2511 2512
        }
    }

E
Eric Blake 已提交
2513
    ret = 0;
2514
 cleanup:
E
Eric Blake 已提交
2515
    return ret;
2516
}
2517

2518
/* Set CPU affinities for emulator threads. */
2519
static int
2520
qemuProcessSetEmulatorAffinity(virDomainObjPtr vm)
2521
{
2522
    virBitmapPtr cpumask;
2523 2524 2525
    virDomainDefPtr def = vm->def;
    int ret = -1;

O
Osier Yang 已提交
2526
    if (def->cputune.emulatorpin)
2527
        cpumask = def->cputune.emulatorpin;
O
Osier Yang 已提交
2528
    else if (def->cpumask)
2529
        cpumask = def->cpumask;
O
Osier Yang 已提交
2530 2531
    else
        return 0;
2532

2533
    ret = virProcessSetAffinity(vm->pid, cpumask);
2534 2535 2536
    return ret;
}

2537 2538 2539 2540 2541 2542 2543 2544
/* Set CPU affinities for IOThreads threads. */
static int
qemuProcessSetIOThreadsAffinity(virDomainObjPtr vm)
{
    virDomainDefPtr def = vm->def;
    size_t i;
    int ret = -1;

2545 2546
    for (i = 0; i < def->niothreadids; i++) {
        /* set affinity only for existing iothreads */
2547
        if (!def->iothreadids[i]->cpumask)
2548 2549
            continue;

2550
        if (virProcessSetAffinity(def->iothreadids[i]->thread_id,
2551
                                  def->iothreadids[i]->cpumask) < 0)
2552 2553 2554 2555 2556 2557 2558 2559
            goto cleanup;
    }
    ret = 0;

 cleanup:
    return ret;
}

2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
/* Set Scheduler parameters for vCPU or I/O threads. */
int
qemuProcessSetSchedParams(int id,
                          pid_t pid,
                          size_t nsp,
                          virDomainThreadSchedParamPtr sp)
{
    bool val = false;
    size_t i = 0;
    virDomainThreadSchedParamPtr s = NULL;

    for (i = 0; i < nsp; i++) {
        if (virBitmapGetBit(sp[i].ids, id, &val) < 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Cannot get bit from bitmap"));
        }
        if (val) {
            s = &sp[i];
            break;
        }
    }

    if (!s)
        return 0;

2585
    return virProcessSetScheduler(pid, s->policy, s->priority);
2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600
}

static int
qemuProcessSetSchedulers(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    size_t i = 0;

    for (i = 0; i < priv->nvcpupids; i++) {
        if (qemuProcessSetSchedParams(i, priv->vcpupids[i],
                                      vm->def->cputune.nvcpusched,
                                      vm->def->cputune.vcpusched) < 0)
            return -1;
    }

2601 2602 2603
    for (i = 0; i < vm->def->niothreadids; i++) {
        if (qemuProcessSetSchedParams(vm->def->iothreadids[i]->iothread_id,
                                      vm->def->iothreadids[i]->thread_id,
2604 2605 2606 2607 2608 2609 2610 2611
                                      vm->def->cputune.niothreadsched,
                                      vm->def->cputune.iothreadsched) < 0)
            return -1;
    }

    return 0;
}

2612 2613
static int
qemuProcessInitPasswords(virConnectPtr conn,
2614
                         virQEMUDriverPtr driver,
2615 2616
                         virDomainObjPtr vm,
                         int asyncJob)
2617 2618 2619
{
    int ret = 0;
    qemuDomainObjPrivatePtr priv = vm->privateData;
2620
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2621
    size_t i;
2622 2623
    char *alias = NULL;
    char *secret = NULL;
2624

2625
    for (i = 0; i < vm->def->ngraphics; ++i) {
2626 2627
        virDomainGraphicsDefPtr graphics = vm->def->graphics[i];
        if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
2628 2629
            ret = qemuDomainChangeGraphicsPasswords(driver, vm,
                                                    VIR_DOMAIN_GRAPHICS_TYPE_VNC,
2630
                                                    &graphics->data.vnc.auth,
2631 2632
                                                    cfg->vncPassword,
                                                    asyncJob);
2633
        } else if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
2634 2635
            ret = qemuDomainChangeGraphicsPasswords(driver, vm,
                                                    VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
2636
                                                    &graphics->data.spice.auth,
2637 2638
                                                    cfg->spicePassword,
                                                    asyncJob);
2639 2640
        }

2641 2642 2643
        if (ret < 0)
            goto cleanup;
    }
2644

2645
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
2646
        for (i = 0; i < vm->def->ndisks; i++) {
2647 2648
            size_t secretLen;

2649
            if (!vm->def->disks[i]->src->encryption ||
2650
                !virDomainDiskGetSource(vm->def->disks[i]))
2651 2652
                continue;

2653
            VIR_FREE(secret);
2654 2655 2656 2657 2658
            if (qemuProcessGetVolumeQcowPassphrase(conn,
                                                   vm->def->disks[i],
                                                   &secret, &secretLen) < 0)
                goto cleanup;

2659 2660 2661 2662
            VIR_FREE(alias);
            if (VIR_STRDUP(alias, vm->def->disks[i]->info.alias) < 0)
                goto cleanup;
            if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
2663
                goto cleanup;
E
Eric Blake 已提交
2664
            ret = qemuMonitorSetDrivePassphrase(priv->mon, alias, secret);
2665 2666
            if (qemuDomainObjExitMonitor(driver, vm) < 0)
                ret = -1;
2667 2668 2669 2670 2671
            if (ret < 0)
                goto cleanup;
        }
    }

2672
 cleanup:
2673 2674
    VIR_FREE(alias);
    VIR_FREE(secret);
2675
    virObjectUnref(cfg);
2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718
    return ret;
}


#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_BALLOON_VIRTIO 0x1002

#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
qemuProcessAssignNextPCIAddress(virDomainDeviceInfo *info,
                                int vendor,
                                int product,
                                qemuMonitorPCIAddress *addrs,
                                int naddrs)
{
2719
    bool found = false;
2720
    size_t i;
2721 2722 2723

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

2724
    for (i = 0; i < naddrs; i++) {
2725 2726 2727
        VIR_DEBUG("Maybe %x:%x", addrs[i].vendor, addrs[i].product);
        if (addrs[i].vendor == vendor &&
            addrs[i].product == product) {
2728
            VIR_DEBUG("Match %zu", i);
2729
            found = true;
2730 2731 2732
            break;
        }
    }
2733
    if (!found)
2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933
        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
qemuProcessGetPCIDiskVendorProduct(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
qemuProcessGetPCINetVendorProduct(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
qemuProcessGetPCIControllerVendorProduct(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
qemuProcessGetPCIVideoVendorProduct(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
qemuProcessGetPCISoundVendorProduct(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
qemuProcessGetPCIWatchdogVendorProduct(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;
}


static int
qemuProcessGetPCIMemballoonVendorProduct(virDomainMemballoonDefPtr def,
                                         unsigned *vendor,
                                         unsigned *product)
{
    switch (def->model) {
    case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO:
        *vendor = QEMU_PCI_VENDOR_REDHAT;
        *product = QEMU_PCI_PRODUCT_BALLOON_VIRTIO;
        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
qemuProcessDetectPCIAddresses(virDomainObjPtr vm,
                              qemuMonitorPCIAddress *addrs,
                              int naddrs)
{
    unsigned int vendor = 0, product = 0;
2934
    size_t i;
2935 2936 2937 2938 2939

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

2940
    for (i = 0; i < vm->def->ndisks; i++) {
2941 2942 2943 2944 2945 2946
        if (qemuProcessGetPCIDiskVendorProduct(vm->def->disks[i], &vendor, &product) < 0)
            continue;

        if (qemuProcessAssignNextPCIAddress(&(vm->def->disks[i]->info),
                                            vendor, product,
                                            addrs, naddrs) < 0) {
2947 2948 2949
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot find PCI address for VirtIO disk %s"),
                           vm->def->disks[i]->dst);
2950 2951 2952 2953
            return -1;
        }
    }

2954
    for (i = 0; i < vm->def->nnets; i++) {
2955 2956 2957 2958 2959 2960
        if (qemuProcessGetPCINetVendorProduct(vm->def->nets[i], &vendor, &product) < 0)
            continue;

        if (qemuProcessAssignNextPCIAddress(&(vm->def->nets[i]->info),
                                            vendor, product,
                                            addrs,  naddrs) < 0) {
2961 2962 2963
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot find PCI address for %s NIC"),
                           vm->def->nets[i]->model);
2964 2965 2966 2967
            return -1;
        }
    }

2968
    for (i = 0; i < vm->def->ncontrollers; i++) {
2969 2970 2971 2972 2973 2974
        if (qemuProcessGetPCIControllerVendorProduct(vm->def->controllers[i], &vendor, &product) < 0)
            continue;

        if (qemuProcessAssignNextPCIAddress(&(vm->def->controllers[i]->info),
                                            vendor, product,
                                            addrs,  naddrs) < 0) {
2975 2976 2977
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot find PCI address for controller %s"),
                           virDomainControllerTypeToString(vm->def->controllers[i]->type));
2978 2979 2980 2981
            return -1;
        }
    }

2982
    for (i = 0; i < vm->def->nvideos; i++) {
2983 2984 2985 2986 2987 2988
        if (qemuProcessGetPCIVideoVendorProduct(vm->def->videos[i], &vendor, &product) < 0)
            continue;

        if (qemuProcessAssignNextPCIAddress(&(vm->def->videos[i]->info),
                                            vendor, product,
                                            addrs,  naddrs) < 0) {
2989 2990 2991
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot find PCI address for video adapter %s"),
                           virDomainVideoTypeToString(vm->def->videos[i]->type));
2992 2993 2994 2995
            return -1;
        }
    }

2996
    for (i = 0; i < vm->def->nsounds; i++) {
2997 2998 2999 3000 3001 3002
        if (qemuProcessGetPCISoundVendorProduct(vm->def->sounds[i], &vendor, &product) < 0)
            continue;

        if (qemuProcessAssignNextPCIAddress(&(vm->def->sounds[i]->info),
                                    vendor, product,
                                     addrs,  naddrs) < 0) {
3003 3004 3005
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot find PCI address for sound adapter %s"),
                           virDomainSoundModelTypeToString(vm->def->sounds[i]->model));
3006 3007 3008 3009 3010 3011 3012 3013 3014 3015
            return -1;
        }
    }


    if (vm->def->watchdog &&
        qemuProcessGetPCIWatchdogVendorProduct(vm->def->watchdog, &vendor, &product) == 0) {
        if (qemuProcessAssignNextPCIAddress(&(vm->def->watchdog->info),
                                            vendor, product,
                                            addrs,  naddrs) < 0) {
3016 3017 3018
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot find PCI address for watchdog %s"),
                           virDomainWatchdogModelTypeToString(vm->def->watchdog->model));
3019 3020 3021 3022 3023 3024 3025 3026 3027
            return -1;
        }
    }

    if (vm->def->memballoon &&
        qemuProcessGetPCIMemballoonVendorProduct(vm->def->memballoon, &vendor, &product) == 0) {
        if (qemuProcessAssignNextPCIAddress(&(vm->def->memballoon->info),
                                            vendor, product,
                                            addrs, naddrs) < 0) {
3028 3029 3030
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("cannot find PCI address for balloon %s"),
                           virDomainMemballoonModelTypeToString(vm->def->memballoon->model));
3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047
            return -1;
        }
    }

    /* XXX console (virtio) */


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

    /* XXX USB controller ? */

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

    return 0;
}

static int
3048
qemuProcessInitPCIAddresses(virQEMUDriverPtr driver,
3049 3050
                            virDomainObjPtr vm,
                            int asyncJob)
3051 3052 3053
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int naddrs;
3054
    int ret = -1;
3055 3056
    qemuMonitorPCIAddress *addrs = NULL;

3057 3058
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;
3059 3060
    naddrs = qemuMonitorGetAllPCIAddresses(priv->mon,
                                           &addrs);
3061 3062
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        goto cleanup;
3063

3064 3065
    if (naddrs > 0)
        ret = qemuProcessDetectPCIAddresses(vm, addrs, naddrs);
3066

3067
 cleanup:
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096
    VIR_FREE(addrs);

    return ret;
}


static int
qemuProcessPrepareChardevDevice(virDomainDefPtr def ATTRIBUTE_UNUSED,
                                virDomainChrDefPtr dev,
                                void *opaque ATTRIBUTE_UNUSED)
{
    int fd;
    if (dev->source.type != VIR_DOMAIN_CHR_TYPE_FILE)
        return 0;

    if ((fd = open(dev->source.data.file.path,
                   O_CREAT | O_APPEND, S_IRUSR|S_IWUSR)) < 0) {
        virReportSystemError(errno,
                             _("Unable to pre-create chardev file '%s'"),
                             dev->source.data.file.path);
        return -1;
    }

    VIR_FORCE_CLOSE(fd);

    return 0;
}


3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109
static int
qemuProcessCleanupChardevDevice(virDomainDefPtr def ATTRIBUTE_UNUSED,
                                virDomainChrDefPtr dev,
                                void *opaque ATTRIBUTE_UNUSED)
{
    if (dev->source.type == VIR_DOMAIN_CHR_TYPE_UNIX &&
        dev->source.data.nix.listen)
        unlink(dev->source.data.nix.path);

    return 0;
}


3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174
/**
 * Loads and update video memory size for video devices according to QEMU
 * process as the QEMU will silently update the values that we pass to QEMU
 * through command line.  We need to load these updated values and store them
 * into the status XML.
 *
 * We will fail if for some reason the values cannot be loaded from QEMU because
 * its mandatory to get the correct video memory size to status XML to not break
 * migration.
 */
static int
qemuProcessUpdateVideoRamSize(virQEMUDriverPtr driver,
                              virDomainObjPtr vm,
                              int asyncJob)
{
    int ret = -1;
    ssize_t i;
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainVideoDefPtr video = NULL;
    virQEMUDriverConfigPtr cfg = NULL;

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

    for (i = 0; i < vm->def->nvideos; i++) {
        video = vm->def->videos[i];

        switch (video->type) {
        case VIR_DOMAIN_VIDEO_TYPE_VGA:
            if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VGA_VGAMEM)) {
                if (qemuMonitorUpdateVideoMemorySize(priv->mon, video, "VGA") < 0)
                    goto error;
            }
            break;
        case VIR_DOMAIN_VIDEO_TYPE_QXL:
            if (i == 0) {
                if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QXL_VGA_VGAMEM)) {
                    if (qemuMonitorUpdateVideoMemorySize(priv->mon, video,
                                                         "qxl-vga") < 0)
                        goto error;
                }
            } else {
                if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QXL_VGAMEM)) {
                    if (qemuMonitorUpdateVideoMemorySize(priv->mon, video,
                                                         "qxl") < 0)
                        goto error;
                }
            }
            break;
        case VIR_DOMAIN_VIDEO_TYPE_VMVGA:
            if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_VMWARE_SVGA_VGAMEM)) {
                if (qemuMonitorUpdateVideoMemorySize(priv->mon, video,
                                                     "vmware-svga") < 0)
                    goto error;
            }
            break;
        case VIR_DOMAIN_VIDEO_TYPE_CIRRUS:
        case VIR_DOMAIN_VIDEO_TYPE_XEN:
        case VIR_DOMAIN_VIDEO_TYPE_VBOX:
        case VIR_DOMAIN_VIDEO_TYPE_LAST:
            break;
        }

    }

3175 3176
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
3177 3178 3179 3180 3181 3182 3183 3184

    cfg = virQEMUDriverGetConfig(driver);
    ret = virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm);
    virObjectUnref(cfg);

    return ret;

 error:
3185
    ignore_value(qemuDomainObjExitMonitor(driver, vm));
3186 3187 3188 3189
    return -1;
}


3190 3191 3192
struct qemuProcessHookData {
    virConnectPtr conn;
    virDomainObjPtr vm;
3193
    virQEMUDriverPtr driver;
3194
    virQEMUDriverConfigPtr cfg;
3195 3196 3197 3198 3199
};

static int qemuProcessHook(void *data)
{
    struct qemuProcessHookData *h = data;
3200
    qemuDomainObjPrivatePtr priv = h->vm->privateData;
3201
    int ret = -1;
3202
    int fd;
3203 3204 3205
    virBitmapPtr nodeset = NULL;
    virDomainNumatuneMemMode mode;

3206 3207 3208 3209 3210
    /* This method cannot use any mutexes, which are not
     * protected across fork()
     */

    virSecurityManagerPostFork(h->driver->securityManager);
3211 3212 3213 3214 3215

    /* Some later calls want pid present */
    h->vm->pid = getpid();

    VIR_DEBUG("Obtaining domain lock");
3216 3217 3218 3219 3220 3221 3222
    /*
     * Since we're going to leak the returned FD to QEMU,
     * we need to make sure it gets a sensible label.
     * This mildly sucks, because there could be other
     * sockets the lock driver opens that we don't want
     * labelled. So far we're ok though.
     */
3223
    if (virSecurityManagerSetSocketLabel(h->driver->securityManager, h->vm->def) < 0)
3224
        goto cleanup;
3225
    if (virDomainLockProcessStart(h->driver->lockManager,
3226
                                  h->cfg->uri,
3227
                                  h->vm,
J
Ján Tomko 已提交
3228
                                  /* QEMU is always paused initially */
3229 3230
                                  true,
                                  &fd) < 0)
3231
        goto cleanup;
3232
    if (virSecurityManagerClearSocketLabel(h->driver->securityManager, h->vm->def) < 0)
3233
        goto cleanup;
3234

3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245
    if (virDomainNumatuneGetMode(h->vm->def->numa, -1, &mode) == 0) {
        if (mode == VIR_DOMAIN_NUMATUNE_MEM_STRICT &&
            h->cfg->cgroupControllers & (1 << VIR_CGROUP_CONTROLLER_CPUSET) &&
            virCgroupControllerAvailable(VIR_CGROUP_CONTROLLER_CPUSET)) {
            /* Use virNuma* API iff necessary. Once set and child is exec()-ed,
             * there's no way for us to change it. Rely on cgroups (if available
             * and enabled in the config) rather than virNuma*. */
            VIR_DEBUG("Relying on CGroups for memory binding");
        } else {
            nodeset = virDomainNumatuneGetNodeset(h->vm->def->numa,
                                                  priv->autoNodeset, -1);
3246

3247 3248 3249
            if (virNumaSetupMemoryPolicy(mode, nodeset) < 0)
                goto cleanup;
        }
3250
    }
3251

3252 3253
    ret = 0;

3254
 cleanup:
3255
    virObjectUnref(h->cfg);
3256 3257
    VIR_DEBUG("Hook complete ret=%d", ret);
    return ret;
3258 3259 3260
}

int
3261
qemuProcessPrepareMonitorChr(virQEMUDriverConfigPtr cfg,
3262 3263 3264 3265 3266 3267
                             virDomainChrSourceDefPtr monConfig,
                             const char *vm)
{
    monConfig->type = VIR_DOMAIN_CHR_TYPE_UNIX;
    monConfig->data.nix.listen = true;

3268
    if (virAsprintf(&monConfig->data.nix.path, "%s/domain-%s/monitor.sock",
3269 3270 3271
                    cfg->libDir, vm) < 0)
        return -1;
    return 0;
3272 3273 3274
}


3275
/*
3276 3277
 * Precondition: vm must be locked, and a job must be active.
 * This method will call {Enter,Exit}Monitor
3278
 */
E
Eric Blake 已提交
3279
int
3280
qemuProcessStartCPUs(virQEMUDriverPtr driver, virDomainObjPtr vm,
3281
                     virConnectPtr conn, virDomainRunningReason reason,
3282
                     qemuDomainAsyncJob asyncJob)
3283
{
3284
    int ret = -1;
3285
    qemuDomainObjPrivatePtr priv = vm->privateData;
3286
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3287

3288
    /* Bring up netdevs before starting CPUs */
3289
    if (qemuInterfaceStartDevices(vm->def) < 0)
3290 3291
       goto cleanup;

3292
    VIR_DEBUG("Using lock state '%s'", NULLSTR(priv->lockState));
3293
    if (virDomainLockProcessResume(driver->lockManager, cfg->uri,
3294
                                   vm, priv->lockState) < 0) {
3295 3296 3297 3298
        /* Don't free priv->lockState on error, because we need
         * to make sure we have state still present if the user
         * tries to resume again
         */
3299
        goto cleanup;
3300 3301 3302
    }
    VIR_FREE(priv->lockState);

3303 3304
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        goto release;
J
Jiri Denemark 已提交
3305

3306
    ret = qemuMonitorStartCPUs(priv->mon, conn);
3307 3308
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        ret = -1;
3309 3310 3311 3312 3313

    if (ret < 0)
        goto release;

    virDomainObjSetState(vm, VIR_DOMAIN_RUNNING, reason);
3314

3315
 cleanup:
3316
    virObjectUnref(cfg);
3317
    return ret;
3318 3319 3320 3321 3322 3323

 release:
    if (virDomainLockProcessPause(driver->lockManager, vm, &priv->lockState) < 0)
        VIR_WARN("Unable to release lease on %s", vm->def->name);
    VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));
    goto cleanup;
3324 3325 3326
}


3327 3328
int qemuProcessStopCPUs(virQEMUDriverPtr driver,
                        virDomainObjPtr vm,
3329
                        virDomainPausedReason reason,
3330
                        qemuDomainAsyncJob asyncJob)
3331
{
3332
    int ret = -1;
3333 3334
    qemuDomainObjPrivatePtr priv = vm->privateData;

3335
    VIR_FREE(priv->lockState);
J
Jiri Denemark 已提交
3336

3337 3338
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        goto cleanup;
J
Jiri Denemark 已提交
3339

3340
    ret = qemuMonitorStopCPUs(priv->mon);
3341 3342
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        ret = -1;
3343 3344 3345 3346

    if (ret < 0)
        goto cleanup;

3347 3348 3349
    /* de-activate netdevs after stopping CPUs */
    ignore_value(qemuInterfaceStopDevices(vm->def));

3350 3351 3352
    if (priv->job.current)
        ignore_value(virTimeMillisNow(&priv->job.current->stopped));

3353 3354 3355 3356
    virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, reason);
    if (virDomainLockProcessPause(driver->lockManager, vm, &priv->lockState) < 0)
        VIR_WARN("Unable to release lease on %s", vm->def->name);
    VIR_DEBUG("Preserving lock state '%s'", NULLSTR(priv->lockState));
J
Jiri Denemark 已提交
3357

3358
 cleanup:
3359 3360 3361 3362 3363
    return ret;
}



3364 3365 3366
static int
qemuProcessNotifyNets(virDomainDefPtr def)
{
3367
    size_t i;
3368

3369 3370
    for (i = 0; i < def->nnets; i++) {
        virDomainNetDefPtr net = def->nets[i];
3371
        if (networkNotifyActualDevice(def, net) < 0)
3372 3373 3374 3375 3376
            return -1;
    }
    return 0;
}

3377
static int
3378
qemuProcessFiltersInstantiate(virDomainDefPtr def)
3379
{
3380
    size_t i;
3381

3382
    for (i = 0; i < def->nnets; i++) {
3383 3384
        virDomainNetDefPtr net = def->nets[i];
        if ((net->filter) && (net->ifname)) {
3385
            if (virDomainConfNWFilterInstantiate(def->uuid, net) < 0)
J
Ján Tomko 已提交
3386
                return 1;
3387 3388 3389
        }
    }

J
Ján Tomko 已提交
3390
    return 0;
3391 3392
}

3393
static int
3394
qemuProcessUpdateState(virQEMUDriverPtr driver, virDomainObjPtr vm)
3395 3396 3397
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainState state;
3398
    virDomainPausedReason reason;
3399
    virDomainState newState = VIR_DOMAIN_NOSTATE;
3400
    int oldReason;
3401
    int newReason;
3402
    bool running;
3403
    char *msg = NULL;
3404 3405
    int ret;

3406
    qemuDomainObjEnterMonitor(driver, vm);
3407
    ret = qemuMonitorGetStatus(priv->mon, &running, &reason);
3408 3409
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
3410

3411
    if (ret < 0)
3412 3413
        return -1;

3414
    state = virDomainObjGetState(vm, &oldReason);
3415

3416 3417 3418 3419 3420 3421 3422 3423
    if (running &&
        (state == VIR_DOMAIN_SHUTOFF ||
         (state == VIR_DOMAIN_PAUSED &&
          oldReason == VIR_DOMAIN_PAUSED_STARTING_UP))) {
        newState = VIR_DOMAIN_RUNNING;
        newReason = VIR_DOMAIN_RUNNING_BOOTED;
        ignore_value(VIR_STRDUP_QUIET(msg, "finished booting"));
    } else if (state == VIR_DOMAIN_PAUSED && running) {
3424 3425
        newState = VIR_DOMAIN_RUNNING;
        newReason = VIR_DOMAIN_RUNNING_UNPAUSED;
3426
        ignore_value(VIR_STRDUP_QUIET(msg, "was unpaused"));
3427
    } else if (state == VIR_DOMAIN_RUNNING && !running) {
3428 3429 3430
        if (reason == VIR_DOMAIN_PAUSED_SHUTTING_DOWN) {
            newState = VIR_DOMAIN_SHUTDOWN;
            newReason = VIR_DOMAIN_SHUTDOWN_UNKNOWN;
3431
            ignore_value(VIR_STRDUP_QUIET(msg, "shutdown"));
3432
        } else if (reason == VIR_DOMAIN_PAUSED_CRASHED) {
3433 3434 3435
            newState = VIR_DOMAIN_CRASHED;
            newReason = VIR_DOMAIN_CRASHED_PANICKED;
            ignore_value(VIR_STRDUP_QUIET(msg, "crashed"));
3436 3437 3438
        } else {
            newState = VIR_DOMAIN_PAUSED;
            newReason = reason;
S
Stefan Berger 已提交
3439 3440
            ignore_value(virAsprintf(&msg, "was paused (%s)",
                                 virDomainPausedReasonTypeToString(reason)));
3441 3442 3443 3444 3445 3446 3447
        }
    }

    if (newState != VIR_DOMAIN_NOSTATE) {
        VIR_DEBUG("Domain %s %s while its monitor was disconnected;"
                  " changing state to %s (%s)",
                  vm->def->name,
3448
                  NULLSTR(msg),
3449 3450 3451 3452
                  virDomainStateTypeToString(newState),
                  virDomainStateReasonToString(newState, newReason));
        VIR_FREE(msg);
        virDomainObjSetState(vm, newState, newReason);
3453 3454 3455 3456 3457
    }

    return 0;
}

3458
static int
3459
qemuProcessRecoverMigration(virQEMUDriverPtr driver,
3460 3461
                            virDomainObjPtr vm,
                            virConnectPtr conn,
3462 3463
                            qemuDomainAsyncJob job,
                            qemuMigrationJobPhase phase,
3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489
                            virDomainState state,
                            int reason)
{
    if (job == QEMU_ASYNC_JOB_MIGRATION_IN) {
        switch (phase) {
        case QEMU_MIGRATION_PHASE_NONE:
        case QEMU_MIGRATION_PHASE_PERFORM2:
        case QEMU_MIGRATION_PHASE_BEGIN3:
        case QEMU_MIGRATION_PHASE_PERFORM3:
        case QEMU_MIGRATION_PHASE_PERFORM3_DONE:
        case QEMU_MIGRATION_PHASE_CONFIRM3_CANCELLED:
        case QEMU_MIGRATION_PHASE_CONFIRM3:
        case QEMU_MIGRATION_PHASE_LAST:
            break;

        case QEMU_MIGRATION_PHASE_PREPARE:
            VIR_DEBUG("Killing unfinished incoming migration for domain %s",
                      vm->def->name);
            return -1;

        case QEMU_MIGRATION_PHASE_FINISH2:
            /* source domain is already killed so let's just resume the domain
             * and hope we are all set */
            VIR_DEBUG("Incoming migration finished, resuming domain %s",
                      vm->def->name);
            if (qemuProcessStartCPUs(driver, vm, conn,
3490 3491
                                     VIR_DOMAIN_RUNNING_UNPAUSED,
                                     QEMU_ASYNC_JOB_NONE) < 0) {
3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519
                VIR_WARN("Could not resume domain %s", vm->def->name);
            }
            break;

        case QEMU_MIGRATION_PHASE_FINISH3:
            /* migration finished, we started resuming the domain but didn't
             * confirm success or failure yet; killing it seems safest */
            VIR_DEBUG("Killing migrated domain %s", vm->def->name);
            return -1;
        }
    } else if (job == QEMU_ASYNC_JOB_MIGRATION_OUT) {
        switch (phase) {
        case QEMU_MIGRATION_PHASE_NONE:
        case QEMU_MIGRATION_PHASE_PREPARE:
        case QEMU_MIGRATION_PHASE_FINISH2:
        case QEMU_MIGRATION_PHASE_FINISH3:
        case QEMU_MIGRATION_PHASE_LAST:
            break;

        case QEMU_MIGRATION_PHASE_BEGIN3:
            /* nothing happen so far, just forget we were about to migrate the
             * domain */
            break;

        case QEMU_MIGRATION_PHASE_PERFORM2:
        case QEMU_MIGRATION_PHASE_PERFORM3:
            /* migration is still in progress, let's cancel it and resume the
             * domain */
3520
            if (qemuMigrationCancel(driver, vm) < 0)
3521
                return -1;
3522 3523 3524 3525 3526 3527
            /* resume the domain but only if it was paused as a result of
             * migration */
            if (state == VIR_DOMAIN_PAUSED &&
                (reason == VIR_DOMAIN_PAUSED_MIGRATION ||
                 reason == VIR_DOMAIN_PAUSED_UNKNOWN)) {
                if (qemuProcessStartCPUs(driver, vm, conn,
3528 3529
                                         VIR_DOMAIN_RUNNING_UNPAUSED,
                                         QEMU_ASYNC_JOB_NONE) < 0) {
3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548
                    VIR_WARN("Could not resume domain %s", vm->def->name);
                }
            }
            break;

        case QEMU_MIGRATION_PHASE_PERFORM3_DONE:
            /* migration finished but we didn't have a chance to get the result
             * of Finish3 step; third party needs to check what to do next
             */
            break;

        case QEMU_MIGRATION_PHASE_CONFIRM3_CANCELLED:
            /* Finish3 failed, we need to resume the domain */
            VIR_DEBUG("Resuming domain %s after failed migration",
                      vm->def->name);
            if (state == VIR_DOMAIN_PAUSED &&
                (reason == VIR_DOMAIN_PAUSED_MIGRATION ||
                 reason == VIR_DOMAIN_PAUSED_UNKNOWN)) {
                if (qemuProcessStartCPUs(driver, vm, conn,
3549 3550
                                         VIR_DOMAIN_RUNNING_UNPAUSED,
                                         QEMU_ASYNC_JOB_NONE) < 0) {
3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564
                    VIR_WARN("Could not resume domain %s", vm->def->name);
                }
            }
            break;

        case QEMU_MIGRATION_PHASE_CONFIRM3:
            /* migration completed, we need to kill the domain here */
            return -1;
        }
    }

    return 0;
}

3565
static int
3566
qemuProcessRecoverJob(virQEMUDriverPtr driver,
3567 3568 3569 3570
                      virDomainObjPtr vm,
                      virConnectPtr conn,
                      const struct qemuDomainJobObj *job)
{
3571
    qemuDomainObjPrivatePtr priv = vm->privateData;
3572 3573 3574 3575 3576 3577 3578 3579
    virDomainState state;
    int reason;

    state = virDomainObjGetState(vm, &reason);

    switch (job->asyncJob) {
    case QEMU_ASYNC_JOB_MIGRATION_OUT:
    case QEMU_ASYNC_JOB_MIGRATION_IN:
3580 3581 3582
        if (qemuProcessRecoverMigration(driver, vm, conn, job->asyncJob,
                                        job->phase, state, reason) < 0)
            return -1;
3583 3584 3585 3586
        break;

    case QEMU_ASYNC_JOB_SAVE:
    case QEMU_ASYNC_JOB_DUMP:
3587
    case QEMU_ASYNC_JOB_SNAPSHOT:
3588
        qemuDomainObjEnterMonitor(driver, vm);
3589
        ignore_value(qemuMonitorMigrateCancel(priv->mon));
3590 3591
        if (qemuDomainObjExitMonitor(driver, vm) < 0)
            return -1;
3592
        /* resume the domain but only if it was paused as a result of
3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608
         * running a migration-to-file operation.  Although we are
         * recovering an async job, this function is run at startup
         * and must resume things using sync monitor connections.  */
         if (state == VIR_DOMAIN_PAUSED &&
             ((job->asyncJob == QEMU_ASYNC_JOB_DUMP &&
               reason == VIR_DOMAIN_PAUSED_DUMP) ||
              (job->asyncJob == QEMU_ASYNC_JOB_SAVE &&
               reason == VIR_DOMAIN_PAUSED_SAVE) ||
              (job->asyncJob == QEMU_ASYNC_JOB_SNAPSHOT &&
               reason == VIR_DOMAIN_PAUSED_SNAPSHOT) ||
              reason == VIR_DOMAIN_PAUSED_UNKNOWN)) {
             if (qemuProcessStartCPUs(driver, vm, conn,
                                      VIR_DOMAIN_RUNNING_UNPAUSED,
                                      QEMU_ASYNC_JOB_NONE) < 0) {
                 VIR_WARN("Could not resume domain '%s' after migration to file",
                          vm->def->name);
3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620
            }
        }
        break;

    case QEMU_ASYNC_JOB_NONE:
    case QEMU_ASYNC_JOB_LAST:
        break;
    }

    if (!virDomainObjIsActive(vm))
        return -1;

3621 3622 3623 3624
    /* In case any special handling is added for job type that has been ignored
     * before, QEMU_DOMAIN_TRACK_JOBS (from qemu_domain.h) needs to be updated
     * for the job to be properly tracked in domain state XML.
     */
3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644
    switch (job->active) {
    case QEMU_JOB_QUERY:
        /* harmless */
        break;

    case QEMU_JOB_DESTROY:
        VIR_DEBUG("Domain %s should have already been destroyed",
                  vm->def->name);
        return -1;

    case QEMU_JOB_SUSPEND:
        /* mostly harmless */
        break;

    case QEMU_JOB_MODIFY:
        /* XXX depending on the command we may be in an inconsistent state and
         * we should probably fall back to "monitor error" state and refuse to
         */
        break;

3645
    case QEMU_JOB_MIGRATION_OP:
3646
    case QEMU_JOB_ABORT:
3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657
    case QEMU_JOB_ASYNC:
    case QEMU_JOB_ASYNC_NESTED:
        /* async job was already handled above */
    case QEMU_JOB_NONE:
    case QEMU_JOB_LAST:
        break;
    }

    return 0;
}

3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672
static int
qemuProcessUpdateDevices(virQEMUDriverPtr driver,
                         virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virDomainDeviceDef dev;
    char **old;
    char **tmp;
    int ret = -1;

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

    old = priv->qemuDevices;
    priv->qemuDevices = NULL;
3673
    if (qemuDomainUpdateDeviceList(driver, vm, QEMU_ASYNC_JOB_NONE) < 0)
3674 3675 3676 3677 3678
        goto cleanup;

    if ((tmp = old)) {
        while (*tmp) {
            if (!virStringArrayHasString(priv->qemuDevices, *tmp) &&
3679 3680 3681 3682
                virDomainDefFindDevice(vm->def, *tmp, &dev, false) == 0 &&
                qemuDomainRemoveDevice(driver, vm, &dev) < 0) {
                goto cleanup;
            }
3683 3684 3685 3686 3687
            tmp++;
        }
    }
    ret = 0;

3688
 cleanup:
3689 3690 3691 3692
    virStringFreeList(old);
    return ret;
}

3693 3694
struct qemuProcessReconnectData {
    virConnectPtr conn;
3695
    virQEMUDriverPtr driver;
3696
    virDomainObjPtr obj;
3697 3698 3699 3700
};
/*
 * Open an existing VM's monitor, re-detect VCPU threads
 * and re-reserve the security labels in use
S
Stefan Berger 已提交
3701 3702 3703 3704
 *
 * We own the virConnectPtr we are passed here - whoever started
 * this thread function has increased the reference counter to it
 * so that we now have to close it.
3705
 *
3706
 * This function also inherits a locked and ref'd domain object.
3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718
 *
 * This function needs to:
 * 1. Enter job
 * 1. just before monitor reconnect do lightweight MonitorEnter
 *    (increase VM refcount and unlock VM)
 * 2. reconnect to monitor
 * 3. do lightweight MonitorExit (lock VM)
 * 4. continue reconnect process
 * 5. EndJob
 *
 * We can't do normal MonitorEnter & MonitorExit because these two lock the
 * monitor lock, which does not exists in this early phase.
3719 3720
 */
static void
3721
qemuProcessReconnect(void *opaque)
3722 3723
{
    struct qemuProcessReconnectData *data = opaque;
3724
    virQEMUDriverPtr driver = data->driver;
3725
    virDomainObjPtr obj = data->obj;
3726 3727
    qemuDomainObjPrivatePtr priv;
    virConnectPtr conn = data->conn;
3728
    struct qemuDomainJobObj oldjob;
3729 3730
    int state;
    int reason;
3731
    virQEMUDriverConfigPtr cfg;
3732
    size_t i;
3733
    int ret;
3734
    unsigned int stopFlags = 0;
3735

3736 3737
    VIR_FREE(data);

3738
    qemuDomainObjRestoreJob(obj, &oldjob);
3739 3740
    if (oldjob.asyncJob == QEMU_ASYNC_JOB_MIGRATION_IN)
        stopFlags |= VIR_QEMU_PROCESS_STOP_MIGRATED;
3741

3742 3743 3744
    cfg = virQEMUDriverGetConfig(driver);
    priv = obj->privateData;

3745 3746 3747 3748 3749
    /* XXX If we ever gonna change pid file pattern, come up with
     * some intelligence here to deal with old paths. */
    if (!(priv->pidfile = virPidFileBuildPath(cfg->stateDir, obj->def->name)))
        goto killvm;

3750 3751 3752 3753
    if (qemuDomainObjBeginJob(driver, obj, QEMU_JOB_MODIFY) < 0)
        goto killvm;

    virNWFilterReadLockFilterUpdates();
3754 3755 3756 3757

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

    /* XXX check PID liveliness & EXE path */
3758
    if (qemuConnectMonitor(driver, obj, QEMU_ASYNC_JOB_NONE, -1) < 0)
3759 3760
        goto error;

D
Daniel P. Berrange 已提交
3761
    /* Failure to connect to agent shouldn't be fatal */
3762 3763 3764 3765
    if ((ret = qemuConnectAgent(driver, obj)) < 0) {
        if (ret == -2)
            goto error;

D
Daniel P. Berrange 已提交
3766 3767 3768 3769 3770 3771
        VIR_WARN("Cannot connect to QEMU guest agent for %s",
                 obj->def->name);
        virResetLastError();
        priv->agentError = true;
    }

3772
    if (qemuUpdateActivePCIHostdevs(driver, obj->def) < 0)
3773 3774
        goto error;

3775
    if (qemuUpdateActiveUSBHostdevs(driver, obj->def) < 0)
3776 3777
        goto error;

3778
    if (qemuUpdateActiveSCSIHostdevs(driver, obj->def) < 0)
3779 3780
        goto error;

3781
    if (qemuConnectCgroup(driver, obj) < 0)
3782 3783
        goto error;

3784
    /* XXX: Need to change as long as lock is introduced for
3785
     * qemu_driver->sharedDevices.
3786 3787
     */
    for (i = 0; i < obj->def->ndisks; i++) {
3788 3789
        virDomainDeviceDef dev;

3790
        if (virStorageTranslateDiskSourcePool(conn, obj->def->disks[i]) < 0)
3791
            goto error;
3792

3793 3794 3795 3796 3797 3798
        /* XXX we should be able to restore all data from XML in the future.
         * This should be the only place that calls qemuDomainDetermineDiskChain
         * with @report_broken == false to guarantee best-effort domain
         * reconnect */
        if (qemuDomainDetermineDiskChain(driver, obj, obj->def->disks[i],
                                         true, false) < 0)
3799 3800
            goto error;

3801 3802 3803
        dev.type = VIR_DOMAIN_DEVICE_DISK;
        dev.data.disk = obj->def->disks[i];
        if (qemuAddSharedDevice(driver, &dev, obj->def->name) < 0)
3804 3805 3806
            goto error;
    }

3807 3808 3809
    if (qemuProcessUpdateState(driver, obj) < 0)
        goto error;

3810
    state = virDomainObjGetState(obj, &reason);
3811 3812 3813
    if (state == VIR_DOMAIN_SHUTOFF ||
        (state == VIR_DOMAIN_PAUSED &&
         reason == VIR_DOMAIN_PAUSED_STARTING_UP)) {
3814 3815 3816 3817 3818
        VIR_DEBUG("Domain '%s' wasn't fully started yet, killing it",
                  obj->def->name);
        goto error;
    }

3819 3820 3821
    /* If upgrading from old libvirtd we won't have found any
     * caps in the domain status, so re-query them
     */
3822 3823
    if (!priv->qemuCaps &&
        !(priv->qemuCaps = virQEMUCapsCacheLookupCopy(driver->qemuCapsCache,
3824 3825
                                                      obj->def->emulator,
                                                      obj->def->os.machine)))
3826 3827
        goto error;

3828
    /* In case the domain shutdown while we were not running,
3829
     * we need to finish the shutdown process. And we need to do it after
3830
     * we have virQEMUCaps filled in.
3831
     */
3832 3833 3834 3835 3836 3837
    if (state == VIR_DOMAIN_SHUTDOWN ||
        (state == VIR_DOMAIN_PAUSED &&
         reason == VIR_DOMAIN_PAUSED_SHUTTING_DOWN)) {
        VIR_DEBUG("Finishing shutdown sequence for domain %s",
                  obj->def->name);
        qemuProcessShutdownOrReboot(driver, obj);
3838 3839
        qemuDomainObjEndJob(driver, obj);
        goto cleanup;
3840 3841
    }

3842 3843
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
        if ((qemuDomainAssignAddresses(obj->def, priv->qemuCaps, obj)) < 0)
3844
            goto error;
3845

3846 3847 3848 3849 3850 3851
    /* if domain requests security driver we haven't loaded, report error, but
     * do not kill the domain
     */
    ignore_value(virSecurityManagerCheckAllLabel(driver->securityManager,
                                                 obj->def));

3852
    if (virSecurityManagerReserveLabel(driver->securityManager, obj->def, obj->pid) < 0)
3853 3854
        goto error;

3855 3856 3857
    if (qemuProcessNotifyNets(obj->def) < 0)
        goto error;

3858
    if (qemuProcessFiltersInstantiate(obj->def))
3859 3860
        goto error;

3861
    if (qemuDomainCheckEjectableMedia(driver, obj, QEMU_ASYNC_JOB_NONE) < 0)
3862 3863
        goto error;

3864 3865 3866
    if (qemuProcessReconnectRefreshChannelVirtioState(driver, obj) < 0)
        goto error;

3867 3868 3869
    if (qemuProcessRefreshBalloonState(driver, obj, QEMU_ASYNC_JOB_NONE) < 0)
        goto error;

3870 3871 3872
    if (qemuProcessRecoverJob(driver, obj, conn, &oldjob) < 0)
        goto error;

3873 3874 3875
    if (qemuProcessUpdateDevices(driver, obj) < 0)
        goto error;

3876
    /* update domain state XML with possibly updated state in virDomainObj */
3877
    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, obj) < 0)
3878 3879
        goto error;

3880 3881
    /* Run an hook to allow admins to do some magic */
    if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) {
3882
        char *xml = qemuDomainDefFormatXML(driver, obj->def, 0);
3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896
        int hookret;

        hookret = virHookCall(VIR_HOOK_DRIVER_QEMU, obj->def->name,
                              VIR_HOOK_QEMU_OP_RECONNECT, VIR_HOOK_SUBOP_BEGIN,
                              NULL, xml, NULL);
        VIR_FREE(xml);

        /*
         * If the script raised an error abort the launch
         */
        if (hookret < 0)
            goto error;
    }

3897
    if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback)
3898 3899
        driver->inhibitCallback(true, driver->inhibitOpaque);

3900 3901
    qemuDomainObjEndJob(driver, obj);
    goto cleanup;
3902

3903
 error:
3904
    qemuDomainObjEndJob(driver, obj);
3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919
 killvm:
    if (virDomainObjIsActive(obj)) {
        /* 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
         */
        if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
            /* If we couldn't get the monitor and qemu supports
             * no-shutdown, we can safely say that the domain
             * crashed ... */
            state = VIR_DOMAIN_SHUTOFF_CRASHED;
        } else {
            /* ... but if it doesn't we can't say what the state
             * really is and FAILED means "failed to start" */
            state = VIR_DOMAIN_SHUTOFF_UNKNOWN;
3920
        }
3921
        qemuProcessStop(driver, obj, state, stopFlags);
3922
    }
3923

3924 3925
    if (!obj->persistent)
        qemuDomainRemoveInactive(driver, obj);
3926

3927
 cleanup:
M
Michal Privoznik 已提交
3928
    virDomainObjEndAPI(&obj);
3929
    virObjectUnref(conn);
3930
    virObjectUnref(cfg);
3931
    virNWFilterUnlockFilterUpdates();
3932 3933
}

3934 3935
static int
qemuProcessReconnectHelper(virDomainObjPtr obj,
3936 3937 3938 3939 3940 3941
                           void *opaque)
{
    virThread thread;
    struct qemuProcessReconnectData *src = opaque;
    struct qemuProcessReconnectData *data;

3942
    /* If the VM was inactive, we don't need to reconnect */
3943 3944 3945
    if (!obj->pid)
        return 0;

3946
    if (VIR_ALLOC(data) < 0)
3947
        return -1;
3948 3949

    memcpy(data, src, sizeof(*data));
3950
    data->obj = obj;
3951

3952 3953
    /* this lock and reference will be eventually transferred to the thread
     * that handles the reconnect */
3954
    virObjectLock(obj);
3955
    virObjectRef(obj);
3956

3957 3958 3959
    /* Since we close the connection later on, we have to make sure that the
     * threads we start see a valid connection throughout their lifetime. We
     * simply increase the reference counter here.
S
Stefan Berger 已提交
3960
     */
3961
    virObjectRef(data->conn);
S
Stefan Berger 已提交
3962

3963
    if (virThreadCreate(&thread, false, qemuProcessReconnect, data) < 0) {
3964 3965 3966
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Could not create thread. QEMU initialization "
                         "might be incomplete"));
3967 3968 3969 3970
       /* We can't spawn a thread and thus connect to monitor. Kill qemu. */
        qemuProcessStop(src->driver, obj, VIR_DOMAIN_SHUTOFF_FAILED, 0);
        if (!obj->persistent)
            qemuDomainRemoveInactive(src->driver, obj);
3971

M
Michal Privoznik 已提交
3972
        virDomainObjEndAPI(&obj);
3973 3974 3975 3976
        virObjectUnref(data->conn);
        VIR_FREE(data);
        return -1;
    }
3977

3978
    return 0;
3979 3980 3981 3982 3983 3984 3985 3986 3987
}

/**
 * qemuProcessReconnectAll
 *
 * Try to re-open the resources for live VMs that we care
 * about.
 */
void
3988
qemuProcessReconnectAll(virConnectPtr conn, virQEMUDriverPtr driver)
3989
{
3990
    struct qemuProcessReconnectData data = {.conn = conn, .driver = driver};
3991
    virDomainObjListForEach(driver->domains, qemuProcessReconnectHelper, &data);
3992 3993
}

3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016
static int
qemuProcessVNCAllocatePorts(virQEMUDriverPtr driver,
                            virDomainGraphicsDefPtr graphics)
{
    unsigned short port;

    if (graphics->data.vnc.socket)
        return 0;

    if (graphics->data.vnc.autoport) {
        if (virPortAllocatorAcquire(driver->remotePorts, &port) < 0)
            return -1;
        graphics->data.vnc.port = port;
    }

    if (graphics->data.vnc.websocket == -1) {
        if (virPortAllocatorAcquire(driver->webSocketPorts, &port) < 0)
            return -1;
        graphics->data.vnc.websocket = port;
    }

    return 0;
}
4017

4018
int
4019 4020
qemuProcessSPICEAllocatePorts(virQEMUDriverPtr driver,
                              virQEMUDriverConfigPtr cfg,
4021 4022
                              virDomainGraphicsDefPtr graphics,
                              bool allocate)
4023 4024 4025
{
    unsigned short port = 0;
    unsigned short tlsPort;
4026
    size_t i;
4027 4028 4029 4030 4031 4032 4033
    int defaultMode = graphics->data.spice.defaultMode;

    bool needTLSPort = false;
    bool needPort = false;

    if (graphics->data.spice.autoport) {
        /* check if tlsPort or port need allocation */
4034
        for (i = 0; i < VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_LAST; i++) {
4035 4036 4037 4038 4039 4040 4041 4042 4043 4044
            switch (graphics->data.spice.channels[i]) {
            case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
                needTLSPort = true;
                break;

            case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE:
                needPort = true;
                break;

            case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_ANY:
4045
                /* default mode will be used */
4046 4047 4048
                break;
            }
        }
4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063
        switch (defaultMode) {
        case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
            needTLSPort = true;
            break;

        case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE:
            needPort = true;
            break;

        case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_ANY:
            if (cfg->spiceTLS)
                needTLSPort = true;
            needPort = true;
            break;
        }
4064 4065
    }

4066 4067 4068 4069 4070 4071 4072 4073 4074 4075
    if (!allocate) {
        if (needPort || graphics->data.spice.port == -1)
            graphics->data.spice.port = 5901;

        if (needTLSPort || graphics->data.spice.tlsPort == -1)
            graphics->data.spice.tlsPort = 5902;

        return 0;
    }

4076
    if (needPort || graphics->data.spice.port == -1) {
4077
        if (virPortAllocatorAcquire(driver->remotePorts, &port) < 0)
4078
            goto error;
4079 4080 4081 4082

        graphics->data.spice.port = port;
    }

4083 4084
    if (needTLSPort || graphics->data.spice.tlsPort == -1) {
        if (!cfg->spiceTLS) {
4085 4086 4087 4088
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Auto allocation of spice TLS port requested "
                             "but spice TLS is disabled in qemu.conf"));
            goto error;
4089
        }
4090 4091 4092 4093 4094

        if (virPortAllocatorAcquire(driver->remotePorts, &tlsPort) < 0)
            goto error;

        graphics->data.spice.tlsPort = tlsPort;
4095 4096
    }

4097
    return 0;
4098

4099
 error:
4100
    virPortAllocatorRelease(driver->remotePorts, port);
4101
    return -1;
4102 4103 4104
}


4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122
static bool
qemuValidateCpuMax(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
{
    unsigned int maxCpus;

    maxCpus = virQEMUCapsGetMachineMaxCpus(qemuCaps, def->os.machine);
    if (!maxCpus)
        return true;

    if (def->maxvcpus > maxCpus) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       "%s", _("Maximum CPUs greater than specified machine type limit"));
        return false;
    }

    return true;
}

4123 4124

static bool
4125 4126 4127
qemuProcessVerifyGuestCPU(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
                          int asyncJob)
4128 4129 4130 4131 4132
{
    virDomainDefPtr def = vm->def;
    virArch arch = def->os.arch;
    virCPUDataPtr guestcpu = NULL;
    qemuDomainObjPrivatePtr priv = vm->privateData;
4133
    int rc;
4134
    bool ret = false;
J
Ján Tomko 已提交
4135
    size_t i;
4136

4137 4138 4139 4140 4141
    /* no features are passed to QEMU with -cpu host
     * so it makes no sense to verify them */
    if (def->cpu && def->cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH)
        return true;

4142 4143 4144
    switch (arch) {
    case VIR_ARCH_I686:
    case VIR_ARCH_X86_64:
4145 4146
        if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
            return false;
4147
        rc = qemuMonitorGetGuestCPU(priv->mon, arch, &guestcpu);
4148 4149
        if (qemuDomainObjExitMonitor(driver, vm) < 0)
            return false;
4150

4151 4152 4153 4154
        if (rc < 0) {
            if (rc == -2)
                break;

4155
            goto cleanup;
4156
        }
4157

J
Ján Tomko 已提交
4158
        if (def->features[VIR_DOMAIN_FEATURE_PVSPINLOCK] == VIR_TRISTATE_SWITCH_ON) {
4159 4160 4161 4162 4163 4164
            if (!cpuHasFeature(guestcpu, VIR_CPU_x86_KVM_PV_UNHALT)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("host doesn't support paravirtual spinlocks"));
                goto cleanup;
            }
        }
J
Ján Tomko 已提交
4165

4166
        for (i = 0; def->cpu && i < def->cpu->nfeatures; i++) {
J
Ján Tomko 已提交
4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178
            virCPUFeatureDefPtr feature = &def->cpu->features[i];

            if (feature->policy != VIR_CPU_FEATURE_REQUIRE)
                continue;

            if (STREQ(feature->name, "invtsc") &&
                !cpuHasFeature(guestcpu, feature->name)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("host doesn't support invariant TSC"));
                goto cleanup;
            }
        }
4179 4180 4181 4182 4183 4184 4185 4186
        break;

    default:
        break;
    }

    ret = true;

4187
 cleanup:
4188 4189 4190 4191 4192
    cpuDataFree(guestcpu);
    return ret;
}


4193 4194
static int
qemuPrepareNVRAM(virQEMUDriverConfigPtr cfg,
4195
                 virDomainObjPtr vm,
4196 4197 4198 4199 4200
                 bool migrated)
{
    int ret = -1;
    int srcFD = -1;
    int dstFD = -1;
4201
    virDomainLoaderDefPtr loader = vm->def->os.loader;
4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226
    bool generated = false;
    bool created = false;

    /* Unless domain has RO loader of pflash type, we have
     * nothing to do here.  If the loader is RW then it's not
     * using split code and vars feature, so no nvram file needs
     * to be created. */
    if (!loader || loader->type != VIR_DOMAIN_LOADER_TYPE_PFLASH ||
        loader->readonly != VIR_TRISTATE_SWITCH_ON)
        return 0;

    /* If the nvram path is configured already, there's nothing
     * we need to do. Unless we are starting the destination side
     * of migration in which case nvram is configured in the
     * domain XML but the file doesn't exist yet. Moreover, after
     * the migration is completed, qemu will invoke a
     * synchronization write into the nvram file so we don't have
     * to take care about transmitting the real data on the other
     * side. */
    if (loader->nvram && !migrated)
        return 0;

    /* Autogenerate nvram path if needed.*/
    if (!loader->nvram) {
        if (virAsprintf(&loader->nvram,
4227 4228
                        "%s/%s_VARS.fd",
                        cfg->nvramDir, vm->def->name) < 0)
4229 4230 4231
            goto cleanup;

        generated = true;
4232

4233 4234
        if (vm->persistent &&
            virDomainSaveConfig(cfg->configDir, vm->def) < 0)
4235
            goto cleanup;
4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325
    }

    if (!virFileExists(loader->nvram)) {
        const char *master_nvram_path = loader->templt;
        ssize_t r;

        if (!loader->templt) {
            size_t i;
            for (i = 0; i < cfg->nloader; i++) {
                if (STREQ(cfg->loader[i], loader->path)) {
                    master_nvram_path = cfg->nvram[i];
                    break;
                }
            }
        }

        if (!master_nvram_path) {
            virReportError(VIR_ERR_OPERATION_FAILED,
                           _("unable to find any master var store for "
                             "loader: %s"), loader->path);
            goto cleanup;
        }

        if ((srcFD = virFileOpenAs(master_nvram_path, O_RDONLY,
                                   0, -1, -1, 0)) < 0) {
            virReportSystemError(-srcFD,
                                 _("Failed to open file '%s'"),
                                 master_nvram_path);
            goto cleanup;
        }
        if ((dstFD = virFileOpenAs(loader->nvram,
                                   O_WRONLY | O_CREAT | O_EXCL,
                                   S_IRUSR | S_IWUSR,
                                   cfg->user, cfg->group, 0)) < 0) {
            virReportSystemError(-dstFD,
                                 _("Failed to create file '%s'"),
                                 loader->nvram);
            goto cleanup;
        }
        created = true;

        do {
            char buf[1024];

            if ((r = saferead(srcFD, buf, sizeof(buf))) < 0) {
                virReportSystemError(errno,
                                     _("Unable to read from file '%s'"),
                                     master_nvram_path);
                goto cleanup;
            }

            if (safewrite(dstFD, buf, r) < 0) {
                virReportSystemError(errno,
                                     _("Unable to write to file '%s'"),
                                     loader->nvram);
                goto cleanup;
            }
        } while (r);

        if (VIR_CLOSE(srcFD) < 0) {
            virReportSystemError(errno,
                                 _("Unable to close file '%s'"),
                                 master_nvram_path);
            goto cleanup;
        }
        if (VIR_CLOSE(dstFD) < 0) {
            virReportSystemError(errno,
                                 _("Unable to close file '%s'"),
                                 loader->nvram);
            goto cleanup;
        }
    }

    ret = 0;
 cleanup:
    /* We successfully generated the nvram path, but failed to
     * copy the file content. Roll back. */
    if (ret < 0) {
        if (created)
            unlink(loader->nvram);
        if (generated)
            VIR_FREE(loader->nvram);
    }

    VIR_FORCE_CLOSE(srcFD);
    VIR_FORCE_CLOSE(dstFD);
    return ret;
}


4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364
static void
qemuLogOperation(virDomainObjPtr vm,
                 const char *msg,
                 int logfd,
                 virCommandPtr cmd)
{
    char *timestamp;
    char *logline;
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int qemuVersion = virQEMUCapsGetVersion(priv->qemuCaps);
    const char *package = virQEMUCapsGetPackage(priv->qemuCaps);
    char ebuf[1024];

    if ((timestamp = virTimeStringNow()) == NULL)
        goto error;

    if (virAsprintf(&logline, "%s: %s %s, qemu version: %d.%d.%d%s\n",
                    timestamp, msg, VIR_LOG_VERSION_STRING,
                    (qemuVersion / 1000000) % 1000, (qemuVersion / 1000) % 1000, qemuVersion % 1000,
                    package ? package : "") < 0)
        goto error;

    if (safewrite(logfd, logline, strlen(logline)) < 0)
        goto error;

    if (cmd)
        virCommandWriteArgLog(cmd, logfd);

 cleanup:
    VIR_FREE(timestamp);
    VIR_FREE(logline);
    return;

 error:
    VIR_WARN("Unable to write banner to logfile: %s",
             virStrerror(errno, ebuf, sizeof(ebuf)));
    goto cleanup;
}

4365
int qemuProcessStart(virConnectPtr conn,
4366
                     virQEMUDriverPtr driver,
4367
                     virDomainObjPtr vm,
4368
                     int asyncJob,
4369 4370 4371
                     const char *migrateFrom,
                     int stdin_fd,
                     const char *stdin_path,
4372
                     virDomainSnapshotObjPtr snapshot,
4373
                     virNetDevVPortProfileOp vmop,
4374
                     unsigned int flags)
4375 4376 4377 4378 4379 4380 4381 4382
{
    int ret;
    off_t pos = -1;
    char ebuf[1024];
    int logfile = -1;
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virCommandPtr cmd = NULL;
    struct qemuProcessHookData hookData;
4383
    size_t i;
4384
    bool rawio_set = false;
4385
    char *nodeset = NULL;
4386
    unsigned int stop_flags;
4387
    virQEMUDriverConfigPtr cfg;
4388
    virCapsPtr caps = NULL;
4389
    unsigned int hostdev_flags = 0;
4390 4391
    size_t nnicindexes = 0;
    int *nicindexes = NULL;
4392
    char *tmppath = NULL;
4393

4394 4395 4396 4397
    VIR_DEBUG("vm=%p name=%s id=%d asyncJob=%d migrateFrom=%s stdin_fd=%d "
              "stdin_path=%s snapshot=%p vmop=%d flags=0x%x",
              vm, vm->def->name, vm->def->id, asyncJob, NULLSTR(migrateFrom),
              stdin_fd, NULLSTR(stdin_path), snapshot, vmop, flags);
4398

4399 4400 4401 4402
    /* Okay, these are just internal flags,
     * but doesn't hurt to check */
    virCheckFlags(VIR_QEMU_PROCESS_START_COLD |
                  VIR_QEMU_PROCESS_START_PAUSED |
4403
                  VIR_QEMU_PROCESS_START_AUTODESTROY, -1);
4404

4405 4406
    cfg = virQEMUDriverGetConfig(driver);

4407 4408 4409 4410 4411
    /* From now on until domain security labeling is done:
     * if any operation fails and we goto cleanup, we must not
     * restore any security label as we would overwrite labels
     * we did not set. */
    stop_flags = VIR_QEMU_PROCESS_STOP_NO_RELABEL;
4412 4413 4414 4415
    /* If we fail while doing incoming migration, then we must not
     * relabel, as the source is still using the files.  */
    if (migrateFrom)
        stop_flags |= VIR_QEMU_PROCESS_STOP_MIGRATED;
4416

4417 4418 4419
    hookData.conn = conn;
    hookData.vm = vm;
    hookData.driver = driver;
4420 4421
    /* We don't increase cfg's reference counter here. */
    hookData.cfg = cfg;
4422

4423
    VIR_DEBUG("Beginning VM startup process");
4424 4425

    if (virDomainObjIsActive(vm)) {
4426 4427
        virReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("VM is already active"));
4428
        virObjectUnref(cfg);
4429 4430 4431
        return -1;
    }

4432 4433 4434
    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
        goto cleanup;

4435 4436 4437 4438
    /* Some things, paths, ... are generated here and we want them to persist.
     * Fill them in prior to setting the domain def as transient. */
    VIR_DEBUG("Generating paths");

4439
    if (qemuPrepareNVRAM(cfg, vm, migrateFrom) < 0)
4440 4441
        goto cleanup;

4442 4443 4444 4445
    /* Do this upfront, so any part of the startup process can add
     * runtime state to vm->def that won't be persisted. This let's us
     * report implicit runtime defaults in the XML, like vnc listen/socket
     */
4446
    VIR_DEBUG("Setting current domain def as transient");
4447
    if (virDomainObjSetDefTransient(caps, driver->xmlopt, vm, true) < 0)
4448 4449
        goto cleanup;

4450
    vm->def->id = qemuDriverAllocateID(driver);
4451
    qemuDomainSetFakeReboot(driver, vm, false);
4452
    virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, VIR_DOMAIN_PAUSED_STARTING_UP);
4453

4454
    if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback)
4455 4456
        driver->inhibitCallback(true, driver->inhibitOpaque);

4457
    /* Run an early hook to set-up missing devices */
4458
    if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) {
4459
        char *xml = qemuDomainDefFormatXML(driver, vm->def, 0);
4460 4461 4462
        int hookret;

        hookret = virHookCall(VIR_HOOK_DRIVER_QEMU, vm->def->name,
4463 4464
                              VIR_HOOK_QEMU_OP_PREPARE, VIR_HOOK_SUBOP_BEGIN,
                              NULL, xml, NULL);
4465 4466 4467 4468 4469 4470 4471 4472 4473
        VIR_FREE(xml);

        /*
         * If the script raised an error abort the launch
         */
        if (hookret < 0)
            goto cleanup;
    }

4474 4475 4476
    VIR_DEBUG("Determining emulator version");
    virObjectUnref(priv->qemuCaps);
    if (!(priv->qemuCaps = virQEMUCapsCacheLookupCopy(driver->qemuCapsCache,
4477 4478
                                                      vm->def->emulator,
                                                      vm->def->os.machine)))
4479 4480
        goto cleanup;

4481 4482 4483 4484 4485 4486 4487 4488
    /* network devices must be "prepared" before hostdevs, because
     * setting up a network device might create a new hostdev that
     * will need to be setup.
     */
    VIR_DEBUG("Preparing network devices");
    if (qemuNetworkPrepareDevices(vm->def) < 0)
       goto cleanup;

4489
    /* Must be run before security labelling */
4490
    VIR_DEBUG("Preparing host devices");
4491 4492
    if (!cfg->relaxedACS)
        hostdev_flags |= VIR_HOSTDEV_STRICT_ACS_CHECK;
4493 4494
    if (!migrateFrom)
        hostdev_flags |= VIR_HOSTDEV_COLD_BOOT;
4495
    if (qemuPrepareHostDevices(driver, vm->def, priv->qemuCaps,
4496
                               hostdev_flags) < 0)
4497 4498
        goto cleanup;

4499
    VIR_DEBUG("Preparing chr devices");
4500 4501 4502 4503 4504 4505
    if (virDomainChrDefForeach(vm->def,
                               true,
                               qemuProcessPrepareChardevDevice,
                               NULL) < 0)
        goto cleanup;

4506 4507 4508 4509
    VIR_DEBUG("Checking domain and device security labels");
    if (virSecurityManagerCheckAllLabel(driver->securityManager, vm->def) < 0)
        goto cleanup;

4510 4511
    /* If you are using a SecurityDriver with dynamic labelling,
       then generate a security label for isolation */
4512
    VIR_DEBUG("Generating domain security label (if required)");
4513
    if (virSecurityManagerGenLabel(driver->securityManager, vm->def) < 0) {
4514
        virDomainAuditSecurityLabel(vm, false);
4515 4516
        goto cleanup;
    }
4517
    virDomainAuditSecurityLabel(vm, true);
4518

4519
    if (vm->def->mem.nhugepages) {
4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533
        for (i = 0; i < cfg->nhugetlbfs; i++) {
            char *hugepagePath = qemuGetHugepagePath(&cfg->hugetlbfs[i]);

            if (!hugepagePath)
                goto cleanup;

            if (virSecurityManagerSetHugepages(driver->securityManager,
                                               vm->def, hugepagePath) < 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("Unable to set huge path in security driver"));
                VIR_FREE(hugepagePath);
                goto cleanup;
            }
            VIR_FREE(hugepagePath);
4534 4535 4536
        }
    }

4537 4538
    /* Ensure no historical cgroup for this VM is lying around bogus
     * settings */
4539
    VIR_DEBUG("Ensuring no historical cgroup is lying around");
4540
    qemuRemoveCgroup(driver, vm);
4541

4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576
    for (i = 0; i < vm->def->ngraphics; ++i) {
        virDomainGraphicsDefPtr graphics = vm->def->graphics[i];
        if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
            !graphics->data.vnc.autoport) {
            if (virPortAllocatorSetUsed(driver->remotePorts,
                                        graphics->data.vnc.port,
                                        true) < 0) {
                goto cleanup;
            }

            graphics->data.vnc.portReserved = true;

        } else if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE &&
                   !graphics->data.spice.autoport) {

            if (graphics->data.spice.port > 0) {
                if (virPortAllocatorSetUsed(driver->remotePorts,
                                            graphics->data.spice.port,
                                            true) < 0)
                    goto cleanup;

                graphics->data.spice.portReserved = true;
            }

            if (graphics->data.spice.tlsPort > 0) {
                if (virPortAllocatorSetUsed(driver->remotePorts,
                                            graphics->data.spice.tlsPort,
                                            true) < 0)
                    goto cleanup;

                graphics->data.spice.tlsPortReserved = true;
            }
        }
    }

4577
    for (i = 0; i < vm->def->ngraphics; ++i) {
4578
        virDomainGraphicsDefPtr graphics = vm->def->graphics[i];
4579 4580
        if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
            if (qemuProcessVNCAllocatePorts(driver, graphics) < 0)
4581
                goto cleanup;
4582
        } else if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
4583
            if (qemuProcessSPICEAllocatePorts(driver, cfg, graphics, true) < 0)
4584
                goto cleanup;
4585
        }
4586

4587 4588
        if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC ||
            graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
4589
            if (graphics->nListens == 0) {
4590
                if (VIR_EXPAND_N(graphics->listens, graphics->nListens, 1) < 0)
4591 4592
                    goto cleanup;
                graphics->listens[0].type = VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS;
4593 4594 4595
                if (VIR_STRDUP(graphics->listens[0].address,
                               graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC ?
                               cfg->vncListen : cfg->spiceListen) < 0) {
4596 4597 4598
                    VIR_SHRINK_N(graphics->listens, graphics->nListens, 1);
                    goto cleanup;
                }
4599
                graphics->listens[0].fromConfig = true;
4600 4601 4602 4603 4604
            } else if (graphics->nListens > 1) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("QEMU does not support multiple listen "
                                 "addresses for one graphics device."));
                goto cleanup;
4605 4606
            }
        }
4607 4608
    }

4609
    if (virFileMakePath(cfg->logDir) < 0) {
4610 4611
        virReportSystemError(errno,
                             _("cannot create log directory %s"),
4612
                             cfg->logDir);
4613 4614 4615
        goto cleanup;
    }

4616
    VIR_DEBUG("Creating domain log file");
4617
    if ((logfile = qemuDomainCreateLog(driver, vm, false)) < 0)
4618 4619
        goto cleanup;

4620 4621
    if (vm->def->virtType == VIR_DOMAIN_VIRT_KVM) {
        VIR_DEBUG("Checking for KVM availability");
4622
        if (!virFileExists("/dev/kvm")) {
4623 4624 4625 4626
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Domain requires KVM, but it is not available. "
                             "Check that virtualization is enabled in the host BIOS, "
                             "and host configuration is setup to load the kvm modules."));
4627 4628 4629 4630
            goto cleanup;
        }
    }

4631 4632 4633
    if (!qemuValidateCpuMax(vm->def, priv->qemuCaps))
        goto cleanup;

4634
    if (qemuAssignDeviceAliases(vm->def, priv->qemuCaps) < 0)
4635 4636
        goto cleanup;

4637 4638 4639
    /* Get the advisory nodeset from numad if 'placement' of
     * either <vcpu> or <numatune> is 'auto'.
     */
4640
    if (virDomainDefNeedsPlacementAdvice(vm->def)) {
4641
        nodeset = virNumaGetAutoPlacementAdvice(vm->def->vcpus,
4642
                                                virDomainDefGetMemoryActual(vm->def));
4643 4644 4645 4646 4647
        if (!nodeset)
            goto cleanup;

        VIR_DEBUG("Nodeset returned from numad: %s", nodeset);

4648 4649 4650 4651 4652 4653
        if (virBitmapParse(nodeset, 0, &priv->autoNodeset,
                           VIR_DOMAIN_CPUMASK_LEN) < 0)
            goto cleanup;

        if (!(priv->autoCpuset = virCapabilitiesGetCpusForNodemask(caps,
                                                                   priv->autoNodeset)))
4654 4655 4656
            goto cleanup;
    }

4657 4658 4659
    if (virDomainDefCheckDuplicateDiskWWN(vm->def) < 0)
        goto cleanup;

4660 4661 4662 4663
    /* "volume" type disk's source must be translated before
     * cgroup and security setting.
     */
    for (i = 0; i < vm->def->ndisks; i++) {
4664
        if (virStorageTranslateDiskSourcePool(conn, vm->def->disks[i]) < 0)
4665 4666 4667
            goto cleanup;
    }

4668 4669 4670 4671
    if (qemuDomainCheckDiskPresence(driver, vm,
                                    flags & VIR_QEMU_PROCESS_START_COLD) < 0)
        goto cleanup;

4672 4673 4674 4675 4676 4677 4678
    if (vm->def->mem.min_guarantee) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Parameter 'min_guarantee' "
                         "not supported by QEMU."));
        goto cleanup;
    }

4679
    if (VIR_ALLOC(priv->monConfig) < 0)
4680 4681
        goto cleanup;

4682
    VIR_DEBUG("Preparing monitor state");
4683
    if (qemuProcessPrepareMonitorChr(cfg, priv->monConfig, vm->def->name) < 0)
4684 4685
        goto cleanup;

E
Eric Blake 已提交
4686
    priv->monJSON = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON);
4687 4688
    priv->monError = false;
    priv->monStart = 0;
4689 4690
    priv->gotShutdown = false;

4691
    VIR_FREE(priv->pidfile);
4692
    if (!(priv->pidfile = virPidFileBuildPath(cfg->stateDir, vm->def->name))) {
4693 4694
        virReportSystemError(errno,
                             "%s", _("Failed to build pidfile path."));
4695 4696 4697
        goto cleanup;
    }

4698 4699
    if (unlink(priv->pidfile) < 0 &&
        errno != ENOENT) {
4700
        virReportSystemError(errno,
4701 4702
                             _("Cannot remove stale PID file %s"),
                             priv->pidfile);
4703 4704 4705 4706 4707 4708 4709
        goto cleanup;
    }

    /*
     * Normally PCI addresses are assigned in the virDomainCreate
     * or virDomainDefine methods. We might still need to assign
     * some here to cope with the question of upgrades. Regardless
M
Martin Kletzander 已提交
4710
     * we also need to populate the PCI address set cache for later
4711 4712
     * use in hotplug
     */
4713
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
4714
        VIR_DEBUG("Assigning domain PCI addresses");
4715
        if ((qemuDomainAssignAddresses(vm->def, priv->qemuCaps, vm)) < 0)
4716
            goto cleanup;
4717 4718
    }

4719
    VIR_DEBUG("Building emulator command line");
4720
    if (!(cmd = qemuBuildCommandLine(conn, driver, vm->def, priv->monConfig,
E
Eric Blake 已提交
4721
                                     priv->monJSON, priv->qemuCaps,
4722
                                     migrateFrom, stdin_fd, snapshot, vmop,
4723
                                     &buildCommandLineCallbacks, false,
4724
                                     qemuCheckFips(),
4725
                                     priv->autoNodeset,
4726
                                     &nnicindexes, &nicindexes)))
4727 4728
        goto cleanup;

4729 4730 4731 4732 4733 4734 4735 4736

    /*
     * Create all per-domain directories in order to make sure domain
     * with any possible seclabels can access it.
     */
    if (virAsprintf(&tmppath, "%s/domain-%s", cfg->libDir, vm->def->name) < 0)
        goto cleanup;

4737
    if (virFileMakePathWithMode(tmppath, 0750) < 0) {
4738
        virReportSystemError(errno, _("Cannot create directory '%s'"), tmppath);
4739
        goto cleanup;
4740
    }
4741 4742

    if (virSecurityManagerDomainSetDirLabel(driver->securityManager,
4743
                                            vm->def, tmppath) < 0)
4744 4745 4746 4747 4748 4749 4750 4751
        goto cleanup;

    VIR_FREE(tmppath);

    if (virAsprintf(&tmppath, "%s/domain-%s",
                    cfg->channelTargetDir, vm->def->name) < 0)
        goto cleanup;

4752
    if (virFileMakePathWithMode(tmppath, 0750) < 0) {
4753
        virReportSystemError(errno, _("Cannot create directory '%s'"), tmppath);
4754
        goto cleanup;
4755
    }
4756 4757

    if (virSecurityManagerDomainSetDirLabel(driver->securityManager,
4758
                                            vm->def, tmppath) < 0)
4759 4760 4761 4762
        goto cleanup;

    VIR_FREE(tmppath);

4763 4764
    /* now that we know it is about to start call the hook if present */
    if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) {
4765
        char *xml = qemuDomainDefFormatXML(driver, vm->def, 0);
4766 4767 4768
        int hookret;

        hookret = virHookCall(VIR_HOOK_DRIVER_QEMU, vm->def->name,
4769 4770
                              VIR_HOOK_QEMU_OP_START, VIR_HOOK_SUBOP_BEGIN,
                              NULL, xml, NULL);
4771 4772 4773 4774 4775 4776 4777 4778 4779
        VIR_FREE(xml);

        /*
         * If the script raised an error abort the launch
         */
        if (hookret < 0)
            goto cleanup;
    }

4780
    qemuLogOperation(vm, "starting up", logfile, cmd);
4781

4782
    qemuDomainObjCheckTaint(driver, vm, logfile);
4783

4784 4785
    if ((pos = lseek(logfile, 0, SEEK_END)) < 0)
        VIR_WARN("Unable to seek to end of logfile: %s",
4786
                 virStrerror(errno, ebuf, sizeof(ebuf)));
4787 4788

    VIR_DEBUG("Clear emulator capabilities: %d",
4789 4790
              cfg->clearEmulatorCapabilities);
    if (cfg->clearEmulatorCapabilities)
4791 4792
        virCommandClearCaps(cmd);

4793 4794
    /* in case a certain disk is desirous of CAP_SYS_RAWIO, add this */
    for (i = 0; i < vm->def->ndisks; i++) {
4795
        virDomainDeviceDef dev;
4796 4797
        virDomainDiskDefPtr disk = vm->def->disks[i];

4798
        if (vm->def->disks[i]->rawio == VIR_TRISTATE_BOOL_YES) {
R
Roman Bogorodskiy 已提交
4799
#ifdef CAP_SYS_RAWIO
4800
            virCommandAllowCap(cmd, CAP_SYS_RAWIO);
4801
            rawio_set = true;
R
Roman Bogorodskiy 已提交
4802 4803 4804
#else
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Raw I/O is not supported on this platform"));
J
John Ferlan 已提交
4805
            goto cleanup;
R
Roman Bogorodskiy 已提交
4806
#endif
J
John Ferlan 已提交
4807
        }
4808

4809 4810 4811
        dev.type = VIR_DOMAIN_DEVICE_DISK;
        dev.data.disk = disk;
        if (qemuAddSharedDevice(driver, &dev, vm->def->name) < 0)
4812
            goto cleanup;
4813

4814
        if (qemuSetUnprivSGIO(&dev) < 0)
4815
            goto cleanup;
4816 4817
    }

4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835
    /* If rawio not already set, check hostdevs as well */
    if (!rawio_set) {
        for (i = 0; i < vm->def->nhostdevs; i++) {
            virDomainHostdevSubsysSCSIPtr scsisrc =
                &vm->def->hostdevs[i]->source.subsys.u.scsi;
            if (scsisrc->rawio == VIR_TRISTATE_BOOL_YES) {
#ifdef CAP_SYS_RAWIO
                virCommandAllowCap(cmd, CAP_SYS_RAWIO);
                break;
#else
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("Raw I/O is not supported on this platform"));
                goto cleanup;
#endif
            }
        }
    }

4836
    virCommandSetPreExecHook(cmd, qemuProcessHook, &hookData);
4837 4838
    virCommandSetMaxProcesses(cmd, cfg->maxProcesses);
    virCommandSetMaxFiles(cmd, cfg->maxFiles);
4839
    virCommandSetUmask(cmd, 0x002);
4840

4841 4842 4843 4844 4845 4846
    VIR_DEBUG("Setting up security labelling");
    if (virSecurityManagerSetChildProcessLabel(driver->securityManager,
                                               vm->def, cmd) < 0) {
        goto cleanup;
    }

4847 4848 4849
    virCommandSetOutputFD(cmd, &logfile);
    virCommandSetErrorFD(cmd, &logfile);
    virCommandNonblockingFDs(cmd);
4850
    virCommandSetPidFile(cmd, priv->pidfile);
4851
    virCommandDaemonize(cmd);
4852
    virCommandRequireHandshake(cmd);
4853

4854 4855
    if (virSecurityManagerPreFork(driver->securityManager) < 0)
        goto cleanup;
4856
    ret = virCommandRun(cmd, NULL);
4857
    virSecurityManagerPostFork(driver->securityManager);
4858

E
Eric Blake 已提交
4859
    /* wait for qemu process to show up */
4860
    if (ret == 0) {
4861
        if (virPidFileReadPath(priv->pidfile, &vm->pid) < 0) {
4862 4863
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Domain %s didn't show up"), vm->def->name);
4864 4865
            ret = -1;
        }
4866 4867 4868 4869 4870
        VIR_DEBUG("QEMU vm=%p name=%s running with pid=%llu",
                  vm, vm->def->name, (unsigned long long)vm->pid);
    } else {
        VIR_DEBUG("QEMU vm=%p name=%s failed to spawn",
                  vm, vm->def->name);
4871 4872
    }

4873
    VIR_DEBUG("Writing early domain status to disk");
4874
    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
4875 4876
        goto cleanup;

4877 4878
    VIR_DEBUG("Waiting for handshake from child");
    if (virCommandHandshakeWait(cmd) < 0) {
4879 4880
        /* Read errors from child that occurred between fork and exec. */
        qemuProcessReadChildErrors(driver, vm, pos);
4881 4882 4883
        goto cleanup;
    }

4884
    VIR_DEBUG("Setting up domain cgroup (if required)");
4885
    if (qemuSetupCgroup(driver, vm, nnicindexes, nicindexes) < 0)
4886 4887 4888 4889 4890
        goto cleanup;

    /* This must be done after cgroup placement to avoid resetting CPU
     * affinity */
    if (!vm->def->cputune.emulatorpin &&
4891
        qemuProcessInitCpuAffinity(vm) < 0)
4892 4893
        goto cleanup;

4894 4895
    VIR_DEBUG("Setting domain security labels");
    if (virSecurityManagerSetAllLabel(driver->securityManager,
4896
                                      vm->def, stdin_path) < 0)
4897 4898
        goto cleanup;

4899 4900 4901 4902 4903 4904
    /* Security manager labeled all devices, therefore
     * if any operation from now on fails and we goto cleanup,
     * where virSecurityManagerRestoreAllLabel() is called
     * (hidden under qemuProcessStop) we need to restore labels. */
    stop_flags &= ~VIR_QEMU_PROCESS_STOP_NO_RELABEL;

4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918
    if (stdin_fd != -1) {
        /* if there's an fd to migrate from, and it's a pipe, put the
         * proper security label on it
         */
        struct stat stdin_sb;

        VIR_DEBUG("setting security label on pipe used for migration");

        if (fstat(stdin_fd, &stdin_sb) < 0) {
            virReportSystemError(errno,
                                 _("cannot stat fd %d"), stdin_fd);
            goto cleanup;
        }
        if (S_ISFIFO(stdin_sb.st_mode) &&
4919
            virSecurityManagerSetImageFDLabel(driver->securityManager, vm->def, stdin_fd) < 0)
4920 4921 4922 4923
            goto cleanup;
    }

    VIR_DEBUG("Labelling done, completing handshake to child");
4924
    if (virCommandHandshakeNotify(cmd) < 0)
4925 4926 4927
        goto cleanup;
    VIR_DEBUG("Handshake complete, child running");

4928
    if (migrateFrom)
4929
        flags |= VIR_QEMU_PROCESS_START_PAUSED;
4930 4931 4932 4933 4934 4935 4936

    if (ret == -1) /* The VM failed to start; tear filters before taps */
        virDomainConfVMNWFilterTeardown(vm);

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

4937
    VIR_DEBUG("Setting cgroup for emulator (if required)");
4938
    if (qemuSetupCgroupForEmulator(vm) < 0)
4939 4940 4941 4942 4943 4944
        goto cleanup;

    VIR_DEBUG("Setting affinity of emulator threads");
    if (qemuProcessSetEmulatorAffinity(vm) < 0)
        goto cleanup;

4945
    VIR_DEBUG("Waiting for monitor to show up");
4946
    if (qemuProcessWaitForMonitor(driver, vm, asyncJob, priv->qemuCaps, pos) < 0)
4947 4948
        goto cleanup;

D
Daniel P. Berrange 已提交
4949
    /* Failure to connect to agent shouldn't be fatal */
4950 4951 4952 4953
    if ((ret = qemuConnectAgent(driver, vm)) < 0) {
        if (ret == -2)
            goto cleanup;

D
Daniel P. Berrange 已提交
4954 4955 4956 4957 4958 4959
        VIR_WARN("Cannot connect to QEMU guest agent for %s",
                 vm->def->name);
        virResetLastError();
        priv->agentError = true;
    }

4960
    VIR_DEBUG("Detecting if required emulator features are present");
4961
    if (!qemuProcessVerifyGuestCPU(driver, vm, asyncJob))
4962 4963
        goto cleanup;

4964
    VIR_DEBUG("Setting up post-init cgroup restrictions");
4965
    if (qemuSetupCpusetMems(vm) < 0)
4966 4967
        goto cleanup;

4968
    VIR_DEBUG("Detecting VCPU PIDs");
4969
    if (qemuProcessDetectVcpuPIDs(driver, vm, asyncJob) < 0)
4970 4971
        goto cleanup;

4972 4973 4974 4975
    VIR_DEBUG("Detecting IOThread PIDs");
    if (qemuProcessDetectIOThreadPIDs(driver, vm, asyncJob) < 0)
        goto cleanup;

4976
    VIR_DEBUG("Setting cgroup for each VCPU (if required)");
4977
    if (qemuSetupCgroupForVcpu(vm) < 0)
4978 4979
        goto cleanup;

4980 4981 4982 4983
    VIR_DEBUG("Setting cgroup for each IOThread (if required)");
    if (qemuSetupCgroupForIOThreads(vm) < 0)
        goto cleanup;

4984
    VIR_DEBUG("Setting VCPU affinities");
4985
    if (qemuProcessSetVcpuAffinities(vm) < 0)
4986 4987
        goto cleanup;

4988 4989 4990 4991
    VIR_DEBUG("Setting affinity of IOThread threads");
    if (qemuProcessSetIOThreadsAffinity(vm) < 0)
        goto cleanup;

4992 4993 4994 4995
    VIR_DEBUG("Setting scheduler parameters");
    if (qemuProcessSetSchedulers(vm) < 0)
        goto cleanup;

4996
    VIR_DEBUG("Setting any required VM passwords");
4997
    if (qemuProcessInitPasswords(conn, driver, vm, asyncJob) < 0)
4998 4999 5000 5001
        goto cleanup;

    /* If we have -device, then addresses are assigned explicitly.
     * If not, then we have to detect dynamic ones here */
5002
    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
5003
        VIR_DEBUG("Determining domain device PCI addresses");
5004
        if (qemuProcessInitPCIAddresses(driver, vm, asyncJob) < 0)
5005 5006 5007
            goto cleanup;
    }

5008 5009 5010 5011
    /* set default link states */
    /* qemu doesn't support setting this on the command line, so
     * enter the monitor */
    VIR_DEBUG("Setting network link states");
5012 5013
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        goto cleanup;
5014 5015 5016
    if (qemuProcessSetLinkStates(vm) < 0)
        goto exit_monitor;
    if (qemuDomainObjExitMonitor(driver, vm))
5017 5018
        goto cleanup;

5019
    VIR_DEBUG("Fetching list of active devices");
5020
    if (qemuDomainUpdateDeviceList(driver, vm, asyncJob) < 0)
5021 5022
        goto cleanup;

5023 5024 5025 5026
    VIR_DEBUG("Updating info of memory devices");
    if (qemuDomainUpdateMemoryDeviceInfo(driver, vm, asyncJob) < 0)
        goto cleanup;

5027
    VIR_DEBUG("Setting initial memory amount");
5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043
    if (vm->def->memballoon &&
        vm->def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE) {
        unsigned long long balloon = vm->def->mem.cur_balloon;
        int period = vm->def->memballoon->period;

        if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
            goto cleanup;

        if (period)
            qemuMonitorSetMemoryStatsPeriod(priv->mon, period);

        if (qemuMonitorSetBalloon(priv->mon, balloon) < 0)
            goto exit_monitor;

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

5046
    /* Since CPUs were not started yet, the balloon could not return the memory
5047 5048
     * to the host and thus cur_balloon needs to be updated so that GetXMLdesc
     * and friends return the correct size in case they can't grab the job */
5049 5050
    if (qemuProcessRefreshBalloonState(driver, vm, asyncJob) < 0)
        goto cleanup;
5051

5052 5053 5054 5055
    VIR_DEBUG("Detecting actual memory size for video device");
    if (qemuProcessUpdateVideoRamSize(driver, vm, asyncJob) < 0)
        goto cleanup;

5056
    if (!(flags & VIR_QEMU_PROCESS_START_PAUSED)) {
5057
        VIR_DEBUG("Starting domain CPUs");
5058
        /* Allow the CPUS to start executing */
J
Jiri Denemark 已提交
5059
        if (qemuProcessStartCPUs(driver, vm, conn,
5060 5061
                                 VIR_DOMAIN_RUNNING_BOOTED,
                                 QEMU_ASYNC_JOB_NONE) < 0) {
5062
            if (virGetLastError() == NULL)
5063 5064
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               "%s", _("resume operation failed"));
5065 5066
            goto cleanup;
        }
J
Jiri Denemark 已提交
5067 5068 5069 5070 5071
    } else {
        virDomainObjSetState(vm, VIR_DOMAIN_PAUSED,
                             migrateFrom ?
                             VIR_DOMAIN_PAUSED_MIGRATION :
                             VIR_DOMAIN_PAUSED_USER);
5072 5073
    }

5074
    if (flags & VIR_QEMU_PROCESS_START_AUTODESTROY &&
5075 5076 5077
        qemuProcessAutoDestroyAdd(driver, vm, conn) < 0)
        goto cleanup;

5078
    VIR_DEBUG("Writing domain status to disk");
5079
    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
5080 5081
        goto cleanup;

5082 5083
    /* finally we can call the 'started' hook script if any */
    if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) {
5084
        char *xml = qemuDomainDefFormatXML(driver, vm->def, 0);
5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098
        int hookret;

        hookret = virHookCall(VIR_HOOK_DRIVER_QEMU, vm->def->name,
                              VIR_HOOK_QEMU_OP_STARTED, VIR_HOOK_SUBOP_BEGIN,
                              NULL, xml, NULL);
        VIR_FREE(xml);

        /*
         * If the script raised an error abort the launch
         */
        if (hookret < 0)
            goto cleanup;
    }

5099 5100 5101 5102
    /* Keep watching qemu log for errors during incoming migration, otherwise
     * unset reporting errors from qemu log. */
    if (!migrateFrom)
        qemuMonitorSetDomainLog(priv->mon, -1);
5103

5104 5105
    virCommandFree(cmd);
    VIR_FORCE_CLOSE(logfile);
5106
    virObjectUnref(cfg);
5107
    virObjectUnref(caps);
5108
    VIR_FREE(nicindexes);
5109 5110 5111

    return 0;

5112
 cleanup:
5113 5114 5115
    /* We jump here if we failed to start the VM for any reason, or
     * if we failed to initialize the now running VM. kill it off and
     * pretend we never started it */
5116
    VIR_FREE(tmppath);
5117
    VIR_FREE(nodeset);
5118 5119
    virCommandFree(cmd);
    VIR_FORCE_CLOSE(logfile);
5120 5121
    if (priv->mon)
        qemuMonitorSetDomainLog(priv->mon, -1);
5122
    qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED, stop_flags);
5123
    virObjectUnref(cfg);
5124
    virObjectUnref(caps);
5125
    VIR_FREE(nicindexes);
5126 5127

    return -1;
5128 5129 5130 5131

 exit_monitor:
    ignore_value(qemuDomainObjExitMonitor(driver, vm));
    goto cleanup;
5132 5133 5134
}


5135
int
5136
qemuProcessKill(virDomainObjPtr vm, unsigned int flags)
5137
{
5138
    int ret;
5139

5140 5141 5142
    VIR_DEBUG("vm=%p name=%s pid=%llu flags=%x",
              vm, vm->def->name,
              (unsigned long long)vm->pid, flags);
5143

5144 5145 5146 5147 5148
    if (!(flags & VIR_QEMU_PROCESS_KILL_NOCHECK)) {
        if (!virDomainObjIsActive(vm)) {
            VIR_DEBUG("VM '%s' not active", vm->def->name);
            return 0;
        }
5149 5150
    }

5151
    if (flags & VIR_QEMU_PROCESS_KILL_NOWAIT) {
5152 5153 5154 5155 5156
        virProcessKill(vm->pid,
                       (flags & VIR_QEMU_PROCESS_KILL_FORCE) ?
                       SIGKILL : SIGTERM);
        return 0;
    }
5157

5158 5159
    ret = virProcessKillPainfully(vm->pid,
                                  !!(flags & VIR_QEMU_PROCESS_KILL_FORCE));
5160

5161
    return ret;
5162 5163 5164
}


5165
void qemuProcessStop(virQEMUDriverPtr driver,
5166
                     virDomainObjPtr vm,
5167 5168
                     virDomainShutoffReason reason,
                     unsigned int flags)
5169 5170 5171 5172 5173 5174
{
    int ret;
    int retries = 0;
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virErrorPtr orig_err;
    virDomainDefPtr def;
A
Ansis Atteka 已提交
5175
    virNetDevVPortProfilePtr vport = NULL;
5176
    size_t i;
5177 5178
    int logfile = -1;
    char *timestamp;
5179
    char *tmppath = NULL;
5180
    char ebuf[1024];
5181
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
5182

5183 5184 5185
    VIR_DEBUG("Shutting down vm=%p name=%s id=%d pid=%llu flags=%x",
              vm, vm->def->name, vm->def->id,
              (unsigned long long)vm->pid, flags);
5186 5187 5188

    if (!virDomainObjIsActive(vm)) {
        VIR_DEBUG("VM '%s' not active", vm->def->name);
5189
        virObjectUnref(cfg);
5190 5191 5192
        return;
    }

5193 5194 5195 5196
    /* This method is routinely used in clean up paths. Disable error
     * reporting so we don't squash a legit error. */
    orig_err = virSaveLastError();

5197
    /*
5198 5199
     * We may unlock the vm in qemuProcessKill(), and another thread
     * can lock the vm, and then call qemuProcessStop(). So we should
5200 5201 5202 5203
     * set vm->def->id to -1 here to avoid qemuProcessStop() to be called twice.
     */
    vm->def->id = -1;

5204
    if (virAtomicIntDecAndTest(&driver->nactive) && driver->inhibitCallback)
5205 5206
        driver->inhibitCallback(false, driver->inhibitOpaque);

5207 5208
    /* Wake up anything waiting on domain condition */
    virDomainObjBroadcast(vm);
5209

5210
    if ((logfile = qemuDomainCreateLog(driver, vm, true)) < 0) {
5211 5212 5213
        /* To not break the normal domain shutdown process, skip the
         * timestamp log writing if failed on opening log file. */
        VIR_WARN("Unable to open logfile: %s",
5214
                  virStrerror(errno, ebuf, sizeof(ebuf)));
5215
    } else {
5216
        if ((timestamp = virTimeStringNow()) != NULL) {
5217 5218 5219 5220
            if (safewrite(logfile, timestamp, strlen(timestamp)) < 0 ||
                safewrite(logfile, SHUTDOWN_POSTFIX,
                          strlen(SHUTDOWN_POSTFIX)) < 0) {
                VIR_WARN("Unable to write timestamp to logfile: %s",
5221
                         virStrerror(errno, ebuf, sizeof(ebuf)));
5222 5223 5224 5225 5226 5227 5228
            }

            VIR_FREE(timestamp);
        }

        if (VIR_CLOSE(logfile) < 0)
             VIR_WARN("Unable to close logfile: %s",
5229
                      virStrerror(errno, ebuf, sizeof(ebuf)));
5230 5231
    }

5232 5233 5234
    /* Clear network bandwidth */
    virDomainClearNetBandwidth(vm);

5235 5236
    virDomainConfVMNWFilterTeardown(vm);

5237
    if (cfg->macFilter) {
5238
        def = vm->def;
5239
        for (i = 0; i < def->nnets; i++) {
5240 5241 5242
            virDomainNetDefPtr net = def->nets[i];
            if (net->ifname == NULL)
                continue;
5243 5244 5245
            ignore_value(ebtablesRemoveForwardAllowIn(driver->ebtables,
                                                      net->ifname,
                                                      &net->mac));
5246 5247 5248
        }
    }

5249
    virPortAllocatorRelease(driver->migrationPorts, priv->nbdPort);
5250
    priv->nbdPort = 0;
5251

D
Daniel P. Berrange 已提交
5252 5253 5254 5255 5256 5257
    if (priv->agent) {
        qemuAgentClose(priv->agent);
        priv->agent = NULL;
        priv->agentError = false;
    }

5258
    if (priv->mon) {
5259
        qemuMonitorClose(priv->mon);
5260 5261
        priv->mon = NULL;
    }
5262 5263 5264 5265 5266 5267 5268 5269

    if (priv->monConfig) {
        if (priv->monConfig->type == VIR_DOMAIN_CHR_TYPE_UNIX)
            unlink(priv->monConfig->data.nix.path);
        virDomainChrSourceDefFree(priv->monConfig);
        priv->monConfig = NULL;
    }

5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281
    ignore_value(virAsprintf(&tmppath, "%s/domain-%s",
                             cfg->libDir, vm->def->name));
    if (tmppath)
        virFileDeleteTree(tmppath);
    VIR_FREE(tmppath);

    ignore_value(virAsprintf(&tmppath, "%s/domain-%s",
                             cfg->channelTargetDir, vm->def->name));
    if (tmppath)
        virFileDeleteTree(tmppath);
    VIR_FREE(tmppath);

5282 5283 5284 5285 5286 5287
    ignore_value(virDomainChrDefForeach(vm->def,
                                        false,
                                        qemuProcessCleanupChardevDevice,
                                        NULL));


5288
    /* shut it off for sure */
5289 5290 5291
    ignore_value(qemuProcessKill(vm,
                                 VIR_QEMU_PROCESS_KILL_FORCE|
                                 VIR_QEMU_PROCESS_KILL_NOCHECK));
5292

5293 5294
    qemuDomainCleanupRun(driver, vm);

5295
    /* Stop autodestroy in case guest is restarted */
5296
    qemuProcessAutoDestroyRemove(driver, vm);
5297

5298 5299
    /* now that we know it's stopped call the hook if present */
    if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) {
5300
        char *xml = qemuDomainDefFormatXML(driver, vm->def, 0);
5301 5302 5303

        /* we can't stop the operation even if the script raised an error */
        virHookCall(VIR_HOOK_DRIVER_QEMU, vm->def->name,
5304 5305
                    VIR_HOOK_QEMU_OP_STOPPED, VIR_HOOK_SUBOP_END,
                    NULL, xml, NULL);
5306 5307 5308
        VIR_FREE(xml);
    }

5309 5310 5311 5312
    /* Reset Security Labels unless caller don't want us to */
    if (!(flags & VIR_QEMU_PROCESS_STOP_NO_RELABEL))
        virSecurityManagerRestoreAllLabel(driver->securityManager,
                                          vm->def,
5313
                                          !!(flags & VIR_QEMU_PROCESS_STOP_MIGRATED));
5314
    virSecurityManagerReleaseLabel(driver->securityManager, vm->def);
5315

5316
    for (i = 0; i < vm->def->ndisks; i++) {
5317
        virDomainDeviceDef dev;
5318
        virDomainDiskDefPtr disk = vm->def->disks[i];
5319 5320 5321 5322

        dev.type = VIR_DOMAIN_DEVICE_DISK;
        dev.data.disk = disk;
        ignore_value(qemuRemoveSharedDevice(driver, &dev, vm->def->name));
5323 5324
    }

5325
    /* Clear out dynamically assigned labels */
5326
    for (i = 0; i < vm->def->nseclabels; i++) {
5327
        if (vm->def->seclabels[i]->type == VIR_DOMAIN_SECLABEL_DYNAMIC)
5328 5329
            VIR_FREE(vm->def->seclabels[i]->label);
        VIR_FREE(vm->def->seclabels[i]->imagelabel);
5330 5331
    }

5332 5333 5334
    virStringFreeList(priv->qemuDevices);
    priv->qemuDevices = NULL;

5335 5336 5337
    virDomainDefClearDeviceAliases(vm->def);
    if (!priv->persistentAddrs) {
        virDomainDefClearPCIAddresses(vm->def);
5338
        virDomainPCIAddressSetFree(priv->pciaddrs);
5339
        priv->pciaddrs = NULL;
5340
        virDomainDefClearCCWAddresses(vm->def);
J
Ján Tomko 已提交
5341
        virDomainCCWAddressSetFree(priv->ccwaddrs);
5342
        priv->ccwaddrs = NULL;
5343 5344
        virDomainVirtioSerialAddrSetFree(priv->vioserialaddrs);
        priv->vioserialaddrs = NULL;
5345 5346 5347 5348 5349 5350 5351
    }

    qemuDomainReAttachHostDevices(driver, vm->def);

    def = vm->def;
    for (i = 0; i < def->nnets; i++) {
        virDomainNetDefPtr net = def->nets[i];
5352 5353 5354 5355
        vport = virDomainNetGetActualVirtPortProfile(net);

        switch (virDomainNetGetActualType(net)) {
        case VIR_DOMAIN_NET_TYPE_DIRECT:
5356
            ignore_value(virNetDevMacVLanDeleteWithVPortProfile(
5357
                             net->ifname, &net->mac,
5358 5359
                             virDomainNetGetActualDirectDev(net),
                             virDomainNetGetActualDirectMode(net),
5360
                             virDomainNetGetActualVirtPortProfile(net),
5361
                             cfg->stateDir));
5362
            VIR_FREE(net->ifname);
5363 5364 5365 5366 5367
            break;
        case VIR_DOMAIN_NET_TYPE_BRIDGE:
        case VIR_DOMAIN_NET_TYPE_NETWORK:
#ifdef VIR_NETDEV_TAP_REQUIRE_MANUAL_CLEANUP
            if (!(vport && vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH))
5368
                ignore_value(virNetDevTapDelete(net->ifname, net->backend.tap));
5369 5370
#endif
            break;
5371
        }
5372 5373 5374
        /* release the physical device (or any other resources used by
         * this interface in the network driver
         */
5375 5376 5377 5378 5379 5380 5381 5382 5383
        if (vport) {
            if (vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_MIDONET) {
                ignore_value(virNetDevMidonetUnbindPort(vport));
            } else if (vport->virtPortType == VIR_NETDEV_VPORT_PROFILE_OPENVSWITCH) {
                ignore_value(virNetDevOpenvswitchRemovePort(
                                 virDomainNetGetActualBridgeName(net),
                                 net->ifname));
            }
        }
A
Ansis Atteka 已提交
5384

5385 5386
        /* kick the device out of the hostdev list too */
        virDomainNetRemoveHostdev(def, net);
5387
        networkReleaseActualDevice(vm->def, net);
5388
    }
5389

5390
 retry:
5391
    if ((ret = qemuRemoveCgroup(driver, vm)) < 0) {
5392 5393 5394 5395 5396 5397 5398
        if (ret == -EBUSY && (retries++ < 5)) {
            usleep(200*1000);
            goto retry;
        }
        VIR_WARN("Failed to remove cgroup for %s",
                 vm->def->name);
    }
5399
    virCgroupFree(&priv->cgroup);
5400 5401 5402

    qemuProcessRemoveDomainStatus(driver, vm);

5403 5404
    /* Remove VNC and Spice ports from port reservation bitmap, but only if
       they were reserved by the driver (autoport=yes)
5405
    */
5406
    for (i = 0; i < vm->def->ngraphics; ++i) {
5407
        virDomainGraphicsDefPtr graphics = vm->def->graphics[i];
5408 5409
        if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
            if (graphics->data.vnc.autoport) {
5410 5411
                virPortAllocatorRelease(driver->remotePorts,
                                        graphics->data.vnc.port);
5412
            } else if (graphics->data.vnc.portReserved) {
5413 5414 5415 5416 5417
                virPortAllocatorSetUsed(driver->remotePorts,
                                        graphics->data.spice.port,
                                        false);
                graphics->data.vnc.portReserved = false;
            }
5418 5419
            virPortAllocatorRelease(driver->webSocketPorts,
                                    graphics->data.vnc.websocket);
5420
        }
5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441
        if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
            if (graphics->data.spice.autoport) {
                virPortAllocatorRelease(driver->remotePorts,
                                        graphics->data.spice.port);
                virPortAllocatorRelease(driver->remotePorts,
                                        graphics->data.spice.tlsPort);
            } else {
                if (graphics->data.spice.portReserved) {
                    virPortAllocatorSetUsed(driver->remotePorts,
                                            graphics->data.spice.port,
                                            false);
                    graphics->data.spice.portReserved = false;
                }

                if (graphics->data.spice.tlsPortReserved) {
                    virPortAllocatorSetUsed(driver->remotePorts,
                                            graphics->data.spice.tlsPort,
                                            false);
                    graphics->data.spice.tlsPortReserved = false;
                }
            }
5442
        }
5443 5444
    }

5445
    vm->taint = 0;
5446
    vm->pid = -1;
J
Jiri Denemark 已提交
5447
    virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason);
5448 5449
    VIR_FREE(priv->vcpupids);
    priv->nvcpupids = 0;
5450 5451
    for (i = 0; i < vm->def->niothreadids; i++)
        vm->def->iothreadids[i]->thread_id = 0;
5452 5453
    virObjectUnref(priv->qemuCaps);
    priv->qemuCaps = NULL;
5454
    VIR_FREE(priv->pidfile);
5455

5456
    /* The "release" hook cleans up additional resources */
5457
    if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) {
5458
        char *xml = qemuDomainDefFormatXML(driver, vm->def, 0);
5459 5460 5461

        /* we can't stop the operation even if the script raised an error */
        virHookCall(VIR_HOOK_DRIVER_QEMU, vm->def->name,
5462 5463
                    VIR_HOOK_QEMU_OP_RELEASE, VIR_HOOK_SUBOP_END,
                    NULL, xml, NULL);
5464 5465 5466
        VIR_FREE(xml);
    }

5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477
    if (vm->newDef) {
        virDomainDefFree(vm->def);
        vm->def = vm->newDef;
        vm->def->id = -1;
        vm->newDef = NULL;
    }

    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
    }
5478
    virObjectUnref(cfg);
5479
}
5480 5481


5482
int qemuProcessAttach(virConnectPtr conn ATTRIBUTE_UNUSED,
5483
                      virQEMUDriverPtr driver,
5484
                      virDomainObjPtr vm,
5485
                      pid_t pid,
5486 5487 5488 5489
                      const char *pidfile,
                      virDomainChrSourceDefPtr monConfig,
                      bool monJSON)
{
5490
    size_t i;
5491 5492 5493 5494 5495
    char ebuf[1024];
    int logfile = -1;
    char *timestamp;
    qemuDomainObjPrivatePtr priv = vm->privateData;
    bool running = true;
5496
    virDomainPausedReason reason;
5497
    virSecurityLabelPtr seclabel = NULL;
5498
    virSecurityLabelDefPtr seclabeldef = NULL;
5499
    bool seclabelgen = false;
5500 5501
    virSecurityManagerPtr* sec_managers = NULL;
    const char *model;
5502
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
5503
    virCapsPtr caps = NULL;
5504
    bool active = false;
5505
    int ret;
5506 5507 5508 5509

    VIR_DEBUG("Beginning VM attach process");

    if (virDomainObjIsActive(vm)) {
5510 5511
        virReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("VM is already active"));
5512
        virObjectUnref(cfg);
5513 5514 5515
        return -1;
    }

5516
    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
5517
        goto error;
5518

5519 5520 5521 5522 5523
    /* Do this upfront, so any part of the startup process can add
     * runtime state to vm->def that won't be persisted. This let's us
     * report implicit runtime defaults in the XML, like vnc listen/socket
     */
    VIR_DEBUG("Setting current domain def as transient");
5524
    if (virDomainObjSetDefTransient(caps, driver->xmlopt, vm, true) < 0)
5525
        goto error;
5526

5527
    vm->def->id = qemuDriverAllocateID(driver);
5528

5529
    if (virAtomicIntInc(&driver->nactive) == 1 && driver->inhibitCallback)
5530
        driver->inhibitCallback(true, driver->inhibitOpaque);
5531
    active = true;
5532

5533
    if (virFileMakePath(cfg->logDir) < 0) {
5534 5535
        virReportSystemError(errno,
                             _("cannot create log directory %s"),
5536
                             cfg->logDir);
5537
        goto error;
5538 5539 5540
    }

    VIR_FREE(priv->pidfile);
5541
    if (VIR_STRDUP(priv->pidfile, pidfile) < 0)
5542
        goto error;
5543

5544 5545
    vm->pid = pid;

5546
    VIR_DEBUG("Detect security driver config");
5547
    sec_managers = virSecurityManagerGetNested(driver->securityManager);
5548 5549
    if (sec_managers == NULL)
        goto error;
5550 5551

    for (i = 0; sec_managers[i]; i++) {
5552
        seclabelgen = false;
5553 5554
        model = virSecurityManagerGetModel(sec_managers[i]);
        seclabeldef = virDomainDefGetSecurityLabelDef(vm->def, model);
5555
        if (seclabeldef == NULL) {
5556
            if (!(seclabeldef = virSecurityLabelDefNew(model)))
5557 5558 5559
                goto error;
            seclabelgen = true;
        }
5560 5561
        seclabeldef->type = VIR_DOMAIN_SECLABEL_STATIC;
        if (VIR_ALLOC(seclabel) < 0)
5562
            goto error;
5563
        if (virSecurityManagerGetProcessLabel(sec_managers[i],
5564
                                              vm->def, vm->pid, seclabel) < 0)
5565
            goto error;
5566

5567
        if (VIR_STRDUP(seclabeldef->model, model) < 0)
5568
            goto error;
5569

5570
        if (VIR_STRDUP(seclabeldef->label, seclabel->label) < 0)
5571
            goto error;
5572
        VIR_FREE(seclabel);
5573 5574 5575 5576 5577 5578

        if (seclabelgen) {
            if (VIR_APPEND_ELEMENT(vm->def->seclabels, vm->def->nseclabels, seclabeldef) < 0)
                goto error;
            seclabelgen = false;
        }
5579
    }
5580

5581 5582
    if (virSecurityManagerCheckAllLabel(driver->securityManager, vm->def) < 0)
        goto error;
5583 5584 5585
    if (virSecurityManagerGenLabel(driver->securityManager, vm->def) < 0)
        goto error;

5586 5587
    VIR_DEBUG("Creating domain log file");
    if ((logfile = qemuDomainCreateLog(driver, vm, false)) < 0)
5588
        goto error;
5589 5590

    VIR_DEBUG("Determining emulator version");
5591 5592
    virObjectUnref(priv->qemuCaps);
    if (!(priv->qemuCaps = virQEMUCapsCacheLookupCopy(driver->qemuCapsCache,
5593 5594
                                                      vm->def->emulator,
                                                      vm->def->os.machine)))
5595
        goto error;
5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607

    VIR_DEBUG("Preparing monitor state");
    priv->monConfig = monConfig;
    monConfig = NULL;
    priv->monJSON = monJSON;

    priv->gotShutdown = false;

    /*
     * Normally PCI addresses are assigned in the virDomainCreate
     * or virDomainDefine methods. We might still need to assign
     * some here to cope with the question of upgrades. Regardless
M
Martin Kletzander 已提交
5608
     * we also need to populate the PCI address set cache for later
5609 5610
     * use in hotplug
     */
5611
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
5612
        VIR_DEBUG("Assigning domain PCI addresses");
5613
        if ((qemuDomainAssignAddresses(vm->def, priv->qemuCaps, vm)) < 0)
5614
            goto error;
5615 5616
    }

5617
    if ((timestamp = virTimeStringNow()) == NULL) {
5618
        goto error;
5619 5620 5621 5622
    } else {
        if (safewrite(logfile, timestamp, strlen(timestamp)) < 0 ||
            safewrite(logfile, ATTACH_POSTFIX, strlen(ATTACH_POSTFIX)) < 0) {
            VIR_WARN("Unable to write timestamp to logfile: %s",
5623
                     virStrerror(errno, ebuf, sizeof(ebuf)));
5624 5625 5626 5627 5628 5629 5630 5631
        }

        VIR_FREE(timestamp);
    }

    qemuDomainObjTaint(driver, vm, VIR_DOMAIN_TAINT_EXTERNAL_LAUNCH, logfile);

    VIR_DEBUG("Waiting for monitor to show up");
5632
    if (qemuProcessWaitForMonitor(driver, vm, QEMU_ASYNC_JOB_NONE, priv->qemuCaps, -1) < 0)
5633
        goto error;
5634

D
Daniel P. Berrange 已提交
5635
    /* Failure to connect to agent shouldn't be fatal */
5636 5637 5638 5639
    if ((ret = qemuConnectAgent(driver, vm)) < 0) {
        if (ret == -2)
            goto error;

D
Daniel P. Berrange 已提交
5640 5641 5642 5643 5644 5645
        VIR_WARN("Cannot connect to QEMU guest agent for %s",
                 vm->def->name);
        virResetLastError();
        priv->agentError = true;
    }

5646
    VIR_DEBUG("Detecting VCPU PIDs");
5647
    if (qemuProcessDetectVcpuPIDs(driver, vm, QEMU_ASYNC_JOB_NONE) < 0)
5648 5649 5650 5651
        goto error;

    VIR_DEBUG("Detecting IOThread PIDs");
    if (qemuProcessDetectIOThreadPIDs(driver, vm, QEMU_ASYNC_JOB_NONE) < 0)
5652
        goto error;
5653 5654 5655

    /* If we have -device, then addresses are assigned explicitly.
     * If not, then we have to detect dynamic ones here */
5656
    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
5657
        VIR_DEBUG("Determining domain device PCI addresses");
5658
        if (qemuProcessInitPCIAddresses(driver, vm, QEMU_ASYNC_JOB_NONE) < 0)
5659
            goto error;
5660 5661 5662
    }

    VIR_DEBUG("Getting initial memory amount");
5663
    qemuDomainObjEnterMonitor(driver, vm);
5664 5665 5666 5667 5668 5669 5670
    if (qemuMonitorGetBalloonInfo(priv->mon, &vm->def->mem.cur_balloon) < 0)
        goto exit_monitor;
    if (qemuMonitorGetStatus(priv->mon, &running, &reason) < 0)
        goto exit_monitor;
    if (qemuMonitorGetVirtType(priv->mon, &vm->def->virtType) < 0)
        goto exit_monitor;
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
5671
        goto error;
5672

5673
    if (running) {
5674 5675
        virDomainObjSetState(vm, VIR_DOMAIN_RUNNING,
                             VIR_DOMAIN_RUNNING_UNPAUSED);
5676 5677 5678
        if (vm->def->memballoon &&
            vm->def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO &&
            vm->def->memballoon->period) {
5679 5680 5681
            qemuDomainObjEnterMonitor(driver, vm);
            qemuMonitorSetMemoryStatsPeriod(priv->mon,
                                            vm->def->memballoon->period);
5682 5683
            if (qemuDomainObjExitMonitor(driver, vm) < 0)
                goto error;
5684 5685
        }
    } else {
5686
        virDomainObjSetState(vm, VIR_DOMAIN_PAUSED, reason);
5687
    }
5688 5689

    VIR_DEBUG("Writing domain status to disk");
5690
    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm) < 0)
5691
        goto error;
5692

5693 5694
    /* Run an hook to allow admins to do some magic */
    if (virHookPresent(VIR_HOOK_DRIVER_QEMU)) {
5695
        char *xml = qemuDomainDefFormatXML(driver, vm->def, 0);
5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706
        int hookret;

        hookret = virHookCall(VIR_HOOK_DRIVER_QEMU, vm->def->name,
                              VIR_HOOK_QEMU_OP_ATTACH, VIR_HOOK_SUBOP_BEGIN,
                              NULL, xml, NULL);
        VIR_FREE(xml);

        /*
         * If the script raised an error abort the launch
         */
        if (hookret < 0)
5707
            goto error;
5708 5709
    }

5710 5711
    VIR_FORCE_CLOSE(logfile);
    VIR_FREE(seclabel);
5712
    VIR_FREE(sec_managers);
5713
    virObjectUnref(cfg);
5714
    virObjectUnref(caps);
5715 5716 5717

    return 0;

5718 5719
 exit_monitor:
    ignore_value(qemuDomainObjExitMonitor(driver, vm));
5720
 error:
5721 5722 5723 5724 5725 5726
    /* We jump here if we failed to attach to the VM for any reason.
     * Leave the domain running, but pretend we never attempted to
     * attach to it.  */
    if (active && virAtomicIntDecAndTest(&driver->nactive) &&
        driver->inhibitCallback)
        driver->inhibitCallback(false, driver->inhibitOpaque);
5727 5728
    VIR_FORCE_CLOSE(logfile);
    VIR_FREE(seclabel);
5729
    VIR_FREE(sec_managers);
5730 5731
    if (seclabelgen)
        virSecurityLabelDefFree(seclabeldef);
5732
    virDomainChrSourceDefFree(monConfig);
5733
    virObjectUnref(cfg);
5734
    virObjectUnref(caps);
5735 5736 5737 5738
    return -1;
}


5739
static virDomainObjPtr
5740 5741 5742
qemuProcessAutoDestroy(virDomainObjPtr dom,
                       virConnectPtr conn,
                       void *opaque)
5743
{
5744
    virQEMUDriverPtr driver = opaque;
5745
    qemuDomainObjPrivatePtr priv = dom->privateData;
5746
    virObjectEventPtr event = NULL;
5747
    unsigned int stopFlags = 0;
5748

5749
    VIR_DEBUG("vm=%s, conn=%p", dom->def->name, conn);
5750

5751 5752
    virObjectRef(dom);

5753 5754 5755
    if (priv->job.asyncJob == QEMU_ASYNC_JOB_MIGRATION_IN)
        stopFlags |= VIR_QEMU_PROCESS_STOP_MIGRATED;

5756 5757
    if (priv->job.asyncJob) {
        VIR_DEBUG("vm=%s has long-term job active, cancelling",
5758
                  dom->def->name);
5759
        qemuDomainObjDiscardAsyncJob(driver, dom);
5760 5761
    }

5762 5763
    if (qemuDomainObjBeginJob(driver, dom,
                              QEMU_JOB_DESTROY) < 0)
5764 5765 5766
        goto cleanup;

    VIR_DEBUG("Killing domain");
5767

5768
    qemuProcessStop(driver, dom, VIR_DOMAIN_SHUTOFF_DESTROYED, stopFlags);
5769

5770
    virDomainAuditStop(dom, "destroyed");
5771
    event = virDomainEventLifecycleNewFromObj(dom,
5772 5773
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
5774

5775 5776
    qemuDomainObjEndJob(driver, dom);

5777
    if (!dom->persistent)
5778
        qemuDomainRemoveInactive(driver, dom);
5779

5780
    if (event)
5781
        qemuDomainEventQueue(driver, event);
5782

5783
 cleanup:
5784
    virDomainObjEndAPI(&dom);
5785
    return dom;
5786 5787
}

5788
int qemuProcessAutoDestroyAdd(virQEMUDriverPtr driver,
5789 5790 5791
                              virDomainObjPtr vm,
                              virConnectPtr conn)
{
5792
    VIR_DEBUG("vm=%s, conn=%p", vm->def->name, conn);
5793 5794
    return virCloseCallbacksSet(driver->closeCallbacks, vm, conn,
                                qemuProcessAutoDestroy);
5795 5796
}

5797
int qemuProcessAutoDestroyRemove(virQEMUDriverPtr driver,
5798 5799
                                 virDomainObjPtr vm)
{
5800
    int ret;
5801
    VIR_DEBUG("vm=%s", vm->def->name);
5802 5803 5804
    ret = virCloseCallbacksUnset(driver->closeCallbacks, vm,
                                 qemuProcessAutoDestroy);
    return ret;
5805
}
5806

5807
bool qemuProcessAutoDestroyActive(virQEMUDriverPtr driver,
5808 5809
                                  virDomainObjPtr vm)
{
5810
    virCloseCallback cb;
5811
    VIR_DEBUG("vm=%s", vm->def->name);
5812
    cb = virCloseCallbacksGet(driver->closeCallbacks, vm, NULL);
5813
    return cb == qemuProcessAutoDestroy;
5814
}