xen_unified.c 18.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
/*
 * xen_unified.c: Unified Xen driver.
 *
 * Copyright (C) 2007 Red Hat, Inc.
 *
 * See COPYING.LIB for the License of this software
 *
 * Richard W.M. Jones <rjones@redhat.com>
 */

#ifdef WITH_XEN

/* Note:
 *
 * This driver provides a unified interface to the five
 * separate underlying Xen drivers (xen_internal, proxy_internal,
 * xend_internal, xs_internal and xm_internal).  Historically
 * the body of libvirt.c handled the five Xen drivers,
 * and contained Xen-specific code.
 *
 * The interface between Xen drivers and xen_unified is
 * the same as for "ordinary" libvirt drivers (ie. virDriverPtr),
 * however this is just for convenience and may be changed
 * in future.  Libvirt.c should no longer call directly
 * to the five underlying Xen drivers.
 */

#include <stdint.h>
#include <unistd.h>
#include <sys/types.h>
#include <xen/dom0_ops.h>

#include "internal.h"

#include "xen_unified.h"

#include "xen_internal.h"
#include "proxy_internal.h"
#include "xend_internal.h"
#include "xs_internal.h"
#include "xm_internal.h"

/* The five Xen drivers below us. */
static virDriverPtr drivers[] = {
45 46 47 48 49
    &xenHypervisorDriver,
    &xenProxyDriver,
    &xenDaemonDriver,
    &xenStoreDriver,
    &xenXMDriver
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
};
static const int nb_drivers = sizeof drivers / sizeof drivers[0];
static const int hypervisor_offset = 0;
static const int proxy_offset = 1;

/**
 * xenUnifiedError:
 * @conn: the connection
 * @error: the error number
 * @info: extra information string
 *
 * Handle an error at the xend daemon interface
 */
static void
xenUnifiedError (virConnectPtr conn, virErrorNumber error, const char *info)
{
    const char *errmsg;

    errmsg = __virErrorMsg (error, info);
    __virRaiseError (conn, NULL, NULL, VIR_FROM_XEN, error, VIR_ERR_ERROR,
70
                     errmsg, info, NULL, 0, 0, errmsg, info);
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
}

/*----- Dispatch functions. -----*/

/* These dispatch functions follow the model used historically
 * by libvirt.c -- trying each low-level Xen driver in turn
 * until one succeeds.  However since we know what low-level
 * drivers can perform which functions, it is probably better
 * in future to optimise these dispatch functions to just call
 * the single function (or small number of appropriate functions)
 * in the low level drivers directly.
 */

static int
xenUnifiedOpen (virConnectPtr conn, const char *name, int flags)
{
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
    int i, j;
    xenUnifiedPrivatePtr priv;

    /* If name == NULL, name == "", or begins with "xen", then it's for us. */
    if (!name || name[0] == '\0')
        name = "xen";
    if (strncasecmp (name, "xen", 3) != 0)
        return VIR_DRV_OPEN_DECLINED;

    /* Allocate per-connection private data. */
    priv = malloc (sizeof *priv);
    if (!priv) {
        xenUnifiedError (conn, VIR_ERR_NO_MEMORY, "allocating private data");
        return VIR_DRV_OPEN_ERROR;
    }
    conn->privateData = priv;

    priv->handle = -1;
    priv->xendConfigVersion = -1;
    priv->type = -1;
    priv->len = -1;
    priv->addr = NULL;
    priv->xshandle = NULL;
    priv->proxy = -1;

    for (i = 0; i < nb_drivers; ++i) {
        int failed_to_open = 1;

        /* Ignore proxy for root */
        if (i == proxy_offset && getuid() == 0)
            continue;

        if (drivers[i]->open &&
            drivers[i]->open (conn, name, flags) == VIR_DRV_OPEN_SUCCESS)
            failed_to_open = 0;

        /* If as root, then all drivers must succeed.
           If non-root, then only proxy must succeed */
        if (failed_to_open && (getuid() == 0 || i == proxy_offset)) {
            for (j = 0; j < i; ++j)
                drivers[j]->close (conn);
            return VIR_DRV_OPEN_ERROR;
        }
130 131
    }

132
    return VIR_DRV_OPEN_SUCCESS;
133 134 135 136 137
}

