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

#include <config.h>

#include <sys/types.h>
A
Atsushi SAKAI 已提交
27
#include <sys/stat.h>
28 29 30
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
C
Chris Lalancette 已提交
31
#include <sys/time.h>
32

33
#include "virterror_internal.h"
34
#include "datatypes.h"
35 36 37 38 39 40 41 42
#include "domain_conf.h"
#include "memory.h"
#include "verify.h"
#include "xml.h"
#include "uuid.h"
#include "util.h"
#include "buf.h"
#include "c-ctype.h"
43
#include "logging.h"
44
#include "network.h"
45
#include "macvtap.h"
46
#include "nwfilter_conf.h"
C
Chris Lalancette 已提交
47
#include "ignore-value.h"
48

49 50
#define VIR_FROM_THIS VIR_FROM_DOMAIN

51 52 53 54 55 56 57 58 59 60 61 62
VIR_ENUM_IMPL(virDomainVirt, VIR_DOMAIN_VIRT_LAST,
              "qemu",
              "kqemu",
              "kvm",
              "xen",
              "lxc",
              "uml",
              "openvz",
              "vserver",
              "ldom",
              "test",
              "vmware",
63
              "hyperv",
D
Daniel Veillard 已提交
64
              "vbox",
65 66
              "one",
              "phyp")
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84

VIR_ENUM_IMPL(virDomainBoot, VIR_DOMAIN_BOOT_LAST,
              "fd",
              "cdrom",
              "hd",
              "network")

VIR_ENUM_IMPL(virDomainFeature, VIR_DOMAIN_FEATURE_LAST,
              "acpi",
              "apic",
              "pae")

VIR_ENUM_IMPL(virDomainLifecycle, VIR_DOMAIN_LIFECYCLE_LAST,
              "destroy",
              "restart",
              "rename-restart",
              "preserve")

85 86 87 88 89 90
VIR_ENUM_IMPL(virDomainDevice, VIR_DOMAIN_DEVICE_LAST,
              "disk",
              "filesystem",
              "interface",
              "input",
              "sound",
91
              "video",
R
Richard Jones 已提交
92
              "hostdev",
93
              "watchdog",
94 95
              "controller",
              "graphics")
96

97 98
VIR_ENUM_IMPL(virDomainDeviceAddress, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_LAST,
              "none",
99
              "pci",
100 101
              "drive",
              "virtio-serial");
102

103 104
VIR_ENUM_IMPL(virDomainDisk, VIR_DOMAIN_DISK_TYPE_LAST,
              "block",
105 106
              "file",
              "dir")
107 108 109 110 111 112 113 114 115 116 117

VIR_ENUM_IMPL(virDomainDiskDevice, VIR_DOMAIN_DISK_DEVICE_LAST,
              "disk",
              "cdrom",
              "floppy")

VIR_ENUM_IMPL(virDomainDiskBus, VIR_DOMAIN_DISK_BUS_LAST,
              "ide",
              "fdc",
              "scsi",
              "virtio",
118
              "xen",
119
              "usb",
120 121
              "uml",
              "sata")
122

123 124 125 126
VIR_ENUM_IMPL(virDomainDiskCache, VIR_DOMAIN_DISK_CACHE_LAST,
              "default",
              "none",
              "writethrough",
127
              "writeback")
128

129 130 131
VIR_ENUM_IMPL(virDomainDiskErrorPolicy, VIR_DOMAIN_DISK_ERROR_POLICY_LAST,
              "default",
              "stop",
132 133
              "ignore",
              "enospace")
134

135 136 137 138
VIR_ENUM_IMPL(virDomainController, VIR_DOMAIN_CONTROLLER_TYPE_LAST,
              "ide",
              "fdc",
              "scsi",
139 140
              "sata",
              "virtio-serial")
141

142 143 144 145 146
VIR_ENUM_IMPL(virDomainControllerModel, VIR_DOMAIN_CONTROLLER_MODEL_LAST,
              "buslogic",
              "lsilogic",
              "lsisas1068")

147 148 149 150 151 152
VIR_ENUM_IMPL(virDomainFS, VIR_DOMAIN_FS_TYPE_LAST,
              "mount",
              "block",
              "file",
              "template")

153 154 155 156 157 158 159
VIR_ENUM_IMPL(virDomainNet, VIR_DOMAIN_NET_TYPE_LAST,
              "user",
              "ethernet",
              "server",
              "client",
              "mcast",
              "network",
D
Daniel Veillard 已提交
160
              "bridge",
161 162
              "internal",
              "direct")
163

164 165 166 167 168
VIR_ENUM_IMPL(virDomainChrTarget, VIR_DOMAIN_CHR_TARGET_TYPE_LAST,
              "null",
              "monitor",
              "parallel",
              "serial",
169
              "console",
170 171
              "guestfwd",
              "virtio")
172

173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
VIR_ENUM_IMPL(virDomainChr, VIR_DOMAIN_CHR_TYPE_LAST,
              "null",
              "vc",
              "pty",
              "dev",
              "file",
              "pipe",
              "stdio",
              "udp",
              "tcp",
              "unix")

VIR_ENUM_IMPL(virDomainSoundModel, VIR_DOMAIN_SOUND_MODEL_LAST,
              "sb16",
              "es1370",
188 189
              "pcspk",
              "ac97")
190

R
Richard Jones 已提交
191 192 193 194 195 196 197 198 199 200 201
VIR_ENUM_IMPL(virDomainWatchdogModel, VIR_DOMAIN_WATCHDOG_MODEL_LAST,
              "i6300esb",
              "ib700")

VIR_ENUM_IMPL(virDomainWatchdogAction, VIR_DOMAIN_WATCHDOG_ACTION_LAST,
              "reset",
              "shutdown",
              "poweroff",
              "pause",
              "none")

202 203 204 205 206 207 208
VIR_ENUM_IMPL(virDomainVideo, VIR_DOMAIN_VIDEO_TYPE_LAST,
              "vga",
              "cirrus",
              "vmvga",
              "xen",
              "vbox")

209 210 211 212 213 214 215 216 217 218 219
VIR_ENUM_IMPL(virDomainInput, VIR_DOMAIN_INPUT_TYPE_LAST,
              "mouse",
              "tablet")

VIR_ENUM_IMPL(virDomainInputBus, VIR_DOMAIN_INPUT_BUS_LAST,
              "ps2",
              "usb",
              "xen")

VIR_ENUM_IMPL(virDomainGraphics, VIR_DOMAIN_GRAPHICS_TYPE_LAST,
              "sdl",
220 221 222
              "vnc",
              "rdp",
              "desktop")
223

224 225 226 227 228 229 230
VIR_ENUM_IMPL(virDomainHostdevMode, VIR_DOMAIN_HOSTDEV_MODE_LAST,
              "subsystem",
              "capabilities")

VIR_ENUM_IMPL(virDomainHostdevSubsys, VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_LAST,
              "usb",
              "pci")
231

232 233 234 235 236 237 238 239 240
VIR_ENUM_IMPL(virDomainState, VIR_DOMAIN_CRASHED+1,
              "nostate",
              "running",
              "blocked",
              "paused",
              "shutdown",
              "shutoff",
              "crashed")

241 242 243 244
VIR_ENUM_IMPL(virDomainSeclabel, VIR_DOMAIN_SECLABEL_LAST,
              "dynamic",
              "static")

245 246 247 248 249
VIR_ENUM_IMPL(virDomainNetdevMacvtap, VIR_DOMAIN_NETDEV_MACVTAP_MODE_LAST,
              "vepa",
              "private",
              "bridge")

250 251 252 253 254
VIR_ENUM_IMPL(virVirtualPort, VIR_VIRTUALPORT_TYPE_LAST,
              "none",
              "802.1Qbg",
              "802.1Qbh")

255 256
VIR_ENUM_IMPL(virDomainClockOffset, VIR_DOMAIN_CLOCK_OFFSET_LAST,
              "utc",
257
              "localtime",
258 259
              "variable",
              "timezone");
260

261 262 263 264 265 266 267
VIR_ENUM_IMPL(virDomainTimerName, VIR_DOMAIN_TIMER_NAME_LAST,
              "platform",
              "pit",
              "rtc",
              "hpet",
              "tsc");

268 269 270 271
VIR_ENUM_IMPL(virDomainTimerTrack, VIR_DOMAIN_TIMER_TRACK_LAST,
              "boot",
              "guest",
              "wall");
272 273 274 275 276 277 278 279 280 281 282

VIR_ENUM_IMPL(virDomainTimerTickpolicy, VIR_DOMAIN_TIMER_TICKPOLICY_LAST,
              "delay",
              "catchup",
              "merge",
              "discard");

VIR_ENUM_IMPL(virDomainTimerMode, VIR_DOMAIN_TIMER_MODE_LAST,
              "auto",
              "native",
              "emulate",
283 284
              "paravirt",
              "smpsafe");
285

286
#define virDomainReportError(code, ...)                              \
287
    virReportErrorHelper(NULL, VIR_FROM_DOMAIN, code, __FILE__,      \
288
                         __FUNCTION__, __LINE__, __VA_ARGS__)
289

D
Daniel P. Berrange 已提交
290 291
#ifndef PROXY

292
int virDomainObjListInit(virDomainObjListPtr doms)
293
{
294 295
    doms->objs = virHashCreate(50);
    if (!doms->objs) {
296
        virReportOOMError();
297
        return -1;
298
    }
299 300
    return 0;
}
301

302 303 304 305

static void virDomainObjListDeallocator(void *payload, const char *name ATTRIBUTE_UNUSED)
{
    virDomainObjPtr obj = payload;
306
    virDomainObjLock(obj);
307
    if (virDomainObjUnref(obj) > 0)
308
        virDomainObjUnlock(obj);
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
}

void virDomainObjListDeinit(virDomainObjListPtr doms)
{
    if (doms->objs)
        virHashFree(doms->objs, virDomainObjListDeallocator);
}


static int virDomainObjListSearchID(const void *payload,
                                    const char *name ATTRIBUTE_UNUSED,
                                    const void *data)
{
    virDomainObjPtr obj = (virDomainObjPtr)payload;
    const int *id = data;
    int want = 0;

    virDomainObjLock(obj);
D
Daniel P. Berrange 已提交
327
    if (virDomainObjIsActive(obj) &&
328 329 330 331 332 333 334 335 336 337 338 339 340 341
        obj->def->id == *id)
        want = 1;
    virDomainObjUnlock(obj);
    return want;
}

virDomainObjPtr virDomainFindByID(const virDomainObjListPtr doms,
                                  int id)
{
    virDomainObjPtr obj;
    obj = virHashSearch(doms->objs, virDomainObjListSearchID, &id);
    if (obj)
        virDomainObjLock(obj);
    return obj;
342 343 344
}


345
virDomainObjPtr virDomainFindByUUID(const virDomainObjListPtr doms,
346 347
                                    const unsigned char *uuid)
{
348 349
    char uuidstr[VIR_UUID_STRING_BUFLEN];
    virDomainObjPtr obj;
350

351
    virUUIDFormat(uuid, uuidstr);
352

353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
    obj = virHashLookup(doms->objs, uuidstr);
    if (obj)
        virDomainObjLock(obj);
    return obj;
}

static int virDomainObjListSearchName(const void *payload,
                                      const char *name ATTRIBUTE_UNUSED,
                                      const void *data)
{
    virDomainObjPtr obj = (virDomainObjPtr)payload;
    int want = 0;

    virDomainObjLock(obj);
    if (STREQ(obj->def->name, (const char *)data))
        want = 1;
    virDomainObjUnlock(obj);
    return want;
371 372
}

373
virDomainObjPtr virDomainFindByName(const virDomainObjListPtr doms,
374 375
                                    const char *name)
{
376 377 378 379 380
    virDomainObjPtr obj;
    obj = virHashSearch(doms->objs, virDomainObjListSearchName, name);
    if (obj)
        virDomainObjLock(obj);
    return obj;
381 382
}

D
Daniel P. Berrange 已提交
383 384
#endif /* !PROXY */

385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def)
{
    if (!def)
        return;

    switch (def->type) {
    case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
        VIR_FREE(def->data.vnc.listenAddr);
        VIR_FREE(def->data.vnc.keymap);
        VIR_FREE(def->data.vnc.passwd);
        break;

    case VIR_DOMAIN_GRAPHICS_TYPE_SDL:
        VIR_FREE(def->data.sdl.display);
        VIR_FREE(def->data.sdl.xauth);
        break;
401 402 403 404 405 406 407 408

    case VIR_DOMAIN_GRAPHICS_TYPE_RDP:
        VIR_FREE(def->data.rdp.listenAddr);
        break;

    case VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP:
        VIR_FREE(def->data.desktop.display);
        break;
409 410 411 412 413 414 415 416 417 418
    }

    VIR_FREE(def);
}

void virDomainInputDefFree(virDomainInputDefPtr def)
{
    if (!def)
        return;

419
    virDomainDeviceInfoClear(&def->info);
420 421 422 423 424 425 426 427
    VIR_FREE(def);
}

void virDomainDiskDefFree(virDomainDiskDefPtr def)
{
    if (!def)
        return;

428
    VIR_FREE(def->serial);
429 430 431 432
    VIR_FREE(def->src);
    VIR_FREE(def->dst);
    VIR_FREE(def->driverName);
    VIR_FREE(def->driverType);
433
    virStorageEncryptionFree(def->encryption);
434
    virDomainDeviceInfoClear(&def->info);
435 436 437 438

    VIR_FREE(def);
}

439 440 441 442 443 444 445 446 447 448
void virDomainControllerDefFree(virDomainControllerDefPtr def)
{
    if (!def)
        return;

    virDomainDeviceInfoClear(&def->info);

    VIR_FREE(def);
}

449 450 451 452 453 454 455
void virDomainFSDefFree(virDomainFSDefPtr def)
{
    if (!def)
        return;

    VIR_FREE(def->src);
    VIR_FREE(def->dst);
456
    virDomainDeviceInfoClear(&def->info);
457 458 459 460

    VIR_FREE(def);
}

461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
void virDomainNetDefFree(virDomainNetDefPtr def)
{
    if (!def)
        return;

    VIR_FREE(def->model);

    switch (def->type) {
    case VIR_DOMAIN_NET_TYPE_ETHERNET:
        VIR_FREE(def->data.ethernet.dev);
        VIR_FREE(def->data.ethernet.script);
        VIR_FREE(def->data.ethernet.ipaddr);
        break;

    case VIR_DOMAIN_NET_TYPE_SERVER:
    case VIR_DOMAIN_NET_TYPE_CLIENT:
    case VIR_DOMAIN_NET_TYPE_MCAST:
        VIR_FREE(def->data.socket.address);
        break;

    case VIR_DOMAIN_NET_TYPE_NETWORK:
        VIR_FREE(def->data.network.name);
        break;

    case VIR_DOMAIN_NET_TYPE_BRIDGE:
        VIR_FREE(def->data.bridge.brname);
487
        VIR_FREE(def->data.bridge.script);
488
        VIR_FREE(def->data.bridge.ipaddr);
489
        break;
D
Daniel Veillard 已提交
490 491 492 493

    case VIR_DOMAIN_NET_TYPE_INTERNAL:
        VIR_FREE(def->data.internal.name);
        break;
494 495 496 497

    case VIR_DOMAIN_NET_TYPE_DIRECT:
        VIR_FREE(def->data.direct.linkdev);
        break;
S
Stefan Berger 已提交
498 499 500 501

    case VIR_DOMAIN_NET_TYPE_USER:
    case VIR_DOMAIN_NET_TYPE_LAST:
        break;
502 503 504
    }

    VIR_FREE(def->ifname);
505 506 507

    virDomainDeviceInfoClear(&def->info);

508 509 510
    VIR_FREE(def->filter);
    virNWFilterHashTableFree(def->filterparams);

511 512 513 514 515 516 517 518
    VIR_FREE(def);
}

void virDomainChrDefFree(virDomainChrDefPtr def)
{
    if (!def)
        return;

519 520 521 522
    switch (def->targetType) {
    case VIR_DOMAIN_CHR_TARGET_TYPE_GUESTFWD:
        VIR_FREE(def->target.addr);
        break;
523 524 525 526

    case VIR_DOMAIN_CHR_TARGET_TYPE_VIRTIO:
        VIR_FREE(def->target.name);
        break;
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 552 553
    switch (def->type) {
    case VIR_DOMAIN_CHR_TYPE_PTY:
    case VIR_DOMAIN_CHR_TYPE_DEV:
    case VIR_DOMAIN_CHR_TYPE_FILE:
    case VIR_DOMAIN_CHR_TYPE_PIPE:
        VIR_FREE(def->data.file.path);
        break;

    case VIR_DOMAIN_CHR_TYPE_UDP:
        VIR_FREE(def->data.udp.bindHost);
        VIR_FREE(def->data.udp.bindService);
        VIR_FREE(def->data.udp.connectHost);
        VIR_FREE(def->data.udp.connectService);
        break;

    case VIR_DOMAIN_CHR_TYPE_TCP:
        VIR_FREE(def->data.tcp.host);
        VIR_FREE(def->data.tcp.service);
        break;

    case VIR_DOMAIN_CHR_TYPE_UNIX:
        VIR_FREE(def->data.nix.path);
        break;
    }

554 555
    virDomainDeviceInfoClear(&def->info);

556 557 558 559 560 561 562 563
    VIR_FREE(def);
}

void virDomainSoundDefFree(virDomainSoundDefPtr def)
{
    if (!def)
        return;

564 565
    virDomainDeviceInfoClear(&def->info);

566 567 568
    VIR_FREE(def);
}

R
Richard Jones 已提交
569 570 571 572 573
void virDomainWatchdogDefFree(virDomainWatchdogDefPtr def)
{
    if (!def)
        return;

574 575
    virDomainDeviceInfoClear(&def->info);

R
Richard Jones 已提交
576 577 578
    VIR_FREE(def);
}

579 580 581 582 583
void virDomainVideoDefFree(virDomainVideoDefPtr def)
{
    if (!def)
        return;

584 585
    virDomainDeviceInfoClear(&def->info);

586
    VIR_FREE(def->accel);
587 588 589
    VIR_FREE(def);
}

590 591 592 593 594 595
void virDomainHostdevDefFree(virDomainHostdevDefPtr def)
{
    if (!def)
        return;

    VIR_FREE(def->target);
596
    virDomainDeviceInfoClear(&def->info);
597 598 599
    VIR_FREE(def);
}

600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
void virDomainDeviceDefFree(virDomainDeviceDefPtr def)
{
    if (!def)
        return;

    switch (def->type) {
    case VIR_DOMAIN_DEVICE_DISK:
        virDomainDiskDefFree(def->data.disk);
        break;
    case VIR_DOMAIN_DEVICE_NET:
        virDomainNetDefFree(def->data.net);
        break;
    case VIR_DOMAIN_DEVICE_INPUT:
        virDomainInputDefFree(def->data.input);
        break;
    case VIR_DOMAIN_DEVICE_SOUND:
        virDomainSoundDefFree(def->data.sound);
        break;
618 619 620
    case VIR_DOMAIN_DEVICE_VIDEO:
        virDomainVideoDefFree(def->data.video);
        break;
621 622 623
    case VIR_DOMAIN_DEVICE_HOSTDEV:
        virDomainHostdevDefFree(def->data.hostdev);
        break;
R
Richard Jones 已提交
624 625 626
    case VIR_DOMAIN_DEVICE_WATCHDOG:
        virDomainWatchdogDefFree(def->data.watchdog);
        break;
627 628 629
    case VIR_DOMAIN_DEVICE_CONTROLLER:
        virDomainControllerDefFree(def->data.controller);
        break;
630 631 632
    case VIR_DOMAIN_DEVICE_GRAPHICS:
        virDomainGraphicsDefFree(def->data.graphics);
        break;
633 634 635 636 637
    }

    VIR_FREE(def);
}

638 639 640 641 642 643 644 645 646
void virSecurityLabelDefFree(virDomainDefPtr def);

void virSecurityLabelDefFree(virDomainDefPtr def)
{
    VIR_FREE(def->seclabel.model);
    VIR_FREE(def->seclabel.label);
    VIR_FREE(def->seclabel.imagelabel);
}

647 648 649 650 651 652 653 654 655 656 657 658
static void
virDomainClockDefClear(virDomainClockDefPtr def)
{
    if (def->offset == VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE)
        VIR_FREE(def->data.timezone);

    int i;
    for (i = 0; i < def->ntimers; i++)
        VIR_FREE(def->timers[i]);
    VIR_FREE(def->timers);
}

659 660
void virDomainDefFree(virDomainDefPtr def)
{
661 662
    unsigned int i;

663 664 665
    if (!def)
        return;

666 667 668
    for (i = 0 ; i < def->ngraphics ; i++)
        virDomainGraphicsDefFree(def->graphics[i]);
    VIR_FREE(def->graphics);
669 670 671 672 673 674 675 676 677

    for (i = 0 ; i < def->ninputs ; i++)
        virDomainInputDefFree(def->inputs[i]);
    VIR_FREE(def->inputs);

    for (i = 0 ; i < def->ndisks ; i++)
        virDomainDiskDefFree(def->disks[i]);
    VIR_FREE(def->disks);

678 679 680 681
    for (i = 0 ; i < def->ncontrollers ; i++)
        virDomainControllerDefFree(def->controllers[i]);
    VIR_FREE(def->controllers);

682 683 684 685 686 687 688
    for (i = 0 ; i < def->nfss ; i++)
        virDomainFSDefFree(def->fss[i]);
    VIR_FREE(def->fss);

    for (i = 0 ; i < def->nnets ; i++)
        virDomainNetDefFree(def->nets[i]);
    VIR_FREE(def->nets);
689

690 691 692 693 694 695 696 697
    for (i = 0 ; i < def->nserials ; i++)
        virDomainChrDefFree(def->serials[i]);
    VIR_FREE(def->serials);

    for (i = 0 ; i < def->nparallels ; i++)
        virDomainChrDefFree(def->parallels[i]);
    VIR_FREE(def->parallels);

698 699 700 701
    for (i = 0 ; i < def->nchannels ; i++)
        virDomainChrDefFree(def->channels[i]);
    VIR_FREE(def->channels);

702
    virDomainChrDefFree(def->console);
703 704 705 706 707

    for (i = 0 ; i < def->nsounds ; i++)
        virDomainSoundDefFree(def->sounds[i]);
    VIR_FREE(def->sounds);

708 709 710 711
    for (i = 0 ; i < def->nvideos ; i++)
        virDomainVideoDefFree(def->videos[i]);
    VIR_FREE(def->videos);

712 713 714
    for (i = 0 ; i < def->nhostdevs ; i++)
        virDomainHostdevDefFree(def->hostdevs[i]);
    VIR_FREE(def->hostdevs);
715 716 717 718

    VIR_FREE(def->os.type);
    VIR_FREE(def->os.arch);
    VIR_FREE(def->os.machine);
719
    VIR_FREE(def->os.init);
720 721 722 723 724 725 726 727
    VIR_FREE(def->os.kernel);
    VIR_FREE(def->os.initrd);
    VIR_FREE(def->os.cmdline);
    VIR_FREE(def->os.root);
    VIR_FREE(def->os.loader);
    VIR_FREE(def->os.bootloader);
    VIR_FREE(def->os.bootloaderArgs);

728
    virDomainClockDefClear(&def->clock);
729

730 731 732
    VIR_FREE(def->name);
    VIR_FREE(def->cpumask);
    VIR_FREE(def->emulator);
733
    VIR_FREE(def->description);
734

R
Richard Jones 已提交
735 736
    virDomainWatchdogDefFree(def->watchdog);

737 738
    virSecurityLabelDefFree(def);

739 740
    virCPUDefFree(def->cpu);

741 742 743
    VIR_FREE(def);
}

D
Daniel P. Berrange 已提交
744 745
#ifndef PROXY

746
static void virDomainSnapshotObjListDeinit(virDomainSnapshotObjListPtr snapshots);
747
static void virDomainObjFree(virDomainObjPtr dom)
748 749 750 751
{
    if (!dom)
        return;

752
    VIR_DEBUG("obj=%p", dom);
753 754 755
    virDomainDefFree(dom->def);
    virDomainDefFree(dom->newDef);

756 757 758
    if (dom->privateDataFreeFunc)
        (dom->privateDataFreeFunc)(dom->privateData);

759 760
    virMutexDestroy(&dom->lock);

C
Chris Lalancette 已提交
761 762
    virDomainSnapshotObjListDeinit(&dom->snapshots);

763 764 765
    VIR_FREE(dom);
}

766 767 768 769 770 771 772 773 774 775 776 777 778 779
void virDomainObjRef(virDomainObjPtr dom)
{
    dom->refs++;
    VIR_DEBUG("obj=%p refs=%d", dom, dom->refs);
}


int virDomainObjUnref(virDomainObjPtr dom)
{
    dom->refs--;
    VIR_DEBUG("obj=%p refs=%d", dom, dom->refs);
    if (dom->refs == 0) {
        virDomainObjUnlock(dom);
        virDomainObjFree(dom);
780
        return 0;
781
    }
782
    return dom->refs;
783 784
}

785
static virDomainObjPtr virDomainObjNew(virCapsPtr caps)
786 787 788 789
{
    virDomainObjPtr domain;

    if (VIR_ALLOC(domain) < 0) {
790
        virReportOOMError();
791 792 793
        return NULL;
    }

794 795
    if (caps->privateDataAllocFunc &&
        !(domain->privateData = (caps->privateDataAllocFunc)())) {
796
        virReportOOMError();
797 798 799 800 801
        VIR_FREE(domain);
        return NULL;
    }
    domain->privateDataFreeFunc = caps->privateDataFreeFunc;

802
    if (virMutexInit(&domain->lock) < 0) {
803
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
804
                             "%s", _("cannot initialize mutex"));
805 806
        if (domain->privateDataFreeFunc)
            (domain->privateDataFreeFunc)(domain->privateData);
807 808 809 810 811 812
        VIR_FREE(domain);
        return NULL;
    }

    virDomainObjLock(domain);
    domain->state = VIR_DOMAIN_SHUTOFF;
813
    domain->refs = 1;
814

C
Chris Lalancette 已提交
815 816
    virDomainSnapshotObjListInit(&domain->snapshots);

817
    VIR_DEBUG("obj=%p", domain);
818 819 820
    return domain;
}

821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
void virDomainObjAssignDef(virDomainObjPtr domain,
                           const virDomainDefPtr def,
                           bool live)
{
    if (!virDomainObjIsActive(domain)) {
        if (live) {
            /* save current configuration to be restored on domain shutdown */
            if (!domain->newDef)
                domain->newDef = domain->def;
            domain->def = def;
        } else {
            virDomainDefFree(domain->def);
            domain->def = def;
        }
    } else {
        virDomainDefFree(domain->newDef);
        domain->newDef = def;
    }
}

841
virDomainObjPtr virDomainAssignDef(virCapsPtr caps,
842
                                   virDomainObjListPtr doms,
843 844
                                   const virDomainDefPtr def,
                                   bool live)
845 846
{
    virDomainObjPtr domain;
847
    char uuidstr[VIR_UUID_STRING_BUFLEN];
848

849
    if ((domain = virDomainFindByUUID(doms, def->uuid))) {
850
        virDomainObjAssignDef(domain, def, live);
851 852 853
        return domain;
    }

854
    if (!(domain = virDomainObjNew(caps)))
855
        return NULL;
856
    domain->def = def;
857

858 859 860
    virUUIDFormat(def->uuid, uuidstr);
    if (virHashAddEntry(doms->objs, uuidstr, domain) < 0) {
        VIR_FREE(domain);
861
        virReportOOMError();
862 863
        return NULL;
    }
864 865 866 867

    return domain;
}

868 869 870 871 872
/*
 * The caller must hold a lock  on the driver owning 'doms',
 * and must also have locked 'dom', to ensure no one else
 * is either waiting for 'dom' or still usingn it
 */
873
void virDomainRemoveInactive(virDomainObjListPtr doms,
874 875
                             virDomainObjPtr dom)
{
876 877
    char uuidstr[VIR_UUID_STRING_BUFLEN];
    virUUIDFormat(dom->def->uuid, uuidstr);
878

879 880
    virDomainObjUnlock(dom);

881
    virHashRemoveEntry(doms->objs, uuidstr, virDomainObjListDeallocator);
882
}
D
Daniel P. Berrange 已提交
883

884

885 886 887 888 889 890 891 892 893
int virDomainDeviceAddressIsValid(virDomainDeviceInfoPtr info,
                                  int type)
{
    if (info->type != type)
        return 0;

    switch (info->type) {
    case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI:
        return virDomainDevicePCIAddressIsValid(&info->addr.pci);
894 895 896

    case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE:
        return virDomainDeviceDriveAddressIsValid(&info->addr.drive);
897 898 899 900 901 902 903 904 905 906 907 908
    }

    return 0;
}


int virDomainDevicePCIAddressIsValid(virDomainDevicePCIAddressPtr addr)
{
    return addr->domain || addr->bus || addr->slot;
}


909 910 911 912 913
int virDomainDeviceDriveAddressIsValid(virDomainDeviceDriveAddressPtr addr ATTRIBUTE_UNUSED)
{
    /*return addr->controller || addr->bus || addr->unit;*/
    return 1; /* 0 is valid for all fields, so any successfully parsed addr is valid */
}
914 915 916 917 918 919 920


int virDomainDeviceVirtioSerialAddressIsValid(
    virDomainDeviceVirtioSerialAddressPtr addr ATTRIBUTE_UNUSED)
{
    return 1; /* 0 is valid for all fields, so any successfully parsed addr is valid */
}
921
#endif /* !PROXY */
922 923


924 925 926 927
int virDomainDeviceInfoIsSet(virDomainDeviceInfoPtr info)
{
    if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
        return 1;
D
Daniel P. Berrange 已提交
928 929
    if (info->alias)
        return 1;
930 931 932 933 934 935
    return 0;
}


void virDomainDeviceInfoClear(virDomainDeviceInfoPtr info)
{
D
Daniel P. Berrange 已提交
936
    VIR_FREE(info->alias);
937 938 939 940 941
    memset(&info->addr, 0, sizeof(info->addr));
    info->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE;
}


942 943 944
static int virDomainDeviceInfoClearAlias(virDomainDefPtr def ATTRIBUTE_UNUSED,
                                         virDomainDeviceInfoPtr info,
                                         void *opaque ATTRIBUTE_UNUSED)
945
{
946 947 948 949 950 951 952 953 954
    VIR_FREE(info->alias);
    return 0;
}

static int virDomainDeviceInfoClearPCIAddress(virDomainDefPtr def ATTRIBUTE_UNUSED,
                                              virDomainDeviceInfoPtr info,
                                              void *opaque ATTRIBUTE_UNUSED)
{
    if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
955 956 957
        memset(&info->addr, 0, sizeof(info->addr));
        info->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE;
    }
