domain_conf.h 88.4 KB
Newer Older
1 2 3
/*
 * domain_conf.h: domain XML processing
 *
4
 * Copyright (C) 2006-2014 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17
 * 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
18
 * License along with this library.  If not, see
O
Osier Yang 已提交
19
 * <http://www.gnu.org/licenses/>.
20 21 22 23 24
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#ifndef __DOMAIN_CONF_H
25
# define __DOMAIN_CONF_H
26

27 28 29
# include <libxml/parser.h>
# include <libxml/tree.h>
# include <libxml/xpath.h>
30

31 32
# include "internal.h"
# include "capabilities.h"
33
# include "virstorageencryption.h"
34
# include "cpu_conf.h"
35
# include "virthread.h"
36
# include "virhash.h"
37
# include "virsocketaddr.h"
38
# include "nwfilter_params.h"
39
# include "numatune_conf.h"
40
# include "virnetdevmacvlan.h"
41
# include "virsysinfo.h"
42
# include "virnetdevvportprofile.h"
A
Ansis Atteka 已提交
43
# include "virnetdevopenvswitch.h"
44
# include "virnetdevbandwidth.h"
45
# include "virnetdevvlan.h"
46
# include "virobject.h"
47
# include "device_conf.h"
48
# include "virbitmap.h"
49
# include "virstoragefile.h"
50
# include "virseclabel.h"
51

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
/* forward declarations of all device types, required by
 * virDomainDeviceDef
 */
typedef struct _virDomainDiskDef virDomainDiskDef;
typedef virDomainDiskDef *virDomainDiskDefPtr;

typedef struct _virDomainControllerDef virDomainControllerDef;
typedef virDomainControllerDef *virDomainControllerDefPtr;

typedef struct _virDomainLeaseDef virDomainLeaseDef;
typedef virDomainLeaseDef *virDomainLeaseDefPtr;

typedef struct _virDomainFSDef virDomainFSDef;
typedef virDomainFSDef *virDomainFSDefPtr;

typedef struct _virDomainNetDef virDomainNetDef;
typedef virDomainNetDef *virDomainNetDefPtr;

typedef struct _virDomainInputDef virDomainInputDef;
typedef virDomainInputDef *virDomainInputDefPtr;

73 74 75
typedef struct _virDomainSoundCodecDef virDomainSoundCodecDef;
typedef virDomainSoundCodecDef *virDomainSoundCodecDefPtr;

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
typedef struct _virDomainSoundDef virDomainSoundDef;
typedef virDomainSoundDef *virDomainSoundDefPtr;

typedef struct _virDomainVideoDef virDomainVideoDef;
typedef virDomainVideoDef *virDomainVideoDefPtr;

typedef struct _virDomainHostdevDef virDomainHostdevDef;
typedef virDomainHostdevDef *virDomainHostdevDefPtr;

typedef struct _virDomainWatchdogDef virDomainWatchdogDef;
typedef virDomainWatchdogDef *virDomainWatchdogDefPtr;

typedef struct _virDomainGraphicsDef virDomainGraphicsDef;
typedef virDomainGraphicsDef *virDomainGraphicsDefPtr;

typedef struct _virDomainHubDef virDomainHubDef;
typedef virDomainHubDef *virDomainHubDefPtr;

typedef struct _virDomainRedirdevDef virDomainRedirdevDef;
typedef virDomainRedirdevDef *virDomainRedirdevDefPtr;

97 98
typedef struct _virDomainRedirFilterUSBDevDef virDomainRedirFilterUSBDevDef;
typedef virDomainRedirFilterUSBDevDef *virDomainRedirFilterUSBDevDefPtr;
99 100 101 102

typedef struct _virDomainRedirFilterDef virDomainRedirFilterDef;
typedef virDomainRedirFilterDef *virDomainRedirFilterDefPtr;

103 104 105 106 107 108 109 110 111
typedef struct _virDomainSmartcardDef virDomainSmartcardDef;
typedef virDomainSmartcardDef *virDomainSmartcardDefPtr;

typedef struct _virDomainChrDef virDomainChrDef;
typedef virDomainChrDef *virDomainChrDefPtr;

typedef struct _virDomainMemballoonDef virDomainMemballoonDef;
typedef virDomainMemballoonDef *virDomainMemballoonDefPtr;

L
Li Zhang 已提交
112 113 114
typedef struct _virDomainNVRAMDef virDomainNVRAMDef;
typedef virDomainNVRAMDef *virDomainNVRAMDefPtr;

115 116 117 118 119 120
typedef struct _virDomainSnapshotObj virDomainSnapshotObj;
typedef virDomainSnapshotObj *virDomainSnapshotObjPtr;

typedef struct _virDomainSnapshotObjList virDomainSnapshotObjList;
typedef virDomainSnapshotObjList *virDomainSnapshotObjListPtr;

121 122 123
typedef struct _virDomainRNGDef virDomainRNGDef;
typedef virDomainRNGDef *virDomainRNGDefPtr;

124 125 126 127 128 129
typedef struct _virDomainIdMapEntry virDomainIdMapEntry;
typedef virDomainIdMapEntry *virDomainIdMapEntryPtr;

typedef struct _virDomainIdMapDef virDomainIdMapDef;
typedef virDomainIdMapDef *virDomainIdMapDefPtr;

H
Hu Tao 已提交
130 131 132
typedef struct _virDomainPanicDef virDomainPanicDef;
typedef virDomainPanicDef *virDomainPanicDefPtr;

M
Michele Paolino 已提交
133 134 135 136 137 138
/* forward declarations virDomainChrSourceDef, required by
 * virDomainNetDef
 */
typedef struct _virDomainChrSourceDef virDomainChrSourceDef;
typedef virDomainChrSourceDef *virDomainChrSourceDefPtr;

139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
/* Flags for the 'type' field in virDomainDeviceDef */
typedef enum {
    VIR_DOMAIN_DEVICE_NONE = 0,
    VIR_DOMAIN_DEVICE_DISK,
    VIR_DOMAIN_DEVICE_LEASE,
    VIR_DOMAIN_DEVICE_FS,
    VIR_DOMAIN_DEVICE_NET,
    VIR_DOMAIN_DEVICE_INPUT,
    VIR_DOMAIN_DEVICE_SOUND,
    VIR_DOMAIN_DEVICE_VIDEO,
    VIR_DOMAIN_DEVICE_HOSTDEV,
    VIR_DOMAIN_DEVICE_WATCHDOG,
    VIR_DOMAIN_DEVICE_CONTROLLER,
    VIR_DOMAIN_DEVICE_GRAPHICS,
    VIR_DOMAIN_DEVICE_HUB,
    VIR_DOMAIN_DEVICE_REDIRDEV,
    VIR_DOMAIN_DEVICE_SMARTCARD,
    VIR_DOMAIN_DEVICE_CHR,
    VIR_DOMAIN_DEVICE_MEMBALLOON,
L
Li Zhang 已提交
158
    VIR_DOMAIN_DEVICE_NVRAM,
159
    VIR_DOMAIN_DEVICE_RNG,
160

161
    VIR_DOMAIN_DEVICE_LAST
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
} virDomainDeviceType;

typedef struct _virDomainDeviceDef virDomainDeviceDef;
typedef virDomainDeviceDef *virDomainDeviceDefPtr;
struct _virDomainDeviceDef {
    int type; /* enum virDomainDeviceType */
    union {
        virDomainDiskDefPtr disk;
        virDomainControllerDefPtr controller;
        virDomainLeaseDefPtr lease;
        virDomainFSDefPtr fs;
        virDomainNetDefPtr net;
        virDomainInputDefPtr input;
        virDomainSoundDefPtr sound;
        virDomainVideoDefPtr video;
        virDomainHostdevDefPtr hostdev;
        virDomainWatchdogDefPtr watchdog;
        virDomainGraphicsDefPtr graphics;
        virDomainHubDefPtr hub;
        virDomainRedirdevDefPtr redirdev;
        virDomainSmartcardDefPtr smartcard;
        virDomainChrDefPtr chr;
        virDomainMemballoonDefPtr memballoon;
L
Li Zhang 已提交
185
        virDomainNVRAMDefPtr nvram;
186
        virDomainRNGDefPtr rng;
187 188 189
    } data;
};

190 191
/* Different types of hypervisor */
/* NB: Keep in sync with virDomainVirtTypeToString impl */
192
typedef enum {
193 194 195 196 197 198 199 200 201 202
    VIR_DOMAIN_VIRT_QEMU,
    VIR_DOMAIN_VIRT_KQEMU,
    VIR_DOMAIN_VIRT_KVM,
    VIR_DOMAIN_VIRT_XEN,
    VIR_DOMAIN_VIRT_LXC,
    VIR_DOMAIN_VIRT_UML,
    VIR_DOMAIN_VIRT_OPENVZ,
    VIR_DOMAIN_VIRT_TEST,
    VIR_DOMAIN_VIRT_VMWARE,
    VIR_DOMAIN_VIRT_HYPERV,
203
    VIR_DOMAIN_VIRT_VBOX,
204
    VIR_DOMAIN_VIRT_PHYP,
D
Dmitry Guryanov 已提交
205
    VIR_DOMAIN_VIRT_PARALLELS,
R
Roman Bogorodskiy 已提交
206
    VIR_DOMAIN_VIRT_BHYVE,
207

208
    VIR_DOMAIN_VIRT_LAST
209
} virDomainVirtType;
210

211
typedef enum {
212 213
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE,
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI,
214
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE,
215
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL,
E
Eric Blake 已提交
216
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCID,
217
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB,
218
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO,
219
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390,
220
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW,
221
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO,
H
Hu Tao 已提交
222
    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_ISA,
223 224

    VIR_DOMAIN_DEVICE_ADDRESS_TYPE_LAST
225
} virDomainDeviceAddressType;
226

227 228 229 230 231
typedef struct _virDomainDeviceDriveAddress virDomainDeviceDriveAddress;
typedef virDomainDeviceDriveAddress *virDomainDeviceDriveAddressPtr;
struct _virDomainDeviceDriveAddress {
    unsigned int controller;
    unsigned int bus;
232
    unsigned int target;
233 234 235
    unsigned int unit;
};

236 237 238 239 240
typedef struct _virDomainDeviceVirtioSerialAddress virDomainDeviceVirtioSerialAddress;
typedef virDomainDeviceVirtioSerialAddress *virDomainDeviceVirtioSerialAddressPtr;
struct _virDomainDeviceVirtioSerialAddress {
    unsigned int controller;
    unsigned int bus;
241
    unsigned int port;
242 243
};

244 245 246 247 248 249 250 251 252 253 254 255 256
# define VIR_DOMAIN_DEVICE_CCW_MAX_CSSID    254
# define VIR_DOMAIN_DEVICE_CCW_MAX_SSID       3
# define VIR_DOMAIN_DEVICE_CCW_MAX_DEVNO  65535

typedef struct _virDomainDeviceCCWAddress virDomainDeviceCCWAddress;
typedef virDomainDeviceCCWAddress *virDomainDeviceCCWAddressPtr;
struct _virDomainDeviceCCWAddress {
    unsigned int cssid;
    unsigned int ssid;
    unsigned int devno;
    bool         assigned;
};

E
Eric Blake 已提交
257 258 259 260 261 262 263
typedef struct _virDomainDeviceCcidAddress virDomainDeviceCcidAddress;
typedef virDomainDeviceCcidAddress *virDomainDeviceCcidAddressPtr;
struct _virDomainDeviceCcidAddress {
    unsigned int controller;
    unsigned int slot;
};

264 265 266 267
typedef struct _virDomainDeviceUSBAddress virDomainDeviceUSBAddress;
typedef virDomainDeviceUSBAddress *virDomainDeviceUSBAddressPtr;
struct _virDomainDeviceUSBAddress {
    unsigned int bus;
268
    char *port;
269 270
};

271 272 273 274 275 276 277
typedef struct _virDomainDeviceSpaprVioAddress virDomainDeviceSpaprVioAddress;
typedef virDomainDeviceSpaprVioAddress *virDomainDeviceSpaprVioAddressPtr;
struct _virDomainDeviceSpaprVioAddress {
    unsigned long long reg;
    bool has_reg;
};

278
typedef enum {
279 280 281 282
    VIR_DOMAIN_CONTROLLER_MASTER_NONE,
    VIR_DOMAIN_CONTROLLER_MASTER_USB,

    VIR_DOMAIN_CONTROLLER_MASTER_LAST
283
} virDomainControllerMaster;
284 285 286 287 288 289 290

typedef struct _virDomainDeviceUSBMaster virDomainDeviceUSBMaster;
typedef virDomainDeviceUSBMaster *virDomainDeviceUSBMasterPtr;
struct _virDomainDeviceUSBMaster {
    unsigned int startport;
};

H
Hu Tao 已提交
291 292 293 294 295 296 297
typedef struct _virDomainDeviceISAAddress virDomainDeviceISAAddress;
typedef virDomainDeviceISAAddress *virDomainDeviceISAAddressPtr;
struct _virDomainDeviceISAAddress {
    unsigned int iobase;
    unsigned int irq;
};

298 299 300
typedef struct _virDomainDeviceInfo virDomainDeviceInfo;
typedef virDomainDeviceInfo *virDomainDeviceInfoPtr;
struct _virDomainDeviceInfo {
301 302 303 304
    /* If adding to this struct, ensure that
     * virDomainDeviceInfoIsSet() is updated
     * to consider the new fields
     */
D
Daniel P. Berrange 已提交
305
    char *alias;
306 307
    int type;
    union {
308
        virDevicePCIAddress pci;
309
        virDomainDeviceDriveAddress drive;
310
        virDomainDeviceVirtioSerialAddress vioserial;
E
Eric Blake 已提交
311
        virDomainDeviceCcidAddress ccid;
312
        virDomainDeviceUSBAddress usb;
313
        virDomainDeviceSpaprVioAddress spaprvio;
314
        virDomainDeviceCCWAddress ccw;
H
Hu Tao 已提交
315
        virDomainDeviceISAAddress isa;
316
    } addr;
317 318 319 320
    int mastertype;
    union {
        virDomainDeviceUSBMaster usb;
    } master;
321 322
    /* rombar and romfile are only used for pci hostdev and network
     * devices. */
J
Ján Tomko 已提交
323
    int rombar;         /* enum virTristateSwitch */
324
    char *romfile;
325 326
    /* bootIndex is only used for disk, network interface, hostdev
     * and redirdev devices */
327
    int bootIndex;
328 329
};

330

331 332 333 334 335 336 337 338
typedef struct _virDomainHostdevOrigStates virDomainHostdevOrigStates;
typedef virDomainHostdevOrigStates *virDomainHostdevOrigStatesPtr;
struct _virDomainHostdevOrigStates {
    union {
        struct {
            /* Does the device need to unbind from stub when
             * reattaching to host?
             */
339
            bool unbind_from_stub;
340 341 342 343

            /* Does it need to use remove_slot when reattaching
             * the device to host?
             */
344
            bool remove_slot;
345 346 347 348

            /* Does it need to reprobe driver for the device when
             * reattaching to host?
             */
349
            bool reprobe;
350 351 352 353 354 355
        } pci;

        /* Perhaps 'usb' in future */
    } states;
};

356 357 358 359 360 361 362
struct _virDomainLeaseDef {
    char *lockspace;
    char *key;
    char *path;
    unsigned long long offset;
};

363

364
typedef enum {
365 366 367
    VIR_DOMAIN_HOSTDEV_MODE_SUBSYS,
    VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES,

368
    VIR_DOMAIN_HOSTDEV_MODE_LAST
369
} virDomainHostdevMode;
370

371
typedef enum {
372 373
    VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB,
    VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI,
H
Han Cheng 已提交
374
    VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI,
375 376

    VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_LAST
377
} virDomainHostdevSubsysType;
378

379 380
/* the backend driver used for PCI hostdev devices */
typedef enum {
381
    VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT, /* detect automaticaly, prefer VFIO */
382 383
    VIR_DOMAIN_HOSTDEV_PCI_BACKEND_KVM,    /* force legacy kvm style */
    VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO,   /* force vfio */
384
    VIR_DOMAIN_HOSTDEV_PCI_BACKEND_XEN,    /* force legacy xen style, use pciback */
385 386

    VIR_DOMAIN_HOSTDEV_PCI_BACKEND_TYPE_LAST
387
} virDomainHostdevSubsysPCIBackendType;
388

