bhyve_driver.c 43.9 KB
Newer Older
R
Roman Bogorodskiy 已提交
1 2 3 4
/*
 * bhyve_driver.c: core driver methods for managing bhyve guests
 *
 * Copyright (C) 2014 Roman Bogorodskiy
5
 * Copyright (C) 2014-2015 Red Hat, Inc.
R
Roman Bogorodskiy 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * 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, see
 * <http://www.gnu.org/licenses/>.
 *
 * Author: Roman Bogorodskiy
 */

#include <config.h>

26
#include <fcntl.h>
R
Roman Bogorodskiy 已提交
27 28 29 30 31 32 33 34 35 36 37
#include <sys/utsname.h>

#include "virerror.h"
#include "datatypes.h"
#include "virbuffer.h"
#include "viruuid.h"
#include "configmake.h"
#include "viralloc.h"
#include "network_conf.h"
#include "interface_conf.h"
#include "domain_audit.h"
R
Roman Bogorodskiy 已提交
38
#include "domain_event.h"
R
Roman Bogorodskiy 已提交
39 40 41 42
#include "snapshot_conf.h"
#include "fdstream.h"
#include "storage_conf.h"
#include "node_device_conf.h"
43
#include "virdomainobjlist.h"
R
Roman Bogorodskiy 已提交
44 45 46 47 48 49 50 51 52
#include "virxml.h"
#include "virthread.h"
#include "virlog.h"
#include "virfile.h"
#include "virtypedparam.h"
#include "virrandom.h"
#include "virstring.h"
#include "cpu/cpu.h"
#include "viraccessapicheck.h"
53
#include "nodeinfo.h"
54 55
#include "virhostcpu.h"
#include "virhostmem.h"
R
Roman Bogorodskiy 已提交
56

57
#include "bhyve_device.h"
R
Roman Bogorodskiy 已提交
58
#include "bhyve_driver.h"
59
#include "bhyve_command.h"
60
#include "bhyve_parse_command.h"
61
#include "bhyve_domain.h"
R
Roman Bogorodskiy 已提交
62
#include "bhyve_process.h"
63
#include "bhyve_capabilities.h"
R
Roman Bogorodskiy 已提交
64 65 66

#define VIR_FROM_THIS   VIR_FROM_BHYVE

67 68
VIR_LOG_INIT("bhyve.bhyve_driver");

R
Roman Bogorodskiy 已提交
69 70 71 72 73 74 75 76 77 78 79 80 81 82
bhyveConnPtr bhyve_driver = NULL;

void
bhyveDriverLock(bhyveConnPtr driver)
{
    virMutexLock(&driver->lock);
}

void
bhyveDriverUnlock(bhyveConnPtr driver)
{
    virMutexUnlock(&driver->lock);
}

83 84 85 86 87 88 89 90 91 92 93
static int
bhyveAutostartDomain(virDomainObjPtr vm, void *opaque)
{
    const struct bhyveAutostartData *data = opaque;
    int ret = 0;
    virObjectLock(vm);
    if (vm->autostart && !virDomainObjIsActive(vm)) {
        virResetLastError();
        ret = virBhyveProcessStart(data->conn, data->driver, vm,
                                   VIR_DOMAIN_RUNNING_BOOTED, 0);
        if (ret < 0) {
94 95 96
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Failed to autostart VM '%s': %s"),
                           vm->def->name, virGetLastErrorMessage());
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
        }
    }
    virObjectUnlock(vm);
    return ret;
}

static void
bhyveAutostartDomains(bhyveConnPtr driver)
{
    /* 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
     */
    virConnectPtr conn = virConnectOpen("bhyve:///system");
    /* Ignoring NULL conn which is mostly harmless here */

    struct bhyveAutostartData data = { driver, conn };

    virDomainObjListForEach(driver->domains, bhyveAutostartDomain, &data);

    virObjectUnref(conn);
}

121 122 123 124 125 126 127 128 129 130
/**
 * bhyveDriverGetCapabilities:
 *
 * Get a reference to the virCapsPtr instance for the
 * driver.
 *
 * The caller must release the reference with virObjetUnref
 *
 * Returns: a reference to a virCapsPtr instance or NULL
 */
M
Michal Privoznik 已提交
131
virCapsPtr ATTRIBUTE_NONNULL(1)
132
bhyveDriverGetCapabilities(bhyveConnPtr driver)
R
Roman Bogorodskiy 已提交
133 134
{

135
    return virObjectRef(driver->caps);
R
Roman Bogorodskiy 已提交
136 137 138 139 140 141
}

static char *
bhyveConnectGetCapabilities(virConnectPtr conn)
{
    bhyveConnPtr privconn = conn->privateData;
142
    virCapsPtr caps;
143
    char *xml = NULL;
R
Roman Bogorodskiy 已提交
144 145 146 147

    if (virConnectGetCapabilitiesEnsureACL(conn) < 0)
        return NULL;

148
    if (!(caps = bhyveDriverGetCapabilities(privconn))) {
149 150
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Unable to get Capabilities"));
151 152
        goto cleanup;
    }
153

154
    if (!(xml = virCapabilitiesFormatXML(caps)))
155
        goto cleanup;
R
Roman Bogorodskiy 已提交
156

157 158
 cleanup:
    virObjectUnref(caps);
R
Roman Bogorodskiy 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
    return xml;
}

static virDomainObjPtr
bhyveDomObjFromDomain(virDomainPtr domain)
{
    virDomainObjPtr vm;
    bhyveConnPtr privconn = domain->conn->privateData;
    char uuidstr[VIR_UUID_STRING_BUFLEN];

    vm = virDomainObjListFindByUUID(privconn->domains, domain->uuid);
    if (!vm) {
        virUUIDFormat(domain->uuid, uuidstr);
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("no domain with matching uuid '%s' (%s)"),
                       uuidstr, domain->name);
        return NULL;
    }

    return vm;
}

static virDrvOpenStatus
bhyveConnectOpen(virConnectPtr conn,
                 virConnectAuthPtr auth ATTRIBUTE_UNUSED,
184
                 virConfPtr conf ATTRIBUTE_UNUSED,
R
Roman Bogorodskiy 已提交
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
                 unsigned int flags)
{
     virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);

     if (conn->uri == NULL) {
         if (bhyve_driver == NULL)
             return VIR_DRV_OPEN_DECLINED;

         if (!(conn->uri = virURIParse("bhyve:///system")))
             return VIR_DRV_OPEN_ERROR;
     } else {
         if (!conn->uri->scheme || STRNEQ(conn->uri->scheme, "bhyve"))
             return VIR_DRV_OPEN_DECLINED;

         if (conn->uri->server)
             return VIR_DRV_OPEN_DECLINED;

202
         if (STRNEQ_NULLABLE(conn->uri->path, "/system")) {
R
Roman Bogorodskiy 已提交
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unexpected bhyve URI path '%s', try bhyve:///system"),
                           conn->uri->path);
            return VIR_DRV_OPEN_ERROR;
         }

         if (bhyve_driver == NULL) {
             virReportError(VIR_ERR_INTERNAL_ERROR,
                            "%s", _("bhyve state driver is not active"));
             return VIR_DRV_OPEN_ERROR;
         }
     }

     if (virConnectOpenEnsureACL(conn) < 0)
         return VIR_DRV_OPEN_ERROR;

     conn->privateData = bhyve_driver;

     return VIR_DRV_OPEN_SUCCESS;
}