958
    return 0;
959 960
}

961 962 963
int virDomainDeviceInfoIterate(virDomainDefPtr def,
                               virDomainDeviceInfoCallback cb,
                               void *opaque)
964 965 966 967
{
    int i;

    for (i = 0; i < def->ndisks ; i++)
968 969
        if (cb(def, &def->disks[i]->info, opaque) < 0)
            return -1;
970
    for (i = 0; i < def->nnets ; i++)
971 972
        if (cb(def, &def->nets[i]->info, opaque) < 0)
            return -1;
973
    for (i = 0; i < def->nsounds ; i++)
974 975
        if (cb(def, &def->sounds[i]->info, opaque) < 0)
            return -1;
976
    for (i = 0; i < def->nhostdevs ; i++)
977 978
        if (cb(def, &def->hostdevs[i]->info, opaque) < 0)
            return -1;
979
    for (i = 0; i < def->nvideos ; i++)
980 981
        if (cb(def, &def->videos[i]->info, opaque) < 0)
            return -1;
982
    for (i = 0; i < def->ncontrollers ; i++)
983 984
        if (cb(def, &def->controllers[i]->info, opaque) < 0)
            return -1;
985
    for (i = 0; i < def->nserials ; i++)
986 987
        if (cb(def, &def->serials[i]->info, opaque) < 0)
            return -1;
988
    for (i = 0; i < def->nparallels ; i++)
989 990
        if (cb(def, &def->parallels[i]->info, opaque) < 0)
            return -1;
991
    for (i = 0; i < def->nchannels ; i++)
992 993
        if (cb(def, &def->channels[i]->info, opaque) < 0)
            return -1;
994
    for (i = 0; i < def->ninputs ; i++)
995 996
        if (cb(def, &def->inputs[i]->info, opaque) < 0)
            return -1;
997
    for (i = 0; i < def->nfss ; i++)
998 999
        if (cb(def, &def->fss[i]->info, opaque) < 0)
            return -1;
1000
    if (def->watchdog)
1001 1002
        if (cb(def, &def->watchdog->info, opaque) < 0)
            return -1;
1003
    if (def->console)
1004 1005 1006
        if (cb(def, &def->console->info, opaque) < 0)
            return -1;
    return 0;
1007 1008 1009 1010 1011
}


void virDomainDefClearPCIAddresses(virDomainDefPtr def)
{
1012
    virDomainDeviceInfoIterate(def, virDomainDeviceInfoClearPCIAddress, NULL);
D
Daniel P. Berrange 已提交
1013 1014 1015 1016
}

void virDomainDefClearDeviceAliases(virDomainDefPtr def)
{
1017
    virDomainDeviceInfoIterate(def, virDomainDeviceInfoClearAlias, NULL);
1018 1019 1020
}


1021 1022 1023 1024
/* Generate a string representation of a device address
 * @param address Device address to stringify
 */
static int virDomainDeviceInfoFormat(virBufferPtr buf,
D
Daniel P. Berrange 已提交
1025 1026
                                     virDomainDeviceInfoPtr info,
                                     int flags)
1027 1028
{
    if (!info) {
1029
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1030 1031 1032 1033
                             _("missing device information"));
        return -1;
    }

D
Daniel P. Berrange 已提交
1034 1035 1036 1037 1038
    if (info->alias &&
        !(flags & VIR_DOMAIN_XML_INACTIVE)) {
        virBufferVSprintf(buf, "      <alias name='%s'/>\n", info->alias);
    }

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
    if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
        return 0;

    /* We'll be in domain/devices/[device type]/ so 3 level indent */
    virBufferVSprintf(buf, "      <address type='%s'",
                      virDomainDeviceAddressTypeToString(info->type));

    switch (info->type) {
    case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI:
        virBufferVSprintf(buf, " domain='0x%.4x' bus='0x%.2x' slot='0x%.2x' function='0x%.1x'",
                          info->addr.pci.domain,
                          info->addr.pci.bus,
                          info->addr.pci.slot,
                          info->addr.pci.function);
        break;

1055 1056 1057 1058 1059 1060 1061
    case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE:
        virBufferVSprintf(buf, " controller='%d' bus='%d' unit='%d'",
                          info->addr.drive.controller,
                          info->addr.drive.bus,
                          info->addr.drive.unit);
        break;

1062
    case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL:
1063
        virBufferVSprintf(buf, " controller='%d' bus='%d' port='%d'",
1064
                          info->addr.vioserial.controller,
1065 1066
                          info->addr.vioserial.bus,
                          info->addr.vioserial.port);
1067 1068
        break;

1069
    default:
1070
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
                             _("unknown address type '%d'"), info->type);
        return -1;
    }

    virBufferAddLit(buf, "/>\n");

    return 0;
}


1081 1082
#ifndef PROXY

1083

1084
static int
1085
virDomainDevicePCIAddressParseXML(xmlNodePtr node,
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
                                  virDomainDevicePCIAddressPtr addr)
{
    char *domain, *slot, *bus, *function;
    int ret = -1;

    memset(addr, 0, sizeof(*addr));

    domain   = virXMLPropString(node, "domain");
    bus      = virXMLPropString(node, "bus");
    slot     = virXMLPropString(node, "slot");
    function = virXMLPropString(node, "function");

    if (domain &&
1099
        virStrToLong_ui(domain, NULL, 0, &addr->domain) < 0) {
1100
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1101 1102 1103 1104 1105
                             _("Cannot parse <address> 'domain' attribute"));
        goto cleanup;
    }

    if (bus &&
1106
        virStrToLong_ui(bus, NULL, 0, &addr->bus) < 0) {
1107
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1108 1109 1110 1111 1112
                             _("Cannot parse <address> 'bus' attribute"));
        goto cleanup;
    }

    if (slot &&
1113
        virStrToLong_ui(slot, NULL, 0, &addr->slot) < 0) {
1114
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1115 1116 1117 1118 1119
                             _("Cannot parse <address> 'slot' attribute"));
        goto cleanup;
    }

    if (function &&
1120
        virStrToLong_ui(function, NULL, 0, &addr->function) < 0) {
1121
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1122 1123 1124 1125 1126
                             _("Cannot parse <address> 'function' attribute"));
        goto cleanup;
    }

    if (!virDomainDevicePCIAddressIsValid(addr)) {
1127
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
                             _("Insufficient specification for PCI address"));
        goto cleanup;
    }

    ret = 0;

cleanup:
    VIR_FREE(domain);
    VIR_FREE(bus);
    VIR_FREE(slot);
    VIR_FREE(function);
    return ret;
}


1143
static int
1144
virDomainDeviceDriveAddressParseXML(xmlNodePtr node,
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
                                    virDomainDeviceDriveAddressPtr addr)
{
    char *bus, *unit, *controller;
    int ret = -1;

    memset(addr, 0, sizeof(*addr));

    controller = virXMLPropString(node, "controller");
    bus = virXMLPropString(node, "bus");
    unit = virXMLPropString(node, "unit");

    if (controller &&
        virStrToLong_ui(controller, NULL, 10, &addr->controller) < 0) {
1158
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1159 1160 1161 1162 1163 1164
                             _("Cannot parse <address> 'controller' attribute"));
        goto cleanup;
    }

    if (bus &&
        virStrToLong_ui(bus, NULL, 10, &addr->bus) < 0) {
1165
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1166 1167 1168 1169 1170 1171
                             _("Cannot parse <address> 'bus' attribute"));
        goto cleanup;
    }

    if (unit &&
        virStrToLong_ui(unit, NULL, 10, &addr->unit) < 0) {
1172
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1173 1174 1175 1176 1177
                             _("Cannot parse <address> 'unit' attribute"));
        goto cleanup;
    }

    if (!virDomainDeviceDriveAddressIsValid(addr)) {
1178
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
                             _("Insufficient specification for drive address"));
        goto cleanup;
    }

    ret = 0;

cleanup:
    VIR_FREE(controller);
    VIR_FREE(bus);
    VIR_FREE(unit);
    return ret;
}

1192 1193 1194 1195 1196 1197 1198

static int
virDomainDeviceVirtioSerialAddressParseXML(
    xmlNodePtr node,
    virDomainDeviceVirtioSerialAddressPtr addr
)
{
1199
    char *controller, *bus, *port;
1200 1201 1202 1203 1204 1205
    int ret = -1;

    memset(addr, 0, sizeof(*addr));

    controller = virXMLPropString(node, "controller");
    bus = virXMLPropString(node, "bus");
1206
    port = virXMLPropString(node, "port");
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221

    if (controller &&
        virStrToLong_ui(controller, NULL, 10, &addr->controller) < 0) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                             _("Cannot parse <address> 'controller' attribute"));
        goto cleanup;
    }

    if (bus &&
        virStrToLong_ui(bus, NULL, 10, &addr->bus) < 0) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                             _("Cannot parse <address> 'bus' attribute"));
        goto cleanup;
    }

1222 1223 1224 1225 1226 1227 1228
    if (port &&
        virStrToLong_ui(port, NULL, 10, &addr->port) < 0) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                             _("Cannot parse <address> 'port' attribute"));
        goto cleanup;
    }

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
    if (!virDomainDeviceVirtioSerialAddressIsValid(addr)) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                             _("Insufficient specification for "
                               "virtio serial address"));
        goto cleanup;
    }

    ret = 0;

cleanup:
    VIR_FREE(controller);
    VIR_FREE(bus);
    return ret;
}

1244 1245 1246 1247
/* Parse the XML definition for a device address
 * @param node XML nodeset to parse for device address definition
 */
static int
1248
virDomainDeviceInfoParseXML(xmlNodePtr node,
1249
                            virDomainDeviceInfoPtr info,
D
Daniel P. Berrange 已提交
1250
                            int flags)
1251 1252 1253
{
    xmlNodePtr cur;
    xmlNodePtr address = NULL;
D
Daniel P. Berrange 已提交
1254
    xmlNodePtr alias = NULL;
1255 1256 1257 1258 1259 1260 1261 1262
    char *type = NULL;
    int ret = -1;

    virDomainDeviceInfoClear(info);

    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
D
Daniel P. Berrange 已提交
1263 1264 1265 1266 1267 1268
            if (alias == NULL &&
                !(flags & VIR_DOMAIN_XML_INACTIVE) &&
                xmlStrEqual(cur->name, BAD_CAST "alias")) {
                alias = cur;
            } else if (address == NULL &&
                       xmlStrEqual(cur->name, BAD_CAST "address")) {
1269 1270 1271 1272 1273 1274
                address = cur;
            }
        }
        cur = cur->next;
    }

D
Daniel P. Berrange 已提交
1275 1276 1277
    if (alias)
        info->alias = virXMLPropString(alias, "name");

1278 1279 1280 1281 1282 1283 1284
    if (!address)
        return 0;

    type = virXMLPropString(address, "type");

    if (type) {
        if ((info->type = virDomainDeviceAddressTypeFromString(type)) < 0) {
1285
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1286 1287 1288 1289
                                 _("unknown address type '%s'"), type);
            goto cleanup;
        }
    } else {
1290
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
J
Jim Meyering 已提交
1291
                             "%s", _("No type specified for device address"));
1292 1293 1294 1295 1296
        goto cleanup;
    }

    switch (info->type) {
    case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI:
1297
        if (virDomainDevicePCIAddressParseXML(address, &info->addr.pci) < 0)
1298 1299 1300
            goto cleanup;
        break;

1301
    case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE:
1302
        if (virDomainDeviceDriveAddressParseXML(address, &info->addr.drive) < 0)
1303 1304 1305
            goto cleanup;
        break;

1306 1307 1308 1309 1310 1311
    case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL:
        if (virDomainDeviceVirtioSerialAddressParseXML
                (address, &info->addr.vioserial) < 0)
            goto cleanup;
        break;

1312 1313
    default:
        /* Should not happen */
1314
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
J
Jim Meyering 已提交
1315
                             "%s", _("Unknown device address type"));
1316 1317 1318 1319 1320 1321
        goto cleanup;
    }

    ret = 0;

cleanup:
D
Daniel P. Berrange 已提交
1322 1323
    if (ret == -1)
        VIR_FREE(info->alias);
1324 1325 1326 1327
    VIR_FREE(type);
    return ret;
}

1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
static int
virDomainParseLegacyDeviceAddress(char *devaddr,
                                  virDomainDevicePCIAddressPtr pci)
{
    char *tmp;

    /* expected format: <domain>:<bus>:<slot> */
    if (/* domain */
        virStrToLong_ui(devaddr, &tmp, 16, &pci->domain) < 0 || *tmp != ':' ||
        /* bus */
        virStrToLong_ui(tmp + 1, &tmp, 16, &pci->bus) < 0 || *tmp != ':' ||
        /* slot */
        virStrToLong_ui(tmp + 1, NULL, 16, &pci->slot) < 0)
        return -1;

    return 0;
}
1345

1346
int
1347
virDomainDiskDefAssignAddress(virCapsPtr caps, virDomainDiskDefPtr def)
1348 1349
{
    int idx = virDiskNameToIndex(def->dst);
1350 1351
    if (idx < 0)
        return -1;
1352 1353 1354 1355

    switch (def->bus) {
    case VIR_DOMAIN_DISK_BUS_SCSI:
        def->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE;
1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378

        if (caps->hasWideScsiBus) {
            /* For a wide SCSI bus we define the default mapping to be
             * 16 units per bus, 1 bus per controller, many controllers.
             * Unit 7 is the SCSI controller itself. Therefore unit 7
             * cannot be assigned to disks and is skipped.
             */
            def->info.addr.drive.controller = idx / 15;
            def->info.addr.drive.bus = 0;
            def->info.addr.drive.unit = idx % 15;

            /* Skip the SCSI controller at unit 7 */
            if (def->info.addr.drive.unit >= 7) {
                ++def->info.addr.drive.unit;
            }
        } else {
            /* For a narrow SCSI bus we define the default mapping to be
             * 7 units per bus, 1 bus per controller, many controllers */
            def->info.addr.drive.controller = idx / 7;
            def->info.addr.drive.bus = 0;
            def->info.addr.drive.unit = idx % 7;
        }

1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
        break;

    case VIR_DOMAIN_DISK_BUS_IDE:
        /* For IDE we define the default mapping to be 2 units
         * per bus, 2 bus per controller, many controllers */
        def->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE;
        def->info.addr.drive.controller = idx / 4;
        def->info.addr.drive.bus = (idx % 4) / 2;
        def->info.addr.drive.unit = (idx % 2);
        break;

    case VIR_DOMAIN_DISK_BUS_FDC:
        /* For FDC we define the default mapping to be 2 units
         * per bus, 1 bus per controller, many controllers */
        def->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE;
        def->info.addr.drive.controller = idx / 2;
        def->info.addr.drive.bus = 0;
        def->info.addr.drive.unit = idx % 2;
        break;

    default:
        /* Other disk bus's aren't controller based */
        break;
    }
1403 1404

    return 0;
1405 1406
}

1407 1408 1409 1410
/* Parse the XML definition for a disk
 * @param node XML nodeset to parse for disk definition
 */
static virDomainDiskDefPtr
1411 1412
virDomainDiskDefParseXML(virCapsPtr caps,
                         xmlNodePtr node,
1413
                         int flags) {
1414 1415 1416 1417 1418 1419 1420 1421 1422
    virDomainDiskDefPtr def;
    xmlNodePtr cur;
    char *type = NULL;
    char *device = NULL;
    char *driverName = NULL;
    char *driverType = NULL;
    char *source = NULL;
    char *target = NULL;
    char *bus = NULL;
1423
    char *cachetag = NULL;
1424
    char *error_policy = NULL;
1425
    char *devaddr = NULL;
1426
    virStorageEncryptionPtr encryption = NULL;
1427
    char *serial = NULL;
1428 1429

    if (VIR_ALLOC(def) < 0) {
1430
        virReportOOMError();
1431 1432 1433 1434 1435 1436
        return NULL;
    }

    type = virXMLPropString(node, "type");
    if (type) {
        if ((def->type = virDomainDiskTypeFromString(type)) < 0) {
1437
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
                                 _("unknown disk type '%s'"), type);
            goto error;
        }
    } else {
        def->type = VIR_DOMAIN_DISK_TYPE_FILE;
    }

    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if ((source == NULL) &&
                (xmlStrEqual(cur->name, BAD_CAST "source"))) {

1451 1452
                switch (def->type) {
                case VIR_DOMAIN_DISK_TYPE_FILE:
1453
                    source = virXMLPropString(cur, "file");
1454 1455
                    break;
                case VIR_DOMAIN_DISK_TYPE_BLOCK:
1456
                    source = virXMLPropString(cur, "dev");
1457 1458 1459 1460 1461
                    break;
                case VIR_DOMAIN_DISK_TYPE_DIR:
                    source = virXMLPropString(cur, "dir");
                    break;
                default:
1462
                    virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1463 1464 1465 1466
                                         _("unexpected disk type %s"),
                                         virDomainDiskTypeToString(def->type));
                    goto error;
                }
1467 1468 1469 1470 1471 1472 1473 1474

                /* People sometimes pass a bogus '' source path
                   when they mean to omit the source element
                   completely. eg CDROM without media. This is
                   just a little compatability check to help
                   those broken apps */
                if (source && STREQ(source, ""))
                    VIR_FREE(source);
1475 1476 1477 1478
            } else if ((target == NULL) &&
                       (xmlStrEqual(cur->name, BAD_CAST "target"))) {
                target = virXMLPropString(cur, "dev");
                bus = virXMLPropString(cur, "bus");
1479 1480 1481 1482 1483 1484

                /* HACK: Work around for compat with Xen
                 * driver in previous libvirt releases */
                if (target &&
                    STRPREFIX(target, "ioemu:"))
                    memmove(target, target+6, strlen(target)-5);
1485 1486 1487 1488
            } else if ((driverName == NULL) &&
                       (xmlStrEqual(cur->name, BAD_CAST "driver"))) {
                driverName = virXMLPropString(cur, "name");
                driverType = virXMLPropString(cur, "type");
1489
                cachetag = virXMLPropString(cur, "cache");
1490
                error_policy = virXMLPropString(cur, "error_policy");
1491 1492 1493 1494
            } else if (xmlStrEqual(cur->name, BAD_CAST "readonly")) {
                def->readonly = 1;
            } else if (xmlStrEqual(cur->name, BAD_CAST "shareable")) {
                def->shared = 1;
1495 1496
            } else if ((flags & VIR_DOMAIN_XML_INTERNAL_STATUS) &&
                       xmlStrEqual(cur->name, BAD_CAST "state")) {
1497
                /* Legacy back-compat. Don't add any more attributes here */
1498
                devaddr = virXMLPropString(cur, "devaddr");
1499 1500
            } else if (encryption == NULL &&
                       xmlStrEqual(cur->name, BAD_CAST "encryption")) {
1501
                encryption = virStorageEncryptionParseNode(node->doc,
1502 1503 1504
                                                           cur);
                if (encryption == NULL)
                    goto error;
1505 1506 1507
            } else if ((serial == NULL) &&
                       (xmlStrEqual(cur->name, BAD_CAST "serial"))) {
                serial = (char *)xmlNodeGetContent(cur);
1508 1509 1510 1511 1512 1513 1514 1515
            }
        }
        cur = cur->next;
    }

    device = virXMLPropString(node, "device");
    if (device) {
        if ((def->device = virDomainDiskDeviceTypeFromString(device)) < 0) {
1516
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528
                                 _("unknown disk device '%s'"), device);
            goto error;
        }
    } else {
        def->device = VIR_DOMAIN_DISK_DEVICE_DISK;
    }

    /* Only CDROM and Floppy devices are allowed missing source path
     * to indicate no media present */
    if (source == NULL &&
        def->device != VIR_DOMAIN_DISK_DEVICE_CDROM &&
        def->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
1529
        virDomainReportError(VIR_ERR_NO_SOURCE,
1530 1531 1532 1533 1534
                             target ? "%s" : NULL, target);
        goto error;
    }

    if (target == NULL) {
1535
        virDomainReportError(VIR_ERR_NO_TARGET,
1536 1537 1538 1539 1540 1541
                             source ? "%s" : NULL, source);
        goto error;
    }

    if (def->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
        !STRPREFIX(target, "fd")) {
1542
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554
                             _("Invalid floppy device name: %s"), target);
        goto error;
    }

    /* Force CDROM to be listed as read only */
    if (def->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
        def->readonly = 1;

    if (def->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
        !STRPREFIX((const char *)target, "hd") &&
        !STRPREFIX((const char *)target, "sd") &&
        !STRPREFIX((const char *)target, "vd") &&
1555 1556
        !STRPREFIX((const char *)target, "xvd") &&
        !STRPREFIX((const char *)target, "ubd")) {
1557
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1558 1559 1560 1561 1562 1563
                             _("Invalid harddisk device name: %s"), target);
        goto error;
    }

    if (bus) {
        if ((def->bus = virDomainDiskBusTypeFromString(bus)) < 0) {
1564
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
                                 _("unknown disk bus type '%s'"), bus);
            goto error;
        }
    } else {
        if (def->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
            def->bus = VIR_DOMAIN_DISK_BUS_FDC;
        } else {
            if (STRPREFIX(target, "hd"))
                def->bus = VIR_DOMAIN_DISK_BUS_IDE;
            else if (STRPREFIX(target, "sd"))
                def->bus = VIR_DOMAIN_DISK_BUS_SCSI;
            else if (STRPREFIX(target, "vd"))
                def->bus = VIR_DOMAIN_DISK_BUS_VIRTIO;
            else if (STRPREFIX(target, "xvd"))
                def->bus = VIR_DOMAIN_DISK_BUS_XEN;
1580 1581
            else if (STRPREFIX(target, "ubd"))
                def->bus = VIR_DOMAIN_DISK_BUS_UML;
1582 1583 1584 1585 1586 1587 1588
            else
                def->bus = VIR_DOMAIN_DISK_BUS_IDE;
        }
    }

    if (def->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
        def->bus != VIR_DOMAIN_DISK_BUS_FDC) {
1589
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1590 1591 1592 1593 1594
                             _("Invalid bus type '%s' for floppy disk"), bus);
        goto error;
    }
    if (def->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
        def->bus == VIR_DOMAIN_DISK_BUS_FDC) {
1595
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1596 1597 1598 1599
                             _("Invalid bus type '%s' for disk"), bus);
        goto error;
    }

1600 1601
    if (cachetag &&
        (def->cachemode = virDomainDiskCacheTypeFromString(cachetag)) < 0) {
1602
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1603 1604 1605 1606
                             _("unknown disk cache mode '%s'"), cachetag);
        goto error;
    }

1607 1608 1609 1610 1611 1612 1613
    if (error_policy &&
        (def->error_policy = virDomainDiskErrorPolicyTypeFromString(error_policy)) < 0) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                             _("unknown disk error policy '%s'"), error_policy);
        goto error;
    }

1614
    if (devaddr) {
1615 1616
        if (virDomainParseLegacyDeviceAddress(devaddr,
                                              &def->info.addr.pci) < 0) {
1617
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1618 1619 1620 1621 1622 1623
                                 _("Unable to parse devaddr parameter '%s'"),
                                 devaddr);
            goto error;
        }
        def->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
    } else {
1624
        if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
1625
            goto error;
1626 1627
    }

1628 1629 1630 1631 1632 1633 1634 1635
    def->src = source;
    source = NULL;
    def->dst = target;
    target = NULL;
    def->driverName = driverName;
    driverName = NULL;
    def->driverType = driverType;
    driverType = NULL;
1636 1637
    def->encryption = encryption;
    encryption = NULL;
1638 1639
    def->serial = serial;
    serial = NULL;
1640

1641
    if (def->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE
1642
        && virDomainDiskDefAssignAddress(caps, def) < 0)
1643
        goto error;
1644

1645 1646 1647 1648 1649 1650 1651 1652
cleanup:
    VIR_FREE(bus);
    VIR_FREE(type);
    VIR_FREE(target);
    VIR_FREE(source);
    VIR_FREE(device);
    VIR_FREE(driverType);
    VIR_FREE(driverName);
1653
    VIR_FREE(cachetag);
1654
    VIR_FREE(error_policy);
1655
    VIR_FREE(devaddr);
1656
    VIR_FREE(serial);
1657
    virStorageEncryptionFree(encryption);
1658 1659 1660 1661 1662 1663 1664 1665 1666 1667

    return def;

 error:
    virDomainDiskDefFree(def);
    def = NULL;
    goto cleanup;
}


1668 1669 1670 1671
/* Parse the XML definition for a controller
 * @param node XML nodeset to parse for controller definition
 */
static virDomainControllerDefPtr
1672
virDomainControllerDefParseXML(xmlNodePtr node,
1673 1674 1675 1676 1677
                               int flags)
{
    virDomainControllerDefPtr def;
    char *type = NULL;
    char *idx = NULL;
1678
    char *model = NULL;
1679 1680

    if (VIR_ALLOC(def) < 0) {
1681
        virReportOOMError();
1682 1683 1684 1685 1686
        return NULL;
    }

    type = virXMLPropString(node, "type");
    if (type) {
1687
        if ((def->type = virDomainControllerTypeFromString(type)) < 0) {
1688
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1689
                                 _("Unknown controller type '%s'"), type);
1690 1691 1692 1693 1694 1695 1696
            goto error;
        }
    }

    idx = virXMLPropString(node, "index");
    if (idx) {
        if (virStrToLong_i(idx, NULL, 10, &def->idx) < 0) {
1697
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1698
                                 _("Cannot parse controller index %s"), idx);
1699 1700 1701 1702
            goto error;
        }
    }

1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
    model = virXMLPropString(node, "model");
    if (model) {
        if ((def->model = virDomainControllerModelTypeFromString(model)) < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("Unknown model type '%s'"), model);
            goto error;
        }
    } else {
        def->model = -1;
    }

1714
    if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
1715 1716
        goto error;

1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
    switch (def->type) {
    case VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL: {
        char *ports = virXMLPropString(node, "ports");
        if (ports) {
            int r = virStrToLong_i(ports, NULL, 10,
                                   &def->opts.vioserial.ports);
            if (r != 0 || def->opts.vioserial.ports < 0) {
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                     _("Invalid ports: %s"), ports);
                VIR_FREE(ports);
                goto error;
            }
        } else {
            def->opts.vioserial.ports = -1;
        }
        VIR_FREE(ports);

        char *vectors = virXMLPropString(node, "vectors");
        if (vectors) {
            int r = virStrToLong_i(vectors, NULL, 10,
                                   &def->opts.vioserial.vectors);
            if (r != 0 || def->opts.vioserial.vectors < 0) {
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                     _("Invalid vectors: %s"), vectors);
                VIR_FREE(vectors);
                goto error;
            }
        } else {
            def->opts.vioserial.vectors = -1;
        }
        VIR_FREE(vectors);
        break;
    }

    default:
        break;
    }

1755 1756
    if (def->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
        def->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
1757
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1758
                             _("Controllers must use the 'pci' address type"));
1759 1760 1761 1762 1763 1764
        goto error;
    }

cleanup:
    VIR_FREE(type);
    VIR_FREE(idx);
1765
    VIR_FREE(model);
1766 1767 1768 1769 1770 1771 1772 1773 1774

    return def;

 error:
    virDomainControllerDefFree(def);
    def = NULL;
    goto cleanup;
}

1775 1776 1777 1778
/* Parse the XML definition for a disk
 * @param node XML nodeset to parse for disk definition
 */
static virDomainFSDefPtr
1779
virDomainFSDefParseXML(xmlNodePtr node,
1780
                       int flags) {
1781 1782 1783 1784 1785 1786 1787
    virDomainFSDefPtr def;
    xmlNodePtr cur;
    char *type = NULL;
    char *source = NULL;
    char *target = NULL;

    if (VIR_ALLOC(def) < 0) {
1788
        virReportOOMError();
1789 1790 1791 1792 1793 1794
        return NULL;
    }

    type = virXMLPropString(node, "type");
    if (type) {
        if ((def->type = virDomainFSTypeFromString(type)) < 0) {
1795
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827
                                 _("unknown filesystem type '%s'"), type);
            goto error;
        }
    } else {
        def->type = VIR_DOMAIN_FS_TYPE_MOUNT;
    }

    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if ((source == NULL) &&
                (xmlStrEqual(cur->name, BAD_CAST "source"))) {

                if (def->type == VIR_DOMAIN_FS_TYPE_MOUNT)
                    source = virXMLPropString(cur, "dir");
                else if (def->type == VIR_DOMAIN_FS_TYPE_FILE)
                    source = virXMLPropString(cur, "file");
                else if (def->type == VIR_DOMAIN_FS_TYPE_BLOCK)
                    source = virXMLPropString(cur, "dev");
                else if (def->type == VIR_DOMAIN_FS_TYPE_TEMPLATE)
                    source = virXMLPropString(cur, "name");
            } else if ((target == NULL) &&
                       (xmlStrEqual(cur->name, BAD_CAST "target"))) {
                target = virXMLPropString(cur, "dir");
            } else if (xmlStrEqual(cur->name, BAD_CAST "readonly")) {
                def->readonly = 1;
            }
        }
        cur = cur->next;
    }

    if (source == NULL) {
1828
        virDomainReportError(VIR_ERR_NO_SOURCE,
1829 1830 1831 1832 1833
                             target ? "%s" : NULL, target);
        goto error;
    }

    if (target == NULL) {
1834
        virDomainReportError(VIR_ERR_NO_TARGET,
1835 1836 1837 1838 1839 1840 1841 1842 1843
                             source ? "%s" : NULL, source);
        goto error;
    }

    def->src = source;
    source = NULL;
    def->dst = target;
    target = NULL;

1844
    if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
1845 1846
        goto error;

1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860
cleanup:
    VIR_FREE(type);
    VIR_FREE(target);
    VIR_FREE(source);

    return def;

 error:
    virDomainFSDefFree(def);
    def = NULL;
    goto cleanup;
}