389
VIR_ENUM_DECL(virDomainHostdevSubsysPCIBackend)
390

391 392 393 394 395 396 397 398 399
typedef enum {
    VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_NONE,
    VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI,

    VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_LAST,
} virDomainHostdevSCSIProtocolType;

VIR_ENUM_DECL(virDomainHostdevSubsysSCSIProtocol)

400 401 402 403 404 405 406 407 408 409 410 411
typedef struct _virDomainHostdevSubsysUSB virDomainHostdevSubsysUSB;
typedef virDomainHostdevSubsysUSB *virDomainHostdevSubsysUSBPtr;
struct _virDomainHostdevSubsysUSB {
    bool autoAddress; /* bus/device were filled automatically based
                         on vendor/product */
    unsigned bus;
    unsigned device;

    unsigned vendor;
    unsigned product;
};

412 413 414 415 416 417 418
typedef struct _virDomainHostdevSubsysPCI virDomainHostdevSubsysPCI;
typedef virDomainHostdevSubsysPCI *virDomainHostdevSubsysPCIPtr;
struct _virDomainHostdevSubsysPCI {
    virDevicePCIAddress addr; /* host address */
    int backend; /* enum virDomainHostdevSubsysPCIBackendType */
};

419 420 421
typedef struct _virDomainHostdevSubsysSCSIHost virDomainHostdevSubsysSCSIHost;
typedef virDomainHostdevSubsysSCSIHost *virDomainHostdevSubsysSCSIHostPtr;
struct _virDomainHostdevSubsysSCSIHost {
422 423 424 425
    char *adapter;
    unsigned bus;
    unsigned target;
    unsigned unit;
426 427
};

428 429 430 431 432 433 434 435 436
typedef struct _virDomainHostdevSubsysSCSIiSCSI virDomainHostdevSubsysSCSIiSCSI;
typedef virDomainHostdevSubsysSCSIiSCSI *virDomainHostdevSubsysSCSIiSCSIPtr;
struct _virDomainHostdevSubsysSCSIiSCSI {
    char *path;
    size_t nhosts;
    virStorageNetHostDefPtr hosts;
    virStorageAuthDefPtr auth;
};

437 438 439
typedef struct _virDomainHostdevSubsysSCSI virDomainHostdevSubsysSCSI;
typedef virDomainHostdevSubsysSCSI *virDomainHostdevSubsysSCSIPtr;
struct _virDomainHostdevSubsysSCSI {
440
    int protocol; /* enum virDomainHostdevSCSIProtocolType */
441
    int sgio; /* enum virDomainDeviceSGIO */
442
    int rawio; /* enum virTristateBool */
443 444
    union {
        virDomainHostdevSubsysSCSIHost host;
445
        virDomainHostdevSubsysSCSIiSCSI iscsi;
446
    } u;
447 448
};

449 450 451
typedef struct _virDomainHostdevSubsys virDomainHostdevSubsys;
typedef virDomainHostdevSubsys *virDomainHostdevSubsysPtr;
struct _virDomainHostdevSubsys {
452
    int type; /* enum virDomainHostdevSubsysType */
453
    union {
454
        virDomainHostdevSubsysUSB usb;
455
        virDomainHostdevSubsysPCI pci;
456
        virDomainHostdevSubsysSCSI scsi;
457 458 459
    } u;
};

460

461
typedef enum {
462 463
    VIR_DOMAIN_HOSTDEV_CAPS_TYPE_STORAGE,
    VIR_DOMAIN_HOSTDEV_CAPS_TYPE_MISC,
464
    VIR_DOMAIN_HOSTDEV_CAPS_TYPE_NET,
465 466

    VIR_DOMAIN_HOSTDEV_CAPS_TYPE_LAST
467
} virDomainHostdevCapsType;
468 469 470 471 472 473 474 475 476 477 478 479

typedef struct _virDomainHostdevCaps virDomainHostdevCaps;
typedef virDomainHostdevCaps *virDomainHostdevCapsPtr;
struct _virDomainHostdevCaps {
    int type; /* enum virDOmainHostdevCapsType */
    union {
        struct {
            char *block;
        } storage;
        struct {
            char *chardev;
        } misc;
480 481 482
        struct {
            char *iface;
        } net;
483 484 485 486
    } u;
};


487 488
/* basic device for direct passthrough */
struct _virDomainHostdevDef {
489
    virDomainDeviceDef parent; /* higher level Def containing this */
490
    int mode; /* enum virDomainHostdevMode */
491
    int startupPolicy; /* enum virDomainStartupPolicy */
492
    bool managed;
493
    bool missing;
O
Osier Yang 已提交
494
    bool readonly;
495
    bool shareable;
496
    union {
497
        virDomainHostdevSubsys subsys;
498
        virDomainHostdevCaps caps;
499 500
    } source;
    virDomainHostdevOrigStates origstates;
501
    virDomainDeviceInfoPtr info; /* Guest address */
502 503
};

504

E
Eric Blake 已提交
505 506
/* Types of disk frontend (guest view).  For backends (host view), see
 * virStorageType in util/virstoragefile.h */
507
typedef enum {
508 509 510
    VIR_DOMAIN_DISK_DEVICE_DISK,
    VIR_DOMAIN_DISK_DEVICE_CDROM,
    VIR_DOMAIN_DISK_DEVICE_FLOPPY,
511
    VIR_DOMAIN_DISK_DEVICE_LUN,
512 513

    VIR_DOMAIN_DISK_DEVICE_LAST
514
} virDomainDiskDevice;
515

516
typedef enum {
517 518 519 520 521
    VIR_DOMAIN_DISK_BUS_IDE,
    VIR_DOMAIN_DISK_BUS_FDC,
    VIR_DOMAIN_DISK_BUS_SCSI,
    VIR_DOMAIN_DISK_BUS_VIRTIO,
    VIR_DOMAIN_DISK_BUS_XEN,
522
    VIR_DOMAIN_DISK_BUS_USB,
523
    VIR_DOMAIN_DISK_BUS_UML,
524
    VIR_DOMAIN_DISK_BUS_SATA,
525
    VIR_DOMAIN_DISK_BUS_SD,
526 527

    VIR_DOMAIN_DISK_BUS_LAST
528
} virDomainDiskBus;
529

530
typedef enum {
531 532 533 534
    VIR_DOMAIN_DISK_CACHE_DEFAULT,
    VIR_DOMAIN_DISK_CACHE_DISABLE,
    VIR_DOMAIN_DISK_CACHE_WRITETHRU,
    VIR_DOMAIN_DISK_CACHE_WRITEBACK,
535
    VIR_DOMAIN_DISK_CACHE_DIRECTSYNC,
536
    VIR_DOMAIN_DISK_CACHE_UNSAFE,
537 538

    VIR_DOMAIN_DISK_CACHE_LAST
539
} virDomainDiskCache;
540

541
typedef enum {
542 543
    VIR_DOMAIN_DISK_ERROR_POLICY_DEFAULT,
    VIR_DOMAIN_DISK_ERROR_POLICY_STOP,
544
    VIR_DOMAIN_DISK_ERROR_POLICY_REPORT,
545
    VIR_DOMAIN_DISK_ERROR_POLICY_IGNORE,
546
    VIR_DOMAIN_DISK_ERROR_POLICY_ENOSPACE,
547 548

    VIR_DOMAIN_DISK_ERROR_POLICY_LAST
549
} virDomainDiskErrorPolicy;
550

M
MORITA Kazutaka 已提交
551

552
typedef enum {
553 554 555 556
    VIR_DOMAIN_DISK_TRAY_CLOSED,
    VIR_DOMAIN_DISK_TRAY_OPEN,

    VIR_DOMAIN_DISK_TRAY_LAST
557
} virDomainDiskTray;
558

559
typedef enum {
J
J.B. Joret 已提交
560 561 562 563 564 565
    VIR_DOMAIN_DISK_TRANS_DEFAULT = 0,
    VIR_DOMAIN_DISK_TRANS_NONE,
    VIR_DOMAIN_DISK_TRANS_AUTO,
    VIR_DOMAIN_DISK_TRANS_LBA,

    VIR_DOMAIN_DISK_TRANS_LAST
566
} virDomainDiskGeometryTrans;
J
J.B. Joret 已提交
567

568
typedef enum {
M
Matthias Dahl 已提交
569 570 571 572 573
    VIR_DOMAIN_DISK_IO_DEFAULT,
    VIR_DOMAIN_DISK_IO_NATIVE,
    VIR_DOMAIN_DISK_IO_THREADS,

    VIR_DOMAIN_DISK_IO_LAST
574
} virDomainDiskIo;
M
Matthias Dahl 已提交
575

576
typedef enum {
577 578 579 580 581 582
    VIR_DOMAIN_STARTUP_POLICY_DEFAULT = 0,
    VIR_DOMAIN_STARTUP_POLICY_MANDATORY,
    VIR_DOMAIN_STARTUP_POLICY_REQUISITE,
    VIR_DOMAIN_STARTUP_POLICY_OPTIONAL,

    VIR_DOMAIN_STARTUP_POLICY_LAST
583
} virDomainStartupPolicy;
584

585

586
typedef enum {
587 588 589
    VIR_DOMAIN_DEVICE_SGIO_DEFAULT = 0,
    VIR_DOMAIN_DEVICE_SGIO_FILTERED,
    VIR_DOMAIN_DEVICE_SGIO_UNFILTERED,
O
Osier Yang 已提交
590

591
    VIR_DOMAIN_DEVICE_SGIO_LAST
592
} virDomainDeviceSGIO;
O
Osier Yang 已提交
593

594
typedef enum {
O
Osier Yang 已提交
595
    VIR_DOMAIN_DISK_DISCARD_DEFAULT = 0,
O
Osier Yang 已提交
596 597
    VIR_DOMAIN_DISK_DISCARD_UNMAP,
    VIR_DOMAIN_DISK_DISCARD_IGNORE,
O
Osier Yang 已提交
598 599

    VIR_DOMAIN_DISK_DISCARD_LAST
600
} virDomainDiskDiscard;
O
Osier Yang 已提交
601

L
Lei Li 已提交
602 603 604 605 606 607 608 609 610 611 612
typedef struct _virDomainBlockIoTuneInfo virDomainBlockIoTuneInfo;
struct _virDomainBlockIoTuneInfo {
    unsigned long long total_bytes_sec;
    unsigned long long read_bytes_sec;
    unsigned long long write_bytes_sec;
    unsigned long long total_iops_sec;
    unsigned long long read_iops_sec;
    unsigned long long write_iops_sec;
};
typedef virDomainBlockIoTuneInfo *virDomainBlockIoTuneInfoPtr;

613

614 615 616 617 618 619 620 621 622 623
typedef enum {
    VIR_DOMAIN_DISK_MIRROR_STATE_NONE = 0, /* No job, or job still not synced */
    VIR_DOMAIN_DISK_MIRROR_STATE_READY, /* Job in second phase */
    VIR_DOMAIN_DISK_MIRROR_STATE_ABORT, /* Job aborted, waiting for event */
    VIR_DOMAIN_DISK_MIRROR_STATE_PIVOT, /* Job pivoted, waiting for event */

    VIR_DOMAIN_DISK_MIRROR_STATE_LAST
} virDomainDiskMirrorState;


624 625
/* Stores the virtual disk configuration */
struct _virDomainDiskDef {
626
    virStorageSourcePtr src; /* non-NULL.  XXX Allow NULL for empty cdrom? */
627 628 629 630 631

    int device; /* enum virDomainDiskDevice */
    int bus; /* enum virDomainDiskBus */
    char *dst;
    int tray_status; /* enum virDomainDiskTray */
J
Ján Tomko 已提交
632
    int removable; /* enum virTristateSwitch */
L
Lei Li 已提交
633

634
    virStorageSourcePtr mirror;
635
    int mirrorState; /* enum virDomainDiskMirrorState */
E
Eric Blake 已提交
636
    int mirrorJob; /* virDomainBlockJobType */
637

J
J.B. Joret 已提交
638 639 640 641
    struct {
        unsigned int cylinders;
        unsigned int heads;
        unsigned int sectors;
642
        int trans; /* enum virDomainDiskGeometryTrans */
J
J.B. Joret 已提交
643 644
    } geometry;

645 646 647
    struct {
        unsigned int logical_block_size;
        unsigned int physical_block_size;
V
Viktor Mihajlovski 已提交
648
    } blockio;
649

L
Lei Li 已提交
650 651
    virDomainBlockIoTuneInfo blkdeviotune;

652
    char *serial;
O
Osier Yang 已提交
653
    char *wwn;
654 655
    char *vendor;
    char *product;
656
    int cachemode; /* enum virDomainDiskCache */
657 658
    int error_policy;  /* enum virDomainDiskErrorPolicy */
    int rerror_policy; /* enum virDomainDiskErrorPolicy */
659
    int iomode; /* enum virDomainDiskIo */
J
Ján Tomko 已提交
660 661 662
    int ioeventfd; /* enum virTristateSwitch */
    int event_idx; /* enum virTristateSwitch */
    int copy_on_read; /* enum virTristateSwitch */
663
    int snapshot; /* virDomainSnapshotLocation, snapshot_conf.h */
664
    int startupPolicy; /* enum virDomainStartupPolicy */
665
    bool transient;
666
    virDomainDeviceInfo info;
667
    int rawio; /* enum virTristateBool */
668
    int sgio; /* enum virDomainDeviceSGIO */
O
Osier Yang 已提交
669
    int discard; /* enum virDomainDiskDiscard */
670
    unsigned int iothread; /* unused = 0, > 0 specific thread # */
671 672 673
};


674
typedef enum {
675 676 677 678
    VIR_DOMAIN_CONTROLLER_TYPE_IDE,
    VIR_DOMAIN_CONTROLLER_TYPE_FDC,
    VIR_DOMAIN_CONTROLLER_TYPE_SCSI,
    VIR_DOMAIN_CONTROLLER_TYPE_SATA,
679
    VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL,
E
Eric Blake 已提交
680
    VIR_DOMAIN_CONTROLLER_TYPE_CCID,
681
    VIR_DOMAIN_CONTROLLER_TYPE_USB,
J
Ján Tomko 已提交
682
    VIR_DOMAIN_CONTROLLER_TYPE_PCI,
683 684

    VIR_DOMAIN_CONTROLLER_TYPE_LAST
685
} virDomainControllerType;
686

687

688
typedef enum {
J
Ján Tomko 已提交
689
    VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT,
L
Laine Stump 已提交
690
    VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT,
J
Ján Tomko 已提交
691
    VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE,
692
    VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE,
J
Ján Tomko 已提交
693 694

    VIR_DOMAIN_CONTROLLER_MODEL_PCI_LAST
695
} virDomainControllerModelPCI;
J
Ján Tomko 已提交
696

697
typedef enum {
698 699 700 701 702
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_AUTO,
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_BUSLOGIC,
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC,
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSISAS1068,
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VMPVSCSI,
703
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI,
704
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI,
705
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSISAS1078,
706

707
    VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LAST
708
} virDomainControllerModelSCSI;
709

710
typedef enum {
M
Marc-André Lureau 已提交
711 712 713 714 715 716 717 718 719
    VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI,
    VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX4_UHCI,
    VIR_DOMAIN_CONTROLLER_MODEL_USB_EHCI,
    VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1,
    VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI1,
    VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI2,
    VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI3,
    VIR_DOMAIN_CONTROLLER_MODEL_USB_VT82C686B_UHCI,
    VIR_DOMAIN_CONTROLLER_MODEL_USB_PCI_OHCI,
G
Gerd Hoffmann 已提交
720
    VIR_DOMAIN_CONTROLLER_MODEL_USB_NEC_XHCI,
721
    VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE,
M
Marc-André Lureau 已提交
722 723

    VIR_DOMAIN_CONTROLLER_MODEL_USB_LAST
724
} virDomainControllerModelUSB;
M
Marc-André Lureau 已提交
725

726 727 728 729 730 731 732
typedef struct _virDomainVirtioSerialOpts virDomainVirtioSerialOpts;
typedef virDomainVirtioSerialOpts *virDomainVirtioSerialOptsPtr;
struct _virDomainVirtioSerialOpts {
    int ports;   /* -1 == undef */
    int vectors; /* -1 == undef */
};

