xenapi_driver.c 66.0 KB
Newer Older
1 2
/*
 * xenapi_driver.c: Xen API driver.
3
 * Copyright (C) 2011-2015 Red Hat, Inc.
4 5 6 7 8 9 10 11 12 13 14 15 16
 * Copyright (C) 2009, 2010 Citrix Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library.  If not, see
O
Osier Yang 已提交
18
 * <http://www.gnu.org/licenses/>.
19 20 21 22 23 24 25 26 27 28 29 30
 *
 * Author: Sharadha Prabhakar <sharadha.prabhakar@citrix.com>
 */

#include <config.h>

#include <limits.h>
#include <string.h>
#include <curl/curl.h>
#include <xen/api/xen_all.h>
#include "internal.h"
#include "domain_conf.h"
31
#include "virerror.h"
32
#include "datatypes.h"
33
#include "virauth.h"
34
#include "viruuid.h"
35
#include "viralloc.h"
36
#include "virbuffer.h"
M
Martin Kletzander 已提交
37
#include "viruri.h"
38 39 40
#include "xenapi_driver.h"
#include "xenapi_driver_private.h"
#include "xenapi_utils.h"
41
#include "virstring.h"
P
Pavel Hrdina 已提交
42
#include "xen_common.h"
43

44 45
#define VIR_FROM_THIS VIR_FROM_XENAPI

46

47 48
static int
xenapiDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
49
                               const virDomainDef *def,
50
                               virCapsPtr caps ATTRIBUTE_UNUSED,
51
                               unsigned int parseFlags ATTRIBUTE_UNUSED,
52 53
                               void *opaque ATTRIBUTE_UNUSED,
                               void *parseOpaque ATTRIBUTE_UNUSED)
54
{
55 56 57
    if (dev->type == VIR_DOMAIN_DEVICE_CHR &&
        dev->data.chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
        dev->data.chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_NONE &&
58
        def->os.type != VIR_DOMAIN_OSTYPE_HVM)
59 60
        dev->data.chr->targetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_XEN;

61 62 63 64 65 66 67 68 69 70
    /* forbid capabilities mode hostdev in this kind of hypervisor */
    if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV &&
        dev->data.hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("hostdev mode 'capabilities' is not "
                         "supported in %s"),
                       virDomainVirtTypeToString(def->virtType));
        return -1;
    }

71
    return 0;
72 73 74
}


75
static int
76
xenapiDomainDefPostParse(virDomainDefPtr def,
77
                         virCapsPtr caps ATTRIBUTE_UNUSED,
78
                         unsigned int parseFlags ATTRIBUTE_UNUSED,
79 80
                         void *opaque ATTRIBUTE_UNUSED,
                         void *parseOpaque ATTRIBUTE_UNUSED)
81
{
P
Pavel Hrdina 已提交
82 83 84 85
    /* add implicit input device */
    if (xenDomainDefAddImplicitInputDevice(def) < 0)
        return -1;

86 87 88 89
    return 0;
}


90 91
virDomainDefParserConfig xenapiDomainDefParserConfig = {
    .devicesPostParseCallback = xenapiDomainDeviceDefPostParse,
92
    .domainPostParseCallback = xenapiDomainDefPostParse,
93
    .features = VIR_DOMAIN_DEF_FEATURE_NAME_SLASH,
94 95 96
};


97 98 99 100 101 102 103
/*
 * getCapsObject
 *
 * Build the capabilities of the hypervisor
 * Return virCapsPtr on success or NULL on failure
 */
static virCapsPtr
104
getCapsObject(void)
105
{
106 107
    virCapsGuestPtr guest1, guest2;
    virCapsGuestDomainPtr domain1, domain2;
108
    virCapsPtr caps = virCapabilitiesNew(virArchFromHost(), false, false);
109

110
    if (!caps)
111
        return NULL;
112
    guest1 = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM, VIR_ARCH_X86_64, "", "", 0, NULL);
113 114
    if (!guest1)
        goto error_cleanup;
115
    domain1 = virCapabilitiesAddGuestDomain(guest1, VIR_DOMAIN_VIRT_XEN, "", "", 0, NULL);
116 117
    if (!domain1)
        goto error_cleanup;
118
    guest2 = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_XEN, VIR_ARCH_X86_64, "", "", 0, NULL);
119 120
    if (!guest2)
        goto error_cleanup;
121
    domain2 = virCapabilitiesAddGuestDomain(guest2, VIR_DOMAIN_VIRT_XEN, "", "", 0, NULL);
122 123 124 125 126
    if (!domain2)
        goto error_cleanup;

    return caps;

127
 error_cleanup:
128
    virObjectUnref(caps);
129 130 131 132
    return NULL;
}

/*
133
 * xenapiConnectOpen
134 135 136 137 138
 *
 * Authenticates and creates a session with the server
 * Return VIR_DRV_OPEN_SUCCESS on success, else VIR_DRV_OPEN_ERROR
 */
static virDrvOpenStatus
139
xenapiConnectOpen(virConnectPtr conn, virConnectAuthPtr auth,
140
                  virConfPtr conf ATTRIBUTE_UNUSED,
141
                  unsigned int flags)
142
{
143 144 145
    char *username = NULL;
    char *password = NULL;
    struct _xenapiPrivate *privP = NULL;
146

E
Eric Blake 已提交
147 148
    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);

149 150
    if (conn->uri == NULL || conn->uri->scheme == NULL ||
        STRCASENEQ(conn->uri->scheme, "XenAPI")) {
151 152
        return VIR_DRV_OPEN_DECLINED;
    }
153

154
    if (conn->uri->server == NULL) {
155
        xenapiSessionErrorHandler(conn, VIR_ERR_INVALID_ARG,
156
                                  _("Server name not in URI"));
157 158 159 160 161
        goto error;
    }

    if (auth == NULL) {
        xenapiSessionErrorHandler(conn, VIR_ERR_AUTH_FAILED,
162
                                  _("Authentication Credentials not found"));
163
        goto error;
164
    }
165 166

    if (conn->uri->user != NULL) {
167
        if (VIR_STRDUP(username, conn->uri->user) < 0)
168
            goto error;
169
    } else {
170
        username = virAuthGetUsername(conn, auth, "xen", NULL, conn->uri->server);
171 172 173

        if (username == NULL) {
            xenapiSessionErrorHandler(conn, VIR_ERR_AUTH_FAILED,
174
                                      _("Username request failed"));
175 176
            goto error;
        }
177
    }
178

179
    password = virAuthGetPassword(conn, auth, "xen", username, conn->uri->server);
180 181 182

    if (password == NULL) {
        xenapiSessionErrorHandler(conn, VIR_ERR_AUTH_FAILED,
183
                                  _("Password request failed"));
184
        goto error;
185
    }
186

187
    if (VIR_ALLOC(privP) < 0)
188 189
        goto error;

190
    if (virAsprintf(&privP->url, "https://%s", conn->uri->server) < 0)
191 192 193 194 195 196 197
        goto error;

    if (xenapiUtil_ParseQuery(conn, conn->uri, &privP->noVerify) < 0)
        goto error;

    if (!(privP->caps = getCapsObject())) {
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
198
                                  _("Capabilities not found"));
199 200 201
        goto error;
    }

202 203
    if (!(privP->xmlopt = virDomainXMLOptionNew(&xenapiDomainDefParserConfig,
                                                NULL, NULL))) {
204 205 206 207 208
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Failed to create XML conf object"));
        goto error;
    }

209 210 211 212
    xmlInitParser();
    xmlKeepBlanksDefault(0);
    xen_init();

213 214
    privP->session = xen_session_login_with_password(call_func, privP, username,
                                                     password, xen_api_latest_version);
215

216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231
    if (privP->session == NULL) {
        /* From inspection of xen_session_login_with_password in
         * libxenserver(Version 5.6.100-1), this appears not to be currently
         * possible. The only way for this to be NULL would be on malloc
         * failure, except that the code doesn't check for this and would
         * segfault before returning.
         *
         * We don't assume the reason here for a failure in an external library.
         */
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Failed to allocate xen session"));

        goto error;
    }

    if (privP->session->ok) {
232
        conn->privateData = privP;
233 234 235 236

        VIR_FREE(username);
        VIR_FREE(password);

237
        return VIR_DRV_OPEN_SUCCESS;
238 239
    }

240
    xenapiSessionErrorHandler(conn, VIR_ERR_AUTH_FAILED, NULL);
241

242
 error:
243 244 245 246
    VIR_FREE(username);
    VIR_FREE(password);

    if (privP != NULL) {
247
        virObjectUnref(privP->caps);
248
        virObjectUnref(privP->xmlopt);
249

250 251 252
        if (privP->session != NULL)
            xenSessionFree(privP->session);

253
        VIR_FREE(privP->url);
254 255
        VIR_FREE(privP);
    }
256 257

    return VIR_DRV_OPEN_ERROR;
258 259 260
}

/*
261
 * xenapiConnectClose:
262 263 264 265 266
 *
 * Returns 0 on successful session logout
 *
 */