static int
bhyveConnectClose(virConnectPtr conn)
{
227 228 229
    bhyveConnPtr privconn = conn->privateData;

    virCloseCallbacksRun(privconn->closeCallbacks, conn, privconn->domains, privconn);
R
Roman Bogorodskiy 已提交
230 231 232 233 234 235
    conn->privateData = NULL;

    return 0;
}

static char *
236
bhyveConnectGetHostname(virConnectPtr conn)
R
Roman Bogorodskiy 已提交
237 238 239 240 241 242 243
{
    if (virConnectGetHostnameEnsureACL(conn) < 0)
        return NULL;

    return virGetHostname();
}

244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
static char *
bhyveConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
{
    bhyveConnPtr privconn = conn->privateData;
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    virCheckFlags(0, NULL);

    if (virConnectGetSysinfoEnsureACL(conn) < 0)
        return NULL;

    if (!privconn->hostsysinfo) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Host SMBIOS information is not available"));
        return NULL;
    }

    if (virSysinfoFormat(&buf, privconn->hostsysinfo) < 0)
        return NULL;
263
    if (virBufferCheckError(&buf) < 0)
264 265 266 267 268
        return NULL;

    return virBufferContentAndReset(&buf);
}

R
Roman Bogorodskiy 已提交
269
static int
270
bhyveConnectGetVersion(virConnectPtr conn, unsigned long *version)
R
Roman Bogorodskiy 已提交
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
{
    struct utsname ver;

    if (virConnectGetVersionEnsureACL(conn) < 0)
        return -1;

    uname(&ver);

    if (virParseVersionString(ver.release, version, true) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Unknown release: %s"), ver.release);
        return -1;
    }

    return 0;
}