733 734 735
typedef struct _virDomainPCIControllerOpts virDomainPCIControllerOpts;
typedef virDomainPCIControllerOpts *virDomainPCIControllerOptsPtr;
struct _virDomainPCIControllerOpts {
736 737 738 739
    bool pcihole64;
    unsigned long pcihole64size;
};

740 741 742
/* Stores the virtual disk controller configuration */
struct _virDomainControllerDef {
    int type;
743
    unsigned int idx;
744
    int model; /* -1 == undef */
745
    unsigned int queues;
746 747
    unsigned int cmd_per_lun;
    unsigned int max_sectors;
748 749
    union {
        virDomainVirtioSerialOpts vioserial;
750
        virDomainPCIControllerOpts pciopts;
751
    } opts;
752 753 754 755
    virDomainDeviceInfo info;
};


G
Giuseppe Scrivano 已提交
756
/* Types of disk backends */
757
typedef enum {
758 759 760 761 762 763
    VIR_DOMAIN_FS_TYPE_MOUNT, /* Mounts (binds) a host dir on a guest dir */
    VIR_DOMAIN_FS_TYPE_BLOCK, /* Mounts a host block dev on a guest dir */
    VIR_DOMAIN_FS_TYPE_FILE,  /* Loopback mounts a host file on a guest dir */
    VIR_DOMAIN_FS_TYPE_TEMPLATE, /* Expands a OS template to a guest dir */
    VIR_DOMAIN_FS_TYPE_RAM,   /* Mount a RAM filesystem on a guest dir */
    VIR_DOMAIN_FS_TYPE_BIND,  /* Binds a guest dir to another guest dir */
764 765

    VIR_DOMAIN_FS_TYPE_LAST
766
} virDomainFSType;
767

768
/* Filesystem driver type */
769
typedef enum {
770 771 772
    VIR_DOMAIN_FS_DRIVER_TYPE_DEFAULT = 0,
    VIR_DOMAIN_FS_DRIVER_TYPE_PATH,
    VIR_DOMAIN_FS_DRIVER_TYPE_HANDLE,
773
    VIR_DOMAIN_FS_DRIVER_TYPE_LOOP,
774
    VIR_DOMAIN_FS_DRIVER_TYPE_NBD,
775 776

    VIR_DOMAIN_FS_DRIVER_TYPE_LAST
777
} virDomainFSDriverType;
778

779
/* Filesystem mount access mode  */
780
typedef enum {
781 782 783 784 785
    VIR_DOMAIN_FS_ACCESSMODE_PASSTHROUGH,
    VIR_DOMAIN_FS_ACCESSMODE_MAPPED,
    VIR_DOMAIN_FS_ACCESSMODE_SQUASH,

    VIR_DOMAIN_FS_ACCESSMODE_LAST
786
} virDomainFSAccessMode;
787

788
/* Filesystem Write policy */
789
typedef enum {
790 791 792 793
    VIR_DOMAIN_FS_WRPOLICY_DEFAULT = 0,
    VIR_DOMAIN_FS_WRPOLICY_IMMEDIATE,

    VIR_DOMAIN_FS_WRPOLICY_LAST
794
} virDomainFSWrpolicy;
795

796 797 798
/* Allow 2 MB ram usage */
# define VIR_DOMAIN_FS_RAM_DEFAULT_USAGE (1024 * 2)

799 800
struct _virDomainFSDef {
    int type;
801 802
    int fsdriver; /* enum virDomainFSDriverType */
    int accessmode; /* enum virDomainFSAccessMode */
803
    int wrpolicy; /* enum virDomainFSWrpolicy */
804
    int format; /* virStorageFileFormat */
805
    unsigned long long usage; /* in bytes */
806 807
    char *src;
    char *dst;
808
    bool readonly;
809
    virDomainDeviceInfo info;
810 811
    unsigned long long space_hard_limit; /* in bytes */
    unsigned long long space_soft_limit; /* in bytes */
812 813 814
};


815
/* network config types */
816
typedef enum {
817 818
    VIR_DOMAIN_NET_TYPE_USER,
    VIR_DOMAIN_NET_TYPE_ETHERNET,
M
Michele Paolino 已提交
819
    VIR_DOMAIN_NET_TYPE_VHOSTUSER,
820 821 822 823 824
    VIR_DOMAIN_NET_TYPE_SERVER,
    VIR_DOMAIN_NET_TYPE_CLIENT,
    VIR_DOMAIN_NET_TYPE_MCAST,
    VIR_DOMAIN_NET_TYPE_NETWORK,
    VIR_DOMAIN_NET_TYPE_BRIDGE,
D
Daniel Veillard 已提交
825
    VIR_DOMAIN_NET_TYPE_INTERNAL,
826
    VIR_DOMAIN_NET_TYPE_DIRECT,
827
    VIR_DOMAIN_NET_TYPE_HOSTDEV,
828

829
    VIR_DOMAIN_NET_TYPE_LAST
830
} virDomainNetType;
831

832
/* the backend driver used for virtio interfaces */
833
typedef enum {
834 835 836 837
    VIR_DOMAIN_NET_BACKEND_TYPE_DEFAULT, /* prefer kernel, fall back to user */
    VIR_DOMAIN_NET_BACKEND_TYPE_QEMU,    /* userland */
    VIR_DOMAIN_NET_BACKEND_TYPE_VHOST,   /* kernel */

838
    VIR_DOMAIN_NET_BACKEND_TYPE_LAST
839
} virDomainNetBackendType;
840

841
/* the TX algorithm used for virtio interfaces */
842
typedef enum {
843 844 845 846
    VIR_DOMAIN_NET_VIRTIO_TX_MODE_DEFAULT, /* default for this version of qemu */
    VIR_DOMAIN_NET_VIRTIO_TX_MODE_IOTHREAD,
    VIR_DOMAIN_NET_VIRTIO_TX_MODE_TIMER,

847
    VIR_DOMAIN_NET_VIRTIO_TX_MODE_LAST
848
} virDomainNetVirtioTxModeType;
849

850
/* link interface states */
851
typedef enum {
852 853 854 855 856
        VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DEFAULT = 0, /* Default link state (up) */
        VIR_DOMAIN_NET_INTERFACE_LINK_STATE_UP,          /* Link is up. ("cable" connected) */
        VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN ,       /* Link is down. ("cable" disconnected) */

        VIR_DOMAIN_NET_INTERFACE_LINK_STATE_LAST
857
} virDomainNetInterfaceLinkState;
858

859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
/* Config that was actually used to bring up interface, after
 * resolving network reference. This is private data, only used within
 * libvirt, but still must maintain backward compatibility, because
 * different versions of libvirt may read the same data file.
 */
typedef struct _virDomainActualNetDef virDomainActualNetDef;
typedef virDomainActualNetDef *virDomainActualNetDefPtr;
struct _virDomainActualNetDef {
    int type; /* enum virDomainNetType */
    union {
        struct {
            char *brname;
        } bridge;
        struct {
            char *linkdev;
            int mode; /* enum virMacvtapMode from util/macvtap.h */
        } direct;
876 877 878
        struct {
            virDomainHostdevDef def;
        } hostdev;
879
    } data;
880
    virNetDevVPortProfilePtr virtPortProfile;
881
    virNetDevBandwidthPtr bandwidth;
882
    virNetDevVlan vlan;
883
    unsigned int class_id; /* class ID for bandwidth 'floor' */
884 885
};

886 887
/* Stores the virtual network interface configuration */
struct _virDomainNetDef {
888
    virDomainNetType type;
889
    virMacAddr mac;
890
    char *model;
891 892
    union {
        struct {
893 894
            virDomainNetBackendType name; /* which driver backend to use */
            virDomainNetVirtioTxModeType txmode;
J
Ján Tomko 已提交
895 896
            virTristateSwitch ioeventfd;
            virTristateSwitch event_idx;
897
            unsigned int queues; /* Multiqueue virtio-net */
898 899
        } virtio;
    } driver;
900 901 902 903
    struct {
        char *tap;
        char *vhost;
    } backend;
904 905 906 907 908
    union {
        struct {
            char *dev;
            char *ipaddr;
        } ethernet;
M
Michele Paolino 已提交
909
        virDomainChrSourceDefPtr vhostuser;
910 911 912 913 914 915
        struct {
            char *address;
            int port;
        } socket; /* any of NET_CLIENT or NET_SERVER or NET_MCAST */
        struct {
            char *name;
916 917 918 919 920 921 922 923 924 925
            char *portgroup;
            /* actual has info about the currently used physical
             * device (if the network is of type
             * bridge/private/vepa/passthrough). This is saved in the
             * domain state, but never written to persistent config,
             * since it needs to be re-allocated whenever the domain
             * is restarted. It is also never shown to the user, and
             * the user cannot specify it in XML documents.
             */
            virDomainActualNetDefPtr actual;
926 927 928
        } network;
        struct {
            char *brname;
929
            char *ipaddr;
930
        } bridge;
D
Daniel Veillard 已提交
931 932 933
        struct {
            char *name;
        } internal;
934 935
        struct {
            char *linkdev;
936
            int mode; /* enum virMacvtapMode from util/macvtap.h */
937
        } direct;
938 939 940
        struct {
            virDomainHostdevDef def;
        } hostdev;
941
    } data;
942 943
    /* virtPortProfile is used by network/bridge/direct/hostdev */
    virNetDevVPortProfilePtr virtPortProfile;
944 945 946 947
    struct {
        bool sndbuf_specified;
        unsigned long sndbuf;
    } tune;
948
    char *script;
949
    char *ifname;
950 951
    char *ifname_guest;
    char *ifname_guest_actual;
952
    virDomainDeviceInfo info;
953 954
    char *filter;
    virNWFilterHashTablePtr filterparams;
955
    virNetDevBandwidthPtr bandwidth;
956
    virNetDevVlan vlan;
957
    int linkstate;
958 959
};

E
Eric Blake 已提交
960 961 962 963
/* Used for prefix of ifname of any network name generated dynamically
 * by libvirt, and cannot be used for a persistent network name.  */
# define VIR_NET_GENERATED_PREFIX "vnet"

964
typedef enum {
965
    VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL = 0,
966 967
    VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL,
    VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE,
968
    VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL,
969

970
    VIR_DOMAIN_CHR_DEVICE_TYPE_LAST
971
} virDomainChrDeviceType;
972

973
typedef enum {
G
Guannan Ren 已提交
974 975 976 977
    VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_ISA = 0,
    VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_USB,

    VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_LAST
978
} virDomainChrSerialTargetType;
G
Guannan Ren 已提交
979

980
typedef enum {
981 982
    VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_NONE = 0,
    VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD,
983 984
    VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO,

985
    VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_LAST
986
} virDomainChrChannelTargetType;
987

988
typedef enum {
989 990
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_NONE  = 0,
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL,
991 992
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_XEN,
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_UML,
C
Cole Robinson 已提交
993
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO,
994 995
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_LXC,
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_OPENVZ,
996 997
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLP,
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLPLM,
998

999
    VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_LAST
1000
} virDomainChrConsoleTargetType;
1001

1002
typedef enum {
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
    VIR_DOMAIN_CHR_TYPE_NULL,
    VIR_DOMAIN_CHR_TYPE_VC,
    VIR_DOMAIN_CHR_TYPE_PTY,
    VIR_DOMAIN_CHR_TYPE_DEV,
    VIR_DOMAIN_CHR_TYPE_FILE,
    VIR_DOMAIN_CHR_TYPE_PIPE,
    VIR_DOMAIN_CHR_TYPE_STDIO,
    VIR_DOMAIN_CHR_TYPE_UDP,
    VIR_DOMAIN_CHR_TYPE_TCP,
    VIR_DOMAIN_CHR_TYPE_UNIX,
1013
    VIR_DOMAIN_CHR_TYPE_SPICEVMC,
1014
    VIR_DOMAIN_CHR_TYPE_SPICEPORT,
1015
    VIR_DOMAIN_CHR_TYPE_NMDM,
1016

1017
    VIR_DOMAIN_CHR_TYPE_LAST
1018
} virDomainChrType;
1019

1020
typedef enum {
1021 1022
    VIR_DOMAIN_CHR_TCP_PROTOCOL_RAW,
    VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET,
1023 1024
    VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNETS, /* secure telnet */
    VIR_DOMAIN_CHR_TCP_PROTOCOL_TLS,
1025

1026
    VIR_DOMAIN_CHR_TCP_PROTOCOL_LAST
1027
} virDomainChrTcpProtocol;
1028

1029
typedef enum {
E
Eric Blake 已提交
1030 1031
    VIR_DOMAIN_CHR_SPICEVMC_VDAGENT,
    VIR_DOMAIN_CHR_SPICEVMC_SMARTCARD,
1032
    VIR_DOMAIN_CHR_SPICEVMC_USBREDIR,
E
Eric Blake 已提交
1033

1034
    VIR_DOMAIN_CHR_SPICEVMC_LAST
1035
} virDomainChrSpicevmcName;
E
Eric Blake 已提交
1036

1037 1038 1039
/* The host side information for a character device.  */
struct _virDomainChrSourceDef {
    int type; /* virDomainChrType */
1040
    union {
E
Eric Blake 已提交
1041
        /* no <source> for null, vc, stdio */
1042 1043 1044
        struct {
            char *path;
        } file; /* pty, file, pipe, or device */
1045 1046 1047 1048
        struct {
            char *master;
            char *slave;
        } nmdm;
1049 1050 1051
        struct {
            char *host;
            char *service;
1052
            bool listen;
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
            int protocol;
        } tcp;
        struct {
            char *bindHost;
            char *bindService;
            char *connectHost;
            char *connectService;
        } udp;
        struct {
            char *path;
1063
            bool listen;
1064
        } nix;
E
Eric Blake 已提交
1065
        int spicevmc;
1066 1067 1068
        struct {
            char *channel;
        } spiceport;
1069
    } data;
1070 1071 1072 1073 1074
};

/* A complete character device, both host and domain views.  */
struct _virDomainChrDef {
    int deviceType;
G
Guannan Ren 已提交
1075 1076

    bool targetTypeAttr;
1077 1078 1079 1080 1081 1082 1083 1084
    int targetType;
    union {
        int port; /* parallel, serial, console */
        virSocketAddrPtr addr; /* guestfwd */
        char *name; /* virtio */
    } target;

    virDomainChrSourceDef source;
1085 1086

    virDomainDeviceInfo info;
1087 1088 1089

    size_t nseclabels;
    virSecurityDeviceLabelDefPtr *seclabels;
1090 1091
};

1092
typedef enum {
E
Eric Blake 已提交
1093 1094 1095 1096
    VIR_DOMAIN_SMARTCARD_TYPE_HOST,
    VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES,
    VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH,

1097
    VIR_DOMAIN_SMARTCARD_TYPE_LAST
1098
} virDomainSmartcardType;
E
Eric Blake 已提交
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116

# define VIR_DOMAIN_SMARTCARD_NUM_CERTIFICATES 3
# define VIR_DOMAIN_SMARTCARD_DEFAULT_DATABASE "/etc/pki/nssdb"

struct _virDomainSmartcardDef {
    int type; /* virDomainSmartcardType */
    union {
        /* no extra data for 'host' */
        struct {
            char *file[VIR_DOMAIN_SMARTCARD_NUM_CERTIFICATES];
            char *database;
        } cert; /* 'host-certificates' */
        virDomainChrSourceDef passthru; /* 'passthrough' */
    } data;

    virDomainDeviceInfo info;
};

M
Marc-André Lureau 已提交
1117 1118 1119 1120 1121
struct _virDomainHubDef {
    int type;
    virDomainDeviceInfo info;
};

1122
typedef enum {
1123 1124 1125
    VIR_DOMAIN_TPM_MODEL_TIS,

    VIR_DOMAIN_TPM_MODEL_LAST
1126
} virDomainTPMModel;
1127

1128
typedef enum {
1129 1130 1131
    VIR_DOMAIN_TPM_TYPE_PASSTHROUGH,

    VIR_DOMAIN_TPM_TYPE_LAST
1132
} virDomainTPMBackendType;
1133 1134 1135 1136 1137 1138

# define VIR_DOMAIN_TPM_DEFAULT_DEVICE "/dev/tpm0"

