uml_driver.c 72.5 KB
Newer Older
1 2 3
/*
 * uml_driver.c: core driver methods for managing UML guests
 *
4
 * Copyright (C) 2006-2011 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
 * Copyright (C) 2006-2008 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#include <config.h>

#include <sys/types.h>
#include <sys/poll.h>
#include <dirent.h>
#include <limits.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/utsname.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <paths.h>
#include <pwd.h>
#include <stdio.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <sys/inotify.h>
46
#include <sys/un.h>
47 48 49 50 51 52 53 54 55 56 57

#include "uml_driver.h"
#include "uml_conf.h"
#include "buf.h"
#include "util.h"
#include "nodeinfo.h"
#include "stats_linux.h"
#include "capabilities.h"
#include "memory.h"
#include "uuid.h"
#include "domain_conf.h"
58
#include "domain_audit.h"
59
#include "datatypes.h"
60
#include "logging.h"
61
#include "domain_nwfilter.h"
E
Eric Blake 已提交
62
#include "virfile.h"
63
#include "fdstream.h"
64
#include "configmake.h"
65

66 67
#define VIR_FROM_THIS VIR_FROM_UML

68
/* For storing short-lived temporary files. */
69
#define TEMPDIR LOCALSTATEDIR "/cache/libvirt"
70

71 72 73 74 75 76 77
typedef struct _umlDomainObjPrivate umlDomainObjPrivate;
typedef umlDomainObjPrivate *umlDomainObjPrivatePtr;
struct _umlDomainObjPrivate {
    int monitor;
    int monitorWatch;
};

78 79 80 81 82 83 84 85 86 87
static int umlProcessAutoDestroyInit(struct uml_driver *driver);
static void umlProcessAutoDestroyRun(struct uml_driver *driver,
                                     virConnectPtr conn);
static void umlProcessAutoDestroyShutdown(struct uml_driver *driver);
static int umlProcessAutoDestroyAdd(struct uml_driver *driver,
                                    virDomainObjPtr vm,
                                    virConnectPtr conn);
static int umlProcessAutoDestroyRemove(struct uml_driver *driver,
                                       virDomainObjPtr vm);

88

89 90
static int umlShutdown(void);

91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
static void *umlDomainObjPrivateAlloc(void)
{
    umlDomainObjPrivatePtr priv;

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

    priv->monitor = -1;
    priv->monitorWatch = -1;

    return priv;
}

static void umlDomainObjPrivateFree(void *data)
{
    umlDomainObjPrivatePtr priv = data;

    VIR_FREE(priv);
}


112 113
static void umlDriverLock(struct uml_driver *driver)
{
114
    virMutexLock(&driver->lock);
115 116 117
}
static void umlDriverUnlock(struct uml_driver *driver)
{
118
    virMutexUnlock(&driver->lock);
119 120
}

121

122
static int umlOpenMonitor(struct uml_driver *driver,
123
                          virDomainObjPtr vm);
124
static int umlReadPidFile(struct uml_driver *driver,
125
                          virDomainObjPtr vm);
126 127 128
static void umlDomainEventFlush(int timer, void *opaque);
static void umlDomainEventQueue(struct uml_driver *driver,
                                virDomainEventPtr event);
129 130 131

static int umlStartVMDaemon(virConnectPtr conn,
                            struct uml_driver *driver,
132 133
                            virDomainObjPtr vm,
                            bool autoDestroy);
134

135
static void umlShutdownVMDaemon(struct uml_driver *driver,
J
Jiri Denemark 已提交
136 137
                                virDomainObjPtr vm,
                                virDomainShutoffReason reason);
138 139


140 141 142 143
static int umlMonitorCommand(const struct uml_driver *driver,
                             const virDomainObjPtr vm,
                             const char *cmd,
                             char **reply);
144 145 146

static struct uml_driver *uml_driver = NULL;

147 148 149 150 151 152
struct umlAutostartData {
    struct uml_driver *driver;
    virConnectPtr conn;
};

static void
153
umlAutostartDomain(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque)
154 155 156 157 158 159
{
    virDomainObjPtr vm = payload;
    const struct umlAutostartData *data = opaque;

    virDomainObjLock(vm);
    if (vm->autostart &&
D
Daniel P. Berrange 已提交
160
        !virDomainObjIsActive(vm)) {
161
        int ret;
162
        virResetLastError();
163
        ret = umlStartVMDaemon(data->conn, data->driver, vm, false);
164 165
        virDomainAuditStart(vm, "booted", ret >= 0);
        if (ret < 0) {
166 167
            virErrorPtr err = virGetLastError();
            VIR_ERROR(_("Failed to autostart VM '%s': %s"),
168
                      vm->def->name, err ? err->message : _("unknown error"));
169 170 171 172 173 174 175
        } else {
            virDomainEventPtr event =
                virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STARTED,
                                         VIR_DOMAIN_EVENT_STARTED_BOOTED);
            if (event)
                umlDomainEventQueue(data->driver, event);
176 177 178 179
        }
    }
    virDomainObjUnlock(vm);
}
180 181 182

static void
umlAutostartConfigs(struct uml_driver *driver) {
183 184 185 186 187
    /* XXX: Figure out a better way todo this. The domain
     * startup code needs a connection handle in order
     * to lookup the bridge associated with a virtual
     * network
     */
188 189 190
    virConnectPtr conn = virConnectOpen(driver->privileged ?
                                        "uml:///system" :
                                        "uml:///session");
191
    /* Ignoring NULL conn which is mostly harmless here */
192

193 194
    struct umlAutostartData data = { driver, conn };

195
    umlDriverLock(driver);
196
    virHashForEach(driver->domains.objs, umlAutostartDomain, &data);
197
    umlDriverUnlock(driver);
198

199 200
    if (conn)
        virConnectClose(conn);
201 202 203 204
}


static int
205
umlIdentifyOneChrPTY(struct uml_driver *driver,
206 207 208 209 210 211 212
                     virDomainObjPtr dom,
                     virDomainChrDefPtr def,
                     const char *dev)
{
    char *cmd;
    char *res = NULL;
    int retries = 0;
213
    if (virAsprintf(&cmd, "config %s%d", dev, def->target.port) < 0) {
214
        virReportOOMError();
215 216 217
        return -1;
    }
requery:
218
    if (umlMonitorCommand(driver, dom, cmd, &res) < 0)
219
        return -1;
220

221
    if (res && STRPREFIX(res, "pts:")) {
222 223
        VIR_FREE(def->source.data.file.path);
        if ((def->source.data.file.path = strdup(res + 4)) == NULL) {
224
            virReportOOMError();
225 226 227 228
            VIR_FREE(res);
            VIR_FREE(cmd);
            return -1;
        }
229
    } else if (!res || STRPREFIX(res, "pts")) {
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
        /* It can take a while to startup, so retry for
           upto 5 seconds */
        /* XXX should do this in a better non-blocking
           way somehow ...perhaps register a timer */
        if (retries++ < 50) {
            usleep(1000*10);
            goto requery;
        }
    }

    VIR_FREE(cmd);
    VIR_FREE(res);
    return 0;
}

static int
246
umlIdentifyChrPTY(struct uml_driver *driver,
247 248 249 250
                  virDomainObjPtr dom)
{
    int i;

251 252
    for (i = 0 ; i < dom->def->nserials; i++)
        if (dom->def->consoles[i]->source.type == VIR_DOMAIN_CHR_TYPE_PTY)
253
        if (umlIdentifyOneChrPTY(driver, dom,
254
                                 dom->def->consoles[i], "con") < 0)
255 256 257
            return -1;

    for (i = 0 ; i < dom->def->nserials; i++)
258
        if (dom->def->serials[i]->source.type == VIR_DOMAIN_CHR_TYPE_PTY &&
259
            umlIdentifyOneChrPTY(driver, dom,
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
                                 dom->def->serials[i], "ssl") < 0)
            return -1;

    return 0;
}

static void
umlInotifyEvent(int watch,
                int fd,
                int events ATTRIBUTE_UNUSED,
                void *data)
{
    char buf[1024];
    struct inotify_event *e;
    int got;
    char *tmp, *name;
    struct uml_driver *driver = data;
    virDomainObjPtr dom;
278
    virDomainEventPtr event = NULL;
279

280
    umlDriverLock(driver);
281
    if (watch != driver->inotifyWatch)
282
        goto cleanup;
283 284 285 286 287 288

reread:
    got = read(fd, buf, sizeof(buf));
    if (got == -1) {
        if (errno == EINTR)
            goto reread;
289
        goto cleanup;
290 291 292 293 294
    }

    tmp = buf;
    while (got) {
        if (got < sizeof(struct inotify_event))
295
            goto cleanup; /* bad */
296 297 298 299 300 301

        e = (struct inotify_event *)tmp;
        tmp += sizeof(struct inotify_event);
        got -= sizeof(struct inotify_event);

        if (got < e->len)
302
            goto cleanup;
303 304 305 306 307 308 309 310 311 312 313 314 315

        tmp += e->len;
        got -= e->len;

        name = (char *)&(e->name);

        dom = virDomainFindByName(&driver->domains, name);

        if (!dom) {
            continue;
        }

        if (e->mask & IN_DELETE) {
316
            VIR_DEBUG("Got inotify domain shutdown '%s'", name);
D
Daniel P. Berrange 已提交
317
            if (!virDomainObjIsActive(dom)) {
318
                virDomainObjUnlock(dom);
319 320 321
                continue;
            }

322
            umlShutdownVMDaemon(driver, dom, VIR_DOMAIN_SHUTOFF_SHUTDOWN);
323
            virDomainAuditStop(dom, "shutdown");
324 325 326
            event = virDomainEventNewFromObj(dom,
                                             VIR_DOMAIN_EVENT_STOPPED,
                                             VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN);
327 328 329 330 331
            if (!dom->persistent) {
                virDomainRemoveInactive(&driver->domains,
                                        dom);
                dom = NULL;
            }
332
        } else if (e->mask & (IN_CREATE | IN_MODIFY)) {
333
            VIR_DEBUG("Got inotify domain startup '%s'", name);
D
Daniel P. Berrange 已提交
334
            if (virDomainObjIsActive(dom)) {
335
                virDomainObjUnlock(dom);
336 337 338
                continue;
            }

339
            if (umlReadPidFile(driver, dom) < 0) {
340
                virDomainObjUnlock(dom);
341 342 343 344
                continue;
            }

            dom->def->id = driver->nextvmid++;
J
Jiri Denemark 已提交
345 346
            virDomainObjSetState(dom, VIR_DOMAIN_RUNNING,
                                 VIR_DOMAIN_RUNNING_BOOTED);
347

348
            if (umlOpenMonitor(driver, dom) < 0) {
349
                VIR_WARN("Could not open monitor for new domain");
350
                umlShutdownVMDaemon(driver, dom,
J
Jiri Denemark 已提交
351
                                    VIR_DOMAIN_SHUTOFF_FAILED);
352
                virDomainAuditStop(dom, "failed");
353 354 355
                event = virDomainEventNewFromObj(dom,
                                                 VIR_DOMAIN_EVENT_STOPPED,
                                                 VIR_DOMAIN_EVENT_STOPPED_FAILED);
356 357 358 359 360
                if (!dom->persistent) {
                    virDomainRemoveInactive(&driver->domains,
                                            dom);
                    dom = NULL;
                }
361
            } else if (umlIdentifyChrPTY(driver, dom) < 0) {
362
                VIR_WARN("Could not identify character devices for new domain");
363
                umlShutdownVMDaemon(driver, dom,
J
Jiri Denemark 已提交
364
                                    VIR_DOMAIN_SHUTOFF_FAILED);
365
                virDomainAuditStop(dom, "failed");
366 367 368
                event = virDomainEventNewFromObj(dom,
                                                 VIR_DOMAIN_EVENT_STOPPED,
                                                 VIR_DOMAIN_EVENT_STOPPED_FAILED);
369 370 371 372 373
                if (!dom->persistent) {
                    virDomainRemoveInactive(&driver->domains,
                                            dom);
                    dom = NULL;
                }
374
            }
375
        }
376 377
        if (dom)
            virDomainObjUnlock(dom);
378
    }
379 380

cleanup:
381 382
    if (event)
        umlDomainEventQueue(driver, event);
383
    umlDriverUnlock(driver);
384 385 386 387 388 389 390 391
}

