capabilities.c 24.2 KB
Newer Older
1 2 3
/*
 * capabilities.c: hypervisor capabilities
 *
E
Eric Blake 已提交
4
 * Copyright (C) 2006-2008, 2010 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 * Copyright (C) 2006-2008 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

24 25
#include <config.h>

26 27
#include "capabilities.h"
#include "buf.h"
28
#include "memory.h"
29
#include "util.h"
30
#include "uuid.h"
31
#include "cpu_conf.h"
32 33 34 35 36 37

/**
 * virCapabilitiesNew:
 * @arch: host machine architecture
 * @offlineMigrate: non-zero if offline migration is available
 * @liveMigrate: non-zero if live migration is available
38
 *
39 40 41 42 43 44 45 46 47
 * Allocate a new capabilities object
 */
virCapsPtr
virCapabilitiesNew(const char *arch,
                   int offlineMigrate,
                   int liveMigrate)
{
    virCapsPtr caps;

48
    if (VIR_ALLOC(caps) < 0)
49
        return NULL;
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

    if ((caps->host.arch = strdup(arch)) == NULL)
        goto no_memory;
    caps->host.offlineMigrate = offlineMigrate;
    caps->host.liveMigrate = liveMigrate;

    return caps;

 no_memory:
    virCapabilitiesFree(caps);
    return NULL;
}

static void
virCapabilitiesFreeHostNUMACell(virCapsHostNUMACellPtr cell)
{
66 67 68
    if (cell == NULL)
        return;

69 70
    VIR_FREE(cell->cpus);
    VIR_FREE(cell);
71 72
}

73 74 75 76 77 78 79 80 81 82
static void
virCapabilitiesFreeGuestMachine(virCapsGuestMachinePtr machine)
{
    if (machine == NULL)
        return;
    VIR_FREE(machine->name);
    VIR_FREE(machine->canonical);
    VIR_FREE(machine);
}

83 84 85 86
static void
virCapabilitiesFreeGuestDomain(virCapsGuestDomainPtr dom)
{
    int i;
87 88 89
    if (dom == NULL)
        return;

90 91
    VIR_FREE(dom->info.emulator);
    VIR_FREE(dom->info.loader);
92
    for (i = 0 ; i < dom->info.nmachines ; i++)
93
        virCapabilitiesFreeGuestMachine(dom->info.machines[i]);
94 95
    VIR_FREE(dom->info.machines);
    VIR_FREE(dom->type);
96

97
    VIR_FREE(dom);
98 99 100 101 102
}

static void
virCapabilitiesFreeGuestFeature(virCapsGuestFeaturePtr feature)
{
103 104
    if (feature == NULL)
        return;
105 106
    VIR_FREE(feature->name);
    VIR_FREE(feature);
107 108 109 110 111 112
}

static void
virCapabilitiesFreeGuest(virCapsGuestPtr guest)
{
    int i;
113 114 115
    if (guest == NULL)
        return;

116
    VIR_FREE(guest->ostype);
117

118 119 120
    VIR_FREE(guest->arch.name);
    VIR_FREE(guest->arch.defaultInfo.emulator);
    VIR_FREE(guest->arch.defaultInfo.loader);
121
    for (i = 0 ; i < guest->arch.defaultInfo.nmachines ; i++)
122
        virCapabilitiesFreeGuestMachine(guest->arch.defaultInfo.machines[i]);
123
    VIR_FREE(guest->arch.defaultInfo.machines);
124 125 126

    for (i = 0 ; i < guest->arch.ndomains ; i++)
        virCapabilitiesFreeGuestDomain(guest->arch.domains[i]);
127
    VIR_FREE(guest->arch.domains);
128 129 130

    for (i = 0 ; i < guest->nfeatures ; i++)
        virCapabilitiesFreeGuestFeature(guest->features[i]);
131
    VIR_FREE(guest->features);
132

133
    VIR_FREE(guest);
134 135
}

136 137 138 139 140 141 142 143
void
virCapabilitiesFreeNUMAInfo(virCapsPtr caps)
{
    int i;

    for (i = 0 ; i < caps->host.nnumaCell ; i++)
        virCapabilitiesFreeHostNUMACell(caps->host.numaCell[i]);
    VIR_FREE(caps->host.numaCell);
144
    caps->host.nnumaCell = 0;
145
}
146 147 148 149 150 151 152 153 154 155