static int
267
xenapiConnectClose(virConnectPtr conn)
268
{
269 270
    struct _xenapiPrivate *priv = conn->privateData;

271
    virObjectUnref(priv->caps);
272
    virObjectUnref(priv->xmlopt);
273 274 275

    if (priv->session != NULL) {
        xen_session_logout(priv->session);
276
        priv->session = NULL;
277 278 279 280 281 282 283
    }

    VIR_FREE(priv->url);
    VIR_FREE(priv);

    conn->privateData = NULL;

284 285 286 287 288
    return 0;
}

/*
 *
289
 * xenapiConnectSupportsFeature
290 291 292 293
 *
 * Returns 0
 */
static int
294
xenapiConnectSupportsFeature(virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
295 296 297 298 299 300 301 302 303 304
{
    switch (feature) {
    case VIR_DRV_FEATURE_MIGRATION_V2:
    case VIR_DRV_FEATURE_MIGRATION_P2P:
    default:
        return 0;
    }
}

/*
305
 * xenapiConnectGetType:
306 307 308 309 310
 *
 *
 * Returns name of the driver
 */
static const char *
311
xenapiConnectGetType(virConnectPtr conn ATTRIBUTE_UNUSED)
312 313 314 315 316 317
{
    return "XenAPI";
}


/*
318
 * xenapiConnectGetVersion:
319 320 321 322 323
 *
 * Gets the version of XenAPI
 *
 */
static int
324
xenapiConnectGetVersion(virConnectPtr conn, unsigned long *hvVer)
325 326 327 328
{
    xen_host host;
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
    xen_string_string_map *result = NULL;
329 330
    size_t i;
    int ret = -1;
331 332 333 334 335 336 337 338 339 340 341 342 343 344
    char *version = NULL;
    if (!(xen_session_get_this_host(session, &host, session))) {
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
        return -1;
    }
    if (!(xen_host_get_software_version(session, &result, host))) {
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
        xen_host_free(host);
        return -1;
    }
    xen_host_free(host);
    if (result && result->size > 0) {
        for (i = 0; i < result->size; i++) {
            if (STREQ(result->contents[i].key, "xen")) {
345
                if (VIR_STRDUP(version, result->contents[i].val) < 0) {
346 347 348 349 350 351 352
                    xen_string_string_map_free(result);
                    return -1;
                }
                break;
            }
        }
        if (version) {
353
            if (virParseVersionString(version, hvVer, false) < 0)
354
                xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
355 356 357
                                          _("Couldn't parse version info"));
            else
                ret = 0;
358
            xen_string_string_map_free(result);
359 360
            VIR_FREE(version);
            return ret;
361
        }
362 363
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Couldn't get version info"));
364 365 366 367 368 369
    }
    return -1;
}


/*
370
 * xenapiConnectGetHostname:
371 372 373 374 375
 *
 *
 * Returns the hostname on success, or NULL on failure
 */
static char *
376
xenapiConnectGetHostname(virConnectPtr conn)
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
{
    char *result = NULL;
    xen_host host;
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
    if (!(xen_session_get_this_host(session, &host, session))) {
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
        return NULL;
    }
    if (!(xen_host_get_hostname(session, &result, host)))
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
    xen_host_free(host);
    return result;
}


/*
393
 * xenapiConnectGetMaxVcpus:
394 395 396 397 398
 *
 *
 * Returns a hardcoded value for Maximum VCPUS
 */
static int
399
xenapiConnectGetMaxVcpus(virConnectPtr conn ATTRIBUTE_UNUSED, const char *type ATTRIBUTE_UNUSED)
400 401 402 403 404 405 406 407 408 409 410 411 412 413
{
    /* this is hardcoded for simplicity and set to a resonable value compared
       to the actual value */
    return 16;
}


/*
 * xenapiNodeGetInfo:
 *
 *
 * Returns Node details on success or else -1
 */
static int
414
xenapiNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info)
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
{
    int64_t memory, mhz;
    xen_host_cpu_set *host_cpu_set;
    xen_host_cpu host_cpu;
    xen_host_metrics_set *xen_met_set;
    char *modelname;
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
    info->nodes = 1;
    info->threads = 1;
    info->sockets = 1;

    if (xen_host_metrics_get_all(session, &xen_met_set)) {
        xen_host_metrics_get_memory_total(session, &memory, xen_met_set->contents[0]);
        info->memory = (unsigned long)(memory / 1024);
        xen_host_metrics_set_free(xen_met_set);
    } else {
431 432
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Unable to get host metric Information"));
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
        return -1;
    }
    if (xen_host_cpu_get_all(session, &host_cpu_set)) {
        host_cpu = host_cpu_set->contents[0];
        xen_host_cpu_get_modelname(session, &modelname, host_cpu);
        if (!virStrncpy(info->model, modelname, LIBVIRT_MODELNAME_LEN - 1, LIBVIRT_MODELNAME_LEN)) {
            virReportOOMError();
            xen_host_cpu_set_free(host_cpu_set);
            VIR_FREE(modelname);
            return -1;
        }
        xen_host_cpu_get_speed(session, &mhz, host_cpu);
        info->mhz = (unsigned long)mhz;
        info->cpus = host_cpu_set->size;
        info->cores = host_cpu_set->size;

        xen_host_cpu_set_free(host_cpu_set);
        VIR_FREE(modelname);
        return 0;
    }
453 454
    xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                              _("Unable to get Host CPU set"));
455 456 457 458
    return -1;
}

/*
459
 * xenapiConnectGetCapabilities:
460 461 462 463 464
 *
 *
 * Returns capabilities as an XML string
 */
static char *
465
xenapiConnectGetCapabilities(virConnectPtr conn)
466
{
467

468
    virCapsPtr caps = ((struct _xenapiPrivate *)(conn->privateData))->caps;
469 470
    if (caps)
        return virCapabilitiesFormatXML(caps);
471

472 473
    xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                              _("Capabilities not available"));
474 475 476 477 478
    return NULL;
}


/*
479
 * xenapiConnectListDomains
480 481 482 483 484
 *
 * Collects the list of active domains, and store their ID in @maxids
 * Returns the number of domain found or -1 in case of error
 */
static int
485
xenapiConnectListDomains(virConnectPtr conn, int *ids, int maxids)
486 487 488 489 490
{
    /* vm.list */
    xen_host host;
    xen_vm_set *result = NULL;
    int64_t t0;
491
    size_t i;
492 493 494 495
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
    if (xen_session_get_this_host(session, &host, session)) {
        xen_host_get_resident_vms(session, &result, host);
        xen_host_free(host);
496
    } else {
497
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
498
    }
499 500 501 502
    if (result != NULL) {
        for (i = 0; (i < (result->size)) && (i < maxids); i++) {
            xen_vm_get_domid(session, &t0, result->contents[i]);
            if (t0 > (int64_t)INT_MAX || t0 < (int64_t)INT_MIN) {
503 504
                xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                          _("DomainID can't fit in 32 bits"));
505 506 507 508 509 510 511 512 513 514 515 516
                xen_vm_set_free(result);
                return -1;
            }
            ids[i] = (int)t0;
        }
        xen_vm_set_free(result);
        return i;
    }
    return -1;
}

/*
517
 * xenapiConnectNumOfDomains
518 519 520 521 522
 *
 *
 * Returns the number of domains found or -1 in case of error
 */
static int
523
xenapiConnectNumOfDomains(virConnectPtr conn)
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
{
    /* #(vm.list) */
    xen_vm_set *result = NULL;
    xen_host host = NULL;
    int numDomains = -1;
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;

    xen_session_get_this_host(session, &host, session);
    if (host != NULL) {
        xen_host_get_resident_vms(session, &result, host);
        if (result != NULL) {
            numDomains = result->size;
            xen_vm_set_free(result);
        }
        xen_host_free(host);
    }
    if (!session->ok)
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
    return numDomains;
}

/*
 * xenapiDomainCreateXML
 *
 * Launches a new domain based on the XML description
 * Returns the domain pointer or NULL in case of error
 */
static virDomainPtr
552 553 554
xenapiDomainCreateXML(virConnectPtr conn,
                      const char *xmlDesc,
                      unsigned int flags)