static int
xenUnifiedClose (virConnectPtr conn)
{
138
    int i;
139

140 141 142
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->close)
            (void) drivers[i]->close (conn);
143

144 145
    free (conn->privateData);
    conn->privateData = NULL;
146

147
    return 0;
148 149 150 151 152
}

static const char *
xenUnifiedType (virConnectPtr conn)
{
153 154
    int i;
    const char *ret;
155

156 157 158 159 160
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->type) {
            ret = drivers[i]->type (conn);
            if (ret) return ret;
        }
161

162
    return NULL;
163 164 165 166 167
}

static int
xenUnifiedVersion (virConnectPtr conn, unsigned long *hvVer)
{
168
    int i;
169

170 171 172 173
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->version &&
            drivers[i]->version (conn, hvVer) == 0)
            return 0;
174

175
    return -1;
176 177 178 179 180
}

static int
xenUnifiedGetMaxVcpus (virConnectPtr conn, const char *type)
{
181
    int i;
182

183 184
    if (!type)
        type = "Xen";
185

186 187 188
    for (i = 0; i < nb_drivers; ++i)
        if (strcmp (drivers[i]->name, type) == 0)
            return drivers[i]->getMaxVcpus (conn, type);
189

190
    return -1;
191 192 193 194 195
}

static int
xenUnifiedNodeGetInfo (virConnectPtr conn, virNodeInfoPtr info)
{
196
    int i;
197

198 199 200 201
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->nodeGetInfo &&
            drivers[i]->nodeGetInfo (conn, info) == 0)
            return 0;
202

203
    return -1;
204 205 206 207 208
}

static char *
xenUnifiedGetCapabilities (virConnectPtr conn)
{
209 210
    int i;
    char *ret;
211

212 213 214 215 216
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->getCapabilities) {
            ret = drivers[i]->getCapabilities (conn);
            if (ret) return ret;
        }
217

218
    return NULL;
219 220 221 222 223
}

static int
xenUnifiedListDomains (virConnectPtr conn, int *ids, int maxids)
{
224
    int i, ret;
225

226 227 228 229 230
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->listDomains) {
            ret = drivers[i]->listDomains (conn, ids, maxids);
            if (ret >= 0) return ret;
        }
231

232
    return -1;
233 234 235 236 237
}

static int
xenUnifiedNumOfDomains (virConnectPtr conn)
{
238
    int i, ret;
239

240 241 242 243 244
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->numOfDomains) {
            ret = drivers[i]->numOfDomains (conn);
            if (ret >= 0) return ret;
        }
245

246
    return -1;
247 248 249 250
}

static virDomainPtr
xenUnifiedDomainCreateLinux (virConnectPtr conn,
251
                             const char *xmlDesc, unsigned int flags)
252
{
253 254
    int i;
    virDomainPtr ret;
255

256 257 258 259 260
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainCreateLinux) {
            ret = drivers[i]->domainCreateLinux (conn, xmlDesc, flags);
            if (ret) return ret;
        }
261

262
    return NULL;
263 264 265 266 267
}

static virDomainPtr
xenUnifiedDomainLookupByID (virConnectPtr conn, int id)
{
268 269
    int i;
    virDomainPtr ret;
270

271 272 273 274 275
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainLookupByID) {
            ret = drivers[i]->domainLookupByID (conn, id);
            if (ret) return ret;
        }
276

277
    return NULL;
278 279 280 281
}

static virDomainPtr
xenUnifiedDomainLookupByUUID (virConnectPtr conn,
282
                              const unsigned char *uuid)