/**
 * umlStartup:
 *
 * Initialization function for the Uml daemon
 */
static int
392 393
umlStartup(int privileged)
{
394 395
    uid_t uid = geteuid();
    char *base = NULL;
396
    char *userdir = NULL;
397 398 399 400

    if (VIR_ALLOC(uml_driver) < 0)
        return -1;

401 402
    uml_driver->privileged = privileged;

403 404 405 406
    if (virMutexInit(&uml_driver->lock) < 0) {
        VIR_FREE(uml_driver);
        return -1;
    }
407 408
    umlDriverLock(uml_driver);

409 410
    /* Don't have a dom0 so start from 1 */
    uml_driver->nextvmid = 1;
411
    uml_driver->inotifyWatch = -1;
412

413 414 415
    if (virDomainObjListInit(&uml_driver->domains) < 0)
        goto error;

416 417 418 419 420 421 422
    uml_driver->domainEventState = virDomainEventStateNew(umlDomainEventFlush,
                                                          uml_driver,
                                                          NULL,
                                                          true);
    if (!uml_driver->domainEventState)
        goto error;

423
    userdir = virGetUserDirectory(uid);
424
    if (!userdir)
425
        goto error;
426

427
    if (privileged) {
428
        if (virAsprintf(&uml_driver->logDir,
429
                        "%s/log/libvirt/uml", LOCALSTATEDIR) == -1)
430 431
            goto out_of_memory;

432
        if ((base = strdup (SYSCONFDIR "/libvirt")) == NULL)
433
            goto out_of_memory;
434 435

        if (virAsprintf(&uml_driver->monitorDir,
436
                        "%s/run/libvirt/uml-guest", LOCALSTATEDIR) == -1)
437
            goto out_of_memory;
438
    } else {
439

440
        if (virAsprintf(&uml_driver->logDir,
441
                        "%s/.libvirt/uml/log", userdir) == -1)
442 443
            goto out_of_memory;

444
        if (virAsprintf(&base, "%s/.libvirt", userdir) == -1)
445 446
            goto out_of_memory;

447 448 449 450
        if (virAsprintf(&uml_driver->monitorDir,
                        "%s/.uml", userdir) == -1)
            goto out_of_memory;
    }
451 452 453 454

    /* Configuration paths are either ~/.libvirt/uml/... (session) or
     * /etc/libvirt/uml/... (system).
     */
455
    if (virAsprintf(&uml_driver->configDir, "%s/uml", base) == -1)
456 457
        goto out_of_memory;

458
    if (virAsprintf(&uml_driver->autostartDir, "%s/uml/autostart", base) == -1)
459 460 461 462 463 464 465
        goto out_of_memory;

    VIR_FREE(base);

    if ((uml_driver->caps = umlCapsInit()) == NULL)
        goto out_of_memory;

466 467
    uml_driver->caps->privateDataAllocFunc = umlDomainObjPrivateAlloc;
    uml_driver->caps->privateDataFreeFunc = umlDomainObjPrivateFree;
468 469

    if ((uml_driver->inotifyFD = inotify_init()) < 0) {
470
        VIR_ERROR(_("cannot initialize inotify"));
471
        goto error;
472 473
    }

474
    if (virFileMakePath(uml_driver->monitorDir) < 0) {
475
        char ebuf[1024];
D
Daniel Veillard 已提交
476
        VIR_ERROR(_("Failed to create monitor directory %s: %s"),
477
               uml_driver->monitorDir, virStrerror(errno, ebuf, sizeof ebuf));
478
        goto error;
479 480
    }

481
    VIR_INFO("Adding inotify watch on %s", uml_driver->monitorDir);
482 483 484
    if (inotify_add_watch(uml_driver->inotifyFD,
                          uml_driver->monitorDir,
                          IN_CREATE | IN_MODIFY | IN_DELETE) < 0) {
485
        goto error;
486 487
    }

488 489
    if ((uml_driver->inotifyWatch =
         virEventAddHandle(uml_driver->inotifyFD, POLLIN,
490 491
                           umlInotifyEvent, uml_driver, NULL)) < 0)
        goto error;
492

493 494 495
    if (umlProcessAutoDestroyInit(uml_driver) < 0)
        goto error;

496
    if (virDomainLoadAllConfigs(uml_driver->caps,
497 498 499
                                &uml_driver->domains,
                                uml_driver->configDir,
                                uml_driver->autostartDir,
M
Matthias Bolte 已提交
500 501
                                0, 1 << VIR_DOMAIN_VIRT_UML,
                                NULL, NULL) < 0)
502 503
        goto error;

504 505
    umlDriverUnlock(uml_driver);

506 507
    umlAutostartConfigs(uml_driver);

508 509
    VIR_FREE(userdir);

510 511
    return 0;

512
out_of_memory:
513
    VIR_ERROR(_("umlStartup: out of memory"));
514 515

error:
516
    VIR_FREE(userdir);
517
    VIR_FREE(base);
518 519
    umlDriverUnlock(uml_driver);
    umlShutdown();
520 521 522
    return -1;
}

523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
static void umlNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
{
    struct uml_driver *driver = opaque;

    if (newVM) {
        virDomainEventPtr event =
            virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_DEFINED,
                                     VIR_DOMAIN_EVENT_DEFINED_ADDED);
        if (event)
            umlDomainEventQueue(driver, event);
    }
}


538 539 540 541 542 543 544 545 546 547 548
/**
 * umlReload:
 *
 * Function to restart the Uml daemon, it will recheck the configuration
 * files and update its state and the networking
 */
static int
umlReload(void) {
    if (!uml_driver)
        return 0;

549
    umlDriverLock(uml_driver);
550
    virDomainLoadAllConfigs(uml_driver->caps,
551 552 553
                            &uml_driver->domains,
                            uml_driver->configDir,
                            uml_driver->autostartDir,
M
Matthias Bolte 已提交
554
                            0, 1 << VIR_DOMAIN_VIRT_UML,
555 556
                            umlNotifyLoadDomain, uml_driver);
    umlDriverUnlock(uml_driver);
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572

    umlAutostartConfigs(uml_driver);

    return 0;
}

/**
 * umlActive:
 *
 * Checks if the Uml daemon is active, i.e. has an active domain or
 * an active network
 *
 * Returns 1 if active, 0 otherwise
 */
static int
umlActive(void) {
573
    int active = 0;
574 575 576 577

    if (!uml_driver)
        return 0;

578
    umlDriverLock(uml_driver);
579
    active = virDomainObjListNumOfDomains(&uml_driver->domains, 1);
580
    umlDriverUnlock(uml_driver);
581

582
    return active;
583 584
}

585
static void
586
umlShutdownOneVM(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque)
587 588 589 590 591
{
    virDomainObjPtr dom = payload;
    struct uml_driver *driver = opaque;

    virDomainObjLock(dom);
592
    if (virDomainObjIsActive(dom)) {
593
        umlShutdownVMDaemon(driver, dom, VIR_DOMAIN_SHUTOFF_SHUTDOWN);
594 595
        virDomainAuditStop(dom, "shutdown");
    }
596 597 598
    virDomainObjUnlock(dom);
}

599 600 601 602 603 604 605 606 607 608
/**
 * umlShutdown:
 *
 * Shutdown the Uml daemon, it will stop all active domains and networks
 */
static int
umlShutdown(void) {
    if (!uml_driver)
        return -1;

609
    umlDriverLock(uml_driver);
610 611
    if (uml_driver->inotifyWatch != -1)
        virEventRemoveHandle(uml_driver->inotifyWatch);
612
    VIR_FORCE_CLOSE(uml_driver->inotifyFD);
613 614
    virCapabilitiesFree(uml_driver->caps);

615 616 617
    /* shutdown active VMs
     * XXX allow them to stay around & reconnect */
    virHashForEach(uml_driver->domains.objs, umlShutdownOneVM, uml_driver);
618

619
    virDomainObjListDeinit(&uml_driver->domains);
620

621 622
    virDomainEventStateFree(uml_driver->domainEventState);

623 624 625 626 627
    VIR_FREE(uml_driver->logDir);
    VIR_FREE(uml_driver->configDir);
    VIR_FREE(uml_driver->autostartDir);
    VIR_FREE(uml_driver->monitorDir);

628 629
    umlProcessAutoDestroyShutdown(uml_driver);

630
    umlDriverUnlock(uml_driver);
631
    virMutexDestroy(&uml_driver->lock);
632 633 634 635 636 637
    VIR_FREE(uml_driver);

    return 0;
}