static int
bhyveDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info)
{
    virDomainObjPtr vm;
    int ret = -1;

    if (!(vm = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainGetInfoEnsureACL(domain->conn, vm->def) < 0)
        goto cleanup;

300 301 302 303 304 305 306
    if (virDomainObjIsActive(vm)) {
        if (virBhyveGetDomainTotalCpuStats(vm, &(info->cpuTime)) < 0)
            goto cleanup;
    } else {
        info->cpuTime = 0;
    }

R
Roman Bogorodskiy 已提交
307
    info->state = virDomainObjGetState(vm, NULL);
308
    info->maxMem = virDomainDefGetMemoryTotal(vm->def);
309
    info->nrVirtCpu = virDomainDefGetVcpus(vm->def);
R
Roman Bogorodskiy 已提交
310 311
    ret = 0;

312
 cleanup:
313 314
    if (vm)
        virObjectUnlock(vm);
R
Roman Bogorodskiy 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
    return ret;
}

static int
bhyveDomainGetState(virDomainPtr domain,
                    int *state,
                    int *reason,
                    unsigned int flags)
{
    virDomainObjPtr vm;
    int ret = -1;

    virCheckFlags(0, -1);

    if (!(vm = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainGetStateEnsureACL(domain->conn, vm->def) < 0)
       goto cleanup;

    *state = virDomainObjGetState(vm, reason);
    ret = 0;

338
 cleanup:
339 340
    if (vm)
        virObjectUnlock(vm);
R
Roman Bogorodskiy 已提交
341 342 343
    return ret;
}

344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
static int
bhyveDomainGetAutostart(virDomainPtr domain, int *autostart)
{
    virDomainObjPtr vm;
    int ret = -1;

    if (!(vm = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainGetAutostartEnsureACL(domain->conn, vm->def) < 0)
        goto cleanup;

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

 cleanup:
360 361
    if (vm)
        virObjectUnlock(vm);
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
    return ret;
}

static int
bhyveDomainSetAutostart(virDomainPtr domain, int autostart)
{
    virDomainObjPtr vm;
    char *configFile = NULL;
    char *autostartLink = NULL;
    int ret = -1;

    if (!(vm = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainSetAutostartEnsureACL(domain->conn, vm->def) < 0)
        goto cleanup;

    if (!vm->persistent) {
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("cannot set autostart for transient domain"));
        goto cleanup;
    }

    autostart = (autostart != 0);

    if (vm->autostart != autostart) {
        if ((configFile = virDomainConfigFile(BHYVE_CONFIG_DIR, vm->def->name)) == NULL)
            goto cleanup;
        if ((autostartLink = virDomainConfigFile(BHYVE_AUTOSTART_DIR, vm->def->name)) == NULL)
            goto cleanup;

        if (autostart) {
            if (virFileMakePath(BHYVE_AUTOSTART_DIR) < 0) {
                virReportSystemError(errno,
                                     _("cannot create autostart directory %s"),
                                     BHYVE_AUTOSTART_DIR);
                goto cleanup;
            }

            if (symlink(configFile, autostartLink) < 0) {
                virReportSystemError(errno,
                                     _("Failed to create symlink '%s' to '%s'"),
                                     autostartLink, configFile);
                goto cleanup;
            }
        } else {
            if (unlink(autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) {
                virReportSystemError(errno,
                                     _("Failed to delete symlink '%s'"),
                                     autostartLink);
                goto cleanup;
            }
        }

        vm->autostart = autostart;
    }

    ret = 0;

 cleanup:
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
424 425
    if (vm)
        virObjectUnlock(vm);
426 427 428
    return ret;
}

429 430 431 432 433 434 435 436 437 438 439 440 441 442
static int
bhyveDomainIsActive(virDomainPtr domain)
{
    virDomainObjPtr obj;
    int ret = -1;

    if (!(obj = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainIsActiveEnsureACL(domain->conn, obj->def) < 0)
        goto cleanup;

    ret = virDomainObjIsActive(obj);

443
 cleanup:
444 445
    if (obj)
        virObjectUnlock(obj);
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
    return ret;
}

static int
bhyveDomainIsPersistent(virDomainPtr domain)
{
    virDomainObjPtr obj;
    int ret = -1;

    if (!(obj = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainIsPersistentEnsureACL(domain->conn, obj->def) < 0)
        goto cleanup;

    ret = obj->persistent;

463
 cleanup:
464 465
    if (obj)
        virObjectUnlock(obj);
466 467 468
    return ret;
}

469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489
static char *
bhyveDomainGetOSType(virDomainPtr dom)
{
    virDomainObjPtr vm;
    char *ret = NULL;

    if (!(vm = bhyveDomObjFromDomain(dom)))
        goto cleanup;

    if (virDomainGetOSTypeEnsureACL(dom->conn, vm->def) < 0)
        goto cleanup;

    if (VIR_STRDUP(ret, virDomainOSTypeToString(vm->def->os.type)) < 0)
        goto cleanup;

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

R
Roman Bogorodskiy 已提交
490 491 492
static char *
bhyveDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
R
Roman Bogorodskiy 已提交
493
    bhyveConnPtr privconn = domain->conn->privateData;
R
Roman Bogorodskiy 已提交
494
    virDomainObjPtr vm;
495
    virCapsPtr caps = NULL;
R
Roman Bogorodskiy 已提交
496 497 498 499 500 501 502 503
    char *ret = NULL;

    if (!(vm = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainGetXMLDescEnsureACL(domain->conn, vm->def, flags) < 0)
        goto cleanup;

504 505 506 507 508
    caps = bhyveDriverGetCapabilities(privconn);
    if (!caps)
        goto cleanup;

    ret = virDomainDefFormat(vm->def, caps,
509
                             virDomainDefFormatConvertXMLFlags(flags));
R
Roman Bogorodskiy 已提交
510

511
    virObjectUnref(caps);
512
 cleanup:
513 514
    if (vm)
        virObjectUnlock(vm);
R
Roman Bogorodskiy 已提交
515 516 517 518
    return ret;
}

static virDomainPtr
519
bhyveDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
R
Roman Bogorodskiy 已提交
520 521 522 523 524 525
{
    bhyveConnPtr privconn = conn->privateData;
    virDomainPtr dom = NULL;
    virDomainDefPtr def = NULL;
    virDomainDefPtr oldDef = NULL;
    virDomainObjPtr vm = NULL;
R
Roman Bogorodskiy 已提交
526
    virObjectEventPtr event = NULL;
527
    virCapsPtr caps = NULL;
528
    unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
529

530 531 532
    virCheckFlags(VIR_DOMAIN_DEFINE_VALIDATE, NULL);

    if (flags & VIR_DOMAIN_DEFINE_VALIDATE)
533
        parse_flags |= VIR_DOMAIN_DEF_PARSE_VALIDATE_SCHEMA;
534

535 536 537
    caps = bhyveDriverGetCapabilities(privconn);
    if (!caps)
        return NULL;
R
Roman Bogorodskiy 已提交
538

539
    if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt,
540
                                       parse_flags)) == NULL)
R
Roman Bogorodskiy 已提交
541 542
        goto cleanup;

543
    if (virDomainDefineXMLFlagsEnsureACL(conn, def) < 0)
R
Roman Bogorodskiy 已提交
544 545
        goto cleanup;

546 547 548
    if (bhyveDomainAssignAddresses(def, NULL) < 0)
        goto cleanup;

R
Roman Bogorodskiy 已提交
549 550 551 552 553
    if (!(vm = virDomainObjListAdd(privconn->domains, def,
                                   privconn->xmlopt,
                                   0, &oldDef)))
        goto cleanup;
    def = NULL;
554
    vm->persistent = 1;
R
Roman Bogorodskiy 已提交
555

556
    if (virDomainSaveConfig(BHYVE_CONFIG_DIR, caps,
557 558 559 560 561 562
                            vm->newDef ? vm->newDef : vm->def) < 0) {
        virDomainObjListRemove(privconn->domains, vm);
        vm = NULL;
        goto cleanup;
    }

R
Roman Bogorodskiy 已提交
563 564 565 566 567 568
    event = virDomainEventLifecycleNewFromObj(vm,
                                              VIR_DOMAIN_EVENT_DEFINED,
                                              !oldDef ?
                                              VIR_DOMAIN_EVENT_DEFINED_ADDED :
                                              VIR_DOMAIN_EVENT_DEFINED_UPDATED);

R
Roman Bogorodskiy 已提交
569 570 571 572
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom)
        dom->id = vm->def->id;

573
 cleanup:
574
    virObjectUnref(caps);
R
Roman Bogorodskiy 已提交
575
    virDomainDefFree(def);
576 577 578
    virDomainDefFree(oldDef);
    if (vm)
        virObjectUnlock(vm);
R
Roman Bogorodskiy 已提交
579 580
    if (event)
        virObjectEventStateQueue(privconn->domainEventState, event);
R
Roman Bogorodskiy 已提交
581 582 583 584

    return dom;
}

585 586 587 588 589 590
static virDomainPtr
bhyveDomainDefineXML(virConnectPtr conn, const char *xml)
{
    return bhyveDomainDefineXMLFlags(conn, xml, 0);
}

591 592 593 594
static int
bhyveDomainUndefine(virDomainPtr domain)
{
    bhyveConnPtr privconn = domain->conn->privateData;
R
Roman Bogorodskiy 已提交
595
    virObjectEventPtr event = NULL;
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
    virDomainObjPtr vm;
    int ret = -1;

    if (!(vm = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainUndefineEnsureACL(domain->conn, vm->def) < 0)
        goto cleanup;

    if (!vm->persistent) {
        virReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("Cannot undefine transient domain"));
        goto cleanup;
    }

    if (virDomainDeleteConfig(BHYVE_CONFIG_DIR,
                              BHYVE_AUTOSTART_DIR,
                              vm) < 0)
        goto cleanup;

R
Roman Bogorodskiy 已提交
616 617 618 619
    event = virDomainEventLifecycleNewFromObj(vm,
                                              VIR_DOMAIN_EVENT_UNDEFINED,
                                              VIR_DOMAIN_EVENT_UNDEFINED_REMOVED);

620 621 622 623 624 625 626 627 628
    if (virDomainObjIsActive(vm)) {
        vm->persistent = 0;
    } else {
        virDomainObjListRemove(privconn->domains, vm);
        vm = NULL;
    }

    ret = 0;

629
 cleanup:
R
Roman Bogorodskiy 已提交
630 631 632 633
    if (vm)
        virObjectUnlock(vm);
    if (event)
        virObjectEventStateQueue(privconn->domainEventState, event);
634 635 636
    return ret;
}

R
Roman Bogorodskiy 已提交
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
static int
bhyveConnectListDomains(virConnectPtr conn, int *ids, int maxids)
{
    bhyveConnPtr privconn = conn->privateData;
    int n;

    if (virConnectListDomainsEnsureACL(conn) < 0)
        return -1;

    n = virDomainObjListGetActiveIDs(privconn->domains, ids, maxids,
                                     virConnectListDomainsCheckACL, conn);

    return n;
}

static int
bhyveConnectNumOfDomains(virConnectPtr conn)
{
    bhyveConnPtr privconn = conn->privateData;
    int count;

    if (virConnectNumOfDomainsEnsureACL(conn) < 0)
        return -1;

    count = virDomainObjListNumOfDomains(privconn->domains, true,
                                         virConnectNumOfDomainsCheckACL, conn);

    return count;
}

static int
bhyveConnectListDefinedDomains(virConnectPtr conn, char **const names,
                               int maxnames)
{
    bhyveConnPtr privconn = conn->privateData;
    int n;

    if (virConnectListDefinedDomainsEnsureACL(conn) < 0)
        return -1;

    memset(names, 0, sizeof(*names) * maxnames);
    n = virDomainObjListGetInactiveNames(privconn->domains, names,
                                         maxnames, virConnectListDefinedDomainsCheckACL, conn);

    return n;
}

static int
bhyveConnectNumOfDefinedDomains(virConnectPtr conn)
{
    bhyveConnPtr privconn = conn->privateData;
    int count;

    if (virConnectNumOfDefinedDomainsEnsureACL(conn) < 0)
        return -1;

    count = virDomainObjListNumOfDomains(privconn->domains, false,
                                         virConnectNumOfDefinedDomainsCheckACL, conn);

    return count;
}

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
static char *
bhyveConnectDomainXMLToNative(virConnectPtr conn,
                              const char *format,
                              const char *xmlData,
                              unsigned int flags)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    bhyveConnPtr privconn = conn->privateData;
    virDomainDefPtr def = NULL;
    virCommandPtr cmd = NULL, loadcmd = NULL;
    virCapsPtr caps = NULL;
    char *ret = NULL;

    virCheckFlags(0, NULL);

    if (virConnectDomainXMLToNativeEnsureACL(conn) < 0)
        goto cleanup;

    if (STRNEQ(format, BHYVE_CONFIG_FORMAT_ARGV)) {
        virReportError(VIR_ERR_INVALID_ARG,
                       _("Unsupported config type %s"), format);
        goto cleanup;
    }

    if (!(caps = bhyveDriverGetCapabilities(privconn)))
        goto cleanup;

    if (!(def = virDomainDefParseString(xmlData, caps, privconn->xmlopt,
727
                                  VIR_DOMAIN_DEF_PARSE_INACTIVE)))
728 729
        goto cleanup;

730 731 732
    if (bhyveDomainAssignAddresses(def, NULL) < 0)
        goto cleanup;

733 734
    if (!(loadcmd = virBhyveProcessBuildLoadCmd(conn, def, "<device.map>",
                                                NULL)))
735 736
        goto cleanup;

R
Roman Bogorodskiy 已提交
737
    if (!(cmd = virBhyveProcessBuildBhyveCmd(conn, def, true)))
738 739 740 741 742 743
        goto cleanup;

    virBufferAdd(&buf, virCommandToString(loadcmd), -1);
    virBufferAddChar(&buf, '\n');
    virBufferAdd(&buf, virCommandToString(cmd), -1);

744
    if (virBufferCheckError(&buf) < 0)
745 746 747 748 749 750 751 752 753 754 755 756
        goto cleanup;

    ret = virBufferContentAndReset(&buf);

 cleanup:
    virCommandFree(loadcmd);
    virCommandFree(cmd);
    virDomainDefFree(def);
    virObjectUnref(caps);
    return ret;
}

R
Roman Bogorodskiy 已提交
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800
static int
bhyveConnectListAllDomains(virConnectPtr conn,
                           virDomainPtr **domains,
                           unsigned int flags)
{
    bhyveConnPtr privconn = conn->privateData;
    int ret = -1;

    virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);

    if (virConnectListAllDomainsEnsureACL(conn) < 0)
        return -1;

    ret = virDomainObjListExport(privconn->domains, conn, domains,
                                 virConnectListAllDomainsCheckACL, flags);

    return ret;
}

static virDomainPtr
bhyveDomainLookupByUUID(virConnectPtr conn,
                        const unsigned char *uuid)
{
    bhyveConnPtr privconn = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;

    vm = virDomainObjListFindByUUID(privconn->domains, uuid);

    if (!vm) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        virUUIDFormat(uuid, uuidstr);
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("No domain with matching uuid '%s'"), uuidstr);
        goto cleanup;
    }

    if (virDomainLookupByUUIDEnsureACL(conn, vm->def) < 0)
        goto cleanup;

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