283
{
284 285
    int i;
    virDomainPtr ret;
286

287 288 289 290 291
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainLookupByUUID) {
            ret = drivers[i]->domainLookupByUUID (conn, uuid);
            if (ret) return ret;
        }
292

293
    return NULL;
294 295 296 297
}

static virDomainPtr
xenUnifiedDomainLookupByName (virConnectPtr conn,
298
                              const char *name)
299
{
300 301
    int i;
    virDomainPtr ret;
302

303 304 305 306 307
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainLookupByName) {
            ret = drivers[i]->domainLookupByName (conn, name);
            if (ret) return ret;
        }
308

309
    return NULL;
310 311 312 313 314
}

static int
xenUnifiedDomainSuspend (virDomainPtr dom)
{
315
    int i;
316

317 318 319 320 321 322 323 324
    /* Try non-hypervisor methods first, then hypervisor direct method
     * as a last resort.
     */
    for (i = 0; i < nb_drivers; ++i)
        if (i != hypervisor_offset &&
            drivers[i]->domainSuspend &&
            drivers[i]->domainSuspend (dom) == 0)
            return 0;
325

326 327 328
    if (drivers[hypervisor_offset]->domainSuspend &&
        drivers[hypervisor_offset]->domainSuspend (dom) == 0)
        return 0;
329

330
    return -1;
331 332 333 334 335
}

static int
xenUnifiedDomainResume (virDomainPtr dom)
{
336
    int i;
337

338 339 340 341 342 343 344 345
    /* Try non-hypervisor methods first, then hypervisor direct method
     * as a last resort.
     */
    for (i = 0; i < nb_drivers; ++i)
        if (i != hypervisor_offset &&
            drivers[i]->domainResume &&
            drivers[i]->domainResume (dom) == 0)
            return 0;
346

347 348 349
    if (drivers[hypervisor_offset]->domainResume &&
        drivers[hypervisor_offset]->domainResume (dom) == 0)
        return 0;
350

351
    return -1;
352 353 354 355 356
}

static int
xenUnifiedDomainShutdown (virDomainPtr dom)
{
357
    int i;
358

359 360 361 362
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainShutdown &&
            drivers[i]->domainShutdown (dom) == 0)
            return 0;
363

364
    return -1;
365 366 367 368 369
}

static int
xenUnifiedDomainReboot (virDomainPtr dom, unsigned int flags)
{
370
    int i;
371

372 373 374 375
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainReboot &&
            drivers[i]->domainReboot (dom, flags) == 0)
            return 0;
376

377
    return -1;
378 379 380 381 382
}

static int
xenUnifiedDomainDestroy (virDomainPtr dom)
{
383
    int i;
384

385 386 387 388 389 390 391 392
    /* Try non-hypervisor methods first, then hypervisor direct method
     * as a last resort.
     */
    for (i = 0; i < nb_drivers; ++i)
        if (i != hypervisor_offset &&
            drivers[i]->domainDestroy &&
            drivers[i]->domainDestroy (dom) == 0)
            return 0;
393

394 395 396
    if (drivers[hypervisor_offset]->domainDestroy &&
        drivers[hypervisor_offset]->domainDestroy (dom) == 0)
        return 0;
397

398
    return -1;
399 400 401 402 403
}

static char *
xenUnifiedDomainGetOSType (virDomainPtr dom)
{
404 405
    int i;
    char *ret;
406

407 408 409 410 411
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainGetOSType) {
            ret = drivers[i]->domainGetOSType (dom);
            if (ret) return ret;
        }
412

413
    return NULL;
414 415 416 417 418
}

static unsigned long
xenUnifiedDomainGetMaxMemory (virDomainPtr dom)
{
419 420
    int i;
    unsigned long ret;
421

422 423 424 425 426
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainGetMaxMemory) {
            ret = drivers[i]->domainGetMaxMemory (dom);
            if (ret != 0) return ret;
        }