638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
static int umlProcessAutoDestroyInit(struct uml_driver *driver)
{
    if (!(driver->autodestroy = virHashCreate(5, NULL)))
        return -1;

    return 0;
}

struct umlProcessAutoDestroyData {
    struct uml_driver *driver;
    virConnectPtr conn;
};

static void umlProcessAutoDestroyDom(void *payload,
                                     const void *name,
                                     void *opaque)
{
    struct umlProcessAutoDestroyData *data = opaque;
    virConnectPtr conn = payload;
    const char *uuidstr = name;
    unsigned char uuid[VIR_UUID_BUFLEN];
    virDomainObjPtr dom;
    virDomainEventPtr event = NULL;

    VIR_DEBUG("conn=%p uuidstr=%s thisconn=%p", conn, uuidstr, data->conn);

    if (data->conn != conn)
        return;

    if (virUUIDParse(uuidstr, uuid) < 0) {
        VIR_WARN("Failed to parse %s", uuidstr);
        return;
    }

    if (!(dom = virDomainFindByUUID(&data->driver->domains,
                                    uuid))) {
        VIR_DEBUG("No domain object to kill");
        return;
    }

    VIR_DEBUG("Killing domain");
    umlShutdownVMDaemon(data->driver, dom, VIR_DOMAIN_SHUTOFF_DESTROYED);
    virDomainAuditStop(dom, "destroyed");
    event = virDomainEventNewFromObj(dom,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_DESTROYED);

    if (dom && !dom->persistent)
        virDomainRemoveInactive(&data->driver->domains, dom);

    if (dom)
        virDomainObjUnlock(dom);
    if (event)
        umlDomainEventQueue(data->driver, event);
    virHashRemoveEntry(data->driver->autodestroy, uuidstr);
}

/*
 * Precondition: driver is locked
 */
static void umlProcessAutoDestroyRun(struct uml_driver *driver, virConnectPtr conn)
{
    struct umlProcessAutoDestroyData data = {
        driver, conn
    };
    VIR_DEBUG("conn=%p", conn);
    virHashForEach(driver->autodestroy, umlProcessAutoDestroyDom, &data);
}

static void umlProcessAutoDestroyShutdown(struct uml_driver *driver)
{
    virHashFree(driver->autodestroy);
}

static int umlProcessAutoDestroyAdd(struct uml_driver *driver,
                                    virDomainObjPtr vm,
                                    virConnectPtr conn)
{
    char uuidstr[VIR_UUID_STRING_BUFLEN];
    virUUIDFormat(vm->def->uuid, uuidstr);
    VIR_DEBUG("vm=%s uuid=%s conn=%p", vm->def->name, uuidstr, conn);
    if (virHashAddEntry(driver->autodestroy, uuidstr, conn) < 0)
        return -1;
    return 0;
}

static int umlProcessAutoDestroyRemove(struct uml_driver *driver,
                                       virDomainObjPtr vm)
{
    char uuidstr[VIR_UUID_STRING_BUFLEN];
    virUUIDFormat(vm->def->uuid, uuidstr);
    VIR_DEBUG("vm=%s uuid=%s", vm->def->name, uuidstr);
    if (virHashRemoveEntry(driver->autodestroy, uuidstr) < 0)
        return -1;
    return 0;
}


736
static int umlReadPidFile(struct uml_driver *driver,
737 738 739 740 741 742 743 744
                          virDomainObjPtr vm)
{
    int rc = -1;
    FILE *file;
    char *pidfile = NULL;
    int retries = 0;

    vm->pid = -1;
745 746
    if (virAsprintf(&pidfile, "%s/%s/pid",
                    driver->monitorDir, vm->def->name) < 0) {
747
        virReportOOMError();
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
        return -1;
    }

reopen:
    if (!(file = fopen(pidfile, "r"))) {
        if (errno == ENOENT &&
            retries++ < 50) {
            usleep(1000 * 100);
            goto reopen;
        }
        goto cleanup;
    }

    if (fscanf(file, "%d", &vm->pid) != 1) {
        errno = EINVAL;
763
        VIR_FORCE_FCLOSE(file);
764 765 766
        goto cleanup;
    }

767
    if (VIR_FCLOSE(file) < 0)
768 769 770 771 772 773
        goto cleanup;

    rc = 0;

 cleanup:
    if (rc != 0)
774
        virReportSystemError(errno,
775 776
                             _("failed to read pid: %s"),
                             pidfile);
777 778 779 780
    VIR_FREE(pidfile);
    return rc;
}

781
static int umlMonitorAddress(const struct uml_driver *driver,
782 783 784
                             virDomainObjPtr vm,
                             struct sockaddr_un *addr) {
    char *sockname;
C
Chris Lalancette 已提交
785
    int retval = 0;
786

787 788
    if (virAsprintf(&sockname, "%s/%s/mconsole",
                    driver->monitorDir, vm->def->name) < 0) {
789
        virReportOOMError();
790 791 792 793 794
        return -1;
    }

    memset(addr, 0, sizeof *addr);
    addr->sun_family = AF_UNIX;
C
Chris Lalancette 已提交
795
    if (virStrcpyStatic(addr->sun_path, sockname) == NULL) {
796
        umlReportError(VIR_ERR_INTERNAL_ERROR,
C
Chris Lalancette 已提交
797 798 799
                       _("Unix path %s too long for destination"), sockname);
        retval = -1;
    }
800
    VIR_FREE(sockname);
C
Chris Lalancette 已提交
801
    return retval;
802 803
}

804
static int umlOpenMonitor(struct uml_driver *driver,
805 806 807 808
                          virDomainObjPtr vm) {
    struct sockaddr_un addr;
    struct stat sb;
    int retries = 0;
809
    umlDomainObjPrivatePtr priv = vm->privateData;
810

811
    if (umlMonitorAddress(driver, vm, &addr) < 0)
812 813
        return -1;

814
    VIR_DEBUG("Dest address for monitor is '%s'", addr.sun_path);
815 816 817
restat:
    if (stat(addr.sun_path, &sb) < 0) {
        if (errno == ENOENT &&
818
            retries++ < 50) {
819 820 821 822 823 824
            usleep(1000 * 100);
            goto restat;
        }
        return -1;
    }

825
    if ((priv->monitor = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) {
826
        virReportSystemError(errno,
827
                             "%s", _("cannot open socket"));
828 829 830 831
        return -1;
    }

    memset(addr.sun_path, 0, sizeof addr.sun_path);
E
Eric Blake 已提交
832 833
    snprintf(addr.sun_path + 1, sizeof(addr.sun_path) - 1,
             "libvirt-uml-%u", vm->pid);
834
    VIR_DEBUG("Reply address for monitor is '%s'", addr.sun_path+1);
835
    if (bind(priv->monitor, (struct sockaddr *)&addr, sizeof addr) < 0) {
836
        virReportSystemError(errno,
837
                             "%s", _("cannot bind socket"));
838
        VIR_FORCE_CLOSE(priv->monitor);
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
        return -1;
    }

    return 0;
}


#define MONITOR_MAGIC 0xcafebabe
#define MONITOR_BUFLEN 512
#define MONITOR_VERSION 2

struct monitor_request {
    uint32_t magic;
    uint32_t version;
    uint32_t length;
    char data[MONITOR_BUFLEN];
};

struct monitor_response {
    uint32_t error;
    uint32_t extra;
    uint32_t length;
    char data[MONITOR_BUFLEN];
};


865
static int umlMonitorCommand(const struct uml_driver *driver,
866 867 868 869 870 871 872 873 874 875
                             const virDomainObjPtr vm,
                             const char *cmd,
                             char **reply)
{
    struct monitor_request req;
    struct monitor_response res;
    char *retdata = NULL;
    int retlen = 0, ret = 0;
    struct sockaddr_un addr;
    unsigned int addrlen;
876
    umlDomainObjPrivatePtr priv = vm->privateData;
877

878 879
    VIR_DEBUG("Run command '%s'", cmd);

880 881
    *reply = NULL;

882
    if (umlMonitorAddress(driver, vm, &addr) < 0)
883 884 885 886 887 888 889
        return -1;

    memset(&req, 0, sizeof(req));
    req.magic = MONITOR_MAGIC;
    req.version = MONITOR_VERSION;
    req.length = strlen(cmd);
    if (req.length > (MONITOR_BUFLEN-1)) {
890
        virReportSystemError(EINVAL,
891 892
                             _("cannot send too long command %s (%d bytes)"),
                             cmd, req.length);
893 894
        return -1;
    }
C
Chris Lalancette 已提交
895
    if (virStrcpyStatic(req.data, cmd) == NULL) {
896
        umlReportError(VIR_ERR_INTERNAL_ERROR,
C
Chris Lalancette 已提交
897 898 899
                       _("Command %s too long for destination"), cmd);
        return -1;
    }
900

901
    if (sendto(priv->monitor, &req, sizeof req, 0,
902
               (struct sockaddr *)&addr, sizeof addr) != (sizeof req)) {
903
        virReportSystemError(errno,
904 905
                             _("cannot send command %s"),
                             cmd);
906 907 908 909
        return -1;
    }

    do {
E
Eric Blake 已提交
910
        ssize_t nbytes;
911
        addrlen = sizeof(addr);
E
Eric Blake 已提交
912
        nbytes = recvfrom(priv->monitor, &res, sizeof res, 0,
913
                          (struct sockaddr *)&addr, &addrlen);
E
Eric Blake 已提交
914 915 916
        if (nbytes < 0) {
            if (errno == EAGAIN || errno == EINTR)
                continue;
917
            virReportSystemError(errno, _("cannot read reply %s"), cmd);
918 919
            goto error;
        }
920 921 922
        /* Ensure res.length is safe to read before validating its value.  */
        if (nbytes < offsetof(struct monitor_request, data) ||
            nbytes < offsetof(struct monitor_request, data) + res.length) {
923 924 925
            virReportSystemError(0, _("incomplete reply %s"), cmd);
            goto error;
        }
926 927

        if (VIR_REALLOC_N(retdata, retlen + res.length) < 0) {
928
            virReportOOMError();
929 930 931 932 933 934 935 936 937 938 939
            goto error;
        }
        memcpy(retdata + retlen, res.data, res.length);
        retlen += res.length - 1;
        retdata[retlen] = '\0';

        if (res.error)
            ret = -1;

    } while (res.extra);

940 941
    VIR_DEBUG("Command reply is '%s'", NULLSTR(retdata));

942 943 944 945
    if (ret < 0)
        VIR_FREE(retdata);
    else
        *reply = retdata;
946 947 948 949 950 951 952 953 954

    return ret;

error:
    VIR_FREE(retdata);
    return -1;
}


955
static void umlCleanupTapDevices(virDomainObjPtr vm) {
956 957 958 959 960 961 962 963 964
    int i;

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

        if (def->type != VIR_DOMAIN_NET_TYPE_BRIDGE &&
            def->type != VIR_DOMAIN_NET_TYPE_NETWORK)
            continue;

965
        ignore_value(virNetDevTapDelete(def->ifname));
966 967 968
    }
}