801
 cleanup:
802 803
    if (vm)
        virObjectUnlock(vm);
R
Roman Bogorodskiy 已提交
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
    return dom;
}

static virDomainPtr bhyveDomainLookupByName(virConnectPtr conn,
                                            const char *name)
{
    bhyveConnPtr privconn = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;

    vm = virDomainObjListFindByName(privconn->domains, name);

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

    if (virDomainLookupByNameEnsureACL(conn, vm->def) < 0)
        goto cleanup;

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

829
 cleanup:
830
    virDomainObjEndAPI(&vm);
R
Roman Bogorodskiy 已提交
831 832 833
    return dom;
}

W
Wojciech Macek 已提交
834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
static virDomainPtr
bhyveDomainLookupByID(virConnectPtr conn,
                      int id)
{
    bhyveConnPtr privconn = conn->privateData;
    virDomainObjPtr vm;
    virDomainPtr dom = NULL;

    vm = virDomainObjListFindByID(privconn->domains, id);

    if (!vm) {
        virReportError(VIR_ERR_NO_DOMAIN,
                       _("No domain with matching ID '%d'"), id);
        goto cleanup;
    }

    if (virDomainLookupByIDEnsureACL(conn, vm->def) < 0)
        goto cleanup;

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

 cleanup:
858 859
    if (vm)
        virObjectUnlock(vm);
W
Wojciech Macek 已提交
860 861 862
    return dom;
}

R
Roman Bogorodskiy 已提交
863
static int
864 865
bhyveDomainCreateWithFlags(virDomainPtr dom,
                           unsigned int flags)
R
Roman Bogorodskiy 已提交
866 867 868
{
    bhyveConnPtr privconn = dom->conn->privateData;
    virDomainObjPtr vm;
R
Roman Bogorodskiy 已提交
869
    virObjectEventPtr event = NULL;
870
    unsigned int start_flags = 0;
R
Roman Bogorodskiy 已提交
871 872
    int ret = -1;

873 874 875 876 877
    virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, -1);

    if (flags & VIR_DOMAIN_START_AUTODESTROY)
        start_flags |= VIR_BHYVE_PROCESS_START_AUTODESTROY;

R
Roman Bogorodskiy 已提交
878 879 880
    if (!(vm = bhyveDomObjFromDomain(dom)))
        goto cleanup;

881
    if (virDomainCreateWithFlagsEnsureACL(dom->conn, vm->def) < 0)
R
Roman Bogorodskiy 已提交
882 883 884 885 886 887 888 889 890
        goto cleanup;

    if (virDomainObjIsActive(vm)) {
        virReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("Domain is already running"));
        goto cleanup;
    }

    ret = virBhyveProcessStart(dom->conn, privconn, vm,
891 892
                               VIR_DOMAIN_RUNNING_BOOTED,
                               start_flags);
R
Roman Bogorodskiy 已提交
893

R
Roman Bogorodskiy 已提交
894 895 896 897 898
    if (ret == 0)
        event = virDomainEventLifecycleNewFromObj(vm,
                                                  VIR_DOMAIN_EVENT_STARTED,
                                                  VIR_DOMAIN_EVENT_STARTED_BOOTED);

899
 cleanup:
900 901
    if (vm)
        virObjectUnlock(vm);
R
Roman Bogorodskiy 已提交
902 903
    if (event)
        virObjectEventStateQueue(privconn->domainEventState, event);
R
Roman Bogorodskiy 已提交
904 905 906
    return ret;
}

907 908 909 910 911 912
static int
bhyveDomainCreate(virDomainPtr dom)
{
    return bhyveDomainCreateWithFlags(dom, 0);
}