typedef struct _virDomainTPMDef virDomainTPMDef;
typedef virDomainTPMDef *virDomainTPMDefPtr;
struct _virDomainTPMDef {
1139
    virDomainTPMBackendType type;
1140
    virDomainDeviceInfo info;
1141
    virDomainTPMModel model;
1142 1143 1144 1145 1146 1147 1148
    union {
        struct {
            virDomainChrSourceDef source;
        } passthrough;
    } data;
};

1149
typedef enum {
1150 1151
    VIR_DOMAIN_INPUT_TYPE_MOUSE,
    VIR_DOMAIN_INPUT_TYPE_TABLET,
L
Li Zhang 已提交
1152
    VIR_DOMAIN_INPUT_TYPE_KBD,
1153

1154
    VIR_DOMAIN_INPUT_TYPE_LAST
1155
} virDomainInputType;
1156

1157
typedef enum {
1158 1159 1160 1161 1162
    VIR_DOMAIN_INPUT_BUS_PS2,
    VIR_DOMAIN_INPUT_BUS_USB,
    VIR_DOMAIN_INPUT_BUS_XEN,

    VIR_DOMAIN_INPUT_BUS_LAST
1163
} virDomainInputBus;
1164 1165 1166 1167

struct _virDomainInputDef {
    int type;
    int bus;
1168
    virDomainDeviceInfo info;
1169 1170
};

1171
typedef enum {
1172 1173 1174 1175
    VIR_DOMAIN_SOUND_CODEC_TYPE_DUPLEX,
    VIR_DOMAIN_SOUND_CODEC_TYPE_MICRO,

    VIR_DOMAIN_SOUND_CODEC_TYPE_LAST
1176
} virDomainSoundCodecType;
1177

1178
typedef enum {
1179 1180 1181
    VIR_DOMAIN_SOUND_MODEL_SB16,
    VIR_DOMAIN_SOUND_MODEL_ES1370,
    VIR_DOMAIN_SOUND_MODEL_PCSPK,
D
Daniel P. Berrange 已提交
1182
    VIR_DOMAIN_SOUND_MODEL_AC97,
1183
    VIR_DOMAIN_SOUND_MODEL_ICH6,
1184
    VIR_DOMAIN_SOUND_MODEL_ICH9,
1185
    VIR_DOMAIN_SOUND_MODEL_USB,
1186 1187

    VIR_DOMAIN_SOUND_MODEL_LAST
1188
} virDomainSoundModel;
1189

1190 1191 1192 1193 1194
struct _virDomainSoundCodecDef {
    int type;
    int cad;
};

1195 1196
struct _virDomainSoundDef {
    int model;
1197
    virDomainDeviceInfo info;
1198

1199
    size_t ncodecs;
1200
    virDomainSoundCodecDefPtr *codecs;
1201 1202
};

1203
typedef enum {
R
Richard Jones 已提交
1204 1205 1206 1207
    VIR_DOMAIN_WATCHDOG_MODEL_I6300ESB,
    VIR_DOMAIN_WATCHDOG_MODEL_IB700,

    VIR_DOMAIN_WATCHDOG_MODEL_LAST
1208
} virDomainWatchdogModel;
R
Richard Jones 已提交
1209

1210
typedef enum {
R
Richard Jones 已提交
1211 1212 1213 1214
    VIR_DOMAIN_WATCHDOG_ACTION_RESET,
    VIR_DOMAIN_WATCHDOG_ACTION_SHUTDOWN,
    VIR_DOMAIN_WATCHDOG_ACTION_POWEROFF,
    VIR_DOMAIN_WATCHDOG_ACTION_PAUSE,
H
Hu Tao 已提交
1215
    VIR_DOMAIN_WATCHDOG_ACTION_DUMP,
R
Richard Jones 已提交
1216 1217 1218
    VIR_DOMAIN_WATCHDOG_ACTION_NONE,

    VIR_DOMAIN_WATCHDOG_ACTION_LAST
1219
} virDomainWatchdogAction;
R
Richard Jones 已提交
1220 1221 1222 1223

struct _virDomainWatchdogDef {
    int model;
    int action;
1224
    virDomainDeviceInfo info;
R
Richard Jones 已提交
1225 1226
};

1227

1228
typedef enum {
1229 1230 1231 1232 1233
    VIR_DOMAIN_VIDEO_TYPE_VGA,
    VIR_DOMAIN_VIDEO_TYPE_CIRRUS,
    VIR_DOMAIN_VIDEO_TYPE_VMVGA,
    VIR_DOMAIN_VIDEO_TYPE_XEN,
    VIR_DOMAIN_VIDEO_TYPE_VBOX,
1234
    VIR_DOMAIN_VIDEO_TYPE_QXL,
1235 1236

    VIR_DOMAIN_VIDEO_TYPE_LAST
1237
} virDomainVideoType;
1238 1239


1240 1241 1242
typedef struct _virDomainVideoAccelDef virDomainVideoAccelDef;
typedef virDomainVideoAccelDef *virDomainVideoAccelDefPtr;
struct _virDomainVideoAccelDef {
1243 1244
    bool support3d;
    bool support2d;
1245 1246 1247
};


1248 1249
struct _virDomainVideoDef {
    int type;
1250 1251
    unsigned int ram;  /* kibibytes (multiples of 1024) */
    unsigned int vram; /* kibibytes (multiples of 1024) */
1252
    unsigned int heads;
1253
    bool primary;
1254
    virDomainVideoAccelDefPtr accel;
1255
    virDomainDeviceInfo info;
1256 1257
};

1258
/* graphics console modes */
1259
typedef enum {
1260 1261
    VIR_DOMAIN_GRAPHICS_TYPE_SDL,
    VIR_DOMAIN_GRAPHICS_TYPE_VNC,
1262 1263
    VIR_DOMAIN_GRAPHICS_TYPE_RDP,
    VIR_DOMAIN_GRAPHICS_TYPE_DESKTOP,
1264
    VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
1265

1266
    VIR_DOMAIN_GRAPHICS_TYPE_LAST
1267
} virDomainGraphicsType;
1268

1269
typedef enum {
1270 1271 1272 1273 1274 1275
    VIR_DOMAIN_GRAPHICS_VNC_SHARE_DEFAULT = 0,
    VIR_DOMAIN_GRAPHICS_VNC_SHARE_ALLOW_EXCLUSIVE,
    VIR_DOMAIN_GRAPHICS_VNC_SHARE_FORCE_SHARED,
    VIR_DOMAIN_GRAPHICS_VNC_SHARE_IGNORE,

    VIR_DOMAIN_GRAPHICS_VNC_SHARE_LAST
1276
} virDomainGraphicsVNCSharePolicy;
1277

1278
typedef enum {
1279 1280 1281 1282 1283 1284
    VIR_DOMAIN_GRAPHICS_AUTH_CONNECTED_DEFAULT = 0,
    VIR_DOMAIN_GRAPHICS_AUTH_CONNECTED_FAIL,
    VIR_DOMAIN_GRAPHICS_AUTH_CONNECTED_DISCONNECT,
    VIR_DOMAIN_GRAPHICS_AUTH_CONNECTED_KEEP,

    VIR_DOMAIN_GRAPHICS_AUTH_CONNECTED_LAST
1285
} virDomainGraphicsAuthConnectedType;
1286

1287 1288 1289 1290
typedef struct _virDomainGraphicsAuthDef virDomainGraphicsAuthDef;
typedef virDomainGraphicsAuthDef *virDomainGraphicsAuthDefPtr;
struct _virDomainGraphicsAuthDef {
    char *passwd;
1291
    bool expires; /* Whether there is an expiry time set */
1292
    time_t validTo;  /* seconds since epoch */
1293
    int connected; /* action if connected */
1294 1295
};

1296
typedef enum {
1297 1298 1299 1300 1301 1302
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MAIN,
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_DISPLAY,
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_INPUT,
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_CURSOR,
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_PLAYBACK,
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_RECORD,
E
Eric Blake 已提交
1303
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_SMARTCARD,
1304
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_USBREDIR,
1305 1306

    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_LAST
1307
} virDomainGraphicsSpiceChannelName;
1308

1309
typedef enum {
1310 1311 1312 1313 1314
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_ANY,
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE,
    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE,

    VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_LAST
1315
} virDomainGraphicsSpiceChannelMode;
1316

1317
typedef enum {
1318 1319 1320 1321 1322 1323 1324 1325 1326
    VIR_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_DEFAULT = 0,
    VIR_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_AUTO_GLZ,
    VIR_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_AUTO_LZ,
    VIR_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_QUIC,
    VIR_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_GLZ,
    VIR_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_LZ,
    VIR_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_OFF,

    VIR_DOMAIN_GRAPHICS_SPICE_IMAGE_COMPRESSION_LAST
1327
} virDomainGraphicsSpiceImageCompression;
1328

1329
typedef enum {
1330 1331 1332 1333 1334 1335
    VIR_DOMAIN_GRAPHICS_SPICE_JPEG_COMPRESSION_DEFAULT = 0,
    VIR_DOMAIN_GRAPHICS_SPICE_JPEG_COMPRESSION_AUTO,
    VIR_DOMAIN_GRAPHICS_SPICE_JPEG_COMPRESSION_NEVER,
    VIR_DOMAIN_GRAPHICS_SPICE_JPEG_COMPRESSION_ALWAYS,

    VIR_DOMAIN_GRAPHICS_SPICE_JPEG_COMPRESSION_LAST
1336
} virDomainGraphicsSpiceJpegCompression;
1337

1338
typedef enum {
1339 1340 1341 1342 1343 1344
    VIR_DOMAIN_GRAPHICS_SPICE_ZLIB_COMPRESSION_DEFAULT = 0,
    VIR_DOMAIN_GRAPHICS_SPICE_ZLIB_COMPRESSION_AUTO,
    VIR_DOMAIN_GRAPHICS_SPICE_ZLIB_COMPRESSION_NEVER,
    VIR_DOMAIN_GRAPHICS_SPICE_ZLIB_COMPRESSION_ALWAYS,

    VIR_DOMAIN_GRAPHICS_SPICE_ZLIB_COMPRESSION_LAST
1345
} virDomainGraphicsSpiceZlibCompression;
1346

1347
typedef enum {
P
Peng Zhou 已提交
1348 1349 1350 1351 1352
    VIR_DOMAIN_GRAPHICS_SPICE_MOUSE_MODE_DEFAULT = 0,
    VIR_DOMAIN_GRAPHICS_SPICE_MOUSE_MODE_SERVER,
    VIR_DOMAIN_GRAPHICS_SPICE_MOUSE_MODE_CLIENT,

    VIR_DOMAIN_GRAPHICS_SPICE_MOUSE_MODE_LAST
1353
} virDomainGraphicsSpiceMouseMode;
P
Peng Zhou 已提交
1354

1355
typedef enum {
1356 1357 1358 1359 1360 1361
    VIR_DOMAIN_GRAPHICS_SPICE_STREAMING_MODE_DEFAULT = 0,
    VIR_DOMAIN_GRAPHICS_SPICE_STREAMING_MODE_FILTER,
    VIR_DOMAIN_GRAPHICS_SPICE_STREAMING_MODE_ALL,
    VIR_DOMAIN_GRAPHICS_SPICE_STREAMING_MODE_OFF,

    VIR_DOMAIN_GRAPHICS_SPICE_STREAMING_MODE_LAST
1362
} virDomainGraphicsSpiceStreamingMode;
1363

1364
typedef enum {
1365 1366 1367 1368
    VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NONE = 0,
    VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS,
    VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK,

1369
    VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_LAST
1370
} virDomainGraphicsListenType;
1371

1372
typedef enum {
M
Marc-André Lureau 已提交
1373 1374
    VIR_DOMAIN_HUB_TYPE_USB,

1375
    VIR_DOMAIN_HUB_TYPE_LAST
1376
} virDomainHubType;
M
Marc-André Lureau 已提交
1377

1378 1379 1380 1381 1382 1383
typedef struct _virDomainGraphicsListenDef virDomainGraphicsListenDef;
typedef virDomainGraphicsListenDef *virDomainGraphicsListenDefPtr;
struct _virDomainGraphicsListenDef {
    int type;   /* enum virDomainGraphicsListenType */
    char *address;
    char *network;
1384
    bool fromConfig;    /* true if the @address is config file originated */
1385 1386
};

1387
struct _virDomainGraphicsDef {
M
Michal Privoznik 已提交
1388 1389 1390 1391 1392
    /* Port value discipline:
     * Value -1 is legacy syntax indicating that it should be auto-allocated.
     * Value 0 means port wasn't specified in XML at all.
     * Positive value is actual port number given in XML.
     */
1393 1394 1395 1396
    int type;
    union {
        struct {
            int port;
1397
            bool portReserved;
M
Martin Kletzander 已提交
1398
            int websocket;
1399
            bool autoport;
1400
            char *keymap;
1401
            char *socket;
1402
            virDomainGraphicsAuthDef auth;
1403
            int sharePolicy;
1404 1405 1406 1407
        } vnc;
        struct {
            char *display;
            char *xauth;
1408
            bool fullscreen;
1409
        } sdl;
1410 1411
        struct {
            int port;
1412 1413 1414
            bool autoport;
            bool replaceUser;
            bool multiUser;
1415 1416 1417
        } rdp;
        struct {
            char *display;
1418
            bool fullscreen;
1419
        } desktop;
1420 1421 1422
        struct {
            int port;
            int tlsPort;
1423 1424
            bool portReserved;
            bool tlsPortReserved;
P
Peng Zhou 已提交
1425
            int mousemode;
1426
            char *keymap;
1427
            virDomainGraphicsAuthDef auth;
1428
            bool autoport;
1429
            int channels[VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_LAST];
1430
            int defaultMode; /* enum virDomainGraphicsSpiceChannelMode */
1431 1432 1433 1434
            int image;
            int jpeg;
            int zlib;
            int playback;
1435
            int streaming;
J
Ján Tomko 已提交
1436 1437
            int copypaste; /* enum virTristateBool */
            int filetransfer; /* enum virTristateBool */
1438
        } spice;
1439
    } data;
1440 1441 1442 1443 1444
    /* nListens, listens, and *port are only useful if type is vnc,
     * rdp, or spice. They've been extracted from the union only to
     * simplify parsing code.*/
    size_t nListens;
    virDomainGraphicsListenDefPtr listens;
1445 1446
};

1447
typedef enum {
1448 1449 1450
    VIR_DOMAIN_REDIRDEV_BUS_USB,

    VIR_DOMAIN_REDIRDEV_BUS_LAST
1451
} virDomainRedirdevBus;
1452 1453 1454 1455 1456 1457 1458 1459 1460 1461

struct _virDomainRedirdevDef {
    int bus; /* enum virDomainRedirdevBus */

    union {
        virDomainChrSourceDef chr;
    } source;

    virDomainDeviceInfo info; /* Guest address */
};
1462

1463
struct _virDomainRedirFilterUSBDevDef {
1464 1465 1466 1467
    int usbClass;
    int vendor;
    int product;
    int version;
1468
    bool allow;
1469 1470 1471 1472
};

struct _virDomainRedirFilterDef {
    size_t nusbdevs;
1473
    virDomainRedirFilterUSBDevDefPtr *usbdevs;
1474 1475
};

1476 1477 1478
enum {
    VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO,
    VIR_DOMAIN_MEMBALLOON_MODEL_XEN,
1479
    VIR_DOMAIN_MEMBALLOON_MODEL_NONE,
1480 1481 1482 1483 1484 1485 1486

    VIR_DOMAIN_MEMBALLOON_MODEL_LAST
};

struct _virDomainMemballoonDef {
    int model;
    virDomainDeviceInfo info;
1487
    unsigned int period; /* seconds between collections */
1488 1489
};

L
Li Zhang 已提交
1490 1491 1492
struct _virDomainNVRAMDef {
    virDomainDeviceInfo info;
};
1493

1494
typedef enum {
1495
    VIR_DOMAIN_SMBIOS_NONE = 0,
1496 1497 1498 1499 1500
    VIR_DOMAIN_SMBIOS_EMULATE,
    VIR_DOMAIN_SMBIOS_HOST,
    VIR_DOMAIN_SMBIOS_SYSINFO,

    VIR_DOMAIN_SMBIOS_LAST
1501
} virDomainSmbiosMode;
1502

1503

1504
# define VIR_DOMAIN_MAX_BOOT_DEVS 4
1505