1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
static int
virVirtualPortProfileParamsParseXML(xmlNodePtr node,
                                    virVirtualPortProfileParamsPtr virtPort)
{
    int ret = -1;
    char *virtPortType;
    char *virtPortManagerID = NULL;
    char *virtPortTypeID = NULL;
    char *virtPortTypeIDVersion = NULL;
    char *virtPortInstanceID = NULL;
    char *virtPortProfileID = NULL;
    xmlNodePtr cur = node->children;
    const char *msg = NULL;

    virtPortType = virXMLPropString(node, "type");
    if (!virtPortType)
        return -1;

    while (cur != NULL) {
        if (xmlStrEqual(cur->name, BAD_CAST "parameters")) {

            virtPortManagerID = virXMLPropString(cur, "managerid");
            virtPortTypeID = virXMLPropString(cur, "typeid");
            virtPortTypeIDVersion = virXMLPropString(cur, "typeidversion");
            virtPortInstanceID = virXMLPropString(cur, "instanceid");
            virtPortProfileID = virXMLPropString(cur, "profileid");

            break;
        }

        cur = cur->next;
    }

    virtPort->virtPortType = VIR_VIRTUALPORT_NONE;

    switch (virVirtualPortTypeFromString(virtPortType)) {

    case VIR_VIRTUALPORT_8021QBG:
        if (virtPortManagerID     != NULL && virtPortTypeID     != NULL &&
            virtPortTypeIDVersion != NULL) {
            unsigned int val;

            if (virStrToLong_ui(virtPortManagerID, NULL, 0, &val)) {
                msg = _("cannot parse value of managerid parameter");
                goto err_exit;
            }

            if (val > 0xff) {
                msg = _("value of managerid out of range");
                goto err_exit;
            }

            virtPort->u.virtPort8021Qbg.managerID = (uint8_t)val;

            if (virStrToLong_ui(virtPortTypeID, NULL, 0, &val)) {
                msg = _("cannot parse value of typeid parameter");
                goto err_exit;
            }

            if (val > 0xffffff) {
                msg = _("value for typeid out of range");
                goto err_exit;
            }

            virtPort->u.virtPort8021Qbg.typeID = (uint32_t)val;

            if (virStrToLong_ui(virtPortTypeIDVersion, NULL, 0, &val)) {
                msg = _("cannot parse value of typeidversion parameter");
                goto err_exit;
            }

            if (val > 0xff) {
                msg = _("value of typeidversion out of range");
                goto err_exit;
            }

            virtPort->u.virtPort8021Qbg.typeIDVersion = (uint8_t)val;

            if (virtPortInstanceID != NULL) {
                if (virUUIDParse(virtPortInstanceID,
                                 virtPort->u.virtPort8021Qbg.instanceID)) {
                    msg = _("cannot parse instanceid parameter as a uuid");
                    goto err_exit;
                }
            } else {
                if (virUUIDGenerate(virtPort->u.virtPort8021Qbg.instanceID)) {
                    msg = _("cannot generate a random uuid for instanceid");
                    goto err_exit;
                }
            }

            virtPort->virtPortType = VIR_VIRTUALPORT_8021QBG;
            ret = 0;
        } else {
            msg = _("a parameter is missing for 802.1Qbg description");
            goto err_exit;
        }
    break;

    case VIR_VIRTUALPORT_8021QBH:
        if (virtPortProfileID != NULL) {
            if (virStrcpyStatic(virtPort->u.virtPort8021Qbh.profileID,
                                virtPortProfileID) != NULL) {
                virtPort->virtPortType = VIR_VIRTUALPORT_8021QBH;
                ret = 0;
            } else {
                msg = _("profileid parameter too long");
                goto err_exit;
            }
        } else {
            msg = _("profileid parameter is missing for 802.1Qbh descripion");
            goto err_exit;
        }
    break;


    default:
    case VIR_VIRTUALPORT_NONE:
    case VIR_VIRTUALPORT_TYPE_LAST:
        msg = _("unknown virtualport type");
        goto err_exit;
    break;
    }

err_exit:

    if (msg)
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s", msg);

    VIR_FREE(virtPortManagerID);
    VIR_FREE(virtPortTypeID);
    VIR_FREE(virtPortTypeIDVersion);
    VIR_FREE(virtPortInstanceID);
    VIR_FREE(virtPortProfileID);
    VIR_FREE(virtPortType);

    return ret;
}


2001 2002 2003 2004
/* Parse the XML definition for a network interface
 * @param node XML nodeset to parse for net definition
 * @return 0 on success, -1 on failure
 */
2005
static virDomainNetDefPtr
2006
virDomainNetDefParseXML(virCapsPtr caps,
2007 2008
                        xmlNodePtr node,
                        int flags ATTRIBUTE_UNUSED) {
2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
    virDomainNetDefPtr def;
    xmlNodePtr cur;
    char *macaddr = NULL;
    char *type = NULL;
    char *network = NULL;
    char *bridge = NULL;
    char *dev = NULL;
    char *ifname = NULL;
    char *script = NULL;
    char *address = NULL;
    char *port = NULL;
    char *model = NULL;
2021
    char *filter = NULL;
D
Daniel Veillard 已提交
2022
    char *internal = NULL;
2023
    char *devaddr = NULL;
2024
    char *mode = NULL;
2025
    virNWFilterHashTablePtr filterparams = NULL;
2026 2027
    virVirtualPortProfileParams virtPort;
    bool virtPortParsed = false;
2028 2029

    if (VIR_ALLOC(def) < 0) {
2030
        virReportOOMError();
2031 2032 2033 2034 2035
        return NULL;
    }

    type = virXMLPropString(node, "type");
    if (type != NULL) {
S
Stefan Berger 已提交
2036
        if ((int)(def->type = virDomainNetTypeFromString(type)) < 0) {
2037
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054
                                 _("unknown interface type '%s'"), type);
            goto error;
        }
    } else {
        def->type = VIR_DOMAIN_NET_TYPE_USER;
    }

    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if ((macaddr == NULL) &&
                (xmlStrEqual(cur->name, BAD_CAST "mac"))) {
                macaddr = virXMLPropString(cur, "address");
            } else if ((network == NULL) &&
                       (def->type == VIR_DOMAIN_NET_TYPE_NETWORK) &&
                       (xmlStrEqual(cur->name, BAD_CAST "source"))) {
                network = virXMLPropString(cur, "network");
D
Daniel Veillard 已提交
2055 2056 2057 2058
            } else if ((internal == NULL) &&
                       (def->type == VIR_DOMAIN_NET_TYPE_INTERNAL) &&
                       (xmlStrEqual(cur->name, BAD_CAST "source"))) {
                internal = virXMLPropString(cur, "name");
2059 2060 2061 2062 2063
            } else if ((network == NULL) &&
                       (def->type == VIR_DOMAIN_NET_TYPE_BRIDGE) &&
                       (xmlStrEqual(cur->name, BAD_CAST "source"))) {
                bridge = virXMLPropString(cur, "bridge");
            } else if ((dev == NULL) &&
2064 2065
                       (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET ||
                        def->type == VIR_DOMAIN_NET_TYPE_DIRECT) &&
2066
                       xmlStrEqual(cur->name, BAD_CAST "source")) {
2067 2068
                dev  = virXMLPropString(cur, "dev");
                mode = virXMLPropString(cur, "mode");
2069 2070 2071 2072 2073 2074
            } else if ((virtPortParsed == false) &&
                       (def->type == VIR_DOMAIN_NET_TYPE_DIRECT) &&
                       xmlStrEqual(cur->name, BAD_CAST "virtualport")) {
                if (virVirtualPortProfileParamsParseXML(cur, &virtPort))
                    goto error;
                virtPortParsed = true;
2075 2076 2077 2078 2079 2080 2081 2082
            } else if ((network == NULL) &&
                       ((def->type == VIR_DOMAIN_NET_TYPE_SERVER) ||
                        (def->type == VIR_DOMAIN_NET_TYPE_CLIENT) ||
                        (def->type == VIR_DOMAIN_NET_TYPE_MCAST)) &&
                       (xmlStrEqual(cur->name, BAD_CAST "source"))) {
                address = virXMLPropString(cur, "address");
                port = virXMLPropString(cur, "port");
            } else if ((address == NULL) &&
2083 2084
                       (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET ||
                        def->type == VIR_DOMAIN_NET_TYPE_BRIDGE) &&
2085 2086 2087 2088 2089
                       (xmlStrEqual(cur->name, BAD_CAST "ip"))) {
                address = virXMLPropString(cur, "address");
            } else if ((ifname == NULL) &&
                       xmlStrEqual(cur->name, BAD_CAST "target")) {
                ifname = virXMLPropString(cur, "dev");
2090
                if ((ifname != NULL) &&
C
Chris Lalancette 已提交
2091 2092
                    ((flags & VIR_DOMAIN_XML_INACTIVE) &&
                      (STRPREFIX((const char*)ifname, "vnet")))) {
2093 2094 2095 2096
                    /* An auto-generated target name, blank it out */
                    VIR_FREE(ifname);
                }
            } else if ((script == NULL) &&
2097 2098
                       (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET ||
                        def->type == VIR_DOMAIN_NET_TYPE_BRIDGE) &&
2099 2100 2101 2102
                       xmlStrEqual(cur->name, BAD_CAST "script")) {
                script = virXMLPropString(cur, "path");
            } else if (xmlStrEqual (cur->name, BAD_CAST "model")) {
                model = virXMLPropString(cur, "type");
2103 2104
            } else if (xmlStrEqual (cur->name, BAD_CAST "filterref")) {
                filter = virXMLPropString(cur, "filter");
2105
                VIR_FREE(filterparams);
2106
                filterparams = virNWFilterParseParamAttributes(cur);
2107 2108
            } else if ((flags & VIR_DOMAIN_XML_INTERNAL_STATUS) &&
                       xmlStrEqual(cur->name, BAD_CAST "state")) {
2109
                /* Legacy back-compat. Don't add any more attributes here */
2110
                devaddr = virXMLPropString(cur, "devaddr");
2111 2112 2113 2114 2115 2116
            }
        }
        cur = cur->next;
    }

    if (macaddr) {
2117
        if (virParseMacAddr((const char *)macaddr, def->mac) < 0) {
2118
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2119 2120 2121 2122
                                 _("unable to parse mac address '%s'"),
                                 (const char *)macaddr);
            goto error;
        }
2123
    } else {
2124
        virCapabilitiesGenerateMac(caps, def->mac);
2125 2126
    }

2127
    if (devaddr) {
2128 2129
        if (virDomainParseLegacyDeviceAddress(devaddr,
                                              &def->info.addr.pci) < 0) {
2130
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2131 2132 2133 2134 2135 2136
                                 _("Unable to parse devaddr parameter '%s'"),
                                 devaddr);
            goto error;
        }
        def->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
    } else {
2137
        if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
2138 2139 2140 2141 2142 2143 2144
            goto error;
    }

    /* XXX what about ISA/USB based NIC models - once we support
     * them we should make sure address type is correct */
    if (def->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
        def->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
2145
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2146
                             _("Network interfaces must use 'pci' address type"));
2147 2148 2149
        goto error;
    }

2150 2151 2152
    switch (def->type) {
    case VIR_DOMAIN_NET_TYPE_NETWORK:
        if (network == NULL) {
2153
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2154
    _("No <source> 'network' attribute specified with <interface type='network'/>"));
2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
            goto error;
        }
        def->data.network.name = network;
        network = NULL;
        break;

    case VIR_DOMAIN_NET_TYPE_ETHERNET:

        if (script != NULL) {
            def->data.ethernet.script = script;
            script = NULL;
        }
        if (dev != NULL) {
            def->data.ethernet.dev = dev;
            dev = NULL;
        }
        if (address != NULL) {
            def->data.ethernet.ipaddr = address;
            address = NULL;
        }
        break;

    case VIR_DOMAIN_NET_TYPE_BRIDGE:
        if (bridge == NULL) {
2179
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2180
    _("No <source> 'bridge' attribute specified with <interface type='bridge'/>"));
2181 2182 2183 2184
            goto error;
        }
        def->data.bridge.brname = bridge;
        bridge = NULL;
2185 2186 2187 2188
        if (script != NULL) {
            def->data.bridge.script = script;
            script = NULL;
        }
2189 2190 2191 2192
        if (address != NULL) {
            def->data.bridge.ipaddr = address;
            address = NULL;
        }
2193 2194 2195 2196 2197 2198
        break;

    case VIR_DOMAIN_NET_TYPE_CLIENT:
    case VIR_DOMAIN_NET_TYPE_SERVER:
    case VIR_DOMAIN_NET_TYPE_MCAST:
        if (port == NULL) {
2199
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2200
            _("No <source> 'port' attribute specified with socket interface"));
2201 2202 2203
            goto error;
        }
        if (virStrToLong_i(port, NULL, 10, &def->data.socket.port) < 0) {
2204
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2205
            _("Cannot parse <source> 'port' attribute with socket interface"));
2206 2207 2208 2209 2210 2211
            goto error;
        }

        if (address == NULL) {
            if (def->type == VIR_DOMAIN_NET_TYPE_CLIENT ||
                def->type == VIR_DOMAIN_NET_TYPE_MCAST) {
2212
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2213
        _("No <source> 'address' attribute specified with socket interface"));
2214 2215 2216 2217 2218 2219
                goto error;
            }
        } else {
            def->data.socket.address = address;
            address = NULL;
        }
2220 2221
        break;

D
Daniel Veillard 已提交
2222 2223
    case VIR_DOMAIN_NET_TYPE_INTERNAL:
        if (internal == NULL) {
2224
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
D
Daniel Veillard 已提交
2225 2226 2227 2228 2229 2230
        _("No <source> 'name' attribute specified with <interface type='internal'/>"));
            goto error;
        }
        def->data.internal.name = internal;
        internal = NULL;
        break;
2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249

    case VIR_DOMAIN_NET_TYPE_DIRECT:
        if (dev == NULL) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
        _("No <source> 'dev' attribute specified with <interface type='direct'/>"));
            goto error;
        }

        if (mode != NULL) {
            int m;
            if ((m = virDomainNetdevMacvtapTypeFromString(mode)) < 0) {
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                     _("Unkown mode has been specified"));
                goto error;
            }
            def->data.direct.mode = m;
        } else
            def->data.direct.mode = VIR_DOMAIN_NETDEV_MACVTAP_MODE_VEPA;

2250 2251 2252
        if (virtPortParsed)
            def->data.direct.virtPortProfile = virtPort;

2253 2254 2255
        def->data.direct.linkdev = dev;
        dev = NULL;

2256 2257
        VIR_FREE(ifname);

2258
        break;
S
Stefan Berger 已提交
2259 2260 2261 2262

    case VIR_DOMAIN_NET_TYPE_USER:
    case VIR_DOMAIN_NET_TYPE_LAST:
        break;
2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279
    }

    if (ifname != NULL) {
        def->ifname = ifname;
        ifname = NULL;
    }

    /* NIC model (see -net nic,model=?).  We only check that it looks
     * reasonable, not that it is a supported NIC type.  FWIW kvm
     * supports these types as of April 2008:
     * i82551 i82557b i82559er ne2k_pci pcnet rtl8139 e1000 virtio
     */
    if (model != NULL) {
        int i;
        for (i = 0 ; i < strlen(model) ; i++) {
            int char_ok = c_isalnum(model[i]) || model[i] == '_';
            if (!char_ok) {
2280 2281
                virDomainReportError(VIR_ERR_INVALID_ARG, "%s",
                                     _("Model name contains invalid characters"));
2282 2283 2284 2285 2286 2287 2288
                goto error;
            }
        }
        def->model = model;
        model = NULL;
    }

2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304
    if (filter != NULL) {
        switch (def->type) {
        case VIR_DOMAIN_NET_TYPE_ETHERNET:
        case VIR_DOMAIN_NET_TYPE_NETWORK:
        case VIR_DOMAIN_NET_TYPE_BRIDGE:
        case VIR_DOMAIN_NET_TYPE_DIRECT:
            def->filter = filter;
            filter = NULL;
            def->filterparams = filterparams;
            filterparams = NULL;
        break;
        default:
        break;
        }
    }

2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
cleanup:
    VIR_FREE(macaddr);
    VIR_FREE(network);
    VIR_FREE(address);
    VIR_FREE(port);
    VIR_FREE(ifname);
    VIR_FREE(dev);
    VIR_FREE(script);
    VIR_FREE(bridge);
    VIR_FREE(model);
2315
    VIR_FREE(filter);
2316
    VIR_FREE(type);
D
Daniel Veillard 已提交
2317
    VIR_FREE(internal);
2318
    VIR_FREE(devaddr);
S
Stefan Berger 已提交
2319
    VIR_FREE(mode);
2320
    virNWFilterHashTableFree(filterparams);
2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353

    return def;

error:
    virDomainNetDefFree(def);
    def = NULL;
    goto cleanup;
}


/* Parse the XML definition for a character device
 * @param node XML nodeset to parse for net definition
 *
 * The XML we're dealing with looks like
 *
 * <serial type="pty">
 *   <source path="/dev/pts/3"/>
 *   <target port="1"/>
 * </serial>
 *
 * <serial type="dev">
 *   <source path="/dev/ttyS0"/>
 *   <target port="1"/>
 * </serial>
 *
 * <serial type="tcp">
 *   <source mode="connect" host="0.0.0.0" service="2445"/>
 *   <target port="1"/>
 * </serial>
 *
 * <serial type="tcp">
 *   <source mode="bind" host="0.0.0.0" service="2445"/>
 *   <target port="1"/>
2354
 *   <protocol type='raw'/>
2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369
 * </serial>
 *
 * <serial type="udp">
 *   <source mode="bind" host="0.0.0.0" service="2445"/>
 *   <source mode="connect" host="0.0.0.0" service="2445"/>
 *   <target port="1"/>
 * </serial>
 *
 * <serial type="unix">
 *   <source mode="bind" path="/tmp/foo"/>
 *   <target port="1"/>
 * </serial>
 *
 */
static virDomainChrDefPtr
2370
virDomainChrDefParseXML(xmlNodePtr node,
2371
                        int flags) {
2372 2373 2374 2375 2376 2377 2378 2379 2380
    xmlNodePtr cur;
    char *type = NULL;
    char *bindHost = NULL;
    char *bindService = NULL;
    char *connectHost = NULL;
    char *connectService = NULL;
    char *path = NULL;
    char *mode = NULL;
    char *protocol = NULL;
2381
    const char *nodeName;
2382
    const char *targetType = NULL;
2383 2384
    const char *addrStr = NULL;
    const char *portStr = NULL;
2385 2386 2387
    virDomainChrDefPtr def;

    if (VIR_ALLOC(def) < 0) {
2388
        virReportOOMError();
2389 2390 2391 2392
        return NULL;
    }

    type = virXMLPropString(node, "type");
2393 2394 2395 2396
    if (type == NULL)
        def->type = VIR_DOMAIN_CHR_TYPE_PTY;
    else if ((def->type = virDomainChrTypeFromString(type)) < 0)
        def->type = VIR_DOMAIN_CHR_TYPE_NULL;
2397

2398 2399 2400
    nodeName = (const char *) node->name;
    if ((def->targetType = virDomainChrTargetTypeFromString(nodeName)) < 0) {
        /* channel is handled below */
2401
        if (STRNEQ(nodeName, "channel")) {
2402
            virDomainReportError(VIR_ERR_XML_ERROR,
2403 2404
                              _("unknown target type for character device: %s"),
                                 nodeName);
2405
            VIR_FREE(def);
2406 2407
            return NULL;
        }
2408 2409 2410
        def->targetType = VIR_DOMAIN_CHR_TARGET_TYPE_NULL;
    }

2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437
    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if (xmlStrEqual(cur->name, BAD_CAST "source")) {
                if (mode == NULL)
                    mode = virXMLPropString(cur, "mode");

                switch (def->type) {
                case VIR_DOMAIN_CHR_TYPE_PTY:
                case VIR_DOMAIN_CHR_TYPE_DEV:
                case VIR_DOMAIN_CHR_TYPE_FILE:
                case VIR_DOMAIN_CHR_TYPE_PIPE:
                case VIR_DOMAIN_CHR_TYPE_UNIX:
                    if (path == NULL)
                        path = virXMLPropString(cur, "path");

                    break;

                case VIR_DOMAIN_CHR_TYPE_UDP:
                case VIR_DOMAIN_CHR_TYPE_TCP:
                    if (mode == NULL ||
                        STREQ((const char *)mode, "connect")) {

                        if (connectHost == NULL)
                            connectHost = virXMLPropString(cur, "host");
                        if (connectService == NULL)
                            connectService = virXMLPropString(cur, "service");
2438
                    } else if (STREQ((const char *)mode, "bind")) {
2439 2440 2441 2442
                        if (bindHost == NULL)
                            bindHost = virXMLPropString(cur, "host");
                        if (bindService == NULL)
                            bindService = virXMLPropString(cur, "service");
2443
                    } else {
2444
                        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2445 2446 2447
                                             _("Unknown source mode '%s'"),
                                             mode);
                        goto error;
2448 2449
                    }

2450
                    if (def->type == VIR_DOMAIN_CHR_TYPE_UDP)
2451 2452 2453 2454 2455
                        VIR_FREE(mode);
                }
            } else if (xmlStrEqual(cur->name, BAD_CAST "protocol")) {
                if (protocol == NULL)
                    protocol = virXMLPropString(cur, "type");
2456 2457
            } else if (xmlStrEqual(cur->name, BAD_CAST "target")) {
                /* If target type isn't set yet, expect it to be set here */
2458
                if (def->targetType == VIR_DOMAIN_CHR_TARGET_TYPE_NULL) {
2459
                    targetType = virXMLPropString(cur, "type");
2460
                    if (targetType == NULL) {
2461
                        virDomainReportError(VIR_ERR_XML_ERROR, "%s",
2462 2463 2464 2465 2466 2467 2468
                                             _("character device target does "
                                               "not define a type"));
                        goto error;
                    }
                    if ((def->targetType =
                        virDomainChrTargetTypeFromString(targetType)) < 0)
                    {
2469
                        virDomainReportError(VIR_ERR_XML_ERROR,
2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
                                             _("unknown target type for "
                                               "character device: %s"),
                                             targetType);
                        goto error;
                    }
                }

                unsigned int port;
                switch (def->targetType) {
                case VIR_DOMAIN_CHR_TARGET_TYPE_PARALLEL:
                case VIR_DOMAIN_CHR_TARGET_TYPE_SERIAL:
                case VIR_DOMAIN_CHR_TARGET_TYPE_CONSOLE:
                    portStr = virXMLPropString(cur, "port");
2483
                    if (portStr == NULL) {
2484 2485 2486 2487 2488
                        /* Not required. It will be assigned automatically
                         * later */
                        break;
                    }

2489
                    if (virStrToLong_ui(portStr, NULL, 10, &port) < 0) {
2490
                        virDomainReportError(VIR_ERR_XML_ERROR,
2491 2492 2493 2494 2495 2496 2497 2498 2499 2500
                                             _("Invalid port number: %s"),
                                             portStr);
                        goto error;
                    }
                    break;

                case VIR_DOMAIN_CHR_TARGET_TYPE_GUESTFWD:
                    addrStr = virXMLPropString(cur, "address");
                    portStr = virXMLPropString(cur, "port");

2501
                    if (addrStr == NULL) {
2502
                        virDomainReportError(VIR_ERR_XML_ERROR, "%s",
2503 2504 2505 2506
                                             _("guestfwd channel does not "
                                               "define a target address"));
                        goto error;
                    }
2507
                    if (VIR_ALLOC(def->target.addr) < 0) {
2508
                        virReportOOMError();
2509 2510
                        goto error;
                    }
2511
                    if (virSocketParseAddr(addrStr, def->target.addr, 0) < 0)
2512
                    {
2513
                        virDomainReportError(VIR_ERR_XML_ERROR,
2514 2515 2516 2517 2518
                                             _("%s is not a valid address"),
                                             addrStr);
                        goto error;
                    }

2519
                    if (def->target.addr->stor.ss_family != AF_INET) {
2520
                        virDomainReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2521 2522 2523 2524 2525 2526
                                     "%s", _("guestfwd channel only supports "
                                             "IPv4 addresses"));
                        goto error;
                    }

                    if (portStr == NULL) {
2527
                        virDomainReportError(VIR_ERR_XML_ERROR, "%s",
2528 2529 2530 2531
                                             _("guestfwd channel does "
                                               "not define a target port"));
                        goto error;
                    }
2532
                    if (virStrToLong_ui(portStr, NULL, 10, &port) < 0) {
2533
                        virDomainReportError(VIR_ERR_XML_ERROR,
2534 2535 2536 2537 2538 2539 2540
                                             _("Invalid port number: %s"),
                                             portStr);
                        goto error;
                    }
                    virSocketSetPort(def->target.addr, port);
                    break;

2541 2542 2543 2544
                case VIR_DOMAIN_CHR_TARGET_TYPE_VIRTIO:
                    def->target.name = virXMLPropString(cur, "name");
                    break;

2545
                default:
2546
                    virDomainReportError(VIR_ERR_XML_ERROR,
2547 2548 2549
                                         _("unexpected target type type %u"),
                                         def->targetType);
                }
2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566
            }
        }
        cur = cur->next;
    }

    switch (def->type) {
    case VIR_DOMAIN_CHR_TYPE_NULL:
        /* Nada */
        break;

    case VIR_DOMAIN_CHR_TYPE_VC:
        break;

    case VIR_DOMAIN_CHR_TYPE_PTY:
    case VIR_DOMAIN_CHR_TYPE_DEV:
    case VIR_DOMAIN_CHR_TYPE_FILE:
    case VIR_DOMAIN_CHR_TYPE_PIPE:
2567 2568
        if (path == NULL &&
            def->type != VIR_DOMAIN_CHR_TYPE_PTY) {
2569
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2570
                       _("Missing source path attribute for char device"));
2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585
            goto error;
        }

        def->data.file.path = path;
        path = NULL;
        break;

    case VIR_DOMAIN_CHR_TYPE_STDIO:
        /* Nada */
        break;

    case VIR_DOMAIN_CHR_TYPE_TCP:
        if (mode == NULL ||
            STREQ(mode, "connect")) {
            if (connectHost == NULL) {
2586
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2587
                        _("Missing source host attribute for char device"));
2588 2589 2590
                goto error;
            }
            if (connectService == NULL) {
2591
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2592
                     _("Missing source service attribute for char device"));
2593 2594 2595 2596 2597 2598 2599 2600 2601 2602
                goto error;
            }

            def->data.tcp.host = connectHost;
            connectHost = NULL;
            def->data.tcp.service = connectService;
            connectService = NULL;
            def->data.tcp.listen = 0;
        } else {
            if (bindHost == NULL) {
2603
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2604
                        _("Missing source host attribute for char device"));
2605 2606 2607
                goto error;
            }
            if (bindService == NULL) {
2608
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2609
                     _("Missing source service attribute for char device"));
2610 2611 2612 2613 2614 2615 2616 2617 2618
                goto error;
            }

            def->data.tcp.host = bindHost;
            bindHost = NULL;
            def->data.tcp.service = bindService;
            bindService = NULL;
            def->data.tcp.listen = 1;
        }
2619 2620 2621

        if (protocol == NULL ||
            STREQ(protocol, "raw"))
2622
            def->data.tcp.protocol = VIR_DOMAIN_CHR_TCP_PROTOCOL_RAW;
2623 2624 2625
        else if (STREQ(protocol, "telnet"))
            def->data.tcp.protocol = VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET;
        else {
2626
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2627 2628 2629 2630
                                 _("Unknown protocol '%s'"), protocol);
            goto error;
        }

2631 2632 2633 2634
        break;

    case VIR_DOMAIN_CHR_TYPE_UDP:
        if (connectService == NULL) {
2635
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2636
                   _("Missing source service attribute for char device"));
2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652
            goto error;
        }

        def->data.udp.connectHost = connectHost;
        connectHost = NULL;
        def->data.udp.connectService = connectService;
        connectService = NULL;

        def->data.udp.bindHost = bindHost;
        bindHost = NULL;
        def->data.udp.bindService = bindService;
        bindService = NULL;
        break;

    case VIR_DOMAIN_CHR_TYPE_UNIX:
        if (path == NULL) {
2653
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2654
                         _("Missing source path attribute for char device"));
2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668
            goto error;
        }

        if (mode != NULL &&
            STRNEQ(mode, "connect"))
            def->data.nix.listen = 1;
        else
            def->data.nix.listen = 0;

        def->data.nix.path = path;
        path = NULL;
        break;
    }

2669
    if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
2670 2671
        goto error;

2672 2673 2674 2675 2676 2677 2678 2679 2680
cleanup:
    VIR_FREE(mode);
    VIR_FREE(protocol);
    VIR_FREE(type);
    VIR_FREE(bindHost);
    VIR_FREE(bindService);
    VIR_FREE(connectHost);
    VIR_FREE(connectService);
    VIR_FREE(path);
2681 2682 2683
    VIR_FREE(targetType);
    VIR_FREE(addrStr);
    VIR_FREE(portStr);
2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694

    return def;

error:
    virDomainChrDefFree(def);
    def = NULL;
    goto cleanup;
}

/* Parse the XML definition for a network interface */
static virDomainInputDefPtr
2695
virDomainInputDefParseXML(const char *ostype,
2696
                          xmlNodePtr node,
2697
                          int flags) {
2698 2699 2700 2701 2702
    virDomainInputDefPtr def;
    char *type = NULL;
    char *bus = NULL;

    if (VIR_ALLOC(def) < 0) {
2703
        virReportOOMError();
2704 2705 2706 2707 2708 2709 2710
        return NULL;
    }

    type = virXMLPropString(node, "type");
    bus = virXMLPropString(node, "bus");

    if (!type) {
2711
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2712 2713 2714 2715 2716
                             "%s", _("missing input device type"));
        goto error;
    }

    if ((def->type = virDomainInputTypeFromString(type)) < 0) {
2717
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2718 2719 2720 2721 2722 2723
                             _("unknown input device type '%s'"), type);
        goto error;
    }

    if (bus) {
        if ((def->bus = virDomainInputBusTypeFromString(bus)) < 0) {
2724
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2725 2726 2727 2728 2729 2730 2731
                                 _("unknown input bus type '%s'"), bus);
            goto error;
        }

        if (STREQ(ostype, "hvm")) {
            if (def->bus == VIR_DOMAIN_INPUT_BUS_PS2 && /* Only allow mouse for ps2 */
                def->type != VIR_DOMAIN_INPUT_TYPE_MOUSE) {
2732
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2733
                                 _("ps2 bus does not support %s input device"),
2734 2735 2736 2737
                                     type);
                goto error;
            }
            if (def->bus == VIR_DOMAIN_INPUT_BUS_XEN) {
2738
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2739 2740 2741 2742 2743 2744
                                     _("unsupported input bus %s"),
                                     bus);
                goto error;
            }
        } else {
            if (def->bus != VIR_DOMAIN_INPUT_BUS_XEN) {
2745
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2746 2747 2748 2749
                                     _("unsupported input bus %s"),
                                     bus);
            }
            if (def->type != VIR_DOMAIN_INPUT_TYPE_MOUSE) {
2750
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2751
                                 _("xen bus does not support %s input device"),
2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766
                                     type);
                goto error;
            }
        }
    } else {
        if (STREQ(ostype, "hvm")) {
            if (def->type == VIR_DOMAIN_INPUT_TYPE_MOUSE)
                def->bus = VIR_DOMAIN_INPUT_BUS_PS2;
            else
                def->bus = VIR_DOMAIN_INPUT_BUS_USB;
        } else {
            def->bus = VIR_DOMAIN_INPUT_BUS_XEN;
        }
    }