/**
 * virCapabilitiesFree:
 * @caps: object to free
 *
 * Free all memory associated with capabilities
 */
void
virCapabilitiesFree(virCapsPtr caps) {
    int i;
156 157
    if (caps == NULL)
        return;
158 159 160

    for (i = 0 ; i < caps->nguests ; i++)
        virCapabilitiesFreeGuest(caps->guests[i]);
161
    VIR_FREE(caps->guests);
162 163

    for (i = 0 ; i < caps->host.nfeatures ; i++)
164 165
        VIR_FREE(caps->host.features[i]);
    VIR_FREE(caps->host.features);
166 167

    virCapabilitiesFreeNUMAInfo(caps);
168

169
    for (i = 0 ; i < caps->host.nmigrateTrans ; i++)
170 171
        VIR_FREE(caps->host.migrateTrans[i]);
    VIR_FREE(caps->host.migrateTrans);
172

173
    VIR_FREE(caps->host.arch);
174 175
    VIR_FREE(caps->host.secModel.model);
    VIR_FREE(caps->host.secModel.doi);
176 177
    virCPUDefFree(caps->host.cpu);

178
    VIR_FREE(caps);
179 180 181 182 183 184 185 186 187 188 189 190 191 192
}


/**
 * virCapabilitiesAddHostFeature:
 * @caps: capabilities to extend
 * @name: name of new feature
 *
 * Registers a new host CPU feature, eg 'pae', or 'vmx'
 */
int
virCapabilitiesAddHostFeature(virCapsPtr caps,
                              const char *name)
{
E
Eric Blake 已提交
193 194
    if (VIR_RESIZE_N(caps->host.features, caps->host.nfeatures_max,
                     caps->host.nfeatures, 1) < 0)
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
        return -1;

    if ((caps->host.features[caps->host.nfeatures] = strdup(name)) == NULL)
        return -1;
    caps->host.nfeatures++;

    return 0;
}


/**
 * virCapabilitiesAddHostMigrateTransport:
 * @caps: capabilities to extend
 * @name: name of migration transport
 *
 * Registers a new domain migration transport URI
 */
int
virCapabilitiesAddHostMigrateTransport(virCapsPtr caps,
                                       const char *name)
{
E
Eric Blake 已提交
216 217
    if (VIR_RESIZE_N(caps->host.migrateTrans, caps->host.nmigrateTrans_max,
                     caps->host.nmigrateTrans, 1) < 0)
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
        return -1;

    if ((caps->host.migrateTrans[caps->host.nmigrateTrans] = strdup(name)) == NULL)
        return -1;
    caps->host.nmigrateTrans++;

    return 0;
}


/**
 * virCapabilitiesAddHostNUMACell:
 * @caps: capabilities to extend
 * @num: ID number of NUMA cell
 * @ncpus: number of CPUs in cell
 * @cpus: array of CPU ID numbers for cell
 *
 * Registers a new NUMA cell for a host, passing in a
 * array of CPU IDs belonging to the cell
 */
int
virCapabilitiesAddHostNUMACell(virCapsPtr caps,
                               int num,
                               int ncpus,
                               const int *cpus)
{
244
    virCapsHostNUMACellPtr cell;
245

E
Eric Blake 已提交
246 247
    if (VIR_RESIZE_N(caps->host.numaCell, caps->host.nnumaCell_max,
                     caps->host.nnumaCell, 1) < 0)
248 249
        return -1;

250
    if (VIR_ALLOC(cell) < 0)
251 252
        return -1;

253 254
    if (VIR_ALLOC_N(cell->cpus, ncpus) < 0) {
        VIR_FREE(cell);
255
        return -1;
256 257
    }
    memcpy(cell->cpus,
258 259 260
           cpus,
           ncpus * sizeof(*cpus));

261 262 263
    cell->ncpus = ncpus;
    cell->num = num;

E
Eric Blake 已提交
264
    caps->host.numaCell[caps->host.nnumaCell++] = cell;
265 266 267 268

    return 0;
}

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289

/**
 * virCapabilitiesSetHostCPU:
 * @caps: capabilities to extend
 * @cpu: CPU definition
 *
 * Sets host CPU specification
 */