W
Wojciech Macek 已提交
913 914 915 916 917 918 919 920 921
static virDomainPtr
bhyveDomainCreateXML(virConnectPtr conn,
                     const char *xml,
                     unsigned int flags)
{
    bhyveConnPtr privconn = conn->privateData;
    virDomainPtr dom = NULL;
    virDomainDefPtr def = NULL;
    virDomainObjPtr vm = NULL;
R
Roman Bogorodskiy 已提交
922
    virObjectEventPtr event = NULL;
W
Wojciech Macek 已提交
923 924
    virCapsPtr caps = NULL;
    unsigned int start_flags = 0;
925
    unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
W
Wojciech Macek 已提交
926

927 928
    virCheckFlags(VIR_DOMAIN_START_AUTODESTROY |
                  VIR_DOMAIN_START_VALIDATE, NULL);
W
Wojciech Macek 已提交
929

930
    if (flags & VIR_DOMAIN_START_VALIDATE)
931
        parse_flags |= VIR_DOMAIN_DEF_PARSE_VALIDATE_SCHEMA;
W
Wojciech Macek 已提交
932 933 934 935 936 937 938 939
    if (flags & VIR_DOMAIN_START_AUTODESTROY)
        start_flags |= VIR_BHYVE_PROCESS_START_AUTODESTROY;

    caps = bhyveDriverGetCapabilities(privconn);
    if (!caps)
        return NULL;

    if ((def = virDomainDefParseString(xml, caps, privconn->xmlopt,
940
                                       parse_flags)) == NULL)
W
Wojciech Macek 已提交
941 942 943 944 945
        goto cleanup;

    if (virDomainCreateXMLEnsureACL(conn, def) < 0)
        goto cleanup;

946 947 948
    if (bhyveDomainAssignAddresses(def, NULL) < 0)
        goto cleanup;

W
Wojciech Macek 已提交
949 950
    if (!(vm = virDomainObjListAdd(privconn->domains, def,
                                   privconn->xmlopt,
951
                                   VIR_DOMAIN_OBJ_LIST_ADD_LIVE |
W
Wojciech Macek 已提交
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
                                   VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE, NULL)))
        goto cleanup;
    def = NULL;

    if (virBhyveProcessStart(conn, privconn, vm,
                             VIR_DOMAIN_RUNNING_BOOTED,
                             start_flags) < 0) {
        /* If domain is not persistent, remove its data */
        if (!vm->persistent) {
            virDomainObjListRemove(privconn->domains, vm);
            vm = NULL;
        }
        goto cleanup;
    }

R
Roman Bogorodskiy 已提交
967 968 969 970
    event = virDomainEventLifecycleNewFromObj(vm,
                                              VIR_DOMAIN_EVENT_STARTED,
                                              VIR_DOMAIN_EVENT_STARTED_BOOTED);

W
Wojciech Macek 已提交
971 972 973 974 975 976 977 978 979
    dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
    if (dom)
        dom->id = vm->def->id;

 cleanup:
    virObjectUnref(caps);
    virDomainDefFree(def);
    if (vm)
        virObjectUnlock(vm);
R
Roman Bogorodskiy 已提交
980 981
    if (event)
        virObjectEventStateQueue(privconn->domainEventState, event);
W
Wojciech Macek 已提交
982 983 984 985

    return dom;
}

R
Roman Bogorodskiy 已提交
986 987 988 989 990
static int
bhyveDomainDestroy(virDomainPtr dom)
{
    bhyveConnPtr privconn = dom->conn->privateData;
    virDomainObjPtr vm;
R
Roman Bogorodskiy 已提交
991
    virObjectEventPtr event = NULL;
R
Roman Bogorodskiy 已提交
992 993 994 995 996 997 998 999
    int ret = -1;

    if (!(vm = bhyveDomObjFromDomain(dom)))
        goto cleanup;

    if (virDomainDestroyEnsureACL(dom->conn, vm->def) < 0)
        goto cleanup;

1000 1001 1002 1003 1004 1005
    if (!virDomainObjIsActive(vm)) {
        virReportError(VIR_ERR_OPERATION_INVALID,
                       "%s", _("Domain is not running"));
        goto cleanup;
    }

R
Roman Bogorodskiy 已提交
1006
    ret = virBhyveProcessStop(privconn, vm, VIR_DOMAIN_SHUTOFF_DESTROYED);
R
Roman Bogorodskiy 已提交
1007 1008 1009
    event = virDomainEventLifecycleNewFromObj(vm,
                                              VIR_DOMAIN_EVENT_STOPPED,
                                              VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
R
Roman Bogorodskiy 已提交
1010

W
Wojciech Macek 已提交
1011 1012 1013 1014 1015
    if (!vm->persistent) {
        virDomainObjListRemove(privconn->domains, vm);
        vm = NULL;
    }

1016
 cleanup:
W
Wojciech Macek 已提交
1017 1018
    if (vm)
        virObjectUnlock(vm);
R
Roman Bogorodskiy 已提交
1019 1020
    if (event)
        virObjectEventStateQueue(privconn->domainEventState, event);
R
Roman Bogorodskiy 已提交
1021 1022 1023
    return ret;
}

1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
static int
bhyveDomainShutdown(virDomainPtr dom)
{
    virDomainObjPtr vm;
    int ret = -1;

    if (!(vm = bhyveDomObjFromDomain(dom)))
        goto cleanup;

    if (virDomainShutdownEnsureACL(dom->conn, vm->def) < 0)
        goto cleanup;

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

    ret = virBhyveProcessShutdown(vm);

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

1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
static int
bhyveDomainOpenConsole(virDomainPtr dom,
                       const char *dev_name ATTRIBUTE_UNUSED,
                       virStreamPtr st,
                       unsigned int flags)
{
    virDomainObjPtr vm = NULL;
    virDomainChrDefPtr chr = NULL;
    int ret = -1;

    virCheckFlags(0, -1);

    if (!(vm = bhyveDomObjFromDomain(dom)))
        goto cleanup;

    if (virDomainOpenConsoleEnsureACL(dom->conn, vm->def) < 0)
        goto cleanup;

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

    if (!vm->def->nserials) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("no console devices available"));
        goto cleanup;
    }

    chr = vm->def->serials[0];

    if (virFDStreamOpenPTY(st, chr->source.data.nmdm.slave,
                           0, 0, O_RDWR) < 0)
        goto cleanup;

    ret = 0;

 cleanup:
1089 1090
    if (vm)
        virObjectUnlock(vm);
1091 1092 1093
    return ret;
}

1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
static int
bhyveDomainSetMetadata(virDomainPtr dom,
                       int type,
                       const char *metadata,
                       const char *key,
                       const char *uri,
                       unsigned int flags)
{
    bhyveConnPtr privconn = dom->conn->privateData;
    virDomainObjPtr vm;
    virCapsPtr caps = NULL;
    int ret = -1;

    virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
                  VIR_DOMAIN_AFFECT_CONFIG, -1);

    if (!(vm = bhyveDomObjFromDomain(dom)))
        return -1;

    if (virDomainSetMetadataEnsureACL(dom->conn, vm->def, flags) < 0)
        goto cleanup;

    if (!(caps = bhyveDriverGetCapabilities(privconn)))
        goto cleanup;

    ret = virDomainObjSetMetadata(vm, type, metadata, key, uri, caps,
1120 1121
                                  privconn->xmlopt, BHYVE_STATE_DIR,
                                  BHYVE_CONFIG_DIR, flags);
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143

 cleanup:
    virObjectUnref(caps);
    virObjectUnlock(vm);
    return ret;
}