555
{
556
    struct _xenapiPrivate *priv = conn->privateData;
557 558 559
    xen_vm_record *record = NULL;
    xen_vm vm = NULL;
    virDomainPtr domP = NULL;
560 561
    unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;

562
    if (!priv->caps)
563 564
        return NULL;

565 566 567
    virCheckFlags(VIR_DOMAIN_START_VALIDATE, NULL);

    if (flags & VIR_DOMAIN_START_VALIDATE)
568
        parse_flags |= VIR_DOMAIN_DEF_PARSE_VALIDATE_SCHEMA;
569

570 571
    virDomainDefPtr defPtr = virDomainDefParseString(xmlDesc,
                                                     priv->caps, priv->xmlopt,
572
                                                     NULL,
573
                                                     parse_flags);
574 575
    if (!defPtr)
        return NULL;
576 577 578 579
    createVMRecordFromXml(conn, defPtr, &record, &vm);
    virDomainDefFree(defPtr);
    if (record) {
        unsigned char raw_uuid[VIR_UUID_BUFLEN];
580
        ignore_value(virUUIDParse(record->uuid, raw_uuid));
581
        if (vm) {
582
            if (xen_vm_start(priv->session, vm, false, false)) {
583 584 585
                domP = virGetDomain(conn, record->name_label, raw_uuid);
                if (!domP) {
                    xen_vm_record_free(record);
586 587
                    xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                              _("Domain Pointer is invalid"));
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
                    return domP;
                }
                domP->id = record->domid;
                xen_vm_free(vm);
            }
            else
                xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
        }
        xen_vm_record_free(record);
    }
    else
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
    return domP;
}

/*
 * xenapiDomainLookupByID
 *
 *
 * Returns a valid domain pointer of the domain with ID same as the one passed
 * or NULL in case of error
 */
static virDomainPtr
611
xenapiDomainLookupByID(virConnectPtr conn, int id)
612
{
613
    size_t i;
614 615 616 617 618 619
    int64_t domID;
    char *uuid;
    xen_host host;
    xen_vm_set *result;
    xen_vm_record *record;
    unsigned char raw_uuid[VIR_UUID_BUFLEN];
620
    virDomainPtr domP = NULL;
621 622 623 624 625
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;

    xen_session_get_this_host(session, &host, session);
    if (host != NULL && session->ok) {
        xen_host_get_resident_vms(session, &result, host);
626
        if (result != NULL) {
627 628 629 630 631
            for (i = 0; i < result->size; i++) {
                xen_vm_get_domid(session, &domID, result->contents[i]);
                if (domID == id) {
                    xen_vm_get_record(session, &record, result->contents[i]);
                    xen_vm_get_uuid(session, &uuid, result->contents[i]);
632
                    ignore_value(virUUIDParse(uuid, raw_uuid));
633 634 635 636 637 638
                    domP = virGetDomain(conn, record->name_label, raw_uuid);
                    if (domP) {
                        int64_t domid = -1;
                        xen_vm_get_domid(session, &domid, result->contents[i]);
                        domP->id = domid;
                    } else {
639 640
                        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                                  _("Domain Pointer not valid"));
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
                        domP = NULL;
                    }
                    xen_uuid_free(uuid);
                    xen_vm_record_free(record);
                    break;
                }
            }
            xen_vm_set_free(result);
        } else {
            xenapiSessionErrorHandler(conn, VIR_ERR_NO_DOMAIN, NULL);
        }
        xen_host_free(host);
    } else {
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
    }
    return domP;
}

/*
 * xenapiDomainLookupByUUID
 *
 * Returns the domain pointer of domain with matching UUID
 * or -1 in case of error
 */
static virDomainPtr
666 667
xenapiDomainLookupByUUID(virConnectPtr conn,
                         const unsigned char *uuid)
668 669 670 671 672 673 674
{
    /* vm.get_by_uuid */
    xen_vm vm;
    xen_vm_record *record;
    char uuidStr[VIR_UUID_STRING_BUFLEN];
    virDomainPtr domP = NULL;
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
E
Eric Blake 已提交
675
    virUUIDFormat(uuid, uuidStr);
676 677 678 679 680
    if (xen_vm_get_by_uuid(session, &vm, uuidStr)) {
        xen_vm_get_record(session, &record, vm);
        if (record != NULL) {
            domP = virGetDomain(conn, record->name_label, uuid);
            if (!domP) {
681 682
                xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                          _("Domain Pointer not valid"));
683 684 685 686 687
                domP = NULL;
            } else {
                domP->id = record->domid;
            }
            xen_vm_record_free(record);
688
        } else {
689
            xenapiSessionErrorHandler(conn, VIR_ERR_NO_DOMAIN, NULL);
690
        }
691
        xen_vm_free(vm);
692
    } else {
693
        xenapiSessionErrorHandler(conn, VIR_ERR_NO_DOMAIN, NULL);
694
    }
695 696 697 698 699 700 701 702 703 704
    return domP;
}

/*
 * xenapiDomainLookupByName
 *
 * Returns the domain pointer of domain with matching name
 * or -1 in case of error
 */
static virDomainPtr
705 706
xenapiDomainLookupByName(virConnectPtr conn,
                         const char *name)
707 708 709 710 711 712 713 714 715 716
{
    /* vm.get_by_name_label */
    xen_vm_set *vms = NULL;
    xen_vm vm;
    char *uuid = NULL;
    unsigned char raw_uuid[VIR_UUID_BUFLEN];
    virDomainPtr domP = NULL;
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
    if (xen_vm_get_by_name_label(session, &vms, (char *)name) && vms->size > 0) {
        if (vms->size != 1) {
717 718
            xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
719 720 721 722 723
            xen_vm_set_free(vms);
            return NULL;
        }
        vm = vms->contents[0];
        xen_vm_get_uuid(session, &uuid, vm);
724
        if (uuid != NULL) {
725
            ignore_value(virUUIDParse(uuid, raw_uuid));
726 727 728 729 730 731 732 733 734 735 736 737
            domP = virGetDomain(conn, name, raw_uuid);
            if (domP != NULL) {
                int64_t domid = -1;
                xen_vm_get_domid(session, &domid, vm);
                domP->id = domid;
                xen_uuid_free(uuid);
                xen_vm_set_free(vms);
                return domP;
            } else {
                xen_uuid_free(uuid);
                xen_vm_set_free(vms);
            if (!session->ok)
738 739
                xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                          _("Couldn't get the Domain Pointer"));
740 741 742 743
                return NULL;
            }
        }
    }
744 745
    if (vms)
        xen_vm_set_free(vms);
746
    xenapiSessionErrorHandler(conn, VIR_ERR_NO_DOMAIN, NULL);
747 748 749 750 751 752 753 754 755 756
    return NULL;
}

/*
 * xenapiDomainSuspend
 *
 * a VM is paused
 * Returns 0 on success or -1 in case of error
 */
static int
757
xenapiDomainSuspend(virDomainPtr dom)
758 759 760
{
    /* vm.pause() */
    xen_vm vm;
761
    xen_vm_set *vms = NULL;
762 763 764
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    if (xen_vm_get_by_name_label(session, &vms, dom->name) &&  vms->size > 0) {
        if (vms->size != 1) {
765 766
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
767 768 769 770 771 772 773 774 775 776 777 778 779
            xen_vm_set_free(vms);
            return -1;
        } else {
            vm = vms->contents[0];
            if (!xen_vm_pause(session, vm)) {
                xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
                xen_vm_set_free(vms);
                return -1;
            }
            xen_vm_set_free(vms);
            return 0;
        }
    }
780 781
    if (vms)
        xen_vm_set_free(vms);
782
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
783 784 785 786 787 788 789 790 791 792
    return -1;
}

/*
 * xenapiDomainResume
 *
 * Resumes a VM
 * Returns 0 on success or -1 in case of error
 */
static int
793
xenapiDomainResume(virDomainPtr dom)
794 795 796 797 798 799 800
{
    /* vm.unpause() */
    xen_vm vm;
    xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
801 802
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
803 804 805 806 807 808 809 810 811 812 813 814 815
            xen_vm_set_free(vms);
            return -1;
        } else {
            vm = vms->contents[0];
            if (!xen_vm_unpause(session, vm)) {
                xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
                xen_vm_set_free(vms);
                return -1;
            }
            xen_vm_set_free(vms);
            return 0;
        }
    }
816 817
    if (vms)
        xen_vm_set_free(vms);
818
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
819 820 821 822 823 824 825 826 827 828
    return -1;
}

/*
 * xenapiDomainShutdown
 *
 * shutsdown a VM
 * Returns 0 on success or -1 in case of error
 */
static int
829
xenapiDomainShutdownFlags(virDomainPtr dom, unsigned int flags)
830 831 832 833 834
{
    /* vm.clean_shutdown */
    xen_vm vm;
    xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
835 836 837

    virCheckFlags(0, -1);

838 839
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
840 841
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
842 843 844 845 846 847 848 849 850 851 852 853 854
            xen_vm_set_free(vms);
            return -1;
        } else {
            vm = vms->contents[0];
            if (!xen_vm_clean_shutdown(session, vm)) {
                xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
                xen_vm_set_free(vms);
                return -1;
            }
            xen_vm_set_free(vms);
            return 0;
        }
    }
855 856
    if (vms)
        xen_vm_set_free(vms);
857
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
858 859 860
    return -1;
}

861 862 863 864 865 866
static int
xenapiDomainShutdown(virDomainPtr dom)
{
    return xenapiDomainShutdownFlags(dom, 0);
}

867 868 869 870 871 872 873
/*
 * xenapiDomainReboot
 *
 * Reboots a VM
 * Returns 0 on success or -1 in case of error
 */
