uml_driver.c 72.0 KB
Newer Older
1 2 3
/*
 * uml_driver.c: core driver methods for managing UML guests
 *
4
 * Copyright (C) 2006-2012 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
 * 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 <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>
45
#include <sys/un.h>
46 47 48 49 50 51 52 53 54 55 56

#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"
57
#include "domain_audit.h"
58
#include "datatypes.h"
59
#include "logging.h"
60
#include "domain_nwfilter.h"
E
Eric Blake 已提交
61
#include "virfile.h"
62
#include "fdstream.h"
63
#include "configmake.h"
64
#include "virnetdevtap.h"
65
#include "virnodesuspend.h"
M
Martin Kletzander 已提交
66
#include "viruri.h"
67
#include "virdomainlist.h"
68

69 70
#define VIR_FROM_THIS VIR_FROM_UML

71
/* For storing short-lived temporary files. */
72
#define TEMPDIR LOCALSTATEDIR "/cache/libvirt"
73

74 75 76 77 78 79 80
typedef struct _umlDomainObjPrivate umlDomainObjPrivate;
typedef umlDomainObjPrivate *umlDomainObjPrivatePtr;
struct _umlDomainObjPrivate {
    int monitor;
    int monitorWatch;
};

81 82 83 84 85 86 87 88 89 90
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);

91

92 93
static int umlShutdown(void);

94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
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);
}


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

124

125
static int umlOpenMonitor(struct uml_driver *driver,
126
                          virDomainObjPtr vm);
127
static int umlReadPidFile(struct uml_driver *driver,
128
                          virDomainObjPtr vm);
129 130
static void umlDomainEventQueue(struct uml_driver *driver,
                                virDomainEventPtr event);
131 132 133

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

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


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

static struct uml_driver *uml_driver = NULL;

149 150 151 152 153 154
struct umlAutostartData {
    struct uml_driver *driver;
    virConnectPtr conn;
};

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

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

static void
umlAutostartConfigs(struct uml_driver *driver) {
185 186 187 188 189
    /* 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
     */
190 191 192
    virConnectPtr conn = virConnectOpen(driver->privileged ?
                                        "uml:///system" :
                                        "uml:///session");
193
    /* Ignoring NULL conn which is mostly harmless here */
194

195 196
    struct umlAutostartData data = { driver, conn };

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

201 202
    if (conn)
        virConnectClose(conn);
203 204 205 206
}


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

223
    if (res && STRPREFIX(res, "pts:")) {
224 225
        VIR_FREE(def->source.data.file.path);
        if ((def->source.data.file.path = strdup(res + 4)) == NULL) {
226
            virReportOOMError();
227 228 229 230
            VIR_FREE(res);
            VIR_FREE(cmd);
            return -1;
        }
231
    } else if (!res || STRPREFIX(res, "pts")) {
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
        /* 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
248
umlIdentifyChrPTY(struct uml_driver *driver,
249 250 251 252
                  virDomainObjPtr dom)
{
    int i;

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

    for (i = 0 ; i < dom->def->nserials; i++)
260
        if (dom->def->serials[i]->source.type == VIR_DOMAIN_CHR_TYPE_PTY &&
261
            umlIdentifyOneChrPTY(driver, dom,
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
                                 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;
280
    virDomainEventPtr event = NULL;
281

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

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

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

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

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

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

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

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

        if (!dom) {
            continue;
        }

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

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

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

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

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

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

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

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

402 403
    uml_driver->privileged = privileged;

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

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

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

417
    uml_driver->domainEventState = virDomainEventStateNew();
418 419 420
    if (!uml_driver->domainEventState)
        goto error;

421
    userdir = virGetUserDirectory();
422
    if (!userdir)
423
        goto error;
424

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

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

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

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

445 446 447 448
        if (virAsprintf(&uml_driver->monitorDir,
                        "%s/.uml", userdir) == -1)
            goto out_of_memory;
    }
449

450
    /* Configuration paths are either $XDG_CONFIG_HOME/libvirt/uml/... (session) or
451 452
     * /etc/libvirt/uml/... (system).
     */
453
    if (virAsprintf(&uml_driver->configDir, "%s/uml", base) == -1)
454 455
        goto out_of_memory;

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

    VIR_FREE(base);

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

464 465
    uml_driver->caps->privateDataAllocFunc = umlDomainObjPrivateAlloc;
    uml_driver->caps->privateDataFreeFunc = umlDomainObjPrivateFree;
466 467

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

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

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

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

491 492 493
    if (umlProcessAutoDestroyInit(uml_driver) < 0)
        goto error;

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

502 503
    umlDriverUnlock(uml_driver);

504 505
    umlAutostartConfigs(uml_driver);

506 507
    VIR_FREE(userdir);

508 509
    return 0;

510
out_of_memory:
511
    VIR_ERROR(_("umlStartup: out of memory"));
512 513

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

521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
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);
    }
}