int
virCapabilitiesSetHostCPU(virCapsPtr caps,
                          virCPUDefPtr cpu)
{
    if (cpu == NULL)
        return -1;

    caps->host.cpu = cpu;

    return 0;
}


290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
/**
 * virCapabilitiesAllocMachines:
 * @machines: machine variants for emulator ('pc', or 'isapc', etc)
 * @nmachines: number of machine variants for emulator
 *
 * Allocate a table of virCapsGuestMachinePtr from the supplied table
 * of machine names.
 */
virCapsGuestMachinePtr *
virCapabilitiesAllocMachines(const char *const *names, int nnames)
{
    virCapsGuestMachinePtr *machines;
    int i;

    if (VIR_ALLOC_N(machines, nnames) < 0)
        return NULL;

    for (i = 0; i < nnames; i++) {
        if (VIR_ALLOC(machines[i]) < 0 ||
            !(machines[i]->name = strdup(names[i]))) {
            virCapabilitiesFreeMachines(machines, nnames);
            return NULL;
        }
    }

    return machines;
}

/**
 * virCapabilitiesFreeMachines:
 * @machines: table of vircapsGuestMachinePtr
 *
 * Free a table of virCapsGuestMachinePtr
 */
void
virCapabilitiesFreeMachines(virCapsGuestMachinePtr *machines,
                            int nmachines)
{
    int i;
    if (!machines)
        return;
    for (i = 0; i < nmachines && machines[i]; i++) {
        virCapabilitiesFreeGuestMachine(machines[i]);
        machines[i] = NULL;
    }
    VIR_FREE(machines);
}
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360

/**
 * virCapabilitiesAddGuest:
 * @caps: capabilities to extend
 * @ostype: guest operating system type ('hvm' or 'xen')
 * @arch: guest CPU architecture ('i686', or 'x86_64', etc)
 * @wordsize: number of bits in CPU word
 * @emulator: path to default device emulator for arch/ostype
 * @loader: path to default BIOS loader for arch/ostype
 * @nmachines: number of machine variants for emulator
 * @machines: machine variants for emulator ('pc', or 'isapc', etc)
 *
 * Registers a new guest operating system. This should be
 * followed by registration of at least one domain for
 * running the guest
 */
virCapsGuestPtr
virCapabilitiesAddGuest(virCapsPtr caps,
                        const char *ostype,
                        const char *arch,
                        int wordsize,
                        const char *emulator,
                        const char *loader,
                        int nmachines,
361
                        virCapsGuestMachinePtr *machines)
362
{
363
    virCapsGuestPtr guest;
364

365
    if (VIR_ALLOC(guest) < 0)
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
        goto no_memory;

    if ((guest->ostype = strdup(ostype)) == NULL)
        goto no_memory;

    if ((guest->arch.name = strdup(arch)) == NULL)
        goto no_memory;
    guest->arch.wordsize = wordsize;

    if (emulator &&
        (guest->arch.defaultInfo.emulator = strdup(emulator)) == NULL)
        goto no_memory;
    if (loader &&
        (guest->arch.defaultInfo.loader = strdup(loader)) == NULL)
        goto no_memory;

E
Eric Blake 已提交
382 383
    if (VIR_RESIZE_N(caps->guests, caps->nguests_max,
                     caps->nguests, 1) < 0)
384
        goto no_memory;
E
Eric Blake 已提交
385
    caps->guests[caps->nguests++] = guest;
386

D
Daniel P. Berrange 已提交
387 388 389 390 391
    if (nmachines) {
        guest->arch.defaultInfo.nmachines = nmachines;
        guest->arch.defaultInfo.machines = machines;
    }

392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
    return guest;

 no_memory:
    virCapabilitiesFreeGuest(guest);
    return NULL;
}


/**
 * virCapabilitiesAddGuestDomain:
 * @guest: guest to support
 * @hvtype: hypervisor type ('xen', 'qemu', 'kvm')
 * @emulator: specialized device emulator for domain
 * @loader: specialized BIOS loader for domain
 * @nmachines: number of machine variants for emulator
 * @machines: specialized machine variants for emulator
 *
 * Registers a virtual domain capable of running a
 * guest operating system
 */