969 970
static int umlStartVMDaemon(virConnectPtr conn,
                            struct uml_driver *driver,
971 972
                            virDomainObjPtr vm,
                            bool autoDestroy) {
973
    int ret = -1;
974 975
    char *logfile;
    int logfd = -1;
976
    umlDomainObjPrivatePtr priv = vm->privateData;
D
Daniel P. Berrange 已提交
977
    virCommandPtr cmd = NULL;
978
    size_t i;
979

D
Daniel P. Berrange 已提交
980
    if (virDomainObjIsActive(vm)) {
981
        umlReportError(VIR_ERR_OPERATION_INVALID, "%s",
982
                       _("VM is already active"));
983 984 985 986
        return -1;
    }

    if (!vm->def->os.kernel) {
987 988
        umlReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("no kernel specified"));
989 990 991 992 993 994
        return -1;
    }
    /* Make sure the binary we are about to try exec'ing exists.
     * Technically we could catch the exec() failure, but that's
     * in a sub-process so its hard to feed back a useful error
     */
E
Eric Blake 已提交
995
    if (!virFileIsExecutable(vm->def->os.kernel)) {
996
        virReportSystemError(errno,
997 998
                             _("Cannot find UML kernel %s"),
                             vm->def->os.kernel);
999 1000 1001
        return -1;
    }

1002
    if (virFileMakePath(driver->logDir) < 0) {
1003
        virReportSystemError(errno,
1004 1005
                             _("cannot create log directory %s"),
                             driver->logDir);
1006 1007 1008
        return -1;
    }

1009 1010
    if (virAsprintf(&logfile, "%s/%s.log",
                    driver->logDir, vm->def->name) < 0) {
1011
        virReportOOMError();
1012 1013 1014 1015 1016
        return -1;
    }

    if ((logfd = open(logfile, O_CREAT | O_TRUNC | O_WRONLY,
                      S_IRUSR | S_IWUSR)) < 0) {
1017
        virReportSystemError(errno,
1018 1019
                             _("failed to create logfile %s"),
                             logfile);
1020 1021 1022 1023 1024
        VIR_FREE(logfile);
        return -1;
    }
    VIR_FREE(logfile);

E
Eric Blake 已提交
1025 1026 1027
    if (virSetCloseExec(logfd) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to set VM logfile close-on-exec flag"));
1028
        VIR_FORCE_CLOSE(logfd);
1029 1030 1031
        return -1;
    }

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
    /* 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");
    if (virDomainObjSetDefTransient(driver->caps, vm, true) < 0) {
        VIR_FORCE_CLOSE(logfd);
        return -1;
    }

D
Daniel P. Berrange 已提交
1042
    if (!(cmd = umlBuildCommandLine(conn, driver, vm))) {
1043
        VIR_FORCE_CLOSE(logfd);
1044
        virDomainConfVMNWFilterTeardown(vm);
1045
        umlCleanupTapDevices(vm);
1046 1047 1048
        return -1;
    }

1049 1050 1051 1052 1053 1054 1055 1056
    for (i = 0 ; i < vm->def->nconsoles ; i++) {
        VIR_FREE(vm->def->consoles[i]->info.alias);
        if (virAsprintf(&vm->def->consoles[i]->info.alias, "console%zu", i) < 0) {
            virReportOOMError();
            goto cleanup;
        }
    }

D
Daniel P. Berrange 已提交
1057
    virCommandWriteArgLog(cmd, logfd);
1058

1059
    priv->monitor = -1;
1060

D
Daniel P. Berrange 已提交
1061 1062 1063 1064 1065 1066
    virCommandClearCaps(cmd);
    virCommandSetOutputFD(cmd, &logfd);
    virCommandSetErrorFD(cmd, &logfd);
    virCommandDaemonize(cmd);

    ret = virCommandRun(cmd, NULL);
1067
    VIR_FORCE_CLOSE(logfd);
1068 1069
    if (ret < 0)
        goto cleanup;
1070

1071 1072 1073 1074
    if (autoDestroy &&
        umlProcessAutoDestroyAdd(driver, vm, conn) < 0)
        goto cleanup;

1075
    ret = virDomainObjSetDefTransient(driver->caps, vm, false);
1076
cleanup:
D
Daniel P. Berrange 已提交
1077
    virCommandFree(cmd);
1078

1079 1080
    if (ret < 0) {
        virDomainConfVMNWFilterTeardown(vm);
1081
        umlCleanupTapDevices(vm);
1082 1083 1084 1085 1086 1087
        if (vm->newDef) {
            virDomainDefFree(vm->def);
            vm->def = vm->newDef;
            vm->def->id = -1;
            vm->newDef = NULL;
        }
1088 1089
    }

1090 1091
    /* NB we don't mark it running here - we do that async
       with inotify */
1092 1093 1094
    /* XXX what if someone else tries to start it again
       before we get the inotification ? Sounds like
       trouble.... */
1095
    /* XXX this is bad for events too. must fix this better */
1096 1097 1098 1099

    return ret;
}

1100
static void umlShutdownVMDaemon(struct uml_driver *driver,
J
Jiri Denemark 已提交
1101 1102
                                virDomainObjPtr vm,
                                virDomainShutoffReason reason)
1103 1104
{
    int ret;
1105 1106
    umlDomainObjPrivatePtr priv = vm->privateData;

D
Daniel P. Berrange 已提交
1107
    if (!virDomainObjIsActive(vm))
1108 1109
        return;

1110
    virKillProcess(vm->pid, SIGTERM);
1111

1112
    VIR_FORCE_CLOSE(priv->monitor);
1113 1114

    if ((ret = waitpid(vm->pid, NULL, 0)) != vm->pid) {
1115
        VIR_WARN("Got unexpected pid %d != %d",
1116 1117 1118 1119 1120
               ret, vm->pid);
    }

    vm->pid = -1;
    vm->def->id = -1;
J
Jiri Denemark 已提交
1121
    virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason);
1122

1123
    virDomainConfVMNWFilterTeardown(vm);
1124 1125 1126 1127
    umlCleanupTapDevices(vm);

    /* Stop autodestroy in case guest is restarted */
    umlProcessAutoDestroyRemove(driver, vm);
1128

1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
    if (vm->newDef) {
        virDomainDefFree(vm->def);
        vm->def = vm->newDef;
        vm->def->id = -1;
        vm->newDef = NULL;
    }
}


static virDrvOpenStatus umlOpen(virConnectPtr conn,
                                virConnectAuthPtr auth ATTRIBUTE_UNUSED,
E
Eric Blake 已提交
1140 1141 1142 1143
                                unsigned int flags)
{
    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);

1144 1145 1146
    if (conn->uri == NULL) {
        if (uml_driver == NULL)
            return VIR_DRV_OPEN_DECLINED;
1147

1148
        conn->uri = xmlParseURI(uml_driver->privileged ?
1149 1150 1151
                                "uml:///system" :
                                "uml:///session");
        if (!conn->uri) {
1152
            virReportOOMError();
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
            return VIR_DRV_OPEN_ERROR;
        }
    } else {
        if (conn->uri->scheme == NULL ||
            STRNEQ (conn->uri->scheme, "uml"))
            return VIR_DRV_OPEN_DECLINED;

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


1165
        /* Check path and tell them correct path if they made a mistake */
1166
        if (uml_driver->privileged) {
1167
            if (STRNEQ (conn->uri->path, "/system") &&
1168
                STRNEQ (conn->uri->path, "/session")) {
1169
                umlReportError(VIR_ERR_INTERNAL_ERROR,
1170 1171 1172 1173 1174 1175
                               _("unexpected UML URI path '%s', try uml:///system"),
                               conn->uri->path);
                return VIR_DRV_OPEN_ERROR;
            }
        } else {
            if (STRNEQ (conn->uri->path, "/session")) {
1176
                umlReportError(VIR_ERR_INTERNAL_ERROR,
1177 1178 1179 1180
                               _("unexpected UML URI path '%s', try uml:///session"),
                               conn->uri->path);
                return VIR_DRV_OPEN_ERROR;
            }
1181
        }
1182 1183 1184

        /* URI was good, but driver isn't active */
        if (uml_driver == NULL) {
1185
            umlReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1186
                           _("uml state driver is not active"));
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
            return VIR_DRV_OPEN_ERROR;
        }
    }

    conn->privateData = uml_driver;

    return VIR_DRV_OPEN_SUCCESS;
}

static int umlClose(virConnectPtr conn) {
1197 1198 1199 1200 1201
    struct uml_driver *driver = conn->privateData;

    umlDriverLock(driver);
    virDomainEventCallbackListRemoveConn(conn,
                                         driver->domainEventState->callbacks);
1202
    umlProcessAutoDestroyRun(driver, conn);
1203
    umlDriverUnlock(driver);
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214

    conn->privateData = NULL;

    return 0;
}

static const char *umlGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
    return "UML";
}


1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
static int umlIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    /* Trivially secure, since always inside the daemon */
    return 1;
}


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


1229 1230 1231 1232
static char *umlGetCapabilities(virConnectPtr conn) {
    struct uml_driver *driver = (struct uml_driver *)conn->privateData;
    char *xml;

1233
    umlDriverLock(driver);
1234
    if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
1235
        virReportOOMError();
1236
    umlDriverUnlock(driver);
1237 1238 1239 1240 1241 1242

    return xml;
}