536 537 538 539 540 541 542 543 544 545 546
/**
 * 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;

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

    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) {
569
    int active = 0;
570 571 572 573

    if (!uml_driver)
        return 0;

574
    umlDriverLock(uml_driver);
575
    active = virDomainObjListNumOfDomains(&uml_driver->domains, 1);
576
    umlDriverUnlock(uml_driver);
577

578
    return active;
579 580
}

581
static void
582
umlShutdownOneVM(void *payload, const void *name ATTRIBUTE_UNUSED, void *opaque)
583 584 585 586 587
{
    virDomainObjPtr dom = payload;
    struct uml_driver *driver = opaque;

    virDomainObjLock(dom);
588
    if (virDomainObjIsActive(dom)) {
589
        umlShutdownVMDaemon(driver, dom, VIR_DOMAIN_SHUTOFF_SHUTDOWN);
590 591
        virDomainAuditStop(dom, "shutdown");
    }
592 593 594
    virDomainObjUnlock(dom);
}

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

605
    umlDriverLock(uml_driver);
606 607
    if (uml_driver->inotifyWatch != -1)
        virEventRemoveHandle(uml_driver->inotifyWatch);
608
    VIR_FORCE_CLOSE(uml_driver->inotifyFD);
609 610
    virCapabilitiesFree(uml_driver->caps);

611 612 613
    /* shutdown active VMs
     * XXX allow them to stay around & reconnect */
    virHashForEach(uml_driver->domains.objs, umlShutdownOneVM, uml_driver);
614

615
    virDomainObjListDeinit(&uml_driver->domains);
616

617 618
    virDomainEventStateFree(uml_driver->domainEventState);

619 620 621 622 623
    VIR_FREE(uml_driver->logDir);
    VIR_FREE(uml_driver->configDir);
    VIR_FREE(uml_driver->autostartDir);
    VIR_FREE(uml_driver->monitorDir);

624 625
    umlProcessAutoDestroyShutdown(uml_driver);

626
    umlDriverUnlock(uml_driver);
627
    virMutexDestroy(&uml_driver->lock);
628 629 630 631 632 633
    VIR_FREE(uml_driver);

    return 0;
}


634 635 636 637 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
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;
}


732
static int umlReadPidFile(struct uml_driver *driver,
733 734 735 736 737 738 739 740
                          virDomainObjPtr vm)
{
    int rc = -1;
    FILE *file;
    char *pidfile = NULL;
    int retries = 0;

    vm->pid = -1;
741 742
    if (virAsprintf(&pidfile, "%s/%s/pid",
                    driver->monitorDir, vm->def->name) < 0) {
743
        virReportOOMError();
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
        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;
759
        VIR_FORCE_FCLOSE(file);
760 761 762
        goto cleanup;
    }

763
    if (VIR_FCLOSE(file) < 0)
764 765 766 767 768 769
        goto cleanup;

    rc = 0;

 cleanup:
    if (rc != 0)
770
        virReportSystemError(errno,
771 772
                             _("failed to read pid: %s"),
                             pidfile);
773 774 775 776
    VIR_FREE(pidfile);
    return rc;
}