1506
typedef enum {
1507 1508 1509 1510 1511
    VIR_DOMAIN_BOOT_FLOPPY,
    VIR_DOMAIN_BOOT_CDROM,
    VIR_DOMAIN_BOOT_DISK,
    VIR_DOMAIN_BOOT_NET,

1512
    VIR_DOMAIN_BOOT_LAST
1513
} virDomainBootOrder;
1514

1515
typedef enum {
1516 1517 1518
    VIR_DOMAIN_FEATURE_ACPI,
    VIR_DOMAIN_FEATURE_APIC,
    VIR_DOMAIN_FEATURE_PAE,
J
Jim Fehlig 已提交
1519
    VIR_DOMAIN_FEATURE_HAP,
1520
    VIR_DOMAIN_FEATURE_VIRIDIAN,
1521
    VIR_DOMAIN_FEATURE_PRIVNET,
1522
    VIR_DOMAIN_FEATURE_HYPERV,
1523
    VIR_DOMAIN_FEATURE_KVM,
1524
    VIR_DOMAIN_FEATURE_PVSPINLOCK,
1525
    VIR_DOMAIN_FEATURE_CAPABILITIES,
1526 1527

    VIR_DOMAIN_FEATURE_LAST
1528
} virDomainFeature;
1529

1530
typedef enum {
1531
    VIR_DOMAIN_HYPERV_RELAXED = 0,
1532 1533
    VIR_DOMAIN_HYPERV_VAPIC,
    VIR_DOMAIN_HYPERV_SPINLOCKS,
1534 1535

    VIR_DOMAIN_HYPERV_LAST
1536
} virDomainHyperv;
1537

1538 1539 1540 1541 1542 1543
typedef enum {
    VIR_DOMAIN_KVM_HIDDEN = 0,

    VIR_DOMAIN_KVM_LAST
} virDomainKVM;

1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
typedef enum {
    VIR_DOMAIN_CAPABILITIES_POLICY_DEFAULT = 0,
    VIR_DOMAIN_CAPABILITIES_POLICY_ALLOW,
    VIR_DOMAIN_CAPABILITIES_POLICY_DENY,

    VIR_DOMAIN_CAPABILITIES_POLICY_LAST
} virDomainCapabilitiesPolicy;

/* The capabilities are ordered alphabetically to help check for new ones */
typedef enum {
    VIR_DOMAIN_CAPS_FEATURE_AUDIT_CONTROL = 0,
    VIR_DOMAIN_CAPS_FEATURE_AUDIT_WRITE,
    VIR_DOMAIN_CAPS_FEATURE_BLOCK_SUSPEND,
    VIR_DOMAIN_CAPS_FEATURE_CHOWN,
    VIR_DOMAIN_CAPS_FEATURE_DAC_OVERRIDE,
    VIR_DOMAIN_CAPS_FEATURE_DAC_READ_SEARCH,
    VIR_DOMAIN_CAPS_FEATURE_FOWNER,
    VIR_DOMAIN_CAPS_FEATURE_FSETID,
    VIR_DOMAIN_CAPS_FEATURE_IPC_LOCK,
    VIR_DOMAIN_CAPS_FEATURE_IPC_OWNER,
    VIR_DOMAIN_CAPS_FEATURE_KILL,
    VIR_DOMAIN_CAPS_FEATURE_LEASE,
    VIR_DOMAIN_CAPS_FEATURE_LINUX_IMMUTABLE,
    VIR_DOMAIN_CAPS_FEATURE_MAC_ADMIN,
    VIR_DOMAIN_CAPS_FEATURE_MAC_OVERRIDE,
    VIR_DOMAIN_CAPS_FEATURE_MKNOD,
    VIR_DOMAIN_CAPS_FEATURE_NET_ADMIN,
    VIR_DOMAIN_CAPS_FEATURE_NET_BIND_SERVICE,
    VIR_DOMAIN_CAPS_FEATURE_NET_BROADCAST,
    VIR_DOMAIN_CAPS_FEATURE_NET_RAW,
    VIR_DOMAIN_CAPS_FEATURE_SETGID,
    VIR_DOMAIN_CAPS_FEATURE_SETFCAP,
    VIR_DOMAIN_CAPS_FEATURE_SETPCAP,
    VIR_DOMAIN_CAPS_FEATURE_SETUID,
    VIR_DOMAIN_CAPS_FEATURE_SYS_ADMIN,
    VIR_DOMAIN_CAPS_FEATURE_SYS_BOOT,
    VIR_DOMAIN_CAPS_FEATURE_SYS_CHROOT,
    VIR_DOMAIN_CAPS_FEATURE_SYS_MODULE,
    VIR_DOMAIN_CAPS_FEATURE_SYS_NICE,
    VIR_DOMAIN_CAPS_FEATURE_SYS_PACCT,
    VIR_DOMAIN_CAPS_FEATURE_SYS_PTRACE,
    VIR_DOMAIN_CAPS_FEATURE_SYS_RAWIO,
    VIR_DOMAIN_CAPS_FEATURE_SYS_RESOURCE,
    VIR_DOMAIN_CAPS_FEATURE_SYS_TIME,
    VIR_DOMAIN_CAPS_FEATURE_SYS_TTY_CONFIG,
    VIR_DOMAIN_CAPS_FEATURE_SYSLOG,
    VIR_DOMAIN_CAPS_FEATURE_WAKE_ALARM,
    VIR_DOMAIN_CAPS_FEATURE_LAST
} virDomainCapsFeature;

1594
typedef enum {
1595 1596 1597 1598 1599 1600
    VIR_DOMAIN_LIFECYCLE_DESTROY,
    VIR_DOMAIN_LIFECYCLE_RESTART,
    VIR_DOMAIN_LIFECYCLE_RESTART_RENAME,
    VIR_DOMAIN_LIFECYCLE_PRESERVE,

    VIR_DOMAIN_LIFECYCLE_LAST
1601
} virDomainLifecycleAction;
1602

1603
typedef enum {
1604 1605 1606 1607 1608 1609 1610 1611
    VIR_DOMAIN_LIFECYCLE_CRASH_DESTROY,
    VIR_DOMAIN_LIFECYCLE_CRASH_RESTART,
    VIR_DOMAIN_LIFECYCLE_CRASH_RESTART_RENAME,
    VIR_DOMAIN_LIFECYCLE_CRASH_PRESERVE,
    VIR_DOMAIN_LIFECYCLE_CRASH_COREDUMP_DESTROY,
    VIR_DOMAIN_LIFECYCLE_CRASH_COREDUMP_RESTART,

    VIR_DOMAIN_LIFECYCLE_CRASH_LAST
1612
} virDomainLifecycleCrashAction;
1613

1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625
typedef enum {
    VIR_DOMAIN_LOCK_FAILURE_DEFAULT,
    VIR_DOMAIN_LOCK_FAILURE_POWEROFF,
    VIR_DOMAIN_LOCK_FAILURE_RESTART,
    VIR_DOMAIN_LOCK_FAILURE_PAUSE,
    VIR_DOMAIN_LOCK_FAILURE_IGNORE,

    VIR_DOMAIN_LOCK_FAILURE_LAST
} virDomainLockFailureAction;

VIR_ENUM_DECL(virDomainLockFailure)

M
Michal Privoznik 已提交
1626 1627 1628
typedef struct _virDomainBIOSDef virDomainBIOSDef;
typedef virDomainBIOSDef *virDomainBIOSDefPtr;
struct _virDomainBIOSDef {
J
Ján Tomko 已提交
1629
    int useserial; /* enum virTristateBool */
1630 1631 1632
    /* reboot-timeout parameters */
    bool rt_set;
    int rt_delay;
M
Michal Privoznik 已提交
1633 1634
};

1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
typedef enum {
    VIR_DOMAIN_LOADER_TYPE_ROM = 0,
    VIR_DOMAIN_LOADER_TYPE_PFLASH,

    VIR_DOMAIN_LOADER_TYPE_LAST
} virDomainLoader;

VIR_ENUM_DECL(virDomainLoader)

typedef struct _virDomainLoaderDef virDomainLoaderDef;
typedef virDomainLoaderDef *virDomainLoaderDefPtr;
struct _virDomainLoaderDef {
    char *path;
    int readonly;   /* enum virTristateBool */
    virDomainLoader type;
    char *nvram;    /* path to non-volatile RAM */
1651
    char *templt;   /* user override of path to master nvram */
1652 1653 1654 1655
};

void virDomainLoaderDefFree(virDomainLoaderDefPtr loader);

1656 1657 1658 1659 1660
/* Operating system configuration data & machine / arch */
typedef struct _virDomainOSDef virDomainOSDef;
typedef virDomainOSDef *virDomainOSDefPtr;
struct _virDomainOSDef {
    char *type;
1661
    virArch arch;
1662
    char *machine;
1663
    size_t nBootDevs;
1664
    int bootDevs[VIR_DOMAIN_BOOT_LAST];
J
Ján Tomko 已提交
1665
    int bootmenu; /* enum virTristateBool */
1666 1667
    unsigned int bm_timeout;
    bool bm_timeout_set;
1668
    char *init;
1669
    char **initargv;
1670 1671 1672
    char *kernel;
    char *initrd;
    char *cmdline;
1673
    char *dtb;
1674
    char *root;
1675
    virDomainLoaderDefPtr loader;
1676 1677
    char *bootloader;
    char *bootloaderArgs;
1678
    int smbios_mode;
1679

M
Michal Privoznik 已提交
1680
    virDomainBIOSDef bios;
1681 1682
};

1683
typedef enum {
1684 1685 1686 1687 1688
    VIR_DOMAIN_TIMER_NAME_PLATFORM = 0,
    VIR_DOMAIN_TIMER_NAME_PIT,
    VIR_DOMAIN_TIMER_NAME_RTC,
    VIR_DOMAIN_TIMER_NAME_HPET,
    VIR_DOMAIN_TIMER_NAME_TSC,
P
Paolo Bonzini 已提交
1689
    VIR_DOMAIN_TIMER_NAME_KVMCLOCK,
1690
    VIR_DOMAIN_TIMER_NAME_HYPERVCLOCK,
1691

1692
    VIR_DOMAIN_TIMER_NAME_LAST
1693
} virDomainTimerNameType;
1694

1695
typedef enum {
1696 1697 1698
    VIR_DOMAIN_TIMER_TRACK_BOOT = 0,
    VIR_DOMAIN_TIMER_TRACK_GUEST,
    VIR_DOMAIN_TIMER_TRACK_WALL,
1699

1700
    VIR_DOMAIN_TIMER_TRACK_LAST
1701
} virDomainTimerTrackType;
1702

1703
typedef enum {
1704 1705 1706 1707 1708
    VIR_DOMAIN_TIMER_TICKPOLICY_DELAY = 0,
    VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP,
    VIR_DOMAIN_TIMER_TICKPOLICY_MERGE,
    VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD,

1709
    VIR_DOMAIN_TIMER_TICKPOLICY_LAST
1710
} virDomainTimerTickpolicyType;
1711

1712
typedef enum {
1713 1714 1715 1716
    VIR_DOMAIN_TIMER_MODE_AUTO = 0,
    VIR_DOMAIN_TIMER_MODE_NATIVE,
    VIR_DOMAIN_TIMER_MODE_EMULATE,
    VIR_DOMAIN_TIMER_MODE_PARAVIRT,
1717
    VIR_DOMAIN_TIMER_MODE_SMPSAFE,
1718

1719
    VIR_DOMAIN_TIMER_MODE_LAST
1720
} virDomainTimerModeType;
1721

1722
typedef enum {
1723
    VIR_DOMAIN_CPU_PLACEMENT_MODE_STATIC = 0,
O
Osier Yang 已提交
1724 1725
    VIR_DOMAIN_CPU_PLACEMENT_MODE_AUTO,

1726
    VIR_DOMAIN_CPU_PLACEMENT_MODE_LAST
1727
} virDomainCpuPlacementMode;
O
Osier Yang 已提交
1728

1729 1730 1731 1732 1733 1734 1735 1736
typedef struct _virDomainTimerCatchupDef virDomainTimerCatchupDef;
typedef virDomainTimerCatchupDef *virDomainTimerCatchupDefPtr;
struct _virDomainTimerCatchupDef {
    unsigned long threshold;
    unsigned long slew;
    unsigned long limit;
};

1737 1738 1739 1740 1741 1742 1743
typedef struct _virDomainTimerDef virDomainTimerDef;
typedef virDomainTimerDef *virDomainTimerDefPtr;
struct _virDomainTimerDef {
    int name;
    int present;    /* unspecified = -1, no = 0, yes = 1 */
    int tickpolicy; /* none|catchup|merge|discard */

1744 1745 1746 1747
    virDomainTimerCatchupDef catchup;

    /* track is only valid for name='platform|rtc' */
    int track;  /* host|guest */
1748 1749 1750 1751 1752 1753

    /* frequency & mode are only valid for name='tsc' */
    unsigned long frequency; /* in Hz, unspecified = 0 */
    int mode;       /* auto|native|emulate|paravirt */
};

1754
typedef enum {
1755 1756
    VIR_DOMAIN_CLOCK_OFFSET_UTC = 0,
    VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME = 1,
1757
    VIR_DOMAIN_CLOCK_OFFSET_VARIABLE = 2,
1758
    VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE = 3,
1759

1760
    VIR_DOMAIN_CLOCK_OFFSET_LAST
1761
} virDomainClockOffsetType;
1762

1763
typedef enum {
1764 1765 1766
    VIR_DOMAIN_CLOCK_BASIS_UTC = 0,
    VIR_DOMAIN_CLOCK_BASIS_LOCALTIME = 1,

1767
    VIR_DOMAIN_CLOCK_BASIS_LAST
1768
} virDomainClockBasis;
1769

1770 1771 1772 1773
typedef struct _virDomainClockDef virDomainClockDef;
typedef virDomainClockDef *virDomainClockDefPtr;
struct _virDomainClockDef {
    int offset;
1774

1775
    union {
1776 1777 1778
        /* Bug-compatibility-mode for Xen utc|localtime */
        int utc_reset;
        /* Adjustment in seconds, relative to UTC or LOCALTIME, when
1779
         * offset == VIR_DOMAIN_CLOCK_OFFSET_VARIABLE */
1780 1781 1782
        struct {
            long long adjustment;
            int basis;
1783 1784 1785 1786 1787 1788 1789

            /* domain start-time adjustment. This is a
             * private/internal read-only value that only exists when
             * a domain is running, and only if the clock
             * offset='variable'
             */
            long long adjustment0;
1790
        } variable;
1791 1792 1793 1794 1795

        /* Timezone name, when
         * offset == VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME */
        char *timezone;
    } data;
1796

1797
    size_t ntimers;
1798
    virDomainTimerDefPtr *timers;
1799 1800
};

1801
# define VIR_DOMAIN_CPUMASK_LEN 1024
1802

E
Eric Blake 已提交
1803 1804 1805
typedef struct _virDomainVcpuPinDef virDomainVcpuPinDef;
typedef virDomainVcpuPinDef *virDomainVcpuPinDefPtr;
struct _virDomainVcpuPinDef {
1806
    int vcpuid;
H
Hu Tao 已提交
1807
    virBitmapPtr cpumask;
1808 1809
};

H
Hu Tao 已提交
1810 1811
void virDomainVcpuPinDefFree(virDomainVcpuPinDefPtr def);
void virDomainVcpuPinDefArrayFree(virDomainVcpuPinDefPtr *def, int nvcpupin);
1812 1813 1814 1815

virDomainVcpuPinDefPtr *virDomainVcpuPinDefCopy(virDomainVcpuPinDefPtr *src,
                                                int nvcpupin);

E
Eric Blake 已提交
1816
int virDomainVcpuPinIsDuplicate(virDomainVcpuPinDefPtr *def,
1817 1818 1819
                                int nvcpupin,
                                int vcpu);

E
Eric Blake 已提交
1820
virDomainVcpuPinDefPtr virDomainVcpuPinFindByVcpu(virDomainVcpuPinDefPtr *def,
1821 1822 1823
                                                  int nvcpupin,
                                                  int vcpu);