1243 1244 1245
static int umlGetProcessInfo(unsigned long long *cpuTime, int pid)
{
    char *proc;
1246 1247 1248
    FILE *pidinfo;
    unsigned long long usertime, systime;

1249
    if (virAsprintf(&proc, "/proc/%d/stat", pid) < 0) {
1250 1251 1252 1253 1254 1255
        return -1;
    }

    if (!(pidinfo = fopen(proc, "r"))) {
        /* VM probably shut down, so fake 0 */
        *cpuTime = 0;
1256
        VIR_FREE(proc);
1257 1258 1259
        return 0;
    }

1260 1261
    VIR_FREE(proc);

1262 1263
    if (fscanf(pidinfo, "%*d %*s %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %llu %llu", &usertime, &systime) != 2) {
        umlDebug("not enough arg");
1264
        VIR_FORCE_FCLOSE(pidinfo);
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
        return -1;
    }

    /* We got jiffies
     * We want nanoseconds
     * _SC_CLK_TCK is jiffies per second
     * So calulate thus....
     */
    *cpuTime = 1000ull * 1000ull * 1000ull * (usertime + systime) / (unsigned long long)sysconf(_SC_CLK_TCK);

    umlDebug("Got %llu %llu %llu", usertime, systime, *cpuTime);

1277
    VIR_FORCE_FCLOSE(pidinfo);
1278 1279 1280 1281 1282 1283 1284 1285

    return 0;
}


static virDomainPtr umlDomainLookupByID(virConnectPtr conn,
                                          int id) {
    struct uml_driver *driver = (struct uml_driver *)conn->privateData;
1286 1287
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
1288

1289
    umlDriverLock(driver);
1290
    vm = virDomainFindByID(&driver->domains, id);
1291 1292
    umlDriverUnlock(driver);

1293
    if (!vm) {
1294
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1295
        goto cleanup;
1296 1297 1298 1299
    }

    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom) dom->id = vm->def->id;
1300 1301

cleanup:
1302 1303
    if (vm)
        virDomainObjUnlock(vm);
1304 1305
    return dom;
}
1306

1307 1308 1309
static virDomainPtr umlDomainLookupByUUID(virConnectPtr conn,
                                            const unsigned char *uuid) {
    struct uml_driver *driver = (struct uml_driver *)conn->privateData;
1310 1311
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
1312

1313
    umlDriverLock(driver);
1314
    vm = virDomainFindByUUID(&driver->domains, uuid);
1315 1316
    umlDriverUnlock(driver);

1317
    if (!vm) {
1318
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1319
        goto cleanup;
1320 1321 1322 1323
    }

    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom) dom->id = vm->def->id;
1324 1325

cleanup:
1326 1327
    if (vm)
        virDomainObjUnlock(vm);
1328 1329
    return dom;
}
1330

1331 1332 1333
static virDomainPtr umlDomainLookupByName(virConnectPtr conn,
                                            const char *name) {
    struct uml_driver *driver = (struct uml_driver *)conn->privateData;
1334 1335
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
1336

1337
    umlDriverLock(driver);
1338
    vm = virDomainFindByName(&driver->domains, name);
1339 1340
    umlDriverUnlock(driver);

1341
    if (!vm) {
1342
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1343
        goto cleanup;
1344 1345 1346 1347
    }

    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom) dom->id = vm->def->id;
1348 1349

cleanup:
1350 1351
    if (vm)
        virDomainObjUnlock(vm);
1352 1353 1354
    return dom;
}

1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365

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

    umlDriverLock(driver);
    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
    umlDriverUnlock(driver);
    if (!obj) {
1366
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
        goto cleanup;
    }
    ret = virDomainObjIsActive(obj);

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


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

    umlDriverLock(driver);
    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
    umlDriverUnlock(driver);
    if (!obj) {
1388
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398
        goto cleanup;
    }
    ret = obj->persistent;

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

1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
static int umlDomainIsUpdated(virDomainPtr dom)
{
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr obj;
    int ret = -1;

    umlDriverLock(driver);
    obj = virDomainFindByUUID(&driver->domains, dom->uuid);
    umlDriverUnlock(driver);
    if (!obj) {
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
        goto cleanup;
    }
    ret = obj->updated;

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

1420
static int umlGetVersion(virConnectPtr conn, unsigned long *version) {
1421
    struct uml_driver *driver = conn->privateData;
1422
    struct utsname ut;
1423
    int ret = -1;
1424

1425
    umlDriverLock(driver);
1426 1427 1428 1429

    if (driver->umlVersion == 0) {
        uname(&ut);

1430
        if (virParseVersionString(ut.release, &driver->umlVersion, true) < 0) {
1431
            umlReportError(VIR_ERR_INTERNAL_ERROR,
1432 1433 1434
                           _("cannot parse version %s"), ut.release);
            goto cleanup;
        }
1435 1436
    }

1437 1438 1439 1440 1441 1442
    *version = driver->umlVersion;
    ret = 0;

cleanup:
    umlDriverUnlock(driver);
    return ret;
1443 1444 1445
}

static int umlListDomains(virConnectPtr conn, int *ids, int nids) {
1446
    struct uml_driver *driver = conn->privateData;
1447
    int n;
1448

1449
    umlDriverLock(driver);
1450
    n = virDomainObjListGetActiveIDs(&driver->domains, ids, nids);
1451
    umlDriverUnlock(driver);
1452

1453
    return n;
1454 1455
}
static int umlNumDomains(virConnectPtr conn) {
1456
    struct uml_driver *driver = conn->privateData;
1457
    int n;
1458

1459
    umlDriverLock(driver);
1460
    n = virDomainObjListNumOfDomains(&driver->domains, 1);
1461
    umlDriverUnlock(driver);
1462 1463 1464 1465

    return n;
}
static virDomainPtr umlDomainCreate(virConnectPtr conn, const char *xml,
1466
                                      unsigned int flags) {
1467
    struct uml_driver *driver = conn->privateData;
1468
    virDomainDefPtr def;
1469
    virDomainObjPtr vm = NULL;
1470
    virDomainPtr dom = NULL;
1471
    virDomainEventPtr event = NULL;
1472

1473
    virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, NULL);
1474

1475
    umlDriverLock(driver);
1476
    if (!(def = virDomainDefParseString(driver->caps, xml,
M
Matthias Bolte 已提交
1477
                                        1 << VIR_DOMAIN_VIRT_UML,
1478
                                        VIR_DOMAIN_XML_INACTIVE)))
1479
        goto cleanup;
1480

1481
    if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
1482
        goto cleanup;
1483

1484
    if (!(vm = virDomainAssignDef(driver->caps,
1485
                                  &driver->domains,
1486
                                  def, false)))
1487 1488
        goto cleanup;
    def = NULL;
1489

1490 1491
    if (umlStartVMDaemon(conn, driver, vm,
                         (flags & VIR_DOMAIN_START_AUTODESTROY)) < 0) {
1492
        virDomainAuditStart(vm, "booted", false);
1493 1494
        virDomainRemoveInactive(&driver->domains,
                                vm);
1495 1496
        vm = NULL;
        goto cleanup;
1497
    }
1498
    virDomainAuditStart(vm, "booted", true);
1499 1500 1501
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_BOOTED);
1502 1503 1504

    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom) dom->id = vm->def->id;
1505 1506 1507

cleanup:
    virDomainDefFree(def);
1508 1509
    if (vm)
        virDomainObjUnlock(vm);
1510 1511
    if (event)
        umlDomainEventQueue(driver, event);
1512
    umlDriverUnlock(driver);
1513 1514 1515 1516 1517
    return dom;
}


static int umlDomainShutdown(virDomainPtr dom) {
1518 1519
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
1520
    char *info = NULL;
1521
    int ret = -1;
1522

1523
    umlDriverLock(driver);
1524
    vm = virDomainFindByID(&driver->domains, dom->id);
1525
    umlDriverUnlock(driver);
1526
    if (!vm) {
1527
        umlReportError(VIR_ERR_NO_DOMAIN,
1528
                       _("no domain with matching id %d"), dom->id);
1529
        goto cleanup;
1530 1531 1532 1533
    }

#if 0
    if (umlMonitorCommand(driver, vm, "system_powerdown", &info) < 0) {
1534 1535
        umlReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("shutdown operation failed"));
1536
        goto cleanup;
1537
    }
1538
    ret = 0;
1539 1540
#endif

1541 1542
cleanup:
    VIR_FREE(info);
1543 1544
    if (vm)
        virDomainObjUnlock(vm);
1545
    return ret;
1546 1547 1548
}


1549 1550 1551 1552
static int
umlDomainDestroyFlags(virDomainPtr dom,
                      unsigned int flags)
{
1553 1554
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
1555
    virDomainEventPtr event = NULL;
1556
    int ret = -1;
1557

1558 1559
    virCheckFlags(0, -1);

1560
    umlDriverLock(driver);
1561
    vm = virDomainFindByID(&driver->domains, dom->id);
1562
    if (!vm) {
1563
        umlReportError(VIR_ERR_NO_DOMAIN,
1564
                       _("no domain with matching id %d"), dom->id);
1565
        goto cleanup;
1566 1567
    }

1568
    umlShutdownVMDaemon(driver, vm, VIR_DOMAIN_SHUTOFF_DESTROYED);
1569
    virDomainAuditStop(vm, "destroyed");
1570 1571 1572
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STOPPED,
                                     VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
1573
    if (!vm->persistent) {
1574 1575
        virDomainRemoveInactive(&driver->domains,
                                vm);
1576 1577 1578
        vm = NULL;
    }
    ret = 0;
1579

1580
cleanup:
1581 1582
    if (vm)
        virDomainObjUnlock(vm);
1583 1584
    if (event)
        umlDomainEventQueue(driver, event);
1585
    umlDriverUnlock(driver);
1586
    return ret;
1587 1588 1589
}


1590 1591 1592 1593 1594 1595
static int umlDomainDestroy(virDomainPtr dom)
{
    return umlDomainDestroyFlags(dom, 0);
}


1596
static char *umlDomainGetOSType(virDomainPtr dom) {
1597 1598 1599
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *type = NULL;
1600

1601
    umlDriverLock(driver);
1602
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1603
    umlDriverUnlock(driver);
1604
    if (!vm) {
1605
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
1606
                       _("no domain with matching uuid"));
1607
        goto cleanup;
1608 1609
    }

1610
    if (!(type = strdup(vm->def->os.type)))
1611
        virReportOOMError();
1612 1613

cleanup:
1614 1615
    if (vm)
        virDomainObjUnlock(vm);
1616 1617 1618 1619 1620
    return type;
}

/* Returns max memory in kb, 0 if error */
static unsigned long umlDomainGetMaxMemory(virDomainPtr dom) {
1621 1622 1623
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    unsigned long ret = 0;
1624

1625
    umlDriverLock(driver);
1626
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1627 1628
    umlDriverUnlock(driver);

1629 1630 1631 1632
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];

        virUUIDFormat(dom->uuid, uuidstr);