2767
    if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
2768 2769
        goto error;

2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782
cleanup:
    VIR_FREE(type);
    VIR_FREE(bus);

    return def;

error:
    virDomainInputDefFree(def);
    def = NULL;
    goto cleanup;
}


2783 2784 2785 2786 2787 2788 2789 2790 2791
/* Parse the XML definition for a clock timer */
static virDomainTimerDefPtr
virDomainTimerDefParseXML(const xmlNodePtr node,
                          xmlXPathContextPtr ctxt,
                          int flags ATTRIBUTE_UNUSED)
{
    char *name = NULL;
    char *present = NULL;
    char *tickpolicy = NULL;
2792
    char *track = NULL;
2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839
    char *mode = NULL;

    virDomainTimerDefPtr def;
    xmlNodePtr oldnode = ctxt->node;

    if (VIR_ALLOC(def) < 0) {
        virReportOOMError();
        return NULL;
    }

    ctxt->node = node;

    name = virXMLPropString(node, "name");
    if (name == NULL) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                             "%s", _("missing timer name"));
        goto error;
    }
    if ((def->name = virDomainTimerNameTypeFromString(name)) < 0) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                             _("unknown timer name '%s'"), name);
        goto error;
    }

    def->present = -1; /* unspecified */
    if ((present = virXMLPropString(node, "present")) != NULL) {
        if (STREQ(present, "yes")) {
            def->present = 1;
        } else if (STREQ(present, "no")) {
            def->present = 0;
        } else {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("unknown timer present value '%s'"), present);
            goto error;
        }
    }

    def->tickpolicy = -1;
    tickpolicy = virXMLPropString(node, "tickpolicy");
    if (tickpolicy != NULL) {
        if ((def->tickpolicy = virDomainTimerTickpolicyTypeFromString(tickpolicy)) < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("unknown timer tickpolicy '%s'"), tickpolicy);
            goto error;
        }
    }

2840 2841 2842 2843
    def->track = -1;
    track = virXMLPropString(node, "track");
    if (track != NULL) {
        if ((def->track = virDomainTimerTrackTypeFromString(track)) < 0) {
2844
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2845
                                 _("unknown timer track '%s'"), track);
2846 2847 2848 2849 2850 2851 2852
            goto error;
        }
    }

    int ret = virXPathULong("string(./frequency)", ctxt, &def->frequency);
    if (ret == -1) {
        def->frequency = 0;
2853
    } else if (ret < 0) {
2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                             "%s", _("invalid timer frequency"));
        goto error;
    }

    def->mode = -1;
    mode = virXMLPropString(node, "mode");
    if (mode != NULL) {
        if ((def->mode = virDomainTimerModeTypeFromString(mode)) < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("unknown timer mode '%s'"), mode);
            goto error;
        }
    }

2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899
    xmlNodePtr catchup = virXPathNode("./catchup", ctxt);
    if (catchup != NULL) {
        ret = virXPathULong("string(./catchup/@threshold)", ctxt,
                            &def->catchup.threshold);
        if (ret == -1) {
            def->catchup.threshold = 0;
        } else if (ret < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 "%s", _("invalid catchup threshold"));
            goto error;
        }

        ret = virXPathULong("string(./catchup/@slew)", ctxt, &def->catchup.slew);
        if (ret == -1) {
            def->catchup.slew = 0;
        } else if (ret < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 "%s", _("invalid catchup slew"));
            goto error;
        }

        ret = virXPathULong("string(./catchup/@limit)", ctxt, &def->catchup.limit);
        if (ret == -1) {
            def->catchup.limit = 0;
        } else if (ret < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 "%s", _("invalid catchup limit"));
            goto error;
        }
    }

2900 2901 2902 2903
cleanup:
    VIR_FREE(name);
    VIR_FREE(present);
    VIR_FREE(tickpolicy);
2904
    VIR_FREE(track);
2905 2906 2907 2908 2909 2910 2911 2912 2913 2914
    VIR_FREE(mode);
    ctxt->node = oldnode;

    return def;

error:
    VIR_FREE(def);
    goto cleanup;
}

2915 2916
/* Parse the XML definition for a graphics device */
static virDomainGraphicsDefPtr
2917
virDomainGraphicsDefParseXML(xmlNodePtr node, int flags) {
2918 2919 2920 2921
    virDomainGraphicsDefPtr def;
    char *type = NULL;

    if (VIR_ALLOC(def) < 0) {
2922
        virReportOOMError();
2923 2924 2925 2926 2927 2928
        return NULL;
    }

    type = virXMLPropString(node, "type");

    if (!type) {
2929
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2930 2931 2932 2933 2934
                             "%s", _("missing graphics device type"));
        goto error;
    }

    if ((def->type = virDomainGraphicsTypeFromString(type)) < 0) {
2935
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2936 2937 2938 2939 2940 2941 2942 2943 2944 2945
                             _("unknown graphics device type '%s'"), type);
        goto error;
    }

    if (def->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
        char *port = virXMLPropString(node, "port");
        char *autoport;

        if (port) {
            if (virStrToLong_i(port, NULL, 10, &def->data.vnc.port) < 0) {
2946
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2947 2948 2949 2950 2951 2952 2953
                                     _("cannot parse vnc port %s"), port);
                VIR_FREE(port);
                goto error;
            }
            VIR_FREE(port);
            /* Legacy compat syntax, used -1 for auto-port */
            if (def->data.vnc.port == -1) {
2954 2955
                if (flags & VIR_DOMAIN_XML_INACTIVE)
                    def->data.vnc.port = 0;
2956 2957 2958 2959 2960 2961 2962 2963 2964
                def->data.vnc.autoport = 1;
            }
        } else {
            def->data.vnc.port = 0;
            def->data.vnc.autoport = 1;
        }

        if ((autoport = virXMLPropString(node, "autoport")) != NULL) {
            if (STREQ(autoport, "yes")) {
2965 2966
                if (flags & VIR_DOMAIN_XML_INACTIVE)
                    def->data.vnc.port = 0;
2967 2968 2969 2970 2971 2972 2973 2974 2975
                def->data.vnc.autoport = 1;
            }
            VIR_FREE(autoport);
        }

        def->data.vnc.listenAddr = virXMLPropString(node, "listen");
        def->data.vnc.passwd = virXMLPropString(node, "passwd");
        def->data.vnc.keymap = virXMLPropString(node, "keymap");
    } else if (def->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) {
2976 2977 2978 2979 2980 2981 2982 2983
        char *fullscreen = virXMLPropString(node, "fullscreen");

        if (fullscreen != NULL) {
            if (STREQ(fullscreen, "yes")) {
                def->data.sdl.fullscreen = 1;
            } else if (STREQ(fullscreen, "no")) {
                def->data.sdl.fullscreen = 0;
            } else {
2984
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
2985 2986 2987 2988 2989 2990 2991
                             _("unknown fullscreen value '%s'"), fullscreen);
                VIR_FREE(fullscreen);
                goto error;
            }
            VIR_FREE(fullscreen);
        } else
            def->data.sdl.fullscreen = 0;
2992 2993
        def->data.sdl.xauth = virXMLPropString(node, "xauth");
        def->data.sdl.display = virXMLPropString(node, "display");
2994 2995 2996 2997 2998 2999 3000 3001
    } else if (def->type == VIR_DOMAIN_GRAPHICS_TYPE_RDP) {
        char *port = virXMLPropString(node, "port");
        char *autoport;
        char *replaceUser;
        char *multiUser;

        if (port) {
            if (virStrToLong_i(port, NULL, 10, &def->data.rdp.port) < 0) {
3002
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045
                                     _("cannot parse rdp port %s"), port);
                VIR_FREE(port);
                goto error;
            }
            VIR_FREE(port);
        } else {
            def->data.rdp.port = 0;
            def->data.rdp.autoport = 1;
        }

        if ((autoport = virXMLPropString(node, "autoport")) != NULL) {
            if (STREQ(autoport, "yes")) {
                if (flags & VIR_DOMAIN_XML_INACTIVE)
                    def->data.rdp.port = 0;
                def->data.rdp.autoport = 1;
            }
            VIR_FREE(autoport);
        }

        if ((replaceUser = virXMLPropString(node, "replaceUser")) != NULL) {
            if (STREQ(replaceUser, "yes")) {
                def->data.rdp.replaceUser = 1;
            }
            VIR_FREE(replaceUser);
        }

        if ((multiUser = virXMLPropString(node, "multiUser")) != NULL) {
            if (STREQ(multiUser, "yes")) {
                def->data.rdp.multiUser = 1;
            }
            VIR_FREE(multiUser);
        }

        def->data.rdp.listenAddr = virXMLPropString(node, "listen");
    } else if (def->type == VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP) {
        char *fullscreen = virXMLPropString(node, "fullscreen");

        if (fullscreen != NULL) {
            if (STREQ(fullscreen, "yes")) {
                def->data.desktop.fullscreen = 1;
            } else if (STREQ(fullscreen, "no")) {
                def->data.desktop.fullscreen = 0;
            } else {
3046
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3047 3048 3049 3050 3051 3052 3053 3054 3055
                             _("unknown fullscreen value '%s'"), fullscreen);
                VIR_FREE(fullscreen);
                goto error;
            }
            VIR_FREE(fullscreen);
        } else
            def->data.desktop.fullscreen = 0;

        def->data.desktop.display = virXMLPropString(node, "display");
3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070
    }

cleanup:
    VIR_FREE(type);

    return def;

error:
    virDomainGraphicsDefFree(def);
    def = NULL;
    goto cleanup;
}


static virDomainSoundDefPtr
3071
virDomainSoundDefParseXML(const xmlNodePtr node,
3072 3073
                          int flags)
{
3074 3075 3076 3077
    char *model;
    virDomainSoundDefPtr def;

    if (VIR_ALLOC(def) < 0) {
3078
        virReportOOMError();
3079 3080 3081 3082 3083
        return NULL;
    }

    model = virXMLPropString(node, "model");
    if ((def->model = virDomainSoundModelTypeFromString(model)) < 0) {
3084
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3085 3086 3087 3088
                             _("unknown sound model '%s'"), model);
        goto error;
    }

3089
    if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
3090 3091
        goto error;

3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102
cleanup:
    VIR_FREE(model);

    return def;

error:
    virDomainSoundDefFree(def);
    def = NULL;
    goto cleanup;
}

3103

R
Richard Jones 已提交
3104
static virDomainWatchdogDefPtr
3105
virDomainWatchdogDefParseXML(const xmlNodePtr node,
3106 3107
                             int flags)
{
R
Richard Jones 已提交
3108 3109 3110 3111 3112 3113

    char *model = NULL;
    char *action = NULL;
    virDomainWatchdogDefPtr def;

    if (VIR_ALLOC (def) < 0) {
3114
        virReportOOMError();
R
Richard Jones 已提交
3115 3116 3117 3118 3119
        return NULL;
    }

    model = virXMLPropString (node, "model");
    if (model == NULL) {
3120 3121
        virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                             _("watchdog must contain model name"));
R
Richard Jones 已提交
3122 3123 3124 3125
        goto error;
    }
    def->model = virDomainWatchdogModelTypeFromString (model);
    if (def->model < 0) {
3126 3127
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                             _("unknown watchdog model '%s'"), model);
R
Richard Jones 已提交
3128 3129 3130 3131 3132 3133 3134 3135 3136
        goto error;
    }

    action = virXMLPropString (node, "action");
    if (action == NULL)
        def->action = VIR_DOMAIN_WATCHDOG_ACTION_RESET;
    else {
        def->action = virDomainWatchdogActionTypeFromString (action);
        if (def->action < 0) {
3137 3138
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("unknown watchdog action '%s'"), action);
R
Richard Jones 已提交
3139 3140 3141 3142
            goto error;
        }
    }

3143
    if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
3144 3145
        goto error;

R
Richard Jones 已提交
3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158
cleanup:
    VIR_FREE (action);
    VIR_FREE (model);

    return def;

error:
    virDomainWatchdogDefFree (def);
    def = NULL;
    goto cleanup;
}


3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169
int
virDomainVideoDefaultRAM(virDomainDefPtr def,
                         int type)
{
    switch (type) {
        /* Wierd, QEMU defaults to 9 MB ??! */
    case VIR_DOMAIN_VIDEO_TYPE_VGA:
    case VIR_DOMAIN_VIDEO_TYPE_CIRRUS:
    case VIR_DOMAIN_VIDEO_TYPE_VMVGA:
        if (def->virtType == VIR_DOMAIN_VIRT_VBOX)
            return 8 * 1024;
M
Matthias Bolte 已提交
3170 3171
        else if (def->virtType == VIR_DOMAIN_VIRT_VMWARE)
            return 4 * 1024;
3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204
        else
            return 9 * 1024;
        break;

    case VIR_DOMAIN_VIDEO_TYPE_XEN:
        /* Original Xen PVFB hardcoded to 4 MB */
        return 4 * 1024;

    default:
        return 0;
    }
}


int
virDomainVideoDefaultType(virDomainDefPtr def)
{
    switch (def->virtType) {
    case VIR_DOMAIN_VIRT_TEST:
    case VIR_DOMAIN_VIRT_QEMU:
    case VIR_DOMAIN_VIRT_KQEMU:
    case VIR_DOMAIN_VIRT_KVM:
    case VIR_DOMAIN_VIRT_XEN:
        if (def->os.type &&
            (STREQ(def->os.type, "xen") ||
             STREQ(def->os.type, "linux")))
            return VIR_DOMAIN_VIDEO_TYPE_XEN;
        else
            return VIR_DOMAIN_VIDEO_TYPE_CIRRUS;

    case VIR_DOMAIN_VIRT_VBOX:
        return VIR_DOMAIN_VIDEO_TYPE_VBOX;

M
Matthias Bolte 已提交
3205 3206 3207
    case VIR_DOMAIN_VIRT_VMWARE:
        return VIR_DOMAIN_VIDEO_TYPE_VMVGA;

3208 3209 3210 3211 3212
    default:
        return -1;
    }
}

3213
static virDomainVideoAccelDefPtr
3214
virDomainVideoAccelDefParseXML(const xmlNodePtr node) {
3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235
    xmlNodePtr cur;
    virDomainVideoAccelDefPtr def;
    char *support3d = NULL;
    char *support2d = NULL;

    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if ((support3d == NULL) && (support2d == NULL) &&
                xmlStrEqual(cur->name, BAD_CAST "acceleration")) {
                support3d = virXMLPropString(cur, "accel3d");
                support2d = virXMLPropString(cur, "accel2d");
            }
        }
        cur = cur->next;
    }

    if ((support3d == NULL) && (support2d == NULL))
        return(NULL);

    if (VIR_ALLOC(def) < 0) {
3236
        virReportOOMError();
3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258
        return NULL;
    }

    if (support3d) {
        if (STREQ(support3d, "yes"))
            def->support3d = 1;
        else
            def->support3d = 0;
        VIR_FREE(support3d);
    }

    if (support2d) {
        if (STREQ(support2d, "yes"))
            def->support2d = 1;
        else
            def->support2d = 0;
        VIR_FREE(support2d);
    }

    return def;
}

3259
static virDomainVideoDefPtr
3260
virDomainVideoDefParseXML(const xmlNodePtr node,
3261
                          virDomainDefPtr dom,
3262
                          int flags) {
3263 3264 3265 3266 3267 3268 3269
    virDomainVideoDefPtr def;
    xmlNodePtr cur;
    char *type = NULL;
    char *heads = NULL;
    char *vram = NULL;

    if (VIR_ALLOC(def) < 0) {
3270
        virReportOOMError();
3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281
        return NULL;
    }

    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if ((type == NULL) && (vram == NULL) && (heads == NULL) &&
                xmlStrEqual(cur->name, BAD_CAST "model")) {
                type = virXMLPropString(cur, "type");
                vram = virXMLPropString(cur, "vram");
                heads = virXMLPropString(cur, "heads");
3282
                def->accel = virDomainVideoAccelDefParseXML(cur);
3283 3284 3285 3286 3287 3288 3289
            }
        }
        cur = cur->next;
    }

    if (type) {
        if ((def->type = virDomainVideoTypeFromString(type)) < 0) {
3290
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3291 3292 3293 3294 3295
                                 _("unknown video model '%s'"), type);
            goto error;
        }
    } else {
        if ((def->type = virDomainVideoDefaultType(dom)) < 0) {
3296
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3297 3298 3299 3300 3301 3302 3303
                                 _("missing video model and cannot determine default"));
            goto error;
        }
    }

    if (vram) {
        if (virStrToLong_ui(vram, NULL, 10, &def->vram) < 0) {
3304
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3305 3306 3307 3308 3309 3310 3311 3312 3313
                                 _("cannot parse video ram '%s'"), vram);
            goto error;
        }
    } else {
        def->vram = virDomainVideoDefaultRAM(dom, def->type);
    }

    if (heads) {
        if (virStrToLong_ui(heads, NULL, 10, &def->heads) < 0) {
3314
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3315 3316 3317 3318 3319 3320 3321
                                 _("cannot parse video heads '%s'"), heads);
            goto error;
        }
    } else {
        def->heads = 1;
    }

3322
    if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
3323 3324
        goto error;

3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338
    VIR_FREE(type);
    VIR_FREE(vram);
    VIR_FREE(heads);

    return def;

error:
    virDomainVideoDefFree(def);
    VIR_FREE(type);
    VIR_FREE(vram);
    VIR_FREE(heads);
    return NULL;
}

3339
static int
3340
virDomainHostdevSubsysUsbDefParseXML(const xmlNodePtr node,
3341 3342
                                     virDomainHostdevDefPtr def,
                                     int flags ATTRIBUTE_UNUSED) {
3343 3344

    int ret = -1;
3345
    int got_product, got_vendor;
3346 3347
    xmlNodePtr cur;

3348 3349 3350 3351 3352
    /* Product can validly be 0, so we need some extra help to determine
     * if it is uninitialized*/
    got_product = 0;
    got_vendor = 0;

3353 3354 3355 3356 3357 3358 3359
    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if (xmlStrEqual(cur->name, BAD_CAST "vendor")) {
                char *vendor = virXMLPropString(cur, "id");

                if (vendor) {
3360
                    got_vendor = 1;
3361
                    if (virStrToLong_ui(vendor, NULL, 0,
3362
                                    &def->source.subsys.u.usb.vendor) < 0) {
3363
                        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3364 3365 3366 3367 3368 3369
                                 _("cannot parse vendor id %s"), vendor);
                        VIR_FREE(vendor);
                        goto out;
                    }
                    VIR_FREE(vendor);
                } else {
3370
                    virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3371 3372 3373 3374 3375 3376 3377
                                         "%s", _("usb vendor needs id"));
                    goto out;
                }
            } else if (xmlStrEqual(cur->name, BAD_CAST "product")) {
                char* product = virXMLPropString(cur, "id");

                if (product) {
3378
                    got_product = 1;
3379
                    if (virStrToLong_ui(product, NULL, 0,
3380
                                        &def->source.subsys.u.usb.product) < 0) {
3381
                        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3382 3383
                                             _("cannot parse product %s"),
                                             product);
3384 3385 3386 3387 3388
                        VIR_FREE(product);
                        goto out;
                    }
                    VIR_FREE(product);
                } else {
3389
                    virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3390 3391 3392 3393 3394 3395 3396 3397 3398
                                         "%s", _("usb product needs id"));
                    goto out;
                }
            } else if (xmlStrEqual(cur->name, BAD_CAST "address")) {
                char *bus, *device;

                bus = virXMLPropString(cur, "bus");
                if (bus) {
                    if (virStrToLong_ui(bus, NULL, 0,
3399
                                        &def->source.subsys.u.usb.bus) < 0) {
3400
                        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3401 3402 3403 3404 3405 3406
                                             _("cannot parse bus %s"), bus);
                        VIR_FREE(bus);
                        goto out;
                    }
                    VIR_FREE(bus);
                } else {
3407
                    virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3408 3409 3410 3411 3412 3413 3414
                                         "%s", _("usb address needs bus id"));
                    goto out;
                }

                device = virXMLPropString(cur, "device");
                if (device) {
                    if (virStrToLong_ui(device, NULL, 0,
3415
                                        &def->source.subsys.u.usb.device) < 0)  {
3416
                        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3417 3418 3419 3420 3421 3422 3423
                                             _("cannot parse device %s"),
                                             device);
                        VIR_FREE(device);
                        goto out;
                    }
                    VIR_FREE(device);
                } else {
3424
                    virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3425
                                         _("usb address needs device id"));
3426 3427 3428
                    goto out;
                }
            } else {
3429
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3430 3431
                                     _("unknown usb source type '%s'"),
                                     cur->name);
3432 3433 3434 3435 3436 3437
                goto out;
            }
        }
        cur = cur->next;
    }

3438
    if (got_vendor && def->source.subsys.u.usb.vendor == 0) {
3439
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3440 3441 3442 3443 3444
            "%s", _("vendor cannot be 0."));
        goto out;
    }

    if (!got_vendor && got_product) {
3445
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
J
Jim Meyering 已提交
3446
            "%s", _("missing vendor"));
3447 3448
        goto out;
    }
3449
    if (got_vendor && !got_product) {
3450
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
J
Jim Meyering 已提交
3451
            "%s", _("missing product"));
3452 3453 3454 3455 3456 3457 3458 3459 3460
        goto out;
    }

    ret = 0;
out:
    return ret;
}


3461
static int
3462
virDomainHostdevSubsysPciDefParseXML(const xmlNodePtr node,
3463
                                     virDomainHostdevDefPtr def,
3464
                                     int flags) {
3465 3466 3467 3468 3469 3470 3471 3472

    int ret = -1;
    xmlNodePtr cur;

    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if (xmlStrEqual(cur->name, BAD_CAST "address")) {
3473 3474
                virDomainDevicePCIAddressPtr addr =
                    &def->source.subsys.u.pci;
3475

3476
                if (virDomainDevicePCIAddressParseXML(cur, addr) < 0)
3477
                    goto out;
3478 3479
            } else if ((flags & VIR_DOMAIN_XML_INTERNAL_STATUS) &&
                       xmlStrEqual(cur->name, BAD_CAST "state")) {
3480
                /* Legacy back-compat. Don't add any more attributes here */
3481 3482
                char *devaddr = virXMLPropString(cur, "devaddr");
                if (devaddr &&
3483 3484
                    virDomainParseLegacyDeviceAddress(devaddr,
                                                      &def->info.addr.pci) < 0) {
3485
                    virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3486 3487 3488 3489 3490
                                         _("Unable to parse devaddr parameter '%s'"),
                                         devaddr);
                    VIR_FREE(devaddr);
                    goto out;
                }
3491
                def->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
3492
            } else {
3493
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507
                                     _("unknown pci source type '%s'"),
                                     cur->name);
                goto out;
            }
        }
        cur = cur->next;
    }

    ret = 0;
out:
    return ret;
}


3508
static virDomainHostdevDefPtr
3509
virDomainHostdevDefParseXML(const xmlNodePtr node,
3510
                            int flags) {
3511 3512 3513

    xmlNodePtr cur;
    virDomainHostdevDefPtr def;
3514
    char *mode, *type = NULL, *managed = NULL;
3515 3516

    if (VIR_ALLOC(def) < 0) {
3517
        virReportOOMError();
3518 3519 3520 3521 3522 3523 3524
        return NULL;
    }
    def->target = NULL;

    mode = virXMLPropString(node, "mode");
    if (mode) {
        if ((def->mode=virDomainHostdevModeTypeFromString(mode)) < 0) {
3525
             virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3526 3527 3528 3529 3530 3531 3532 3533 3534 3535
                                  _("unknown hostdev mode '%s'"), mode);
            goto error;
        }
    } else {
        def->mode = VIR_DOMAIN_HOSTDEV_MODE_SUBSYS;
    }

    type = virXMLPropString(node, "type");
    if (type) {
        if ((def->source.subsys.type = virDomainHostdevSubsysTypeFromString(type)) < 0) {
3536
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3537 3538 3539 3540
                                 _("unknown host device type '%s'"), type);
            goto error;
        }
    } else {
3541
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3542 3543 3544 3545
                             "%s", _("missing type in hostdev"));
        goto error;
    }

3546 3547 3548 3549 3550 3551 3552
    managed = virXMLPropString(node, "managed");
    if (managed != NULL) {
        if (STREQ(managed, "yes"))
            def->managed = 1;
        VIR_FREE(managed);
    }

3553 3554 3555 3556 3557 3558
    cur = node->children;
    while (cur != NULL) {
        if (cur->type == XML_ELEMENT_NODE) {
            if (xmlStrEqual(cur->name, BAD_CAST "source")) {
                if (def->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
                    def->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
3559
                        if (virDomainHostdevSubsysUsbDefParseXML(cur, def, flags) < 0)
3560 3561
                            goto error;
                }
3562 3563
                if (def->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
                    def->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
3564
                        if (virDomainHostdevSubsysPciDefParseXML(cur, def, flags) < 0)
3565 3566
                            goto error;
                }
D
Daniel P. Berrange 已提交
3567 3568
            } else if (xmlStrEqual(cur->name, BAD_CAST "address")) {
            } else {
3569
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
D
Daniel P. Berrange 已提交
3570
                                     _("unknown node %s"), cur->name);
3571 3572 3573 3574 3575
            }
        }
        cur = cur->next;
    }

3576
    if (def->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
3577
        if (virDomainDeviceInfoParseXML(node, &def->info, flags) < 0)
3578 3579 3580 3581 3582 3583 3584 3585
            goto error;
    }

    if (def->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
        switch (def->source.subsys.type) {
        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
            if (def->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
                def->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
3586
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3587 3588 3589 3590 3591 3592 3593
                                     _("PCI host devices must use 'pci' address type"));
                goto error;
            }
            break;
        }
    }

3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604
cleanup:
    VIR_FREE(type);
    VIR_FREE(mode);
    return def;

error:
    virDomainHostdevDefFree(def);
    def = NULL;
    goto cleanup;
}

3605

3606
static int virDomainLifecycleParseXML(xmlXPathContextPtr ctxt,
3607 3608 3609 3610
                                      const char *xpath,
                                      int *val,
                                      int defaultVal)
{
3611
    char *tmp = virXPathString(xpath, ctxt);
3612 3613 3614 3615 3616
    if (tmp == NULL) {
        *val = defaultVal;
    } else {
        *val = virDomainLifecycleTypeFromString(tmp);
        if (*val < 0) {
3617
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3618 3619 3620 3621 3622 3623 3624 3625 3626
                                 _("unknown lifecycle action %s"), tmp);
            VIR_FREE(tmp);
            return -1;
        }
        VIR_FREE(tmp);
    }
    return 0;
}

3627
static int
3628
virSecurityLabelDefParseXML(const virDomainDefPtr def,
3629 3630
                            xmlXPathContextPtr ctxt,
                            int flags)
3631 3632 3633
{
    char *p;

3634
    if (virXPathNode("./seclabel", ctxt) == NULL)
3635 3636
        return 0;

3637
    p = virXPathStringLimit("string(./seclabel/@type)",
3638
                            VIR_SECURITY_LABEL_BUFLEN-1, ctxt);
3639
    if (p == NULL) {
3640
        virDomainReportError(VIR_ERR_XML_ERROR,
3641
                             "%s", _("missing security type"));
3642
        goto error;
3643 3644
    }
    def->seclabel.type = virDomainSeclabelTypeFromString(p);
3645
    VIR_FREE(p);
3646
    if (def->seclabel.type < 0) {
3647
        virDomainReportError(VIR_ERR_XML_ERROR,
3648
                             "%s", _("invalid security type"));
3649 3650
        goto error;
    }
3651 3652 3653 3654 3655 3656

    /* Only parse details, if using static labels, or
     * if the 'live' VM XML is requested
     */
    if (def->seclabel.type == VIR_DOMAIN_SECLABEL_STATIC ||
        !(flags & VIR_DOMAIN_XML_INACTIVE)) {
3657
        p = virXPathStringLimit("string(./seclabel/@model)",
3658 3659
                                VIR_SECURITY_MODEL_BUFLEN-1, ctxt);
        if (p == NULL) {
3660
            virDomainReportError(VIR_ERR_XML_ERROR,
3661 3662 3663 3664
                                 "%s", _("missing security model"));
            goto error;
        }
        def->seclabel.model = p;
3665

3666
        p = virXPathStringLimit("string(./seclabel/label[1])",
3667
                                VIR_SECURITY_LABEL_BUFLEN-1, ctxt);
3668
        if (p == NULL) {
3669
            virDomainReportError(VIR_ERR_XML_ERROR,
3670
                                 "%s", _("security label is missing"));
3671
            goto error;
3672 3673
        }

3674 3675 3676 3677 3678 3679
        def->seclabel.label = p;
    }

    /* Only parse imagelabel, if requested live XML for dynamic label */
    if (def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC &&
        !(flags & VIR_DOMAIN_XML_INACTIVE)) {
3680
        p = virXPathStringLimit("string(./seclabel/imagelabel[1])",
3681
                                VIR_SECURITY_LABEL_BUFLEN-1, ctxt);
3682
        if (p == NULL) {
3683
            virDomainReportError(VIR_ERR_XML_ERROR,
3684
                                 "%s", _("security imagelabel is missing"));
3685
            goto error;
3686
        }
3687 3688
        def->seclabel.imagelabel = p;
    }
3689 3690 3691 3692 3693 3694 3695

    return 0;

error:
    virSecurityLabelDefFree(def);
    return -1;
}
3696

3697
virDomainDeviceDefPtr virDomainDeviceDefParse(virCapsPtr caps,
3698
                                              const virDomainDefPtr def,
3699 3700
                                              const char *xmlStr,
                                              int flags)