static char *
bhyveDomainGetMetadata(virDomainPtr dom,
                      int type,
                      const char *uri,
                      unsigned int flags)
{
    virDomainObjPtr vm;
    char *ret = NULL;

    if (!(vm = bhyveDomObjFromDomain(dom)))
        return NULL;

    if (virDomainGetMetadataEnsureACL(dom->conn, vm->def) < 0)
        goto cleanup;

1144
    ret = virDomainObjGetMetadata(vm, type, uri, flags);
1145 1146 1147 1148 1149 1150

 cleanup:
    virObjectUnlock(vm);
    return ret;
}

1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
static int
bhyveNodeGetCPUStats(virConnectPtr conn,
                     int cpuNum,
                     virNodeCPUStatsPtr params,
                     int *nparams,
                     unsigned int flags)
{
    if (virNodeGetCPUStatsEnsureACL(conn) < 0)
        return -1;

1161
    return virHostCPUGetStats(cpuNum, params, nparams, flags);
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
}

static int
bhyveNodeGetMemoryStats(virConnectPtr conn,
                        int cellNum,
                        virNodeMemoryStatsPtr params,
                        int *nparams,
                        unsigned int flags)
{
    if (virNodeGetMemoryStatsEnsureACL(conn) < 0)
        return -1;

1174
    return virHostMemGetStats(cellNum, params, nparams, flags);
1175 1176
}

1177 1178 1179 1180 1181 1182 1183
static int
bhyveNodeGetInfo(virConnectPtr conn,
                      virNodeInfoPtr nodeinfo)
{
    if (virNodeGetInfoEnsureACL(conn) < 0)
        return -1;

1184
    return nodeGetInfo(nodeinfo);
1185 1186
}

R
Roman Bogorodskiy 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
static int
bhyveStateCleanup(void)
{
    VIR_DEBUG("bhyve state cleanup");

    if (bhyve_driver == NULL)
        return -1;

    virObjectUnref(bhyve_driver->domains);
    virObjectUnref(bhyve_driver->caps);
    virObjectUnref(bhyve_driver->xmlopt);
1198
    virSysinfoDefFree(bhyve_driver->hostsysinfo);
1199
    virObjectUnref(bhyve_driver->closeCallbacks);
R
Roman Bogorodskiy 已提交
1200
    virObjectEventStateFree(bhyve_driver->domainEventState);
R
Roman Bogorodskiy 已提交
1201 1202 1203 1204 1205 1206 1207 1208

    virMutexDestroy(&bhyve_driver->lock);
    VIR_FREE(bhyve_driver);

    return 0;
}

static int
M
Martin Kletzander 已提交
1209
bhyveStateInitialize(bool privileged,
R
Roman Bogorodskiy 已提交
1210 1211 1212
                     virStateInhibitCallback callback ATTRIBUTE_UNUSED,
                     void *opaque ATTRIBUTE_UNUSED)
{
M
Martin Kletzander 已提交
1213 1214
    if (!privileged) {
        VIR_INFO("Not running privileged, disabling driver");
R
Roman Bogorodskiy 已提交
1215 1216 1217
        return 0;
    }

1218
    if (VIR_ALLOC(bhyve_driver) < 0)
R
Roman Bogorodskiy 已提交
1219 1220 1221 1222 1223 1224 1225
        return -1;

    if (virMutexInit(&bhyve_driver->lock) < 0) {
        VIR_FREE(bhyve_driver);
        return -1;
    }

1226 1227 1228
    if (!(bhyve_driver->closeCallbacks = virCloseCallbacksNew()))
        goto cleanup;

1229
    if (!(bhyve_driver->caps = virBhyveCapsBuild()))
R
Roman Bogorodskiy 已提交
1230 1231
        goto cleanup;

R
Roman Bogorodskiy 已提交
1232 1233 1234
    if (virBhyveProbeCaps(&bhyve_driver->bhyvecaps) < 0)
        goto cleanup;

1235 1236 1237
    if (virBhyveProbeGrubCaps(&bhyve_driver->grubcaps) < 0)
        goto cleanup;

1238 1239 1240
    if (!(bhyve_driver->xmlopt = virDomainXMLOptionNew(&virBhyveDriverDomainDefParserConfig,
                                                       &virBhyveDriverPrivateDataCallbacks,
                                                       NULL)))
R
Roman Bogorodskiy 已提交
1241 1242 1243 1244 1245
        goto cleanup;

    if (!(bhyve_driver->domains = virDomainObjListNew()))
        goto cleanup;

R
Roman Bogorodskiy 已提交
1246 1247 1248
    if (!(bhyve_driver->domainEventState = virObjectEventStateNew()))
        goto cleanup;

1249 1250
    bhyve_driver->hostsysinfo = virSysinfoRead();

R
Roman Bogorodskiy 已提交
1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
    if (virFileMakePath(BHYVE_LOG_DIR) < 0) {
        virReportSystemError(errno,
                             _("Failed to mkdir %s"),
                             BHYVE_LOG_DIR);
        goto cleanup;
    }

    if (virFileMakePath(BHYVE_STATE_DIR) < 0) {
        virReportSystemError(errno,
                             _("Failed to mkdir %s"),
1261
                             BHYVE_STATE_DIR);
R
Roman Bogorodskiy 已提交
1262 1263 1264
        goto cleanup;
    }

1265 1266 1267 1268 1269 1270 1271 1272
    if (virDomainObjListLoadAllConfigs(bhyve_driver->domains,
                                       BHYVE_STATE_DIR,
                                       NULL, 1,
                                       bhyve_driver->caps,
                                       bhyve_driver->xmlopt,
                                       NULL, NULL) < 0)
        goto cleanup;

R
Roman Bogorodskiy 已提交
1273 1274
    if (virDomainObjListLoadAllConfigs(bhyve_driver->domains,
                                       BHYVE_CONFIG_DIR,
1275
                                       BHYVE_AUTOSTART_DIR, 0,
R
Roman Bogorodskiy 已提交
1276 1277 1278 1279 1280
                                       bhyve_driver->caps,
                                       bhyve_driver->xmlopt,
                                       NULL, NULL) < 0)
        goto cleanup;

1281 1282
    virBhyveProcessReconnectAll(bhyve_driver);

R
Roman Bogorodskiy 已提交
1283 1284
    return 0;

1285
 cleanup:
R
Roman Bogorodskiy 已提交
1286 1287 1288 1289
    bhyveStateCleanup();
    return -1;
}

R
Roman Bogorodskiy 已提交
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
unsigned
bhyveDriverGetCaps(virConnectPtr conn)
{
    bhyveConnPtr driver = conn->privateData;

    if (driver != NULL)
        return driver->bhyvecaps;
    return 0;
}

1300 1301 1302 1303 1304 1305 1306 1307 1308 1309
unsigned
bhyveDriverGetGrubCaps(virConnectPtr conn)
{
    bhyveConnPtr driver = conn->privateData;

    if (driver != NULL)
        return driver->grubcaps;
    return 0;
}

1310 1311 1312 1313 1314 1315 1316 1317 1318
static void
bhyveStateAutoStart(void)
{
    if (!bhyve_driver)
        return;

    bhyveAutostartDomains(bhyve_driver);
}