427

428
    return 0;
429 430 431 432 433
}

static int
xenUnifiedDomainSetMaxMemory (virDomainPtr dom, unsigned long memory)
{
434
    int i;
435

436 437 438 439
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainSetMaxMemory &&
            drivers[i]->domainSetMaxMemory (dom, memory) == 0)
            return 0;
440

441
    return -1;
442 443 444 445 446
}

static int
xenUnifiedDomainSetMemory (virDomainPtr dom, unsigned long memory)
{
447
    int i;
448

449 450 451 452
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainSetMemory &&
            drivers[i]->domainSetMemory (dom, memory) == 0)
            return 0;
453

454
    return -1;
455 456 457 458 459
}

static int
xenUnifiedDomainGetInfo (virDomainPtr dom, virDomainInfoPtr info)
{
460
    int i;
461

462 463 464 465
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainGetInfo &&
            drivers[i]->domainGetInfo (dom, info) == 0)
            return 0;
466

467
    return -1;
468 469 470 471 472
}

static int
xenUnifiedDomainSave (virDomainPtr dom, const char *to)
{
473
    int i;
474

475 476 477 478
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainSave &&
            drivers[i]->domainSave (dom, to) == 0)
            return 0;
479

480
    return -1;
481 482 483 484 485
}

static int
xenUnifiedDomainRestore (virConnectPtr conn, const char *from)
{
486
    int i;
487

488 489 490 491
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainRestore &&
            drivers[i]->domainRestore (conn, from) == 0)
            return 0;
492

493
    return -1;
494 495 496 497 498
}

static int
xenUnifiedDomainCoreDump (virDomainPtr dom, const char *to, int flags)
{
499
    int i;
500

501 502 503 504
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainCoreDump &&
            drivers[i]->domainCoreDump (dom, to, flags) == 0)
            return 0;
505

506
    return -1;
507 508 509 510 511
}

static int
xenUnifiedDomainSetVcpus (virDomainPtr dom, unsigned int nvcpus)
{
512
    int i;
513

514 515 516 517 518 519 520 521
    /* Try non-hypervisor methods first, then hypervisor direct method
     * as a last resort.
     */
    for (i = 0; i < nb_drivers; ++i)
        if (i != hypervisor_offset &&
            drivers[i]->domainSetVcpus &&
            drivers[i]->domainSetVcpus (dom, nvcpus) == 0)
            return 0;
522

523 524 525
    if (drivers[hypervisor_offset]->domainSetVcpus &&
        drivers[hypervisor_offset]->domainSetVcpus (dom, nvcpus) == 0)
        return 0;
526

527
    return -1;
528 529 530 531
}

static int
xenUnifiedDomainPinVcpu (virDomainPtr dom, unsigned int vcpu,
532
                         unsigned char *cpumap, int maplen)
533
{
534
    int i;
535

536 537 538 539
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainPinVcpu &&
            drivers[i]->domainPinVcpu (dom, vcpu, cpumap, maplen) == 0)
            return 0;
540

541
    return -1;
542 543 544 545
}

static int
xenUnifiedDomainGetVcpus (virDomainPtr dom,
546 547
                          virVcpuInfoPtr info, int maxinfo,
                          unsigned char *cpumaps, int maplen)
548
{
549
    int i;
550

551 552 553 554
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainGetVcpus &&
            drivers[i]->domainGetVcpus (dom, info, maxinfo, cpumaps, maplen) == 0)
            return 0;
555

556
    return -1;
557 558 559 560 561
}

static int
xenUnifiedDomainGetMaxVcpus (virDomainPtr dom)
{
562
    int i, ret;
563

564 565 566 567 568
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainGetMaxVcpus) {
            ret = drivers[i]->domainGetMaxVcpus (dom);
            if (ret != 0) return ret;
        }
569

570
    return -1;