777
static int umlMonitorAddress(const struct uml_driver *driver,
778 779 780
                             virDomainObjPtr vm,
                             struct sockaddr_un *addr) {
    char *sockname;
C
Chris Lalancette 已提交
781
    int retval = 0;
782

783 784
    if (virAsprintf(&sockname, "%s/%s/mconsole",
                    driver->monitorDir, vm->def->name) < 0) {
785
        virReportOOMError();
786 787 788
        return -1;
    }

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

800
static int umlOpenMonitor(struct uml_driver *driver,
801 802 803 804
                          virDomainObjPtr vm) {
    struct sockaddr_un addr;
    struct stat sb;
    int retries = 0;
805
    umlDomainObjPrivatePtr priv = vm->privateData;
806

807
    if (umlMonitorAddress(driver, vm, &addr) < 0)
808 809
        return -1;

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

821
    if ((priv->monitor = socket(PF_UNIX, SOCK_DGRAM, 0)) < 0) {
822
        virReportSystemError(errno,
823
                             "%s", _("cannot open socket"));
824 825 826
        return -1;
    }

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


861
static int umlMonitorCommand(const struct uml_driver *driver,
862 863 864 865 866 867 868 869 870 871
                             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;
872
    umlDomainObjPrivatePtr priv = vm->privateData;
873

874 875
    VIR_DEBUG("Run command '%s'", cmd);

876 877
    *reply = NULL;

878
    if (umlMonitorAddress(driver, vm, &addr) < 0)
879 880 881 882 883 884 885
        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)) {
886
        virReportSystemError(EINVAL,
887 888
                             _("cannot send too long command %s (%d bytes)"),
                             cmd, req.length);
889 890
        return -1;
    }
C
Chris Lalancette 已提交
891
    if (virStrcpyStatic(req.data, cmd) == NULL) {
892
        umlReportError(VIR_ERR_INTERNAL_ERROR,
C
Chris Lalancette 已提交
893 894 895
                       _("Command %s too long for destination"), cmd);
        return -1;
    }
896

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

    do {
E
Eric Blake 已提交
906
        ssize_t nbytes;
907
        addrlen = sizeof(addr);
908
        nbytes = recvfrom(priv->monitor, &res, sizeof(res), 0,
909
                          (struct sockaddr *)&addr, &addrlen);
E
Eric Blake 已提交
910 911 912
        if (nbytes < 0) {
            if (errno == EAGAIN || errno == EINTR)
                continue;
913
            virReportSystemError(errno, _("cannot read reply %s"), cmd);
914 915
            goto error;
        }
916 917 918
        /* 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) {
919 920 921
            virReportSystemError(0, _("incomplete reply %s"), cmd);
            goto error;
        }
922 923

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

        if (res.error)
            ret = -1;

    } while (res.extra);

936 937
    VIR_DEBUG("Command reply is '%s'", NULLSTR(retdata));

938 939 940 941
    if (ret < 0)
        VIR_FREE(retdata);
    else
        *reply = retdata;
942 943 944 945 946 947 948 949 950

    return ret;

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


951
static void umlCleanupTapDevices(virDomainObjPtr vm) {
952 953 954 955 956 957 958 959 960
    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;

961
        ignore_value(virNetDevTapDelete(def->ifname));
962 963 964
    }
}

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

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

    if (!vm->def->os.kernel) {
983 984
        umlReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("no kernel specified"));
985 986 987 988 989 990
        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 已提交
991
    if (!virFileIsExecutable(vm->def->os.kernel)) {
992
        virReportSystemError(errno,
993 994
                             _("Cannot find UML kernel %s"),
                             vm->def->os.kernel);
995 996 997
        return -1;
    }

998
    if (virFileMakePath(driver->logDir) < 0) {
999
        virReportSystemError(errno,
1000 1001
                             _("cannot create log directory %s"),
                             driver->logDir);
1002 1003 1004
        return -1;
    }

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

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

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

1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
    /* 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;
    }

1038 1039
    if (!(cmd = umlBuildCommandLine(conn, driver, vm)))
        goto cleanup;
1040

1041 1042 1043 1044 1045 1046 1047 1048
    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 已提交
1049
    virCommandWriteArgLog(cmd, logfd);
1050

1051
    priv->monitor = -1;
1052

D
Daniel P. Berrange 已提交
1053 1054 1055 1056 1057 1058
    virCommandClearCaps(cmd);
    virCommandSetOutputFD(cmd, &logfd);
    virCommandSetErrorFD(cmd, &logfd);
    virCommandDaemonize(cmd);

    ret = virCommandRun(cmd, NULL);
1059 1060
    if (ret < 0)
        goto cleanup;
1061

1062
    if (autoDestroy &&
1063
        (ret = umlProcessAutoDestroyAdd(driver, vm, conn)) < 0)
1064 1065
        goto cleanup;

1066
    ret = virDomainObjSetDefTransient(driver->caps, vm, false);
1067
cleanup:
1068
    VIR_FORCE_CLOSE(logfd);
D
Daniel P. Berrange 已提交
1069
    virCommandFree(cmd);
1070

1071 1072
    if (ret < 0) {
        virDomainConfVMNWFilterTeardown(vm);
1073
        umlCleanupTapDevices(vm);
1074 1075 1076 1077 1078 1079
        if (vm->newDef) {
            virDomainDefFree(vm->def);
            vm->def = vm->newDef;
            vm->def->id = -1;
            vm->newDef = NULL;
        }
1080 1081
    }

1082 1083
    /* NB we don't mark it running here - we do that async
       with inotify */
1084 1085 1086
    /* XXX what if someone else tries to start it again
       before we get the inotification ? Sounds like
       trouble.... */
1087
    /* XXX this is bad for events too. must fix this better */
1088 1089 1090 1091

    return ret;
}

1092
static void umlShutdownVMDaemon(struct uml_driver *driver,
J
Jiri Denemark 已提交
1093 1094
                                virDomainObjPtr vm,
                                virDomainShutoffReason reason)
1095 1096
{
    int ret;
1097 1098
    umlDomainObjPrivatePtr priv = vm->privateData;

D
Daniel P. Berrange 已提交
1099
    if (!virDomainObjIsActive(vm))
1100 1101
        return;

1102
    virKillProcess(vm->pid, SIGTERM);
1103

1104
    VIR_FORCE_CLOSE(priv->monitor);
1105 1106

    if ((ret = waitpid(vm->pid, NULL, 0)) != vm->pid) {
1107
        VIR_WARN("Got unexpected pid %d != %d",
1108 1109 1110 1111 1112
               ret, vm->pid);
    }

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

1115
    virDomainConfVMNWFilterTeardown(vm);
1116 1117 1118 1119
    umlCleanupTapDevices(vm);

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

1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
    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 已提交
1132 1133 1134 1135
                                unsigned int flags)
{
    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);

1136 1137 1138
    if (conn->uri == NULL) {
        if (uml_driver == NULL)
            return VIR_DRV_OPEN_DECLINED;
1139

1140 1141 1142
        if (!(conn->uri = virURIParse(uml_driver->privileged ?
                                      "uml:///system" :
                                      "uml:///session")))
1143 1144 1145 1146 1147 1148 1149 1150 1151
            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;
1152 1153


1154
        /* Check path and tell them correct path if they made a mistake */
1155
        if (uml_driver->privileged) {
1156
            if (STRNEQ (conn->uri->path, "/system") &&
1157
                STRNEQ (conn->uri->path, "/session")) {
1158
                umlReportError(VIR_ERR_INTERNAL_ERROR,
1159 1160 1161 1162 1163 1164
                               _("unexpected UML URI path '%s', try uml:///system"),
                               conn->uri->path);
                return VIR_DRV_OPEN_ERROR;
            }
        } else {
            if (STRNEQ (conn->uri->path, "/session")) {
1165
                umlReportError(VIR_ERR_INTERNAL_ERROR,
1166 1167 1168 1169
                               _("unexpected UML URI path '%s', try uml:///session"),
                               conn->uri->path);
                return VIR_DRV_OPEN_ERROR;
            }
1170
        }
1171 1172 1173

        /* URI was good, but driver isn't active */
        if (uml_driver == NULL) {
1174
            umlReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1175
                           _("uml state driver is not active"));
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
            return VIR_DRV_OPEN_ERROR;
        }
    }

    conn->privateData = uml_driver;

    return VIR_DRV_OPEN_SUCCESS;
}