1633
        umlReportError(VIR_ERR_NO_DOMAIN,
1634 1635
                       _("no domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
1636
    }
1637
    ret = vm->def->mem.max_balloon;
1638

1639
cleanup:
1640 1641
    if (vm)
        virDomainObjUnlock(vm);
1642
    return ret;
1643 1644 1645
}

static int umlDomainSetMaxMemory(virDomainPtr dom, unsigned long newmax) {
1646 1647 1648
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
1649

1650
    umlDriverLock(driver);
1651
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1652 1653
    umlDriverUnlock(driver);

1654 1655 1656 1657
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];

        virUUIDFormat(dom->uuid, uuidstr);
1658
        umlReportError(VIR_ERR_NO_DOMAIN,
1659
                       _("no domain with matching uuid '%s'"), uuidstr);
1660
        goto cleanup;
1661 1662
    }

1663
    if (newmax < vm->def->mem.cur_balloon) {
1664 1665
        umlReportError(VIR_ERR_INVALID_ARG, "%s",
                       _("cannot set max memory lower than current memory"));
1666
        goto cleanup;
1667 1668
    }

1669
    vm->def->mem.max_balloon = newmax;
1670 1671 1672
    ret = 0;

cleanup:
1673 1674
    if (vm)
        virDomainObjUnlock(vm);
1675
    return ret;
1676 1677 1678
}

static int umlDomainSetMemory(virDomainPtr dom, unsigned long newmem) {
1679 1680 1681
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
1682

1683
    umlDriverLock(driver);
1684
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1685 1686
    umlDriverUnlock(driver);

1687 1688 1689 1690
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];

        virUUIDFormat(dom->uuid, uuidstr);
1691
        umlReportError(VIR_ERR_NO_DOMAIN,
1692
                       _("no domain with matching uuid '%s'"), uuidstr);
1693
        goto cleanup;
1694 1695
    }

D
Daniel P. Berrange 已提交
1696
    if (virDomainObjIsActive(vm)) {
1697
        umlReportError(VIR_ERR_OPERATION_INVALID, "%s",
1698
                       _("cannot set memory of an active domain"));
1699
        goto cleanup;
1700 1701
    }

1702
    if (newmem > vm->def->mem.max_balloon) {
1703 1704
        umlReportError(VIR_ERR_INVALID_ARG, "%s",
                       _("cannot set memory higher than max memory"));
1705
        goto cleanup;
1706 1707
    }

1708
    vm->def->mem.cur_balloon = newmem;
1709 1710 1711
    ret = 0;

cleanup:
1712 1713
    if (vm)
        virDomainObjUnlock(vm);
1714
    return ret;
1715 1716 1717 1718
}

static int umlDomainGetInfo(virDomainPtr dom,
                              virDomainInfoPtr info) {
1719 1720 1721 1722
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;

1723
    umlDriverLock(driver);
1724
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1725 1726
    umlDriverUnlock(driver);

1727
    if (!vm) {
1728
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
1729
                       _("no domain with matching uuid"));
1730
        goto cleanup;
1731 1732
    }

J
Jiri Denemark 已提交
1733
    info->state = virDomainObjGetState(vm, NULL);
1734

D
Daniel P. Berrange 已提交
1735
    if (!virDomainObjIsActive(vm)) {
1736 1737 1738
        info->cpuTime = 0;
    } else {
        if (umlGetProcessInfo(&(info->cpuTime), vm->pid) < 0) {
1739 1740
            umlReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("cannot read cputime for domain"));
1741
            goto cleanup;
1742 1743 1744
        }
    }

1745 1746
    info->maxMem = vm->def->mem.max_balloon;
    info->memory = vm->def->mem.cur_balloon;
1747
    info->nrVirtCpu = vm->def->vcpus;
1748 1749 1750
    ret = 0;

cleanup:
1751 1752
    if (vm)
        virDomainObjUnlock(vm);
1753
    return ret;
1754 1755 1756
}


1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
static int
umlDomainGetState(virDomainPtr dom,
                  int *state,
                  int *reason,
                  unsigned int flags)
{
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;

    virCheckFlags(0, -1);

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

    if (!vm) {
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
                       _("no domain with matching uuid"));
        goto cleanup;
    }

J
Jiri Denemark 已提交
1779
    *state = virDomainObjGetState(vm, reason);
1780 1781 1782 1783 1784 1785 1786 1787 1788
    ret = 0;

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


1789
static char *umlDomainGetXMLDesc(virDomainPtr dom,
E
Eric Blake 已提交
1790 1791
                                 unsigned int flags)
{
1792 1793 1794 1795
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    char *ret = NULL;

1796
    /* Flags checked by virDomainDefFormat */
E
Eric Blake 已提交
1797

1798
    umlDriverLock(driver);
1799
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1800 1801
    umlDriverUnlock(driver);

1802
    if (!vm) {
1803
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
1804
                       _("no domain with matching uuid"));
1805
        goto cleanup;
1806 1807
    }

1808
    ret = virDomainDefFormat((flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ?
1809 1810 1811 1812
                             vm->newDef : vm->def,
                             flags);

cleanup:
1813 1814
    if (vm)
        virDomainObjUnlock(vm);
1815
    return ret;
1816 1817 1818 1819 1820
}


static int umlListDefinedDomains(virConnectPtr conn,
                            char **const names, int nnames) {
1821
    struct uml_driver *driver = conn->privateData;
1822
    int n;
1823

1824
    umlDriverLock(driver);
1825
    n = virDomainObjListGetInactiveNames(&driver->domains, names, nnames);
1826
    umlDriverUnlock(driver);
1827

1828
    return n;
1829 1830 1831
}

static int umlNumDefinedDomains(virConnectPtr conn) {
1832
    struct uml_driver *driver = conn->privateData;
1833
    int n;
1834

1835
    umlDriverLock(driver);
1836
    n = virDomainObjListNumOfDomains(&driver->domains, 0);
1837
    umlDriverUnlock(driver);
1838 1839 1840 1841 1842

    return n;
}


1843
static int umlDomainStartWithFlags(virDomainPtr dom, unsigned int flags) {
1844 1845
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
1846
    virDomainEventPtr event = NULL;
1847
    int ret = -1;
1848

1849
    virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, -1);
1850

1851
    umlDriverLock(driver);
1852
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1853

1854
    if (!vm) {
1855
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
1856
                       _("no domain with matching uuid"));
1857
        goto cleanup;
1858 1859
    }

1860 1861
    ret = umlStartVMDaemon(dom->conn, driver, vm,
                           (flags & VIR_DOMAIN_START_AUTODESTROY));
1862
    virDomainAuditStart(vm, "booted", ret >= 0);
1863 1864 1865 1866
    if (ret == 0)
        event = virDomainEventNewFromObj(vm,
                                         VIR_DOMAIN_EVENT_STARTED,
                                         VIR_DOMAIN_EVENT_STARTED_BOOTED);
1867 1868

cleanup:
1869 1870
    if (vm)
        virDomainObjUnlock(vm);
1871 1872
    if (event)
        umlDomainEventQueue(driver, event);
1873
    umlDriverUnlock(driver);
1874
    return ret;
1875 1876
}

1877 1878 1879
static int umlDomainStart(virDomainPtr dom) {
    return umlDomainStartWithFlags(dom, 0);
}
1880 1881

static virDomainPtr umlDomainDefine(virConnectPtr conn, const char *xml) {
1882
    struct uml_driver *driver = conn->privateData;
1883
    virDomainDefPtr def;
1884
    virDomainObjPtr vm = NULL;
1885
    virDomainPtr dom = NULL;
1886

1887
    umlDriverLock(driver);
1888
    if (!(def = virDomainDefParseString(driver->caps, xml,
M
Matthias Bolte 已提交
1889
                                        1 << VIR_DOMAIN_VIRT_UML,
1890
                                        VIR_DOMAIN_XML_INACTIVE)))
1891
        goto cleanup;
1892

1893 1894 1895
    if (virDomainObjIsDuplicate(&driver->domains, def, 0) < 0)
        goto cleanup;

1896
    if (!(vm = virDomainAssignDef(driver->caps,
1897
                                  &driver->domains,
1898
                                  def, false)))
1899 1900
        goto cleanup;
    def = NULL;
1901 1902
    vm->persistent = 1;

1903
    if (virDomainSaveConfig(driver->configDir,
1904 1905 1906
                            vm->newDef ? vm->newDef : vm->def) < 0) {
        virDomainRemoveInactive(&driver->domains,
                                vm);
1907
        vm = NULL;
1908
        goto cleanup;
1909 1910 1911 1912
    }

    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom) dom->id = vm->def->id;
1913 1914 1915

cleanup:
    virDomainDefFree(def);
1916 1917 1918
    if (vm)
        virDomainObjUnlock(vm);
    umlDriverUnlock(driver);
1919 1920 1921
    return dom;
}

1922 1923 1924
static int umlDomainUndefineFlags(virDomainPtr dom,
                                  unsigned int flags)
{
1925 1926 1927
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
1928

1929 1930
    virCheckFlags(0, -1);

1931
    umlDriverLock(driver);
1932
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1933
    if (!vm) {
1934
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
1935
                       _("no domain with matching uuid"));
1936
        goto cleanup;
1937 1938 1939
    }

    if (!vm->persistent) {
1940
        umlReportError(VIR_ERR_OPERATION_INVALID, "%s",
1941
                       _("cannot undefine transient domain"));
1942
        goto cleanup;
1943 1944
    }

1945
    if (virDomainDeleteConfig(driver->configDir, driver->autostartDir, vm) < 0)
1946
        goto cleanup;
1947

1948 1949 1950 1951 1952 1953 1954
    if (virDomainObjIsActive(vm)) {
        vm->persistent = 0;
    } else {
        virDomainRemoveInactive(&driver->domains, vm);
        vm = NULL;
    }

1955
    ret = 0;
1956

1957
cleanup:
1958 1959 1960
    if (vm)
        virDomainObjUnlock(vm);
    umlDriverUnlock(driver);
1961
    return ret;
1962 1963 1964
}


1965 1966 1967 1968 1969
static int umlDomainUndefine(virDomainPtr dom)
{
    return umlDomainUndefineFlags(dom, 0);
}