static int
874
xenapiDomainReboot(virDomainPtr dom, unsigned int flags)
875 876 877 878 879
{
    /* vm.clean_reboot */
    xen_vm vm;
    struct xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
E
Eric Blake 已提交
880 881 882

    virCheckFlags(0, -1);

883 884
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
885 886
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
887 888 889 890 891 892 893 894 895 896 897 898
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        if (!xen_vm_clean_reboot(session, vm)) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            xen_vm_set_free(vms);
            return -1;
        }
        xen_vm_set_free(vms);
        return 0;
    }
899 900
    if (vms)
        xen_vm_set_free(vms);
901
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
902 903 904 905
    return -1;
}

/*
906 907 908 909 910 911
 * xenapiDomainDestroyFlags:
 * @dom: domain object
 * @flags: an OR'ed set of virDomainDestroyFlagsValues
 *
 * Calling this function with no flags set (equal to zero)
 * is equivalent to calling xenapiDomainDestroy.
912 913 914 915 916
 *
 * A VM is hard shutdown
 * Returns 0 on success or -1 in case of error
 */
static int
917 918
xenapiDomainDestroyFlags(virDomainPtr dom,
                         unsigned int flags)
919 920 921 922 923
{
    /* vm.hard_shutdown */
    xen_vm vm;
    struct xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
924 925 926

    virCheckFlags(0, -1);

927 928
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
929 930
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
931 932 933 934 935 936 937 938 939 940
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        if (!xen_vm_hard_shutdown(session, vm)) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            xen_vm_set_free(vms);
            return -1;
        }
        xen_vm_set_free(vms);
941
        dom->id = -1;
942 943
        return 0;
    }
944 945
    if (vms)
        xen_vm_set_free(vms);
946
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
947 948 949
    return -1;
}

950 951 952 953 954 955 956 957 958 959 960
/*
 * xenapiDomainDestroy:
 * @dom: domain object
 *
 * See xenapiDomainDestroyFlags
 */
static int
xenapiDomainDestroy(virDomainPtr dom)
{
    return xenapiDomainDestroyFlags(dom, 0);
}
961 962 963 964 965 966 967
/*
 * xenapiDomainGetOSType
 *
 *
 * Returns OS version on success or NULL in case of error
 */
static char *
968
xenapiDomainGetOSType(virDomainPtr dom)
969
{
970
    xen_vm vm = NULL;
971 972
    xen_vm_set *vms;
    char *ostype = NULL;
973
    char *boot_policy = NULL;
974 975 976 977
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;

    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
978 979
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
980 981 982 983 984 985 986 987
            xen_vm_set_free(vms);
            return NULL;
        }
        vm = vms->contents[0];
        if (!xen_vm_get_hvm_boot_policy(session, &boot_policy, vm)) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            goto cleanup;
        }
988 989
        ignore_value(VIR_STRDUP(ostype,
                                STREQ(boot_policy, "BIOS order") ? "hvm" : "xen"));
990
        VIR_FREE(boot_policy);
991
    } else {
992
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
993
    }
994

995
 cleanup:
996 997
    if (vms)
        xen_vm_set_free(vms);
998 999 1000 1001 1002 1003 1004 1005
    return ostype;
}
/*
 * xenapiDomainGetMaxMemory
 *
 * Returns maximum static memory for VM on success
 * or 0 in case of error
 */
1006
static unsigned long long
1007
xenapiDomainGetMaxMemory(virDomainPtr dom)
1008 1009 1010 1011 1012 1013 1014
{
    int64_t mem_static_max = 0;
    xen_vm vm;
    xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1015 1016
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1017 1018 1019 1020 1021 1022
            xen_vm_set_free(vms);
            return 0;
        }
        vm = vms->contents[0];
        xen_vm_get_memory_static_max(session, &mem_static_max, vm);
        xen_vm_set_free(vms);
1023
        return mem_static_max / 1024;
1024
    } else {
1025 1026
        if (vms)
            xen_vm_set_free(vms);
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
        return 0;
    }
}

/*
 * xenapiDomainSetMaxMemory
 *
 * Sets maximum static memory for VM on success
 * Returns 0 on success or -1 in case of error
 */
static int
1039
xenapiDomainSetMaxMemory(virDomainPtr dom, unsigned long memory)
1040 1041 1042 1043 1044 1045 1046
{
    /* vm.set_memory_static_max */
    xen_vm vm;
    struct xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1047 1048
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        if (!(xen_vm_set_memory_static_max(session, vm, memory * 1024))) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            xen_vm_set_free(vms);
            return -1;
        }
        xen_vm_set_free(vms);
    } else {
1060 1061
        if (vms)
            xen_vm_set_free(vms);
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
        return -1;
    }
    return 0;
}

/*
 * xenapiDomainGetInfo:
 *
 * Fills a structure with domain information
 * Returns 0 on success or -1 in case of error
 */
static int
1075
xenapiDomainGetInfo(virDomainPtr dom, virDomainInfoPtr info)
1076 1077 1078 1079 1080 1081 1082 1083 1084
{
    int64_t maxmem = 0, memory = 0, vcpu = 0;
    xen_vm vm;
    xen_vm_record *record;
    xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    info->cpuTime = 0; /* CPU time is not advertised */
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1085 1086
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1087 1088 1089 1090 1091 1092
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        xen_vm_get_memory_static_max(session, &maxmem, vm);
        info->maxMem = (maxmem / 1024);
1093
        enum xen_vm_power_state state = XEN_VM_POWER_STATE_UNDEFINED;
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
        xen_vm_get_power_state(session, &state, vm);
        info->state = mapPowerState(state);
        xen_vm_get_record(session, &record, vm);
        if (record != NULL) {
            xen_vm_metrics_get_memory_actual(session, &memory, record->metrics->u.handle);
            info->memory = (memory / 1024);
            xen_vm_record_free(record);
        }
        xen_vm_get_vcpus_max(session, &vcpu, vm);
        info->nrVirtCpu = vcpu;
        xen_vm_set_free(vms);
        return 0;
    }
1107 1108
    if (vms)
        xen_vm_set_free(vms);
1109 1110 1111 1112
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
    return -1;
}

1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
/*
 * xenapiDomainGetState:
 *
 * Retrieves domain status and its reason.
 *
 * Returns 0 on success or -1 in case of error
 */
static int
xenapiDomainGetState(virDomainPtr dom,
                     int *state,
                     int *reason,
                     unsigned int flags)
{
    struct _xenapiPrivate *priv = dom->conn->privateData;
    enum xen_vm_power_state powerState = XEN_VM_POWER_STATE_UNDEFINED;
    xen_vm_set *vms = NULL;
    xen_vm vm;
    int ret = -1;

    virCheckFlags(0, -1);

    if (!xen_vm_get_by_name_label(priv->session, &vms, dom->name) ||
        vms->size == 0) {
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
        goto cleanup;
    }

    if (vms->size != 1) {
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Domain name is not unique"));
        goto cleanup;
    }

    vm = vms->contents[0];
    xen_vm_get_power_state(priv->session, &powerState, vm);

    *state = mapPowerState(powerState);
    if (reason)
        *reason = 0;

    ret = 0;

1155
 cleanup:
1156 1157 1158 1159 1160
    if (vms)
        xen_vm_set_free(vms);
    return ret;
}

1161 1162

/*
1163
 * xenapiDomainSetVcpusFlags
1164 1165 1166 1167 1168
 *
 * Sets the VCPUs on the domain
 * Return 0 on success or -1 in case of error
 */
static int
1169 1170
xenapiDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus,
                          unsigned int flags)
1171 1172 1173 1174 1175
{
    /* vm.set_vcpus_max */
    xen_vm vm;
    xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
1176 1177

    if (flags != VIR_DOMAIN_VCPU_LIVE) {
1178 1179
        virReportError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"),
                       flags);
1180 1181 1182
        return -1;
    }

1183 1184
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1185 1186
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1187 1188 1189 1190 1191 1192 1193 1194 1195
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        if (xen_vm_set_vcpus_number_live(session, vm, (int64_t)nvcpus)) {
            xen_vm_set_free(vms);
            return 0;
        }
    }
1196 1197
    if (vms)
        xen_vm_set_free(vms);
1198 1199 1200 1201
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
    return -1;
}

1202 1203 1204 1205 1206 1207 1208
/*
 * xenapiDomainSetVcpus
 *
 * Sets the VCPUs on the domain
 * Return 0 on success or -1 in case of error
 */
static int
1209
xenapiDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus)
1210 1211 1212 1213
{
    return xenapiDomainSetVcpusFlags(dom, nvcpus, VIR_DOMAIN_VCPU_LIVE);
}

1214 1215 1216 1217 1218 1219 1220
/*
 * xenapiDomainPinVcpu
 *
 * Dynamically change the real CPUs which can be allocated to a virtual CPU
 * Returns 0 on success or -1 in case of error
 */
static int
1221 1222
xenapiDomainPinVcpu(virDomainPtr dom, unsigned int vcpu ATTRIBUTE_UNUSED,
                    unsigned char *cpumap, int maplen)