virCapsGuestDomainPtr
virCapabilitiesAddGuestDomain(virCapsGuestPtr guest,
                              const char *hvtype,
                              const char *emulator,
                              const char *loader,
                              int nmachines,
418
                              virCapsGuestMachinePtr *machines)
419
{
420
    virCapsGuestDomainPtr dom;
421

422
    if (VIR_ALLOC(dom) < 0)
423 424 425 426 427 428 429 430 431 432 433 434
        goto no_memory;

    if ((dom->type = strdup(hvtype)) == NULL)
        goto no_memory;

    if (emulator &&
        (dom->info.emulator = strdup(emulator)) == NULL)
        goto no_memory;
    if (loader &&
        (dom->info.loader = strdup(loader)) == NULL)
        goto no_memory;

E
Eric Blake 已提交
435 436
    if (VIR_RESIZE_N(guest->arch.domains, guest->arch.ndomains_max,
                     guest->arch.ndomains, 1) < 0)
437 438 439 440
        goto no_memory;
    guest->arch.domains[guest->arch.ndomains] = dom;
    guest->arch.ndomains++;

D
Daniel P. Berrange 已提交
441 442 443 444
    if (nmachines) {
        dom->info.nmachines = nmachines;
        dom->info.machines = machines;
    }
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468

    return dom;

 no_memory:
    virCapabilitiesFreeGuestDomain(dom);
    return NULL;
}


/**
 * virCapabilitiesAddGuestFeature:
 * @guest: guest to associate feature with
 * @name: name of feature ('pae', 'acpi', 'apic')
 * @defaultOn: non-zero if it defaults to on
 * @toggle: non-zero if its state can be toggled
 *
 * Registers a feature for a guest domain
 */
virCapsGuestFeaturePtr
virCapabilitiesAddGuestFeature(virCapsGuestPtr guest,
                               const char *name,
                               int defaultOn,
                               int toggle)
{
469
    virCapsGuestFeaturePtr feature;
470

471
    if (VIR_ALLOC(feature) < 0)
472 473 474 475 476 477 478
        goto no_memory;

    if ((feature->name = strdup(name)) == NULL)
        goto no_memory;
    feature->defaultOn = defaultOn;
    feature->toggle = toggle;

E
Eric Blake 已提交
479 480
    if (VIR_RESIZE_N(guest->features, guest->nfeatures_max,
                     guest->nfeatures, 1) < 0)
481
        goto no_memory;
E
Eric Blake 已提交
482
    guest->features[guest->nfeatures++] = feature;
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512

    return feature;

 no_memory:
    virCapabilitiesFreeGuestFeature(feature);
    return NULL;
}


/**
 * virCapabilitiesSupportsGuestOSType:
 * @caps: capabilities to query
 * @ostype: OS type to search for (eg 'hvm', 'xen')
 *
 * Returns non-zero if the capabilities support the
 * requested operating system type
 */
extern int
virCapabilitiesSupportsGuestOSType(virCapsPtr caps,
                                   const char *ostype)
{
    int i;
    for (i = 0 ; i < caps->nguests ; i++) {
        if (STREQ(caps->guests[i]->ostype, ostype))
            return 1;
    }
    return 0;
}


513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
/**
 * virCapabilitiesSupportsGuestOSType:
 * @caps: capabilities to query
 * @ostype: OS type to search for (eg 'hvm', 'xen')
 * @arch: Architecture to search for (eg, 'i686', 'x86_64')
 *
 * Returns non-zero if the capabilities support the
 * requested operating system type
 */
extern int
virCapabilitiesSupportsGuestArch(virCapsPtr caps,
                                 const char *ostype,
                                 const char *arch)
{
    int i;
    for (i = 0 ; i < caps->nguests ; i++) {
        if (STREQ(caps->guests[i]->ostype, ostype) &&
            STREQ(caps->guests[i]->arch.name, arch))
            return 1;
    }
    return 0;
}


537 538 539 540 541 542 543 544 545 546
/**
 * virCapabilitiesDefaultGuestArch:
 * @caps: capabilities to query
 * @ostype: OS type to search for
 *
 * Returns the first architecture able to run the
 * requested operating system type
 */