static int umlClose(virConnectPtr conn) {
1186 1187 1188
    struct uml_driver *driver = conn->privateData;

    umlDriverLock(driver);
1189
    umlProcessAutoDestroyRun(driver, conn);
1190
    umlDriverUnlock(driver);
1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201

    conn->privateData = NULL;

    return 0;
}

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


1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
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;
}


1216 1217 1218 1219 1220 1221
static int umlIsAlive(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    return 1;
}


1222 1223 1224 1225
static char *umlGetCapabilities(virConnectPtr conn) {
    struct uml_driver *driver = (struct uml_driver *)conn->privateData;
    char *xml;

1226
    umlDriverLock(driver);
1227
    if ((xml = virCapabilitiesFormatXML(driver->caps)) == NULL)
1228
        virReportOOMError();
1229
    umlDriverUnlock(driver);
1230 1231 1232 1233 1234 1235

    return xml;
}



1236
static int umlGetProcessInfo(unsigned long long *cpuTime, pid_t pid)
1237 1238
{
    char *proc;
1239 1240 1241
    FILE *pidinfo;
    unsigned long long usertime, systime;

1242
    if (virAsprintf(&proc, "/proc/%lld/stat", (long long) pid) < 0) {
1243 1244 1245 1246 1247 1248
        return -1;
    }

    if (!(pidinfo = fopen(proc, "r"))) {
        /* VM probably shut down, so fake 0 */
        *cpuTime = 0;
1249
        VIR_FREE(proc);
1250 1251 1252
        return 0;
    }

1253 1254
    VIR_FREE(proc);

1255 1256
    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");
1257
        VIR_FORCE_FCLOSE(pidinfo);
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
        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);