1824 1825 1826
typedef struct _virBlkioDevice virBlkioDevice;
typedef virBlkioDevice *virBlkioDevicePtr;
struct _virBlkioDevice {
1827 1828
    char *path;
    unsigned int weight;
1829 1830 1831 1832
    unsigned int riops;
    unsigned int wiops;
    unsigned long long rbps;
    unsigned long long wbps;
1833 1834
};

1835
typedef enum {
1836 1837 1838
    VIR_DOMAIN_RNG_MODEL_VIRTIO,

    VIR_DOMAIN_RNG_MODEL_LAST
1839
} virDomainRNGModel;
1840

1841
typedef enum {
1842 1843 1844 1845 1846
    VIR_DOMAIN_RNG_BACKEND_RANDOM,
    VIR_DOMAIN_RNG_BACKEND_EGD,
    /* VIR_DOMAIN_RNG_BACKEND_POOL, */

    VIR_DOMAIN_RNG_BACKEND_LAST
1847
} virDomainRNGBackend;
1848 1849 1850 1851

struct _virDomainRNGDef {
    int model;
    int backend;
1852 1853
    unsigned int rate; /* bytes per period */
    unsigned int period; /* milliseconds */
1854 1855 1856 1857 1858 1859 1860 1861 1862 1863

    union {
        char *file; /* file name for 'random' source */
        virDomainChrSourceDefPtr chardev; /* a char backend for
                                             the EGD source */
    } source;

    virDomainDeviceInfo info;
};

1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878
struct _virDomainIdMapEntry {
    unsigned int start;
    unsigned int target;
    unsigned int count;
};

struct _virDomainIdMapDef {
    size_t nuidmap;
    virDomainIdMapEntryPtr uidmap;

    size_t ngidmap;
    virDomainIdMapEntryPtr gidmap;
};


H
Hu Tao 已提交
1879 1880 1881 1882 1883
struct _virDomainPanicDef {
    virDomainDeviceInfo info;
};


1884
void virBlkioDeviceArrayClear(virBlkioDevicePtr deviceWeights,
1885
                              int ndevices);
1886

1887 1888 1889 1890 1891
typedef struct _virDomainResourceDef virDomainResourceDef;
typedef virDomainResourceDef *virDomainResourceDefPtr;
struct _virDomainResourceDef {
    char *partition;
};
1892

1893
typedef struct _virDomainHugePage virDomainHugePage;
1894 1895
typedef virDomainHugePage *virDomainHugePagePtr;

1896
struct _virDomainHugePage {
1897 1898 1899 1900
    virBitmapPtr nodemask;      /* guest's NUMA node mask */
    unsigned long long size;    /* hugepage size in KiB */
};

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
typedef struct _virDomainCputune virDomainCputune;
typedef virDomainCputune *virDomainCputunePtr;

struct _virDomainCputune {
    unsigned long shares;
    bool sharesSpecified;
    unsigned long long period;
    long long quota;
    unsigned long long emulator_period;
    long long emulator_quota;
    size_t nvcpupin;
    virDomainVcpuPinDefPtr *vcpupin;
    virDomainVcpuPinDefPtr emulatorpin;
    size_t niothreadspin;
    virDomainVcpuPinDefPtr *iothreadspin;
};

typedef struct _virDomainBlkiotune virDomainBlkiotune;
typedef virDomainBlkiotune *virDomainBlkiotunePtr;

struct _virDomainBlkiotune {
    unsigned int weight;

    size_t ndevices;
    virBlkioDevicePtr devices;
};

typedef struct _virDomainMemtune virDomainMemtune;
typedef virDomainMemtune *virDomainMemtunePtr;

struct _virDomainMemtune {
    unsigned long long max_balloon; /* in kibibytes */
    unsigned long long cur_balloon; /* in kibibytes */

    virDomainHugePagePtr hugepages;
    size_t nhugepages;

    bool nosharepages;
    bool locked;
    int dump_core; /* enum virTristateSwitch */
    unsigned long long hard_limit; /* in kibibytes */
    unsigned long long soft_limit; /* in kibibytes */
    unsigned long long min_guarantee; /* in kibibytes */
    unsigned long long swap_hard_limit; /* in kibibytes */
};

typedef struct _virDomainPowerManagement virDomainPowerManagement;
typedef virDomainPowerManagement *virDomainPowerManagementPtr;

struct _virDomainPowerManagement {
    /* These options are of type enum virTristateBool */
    int s3;
    int s4;
};

1956 1957 1958 1959 1960 1961
/*
 * Guest VM main configuration
 *
 * NB: if adding to this struct, virDomainDefCheckABIStability
 * may well need an update
 */
1962 1963
typedef struct _virDomainDef virDomainDef;
typedef virDomainDef *virDomainDefPtr;
1964 1965 1966 1967 1968
struct _virDomainDef {
    int virtType;
    int id;
    unsigned char uuid[VIR_UUID_BUFLEN];
    char *name;
1969
    char *title;
1970
    char *description;
1971

1972 1973
    virDomainBlkiotune blkio;
    virDomainMemtune mem;
1974

E
Eric Blake 已提交
1975 1976
    unsigned short vcpus;
    unsigned short maxvcpus;
O
Osier Yang 已提交
1977
    int placement_mode;
H
Hu Tao 已提交
1978
    virBitmapPtr cpumask;
1979

1980 1981
    unsigned int iothreads;

1982
    virDomainCputune cputune;
1983

1984
    virDomainNumatunePtr numatune;
1985
    virDomainResourceDefPtr resource;
1986
    virDomainIdMapDef idmap;
1987

1988 1989 1990 1991 1992
    /* These 3 are based on virDomainLifeCycleAction enum flags */
    int onReboot;
    int onPoweroff;
    int onCrash;

1993 1994
    int onLockFailure; /* enum virDomainLockFailureAction */

1995
    virDomainPowerManagement pm;
1996

1997 1998
    virDomainOSDef os;
    char *emulator;
1999 2000 2001
    /* These three options are of type virTristateSwitch,
     * except VIR_DOMAIN_FEATURE_CAPABILITIES that is of type
     * virDomainCapabilitiesPolicy */
2002
    int features[VIR_DOMAIN_FEATURE_LAST];
2003
    int apic_eoi;
2004
    int hyperv_features[VIR_DOMAIN_HYPERV_LAST];
2005
    int kvm_features[VIR_DOMAIN_KVM_LAST];
2006
    unsigned int hyperv_spinlocks;
2007

J
Ján Tomko 已提交
2008
    /* These options are of type virTristateSwitch: ON = keep, OFF = drop */
2009 2010
    int caps_features[VIR_DOMAIN_CAPS_FEATURE_LAST];

2011
    virDomainClockDef clock;
2012

2013
    size_t ngraphics;
2014
    virDomainGraphicsDefPtr *graphics;
2015

2016
    size_t ndisks;
2017 2018
    virDomainDiskDefPtr *disks;

2019
    size_t ncontrollers;
2020 2021
    virDomainControllerDefPtr *controllers;

2022
    size_t nfss;
2023 2024
    virDomainFSDefPtr *fss;

2025
    size_t nnets;
2026 2027
    virDomainNetDefPtr *nets;

2028
    size_t ninputs;
2029 2030
    virDomainInputDefPtr *inputs;

2031
    size_t nsounds;
2032 2033
    virDomainSoundDefPtr *sounds;

2034
    size_t nvideos;
2035 2036
    virDomainVideoDefPtr *videos;

2037
    size_t nhostdevs;
2038 2039
    virDomainHostdevDefPtr *hostdevs;

2040
    size_t nredirdevs;
2041 2042
    virDomainRedirdevDefPtr *redirdevs;

2043
    size_t nsmartcards;
E
Eric Blake 已提交
2044 2045
    virDomainSmartcardDefPtr *smartcards;

2046
    size_t nserials;
2047 2048
    virDomainChrDefPtr *serials;

2049
    size_t nparallels;
2050 2051
    virDomainChrDefPtr *parallels;

2052
    size_t nchannels;
2053 2054
    virDomainChrDefPtr *channels;

2055
    size_t nconsoles;
2056 2057
    virDomainChrDefPtr *consoles;

2058
    size_t nleases;
2059 2060
    virDomainLeaseDefPtr *leases;

2061
    size_t nhubs;
M
Marc-André Lureau 已提交
2062 2063
    virDomainHubDefPtr *hubs;

2064 2065 2066
    size_t nseclabels;
    virSecurityLabelDefPtr *seclabels;

2067 2068 2069
    size_t nrngs;
    virDomainRNGDefPtr *rngs;

2070
    /* Only 1 */
R
Richard Jones 已提交
2071
    virDomainWatchdogDefPtr watchdog;
2072
    virDomainMemballoonDefPtr memballoon;
L
Li Zhang 已提交
2073
    virDomainNVRAMDefPtr nvram;
2074
    virDomainTPMDefPtr tpm;
2075
    virCPUDefPtr cpu;
2076
    virSysinfoDefPtr sysinfo;
2077
    virDomainRedirFilterDefPtr redirfilter;
H
Hu Tao 已提交
2078
    virDomainPanicDefPtr panic;
2079 2080 2081

    void *namespaceData;
    virDomainXMLNamespace ns;
2082 2083 2084

    /* Application-specific custom metadata */
    xmlNodePtr metadata;
2085 2086
};

2087
typedef enum {
2088 2089 2090 2091 2092
    VIR_DOMAIN_TAINT_CUSTOM_ARGV,      /* Custom ARGV passthrough from XML */
    VIR_DOMAIN_TAINT_CUSTOM_MONITOR,   /* Custom monitor commands issued */
    VIR_DOMAIN_TAINT_HIGH_PRIVILEGES,  /* Running with undesirably high privileges */
    VIR_DOMAIN_TAINT_SHELL_SCRIPTS,    /* Network configuration using opaque shell scripts */
    VIR_DOMAIN_TAINT_DISK_PROBING,     /* Relying on potentially unsafe disk format probing */
2093
    VIR_DOMAIN_TAINT_EXTERNAL_LAUNCH,  /* Externally launched guest domain */
2094
    VIR_DOMAIN_TAINT_HOST_CPU,         /* Host CPU passthrough in use */
2095
    VIR_DOMAIN_TAINT_HOOK,             /* Domain (possibly) changed via hook script */
2096 2097

    VIR_DOMAIN_TAINT_LAST
2098
} virDomainTaintFlags;
2099

2100
/* Guest VM runtime state */
J
Jiri Denemark 已提交
2101 2102 2103 2104 2105 2106
typedef struct _virDomainStateReason virDomainStateReason;
struct _virDomainStateReason {
    int state;
    int reason;
};

2107 2108 2109
typedef struct _virDomainObj virDomainObj;
typedef virDomainObj *virDomainObjPtr;
struct _virDomainObj {
2110
    virObjectLockable parent;
2111

2112
    pid_t pid;
J
Jiri Denemark 已提交
2113
    virDomainStateReason state;
2114 2115 2116

    unsigned int autostart : 1;
    unsigned int persistent : 1;
2117
    unsigned int updated : 1;
2118 2119 2120

    virDomainDefPtr def; /* The current definition */
    virDomainDefPtr newDef; /* New definition to activate at shutdown */
2121

2122
    virDomainSnapshotObjListPtr snapshots;
C
Chris Lalancette 已提交
2123 2124
    virDomainSnapshotObjPtr current_snapshot;

2125 2126
    bool hasManagedSave;

2127 2128
    void *privateData;
    void (*privateDataFreeFunc)(void *);
2129 2130

    int taint;
2131 2132
};

2133 2134
typedef struct _virDomainObjList virDomainObjList;
typedef virDomainObjList *virDomainObjListPtr;
2135

2136 2137 2138
typedef bool (*virDomainObjListFilter)(virConnectPtr conn,
                                       virDomainDefPtr def);

2139 2140 2141

/* This structure holds various callbacks and data needed
 * while parsing and creating domain XMLs */
2142 2143
typedef struct _virDomainXMLOption virDomainXMLOption;
typedef virDomainXMLOption *virDomainXMLOptionPtr;
2144 2145 2146 2147 2148 2149

typedef void *(*virDomainXMLPrivateDataAllocFunc)(void);
typedef void (*virDomainXMLPrivateDataFreeFunc)(void *);
typedef int (*virDomainXMLPrivateDataFormatFunc)(virBufferPtr, void *);
typedef int (*virDomainXMLPrivateDataParseFunc)(xmlXPathContextPtr, void *);

2150 2151
/* Called once after everything else has been parsed, for adjusting
 * overall domain defaults.  */
2152 2153 2154
typedef int (*virDomainDefPostParseCallback)(virDomainDefPtr def,
                                             virCapsPtr caps,
                                             void *opaque);
2155 2156
/* Called once per device, for adjusting per-device settings while
 * leaving the overall domain otherwise unchanged.  */
2157
typedef int (*virDomainDeviceDefPostParseCallback)(virDomainDeviceDefPtr dev,
2158
                                                   const virDomainDef *def,
2159 2160 2161 2162 2163 2164
                                                   virCapsPtr caps,
                                                   void *opaque);

typedef struct _virDomainDefParserConfig virDomainDefParserConfig;
typedef virDomainDefParserConfig *virDomainDefParserConfigPtr;
struct _virDomainDefParserConfig {
2165
    /* driver domain definition callbacks */
2166 2167 2168
    virDomainDefPostParseCallback domainPostParseCallback;
    virDomainDeviceDefPostParseCallback devicesPostParseCallback;

2169
    /* private data for the callbacks */
2170 2171
    void *priv;
    virFreeCallback privFree;
2172 2173

    /* data */
2174
    bool hasWideSCSIBus;
2175
    unsigned char macPrefix[VIR_MAC_PREFIX_BUFLEN];
2176 2177
};

2178 2179 2180 2181 2182 2183 2184 2185 2186
typedef struct _virDomainXMLPrivateDataCallbacks virDomainXMLPrivateDataCallbacks;
typedef virDomainXMLPrivateDataCallbacks *virDomainXMLPrivateDataCallbacksPtr;
struct _virDomainXMLPrivateDataCallbacks {
    virDomainXMLPrivateDataAllocFunc  alloc;
    virDomainXMLPrivateDataFreeFunc   free;
    virDomainXMLPrivateDataFormatFunc format;
    virDomainXMLPrivateDataParseFunc  parse;
};

2187 2188 2189
virDomainXMLOptionPtr virDomainXMLOptionNew(virDomainDefParserConfigPtr config,
                                            virDomainXMLPrivateDataCallbacksPtr priv,
                                            virDomainXMLNamespacePtr xmlns);
2190

2191 2192
void virDomainNetGenerateMAC(virDomainXMLOptionPtr xmlopt, virMacAddrPtr mac);

2193
virDomainXMLNamespacePtr
2194
virDomainXMLOptionGetNamespace(virDomainXMLOptionPtr xmlopt)
2195 2196
    ATTRIBUTE_NONNULL(1);

2197 2198 2199 2200 2201
int
virDomainDefPostParse(virDomainDefPtr def,
                      virCapsPtr caps,
                      virDomainXMLOptionPtr xmlopt);

2202
static inline bool
D
Daniel P. Berrange 已提交
2203
virDomainObjIsActive(virDomainObjPtr dom)
2204 2205 2206 2207
{
    return dom->def->id != -1;
}

2208
virDomainObjPtr virDomainObjNew(virDomainXMLOptionPtr caps)
2209
    ATTRIBUTE_NONNULL(1);
2210

2211
virDomainObjListPtr virDomainObjListNew(void);
2212

2213
virDomainObjPtr virDomainObjListFindByID(virDomainObjListPtr doms,
2214
                                         int id);
2215
virDomainObjPtr virDomainObjListFindByUUID(virDomainObjListPtr doms,
2216
                                           const unsigned char *uuid);
2217
virDomainObjPtr virDomainObjListFindByName(virDomainObjListPtr doms,
2218
                                           const char *name);
2219

2220
bool virDomainObjTaint(virDomainObjPtr obj,
2221
                       virDomainTaintFlags taint);
2222

H
Hu Tao 已提交
2223
void virDomainPanicDefFree(virDomainPanicDefPtr panic);
2224
void virDomainResourceDefFree(virDomainResourceDefPtr resource);
2225 2226
void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def);
void virDomainInputDefFree(virDomainInputDefPtr def);
2227
virDomainDiskDefPtr virDomainDiskDefNew(void);
2228
void virDomainDiskDefFree(virDomainDiskDefPtr def);
2229
void virDomainLeaseDefFree(virDomainLeaseDefPtr def);
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239
int virDomainDiskGetType(virDomainDiskDefPtr def);
void virDomainDiskSetType(virDomainDiskDefPtr def, int type);
const char *virDomainDiskGetSource(virDomainDiskDefPtr def);
int virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src)
    ATTRIBUTE_RETURN_CHECK;