3701 3702 3703 3704 3705 3706 3707 3708
{
    xmlDocPtr xml;
    xmlNodePtr node;
    virDomainDeviceDefPtr dev = NULL;

    if (!(xml = xmlReadDoc(BAD_CAST xmlStr, "device.xml", NULL,
                           XML_PARSE_NOENT | XML_PARSE_NONET |
                           XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) {
3709
        virDomainReportError(VIR_ERR_XML_ERROR, NULL);
3710 3711 3712 3713 3714
        goto error;
    }

    node = xmlDocGetRootElement(xml);
    if (node == NULL) {
3715
        virDomainReportError(VIR_ERR_XML_ERROR,
3716 3717 3718 3719 3720
                             "%s", _("missing root element"));
        goto error;
    }

    if (VIR_ALLOC(dev) < 0) {
3721
        virReportOOMError();
3722 3723 3724 3725 3726
        goto error;
    }

    if (xmlStrEqual(node->name, BAD_CAST "disk")) {
        dev->type = VIR_DOMAIN_DEVICE_DISK;
3727
        if (!(dev->data.disk = virDomainDiskDefParseXML(caps, node, flags)))
3728
            goto error;
3729 3730
    } else if (xmlStrEqual(node->name, BAD_CAST "filesystem")) {
        dev->type = VIR_DOMAIN_DEVICE_FS;
3731
        if (!(dev->data.fs = virDomainFSDefParseXML(node, flags)))
3732
            goto error;
3733 3734
    } else if (xmlStrEqual(node->name, BAD_CAST "interface")) {
        dev->type = VIR_DOMAIN_DEVICE_NET;
3735
        if (!(dev->data.net = virDomainNetDefParseXML(caps, node, flags)))
3736 3737
            goto error;
    } else if (xmlStrEqual(node->name, BAD_CAST "input")) {
3738
        dev->type = VIR_DOMAIN_DEVICE_INPUT;
3739
        if (!(dev->data.input = virDomainInputDefParseXML(def->os.type,
3740
                                                          node, flags)))
3741 3742 3743
            goto error;
    } else if (xmlStrEqual(node->name, BAD_CAST "sound")) {
        dev->type = VIR_DOMAIN_DEVICE_SOUND;
3744
        if (!(dev->data.sound = virDomainSoundDefParseXML(node, flags)))
3745
            goto error;
R
Richard Jones 已提交
3746 3747
    } else if (xmlStrEqual(node->name, BAD_CAST "watchdog")) {
        dev->type = VIR_DOMAIN_DEVICE_WATCHDOG;
3748
        if (!(dev->data.watchdog = virDomainWatchdogDefParseXML(node, flags)))
R
Richard Jones 已提交
3749
            goto error;
3750 3751
    } else if (xmlStrEqual(node->name, BAD_CAST "video")) {
        dev->type = VIR_DOMAIN_DEVICE_VIDEO;
3752
        if (!(dev->data.video = virDomainVideoDefParseXML(node, def, flags)))
3753
            goto error;
3754 3755
    } else if (xmlStrEqual(node->name, BAD_CAST "hostdev")) {
        dev->type = VIR_DOMAIN_DEVICE_HOSTDEV;
3756
        if (!(dev->data.hostdev = virDomainHostdevDefParseXML(node, flags)))
3757
            goto error;
3758 3759
    } else if (xmlStrEqual(node->name, BAD_CAST "controller")) {
        dev->type = VIR_DOMAIN_DEVICE_CONTROLLER;
3760
        if (!(dev->data.controller = virDomainControllerDefParseXML(node, flags)))
3761
            goto error;
3762 3763 3764 3765
    } else if (xmlStrEqual(node->name, BAD_CAST "graphics")) {
        dev->type = VIR_DOMAIN_DEVICE_GRAPHICS;
        if (!(dev->data.graphics = virDomainGraphicsDefParseXML(node, flags)))
            goto error;
3766
    } else {
3767
        virDomainReportError(VIR_ERR_XML_ERROR,
3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780
                             "%s", _("unknown device type"));
        goto error;
    }

    xmlFreeDoc(xml);

    return dev;

  error:
    xmlFreeDoc(xml);
    VIR_FREE(dev);
    return NULL;
}
M
Matthias Bolte 已提交
3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814
#endif /* !PROXY */


static void
virVirtualPortProfileFormat(virBufferPtr buf,
                            virVirtualPortProfileParamsPtr virtPort,
                            const char *indent)
{
    char uuidstr[VIR_UUID_STRING_BUFLEN];

    if (virtPort->virtPortType == VIR_VIRTUALPORT_NONE)
        return;

    virBufferVSprintf(buf, "%s<virtualport type='%s'>\n",
                      indent,
                      virVirtualPortTypeToString(virtPort->virtPortType));

    switch (virtPort->virtPortType) {
    case VIR_VIRTUALPORT_NONE:
    case VIR_VIRTUALPORT_TYPE_LAST:
        break;

    case VIR_VIRTUALPORT_8021QBG:
        virUUIDFormat(virtPort->u.virtPort8021Qbg.instanceID,
                      uuidstr);
        virBufferVSprintf(buf,
                          "%s  <parameters managerid='%d' typeid='%d' "
                          "typeidversion='%d' instanceid='%s'/>\n",
                          indent,
                          virtPort->u.virtPort8021Qbg.managerID,
                          virtPort->u.virtPort8021Qbg.typeID,
                          virtPort->u.virtPort8021Qbg.typeIDVersion,
                          uuidstr);
        break;
3815

M
Matthias Bolte 已提交
3816 3817 3818 3819 3820 3821 3822 3823 3824 3825
    case VIR_VIRTUALPORT_8021QBH:
        virBufferVSprintf(buf,
                          "%s  <parameters profileid='%s'/>\n",
                          indent,
                          virtPort->u.virtPort8021Qbh.profileID);
        break;
    }

    virBufferVSprintf(buf, "%s</virtualport>\n", indent);
}
3826 3827 3828

int virDomainDiskInsert(virDomainDefPtr def,
                        virDomainDiskDefPtr disk)
3829 3830
{

3831 3832 3833 3834 3835 3836
    if (VIR_REALLOC_N(def->disks, def->ndisks+1) < 0)
        return -1;

    virDomainDiskInsertPreAlloced(def, disk);

    return 0;
3837 3838
}

3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880
void virDomainDiskInsertPreAlloced(virDomainDefPtr def,
                                   virDomainDiskDefPtr disk)
{
    int i;
    /* Tenatively plan to insert disk at the end. */
    int insertAt = -1;

    /* Then work backwards looking for disks on
     * the same bus. If we find a disk with a drive
     * index greater than the new one, insert at
     * that position
     */
    for (i = (def->ndisks - 1) ; i >= 0 ; i--) {
        /* If bus matches and current disk is after
         * new disk, then new disk should go here */
        if (def->disks[i]->bus == disk->bus &&
            (virDiskNameToIndex(def->disks[i]->dst) >
             virDiskNameToIndex(disk->dst))) {
            insertAt = i;
        } else if (def->disks[i]->bus == disk->bus &&
                   insertAt == -1) {
            /* Last disk with match bus is before the
             * new disk, then put new disk just after
             */
            insertAt = i + 1;
        }
    }

    /* No disks with this bus yet, so put at end of list */
    if (insertAt == -1)
        insertAt = def->ndisks;

    if (insertAt < def->ndisks)
        memmove(def->disks + insertAt + 1,
                def->disks + insertAt,
                (sizeof(def->disks[0]) * (def->ndisks-insertAt)));

    def->disks[insertAt] = disk;
    def->ndisks++;
}


3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933
int virDomainControllerInsert(virDomainDefPtr def,
                              virDomainControllerDefPtr controller)
{

    if (VIR_REALLOC_N(def->controllers, def->ncontrollers+1) < 0)
        return -1;

    virDomainControllerInsertPreAlloced(def, controller);

    return 0;
}

void virDomainControllerInsertPreAlloced(virDomainDefPtr def,
                                         virDomainControllerDefPtr controller)
{
    int i;
    /* Tenatively plan to insert controller at the end. */
    int insertAt = -1;

    /* Then work backwards looking for controllers of
     * the same type. If we find a controller with a
     * index greater than the new one, insert at
     * that position
     */
    for (i = (def->ncontrollers - 1) ; i >= 0 ; i--) {
        /* If bus matches and current controller is after
         * new controller, then new controller should go here */
        if ((def->controllers[i]->type == controller->type) &&
            (def->controllers[i]->idx > controller->idx)) {
            insertAt = i;
        } else if (def->controllers[i]->type == controller->type &&
                   insertAt == -1) {
            /* Last controller with match bus is before the
             * new controller, then put new controller just after
             */
            insertAt = i + 1;
        }
    }

    /* No controllers with this bus yet, so put at end of list */
    if (insertAt == -1)
        insertAt = def->ncontrollers;

    if (insertAt < def->ncontrollers)
        memmove(def->controllers + insertAt + 1,
                def->controllers + insertAt,
                (sizeof(def->controllers[0]) * (def->ncontrollers-insertAt)));

    def->controllers[insertAt] = controller;
    def->ncontrollers++;
}


R
Richard W.M. Jones 已提交
3934
#ifndef PROXY
3935
static char *virDomainDefDefaultEmulator(virDomainDefPtr def,
3936 3937 3938 3939 3940 3941 3942
                                         virCapsPtr caps) {
    const char *type;
    const char *emulator;
    char *retemu;

    type = virDomainVirtTypeToString(def->virtType);
    if (!type) {
3943
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3944 3945 3946 3947 3948 3949 3950 3951 3952 3953
                             "%s", _("unknown virt type"));
        return NULL;
    }

    emulator = virCapabilitiesDefaultGuestEmulator(caps,
                                                   def->os.type,
                                                   def->os.arch,
                                                   type);

    if (!emulator) {
3954
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3955 3956 3957 3958 3959 3960 3961
                             _("no emulator for domain %s os type %s on architecture %s"),
                             type, def->os.type, def->os.arch);
        return NULL;
    }

    retemu = strdup(emulator);
    if (!retemu)
3962
        virReportOOMError();
3963 3964 3965 3966

    return retemu;
}

3967
static virDomainDefPtr virDomainDefParseXML(virCapsPtr caps,
3968
                                            xmlXPathContextPtr ctxt, int flags)
3969 3970 3971 3972
{
    xmlNodePtr *nodes = NULL, node = NULL;
    char *tmp = NULL;
    int i, n;
3973
    long id = -1;
3974 3975 3976
    virDomainDefPtr def;

    if (VIR_ALLOC(def) < 0) {
3977
        virReportOOMError();
3978 3979
        return NULL;
    }
3980 3981

    if (!(flags & VIR_DOMAIN_XML_INACTIVE))
3982
        if ((virXPathLong("string(./@id)", ctxt, &id)) < 0)
3983 3984
            id = -1;
    def->id = (int)id;
3985

3986
    /* Find out what type of virtualization to use */
3987
    if (!(tmp = virXPathString("string(./@type)", ctxt))) {
3988
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3989 3990 3991 3992 3993
                             "%s", _("missing domain type attribute"));
        goto error;
    }

    if ((def->virtType = virDomainVirtTypeFromString(tmp)) < 0) {
3994
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
3995 3996 3997 3998 3999 4000
                             _("invalid domain type %s"), tmp);
        goto error;
    }
    VIR_FREE(tmp);

    /* Extract domain name */
4001
    if (!(def->name = virXPathString("string(./name[1])", ctxt))) {
4002
        virDomainReportError(VIR_ERR_NO_NAME, NULL);
4003 4004 4005 4006
        goto error;
    }

    /* Extract domain uuid */
4007
    tmp = virXPathString("string(./uuid[1])", ctxt);
4008
    if (!tmp) {
4009
        if (virUUIDGenerate(def->uuid)) {
4010
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4011
                                 "%s", _("Failed to generate UUID"));
4012 4013 4014 4015
            goto error;
        }
    } else {
        if (virUUIDParse(tmp, def->uuid) < 0) {
4016
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4017 4018 4019 4020 4021 4022
                                 "%s", _("malformed uuid element"));
            goto error;
        }
        VIR_FREE(tmp);
    }

4023
    /* Extract documentation if present */
4024
    def->description = virXPathString("string(./description[1])", ctxt);
4025

4026
    /* Extract domain memory */
4027
    if (virXPathULong("string(./memory[1])", ctxt, &def->maxmem) < 0) {
4028
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4029 4030 4031 4032
                             "%s", _("missing memory element"));
        goto error;
    }

4033
    if (virXPathULong("string(./currentMemory[1])", ctxt, &def->memory) < 0)
4034 4035
        def->memory = def->maxmem;

4036
    node = virXPathNode("./memoryBacking/hugepages", ctxt);
4037 4038 4039
    if (node)
        def->hugepage_backed = 1;

4040
    if (virXPathULong("string(./vcpu[1])", ctxt, &def->vcpus) < 0)
4041 4042
        def->vcpus = 1;

4043
    tmp = virXPathString("string(./vcpu[1]/@cpuset)", ctxt);
4044 4045 4046 4047
    if (tmp) {
        char *set = tmp;
        def->cpumasklen = VIR_DOMAIN_CPUMASK_LEN;
        if (VIR_ALLOC_N(def->cpumask, def->cpumasklen) < 0) {
4048
            virReportOOMError();
4049 4050
            goto error;
        }
4051
        if (virDomainCpuSetParse((const char **)&set,
4052 4053 4054 4055 4056 4057
                                 0, def->cpumask,
                                 def->cpumasklen) < 0)
            goto error;
        VIR_FREE(tmp);
    }

4058
    n = virXPathNodeSet("./features/*", ctxt, &nodes);
4059 4060 4061
    if (n < 0)
        goto error;
    if (n) {
4062 4063 4064
        for (i = 0 ; i < n ; i++) {
            int val = virDomainFeatureTypeFromString((const char *)nodes[i]->name);
            if (val < 0) {
4065
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4066 4067 4068 4069 4070 4071
                                     _("unexpected feature %s"),
                                     nodes[i]->name);
                goto error;
            }
            def->features |= (1 << val);
        }
4072
        VIR_FREE(nodes);
4073 4074
    }

4075
    if (virDomainLifecycleParseXML(ctxt, "string(./on_reboot[1])",
4076 4077 4078
                                   &def->onReboot, VIR_DOMAIN_LIFECYCLE_RESTART) < 0)
        goto error;

4079
    if (virDomainLifecycleParseXML(ctxt, "string(./on_poweroff[1])",
4080 4081 4082
                                   &def->onPoweroff, VIR_DOMAIN_LIFECYCLE_DESTROY) < 0)
        goto error;

4083
    if (virDomainLifecycleParseXML(ctxt, "string(./on_crash[1])",
4084 4085 4086
                                   &def->onCrash, VIR_DOMAIN_LIFECYCLE_DESTROY) < 0)
        goto error;

4087
    tmp = virXPathString("string(./clock/@offset)", ctxt);
4088 4089 4090 4091 4092 4093 4094 4095 4096 4097
    if (tmp) {
        if ((def->clock.offset = virDomainClockOffsetTypeFromString(tmp)) < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("unknown clock offset '%s'"), tmp);
            goto error;
        }
        VIR_FREE(tmp);
    } else {
        def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_UTC;
    }
4098 4099 4100
    switch (def->clock.offset) {
    case VIR_DOMAIN_CLOCK_OFFSET_VARIABLE:
        if (virXPathLongLong("number(./clock/@adjustment)", ctxt,
4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111
                             &def->clock.data.adjustment) < 0)
            def->clock.data.adjustment = 0;
        break;

    case VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE:
        def->clock.data.timezone = virXPathString("string(./clock/@timezone)", ctxt);
        if (!def->clock.data.timezone) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                 _("missing 'timezone' attribute for clock with offset='timezone'"));
            goto error;
        }
4112 4113
        break;
    }
4114

4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132
    if ((n = virXPathNodeSet("./clock/timer", ctxt, &nodes)) < 0) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                             "%s", _("failed to parse timers"));
        goto error;
    }
    if (n && VIR_ALLOC_N(def->clock.timers, n) < 0)
        goto no_memory;
    for (i = 0 ; i < n ; i++) {
        virDomainTimerDefPtr timer = virDomainTimerDefParseXML(nodes[i],
                                                               ctxt,
                                                               flags);
        if (!timer)
            goto error;

        def->clock.timers[def->clock.ntimers++] = timer;
    }
    VIR_FREE(nodes);

4133 4134
    def->os.bootloader = virXPathString("string(./bootloader)", ctxt);
    def->os.bootloaderArgs = virXPathString("string(./bootloader_args)", ctxt);
4135

4136
    def->os.type = virXPathString("string(./os/type[1])", ctxt);
4137 4138 4139 4140
    if (!def->os.type) {
        if (def->os.bootloader) {
            def->os.type = strdup("xen");
            if (!def->os.type) {
4141
                virReportOOMError();
4142 4143 4144
                goto error;
            }
        } else {
4145
            virDomainReportError(VIR_ERR_OS_TYPE,
4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158
                                 "%s", _("no OS type"));
            goto error;
        }
    }
    /*
     * HACK: For xen driver we previously used bogus 'linux' as the
     * os type for paravirt, whereas capabilities declare it to
     * be 'xen'. So we accept the former and convert
     */
    if (STREQ(def->os.type, "linux") &&
        def->virtType == VIR_DOMAIN_VIRT_XEN) {
        VIR_FREE(def->os.type);
        if (!(def->os.type = strdup("xen"))) {
4159
            virReportOOMError();
4160 4161 4162 4163 4164
            goto error;
        }
    }

    if (!virCapabilitiesSupportsGuestOSType(caps, def->os.type)) {
4165
        virDomainReportError(VIR_ERR_OS_TYPE,
4166 4167 4168 4169
                             "%s", def->os.type);
        goto error;
    }

4170
    def->os.arch = virXPathString("string(./os/type[1]/@arch)", ctxt);
4171 4172
    if (def->os.arch) {
        if (!virCapabilitiesSupportsGuestArch(caps, def->os.type, def->os.arch)) {
4173
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4174 4175 4176 4177 4178
                                 _("os type '%s' & arch '%s' combination is not supported"),
                                 def->os.type, def->os.arch);
            goto error;
        }
    } else {
4179
        const char *defaultArch = virCapabilitiesDefaultGuestArch(caps, def->os.type, virDomainVirtTypeToString(def->virtType));
4180
        if (defaultArch == NULL) {
4181
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4182 4183 4184 4185 4186
                                 _("no supported architecture for os type '%s'"),
                                 def->os.type);
            goto error;
        }
        if (!(def->os.arch = strdup(defaultArch))) {
4187
            virReportOOMError();
4188 4189 4190 4191
            goto error;
        }
    }

4192
    def->os.machine = virXPathString("string(./os/type[1]/@machine)", ctxt);
4193 4194 4195
    if (!def->os.machine) {
        const char *defaultMachine = virCapabilitiesDefaultGuestMachine(caps,
                                                                        def->os.type,
4196 4197
                                                                        def->os.arch,
                                                                        virDomainVirtTypeToString(def->virtType));
4198 4199
        if (defaultMachine != NULL) {
            if (!(def->os.machine = strdup(defaultMachine))) {
4200
                virReportOOMError();
4201 4202 4203 4204 4205
                goto error;
            }
        }
    }

4206 4207 4208 4209 4210 4211 4212 4213 4214 4215
    /*
     * Booting options for different OS types....
     *
     *   - A bootloader (and optional kernel+initrd)  (xen)
     *   - A kernel + initrd                          (xen)
     *   - A boot device (and optional kernel+initrd) (hvm)
     *   - An init script                             (exe)
     */

    if (STREQ(def->os.type, "exe")) {
4216
        def->os.init = virXPathString("string(./os/init[1])", ctxt);
4217 4218 4219
    }

    if (STREQ(def->os.type, "xen") ||
4220 4221
        STREQ(def->os.type, "hvm") ||
        STREQ(def->os.type, "uml")) {
4222 4223 4224 4225 4226
        def->os.kernel = virXPathString("string(./os/kernel[1])", ctxt);
        def->os.initrd = virXPathString("string(./os/initrd[1])", ctxt);
        def->os.cmdline = virXPathString("string(./os/cmdline[1])", ctxt);
        def->os.root = virXPathString("string(./os/root[1])", ctxt);
        def->os.loader = virXPathString("string(./os/loader[1])", ctxt);
4227
    }
4228

4229
    if (STREQ(def->os.type, "hvm")) {
4230
        /* analysis of the boot devices */
4231
        if ((n = virXPathNodeSet("./os/boot", ctxt, &nodes)) < 0) {
4232
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4233 4234 4235 4236 4237 4238 4239
                                 "%s", _("cannot extract boot device"));
            goto error;
        }
        for (i = 0 ; i < n && i < VIR_DOMAIN_BOOT_LAST ; i++) {
            int val;
            char *dev = virXMLPropString(nodes[i], "dev");
            if (!dev) {
4240
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4241 4242 4243 4244
                                     "%s", _("missing boot device"));
                goto error;
            }
            if ((val = virDomainBootTypeFromString(dev)) < 0) {
4245
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260
                                     _("unknown boot device '%s'"),
                                     dev);
                VIR_FREE(dev);
                goto error;
            }
            VIR_FREE(dev);
            def->os.bootDevs[def->os.nBootDevs++] = val;
        }
        if (def->os.nBootDevs == 0) {
            def->os.nBootDevs = 1;
            def->os.bootDevs[0] = VIR_DOMAIN_BOOT_DISK;
        }
        VIR_FREE(nodes);
    }

4261
    def->emulator = virXPathString("string(./devices/emulator[1])", ctxt);
4262
    if (!def->emulator && virCapabilitiesIsEmulatorRequired(caps)) {
4263
        def->emulator = virDomainDefDefaultEmulator(def, caps);
4264 4265 4266
        if (!def->emulator)
            goto error;
    }
4267 4268

    /* analysis of the disk devices */
4269
    if ((n = virXPathNodeSet("./devices/disk", ctxt, &nodes)) < 0) {
4270
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4271 4272 4273
                             "%s", _("cannot extract disk devices"));
        goto error;
    }
4274 4275
    if (n && VIR_ALLOC_N(def->disks, n) < 0)
        goto no_memory;
4276
    for (i = 0 ; i < n ; i++) {
4277
        virDomainDiskDefPtr disk = virDomainDiskDefParseXML(caps, nodes[i],
4278
                                                            flags);
4279 4280 4281
        if (!disk)
            goto error;

4282
        def->disks[def->ndisks++] = disk;
4283 4284 4285
    }
    VIR_FREE(nodes);

4286
    /* analysis of the controller devices */
4287
    if ((n = virXPathNodeSet("./devices/controller", ctxt, &nodes)) < 0) {
4288
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4289 4290 4291 4292 4293 4294
                             "%s", _("cannot extract controller devices"));
        goto error;
    }
    if (n && VIR_ALLOC_N(def->controllers, n) < 0)
        goto no_memory;
    for (i = 0 ; i < n ; i++) {
4295
        virDomainControllerDefPtr controller = virDomainControllerDefParseXML(nodes[i],
4296 4297 4298 4299 4300 4301 4302 4303
                                                                              flags);
        if (!controller)
            goto error;

        def->controllers[def->ncontrollers++] = controller;
    }
    VIR_FREE(nodes);

4304
    /* analysis of the filesystems */
4305
    if ((n = virXPathNodeSet("./devices/filesystem", ctxt, &nodes)) < 0) {
4306
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4307 4308 4309
                             "%s", _("cannot extract filesystem devices"));
        goto error;
    }
4310 4311 4312
    if (n && VIR_ALLOC_N(def->fss, n) < 0)
        goto no_memory;
    for (i = 0 ; i < n ; i++) {
4313
        virDomainFSDefPtr fs = virDomainFSDefParseXML(nodes[i],
4314
                                                      flags);
4315 4316 4317
        if (!fs)
            goto error;

4318
        def->fss[def->nfss++] = fs;
4319 4320 4321
    }
    VIR_FREE(nodes);

4322
    /* analysis of the network devices */
4323
    if ((n = virXPathNodeSet("./devices/interface", ctxt, &nodes)) < 0) {
4324
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4325 4326 4327
                             "%s", _("cannot extract network devices"));
        goto error;
    }
4328 4329 4330
    if (n && VIR_ALLOC_N(def->nets, n) < 0)
        goto no_memory;
    for (i = 0 ; i < n ; i++) {
4331
        virDomainNetDefPtr net = virDomainNetDefParseXML(caps,
4332 4333
                                                         nodes[i],
                                                         flags);
4334 4335 4336
        if (!net)
            goto error;

4337
        def->nets[def->nnets++] = net;
4338 4339 4340 4341 4342
    }
    VIR_FREE(nodes);


    /* analysis of the character devices */
4343
    if ((n = virXPathNodeSet("./devices/parallel", ctxt, &nodes)) < 0) {
4344
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4345 4346 4347
                             "%s", _("cannot extract parallel devices"));
        goto error;
    }
4348 4349 4350 4351
    if (n && VIR_ALLOC_N(def->parallels, n) < 0)
        goto no_memory;

    for (i = 0 ; i < n ; i++) {
4352
        virDomainChrDefPtr chr = virDomainChrDefParseXML(nodes[i],
4353
                                                         flags);
4354 4355 4356
        if (!chr)
            goto error;

4357
        chr->target.port = i;
4358
        def->parallels[def->nparallels++] = chr;
4359 4360 4361
    }
    VIR_FREE(nodes);

4362
    if ((n = virXPathNodeSet("./devices/serial", ctxt, &nodes)) < 0) {
4363
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4364 4365 4366
                             "%s", _("cannot extract serial devices"));
        goto error;
    }
4367 4368 4369 4370
    if (n && VIR_ALLOC_N(def->serials, n) < 0)
        goto no_memory;

    for (i = 0 ; i < n ; i++) {
4371
        virDomainChrDefPtr chr = virDomainChrDefParseXML(nodes[i],
4372
                                                         flags);
4373 4374 4375
        if (!chr)
            goto error;

4376
        chr->target.port = i;
4377
        def->serials[def->nserials++] = chr;
4378 4379 4380
    }
    VIR_FREE(nodes);

4381
    if ((node = virXPathNode("./devices/console[1]", ctxt)) != NULL) {
4382
        virDomainChrDefPtr chr = virDomainChrDefParseXML(node,
4383
                                                         flags);
4384 4385
        if (!chr)
            goto error;
4386

4387
        chr->target.port = 0;
4388 4389 4390 4391 4392 4393 4394 4395
        /*
         * For HVM console actually created a serial device
         * while for non-HVM it was a parvirt console
         */
        if (STREQ(def->os.type, "hvm")) {
            if (def->nserials != 0) {
                virDomainChrDefFree(chr);
            } else {
4396 4397 4398 4399 4400 4401
                if (VIR_ALLOC_N(def->serials, 1) < 0) {
                    virDomainChrDefFree(chr);
                    goto no_memory;
                }
                def->nserials = 1;
                def->serials[0] = chr;
4402
                chr->targetType = VIR_DOMAIN_CHR_TARGET_TYPE_SERIAL;
4403
            }
4404 4405
        } else {
            def->console = chr;
4406 4407 4408
        }
    }

4409
    if ((n = virXPathNodeSet("./devices/channel", ctxt, &nodes)) < 0) {
4410
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4411 4412 4413 4414 4415 4416 4417
                             "%s", _("cannot extract channel devices"));
        goto error;
    }
    if (n && VIR_ALLOC_N(def->channels, n) < 0)
        goto no_memory;

    for (i = 0 ; i < n ; i++) {
4418
        virDomainChrDefPtr chr = virDomainChrDefParseXML(nodes[i],
4419 4420 4421 4422 4423
                                                         flags);
        if (!chr)
            goto error;

        def->channels[def->nchannels++] = chr;
4424

4425 4426 4427 4428
        if (chr->targetType == VIR_DOMAIN_CHR_TARGET_TYPE_VIRTIO &&
            chr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
            chr->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL;

4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442
        if (chr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL &&
            chr->info.addr.vioserial.port == 0) {
            int maxport = -1;
            int j;
            for (j = 0 ; j < i ; j++) {
                virDomainChrDefPtr thischr = def->channels[j];
                if (thischr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL &&
                    thischr->info.addr.vioserial.controller == chr->info.addr.vioserial.controller &&
                    thischr->info.addr.vioserial.bus == chr->info.addr.vioserial.bus &&
                    (int)thischr->info.addr.vioserial.port > maxport)
                    maxport = thischr->info.addr.vioserial.port;
            }
            chr->info.addr.vioserial.port = maxport + 1;
        }
4443 4444 4445
    }
    VIR_FREE(nodes);

4446 4447

    /* analysis of the input devices */
4448
    if ((n = virXPathNodeSet("./devices/input", ctxt, &nodes)) < 0) {
4449
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4450 4451 4452
                             "%s", _("cannot extract input devices"));
        goto error;
    }
4453 4454 4455 4456
    if (n && VIR_ALLOC_N(def->inputs, n) < 0)
        goto no_memory;

    for (i = 0 ; i < n ; i++) {
4457
        virDomainInputDefPtr input = virDomainInputDefParseXML(def->os.type,
4458 4459
                                                               nodes[i],
                                                               flags);
4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476
        if (!input)
            goto error;


        /* With QEMU / KVM / Xen graphics, mouse + PS/2 is implicit
         * with graphics, so don't store it.
         * XXX will this be true for other virt types ? */
        if ((STREQ(def->os.type, "hvm") &&
             input->bus == VIR_DOMAIN_INPUT_BUS_PS2 &&
             input->type == VIR_DOMAIN_INPUT_TYPE_MOUSE) ||
            (STRNEQ(def->os.type, "hvm") &&
             input->bus == VIR_DOMAIN_INPUT_BUS_XEN &&
             input->type == VIR_DOMAIN_INPUT_TYPE_MOUSE)) {
            virDomainInputDefFree(input);
            continue;
        }

4477
        def->inputs[def->ninputs++] = input;
4478 4479 4480
    }
    VIR_FREE(nodes);

4481
    /* analysis of the graphics devices */
4482
    if ((n = virXPathNodeSet("./devices/graphics", ctxt, &nodes)) < 0) {
4483
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4484 4485 4486
                             "%s", _("cannot extract graphics devices"));
        goto error;
    }
4487 4488 4489
    if (n && VIR_ALLOC_N(def->graphics, n) < 0)
        goto no_memory;
    for (i = 0 ; i < n ; i++) {
4490
        virDomainGraphicsDefPtr graphics = virDomainGraphicsDefParseXML(nodes[i],
4491
                                                                        flags);
4492 4493 4494
        if (!graphics)
            goto error;

4495
        def->graphics[def->ngraphics++] = graphics;
4496 4497 4498 4499
    }
    VIR_FREE(nodes);

    /* If graphics are enabled, there's an implicit PS2 mouse */
4500
    if (def->ngraphics > 0) {
4501 4502 4503
        virDomainInputDefPtr input;

        if (VIR_ALLOC(input) < 0) {
4504
            virReportOOMError();
4505 4506 4507 4508 4509 4510 4511 4512 4513
            goto error;
        }
        if (STREQ(def->os.type, "hvm")) {
            input->type = VIR_DOMAIN_INPUT_TYPE_MOUSE;
            input->bus = VIR_DOMAIN_INPUT_BUS_PS2;
        } else {
            input->type = VIR_DOMAIN_INPUT_TYPE_MOUSE;
            input->bus = VIR_DOMAIN_INPUT_BUS_XEN;
        }
4514 4515 4516 4517 4518 4519 4520

        if (VIR_REALLOC_N(def->inputs, def->ninputs + 1) < 0) {
            virDomainInputDefFree(input);
            goto no_memory;
        }
        def->inputs[def->ninputs] = input;
        def->ninputs++;
4521 4522 4523 4524
    }


    /* analysis of the sound devices */