1270
    VIR_FORCE_FCLOSE(pidinfo);
1271 1272 1273 1274 1275 1276 1277 1278

    return 0;
}


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

1282
    umlDriverLock(driver);
1283
    vm = virDomainFindByID(&driver->domains, id);
1284 1285
    umlDriverUnlock(driver);

1286
    if (!vm) {
1287
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1288
        goto cleanup;
1289 1290 1291 1292
    }

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

cleanup:
1295 1296
    if (vm)
        virDomainObjUnlock(vm);
1297 1298
    return dom;
}
1299

1300 1301 1302
static virDomainPtr umlDomainLookupByUUID(virConnectPtr conn,
                                            const unsigned char *uuid) {
    struct uml_driver *driver = (struct uml_driver *)conn->privateData;
1303 1304
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
1305

1306
    umlDriverLock(driver);
1307
    vm = virDomainFindByUUID(&driver->domains, uuid);
1308 1309
    umlDriverUnlock(driver);

1310
    if (!vm) {
1311
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1312
        goto cleanup;
1313 1314 1315 1316
    }

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

cleanup:
1319 1320
    if (vm)
        virDomainObjUnlock(vm);
1321 1322
    return dom;
}
1323

1324 1325 1326
static virDomainPtr umlDomainLookupByName(virConnectPtr conn,
                                            const char *name) {
    struct uml_driver *driver = (struct uml_driver *)conn->privateData;
1327 1328
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;
1329

1330
    umlDriverLock(driver);
1331
    vm = virDomainFindByName(&driver->domains, name);
1332 1333
    umlDriverUnlock(driver);

1334
    if (!vm) {
1335
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1336
        goto cleanup;
1337 1338 1339 1340
    }

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

cleanup:
1343 1344
    if (vm)
        virDomainObjUnlock(vm);
1345 1346 1347
    return dom;
}

1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358

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) {
1359
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
        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) {
1381
        umlReportError(VIR_ERR_NO_DOMAIN, NULL);
1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
        goto cleanup;
    }
    ret = obj->persistent;

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

1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
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;
}
1412

1413
static int umlGetVersion(virConnectPtr conn, unsigned long *version) {
1414
    struct uml_driver *driver = conn->privateData;
1415
    struct utsname ut;
1416
    int ret = -1;
1417

1418
    umlDriverLock(driver);
1419 1420 1421 1422

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

1423
        if (virParseVersionString(ut.release, &driver->umlVersion, true) < 0) {
1424
            umlReportError(VIR_ERR_INTERNAL_ERROR,
1425 1426 1427
                           _("cannot parse version %s"), ut.release);
            goto cleanup;
        }
1428 1429
    }

1430 1431 1432 1433 1434 1435
    *version = driver->umlVersion;
    ret = 0;

cleanup:
    umlDriverUnlock(driver);
    return ret;
1436 1437 1438
}

static int umlListDomains(virConnectPtr conn, int *ids, int nids) {
1439
    struct uml_driver *driver = conn->privateData;
1440
    int n;
1441

1442
    umlDriverLock(driver);
1443
    n = virDomainObjListGetActiveIDs(&driver->domains, ids, nids);
1444
    umlDriverUnlock(driver);
1445

1446
    return n;
1447 1448
}
static int umlNumDomains(virConnectPtr conn) {
1449
    struct uml_driver *driver = conn->privateData;
1450
    int n;
1451

1452
    umlDriverLock(driver);
1453
    n = virDomainObjListNumOfDomains(&driver->domains, 1);
1454
    umlDriverUnlock(driver);
1455 1456 1457 1458

    return n;
}
static virDomainPtr umlDomainCreate(virConnectPtr conn, const char *xml,
1459
                                      unsigned int flags) {
1460
    struct uml_driver *driver = conn->privateData;
1461
    virDomainDefPtr def;
1462
    virDomainObjPtr vm = NULL;
1463
    virDomainPtr dom = NULL;
1464
    virDomainEventPtr event = NULL;
1465

1466
    virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, NULL);