const char *virDomainDiskGetDriver(virDomainDiskDefPtr def);
int virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name)
    ATTRIBUTE_RETURN_CHECK;
int virDomainDiskGetFormat(virDomainDiskDefPtr def);
void virDomainDiskSetFormat(virDomainDiskDefPtr def, int format);
H
Han Cheng 已提交
2240 2241 2242
int virDomainDeviceFindControllerModel(virDomainDefPtr def,
                                       virDomainDeviceInfoPtr info,
                                       int controllerType);
2243 2244 2245
virDomainDiskDefPtr virDomainDiskFindByBusAndDst(virDomainDefPtr def,
                                                 int bus,
                                                 char *dst);
2246
void virDomainControllerDefFree(virDomainControllerDefPtr def);
2247
void virDomainFSDefFree(virDomainFSDefPtr def);
2248
void virDomainActualNetDefFree(virDomainActualNetDefPtr def);
2249
void virDomainNetDefFree(virDomainNetDefPtr def);
E
Eric Blake 已提交
2250
void virDomainSmartcardDefFree(virDomainSmartcardDefPtr def);
2251
void virDomainChrDefFree(virDomainChrDefPtr def);
2252
void virDomainChrSourceDefFree(virDomainChrSourceDefPtr def);
2253 2254
int virDomainChrSourceDefCopy(virDomainChrSourceDefPtr src,
                              virDomainChrSourceDefPtr dest);
2255
void virDomainSoundCodecDefFree(virDomainSoundCodecDefPtr def);
2256
void virDomainSoundDefFree(virDomainSoundDefPtr def);
2257
void virDomainMemballoonDefFree(virDomainMemballoonDefPtr def);
L
Li Zhang 已提交
2258
void virDomainNVRAMDefFree(virDomainNVRAMDefPtr def);
R
Richard Jones 已提交
2259
void virDomainWatchdogDefFree(virDomainWatchdogDefPtr def);
2260
void virDomainVideoDefFree(virDomainVideoDefPtr def);
2261 2262
virDomainHostdevDefPtr virDomainHostdevDefAlloc(void);
void virDomainHostdevDefClear(virDomainHostdevDefPtr def);
2263
void virDomainHostdevDefFree(virDomainHostdevDefPtr def);
M
Marc-André Lureau 已提交
2264
void virDomainHubDefFree(virDomainHubDefPtr def);
2265
void virDomainRedirdevDefFree(virDomainRedirdevDefPtr def);
2266
void virDomainRedirFilterDefFree(virDomainRedirFilterDefPtr def);
2267
void virDomainDeviceDefFree(virDomainDeviceDefPtr def);
2268
virDomainDeviceDefPtr virDomainDeviceDefCopy(virDomainDeviceDefPtr src,
2269
                                             const virDomainDef *def,
2270 2271
                                             virCapsPtr caps,
                                             virDomainXMLOptionPtr xmlopt);
2272 2273
int virDomainDeviceAddressIsValid(virDomainDeviceInfoPtr info,
                                  int type);
2274
virDomainDeviceInfoPtr virDomainDeviceGetInfo(virDomainDeviceDefPtr device);
2275 2276
int virDomainDeviceInfoCopy(virDomainDeviceInfoPtr dst,
                            virDomainDeviceInfoPtr src);
2277
void virDomainDeviceInfoClear(virDomainDeviceInfoPtr info);
2278
void virDomainDefClearPCIAddresses(virDomainDefPtr def);
2279
void virDomainDefClearCCWAddresses(virDomainDefPtr def);
D
Daniel P. Berrange 已提交
2280
void virDomainDefClearDeviceAliases(virDomainDefPtr def);
2281
void virDomainTPMDefFree(virDomainTPMDefPtr def);
2282

2283
typedef int (*virDomainDeviceInfoCallback)(virDomainDefPtr def,
2284 2285
                                           virDomainDeviceDefPtr dev,
                                           virDomainDeviceInfoPtr info,
2286 2287 2288 2289 2290 2291
                                           void *opaque);

int virDomainDeviceInfoIterate(virDomainDefPtr def,
                               virDomainDeviceInfoCallback cb,
                               void *opaque);

2292 2293
void virDomainDefFree(virDomainDefPtr vm);

M
Michal Novotny 已提交
2294 2295
virDomainChrDefPtr virDomainChrDefNew(void);

2296 2297 2298 2299
virDomainDefPtr virDomainDefNew(const char *name,
                                const unsigned char *uuid,
                                int id);

2300 2301 2302 2303
enum {
    VIR_DOMAIN_OBJ_LIST_ADD_LIVE = (1 << 0),
    VIR_DOMAIN_OBJ_LIST_ADD_CHECK_LIVE = (1 << 1),
};
2304
virDomainObjPtr virDomainObjListAdd(virDomainObjListPtr doms,
2305
                                    virDomainDefPtr def,
2306
                                    virDomainXMLOptionPtr xmlopt,
2307 2308
                                    unsigned int flags,
                                    virDomainDefPtr *oldDef);
2309
void virDomainObjAssignDef(virDomainObjPtr domain,
2310
                           virDomainDefPtr def,
2311 2312
                           bool live,
                           virDomainDefPtr *oldDef);
2313
int virDomainObjSetDefTransient(virCapsPtr caps,
2314
                                virDomainXMLOptionPtr xmlopt,
2315 2316
                                virDomainObjPtr domain,
                                bool live);
2317 2318
virDomainDefPtr
virDomainObjGetPersistentDef(virCapsPtr caps,
2319
                             virDomainXMLOptionPtr xmlopt,
2320
                             virDomainObjPtr domain);
2321 2322 2323

int
virDomainLiveConfigHelperMethod(virCapsPtr caps,
2324
                                virDomainXMLOptionPtr xmlopt,
2325 2326 2327 2328
                                virDomainObjPtr dom,
                                unsigned int *flags,
                                virDomainDefPtr *persistentDef);

2329 2330 2331 2332 2333 2334 2335
virDomainDefPtr virDomainDefCopy(virDomainDefPtr src,
                                 virCapsPtr caps,
                                 virDomainXMLOptionPtr xmlopt,
                                 bool migratable);
virDomainDefPtr virDomainObjCopyPersistentDef(virDomainObjPtr dom,
                                              virCapsPtr caps,
                                              virDomainXMLOptionPtr xmlopt);
2336

2337 2338
void virDomainObjListRemove(virDomainObjListPtr doms,
                            virDomainObjPtr dom);
2339 2340
void virDomainObjListRemoveLocked(virDomainObjListPtr doms,
                                  virDomainObjPtr dom);
2341

2342
virDomainDeviceDefPtr virDomainDeviceDefParse(const char *xmlStr,
2343
                                              const virDomainDef *def,
2344 2345
                                              virCapsPtr caps,
                                              virDomainXMLOptionPtr xmlopt,
L
Laine Stump 已提交
2346
                                              unsigned int flags);
2347 2348 2349 2350
virStorageSourcePtr virDomainDiskDefSourceParse(const char *xmlStr,
                                                const virDomainDef *def,
                                                virDomainXMLOptionPtr xmlopt,
                                                unsigned int flags);
2351 2352
virDomainDefPtr virDomainDefParseString(const char *xmlStr,
                                        virCapsPtr caps,
2353
                                        virDomainXMLOptionPtr xmlopt,
M
Matthias Bolte 已提交
2354
                                        unsigned int expectedVirtTypes,
L
Laine Stump 已提交
2355
                                        unsigned int flags);
2356 2357
virDomainDefPtr virDomainDefParseFile(const char *filename,
                                      virCapsPtr caps,
2358
                                      virDomainXMLOptionPtr xmlopt,
M
Matthias Bolte 已提交
2359
                                      unsigned int expectedVirtTypes,
L
Laine Stump 已提交
2360
                                      unsigned int flags);
2361
virDomainDefPtr virDomainDefParseNode(xmlDocPtr doc,
2362
                                      xmlNodePtr root,
2363 2364
                                      virCapsPtr caps,
                                      virDomainXMLOptionPtr xmlopt,
M
Matthias Bolte 已提交
2365
                                      unsigned int expectedVirtTypes,
L
Laine Stump 已提交
2366
                                      unsigned int flags);
2367

2368 2369 2370
bool virDomainDefCheckABIStability(virDomainDefPtr src,
                                   virDomainDefPtr dst);

2371
int virDomainDefAddImplicitControllers(virDomainDefPtr def);
2372

2373
char *virDomainDefFormat(virDomainDefPtr def,
L
Laine Stump 已提交
2374
                         unsigned int flags);
2375 2376 2377
int virDomainDefFormatInternal(virDomainDefPtr def,
                               unsigned int flags,
                               virBufferPtr buf);
2378

2379 2380 2381 2382
int virDomainDiskSourceFormat(virBufferPtr buf,
                              virStorageSourcePtr src,
                              int policy,
                              unsigned int flags);
2383

2384 2385 2386 2387
int virDomainNetDefFormat(virBufferPtr buf,
                          virDomainNetDefPtr def,
                          unsigned int flags);

2388 2389 2390 2391 2392 2393
typedef enum {
    VIR_DOMAIN_DEVICE_ACTION_ATTACH,
    VIR_DOMAIN_DEVICE_ACTION_DETACH,
    VIR_DOMAIN_DEVICE_ACTION_UPDATE,
} virDomainDeviceAction;

2394
int virDomainDefCompatibleDevice(virDomainDefPtr def,
2395 2396
                                 virDomainDeviceDefPtr dev,
                                 virDomainDeviceAction action);
2397

2398
int virDomainVcpuPinAdd(virDomainVcpuPinDefPtr **vcpupin_list,
2399
                        size_t *nvcpupin,
2400 2401 2402 2403
                        unsigned char *cpumap,
                        int maplen,
                        int vcpu);

2404
void virDomainVcpuPinDel(virDomainDefPtr def, int vcpu);
2405

2406 2407 2408 2409 2410 2411
int virDomainEmulatorPinAdd(virDomainDefPtr def,
                              unsigned char *cpumap,
                              int maplen);

int virDomainEmulatorPinDel(virDomainDefPtr def);

2412 2413
void virDomainRNGDefFree(virDomainRNGDefPtr def);

2414 2415 2416
int virDomainDiskIndexByName(virDomainDefPtr def, const char *name,
                             bool allow_ambiguous);
const char *virDomainDiskPathByName(virDomainDefPtr, const char *name);
2417
int virDomainDiskInsert(virDomainDefPtr def,
2418 2419
                        virDomainDiskDefPtr disk)
    ATTRIBUTE_RETURN_CHECK;
2420 2421
void virDomainDiskInsertPreAlloced(virDomainDefPtr def,
                                   virDomainDiskDefPtr disk);
2422 2423
int virDomainDiskDefAssignAddress(virDomainXMLOptionPtr xmlopt,
                                  virDomainDiskDefPtr def);
2424

2425 2426 2427 2428
virDomainDiskDefPtr
virDomainDiskRemove(virDomainDefPtr def, size_t i);
virDomainDiskDefPtr
virDomainDiskRemoveByName(virDomainDefPtr def, const char *name);
2429 2430
int virDomainDiskSourceParse(xmlNodePtr node,
                             virStorageSourcePtr src);
2431

E
Eric Blake 已提交
2432
bool virDomainHasDiskMirror(virDomainObjPtr vm);
2433

2434 2435
int virDomainNetFindIdx(virDomainDefPtr def, virDomainNetDefPtr net);
virDomainNetDefPtr virDomainNetFind(virDomainDefPtr def, const char *device);
2436
int virDomainNetInsert(virDomainDefPtr def, virDomainNetDefPtr net);
2437
virDomainNetDefPtr virDomainNetRemove(virDomainDefPtr def, size_t i);
2438
void virDomainNetRemoveHostdev(virDomainDefPtr def, virDomainNetDefPtr net);
2439

L
Laine Stump 已提交
2440
int virDomainHostdevInsert(virDomainDefPtr def, virDomainHostdevDefPtr hostdev);
2441 2442
virDomainHostdevDefPtr
virDomainHostdevRemove(virDomainDefPtr def, size_t i);
L
Laine Stump 已提交
2443 2444 2445
int virDomainHostdevFind(virDomainDefPtr def, virDomainHostdevDefPtr match,
                         virDomainHostdevDefPtr *found);

2446
int virDomainGraphicsListenGetType(virDomainGraphicsDefPtr def, size_t i)
2447
            ATTRIBUTE_NONNULL(1);
2448
int virDomainGraphicsListenSetType(virDomainGraphicsDefPtr def, size_t i, int val)
2449 2450
            ATTRIBUTE_NONNULL(1);
const char *virDomainGraphicsListenGetAddress(virDomainGraphicsDefPtr def,
2451
                                              size_t i)
2452 2453
            ATTRIBUTE_NONNULL(1);
int virDomainGraphicsListenSetAddress(virDomainGraphicsDefPtr def,
2454
                                      size_t i, const char *address,
2455 2456 2457
                                      int len, bool setType)
            ATTRIBUTE_NONNULL(1);
const char *virDomainGraphicsListenGetNetwork(virDomainGraphicsDefPtr def,
2458
                                              size_t i)
2459 2460
            ATTRIBUTE_NONNULL(1);
int virDomainGraphicsListenSetNetwork(virDomainGraphicsDefPtr def,
2461
                                      size_t i, const char *network, int len)
2462 2463
            ATTRIBUTE_NONNULL(1);

2464
int virDomainNetGetActualType(virDomainNetDefPtr iface);
2465 2466
const char *virDomainNetGetActualBridgeName(virDomainNetDefPtr iface);
const char *virDomainNetGetActualDirectDev(virDomainNetDefPtr iface);
2467
int virDomainNetGetActualDirectMode(virDomainNetDefPtr iface);
2468
virDomainHostdevDefPtr virDomainNetGetActualHostdev(virDomainNetDefPtr iface);
2469
virNetDevVPortProfilePtr
2470
virDomainNetGetActualVirtPortProfile(virDomainNetDefPtr iface);
2471
virNetDevBandwidthPtr
2472
virDomainNetGetActualBandwidth(virDomainNetDefPtr iface);
2473
virNetDevVlanPtr virDomainNetGetActualVlan(virDomainNetDefPtr iface);
2474

2475
int virDomainControllerInsert(virDomainDefPtr def,
2476 2477
                              virDomainControllerDefPtr controller)
    ATTRIBUTE_RETURN_CHECK;
2478 2479
void virDomainControllerInsertPreAlloced(virDomainDefPtr def,
                                         virDomainControllerDefPtr controller);
2480 2481
int virDomainControllerFind(virDomainDefPtr def, int type, int idx);
virDomainControllerDefPtr virDomainControllerRemove(virDomainDefPtr def, size_t i);
2482 2483 2484 2485 2486

int virDomainLeaseIndex(virDomainDefPtr def,
                        virDomainLeaseDefPtr lease);
int virDomainLeaseInsert(virDomainDefPtr def,
                         virDomainLeaseDefPtr lease);
2487 2488
int virDomainLeaseInsertPreAlloc(virDomainDefPtr def)
    ATTRIBUTE_RETURN_CHECK;
2489 2490
void virDomainLeaseInsertPreAlloced(virDomainDefPtr def,
                                    virDomainLeaseDefPtr lease);
2491 2492 2493 2494 2495
virDomainLeaseDefPtr
virDomainLeaseRemoveAt(virDomainDefPtr def, size_t i);
virDomainLeaseDefPtr
virDomainLeaseRemove(virDomainDefPtr def,
                     virDomainLeaseDefPtr lease);
2496

2497
void
2498
virDomainChrGetDomainPtrs(const virDomainDef *vmdef,
2499
                          virDomainChrDeviceType type,
2500 2501 2502
                          const virDomainChrDef ***arrPtr,
                          size_t *cntPtr)
    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
2503 2504 2505
virDomainChrDefPtr
virDomainChrFind(virDomainDefPtr def,
                 virDomainChrDefPtr target);
2506 2507 2508
bool
virDomainChrEquals(virDomainChrDefPtr src,
                   virDomainChrDefPtr tgt);