4525
    if ((n = virXPathNodeSet("./devices/sound", ctxt, &nodes)) < 0) {
4526
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4527 4528 4529
                             "%s", _("cannot extract sound devices"));
        goto error;
    }
4530 4531 4532
    if (n && VIR_ALLOC_N(def->sounds, n) < 0)
        goto no_memory;
    for (i = 0 ; i < n ; i++) {
4533
        virDomainSoundDefPtr sound = virDomainSoundDefParseXML(nodes[i],
4534
                                                               flags);
4535 4536 4537
        if (!sound)
            goto error;

4538
        def->sounds[def->nsounds++] = sound;
4539 4540 4541
    }
    VIR_FREE(nodes);

4542
    /* analysis of the video devices */
4543
    if ((n = virXPathNodeSet("./devices/video", ctxt, &nodes)) < 0) {
4544
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4545 4546 4547 4548 4549 4550
                             "%s", _("cannot extract video devices"));
        goto error;
    }
    if (n && VIR_ALLOC_N(def->videos, n) < 0)
        goto no_memory;
    for (i = 0 ; i < n ; i++) {
4551
        virDomainVideoDefPtr video = virDomainVideoDefParseXML(nodes[i],
4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567
                                                               def,
                                                               flags);
        if (!video)
            goto error;
        def->videos[def->nvideos++] = video;
    }
    VIR_FREE(nodes);

    /* For backwards compatability, if no <video> tag is set but there
     * is a <graphics> tag, then we add a single video tag */
    if (def->ngraphics && !def->nvideos) {
        virDomainVideoDefPtr video;
        if (VIR_ALLOC(video) < 0)
            goto no_memory;
        video->type = virDomainVideoDefaultType(def);
        if (video->type < 0) {
4568
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581
                                 _("cannot determine default video type"));
            VIR_FREE(video);
            goto error;
        }
        video->vram = virDomainVideoDefaultRAM(def, video->type);
        video->heads = 1;
        if (VIR_ALLOC_N(def->videos, 1) < 0) {
            virDomainVideoDefFree(video);
            goto no_memory;
        }
        def->videos[def->nvideos++] = video;
    }

4582
    /* analysis of the host devices */
4583
    if ((n = virXPathNodeSet("./devices/hostdev", ctxt, &nodes)) < 0) {
4584
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4585 4586 4587
                             "%s", _("cannot extract host devices"));
        goto error;
    }
4588 4589
    if (n && VIR_ALLOC_N(def->hostdevs, n) < 0)
        goto no_memory;
4590
    for (i = 0 ; i < n ; i++) {
4591
        virDomainHostdevDefPtr hostdev = virDomainHostdevDefParseXML(nodes[i],
4592
                                                                     flags);
4593 4594 4595
        if (!hostdev)
            goto error;

4596
        def->hostdevs[def->nhostdevs++] = hostdev;
4597 4598 4599
    }
    VIR_FREE(nodes);

R
Richard Jones 已提交
4600 4601
    /* analysis of the watchdog devices */
    def->watchdog = NULL;
4602
    if ((n = virXPathNodeSet("./devices/watchdog", ctxt, &nodes)) < 0) {
4603
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
R
Richard Jones 已提交
4604 4605 4606 4607
                             "%s", _("cannot extract watchdog devices"));
        goto error;
    }
    if (n > 1) {
4608
        virDomainReportError (VIR_ERR_INTERNAL_ERROR,
R
Richard Jones 已提交
4609 4610 4611 4612 4613
                              "%s", _("only a single watchdog device is supported"));
        goto error;
    }
    if (n > 0) {
        virDomainWatchdogDefPtr watchdog =
4614
            virDomainWatchdogDefParseXML(nodes[0], flags);
R
Richard Jones 已提交
4615 4616 4617 4618 4619 4620 4621
        if (!watchdog)
            goto error;

        def->watchdog = watchdog;
        VIR_FREE(nodes);
    }

4622
    /* analysis of security label */
4623
    if (virSecurityLabelDefParseXML(def, ctxt, flags) == -1)
4624 4625
        goto error;

4626
    if ((node = virXPathNode("./cpu[1]", ctxt)) != NULL) {
4627 4628
        xmlNodePtr oldnode = ctxt->node;
        ctxt->node = node;
4629
        def->cpu = virCPUDefParseXML(node, ctxt, VIR_CPU_TYPE_GUEST);
4630 4631 4632 4633 4634 4635
        ctxt->node = oldnode;

        if (def->cpu == NULL)
            goto error;
    }

4636 4637 4638 4639 4640
    /* Auto-add any implied controllers which aren't present
     */
    if (virDomainDefAddImplicitControllers(def) < 0)
        goto error;

4641 4642
    return def;

4643
no_memory:
4644
    virReportOOMError();
4645 4646
    /* fallthrough */

4647 4648 4649 4650 4651 4652 4653
 error:
    VIR_FREE(tmp);
    VIR_FREE(nodes);
    virDomainDefFree(def);
    return NULL;
}

4654

4655
static virDomainObjPtr virDomainObjParseXML(virCapsPtr caps,
4656 4657 4658 4659 4660 4661 4662 4663
                                            xmlXPathContextPtr ctxt)
{
    char *tmp = NULL;
    long val;
    xmlNodePtr config;
    xmlNodePtr oldnode;
    virDomainObjPtr obj;

4664
    if (!(obj = virDomainObjNew(caps)))
4665 4666
        return NULL;

4667
    if (!(config = virXPathNode("./domain", ctxt))) {
4668
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4669 4670 4671 4672 4673 4674
                             "%s", _("no domain config"));
        goto error;
    }

    oldnode = ctxt->node;
    ctxt->node = config;
4675
    obj->def = virDomainDefParseXML(caps, ctxt,
4676
                                    VIR_DOMAIN_XML_INTERNAL_STATUS);
4677 4678 4679 4680
    ctxt->node = oldnode;
    if (!obj->def)
        goto error;

4681
    if (!(tmp = virXPathString("string(./@state)", ctxt))) {
4682
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4683 4684 4685 4686
                             "%s", _("missing domain state"));
        goto error;
    }
    if ((obj->state = virDomainStateTypeFromString(tmp)) < 0) {
4687
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4688 4689 4690 4691 4692 4693
                             _("invalid domain state '%s'"), tmp);
        VIR_FREE(tmp);
        goto error;
    }
    VIR_FREE(tmp);

4694
    if ((virXPathLong("string(./@pid)", ctxt, &val)) < 0) {
4695
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4696 4697 4698 4699 4700
                             "%s", _("invalid pid"));
        goto error;
    }
    obj->pid = (pid_t)val;

4701 4702
    if (caps->privateDataXMLParse &&
        ((caps->privateDataXMLParse)(ctxt, obj->privateData)) < 0)
4703
        goto error;
4704

4705 4706 4707
    return obj;

error:
4708
    virDomainObjUnref(obj);
4709 4710 4711 4712
    return NULL;
}


J
Jiri Denemark 已提交
4713 4714 4715 4716 4717
static virDomainDefPtr
virDomainDefParse(const char *xmlStr,
                  const char *filename,
                  virCapsPtr caps,
                  int flags)
4718
{
J
Jiri Denemark 已提交
4719 4720 4721 4722 4723 4724
    xmlDocPtr xml;
    virDomainDefPtr def = NULL;

    if ((xml = virXMLParse(filename, xmlStr, "domain.xml"))) {
        def = virDomainDefParseNode(caps, xml, xmlDocGetRootElement(xml), flags);
        xmlFreeDoc(xml);
4725
    }
J
Jiri Denemark 已提交
4726 4727

    return def;
4728
}
4729

4730
virDomainDefPtr virDomainDefParseString(virCapsPtr caps,
4731 4732
                                        const char *xmlStr,
                                        int flags)
4733
{
J
Jiri Denemark 已提交
4734
    return virDomainDefParse(xmlStr, NULL, caps, flags);
4735 4736
}

4737
virDomainDefPtr virDomainDefParseFile(virCapsPtr caps,
J
Jiri Denemark 已提交
4738 4739
                                      const char *filename,
                                      int flags)
4740
{
J
Jiri Denemark 已提交
4741
    return virDomainDefParse(NULL, filename, caps, flags);
4742 4743 4744
}


4745
virDomainDefPtr virDomainDefParseNode(virCapsPtr caps,
4746
                                      xmlDocPtr xml,
4747 4748
                                      xmlNodePtr root,
                                      int flags)
4749 4750 4751 4752 4753
{
    xmlXPathContextPtr ctxt = NULL;
    virDomainDefPtr def = NULL;

    if (!xmlStrEqual(root->name, BAD_CAST "domain")) {
4754
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4755 4756 4757 4758 4759 4760
                              "%s", _("incorrect root element"));
        goto cleanup;
    }

    ctxt = xmlXPathNewContext(xml);
    if (ctxt == NULL) {
4761
        virReportOOMError();
4762 4763 4764 4765
        goto cleanup;
    }

    ctxt->node = root;
4766
    def = virDomainDefParseXML(caps, ctxt, flags);
4767 4768 4769 4770 4771

cleanup:
    xmlXPathFreeContext(ctxt);
    return def;
}
4772 4773


4774
virDomainObjPtr virDomainObjParseFile(virCapsPtr caps,
4775 4776
                                      const char *filename)
{
J
Jiri Denemark 已提交
4777
    xmlDocPtr xml;
4778 4779
    virDomainObjPtr obj = NULL;

J
Jiri Denemark 已提交
4780 4781 4782
    if ((xml = virXMLParseFile(filename))) {
        obj = virDomainObjParseNode(caps, xml, xmlDocGetRootElement(xml));
        xmlFreeDoc(xml);
4783 4784 4785 4786 4787 4788
    }

    return obj;
}


4789
virDomainObjPtr virDomainObjParseNode(virCapsPtr caps,
4790 4791 4792 4793 4794 4795 4796
                                      xmlDocPtr xml,
                                      xmlNodePtr root)
{
    xmlXPathContextPtr ctxt = NULL;
    virDomainObjPtr obj = NULL;

    if (!xmlStrEqual(root->name, BAD_CAST "domstatus")) {
4797
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
4798 4799 4800 4801 4802 4803
                             "%s", _("incorrect root element"));
        goto cleanup;
    }

    ctxt = xmlXPathNewContext(xml);
    if (ctxt == NULL) {
4804
        virReportOOMError();
4805 4806 4807 4808
        goto cleanup;
    }

    ctxt->node = root;
4809
    obj = virDomainObjParseXML(caps, ctxt);
4810 4811 4812 4813 4814 4815

cleanup:
    xmlXPathFreeContext(ctxt);
    return obj;
}

4816 4817 4818
static int virDomainDefMaybeAddController(virDomainDefPtr def,
                                          int type,
                                          int idx)
4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833
{
    int found = 0;
    int i;
    virDomainControllerDefPtr cont;

    for (i = 0 ; (i < def->ncontrollers) && !found; i++) {
        if (def->controllers[i]->type == type &&
            def->controllers[i]->idx == idx)
            found = 1;
    }

    if (found)
        return 0;

    if (VIR_ALLOC(cont) < 0) {
4834
        virReportOOMError();
4835 4836 4837 4838 4839
        return -1;
    }

    cont->type = type;
    cont->idx = idx;
4840
    cont->model = -1;
4841

4842 4843 4844 4845 4846 4847
    if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL) {
        cont->opts.vioserial.ports = -1;
        cont->opts.vioserial.vectors = -1;
    }


4848 4849
    if (VIR_REALLOC_N(def->controllers, def->ncontrollers+1) < 0) {
        VIR_FREE(cont);
4850
        virReportOOMError();
4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877
        return -1;
    }
    def->controllers[def->ncontrollers] = cont;
    def->ncontrollers++;

    return 0;
}

static int virDomainDefAddDiskControllersForType(virDomainDefPtr def,
                                                 int controllerType,
                                                 int diskBus)
{
    int i;
    int maxController = -1;

    for (i = 0 ; i < def->ndisks ; i++) {
        if (def->disks[i]->bus != diskBus)
            continue;

        if (def->disks[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE)
            continue;

        if ((int)def->disks[i]->info.addr.drive.controller > maxController)
            maxController = def->disks[i]->info.addr.drive.controller;
    }

    for (i = 0 ; i <= maxController ; i++) {
4878
        if (virDomainDefMaybeAddController(def, controllerType, i) < 0)
4879 4880 4881 4882 4883 4884 4885
            return -1;
    }

    return 0;
}


4886 4887 4888 4889
static int virDomainDefMaybeAddVirtioSerialController(virDomainDefPtr def)
{
    /* Look for any virtio serial device */
    int i;
4890

4891 4892 4893 4894
    for (i = 0 ; i < def->nchannels ; i++) {
        virDomainChrDefPtr channel = def->channels[i];

        if (channel->targetType == VIR_DOMAIN_CHR_TARGET_TYPE_VIRTIO) {
4895 4896 4897 4898
            int idx = 0;
            if (channel->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL)
                idx = channel->info.addr.vioserial.controller;

4899
            if (virDomainDefMaybeAddController(def,
4900
                VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL, idx) < 0)
4901 4902 4903 4904 4905 4906 4907 4908
                return -1;
        }
    }

    return 0;
}


4909
/*
4910
 * Based on the declared <address/> info for any devices,
4911 4912 4913 4914
 * add neccessary drive controllers which are not already present
 * in the XML. This is for compat with existing apps which will
 * not know/care about <controller> info in the XML
 */
4915
int virDomainDefAddImplicitControllers(virDomainDefPtr def)
4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931
{
    if (virDomainDefAddDiskControllersForType(def,
                                              VIR_DOMAIN_CONTROLLER_TYPE_SCSI,
                                              VIR_DOMAIN_DISK_BUS_SCSI) < 0)
        return -1;

    if (virDomainDefAddDiskControllersForType(def,
                                              VIR_DOMAIN_CONTROLLER_TYPE_FDC,
                                              VIR_DOMAIN_DISK_BUS_FDC) < 0)
        return -1;

    if (virDomainDefAddDiskControllersForType(def,
                                              VIR_DOMAIN_CONTROLLER_TYPE_IDE,
                                              VIR_DOMAIN_DISK_BUS_IDE) < 0)
        return -1;

4932 4933 4934
    if (virDomainDefMaybeAddVirtioSerialController(def) < 0)
        return -1;

4935 4936 4937 4938
    return 0;
}


4939
#endif /* ! PROXY */
4940 4941

/************************************************************************
4942 4943 4944
 *                                                                        *
 * Parser and converter for the CPUset strings used in libvirt                *
 *                                                                        *
4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986
 ************************************************************************/
/**
 * virDomainCpuNumberParse
 * @str: pointer to the char pointer used
 * @maxcpu: maximum CPU number allowed
 *
 * Parse a CPU number
 *
 * Returns the CPU number or -1 in case of error. @str will be
 *         updated to skip the number.
 */
static int
virDomainCpuNumberParse(const char **str, int maxcpu)
{
    int ret = 0;
    const char *cur = *str;

    if (!c_isdigit(*cur))
        return (-1);

    while (c_isdigit(*cur)) {
        ret = ret * 10 + (*cur - '0');
        if (ret >= maxcpu)
            return (-1);
        cur++;
    }
    *str = cur;
    return (ret);
}

/**
 * virDomainCpuSetFormat:
 * @conn: connection
 * @cpuset: pointer to a char array for the CPU set
 * @maxcpu: number of elements available in @cpuset
 *
 * Serialize the cpuset to a string
 *
 * Returns the new string NULL in case of error. The string need to be
 *         freed by the caller.
 */
char *
4987
virDomainCpuSetFormat(char *cpuset, int maxcpu)
4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    int start, cur;
    int first = 1;

    if ((cpuset == NULL) || (maxcpu <= 0) || (maxcpu > 100000))
        return (NULL);

    cur = 0;
    start = -1;
    while (cur < maxcpu) {
        if (cpuset[cur]) {
            if (start == -1)
                start = cur;
        } else if (start != -1) {
            if (!first)
                virBufferAddLit(&buf, ",");
            else
                first = 0;
            if (cur == start + 1)
                virBufferVSprintf(&buf, "%d", start);
            else
                virBufferVSprintf(&buf, "%d-%d", start, cur - 1);
            start = -1;
        }
        cur++;
    }
    if (start != -1) {
        if (!first)
            virBufferAddLit(&buf, ",");
        if (maxcpu == start + 1)
            virBufferVSprintf(&buf, "%d", start);
        else
            virBufferVSprintf(&buf, "%d-%d", start, maxcpu - 1);
    }

    if (virBufferError(&buf)) {
5025
        virBufferFreeAndReset(&buf);
5026
        virReportOOMError();
5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049
        return NULL;
    }

    return virBufferContentAndReset(&buf);
}

/**
 * virDomainCpuSetParse:
 * @conn: connection
 * @str: pointer to a CPU set string pointer
 * @sep: potential character used to mark the end of string if not 0
 * @cpuset: pointer to a char array for the CPU set
 * @maxcpu: number of elements available in @cpuset
 *
 * Parse the cpu set, it will set the value for enabled CPUs in the @cpuset
 * to 1, and 0 otherwise. The syntax allows coma separated entries each
 * can be either a CPU number, ^N to unset that CPU or N-M for ranges.
 *
 * Returns the number of CPU found in that set, or -1 in case of error.
 *         @cpuset is modified accordingly to the value parsed.
 *         @str is updated to the end of the part parsed
 */
int
5050
virDomainCpuSetParse(const char **str, char sep,
5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130
                     char *cpuset, int maxcpu)
{
    const char *cur;
    int ret = 0;
    int i, start, last;
    int neg = 0;

    if ((str == NULL) || (cpuset == NULL) || (maxcpu <= 0) ||
        (maxcpu > 100000))
        return (-1);

    cur = *str;
    virSkipSpaces(&cur);
    if (*cur == 0)
        goto parse_error;

    /* initialize cpumap to all 0s */
    for (i = 0; i < maxcpu; i++)
        cpuset[i] = 0;
    ret = 0;

    while ((*cur != 0) && (*cur != sep)) {
        /*
         * 3 constructs are allowed:
         *     - N   : a single CPU number
         *     - N-M : a range of CPU numbers with N < M
         *     - ^N  : remove a single CPU number from the current set
         */
        if (*cur == '^') {
            cur++;
            neg = 1;
        }

        if (!c_isdigit(*cur))
            goto parse_error;
        start = virDomainCpuNumberParse(&cur, maxcpu);
        if (start < 0)
            goto parse_error;
        virSkipSpaces(&cur);
        if ((*cur == ',') || (*cur == 0) || (*cur == sep)) {
            if (neg) {
                if (cpuset[start] == 1) {
                    cpuset[start] = 0;
                    ret--;
                }
            } else {
                if (cpuset[start] == 0) {
                    cpuset[start] = 1;
                    ret++;
                }
            }
        } else if (*cur == '-') {
            if (neg)
                goto parse_error;
            cur++;
            virSkipSpaces(&cur);
            last = virDomainCpuNumberParse(&cur, maxcpu);
            if (last < start)
                goto parse_error;
            for (i = start; i <= last; i++) {
                if (cpuset[i] == 0) {
                    cpuset[i] = 1;
                    ret++;
                }
            }
            virSkipSpaces(&cur);
        }
        if (*cur == ',') {
            cur++;
            virSkipSpaces(&cur);
            neg = 0;
        } else if ((*cur == 0) || (*cur == sep)) {
            break;
        } else
            goto parse_error;
    }
    *str = cur;
    return (ret);

  parse_error:
5131
    virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5132 5133 5134 5135 5136 5137
                         "%s", _("topology cpuset syntax error"));
    return (-1);
}


static int
5138
virDomainLifecycleDefFormat(virBufferPtr buf,
5139 5140 5141 5142 5143
                            int type,
                            const char *name)
{
    const char *typeStr = virDomainLifecycleTypeToString(type);
    if (!typeStr) {
5144
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155
                             _("unexpected lifecycle type %d"), type);
        return -1;
    }

    virBufferVSprintf(buf, "  <%s>%s</%s>\n", name, typeStr, name);

    return 0;
}


static int
5156
virDomainDiskDefFormat(virBufferPtr buf,
D
Daniel P. Berrange 已提交
5157 5158
                       virDomainDiskDefPtr def,
                       int flags)
5159 5160 5161 5162
{
    const char *type = virDomainDiskTypeToString(def->type);
    const char *device = virDomainDiskDeviceTypeToString(def->device);
    const char *bus = virDomainDiskBusTypeToString(def->bus);
5163
    const char *cachemode = virDomainDiskCacheTypeToString(def->cachemode);
5164
    const char *error_policy = virDomainDiskErrorPolicyTypeToString(def->error_policy);
5165 5166

    if (!type) {
5167
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5168 5169 5170 5171
                             _("unexpected disk type %d"), def->type);
        return -1;
    }
    if (!device) {
5172
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5173 5174 5175 5176
                             _("unexpected disk device %d"), def->device);
        return -1;
    }
    if (!bus) {
5177
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5178 5179 5180
                             _("unexpected disk bus %d"), def->bus);
        return -1;
    }
5181
    if (!cachemode) {
5182
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5183 5184 5185
                             _("unexpected disk cache mode %d"), def->cachemode);
        return -1;
    }
5186 5187 5188 5189 5190

    virBufferVSprintf(buf,
                      "    <disk type='%s' device='%s'>\n",
                      type, device);

5191 5192 5193 5194
    if (def->driverName || def->driverType || def->cachemode) {
        virBufferVSprintf(buf, "      <driver");
        if (def->driverName)
            virBufferVSprintf(buf, " name='%s'", def->driverName);
5195
        if (def->driverType)
5196 5197 5198
            virBufferVSprintf(buf, " type='%s'", def->driverType);
        if (def->cachemode)
            virBufferVSprintf(buf, " cache='%s'", cachemode);
5199 5200
        if (def->error_policy)
            virBufferVSprintf(buf, " error_policy='%s'", error_policy);
5201
        virBufferVSprintf(buf, "/>\n");
5202 5203 5204
    }

    if (def->src) {
5205 5206
        switch (def->type) {
        case VIR_DOMAIN_DISK_TYPE_FILE:
5207 5208
            virBufferEscapeString(buf, "      <source file='%s'/>\n",
                                  def->src);
5209 5210
            break;
        case VIR_DOMAIN_DISK_TYPE_BLOCK:
5211 5212
            virBufferEscapeString(buf, "      <source dev='%s'/>\n",
                                  def->src);
5213 5214 5215 5216 5217 5218
            break;
        case VIR_DOMAIN_DISK_TYPE_DIR:
            virBufferEscapeString(buf, "      <source dir='%s'/>\n",
                                  def->src);
            break;
        default:
5219
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5220 5221 5222 5223
                                 _("unexpected disk type %s"),
                                 virDomainDiskTypeToString(def->type));
            return -1;
        }
5224 5225 5226 5227 5228 5229 5230 5231 5232
    }

    virBufferVSprintf(buf, "      <target dev='%s' bus='%s'/>\n",
                      def->dst, bus);

    if (def->readonly)
        virBufferAddLit(buf, "      <readonly/>\n");
    if (def->shared)
        virBufferAddLit(buf, "      <shareable/>\n");
5233 5234 5235
    if (def->serial)
        virBufferEscapeString(buf, "      <serial>%s</serial>\n",
                              def->serial);
5236
    if (def->encryption != NULL &&
5237
        virStorageEncryptionFormat(buf, def->encryption, 6) < 0)
5238
        return -1;
5239

D
Daniel P. Berrange 已提交
5240
    if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
5241
        return -1;
5242

5243 5244 5245 5246 5247
    virBufferAddLit(buf, "    </disk>\n");

    return 0;
}

5248
static int
5249
virDomainControllerDefFormat(virBufferPtr buf,
D
Daniel P. Berrange 已提交
5250 5251
                             virDomainControllerDefPtr def,
                             int flags)
5252 5253
{
    const char *type = virDomainControllerTypeToString(def->type);
5254
    const char *model = NULL;
5255 5256

    if (!type) {
5257
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5258 5259 5260 5261
                             _("unexpected controller type %d"), def->type);
        return -1;
    }

5262 5263 5264 5265 5266 5267 5268 5269 5270 5271
    if (def->model != -1) {
        model = virDomainControllerModelTypeToString(def->model);

        if (!model) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("unexpected model type %d"), def->model);
            return -1;
        }
    }

5272 5273 5274 5275
    virBufferVSprintf(buf,
                      "    <controller type='%s' index='%d'",
                      type, def->idx);

5276 5277 5278 5279
    if (model) {
        virBufferEscapeString(buf, " model='%s'", model);
    }

5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295
    switch (def->type) {
    case VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL:
        if (def->opts.vioserial.ports != -1) {
            virBufferVSprintf(buf, " ports='%d'",
                              def->opts.vioserial.ports);
        }
        if (def->opts.vioserial.vectors != -1) {
            virBufferVSprintf(buf, " vectors='%d'",
                              def->opts.vioserial.vectors);
        }
        break;

    default:
        break;
    }

5296 5297
    if (virDomainDeviceInfoIsSet(&def->info)) {
        virBufferAddLit(buf, ">\n");
D
Daniel P. Berrange 已提交
5298
        if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
5299 5300 5301 5302 5303 5304 5305 5306 5307
            return -1;
        virBufferAddLit(buf, "    </controller>\n");
    } else {
        virBufferAddLit(buf, "/>\n");
    }

    return 0;
}

5308
static int
5309
virDomainFSDefFormat(virBufferPtr buf,
5310 5311
                     virDomainFSDefPtr def,
                     int flags)
5312 5313 5314 5315
{
    const char *type = virDomainFSTypeToString(def->type);

    if (!type) {
5316
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353
                             _("unexpected filesystem type %d"), def->type);
        return -1;
    }

    virBufferVSprintf(buf,
                      "    <filesystem type='%s'>\n",
                      type);

    if (def->src) {
        switch (def->type) {
        case VIR_DOMAIN_FS_TYPE_MOUNT:
            virBufferEscapeString(buf, "      <source dir='%s'/>\n",
                                  def->src);
            break;

        case VIR_DOMAIN_FS_TYPE_BLOCK:
            virBufferEscapeString(buf, "      <source dev='%s'/>\n",
                                  def->src);
            break;

        case VIR_DOMAIN_FS_TYPE_FILE:
            virBufferEscapeString(buf, "      <source file='%s'/>\n",
                                  def->src);
            break;

        case VIR_DOMAIN_FS_TYPE_TEMPLATE:
            virBufferEscapeString(buf, "      <source name='%s'/>\n",
                                  def->src);
        }
    }

    virBufferVSprintf(buf, "      <target dir='%s'/>\n",
                      def->dst);

    if (def->readonly)
        virBufferAddLit(buf, "      <readonly/>\n");

5354 5355 5356
    if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
        return -1;

5357 5358 5359 5360 5361
    virBufferAddLit(buf, "    </filesystem>\n");

    return 0;
}

5362
static int
5363
virDomainNetDefFormat(virBufferPtr buf,
5364 5365
                      virDomainNetDefPtr def,
                      int flags)
5366 5367
{
    const char *type = virDomainNetTypeToString(def->type);
5368
    char *attrs;
5369 5370

    if (!type) {
5371
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403
                             _("unexpected net type %d"), def->type);
        return -1;
    }

    virBufferVSprintf(buf, "    <interface type='%s'>\n", type);

    virBufferVSprintf(buf,
                      "      <mac address='%02x:%02x:%02x:%02x:%02x:%02x'/>\n",
                      def->mac[0], def->mac[1], def->mac[2],
                      def->mac[3], def->mac[4], def->mac[5]);

    switch (def->type) {
    case VIR_DOMAIN_NET_TYPE_NETWORK:
        virBufferEscapeString(buf, "      <source network='%s'/>\n",
                              def->data.network.name);
        break;

    case VIR_DOMAIN_NET_TYPE_ETHERNET:
        if (def->data.ethernet.dev)
            virBufferEscapeString(buf, "      <source dev='%s'/>\n",
                                  def->data.ethernet.dev);
        if (def->data.ethernet.ipaddr)
            virBufferVSprintf(buf, "      <ip address='%s'/>\n",
                              def->data.ethernet.ipaddr);
        if (def->data.ethernet.script)
            virBufferEscapeString(buf, "      <script path='%s'/>\n",
                                  def->data.ethernet.script);
        break;

    case VIR_DOMAIN_NET_TYPE_BRIDGE:
        virBufferEscapeString(buf, "      <source bridge='%s'/>\n",
                              def->data.bridge.brname);
5404 5405 5406
        if (def->data.bridge.ipaddr)
            virBufferVSprintf(buf, "      <ip address='%s'/>\n",
                              def->data.bridge.ipaddr);
5407 5408 5409
        if (def->data.bridge.script)
            virBufferEscapeString(buf, "      <script path='%s'/>\n",
                                  def->data.bridge.script);
5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420
        break;

    case VIR_DOMAIN_NET_TYPE_SERVER:
    case VIR_DOMAIN_NET_TYPE_CLIENT:
    case VIR_DOMAIN_NET_TYPE_MCAST:
        if (def->data.socket.address)
            virBufferVSprintf(buf, "      <source address='%s' port='%d'/>\n",
                              def->data.socket.address, def->data.socket.port);
        else
            virBufferVSprintf(buf, "      <source port='%d'/>\n",
                              def->data.socket.port);
5421
        break;
D
Daniel Veillard 已提交
5422 5423 5424 5425 5426 5427

    case VIR_DOMAIN_NET_TYPE_INTERNAL:
        virBufferEscapeString(buf, "      <source name='%s'/>\n",
                              def->data.internal.name);
        break;

5428 5429 5430 5431 5432 5433
    case VIR_DOMAIN_NET_TYPE_DIRECT:
        virBufferEscapeString(buf, "      <source dev='%s'",
                              def->data.direct.linkdev);
        virBufferVSprintf(buf, " mode='%s'",
                   virDomainNetdevMacvtapTypeToString(def->data.direct.mode));
        virBufferAddLit(buf, "/>\n");
5434 5435
        virVirtualPortProfileFormat(buf, &def->data.direct.virtPortProfile,
                                    "      ");
5436
        break;
S
Stefan Berger 已提交
5437 5438 5439 5440

    case VIR_DOMAIN_NET_TYPE_USER:
    case VIR_DOMAIN_NET_TYPE_LAST:
        break;
5441 5442 5443 5444 5445 5446 5447 5448
    }

    if (def->ifname)
        virBufferEscapeString(buf, "      <target dev='%s'/>\n",
                              def->ifname);
    if (def->model)
        virBufferEscapeString(buf, "      <model type='%s'/>\n",
                              def->model);