1467

1468
    umlDriverLock(driver);
1469
    if (!(def = virDomainDefParseString(driver->caps, xml,
M
Matthias Bolte 已提交
1470
                                        1 << VIR_DOMAIN_VIRT_UML,
1471
                                        VIR_DOMAIN_XML_INACTIVE)))
1472
        goto cleanup;
1473

1474
    if (virDomainObjIsDuplicate(&driver->domains, def, 1) < 0)
1475
        goto cleanup;
1476

1477
    if (!(vm = virDomainAssignDef(driver->caps,
1478
                                  &driver->domains,
1479
                                  def, false)))
1480 1481
        goto cleanup;
    def = NULL;
1482

1483 1484
    if (umlStartVMDaemon(conn, driver, vm,
                         (flags & VIR_DOMAIN_START_AUTODESTROY)) < 0) {
1485
        virDomainAuditStart(vm, "booted", false);
1486 1487
        virDomainRemoveInactive(&driver->domains,
                                vm);
1488 1489
        vm = NULL;
        goto cleanup;
1490
    }
1491
    virDomainAuditStart(vm, "booted", true);
1492 1493 1494
    event = virDomainEventNewFromObj(vm,
                                     VIR_DOMAIN_EVENT_STARTED,
                                     VIR_DOMAIN_EVENT_STARTED_BOOTED);
1495 1496 1497

    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom) dom->id = vm->def->id;
1498 1499 1500

cleanup:
    virDomainDefFree(def);
1501 1502
    if (vm)
        virDomainObjUnlock(vm);
1503 1504
    if (event)
        umlDomainEventQueue(driver, event);
1505
    umlDriverUnlock(driver);
1506 1507 1508 1509
    return dom;
}


1510 1511
static int umlDomainShutdownFlags(virDomainPtr dom,
                                  unsigned int flags) {
1512 1513
    struct uml_driver *driver = dom->conn->privateData;
    virDomainObjPtr vm;
1514
    char *info = NULL;
1515
    int ret = -1;
1516

1517 1518
    virCheckFlags(0, -1);

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

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

1537 1538
cleanup:
    VIR_FREE(info);
1539 1540
    if (vm)
        virDomainObjUnlock(vm);
1541
    return ret;
1542 1543
}

1544 1545 1546 1547 1548
static int
umlDomainShutdown(virDomainPtr dom)
{
    return umlDomainShutdownFlags(dom, 0);
}
1549

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

1559 1560
    virCheckFlags(0, -1);

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

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

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


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


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

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

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

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

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

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

1632 1633 1634 1635
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];

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

1642
cleanup:
1643 1644
    if (vm)
        virDomainObjUnlock(vm);
1645
    return ret;
1646 1647 1648
}

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

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

1657 1658 1659 1660
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];

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

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

1672
    vm->def->mem.max_balloon = newmax;
1673 1674 1675
    ret = 0;

cleanup:
1676 1677
    if (vm)
        virDomainObjUnlock(vm);
1678
    return ret;
1679 1680 1681
}

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

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

1690 1691 1692 1693
    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];

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

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

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

1711
    vm->def->mem.cur_balloon = newmem;
1712 1713 1714
    ret = 0;

cleanup:
1715 1716
    if (vm)
        virDomainObjUnlock(vm);
1717
    return ret;
1718 1719 1720 1721
}

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

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

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

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

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

1748 1749
    info->maxMem = vm->def->mem.max_balloon;
    info->memory = vm->def->mem.cur_balloon;
1750
    info->nrVirtCpu = vm->def->vcpus;
1751 1752 1753
    ret = 0;

cleanup:
1754 1755
    if (vm)
        virDomainObjUnlock(vm);
1756
    return ret;
1757 1758 1759
}


1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781
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 已提交
1782
    *state = virDomainObjGetState(vm, reason);
1783 1784 1785 1786 1787 1788 1789 1790 1791
    ret = 0;

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


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

1799
    /* Flags checked by virDomainDefFormat */
E
Eric Blake 已提交
1800

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

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