1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077
static int umlDomainAttachUmlDisk(struct uml_driver *driver,
                                  virDomainObjPtr vm,
                                  virDomainDiskDefPtr disk)
{
    int i;
    char *cmd = NULL;
    char *reply = NULL;

    for (i = 0 ; i < vm->def->ndisks ; i++) {
        if (STREQ(vm->def->disks[i]->dst, disk->dst)) {
            umlReportError(VIR_ERR_OPERATION_FAILED,
                           _("target %s already exists"), disk->dst);
            return -1;
        }
    }

    if (!disk->src) {
        umlReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("disk source path is missing"));
        goto error;
    }

    if (virAsprintf(&cmd, "config %s=%s", disk->dst, disk->src) < 0) {
        virReportOOMError();
        return -1;
    }

    if (umlMonitorCommand(driver, vm, cmd, &reply) < 0)
        goto error;

    if (VIR_REALLOC_N(vm->def->disks, vm->def->ndisks+1) < 0) {
        virReportOOMError();
        goto error;
    }

    virDomainDiskInsertPreAlloced(vm->def, disk);

    VIR_FREE(reply);
    VIR_FREE(cmd);

    return 0;

error:

    VIR_FREE(reply);
    VIR_FREE(cmd);

    return -1;
}


static int umlDomainAttachDevice(virDomainPtr dom, const char *xml)
{
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr dev = NULL;
    int ret = -1;

    umlDriverLock(driver);

    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        umlReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
    }

    if (!virDomainObjIsActive(vm)) {
        umlReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("cannot attach device on inactive domain"));
        goto cleanup;
    }

    dev = virDomainDeviceDefParse(driver->caps, vm->def, xml,
                                  VIR_DOMAIN_XML_INACTIVE);

    if (dev == NULL)
        goto cleanup;

    if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
        if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_UML) {
            ret = umlDomainAttachUmlDisk(driver, vm, dev->data.disk);
            if (ret == 0)
                dev->data.disk = NULL;
        } else {
            umlReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("disk bus '%s' cannot be hotplugged."),
                           virDomainDiskBusTypeToString(dev->data.disk->bus));
        }
    } else {
        umlReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("device type '%s' cannot be attached"),
                       virDomainDeviceTypeToString(dev->type));
        goto cleanup;
    }

cleanup:

    virDomainDeviceDefFree(dev);
    if (vm)
        virDomainObjUnlock(vm);
    umlDriverUnlock(driver);
    return ret;
}


2078 2079 2080 2081 2082 2083 2084
static int
umlDomainAttachDeviceFlags(virDomainPtr dom,
                           const char *xml,
                           unsigned int flags)
{
    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1);

2085
    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 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 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189
        umlReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("cannot modify the persistent configuration of a domain"));
        return -1;
    }

    return umlDomainAttachDevice(dom, xml);
}


static int umlDomainDetachUmlDisk(struct uml_driver *driver,
                                  virDomainObjPtr vm,
                                  virDomainDeviceDefPtr dev)
{
    int i, ret = -1;
    virDomainDiskDefPtr detach = NULL;
    char *cmd;
    char *reply;

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

    if (i == vm->def->ndisks) {
        umlReportError(VIR_ERR_OPERATION_FAILED,
                       _("disk %s not found"), dev->data.disk->dst);
        return -1;
    }

    detach = vm->def->disks[i];

    if (virAsprintf(&cmd, "remove %s", detach->dst) < 0) {
        virReportOOMError();
        return -1;
    }

    if (umlMonitorCommand(driver, vm, cmd, &reply) < 0)
        goto cleanup;

    virDomainDiskRemove(vm->def, i);

    virDomainDiskDefFree(detach);

    ret = 0;

    VIR_FREE(reply);

cleanup:
    VIR_FREE(cmd);

    return ret;
}


static int umlDomainDetachDevice(virDomainPtr dom, const char *xml) {
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr dev = NULL;
    int ret = -1;

    umlDriverLock(driver);
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(dom->uuid, uuidstr);
        umlReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
    }

    if (!virDomainObjIsActive(vm)) {
        umlReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("cannot detach device on inactive domain"));
        goto cleanup;
    }

    dev = virDomainDeviceDefParse(driver->caps, vm->def, xml,
                                  VIR_DOMAIN_XML_INACTIVE);
    if (dev == NULL)
        goto cleanup;

    if (dev->type == VIR_DOMAIN_DEVICE_DISK &&
        dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
        if (dev->data.disk->bus == VIR_DOMAIN_DISK_BUS_UML)
            ret = umlDomainDetachUmlDisk(driver, vm, dev);
        else {
            umlReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("This type of disk cannot be hot unplugged"));
        }
    } else {
        umlReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       "%s", _("This type of device cannot be hot unplugged"));
    }

cleanup:
    virDomainDeviceDefFree(dev);
    if (vm)
        virDomainObjUnlock(vm);
    umlDriverUnlock(driver);
    return ret;
}


2190 2191 2192 2193 2194 2195 2196
static int
umlDomainDetachDeviceFlags(virDomainPtr dom,
                           const char *xml,
                           unsigned int flags)
{
    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG, -1);

2197
    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
2198 2199 2200 2201 2202 2203 2204 2205
        umlReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("cannot modify the persistent configuration of a domain"));
        return -1;
    }

    return umlDomainDetachDevice(dom, xml);
}

2206 2207 2208

static int umlDomainGetAutostart(virDomainPtr dom,
                            int *autostart) {
2209 2210 2211
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
    int ret = -1;
2212

2213
    umlDriverLock(driver);
2214
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2215

2216
    if (!vm) {
2217
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
2218
                       _("no domain with matching uuid"));
2219
        goto cleanup;
2220 2221 2222
    }

    *autostart = vm->autostart;
2223
    ret = 0;
2224

2225
cleanup:
2226 2227
    if (vm)
        virDomainObjUnlock(vm);
2228
    umlDriverUnlock(driver);
2229
    return ret;
2230 2231 2232 2233
}

static int umlDomainSetAutostart(virDomainPtr dom,
                                   int autostart) {
2234
    struct uml_driver *driver = dom->conn->privateData;
2235
    virDomainObjPtr vm;
2236 2237 2238
    char *configFile = NULL, *autostartLink = NULL;
    int ret = -1;

2239 2240 2241
    umlDriverLock(driver);
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);

2242
    if (!vm) {
2243
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
2244
                       _("no domain with matching uuid"));
2245
        goto cleanup;
2246 2247 2248
    }

    if (!vm->persistent) {
2249
        umlReportError(VIR_ERR_OPERATION_INVALID, "%s",
2250
                       _("cannot set autostart for transient domain"));
2251
        goto cleanup;
2252 2253 2254 2255
    }

    autostart = (autostart != 0);

2256
    if (vm->autostart != autostart) {
2257
        if ((configFile = virDomainConfigFile(driver->configDir, vm->def->name)) == NULL)
2258
            goto cleanup;
2259
        if ((autostartLink = virDomainConfigFile(driver->autostartDir, vm->def->name)) == NULL)
2260
            goto cleanup;
2261

2262
        if (autostart) {
2263 2264
            if (virFileMakePath(driver->autostartDir) < 0) {
                virReportSystemError(errno,
2265 2266
                                     _("cannot create autostart directory %s"),
                                     driver->autostartDir);
2267 2268
                goto cleanup;
            }
2269

2270
            if (symlink(configFile, autostartLink) < 0) {
2271
                virReportSystemError(errno,
2272 2273
                                     _("Failed to create symlink '%s to '%s'"),
                                     autostartLink, configFile);
2274 2275 2276 2277
                goto cleanup;
            }
        } else {
            if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
2278
                virReportSystemError(errno,
2279 2280
                                     _("Failed to delete symlink '%s'"),
                                     autostartLink);
2281 2282
                goto cleanup;
            }
2283 2284
        }

2285
        vm->autostart = autostart;
2286 2287 2288 2289 2290 2291
    }
    ret = 0;

cleanup:
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
2292 2293
    if (vm)
        virDomainObjUnlock(vm);
2294
    umlDriverUnlock(driver);
2295 2296 2297 2298 2299
    return ret;
}


static int
2300 2301 2302 2303
umlDomainBlockPeek(virDomainPtr dom,
                   const char *path,
                   unsigned long long offset, size_t size,
                   void *buffer,
E
Eric Blake 已提交
2304
                   unsigned int flags)
2305
{
2306 2307
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
2308 2309
    int fd = -1, ret = -1;
    const char *actual;
2310

E
Eric Blake 已提交
2311 2312
    virCheckFlags(0, -1);

2313
    umlDriverLock(driver);
2314
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2315 2316
    umlDriverUnlock(driver);

2317
    if (!vm) {
2318
        umlReportError(VIR_ERR_NO_DOMAIN, "%s",
2319
                       _("no domain with matching uuid"));
2320
        goto cleanup;
2321 2322 2323
    }

    if (!path || path[0] == '\0') {
2324 2325
        umlReportError(VIR_ERR_INVALID_ARG, "%s",
                       _("NULL or empty path"));
2326
        goto cleanup;
2327 2328 2329
    }

    /* Check the path belongs to this domain. */
2330 2331 2332 2333
    if (!(actual = virDomainDiskPathByName(vm->def, path))) {
        umlReportError(VIR_ERR_INVALID_ARG,
                       _("invalid path '%s'"), path);
        goto cleanup;
2334
    }
2335
    path = actual;
2336

2337 2338 2339 2340 2341 2342 2343
    /* The path is correct, now try to open it and get its size. */
    fd = open(path, O_RDONLY);
    if (fd == -1) {
        virReportSystemError(errno,
                             _("cannot open %s"), path);
        goto cleanup;
    }
2344

2345 2346 2347 2348 2349 2350 2351 2352 2353
    /* Seek and read. */
    /* NB. Because we configure with AC_SYS_LARGEFILE, off_t should
     * be 64 bits on all platforms.
     */
    if (lseek(fd, offset, SEEK_SET) == (off_t) -1 ||
        saferead(fd, buffer, size) == (ssize_t) -1) {
        virReportSystemError(errno,
                             _("cannot read %s"), path);
        goto cleanup;
2354 2355
    }

2356 2357
    ret = 0;

2358
cleanup:
2359
    VIR_FORCE_CLOSE(fd);
2360 2361
    if (vm)
        virDomainObjUnlock(vm);
2362 2363 2364 2365
    return ret;
}