571 572 573 574 575
}

static char *
xenUnifiedDomainDumpXML (virDomainPtr dom, int flags)
{
576 577
    int i;
    char *ret;
578

579 580 581 582 583
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainDumpXML) {
            ret = drivers[i]->domainDumpXML (dom, flags);
            if (ret) return ret;
        }
584

585
    return NULL;
586 587 588 589
}

static int
xenUnifiedListDefinedDomains (virConnectPtr conn, char **const names,
590
                              int maxnames)
591
{
592 593
    int i;
    int ret;
594

595 596 597 598 599
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->listDefinedDomains) {
            ret = drivers[i]->listDefinedDomains (conn, names, maxnames);
            if (ret >= 0) return ret;
        }
600

601
    return -1;
602 603 604 605 606
}

static int
xenUnifiedNumOfDefinedDomains (virConnectPtr conn)
{
607 608
    int i;
    int ret;
609

610 611 612 613 614
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->numOfDefinedDomains) {
            ret = drivers[i]->numOfDefinedDomains (conn);
            if (ret >= 0) return ret;
        }
615

616
    return -1;
617 618 619 620 621
}

static int
xenUnifiedDomainCreate (virDomainPtr dom)
{
622
    int i;
623

624 625 626 627
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainCreate &&
            drivers[i]->domainCreate (dom) == 0)
            return 0;
628

629
    return -1;
630 631 632 633 634
}

static virDomainPtr
xenUnifiedDomainDefineXML (virConnectPtr conn, const char *xml)
{
635 636
    int i;
    virDomainPtr ret;
637

638 639 640 641 642
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainDefineXML) {
            ret = drivers[i]->domainDefineXML (conn, xml);
            if (ret) return ret;
        }
643

644
    return NULL;
645 646 647 648 649
}

static int
xenUnifiedDomainUndefine (virDomainPtr dom)
{
650
    int i;
651

652 653 654 655
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainUndefine &&
            drivers[i]->domainUndefine (dom) == 0)
            return 0;
656

657
    return -1;
658 659 660 661 662
}

static int
xenUnifiedDomainAttachDevice (virDomainPtr dom, char *xml)
{
663
    int i;
664

665 666 667 668
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainAttachDevice &&
            drivers[i]->domainAttachDevice (dom, xml) == 0)
            return 0;
669

670
    return -1;
671 672 673 674 675
}

static int
xenUnifiedDomainDetachDevice (virDomainPtr dom, char *xml)
{
676
    int i;
677

678 679 680 681
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainDetachDevice &&
            drivers[i]->domainDetachDevice (dom, xml) == 0)
            return 0;
682

683
    return -1;
684 685 686 687 688
}

static int
xenUnifiedDomainGetAutostart (virDomainPtr dom, int *autostart)
{
689
    int i;
690

691 692 693 694
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainGetAutostart &&
            drivers[i]->domainGetAutostart (dom, autostart) == 0)
            return 0;
695

696
    return -1;
697 698 699 700 701
}

static int
xenUnifiedDomainSetAutostart (virDomainPtr dom, int autostart)
{
702
    int i;
703

704 705 706 707
    for (i = 0; i < nb_drivers; ++i)
        if (drivers[i]->domainSetAutostart &&
            drivers[i]->domainSetAutostart (dom, autostart) == 0)
            return 0;
708

709
    return -1;
710 711 712 713
}

/*----- Register with libvirt.c, and initialise Xen drivers. -----*/

714 715 716
#define VERSION ((DOM0_INTERFACE_VERSION >> 24) * 1000000 +         \
                 ((DOM0_INTERFACE_VERSION >> 16) & 0xFF) * 1000 +	\
                 (DOM0_INTERFACE_VERSION & 0xFFFF))
717 718 719