5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459
    if (def->filter) {
        virBufferEscapeString(buf, "      <filterref filter='%s'",
                              def->filter);
        attrs = virNWFilterFormatParamAttributes(def->filterparams,
                                                 "        ");
        if (!attrs || strlen(attrs) <= 1)
            virBufferAddLit(buf, "/>\n");
        else
            virBufferVSprintf(buf, ">\n%s      </filterref>\n", attrs);
        VIR_FREE(attrs);
    }
5460

D
Daniel P. Berrange 已提交
5461
    if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
5462 5463
        return -1;

5464 5465 5466 5467 5468 5469 5470
    virBufferAddLit(buf, "    </interface>\n");

    return 0;
}


static int
5471
virDomainChrDefFormat(virBufferPtr buf,
5472
                      virDomainChrDefPtr def,
5473
                      int flags)
5474 5475
{
    const char *type = virDomainChrTypeToString(def->type);
5476
    const char *targetName = virDomainChrTargetTypeToString(def->targetType);
5477 5478 5479 5480 5481 5482 5483
    const char *elementName;

    int ret = 0;

    switch (def->targetType) {
    /* channel types are in a common channel element */
    case VIR_DOMAIN_CHR_TARGET_TYPE_GUESTFWD:
5484
    case VIR_DOMAIN_CHR_TARGET_TYPE_VIRTIO:
5485 5486
        elementName = "channel";
        break;
5487

5488 5489 5490
    default:
        elementName = targetName;
    }
5491 5492

    if (!type) {
5493
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5494
                             _("unexpected char type %d"), def->type);
5495
        return -1;
5496 5497 5498 5499
    }

    /* Compat with legacy  <console tty='/dev/pts/5'/> syntax */
    virBufferVSprintf(buf, "    <%s type='%s'",
5500 5501
                      elementName, type);
    if (def->targetType == VIR_DOMAIN_CHR_TARGET_TYPE_CONSOLE &&
5502
        def->type == VIR_DOMAIN_CHR_TYPE_PTY &&
5503
        !(flags & VIR_DOMAIN_XML_INACTIVE) &&
5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522
        def->data.file.path) {
        virBufferEscapeString(buf, " tty='%s'>\n",
                              def->data.file.path);
    } else {
        virBufferAddLit(buf, ">\n");
    }

    switch (def->type) {
    case VIR_DOMAIN_CHR_TYPE_NULL:
    case VIR_DOMAIN_CHR_TYPE_VC:
    case VIR_DOMAIN_CHR_TYPE_STDIO:
        /* nada */
        break;

    case VIR_DOMAIN_CHR_TYPE_PTY:
    case VIR_DOMAIN_CHR_TYPE_DEV:
    case VIR_DOMAIN_CHR_TYPE_FILE:
    case VIR_DOMAIN_CHR_TYPE_PIPE:
        if (def->type != VIR_DOMAIN_CHR_TYPE_PTY ||
5523
            (def->data.file.path && !(flags & VIR_DOMAIN_XML_INACTIVE))) {
5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575
            virBufferEscapeString(buf, "      <source path='%s'/>\n",
                                  def->data.file.path);
        }
        break;

    case VIR_DOMAIN_CHR_TYPE_UDP:
        if (def->data.udp.bindService &&
            def->data.udp.bindHost) {
            virBufferVSprintf(buf, "      <source mode='bind' host='%s' service='%s'/>\n",
                              def->data.udp.bindHost,
                              def->data.udp.bindService);
        } else if (def->data.udp.bindHost) {
            virBufferVSprintf(buf, "      <source mode='bind' host='%s'/>\n",
                              def->data.udp.bindHost);
        } else if (def->data.udp.bindService) {
            virBufferVSprintf(buf, "      <source mode='bind' service='%s'/>\n",
                              def->data.udp.bindService);
        }

        if (def->data.udp.connectService &&
            def->data.udp.connectHost) {
            virBufferVSprintf(buf, "      <source mode='connect' host='%s' service='%s'/>\n",
                              def->data.udp.connectHost,
                              def->data.udp.connectService);
        } else if (def->data.udp.connectHost) {
            virBufferVSprintf(buf, "      <source mode='connect' host='%s'/>\n",
                              def->data.udp.connectHost);
        } else if (def->data.udp.connectService) {
            virBufferVSprintf(buf, "      <source mode='connect' service='%s'/>\n",
                              def->data.udp.connectService);
        }
        break;

    case VIR_DOMAIN_CHR_TYPE_TCP:
        virBufferVSprintf(buf, "      <source mode='%s' host='%s' service='%s'/>\n",
                          def->data.tcp.listen ? "bind" : "connect",
                          def->data.tcp.host,
                          def->data.tcp.service);
        virBufferVSprintf(buf, "      <protocol type='%s'/>\n",
                          def->data.tcp.protocol ==
                          VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET
                          ? "telnet" : "raw");
        break;

    case VIR_DOMAIN_CHR_TYPE_UNIX:
        virBufferVSprintf(buf, "      <source mode='%s'",
                          def->data.nix.listen ? "bind" : "connect");
        virBufferEscapeString(buf, " path='%s'/>\n",
                              def->data.nix.path);
        break;
    }

5576
    switch (def->targetType) {
5577
    case VIR_DOMAIN_CHR_TARGET_TYPE_GUESTFWD:
5578 5579 5580
        {
            int port = virSocketGetPort(def->target.addr);
            if (port < 0) {
5581
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
5582 5583 5584 5585 5586
                                     _("Unable to format guestfwd port"));
                return -1;
            }
            const char *addr = virSocketFormatAddr(def->target.addr);
            if (addr == NULL) {
5587
                virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
5588 5589 5590 5591 5592 5593 5594 5595
                                     _("Unable to format guestfwd address"));
                return -1;
            }
            virBufferVSprintf(buf,
                    "      <target type='guestfwd' address='%s' port='%d'/>\n",
                              addr, port);
            VIR_FREE(addr);
            break;
5596 5597
        }

5598 5599 5600 5601 5602 5603 5604 5605
    case VIR_DOMAIN_CHR_TARGET_TYPE_VIRTIO:
        virBufferAddLit(buf, "      <target type='virtio'");
        if (def->target.name) {
            virBufferEscapeString(buf, " name='%s'", def->target.name);
        }
        virBufferAddLit(buf, "/>\n");
        break;

5606 5607 5608
    case VIR_DOMAIN_CHR_TARGET_TYPE_PARALLEL:
    case VIR_DOMAIN_CHR_TARGET_TYPE_SERIAL:
    case VIR_DOMAIN_CHR_TARGET_TYPE_CONSOLE:
5609
        virBufferVSprintf(buf, "      <target port='%d'/>\n", def->target.port);
5610 5611 5612
        break;

    default:
5613
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5614 5615 5616 5617
                             _("unexpected character destination type %d"),
                             def->targetType);
        return -1;
    }
5618

5619 5620 5621 5622
    if (virDomainDeviceInfoIsSet(&def->info)) {
        if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
            return -1;
    }
5623

5624
    virBufferVSprintf(buf, "    </%s>\n",
5625
                      elementName);
5626

5627
    return ret;
5628 5629 5630
}

static int
5631
virDomainSoundDefFormat(virBufferPtr buf,
D
Daniel P. Berrange 已提交
5632 5633
                        virDomainSoundDefPtr def,
                        int flags)
5634 5635 5636 5637
{
    const char *model = virDomainSoundModelTypeToString(def->model);

    if (!model) {
5638
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5639 5640 5641 5642
                             _("unexpected sound model %d"), def->model);
        return -1;
    }

5643
    virBufferVSprintf(buf, "    <sound model='%s'",
5644 5645
                      model);

5646 5647
    if (virDomainDeviceInfoIsSet(&def->info)) {
        virBufferAddLit(buf, ">\n");
D
Daniel P. Berrange 已提交
5648
        if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
5649 5650 5651 5652 5653 5654
            return -1;
        virBufferAddLit(buf, "    </sound>\n");
    } else {
        virBufferAddLit(buf, "/>\n");
    }

5655 5656 5657
    return 0;
}

5658

R
Richard Jones 已提交
5659
static int
5660
virDomainWatchdogDefFormat(virBufferPtr buf,
D
Daniel P. Berrange 已提交
5661 5662
                           virDomainWatchdogDefPtr def,
                           int flags)
R
Richard Jones 已提交
5663 5664 5665 5666 5667
{
    const char *model = virDomainWatchdogModelTypeToString (def->model);
    const char *action = virDomainWatchdogActionTypeToString (def->action);

    if (!model) {
5668
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
R
Richard Jones 已提交
5669 5670 5671 5672 5673
                             _("unexpected watchdog model %d"), def->model);
        return -1;
    }

    if (!action) {
5674
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
R
Richard Jones 已提交
5675 5676 5677 5678
                             _("unexpected watchdog action %d"), def->action);
        return -1;
    }

5679
    virBufferVSprintf(buf, "    <watchdog model='%s' action='%s'",
R
Richard Jones 已提交
5680 5681
                      model, action);

5682 5683
    if (virDomainDeviceInfoIsSet(&def->info)) {
        virBufferAddLit(buf, ">\n");
D
Daniel P. Berrange 已提交
5684
        if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
5685 5686 5687 5688 5689 5690
            return -1;
        virBufferAddLit(buf, "    </watchdog>\n");
    } else {
        virBufferAddLit(buf, "/>\n");
    }

R
Richard Jones 已提交
5691 5692 5693 5694
    return 0;
}


5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706
static void
virDomainVideoAccelDefFormat(virBufferPtr buf,
                             virDomainVideoAccelDefPtr def)
{
    virBufferVSprintf(buf, "        <acceleration accel3d='%s'",
                      def->support3d ? "yes" : "no");
    virBufferVSprintf(buf, " accel2d='%s'",
                      def->support2d ? "yes" : "no");
    virBufferAddLit(buf, "/>\n");
}


5707
static int
5708
virDomainVideoDefFormat(virBufferPtr buf,
D
Daniel P. Berrange 已提交
5709 5710
                        virDomainVideoDefPtr def,
                        int flags)
5711 5712 5713 5714
{
    const char *model = virDomainVideoTypeToString(def->type);

    if (!model) {
5715
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726
                             _("unexpected video model %d"), def->type);
        return -1;
    }

    virBufferAddLit(buf, "    <video>\n");
    virBufferVSprintf(buf, "      <model type='%s'",
                      model);
    if (def->vram)
        virBufferVSprintf(buf, " vram='%u'", def->vram);
    if (def->heads)
        virBufferVSprintf(buf, " heads='%u'", def->heads);
5727 5728 5729 5730 5731 5732 5733 5734
    if (def->accel) {
        virBufferAddLit(buf, ">\n");
        virDomainVideoAccelDefFormat(buf, def->accel);
        virBufferAddLit(buf, "      </model>\n");
    } else {
        virBufferAddLit(buf, "/>\n");
    }

D
Daniel P. Berrange 已提交
5735
    if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
5736 5737
        return -1;

5738 5739 5740 5741 5742
    virBufferAddLit(buf, "    </video>\n");

    return 0;
}

5743
static int
5744
virDomainInputDefFormat(virBufferPtr buf,
5745 5746
                        virDomainInputDefPtr def,
                        int flags)
5747 5748 5749 5750 5751
{
    const char *type = virDomainInputTypeToString(def->type);
    const char *bus = virDomainInputBusTypeToString(def->bus);

    if (!type) {
5752
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5753 5754 5755 5756
                             _("unexpected input type %d"), def->type);
        return -1;
    }
    if (!bus) {
5757
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5758 5759 5760 5761
                             _("unexpected input bus type %d"), def->bus);
        return -1;
    }

5762
    virBufferVSprintf(buf, "    <input type='%s' bus='%s'",
5763 5764
                      type, bus);

5765 5766 5767 5768 5769 5770 5771 5772 5773
    if (virDomainDeviceInfoIsSet(&def->info)) {
        virBufferAddLit(buf, ">\n");
        if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
            return -1;
        virBufferAddLit(buf, "    </input>\n");
    } else {
        virBufferAddLit(buf, "/>\n");
    }

5774 5775 5776 5777
    return 0;
}


5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810
static int
virDomainTimerDefFormat(virBufferPtr buf,
                        virDomainTimerDefPtr def)
{
    const char *name = virDomainTimerNameTypeToString(def->name);

    if (!name) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                             _("unexpected timer name %d"), def->name);
        return -1;
    }
    virBufferVSprintf(buf, "    <timer name='%s'", name);

    if (def->present == 0) {
        virBufferAddLit(buf, " present='no'");
    } else if (def->present == 1) {
        virBufferAddLit(buf, " present='yes'");
    }

    if (def->tickpolicy != -1) {
        const char *tickpolicy
            = virDomainTimerTickpolicyTypeToString(def->tickpolicy);
        if (!tickpolicy) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("unexpected timer tickpolicy %d"),
                                 def->tickpolicy);
            return -1;
        }
        virBufferVSprintf(buf, " tickpolicy='%s'", tickpolicy);
    }

    if ((def->name == VIR_DOMAIN_TIMER_NAME_PLATFORM)
        || (def->name == VIR_DOMAIN_TIMER_NAME_RTC)) {
5811 5812 5813 5814
        if (def->track != -1) {
            const char *track
                = virDomainTimerTrackTypeToString(def->track);
            if (!track) {
5815
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5816 5817
                                     _("unexpected timer track %d"),
                                     def->track);
5818 5819
                return -1;
            }
5820
            virBufferVSprintf(buf, " track='%s'", track);
5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841
        }
    }

    if (def->name == VIR_DOMAIN_TIMER_NAME_TSC) {
        if (def->frequency > 0) {
            virBufferVSprintf(buf, " frequency='%lu'", def->frequency);
        }

        if (def->mode != -1) {
            const char *mode
                = virDomainTimerModeTypeToString(def->mode);
            if (!mode) {
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                     _("unexpected timer mode %d"),
                                     def->mode);
                return -1;
            }
            virBufferVSprintf(buf, " mode='%s'", mode);
        }
    }

5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858
    if ((def->catchup.threshold == 0)
        && (def->catchup.slew == 0)
        && (def->catchup.limit == 0)) {
        virBufferAddLit(buf, "/>\n");
    } else {
        virBufferAddLit(buf, ">\n      <catchup ");
        if (def->catchup.threshold > 0) {
            virBufferVSprintf(buf, " threshold='%lu'", def->catchup.threshold);
        }
        if (def->catchup.slew > 0) {
            virBufferVSprintf(buf, " slew='%lu'", def->catchup.slew);
        }
        if (def->catchup.limit > 0) {
            virBufferVSprintf(buf, " limit='%lu'", def->catchup.limit);
        }
        virBufferAddLit(buf, "/>\n    </timer>\n");
    }
5859 5860 5861 5862

    return 0;
}

5863
static int
5864
virDomainGraphicsDefFormat(virBufferPtr buf,
5865 5866 5867 5868 5869 5870
                           virDomainGraphicsDefPtr def,
                           int flags)
{
    const char *type = virDomainGraphicsTypeToString(def->type);

    if (!type) {
5871
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5872 5873 5874 5875 5876 5877 5878 5879
                             _("unexpected net type %d"), def->type);
        return -1;
    }

    virBufferVSprintf(buf, "    <graphics type='%s'", type);

    switch (def->type) {
    case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
5880
        if (def->data.vnc.port &&
5881
            (!def->data.vnc.autoport || !(flags & VIR_DOMAIN_XML_INACTIVE)))
5882 5883
            virBufferVSprintf(buf, " port='%d'",
                              def->data.vnc.port);
C
Chris Lalancette 已提交
5884 5885
        else if (def->data.vnc.autoport)
            virBufferAddLit(buf, " port='-1'");
5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912

        virBufferVSprintf(buf, " autoport='%s'",
                          def->data.vnc.autoport ? "yes" : "no");

        if (def->data.vnc.listenAddr)
            virBufferVSprintf(buf, " listen='%s'",
                              def->data.vnc.listenAddr);

        if (def->data.vnc.keymap)
            virBufferEscapeString(buf, " keymap='%s'",
                                  def->data.vnc.keymap);

        if (def->data.vnc.passwd &&
            (flags & VIR_DOMAIN_XML_SECURE))
            virBufferEscapeString(buf, " passwd='%s'",
                                  def->data.vnc.passwd);

        break;

    case VIR_DOMAIN_GRAPHICS_TYPE_SDL:
        if (def->data.sdl.display)
            virBufferEscapeString(buf, " display='%s'",
                                  def->data.sdl.display);

        if (def->data.sdl.xauth)
            virBufferEscapeString(buf, " xauth='%s'",
                                  def->data.sdl.xauth);
5913 5914 5915
        if (def->data.sdl.fullscreen)
            virBufferAddLit(buf, " fullscreen='yes'");

5916
        break;
5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948

    case VIR_DOMAIN_GRAPHICS_TYPE_RDP:
        if (def->data.rdp.port)
            virBufferVSprintf(buf, " port='%d'",
                              def->data.rdp.port);
        else if (def->data.rdp.autoport)
            virBufferAddLit(buf, " port='0'");

        if (def->data.rdp.autoport)
            virBufferVSprintf(buf, " autoport='yes'");

        if (def->data.rdp.replaceUser)
            virBufferVSprintf(buf, " replaceUser='yes'");

        if (def->data.rdp.multiUser)
            virBufferVSprintf(buf, " multiUser='yes'");

        if (def->data.rdp.listenAddr)
            virBufferVSprintf(buf, " listen='%s'", def->data.rdp.listenAddr);

        break;

    case VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP:
        if (def->data.desktop.display)
            virBufferEscapeString(buf, " display='%s'",
                                  def->data.desktop.display);

        if (def->data.desktop.fullscreen)
            virBufferAddLit(buf, " fullscreen='yes'");

        break;

5949 5950 5951 5952 5953 5954 5955
    }

    virBufferAddLit(buf, "/>\n");

    return 0;
}

5956 5957

static int
5958
virDomainHostdevDefFormat(virBufferPtr buf,
D
Daniel P. Berrange 已提交
5959 5960
                          virDomainHostdevDefPtr def,
                          int flags)
5961 5962 5963 5964 5965
{
    const char *mode = virDomainHostdevModeTypeToString(def->mode);
    const char *type;

    if (!mode || def->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS) {
5966
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5967 5968 5969 5970 5971
                             _("unexpected hostdev mode %d"), def->mode);
        return -1;
    }

    type = virDomainHostdevSubsysTypeToString(def->source.subsys.type);
5972
    if (!type || (def->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB && def->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) ) {
5973
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
5974 5975 5976 5977 5978
                             _("unexpected hostdev type %d"),
                             def->source.subsys.type);
        return -1;
    }

5979 5980
    virBufferVSprintf(buf, "    <hostdev mode='%s' type='%s' managed='%s'>\n",
                      mode, type, def->managed ? "yes" : "no");
5981 5982
    virBufferAddLit(buf, "      <source>\n");

5983 5984 5985 5986 5987 5988
    if (def->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
        if (def->source.subsys.u.usb.vendor) {
            virBufferVSprintf(buf, "        <vendor id='0x%.4x'/>\n",
                              def->source.subsys.u.usb.vendor);
            virBufferVSprintf(buf, "        <product id='0x%.4x'/>\n",
                              def->source.subsys.u.usb.product);
5989 5990 5991
        }
        if (def->source.subsys.u.usb.bus ||
            def->source.subsys.u.usb.device)
5992 5993 5994
            virBufferVSprintf(buf, "        <address bus='%d' device='%d'/>\n",
                              def->source.subsys.u.usb.bus,
                              def->source.subsys.u.usb.device);
5995
    } else if (def->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
5996 5997 5998 5999 6000
        virBufferVSprintf(buf, "        <address domain='0x%.4x' bus='0x%.2x' slot='0x%.2x' function='0x%.1x'/>\n",
                          def->source.subsys.u.pci.domain,
                          def->source.subsys.u.pci.bus,
                          def->source.subsys.u.pci.slot,
                          def->source.subsys.u.pci.function);
6001 6002 6003
    }

    virBufferAddLit(buf, "      </source>\n");
6004

D
Daniel P. Berrange 已提交
6005
    if (virDomainDeviceInfoFormat(buf, &def->info, flags) < 0)
6006 6007
        return -1;

6008 6009 6010 6011 6012 6013
    virBufferAddLit(buf, "    </hostdev>\n");

    return 0;
}


6014
char *virDomainDefFormat(virDomainDefPtr def,
6015 6016 6017 6018 6019
                         int flags)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    unsigned char *uuid;
    char uuidstr[VIR_UUID_STRING_BUFLEN];
6020
    const char *type = NULL;
6021 6022 6023
    int n, allones = 1;

    if (!(type = virDomainVirtTypeToString(def->virtType))) {
6024
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
6025 6026 6027 6028
                         _("unexpected domain type %d"), def->virtType);
        goto cleanup;
    }

6029 6030 6031 6032
    if (def->id == -1)
        flags |= VIR_DOMAIN_XML_INACTIVE;

    if (!(flags & VIR_DOMAIN_XML_INACTIVE))
6033 6034 6035 6036 6037 6038 6039 6040 6041 6042
        virBufferVSprintf(&buf, "<domain type='%s' id='%d'>\n", type, def->id);
    else
        virBufferVSprintf(&buf, "<domain type='%s'>\n", type);

    virBufferEscapeString(&buf, "  <name>%s</name>\n", def->name);

    uuid = def->uuid;
    virUUIDFormat(uuid, uuidstr);
    virBufferVSprintf(&buf, "  <uuid>%s</uuid>\n", uuidstr);

6043 6044 6045 6046
    if (def->description)
        virBufferEscapeString(&buf, "  <description>%s</description>\n",
                              def->description);

6047 6048 6049
    virBufferVSprintf(&buf, "  <memory>%lu</memory>\n", def->maxmem);
    virBufferVSprintf(&buf, "  <currentMemory>%lu</currentMemory>\n",
                      def->memory);
6050 6051 6052 6053 6054
    if (def->hugepage_backed) {
        virBufferAddLit(&buf, "  <memoryBacking>\n");
        virBufferAddLit(&buf, "    <hugepages/>\n");
        virBufferAddLit(&buf, "  </memoryBacking>\n");
    }
6055 6056 6057 6058 6059 6060 6061 6062 6063
    for (n = 0 ; n < def->cpumasklen ; n++)
        if (def->cpumask[n] != 1)
            allones = 0;

    if (allones) {
        virBufferVSprintf(&buf, "  <vcpu>%lu</vcpu>\n", def->vcpus);
    } else {
        char *cpumask = NULL;
        if ((cpumask =
6064
             virDomainCpuSetFormat(def->cpumask, def->cpumasklen)) == NULL)
6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095
            goto cleanup;
        virBufferVSprintf(&buf, "  <vcpu cpuset='%s'>%lu</vcpu>\n",
                          cpumask, def->vcpus);
        VIR_FREE(cpumask);
    }

    if (def->os.bootloader) {
        virBufferEscapeString(&buf, "  <bootloader>%s</bootloader>\n",
                              def->os.bootloader);
        if (def->os.bootloaderArgs)
            virBufferEscapeString(&buf, "  <bootloader_args>%s</bootloader_args>\n",
                                  def->os.bootloaderArgs);
    }
    virBufferAddLit(&buf, "  <os>\n");

    virBufferAddLit(&buf, "    <type");
    if (def->os.arch)
        virBufferVSprintf(&buf, " arch='%s'", def->os.arch);
    if (def->os.machine)
        virBufferVSprintf(&buf, " machine='%s'", def->os.machine);
    /*
     * HACK: For xen driver we previously used bogus 'linux' as the
     * os type for paravirt, whereas capabilities declare it to
     * be 'xen'. So we convert to the former for backcompat
     */
    if (def->virtType == VIR_DOMAIN_VIRT_XEN &&
        STREQ(def->os.type, "xen"))
        virBufferVSprintf(&buf, ">%s</type>\n", "linux");
    else
        virBufferVSprintf(&buf, ">%s</type>\n", def->os.type);

6096 6097 6098
    if (def->os.init)
        virBufferEscapeString(&buf, "    <init>%s</init>\n",
                              def->os.init);
6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119
    if (def->os.loader)
        virBufferEscapeString(&buf, "    <loader>%s</loader>\n",
                              def->os.loader);
    if (def->os.kernel)
        virBufferEscapeString(&buf, "    <kernel>%s</kernel>\n",
                              def->os.kernel);
    if (def->os.initrd)
        virBufferEscapeString(&buf, "    <initrd>%s</initrd>\n",
                              def->os.initrd);
    if (def->os.cmdline)
        virBufferEscapeString(&buf, "    <cmdline>%s</cmdline>\n",
                              def->os.cmdline);
    if (def->os.root)
        virBufferEscapeString(&buf, "    <root>%s</root>\n",
                              def->os.root);

    if (!def->os.bootloader) {
        for (n = 0 ; n < def->os.nBootDevs ; n++) {
            const char *boottype =
                virDomainBootTypeToString(def->os.bootDevs[n]);
            if (!boottype) {
6120
                virDomainReportError(VIR_ERR_INTERNAL_ERROR,
6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137
                                     _("unexpected boot device type %d"),
                                     def->os.bootDevs[n]);
                goto cleanup;
            }
            virBufferVSprintf(&buf, "    <boot dev='%s'/>\n", boottype);
        }
    }

    virBufferAddLit(&buf, "  </os>\n");

    if (def->features) {
        int i;
        virBufferAddLit(&buf, "  <features>\n");
        for (i = 0 ; i < VIR_DOMAIN_FEATURE_LAST ; i++) {
            if (def->features & (1 << i)) {
                const char *name = virDomainFeatureTypeToString(i);
                if (!name) {
6138
                    virDomainReportError(VIR_ERR_INTERNAL_ERROR,
6139 6140 6141 6142 6143 6144 6145 6146 6147
                                         _("unexpected feature %d"), i);
                    goto cleanup;
                }
                virBufferVSprintf(&buf, "    <%s/>\n", name);
            }
        }
        virBufferAddLit(&buf, "  </features>\n");
    }

6148
    if (virCPUDefFormatBuf(&buf, def->cpu, "  ", 0) < 0)
6149 6150
        goto cleanup;

6151
    virBufferVSprintf(&buf, "  <clock offset='%s'",
6152
                      virDomainClockOffsetTypeToString(def->clock.offset));
6153 6154
    switch (def->clock.offset) {
    case VIR_DOMAIN_CLOCK_OFFSET_VARIABLE:
6155 6156 6157 6158
        virBufferVSprintf(&buf, " adjustment='%lld'", def->clock.data.adjustment);
        break;
    case VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE:
        virBufferEscapeString(&buf, " timezone='%s'", def->clock.data.timezone);
6159 6160
        break;
    }
6161 6162 6163 6164 6165 6166 6167 6168 6169 6170
    if (def->clock.ntimers == 0) {
        virBufferAddLit(&buf, "/>\n");
    } else {
        virBufferAddLit(&buf, ">\n");
        for (n = 0; n < def->clock.ntimers; n++) {
            if (virDomainTimerDefFormat(&buf, def->clock.timers[n]) < 0)
                goto cleanup;
        }
        virBufferAddLit(&buf, "  </clock>\n");
    }
6171

6172
    if (virDomainLifecycleDefFormat(&buf, def->onPoweroff,
6173 6174
                                    "on_poweroff") < 0)
        goto cleanup;
6175
    if (virDomainLifecycleDefFormat(&buf, def->onReboot,
6176 6177
                                    "on_reboot") < 0)
        goto cleanup;
6178
    if (virDomainLifecycleDefFormat(&buf, def->onCrash,
6179 6180 6181 6182 6183 6184 6185 6186 6187
                                    "on_crash") < 0)
        goto cleanup;

    virBufferAddLit(&buf, "  <devices>\n");

    if (def->emulator)
        virBufferEscapeString(&buf, "    <emulator>%s</emulator>\n",
                              def->emulator);

6188
    for (n = 0 ; n < def->ndisks ; n++)
6189
        if (virDomainDiskDefFormat(&buf, def->disks[n], flags) < 0)
6190
            goto cleanup;
6191

6192
    for (n = 0 ; n < def->ncontrollers ; n++)
6193
        if (virDomainControllerDefFormat(&buf, def->controllers[n], flags) < 0)
6194 6195
            goto cleanup;

6196
    for (n = 0 ; n < def->nfss ; n++)
6197
        if (virDomainFSDefFormat(&buf, def->fss[n], flags) < 0)
6198
            goto cleanup;
6199 6200


6201
    for (n = 0 ; n < def->nnets ; n++)
6202
        if (virDomainNetDefFormat(&buf, def->nets[n], flags) < 0)
6203
            goto cleanup;
6204

6205
    for (n = 0 ; n < def->nserials ; n++)
6206
        if (virDomainChrDefFormat(&buf, def->serials[n], flags) < 0)
6207 6208
            goto cleanup;

6209
    for (n = 0 ; n < def->nparallels ; n++)
6210
        if (virDomainChrDefFormat(&buf, def->parallels[n], flags) < 0)
6211 6212 6213 6214
            goto cleanup;

    /* If there's a PV console that's preferred.. */
    if (def->console) {
6215
        if (virDomainChrDefFormat(&buf, def->console, flags) < 0)
6216
            goto cleanup;
6217
    } else if (def->nserials != 0) {
6218 6219
        /* ..else for legacy compat duplicate the first serial device as a
         * console */
6220 6221 6222
        virDomainChrDef console;
        memcpy(&console, def->serials[0], sizeof(console));
        console.targetType = VIR_DOMAIN_CHR_TARGET_TYPE_CONSOLE;
6223
        if (virDomainChrDefFormat(&buf, &console, flags) < 0)
6224 6225 6226
            goto cleanup;
    }

6227
    for (n = 0 ; n < def->nchannels ; n++)
6228
        if (virDomainChrDefFormat(&buf, def->channels[n], flags) < 0)
6229 6230
            goto cleanup;

6231 6232
    for (n = 0 ; n < def->ninputs ; n++)
        if (def->inputs[n]->bus == VIR_DOMAIN_INPUT_BUS_USB &&
6233
            virDomainInputDefFormat(&buf, def->inputs[n], flags) < 0)
6234 6235
            goto cleanup;

6236
    if (def->ngraphics > 0) {
6237 6238 6239 6240
        /* If graphics is enabled, add the implicit mouse */
        virDomainInputDef autoInput = {
            VIR_DOMAIN_INPUT_TYPE_MOUSE,
            STREQ(def->os.type, "hvm") ?
6241 6242
            VIR_DOMAIN_INPUT_BUS_PS2 : VIR_DOMAIN_INPUT_BUS_XEN,
            { .alias = NULL },
6243
        };
6244

6245
        if (virDomainInputDefFormat(&buf, &autoInput, flags) < 0)
6246 6247
            goto cleanup;

6248
        for (n = 0 ; n < def->ngraphics ; n++)
6249
            if (virDomainGraphicsDefFormat(&buf, def->graphics[n], flags) < 0)
6250
                goto cleanup;
6251 6252
    }