W
Wojciech Macek 已提交
1319
static int
1320
bhyveConnectGetMaxVcpus(virConnectPtr conn,
1321 1322
                        const char *type)
{
W
Wojciech Macek 已提交
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
    if (virConnectGetMaxVcpusEnsureACL(conn) < 0)
        return -1;

    /*
     * Bhyve supports up to 16 VCPUs, but offers no method to check this
     * value. Hardcode 16...
     */
    if (!type || STRCASEEQ(type, "bhyve"))
        return 16;

    virReportError(VIR_ERR_INVALID_ARG, _("unknown type '%s'"), type);
    return -1;
}

static unsigned long long
bhyveNodeGetFreeMemory(virConnectPtr conn)
{
1340 1341
    unsigned long long freeMem;

W
Wojciech Macek 已提交
1342 1343 1344
    if (virNodeGetFreeMemoryEnsureACL(conn) < 0)
        return 0;

1345
    if (virHostMemGetInfo(NULL, &freeMem) < 0)
1346 1347 1348
        return 0;

    return freeMem;
W
Wojciech Macek 已提交
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
}

static int
bhyveNodeGetCPUMap(virConnectPtr conn,
                   unsigned char **cpumap,
                   unsigned int *online,
                   unsigned int flags)
{
    if (virNodeGetCPUMapEnsureACL(conn) < 0)
        return -1;

1360
    return virHostCPUGetMap(cpumap, online, flags);
W
Wojciech Macek 已提交
1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371
}

static int
bhyveNodeGetMemoryParameters(virConnectPtr conn,
                             virTypedParameterPtr params,
                             int *nparams,
                             unsigned int flags)
{
    if (virNodeGetMemoryParametersEnsureACL(conn) < 0)
        return -1;

1372
    return virHostMemGetParameters(params, nparams, flags);
W
Wojciech Macek 已提交
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
}

static int
bhyveNodeSetMemoryParameters(virConnectPtr conn,
                             virTypedParameterPtr params,
                             int nparams,
                             unsigned int flags)
{
    if (virNodeSetMemoryParametersEnsureACL(conn) < 0)
        return -1;

1384
    return virHostMemSetParameters(params, nparams, flags);
W
Wojciech Macek 已提交
1385
}
R
Roman Bogorodskiy 已提交
1386

1387
static char *
1388
bhyveConnectBaselineCPU(virConnectPtr conn,
1389 1390 1391 1392 1393 1394
                        const char **xmlCPUs,
                        unsigned int ncpus,
                        unsigned int flags)
{
    char *cpu = NULL;

1395 1396
    virCheckFlags(VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES |
                  VIR_CONNECT_BASELINE_CPU_MIGRATABLE, NULL);
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406

    if (virConnectBaselineCPUEnsureACL(conn) < 0)
        goto cleanup;

    cpu = cpuBaselineXML(xmlCPUs, ncpus, NULL, 0, flags);

 cleanup:
    return cpu;
}

1407 1408 1409 1410 1411 1412 1413 1414
static int
bhyveConnectCompareCPU(virConnectPtr conn,
                       const char *xmlDesc,
                       unsigned int flags)
{
    bhyveConnPtr driver = conn->privateData;
    int ret = VIR_CPU_COMPARE_ERROR;
    virCapsPtr caps = NULL;
1415
    bool failIncompatible;
1416

1417 1418
    virCheckFlags(VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE,
                  VIR_CPU_COMPARE_ERROR);
1419 1420 1421 1422

    if (virConnectCompareCPUEnsureACL(conn) < 0)
        goto cleanup;

1423
    failIncompatible = !!(flags & VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE);
1424

1425 1426 1427 1428 1429
    if (!(caps = bhyveDriverGetCapabilities(driver)))
        goto cleanup;

    if (!caps->host.cpu ||
        !caps->host.cpu->model) {
1430
        if (failIncompatible) {
1431 1432 1433 1434 1435 1436
            virReportError(VIR_ERR_CPU_INCOMPATIBLE, "%s",
                           _("cannot get host CPU capabilities"));
        } else {
            VIR_WARN("cannot get host CPU capabilities");
            ret = VIR_CPU_COMPARE_INCOMPATIBLE;
        }
1437
    } else {
1438
        ret = cpuCompareXML(caps->host.cpu, xmlDesc, failIncompatible);
1439 1440 1441 1442 1443 1444 1445
    }

 cleanup:
    virObjectUnref(caps);
    return ret;
}

R
Roman Bogorodskiy 已提交
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
static int
bhyveConnectDomainEventRegisterAny(virConnectPtr conn,
                                   virDomainPtr dom,
                                   int eventID,
                                   virConnectDomainEventGenericCallback callback,
                                   void *opaque,
                                   virFreeCallback freecb)
{
    bhyveConnPtr privconn = conn->privateData;
    int ret;

    if (virConnectDomainEventRegisterAnyEnsureACL(conn) < 0)
        return -1;

    if (virDomainEventStateRegisterID(conn,
                                      privconn->domainEventState,
                                      dom, eventID,
                                      callback, opaque, freecb, &ret) < 0)
        ret = -1;

    return ret;
}

static int
bhyveConnectDomainEventDeregisterAny(virConnectPtr conn,
                                     int callbackID)
{
    bhyveConnPtr privconn = conn->privateData;

    if (virConnectDomainEventDeregisterAnyEnsureACL(conn) < 0)
        return -1;

    if (virObjectEventStateDeregisterID(conn,
                                        privconn->domainEventState,
                                        callbackID) < 0)
        return -1;

    return 0;
}

1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
static int
bhyveDomainHasManagedSaveImage(virDomainPtr domain, unsigned int flags)
{
    virDomainObjPtr vm = NULL;
    int ret = -1;

    virCheckFlags(0, -1);

    if (!(vm = bhyveDomObjFromDomain(domain)))
        goto cleanup;

    if (virDomainHasManagedSaveImageEnsureACL(domain->conn, vm->def) < 0)
        goto cleanup;

    ret = 0;

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

1508 1509 1510 1511 1512 1513 1514 1515 1516
static const char *
bhyveConnectGetType(virConnectPtr conn)
{
    if (virConnectGetTypeEnsureACL(conn) < 0)
        return NULL;

    return "BHYVE";
}

1517 1518 1519 1520 1521
static int bhyveConnectIsAlive(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    return 1;
}

1522 1523 1524 1525 1526 1527 1528
static int
bhyveConnectIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    /* Trivially secure, since always inside the daemon */
    return 1;
}

1529 1530 1531 1532 1533 1534 1535
static int
bhyveConnectIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    /* Not encrypted, but remote driver takes care of that */
    return 0;
}

1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
static char *
bhyveConnectDomainXMLFromNative(virConnectPtr conn,
                                const char *nativeFormat,
                                const char *nativeConfig,
                                unsigned int flags)
{
    char *xml = NULL;
    virDomainDefPtr def = NULL;
    bhyveConnPtr privconn = conn->privateData;
    virCapsPtr capabilities = NULL;
    unsigned caps = bhyveDriverGetCaps(conn);

    virCheckFlags(0, NULL);

    if (virConnectDomainXMLFromNativeEnsureACL(conn) < 0)
        return NULL;

    capabilities = bhyveDriverGetCapabilities(privconn);
    if (!capabilities)
        return NULL;

    if (STRNEQ(nativeFormat, BHYVE_CONFIG_FORMAT_ARGV)) {
        virReportError(VIR_ERR_INVALID_ARG,
                       _("unsupported config type %s"), nativeFormat);
        goto cleanup;
    }

    def = bhyveParseCommandLineString(nativeConfig, caps, privconn->xmlopt);
    if (def == NULL)
        goto cleanup;

    xml = virDomainDefFormat(def, capabilities, 0);

 cleanup:
    virObjectUnref(capabilities);
    virDomainDefFree(def);
    return xml;
}