/* The interface which we export upwards to libvirt.c. */
static virDriver xenUnifiedDriver = {
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
    .no = VIR_DRV_XEN_UNIFIED,
    .name = "xen",
    .ver = VERSION,
    .open 			= xenUnifiedOpen,
    .close 			= xenUnifiedClose,
    .type 			= xenUnifiedType,
    .version 			= xenUnifiedVersion,
    .getMaxVcpus 			= xenUnifiedGetMaxVcpus,
    .nodeGetInfo 			= xenUnifiedNodeGetInfo,
    .getCapabilities 		= xenUnifiedGetCapabilities,
    .listDomains 			= xenUnifiedListDomains,
    .numOfDomains 		= xenUnifiedNumOfDomains,
    .domainCreateLinux 		= xenUnifiedDomainCreateLinux,
    .domainLookupByID 		= xenUnifiedDomainLookupByID,
    .domainLookupByUUID 		= xenUnifiedDomainLookupByUUID,
    .domainLookupByName 		= xenUnifiedDomainLookupByName,
    .domainSuspend 		= xenUnifiedDomainSuspend,
    .domainResume 		= xenUnifiedDomainResume,
    .domainShutdown 		= xenUnifiedDomainShutdown,
    .domainReboot 		= xenUnifiedDomainReboot,
    .domainDestroy 		= xenUnifiedDomainDestroy,
    .domainGetOSType 		= xenUnifiedDomainGetOSType,
    .domainGetMaxMemory 		= xenUnifiedDomainGetMaxMemory,
    .domainSetMaxMemory 		= xenUnifiedDomainSetMaxMemory,
    .domainSetMemory 		= xenUnifiedDomainSetMemory,
    .domainGetInfo 		= xenUnifiedDomainGetInfo,
    .domainSave 			= xenUnifiedDomainSave,
    .domainRestore 		= xenUnifiedDomainRestore,
    .domainCoreDump 		= xenUnifiedDomainCoreDump,
    .domainSetVcpus 		= xenUnifiedDomainSetVcpus,
    .domainPinVcpu 		= xenUnifiedDomainPinVcpu,
    .domainGetVcpus 		= xenUnifiedDomainGetVcpus,
    .domainGetMaxVcpus 		= xenUnifiedDomainGetMaxVcpus,
    .domainDumpXML 		= xenUnifiedDomainDumpXML,
    .listDefinedDomains 		= xenUnifiedListDefinedDomains,
    .numOfDefinedDomains 		= xenUnifiedNumOfDefinedDomains,
    .domainCreate 		= xenUnifiedDomainCreate,
    .domainDefineXML 		= xenUnifiedDomainDefineXML,
    .domainUndefine 		= xenUnifiedDomainUndefine,
    .domainAttachDevice 		= xenUnifiedDomainAttachDevice,
    .domainDetachDevice 		= xenUnifiedDomainDetachDevice,
    .domainGetAutostart 		= xenUnifiedDomainGetAutostart,
    .domainSetAutostart 		= xenUnifiedDomainSetAutostart,
763 764
};

765 766 767 768 769 770 771
/**
 * xenUnifiedRegister:
 *
 * Register xen related drivers
 *
 * Returns the driver priority or -1 in case of error.
 */
772 773 774
int
xenUnifiedRegister (void)
{
775 776 777 778 779 780
    /* Ignore failures here. */
    (void) xenHypervisorInit ();
    (void) xenProxyInit ();
    (void) xenDaemonInit ();
    (void) xenStoreInit ();
    (void) xenXMInit ();
781

782
    return virRegisterDriver (&xenUnifiedDriver);
783 784 785
}

#endif /* WITH_XEN */
786 787 788 789 790 791 792 793 794 795 796 797 798 799

/*
 * vim: set tabstop=4:
 * vim: set shiftwidth=4:
 * vim: set expandtab:
 */
/*
 * Local variables:
 *  indent-tabs-mode: nil
 *  c-indent-level: 4
 *  c-basic-offset: 4
 *  tab-width: 4
 * End:
 */