1811
    ret = virDomainDefFormat((flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef ?
1812 1813 1814 1815
                             vm->newDef : vm->def,
                             flags);

cleanup:
1816 1817
    if (vm)
        virDomainObjUnlock(vm);
1818
    return ret;
1819 1820 1821 1822 1823
}


static int umlListDefinedDomains(virConnectPtr conn,
                            char **const names, int nnames) {
1824
    struct uml_driver *driver = conn->privateData;
1825
    int n;
1826

1827
    umlDriverLock(driver);
1828
    n = virDomainObjListGetInactiveNames(&driver->domains, names, nnames);
1829
    umlDriverUnlock(driver);
1830

1831
    return n;
1832 1833 1834
}

static int umlNumDefinedDomains(virConnectPtr conn) {
1835
    struct uml_driver *driver = conn->privateData;
1836
    int n;
1837

1838
    umlDriverLock(driver);
1839
    n = virDomainObjListNumOfDomains(&driver->domains, 0);
1840
    umlDriverUnlock(driver);
1841 1842 1843 1844 1845

    return n;
}


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

1852
    virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, -1);
1853

1854
    umlDriverLock(driver);
1855
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
1856

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

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

cleanup:
1872 1873
    if (vm)
        virDomainObjUnlock(vm);
1874 1875
    if (event)
        umlDomainEventQueue(driver, event);
1876
    umlDriverUnlock(driver);
1877
    return ret;
1878 1879
}

1880 1881 1882
static int umlDomainStart(virDomainPtr dom) {
    return umlDomainStartWithFlags(dom, 0);
}
1883 1884

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

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

1896 1897 1898
    if (virDomainObjIsDuplicate(&driver->domains, def, 0) < 0)
        goto cleanup;

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

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

    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom) dom->id = vm->def->id;
1916 1917 1918

cleanup:
    virDomainDefFree(def);
1919 1920 1921
    if (vm)
        virDomainObjUnlock(vm);
    umlDriverUnlock(driver);
1922 1923 1924
    return dom;
}

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

1932 1933
    virCheckFlags(0, -1);

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

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

1948
    if (virDomainDeleteConfig(driver->configDir, driver->autostartDir, vm) < 0)
1949
        goto cleanup;
1950

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

1958
    ret = 0;
1959

1960
cleanup:
1961 1962 1963
    if (vm)
        virDomainObjUnlock(vm);
    umlDriverUnlock(driver);
1964
    return ret;
1965 1966 1967
}


1968 1969 1970 1971 1972
static int umlDomainUndefine(virDomainPtr dom)
{
    return umlDomainUndefineFlags(dom, 0);
}

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 2078 2079 2080
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;
}


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

2088
    if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
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 2190 2191 2192
        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;
}


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

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

    return umlDomainDetachDevice(dom, xml);
}

2209 2210 2211

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

2216
    umlDriverLock(driver);
2217
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);
2218

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

    *autostart = vm->autostart;
2226
    ret = 0;
2227

2228
cleanup:
2229 2230
    if (vm)
        virDomainObjUnlock(vm);
2231
    umlDriverUnlock(driver);
2232
    return ret;
2233 2234 2235 2236
}

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

2242 2243 2244
    umlDriverLock(driver);
    vm = virDomainFindByUUID(&driver->domains, dom->uuid);

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

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

    autostart = (autostart != 0);

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

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

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

2288
        vm->autostart = autostart;
2289 2290 2291 2292 2293 2294
    }
    ret = 0;

cleanup:
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
2295 2296
    if (vm)
        virDomainObjUnlock(vm);
2297
    umlDriverUnlock(driver);
2298 2299 2300 2301 2302
    return ret;
}


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

E
Eric Blake 已提交
2314 2315
    virCheckFlags(0, -1);

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

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

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

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