1575
static virHypervisorDriver bhyveHypervisorDriver = {
R
Roman Bogorodskiy 已提交
1576 1577 1578 1579 1580
    .name = "bhyve",
    .connectOpen = bhyveConnectOpen, /* 1.2.2 */
    .connectClose = bhyveConnectClose, /* 1.2.2 */
    .connectGetVersion = bhyveConnectGetVersion, /* 1.2.2 */
    .connectGetHostname = bhyveConnectGetHostname, /* 1.2.2 */
1581
    .connectGetSysinfo = bhyveConnectGetSysinfo, /* 1.2.5 */
R
Roman Bogorodskiy 已提交
1582 1583 1584 1585 1586 1587 1588 1589
    .domainGetInfo = bhyveDomainGetInfo, /* 1.2.2 */
    .domainGetState = bhyveDomainGetState, /* 1.2.2 */
    .connectGetCapabilities = bhyveConnectGetCapabilities, /* 1.2.2 */
    .connectListDomains = bhyveConnectListDomains, /* 1.2.2 */
    .connectNumOfDomains = bhyveConnectNumOfDomains, /* 1.2.2 */
    .connectListAllDomains = bhyveConnectListAllDomains, /* 1.2.2 */
    .connectListDefinedDomains = bhyveConnectListDefinedDomains, /* 1.2.2 */
    .connectNumOfDefinedDomains = bhyveConnectNumOfDefinedDomains, /* 1.2.2 */
1590
    .connectDomainXMLToNative = bhyveConnectDomainXMLToNative, /* 1.2.5 */
R
Roman Bogorodskiy 已提交
1591
    .domainCreate = bhyveDomainCreate, /* 1.2.2 */
1592
    .domainCreateWithFlags = bhyveDomainCreateWithFlags, /* 1.2.3 */
W
Wojciech Macek 已提交
1593
    .domainCreateXML = bhyveDomainCreateXML, /* 1.2.4 */
R
Roman Bogorodskiy 已提交
1594
    .domainDestroy = bhyveDomainDestroy, /* 1.2.2 */
1595
    .domainShutdown = bhyveDomainShutdown, /* 1.3.3 */
R
Roman Bogorodskiy 已提交
1596 1597
    .domainLookupByUUID = bhyveDomainLookupByUUID, /* 1.2.2 */
    .domainLookupByName = bhyveDomainLookupByName, /* 1.2.2 */
W
Wojciech Macek 已提交
1598
    .domainLookupByID = bhyveDomainLookupByID, /* 1.2.3 */
R
Roman Bogorodskiy 已提交
1599
    .domainDefineXML = bhyveDomainDefineXML, /* 1.2.2 */
1600
    .domainDefineXMLFlags = bhyveDomainDefineXMLFlags, /* 1.2.12 */
1601
    .domainUndefine = bhyveDomainUndefine, /* 1.2.2 */
1602
    .domainGetOSType = bhyveDomainGetOSType, /* 1.2.21 */
R
Roman Bogorodskiy 已提交
1603
    .domainGetXMLDesc = bhyveDomainGetXMLDesc, /* 1.2.2 */
1604 1605
    .domainIsActive = bhyveDomainIsActive, /* 1.2.2 */
    .domainIsPersistent = bhyveDomainIsPersistent, /* 1.2.2 */
1606 1607
    .domainGetAutostart = bhyveDomainGetAutostart, /* 1.2.4 */
    .domainSetAutostart = bhyveDomainSetAutostart, /* 1.2.4 */
1608
    .domainOpenConsole = bhyveDomainOpenConsole, /* 1.2.4 */
1609 1610
    .domainSetMetadata = bhyveDomainSetMetadata, /* 1.2.4 */
    .domainGetMetadata = bhyveDomainGetMetadata, /* 1.2.4 */
1611 1612
    .nodeGetCPUStats = bhyveNodeGetCPUStats, /* 1.2.2 */
    .nodeGetMemoryStats = bhyveNodeGetMemoryStats, /* 1.2.2 */
1613
    .nodeGetInfo = bhyveNodeGetInfo, /* 1.2.3 */
W
Wojciech Macek 已提交
1614 1615 1616 1617 1618
    .connectGetMaxVcpus = bhyveConnectGetMaxVcpus, /* 1.2.3 */
    .nodeGetFreeMemory = bhyveNodeGetFreeMemory, /* 1.2.3 */
    .nodeGetCPUMap = bhyveNodeGetCPUMap, /* 1.2.3 */
    .nodeGetMemoryParameters = bhyveNodeGetMemoryParameters, /* 1.2.3 */
    .nodeSetMemoryParameters = bhyveNodeSetMemoryParameters, /* 1.2.3 */
1619
    .connectBaselineCPU = bhyveConnectBaselineCPU, /* 1.2.4 */
1620
    .connectCompareCPU = bhyveConnectCompareCPU, /* 1.2.4 */
R
Roman Bogorodskiy 已提交
1621 1622
    .connectDomainEventRegisterAny = bhyveConnectDomainEventRegisterAny, /* 1.2.5 */
    .connectDomainEventDeregisterAny = bhyveConnectDomainEventDeregisterAny, /* 1.2.5 */
1623
    .domainHasManagedSaveImage = bhyveDomainHasManagedSaveImage, /* 1.2.13 */
1624
    .connectGetType = bhyveConnectGetType, /* 1.3.5 */
1625
    .connectIsAlive = bhyveConnectIsAlive, /* 1.3.5 */
1626
    .connectIsSecure = bhyveConnectIsSecure, /* 1.3.5 */
1627
    .connectIsEncrypted = bhyveConnectIsEncrypted, /* 1.3.5 */
1628
    .connectDomainXMLFromNative = bhyveConnectDomainXMLFromNative, /* 2.1.0 */
R
Roman Bogorodskiy 已提交
1629 1630 1631
};


1632 1633 1634 1635
static virConnectDriver bhyveConnectDriver = {
    .hypervisorDriver = &bhyveHypervisorDriver,
};

R
Roman Bogorodskiy 已提交
1636 1637 1638
static virStateDriver bhyveStateDriver = {
    .name = "bhyve",
    .stateInitialize = bhyveStateInitialize,
1639
    .stateAutoStart = bhyveStateAutoStart,
R
Roman Bogorodskiy 已提交
1640 1641 1642 1643 1644 1645
    .stateCleanup = bhyveStateCleanup,
};

int
bhyveRegister(void)
{
1646 1647
    if (virRegisterConnectDriver(&bhyveConnectDriver,
                                 true) < 0)
1648
        return -1;
1649
    if (virRegisterStateDriver(&bhyveStateDriver) < 0)
1650
        return -1;
1651
    return 0;
R
Roman Bogorodskiy 已提交
1652
}