6253
    for (n = 0 ; n < def->nsounds ; n++)
6254
        if (virDomainSoundDefFormat(&buf, def->sounds[n], flags) < 0)
6255 6256
            goto cleanup;

6257
    for (n = 0 ; n < def->nvideos ; n++)
6258
        if (virDomainVideoDefFormat(&buf, def->videos[n], flags) < 0)
6259 6260
            goto cleanup;

6261
    for (n = 0 ; n < def->nhostdevs ; n++)
6262
        if (virDomainHostdevDefFormat(&buf, def->hostdevs[n], flags) < 0)
6263 6264
            goto cleanup;

R
Richard Jones 已提交
6265
    if (def->watchdog)
6266
        virDomainWatchdogDefFormat (&buf, def->watchdog, flags);
R
Richard Jones 已提交
6267

6268
    virBufferAddLit(&buf, "  </devices>\n");
6269 6270

    if (def->seclabel.model) {
6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289
        const char *sectype = virDomainSeclabelTypeToString(def->seclabel.type);
        if (!sectype)
            goto cleanup;
        if (!def->seclabel.label ||
            (def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC &&
             (flags & VIR_DOMAIN_XML_INACTIVE))) {
            virBufferVSprintf(&buf, "  <seclabel type='%s' model='%s'/>\n",
                              sectype, def->seclabel.model);
        } else {
            virBufferVSprintf(&buf, "  <seclabel type='%s' model='%s'>\n",
                                  sectype, def->seclabel.model);
            virBufferEscapeString(&buf, "    <label>%s</label>\n",
                                  def->seclabel.label);
            if (def->seclabel.imagelabel &&
                def->seclabel.type == VIR_DOMAIN_SECLABEL_DYNAMIC)
                virBufferEscapeString(&buf, "    <imagelabel>%s</imagelabel>\n",
                                      def->seclabel.imagelabel);
            virBufferAddLit(&buf, "  </seclabel>\n");
        }
6290 6291
    }

6292 6293 6294 6295 6296 6297 6298 6299
    virBufferAddLit(&buf, "</domain>\n");

    if (virBufferError(&buf))
        goto no_memory;

    return virBufferContentAndReset(&buf);

 no_memory:
6300
    virReportOOMError();
6301
 cleanup:
6302
    virBufferFreeAndReset(&buf);
6303 6304 6305
    return NULL;
}

6306 6307
#ifndef PROXY

6308 6309 6310
static char *virDomainObjFormat(virCapsPtr caps,
                                virDomainObjPtr obj,
                                int flags)
6311
{
6312
    char *config_xml = NULL;
6313 6314 6315 6316 6317
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    virBufferVSprintf(&buf, "<domstatus state='%s' pid='%d'>\n",
                      virDomainStateTypeToString(obj->state),
                      obj->pid);
6318

6319 6320 6321
    if (caps->privateDataXMLFormat &&
        ((caps->privateDataXMLFormat)(&buf, obj->privateData)) < 0)
        goto error;
6322

6323
    if (!(config_xml = virDomainDefFormat(obj->def,
6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336
                                          flags)))
        goto error;

    virBufferAdd(&buf, config_xml, strlen(config_xml));
    VIR_FREE(config_xml);
    virBufferAddLit(&buf, "</domstatus>\n");

    if (virBufferError(&buf))
        goto no_memory;

    return virBufferContentAndReset(&buf);

no_memory:
6337
    virReportOOMError();
6338
error:
6339
    virBufferFreeAndReset(&buf);
6340 6341 6342
    return NULL;
}

6343
int virDomainSaveXML(const char *configDir,
6344 6345
                     virDomainDefPtr def,
                     const char *xml)
6346
{
6347
    char *configFile = NULL;
6348 6349 6350
    int fd = -1, ret = -1;
    size_t towrite;

6351
    if ((configFile = virDomainConfigFile(configDir, def->name)) == NULL)
6352 6353
        goto cleanup;

6354
    if (virFileMakePath(configDir)) {
6355
        virReportSystemError(errno,
6356 6357
                             _("cannot create config directory '%s'"),
                             configDir);
6358 6359 6360
        goto cleanup;
    }

6361
    if ((fd = open(configFile,
6362 6363
                   O_WRONLY | O_CREAT | O_TRUNC,
                   S_IRUSR | S_IWUSR )) < 0) {
6364
        virReportSystemError(errno,
6365 6366
                             _("cannot create config file '%s'"),
                             configFile);
6367 6368 6369 6370 6371
        goto cleanup;
    }

    towrite = strlen(xml);
    if (safewrite(fd, xml, towrite) < 0) {
6372
        virReportSystemError(errno,
6373 6374
                             _("cannot write config file '%s'"),
                             configFile);
6375 6376 6377 6378
        goto cleanup;
    }

    if (close(fd) < 0) {
6379
        virReportSystemError(errno,
6380 6381
                             _("cannot save config file '%s'"),
                             configFile);
6382 6383 6384 6385 6386 6387 6388
        goto cleanup;
    }

    ret = 0;
 cleanup:
    if (fd != -1)
        close(fd);
R
Ryota Ozaki 已提交
6389
    VIR_FREE(configFile);
6390 6391 6392
    return ret;
}

6393
int virDomainSaveConfig(const char *configDir,
6394 6395 6396 6397
                        virDomainDefPtr def)
{
    int ret = -1;
    char *xml;
6398

6399
    if (!(xml = virDomainDefFormat(def,
6400 6401 6402
                                   VIR_DOMAIN_XML_SECURE)))
        goto cleanup;

6403
    if (virDomainSaveXML(configDir, def, xml))
6404 6405 6406 6407 6408
        goto cleanup;

    ret = 0;
cleanup:
    VIR_FREE(xml);
6409 6410 6411
    return ret;
}

6412
int virDomainSaveStatus(virCapsPtr caps,
6413 6414 6415
                        const char *statusDir,
                        virDomainObjPtr obj)
{
6416
    int flags = VIR_DOMAIN_XML_SECURE|VIR_DOMAIN_XML_INTERNAL_STATUS;
6417 6418 6419
    int ret = -1;
    char *xml;

6420
    if (!(xml = virDomainObjFormat(caps, obj, flags)))
6421 6422
        goto cleanup;

6423
    if (virDomainSaveXML(statusDir, obj->def, xml))
6424 6425 6426 6427 6428 6429 6430 6431
        goto cleanup;

    ret = 0;
cleanup:
    VIR_FREE(xml);
    return ret;
}

6432

6433 6434 6435 6436 6437 6438 6439
static virDomainObjPtr virDomainLoadConfig(virCapsPtr caps,
                                           virDomainObjListPtr doms,
                                           const char *configDir,
                                           const char *autostartDir,
                                           const char *name,
                                           virDomainLoadConfigNotify notify,
                                           void *opaque)
6440 6441 6442 6443 6444
{
    char *configFile = NULL, *autostartLink = NULL;
    virDomainDefPtr def = NULL;
    virDomainObjPtr dom;
    int autostart;
6445
    int newVM = 1;
6446

6447
    if ((configFile = virDomainConfigFile(configDir, name)) == NULL)
6448
        goto error;
6449
    if (!(def = virDomainDefParseFile(caps, configFile,
6450
                                      VIR_DOMAIN_XML_INACTIVE)))
6451 6452
        goto error;

6453 6454 6455 6456 6457 6458 6459
    /* if the domain is already in our hashtable, we don't need to do
     * anything further
     */
    if ((dom = virDomainFindByUUID(doms, def->uuid))) {
        VIR_FREE(configFile);
        virDomainDefFree(def);
        return dom;
6460
    }
6461

6462 6463 6464 6465 6466 6467
    if ((autostartLink = virDomainConfigFile(autostartDir, name)) == NULL)
        goto error;

    if ((autostart = virFileLinkPointsTo(autostartLink, configFile)) < 0)
        goto error;

6468
    if (!(dom = virDomainAssignDef(caps, doms, def, false)))
6469 6470 6471 6472
        goto error;

    dom->autostart = autostart;

6473 6474 6475
    if (notify)
        (*notify)(dom, newVM, opaque);

6476 6477
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
6478 6479 6480 6481 6482 6483 6484 6485 6486
    return dom;

error:
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
    virDomainDefFree(def);
    return NULL;
}

6487
static virDomainObjPtr virDomainLoadStatus(virCapsPtr caps,
6488 6489 6490 6491 6492 6493 6494 6495
                                           virDomainObjListPtr doms,
                                           const char *statusDir,
                                           const char *name,
                                           virDomainLoadConfigNotify notify,
                                           void *opaque)
{
    char *statusFile = NULL;
    virDomainObjPtr obj = NULL;
6496
    char uuidstr[VIR_UUID_STRING_BUFLEN];
6497

6498
    if ((statusFile = virDomainConfigFile(statusDir, name)) == NULL)
6499 6500
        goto error;

6501
    if (!(obj = virDomainObjParseFile(caps, statusFile)))
6502 6503
        goto error;

6504 6505 6506
    virUUIDFormat(obj->def->uuid, uuidstr);

    if (virHashLookup(doms->objs, uuidstr) != NULL) {
6507
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
6508 6509 6510 6511 6512
                             _("unexpected domain %s already exists"),
                             obj->def->name);
        goto error;
    }

6513
    if (virHashAddEntry(doms->objs, uuidstr, obj) < 0) {
6514
        virReportOOMError();
6515 6516 6517 6518 6519 6520 6521 6522 6523 6524
        goto error;
    }

    if (notify)
        (*notify)(obj, 1, opaque);

    VIR_FREE(statusFile);
    return obj;

error:
6525 6526
    if (obj)
        virDomainObjUnref(obj);
6527 6528 6529 6530
    VIR_FREE(statusFile);
    return NULL;
}

6531
int virDomainLoadAllConfigs(virCapsPtr caps,
6532
                            virDomainObjListPtr doms,
6533
                            const char *configDir,
6534
                            const char *autostartDir,
6535
                            int liveStatus,
6536 6537
                            virDomainLoadConfigNotify notify,
                            void *opaque)
6538 6539 6540 6541
{
    DIR *dir;
    struct dirent *entry;

6542 6543
    VIR_INFO("Scanning for configs in %s", configDir);

6544 6545 6546
    if (!(dir = opendir(configDir))) {
        if (errno == ENOENT)
            return 0;
6547
        virReportSystemError(errno,
6548 6549
                             _("Failed to open dir '%s'"),
                             configDir);
6550 6551 6552 6553
        return -1;
    }

    while ((entry = readdir(dir))) {
6554 6555
        virDomainObjPtr dom;

6556 6557 6558
        if (entry->d_name[0] == '.')
            continue;

6559
        if (!virFileStripSuffix(entry->d_name, ".xml"))
6560 6561 6562 6563
            continue;

        /* NB: ignoring errors, so one malformed config doesn't
           kill the whole process */
6564 6565
        VIR_INFO("Loading config file '%s.xml'", entry->d_name);
        if (liveStatus)
6566
            dom = virDomainLoadStatus(caps,
6567 6568 6569 6570 6571 6572
                                      doms,
                                      configDir,
                                      entry->d_name,
                                      notify,
                                      opaque);
        else
6573
            dom = virDomainLoadConfig(caps,
6574 6575 6576 6577 6578 6579
                                      doms,
                                      configDir,
                                      autostartDir,
                                      entry->d_name,
                                      notify,
                                      opaque);
6580 6581
        if (dom) {
            virDomainObjUnlock(dom);
D
Daniel Veillard 已提交
6582 6583
            if (!liveStatus)
                dom->persistent = 1;
6584
        }
6585 6586 6587 6588 6589 6590 6591
    }

    closedir(dir);

    return 0;
}

6592
int virDomainDeleteConfig(const char *configDir,
6593 6594
                          const char *autostartDir,
                          virDomainObjPtr dom)
6595
{
6596 6597 6598
    char *configFile = NULL, *autostartLink = NULL;
    int ret = -1;

6599
    if ((configFile = virDomainConfigFile(configDir, dom->def->name)) == NULL)
6600
        goto cleanup;
6601
    if ((autostartLink = virDomainConfigFile(autostartDir, dom->def->name)) == NULL)
6602
        goto cleanup;
6603 6604

    /* Not fatal if this doesn't work */
6605
    unlink(autostartLink);
6606

6607 6608
    if (unlink(configFile) < 0 &&
        errno != ENOENT) {
6609
        virReportSystemError(errno,
6610 6611
                             _("cannot remove config %s"),
                             configFile);
6612
        goto cleanup;
6613 6614
    }

6615 6616 6617 6618 6619 6620
    ret = 0;

cleanup:
    VIR_FREE(configFile);
    VIR_FREE(autostartLink);
    return ret;
6621
}
6622

6623
char *virDomainConfigFile(const char *dir,
6624 6625 6626 6627
                          const char *name)
{
    char *ret = NULL;

6628
    if (virAsprintf(&ret, "%s/%s.xml", dir, name) < 0) {
6629
        virReportOOMError();
6630 6631 6632 6633 6634 6635
        return NULL;
    }

    return ret;
}

6636 6637
/* Translates a device name of the form (regex) "[fhv]d[a-z]+" into
 * the corresponding bus,index combination (e.g. sda => (0,0), sdi (1,1),
D
Daniel Veillard 已提交
6638
 *                                               hdd => (1,1), vdaa => (0,26))
6639 6640 6641 6642 6643
 * @param disk The disk device
 * @param busIdx parsed bus number
 * @param devIdx parsed device number
 * @return 0 on success, -1 on failure
 */
6644
int virDiskNameToBusDeviceIndex(const virDomainDiskDefPtr disk,
6645 6646 6647 6648
                                int *busIdx,
                                int *devIdx) {

    int idx = virDiskNameToIndex(disk->dst);
6649
    if (idx < 0)
6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672
        return -1;

    switch (disk->bus) {
        case VIR_DOMAIN_DISK_BUS_IDE:
            *busIdx = idx / 2;
            *devIdx = idx % 2;
            break;
        case VIR_DOMAIN_DISK_BUS_SCSI:
            *busIdx = idx / 7;
            *devIdx = idx % 7;
            break;
        case VIR_DOMAIN_DISK_BUS_FDC:
        case VIR_DOMAIN_DISK_BUS_USB:
        case VIR_DOMAIN_DISK_BUS_VIRTIO:
        case VIR_DOMAIN_DISK_BUS_XEN:
        default:
            *busIdx = 0;
            *devIdx = idx;
            break;
    }

    return 0;
}
6673

6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688
virDomainFSDefPtr virDomainGetRootFilesystem(virDomainDefPtr def)
{
    int i;

    for (i = 0 ; i < def->nfss ; i++) {
        if (def->fss[i]->type != VIR_DOMAIN_FS_TYPE_MOUNT)
            continue;

        if (STREQ(def->fss[i]->dst, "/"))
            return def->fss[i];
    }

    return NULL;
}

6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714
/*
 * virDomainObjIsDuplicate:
 * @doms : virDomainObjListPtr to search
 * @def  : virDomainDefPtr definition of domain to lookup
 * @check_active: If true, ensure that domain is not active
 *
 * Returns: -1 on error
 *          0 if domain is new
 *          1 if domain is a duplicate
 */
int
virDomainObjIsDuplicate(virDomainObjListPtr doms,
                        virDomainDefPtr def,
                        unsigned int check_active)
{
    int ret = -1;
    int dupVM = 0;
    virDomainObjPtr vm = NULL;

    /* See if a VM with matching UUID already exists */
    vm = virDomainFindByUUID(doms, def->uuid);
    if (vm) {
        /* UUID matches, but if names don't match, refuse it */
        if (STRNEQ(vm->def->name, def->name)) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(vm->def->uuid, uuidstr);
6715 6716 6717
            virDomainReportError(VIR_ERR_OPERATION_FAILED,
                                 _("domain '%s' is already defined with uuid %s"),
                                 vm->def->name, uuidstr);
6718 6719 6720 6721 6722 6723
            goto cleanup;
        }

        if (check_active) {
            /* UUID & name match, but if VM is already active, refuse it */
            if (virDomainObjIsActive(vm)) {
6724
                virDomainReportError(VIR_ERR_OPERATION_INVALID,
6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737
                                     _("domain is already active as '%s'"),
                                     vm->def->name);
                goto cleanup;
            }
        }

        dupVM = 1;
    } else {
        /* UUID does not match, but if a name matches, refuse it */
        vm = virDomainFindByName(doms, def->name);
        if (vm) {
            char uuidstr[VIR_UUID_STRING_BUFLEN];
            virUUIDFormat(vm->def->uuid, uuidstr);
6738
            virDomainReportError(VIR_ERR_OPERATION_FAILED,
6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751
                                 _("domain '%s' already exists with uuid %s"),
                                 def->name, uuidstr);
            goto cleanup;
        }
    }

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

6752

6753 6754
void virDomainObjLock(virDomainObjPtr obj)
{
6755
    virMutexLock(&obj->lock);
6756 6757 6758 6759
}

void virDomainObjUnlock(virDomainObjPtr obj)
{
6760
    virMutexUnlock(&obj->lock);
6761 6762
}

6763 6764 6765 6766 6767 6768

static void virDomainObjListCountActive(void *payload, const char *name ATTRIBUTE_UNUSED, void *data)
{
    virDomainObjPtr obj = payload;
    int *count = data;
    virDomainObjLock(obj);
D
Daniel P. Berrange 已提交
6769
    if (virDomainObjIsActive(obj))
6770 6771 6772 6773 6774 6775 6776 6777 6778
        (*count)++;
    virDomainObjUnlock(obj);
}

static void virDomainObjListCountInactive(void *payload, const char *name ATTRIBUTE_UNUSED, void *data)
{
    virDomainObjPtr obj = payload;
    int *count = data;
    virDomainObjLock(obj);
D
Daniel P. Berrange 已提交
6779
    if (!virDomainObjIsActive(obj))
6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804
        (*count)++;
    virDomainObjUnlock(obj);
}

int virDomainObjListNumOfDomains(virDomainObjListPtr doms, int active)
{
    int count = 0;
    if (active)
        virHashForEach(doms->objs, virDomainObjListCountActive, &count);
    else
        virHashForEach(doms->objs, virDomainObjListCountInactive, &count);
    return count;
}

struct virDomainIDData {
    int numids;
    int maxids;
    int *ids;
};

static void virDomainObjListCopyActiveIDs(void *payload, const char *name ATTRIBUTE_UNUSED, void *opaque)
{
    virDomainObjPtr obj = payload;
    struct virDomainIDData *data = opaque;
    virDomainObjLock(obj);
D
Daniel P. Berrange 已提交
6805
    if (virDomainObjIsActive(obj) && data->numids < data->maxids)
6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834
        data->ids[data->numids++] = obj->def->id;
    virDomainObjUnlock(obj);
}

int virDomainObjListGetActiveIDs(virDomainObjListPtr doms,
                                 int *ids,
                                 int maxids)
{
    struct virDomainIDData data = { 0, maxids, ids };
    virHashForEach(doms->objs, virDomainObjListCopyActiveIDs, &data);
    return data.numids;
}

struct virDomainNameData {
    int oom;
    int numnames;
    int maxnames;
    char **const names;
};

static void virDomainObjListCopyInactiveNames(void *payload, const char *name ATTRIBUTE_UNUSED, void *opaque)
{
    virDomainObjPtr obj = payload;
    struct virDomainNameData *data = opaque;

    if (data->oom)
        return;

    virDomainObjLock(obj);
D
Daniel P. Berrange 已提交
6835
    if (!virDomainObjIsActive(obj) && data->numnames < data->maxnames) {
6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852
        if (!(data->names[data->numnames] = strdup(obj->def->name)))
            data->oom = 1;
        else
            data->numnames++;
    }
    virDomainObjUnlock(obj);
}


int virDomainObjListGetInactiveNames(virDomainObjListPtr doms,
                                     char **const names,
                                     int maxnames)
{
    struct virDomainNameData data = { 0, 0, maxnames, names };
    int i;
    virHashForEach(doms->objs, virDomainObjListCopyInactiveNames, &data);
    if (data.oom) {
6853
        virReportOOMError();
6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864
        goto cleanup;
    }

    return data.numnames;

cleanup:
    for (i = 0 ; i < data.numnames ; i++)
        VIR_FREE(data.names[i]);
    return -1;
}

C
Chris Lalancette 已提交
6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901
/* Snapshot Def functions */
void virDomainSnapshotDefFree(virDomainSnapshotDefPtr def)
{
    if (!def)
        return;

    VIR_FREE(def->name);
    VIR_FREE(def->description);
    VIR_FREE(def->parent);
    VIR_FREE(def);
}

virDomainSnapshotDefPtr virDomainSnapshotDefParseString(const char *xmlStr,
                                                        int newSnapshot)
{
    xmlXPathContextPtr ctxt = NULL;
    xmlDocPtr xml = NULL;
    xmlNodePtr root;
    virDomainSnapshotDefPtr def = NULL;
    virDomainSnapshotDefPtr ret = NULL;
    char *creation = NULL, *state = NULL;
    struct timeval tv;

    xml = virXMLParse(NULL, xmlStr, "domainsnapshot.xml");
    if (!xml) {
        virDomainReportError(VIR_ERR_XML_ERROR,
                             "%s",_("failed to parse snapshot xml document"));
        return NULL;
    }

    if ((root = xmlDocGetRootElement(xml)) == NULL) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                              "%s", _("missing root element"));
        goto cleanup;
    }

    if (!xmlStrEqual(root->name, BAD_CAST "domainsnapshot")) {
6902
        virDomainReportError(VIR_ERR_XML_ERROR, "%s", _("domainsnapshot"));
C
Chris Lalancette 已提交
6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961 6962 6963 6964 6965 6966 6967 6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041
        goto cleanup;
    }

    ctxt = xmlXPathNewContext(xml);
    if (ctxt == NULL) {
        virReportOOMError();
        goto cleanup;
    }

    if (VIR_ALLOC(def) < 0) {
        virReportOOMError();
        goto cleanup;
    }

    ctxt->node = root;

    gettimeofday(&tv, NULL);

    def->name = virXPathString("string(./name)", ctxt);
    if (def->name == NULL)
        ignore_value(virAsprintf(&def->name, "%ld", tv.tv_sec));

    if (def->name == NULL) {
        virReportOOMError();
        goto cleanup;
    }

    def->description = virXPathString("string(./description)", ctxt);

    if (!newSnapshot) {
        if (virXPathLong("string(./creationTime)", ctxt,
                         &def->creationTime) < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                 _("missing creationTime from existing snapshot"));
            goto cleanup;
        }

        def->parent = virXPathString("string(./parent/name)", ctxt);

        state = virXPathString("string(./state)", ctxt);
        if (state == NULL) {
            /* there was no state in an existing snapshot; this
             * should never happen
             */
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                 _("missing state from existing snapshot"));
            goto cleanup;
        }
        def->state = virDomainStateTypeFromString(state);
        if (def->state < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                                 _("Invalid state '%s' in domain snapshot XML"),
                                 state);
            goto cleanup;
        }

        if (virXPathLong("string(./active)", ctxt, &def->active) < 0) {
            virDomainReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                 _("Could not find 'active' element"));
            goto cleanup;
        }
    }
    else
        def->creationTime = tv.tv_sec;

    ret = def;

cleanup:
    VIR_FREE(creation);
    VIR_FREE(state);
    xmlXPathFreeContext(ctxt);
    if (ret == NULL)
        virDomainSnapshotDefFree(def);
    xmlFreeDoc(xml);

    return ret;
}

char *virDomainSnapshotDefFormat(char *domain_uuid,
                                 virDomainSnapshotDefPtr def,
                                 int internal)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

    virBufferAddLit(&buf, "<domainsnapshot>\n");
    virBufferVSprintf(&buf, "  <name>%s</name>\n", def->name);
    if (def->description)
        virBufferVSprintf(&buf, "  <description>%s</description>\n",
                          def->description);
    virBufferVSprintf(&buf, "  <state>%s</state>\n",
                      virDomainStateTypeToString(def->state));
    if (def->parent) {
        virBufferAddLit(&buf, "  <parent>\n");
        virBufferVSprintf(&buf, "    <name>%s</name>\n", def->parent);
        virBufferAddLit(&buf, "  </parent>\n");
    }
    virBufferVSprintf(&buf, "  <creationTime>%ld</creationTime>\n",
                      def->creationTime);
    virBufferAddLit(&buf, "  <domain>\n");
    virBufferVSprintf(&buf, "    <uuid>%s</uuid>\n", domain_uuid);
    virBufferAddLit(&buf, "  </domain>\n");
    if (internal)
        virBufferVSprintf(&buf, "  <active>%ld</active>\n", def->active);
    virBufferAddLit(&buf, "</domainsnapshot>\n");

    if (virBufferError(&buf)) {
        virBufferFreeAndReset(&buf);
        virReportOOMError();
        return NULL;
    }

    return virBufferContentAndReset(&buf);
}

/* Snapshot Obj functions */
static virDomainSnapshotObjPtr virDomainSnapshotObjNew(void)
{
    virDomainSnapshotObjPtr snapshot;

    if (VIR_ALLOC(snapshot) < 0) {
        virReportOOMError();
        return NULL;
    }

    snapshot->refs = 1;

    VIR_DEBUG("obj=%p", snapshot);

    return snapshot;
}

static void virDomainSnapshotObjFree(virDomainSnapshotObjPtr snapshot)
{
    if (!snapshot)
        return;

    VIR_DEBUG("obj=%p", snapshot);

    virDomainSnapshotDefFree(snapshot->def);
7042
    VIR_FREE(snapshot);
C
Chris Lalancette 已提交
7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099
}

int virDomainSnapshotObjUnref(virDomainSnapshotObjPtr snapshot)
{
    snapshot->refs--;
    VIR_DEBUG("obj=%p refs=%d", snapshot, snapshot->refs);
    if (snapshot->refs == 0) {
        virDomainSnapshotObjFree(snapshot);
        return 0;
    }
    return snapshot->refs;
}

virDomainSnapshotObjPtr virDomainSnapshotAssignDef(virDomainSnapshotObjListPtr snapshots,
                                                   const virDomainSnapshotDefPtr def)
{
    virDomainSnapshotObjPtr snap;

    if (virHashLookup(snapshots->objs, def->name) != NULL) {
        virDomainReportError(VIR_ERR_INTERNAL_ERROR,
                             _("unexpected domain snapshot %s already exists"),
                             def->name);
        return NULL;
    }

    if (!(snap = virDomainSnapshotObjNew()))
        return NULL;
    snap->def = def;

    if (virHashAddEntry(snapshots->objs, snap->def->name, snap) < 0) {
        VIR_FREE(snap);
        virReportOOMError();
        return NULL;
    }

    return snap;
}

/* Snapshot Obj List functions */
int virDomainSnapshotObjListInit(virDomainSnapshotObjListPtr snapshots)
{
    snapshots->objs = virHashCreate(50);
    if (!snapshots->objs) {
        virReportOOMError();
        return -1;
    }
    return 0;
}

static void virDomainSnapshotObjListDeallocator(void *payload,
                                                const char *name ATTRIBUTE_UNUSED)
{
    virDomainSnapshotObjPtr obj = payload;

    virDomainSnapshotObjUnref(obj);
}

7100
static void virDomainSnapshotObjListDeinit(virDomainSnapshotObjListPtr snapshots)
C
Chris Lalancette 已提交
7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223
{
    if (snapshots->objs)
        virHashFree(snapshots->objs, virDomainSnapshotObjListDeallocator);
}

struct virDomainSnapshotNameData {
    int oom;
    int numnames;
    int maxnames;
    char **const names;
};

static void virDomainSnapshotObjListCopyNames(void *payload,
                                              const char *name ATTRIBUTE_UNUSED,
                                              void *opaque)
{
    virDomainSnapshotObjPtr obj = payload;
    struct virDomainSnapshotNameData *data = opaque;

    if (data->oom)
        return;

    if (data->numnames < data->maxnames) {
        if (!(data->names[data->numnames] = strdup(obj->def->name)))
            data->oom = 1;
        else
            data->numnames++;
    }
}

int virDomainSnapshotObjListGetNames(virDomainSnapshotObjListPtr snapshots,
                                     char **const names, int maxnames)
{
    struct virDomainSnapshotNameData data = { 0, 0, maxnames, names };
    int i;

    virHashForEach(snapshots->objs, virDomainSnapshotObjListCopyNames, &data);
    if (data.oom) {
        virReportOOMError();
        goto cleanup;
    }

    return data.numnames;

cleanup:
    for (i = 0; i < data.numnames; i++)
        VIR_FREE(data.names[i]);
    return -1;
}

static void virDomainSnapshotObjListCount(void *payload ATTRIBUTE_UNUSED,
                                          const char *name ATTRIBUTE_UNUSED,
                                          void *data)
{
    int *count = data;

    (*count)++;
}

int virDomainSnapshotObjListNum(virDomainSnapshotObjListPtr snapshots)
{
    int count = 0;

    virHashForEach(snapshots->objs, virDomainSnapshotObjListCount, &count);

    return count;
}

static int virDomainSnapshotObjListSearchName(const void *payload,
                                              const char *name ATTRIBUTE_UNUSED,
                                              const void *data)
{
    virDomainSnapshotObjPtr obj = (virDomainSnapshotObjPtr)payload;
    int want = 0;

    if (STREQ(obj->def->name, (const char *)data))
        want = 1;

    return want;
}

virDomainSnapshotObjPtr virDomainSnapshotFindByName(const virDomainSnapshotObjListPtr snapshots,
                                                    const char *name)
{
    return virHashSearch(snapshots->objs, virDomainSnapshotObjListSearchName, name);
}

void virDomainSnapshotObjListRemove(virDomainSnapshotObjListPtr snapshots,
                                    virDomainSnapshotObjPtr snapshot)
{
    virHashRemoveEntry(snapshots->objs, snapshot->def->name,
                       virDomainSnapshotObjListDeallocator);
}

struct snapshot_has_children {
    char *name;
    int number;
};

static void virDomainSnapshotCountChildren(void *payload,
                                           const char *name ATTRIBUTE_UNUSED,
                                           void *data)
{
    virDomainSnapshotObjPtr obj = payload;
    struct snapshot_has_children *curr = data;

    if (obj->def->parent && STREQ(obj->def->parent, curr->name))
        curr->number++;
}

int virDomainSnapshotHasChildren(virDomainSnapshotObjPtr snap,
                                virDomainSnapshotObjListPtr snapshots)
{
    struct snapshot_has_children children;

    children.name = snap->def->name;
    children.number = 0;
    virHashForEach(snapshots->objs, virDomainSnapshotCountChildren, &children);

    return children.number;
}


7224
#endif /* ! PROXY */