1223 1224 1225 1226 1227 1228 1229
{
    char *value = NULL;
    xen_vm vm;
    xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1230 1231
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        if ((value = mapDomainPinVcpu(cpumap, maplen))) {
            xen_vm_remove_from_vcpus_params(session, vm, (char *)"mask");
            if (xen_vm_add_to_vcpus_params(session, vm, (char *)"mask", value)) {
                xen_vm_set_free(vms);
                VIR_FREE(value);
                return 0;
            }
            VIR_FREE(value);
        } else {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            xen_vm_set_free(vms);
            return -1;
        }
    }
1250 1251
    if (vms)
        xen_vm_set_free(vms);
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
    return -1;
}

/*
 * xenapiDomainGetVcpus
 *
 * Gets Vcpu information
 * Return number of structures filled on success or -1 in case of error
 */
static int
1263 1264 1265
xenapiDomainGetVcpus(virDomainPtr dom,
                     virVcpuInfoPtr info, int maxinfo,
                     unsigned char *cpumaps, int maplen)
1266 1267 1268 1269 1270
{

    xen_vm_set *vms = NULL;
    xen_vm vm = NULL;
    xen_string_string_map *vcpu_params = NULL;
1271 1272
    int nvcpus = 0;
    size_t i;
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
    virDomainInfo domInfo;
    virNodeInfo nodeInfo;
    virVcpuInfoPtr ifptr;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    char *mask = NULL;
    if (cpumaps != NULL && maplen < 1)
        return -1;
    if (xenapiDomainGetInfo(dom, &domInfo) == 0) {
        nvcpus = domInfo.nrVirtCpu;
    } else {
1283 1284
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Couldn't fetch Domain Information"));
1285 1286
        return -1;
    }
E
Eric Blake 已提交
1287
    if (xenapiNodeGetInfo(dom->conn, &nodeInfo) != 0) {
1288 1289
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Couldn't fetch Node Information"));
1290 1291 1292 1293 1294 1295 1296 1297 1298
        return -1;
    }
    if (nvcpus > maxinfo)
        nvcpus = maxinfo;
    if (cpumaps != NULL)
        memset(cpumaps, 0, maxinfo * maplen);
    if (!xen_vm_get_by_name_label(session, &vms, dom->name))
        return -1;
    if (vms->size != 1) {
1299 1300
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Domain name is not unique"));
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311
        xen_vm_set_free(vms);
        return -1;
    }
    vm = vms->contents[0];
    if (!xen_vm_get_vcpus_params(session, &vcpu_params, vm)) {
        xen_vm_set_free(vms);
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
        return -1;
    }
    for (i = 0; i < vcpu_params->size; i++) {
        if (STREQ(vcpu_params->contents[i].key, "mask")) {
1312
            if (VIR_STRDUP(mask, vcpu_params->contents[i].val) < 0) {
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
                 xen_vm_set_free(vms);
                 xen_string_string_map_free(vcpu_params);
                 return -1;
            }
            break;
         }
    }
    xen_string_string_map_free(vcpu_params);
    for (i = 0, ifptr = info; i < nvcpus; i++, ifptr++) {
        ifptr->number = i;
        ifptr->state = VIR_VCPU_RUNNING;
        ifptr->cpuTime = 0;
        ifptr->cpu = 0;
        if (mask != NULL)
            getCpuBitMapfromString(mask, VIR_GET_CPUMAP(cpumaps, maplen, i), maplen);
    }
    VIR_FREE(mask);
    xen_vm_set_free(vms);
    return i;
}

/*
1335
 * xenapiDomainGetVcpusFlags
1336 1337
 *
 *
1338
 * Returns Vcpus count on success or -1 in case of error
1339 1340
 */
static int
1341
xenapiDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
1342 1343 1344 1345 1346 1347
{
    xen_vm vm;
    xen_vm_set *vms;
    int64_t maxvcpu = 0;
    enum xen_vm_power_state state;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
1348 1349

    if (flags != (VIR_DOMAIN_VCPU_LIVE | VIR_DOMAIN_VCPU_MAXIMUM)) {
1350 1351
        virReportError(VIR_ERR_INVALID_ARG, _("unsupported flags: (0x%x)"),
                       flags);
1352 1353 1354
        return -1;
    }

1355 1356
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1357 1358
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1359 1360 1361 1362 1363 1364 1365 1366
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        xen_vm_get_power_state(session, &state, vm);
        if (state == XEN_VM_POWER_STATE_RUNNING) {
            xen_vm_get_vcpus_max(session, &maxvcpu, vm);
        } else {
1367
            maxvcpu = xenapiConnectGetMaxVcpus(dom->conn, NULL);
1368 1369 1370 1371
        }
        xen_vm_set_free(vms);
        return (int)maxvcpu;
    }
1372 1373
    if (vms)
        xen_vm_set_free(vms);
1374 1375 1376 1377
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
    return -1;
}

1378 1379 1380 1381 1382 1383 1384
/*
 * xenapiDomainGetMaxVcpus
 *
 *
 * Returns maximum number of Vcpus on success or -1 in case of error
 */
static int
1385
xenapiDomainGetMaxVcpus(virDomainPtr dom)
1386 1387 1388 1389 1390
{
    return xenapiDomainGetVcpusFlags(dom, (VIR_DOMAIN_VCPU_LIVE |
                                           VIR_DOMAIN_VCPU_MAXIMUM));
}

1391
/*
1392
 * xenapiDomainGetXMLDesc
1393 1394 1395 1396 1397
 *
 *
 * Returns XML string of the domain configuration on success or -1 in case of error
 */