extern const char *
virCapabilitiesDefaultGuestArch(virCapsPtr caps,
547 548
                                const char *ostype,
                                const char *domain)
549
{
550 551
    int i, j;
    const char *arch = NULL;
552
    for (i = 0 ; i < caps->nguests ; i++) {
553 554 555 556 557 558 559 560 561 562 563 564
        if (STREQ(caps->guests[i]->ostype, ostype)) {
            for (j = 0 ; j < caps->guests[i]->arch.ndomains ; j++) {
                if (STREQ(caps->guests[i]->arch.domains[j]->type, domain)) {
                    /* Use the first match... */
                    if (!arch)
                        arch = caps->guests[i]->arch.name;
                    /* ...unless we can match the host's architecture. */
                    if (STREQ(caps->guests[i]->arch.name, caps->host.arch))
                        return caps->guests[i]->arch.name;
                }
            }
        }
565
    }
566
    return arch;
567 568 569 570 571 572 573
}

/**
 * virCapabilitiesDefaultGuestMachine:
 * @caps: capabilities to query
 * @ostype: OS type to search for
 * @arch: architecture to search for
574
 * @domain: domain type to search for
575 576
 *
 * Returns the first machine variant associated with
577 578
 * the requested operating system type, architecture
 * and domain type
579 580 581 582
 */
extern const char *
virCapabilitiesDefaultGuestMachine(virCapsPtr caps,
                                   const char *ostype,
583 584
                                   const char *arch,
                                   const char *domain)
585 586
{
    int i;
587

588
    for (i = 0 ; i < caps->nguests ; i++) {
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
        virCapsGuestPtr guest = caps->guests[i];
        int j;

        if (!STREQ(guest->ostype, ostype) || !STREQ(guest->arch.name, arch))
            continue;

        for (j = 0; j < guest->arch.ndomains; j++) {
            virCapsGuestDomainPtr dom= guest->arch.domains[j];

            if (!STREQ(dom->type, domain))
                continue;

            if (!dom->info.nmachines)
                break;

            return dom->info.machines[0]->name;
        }

        if (guest->arch.defaultInfo.nmachines)
608
            return caps->guests[i]->arch.defaultInfo.machines[0]->name;
609
    }
610

611 612 613 614
    return NULL;
}

/**
615
 * virCapabilitiesDefaultGuestEmulator:
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
 * @caps: capabilities to query
 * @ostype: OS type to search for ('xen', 'hvm')
 * @arch: architecture to search for
 * @domain: domain type ('xen', 'qemu', 'kvm')
 *
 * Returns the first emulator path associated with
 * the requested operating system type, architecture
 * and domain type
 */
extern const char *
virCapabilitiesDefaultGuestEmulator(virCapsPtr caps,
                                    const char *ostype,
                                    const char *arch,
                                    const char *domain)
{
    int i, j;
    for (i = 0 ; i < caps->nguests ; i++) {
        char *emulator;
        if (STREQ(caps->guests[i]->ostype, ostype) &&
            STREQ(caps->guests[i]->arch.name, arch)) {
            emulator = caps->guests[i]->arch.defaultInfo.emulator;
            for (j = 0 ; j < caps->guests[i]->arch.ndomains ; j++) {
                if (STREQ(caps->guests[i]->arch.domains[j]->type, domain)) {
                    if (caps->guests[i]->arch.domains[j]->info.emulator)
                        emulator = caps->guests[i]->arch.domains[j]->info.emulator;
                }
            }
            return emulator;
        }
    }
    return NULL;
}


/**
 * virCapabilitiesFormatXML:
 * @caps: capabilities to format
 *
 * Convert the capabilities object into an XML representation
 *
 * Returns the XML document as a string
 */