2340 2341 2342 2343 2344 2345 2346
    /* 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;
    }
2347

2348 2349 2350 2351 2352 2353 2354 2355 2356
    /* 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;
2357 2358
    }

2359 2360
    ret = 0;

2361
cleanup:
2362
    VIR_FORCE_CLOSE(fd);
2363 2364
    if (vm)
        virDomainObjUnlock(vm);
2365 2366 2367 2368
    return ret;
}


2369 2370
static int
umlDomainOpenConsole(virDomainPtr dom,
2371
                     const char *dev_name,
2372 2373 2374 2375 2376 2377 2378 2379
                     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;
2380
    size_t i;
2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398

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

2399
    if (dev_name) {
2400 2401 2402 2403 2404 2405 2406
        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;
            }
        }
2407
    } else {
2408 2409
        if (vm->def->nconsoles)
            chr = vm->def->consoles[0];
2410 2411 2412 2413 2414 2415
        else if (vm->def->nserials)
            chr = vm->def->serials[0];
    }

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

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

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

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

2439

2440 2441 2442 2443 2444 2445 2446 2447 2448 2449
static int
umlDomainEventRegister(virConnectPtr conn,
                       virConnectDomainEventCallback callback,
                       void *opaque,
                       virFreeCallback freecb)
{
    struct uml_driver *driver = conn->privateData;
    int ret;

    umlDriverLock(driver);
2450 2451 2452
    ret = virDomainEventStateRegister(conn,
                                      driver->domainEventState,
                                      callback, opaque, freecb);
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
    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);
2486 2487 2488 2489
    if (virDomainEventStateRegisterID(conn,
                                      driver->domainEventState,
                                      dom, eventID,
                                      callback, opaque, freecb, &ret) < 0)
2490
        ret = -1;
2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504
    umlDriverUnlock(driver);

    return ret;
}


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

    umlDriverLock(driver);
2505 2506 2507
    ret = virDomainEventStateDeregisterID(conn,
                                          driver->domainEventState,
                                          callbackID);
2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
    umlDriverUnlock(driver);

    return ret;
}


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

2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536
static int umlListAllDomains(virConnectPtr conn,
                             virDomainPtr **domains,
                             unsigned int flags)
{
    struct uml_driver *driver = conn->privateData;
    int ret = -1;

    virCheckFlags(VIR_CONNECT_LIST_FILTERS_ALL, -1);

    umlDriverLock(driver);
    ret = virDomainList(conn, driver->domains.objs, domains, flags);
    umlDriverUnlock(driver);

    return ret;
}

2537 2538


2539
static virDriver umlDriver = {
2540 2541
    .no = VIR_DRV_UML,
    .name = "UML",
2542 2543 2544 2545 2546 2547 2548 2549 2550
    .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 */
2551
    .listAllDomains = umlListAllDomains, /* 0.9.13 */
2552 2553 2554 2555 2556
    .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 */
2557
    .domainShutdownFlags = umlDomainShutdownFlags, /* 0.9.10 */
2558
    .domainDestroy = umlDomainDestroy, /* 0.5.0 */
2559
    .domainDestroyFlags = umlDomainDestroyFlags, /* 0.9.4 */
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572
    .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 */
2573
    .domainUndefineFlags = umlDomainUndefineFlags, /* 0.9.4 */
2574 2575 2576 2577 2578 2579 2580
    .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 */
2581
    .nodeGetCPUStats = nodeGetCPUStats, /* 0.9.3 */
2582
    .nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.3 */
2583 2584
    .nodeGetCellsFreeMemory = nodeGetCellsFreeMemory, /* 0.5.0 */
    .nodeGetFreeMemory = nodeGetFreeMemory, /* 0.5.0 */
2585 2586
    .domainEventRegister = umlDomainEventRegister, /* 0.9.4 */
    .domainEventDeregister = umlDomainEventDeregister, /* 0.9.4 */
2587 2588 2589 2590 2591
    .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 */
2592 2593
    .domainEventRegisterAny = umlDomainEventRegisterAny, /* 0.9.4 */
    .domainEventDeregisterAny = umlDomainEventDeregisterAny, /* 0.9.4 */
2594
    .domainOpenConsole = umlDomainOpenConsole, /* 0.8.6 */
2595
    .isAlive = umlIsAlive, /* 0.9.8 */
2596
    .nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
2597 2598
};

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

    return 0;
}
2607 2608

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

2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
static void
umlVMDriverLock(void)
{
    umlDriverLock(uml_driver);
}

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

2628 2629 2630
static virNWFilterCallbackDriver umlCallbackDriver = {
    .name = "UML",
    .vmFilterRebuild = umlVMFilterRebuild,
2631 2632
    .vmDriverLock = umlVMDriverLock,
    .vmDriverUnlock = umlVMDriverUnlock,
2633 2634
};

2635 2636 2637
int umlRegister(void) {
    virRegisterDriver(&umlDriver);
    virRegisterStateDriver(&umlStateDriver);
2638
    virNWFilterRegisterCallbackDriver(&umlCallbackDriver);
2639 2640
    return 0;
}