static char *
E
Eric Blake 已提交
1398
xenapiDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
1399
{
1400
    xen_vm vm = NULL;
1401
    xen_vm_set *vms;
1402
    xen_string_string_map *result = NULL;
P
Peter Krempa 已提交
1403
    struct _xenapiPrivate *priv = dom->conn->privateData;
1404
    xen_session *session = priv->session;
1405
    virDomainDefPtr defPtr = NULL;
1406
    char *boot_policy = NULL;
1407 1408
    unsigned long memory = 0;
    int64_t dynamic_mem = 0;
1409 1410 1411
    char *val = NULL;
    struct xen_vif_set *vif_set = NULL;
    char *xml;
1412
    unsigned int vcpus;
1413

1414
    /* Flags checked by virDomainDefFormat */
E
Eric Blake 已提交
1415

1416 1417
    if (!xen_vm_get_by_name_label(session, &vms, dom->name))
        return NULL;
1418
    if (vms->size != 1) {
1419 1420
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Domain name is not unique"));
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
        xen_vm_set_free(vms);
        return NULL;
    }
    if (VIR_ALLOC(defPtr) < 0) {
        xen_vm_set_free(vms);
        return NULL;
    }
    vm = vms->contents[0];
    defPtr->virtType = VIR_DOMAIN_VIRT_XEN;
    defPtr->id = dom->id;
    memcpy(defPtr->uuid, dom->uuid, VIR_UUID_BUFLEN);
1432 1433
    if (VIR_STRDUP(defPtr->name, dom->name) < 0)
        goto error;
1434
    xen_vm_get_hvm_boot_policy(session, &boot_policy, vm);
E
Eric Blake 已提交
1435
    if (STREQ(boot_policy, "BIOS order")) {
1436
        defPtr->os.type = VIR_DOMAIN_OSTYPE_HVM;
1437 1438
        xen_vm_get_hvm_boot_params(session, &result, vm);
        if (result != NULL) {
1439
            size_t i;
1440 1441 1442
            for (i = 0; i < result->size; i++) {
                if (STREQ(result->contents[i].key, "order")) {
                    int cnt = 0;
1443
                    while (result->contents[i].val[cnt] != '\0') {
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
                        defPtr->os.bootDevs[cnt] = map2LibvirtBootOrder(result->contents[i].val[cnt]);
                        cnt++;
                    }
                    defPtr->os.nBootDevs = cnt;
                    break;
                }
            }
            xen_string_string_map_free(result);
        }
        VIR_FREE(boot_policy);
    } else {
        char *value = NULL;
1456
        defPtr->os.type = VIR_DOMAIN_OSTYPE_XEN;
1457 1458
        if (VIR_ALLOC(defPtr->os.loader) < 0 ||
            VIR_STRDUP(defPtr->os.loader->path, "pygrub") < 0) {
1459
            VIR_FREE(boot_policy);
1460
            goto error;
1461 1462 1463
        }
        xen_vm_get_pv_kernel(session, &value, vm);
        if (STRNEQ(value, "")) {
1464
            if (VIR_STRDUP(defPtr->os.kernel, value) < 0) {
1465 1466
                VIR_FREE(boot_policy);
                VIR_FREE(value);
1467
                goto error;
1468 1469 1470 1471 1472
            }
            VIR_FREE(value);
        }
        xen_vm_get_pv_ramdisk(session, &value, vm);
        if (STRNEQ(value, "")) {
1473
            if (VIR_STRDUP(defPtr->os.initrd, value) < 0) {
1474 1475
                VIR_FREE(boot_policy);
                VIR_FREE(value);
1476
                goto error;
1477 1478 1479 1480 1481
            }
            VIR_FREE(value);
        }
        xen_vm_get_pv_args(session, &value, vm);
        if (STRNEQ(value, "")) {
1482
            if (VIR_STRDUP(defPtr->os.cmdline, value) < 0) {
1483 1484
                VIR_FREE(boot_policy);
                VIR_FREE(value);
1485
                goto error;
1486 1487 1488 1489
            }
            VIR_FREE(value);
        }
        VIR_FREE(boot_policy);
1490 1491
        if (VIR_STRDUP(defPtr->os.bootloader, "pygrub") < 0)
            goto error;
1492 1493 1494
    }
    xen_vm_get_pv_bootloader_args(session, &val, vm);
    if (STRNEQ(val, "")) {
1495
        if (VIR_STRDUP(defPtr->os.bootloaderArgs, val) < 0) {
1496
            VIR_FREE(val);
1497
            goto error;
1498 1499 1500 1501
        }
        VIR_FREE(val);
    }
    memory = xenapiDomainGetMaxMemory(dom);
1502
    virDomainDefSetMemoryTotal(defPtr, memory);
1503
    if (xen_vm_get_memory_dynamic_max(session, &dynamic_mem, vm)) {
1504
        defPtr->mem.cur_balloon = (unsigned long) (dynamic_mem / 1024);
1505
    } else {
1506
        defPtr->mem.cur_balloon = memory;
1507
    }
1508 1509 1510

    vcpus = xenapiDomainGetMaxVcpus(dom);

1511
    if (virDomainDefSetVcpusMax(defPtr, vcpus, priv->xmlopt) < 0)
1512 1513
        goto error;

1514 1515
    if (virDomainDefSetVcpus(defPtr, vcpus) < 0)
        goto error;
1516

1517
    enum xen_on_normal_exit action;
1518
    if (xen_vm_get_actions_after_shutdown(session, &action, vm))
1519
        defPtr->onPoweroff = xenapiNormalExitEnum2virDomainLifecycle(action);
1520
    if (xen_vm_get_actions_after_reboot(session, &action, vm))
1521 1522
        defPtr->onReboot = xenapiNormalExitEnum2virDomainLifecycle(action);
    enum xen_on_crash_behaviour crash;
1523
    if (xen_vm_get_actions_after_crash(session, &crash, vm))
1524
        defPtr->onCrash = xenapiCrashExitEnum2virDomainLifecycle(crash);
1525 1526
    xen_vm_get_platform(session, &result, vm);
    if (result != NULL) {
1527
        size_t i;
1528
        for (i = 0; i < result->size; i++) {
1529 1530
            if (STREQ(result->contents[i].val, "true")) {
                if (STREQ(result->contents[i].key, "acpi"))
J
Ján Tomko 已提交
1531
                    defPtr->features[VIR_DOMAIN_FEATURE_ACPI] = VIR_TRISTATE_SWITCH_ON;
1532
                else if (STREQ(result->contents[i].key, "apic"))
J
Ján Tomko 已提交
1533
                    defPtr->features[VIR_DOMAIN_FEATURE_APIC] = VIR_TRISTATE_SWITCH_ON;
1534
                else if (STREQ(result->contents[i].key, "pae"))
J
Ján Tomko 已提交
1535
                    defPtr->features[VIR_DOMAIN_FEATURE_PAE] = VIR_TRISTATE_SWITCH_ON;
1536
                else if (STREQ(result->contents[i].key, "hap"))
J
Ján Tomko 已提交
1537
                    defPtr->features[VIR_DOMAIN_FEATURE_HAP] = VIR_TRISTATE_SWITCH_ON;
1538
                else if (STREQ(result->contents[i].key, "viridian"))
J
Ján Tomko 已提交
1539
                    defPtr->features[VIR_DOMAIN_FEATURE_VIRIDIAN] = VIR_TRISTATE_SWITCH_ON;
1540 1541 1542 1543 1544 1545
            }
        }
        xen_string_string_map_free(result);
    }
    xen_vm_get_vifs(session, &vif_set, vm);
    if (vif_set) {
1546
        size_t i;
1547 1548 1549 1550 1551 1552 1553
        xen_vif vif;
        xen_vif_record *vif_rec = NULL;
        xen_network network;
        char *bridge = NULL;
        defPtr->nnets = vif_set->size;
        if (VIR_ALLOC_N(defPtr->nets, vif_set->size) < 0) {
            xen_vif_set_free(vif_set);
1554
            goto error;
1555 1556 1557 1558
        }
        for (i = 0; i < vif_set->size; i++) {
            if (VIR_ALLOC(defPtr->nets[i]) < 0) {
                xen_vif_set_free(vif_set);
1559
                goto error;
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
            }
            defPtr->nets[i]->type = VIR_DOMAIN_NET_TYPE_BRIDGE;
            vif = vif_set->contents[i];
            xen_vif_get_network(session, &network, vif);
            if (network != NULL) {
                xen_network_get_bridge(session, &bridge, network);
                if (bridge != NULL)
                    defPtr->nets[i]->data.bridge.brname = bridge;
                xen_network_free(network);
            }
            xen_vif_get_record(session, &vif_rec, vif);
            if (vif_rec != NULL) {
J
Jiri Denemark 已提交
1572 1573
                if (virMacAddrParse((const char *)vif_rec->mac,
                                    &defPtr->nets[i]->mac) < 0)
1574
                    xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
1575
                                              _("Unable to parse given mac address"));
1576 1577 1578 1579 1580
                xen_vif_record_free(vif_rec);
            }
        }
        xen_vif_set_free(vif_set);
    }
1581
    xen_vm_set_free(vms);
1582
    xml = virDomainDefFormat(defPtr, priv->caps, flags);
1583 1584 1585
    virDomainDefFree(defPtr);
    return xml;

1586
 error:
1587 1588 1589 1590 1591 1592
    xen_vm_set_free(vms);
    virDomainDefFree(defPtr);
    return NULL;
}

/*
1593
 * xenapiConnectListDefinedDomains
1594 1595 1596 1597 1598
 *
 * list the defined but inactive domains, stores the pointers to the names in @names
 * Returns number of names provided in the array or -1 in case of error
 */
static int
1599 1600
xenapiConnectListDefinedDomains(virConnectPtr conn, char **const names,
                                int maxnames)
1601
{
1602 1603
    size_t i, j;
    int doms;
1604 1605 1606 1607
    xen_vm_set *result;
    xen_vm_record *record;
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
    xen_vm_get_all(session, &result);
1608
    memset(names, 0, sizeof(names[0])*maxnames);
1609
    if (result != NULL) {
1610
        for (i = 0, j = 0; i < result->size && j < maxnames; i++) {
1611 1612 1613 1614
            xen_vm_get_record(session, &record, result->contents[i]);
            if (record != NULL) {
                if (record->is_a_template == 0) {
                    char *usenames = NULL;
1615
                    if (VIR_STRDUP(usenames, record->name_label) < 0) {
1616 1617
                        xen_vm_record_free(record);
                        xen_vm_set_free(result);
1618 1619
                        for (i = 0; i < maxnames; i++)
                            VIR_FREE(names[j]);
1620 1621 1622 1623 1624 1625
                        return -1;
                    }
                    names[j++] = usenames;
                }
                xen_vm_record_free(record);
            } else {
1626 1627
                xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                          _("Couldn't get VM record"));
1628
                xen_vm_set_free(result);
1629 1630 1631
                for (i = 0; i < maxnames; i++)
                    VIR_FREE(names[j]);
                return -1;
1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
            }
        }
        doms = j;
        xen_vm_set_free(result);
        return doms;
    }
    xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
    return -1;
}

/*
1643
 * xenapiConnectNumOfDefinedDomains
1644 1645 1646 1647 1648
 *
 * Provides the number of defined but inactive domains
 * Returns number of domains found on success or -1 in case of error
 */
static int
1649
xenapiConnectNumOfDefinedDomains(virConnectPtr conn)
1650 1651 1652
{
    xen_vm_set *result;
    xen_vm_record *record;
1653 1654
    int DomNum = 0;
    size_t i;
1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
    xen_vm_get_all(session, &result);
    if (result != NULL) {
        for (i = 0; i < result->size; i++) {
            xen_vm_get_record(session, &record, result->contents[i]);
            if (record == NULL && !session->ok) {
                xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
                xen_vm_set_free(result);
                return -1;
            }
1665 1666 1667 1668 1669
            if (record) {
                if (record->is_a_template == 0)
                    DomNum++;
                xen_vm_record_free(record);
            }
1670 1671 1672 1673 1674 1675 1676 1677 1678
        }
        xen_vm_set_free(result);
        return DomNum;
    }
    xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
    return -1;
}

/*
1679
 * xenapiDomainCreateWithFlags
1680 1681 1682 1683 1684
 *
 * starts a VM
 * Return 0 on success or -1 in case of error
 */