2509 2510 2511 2512 2513 2514 2515
int
virDomainChrInsert(virDomainDefPtr vmdef,
                   virDomainChrDefPtr chr);
virDomainChrDefPtr
virDomainChrRemove(virDomainDefPtr vmdef,
                   virDomainChrDefPtr chr);

2516
int virDomainSaveXML(const char *configDir,
2517 2518 2519
                     virDomainDefPtr def,
                     const char *xml);

2520
int virDomainSaveConfig(const char *configDir,
2521
                        virDomainDefPtr def);
2522
int virDomainSaveStatus(virDomainXMLOptionPtr xmlopt,
2523
                        const char *statusDir,
2524
                        virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
2525

2526 2527 2528 2529
typedef void (*virDomainLoadConfigNotify)(virDomainObjPtr dom,
                                          int newDomain,
                                          void *opaque);

2530 2531 2532 2533
int virDomainObjListLoadAllConfigs(virDomainObjListPtr doms,
                                   const char *configDir,
                                   const char *autostartDir,
                                   int liveStatus,
2534 2535
                                   virCapsPtr caps,
                                   virDomainXMLOptionPtr xmlopt,
2536 2537 2538
                                   unsigned int expectedVirtTypes,
                                   virDomainLoadConfigNotify notify,
                                   void *opaque);
2539

2540
int virDomainDeleteConfig(const char *configDir,
2541
                          const char *autostartDir,
2542 2543
                          virDomainObjPtr dom);

2544
char *virDomainConfigFile(const char *dir,
2545 2546
                          const char *name);

2547 2548 2549 2550
int virDiskNameToBusDeviceIndex(virDomainDiskDefPtr disk,
                                int *busIdx,
                                int *devIdx);

2551
virDomainFSDefPtr virDomainGetFilesystemForTarget(virDomainDefPtr def,
2552
                                                  const char *target);
2553
int virDomainFSInsert(virDomainDefPtr def, virDomainFSDefPtr fs);
2554
int virDomainFSIndexByName(virDomainDefPtr def, const char *name);
2555 2556
virDomainFSDefPtr virDomainFSRemove(virDomainDefPtr def, size_t i);

2557 2558
int virDomainVideoDefaultType(const virDomainDef *def);
int virDomainVideoDefaultRAM(const virDomainDef *def, int type);
2559

2560 2561 2562 2563
int virDomainObjListNumOfDomains(virDomainObjListPtr doms,
                                 bool active,
                                 virDomainObjListFilter filter,
                                 virConnectPtr conn);
2564 2565 2566

int virDomainObjListGetActiveIDs(virDomainObjListPtr doms,
                                 int *ids,
2567 2568 2569
                                 int maxids,
                                 virDomainObjListFilter filter,
                                 virConnectPtr conn);
2570 2571
int virDomainObjListGetInactiveNames(virDomainObjListPtr doms,
                                     char **const names,
2572 2573 2574
                                     int maxnames,
                                     virDomainObjListFilter filter,
                                     virConnectPtr conn);
2575

2576 2577 2578 2579 2580 2581 2582
typedef int (*virDomainObjListIterator)(virDomainObjPtr dom,
                                        void *opaque);

int virDomainObjListForEach(virDomainObjListPtr doms,
                            virDomainObjListIterator callback,
                            void *opaque);

E
Eric Blake 已提交
2583 2584 2585 2586 2587 2588 2589 2590 2591
typedef int (*virDomainSmartcardDefIterator)(virDomainDefPtr def,
                                             virDomainSmartcardDefPtr dev,
                                             void *opaque);

int virDomainSmartcardDefForeach(virDomainDefPtr def,
                                 bool abortOnError,
                                 virDomainSmartcardDefIterator iter,
                                 void *opaque);

2592 2593 2594 2595 2596 2597 2598 2599 2600
typedef int (*virDomainChrDefIterator)(virDomainDefPtr def,
                                       virDomainChrDefPtr dev,
                                       void *opaque);

int virDomainChrDefForeach(virDomainDefPtr def,
                           bool abortOnError,
                           virDomainChrDefIterator iter,
                           void *opaque);

2601 2602 2603 2604 2605 2606 2607 2608 2609 2610
typedef int (*virDomainDiskDefPathIterator)(virDomainDiskDefPtr disk,
                                            const char *path,
                                            size_t depth,
                                            void *opaque);

int virDomainDiskDefForeachPath(virDomainDiskDefPtr disk,
                                bool ignoreOpenFailure,
                                virDomainDiskDefPathIterator iter,
                                void *opaque);

J
Jiri Denemark 已提交
2611 2612 2613 2614 2615 2616 2617
void
virDomainObjSetState(virDomainObjPtr obj, virDomainState state, int reason)
        ATTRIBUTE_NONNULL(1);
virDomainState
virDomainObjGetState(virDomainObjPtr obj, int *reason)
        ATTRIBUTE_NONNULL(1);

2618 2619 2620
virSecurityLabelDefPtr
virDomainDefGetSecurityLabelDef(virDomainDefPtr def, const char *model);

2621 2622 2623
virSecurityDeviceLabelDefPtr
virDomainChrDefGetSecurityLabelDef(virDomainChrDefPtr def, const char *model);

2624 2625
typedef const char* (*virEventActionToStringFunc)(int type);
typedef int (*virEventActionFromStringFunc)(const char *type);
2626

2627
VIR_ENUM_DECL(virDomainTaint)
2628 2629 2630
VIR_ENUM_DECL(virDomainVirt)
VIR_ENUM_DECL(virDomainBoot)
VIR_ENUM_DECL(virDomainFeature)
2631 2632
VIR_ENUM_DECL(virDomainCapabilitiesPolicy)
VIR_ENUM_DECL(virDomainCapsFeature)
2633
VIR_ENUM_DECL(virDomainLifecycle)
2634
VIR_ENUM_DECL(virDomainLifecycleCrash)
2635
VIR_ENUM_DECL(virDomainDevice)
2636
VIR_ENUM_DECL(virDomainDeviceAddress)
2637
VIR_ENUM_DECL(virDomainDiskDevice)
J
J.B. Joret 已提交
2638
VIR_ENUM_DECL(virDomainDiskGeometryTrans)
2639
VIR_ENUM_DECL(virDomainDiskBus)
2640
VIR_ENUM_DECL(virDomainDiskCache)
2641
VIR_ENUM_DECL(virDomainDiskErrorPolicy)
M
Matthias Dahl 已提交
2642
VIR_ENUM_DECL(virDomainDiskIo)
2643
VIR_ENUM_DECL(virDomainDeviceSGIO)
2644
VIR_ENUM_DECL(virDomainDiskTray)
O
Osier Yang 已提交
2645
VIR_ENUM_DECL(virDomainDiskDiscard)
2646
VIR_ENUM_DECL(virDomainDiskMirrorState)
2647
VIR_ENUM_DECL(virDomainController)
J
Ján Tomko 已提交
2648
VIR_ENUM_DECL(virDomainControllerModelPCI)
2649
VIR_ENUM_DECL(virDomainControllerModelSCSI)
M
Marc-André Lureau 已提交
2650
VIR_ENUM_DECL(virDomainControllerModelUSB)
2651
VIR_ENUM_DECL(virDomainFS)
2652
VIR_ENUM_DECL(virDomainFSDriver)
2653
VIR_ENUM_DECL(virDomainFSAccessMode)
2654
VIR_ENUM_DECL(virDomainFSWrpolicy)
2655
VIR_ENUM_DECL(virDomainNet)
2656
VIR_ENUM_DECL(virDomainNetBackend)
2657
VIR_ENUM_DECL(virDomainNetVirtioTxMode)
2658
VIR_ENUM_DECL(virDomainNetInterfaceLinkState)
2659
VIR_ENUM_DECL(virDomainChrDevice)
2660
VIR_ENUM_DECL(virDomainChrChannelTarget)
2661
VIR_ENUM_DECL(virDomainChrConsoleTarget)
G
Guannan Ren 已提交
2662
VIR_ENUM_DECL(virDomainChrSerialTarget)
E
Eric Blake 已提交
2663
VIR_ENUM_DECL(virDomainSmartcard)
2664
VIR_ENUM_DECL(virDomainChr)
2665
VIR_ENUM_DECL(virDomainChrTcpProtocol)
E
Eric Blake 已提交
2666
VIR_ENUM_DECL(virDomainChrSpicevmc)
2667
VIR_ENUM_DECL(virDomainSoundCodec)
2668
VIR_ENUM_DECL(virDomainSoundModel)
2669
VIR_ENUM_DECL(virDomainMemballoonModel)
2670
VIR_ENUM_DECL(virDomainSmbiosMode)
R
Richard Jones 已提交
2671 2672
VIR_ENUM_DECL(virDomainWatchdogModel)
VIR_ENUM_DECL(virDomainWatchdogAction)
2673
VIR_ENUM_DECL(virDomainVideo)
2674 2675
VIR_ENUM_DECL(virDomainHostdevMode)
VIR_ENUM_DECL(virDomainHostdevSubsys)
2676
VIR_ENUM_DECL(virDomainHostdevCaps)
M
Marc-André Lureau 已提交
2677
VIR_ENUM_DECL(virDomainHub)
2678
VIR_ENUM_DECL(virDomainRedirdevBus)
2679 2680 2681
VIR_ENUM_DECL(virDomainInput)
VIR_ENUM_DECL(virDomainInputBus)
VIR_ENUM_DECL(virDomainGraphics)
2682
VIR_ENUM_DECL(virDomainGraphicsListen)
2683
VIR_ENUM_DECL(virDomainGraphicsAuthConnected)
2684 2685
VIR_ENUM_DECL(virDomainGraphicsSpiceChannelName)
VIR_ENUM_DECL(virDomainGraphicsSpiceChannelMode)
2686 2687 2688
VIR_ENUM_DECL(virDomainGraphicsSpiceImageCompression)
VIR_ENUM_DECL(virDomainGraphicsSpiceJpegCompression)
VIR_ENUM_DECL(virDomainGraphicsSpiceZlibCompression)
2689
VIR_ENUM_DECL(virDomainGraphicsSpiceStreamingMode)
P
Peng Zhou 已提交
2690
VIR_ENUM_DECL(virDomainGraphicsSpiceMouseMode)
2691
VIR_ENUM_DECL(virDomainGraphicsVNCSharePolicy)
2692
VIR_ENUM_DECL(virDomainHyperv)
2693
VIR_ENUM_DECL(virDomainKVM)
2694 2695
VIR_ENUM_DECL(virDomainRNGModel)
VIR_ENUM_DECL(virDomainRNGBackend)
2696 2697
VIR_ENUM_DECL(virDomainTPMModel)
VIR_ENUM_DECL(virDomainTPMBackend)
2698 2699
/* from libvirt.h */
VIR_ENUM_DECL(virDomainState)
J
Jiri Denemark 已提交
2700 2701 2702 2703 2704 2705 2706
VIR_ENUM_DECL(virDomainNostateReason)
VIR_ENUM_DECL(virDomainRunningReason)
VIR_ENUM_DECL(virDomainBlockedReason)
VIR_ENUM_DECL(virDomainPausedReason)
VIR_ENUM_DECL(virDomainShutdownReason)
VIR_ENUM_DECL(virDomainShutoffReason)
VIR_ENUM_DECL(virDomainCrashedReason)
2707
VIR_ENUM_DECL(virDomainPMSuspendedReason)
J
Jiri Denemark 已提交
2708 2709 2710 2711

const char *virDomainStateReasonToString(virDomainState state, int reason);
int virDomainStateReasonFromString(virDomainState state, const char *reason);

2712
VIR_ENUM_DECL(virDomainSeclabel)
2713
VIR_ENUM_DECL(virDomainClockOffset)
2714
VIR_ENUM_DECL(virDomainClockBasis)
2715

2716
VIR_ENUM_DECL(virDomainTimerName)
2717
VIR_ENUM_DECL(virDomainTimerTrack)
2718 2719
VIR_ENUM_DECL(virDomainTimerTickpolicy)
VIR_ENUM_DECL(virDomainTimerMode)
O
Osier Yang 已提交
2720
VIR_ENUM_DECL(virDomainCpuPlacementMode)
2721

2722
VIR_ENUM_DECL(virDomainStartupPolicy)
2723

O
Osier Yang 已提交
2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757
# define VIR_CONNECT_LIST_DOMAINS_FILTERS_ACTIVE   \
                (VIR_CONNECT_LIST_DOMAINS_ACTIVE | \
                 VIR_CONNECT_LIST_DOMAINS_INACTIVE)

# define VIR_CONNECT_LIST_DOMAINS_FILTERS_PERSISTENT   \
                (VIR_CONNECT_LIST_DOMAINS_PERSISTENT | \
                 VIR_CONNECT_LIST_DOMAINS_TRANSIENT)

# define VIR_CONNECT_LIST_DOMAINS_FILTERS_STATE     \
                (VIR_CONNECT_LIST_DOMAINS_RUNNING | \
                 VIR_CONNECT_LIST_DOMAINS_PAUSED  | \
                 VIR_CONNECT_LIST_DOMAINS_SHUTOFF | \
                 VIR_CONNECT_LIST_DOMAINS_OTHER)

# define VIR_CONNECT_LIST_DOMAINS_FILTERS_MANAGEDSAVE   \
                (VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE | \
                 VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE)

# define VIR_CONNECT_LIST_DOMAINS_FILTERS_AUTOSTART   \
                (VIR_CONNECT_LIST_DOMAINS_AUTOSTART | \
                 VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART)

# define VIR_CONNECT_LIST_DOMAINS_FILTERS_SNAPSHOT       \
                (VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT | \
                 VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT)

# define VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL                   \
                (VIR_CONNECT_LIST_DOMAINS_FILTERS_ACTIVE      | \
                 VIR_CONNECT_LIST_DOMAINS_FILTERS_PERSISTENT  | \
                 VIR_CONNECT_LIST_DOMAINS_FILTERS_STATE       | \
                 VIR_CONNECT_LIST_DOMAINS_FILTERS_MANAGEDSAVE | \
                 VIR_CONNECT_LIST_DOMAINS_FILTERS_AUTOSTART   | \
                 VIR_CONNECT_LIST_DOMAINS_FILTERS_SNAPSHOT)

2758 2759 2760
int virDomainObjListExport(virDomainObjListPtr doms,
                           virConnectPtr conn,
                           virDomainPtr **domains,
2761
                           virDomainObjListFilter filter,
2762
                           unsigned int flags);
O
Osier Yang 已提交
2763

2764 2765
void virDomainListFree(virDomainPtr *list);

2766 2767 2768 2769 2770
int
virDomainDefMaybeAddController(virDomainDefPtr def,
                               int type,
                               int idx,
                               int model);
2771 2772 2773 2774
int
virDomainDefMaybeAddInput(virDomainDefPtr def,
                          int type,
                          int bus);
2775

2776 2777
char *virDomainDefGetDefaultEmulator(virDomainDefPtr def, virCapsPtr caps);

2778 2779
int virDomainDefFindDevice(virDomainDefPtr def,
                           const char *devAlias,
2780 2781
                           virDomainDeviceDefPtr dev,
                           bool reportError);
2782

2783
bool virDomainDiskSourceIsBlockType(virStorageSourcePtr src)
2784 2785
    ATTRIBUTE_NONNULL(1);

2786 2787
void virDomainChrSourceDefClear(virDomainChrSourceDefPtr def);

2788 2789 2790 2791 2792 2793 2794
char *virDomainObjGetMetadata(virDomainObjPtr vm,
                              int type,
                              const char *uri,
                              virCapsPtr caps,
                              virDomainXMLOptionPtr xmlopt,
                              unsigned int flags);

2795 2796 2797 2798 2799 2800 2801
int virDomainObjSetMetadata(virDomainObjPtr vm,
                            int type,
                            const char *metadata,
                            const char *key,
                            const char *uri,
                            virCapsPtr caps,
                            virDomainXMLOptionPtr xmlopt,
2802
                            const char *stateDir,
2803 2804 2805
                            const char *configDir,
                            unsigned int flags);

2806 2807 2808
bool virDomainDefNeedsPlacementAdvice(virDomainDefPtr def)
    ATTRIBUTE_NONNULL(1);

2809
#endif /* __DOMAIN_CONF_H */