2366 2367
static int
umlDomainOpenConsole(virDomainPtr dom,
2368
                     const char *dev_name,
2369 2370 2371 2372 2373 2374 2375 2376
                     virStreamPtr st,
                     unsigned int flags)
{
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm = NULL;
    char uuidstr[VIR_UUID_STRING_BUFLEN];
    int ret = -1;
    virDomainChrDefPtr chr = NULL;
2377
    size_t i;
2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395

    virCheckFlags(0, -1);

    umlDriverLock(driver);
    virUUIDFormat(dom->uuid, uuidstr);
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
    if (!vm) {
        umlReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
    }

    if (!virDomainObjIsActive(vm)) {
        umlReportError(VIR_ERR_OPERATION_INVALID,
                        "%s", _("domain is not running"));
        goto cleanup;
    }

2396
    if (dev_name) {
2397 2398 2399 2400 2401 2402 2403
        for (i = 0 ; i < vm->def->nconsoles ; i++) {
            if (vm->def->consoles[i]->info.alias &&
                STREQ(vm->def->consoles[i]->info.alias, dev_name)) {
                chr = vm->def->consoles[i];
                break;
            }
        }
2404
    } else {
2405 2406
        if (vm->def->nconsoles)
            chr = vm->def->consoles[0];
2407 2408 2409 2410 2411 2412
        else if (vm->def->nserials)
            chr = vm->def->serials[0];
    }

    if (!chr) {
        umlReportError(VIR_ERR_INTERNAL_ERROR,
2413 2414
                       _("cannot find console device '%s'"),
                       dev_name ? dev_name : _("default"));
2415 2416 2417
        goto cleanup;
    }

2418
    if (chr->source.type != VIR_DOMAIN_CHR_TYPE_PTY) {
2419
        umlReportError(VIR_ERR_INTERNAL_ERROR,
2420
                        _("character device %s is not using a PTY"), dev_name);
2421 2422 2423
        goto cleanup;
    }

2424
    if (virFDStreamOpenFile(st, chr->source.data.file.path,
E
Eric Blake 已提交
2425
                            0, 0, O_RDWR) < 0)
2426 2427 2428 2429 2430 2431 2432 2433 2434 2435
        goto cleanup;

    ret = 0;
cleanup:
    if (vm)
        virDomainObjUnlock(vm);
    umlDriverUnlock(driver);
    return ret;
}

2436

2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545
static int
umlDomainEventRegister(virConnectPtr conn,
                       virConnectDomainEventCallback callback,
                       void *opaque,
                       virFreeCallback freecb)
{
    struct uml_driver *driver = conn->privateData;
    int ret;

    umlDriverLock(driver);
    ret = virDomainEventCallbackListAdd(conn,
                                        driver->domainEventState->callbacks,
                                        callback, opaque, freecb);
    umlDriverUnlock(driver);

    return ret;
}

static int
umlDomainEventDeregister(virConnectPtr conn,
                         virConnectDomainEventCallback callback)
{
    struct uml_driver *driver = conn->privateData;
    int ret;

    umlDriverLock(driver);
    ret = virDomainEventStateDeregister(conn,
                                        driver->domainEventState,
                                        callback);
    umlDriverUnlock(driver);

    return ret;
}

static int
umlDomainEventRegisterAny(virConnectPtr conn,
                          virDomainPtr dom,
                          int eventID,
                          virConnectDomainEventGenericCallback callback,
                          void *opaque,
                          virFreeCallback freecb)
{
    struct uml_driver *driver = conn->privateData;
    int ret;

    umlDriverLock(driver);
    ret = virDomainEventCallbackListAddID(conn,
                                          driver->domainEventState->callbacks,
                                          dom, eventID,
                                          callback, opaque, freecb);
    umlDriverUnlock(driver);

    return ret;
}


static int
umlDomainEventDeregisterAny(virConnectPtr conn,
                            int callbackID)
{
    struct uml_driver *driver = conn->privateData;
    int ret;

    umlDriverLock(driver);
    ret = virDomainEventStateDeregisterAny(conn,
                                           driver->domainEventState,
                                           callbackID);
    umlDriverUnlock(driver);

    return ret;
}


static void umlDomainEventDispatchFunc(virConnectPtr conn,
                                       virDomainEventPtr event,
                                       virConnectDomainEventGenericCallback cb,
                                       void *cbopaque,
                                       void *opaque)
{
    struct uml_driver *driver = opaque;

    /* Drop the lock whle dispatching, for sake of re-entrancy */
    umlDriverUnlock(driver);
    virDomainEventDispatchDefaultFunc(conn, event, cb, cbopaque, NULL);
    umlDriverLock(driver);
}


static void umlDomainEventFlush(int timer ATTRIBUTE_UNUSED, void *opaque)
{
    struct uml_driver *driver = opaque;

    umlDriverLock(driver);
    virDomainEventStateFlush(driver->domainEventState,
                             umlDomainEventDispatchFunc,
                             driver);
    umlDriverUnlock(driver);
}


/* driver must be locked before calling */
static void umlDomainEventQueue(struct uml_driver *driver,
                                virDomainEventPtr event)
{
    virDomainEventStateQueue(driver->domainEventState, event);
}



2546
static virDriver umlDriver = {
2547 2548
    .no = VIR_DRV_UML,
    .name = "UML",
2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
    .open = umlOpen, /* 0.5.0 */
    .close = umlClose, /* 0.5.0 */
    .type = umlGetType, /* 0.5.0 */
    .version = umlGetVersion, /* 0.5.0 */
    .getHostname = virGetHostname, /* 0.5.0 */
    .nodeGetInfo = nodeGetInfo, /* 0.5.0 */
    .getCapabilities = umlGetCapabilities, /* 0.5.0 */
    .listDomains = umlListDomains, /* 0.5.0 */
    .numOfDomains = umlNumDomains, /* 0.5.0 */
    .domainCreateXML = umlDomainCreate, /* 0.5.0 */
    .domainLookupByID = umlDomainLookupByID, /* 0.5.0 */
    .domainLookupByUUID = umlDomainLookupByUUID, /* 0.5.0 */
    .domainLookupByName = umlDomainLookupByName, /* 0.5.0 */
    .domainShutdown = umlDomainShutdown, /* 0.5.0 */
    .domainDestroy = umlDomainDestroy, /* 0.5.0 */
2564
    .domainDestroyFlags = umlDomainDestroyFlags, /* 0.9.4 */
2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
    .domainGetOSType = umlDomainGetOSType, /* 0.5.0 */
    .domainGetMaxMemory = umlDomainGetMaxMemory, /* 0.5.0 */
    .domainSetMaxMemory = umlDomainSetMaxMemory, /* 0.5.0 */
    .domainSetMemory = umlDomainSetMemory, /* 0.5.0 */
    .domainGetInfo = umlDomainGetInfo, /* 0.5.0 */
    .domainGetState = umlDomainGetState, /* 0.9.2 */
    .domainGetXMLDesc = umlDomainGetXMLDesc, /* 0.5.0 */
    .listDefinedDomains = umlListDefinedDomains, /* 0.5.0 */
    .numOfDefinedDomains = umlNumDefinedDomains, /* 0.5.0 */
    .domainCreate = umlDomainStart, /* 0.5.0 */
    .domainCreateWithFlags = umlDomainStartWithFlags, /* 0.8.2 */
    .domainDefineXML = umlDomainDefine, /* 0.5.0 */
    .domainUndefine = umlDomainUndefine, /* 0.5.0 */
2578
    .domainUndefineFlags = umlDomainUndefineFlags, /* 0.9.4 */
2579 2580 2581 2582 2583 2584 2585
    .domainAttachDevice = umlDomainAttachDevice, /* 0.8.4 */
    .domainAttachDeviceFlags = umlDomainAttachDeviceFlags, /* 0.8.4 */
    .domainDetachDevice = umlDomainDetachDevice, /* 0.8.4 */
    .domainDetachDeviceFlags = umlDomainDetachDeviceFlags, /* 0.8.4 */
    .domainGetAutostart = umlDomainGetAutostart, /* 0.5.0 */
    .domainSetAutostart = umlDomainSetAutostart, /* 0.5.0 */
    .domainBlockPeek = umlDomainBlockPeek, /* 0.5.0 */
2586
    .nodeGetCPUStats = nodeGetCPUStats, /* 0.9.3 */
2587
    .nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.3 */
2588 2589
    .nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.5.0 */
    .nodeGetFreeMemory = nodeGetFreeMemory, /* 0.5.0 */
2590 2591
    .domainEventRegister = umlDomainEventRegister, /* 0.9.4 */
    .domainEventDeregister = umlDomainEventDeregister, /* 0.9.4 */
2592 2593 2594 2595 2596
    .isEncrypted = umlIsEncrypted, /* 0.7.3 */
    .isSecure = umlIsSecure, /* 0.7.3 */
    .domainIsActive = umlDomainIsActive, /* 0.7.3 */
    .domainIsPersistent = umlDomainIsPersistent, /* 0.7.3 */
    .domainIsUpdated = umlDomainIsUpdated, /* 0.8.6 */
2597 2598
    .domainEventRegisterAny = umlDomainEventRegisterAny, /* 0.9.4 */
    .domainEventDeregisterAny = umlDomainEventDeregisterAny, /* 0.9.4 */
2599
    .domainOpenConsole = umlDomainOpenConsole, /* 0.8.6 */
2600 2601
};

2602 2603 2604 2605 2606 2607 2608 2609
static int
umlVMFilterRebuild(virConnectPtr conn ATTRIBUTE_UNUSED,
                   virHashIterator iter, void *data)
{
    virHashForEach(uml_driver->domains.objs, iter, data);

    return 0;
}
2610 2611

static virStateDriver umlStateDriver = {
2612
    .name = "UML",
2613 2614 2615 2616 2617 2618
    .initialize = umlStartup,
    .cleanup = umlShutdown,
    .reload = umlReload,
    .active = umlActive,
};

2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630
static void
umlVMDriverLock(void)
{
    umlDriverLock(uml_driver);
}

static void
umlVMDriverUnlock(void)
{
    umlDriverUnlock(uml_driver);
}

2631 2632 2633
static virNWFilterCallbackDriver umlCallbackDriver = {
    .name = "UML",
    .vmFilterRebuild = umlVMFilterRebuild,
2634 2635
    .vmDriverLock = umlVMDriverLock,
    .vmDriverUnlock = umlVMDriverUnlock,
2636 2637
};

2638 2639 2640
int umlRegister(void) {
    virRegisterDriver(&umlDriver);
    virRegisterStateDriver(&umlStateDriver);
2641
    virNWFilterRegisterCallbackDriver(&umlCallbackDriver);
2642 2643
    return 0;
}