static int
1685
xenapiDomainCreateWithFlags(virDomainPtr dom, unsigned int flags)
1686 1687 1688 1689
{
    xen_vm_set *vms;
    xen_vm vm;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
1690
    int64_t domid = -1;
1691 1692 1693

    virCheckFlags(0, -1);

1694 1695
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1696 1697
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1698 1699 1700 1701 1702 1703 1704 1705 1706
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        if (!xen_vm_start(session, vm, false, false)) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            xen_vm_set_free(vms);
            return -1;
        }
1707 1708 1709 1710

        xen_vm_get_domid(session, &domid, vm);
        dom->id = domid;

1711 1712
        xen_vm_set_free(vms);
    } else {
1713 1714
        if (vms)
            xen_vm_set_free(vms);
1715 1716 1717 1718 1719 1720
        xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
        return -1;
    }
    return 0;
}

1721 1722 1723 1724 1725 1726 1727
/*
 * xenapiDomainCreate
 *
 * starts a VM
 * Return 0 on success or -1 in case of error
 */
static int
1728
xenapiDomainCreate(virDomainPtr dom)
1729 1730 1731 1732
{
    return xenapiDomainCreateWithFlags(dom, 0);
}

1733 1734 1735 1736 1737 1738 1739
/*
 * xenapiDomainDefineXML
 *
 * Defines a domain from the given XML but does not start it
 * Returns 0 on success or -1 in case of error
 */
static virDomainPtr
1740
xenapiDomainDefineXMLFlags(virConnectPtr conn, const char *xml, unsigned int flags)
1741
{
1742
    struct _xenapiPrivate *priv = conn->privateData;
1743 1744 1745
    xen_vm_record *record = NULL;
    xen_vm vm = NULL;
    virDomainPtr domP = NULL;
1746 1747 1748
    unsigned int parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;

    virCheckFlags(VIR_DOMAIN_DEFINE_VALIDATE, NULL);
1749

1750
    if (flags & VIR_DOMAIN_DEFINE_VALIDATE)
1751
        parse_flags |= VIR_DOMAIN_DEF_PARSE_VALIDATE_SCHEMA;
1752

1753
    if (!priv->caps)
1754
        return NULL;
1755 1756
    virDomainDefPtr defPtr = virDomainDefParseString(xml,
                                                     priv->caps, priv->xmlopt,
1757
                                                     NULL,
1758
                                                     parse_flags);
1759 1760
    if (!defPtr)
        return NULL;
M
Matthias Bolte 已提交
1761

1762
    if (createVMRecordFromXml(conn, defPtr, &record, &vm) != 0) {
1763
        if (!priv->session->ok)
1764 1765
            xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR, NULL);
        else
1766 1767
            xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Couldn't get VM information from XML"));
1768 1769 1770 1771 1772
        virDomainDefFree(defPtr);
        return NULL;
    }
    if (record != NULL) {
        unsigned char raw_uuid[VIR_UUID_BUFLEN];
1773
        ignore_value(virUUIDParse(record->uuid, raw_uuid));
1774
        domP = virGetDomain(conn, record->name_label, raw_uuid);
1775
        if (!domP && !priv->session->ok)
1776 1777 1778 1779 1780 1781 1782 1783 1784
            xenapiSessionErrorHandler(conn, VIR_ERR_NO_DOMAIN, NULL);
        xen_vm_record_free(record);
    }
    else if (vm != NULL)
        xen_vm_free(vm);
    virDomainDefFree(defPtr);
    return domP;
}

1785 1786 1787 1788 1789 1790
static virDomainPtr
xenapiDomainDefineXML(virConnectPtr conn, const char *xml)
{
    return xenapiDomainDefineXMLFlags(conn, xml, 0);
}

1791
/*
1792
 * xenapiDomainUndefineFlags
1793 1794 1795 1796 1797
 *
 * destroys a domain
 * Return 0 on success or -1 in case of error
 */
static int
1798
xenapiDomainUndefineFlags(virDomainPtr dom, unsigned int flags)
1799 1800 1801 1802
{
    struct xen_vm_set *vms;
    xen_vm vm;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
1803 1804
    virCheckFlags(0, -1);

1805 1806
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1807 1808
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        if (!xen_vm_destroy(session, vm)) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            xen_vm_set_free(vms);
            return -1;
        }
        xen_vm_set_free(vms);
        return 0;
    }
1821 1822
    if (vms)
        xen_vm_set_free(vms);
1823
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
1824 1825 1826
    return -1;
}

1827 1828 1829 1830 1831 1832
static int
xenapiDomainUndefine(virDomainPtr dom)
{
    return xenapiDomainUndefineFlags(dom, 0);
}

1833 1834 1835 1836 1837 1838 1839 1840
/*
 * xenapiDomainGetAutostart
 *
 * Provides a boolean value indicating whether the domain configured
 * to be automatically started when the host machine boots
 * Return 0 on success or -1 in case of error
 */
static int
1841
xenapiDomainGetAutostart(virDomainPtr dom, int *autostart)
1842
{
1843 1844
    size_t i;
    int flag = 0;
1845 1846 1847 1848 1849 1850
    xen_vm_set *vms;
    xen_vm vm;
    xen_string_string_map *result;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1851 1852
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        if (!xen_vm_get_other_config(session, &result, vm)) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            xen_vm_set_free(vms);
            return -1;
        }
        for (i = 0; i < result->size; i++) {
            if (STREQ(result->contents[i].key, "auto_poweron")) {
                flag = 1;
                if (STREQ(result->contents[i].val, "true"))
                    *autostart = 1;
                else
                    *autostart = 0;
                break;
            }
        }
        xen_vm_set_free(vms);
        xen_string_string_map_free(result);
1874 1875
        if (flag == 0)
            return -1;
1876 1877
        return 0;
    }
1878 1879
    if (vms)
        xen_vm_set_free(vms);
1880
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
1881 1882 1883 1884 1885 1886 1887 1888 1889 1890
    return -1;
}

/*
 * xenapiDomainSetAutostart
 *
 * Configure the domain to be automatically started when the host machine boots
 * Return 0 on success or -1 in case of error
 */
static int
1891
xenapiDomainSetAutostart(virDomainPtr dom, int autostart)
1892 1893 1894 1895 1896 1897 1898
{
    xen_vm_set *vms;
    xen_vm vm;
    char *value;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;
    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
1899 1900
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
1901 1902 1903 1904 1905
            xen_vm_set_free(vms);
            return -1;
        }
        vm = vms->contents[0];
        xen_vm_remove_from_other_config(session, vm, (char *)"auto_poweron");
1906
        if (autostart == 1)
1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917
            value = (char *)"true";
        else
            value = (char *)"false";
        if (!xen_vm_add_to_other_config(session, vm, (char *)"auto_poweron", value)) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR, NULL);
            xen_vm_set_free(vms);
            return -1;
        }
        xen_vm_set_free(vms);
        return 0;
    }
1918 1919
    if (vms)
        xen_vm_set_free(vms);
1920
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
1921 1922 1923 1924
    return -1;
}

static char *
1925
xenapiDomainGetSchedulerType(virDomainPtr dom ATTRIBUTE_UNUSED, int *nparams)
1926 1927
{
    char *result = NULL;
1928 1929 1930

    if (nparams)
        *nparams = 0;
1931
    ignore_value(VIR_STRDUP(result, "credit"));
1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
    return result;
}

/*
 * xenapiNodeGetFreeMemory
 *
 * provides the free memory available on the Node
 * Returns memory size on success or 0 in case of error
 */
static unsigned long long
1942
xenapiNodeGetFreeMemory(virConnectPtr conn)
1943 1944 1945 1946 1947 1948 1949
{
    xen_host_metrics_set *xen_met_set;
    unsigned long long freeMem = 0;
    xen_session *session = ((struct _xenapiPrivate *)(conn->privateData))->session;
    xen_host_metrics_get_all(session, &xen_met_set);
    if (xen_met_set != NULL) {
        if (!xen_host_metrics_get_memory_free(session, (int64_t *)&freeMem, xen_met_set->contents[0])) {
1950 1951
            xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Couldn't get host metrics - memory information"));
1952 1953 1954 1955
            freeMem = 0;
        }
        xen_host_metrics_set_free(xen_met_set);
    } else {
1956 1957
        xenapiSessionErrorHandler(conn, VIR_ERR_INTERNAL_ERROR,
                                  _("Couldn't get host metrics"));
1958 1959 1960 1961
    }
    return freeMem;
}

1962 1963 1964 1965 1966 1967
static int
xenapiDomainIsUpdated(virDomainPtr dom ATTRIBUTE_UNUSED)
{
    return 0;
}

1968 1969 1970 1971 1972 1973 1974
/*
 * xenapiNodeGetCellsFreeMemory
 *
 *
 * Returns the number of entries filled in freeMems, or -1 in case of error.
 */