char *
virCapabilitiesFormatXML(virCapsPtr caps)
{
661
    virBuffer xml = VIR_BUFFER_INITIALIZER;
662
    int i, j, k;
663
    char host_uuid[VIR_UUID_STRING_BUFLEN];
664

665 666
    virBufferAddLit(&xml, "<capabilities>\n\n");
    virBufferAddLit(&xml, "  <host>\n");
667 668 669 670
    if (virUUIDIsValid(caps->host.host_uuid)) {
        virUUIDFormat(caps->host.host_uuid, host_uuid);
        virBufferVSprintf(&xml,"    <uuid>%s</uuid>\n", host_uuid);
    }
671 672 673
    virBufferAddLit(&xml, "    <cpu>\n");
    virBufferVSprintf(&xml, "      <arch>%s</arch>\n",
                      caps->host.arch);
674 675

    if (caps->host.nfeatures) {
676
        virBufferAddLit(&xml, "      <features>\n");
677
        for (i = 0 ; i < caps->host.nfeatures ; i++) {
678 679
            virBufferVSprintf(&xml, "        <%s/>\n",
                              caps->host.features[i]);
680
        }
681
        virBufferAddLit(&xml, "      </features>\n");
682
    }
683

684
    virCPUDefFormatBuf(&xml, caps->host.cpu, "    ",
685 686
                       VIR_CPU_FORMAT_EMBEDED);

687
    virBufferAddLit(&xml, "    </cpu>\n");
688 689

    if (caps->host.offlineMigrate) {
690 691 692
        virBufferAddLit(&xml, "    <migration_features>\n");
        if (caps->host.liveMigrate)
            virBufferAddLit(&xml, "      <live/>\n");
693
        if (caps->host.nmigrateTrans) {
694
            virBufferAddLit(&xml, "      <uri_transports>\n");
695
            for (i = 0 ; i < caps->host.nmigrateTrans ; i++) {
696 697
                virBufferVSprintf(&xml, "        <uri_transport>%s</uri_transport>\n",
                                      caps->host.migrateTrans[i]);
698
            }
699
            virBufferAddLit(&xml, "      </uri_transports>\n");
700
        }
701
        virBufferAddLit(&xml, "    </migration_features>\n");
702 703 704
    }

    if (caps->host.nnumaCell) {
705
        virBufferAddLit(&xml, "    <topology>\n");
E
Eric Blake 已提交
706
        virBufferVSprintf(&xml, "      <cells num='%zu'>\n",
707
                          caps->host.nnumaCell);
708
        for (i = 0 ; i < caps->host.nnumaCell ; i++) {
709 710 711 712
            virBufferVSprintf(&xml, "        <cell id='%d'>\n",
                              caps->host.numaCell[i]->num);
            virBufferVSprintf(&xml, "          <cpus num='%d'>\n",
                              caps->host.numaCell[i]->ncpus);
713
            for (j = 0 ; j < caps->host.numaCell[i]->ncpus ; j++)
714 715 716 717
                virBufferVSprintf(&xml, "            <cpu id='%d'/>\n",
                                  caps->host.numaCell[i]->cpus[j]);
            virBufferAddLit(&xml, "          </cpus>\n");
            virBufferAddLit(&xml, "        </cell>\n");
718
        }
719 720
        virBufferAddLit(&xml, "      </cells>\n");
        virBufferAddLit(&xml, "    </topology>\n");
721
    }
722 723 724 725 726 727 728 729

    if (caps->host.secModel.model) {
        virBufferAddLit(&xml, "    <secmodel>\n");
        virBufferVSprintf(&xml, "      <model>%s</model>\n", caps->host.secModel.model);
        virBufferVSprintf(&xml, "      <doi>%s</doi>\n", caps->host.secModel.doi);
        virBufferAddLit(&xml, "    </secmodel>\n");
    }

730
    virBufferAddLit(&xml, "  </host>\n\n");
731 732 733


    for (i = 0 ; i < caps->nguests ; i++) {
734 735 736 737 738 739 740 741
        virBufferAddLit(&xml, "  <guest>\n");
        virBufferVSprintf(&xml, "    <os_type>%s</os_type>\n",
                          caps->guests[i]->ostype);
        virBufferVSprintf(&xml, "    <arch name='%s'>\n",
                          caps->guests[i]->arch.name);
        virBufferVSprintf(&xml, "      <wordsize>%d</wordsize>\n",
                          caps->guests[i]->arch.wordsize);
        if (caps->guests[i]->arch.defaultInfo.emulator)
742
            virBufferVSprintf(&xml, "      <emulator>%s</emulator>\n",
743 744 745 746
                              caps->guests[i]->arch.defaultInfo.emulator);
            if (caps->guests[i]->arch.defaultInfo.loader)
                virBufferVSprintf(&xml, "      <loader>%s</loader>\n",
                                  caps->guests[i]->arch.defaultInfo.loader);
747 748

        for (j = 0 ; j < caps->guests[i]->arch.defaultInfo.nmachines ; j++) {
749 750 751 752 753
            virCapsGuestMachinePtr machine = caps->guests[i]->arch.defaultInfo.machines[j];
            virBufferAddLit(&xml, "      <machine");
            if (machine->canonical)
                virBufferVSprintf(&xml, " canonical='%s'", machine->canonical);
            virBufferVSprintf(&xml, ">%s</machine>\n", machine->name);
754 755 756
        }

        for (j = 0 ; j < caps->guests[i]->arch.ndomains ; j++) {
757 758 759
            virBufferVSprintf(&xml, "      <domain type='%s'>\n",
                                  caps->guests[i]->arch.domains[j]->type);
            if (caps->guests[i]->arch.domains[j]->info.emulator)
760
                virBufferVSprintf(&xml, "        <emulator>%s</emulator>\n",
761 762
                                  caps->guests[i]->arch.domains[j]->info.emulator);
            if (caps->guests[i]->arch.domains[j]->info.loader)
763
                virBufferVSprintf(&xml, "        <loader>%s</loader>\n",
764
                                  caps->guests[i]->arch.domains[j]->info.loader);
765 766

            for (k = 0 ; k < caps->guests[i]->arch.domains[j]->info.nmachines ; k++) {
767
                virCapsGuestMachinePtr machine = caps->guests[i]->arch.domains[j]->info.machines[k];
768
                virBufferAddLit(&xml, "        <machine");
769 770 771
                if (machine->canonical)
                    virBufferVSprintf(&xml, " canonical='%s'", machine->canonical);
                virBufferVSprintf(&xml, ">%s</machine>\n", machine->name);
772
            }
773
            virBufferAddLit(&xml, "      </domain>\n");
774 775
        }

776
        virBufferAddLit(&xml, "    </arch>\n");
777 778

        if (caps->guests[i]->nfeatures) {
779
            virBufferAddLit(&xml, "    <features>\n");
780 781 782 783

            for (j = 0 ; j < caps->guests[i]->nfeatures ; j++) {
                if (STREQ(caps->guests[i]->features[j]->name, "pae") ||
                    STREQ(caps->guests[i]->features[j]->name, "nonpae") ||
784 785
                    STREQ(caps->guests[i]->features[j]->name, "ia64_be") ||
                    STREQ(caps->guests[i]->features[j]->name, "cpuselection")) {
786 787
                    virBufferVSprintf(&xml, "      <%s/>\n",
                                      caps->guests[i]->features[j]->name);
788
                } else {
789 790 791 792
                    virBufferVSprintf(&xml, "      <%s default='%s' toggle='%s'/>\n",
                                      caps->guests[i]->features[j]->name,
                                      caps->guests[i]->features[j]->defaultOn ? "on" : "off",
                                      caps->guests[i]->features[j]->toggle ? "yes" : "no");
793 794 795
                }
            }

796
            virBufferAddLit(&xml, "    </features>\n");
797 798
        }

799
        virBufferAddLit(&xml, "  </guest>\n\n");
800 801
    }

802
    virBufferAddLit(&xml, "</capabilities>\n");
803

804 805
    if (virBufferError(&xml)) {
        virBufferFreeAndReset(&xml);
806
        return NULL;
807
    }
808

809
    return virBufferContentAndReset(&xml);
810
}
811 812 813 814 815 816 817 818 819 820 821 822 823 824

extern void
virCapabilitiesSetMacPrefix(virCapsPtr caps,
                            unsigned char *prefix)
{
    memcpy(caps->macPrefix, prefix, sizeof(caps->macPrefix));
}

extern void
virCapabilitiesGenerateMac(virCapsPtr caps,
                           unsigned char *mac)
{
    virGenerateMacAddr(caps->macPrefix, mac);
}
825 826 827 828 829 830 831 832 833 834

extern void
virCapabilitiesSetEmulatorRequired(virCapsPtr caps) {
    caps->emulatorRequired = 1;
}

extern unsigned int
virCapabilitiesIsEmulatorRequired(virCapsPtr caps) {
    return caps->emulatorRequired;
}