static int
1975 1976
xenapiNodeGetCellsFreeMemory(virConnectPtr conn, unsigned long long *freeMems,
                             int startCell, int maxCells)
1977 1978
{
    if (maxCells > 1 && startCell > 0) {
1979
        xenapiSessionErrorHandler(conn, VIR_ERR_NO_SUPPORT, NULL);
1980 1981 1982 1983 1984 1985 1986
        return -1;
    } else {
        freeMems[0] = xenapiNodeGetFreeMemory(conn);
        return 1;
    }
}

1987
static int
1988
xenapiConnectIsAlive(virConnectPtr conn)
1989 1990 1991 1992 1993 1994 1995 1996 1997
{
    struct _xenapiPrivate *priv = conn->privateData;

    if (priv->session && priv->session->ok)
        return 1;
    else
        return 0;
}

1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
static int
xenapiDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
    struct xen_vm_set *vms;
    xen_session *session = ((struct _xenapiPrivate *)(dom->conn->privateData))->session;

    virCheckFlags(0, -1);

    if (xen_vm_get_by_name_label(session, &vms, dom->name) && vms->size > 0) {
        if (vms->size != 1) {
            xenapiSessionErrorHandler(dom->conn, VIR_ERR_INTERNAL_ERROR,
                                      _("Domain name is not unique"));
            xen_vm_set_free(vms);
            return -1;
        }
        xen_vm_set_free(vms);
        return 0;
    }
    if (vms)
        xen_vm_set_free(vms);
    xenapiSessionErrorHandler(dom->conn, VIR_ERR_NO_DOMAIN, NULL);
    return -1;
}

2022
/* The interface which we export upwards to libvirt.c. */
2023
static virHypervisorDriver xenapiHypervisorDriver = {
2024
    .name = "XenAPI",
2025 2026 2027 2028 2029 2030 2031
    .connectOpen = xenapiConnectOpen, /* 0.8.0 */
    .connectClose = xenapiConnectClose, /* 0.8.0 */
    .connectSupportsFeature = xenapiConnectSupportsFeature, /* 0.8.0 */
    .connectGetType = xenapiConnectGetType, /* 0.8.0 */
    .connectGetVersion = xenapiConnectGetVersion, /* 0.8.0 */
    .connectGetHostname = xenapiConnectGetHostname, /* 0.8.0 */
    .connectGetMaxVcpus = xenapiConnectGetMaxVcpus, /* 0.8.0 */
2032
    .nodeGetInfo = xenapiNodeGetInfo, /* 0.8.0 */
2033 2034 2035
    .connectGetCapabilities = xenapiConnectGetCapabilities, /* 0.8.0 */
    .connectListDomains = xenapiConnectListDomains, /* 0.8.0 */
    .connectNumOfDomains = xenapiConnectNumOfDomains, /* 0.8.0 */
2036 2037 2038 2039 2040 2041 2042
    .domainCreateXML = xenapiDomainCreateXML, /* 0.8.0 */
    .domainLookupByID = xenapiDomainLookupByID, /* 0.8.0 */
    .domainLookupByUUID = xenapiDomainLookupByUUID, /* 0.8.0 */
    .domainLookupByName = xenapiDomainLookupByName, /* 0.8.0 */
    .domainSuspend = xenapiDomainSuspend, /* 0.8.0 */
    .domainResume = xenapiDomainResume, /* 0.8.0 */
    .domainShutdown = xenapiDomainShutdown, /* 0.8.0 */
2043
    .domainShutdownFlags = xenapiDomainShutdownFlags, /* 0.9.10 */
2044 2045
    .domainReboot = xenapiDomainReboot, /* 0.8.0 */
    .domainDestroy = xenapiDomainDestroy, /* 0.8.0 */
2046
    .domainDestroyFlags = xenapiDomainDestroyFlags, /* 0.9.4 */
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
    .domainGetOSType = xenapiDomainGetOSType, /* 0.8.0 */
    .domainGetMaxMemory = xenapiDomainGetMaxMemory, /* 0.8.0 */
    .domainSetMaxMemory = xenapiDomainSetMaxMemory, /* 0.8.0 */
    .domainGetInfo = xenapiDomainGetInfo, /* 0.8.0 */
    .domainGetState = xenapiDomainGetState, /* 0.9.2 */
    .domainSetVcpus = xenapiDomainSetVcpus, /* 0.8.0 */
    .domainSetVcpusFlags = xenapiDomainSetVcpusFlags, /* 0.8.5 */
    .domainGetVcpusFlags = xenapiDomainGetVcpusFlags, /* 0.8.5 */
    .domainPinVcpu = xenapiDomainPinVcpu, /* 0.8.0 */
    .domainGetVcpus = xenapiDomainGetVcpus, /* 0.8.0 */
    .domainGetMaxVcpus = xenapiDomainGetMaxVcpus, /* 0.8.0 */
    .domainGetXMLDesc = xenapiDomainGetXMLDesc, /* 0.8.0 */
2059 2060
    .connectListDefinedDomains = xenapiConnectListDefinedDomains, /* 0.8.0 */
    .connectNumOfDefinedDomains = xenapiConnectNumOfDefinedDomains, /* 0.8.0 */
2061 2062 2063
    .domainCreate = xenapiDomainCreate, /* 0.8.0 */
    .domainCreateWithFlags = xenapiDomainCreateWithFlags, /* 0.8.2 */
    .domainDefineXML = xenapiDomainDefineXML, /* 0.8.0 */
2064
    .domainDefineXMLFlags = xenapiDomainDefineXMLFlags, /* 1.2.12 */
2065
    .domainUndefine = xenapiDomainUndefine, /* 0.8.0 */
2066
    .domainUndefineFlags = xenapiDomainUndefineFlags, /* 0.9.5 */
2067 2068 2069 2070 2071 2072
    .domainGetAutostart = xenapiDomainGetAutostart, /* 0.8.0 */
    .domainSetAutostart = xenapiDomainSetAutostart, /* 0.8.0 */
    .domainGetSchedulerType = xenapiDomainGetSchedulerType, /* 0.8.0 */
    .nodeGetCellsFreeMemory = xenapiNodeGetCellsFreeMemory, /* 0.8.0 */
    .nodeGetFreeMemory = xenapiNodeGetFreeMemory, /* 0.8.0 */
    .domainIsUpdated = xenapiDomainIsUpdated, /* 0.8.6 */
2073
    .connectIsAlive = xenapiConnectIsAlive, /* 0.9.8 */
2074
    .domainHasManagedSaveImage = xenapiDomainHasManagedSaveImage, /* 1.2.13 */
2075 2076
};

2077 2078 2079 2080 2081

static virConnectDriver xenapiConnectDriver = {
    .hypervisorDriver = &xenapiHypervisorDriver,
};

2082 2083 2084 2085 2086 2087 2088
/**
 * xenapiRegister:
 *
 *
 * Returns the driver priority or -1 in case of error.
 */
int
2089
xenapiRegister(void)
2090
{
2091 2092
    return virRegisterConnectDriver(&xenapiConnectDriver,
                                    false);
2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
}

/*
 * write_func
 * used by curl to read data from the server
 */
size_t
write_func(void *ptr, size_t size, size_t nmemb, void *comms_)
{
    xen_comms *comms = comms_;
    size_t n = size * nmemb;
J
Jiri Denemark 已提交
2104 2105
#ifdef PRINT_XML
    printf("\n\n---Result from server -----------------------\n");
E
Eric Blake 已提交
2106
    printf("%s\n", (char*) ptr);
J
Jiri Denemark 已提交
2107 2108
    fflush(stdout);
#endif
2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120
    return (size_t) (comms->func(ptr, n, comms->handle) ? n : 0);
}

/*
 * call_func
 * sets curl options, used with xen_session_login_with_password
 */
int
call_func(const void *data, size_t len, void *user_handle,
          void *result_handle, xen_result_func result_func)
{
    struct _xenapiPrivate *priv = (struct _xenapiPrivate *)user_handle;
J
Jiri Denemark 已提交
2121 2122
#ifdef PRINT_XML
    printf("\n\n---Data to server: -----------------------\n");
E
Eric Blake 已提交
2123
    printf("%s\n", (char*) data);
J
Jiri Denemark 已提交
2124 2125
    fflush(stdout);
#endif
2126
    CURL *curl = curl_easy_init();
2127
    if (!curl)
2128 2129 2130 2131 2132 2133 2134
      return -1;
    xen_comms comms = {
     .func = result_func,
     .handle = result_handle
    };
    curl_easy_setopt(curl, CURLOPT_URL, priv->url);
    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
J
Jiri Denemark 已提交
2135 2136 2137
#ifdef CURLOPT_MUTE
    curl_easy_setopt(curl, CURLOPT_MUTE, 1);
#endif
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &write_func);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &comms);
    curl_easy_setopt(curl, CURLOPT_POST, 1);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, priv->noVerify?0:1);
    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, priv->noVerify?0:2);
    CURLcode result = curl_easy_perform(curl);
    curl_easy_cleanup(curl);
    return result;
}